From 49ef2eef6563823d3230497d7e4426664e0dd16e Mon Sep 17 00:00:00 2001 From: David Wrighton Date: Fri, 14 Aug 2026 15:44:18 -0700 Subject: [PATCH 01/23] Initial infrastructure for new eh handling in qcalls --- src/coreclr/vm/excep.cpp | 34 ++++++++++++++++ src/coreclr/vm/exceptmacros.h | 74 +++++++++++++++++++++++++++++++++++ src/coreclr/vm/qcall.cpp | 7 ++++ 3 files changed, 115 insertions(+) diff --git a/src/coreclr/vm/excep.cpp b/src/coreclr/vm/excep.cpp index f252a2c2c16104..8c14d7ac5ce9ef 100644 --- a/src/coreclr/vm/excep.cpp +++ b/src/coreclr/vm/excep.cpp @@ -6650,6 +6650,40 @@ void UnwindAndContinueRethrowHelperInsideCatch(Frame* pEntryFrame, Exception* pE #endif } +// +// This does the work of the Unwind and Continue Hanlder inside the catch clause of that handler. The stack has not +// been unwound when this is called. Keep that in mind when deciding where to put new code :) +// +void UnwindAndContinueRethrowHelperInsideQcallCatch(Frame* pEntryFrame, Exception* pException, QCallException qCallException) +{ + STATIC_CONTRACT_NOTHROW; + STATIC_CONTRACT_GC_TRIGGERS; + STATIC_CONTRACT_MODE_ANY; + + Thread* pThread = GetThread(); + + GCX_COOP(); + + LOG((LF_EH, LL_INFO1000, "UNWIND_AND_CONTINUE inside catch, unwinding frame chain\n")); + + // This SetFrame is OK because we will not have frames that require ExceptionUnwind in strictly unmanaged EE + // code chunks which is all that an UnC handler can guard. + // + // @todo: we'd rather use UnwindFrameChain, but there is a concern: some of the ExceptionUnwind methods on some + // of the Frame types do a great deal of work; load classes, throw exceptions, etc. We need to decide on some + // policy here. Do we want to let such functions throw, etc.? Right now, we believe that there are no such + // frames on the stack to be unwound, so the SetFrame is alright (see the first comment above.) At the very + // least, we should add some way to assert that. + pThread->SetFrame(pEntryFrame); + + // Call CLRException::GetThrowableFromException to force us to retrieve the THROWABLE + // while we are still within the context of the catch block. This will help diagnose + // cases where the last thrown object is NULL. + OBJECTREF orThrowable = CLRException::GetThrowableFromException(pException); + CONSISTENCY_CHECK(orThrowable != NULL); + qCallException.SetThrowable(orThrowable); +} + // // This does the work of the Unwind and Continue Hanlder after the catch clause of that handler. The stack has been // unwound by the time this is called. Keep that in mind when deciding where to put new code :) diff --git a/src/coreclr/vm/exceptmacros.h b/src/coreclr/vm/exceptmacros.h index 7fea6c62f1ecc9..ac29209266ef4e 100644 --- a/src/coreclr/vm/exceptmacros.h +++ b/src/coreclr/vm/exceptmacros.h @@ -202,7 +202,20 @@ VOID DECLSPEC_NORETURN RaiseTheExceptionInternalOnly(OBJECTREF throwable); #define UNINSTALL_UNWIND_AND_CONTINUE_HANDLER_EX #else // DACCESS_COMPILE +struct QCallException +{ +private: + OBJECTREF* m_throwable; + + QCallException() : m_throwable(nullptr) {} + +public: + void SetThrowable(OBJECTREF throwable); +}; + void UnwindAndContinueRethrowHelperInsideCatch(Frame* pEntryFrame, Exception* pException); +void UnwindAndContinueRethrowHelperInsideQcallCatch(Frame* pEntryFrame, Exception* pException, QCallException qCallException); + VOID DECLSPEC_NORETURN UnwindAndContinueRethrowHelperAfterCatch(Frame* pEntryFrame, Exception* pException, bool nativeRethrow); #ifdef FEATURE_INTERPRETER @@ -318,6 +331,36 @@ VOID DECLSPEC_NORETURN DispatchManagedException(PAL_SEHException& ex, bool isHar UNREACHABLE(); \ } + +#define INSTALL_MANAGED_EXCEPTION_CAPTURE_DISPATCHER \ + { \ + MAKE_CURRENT_THREAD_AVAILABLE(); \ + Frame* __pUnCEntryFrame = CURRENT_THREAD->GetFrame(); \ + PAL_CPP_TRY { + +#define UNINSTALL_MANAGED_EXCEPTION_CAPTURE_DISPATCHER \ + } \ + PAL_CPP_CATCH_NON_DERIVED (PAL_SEHException&, ex) \ + { \ + GCX_COOP(); \ + OBJECTREF throwable = ExInfo::CreateThrowable(ex.GetExceptionRecord(), FALSE); \ + qcallError.SetThrowable(throwable); \ + } \ + PAL_CPP_CATCH_NON_DERIVED_NOARG (const std::bad_alloc&) \ + { \ + __pUnCException = Exception::GetOOMException(); \ + UnwindAndContinueRethrowHelperInsideQcallCatch(__pUnCEntryFrame, __pUnCException, qcallError); \ + } \ + PAL_CPP_CATCH_DERIVED (Exception, __pException) \ + { \ + CONSISTENCY_CHECK(NULL != __pException); \ + __pUnCException = __pException; \ + UnwindAndContinueRethrowHelperInsideQcallCatch(__pUnCEntryFrame, __pUnCException, qcallError); \ + } \ + PAL_CPP_ENDTRY \ + } + + #elif defined(TARGET_X86) && defined(TARGET_WINDOWS) #define INSTALL_MANAGED_EXCEPTION_DISPATCHER @@ -404,6 +447,37 @@ VOID DECLSPEC_NORETURN DispatchManagedException(PAL_SEHException& ex, bool isHar #define UNINSTALL_UNWIND_AND_CONTINUE_HANDLER \ UNINSTALL_UNWIND_AND_CONTINUE_HANDLER_EX(false); + +#if !defined(TARGET_UNIX) + // The Windows implementation of the INSTALL_MANAGED_EXCEPTION_CAPTURE_DISPATCHER is very similar + // to the unix one, but the major distinction is that the Windows version allows for an existing + // eh which has been converted into SEH, to flow directly into managed code. The unix version + // catches the PAL_SEHException and converts it into a managed exception before it hits managed code. + +#define INSTALL_MANAGED_EXCEPTION_CAPTURE_DISPATCHER \ + { \ + MAKE_CURRENT_THREAD_AVAILABLE(); \ + Frame* __pUnCEntryFrame = CURRENT_THREAD->GetFrame(); \ + PAL_CPP_TRY { \ + INSTALL_UNWIND_AND_CONTINUE_HANDLER + +#define UNINSTALL_MANAGED_EXCEPTION_CAPTURE_DISPATCHER \ + } \ + PAL_CPP_CATCH_NON_DERIVED_NOARG (const std::bad_alloc&) \ + { \ + __pUnCException = Exception::GetOOMException(); \ + UnwindAndContinueRethrowHelperInsideQcallCatch(__pUnCEntryFrame, __pUnCException, qcallError); \ + } \ + PAL_CPP_CATCH_DERIVED (Exception, __pException) \ + { \ + CONSISTENCY_CHECK(NULL != __pException); \ + __pUnCException = __pException; \ + UnwindAndContinueRethrowHelperInsideQcallCatch(__pUnCEntryFrame, __pUnCException, qcallError); \ + } \ + PAL_CPP_ENDTRY \ + } +#endif + #endif // DACCESS_COMPILE diff --git a/src/coreclr/vm/qcall.cpp b/src/coreclr/vm/qcall.cpp index 497cdff7adf000..3267608da3c0cc 100644 --- a/src/coreclr/vm/qcall.cpp +++ b/src/coreclr/vm/qcall.cpp @@ -7,6 +7,13 @@ #include "common.h" +void QCallException::SetThrowable(OBJECTREF throwable) +{ + LIMITED_METHOD_CONTRACT; + + SetObjectReference(m_throwable, throwable); +} + // // Helpers for returning managed string from QCall // From e8d8016f62ca33cea7bbd5e64bd081c71ef2872f Mon Sep 17 00:00:00 2001 From: David Wrighton Date: Mon, 17 Aug 2026 09:34:20 -0700 Subject: [PATCH 02/23] Route QCall exceptions through marshalling Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 97d405de-8e39-4e76-afe4-2f94b74ecfa2 --- .../System.Private.CoreLib.csproj | 1 + .../Runtime/CompilerHelpers/ThrowHelpers.cs | 20 +- .../VersionResilientHashCode.CoreCLR.cs | 4 +- .../src/System/AppContext.CoreCLR.cs | 2 +- .../src/System/ArgIterator.cs | 20 +- .../src/System/Array.CoreCLR.cs | 17 +- .../src/System/CLRConfig.cs | 4 +- .../System/ComAwareWeakReference.CoreCLR.cs | 8 +- .../src/System/Delegate.CoreCLR.cs | 37 +-- .../src/System/Diagnostics/Debugger.cs | 16 +- .../System/Diagnostics/StackFrame.CoreCLR.cs | 4 +- .../System/Diagnostics/StackTrace.CoreCLR.cs | 4 +- .../src/System/Enum.CoreCLR.cs | 5 +- .../src/System/Environment.CoreCLR.cs | 10 +- .../src/System/Exception.CoreCLR.cs | 12 +- .../src/System/GC.CoreCLR.cs | 82 +++--- .../System/IO/FileLoadException.CoreCLR.cs | 8 +- .../src/System/IO/Stream.CoreCLR.cs | 6 +- .../src/System/Object.CoreCLR.cs | 2 +- .../src/System/Reflection/Assembly.CoreCLR.cs | 8 +- .../System/Reflection/AssemblyName.CoreCLR.cs | 4 +- .../Reflection/Emit/DynamicILGenerator.cs | 2 +- .../Reflection/Emit/DynamicMethod.CoreCLR.cs | 2 +- .../Reflection/Emit/RuntimeAssemblyBuilder.cs | 6 +- .../Reflection/Emit/RuntimeEventBuilder.cs | 3 +- .../Reflection/Emit/RuntimeFieldBuilder.cs | 6 +- .../Reflection/Emit/RuntimeMethodBuilder.cs | 6 +- .../Reflection/Emit/RuntimeModuleBuilder.cs | 43 +-- .../Emit/RuntimeParameterBuilder.cs | 3 +- .../Reflection/Emit/RuntimePropertyBuilder.cs | 3 +- .../Reflection/Emit/RuntimeTypeBuilder.cs | 90 +++--- .../src/System/Reflection/LoaderAllocator.cs | 4 +- .../src/System/Reflection/MdImport.cs | 10 +- .../Reflection/Metadata/AssemblyExtensions.cs | 4 +- .../Reflection/Metadata/MetadataUpdater.cs | 8 +- .../System/Reflection/MethodBase.CoreCLR.cs | 4 +- .../src/System/Reflection/RuntimeAssembly.cs | 104 ++++--- .../Reflection/RuntimeCustomAttributeData.cs | 15 +- .../src/System/Reflection/RuntimeModule.cs | 12 +- .../Reflection/TypeNameResolver.CoreCLR.cs | 4 +- .../CompilerServices/AsyncHelpers.CoreCLR.cs | 4 +- .../Runtime/CompilerServices/CastHelpers.cs | 14 +- .../CompilerServices/GenericsHelpers.cs | 10 +- .../Runtime/CompilerServices/InitHelpers.cs | 4 +- .../CompilerServices/QCallException.cs | 46 +++ .../RuntimeHelpers.CoreCLR.cs | 46 +-- .../CompilerServices/StaticsHelpers.cs | 12 +- .../VirtualDispatchHelpers.cs | 4 +- .../Runtime/ControlledExecution.CoreCLR.cs | 6 +- .../src/System/Runtime/DependentHandle.cs | 8 +- .../ExceptionServices/InternalCalls.cs | 11 +- .../InteropServices/ComWrappers.CoreCLR.cs | 6 +- .../InteropServices/GCHandle.CoreCLR.cs | 12 +- .../Java/JavaMarshal.CoreCLR.cs | 13 +- .../InteropServices/Marshal.CoreCLR.cs | 118 ++++---- .../InteropServices/NativeLibrary.CoreCLR.cs | 6 +- .../ObjectiveCMarshal.CoreCLR.cs | 11 +- .../TrackerObjectManager.CoreCLR.cs | 6 +- .../Loader/AssemblyLoadContext.CoreCLR.cs | 42 +-- .../src/System/RuntimeHandles.cs | 271 ++++++++++-------- .../src/System/RuntimeType.BoxCache.cs | 6 +- .../src/System/RuntimeType.CoreCLR.cs | 20 +- ...meType.CreateUninitializedCache.CoreCLR.cs | 8 +- .../src/System/String.CoreCLR.cs | 8 +- .../src/System/StubHelpers.cs | 78 ++--- .../System/Threading/ObjectHeader.CoreCLR.cs | 4 +- .../src/System/Threading/Thread.CoreCLR.cs | 72 +++-- .../src/System/TypeLoadException.CoreCLR.cs | 4 +- .../src/System/ValueType.cs | 9 +- .../src/System/Variant.cs | 8 +- .../src/System/Runtime/ExceptionHandling.cs | 24 +- .../src/System/Runtime/StackFrameIterator.cs | 16 +- src/coreclr/runtime/MiscNativeHelpers.cpp | 12 +- src/coreclr/runtime/MiscNativeHelpers.h | 16 +- src/coreclr/vm/JitQCallHelpers.h | 14 +- src/coreclr/vm/appdomainnative.cpp | 10 +- src/coreclr/vm/appdomainnative.hpp | 10 +- src/coreclr/vm/arraynative.cpp | 6 +- src/coreclr/vm/arraynative.h | 6 +- src/coreclr/vm/assemblynative.cpp | 91 +++--- src/coreclr/vm/assemblynative.hpp | 82 +++--- src/coreclr/vm/clrconfignative.cpp | 2 +- src/coreclr/vm/clrconfignative.h | 2 +- src/coreclr/vm/comdelegate.cpp | 18 +- src/coreclr/vm/comdelegate.h | 18 +- src/coreclr/vm/comdependenthandle.cpp | 4 +- src/coreclr/vm/comdependenthandle.h | 4 +- src/coreclr/vm/comdynamic.cpp | 50 ++-- src/coreclr/vm/comdynamic.h | 48 ++-- src/coreclr/vm/commodule.cpp | 31 +- src/coreclr/vm/commodule.h | 31 +- src/coreclr/vm/comsynchronizable.cpp | 54 ++-- src/coreclr/vm/comsynchronizable.h | 36 +-- src/coreclr/vm/comutilnative.cpp | 76 ++--- src/coreclr/vm/comutilnative.h | 82 +++--- src/coreclr/vm/coreassemblyspec.cpp | 2 +- src/coreclr/vm/corelib.h | 1 + src/coreclr/vm/customattribute.cpp | 6 +- src/coreclr/vm/customattribute.h | 6 +- src/coreclr/vm/debugdebugger.cpp | 35 ++- src/coreclr/vm/debugdebugger.h | 16 +- src/coreclr/vm/eventpipeinternal.cpp | 28 +- src/coreclr/vm/eventpipeinternal.h | 34 ++- src/coreclr/vm/excep.cpp | 10 +- src/coreclr/vm/exceptionhandling.cpp | 10 +- src/coreclr/vm/exceptionhandlingqcalls.h | 10 +- src/coreclr/vm/exceptmacros.h | 15 +- src/coreclr/vm/finalizerthread.cpp | 4 +- src/coreclr/vm/ilmarshalers.cpp | 10 +- src/coreclr/vm/ilmarshalers.h | 10 +- src/coreclr/vm/interoplibinterface.h | 17 +- .../vm/interoplibinterface_comwrappers.cpp | 6 +- .../vm/interoplibinterface_comwrappers.h | 6 +- src/coreclr/vm/interoplibinterface_java.cpp | 9 +- src/coreclr/vm/interoplibinterface_objc.cpp | 8 +- src/coreclr/vm/jithelpers.cpp | 39 +-- src/coreclr/vm/loaderallocator.cpp | 2 +- src/coreclr/vm/loaderallocator.hpp | 2 +- src/coreclr/vm/managedmdimport.cpp | 6 +- src/coreclr/vm/managedmdimport.hpp | 6 +- src/coreclr/vm/marshalnative.cpp | 66 ++--- src/coreclr/vm/marshalnative.h | 66 ++--- src/coreclr/vm/method.hpp | 2 +- src/coreclr/vm/mlinfo.cpp | 2 +- src/coreclr/vm/multicorejit.cpp | 4 +- src/coreclr/vm/multicorejit.h | 4 +- src/coreclr/vm/nativeeventsource.cpp | 39 +-- src/coreclr/vm/nativeeventsource.h | 38 +-- src/coreclr/vm/nativelibrarynative.cpp | 3 +- src/coreclr/vm/nativelibrarynative.h | 3 +- src/coreclr/vm/object.h | 10 + src/coreclr/vm/olevariant.cpp | 2 +- src/coreclr/vm/olevariant.h | 2 +- src/coreclr/vm/qcall.cpp | 9 +- src/coreclr/vm/qcall.h | 20 +- src/coreclr/vm/qcallentrypoints.cpp | 1 + src/coreclr/vm/reflectioninvocation.cpp | 56 ++-- src/coreclr/vm/reflectioninvocation.h | 24 +- src/coreclr/vm/runtimehandles.cpp | 109 +++---- src/coreclr/vm/runtimehandles.h | 141 ++++----- src/coreclr/vm/stackwalk.h | 4 +- src/coreclr/vm/stubhelpers.cpp | 32 +-- src/coreclr/vm/stubhelpers.h | 34 +-- src/coreclr/vm/tailcallhelp.cpp | 2 +- src/coreclr/vm/tailcallhelp.h | 2 +- src/coreclr/vm/unsafeaccessors.cpp | 2 +- src/coreclr/vm/varargsnative.cpp | 10 +- src/coreclr/vm/varargsnative.h | 10 +- src/coreclr/vm/versionresilienthashcode.cpp | 2 +- src/coreclr/vm/versionresilienthashcode.h | 2 +- src/coreclr/vm/wasm/entrypoints.h | 4 +- src/coreclr/vm/weakreferencenative.cpp | 4 +- src/coreclr/vm/weakreferencenative.h | 4 +- .../src/System/AppContext.cs | 8 +- .../Diagnostics/Tracing/EventPipe.Internal.cs | 97 ++++++- .../System/Diagnostics/Tracing/EventPipe.cs | 8 +- .../EventPipeEventDispatcher.Threads.cs | 17 +- .../Tracing/EventPipeEventDispatcher.cs | 33 ++- .../Tracing/EventPipeEventProvider.cs | 48 +++- ...ntSource.Threading.NativeSinks.Internal.cs | 128 +++++++-- ...untimeEventSource.Threading.NativeSinks.cs | 128 +++++++-- .../Tracing/TraceLogging/XplatEventLogger.cs | 38 ++- .../src/System/Environment.cs | 4 + .../src/System/Reflection/Assembly.cs | 4 +- .../Runtime/InteropServices/ComWrappers.cs | 4 + .../Runtime/InteropServices/Marshal.NoCom.cs | 6 +- .../ObjectiveC/ObjectiveCMarshal.cs | 12 +- .../InteropServices/TypeMapLazyDictionary.cs | 48 +++- .../System/Runtime/Intrinsics/X86/X86Base.cs | 7 + .../Runtime/Loader/AssemblyLoadContext.cs | 48 +++- .../src/System/Threading/Interlocked.cs | 9 + .../src/System/Threading/Lock.cs | 4 + .../src/System/Threading/Thread.cs | 6 +- .../System/Threading/WaitHandle.Windows.cs | 8 +- .../Threading/Wasi/WasiFinalizerScheduler.cs | 24 +- 175 files changed, 2382 insertions(+), 1531 deletions(-) create mode 100644 src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallException.cs diff --git a/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj b/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj index 0d0f874aca3f9c..9e77600c4db36d 100644 --- a/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj +++ b/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj @@ -208,6 +208,7 @@ + diff --git a/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs b/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs index 377fba25b43a36..bb1ffe93f98e1a 100644 --- a/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs @@ -12,7 +12,7 @@ internal static unsafe partial class ThrowHelpers { [DoesNotReturn] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowAmbiguousResolutionException")] - private static partial void ThrowAmbiguousResolutionException(MethodTable* targetType, MethodTable* interfaceType, void* methodDesc); + private static partial void ThrowAmbiguousResolutionException(MethodTable* targetType, MethodTable* interfaceType, void* methodDesc, out QCallException qcallException); [DoesNotReturn] [DebuggerHidden] @@ -21,12 +21,12 @@ internal static void ThrowAmbiguousResolutionException( void* interfaceType, // MethodTable* void* targetType) // MethodTable* { - ThrowAmbiguousResolutionException((MethodTable*)targetType, (MethodTable*)interfaceType, method); + ThrowAmbiguousResolutionException((MethodTable*)targetType, (MethodTable*)interfaceType, method, out _); } [DoesNotReturn] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowEntryPointNotFoundException")] - private static partial void ThrowEntryPointNotFoundException(MethodTable* targetType, MethodTable* interfaceType, void* methodDesc); + private static partial void ThrowEntryPointNotFoundException(MethodTable* targetType, MethodTable* interfaceType, void* methodDesc, out QCallException qcallException); [DoesNotReturn] [DebuggerHidden] @@ -35,12 +35,12 @@ internal static void ThrowEntryPointNotFoundException( void* interfaceType, // MethodTable* void* targetType) // MethodTable* { - ThrowEntryPointNotFoundException((MethodTable*)targetType, (MethodTable*)interfaceType, method); + ThrowEntryPointNotFoundException((MethodTable*)targetType, (MethodTable*)interfaceType, method, out _); } [DoesNotReturn] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowMethodAccessException")] - private static partial void ThrowMethodAccessExceptionInternal(void* caller, void* callee); + private static partial void ThrowMethodAccessExceptionInternal(void* caller, void* callee, out QCallException qcallException); // implementation of CORINFO_HELP_METHOD_ACCESS_EXCEPTION [DoesNotReturn] @@ -49,12 +49,12 @@ internal static void ThrowMethodAccessException( void* caller, // MethodDesc* void* callee) // MethodDesc* { - ThrowMethodAccessExceptionInternal(caller, callee); + ThrowMethodAccessExceptionInternal(caller, callee, out _); } [DoesNotReturn] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowFieldAccessException")] - private static partial void ThrowFieldAccessExceptionInternal(void* caller, void* callee); + private static partial void ThrowFieldAccessExceptionInternal(void* caller, void* callee, out QCallException qcallException); // implementation of CORINFO_HELP_FIELD_ACCESS_EXCEPTION [DoesNotReturn] @@ -63,12 +63,12 @@ internal static void ThrowFieldAccessException( void* caller, // MethodDesc* void* callee) // FieldDesc* { - ThrowFieldAccessExceptionInternal(caller, callee); + ThrowFieldAccessExceptionInternal(caller, callee, out _); } [DoesNotReturn] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowClassAccessException")] - private static partial void ThrowClassAccessExceptionInternal(void* caller, void* callee); + private static partial void ThrowClassAccessExceptionInternal(void* caller, void* callee, out QCallException qcallException); // implementation of CORINFO_HELP_CLASS_ACCESS_EXCEPTION [DoesNotReturn] @@ -77,7 +77,7 @@ internal static void ThrowClassAccessException( void* caller, // MethodDesc* void* callee) // Type handle { - ThrowClassAccessExceptionInternal(caller, callee); + ThrowClassAccessExceptionInternal(caller, callee, out _); } } } diff --git a/src/coreclr/System.Private.CoreLib/src/Internal/VersionResilientHashCode.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/Internal/VersionResilientHashCode.CoreCLR.cs index 226deaa7a75a10..08a4581bedc335 100644 --- a/src/coreclr/System.Private.CoreLib/src/Internal/VersionResilientHashCode.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/Internal/VersionResilientHashCode.CoreCLR.cs @@ -14,10 +14,10 @@ namespace Internal internal static partial class VersionResilientHashCode { [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "VersionResilientHashCode_TypeHashCode")] - private static partial int TypeHashCode(QCallTypeHandle typeHandle); + private static partial int TypeHashCode(QCallTypeHandle typeHandle, out QCallException qcallException); public static int TypeHashCode(RuntimeType type) - => TypeHashCode(new QCallTypeHandle(ref type)); + => TypeHashCode(new QCallTypeHandle(ref type), out _); private static int NameHashCode(string s1, string s2) => NameHashCode(System.Text.Encoding.UTF8.GetBytes(s1), System.Text.Encoding.UTF8.GetBytes(s2)); diff --git a/src/coreclr/System.Private.CoreLib/src/System/AppContext.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/AppContext.CoreCLR.cs index 0fd0ff7b7564b7..060e260ab79ca9 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/AppContext.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/AppContext.CoreCLR.cs @@ -18,7 +18,7 @@ private static bool IsKnownHostProperty(string name) [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AppContext_TryGetHostPropertyValue", StringMarshalling = StringMarshalling.Utf16)] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool TryGetHostPropertyValue(string name, StringHandleOnStack retValue); + private static partial bool TryGetHostPropertyValue(string name, StringHandleOnStack retValue, out QCallException qcallException); [UnmanagedCallersOnly] private static unsafe void OnProcessExit(Exception* pException) diff --git a/src/coreclr/System.Private.CoreLib/src/System/ArgIterator.cs b/src/coreclr/System.Private.CoreLib/src/System/ArgIterator.cs index 5bc772cf117b8e..1571688362ed9a 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/ArgIterator.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/ArgIterator.cs @@ -37,11 +37,11 @@ public ArgIterator(RuntimeArgumentHandle arglist) IntPtr cookie = arglist.Value; if (cookie == 0) throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized); - Init(ThisPtr, cookie); + Init(ThisPtr, cookie, out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_Init")] - private static partial void Init(ArgIterator* thisPtr, IntPtr cookie); + private static partial void Init(ArgIterator* thisPtr, IntPtr cookie, out QCallException qcallException); // create an arg iterator that points just past 'firstArg'. // 'arglist' is the value returned by the ARGLIST instruction @@ -53,11 +53,11 @@ public ArgIterator(RuntimeArgumentHandle arglist, void* ptr) IntPtr cookie = arglist.Value; if (cookie == 0) throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized); - Init(ThisPtr, cookie, ptr); + Init(ThisPtr, cookie, ptr, out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_Init2")] - private static partial void Init(ArgIterator* thisPtr, IntPtr cookie, void* ptr); + private static partial void Init(ArgIterator* thisPtr, IntPtr cookie, void* ptr, out QCallException qcallException); // Fetch an argument as a typed referece, advance the iterator. // Throws an exception if past end of argument list @@ -78,12 +78,12 @@ public TypedReference GetNextArg() } TypedReference result = default; - GetNextArg(ThisPtr, &result); + GetNextArg(ThisPtr, &result, out _); return result; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_GetNextArg")] - private static partial void GetNextArg(ArgIterator* thisPtr, TypedReference* pResult); + private static partial void GetNextArg(ArgIterator* thisPtr, TypedReference* pResult, out QCallException qcallException); // Alternate version of GetNextArg() intended primarily for IJW code // generated by VC's "va_arg()" construct. @@ -113,12 +113,12 @@ public TypedReference GetNextArg(RuntimeTypeHandle rth) } TypedReference result = default; - GetNextArg(ThisPtr, new QCallTypeHandle(ref rth), &result); + GetNextArg(ThisPtr, new QCallTypeHandle(ref rth), &result, out _); return result; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_GetNextArg2")] - private static partial void GetNextArg(ArgIterator* thisPtr, QCallTypeHandle rth, TypedReference* pResult); + private static partial void GetNextArg(ArgIterator* thisPtr, QCallTypeHandle rth, TypedReference* pResult, out QCallException qcallException); // This method should invalidate the iterator (va_end). It is not supported yet. public void End() @@ -139,11 +139,11 @@ public int GetRemainingCount() // Gets the type of the current arg, does NOT advance the iterator public RuntimeTypeHandle GetNextArgType() { - return RuntimeTypeHandle.FromIntPtr(GetNextArgType(ThisPtr)); + return RuntimeTypeHandle.FromIntPtr(GetNextArgType(ThisPtr, out _)); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_GetNextArgType")] - private static partial IntPtr GetNextArgType(ArgIterator* thisPtr); + private static partial IntPtr GetNextArgType(ArgIterator* thisPtr, out QCallException qcallException); public override int GetHashCode() { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Array.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Array.CoreCLR.cs index e16d76377cd8f4..8faa8a962e0033 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Array.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Array.CoreCLR.cs @@ -17,13 +17,15 @@ public abstract partial class Array : ICloneable, IList, IStructuralComparable, { [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Array_CreateInstance")] private static unsafe partial void InternalCreate(QCallTypeHandle type, int rank, int* pLengths, int* pLowerBounds, - [MarshalAs(UnmanagedType.Bool)] bool fromArrayType, ObjectHandleOnStack retArray); + [MarshalAs(UnmanagedType.Bool)] bool fromArrayType, ObjectHandleOnStack retArray, + out QCallException qcallException); private static unsafe Array InternalCreate(RuntimeType elementType, int rank, int* pLengths, int* pLowerBounds) { Array? retArray = null; InternalCreate(new QCallTypeHandle(ref elementType), rank, pLengths, pLowerBounds, - fromArrayType: false, ObjectHandleOnStack.Create(ref retArray)); + fromArrayType: false, ObjectHandleOnStack.Create(ref retArray), + out _); return retArray!; } @@ -31,12 +33,13 @@ private static unsafe Array InternalCreateFromArrayType(RuntimeType arrayType, i { Array? retArray = null; InternalCreate(new QCallTypeHandle(ref arrayType), rank, pLengths, pLowerBounds, - fromArrayType: true, ObjectHandleOnStack.Create(ref retArray)); + fromArrayType: true, ObjectHandleOnStack.Create(ref retArray), + out _); return retArray!; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Array_Ctor")] - private static unsafe partial void Ctor(MethodTable* pArrayMT, uint dwNumArgs, int* pArgList, ObjectHandleOnStack retArray); + private static unsafe partial void Ctor(MethodTable* pArrayMT, uint dwNumArgs, int* pArgList, ObjectHandleOnStack retArray, out QCallException qcallException); // implementation of CORINFO_HELP_NEW_MDARR and CORINFO_HELP_NEW_MDARR_RARE. [StackTraceHidden] @@ -45,7 +48,7 @@ private static unsafe Array InternalCreateFromArrayType(RuntimeType arrayType, i internal static unsafe Array Ctor(MethodTable* pArrayMT, uint dwNumArgs, int* pArgList) { Array? arr = null; - Ctor(pArrayMT, dwNumArgs, pArgList, ObjectHandleOnStack.Create(ref arr)); + Ctor(pArrayMT, dwNumArgs, pArgList, ObjectHandleOnStack.Create(ref arr), out _); return arr!; } @@ -350,14 +353,14 @@ internal sealed unsafe partial class ArrayInitializeCache : RuntimeType.IGeneric internal readonly delegate* ConstructorEntrypoint; [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Array_GetElementConstructorEntrypoint")] - private static partial delegate* GetElementConstructorEntrypoint(QCallTypeHandle arrayType); + private static partial delegate* GetElementConstructorEntrypoint(QCallTypeHandle arrayType, out QCallException qcallException); private ArrayInitializeCache(delegate* constructorEntrypoint) { ConstructorEntrypoint = constructorEntrypoint; } - public static ArrayInitializeCache Create(RuntimeType arrayType) => new(GetElementConstructorEntrypoint(new QCallTypeHandle(ref arrayType))); + public static ArrayInitializeCache Create(RuntimeType arrayType) => new(GetElementConstructorEntrypoint(new QCallTypeHandle(ref arrayType), out _)); public void InitializeCompositeCache(RuntimeType.CompositeCacheEntry compositeEntry) => compositeEntry._arrayInitializeCache = this; public static ref ArrayInitializeCache? GetStorageRef(RuntimeType.CompositeCacheEntry compositeEntry) => ref compositeEntry._arrayInitializeCache; } diff --git a/src/coreclr/System.Private.CoreLib/src/System/CLRConfig.cs b/src/coreclr/System.Private.CoreLib/src/System/CLRConfig.cs index 31d0d357f93747..908e1e076730ee 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/CLRConfig.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/CLRConfig.cs @@ -12,11 +12,11 @@ internal static partial class CLRConfig { internal static bool GetBoolValue(string switchName, out bool exist) { - return GetConfigBoolValue(switchName, out exist); + return GetConfigBoolValue(switchName, out exist, out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ClrConfig_GetConfigBoolValue", StringMarshalling = StringMarshalling.Utf16)] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool GetConfigBoolValue(string configSwitchName, [MarshalAs(UnmanagedType.Bool)] out bool exist); + private static partial bool GetConfigBoolValue(string configSwitchName, [MarshalAs(UnmanagedType.Bool)] out bool exist, out QCallException qcallException); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/ComAwareWeakReference.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/ComAwareWeakReference.CoreCLR.cs index a4694b9fab2522..872d5608acd16c 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/ComAwareWeakReference.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/ComAwareWeakReference.CoreCLR.cs @@ -10,7 +10,7 @@ namespace System internal sealed partial class ComAwareWeakReference { [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ComWeakRefToObject")] - private static partial void ComWeakRefToObject(IntPtr pComWeakRef, ObjectHandleOnStack retRcw); + private static partial void ComWeakRefToObject(IntPtr pComWeakRef, ObjectHandleOnStack retRcw, out QCallException qcallException); internal static object? ComWeakRefToObject(IntPtr pComWeakRef, object? context) { @@ -19,7 +19,7 @@ internal sealed partial class ComAwareWeakReference { // This wrapper was not created by ComWrappers, so we try to rehydrate using built-in COM. object? retRcw = null; - ComWeakRefToObject(pComWeakRef, ObjectHandleOnStack.Create(ref retRcw)); + ComWeakRefToObject(pComWeakRef, ObjectHandleOnStack.Create(ref retRcw), out _); return retRcw; } #endif // FEATURE_COMINTEROP @@ -39,7 +39,7 @@ internal static bool PossiblyComObject(object target) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjectToComWeakRef")] - private static partial IntPtr ObjectToComWeakRef(ObjectHandleOnStack retRcw); + private static partial IntPtr ObjectToComWeakRef(ObjectHandleOnStack retRcw, out QCallException qcallException); internal static nint ObjectToComWeakRef(object target, out object? context) { @@ -48,7 +48,7 @@ internal static nint ObjectToComWeakRef(object target, out object? context) { // This object is using built-in COM, so use built-in COM to create the weak reference. context = null; - return ObjectToComWeakRef(ObjectHandleOnStack.Create(ref target)); + return ObjectToComWeakRef(ObjectHandleOnStack.Create(ref target), out _); } #endif // FEATURE_COMINTEROP diff --git a/src/coreclr/System.Private.CoreLib/src/System/Delegate.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Delegate.CoreCLR.cs index b27d21da100350..a4fe7ebfa38719 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Delegate.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Delegate.CoreCLR.cs @@ -500,7 +500,8 @@ private bool BindToMethodName(object? target, [DynamicallyAccessedMembers(Dynami unsafe { ret = BindToMethodName(RuntimeHelpers.GetMethodTable(this), (target != null) ? RuntimeHelpers.GetMethodTable(target) : null, - new QCallTypeHandle(ref methodType), method, flags, ObjectHandleOnStack.Create(ref target), out bindToMethodDetails); + new QCallTypeHandle(ref methodType), method, flags, ObjectHandleOnStack.Create(ref target), out bindToMethodDetails, + out _); } if (ret) @@ -534,7 +535,7 @@ private struct BindToMethodDetails [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_BindToMethodName", StringMarshalling = StringMarshalling.Utf8)] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool BindToMethodName(MethodTable* pDelegateMT, MethodTable *pTargetMT, QCallTypeHandle methodType, string method, DelegateBindingFlags flags, ObjectHandleOnStack targetParameter, out BindToMethodDetails bindToMethodDetails); + private static partial bool BindToMethodName(MethodTable* pDelegateMT, MethodTable *pTargetMT, QCallTypeHandle methodType, string method, DelegateBindingFlags flags, ObjectHandleOnStack targetParameter, out BindToMethodDetails bindToMethodDetails, out QCallException qcallException); private bool BindToMethodInfo(object? target, IRuntimeMethodInfo method, RuntimeType methodType, DelegateBindingFlags flags) { @@ -544,7 +545,8 @@ private bool BindToMethodInfo(object? target, IRuntimeMethodInfo method, Runtime unsafe { ret = BindToMethodInfo(RuntimeHelpers.GetMethodTable(this), (target != null) ? RuntimeHelpers.GetMethodTable(target) : null, - IRuntimeMethodInfo.GetValue(method), new QCallTypeHandle(ref methodType), flags, ObjectHandleOnStack.Create(ref target), out bindToMethodDetails); + IRuntimeMethodInfo.GetValue(method), new QCallTypeHandle(ref methodType), flags, ObjectHandleOnStack.Create(ref target), out bindToMethodDetails, + out _); } if (ret) @@ -569,7 +571,7 @@ private bool BindToMethodInfo(object? target, IRuntimeMethodInfo method, Runtime [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_BindToMethodInfo")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool BindToMethodInfo(MethodTable* pDelegateMT, MethodTable *pTargetMT, RuntimeMethodHandleInternal method, QCallTypeHandle methodType, DelegateBindingFlags flags, ObjectHandleOnStack targetParameter, out BindToMethodDetails bindToMethodDetails); + private static partial bool BindToMethodInfo(MethodTable* pDelegateMT, MethodTable *pTargetMT, RuntimeMethodHandleInternal method, QCallTypeHandle methodType, DelegateBindingFlags flags, ObjectHandleOnStack targetParameter, out BindToMethodDetails bindToMethodDetails, out QCallException qcallException); private static Delegate InternalAlloc(RuntimeType type) { @@ -595,7 +597,7 @@ private static unsafe bool InternalEqualTypes(object a, object b) bool ret = pMTa->HasTypeEquivalence && pMTb->HasTypeEquivalence && // only use QCall to check the type equivalence scenario - RuntimeHelpers.AreTypesEquivalent(pMTa, pMTb); + RuntimeHelpers.AreTypesEquivalent(pMTa, pMTb, out _); GC.KeepAlive(a); GC.KeepAlive(b); @@ -622,7 +624,8 @@ private void DelegateConstruct(object target, IntPtr method) unsafe { Construct(RuntimeHelpers.GetMethodTable(this), (target != null) ? RuntimeHelpers.GetMethodTable(target) : null, - method, out bindToMethodDetails); + method, out bindToMethodDetails, + out _); } // Apply the results of the QCall to the delegate instance. @@ -641,13 +644,13 @@ private void DelegateConstruct(object target, IntPtr method) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_Construct")] - private static partial void Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, IntPtr method, out BindToMethodDetails bindToMethodDetails); + private static partial void Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, IntPtr method, out BindToMethodDetails bindToMethodDetails, out QCallException qcallException); [MethodImpl(MethodImplOptions.InternalCall)] private static extern unsafe void* GetMulticastInvoke(MethodTable* pMT); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_GetMulticastInvokeSlow")] - private static unsafe partial void* GetMulticastInvokeSlow(MethodTable* pMT); + private static unsafe partial void* GetMulticastInvokeSlow(MethodTable* pMT, out QCallException qcallException); private unsafe IntPtr GetMulticastInvoke() { @@ -655,7 +658,7 @@ private unsafe IntPtr GetMulticastInvoke() void* ptr = GetMulticastInvoke(pMT); if (ptr == null) { - ptr = GetMulticastInvokeSlow(pMT); + ptr = GetMulticastInvokeSlow(pMT, out _); Debug.Assert(ptr != null); Debug.Assert(ptr == GetMulticastInvoke(pMT)); } @@ -677,22 +680,22 @@ private unsafe IntPtr GetInvokeMethod() private static unsafe IRuntimeMethodInfo CreateMethodInfo(MethodDesc* methodDesc) { IRuntimeMethodInfo? methodInfo = null; - CreateMethodInfo(methodDesc, ObjectHandleOnStack.Create(ref methodInfo)); + CreateMethodInfo(methodDesc, ObjectHandleOnStack.Create(ref methodInfo), out _); return methodInfo!; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_CreateMethodInfo")] - private static unsafe partial void CreateMethodInfo(MethodDesc* methodDesc, ObjectHandleOnStack retMethodInfo); + private static unsafe partial void CreateMethodInfo(MethodDesc* methodDesc, ObjectHandleOnStack retMethodInfo, out QCallException qcallException); [MethodImpl(MethodImplOptions.NoInlining)] private unsafe MethodDesc* GetMethodDesc() { Delegate instance = this; - return GetMethodDesc(ObjectHandleOnStack.Create(ref instance)); + return GetMethodDesc(ObjectHandleOnStack.Create(ref instance), out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_GetMethodDesc")] - private static unsafe partial MethodDesc* GetMethodDesc(ObjectHandleOnStack instance); + private static unsafe partial MethodDesc* GetMethodDesc(ObjectHandleOnStack instance, out QCallException qcallException); internal struct Wrapper(Delegate? value) : IEquatable { @@ -881,23 +884,23 @@ internal static IntPtr AdjustTarget(object target, IntPtr methodPtr) { unsafe { - IntPtr result = AdjustTarget(RuntimeHelpers.GetMethodTable(target), methodPtr); + IntPtr result = AdjustTarget(RuntimeHelpers.GetMethodTable(target), methodPtr, out _); GC.KeepAlive(target); return result; } } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_AdjustTarget")] - private static partial IntPtr AdjustTarget(MethodTable* targetMT, IntPtr methodPtr); + private static partial IntPtr AdjustTarget(MethodTable* targetMT, IntPtr methodPtr, out QCallException qcallException); internal void InitializeVirtualCallStub(IntPtr methodPtr) { Delegate d = this; - InitializeVirtualCallStub(ObjectHandleOnStack.Create(ref d), methodPtr); + InitializeVirtualCallStub(ObjectHandleOnStack.Create(ref d), methodPtr, out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_InitializeVirtualCallStub")] - private static partial void InitializeVirtualCallStub(ObjectHandleOnStack d, IntPtr methodPtr); + private static partial void InitializeVirtualCallStub(ObjectHandleOnStack d, IntPtr methodPtr, out QCallException qcallException); [DoesNotReturn] [DebuggerNonUserCode] diff --git a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs index cd39afd38c997f..e7de3f6f5a7efe 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs @@ -12,18 +12,18 @@ namespace System.Diagnostics public static partial class Debugger { [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DebugDebugger_Break")] - private static partial void BreakInternal(); + private static partial void BreakInternal(out QCallException qcallException); // Break causes a breakpoint to be signalled to an attached debugger. If no debugger // is attached, the user is asked if they want to attach a debugger. If yes, then the // debugger is launched. [MethodImpl(MethodImplOptions.NoInlining)] - public static void Break() => BreakInternal(); + public static void Break() => BreakInternal(out _); // Launch launches & attaches a debugger to the process. If a debugger is already attached, // nothing happens. // - public static bool Launch() => IsAttached || LaunchInternal(); + public static bool Launch() => IsAttached || LaunchInternal(out _); // This class implements code:ICustomDebuggerNotification and provides a type to be used to notify // the debugger that execution is about to enter a path that involves a cross-thread dependency. @@ -50,13 +50,13 @@ public static void NotifyOfCrossThreadDependency() static void NotifyOfCrossThreadDependencySlow() { var notify = new CrossThreadDependencyNotification(); - CustomNotification(ObjectHandleOnStack.Create(ref notify)); + CustomNotification(ObjectHandleOnStack.Create(ref notify), out _); } } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DebugDebugger_Launch")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool LaunchInternal(); + private static partial bool LaunchInternal(out QCallException qcallException); // Returns whether or not a managed debugger is attached to the process. public static bool IsAttached => IsManagedDebuggerAttached() != 0; @@ -68,10 +68,10 @@ static void NotifyOfCrossThreadDependencySlow() // Posts a message for the attached debugger. If there is no // debugger attached, has no effect. The debugger may or may not // report the message depending on its settings. - public static void Log(int level, string? category, string? message) => LogInternal(level, category, message); + public static void Log(int level, string? category, string? message) => LogInternal(level, category, message, out _); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DebugDebugger_Log", StringMarshalling = StringMarshalling.Utf16)] - private static partial void LogInternal(int level, string? category, string? message); + private static partial void LogInternal(int level, string? category, string? message, out QCallException qcallException); // Checks to see if an attached debugger has logging enabled public static bool IsLogging() => IsLoggingInternal() != 0; @@ -84,7 +84,7 @@ static void NotifyOfCrossThreadDependencySlow() // debugger attached, has no effect. The debugger may or may not // report the notification depending on its settings. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DebugDebugger_CustomNotification")] - private static partial void CustomNotification(ObjectHandleOnStack data); + private static partial void CustomNotification(ObjectHandleOnStack data, out QCallException qcallException); // implementation of CORINFO_HELP_USER_BREAKPOINT [StackTraceHidden] diff --git a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrame.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrame.CoreCLR.cs index 8c1850d31e840b..097b113b63663b 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrame.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrame.CoreCLR.cs @@ -57,7 +57,7 @@ private void BuildStackFrame(int skipFrames, bool needFileInfo) #pragma warning restore IDE0060 [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StackFrame_GetMethodDescFromNativeIP")] - private static partial RuntimeMethodHandleInternal GetMethodDescFromNativeIP(IntPtr ip); + private static partial RuntimeMethodHandleInternal GetMethodDescFromNativeIP(IntPtr ip, out QCallException qcallException); /// /// Returns the MethodBase instance for the managed code IP address. @@ -68,7 +68,7 @@ private void BuildStackFrame(int skipFrames, bool needFileInfo) /// MethodBase instance for the method or null if IP not found internal static MethodBase? GetMethodFromNativeIP(IntPtr ip) { - RuntimeMethodHandleInternal method = GetMethodDescFromNativeIP(ip); + RuntimeMethodHandleInternal method = GetMethodDescFromNativeIP(ip, out _); if (method.Value == IntPtr.Zero) return null; diff --git a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackTrace.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackTrace.CoreCLR.cs index 5d4bc6008e6400..d564d31cb6c531 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackTrace.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackTrace.CoreCLR.cs @@ -10,10 +10,10 @@ namespace System.Diagnostics public partial class StackTrace { [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StackTrace_GetStackFramesInternal")] - private static partial void GetStackFramesInternal(ObjectHandleOnStack sfh, [MarshalAs(UnmanagedType.Bool)] bool fNeedFileInfo, ObjectHandleOnStack e); + private static partial void GetStackFramesInternal(ObjectHandleOnStack sfh, [MarshalAs(UnmanagedType.Bool)] bool fNeedFileInfo, ObjectHandleOnStack e, out QCallException qcallException); internal static void GetStackFramesInternal(StackFrameHelper sfh, bool fNeedFileInfo, Exception? e) - => GetStackFramesInternal(ObjectHandleOnStack.Create(ref sfh), fNeedFileInfo, ObjectHandleOnStack.Create(ref e)); + => GetStackFramesInternal(ObjectHandleOnStack.Create(ref sfh), fNeedFileInfo, ObjectHandleOnStack.Create(ref e), out _); internal static int CalculateFramesToSkip(StackFrameHelper StackF, int iNumFrames) { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs index fb369e9393f112..60e3d37c6e0da6 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs @@ -12,7 +12,7 @@ namespace System public abstract partial class Enum { [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Enum_GetValuesAndNames")] - private static partial void GetEnumValuesAndNames(QCallTypeHandle enumType, ObjectHandleOnStack values, ObjectHandleOnStack names, Interop.BOOL getNames); + private static partial void GetEnumValuesAndNames(QCallTypeHandle enumType, ObjectHandleOnStack values, ObjectHandleOnStack names, Interop.BOOL getNames, out QCallException qcallException); [MethodImpl(MethodImplOptions.AggressiveInlining)] private static unsafe CorElementType InternalGetCorElementType(RuntimeType rt) @@ -111,7 +111,8 @@ public static EnumInfo Create(RuntimeType type, bool getNames) new QCallTypeHandle(ref type), ObjectHandleOnStack.Create(ref values), ObjectHandleOnStack.Create(ref names), - getNames ? Interop.BOOL.TRUE : Interop.BOOL.FALSE); + getNames ? Interop.BOOL.TRUE : Interop.BOOL.FALSE, + out _); Debug.Assert(values!.GetType() == typeof(TStorage[])); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Environment.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Environment.CoreCLR.cs index b1c7ad10bb4481..b8c8c4ba9be125 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Environment.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Environment.CoreCLR.cs @@ -22,10 +22,10 @@ public static int CurrentManagedThreadId /// QCall that passes the integer exit code to the runtime to terminate the process; it accesses no caller-supplied memory. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Environment_Exit")] [DoesNotReturn] - private static safe partial void _Exit(int exitCode); + private static safe partial void _Exit(int exitCode, out QCallException qcallException); [DoesNotReturn] - public static void Exit(int exitCode) => _Exit(exitCode); + public static void Exit(int exitCode) => _Exit(exitCode, out _); /// Runtime FCall get/set of the process-wide exit code (an int); it accesses no caller-supplied memory. public static extern safe int ExitCode @@ -82,12 +82,12 @@ internal static void FailFast(string? message, Exception? exception, string? err [DoesNotReturn] private static void FailFast(ref StackCrawlMark mark, string? message, Exception? exception, string? errorMessage) { - FailFast(new StackCrawlMarkHandle(ref mark), message, ObjectHandleOnStack.Create(ref exception), errorMessage); + FailFast(new StackCrawlMarkHandle(ref mark), message, ObjectHandleOnStack.Create(ref exception), errorMessage, out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Environment_FailFast", StringMarshalling = StringMarshalling.Utf16)] [DoesNotReturn] - private static partial void FailFast(StackCrawlMarkHandle mark, string? message, ObjectHandleOnStack exception, string? errorMessage); + private static partial void FailFast(StackCrawlMarkHandle mark, string? message, ObjectHandleOnStack exception, string? errorMessage, out QCallException qcallException); private static unsafe string[] InitializeCommandLineArgs(char* exePath, int argc, char** argv) // invoked from VM { @@ -120,7 +120,7 @@ private static unsafe void InitializeCommandLineArgs(char* exePath, int argc, ch /// QCall that returns the available processor count as an int; it accesses no caller-supplied memory. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Environment_GetProcessorCount")] - internal static safe partial int GetProcessorCount(); + internal static safe partial int GetProcessorCount(out QCallException qcallException); [UnmanagedCallersOnly] private static unsafe void GetResourceString(char* pKey, string* pResult, Exception* pException) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Exception.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Exception.CoreCLR.cs index defddcdd5c488f..d174a541a145ed 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Exception.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Exception.CoreCLR.cs @@ -56,7 +56,7 @@ private IDictionary CreateDataContainer() private static extern bool IsImmutableAgileException(Exception e); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_GetMethodFromStackTrace")] - private static partial void GetMethodFromStackTrace(ObjectHandleOnStack stackTrace, ObjectHandleOnStack method); + private static partial void GetMethodFromStackTrace(ObjectHandleOnStack stackTrace, ObjectHandleOnStack method, out QCallException qcallException); private MethodBase? GetExceptionMethodFromStackTrace() { @@ -67,7 +67,7 @@ private IDictionary CreateDataContainer() } IRuntimeMethodInfo? methodInfo = null; - GetMethodFromStackTrace(ObjectHandleOnStack.Create(ref stackTraceLocal), ObjectHandleOnStack.Create(ref methodInfo)); + GetMethodFromStackTrace(ObjectHandleOnStack.Create(ref stackTraceLocal), ObjectHandleOnStack.Create(ref methodInfo), out _); Debug.Assert(methodInfo != null); return RuntimeType.GetMethodBase(methodInfo); @@ -209,12 +209,12 @@ internal enum ExceptionMessageKind internal static string GetMessageFromNativeResources(ExceptionMessageKind kind) { string? retMesg = null; - GetMessageFromNativeResources(kind, new StringHandleOnStack(ref retMesg)); + GetMessageFromNativeResources(kind, new StringHandleOnStack(ref retMesg), out _); return retMesg!; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_GetMessageFromNativeResources")] - private static partial void GetMessageFromNativeResources(ExceptionMessageKind kind, StringHandleOnStack retMesg); + private static partial void GetMessageFromNativeResources(ExceptionMessageKind kind, StringHandleOnStack retMesg, out QCallException qcallException); internal readonly struct DispatchState { @@ -237,13 +237,13 @@ public DispatchState( } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_GetFrozenStackTrace")] - private static partial void GetFrozenStackTrace(ObjectHandleOnStack exception, ObjectHandleOnStack stackTrace); + private static partial void GetFrozenStackTrace(ObjectHandleOnStack exception, ObjectHandleOnStack stackTrace, out QCallException qcallException); internal DispatchState CaptureDispatchState() { Exception _this = this; object? stackTrace = null; - GetFrozenStackTrace(ObjectHandleOnStack.Create(ref _this), ObjectHandleOnStack.Create(ref stackTrace)); + GetFrozenStackTrace(ObjectHandleOnStack.Create(ref _this), ObjectHandleOnStack.Create(ref stackTrace), out _); return new DispatchState(stackTrace, _remoteStackTraceString, _ipForWatsonBuckets, _watsonBuckets); diff --git a/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs index 32ff5c2f6fbea3..62506a3d5c255d 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs @@ -92,11 +92,11 @@ public static GCMemoryInfo GetGCMemoryInfo(GCKind kind) /// exceed it. is the audited entry point that /// validates both. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_StartNoGCRegion")] - internal static unsafe partial int _StartNoGCRegion(long totalSize, [MarshalAs(UnmanagedType.Bool)] bool lohSizeKnown, long lohSize, [MarshalAs(UnmanagedType.Bool)] bool disallowFullBlockingGC); + internal static unsafe partial int _StartNoGCRegion(long totalSize, [MarshalAs(UnmanagedType.Bool)] bool lohSizeKnown, long lohSize, [MarshalAs(UnmanagedType.Bool)] bool disallowFullBlockingGC, out QCallException qcallException); /// QCall that ends the no-GC region and returns a status code; it takes no arguments and accesses no caller-supplied memory. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_EndNoGCRegion")] - internal static safe partial int _EndNoGCRegion(); + internal static safe partial int _EndNoGCRegion(out QCallException qcallException); // keep in sync with GC_ALLOC_FLAGS in gcinterface.h internal enum GC_ALLOC_FLAGS @@ -107,17 +107,17 @@ internal enum GC_ALLOC_FLAGS }; [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_AllocateNewArray")] - private static partial void AllocateNewArray(IntPtr typeHandlePtr, int length, GC_ALLOC_FLAGS flags, ObjectHandleOnStack ret); + private static partial void AllocateNewArray(IntPtr typeHandlePtr, int length, GC_ALLOC_FLAGS flags, ObjectHandleOnStack ret, out QCallException qcallException); /// QCall that returns the total managed heap byte count as a scalar; it takes no arguments and accesses no caller-supplied memory. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_GetTotalMemory")] - private static safe partial long GetTotalMemory(); + private static safe partial long GetTotalMemory(out QCallException qcallException); /// The runtime only asserts that is at least -1 before handing it to the /// GC, so the caller must not pass a smaller value. /// is the audited entry point that validates it. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_Collect")] - private static unsafe partial void _Collect(int generation, int mode, [MarshalAs(UnmanagedType.U1)] bool lowMemoryPressure); + private static unsafe partial void _Collect(int generation, int mode, [MarshalAs(UnmanagedType.U1)] bool lowMemoryPressure, out QCallException qcallException); /// FCall that returns the maximum supported generation number as a scalar; it takes no arguments and accesses no caller-supplied memory. [MethodImpl(MethodImplOptions.InternalCall)] @@ -144,11 +144,11 @@ internal enum GC_ALLOC_FLAGS /// QCall that records added memory pressure from a scalar byte count; it accesses no caller-supplied memory. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_AddMemoryPressure")] - private static safe partial void _AddMemoryPressure(ulong bytesAllocated); + private static safe partial void _AddMemoryPressure(ulong bytesAllocated, out QCallException qcallException); /// QCall that records removed memory pressure from a scalar byte count; it accesses no caller-supplied memory. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_RemoveMemoryPressure")] - private static safe partial void _RemoveMemoryPressure(ulong bytesAllocated); + private static safe partial void _RemoveMemoryPressure(ulong bytesAllocated, out QCallException qcallException); public static void AddMemoryPressure(long bytesAllocated) { @@ -158,7 +158,7 @@ public static void AddMemoryPressure(long bytesAllocated) ArgumentOutOfRangeException.ThrowIfGreaterThan(bytesAllocated, int.MaxValue); } - _AddMemoryPressure((ulong)bytesAllocated); + _AddMemoryPressure((ulong)bytesAllocated, out _); } public static void RemoveMemoryPressure(long bytesAllocated) @@ -169,7 +169,7 @@ public static void RemoveMemoryPressure(long bytesAllocated) ArgumentOutOfRangeException.ThrowIfGreaterThan(bytesAllocated, int.MaxValue); } - _RemoveMemoryPressure((ulong)bytesAllocated); + _RemoveMemoryPressure((ulong)bytesAllocated, out _); } // Returns the generation that obj is currently in. @@ -195,7 +195,7 @@ public static void Collect(int generation) public static void Collect() { // -1 says to GC all generations. - _Collect(-1, (int)InternalGCCollectionMode.Blocking, lowMemoryPressure: false); + _Collect(-1, (int)InternalGCCollectionMode.Blocking, lowMemoryPressure: false, out _); } public static void Collect(int generation, GCCollectionMode mode) @@ -260,7 +260,7 @@ internal static void Collect(int generation, GCCollectionMode mode, bool blockin iInternalModes |= (int)InternalGCCollectionMode.NonBlocking; } - _Collect(generation, (int)iInternalModes, lowMemoryPressure); + _Collect(generation, (int)iInternalModes, lowMemoryPressure, out _); } public static int CollectionCount(int generation) @@ -328,7 +328,7 @@ public static int GetGeneration(WeakReference wo) public static int MaxGeneration => GetMaxGeneration(); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_GetNextFinalizableObject")] - private static unsafe partial void* GetNextFinalizeableObject(ObjectHandleOnStack target); + private static unsafe partial void* GetNextFinalizeableObject(ObjectHandleOnStack target, out QCallException qcallException); [UnmanagedCallersOnly] private static unsafe uint RunFinalizers() @@ -339,7 +339,7 @@ private static unsafe uint RunFinalizers() while (true) { object? target = null; - void* fptr = GetNextFinalizeableObject(ObjectHandleOnStack.Create(ref target)); + void* fptr = GetNextFinalizeableObject(ObjectHandleOnStack.Create(ref target), out _); if (fptr == null) break; @@ -361,12 +361,12 @@ private static unsafe uint RunFinalizers() /// QCall that blocks until pending finalizers drain; it takes no arguments and accesses no caller-supplied memory. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_WaitForPendingFinalizers")] - private static safe partial void _WaitForPendingFinalizers(); + private static safe partial void _WaitForPendingFinalizers(out QCallException qcallException); public static void WaitForPendingFinalizers() { // QCalls can not be exposed directly, need to wrap it. - _WaitForPendingFinalizers(); + _WaitForPendingFinalizers(out _); } // Indicates that the system should not call the Finalize() method on @@ -390,7 +390,7 @@ public static unsafe void SuppressFinalize(object obj) // where calling ReRegisterForFinalize is useful is inside a finalizer that // needs to resurrect itself or an object that it references. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_ReRegisterForFinalize")] - private static partial void ReRegisterForFinalize(ObjectHandleOnStack o); + private static partial void ReRegisterForFinalize(ObjectHandleOnStack o, out QCallException qcallException); public static unsafe void ReRegisterForFinalize(object obj) { @@ -399,7 +399,7 @@ public static unsafe void ReRegisterForFinalize(object obj) MethodTable* pMT = RuntimeHelpers.GetMethodTable(obj); if (pMT->HasFinalizer) { - ReRegisterForFinalize(ObjectHandleOnStack.Create(ref obj)); + ReRegisterForFinalize(ObjectHandleOnStack.Create(ref obj), out _); } // GC.KeepAlive(obj) not required. pMT kept alive via ObjectHandleOnStack @@ -411,7 +411,7 @@ public static unsafe void ReRegisterForFinalize(object obj) // public static long GetTotalMemory(bool forceFullCollection) { - long size = GetTotalMemory(); + long size = GetTotalMemory(out _); if (!forceFullCollection) return size; // If we force a full collection, we will run the finalizers on all @@ -427,17 +427,17 @@ public static long GetTotalMemory(bool forceFullCollection) WaitForPendingFinalizers(); Collect(); size = newSize; - newSize = GetTotalMemory(); + newSize = GetTotalMemory(out _); diff = ((float)(newSize - size)) / size; } while (reps-- > 0 && !(-.05 < diff && diff < .05)); return newSize; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_RegisterFrozenSegment")] - private static partial IntPtr _RegisterFrozenSegment(IntPtr sectionAddress, nint sectionSize); + private static partial IntPtr _RegisterFrozenSegment(IntPtr sectionAddress, nint sectionSize, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_UnregisterFrozenSegment")] - private static partial void _UnregisterFrozenSegment(IntPtr segmentHandle); + private static partial void _UnregisterFrozenSegment(IntPtr segmentHandle, out QCallException qcallException); /// FCall that returns the current thread's allocated byte count as a scalar; it takes no arguments and accesses no caller-supplied memory. [MethodImpl(MethodImplOptions.InternalCall)] @@ -448,7 +448,7 @@ public static long GetTotalMemory(bool forceFullCollection) /// Get a count of the bytes allocated over the lifetime of the process. /// /// If true, gather a precise number, otherwise gather a fairly count. Gathering a precise value triggers at a significant performance penalty. - public static long GetTotalAllocatedBytes(bool precise = false) => precise ? GetTotalAllocatedBytesPrecise() : GetTotalAllocatedBytesApproximate(); + public static long GetTotalAllocatedBytes(bool precise = false) => precise ? GetTotalAllocatedBytesPrecise(out _) : GetTotalAllocatedBytesApproximate(); /// FCall that returns an approximate process-wide allocated byte count as a scalar; it takes no arguments and accesses no caller-supplied memory. [MethodImpl(MethodImplOptions.InternalCall)] @@ -456,7 +456,7 @@ public static long GetTotalMemory(bool forceFullCollection) /// QCall that returns a precise process-wide allocated byte count as a scalar; it takes no arguments and accesses no caller-supplied memory. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_GetTotalAllocatedBytesPrecise")] - private static safe partial long GetTotalAllocatedBytesPrecise(); + private static safe partial long GetTotalAllocatedBytesPrecise(out QCallException qcallException); /// FCall that enables full-GC notifications from scalar percentage arguments and returns a status flag; it accesses no caller-supplied memory. [MethodImpl(MethodImplOptions.InternalCall)] @@ -468,11 +468,11 @@ public static long GetTotalMemory(bool forceFullCollection) /// QCall that waits for an approaching full GC using a scalar timeout and returns a status code; it accesses no caller-supplied memory. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_WaitForFullGCApproach")] - private static safe partial int _WaitForFullGCApproach(int millisecondsTimeout); + private static safe partial int _WaitForFullGCApproach(int millisecondsTimeout, out QCallException qcallException); /// QCall that waits for full-GC completion using a scalar timeout and returns a status code; it accesses no caller-supplied memory. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_WaitForFullGCComplete")] - private static safe partial int _WaitForFullGCComplete(int millisecondsTimeout); + private static safe partial int _WaitForFullGCComplete(int millisecondsTimeout, out QCallException qcallException); public static void RegisterForFullGCNotification(int maxGenerationThreshold, int largeObjectHeapThreshold) { @@ -510,25 +510,25 @@ public static void CancelFullGCNotification() public static GCNotificationStatus WaitForFullGCApproach() { - return (GCNotificationStatus)_WaitForFullGCApproach(-1); + return (GCNotificationStatus)_WaitForFullGCApproach(-1, out _); } public static GCNotificationStatus WaitForFullGCApproach(int millisecondsTimeout) { ArgumentOutOfRangeException.ThrowIfLessThan(millisecondsTimeout, -1); - return (GCNotificationStatus)_WaitForFullGCApproach(millisecondsTimeout); + return (GCNotificationStatus)_WaitForFullGCApproach(millisecondsTimeout, out _); } public static GCNotificationStatus WaitForFullGCComplete() { - return (GCNotificationStatus)_WaitForFullGCComplete(-1); + return (GCNotificationStatus)_WaitForFullGCComplete(-1, out _); } public static GCNotificationStatus WaitForFullGCComplete(int millisecondsTimeout) { ArgumentOutOfRangeException.ThrowIfLessThan(millisecondsTimeout, -1); - return (GCNotificationStatus)_WaitForFullGCComplete(millisecondsTimeout); + return (GCNotificationStatus)_WaitForFullGCComplete(millisecondsTimeout, out _); } private enum StartNoGCRegionStatus @@ -558,7 +558,7 @@ private static bool StartNoGCRegionWorker(long totalSize, bool hasLohSize, long ArgumentOutOfRangeException.ThrowIfGreaterThan(lohSize, totalSize); } - StartNoGCRegionStatus status = (StartNoGCRegionStatus)_StartNoGCRegion(totalSize, hasLohSize, lohSize, disallowFullBlockingGC); + StartNoGCRegionStatus status = (StartNoGCRegionStatus)_StartNoGCRegion(totalSize, hasLohSize, lohSize, disallowFullBlockingGC, out _); switch (status) { case StartNoGCRegionStatus.NotEnoughMemory: @@ -595,7 +595,7 @@ public static bool TryStartNoGCRegion(long totalSize, long lohSize, bool disallo public static void EndNoGCRegion() { - EndNoGCRegionStatus status = (EndNoGCRegionStatus)_EndNoGCRegion(); + EndNoGCRegionStatus status = (EndNoGCRegionStatus)_EndNoGCRegion(out _); if (status == EndNoGCRegionStatus.NotInProgress) throw new InvalidOperationException(SR.InvalidOperationException_NoGCRegionNotInProgress); else if (status == EndNoGCRegionStatus.GCInduced) @@ -751,7 +751,7 @@ public static unsafe void RegisterNoGCRegionCallback(long totalSize, Action call pWorkItem->action = new GCHandle(callback); pWorkItem->callback = &Callback; - EnableNoGCRegionCallbackStatus status = (EnableNoGCRegionCallbackStatus)_EnableNoGCRegionCallback(pWorkItem, totalSize); + EnableNoGCRegionCallbackStatus status = (EnableNoGCRegionCallbackStatus)_EnableNoGCRegionCallback(pWorkItem, totalSize, out _); if (status != EnableNoGCRegionCallbackStatus.Success) { switch (status) @@ -790,17 +790,17 @@ static void Free(NoGCRegionCallbackFinalizerWorkItem* pWorkItem) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_EnableNoGCRegionCallback")] - private static unsafe partial EnableNoGCRegionCallbackStatus _EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, long totalSize); + private static unsafe partial EnableNoGCRegionCallbackStatus _EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, long totalSize, out QCallException qcallException); internal static long GetGenerationBudget(int generation) { - return _GetGenerationBudget(generation); + return _GetGenerationBudget(generation, out _); } /// The GC indexes its per-generation dynamic data with without /// bounds-checking it, so the caller must pass an existing generation number. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_GetGenerationBudget")] - internal static unsafe partial long _GetGenerationBudget(int generation); + internal static unsafe partial long _GetGenerationBudget(int generation, out QCallException qcallException); internal static void UnregisterMemoryLoadChangeNotification(Action notification) { @@ -861,7 +861,7 @@ static T[] AllocateNewArrayWorker(int length, bool pinned) } T[]? result = null; - AllocateNewArray(RuntimeTypeHandle.ToIntPtr(typeof(T[]).TypeHandle), length, flags, ObjectHandleOnStack.Create(ref result)); + AllocateNewArray(RuntimeTypeHandle.ToIntPtr(typeof(T[]).TypeHandle), length, flags, ObjectHandleOnStack.Create(ref result), out _); return result!; } } @@ -882,7 +882,7 @@ public static T[] AllocateArray(int length, bool pinned = false) // T[] rathe } T[]? result = null; - AllocateNewArray(RuntimeTypeHandle.ToIntPtr(typeof(T[]).TypeHandle), length, flags, ObjectHandleOnStack.Create(ref result)); + AllocateNewArray(RuntimeTypeHandle.ToIntPtr(typeof(T[]).TypeHandle), length, flags, ObjectHandleOnStack.Create(ref result), out _); return result!; } @@ -953,7 +953,7 @@ public static unsafe IReadOnlyDictionary GetConfigurationVariabl Configurations = new Dictionary() }; - _EnumerateConfigurationValues(&context, &ConfigCallback); + _EnumerateConfigurationValues(&context, &ConfigCallback, out _); return context.Configurations!; } @@ -966,7 +966,7 @@ internal enum GCConfigurationType } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_EnumerateConfigurationValues")] - internal static unsafe partial void _EnumerateConfigurationValues(void* configurationDictionary, delegate* unmanaged callback); + internal static unsafe partial void _EnumerateConfigurationValues(void* configurationDictionary, delegate* unmanaged callback, out QCallException qcallException); internal enum RefreshMemoryStatus { @@ -1021,7 +1021,7 @@ public static void RefreshMemoryLimit() HeapHardLimitLOHPercent = heapHardLimitLOHPercent, HeapHardLimitPOHPercent = heapHardLimitPOHPercent, }; - RefreshMemoryStatus status = (RefreshMemoryStatus)_RefreshMemoryLimit(heapHardLimitInfo); + RefreshMemoryStatus status = (RefreshMemoryStatus)_RefreshMemoryLimit(heapHardLimitInfo, out _); switch (status) { case RefreshMemoryStatus.HardLimitTooLow: @@ -1033,7 +1033,7 @@ public static void RefreshMemoryLimit() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_RefreshMemoryLimit")] - internal static partial int _RefreshMemoryLimit(GCHeapHardLimitInfo heapHardLimitInfo); + internal static partial int _RefreshMemoryLimit(GCHeapHardLimitInfo heapHardLimitInfo, out QCallException qcallException); internal struct GCHeapHardLimitInfo { diff --git a/src/coreclr/System.Private.CoreLib/src/System/IO/FileLoadException.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/IO/FileLoadException.CoreCLR.cs index ec1d8f194f2a70..2aec1ced65f505 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/IO/FileLoadException.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/IO/FileLoadException.CoreCLR.cs @@ -21,22 +21,22 @@ private FileLoadException(string? fileName, string? requestingAssemblyChain, int internal static string FormatFileLoadExceptionMessage(string? fileName, int hResult) { string? format = null; - GetFileLoadExceptionMessage(hResult, new StringHandleOnStack(ref format)); + GetFileLoadExceptionMessage(hResult, new StringHandleOnStack(ref format), out _); string? message = null; if (hResult == HResults.COR_E_BADEXEFORMAT) message = SR.Arg_BadImageFormatException; else - GetMessageForHR(hResult, new StringHandleOnStack(ref message)); + GetMessageForHR(hResult, new StringHandleOnStack(ref message), out _); return string.Format(format!, fileName, message); } [LibraryImport(RuntimeHelpers.QCall)] - private static partial void GetFileLoadExceptionMessage(int hResult, StringHandleOnStack retString); + private static partial void GetFileLoadExceptionMessage(int hResult, StringHandleOnStack retString, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "FileLoadException_GetMessageForHR")] - private static partial void GetMessageForHR(int hresult, StringHandleOnStack retString); + private static partial void GetMessageForHR(int hresult, StringHandleOnStack retString, out QCallException qcallException); // See clrex.cpp for native version. internal enum FileLoadExceptionKind diff --git a/src/coreclr/System.Private.CoreLib/src/System/IO/Stream.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/IO/Stream.CoreCLR.cs index 1a78a6cdf897c9..ee3c15c4d3a2c1 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/IO/Stream.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/IO/Stream.CoreCLR.cs @@ -11,7 +11,7 @@ public abstract unsafe partial class Stream { [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Stream_HasOverriddenSlow")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool HasOverriddenSlow(MethodTable* pMT, [MarshalAs(UnmanagedType.Bool)] bool isRead); + private static partial bool HasOverriddenSlow(MethodTable* pMT, [MarshalAs(UnmanagedType.Bool)] bool isRead, out QCallException qcallException); private bool HasOverriddenBeginEndRead() { @@ -24,7 +24,7 @@ private bool HasOverriddenBeginEndRead() [MethodImpl(MethodImplOptions.NoInlining)] static bool HasOverriddenReadSlow(MethodTable* pMT) - => HasOverriddenSlow(pMT, isRead: true); + => HasOverriddenSlow(pMT, isRead: true, out _); } private bool HasOverriddenBeginEndWrite() @@ -38,7 +38,7 @@ private bool HasOverriddenBeginEndWrite() [MethodImpl(MethodImplOptions.NoInlining)] static bool HasOverriddenWriteSlow(MethodTable* pMT) - => HasOverriddenSlow(pMT, isRead: false); + => HasOverriddenSlow(pMT, isRead: false, out _); } } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Object.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Object.CoreCLR.cs index 445666ea916fc0..156c52f9091631 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Object.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Object.CoreCLR.cs @@ -27,7 +27,7 @@ public unsafe Type GetType() protected internal unsafe object MemberwiseClone() { object clone = this; - RuntimeHelpers.AllocateUninitializedClone(ObjectHandleOnStack.Create(ref clone)); + RuntimeHelpers.AllocateUninitializedClone(ObjectHandleOnStack.Create(ref clone), out _); Debug.Assert(clone != this); // copy contents of "this" to the clone diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Assembly.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Assembly.CoreCLR.cs index 3ec13fc66b555d..381344a0cc6545 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Assembly.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Assembly.CoreCLR.cs @@ -55,12 +55,12 @@ public static Assembly Load(AssemblyName assemblyRef) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetExecutingAssembly")] - private static partial void GetExecutingAssemblyNative(StackCrawlMarkHandle stackMark, ObjectHandleOnStack retAssembly); + private static partial void GetExecutingAssemblyNative(StackCrawlMarkHandle stackMark, ObjectHandleOnStack retAssembly, out QCallException qcallException); internal static RuntimeAssembly GetExecutingAssembly(ref StackCrawlMark stackMark) { RuntimeAssembly? retAssembly = null; - GetExecutingAssemblyNative(new StackCrawlMarkHandle(ref stackMark), ObjectHandleOnStack.Create(ref retAssembly)); + GetExecutingAssemblyNative(new StackCrawlMarkHandle(ref stackMark), ObjectHandleOnStack.Create(ref retAssembly), out _); return retAssembly!; } @@ -86,12 +86,12 @@ public static Assembly GetCallingAssembly() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetEntryAssembly")] - private static partial void GetEntryAssemblyNative(ObjectHandleOnStack retAssembly); + private static partial void GetEntryAssemblyNative(ObjectHandleOnStack retAssembly, out QCallException qcallException); private static RuntimeAssembly? GetEntryAssemblyInternal() { RuntimeAssembly? entryAssembly = null; - GetEntryAssemblyNative(ObjectHandleOnStack.Create(ref entryAssembly)); + GetEntryAssemblyNative(ObjectHandleOnStack.Create(ref entryAssembly), out _); return entryAssembly; } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs index e36148a3455518..d1e2520dc91a1d 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs @@ -170,7 +170,7 @@ private static unsafe void ParseAsAssemblySpec(char* pAssemblyName, void* pAssem nameParts.SetVersion(parts._version, defaultValue: ushort.MaxValue); - InitializeAssemblySpec(&nameParts, pAssemblySpec); + InitializeAssemblySpec(&nameParts, pAssemblySpec, out _); } } catch (Exception ex) @@ -193,6 +193,6 @@ private static unsafe void CreateAssemblyName(AssemblyName* pResult, NativeAssem } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyName_InitializeAssemblySpec")] - private static unsafe partial void InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, void* pAssemblySpec); + private static unsafe partial void InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, void* pAssemblySpec, out QCallException qcallException); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicILGenerator.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicILGenerator.cs index 42fad545acf345..9744d4c9c62b36 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicILGenerator.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicILGenerator.cs @@ -673,7 +673,7 @@ private sealed class DestroyScout return; } - RuntimeMethodHandle.Destroy(m_methodHandle); + RuntimeMethodHandle.Destroy(m_methodHandle, out _); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicMethod.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicMethod.CoreCLR.cs index b337fa3dd8d25e..bcfe81973b792f 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicMethod.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicMethod.CoreCLR.cs @@ -51,7 +51,7 @@ public sealed override Delegate CreateDelegate(Type delegateType, object? target // Compile the method since accessibility checks are done as part of compilation GetMethodDescriptor(); IRuntimeMethodInfo? methodHandle = _methodHandle; - CompileMethod(methodHandle != null ? IRuntimeMethodInfo.GetValue(methodHandle) : RuntimeMethodHandleInternal.EmptyHandle); + CompileMethod(methodHandle != null ? IRuntimeMethodInfo.GetValue(methodHandle) : RuntimeMethodHandleInternal.EmptyHandle, out _); GC.KeepAlive(methodHandle); } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeAssemblyBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeAssemblyBuilder.cs index 474e2c68292709..e2850d2aca730f 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeAssemblyBuilder.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeAssemblyBuilder.cs @@ -117,7 +117,8 @@ private static unsafe partial void CreateDynamicAssembly(ObjectHandleOnStack ass NativeAssemblyNameParts* pAssemblyName, AssemblyHashAlgorithm hashAlgId, AssemblyBuilderAccess access, - ObjectHandleOnStack retAssembly); + ObjectHandleOnStack retAssembly, + out QCallException qcallException); private static unsafe RuntimeAssembly CreateDynamicAssembly(AssemblyLoadContext assemblyLoadContext, AssemblyName name, AssemblyBuilderAccess access) { @@ -145,7 +146,8 @@ private static unsafe RuntimeAssembly CreateDynamicAssembly(AssemblyLoadContext &nameParts, name.HashAlgorithm, access, - ObjectHandleOnStack.Create(ref retAssembly)); + ObjectHandleOnStack.Create(ref retAssembly), + out _); #pragma warning restore SYSLIB0037 } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeEventBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeEventBuilder.cs index cf3da5e026c41a..1aacb3d27edd3a 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeEventBuilder.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeEventBuilder.cs @@ -55,7 +55,8 @@ private void SetMethodSemantics(MethodBuilder mdBuilder, MethodSemanticsAttribut new QCallModule(ref module), m_evToken, semantics, - mdBuilder.MetadataToken); + mdBuilder.MetadataToken, + out _); } protected override void SetAddOnMethodCore(MethodBuilder mdBuilder) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeFieldBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeFieldBuilder.cs index e607b1523d7653..adbecceef032a5 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeFieldBuilder.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeFieldBuilder.cs @@ -38,7 +38,7 @@ internal RuntimeFieldBuilder(RuntimeTypeBuilder typeBuilder, string fieldName, T RuntimeModuleBuilder module = m_typeBuilder.GetModuleBuilder(); m_fieldTok = RuntimeTypeBuilder.DefineField(new QCallModule(ref module), - typeBuilder.TypeToken, fieldName, signature, sigLength, m_Attributes); + typeBuilder.TypeToken, fieldName, signature, sigLength, m_Attributes, out _); } #endregion @@ -47,7 +47,7 @@ internal RuntimeFieldBuilder(RuntimeTypeBuilder typeBuilder, string fieldName, T internal void SetData(byte[]? data, int size) { RuntimeModuleBuilder module = m_typeBuilder.GetModuleBuilder(); - RuntimeModuleBuilder.SetFieldRVAContent(new QCallModule(ref module), m_fieldTok, data, size); + RuntimeModuleBuilder.SetFieldRVAContent(new QCallModule(ref module), m_fieldTok, data, size, out _); } #endregion @@ -133,7 +133,7 @@ protected override void SetOffsetCore(int iOffset) m_typeBuilder.ThrowIfCreated(); RuntimeModuleBuilder module = m_typeBuilder.GetModuleBuilder(); - RuntimeTypeBuilder.SetFieldLayoutOffset(new QCallModule(ref module), m_fieldTok, iOffset); + RuntimeTypeBuilder.SetFieldLayoutOffset(new QCallModule(ref module), m_fieldTok, iOffset, out _); } protected override void SetConstantCore(object? defaultValue) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeMethodBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeMethodBuilder.cs index 6ee68d1843e80b..abbb99da5426db 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeMethodBuilder.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeMethodBuilder.cs @@ -596,14 +596,14 @@ private int GetTokenNoLock() byte[] sigBytes = GetMethodSignature().InternalGetSignature(out int sigLength); RuntimeModuleBuilder module = m_module; - int token = RuntimeTypeBuilder.DefineMethod(new QCallModule(ref module), m_containingType.MetadataToken, m_strName, sigBytes, sigLength, Attributes); + int token = RuntimeTypeBuilder.DefineMethod(new QCallModule(ref module), m_containingType.MetadataToken, m_strName, sigBytes, sigLength, Attributes, out _); m_token = token; if (m_inst != null) foreach (RuntimeGenericTypeParameterBuilder tb in m_inst) if (!tb.m_type.IsCreated()) tb.m_type.CreateType(); - RuntimeTypeBuilder.SetMethodImpl(new QCallModule(ref module), token, m_dwMethodImplFlags); + RuntimeTypeBuilder.SetMethodImpl(new QCallModule(ref module), token, m_dwMethodImplFlags, out _); return m_token; } @@ -658,7 +658,7 @@ protected override void SetImplementationFlagsCore(MethodImplAttributes attribut m_dwMethodImplFlags = attributes; RuntimeModuleBuilder module = m_module; - RuntimeTypeBuilder.SetMethodImpl(new QCallModule(ref module), MetadataToken, attributes); + RuntimeTypeBuilder.SetMethodImpl(new QCallModule(ref module), MetadataToken, attributes, out _); } protected override ILGenerator GetILGeneratorCore(int size) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeModuleBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeModuleBuilder.cs index dd094bda0c06dd..ccb23342af0c14 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeModuleBuilder.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeModuleBuilder.cs @@ -99,37 +99,37 @@ internal void CheckTypeNameConflict(string strTypeName, Type? enclosingType) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetTypeRef", StringMarshalling = StringMarshalling.Utf16)] - private static partial int GetTypeRef(QCallModule module, string strFullName, QCallModule refedModule, int tkResolution); + private static partial int GetTypeRef(QCallModule module, string strFullName, QCallModule refedModule, int tkResolution, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetMemberRef")] - private static partial int GetMemberRef(QCallModule module, QCallModule refedModule, int tr, int defToken); + private static partial int GetMemberRef(QCallModule module, QCallModule refedModule, int tr, int defToken, out QCallException qcallException); private int GetMemberRef(Module? refedModule, int tr, int defToken) { RuntimeModuleBuilder thisModule = this; RuntimeModule refedRuntimeModule = GetRuntimeModuleFromModule(refedModule); - return GetMemberRef(new QCallModule(ref thisModule), new QCallModule(ref refedRuntimeModule), tr, defToken); + return GetMemberRef(new QCallModule(ref thisModule), new QCallModule(ref refedRuntimeModule), tr, defToken, out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetMemberRefFromSignature", StringMarshalling = StringMarshalling.Utf16)] - private static partial int GetMemberRefFromSignature(QCallModule module, int tr, string methodName, byte[] signature, int length); + private static partial int GetMemberRefFromSignature(QCallModule module, int tr, string methodName, byte[] signature, int length, out QCallException qcallException); private int GetMemberRefFromSignature(int tr, string methodName, byte[] signature, int length) { RuntimeModuleBuilder thisModule = this; - return GetMemberRefFromSignature(new QCallModule(ref thisModule), tr, methodName, signature, length); + return GetMemberRefFromSignature(new QCallModule(ref thisModule), tr, methodName, signature, length, out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetMemberRefOfMethodInfo")] - private static partial int GetMemberRefOfMethodInfo(QCallModule module, int tr, RuntimeMethodHandleInternal method); + private static partial int GetMemberRefOfMethodInfo(QCallModule module, int tr, RuntimeMethodHandleInternal method, out QCallException qcallException); private int GetMemberRefOfMethodInfo(int tr, RuntimeMethodInfo method) { Debug.Assert(method != null); RuntimeModuleBuilder thisModule = this; - int result = GetMemberRefOfMethodInfo(new QCallModule(ref thisModule), tr, IRuntimeMethodInfo.GetValue(method)); + int result = GetMemberRefOfMethodInfo(new QCallModule(ref thisModule), tr, IRuntimeMethodInfo.GetValue(method), out _); GC.KeepAlive(method); return result; } @@ -139,39 +139,39 @@ private int GetMemberRefOfMethodInfo(int tr, RuntimeConstructorInfo method) Debug.Assert(method != null); RuntimeModuleBuilder thisModule = this; - int result = GetMemberRefOfMethodInfo(new QCallModule(ref thisModule), tr, IRuntimeMethodInfo.GetValue(method)); + int result = GetMemberRefOfMethodInfo(new QCallModule(ref thisModule), tr, IRuntimeMethodInfo.GetValue(method), out _); GC.KeepAlive(method); return result; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetMemberRefOfFieldInfo")] - private static partial int GetMemberRefOfFieldInfo(QCallModule module, int tkType, QCallTypeHandle declaringType, int tkField); + private static partial int GetMemberRefOfFieldInfo(QCallModule module, int tkType, QCallTypeHandle declaringType, int tkField, out QCallException qcallException); private int GetMemberRefOfFieldInfo(int tkType, RuntimeTypeHandle declaringType, RuntimeFieldInfo runtimeField) { Debug.Assert(runtimeField != null); RuntimeModuleBuilder thisModule = this; - return GetMemberRefOfFieldInfo(new QCallModule(ref thisModule), tkType, new QCallTypeHandle(ref declaringType), runtimeField.MetadataToken); + return GetMemberRefOfFieldInfo(new QCallModule(ref thisModule), tkType, new QCallTypeHandle(ref declaringType), runtimeField.MetadataToken, out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetTokenFromTypeSpec")] - private static partial int GetTokenFromTypeSpec(QCallModule pModule, byte[] signature, int length); + private static partial int GetTokenFromTypeSpec(QCallModule pModule, byte[] signature, int length, out QCallException qcallException); private int GetTokenFromTypeSpec(byte[] signature, int length) { RuntimeModuleBuilder thisModule = this; - return GetTokenFromTypeSpec(new QCallModule(ref thisModule), signature, length); + return GetTokenFromTypeSpec(new QCallModule(ref thisModule), signature, length, out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetArrayMethodToken", StringMarshalling = StringMarshalling.Utf16)] - private static partial int GetArrayMethodToken(QCallModule module, int tkTypeSpec, string methodName, byte[] signature, int sigLength); + private static partial int GetArrayMethodToken(QCallModule module, int tkTypeSpec, string methodName, byte[] signature, int sigLength, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetStringConstant", StringMarshalling = StringMarshalling.Utf16)] - private static partial int GetStringConstant(QCallModule module, string str, int length); + private static partial int GetStringConstant(QCallModule module, string str, int length, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_SetFieldRVAContent")] - internal static partial void SetFieldRVAContent(QCallModule module, int fdToken, byte[]? data, int length); + internal static partial void SetFieldRVAContent(QCallModule module, int fdToken, byte[]? data, int length, out QCallException qcallException); #endregion @@ -218,7 +218,7 @@ private int GetTypeRefNested(Type type, Module? refedModule) RuntimeModuleBuilder thisModule = this; RuntimeModule refedRuntimeModule = GetRuntimeModuleFromModule(refedModule); - return GetTypeRef(new QCallModule(ref thisModule), typeName, new QCallModule(ref refedRuntimeModule), tkResolution); + return GetTypeRef(new QCallModule(ref thisModule), typeName, new QCallModule(ref refedRuntimeModule), tkResolution, out _); } public override int GetMethodMetadataToken(ConstructorInfo constructor) @@ -1094,7 +1094,7 @@ internal int GetMethodTokenInternal(MethodBase method, Type[]? optionalParameter byte[] sigBytes = SignatureHelper.GetMethodSpecSigHelper( this, methodInfo.GetGenericArguments()).InternalGetSignature(out int sigLength); RuntimeModuleBuilder thisModule = this; - tk = RuntimeTypeBuilder.DefineMethodSpec(new QCallModule(ref thisModule), tk, sigBytes, sigLength); + tk = RuntimeTypeBuilder.DefineMethodSpec(new QCallModule(ref thisModule), tk, sigBytes, sigLength, out _); } else { @@ -1145,7 +1145,8 @@ private int GetArrayMethodTokenNoLock(Type arrayClass, string methodName, Callin RuntimeModuleBuilder thisModule = this; return GetArrayMethodToken(new QCallModule(ref thisModule), - typeSpec, methodName, sigBytes, length); + typeSpec, methodName, sigBytes, length, + out _); } protected override MethodInfo GetArrayMethodCore(Type arrayClass, string methodName, CallingConventions callingConvention, @@ -1251,7 +1252,7 @@ public override int GetStringMetadataToken(string stringConstant) // Returns a token representing a String constant. If the string // value has already been defined, the existing token will be returned. RuntimeModuleBuilder thisModule = this; - return GetStringConstant(new QCallModule(ref thisModule), stringConstant, stringConstant.Length); + return GetStringConstant(new QCallModule(ref thisModule), stringConstant, stringConstant.Length, out _); } public override int GetSignatureMetadataToken(SignatureHelper signature) @@ -1263,7 +1264,7 @@ public override int GetSignatureMetadataToken(SignatureHelper signature) // Get the signature in byte form. byte[] sigBytes = signature.InternalGetSignature(out int sigLength); RuntimeModuleBuilder thisModule = this; - return RuntimeTypeBuilder.GetTokenFromSig(new QCallModule(ref thisModule), sigBytes, sigLength); + return RuntimeTypeBuilder.GetTokenFromSig(new QCallModule(ref thisModule), sigBytes, sigLength, out _); } internal int GetSignatureToken(byte[] sigBytes, int sigLength) @@ -1274,7 +1275,7 @@ internal int GetSignatureToken(byte[] sigBytes, int sigLength) Buffer.BlockCopy(sigBytes, 0, localSigBytes, 0, sigBytes.Length); RuntimeModuleBuilder thisModule = this; - return RuntimeTypeBuilder.GetTokenFromSig(new QCallModule(ref thisModule), localSigBytes, sigLength); + return RuntimeTypeBuilder.GetTokenFromSig(new QCallModule(ref thisModule), localSigBytes, sigLength, out _); } #endregion diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeParameterBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeParameterBuilder.cs index 71980345a00776..c5bcbc88be5d8c 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeParameterBuilder.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeParameterBuilder.cs @@ -42,7 +42,8 @@ internal RuntimeParameterBuilder( _methodBuilder.MetadataToken, sequence, attributes, - paramName); + paramName, + out _); } internal int GetToken() diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimePropertyBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimePropertyBuilder.cs index 9c6bad8f0bb00a..c1947acbae873d 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimePropertyBuilder.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimePropertyBuilder.cs @@ -76,7 +76,8 @@ private void SetMethodSemantics(MethodBuilder mdBuilder, MethodSemanticsAttribut new QCallModule(ref module), m_tkProperty, semantics, - mdBuilder.MetadataToken); + mdBuilder.MetadataToken, + out _); } protected override void SetGetMethodCore(MethodBuilder mdBuilder) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeTypeBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeTypeBuilder.cs index 58fe7960ab3c6d..b5b79db5d0d1ed 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeTypeBuilder.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeTypeBuilder.cs @@ -58,23 +58,25 @@ public void Bake(RuntimeModuleBuilder module, int token) #region Private Static FCalls [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetParentType")] - private static partial void SetParentType(QCallModule module, int tdTypeDef, int tkParent); + private static partial void SetParentType(QCallModule module, int tdTypeDef, int tkParent, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_AddInterfaceImpl")] - private static partial void AddInterfaceImpl(QCallModule module, int tdTypeDef, int tkInterface); + private static partial void AddInterfaceImpl(QCallModule module, int tdTypeDef, int tkInterface, out QCallException qcallException); #endregion #region Internal Static FCalls [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineMethod", StringMarshalling = StringMarshalling.Utf16)] internal static partial int DefineMethod(QCallModule module, int tkParent, string name, byte[] signature, int sigLength, - MethodAttributes attributes); + MethodAttributes attributes, + out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineMethodSpec")] - internal static partial int DefineMethodSpec(QCallModule module, int tkParent, byte[] signature, int sigLength); + internal static partial int DefineMethodSpec(QCallModule module, int tkParent, byte[] signature, int sigLength, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineField", StringMarshalling = StringMarshalling.Utf16)] internal static partial int DefineField(QCallModule module, int tkParent, string name, byte[] signature, int sigLength, - FieldAttributes attributes); + FieldAttributes attributes, + out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetMethodIL")] private static partial void SetMethodIL(QCallModule module, int tk, [MarshalAs(UnmanagedType.Bool)] bool isInitLocals, @@ -82,54 +84,60 @@ private static partial void SetMethodIL(QCallModule module, int tk, [MarshalAs(U byte[] LocalSig, int sigLength, int maxStackSize, ExceptionHandler[]? exceptions, int numExceptions, - int[]? tokenFixups, int numTokenFixups); + int[]? tokenFixups, int numTokenFixups, + out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineCustomAttribute")] private static partial void DefineCustomAttribute(QCallModule module, int tkAssociate, int tkConstructor, - ReadOnlySpan attr, int attrLength); + ReadOnlySpan attr, int attrLength, + out QCallException qcallException); internal static void DefineCustomAttribute(RuntimeModuleBuilder module, int tkAssociate, int tkConstructor, ReadOnlySpan attr) { DefineCustomAttribute(new QCallModule(ref module), tkAssociate, tkConstructor, - attr, attr.Length); + attr, attr.Length, + out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineProperty", StringMarshalling = StringMarshalling.Utf16)] internal static partial int DefineProperty(QCallModule module, int tkParent, string name, PropertyAttributes attributes, - byte[] signature, int sigLength); + byte[] signature, int sigLength, + out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineEvent", StringMarshalling = StringMarshalling.Utf16)] - internal static partial int DefineEvent(QCallModule module, int tkParent, string name, EventAttributes attributes, int tkEventType); + internal static partial int DefineEvent(QCallModule module, int tkParent, string name, EventAttributes attributes, int tkEventType, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineMethodSemantics")] internal static partial void DefineMethodSemantics(QCallModule module, int tkAssociation, - MethodSemanticsAttributes semantics, int tkMethod); + MethodSemanticsAttributes semantics, int tkMethod, + out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineMethodImpl")] - internal static partial void DefineMethodImpl(QCallModule module, int tkType, int tkBody, int tkDecl); + internal static partial void DefineMethodImpl(QCallModule module, int tkType, int tkBody, int tkDecl, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetMethodImpl")] - internal static partial void SetMethodImpl(QCallModule module, int tkMethod, MethodImplAttributes MethodImplAttributes); + internal static partial void SetMethodImpl(QCallModule module, int tkMethod, MethodImplAttributes MethodImplAttributes, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetParamInfo", StringMarshalling = StringMarshalling.Utf16)] internal static partial int SetParamInfo(QCallModule module, int tkMethod, int iSequence, - ParameterAttributes iParamAttributes, string? strParamName); + ParameterAttributes iParamAttributes, string? strParamName, + out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_GetTokenFromSig")] - internal static partial int GetTokenFromSig(QCallModule module, byte[] signature, int sigLength); + internal static partial int GetTokenFromSig(QCallModule module, byte[] signature, int sigLength, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetFieldLayoutOffset")] - internal static partial void SetFieldLayoutOffset(QCallModule module, int fdToken, int iOffset); + internal static partial void SetFieldLayoutOffset(QCallModule module, int fdToken, int iOffset, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetClassLayout")] - internal static partial void SetClassLayout(QCallModule module, int tk, PackingSize iPackingSize, int iTypeSize); + internal static partial void SetClassLayout(QCallModule module, int tk, PackingSize iPackingSize, int iTypeSize, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetConstantValue")] - private static unsafe partial void SetConstantValue(QCallModule module, int tk, int corType, void* pValue); + private static unsafe partial void SetConstantValue(QCallModule module, int tk, int corType, void* pValue, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetPInvokeData", StringMarshalling = StringMarshalling.Utf16)] - private static partial void SetPInvokeData(QCallModule module, string DllName, string name, int token, int linkFlags); + private static partial void SetPInvokeData(QCallModule module, string DllName, string name, int token, int linkFlags, out QCallException qcallException); #endregion #region Internal\Private Static Members @@ -266,20 +274,20 @@ internal static unsafe void SetConstantValue(RuntimeModuleBuilder module, int tk case CorElementType.ELEMENT_TYPE_U8: case CorElementType.ELEMENT_TYPE_R8: fixed (byte* pData = &value.GetRawData()) - SetConstantValue(new QCallModule(ref module), tk, (int)corType, pData); + SetConstantValue(new QCallModule(ref module), tk, (int)corType, pData, out _); break; default: if (type == typeof(string)) { fixed (char* pString = (string)value) - SetConstantValue(new QCallModule(ref module), tk, (int)CorElementType.ELEMENT_TYPE_STRING, pString); + SetConstantValue(new QCallModule(ref module), tk, (int)CorElementType.ELEMENT_TYPE_STRING, pString, out _); } else if (type == typeof(DateTime)) { // date is a I8 representation long ticks = ((DateTime)value).Ticks; - SetConstantValue(new QCallModule(ref module), tk, (int)CorElementType.ELEMENT_TYPE_I8, &ticks); + SetConstantValue(new QCallModule(ref module), tk, (int)CorElementType.ELEMENT_TYPE_I8, &ticks, out _); } else { @@ -294,7 +302,7 @@ internal static unsafe void SetConstantValue(RuntimeModuleBuilder module, int tk // (See ECMA-335 II.15.4.1.4 "The .param directive" and II.22.9 "Constant" for details.) // This is how the Roslyn compilers generally encode `default(TValueType)` default values. - SetConstantValue(new QCallModule(ref module), tk, (int)CorElementType.ELEMENT_TYPE_CLASS, null); + SetConstantValue(new QCallModule(ref module), tk, (int)CorElementType.ELEMENT_TYPE_CLASS, null, out _); } } @@ -450,12 +458,13 @@ internal RuntimeTypeBuilder( } m_tdType = DefineType(new QCallModule(ref module), - name, tkParent, m_iAttr, tkEnclosingType, interfaceTokens!); + name, tkParent, m_iAttr, tkEnclosingType, interfaceTokens!, + out _); m_iPackingSize = iPackingSize; m_iTypeSize = iTypeSize; if ((m_iPackingSize != 0) || (m_iTypeSize != 0)) - SetClassLayout(new QCallModule(ref module), m_tdType, m_iPackingSize, m_iTypeSize); + SetClassLayout(new QCallModule(ref module), m_tdType, m_iPackingSize, m_iTypeSize, out _); m_module.AddType(FullName!, this); } @@ -535,14 +544,16 @@ protected override bool IsCreatedCore() #region FCalls [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineType", StringMarshalling = StringMarshalling.Utf16)] private static partial int DefineType(QCallModule module, - string fullname, int tkParent, TypeAttributes attributes, int tkEnclosingType, int[] interfaceTokens); + string fullname, int tkParent, TypeAttributes attributes, int tkEnclosingType, int[] interfaceTokens, + out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineGenericParam", StringMarshalling = StringMarshalling.Utf16)] private static partial int DefineGenericParam(QCallModule module, - string name, int tkParent, GenericParameterAttributes attributes, int position, int[] constraints); + string name, int tkParent, GenericParameterAttributes attributes, int position, int[] constraints, + out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_TermCreateClass")] - private static partial void TermCreateClass(QCallModule module, int tk, ObjectHandleOnStack type); + private static partial void TermCreateClass(QCallModule module, int tk, ObjectHandleOnStack type, out QCallException qcallException); #endregion #region Internal Methods @@ -1071,7 +1082,7 @@ protected override void DefineMethodOverrideCore(MethodInfo methodInfoBody, Meth int tkDecl = m_module.GetMethodMetadataToken(methodInfoDeclaration); RuntimeModuleBuilder module = m_module; - DefineMethodImpl(new QCallModule(ref module), m_tdType, tkBody, tkDecl); + DefineMethodImpl(new QCallModule(ref module), m_tdType, tkBody, tkDecl, out _); } } @@ -1182,7 +1193,8 @@ protected override MethodBuilder DefinePInvokeMethodCore(string name, string dll dllName, entryName, token, - linkFlags); + linkFlags, + out _); method.SetToken(token); @@ -1409,7 +1421,8 @@ protected override PropertyBuilder DefinePropertyCore(string name, PropertyAttri name, attributes, sigBytes, - sigLength); + sigLength, + out _); // create the property builder now. return new RuntimePropertyBuilder( @@ -1445,7 +1458,8 @@ protected override EventBuilder DefineEventCore(string name, EventAttributes att m_tdType, name, attributes, - tkType); + tkType, + out _); // create the property builder now. return new RuntimeEventBuilder( @@ -1527,7 +1541,8 @@ protected override TypeInfo CreateTypeInfoCore() int declMember = m_declMeth == null ? m_DeclaringType!.m_tdType : m_declMeth.MetadataToken; m_tdType = DefineGenericParam(new QCallModule(ref module), - m_strName!, declMember, m_genParamAttributes, m_genParamPos, constraints); + m_strName!, declMember, m_genParamAttributes, m_genParamPos, constraints, + out _); if (m_ca != null) { @@ -1546,7 +1561,7 @@ protected override TypeInfo CreateTypeInfoCore() // Check for global typebuilder if (((m_tdType & 0x00FFFFFF) != 0) && ((tkParent & 0x00FFFFFF) != 0)) { - SetParentType(new QCallModule(ref module), m_tdType, tkParent); + SetParentType(new QCallModule(ref module), m_tdType, tkParent, out _); } if (m_inst != null) @@ -1621,7 +1636,8 @@ protected override TypeInfo CreateTypeInfoCore() body, (body != null) ? body.Length : 0, localSig, sigLength, maxStack, exceptions, (exceptions != null) ? exceptions.Length : 0, - tokenFixups, (tokenFixups != null) ? tokenFixups.Length : 0); + tokenFixups, (tokenFixups != null) ? tokenFixups.Length : 0, + out _); if (m_module.ContainingAssemblyBuilder._access == AssemblyBuilderAccess.Run) { @@ -1635,7 +1651,7 @@ protected override TypeInfo CreateTypeInfoCore() // Terminate the process. RuntimeType? cls = null; - TermCreateClass(new QCallModule(ref module), m_tdType, ObjectHandleOnStack.Create(ref cls)); + TermCreateClass(new QCallModule(ref module), m_tdType, ObjectHandleOnStack.Create(ref cls), out _); if (!m_isHiddenGlobalType) { @@ -1696,7 +1712,7 @@ protected override void AddInterfaceImplementationCore([DynamicallyAccessedMembe int tkInterface = m_module.GetTypeTokenInternal(interfaceType); RuntimeModuleBuilder module = m_module; - AddInterfaceImpl(new QCallModule(ref module), m_tdType, tkInterface); + AddInterfaceImpl(new QCallModule(ref module), m_tdType, tkInterface, out _); m_typeInterfaces!.Add(interfaceType); } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/LoaderAllocator.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/LoaderAllocator.cs index 0a377941f053a2..402cc500cd9d39 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/LoaderAllocator.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/LoaderAllocator.cs @@ -28,7 +28,7 @@ internal sealed partial class LoaderAllocatorScout [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "LoaderAllocator_Destroy")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool Destroy(IntPtr nativeLoaderAllocator); + private static partial bool Destroy(IntPtr nativeLoaderAllocator, out QCallException qcallException); ~LoaderAllocatorScout() { @@ -36,7 +36,7 @@ internal sealed partial class LoaderAllocatorScout return; // Destroy returns false if the managed LoaderAllocator is still alive. - if (!Destroy(m_nativeLoaderAllocator)) + if (!Destroy(m_nativeLoaderAllocator, out _)) { // Somebody might have been holding a reference on us via weak handle. // We will keep trying. It will be hopefully released eventually. diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs index 885a3305a4e292..74bca408680722 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs @@ -244,7 +244,8 @@ private static unsafe partial bool GetMarshalAs( out int marshalTypeLength, out byte* marshalCookie, out int marshalCookieLength, - out int iidParamIndex); + out int iidParamIndex, + out QCallException qcallException); internal static unsafe MarshalAsAttribute GetMarshalAs(ConstArray nativeType, RuntimeModule scope) { @@ -262,7 +263,8 @@ internal static unsafe MarshalAsAttribute GetMarshalAs(ConstArray nativeType, Ru out int marshalTypeLength, out byte* marshalCookieRaw, out int marshalCookieLength, - out int iidParamIndex)) + out int iidParamIndex, + out _)) { throw new BadImageFormatException(); } @@ -334,7 +336,7 @@ internal MetadataImport(RuntimeModule module) #endregion [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MetadataImport_Enum")] - private static unsafe partial void Enum(IntPtr scope, int type, int parent, ref int length, int* shortResult, ObjectHandleOnStack longResult); + private static unsafe partial void Enum(IntPtr scope, int type, int parent, ref int length, int* shortResult, ObjectHandleOnStack longResult, out QCallException qcallException); public unsafe void Enum(MetadataTokenType type, int parent, out MetadataEnumResult result) { @@ -342,7 +344,7 @@ public unsafe void Enum(MetadataTokenType type, int parent, out MetadataEnumResu int length = MetadataEnumResult.SmallIntArrayLength; fixed (int* p = &result._smallResult.e) { - Enum(m_metadataImport2, (int)type, parent, ref length, p, ObjectHandleOnStack.Create(ref result._largeResult)); + Enum(m_metadataImport2, (int)type, parent, ref length, p, ObjectHandleOnStack.Create(ref result._largeResult), out _); } result._length = length; } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/AssemblyExtensions.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/AssemblyExtensions.cs index cf47e46a60fcb6..b1d9f209ddef53 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/AssemblyExtensions.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/AssemblyExtensions.cs @@ -11,7 +11,7 @@ public static partial class AssemblyExtensions { [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_InternalTryGetRawMetadata")] [return: MarshalAs(UnmanagedType.Bool)] - private static unsafe partial bool InternalTryGetRawMetadata(QCallAssembly assembly, ref byte* blob, ref int length); + private static unsafe partial bool InternalTryGetRawMetadata(QCallAssembly assembly, ref byte* blob, ref int length, out QCallException qcallException); /// /// Retrieves the metadata section of the assembly, for use with . @@ -44,7 +44,7 @@ public static unsafe bool TryGetRawMetadata(this Assembly assembly, out byte* bl RuntimeAssembly rtAsm = runtimeAssembly; - return InternalTryGetRawMetadata(new QCallAssembly(ref rtAsm), ref blob, ref length); + return InternalTryGetRawMetadata(new QCallAssembly(ref rtAsm), ref blob, ref length, out _); } } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs index f0b6774ac45503..1dd95afa872cc8 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs @@ -11,11 +11,11 @@ namespace System.Reflection.Metadata public static partial class MetadataUpdater { [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_ApplyUpdate")] - private static unsafe partial void ApplyUpdate(QCallAssembly assembly, byte* metadataDelta, int metadataDeltaLength, byte* ilDelta, int ilDeltaLength, byte* pdbDelta, int pdbDeltaLength); + private static unsafe partial void ApplyUpdate(QCallAssembly assembly, byte* metadataDelta, int metadataDeltaLength, byte* ilDelta, int ilDeltaLength, byte* pdbDelta, int pdbDeltaLength, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_IsApplyUpdateSupported")] [return: MarshalAs(UnmanagedType.Bool)] - private static unsafe partial bool IsApplyUpdateSupported(); + private static unsafe partial bool IsApplyUpdateSupported(out QCallException qcallException); /// /// Updates the specified assembly using the provided metadata, IL and PDB deltas. @@ -47,7 +47,7 @@ public static void ApplyUpdate(Assembly assembly, ReadOnlySpan metadataDel RuntimeAssembly rtAsm = runtimeAssembly; fixed (byte* metadataDeltaPtr = metadataDelta, ilDeltaPtr = ilDelta, pdbDeltaPtr = pdbDelta) { - ApplyUpdate(new QCallAssembly(ref rtAsm), metadataDeltaPtr, metadataDelta.Length, ilDeltaPtr, ilDelta.Length, pdbDeltaPtr, pdbDelta.Length); + ApplyUpdate(new QCallAssembly(ref rtAsm), metadataDeltaPtr, metadataDelta.Length, ilDeltaPtr, ilDelta.Length, pdbDeltaPtr, pdbDelta.Length, out _); } } } @@ -61,6 +61,6 @@ public static void ApplyUpdate(Assembly assembly, ReadOnlySpan metadataDel /// Returns true if the apply assembly update is enabled and available. /// [FeatureSwitchDefinition("System.Reflection.Metadata.MetadataUpdater.IsSupported")] - public static bool IsSupported { get; } = IsApplyUpdateSupported(); + public static bool IsSupported { get; } = IsApplyUpdateSupported(out _); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MethodBase.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MethodBase.CoreCLR.cs index 8e8d7148b3974e..b62ebddd2fe547 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MethodBase.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MethodBase.CoreCLR.cs @@ -37,14 +37,14 @@ public abstract partial class MethodBase : MemberInfo } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MethodBase_GetCurrentMethod")] - private static partial RuntimeMethodHandleInternal GetCurrentMethod(StackCrawlMarkHandle stackMark); + private static partial RuntimeMethodHandleInternal GetCurrentMethod(StackCrawlMarkHandle stackMark, out QCallException qcallException); [RequiresUnreferencedCode("Metadata for the method might be incomplete or removed")] [DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod public static MethodBase? GetCurrentMethod() { StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; - RuntimeMethodHandleInternal methodHandle = GetCurrentMethod(new StackCrawlMarkHandle(ref stackMark)); + RuntimeMethodHandleInternal methodHandle = GetCurrentMethod(new StackCrawlMarkHandle(ref stackMark), out _); return methodHandle.IsNullHandle() ? null : RuntimeType.GetMethodBase(null, methodHandle); } #endregion diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs index ea39af1c950455..d2fb7abe4ec7da 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs @@ -70,13 +70,14 @@ public override event ModuleResolveEventHandler? ModuleResolve [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetCodeBase")] [return: MarshalAs(UnmanagedType.Bool)] private static partial bool GetCodeBase(QCallAssembly assembly, - StringHandleOnStack retString); + StringHandleOnStack retString, + out QCallException qcallException); internal string? GetCodeBase() { string? codeBase = null; RuntimeAssembly runtimeAssembly = this; - if (GetCodeBase(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref codeBase))) + if (GetCodeBase(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref codeBase), out _)) { return codeBase; } @@ -139,7 +140,7 @@ public override AssemblyName GetName(bool copiedName) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetFullName")] - private static partial void GetFullName(QCallAssembly assembly, StringHandleOnStack retString); + private static partial void GetFullName(QCallAssembly assembly, StringHandleOnStack retString, out QCallException qcallException); public override string? FullName { @@ -150,7 +151,7 @@ public override string? FullName { string? s = null; RuntimeAssembly runtimeAssembly = this; - GetFullName(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref s)); + GetFullName(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref s), out _); Interlocked.CompareExchange(ref m_fullname, s, null); } @@ -159,7 +160,7 @@ public override string? FullName } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetEntryPoint")] - private static partial void GetEntryPoint(QCallAssembly assembly, ObjectHandleOnStack retMethod); + private static partial void GetEntryPoint(QCallAssembly assembly, ObjectHandleOnStack retMethod, out QCallException qcallException); public override MethodInfo? EntryPoint { @@ -167,7 +168,7 @@ public override MethodInfo? EntryPoint { IRuntimeMethodInfo? methodHandle = null; RuntimeAssembly runtimeAssembly = this; - GetEntryPoint(new QCallAssembly(ref runtimeAssembly), ObjectHandleOnStack.Create(ref methodHandle)); + GetEntryPoint(new QCallAssembly(ref runtimeAssembly), ObjectHandleOnStack.Create(ref methodHandle), out _); if (methodHandle == null) return null; @@ -182,14 +183,16 @@ private static partial void GetTypeCore(QCallAssembly assembly, string typeName, ReadOnlySpan nestedTypeNames, int nestedTypeNamesLength, - ObjectHandleOnStack retType); + ObjectHandleOnStack retType, + out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetTypeCoreIgnoreCase", StringMarshalling = StringMarshalling.Utf16)] private static partial void GetTypeCoreIgnoreCase(QCallAssembly assembly, string typeName, ReadOnlySpan nestedTypeNames, int nestedTypeNamesLength, - ObjectHandleOnStack retType); + ObjectHandleOnStack retType, + out QCallException qcallException); internal Type? GetTypeCore(string typeName, ReadOnlySpan nestedTypeNames, bool throwOnFileNotFound, bool ignoreCase) { @@ -204,7 +207,8 @@ private static partial void GetTypeCoreIgnoreCase(QCallAssembly assembly, typeName, nestedTypeNames, nestedTypeNames.Length, - ObjectHandleOnStack.Create(ref type)); + ObjectHandleOnStack.Create(ref type), + out _); } else { @@ -212,7 +216,8 @@ private static partial void GetTypeCoreIgnoreCase(QCallAssembly assembly, typeName, nestedTypeNames, nestedTypeNames.Length, - ObjectHandleOnStack.Create(ref type)); + ObjectHandleOnStack.Create(ref type), + out _); } } catch (FileNotFoundException) when (!throwOnFileNotFound) @@ -235,14 +240,14 @@ private static partial void GetTypeCoreIgnoreCase(QCallAssembly assembly, } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetExportedTypes")] - private static partial void GetExportedTypes(QCallAssembly assembly, ObjectHandleOnStack retTypes); + private static partial void GetExportedTypes(QCallAssembly assembly, ObjectHandleOnStack retTypes, out QCallException qcallException); [RequiresUnreferencedCode("Types might be removed")] public override Type[] GetExportedTypes() { Type[]? types = null; RuntimeAssembly runtimeAssembly = this; - GetExportedTypes(new QCallAssembly(ref runtimeAssembly), ObjectHandleOnStack.Create(ref types)); + GetExportedTypes(new QCallAssembly(ref runtimeAssembly), ObjectHandleOnStack.Create(ref types), out _); return types!; } @@ -269,7 +274,8 @@ public override bool IsCollectible [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetResource", StringMarshalling = StringMarshalling.Utf16)] private static unsafe partial byte* GetResource(QCallAssembly assembly, string resourceName, - out uint length); + out uint length, + out QCallException qcallException); // Load a resource based on the NameSpace of the type. public override Stream? GetManifestResourceStream(Type type, string name) @@ -290,7 +296,7 @@ public override bool IsCollectible public override unsafe Stream? GetManifestResourceStream(string name) { RuntimeAssembly runtimeAssembly = this; - byte* pbInMemoryResource = GetResource(new QCallAssembly(ref runtimeAssembly), name, out uint length); + byte* pbInMemoryResource = GetResource(new QCallAssembly(ref runtimeAssembly), name, out uint length, out _); if (pbInMemoryResource != null) { @@ -388,7 +394,8 @@ internal static unsafe RuntimeAssembly InternalLoad(AssemblyName assemblyName, new StackCrawlMarkHandle(ref stackMark), throwOnFileNotFound, ObjectHandleOnStack.Create(ref assemblyLoadContext), - ObjectHandleOnStack.Create(ref retAssembly)); + ObjectHandleOnStack.Create(ref retAssembly), + out _); } return retAssembly!; @@ -400,20 +407,21 @@ private static unsafe partial void InternalLoad(NativeAssemblyNameParts* pAssemb StackCrawlMarkHandle stackMark, [MarshalAs(UnmanagedType.Bool)] bool throwOnFileNotFound, ObjectHandleOnStack assemblyLoadContext, - ObjectHandleOnStack retAssembly); + ObjectHandleOnStack retAssembly, + out QCallException qcallException); public override bool ReflectionOnly => false; // Returns the module in this assembly with name 'name' [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetModule", StringMarshalling = StringMarshalling.Utf16)] - private static partial void GetModule(QCallAssembly assembly, string name, ObjectHandleOnStack retModule); + private static partial void GetModule(QCallAssembly assembly, string name, ObjectHandleOnStack retModule, out QCallException qcallException); public override Module? GetModule(string name) { Module? retModule = null; RuntimeAssembly runtimeAssembly = this; - GetModule(new QCallAssembly(ref runtimeAssembly), name, ObjectHandleOnStack.Create(ref retModule)); + GetModule(new QCallAssembly(ref runtimeAssembly), name, ObjectHandleOnStack.Create(ref retModule), out _); return retModule; } @@ -461,27 +469,27 @@ public override FileStream[] GetFiles(bool getResourceModules) // Returns the names of all the resources [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetManifestResourceNames")] - private static partial void GetManifestResourceNames(QCallAssembly assembly, ObjectHandleOnStack retResourceNames); + private static partial void GetManifestResourceNames(QCallAssembly assembly, ObjectHandleOnStack retResourceNames, out QCallException qcallException); // Returns the names of all the resources public override string[] GetManifestResourceNames() { string[]? resourceNames = null; RuntimeAssembly runtimeAssembly = this; - GetManifestResourceNames(new QCallAssembly(ref runtimeAssembly), ObjectHandleOnStack.Create(ref resourceNames)); + GetManifestResourceNames(new QCallAssembly(ref runtimeAssembly), ObjectHandleOnStack.Create(ref resourceNames), out _); return resourceNames!; } // Returns the names of all the resources [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetReferencedAssemblies")] - private static partial void GetReferencedAssemblies(QCallAssembly assembly, ObjectHandleOnStack retReferencedAssemblies); + private static partial void GetReferencedAssemblies(QCallAssembly assembly, ObjectHandleOnStack retReferencedAssemblies, out QCallException qcallException); [RequiresUnreferencedCode("Assembly references might be removed")] public override AssemblyName[] GetReferencedAssemblies() { AssemblyName[]? referencedAssemblies = null; RuntimeAssembly runtimeAssembly = this; - GetReferencedAssemblies(new QCallAssembly(ref runtimeAssembly), ObjectHandleOnStack.Create(ref referencedAssemblies)); + GetReferencedAssemblies(new QCallAssembly(ref runtimeAssembly), ObjectHandleOnStack.Create(ref referencedAssemblies), out _); return referencedAssemblies!; } @@ -489,7 +497,8 @@ public override AssemblyName[] GetReferencedAssemblies() private static partial int GetManifestResourceInfo(QCallAssembly assembly, string resourceName, ObjectHandleOnStack assemblyRef, - StringHandleOnStack retFileName); + StringHandleOnStack retFileName, + out QCallException qcallException); public override ManifestResourceInfo? GetManifestResourceInfo(string resourceName) { @@ -498,7 +507,8 @@ private static partial int GetManifestResourceInfo(QCallAssembly assembly, RuntimeAssembly runtimeAssembly = this; int location = GetManifestResourceInfo(new QCallAssembly(ref runtimeAssembly), resourceName, ObjectHandleOnStack.Create(ref retAssembly), - new StringHandleOnStack(ref fileName)); + new StringHandleOnStack(ref fileName), + out _); if (location == -1) return null; @@ -508,7 +518,7 @@ private static partial int GetManifestResourceInfo(QCallAssembly assembly, } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetLocation")] - private static partial void GetLocation(QCallAssembly assembly, StringHandleOnStack retString); + private static partial void GetLocation(QCallAssembly assembly, StringHandleOnStack retString, out QCallException qcallException); public override string Location { @@ -517,14 +527,14 @@ public override string Location string? location = null; RuntimeAssembly runtimeAssembly = this; - GetLocation(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref location)); + GetLocation(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref location), out _); return AssemblyLoadContext.ResolveAssemblyLocation(this, location!); } } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetImageRuntimeVersion")] - private static partial void GetImageRuntimeVersion(QCallAssembly assembly, StringHandleOnStack retString); + private static partial void GetImageRuntimeVersion(QCallAssembly assembly, StringHandleOnStack retString, out QCallException qcallException); public override string ImageRuntimeVersion { @@ -532,7 +542,7 @@ public override string ImageRuntimeVersion { string? s = null; RuntimeAssembly runtimeAssembly = this; - GetImageRuntimeVersion(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref s)); + GetImageRuntimeVersion(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref s), out _); return s!; } } @@ -547,24 +557,25 @@ private static partial void GetVersion(QCallAssembly assembly, out int majVer, out int minVer, out int buildNum, - out int revNum); + out int revNum, + out QCallException qcallException); private Version GetVersion() { RuntimeAssembly runtimeAssembly = this; - GetVersion(new QCallAssembly(ref runtimeAssembly), out int majorVer, out int minorVer, out int build, out int revision); + GetVersion(new QCallAssembly(ref runtimeAssembly), out int majorVer, out int minorVer, out int build, out int revision, out _); return new Version(majorVer, minorVer, build, revision); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetLocale")] - private static partial void GetLocale(QCallAssembly assembly, StringHandleOnStack retString); + private static partial void GetLocale(QCallAssembly assembly, StringHandleOnStack retString, out QCallException qcallException); private CultureInfo GetLocale() { string? locale = null; RuntimeAssembly runtimeAssembly = this; - GetLocale(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref locale)); + GetLocale(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref locale), out _); if (locale == null) return CultureInfo.InvariantCulture; @@ -586,42 +597,42 @@ public override bool IsDynamic } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetSimpleName")] - private static partial void GetSimpleName(QCallAssembly assembly, StringHandleOnStack retSimpleName); + private static partial void GetSimpleName(QCallAssembly assembly, StringHandleOnStack retSimpleName, out QCallException qcallException); internal string GetSimpleName() { RuntimeAssembly runtimeAssembly = this; string? name = null; - GetSimpleName(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref name)); + GetSimpleName(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref name), out _); return name!; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetHashAlgorithm")] - private static partial AssemblyHashAlgorithm GetHashAlgorithm(QCallAssembly assembly); + private static partial AssemblyHashAlgorithm GetHashAlgorithm(QCallAssembly assembly, out QCallException qcallException); private AssemblyHashAlgorithm GetHashAlgorithm() { RuntimeAssembly runtimeAssembly = this; - return GetHashAlgorithm(new QCallAssembly(ref runtimeAssembly)); + return GetHashAlgorithm(new QCallAssembly(ref runtimeAssembly), out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetFlags")] - private static partial AssemblyNameFlags GetFlags(QCallAssembly assembly); + private static partial AssemblyNameFlags GetFlags(QCallAssembly assembly, out QCallException qcallException); private AssemblyNameFlags GetFlags() { RuntimeAssembly runtimeAssembly = this; - return GetFlags(new QCallAssembly(ref runtimeAssembly)); + return GetFlags(new QCallAssembly(ref runtimeAssembly), out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetPublicKey")] - private static partial void GetPublicKey(QCallAssembly assembly, ObjectHandleOnStack retPublicKey); + private static partial void GetPublicKey(QCallAssembly assembly, ObjectHandleOnStack retPublicKey, out QCallException qcallException); internal byte[]? GetPublicKey() { byte[]? publicKey = null; RuntimeAssembly runtimeAssembly = this; - GetPublicKey(new QCallAssembly(ref runtimeAssembly), ObjectHandleOnStack.Create(ref publicKey)); + GetPublicKey(new QCallAssembly(ref runtimeAssembly), ObjectHandleOnStack.Create(ref publicKey), out _); return publicKey; } @@ -674,7 +685,8 @@ public override Assembly GetSatelliteAssembly(CultureInfo culture, Version? vers private static partial void GetModules(QCallAssembly assembly, [MarshalAs(UnmanagedType.Bool)] bool loadIfNotFound, [MarshalAs(UnmanagedType.Bool)] bool getResourceModules, - ObjectHandleOnStack retModuleHandles); + ObjectHandleOnStack retModuleHandles, + out QCallException qcallException); private RuntimeModule[] GetModulesInternal(bool loadIfNotFound, bool getResourceModules) @@ -682,7 +694,7 @@ private RuntimeModule[] GetModulesInternal(bool loadIfNotFound, RuntimeModule[]? modules = null; RuntimeAssembly runtimeAssembly = this; - GetModules(new QCallAssembly(ref runtimeAssembly), loadIfNotFound, getResourceModules, ObjectHandleOnStack.Create(ref modules)); + GetModules(new QCallAssembly(ref runtimeAssembly), loadIfNotFound, getResourceModules, ObjectHandleOnStack.Create(ref modules), out _); return modules!; } @@ -704,7 +716,7 @@ private RuntimeModule GetManifestModule() static RuntimeModule GetManifestModuleWorker(RuntimeAssembly assembly) { RuntimeModule? module = null; - GetManifestModuleSlow(ObjectHandleOnStack.Create(ref assembly), ObjectHandleOnStack.Create(ref module)); + GetManifestModuleSlow(ObjectHandleOnStack.Create(ref assembly), ObjectHandleOnStack.Create(ref module), out _); return module!; } } @@ -713,7 +725,7 @@ static RuntimeModule GetManifestModuleWorker(RuntimeAssembly assembly) private static extern RuntimeModule? GetManifestModule(RuntimeAssembly assembly); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyHandle_GetManifestModuleSlow")] - private static partial void GetManifestModuleSlow(ObjectHandleOnStack assembly, ObjectHandleOnStack module); + private static partial void GetManifestModuleSlow(ObjectHandleOnStack assembly, ObjectHandleOnStack module, out QCallException qcallException); [MethodImpl(MethodImplOptions.InternalCall)] private static extern int GetTokenInternal(RuntimeAssembly assembly); @@ -745,7 +757,7 @@ public sealed override Type[] GetForwardedTypes() ObjectHandleOnStack pType = ObjectHandleOnStack.Create(ref type); try { - GetForwardedType(pAssembly, mdtExternalType, pType); + GetForwardedType(pAssembly, mdtExternalType, pType, out _); if (type == null) continue; // mdtExternalType was not a forwarder entry. } @@ -801,6 +813,6 @@ private static void AddPublicNestedTypes(Type type, List types, List GetFullyQualifiedName(); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeModule_GetTypes")] - private static partial void GetTypes(QCallModule module, ObjectHandleOnStack retTypes, ObjectHandleOnStack retExceptions); + private static partial void GetTypes(QCallModule module, ObjectHandleOnStack retTypes, ObjectHandleOnStack retExceptions, out QCallException qcallException); internal RuntimeType[] GetDefinedTypes() { RuntimeType[]? types = null; Exception[]? exceptions = null; RuntimeModule thisAsLocal = this; - GetTypes(new QCallModule(ref thisAsLocal), ObjectHandleOnStack.Create(ref types), ObjectHandleOnStack.Create(ref exceptions)); + GetTypes(new QCallModule(ref thisAsLocal), ObjectHandleOnStack.Create(ref types), ObjectHandleOnStack.Create(ref exceptions), out _); if (exceptions is not null) throw new ReflectionTypeLoadException(types, exceptions, SR.ReflectionTypeLoad_LoadFailed); @@ -482,7 +482,7 @@ public override MethodInfo[] GetMethods(BindingFlags bindingFlags) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeModule_GetScopeName")] - private static partial void GetScopeName(QCallModule module, StringHandleOnStack retString); + private static partial void GetScopeName(QCallModule module, StringHandleOnStack retString, out QCallException qcallException); public override string ScopeName { @@ -490,7 +490,7 @@ public override string ScopeName { string? scopeName = null; RuntimeModule thisAsLocal = this; - GetScopeName(new QCallModule(ref thisAsLocal), new StringHandleOnStack(ref scopeName)); + GetScopeName(new QCallModule(ref thisAsLocal), new StringHandleOnStack(ref scopeName), out _); return scopeName!; } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs index fb79062fe8f54b..19d1894400385a 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs @@ -198,7 +198,7 @@ private static unsafe void GetTypeHelper(char* pTypeName, RuntimeAssembly* pRequ } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "UnsafeAccessors_ResolveGenericParamToTypeHandle")] - private static partial IntPtr ResolveGenericParamToTypeHandle(IntPtr unsafeAccessorMethod, [MarshalAs(UnmanagedType.Bool)] bool isMethodParam, uint paramIndex); + private static partial IntPtr ResolveGenericParamToTypeHandle(IntPtr unsafeAccessorMethod, [MarshalAs(UnmanagedType.Bool)] bool isMethodParam, uint paramIndex, out QCallException qcallException); [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "TypeNameResolver.GetType is marked as RequiresUnreferencedCode.")] @@ -269,7 +269,7 @@ private static unsafe void GetTypeHelper(char* pTypeName, RuntimeAssembly* pRequ } Debug.Assert(_unsafeAccessorMethod != IntPtr.Zero); - IntPtr typeHandle = ResolveGenericParamToTypeHandle(_unsafeAccessorMethod, isMethodParam, paramIndex); + IntPtr typeHandle = ResolveGenericParamToTypeHandle(_unsafeAccessorMethod, isMethodParam, paramIndex, out _); if (typeHandle == IntPtr.Zero) { throw new TypeLoadException(SR.Format(SR.TypeLoad_ResolveType, escapedTypeName), typeName: escapedTypeName); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs index 90f74e4b867457..c9c913bb09da47 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs @@ -321,10 +321,10 @@ internal static void ReturnTaskContinuation(RuntimeAsyncTaskContinuation continu #if !NATIVEAOT [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AsyncHelpers_AddContinuationToExInternal")] - private static unsafe partial void AddContinuationToExInternal(void* diagnosticIP, ObjectHandleOnStack ex); + private static unsafe partial void AddContinuationToExInternal(void* diagnosticIP, ObjectHandleOnStack ex, out QCallException qcallException); internal static unsafe void AddContinuationToExInternal(void* diagnosticIP, Exception e) - => AddContinuationToExInternal(diagnosticIP, ObjectHandleOnStack.Create(ref e)); + => AddContinuationToExInternal(diagnosticIP, ObjectHandleOnStack.Create(ref e), out _); #endif private static unsafe Continuation AllocContinuation(Continuation prevContinuation, MethodTable* contMT) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastHelpers.cs index 52d3a6234aee98..f99a94bac52260 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastHelpers.cs @@ -15,31 +15,31 @@ internal static unsafe partial class CastHelpers internal static int[]? s_table; [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThrowInvalidCastException")] - private static partial void ThrowInvalidCastExceptionInternal(void* fromTypeHnd, void* toTypeHnd); + private static partial void ThrowInvalidCastExceptionInternal(void* fromTypeHnd, void* toTypeHnd, out QCallException qcallException); [DoesNotReturn] internal static void ThrowInvalidCastException(void* fromTypeHnd, void* toTypeHnd) { - ThrowInvalidCastExceptionInternal(fromTypeHnd, toTypeHnd); + ThrowInvalidCastExceptionInternal(fromTypeHnd, toTypeHnd, out _); throw null!; // Provide hint to the inliner that this method does not return } [DoesNotReturn] internal static void ThrowInvalidCastException(object fromType, void* toTypeHnd) { - ThrowInvalidCastExceptionInternal(RuntimeHelpers.GetMethodTable(fromType), toTypeHnd); + ThrowInvalidCastExceptionInternal(RuntimeHelpers.GetMethodTable(fromType), toTypeHnd, out _); GC.KeepAlive(fromType); throw null!; // Provide hint to the inliner that this method does not return } [LibraryImport(RuntimeHelpers.QCall)] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool IsInstanceOf_NoCacheLookup(void *toTypeHnd, [MarshalAs(UnmanagedType.Bool)] bool throwCastException, ObjectHandleOnStack obj); + private static partial bool IsInstanceOf_NoCacheLookup(void *toTypeHnd, [MarshalAs(UnmanagedType.Bool)] bool throwCastException, ObjectHandleOnStack obj, out QCallException qcallException); [MethodImpl(MethodImplOptions.NoInlining)] private static object? IsInstanceOfAny_NoCacheLookup(void* toTypeHnd, object obj) { - if (IsInstanceOf_NoCacheLookup(toTypeHnd, false, ObjectHandleOnStack.Create(ref obj))) + if (IsInstanceOf_NoCacheLookup(toTypeHnd, false, ObjectHandleOnStack.Create(ref obj), out _)) { return obj; } @@ -49,7 +49,7 @@ internal static void ThrowInvalidCastException(object fromType, void* toTypeHnd) [MethodImpl(MethodImplOptions.NoInlining)] private static object ChkCastAny_NoCacheLookup(void* toTypeHnd, object obj) { - IsInstanceOf_NoCacheLookup(toTypeHnd, true, ObjectHandleOnStack.Create(ref obj)); + IsInstanceOf_NoCacheLookup(toTypeHnd, true, ObjectHandleOnStack.Create(ref obj), out _); return obj; } @@ -577,7 +577,7 @@ private static bool AreTypesEquivalent(MethodTable* pMTa, MethodTable* pMTb) return false; } - return RuntimeHelpers.AreTypesEquivalent(pMTa, pMTb); + return RuntimeHelpers.AreTypesEquivalent(pMTa, pMTb, out _); } #endif // FEATURE_TYPEEQUIVALENCE diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/GenericsHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/GenericsHelpers.cs index da1a4dec2bf57c..991c67a079421d 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/GenericsHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/GenericsHelpers.cs @@ -13,7 +13,7 @@ namespace System.Runtime.CompilerServices; internal static unsafe partial class GenericsHelpers { [LibraryImport(RuntimeHelpers.QCall)] - private static partial IntPtr GenericHandleWorker(IntPtr pMD, IntPtr pMT, IntPtr signature, uint dictionaryIndexAndSlot, IntPtr pModule); + private static partial IntPtr GenericHandleWorker(IntPtr pMD, IntPtr pMT, IntPtr signature, uint dictionaryIndexAndSlot, IntPtr pModule, out QCallException qcallException); public struct GenericHandleArgs { @@ -25,24 +25,24 @@ public struct GenericHandleArgs [DebuggerHidden] public static IntPtr Method(IntPtr methodHnd, IntPtr signature) { - return GenericHandleWorker(methodHnd, IntPtr.Zero, signature, 0xFFFFFFFF, IntPtr.Zero); + return GenericHandleWorker(methodHnd, IntPtr.Zero, signature, 0xFFFFFFFF, IntPtr.Zero, out _); } [DebuggerHidden] public static IntPtr MethodWithSlotAndModule(IntPtr methodHnd, GenericHandleArgs * pArgs) { - return GenericHandleWorker(methodHnd, IntPtr.Zero, pArgs->signature, pArgs->dictionaryIndexAndSlot, pArgs->module); + return GenericHandleWorker(methodHnd, IntPtr.Zero, pArgs->signature, pArgs->dictionaryIndexAndSlot, pArgs->module, out _); } [DebuggerHidden] public static IntPtr Class(IntPtr classHnd, IntPtr signature) { - return GenericHandleWorker(IntPtr.Zero, classHnd, signature, 0xFFFFFFFF, IntPtr.Zero); + return GenericHandleWorker(IntPtr.Zero, classHnd, signature, 0xFFFFFFFF, IntPtr.Zero, out _); } [DebuggerHidden] public static IntPtr ClassWithSlotAndModule(IntPtr classHnd, GenericHandleArgs * pArgs) { - return GenericHandleWorker(IntPtr.Zero, classHnd, pArgs->signature, pArgs->dictionaryIndexAndSlot, pArgs->module); + return GenericHandleWorker(IntPtr.Zero, classHnd, pArgs->signature, pArgs->dictionaryIndexAndSlot, pArgs->module, out _); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/InitHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/InitHelpers.cs index e2a52e15d1ab70..69831a9e633ca1 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/InitHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/InitHelpers.cs @@ -12,13 +12,13 @@ namespace System.Runtime.CompilerServices internal static unsafe partial class InitHelpers { [LibraryImport(RuntimeHelpers.QCall)] - private static partial void InitClassHelper(MethodTable* mt); + private static partial void InitClassHelper(MethodTable* mt, out QCallException qcallException); [DebuggerHidden] [MethodImpl(MethodImplOptions.NoInlining)] internal static void InitClassSlow(MethodTable* mt) { - InitClassHelper(mt); + InitClassHelper(mt, out _); } [DebuggerHidden] diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallException.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallException.cs new file mode 100644 index 00000000000000..a95a86487cff85 --- /dev/null +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallException.cs @@ -0,0 +1,46 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; +using System.Runtime.ExceptionServices; +using System.Runtime.InteropServices.Marshalling; +using System.Threading; + +namespace System.Runtime.CompilerServices +{ + [NativeMarshalling(typeof(QCallExceptionMarshaller))] + internal readonly struct QCallException + { + } + + [CustomMarshaller(typeof(QCallException), MarshalMode.ManagedToUnmanagedOut, typeof(QCallExceptionMarshaller))] + internal struct QCallExceptionMarshaller + { + private readonly Thread _thread; + + public QCallExceptionMarshaller() + { + _thread = Thread.CurrentThread; + } + + public void FromUnmanaged(int exceptionPending) + { + Debug.Assert(exceptionPending is 0 or 1); + + if (exceptionPending == 1) + { + Exception exception = _thread.GetAndClearQCallException(); + + // Throw during unmarshalling so QCall exception propagation remains as close as + // possible to throwing directly from native code, as QCalls did previously. + ExceptionDispatchInfo.Throw(exception); + } + } + + public QCallException ToManaged() => default; + + public void Free() + { + } + } +} diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs index 0b268cc6e12bee..706b9fe783c397 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs @@ -26,7 +26,7 @@ public static unsafe void InitializeArray(Array array, RuntimeFieldHandle fldHan IRuntimeFieldInfo fldInfo = fldHandle.GetRuntimeFieldInfo(); - if (!RuntimeFieldHandle.GetRVAFieldInfo(fldInfo.Value, out void* address, out uint size)) + if (!RuntimeFieldHandle.GetRVAFieldInfo(fldInfo.Value, out void* address, out uint size, out _)) throw new ArgumentException(SR.Argument_BadFieldForInitializeArray); // Note that we do not check that the field is actually in the PE file that is initializing @@ -96,7 +96,7 @@ private static unsafe ref byte GetSpanDataFrom( IRuntimeFieldInfo fldInfo = fldHandle.GetRuntimeFieldInfo(); - if (!RuntimeFieldHandle.GetRVAFieldInfo(fldInfo.Value, out void* data, out uint totalSize)) + if (!RuntimeFieldHandle.GetRVAFieldInfo(fldInfo.Value, out void* data, out uint totalSize, out _)) throw new ArgumentException(SR.Argument_BadFieldForInitializeArray); TypeHandle th = targetTypeHandle.GetRuntimeType().GetNativeTypeHandle(); @@ -164,7 +164,7 @@ private static unsafe ref byte GetSpanDataFrom( // exception when it ran. [LibraryImport(QCall, EntryPoint = "ReflectionInvocation_RunClassConstructor")] - private static partial void RunClassConstructor(QCallTypeHandle type); + private static partial void RunClassConstructor(QCallTypeHandle type, out QCallException qcallException); [RequiresUnreferencedCode("Trimmer can't guarantee existence of class constructor")] public static void RunClassConstructor(RuntimeTypeHandle type) @@ -172,7 +172,7 @@ public static void RunClassConstructor(RuntimeTypeHandle type) RuntimeType rt = type.GetRuntimeType() ?? throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized, nameof(type)); - RunClassConstructor(new QCallTypeHandle(ref rt)); + RunClassConstructor(new QCallTypeHandle(ref rt), out _); } // RunModuleConstructor causes the module constructor for the given type to be triggered @@ -184,21 +184,21 @@ public static void RunClassConstructor(RuntimeTypeHandle type) // exception when it ran. [LibraryImport(QCall, EntryPoint = "ReflectionInvocation_RunModuleConstructor")] - private static partial void RunModuleConstructor(QCallModule module); + private static partial void RunModuleConstructor(QCallModule module, out QCallException qcallException); public static void RunModuleConstructor(ModuleHandle module) { RuntimeModule rm = module.GetRuntimeModule() ?? throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized, nameof(module)); - RunModuleConstructor(new QCallModule(ref rm)); + RunModuleConstructor(new QCallModule(ref rm), out _); } [LibraryImport(QCall, EntryPoint = "ReflectionInvocation_CompileMethod")] - internal static partial void CompileMethod(RuntimeMethodHandleInternal method); + internal static partial void CompileMethod(RuntimeMethodHandleInternal method, out QCallException qcallException); [LibraryImport(QCall, EntryPoint = "ReflectionInvocation_PrepareMethod")] - private static unsafe partial void PrepareMethod(RuntimeMethodHandleInternal method, IntPtr* pInstantiation, int cInstantiation); + private static unsafe partial void PrepareMethod(RuntimeMethodHandleInternal method, IntPtr* pInstantiation, int cInstantiation, out QCallException qcallException); public static void PrepareMethod(RuntimeMethodHandle method) => PrepareMethod(method, null); @@ -213,14 +213,14 @@ public static unsafe void PrepareMethod(RuntimeMethodHandle method, RuntimeTypeH ReadOnlySpan instantiationHandles = RuntimeTypeHandle.CopyRuntimeTypeHandles(instantiation, stackScratch: stackalloc IntPtr[8]); fixed (IntPtr* pInstantiation = instantiationHandles) { - PrepareMethod(IRuntimeMethodInfo.GetValue(methodInfo), pInstantiation, instantiationHandles.Length); + PrepareMethod(IRuntimeMethodInfo.GetValue(methodInfo), pInstantiation, instantiationHandles.Length, out _); GC.KeepAlive(instantiation); GC.KeepAlive(methodInfo); } } [LibraryImport(QCall, EntryPoint = "ReflectionInvocation_PrepareDelegate")] - private static partial void PrepareDelegate(ObjectHandleOnStack d); + private static partial void PrepareDelegate(ObjectHandleOnStack d, out QCallException qcallException); public static void PrepareDelegate(Delegate d) { @@ -229,7 +229,7 @@ public static void PrepareDelegate(Delegate d) return; } - PrepareDelegate(ObjectHandleOnStack.Create(ref d)); + PrepareDelegate(ObjectHandleOnStack.Create(ref d), out _); } /// @@ -241,7 +241,7 @@ public static void PrepareDelegate(Delegate d) internal static extern safe int TryGetHashCode(object? o); [LibraryImport(QCall, EntryPoint = "ObjectNative_GetHashCodeSlow")] - private static partial int GetHashCodeSlow(ObjectHandleOnStack o); + private static partial int GetHashCodeSlow(ObjectHandleOnStack o, out QCallException qcallException); public static int GetHashCode(object? o) { @@ -259,7 +259,7 @@ static int GetHashCodeWorker(object? o) { return 0; } - return GetHashCodeSlow(ObjectHandleOnStack.Create(ref o)); + return GetHashCodeSlow(ObjectHandleOnStack.Create(ref o), out _); } } @@ -350,7 +350,7 @@ public static object GetUninitializedObject( } [LibraryImport(QCall, EntryPoint = "ObjectNative_AllocateUninitializedClone")] - internal static partial void AllocateUninitializedClone(ObjectHandleOnStack objHandle); + internal static partial void AllocateUninitializedClone(ObjectHandleOnStack objHandle, out QCallException qcallException); /// true if given type is bitwise equatable (memcmp can be used for equality checking) /// @@ -475,7 +475,7 @@ internal static unsafe bool ObjectHasComponentSize(object obj) [LibraryImport(QCall, EntryPoint = "MethodTable_AreTypesEquivalent")] [return: MarshalAs(UnmanagedType.Bool)] - internal static unsafe partial bool AreTypesEquivalent(MethodTable* pMTa, MethodTable* pMTb); + internal static unsafe partial bool AreTypesEquivalent(MethodTable* pMTa, MethodTable* pMTb, out QCallException qcallException); /// Allocates memory that's associated with the and is freed if and when the is unloaded. /// The type associated with the allocated memory. @@ -492,7 +492,7 @@ public static IntPtr AllocateTypeAssociatedMemory(Type type, int size) ArgumentOutOfRangeException.ThrowIfNegative(size); - return AllocateTypeAssociatedMemory(new QCallTypeHandle(ref rt), (uint)size); + return AllocateTypeAssociatedMemory(new QCallTypeHandle(ref rt), (uint)size, out _); } /// Allocates aligned memory that's associated with the and is freed if and when the is unloaded. @@ -518,20 +518,20 @@ public static IntPtr AllocateTypeAssociatedMemory(Type type, int size, int align ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_AlignmentMustBePow2); } - return AllocateTypeAssociatedMemoryAligned(new QCallTypeHandle(ref rt), (uint)size, (uint)alignment); + return AllocateTypeAssociatedMemoryAligned(new QCallTypeHandle(ref rt), (uint)size, (uint)alignment, out _); } [LibraryImport(QCall, EntryPoint = "RuntimeTypeHandle_AllocateTypeAssociatedMemory")] - private static partial IntPtr AllocateTypeAssociatedMemory(QCallTypeHandle type, uint size); + private static partial IntPtr AllocateTypeAssociatedMemory(QCallTypeHandle type, uint size, out QCallException qcallException); [LibraryImport(QCall, EntryPoint = "RuntimeTypeHandle_AllocateTypeAssociatedMemoryAligned")] - private static partial IntPtr AllocateTypeAssociatedMemoryAligned(QCallTypeHandle type, uint size, uint alignment); + private static partial IntPtr AllocateTypeAssociatedMemoryAligned(QCallTypeHandle type, uint size, uint alignment, out QCallException qcallException); [MethodImpl(MethodImplOptions.InternalCall)] private static extern unsafe TailCallArgBuffer* GetTailCallArgBuffer(); [LibraryImport(QCall, EntryPoint = "TailCallHelp_AllocTailCallArgBufferInternal")] - private static unsafe partial TailCallArgBuffer* AllocTailCallArgBufferInternal(int size); + private static unsafe partial TailCallArgBuffer* AllocTailCallArgBufferInternal(int size, out QCallException qcallException); private const int TAILCALLARGBUFFER_ACTIVE = 0; // private const int TAILCALLARGBUFFER_INSTARG_ONLY = 1; @@ -550,7 +550,7 @@ public static IntPtr AllocateTypeAssociatedMemory(Type type, int size, int align buffer = AllocTailCallArgBufferWorker(size); [MethodImpl(MethodImplOptions.NoInlining)] - static TailCallArgBuffer* AllocTailCallArgBufferWorker(int size) => AllocTailCallArgBufferInternal(size); + static TailCallArgBuffer* AllocTailCallArgBufferWorker(int size) => AllocTailCallArgBufferInternal(size, out _); } Debug.Assert(buffer != null); Debug.Assert(buffer->Size >= size); @@ -1317,11 +1317,11 @@ private static bool CanCastToWorker(TypeHandle srcTH, TypeHandle destTH, bool nu return nullableCast; } - return CanCastTo_NoCacheLookup(srcTH.m_asTAddr, destTH.m_asTAddr) != Interop.BOOL.FALSE; + return CanCastTo_NoCacheLookup(srcTH.m_asTAddr, destTH.m_asTAddr, out _) != Interop.BOOL.FALSE; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeHandle_CanCastTo_NoCacheLookup")] - private static partial Interop.BOOL CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd); + private static partial Interop.BOOL CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd, out QCallException qcallException); [SuppressGCTransition] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeHandle_GetCorElementType")] diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/StaticsHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/StaticsHelpers.cs index 1504418b3b4321..01aa79c0f9e792 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/StaticsHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/StaticsHelpers.cs @@ -12,10 +12,10 @@ namespace System.Runtime.CompilerServices internal static unsafe partial class StaticsHelpers { [LibraryImport(RuntimeHelpers.QCall)] - private static partial void GetThreadStaticsByIndex(ByteRefOnStack result, int index, [MarshalAs(UnmanagedType.Bool)] bool gcStatics); + private static partial void GetThreadStaticsByIndex(ByteRefOnStack result, int index, [MarshalAs(UnmanagedType.Bool)] bool gcStatics, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall)] - private static partial void GetThreadStaticsByMethodTable(ByteRefOnStack result, MethodTable* pMT, [MarshalAs(UnmanagedType.Bool)] bool gcStatics); + private static partial void GetThreadStaticsByMethodTable(ByteRefOnStack result, MethodTable* pMT, [MarshalAs(UnmanagedType.Bool)] bool gcStatics, out QCallException qcallException); [Intrinsic] private static ref byte VolatileReadAsByref(ref IntPtr address) => ref VolatileReadAsByref(ref address); @@ -140,7 +140,7 @@ private static bool IsIndexAllocated(int index) private static ref byte GetNonGCThreadStaticsByIndexSlow(int index) { ByteRef result = default; - GetThreadStaticsByIndex(ByteRefOnStack.Create(ref result), index, false); + GetThreadStaticsByIndex(ByteRefOnStack.Create(ref result), index, false, out _); return ref result.Value; } @@ -149,7 +149,7 @@ private static ref byte GetNonGCThreadStaticsByIndexSlow(int index) private static ref byte GetGCThreadStaticsByIndexSlow(int index) { ByteRef result = default; - GetThreadStaticsByIndex(ByteRefOnStack.Create(ref result), index, true); + GetThreadStaticsByIndex(ByteRefOnStack.Create(ref result), index, true, out _); return ref result.Value; } @@ -158,7 +158,7 @@ private static ref byte GetGCThreadStaticsByIndexSlow(int index) private static ref byte GetNonGCThreadStaticBaseSlow(MethodTable* mt) { ByteRef result = default; - GetThreadStaticsByMethodTable(ByteRefOnStack.Create(ref result), mt, false); + GetThreadStaticsByMethodTable(ByteRefOnStack.Create(ref result), mt, false, out _); return ref result.Value; } @@ -167,7 +167,7 @@ private static ref byte GetNonGCThreadStaticBaseSlow(MethodTable* mt) private static ref byte GetGCThreadStaticBaseSlow(MethodTable* mt) { ByteRef result = default; - GetThreadStaticsByMethodTable(ByteRefOnStack.Create(ref result), mt, true); + GetThreadStaticsByMethodTable(ByteRefOnStack.Create(ref result), mt, true, out _); return ref result.Value; } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/VirtualDispatchHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/VirtualDispatchHelpers.cs index c9564984c38b41..a73a0fcef0ab7b 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/VirtualDispatchHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/VirtualDispatchHelpers.cs @@ -59,13 +59,13 @@ private struct VirtualFunctionPointerArgs private static GenericCache s_virtualFunctionPointerCache = new GenericCache(InitialCacheSize, MaximumCacheSize); [LibraryImport(RuntimeHelpers.QCall)] - private static unsafe partial IntPtr ResolveVirtualFunctionPointer(ObjectHandleOnStack obj, IntPtr classHandle, IntPtr methodHandle); + private static unsafe partial IntPtr ResolveVirtualFunctionPointer(ObjectHandleOnStack obj, IntPtr classHandle, IntPtr methodHandle, out QCallException qcallException); [MethodImpl(MethodImplOptions.NoInlining)] [DebuggerHidden] private static IntPtr VirtualFunctionPointerSlow(object obj, IntPtr classHandle, IntPtr methodHandle) { - IntPtr result = ResolveVirtualFunctionPointer(ObjectHandleOnStack.Create(ref obj), classHandle, methodHandle); + IntPtr result = ResolveVirtualFunctionPointer(ObjectHandleOnStack.Create(ref obj), classHandle, methodHandle, out _); s_virtualFunctionPointerCache.TrySet(new VirtualResolutionData(RuntimeHelpers.GetMethodTable(obj), classHandle, methodHandle), result); GC.KeepAlive(obj); return result; diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/ControlledExecution.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/ControlledExecution.CoreCLR.cs index 67971b90caa1b6..cf367307731df8 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/ControlledExecution.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/ControlledExecution.CoreCLR.cs @@ -1,4 +1,4 @@ -// Licensed to the .NET Foundation under one or more agreements. +// Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. using System.Runtime.CompilerServices; @@ -119,7 +119,7 @@ public static void Run(Action action, CancellationToken cancellationToken) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_Abort")] - private static partial void AbortThread(ThreadHandle thread); + private static partial void AbortThread(ThreadHandle thread, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_ResetAbort")] [SuppressGCTransition] @@ -142,7 +142,7 @@ public void Cancel() try { // Abort the thread executing the action (which may be the current thread). - AbortThread(_thread.GetNativeHandle()); + AbortThread(_thread.GetNativeHandle(), out _); } finally { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/DependentHandle.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/DependentHandle.cs index 8fb031b15a3e91..29d020079d2ec1 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/DependentHandle.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/DependentHandle.cs @@ -241,10 +241,10 @@ public void Dispose() [MethodImpl(MethodImplOptions.NoInlining)] private static IntPtr InternalAllocWithGCTransition(object? target, object? dependent) - => _InternalAllocWithGCTransition(ObjectHandleOnStack.Create(ref target), ObjectHandleOnStack.Create(ref dependent)); + => _InternalAllocWithGCTransition(ObjectHandleOnStack.Create(ref target), ObjectHandleOnStack.Create(ref dependent), out _); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DependentHandle_InternalAllocWithGCTransition")] - private static partial IntPtr _InternalAllocWithGCTransition(ObjectHandleOnStack target, ObjectHandleOnStack dependent); + private static partial IntPtr _InternalAllocWithGCTransition(ObjectHandleOnStack target, ObjectHandleOnStack dependent, out QCallException qcallException); #if DEBUG [MethodImpl(MethodImplOptions.InternalCall)] @@ -273,9 +273,9 @@ private static IntPtr InternalAllocWithGCTransition(object? target, object? depe [MethodImpl(MethodImplOptions.NoInlining)] private static void InternalFreeWithGCTransition(IntPtr dependentHandle) - => _InternalFreeWithGCTransition(dependentHandle); + => _InternalFreeWithGCTransition(dependentHandle, out _); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DependentHandle_InternalFreeWithGCTransition")] - private static partial void _InternalFreeWithGCTransition(IntPtr dependentHandle); + private static partial void _InternalFreeWithGCTransition(IntPtr dependentHandle, out QCallException qcallException); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/ExceptionServices/InternalCalls.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/ExceptionServices/InternalCalls.cs index 9a31bf082fb1c5..1ea4d69b22da03 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/ExceptionServices/InternalCalls.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/ExceptionServices/InternalCalls.cs @@ -18,25 +18,26 @@ internal static partial class InternalCalls [DebuggerHidden] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "SfiInit")] [return: MarshalAs(UnmanagedType.U1)] - internal static unsafe partial bool RhpSfiInit(ref StackFrameIterator pThis, void* pStackwalkCtx, [MarshalAs(UnmanagedType.U1)] bool instructionFault, bool* fIsExceptionIntercepted); + internal static unsafe partial bool RhpSfiInit(ref StackFrameIterator pThis, void* pStackwalkCtx, [MarshalAs(UnmanagedType.U1)] bool instructionFault, bool* fIsExceptionIntercepted, out QCallException qcallException); [StackTraceHidden] [DebuggerHidden] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "SfiNext")] [return: MarshalAs(UnmanagedType.U1)] - internal static unsafe partial bool RhpSfiNext(ref StackFrameIterator pThis, uint* uExCollideClauseIdx, bool* fUnwoundReversePInvoke, bool* fIsExceptionIntercepted); + internal static unsafe partial bool RhpSfiNext(ref StackFrameIterator pThis, uint* uExCollideClauseIdx, bool* fUnwoundReversePInvoke, bool* fIsExceptionIntercepted, out QCallException qcallException); [StackTraceHidden] [DebuggerHidden] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "CallFilterFunclet")] [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool RhpCallFilterFunclet( - ObjectHandleOnStack exceptionObj, byte* pFilterIP, void* pvRegDisplay); + ObjectHandleOnStack exceptionObj, byte* pFilterIP, void* pvRegDisplay, + out QCallException qcallException); [StackTraceHidden] [DebuggerHidden] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AppendExceptionStackFrame")] - internal static unsafe partial void RhpAppendExceptionStackFrame(ObjectHandleOnStack exceptionObj, IntPtr ip, UIntPtr sp, int flags, EH.ExInfo* exInfo); + internal static unsafe partial void RhpAppendExceptionStackFrame(ObjectHandleOnStack exceptionObj, IntPtr ip, UIntPtr sp, int flags, EH.ExInfo* exInfo, out QCallException qcallException); [StackTraceHidden] [DebuggerHidden] @@ -49,6 +50,6 @@ internal static unsafe partial bool RhpCallFilterFunclet( [DebuggerHidden] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EHEnumNext")] [return: MarshalAs(UnmanagedType.U1)] - internal static unsafe partial bool RhpEHEnumNext(void* pEHEnum, void* pEHClause); + internal static unsafe partial bool RhpEHEnumNext(void* pEHEnum, void* pEHClause, out QCallException qcallException); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.CoreCLR.cs index 23dea958040b58..c2ff63664fd551 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.CoreCLR.cs @@ -163,15 +163,15 @@ private static IntPtr GetTaggedImplCurrentVersion() internal sealed partial class ManagedObjectWrapperHolder { [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ComWrappers_RegisterIsRootedCallback")] - private static partial void RegisterIsRootedCallback(); + private static partial void RegisterIsRootedCallback(out QCallException qcallException); private static IntPtr AllocateRefCountedHandle(ManagedObjectWrapperHolder holder) { - return AllocateRefCountedHandle(ObjectHandleOnStack.Create(ref holder)); + return AllocateRefCountedHandle(ObjectHandleOnStack.Create(ref holder), out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ComWrappers_AllocateRefCountedHandle")] - private static partial IntPtr AllocateRefCountedHandle(ObjectHandleOnStack obj); + private static partial IntPtr AllocateRefCountedHandle(ObjectHandleOnStack obj, out QCallException qcallException); } } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/GCHandle.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/GCHandle.CoreCLR.cs index d6458b09c025ca..711aa49921940f 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/GCHandle.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/GCHandle.CoreCLR.cs @@ -20,10 +20,10 @@ internal static IntPtr InternalAlloc(object? value, GCHandleType type) [MethodImpl(MethodImplOptions.NoInlining)] private static IntPtr InternalAllocWithGCTransition(object? value, GCHandleType type) - => _InternalAllocWithGCTransition(ObjectHandleOnStack.Create(ref value), type); + => _InternalAllocWithGCTransition(ObjectHandleOnStack.Create(ref value), type, out _); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCHandle_InternalAllocWithGCTransition")] - private static partial IntPtr _InternalAllocWithGCTransition(ObjectHandleOnStack value, GCHandleType type); + private static partial IntPtr _InternalAllocWithGCTransition(ObjectHandleOnStack value, GCHandleType type, out QCallException qcallException); internal static void InternalFree(IntPtr handle) { @@ -36,10 +36,10 @@ internal static void InternalFree(IntPtr handle) [MethodImpl(MethodImplOptions.NoInlining)] private static void InternalFreeWithGCTransition(IntPtr dependentHandle) - => _InternalFreeWithGCTransition(dependentHandle); + => _InternalFreeWithGCTransition(dependentHandle, out _); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCHandle_InternalFreeWithGCTransition")] - private static partial void _InternalFreeWithGCTransition(IntPtr dependentHandle); + private static partial void _InternalFreeWithGCTransition(IntPtr dependentHandle, out QCallException qcallException); #if FEATURE_JAVAMARSHAL internal static object? InternalGetBridgeWait(IntPtr handle) @@ -49,7 +49,7 @@ private static void InternalFreeWithGCTransition(IntPtr dependentHandle) if (GCHandle.InternalTryGetBridgeWait(handle, ref target)) return target; - InternalGetBridgeWait(handle, ObjectHandleOnStack.Create(ref target)); + InternalGetBridgeWait(handle, ObjectHandleOnStack.Create(ref target), out _); return target; } @@ -58,7 +58,7 @@ private static void InternalFreeWithGCTransition(IntPtr dependentHandle) private static extern bool InternalTryGetBridgeWait(IntPtr handle, ref object? result); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCHandle_InternalGetBridgeWait")] - private static partial void InternalGetBridgeWait(IntPtr handle, ObjectHandleOnStack result); + private static partial void InternalGetBridgeWait(IntPtr handle, ObjectHandleOnStack result, out QCallException qcallException); #endif #if DEBUG diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Java/JavaMarshal.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Java/JavaMarshal.CoreCLR.cs index 51f0f5a3ddc669..935b20c3437e85 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Java/JavaMarshal.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Java/JavaMarshal.CoreCLR.cs @@ -42,7 +42,7 @@ public static unsafe void Initialize(delegate* unmanaged SizeOfHelper(new QCallTypeHandle(ref t), throwIfNotMarshalable); + => SizeOfHelper(new QCallTypeHandle(ref t), throwIfNotMarshalable, out _); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_SizeOfHelper")] - private static partial int SizeOfHelper(QCallTypeHandle t, [MarshalAs(UnmanagedType.Bool)] bool throwIfNotMarshalable); + private static partial int SizeOfHelper(QCallTypeHandle t, [MarshalAs(UnmanagedType.Bool)] bool throwIfNotMarshalable, out QCallException qcallException); [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern", Justification = "Trimming doesn't affect types eligible for marshalling. Different exception for invalid inputs doesn't matter.")] @@ -50,13 +50,13 @@ public static IntPtr OffsetOf(Type t, string fieldName) throw new ArgumentException(SR.Argument_MustBeRuntimeFieldInfo, nameof(fieldName)); } - nint offset = OffsetOf(rtField.GetFieldDesc()); + nint offset = OffsetOf(rtField.GetFieldDesc(), out _); GC.KeepAlive(rtField); return offset; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_OffsetOf")] - private static partial nint OffsetOf(IntPtr pFD); + private static partial nint OffsetOf(IntPtr pFD, out QCallException qcallException); [EditorBrowsable(EditorBrowsableState.Never)] [Obsolete("ReadByte(Object, Int32) may be unavailable in future releases.")] @@ -219,12 +219,12 @@ private static void PrelinkCore(MethodInfo m) throw new ArgumentException(SR.Argument_MustBeRuntimeMethodInfo, nameof(m)); } - InternalPrelink(IRuntimeMethodInfo.GetValue(rmi)); + InternalPrelink(IRuntimeMethodInfo.GetValue(rmi), out _); GC.KeepAlive(rmi); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_Prelink")] - private static partial void InternalPrelink(RuntimeMethodHandleInternal m); + private static partial void InternalPrelink(RuntimeMethodHandleInternal m, out QCallException qcallException); [MethodImpl(MethodImplOptions.InternalCall)] public static extern /* struct _EXCEPTION_POINTERS* */ IntPtr GetExceptionPointers(); @@ -287,7 +287,7 @@ internal static LayoutTypeMarshalerMethods GetMarshalMethodsForType(RuntimeType [RequiresDynamicCode("Marshalling code for the object might not be available.")] public static LayoutTypeMarshalerMethods Create(RuntimeType type) { - if (!HasLayout(new QCallTypeHandle(ref type), out bool isBlittable, out _)) + if (!HasLayout(new QCallTypeHandle(ref type), out bool isBlittable, out _, out _)) throw new ArgumentException(SR.Argument_MustHaveLayoutOrBeBlittable, nameof(type)); Type instantiatedMarshaler = typeof(BoxedLayoutTypeMarshaler<>).MakeGenericType([type]); @@ -307,7 +307,7 @@ public void InitializeCompositeCache(RuntimeType.CompositeCacheEntry compositeEn [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_HasLayout")] [return: MarshalAs(UnmanagedType.Bool)] - internal static partial bool HasLayout(QCallTypeHandle t, [MarshalAs(UnmanagedType.Bool)] out bool isBlittable, out int nativeSize); + internal static partial bool HasLayout(QCallTypeHandle t, [MarshalAs(UnmanagedType.Bool)] out bool isBlittable, out int nativeSize, out QCallException qcallException); /// /// Marshals data from a structure class to a native memory block. If the @@ -405,11 +405,11 @@ internal static unsafe bool IsPinnable(object? obj) #if TARGET_WINDOWS [FeatureSwitchDefinition("System.Runtime.InteropServices.BuiltInComInterop.IsSupported")] - internal static bool IsBuiltInComSupported { get; } = IsBuiltInComSupportedInternal(); + internal static bool IsBuiltInComSupported { get; } = IsBuiltInComSupportedInternal(out _); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_IsBuiltInComSupported")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool IsBuiltInComSupportedInternal(); + private static partial bool IsBuiltInComSupportedInternal(out QCallException qcallException); /// /// Returns the HInstance for this module. Returns -1 if the module doesn't have @@ -423,26 +423,26 @@ public static IntPtr GetHINSTANCE(Module m) if (m is RuntimeModule rtModule) { - return GetHINSTANCE(new QCallModule(ref rtModule)); + return GetHINSTANCE(new QCallModule(ref rtModule), out _); } return (IntPtr)(-1); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetHINSTANCE")] - private static partial IntPtr GetHINSTANCE(QCallModule m); + private static partial IntPtr GetHINSTANCE(QCallModule m, out QCallException qcallException); #endif // TARGET_WINDOWS internal static Exception GetExceptionForHRInternal(int errorCode, IntPtr errorInfo) { Exception? exception = null; - GetExceptionForHRInternal(errorCode, errorInfo, ObjectHandleOnStack.Create(ref exception)); + GetExceptionForHRInternal(errorCode, errorInfo, ObjectHandleOnStack.Create(ref exception), out _); return exception!; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetExceptionForHR")] - private static partial void GetExceptionForHRInternal(int errorCode, IntPtr errorInfo, ObjectHandleOnStack exception); + private static partial void GetExceptionForHRInternal(int errorCode, IntPtr errorInfo, ObjectHandleOnStack exception, out QCallException qcallException); #if FEATURE_COMINTEROP /// @@ -450,10 +450,10 @@ internal static Exception GetExceptionForHRInternal(int errorCode, IntPtr errorI /// up an IErrorInfo for the exception. /// public static int GetHRForException(Exception? e) - => GetHRForException(ObjectHandleOnStack.Create(ref e)); + => GetHRForException(ObjectHandleOnStack.Create(ref e), out _); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetHRForException")] - private static partial int GetHRForException(ObjectHandleOnStack exception); + private static partial int GetHRForException(ObjectHandleOnStack exception, out QCallException qcallException); /// /// Given a managed object that wraps an ITypeInfo, return its name. @@ -481,13 +481,13 @@ public static string GetTypeInfoName(ITypeInfo typeInfo) // on the Activator.CreateInstance() call. GetTypeFromCLSID() merely wraps the data in a Type object without any validation. Type? type = null; - GetTypeFromCLSID(clsid, server, ObjectHandleOnStack.Create(ref type)); + GetTypeFromCLSID(clsid, server, ObjectHandleOnStack.Create(ref type), out _); return type; } #pragma warning restore IDE0060 [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetTypeFromCLSID", StringMarshalling = StringMarshalling.Utf16)] - private static partial void GetTypeFromCLSID(in Guid clsid, string? server, ObjectHandleOnStack retType); + private static partial void GetTypeFromCLSID(in Guid clsid, string? server, ObjectHandleOnStack retType, out QCallException qcallException); /// /// Return the IUnknown* for an Object if the current context is the one @@ -498,11 +498,11 @@ public static string GetTypeInfoName(ITypeInfo typeInfo) { ArgumentNullException.ThrowIfNull(o); - return GetIUnknownForObject(ObjectHandleOnStack.Create(ref o)); + return GetIUnknownForObject(ObjectHandleOnStack.Create(ref o), out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetIUnknownForObject")] - private static partial IntPtr /* IUnknown* */ GetIUnknownForObject(ObjectHandleOnStack o); + private static partial IntPtr /* IUnknown* */ GetIUnknownForObject(ObjectHandleOnStack o, out QCallException qcallException); /// /// Return the IDispatch* for an Object. @@ -512,11 +512,11 @@ public static string GetTypeInfoName(ITypeInfo typeInfo) { ArgumentNullException.ThrowIfNull(o); - return GetIDispatchForObject(ObjectHandleOnStack.Create(ref o)); + return GetIDispatchForObject(ObjectHandleOnStack.Create(ref o), out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetIDispatchForObject")] - private static partial IntPtr /* IDispatch* */ GetIDispatchForObject(ObjectHandleOnStack o); + private static partial IntPtr /* IDispatch* */ GetIDispatchForObject(ObjectHandleOnStack o, out QCallException qcallException); /// /// Return the IUnknown* representing the interface for the Object. @@ -546,11 +546,11 @@ public static IntPtr GetComInterfaceForObject([DisallowNull] T o) if (T is not RuntimeType rt) throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(T)); - return GetComInterfaceForObject(ObjectHandleOnStack.Create(ref o), new QCallTypeHandle(ref rt), fEnableCustomizedQueryInterface: mode == CustomQueryInterfaceMode.Allow); + return GetComInterfaceForObject(ObjectHandleOnStack.Create(ref o), new QCallTypeHandle(ref rt), fEnableCustomizedQueryInterface: mode == CustomQueryInterfaceMode.Allow, out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetComInterfaceForObject")] - private static partial IntPtr /* IUnknown* */ GetComInterfaceForObject(ObjectHandleOnStack o, QCallTypeHandle t, [MarshalAs(UnmanagedType.Bool)] bool fEnableCustomizedQueryInterface); + private static partial IntPtr /* IUnknown* */ GetComInterfaceForObject(ObjectHandleOnStack o, QCallTypeHandle t, [MarshalAs(UnmanagedType.Bool)] bool fEnableCustomizedQueryInterface, out QCallException qcallException); /// /// Return the managed object representing the IUnknown* @@ -561,12 +561,12 @@ public static object GetObjectForIUnknown(IntPtr /* IUnknown* */ pUnk) ArgumentNullException.ThrowIfNull(pUnk); object? retObject = null; - GetObjectForIUnknown(pUnk, ObjectHandleOnStack.Create(ref retObject)); + GetObjectForIUnknown(pUnk, ObjectHandleOnStack.Create(ref retObject), out _); return retObject!; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetObjectForIUnknown")] - private static partial void GetObjectForIUnknown(IntPtr /* IUnknown* */ pUnk, ObjectHandleOnStack retObject); + private static partial void GetObjectForIUnknown(IntPtr /* IUnknown* */ pUnk, ObjectHandleOnStack retObject, out QCallException qcallException); [SupportedOSPlatform("windows")] public static object GetUniqueObjectForIUnknown(IntPtr unknown) @@ -574,7 +574,7 @@ public static object GetUniqueObjectForIUnknown(IntPtr unknown) ArgumentNullException.ThrowIfNull(unknown); object? retObject = null; - GetUniqueObjectForIUnknown(unknown, ObjectHandleOnStack.Create(ref retObject)); + GetUniqueObjectForIUnknown(unknown, ObjectHandleOnStack.Create(ref retObject), out _); return retObject!; } @@ -585,7 +585,7 @@ public static object GetUniqueObjectForIUnknown(IntPtr unknown) /// ReleaseComObject on a RCW and not worry about other active uses ofsaid RCW. /// [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetUniqueObjectForIUnknown")] - private static partial void GetUniqueObjectForIUnknown(IntPtr unknown, ObjectHandleOnStack retObject); + private static partial void GetUniqueObjectForIUnknown(IntPtr unknown, ObjectHandleOnStack retObject, out QCallException qcallException); /// /// Return an Object for IUnknown, using the Type T. @@ -601,12 +601,12 @@ public static object GetTypedObjectForIUnknown(IntPtr /* IUnknown* */ pUnk, Type throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(t)); object? retObject = null; - GetTypedObjectForIUnknown(pUnk, new QCallTypeHandle(ref rt), ObjectHandleOnStack.Create(ref retObject)); + GetTypedObjectForIUnknown(pUnk, new QCallTypeHandle(ref rt), ObjectHandleOnStack.Create(ref retObject), out _); return retObject!; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetTypedObjectForIUnknown")] - private static partial void GetTypedObjectForIUnknown(IntPtr /* IUnknown* */ pUnk, QCallTypeHandle t, ObjectHandleOnStack retObject); + private static partial void GetTypedObjectForIUnknown(IntPtr /* IUnknown* */ pUnk, QCallTypeHandle t, ObjectHandleOnStack retObject, out QCallException qcallException); [SupportedOSPlatform("windows")] [EditorBrowsable(EditorBrowsableState.Never)] @@ -620,11 +620,11 @@ public static IntPtr CreateAggregatedObject(IntPtr pOuter, object o) ArgumentNullException.ThrowIfNull(pOuter); ArgumentNullException.ThrowIfNull(o); - return CreateAggregatedObject(pOuter, ObjectHandleOnStack.Create(ref o)); + return CreateAggregatedObject(pOuter, ObjectHandleOnStack.Create(ref o), out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_CreateAggregatedObject")] - private static partial IntPtr CreateAggregatedObject(IntPtr pOuter, ObjectHandleOnStack o); + private static partial IntPtr CreateAggregatedObject(IntPtr pOuter, ObjectHandleOnStack o, out QCallException qcallException); [SupportedOSPlatform("windows")] public static IntPtr CreateAggregatedObject(IntPtr pOuter, T o) where T : notnull @@ -638,10 +638,10 @@ public static IntPtr CreateAggregatedObject(IntPtr pOuter, T o) where T : not } public static void CleanupUnusedObjectsInCurrentContext() - => InternalCleanupUnusedObjectsInCurrentContext(); + => InternalCleanupUnusedObjectsInCurrentContext(out _); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_CleanupUnusedObjectsInCurrentContext")] - private static partial void InternalCleanupUnusedObjectsInCurrentContext(); + private static partial void InternalCleanupUnusedObjectsInCurrentContext(out QCallException qcallException); /// Returns a Boolean computed from runtime COM-cleanup state; it takes no arguments and dereferences no caller-supplied memory. [MethodImpl(MethodImplOptions.InternalCall)] @@ -679,11 +679,11 @@ public static int ReleaseComObject(object o) throw new ArgumentException(SR.Argument_ObjNotComObject, nameof(o)); } - return ReleaseComObject(ObjectHandleOnStack.Create(ref co)); + return ReleaseComObject(ObjectHandleOnStack.Create(ref co), out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_ReleaseComObject")] - private static partial int ReleaseComObject(ObjectHandleOnStack o); + private static partial int ReleaseComObject(ObjectHandleOnStack o, out QCallException qcallException); /// /// Release the COM component and zombie this object. @@ -703,12 +703,12 @@ public static int FinalReleaseComObject(object o) throw new ArgumentException(SR.Argument_ObjNotComObject, nameof(o)); } - FinalReleaseComObject(ObjectHandleOnStack.Create(ref co)); + FinalReleaseComObject(ObjectHandleOnStack.Create(ref co), out _); return 0; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_FinalReleaseComObject")] - private static partial void FinalReleaseComObject(ObjectHandleOnStack o); + private static partial void FinalReleaseComObject(ObjectHandleOnStack o, out QCallException qcallException); [SupportedOSPlatform("windows")] public static object? GetComObjectData(object obj, object key) @@ -829,12 +829,12 @@ private static object InternalCreateWrapperOfType(object o, Type t) throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(t)); object? retObject = null; - InternalCreateWrapperOfType(ObjectHandleOnStack.Create(ref o), new QCallTypeHandle(ref rt), ObjectHandleOnStack.Create(ref retObject)); + InternalCreateWrapperOfType(ObjectHandleOnStack.Create(ref o), new QCallTypeHandle(ref rt), ObjectHandleOnStack.Create(ref retObject), out _); return retObject!; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_InternalCreateWrapperOfType")] - private static partial void InternalCreateWrapperOfType(ObjectHandleOnStack o, QCallTypeHandle rt, ObjectHandleOnStack retObject); + private static partial void InternalCreateWrapperOfType(ObjectHandleOnStack o, QCallTypeHandle rt, ObjectHandleOnStack retObject, out QCallException qcallException); /// /// check if the type is visible from COM. @@ -846,12 +846,12 @@ public static bool IsTypeVisibleFromCom(Type t) if (t is not RuntimeType rt) throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(t)); - return IsTypeVisibleFromCom(new QCallTypeHandle(ref rt)); + return IsTypeVisibleFromCom(new QCallTypeHandle(ref rt), out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_IsTypeVisibleFromCom")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool IsTypeVisibleFromCom(QCallTypeHandle rt); + private static partial bool IsTypeVisibleFromCom(QCallTypeHandle rt, out QCallException qcallException); [SupportedOSPlatform("windows")] [EditorBrowsable(EditorBrowsableState.Never)] @@ -864,11 +864,11 @@ public static void GetNativeVariantForObject(object? obj, /* VARIANT * */ IntPtr ArgumentNullException.ThrowIfNull(pDstNativeVariant); - GetNativeVariantForObject(ObjectHandleOnStack.Create(ref obj), pDstNativeVariant); + GetNativeVariantForObject(ObjectHandleOnStack.Create(ref obj), pDstNativeVariant, out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetNativeVariantForObject")] - private static partial void GetNativeVariantForObject(ObjectHandleOnStack obj, /* VARIANT * */ IntPtr pDstNativeVariant); + private static partial void GetNativeVariantForObject(ObjectHandleOnStack obj, /* VARIANT * */ IntPtr pDstNativeVariant, out QCallException qcallException); [SupportedOSPlatform("windows")] [EditorBrowsable(EditorBrowsableState.Never)] @@ -894,12 +894,12 @@ public static void GetNativeVariantForObject(T? obj, IntPtr pDstNativeVariant ArgumentNullException.ThrowIfNull(pSrcNativeVariant); object? retObject = null; - GetObjectForNativeVariant(pSrcNativeVariant, ObjectHandleOnStack.Create(ref retObject)); + GetObjectForNativeVariant(pSrcNativeVariant, ObjectHandleOnStack.Create(ref retObject), out _); return retObject; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetObjectForNativeVariant")] - private static partial void GetObjectForNativeVariant(/* VARIANT * */ IntPtr pSrcNativeVariant, ObjectHandleOnStack retObject); + private static partial void GetObjectForNativeVariant(/* VARIANT * */ IntPtr pSrcNativeVariant, ObjectHandleOnStack retObject, out QCallException qcallException); [SupportedOSPlatform("windows")] [EditorBrowsable(EditorBrowsableState.Never)] @@ -926,12 +926,12 @@ public static void GetNativeVariantForObject(T? obj, IntPtr pDstNativeVariant ArgumentOutOfRangeException.ThrowIfNegative(cVars); object?[]? retArray = null; - GetObjectsForNativeVariants(aSrcNativeVariant, cVars, ObjectHandleOnStack.Create(ref retArray)); + GetObjectsForNativeVariants(aSrcNativeVariant, cVars, ObjectHandleOnStack.Create(ref retArray), out _); return retArray!; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetObjectsForNativeVariants")] - private static partial void GetObjectsForNativeVariants(/* VARIANT * */ IntPtr aSrcNativeVariant, int cVars, ObjectHandleOnStack retArray); + private static partial void GetObjectsForNativeVariants(/* VARIANT * */ IntPtr aSrcNativeVariant, int cVars, ObjectHandleOnStack retArray, out QCallException qcallException); [SupportedOSPlatform("windows")] [EditorBrowsable(EditorBrowsableState.Never)] @@ -962,11 +962,11 @@ public static int GetStartComSlot(Type t) if (t is not RuntimeType rt) throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(t)); - return GetStartComSlot(new QCallTypeHandle(ref rt)); + return GetStartComSlot(new QCallTypeHandle(ref rt), out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetStartComSlot")] - private static partial int GetStartComSlot(QCallTypeHandle rt); + private static partial int GetStartComSlot(QCallTypeHandle rt, out QCallException qcallException); /// /// Returns the last valid COM slot that GetMethodInfoForSlot will work on. @@ -979,11 +979,11 @@ public static int GetEndComSlot(Type t) if (t is not RuntimeType rt) throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(t)); - return GetEndComSlot(new QCallTypeHandle(ref rt)); + return GetEndComSlot(new QCallTypeHandle(ref rt), out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetEndComSlot")] - private static partial int GetEndComSlot(QCallTypeHandle rt); + private static partial int GetEndComSlot(QCallTypeHandle rt, out QCallException qcallException); [RequiresUnreferencedCode("Built-in COM support is not trim compatible", Url = "https://aka.ms/dotnet-illink/com")] [SupportedOSPlatform("windows")] @@ -1035,34 +1035,34 @@ public static void ChangeWrapperHandleStrength(object otp, bool fIsWeak) { ArgumentNullException.ThrowIfNull(otp); - ChangeWrapperHandleStrength(ObjectHandleOnStack.Create(ref otp), fIsWeak); + ChangeWrapperHandleStrength(ObjectHandleOnStack.Create(ref otp), fIsWeak, out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_ChangeWrapperHandleStrength")] - private static partial void ChangeWrapperHandleStrength(ObjectHandleOnStack otp, [MarshalAs(UnmanagedType.Bool)] bool fIsWeak); + private static partial void ChangeWrapperHandleStrength(ObjectHandleOnStack otp, [MarshalAs(UnmanagedType.Bool)] bool fIsWeak, out QCallException qcallException); #endif // FEATURE_COMINTEROP internal static Delegate GetDelegateForFunctionPointerInternal(IntPtr ptr, RuntimeType t) { Delegate? retDelegate = null; - GetDelegateForFunctionPointerInternal(ptr, new QCallTypeHandle(ref t), ObjectHandleOnStack.Create(ref retDelegate)); + GetDelegateForFunctionPointerInternal(ptr, new QCallTypeHandle(ref t), ObjectHandleOnStack.Create(ref retDelegate), out _); return retDelegate!; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetDelegateForFunctionPointerInternal")] - private static partial void GetDelegateForFunctionPointerInternal(IntPtr ptr, QCallTypeHandle t, ObjectHandleOnStack retDelegate); + private static partial void GetDelegateForFunctionPointerInternal(IntPtr ptr, QCallTypeHandle t, ObjectHandleOnStack retDelegate, out QCallException qcallException); internal static IntPtr GetFunctionPointerForDelegateInternal(Delegate d) { - return GetFunctionPointerForDelegateInternal(ObjectHandleOnStack.Create(ref d)); + return GetFunctionPointerForDelegateInternal(ObjectHandleOnStack.Create(ref d), out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetFunctionPointerForDelegateInternal")] - private static partial IntPtr GetFunctionPointerForDelegateInternal(ObjectHandleOnStack d); + private static partial IntPtr GetFunctionPointerForDelegateInternal(ObjectHandleOnStack d, out QCallException qcallException); #if DEBUG // Used for testing in Checked or Debug [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetIsInCooperativeGCModeFunctionPointer")] - internal static unsafe partial delegate* unmanaged GetIsInCooperativeGCModeFunctionPointer(); + internal static unsafe partial delegate* unmanaged GetIsInCooperativeGCModeFunctionPointer(out QCallException qcallException); #endif } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs index 1c19a684f6d130..270732386206e9 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs @@ -16,7 +16,8 @@ internal static IntPtr LoadLibraryByName(string libraryName, Assembly assembly, new QCallAssembly(ref rtAsm), searchPath.HasValue, (uint)searchPath.GetValueOrDefault(), - throwOnError); + throwOnError, + out _); } /// External functions that implement the NativeLibrary interface @@ -24,7 +25,8 @@ internal static IntPtr LoadLibraryByName(string libraryName, Assembly assembly, [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeLibrary_LoadByName", StringMarshalling = StringMarshalling.Utf16)] internal static partial IntPtr LoadByName(string libraryName, QCallAssembly callingAssembly, [MarshalAs(UnmanagedType.Bool)] bool hasDllImportSearchPathFlag, uint dllImportSearchPathFlag, - [MarshalAs(UnmanagedType.Bool)] bool throwOnError); + [MarshalAs(UnmanagedType.Bool)] bool throwOnError, + out QCallException qcallException); [UnmanagedCallersOnly] private static unsafe IntPtr LoadLibraryCallbackStub(char* pLibraryName, Assembly* pAssembly, bool hasDllImportSearchPathFlags, uint dllImportSearchPathFlags, Exception* pException) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveCMarshal.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveCMarshal.CoreCLR.cs index 69bbcb5ee9aab2..b76b6ce93028f6 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveCMarshal.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveCMarshal.CoreCLR.cs @@ -25,7 +25,8 @@ public static void SetMessageSendPendingException(Exception? exception) [return: MarshalAs(UnmanagedType.Bool)] private static partial bool TrySetGlobalMessageSendCallback( MessageSendFunction msgSendFunction, - IntPtr func); + IntPtr func, + out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjCMarshal_TryInitializeReferenceTracker")] [return: MarshalAs(UnmanagedType.Bool)] @@ -33,7 +34,8 @@ private static unsafe partial bool TryInitializeReferenceTracker( delegate* unmanaged beginEndCallback, delegate* unmanaged isReferencedCallback, delegate* unmanaged trackedObjectEnteredFinalization, - ObjectHandleOnStack objectTrackingInfoTable); + ObjectHandleOnStack objectTrackingInfoTable, + out QCallException qcallException); private static unsafe bool TryInitializeReferenceTracker( delegate* unmanaged beginEndCallback, @@ -47,14 +49,15 @@ private static unsafe bool TryInitializeReferenceTracker( beginEndCallback, isReferencedCallback, trackedObjectEnteredFinalization, - ObjectHandleOnStack.Create(ref objects)); + ObjectHandleOnStack.Create(ref objects), + out _); Debug.Assert(object.ReferenceEquals(objects, s_objects)); return result; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjCMarshal_AllocateReferenceTrackingHandle")] - private static partial IntPtr AllocateReferenceTrackingHandle(ObjectHandleOnStack obj); + private static partial IntPtr AllocateReferenceTrackingHandle(ObjectHandleOnStack obj, out QCallException qcallException); private static IntPtr AllocateReferenceTrackingHandle(object obj) => AllocateReferenceTrackingHandle(ObjectHandleOnStack.Create(ref obj)); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/TrackerObjectManager.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/TrackerObjectManager.CoreCLR.cs index ac60cd56719b64..494d818d754397 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/TrackerObjectManager.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/TrackerObjectManager.CoreCLR.cs @@ -1,4 +1,4 @@ -// Licensed to the .NET Foundation under one or more agreements. +// Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. using System; @@ -36,10 +36,10 @@ private static void RegisterGCCallbacks() // CoreCLR doesn't have GC callbacks, but we do need to register the GC handle set with the runtime for enumeration // during GC. GCHandleSet handleSet = s_referenceTrackerNativeObjectWrapperCache; - RegisterNativeObjectWrapperCache(ObjectHandleOnStack.Create(ref handleSet)); + RegisterNativeObjectWrapperCache(ObjectHandleOnStack.Create(ref handleSet), out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TrackerObjectManager_RegisterNativeObjectWrapperCache")] - private static partial void RegisterNativeObjectWrapperCache(ObjectHandleOnStack nativeObjectWrapperCache); + private static partial void RegisterNativeObjectWrapperCache(ObjectHandleOnStack nativeObjectWrapperCache, out QCallException qcallException); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs index 9bae4217c8cb58..6714e66606e9b0 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs @@ -12,59 +12,59 @@ namespace System.Runtime.Loader public partial class AssemblyLoadContext { [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_InitializeAssemblyLoadContext")] - private static partial IntPtr InitializeAssemblyLoadContext(IntPtr ptrAssemblyLoadContext, [MarshalAs(UnmanagedType.Bool)] bool fRepresentsTPALoadContext, [MarshalAs(UnmanagedType.Bool)] bool isCollectible); + private static partial IntPtr InitializeAssemblyLoadContext(IntPtr ptrAssemblyLoadContext, [MarshalAs(UnmanagedType.Bool)] bool fRepresentsTPALoadContext, [MarshalAs(UnmanagedType.Bool)] bool isCollectible, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_PrepareForAssemblyLoadContextRelease")] - private static partial void PrepareForAssemblyLoadContextRelease(IntPtr ptrNativeAssemblyBinder, IntPtr ptrAssemblyLoadContextStrong); + private static partial void PrepareForAssemblyLoadContextRelease(IntPtr ptrNativeAssemblyBinder, IntPtr ptrAssemblyLoadContextStrong, out QCallException qcallException); [RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_LoadFromStream")] - private static partial void LoadFromStream(IntPtr ptrNativeAssemblyBinder, IntPtr ptrAssemblyArray, int iAssemblyArrayLen, IntPtr ptrSymbols, int iSymbolArrayLen, ObjectHandleOnStack retAssembly); + private static partial void LoadFromStream(IntPtr ptrNativeAssemblyBinder, IntPtr ptrAssemblyArray, int iAssemblyArrayLen, IntPtr ptrSymbols, int iSymbolArrayLen, ObjectHandleOnStack retAssembly, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MultiCoreJIT_InternalSetProfileRoot", StringMarshalling = StringMarshalling.Utf16)] - internal static partial void InternalSetProfileRoot(string directoryPath); + internal static partial void InternalSetProfileRoot(string directoryPath, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MultiCoreJIT_InternalStartProfile", StringMarshalling = StringMarshalling.Utf16)] - internal static partial void InternalStartProfile(string? profile, IntPtr ptrNativeAssemblyBinder); + internal static partial void InternalStartProfile(string? profile, IntPtr ptrNativeAssemblyBinder, out QCallException qcallException); [RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_LoadFromPath", StringMarshalling = StringMarshalling.Utf16)] - private static partial void LoadFromPath(IntPtr ptrNativeAssemblyBinder, string? ilPath, ObjectHandleOnStack retAssembly); + private static partial void LoadFromPath(IntPtr ptrNativeAssemblyBinder, string? ilPath, ObjectHandleOnStack retAssembly, out QCallException qcallException); internal static Assembly[] GetLoadedAssemblies() { Assembly[]? assemblies = null; - GetLoadedAssemblies(ObjectHandleOnStack.Create(ref assemblies)); + GetLoadedAssemblies(ObjectHandleOnStack.Create(ref assemblies), out _); return assemblies!; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetLoadedAssemblies")] - private static partial void GetLoadedAssemblies(ObjectHandleOnStack retAssemblies); + private static partial void GetLoadedAssemblies(ObjectHandleOnStack retAssemblies, out QCallException qcallException); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern bool IsTracingEnabled(); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_TraceResolvingHandlerInvoked", StringMarshalling = StringMarshalling.Utf16)] [return: MarshalAs(UnmanagedType.Bool)] - internal static partial bool TraceResolvingHandlerInvoked(string assemblyName, string handlerName, string? alcName, string? resultAssemblyName, string? resultAssemblyPath); + internal static partial bool TraceResolvingHandlerInvoked(string assemblyName, string handlerName, string? alcName, string? resultAssemblyName, string? resultAssemblyPath, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_TraceAssemblyResolveHandlerInvoked", StringMarshalling = StringMarshalling.Utf16)] [return: MarshalAs(UnmanagedType.Bool)] - internal static partial bool TraceAssemblyResolveHandlerInvoked(string assemblyName, string handlerName, string? resultAssemblyName, string? resultAssemblyPath); + internal static partial bool TraceAssemblyResolveHandlerInvoked(string assemblyName, string handlerName, string? resultAssemblyName, string? resultAssemblyPath, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_TraceAssemblyLoadFromResolveHandlerInvoked", StringMarshalling = StringMarshalling.Utf16)] [return: MarshalAs(UnmanagedType.Bool)] - internal static partial bool TraceAssemblyLoadFromResolveHandlerInvoked(string assemblyName, [MarshalAs(UnmanagedType.Bool)] bool isTrackedAssembly, string requestingAssemblyPath, string? requestedAssemblyPath); + internal static partial bool TraceAssemblyLoadFromResolveHandlerInvoked(string assemblyName, [MarshalAs(UnmanagedType.Bool)] bool isTrackedAssembly, string requestingAssemblyPath, string? requestedAssemblyPath, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_TraceSatelliteSubdirectoryPathProbed", StringMarshalling = StringMarshalling.Utf16)] [return: MarshalAs(UnmanagedType.Bool)] - internal static partial bool TraceSatelliteSubdirectoryPathProbed(string filePath, int hResult); + internal static partial bool TraceSatelliteSubdirectoryPathProbed(string filePath, int hResult, out QCallException qcallException); [RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")] private RuntimeAssembly InternalLoadFromPath(string? assemblyPath) { RuntimeAssembly? loadedAssembly = null; - LoadFromPath(_nativeAssemblyLoadContext, assemblyPath, ObjectHandleOnStack.Create(ref loadedAssembly)); + LoadFromPath(_nativeAssemblyLoadContext, assemblyPath, ObjectHandleOnStack.Create(ref loadedAssembly), out _); return loadedAssembly!; } @@ -76,7 +76,8 @@ internal unsafe Assembly InternalLoad(ReadOnlySpan arrAssembly, ReadOnlySp fixed (byte* ptrAssembly = arrAssembly, ptrSymbols = arrSymbols) { LoadFromStream(_nativeAssemblyLoadContext, new IntPtr(ptrAssembly), arrAssembly.Length, - new IntPtr(ptrSymbols), arrSymbols.Length, ObjectHandleOnStack.Create(ref loadedAssembly)); + new IntPtr(ptrSymbols), arrSymbols.Length, ObjectHandleOnStack.Create(ref loadedAssembly), + out _); } return loadedAssembly!; @@ -84,7 +85,7 @@ internal unsafe Assembly InternalLoad(ReadOnlySpan arrAssembly, ReadOnlySp #if TARGET_WINDOWS [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_LoadFromInMemoryModule")] - private static partial IntPtr LoadFromInMemoryModuleInternal(IntPtr ptrNativeAssemblyBinder, IntPtr hModule, ObjectHandleOnStack retAssembly); + private static partial IntPtr LoadFromInMemoryModuleInternal(IntPtr ptrNativeAssemblyBinder, IntPtr hModule, ObjectHandleOnStack retAssembly, out QCallException qcallException); /// @@ -102,7 +103,8 @@ internal Assembly LoadFromInMemoryModule(IntPtr moduleHandle) LoadFromInMemoryModuleInternal( _nativeAssemblyLoadContext, moduleHandle, - ObjectHandleOnStack.Create(ref loadedAssembly)); + ObjectHandleOnStack.Create(ref loadedAssembly), + out _); return loadedAssembly!; } } @@ -143,7 +145,7 @@ private static unsafe IntPtr ResolveUnmanagedDllUsingEvent(char* pUnmanagedDllNa } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetLoadContextForAssembly")] - private static partial IntPtr GetLoadContextForAssembly(QCallAssembly assembly); + private static partial IntPtr GetLoadContextForAssembly(QCallAssembly assembly, out QCallException qcallException); // Returns the load context in which the specified assembly has been loaded public static AssemblyLoadContext? GetLoadContext(Assembly assembly) @@ -157,7 +159,7 @@ private static unsafe IntPtr ResolveUnmanagedDllUsingEvent(char* pUnmanagedDllNa if (rtAsm != null) { RuntimeAssembly runtimeAssembly = rtAsm; - IntPtr ptrAssemblyLoadContext = GetLoadContextForAssembly(new QCallAssembly(ref runtimeAssembly)); + IntPtr ptrAssemblyLoadContext = GetLoadContextForAssembly(new QCallAssembly(ref runtimeAssembly), out _); if (ptrAssemblyLoadContext == IntPtr.Zero) { // If the load context is returned null, then the assembly was bound using the TPA binder @@ -176,13 +178,13 @@ private static unsafe IntPtr ResolveUnmanagedDllUsingEvent(char* pUnmanagedDllNa // Set the root directory path for profile optimization. public void SetProfileOptimizationRoot(string directoryPath) { - InternalSetProfileRoot(directoryPath); + InternalSetProfileRoot(directoryPath, out _); } // Start profile optimization for the specified profile name. public void StartProfileOptimization(string? profile) { - InternalStartProfile(profile, _nativeAssemblyLoadContext); + InternalStartProfile(profile, _nativeAssemblyLoadContext, out _); } private static RuntimeAssembly? GetRuntimeAssembly(Assembly? asm) diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs index 81b0dff3c61034..712dfd93461a40 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs @@ -36,13 +36,14 @@ public static RuntimeTypeHandle FromIntPtr(IntPtr value) => [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetRuntimeTypeFromHandleSlow")] private static partial void GetRuntimeTypeFromHandleSlow( IntPtr handle, - ObjectHandleOnStack typeObject); + ObjectHandleOnStack typeObject, + out QCallException qcallException); [MethodImpl(MethodImplOptions.NoInlining)] private static RuntimeType GetRuntimeTypeFromHandleSlow(IntPtr handle) { RuntimeType? typeObject = null; - GetRuntimeTypeFromHandleSlow(handle, ObjectHandleOnStack.Create(ref typeObject)); + GetRuntimeTypeFromHandleSlow(handle, ObjectHandleOnStack.Create(ref typeObject), out _); return typeObject!; } @@ -237,7 +238,8 @@ internal static object CreateInstanceForAnotherGenericParameter( new QCallTypeHandle(ref type), &typeHandle, 1, - ObjectHandleOnStack.Create(ref instantiatedObject)); + ObjectHandleOnStack.Create(ref instantiatedObject), + out _); GC.KeepAlive(genericParameter); return instantiatedObject!; @@ -266,7 +268,8 @@ internal static object CreateInstanceForAnotherGenericParameter( new QCallTypeHandle(ref type), pTypeHandles, 2, - ObjectHandleOnStack.Create(ref instantiatedObject)); + ObjectHandleOnStack.Create(ref instantiatedObject), + out _); GC.KeepAlive(genericParameter1); GC.KeepAlive(genericParameter2); @@ -279,12 +282,13 @@ private static partial void CreateInstanceForAnotherGenericParameter( QCallTypeHandle baseType, IntPtr* pTypeHandles, int cTypeHandles, - ObjectHandleOnStack instantiatedObject); + ObjectHandleOnStack instantiatedObject, + out QCallException qcallException); internal static unsafe object InternalAlloc(MethodTable* pMT) { object? result = null; - InternalAlloc(pMT, ObjectHandleOnStack.Create(ref result)); + InternalAlloc(pMT, ObjectHandleOnStack.Create(ref result), out _); return result!; } @@ -297,7 +301,7 @@ internal static object InternalAlloc(RuntimeType type) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_InternalAlloc")] - private static unsafe partial void InternalAlloc(MethodTable* pMT, ObjectHandleOnStack result); + private static unsafe partial void InternalAlloc(MethodTable* pMT, ObjectHandleOnStack result, out QCallException qcallException); [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -309,13 +313,13 @@ internal static object InternalAllocNoChecks(MethodTable* pMT) static object InternalAllocNoChecksWorker(MethodTable* pMT) { object? result = null; - InternalAllocNoChecks(pMT, ObjectHandleOnStack.Create(ref result)); + InternalAllocNoChecks(pMT, ObjectHandleOnStack.Create(ref result), out _); return result!; } } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_InternalAllocNoChecks")] - private static unsafe partial void InternalAllocNoChecks(MethodTable* pMT, ObjectHandleOnStack result); + private static unsafe partial void InternalAllocNoChecks(MethodTable* pMT, ObjectHandleOnStack result, out QCallException qcallException); [MethodImpl(MethodImplOptions.InternalCall)] private static extern object? InternalAllocNoChecks_FastPath(MethodTable* pMT); @@ -344,7 +348,8 @@ internal static void GetActivationInfo( GetActivationInfo( ObjectHandleOnStack.Create(ref rt), &pfnAllocatorTemp, &vAllocatorFirstArgTemp, - &pfnRefCtorTemp, &pfnValueCtorTemp, &fCtorIsPublicTemp); + &pfnRefCtorTemp, &pfnValueCtorTemp, &fCtorIsPublicTemp, + out _); pfnAllocator = pfnAllocatorTemp; vAllocatorFirstArg = vAllocatorFirstArgTemp; @@ -360,18 +365,19 @@ private static partial void GetActivationInfo( void** pvAllocatorFirstArg, delegate** ppfnRefCtor, delegate** ppfnValueCtor, - Interop.BOOL* pfCtorIsPublic); + Interop.BOOL* pfCtorIsPublic, + out QCallException qcallException); #if FEATURE_COMINTEROP [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_AllocateComObject")] - private static partial void AllocateComObject(void* pClassFactory, ObjectHandleOnStack result); + private static partial void AllocateComObject(void* pClassFactory, ObjectHandleOnStack result, out QCallException qcallException); // Referenced by unmanaged layer (see GetActivationInfo). // First parameter is ComClassFactory*. private static object AllocateComObject(void* pClassFactory) { object? result = null; - AllocateComObject(pClassFactory, ObjectHandleOnStack.Create(ref result)); + AllocateComObject(pClassFactory, ObjectHandleOnStack.Create(ref result), out _); return result!; } #endif // FEATURE_COMINTEROP @@ -389,7 +395,7 @@ internal static RuntimeAssembly GetAssembly(RuntimeType type) static RuntimeAssembly GetAssemblyWorker(RuntimeType type) { RuntimeAssembly? assembly = null; - GetAssemblySlow(ObjectHandleOnStack.Create(ref type), ObjectHandleOnStack.Create(ref assembly)); + GetAssemblySlow(ObjectHandleOnStack.Create(ref type), ObjectHandleOnStack.Create(ref assembly), out _); return assembly!; } } @@ -398,7 +404,7 @@ static RuntimeAssembly GetAssemblyWorker(RuntimeType type) private static extern RuntimeAssembly? GetAssemblyIfExists(RuntimeType type); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetAssemblySlow")] - private static partial void GetAssemblySlow(ObjectHandleOnStack type, ObjectHandleOnStack assembly); + private static partial void GetAssemblySlow(ObjectHandleOnStack type, ObjectHandleOnStack assembly, out QCallException qcallException); internal static RuntimeModule GetModule(RuntimeType type) { @@ -408,7 +414,7 @@ internal static RuntimeModule GetModule(RuntimeType type) static RuntimeModule GetModuleWorker(RuntimeType type) { RuntimeModule? module = null; - GetModuleSlow(ObjectHandleOnStack.Create(ref type), ObjectHandleOnStack.Create(ref module)); + GetModuleSlow(ObjectHandleOnStack.Create(ref type), ObjectHandleOnStack.Create(ref module), out _); return module!; } } @@ -417,7 +423,7 @@ static RuntimeModule GetModuleWorker(RuntimeType type) private static extern RuntimeModule? GetModuleIfExists(RuntimeType type); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetModuleSlow")] - private static partial void GetModuleSlow(ObjectHandleOnStack type, ObjectHandleOnStack module); + private static partial void GetModuleSlow(ObjectHandleOnStack type, ObjectHandleOnStack module, out QCallException qcallException); public ModuleHandle GetModuleHandle() { @@ -458,7 +464,7 @@ public ModuleHandle GetModuleHandle() internal static extern int GetToken(RuntimeType type); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetMethodAt")] - private static unsafe partial IntPtr GetMethodAt(MethodTable* pMT, int slot); + private static unsafe partial IntPtr GetMethodAt(MethodTable* pMT, int slot, out QCallException qcallException); internal static RuntimeMethodHandleInternal GetMethodAt(RuntimeType type, int slot) { @@ -473,19 +479,19 @@ internal static RuntimeMethodHandleInternal GetMethodAt(RuntimeType type, int sl throw new ArgumentException(SR.Arg_ArgumentOutOfRangeException); } - return new RuntimeMethodHandleInternal(GetMethodAt(typeHandle.AsMethodTable(), slot)); + return new RuntimeMethodHandleInternal(GetMethodAt(typeHandle.AsMethodTable(), slot, out _)); } internal static Type[] GetArgumentTypesFromFunctionPointer(RuntimeType type) { Debug.Assert(type.IsFunctionPointer); Type[]? argTypes = null; - GetArgumentTypesFromFunctionPointer(new QCallTypeHandle(ref type), ObjectHandleOnStack.Create(ref argTypes)); + GetArgumentTypesFromFunctionPointer(new QCallTypeHandle(ref type), ObjectHandleOnStack.Create(ref argTypes), out _); return argTypes!; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetArgumentTypesFromFunctionPointer")] - private static partial void GetArgumentTypesFromFunctionPointer(QCallTypeHandle type, ObjectHandleOnStack argTypes); + private static partial void GetArgumentTypesFromFunctionPointer(QCallTypeHandle type, ObjectHandleOnStack argTypes, out QCallException qcallException); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern bool IsUnmanagedFunctionPointer(RuntimeType type); @@ -536,7 +542,7 @@ internal static IntroducedMethodEnumerator GetIntroducedMethods(RuntimeType type private static extern void GetNextIntroducedMethod(ref RuntimeMethodHandleInternal method); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetFields")] - private static partial Interop.BOOL GetFields(MethodTable* pMT, Span data, ref int usedCount); + private static partial Interop.BOOL GetFields(MethodTable* pMT, Span data, ref int usedCount, out QCallException qcallException); internal static bool GetFields(RuntimeType type, Span buffer, out int count) { @@ -550,14 +556,14 @@ internal static bool GetFields(RuntimeType type, Span buffer, out int co } int countLocal = buffer.Length; - bool success = GetFields(typeHandle.AsMethodTable(), buffer, ref countLocal) != Interop.BOOL.FALSE; + bool success = GetFields(typeHandle.AsMethodTable(), buffer, ref countLocal, out _) != Interop.BOOL.FALSE; GC.KeepAlive(type); count = countLocal; return success; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetInterfaces")] - private static unsafe partial void GetInterfaces(MethodTable* pMT, ObjectHandleOnStack result); + private static unsafe partial void GetInterfaces(MethodTable* pMT, ObjectHandleOnStack result, out QCallException qcallException); internal static Type[] GetInterfaces(RuntimeType type) { @@ -570,91 +576,91 @@ internal static Type[] GetInterfaces(RuntimeType type) } Type[] result = []; - GetInterfaces(typeHandle.AsMethodTable(), ObjectHandleOnStack.Create(ref result)); + GetInterfaces(typeHandle.AsMethodTable(), ObjectHandleOnStack.Create(ref result), out _); GC.KeepAlive(type); return result; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetConstraints")] - private static partial void GetConstraints(QCallTypeHandle handle, ObjectHandleOnStack types); + private static partial void GetConstraints(QCallTypeHandle handle, ObjectHandleOnStack types, out QCallException qcallException); internal Type[]? GetConstraints() { Type[]? types = null; RuntimeTypeHandle nativeHandle = GetNativeHandle(); - GetConstraints(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref types)); + GetConstraints(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref types), out _); return types; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "QCall_GetGCHandleForTypeHandle")] - private static partial IntPtr GetGCHandle(QCallTypeHandle handle, GCHandleType type); + private static partial IntPtr GetGCHandle(QCallTypeHandle handle, GCHandleType type, out QCallException qcallException); internal IntPtr GetGCHandle(GCHandleType type) { RuntimeTypeHandle nativeHandle = GetNativeHandle(); - return GetGCHandle(new QCallTypeHandle(ref nativeHandle), type); + return GetGCHandle(new QCallTypeHandle(ref nativeHandle), type, out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "QCall_FreeGCHandleForTypeHandle")] - private static partial IntPtr FreeGCHandle(QCallTypeHandle typeHandle, IntPtr objHandle); + private static partial IntPtr FreeGCHandle(QCallTypeHandle typeHandle, IntPtr objHandle, out QCallException qcallException); internal IntPtr FreeGCHandle(IntPtr objHandle) { RuntimeTypeHandle nativeHandle = GetNativeHandle(); - return FreeGCHandle(new QCallTypeHandle(ref nativeHandle), objHandle); + return FreeGCHandle(new QCallTypeHandle(ref nativeHandle), objHandle, out _); } [MethodImpl(MethodImplOptions.InternalCall)] internal static extern int GetNumVirtuals(RuntimeType type); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals")] - private static partial int GetNumVirtualsAndStaticVirtuals(QCallTypeHandle type); + private static partial int GetNumVirtualsAndStaticVirtuals(QCallTypeHandle type, out QCallException qcallException); internal static int GetNumVirtualsAndStaticVirtuals(RuntimeType type) { Debug.Assert(type != null); - return GetNumVirtualsAndStaticVirtuals(new QCallTypeHandle(ref type)); + return GetNumVirtualsAndStaticVirtuals(new QCallTypeHandle(ref type), out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_VerifyInterfaceIsImplemented")] - private static partial void VerifyInterfaceIsImplemented(QCallTypeHandle handle, QCallTypeHandle interfaceHandle); + private static partial void VerifyInterfaceIsImplemented(QCallTypeHandle handle, QCallTypeHandle interfaceHandle, out QCallException qcallException); internal void VerifyInterfaceIsImplemented(RuntimeTypeHandle interfaceHandle) { RuntimeTypeHandle nativeHandle = GetNativeHandle(); RuntimeTypeHandle nativeInterfaceHandle = interfaceHandle.GetNativeHandle(); - VerifyInterfaceIsImplemented(new QCallTypeHandle(ref nativeHandle), new QCallTypeHandle(ref nativeInterfaceHandle)); + VerifyInterfaceIsImplemented(new QCallTypeHandle(ref nativeHandle), new QCallTypeHandle(ref nativeInterfaceHandle), out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetInterfaceMethodImplementation")] - private static partial RuntimeMethodHandleInternal GetInterfaceMethodImplementation(QCallTypeHandle handle, QCallTypeHandle interfaceHandle, RuntimeMethodHandleInternal interfaceMethodHandle); + private static partial RuntimeMethodHandleInternal GetInterfaceMethodImplementation(QCallTypeHandle handle, QCallTypeHandle interfaceHandle, RuntimeMethodHandleInternal interfaceMethodHandle, out QCallException qcallException); internal RuntimeMethodHandleInternal GetInterfaceMethodImplementation(RuntimeTypeHandle interfaceHandle, RuntimeMethodHandleInternal interfaceMethodHandle) { RuntimeTypeHandle nativeHandle = GetNativeHandle(); RuntimeTypeHandle nativeInterfaceHandle = interfaceHandle.GetNativeHandle(); - return GetInterfaceMethodImplementation(new QCallTypeHandle(ref nativeHandle), new QCallTypeHandle(ref nativeInterfaceHandle), interfaceMethodHandle); + return GetInterfaceMethodImplementation(new QCallTypeHandle(ref nativeHandle), new QCallTypeHandle(ref nativeInterfaceHandle), interfaceMethodHandle, out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_IsVisible")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool _IsVisible(QCallTypeHandle typeHandle); + private static partial bool _IsVisible(QCallTypeHandle typeHandle, out QCallException qcallException); internal static bool IsVisible(RuntimeType type) { - return _IsVisible(new QCallTypeHandle(ref type)); + return _IsVisible(new QCallTypeHandle(ref type), out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_ConstructName")] - private static partial void ConstructName(QCallTypeHandle handle, TypeNameFormatFlags formatFlags, StringHandleOnStack retString); + private static partial void ConstructName(QCallTypeHandle handle, TypeNameFormatFlags formatFlags, StringHandleOnStack retString, out QCallException qcallException); internal string ConstructName(TypeNameFormatFlags formatFlags) { string? name = null; RuntimeTypeHandle nativeHandle = GetNativeHandle(); - ConstructName(new QCallTypeHandle(ref nativeHandle), formatFlags, new StringHandleOnStack(ref name)); + ConstructName(new QCallTypeHandle(ref nativeHandle), formatFlags, new StringHandleOnStack(ref name), out _); return name!; } @@ -689,10 +695,10 @@ internal static bool CanCastTo(RuntimeType type, RuntimeType target) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetDeclaringTypeHandleForGenericVariable")] - private static partial IntPtr GetDeclaringTypeHandleForGenericVariable(IntPtr typeHandle); + private static partial IntPtr GetDeclaringTypeHandleForGenericVariable(IntPtr typeHandle, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetDeclaringTypeHandle")] - private static partial IntPtr GetDeclaringTypeHandle(IntPtr typeHandle); + private static partial IntPtr GetDeclaringTypeHandle(IntPtr typeHandle, out QCallException qcallException); internal static RuntimeType? GetDeclaringType(RuntimeType type) { @@ -703,12 +709,12 @@ internal static bool CanCastTo(RuntimeType type, RuntimeType target) CorElementType elementType = (CorElementType)typeHandle.GetCorElementType(); if (elementType is CorElementType.ELEMENT_TYPE_VAR or CorElementType.ELEMENT_TYPE_MVAR) { - retTypeHandle = GetDeclaringTypeHandleForGenericVariable(type.GetUnderlyingNativeHandle()); + retTypeHandle = GetDeclaringTypeHandleForGenericVariable(type.GetUnderlyingNativeHandle(), out _); } } else { - retTypeHandle = GetDeclaringTypeHandle(type.GetUnderlyingNativeHandle()); + retTypeHandle = GetDeclaringTypeHandle(type.GetUnderlyingNativeHandle(), out _); } if (retTypeHandle == IntPtr.Zero) @@ -722,25 +728,25 @@ internal static bool CanCastTo(RuntimeType type, RuntimeType target) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetDeclaringMethodForGenericParameter")] - private static partial void GetDeclaringMethodForGenericParameter(QCallTypeHandle typeHandle, ObjectHandleOnStack result); + private static partial void GetDeclaringMethodForGenericParameter(QCallTypeHandle typeHandle, ObjectHandleOnStack result, out QCallException qcallException); internal static IRuntimeMethodInfo? GetDeclaringMethodForGenericParameter(RuntimeType type) { Debug.Assert(IsGenericVariable(type)); IRuntimeMethodInfo? method = null; - GetDeclaringMethodForGenericParameter(new QCallTypeHandle(ref type), ObjectHandleOnStack.Create(ref method)); + GetDeclaringMethodForGenericParameter(new QCallTypeHandle(ref type), ObjectHandleOnStack.Create(ref method), out _); return method; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetInstantiation")] - internal static partial void GetInstantiation(QCallTypeHandle type, ObjectHandleOnStack types, Interop.BOOL fAsRuntimeTypeArray); + internal static partial void GetInstantiation(QCallTypeHandle type, ObjectHandleOnStack types, Interop.BOOL fAsRuntimeTypeArray, out QCallException qcallException); internal RuntimeType[] GetInstantiationInternal() { RuntimeType[]? types = null; RuntimeTypeHandle nativeHandle = GetNativeHandle(); - GetInstantiation(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref types), Interop.BOOL.TRUE); + GetInstantiation(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref types), Interop.BOOL.TRUE, out _); return types!; } @@ -748,12 +754,12 @@ internal RuntimeType[] GetInstantiationInternal() { Type[]? types = null; RuntimeTypeHandle nativeHandle = GetNativeHandle(); - GetInstantiation(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref types), Interop.BOOL.FALSE); + GetInstantiation(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref types), Interop.BOOL.FALSE, out _); return types; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_Instantiate")] - private static partial void Instantiate(QCallTypeHandle handle, IntPtr* pInst, int numGenericArgs, ObjectHandleOnStack type); + private static partial void Instantiate(QCallTypeHandle handle, IntPtr* pInst, int numGenericArgs, ObjectHandleOnStack type, out QCallException qcallException); internal RuntimeType Instantiate(RuntimeType inst) { @@ -761,7 +767,7 @@ internal RuntimeType Instantiate(RuntimeType inst) RuntimeType? type = null; RuntimeTypeHandle nativeHandle = GetNativeHandle(); - Instantiate(new QCallTypeHandle(ref nativeHandle), &ptr, 1, ObjectHandleOnStack.Create(ref type)); + Instantiate(new QCallTypeHandle(ref nativeHandle), &ptr, 1, ObjectHandleOnStack.Create(ref type), out _); GC.KeepAlive(inst); return type!; } @@ -774,47 +780,47 @@ internal RuntimeType Instantiate(Type[]? inst) { RuntimeType? type = null; RuntimeTypeHandle nativeHandle = GetNativeHandle(); - Instantiate(new QCallTypeHandle(ref nativeHandle), pInst, instCount, ObjectHandleOnStack.Create(ref type)); + Instantiate(new QCallTypeHandle(ref nativeHandle), pInst, instCount, ObjectHandleOnStack.Create(ref type), out _); GC.KeepAlive(inst); return type!; } } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_MakeArray")] - private static partial void MakeArray(QCallTypeHandle handle, int rank, ObjectHandleOnStack type); + private static partial void MakeArray(QCallTypeHandle handle, int rank, ObjectHandleOnStack type, out QCallException qcallException); internal RuntimeType MakeArray(int rank) { RuntimeType? type = null; RuntimeTypeHandle nativeHandle = GetNativeHandle(); - MakeArray(new QCallTypeHandle(ref nativeHandle), rank, ObjectHandleOnStack.Create(ref type)); + MakeArray(new QCallTypeHandle(ref nativeHandle), rank, ObjectHandleOnStack.Create(ref type), out _); return type!; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_MakeSZArray")] - private static partial void MakeSZArray(QCallTypeHandle handle, ObjectHandleOnStack type); + private static partial void MakeSZArray(QCallTypeHandle handle, ObjectHandleOnStack type, out QCallException qcallException); internal RuntimeType MakeSZArray() { RuntimeType? type = null; RuntimeTypeHandle nativeHandle = GetNativeHandle(); - MakeSZArray(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref type)); + MakeSZArray(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref type), out _); return type!; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_MakeByRef")] - private static partial void MakeByRef(QCallTypeHandle handle, ObjectHandleOnStack type); + private static partial void MakeByRef(QCallTypeHandle handle, ObjectHandleOnStack type, out QCallException qcallException); internal RuntimeType MakeByRef() { RuntimeType? type = null; RuntimeTypeHandle nativeHandle = GetNativeHandle(); - MakeByRef(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref type)); + MakeByRef(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref type), out _); return type!; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_MakeFunctionPointer")] - private static partial void MakeFunctionPointer(nint* retAndParamTypes, int numArgs, [MarshalAs(UnmanagedType.Bool)] bool isUnmanaged, ObjectHandleOnStack type); + private static partial void MakeFunctionPointer(nint* retAndParamTypes, int numArgs, [MarshalAs(UnmanagedType.Bool)] bool isUnmanaged, ObjectHandleOnStack type, out QCallException qcallException); internal RuntimeType MakeFunctionPointer(Type[] parameterTypes, bool isUnmanaged) { @@ -828,7 +834,7 @@ internal RuntimeType MakeFunctionPointer(Type[] parameterTypes, bool isUnmanaged RuntimeType? type = null; fixed (nint* pRetAndParamTypeHandles = retAndParamTypeHandles) { - MakeFunctionPointer(pRetAndParamTypeHandles, parameterTypes.Length, isUnmanaged, ObjectHandleOnStack.Create(ref type)); + MakeFunctionPointer(pRetAndParamTypeHandles, parameterTypes.Length, isUnmanaged, ObjectHandleOnStack.Create(ref type), out _); } GC.KeepAlive(m_type); @@ -837,18 +843,18 @@ internal RuntimeType MakeFunctionPointer(Type[] parameterTypes, bool isUnmanaged } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_MakePointer")] - private static partial void MakePointer(QCallTypeHandle handle, ObjectHandleOnStack type); + private static partial void MakePointer(QCallTypeHandle handle, ObjectHandleOnStack type, out QCallException qcallException); internal RuntimeType MakePointer() { RuntimeType? type = null; RuntimeTypeHandle nativeHandle = GetNativeHandle(); - MakePointer(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref type)); + MakePointer(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref type), out _); return type!; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetGenericTypeDefinition")] - internal static partial void GetGenericTypeDefinition(QCallTypeHandle type, ObjectHandleOnStack retType); + internal static partial void GetGenericTypeDefinition(QCallTypeHandle type, ObjectHandleOnStack retType, out QCallException qcallException); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern bool IsGenericVariable(RuntimeType type); @@ -875,22 +881,22 @@ internal bool ContainsGenericVariables() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_SatisfiesConstraints")] - private static partial Interop.BOOL SatisfiesConstraints(QCallTypeHandle paramType, QCallTypeHandle pTypeContext, RuntimeMethodHandleInternal pMethodContext, QCallTypeHandle toType); + private static partial Interop.BOOL SatisfiesConstraints(QCallTypeHandle paramType, QCallTypeHandle pTypeContext, RuntimeMethodHandleInternal pMethodContext, QCallTypeHandle toType, out QCallException qcallException); internal static bool SatisfiesConstraints(RuntimeType paramType, RuntimeType? typeContext, RuntimeMethodInfo? methodContext, RuntimeType toType) { RuntimeMethodHandleInternal methodContextRaw = (methodContext == null) ? RuntimeMethodHandleInternal.EmptyHandle : IRuntimeMethodInfo.GetValue(methodContext); - bool result = SatisfiesConstraints(new QCallTypeHandle(ref paramType), new QCallTypeHandle(ref typeContext!), methodContextRaw, new QCallTypeHandle(ref toType)) != Interop.BOOL.FALSE; + bool result = SatisfiesConstraints(new QCallTypeHandle(ref paramType), new QCallTypeHandle(ref typeContext!), methodContextRaw, new QCallTypeHandle(ref toType), out _) != Interop.BOOL.FALSE; GC.KeepAlive(methodContext); return result; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_RegisterCollectibleTypeDependency")] - private static partial void RegisterCollectibleTypeDependency(QCallTypeHandle type, QCallAssembly assembly); + private static partial void RegisterCollectibleTypeDependency(QCallTypeHandle type, QCallAssembly assembly, out QCallException qcallException); internal static void RegisterCollectibleTypeDependency(RuntimeType type, RuntimeAssembly? assembly) { - RegisterCollectibleTypeDependency(new QCallTypeHandle(ref type), new QCallAssembly(ref assembly!)); + RegisterCollectibleTypeDependency(new QCallTypeHandle(ref type), new QCallAssembly(ref assembly!), out _); } [Obsolete(Obsoletions.LegacyFormatterImplMessage, DiagnosticId = Obsoletions.LegacyFormatterImplDiagId, UrlFormat = Obsoletions.SharedUrlFormat)] @@ -902,10 +908,10 @@ public void GetObjectData(SerializationInfo info, StreamingContext context) #if FEATURE_TYPEEQUIVALENCE [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_IsEquivalentTo")] - private static partial Interop.BOOL IsEquivalentTo(QCallTypeHandle rtType1, QCallTypeHandle rtType2); + private static partial Interop.BOOL IsEquivalentTo(QCallTypeHandle rtType1, QCallTypeHandle rtType2, out QCallException qcallException); internal static bool IsEquivalentTo(RuntimeType rtType1, RuntimeType rtType2) - => IsEquivalentTo(new QCallTypeHandle(ref rtType1), new QCallTypeHandle(ref rtType2)) == Interop.BOOL.TRUE; + => IsEquivalentTo(new QCallTypeHandle(ref rtType1), new QCallTypeHandle(ref rtType2), out _) == Interop.BOOL.TRUE; #endif // FEATURE_TYPEEQUIVALENCE } @@ -1063,11 +1069,11 @@ internal bool IsNullHandle() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetFunctionPointer")] - internal static partial IntPtr GetFunctionPointer(RuntimeMethodHandleInternal handle); + internal static partial IntPtr GetFunctionPointer(RuntimeMethodHandleInternal handle, out QCallException qcallException); public IntPtr GetFunctionPointer() { - IntPtr ptr = GetFunctionPointer(IRuntimeMethodInfo.GetValue(EnsureNonNullMethodInfo(m_value))); + IntPtr ptr = GetFunctionPointer(IRuntimeMethodInfo.GetValue(EnsureNonNullMethodInfo(m_value)), out _); GC.KeepAlive(m_value); return ptr; } @@ -1080,7 +1086,8 @@ internal static partial Interop.BOOL IsCAVisibleFromDecoratedType( QCallTypeHandle attrTypeHandle, RuntimeMethodHandleInternal attrCtor, QCallTypeHandle sourceTypeHandle, - QCallModule sourceModule); + QCallModule sourceModule, + out QCallException qcallException); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern MethodAttributes GetAttributes(RuntimeMethodHandleInternal method); @@ -1096,13 +1103,13 @@ internal static MethodAttributes GetAttributes(IRuntimeMethodInfo method) internal static extern MethodImplAttributes GetImplAttributes(IRuntimeMethodInfo method); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_ConstructInstantiation")] - private static partial void ConstructInstantiation(RuntimeMethodHandleInternal method, TypeNameFormatFlags format, StringHandleOnStack retString); + private static partial void ConstructInstantiation(RuntimeMethodHandleInternal method, TypeNameFormatFlags format, StringHandleOnStack retString, out QCallException qcallException); internal static string ConstructInstantiation(IRuntimeMethodInfo method, TypeNameFormatFlags format) { string? name = null; IRuntimeMethodInfo methodInfo = EnsureNonNullMethodInfo(method); - ConstructInstantiation(IRuntimeMethodInfo.GetValue(methodInfo), format, new StringHandleOnStack(ref name)); + ConstructInstantiation(IRuntimeMethodInfo.GetValue(methodInfo), format, new StringHandleOnStack(ref name), out _); GC.KeepAlive(methodInfo); return name!; } @@ -1177,7 +1184,7 @@ internal static MdUtf8String GetUtf8Name(RuntimeMethodHandleInternal method) [DebuggerStepThrough] [DebuggerHidden] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_InvokeMethod")] - private static partial void InvokeMethod(ObjectHandleOnStack target, void** arguments, ObjectHandleOnStack sig, Interop.BOOL isConstructor, ObjectHandleOnStack result); + private static partial void InvokeMethod(ObjectHandleOnStack target, void** arguments, ObjectHandleOnStack sig, Interop.BOOL isConstructor, ObjectHandleOnStack result, out QCallException qcallException); [DebuggerStepThrough] [DebuggerHidden] @@ -1189,7 +1196,8 @@ internal static MdUtf8String GetUtf8Name(RuntimeMethodHandleInternal method) arguments, ObjectHandleOnStack.Create(ref sig), isConstructor ? Interop.BOOL.TRUE : Interop.BOOL.FALSE, - ObjectHandleOnStack.Create(ref result)); + ObjectHandleOnStack.Create(ref result), + out _); return result; } @@ -1231,12 +1239,12 @@ ref obj.GetRawData(), } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetMethodInstantiation")] - private static partial void GetMethodInstantiation(RuntimeMethodHandleInternal method, ObjectHandleOnStack types, Interop.BOOL fAsRuntimeTypeArray); + private static partial void GetMethodInstantiation(RuntimeMethodHandleInternal method, ObjectHandleOnStack types, Interop.BOOL fAsRuntimeTypeArray, out QCallException qcallException); internal static RuntimeType[] GetMethodInstantiationInternal(IRuntimeMethodInfo method) { RuntimeType[]? types = null; - GetMethodInstantiation(IRuntimeMethodInfo.GetValue(EnsureNonNullMethodInfo(method)), ObjectHandleOnStack.Create(ref types), Interop.BOOL.TRUE); + GetMethodInstantiation(IRuntimeMethodInfo.GetValue(EnsureNonNullMethodInfo(method)), ObjectHandleOnStack.Create(ref types), Interop.BOOL.TRUE, out _); GC.KeepAlive(method); return types!; } @@ -1244,14 +1252,14 @@ internal static RuntimeType[] GetMethodInstantiationInternal(IRuntimeMethodInfo internal static RuntimeType[] GetMethodInstantiationInternal(RuntimeMethodHandleInternal method) { RuntimeType[]? types = null; - GetMethodInstantiation(method, ObjectHandleOnStack.Create(ref types), Interop.BOOL.TRUE); + GetMethodInstantiation(method, ObjectHandleOnStack.Create(ref types), Interop.BOOL.TRUE, out _); return types!; } internal static Type[]? GetMethodInstantiationPublic(IRuntimeMethodInfo method) { Type[]? types = null; - GetMethodInstantiation(IRuntimeMethodInfo.GetValue(EnsureNonNullMethodInfo(method)), ObjectHandleOnStack.Create(ref types), Interop.BOOL.FALSE); + GetMethodInstantiation(IRuntimeMethodInfo.GetValue(EnsureNonNullMethodInfo(method)), ObjectHandleOnStack.Create(ref types), Interop.BOOL.FALSE, out _); GC.KeepAlive(method); return types; } @@ -1270,7 +1278,7 @@ internal static bool HasMethodInstantiation(IRuntimeMethodInfo method) private static extern RuntimeMethodHandleInternal GetStubIfNeededInternal(RuntimeMethodHandleInternal method, RuntimeType declaringType); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetStubIfNeededSlow")] - private static partial RuntimeMethodHandleInternal GetStubIfNeededSlow(RuntimeMethodHandleInternal method, QCallTypeHandle declaringTypeHandle, ObjectHandleOnStack methodInstantiation); + private static partial RuntimeMethodHandleInternal GetStubIfNeededSlow(RuntimeMethodHandleInternal method, QCallTypeHandle declaringTypeHandle, ObjectHandleOnStack methodInstantiation, out QCallException qcallException); internal static RuntimeMethodHandleInternal GetStubIfNeeded(RuntimeMethodHandleInternal method, RuntimeType declaringType, RuntimeType[]? methodInstantiation) { @@ -1285,18 +1293,18 @@ internal static RuntimeMethodHandleInternal GetStubIfNeeded(RuntimeMethodHandleI [MethodImpl(MethodImplOptions.NoInlining)] static RuntimeMethodHandleInternal GetStubIfNeededWorker(RuntimeMethodHandleInternal method, RuntimeType declaringType, RuntimeType[]? methodInstantiation) - => GetStubIfNeededSlow(method, new QCallTypeHandle(ref declaringType), ObjectHandleOnStack.Create(ref methodInstantiation)); + => GetStubIfNeededSlow(method, new QCallTypeHandle(ref declaringType), ObjectHandleOnStack.Create(ref methodInstantiation), out _); } [MethodImpl(MethodImplOptions.InternalCall)] internal static extern RuntimeMethodHandleInternal GetMethodFromCanonical(RuntimeMethodHandleInternal method, RuntimeType declaringType); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetNativeCode")] - private static partial IntPtr GetNativeCode(RuntimeMethodHandleInternal method); + private static partial IntPtr GetNativeCode(RuntimeMethodHandleInternal method, out QCallException qcallException); internal static IntPtr GetNativeCodeInternal(IRuntimeMethodInfo method) { - IntPtr value = GetNativeCode(IRuntimeMethodInfo.GetValue(method)); + IntPtr value = GetNativeCode(IRuntimeMethodInfo.GetValue(method), out _); GC.KeepAlive(method); return value; } @@ -1315,13 +1323,13 @@ internal static bool IsGenericMethodDefinition(IRuntimeMethodInfo method) private static extern bool IsTypicalMethodDefinition(IRuntimeMethodInfo method); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetTypicalMethodDefinition")] - private static partial void GetTypicalMethodDefinition(RuntimeMethodHandleInternal method, ObjectHandleOnStack outMethod); + private static partial void GetTypicalMethodDefinition(RuntimeMethodHandleInternal method, ObjectHandleOnStack outMethod, out QCallException qcallException); internal static IRuntimeMethodInfo GetTypicalMethodDefinition(IRuntimeMethodInfo method) { if (!IsTypicalMethodDefinition(method)) { - GetTypicalMethodDefinition(IRuntimeMethodInfo.GetValue(method), ObjectHandleOnStack.Create(ref method)); + GetTypicalMethodDefinition(IRuntimeMethodInfo.GetValue(method), ObjectHandleOnStack.Create(ref method), out _); GC.KeepAlive(method); } @@ -1334,13 +1342,13 @@ internal static IRuntimeMethodInfo GetTypicalMethodDefinition(IRuntimeMethodInfo internal static int GetGenericParameterCount(IRuntimeMethodInfo method) => GetGenericParameterCount(IRuntimeMethodInfo.GetValue(method)); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_StripMethodInstantiation")] - private static partial void StripMethodInstantiation(RuntimeMethodHandleInternal method, ObjectHandleOnStack outMethod); + private static partial void StripMethodInstantiation(RuntimeMethodHandleInternal method, ObjectHandleOnStack outMethod, out QCallException qcallException); internal static IRuntimeMethodInfo StripMethodInstantiation(IRuntimeMethodInfo method) { IRuntimeMethodInfo strippedMethod = method; - StripMethodInstantiation(IRuntimeMethodInfo.GetValue(method), ObjectHandleOnStack.Create(ref strippedMethod)); + StripMethodInstantiation(IRuntimeMethodInfo.GetValue(method), ObjectHandleOnStack.Create(ref strippedMethod), out _); GC.KeepAlive(method); return strippedMethod; @@ -1350,18 +1358,18 @@ internal static IRuntimeMethodInfo StripMethodInstantiation(IRuntimeMethodInfo m internal static extern bool IsDynamicMethod(RuntimeMethodHandleInternal method); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_Destroy")] - internal static partial void Destroy(RuntimeMethodHandleInternal method); + internal static partial void Destroy(RuntimeMethodHandleInternal method, out QCallException qcallException); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern Resolver GetResolver(RuntimeMethodHandleInternal method); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetMethodBody")] - private static partial void GetMethodBody(RuntimeMethodHandleInternal method, QCallTypeHandle declaringType, ObjectHandleOnStack result); + private static partial void GetMethodBody(RuntimeMethodHandleInternal method, QCallTypeHandle declaringType, ObjectHandleOnStack result, out QCallException qcallException); internal static RuntimeMethodBody? GetMethodBody(IRuntimeMethodInfo method, RuntimeType declaringType) { RuntimeMethodBody? result = null; - GetMethodBody(IRuntimeMethodInfo.GetValue(method), new QCallTypeHandle(ref declaringType), ObjectHandleOnStack.Create(ref result)); + GetMethodBody(IRuntimeMethodInfo.GetValue(method), new QCallTypeHandle(ref declaringType), ObjectHandleOnStack.Create(ref result), out _); GC.KeepAlive(method); return result; } @@ -1579,12 +1587,12 @@ internal static RuntimeType GetApproxDeclaringType(IRuntimeFieldInfo field) [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeFieldHandle_GetRVAFieldInfo")] [return: MarshalAs(UnmanagedType.Bool)] - internal static partial bool GetRVAFieldInfo(RuntimeFieldHandleInternal field, out void* address, out uint size); + internal static partial bool GetRVAFieldInfo(RuntimeFieldHandleInternal field, out void* address, out uint size, out QCallException qcallException); internal static ref byte GetFieldDataReference(object target, RuntimeFieldInfo field) { ByteRef fieldDataRef = default; - GetFieldDataReference(((RtFieldInfo)field).GetFieldDesc(), ObjectHandleOnStack.Create(ref target), ByteRefOnStack.Create(ref fieldDataRef)); + GetFieldDataReference(((RtFieldInfo)field).GetFieldDesc(), ObjectHandleOnStack.Create(ref target), ByteRefOnStack.Create(ref fieldDataRef), out _); Debug.Assert(!Unsafe.IsNullRef(ref fieldDataRef.Value)); GC.KeepAlive(field); return ref fieldDataRef.Value; @@ -1598,7 +1606,7 @@ internal static ref byte GetFieldDataReference(ref byte target, RuntimeFieldInfo } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeFieldHandle_GetFieldDataReference")] - private static unsafe partial void GetFieldDataReference(IntPtr fieldDesc, ObjectHandleOnStack target, ByteRefOnStack fieldDataRef); + private static unsafe partial void GetFieldDataReference(IntPtr fieldDesc, ObjectHandleOnStack target, ByteRefOnStack fieldDataRef, out QCallException qcallException); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern int GetToken(IntPtr fieldDesc); @@ -1617,7 +1625,8 @@ private static partial void GetValue( QCallTypeHandle fieldType, QCallTypeHandle declaringType, [MarshalAs(UnmanagedType.Bool)] ref bool isClassInitialized, - ObjectHandleOnStack result); + ObjectHandleOnStack result, + out QCallException qcallException); internal static object? GetValue(RtFieldInfo field, object? instance, RuntimeType fieldType, RuntimeType? declaringType, ref bool isClassInitialized) { @@ -1627,7 +1636,7 @@ private static partial void GetValue( } object? result = null; - GetValue(field.GetFieldDesc(), ObjectHandleOnStack.Create(ref instance), new QCallTypeHandle(ref fieldType), new QCallTypeHandle(ref declaringType!), ref isClassInitialized, ObjectHandleOnStack.Create(ref result)); + GetValue(field.GetFieldDesc(), ObjectHandleOnStack.Create(ref instance), new QCallTypeHandle(ref fieldType), new QCallTypeHandle(ref declaringType!), ref isClassInitialized, ObjectHandleOnStack.Create(ref result), out _); GC.KeepAlive(field); return result; } @@ -1638,7 +1647,8 @@ private static partial void GetValueDirect( void* pTypedRef, QCallTypeHandle fieldType, QCallTypeHandle declaringType, - ObjectHandleOnStack result); + ObjectHandleOnStack result, + out QCallException qcallException); internal static object? GetValueDirect(RtFieldInfo field, RuntimeType fieldType, TypedReference typedRef, RuntimeType? contextType) { @@ -1648,7 +1658,7 @@ private static partial void GetValueDirect( } object? result = null; - GetValueDirect(field.GetFieldDesc(), &typedRef, new QCallTypeHandle(ref fieldType), new QCallTypeHandle(ref contextType!), ObjectHandleOnStack.Create(ref result)); + GetValueDirect(field.GetFieldDesc(), &typedRef, new QCallTypeHandle(ref fieldType), new QCallTypeHandle(ref contextType!), ObjectHandleOnStack.Create(ref result), out _); GC.KeepAlive(field); return result; } @@ -1660,7 +1670,8 @@ private static partial void SetValue( ObjectHandleOnStack value, QCallTypeHandle fieldType, QCallTypeHandle declaringType, - [MarshalAs(UnmanagedType.Bool)] ref bool isClassInitialized); + [MarshalAs(UnmanagedType.Bool)] ref bool isClassInitialized, + out QCallException qcallException); internal static void SetValue(RtFieldInfo field, object? obj, object? value, RuntimeType fieldType, RuntimeType? declaringType, ref bool isClassInitialized) { @@ -1669,7 +1680,7 @@ internal static void SetValue(RtFieldInfo field, object? obj, object? value, Run throw new ArgumentNullException(SR.Arg_InvalidHandle); } - SetValue(field.GetFieldDesc(), ObjectHandleOnStack.Create(ref obj), ObjectHandleOnStack.Create(ref value), new QCallTypeHandle(ref fieldType), new QCallTypeHandle(ref declaringType!), ref isClassInitialized); + SetValue(field.GetFieldDesc(), ObjectHandleOnStack.Create(ref obj), ObjectHandleOnStack.Create(ref value), new QCallTypeHandle(ref fieldType), new QCallTypeHandle(ref declaringType!), ref isClassInitialized, out _); GC.KeepAlive(field); } @@ -1679,7 +1690,8 @@ private static partial void SetValueDirect( void* pTypedRef, ObjectHandleOnStack value, QCallTypeHandle fieldType, - QCallTypeHandle declaringType); + QCallTypeHandle declaringType, + out QCallException qcallException); internal static void SetValueDirect(RtFieldInfo field, RuntimeType fieldType, TypedReference typedRef, object? value, RuntimeType? contextType) { @@ -1688,7 +1700,7 @@ internal static void SetValueDirect(RtFieldInfo field, RuntimeType fieldType, Ty throw new ArgumentNullException(SR.Arg_InvalidHandle); } - SetValueDirect(field.GetFieldDesc(), &typedRef, ObjectHandleOnStack.Create(ref value), new QCallTypeHandle(ref fieldType), new QCallTypeHandle(ref contextType!)); + SetValueDirect(field.GetFieldDesc(), &typedRef, ObjectHandleOnStack.Create(ref value), new QCallTypeHandle(ref fieldType), new QCallTypeHandle(ref contextType!), out _); GC.KeepAlive(field); } @@ -1727,7 +1739,7 @@ public void GetObjectData(SerializationInfo info, StreamingContext context) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeFieldHandle_GetEnCFieldAddr")] - private static partial void* GetEnCFieldAddr(ObjectHandleOnStack tgt, void* pFD); + private static partial void* GetEnCFieldAddr(ObjectHandleOnStack tgt, void* pFD, out QCallException qcallException); // implementation of CORINFO_HELP_GETFIELDADDR [StackTraceHidden] @@ -1735,7 +1747,7 @@ public void GetObjectData(SerializationInfo info, StreamingContext context) [DebuggerHidden] internal static unsafe void* GetFieldAddr(object tgt, void* pFD) { - void* addr = GetEnCFieldAddr(ObjectHandleOnStack.Create(ref tgt), pFD); + void* addr = GetEnCFieldAddr(ObjectHandleOnStack.Create(ref tgt), pFD, out _); if (addr == null) throw new NullReferenceException(); return addr; @@ -1748,7 +1760,7 @@ public void GetObjectData(SerializationInfo info, StreamingContext context) internal static unsafe void* GetStaticFieldAddr(void* pFD) { object? nullTarget = null; - void* addr = GetEnCFieldAddr(ObjectHandleOnStack.Create(ref nullTarget), pFD); + void* addr = GetEnCFieldAddr(ObjectHandleOnStack.Create(ref nullTarget), pFD, out _); if (addr == null) throw new NullReferenceException(); return addr; @@ -1808,7 +1820,8 @@ private static partial void GetDynamicMethod( byte[] sig, int sigLen, ObjectHandleOnStack resolver, - ObjectHandleOnStack result); + ObjectHandleOnStack result, + out QCallException qcallException); internal static IRuntimeMethodInfo GetDynamicMethod(RuntimeModule module, string name, byte[] sig, Resolver resolver) { @@ -1819,7 +1832,8 @@ internal static IRuntimeMethodInfo GetDynamicMethod(RuntimeModule module, string sig, sig.Length, ObjectHandleOnStack.Create(ref resolver), - ObjectHandleOnStack.Create(ref methodInfo)); + ObjectHandleOnStack.Create(ref methodInfo), + out _); return methodInfo!; } @@ -1875,7 +1889,7 @@ public RuntimeTypeHandle ResolveTypeHandle(int typeToken, RuntimeTypeHandle[]? t try { RuntimeType? type = null; - ResolveType(new QCallModule(ref module), typeToken, typeInstArgs, typeInstantiationContextHandles.Length, methodInstArgs, methodInstantiationContextHandles.Length, ObjectHandleOnStack.Create(ref type)); + ResolveType(new QCallModule(ref module), typeToken, typeInstArgs, typeInstantiationContextHandles.Length, methodInstArgs, methodInstantiationContextHandles.Length, ObjectHandleOnStack.Create(ref type), out _); GC.KeepAlive(typeInstantiationContext); GC.KeepAlive(methodInstantiationContext); return new RuntimeTypeHandle(type!); @@ -1897,7 +1911,8 @@ private static partial void ResolveType(QCallModule module, int typeInstCount, IntPtr* methodInstArgs, int methodInstCount, - ObjectHandleOnStack type); + ObjectHandleOnStack type, + out QCallException qcallException); // SQL-CLR LKG9 Compiler dependency [RequiresUnreferencedCode("Trimming changes metadata tokens")] @@ -1930,7 +1945,7 @@ internal static RuntimeMethodHandleInternal ResolveMethodHandleInternal(RuntimeM { fixed (IntPtr* typeInstArgs = typeInstantiationContext, methodInstArgs = methodInstantiationContext) { - return ResolveMethod(new QCallModule(ref module), methodToken, typeInstArgs, typeInstantiationContext.Length, methodInstArgs, methodInstantiationContext.Length); + return ResolveMethod(new QCallModule(ref module), methodToken, typeInstArgs, typeInstantiationContext.Length, methodInstArgs, methodInstantiationContext.Length, out _); } } catch (Exception) @@ -1948,7 +1963,8 @@ private static partial RuntimeMethodHandleInternal ResolveMethod(QCallModule mod IntPtr* typeInstArgs, int typeInstCount, IntPtr* methodInstArgs, - int methodInstCount); + int methodInstCount, + out QCallException qcallException); // SQL-CLR LKG9 Compiler dependency [RequiresUnreferencedCode("Trimming changes metadata tokens")] @@ -1981,7 +1997,7 @@ public RuntimeFieldHandle ResolveFieldHandle(int fieldToken, RuntimeTypeHandle[] try { IRuntimeFieldInfo? field = null; - ResolveField(new QCallModule(ref module), fieldToken, typeInstArgs, typeInstantiationContextHandles.Length, methodInstArgs, methodInstantiationContextHandles.Length, ObjectHandleOnStack.Create(ref field)); + ResolveField(new QCallModule(ref module), fieldToken, typeInstArgs, typeInstantiationContextHandles.Length, methodInstArgs, methodInstantiationContextHandles.Length, ObjectHandleOnStack.Create(ref field), out _); GC.KeepAlive(typeInstantiationContext); GC.KeepAlive(methodInstantiationContext); return new RuntimeFieldHandle(field!); @@ -2003,26 +2019,27 @@ private static partial void ResolveField(QCallModule module, int typeInstCount, IntPtr* methodInstArgs, int methodInstCount, - ObjectHandleOnStack retField); + ObjectHandleOnStack retField, + out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleHandle_GetModuleType")] - internal static partial void GetModuleType(QCallModule handle, ObjectHandleOnStack type); + internal static partial void GetModuleType(QCallModule handle, ObjectHandleOnStack type, out QCallException qcallException); internal static RuntimeType GetModuleType(RuntimeModule module) { RuntimeType? type = null; - GetModuleType(new QCallModule(ref module), ObjectHandleOnStack.Create(ref type)); + GetModuleType(new QCallModule(ref module), ObjectHandleOnStack.Create(ref type), out _); return type!; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleHandle_GetPEKind")] - private static partial void GetPEKind(QCallModule handle, int* peKind, int* machine); + private static partial void GetPEKind(QCallModule handle, int* peKind, int* machine, out QCallException qcallException); // making this internal, used by Module.GetPEKind internal static void GetPEKind(RuntimeModule module, out PortableExecutableKinds peKind, out ImageFileMachine machine) { int lKind, lMachine; - GetPEKind(new QCallModule(ref module), &lKind, &lMachine); + GetPEKind(new QCallModule(ref module), &lKind, &lMachine, out _); peKind = (PortableExecutableKinds)lKind; machine = (ImageFileMachine)lMachine; } @@ -2063,7 +2080,8 @@ private static partial void Init( ObjectHandleOnStack _this, void* pCorSig, int cCorSig, RuntimeFieldHandleInternal fieldHandle, - RuntimeMethodHandleInternal methodHandle); + RuntimeMethodHandleInternal methodHandle, + out QCallException qcallException); [MemberNotNull(nameof(_returnTypeORfieldType))] private void Init( @@ -2075,7 +2093,8 @@ private void Init( Init(ObjectHandleOnStack.Create(ref _this), pCorSig, cCorSig, fieldHandle, - methodHandle); + methodHandle, + out _); Debug.Assert(_returnTypeORfieldType != null); } @@ -2134,13 +2153,15 @@ internal RuntimeType[] Arguments [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Signature_AreEqual")] private static partial Interop.BOOL AreEqual( void* sig1, int csig1, QCallTypeHandle type1, - void* sig2, int csig2, QCallTypeHandle type2); + void* sig2, int csig2, QCallTypeHandle type2, + out QCallException qcallException); internal static bool AreEqual(Signature sig1, Signature sig2) { return AreEqual( sig1._sig, sig1._csig, new QCallTypeHandle(ref sig1._declaringType), - sig2._sig, sig2._csig, new QCallTypeHandle(ref sig2._declaringType)) != Interop.BOOL.FALSE; + sig2._sig, sig2._csig, new QCallTypeHandle(ref sig2._declaringType), + out _) != Interop.BOOL.FALSE; } [MethodImpl(MethodImplOptions.InternalCall)] @@ -2199,7 +2220,8 @@ private static partial void GetCustomModifiersAtOffset( ObjectHandleOnStack sigObj, int offset, Interop.BOOL required, - ObjectHandleOnStack result); + ObjectHandleOnStack result, + out QCallException qcallException); internal Type[] GetCustomModifiersAtOffset(int offset, bool required) { @@ -2209,7 +2231,8 @@ internal Type[] GetCustomModifiersAtOffset(int offset, bool required) ObjectHandleOnStack.Create(ref _this), offset, required ? Interop.BOOL.TRUE : Interop.BOOL.FALSE, - ObjectHandleOnStack.Create(ref result)); + ObjectHandleOnStack.Create(ref result), + out _); return result!; } #endregion diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.BoxCache.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.BoxCache.cs index ca46521ec21c78..f3d4a30943007a 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.BoxCache.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.BoxCache.cs @@ -122,7 +122,8 @@ private static void GetBoxInfo( GetBoxInfo( new QCallTypeHandle(ref rt), &pfnAllocatorTemp, &vAllocatorFirstArgTemp, - &nullableValueOffsetTemp, &valueTypeSizeTemp); + &nullableValueOffsetTemp, &valueTypeSizeTemp, + out _); pfnAllocator = pfnAllocatorTemp; vAllocatorFirstArg = vAllocatorFirstArgTemp; @@ -136,7 +137,8 @@ private static partial void GetBoxInfo( delegate** ppfnAllocator, void** pvAllocatorFirstArg, int* pNullableValueOffset, - uint* pValueTypeSize); + uint* pValueTypeSize, + out QCallException qcallException); } internal object? Box(ref byte data) diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs index 849f33fd9afb81..e550685dfd7e3a 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs @@ -1651,7 +1651,7 @@ RuntimeType CacheGenericDefinition() else { RuntimeType type = m_runtimeType; - RuntimeTypeHandle.GetGenericTypeDefinition(new QCallTypeHandle(ref type), ObjectHandleOnStack.Create(ref genericDefinition)); + RuntimeTypeHandle.GetGenericTypeDefinition(new QCallTypeHandle(ref type), ObjectHandleOnStack.Create(ref genericDefinition), out _); } return _genericTypeDefinition = genericDefinition; } @@ -3407,7 +3407,7 @@ public override unsafe Guid GUID else #endif // FEATURE_COMINTEROP { - GetGuid(th.AsMethodTable(), &result); + GetGuid(th.AsMethodTable(), &result, out _); } GC.KeepAlive(this); // Ensure TypeHandle remains alive. return result; @@ -3415,7 +3415,7 @@ public override unsafe Guid GUID } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ReflectionInvocation_GetGuid")] - private static unsafe partial void GetGuid(MethodTable* pMT, Guid* result); + private static unsafe partial void GetGuid(MethodTable* pMT, Guid* result, out QCallException qcallException); #if FEATURE_COMINTEROP [MethodImpl(MethodImplOptions.NoInlining)] @@ -3423,11 +3423,11 @@ private static unsafe void GetComObjectGuidWorker(RuntimeType type, Guid* result { Debug.Assert(type.IsGenericCOMObjectImpl()); Debug.Assert(result is not null); - GetComObjectGuid(ObjectHandleOnStack.Create(ref type), result); + GetComObjectGuid(ObjectHandleOnStack.Create(ref type), result, out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ReflectionInvocation_GetComObjectGuid")] - private static unsafe partial void GetComObjectGuid(ObjectHandleOnStack type, Guid* result); + private static unsafe partial void GetComObjectGuid(ObjectHandleOnStack type, Guid* result, out QCallException qcallException); #endif // FEATURE_COMINTEROP protected override unsafe bool IsValueTypeImpl() @@ -4146,7 +4146,8 @@ private static partial void InvokeDispMethod( ObjectHandleOnStack byrefModifiers, int lcid, ObjectHandleOnStack namedParameters, - ObjectHandleOnStack result); + ObjectHandleOnStack result, + out QCallException qcallException); private object InvokeDispMethod( string name, @@ -4168,7 +4169,8 @@ private object InvokeDispMethod( ObjectHandleOnStack.Create(ref byrefModifiers), culture, ObjectHandleOnStack.Create(ref namedParameters), - ObjectHandleOnStack.Create(ref result)); + ObjectHandleOnStack.Create(ref result), + out _); return result!; } @@ -4368,7 +4370,7 @@ internal readonly unsafe partial struct MdUtf8String { [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MdUtf8String_EqualsCaseInsensitive")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool EqualsCaseInsensitive(void* szLhs, void* szRhs, int cSz); + private static partial bool EqualsCaseInsensitive(void* szLhs, void* szRhs, int cSz, out QCallException qcallException); private readonly byte* m_pStringHeap; // This is the raw UTF8 string. private readonly int m_StringHeapByteLength; @@ -4416,7 +4418,7 @@ internal bool EqualsCaseInsensitive(MdUtf8String s) } else { - return (m_StringHeapByteLength == 0) || EqualsCaseInsensitive(s.m_pStringHeap, m_pStringHeap, m_StringHeapByteLength); + return (m_StringHeapByteLength == 0) || EqualsCaseInsensitive(s.m_pStringHeap, m_pStringHeap, m_StringHeapByteLength, out _); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CreateUninitializedCache.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CreateUninitializedCache.CoreCLR.cs index 0612afd03825c0..68761ae52f4090 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CreateUninitializedCache.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CreateUninitializedCache.CoreCLR.cs @@ -1,4 +1,4 @@ -// Licensed to the .NET Foundation under one or more agreements. +// Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. using System.Diagnostics; @@ -69,7 +69,8 @@ private static void GetCreateUninitializedInfo( GetCreateUninitializedInfo( new QCallTypeHandle(ref rt), - &pfnAllocatorTemp, &vAllocatorFirstArgTemp); + &pfnAllocatorTemp, &vAllocatorFirstArgTemp, + out _); pfnAllocator = pfnAllocatorTemp; vAllocatorFirstArg = vAllocatorFirstArgTemp; @@ -79,7 +80,8 @@ private static void GetCreateUninitializedInfo( private static partial void GetCreateUninitializedInfo( QCallTypeHandle type, delegate** ppfnAllocator, - void** pvAllocatorFirstArg); + void** pvAllocatorFirstArg, + out QCallException qcallException); } } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/String.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/String.CoreCLR.cs index 8e4fbf43f9e64d..caae0f87cf3600 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/String.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/String.CoreCLR.cs @@ -23,22 +23,22 @@ internal static unsafe string FastAllocateString(nint length) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "String_Intern")] - private static partial void Intern(StringHandleOnStack src); + private static partial void Intern(StringHandleOnStack src, out QCallException qcallException); public static string Intern(string str) { ArgumentNullException.ThrowIfNull(str); - Intern(new StringHandleOnStack(ref str!)); + Intern(new StringHandleOnStack(ref str!), out _); return str; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "String_IsInterned")] - private static partial void IsInterned(StringHandleOnStack src); + private static partial void IsInterned(StringHandleOnStack src, out QCallException qcallException); public static string? IsInterned(string str) { ArgumentNullException.ThrowIfNull(str); - IsInterned(new StringHandleOnStack(ref str!)); + IsInterned(new StringHandleOnStack(ref str!), out _); return str; } diff --git a/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs index 515ff1dece0405..786f80b3fb0a4d 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs @@ -535,21 +535,21 @@ internal static partial class ObjectMarshaler { internal static void ConvertToNative(object objSrc, IntPtr pDstVariant) { - ConvertToNative(ObjectHandleOnStack.Create(ref objSrc), pDstVariant); + ConvertToNative(ObjectHandleOnStack.Create(ref objSrc), pDstVariant, out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjectMarshaler_ConvertToNative")] - private static partial void ConvertToNative(ObjectHandleOnStack objSrc, IntPtr pDstVariant); + private static partial void ConvertToNative(ObjectHandleOnStack objSrc, IntPtr pDstVariant, out QCallException qcallException); internal static object ConvertToManaged(IntPtr pSrcVariant) { object? retObject = null; - ConvertToManaged(pSrcVariant, ObjectHandleOnStack.Create(ref retObject)); + ConvertToManaged(pSrcVariant, ObjectHandleOnStack.Create(ref retObject), out _); return retObject!; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjectMarshaler_ConvertToManaged")] - private static partial void ConvertToManaged(IntPtr pSrcVariant, ObjectHandleOnStack retObject); + private static partial void ConvertToManaged(IntPtr pSrcVariant, ObjectHandleOnStack retObject, out QCallException qcallException); internal static unsafe void ClearNative(IntPtr pVariant) { @@ -628,11 +628,11 @@ internal static IntPtr ConvertToNative(object? objSrc, IntPtr itfMT, IntPtr clas if (objSrc == null) return IntPtr.Zero; - return ConvertToNative(ObjectHandleOnStack.Create(ref objSrc), itfMT, classMT, flags); + return ConvertToNative(ObjectHandleOnStack.Create(ref objSrc), itfMT, classMT, flags, out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "InterfaceMarshaler_ConvertToNative")] - private static partial IntPtr ConvertToNative(ObjectHandleOnStack objSrc, IntPtr itfMT, IntPtr classMT, int flag); + private static partial IntPtr ConvertToNative(ObjectHandleOnStack objSrc, IntPtr itfMT, IntPtr classMT, int flag, out QCallException qcallException); internal static object? ConvertToManaged(ref IntPtr ppUnk, IntPtr itfMT, IntPtr classMT, int flags) { @@ -640,12 +640,12 @@ internal static IntPtr ConvertToNative(object? objSrc, IntPtr itfMT, IntPtr clas return null; object? retObject = null; - ConvertToManaged(ref ppUnk, itfMT, classMT, flags, ObjectHandleOnStack.Create(ref retObject)); + ConvertToManaged(ref ppUnk, itfMT, classMT, flags, ObjectHandleOnStack.Create(ref retObject), out _); return retObject; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "InterfaceMarshaler_ConvertToManaged")] - private static partial void ConvertToManaged(ref IntPtr ppUnk, IntPtr itfMT, IntPtr classMT, int flags, ObjectHandleOnStack retObject); + private static partial void ConvertToManaged(ref IntPtr ppUnk, IntPtr itfMT, IntPtr classMT, int flags, ObjectHandleOnStack retObject, out QCallException qcallException); internal static void ClearNative(IntPtr pUnk) { @@ -658,15 +658,15 @@ internal static void ClearNative(IntPtr pUnk) internal static object GetObjectForComCallableWrapperIUnknown(IntPtr unk) { object? retObject = null; - GetObjectForComCallableWrapperIUnknown(unk, ObjectHandleOnStack.Create(ref retObject)); + GetObjectForComCallableWrapperIUnknown(unk, ObjectHandleOnStack.Create(ref retObject), out _); return retObject!; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "InterfaceMarshaler_GetObjectForComCallableWrapperIUnknown")] - private static partial void GetObjectForComCallableWrapperIUnknown(IntPtr unk, ObjectHandleOnStack retObject); + private static partial void GetObjectForComCallableWrapperIUnknown(IntPtr unk, ObjectHandleOnStack retObject, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "InterfaceMarshaler_ValidateComVisibilityForIUnknown")] - internal static partial void ValidateComVisibilityForIUnknown(IntPtr unk); + internal static partial void ValidateComVisibilityForIUnknown(IntPtr unk, out QCallException qcallException); } // class InterfaceMarshaler #endif // FEATURE_COMINTEROP @@ -681,50 +681,50 @@ internal static partial class MngdSafeArrayMarshaler internal static void ConvertSpaceToNative(IntPtr pMarshalState, in object pManagedHome, IntPtr pNativeHome) { object managedHome = pManagedHome; - ConvertSpaceToNative(pMarshalState, ObjectHandleOnStack.Create(ref managedHome), pNativeHome); + ConvertSpaceToNative(pMarshalState, ObjectHandleOnStack.Create(ref managedHome), pNativeHome, out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MngdSafeArrayMarshaler_ConvertSpaceToNative")] - private static partial void ConvertSpaceToNative(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome); + private static partial void ConvertSpaceToNative(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome, out QCallException qcallException); internal static void ConvertContentsToNative(IntPtr pMarshalState, in object pManagedHome, IntPtr pNativeHome, object pOriginalManagedObject) { object managedHome = pManagedHome; object originalManagedObject = pOriginalManagedObject; - ConvertContentsToNative(pMarshalState, ObjectHandleOnStack.Create(ref managedHome), pNativeHome, ObjectHandleOnStack.Create(ref originalManagedObject)); + ConvertContentsToNative(pMarshalState, ObjectHandleOnStack.Create(ref managedHome), pNativeHome, ObjectHandleOnStack.Create(ref originalManagedObject), out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MngdSafeArrayMarshaler_ConvertContentsToNative")] - private static partial void ConvertContentsToNative(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome, ObjectHandleOnStack pOriginalManagedObject); + private static partial void ConvertContentsToNative(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome, ObjectHandleOnStack pOriginalManagedObject, out QCallException qcallException); internal static void ConvertSpaceToManaged(IntPtr pMarshalState, ref object? pManagedHome, IntPtr pNativeHome) { object? managedHome = null; - ConvertSpaceToManaged(pMarshalState, ObjectHandleOnStack.Create(ref managedHome), pNativeHome); + ConvertSpaceToManaged(pMarshalState, ObjectHandleOnStack.Create(ref managedHome), pNativeHome, out _); pManagedHome = managedHome; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MngdSafeArrayMarshaler_ConvertSpaceToManaged")] - private static partial void ConvertSpaceToManaged(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome); + private static partial void ConvertSpaceToManaged(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome, out QCallException qcallException); internal static void ConvertContentsToManaged(IntPtr pMarshalState, in object pManagedHome, IntPtr pNativeHome) { object managedHome = pManagedHome; - ConvertContentsToManaged(pMarshalState, ObjectHandleOnStack.Create(ref managedHome), pNativeHome); + ConvertContentsToManaged(pMarshalState, ObjectHandleOnStack.Create(ref managedHome), pNativeHome, out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MngdSafeArrayMarshaler_ConvertContentsToManaged")] - private static partial void ConvertContentsToManaged(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome); + private static partial void ConvertContentsToManaged(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome, out QCallException qcallException); #pragma warning disable IDE0060 // Remove unused parameter. These APIs need to match a the shape of a "managed" marshaler. internal static void ClearNative(IntPtr pMarshalState, in object pManagedHome, IntPtr pNativeHome) { - ClearNative(pMarshalState, pNativeHome); + ClearNative(pMarshalState, pNativeHome, out _); } #pragma warning restore IDE0060 // Remove unused parameter [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MngdSafeArrayMarshaler_ClearNative")] - private static partial void ClearNative(IntPtr pMarshalState, IntPtr pNativeHome); + private static partial void ClearNative(IntPtr pMarshalState, IntPtr pNativeHome, out QCallException qcallException); } // class MngdSafeArrayMarshaler #endif // FEATURE_COMINTEROP @@ -1399,7 +1399,7 @@ private static void Validate() { Debug.Assert(typeof(T).IsValueType, "StructureMarshaler can only be used for value types"); RuntimeType type = (RuntimeType)typeof(T); - bool hasLayout = Marshal.HasLayout(new QCallTypeHandle(ref type), out bool isBlittable, out int _); + bool hasLayout = Marshal.HasLayout(new QCallTypeHandle(ref type), out bool isBlittable, out int _, out _); Debug.Assert(hasLayout, "Non-layout classes should not use the layout class marshaler."); Debug.Assert(isBlittable, "Non-blittable structs should have a custom IL body generated with the marshaling logic."); } @@ -1473,7 +1473,7 @@ private static class Methods static Methods() { RuntimeTypeHandle th = typeof(T).TypeHandle; - bool hasLayout = Marshal.HasLayout(new QCallTypeHandle(ref th), out bool isBlittable, out int nativeSize); + bool hasLayout = Marshal.HasLayout(new QCallTypeHandle(ref th), out bool isBlittable, out int nativeSize, out _); Debug.Assert(hasLayout, "Non-layout classes should not use the layout class marshaler."); s_unmanagedSize = (nuint)nativeSize; if (isBlittable) @@ -1484,7 +1484,7 @@ static Methods() } else { - StubHelpers.CreateLayoutClassMarshalStubs(new QCallTypeHandle(ref th), out _convertToUnmanaged, out _convertToManaged, out _free); + StubHelpers.CreateLayoutClassMarshalStubs(new QCallTypeHandle(ref th), out _convertToUnmanaged, out _convertToManaged, out _free, out _); } } #pragma warning restore CA1810 @@ -2177,7 +2177,7 @@ internal static partial class StubHelpers /// QCall that throws an interop parameter exception selected by integer resource and parameter indices; it accesses no caller-supplied memory. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_ThrowInteropParamException")] - internal static safe partial void ThrowInteropParamException(int resID, int paramIdx); + internal static safe partial void ThrowInteropParamException(int resID, int paramIdx, out QCallException qcallException); internal static IntPtr AddToCleanupList(ref CleanupWorkListElement? pCleanupWorkList, SafeHandle handle) { @@ -2238,7 +2238,7 @@ internal static void SetPendingExceptionObject(Exception? exception) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_CreateCustomMarshaler")] - internal static partial void CreateCustomMarshaler(IntPtr pMD, int paramToken, IntPtr hndManagedType, ObjectHandleOnStack customMarshaler); + internal static partial void CreateCustomMarshaler(IntPtr pMD, int paramToken, IntPtr hndManagedType, ObjectHandleOnStack customMarshaler, out QCallException qcallException); #if FEATURE_COMINTEROP [SupportedOSPlatform("windows")] @@ -2309,7 +2309,7 @@ internal static object CreateCustomMarshaler(IntPtr pMD, int paramToken, IntPtr #endif object? retVal = null; - CreateCustomMarshaler(pMD, paramToken, hndManagedType, ObjectHandleOnStack.Create(ref retVal)); + CreateCustomMarshaler(pMD, paramToken, hndManagedType, ObjectHandleOnStack.Create(ref retVal), out _); return retVal!; } @@ -2345,7 +2345,7 @@ internal static void SafeHandleRelease(SafeHandle pHandle) private static extern IntPtr GetCOMIPFromRCW(object objSrc, IntPtr pCPCMD, out IntPtr ppTarget); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_GetCOMIPFromRCWSlow")] - private static partial IntPtr GetCOMIPFromRCWSlow(ObjectHandleOnStack objSrc, IntPtr pCPCMD, out IntPtr ppTarget, [MarshalAs(UnmanagedType.Bool)] out bool pfNeedsRelease); + private static partial IntPtr GetCOMIPFromRCWSlow(ObjectHandleOnStack objSrc, IntPtr pCPCMD, out IntPtr ppTarget, [MarshalAs(UnmanagedType.Bool)] out bool pfNeedsRelease, out QCallException qcallException); internal static IntPtr GetCOMIPFromRCW(object objSrc, IntPtr pCPCMD, out IntPtr ppTarget, out bool pfNeedsRelease) { @@ -2362,7 +2362,7 @@ internal static IntPtr GetCOMIPFromRCW(object objSrc, IntPtr pCPCMD, out IntPtr [MethodImpl(MethodImplOptions.NoInlining)] static IntPtr GetCOMIPFromRCWWorker(object objSrc, IntPtr pCPCMD, out IntPtr ppTarget, out bool pfNeedsRelease) - => GetCOMIPFromRCWSlow(ObjectHandleOnStack.Create(ref objSrc), pCPCMD, out ppTarget, out pfNeedsRelease); + => GetCOMIPFromRCWSlow(ObjectHandleOnStack.Create(ref objSrc), pCPCMD, out ppTarget, out pfNeedsRelease, out _); } #endif // FEATURE_COMINTEROP @@ -2371,10 +2371,10 @@ static IntPtr GetCOMIPFromRCWWorker(object objSrc, IntPtr pCPCMD, out IntPtr ppT // Profiler helpers //------------------------------------------------------- [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_ProfilerBeginTransitionCallback")] - internal static unsafe partial void* ProfilerBeginTransitionCallback(void* pTargetMD); + internal static unsafe partial void* ProfilerBeginTransitionCallback(void* pTargetMD, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_ProfilerEndTransitionCallback")] - internal static unsafe partial void ProfilerEndTransitionCallback(void* pTargetMD); + internal static unsafe partial void ProfilerEndTransitionCallback(void* pTargetMD, out QCallException qcallException); #endif // PROFILING_SUPPORTED //------------------------------------------------------ @@ -2394,7 +2394,7 @@ internal static void CheckStringLength(uint length) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_CreateLayoutClassMarshalStubs")] - internal static unsafe partial void CreateLayoutClassMarshalStubs(QCallTypeHandle th, out delegate* pConvertToUnmanaged, out delegate* pConvertToManaged, out delegate* pFree); + internal static unsafe partial void CreateLayoutClassMarshalStubs(QCallTypeHandle th, out delegate* pConvertToUnmanaged, out delegate* pConvertToManaged, out delegate* pFree, out QCallException qcallException); internal static unsafe void LayoutTypeConvertToUnmanaged(object obj, byte* pNative, ref CleanupWorkListElement? pCleanupWorkList) { @@ -2507,10 +2507,10 @@ internal static void ThrowWrongSizeArrayInNativeStruct() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_MarshalToManagedVaList")] - internal static partial void MarshalToManagedVaList(IntPtr va_list, IntPtr pArgIterator); + internal static partial void MarshalToManagedVaList(IntPtr va_list, IntPtr pArgIterator, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_MarshalToUnmanagedVaList")] - internal static partial void MarshalToUnmanagedVaList(IntPtr va_list, uint vaListSize, IntPtr pArgIterator); + internal static partial void MarshalToUnmanagedVaList(IntPtr va_list, uint vaListSize, IntPtr pArgIterator, out QCallException qcallException); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern uint CalcVaListSize(IntPtr va_list); @@ -2519,13 +2519,13 @@ internal static void ThrowWrongSizeArrayInNativeStruct() internal static extern void LogPinnedArgument(IntPtr localDesc, IntPtr nativeArg); [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_ValidateObject")] - private static partial void ValidateObject(ObjectHandleOnStack obj, IntPtr pMD); + private static partial void ValidateObject(ObjectHandleOnStack obj, IntPtr pMD, out QCallException qcallException); internal static void ValidateObject(object obj, IntPtr pMD) - => ValidateObject(ObjectHandleOnStack.Create(ref obj), pMD); + => ValidateObject(ObjectHandleOnStack.Create(ref obj), pMD, out _); [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_ValidateByref")] - internal static partial void ValidateByref(IntPtr byref, IntPtr pMD); // the byref is pinned so we can safely "cast" it to IntPtr + internal static partial void ValidateByref(IntPtr byref, IntPtr pMD, out QCallException qcallException); // the byref is pinned so we can safely "cast" it to IntPtr [Intrinsic] internal static IntPtr GetStubContext() => throw new UnreachableException(); // Unconditionally expanded intrinsic @@ -2533,11 +2533,11 @@ internal static void ValidateObject(object obj, IntPtr pMD) [MethodImpl(MethodImplOptions.NoInlining)] internal static void MulticastDebuggerTraceHelper(object o, int count) { - MulticastDebuggerTraceHelperQCall(ObjectHandleOnStack.Create(ref o), count); + MulticastDebuggerTraceHelperQCall(ObjectHandleOnStack.Create(ref o), count, out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_MulticastDebuggerTraceHelper")] - private static partial void MulticastDebuggerTraceHelperQCall(ObjectHandleOnStack obj, int count); + private static partial void MulticastDebuggerTraceHelperQCall(ObjectHandleOnStack obj, int count, out QCallException qcallException); [Intrinsic] internal static IntPtr NextCallReturnAddress() => throw new UnreachableException(); // Unconditionally expanded intrinsic diff --git a/src/coreclr/System.Private.CoreLib/src/System/Threading/ObjectHeader.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Threading/ObjectHeader.CoreCLR.cs index bd87f0f6c7ca56..456147b90a87cc 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Threading/ObjectHeader.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Threading/ObjectHeader.CoreCLR.cs @@ -80,7 +80,7 @@ static Lock GetLockObjectFallback(object obj) #pragma warning disable CS9216 // A value of type 'System.Threading.Lock' converted to a different type will use likely unintended monitor-based locking in 'lock' statement. object lockObj = new Lock(); #pragma warning restore CS9216 - GetOrCreateLockObject(ObjectHandleOnStack.Create(ref obj), ObjectHandleOnStack.Create(ref lockObj)); + GetOrCreateLockObject(ObjectHandleOnStack.Create(ref obj), ObjectHandleOnStack.Create(ref lockObj), out _); return (Lock)lockObj!; } } @@ -89,7 +89,7 @@ static Lock GetLockObjectFallback(object obj) private static extern IntPtr GetLockHandleIfExists(object obj); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjectHeader_GetOrCreateLockObject")] - private static partial void GetOrCreateLockObject(ObjectHandleOnStack obj, ObjectHandleOnStack lockObj); + private static partial void GetOrCreateLockObject(ObjectHandleOnStack obj, ObjectHandleOnStack lockObj, out QCallException qcallException); // // A few words about spinning choices: diff --git a/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs index 38253f6a4fe137..c47c118db9404a 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs @@ -34,6 +34,7 @@ public sealed partial class Thread private string? _name; private StartHelper? _startHelper; + private Exception? _qcallException; #if TARGET_UNIX || TARGET_BROWSER || TARGET_WASI internal WaitSubsystem.ThreadWaitInfo? _waitInfo; @@ -73,6 +74,15 @@ public sealed partial class Thread private Thread() { } + internal Exception GetAndClearQCallException() + { + Exception? exception = _qcallException; + _qcallException = null; + + Debug.Assert(exception is not null); + return exception; + } + public int ManagedThreadId { [Intrinsic] @@ -100,7 +110,7 @@ private unsafe void StartCore() fixed (char* pThreadName = _name) { Exception? exception = null; - if (StartInternal(GetNativeHandle(), _startHelper?._maxStackSize ?? 0, _priority, _isThreadPool ? Interop.BOOL.TRUE : Interop.BOOL.FALSE, pThreadName, ObjectHandleOnStack.Create(ref exception)) == Interop.BOOL.FALSE) + if (StartInternal(GetNativeHandle(), _startHelper?._maxStackSize ?? 0, _priority, _isThreadPool ? Interop.BOOL.TRUE : Interop.BOOL.FALSE, pThreadName, ObjectHandleOnStack.Create(ref exception), out _) == Interop.BOOL.FALSE) { throw new ThreadStartException(exception); } @@ -109,7 +119,7 @@ private unsafe void StartCore() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_Start")] - private static unsafe partial Interop.BOOL StartInternal(ThreadHandle t, int stackSize, int priority, Interop.BOOL isThreadPool, char* pThreadName, ObjectHandleOnStack exception); + private static unsafe partial Interop.BOOL StartInternal(ThreadHandle t, int stackSize, int priority, Interop.BOOL isThreadPool, char* pThreadName, ObjectHandleOnStack exception, out QCallException qcallException); [UnmanagedCallersOnly] private static unsafe void StartCallback(Thread* pThread) @@ -133,11 +143,11 @@ private static unsafe void StartCallback(Thread* pThread) [SuppressGCTransition] private static partial void SpinWaitInternal(int iterations); - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_SpinWait")] - private static partial void LongSpinWaitInternal(int iterations); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_LongSpinWait")] + private static partial void LongSpinWaitInternal(int iterations, out QCallException qcallException); [MethodImpl(MethodImplOptions.NoInlining)] // Slow path method. Make sure that the caller frame does not pay for PInvoke overhead. - private static void LongSpinWait(int iterations) => LongSpinWaitInternal(iterations); + private static void LongSpinWait(int iterations) => LongSpinWaitInternal(iterations, out _); /// /// Wait for a length of time proportional to 'iterations'. Each iteration is should @@ -159,29 +169,29 @@ public static void SpinWait(int iterations) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_YieldThread")] - private static partial Interop.BOOL YieldInternal(); + private static partial Interop.BOOL YieldInternal(out QCallException qcallException); - public static bool Yield() => YieldInternal() != Interop.BOOL.FALSE; + public static bool Yield() => YieldInternal(out _) != Interop.BOOL.FALSE; [MethodImpl(MethodImplOptions.NoInlining)] private static Thread InitializeCurrentThread() { Thread? thread = null; - GetCurrentThread(ObjectHandleOnStack.Create(ref thread)); + GetCurrentThread(ObjectHandleOnStack.Create(ref thread), out _); return t_currentThread = thread!; } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetCurrentThread")] - private static partial void GetCurrentThread(ObjectHandleOnStack thread); + private static partial void GetCurrentThread(ObjectHandleOnStack thread, out QCallException qcallException); private void Initialize() { Thread _this = this; - Initialize(ObjectHandleOnStack.Create(ref _this)); + Initialize(ObjectHandleOnStack.Create(ref _this), out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_Initialize")] - private static partial void Initialize(ObjectHandleOnStack thread); + private static partial void Initialize(ObjectHandleOnStack thread, out QCallException qcallException); /// Clean up the thread when it goes away. ~Thread() => InternalFinalize(); // Delegate to the unmanaged portion. @@ -191,12 +201,12 @@ private void Initialize() private void ThreadNameChanged(string? value) { - InformThreadNameChange(GetNativeHandle(), value, value?.Length ?? 0); + InformThreadNameChange(GetNativeHandle(), value, value?.Length ?? 0, out _); GC.KeepAlive(this); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_InformThreadNameChange", StringMarshalling = StringMarshalling.Utf16)] - private static partial void InformThreadNameChange(ThreadHandle t, string? name, int len); + private static partial void InformThreadNameChange(ThreadHandle t, string? name, int len, out QCallException qcallException); /// Returns true if the thread has been started and is not dead. public bool IsAlive => (ThreadState & (ThreadState.Unstarted | ThreadState.Stopped | ThreadState.Aborted)) == 0; @@ -225,7 +235,7 @@ public bool IsBackground throw new ThreadStateException(SR.ThreadState_Dead_State); } - SetIsBackground(GetNativeHandle(), value ? Interop.BOOL.TRUE : Interop.BOOL.FALSE); + SetIsBackground(GetNativeHandle(), value ? Interop.BOOL.TRUE : Interop.BOOL.FALSE, out _); GC.KeepAlive(this); if (!value) { @@ -239,7 +249,7 @@ public bool IsBackground private static partial Interop.BOOL GetIsBackground(ThreadHandle t); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_SetIsBackground")] - private static partial void SetIsBackground(ThreadHandle t, Interop.BOOL value); + private static partial void SetIsBackground(ThreadHandle t, Interop.BOOL value, out QCallException qcallException); /// Returns true if the thread is a threadpool thread. public bool IsThreadPoolThread @@ -268,7 +278,7 @@ internal set [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_SetPriority")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial void SetPriority(ObjectHandleOnStack thread, int priority); + private static partial void SetPriority(ObjectHandleOnStack thread, int priority, out QCallException qcallException); /// Returns the priority of the thread. public ThreadPriority Priority @@ -284,13 +294,13 @@ public ThreadPriority Priority set { Thread _this = this; - SetPriority(ObjectHandleOnStack.Create(ref _this), (int)value); + SetPriority(ObjectHandleOnStack.Create(ref _this), (int)value, out _); _mayNeedResetForThreadPool = true; } } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetCurrentOSThreadId")] - private static partial ulong GetCurrentOSThreadId(); + private static partial ulong GetCurrentOSThreadId(out QCallException qcallException); /// /// Return the thread state as a consistent set of bits. This is more @@ -345,15 +355,15 @@ internal void ClearWaitSleepJoinState() /// #if FEATURE_COMINTEROP_APARTMENT_SUPPORT [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetApartmentState")] - private static partial int GetApartmentState(ObjectHandleOnStack t); + private static partial int GetApartmentState(ObjectHandleOnStack t, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_SetApartmentState")] - private static partial int SetApartmentState(ObjectHandleOnStack t, int state); + private static partial int SetApartmentState(ObjectHandleOnStack t, int state, out QCallException qcallException); public ApartmentState GetApartmentState() { Thread _this = this; - return (ApartmentState)GetApartmentState(ObjectHandleOnStack.Create(ref _this)); + return (ApartmentState)GetApartmentState(ObjectHandleOnStack.Create(ref _this), out _); } private bool SetApartmentStateUnchecked(ApartmentState state, bool throwOnError) @@ -362,7 +372,7 @@ private bool SetApartmentStateUnchecked(ApartmentState state, bool throwOnError) lock (this) // This lock is only needed when the this is not the current thread. { Thread _this = this; - retState = (ApartmentState)SetApartmentState(ObjectHandleOnStack.Create(ref _this), (int)state); + retState = (ApartmentState)SetApartmentState(ObjectHandleOnStack.Create(ref _this), (int)state, out _); } // Special case where we pass in Unknown and get back MTA. @@ -436,21 +446,21 @@ public void Interrupt() #if TARGET_UNIX || TARGET_BROWSER || TARGET_WASI WaitSubsystem.Interrupt(this); #else - Interrupt(GetNativeHandle()); + Interrupt(GetNativeHandle(), out _); GC.KeepAlive(this); #endif } #if TARGET_WINDOWS [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_Interrupt")] - private static partial void Interrupt(ThreadHandle t); + private static partial void Interrupt(ThreadHandle t, out QCallException qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetOSHandle")] - private static partial SafeWaitHandle GetOSHandle(ThreadHandle t); + private static partial SafeWaitHandle GetOSHandle(ThreadHandle t, out QCallException qcallException); private SafeWaitHandle GetJoinHandle() { - SafeWaitHandle handle = GetOSHandle(GetNativeHandle()); + SafeWaitHandle handle = GetOSHandle(GetNativeHandle(), out _); GC.KeepAlive(this); return handle; } @@ -547,7 +557,7 @@ private void ResetFinalizerThreadSlow() private static extern bool CatchAtSafePoint(); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_PollGC")] - private static partial void PollGCInternal(); + private static partial void PollGCInternal(out QCallException qcallException); // GC Suspension is done by simply dropping into native code via p/invoke, and we reuse the p/invoke // mechanism for suspension. On all architectures we should have the actual stub used for the check be implemented @@ -560,7 +570,7 @@ private static void PollGC() } [MethodImpl(MethodImplOptions.NoInlining)] - static void PollGCWorker() => PollGCInternal(); + static void PollGCWorker() => PollGCInternal(out _); } #if TARGET_UNIX || TARGET_BROWSER || TARGET_WASI @@ -609,16 +619,16 @@ private static unsafe void OnThreadExited(Thread* pThread, Exception* pException } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_ReentrantWaitAny")] - internal static unsafe partial int ReentrantWaitAny([MarshalAs(UnmanagedType.Bool)] bool alertable, int timeout, int count, IntPtr* handles); + internal static unsafe partial int ReentrantWaitAny([MarshalAs(UnmanagedType.Bool)] bool alertable, int timeout, int count, IntPtr* handles, out QCallException qcallException); internal static void CheckForPendingInterrupt() { - CheckForPendingInterrupt(CurrentThread.GetNativeHandle()); + CheckForPendingInterrupt(CurrentThread.GetNativeHandle(), out _); GC.KeepAlive(CurrentThread); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_CheckForPendingInterrupt")] - private static partial void CheckForPendingInterrupt(ThreadHandle t); + private static partial void CheckForPendingInterrupt(ThreadHandle t, out QCallException qcallException); [StructLayout(LayoutKind.Sequential)] private struct NativeThreadClass diff --git a/src/coreclr/System.Private.CoreLib/src/System/TypeLoadException.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/TypeLoadException.CoreCLR.cs index eb13a78c9e2a50..684e94c0aa3e5f 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/TypeLoadException.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/TypeLoadException.CoreCLR.cs @@ -39,14 +39,14 @@ private void SetMessageField() _className ??= SR.IO_UnknownFileName; string? format = null; - GetTypeLoadExceptionMessage(_resourceId, new StringHandleOnStack(ref format)); + GetTypeLoadExceptionMessage(_resourceId, new StringHandleOnStack(ref format), out _); _message = string.Format(format!, _className, _assemblyName, _messageArg); } } } [LibraryImport(RuntimeHelpers.QCall)] - private static partial void GetTypeLoadExceptionMessage(int resourceId, StringHandleOnStack retString); + private static partial void GetTypeLoadExceptionMessage(int resourceId, StringHandleOnStack retString, out QCallException qcallException); [UnmanagedCallersOnly] internal static unsafe void Create(char* pClassName, char* pAssemblyName, char* pMessageArg, int resourceId, object* pResult, Exception* pException) diff --git a/src/coreclr/System.Private.CoreLib/src/System/ValueType.cs b/src/coreclr/System.Private.CoreLib/src/System/ValueType.cs index 2fcecf86864836..9dfc1d99e9f388 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/ValueType.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/ValueType.cs @@ -79,12 +79,12 @@ private static unsafe bool CanCompareBitsOrUseFastGetHashCode(MethodTable* pMT) return pAuxData->CanCompareBitsOrUseFastGetHashCode; } - return CanCompareBitsOrUseFastGetHashCodeHelper(pMT); + return CanCompareBitsOrUseFastGetHashCodeHelper(pMT, out _); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MethodTable_CanCompareBitsOrUseFastGetHashCode")] [return: MarshalAs(UnmanagedType.Bool)] - private static unsafe partial bool CanCompareBitsOrUseFastGetHashCodeHelper(MethodTable* pMT); + private static unsafe partial bool CanCompareBitsOrUseFastGetHashCodeHelper(MethodTable* pMT, out QCallException qcallException); /*=================================GetHashCode================================== **Action: Our algorithm for returning the hashcode is a little bit complex. We look @@ -120,7 +120,7 @@ public override unsafe int GetHashCode() else { object thisRef = this; - switch (GetHashCodeStrategy(pMT, ObjectHandleOnStack.Create(ref thisRef), out uint fieldOffset, out uint fieldSize, out MethodTable* fieldMT)) + switch (GetHashCodeStrategy(pMT, ObjectHandleOnStack.Create(ref thisRef), out uint fieldOffset, out uint fieldSize, out MethodTable* fieldMT, out _)) { case ValueTypeHashCodeStrategy.ReferenceField: hashCode.Add(Unsafe.As(ref Unsafe.AddByteOffset(ref rawData, fieldOffset)).GetHashCode()); @@ -164,7 +164,8 @@ private enum ValueTypeHashCodeStrategy [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ValueType_GetHashCodeStrategy")] private static unsafe partial ValueTypeHashCodeStrategy GetHashCodeStrategy( - MethodTable* pMT, ObjectHandleOnStack objHandle, out uint fieldOffset, out uint fieldSize, out MethodTable* fieldMT); + MethodTable* pMT, ObjectHandleOnStack objHandle, out uint fieldOffset, out uint fieldSize, out MethodTable* fieldMT, + out QCallException qcallException); public override string? ToString() { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Variant.cs b/src/coreclr/System.Private.CoreLib/src/System/Variant.cs index 0d2cb9c302c259..44b32faa103ac9 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Variant.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Variant.cs @@ -19,16 +19,16 @@ internal static partial class Variant internal static bool IsSystemDrawingColor(Type type) => type.FullName == "System.Drawing.Color"; // Matches the behavior of IsTypeRefOrDef [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Variant_ConvertValueTypeToRecord")] - private static partial void ConvertValueTypeToRecord(ObjectHandleOnStack obj, out ComVariant pOle); + private static partial void ConvertValueTypeToRecord(ObjectHandleOnStack obj, out ComVariant pOle, out QCallException qcallException); internal static ComVariant GetIUnknownOrIDispatchFromObject(object? obj) { - IntPtr pUnk = GetIUnknownOrIDispatchForObject(ObjectHandleOnStack.Create(ref obj), out bool isIDispatch); + IntPtr pUnk = GetIUnknownOrIDispatchForObject(ObjectHandleOnStack.Create(ref obj), out bool isIDispatch, out _); return ComVariant.CreateRaw(isIDispatch ? VarEnum.VT_DISPATCH : VarEnum.VT_UNKNOWN, pUnk); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetIUnknownOrIDispatchForObject")] - private static partial IntPtr GetIUnknownOrIDispatchForObject(ObjectHandleOnStack o, [MarshalAs(UnmanagedType.Bool)] out bool isIDispatch); + private static partial IntPtr GetIUnknownOrIDispatchForObject(ObjectHandleOnStack o, [MarshalAs(UnmanagedType.Bool)] out bool isIDispatch, out QCallException qcallException); private static object? GetObjectFromIUnknown(IntPtr pUnk) { @@ -170,7 +170,7 @@ internal static void MarshalHelperConvertObjectToVariant(object? o, out ComVaria // Enums handled by IConvertible case case ValueType: - ConvertValueTypeToRecord(ObjectHandleOnStack.Create(ref o), out pOle); + ConvertValueTypeToRecord(ObjectHandleOnStack.Create(ref o), out pOle, out _); break; // SafeHandle's or CriticalHandle's cannot be stored in VARIANT's. diff --git a/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/ExceptionHandling.cs b/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/ExceptionHandling.cs index 7b1d9ac811835e..140e02acd797e3 100644 --- a/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/ExceptionHandling.cs +++ b/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/ExceptionHandling.cs @@ -283,7 +283,13 @@ private static void AppendExceptionStackFrameViaClasslib(object exception, IntPt #else fixed (EH.ExInfo* pExInfo = &exInfo) { - InternalCalls.RhpAppendExceptionStackFrame(ObjectHandleOnStack.Create(ref exception), ip, sp, flags, pExInfo); + InternalCalls.RhpAppendExceptionStackFrame(ObjectHandleOnStack.Create(ref exception), ip, sp, flags, pExInfo +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } // Clear flags only if we called the function @@ -1038,7 +1044,13 @@ private static bool FindFirstPassHandler(object exception, uint idxStart, // Search the clauses for one that contains the current offset. RhEHClause ehClause; - for (uint curIdx = 0; InternalCalls.RhpEHEnumNext(&ehEnum, &ehClause); curIdx++) + for (uint curIdx = 0; InternalCalls.RhpEHEnumNext(&ehEnum, &ehClause +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); curIdx++) { // // Skip to the starting try region. This is used by collided unwinds and rethrows to pickup where @@ -1103,7 +1115,13 @@ private static bool FindFirstPassHandler(object exception, uint idxStart, } #else // NATIVEAOT shouldInvokeHandler = - InternalCalls.RhpCallFilterFunclet(ObjectHandleOnStack.Create(ref exception), pFilterFunclet, frameIter.RegisterSet); + InternalCalls.RhpCallFilterFunclet(ObjectHandleOnStack.Create(ref exception), pFilterFunclet, frameIter.RegisterSet +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); #endif // NATIVEAOT if (shouldInvokeHandler) diff --git a/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/StackFrameIterator.cs b/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/StackFrameIterator.cs index 6a9577fd935b36..705c6ac443f745 100644 --- a/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/StackFrameIterator.cs +++ b/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/StackFrameIterator.cs @@ -65,7 +65,13 @@ internal unsafe struct StackFrameIterator [DebuggerHidden] internal bool Init(EH.PAL_LIMITED_CONTEXT* pStackwalkCtx, bool instructionFault = false, bool* fIsExceptionIntercepted = null) { - return InternalCalls.RhpSfiInit(ref this, pStackwalkCtx, instructionFault, fIsExceptionIntercepted); + return InternalCalls.RhpSfiInit(ref this, pStackwalkCtx, instructionFault, fIsExceptionIntercepted +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } [StackTraceHidden] @@ -86,7 +92,13 @@ internal bool Next(uint* uExCollideClauseIdx, bool* fIsExceptionIntercepted) [DebuggerHidden] internal bool Next(uint* uExCollideClauseIdx, bool* fUnwoundReversePInvoke, bool* fIsExceptionIntercepted) { - return InternalCalls.RhpSfiNext(ref this, uExCollideClauseIdx, fUnwoundReversePInvoke, fIsExceptionIntercepted); + return InternalCalls.RhpSfiNext(ref this, uExCollideClauseIdx, fUnwoundReversePInvoke, fIsExceptionIntercepted +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } } } diff --git a/src/coreclr/runtime/MiscNativeHelpers.cpp b/src/coreclr/runtime/MiscNativeHelpers.cpp index df438c42127ac7..b5390ecbaf2221 100644 --- a/src/coreclr/runtime/MiscNativeHelpers.cpp +++ b/src/coreclr/runtime/MiscNativeHelpers.cpp @@ -7,13 +7,21 @@ #include #if defined(TARGET_X86) || defined(TARGET_AMD64) -extern "C" void QCALLTYPE X86Base_CpuId(int cpuInfo[4], int functionId, int subFunctionId) +extern "C" void QCALLTYPE X86Base_CpuId(int cpuInfo[4], int functionId, int subFunctionId +#ifndef TARGET_NATIVEAOT + , QCallException* qcallError +#endif +) { __cpuidex(cpuInfo, functionId, subFunctionId); } #endif // defined(TARGET_X86) || defined(TARGET_AMD64) -extern "C" void QCALLTYPE Interlocked_MemoryBarrierProcessWide() +extern "C" void QCALLTYPE Interlocked_MemoryBarrierProcessWide( +#ifndef TARGET_NATIVEAOT + QCallException* qcallError +#endif +) { minipal_memory_barrier_process_wide(); } diff --git a/src/coreclr/runtime/MiscNativeHelpers.h b/src/coreclr/runtime/MiscNativeHelpers.h index 4d1a5aecbd6093..aceea693ae8026 100644 --- a/src/coreclr/runtime/MiscNativeHelpers.h +++ b/src/coreclr/runtime/MiscNativeHelpers.h @@ -4,11 +4,23 @@ #ifndef __MISCNATIVEHELPERS_H__ #define __MISCNATIVEHELPERS_H__ +#ifndef TARGET_NATIVEAOT +struct QCallException; +#endif + #if defined(TARGET_X86) || defined(TARGET_AMD64) -extern "C" void QCALLTYPE X86Base_CpuId(int cpuInfo[4], int functionId, int subFunctionId); +extern "C" void QCALLTYPE X86Base_CpuId(int cpuInfo[4], int functionId, int subFunctionId +#ifndef TARGET_NATIVEAOT + , QCallException* qcallError +#endif +); #endif // defined(TARGET_X86) || defined(TARGET_AMD64) -extern "C" void QCALLTYPE Interlocked_MemoryBarrierProcessWide(); +extern "C" void QCALLTYPE Interlocked_MemoryBarrierProcessWide( +#ifndef TARGET_NATIVEAOT + QCallException* qcallError +#endif +); // WASM-TODO: once we have R2R stack walking working we should be able to set pTransitionBlock to &transitionBlock unconditionally diff --git a/src/coreclr/vm/JitQCallHelpers.h b/src/coreclr/vm/JitQCallHelpers.h index f229bff39f9fca..991d23980902d4 100644 --- a/src/coreclr/vm/JitQCallHelpers.h +++ b/src/coreclr/vm/JitQCallHelpers.h @@ -18,12 +18,12 @@ class Module; class MethodTable; class MethodDesc; -extern "C" void * QCALLTYPE ResolveVirtualFunctionPointer(QCall::ObjectHandleOnStack obj, CORINFO_CLASS_HANDLE classHnd, CORINFO_METHOD_HANDLE methodHnd); -extern "C" CORINFO_GENERIC_HANDLE QCALLTYPE GenericHandleWorker(MethodDesc * pMD, MethodTable * pMT, LPVOID signature, DWORD dictionaryIndexAndSlot, Module* pModule); -extern "C" void QCALLTYPE InitClassHelper(MethodTable* pMT); -extern "C" void QCALLTYPE ThrowInvalidCastException(CORINFO_CLASS_HANDLE pTargetType, CORINFO_CLASS_HANDLE pSourceType); -extern "C" void QCALLTYPE GetThreadStaticsByMethodTable(QCall::ByteRefOnStack refHandle, MethodTable* pMT, bool gcStatic); -extern "C" void QCALLTYPE GetThreadStaticsByIndex(QCall::ByteRefOnStack refHandle, uint32_t staticBlockIndex, bool gcStatic); -extern "C" BOOL QCALLTYPE IsInstanceOf_NoCacheLookup(CORINFO_CLASS_HANDLE type, BOOL throwCastException, QCall::ObjectHandleOnStack objOnStack); +extern "C" void * QCALLTYPE ResolveVirtualFunctionPointer(QCall::ObjectHandleOnStack obj, CORINFO_CLASS_HANDLE classHnd, CORINFO_METHOD_HANDLE methodHnd, QCallException* qcallError); +extern "C" CORINFO_GENERIC_HANDLE QCALLTYPE GenericHandleWorker(MethodDesc * pMD, MethodTable * pMT, LPVOID signature, DWORD dictionaryIndexAndSlot, Module* pModule, QCallException* qcallError); +extern "C" void QCALLTYPE InitClassHelper(MethodTable* pMT, QCallException* qcallError); +extern "C" void QCALLTYPE ThrowInvalidCastException(CORINFO_CLASS_HANDLE pTargetType, CORINFO_CLASS_HANDLE pSourceType, QCallException* qcallError); +extern "C" void QCALLTYPE GetThreadStaticsByMethodTable(QCall::ByteRefOnStack refHandle, MethodTable* pMT, bool gcStatic, QCallException* qcallError); +extern "C" void QCALLTYPE GetThreadStaticsByIndex(QCall::ByteRefOnStack refHandle, uint32_t staticBlockIndex, bool gcStatic, QCallException* qcallError); +extern "C" BOOL QCALLTYPE IsInstanceOf_NoCacheLookup(CORINFO_CLASS_HANDLE type, BOOL throwCastException, QCall::ObjectHandleOnStack objOnStack, QCallException* qcallError); #endif //_JITQCALLHELPERS_H diff --git a/src/coreclr/vm/appdomainnative.cpp b/src/coreclr/vm/appdomainnative.cpp index ffcf604e4e5280..0ef8a2afa404ee 100644 --- a/src/coreclr/vm/appdomainnative.cpp +++ b/src/coreclr/vm/appdomainnative.cpp @@ -16,7 +16,7 @@ #include "stringarraylist.h" // static -extern "C" void QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnStack assemblyLoadContext, NativeAssemblyNameParts* pAssemblyNameParts, INT32 hashAlgorithm, INT32 access, QCall::ObjectHandleOnStack retAssembly) +extern "C" void QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnStack assemblyLoadContext, NativeAssemblyNameParts* pAssemblyNameParts, INT32 hashAlgorithm, INT32 access, QCall::ObjectHandleOnStack retAssembly, QCallException* qcallError) { QCALL_CONTRACT; @@ -41,7 +41,7 @@ extern "C" void QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnS END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetLoadedAssemblies(QCall::ObjectHandleOnStack retAssemblies) +extern "C" void QCALLTYPE AssemblyNative_GetLoadedAssemblies(QCall::ObjectHandleOnStack retAssemblies, QCallException* qcallError) { QCALL_CONTRACT; @@ -141,7 +141,7 @@ namespace } // Get the value of a known host property from the binder/AppDomain state. -extern "C" BOOL QCALLTYPE AppContext_TryGetHostPropertyValue(LPCWSTR name, QCall::StringHandleOnStack retValue) +extern "C" BOOL QCALLTYPE AppContext_TryGetHostPropertyValue(LPCWSTR name, QCall::StringHandleOnStack retValue, QCallException* qcallError) { QCALL_CONTRACT; @@ -234,7 +234,7 @@ extern "C" BOOL QCALLTYPE AppContext_TryGetHostPropertyValue(LPCWSTR name, QCall return found; } -extern "C" void QCALLTYPE String_IsInterned(QCall::StringHandleOnStack str) +extern "C" void QCALLTYPE String_IsInterned(QCall::StringHandleOnStack str, QCallException* qcallError) { QCALL_CONTRACT; @@ -251,7 +251,7 @@ extern "C" void QCALLTYPE String_IsInterned(QCall::StringHandleOnStack str) END_QCALL; } -extern "C" void QCALLTYPE String_Intern(QCall::StringHandleOnStack str) +extern "C" void QCALLTYPE String_Intern(QCall::StringHandleOnStack str, QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/appdomainnative.hpp b/src/coreclr/vm/appdomainnative.hpp index 1ddcc1da98df49..7622b81fcb0e81 100644 --- a/src/coreclr/vm/appdomainnative.hpp +++ b/src/coreclr/vm/appdomainnative.hpp @@ -16,13 +16,13 @@ #include "qcall.h" -extern "C" void QCALLTYPE String_Intern(QCall::StringHandleOnStack str); -extern "C" void QCALLTYPE String_IsInterned(QCall::StringHandleOnStack str); +extern "C" void QCALLTYPE String_Intern(QCall::StringHandleOnStack str, QCallException* qcallError); +extern "C" void QCALLTYPE String_IsInterned(QCall::StringHandleOnStack str, QCallException* qcallError); -extern "C" void QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnStack assemblyLoadContext, NativeAssemblyNameParts* pAssemblyName, INT32 hashAlgorithm, INT32 access, QCall::ObjectHandleOnStack retAssembly); +extern "C" void QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnStack assemblyLoadContext, NativeAssemblyNameParts* pAssemblyName, INT32 hashAlgorithm, INT32 access, QCall::ObjectHandleOnStack retAssembly, QCallException* qcallError); extern "C" void QCALLTYPE AppContext_SetFirstChanceExceptionHandler(); -extern "C" BOOL QCALLTYPE AppContext_TryGetHostPropertyValue(LPCWSTR name, QCall::StringHandleOnStack retValue); +extern "C" BOOL QCALLTYPE AppContext_TryGetHostPropertyValue(LPCWSTR name, QCall::StringHandleOnStack retValue, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetLoadedAssemblies(QCall::ObjectHandleOnStack retAssemblies); +extern "C" void QCALLTYPE AssemblyNative_GetLoadedAssemblies(QCall::ObjectHandleOnStack retAssemblies, QCallException* qcallError); #endif diff --git a/src/coreclr/vm/arraynative.cpp b/src/coreclr/vm/arraynative.cpp index dd33b595930cf8..2f5d2c0473cf41 100644 --- a/src/coreclr/vm/arraynative.cpp +++ b/src/coreclr/vm/arraynative.cpp @@ -28,7 +28,7 @@ FCIMPL1(INT32, ArrayNative::GetCorElementTypeOfElementType, ArrayBase* arrayUNSA } FCIMPLEND -extern "C" PCODE QCALLTYPE Array_GetElementConstructorEntrypoint(QCall::TypeHandle pArrayTypeHnd) +extern "C" PCODE QCALLTYPE Array_GetElementConstructorEntrypoint(QCall::TypeHandle pArrayTypeHnd, QCallException* qcallError) { QCALL_CONTRACT; @@ -107,7 +107,7 @@ static void CheckElementType(TypeHandle elementType) } } -extern "C" void QCALLTYPE Array_CreateInstance(QCall::TypeHandle pTypeHnd, INT32 rank, INT32* pLengths, INT32* pLowerBounds, BOOL createFromArrayType, QCall::ObjectHandleOnStack retArray) +extern "C" void QCALLTYPE Array_CreateInstance(QCall::TypeHandle pTypeHnd, INT32 rank, INT32* pLengths, INT32* pLowerBounds, BOOL createFromArrayType, QCall::ObjectHandleOnStack retArray, QCallException* qcallError) { CONTRACTL { QCALL_CHECK; @@ -203,7 +203,7 @@ Done: ; END_QCALL; } -extern "C" void QCALLTYPE Array_Ctor(MethodTable* pArrayMT, UINT32 dwNumArgs, INT32* pArgList, QCall::ObjectHandleOnStack retArray) +extern "C" void QCALLTYPE Array_Ctor(MethodTable* pArrayMT, UINT32 dwNumArgs, INT32* pArgList, QCall::ObjectHandleOnStack retArray, QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/arraynative.h b/src/coreclr/vm/arraynative.h index 949c6674c0b571..5fcf51cb46a0c3 100644 --- a/src/coreclr/vm/arraynative.h +++ b/src/coreclr/vm/arraynative.h @@ -21,8 +21,8 @@ class ArrayNative FCDECL1(static INT32, GetCorElementTypeOfElementType, ArrayBase* arrayUNSAFE); }; -extern "C" PCODE QCALLTYPE Array_GetElementConstructorEntrypoint(QCall::TypeHandle pArrayTypeHnd); -extern "C" void QCALLTYPE Array_CreateInstance(QCall::TypeHandle pTypeHnd, INT32 rank, INT32* pLengths, INT32* pBounds, BOOL createFromArrayType, QCall::ObjectHandleOnStack retArray); -extern "C" void QCALLTYPE Array_Ctor(MethodTable* pArrayMT, UINT32 dwNumArgs, INT32* pArgList, QCall::ObjectHandleOnStack retArray); +extern "C" PCODE QCALLTYPE Array_GetElementConstructorEntrypoint(QCall::TypeHandle pArrayTypeHnd, QCallException* qcallError); +extern "C" void QCALLTYPE Array_CreateInstance(QCall::TypeHandle pTypeHnd, INT32 rank, INT32* pLengths, INT32* pBounds, BOOL createFromArrayType, QCall::ObjectHandleOnStack retArray, QCallException* qcallError); +extern "C" void QCALLTYPE Array_Ctor(MethodTable* pArrayMT, UINT32 dwNumArgs, INT32* pArgList, QCall::ObjectHandleOnStack retArray, QCallException* qcallError); #endif // _ARRAYNATIVE_H_ diff --git a/src/coreclr/vm/assemblynative.cpp b/src/coreclr/vm/assemblynative.cpp index 683c26aaed3445..f7d0a41e2aae8c 100644 --- a/src/coreclr/vm/assemblynative.cpp +++ b/src/coreclr/vm/assemblynative.cpp @@ -36,7 +36,8 @@ extern "C" void QCALLTYPE AssemblyNative_InternalLoad(NativeAssemblyNameParts* p QCall::StackCrawlMarkHandle stackMark, BOOL fThrowOnFileNotFound, QCall::ObjectHandleOnStack assemblyLoadContext, - QCall::ObjectHandleOnStack retAssembly) + QCall::ObjectHandleOnStack retAssembly, + QCallException* qcallError) { QCALL_CONTRACT; @@ -187,7 +188,7 @@ Assembly* AssemblyNative::LoadFromPEImage(AssemblyBinder* pBinder, PEImage *pIma return pCurDomain->LoadAssembly(&spec, pPEAssembly, FILE_LOADED); } -extern "C" void QCALLTYPE AssemblyNative_LoadFromPath(INT_PTR ptrNativeAssemblyBinder, LPCWSTR pwzILPath, QCall::ObjectHandleOnStack retLoadedAssembly) +extern "C" void QCALLTYPE AssemblyNative_LoadFromPath(INT_PTR ptrNativeAssemblyBinder, LPCWSTR pwzILPath, QCall::ObjectHandleOnStack retLoadedAssembly, QCallException* qcallError) { QCALL_CONTRACT; @@ -238,7 +239,8 @@ extern "C" void QCALLTYPE AssemblyNative_LoadFromPath(INT_PTR ptrNativeAssemblyB /*static */ extern "C" void QCALLTYPE AssemblyNative_LoadFromStream(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrAssemblyArray, INT32 cbAssemblyArrayLength, INT_PTR ptrSymbolArray, INT32 cbSymbolArrayLength, - QCall::ObjectHandleOnStack retLoadedAssembly) + QCall::ObjectHandleOnStack retLoadedAssembly, + QCallException* qcallError) { QCALL_CONTRACT; @@ -302,7 +304,7 @@ extern "C" void QCALLTYPE AssemblyNative_LoadFromStream(INT_PTR ptrNativeAssembl #ifdef TARGET_WINDOWS /*static */ -extern "C" void QCALLTYPE AssemblyNative_LoadFromInMemoryModule(INT_PTR ptrNativeAssemblyBinder, INT_PTR hModule, QCall::ObjectHandleOnStack retLoadedAssembly) +extern "C" void QCALLTYPE AssemblyNative_LoadFromInMemoryModule(INT_PTR ptrNativeAssemblyBinder, INT_PTR hModule, QCall::ObjectHandleOnStack retLoadedAssembly, QCallException* qcallError) { QCALL_CONTRACT; @@ -336,7 +338,7 @@ extern "C" void QCALLTYPE AssemblyNative_LoadFromInMemoryModule(INT_PTR ptrNativ } #endif -extern "C" void QCALLTYPE AssemblyNative_GetLocation(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString) +extern "C" void QCALLTYPE AssemblyNative_GetLocation(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallException* qcallError) { QCALL_CONTRACT; @@ -353,7 +355,8 @@ extern "C" void QCALLTYPE AssemblyNative_GetTypeCore(QCall::AssemblyHandle pAsse LPCSTR szTypeName, LPCSTR * rgszNestedTypeNames, int32_t cNestedTypeNamesLength, - QCall::ObjectHandleOnStack retType) + QCall::ObjectHandleOnStack retType, + QCallException* qcallError) { CONTRACTL { @@ -421,7 +424,8 @@ extern "C" void QCALLTYPE AssemblyNative_GetTypeCoreIgnoreCase(QCall::AssemblyHa LPCWSTR wszTypeName, LPCWSTR* rgwszNestedTypeNames, int32_t cNestedTypeNamesLength, - QCall::ObjectHandleOnStack retType) + QCall::ObjectHandleOnStack retType, + QCallException* qcallError) { CONTRACTL { @@ -496,7 +500,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetTypeCoreIgnoreCase(QCall::AssemblyHa END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetForwardedType(QCall::AssemblyHandle pAssembly, mdToken mdtExternalType, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE AssemblyNative_GetForwardedType(QCall::AssemblyHandle pAssembly, mdToken mdtExternalType, QCall::ObjectHandleOnStack retType, QCallException* qcallError) { CONTRACTL { @@ -539,7 +543,7 @@ FCIMPL1(FC_BOOL_RET, AssemblyNative::GetIsDynamic, Assembly* pAssembly) } FCIMPLEND -extern "C" void QCALLTYPE AssemblyNative_GetVersion(QCall::AssemblyHandle pAssembly, INT32* pMajorVersion, INT32* pMinorVersion, INT32*pBuildNumber, INT32* pRevisionNumber) +extern "C" void QCALLTYPE AssemblyNative_GetVersion(QCall::AssemblyHandle pAssembly, INT32* pMajorVersion, INT32* pMinorVersion, INT32*pBuildNumber, INT32* pRevisionNumber, QCallException* qcallError) { QCALL_CONTRACT; @@ -557,7 +561,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetVersion(QCall::AssemblyHandle pAssem END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetPublicKey(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retPublicKey) +extern "C" void QCALLTYPE AssemblyNative_GetPublicKey(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retPublicKey, QCallException* qcallError) { QCALL_CONTRACT; @@ -570,7 +574,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetPublicKey(QCall::AssemblyHandle pAss END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetSimpleName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retSimpleName) +extern "C" void QCALLTYPE AssemblyNative_GetSimpleName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retSimpleName, QCallException* qcallError) { QCALL_CONTRACT; @@ -579,7 +583,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetSimpleName(QCall::AssemblyHandle pAs END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetLocale(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString) +extern "C" void QCALLTYPE AssemblyNative_GetLocale(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallException* qcallError) { QCALL_CONTRACT; @@ -594,7 +598,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetLocale(QCall::AssemblyHandle pAssemb END_QCALL; } -extern "C" BOOL QCALLTYPE AssemblyNative_GetCodeBase(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString) +extern "C" BOOL QCALLTYPE AssemblyNative_GetCodeBase(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallException* qcallError) { QCALL_CONTRACT; @@ -614,7 +618,7 @@ extern "C" BOOL QCALLTYPE AssemblyNative_GetCodeBase(QCall::AssemblyHandle pAsse return ret; } -extern "C" INT32 QCALLTYPE AssemblyNative_GetHashAlgorithm(QCall::AssemblyHandle pAssembly) +extern "C" INT32 QCALLTYPE AssemblyNative_GetHashAlgorithm(QCall::AssemblyHandle pAssembly, QCallException* qcallError) { QCALL_CONTRACT; @@ -625,7 +629,7 @@ extern "C" INT32 QCALLTYPE AssemblyNative_GetHashAlgorithm(QCall::AssemblyHandle return retVal; } -extern "C" INT32 QCALLTYPE AssemblyNative_GetFlags(QCall::AssemblyHandle pAssembly) +extern "C" INT32 QCALLTYPE AssemblyNative_GetFlags(QCall::AssemblyHandle pAssembly, QCallException* qcallError) { QCALL_CONTRACT; @@ -636,7 +640,7 @@ extern "C" INT32 QCALLTYPE AssemblyNative_GetFlags(QCall::AssemblyHandle pAssemb return retVal; } -extern "C" BYTE * QCALLTYPE AssemblyNative_GetResource(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, DWORD * length) +extern "C" BYTE * QCALLTYPE AssemblyNative_GetResource(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, DWORD * length, QCallException* qcallError) { QCALL_CONTRACT; @@ -666,7 +670,7 @@ extern "C" BYTE * QCALLTYPE AssemblyNative_GetResource(QCall::AssemblyHandle pAs return pbInMemoryResource; } -extern "C" INT32 QCALLTYPE AssemblyNative_GetManifestResourceInfo(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, QCall::ObjectHandleOnStack retAssembly, QCall::StringHandleOnStack retFileName) +extern "C" INT32 QCALLTYPE AssemblyNative_GetManifestResourceInfo(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, QCall::ObjectHandleOnStack retAssembly, QCall::StringHandleOnStack retFileName, QCallException* qcallError) { QCALL_CONTRACT; @@ -708,7 +712,7 @@ extern "C" INT32 QCALLTYPE AssemblyNative_GetManifestResourceInfo(QCall::Assembl return rv; } -extern "C" void QCALLTYPE AssemblyNative_GetModules(QCall::AssemblyHandle pAssembly, BOOL fLoadIfNotFound, BOOL fGetResourceModules, QCall::ObjectHandleOnStack retModules) +extern "C" void QCALLTYPE AssemblyNative_GetModules(QCall::AssemblyHandle pAssembly, BOOL fLoadIfNotFound, BOOL fGetResourceModules, QCall::ObjectHandleOnStack retModules, QCallException* qcallError) { QCALL_CONTRACT; @@ -779,7 +783,7 @@ extern "C" uint32_t QCALLTYPE AssemblyNative_GetAssemblyCount() return g_cAssemblies; } -extern "C" void QCALLTYPE AssemblyNative_GetModule(QCall::AssemblyHandle pAssembly, LPCWSTR wszFileName, QCall::ObjectHandleOnStack retModule) +extern "C" void QCALLTYPE AssemblyNative_GetModule(QCall::AssemblyHandle pAssembly, LPCWSTR wszFileName, QCall::ObjectHandleOnStack retModule, QCallException* qcallError) { QCALL_CONTRACT; @@ -816,7 +820,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetModule(QCall::AssemblyHandle pAssemb END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes) +extern "C" void QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes, QCallException* qcallError) { QCALL_CONTRACT; @@ -933,7 +937,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetForwardedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes) +extern "C" void QCALLTYPE AssemblyNative_GetForwardedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes, QCallException* qcallError) { QCALL_CONTRACT; @@ -1001,7 +1005,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetForwardedTypes(QCall::AssemblyHandle END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetManifestResourceNames(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retResourceNames) +extern "C" void QCALLTYPE AssemblyNative_GetManifestResourceNames(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retResourceNames, QCallException* qcallError) { QCALL_CONTRACT; @@ -1043,7 +1047,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetManifestResourceNames(QCall::Assembl END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetReferencedAssemblies(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retReferencedAssemblies) +extern "C" void QCALLTYPE AssemblyNative_GetReferencedAssemblies(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retReferencedAssemblies, QCallException* qcallError) { BEGIN_QCALL; @@ -1089,7 +1093,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetReferencedAssemblies(QCall::Assembly END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetEntryPoint(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retMethod) +extern "C" void QCALLTYPE AssemblyNative_GetEntryPoint(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retMethod, QCallException* qcallError) { QCALL_CONTRACT; @@ -1113,7 +1117,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetEntryPoint(QCall::AssemblyHandle pAs // // -extern "C" void QCALLTYPE AssemblyNative_GetFullName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString) +extern "C" void QCALLTYPE AssemblyNative_GetFullName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallException* qcallError) { QCALL_CONTRACT; @@ -1126,7 +1130,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetFullName(QCall::AssemblyHandle pAsse END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetExecutingAssembly(QCall::StackCrawlMarkHandle stackMark, QCall::ObjectHandleOnStack retAssembly) +extern "C" void QCALLTYPE AssemblyNative_GetExecutingAssembly(QCall::StackCrawlMarkHandle stackMark, QCall::ObjectHandleOnStack retAssembly, QCallException* qcallError) { QCALL_CONTRACT; @@ -1142,7 +1146,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetExecutingAssembly(QCall::StackCrawlM END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetEntryAssembly(QCall::ObjectHandleOnStack retAssembly) +extern "C" void QCALLTYPE AssemblyNative_GetEntryAssembly(QCall::ObjectHandleOnStack retAssembly, QCallException* qcallError) { QCALL_CONTRACT; @@ -1158,7 +1162,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetEntryAssembly(QCall::ObjectHandleOnS END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetImageRuntimeVersion(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString) +extern "C" void QCALLTYPE AssemblyNative_GetImageRuntimeVersion(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallException* qcallError) { QCALL_CONTRACT; @@ -1181,7 +1185,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetImageRuntimeVersion(QCall::AssemblyH /*static*/ -extern "C" INT_PTR QCALLTYPE AssemblyNative_InitializeAssemblyLoadContext(INT_PTR ptrAssemblyLoadContext, BOOL fRepresentsTPALoadContext, BOOL fIsCollectible) +extern "C" INT_PTR QCALLTYPE AssemblyNative_InitializeAssemblyLoadContext(INT_PTR ptrAssemblyLoadContext, BOOL fRepresentsTPALoadContext, BOOL fIsCollectible, QCallException* qcallError) { QCALL_CONTRACT; @@ -1253,7 +1257,7 @@ extern "C" INT_PTR QCALLTYPE AssemblyNative_InitializeAssemblyLoadContext(INT_PT } /*static*/ -extern "C" void QCALLTYPE AssemblyNative_PrepareForAssemblyLoadContextRelease(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrManagedStrongAssemblyLoadContext) +extern "C" void QCALLTYPE AssemblyNative_PrepareForAssemblyLoadContextRelease(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrManagedStrongAssemblyLoadContext, QCallException* qcallError) { QCALL_CONTRACT; @@ -1271,7 +1275,7 @@ extern "C" void QCALLTYPE AssemblyNative_PrepareForAssemblyLoadContextRelease(IN } /*static*/ -extern "C" INT_PTR QCALLTYPE AssemblyNative_GetLoadContextForAssembly(QCall::AssemblyHandle pAssembly) +extern "C" INT_PTR QCALLTYPE AssemblyNative_GetLoadContextForAssembly(QCall::AssemblyHandle pAssembly, QCallException* qcallError) { QCALL_CONTRACT; @@ -1299,7 +1303,8 @@ extern "C" INT_PTR QCALLTYPE AssemblyNative_GetLoadContextForAssembly(QCall::Ass extern "C" BOOL QCALLTYPE AssemblyNative_InternalTryGetRawMetadata( QCall::AssemblyHandle assembly, UINT8 **blobRef, - INT32 *lengthRef) + INT32 *lengthRef, + QCallException* qcallError) { QCALL_CONTRACT; @@ -1331,7 +1336,7 @@ FCIMPL0(FC_BOOL_RET, AssemblyNative::IsTracingEnabled) FCIMPLEND // static -extern "C" void QCALLTYPE AssemblyNative_TraceResolvingHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR alcName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath) +extern "C" void QCALLTYPE AssemblyNative_TraceResolvingHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR alcName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath, QCallException* qcallError) { QCALL_CONTRACT; @@ -1343,7 +1348,7 @@ extern "C" void QCALLTYPE AssemblyNative_TraceResolvingHandlerInvoked(LPCWSTR as } // static -extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyResolveHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath) +extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyResolveHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath, QCallException* qcallError) { QCALL_CONTRACT; @@ -1355,7 +1360,7 @@ extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyResolveHandlerInvoked(LPCW } // static -extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyLoadFromResolveHandlerInvoked(LPCWSTR assemblyName, bool isTrackedAssembly, LPCWSTR requestingAssemblyPath, LPCWSTR requestedAssemblyPath) +extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyLoadFromResolveHandlerInvoked(LPCWSTR assemblyName, bool isTrackedAssembly, LPCWSTR requestingAssemblyPath, LPCWSTR requestedAssemblyPath, QCallException* qcallError) { QCALL_CONTRACT; @@ -1367,7 +1372,7 @@ extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyLoadFromResolveHandlerInvo } // static -extern "C" void QCALLTYPE AssemblyNative_TraceSatelliteSubdirectoryPathProbed(LPCWSTR filePath, HRESULT hr) +extern "C" void QCALLTYPE AssemblyNative_TraceSatelliteSubdirectoryPathProbed(LPCWSTR filePath, HRESULT hr, QCallException* qcallError) { QCALL_CONTRACT; @@ -1386,7 +1391,8 @@ extern "C" void QCALLTYPE AssemblyNative_ApplyUpdate( UINT8* ilDelta, INT32 ilDeltaLength, UINT8* pdbDelta, - INT32 pdbDeltaLength) + INT32 pdbDeltaLength, + QCallException* qcallError) { QCALL_CONTRACT; @@ -1424,7 +1430,7 @@ extern "C" void QCALLTYPE AssemblyNative_ApplyUpdate( } // static -extern "C" BOOL QCALLTYPE AssemblyNative_IsApplyUpdateSupported() +extern "C" BOOL QCALLTYPE AssemblyNative_IsApplyUpdateSupported(QCallException* qcallError) { QCALL_CONTRACT; @@ -1704,7 +1710,8 @@ extern "C" void QCALLTYPE TypeMapLazyDictionary_ProcessAttributes( BOOL (*newProxyTypeEntry)(CallbackContext* context, ProcessAttributesCallbackArg* arg), BOOL (*newPrecachedExternalTypeMap)(CallbackContext* context), BOOL (*newPrecachedProxyTypeMap)(CallbackContext* context), - CallbackContext* context) + CallbackContext* context, + QCallException* qcallError) { QCALL_CONTRACT; _ASSERTE(pAssembly != NULL); @@ -1831,7 +1838,8 @@ extern "C" void QCALLTYPE TypeMapLazyDictionary_ProcessAttributes( extern "C" TADDR QCALLTYPE TypeMapLazyDictionary_FindPrecachedExternalTypeMapEntry( QCall::ModuleHandle pModule, QCall::TypeHandle pGroupType, - LPCUTF8 key) + LPCUTF8 key, + QCallException* qcallError) { QCALL_CONTRACT; _ASSERTE(pModule != NULL); @@ -1864,7 +1872,8 @@ extern "C" TADDR QCALLTYPE TypeMapLazyDictionary_FindPrecachedExternalTypeMapEnt extern "C" TADDR QCALLTYPE TypeMapLazyDictionary_FindPrecachedProxyTypeMapEntry( QCall::ModuleHandle pModule, QCall::TypeHandle pGroupType, - QCall::TypeHandle pType) + QCall::TypeHandle pType, + QCallException* qcallError) { QCALL_CONTRACT; _ASSERTE(pModule != NULL); diff --git a/src/coreclr/vm/assemblynative.hpp b/src/coreclr/vm/assemblynative.hpp index 9a4a9ad9a0df9c..3228204aa974ef 100644 --- a/src/coreclr/vm/assemblynative.hpp +++ b/src/coreclr/vm/assemblynative.hpp @@ -37,109 +37,109 @@ class AssemblyNative extern "C" uint32_t QCALLTYPE AssemblyNative_GetAssemblyCount(); -extern "C" void QCALLTYPE AssemblyNative_GetEntryAssembly(QCall::ObjectHandleOnStack retAssembly); +extern "C" void QCALLTYPE AssemblyNative_GetEntryAssembly(QCall::ObjectHandleOnStack retAssembly, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetExecutingAssembly(QCall::StackCrawlMarkHandle stackMark, QCall::ObjectHandleOnStack retAssembly); +extern "C" void QCALLTYPE AssemblyNative_GetExecutingAssembly(QCall::StackCrawlMarkHandle stackMark, QCall::ObjectHandleOnStack retAssembly, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetLocale(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString); +extern "C" void QCALLTYPE AssemblyNative_GetLocale(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallException* qcallError); -extern "C" INT32 QCALLTYPE AssemblyNative_GetHashAlgorithm(QCall::AssemblyHandle pAssembly); +extern "C" INT32 QCALLTYPE AssemblyNative_GetHashAlgorithm(QCall::AssemblyHandle pAssembly, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetSimpleName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retSimpleName); +extern "C" void QCALLTYPE AssemblyNative_GetSimpleName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retSimpleName, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetPublicKey(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retPublicKey); +extern "C" void QCALLTYPE AssemblyNative_GetPublicKey(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retPublicKey, QCallException* qcallError); -extern "C" INT32 QCALLTYPE AssemblyNative_GetFlags(QCall::AssemblyHandle pAssembly); +extern "C" INT32 QCALLTYPE AssemblyNative_GetFlags(QCall::AssemblyHandle pAssembly, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetFullName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString); +extern "C" void QCALLTYPE AssemblyNative_GetFullName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetLocation(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString); +extern "C" void QCALLTYPE AssemblyNative_GetLocation(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallException* qcallError); -extern "C" BOOL QCALLTYPE AssemblyNative_GetCodeBase(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString); +extern "C" BOOL QCALLTYPE AssemblyNative_GetCodeBase(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallException* qcallError); -extern "C" BYTE * QCALLTYPE AssemblyNative_GetResource(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, DWORD * length); +extern "C" BYTE * QCALLTYPE AssemblyNative_GetResource(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, DWORD * length, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetVersion(QCall::AssemblyHandle pAssembly, INT32* pMajorVersion, INT32* pMinorVersion, INT32*pBuildNumber, INT32* pRevisionNumber); +extern "C" void QCALLTYPE AssemblyNative_GetVersion(QCall::AssemblyHandle pAssembly, INT32* pMajorVersion, INT32* pMinorVersion, INT32*pBuildNumber, INT32* pRevisionNumber, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetTypeCore(QCall::AssemblyHandle pAssembly, LPCSTR szTypeName, LPCSTR* rgszNestedTypeNames, int32_t cNestedTypeNamesLength, QCall::ObjectHandleOnStack retType); +extern "C" void QCALLTYPE AssemblyNative_GetTypeCore(QCall::AssemblyHandle pAssembly, LPCSTR szTypeName, LPCSTR* rgszNestedTypeNames, int32_t cNestedTypeNamesLength, QCall::ObjectHandleOnStack retType, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetTypeCoreIgnoreCase(QCall::AssemblyHandle pAssembly, LPCWSTR wszTypeName, LPCWSTR* rgwszNestedTypeNames, int32_t cNestedTypeNamesLength, QCall::ObjectHandleOnStack retType); +extern "C" void QCALLTYPE AssemblyNative_GetTypeCoreIgnoreCase(QCall::AssemblyHandle pAssembly, LPCWSTR wszTypeName, LPCWSTR* rgwszNestedTypeNames, int32_t cNestedTypeNamesLength, QCall::ObjectHandleOnStack retType, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetForwardedType(QCall::AssemblyHandle pAssembly, mdToken mdtExternalType, QCall::ObjectHandleOnStack retType); +extern "C" void QCALLTYPE AssemblyNative_GetForwardedType(QCall::AssemblyHandle pAssembly, mdToken mdtExternalType, QCall::ObjectHandleOnStack retType, QCallException* qcallError); -extern "C" INT32 QCALLTYPE AssemblyNative_GetManifestResourceInfo(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, QCall::ObjectHandleOnStack retAssembly, QCall::StringHandleOnStack retFileName); +extern "C" INT32 QCALLTYPE AssemblyNative_GetManifestResourceInfo(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, QCall::ObjectHandleOnStack retAssembly, QCall::StringHandleOnStack retFileName, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetModules(QCall::AssemblyHandle pAssembly, BOOL fLoadIfNotFound, BOOL fGetResourceModules, QCall::ObjectHandleOnStack retModules); +extern "C" void QCALLTYPE AssemblyNative_GetModules(QCall::AssemblyHandle pAssembly, BOOL fLoadIfNotFound, BOOL fGetResourceModules, QCall::ObjectHandleOnStack retModules, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetModule(QCall::AssemblyHandle pAssembly, LPCWSTR wszFileName, QCall::ObjectHandleOnStack retModule); +extern "C" void QCALLTYPE AssemblyNative_GetModule(QCall::AssemblyHandle pAssembly, LPCWSTR wszFileName, QCall::ObjectHandleOnStack retModule, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes); +extern "C" void QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetForwardedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes); +extern "C" void QCALLTYPE AssemblyNative_GetForwardedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetManifestResourceNames(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retResourceNames); +extern "C" void QCALLTYPE AssemblyNative_GetManifestResourceNames(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retResourceNames, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetReferencedAssemblies(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retReferencedAssemblies); +extern "C" void QCALLTYPE AssemblyNative_GetReferencedAssemblies(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retReferencedAssemblies, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetEntryPoint(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retMethod); +extern "C" void QCALLTYPE AssemblyNative_GetEntryPoint(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retMethod, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetImageRuntimeVersion(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString); +extern "C" void QCALLTYPE AssemblyNative_GetImageRuntimeVersion(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallException* qcallError); -extern "C" INT_PTR QCALLTYPE AssemblyNative_InitializeAssemblyLoadContext(INT_PTR ptrAssemblyLoadContext, BOOL fRepresentsTPALoadContext, BOOL fIsCollectible); +extern "C" INT_PTR QCALLTYPE AssemblyNative_InitializeAssemblyLoadContext(INT_PTR ptrAssemblyLoadContext, BOOL fRepresentsTPALoadContext, BOOL fIsCollectible, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_PrepareForAssemblyLoadContextRelease(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrManagedStrongAssemblyLoadContext); +extern "C" void QCALLTYPE AssemblyNative_PrepareForAssemblyLoadContextRelease(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrManagedStrongAssemblyLoadContext, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_InternalLoad(NativeAssemblyNameParts* pAssemblyName, QCall::ObjectHandleOnStack requestingAssembly, QCall::StackCrawlMarkHandle stackMark,BOOL fThrowOnFileNotFound, QCall::ObjectHandleOnStack assemblyLoadContext, QCall::ObjectHandleOnStack retAssembly); +extern "C" void QCALLTYPE AssemblyNative_InternalLoad(NativeAssemblyNameParts* pAssemblyName, QCall::ObjectHandleOnStack requestingAssembly, QCall::StackCrawlMarkHandle stackMark,BOOL fThrowOnFileNotFound, QCall::ObjectHandleOnStack assemblyLoadContext, QCall::ObjectHandleOnStack retAssembly, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_LoadFromPath(INT_PTR ptrNativeAssemblyBinder, LPCWSTR pwzILPath, QCall::ObjectHandleOnStack retLoadedAssembly); +extern "C" void QCALLTYPE AssemblyNative_LoadFromPath(INT_PTR ptrNativeAssemblyBinder, LPCWSTR pwzILPath, QCall::ObjectHandleOnStack retLoadedAssembly, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_LoadFromStream(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrAssemblyArray, INT32 cbAssemblyArrayLength, INT_PTR ptrSymbolArray, INT32 cbSymbolArrayLength, QCall::ObjectHandleOnStack retLoadedAssembly); +extern "C" void QCALLTYPE AssemblyNative_LoadFromStream(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrAssemblyArray, INT32 cbAssemblyArrayLength, INT_PTR ptrSymbolArray, INT32 cbSymbolArrayLength, QCall::ObjectHandleOnStack retLoadedAssembly, QCallException* qcallError); #ifdef TARGET_WINDOWS -extern "C" void QCALLTYPE AssemblyNative_LoadFromInMemoryModule(INT_PTR ptrNativeAssemblyBinder, INT_PTR hModule, QCall::ObjectHandleOnStack retLoadedAssembly); +extern "C" void QCALLTYPE AssemblyNative_LoadFromInMemoryModule(INT_PTR ptrNativeAssemblyBinder, INT_PTR hModule, QCall::ObjectHandleOnStack retLoadedAssembly, QCallException* qcallError); #endif -extern "C" INT_PTR QCALLTYPE AssemblyNative_GetLoadContextForAssembly(QCall::AssemblyHandle pAssembly); +extern "C" INT_PTR QCALLTYPE AssemblyNative_GetLoadContextForAssembly(QCall::AssemblyHandle pAssembly, QCallException* qcallError); -extern "C" BOOL QCALLTYPE AssemblyNative_InternalTryGetRawMetadata(QCall::AssemblyHandle assembly, UINT8 **blobRef, INT32 *lengthRef); +extern "C" BOOL QCALLTYPE AssemblyNative_InternalTryGetRawMetadata(QCall::AssemblyHandle assembly, UINT8 **blobRef, INT32 *lengthRef, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_TraceResolvingHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR alcName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath); +extern "C" void QCALLTYPE AssemblyNative_TraceResolvingHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR alcName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyResolveHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath); +extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyResolveHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyLoadFromResolveHandlerInvoked(LPCWSTR assemblyName, bool isTrackedAssembly, LPCWSTR requestingAssemblyPath, LPCWSTR requestedAssemblyPath); +extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyLoadFromResolveHandlerInvoked(LPCWSTR assemblyName, bool isTrackedAssembly, LPCWSTR requestingAssemblyPath, LPCWSTR requestedAssemblyPath, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_TraceSatelliteSubdirectoryPathProbed(LPCWSTR filePath, HRESULT hr); +extern "C" void QCALLTYPE AssemblyNative_TraceSatelliteSubdirectoryPathProbed(LPCWSTR filePath, HRESULT hr, QCallException* qcallError); -extern "C" void QCALLTYPE AssemblyNative_ApplyUpdate(QCall::AssemblyHandle assembly, UINT8* metadataDelta, INT32 metadataDeltaLength, UINT8* ilDelta, INT32 ilDeltaLength, UINT8* pdbDelta, INT32 pdbDeltaLength); +extern "C" void QCALLTYPE AssemblyNative_ApplyUpdate(QCall::AssemblyHandle assembly, UINT8* metadataDelta, INT32 metadataDeltaLength, UINT8* ilDelta, INT32 ilDeltaLength, UINT8* pdbDelta, INT32 pdbDeltaLength, QCallException* qcallError); -extern "C" BOOL QCALLTYPE AssemblyNative_IsApplyUpdateSupported(); +extern "C" BOOL QCALLTYPE AssemblyNative_IsApplyUpdateSupported(QCallException* qcallError); extern "C" void QCALLTYPE AssemblyName_InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, BaseAssemblySpec* pAssemblySpec); @@ -169,18 +169,18 @@ extern "C" void QCALLTYPE TypeMapLazyDictionary_ProcessAttributes( BOOL (*newProxyTypeEntry)(CallbackContext* context, ProcessAttributesCallbackArg* arg), BOOL (*newPrecachedExternalTypeMap)(CallbackContext* context), BOOL (*newPrecachedProxyTypeMap)(CallbackContext* context), - CallbackContext* context); + CallbackContext* context, QCallException* qcallError); extern "C" TADDR QCALLTYPE TypeMapLazyDictionary_FindPrecachedExternalTypeMapEntry( QCall::ModuleHandle pModule, QCall::TypeHandle pGroupType, LPCUTF8 key -); +, QCallException* qcallError); extern "C" TADDR QCALLTYPE TypeMapLazyDictionary_FindPrecachedProxyTypeMapEntry( QCall::ModuleHandle pModule, QCall::TypeHandle pGroupType, QCall::TypeHandle pType -); +, QCallException* qcallError); #endif diff --git a/src/coreclr/vm/clrconfignative.cpp b/src/coreclr/vm/clrconfignative.cpp index 7868f80014236c..a4abed392bd397 100644 --- a/src/coreclr/vm/clrconfignative.cpp +++ b/src/coreclr/vm/clrconfignative.cpp @@ -8,7 +8,7 @@ #include "clrconfignative.h" #include -extern "C" BOOL QCALLTYPE ClrConfig_GetConfigBoolValue(LPCWSTR name, BOOL *exist) +extern "C" BOOL QCALLTYPE ClrConfig_GetConfigBoolValue(LPCWSTR name, BOOL *exist, QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/clrconfignative.h b/src/coreclr/vm/clrconfignative.h index c2c0009442e2ed..655a1ceb012e55 100644 --- a/src/coreclr/vm/clrconfignative.h +++ b/src/coreclr/vm/clrconfignative.h @@ -4,5 +4,5 @@ #ifndef _CLRCONFIGNATIVE_H_ #define _CLRCONFIGNATIVE_H_ -extern "C" BOOL QCALLTYPE ClrConfig_GetConfigBoolValue(LPCWSTR name, BOOL *exist); +extern "C" BOOL QCALLTYPE ClrConfig_GetConfigBoolValue(LPCWSTR name, BOOL *exist, QCallException* qcallError); #endif // _CLRCONFIGNATIVE_H_ diff --git a/src/coreclr/vm/comdelegate.cpp b/src/coreclr/vm/comdelegate.cpp index dc7f140946e6a8..dbc955dd51ad32 100644 --- a/src/coreclr/vm/comdelegate.cpp +++ b/src/coreclr/vm/comdelegate.cpp @@ -973,7 +973,8 @@ static PCODE GetVirtualCallStub(MethodDesc *method, TypeHandle scopeType) } extern "C" BOOL QCALLTYPE Delegate_BindToMethodName(MethodTable* pDelegateMT, MethodTable *pTargetMT, - QCall::TypeHandle pMethodType, LPCUTF8 pszMethodName, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails) + QCall::TypeHandle pMethodType, LPCUTF8 pszMethodName, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, + QCallException* qcallError) { QCALL_CONTRACT; @@ -1078,7 +1079,8 @@ extern "C" BOOL QCALLTYPE Delegate_BindToMethodName(MethodTable* pDelegateMT, Me } extern "C" BOOL QCALLTYPE Delegate_BindToMethodInfo(MethodTable* pDelegateMT, MethodTable *pTargetMT, - MethodDesc * method, QCall::TypeHandle pMethodType, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails) + MethodDesc * method, QCall::TypeHandle pMethodType, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, + QCallException* qcallError) { QCALL_CONTRACT; @@ -1528,7 +1530,7 @@ MethodDesc* COMDelegate::GetILStubMethodDesc(EEImplMethodDesc* pDelegateMD, DWOR return PInvoke::CreateCLRToNativeILStub(&sigInfo, dwStubFlags, pDelegateMD); } -extern "C" void QCALLTYPE Delegate_InitializeVirtualCallStub(QCall::ObjectHandleOnStack d, PCODE method) +extern "C" void QCALLTYPE Delegate_InitializeVirtualCallStub(QCall::ObjectHandleOnStack d, PCODE method, QCallException* qcallError) { QCALL_CONTRACT; @@ -1548,7 +1550,7 @@ extern "C" void QCALLTYPE Delegate_InitializeVirtualCallStub(QCall::ObjectHandle END_QCALL; } -extern "C" PCODE QCALLTYPE Delegate_AdjustTarget(MethodTable* pMTTarg, PCODE method) +extern "C" PCODE QCALLTYPE Delegate_AdjustTarget(MethodTable* pMTTarg, PCODE method, QCallException* qcallError) { QCALL_CONTRACT; @@ -1606,7 +1608,7 @@ uint32_t MethodDescToNumFixedArgs(MethodDesc *pMD) // This is the single constructor for all Delegates. The compiler // doesn't provide an implementation of the Delegate constructor. We // provide that implementation through a QCall call to this method. -extern "C" void QCALLTYPE Delegate_Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, PCODE method, BindToMethodDetails *pBindToMethodDetails) +extern "C" void QCALLTYPE Delegate_Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, PCODE method, BindToMethodDetails *pBindToMethodDetails, QCallException* qcallError) { QCALL_CONTRACT; @@ -1909,7 +1911,7 @@ void COMDelegate::ThrowIfInvalidUnmanagedCallersOnlyUsage(MethodDesc* pMD) } // This method will get the MethodInfo for a delegate -extern "C" void QCALLTYPE Delegate_CreateMethodInfo(MethodDesc* methodDesc, QCall::ObjectHandleOnStack retMethodInfo) +extern "C" void QCALLTYPE Delegate_CreateMethodInfo(MethodDesc* methodDesc, QCall::ObjectHandleOnStack retMethodInfo, QCallException* qcallError) { QCALL_CONTRACT; @@ -1924,7 +1926,7 @@ extern "C" void QCALLTYPE Delegate_CreateMethodInfo(MethodDesc* methodDesc, QCal END_QCALL; } -extern "C" MethodDesc* QCALLTYPE Delegate_GetMethodDesc(QCall::ObjectHandleOnStack instance) +extern "C" MethodDesc* QCALLTYPE Delegate_GetMethodDesc(QCall::ObjectHandleOnStack instance, QCallException* qcallError) { QCALL_CONTRACT; @@ -1962,7 +1964,7 @@ FCIMPL1(PCODE, COMDelegate::GetMulticastInvoke, MethodTable* pDelegateMT) } FCIMPLEND -extern "C" PCODE QCALLTYPE Delegate_GetMulticastInvokeSlow(MethodTable* pDelegateMT) +extern "C" PCODE QCALLTYPE Delegate_GetMulticastInvokeSlow(MethodTable* pDelegateMT, QCallException* qcallError) { QCALL_CONTRACT; _ASSERTE(pDelegateMT != NULL); diff --git a/src/coreclr/vm/comdelegate.h b/src/coreclr/vm/comdelegate.h index f571ecb9daf8f2..dcb6d8e4439458 100644 --- a/src/coreclr/vm/comdelegate.h +++ b/src/coreclr/vm/comdelegate.h @@ -96,13 +96,13 @@ class COMDelegate BindToMethodDetails *pBindToMethodDetails); }; -extern "C" void QCALLTYPE Delegate_Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, PCODE method, BindToMethodDetails *pBindToMethodDetails); +extern "C" void QCALLTYPE Delegate_Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, PCODE method, BindToMethodDetails *pBindToMethodDetails, QCallException* qcallError); -extern "C" PCODE QCALLTYPE Delegate_GetMulticastInvokeSlow(MethodTable* pDelegateMT); +extern "C" PCODE QCALLTYPE Delegate_GetMulticastInvokeSlow(MethodTable* pDelegateMT, QCallException* qcallError); -extern "C" PCODE QCALLTYPE Delegate_AdjustTarget(MethodTable* pMTTarg, PCODE method); +extern "C" PCODE QCALLTYPE Delegate_AdjustTarget(MethodTable* pMTTarg, PCODE method, QCallException* qcallError); -extern "C" void QCALLTYPE Delegate_InitializeVirtualCallStub(QCall::ObjectHandleOnStack d, PCODE method); +extern "C" void QCALLTYPE Delegate_InitializeVirtualCallStub(QCall::ObjectHandleOnStack d, PCODE method, QCallException* qcallError); // These flags effect the way BindToMethodInfo and BindToMethodName are allowed to bind a delegate to a target method. Their // values must be kept in sync with the definition in bcl\system\delegate.cs. @@ -118,14 +118,16 @@ enum DelegateBindingFlags }; extern "C" BOOL QCALLTYPE Delegate_BindToMethodName(MethodTable* pDelegateMT, MethodTable *pTargetMT, - QCall::TypeHandle pMethodType, LPCUTF8 pszMethodName, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails); + QCall::TypeHandle pMethodType, LPCUTF8 pszMethodName, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, + QCallException* qcallError); extern "C" BOOL QCALLTYPE Delegate_BindToMethodInfo(MethodTable* pDelegateMT, MethodTable *pTargetMT, - MethodDesc * method, QCall::TypeHandle pMethodType, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails); + MethodDesc * method, QCall::TypeHandle pMethodType, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, + QCallException* qcallError); -extern "C" void QCALLTYPE Delegate_CreateMethodInfo(MethodDesc* methodDesc, QCall::ObjectHandleOnStack retMethodInfo); +extern "C" void QCALLTYPE Delegate_CreateMethodInfo(MethodDesc* methodDesc, QCall::ObjectHandleOnStack retMethodInfo, QCallException* qcallError); -extern "C" MethodDesc* QCALLTYPE Delegate_GetMethodDesc(QCall::ObjectHandleOnStack instance); +extern "C" MethodDesc* QCALLTYPE Delegate_GetMethodDesc(QCall::ObjectHandleOnStack instance, QCallException* qcallError); void DistributeEvent(OBJECTREF *pDelegate, OBJECTREF *pDomain); diff --git a/src/coreclr/vm/comdependenthandle.cpp b/src/coreclr/vm/comdependenthandle.cpp index a76d62316c6880..6d338782b41af4 100644 --- a/src/coreclr/vm/comdependenthandle.cpp +++ b/src/coreclr/vm/comdependenthandle.cpp @@ -26,7 +26,7 @@ FCIMPL2(OBJECTHANDLE, DependentHandle::InternalAlloc, Object *target, Object *de } FCIMPLEND -extern "C" OBJECTHANDLE QCALLTYPE DependentHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack target, QCall::ObjectHandleOnStack dependent) +extern "C" OBJECTHANDLE QCALLTYPE DependentHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack target, QCall::ObjectHandleOnStack dependent, QCallException* qcallError) { QCALL_CONTRACT; @@ -122,7 +122,7 @@ FCIMPL1(FC_BOOL_RET, DependentHandle::InternalFree, OBJECTHANDLE handle) } FCIMPLEND -extern "C" void QCALLTYPE DependentHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle) +extern "C" void QCALLTYPE DependentHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle, QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/comdependenthandle.h b/src/coreclr/vm/comdependenthandle.h index 32cc5bef53f9fc..9b13b2b0d236e9 100644 --- a/src/coreclr/vm/comdependenthandle.h +++ b/src/coreclr/vm/comdependenthandle.h @@ -49,7 +49,7 @@ class DependentHandle FCDECL1(static FC_BOOL_RET, InternalFree, OBJECTHANDLE handle); }; -extern "C" OBJECTHANDLE QCALLTYPE DependentHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack target, QCall::ObjectHandleOnStack dependent); -extern "C" void QCALLTYPE DependentHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle); +extern "C" OBJECTHANDLE QCALLTYPE DependentHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack target, QCall::ObjectHandleOnStack dependent, QCallException* qcallError); +extern "C" void QCALLTYPE DependentHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle, QCallException* qcallError); #endif diff --git a/src/coreclr/vm/comdynamic.cpp b/src/coreclr/vm/comdynamic.cpp index 65f780230a82ca..02640a98e44f87 100644 --- a/src/coreclr/vm/comdynamic.cpp +++ b/src/coreclr/vm/comdynamic.cpp @@ -42,7 +42,8 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineGenericParam(QCall::ModuleHandle pM INT32 tkParent, INT32 attributes, INT32 position, - INT32 * pConstraintTokens) + INT32 * pConstraintTokens, + QCallException* qcallError) { QCALL_CONTRACT; @@ -66,7 +67,8 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineType(QCall::ModuleHandle pModule, INT32 tkParent, INT32 attributes, INT32 tkEnclosingType, - INT32 * pInterfaceTokens) + INT32 * pInterfaceTokens, + QCallException* qcallError) { QCALL_CONTRACT; @@ -74,7 +76,7 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineType(QCall::ModuleHandle pModule, BEGIN_QCALL; - classE = COMDynamicWrite::DefineType(pModule, wszFullName, tkParent, attributes, tkEnclosingType, pInterfaceTokens); + classE = COMDynamicWrite::DefineType(pModule, wszFullName, tkParent, attributes, tkEnclosingType, pInterfaceTokens, qcallError); END_QCALL; @@ -86,7 +88,8 @@ INT32 COMDynamicWrite::DefineType(Module* pModule, INT32 tkParent, INT32 attributes, INT32 tkEnclosingType, - INT32 * pInterfaceTokens) + INT32 * pInterfaceTokens, + QCallException* qcallError) { QCALL_CONTRACT; @@ -141,7 +144,7 @@ INT32 COMDynamicWrite::DefineType(Module* pModule, } // This function will reset the parent class in metadata -extern "C" void QCALLTYPE TypeBuilder_SetParentType(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkParent) +extern "C" void QCALLTYPE TypeBuilder_SetParentType(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkParent, QCallException* qcallError) { QCALL_CONTRACT; @@ -156,7 +159,7 @@ extern "C" void QCALLTYPE TypeBuilder_SetParentType(QCall::ModuleHandle pModule, } // This function will add another interface impl -extern "C" void QCALLTYPE TypeBuilder_AddInterfaceImpl(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkInterface) +extern "C" void QCALLTYPE TypeBuilder_AddInterfaceImpl(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkInterface, QCallException* qcallError) { QCALL_CONTRACT; @@ -171,7 +174,7 @@ extern "C" void QCALLTYPE TypeBuilder_AddInterfaceImpl(QCall::ModuleHandle pModu } // This function will create a method within the class -extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethodSpec(QCall::ModuleHandle pModule, INT32 tkParent, LPCBYTE pSignature, INT32 sigLength) +extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethodSpec(QCall::ModuleHandle pModule, INT32 tkParent, LPCBYTE pSignature, INT32 sigLength, QCallException* qcallError) { QCALL_CONTRACT; @@ -193,7 +196,7 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethodSpec(QCall::ModuleHandle pMod return (INT32) memberE; } -extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethod(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attributes) +extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethod(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attributes, QCallException* qcallError) { QCALL_CONTRACT; @@ -225,7 +228,7 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethod(QCall::ModuleHandle pModule, **Arguments: **Exceptions: ==============================================================================*/ -extern "C" mdFieldDef QCALLTYPE TypeBuilder_DefineField(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attr) +extern "C" mdFieldDef QCALLTYPE TypeBuilder_DefineField(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attr, QCallException* qcallError) { QCALL_CONTRACT; @@ -310,7 +313,8 @@ extern "C" void QCALLTYPE TypeBuilder_SetMethodIL(QCall::ModuleHandle pModule, ExceptionInstance * pExceptions, INT32 numExceptions, INT32 * pTokenFixups, - INT32 numTokenFixups) + INT32 numTokenFixups, + QCallException* qcallError) { QCALL_CONTRACT; @@ -469,7 +473,7 @@ extern "C" void QCALLTYPE TypeBuilder_SetMethodIL(QCall::ModuleHandle pModule, END_QCALL; } -extern "C" void QCALLTYPE TypeBuilder_TermCreateClass(QCall::ModuleHandle pModule, INT32 tk, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE TypeBuilder_TermCreateClass(QCall::ModuleHandle pModule, INT32 tk, QCall::ObjectHandleOnStack retType, QCallException* qcallError) { QCALL_CONTRACT; @@ -511,7 +515,7 @@ void COMDynamicWrite::TermCreateClass(Module* pModule, INT32 tk, QCall::ObjectHa **Arguments: **Exceptions: ==============================================================================*/ -extern "C" void QCALLTYPE TypeBuilder_SetPInvokeData(QCall::ModuleHandle pModule, LPCWSTR wszDllName, LPCWSTR wszFunctionName, INT32 token, INT32 linkFlags) +extern "C" void QCALLTYPE TypeBuilder_SetPInvokeData(QCall::ModuleHandle pModule, LPCWSTR wszDllName, LPCWSTR wszFunctionName, INT32 token, INT32 linkFlags, QCallException* qcallError) { QCALL_CONTRACT; @@ -540,7 +544,7 @@ extern "C" void QCALLTYPE TypeBuilder_SetPInvokeData(QCall::ModuleHandle pModule **Arguments: **Exceptions: ==============================================================================*/ -extern "C" INT32 QCALLTYPE TypeBuilder_DefineProperty(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, LPCBYTE pSignature, INT32 sigLength) +extern "C" INT32 QCALLTYPE TypeBuilder_DefineProperty(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, LPCBYTE pSignature, INT32 sigLength, QCallException* qcallError) { QCALL_CONTRACT; @@ -577,7 +581,7 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineProperty(QCall::ModuleHandle pModul **Arguments: **Exceptions: ==============================================================================*/ -extern "C" INT32 QCALLTYPE TypeBuilder_DefineEvent(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, INT32 tkEventType) +extern "C" INT32 QCALLTYPE TypeBuilder_DefineEvent(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, INT32 tkEventType, QCallException* qcallError) { QCALL_CONTRACT; @@ -607,7 +611,7 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineEvent(QCall::ModuleHandle pModule, **Arguments: **Exceptions: ==============================================================================*/ -extern "C" void QCALLTYPE TypeBuilder_DefineMethodSemantics(QCall::ModuleHandle pModule, INT32 tkAssociation, INT32 attr, INT32 tkMethod) +extern "C" void QCALLTYPE TypeBuilder_DefineMethodSemantics(QCall::ModuleHandle pModule, INT32 tkAssociation, INT32 attr, INT32 tkMethod, QCallException* qcallError) { QCALL_CONTRACT; @@ -628,7 +632,7 @@ extern "C" void QCALLTYPE TypeBuilder_DefineMethodSemantics(QCall::ModuleHandle /*============================SetMethodImpl============================ ** To set a Method's Implementation flags ==============================================================================*/ -extern "C" void QCALLTYPE TypeBuilder_SetMethodImpl(QCall::ModuleHandle pModule, INT32 tkMethod, INT32 attr) +extern "C" void QCALLTYPE TypeBuilder_SetMethodImpl(QCall::ModuleHandle pModule, INT32 tkMethod, INT32 attr, QCallException* qcallError) { QCALL_CONTRACT; @@ -648,7 +652,7 @@ extern "C" void QCALLTYPE TypeBuilder_SetMethodImpl(QCall::ModuleHandle pModule, /*============================DefineMethodImpl============================ ** Define a MethodImpl record ==============================================================================*/ -extern "C" void QCALLTYPE TypeBuilder_DefineMethodImpl(QCall::ModuleHandle pModule, UINT32 tkType, UINT32 tkBody, UINT32 tkDecl) +extern "C" void QCALLTYPE TypeBuilder_DefineMethodImpl(QCall::ModuleHandle pModule, UINT32 tkType, UINT32 tkBody, UINT32 tkDecl, QCallException* qcallError) { QCALL_CONTRACT; @@ -672,7 +676,7 @@ extern "C" void QCALLTYPE TypeBuilder_DefineMethodImpl(QCall::ModuleHandle pModu **Arguments: **Exceptions: ==============================================================================*/ -extern "C" INT32 QCALLTYPE TypeBuilder_GetTokenFromSig(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength) +extern "C" INT32 QCALLTYPE TypeBuilder_GetTokenFromSig(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, QCallException* qcallError) { QCALL_CONTRACT; @@ -702,7 +706,7 @@ extern "C" INT32 QCALLTYPE TypeBuilder_GetTokenFromSig(QCall::ModuleHandle pModu **Arguments: **Exceptions: ==============================================================================*/ -extern "C" INT32 QCALLTYPE TypeBuilder_SetParamInfo(QCall::ModuleHandle pModule, UINT32 tkMethod, UINT32 iSequence, UINT32 iAttributes, LPCWSTR wszParamName) +extern "C" INT32 QCALLTYPE TypeBuilder_SetParamInfo(QCall::ModuleHandle pModule, UINT32 tkMethod, UINT32 iSequence, UINT32 iAttributes, LPCWSTR wszParamName, QCallException* qcallError) { QCALL_CONTRACT; @@ -736,7 +740,7 @@ extern "C" INT32 QCALLTYPE TypeBuilder_SetParamInfo(QCall::ModuleHandle pModule, **Arguments: **Exceptions: ==============================================================================*/ -extern "C" void QCALLTYPE TypeBuilder_SetConstantValue(QCall::ModuleHandle pModule, UINT32 tk, DWORD valueCorType, LPVOID pValue) +extern "C" void QCALLTYPE TypeBuilder_SetConstantValue(QCall::ModuleHandle pModule, UINT32 tk, DWORD valueCorType, LPVOID pValue, QCallException* qcallError) { QCALL_CONTRACT; @@ -792,7 +796,7 @@ extern "C" void QCALLTYPE TypeBuilder_SetConstantValue(QCall::ModuleHandle pModu **Arguments: **Exceptions: ==============================================================================*/ -extern "C" void QCALLTYPE TypeBuilder_SetFieldLayoutOffset(QCall::ModuleHandle pModule, INT32 tkField, INT32 iOffset) +extern "C" void QCALLTYPE TypeBuilder_SetFieldLayoutOffset(QCall::ModuleHandle pModule, INT32 tkField, INT32 iOffset, QCallException* qcallError) { QCALL_CONTRACT; @@ -816,7 +820,7 @@ extern "C" void QCALLTYPE TypeBuilder_SetFieldLayoutOffset(QCall::ModuleHandle p **Arguments: **Exceptions: ==============================================================================*/ -extern "C" void QCALLTYPE TypeBuilder_SetClassLayout(QCall::ModuleHandle pModule, INT32 tk, INT32 iPackSize, UINT32 iTotalSize) +extern "C" void QCALLTYPE TypeBuilder_SetClassLayout(QCall::ModuleHandle pModule, INT32 tk, INT32 iPackSize, UINT32 iTotalSize, QCallException* qcallError) { QCALL_CONTRACT; @@ -911,7 +915,7 @@ void UpdateRuntimeStateForAssemblyCustomAttribute(Module* pModule, mdToken tkCus } } -extern "C" void QCALLTYPE TypeBuilder_DefineCustomAttribute(QCall::ModuleHandle pModule, INT32 token, INT32 conTok, LPCBYTE pBlob, INT32 cbBlob) +extern "C" void QCALLTYPE TypeBuilder_DefineCustomAttribute(QCall::ModuleHandle pModule, INT32 token, INT32 conTok, LPCBYTE pBlob, INT32 cbBlob, QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/comdynamic.h b/src/coreclr/vm/comdynamic.h index d279aef52faf1b..8056a4b20b4af4 100644 --- a/src/coreclr/vm/comdynamic.h +++ b/src/coreclr/vm/comdynamic.h @@ -31,7 +31,8 @@ class COMDynamicWrite INT32 tkParent, INT32 attributes, INT32 tkEnclosingType, - INT32 * pInterfaceTokens); + INT32 * pInterfaceTokens, + QCallException* qcallError); static void TermCreateClass(Module* pModule, INT32 tk, QCall::ObjectHandleOnStack retType); }; @@ -43,7 +44,8 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineType(QCall::ModuleHandle pModule, INT32 tkParent, INT32 attributes, INT32 tkEnclosingType, - INT32 * pInterfaceTokens); + INT32 * pInterfaceTokens, + QCallException* qcallError); extern "C" INT32 QCALLTYPE TypeBuilder_DefineGenericParam(QCall::ModuleHandle pModule, @@ -51,22 +53,23 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineGenericParam(QCall::ModuleHandle pM INT32 tkParent, INT32 attributes, INT32 position, - INT32 * pConstraintTokens); + INT32 * pConstraintTokens, + QCallException* qcallError); // This function will reset the parent class in metadata -extern "C" void QCALLTYPE TypeBuilder_SetParentType(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkParent); +extern "C" void QCALLTYPE TypeBuilder_SetParentType(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkParent, QCallException* qcallError); // This function will add another interface impl -extern "C" void QCALLTYPE TypeBuilder_AddInterfaceImpl(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkInterface); +extern "C" void QCALLTYPE TypeBuilder_AddInterfaceImpl(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkInterface, QCallException* qcallError); // This function will create a method within the class -extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethod(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attributes); +extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethod(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attributes, QCallException* qcallError); -extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethodSpec(QCall::ModuleHandle pModule, INT32 tkParent, LPCBYTE pSignature, INT32 sigLength); +extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethodSpec(QCall::ModuleHandle pModule, INT32 tkParent, LPCBYTE pSignature, INT32 sigLength, QCallException* qcallError); // This function will create a method within the class @@ -81,57 +84,58 @@ extern "C" void QCALLTYPE TypeBuilder_SetMethodIL(QCall::ModuleHandle pModule, ExceptionInstance * pExceptions, INT32 numExceptions, INT32 * pTokenFixups, - INT32 numTokenFixups); + INT32 numTokenFixups, + QCallException* qcallError); -extern "C" void QCALLTYPE TypeBuilder_TermCreateClass(QCall::ModuleHandle pModule, INT32 tk, QCall::ObjectHandleOnStack retType); +extern "C" void QCALLTYPE TypeBuilder_TermCreateClass(QCall::ModuleHandle pModule, INT32 tk, QCall::ObjectHandleOnStack retType, QCallException* qcallError); -extern "C" mdFieldDef QCALLTYPE TypeBuilder_DefineField(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attr); +extern "C" mdFieldDef QCALLTYPE TypeBuilder_DefineField(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attr, QCallException* qcallError); -extern "C" void QCALLTYPE TypeBuilder_SetPInvokeData(QCall::ModuleHandle pModule, LPCWSTR wszDllName, LPCWSTR wszFunctionName, INT32 token, INT32 linkFlags); +extern "C" void QCALLTYPE TypeBuilder_SetPInvokeData(QCall::ModuleHandle pModule, LPCWSTR wszDllName, LPCWSTR wszFunctionName, INT32 token, INT32 linkFlags, QCallException* qcallError); -extern "C" INT32 QCALLTYPE TypeBuilder_DefineProperty(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, LPCBYTE pSignature, INT32 sigLength); +extern "C" INT32 QCALLTYPE TypeBuilder_DefineProperty(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, LPCBYTE pSignature, INT32 sigLength, QCallException* qcallError); -extern "C" INT32 QCALLTYPE TypeBuilder_DefineEvent(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, INT32 tkEventType); +extern "C" INT32 QCALLTYPE TypeBuilder_DefineEvent(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, INT32 tkEventType, QCallException* qcallError); // functions to set Setter, Getter, Reset, TestDefault, and other methods -extern "C" void QCALLTYPE TypeBuilder_DefineMethodSemantics(QCall::ModuleHandle pModule, INT32 tkAssociation, INT32 attr, INT32 tkMethod); +extern "C" void QCALLTYPE TypeBuilder_DefineMethodSemantics(QCall::ModuleHandle pModule, INT32 tkAssociation, INT32 attr, INT32 tkMethod, QCallException* qcallError); // functions to set method's implementation flag -extern "C" void QCALLTYPE TypeBuilder_SetMethodImpl(QCall::ModuleHandle pModule, INT32 tkMethod, INT32 attr); +extern "C" void QCALLTYPE TypeBuilder_SetMethodImpl(QCall::ModuleHandle pModule, INT32 tkMethod, INT32 attr, QCallException* qcallError); // functions to create MethodImpl record -extern "C" void QCALLTYPE TypeBuilder_DefineMethodImpl(QCall::ModuleHandle pModule, UINT32 tkType, UINT32 tkBody, UINT32 tkDecl); +extern "C" void QCALLTYPE TypeBuilder_DefineMethodImpl(QCall::ModuleHandle pModule, UINT32 tkType, UINT32 tkBody, UINT32 tkDecl, QCallException* qcallError); // GetTokenFromSig's argument -extern "C" INT32 QCALLTYPE TypeBuilder_GetTokenFromSig(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength); +extern "C" INT32 QCALLTYPE TypeBuilder_GetTokenFromSig(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, QCallException* qcallError); // Set Field offset -extern "C" void QCALLTYPE TypeBuilder_SetFieldLayoutOffset(QCall::ModuleHandle pModule, INT32 tkField, INT32 iOffset); +extern "C" void QCALLTYPE TypeBuilder_SetFieldLayoutOffset(QCall::ModuleHandle pModule, INT32 tkField, INT32 iOffset, QCallException* qcallError); // Set classlayout info -extern "C" void QCALLTYPE TypeBuilder_SetClassLayout(QCall::ModuleHandle pModule, INT32 tk, INT32 iPackSize, UINT32 iTotalSize); +extern "C" void QCALLTYPE TypeBuilder_SetClassLayout(QCall::ModuleHandle pModule, INT32 tk, INT32 iPackSize, UINT32 iTotalSize, QCallException* qcallError); // Set a custom attribute -extern "C" void QCALLTYPE TypeBuilder_DefineCustomAttribute(QCall::ModuleHandle pModule, INT32 token, INT32 conTok, LPCBYTE pBlob, INT32 cbBlob); +extern "C" void QCALLTYPE TypeBuilder_DefineCustomAttribute(QCall::ModuleHandle pModule, INT32 token, INT32 conTok, LPCBYTE pBlob, INT32 cbBlob, QCallException* qcallError); // functions to set ParamInfo -extern "C" INT32 QCALLTYPE TypeBuilder_SetParamInfo(QCall::ModuleHandle pModule, UINT32 tkMethod, UINT32 iSequence, UINT32 iAttributes, LPCWSTR wszParamName); +extern "C" INT32 QCALLTYPE TypeBuilder_SetParamInfo(QCall::ModuleHandle pModule, UINT32 tkMethod, UINT32 iSequence, UINT32 iAttributes, LPCWSTR wszParamName, QCallException* qcallError); // functions to set default value -extern "C" void QCALLTYPE TypeBuilder_SetConstantValue(QCall::ModuleHandle pModule, UINT32 tk, DWORD valueType, LPVOID pValue); +extern "C" void QCALLTYPE TypeBuilder_SetConstantValue(QCall::ModuleHandle pModule, UINT32 tk, DWORD valueType, LPVOID pValue, QCallException* qcallError); #endif // _COMDYNAMIC_H_ diff --git a/src/coreclr/vm/commodule.cpp b/src/coreclr/vm/commodule.cpp index 40ee2900fd0759..63df7f97f3f65d 100644 --- a/src/coreclr/vm/commodule.cpp +++ b/src/coreclr/vm/commodule.cpp @@ -24,7 +24,8 @@ extern "C" mdTypeRef QCALLTYPE ModuleBuilder_GetTypeRef(QCall::ModuleHandle pModule, LPCWSTR wszFullName, QCall::ModuleHandle pRefedModule, - INT32 tkResolutionArg) + INT32 tkResolutionArg, + QCallException* qcallError) { QCALL_CONTRACT; @@ -128,7 +129,8 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetArrayMethodToken(QCall::ModuleHandle INT32 tkTypeSpec, LPCWSTR wszMethodName, LPCBYTE pSignature, - INT32 sigLength) + INT32 sigLength, + QCallException* qcallError) { QCALL_CONTRACT; @@ -203,7 +205,7 @@ namespace // This function will return a MemberRef token given a MethodDef token and the module where the MethodDef/FieldDef is defined. // //****************************************************************************** -extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRef(QCall::ModuleHandle pModule, QCall::ModuleHandle pRefedModule, INT32 tr, INT32 token) +extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRef(QCall::ModuleHandle pModule, QCall::ModuleHandle pRefedModule, INT32 tr, INT32 token, QCallException* qcallError) { QCALL_CONTRACT; @@ -284,7 +286,7 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRef(QCall::ModuleHandle pModul // Return a MemberRef token given a RuntimeMethodInfo // //****************************************************************************** -extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo(QCall::ModuleHandle pModule, INT32 tr, MethodDesc * pMeth) +extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo(QCall::ModuleHandle pModule, INT32 tr, MethodDesc * pMeth, QCallException* qcallError) { QCALL_CONTRACT; @@ -363,7 +365,7 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo(QCall::ModuleH // Return a MemberRef token given a RuntimeFieldInfo // //****************************************************************************** -extern "C" mdMemberRef QCALLTYPE ModuleBuilder_GetMemberRefOfFieldInfo(QCall::ModuleHandle pModule, mdTypeDef tr, QCall::TypeHandle th, mdFieldDef tkField) +extern "C" mdMemberRef QCALLTYPE ModuleBuilder_GetMemberRefOfFieldInfo(QCall::ModuleHandle pModule, mdTypeDef tr, QCall::TypeHandle th, mdFieldDef tkField, QCallException* qcallError) { QCALL_CONTRACT; @@ -441,7 +443,8 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefFromSignature(QCall::Module INT32 tr, LPCWSTR wszMemberName, LPCBYTE pSignature, - INT32 sigLength) + INT32 sigLength, + QCallException* qcallError) { QCALL_CONTRACT; @@ -469,7 +472,7 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefFromSignature(QCall::Module // This function is used to set the FieldRVA with the content data // //****************************************************************************** -extern "C" void QCALLTYPE ModuleBuilder_SetFieldRVAContent(QCall::ModuleHandle pModule, INT32 tkField, LPCBYTE pContent, INT32 length) +extern "C" void QCALLTYPE ModuleBuilder_SetFieldRVAContent(QCall::ModuleHandle pModule, INT32 tkField, LPCBYTE pContent, INT32 length, QCallException* qcallError) { QCALL_CONTRACT; @@ -525,7 +528,7 @@ extern "C" void QCALLTYPE ModuleBuilder_SetFieldRVAContent(QCall::ModuleHandle p // string constant or return the token of an existing constant. // //****************************************************************************** -extern "C" mdString QCALLTYPE ModuleBuilder_GetStringConstant(QCall::ModuleHandle pModule, LPCWSTR pwzValue, INT32 iLength) +extern "C" mdString QCALLTYPE ModuleBuilder_GetStringConstant(QCall::ModuleHandle pModule, LPCWSTR pwzValue, INT32 iLength, QCallException* qcallError) { QCALL_CONTRACT; @@ -552,7 +555,7 @@ extern "C" mdString QCALLTYPE ModuleBuilder_GetStringConstant(QCall::ModuleHandl /*=============================SetModuleName==================================== // SetModuleName ==============================================================================*/ -extern "C" void QCALLTYPE ModuleBuilder_SetModuleName(QCall::ModuleHandle pModule, LPCWSTR wszModuleName) +extern "C" void QCALLTYPE ModuleBuilder_SetModuleName(QCall::ModuleHandle pModule, LPCWSTR wszModuleName, QCallException* qcallError) { QCALL_CONTRACT; @@ -571,7 +574,7 @@ extern "C" void QCALLTYPE ModuleBuilder_SetModuleName(QCall::ModuleHandle pModul // Return a type spec token given a byte array // //****************************************************************************** -extern "C" mdTypeSpec QCALLTYPE ModuleBuilder_GetTokenFromTypeSpec(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength) +extern "C" mdTypeSpec QCALLTYPE ModuleBuilder_GetTokenFromTypeSpec(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, QCallException* qcallError) { QCALL_CONTRACT; @@ -592,7 +595,7 @@ extern "C" mdTypeSpec QCALLTYPE ModuleBuilder_GetTokenFromTypeSpec(QCall::Module // GetName // This routine will return the name of the module as a String -extern "C" void QCALLTYPE RuntimeModule_GetScopeName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString) +extern "C" void QCALLTYPE RuntimeModule_GetScopeName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString, QCallException* qcallError) { QCALL_CONTRACT; @@ -616,7 +619,7 @@ extern "C" void QCALLTYPE RuntimeModule_GetScopeName(QCall::ModuleHandle pModule **Arguments: **Exceptions: ==============================================================================*/ -extern "C" void QCALLTYPE RuntimeModule_GetFullyQualifiedName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString) +extern "C" void QCALLTYPE RuntimeModule_GetFullyQualifiedName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString, QCallException* qcallError) { QCALL_CONTRACT; @@ -650,7 +653,7 @@ extern "C" void QCALLTYPE RuntimeModule_GetFullyQualifiedName(QCall::ModuleHandl **Arguments: refThis **Exceptions: None. ==============================================================================*/ -extern "C" HINSTANCE QCALLTYPE MarshalNative_GetHINSTANCE(QCall::ModuleHandle pModule) +extern "C" HINSTANCE QCALLTYPE MarshalNative_GetHINSTANCE(QCall::ModuleHandle pModule, QCallException* qcallError) { QCALL_CONTRACT; @@ -678,7 +681,7 @@ extern "C" HINSTANCE QCALLTYPE MarshalNative_GetHINSTANCE(QCall::ModuleHandle pM // Get class will return an array contain all of the classes // that are defined within this Module. -extern "C" void QCALLTYPE RuntimeModule_GetTypes(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retTypes, QCall::ObjectHandleOnStack retExceptions) +extern "C" void QCALLTYPE RuntimeModule_GetTypes(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retTypes, QCall::ObjectHandleOnStack retExceptions, QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/commodule.h b/src/coreclr/vm/commodule.h index f675c6eca9cc6f..e68052da2c8b13 100644 --- a/src/coreclr/vm/commodule.h +++ b/src/coreclr/vm/commodule.h @@ -22,11 +22,12 @@ class COMModule extern "C" mdTypeRef QCALLTYPE ModuleBuilder_GetTypeRef(QCall::ModuleHandle pModule, LPCWSTR wszFullName, QCall::ModuleHandle pRefedModule, - INT32 tkResolution); + INT32 tkResolution, + QCallException* qcallError); // SetFieldRVAContent // This function is used to set the FieldRVA with the content data -extern "C" void QCALLTYPE ModuleBuilder_SetFieldRVAContent(QCall::ModuleHandle pModule, INT32 tkField, LPCBYTE pContent, INT32 length); +extern "C" void QCALLTYPE ModuleBuilder_SetFieldRVAContent(QCall::ModuleHandle pModule, INT32 tkField, LPCBYTE pContent, INT32 length, QCallException* qcallError); //GetArrayMethodToken @@ -34,19 +35,20 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetArrayMethodToken(QCall::ModuleHandle INT32 tkTypeSpec, LPCWSTR wszMethodName, LPCBYTE pSignature, - INT32 sigLength); + INT32 sigLength, + QCallException* qcallError); // GetMemberRefToken // This function will return the MemberRef token -extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRef(QCall::ModuleHandle pModule, QCall::ModuleHandle pRefedModule, INT32 tr, INT32 token); +extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRef(QCall::ModuleHandle pModule, QCall::ModuleHandle pRefedModule, INT32 tr, INT32 token, QCallException* qcallError); // This function return a MemberRef token given a MethodInfo describing an array method -extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo(QCall::ModuleHandle pModule, INT32 tr, MethodDesc * method); +extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo(QCall::ModuleHandle pModule, INT32 tr, MethodDesc * method, QCallException* qcallError); // GetMemberRefOfFieldInfo // This function will return a memberRef token given a FieldInfo -extern "C" mdMemberRef QCALLTYPE ModuleBuilder_GetMemberRefOfFieldInfo(QCall::ModuleHandle pModule, mdTypeDef tr, QCall::TypeHandle th, mdFieldDef tkField); +extern "C" mdMemberRef QCALLTYPE ModuleBuilder_GetMemberRefOfFieldInfo(QCall::ModuleHandle pModule, mdTypeDef tr, QCall::TypeHandle th, mdFieldDef tkField, QCallException* qcallError); // GetMemberRefFromSignature // This function will return the MemberRef token given the signature from managed code @@ -54,25 +56,26 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefFromSignature(QCall::Module INT32 tr, LPCWSTR wszMemberName, LPCBYTE pSignature, - INT32 sigLength); + INT32 sigLength, + QCallException* qcallError); // GetTokenFromTypeSpec -extern "C" mdTypeSpec QCALLTYPE ModuleBuilder_GetTokenFromTypeSpec(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength); +extern "C" mdTypeSpec QCALLTYPE ModuleBuilder_GetTokenFromTypeSpec(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, QCallException* qcallError); // GetStringConstant // If this is a dynamic module, this routine will define a new // string constant or return the token of an existing constant. -extern "C" mdString QCALLTYPE ModuleBuilder_GetStringConstant(QCall::ModuleHandle pModule, LPCWSTR pwzValue, INT32 iLength); +extern "C" mdString QCALLTYPE ModuleBuilder_GetStringConstant(QCall::ModuleHandle pModule, LPCWSTR pwzValue, INT32 iLength, QCallException* qcallError); -extern "C" void QCALLTYPE ModuleBuilder_SetModuleName(QCall::ModuleHandle pModule, LPCWSTR wszModuleName); +extern "C" void QCALLTYPE ModuleBuilder_SetModuleName(QCall::ModuleHandle pModule, LPCWSTR wszModuleName, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeModule_GetScopeName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString); +extern "C" void QCALLTYPE RuntimeModule_GetScopeName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeModule_GetFullyQualifiedName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString); +extern "C" void QCALLTYPE RuntimeModule_GetFullyQualifiedName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString, QCallException* qcallError); // GetTypes will return an array containing all of the types that are defined within this Module. -extern "C" void QCALLTYPE RuntimeModule_GetTypes(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retTypes, QCall::ObjectHandleOnStack retExceptions); +extern "C" void QCALLTYPE RuntimeModule_GetTypes(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retTypes, QCall::ObjectHandleOnStack retExceptions, QCallException* qcallError); -extern "C" HINSTANCE QCALLTYPE MarshalNative_GetHINSTANCE(QCall::ModuleHandle pModule); +extern "C" HINSTANCE QCALLTYPE MarshalNative_GetHINSTANCE(QCall::ModuleHandle pModule, QCallException* qcallError); #endif diff --git a/src/coreclr/vm/comsynchronizable.cpp b/src/coreclr/vm/comsynchronizable.cpp index a41b1d616cdf9d..f7dda51fa147f6 100644 --- a/src/coreclr/vm/comsynchronizable.cpp +++ b/src/coreclr/vm/comsynchronizable.cpp @@ -197,7 +197,7 @@ static ULONG WINAPI KickOffThread(void* pass) return 0; } -extern "C" BOOL QCALLTYPE ThreadNative_Start(QCall::ThreadHandle thread, int threadStackSize, int priority, BOOL isThreadPool, PCWSTR pThreadName, QCall::ObjectHandleOnStack exception) +extern "C" BOOL QCALLTYPE ThreadNative_Start(QCall::ThreadHandle thread, int threadStackSize, int priority, BOOL isThreadPool, PCWSTR pThreadName, QCall::ObjectHandleOnStack exception, QCallException* qcallError) { QCALL_CONTRACT; @@ -287,7 +287,7 @@ extern "C" BOOL QCALLTYPE ThreadNative_Start(QCall::ThreadHandle thread, int thr return result; } -extern "C" void QCALLTYPE ThreadNative_SetPriority(QCall::ObjectHandleOnStack thread, INT32 iPriority) +extern "C" void QCALLTYPE ThreadNative_SetPriority(QCall::ObjectHandleOnStack thread, INT32 iPriority, QCallException* qcallError) { QCALL_CONTRACT; @@ -328,7 +328,7 @@ extern "C" void QCALLTYPE ThreadNative_SetPriority(QCall::ObjectHandleOnStack th END_QCALL; } -extern "C" void QCALLTYPE ThreadNative_GetCurrentThread(QCall::ObjectHandleOnStack thread) +extern "C" void QCALLTYPE ThreadNative_GetCurrentThread(QCall::ObjectHandleOnStack thread, QCallException* qcallError) { QCALL_CONTRACT; @@ -340,7 +340,7 @@ extern "C" void QCALLTYPE ThreadNative_GetCurrentThread(QCall::ObjectHandleOnSta END_QCALL; } -extern "C" UINT64 QCALLTYPE ThreadNative_GetCurrentOSThreadId() +extern "C" UINT64 QCALLTYPE ThreadNative_GetCurrentOSThreadId(QCallException* qcallError) { QCALL_CONTRACT; @@ -362,7 +362,7 @@ extern "C" UINT64 QCALLTYPE ThreadNative_GetCurrentOSThreadId() return threadId; } -extern "C" void QCALLTYPE ThreadNative_Initialize(QCall::ObjectHandleOnStack t) +extern "C" void QCALLTYPE ThreadNative_Initialize(QCall::ObjectHandleOnStack t, QCallException* qcallError) { QCALL_CONTRACT; @@ -457,7 +457,7 @@ extern "C" void QCALLTYPE ThreadNative_ClearWaitSleepJoinState(QCall::ThreadHand // Return whether the thread hosts an STA, is a member of the MTA or is not // currently initialized for COM. -extern "C" INT32 QCALLTYPE ThreadNative_GetApartmentState(QCall::ObjectHandleOnStack t) +extern "C" INT32 QCALLTYPE ThreadNative_GetApartmentState(QCall::ObjectHandleOnStack t, QCallException* qcallError) { QCALL_CONTRACT; @@ -487,7 +487,7 @@ extern "C" INT32 QCALLTYPE ThreadNative_GetApartmentState(QCall::ObjectHandleOnS // Indicate whether the thread will host an STA (this may fail if the thread has // already been made part of the MTA, use GetApartmentState or the return state // from this routine to check for this). -extern "C" INT32 QCALLTYPE ThreadNative_SetApartmentState(QCall::ObjectHandleOnStack t, INT32 iState) +extern "C" INT32 QCALLTYPE ThreadNative_SetApartmentState(QCall::ObjectHandleOnStack t, INT32 iState, QCallException* qcallError) { QCALL_CONTRACT; @@ -532,7 +532,7 @@ extern "C" INT32 QCALLTYPE ThreadNative_SetApartmentState(QCall::ObjectHandleOnS #endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT #if TARGET_WINDOWS -extern "C" HANDLE QCALLTYPE ThreadNative_GetOSHandle(QCall::ThreadHandle t) +extern "C" HANDLE QCALLTYPE ThreadNative_GetOSHandle(QCall::ThreadHandle t, QCallException* qcallError) { QCALL_CONTRACT; @@ -658,7 +658,7 @@ extern "C" BOOL QCALLTYPE ThreadNative_GetIsBackground(QCall::ThreadHandle threa } // Set whether or not this is a background thread. -extern "C" void QCALLTYPE ThreadNative_SetIsBackground(QCall::ThreadHandle thread, BOOL value) +extern "C" void QCALLTYPE ThreadNative_SetIsBackground(QCall::ThreadHandle thread, BOOL value, QCallException* qcallError) { CONTRACTL { @@ -674,7 +674,7 @@ extern "C" void QCALLTYPE ThreadNative_SetIsBackground(QCall::ThreadHandle threa END_QCALL; } -extern "C" void QCALLTYPE ThreadNative_InformThreadNameChange(QCall::ThreadHandle thread, LPCWSTR name, INT32 len) +extern "C" void QCALLTYPE ThreadNative_InformThreadNameChange(QCall::ThreadHandle thread, LPCWSTR name, INT32 len, QCallException* qcallError) { QCALL_CONTRACT; @@ -747,10 +747,24 @@ extern "C" void QCALLTYPE ThreadNative_SpinWait(INT32 iterations) YieldProcessorNormalized(iterations); } +extern "C" void QCALLTYPE ThreadNative_LongSpinWait(INT32 iterations, QCallException* qcallError) +{ + QCALL_CONTRACT; + + BEGIN_QCALL; + + if (iterations > 0) + { + YieldProcessorNormalized(iterations); + } + + END_QCALL; +} + #ifdef TARGET_WINDOWS // This service can be called on unstarted and dead threads. For unstarted ones, the // next wait will be interrupted. For dead ones, this service quietly does nothing. -extern "C" void QCALLTYPE ThreadNative_Interrupt(QCall::ThreadHandle thread) +extern "C" void QCALLTYPE ThreadNative_Interrupt(QCall::ThreadHandle thread, QCallException* qcallError) { CONTRACTL { @@ -766,7 +780,7 @@ extern "C" void QCALLTYPE ThreadNative_Interrupt(QCall::ThreadHandle thread) END_QCALL; } -extern "C" void QCALLTYPE ThreadNative_CheckForPendingInterrupt(QCall::ThreadHandle thread) +extern "C" void QCALLTYPE ThreadNative_CheckForPendingInterrupt(QCall::ThreadHandle thread, QCallException* qcallError) { QCALL_CONTRACT; @@ -792,13 +806,19 @@ extern "C" void QCALLTYPE ThreadNative_DisableComObjectEagerCleanup(QCall::Threa } #endif //FEATURE_COMINTEROP -extern "C" void QCALLTYPE ThreadNative_PollGC() +extern "C" void QCALLTYPE ThreadNative_PollGC(QCallException* qcallError) { + QCALL_CONTRACT; + + BEGIN_QCALL; + // This is an intentional no-op. The call is made to ensure that the thread goes through a GC transition // and is thus marked as a GC safe point, and that the p/invoke rare path will kick in + + END_QCALL; } -extern "C" BOOL QCALLTYPE ThreadNative_YieldThread() +extern "C" BOOL QCALLTYPE ThreadNative_YieldThread(QCallException* qcallError) { QCALL_CONTRACT; @@ -813,7 +833,7 @@ extern "C" BOOL QCALLTYPE ThreadNative_YieldThread() return ret; } -extern "C" void QCALLTYPE ThreadNative_Abort(QCall::ThreadHandle thread) +extern "C" void QCALLTYPE ThreadNative_Abort(QCall::ThreadHandle thread, QCallException* qcallError) { QCALL_CONTRACT; @@ -858,7 +878,7 @@ FCIMPL1(OBJECTHANDLE, ObjectHeader_GetLockHandleIfExists, Object* pObj) } FCIMPLEND -extern "C" void QCALLTYPE ObjectHeader_GetOrCreateLockObject(QCall::ObjectHandleOnStack obj, QCall::ObjectHandleOnStack lockObj) +extern "C" void QCALLTYPE ObjectHeader_GetOrCreateLockObject(QCall::ObjectHandleOnStack obj, QCall::ObjectHandleOnStack lockObj, QCallException* qcallError) { QCALL_CONTRACT; @@ -873,7 +893,7 @@ extern "C" void QCALLTYPE ObjectHeader_GetOrCreateLockObject(QCall::ObjectHandle END_QCALL; } -extern "C" INT32 QCALLTYPE ThreadNative_ReentrantWaitAny(BOOL alertable, INT32 timeout, INT32 count, HANDLE *handles) +extern "C" INT32 QCALLTYPE ThreadNative_ReentrantWaitAny(BOOL alertable, INT32 timeout, INT32 count, HANDLE *handles, QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/comsynchronizable.h b/src/coreclr/vm/comsynchronizable.h index c619bf9bf36bb1..6a5a039a2b9e61 100644 --- a/src/coreclr/vm/comsynchronizable.h +++ b/src/coreclr/vm/comsynchronizable.h @@ -48,43 +48,43 @@ class ThreadNative FCDECL0(static FC_BOOL_RET, CurrentThreadIsFinalizerThread); }; -extern "C" BOOL QCALLTYPE ThreadNative_Start(QCall::ThreadHandle thread, int threadStackSize, int priority, BOOL isThreadPool, PCWSTR pThreadName, QCall::ObjectHandleOnStack exception); -extern "C" void QCALLTYPE ThreadNative_SetPriority(QCall::ObjectHandleOnStack thread, INT32 iPriority); -extern "C" void QCALLTYPE ThreadNative_GetCurrentThread(QCall::ObjectHandleOnStack thread); +extern "C" BOOL QCALLTYPE ThreadNative_Start(QCall::ThreadHandle thread, int threadStackSize, int priority, BOOL isThreadPool, PCWSTR pThreadName, QCall::ObjectHandleOnStack exception, QCallException* qcallError); +extern "C" void QCALLTYPE ThreadNative_SetPriority(QCall::ObjectHandleOnStack thread, INT32 iPriority, QCallException* qcallError); +extern "C" void QCALLTYPE ThreadNative_GetCurrentThread(QCall::ObjectHandleOnStack thread, QCallException* qcallError); extern "C" BOOL QCALLTYPE ThreadNative_GetIsBackground(QCall::ThreadHandle thread); -extern "C" void QCALLTYPE ThreadNative_SetIsBackground(QCall::ThreadHandle thread, BOOL value); -extern "C" void QCALLTYPE ThreadNative_InformThreadNameChange(QCall::ThreadHandle thread, LPCWSTR name, INT32 len); -extern "C" BOOL QCALLTYPE ThreadNative_YieldThread(); -extern "C" void QCALLTYPE ThreadNative_PollGC(); -extern "C" UINT64 QCALLTYPE ThreadNative_GetCurrentOSThreadId(); -extern "C" void QCALLTYPE ThreadNative_Initialize(QCall::ObjectHandleOnStack t); +extern "C" void QCALLTYPE ThreadNative_SetIsBackground(QCall::ThreadHandle thread, BOOL value, QCallException* qcallError); +extern "C" void QCALLTYPE ThreadNative_InformThreadNameChange(QCall::ThreadHandle thread, LPCWSTR name, INT32 len, QCallException* qcallError); +extern "C" BOOL QCALLTYPE ThreadNative_YieldThread(QCallException* qcallError); +extern "C" void QCALLTYPE ThreadNative_PollGC(QCallException* qcallError); +extern "C" UINT64 QCALLTYPE ThreadNative_GetCurrentOSThreadId(QCallException* qcallError); +extern "C" void QCALLTYPE ThreadNative_Initialize(QCall::ObjectHandleOnStack t, QCallException* qcallError); extern "C" INT32 QCALLTYPE ThreadNative_GetThreadState(QCall::ThreadHandle thread); extern "C" void QCALLTYPE ThreadNative_SetWaitSleepJoinState(QCall::ThreadHandle thread); extern "C" void QCALLTYPE ThreadNative_ClearWaitSleepJoinState(QCall::ThreadHandle thread); -extern "C" INT32 QCALLTYPE ThreadNative_ReentrantWaitAny(BOOL alertable, INT32 timeout, INT32 count, HANDLE *handles); +extern "C" INT32 QCALLTYPE ThreadNative_ReentrantWaitAny(BOOL alertable, INT32 timeout, INT32 count, HANDLE *handles, QCallException* qcallError); #ifdef TARGET_WINDOWS -extern "C" void QCALLTYPE ThreadNative_Interrupt(QCall::ThreadHandle thread); -extern "C" void QCALLTYPE ThreadNative_CheckForPendingInterrupt(QCall::ThreadHandle thread); +extern "C" void QCALLTYPE ThreadNative_Interrupt(QCall::ThreadHandle thread, QCallException* qcallError); +extern "C" void QCALLTYPE ThreadNative_CheckForPendingInterrupt(QCall::ThreadHandle thread, QCallException* qcallError); #endif // TARGET_WINDOWS #ifdef FEATURE_COMINTEROP_APARTMENT_SUPPORT -extern "C" INT32 QCALLTYPE ThreadNative_GetApartmentState(QCall::ObjectHandleOnStack t); -extern "C" INT32 QCALLTYPE ThreadNative_SetApartmentState(QCall::ObjectHandleOnStack t, INT32 iState); +extern "C" INT32 QCALLTYPE ThreadNative_GetApartmentState(QCall::ObjectHandleOnStack t, QCallException* qcallError); +extern "C" INT32 QCALLTYPE ThreadNative_SetApartmentState(QCall::ObjectHandleOnStack t, INT32 iState, QCallException* qcallError); #endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT #ifdef TARGET_WINDOWS -extern "C" HANDLE QCALLTYPE ThreadNative_GetOSHandle(QCall::ThreadHandle t); +extern "C" HANDLE QCALLTYPE ThreadNative_GetOSHandle(QCall::ThreadHandle t, QCallException* qcallError); #endif // TARGET_WINDOWS -extern "C" void QCALLTYPE ThreadNative_Abort(QCall::ThreadHandle thread); +extern "C" void QCALLTYPE ThreadNative_Abort(QCall::ThreadHandle thread, QCallException* qcallError); extern "C" void QCALLTYPE ThreadNative_ResetAbort(); extern "C" void QCALLTYPE ThreadNative_SpinWait(INT32 iterations); +extern "C" void QCALLTYPE ThreadNative_LongSpinWait(INT32 iterations, QCallException* qcallError); #ifdef FEATURE_COMINTEROP extern "C" void QCALLTYPE ThreadNative_DisableComObjectEagerCleanup(QCall::ThreadHandle thread); #endif // FEATURE_COMINTEROP -extern "C" void QCALLTYPE ObjectHeader_GetOrCreateLockObject(QCall::ObjectHandleOnStack obj, QCall::ObjectHandleOnStack lockObj); +extern "C" void QCALLTYPE ObjectHeader_GetOrCreateLockObject(QCall::ObjectHandleOnStack obj, QCall::ObjectHandleOnStack lockObj, QCallException* qcallError); FCDECL1(OBJECTHANDLE, ObjectHeader_GetLockHandleIfExists, Object* obj); #endif // _COMSYNCHRONIZABLE_H - diff --git a/src/coreclr/vm/comutilnative.cpp b/src/coreclr/vm/comutilnative.cpp index 4444343d4404d2..2821c44e98f956 100644 --- a/src/coreclr/vm/comutilnative.cpp +++ b/src/coreclr/vm/comutilnative.cpp @@ -82,7 +82,7 @@ FCIMPLEND // Given an exception object, this method will mark its stack trace as frozen and return it to the caller. // Frozen stack traces are immutable, when a thread attempts to add a frame to it, the stack trace is cloned first. -extern "C" void QCALLTYPE ExceptionNative_GetFrozenStackTrace(QCall::ObjectHandleOnStack exception, QCall::ObjectHandleOnStack ret) +extern "C" void QCALLTYPE ExceptionNative_GetFrozenStackTrace(QCall::ObjectHandleOnStack exception, QCall::ObjectHandleOnStack ret, QCallException* qcallError) { QCALL_CONTRACT; @@ -313,7 +313,7 @@ FCIMPLEND // our locks within CER's to avoid this problem - just use the CLR's // unmanaged resources. // -extern "C" void QCALLTYPE ExceptionNative_GetMessageFromNativeResources(ExceptionMessageKind kind, QCall::StringHandleOnStack retMesg) +extern "C" void QCALLTYPE ExceptionNative_GetMessageFromNativeResources(ExceptionMessageKind kind, QCall::StringHandleOnStack retMesg, QCallException* qcallError) { QCALL_CONTRACT; @@ -360,7 +360,7 @@ extern "C" void QCALLTYPE ExceptionNative_GetMessageFromNativeResources(Exceptio END_QCALL; } -extern "C" void QCALLTYPE ExceptionNative_GetMethodFromStackTrace(QCall::ObjectHandleOnStack stacktrace, QCall::ObjectHandleOnStack retMethodInfo) +extern "C" void QCALLTYPE ExceptionNative_GetMethodFromStackTrace(QCall::ObjectHandleOnStack stacktrace, QCall::ObjectHandleOnStack retMethodInfo, QCallException* qcallError) { QCALL_CONTRACT; @@ -404,7 +404,8 @@ extern "C" void QCALLTYPE ExceptionNative_GetMethodFromStackTrace(QCall::ObjectH extern "C" void QCALLTYPE ExceptionNative_ThrowAmbiguousResolutionException( MethodTable* pTargetClass, MethodTable* pInterfaceMT, - MethodDesc* pInterfaceMD) + MethodDesc* pInterfaceMD, + QCallException* qcallError) { QCALL_CONTRACT; @@ -418,7 +419,8 @@ extern "C" void QCALLTYPE ExceptionNative_ThrowAmbiguousResolutionException( extern "C" void QCALLTYPE ExceptionNative_ThrowEntryPointNotFoundException( MethodTable* pTargetClass, MethodTable* pInterfaceMT, - MethodDesc* pInterfaceMD) + MethodDesc* pInterfaceMD, + QCallException* qcallError) { QCALL_CONTRACT; @@ -429,7 +431,7 @@ extern "C" void QCALLTYPE ExceptionNative_ThrowEntryPointNotFoundException( END_QCALL; } -extern "C" void QCALLTYPE ExceptionNative_ThrowMethodAccessException(MethodDesc* caller, MethodDesc* callee) +extern "C" void QCALLTYPE ExceptionNative_ThrowMethodAccessException(MethodDesc* caller, MethodDesc* callee, QCallException* qcallError) { QCALL_CONTRACT; @@ -442,7 +444,7 @@ extern "C" void QCALLTYPE ExceptionNative_ThrowMethodAccessException(MethodDesc* END_QCALL; } -extern "C" void QCALLTYPE ExceptionNative_ThrowFieldAccessException(MethodDesc* caller, FieldDesc* callee) +extern "C" void QCALLTYPE ExceptionNative_ThrowFieldAccessException(MethodDesc* caller, FieldDesc* callee, QCallException* qcallError) { QCALL_CONTRACT; @@ -455,7 +457,7 @@ extern "C" void QCALLTYPE ExceptionNative_ThrowFieldAccessException(MethodDesc* END_QCALL; } -extern "C" void QCALLTYPE ExceptionNative_ThrowClassAccessException(MethodDesc* caller, EnregisteredTypeHandle callee) +extern "C" void QCALLTYPE ExceptionNative_ThrowClassAccessException(MethodDesc* caller, EnregisteredTypeHandle callee, QCallException* qcallError) { QCALL_CONTRACT; @@ -586,7 +588,7 @@ FCIMPL0(FC_BOOL_RET, GCInterface::CancelFullGCNotification) } FCIMPLEND -extern "C" int QCALLTYPE GCInterface_WaitForFullGCApproach(int millisecondsTimeout) +extern "C" int QCALLTYPE GCInterface_WaitForFullGCApproach(int millisecondsTimeout, QCallException* qcallError) { QCALL_CONTRACT; @@ -604,7 +606,7 @@ extern "C" int QCALLTYPE GCInterface_WaitForFullGCApproach(int millisecondsTimeo return result; } -extern "C" int QCALLTYPE GCInterface_WaitForFullGCComplete(int millisecondsTimeout) +extern "C" int QCALLTYPE GCInterface_WaitForFullGCComplete(int millisecondsTimeout, QCallException* qcallError) { QCALL_CONTRACT; @@ -671,7 +673,7 @@ FCIMPL2(int, GCInterface::CollectionCount, INT32 generation, INT32 getSpecialGCC } FCIMPLEND -extern "C" int QCALLTYPE GCInterface_StartNoGCRegion(INT64 totalSize, BOOL lohSizeKnown, INT64 lohSize, BOOL disallowFullBlockingGC) +extern "C" int QCALLTYPE GCInterface_StartNoGCRegion(INT64 totalSize, BOOL lohSizeKnown, INT64 lohSize, BOOL disallowFullBlockingGC, QCallException* qcallError) { QCALL_CONTRACT; @@ -691,7 +693,7 @@ extern "C" int QCALLTYPE GCInterface_StartNoGCRegion(INT64 totalSize, BOOL lohSi return retVal; } -extern "C" int QCALLTYPE GCInterface_EndNoGCRegion() +extern "C" int QCALLTYPE GCInterface_EndNoGCRegion(QCallException* qcallError) { QCALL_CONTRACT; @@ -728,7 +730,7 @@ FCIMPLEND **Arguments: None **Exceptions: None ==============================================================================*/ -extern "C" INT64 QCALLTYPE GCInterface_GetTotalMemory() +extern "C" INT64 QCALLTYPE GCInterface_GetTotalMemory(QCallException* qcallError) { QCALL_CONTRACT; @@ -750,7 +752,7 @@ extern "C" INT64 QCALLTYPE GCInterface_GetTotalMemory() **Arguments: args->generation: The maximum generation to collect **Exceptions: Argument exception if args->generation is < 0 or > GetMaxGeneration(); ==============================================================================*/ -extern "C" void QCALLTYPE GCInterface_Collect(INT32 generation, INT32 mode, CLR_BOOL lowMemoryPressure) +extern "C" void QCALLTYPE GCInterface_Collect(INT32 generation, INT32 mode, CLR_BOOL lowMemoryPressure, QCallException* qcallError) { QCALL_CONTRACT; @@ -767,7 +769,7 @@ extern "C" void QCALLTYPE GCInterface_Collect(INT32 generation, INT32 mode, CLR_ END_QCALL; } -extern "C" void* QCALLTYPE GCInterface_GetNextFinalizableObject(QCall::ObjectHandleOnStack pObj) +extern "C" void* QCALLTYPE GCInterface_GetNextFinalizableObject(QCall::ObjectHandleOnStack pObj, QCallException* qcallError) { QCALL_CONTRACT; @@ -809,7 +811,7 @@ extern "C" void* QCALLTYPE GCInterface_GetNextFinalizableObject(QCall::ObjectHan **Arguments: None **Exceptions: None ==============================================================================*/ -extern "C" void QCALLTYPE GCInterface_WaitForPendingFinalizers() +extern "C" void QCALLTYPE GCInterface_WaitForPendingFinalizers(QCallException* qcallError) { QCALL_CONTRACT; @@ -876,7 +878,7 @@ FCIMPLEND ** ret -> The allocated array. **Exceptions: IDS_EE_ARRAY_DIMENSIONS_EXCEEDED when size is too large. OOM if can't allocate. ==============================================================================*/ -extern "C" void QCALLTYPE GCInterface_AllocateNewArray(void* typeHandlePtr, INT32 length, INT32 flags, QCall::ObjectHandleOnStack ret) +extern "C" void QCALLTYPE GCInterface_AllocateNewArray(void* typeHandlePtr, INT32 length, INT32 flags, QCall::ObjectHandleOnStack ret, QCallException* qcallError) { QCALL_CONTRACT; _ASSERTE(typeHandlePtr != NULL); @@ -926,7 +928,7 @@ FCIMPL0(INT64, GCInterface::GetTotalAllocatedBytesApproximate) } FCIMPLEND; -extern "C" INT64 QCALLTYPE GCInterface_GetTotalAllocatedBytesPrecise() +extern "C" INT64 QCALLTYPE GCInterface_GetTotalAllocatedBytesPrecise(QCallException* qcallError) { INT64 allocated = 0; @@ -964,7 +966,7 @@ extern "C" INT64 QCALLTYPE GCInterface_GetTotalAllocatedBytesPrecise() **Arguments: args-> pointer to section, size of section **Exceptions: None ==============================================================================*/ -extern "C" void* QCALLTYPE GCInterface_RegisterFrozenSegment(void* pSection, SIZE_T sizeSection) +extern "C" void* QCALLTYPE GCInterface_RegisterFrozenSegment(void* pSection, SIZE_T sizeSection, QCallException* qcallError) { QCALL_CONTRACT; @@ -997,7 +999,7 @@ extern "C" void* QCALLTYPE GCInterface_RegisterFrozenSegment(void* pSection, SIZ **Arguments: args-> segment handle **Exceptions: None ==============================================================================*/ -extern "C" void QCALLTYPE GCInterface_UnregisterFrozenSegment(void* segment) +extern "C" void QCALLTYPE GCInterface_UnregisterFrozenSegment(void* segment, QCallException* qcallError) { QCALL_CONTRACT; @@ -1033,7 +1035,7 @@ FCIMPLEND **Arguments: Object of interest **Exceptions: None ==============================================================================*/ -extern "C" void QCALLTYPE GCInterface_ReRegisterForFinalize(QCall::ObjectHandleOnStack pObj) +extern "C" void QCALLTYPE GCInterface_ReRegisterForFinalize(QCall::ObjectHandleOnStack pObj, QCallException* qcallError) { QCALL_CONTRACT; @@ -1091,7 +1093,7 @@ FORCEINLINE UINT64 GCInterface::InterlockedSub(UINT64 *pMinuend, UINT64 subtrahe return newMemValue; } -extern "C" void QCALLTYPE GCInterface_AddMemoryPressure(UINT64 bytesAllocated) +extern "C" void QCALLTYPE GCInterface_AddMemoryPressure(UINT64 bytesAllocated, QCallException* qcallError) { QCALL_CONTRACT; @@ -1100,7 +1102,7 @@ extern "C" void QCALLTYPE GCInterface_AddMemoryPressure(UINT64 bytesAllocated) END_QCALL; } -extern "C" void QCALLTYPE GCInterface_EnumerateConfigurationValues(void* configurationContext, EnumerateConfigurationValuesCallback callback) +extern "C" void QCALLTYPE GCInterface_EnumerateConfigurationValues(void* configurationContext, EnumerateConfigurationValuesCallback callback, QCallException* qcallError) { QCALL_CONTRACT; @@ -1128,7 +1130,7 @@ void GCInterface::EnumerateConfigurationValues(void* configurationContext, Enume GCHeapHardLimitInfo g_gcHeapHardLimitInfo; bool g_gcHeapHardLimitInfoSpecified = false; -extern "C" int QCALLTYPE GCInterface_RefreshMemoryLimit(GCHeapHardLimitInfo heapHardLimitInfo) +extern "C" int QCALLTYPE GCInterface_RefreshMemoryLimit(GCHeapHardLimitInfo heapHardLimitInfo, QCallException* qcallError) { QCALL_CONTRACT; @@ -1156,7 +1158,7 @@ int GCInterface::RefreshMemoryLimit() return GCHeapUtilities::GetGCHeap()->RefreshMemoryLimit(); } -extern "C" enable_no_gc_region_callback_status QCALLTYPE GCInterface_EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, INT64 totalSize) +extern "C" enable_no_gc_region_callback_status QCALLTYPE GCInterface_EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, INT64 totalSize, QCallException* qcallError) { enable_no_gc_region_callback_status status = enable_no_gc_region_callback_status::succeed; QCALL_CONTRACT; @@ -1180,7 +1182,7 @@ enable_no_gc_region_callback_status GCInterface::EnableNoGCRegionCallback(NoGCRe return GCHeapUtilities::GetGCHeap()->EnableNoGCRegionCallback(callback, totalSize); } -extern "C" uint64_t QCALLTYPE GCInterface_GetGenerationBudget(int generation) +extern "C" uint64_t QCALLTYPE GCInterface_GetGenerationBudget(int generation, QCallException* qcallError) { uint64_t result = 0; QCALL_CONTRACT; @@ -1329,7 +1331,7 @@ void GCInterface::AddMemoryPressure(UINT64 bytesAllocated) } } -extern "C" void QCALLTYPE GCInterface_RemoveMemoryPressure(UINT64 bytesAllocated) +extern "C" void QCALLTYPE GCInterface_RemoveMemoryPressure(UINT64 bytesAllocated, QCallException* qcallError) { QCALL_CONTRACT; @@ -1413,7 +1415,7 @@ NOINLINE void GCInterface::GarbageCollectModeAny(int generation) // // EnvironmentNative // -extern "C" VOID QCALLTYPE Environment_Exit(INT32 exitcode) +extern "C" VOID QCALLTYPE Environment_Exit(INT32 exitcode, QCallException* qcallError) { QCALL_CONTRACT; @@ -1451,7 +1453,7 @@ FCIMPL0(INT32, EnvironmentNative::GetExitCode) } FCIMPLEND -extern "C" INT32 QCALLTYPE Environment_GetProcessorCount() +extern "C" INT32 QCALLTYPE Environment_GetProcessorCount(QCallException* qcallError) { QCALL_CONTRACT; @@ -1500,7 +1502,7 @@ static StackWalkAction FindFailFastCallerCallback(CrawlFrame* frame, VOID* data) static thread_local int8_t alreadyFailing = 0; -extern "C" void QCALLTYPE Environment_FailFast(QCall::StackCrawlMarkHandle mark, PCWSTR message, QCall::ObjectHandleOnStack exception, PCWSTR errorSource) +extern "C" void QCALLTYPE Environment_FailFast(QCall::StackCrawlMarkHandle mark, PCWSTR message, QCall::ObjectHandleOnStack exception, PCWSTR errorSource, QCallException* qcallError) { QCALL_CONTRACT; @@ -1575,7 +1577,7 @@ extern "C" void QCALLTYPE Environment_FailFast(QCall::StackCrawlMarkHandle mark, // // ObjectNative // -extern "C" INT32 QCALLTYPE ObjectNative_GetHashCodeSlow(QCall::ObjectHandleOnStack objHandle) +extern "C" INT32 QCALLTYPE ObjectNative_GetHashCodeSlow(QCall::ObjectHandleOnStack objHandle, QCallException* qcallError) { QCALL_CONTRACT; @@ -1626,7 +1628,7 @@ FCIMPL2(FC_BOOL_RET, ObjectNative::ContentEquals, Object *pThisRef, Object *pCom } FCIMPLEND -extern "C" void QCALLTYPE ObjectNative_AllocateUninitializedClone(QCall::ObjectHandleOnStack objHandle) +extern "C" void QCALLTYPE ObjectNative_AllocateUninitializedClone(QCall::ObjectHandleOnStack objHandle, QCallException* qcallError) { QCALL_CONTRACT; @@ -1842,7 +1844,7 @@ BOOL CanCompareBitsOrUseFastGetHashCode(MethodTable* mt) return canCompareBitsOrUseFastGetHashCode; } -extern "C" BOOL QCALLTYPE MethodTable_CanCompareBitsOrUseFastGetHashCode(MethodTable* mt) +extern "C" BOOL QCALLTYPE MethodTable_CanCompareBitsOrUseFastGetHashCode(MethodTable* mt, QCallException* qcallError) { QCALL_CONTRACT; @@ -1961,7 +1963,7 @@ static ValueTypeHashCodeStrategy GetHashCodeStrategy(MethodTable* mt, QCall::Obj return ret; } -extern "C" INT32 QCALLTYPE ValueType_GetHashCodeStrategy(MethodTable* mt, QCall::ObjectHandleOnStack objHandle, UINT32* fieldOffset, UINT32* fieldSize, MethodTable** fieldMT) +extern "C" INT32 QCALLTYPE ValueType_GetHashCodeStrategy(MethodTable* mt, QCall::ObjectHandleOnStack objHandle, UINT32* fieldOffset, UINT32* fieldSize, MethodTable** fieldMT, QCallException* qcallError) { QCALL_CONTRACT; @@ -2022,7 +2024,7 @@ FCIMPL1(OBJECTHANDLE, MethodTableNative::GetLoaderAllocatorHandle, MethodTable * } FCIMPLEND -extern "C" BOOL QCALLTYPE MethodTable_AreTypesEquivalent(MethodTable* mta, MethodTable* mtb) +extern "C" BOOL QCALLTYPE MethodTable_AreTypesEquivalent(MethodTable* mta, MethodTable* mtb, QCallException* qcallError) { QCALL_CONTRACT; @@ -2037,7 +2039,7 @@ extern "C" BOOL QCALLTYPE MethodTable_AreTypesEquivalent(MethodTable* mta, Metho return bResult; } -extern "C" BOOL QCALLTYPE TypeHandle_CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd) +extern "C" BOOL QCALLTYPE TypeHandle_CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd, QCallException* qcallError) { QCALL_CONTRACT; @@ -2095,7 +2097,7 @@ static bool HasOverriddenStreamMethod(MethodTable* streamMT, MethodTable* pMT, W return NonVirtualEntry2MethodDesc(actual) != NonVirtualEntry2MethodDesc(base); } -extern "C" BOOL QCALLTYPE Stream_HasOverriddenSlow(MethodTable* pMT, BOOL isRead) +extern "C" BOOL QCALLTYPE Stream_HasOverriddenSlow(MethodTable* pMT, BOOL isRead, QCallException* qcallError) { QCALL_CONTRACT; _ASSERTE(pMT != NULL); diff --git a/src/coreclr/vm/comutilnative.h b/src/coreclr/vm/comutilnative.h index cd1c31211d7064..9996b6ffc7625f 100644 --- a/src/coreclr/vm/comutilnative.h +++ b/src/coreclr/vm/comutilnative.h @@ -48,30 +48,32 @@ class ExceptionNative FCDECL0(static UINT32, GetExceptionCount); }; -extern "C" void QCALLTYPE ExceptionNative_GetFrozenStackTrace(QCall::ObjectHandleOnStack exception, QCall::ObjectHandleOnStack ret); +extern "C" void QCALLTYPE ExceptionNative_GetFrozenStackTrace(QCall::ObjectHandleOnStack exception, QCall::ObjectHandleOnStack ret, QCallException* qcallError); enum class ExceptionMessageKind { ThreadAbort = 1, ThreadInterrupted = 2, OutOfMemory = 3 }; -extern "C" void QCALLTYPE ExceptionNative_GetMessageFromNativeResources(ExceptionMessageKind kind, QCall::StringHandleOnStack retMesg); +extern "C" void QCALLTYPE ExceptionNative_GetMessageFromNativeResources(ExceptionMessageKind kind, QCall::StringHandleOnStack retMesg, QCallException* qcallError); -extern "C" void QCALLTYPE ExceptionNative_GetMethodFromStackTrace(QCall::ObjectHandleOnStack array, QCall::ObjectHandleOnStack retMethodInfo); +extern "C" void QCALLTYPE ExceptionNative_GetMethodFromStackTrace(QCall::ObjectHandleOnStack array, QCall::ObjectHandleOnStack retMethodInfo, QCallException* qcallError); extern "C" void QCALLTYPE ExceptionNative_ThrowAmbiguousResolutionException( MethodTable* pTargetClass, MethodTable* pInterfaceMT, - MethodDesc* pInterfaceMD); + MethodDesc* pInterfaceMD, + QCallException* qcallError); extern "C" void QCALLTYPE ExceptionNative_ThrowEntryPointNotFoundException( MethodTable* pTargetClass, MethodTable* pInterfaceMT, - MethodDesc* pInterfaceMD); + MethodDesc* pInterfaceMD, + QCallException* qcallError); -extern "C" void QCALLTYPE ExceptionNative_ThrowMethodAccessException(MethodDesc* caller, MethodDesc* callee); -extern "C" void QCALLTYPE ExceptionNative_ThrowFieldAccessException(MethodDesc* caller, FieldDesc* callee); -extern "C" void QCALLTYPE ExceptionNative_ThrowClassAccessException(MethodDesc* caller, EnregisteredTypeHandle callee); +extern "C" void QCALLTYPE ExceptionNative_ThrowMethodAccessException(MethodDesc* caller, MethodDesc* callee, QCallException* qcallError); +extern "C" void QCALLTYPE ExceptionNative_ThrowFieldAccessException(MethodDesc* caller, FieldDesc* callee, QCallException* qcallError); +extern "C" void QCALLTYPE ExceptionNative_ThrowClassAccessException(MethodDesc* caller, EnregisteredTypeHandle callee, QCallException* qcallError); // // Buffer @@ -191,42 +193,42 @@ class GCInterface { NOINLINE static void GarbageCollectModeAny(int generation); }; -extern "C" INT64 QCALLTYPE GCInterface_GetTotalAllocatedBytesPrecise(); +extern "C" INT64 QCALLTYPE GCInterface_GetTotalAllocatedBytesPrecise(QCallException* qcallError); -extern "C" void QCALLTYPE GCInterface_AllocateNewArray(void* typeHandlePtr, INT32 length, INT32 flags, QCall::ObjectHandleOnStack ret); +extern "C" void QCALLTYPE GCInterface_AllocateNewArray(void* typeHandlePtr, INT32 length, INT32 flags, QCall::ObjectHandleOnStack ret, QCallException* qcallError); -extern "C" INT64 QCALLTYPE GCInterface_GetTotalMemory(); +extern "C" INT64 QCALLTYPE GCInterface_GetTotalMemory(QCallException* qcallError); -extern "C" void QCALLTYPE GCInterface_Collect(INT32 generation, INT32 mode, CLR_BOOL lowMemoryPressure); +extern "C" void QCALLTYPE GCInterface_Collect(INT32 generation, INT32 mode, CLR_BOOL lowMemoryPressure, QCallException* qcallError); -extern "C" void* QCALLTYPE GCInterface_GetNextFinalizableObject(QCall::ObjectHandleOnStack pObj); +extern "C" void* QCALLTYPE GCInterface_GetNextFinalizableObject(QCall::ObjectHandleOnStack pObj, QCallException* qcallError); -extern "C" void QCALLTYPE GCInterface_WaitForPendingFinalizers(); -extern "C" void* QCALLTYPE GCInterface_RegisterFrozenSegment(void *pSection, SIZE_T sizeSection); +extern "C" void QCALLTYPE GCInterface_WaitForPendingFinalizers(QCallException* qcallError); +extern "C" void* QCALLTYPE GCInterface_RegisterFrozenSegment(void *pSection, SIZE_T sizeSection, QCallException* qcallError); -extern "C" void QCALLTYPE GCInterface_UnregisterFrozenSegment(void *segmentHandle); +extern "C" void QCALLTYPE GCInterface_UnregisterFrozenSegment(void *segmentHandle, QCallException* qcallError); -extern "C" int QCALLTYPE GCInterface_WaitForFullGCApproach(int millisecondsTimeout); +extern "C" int QCALLTYPE GCInterface_WaitForFullGCApproach(int millisecondsTimeout, QCallException* qcallError); -extern "C" int QCALLTYPE GCInterface_WaitForFullGCComplete(int millisecondsTimeout); +extern "C" int QCALLTYPE GCInterface_WaitForFullGCComplete(int millisecondsTimeout, QCallException* qcallError); -extern "C" int QCALLTYPE GCInterface_StartNoGCRegion(INT64 totalSize, BOOL lohSizeKnown, INT64 lohSize, BOOL disallowFullBlockingGC); +extern "C" int QCALLTYPE GCInterface_StartNoGCRegion(INT64 totalSize, BOOL lohSizeKnown, INT64 lohSize, BOOL disallowFullBlockingGC, QCallException* qcallError); -extern "C" int QCALLTYPE GCInterface_EndNoGCRegion(); +extern "C" int QCALLTYPE GCInterface_EndNoGCRegion(QCallException* qcallError); -extern "C" void QCALLTYPE GCInterface_AddMemoryPressure(UINT64 bytesAllocated); +extern "C" void QCALLTYPE GCInterface_AddMemoryPressure(UINT64 bytesAllocated, QCallException* qcallError); -extern "C" void QCALLTYPE GCInterface_RemoveMemoryPressure(UINT64 bytesAllocated); +extern "C" void QCALLTYPE GCInterface_RemoveMemoryPressure(UINT64 bytesAllocated, QCallException* qcallError); -extern "C" void QCALLTYPE GCInterface_ReRegisterForFinalize(QCall::ObjectHandleOnStack pObj); +extern "C" void QCALLTYPE GCInterface_ReRegisterForFinalize(QCall::ObjectHandleOnStack pObj, QCallException* qcallError); -extern "C" void QCALLTYPE GCInterface_EnumerateConfigurationValues(void* configurationContext, EnumerateConfigurationValuesCallback callback); +extern "C" void QCALLTYPE GCInterface_EnumerateConfigurationValues(void* configurationContext, EnumerateConfigurationValuesCallback callback, QCallException* qcallError); -extern "C" int QCALLTYPE GCInterface_RefreshMemoryLimit(GCHeapHardLimitInfo heapHardLimitInfo); +extern "C" int QCALLTYPE GCInterface_RefreshMemoryLimit(GCHeapHardLimitInfo heapHardLimitInfo, QCallException* qcallError); -extern "C" enable_no_gc_region_callback_status QCALLTYPE GCInterface_EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, INT64 totalSize); +extern "C" enable_no_gc_region_callback_status QCALLTYPE GCInterface_EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, INT64 totalSize, QCallException* qcallError); -extern "C" uint64_t QCALLTYPE GCInterface_GetGenerationBudget(int generation); +extern "C" uint64_t QCALLTYPE GCInterface_GetGenerationBudget(int generation, QCallException* qcallError); // // EnvironmentNative @@ -239,18 +241,18 @@ class EnvironmentNative FCDECL0(static INT32, GetExitCode); }; -extern "C" void QCALLTYPE Environment_Exit(INT32 exitcode); +extern "C" void QCALLTYPE Environment_Exit(INT32 exitcode, QCallException* qcallError); -extern "C" void QCALLTYPE Environment_FailFast(QCall::StackCrawlMarkHandle mark, PCWSTR message, QCall::ObjectHandleOnStack exception, PCWSTR errorSource); +extern "C" void QCALLTYPE Environment_FailFast(QCall::StackCrawlMarkHandle mark, PCWSTR message, QCall::ObjectHandleOnStack exception, PCWSTR errorSource, QCallException* qcallError); // Returns the number of logical processors that can be used by managed code -extern "C" INT32 QCALLTYPE Environment_GetProcessorCount(); +extern "C" INT32 QCALLTYPE Environment_GetProcessorCount(QCallException* qcallError); -extern "C" void QCALLTYPE GetTypeLoadExceptionMessage(UINT32 resId, QCall::StringHandleOnStack retString); +extern "C" void QCALLTYPE GetTypeLoadExceptionMessage(UINT32 resId, QCall::StringHandleOnStack retString, QCallException* qcallError); -extern "C" void QCALLTYPE GetFileLoadExceptionMessage(UINT32 hr, QCall::StringHandleOnStack retString); +extern "C" void QCALLTYPE GetFileLoadExceptionMessage(UINT32 hr, QCall::StringHandleOnStack retString, QCallException* qcallError); -extern "C" void QCALLTYPE FileLoadException_GetMessageForHR(UINT32 hresult, QCall::StringHandleOnStack retString); +extern "C" void QCALLTYPE FileLoadException_GetMessageForHR(UINT32 hresult, QCall::StringHandleOnStack retString, QCallException* qcallError); class ObjectNative { @@ -259,8 +261,8 @@ class ObjectNative FCDECL2(static FC_BOOL_RET, ContentEquals, Object *pThisRef, Object *pCompareRef); }; -extern "C" INT32 QCALLTYPE ObjectNative_GetHashCodeSlow(QCall::ObjectHandleOnStack objHandle); -extern "C" void QCALLTYPE ObjectNative_AllocateUninitializedClone(QCall::ObjectHandleOnStack objHandle); +extern "C" INT32 QCALLTYPE ObjectNative_GetHashCodeSlow(QCall::ObjectHandleOnStack objHandle, QCallException* qcallError); +extern "C" void QCALLTYPE ObjectNative_AllocateUninitializedClone(QCall::ObjectHandleOnStack objHandle, QCallException* qcallError); class COMInterlocked { @@ -284,14 +286,14 @@ class MethodTableNative { FCDECL1(static OBJECTHANDLE, GetLoaderAllocatorHandle, MethodTable* mt); }; -extern "C" BOOL QCALLTYPE MethodTable_AreTypesEquivalent(MethodTable* mta, MethodTable* mtb); -extern "C" BOOL QCALLTYPE MethodTable_CanCompareBitsOrUseFastGetHashCode(MethodTable* mt); -extern "C" BOOL QCALLTYPE TypeHandle_CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd); +extern "C" BOOL QCALLTYPE MethodTable_AreTypesEquivalent(MethodTable* mta, MethodTable* mtb, QCallException* qcallError); +extern "C" BOOL QCALLTYPE MethodTable_CanCompareBitsOrUseFastGetHashCode(MethodTable* mt, QCallException* qcallError); +extern "C" BOOL QCALLTYPE TypeHandle_CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd, QCallException* qcallError); extern "C" INT32 QCALLTYPE TypeHandle_GetCorElementType(void* typeHnd); -extern "C" INT32 QCALLTYPE ValueType_GetHashCodeStrategy(MethodTable* mt, QCall::ObjectHandleOnStack objHandle, UINT32* fieldOffset, UINT32* fieldSize, MethodTable** fieldMT); +extern "C" INT32 QCALLTYPE ValueType_GetHashCodeStrategy(MethodTable* mt, QCall::ObjectHandleOnStack objHandle, UINT32* fieldOffset, UINT32* fieldSize, MethodTable** fieldMT, QCallException* qcallError); BOOL CanCompareBitsOrUseFastGetHashCode(MethodTable* mt); -extern "C" BOOL QCALLTYPE Stream_HasOverriddenSlow(MethodTable* pMT, BOOL isRead); +extern "C" BOOL QCALLTYPE Stream_HasOverriddenSlow(MethodTable* pMT, BOOL isRead, QCallException* qcallError); #endif // _COMUTILNATIVE_H_ diff --git a/src/coreclr/vm/coreassemblyspec.cpp b/src/coreclr/vm/coreassemblyspec.cpp index b289c69257d2a8..8d8d5899c0c628 100644 --- a/src/coreclr/vm/coreassemblyspec.cpp +++ b/src/coreclr/vm/coreassemblyspec.cpp @@ -184,7 +184,7 @@ void BaseAssemblySpec::Init(SString& assemblyDisplayName) parseAsAssemblySpec.InvokeThrowing(pAssemblyDisplayName, (void*)this); } -extern "C" void QCALLTYPE AssemblyName_InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, BaseAssemblySpec* pAssemblySpec) +extern "C" void QCALLTYPE AssemblyName_InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, BaseAssemblySpec* pAssemblySpec, QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/corelib.h b/src/coreclr/vm/corelib.h index 972fb1580d2006..c23560b5993506 100644 --- a/src/coreclr/vm/corelib.h +++ b/src/coreclr/vm/corelib.h @@ -978,6 +978,7 @@ DEFINE_CLASS(STACKCRAWMARK, Threading, StackCrawlMark) DEFINE_CLASS_U(Threading, Thread, ThreadBaseObject) DEFINE_FIELD_U(_name, ThreadBaseObject, m_Name) DEFINE_FIELD_U(_startHelper, ThreadBaseObject, m_StartHelper) +DEFINE_FIELD_U(_qcallException, ThreadBaseObject, m_QCallException) DEFINE_FIELD_U(_DONT_USE_InternalThread, ThreadBaseObject, m_InternalThread) DEFINE_FIELD_U(_priority, ThreadBaseObject, m_Priority) DEFINE_FIELD_U(_isDead, ThreadBaseObject, m_IsDead) diff --git a/src/coreclr/vm/customattribute.cpp b/src/coreclr/vm/customattribute.cpp index 82fcdbf0941eac..8a6438827922dc 100644 --- a/src/coreclr/vm/customattribute.cpp +++ b/src/coreclr/vm/customattribute.cpp @@ -904,7 +904,8 @@ extern "C" void QCALLTYPE CustomAttribute_CreateCustomAttributeInstance( BYTE** ppBlob, BYTE* pEndBlob, INT32* pcNamedArgs, - QCall::ObjectHandleOnStack result) + QCall::ObjectHandleOnStack result, + QCallException* qcallError) { QCALL_CONTRACT; @@ -1033,7 +1034,8 @@ extern "C" void QCALLTYPE CustomAttribute_CreatePropertyOrFieldData( QCall::StringHandleOnStack pName, BOOL* pbIsProperty, QCall::ObjectHandleOnStack pType, - QCall::ObjectHandleOnStack pValue) + QCall::ObjectHandleOnStack pValue, + QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/customattribute.h b/src/coreclr/vm/customattribute.h index 2cbc846bff8f10..a1dfffe41de868 100644 --- a/src/coreclr/vm/customattribute.h +++ b/src/coreclr/vm/customattribute.h @@ -37,7 +37,8 @@ extern "C" void QCALLTYPE CustomAttribute_CreateCustomAttributeInstance( BYTE** ppBlob, BYTE* pEndBlob, INT32* pcNamedArgs, - QCall::ObjectHandleOnStack result); + QCall::ObjectHandleOnStack result, + QCallException* qcallError); extern "C" void QCALLTYPE CustomAttribute_CreatePropertyOrFieldData( QCall::ModuleHandle pModule, @@ -46,6 +47,7 @@ extern "C" void QCALLTYPE CustomAttribute_CreatePropertyOrFieldData( QCall::StringHandleOnStack pName, BOOL* pbIsProperty, QCall::ObjectHandleOnStack pType, - QCall::ObjectHandleOnStack value); + QCall::ObjectHandleOnStack value, + QCallException* qcallError); #endif // _CUSTOMATTRIBUTE_H_ diff --git a/src/coreclr/vm/debugdebugger.cpp b/src/coreclr/vm/debugdebugger.cpp index dcb17d68da4e1a..e5dc79c4f6fa1e 100644 --- a/src/coreclr/vm/debugdebugger.cpp +++ b/src/coreclr/vm/debugdebugger.cpp @@ -38,7 +38,7 @@ // Else if a native debugger is attached, this should send a native break event (kernel32!DebugBreak) // Else, this should invoke Watson. // -extern "C" void QCALLTYPE DebugDebugger_Break() +extern "C" void QCALLTYPE DebugDebugger_Break(QCallException* qcallError) { QCALL_CONTRACT; @@ -83,24 +83,29 @@ extern "C" void QCALLTYPE DebugDebugger_Break() #endif // DEBUGGING_SUPPORTED } -extern "C" BOOL QCALLTYPE DebugDebugger_Launch() +extern "C" BOOL QCALLTYPE DebugDebugger_Launch(QCallException* qcallError) { QCALL_CONTRACT; + BOOL ret = FALSE; + + BEGIN_QCALL; + #ifdef DEBUGGING_SUPPORTED if (CORDebuggerAttached()) { - return TRUE; + ret = TRUE; } - - if (g_pDebugInterface != NULL) + else if (g_pDebugInterface != NULL) { HRESULT hr = g_pDebugInterface->LaunchDebuggerForUser(GetThread(), NULL, TRUE, TRUE); - return SUCCEEDED(hr); + ret = SUCCEEDED(hr); } #endif // DEBUGGING_SUPPORTED - return FALSE; + END_QCALL; + + return ret; } // Log to managed debugger. @@ -108,7 +113,7 @@ extern "C" BOOL QCALLTYPE DebugDebugger_Launch() // appending a newline to anything. // It will also call OutputDebugString() which will send a native debug event. The message // string there will be a composite of the two managed string parameters and may include a newline. -extern "C" void QCALLTYPE DebugDebugger_Log(INT32 Level, PCWSTR pwzModule, PCWSTR pwzMessage) +extern "C" void QCALLTYPE DebugDebugger_Log(INT32 Level, PCWSTR pwzModule, PCWSTR pwzMessage, QCallException* qcallError) { CONTRACTL { @@ -118,6 +123,8 @@ extern "C" void QCALLTYPE DebugDebugger_Log(INT32 Level, PCWSTR pwzModule, PCWST } CONTRACTL_END; + BEGIN_QCALL; + // OutputDebugString will log to native/interop debugger. if (pwzModule != NULL) { @@ -175,6 +182,8 @@ extern "C" void QCALLTYPE DebugDebugger_Log(INT32 Level, PCWSTR pwzModule, PCWST } #endif // DEBUGGING_SUPPORTED + + END_QCALL; } static StackWalkAction GetStackFramesCallback(CrawlFrame* pCf, VOID* data) @@ -291,7 +300,8 @@ static void GetStackFrames(DebugStackTrace::GetStackFramesData *pData) extern "C" void QCALLTYPE AsyncHelpers_AddContinuationToExInternal( void* diagnosticIP, - QCall::ObjectHandleOnStack exception) + QCall::ObjectHandleOnStack exception, + QCallException* qcallError) { QCALL_CONTRACT; @@ -319,7 +329,8 @@ extern "C" void QCALLTYPE AsyncHelpers_AddContinuationToExInternal( extern "C" void QCALLTYPE StackTrace_GetStackFramesInternal( QCall::ObjectHandleOnStack stackFrameHelper, BOOL fNeedFileInfo, - QCall::ObjectHandleOnStack exception) + QCall::ObjectHandleOnStack exception, + QCallException* qcallError) { QCALL_CONTRACT; @@ -822,7 +833,7 @@ extern "C" void QCALLTYPE StackTrace_GetStackFramesInternal( END_QCALL; } -extern "C" MethodDesc* QCALLTYPE StackFrame_GetMethodDescFromNativeIP(LPVOID ip) +extern "C" MethodDesc* QCALLTYPE StackFrame_GetMethodDescFromNativeIP(LPVOID ip, QCallException* qcallError) { QCALL_CONTRACT; @@ -861,7 +872,7 @@ using StrongHandleHolder = LifetimeHolder; // receives a custom notification object from the target and sends it to the RS via // code:Debugger::SendCustomDebuggerNotification // Argument: dataUNSAFE - a pointer the custom notification object being sent -extern "C" void QCALLTYPE DebugDebugger_CustomNotification(QCall::ObjectHandleOnStack data) +extern "C" void QCALLTYPE DebugDebugger_CustomNotification(QCall::ObjectHandleOnStack data, QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/debugdebugger.h b/src/coreclr/vm/debugdebugger.h index 8cd17439db17cc..9de53e172dbce7 100644 --- a/src/coreclr/vm/debugdebugger.h +++ b/src/coreclr/vm/debugdebugger.h @@ -13,10 +13,10 @@ #define __DEBUG_DEBUGGER_h__ #include -extern "C" void QCALLTYPE DebugDebugger_Break(); -extern "C" BOOL QCALLTYPE DebugDebugger_Launch(); -extern "C" void QCALLTYPE DebugDebugger_Log(INT32 Level, PCWSTR pwzModule, PCWSTR pwzMessage); -extern "C" void QCALLTYPE DebugDebugger_CustomNotification(QCall::ObjectHandleOnStack data); +extern "C" void QCALLTYPE DebugDebugger_Break(QCallException* qcallError); +extern "C" BOOL QCALLTYPE DebugDebugger_Launch(QCallException* qcallError); +extern "C" void QCALLTYPE DebugDebugger_Log(INT32 Level, PCWSTR pwzModule, PCWSTR pwzMessage, QCallException* qcallError); +extern "C" void QCALLTYPE DebugDebugger_CustomNotification(QCall::ObjectHandleOnStack data, QCallException* qcallError); extern "C" BOOL QCALLTYPE DebugDebugger_IsLoggingHelper(); extern "C" BOOL QCALLTYPE DebugDebugger_IsManagedDebuggerAttached(); @@ -133,13 +133,15 @@ class DebugStackTrace extern "C" void QCALLTYPE StackTrace_GetStackFramesInternal( QCall::ObjectHandleOnStack stackFrameHelper, BOOL fNeedFileInfo, - QCall::ObjectHandleOnStack exception); + QCall::ObjectHandleOnStack exception, + QCallException* qcallError); extern "C" void QCALLTYPE AsyncHelpers_AddContinuationToExInternal( void* diagnosticIP, - QCall::ObjectHandleOnStack exception); + QCall::ObjectHandleOnStack exception, + QCallException* qcallError); -extern "C" MethodDesc* QCALLTYPE StackFrame_GetMethodDescFromNativeIP(LPVOID ip); +extern "C" MethodDesc* QCALLTYPE StackFrame_GetMethodDescFromNativeIP(LPVOID ip, QCallException* qcallError); class ILToNativeMapArrays diff --git a/src/coreclr/vm/eventpipeinternal.cpp b/src/coreclr/vm/eventpipeinternal.cpp index e981e629055530..e4de4e474d3066 100644 --- a/src/coreclr/vm/eventpipeinternal.cpp +++ b/src/coreclr/vm/eventpipeinternal.cpp @@ -19,7 +19,8 @@ extern "C" UINT64 QCALLTYPE EventPipeInternal_Enable( EventPipeSerializationFormat format, UINT32 circularBufferSizeInMB, /* COR_PRF_EVENTPIPE_PROVIDER_CONFIG */ LPCVOID pProviders, - UINT32 numProviders) + UINT32 numProviders, + QCallException* qcallError) { QCALL_CONTRACT; @@ -57,7 +58,7 @@ extern "C" UINT64 QCALLTYPE EventPipeInternal_Enable( return sessionID; } -extern "C" void QCALLTYPE EventPipeInternal_Disable(UINT64 sessionID) +extern "C" void QCALLTYPE EventPipeInternal_Disable(UINT64 sessionID, QCallException* qcallError) { QCALL_CONTRACT; @@ -66,7 +67,7 @@ extern "C" void QCALLTYPE EventPipeInternal_Disable(UINT64 sessionID) END_QCALL; } -extern "C" BOOL QCALLTYPE EventPipeInternal_GetSessionInfo(UINT64 sessionID, EventPipeSessionInfo *pSessionInfo) +extern "C" BOOL QCALLTYPE EventPipeInternal_GetSessionInfo(UINT64 sessionID, EventPipeSessionInfo *pSessionInfo, QCallException* qcallError) { QCALL_CONTRACT; @@ -92,7 +93,8 @@ extern "C" BOOL QCALLTYPE EventPipeInternal_GetSessionInfo(UINT64 sessionID, Eve extern "C" INT_PTR QCALLTYPE EventPipeInternal_CreateProvider( _In_z_ LPCWSTR providerName, EventPipeCallback pCallbackFunc, - void* pCallbackContext) + void* pCallbackContext, + QCallException* qcallError) { QCALL_CONTRACT; @@ -114,7 +116,8 @@ extern "C" INT_PTR QCALLTYPE EventPipeInternal_DefineEvent( UINT32 eventVersion, UINT32 level, void *pMetadata, - UINT32 metadataLength) + UINT32 metadataLength, + QCallException* qcallError) { QCALL_CONTRACT; @@ -132,7 +135,7 @@ extern "C" INT_PTR QCALLTYPE EventPipeInternal_DefineEvent( return reinterpret_cast(pEvent); } -extern "C" INT_PTR QCALLTYPE EventPipeInternal_GetProvider(_In_z_ LPCWSTR providerName) +extern "C" INT_PTR QCALLTYPE EventPipeInternal_GetProvider(_In_z_ LPCWSTR providerName, QCallException* qcallError) { QCALL_CONTRACT; @@ -147,7 +150,7 @@ extern "C" INT_PTR QCALLTYPE EventPipeInternal_GetProvider(_In_z_ LPCWSTR provid return reinterpret_cast(pProvider); } -extern "C" void QCALLTYPE EventPipeInternal_DeleteProvider(INT_PTR provHandle) +extern "C" void QCALLTYPE EventPipeInternal_DeleteProvider(INT_PTR provHandle, QCallException* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -161,7 +164,7 @@ extern "C" void QCALLTYPE EventPipeInternal_DeleteProvider(INT_PTR provHandle) END_QCALL; } -extern "C" int QCALLTYPE EventPipeInternal_EventActivityIdControl(uint32_t controlCode, GUID *pActivityId) +extern "C" int QCALLTYPE EventPipeInternal_EventActivityIdControl(uint32_t controlCode, GUID *pActivityId, QCallException* qcallError) { QCALL_CONTRACT; @@ -224,7 +227,8 @@ extern "C" void QCALLTYPE EventPipeInternal_WriteEventData( EventData *pEventData, UINT32 eventDataCount, LPCGUID pActivityId, - LPCGUID pRelatedActivityId) + LPCGUID pRelatedActivityId, + QCallException* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -236,7 +240,7 @@ extern "C" void QCALLTYPE EventPipeInternal_WriteEventData( END_QCALL; } -extern "C" BOOL QCALLTYPE EventPipeInternal_GetNextEvent(UINT64 sessionID, EventPipeEventInstanceData *pInstance) +extern "C" BOOL QCALLTYPE EventPipeInternal_GetNextEvent(UINT64 sessionID, EventPipeEventInstanceData *pInstance, QCallException* qcallError) { QCALL_CONTRACT; @@ -262,7 +266,7 @@ extern "C" BOOL QCALLTYPE EventPipeInternal_GetNextEvent(UINT64 sessionID, Event return pNextInstance != NULL; } -extern "C" BOOL QCALLTYPE EventPipeInternal_SignalSession(UINT64 sessionID) +extern "C" BOOL QCALLTYPE EventPipeInternal_SignalSession(UINT64 sessionID, QCallException* qcallError) { QCALL_CONTRACT; @@ -275,7 +279,7 @@ extern "C" BOOL QCALLTYPE EventPipeInternal_SignalSession(UINT64 sessionID) return result; } -extern "C" BOOL QCALLTYPE EventPipeInternal_WaitForSessionSignal(UINT64 sessionID, INT32 timeoutMs) +extern "C" BOOL QCALLTYPE EventPipeInternal_WaitForSessionSignal(UINT64 sessionID, INT32 timeoutMs, QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/eventpipeinternal.h b/src/coreclr/vm/eventpipeinternal.h index 24740c821c784c..8ded1c2ca5d138 100644 --- a/src/coreclr/vm/eventpipeinternal.h +++ b/src/coreclr/vm/eventpipeinternal.h @@ -44,19 +44,21 @@ extern "C" UINT64 QCALLTYPE EventPipeInternal_Enable( EventPipeSerializationFormat format, UINT32 circularBufferSizeInMB, /* COR_PRF_EVENTPIPE_PROVIDER_CONFIG */ LPCVOID pProviders, - UINT32 numProviders); + UINT32 numProviders, + QCallException* qcallError); //! //! Disables the specified session Id. //! -extern "C" void QCALLTYPE EventPipeInternal_Disable(UINT64 sessionID); +extern "C" void QCALLTYPE EventPipeInternal_Disable(UINT64 sessionID, QCallException* qcallError); -extern "C" BOOL QCALLTYPE EventPipeInternal_GetSessionInfo(UINT64 sessionID, EventPipeSessionInfo *pSessionInfo); +extern "C" BOOL QCALLTYPE EventPipeInternal_GetSessionInfo(UINT64 sessionID, EventPipeSessionInfo *pSessionInfo, QCallException* qcallError); extern "C" INT_PTR QCALLTYPE EventPipeInternal_CreateProvider( _In_z_ LPCWSTR providerName, EventPipeCallback pCallbackFunc, - void* pCallbackContext); + void* pCallbackContext, + QCallException* qcallError); extern "C" INT_PTR QCALLTYPE EventPipeInternal_DefineEvent( INT_PTR provHandle, @@ -65,34 +67,42 @@ extern "C" INT_PTR QCALLTYPE EventPipeInternal_DefineEvent( UINT32 eventVersion, UINT32 level, void *pMetadata, - UINT32 metadataLength); + UINT32 metadataLength, + QCallException* qcallError); extern "C" INT_PTR QCALLTYPE EventPipeInternal_GetProvider( - _In_z_ LPCWSTR providerName); + _In_z_ LPCWSTR providerName, + QCallException* qcallError); extern "C" void QCALLTYPE EventPipeInternal_DeleteProvider( - INT_PTR provHandle); + INT_PTR provHandle, + QCallException* qcallError); extern "C" int QCALLTYPE EventPipeInternal_EventActivityIdControl( UINT32 controlCode, - GUID *pActivityId); + GUID *pActivityId, + QCallException* qcallError); extern "C" void QCALLTYPE EventPipeInternal_WriteEventData( INT_PTR eventHandle, EventData *pEventData, UINT32 eventDataCount, - LPCGUID pActivityId, LPCGUID pRelatedActivityId); + LPCGUID pActivityId, LPCGUID pRelatedActivityId, + QCallException* qcallError); extern "C" BOOL QCALLTYPE EventPipeInternal_GetNextEvent( UINT64 sessionID, - EventPipeEventInstanceData *pInstance); + EventPipeEventInstanceData *pInstance, + QCallException* qcallError); extern "C" BOOL QCALLTYPE EventPipeInternal_SignalSession( - UINT64 sessionID); + UINT64 sessionID, + QCallException* qcallError); extern "C" BOOL QCALLTYPE EventPipeInternal_WaitForSessionSignal( UINT64 sessionID, - INT32 timeoutMs); + INT32 timeoutMs, + QCallException* qcallError); #endif // FEATURE_PERFTRACING diff --git a/src/coreclr/vm/excep.cpp b/src/coreclr/vm/excep.cpp index 8c14d7ac5ce9ef..7fa1a7f6eb18c1 100644 --- a/src/coreclr/vm/excep.cpp +++ b/src/coreclr/vm/excep.cpp @@ -4736,7 +4736,7 @@ static BOOL GetManagedFormatStringForResourceID(UINT32 resId, SString & converte //========================================================================== // Private helper for TypeLoadException. //========================================================================== -extern "C" void QCALLTYPE GetTypeLoadExceptionMessage(UINT32 resId, QCall::StringHandleOnStack retString) +extern "C" void QCALLTYPE GetTypeLoadExceptionMessage(UINT32 resId, QCall::StringHandleOnStack retString, QCallException* qcallError) { QCALL_CONTRACT; @@ -4755,7 +4755,7 @@ extern "C" void QCALLTYPE GetTypeLoadExceptionMessage(UINT32 resId, QCall::Strin // Private helper for FileLoadException and FileNotFoundException. //========================================================================== -extern "C" void QCALLTYPE GetFileLoadExceptionMessage(UINT32 hr, QCall::StringHandleOnStack retString) +extern "C" void QCALLTYPE GetFileLoadExceptionMessage(UINT32 hr, QCall::StringHandleOnStack retString, QCallException* qcallError) { QCALL_CONTRACT; @@ -4771,7 +4771,7 @@ extern "C" void QCALLTYPE GetFileLoadExceptionMessage(UINT32 hr, QCall::StringHa //========================================================================== // Private helper for FileLoadException and FileNotFoundException. //========================================================================== -extern "C" void QCALLTYPE FileLoadException_GetMessageForHR(UINT32 hresult, QCall::StringHandleOnStack retString) +extern "C" void QCALLTYPE FileLoadException_GetMessageForHR(UINT32 hresult, QCall::StringHandleOnStack retString, QCallException* qcallError) { QCALL_CONTRACT; @@ -6654,7 +6654,7 @@ void UnwindAndContinueRethrowHelperInsideCatch(Frame* pEntryFrame, Exception* pE // This does the work of the Unwind and Continue Hanlder inside the catch clause of that handler. The stack has not // been unwound when this is called. Keep that in mind when deciding where to put new code :) // -void UnwindAndContinueRethrowHelperInsideQcallCatch(Frame* pEntryFrame, Exception* pException, QCallException qCallException) +void UnwindAndContinueRethrowHelperInsideQcallCatch(Frame* pEntryFrame, Exception* pException, QCallException* pQCallException) { STATIC_CONTRACT_NOTHROW; STATIC_CONTRACT_GC_TRIGGERS; @@ -6681,7 +6681,7 @@ void UnwindAndContinueRethrowHelperInsideQcallCatch(Frame* pEntryFrame, Exceptio // cases where the last thrown object is NULL. OBJECTREF orThrowable = CLRException::GetThrowableFromException(pException); CONSISTENCY_CHECK(orThrowable != NULL); - qCallException.SetThrowable(orThrowable); + pQCallException->SetThrowable(orThrowable); } // diff --git a/src/coreclr/vm/exceptionhandling.cpp b/src/coreclr/vm/exceptionhandling.cpp index b5227bca050729..9d6f74c682e949 100644 --- a/src/coreclr/vm/exceptionhandling.cpp +++ b/src/coreclr/vm/exceptionhandling.cpp @@ -3133,7 +3133,7 @@ static TADDR GetSpForDiagnosticReporting(REGDISPLAY *pRD) #endif } -extern "C" void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo) +extern "C" void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo, QCallException* qcallError) { QCALL_CONTRACT; @@ -3529,7 +3529,7 @@ void CallFinallyFunclet(BYTE* pHandlerIP, REGDISPLAY* pvRegDisplay, ExInfo* exIn exInfo->MakeCallbacksRelatedToHandler(false, pThread, pMD, &exInfo->m_CurrentClause, (DWORD_PTR)pHandlerIP, spForDebugger); } -extern "C" CLR_BOOL QCALLTYPE CallFilterFunclet(QCall::ObjectHandleOnStack exceptionObj, BYTE* pFilterIP, REGDISPLAY* pvRegDisplay) +extern "C" CLR_BOOL QCALLTYPE CallFilterFunclet(QCall::ObjectHandleOnStack exceptionObj, BYTE* pFilterIP, REGDISPLAY* pvRegDisplay, QCallException* qcallError) { QCALL_CONTRACT; @@ -3696,7 +3696,7 @@ CLR_BOOL EHEnumNextWorker(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClause* pEHClause, return result; } -extern "C" CLR_BOOL QCALLTYPE EHEnumNext(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClause* pEHClause) +extern "C" CLR_BOOL QCALLTYPE EHEnumNext(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClause* pEHClause, QCallException* qcallError) { QCALL_CONTRACT; @@ -4047,7 +4047,7 @@ CLR_BOOL SfiInitWorker(StackFrameIterator* pThis, CONTEXT* pStackwalkCtx, CLR_BO return result; } -extern "C" CLR_BOOL QCALLTYPE SfiInit(StackFrameIterator* pThis, CONTEXT* pStackwalkCtx, CLR_BOOL instructionFault, CLR_BOOL* pfIsExceptionIntercepted) +extern "C" CLR_BOOL QCALLTYPE SfiInit(StackFrameIterator* pThis, CONTEXT* pStackwalkCtx, CLR_BOOL instructionFault, CLR_BOOL* pfIsExceptionIntercepted, QCallException* qcallError) { QCALL_CONTRACT; @@ -4368,7 +4368,7 @@ Exit:; return success; } -extern "C" CLR_BOOL QCALLTYPE SfiNext(StackFrameIterator* pThis, uint* uExCollideClauseIdx, CLR_BOOL* fUnwoundReversePInvoke, CLR_BOOL* pfIsExceptionIntercepted) +extern "C" CLR_BOOL QCALLTYPE SfiNext(StackFrameIterator* pThis, uint* uExCollideClauseIdx, CLR_BOOL* fUnwoundReversePInvoke, CLR_BOOL* pfIsExceptionIntercepted, QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/exceptionhandlingqcalls.h b/src/coreclr/vm/exceptionhandlingqcalls.h index ca0a25826c15d8..b0a933a8aa3fcf 100644 --- a/src/coreclr/vm/exceptionhandlingqcalls.h +++ b/src/coreclr/vm/exceptionhandlingqcalls.h @@ -9,12 +9,12 @@ struct ExInfo; #ifndef DACCESS_COMPILE -extern "C" CLR_BOOL QCALLTYPE CallFilterFunclet(QCall::ObjectHandleOnStack exceptionObj, BYTE* pFilterP, REGDISPLAY* pvRegDisplay); -extern "C" void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo); +extern "C" CLR_BOOL QCALLTYPE CallFilterFunclet(QCall::ObjectHandleOnStack exceptionObj, BYTE* pFilterP, REGDISPLAY* pvRegDisplay, QCallException* qcallError); +extern "C" void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo, QCallException* qcallError); extern "C" CLR_BOOL QCALLTYPE EHEnumInitFromStackFrameIterator(StackFrameIterator *pFrameIter, IJitManager::MethodRegionInfo *pMethodRegionInfo, EH_CLAUSE_ENUMERATOR * pEHEnum); -extern "C" CLR_BOOL QCALLTYPE EHEnumNext(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClause* pEHClause); -extern "C" CLR_BOOL QCALLTYPE SfiInit(StackFrameIterator* pThis, CONTEXT* pStackwalkCtx, CLR_BOOL instructionFault, CLR_BOOL* pIsExceptionIntercepted); -extern "C" CLR_BOOL QCALLTYPE SfiNext(StackFrameIterator* pThis, unsigned int* uExCollideClauseIdx, CLR_BOOL* fUnwoundReversePInvoke, CLR_BOOL* pIsExceptionIntercepted); +extern "C" CLR_BOOL QCALLTYPE EHEnumNext(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClause* pEHClause, QCallException* qcallError); +extern "C" CLR_BOOL QCALLTYPE SfiInit(StackFrameIterator* pThis, CONTEXT* pStackwalkCtx, CLR_BOOL instructionFault, CLR_BOOL* pIsExceptionIntercepted, QCallException* qcallError); +extern "C" CLR_BOOL QCALLTYPE SfiNext(StackFrameIterator* pThis, unsigned int* uExCollideClauseIdx, CLR_BOOL* fUnwoundReversePInvoke, CLR_BOOL* pIsExceptionIntercepted, QCallException* qcallError); #endif // DACCESS_COMPILE #endif // EXCEPTION_HANDLING_QCALLS_H diff --git a/src/coreclr/vm/exceptmacros.h b/src/coreclr/vm/exceptmacros.h index ac29209266ef4e..a96234e70b41e9 100644 --- a/src/coreclr/vm/exceptmacros.h +++ b/src/coreclr/vm/exceptmacros.h @@ -193,6 +193,8 @@ extern LONG InternalUnhandledExceptionFilter_Worker(PEXCEPTION_POINTERS pExcepti VOID DECLSPEC_NORETURN RaiseTheExceptionInternalOnly(OBJECTREF throwable); +struct QCallException; + #if defined(DACCESS_COMPILE) #define INSTALL_UNWIND_AND_CONTINUE_HANDLER @@ -205,16 +207,14 @@ VOID DECLSPEC_NORETURN RaiseTheExceptionInternalOnly(OBJECTREF throwable); struct QCallException { private: - OBJECTREF* m_throwable; - - QCallException() : m_throwable(nullptr) {} + INT32 m_exceptionPending; public: void SetThrowable(OBJECTREF throwable); }; void UnwindAndContinueRethrowHelperInsideCatch(Frame* pEntryFrame, Exception* pException); -void UnwindAndContinueRethrowHelperInsideQcallCatch(Frame* pEntryFrame, Exception* pException, QCallException qCallException); +void UnwindAndContinueRethrowHelperInsideQcallCatch(Frame* pEntryFrame, Exception* pException, QCallException* pQCallException); VOID DECLSPEC_NORETURN UnwindAndContinueRethrowHelperAfterCatch(Frame* pEntryFrame, Exception* pException, bool nativeRethrow); @@ -335,6 +335,7 @@ VOID DECLSPEC_NORETURN DispatchManagedException(PAL_SEHException& ex, bool isHar #define INSTALL_MANAGED_EXCEPTION_CAPTURE_DISPATCHER \ { \ MAKE_CURRENT_THREAD_AVAILABLE(); \ + Exception* __pUnCException = NULL; \ Frame* __pUnCEntryFrame = CURRENT_THREAD->GetFrame(); \ PAL_CPP_TRY { @@ -344,7 +345,7 @@ VOID DECLSPEC_NORETURN DispatchManagedException(PAL_SEHException& ex, bool isHar { \ GCX_COOP(); \ OBJECTREF throwable = ExInfo::CreateThrowable(ex.GetExceptionRecord(), FALSE); \ - qcallError.SetThrowable(throwable); \ + qcallError->SetThrowable(throwable); \ } \ PAL_CPP_CATCH_NON_DERIVED_NOARG (const std::bad_alloc&) \ { \ @@ -457,9 +458,9 @@ VOID DECLSPEC_NORETURN DispatchManagedException(PAL_SEHException& ex, bool isHar #define INSTALL_MANAGED_EXCEPTION_CAPTURE_DISPATCHER \ { \ MAKE_CURRENT_THREAD_AVAILABLE(); \ + Exception* __pUnCException = NULL; \ Frame* __pUnCEntryFrame = CURRENT_THREAD->GetFrame(); \ - PAL_CPP_TRY { \ - INSTALL_UNWIND_AND_CONTINUE_HANDLER + PAL_CPP_TRY { #define UNINSTALL_MANAGED_EXCEPTION_CAPTURE_DISPATCHER \ } \ diff --git a/src/coreclr/vm/finalizerthread.cpp b/src/coreclr/vm/finalizerthread.cpp index 56db5891234347..44151fbf24a41c 100644 --- a/src/coreclr/vm/finalizerthread.cpp +++ b/src/coreclr/vm/finalizerthread.cpp @@ -87,7 +87,7 @@ extern "C" void SystemJS_ExecuteFinalizationCallback() RunFinalizerIterationOnCurrentThread(); } #else // TARGET_WASI -extern "C" void QCALLTYPE WasiFinalizer_RunWorker() +extern "C" void QCALLTYPE WasiFinalizer_RunWorker(QCallException* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -128,7 +128,7 @@ extern "C" void WasiFinalizer_Schedule() s_finalizationPending = true; } -extern "C" CLR_BOOL QCALLTYPE WasiFinalizer_TryClearPending() +extern "C" CLR_BOOL QCALLTYPE WasiFinalizer_TryClearPending(QCallException* qcallError) { QCALL_CONTRACT; CLR_BOOL pending = FALSE; diff --git a/src/coreclr/vm/ilmarshalers.cpp b/src/coreclr/vm/ilmarshalers.cpp index 2b0239f2f0c3cb..3c6f4be63670e1 100644 --- a/src/coreclr/vm/ilmarshalers.cpp +++ b/src/coreclr/vm/ilmarshalers.cpp @@ -4759,7 +4759,7 @@ extern "C" void QCALLTYPE MngdSafeArrayMarshaler_CreateMarshaler(MngdSafeArrayMa pThis->m_pConvertContentsToManagedCode = pConvertToManaged; } -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome) +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallException* qcallError) { CONTRACTL { @@ -4794,7 +4794,7 @@ extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToNative(MngdSafeAr END_QCALL; } -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCall::ObjectHandleOnStack pOriginalManaged) +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCall::ObjectHandleOnStack pOriginalManaged, QCallException* qcallError) { CONTRACTL { @@ -4837,7 +4837,7 @@ extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToNative(MngdSaf END_QCALL; } -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome) +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallException* qcallError) { CONTRACTL { @@ -4894,7 +4894,7 @@ extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToManaged(MngdSafeA END_QCALL; } -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome) +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallException* qcallError) { CONTRACTL { @@ -4931,7 +4931,7 @@ extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToManaged(MngdSa END_QCALL; } -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ClearNative(MngdSafeArrayMarshaler* pThis, void** pNativeHome) +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ClearNative(MngdSafeArrayMarshaler* pThis, void** pNativeHome, QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/ilmarshalers.h b/src/coreclr/vm/ilmarshalers.h index fd42e348875c34..25241db22e94d0 100644 --- a/src/coreclr/vm/ilmarshalers.h +++ b/src/coreclr/vm/ilmarshalers.h @@ -3463,11 +3463,11 @@ class MngdSafeArrayMarshaler }; extern "C" void QCALLTYPE MngdSafeArrayMarshaler_CreateMarshaler(MngdSafeArrayMarshaler* pThis, MethodTable* pMT, UINT32 iRank, UINT32 dwFlags, PCODE pConvertToNative, PCODE pConvertToManaged); -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome); -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCall::ObjectHandleOnStack pOriginalManaged); -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome); -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome); -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ClearNative(MngdSafeArrayMarshaler* pThis, void** pNativeHome); +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallException* qcallError); +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCall::ObjectHandleOnStack pOriginalManaged, QCallException* qcallError); +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallException* qcallError); +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallException* qcallError); +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ClearNative(MngdSafeArrayMarshaler* pThis, void** pNativeHome, QCallException* qcallError); #endif // FEATURE_COMINTEROP class ILReferenceCustomMarshaler : public ILMngdMarshaler diff --git a/src/coreclr/vm/interoplibinterface.h b/src/coreclr/vm/interoplibinterface.h index 18e8944a3a1fdb..0a0e3194b76611 100644 --- a/src/coreclr/vm/interoplibinterface.h +++ b/src/coreclr/vm/interoplibinterface.h @@ -71,9 +71,10 @@ extern "C" BOOL QCALLTYPE ObjCMarshal_TryInitializeReferenceTracker( _In_ ObjCMarshalNative::BeginEndCallback beginEndCallback, _In_ ObjCMarshalNative::IsReferencedCallback isReferencedCallback, _In_ ObjCMarshalNative::EnteredFinalizationCallback trackedObjectEnteredFinalization, - _In_ QCall::ObjectHandleOnStack objectTrackingInfoTable); + _In_ QCall::ObjectHandleOnStack objectTrackingInfoTable, + QCallException* qcallError); -extern "C" void* QCALLTYPE ObjCMarshal_AllocateReferenceTrackingHandle(_In_ QCall::ObjectHandleOnStack obj); +extern "C" void* QCALLTYPE ObjCMarshal_AllocateReferenceTrackingHandle(_In_ QCall::ObjectHandleOnStack obj, QCallException* qcallError); extern "C" void QCALLTYPE ObjCMarshal_GetOrCreateReferenceTrackingMemory( _In_ QCall::ObjectHandleOnStack obj, @@ -82,7 +83,8 @@ extern "C" void QCALLTYPE ObjCMarshal_GetOrCreateReferenceTrackingMemory( extern "C" BOOL QCALLTYPE ObjCMarshal_TrySetGlobalMessageSendCallback( _In_ ObjCMarshalNative::MessageSendFunction msgSendFunction, - _In_ void* fptr); + _In_ void* fptr, + QCallException* qcallError); #endif // FEATURE_OBJCMARSHAL @@ -95,16 +97,19 @@ class JavaNative }; extern "C" BOOL QCALLTYPE JavaMarshal_Initialize( - _In_ void* markCrossReferences); + _In_ void* markCrossReferences, + QCallException* qcallError); extern "C" void* QCALLTYPE JavaMarshal_CreateReferenceTrackingHandle( _In_ QCall::ObjectHandleOnStack obj, - _In_ void* context); + _In_ void* context, + QCallException* qcallError); extern "C" void QCALLTYPE JavaMarshal_FinishCrossReferenceProcessing( _In_ MarkCrossReferencesArgs *crossReferences, _In_ size_t length, - _In_ void* unreachableObjectHandles); + _In_ void* unreachableObjectHandles, + QCallException* qcallError); extern "C" BOOL QCALLTYPE JavaMarshal_GetContext( _In_ OBJECTHANDLE handle, diff --git a/src/coreclr/vm/interoplibinterface_comwrappers.cpp b/src/coreclr/vm/interoplibinterface_comwrappers.cpp index 857e4cd77bc18e..d31df184d3534a 100644 --- a/src/coreclr/vm/interoplibinterface_comwrappers.cpp +++ b/src/coreclr/vm/interoplibinterface_comwrappers.cpp @@ -112,7 +112,7 @@ bool GlobalComWrappersForMarshalling::TryGetOrCreateObjectForComInstance( return obj != NULL; } -extern "C" void* QCALLTYPE ComWrappers_AllocateRefCountedHandle(_In_ QCall::ObjectHandleOnStack obj) +extern "C" void* QCALLTYPE ComWrappers_AllocateRefCountedHandle(_In_ QCall::ObjectHandleOnStack obj, QCallException* qcallError) { QCALL_CONTRACT; @@ -564,7 +564,7 @@ void ComWrappersNative::OnAfterGCScanRoots() (void)InteropLib::Com::DetachNonPromotedObjects(&cxt); } -extern "C" void QCALLTYPE ComWrappers_RegisterIsRootedCallback() +extern "C" void QCALLTYPE ComWrappers_RegisterIsRootedCallback(QCallException* qcallError) { QCALL_CONTRACT; @@ -576,7 +576,7 @@ extern "C" void QCALLTYPE ComWrappers_RegisterIsRootedCallback() END_QCALL; } -extern "C" void QCALLTYPE TrackerObjectManager_RegisterNativeObjectWrapperCache(_In_ QCall::ObjectHandleOnStack cache) +extern "C" void QCALLTYPE TrackerObjectManager_RegisterNativeObjectWrapperCache(_In_ QCall::ObjectHandleOnStack cache, QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/interoplibinterface_comwrappers.h b/src/coreclr/vm/interoplibinterface_comwrappers.h index 205456136b9d6b..2bb07e40b30c91 100644 --- a/src/coreclr/vm/interoplibinterface_comwrappers.h +++ b/src/coreclr/vm/interoplibinterface_comwrappers.h @@ -34,19 +34,19 @@ extern "C" void QCALLTYPE ComWrappers_GetIUnknownImpl( extern "C" void* QCALLTYPE ComWrappers_GetUntrackedAddRefRelease(); -extern "C" void* QCALLTYPE ComWrappers_AllocateRefCountedHandle(_In_ QCall::ObjectHandleOnStack obj); +extern "C" void* QCALLTYPE ComWrappers_AllocateRefCountedHandle(_In_ QCall::ObjectHandleOnStack obj, QCallException* qcallError); extern "C" void const* QCALLTYPE ComWrappers_GetIReferenceTrackerTargetVftbl(); extern "C" void const* QCALLTYPE ComWrappers_GetTaggedImpl(); -extern "C" void QCALLTYPE ComWrappers_RegisterIsRootedCallback(); +extern "C" void QCALLTYPE ComWrappers_RegisterIsRootedCallback(QCallException* qcallError); extern "C" CLR_BOOL QCALLTYPE TrackerObjectManager_HasReferenceTrackerManager(); extern "C" CLR_BOOL QCALLTYPE TrackerObjectManager_TryRegisterReferenceTrackerManager(_In_ void* manager); -extern "C" void QCALLTYPE TrackerObjectManager_RegisterNativeObjectWrapperCache(_In_ QCall::ObjectHandleOnStack cache); +extern "C" void QCALLTYPE TrackerObjectManager_RegisterNativeObjectWrapperCache(_In_ QCall::ObjectHandleOnStack cache, QCallException* qcallError); extern "C" CLR_BOOL QCALLTYPE TrackerObjectManager_IsGlobalPeggingEnabled(); diff --git a/src/coreclr/vm/interoplibinterface_java.cpp b/src/coreclr/vm/interoplibinterface_java.cpp index e4f1f07f11997b..fd1635b9d812f6 100644 --- a/src/coreclr/vm/interoplibinterface_java.cpp +++ b/src/coreclr/vm/interoplibinterface_java.cpp @@ -135,7 +135,8 @@ void Interop::FinishCrossReferenceProcessing( } extern "C" BOOL QCALLTYPE JavaMarshal_Initialize( - _In_ void* markCrossReferences) + _In_ void* markCrossReferences, + QCallException* qcallError) { QCALL_CONTRACT; _ASSERTE(markCrossReferences != NULL); @@ -164,7 +165,8 @@ extern "C" BOOL QCALLTYPE JavaMarshal_Initialize( extern "C" void* QCALLTYPE JavaMarshal_CreateReferenceTrackingHandle( _In_ QCall::ObjectHandleOnStack obj, - _In_ void* context) + _In_ void* context, + QCallException* qcallError) { QCALL_CONTRACT; @@ -183,7 +185,8 @@ extern "C" void* QCALLTYPE JavaMarshal_CreateReferenceTrackingHandle( extern "C" void QCALLTYPE JavaMarshal_FinishCrossReferenceProcessing( _In_ MarkCrossReferencesArgs *crossReferences, _In_ size_t length, - _In_ void* unreachableObjectHandles) + _In_ void* unreachableObjectHandles, + QCallException* qcallError) { QCALL_CONTRACT; _ASSERTE(crossReferences->ComponentCount >= 0); diff --git a/src/coreclr/vm/interoplibinterface_objc.cpp b/src/coreclr/vm/interoplibinterface_objc.cpp index 924cca2c031f6a..99421808548dc1 100644 --- a/src/coreclr/vm/interoplibinterface_objc.cpp +++ b/src/coreclr/vm/interoplibinterface_objc.cpp @@ -28,7 +28,8 @@ extern "C" BOOL QCALLTYPE ObjCMarshal_TryInitializeReferenceTracker( _In_ ObjCMarshalNative::BeginEndCallback beginEndCallback, _In_ ObjCMarshalNative::IsReferencedCallback isReferencedCallback, _In_ ObjCMarshalNative::EnteredFinalizationCallback trackedObjectEnteredFinalization, - _In_ QCall::ObjectHandleOnStack objectTrackingInfoTable) + _In_ QCall::ObjectHandleOnStack objectTrackingInfoTable, + QCallException* qcallError) { QCALL_CONTRACT; _ASSERTE(beginEndCallback != NULL @@ -60,7 +61,7 @@ extern "C" BOOL QCALLTYPE ObjCMarshal_TryInitializeReferenceTracker( return success; } -extern "C" void* QCALLTYPE ObjCMarshal_AllocateReferenceTrackingHandle(_In_ QCall::ObjectHandleOnStack obj) +extern "C" void* QCALLTYPE ObjCMarshal_AllocateReferenceTrackingHandle(_In_ QCall::ObjectHandleOnStack obj, QCallException* qcallError) { QCALL_CONTRACT; @@ -121,7 +122,8 @@ namespace extern "C" BOOL QCALLTYPE ObjCMarshal_TrySetGlobalMessageSendCallback( _In_ ObjCMarshalNative::MessageSendFunction msgSendFunction, - _In_ void* fptr) + _In_ void* fptr, + QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/jithelpers.cpp b/src/coreclr/vm/jithelpers.cpp index 6330135b6f1c26..013fec944749d6 100644 --- a/src/coreclr/vm/jithelpers.cpp +++ b/src/coreclr/vm/jithelpers.cpp @@ -245,7 +245,7 @@ HCIMPLEND #include // Helper for the managed InitClass implementations -extern "C" void QCALLTYPE InitClassHelper(MethodTable* pMT) +extern "C" void QCALLTYPE InitClassHelper(MethodTable* pMT, QCallException* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -318,7 +318,7 @@ __declspec(selectany) #endif // _MSC_VER PLATFORM_THREAD_LOCAL ThreadLocalData t_ThreadStatics; -extern "C" void QCALLTYPE GetThreadStaticsByMethodTable(QCall::ByteRefOnStack refHandle, MethodTable* pMT, bool gcStatic) +extern "C" void QCALLTYPE GetThreadStaticsByMethodTable(QCall::ByteRefOnStack refHandle, MethodTable* pMT, bool gcStatic, QCallException* qcallError) { QCALL_CONTRACT; @@ -339,7 +339,7 @@ extern "C" void QCALLTYPE GetThreadStaticsByMethodTable(QCall::ByteRefOnStack re END_QCALL; } -extern "C" void QCALLTYPE GetThreadStaticsByIndex(QCall::ByteRefOnStack refHandle, uint32_t staticBlockIndex, bool gcStatic) +extern "C" void QCALLTYPE GetThreadStaticsByIndex(QCall::ByteRefOnStack refHandle, uint32_t staticBlockIndex, bool gcStatic, QCallException* qcallError) { QCALL_CONTRACT; @@ -473,7 +473,7 @@ BOOL ObjIsInstanceOf(Object* pObject, TypeHandle toTypeHnd, BOOL throwCastExcept return ObjIsInstanceOfCore(pObject, toTypeHnd, throwCastException); } -extern "C" BOOL QCALLTYPE IsInstanceOf_NoCacheLookup(EnregisteredTypeHandle type, BOOL throwCastException, QCall::ObjectHandleOnStack objOnStack) +extern "C" BOOL QCALLTYPE IsInstanceOf_NoCacheLookup(EnregisteredTypeHandle type, BOOL throwCastException, QCall::ObjectHandleOnStack objOnStack, QCallException* qcallError) { QCALL_CONTRACT; BOOL result = FALSE; @@ -502,7 +502,7 @@ HCIMPL2(BOOL, JIT_IsInstanceOfException, EnregisteredTypeHandle type, Object* ob } HCIMPLEND -extern "C" void QCALLTYPE ThrowInvalidCastException(EnregisteredTypeHandle pSourceType, EnregisteredTypeHandle pTargetType) +extern "C" void QCALLTYPE ThrowInvalidCastException(EnregisteredTypeHandle pSourceType, EnregisteredTypeHandle pTargetType, QCallException* qcallError) { QCALL_CONTRACT; @@ -600,7 +600,7 @@ DictionaryEntry GenericHandleWorkerCore(MethodDesc * pMD, MethodTable * pMT, LPV return result; } -extern "C" void* QCALLTYPE GenericHandleWorker(MethodDesc * pMD, MethodTable * pMT, LPVOID signature, DWORD dictionaryIndexAndSlot, Module* pModule) +extern "C" void* QCALLTYPE GenericHandleWorker(MethodDesc * pMD, MethodTable * pMT, LPVOID signature, DWORD dictionaryIndexAndSlot, Module* pModule, QCallException* qcallError) { QCALL_CONTRACT; @@ -675,7 +675,8 @@ void FlushVirtualFunctionPointerCaches() // slow helper to call from the fast one extern "C" PCODE QCALLTYPE ResolveVirtualFunctionPointer(QCall::ObjectHandleOnStack obj, EnregisteredTypeHandle classHnd, - MethodDesc* pStaticMD) + MethodDesc* pStaticMD, + QCallException* qcallError) { QCALL_CONTRACT; @@ -1133,12 +1134,15 @@ NOINLINE void JIT_PInvokeEndRarePath() // or ThreadAbort is requested. This means that the pinvoke frame is still on the stack and // enabled, but the thread has been marked as returning to cooperative mode. Thus we can // use that frame to provide GC suspension safety, but we need to manually call EnablePreemptiveGC - // and DisablePreemptiveGC to put the function in a state where the BEGIN_QCALL/END_QCALL macros - // will work correctly. + // and DisablePreemptiveGC around the exception dispatch handlers. thread->EnablePreemptiveGC(); - BEGIN_QCALL; + INSTALL_RESUME_AFTER_CATCH_HANDLER_WITH_FRAME(GetThread()->GetFrame()) + INSTALL_MANAGED_EXCEPTION_DISPATCHER + INSTALL_UNWIND_AND_CONTINUE_HANDLER thread->HandleThreadAbort(); - END_QCALL; + UNINSTALL_UNWIND_AND_CONTINUE_HANDLER + UNINSTALL_MANAGED_EXCEPTION_DISPATCHER + UNINSTALL_RESUME_AFTER_CATCH_HANDLER_WITH_FRAME thread->DisablePreemptiveGC(); } @@ -1162,7 +1166,7 @@ void JIT_RareDisableHelperWorker() void JIT_RareDisableHelper() #endif { - // We do this here (before we enter the BEGIN_QCALL macro), because the following scenario + // We do this before installing the exception handlers because of the following scenario. // We are in the process of doing an inlined pinvoke. Since we are in preemtive // mode, the thread is allowed to continue. The thread continues and gets a context // switch just after it has cleared the preemptive mode bit but before it gets @@ -1194,12 +1198,15 @@ void JIT_RareDisableHelper() // or ThreadAbort is requested. This means that the pinvoke frame is still on the stack and // enabled, but the thread has been marked as returning to cooperative mode. Thus we can // use that frame to provide GC suspension safety, but we need to manually call EnablePreemptiveGC - // and DisablePreemptiveGC to put the function in a state where the BEGIN_QCALL/END_QCALL macros - // will work correctly. + // and DisablePreemptiveGC around the exception dispatch handlers. thread->EnablePreemptiveGC(); - BEGIN_QCALL; + INSTALL_RESUME_AFTER_CATCH_HANDLER_WITH_FRAME(GetThread()->GetFrame()) + INSTALL_MANAGED_EXCEPTION_DISPATCHER + INSTALL_UNWIND_AND_CONTINUE_HANDLER thread->HandleThreadAbort(); - END_QCALL; + UNINSTALL_UNWIND_AND_CONTINUE_HANDLER + UNINSTALL_MANAGED_EXCEPTION_DISPATCHER + UNINSTALL_RESUME_AFTER_CATCH_HANDLER_WITH_FRAME thread->DisablePreemptiveGC(); } } diff --git a/src/coreclr/vm/loaderallocator.cpp b/src/coreclr/vm/loaderallocator.cpp index 926978bbad9018..ee39679533296a 100644 --- a/src/coreclr/vm/loaderallocator.cpp +++ b/src/coreclr/vm/loaderallocator.cpp @@ -757,7 +757,7 @@ BOOL LoaderAllocator::Destroy(QCall::LoaderAllocatorHandle pLoaderAllocator) return FALSE; } // LoaderAllocator::Destroy -extern "C" BOOL QCALLTYPE LoaderAllocator_Destroy(QCall::LoaderAllocatorHandle pLoaderAllocator) +extern "C" BOOL QCALLTYPE LoaderAllocator_Destroy(QCall::LoaderAllocatorHandle pLoaderAllocator, QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/loaderallocator.hpp b/src/coreclr/vm/loaderallocator.hpp index 0ddffcd79ec57f..f9cc45d613af1b 100644 --- a/src/coreclr/vm/loaderallocator.hpp +++ b/src/coreclr/vm/loaderallocator.hpp @@ -960,7 +960,7 @@ struct cdac_data typedef VPTR(LoaderAllocator) PTR_LoaderAllocator; -extern "C" BOOL QCALLTYPE LoaderAllocator_Destroy(QCall::LoaderAllocatorHandle pLoaderAllocator); +extern "C" BOOL QCALLTYPE LoaderAllocator_Destroy(QCall::LoaderAllocatorHandle pLoaderAllocator, QCallException* qcallError); class GlobalLoaderAllocator : public LoaderAllocator { diff --git a/src/coreclr/vm/managedmdimport.cpp b/src/coreclr/vm/managedmdimport.cpp index 864f0bec4fa00e..6783d171266f9a 100644 --- a/src/coreclr/vm/managedmdimport.cpp +++ b/src/coreclr/vm/managedmdimport.cpp @@ -26,7 +26,8 @@ extern "C" BOOL QCALLTYPE MetadataImport_GetMarshalAs( INT32* marshalTypeLength, LPUTF8* marshalCookie, INT32* marshalCookieLength, - INT32* iidParamIndex) + INT32* iidParamIndex, + QCallException* qcallError) { CONTRACTL { @@ -539,7 +540,8 @@ extern "C" void QCALLTYPE MetadataImport_Enum( mdToken tkParent, /* in/out */ INT32* length, INT32* shortResult, - QCall::ObjectHandleOnStack longResult) + QCall::ObjectHandleOnStack longResult, + QCallException* qcallError) { CONTRACTL { diff --git a/src/coreclr/vm/managedmdimport.hpp b/src/coreclr/vm/managedmdimport.hpp index aae7563b71edad..d7d91515d8be33 100644 --- a/src/coreclr/vm/managedmdimport.hpp +++ b/src/coreclr/vm/managedmdimport.hpp @@ -70,7 +70,8 @@ extern "C" BOOL QCALLTYPE MetadataImport_GetMarshalAs( INT32* marshalTypeLength, LPUTF8* marshalCookie, INT32* marshalCookieLength, - INT32* iidParamIndex); + INT32* iidParamIndex, + QCallException* qcallError); extern "C" void QCALLTYPE MetadataImport_Enum( IMDInternalImport* pScope, @@ -78,6 +79,7 @@ extern "C" void QCALLTYPE MetadataImport_Enum( mdToken tkParent, INT32* length, INT32* shortResult, - QCall::ObjectHandleOnStack longResult); + QCall::ObjectHandleOnStack longResult, + QCallException* qcallError); #endif diff --git a/src/coreclr/vm/marshalnative.cpp b/src/coreclr/vm/marshalnative.cpp index de5285443fcd23..e7da5ef0e4eeb7 100644 --- a/src/coreclr/vm/marshalnative.cpp +++ b/src/coreclr/vm/marshalnative.cpp @@ -50,7 +50,7 @@ // Prelink // Does advance loading of an PInvoke library -extern "C" VOID QCALLTYPE MarshalNative_Prelink(MethodDesc * pMD) +extern "C" VOID QCALLTYPE MarshalNative_Prelink(MethodDesc * pMD, QCallException* qcallError) { QCALL_CONTRACT; @@ -77,7 +77,7 @@ extern "C" VOID QCALLTYPE MarshalNative_Prelink(MethodDesc * pMD) // IsBuiltInComSupported // Built-in COM support is only checked from the native side to ensure the runtime // is in a consistent state -extern "C" BOOL QCALLTYPE MarshalNative_IsBuiltInComSupported() +extern "C" BOOL QCALLTYPE MarshalNative_IsBuiltInComSupported(QCallException* qcallError) { QCALL_CONTRACT; @@ -96,7 +96,7 @@ extern "C" BOOL QCALLTYPE MarshalNative_IsBuiltInComSupported() return ret; } -extern "C" BOOL QCALLTYPE MarshalNative_HasLayout(QCall::TypeHandle t, BOOL* pIsBlittable, DWORD* pNativeSize) +extern "C" BOOL QCALLTYPE MarshalNative_HasLayout(QCall::TypeHandle t, BOOL* pIsBlittable, DWORD* pNativeSize, QCallException* qcallError) { QCALL_CONTRACT; @@ -133,7 +133,7 @@ extern "C" BOOL QCALLTYPE MarshalNative_HasLayout(QCall::TypeHandle t, BOOL* pIs /************************************************************************ * PInvoke.SizeOf(Class) */ -extern "C" INT32 QCALLTYPE MarshalNative_SizeOfHelper(QCall::TypeHandle t, BOOL throwIfNotMarshalable) +extern "C" INT32 QCALLTYPE MarshalNative_SizeOfHelper(QCall::TypeHandle t, BOOL throwIfNotMarshalable, QCallException* qcallError) { QCALL_CONTRACT; @@ -163,7 +163,7 @@ extern "C" INT32 QCALLTYPE MarshalNative_SizeOfHelper(QCall::TypeHandle t, BOOL return rv; } -extern "C" SIZE_T QCALLTYPE MarshalNative_OffsetOf(FieldDesc* pFD) +extern "C" SIZE_T QCALLTYPE MarshalNative_OffsetOf(FieldDesc* pFD, QCallException* qcallError) { CONTRACTL { @@ -215,7 +215,7 @@ extern "C" SIZE_T QCALLTYPE MarshalNative_OffsetOf(FieldDesc* pFD) return offset; } -extern "C" void QCALLTYPE MarshalNative_GetDelegateForFunctionPointerInternal(PVOID FPtr, QCall::TypeHandle t, QCall::ObjectHandleOnStack retDelegate) +extern "C" void QCALLTYPE MarshalNative_GetDelegateForFunctionPointerInternal(PVOID FPtr, QCall::TypeHandle t, QCall::ObjectHandleOnStack retDelegate, QCallException* qcallError) { QCALL_CONTRACT; @@ -232,7 +232,7 @@ extern "C" void QCALLTYPE MarshalNative_GetDelegateForFunctionPointerInternal(PV END_QCALL; } -extern "C" PVOID QCALLTYPE MarshalNative_GetFunctionPointerForDelegateInternal(QCall::ObjectHandleOnStack d) +extern "C" PVOID QCALLTYPE MarshalNative_GetFunctionPointerForDelegateInternal(QCall::ObjectHandleOnStack d, QCallException* qcallError) { QCALL_CONTRACT; @@ -257,7 +257,7 @@ namespace } } -extern "C" IsInCooperativeGCMode_fn QCALLTYPE MarshalNative_GetIsInCooperativeGCModeFunctionPointer() +extern "C" IsInCooperativeGCMode_fn QCALLTYPE MarshalNative_GetIsInCooperativeGCModeFunctionPointer(QCallException* qcallError) { QCALL_CONTRACT; @@ -319,7 +319,7 @@ DWORD STDMETHODCALLTYPE FalseGetLastError() * Support for the GCHandle class. */ -extern "C" OBJECTHANDLE QCALLTYPE GCHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack obj, int type) +extern "C" OBJECTHANDLE QCALLTYPE GCHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack obj, int type, QCallException* qcallError) { QCALL_CONTRACT; @@ -350,7 +350,7 @@ FCIMPL2(LPVOID, MarshalNative::GCHandleInternalAlloc, Object *obj, int type) } FCIMPLEND -extern "C" void QCALLTYPE GCHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle) +extern "C" void QCALLTYPE GCHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle, QCallException* qcallError) { QCALL_CONTRACT; @@ -410,7 +410,7 @@ FCIMPL2(FC_BOOL_RET, MarshalNative::GCHandleInternalTryGetBridgeWait, OBJECTHAND FCIMPLEND // Unlike the fast call above, this can block -extern "C" void QCALLTYPE GCHandle_InternalGetBridgeWait(OBJECTHANDLE handle, QCall::ObjectHandleOnStack result) +extern "C" void QCALLTYPE GCHandle_InternalGetBridgeWait(OBJECTHANDLE handle, QCall::ObjectHandleOnStack result, QCallException* qcallError) { QCALL_CONTRACT; @@ -460,7 +460,7 @@ FCIMPLEND // *** Interop Helpers *** //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetExceptionForHR(INT32 errorCode, LPVOID errorInfo, QCall::ObjectHandleOnStack retVal) +extern "C" void QCALLTYPE MarshalNative_GetExceptionForHR(INT32 errorCode, LPVOID errorInfo, QCall::ObjectHandleOnStack retVal, QCallException* qcallError) { CONTRACTL { @@ -502,7 +502,7 @@ extern "C" void QCALLTYPE MarshalNative_GetExceptionForHR(INT32 errorCode, LPVOI } #ifdef FEATURE_COMINTEROP -extern "C" int32_t QCALLTYPE MarshalNative_GetHRForException(QCall::ObjectHandleOnStack obj) +extern "C" int32_t QCALLTYPE MarshalNative_GetHRForException(QCall::ObjectHandleOnStack obj, QCallException* qcallError) { CONTRACTL { @@ -527,7 +527,7 @@ extern "C" int32_t QCALLTYPE MarshalNative_GetHRForException(QCall::ObjectHandle //==================================================================== // return the IUnknown* for an Object. //==================================================================== -extern "C" IUnknown* QCALLTYPE MarshalNative_GetIUnknownForObject(QCall::ObjectHandleOnStack o) +extern "C" IUnknown* QCALLTYPE MarshalNative_GetIUnknownForObject(QCall::ObjectHandleOnStack o, QCallException* qcallError) { QCALL_CONTRACT; @@ -552,7 +552,7 @@ extern "C" IUnknown* QCALLTYPE MarshalNative_GetIUnknownForObject(QCall::ObjectH //==================================================================== // return the IDispatch* for an Object. //==================================================================== -extern "C" IDispatch* QCALLTYPE MarshalNative_GetIDispatchForObject(QCall::ObjectHandleOnStack o) +extern "C" IDispatch* QCALLTYPE MarshalNative_GetIDispatchForObject(QCall::ObjectHandleOnStack o, QCallException* qcallError) { QCALL_CONTRACT; @@ -577,7 +577,7 @@ extern "C" IDispatch* QCALLTYPE MarshalNative_GetIDispatchForObject(QCall::Objec //==================================================================== // return the IUnknown* or IDispatch* for an Object. //==================================================================== -extern "C" void* QCALLTYPE MarshalNative_GetIUnknownOrIDispatchForObject(QCall::ObjectHandleOnStack o, BOOL* isIDispatch) +extern "C" void* QCALLTYPE MarshalNative_GetIUnknownOrIDispatchForObject(QCall::ObjectHandleOnStack o, BOOL* isIDispatch, QCallException* qcallError) { QCALL_CONTRACT; @@ -605,7 +605,7 @@ extern "C" void* QCALLTYPE MarshalNative_GetIUnknownOrIDispatchForObject(QCall:: // return the IUnknown* representing the interface for the Object // Object o should support Type T //==================================================================== -extern "C" IUnknown* QCALLTYPE MarshalNative_GetComInterfaceForObject(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, BOOL bEnableCustomizedQueryInterface) +extern "C" IUnknown* QCALLTYPE MarshalNative_GetComInterfaceForObject(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, BOOL bEnableCustomizedQueryInterface, QCallException* qcallError) { QCALL_CONTRACT; @@ -651,7 +651,7 @@ extern "C" IUnknown* QCALLTYPE MarshalNative_GetComInterfaceForObject(QCall::Obj //==================================================================== // return an Object for IUnknown //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject) +extern "C" void QCALLTYPE MarshalNative_GetObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject, QCallException* qcallError) { CONTRACTL { @@ -676,7 +676,7 @@ extern "C" void QCALLTYPE MarshalNative_GetObjectForIUnknown(IUnknown* pUnk, QCa END_QCALL; } -extern "C" void QCALLTYPE MarshalNative_GetUniqueObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject) +extern "C" void QCALLTYPE MarshalNative_GetUniqueObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject, QCallException* qcallError) { CONTRACTL { @@ -706,7 +706,7 @@ extern "C" void QCALLTYPE MarshalNative_GetUniqueObjectForIUnknown(IUnknown* pUn // NOTE: // Type T should be either a COM imported Type or a sub-type of COM imported Type //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetTypedObjectForIUnknown(IUnknown* pUnk, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject) +extern "C" void QCALLTYPE MarshalNative_GetTypedObjectForIUnknown(IUnknown* pUnk, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject, QCallException* qcallError) { CONTRACTL { @@ -738,7 +738,7 @@ extern "C" void QCALLTYPE MarshalNative_GetTypedObjectForIUnknown(IUnknown* pUnk END_QCALL; } -extern "C" IUnknown* QCALLTYPE MarshalNative_CreateAggregatedObject(IUnknown* pOuter, QCall::ObjectHandleOnStack o) +extern "C" IUnknown* QCALLTYPE MarshalNative_CreateAggregatedObject(IUnknown* pOuter, QCall::ObjectHandleOnStack o, QCallException* qcallError) { CONTRACTL { @@ -781,7 +781,7 @@ extern "C" IUnknown* QCALLTYPE MarshalNative_CreateAggregatedObject(IUnknown* pO //==================================================================== // Free unused RCWs in the current CLR context. //==================================================================== -extern "C" void QCALLTYPE MarshalNative_CleanupUnusedObjectsInCurrentContext() +extern "C" void QCALLTYPE MarshalNative_CleanupUnusedObjectsInCurrentContext(QCallException* qcallError) { QCALL_CONTRACT; @@ -820,7 +820,7 @@ FCIMPLEND // free the COM component and zombie this object if the ref count hits 0 // further usage of this Object might throw an exception, //==================================================================== -extern "C" INT32 QCALLTYPE MarshalNative_ReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE) +extern "C" INT32 QCALLTYPE MarshalNative_ReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, QCallException* qcallError) { QCALL_CONTRACT; @@ -852,7 +852,7 @@ extern "C" INT32 QCALLTYPE MarshalNative_ReleaseComObject(QCall::ObjectHandleOnS // free the COM component and zombie this object // further usage of this Object might throw an exception, //==================================================================== -extern "C" void QCALLTYPE MarshalNative_FinalReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE) +extern "C" void QCALLTYPE MarshalNative_FinalReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, QCallException* qcallError) { QCALL_CONTRACT; @@ -880,7 +880,7 @@ extern "C" void QCALLTYPE MarshalNative_FinalReleaseComObject(QCall::ObjectHandl // This method takes the given COM object and wraps it in an object // of the specified type. The type must be derived from __ComObject. //==================================================================== -extern "C" void QCALLTYPE MarshalNative_InternalCreateWrapperOfType(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject) +extern "C" void QCALLTYPE MarshalNative_InternalCreateWrapperOfType(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject, QCallException* qcallError) { QCALL_CONTRACT; @@ -942,7 +942,7 @@ extern "C" void QCALLTYPE MarshalNative_InternalCreateWrapperOfType(QCall::Objec //==================================================================== // check if the type is visible from COM. //==================================================================== -extern "C" BOOL QCALLTYPE MarshalNative_IsTypeVisibleFromCom(QCall::TypeHandle t) +extern "C" BOOL QCALLTYPE MarshalNative_IsTypeVisibleFromCom(QCall::TypeHandle t, QCallException* qcallError) { QCALL_CONTRACT; @@ -958,7 +958,7 @@ extern "C" BOOL QCALLTYPE MarshalNative_IsTypeVisibleFromCom(QCall::TypeHandle t return retVal; } -extern "C" void QCALLTYPE MarshalNative_GetNativeVariantForObject(QCall::ObjectHandleOnStack ObjUNSAFE, LPVOID pDestNativeVariant) +extern "C" void QCALLTYPE MarshalNative_GetNativeVariantForObject(QCall::ObjectHandleOnStack ObjUNSAFE, LPVOID pDestNativeVariant, QCallException* qcallError) { CONTRACTL { @@ -992,7 +992,7 @@ extern "C" void QCALLTYPE MarshalNative_GetNativeVariantForObject(QCall::ObjectH END_QCALL; } -extern "C" void QCALLTYPE MarshalNative_GetObjectForNativeVariant(LPVOID pSrcNativeVariant, QCall::ObjectHandleOnStack retObject) +extern "C" void QCALLTYPE MarshalNative_GetObjectForNativeVariant(LPVOID pSrcNativeVariant, QCall::ObjectHandleOnStack retObject, QCallException* qcallError) { CONTRACTL { @@ -1015,7 +1015,7 @@ extern "C" void QCALLTYPE MarshalNative_GetObjectForNativeVariant(LPVOID pSrcNat } -extern "C" void QCALLTYPE MarshalNative_GetObjectsForNativeVariants(VARIANT* aSrcNativeVariant, int cVars, QCall::ObjectHandleOnStack retArray) +extern "C" void QCALLTYPE MarshalNative_GetObjectsForNativeVariants(VARIANT* aSrcNativeVariant, int cVars, QCall::ObjectHandleOnStack retArray, QCallException* qcallError) { CONTRACTL { @@ -1102,7 +1102,7 @@ static int GetComSlotInfo(MethodTable *pMT, MethodTable **ppDefItfMT) } } -extern "C" INT32 QCALLTYPE MarshalNative_GetStartComSlot(QCall::TypeHandle t) +extern "C" INT32 QCALLTYPE MarshalNative_GetStartComSlot(QCall::TypeHandle t, QCallException* qcallError) { QCALL_CONTRACT; @@ -1125,7 +1125,7 @@ extern "C" INT32 QCALLTYPE MarshalNative_GetStartComSlot(QCall::TypeHandle t) return retVal; } -extern "C" INT32 QCALLTYPE MarshalNative_GetEndComSlot(QCall::TypeHandle t) +extern "C" INT32 QCALLTYPE MarshalNative_GetEndComSlot(QCall::TypeHandle t, QCallException* qcallError) { QCALL_CONTRACT; @@ -1164,7 +1164,7 @@ extern "C" INT32 QCALLTYPE MarshalNative_GetEndComSlot(QCall::TypeHandle t) return retVal; } -extern "C" VOID QCALLTYPE MarshalNative_ChangeWrapperHandleStrength(QCall::ObjectHandleOnStack otp, BOOL fIsWeak) +extern "C" VOID QCALLTYPE MarshalNative_ChangeWrapperHandleStrength(QCall::ObjectHandleOnStack otp, BOOL fIsWeak, QCallException* qcallError) { QCALL_CONTRACT; @@ -1190,7 +1190,7 @@ extern "C" VOID QCALLTYPE MarshalNative_ChangeWrapperHandleStrength(QCall::Objec END_QCALL; } -extern "C" void QCALLTYPE MarshalNative_GetTypeFromCLSID(REFCLSID clsid, PCWSTR wszServer, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE MarshalNative_GetTypeFromCLSID(REFCLSID clsid, PCWSTR wszServer, QCall::ObjectHandleOnStack retType, QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/marshalnative.h b/src/coreclr/vm/marshalnative.h index aafcfadb161df8..94632ecfe0434f 100644 --- a/src/coreclr/vm/marshalnative.h +++ b/src/coreclr/vm/marshalnative.h @@ -37,122 +37,122 @@ class MarshalNative #endif // FEATURE_COMINTEROP }; -extern "C" SIZE_T QCALLTYPE MarshalNative_OffsetOf(FieldDesc* pFD); +extern "C" SIZE_T QCALLTYPE MarshalNative_OffsetOf(FieldDesc* pFD, QCallException* qcallError); -extern "C" VOID QCALLTYPE MarshalNative_Prelink(MethodDesc * pMD); -extern "C" BOOL QCALLTYPE MarshalNative_IsBuiltInComSupported(); +extern "C" VOID QCALLTYPE MarshalNative_Prelink(MethodDesc * pMD, QCallException* qcallError); +extern "C" BOOL QCALLTYPE MarshalNative_IsBuiltInComSupported(QCallException* qcallError); -extern "C" BOOL QCALLTYPE MarshalNative_HasLayout(QCall::TypeHandle t, BOOL* pIsBlittable, DWORD* pNativeSize); -extern "C" INT32 QCALLTYPE MarshalNative_SizeOfHelper(QCall::TypeHandle t, BOOL throwIfNotMarshalable); +extern "C" BOOL QCALLTYPE MarshalNative_HasLayout(QCall::TypeHandle t, BOOL* pIsBlittable, DWORD* pNativeSize, QCallException* qcallError); +extern "C" INT32 QCALLTYPE MarshalNative_SizeOfHelper(QCall::TypeHandle t, BOOL throwIfNotMarshalable, QCallException* qcallError); -extern "C" void QCALLTYPE MarshalNative_GetDelegateForFunctionPointerInternal(PVOID FPtr, QCall::TypeHandle t, QCall::ObjectHandleOnStack retDelegate); -extern "C" PVOID QCALLTYPE MarshalNative_GetFunctionPointerForDelegateInternal(QCall::ObjectHandleOnStack delegate); +extern "C" void QCALLTYPE MarshalNative_GetDelegateForFunctionPointerInternal(PVOID FPtr, QCall::TypeHandle t, QCall::ObjectHandleOnStack retDelegate, QCallException* qcallError); +extern "C" PVOID QCALLTYPE MarshalNative_GetFunctionPointerForDelegateInternal(QCall::ObjectHandleOnStack delegate, QCallException* qcallError); //==================================================================== // These methods convert between an HR and and a managed exception. //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetExceptionForHR(INT32 errorCode, LPVOID errorInfo, QCall::ObjectHandleOnStack obj); +extern "C" void QCALLTYPE MarshalNative_GetExceptionForHR(INT32 errorCode, LPVOID errorInfo, QCall::ObjectHandleOnStack obj, QCallException* qcallError); #ifdef FEATURE_COMINTEROP -extern "C" int32_t QCALLTYPE MarshalNative_GetHRForException(QCall::ObjectHandleOnStack obj); +extern "C" int32_t QCALLTYPE MarshalNative_GetHRForException(QCall::ObjectHandleOnStack obj, QCallException* qcallError); #endif // FEATURE_COMINTEROP -extern "C" OBJECTHANDLE QCALLTYPE GCHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack obj, int type); -extern "C" void QCALLTYPE GCHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle); +extern "C" OBJECTHANDLE QCALLTYPE GCHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack obj, int type, QCallException* qcallError); +extern "C" void QCALLTYPE GCHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle, QCallException* qcallError); #ifdef FEATURE_JAVAMARSHAL -extern "C" void QCALLTYPE GCHandle_InternalGetBridgeWait(OBJECTHANDLE handle, QCall::ObjectHandleOnStack result); +extern "C" void QCALLTYPE GCHandle_InternalGetBridgeWait(OBJECTHANDLE handle, QCall::ObjectHandleOnStack result, QCallException* qcallError); #endif #ifdef _DEBUG using IsInCooperativeGCMode_fn = BOOL(STDMETHODCALLTYPE*)(void); -extern "C" IsInCooperativeGCMode_fn QCALLTYPE MarshalNative_GetIsInCooperativeGCModeFunctionPointer(); +extern "C" IsInCooperativeGCMode_fn QCALLTYPE MarshalNative_GetIsInCooperativeGCModeFunctionPointer(QCallException* qcallError); #endif #ifdef FEATURE_COMINTEROP //==================================================================== // Create type for given CLSID. //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetTypeFromCLSID(REFCLSID clsid, PCWSTR wszServer, QCall::ObjectHandleOnStack retType); +extern "C" void QCALLTYPE MarshalNative_GetTypeFromCLSID(REFCLSID clsid, PCWSTR wszServer, QCall::ObjectHandleOnStack retType, QCallException* qcallError); //==================================================================== // return the IUnknown* for an Object //==================================================================== -extern "C" IUnknown* QCALLTYPE MarshalNative_GetIUnknownForObject(QCall::ObjectHandleOnStack o); +extern "C" IUnknown* QCALLTYPE MarshalNative_GetIUnknownForObject(QCall::ObjectHandleOnStack o, QCallException* qcallError); //==================================================================== // return the IDispatch* for an Object //==================================================================== -extern "C" IDispatch* QCALLTYPE MarshalNative_GetIDispatchForObject(QCall::ObjectHandleOnStack o); +extern "C" IDispatch* QCALLTYPE MarshalNative_GetIDispatchForObject(QCall::ObjectHandleOnStack o, QCallException* qcallError); //==================================================================== // return the IUnknown* or IDispatch* for an Object. //==================================================================== -extern "C" void* QCALLTYPE MarshalNative_GetIUnknownOrIDispatchForObject(QCall::ObjectHandleOnStack o, BOOL* isIDispatch); +extern "C" void* QCALLTYPE MarshalNative_GetIUnknownOrIDispatchForObject(QCall::ObjectHandleOnStack o, BOOL* isIDispatch, QCallException* qcallError); //==================================================================== // return the IUnknown* representing the interface for the Object // Object o should support Type T //==================================================================== -extern "C" IUnknown* QCALLTYPE MarshalNative_GetComInterfaceForObject(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, BOOL bEnableCustomizedQueryInterface); +extern "C" IUnknown* QCALLTYPE MarshalNative_GetComInterfaceForObject(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, BOOL bEnableCustomizedQueryInterface, QCallException* qcallError); //==================================================================== // return an Object for IUnknown //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject); +extern "C" void QCALLTYPE MarshalNative_GetObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject, QCallException* qcallError); //==================================================================== // return a unique cacheless Object for IUnknown //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetUniqueObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject); +extern "C" void QCALLTYPE MarshalNative_GetUniqueObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject, QCallException* qcallError); //==================================================================== // return an Object for IUnknown, using the Type T, // NOTE: // Type T should be either a COM imported Type or a sub-type of COM imported Type //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetTypedObjectForIUnknown(IUnknown* pUnk, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject); +extern "C" void QCALLTYPE MarshalNative_GetTypedObjectForIUnknown(IUnknown* pUnk, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject, QCallException* qcallError); //==================================================================== // Create an object and aggregate it, then return the inner unknown. //==================================================================== -extern "C" IUnknown* QCALLTYPE MarshalNative_CreateAggregatedObject(IUnknown* pOuter, QCall::ObjectHandleOnStack o); +extern "C" IUnknown* QCALLTYPE MarshalNative_CreateAggregatedObject(IUnknown* pOuter, QCall::ObjectHandleOnStack o, QCallException* qcallError); //==================================================================== // Free unused RCWs in the current CLR context. //==================================================================== -extern "C" void QCALLTYPE MarshalNative_CleanupUnusedObjectsInCurrentContext(); +extern "C" void QCALLTYPE MarshalNative_CleanupUnusedObjectsInCurrentContext(QCallException* qcallError); //==================================================================== // free the COM component and zombie this object // further usage of this Object might throw an exception, //==================================================================== -extern "C" INT32 QCALLTYPE MarshalNative_ReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE); -extern "C" void QCALLTYPE MarshalNative_FinalReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE); +extern "C" INT32 QCALLTYPE MarshalNative_ReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, QCallException* qcallError); +extern "C" void QCALLTYPE MarshalNative_FinalReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, QCallException* qcallError); //==================================================================== // This method takes the given COM object and wraps it in an object // of the specified type. The type must be derived from __ComObject. //==================================================================== -extern "C" void QCALLTYPE MarshalNative_InternalCreateWrapperOfType(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject); +extern "C" void QCALLTYPE MarshalNative_InternalCreateWrapperOfType(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject, QCallException* qcallError); //==================================================================== // check if the type is visible from COM. //==================================================================== -extern "C" BOOL QCALLTYPE MarshalNative_IsTypeVisibleFromCom(QCall::TypeHandle t); +extern "C" BOOL QCALLTYPE MarshalNative_IsTypeVisibleFromCom(QCall::TypeHandle t, QCallException* qcallError); //==================================================================== // These methods convert OLE variants to and from objects. //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetNativeVariantForObject(QCall::ObjectHandleOnStack ObjUNSAFE, LPVOID pDestNativeVariant); -extern "C" void QCALLTYPE MarshalNative_GetObjectForNativeVariant(LPVOID pSrcNativeVariant, QCall::ObjectHandleOnStack retObject); -extern "C" void QCALLTYPE MarshalNative_GetObjectsForNativeVariants(VARIANT* aSrcNativeVariant, int cVars, QCall::ObjectHandleOnStack retArray); +extern "C" void QCALLTYPE MarshalNative_GetNativeVariantForObject(QCall::ObjectHandleOnStack ObjUNSAFE, LPVOID pDestNativeVariant, QCallException* qcallError); +extern "C" void QCALLTYPE MarshalNative_GetObjectForNativeVariant(LPVOID pSrcNativeVariant, QCall::ObjectHandleOnStack retObject, QCallException* qcallError); +extern "C" void QCALLTYPE MarshalNative_GetObjectsForNativeVariants(VARIANT* aSrcNativeVariant, int cVars, QCall::ObjectHandleOnStack retArray, QCallException* qcallError); //==================================================================== // These methods are used to map COM slots to method info's. //==================================================================== -extern "C" INT32 QCALLTYPE MarshalNative_GetStartComSlot(QCall::TypeHandle t); -extern "C" INT32 QCALLTYPE MarshalNative_GetEndComSlot(QCall::TypeHandle t); +extern "C" INT32 QCALLTYPE MarshalNative_GetStartComSlot(QCall::TypeHandle t, QCallException* qcallError); +extern "C" INT32 QCALLTYPE MarshalNative_GetEndComSlot(QCall::TypeHandle t, QCallException* qcallError); -extern "C" VOID QCALLTYPE MarshalNative_ChangeWrapperHandleStrength(QCall::ObjectHandleOnStack otp, BOOL fIsWeak); +extern "C" VOID QCALLTYPE MarshalNative_ChangeWrapperHandleStrength(QCall::ObjectHandleOnStack otp, BOOL fIsWeak, QCallException* qcallError); #endif // FEATURE_COMINTEROP #endif diff --git a/src/coreclr/vm/method.hpp b/src/coreclr/vm/method.hpp index fd6ddd35ca4c39..869e5f3ceddad9 100644 --- a/src/coreclr/vm/method.hpp +++ b/src/coreclr/vm/method.hpp @@ -2399,7 +2399,7 @@ class MethodDesc }; #ifndef DACCESS_COMPILE -extern "C" void* QCALLTYPE UnsafeAccessors_ResolveGenericParamToTypeHandle(MethodDesc* unsafeAccessorMethod, BOOL isMethodParam, DWORD paramIndex); +extern "C" void* QCALLTYPE UnsafeAccessors_ResolveGenericParamToTypeHandle(MethodDesc* unsafeAccessorMethod, BOOL isMethodParam, DWORD paramIndex, QCallException* qcallError); #endif // DACCESS_COMPILE template<> struct cdac_data diff --git a/src/coreclr/vm/mlinfo.cpp b/src/coreclr/vm/mlinfo.cpp index eb95219367193d..44c9c8e305e243 100644 --- a/src/coreclr/vm/mlinfo.cpp +++ b/src/coreclr/vm/mlinfo.cpp @@ -3585,7 +3585,7 @@ bool IsUnsupportedTypedrefReturn(MetaSig& msig) #include "stubhelpers.h" -extern "C" void QCALLTYPE StubHelpers_CreateCustomMarshaler(MethodDesc* pMD, mdToken paramToken, TypeHandle hndManagedType, QCall::ObjectHandleOnStack retObject) +extern "C" void QCALLTYPE StubHelpers_CreateCustomMarshaler(MethodDesc* pMD, mdToken paramToken, TypeHandle hndManagedType, QCall::ObjectHandleOnStack retObject, QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/multicorejit.cpp b/src/coreclr/vm/multicorejit.cpp index 9e828f69512741..1c93fbacee23f0 100644 --- a/src/coreclr/vm/multicorejit.cpp +++ b/src/coreclr/vm/multicorejit.cpp @@ -1548,7 +1548,7 @@ DWORD MulticoreJitManager::EncodeModuleHelper(void * pModuleContext, Module * pR // wszProfile - profile name // ptrNativeAssemblyBinder - the binding context // -extern "C" void QCALLTYPE MultiCoreJIT_InternalStartProfile(_In_z_ LPCWSTR wszProfile, INT_PTR ptrNativeAssemblyBinder) +extern "C" void QCALLTYPE MultiCoreJIT_InternalStartProfile(_In_z_ LPCWSTR wszProfile, INT_PTR ptrNativeAssemblyBinder, QCallException* qcallError) { QCALL_CONTRACT; @@ -1567,7 +1567,7 @@ extern "C" void QCALLTYPE MultiCoreJIT_InternalStartProfile(_In_z_ LPCWSTR wszPr } -extern "C" void QCALLTYPE MultiCoreJIT_InternalSetProfileRoot(_In_z_ LPCWSTR wszProfilePath) +extern "C" void QCALLTYPE MultiCoreJIT_InternalSetProfileRoot(_In_z_ LPCWSTR wszProfilePath, QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/multicorejit.h b/src/coreclr/vm/multicorejit.h index 37eea5782156c6..199ba19ab7725b 100644 --- a/src/coreclr/vm/multicorejit.h +++ b/src/coreclr/vm/multicorejit.h @@ -315,7 +315,7 @@ class MulticoreJitManager // For qcallentrypoints.cpp -extern "C" void QCALLTYPE MultiCoreJIT_InternalSetProfileRoot(_In_z_ LPCWSTR directoryPath); -extern "C" void QCALLTYPE MultiCoreJIT_InternalStartProfile(_In_z_ LPCWSTR wszProfile, INT_PTR ptrNativeAssemblyBinder); +extern "C" void QCALLTYPE MultiCoreJIT_InternalSetProfileRoot(_In_z_ LPCWSTR directoryPath, QCallException* qcallError); +extern "C" void QCALLTYPE MultiCoreJIT_InternalStartProfile(_In_z_ LPCWSTR wszProfile, INT_PTR ptrNativeAssemblyBinder, QCallException* qcallError); #endif // __MULTICORE_JIT_H__ diff --git a/src/coreclr/vm/nativeeventsource.cpp b/src/coreclr/vm/nativeeventsource.cpp index e421343e8533a8..14796c32419816 100644 --- a/src/coreclr/vm/nativeeventsource.cpp +++ b/src/coreclr/vm/nativeeventsource.cpp @@ -13,7 +13,7 @@ #if defined(FEATURE_EVENTSOURCE_XPLAT) -extern "C" void QCALLTYPE LogEventSource(_In_z_ int eventID, _In_z_ LPCWSTR eventName, _In_z_ LPCWSTR eventSourceName, _In_z_ LPCWSTR payload) +extern "C" void QCALLTYPE LogEventSource(_In_z_ int eventID, _In_z_ LPCWSTR eventName, _In_z_ LPCWSTR eventSourceName, _In_z_ LPCWSTR payload, QCallException* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -21,7 +21,7 @@ extern "C" void QCALLTYPE LogEventSource(_In_z_ int eventID, _In_z_ LPCWSTR even END_QCALL; } -extern "C" BOOL QCALLTYPE IsEventSourceLoggingEnabled() +extern "C" BOOL QCALLTYPE IsEventSourceLoggingEnabled(QCallException* qcallError) { QCALL_CONTRACT; @@ -34,7 +34,7 @@ extern "C" BOOL QCALLTYPE IsEventSourceLoggingEnabled() return retVal; } -extern "C" LPWSTR QCALLTYPE EventSource_GetClrConfig(LPCWSTR configName) +extern "C" LPWSTR QCALLTYPE EventSource_GetClrConfig(LPCWSTR configName, QCallException* qcallError) { QCALL_CONTRACT; @@ -60,7 +60,7 @@ extern "C" LPWSTR QCALLTYPE EventSource_GetClrConfig(LPCWSTR configName) // change genRuntimeEventSources.py script to not emit the body that throws NotImplementedException for the event that // want to be fired from managed code. // See https://github.com/dotnet/runtime/pull/47829 for an example of how to do this. -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStart(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStart(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallException* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -70,7 +70,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStar END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallException* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -80,7 +80,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallException* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -90,7 +90,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolMinMaxThreads(_In_z_ short minWorkerThreads, _In_z_ short maxWorkerThreads, _In_z_ short minIOCompletionThreads, _In_z_ short maxIOCompletionThreads, _In_z_ short clrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolMinMaxThreads(_In_z_ short minWorkerThreads, _In_z_ short maxWorkerThreads, _In_z_ short minIOCompletionThreads, _In_z_ short maxIOCompletionThreads, _In_z_ short clrInstanceID, QCallException* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -100,7 +100,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolMinMaxThreads(_I END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentSample(_In_z_ double throughput, _In_z_ short clrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentSample(_In_z_ double throughput, _In_z_ short clrInstanceID, QCallException* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -110,7 +110,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdju END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentAdjustment(_In_z_ double averageThroughput, _In_z_ uint newWorkerThreadCount, _In_z_ uint reason, _In_z_ short clrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentAdjustment(_In_z_ double averageThroughput, _In_z_ uint newWorkerThreadCount, _In_z_ uint reason, _In_z_ short clrInstanceID, QCallException* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -120,7 +120,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdju END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentStats(_In_z_ double duration, _In_z_ double throughput, _In_z_ double threadWave, _In_z_ double throughputWave, _In_z_ double throughputErrorEstimate, _In_z_ double AverageThroughputErrorEstimate, _In_z_ double ThroughputRatio, _In_z_ double confidence, _In_z_ double newControlSetting, _In_z_ short newThreadWaveMagnitude, _In_z_ short ClrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentStats(_In_z_ double duration, _In_z_ double throughput, _In_z_ double threadWave, _In_z_ double throughputWave, _In_z_ double throughputErrorEstimate, _In_z_ double AverageThroughputErrorEstimate, _In_z_ double ThroughputRatio, _In_z_ double confidence, _In_z_ double newControlSetting, _In_z_ short newThreadWaveMagnitude, _In_z_ short ClrInstanceID, QCallException* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -130,7 +130,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdju END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOEnqueue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ bool multiDequeues, _In_z_ short ClrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOEnqueue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ bool multiDequeues, _In_z_ short ClrInstanceID, QCallException* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -140,7 +140,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOEnqueue(_In_z_ END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIODequeue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIODequeue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID, QCallException* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -150,7 +150,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIODequeue(_In_z_ END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkingThreadCount(_In_z_ uint count, _In_z_ short ClrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkingThreadCount(_In_z_ uint count, _In_z_ short ClrInstanceID, QCallException* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -160,7 +160,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkingThreadCou END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOPack(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOPack(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID, QCallException* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -170,7 +170,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOPack(_In_z_ vo END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionLockCreated(void* LockID, void* AssociatedObjectID, uint16_t ClrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionLockCreated(void* LockID, void* AssociatedObjectID, uint16_t ClrInstanceID, QCallException* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -185,7 +185,8 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStart( uint16_t ClrInstanceID, void* LockID, void* AssociatedObjectID, - uint64_t LockOwnerThreadID) + uint64_t LockOwnerThreadID, + QCallException* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -195,7 +196,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStart( END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStop(uint8_t ContentionFlags, uint16_t ClrInstanceID, double DurationNs) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStop(uint8_t ContentionFlags, uint16_t ClrInstanceID, double DurationNs, QCallException* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -205,7 +206,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStop(uint8_t Con END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStart(uint8_t WaitSource, intptr_t AssociatedObjectID, uint16_t ClrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStart(uint8_t WaitSource, intptr_t AssociatedObjectID, uint16_t ClrInstanceID, QCallException* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -215,7 +216,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStart(uint8_ END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStop(uint16_t ClrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStop(uint16_t ClrInstanceID, QCallException* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; diff --git a/src/coreclr/vm/nativeeventsource.h b/src/coreclr/vm/nativeeventsource.h index 9a457cfff9130b..8fc0d5e9b4819b 100644 --- a/src/coreclr/vm/nativeeventsource.h +++ b/src/coreclr/vm/nativeeventsource.h @@ -15,28 +15,28 @@ #include "qcall.h" #if defined(FEATURE_EVENTSOURCE_XPLAT) -extern "C" void QCALLTYPE LogEventSource(_In_z_ int eventID, _In_z_ LPCWSTR eventName, _In_z_ LPCWSTR eventSourceName, _In_z_ LPCWSTR payload); -extern "C" BOOL QCALLTYPE IsEventSourceLoggingEnabled(); -extern "C" LPWSTR QCALLTYPE EventSource_GetClrConfig(LPCWSTR configName); +extern "C" void QCALLTYPE LogEventSource(_In_z_ int eventID, _In_z_ LPCWSTR eventName, _In_z_ LPCWSTR eventSourceName, _In_z_ LPCWSTR payload, QCallException* qcallError); +extern "C" BOOL QCALLTYPE IsEventSourceLoggingEnabled(QCallException* qcallError); +extern "C" LPWSTR QCALLTYPE EventSource_GetClrConfig(LPCWSTR configName, QCallException* qcallError); #endif //defined(FEATURE_EVENTSOURCE_XPLAT) #if defined(FEATURE_PERFTRACING) -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStart(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolMinMaxThreads(_In_z_ short minWorkerThreads, _In_z_ short maxWorkerThreads, _In_z_ short minIOCompletionThreads, _In_z_ short maxIOCompletionThreads, _In_z_ short clrInstanceID); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentSample(_In_z_ double throughput, _In_z_ short clrInstanceID); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentAdjustment(_In_z_ double averageThroughput, _In_z_ uint newWorkerThreadCount, _In_z_ uint reason, _In_z_ short clrInstanceID); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentStats(_In_z_ double duration, _In_z_ double throughput, _In_z_ double threadWave, _In_z_ double throughputWave, _In_z_ double throughputErrorEstimate, _In_z_ double AverageThroughputErrorEstimate, _In_z_ double ThroughputRatio, _In_z_ double confidence, _In_z_ double newControlSetting, _In_z_ short newThreadWaveMagnitude, _In_z_ short ClrInstanceID); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOEnqueue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ bool multiDequeues, _In_z_ short ClrInstanceID); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIODequeue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkingThreadCount(_In_z_ uint count, _In_z_ short ClrInstanceID); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOPack(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionLockCreated(void* LockID, void* AssociatedObjectID, uint16_t ClrInstanceID); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStart(uint8_t ContentionFlags, uint16_t ClrInstanceID, void* LockID, void* AssociatedObjectID, uint64_t LockOwnerThreadID); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStop(uint8_t ContentionFlags, uint16_t ClrInstanceID, double DurationNs); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStart(uint8_t WaitSource, intptr_t AssociatedObjectID, uint16_t ClrInstanceID); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStop(uint16_t ClrInstanceID); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStart(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallException* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallException* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallException* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolMinMaxThreads(_In_z_ short minWorkerThreads, _In_z_ short maxWorkerThreads, _In_z_ short minIOCompletionThreads, _In_z_ short maxIOCompletionThreads, _In_z_ short clrInstanceID, QCallException* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentSample(_In_z_ double throughput, _In_z_ short clrInstanceID, QCallException* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentAdjustment(_In_z_ double averageThroughput, _In_z_ uint newWorkerThreadCount, _In_z_ uint reason, _In_z_ short clrInstanceID, QCallException* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentStats(_In_z_ double duration, _In_z_ double throughput, _In_z_ double threadWave, _In_z_ double throughputWave, _In_z_ double throughputErrorEstimate, _In_z_ double AverageThroughputErrorEstimate, _In_z_ double ThroughputRatio, _In_z_ double confidence, _In_z_ double newControlSetting, _In_z_ short newThreadWaveMagnitude, _In_z_ short ClrInstanceID, QCallException* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOEnqueue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ bool multiDequeues, _In_z_ short ClrInstanceID, QCallException* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIODequeue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID, QCallException* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkingThreadCount(_In_z_ uint count, _In_z_ short ClrInstanceID, QCallException* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOPack(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID, QCallException* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionLockCreated(void* LockID, void* AssociatedObjectID, uint16_t ClrInstanceID, QCallException* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStart(uint8_t ContentionFlags, uint16_t ClrInstanceID, void* LockID, void* AssociatedObjectID, uint64_t LockOwnerThreadID, QCallException* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStop(uint8_t ContentionFlags, uint16_t ClrInstanceID, double DurationNs, QCallException* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStart(uint8_t WaitSource, intptr_t AssociatedObjectID, uint16_t ClrInstanceID, QCallException* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStop(uint16_t ClrInstanceID, QCallException* qcallError); #endif // defined(FEATURE_PERFTRACING) diff --git a/src/coreclr/vm/nativelibrarynative.cpp b/src/coreclr/vm/nativelibrarynative.cpp index 7a8af3c489ecb2..baa35600dc7887 100644 --- a/src/coreclr/vm/nativelibrarynative.cpp +++ b/src/coreclr/vm/nativelibrarynative.cpp @@ -11,7 +11,8 @@ // static extern "C" INT_PTR QCALLTYPE NativeLibrary_LoadByName(LPCWSTR name, QCall::AssemblyHandle callingAssembly, BOOL hasDllImportSearchPathFlag, DWORD dllImportSearchPathFlag, - BOOL throwOnError) + BOOL throwOnError, + QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/nativelibrarynative.h b/src/coreclr/vm/nativelibrarynative.h index d78cfdcedafef6..d4f6c09231144f 100644 --- a/src/coreclr/vm/nativelibrarynative.h +++ b/src/coreclr/vm/nativelibrarynative.h @@ -12,6 +12,7 @@ extern "C" INT_PTR QCALLTYPE NativeLibrary_LoadByName(LPCWSTR name, QCall::AssemblyHandle callingAssembly, BOOL hasDllImportSearchPathFlag, DWORD dllImportSearchPathFlag, - BOOL throwOnError); + BOOL throwOnError, + QCallException* qcallError); #endif // __NATIVELIBRARYNATIVE_H__ diff --git a/src/coreclr/vm/object.h b/src/coreclr/vm/object.h index a9710bb168cf94..9477bdcec90b5f 100644 --- a/src/coreclr/vm/object.h +++ b/src/coreclr/vm/object.h @@ -1185,6 +1185,7 @@ class ThreadBaseObject : public Object OBJECTREF m_SynchronizationContext; STRINGREF m_Name; OBJECTREF m_StartHelper; + OBJECTREF m_QCallException; #ifdef TARGET_UNIX OBJECTREF m_WaitInfo; OBJECTREF m_joinEvent; @@ -1224,6 +1225,15 @@ class ThreadBaseObject : public Object void SetInternal(Thread *it); void ClearInternal(); + void SetQCallException(OBJECTREF throwable) + { + LIMITED_METHOD_CONTRACT; + + _ASSERTE(throwable != NULL); + _ASSERTE(m_QCallException == NULL); + SetObjectReference(&m_QCallException, throwable); + } + void SetManagedThreadId(INT32 id) { LIMITED_METHOD_CONTRACT; diff --git a/src/coreclr/vm/olevariant.cpp b/src/coreclr/vm/olevariant.cpp index 1dcdedb59a32e8..89e8e243235cc8 100644 --- a/src/coreclr/vm/olevariant.cpp +++ b/src/coreclr/vm/olevariant.cpp @@ -2666,7 +2666,7 @@ BSTR OleVariant::ConvertStringToBSTR(STRINGREF *pStringObj) return result; } -extern "C" void QCALLTYPE Variant_ConvertValueTypeToRecord(QCall::ObjectHandleOnStack obj, VARIANT * pOle) +extern "C" void QCALLTYPE Variant_ConvertValueTypeToRecord(QCall::ObjectHandleOnStack obj, VARIANT * pOle, QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/olevariant.h b/src/coreclr/vm/olevariant.h index a3dd84ab287a88..3ff901c5029daa 100644 --- a/src/coreclr/vm/olevariant.h +++ b/src/coreclr/vm/olevariant.h @@ -107,6 +107,6 @@ class OleVariant // SAFEARRAY VARTYPE and element MethodTable. MethodDesc* GetInstantiatedSafeArrayMethod(BinderMethodID methodId, VARTYPE vt, MethodTable* pElementMT, BOOL bHeterogeneous, BOOL bNativeDataValid = FALSE); -extern "C" void QCALLTYPE Variant_ConvertValueTypeToRecord(QCall::ObjectHandleOnStack obj, VARIANT* pOle); +extern "C" void QCALLTYPE Variant_ConvertValueTypeToRecord(QCall::ObjectHandleOnStack obj, VARIANT* pOle, QCallException* qcallError); #endif diff --git a/src/coreclr/vm/qcall.cpp b/src/coreclr/vm/qcall.cpp index 3267608da3c0cc..df32f9116db477 100644 --- a/src/coreclr/vm/qcall.cpp +++ b/src/coreclr/vm/qcall.cpp @@ -11,7 +11,14 @@ void QCallException::SetThrowable(OBJECTREF throwable) { LIMITED_METHOD_CONTRACT; - SetObjectReference(m_throwable, throwable); + _ASSERTE(throwable != NULL); + _ASSERTE(m_exceptionPending == 0 || m_exceptionPending == 1); + _ASSERTE(m_exceptionPending == 0); + + THREADBASEREF thread = (THREADBASEREF)GetThread()->GetExposedObjectRaw(); + _ASSERTE(thread != NULL); + thread->SetQCallException(throwable); + VolatileStore(&m_exceptionPending, 1); } // diff --git a/src/coreclr/vm/qcall.h b/src/coreclr/vm/qcall.h index 96d59421ae50dc..68340638ee6086 100644 --- a/src/coreclr/vm/qcall.h +++ b/src/coreclr/vm/qcall.h @@ -36,12 +36,12 @@ // QCall example - managed part (do not replicate the comments into your actual QCall implementation): // --------------------------------------------------------------------------------------------------- // -// class Foo { +// class Foo +// { // -// // All QCalls should have the following DllImport and SuppressUnmanagedCodeSecurity attributes -// [DllImport(JitHelpers.QCall, EntryPoint = "FooNative_Bar", CharSet = CharSet.Unicode)] -// // QCalls should always be static extern. -// private static extern bool Bar(int flags, string inString, StringHandleOnStack retString); +// // All QCalls that use BEGIN_QCALL must have a final QCallException out parameter. +// [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "FooNative_Bar", StringMarshalling = StringMarshalling.Utf16)] +// private static partial bool Bar(int flags, string inString, StringHandleOnStack retString, out QCallException qcallException); // // // Many QCalls have a thin managed wrapper around them to expose them to the world in more meaningful way. // public string Bar(int flags) @@ -50,7 +50,7 @@ // // // The strings are returned from QCalls by taking address // // of a local variable using JitHelpers.GetStringHandleOnStack method -// if (!Bar(flags, this.Id, JitHelpers.GetStringHandleOnStack(ref retString))) +// if (!Bar(flags, this.Id, StringHandleOnStack.Create(ref retString), out _)) // FatalError(); // // return retString; @@ -65,7 +65,7 @@ // The entrypoints of all QCalls has to be registered in tables in vm\qcallentrypoints.cpp using the DllImportEntry macro, // For example: DllImportEntry(FooNative_Bar) // -// extern "C" BOOL QCALLTYPE FooNative_Bar(int flags, LPCWSTR wszString, QCall::StringHandleOnStack retString) +// extern "C" BOOL QCALLTYPE FooNative_Bar(int flags, LPCWSTR wszString, QCall::StringHandleOnStack retString, QCallException* qcallError) // { // // All QCalls should have QCALL_CONTRACT. It is alias for THROWS; GC_TRIGGERS; MODE_PREEMPTIVE. // QCALL_CONTRACT; @@ -111,12 +111,10 @@ #define BEGIN_QCALL \ INSTALL_RESUME_AFTER_CATCH_HANDLER_WITH_FRAME(GetThread()->GetFrame()) \ - INSTALL_MANAGED_EXCEPTION_DISPATCHER \ - INSTALL_UNWIND_AND_CONTINUE_HANDLER + INSTALL_MANAGED_EXCEPTION_CAPTURE_DISPATCHER #define END_QCALL \ - UNINSTALL_UNWIND_AND_CONTINUE_HANDLER \ - UNINSTALL_MANAGED_EXCEPTION_DISPATCHER \ + UNINSTALL_MANAGED_EXCEPTION_CAPTURE_DISPATCHER \ UNINSTALL_RESUME_AFTER_CATCH_HANDLER_WITH_FRAME #define QCALL_CHECK \ diff --git a/src/coreclr/vm/qcallentrypoints.cpp b/src/coreclr/vm/qcallentrypoints.cpp index 41e7624c50466f..f6e706ff9a15e9 100644 --- a/src/coreclr/vm/qcallentrypoints.cpp +++ b/src/coreclr/vm/qcallentrypoints.cpp @@ -317,6 +317,7 @@ static const Entry s_QCall[] = DllImportEntry(ThreadNative_Abort) DllImportEntry(ThreadNative_ResetAbort) DllImportEntry(ThreadNative_SpinWait) + DllImportEntry(ThreadNative_LongSpinWait) #ifdef TARGET_WINDOWS DllImportEntry(ThreadNative_CheckForPendingInterrupt) DllImportEntry(ThreadNative_Interrupt) diff --git a/src/coreclr/vm/reflectioninvocation.cpp b/src/coreclr/vm/reflectioninvocation.cpp index 138ebca1576c1a..28c5378e39eba7 100644 --- a/src/coreclr/vm/reflectioninvocation.cpp +++ b/src/coreclr/vm/reflectioninvocation.cpp @@ -27,7 +27,7 @@ #include "interpexec.h" -extern "C" void QCALLTYPE RuntimeFieldHandle_GetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized, QCall::ObjectHandleOnStack result) +extern "C" void QCALLTYPE RuntimeFieldHandle_GetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized, QCall::ObjectHandleOnStack result, QCallException* qcallError) { QCALL_CONTRACT; @@ -45,7 +45,7 @@ extern "C" void QCALLTYPE RuntimeFieldHandle_GetValue(FieldDesc* fieldDesc, QCal END_QCALL; } -extern "C" void QCALLTYPE RuntimeFieldHandle_SetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::ObjectHandleOnStack value, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized) +extern "C" void QCALLTYPE RuntimeFieldHandle_SetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::ObjectHandleOnStack value, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized, QCallException* qcallError) { QCALL_CONTRACT; @@ -73,7 +73,8 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_CreateInstanceForAnotherGenericParam QCall::TypeHandle pTypeHandle, TypeHandle* pInstArray, INT32 cInstArray, - QCall::ObjectHandleOnStack pInstantiatedObject + QCall::ObjectHandleOnStack pInstantiatedObject, + QCallException* qcallError ) { CONTRACTL @@ -118,7 +119,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_CreateInstanceForAnotherGenericParam END_QCALL; } -extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAlloc(MethodTable* pMT, QCall::ObjectHandleOnStack allocated) +extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAlloc(MethodTable* pMT, QCall::ObjectHandleOnStack allocated, QCallException* qcallError) { QCALL_CONTRACT; @@ -133,7 +134,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAlloc(MethodTable* pMT, QCal END_QCALL; } -extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAllocNoChecks(MethodTable* pMT, QCall::ObjectHandleOnStack allocated) +extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAllocNoChecks(MethodTable* pMT, QCall::ObjectHandleOnStack allocated, QCallException* qcallError) { QCALL_CONTRACT; @@ -329,7 +330,8 @@ extern "C" void QCALLTYPE RuntimeMethodHandle_InvokeMethod( PVOID* args, // An array of byrefs QCall::ObjectHandleOnStack pSig, BOOL fConstructor, - QCall::ObjectHandleOnStack result) + QCall::ObjectHandleOnStack result, + QCallException* qcallError) { QCALL_CONTRACT; @@ -792,7 +794,7 @@ static StackWalkAction SkipMethods(CrawlFrame* frame, VOID* data) { } // Return the MethodInfo that represents the current method (two above this one) -extern "C" MethodDesc* QCALLTYPE MethodBase_GetCurrentMethod(QCall::StackCrawlMarkHandle stackMark) { +extern "C" MethodDesc* QCALLTYPE MethodBase_GetCurrentMethod(QCall::StackCrawlMarkHandle stackMark, QCallException* qcallError) { QCALL_CONTRACT; @@ -841,7 +843,7 @@ static OBJECTREF DirectObjectFieldGet(FieldDesc *pField, TypeHandle fieldType, T return refRet; } -extern "C" void QCALLTYPE RuntimeFieldHandle_GetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack result) +extern "C" void QCALLTYPE RuntimeFieldHandle_GetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack result, QCallException* qcallError) { QCALL_CONTRACT; @@ -946,7 +948,7 @@ static void DirectObjectFieldSet(FieldDesc *pField, TypeHandle fieldType, TypeHa GCPROTECT_END(); } -extern "C" void QCALLTYPE RuntimeFieldHandle_SetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::ObjectHandleOnStack newValue, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringType) +extern "C" void QCALLTYPE RuntimeFieldHandle_SetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::ObjectHandleOnStack newValue, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringType, QCallException* qcallError) { QCALL_CONTRACT; @@ -1190,7 +1192,7 @@ FCIMPLEND // Returns the address of the EnC instance field in the object (This is an interior // pointer and the caller has to use it appropriately) or an EnC static field. -extern "C" void* QCALLTYPE RuntimeFieldHandle_GetEnCFieldAddr(QCall::ObjectHandleOnStack target, FieldDesc* pFD) +extern "C" void* QCALLTYPE RuntimeFieldHandle_GetEnCFieldAddr(QCall::ObjectHandleOnStack target, FieldDesc* pFD, QCallException* qcallError) { CONTRACTL { @@ -1217,7 +1219,7 @@ extern "C" void* QCALLTYPE RuntimeFieldHandle_GetEnCFieldAddr(QCall::ObjectHandl return ret; } -extern "C" BOOL QCALLTYPE RuntimeFieldHandle_GetRVAFieldInfo(FieldDesc* pField, void** address, UINT* size) +extern "C" BOOL QCALLTYPE RuntimeFieldHandle_GetRVAFieldInfo(FieldDesc* pField, void** address, UINT* size, QCallException* qcallError) { QCALL_CONTRACT; @@ -1237,7 +1239,7 @@ extern "C" BOOL QCALLTYPE RuntimeFieldHandle_GetRVAFieldInfo(FieldDesc* pField, return ret; } -extern "C" void QCALLTYPE RuntimeFieldHandle_GetFieldDataReference(FieldDesc* pField, QCall::ObjectHandleOnStack instance, QCall::ByteRefOnStack fieldDataRef) +extern "C" void QCALLTYPE RuntimeFieldHandle_GetFieldDataReference(FieldDesc* pField, QCall::ObjectHandleOnStack instance, QCall::ByteRefOnStack fieldDataRef, QCallException* qcallError) { CONTRACTL { @@ -1256,7 +1258,7 @@ extern "C" void QCALLTYPE RuntimeFieldHandle_GetFieldDataReference(FieldDesc* pF END_QCALL; } -extern "C" void QCALLTYPE ReflectionInvocation_CompileMethod(MethodDesc * pMD) +extern "C" void QCALLTYPE ReflectionInvocation_CompileMethod(MethodDesc * pMD, QCallException* qcallError) { QCALL_CONTRACT; @@ -1272,7 +1274,7 @@ extern "C" void QCALLTYPE ReflectionInvocation_CompileMethod(MethodDesc * pMD) } // This method triggers the class constructor for a give type -extern "C" void QCALLTYPE ReflectionInvocation_RunClassConstructor(QCall::TypeHandle pType) +extern "C" void QCALLTYPE ReflectionInvocation_RunClassConstructor(QCall::TypeHandle pType, QCallException* qcallError) { QCALL_CONTRACT; @@ -1293,7 +1295,7 @@ extern "C" void QCALLTYPE ReflectionInvocation_RunClassConstructor(QCall::TypeHa } // This method triggers the module constructor for a given module -extern "C" void QCALLTYPE ReflectionInvocation_RunModuleConstructor(QCall::ModuleHandle pModule) +extern "C" void QCALLTYPE ReflectionInvocation_RunModuleConstructor(QCall::ModuleHandle pModule, QCallException* qcallError) { QCALL_CONTRACT; @@ -1339,7 +1341,7 @@ static void PrepareMethodHelper(MethodDesc * pMD) // This method triggers a given method to be jitted. CoreCLR implementation of this method triggers jiting of the given method only. // It does not walk a subset of callgraph to provide CER guarantees. -extern "C" void QCALLTYPE ReflectionInvocation_PrepareMethod(MethodDesc *pMD, TypeHandle *pInstantiation, UINT32 cInstantiation) +extern "C" void QCALLTYPE ReflectionInvocation_PrepareMethod(MethodDesc *pMD, TypeHandle *pInstantiation, UINT32 cInstantiation, QCallException* qcallError) { CONTRACTL { @@ -1392,7 +1394,7 @@ extern "C" void QCALLTYPE ReflectionInvocation_PrepareMethod(MethodDesc *pMD, Ty // This method triggers target of a given method to be jitted. // In the case of a multi-cast delegate, we rely on the fact that each individual component // was prepared prior to the Combine. -extern "C" void QCALLTYPE ReflectionInvocation_PrepareDelegate(QCall::ObjectHandleOnStack delegate) +extern "C" void QCALLTYPE ReflectionInvocation_PrepareDelegate(QCall::ObjectHandleOnStack delegate, QCallException* qcallError) { QCALL_CONTRACT; @@ -1454,7 +1456,8 @@ extern "C" void QCALLTYPE ReflectionInvocation_InvokeDispMethod( QCall::ObjectHandleOnStack byrefModifiers, LCID lcid, QCall::ObjectHandleOnStack namedParameters, - QCall::ObjectHandleOnStack result) + QCall::ObjectHandleOnStack result, + QCallException* qcallError) { QCALL_CONTRACT; @@ -1515,7 +1518,7 @@ extern "C" void QCALLTYPE ReflectionInvocation_InvokeDispMethod( END_QCALL; } -extern "C" void QCALLTYPE ReflectionInvocation_GetComObjectGuid(QCall::ObjectHandleOnStack type, GUID* result) +extern "C" void QCALLTYPE ReflectionInvocation_GetComObjectGuid(QCall::ObjectHandleOnStack type, GUID* result, QCallException* qcallError) { CONTRACTL { @@ -1548,7 +1551,7 @@ extern "C" void QCALLTYPE ReflectionInvocation_GetComObjectGuid(QCall::ObjectHan } #endif // FEATURE_COMINTEROP -extern "C" void QCALLTYPE ReflectionInvocation_GetGuid(MethodTable* pMT, GUID* result) +extern "C" void QCALLTYPE ReflectionInvocation_GetGuid(MethodTable* pMT, GUID* result, QCallException* qcallError) { CONTRACTL { @@ -1660,7 +1663,8 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_GetActivationInfo( void** pvAllocatorFirstArg, PCODE* ppfnRefCtor, PCODE* ppfnValueCtor, - BOOL* pfCtorIsPublic + BOOL* pfCtorIsPublic, + QCallException* qcallError ) { CONTRACTL @@ -1797,7 +1801,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_GetActivationInfo( * Given a ComClassFactory*, calls the COM allocator * and returns a RCW. */ -extern "C" void QCALLTYPE RuntimeTypeHandle_AllocateComObject(void* pClassFactory, QCall::ObjectHandleOnStack result) +extern "C" void QCALLTYPE RuntimeTypeHandle_AllocateComObject(void* pClassFactory, QCall::ObjectHandleOnStack result, QCallException* qcallError) { QCALL_CONTRACT; @@ -1829,7 +1833,8 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_AllocateComObject(void* pClassFactor extern "C" void QCALLTYPE ReflectionSerialization_GetCreateUninitializedObjectInfo( QCall::TypeHandle pType, PCODE* ppfnAllocator, - void** pvAllocatorFirstArg) + void** pvAllocatorFirstArg, + QCallException* qcallError) { CONTRACTL { @@ -1881,7 +1886,7 @@ struct TempEnumValue UINT64 value; }; -extern "C" void QCALLTYPE Enum_GetValuesAndNames(QCall::TypeHandle pEnumType, QCall::ObjectHandleOnStack pReturnValues, QCall::ObjectHandleOnStack pReturnNames, BOOL fGetNames) +extern "C" void QCALLTYPE Enum_GetValuesAndNames(QCall::TypeHandle pEnumType, QCall::ObjectHandleOnStack pReturnValues, QCall::ObjectHandleOnStack pReturnNames, BOOL fGetNames, QCallException* qcallError) { QCALL_CONTRACT; @@ -2003,7 +2008,8 @@ extern "C" void QCALLTYPE ReflectionInvocation_GetBoxInfo( PCODE* ppfnAllocator, void** pvAllocatorFirstArg, int32_t* pValueOffset, - uint32_t* pValueSize) + uint32_t* pValueSize, + QCallException* qcallError) { CONTRACTL { diff --git a/src/coreclr/vm/reflectioninvocation.h b/src/coreclr/vm/reflectioninvocation.h index cf75f5391f6d57..3dd84a0b1a0de4 100644 --- a/src/coreclr/vm/reflectioninvocation.h +++ b/src/coreclr/vm/reflectioninvocation.h @@ -48,15 +48,15 @@ class ReflectionInvocation FCDECL0(static FC_BOOL_RET, TryEnsureSufficientExecutionStack); }; -extern "C" void QCALLTYPE ReflectionInvocation_CompileMethod(MethodDesc * pMD); +extern "C" void QCALLTYPE ReflectionInvocation_CompileMethod(MethodDesc * pMD, QCallException* qcallError); -extern "C" void QCALLTYPE ReflectionInvocation_RunClassConstructor(QCall::TypeHandle pType); +extern "C" void QCALLTYPE ReflectionInvocation_RunClassConstructor(QCall::TypeHandle pType, QCallException* qcallError); -extern "C" void QCALLTYPE ReflectionInvocation_RunModuleConstructor(QCall::ModuleHandle pModule); +extern "C" void QCALLTYPE ReflectionInvocation_RunModuleConstructor(QCall::ModuleHandle pModule, QCallException* qcallError); -extern "C" void QCALLTYPE ReflectionInvocation_PrepareMethod(MethodDesc* pMD, TypeHandle *pInstantiation, UINT32 cInstantiation); +extern "C" void QCALLTYPE ReflectionInvocation_PrepareMethod(MethodDesc* pMD, TypeHandle *pInstantiation, UINT32 cInstantiation, QCallException* qcallError); -extern "C" void QCALLTYPE ReflectionInvocation_PrepareDelegate(QCall::ObjectHandleOnStack delegate); +extern "C" void QCALLTYPE ReflectionInvocation_PrepareDelegate(QCall::ObjectHandleOnStack delegate, QCallException* qcallError); #ifdef FEATURE_COMINTEROP extern "C" void QCALLTYPE ReflectionInvocation_InvokeDispMethod( @@ -68,23 +68,25 @@ extern "C" void QCALLTYPE ReflectionInvocation_InvokeDispMethod( QCall::ObjectHandleOnStack byrefModifiers, LCID lcid, QCall::ObjectHandleOnStack namedParameters, - QCall::ObjectHandleOnStack result); + QCall::ObjectHandleOnStack result, + QCallException* qcallError); -extern "C" void QCALLTYPE ReflectionInvocation_GetComObjectGuid(QCall::ObjectHandleOnStack type, GUID* result); +extern "C" void QCALLTYPE ReflectionInvocation_GetComObjectGuid(QCall::ObjectHandleOnStack type, GUID* result, QCallException* qcallError); #endif // FEATURE_COMINTEROP -extern "C" void QCALLTYPE ReflectionInvocation_GetGuid(MethodTable* pMT, GUID* result); +extern "C" void QCALLTYPE ReflectionInvocation_GetGuid(MethodTable* pMT, GUID* result, QCallException* qcallError); -extern "C" void QCALLTYPE ReflectionSerialization_GetCreateUninitializedObjectInfo(QCall::TypeHandle pType, PCODE* ppfnAllocator, void** pvAllocatorFirstArg); +extern "C" void QCALLTYPE ReflectionSerialization_GetCreateUninitializedObjectInfo(QCall::TypeHandle pType, PCODE* ppfnAllocator, void** pvAllocatorFirstArg, QCallException* qcallError); extern "C" void QCALLTYPE ReflectionInvocation_GetBoxInfo( QCall::TypeHandle pType, PCODE* ppfnAllocator, void** pvAllocatorFirstArg, int32_t* pValueOffset, - uint32_t* pValueSize); + uint32_t* pValueSize, + QCallException* qcallError); -extern "C" void QCALLTYPE Enum_GetValuesAndNames(QCall::TypeHandle pEnumType, QCall::ObjectHandleOnStack pReturnValues, QCall::ObjectHandleOnStack pReturnNames, BOOL fGetNames); +extern "C" void QCALLTYPE Enum_GetValuesAndNames(QCall::TypeHandle pEnumType, QCall::ObjectHandleOnStack pReturnValues, QCall::ObjectHandleOnStack pReturnNames, BOOL fGetNames, QCallException* qcallError); extern "C" int32_t QCALLTYPE ReflectionInvocation_SizeOf(QCall::TypeHandle pType); diff --git a/src/coreclr/vm/runtimehandles.cpp b/src/coreclr/vm/runtimehandles.cpp index b65134fd611157..f2ed15a7455b21 100644 --- a/src/coreclr/vm/runtimehandles.cpp +++ b/src/coreclr/vm/runtimehandles.cpp @@ -33,7 +33,7 @@ #include "finalizerthread.h" #include "pregeneratedstringthunks.h" -extern "C" BOOL QCALLTYPE MdUtf8String_EqualsCaseInsensitive(LPCUTF8 szLhs, LPCUTF8 szRhs, INT32 stringNumBytes) +extern "C" BOOL QCALLTYPE MdUtf8String_EqualsCaseInsensitive(LPCUTF8 szLhs, LPCUTF8 szRhs, INT32 stringNumBytes, QCallException* qcallError) { QCALL_CONTRACT; @@ -98,7 +98,8 @@ extern "C" BOOL QCALLTYPE RuntimeMethodHandle_IsCAVisibleFromDecoratedType( QCall::TypeHandle targetTypeHandle, MethodDesc * pTargetCtor, QCall::TypeHandle sourceTypeHandle, - QCall::ModuleHandle sourceModuleHandle) + QCall::ModuleHandle sourceModuleHandle, + QCallException* qcallError) { QCALL_CONTRACT; @@ -140,7 +141,8 @@ extern "C" BOOL QCALLTYPE RuntimeMethodHandle_IsCAVisibleFromDecoratedType( extern "C" void QCALLTYPE RuntimeTypeHandle_GetRuntimeTypeFromHandleSlow( EnregisteredTypeHandle typeHandleRaw, - QCall::ObjectHandleOnStack result) + QCall::ObjectHandleOnStack result, + QCallException* qcallError) { QCALL_CONTRACT; @@ -158,7 +160,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_GetRuntimeTypeFromHandleSlow( } #ifdef FEATURE_TYPEEQUIVALENCE -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsEquivalentTo(QCall::TypeHandle rtType1, QCall::TypeHandle rtType2) +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsEquivalentTo(QCall::TypeHandle rtType1, QCall::TypeHandle rtType2, QCallException* qcallError) { QCALL_CONTRACT; @@ -232,7 +234,7 @@ FCIMPL1(AssemblyBaseObject*, RuntimeTypeHandle::GetAssemblyIfExists, ReflectClas } FCIMPLEND -extern "C" void QCALLTYPE RuntimeTypeHandle_GetAssemblySlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack assembly) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetAssemblySlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack assembly, QCallException* qcallError) { QCALL_CONTRACT; @@ -289,7 +291,7 @@ FCIMPL1(ReflectModuleBaseObject*, RuntimeTypeHandle::GetModuleIfExists, ReflectC } FCIMPLEND -extern "C" void QCALLTYPE RuntimeTypeHandle_GetModuleSlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack module) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetModuleSlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack module, QCallException* qcallError) { QCALL_CONTRACT; @@ -362,7 +364,7 @@ FCIMPL1(INT32, RuntimeTypeHandle::GetNumVirtuals, ReflectClassBaseObject* pTypeU } FCIMPLEND -extern "C" INT32 QCALLTYPE RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals(QCall::TypeHandle pTypeHandle) +extern "C" INT32 QCALLTYPE RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals(QCall::TypeHandle pTypeHandle, QCallException* qcallError) { QCALL_CONTRACT; @@ -396,7 +398,7 @@ extern "C" INT32 QCALLTYPE RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals(QCa return numVirtuals; } -extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetMethodAt(MethodTable* pMT, INT32 slot) +extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetMethodAt(MethodTable* pMT, INT32 slot, QCallException* qcallError) { QCALL_CONTRACT; @@ -455,7 +457,7 @@ extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetMethodAt(MethodTable* pMT, return pRetMethod; } -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_GetFields(MethodTable* pMT, intptr_t* result, INT32* pCount) +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_GetFields(MethodTable* pMT, intptr_t* result, INT32* pCount, QCallException* qcallError) { QCALL_CONTRACT; @@ -489,7 +491,7 @@ extern "C" BOOL QCALLTYPE RuntimeTypeHandle_GetFields(MethodTable* pMT, intptr_t return retVal; } -extern "C" void QCALLTYPE RuntimeMethodHandle_ConstructInstantiation(MethodDesc * pMethod, DWORD format, QCall::StringHandleOnStack retString) +extern "C" void QCALLTYPE RuntimeMethodHandle_ConstructInstantiation(MethodDesc * pMethod, DWORD format, QCall::StringHandleOnStack retString, QCallException* qcallError) { QCALL_CONTRACT; @@ -502,7 +504,7 @@ extern "C" void QCALLTYPE RuntimeMethodHandle_ConstructInstantiation(MethodDesc END_QCALL; } -extern "C" void QCALLTYPE RuntimeTypeHandle_ConstructName(QCall::TypeHandle pTypeHandle, DWORD format, QCall::StringHandleOnStack retString) +extern "C" void QCALLTYPE RuntimeTypeHandle_ConstructName(QCall::TypeHandle pTypeHandle, DWORD format, QCall::StringHandleOnStack retString, QCallException* qcallError) { QCALL_CONTRACT; @@ -515,7 +517,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_ConstructName(QCall::TypeHandle pTyp END_QCALL; } -extern "C" void QCALLTYPE RuntimeTypeHandle_GetInterfaces(MethodTable* pMT, QCall::ObjectHandleOnStack result) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetInterfaces(MethodTable* pMT, QCall::ObjectHandleOnStack result, QCallException* qcallError) { QCALL_CONTRACT; @@ -596,7 +598,7 @@ static PTRARRAYREF CopyRuntimeTypeHandles(TypeHandle * prgTH, INT32 numTypeHandl return refReturn; } -extern "C" void QCALLTYPE RuntimeTypeHandle_GetConstraints(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retTypeArray) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetConstraints(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retTypeArray, QCallException* qcallError) { QCALL_CONTRACT; @@ -644,7 +646,7 @@ FCIMPL1(INT32, RuntimeTypeHandle::GetAttributes, ReflectClassBaseObject *pTypeUN } FCIMPLEND -extern "C" void QCALLTYPE RuntimeTypeHandle_GetArgumentTypesFromFunctionPointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack argTypes) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetArgumentTypesFromFunctionPointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack argTypes, QCallException* qcallError) { QCALL_CONTRACT; @@ -706,7 +708,7 @@ FCIMPL1(FC_BOOL_RET, RuntimeTypeHandle::IsUnmanagedFunctionPointer, ReflectClass } FCIMPLEND -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsVisible(QCall::TypeHandle pTypeHandle) +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsVisible(QCall::TypeHandle pTypeHandle, QCallException* qcallError) { CONTRACTL { @@ -775,7 +777,7 @@ FCIMPL1(INT32, RuntimeTypeHandle::GetToken, ReflectClassBaseObject *pTypeUNSAFE) } FCIMPLEND -extern "C" PVOID QCALLTYPE QCall_GetGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, INT32 handleType) +extern "C" PVOID QCALLTYPE QCall_GetGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, INT32 handleType, QCallException* qcallError) { QCALL_CONTRACT; @@ -796,7 +798,7 @@ extern "C" PVOID QCALLTYPE QCall_GetGCHandleForTypeHandle(QCall::TypeHandle pTyp return objHandle; } -extern "C" void QCALLTYPE QCall_FreeGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, OBJECTHANDLE objHandle) +extern "C" void QCALLTYPE QCall_FreeGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, OBJECTHANDLE objHandle, QCallException* qcallError) { QCALL_CONTRACT; @@ -811,7 +813,7 @@ extern "C" void QCALLTYPE QCall_FreeGCHandleForTypeHandle(QCall::TypeHandle pTyp END_QCALL; } -extern "C" void QCALLTYPE RuntimeTypeHandle_VerifyInterfaceIsImplemented(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pIFaceHandle) +extern "C" void QCALLTYPE RuntimeTypeHandle_VerifyInterfaceIsImplemented(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pIFaceHandle, QCallException* qcallError) { QCALL_CONTRACT; @@ -847,7 +849,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_VerifyInterfaceIsImplemented(QCall:: END_QCALL; } -extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetInterfaceMethodImplementation(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pOwner, MethodDesc * pMD) +extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetInterfaceMethodImplementation(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pOwner, MethodDesc * pMD, QCallException* qcallError) { QCALL_CONTRACT; @@ -883,7 +885,7 @@ extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetInterfaceMethodImplementat return pResult; } -extern "C" void QCALLTYPE RuntimeTypeHandle_GetDeclaringMethodForGenericParameter(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack result) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetDeclaringMethodForGenericParameter(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack result, QCallException* qcallError) { QCALL_CONTRACT; @@ -905,7 +907,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_GetDeclaringMethodForGenericParamete END_QCALL; } -extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandleForGenericVariable(EnregisteredTypeHandle pTypeHandle) +extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandleForGenericVariable(EnregisteredTypeHandle pTypeHandle, QCallException* qcallError) { QCALL_CONTRACT; @@ -950,7 +952,7 @@ extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHa return (EnregisteredTypeHandle)retTypeHandle.AsTAddr(); } -extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandle(EnregisteredTypeHandle pTypeHandle) +extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandle(EnregisteredTypeHandle pTypeHandle, QCallException* qcallError) { QCALL_CONTRACT; @@ -984,7 +986,7 @@ extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHa return (EnregisteredTypeHandle)retTypeHandle.AsTAddr(); } -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_SatisfiesConstraints(QCall::TypeHandle paramType, QCall::TypeHandle typeContext, MethodDesc* methodContext, QCall::TypeHandle toType) +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_SatisfiesConstraints(QCall::TypeHandle paramType, QCall::TypeHandle typeContext, MethodDesc* methodContext, QCall::TypeHandle toType, QCallException* qcallError) { CONTRACTL { @@ -1017,7 +1019,7 @@ extern "C" BOOL QCALLTYPE RuntimeTypeHandle_SatisfiesConstraints(QCall::TypeHand return bResult; } -extern "C" void QCALLTYPE RuntimeTypeHandle_GetInstantiation(QCall::TypeHandle pType, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetInstantiation(QCall::TypeHandle pType, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray, QCallException* qcallError) { QCALL_CONTRACT; @@ -1032,7 +1034,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_GetInstantiation(QCall::TypeHandle p return; } -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeArray(QCall::TypeHandle pTypeHandle, INT32 rank, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeArray(QCall::TypeHandle pTypeHandle, INT32 rank, QCall::ObjectHandleOnStack retType, QCallException* qcallError) { QCALL_CONTRACT; @@ -1047,7 +1049,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_MakeArray(QCall::TypeHandle pTypeHan return; } -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeSZArray(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeSZArray(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallException* qcallError) { QCALL_CONTRACT; @@ -1062,7 +1064,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_MakeSZArray(QCall::TypeHandle pTypeH return; } -extern "C" void QCALLTYPE RuntimeTypeHandle_MakePointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE RuntimeTypeHandle_MakePointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallException* qcallError) { QCALL_CONTRACT; @@ -1077,7 +1079,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_MakePointer(QCall::TypeHandle pTypeH return; } -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallException* qcallError) { QCALL_CONTRACT; @@ -1092,7 +1094,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHan return; } -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeFunctionPointer(TypeHandle* pRetAndArgTypes, INT32 numArgs, BOOL isUnmanaged, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeFunctionPointer(TypeHandle* pRetAndArgTypes, INT32 numArgs, BOOL isUnmanaged, QCall::ObjectHandleOnStack retType, QCallException* qcallError) { QCALL_CONTRACT; @@ -1108,7 +1110,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_MakeFunctionPointer(TypeHandle* pRet return; } -extern "C" void QCALLTYPE RuntimeTypeHandle_Instantiate(QCall::TypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE RuntimeTypeHandle_Instantiate(QCall::TypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType, QCallException* qcallError) { QCALL_CONTRACT; @@ -1123,7 +1125,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_Instantiate(QCall::TypeHandle pTypeH return; } -extern "C" void QCALLTYPE RuntimeTypeHandle_GetGenericTypeDefinition(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetGenericTypeDefinition(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallException* qcallError) { QCALL_CONTRACT; @@ -1227,7 +1229,7 @@ FCIMPL1(FC_BOOL_RET, RuntimeTypeHandle::ContainsGenericVariables, PTR_ReflectCla } FCIMPLEND -extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemory(QCall::TypeHandle type, uint32_t size) +extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemory(QCall::TypeHandle type, uint32_t size, QCallException* qcallError) { QCALL_CONTRACT; @@ -1250,7 +1252,7 @@ extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemory(QCall: return allocatedMemory; } -extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemoryAligned(QCall::TypeHandle type, uint32_t size, uint32_t alignment) +extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemoryAligned(QCall::TypeHandle type, uint32_t size, uint32_t alignment, QCallException* qcallError) { QCALL_CONTRACT; @@ -1276,7 +1278,7 @@ extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemoryAligned return allocatedMemory; } -extern "C" void QCALLTYPE RuntimeTypeHandle_RegisterCollectibleTypeDependency(QCall::TypeHandle pTypeHandle, QCall::AssemblyHandle pAssembly) +extern "C" void QCALLTYPE RuntimeTypeHandle_RegisterCollectibleTypeDependency(QCall::TypeHandle pTypeHandle, QCall::AssemblyHandle pAssembly, QCallException* qcallError) { QCALL_CONTRACT; @@ -1303,7 +1305,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_RegisterCollectibleTypeDependency(QC //*********************************************************************************** //*********************************************************************************** -extern "C" void * QCALLTYPE RuntimeMethodHandle_GetFunctionPointer(MethodDesc * pMethod) +extern "C" void * QCALLTYPE RuntimeMethodHandle_GetFunctionPointer(MethodDesc * pMethod, QCallException* qcallError) { QCALL_CONTRACT; @@ -1485,7 +1487,8 @@ extern "C" void QCALLTYPE Signature_GetCustomModifiersAtOffset( QCall::ObjectHandleOnStack sigObj, INT32 offset, BOOL fRequired, - QCall::ObjectHandleOnStack result) + QCall::ObjectHandleOnStack result, + QCallException* qcallError) { QCALL_CONTRACT; @@ -1609,7 +1612,8 @@ extern "C" void QCALLTYPE Signature_Init( QCall::ObjectHandleOnStack sigObj, PCCOR_SIGNATURE pCorSig, DWORD cCorSig, FieldDesc* pFieldDesc, - MethodDesc* pMethodDesc) + MethodDesc* pMethodDesc, + QCallException* qcallError) { QCALL_CONTRACT; @@ -1710,7 +1714,8 @@ extern "C" void QCALLTYPE Signature_Init( extern "C" BOOL QCALLTYPE Signature_AreEqual( PCCOR_SIGNATURE sig1, INT32 cSig1, QCall::TypeHandle handle1, - PCCOR_SIGNATURE sig2, INT32 cSig2, QCall::TypeHandle handle2) + PCCOR_SIGNATURE sig2, INT32 cSig2, QCall::TypeHandle handle2, + QCallException* qcallError) { QCALL_CONTRACT; @@ -1728,7 +1733,7 @@ extern "C" BOOL QCALLTYPE Signature_AreEqual( return ret; } -extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray) +extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray, QCallException* qcallError) { QCALL_CONTRACT; @@ -1788,7 +1793,7 @@ FCIMPL1(Object*, RuntimeMethodHandle::GetResolver, MethodDesc * pMethod) } FCIMPLEND -extern "C" void QCALLTYPE RuntimeMethodHandle_Destroy(MethodDesc * pMethod) +extern "C" void QCALLTYPE RuntimeMethodHandle_Destroy(MethodDesc * pMethod, QCallException* qcallError) { QCALL_CONTRACT; _ASSERTE(pMethod != NULL); @@ -1832,7 +1837,7 @@ FCIMPL1(FC_BOOL_RET, RuntimeMethodHandle::IsTypicalMethodDefinition, ReflectMeth } FCIMPLEND -extern "C" void QCALLTYPE RuntimeMethodHandle_GetTypicalMethodDefinition(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod) +extern "C" void QCALLTYPE RuntimeMethodHandle_GetTypicalMethodDefinition(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod, QCallException* qcallError) { QCALL_CONTRACT; @@ -1854,7 +1859,7 @@ extern "C" void QCALLTYPE RuntimeMethodHandle_GetTypicalMethodDefinition(MethodD return; } -extern "C" void QCALLTYPE RuntimeMethodHandle_StripMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod) +extern "C" void QCALLTYPE RuntimeMethodHandle_StripMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod, QCallException* qcallError) { QCALL_CONTRACT; @@ -1939,7 +1944,7 @@ FCIMPL2(MethodDesc*, RuntimeMethodHandle::GetStubIfNeededInternal, FCIMPLEND // See RuntimeMethodHandle::GetStubIfNeededInternal for more details. -extern "C" MethodDesc* QCALLTYPE RuntimeMethodHandle_GetStubIfNeededSlow(MethodDesc* pMethod, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack methodInstantiation) +extern "C" MethodDesc* QCALLTYPE RuntimeMethodHandle_GetStubIfNeededSlow(MethodDesc* pMethod, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack methodInstantiation, QCallException* qcallError) { QCALL_CONTRACT; @@ -2006,7 +2011,7 @@ FCIMPL2(MethodDesc*, RuntimeMethodHandle::GetMethodFromCanonical, MethodDesc *pM } FCIMPLEND -extern "C" PCODE QCALLTYPE RuntimeMethodHandle_GetNativeCode(MethodDesc* pMethod) +extern "C" PCODE QCALLTYPE RuntimeMethodHandle_GetNativeCode(MethodDesc* pMethod, QCallException* qcallError) { QCALL_CONTRACT; @@ -2033,7 +2038,7 @@ extern "C" PCODE QCALLTYPE RuntimeMethodHandle_GetNativeCode(MethodDesc* pMethod return result; } -extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodBody(MethodDesc* pMethod, QCall::TypeHandle pDeclaringType, QCall::ObjectHandleOnStack result) +extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodBody(MethodDesc* pMethod, QCall::TypeHandle pDeclaringType, QCall::ObjectHandleOnStack result, QCallException* qcallError) { QCALL_CONTRACT; @@ -2332,7 +2337,7 @@ FCIMPL1(INT32, AssemblyHandle::GetTokenInternal, AssemblyBaseObject* pAssemblyUN } FCIMPLEND -extern "C" void QCALLTYPE AssemblyHandle_GetManifestModuleSlow(QCall::ObjectHandleOnStack assembly, QCall::ObjectHandleOnStack module) +extern "C" void QCALLTYPE AssemblyHandle_GetManifestModuleSlow(QCall::ObjectHandleOnStack assembly, QCall::ObjectHandleOnStack module, QCallException* qcallError) { QCALL_CONTRACT; @@ -2347,7 +2352,7 @@ extern "C" void QCALLTYPE AssemblyHandle_GetManifestModuleSlow(QCall::ObjectHand END_QCALL; } -extern "C" void QCALLTYPE ModuleHandle_GetPEKind(QCall::ModuleHandle pModule, DWORD* pdwPEKind, DWORD* pdwMachine) +extern "C" void QCALLTYPE ModuleHandle_GetPEKind(QCall::ModuleHandle pModule, DWORD* pdwPEKind, DWORD* pdwMachine, QCallException* qcallError) { QCALL_CONTRACT; @@ -2363,7 +2368,7 @@ extern "C" INT32 QCALLTYPE ModuleHandle_GetMDStreamVersion(QCall::ModuleHandle p return pModule->GetMDImport()->GetMetadataStreamVersion(); } -extern "C" void QCALLTYPE ModuleHandle_GetModuleType(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE ModuleHandle_GetModuleType(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retType, QCallException* qcallError) { QCALL_CONTRACT; @@ -2395,7 +2400,7 @@ extern "C" INT32 QCALLTYPE ModuleHandle_GetToken(QCall::ModuleHandle pModule) return pModule->GetMDImport()->GetModuleFromScope(); } -extern "C" void QCALLTYPE ModuleHandle_ResolveType(QCall::ModuleHandle pModule, INT32 tkType, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE ModuleHandle_ResolveType(QCall::ModuleHandle pModule, INT32 tkType, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retType, QCallException* qcallError) { QCALL_CONTRACT; @@ -2416,7 +2421,7 @@ extern "C" void QCALLTYPE ModuleHandle_ResolveType(QCall::ModuleHandle pModule, return; } -extern "C" MethodDesc *QCALLTYPE ModuleHandle_ResolveMethod(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount) +extern "C" MethodDesc *QCALLTYPE ModuleHandle_ResolveMethod(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCallException* qcallError) { QCALL_CONTRACT; @@ -2437,7 +2442,7 @@ extern "C" MethodDesc *QCALLTYPE ModuleHandle_ResolveMethod(QCall::ModuleHandle return pMD; } -extern "C" void QCALLTYPE ModuleHandle_ResolveField(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retField) +extern "C" void QCALLTYPE ModuleHandle_ResolveField(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retField, QCallException* qcallError) { QCALL_CONTRACT; @@ -2455,7 +2460,7 @@ extern "C" void QCALLTYPE ModuleHandle_ResolveField(QCall::ModuleHandle pModule, return; } -extern "C" void QCALLTYPE ModuleHandle_GetDynamicMethod(QCall::ModuleHandle pModule, const char* name, byte* sig, INT32 sigLen, QCall::ObjectHandleOnStack resolver, QCall::ObjectHandleOnStack result) +extern "C" void QCALLTYPE ModuleHandle_GetDynamicMethod(QCall::ModuleHandle pModule, const char* name, byte* sig, INT32 sigLen, QCall::ObjectHandleOnStack resolver, QCall::ObjectHandleOnStack result, QCallException* qcallError) { CONTRACTL { diff --git a/src/coreclr/vm/runtimehandles.h b/src/coreclr/vm/runtimehandles.h index 1ac8932778ef8a..e75ed28afc6dc5 100644 --- a/src/coreclr/vm/runtimehandles.h +++ b/src/coreclr/vm/runtimehandles.h @@ -96,7 +96,7 @@ class RuntimeLocalVariableInfo : public Object CLR_BOOL _isPinned; }; -extern "C" BOOL QCALLTYPE MdUtf8String_EqualsCaseInsensitive(LPCUTF8 szLhs, LPCUTF8 szRhs, INT32 stringNumBytes); +extern "C" BOOL QCALLTYPE MdUtf8String_EqualsCaseInsensitive(LPCUTF8 szLhs, LPCUTF8 szRhs, INT32 stringNumBytes, QCallException* qcallError); class RuntimeTypeHandle { @@ -129,19 +129,19 @@ class RuntimeTypeHandle FCDECL1(static void, GetNextIntroducedMethod, MethodDesc **ppMethod); }; -extern "C" void QCALLTYPE RuntimeTypeHandle_GetRuntimeTypeFromHandleSlow(void* typeHandleRaw, QCall::ObjectHandleOnStack result); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetRuntimeTypeFromHandleSlow(void* typeHandleRaw, QCall::ObjectHandleOnStack result, QCallException* qcallError); #ifdef FEATURE_TYPEEQUIVALENCE -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsEquivalentTo(QCall::TypeHandle rtType1, QCall::TypeHandle rtType2); +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsEquivalentTo(QCall::TypeHandle rtType1, QCall::TypeHandle rtType2, QCallException* qcallError); #endif // FEATURE_TYPEEQUIVALENCE -extern "C" void QCALLTYPE RuntimeTypeHandle_CreateInstanceForAnotherGenericParameter(QCall::TypeHandle pTypeHandle, TypeHandle *pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack pInstantiatedObject); -extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAlloc(MethodTable* pMT, QCall::ObjectHandleOnStack allocated); +extern "C" void QCALLTYPE RuntimeTypeHandle_CreateInstanceForAnotherGenericParameter(QCall::TypeHandle pTypeHandle, TypeHandle *pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack pInstantiatedObject, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAlloc(MethodTable* pMT, QCall::ObjectHandleOnStack allocated, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAllocNoChecks(MethodTable* pMT, QCall::ObjectHandleOnStack allocated); -extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemory(QCall::TypeHandle type, uint32_t size); -extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemoryAligned(QCall::TypeHandle type, uint32_t size, uint32_t alignment); +extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAllocNoChecks(MethodTable* pMT, QCall::ObjectHandleOnStack allocated, QCallException* qcallError); +extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemory(QCall::TypeHandle type, uint32_t size, QCallException* qcallError); +extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemoryAligned(QCall::TypeHandle type, uint32_t size, uint32_t alignment, QCallException* qcallError); -extern "C" PVOID QCALLTYPE QCall_GetGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, INT32 handleType); -extern "C" void QCALLTYPE QCall_FreeGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, OBJECTHANDLE objHandle); +extern "C" PVOID QCALLTYPE QCall_GetGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, INT32 handleType, QCallException* qcallError); +extern "C" void QCALLTYPE QCall_FreeGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, OBJECTHANDLE objHandle, QCallException* qcallError); extern "C" void QCALLTYPE RuntimeTypeHandle_GetActivationInfo( QCall::ObjectHandleOnStack pRuntimeType, @@ -149,36 +149,37 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_GetActivationInfo( void** pvAllocatorFirstArg, PCODE* ppfnCtor, PCODE* ppfnValueCtor, - BOOL* pfCtorIsPublic); + BOOL* pfCtorIsPublic, + QCallException* qcallError); #ifdef FEATURE_COMINTEROP -extern "C" void QCALLTYPE RuntimeTypeHandle_AllocateComObject(void* pClassFactory, QCall::ObjectHandleOnStack result); +extern "C" void QCALLTYPE RuntimeTypeHandle_AllocateComObject(void* pClassFactory, QCall::ObjectHandleOnStack result, QCallException* qcallError); #endif // FEATURE_COMINTEROP -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType); -extern "C" void QCALLTYPE RuntimeTypeHandle_MakePointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType); -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeSZArray(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType); -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeArray(QCall::TypeHandle pTypeHandle, INT32 rank, QCall::ObjectHandleOnStack retType); -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeFunctionPointer(TypeHandle* pRetAndArgTypes, INT32 numArgs, BOOL isUnmanaged, QCall::ObjectHandleOnStack retType); +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_MakePointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeSZArray(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeArray(QCall::TypeHandle pTypeHandle, INT32 rank, QCall::ObjectHandleOnStack retType, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeFunctionPointer(TypeHandle* pRetAndArgTypes, INT32 numArgs, BOOL isUnmanaged, QCall::ObjectHandleOnStack retType, QCallException* qcallError); extern "C" void QCALLTYPE RuntimeTypeHandle_PrepareMemberInfoCache(QCall::TypeHandle pMemberInfoCache); -extern "C" void QCALLTYPE RuntimeTypeHandle_ConstructName(QCall::TypeHandle pTypeHandle, DWORD format, QCall::StringHandleOnStack retString); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetInterfaces(MethodTable* pMT, QCall::ObjectHandleOnStack result); -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsVisible(QCall::TypeHandle pTypeHandle); -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_SatisfiesConstraints(QCall::TypeHandle paramType, QCall::TypeHandle typeContext, MethodDesc* methodContext, QCall::TypeHandle toType); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetInstantiation(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, BOOL fAsRuntimeTypeArray); -extern "C" void QCALLTYPE RuntimeTypeHandle_Instantiate(QCall::TypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetGenericTypeDefinition(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetConstraints(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retTypes); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetArgumentTypesFromFunctionPointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack argTypes); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetAssemblySlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack assembly); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetModuleSlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack module); -extern "C" INT32 QCALLTYPE RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals(QCall::TypeHandle pTypeHandle); -extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetMethodAt(MethodTable* pMT, INT32 slot); -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_GetFields(MethodTable* pMT, intptr_t* result, INT32* pCount); -extern "C" void QCALLTYPE RuntimeTypeHandle_VerifyInterfaceIsImplemented(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pIFaceHandle); -extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetInterfaceMethodImplementation(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pOwner, MethodDesc * pMD); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetDeclaringMethodForGenericParameter(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack result); -extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandleForGenericVariable(EnregisteredTypeHandle pTypeHandle); -extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandle(EnregisteredTypeHandle pTypeHandle); -extern "C" void QCALLTYPE RuntimeTypeHandle_RegisterCollectibleTypeDependency(QCall::TypeHandle pTypeHandle, QCall::AssemblyHandle pAssembly); +extern "C" void QCALLTYPE RuntimeTypeHandle_ConstructName(QCall::TypeHandle pTypeHandle, DWORD format, QCall::StringHandleOnStack retString, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetInterfaces(MethodTable* pMT, QCall::ObjectHandleOnStack result, QCallException* qcallError); +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsVisible(QCall::TypeHandle pTypeHandle, QCallException* qcallError); +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_SatisfiesConstraints(QCall::TypeHandle paramType, QCall::TypeHandle typeContext, MethodDesc* methodContext, QCall::TypeHandle toType, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetInstantiation(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, BOOL fAsRuntimeTypeArray, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_Instantiate(QCall::TypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetGenericTypeDefinition(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetConstraints(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retTypes, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetArgumentTypesFromFunctionPointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack argTypes, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetAssemblySlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack assembly, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetModuleSlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack module, QCallException* qcallError); +extern "C" INT32 QCALLTYPE RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals(QCall::TypeHandle pTypeHandle, QCallException* qcallError); +extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetMethodAt(MethodTable* pMT, INT32 slot, QCallException* qcallError); +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_GetFields(MethodTable* pMT, intptr_t* result, INT32* pCount, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_VerifyInterfaceIsImplemented(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pIFaceHandle, QCallException* qcallError); +extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetInterfaceMethodImplementation(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pOwner, MethodDesc * pMD, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetDeclaringMethodForGenericParameter(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack result, QCallException* qcallError); +extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandleForGenericVariable(EnregisteredTypeHandle pTypeHandle, QCallException* qcallError); +extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandle(EnregisteredTypeHandle pTypeHandle, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_RegisterCollectibleTypeDependency(QCall::TypeHandle pTypeHandle, QCall::AssemblyHandle pAssembly, QCallException* qcallError); class RuntimeMethodHandle { @@ -213,32 +214,34 @@ class RuntimeMethodHandle FCDECL1(static Object*, GetLoaderAllocatorInternal, MethodDesc *pMethod); }; -extern "C" MethodDesc* QCALLTYPE MethodBase_GetCurrentMethod(QCall::StackCrawlMarkHandle stackMark); +extern "C" MethodDesc* QCALLTYPE MethodBase_GetCurrentMethod(QCall::StackCrawlMarkHandle stackMark, QCallException* qcallError); extern "C" BOOL QCALLTYPE RuntimeMethodHandle_IsCAVisibleFromDecoratedType( QCall::TypeHandle targetTypeHandle, MethodDesc * pTargetCtor, QCall::TypeHandle sourceTypeHandle, - QCall::ModuleHandle sourceModuleHandle); + QCall::ModuleHandle sourceModuleHandle, + QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray); +extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray, QCallException* qcallError); extern "C" void QCALLTYPE RuntimeMethodHandle_InvokeMethod( QCall::ObjectHandleOnStack target, PVOID* args, QCall::ObjectHandleOnStack pSigUNSAFE, BOOL fConstructor, - QCall::ObjectHandleOnStack result); + QCall::ObjectHandleOnStack result, + QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeMethodHandle_ConstructInstantiation(MethodDesc * pMethod, DWORD format, QCall::StringHandleOnStack retString); -extern "C" void* QCALLTYPE RuntimeMethodHandle_GetFunctionPointer(MethodDesc * pMethod); +extern "C" void QCALLTYPE RuntimeMethodHandle_ConstructInstantiation(MethodDesc * pMethod, DWORD format, QCall::StringHandleOnStack retString, QCallException* qcallError); +extern "C" void* QCALLTYPE RuntimeMethodHandle_GetFunctionPointer(MethodDesc * pMethod, QCallException* qcallError); extern "C" BOOL QCALLTYPE RuntimeMethodHandle_GetIsCollectible(MethodDesc * pMethod); -extern "C" void QCALLTYPE RuntimeMethodHandle_GetTypicalMethodDefinition(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod); -extern "C" void QCALLTYPE RuntimeMethodHandle_StripMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod); -extern "C" void QCALLTYPE RuntimeMethodHandle_Destroy(MethodDesc * pMethod); -extern "C" MethodDesc* QCALLTYPE RuntimeMethodHandle_GetStubIfNeededSlow(MethodDesc* pMethod, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack methodInstantiation); -extern "C" PCODE QCALLTYPE RuntimeMethodHandle_GetNativeCode(MethodDesc* pMethod); -extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodBody(MethodDesc* pMethod, QCall::TypeHandle pDeclaringType, QCall::ObjectHandleOnStack result); +extern "C" void QCALLTYPE RuntimeMethodHandle_GetTypicalMethodDefinition(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeMethodHandle_StripMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeMethodHandle_Destroy(MethodDesc * pMethod, QCallException* qcallError); +extern "C" MethodDesc* QCALLTYPE RuntimeMethodHandle_GetStubIfNeededSlow(MethodDesc* pMethod, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack methodInstantiation, QCallException* qcallError); +extern "C" PCODE QCALLTYPE RuntimeMethodHandle_GetNativeCode(MethodDesc* pMethod, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodBody(MethodDesc* pMethod, QCall::TypeHandle pDeclaringType, QCall::ObjectHandleOnStack result, QCallException* qcallError); class RuntimeFieldHandle { @@ -256,28 +259,28 @@ class RuntimeFieldHandle FCDECL1(static Object*, GetLoaderAllocatorInternal, FieldDesc *pField); }; -extern "C" void QCALLTYPE RuntimeFieldHandle_GetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL *pIsClassInitialized, QCall::ObjectHandleOnStack result); -extern "C" void QCALLTYPE RuntimeFieldHandle_SetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::ObjectHandleOnStack value, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized); -extern "C" void QCALLTYPE RuntimeFieldHandle_GetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack result); -extern "C" void QCALLTYPE RuntimeFieldHandle_SetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::ObjectHandleOnStack newValue, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType); -extern "C" void* QCALLTYPE RuntimeFieldHandle_GetEnCFieldAddr(QCall::ObjectHandleOnStack target, FieldDesc* pFD); -extern "C" BOOL QCALLTYPE RuntimeFieldHandle_GetRVAFieldInfo(FieldDesc* pField, void** address, UINT* size); -extern "C" void QCALLTYPE RuntimeFieldHandle_GetFieldDataReference(FieldDesc* pField, QCall::ObjectHandleOnStack instance, QCall::ByteRefOnStack offset); +extern "C" void QCALLTYPE RuntimeFieldHandle_GetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL *pIsClassInitialized, QCall::ObjectHandleOnStack result, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeFieldHandle_SetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::ObjectHandleOnStack value, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeFieldHandle_GetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack result, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeFieldHandle_SetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::ObjectHandleOnStack newValue, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, QCallException* qcallError); +extern "C" void* QCALLTYPE RuntimeFieldHandle_GetEnCFieldAddr(QCall::ObjectHandleOnStack target, FieldDesc* pFD, QCallException* qcallError); +extern "C" BOOL QCALLTYPE RuntimeFieldHandle_GetRVAFieldInfo(FieldDesc* pField, void** address, UINT* size, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeFieldHandle_GetFieldDataReference(FieldDesc* pField, QCall::ObjectHandleOnStack instance, QCall::ByteRefOnStack offset, QCallException* qcallError); extern "C" INT32 QCALLTYPE ModuleHandle_GetMDStreamVersion(QCall::ModuleHandle pModule); -extern "C" void QCALLTYPE ModuleHandle_GetModuleType(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retType); +extern "C" void QCALLTYPE ModuleHandle_GetModuleType(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retType, QCallException* qcallError); extern "C" INT32 QCALLTYPE ModuleHandle_GetToken(QCall::ModuleHandle pModule); -extern "C" void QCALLTYPE ModuleHandle_ResolveType(QCall::ModuleHandle pModule, INT32 tkType, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retType); +extern "C" void QCALLTYPE ModuleHandle_ResolveType(QCall::ModuleHandle pModule, INT32 tkType, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retType, QCallException* qcallError); -extern "C" MethodDesc * QCALLTYPE ModuleHandle_ResolveMethod(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount); +extern "C" MethodDesc * QCALLTYPE ModuleHandle_ResolveMethod(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCallException* qcallError); -extern "C" void QCALLTYPE ModuleHandle_ResolveField(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retField); +extern "C" void QCALLTYPE ModuleHandle_ResolveField(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retField, QCallException* qcallError); -extern "C" void QCALLTYPE ModuleHandle_GetPEKind(QCall::ModuleHandle pModule, DWORD* pdwPEKind, DWORD* pdwMachine); +extern "C" void QCALLTYPE ModuleHandle_GetPEKind(QCall::ModuleHandle pModule, DWORD* pdwPEKind, DWORD* pdwMachine, QCallException* qcallError); -extern "C" void QCALLTYPE ModuleHandle_GetDynamicMethod(QCall::ModuleHandle pModule, const char* name, byte* sig, INT32 sigLen, QCall::ObjectHandleOnStack resolver, QCall::ObjectHandleOnStack result); +extern "C" void QCALLTYPE ModuleHandle_GetDynamicMethod(QCall::ModuleHandle pModule, const char* name, byte* sig, INT32 sigLen, QCall::ObjectHandleOnStack resolver, QCall::ObjectHandleOnStack result, QCallException* qcallError); class AssemblyHandle { @@ -286,23 +289,26 @@ class AssemblyHandle FCDECL1(static INT32, GetTokenInternal, AssemblyBaseObject *pAssemblyUNSAFE); }; -extern "C" void QCALLTYPE AssemblyHandle_GetManifestModuleSlow(QCall::ObjectHandleOnStack assembly, QCall::ObjectHandleOnStack module); +extern "C" void QCALLTYPE AssemblyHandle_GetManifestModuleSlow(QCall::ObjectHandleOnStack assembly, QCall::ObjectHandleOnStack module, QCallException* qcallError); extern "C" void QCALLTYPE Signature_Init( QCall::ObjectHandleOnStack sigObj, PCCOR_SIGNATURE pCorSig, DWORD cCorSig, FieldDesc* pFieldDesc, - MethodDesc* pMethodDesc); + MethodDesc* pMethodDesc, + QCallException* qcallError); extern "C" BOOL QCALLTYPE Signature_AreEqual( PCCOR_SIGNATURE sig1, INT32 cSig1, QCall::TypeHandle handle1, - PCCOR_SIGNATURE sig2, INT32 cSig2, QCall::TypeHandle handle2); + PCCOR_SIGNATURE sig2, INT32 cSig2, QCall::TypeHandle handle2, + QCallException* qcallError); extern "C" void QCALLTYPE Signature_GetCustomModifiersAtOffset( QCall::ObjectHandleOnStack sigObj, INT32 offset, BOOL fRequired, - QCall::ObjectHandleOnStack result); + QCall::ObjectHandleOnStack result, + QCallException* qcallError); class SignatureNative : public Object { @@ -310,7 +316,8 @@ class SignatureNative : public Object QCall::ObjectHandleOnStack sigObj, PCCOR_SIGNATURE pCorSig, DWORD cCorSig, FieldDesc* pFieldDesc, - MethodDesc* pMethodDesc); + MethodDesc* pMethodDesc, + QCallException* qcallError); friend class ArgIteratorForMethodInvoke; public: diff --git a/src/coreclr/vm/stackwalk.h b/src/coreclr/vm/stackwalk.h index 4b2c70823a418a..af1cbefbb59857 100644 --- a/src/coreclr/vm/stackwalk.h +++ b/src/coreclr/vm/stackwalk.h @@ -40,7 +40,7 @@ namespace AsmOffsetsAsserts class AsmOffsets; }; -extern "C" void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo); +extern "C" void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo, QCallException* qcallError); class CrawlFrame { @@ -403,7 +403,7 @@ class CrawlFrame friend class EECodeManager; friend class StackFrameIterator; friend struct ExInfo; - friend void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo); + friend void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo, QCallException* qcallError); bool isFrameless; bool isFirst; diff --git a/src/coreclr/vm/stubhelpers.cpp b/src/coreclr/vm/stubhelpers.cpp index 135d7a07c6d0f6..82f320ccd99fb0 100644 --- a/src/coreclr/vm/stubhelpers.cpp +++ b/src/coreclr/vm/stubhelpers.cpp @@ -313,7 +313,7 @@ FCIMPLEND #include -extern "C" IUnknown* QCALLTYPE StubHelpers_GetCOMIPFromRCWSlow(QCall::ObjectHandleOnStack pSrc, MethodDesc* pMD, void** ppTarget, BOOL* pfNeedsRelease) +extern "C" IUnknown* QCALLTYPE StubHelpers_GetCOMIPFromRCWSlow(QCall::ObjectHandleOnStack pSrc, MethodDesc* pMD, void** ppTarget, BOOL* pfNeedsRelease, QCallException* qcallError) { QCALL_CONTRACT; _ASSERTE(pMD != NULL); @@ -360,7 +360,7 @@ extern "C" IUnknown* QCALLTYPE StubHelpers_GetCOMIPFromRCWSlow(QCall::ObjectHand return pIntf; } -extern "C" void QCALLTYPE ObjectMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pSrcUNSAFE, VARIANT* pDest) +extern "C" void QCALLTYPE ObjectMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pSrcUNSAFE, VARIANT* pDest, QCallException* qcallError) { QCALL_CONTRACT; @@ -385,7 +385,7 @@ extern "C" void QCALLTYPE ObjectMarshaler_ConvertToNative(QCall::ObjectHandleOnS END_QCALL; } -extern "C" void QCALLTYPE ObjectMarshaler_ConvertToManaged(VARIANT* pSrc, QCall::ObjectHandleOnStack retObject) +extern "C" void QCALLTYPE ObjectMarshaler_ConvertToManaged(VARIANT* pSrc, QCall::ObjectHandleOnStack retObject, QCallException* qcallError) { QCALL_CONTRACT; @@ -407,7 +407,7 @@ extern "C" void QCALLTYPE ObjectMarshaler_ConvertToManaged(VARIANT* pSrc, QCall: } #include -extern "C" IUnknown* QCALLTYPE InterfaceMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pObjUNSAFE, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags) +extern "C" IUnknown* QCALLTYPE InterfaceMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pObjUNSAFE, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCallException* qcallError) { QCALL_CONTRACT; @@ -431,7 +431,7 @@ extern "C" IUnknown* QCALLTYPE InterfaceMarshaler_ConvertToNative(QCall::ObjectH return pIntf; } -extern "C" void QCALLTYPE InterfaceMarshaler_ConvertToManaged(IUnknown** ppUnk, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCall::ObjectHandleOnStack retObject) +extern "C" void QCALLTYPE InterfaceMarshaler_ConvertToManaged(IUnknown** ppUnk, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCall::ObjectHandleOnStack retObject, QCallException* qcallError) { QCALL_CONTRACT; @@ -454,7 +454,7 @@ extern "C" void QCALLTYPE InterfaceMarshaler_ConvertToManaged(IUnknown** ppUnk, } #include -extern "C" void QCALLTYPE InterfaceMarshaler_GetObjectForComCallableWrapperIUnknown(IUnknown* unk, QCall::ObjectHandleOnStack retObject) +extern "C" void QCALLTYPE InterfaceMarshaler_GetObjectForComCallableWrapperIUnknown(IUnknown* unk, QCall::ObjectHandleOnStack retObject, QCallException* qcallError) { QCALL_CONTRACT; @@ -467,7 +467,7 @@ extern "C" void QCALLTYPE InterfaceMarshaler_GetObjectForComCallableWrapperIUnkn END_QCALL; } -extern "C" void QCALLTYPE InterfaceMarshaler_ValidateComVisibilityForIUnknown(IUnknown* unk) +extern "C" void QCALLTYPE InterfaceMarshaler_ValidateComVisibilityForIUnknown(IUnknown* unk, QCallException* qcallError) { QCALL_CONTRACT; @@ -493,7 +493,7 @@ FCIMPL0(void, StubHelpers::ClearLastError) } FCIMPLEND -extern "C" void QCALLTYPE StubHelpers_ThrowInteropParamException(INT resID, INT paramIdx) +extern "C" void QCALLTYPE StubHelpers_ThrowInteropParamException(INT resID, INT paramIdx, QCallException* qcallError) { QCALL_CONTRACT; @@ -503,7 +503,7 @@ extern "C" void QCALLTYPE StubHelpers_ThrowInteropParamException(INT resID, INT } #ifdef PROFILING_SUPPORTED -extern "C" void* QCALLTYPE StubHelpers_ProfilerBeginTransitionCallback(MethodDesc* pTargetMD) +extern "C" void* QCALLTYPE StubHelpers_ProfilerBeginTransitionCallback(MethodDesc* pTargetMD, QCallException* qcallError) { PreserveLastErrorHolder preserveLastError; @@ -518,7 +518,7 @@ extern "C" void* QCALLTYPE StubHelpers_ProfilerBeginTransitionCallback(MethodDes return pTargetMD; } -extern "C" void QCALLTYPE StubHelpers_ProfilerEndTransitionCallback(MethodDesc* pTargetMD) +extern "C" void QCALLTYPE StubHelpers_ProfilerEndTransitionCallback(MethodDesc* pTargetMD, QCallException* qcallError) { PreserveLastErrorHolder preserveLastError; @@ -532,7 +532,7 @@ extern "C" void QCALLTYPE StubHelpers_ProfilerEndTransitionCallback(MethodDesc* } #endif // PROFILING_SUPPORTED -extern "C" void QCALLTYPE StubHelpers_MarshalToManagedVaList(va_list va, VARARGS* pArgIterator) +extern "C" void QCALLTYPE StubHelpers_MarshalToManagedVaList(va_list va, VARARGS* pArgIterator, QCallException* qcallError) { QCALL_CONTRACT; @@ -541,7 +541,7 @@ extern "C" void QCALLTYPE StubHelpers_MarshalToManagedVaList(va_list va, VARARGS END_QCALL; } -extern "C" void QCALLTYPE StubHelpers_MarshalToUnmanagedVaList(va_list va, DWORD cbVaListSize, const VARARGS* pArgIterator) +extern "C" void QCALLTYPE StubHelpers_MarshalToUnmanagedVaList(va_list va, DWORD cbVaListSize, const VARARGS* pArgIterator, QCallException* qcallError) { QCALL_CONTRACT; @@ -550,7 +550,7 @@ extern "C" void QCALLTYPE StubHelpers_MarshalToUnmanagedVaList(va_list va, DWORD END_QCALL; } -extern "C" void QCALLTYPE StubHelpers_ValidateObject(QCall::ObjectHandleOnStack pObj, MethodDesc *pMD) +extern "C" void QCALLTYPE StubHelpers_ValidateObject(QCall::ObjectHandleOnStack pObj, MethodDesc *pMD, QCallException* qcallError) { QCALL_CONTRACT; @@ -581,7 +581,7 @@ extern "C" void QCALLTYPE StubHelpers_ValidateObject(QCall::ObjectHandleOnStack END_QCALL; } -extern "C" void QCALLTYPE StubHelpers_ValidateByref(void *pByref, MethodDesc *pMD) +extern "C" void QCALLTYPE StubHelpers_ValidateByref(void *pByref, MethodDesc *pMD, QCallException* qcallError) { QCALL_CONTRACT; @@ -669,7 +669,7 @@ FCIMPL1(DWORD, StubHelpers::CalcVaListSize, VARARGS *varargs) } FCIMPLEND -extern "C" void QCALLTYPE StubHelpers_MulticastDebuggerTraceHelper(QCall::ObjectHandleOnStack element, INT32 count) +extern "C" void QCALLTYPE StubHelpers_MulticastDebuggerTraceHelper(QCall::ObjectHandleOnStack element, INT32 count, QCallException* qcallError) { QCALL_CONTRACT; @@ -682,7 +682,7 @@ extern "C" void QCALLTYPE StubHelpers_MulticastDebuggerTraceHelper(QCall::Object END_QCALL; } -extern "C" void QCALLTYPE StubHelpers_CreateLayoutClassMarshalStubs(QCall::TypeHandle th, PCODE* pConvertToUnmanaged, PCODE* pConvertToManaged, PCODE* pFree) +extern "C" void QCALLTYPE StubHelpers_CreateLayoutClassMarshalStubs(QCall::TypeHandle th, PCODE* pConvertToUnmanaged, PCODE* pConvertToManaged, PCODE* pFree, QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/stubhelpers.h b/src/coreclr/vm/stubhelpers.h index 33d791390844a7..87114099ae24ac 100644 --- a/src/coreclr/vm/stubhelpers.h +++ b/src/coreclr/vm/stubhelpers.h @@ -37,34 +37,34 @@ class StubHelpers FCDECL1(static DWORD, CalcVaListSize, VARARGS *varargs); }; -extern "C" void QCALLTYPE StubHelpers_CreateCustomMarshaler(MethodDesc* pMD, mdToken paramToken, TypeHandle hndManagedType, QCall::ObjectHandleOnStack retObject); +extern "C" void QCALLTYPE StubHelpers_CreateCustomMarshaler(MethodDesc* pMD, mdToken paramToken, TypeHandle hndManagedType, QCall::ObjectHandleOnStack retObject, QCallException* qcallError); #ifdef PROFILING_SUPPORTED -extern "C" void* QCALLTYPE StubHelpers_ProfilerBeginTransitionCallback(MethodDesc* pTargetMD); -extern "C" void QCALLTYPE StubHelpers_ProfilerEndTransitionCallback(MethodDesc* pTargetMD); +extern "C" void* QCALLTYPE StubHelpers_ProfilerBeginTransitionCallback(MethodDesc* pTargetMD, QCallException* qcallError); +extern "C" void QCALLTYPE StubHelpers_ProfilerEndTransitionCallback(MethodDesc* pTargetMD, QCallException* qcallError); #endif #ifdef FEATURE_COMINTEROP -extern "C" IUnknown* QCALLTYPE StubHelpers_GetCOMIPFromRCWSlow(QCall::ObjectHandleOnStack pSrc, MethodDesc* pMD, void** ppTarget, BOOL* pfNeedsRelease); +extern "C" IUnknown* QCALLTYPE StubHelpers_GetCOMIPFromRCWSlow(QCall::ObjectHandleOnStack pSrc, MethodDesc* pMD, void** ppTarget, BOOL* pfNeedsRelease, QCallException* qcallError); -extern "C" void QCALLTYPE ObjectMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pSrcUNSAFE, VARIANT* pDest); -extern "C" void QCALLTYPE ObjectMarshaler_ConvertToManaged(VARIANT* pSrc, QCall::ObjectHandleOnStack retObject); +extern "C" void QCALLTYPE ObjectMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pSrcUNSAFE, VARIANT* pDest, QCallException* qcallError); +extern "C" void QCALLTYPE ObjectMarshaler_ConvertToManaged(VARIANT* pSrc, QCall::ObjectHandleOnStack retObject, QCallException* qcallError); -extern "C" IUnknown* QCALLTYPE InterfaceMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pObjUNSAFE, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags); -extern "C" void QCALLTYPE InterfaceMarshaler_ConvertToManaged(IUnknown** ppUnk, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCall::ObjectHandleOnStack retObject); -extern "C" void QCALLTYPE InterfaceMarshaler_GetObjectForComCallableWrapperIUnknown(IUnknown* unk, QCall::ObjectHandleOnStack retObject); -extern "C" void QCALLTYPE InterfaceMarshaler_ValidateComVisibilityForIUnknown(IUnknown* unk); +extern "C" IUnknown* QCALLTYPE InterfaceMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pObjUNSAFE, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCallException* qcallError); +extern "C" void QCALLTYPE InterfaceMarshaler_ConvertToManaged(IUnknown** ppUnk, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCall::ObjectHandleOnStack retObject, QCallException* qcallError); +extern "C" void QCALLTYPE InterfaceMarshaler_GetObjectForComCallableWrapperIUnknown(IUnknown* unk, QCall::ObjectHandleOnStack retObject, QCallException* qcallError); +extern "C" void QCALLTYPE InterfaceMarshaler_ValidateComVisibilityForIUnknown(IUnknown* unk, QCallException* qcallError); #endif -extern "C" void QCALLTYPE StubHelpers_ThrowInteropParamException(INT resID, INT paramIdx); +extern "C" void QCALLTYPE StubHelpers_ThrowInteropParamException(INT resID, INT paramIdx, QCallException* qcallError); -extern "C" void QCALLTYPE StubHelpers_MarshalToManagedVaList(va_list va, VARARGS* pArgIterator); -extern "C" void QCALLTYPE StubHelpers_MarshalToUnmanagedVaList(va_list va, DWORD cbVaListSize, const VARARGS* pArgIterator); +extern "C" void QCALLTYPE StubHelpers_MarshalToManagedVaList(va_list va, VARARGS* pArgIterator, QCallException* qcallError); +extern "C" void QCALLTYPE StubHelpers_MarshalToUnmanagedVaList(va_list va, DWORD cbVaListSize, const VARARGS* pArgIterator, QCallException* qcallError); -extern "C" void QCALLTYPE StubHelpers_ValidateObject(QCall::ObjectHandleOnStack pObj, MethodDesc *pMD); -extern "C" void QCALLTYPE StubHelpers_ValidateByref(void *pByref, MethodDesc *pMD); +extern "C" void QCALLTYPE StubHelpers_ValidateObject(QCall::ObjectHandleOnStack pObj, MethodDesc *pMD, QCallException* qcallError); +extern "C" void QCALLTYPE StubHelpers_ValidateByref(void *pByref, MethodDesc *pMD, QCallException* qcallError); -extern "C" void QCALLTYPE StubHelpers_MulticastDebuggerTraceHelper(QCall::ObjectHandleOnStack element, INT32 count); +extern "C" void QCALLTYPE StubHelpers_MulticastDebuggerTraceHelper(QCall::ObjectHandleOnStack element, INT32 count, QCallException* qcallError); -extern "C" void QCALLTYPE StubHelpers_CreateLayoutClassMarshalStubs(QCall::TypeHandle th, PCODE* pConvertToUnmanaged, PCODE* pConvertToManaged, PCODE* pFree); +extern "C" void QCALLTYPE StubHelpers_CreateLayoutClassMarshalStubs(QCall::TypeHandle th, PCODE* pConvertToUnmanaged, PCODE* pConvertToManaged, PCODE* pFree, QCallException* qcallError); #endif // __STUBHELPERS_h__ diff --git a/src/coreclr/vm/tailcallhelp.cpp b/src/coreclr/vm/tailcallhelp.cpp index 92efd671e2a6d0..bb239f7c78e7f8 100644 --- a/src/coreclr/vm/tailcallhelp.cpp +++ b/src/coreclr/vm/tailcallhelp.cpp @@ -21,7 +21,7 @@ FCIMPL0(void*, TailCallHelp::GetTailCallArgBuffer) } FCIMPLEND -extern "C" void* QCALLTYPE TailCallHelp_AllocTailCallArgBufferInternal(int size) +extern "C" void* QCALLTYPE TailCallHelp_AllocTailCallArgBufferInternal(int size, QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/tailcallhelp.h b/src/coreclr/vm/tailcallhelp.h index adc626b2fdf15f..c064587abf08b5 100644 --- a/src/coreclr/vm/tailcallhelp.h +++ b/src/coreclr/vm/tailcallhelp.h @@ -47,6 +47,6 @@ class TailCallHelp static void* AllocateBlob(LoaderAllocator* alloc, const void* blob, size_t blobLen); }; -extern "C" void* QCALLTYPE TailCallHelp_AllocTailCallArgBufferInternal(int size); +extern "C" void* QCALLTYPE TailCallHelp_AllocTailCallArgBufferInternal(int size, QCallException* qcallError); #endif diff --git a/src/coreclr/vm/unsafeaccessors.cpp b/src/coreclr/vm/unsafeaccessors.cpp index 042fa4ebc1f853..f79e2e28c6a787 100644 --- a/src/coreclr/vm/unsafeaccessors.cpp +++ b/src/coreclr/vm/unsafeaccessors.cpp @@ -1172,7 +1172,7 @@ bool MethodDesc::TryGenerateUnsafeAccessor(DynamicResolver** resolver, COR_ILMET return true; } -extern "C" void* QCALLTYPE UnsafeAccessors_ResolveGenericParamToTypeHandle(MethodDesc* unsafeAccessorMethod, BOOL isMethodParam, DWORD paramIndex) +extern "C" void* QCALLTYPE UnsafeAccessors_ResolveGenericParamToTypeHandle(MethodDesc* unsafeAccessorMethod, BOOL isMethodParam, DWORD paramIndex, QCallException* qcallError) { QCALL_CONTRACT; _ASSERTE(unsafeAccessorMethod != NULL); diff --git a/src/coreclr/vm/varargsnative.cpp b/src/coreclr/vm/varargsnative.cpp index be6f771fc69c01..393add49ffb9d0 100644 --- a/src/coreclr/vm/varargsnative.cpp +++ b/src/coreclr/vm/varargsnative.cpp @@ -167,7 +167,7 @@ static void AdvanceArgPtr(VARARGS *data) // ArgIterator constructor that initializes the state to support iteration // of the args starting at the first optional argument. //////////////////////////////////////////////////////////////////////////////// -extern "C" void QCALLTYPE ArgIterator_Init(VARARGS* data, PVOID cookie) +extern "C" void QCALLTYPE ArgIterator_Init(VARARGS* data, PVOID cookie, QCallException* qcallError) { QCALL_CONTRACT; @@ -197,7 +197,7 @@ extern "C" void QCALLTYPE ArgIterator_Init(VARARGS* data, PVOID cookie) // Specifying NULL as the firstArg parameter causes it to start at the first // argument to the call. //////////////////////////////////////////////////////////////////////////////// -extern "C" void QCALLTYPE ArgIterator_Init2(VARARGS* data, PVOID cookie, PVOID firstArg) +extern "C" void QCALLTYPE ArgIterator_Init2(VARARGS* data, PVOID cookie, PVOID firstArg, QCallException* qcallError) { QCALL_CONTRACT; @@ -469,7 +469,7 @@ static void GetNextArgHelper(VARARGS* data, TypedByRef* value, BOOL fData) //////////////////////////////////////////////////////////////////////////////// // Retrieve the type of the next argument without consuming it. //////////////////////////////////////////////////////////////////////////////// -extern "C" void* QCALLTYPE ArgIterator_GetNextArgType(VARARGS* data) +extern "C" void* QCALLTYPE ArgIterator_GetNextArgType(VARARGS* data, QCallException* qcallError) { QCALL_CONTRACT; @@ -498,7 +498,7 @@ extern "C" void* QCALLTYPE ArgIterator_GetNextArgType(VARARGS* data) // Retrieve the next argument and return it in a TypedByRef and advance the // next argument pointer. //////////////////////////////////////////////////////////////////////////////// -extern "C" void QCALLTYPE ArgIterator_GetNextArg(VARARGS* data, TypedByRef* pResult) +extern "C" void QCALLTYPE ArgIterator_GetNextArg(VARARGS* data, TypedByRef* pResult, QCallException* qcallError) { QCALL_CONTRACT; @@ -514,7 +514,7 @@ extern "C" void QCALLTYPE ArgIterator_GetNextArg(VARARGS* data, TypedByRef* pRes // Retrieve the next argument and return it in a TypedByRef and advance the // next argument pointer. //////////////////////////////////////////////////////////////////////////////// -extern "C" void QCALLTYPE ArgIterator_GetNextArg2(VARARGS* data, QCall::TypeHandle pType, TypedByRef* pResult) +extern "C" void QCALLTYPE ArgIterator_GetNextArg2(VARARGS* data, QCall::TypeHandle pType, TypedByRef* pResult, QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/varargsnative.h b/src/coreclr/vm/varargsnative.h index 7ee42e02affaf9..4209dde33e0bc9 100644 --- a/src/coreclr/vm/varargsnative.h +++ b/src/coreclr/vm/varargsnative.h @@ -14,10 +14,10 @@ #include "clrvarargs.h" -extern "C" void QCALLTYPE ArgIterator_Init(VARARGS* thisPtr, PVOID cookie); -extern "C" void QCALLTYPE ArgIterator_Init2(VARARGS* thisPtr, PVOID cookie, PVOID firstArg); -extern "C" void* QCALLTYPE ArgIterator_GetNextArgType(VARARGS* thisPtr); -extern "C" void QCALLTYPE ArgIterator_GetNextArg(VARARGS* thisPtr, TypedByRef* pResult); -extern "C" void QCALLTYPE ArgIterator_GetNextArg2(VARARGS* thisPtr, QCall::TypeHandle pType, TypedByRef* pResult); +extern "C" void QCALLTYPE ArgIterator_Init(VARARGS* thisPtr, PVOID cookie, QCallException* qcallError); +extern "C" void QCALLTYPE ArgIterator_Init2(VARARGS* thisPtr, PVOID cookie, PVOID firstArg, QCallException* qcallError); +extern "C" void* QCALLTYPE ArgIterator_GetNextArgType(VARARGS* thisPtr, QCallException* qcallError); +extern "C" void QCALLTYPE ArgIterator_GetNextArg(VARARGS* thisPtr, TypedByRef* pResult, QCallException* qcallError); +extern "C" void QCALLTYPE ArgIterator_GetNextArg2(VARARGS* thisPtr, QCall::TypeHandle pType, TypedByRef* pResult, QCallException* qcallError); #endif // _VARARGSNATIVE_H_ diff --git a/src/coreclr/vm/versionresilienthashcode.cpp b/src/coreclr/vm/versionresilienthashcode.cpp index deccbde1aca8ca..846b83b2fcae48 100644 --- a/src/coreclr/vm/versionresilienthashcode.cpp +++ b/src/coreclr/vm/versionresilienthashcode.cpp @@ -450,7 +450,7 @@ bool GetVersionResilientILCodeHashCode(MethodDesc *pMD, const COR_ILMETHOD_DECOD return true; } -extern "C" INT32 VersionResilientHashCode_TypeHashCode(QCall::TypeHandle pTypeHandle) +extern "C" INT32 QCALLTYPE VersionResilientHashCode_TypeHashCode(QCall::TypeHandle pTypeHandle, QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/versionresilienthashcode.h b/src/coreclr/vm/versionresilienthashcode.h index 16898ff41027a3..a05c672f3b8881 100644 --- a/src/coreclr/vm/versionresilienthashcode.h +++ b/src/coreclr/vm/versionresilienthashcode.h @@ -14,4 +14,4 @@ int GetVersionResilientModuleHashCode(Module* pModule); bool GetVersionResilientILCodeHashCode(MethodDesc *pMD, const COR_ILMETHOD_DECODER* header, int* hashCode, unsigned* ilSize); -extern "C" INT32 VersionResilientHashCode_TypeHashCode(QCall::TypeHandle pTypeHandle); +extern "C" INT32 QCALLTYPE VersionResilientHashCode_TypeHashCode(QCall::TypeHandle pTypeHandle, QCallException* qcallError); diff --git a/src/coreclr/vm/wasm/entrypoints.h b/src/coreclr/vm/wasm/entrypoints.h index 637476db1fe6ef..ec32d573b1394a 100644 --- a/src/coreclr/vm/wasm/entrypoints.h +++ b/src/coreclr/vm/wasm/entrypoints.h @@ -22,11 +22,11 @@ extern "C" void SystemJS_DiagnosticServerQueueJob(size_t (*cb)(void *data), void // the WasiEventLoop pump when WasiFinalizer_TryClearPending returns true. // Same implementation as browser's SystemJS_ExecuteFinalizationCallback, just // exported under a WASI-specific symbol; see src/coreclr/vm/finalizerthread.cpp. -extern "C" void QCALLTYPE WasiFinalizer_RunWorker(); +extern "C" void QCALLTYPE WasiFinalizer_RunWorker(QCallException* qcallError); // Atomic-flag drain used by managed WasiEventLoop to learn whether a GC has // requested finalization since the last poll. Returns TRUE once per scheduled // finalization, FALSE otherwise. -extern "C" CLR_BOOL QCALLTYPE WasiFinalizer_TryClearPending(); +extern "C" CLR_BOOL QCALLTYPE WasiFinalizer_TryClearPending(QCallException* qcallError); #endif // TARGET_WASI #endif // HAVE_WASM_ENTRYPOINTS_H \ No newline at end of file diff --git a/src/coreclr/vm/weakreferencenative.cpp b/src/coreclr/vm/weakreferencenative.cpp index 74dcf7c1ea71d5..db690b48c07f4a 100644 --- a/src/coreclr/vm/weakreferencenative.cpp +++ b/src/coreclr/vm/weakreferencenative.cpp @@ -47,7 +47,7 @@ void FinalizeWeakReference(Object* obj) #if defined(FEATURE_COMINTEROP) -extern "C" void QCALLTYPE ComWeakRefToObject(IWeakReference* pComWeakReference, QCall::ObjectHandleOnStack retRcw) +extern "C" void QCALLTYPE ComWeakRefToObject(IWeakReference* pComWeakReference, QCall::ObjectHandleOnStack retRcw, QCallException* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -88,7 +88,7 @@ extern "C" void QCALLTYPE ComWeakRefToObject(IWeakReference* pComWeakReference, return; } -extern "C" IWeakReference * QCALLTYPE ObjectToComWeakRef(QCall::ObjectHandleOnStack obj) +extern "C" IWeakReference * QCALLTYPE ObjectToComWeakRef(QCall::ObjectHandleOnStack obj, QCallException* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/weakreferencenative.h b/src/coreclr/vm/weakreferencenative.h index df2ba1dc23e4dd..e0646511f98381 100644 --- a/src/coreclr/vm/weakreferencenative.h +++ b/src/coreclr/vm/weakreferencenative.h @@ -15,8 +15,8 @@ #ifdef FEATURE_COMINTEROP -extern "C" void QCALLTYPE ComWeakRefToObject(IWeakReference * pComWeakReference, QCall::ObjectHandleOnStack retRcw); -extern "C" IWeakReference * QCALLTYPE ObjectToComWeakRef(QCall::ObjectHandleOnStack obj); +extern "C" void QCALLTYPE ComWeakRefToObject(IWeakReference * pComWeakReference, QCall::ObjectHandleOnStack retRcw, QCallException* qcallError); +extern "C" IWeakReference * QCALLTYPE ObjectToComWeakRef(QCall::ObjectHandleOnStack obj, QCallException* qcallError); #endif // FEATURE_COMINTEROP diff --git a/src/libraries/System.Private.CoreLib/src/System/AppContext.cs b/src/libraries/System.Private.CoreLib/src/System/AppContext.cs index 289d3432db4c93..e98da2b103c95b 100644 --- a/src/libraries/System.Private.CoreLib/src/System/AppContext.cs +++ b/src/libraries/System.Private.CoreLib/src/System/AppContext.cs @@ -53,7 +53,13 @@ public static partial class AppContext if (IsKnownHostProperty(name)) { string? value = null; - if (TryGetHostPropertyValue(name, new StringHandleOnStack(ref value))) + if (TryGetHostPropertyValue(name, new StringHandleOnStack(ref value) +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + )) { lock (s_dataStore) { diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.Internal.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.Internal.cs index dfa67fe2c2c392..2e408295c81fc9 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.Internal.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.Internal.cs @@ -1,5 +1,6 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. + using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Runtime.CompilerServices; @@ -20,10 +21,22 @@ private static unsafe partial ulong Enable( EventPipeSerializationFormat format, uint circularBufferSizeInMB, EventPipeProviderConfigurationNative* providers, - uint numProviders); + uint numProviders +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_Disable")] - internal static partial void Disable(ulong sessionID); + internal static partial void Disable(ulong sessionID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); // // These PInvokes are used by EventSource to interact with the EventPipe. @@ -31,41 +44,101 @@ private static unsafe partial ulong Enable( [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_CreateProvider", StringMarshalling = StringMarshalling.Utf16)] internal static unsafe partial IntPtr CreateProvider(string providerName, delegate* unmanaged callbackFunc, - void* callbackContext); + void* callbackContext +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_DefineEvent")] - internal static unsafe partial IntPtr DefineEvent(IntPtr provHandle, uint eventID, long keywords, uint eventVersion, uint level, void *pMetadata, uint metadataLength); + internal static unsafe partial IntPtr DefineEvent(IntPtr provHandle, uint eventID, long keywords, uint eventVersion, uint level, void *pMetadata, uint metadataLength +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_GetProvider", StringMarshalling = StringMarshalling.Utf16)] - internal static partial IntPtr GetProvider(string providerName); + internal static partial IntPtr GetProvider(string providerName +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_DeleteProvider")] - internal static partial void DeleteProvider(IntPtr provHandle); + internal static partial void DeleteProvider(IntPtr provHandle +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_EventActivityIdControl")] - internal static partial int EventActivityIdControl(uint controlCode, ref Guid activityId); + internal static partial int EventActivityIdControl(uint controlCode, ref Guid activityId +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_WriteEventData")] - internal static unsafe partial void WriteEventData(IntPtr eventHandle, EventProvider.EventData* pEventData, uint dataCount, Guid* activityId, Guid* relatedActivityId); + internal static unsafe partial void WriteEventData(IntPtr eventHandle, EventProvider.EventData* pEventData, uint dataCount, Guid* activityId, Guid* relatedActivityId +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); // // These PInvokes are used as part of the EventPipeEventDispatcher. // [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_GetSessionInfo")] [return: MarshalAs(UnmanagedType.Bool)] - internal static unsafe partial bool GetSessionInfo(ulong sessionID, EventPipeSessionInfo* pSessionInfo); + internal static unsafe partial bool GetSessionInfo(ulong sessionID, EventPipeSessionInfo* pSessionInfo +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_GetNextEvent")] [return: MarshalAs(UnmanagedType.Bool)] - internal static unsafe partial bool GetNextEvent(ulong sessionID, EventPipeEventInstanceData* pInstance); + internal static unsafe partial bool GetNextEvent(ulong sessionID, EventPipeEventInstanceData* pInstance +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_SignalSession")] [return: MarshalAs(UnmanagedType.Bool)] - internal static unsafe partial bool SignalSession(ulong sessionID); + internal static unsafe partial bool SignalSession(ulong sessionID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_WaitForSessionSignal")] [return: MarshalAs(UnmanagedType.Bool)] - internal static unsafe partial bool WaitForSessionSignal(ulong sessionID, int timeoutMs); + internal static unsafe partial bool WaitForSessionSignal(ulong sessionID, int timeoutMs +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); #else #pragma warning disable IDE0060 private static unsafe ulong Enable( diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.cs index a4a2513525150b..a022b61b7c3ddb 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.cs @@ -131,7 +131,13 @@ internal static unsafe ulong Enable( fixed (char* outputFilePath = outputFile) fixed (EventPipeProviderConfigurationNative* providersNativePointer = providersNative) { - return Enable(outputFilePath, format, circularBufferSizeInMB, providersNativePointer, (uint)providersNative.Length); + return Enable(outputFilePath, format, circularBufferSizeInMB, providersNativePointer, (uint)providersNative.Length +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } } finally diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Threads.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Threads.cs index 93c7f3473c8f5f..ebbec167c960d3 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Threads.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Threads.cs @@ -1,5 +1,6 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. + using System.Collections.Generic; using System.Threading; using System.Threading.Tasks; @@ -33,7 +34,13 @@ private void DispatchEventsToEventListeners(ulong sessionID, DateTime syncTimeUt { if (!eventsReceived) { - EventPipeInternal.WaitForSessionSignal(sessionID, Timeout.Infinite); + EventPipeInternal.WaitForSessionSignal(sessionID, Timeout.Infinite +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } Thread.Sleep(10); @@ -50,7 +57,13 @@ private void DispatchEventsToEventListeners(ulong sessionID, DateTime syncTimeUt // Disable the old session. This can happen asynchronously since we aren't using the old session // anymore. - EventPipeInternal.Disable(sessionID); + EventPipeInternal.Disable(sessionID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.cs index 83911a0a13a492..573f1d7c426e1a 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.cs @@ -1,5 +1,6 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. + using System.Collections.Generic; using System.Threading; using System.Threading.Tasks; @@ -40,7 +41,13 @@ internal EventListenerSubscription(EventKeywords matchAnyKeywords, EventLevel le private EventPipeEventDispatcher() { // Get the ID of the runtime provider so that it can be used as a filter when processing events. - m_RuntimeProviderID = EventPipeInternal.GetProvider(NativeRuntimeEventSource.EventSourceName); + m_RuntimeProviderID = EventPipeInternal.GetProvider(NativeRuntimeEventSource.EventSourceName +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } internal void SendCommand(EventListener eventListener, EventCommand command, bool enable, EventLevel level, EventKeywords matchAnyKeywords) @@ -111,7 +118,13 @@ private void CommitDispatchConfiguration() EventPipeSessionInfo sessionInfo; unsafe { - if (!EventPipeInternal.GetSessionInfo(sessionID, &sessionInfo)) + if (!EventPipeInternal.GetSessionInfo(sessionID, &sessionInfo +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + )) { Debug.Fail("GetSessionInfo returned false."); } @@ -141,7 +154,13 @@ private void SetStopDispatchTask() ulong sessionID = Volatile.Read(ref m_sessionID); Debug.Assert(sessionID != 0); m_dispatchTaskCancellationSource.Cancel(); - EventPipeInternal.SignalSession(sessionID); + EventPipeInternal.SignalSession(sessionID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); Volatile.Write(ref m_sessionID, 0); } @@ -153,7 +172,13 @@ private unsafe bool DispatchEventsToEventListenersOnce(ulong sessionID, DateTime EventPipeEventInstanceData instanceData; // Get the next event. - while (!token.IsCancellationRequested && EventPipeInternal.GetNextEvent(sessionID, &instanceData)) + while (!token.IsCancellationRequested && EventPipeInternal.GetNextEvent(sessionID, &instanceData +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + )) { eventsReceived = true; diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventProvider.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventProvider.cs index 2e49aba519abbc..7c4ea276846c98 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventProvider.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventProvider.cs @@ -76,7 +76,13 @@ internal override unsafe void Register(Guid id, string name) Debug.Assert(!_gcHandle.IsAllocated); _gcHandle = new GCHandle(this); - _provHandle = EventPipeInternal.CreateProvider(name, &Callback, (void*)GCHandle.ToIntPtr(_gcHandle)); + _provHandle = EventPipeInternal.CreateProvider(name, &Callback, (void*)GCHandle.ToIntPtr(_gcHandle) +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); if (_provHandle == 0) { // Unable to create the provider. @@ -93,7 +99,13 @@ internal override void Unregister() { if (_provHandle != 0) { - EventPipeInternal.DeleteProvider(_provHandle); + EventPipeInternal.DeleteProvider(_provHandle +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); _provHandle = 0; } _gcHandle.Dispose(); @@ -112,7 +124,13 @@ internal override unsafe EventProvider.WriteEventErrorCode EventWriteTransfer( { if (userDataCount == 0) { - EventPipeInternal.WriteEventData(eventHandle, null, 0, activityId, relatedActivityId); + EventPipeInternal.WriteEventData(eventHandle, null, 0, activityId, relatedActivityId +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); return EventProvider.WriteEventErrorCode.NoError; } @@ -125,7 +143,13 @@ internal override unsafe EventProvider.WriteEventErrorCode EventWriteTransfer( userDataCount -= 3; Debug.Assert(userDataCount >= 0); } - EventPipeInternal.WriteEventData(eventHandle, userData, (uint)userDataCount, activityId, relatedActivityId); + EventPipeInternal.WriteEventData(eventHandle, userData, (uint)userDataCount, activityId, relatedActivityId +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } return EventProvider.WriteEventErrorCode.NoError; @@ -141,13 +165,25 @@ internal override int ActivityIdControl(Interop.Advapi32.ActivityControl control internal override unsafe IntPtr DefineEventHandle(uint eventID, string eventName, long keywords, uint eventVersion, uint level, byte* pMetadata, uint metadataLength) { - return EventPipeInternal.DefineEvent(_provHandle, eventID, keywords, eventVersion, level, pMetadata, metadataLength); + return EventPipeInternal.DefineEvent(_provHandle, eventID, keywords, eventVersion, level, pMetadata, metadataLength +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } // Get or set the per-thread activity ID. internal static int EventActivityIdControl(Interop.Advapi32.ActivityControl controlCode, ref Guid activityId) { - return EventPipeInternal.EventActivityIdControl((uint)controlCode, ref activityId); + return EventPipeInternal.EventActivityIdControl((uint)controlCode, ref activityId +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs index 870a12080ab499..94b9de9f1a4dac 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs @@ -10,7 +10,13 @@ internal sealed partial class NativeRuntimeEventSource : EventSource { [NonEvent] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogContentionLockCreated")] - private static partial void LogContentionLockCreated(nint LockID, nint AssociatedObjectID, ushort ClrInstanceID); + private static partial void LogContentionLockCreated(nint LockID, nint AssociatedObjectID, ushort ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [NonEvent] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogContentionStart")] @@ -19,38 +25,86 @@ private static partial void LogContentionStart( ushort ClrInstanceID, nint LockID, nint AssociatedObjectID, - ulong LockOwnerThreadID); + ulong LockOwnerThreadID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [NonEvent] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogContentionStop")] private static partial void LogContentionStop( ContentionFlagsMap ContentionFlags, ushort ClrInstanceID, - double DurationNs); + double DurationNs +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [NonEvent] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadStart")] - private static partial void LogThreadPoolWorkerThreadStart(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID); + private static partial void LogThreadPoolWorkerThreadStart(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [NonEvent] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop")] - private static partial void LogThreadPoolWorkerThreadStop(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID); + private static partial void LogThreadPoolWorkerThreadStop(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [NonEvent] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait")] - private static partial void LogThreadPoolWorkerThreadWait(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID); + private static partial void LogThreadPoolWorkerThreadWait(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [NonEvent] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolMinMaxThreads")] - private static partial void LogThreadPoolMinMaxThreads(ushort MinWorkerThreads, ushort MaxWorkerThreads, ushort MinIOCompletionThreads, ushort MaxIOCompletionThreads, ushort ClrInstanceID); + private static partial void LogThreadPoolMinMaxThreads(ushort MinWorkerThreads, ushort MaxWorkerThreads, ushort MinIOCompletionThreads, ushort MaxIOCompletionThreads, ushort ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [NonEvent] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentSample")] - private static partial void LogThreadPoolWorkerThreadAdjustmentSample(double Throughput, ushort ClrInstanceID); + private static partial void LogThreadPoolWorkerThreadAdjustmentSample(double Throughput, ushort ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [NonEvent] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentAdjustment")] - private static partial void LogThreadPoolWorkerThreadAdjustmentAdjustment(double AverageThroughput, uint NewWorkerThreadCount, ThreadAdjustmentReasonMap Reason, ushort ClrInstanceID); + private static partial void LogThreadPoolWorkerThreadAdjustmentAdjustment(double AverageThroughput, uint NewWorkerThreadCount, ThreadAdjustmentReasonMap Reason, ushort ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [NonEvent] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentStats")] @@ -65,7 +119,13 @@ private static partial void LogThreadPoolWorkerThreadAdjustmentStats( double Confidence, double NewControlSetting, ushort NewThreadWaveMagnitude, - ushort ClrInstanceID); + ushort ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [NonEvent] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolIOEnqueue")] @@ -73,37 +133,73 @@ private static partial void LogThreadPoolIOEnqueue( IntPtr NativeOverlapped, IntPtr Overlapped, [MarshalAs(UnmanagedType.Bool)] bool MultiDequeues, - ushort ClrInstanceID); + ushort ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [NonEvent] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolIODequeue")] private static partial void LogThreadPoolIODequeue( IntPtr NativeOverlapped, IntPtr Overlapped, - ushort ClrInstanceID); + ushort ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [NonEvent] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkingThreadCount")] private static partial void LogThreadPoolWorkingThreadCount( uint Count, - ushort ClrInstanceID); + ushort ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [NonEvent] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolIOPack")] private static partial void LogThreadPoolIOPack( IntPtr NativeOverlapped, IntPtr Overlapped, - ushort ClrInstanceID); + ushort ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [NonEvent] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogWaitHandleWaitStart")] private static partial void LogWaitHandleWaitStart( WaitHandleWaitSourceMap WaitSource, IntPtr AssociatedObjectID, - ushort ClrInstanceID); + ushort ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [NonEvent] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogWaitHandleWaitStop")] - private static partial void LogWaitHandleWaitStop(ushort ClrInstanceID); + private static partial void LogWaitHandleWaitStop(ushort ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.cs index 1fc333603fdd0a..1268029df94ef3 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.cs @@ -80,7 +80,13 @@ public enum WaitHandleWaitSourceMap : byte private void ContentionLockCreated(nint LockID, nint AssociatedObjectID, ushort ClrInstanceID = DefaultClrInstanceId) { Debug.Assert(IsEnabled(EventLevel.Informational, Keywords.ContentionKeyword)); - LogContentionLockCreated(LockID, AssociatedObjectID, ClrInstanceID); + LogContentionLockCreated(LockID, AssociatedObjectID, ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } [NonEvent] @@ -101,7 +107,13 @@ private void ContentionStart( ulong LockOwnerThreadID) { Debug.Assert(IsEnabled(EventLevel.Informational, Keywords.ContentionKeyword)); - LogContentionStart(ContentionFlags, ClrInstanceID, LockID, AssociatedObjectID, LockOwnerThreadID); + LogContentionStart(ContentionFlags, ClrInstanceID, LockID, AssociatedObjectID, LockOwnerThreadID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } [NonEvent] @@ -120,7 +132,13 @@ public void ContentionStart(Lock lockObj) => private void ContentionStop(ContentionFlagsMap ContentionFlags, ushort ClrInstanceID, double DurationNs) { Debug.Assert(IsEnabled(EventLevel.Informational, Keywords.ContentionKeyword)); - LogContentionStop(ContentionFlags, ClrInstanceID, DurationNs); + LogContentionStop(ContentionFlags, ClrInstanceID, DurationNs +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } [NonEvent] @@ -136,7 +154,13 @@ public void ThreadPoolWorkerThreadStart( { if (IsEnabled(EventLevel.Informational, Keywords.ThreadingKeyword)) { - LogThreadPoolWorkerThreadStart(ActiveWorkerThreadCount, RetiredWorkerThreadCount, ClrInstanceID); + LogThreadPoolWorkerThreadStart(ActiveWorkerThreadCount, RetiredWorkerThreadCount, ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } } @@ -148,7 +172,13 @@ public void ThreadPoolWorkerThreadStop( { if (IsEnabled(EventLevel.Informational, Keywords.ThreadingKeyword)) { - LogThreadPoolWorkerThreadStop(ActiveWorkerThreadCount, RetiredWorkerThreadCount, ClrInstanceID); + LogThreadPoolWorkerThreadStop(ActiveWorkerThreadCount, RetiredWorkerThreadCount, ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } } @@ -161,7 +191,13 @@ public void ThreadPoolWorkerThreadWait( { if (IsEnabled(EventLevel.Informational, Keywords.ThreadingKeyword)) { - LogThreadPoolWorkerThreadWait(ActiveWorkerThreadCount, RetiredWorkerThreadCount, ClrInstanceID); + LogThreadPoolWorkerThreadWait(ActiveWorkerThreadCount, RetiredWorkerThreadCount, ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } } @@ -174,7 +210,13 @@ public void ThreadPoolWorkerThreadAdjustmentSample( { return; } - LogThreadPoolWorkerThreadAdjustmentSample(Throughput, ClrInstanceID); + LogThreadPoolWorkerThreadAdjustmentSample(Throughput, ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } [Event(55, Level = EventLevel.Informational, Message = Messages.WorkerThreadAdjustmentAdjustment, Task = Tasks.ThreadPoolWorkerThreadAdjustment, Opcode = Opcodes.Adjustment, Version = 0, Keywords = Keywords.ThreadingKeyword)] @@ -188,7 +230,13 @@ public void ThreadPoolWorkerThreadAdjustmentAdjustment( { return; } - LogThreadPoolWorkerThreadAdjustmentAdjustment(AverageThroughput, NewWorkerThreadCount, Reason, ClrInstanceID); + LogThreadPoolWorkerThreadAdjustmentAdjustment(AverageThroughput, NewWorkerThreadCount, Reason, ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } [Event(56, Level = EventLevel.Verbose, Message = Messages.WorkerThreadAdjustmentStats, Task = Tasks.ThreadPoolWorkerThreadAdjustment, Opcode = Opcodes.Stats, Version = 0, Keywords = Keywords.ThreadingKeyword)] @@ -209,7 +257,13 @@ public void ThreadPoolWorkerThreadAdjustmentStats( { return; } - LogThreadPoolWorkerThreadAdjustmentStats(Duration, Throughput, ThreadWave, ThroughputWave, ThroughputErrorEstimate, AverageThroughputErrorEstimate, ThroughputRatio, Confidence, NewControlSetting, NewThreadWaveMagnitude, ClrInstanceID); + LogThreadPoolWorkerThreadAdjustmentStats(Duration, Throughput, ThreadWave, ThroughputWave, ThroughputErrorEstimate, AverageThroughputErrorEstimate, ThroughputRatio, Confidence, NewControlSetting, NewThreadWaveMagnitude, ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } [Event(63, Level = EventLevel.Verbose, Message = Messages.IOEnqueue, Task = Tasks.ThreadPool, Opcode = Opcodes.IOEnqueue, Version = 0, Keywords = Keywords.ThreadingKeyword | Keywords.ThreadTransferKeyword)] @@ -219,7 +273,13 @@ private void ThreadPoolIOEnqueue( bool MultiDequeues, ushort ClrInstanceID = DefaultClrInstanceId) { - LogThreadPoolIOEnqueue(NativeOverlapped, Overlapped, MultiDequeues, ClrInstanceID); + LogThreadPoolIOEnqueue(NativeOverlapped, Overlapped, MultiDequeues, ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } [NonEvent] @@ -260,7 +320,13 @@ private void ThreadPoolIODequeue( IntPtr Overlapped, // 0 if the Windows thread pool is used, the relevant info could be obtained from the NativeOverlapped* if necessary ushort ClrInstanceID = DefaultClrInstanceId) { - LogThreadPoolIODequeue(NativeOverlapped, Overlapped, ClrInstanceID); + LogThreadPoolIODequeue(NativeOverlapped, Overlapped, ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } [NonEvent] @@ -299,7 +365,13 @@ public void ThreadPoolWorkingThreadCount(uint Count, ushort ClrInstanceID = Defa { return; } - LogThreadPoolWorkingThreadCount(Count, ClrInstanceID); + LogThreadPoolWorkingThreadCount(Count, ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } [NonEvent] @@ -325,7 +397,13 @@ private void ThreadPoolIOPack( IntPtr Overlapped, // 0 if the Windows thread pool is used, the relevant info could be obtained from the NativeOverlapped* if necessary ushort ClrInstanceID = DefaultClrInstanceId) { - LogThreadPoolIOPack(NativeOverlapped, Overlapped, ClrInstanceID); + LogThreadPoolIOPack(NativeOverlapped, Overlapped, ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } @@ -339,7 +417,13 @@ public void ThreadPoolMinMaxThreads( { if (IsEnabled(EventLevel.Informational, Keywords.ThreadingKeyword)) { - LogThreadPoolMinMaxThreads(MinWorkerThreads, MaxWorkerThreads, MinIOCompletionThreads, MaxIOCompletionThreads, ClrInstanceID); + LogThreadPoolMinMaxThreads(MinWorkerThreads, MaxWorkerThreads, MinIOCompletionThreads, MaxIOCompletionThreads, ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } } @@ -350,7 +434,13 @@ private void WaitHandleWaitStart( ushort ClrInstanceID = DefaultClrInstanceId) { Debug.Assert(IsEnabled(EventLevel.Verbose, Keywords.WaitHandleKeyword)); - LogWaitHandleWaitStart(WaitSource, AssociatedObjectID, ClrInstanceID); + LogWaitHandleWaitStart(WaitSource, AssociatedObjectID, ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } [NonEvent] @@ -364,7 +454,13 @@ public void WaitHandleWaitStart( public void WaitHandleWaitStop(ushort ClrInstanceID = DefaultClrInstanceId) { Debug.Assert(IsEnabled(EventLevel.Verbose, Keywords.WaitHandleKeyword)); - LogWaitHandleWaitStop(ClrInstanceID); + LogWaitHandleWaitStop(ClrInstanceID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs index fdc303ec2db743..1b528f7029d45e 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs @@ -1,4 +1,4 @@ -// Licensed to the .NET Foundation under one or more agreements. +// Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. using System.Collections.Generic; @@ -19,10 +19,18 @@ public XplatEventLogger() { } private static readonly string s_eventSourceNameFilter = GetClrConfig("EventSourceFilter"); private static readonly string s_eventSourceEventFilter = GetClrConfig("EventNameFilter"); - private static unsafe string GetClrConfig(string configName) => new string(EventSource_GetClrConfig(configName)); + private static unsafe string GetClrConfig(string configName) => new string(EventSource_GetClrConfig(configName +#if CORECLR + , out _ +#endif + )); [LibraryImport(RuntimeHelpers.QCall, StringMarshalling = StringMarshalling.Utf16)] - private static unsafe partial char* EventSource_GetClrConfig(string configName); + private static unsafe partial char* EventSource_GetClrConfig(string configName +#if CORECLR + , out QCallException qcallException +#endif + ); private static bool initializedPersistentListener; @@ -30,7 +38,11 @@ public XplatEventLogger() { } { try { - if (!initializedPersistentListener && XplatEventLogger.IsEventSourceLoggingEnabled()) + if (!initializedPersistentListener && XplatEventLogger.IsEventSourceLoggingEnabled( +#if CORECLR + out _ +#endif + )) { initializedPersistentListener = true; return new XplatEventLogger(); @@ -43,10 +55,18 @@ public XplatEventLogger() { } [LibraryImport(RuntimeHelpers.QCall)] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool IsEventSourceLoggingEnabled(); + private static partial bool IsEventSourceLoggingEnabled( +#if CORECLR + out QCallException qcallException +#endif + ); [LibraryImport(RuntimeHelpers.QCall, StringMarshalling = StringMarshalling.Utf16)] - private static partial void LogEventSource(int eventID, string? eventName, string eventSourceName, string payload); + private static partial void LogEventSource(int eventID, string? eventName, string eventSourceName, string payload +#if CORECLR + , out QCallException qcallException +#endif + ); private static readonly List escape_seq = new List { '\b', '\f', '\n', '\r', '\t', '\"', '\\' }; private static readonly Dictionary seq_mapping = new Dictionary() @@ -195,7 +215,11 @@ private static void LogOnEventWritten(EventWrittenEventArgs eventData) } } - LogEventSource(eventData.EventId, eventData.EventName, eventData.EventSource.Name, payload); + LogEventSource(eventData.EventId, eventData.EventName, eventData.EventSource.Name, payload +#if CORECLR + , out _ +#endif + ); } } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Environment.cs b/src/libraries/System.Private.CoreLib/src/System/Environment.cs index dabc44cab4c4bf..451a290a48f07a 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Environment.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Environment.cs @@ -39,7 +39,11 @@ public readonly struct ProcessCpuUsage /// Gets whether the current machine has only a single processor. /// internal static bool IsSingleProcessor => RuntimeFeature.IsMultithreadingSupported ? ProcessorCount == 1 : true; +#if CORECLR + public static int ProcessorCount { get; } = RuntimeFeature.IsMultithreadingSupported ? GetProcessorCount(out _) : 1; +#else public static int ProcessorCount { get; } = RuntimeFeature.IsMultithreadingSupported ? GetProcessorCount() : 1; +#endif private static NullableBool s_privilegedProcess; diff --git a/src/libraries/System.Private.CoreLib/src/System/Reflection/Assembly.cs b/src/libraries/System.Private.CoreLib/src/System/Reflection/Assembly.cs index 9866c0e660c04a..b7cb69bc6cc9d0 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Reflection/Assembly.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Reflection/Assembly.cs @@ -331,7 +331,7 @@ public static Assembly LoadFile(string path) #if CORECLR if (AssemblyLoadContext.IsTracingEnabled()) { - AssemblyLoadContext.TraceAssemblyLoadFromResolveHandlerInvoked(args.Name, false, requestorPath, null); + AssemblyLoadContext.TraceAssemblyLoadFromResolveHandlerInvoked(args.Name, false, requestorPath, null, out _); } #endif // CORECLR return null; @@ -346,7 +346,7 @@ public static Assembly LoadFile(string path) #if CORECLR if (AssemblyLoadContext.IsTracingEnabled()) { - AssemblyLoadContext.TraceAssemblyLoadFromResolveHandlerInvoked(args.Name, true, requestorPath, requestedAssemblyPath); + AssemblyLoadContext.TraceAssemblyLoadFromResolveHandlerInvoked(args.Name, true, requestorPath, requestedAssemblyPath, out _); } #endif // CORECLR try diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.cs index 551f84fc1ec3e5..fd8e6e0e7b271e 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.cs @@ -478,7 +478,11 @@ internal sealed unsafe partial class ManagedObjectWrapperHolder { static ManagedObjectWrapperHolder() { +#if CORECLR + RegisterIsRootedCallback(out _); +#else RegisterIsRootedCallback(); +#endif } private readonly ManagedObjectWrapperReleaser _releaser; diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.NoCom.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.NoCom.cs index 8c7fb2e5ed09bb..04ff5af207eef1 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.NoCom.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.NoCom.cs @@ -175,7 +175,11 @@ public static int GetEndComSlot(Type t) } #pragma warning disable IDE0060 - internal static Type? GetTypeFromCLSID(Guid clsid, string? server, bool throwOnError) + internal static Type? GetTypeFromCLSID(Guid clsid, string? server, bool throwOnError +#if CORECLR + , out _ +#endif + ) { if (throwOnError) throw new PlatformNotSupportedException(SR.PlatformNotSupported_ComInterop); diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveC/ObjectiveCMarshal.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveC/ObjectiveCMarshal.cs index 44cf38cf81a131..5b955267475753 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveC/ObjectiveCMarshal.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveC/ObjectiveCMarshal.cs @@ -121,7 +121,11 @@ public static GCHandle CreateReferenceTrackingHandle( { // Defer to GetOrCreateReferenceTrackingMemory for argument/state validation. taggedMemory = GetOrCreateReferenceTrackingMemory(obj); - return GCHandle.FromIntPtr(AllocateReferenceTrackingHandle(obj)); + return GCHandle.FromIntPtr(AllocateReferenceTrackingHandle(obj +#if CORECLR + , out _ +#endif + )); } /// @@ -216,7 +220,11 @@ public static void SetMessageSendCallback(MessageSendFunction msgSendFunction, I if (msgSendFunction < MessageSendFunction.MsgSend || msgSendFunction > MessageSendFunction.MsgSendSuperStret) throw new ArgumentOutOfRangeException(nameof(msgSendFunction)); - if (!TrySetGlobalMessageSendCallback(msgSendFunction, func)) + if (!TrySetGlobalMessageSendCallback(msgSendFunction, func +#if CORECLR + , out _ +#endif + )) throw new InvalidOperationException(SR.InvalidOperation_ResetGlobalObjectiveCMsgSend); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/TypeMapLazyDictionary.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/TypeMapLazyDictionary.cs index 8ac8130065b09c..9f64de489bf780 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/TypeMapLazyDictionary.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/TypeMapLazyDictionary.cs @@ -88,13 +88,31 @@ private static unsafe partial void ProcessAttributes( delegate* unmanaged newProxyTypeEntry, delegate* unmanaged newPrecachedExternalTypeMap, delegate* unmanaged newPrecachedProxyTypeMap, - CallbackContext* context); + CallbackContext* context +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeMapLazyDictionary_FindPrecachedExternalTypeMapEntry", StringMarshalling = StringMarshalling.Utf8)] - private static unsafe partial IntPtr FindPrecachedExternalTypeMapEntry(QCallModule module, QCallTypeHandle groupType, string key); + private static unsafe partial IntPtr FindPrecachedExternalTypeMapEntry(QCallModule module, QCallTypeHandle groupType, string key +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeMapLazyDictionary_FindPrecachedProxyTypeMapEntry")] - private static unsafe partial IntPtr FindPrecachedProxyTypeMapEntry(QCallModule module, QCallTypeHandle groupType, QCallTypeHandle type); + private static unsafe partial IntPtr FindPrecachedProxyTypeMapEntry(QCallModule module, QCallTypeHandle groupType, QCallTypeHandle type +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); public ref struct Utf16SharedBuffer { @@ -264,7 +282,13 @@ private static unsafe CallbackContext CreateMaps( newProxyTypeEntry, &NewPrecachedExternalTypeMap, &NewPrecachedProxyTypeMap, - &context); + &context +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); // If an exception was thrown during the processing of // the attributes, rethrow it. @@ -409,7 +433,13 @@ private sealed class LazyExternalTypeDictionary : LazyTypeLoadDictionary protected override bool TryGetOrLoadTypeFromPreCachedDictionary(RuntimeModule module, string key, [NotNullWhen(true)] out Type? type) { - IntPtr handle = FindPrecachedExternalTypeMapEntry(new QCallModule(ref module), new QCallTypeHandle(ref _groupType), key); + IntPtr handle = FindPrecachedExternalTypeMapEntry(new QCallModule(ref module), new QCallTypeHandle(ref _groupType), key +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); type = RuntimeTypeHandle.GetRuntimeTypeFromHandleMaybeNull(handle); return type != null; } @@ -484,7 +514,13 @@ public void Add(SourceProxyPair newEntryMaybe) protected override bool TryGetOrLoadTypeFromPreCachedDictionary(RuntimeModule module, Type key, [NotNullWhen(true)] out Type? type) { RuntimeType rtKey = (RuntimeType)key; - IntPtr handle = FindPrecachedProxyTypeMapEntry(new QCallModule(ref module), new QCallTypeHandle(ref _groupType), new QCallTypeHandle(ref rtKey)); + IntPtr handle = FindPrecachedProxyTypeMapEntry(new QCallModule(ref module), new QCallTypeHandle(ref _groupType), new QCallTypeHandle(ref rtKey) +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); type = RuntimeTypeHandle.GetRuntimeTypeFromHandleMaybeNull(handle); return type != null; } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.cs index 805cd0544cceb4..5bd113ef92a22e 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.cs @@ -117,13 +117,20 @@ internal X64() { } public static unsafe (int Eax, int Ebx, int Ecx, int Edx) CpuId(int functionId, int subFunctionId) { int* cpuInfo = stackalloc int[4]; +#if CORECLR + CpuId(cpuInfo, functionId, subFunctionId, out _); +#else CpuId(cpuInfo, functionId, subFunctionId); +#endif return (cpuInfo[0], cpuInfo[1], cpuInfo[2], cpuInfo[3]); } #if MONO [MethodImplAttribute(MethodImplOptions.InternalCall)] private static extern unsafe void CpuId(int* cpuInfo, int functionId, int subFunctionId); +#elif CORECLR + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "X86Base_CpuId")] + private static unsafe partial void CpuId(int* cpuInfo, int functionId, int subFunctionId, out QCallException qcallException); #else [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "X86Base_CpuId")] private static unsafe partial void CpuId(int* cpuInfo, int functionId, int subFunctionId); diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.cs index 8064d2a46a7bd1..07e9f4149d33b6 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.cs @@ -101,7 +101,13 @@ private protected AssemblyLoadContext(bool representsTPALoadContext, bool isColl // If this is a collectible ALC, we are creating a weak handle tracking resurrection otherwise we use a strong handle var thisHandle = GCHandle.Alloc(this, IsCollectible ? GCHandleType.WeakTrackResurrection : GCHandleType.Normal); var thisHandlePtr = GCHandle.ToIntPtr(thisHandle); - _nativeAssemblyLoadContext = InitializeAssemblyLoadContext(thisHandlePtr, representsTPALoadContext, isCollectible); + _nativeAssemblyLoadContext = InitializeAssemblyLoadContext(thisHandlePtr, representsTPALoadContext, isCollectible +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); // Add this instance to the list of alive ALC Dictionary> allContexts = AllContexts; @@ -149,7 +155,13 @@ private void InitiateUnload() var thisStrongHandlePtr = GCHandle.ToIntPtr(thisStrongHandle); // The underlying code will transform the original weak handle // created by InitializeLoadContext to a strong handle - PrepareForAssemblyLoadContextRelease(_nativeAssemblyLoadContext, thisStrongHandlePtr); + PrepareForAssemblyLoadContextRelease(_nativeAssemblyLoadContext, thisStrongHandlePtr +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); _state = InternalState.Unloading; } @@ -667,7 +679,13 @@ public void Dispose() handler.Method.DeclaringType is Type declaringType ? $"{declaringType.FullName}.{handler.Method.Name}" : handler.Method.Name, this != Default ? ToString() : Name, resolvedAssembly?.FullName, - resolvedAssembly != null && !resolvedAssembly.IsDynamic ? resolvedAssembly.Location : null); + resolvedAssembly != null && !resolvedAssembly.IsDynamic ? resolvedAssembly.Location : null +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } #endif // CORECLR if (resolvedAssembly != null) @@ -763,7 +781,13 @@ internal static void InvokeAssemblyLoadEvent(Assembly assembly) name, handler.Method.DeclaringType is Type declaringType ? $"{declaringType.FullName}.{handler.Method.Name}" : handler.Method.Name, asm?.FullName, - asm != null && !asm.IsDynamic ? asm.Location : null); + asm != null && !asm.IsDynamic ? asm.Location : null +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } #endif // CORECLR RuntimeAssembly? ret = GetRuntimeAssembly(asm); @@ -926,7 +950,13 @@ private static unsafe void ResolveUsingEvent(IntPtr gchAssemblyLoadContext, Asse #if CORECLR if (IsTracingEnabled()) { - TraceSatelliteSubdirectoryPathProbed(assemblyPath, HResults.COR_E_FILENOTFOUND); + TraceSatelliteSubdirectoryPathProbed(assemblyPath, HResults.COR_E_FILENOTFOUND +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } #endif // CORECLR assemblyPath = Path.Combine(parentDirectory, assemblyName.CultureName!.ToLowerInvariant(), $"{assemblyName.Name}.dll"); @@ -937,7 +967,13 @@ private static unsafe void ResolveUsingEvent(IntPtr gchAssemblyLoadContext, Asse #if CORECLR if (IsTracingEnabled()) { - TraceSatelliteSubdirectoryPathProbed(assemblyPath, exists ? HResults.S_OK : HResults.COR_E_FILENOTFOUND); + TraceSatelliteSubdirectoryPathProbed(assemblyPath, exists ? HResults.S_OK : HResults.COR_E_FILENOTFOUND +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } #endif // CORECLR diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Interlocked.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Interlocked.cs index dfa92e8b9381e1..7eb2f779627ebe 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Interlocked.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Interlocked.cs @@ -868,11 +868,20 @@ ref Unsafe.As(ref location1), #if !MONO #region MemoryBarrierProcessWide +#if CORECLR + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Interlocked_MemoryBarrierProcessWide")] + private static partial void _MemoryBarrierProcessWide(out QCallException qcallException); +#else [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Interlocked_MemoryBarrierProcessWide")] private static partial void _MemoryBarrierProcessWide(); +#endif /// Provides a process-wide memory barrier that ensures that reads and writes from any CPU cannot move across the barrier. +#if CORECLR + public static void MemoryBarrierProcessWide() => _MemoryBarrierProcessWide(out _); +#else public static void MemoryBarrierProcessWide() => _MemoryBarrierProcessWide(); +#endif #endregion #endif } diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Lock.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Lock.cs index bf3a2a70ec5b60..81d6f57369fd14 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Lock.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Lock.cs @@ -875,7 +875,11 @@ private static bool TryInitializeStatics() // Not using Environment.ProcessorCount here as it involves class construction, and if that property is // already being constructed earlier in the stack on the same thread, it would return the default value // here. Initialize s_isSingleProcessor first, as it may be used by other initialization afterwards. +#if CORECLR + s_isSingleProcessor = Environment.GetProcessorCount(out _) == 1; +#else s_isSingleProcessor = Environment.GetProcessorCount() == 1; +#endif s_maxSpinCount = DetermineMaxSpinCount(); s_minSpinCountForAdaptiveSpin = DetermineMinSpinCountForAdaptiveSpin(); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.cs index ea1a24b625f4fd..d07823a37e99f6 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.cs @@ -376,7 +376,11 @@ public static void Sleep(int millisecondsTimeout) #if !NATIVEAOT /// Returns the operating system identifier for the current thread. - internal static ulong CurrentOSThreadId => GetCurrentOSThreadId(); + internal static ulong CurrentOSThreadId => GetCurrentOSThreadId( +#if CORECLR + out _ +#endif + ); #endif #if !MONO diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.Windows.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.Windows.cs index 18373595f96c3c..7ad7c9e9354bdc 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.Windows.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.Windows.cs @@ -65,7 +65,13 @@ private static unsafe int WaitForMultipleObjectsIgnoringSyncContext(IntPtr* pHan if (reentrantWait) { Debug.Assert(!waitAll); - result = Thread.ReentrantWaitAny(true, millisecondsTimeout, numHandles, pHandles); + result = Thread.ReentrantWaitAny(true, millisecondsTimeout, numHandles, pHandles +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } else { diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiFinalizerScheduler.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiFinalizerScheduler.cs index a1bcc6631e3988..af443c656c677a 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiFinalizerScheduler.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiFinalizerScheduler.cs @@ -23,16 +23,32 @@ internal static void DrainIfPending() { } #else [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "WasiFinalizer_TryClearPending")] [return: MarshalAs(UnmanagedType.Bool)] - internal static partial bool TryClearPendingFinalization(); + internal static partial bool TryClearPendingFinalization( +#if CORECLR + out QCallException qcallException +#endif + ); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "WasiFinalizer_RunWorker")] - internal static partial void ExecuteFinalizationCallback(); + internal static partial void ExecuteFinalizationCallback( +#if CORECLR + out QCallException qcallException +#endif + ); internal static void DrainIfPending() { - if (TryClearPendingFinalization()) + if (TryClearPendingFinalization( +#if CORECLR + out _ +#endif + )) { - ExecuteFinalizationCallback(); + ExecuteFinalizationCallback( +#if CORECLR + out _ +#endif + ); } } #endif From 01c1f904c869b8e99ea173d9c0c0ea74503f8459 Mon Sep 17 00:00:00 2001 From: David Wrighton Date: Mon, 17 Aug 2026 10:27:19 -0700 Subject: [PATCH 03/23] Limit QCall exception arguments to wrapped calls Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 97d405de-8e39-4e76-afe4-2f94b74ecfa2 --- .../src/System/Diagnostics/Debugger.cs | 8 +++---- .../src/System/Reflection/MdImport.cs | 6 ++--- .../src/System/Threading/Thread.CoreCLR.cs | 10 ++++---- src/coreclr/runtime/MiscNativeHelpers.cpp | 12 ++-------- src/coreclr/runtime/MiscNativeHelpers.h | 16 ++----------- src/coreclr/vm/comsynchronizable.cpp | 22 +----------------- src/coreclr/vm/comsynchronizable.h | 3 +-- src/coreclr/vm/debugdebugger.cpp | 23 ++++++------------- src/coreclr/vm/debugdebugger.h | 4 ++-- src/coreclr/vm/managedmdimport.cpp | 3 +-- src/coreclr/vm/managedmdimport.hpp | 3 +-- src/coreclr/vm/qcallentrypoints.cpp | 1 - .../System/Runtime/Intrinsics/X86/X86Base.cs | 7 ------ .../src/System/Threading/Interlocked.cs | 9 -------- 14 files changed, 28 insertions(+), 99 deletions(-) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs index e7de3f6f5a7efe..8c6dc0d38cee7f 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs @@ -23,7 +23,7 @@ public static partial class Debugger // Launch launches & attaches a debugger to the process. If a debugger is already attached, // nothing happens. // - public static bool Launch() => IsAttached || LaunchInternal(out _); + public static bool Launch() => IsAttached || LaunchInternal(); // This class implements code:ICustomDebuggerNotification and provides a type to be used to notify // the debugger that execution is about to enter a path that involves a cross-thread dependency. @@ -56,7 +56,7 @@ static void NotifyOfCrossThreadDependencySlow() [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DebugDebugger_Launch")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool LaunchInternal(out QCallException qcallException); + private static partial bool LaunchInternal(); // Returns whether or not a managed debugger is attached to the process. public static bool IsAttached => IsManagedDebuggerAttached() != 0; @@ -68,10 +68,10 @@ static void NotifyOfCrossThreadDependencySlow() // Posts a message for the attached debugger. If there is no // debugger attached, has no effect. The debugger may or may not // report the message depending on its settings. - public static void Log(int level, string? category, string? message) => LogInternal(level, category, message, out _); + public static void Log(int level, string? category, string? message) => LogInternal(level, category, message); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DebugDebugger_Log", StringMarshalling = StringMarshalling.Utf16)] - private static partial void LogInternal(int level, string? category, string? message, out QCallException qcallException); + private static partial void LogInternal(int level, string? category, string? message); // Checks to see if an attached debugger has logging enabled public static bool IsLogging() => IsLoggingInternal() != 0; diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs index 74bca408680722..e3f6823d5c9fd8 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs @@ -244,8 +244,7 @@ private static unsafe partial bool GetMarshalAs( out int marshalTypeLength, out byte* marshalCookie, out int marshalCookieLength, - out int iidParamIndex, - out QCallException qcallException); + out int iidParamIndex); internal static unsafe MarshalAsAttribute GetMarshalAs(ConstArray nativeType, RuntimeModule scope) { @@ -263,8 +262,7 @@ internal static unsafe MarshalAsAttribute GetMarshalAs(ConstArray nativeType, Ru out int marshalTypeLength, out byte* marshalCookieRaw, out int marshalCookieLength, - out int iidParamIndex, - out _)) + out int iidParamIndex)) { throw new BadImageFormatException(); } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs index c47c118db9404a..fc50ca290daaea 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs @@ -143,11 +143,11 @@ private static unsafe void StartCallback(Thread* pThread) [SuppressGCTransition] private static partial void SpinWaitInternal(int iterations); - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_LongSpinWait")] - private static partial void LongSpinWaitInternal(int iterations, out QCallException qcallException); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_SpinWait")] + private static partial void LongSpinWaitInternal(int iterations); [MethodImpl(MethodImplOptions.NoInlining)] // Slow path method. Make sure that the caller frame does not pay for PInvoke overhead. - private static void LongSpinWait(int iterations) => LongSpinWaitInternal(iterations, out _); + private static void LongSpinWait(int iterations) => LongSpinWaitInternal(iterations); /// /// Wait for a length of time proportional to 'iterations'. Each iteration is should @@ -557,7 +557,7 @@ private void ResetFinalizerThreadSlow() private static extern bool CatchAtSafePoint(); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_PollGC")] - private static partial void PollGCInternal(out QCallException qcallException); + private static partial void PollGCInternal(); // GC Suspension is done by simply dropping into native code via p/invoke, and we reuse the p/invoke // mechanism for suspension. On all architectures we should have the actual stub used for the check be implemented @@ -570,7 +570,7 @@ private static void PollGC() } [MethodImpl(MethodImplOptions.NoInlining)] - static void PollGCWorker() => PollGCInternal(out _); + static void PollGCWorker() => PollGCInternal(); } #if TARGET_UNIX || TARGET_BROWSER || TARGET_WASI diff --git a/src/coreclr/runtime/MiscNativeHelpers.cpp b/src/coreclr/runtime/MiscNativeHelpers.cpp index b5390ecbaf2221..df438c42127ac7 100644 --- a/src/coreclr/runtime/MiscNativeHelpers.cpp +++ b/src/coreclr/runtime/MiscNativeHelpers.cpp @@ -7,21 +7,13 @@ #include #if defined(TARGET_X86) || defined(TARGET_AMD64) -extern "C" void QCALLTYPE X86Base_CpuId(int cpuInfo[4], int functionId, int subFunctionId -#ifndef TARGET_NATIVEAOT - , QCallException* qcallError -#endif -) +extern "C" void QCALLTYPE X86Base_CpuId(int cpuInfo[4], int functionId, int subFunctionId) { __cpuidex(cpuInfo, functionId, subFunctionId); } #endif // defined(TARGET_X86) || defined(TARGET_AMD64) -extern "C" void QCALLTYPE Interlocked_MemoryBarrierProcessWide( -#ifndef TARGET_NATIVEAOT - QCallException* qcallError -#endif -) +extern "C" void QCALLTYPE Interlocked_MemoryBarrierProcessWide() { minipal_memory_barrier_process_wide(); } diff --git a/src/coreclr/runtime/MiscNativeHelpers.h b/src/coreclr/runtime/MiscNativeHelpers.h index aceea693ae8026..4d1a5aecbd6093 100644 --- a/src/coreclr/runtime/MiscNativeHelpers.h +++ b/src/coreclr/runtime/MiscNativeHelpers.h @@ -4,23 +4,11 @@ #ifndef __MISCNATIVEHELPERS_H__ #define __MISCNATIVEHELPERS_H__ -#ifndef TARGET_NATIVEAOT -struct QCallException; -#endif - #if defined(TARGET_X86) || defined(TARGET_AMD64) -extern "C" void QCALLTYPE X86Base_CpuId(int cpuInfo[4], int functionId, int subFunctionId -#ifndef TARGET_NATIVEAOT - , QCallException* qcallError -#endif -); +extern "C" void QCALLTYPE X86Base_CpuId(int cpuInfo[4], int functionId, int subFunctionId); #endif // defined(TARGET_X86) || defined(TARGET_AMD64) -extern "C" void QCALLTYPE Interlocked_MemoryBarrierProcessWide( -#ifndef TARGET_NATIVEAOT - QCallException* qcallError -#endif -); +extern "C" void QCALLTYPE Interlocked_MemoryBarrierProcessWide(); // WASM-TODO: once we have R2R stack walking working we should be able to set pTransitionBlock to &transitionBlock unconditionally diff --git a/src/coreclr/vm/comsynchronizable.cpp b/src/coreclr/vm/comsynchronizable.cpp index f7dda51fa147f6..b492ce0dbf76a4 100644 --- a/src/coreclr/vm/comsynchronizable.cpp +++ b/src/coreclr/vm/comsynchronizable.cpp @@ -747,20 +747,6 @@ extern "C" void QCALLTYPE ThreadNative_SpinWait(INT32 iterations) YieldProcessorNormalized(iterations); } -extern "C" void QCALLTYPE ThreadNative_LongSpinWait(INT32 iterations, QCallException* qcallError) -{ - QCALL_CONTRACT; - - BEGIN_QCALL; - - if (iterations > 0) - { - YieldProcessorNormalized(iterations); - } - - END_QCALL; -} - #ifdef TARGET_WINDOWS // This service can be called on unstarted and dead threads. For unstarted ones, the // next wait will be interrupted. For dead ones, this service quietly does nothing. @@ -806,16 +792,10 @@ extern "C" void QCALLTYPE ThreadNative_DisableComObjectEagerCleanup(QCall::Threa } #endif //FEATURE_COMINTEROP -extern "C" void QCALLTYPE ThreadNative_PollGC(QCallException* qcallError) +extern "C" void QCALLTYPE ThreadNative_PollGC() { - QCALL_CONTRACT; - - BEGIN_QCALL; - // This is an intentional no-op. The call is made to ensure that the thread goes through a GC transition // and is thus marked as a GC safe point, and that the p/invoke rare path will kick in - - END_QCALL; } extern "C" BOOL QCALLTYPE ThreadNative_YieldThread(QCallException* qcallError) diff --git a/src/coreclr/vm/comsynchronizable.h b/src/coreclr/vm/comsynchronizable.h index 6a5a039a2b9e61..f3d0e39d2d87d1 100644 --- a/src/coreclr/vm/comsynchronizable.h +++ b/src/coreclr/vm/comsynchronizable.h @@ -55,7 +55,7 @@ extern "C" BOOL QCALLTYPE ThreadNative_GetIsBackground(QCall::ThreadHandle threa extern "C" void QCALLTYPE ThreadNative_SetIsBackground(QCall::ThreadHandle thread, BOOL value, QCallException* qcallError); extern "C" void QCALLTYPE ThreadNative_InformThreadNameChange(QCall::ThreadHandle thread, LPCWSTR name, INT32 len, QCallException* qcallError); extern "C" BOOL QCALLTYPE ThreadNative_YieldThread(QCallException* qcallError); -extern "C" void QCALLTYPE ThreadNative_PollGC(QCallException* qcallError); +extern "C" void QCALLTYPE ThreadNative_PollGC(); extern "C" UINT64 QCALLTYPE ThreadNative_GetCurrentOSThreadId(QCallException* qcallError); extern "C" void QCALLTYPE ThreadNative_Initialize(QCall::ObjectHandleOnStack t, QCallException* qcallError); extern "C" INT32 QCALLTYPE ThreadNative_GetThreadState(QCall::ThreadHandle thread); @@ -79,7 +79,6 @@ extern "C" HANDLE QCALLTYPE ThreadNative_GetOSHandle(QCall::ThreadHandle t, QCal extern "C" void QCALLTYPE ThreadNative_Abort(QCall::ThreadHandle thread, QCallException* qcallError); extern "C" void QCALLTYPE ThreadNative_ResetAbort(); extern "C" void QCALLTYPE ThreadNative_SpinWait(INT32 iterations); -extern "C" void QCALLTYPE ThreadNative_LongSpinWait(INT32 iterations, QCallException* qcallError); #ifdef FEATURE_COMINTEROP extern "C" void QCALLTYPE ThreadNative_DisableComObjectEagerCleanup(QCall::ThreadHandle thread); #endif // FEATURE_COMINTEROP diff --git a/src/coreclr/vm/debugdebugger.cpp b/src/coreclr/vm/debugdebugger.cpp index e5dc79c4f6fa1e..ab853bf458b369 100644 --- a/src/coreclr/vm/debugdebugger.cpp +++ b/src/coreclr/vm/debugdebugger.cpp @@ -83,29 +83,24 @@ extern "C" void QCALLTYPE DebugDebugger_Break(QCallException* qcallError) #endif // DEBUGGING_SUPPORTED } -extern "C" BOOL QCALLTYPE DebugDebugger_Launch(QCallException* qcallError) +extern "C" BOOL QCALLTYPE DebugDebugger_Launch() { QCALL_CONTRACT; - BOOL ret = FALSE; - - BEGIN_QCALL; - #ifdef DEBUGGING_SUPPORTED if (CORDebuggerAttached()) { - ret = TRUE; + return TRUE; } - else if (g_pDebugInterface != NULL) + + if (g_pDebugInterface != NULL) { HRESULT hr = g_pDebugInterface->LaunchDebuggerForUser(GetThread(), NULL, TRUE, TRUE); - ret = SUCCEEDED(hr); + return SUCCEEDED(hr); } #endif // DEBUGGING_SUPPORTED - END_QCALL; - - return ret; + return FALSE; } // Log to managed debugger. @@ -113,7 +108,7 @@ extern "C" BOOL QCALLTYPE DebugDebugger_Launch(QCallException* qcallError) // appending a newline to anything. // It will also call OutputDebugString() which will send a native debug event. The message // string there will be a composite of the two managed string parameters and may include a newline. -extern "C" void QCALLTYPE DebugDebugger_Log(INT32 Level, PCWSTR pwzModule, PCWSTR pwzMessage, QCallException* qcallError) +extern "C" void QCALLTYPE DebugDebugger_Log(INT32 Level, PCWSTR pwzModule, PCWSTR pwzMessage) { CONTRACTL { @@ -123,8 +118,6 @@ extern "C" void QCALLTYPE DebugDebugger_Log(INT32 Level, PCWSTR pwzModule, PCWST } CONTRACTL_END; - BEGIN_QCALL; - // OutputDebugString will log to native/interop debugger. if (pwzModule != NULL) { @@ -182,8 +175,6 @@ extern "C" void QCALLTYPE DebugDebugger_Log(INT32 Level, PCWSTR pwzModule, PCWST } #endif // DEBUGGING_SUPPORTED - - END_QCALL; } static StackWalkAction GetStackFramesCallback(CrawlFrame* pCf, VOID* data) diff --git a/src/coreclr/vm/debugdebugger.h b/src/coreclr/vm/debugdebugger.h index 9de53e172dbce7..4eb9d455267cfd 100644 --- a/src/coreclr/vm/debugdebugger.h +++ b/src/coreclr/vm/debugdebugger.h @@ -14,8 +14,8 @@ #include extern "C" void QCALLTYPE DebugDebugger_Break(QCallException* qcallError); -extern "C" BOOL QCALLTYPE DebugDebugger_Launch(QCallException* qcallError); -extern "C" void QCALLTYPE DebugDebugger_Log(INT32 Level, PCWSTR pwzModule, PCWSTR pwzMessage, QCallException* qcallError); +extern "C" BOOL QCALLTYPE DebugDebugger_Launch(); +extern "C" void QCALLTYPE DebugDebugger_Log(INT32 Level, PCWSTR pwzModule, PCWSTR pwzMessage); extern "C" void QCALLTYPE DebugDebugger_CustomNotification(QCall::ObjectHandleOnStack data, QCallException* qcallError); extern "C" BOOL QCALLTYPE DebugDebugger_IsLoggingHelper(); extern "C" BOOL QCALLTYPE DebugDebugger_IsManagedDebuggerAttached(); diff --git a/src/coreclr/vm/managedmdimport.cpp b/src/coreclr/vm/managedmdimport.cpp index 6783d171266f9a..85dfbf5e222291 100644 --- a/src/coreclr/vm/managedmdimport.cpp +++ b/src/coreclr/vm/managedmdimport.cpp @@ -26,8 +26,7 @@ extern "C" BOOL QCALLTYPE MetadataImport_GetMarshalAs( INT32* marshalTypeLength, LPUTF8* marshalCookie, INT32* marshalCookieLength, - INT32* iidParamIndex, - QCallException* qcallError) + INT32* iidParamIndex) { CONTRACTL { diff --git a/src/coreclr/vm/managedmdimport.hpp b/src/coreclr/vm/managedmdimport.hpp index d7d91515d8be33..0ed23a3fcc517d 100644 --- a/src/coreclr/vm/managedmdimport.hpp +++ b/src/coreclr/vm/managedmdimport.hpp @@ -70,8 +70,7 @@ extern "C" BOOL QCALLTYPE MetadataImport_GetMarshalAs( INT32* marshalTypeLength, LPUTF8* marshalCookie, INT32* marshalCookieLength, - INT32* iidParamIndex, - QCallException* qcallError); + INT32* iidParamIndex); extern "C" void QCALLTYPE MetadataImport_Enum( IMDInternalImport* pScope, diff --git a/src/coreclr/vm/qcallentrypoints.cpp b/src/coreclr/vm/qcallentrypoints.cpp index f6e706ff9a15e9..41e7624c50466f 100644 --- a/src/coreclr/vm/qcallentrypoints.cpp +++ b/src/coreclr/vm/qcallentrypoints.cpp @@ -317,7 +317,6 @@ static const Entry s_QCall[] = DllImportEntry(ThreadNative_Abort) DllImportEntry(ThreadNative_ResetAbort) DllImportEntry(ThreadNative_SpinWait) - DllImportEntry(ThreadNative_LongSpinWait) #ifdef TARGET_WINDOWS DllImportEntry(ThreadNative_CheckForPendingInterrupt) DllImportEntry(ThreadNative_Interrupt) diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.cs index 5bd113ef92a22e..805cd0544cceb4 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.cs @@ -117,20 +117,13 @@ internal X64() { } public static unsafe (int Eax, int Ebx, int Ecx, int Edx) CpuId(int functionId, int subFunctionId) { int* cpuInfo = stackalloc int[4]; -#if CORECLR - CpuId(cpuInfo, functionId, subFunctionId, out _); -#else CpuId(cpuInfo, functionId, subFunctionId); -#endif return (cpuInfo[0], cpuInfo[1], cpuInfo[2], cpuInfo[3]); } #if MONO [MethodImplAttribute(MethodImplOptions.InternalCall)] private static extern unsafe void CpuId(int* cpuInfo, int functionId, int subFunctionId); -#elif CORECLR - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "X86Base_CpuId")] - private static unsafe partial void CpuId(int* cpuInfo, int functionId, int subFunctionId, out QCallException qcallException); #else [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "X86Base_CpuId")] private static unsafe partial void CpuId(int* cpuInfo, int functionId, int subFunctionId); diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Interlocked.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Interlocked.cs index 7eb2f779627ebe..dfa92e8b9381e1 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Interlocked.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Interlocked.cs @@ -868,20 +868,11 @@ ref Unsafe.As(ref location1), #if !MONO #region MemoryBarrierProcessWide -#if CORECLR - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Interlocked_MemoryBarrierProcessWide")] - private static partial void _MemoryBarrierProcessWide(out QCallException qcallException); -#else [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Interlocked_MemoryBarrierProcessWide")] private static partial void _MemoryBarrierProcessWide(); -#endif /// Provides a process-wide memory barrier that ensures that reads and writes from any CPU cannot move across the barrier. -#if CORECLR - public static void MemoryBarrierProcessWide() => _MemoryBarrierProcessWide(out _); -#else public static void MemoryBarrierProcessWide() => _MemoryBarrierProcessWide(); -#endif #endregion #endif } From 47190b922cd3932663d42f058aca1edf9652ac98 Mon Sep 17 00:00:00 2001 From: David Wrighton Date: Mon, 17 Aug 2026 13:25:36 -0700 Subject: [PATCH 04/23] Remove excess use of current thread static --- src/coreclr/vm/excep.cpp | 20 +++++++++++++++-- src/coreclr/vm/exceptionhandling.cpp | 5 +++++ src/coreclr/vm/exceptmacros.h | 30 ++++++++++++------------- src/coreclr/vm/reflectioninvocation.cpp | 1 + 4 files changed, 39 insertions(+), 17 deletions(-) diff --git a/src/coreclr/vm/excep.cpp b/src/coreclr/vm/excep.cpp index 7fa1a7f6eb18c1..a9e876687ea0c1 100644 --- a/src/coreclr/vm/excep.cpp +++ b/src/coreclr/vm/excep.cpp @@ -6654,7 +6654,9 @@ void UnwindAndContinueRethrowHelperInsideCatch(Frame* pEntryFrame, Exception* pE // This does the work of the Unwind and Continue Hanlder inside the catch clause of that handler. The stack has not // been unwound when this is called. Keep that in mind when deciding where to put new code :) // -void UnwindAndContinueRethrowHelperInsideQcallCatch(Frame* pEntryFrame, Exception* pException, QCallException* pQCallException) +void UnwindAndContinueRethrowHelperInsideQcallCatch( + Exception* pException, + QCallException* pQCallException DEBUG_ARG(Frame* pEntryFrame)) { STATIC_CONTRACT_NOTHROW; STATIC_CONTRACT_GC_TRIGGERS; @@ -6662,6 +6664,20 @@ void UnwindAndContinueRethrowHelperInsideQcallCatch(Frame* pEntryFrame, Exceptio Thread* pThread = GetThread(); + // The native exception unwind can leave stale entries below the current stack pointer + // on the Frame chain. Find the first enclosing InlinedCallFrame without inspecting them. + Frame* pCurrentSP = static_cast(GetCurrentSP()); + Frame* pInlinedCallFrame = pThread->GetFrame(); + while ((pInlinedCallFrame != FRAME_TOP) && + ((pInlinedCallFrame < pCurrentSP) || + (pInlinedCallFrame->GetFrameIdentifier() != FrameIdentifier::InlinedCallFrame))) + { + pInlinedCallFrame = pInlinedCallFrame->PtrNextFrame(); + } + + _ASSERTE(pInlinedCallFrame != FRAME_TOP); + _ASSERTE(pInlinedCallFrame == pEntryFrame); + GCX_COOP(); LOG((LF_EH, LL_INFO1000, "UNWIND_AND_CONTINUE inside catch, unwinding frame chain\n")); @@ -6674,7 +6690,7 @@ void UnwindAndContinueRethrowHelperInsideQcallCatch(Frame* pEntryFrame, Exceptio // policy here. Do we want to let such functions throw, etc.? Right now, we believe that there are no such // frames on the stack to be unwound, so the SetFrame is alright (see the first comment above.) At the very // least, we should add some way to assert that. - pThread->SetFrame(pEntryFrame); + pThread->SetFrame(pInlinedCallFrame); // Call CLRException::GetThrowableFromException to force us to retrieve the THROWABLE // while we are still within the context of the catch block. This will help diagnose diff --git a/src/coreclr/vm/exceptionhandling.cpp b/src/coreclr/vm/exceptionhandling.cpp index 9d6f74c682e949..d8e536ccf7c59e 100644 --- a/src/coreclr/vm/exceptionhandling.cpp +++ b/src/coreclr/vm/exceptionhandling.cpp @@ -3139,6 +3139,7 @@ extern "C" void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack e BEGIN_QCALL; + MAKE_CURRENT_THREAD_AVAILABLE(); Thread* pThread = GET_THREAD(); { @@ -3536,6 +3537,7 @@ extern "C" CLR_BOOL QCALLTYPE CallFilterFunclet(QCall::ObjectHandleOnStack excep DWORD_PTR dwResult = 0; BEGIN_QCALL; + MAKE_CURRENT_THREAD_AVAILABLE(); GCX_COOP(); Thread* pThread = GET_THREAD(); @@ -3704,6 +3706,7 @@ extern "C" CLR_BOOL QCALLTYPE EHEnumNext(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClau BEGIN_QCALL; + MAKE_CURRENT_THREAD_AVAILABLE(); Thread* pThread = GET_THREAD(); Frame* pFrame = pThread->GetFrame(); MarkInlinedCallFrameAsEHHelperCall(pFrame); @@ -4054,6 +4057,7 @@ extern "C" CLR_BOOL QCALLTYPE SfiInit(StackFrameIterator* pThis, CONTEXT* pStack CLR_BOOL result = FALSE; BEGIN_QCALL; + MAKE_CURRENT_THREAD_AVAILABLE(); Thread* pThread = GET_THREAD(); Frame* pFrame = pThread->GetFrame(); MarkInlinedCallFrameAsEHHelperCall(pFrame); @@ -4376,6 +4380,7 @@ extern "C" CLR_BOOL QCALLTYPE SfiNext(StackFrameIterator* pThis, uint* uExCollid BEGIN_QCALL; + MAKE_CURRENT_THREAD_AVAILABLE(); Thread* pThread = GET_THREAD(); Frame* pFrame = pThread->GetFrame(); MarkInlinedCallFrameAsEHHelperCall(pFrame); diff --git a/src/coreclr/vm/exceptmacros.h b/src/coreclr/vm/exceptmacros.h index a96234e70b41e9..07855b42189a62 100644 --- a/src/coreclr/vm/exceptmacros.h +++ b/src/coreclr/vm/exceptmacros.h @@ -214,7 +214,9 @@ struct QCallException }; void UnwindAndContinueRethrowHelperInsideCatch(Frame* pEntryFrame, Exception* pException); -void UnwindAndContinueRethrowHelperInsideQcallCatch(Frame* pEntryFrame, Exception* pException, QCallException* pQCallException); +void UnwindAndContinueRethrowHelperInsideQcallCatch( + Exception* pException, + QCallException* pQCallException DEBUG_ARG(Frame* pEntryFrame)); VOID DECLSPEC_NORETURN UnwindAndContinueRethrowHelperAfterCatch(Frame* pEntryFrame, Exception* pException, bool nativeRethrow); @@ -334,29 +336,29 @@ VOID DECLSPEC_NORETURN DispatchManagedException(PAL_SEHException& ex, bool isHar #define INSTALL_MANAGED_EXCEPTION_CAPTURE_DISPATCHER \ { \ - MAKE_CURRENT_THREAD_AVAILABLE(); \ - Exception* __pUnCException = NULL; \ - Frame* __pUnCEntryFrame = CURRENT_THREAD->GetFrame(); \ + INDEBUG(MAKE_CURRENT_THREAD_AVAILABLE();) \ + INDEBUG(Frame* __pUnCEntryFrame = CURRENT_THREAD->GetFrame();) \ + _ASSERTE(__pUnCEntryFrame->GetFrameIdentifier() == FrameIdentifier::InlinedCallFrame); \ PAL_CPP_TRY { #define UNINSTALL_MANAGED_EXCEPTION_CAPTURE_DISPATCHER \ } \ PAL_CPP_CATCH_NON_DERIVED (PAL_SEHException&, ex) \ { \ + _ASSERTE(CURRENT_THREAD->GetFrame() == __pUnCEntryFrame); \ + _ASSERTE(CURRENT_THREAD->GetFrame()->GetFrameIdentifier() == FrameIdentifier::InlinedCallFrame); \ GCX_COOP(); \ OBJECTREF throwable = ExInfo::CreateThrowable(ex.GetExceptionRecord(), FALSE); \ qcallError->SetThrowable(throwable); \ } \ PAL_CPP_CATCH_NON_DERIVED_NOARG (const std::bad_alloc&) \ { \ - __pUnCException = Exception::GetOOMException(); \ - UnwindAndContinueRethrowHelperInsideQcallCatch(__pUnCEntryFrame, __pUnCException, qcallError); \ + UnwindAndContinueRethrowHelperInsideQcallCatch(Exception::GetOOMException(), qcallError DEBUG_ARG(__pUnCEntryFrame)); \ } \ PAL_CPP_CATCH_DERIVED (Exception, __pException) \ { \ CONSISTENCY_CHECK(NULL != __pException); \ - __pUnCException = __pException; \ - UnwindAndContinueRethrowHelperInsideQcallCatch(__pUnCEntryFrame, __pUnCException, qcallError); \ + UnwindAndContinueRethrowHelperInsideQcallCatch(__pException, qcallError DEBUG_ARG(__pUnCEntryFrame)); \ } \ PAL_CPP_ENDTRY \ } @@ -457,23 +459,21 @@ VOID DECLSPEC_NORETURN DispatchManagedException(PAL_SEHException& ex, bool isHar #define INSTALL_MANAGED_EXCEPTION_CAPTURE_DISPATCHER \ { \ - MAKE_CURRENT_THREAD_AVAILABLE(); \ - Exception* __pUnCException = NULL; \ - Frame* __pUnCEntryFrame = CURRENT_THREAD->GetFrame(); \ + INDEBUG(MAKE_CURRENT_THREAD_AVAILABLE();) \ + INDEBUG(Frame* __pUnCEntryFrame = CURRENT_THREAD->GetFrame();) \ + _ASSERTE(__pUnCEntryFrame->GetFrameIdentifier() == FrameIdentifier::InlinedCallFrame); \ PAL_CPP_TRY { #define UNINSTALL_MANAGED_EXCEPTION_CAPTURE_DISPATCHER \ } \ PAL_CPP_CATCH_NON_DERIVED_NOARG (const std::bad_alloc&) \ { \ - __pUnCException = Exception::GetOOMException(); \ - UnwindAndContinueRethrowHelperInsideQcallCatch(__pUnCEntryFrame, __pUnCException, qcallError); \ + UnwindAndContinueRethrowHelperInsideQcallCatch(Exception::GetOOMException(), qcallError DEBUG_ARG(__pUnCEntryFrame)); \ } \ PAL_CPP_CATCH_DERIVED (Exception, __pException) \ { \ CONSISTENCY_CHECK(NULL != __pException); \ - __pUnCException = __pException; \ - UnwindAndContinueRethrowHelperInsideQcallCatch(__pUnCEntryFrame, __pUnCException, qcallError); \ + UnwindAndContinueRethrowHelperInsideQcallCatch(__pException, qcallError DEBUG_ARG(__pUnCEntryFrame)); \ } \ PAL_CPP_ENDTRY \ } diff --git a/src/coreclr/vm/reflectioninvocation.cpp b/src/coreclr/vm/reflectioninvocation.cpp index 28c5378e39eba7..5fa8e86dc2fc8f 100644 --- a/src/coreclr/vm/reflectioninvocation.cpp +++ b/src/coreclr/vm/reflectioninvocation.cpp @@ -337,6 +337,7 @@ extern "C" void QCALLTYPE RuntimeMethodHandle_InvokeMethod( BEGIN_QCALL; + MAKE_CURRENT_THREAD_AVAILABLE(); GCX_COOP(); struct From 9ed97b6d78708dd959e281c8df0bbb2ec05cc9f1 Mon Sep 17 00:00:00 2001 From: David Wrighton Date: Mon, 17 Aug 2026 14:11:52 -0700 Subject: [PATCH 05/23] Fix the build --- src/coreclr/vm/excep.cpp | 14 ++++++++++++++ src/coreclr/vm/exceptmacros.h | 8 +++++--- .../Tracing/EventPipeEventDispatcher.Wasm.cs | 8 +++++++- .../Runtime/InteropServices/Marshal.NoCom.cs | 6 +----- 4 files changed, 27 insertions(+), 9 deletions(-) diff --git a/src/coreclr/vm/excep.cpp b/src/coreclr/vm/excep.cpp index a9e876687ea0c1..6e41fe3800b79b 100644 --- a/src/coreclr/vm/excep.cpp +++ b/src/coreclr/vm/excep.cpp @@ -6700,6 +6700,20 @@ void UnwindAndContinueRethrowHelperInsideQcallCatch( pQCallException->SetThrowable(orThrowable); } +#ifdef TARGET_UNIX +void CaptureQCallExceptionFromPALException(PAL_SEHException& exception, QCallException* pQCallException) +{ + STATIC_CONTRACT_NOTHROW; + STATIC_CONTRACT_GC_TRIGGERS; + STATIC_CONTRACT_MODE_ANY; + + GCX_COOP(); + + OBJECTREF throwable = ExInfo::CreateThrowable(exception.GetExceptionRecord(), FALSE); + pQCallException->SetThrowable(throwable); +} +#endif + // // This does the work of the Unwind and Continue Hanlder after the catch clause of that handler. The stack has been // unwound by the time this is called. Keep that in mind when deciding where to put new code :) diff --git a/src/coreclr/vm/exceptmacros.h b/src/coreclr/vm/exceptmacros.h index 07855b42189a62..938771baf763ec 100644 --- a/src/coreclr/vm/exceptmacros.h +++ b/src/coreclr/vm/exceptmacros.h @@ -218,6 +218,10 @@ void UnwindAndContinueRethrowHelperInsideQcallCatch( Exception* pException, QCallException* pQCallException DEBUG_ARG(Frame* pEntryFrame)); +#ifdef TARGET_UNIX +void CaptureQCallExceptionFromPALException(PAL_SEHException& exception, QCallException* pQCallException); +#endif + VOID DECLSPEC_NORETURN UnwindAndContinueRethrowHelperAfterCatch(Frame* pEntryFrame, Exception* pException, bool nativeRethrow); #ifdef FEATURE_INTERPRETER @@ -347,9 +351,7 @@ VOID DECLSPEC_NORETURN DispatchManagedException(PAL_SEHException& ex, bool isHar { \ _ASSERTE(CURRENT_THREAD->GetFrame() == __pUnCEntryFrame); \ _ASSERTE(CURRENT_THREAD->GetFrame()->GetFrameIdentifier() == FrameIdentifier::InlinedCallFrame); \ - GCX_COOP(); \ - OBJECTREF throwable = ExInfo::CreateThrowable(ex.GetExceptionRecord(), FALSE); \ - qcallError->SetThrowable(throwable); \ + CaptureQCallExceptionFromPALException(ex, qcallError); \ } \ PAL_CPP_CATCH_NON_DERIVED_NOARG (const std::bad_alloc&) \ { \ diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Wasm.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Wasm.cs index b9d9acb6db8b51..677894c0d87f5d 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Wasm.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Wasm.cs @@ -44,7 +44,13 @@ private async Task DispatchEventsToEventListeners(ulong sessionID, DateTime sync // the SignalSession() call could be on a disabled session. await Task.Yield(); - EventPipeInternal.Disable(sessionID); + EventPipeInternal.Disable(sessionID +#if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. + , out _ +#pragma warning restore SA1001, SA1113, SA1115 +#endif + ); } } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.NoCom.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.NoCom.cs index 04ff5af207eef1..8c7fb2e5ed09bb 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.NoCom.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.NoCom.cs @@ -175,11 +175,7 @@ public static int GetEndComSlot(Type t) } #pragma warning disable IDE0060 - internal static Type? GetTypeFromCLSID(Guid clsid, string? server, bool throwOnError -#if CORECLR - , out _ -#endif - ) + internal static Type? GetTypeFromCLSID(Guid clsid, string? server, bool throwOnError) { if (throwOnError) throw new PlatformNotSupportedException(SR.PlatformNotSupported_ComInterop); From 35b67178ad77d155ebc96e66a1e29c6759309365 Mon Sep 17 00:00:00 2001 From: David Wrighton Date: Mon, 17 Aug 2026 14:31:11 -0700 Subject: [PATCH 06/23] Fix build --- .../Tracing/TraceLogging/XplatEventLogger.cs | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs index 1b528f7029d45e..c932bea5aaf380 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs @@ -21,14 +21,18 @@ public XplatEventLogger() { } private static unsafe string GetClrConfig(string configName) => new string(EventSource_GetClrConfig(configName #if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. , out _ +#pragma warning restore SA1001, SA1113, SA1115 #endif )); [LibraryImport(RuntimeHelpers.QCall, StringMarshalling = StringMarshalling.Utf16)] private static unsafe partial char* EventSource_GetClrConfig(string configName #if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -40,7 +44,9 @@ public XplatEventLogger() { } { if (!initializedPersistentListener && XplatEventLogger.IsEventSourceLoggingEnabled( #if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. out _ +#pragma warning restore SA1001, SA1113, SA1115 #endif )) { @@ -57,14 +63,18 @@ out _ [return: MarshalAs(UnmanagedType.Bool)] private static partial bool IsEventSourceLoggingEnabled( #if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 #endif ); [LibraryImport(RuntimeHelpers.QCall, StringMarshalling = StringMarshalling.Utf16)] private static partial void LogEventSource(int eventID, string? eventName, string eventSourceName, string payload #if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. , out QCallException qcallException +#pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -217,7 +227,9 @@ private static void LogOnEventWritten(EventWrittenEventArgs eventData) LogEventSource(eventData.EventId, eventData.EventName, eventData.EventSource.Name, payload #if CORECLR +#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. , out _ +#pragma warning restore SA1001, SA1113, SA1115 #endif ); } From 4b99b55fb445499dc5ae5bf2e291910cd605f608 Mon Sep 17 00:00:00 2001 From: David Wrighton Date: Mon, 17 Aug 2026 17:14:14 -0700 Subject: [PATCH 07/23] Initialize QCall exception status Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 97d405de-8e39-4e76-afe4-2f94b74ecfa2 --- src/coreclr/vm/debugdebugger.cpp | 7 +++++++ src/coreclr/vm/eventpipeinternal.cpp | 1 + src/coreclr/vm/exceptmacros.h | 5 +++++ src/coreclr/vm/ilmarshalers.cpp | 6 ++++++ src/coreclr/vm/marshalnative.cpp | 6 ++++++ src/coreclr/vm/qcall.h | 1 + src/coreclr/vm/reflectioninvocation.cpp | 12 ++++++++++++ src/coreclr/vm/stubhelpers.cpp | 1 + 8 files changed, 39 insertions(+) diff --git a/src/coreclr/vm/debugdebugger.cpp b/src/coreclr/vm/debugdebugger.cpp index ab853bf458b369..e8329647ef4bd7 100644 --- a/src/coreclr/vm/debugdebugger.cpp +++ b/src/coreclr/vm/debugdebugger.cpp @@ -80,6 +80,8 @@ extern "C" void QCALLTYPE DebugDebugger_Break(QCallException* qcallError) } END_QCALL; +#else + qcallError->SetNoException(); #endif // DEBUGGING_SUPPORTED } @@ -870,7 +872,10 @@ extern "C" void QCALLTYPE DebugDebugger_CustomNotification(QCall::ObjectHandleOn #ifdef DEBUGGING_SUPPORTED // Send notification only if the debugger is attached if (!CORDebuggerAttached()) + { + qcallError->SetNoException(); return; + } BEGIN_QCALL; @@ -895,6 +900,8 @@ extern "C" void QCALLTYPE DebugDebugger_CustomNotification(QCall::ObjectHandleOn } END_QCALL; +#else + qcallError->SetNoException(); #endif // DEBUGGING_SUPPORTED } diff --git a/src/coreclr/vm/eventpipeinternal.cpp b/src/coreclr/vm/eventpipeinternal.cpp index e4de4e474d3066..dd5c5c08e8758c 100644 --- a/src/coreclr/vm/eventpipeinternal.cpp +++ b/src/coreclr/vm/eventpipeinternal.cpp @@ -32,6 +32,7 @@ extern "C" UINT64 QCALLTYPE EventPipeInternal_Enable( numProviders == 0 || pProviders == nullptr) { + qcallError->SetNoException(); return 0; } diff --git a/src/coreclr/vm/exceptmacros.h b/src/coreclr/vm/exceptmacros.h index 938771baf763ec..79255431d8c077 100644 --- a/src/coreclr/vm/exceptmacros.h +++ b/src/coreclr/vm/exceptmacros.h @@ -210,6 +210,11 @@ struct QCallException INT32 m_exceptionPending; public: + void SetNoException() + { + m_exceptionPending = 0; + } + void SetThrowable(OBJECTREF throwable); }; diff --git a/src/coreclr/vm/ilmarshalers.cpp b/src/coreclr/vm/ilmarshalers.cpp index 3c6f4be63670e1..b81cc6e6b6cb72 100644 --- a/src/coreclr/vm/ilmarshalers.cpp +++ b/src/coreclr/vm/ilmarshalers.cpp @@ -4770,7 +4770,10 @@ extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToNative(MngdSafeAr CONTRACTL_END; if (pThis->m_fStatic & MngdSafeArrayMarshaler::SCSF_IsStatic) + { + qcallError->SetNoException(); return; + } BEGIN_QCALL; @@ -4936,7 +4939,10 @@ extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ClearNative(MngdSafeArrayMarsha QCALL_CONTRACT; if (pThis->m_fStatic & MngdSafeArrayMarshaler::SCSF_IsStatic) + { + qcallError->SetNoException(); return; + } BEGIN_QCALL; diff --git a/src/coreclr/vm/marshalnative.cpp b/src/coreclr/vm/marshalnative.cpp index e7da5ef0e4eeb7..205e865d8a68a4 100644 --- a/src/coreclr/vm/marshalnative.cpp +++ b/src/coreclr/vm/marshalnative.cpp @@ -60,11 +60,17 @@ extern "C" VOID QCALLTYPE MarshalNative_Prelink(MethodDesc * pMD, QCallException // If the code is already ready, we are done. Else, we need to execute the prestub // This is a perf thing since it's always safe to execute the prestub twice. if (!pMD->ShouldCallPrestub()) + { + qcallError->SetNoException(); return; + } // Silently ignore if not PInvoke and not runtime generated. if (!(pMD->IsPInvoke()) && !(pMD->IsRuntimeSupplied())) + { + qcallError->SetNoException(); return; + } BEGIN_QCALL; diff --git a/src/coreclr/vm/qcall.h b/src/coreclr/vm/qcall.h index 68340638ee6086..f3614683b5868e 100644 --- a/src/coreclr/vm/qcall.h +++ b/src/coreclr/vm/qcall.h @@ -110,6 +110,7 @@ #endif // !TARGET_UNIX #define BEGIN_QCALL \ + qcallError->SetNoException(); \ INSTALL_RESUME_AFTER_CATCH_HANDLER_WITH_FRAME(GetThread()->GetFrame()) \ INSTALL_MANAGED_EXCEPTION_CAPTURE_DISPATCHER diff --git a/src/coreclr/vm/reflectioninvocation.cpp b/src/coreclr/vm/reflectioninvocation.cpp index 5fa8e86dc2fc8f..21ea154848915b 100644 --- a/src/coreclr/vm/reflectioninvocation.cpp +++ b/src/coreclr/vm/reflectioninvocation.cpp @@ -1267,7 +1267,10 @@ extern "C" void QCALLTYPE ReflectionInvocation_CompileMethod(MethodDesc * pMD, Q PRECONDITION(pMD != NULL); if (!pMD->ShouldCallPrestub()) + { + qcallError->SetNoException(); return; + } BEGIN_QCALL; pMD->DoPrestub(NULL); @@ -1281,12 +1284,18 @@ extern "C" void QCALLTYPE ReflectionInvocation_RunClassConstructor(QCall::TypeHa TypeHandle typeHnd = pType.AsTypeHandle(); if (typeHnd.IsTypeDesc()) + { + qcallError->SetNoException(); return; + } MethodTable *pMT = typeHnd.AsMethodTable(); // The ContainsGenericVariables check is to preserve back-compat where we assume the generic type is already initialized if (pMT->IsClassInited() || pMT->ContainsGenericVariables()) + { + qcallError->SetNoException(); return; + } BEGIN_QCALL; pMT->CheckRestore(); @@ -1302,7 +1311,10 @@ extern "C" void QCALLTYPE ReflectionInvocation_RunModuleConstructor(QCall::Modul Assembly *pAssembly = pModule->GetAssembly(); if (pAssembly != NULL && pAssembly->IsActive()) + { + qcallError->SetNoException(); return; + } BEGIN_QCALL; pAssembly->EnsureActive(); diff --git a/src/coreclr/vm/stubhelpers.cpp b/src/coreclr/vm/stubhelpers.cpp index 82f320ccd99fb0..b2847025a7ee4e 100644 --- a/src/coreclr/vm/stubhelpers.cpp +++ b/src/coreclr/vm/stubhelpers.cpp @@ -588,6 +588,7 @@ extern "C" void QCALLTYPE StubHelpers_ValidateByref(void *pByref, MethodDesc *pM // Skip byref if is not pointing inside managed heap if (!GCHeapUtilities::GetGCHeap()->IsHeapPointer(pByref)) { + qcallError->SetNoException(); return; } From 566879c13531d44fc6235cc68eef3fbc4c522074 Mon Sep 17 00:00:00 2001 From: David Wrighton Date: Tue, 18 Aug 2026 12:45:32 -0700 Subject: [PATCH 08/23] Move qcall exception to tls data to avoid the Thread object --- .../CompilerServices/QCallException.cs | 28 +++++++++---------- .../src/System/Threading/Thread.CoreCLR.cs | 11 ++------ src/coreclr/vm/comsynchronizable.cpp | 11 ++++++++ src/coreclr/vm/comsynchronizable.h | 1 + src/coreclr/vm/corelib.h | 1 - src/coreclr/vm/ecalllist.h | 1 + src/coreclr/vm/object.h | 10 ------- src/coreclr/vm/qcall.cpp | 7 ++--- src/coreclr/vm/threadstatics.cpp | 3 ++ src/coreclr/vm/threadstatics.h | 1 + 10 files changed, 35 insertions(+), 39 deletions(-) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallException.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallException.cs index a95a86487cff85..836b0f5dff21e7 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallException.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallException.cs @@ -16,31 +16,29 @@ internal readonly struct QCallException [CustomMarshaller(typeof(QCallException), MarshalMode.ManagedToUnmanagedOut, typeof(QCallExceptionMarshaller))] internal struct QCallExceptionMarshaller { - private readonly Thread _thread; - - public QCallExceptionMarshaller() - { - _thread = Thread.CurrentThread; - } - + [MethodImpl(MethodImplOptions.AggressiveInlining)] public void FromUnmanaged(int exceptionPending) { - Debug.Assert(exceptionPending is 0 or 1); - if (exceptionPending == 1) { - Exception exception = _thread.GetAndClearQCallException(); - - // Throw during unmarshalling so QCall exception propagation remains as close as - // possible to throwing directly from native code, as QCalls did previously. - ExceptionDispatchInfo.Throw(exception); + HandleException(); } } + [MethodImpl(MethodImplOptions.AggressiveInlining)] public QCallException ToManaged() => default; - public void Free() + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void Free() { } + + [MethodImpl(MethodImplOptions.NoInlining)] + private static void HandleException() { + Exception exception = Thread.GetAndClearQCallException(); + + // Throw during unmarshalling so QCall exception propagation remains as close as + // possible to throwing directly from native code, as QCalls did previously. + ExceptionDispatchInfo.Throw(exception); } } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs index fc50ca290daaea..1baad1c8fc8b63 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs @@ -34,7 +34,6 @@ public sealed partial class Thread private string? _name; private StartHelper? _startHelper; - private Exception? _qcallException; #if TARGET_UNIX || TARGET_BROWSER || TARGET_WASI internal WaitSubsystem.ThreadWaitInfo? _waitInfo; @@ -74,14 +73,8 @@ public sealed partial class Thread private Thread() { } - internal Exception GetAndClearQCallException() - { - Exception? exception = _qcallException; - _qcallException = null; - - Debug.Assert(exception is not null); - return exception; - } + [MethodImpl(MethodImplOptions.InternalCall)] + internal static extern Exception GetAndClearQCallException(); public int ManagedThreadId { diff --git a/src/coreclr/vm/comsynchronizable.cpp b/src/coreclr/vm/comsynchronizable.cpp index b492ce0dbf76a4..0b7e6563823665 100644 --- a/src/coreclr/vm/comsynchronizable.cpp +++ b/src/coreclr/vm/comsynchronizable.cpp @@ -723,6 +723,17 @@ FCIMPL0(INT32, ThreadNative::GetOptimalMaxSpinWaitsPerSpinIteration) } FCIMPLEND +FCIMPL0(Object*, ThreadNative::GetAndClearQCallException) +{ + FCALL_CONTRACT; + + Object *result = t_ThreadStatics.pQCallException; + t_ThreadStatics.pQCallException = NULL; + + return result; +} +FCIMPLEND + // Returns the address of the current thread's ThreadLocalData (&t_ThreadStatics). Used on wasm to break // the thread-static bootstrap recursion in Thread.GetThreadStaticsBase (see the managed counterpart). #ifdef TARGET_WASM diff --git a/src/coreclr/vm/comsynchronizable.h b/src/coreclr/vm/comsynchronizable.h index f3d0e39d2d87d1..4aaff4e1a8f75b 100644 --- a/src/coreclr/vm/comsynchronizable.h +++ b/src/coreclr/vm/comsynchronizable.h @@ -46,6 +46,7 @@ class ThreadNative FCDECL1(static void, Finalize, ThreadBaseObject* pThis); FCDECL0(static FC_BOOL_RET, CatchAtSafePoint); FCDECL0(static FC_BOOL_RET, CurrentThreadIsFinalizerThread); + FCDECL0(static Object*, GetAndClearQCallException); }; extern "C" BOOL QCALLTYPE ThreadNative_Start(QCall::ThreadHandle thread, int threadStackSize, int priority, BOOL isThreadPool, PCWSTR pThreadName, QCall::ObjectHandleOnStack exception, QCallException* qcallError); diff --git a/src/coreclr/vm/corelib.h b/src/coreclr/vm/corelib.h index c23560b5993506..972fb1580d2006 100644 --- a/src/coreclr/vm/corelib.h +++ b/src/coreclr/vm/corelib.h @@ -978,7 +978,6 @@ DEFINE_CLASS(STACKCRAWMARK, Threading, StackCrawlMark) DEFINE_CLASS_U(Threading, Thread, ThreadBaseObject) DEFINE_FIELD_U(_name, ThreadBaseObject, m_Name) DEFINE_FIELD_U(_startHelper, ThreadBaseObject, m_StartHelper) -DEFINE_FIELD_U(_qcallException, ThreadBaseObject, m_QCallException) DEFINE_FIELD_U(_DONT_USE_InternalThread, ThreadBaseObject, m_InternalThread) DEFINE_FIELD_U(_priority, ThreadBaseObject, m_Priority) DEFINE_FIELD_U(_isDead, ThreadBaseObject, m_IsDead) diff --git a/src/coreclr/vm/ecalllist.h b/src/coreclr/vm/ecalllist.h index d64b8c7dab8ffa..47cd2b5530d465 100644 --- a/src/coreclr/vm/ecalllist.h +++ b/src/coreclr/vm/ecalllist.h @@ -257,6 +257,7 @@ FCFuncStart(gThreadFuncs) FCFuncElement("CatchAtSafePoint", ThreadNative::CatchAtSafePoint) FCFuncElement("CurrentThreadIsFinalizerThread", ThreadNative::CurrentThreadIsFinalizerThread) FCFuncElement("get_OptimalMaxSpinWaitsPerSpinIteration", ThreadNative::GetOptimalMaxSpinWaitsPerSpinIteration) + FCFuncElement("GetAndClearQCallException", ThreadNative::GetAndClearQCallException) #ifdef TARGET_WASM FCFuncElement("GetThreadStaticsBaseNative", ThreadNative::GetThreadStaticsBaseNative) #endif diff --git a/src/coreclr/vm/object.h b/src/coreclr/vm/object.h index 9477bdcec90b5f..a9710bb168cf94 100644 --- a/src/coreclr/vm/object.h +++ b/src/coreclr/vm/object.h @@ -1185,7 +1185,6 @@ class ThreadBaseObject : public Object OBJECTREF m_SynchronizationContext; STRINGREF m_Name; OBJECTREF m_StartHelper; - OBJECTREF m_QCallException; #ifdef TARGET_UNIX OBJECTREF m_WaitInfo; OBJECTREF m_joinEvent; @@ -1225,15 +1224,6 @@ class ThreadBaseObject : public Object void SetInternal(Thread *it); void ClearInternal(); - void SetQCallException(OBJECTREF throwable) - { - LIMITED_METHOD_CONTRACT; - - _ASSERTE(throwable != NULL); - _ASSERTE(m_QCallException == NULL); - SetObjectReference(&m_QCallException, throwable); - } - void SetManagedThreadId(INT32 id) { LIMITED_METHOD_CONTRACT; diff --git a/src/coreclr/vm/qcall.cpp b/src/coreclr/vm/qcall.cpp index df32f9116db477..7f06c10c5adfd2 100644 --- a/src/coreclr/vm/qcall.cpp +++ b/src/coreclr/vm/qcall.cpp @@ -6,18 +6,17 @@ #include "common.h" +#include "threadstatics.h" void QCallException::SetThrowable(OBJECTREF throwable) { LIMITED_METHOD_CONTRACT; _ASSERTE(throwable != NULL); - _ASSERTE(m_exceptionPending == 0 || m_exceptionPending == 1); _ASSERTE(m_exceptionPending == 0); - THREADBASEREF thread = (THREADBASEREF)GetThread()->GetExposedObjectRaw(); - _ASSERTE(thread != NULL); - thread->SetQCallException(throwable); + _ASSERTE(t_ThreadStatics.pQCallException == NULL); + t_ThreadStatics.pQCallException = OBJECTREFToObject(throwable); VolatileStore(&m_exceptionPending, 1); } diff --git a/src/coreclr/vm/threadstatics.cpp b/src/coreclr/vm/threadstatics.cpp index d5ae02973ac091..112f419c2c3779 100644 --- a/src/coreclr/vm/threadstatics.cpp +++ b/src/coreclr/vm/threadstatics.cpp @@ -202,6 +202,9 @@ void ScanThreadStaticRoots(Thread* pThread, promote_func* fn, ScanContext* sc) // Report non-collectible object array fn(&pThreadLocalData->pNonCollectibleTlsArrayData, sc, 0); + + // Report qcall exception object + fn(&pThreadLocalData->pQCallException, sc, 0); } #endif // DACCESS_COMPILE diff --git a/src/coreclr/vm/threadstatics.h b/src/coreclr/vm/threadstatics.h index 0a77a356e33db4..8a96b691c63951 100644 --- a/src/coreclr/vm/threadstatics.h +++ b/src/coreclr/vm/threadstatics.h @@ -90,6 +90,7 @@ struct ThreadLocalData PTR_Object pNonCollectibleTlsArrayData; DPTR(OBJECTHANDLE) pCollectibleTlsArrayData; // Points at the Thread local array data. PTR_Thread pThread; // This starts the region of ThreadLocalData which is referenceable by TLSIndexType::DirectOnThreadLocalData + PTR_Object pQCallException; // This is used to store an exception that is thrown in a QCall, so that it can be rethrown in managed code. It is stored here because this is the only place that is guaranteed to be allocated for the lifetime of the thread, and it is not used for anything else. uint32_t managedThreadId; PTR_InFlightTLSData pInFlightData; // Points at the in-flight TLS data (TLS data that exists before the class constructor finishes running) BYTE ExtendedDirectThreadLocalTLSData[EXTENDED_DIRECT_THREAD_LOCAL_SIZE]; From da22e7b28e482846ff7f9d98c1e41c2e6f2dd40c Mon Sep 17 00:00:00 2001 From: David Wrighton Date: Wed, 19 Aug 2026 12:03:04 -0700 Subject: [PATCH 09/23] Preserve QCall IL stub helper signatures Add managed forwarding overloads for helpers invoked by native IL stub generation so their CoreLib binder signatures remain stable after adding QCall exception parameters. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 97d405de-8e39-4e76-afe4-2f94b74ecfa2 --- .../src/System/StubHelpers.cs | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs index 786f80b3fb0a4d..33c8b6b84332f0 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs @@ -667,6 +667,11 @@ internal static object GetObjectForComCallableWrapperIUnknown(IntPtr unk) [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "InterfaceMarshaler_ValidateComVisibilityForIUnknown")] internal static partial void ValidateComVisibilityForIUnknown(IntPtr unk, out QCallException qcallException); + + internal static void ValidateComVisibilityForIUnknown(IntPtr unk) + { + ValidateComVisibilityForIUnknown(unk, out _); + } } // class InterfaceMarshaler #endif // FEATURE_COMINTEROP @@ -2179,6 +2184,9 @@ internal static partial class StubHelpers [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_ThrowInteropParamException")] internal static safe partial void ThrowInteropParamException(int resID, int paramIdx, out QCallException qcallException); + internal static safe void ThrowInteropParamException(int resID, int paramIdx) + => ThrowInteropParamException(resID, paramIdx, out _); + internal static IntPtr AddToCleanupList(ref CleanupWorkListElement? pCleanupWorkList, SafeHandle handle) { SafeHandleCleanupWorkListElement element = new SafeHandleCleanupWorkListElement(handle); @@ -2373,8 +2381,14 @@ static IntPtr GetCOMIPFromRCWWorker(object objSrc, IntPtr pCPCMD, out IntPtr ppT [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_ProfilerBeginTransitionCallback")] internal static unsafe partial void* ProfilerBeginTransitionCallback(void* pTargetMD, out QCallException qcallException); + internal static unsafe void* ProfilerBeginTransitionCallback(void* pTargetMD) + => ProfilerBeginTransitionCallback(pTargetMD, out _); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_ProfilerEndTransitionCallback")] internal static unsafe partial void ProfilerEndTransitionCallback(void* pTargetMD, out QCallException qcallException); + + internal static unsafe void ProfilerEndTransitionCallback(void* pTargetMD) + => ProfilerEndTransitionCallback(pTargetMD, out _); #endif // PROFILING_SUPPORTED //------------------------------------------------------ @@ -2509,9 +2523,15 @@ internal static void ThrowWrongSizeArrayInNativeStruct() [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_MarshalToManagedVaList")] internal static partial void MarshalToManagedVaList(IntPtr va_list, IntPtr pArgIterator, out QCallException qcallException); + internal static void MarshalToManagedVaList(IntPtr va_list, IntPtr pArgIterator) + => MarshalToManagedVaList(va_list, pArgIterator, out _); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_MarshalToUnmanagedVaList")] internal static partial void MarshalToUnmanagedVaList(IntPtr va_list, uint vaListSize, IntPtr pArgIterator, out QCallException qcallException); + internal static void MarshalToUnmanagedVaList(IntPtr va_list, uint vaListSize, IntPtr pArgIterator) + => MarshalToUnmanagedVaList(va_list, vaListSize, pArgIterator, out _); + [MethodImpl(MethodImplOptions.InternalCall)] internal static extern uint CalcVaListSize(IntPtr va_list); @@ -2527,6 +2547,9 @@ internal static void ValidateObject(object obj, IntPtr pMD) [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_ValidateByref")] internal static partial void ValidateByref(IntPtr byref, IntPtr pMD, out QCallException qcallException); // the byref is pinned so we can safely "cast" it to IntPtr + internal static void ValidateByref(IntPtr byref, IntPtr pMD) + => ValidateByref(byref, pMD, out _); + [Intrinsic] internal static IntPtr GetStubContext() => throw new UnreachableException(); // Unconditionally expanded intrinsic From 8432bb32b9be1531e84cd0c3f2d65264fcab258a Mon Sep 17 00:00:00 2001 From: David Wrighton Date: Wed, 19 Aug 2026 12:55:41 -0700 Subject: [PATCH 10/23] Fix shared thread ID call formatting Keep the CoreCLR QCall exception argument and Mono zero-argument call in separately formatted conditional branches so both CoreLib builds satisfy style validation. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 97d405de-8e39-4e76-afe4-2f94b74ecfa2 --- .../System.Private.CoreLib/src/System/Threading/Thread.cs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.cs index d07823a37e99f6..47db205e0c69dc 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.cs @@ -376,11 +376,11 @@ public static void Sleep(int millisecondsTimeout) #if !NATIVEAOT /// Returns the operating system identifier for the current thread. - internal static ulong CurrentOSThreadId => GetCurrentOSThreadId( #if CORECLR - out _ + internal static ulong CurrentOSThreadId => GetCurrentOSThreadId(out _); +#else + internal static ulong CurrentOSThreadId => GetCurrentOSThreadId(); #endif - ); #endif #if !MONO From 5457b28d873b704721536afdabfc9627bb897b53 Mon Sep 17 00:00:00 2001 From: David Wrighton Date: Wed, 19 Aug 2026 13:53:02 -0700 Subject: [PATCH 11/23] Regenerate CoreCLR WebAssembly call helpers Update browser and WASI interpreter-to-managed thunks for the QCall exception argument and refresh generated P/Invoke tables. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 97d405de-8e39-4e76-afe4-2f94b74ecfa2 --- .../browser/callhelpers-interp-to-managed.cpp | 266 +++++++++--------- .../vm/wasm/browser/callhelpers-pinvoke.cpp | 6 +- .../wasi/callhelpers-interp-to-managed.cpp | 196 +++++++------ .../vm/wasm/wasi/callhelpers-pinvoke.cpp | 8 +- 4 files changed, 251 insertions(+), 225 deletions(-) diff --git a/src/coreclr/vm/wasm/browser/callhelpers-interp-to-managed.cpp b/src/coreclr/vm/wasm/browser/callhelpers-interp-to-managed.cpp index dc7af3ffa4ea3a..d6570db6f62385 100644 --- a/src/coreclr/vm/wasm/browser/callhelpers-interp-to-managed.cpp +++ b/src/coreclr/vm/wasm/browser/callhelpers-interp-to-managed.cpp @@ -88,10 +88,10 @@ namespace *((int32_t*)pRet) = (*fptr)(); } - static void CallFunc_S64_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_S64_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t) = (int32_t (*)(int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0)); + int32_t (*fptr)(int32_t, int32_t) = (int32_t (*)(int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(8)); } static void CallFunc_S8_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) @@ -100,28 +100,28 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_IND(0)); } - static void CallFunc_S8_S8_S8_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_S8_S8_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_IND(2)); + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_IND(2), ARG_I32(3)); } - static void CallFunc_S8_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_S8_S8_I32_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2)); + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_IND(3), ARG_I32(4)); } - static void CallFunc_S8_S8_I32_S8_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_S8_S8_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_IND(3)); + *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_I32(3)); } - static void CallFunc_S8_S8_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_S8_S8_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_I32(3)); + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_I32(3), ARG_I32(4)); } static void CallFunc_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) @@ -130,16 +130,16 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1)); } - static void CallFunc_S8_I32_S8_S8_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_S8_I32_S8_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_IND(2), ARG_IND(3)); + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_IND(2), ARG_IND(3), ARG_I32(4)); } - static void CallFunc_S8_I32_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_S8_I32_S8_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_IND(2), ARG_I32(3)); + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_IND(2), ARG_I32(3), ARG_I32(4)); } static void CallFunc_S8_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) @@ -166,6 +166,12 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5)); } + static void CallFunc_S8_I32_I32_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); + } + NOINLINE static void CallFunc_This_I32_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; @@ -186,16 +192,16 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_I32(0)); } - static void CallFunc_I32_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I32_S8_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_IND(1), ARG_I32(2)); + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_IND(1), ARG_I32(2), ARG_I32(3)); } - static void CallFunc_I32_S8_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I32_S8_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_IND(1), ARG_I32(2), ARG_I32(3), ARG_I32(4)); + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_IND(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5)); } static void CallFunc_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) @@ -204,16 +210,16 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1)); } - static void CallFunc_I32_I32_S8_I32_I32_S8_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I32_I32_S8_I32_I32_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_I32(3), ARG_I32(4), ARG_IND(5)); + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_I32(3), ARG_I32(4), ARG_IND(5), ARG_I32(6)); } - static void CallFunc_I32_I32_S8_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I32_I32_S8_I32_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7)); } static void CallFunc_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) @@ -222,10 +228,10 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2)); } - static void CallFunc_I32_I32_I32_S8_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I32_I32_I32_S8_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7)); } static void CallFunc_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) @@ -298,10 +304,10 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I64(2)); } - static void CallFunc_I32_I32_I64_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I32_I32_I64_I32_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int64_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int64_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I64(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); + int32_t (*fptr)(int32_t, int32_t, int64_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int64_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I64(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7)); } NOINLINE static void CallFunc_I32_I32_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) @@ -348,22 +354,22 @@ namespace *((int32_t*)pRet) = (*fptr)(&framePointer, ARG_I32(0), pPortableEntryPoint); } - static void CallFunc_I64_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int64_t) = (int32_t (*)(int64_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I64(0)); - } - static void CallFunc_I64_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int64_t, int32_t) = (int32_t (*)(int64_t, int32_t))pcode; *((int32_t*)pRet) = (*fptr)(ARG_I64(0), ARG_I32(1)); } - static void CallFunc_I64_I32_I64_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I64_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int64_t, int32_t, int64_t, int32_t) = (int32_t (*)(int64_t, int32_t, int64_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I64(0), ARG_I32(1), ARG_I64(2), ARG_I32(3)); + int32_t (*fptr)(int64_t, int32_t, int32_t) = (int32_t (*)(int64_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I64(0), ARG_I32(1), ARG_I32(2)); + } + + static void CallFunc_I64_I32_I64_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(int64_t, int32_t, int64_t, int32_t, int32_t) = (int32_t (*)(int64_t, int32_t, int64_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I64(0), ARG_I32(1), ARG_I64(2), ARG_I32(3), ARG_I32(4)); } NOINLINE static void CallFunc_Void_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) @@ -391,10 +397,10 @@ namespace *((int64_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2)); } - static void CallFunc_I32_I32_I32_I32_I32_RetI64(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I32_I32_I32_I32_I32_I32_RetI64(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int64_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int64_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int64_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4)); + int64_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int64_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int64_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5)); } static void CallFunc_I32_I32_I32_I64_RetI64(PCODE pcode, int8_t* pArgs, int8_t* pRet) @@ -450,22 +456,16 @@ namespace (*fptr)(); } - static void CallFunc_S8_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t) = (void (*)(int32_t))pcode; - (*fptr)(ARG_IND(0)); - } - - static void CallFunc_S8_S8_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_S8_S8_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - void (*fptr)(int32_t, int32_t) = (void (*)(int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_IND(1)); + void (*fptr)(int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2)); } - static void CallFunc_S8_S8_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_S8_S8_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7)); } static void CallFunc_S8_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) @@ -504,10 +504,16 @@ namespace (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); } - static void CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7), ARG_I32(8), ARG_I32(9), ARG_I32(10), ARG_I32(11)); + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7)); + } + + static void CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7), ARG_I32(8), ARG_I32(9), ARG_I32(10), ARG_I32(11), ARG_I32(12)); } NOINLINE static void CallFunc_This_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) @@ -517,22 +523,22 @@ namespace (*fptr)(&framePointer, ARG_I32(0), pPortableEntryPoint); } - static void CallFunc_F64_F64_F64_F64_F64_F64_F64_F64_F64_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_F64_F64_F64_F64_F64_F64_F64_F64_F64_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - void (*fptr)(double, double, double, double, double, double, double, double, double, int32_t, int32_t) = (void (*)(double, double, double, double, double, double, double, double, double, int32_t, int32_t))pcode; - (*fptr)(ARG_F64(0), ARG_F64(1), ARG_F64(2), ARG_F64(3), ARG_F64(4), ARG_F64(5), ARG_F64(6), ARG_F64(7), ARG_F64(8), ARG_I32(9), ARG_I32(10)); + void (*fptr)(double, double, double, double, double, double, double, double, double, int32_t, int32_t, int32_t) = (void (*)(double, double, double, double, double, double, double, double, double, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_F64(0), ARG_F64(1), ARG_F64(2), ARG_F64(3), ARG_F64(4), ARG_F64(5), ARG_F64(6), ARG_F64(7), ARG_F64(8), ARG_I32(9), ARG_I32(10), ARG_I32(11)); } - static void CallFunc_F64_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_F64_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - void (*fptr)(double, int32_t) = (void (*)(double, int32_t))pcode; - (*fptr)(ARG_F64(0), ARG_I32(1)); + void (*fptr)(double, int32_t, int32_t) = (void (*)(double, int32_t, int32_t))pcode; + (*fptr)(ARG_F64(0), ARG_I32(1), ARG_I32(2)); } - static void CallFunc_F64_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_F64_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - void (*fptr)(double, int32_t, int32_t, int32_t) = (void (*)(double, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_F64(0), ARG_I32(1), ARG_I32(2), ARG_I32(3)); + void (*fptr)(double, int32_t, int32_t, int32_t, int32_t) = (void (*)(double, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_F64(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4)); } NOINLINE static void CallFunc_F64_I32_I32_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) @@ -555,10 +561,10 @@ namespace (*fptr)(ARG_I32(0)); } - static void CallFunc_I32_S8_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I32_S8_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - void (*fptr)(int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_IND(1), ARG_I32(2)); + void (*fptr)(int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_I32(0), ARG_IND(1), ARG_I32(2), ARG_I32(3)); } static void CallFunc_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) @@ -567,34 +573,28 @@ namespace (*fptr)(ARG_I32(0), ARG_I32(1)); } - static void CallFunc_I32_I32_S8_S8_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_IND(3), ARG_I32(4)); - } - static void CallFunc_I32_I32_S8_S8_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_IND(3), ARG_I32(4), ARG_I32(5)); } - static void CallFunc_I32_I32_F64_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I32_I32_S8_S8_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - void (*fptr)(int32_t, int32_t, double) = (void (*)(int32_t, int32_t, double))pcode; - (*fptr)(ARG_I32(0), ARG_I32(1), ARG_F64(2)); + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_IND(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); } - static void CallFunc_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I32_I32_F64_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - void (*fptr)(int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2)); + void (*fptr)(int32_t, int32_t, double, int32_t) = (void (*)(int32_t, int32_t, double, int32_t))pcode; + (*fptr)(ARG_I32(0), ARG_I32(1), ARG_F64(2), ARG_I32(3)); } - static void CallFunc_I32_I32_I32_S8_S8_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_IND(4)); + void (*fptr)(int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2)); } static void CallFunc_I32_I32_I32_S8_S8_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) @@ -603,6 +603,12 @@ namespace (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_IND(4), ARG_I32(5)); } + static void CallFunc_I32_I32_I32_S8_S8_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_IND(4), ARG_I32(5), ARG_I32(6)); + } + static void CallFunc_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { void (*fptr)(int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t))pcode; @@ -621,10 +627,16 @@ namespace (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5)); } - static void CallFunc_I32_I32_I32_I32_I64_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I32_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); + } + + static void CallFunc_I32_I32_I32_I32_I64_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int64_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int64_t))pcode; - (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I64(4)); + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int64_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int64_t, int32_t))pcode; + (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I64(4), ARG_I32(5)); } NOINLINE static void CallFunc_I32_I32_I32_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) @@ -648,10 +660,10 @@ namespace (*fptr)(&framePointer, ARG_I32(0), pPortableEntryPoint); } - static void CallFunc_I64_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I64_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - void (*fptr)(int64_t) = (void (*)(int64_t))pcode; - (*fptr)(ARG_I64(0)); + void (*fptr)(int64_t, int32_t) = (void (*)(int64_t, int32_t))pcode; + (*fptr)(ARG_I64(0), ARG_I32(1)); } NOINLINE static void CallFunc_Void_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) @@ -673,29 +685,30 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "Mffip", (void*)&CallFunc_F32_I32_RetF32_PE }, { "Mffp", (void*)&CallFunc_F32_RetF32_PE }, { "Mi", (void*)&CallFunc_Void_RetI32 }, - { "MiS64", (void*)&CallFunc_S64_RetI32 }, + { "MiS64i", (void*)&CallFunc_S64_I32_RetI32 }, { "MiS8", (void*)&CallFunc_S8_RetI32 }, - { "MiS8S8S8", (void*)&CallFunc_S8_S8_S8_RetI32 }, - { "MiS8S8i", (void*)&CallFunc_S8_S8_I32_RetI32 }, - { "MiS8S8iS8", (void*)&CallFunc_S8_S8_I32_S8_RetI32 }, + { "MiS8S8S8i", (void*)&CallFunc_S8_S8_S8_I32_RetI32 }, + { "MiS8S8iS8i", (void*)&CallFunc_S8_S8_I32_S8_I32_RetI32 }, { "MiS8S8ii", (void*)&CallFunc_S8_S8_I32_I32_RetI32 }, + { "MiS8S8iii", (void*)&CallFunc_S8_S8_I32_I32_I32_RetI32 }, { "MiS8i", (void*)&CallFunc_S8_I32_RetI32 }, - { "MiS8iS8S8", (void*)&CallFunc_S8_I32_S8_S8_RetI32 }, - { "MiS8iS8i", (void*)&CallFunc_S8_I32_S8_I32_RetI32 }, + { "MiS8iS8S8i", (void*)&CallFunc_S8_I32_S8_S8_I32_RetI32 }, + { "MiS8iS8ii", (void*)&CallFunc_S8_I32_S8_I32_I32_RetI32 }, { "MiS8ii", (void*)&CallFunc_S8_I32_I32_RetI32 }, { "MiS8iii", (void*)&CallFunc_S8_I32_I32_I32_RetI32 }, { "MiS8iiii", (void*)&CallFunc_S8_I32_I32_I32_I32_RetI32 }, { "MiS8iiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_RetI32 }, + { "MiS8iiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_RetI32 }, { "MiTip", (void*)&CallFunc_This_I32_RetI32_PE }, { "MiTp", (void*)&CallFunc_This_RetI32_PE }, { "Mii", (void*)&CallFunc_I32_RetI32 }, - { "MiiS8i", (void*)&CallFunc_I32_S8_I32_RetI32 }, - { "MiiS8iii", (void*)&CallFunc_I32_S8_I32_I32_I32_RetI32 }, + { "MiiS8ii", (void*)&CallFunc_I32_S8_I32_I32_RetI32 }, + { "MiiS8iiii", (void*)&CallFunc_I32_S8_I32_I32_I32_I32_RetI32 }, { "Miii", (void*)&CallFunc_I32_I32_RetI32 }, - { "MiiiS8iiS8", (void*)&CallFunc_I32_I32_S8_I32_I32_S8_RetI32 }, - { "MiiiS8iiii", (void*)&CallFunc_I32_I32_S8_I32_I32_I32_I32_RetI32 }, + { "MiiiS8iiS8i", (void*)&CallFunc_I32_I32_S8_I32_I32_S8_I32_RetI32 }, + { "MiiiS8iiiii", (void*)&CallFunc_I32_I32_S8_I32_I32_I32_I32_I32_RetI32 }, { "Miiii", (void*)&CallFunc_I32_I32_I32_RetI32 }, - { "MiiiiS8iii", (void*)&CallFunc_I32_I32_I32_S8_I32_I32_I32_RetI32 }, + { "MiiiiS8iiii", (void*)&CallFunc_I32_I32_I32_S8_I32_I32_I32_I32_RetI32 }, { "Miiiii", (void*)&CallFunc_I32_I32_I32_I32_RetI32 }, { "Miiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_RetI32 }, { "Miiiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_RetI32 }, @@ -707,7 +720,7 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "Miiiil", (void*)&CallFunc_I32_I32_I32_I64_RetI32 }, { "Miiiip", (void*)&CallFunc_I32_I32_I32_RetI32_PE }, { "Miiil", (void*)&CallFunc_I32_I32_I64_RetI32 }, - { "Miiiliiii", (void*)&CallFunc_I32_I32_I64_I32_I32_I32_I32_RetI32 }, + { "Miiiliiiii", (void*)&CallFunc_I32_I32_I64_I32_I32_I32_I32_I32_RetI32 }, { "Miiip", (void*)&CallFunc_I32_I32_RetI32_PE }, { "Miil", (void*)&CallFunc_I32_I64_RetI32 }, { "Miili", (void*)&CallFunc_I32_I64_I32_RetI32 }, @@ -715,14 +728,14 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "Miill", (void*)&CallFunc_I32_I64_I64_RetI32 }, { "Miilli", (void*)&CallFunc_I32_I64_I64_I32_RetI32 }, { "Miip", (void*)&CallFunc_I32_RetI32_PE }, - { "Mil", (void*)&CallFunc_I64_RetI32 }, { "Mili", (void*)&CallFunc_I64_I32_RetI32 }, - { "Milili", (void*)&CallFunc_I64_I32_I64_I32_RetI32 }, + { "Milii", (void*)&CallFunc_I64_I32_I32_RetI32 }, + { "Mililii", (void*)&CallFunc_I64_I32_I64_I32_I32_RetI32 }, { "Mip", (void*)&CallFunc_Void_RetI32_PE }, { "Ml", (void*)&CallFunc_Void_RetI64 }, { "Mli", (void*)&CallFunc_I32_RetI64 }, { "Mliii", (void*)&CallFunc_I32_I32_I32_RetI64 }, - { "Mliiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_RetI64 }, + { "Mliiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_RetI64 }, { "Mliiil", (void*)&CallFunc_I32_I32_I32_I64_RetI64 }, { "Mlili", (void*)&CallFunc_I32_I64_I32_RetI64 }, { "Mlillp", (void*)&CallFunc_I32_I64_I64_RetI64_PE }, @@ -731,39 +744,40 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "Mlllp", (void*)&CallFunc_I64_I64_RetI64_PE }, { "Mlp", (void*)&CallFunc_Void_RetI64_PE }, { "Mv", (void*)&CallFunc_Void_RetVoid }, - { "MvS8", (void*)&CallFunc_S8_RetVoid }, - { "MvS8S8", (void*)&CallFunc_S8_S8_RetVoid }, - { "MvS8S8iiiii", (void*)&CallFunc_S8_S8_I32_I32_I32_I32_I32_RetVoid }, + { "MvS8S8i", (void*)&CallFunc_S8_S8_I32_RetVoid }, + { "MvS8S8iiiiii", (void*)&CallFunc_S8_S8_I32_I32_I32_I32_I32_I32_RetVoid }, { "MvS8i", (void*)&CallFunc_S8_I32_RetVoid }, { "MvS8ii", (void*)&CallFunc_S8_I32_I32_RetVoid }, { "MvS8iii", (void*)&CallFunc_S8_I32_I32_I32_RetVoid }, { "MvS8iiii", (void*)&CallFunc_S8_I32_I32_I32_I32_RetVoid }, { "MvS8iiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_RetVoid }, { "MvS8iiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_RetVoid }, - { "MvS8iiiiiiiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetVoid }, + { "MvS8iiiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_RetVoid }, + { "MvS8iiiiiiiiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetVoid }, { "MvTp", (void*)&CallFunc_This_RetVoid_PE }, - { "Mvdddddddddii", (void*)&CallFunc_F64_F64_F64_F64_F64_F64_F64_F64_F64_I32_I32_RetVoid }, - { "Mvdi", (void*)&CallFunc_F64_I32_RetVoid }, - { "Mvdiii", (void*)&CallFunc_F64_I32_I32_I32_RetVoid }, + { "Mvdddddddddiii", (void*)&CallFunc_F64_F64_F64_F64_F64_F64_F64_F64_F64_I32_I32_I32_RetVoid }, + { "Mvdii", (void*)&CallFunc_F64_I32_I32_RetVoid }, + { "Mvdiiii", (void*)&CallFunc_F64_I32_I32_I32_I32_RetVoid }, { "Mvdiip", (void*)&CallFunc_F64_I32_I32_RetVoid_PE }, { "Mvfiip", (void*)&CallFunc_F32_I32_I32_RetVoid_PE }, { "Mvi", (void*)&CallFunc_I32_RetVoid }, - { "MviS8i", (void*)&CallFunc_I32_S8_I32_RetVoid }, + { "MviS8ii", (void*)&CallFunc_I32_S8_I32_I32_RetVoid }, { "Mvii", (void*)&CallFunc_I32_I32_RetVoid }, - { "MviiS8S8i", (void*)&CallFunc_I32_I32_S8_S8_I32_RetVoid }, { "MviiS8S8ii", (void*)&CallFunc_I32_I32_S8_S8_I32_I32_RetVoid }, - { "Mviid", (void*)&CallFunc_I32_I32_F64_RetVoid }, + { "MviiS8S8iii", (void*)&CallFunc_I32_I32_S8_S8_I32_I32_I32_RetVoid }, + { "Mviidi", (void*)&CallFunc_I32_I32_F64_I32_RetVoid }, { "Mviii", (void*)&CallFunc_I32_I32_I32_RetVoid }, - { "MviiiS8S8", (void*)&CallFunc_I32_I32_I32_S8_S8_RetVoid }, { "MviiiS8S8i", (void*)&CallFunc_I32_I32_I32_S8_S8_I32_RetVoid }, + { "MviiiS8S8ii", (void*)&CallFunc_I32_I32_I32_S8_S8_I32_I32_RetVoid }, { "Mviiii", (void*)&CallFunc_I32_I32_I32_I32_RetVoid }, { "Mviiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_RetVoid }, { "Mviiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_RetVoid }, - { "Mviiiil", (void*)&CallFunc_I32_I32_I32_I32_I64_RetVoid }, + { "Mviiiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_I32_RetVoid }, + { "Mviiiili", (void*)&CallFunc_I32_I32_I32_I32_I64_I32_RetVoid }, { "Mviiip", (void*)&CallFunc_I32_I32_I32_RetVoid_PE }, { "Mviip", (void*)&CallFunc_I32_I32_RetVoid_PE }, { "Mvip", (void*)&CallFunc_I32_RetVoid_PE }, - { "Mvl", (void*)&CallFunc_I64_RetVoid }, + { "Mvli", (void*)&CallFunc_I64_I32_RetVoid }, { "Mvp", (void*)&CallFunc_Void_RetVoid_PE } }; diff --git a/src/coreclr/vm/wasm/browser/callhelpers-pinvoke.cpp b/src/coreclr/vm/wasm/browser/callhelpers-pinvoke.cpp index 9dbd7f579c68e6..2248bb068804aa 100644 --- a/src/coreclr/vm/wasm/browser/callhelpers-pinvoke.cpp +++ b/src/coreclr/vm/wasm/browser/callhelpers-pinvoke.cpp @@ -11,7 +11,6 @@ #include extern "C" { - uint32_t CompressionNative_CompressBound (uint32_t); uint32_t CompressionNative_Crc32 (uint32_t, void *, int32_t); int32_t CompressionNative_Deflate (void *, int32_t); int32_t CompressionNative_DeflateEnd (void *); @@ -196,7 +195,6 @@ static const Entry s_libSystem_Globalization_Native [] = { }; static const Entry s_libSystem_IO_Compression_Native [] = { - DllImportEntry(CompressionNative_CompressBound) // System.IO.Compression DllImportEntry(CompressionNative_Crc32) // System.IO.Compression DllImportEntry(CompressionNative_Deflate) // System.IO.Compression, System.Net.WebSockets DllImportEntry(CompressionNative_DeflateEnd) // System.IO.Compression, System.Net.WebSockets @@ -236,7 +234,7 @@ static const Entry s_libSystem_Native [] = { DllImportEntry(SystemNative_Free) // System.Private.CoreLib DllImportEntry(SystemNative_FreeLibrary) // System.Private.CoreLib DllImportEntry(SystemNative_GetCpuUtilization) // System.Private.CoreLib - DllImportEntry(SystemNative_GetCryptographicallySecureRandomBytes) // System.Private.CoreLib, System.Security.Cryptography + DllImportEntry(SystemNative_GetCryptographicallySecureRandomBytes) // System.IO.Compression, System.Private.CoreLib, System.Security.Cryptography DllImportEntry(SystemNative_GetCwd) // System.Private.CoreLib DllImportEntry(SystemNative_GetDefaultSearchOrderPseudoHandle) // System.Private.CoreLib DllImportEntry(SystemNative_GetErrNo) // System.Private.CoreLib @@ -326,7 +324,7 @@ typedef struct PInvokeTable { static PInvokeTable s_PInvokeTables[] = { {"libSystem.Globalization.Native", s_libSystem_Globalization_Native, 34}, - {"libSystem.IO.Compression.Native", s_libSystem_IO_Compression_Native, 10}, + {"libSystem.IO.Compression.Native", s_libSystem_IO_Compression_Native, 9}, {"libSystem.Native", s_libSystem_Native, 94}, {"libSystem.Native.Browser", s_libSystem_Native_Browser, 1}, {"libSystem.Runtime.InteropServices.JavaScript.Native", s_libSystem_Runtime_InteropServices_JavaScript_Native, 6} diff --git a/src/coreclr/vm/wasm/wasi/callhelpers-interp-to-managed.cpp b/src/coreclr/vm/wasm/wasi/callhelpers-interp-to-managed.cpp index 0033e59ea2469e..073e10d6b3cf57 100644 --- a/src/coreclr/vm/wasm/wasi/callhelpers-interp-to-managed.cpp +++ b/src/coreclr/vm/wasm/wasi/callhelpers-interp-to-managed.cpp @@ -88,10 +88,10 @@ namespace *((int32_t*)pRet) = (*fptr)(); } - static void CallFunc_S64_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_S64_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t) = (int32_t (*)(int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0)); + int32_t (*fptr)(int32_t, int32_t) = (int32_t (*)(int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(8)); } static void CallFunc_S8_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) @@ -100,28 +100,28 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_IND(0)); } - static void CallFunc_S8_S8_S8_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_S8_S8_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_IND(2)); + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_IND(2), ARG_I32(3)); } - static void CallFunc_S8_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_S8_S8_I32_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2)); + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_IND(3), ARG_I32(4)); } - static void CallFunc_S8_S8_I32_S8_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_S8_S8_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_IND(3)); + *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_I32(3)); } - static void CallFunc_S8_S8_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_S8_S8_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_I32(3)); + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_I32(3), ARG_I32(4)); } static void CallFunc_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) @@ -130,16 +130,16 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1)); } - static void CallFunc_S8_I32_S8_S8_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_S8_I32_S8_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_IND(2), ARG_IND(3)); + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_IND(2), ARG_IND(3), ARG_I32(4)); } - static void CallFunc_S8_I32_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_S8_I32_S8_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_IND(2), ARG_I32(3)); + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_IND(2), ARG_I32(3), ARG_I32(4)); } static void CallFunc_S8_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) @@ -166,6 +166,12 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5)); } + static void CallFunc_S8_I32_I32_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); + } + NOINLINE static void CallFunc_This_I32_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; @@ -186,16 +192,16 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_I32(0)); } - static void CallFunc_I32_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I32_S8_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_IND(1), ARG_I32(2)); + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_IND(1), ARG_I32(2), ARG_I32(3)); } - static void CallFunc_I32_S8_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I32_S8_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_IND(1), ARG_I32(2), ARG_I32(3), ARG_I32(4)); + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_IND(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5)); } static void CallFunc_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) @@ -204,16 +210,16 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1)); } - static void CallFunc_I32_I32_S8_I32_I32_S8_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I32_I32_S8_I32_I32_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_I32(3), ARG_I32(4), ARG_IND(5)); + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_I32(3), ARG_I32(4), ARG_IND(5), ARG_I32(6)); } - static void CallFunc_I32_I32_S8_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I32_I32_S8_I32_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7)); } static void CallFunc_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) @@ -222,10 +228,10 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2)); } - static void CallFunc_I32_I32_I32_S8_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I32_I32_I32_S8_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7)); } static void CallFunc_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) @@ -366,10 +372,10 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_I64(0)); } - static void CallFunc_I64_I32_I64_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I64_I32_I64_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int64_t, int32_t, int64_t, int32_t) = (int32_t (*)(int64_t, int32_t, int64_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I64(0), ARG_I32(1), ARG_I64(2), ARG_I32(3)); + int32_t (*fptr)(int64_t, int32_t, int64_t, int32_t, int32_t) = (int32_t (*)(int64_t, int32_t, int64_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I64(0), ARG_I32(1), ARG_I64(2), ARG_I32(3), ARG_I32(4)); } NOINLINE static void CallFunc_Void_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) @@ -450,22 +456,16 @@ namespace (*fptr)(); } - static void CallFunc_S8_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_S8_S8_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - void (*fptr)(int32_t) = (void (*)(int32_t))pcode; - (*fptr)(ARG_IND(0)); - } - - static void CallFunc_S8_S8_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t) = (void (*)(int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_IND(1)); + void (*fptr)(int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2)); } - static void CallFunc_S8_S8_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_S8_S8_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7)); } static void CallFunc_S8_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) @@ -504,10 +504,16 @@ namespace (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); } - static void CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7)); + } + + static void CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7), ARG_I32(8), ARG_I32(9), ARG_I32(10), ARG_I32(11)); + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7), ARG_I32(8), ARG_I32(9), ARG_I32(10), ARG_I32(11), ARG_I32(12)); } NOINLINE static void CallFunc_This_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) @@ -537,10 +543,10 @@ namespace (*fptr)(ARG_I32(0)); } - static void CallFunc_I32_S8_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I32_S8_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - void (*fptr)(int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_IND(1), ARG_I32(2)); + void (*fptr)(int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_I32(0), ARG_IND(1), ARG_I32(2), ARG_I32(3)); } static void CallFunc_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) @@ -549,28 +555,22 @@ namespace (*fptr)(ARG_I32(0), ARG_I32(1)); } - static void CallFunc_I32_I32_S8_S8_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_IND(3), ARG_I32(4)); - } - static void CallFunc_I32_I32_S8_S8_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_IND(3), ARG_I32(4), ARG_I32(5)); } - static void CallFunc_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I32_I32_S8_S8_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - void (*fptr)(int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2)); + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_IND(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); } - static void CallFunc_I32_I32_I32_S8_S8_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_IND(4)); + void (*fptr)(int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2)); } static void CallFunc_I32_I32_I32_S8_S8_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) @@ -579,6 +579,12 @@ namespace (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_IND(4), ARG_I32(5)); } + static void CallFunc_I32_I32_I32_S8_S8_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_IND(4), ARG_I32(5), ARG_I32(6)); + } + static void CallFunc_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { void (*fptr)(int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t))pcode; @@ -597,6 +603,12 @@ namespace (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5)); } + static void CallFunc_I32_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); + } + NOINLINE static void CallFunc_I32_I32_I32_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; @@ -624,10 +636,10 @@ namespace (*fptr)(&framePointer, ARG_I32(0), pPortableEntryPoint); } - static void CallFunc_I64_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + static void CallFunc_I64_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { - void (*fptr)(int64_t) = (void (*)(int64_t))pcode; - (*fptr)(ARG_I64(0)); + void (*fptr)(int64_t, int32_t) = (void (*)(int64_t, int32_t))pcode; + (*fptr)(ARG_I64(0), ARG_I32(1)); } NOINLINE static void CallFunc_Void_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) @@ -649,29 +661,30 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "Mffip", (void*)&CallFunc_F32_I32_RetF32_PE }, { "Mffp", (void*)&CallFunc_F32_RetF32_PE }, { "Mi", (void*)&CallFunc_Void_RetI32 }, - { "MiS64", (void*)&CallFunc_S64_RetI32 }, + { "MiS64i", (void*)&CallFunc_S64_I32_RetI32 }, { "MiS8", (void*)&CallFunc_S8_RetI32 }, - { "MiS8S8S8", (void*)&CallFunc_S8_S8_S8_RetI32 }, - { "MiS8S8i", (void*)&CallFunc_S8_S8_I32_RetI32 }, - { "MiS8S8iS8", (void*)&CallFunc_S8_S8_I32_S8_RetI32 }, + { "MiS8S8S8i", (void*)&CallFunc_S8_S8_S8_I32_RetI32 }, + { "MiS8S8iS8i", (void*)&CallFunc_S8_S8_I32_S8_I32_RetI32 }, { "MiS8S8ii", (void*)&CallFunc_S8_S8_I32_I32_RetI32 }, + { "MiS8S8iii", (void*)&CallFunc_S8_S8_I32_I32_I32_RetI32 }, { "MiS8i", (void*)&CallFunc_S8_I32_RetI32 }, - { "MiS8iS8S8", (void*)&CallFunc_S8_I32_S8_S8_RetI32 }, - { "MiS8iS8i", (void*)&CallFunc_S8_I32_S8_I32_RetI32 }, + { "MiS8iS8S8i", (void*)&CallFunc_S8_I32_S8_S8_I32_RetI32 }, + { "MiS8iS8ii", (void*)&CallFunc_S8_I32_S8_I32_I32_RetI32 }, { "MiS8ii", (void*)&CallFunc_S8_I32_I32_RetI32 }, { "MiS8iii", (void*)&CallFunc_S8_I32_I32_I32_RetI32 }, { "MiS8iiii", (void*)&CallFunc_S8_I32_I32_I32_I32_RetI32 }, { "MiS8iiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_RetI32 }, + { "MiS8iiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_RetI32 }, { "MiTip", (void*)&CallFunc_This_I32_RetI32_PE }, { "MiTp", (void*)&CallFunc_This_RetI32_PE }, { "Mii", (void*)&CallFunc_I32_RetI32 }, - { "MiiS8i", (void*)&CallFunc_I32_S8_I32_RetI32 }, - { "MiiS8iii", (void*)&CallFunc_I32_S8_I32_I32_I32_RetI32 }, + { "MiiS8ii", (void*)&CallFunc_I32_S8_I32_I32_RetI32 }, + { "MiiS8iiii", (void*)&CallFunc_I32_S8_I32_I32_I32_I32_RetI32 }, { "Miii", (void*)&CallFunc_I32_I32_RetI32 }, - { "MiiiS8iiS8", (void*)&CallFunc_I32_I32_S8_I32_I32_S8_RetI32 }, - { "MiiiS8iiii", (void*)&CallFunc_I32_I32_S8_I32_I32_I32_I32_RetI32 }, + { "MiiiS8iiS8i", (void*)&CallFunc_I32_I32_S8_I32_I32_S8_I32_RetI32 }, + { "MiiiS8iiiii", (void*)&CallFunc_I32_I32_S8_I32_I32_I32_I32_I32_RetI32 }, { "Miiii", (void*)&CallFunc_I32_I32_I32_RetI32 }, - { "MiiiiS8iii", (void*)&CallFunc_I32_I32_I32_S8_I32_I32_I32_RetI32 }, + { "MiiiiS8iiii", (void*)&CallFunc_I32_I32_I32_S8_I32_I32_I32_I32_RetI32 }, { "Miiiii", (void*)&CallFunc_I32_I32_I32_I32_RetI32 }, { "Miiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_RetI32 }, { "Miiiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_RetI32 }, @@ -694,7 +707,7 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "Miilli", (void*)&CallFunc_I32_I64_I64_I32_RetI32 }, { "Miip", (void*)&CallFunc_I32_RetI32_PE }, { "Mil", (void*)&CallFunc_I64_RetI32 }, - { "Milili", (void*)&CallFunc_I64_I32_I64_I32_RetI32 }, + { "Mililii", (void*)&CallFunc_I64_I32_I64_I32_I32_RetI32 }, { "Mip", (void*)&CallFunc_Void_RetI32_PE }, { "Ml", (void*)&CallFunc_Void_RetI64 }, { "Mli", (void*)&CallFunc_I32_RetI64 }, @@ -707,35 +720,36 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "Mlllp", (void*)&CallFunc_I64_I64_RetI64_PE }, { "Mlp", (void*)&CallFunc_Void_RetI64_PE }, { "Mv", (void*)&CallFunc_Void_RetVoid }, - { "MvS8", (void*)&CallFunc_S8_RetVoid }, - { "MvS8S8", (void*)&CallFunc_S8_S8_RetVoid }, - { "MvS8S8iiiii", (void*)&CallFunc_S8_S8_I32_I32_I32_I32_I32_RetVoid }, + { "MvS8S8i", (void*)&CallFunc_S8_S8_I32_RetVoid }, + { "MvS8S8iiiiii", (void*)&CallFunc_S8_S8_I32_I32_I32_I32_I32_I32_RetVoid }, { "MvS8i", (void*)&CallFunc_S8_I32_RetVoid }, { "MvS8ii", (void*)&CallFunc_S8_I32_I32_RetVoid }, { "MvS8iii", (void*)&CallFunc_S8_I32_I32_I32_RetVoid }, { "MvS8iiii", (void*)&CallFunc_S8_I32_I32_I32_I32_RetVoid }, { "MvS8iiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_RetVoid }, { "MvS8iiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_RetVoid }, - { "MvS8iiiiiiiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetVoid }, + { "MvS8iiiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_RetVoid }, + { "MvS8iiiiiiiiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetVoid }, { "MvTp", (void*)&CallFunc_This_RetVoid_PE }, { "Mvdiip", (void*)&CallFunc_F64_I32_I32_RetVoid_PE }, { "Mvfiip", (void*)&CallFunc_F32_I32_I32_RetVoid_PE }, { "Mvi", (void*)&CallFunc_I32_RetVoid }, - { "MviS8i", (void*)&CallFunc_I32_S8_I32_RetVoid }, + { "MviS8ii", (void*)&CallFunc_I32_S8_I32_I32_RetVoid }, { "Mvii", (void*)&CallFunc_I32_I32_RetVoid }, - { "MviiS8S8i", (void*)&CallFunc_I32_I32_S8_S8_I32_RetVoid }, { "MviiS8S8ii", (void*)&CallFunc_I32_I32_S8_S8_I32_I32_RetVoid }, + { "MviiS8S8iii", (void*)&CallFunc_I32_I32_S8_S8_I32_I32_I32_RetVoid }, { "Mviii", (void*)&CallFunc_I32_I32_I32_RetVoid }, - { "MviiiS8S8", (void*)&CallFunc_I32_I32_I32_S8_S8_RetVoid }, { "MviiiS8S8i", (void*)&CallFunc_I32_I32_I32_S8_S8_I32_RetVoid }, + { "MviiiS8S8ii", (void*)&CallFunc_I32_I32_I32_S8_S8_I32_I32_RetVoid }, { "Mviiii", (void*)&CallFunc_I32_I32_I32_I32_RetVoid }, { "Mviiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_RetVoid }, { "Mviiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_RetVoid }, + { "Mviiiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_I32_RetVoid }, { "Mviiip", (void*)&CallFunc_I32_I32_I32_RetVoid_PE }, { "Mviip", (void*)&CallFunc_I32_I32_RetVoid_PE }, { "Mvili", (void*)&CallFunc_I32_I64_I32_RetVoid }, { "Mvip", (void*)&CallFunc_I32_RetVoid_PE }, - { "Mvl", (void*)&CallFunc_I64_RetVoid }, + { "Mvli", (void*)&CallFunc_I64_I32_RetVoid }, { "Mvp", (void*)&CallFunc_Void_RetVoid_PE } }; diff --git a/src/coreclr/vm/wasm/wasi/callhelpers-pinvoke.cpp b/src/coreclr/vm/wasm/wasi/callhelpers-pinvoke.cpp index e128a77b7bd640..0a5a7cd5c3d52e 100644 --- a/src/coreclr/vm/wasm/wasi/callhelpers-pinvoke.cpp +++ b/src/coreclr/vm/wasm/wasi/callhelpers-pinvoke.cpp @@ -11,7 +11,6 @@ #include extern "C" { - uint32_t CompressionNative_CompressBound (uint32_t); uint32_t CompressionNative_Crc32 (uint32_t, void *, int32_t); int32_t CompressionNative_Deflate (void *, int32_t); int32_t CompressionNative_DeflateEnd (void *); @@ -94,6 +93,7 @@ extern "C" { int32_t SystemNative_GetBytesAvailable (void *, void *); int32_t SystemNative_GetControlMessageBufferSize (int32_t, int32_t); double SystemNative_GetCpuUtilization (void *); + int32_t SystemNative_GetCryptographicallySecureRandomBytes (void *, int32_t); void * SystemNative_GetCwd (void *, int32_t); void * SystemNative_GetDefaultSearchOrderPseudoHandle (); int32_t SystemNative_GetErrNo (); @@ -290,7 +290,6 @@ static const Entry s_libSystem_Globalization_Native [] = { }; static const Entry s_libSystem_IO_Compression_Native [] = { - DllImportEntry(CompressionNative_CompressBound) // System.IO.Compression DllImportEntry(CompressionNative_Crc32) // System.IO.Compression DllImportEntry(CompressionNative_Deflate) // System.IO.Compression DllImportEntry(CompressionNative_DeflateEnd) // System.IO.Compression @@ -342,6 +341,7 @@ static const Entry s_libSystem_Native [] = { DllImportEntry(SystemNative_GetBytesAvailable) // System.Net.Sockets DllImportEntry(SystemNative_GetControlMessageBufferSize) // System.Net.Sockets DllImportEntry(SystemNative_GetCpuUtilization) // System.Private.CoreLib + DllImportEntry(SystemNative_GetCryptographicallySecureRandomBytes) // System.IO.Compression DllImportEntry(SystemNative_GetCwd) // System.Private.CoreLib DllImportEntry(SystemNative_GetDefaultSearchOrderPseudoHandle) // System.Private.CoreLib DllImportEntry(SystemNative_GetErrNo) // System.Net.NameResolution, System.Private.CoreLib @@ -526,8 +526,8 @@ typedef struct PInvokeTable { static PInvokeTable s_PInvokeTables[] = { {"libSystem.Globalization.Native", s_libSystem_Globalization_Native, 34}, - {"libSystem.IO.Compression.Native", s_libSystem_IO_Compression_Native, 10}, - {"libSystem.Native", s_libSystem_Native, 147}, + {"libSystem.IO.Compression.Native", s_libSystem_IO_Compression_Native, 9}, + {"libSystem.Native", s_libSystem_Native, 148}, {"libSystem.Native.Browser", s_libSystem_Native_Browser, 0}, {"libSystem.Runtime.InteropServices.JavaScript.Native", s_libSystem_Runtime_InteropServices_JavaScript_Native, 0}, {"wasi:clocks/monotonic-clock@0.2.8", s_wasi_3A_clocks_2F_monotonic_clock_40_0_2_8, 4}, From 780f494666e0636035b56bb8b982dd4270f7cac4 Mon Sep 17 00:00:00 2001 From: David Wrighton Date: Wed, 19 Aug 2026 15:56:20 -0700 Subject: [PATCH 12/23] Rename QCall exception status and fix signatures Rename the managed and native status carrier to QCallExceptionStatus and update its custom marshaller. Restore runtime-neutral Objective-C wrappers, align the AssemblyName declaration, and remove exception capture from the non-throwing GC mode helper. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 97d405de-8e39-4e76-afe4-2f94b74ecfa2 --- .../System.Private.CoreLib.csproj | 2 +- .../Runtime/CompilerHelpers/ThrowHelpers.cs | 10 +- .../VersionResilientHashCode.CoreCLR.cs | 2 +- .../src/System/AppContext.CoreCLR.cs | 2 +- .../src/System/ArgIterator.cs | 10 +- .../src/System/Array.CoreCLR.cs | 6 +- .../src/System/CLRConfig.cs | 2 +- .../System/ComAwareWeakReference.CoreCLR.cs | 4 +- .../src/System/Delegate.CoreCLR.cs | 16 +-- .../src/System/Diagnostics/Debugger.cs | 4 +- .../System/Diagnostics/StackFrame.CoreCLR.cs | 2 +- .../System/Diagnostics/StackTrace.CoreCLR.cs | 2 +- .../src/System/Enum.CoreCLR.cs | 2 +- .../src/System/Environment.CoreCLR.cs | 6 +- .../src/System/Exception.CoreCLR.cs | 6 +- .../src/System/GC.CoreCLR.cs | 38 ++--- .../System/IO/FileLoadException.CoreCLR.cs | 4 +- .../src/System/IO/Stream.CoreCLR.cs | 2 +- .../src/System/Reflection/Assembly.CoreCLR.cs | 4 +- .../System/Reflection/AssemblyName.CoreCLR.cs | 2 +- .../Reflection/Emit/RuntimeAssemblyBuilder.cs | 2 +- .../Reflection/Emit/RuntimeModuleBuilder.cs | 18 +-- .../Reflection/Emit/RuntimeTypeBuilder.cs | 42 +++--- .../src/System/Reflection/LoaderAllocator.cs | 2 +- .../src/System/Reflection/MdImport.cs | 2 +- .../Reflection/Metadata/AssemblyExtensions.cs | 2 +- .../Reflection/Metadata/MetadataUpdater.cs | 4 +- .../System/Reflection/MethodBase.CoreCLR.cs | 2 +- .../src/System/Reflection/RuntimeAssembly.cs | 46 +++--- .../Reflection/RuntimeCustomAttributeData.cs | 4 +- .../src/System/Reflection/RuntimeModule.cs | 6 +- .../Reflection/TypeNameResolver.CoreCLR.cs | 2 +- .../CompilerServices/AsyncHelpers.CoreCLR.cs | 2 +- .../Runtime/CompilerServices/CastHelpers.cs | 4 +- .../CompilerServices/GenericsHelpers.cs | 2 +- .../Runtime/CompilerServices/InitHelpers.cs | 2 +- ...llException.cs => QCallExceptionStatus.cs} | 10 +- .../RuntimeHelpers.CoreCLR.cs | 24 ++-- .../CompilerServices/StaticsHelpers.cs | 4 +- .../VirtualDispatchHelpers.cs | 2 +- .../Runtime/ControlledExecution.CoreCLR.cs | 2 +- .../src/System/Runtime/DependentHandle.cs | 4 +- .../ExceptionServices/InternalCalls.cs | 10 +- .../InteropServices/ComWrappers.CoreCLR.cs | 4 +- .../InteropServices/GCHandle.CoreCLR.cs | 6 +- .../Java/JavaMarshal.CoreCLR.cs | 6 +- .../InteropServices/Marshal.CoreCLR.cs | 60 ++++---- .../InteropServices/NativeLibrary.CoreCLR.cs | 2 +- .../ObjectiveCMarshal.CoreCLR.cs | 11 +- .../TrackerObjectManager.CoreCLR.cs | 2 +- .../Loader/AssemblyLoadContext.CoreCLR.cs | 26 ++-- .../src/System/RuntimeHandles.cs | 122 ++++++++-------- .../src/System/RuntimeType.BoxCache.cs | 2 +- .../src/System/RuntimeType.CoreCLR.cs | 8 +- ...meType.CreateUninitializedCache.CoreCLR.cs | 2 +- .../src/System/String.CoreCLR.cs | 4 +- .../src/System/StubHelpers.cs | 44 +++--- .../System/Threading/ObjectHeader.CoreCLR.cs | 2 +- .../src/System/Threading/Thread.CoreCLR.cs | 28 ++-- .../src/System/TypeLoadException.CoreCLR.cs | 2 +- .../src/System/ValueType.cs | 4 +- .../src/System/Variant.cs | 4 +- src/coreclr/vm/JitQCallHelpers.h | 14 +- src/coreclr/vm/appdomainnative.cpp | 10 +- src/coreclr/vm/appdomainnative.hpp | 10 +- src/coreclr/vm/arraynative.cpp | 6 +- src/coreclr/vm/arraynative.h | 6 +- src/coreclr/vm/assemblynative.cpp | 82 +++++------ src/coreclr/vm/assemblynative.hpp | 84 +++++------ src/coreclr/vm/clrconfignative.cpp | 2 +- src/coreclr/vm/clrconfignative.h | 2 +- src/coreclr/vm/comdelegate.cpp | 16 +-- src/coreclr/vm/comdelegate.h | 16 +-- src/coreclr/vm/comdependenthandle.cpp | 4 +- src/coreclr/vm/comdependenthandle.h | 4 +- src/coreclr/vm/comdynamic.cpp | 44 +++--- src/coreclr/vm/comdynamic.h | 44 +++--- src/coreclr/vm/commodule.cpp | 28 ++-- src/coreclr/vm/commodule.h | 28 ++-- src/coreclr/vm/comsynchronizable.cpp | 32 ++--- src/coreclr/vm/comsynchronizable.h | 32 ++--- src/coreclr/vm/comutilnative.cpp | 74 +++++----- src/coreclr/vm/comutilnative.h | 80 +++++------ src/coreclr/vm/coreassemblyspec.cpp | 2 +- src/coreclr/vm/customattribute.cpp | 4 +- src/coreclr/vm/customattribute.h | 4 +- src/coreclr/vm/debugdebugger.cpp | 10 +- src/coreclr/vm/debugdebugger.h | 10 +- src/coreclr/vm/eventpipeinternal.cpp | 24 ++-- src/coreclr/vm/eventpipeinternal.h | 24 ++-- src/coreclr/vm/excep.cpp | 10 +- src/coreclr/vm/exceptionhandling.cpp | 10 +- src/coreclr/vm/exceptionhandlingqcalls.h | 10 +- src/coreclr/vm/exceptmacros.h | 8 +- src/coreclr/vm/finalizerthread.cpp | 4 +- src/coreclr/vm/ilmarshalers.cpp | 10 +- src/coreclr/vm/ilmarshalers.h | 10 +- src/coreclr/vm/interoplibinterface.h | 12 +- .../vm/interoplibinterface_comwrappers.cpp | 6 +- .../vm/interoplibinterface_comwrappers.h | 6 +- src/coreclr/vm/interoplibinterface_java.cpp | 6 +- src/coreclr/vm/interoplibinterface_objc.cpp | 6 +- src/coreclr/vm/jithelpers.cpp | 14 +- src/coreclr/vm/loaderallocator.cpp | 2 +- src/coreclr/vm/loaderallocator.hpp | 2 +- src/coreclr/vm/managedmdimport.cpp | 2 +- src/coreclr/vm/managedmdimport.hpp | 2 +- src/coreclr/vm/marshalnative.cpp | 76 +++++----- src/coreclr/vm/marshalnative.h | 66 ++++----- src/coreclr/vm/method.hpp | 2 +- src/coreclr/vm/mlinfo.cpp | 2 +- src/coreclr/vm/multicorejit.cpp | 4 +- src/coreclr/vm/multicorejit.h | 4 +- src/coreclr/vm/nativeeventsource.cpp | 38 ++--- src/coreclr/vm/nativeeventsource.h | 38 ++--- src/coreclr/vm/nativelibrarynative.cpp | 2 +- src/coreclr/vm/nativelibrarynative.h | 2 +- src/coreclr/vm/olevariant.cpp | 2 +- src/coreclr/vm/olevariant.h | 2 +- src/coreclr/vm/qcall.cpp | 2 +- src/coreclr/vm/qcall.h | 6 +- src/coreclr/vm/reflectioninvocation.cpp | 50 +++---- src/coreclr/vm/reflectioninvocation.h | 22 +-- src/coreclr/vm/runtimehandles.cpp | 104 +++++++------- src/coreclr/vm/runtimehandles.h | 134 +++++++++--------- src/coreclr/vm/stackwalk.h | 4 +- src/coreclr/vm/stubhelpers.cpp | 32 ++--- src/coreclr/vm/stubhelpers.h | 34 ++--- src/coreclr/vm/tailcallhelp.cpp | 2 +- src/coreclr/vm/tailcallhelp.h | 2 +- src/coreclr/vm/unsafeaccessors.cpp | 2 +- src/coreclr/vm/varargsnative.cpp | 10 +- src/coreclr/vm/varargsnative.h | 10 +- src/coreclr/vm/versionresilienthashcode.cpp | 2 +- src/coreclr/vm/versionresilienthashcode.h | 2 +- src/coreclr/vm/wasm/entrypoints.h | 4 +- src/coreclr/vm/weakreferencenative.cpp | 4 +- src/coreclr/vm/weakreferencenative.h | 4 +- .../Diagnostics/Tracing/EventPipe.Internal.cs | 24 ++-- ...ntSource.Threading.NativeSinks.Internal.cs | 32 ++--- .../Tracing/TraceLogging/XplatEventLogger.cs | 6 +- .../ObjectiveC/ObjectiveCMarshal.cs | 12 +- .../InteropServices/TypeMapLazyDictionary.cs | 6 +- .../Threading/Wasi/WasiFinalizerScheduler.cs | 4 +- 144 files changed, 1109 insertions(+), 1122 deletions(-) rename src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/{QCallException.cs => QCallExceptionStatus.cs} (76%) diff --git a/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj b/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj index 9e77600c4db36d..87287c40db6c5a 100644 --- a/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj +++ b/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj @@ -208,7 +208,7 @@ - + diff --git a/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs b/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs index bb1ffe93f98e1a..1a11f8992c40b3 100644 --- a/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs @@ -12,7 +12,7 @@ internal static unsafe partial class ThrowHelpers { [DoesNotReturn] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowAmbiguousResolutionException")] - private static partial void ThrowAmbiguousResolutionException(MethodTable* targetType, MethodTable* interfaceType, void* methodDesc, out QCallException qcallException); + private static partial void ThrowAmbiguousResolutionException(MethodTable* targetType, MethodTable* interfaceType, void* methodDesc, out QCallExceptionStatus qcallException); [DoesNotReturn] [DebuggerHidden] @@ -26,7 +26,7 @@ internal static void ThrowAmbiguousResolutionException( [DoesNotReturn] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowEntryPointNotFoundException")] - private static partial void ThrowEntryPointNotFoundException(MethodTable* targetType, MethodTable* interfaceType, void* methodDesc, out QCallException qcallException); + private static partial void ThrowEntryPointNotFoundException(MethodTable* targetType, MethodTable* interfaceType, void* methodDesc, out QCallExceptionStatus qcallException); [DoesNotReturn] [DebuggerHidden] @@ -40,7 +40,7 @@ internal static void ThrowEntryPointNotFoundException( [DoesNotReturn] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowMethodAccessException")] - private static partial void ThrowMethodAccessExceptionInternal(void* caller, void* callee, out QCallException qcallException); + private static partial void ThrowMethodAccessExceptionInternal(void* caller, void* callee, out QCallExceptionStatus qcallException); // implementation of CORINFO_HELP_METHOD_ACCESS_EXCEPTION [DoesNotReturn] @@ -54,7 +54,7 @@ internal static void ThrowMethodAccessException( [DoesNotReturn] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowFieldAccessException")] - private static partial void ThrowFieldAccessExceptionInternal(void* caller, void* callee, out QCallException qcallException); + private static partial void ThrowFieldAccessExceptionInternal(void* caller, void* callee, out QCallExceptionStatus qcallException); // implementation of CORINFO_HELP_FIELD_ACCESS_EXCEPTION [DoesNotReturn] @@ -68,7 +68,7 @@ internal static void ThrowFieldAccessException( [DoesNotReturn] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowClassAccessException")] - private static partial void ThrowClassAccessExceptionInternal(void* caller, void* callee, out QCallException qcallException); + private static partial void ThrowClassAccessExceptionInternal(void* caller, void* callee, out QCallExceptionStatus qcallException); // implementation of CORINFO_HELP_CLASS_ACCESS_EXCEPTION [DoesNotReturn] diff --git a/src/coreclr/System.Private.CoreLib/src/Internal/VersionResilientHashCode.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/Internal/VersionResilientHashCode.CoreCLR.cs index 08a4581bedc335..d537c3f22631e1 100644 --- a/src/coreclr/System.Private.CoreLib/src/Internal/VersionResilientHashCode.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/Internal/VersionResilientHashCode.CoreCLR.cs @@ -14,7 +14,7 @@ namespace Internal internal static partial class VersionResilientHashCode { [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "VersionResilientHashCode_TypeHashCode")] - private static partial int TypeHashCode(QCallTypeHandle typeHandle, out QCallException qcallException); + private static partial int TypeHashCode(QCallTypeHandle typeHandle, out QCallExceptionStatus qcallException); public static int TypeHashCode(RuntimeType type) => TypeHashCode(new QCallTypeHandle(ref type), out _); diff --git a/src/coreclr/System.Private.CoreLib/src/System/AppContext.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/AppContext.CoreCLR.cs index 060e260ab79ca9..1aab2c72fa12ce 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/AppContext.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/AppContext.CoreCLR.cs @@ -18,7 +18,7 @@ private static bool IsKnownHostProperty(string name) [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AppContext_TryGetHostPropertyValue", StringMarshalling = StringMarshalling.Utf16)] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool TryGetHostPropertyValue(string name, StringHandleOnStack retValue, out QCallException qcallException); + private static partial bool TryGetHostPropertyValue(string name, StringHandleOnStack retValue, out QCallExceptionStatus qcallException); [UnmanagedCallersOnly] private static unsafe void OnProcessExit(Exception* pException) diff --git a/src/coreclr/System.Private.CoreLib/src/System/ArgIterator.cs b/src/coreclr/System.Private.CoreLib/src/System/ArgIterator.cs index 1571688362ed9a..a9bba91a3da2fa 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/ArgIterator.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/ArgIterator.cs @@ -41,7 +41,7 @@ public ArgIterator(RuntimeArgumentHandle arglist) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_Init")] - private static partial void Init(ArgIterator* thisPtr, IntPtr cookie, out QCallException qcallException); + private static partial void Init(ArgIterator* thisPtr, IntPtr cookie, out QCallExceptionStatus qcallException); // create an arg iterator that points just past 'firstArg'. // 'arglist' is the value returned by the ARGLIST instruction @@ -57,7 +57,7 @@ public ArgIterator(RuntimeArgumentHandle arglist, void* ptr) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_Init2")] - private static partial void Init(ArgIterator* thisPtr, IntPtr cookie, void* ptr, out QCallException qcallException); + private static partial void Init(ArgIterator* thisPtr, IntPtr cookie, void* ptr, out QCallExceptionStatus qcallException); // Fetch an argument as a typed referece, advance the iterator. // Throws an exception if past end of argument list @@ -83,7 +83,7 @@ public TypedReference GetNextArg() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_GetNextArg")] - private static partial void GetNextArg(ArgIterator* thisPtr, TypedReference* pResult, out QCallException qcallException); + private static partial void GetNextArg(ArgIterator* thisPtr, TypedReference* pResult, out QCallExceptionStatus qcallException); // Alternate version of GetNextArg() intended primarily for IJW code // generated by VC's "va_arg()" construct. @@ -118,7 +118,7 @@ public TypedReference GetNextArg(RuntimeTypeHandle rth) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_GetNextArg2")] - private static partial void GetNextArg(ArgIterator* thisPtr, QCallTypeHandle rth, TypedReference* pResult, out QCallException qcallException); + private static partial void GetNextArg(ArgIterator* thisPtr, QCallTypeHandle rth, TypedReference* pResult, out QCallExceptionStatus qcallException); // This method should invalidate the iterator (va_end). It is not supported yet. public void End() @@ -143,7 +143,7 @@ public RuntimeTypeHandle GetNextArgType() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_GetNextArgType")] - private static partial IntPtr GetNextArgType(ArgIterator* thisPtr, out QCallException qcallException); + private static partial IntPtr GetNextArgType(ArgIterator* thisPtr, out QCallExceptionStatus qcallException); public override int GetHashCode() { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Array.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Array.CoreCLR.cs index 8faa8a962e0033..d655ac4176c6f3 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Array.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Array.CoreCLR.cs @@ -18,7 +18,7 @@ public abstract partial class Array : ICloneable, IList, IStructuralComparable, [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Array_CreateInstance")] private static unsafe partial void InternalCreate(QCallTypeHandle type, int rank, int* pLengths, int* pLowerBounds, [MarshalAs(UnmanagedType.Bool)] bool fromArrayType, ObjectHandleOnStack retArray, - out QCallException qcallException); + out QCallExceptionStatus qcallException); private static unsafe Array InternalCreate(RuntimeType elementType, int rank, int* pLengths, int* pLowerBounds) { @@ -39,7 +39,7 @@ private static unsafe Array InternalCreateFromArrayType(RuntimeType arrayType, i } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Array_Ctor")] - private static unsafe partial void Ctor(MethodTable* pArrayMT, uint dwNumArgs, int* pArgList, ObjectHandleOnStack retArray, out QCallException qcallException); + private static unsafe partial void Ctor(MethodTable* pArrayMT, uint dwNumArgs, int* pArgList, ObjectHandleOnStack retArray, out QCallExceptionStatus qcallException); // implementation of CORINFO_HELP_NEW_MDARR and CORINFO_HELP_NEW_MDARR_RARE. [StackTraceHidden] @@ -353,7 +353,7 @@ internal sealed unsafe partial class ArrayInitializeCache : RuntimeType.IGeneric internal readonly delegate* ConstructorEntrypoint; [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Array_GetElementConstructorEntrypoint")] - private static partial delegate* GetElementConstructorEntrypoint(QCallTypeHandle arrayType, out QCallException qcallException); + private static partial delegate* GetElementConstructorEntrypoint(QCallTypeHandle arrayType, out QCallExceptionStatus qcallException); private ArrayInitializeCache(delegate* constructorEntrypoint) { diff --git a/src/coreclr/System.Private.CoreLib/src/System/CLRConfig.cs b/src/coreclr/System.Private.CoreLib/src/System/CLRConfig.cs index 908e1e076730ee..cd48a17172e0b9 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/CLRConfig.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/CLRConfig.cs @@ -17,6 +17,6 @@ internal static bool GetBoolValue(string switchName, out bool exist) [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ClrConfig_GetConfigBoolValue", StringMarshalling = StringMarshalling.Utf16)] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool GetConfigBoolValue(string configSwitchName, [MarshalAs(UnmanagedType.Bool)] out bool exist, out QCallException qcallException); + private static partial bool GetConfigBoolValue(string configSwitchName, [MarshalAs(UnmanagedType.Bool)] out bool exist, out QCallExceptionStatus qcallException); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/ComAwareWeakReference.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/ComAwareWeakReference.CoreCLR.cs index 872d5608acd16c..095861d08a5fc4 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/ComAwareWeakReference.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/ComAwareWeakReference.CoreCLR.cs @@ -10,7 +10,7 @@ namespace System internal sealed partial class ComAwareWeakReference { [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ComWeakRefToObject")] - private static partial void ComWeakRefToObject(IntPtr pComWeakRef, ObjectHandleOnStack retRcw, out QCallException qcallException); + private static partial void ComWeakRefToObject(IntPtr pComWeakRef, ObjectHandleOnStack retRcw, out QCallExceptionStatus qcallException); internal static object? ComWeakRefToObject(IntPtr pComWeakRef, object? context) { @@ -39,7 +39,7 @@ internal static bool PossiblyComObject(object target) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjectToComWeakRef")] - private static partial IntPtr ObjectToComWeakRef(ObjectHandleOnStack retRcw, out QCallException qcallException); + private static partial IntPtr ObjectToComWeakRef(ObjectHandleOnStack retRcw, out QCallExceptionStatus qcallException); internal static nint ObjectToComWeakRef(object target, out object? context) { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Delegate.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Delegate.CoreCLR.cs index a4fe7ebfa38719..5c72d4a5032c48 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Delegate.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Delegate.CoreCLR.cs @@ -535,7 +535,7 @@ private struct BindToMethodDetails [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_BindToMethodName", StringMarshalling = StringMarshalling.Utf8)] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool BindToMethodName(MethodTable* pDelegateMT, MethodTable *pTargetMT, QCallTypeHandle methodType, string method, DelegateBindingFlags flags, ObjectHandleOnStack targetParameter, out BindToMethodDetails bindToMethodDetails, out QCallException qcallException); + private static partial bool BindToMethodName(MethodTable* pDelegateMT, MethodTable *pTargetMT, QCallTypeHandle methodType, string method, DelegateBindingFlags flags, ObjectHandleOnStack targetParameter, out BindToMethodDetails bindToMethodDetails, out QCallExceptionStatus qcallException); private bool BindToMethodInfo(object? target, IRuntimeMethodInfo method, RuntimeType methodType, DelegateBindingFlags flags) { @@ -571,7 +571,7 @@ private bool BindToMethodInfo(object? target, IRuntimeMethodInfo method, Runtime [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_BindToMethodInfo")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool BindToMethodInfo(MethodTable* pDelegateMT, MethodTable *pTargetMT, RuntimeMethodHandleInternal method, QCallTypeHandle methodType, DelegateBindingFlags flags, ObjectHandleOnStack targetParameter, out BindToMethodDetails bindToMethodDetails, out QCallException qcallException); + private static partial bool BindToMethodInfo(MethodTable* pDelegateMT, MethodTable *pTargetMT, RuntimeMethodHandleInternal method, QCallTypeHandle methodType, DelegateBindingFlags flags, ObjectHandleOnStack targetParameter, out BindToMethodDetails bindToMethodDetails, out QCallExceptionStatus qcallException); private static Delegate InternalAlloc(RuntimeType type) { @@ -644,13 +644,13 @@ private void DelegateConstruct(object target, IntPtr method) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_Construct")] - private static partial void Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, IntPtr method, out BindToMethodDetails bindToMethodDetails, out QCallException qcallException); + private static partial void Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, IntPtr method, out BindToMethodDetails bindToMethodDetails, out QCallExceptionStatus qcallException); [MethodImpl(MethodImplOptions.InternalCall)] private static extern unsafe void* GetMulticastInvoke(MethodTable* pMT); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_GetMulticastInvokeSlow")] - private static unsafe partial void* GetMulticastInvokeSlow(MethodTable* pMT, out QCallException qcallException); + private static unsafe partial void* GetMulticastInvokeSlow(MethodTable* pMT, out QCallExceptionStatus qcallException); private unsafe IntPtr GetMulticastInvoke() { @@ -685,7 +685,7 @@ private static unsafe IRuntimeMethodInfo CreateMethodInfo(MethodDesc* methodDesc } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_CreateMethodInfo")] - private static unsafe partial void CreateMethodInfo(MethodDesc* methodDesc, ObjectHandleOnStack retMethodInfo, out QCallException qcallException); + private static unsafe partial void CreateMethodInfo(MethodDesc* methodDesc, ObjectHandleOnStack retMethodInfo, out QCallExceptionStatus qcallException); [MethodImpl(MethodImplOptions.NoInlining)] private unsafe MethodDesc* GetMethodDesc() @@ -695,7 +695,7 @@ private static unsafe IRuntimeMethodInfo CreateMethodInfo(MethodDesc* methodDesc } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_GetMethodDesc")] - private static unsafe partial MethodDesc* GetMethodDesc(ObjectHandleOnStack instance, out QCallException qcallException); + private static unsafe partial MethodDesc* GetMethodDesc(ObjectHandleOnStack instance, out QCallExceptionStatus qcallException); internal struct Wrapper(Delegate? value) : IEquatable { @@ -891,7 +891,7 @@ internal static IntPtr AdjustTarget(object target, IntPtr methodPtr) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_AdjustTarget")] - private static partial IntPtr AdjustTarget(MethodTable* targetMT, IntPtr methodPtr, out QCallException qcallException); + private static partial IntPtr AdjustTarget(MethodTable* targetMT, IntPtr methodPtr, out QCallExceptionStatus qcallException); internal void InitializeVirtualCallStub(IntPtr methodPtr) { @@ -900,7 +900,7 @@ internal void InitializeVirtualCallStub(IntPtr methodPtr) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_InitializeVirtualCallStub")] - private static partial void InitializeVirtualCallStub(ObjectHandleOnStack d, IntPtr methodPtr, out QCallException qcallException); + private static partial void InitializeVirtualCallStub(ObjectHandleOnStack d, IntPtr methodPtr, out QCallExceptionStatus qcallException); [DoesNotReturn] [DebuggerNonUserCode] diff --git a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs index 8c6dc0d38cee7f..f36a9bda972708 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs @@ -12,7 +12,7 @@ namespace System.Diagnostics public static partial class Debugger { [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DebugDebugger_Break")] - private static partial void BreakInternal(out QCallException qcallException); + private static partial void BreakInternal(out QCallExceptionStatus qcallException); // Break causes a breakpoint to be signalled to an attached debugger. If no debugger // is attached, the user is asked if they want to attach a debugger. If yes, then the @@ -84,7 +84,7 @@ static void NotifyOfCrossThreadDependencySlow() // debugger attached, has no effect. The debugger may or may not // report the notification depending on its settings. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DebugDebugger_CustomNotification")] - private static partial void CustomNotification(ObjectHandleOnStack data, out QCallException qcallException); + private static partial void CustomNotification(ObjectHandleOnStack data, out QCallExceptionStatus qcallException); // implementation of CORINFO_HELP_USER_BREAKPOINT [StackTraceHidden] diff --git a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrame.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrame.CoreCLR.cs index 097b113b63663b..c761e3fab6fdba 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrame.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrame.CoreCLR.cs @@ -57,7 +57,7 @@ private void BuildStackFrame(int skipFrames, bool needFileInfo) #pragma warning restore IDE0060 [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StackFrame_GetMethodDescFromNativeIP")] - private static partial RuntimeMethodHandleInternal GetMethodDescFromNativeIP(IntPtr ip, out QCallException qcallException); + private static partial RuntimeMethodHandleInternal GetMethodDescFromNativeIP(IntPtr ip, out QCallExceptionStatus qcallException); /// /// Returns the MethodBase instance for the managed code IP address. diff --git a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackTrace.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackTrace.CoreCLR.cs index d564d31cb6c531..d352d7d855728b 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackTrace.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackTrace.CoreCLR.cs @@ -10,7 +10,7 @@ namespace System.Diagnostics public partial class StackTrace { [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StackTrace_GetStackFramesInternal")] - private static partial void GetStackFramesInternal(ObjectHandleOnStack sfh, [MarshalAs(UnmanagedType.Bool)] bool fNeedFileInfo, ObjectHandleOnStack e, out QCallException qcallException); + private static partial void GetStackFramesInternal(ObjectHandleOnStack sfh, [MarshalAs(UnmanagedType.Bool)] bool fNeedFileInfo, ObjectHandleOnStack e, out QCallExceptionStatus qcallException); internal static void GetStackFramesInternal(StackFrameHelper sfh, bool fNeedFileInfo, Exception? e) => GetStackFramesInternal(ObjectHandleOnStack.Create(ref sfh), fNeedFileInfo, ObjectHandleOnStack.Create(ref e), out _); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs index 60e3d37c6e0da6..117e5a97cdd831 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs @@ -12,7 +12,7 @@ namespace System public abstract partial class Enum { [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Enum_GetValuesAndNames")] - private static partial void GetEnumValuesAndNames(QCallTypeHandle enumType, ObjectHandleOnStack values, ObjectHandleOnStack names, Interop.BOOL getNames, out QCallException qcallException); + private static partial void GetEnumValuesAndNames(QCallTypeHandle enumType, ObjectHandleOnStack values, ObjectHandleOnStack names, Interop.BOOL getNames, out QCallExceptionStatus qcallException); [MethodImpl(MethodImplOptions.AggressiveInlining)] private static unsafe CorElementType InternalGetCorElementType(RuntimeType rt) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Environment.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Environment.CoreCLR.cs index b8c8c4ba9be125..37621d0bd59139 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Environment.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Environment.CoreCLR.cs @@ -22,7 +22,7 @@ public static int CurrentManagedThreadId /// QCall that passes the integer exit code to the runtime to terminate the process; it accesses no caller-supplied memory. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Environment_Exit")] [DoesNotReturn] - private static safe partial void _Exit(int exitCode, out QCallException qcallException); + private static safe partial void _Exit(int exitCode, out QCallExceptionStatus qcallException); [DoesNotReturn] public static void Exit(int exitCode) => _Exit(exitCode, out _); @@ -87,7 +87,7 @@ private static void FailFast(ref StackCrawlMark mark, string? message, Exception [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Environment_FailFast", StringMarshalling = StringMarshalling.Utf16)] [DoesNotReturn] - private static partial void FailFast(StackCrawlMarkHandle mark, string? message, ObjectHandleOnStack exception, string? errorMessage, out QCallException qcallException); + private static partial void FailFast(StackCrawlMarkHandle mark, string? message, ObjectHandleOnStack exception, string? errorMessage, out QCallExceptionStatus qcallException); private static unsafe string[] InitializeCommandLineArgs(char* exePath, int argc, char** argv) // invoked from VM { @@ -120,7 +120,7 @@ private static unsafe void InitializeCommandLineArgs(char* exePath, int argc, ch /// QCall that returns the available processor count as an int; it accesses no caller-supplied memory. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Environment_GetProcessorCount")] - internal static safe partial int GetProcessorCount(out QCallException qcallException); + internal static safe partial int GetProcessorCount(out QCallExceptionStatus qcallException); [UnmanagedCallersOnly] private static unsafe void GetResourceString(char* pKey, string* pResult, Exception* pException) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Exception.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Exception.CoreCLR.cs index d174a541a145ed..92726a5edb8824 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Exception.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Exception.CoreCLR.cs @@ -56,7 +56,7 @@ private IDictionary CreateDataContainer() private static extern bool IsImmutableAgileException(Exception e); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_GetMethodFromStackTrace")] - private static partial void GetMethodFromStackTrace(ObjectHandleOnStack stackTrace, ObjectHandleOnStack method, out QCallException qcallException); + private static partial void GetMethodFromStackTrace(ObjectHandleOnStack stackTrace, ObjectHandleOnStack method, out QCallExceptionStatus qcallException); private MethodBase? GetExceptionMethodFromStackTrace() { @@ -214,7 +214,7 @@ internal static string GetMessageFromNativeResources(ExceptionMessageKind kind) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_GetMessageFromNativeResources")] - private static partial void GetMessageFromNativeResources(ExceptionMessageKind kind, StringHandleOnStack retMesg, out QCallException qcallException); + private static partial void GetMessageFromNativeResources(ExceptionMessageKind kind, StringHandleOnStack retMesg, out QCallExceptionStatus qcallException); internal readonly struct DispatchState { @@ -237,7 +237,7 @@ public DispatchState( } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_GetFrozenStackTrace")] - private static partial void GetFrozenStackTrace(ObjectHandleOnStack exception, ObjectHandleOnStack stackTrace, out QCallException qcallException); + private static partial void GetFrozenStackTrace(ObjectHandleOnStack exception, ObjectHandleOnStack stackTrace, out QCallExceptionStatus qcallException); internal DispatchState CaptureDispatchState() { diff --git a/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs index 62506a3d5c255d..caddcbb85f4b89 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs @@ -92,11 +92,11 @@ public static GCMemoryInfo GetGCMemoryInfo(GCKind kind) /// exceed it. is the audited entry point that /// validates both. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_StartNoGCRegion")] - internal static unsafe partial int _StartNoGCRegion(long totalSize, [MarshalAs(UnmanagedType.Bool)] bool lohSizeKnown, long lohSize, [MarshalAs(UnmanagedType.Bool)] bool disallowFullBlockingGC, out QCallException qcallException); + internal static unsafe partial int _StartNoGCRegion(long totalSize, [MarshalAs(UnmanagedType.Bool)] bool lohSizeKnown, long lohSize, [MarshalAs(UnmanagedType.Bool)] bool disallowFullBlockingGC, out QCallExceptionStatus qcallException); /// QCall that ends the no-GC region and returns a status code; it takes no arguments and accesses no caller-supplied memory. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_EndNoGCRegion")] - internal static safe partial int _EndNoGCRegion(out QCallException qcallException); + internal static safe partial int _EndNoGCRegion(out QCallExceptionStatus qcallException); // keep in sync with GC_ALLOC_FLAGS in gcinterface.h internal enum GC_ALLOC_FLAGS @@ -107,17 +107,17 @@ internal enum GC_ALLOC_FLAGS }; [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_AllocateNewArray")] - private static partial void AllocateNewArray(IntPtr typeHandlePtr, int length, GC_ALLOC_FLAGS flags, ObjectHandleOnStack ret, out QCallException qcallException); + private static partial void AllocateNewArray(IntPtr typeHandlePtr, int length, GC_ALLOC_FLAGS flags, ObjectHandleOnStack ret, out QCallExceptionStatus qcallException); /// QCall that returns the total managed heap byte count as a scalar; it takes no arguments and accesses no caller-supplied memory. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_GetTotalMemory")] - private static safe partial long GetTotalMemory(out QCallException qcallException); + private static safe partial long GetTotalMemory(out QCallExceptionStatus qcallException); /// The runtime only asserts that is at least -1 before handing it to the /// GC, so the caller must not pass a smaller value. /// is the audited entry point that validates it. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_Collect")] - private static unsafe partial void _Collect(int generation, int mode, [MarshalAs(UnmanagedType.U1)] bool lowMemoryPressure, out QCallException qcallException); + private static unsafe partial void _Collect(int generation, int mode, [MarshalAs(UnmanagedType.U1)] bool lowMemoryPressure, out QCallExceptionStatus qcallException); /// FCall that returns the maximum supported generation number as a scalar; it takes no arguments and accesses no caller-supplied memory. [MethodImpl(MethodImplOptions.InternalCall)] @@ -144,11 +144,11 @@ internal enum GC_ALLOC_FLAGS /// QCall that records added memory pressure from a scalar byte count; it accesses no caller-supplied memory. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_AddMemoryPressure")] - private static safe partial void _AddMemoryPressure(ulong bytesAllocated, out QCallException qcallException); + private static safe partial void _AddMemoryPressure(ulong bytesAllocated, out QCallExceptionStatus qcallException); /// QCall that records removed memory pressure from a scalar byte count; it accesses no caller-supplied memory. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_RemoveMemoryPressure")] - private static safe partial void _RemoveMemoryPressure(ulong bytesAllocated, out QCallException qcallException); + private static safe partial void _RemoveMemoryPressure(ulong bytesAllocated, out QCallExceptionStatus qcallException); public static void AddMemoryPressure(long bytesAllocated) { @@ -328,7 +328,7 @@ public static int GetGeneration(WeakReference wo) public static int MaxGeneration => GetMaxGeneration(); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_GetNextFinalizableObject")] - private static unsafe partial void* GetNextFinalizeableObject(ObjectHandleOnStack target, out QCallException qcallException); + private static unsafe partial void* GetNextFinalizeableObject(ObjectHandleOnStack target, out QCallExceptionStatus qcallException); [UnmanagedCallersOnly] private static unsafe uint RunFinalizers() @@ -361,7 +361,7 @@ private static unsafe uint RunFinalizers() /// QCall that blocks until pending finalizers drain; it takes no arguments and accesses no caller-supplied memory. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_WaitForPendingFinalizers")] - private static safe partial void _WaitForPendingFinalizers(out QCallException qcallException); + private static safe partial void _WaitForPendingFinalizers(out QCallExceptionStatus qcallException); public static void WaitForPendingFinalizers() { @@ -390,7 +390,7 @@ public static unsafe void SuppressFinalize(object obj) // where calling ReRegisterForFinalize is useful is inside a finalizer that // needs to resurrect itself or an object that it references. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_ReRegisterForFinalize")] - private static partial void ReRegisterForFinalize(ObjectHandleOnStack o, out QCallException qcallException); + private static partial void ReRegisterForFinalize(ObjectHandleOnStack o, out QCallExceptionStatus qcallException); public static unsafe void ReRegisterForFinalize(object obj) { @@ -434,10 +434,10 @@ public static long GetTotalMemory(bool forceFullCollection) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_RegisterFrozenSegment")] - private static partial IntPtr _RegisterFrozenSegment(IntPtr sectionAddress, nint sectionSize, out QCallException qcallException); + private static partial IntPtr _RegisterFrozenSegment(IntPtr sectionAddress, nint sectionSize, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_UnregisterFrozenSegment")] - private static partial void _UnregisterFrozenSegment(IntPtr segmentHandle, out QCallException qcallException); + private static partial void _UnregisterFrozenSegment(IntPtr segmentHandle, out QCallExceptionStatus qcallException); /// FCall that returns the current thread's allocated byte count as a scalar; it takes no arguments and accesses no caller-supplied memory. [MethodImpl(MethodImplOptions.InternalCall)] @@ -456,7 +456,7 @@ public static long GetTotalMemory(bool forceFullCollection) /// QCall that returns a precise process-wide allocated byte count as a scalar; it takes no arguments and accesses no caller-supplied memory. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_GetTotalAllocatedBytesPrecise")] - private static safe partial long GetTotalAllocatedBytesPrecise(out QCallException qcallException); + private static safe partial long GetTotalAllocatedBytesPrecise(out QCallExceptionStatus qcallException); /// FCall that enables full-GC notifications from scalar percentage arguments and returns a status flag; it accesses no caller-supplied memory. [MethodImpl(MethodImplOptions.InternalCall)] @@ -468,11 +468,11 @@ public static long GetTotalMemory(bool forceFullCollection) /// QCall that waits for an approaching full GC using a scalar timeout and returns a status code; it accesses no caller-supplied memory. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_WaitForFullGCApproach")] - private static safe partial int _WaitForFullGCApproach(int millisecondsTimeout, out QCallException qcallException); + private static safe partial int _WaitForFullGCApproach(int millisecondsTimeout, out QCallExceptionStatus qcallException); /// QCall that waits for full-GC completion using a scalar timeout and returns a status code; it accesses no caller-supplied memory. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_WaitForFullGCComplete")] - private static safe partial int _WaitForFullGCComplete(int millisecondsTimeout, out QCallException qcallException); + private static safe partial int _WaitForFullGCComplete(int millisecondsTimeout, out QCallExceptionStatus qcallException); public static void RegisterForFullGCNotification(int maxGenerationThreshold, int largeObjectHeapThreshold) { @@ -790,7 +790,7 @@ static void Free(NoGCRegionCallbackFinalizerWorkItem* pWorkItem) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_EnableNoGCRegionCallback")] - private static unsafe partial EnableNoGCRegionCallbackStatus _EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, long totalSize, out QCallException qcallException); + private static unsafe partial EnableNoGCRegionCallbackStatus _EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, long totalSize, out QCallExceptionStatus qcallException); internal static long GetGenerationBudget(int generation) { @@ -800,7 +800,7 @@ internal static long GetGenerationBudget(int generation) /// The GC indexes its per-generation dynamic data with without /// bounds-checking it, so the caller must pass an existing generation number. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_GetGenerationBudget")] - internal static unsafe partial long _GetGenerationBudget(int generation, out QCallException qcallException); + internal static unsafe partial long _GetGenerationBudget(int generation, out QCallExceptionStatus qcallException); internal static void UnregisterMemoryLoadChangeNotification(Action notification) { @@ -966,7 +966,7 @@ internal enum GCConfigurationType } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_EnumerateConfigurationValues")] - internal static unsafe partial void _EnumerateConfigurationValues(void* configurationDictionary, delegate* unmanaged callback, out QCallException qcallException); + internal static unsafe partial void _EnumerateConfigurationValues(void* configurationDictionary, delegate* unmanaged callback, out QCallExceptionStatus qcallException); internal enum RefreshMemoryStatus { @@ -1033,7 +1033,7 @@ public static void RefreshMemoryLimit() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_RefreshMemoryLimit")] - internal static partial int _RefreshMemoryLimit(GCHeapHardLimitInfo heapHardLimitInfo, out QCallException qcallException); + internal static partial int _RefreshMemoryLimit(GCHeapHardLimitInfo heapHardLimitInfo, out QCallExceptionStatus qcallException); internal struct GCHeapHardLimitInfo { diff --git a/src/coreclr/System.Private.CoreLib/src/System/IO/FileLoadException.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/IO/FileLoadException.CoreCLR.cs index 2aec1ced65f505..60a25971de983f 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/IO/FileLoadException.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/IO/FileLoadException.CoreCLR.cs @@ -33,10 +33,10 @@ internal static string FormatFileLoadExceptionMessage(string? fileName, int hRes } [LibraryImport(RuntimeHelpers.QCall)] - private static partial void GetFileLoadExceptionMessage(int hResult, StringHandleOnStack retString, out QCallException qcallException); + private static partial void GetFileLoadExceptionMessage(int hResult, StringHandleOnStack retString, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "FileLoadException_GetMessageForHR")] - private static partial void GetMessageForHR(int hresult, StringHandleOnStack retString, out QCallException qcallException); + private static partial void GetMessageForHR(int hresult, StringHandleOnStack retString, out QCallExceptionStatus qcallException); // See clrex.cpp for native version. internal enum FileLoadExceptionKind diff --git a/src/coreclr/System.Private.CoreLib/src/System/IO/Stream.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/IO/Stream.CoreCLR.cs index ee3c15c4d3a2c1..5129259fe35a87 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/IO/Stream.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/IO/Stream.CoreCLR.cs @@ -11,7 +11,7 @@ public abstract unsafe partial class Stream { [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Stream_HasOverriddenSlow")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool HasOverriddenSlow(MethodTable* pMT, [MarshalAs(UnmanagedType.Bool)] bool isRead, out QCallException qcallException); + private static partial bool HasOverriddenSlow(MethodTable* pMT, [MarshalAs(UnmanagedType.Bool)] bool isRead, out QCallExceptionStatus qcallException); private bool HasOverriddenBeginEndRead() { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Assembly.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Assembly.CoreCLR.cs index 381344a0cc6545..40d731fbf389f3 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Assembly.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Assembly.CoreCLR.cs @@ -55,7 +55,7 @@ public static Assembly Load(AssemblyName assemblyRef) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetExecutingAssembly")] - private static partial void GetExecutingAssemblyNative(StackCrawlMarkHandle stackMark, ObjectHandleOnStack retAssembly, out QCallException qcallException); + private static partial void GetExecutingAssemblyNative(StackCrawlMarkHandle stackMark, ObjectHandleOnStack retAssembly, out QCallExceptionStatus qcallException); internal static RuntimeAssembly GetExecutingAssembly(ref StackCrawlMark stackMark) { @@ -86,7 +86,7 @@ public static Assembly GetCallingAssembly() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetEntryAssembly")] - private static partial void GetEntryAssemblyNative(ObjectHandleOnStack retAssembly, out QCallException qcallException); + private static partial void GetEntryAssemblyNative(ObjectHandleOnStack retAssembly, out QCallExceptionStatus qcallException); private static RuntimeAssembly? GetEntryAssemblyInternal() { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs index d1e2520dc91a1d..6a19fa743b77e5 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs @@ -193,6 +193,6 @@ private static unsafe void CreateAssemblyName(AssemblyName* pResult, NativeAssem } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyName_InitializeAssemblySpec")] - private static unsafe partial void InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, void* pAssemblySpec, out QCallException qcallException); + private static unsafe partial void InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, void* pAssemblySpec, out QCallExceptionStatus qcallException); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeAssemblyBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeAssemblyBuilder.cs index e2850d2aca730f..b2168540caf705 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeAssemblyBuilder.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeAssemblyBuilder.cs @@ -118,7 +118,7 @@ private static unsafe partial void CreateDynamicAssembly(ObjectHandleOnStack ass AssemblyHashAlgorithm hashAlgId, AssemblyBuilderAccess access, ObjectHandleOnStack retAssembly, - out QCallException qcallException); + out QCallExceptionStatus qcallException); private static unsafe RuntimeAssembly CreateDynamicAssembly(AssemblyLoadContext assemblyLoadContext, AssemblyName name, AssemblyBuilderAccess access) { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeModuleBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeModuleBuilder.cs index ccb23342af0c14..038d61b1656e5b 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeModuleBuilder.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeModuleBuilder.cs @@ -99,10 +99,10 @@ internal void CheckTypeNameConflict(string strTypeName, Type? enclosingType) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetTypeRef", StringMarshalling = StringMarshalling.Utf16)] - private static partial int GetTypeRef(QCallModule module, string strFullName, QCallModule refedModule, int tkResolution, out QCallException qcallException); + private static partial int GetTypeRef(QCallModule module, string strFullName, QCallModule refedModule, int tkResolution, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetMemberRef")] - private static partial int GetMemberRef(QCallModule module, QCallModule refedModule, int tr, int defToken, out QCallException qcallException); + private static partial int GetMemberRef(QCallModule module, QCallModule refedModule, int tr, int defToken, out QCallExceptionStatus qcallException); private int GetMemberRef(Module? refedModule, int tr, int defToken) { @@ -113,7 +113,7 @@ private int GetMemberRef(Module? refedModule, int tr, int defToken) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetMemberRefFromSignature", StringMarshalling = StringMarshalling.Utf16)] - private static partial int GetMemberRefFromSignature(QCallModule module, int tr, string methodName, byte[] signature, int length, out QCallException qcallException); + private static partial int GetMemberRefFromSignature(QCallModule module, int tr, string methodName, byte[] signature, int length, out QCallExceptionStatus qcallException); private int GetMemberRefFromSignature(int tr, string methodName, byte[] signature, int length) { @@ -122,7 +122,7 @@ private int GetMemberRefFromSignature(int tr, string methodName, byte[] signatur } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetMemberRefOfMethodInfo")] - private static partial int GetMemberRefOfMethodInfo(QCallModule module, int tr, RuntimeMethodHandleInternal method, out QCallException qcallException); + private static partial int GetMemberRefOfMethodInfo(QCallModule module, int tr, RuntimeMethodHandleInternal method, out QCallExceptionStatus qcallException); private int GetMemberRefOfMethodInfo(int tr, RuntimeMethodInfo method) { @@ -145,7 +145,7 @@ private int GetMemberRefOfMethodInfo(int tr, RuntimeConstructorInfo method) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetMemberRefOfFieldInfo")] - private static partial int GetMemberRefOfFieldInfo(QCallModule module, int tkType, QCallTypeHandle declaringType, int tkField, out QCallException qcallException); + private static partial int GetMemberRefOfFieldInfo(QCallModule module, int tkType, QCallTypeHandle declaringType, int tkField, out QCallExceptionStatus qcallException); private int GetMemberRefOfFieldInfo(int tkType, RuntimeTypeHandle declaringType, RuntimeFieldInfo runtimeField) { @@ -156,7 +156,7 @@ private int GetMemberRefOfFieldInfo(int tkType, RuntimeTypeHandle declaringType, } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetTokenFromTypeSpec")] - private static partial int GetTokenFromTypeSpec(QCallModule pModule, byte[] signature, int length, out QCallException qcallException); + private static partial int GetTokenFromTypeSpec(QCallModule pModule, byte[] signature, int length, out QCallExceptionStatus qcallException); private int GetTokenFromTypeSpec(byte[] signature, int length) { @@ -165,13 +165,13 @@ private int GetTokenFromTypeSpec(byte[] signature, int length) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetArrayMethodToken", StringMarshalling = StringMarshalling.Utf16)] - private static partial int GetArrayMethodToken(QCallModule module, int tkTypeSpec, string methodName, byte[] signature, int sigLength, out QCallException qcallException); + private static partial int GetArrayMethodToken(QCallModule module, int tkTypeSpec, string methodName, byte[] signature, int sigLength, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetStringConstant", StringMarshalling = StringMarshalling.Utf16)] - private static partial int GetStringConstant(QCallModule module, string str, int length, out QCallException qcallException); + private static partial int GetStringConstant(QCallModule module, string str, int length, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_SetFieldRVAContent")] - internal static partial void SetFieldRVAContent(QCallModule module, int fdToken, byte[]? data, int length, out QCallException qcallException); + internal static partial void SetFieldRVAContent(QCallModule module, int fdToken, byte[]? data, int length, out QCallExceptionStatus qcallException); #endregion diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeTypeBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeTypeBuilder.cs index b5b79db5d0d1ed..51ffc5cf9ff3d1 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeTypeBuilder.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeTypeBuilder.cs @@ -58,25 +58,25 @@ public void Bake(RuntimeModuleBuilder module, int token) #region Private Static FCalls [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetParentType")] - private static partial void SetParentType(QCallModule module, int tdTypeDef, int tkParent, out QCallException qcallException); + private static partial void SetParentType(QCallModule module, int tdTypeDef, int tkParent, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_AddInterfaceImpl")] - private static partial void AddInterfaceImpl(QCallModule module, int tdTypeDef, int tkInterface, out QCallException qcallException); + private static partial void AddInterfaceImpl(QCallModule module, int tdTypeDef, int tkInterface, out QCallExceptionStatus qcallException); #endregion #region Internal Static FCalls [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineMethod", StringMarshalling = StringMarshalling.Utf16)] internal static partial int DefineMethod(QCallModule module, int tkParent, string name, byte[] signature, int sigLength, MethodAttributes attributes, - out QCallException qcallException); + out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineMethodSpec")] - internal static partial int DefineMethodSpec(QCallModule module, int tkParent, byte[] signature, int sigLength, out QCallException qcallException); + internal static partial int DefineMethodSpec(QCallModule module, int tkParent, byte[] signature, int sigLength, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineField", StringMarshalling = StringMarshalling.Utf16)] internal static partial int DefineField(QCallModule module, int tkParent, string name, byte[] signature, int sigLength, FieldAttributes attributes, - out QCallException qcallException); + out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetMethodIL")] private static partial void SetMethodIL(QCallModule module, int tk, [MarshalAs(UnmanagedType.Bool)] bool isInitLocals, @@ -85,12 +85,12 @@ private static partial void SetMethodIL(QCallModule module, int tk, [MarshalAs(U int maxStackSize, ExceptionHandler[]? exceptions, int numExceptions, int[]? tokenFixups, int numTokenFixups, - out QCallException qcallException); + out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineCustomAttribute")] private static partial void DefineCustomAttribute(QCallModule module, int tkAssociate, int tkConstructor, ReadOnlySpan attr, int attrLength, - out QCallException qcallException); + out QCallExceptionStatus qcallException); internal static void DefineCustomAttribute(RuntimeModuleBuilder module, int tkAssociate, int tkConstructor, ReadOnlySpan attr) @@ -103,41 +103,41 @@ internal static void DefineCustomAttribute(RuntimeModuleBuilder module, int tkAs [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineProperty", StringMarshalling = StringMarshalling.Utf16)] internal static partial int DefineProperty(QCallModule module, int tkParent, string name, PropertyAttributes attributes, byte[] signature, int sigLength, - out QCallException qcallException); + out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineEvent", StringMarshalling = StringMarshalling.Utf16)] - internal static partial int DefineEvent(QCallModule module, int tkParent, string name, EventAttributes attributes, int tkEventType, out QCallException qcallException); + internal static partial int DefineEvent(QCallModule module, int tkParent, string name, EventAttributes attributes, int tkEventType, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineMethodSemantics")] internal static partial void DefineMethodSemantics(QCallModule module, int tkAssociation, MethodSemanticsAttributes semantics, int tkMethod, - out QCallException qcallException); + out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineMethodImpl")] - internal static partial void DefineMethodImpl(QCallModule module, int tkType, int tkBody, int tkDecl, out QCallException qcallException); + internal static partial void DefineMethodImpl(QCallModule module, int tkType, int tkBody, int tkDecl, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetMethodImpl")] - internal static partial void SetMethodImpl(QCallModule module, int tkMethod, MethodImplAttributes MethodImplAttributes, out QCallException qcallException); + internal static partial void SetMethodImpl(QCallModule module, int tkMethod, MethodImplAttributes MethodImplAttributes, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetParamInfo", StringMarshalling = StringMarshalling.Utf16)] internal static partial int SetParamInfo(QCallModule module, int tkMethod, int iSequence, ParameterAttributes iParamAttributes, string? strParamName, - out QCallException qcallException); + out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_GetTokenFromSig")] - internal static partial int GetTokenFromSig(QCallModule module, byte[] signature, int sigLength, out QCallException qcallException); + internal static partial int GetTokenFromSig(QCallModule module, byte[] signature, int sigLength, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetFieldLayoutOffset")] - internal static partial void SetFieldLayoutOffset(QCallModule module, int fdToken, int iOffset, out QCallException qcallException); + internal static partial void SetFieldLayoutOffset(QCallModule module, int fdToken, int iOffset, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetClassLayout")] - internal static partial void SetClassLayout(QCallModule module, int tk, PackingSize iPackingSize, int iTypeSize, out QCallException qcallException); + internal static partial void SetClassLayout(QCallModule module, int tk, PackingSize iPackingSize, int iTypeSize, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetConstantValue")] - private static unsafe partial void SetConstantValue(QCallModule module, int tk, int corType, void* pValue, out QCallException qcallException); + private static unsafe partial void SetConstantValue(QCallModule module, int tk, int corType, void* pValue, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetPInvokeData", StringMarshalling = StringMarshalling.Utf16)] - private static partial void SetPInvokeData(QCallModule module, string DllName, string name, int token, int linkFlags, out QCallException qcallException); + private static partial void SetPInvokeData(QCallModule module, string DllName, string name, int token, int linkFlags, out QCallExceptionStatus qcallException); #endregion #region Internal\Private Static Members @@ -545,15 +545,15 @@ protected override bool IsCreatedCore() [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineType", StringMarshalling = StringMarshalling.Utf16)] private static partial int DefineType(QCallModule module, string fullname, int tkParent, TypeAttributes attributes, int tkEnclosingType, int[] interfaceTokens, - out QCallException qcallException); + out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineGenericParam", StringMarshalling = StringMarshalling.Utf16)] private static partial int DefineGenericParam(QCallModule module, string name, int tkParent, GenericParameterAttributes attributes, int position, int[] constraints, - out QCallException qcallException); + out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_TermCreateClass")] - private static partial void TermCreateClass(QCallModule module, int tk, ObjectHandleOnStack type, out QCallException qcallException); + private static partial void TermCreateClass(QCallModule module, int tk, ObjectHandleOnStack type, out QCallExceptionStatus qcallException); #endregion #region Internal Methods diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/LoaderAllocator.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/LoaderAllocator.cs index 402cc500cd9d39..6e9ca1a9552238 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/LoaderAllocator.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/LoaderAllocator.cs @@ -28,7 +28,7 @@ internal sealed partial class LoaderAllocatorScout [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "LoaderAllocator_Destroy")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool Destroy(IntPtr nativeLoaderAllocator, out QCallException qcallException); + private static partial bool Destroy(IntPtr nativeLoaderAllocator, out QCallExceptionStatus qcallException); ~LoaderAllocatorScout() { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs index e3f6823d5c9fd8..ea71f4c1f7d24c 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs @@ -334,7 +334,7 @@ internal MetadataImport(RuntimeModule module) #endregion [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MetadataImport_Enum")] - private static unsafe partial void Enum(IntPtr scope, int type, int parent, ref int length, int* shortResult, ObjectHandleOnStack longResult, out QCallException qcallException); + private static unsafe partial void Enum(IntPtr scope, int type, int parent, ref int length, int* shortResult, ObjectHandleOnStack longResult, out QCallExceptionStatus qcallException); public unsafe void Enum(MetadataTokenType type, int parent, out MetadataEnumResult result) { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/AssemblyExtensions.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/AssemblyExtensions.cs index b1d9f209ddef53..4874d76c63c491 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/AssemblyExtensions.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/AssemblyExtensions.cs @@ -11,7 +11,7 @@ public static partial class AssemblyExtensions { [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_InternalTryGetRawMetadata")] [return: MarshalAs(UnmanagedType.Bool)] - private static unsafe partial bool InternalTryGetRawMetadata(QCallAssembly assembly, ref byte* blob, ref int length, out QCallException qcallException); + private static unsafe partial bool InternalTryGetRawMetadata(QCallAssembly assembly, ref byte* blob, ref int length, out QCallExceptionStatus qcallException); /// /// Retrieves the metadata section of the assembly, for use with . diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs index 1dd95afa872cc8..5faa207513eb12 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs @@ -11,11 +11,11 @@ namespace System.Reflection.Metadata public static partial class MetadataUpdater { [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_ApplyUpdate")] - private static unsafe partial void ApplyUpdate(QCallAssembly assembly, byte* metadataDelta, int metadataDeltaLength, byte* ilDelta, int ilDeltaLength, byte* pdbDelta, int pdbDeltaLength, out QCallException qcallException); + private static unsafe partial void ApplyUpdate(QCallAssembly assembly, byte* metadataDelta, int metadataDeltaLength, byte* ilDelta, int ilDeltaLength, byte* pdbDelta, int pdbDeltaLength, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_IsApplyUpdateSupported")] [return: MarshalAs(UnmanagedType.Bool)] - private static unsafe partial bool IsApplyUpdateSupported(out QCallException qcallException); + private static unsafe partial bool IsApplyUpdateSupported(out QCallExceptionStatus qcallException); /// /// Updates the specified assembly using the provided metadata, IL and PDB deltas. diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MethodBase.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MethodBase.CoreCLR.cs index b62ebddd2fe547..ecbc4e4a4f2fbb 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MethodBase.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MethodBase.CoreCLR.cs @@ -37,7 +37,7 @@ public abstract partial class MethodBase : MemberInfo } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MethodBase_GetCurrentMethod")] - private static partial RuntimeMethodHandleInternal GetCurrentMethod(StackCrawlMarkHandle stackMark, out QCallException qcallException); + private static partial RuntimeMethodHandleInternal GetCurrentMethod(StackCrawlMarkHandle stackMark, out QCallExceptionStatus qcallException); [RequiresUnreferencedCode("Metadata for the method might be incomplete or removed")] [DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs index d2fb7abe4ec7da..b09c14ebd5206d 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs @@ -71,7 +71,7 @@ public override event ModuleResolveEventHandler? ModuleResolve [return: MarshalAs(UnmanagedType.Bool)] private static partial bool GetCodeBase(QCallAssembly assembly, StringHandleOnStack retString, - out QCallException qcallException); + out QCallExceptionStatus qcallException); internal string? GetCodeBase() { @@ -140,7 +140,7 @@ public override AssemblyName GetName(bool copiedName) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetFullName")] - private static partial void GetFullName(QCallAssembly assembly, StringHandleOnStack retString, out QCallException qcallException); + private static partial void GetFullName(QCallAssembly assembly, StringHandleOnStack retString, out QCallExceptionStatus qcallException); public override string? FullName { @@ -160,7 +160,7 @@ public override string? FullName } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetEntryPoint")] - private static partial void GetEntryPoint(QCallAssembly assembly, ObjectHandleOnStack retMethod, out QCallException qcallException); + private static partial void GetEntryPoint(QCallAssembly assembly, ObjectHandleOnStack retMethod, out QCallExceptionStatus qcallException); public override MethodInfo? EntryPoint { @@ -184,7 +184,7 @@ private static partial void GetTypeCore(QCallAssembly assembly, ReadOnlySpan nestedTypeNames, int nestedTypeNamesLength, ObjectHandleOnStack retType, - out QCallException qcallException); + out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetTypeCoreIgnoreCase", StringMarshalling = StringMarshalling.Utf16)] private static partial void GetTypeCoreIgnoreCase(QCallAssembly assembly, @@ -192,7 +192,7 @@ private static partial void GetTypeCoreIgnoreCase(QCallAssembly assembly, ReadOnlySpan nestedTypeNames, int nestedTypeNamesLength, ObjectHandleOnStack retType, - out QCallException qcallException); + out QCallExceptionStatus qcallException); internal Type? GetTypeCore(string typeName, ReadOnlySpan nestedTypeNames, bool throwOnFileNotFound, bool ignoreCase) { @@ -240,7 +240,7 @@ private static partial void GetTypeCoreIgnoreCase(QCallAssembly assembly, } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetExportedTypes")] - private static partial void GetExportedTypes(QCallAssembly assembly, ObjectHandleOnStack retTypes, out QCallException qcallException); + private static partial void GetExportedTypes(QCallAssembly assembly, ObjectHandleOnStack retTypes, out QCallExceptionStatus qcallException); [RequiresUnreferencedCode("Types might be removed")] public override Type[] GetExportedTypes() @@ -275,7 +275,7 @@ public override bool IsCollectible private static unsafe partial byte* GetResource(QCallAssembly assembly, string resourceName, out uint length, - out QCallException qcallException); + out QCallExceptionStatus qcallException); // Load a resource based on the NameSpace of the type. public override Stream? GetManifestResourceStream(Type type, string name) @@ -408,14 +408,14 @@ private static unsafe partial void InternalLoad(NativeAssemblyNameParts* pAssemb [MarshalAs(UnmanagedType.Bool)] bool throwOnFileNotFound, ObjectHandleOnStack assemblyLoadContext, ObjectHandleOnStack retAssembly, - out QCallException qcallException); + out QCallExceptionStatus qcallException); public override bool ReflectionOnly => false; // Returns the module in this assembly with name 'name' [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetModule", StringMarshalling = StringMarshalling.Utf16)] - private static partial void GetModule(QCallAssembly assembly, string name, ObjectHandleOnStack retModule, out QCallException qcallException); + private static partial void GetModule(QCallAssembly assembly, string name, ObjectHandleOnStack retModule, out QCallExceptionStatus qcallException); public override Module? GetModule(string name) { @@ -469,7 +469,7 @@ public override FileStream[] GetFiles(bool getResourceModules) // Returns the names of all the resources [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetManifestResourceNames")] - private static partial void GetManifestResourceNames(QCallAssembly assembly, ObjectHandleOnStack retResourceNames, out QCallException qcallException); + private static partial void GetManifestResourceNames(QCallAssembly assembly, ObjectHandleOnStack retResourceNames, out QCallExceptionStatus qcallException); // Returns the names of all the resources public override string[] GetManifestResourceNames() @@ -482,7 +482,7 @@ public override string[] GetManifestResourceNames() // Returns the names of all the resources [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetReferencedAssemblies")] - private static partial void GetReferencedAssemblies(QCallAssembly assembly, ObjectHandleOnStack retReferencedAssemblies, out QCallException qcallException); + private static partial void GetReferencedAssemblies(QCallAssembly assembly, ObjectHandleOnStack retReferencedAssemblies, out QCallExceptionStatus qcallException); [RequiresUnreferencedCode("Assembly references might be removed")] public override AssemblyName[] GetReferencedAssemblies() @@ -498,7 +498,7 @@ private static partial int GetManifestResourceInfo(QCallAssembly assembly, string resourceName, ObjectHandleOnStack assemblyRef, StringHandleOnStack retFileName, - out QCallException qcallException); + out QCallExceptionStatus qcallException); public override ManifestResourceInfo? GetManifestResourceInfo(string resourceName) { @@ -518,7 +518,7 @@ private static partial int GetManifestResourceInfo(QCallAssembly assembly, } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetLocation")] - private static partial void GetLocation(QCallAssembly assembly, StringHandleOnStack retString, out QCallException qcallException); + private static partial void GetLocation(QCallAssembly assembly, StringHandleOnStack retString, out QCallExceptionStatus qcallException); public override string Location { @@ -534,7 +534,7 @@ public override string Location } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetImageRuntimeVersion")] - private static partial void GetImageRuntimeVersion(QCallAssembly assembly, StringHandleOnStack retString, out QCallException qcallException); + private static partial void GetImageRuntimeVersion(QCallAssembly assembly, StringHandleOnStack retString, out QCallExceptionStatus qcallException); public override string ImageRuntimeVersion { @@ -558,7 +558,7 @@ private static partial void GetVersion(QCallAssembly assembly, out int minVer, out int buildNum, out int revNum, - out QCallException qcallException); + out QCallExceptionStatus qcallException); private Version GetVersion() { @@ -568,7 +568,7 @@ private Version GetVersion() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetLocale")] - private static partial void GetLocale(QCallAssembly assembly, StringHandleOnStack retString, out QCallException qcallException); + private static partial void GetLocale(QCallAssembly assembly, StringHandleOnStack retString, out QCallExceptionStatus qcallException); private CultureInfo GetLocale() { @@ -597,7 +597,7 @@ public override bool IsDynamic } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetSimpleName")] - private static partial void GetSimpleName(QCallAssembly assembly, StringHandleOnStack retSimpleName, out QCallException qcallException); + private static partial void GetSimpleName(QCallAssembly assembly, StringHandleOnStack retSimpleName, out QCallExceptionStatus qcallException); internal string GetSimpleName() { @@ -608,7 +608,7 @@ internal string GetSimpleName() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetHashAlgorithm")] - private static partial AssemblyHashAlgorithm GetHashAlgorithm(QCallAssembly assembly, out QCallException qcallException); + private static partial AssemblyHashAlgorithm GetHashAlgorithm(QCallAssembly assembly, out QCallExceptionStatus qcallException); private AssemblyHashAlgorithm GetHashAlgorithm() { @@ -617,7 +617,7 @@ private AssemblyHashAlgorithm GetHashAlgorithm() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetFlags")] - private static partial AssemblyNameFlags GetFlags(QCallAssembly assembly, out QCallException qcallException); + private static partial AssemblyNameFlags GetFlags(QCallAssembly assembly, out QCallExceptionStatus qcallException); private AssemblyNameFlags GetFlags() { @@ -626,7 +626,7 @@ private AssemblyNameFlags GetFlags() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetPublicKey")] - private static partial void GetPublicKey(QCallAssembly assembly, ObjectHandleOnStack retPublicKey, out QCallException qcallException); + private static partial void GetPublicKey(QCallAssembly assembly, ObjectHandleOnStack retPublicKey, out QCallExceptionStatus qcallException); internal byte[]? GetPublicKey() { @@ -686,7 +686,7 @@ private static partial void GetModules(QCallAssembly assembly, [MarshalAs(UnmanagedType.Bool)] bool loadIfNotFound, [MarshalAs(UnmanagedType.Bool)] bool getResourceModules, ObjectHandleOnStack retModuleHandles, - out QCallException qcallException); + out QCallExceptionStatus qcallException); private RuntimeModule[] GetModulesInternal(bool loadIfNotFound, bool getResourceModules) @@ -725,7 +725,7 @@ static RuntimeModule GetManifestModuleWorker(RuntimeAssembly assembly) private static extern RuntimeModule? GetManifestModule(RuntimeAssembly assembly); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyHandle_GetManifestModuleSlow")] - private static partial void GetManifestModuleSlow(ObjectHandleOnStack assembly, ObjectHandleOnStack module, out QCallException qcallException); + private static partial void GetManifestModuleSlow(ObjectHandleOnStack assembly, ObjectHandleOnStack module, out QCallExceptionStatus qcallException); [MethodImpl(MethodImplOptions.InternalCall)] private static extern int GetTokenInternal(RuntimeAssembly assembly); @@ -813,6 +813,6 @@ private static void AddPublicNestedTypes(Type type, List types, List GetFullyQualifiedName(); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeModule_GetTypes")] - private static partial void GetTypes(QCallModule module, ObjectHandleOnStack retTypes, ObjectHandleOnStack retExceptions, out QCallException qcallException); + private static partial void GetTypes(QCallModule module, ObjectHandleOnStack retTypes, ObjectHandleOnStack retExceptions, out QCallExceptionStatus qcallException); internal RuntimeType[] GetDefinedTypes() { @@ -482,7 +482,7 @@ public override MethodInfo[] GetMethods(BindingFlags bindingFlags) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeModule_GetScopeName")] - private static partial void GetScopeName(QCallModule module, StringHandleOnStack retString, out QCallException qcallException); + private static partial void GetScopeName(QCallModule module, StringHandleOnStack retString, out QCallExceptionStatus qcallException); public override string ScopeName { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs index 19d1894400385a..08296d3afd61b1 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs @@ -198,7 +198,7 @@ private static unsafe void GetTypeHelper(char* pTypeName, RuntimeAssembly* pRequ } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "UnsafeAccessors_ResolveGenericParamToTypeHandle")] - private static partial IntPtr ResolveGenericParamToTypeHandle(IntPtr unsafeAccessorMethod, [MarshalAs(UnmanagedType.Bool)] bool isMethodParam, uint paramIndex, out QCallException qcallException); + private static partial IntPtr ResolveGenericParamToTypeHandle(IntPtr unsafeAccessorMethod, [MarshalAs(UnmanagedType.Bool)] bool isMethodParam, uint paramIndex, out QCallExceptionStatus qcallException); [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "TypeNameResolver.GetType is marked as RequiresUnreferencedCode.")] diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs index c9c913bb09da47..9ebcb53ba218e6 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs @@ -321,7 +321,7 @@ internal static void ReturnTaskContinuation(RuntimeAsyncTaskContinuation continu #if !NATIVEAOT [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AsyncHelpers_AddContinuationToExInternal")] - private static unsafe partial void AddContinuationToExInternal(void* diagnosticIP, ObjectHandleOnStack ex, out QCallException qcallException); + private static unsafe partial void AddContinuationToExInternal(void* diagnosticIP, ObjectHandleOnStack ex, out QCallExceptionStatus qcallException); internal static unsafe void AddContinuationToExInternal(void* diagnosticIP, Exception e) => AddContinuationToExInternal(diagnosticIP, ObjectHandleOnStack.Create(ref e), out _); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastHelpers.cs index f99a94bac52260..aa2ff46d32c59a 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastHelpers.cs @@ -15,7 +15,7 @@ internal static unsafe partial class CastHelpers internal static int[]? s_table; [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThrowInvalidCastException")] - private static partial void ThrowInvalidCastExceptionInternal(void* fromTypeHnd, void* toTypeHnd, out QCallException qcallException); + private static partial void ThrowInvalidCastExceptionInternal(void* fromTypeHnd, void* toTypeHnd, out QCallExceptionStatus qcallException); [DoesNotReturn] internal static void ThrowInvalidCastException(void* fromTypeHnd, void* toTypeHnd) @@ -34,7 +34,7 @@ internal static void ThrowInvalidCastException(object fromType, void* toTypeHnd) [LibraryImport(RuntimeHelpers.QCall)] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool IsInstanceOf_NoCacheLookup(void *toTypeHnd, [MarshalAs(UnmanagedType.Bool)] bool throwCastException, ObjectHandleOnStack obj, out QCallException qcallException); + private static partial bool IsInstanceOf_NoCacheLookup(void *toTypeHnd, [MarshalAs(UnmanagedType.Bool)] bool throwCastException, ObjectHandleOnStack obj, out QCallExceptionStatus qcallException); [MethodImpl(MethodImplOptions.NoInlining)] private static object? IsInstanceOfAny_NoCacheLookup(void* toTypeHnd, object obj) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/GenericsHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/GenericsHelpers.cs index 991c67a079421d..f9a5b332da833d 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/GenericsHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/GenericsHelpers.cs @@ -13,7 +13,7 @@ namespace System.Runtime.CompilerServices; internal static unsafe partial class GenericsHelpers { [LibraryImport(RuntimeHelpers.QCall)] - private static partial IntPtr GenericHandleWorker(IntPtr pMD, IntPtr pMT, IntPtr signature, uint dictionaryIndexAndSlot, IntPtr pModule, out QCallException qcallException); + private static partial IntPtr GenericHandleWorker(IntPtr pMD, IntPtr pMT, IntPtr signature, uint dictionaryIndexAndSlot, IntPtr pModule, out QCallExceptionStatus qcallException); public struct GenericHandleArgs { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/InitHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/InitHelpers.cs index 69831a9e633ca1..05c1f0cdfd7210 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/InitHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/InitHelpers.cs @@ -12,7 +12,7 @@ namespace System.Runtime.CompilerServices internal static unsafe partial class InitHelpers { [LibraryImport(RuntimeHelpers.QCall)] - private static partial void InitClassHelper(MethodTable* mt, out QCallException qcallException); + private static partial void InitClassHelper(MethodTable* mt, out QCallExceptionStatus qcallException); [DebuggerHidden] [MethodImpl(MethodImplOptions.NoInlining)] diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallException.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallExceptionStatus.cs similarity index 76% rename from src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallException.cs rename to src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallExceptionStatus.cs index 836b0f5dff21e7..87ce08f6d9e9d5 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallException.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallExceptionStatus.cs @@ -8,13 +8,13 @@ namespace System.Runtime.CompilerServices { - [NativeMarshalling(typeof(QCallExceptionMarshaller))] - internal readonly struct QCallException + [NativeMarshalling(typeof(QCallExceptionStatusMarshaller))] + internal readonly struct QCallExceptionStatus { } - [CustomMarshaller(typeof(QCallException), MarshalMode.ManagedToUnmanagedOut, typeof(QCallExceptionMarshaller))] - internal struct QCallExceptionMarshaller + [CustomMarshaller(typeof(QCallExceptionStatus), MarshalMode.ManagedToUnmanagedOut, typeof(QCallExceptionStatusMarshaller))] + internal struct QCallExceptionStatusMarshaller { [MethodImpl(MethodImplOptions.AggressiveInlining)] public void FromUnmanaged(int exceptionPending) @@ -26,7 +26,7 @@ public void FromUnmanaged(int exceptionPending) } [MethodImpl(MethodImplOptions.AggressiveInlining)] - public QCallException ToManaged() => default; + public QCallExceptionStatus ToManaged() => default; [MethodImpl(MethodImplOptions.AggressiveInlining)] public void Free() { } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs index 706b9fe783c397..b9755922ad7813 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs @@ -164,7 +164,7 @@ private static unsafe ref byte GetSpanDataFrom( // exception when it ran. [LibraryImport(QCall, EntryPoint = "ReflectionInvocation_RunClassConstructor")] - private static partial void RunClassConstructor(QCallTypeHandle type, out QCallException qcallException); + private static partial void RunClassConstructor(QCallTypeHandle type, out QCallExceptionStatus qcallException); [RequiresUnreferencedCode("Trimmer can't guarantee existence of class constructor")] public static void RunClassConstructor(RuntimeTypeHandle type) @@ -184,7 +184,7 @@ public static void RunClassConstructor(RuntimeTypeHandle type) // exception when it ran. [LibraryImport(QCall, EntryPoint = "ReflectionInvocation_RunModuleConstructor")] - private static partial void RunModuleConstructor(QCallModule module, out QCallException qcallException); + private static partial void RunModuleConstructor(QCallModule module, out QCallExceptionStatus qcallException); public static void RunModuleConstructor(ModuleHandle module) { @@ -195,10 +195,10 @@ public static void RunModuleConstructor(ModuleHandle module) } [LibraryImport(QCall, EntryPoint = "ReflectionInvocation_CompileMethod")] - internal static partial void CompileMethod(RuntimeMethodHandleInternal method, out QCallException qcallException); + internal static partial void CompileMethod(RuntimeMethodHandleInternal method, out QCallExceptionStatus qcallException); [LibraryImport(QCall, EntryPoint = "ReflectionInvocation_PrepareMethod")] - private static unsafe partial void PrepareMethod(RuntimeMethodHandleInternal method, IntPtr* pInstantiation, int cInstantiation, out QCallException qcallException); + private static unsafe partial void PrepareMethod(RuntimeMethodHandleInternal method, IntPtr* pInstantiation, int cInstantiation, out QCallExceptionStatus qcallException); public static void PrepareMethod(RuntimeMethodHandle method) => PrepareMethod(method, null); @@ -220,7 +220,7 @@ public static unsafe void PrepareMethod(RuntimeMethodHandle method, RuntimeTypeH } [LibraryImport(QCall, EntryPoint = "ReflectionInvocation_PrepareDelegate")] - private static partial void PrepareDelegate(ObjectHandleOnStack d, out QCallException qcallException); + private static partial void PrepareDelegate(ObjectHandleOnStack d, out QCallExceptionStatus qcallException); public static void PrepareDelegate(Delegate d) { @@ -241,7 +241,7 @@ public static void PrepareDelegate(Delegate d) internal static extern safe int TryGetHashCode(object? o); [LibraryImport(QCall, EntryPoint = "ObjectNative_GetHashCodeSlow")] - private static partial int GetHashCodeSlow(ObjectHandleOnStack o, out QCallException qcallException); + private static partial int GetHashCodeSlow(ObjectHandleOnStack o, out QCallExceptionStatus qcallException); public static int GetHashCode(object? o) { @@ -350,7 +350,7 @@ public static object GetUninitializedObject( } [LibraryImport(QCall, EntryPoint = "ObjectNative_AllocateUninitializedClone")] - internal static partial void AllocateUninitializedClone(ObjectHandleOnStack objHandle, out QCallException qcallException); + internal static partial void AllocateUninitializedClone(ObjectHandleOnStack objHandle, out QCallExceptionStatus qcallException); /// true if given type is bitwise equatable (memcmp can be used for equality checking) /// @@ -475,7 +475,7 @@ internal static unsafe bool ObjectHasComponentSize(object obj) [LibraryImport(QCall, EntryPoint = "MethodTable_AreTypesEquivalent")] [return: MarshalAs(UnmanagedType.Bool)] - internal static unsafe partial bool AreTypesEquivalent(MethodTable* pMTa, MethodTable* pMTb, out QCallException qcallException); + internal static unsafe partial bool AreTypesEquivalent(MethodTable* pMTa, MethodTable* pMTb, out QCallExceptionStatus qcallException); /// Allocates memory that's associated with the and is freed if and when the is unloaded. /// The type associated with the allocated memory. @@ -522,16 +522,16 @@ public static IntPtr AllocateTypeAssociatedMemory(Type type, int size, int align } [LibraryImport(QCall, EntryPoint = "RuntimeTypeHandle_AllocateTypeAssociatedMemory")] - private static partial IntPtr AllocateTypeAssociatedMemory(QCallTypeHandle type, uint size, out QCallException qcallException); + private static partial IntPtr AllocateTypeAssociatedMemory(QCallTypeHandle type, uint size, out QCallExceptionStatus qcallException); [LibraryImport(QCall, EntryPoint = "RuntimeTypeHandle_AllocateTypeAssociatedMemoryAligned")] - private static partial IntPtr AllocateTypeAssociatedMemoryAligned(QCallTypeHandle type, uint size, uint alignment, out QCallException qcallException); + private static partial IntPtr AllocateTypeAssociatedMemoryAligned(QCallTypeHandle type, uint size, uint alignment, out QCallExceptionStatus qcallException); [MethodImpl(MethodImplOptions.InternalCall)] private static extern unsafe TailCallArgBuffer* GetTailCallArgBuffer(); [LibraryImport(QCall, EntryPoint = "TailCallHelp_AllocTailCallArgBufferInternal")] - private static unsafe partial TailCallArgBuffer* AllocTailCallArgBufferInternal(int size, out QCallException qcallException); + private static unsafe partial TailCallArgBuffer* AllocTailCallArgBufferInternal(int size, out QCallExceptionStatus qcallException); private const int TAILCALLARGBUFFER_ACTIVE = 0; // private const int TAILCALLARGBUFFER_INSTARG_ONLY = 1; @@ -1321,7 +1321,7 @@ private static bool CanCastToWorker(TypeHandle srcTH, TypeHandle destTH, bool nu } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeHandle_CanCastTo_NoCacheLookup")] - private static partial Interop.BOOL CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd, out QCallException qcallException); + private static partial Interop.BOOL CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd, out QCallExceptionStatus qcallException); [SuppressGCTransition] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeHandle_GetCorElementType")] diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/StaticsHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/StaticsHelpers.cs index 01aa79c0f9e792..d5d9d31de32485 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/StaticsHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/StaticsHelpers.cs @@ -12,10 +12,10 @@ namespace System.Runtime.CompilerServices internal static unsafe partial class StaticsHelpers { [LibraryImport(RuntimeHelpers.QCall)] - private static partial void GetThreadStaticsByIndex(ByteRefOnStack result, int index, [MarshalAs(UnmanagedType.Bool)] bool gcStatics, out QCallException qcallException); + private static partial void GetThreadStaticsByIndex(ByteRefOnStack result, int index, [MarshalAs(UnmanagedType.Bool)] bool gcStatics, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall)] - private static partial void GetThreadStaticsByMethodTable(ByteRefOnStack result, MethodTable* pMT, [MarshalAs(UnmanagedType.Bool)] bool gcStatics, out QCallException qcallException); + private static partial void GetThreadStaticsByMethodTable(ByteRefOnStack result, MethodTable* pMT, [MarshalAs(UnmanagedType.Bool)] bool gcStatics, out QCallExceptionStatus qcallException); [Intrinsic] private static ref byte VolatileReadAsByref(ref IntPtr address) => ref VolatileReadAsByref(ref address); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/VirtualDispatchHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/VirtualDispatchHelpers.cs index a73a0fcef0ab7b..b0ecc2c2816fae 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/VirtualDispatchHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/VirtualDispatchHelpers.cs @@ -59,7 +59,7 @@ private struct VirtualFunctionPointerArgs private static GenericCache s_virtualFunctionPointerCache = new GenericCache(InitialCacheSize, MaximumCacheSize); [LibraryImport(RuntimeHelpers.QCall)] - private static unsafe partial IntPtr ResolveVirtualFunctionPointer(ObjectHandleOnStack obj, IntPtr classHandle, IntPtr methodHandle, out QCallException qcallException); + private static unsafe partial IntPtr ResolveVirtualFunctionPointer(ObjectHandleOnStack obj, IntPtr classHandle, IntPtr methodHandle, out QCallExceptionStatus qcallException); [MethodImpl(MethodImplOptions.NoInlining)] [DebuggerHidden] diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/ControlledExecution.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/ControlledExecution.CoreCLR.cs index cf367307731df8..092bf1eb701687 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/ControlledExecution.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/ControlledExecution.CoreCLR.cs @@ -119,7 +119,7 @@ public static void Run(Action action, CancellationToken cancellationToken) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_Abort")] - private static partial void AbortThread(ThreadHandle thread, out QCallException qcallException); + private static partial void AbortThread(ThreadHandle thread, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_ResetAbort")] [SuppressGCTransition] diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/DependentHandle.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/DependentHandle.cs index 29d020079d2ec1..a5f955fb64c8f9 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/DependentHandle.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/DependentHandle.cs @@ -244,7 +244,7 @@ private static IntPtr InternalAllocWithGCTransition(object? target, object? depe => _InternalAllocWithGCTransition(ObjectHandleOnStack.Create(ref target), ObjectHandleOnStack.Create(ref dependent), out _); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DependentHandle_InternalAllocWithGCTransition")] - private static partial IntPtr _InternalAllocWithGCTransition(ObjectHandleOnStack target, ObjectHandleOnStack dependent, out QCallException qcallException); + private static partial IntPtr _InternalAllocWithGCTransition(ObjectHandleOnStack target, ObjectHandleOnStack dependent, out QCallExceptionStatus qcallException); #if DEBUG [MethodImpl(MethodImplOptions.InternalCall)] @@ -276,6 +276,6 @@ private static void InternalFreeWithGCTransition(IntPtr dependentHandle) => _InternalFreeWithGCTransition(dependentHandle, out _); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DependentHandle_InternalFreeWithGCTransition")] - private static partial void _InternalFreeWithGCTransition(IntPtr dependentHandle, out QCallException qcallException); + private static partial void _InternalFreeWithGCTransition(IntPtr dependentHandle, out QCallExceptionStatus qcallException); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/ExceptionServices/InternalCalls.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/ExceptionServices/InternalCalls.cs index 1ea4d69b22da03..a1d166c3aafc41 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/ExceptionServices/InternalCalls.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/ExceptionServices/InternalCalls.cs @@ -18,13 +18,13 @@ internal static partial class InternalCalls [DebuggerHidden] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "SfiInit")] [return: MarshalAs(UnmanagedType.U1)] - internal static unsafe partial bool RhpSfiInit(ref StackFrameIterator pThis, void* pStackwalkCtx, [MarshalAs(UnmanagedType.U1)] bool instructionFault, bool* fIsExceptionIntercepted, out QCallException qcallException); + internal static unsafe partial bool RhpSfiInit(ref StackFrameIterator pThis, void* pStackwalkCtx, [MarshalAs(UnmanagedType.U1)] bool instructionFault, bool* fIsExceptionIntercepted, out QCallExceptionStatus qcallException); [StackTraceHidden] [DebuggerHidden] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "SfiNext")] [return: MarshalAs(UnmanagedType.U1)] - internal static unsafe partial bool RhpSfiNext(ref StackFrameIterator pThis, uint* uExCollideClauseIdx, bool* fUnwoundReversePInvoke, bool* fIsExceptionIntercepted, out QCallException qcallException); + internal static unsafe partial bool RhpSfiNext(ref StackFrameIterator pThis, uint* uExCollideClauseIdx, bool* fUnwoundReversePInvoke, bool* fIsExceptionIntercepted, out QCallExceptionStatus qcallException); [StackTraceHidden] [DebuggerHidden] @@ -32,12 +32,12 @@ internal static partial class InternalCalls [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool RhpCallFilterFunclet( ObjectHandleOnStack exceptionObj, byte* pFilterIP, void* pvRegDisplay, - out QCallException qcallException); + out QCallExceptionStatus qcallException); [StackTraceHidden] [DebuggerHidden] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AppendExceptionStackFrame")] - internal static unsafe partial void RhpAppendExceptionStackFrame(ObjectHandleOnStack exceptionObj, IntPtr ip, UIntPtr sp, int flags, EH.ExInfo* exInfo, out QCallException qcallException); + internal static unsafe partial void RhpAppendExceptionStackFrame(ObjectHandleOnStack exceptionObj, IntPtr ip, UIntPtr sp, int flags, EH.ExInfo* exInfo, out QCallExceptionStatus qcallException); [StackTraceHidden] [DebuggerHidden] @@ -50,6 +50,6 @@ internal static unsafe partial bool RhpCallFilterFunclet( [DebuggerHidden] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EHEnumNext")] [return: MarshalAs(UnmanagedType.U1)] - internal static unsafe partial bool RhpEHEnumNext(void* pEHEnum, void* pEHClause, out QCallException qcallException); + internal static unsafe partial bool RhpEHEnumNext(void* pEHEnum, void* pEHClause, out QCallExceptionStatus qcallException); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.CoreCLR.cs index c2ff63664fd551..0d6efe6dda1d66 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.CoreCLR.cs @@ -163,7 +163,7 @@ private static IntPtr GetTaggedImplCurrentVersion() internal sealed partial class ManagedObjectWrapperHolder { [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ComWrappers_RegisterIsRootedCallback")] - private static partial void RegisterIsRootedCallback(out QCallException qcallException); + private static partial void RegisterIsRootedCallback(out QCallExceptionStatus qcallException); private static IntPtr AllocateRefCountedHandle(ManagedObjectWrapperHolder holder) { @@ -171,7 +171,7 @@ private static IntPtr AllocateRefCountedHandle(ManagedObjectWrapperHolder holder } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ComWrappers_AllocateRefCountedHandle")] - private static partial IntPtr AllocateRefCountedHandle(ObjectHandleOnStack obj, out QCallException qcallException); + private static partial IntPtr AllocateRefCountedHandle(ObjectHandleOnStack obj, out QCallExceptionStatus qcallException); } } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/GCHandle.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/GCHandle.CoreCLR.cs index 711aa49921940f..8fb3b7dab91de2 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/GCHandle.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/GCHandle.CoreCLR.cs @@ -23,7 +23,7 @@ private static IntPtr InternalAllocWithGCTransition(object? value, GCHandleType => _InternalAllocWithGCTransition(ObjectHandleOnStack.Create(ref value), type, out _); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCHandle_InternalAllocWithGCTransition")] - private static partial IntPtr _InternalAllocWithGCTransition(ObjectHandleOnStack value, GCHandleType type, out QCallException qcallException); + private static partial IntPtr _InternalAllocWithGCTransition(ObjectHandleOnStack value, GCHandleType type, out QCallExceptionStatus qcallException); internal static void InternalFree(IntPtr handle) { @@ -39,7 +39,7 @@ private static void InternalFreeWithGCTransition(IntPtr dependentHandle) => _InternalFreeWithGCTransition(dependentHandle, out _); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCHandle_InternalFreeWithGCTransition")] - private static partial void _InternalFreeWithGCTransition(IntPtr dependentHandle, out QCallException qcallException); + private static partial void _InternalFreeWithGCTransition(IntPtr dependentHandle, out QCallExceptionStatus qcallException); #if FEATURE_JAVAMARSHAL internal static object? InternalGetBridgeWait(IntPtr handle) @@ -58,7 +58,7 @@ private static void InternalFreeWithGCTransition(IntPtr dependentHandle) private static extern bool InternalTryGetBridgeWait(IntPtr handle, ref object? result); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCHandle_InternalGetBridgeWait")] - private static partial void InternalGetBridgeWait(IntPtr handle, ObjectHandleOnStack result, out QCallException qcallException); + private static partial void InternalGetBridgeWait(IntPtr handle, ObjectHandleOnStack result, out QCallExceptionStatus qcallException); #endif #if DEBUG diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Java/JavaMarshal.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Java/JavaMarshal.CoreCLR.cs index 935b20c3437e85..83f36ac71313d0 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Java/JavaMarshal.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Java/JavaMarshal.CoreCLR.cs @@ -119,13 +119,13 @@ public static unsafe void FinishCrossReferenceProcessing( [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "JavaMarshal_Initialize")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool InitializeInternal(IntPtr callback, out QCallException qcallException); + private static partial bool InitializeInternal(IntPtr callback, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "JavaMarshal_CreateReferenceTrackingHandle")] - private static unsafe partial IntPtr CreateReferenceTrackingHandleInternal(ObjectHandleOnStack obj, void* context, out QCallException qcallException); + private static unsafe partial IntPtr CreateReferenceTrackingHandleInternal(ObjectHandleOnStack obj, void* context, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "JavaMarshal_FinishCrossReferenceProcessing")] - private static unsafe partial void FinishCrossReferenceProcessing(MarkCrossReferencesArgs* crossReferences, nuint length, void* unreachableObjectHandles, out QCallException qcallException); + private static unsafe partial void FinishCrossReferenceProcessing(MarkCrossReferencesArgs* crossReferences, nuint length, void* unreachableObjectHandles, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "JavaMarshal_GetContext")] [SuppressGCTransition] diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.CoreCLR.cs index ccb72d777158a7..f88197b2c0b4f5 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.CoreCLR.cs @@ -33,7 +33,7 @@ internal static int SizeOfHelper(RuntimeType t, [MarshalAs(UnmanagedType.Bool)] => SizeOfHelper(new QCallTypeHandle(ref t), throwIfNotMarshalable, out _); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_SizeOfHelper")] - private static partial int SizeOfHelper(QCallTypeHandle t, [MarshalAs(UnmanagedType.Bool)] bool throwIfNotMarshalable, out QCallException qcallException); + private static partial int SizeOfHelper(QCallTypeHandle t, [MarshalAs(UnmanagedType.Bool)] bool throwIfNotMarshalable, out QCallExceptionStatus qcallException); [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern", Justification = "Trimming doesn't affect types eligible for marshalling. Different exception for invalid inputs doesn't matter.")] @@ -56,7 +56,7 @@ public static IntPtr OffsetOf(Type t, string fieldName) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_OffsetOf")] - private static partial nint OffsetOf(IntPtr pFD, out QCallException qcallException); + private static partial nint OffsetOf(IntPtr pFD, out QCallExceptionStatus qcallException); [EditorBrowsable(EditorBrowsableState.Never)] [Obsolete("ReadByte(Object, Int32) may be unavailable in future releases.")] @@ -224,7 +224,7 @@ private static void PrelinkCore(MethodInfo m) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_Prelink")] - private static partial void InternalPrelink(RuntimeMethodHandleInternal m, out QCallException qcallException); + private static partial void InternalPrelink(RuntimeMethodHandleInternal m, out QCallExceptionStatus qcallException); [MethodImpl(MethodImplOptions.InternalCall)] public static extern /* struct _EXCEPTION_POINTERS* */ IntPtr GetExceptionPointers(); @@ -307,7 +307,7 @@ public void InitializeCompositeCache(RuntimeType.CompositeCacheEntry compositeEn [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_HasLayout")] [return: MarshalAs(UnmanagedType.Bool)] - internal static partial bool HasLayout(QCallTypeHandle t, [MarshalAs(UnmanagedType.Bool)] out bool isBlittable, out int nativeSize, out QCallException qcallException); + internal static partial bool HasLayout(QCallTypeHandle t, [MarshalAs(UnmanagedType.Bool)] out bool isBlittable, out int nativeSize, out QCallExceptionStatus qcallException); /// /// Marshals data from a structure class to a native memory block. If the @@ -409,7 +409,7 @@ internal static unsafe bool IsPinnable(object? obj) [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_IsBuiltInComSupported")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool IsBuiltInComSupportedInternal(out QCallException qcallException); + private static partial bool IsBuiltInComSupportedInternal(out QCallExceptionStatus qcallException); /// /// Returns the HInstance for this module. Returns -1 if the module doesn't have @@ -430,7 +430,7 @@ public static IntPtr GetHINSTANCE(Module m) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetHINSTANCE")] - private static partial IntPtr GetHINSTANCE(QCallModule m, out QCallException qcallException); + private static partial IntPtr GetHINSTANCE(QCallModule m, out QCallExceptionStatus qcallException); #endif // TARGET_WINDOWS @@ -442,7 +442,7 @@ internal static Exception GetExceptionForHRInternal(int errorCode, IntPtr errorI } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetExceptionForHR")] - private static partial void GetExceptionForHRInternal(int errorCode, IntPtr errorInfo, ObjectHandleOnStack exception, out QCallException qcallException); + private static partial void GetExceptionForHRInternal(int errorCode, IntPtr errorInfo, ObjectHandleOnStack exception, out QCallExceptionStatus qcallException); #if FEATURE_COMINTEROP /// @@ -453,7 +453,7 @@ public static int GetHRForException(Exception? e) => GetHRForException(ObjectHandleOnStack.Create(ref e), out _); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetHRForException")] - private static partial int GetHRForException(ObjectHandleOnStack exception, out QCallException qcallException); + private static partial int GetHRForException(ObjectHandleOnStack exception, out QCallExceptionStatus qcallException); /// /// Given a managed object that wraps an ITypeInfo, return its name. @@ -487,7 +487,7 @@ public static string GetTypeInfoName(ITypeInfo typeInfo) #pragma warning restore IDE0060 [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetTypeFromCLSID", StringMarshalling = StringMarshalling.Utf16)] - private static partial void GetTypeFromCLSID(in Guid clsid, string? server, ObjectHandleOnStack retType, out QCallException qcallException); + private static partial void GetTypeFromCLSID(in Guid clsid, string? server, ObjectHandleOnStack retType, out QCallExceptionStatus qcallException); /// /// Return the IUnknown* for an Object if the current context is the one @@ -502,7 +502,7 @@ public static string GetTypeInfoName(ITypeInfo typeInfo) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetIUnknownForObject")] - private static partial IntPtr /* IUnknown* */ GetIUnknownForObject(ObjectHandleOnStack o, out QCallException qcallException); + private static partial IntPtr /* IUnknown* */ GetIUnknownForObject(ObjectHandleOnStack o, out QCallExceptionStatus qcallException); /// /// Return the IDispatch* for an Object. @@ -516,7 +516,7 @@ public static string GetTypeInfoName(ITypeInfo typeInfo) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetIDispatchForObject")] - private static partial IntPtr /* IDispatch* */ GetIDispatchForObject(ObjectHandleOnStack o, out QCallException qcallException); + private static partial IntPtr /* IDispatch* */ GetIDispatchForObject(ObjectHandleOnStack o, out QCallExceptionStatus qcallException); /// /// Return the IUnknown* representing the interface for the Object. @@ -550,7 +550,7 @@ public static IntPtr GetComInterfaceForObject([DisallowNull] T o) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetComInterfaceForObject")] - private static partial IntPtr /* IUnknown* */ GetComInterfaceForObject(ObjectHandleOnStack o, QCallTypeHandle t, [MarshalAs(UnmanagedType.Bool)] bool fEnableCustomizedQueryInterface, out QCallException qcallException); + private static partial IntPtr /* IUnknown* */ GetComInterfaceForObject(ObjectHandleOnStack o, QCallTypeHandle t, [MarshalAs(UnmanagedType.Bool)] bool fEnableCustomizedQueryInterface, out QCallExceptionStatus qcallException); /// /// Return the managed object representing the IUnknown* @@ -566,7 +566,7 @@ public static object GetObjectForIUnknown(IntPtr /* IUnknown* */ pUnk) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetObjectForIUnknown")] - private static partial void GetObjectForIUnknown(IntPtr /* IUnknown* */ pUnk, ObjectHandleOnStack retObject, out QCallException qcallException); + private static partial void GetObjectForIUnknown(IntPtr /* IUnknown* */ pUnk, ObjectHandleOnStack retObject, out QCallExceptionStatus qcallException); [SupportedOSPlatform("windows")] public static object GetUniqueObjectForIUnknown(IntPtr unknown) @@ -585,7 +585,7 @@ public static object GetUniqueObjectForIUnknown(IntPtr unknown) /// ReleaseComObject on a RCW and not worry about other active uses ofsaid RCW. /// [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetUniqueObjectForIUnknown")] - private static partial void GetUniqueObjectForIUnknown(IntPtr unknown, ObjectHandleOnStack retObject, out QCallException qcallException); + private static partial void GetUniqueObjectForIUnknown(IntPtr unknown, ObjectHandleOnStack retObject, out QCallExceptionStatus qcallException); /// /// Return an Object for IUnknown, using the Type T. @@ -606,7 +606,7 @@ public static object GetTypedObjectForIUnknown(IntPtr /* IUnknown* */ pUnk, Type } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetTypedObjectForIUnknown")] - private static partial void GetTypedObjectForIUnknown(IntPtr /* IUnknown* */ pUnk, QCallTypeHandle t, ObjectHandleOnStack retObject, out QCallException qcallException); + private static partial void GetTypedObjectForIUnknown(IntPtr /* IUnknown* */ pUnk, QCallTypeHandle t, ObjectHandleOnStack retObject, out QCallExceptionStatus qcallException); [SupportedOSPlatform("windows")] [EditorBrowsable(EditorBrowsableState.Never)] @@ -624,7 +624,7 @@ public static IntPtr CreateAggregatedObject(IntPtr pOuter, object o) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_CreateAggregatedObject")] - private static partial IntPtr CreateAggregatedObject(IntPtr pOuter, ObjectHandleOnStack o, out QCallException qcallException); + private static partial IntPtr CreateAggregatedObject(IntPtr pOuter, ObjectHandleOnStack o, out QCallExceptionStatus qcallException); [SupportedOSPlatform("windows")] public static IntPtr CreateAggregatedObject(IntPtr pOuter, T o) where T : notnull @@ -641,7 +641,7 @@ public static void CleanupUnusedObjectsInCurrentContext() => InternalCleanupUnusedObjectsInCurrentContext(out _); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_CleanupUnusedObjectsInCurrentContext")] - private static partial void InternalCleanupUnusedObjectsInCurrentContext(out QCallException qcallException); + private static partial void InternalCleanupUnusedObjectsInCurrentContext(out QCallExceptionStatus qcallException); /// Returns a Boolean computed from runtime COM-cleanup state; it takes no arguments and dereferences no caller-supplied memory. [MethodImpl(MethodImplOptions.InternalCall)] @@ -683,7 +683,7 @@ public static int ReleaseComObject(object o) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_ReleaseComObject")] - private static partial int ReleaseComObject(ObjectHandleOnStack o, out QCallException qcallException); + private static partial int ReleaseComObject(ObjectHandleOnStack o, out QCallExceptionStatus qcallException); /// /// Release the COM component and zombie this object. @@ -708,7 +708,7 @@ public static int FinalReleaseComObject(object o) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_FinalReleaseComObject")] - private static partial void FinalReleaseComObject(ObjectHandleOnStack o, out QCallException qcallException); + private static partial void FinalReleaseComObject(ObjectHandleOnStack o, out QCallExceptionStatus qcallException); [SupportedOSPlatform("windows")] public static object? GetComObjectData(object obj, object key) @@ -834,7 +834,7 @@ private static object InternalCreateWrapperOfType(object o, Type t) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_InternalCreateWrapperOfType")] - private static partial void InternalCreateWrapperOfType(ObjectHandleOnStack o, QCallTypeHandle rt, ObjectHandleOnStack retObject, out QCallException qcallException); + private static partial void InternalCreateWrapperOfType(ObjectHandleOnStack o, QCallTypeHandle rt, ObjectHandleOnStack retObject, out QCallExceptionStatus qcallException); /// /// check if the type is visible from COM. @@ -851,7 +851,7 @@ public static bool IsTypeVisibleFromCom(Type t) [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_IsTypeVisibleFromCom")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool IsTypeVisibleFromCom(QCallTypeHandle rt, out QCallException qcallException); + private static partial bool IsTypeVisibleFromCom(QCallTypeHandle rt, out QCallExceptionStatus qcallException); [SupportedOSPlatform("windows")] [EditorBrowsable(EditorBrowsableState.Never)] @@ -868,7 +868,7 @@ public static void GetNativeVariantForObject(object? obj, /* VARIANT * */ IntPtr } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetNativeVariantForObject")] - private static partial void GetNativeVariantForObject(ObjectHandleOnStack obj, /* VARIANT * */ IntPtr pDstNativeVariant, out QCallException qcallException); + private static partial void GetNativeVariantForObject(ObjectHandleOnStack obj, /* VARIANT * */ IntPtr pDstNativeVariant, out QCallExceptionStatus qcallException); [SupportedOSPlatform("windows")] [EditorBrowsable(EditorBrowsableState.Never)] @@ -899,7 +899,7 @@ public static void GetNativeVariantForObject(T? obj, IntPtr pDstNativeVariant } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetObjectForNativeVariant")] - private static partial void GetObjectForNativeVariant(/* VARIANT * */ IntPtr pSrcNativeVariant, ObjectHandleOnStack retObject, out QCallException qcallException); + private static partial void GetObjectForNativeVariant(/* VARIANT * */ IntPtr pSrcNativeVariant, ObjectHandleOnStack retObject, out QCallExceptionStatus qcallException); [SupportedOSPlatform("windows")] [EditorBrowsable(EditorBrowsableState.Never)] @@ -931,7 +931,7 @@ public static void GetNativeVariantForObject(T? obj, IntPtr pDstNativeVariant } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetObjectsForNativeVariants")] - private static partial void GetObjectsForNativeVariants(/* VARIANT * */ IntPtr aSrcNativeVariant, int cVars, ObjectHandleOnStack retArray, out QCallException qcallException); + private static partial void GetObjectsForNativeVariants(/* VARIANT * */ IntPtr aSrcNativeVariant, int cVars, ObjectHandleOnStack retArray, out QCallExceptionStatus qcallException); [SupportedOSPlatform("windows")] [EditorBrowsable(EditorBrowsableState.Never)] @@ -966,7 +966,7 @@ public static int GetStartComSlot(Type t) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetStartComSlot")] - private static partial int GetStartComSlot(QCallTypeHandle rt, out QCallException qcallException); + private static partial int GetStartComSlot(QCallTypeHandle rt, out QCallExceptionStatus qcallException); /// /// Returns the last valid COM slot that GetMethodInfoForSlot will work on. @@ -983,7 +983,7 @@ public static int GetEndComSlot(Type t) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetEndComSlot")] - private static partial int GetEndComSlot(QCallTypeHandle rt, out QCallException qcallException); + private static partial int GetEndComSlot(QCallTypeHandle rt, out QCallExceptionStatus qcallException); [RequiresUnreferencedCode("Built-in COM support is not trim compatible", Url = "https://aka.ms/dotnet-illink/com")] [SupportedOSPlatform("windows")] @@ -1039,7 +1039,7 @@ public static void ChangeWrapperHandleStrength(object otp, bool fIsWeak) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_ChangeWrapperHandleStrength")] - private static partial void ChangeWrapperHandleStrength(ObjectHandleOnStack otp, [MarshalAs(UnmanagedType.Bool)] bool fIsWeak, out QCallException qcallException); + private static partial void ChangeWrapperHandleStrength(ObjectHandleOnStack otp, [MarshalAs(UnmanagedType.Bool)] bool fIsWeak, out QCallExceptionStatus qcallException); #endif // FEATURE_COMINTEROP internal static Delegate GetDelegateForFunctionPointerInternal(IntPtr ptr, RuntimeType t) @@ -1050,7 +1050,7 @@ internal static Delegate GetDelegateForFunctionPointerInternal(IntPtr ptr, Runti } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetDelegateForFunctionPointerInternal")] - private static partial void GetDelegateForFunctionPointerInternal(IntPtr ptr, QCallTypeHandle t, ObjectHandleOnStack retDelegate, out QCallException qcallException); + private static partial void GetDelegateForFunctionPointerInternal(IntPtr ptr, QCallTypeHandle t, ObjectHandleOnStack retDelegate, out QCallExceptionStatus qcallException); internal static IntPtr GetFunctionPointerForDelegateInternal(Delegate d) { @@ -1058,11 +1058,11 @@ internal static IntPtr GetFunctionPointerForDelegateInternal(Delegate d) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetFunctionPointerForDelegateInternal")] - private static partial IntPtr GetFunctionPointerForDelegateInternal(ObjectHandleOnStack d, out QCallException qcallException); + private static partial IntPtr GetFunctionPointerForDelegateInternal(ObjectHandleOnStack d, out QCallExceptionStatus qcallException); #if DEBUG // Used for testing in Checked or Debug [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetIsInCooperativeGCModeFunctionPointer")] - internal static unsafe partial delegate* unmanaged GetIsInCooperativeGCModeFunctionPointer(out QCallException qcallException); + internal static unsafe partial delegate* unmanaged GetIsInCooperativeGCModeFunctionPointer(); #endif } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs index 270732386206e9..e0a5600a1faedf 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs @@ -26,7 +26,7 @@ internal static IntPtr LoadLibraryByName(string libraryName, Assembly assembly, internal static partial IntPtr LoadByName(string libraryName, QCallAssembly callingAssembly, [MarshalAs(UnmanagedType.Bool)] bool hasDllImportSearchPathFlag, uint dllImportSearchPathFlag, [MarshalAs(UnmanagedType.Bool)] bool throwOnError, - out QCallException qcallException); + out QCallExceptionStatus qcallException); [UnmanagedCallersOnly] private static unsafe IntPtr LoadLibraryCallbackStub(char* pLibraryName, Assembly* pAssembly, bool hasDllImportSearchPathFlags, uint dllImportSearchPathFlags, Exception* pException) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveCMarshal.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveCMarshal.CoreCLR.cs index b76b6ce93028f6..5d05cbde453c7d 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveCMarshal.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveCMarshal.CoreCLR.cs @@ -26,7 +26,10 @@ public static void SetMessageSendPendingException(Exception? exception) private static partial bool TrySetGlobalMessageSendCallback( MessageSendFunction msgSendFunction, IntPtr func, - out QCallException qcallException); + out QCallExceptionStatus qcallException); + + private static bool TrySetGlobalMessageSendCallback(MessageSendFunction msgSendFunction, IntPtr func) + => TrySetGlobalMessageSendCallback(msgSendFunction, func, out _); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjCMarshal_TryInitializeReferenceTracker")] [return: MarshalAs(UnmanagedType.Bool)] @@ -35,7 +38,7 @@ private static unsafe partial bool TryInitializeReferenceTracker( delegate* unmanaged isReferencedCallback, delegate* unmanaged trackedObjectEnteredFinalization, ObjectHandleOnStack objectTrackingInfoTable, - out QCallException qcallException); + out QCallExceptionStatus qcallException); private static unsafe bool TryInitializeReferenceTracker( delegate* unmanaged beginEndCallback, @@ -57,10 +60,10 @@ private static unsafe bool TryInitializeReferenceTracker( } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjCMarshal_AllocateReferenceTrackingHandle")] - private static partial IntPtr AllocateReferenceTrackingHandle(ObjectHandleOnStack obj, out QCallException qcallException); + private static partial IntPtr AllocateReferenceTrackingHandle(ObjectHandleOnStack obj, out QCallExceptionStatus qcallException); private static IntPtr AllocateReferenceTrackingHandle(object obj) - => AllocateReferenceTrackingHandle(ObjectHandleOnStack.Create(ref obj)); + => AllocateReferenceTrackingHandle(ObjectHandleOnStack.Create(ref obj), out _); private static unsafe bool IsTrackedReferenceWithFinalizer(object obj) => RuntimeHelpers.GetMethodTable(obj)->IsTrackedReferenceWithFinalizer; diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/TrackerObjectManager.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/TrackerObjectManager.CoreCLR.cs index 494d818d754397..5a10882a87c072 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/TrackerObjectManager.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/TrackerObjectManager.CoreCLR.cs @@ -40,6 +40,6 @@ private static void RegisterGCCallbacks() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TrackerObjectManager_RegisterNativeObjectWrapperCache")] - private static partial void RegisterNativeObjectWrapperCache(ObjectHandleOnStack nativeObjectWrapperCache, out QCallException qcallException); + private static partial void RegisterNativeObjectWrapperCache(ObjectHandleOnStack nativeObjectWrapperCache, out QCallExceptionStatus qcallException); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs index 6714e66606e9b0..6cec4e0aa93b99 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs @@ -12,24 +12,24 @@ namespace System.Runtime.Loader public partial class AssemblyLoadContext { [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_InitializeAssemblyLoadContext")] - private static partial IntPtr InitializeAssemblyLoadContext(IntPtr ptrAssemblyLoadContext, [MarshalAs(UnmanagedType.Bool)] bool fRepresentsTPALoadContext, [MarshalAs(UnmanagedType.Bool)] bool isCollectible, out QCallException qcallException); + private static partial IntPtr InitializeAssemblyLoadContext(IntPtr ptrAssemblyLoadContext, [MarshalAs(UnmanagedType.Bool)] bool fRepresentsTPALoadContext, [MarshalAs(UnmanagedType.Bool)] bool isCollectible, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_PrepareForAssemblyLoadContextRelease")] - private static partial void PrepareForAssemblyLoadContextRelease(IntPtr ptrNativeAssemblyBinder, IntPtr ptrAssemblyLoadContextStrong, out QCallException qcallException); + private static partial void PrepareForAssemblyLoadContextRelease(IntPtr ptrNativeAssemblyBinder, IntPtr ptrAssemblyLoadContextStrong, out QCallExceptionStatus qcallException); [RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_LoadFromStream")] - private static partial void LoadFromStream(IntPtr ptrNativeAssemblyBinder, IntPtr ptrAssemblyArray, int iAssemblyArrayLen, IntPtr ptrSymbols, int iSymbolArrayLen, ObjectHandleOnStack retAssembly, out QCallException qcallException); + private static partial void LoadFromStream(IntPtr ptrNativeAssemblyBinder, IntPtr ptrAssemblyArray, int iAssemblyArrayLen, IntPtr ptrSymbols, int iSymbolArrayLen, ObjectHandleOnStack retAssembly, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MultiCoreJIT_InternalSetProfileRoot", StringMarshalling = StringMarshalling.Utf16)] - internal static partial void InternalSetProfileRoot(string directoryPath, out QCallException qcallException); + internal static partial void InternalSetProfileRoot(string directoryPath, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MultiCoreJIT_InternalStartProfile", StringMarshalling = StringMarshalling.Utf16)] - internal static partial void InternalStartProfile(string? profile, IntPtr ptrNativeAssemblyBinder, out QCallException qcallException); + internal static partial void InternalStartProfile(string? profile, IntPtr ptrNativeAssemblyBinder, out QCallExceptionStatus qcallException); [RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_LoadFromPath", StringMarshalling = StringMarshalling.Utf16)] - private static partial void LoadFromPath(IntPtr ptrNativeAssemblyBinder, string? ilPath, ObjectHandleOnStack retAssembly, out QCallException qcallException); + private static partial void LoadFromPath(IntPtr ptrNativeAssemblyBinder, string? ilPath, ObjectHandleOnStack retAssembly, out QCallExceptionStatus qcallException); internal static Assembly[] GetLoadedAssemblies() { @@ -39,26 +39,26 @@ internal static Assembly[] GetLoadedAssemblies() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetLoadedAssemblies")] - private static partial void GetLoadedAssemblies(ObjectHandleOnStack retAssemblies, out QCallException qcallException); + private static partial void GetLoadedAssemblies(ObjectHandleOnStack retAssemblies, out QCallExceptionStatus qcallException); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern bool IsTracingEnabled(); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_TraceResolvingHandlerInvoked", StringMarshalling = StringMarshalling.Utf16)] [return: MarshalAs(UnmanagedType.Bool)] - internal static partial bool TraceResolvingHandlerInvoked(string assemblyName, string handlerName, string? alcName, string? resultAssemblyName, string? resultAssemblyPath, out QCallException qcallException); + internal static partial bool TraceResolvingHandlerInvoked(string assemblyName, string handlerName, string? alcName, string? resultAssemblyName, string? resultAssemblyPath, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_TraceAssemblyResolveHandlerInvoked", StringMarshalling = StringMarshalling.Utf16)] [return: MarshalAs(UnmanagedType.Bool)] - internal static partial bool TraceAssemblyResolveHandlerInvoked(string assemblyName, string handlerName, string? resultAssemblyName, string? resultAssemblyPath, out QCallException qcallException); + internal static partial bool TraceAssemblyResolveHandlerInvoked(string assemblyName, string handlerName, string? resultAssemblyName, string? resultAssemblyPath, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_TraceAssemblyLoadFromResolveHandlerInvoked", StringMarshalling = StringMarshalling.Utf16)] [return: MarshalAs(UnmanagedType.Bool)] - internal static partial bool TraceAssemblyLoadFromResolveHandlerInvoked(string assemblyName, [MarshalAs(UnmanagedType.Bool)] bool isTrackedAssembly, string requestingAssemblyPath, string? requestedAssemblyPath, out QCallException qcallException); + internal static partial bool TraceAssemblyLoadFromResolveHandlerInvoked(string assemblyName, [MarshalAs(UnmanagedType.Bool)] bool isTrackedAssembly, string requestingAssemblyPath, string? requestedAssemblyPath, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_TraceSatelliteSubdirectoryPathProbed", StringMarshalling = StringMarshalling.Utf16)] [return: MarshalAs(UnmanagedType.Bool)] - internal static partial bool TraceSatelliteSubdirectoryPathProbed(string filePath, int hResult, out QCallException qcallException); + internal static partial bool TraceSatelliteSubdirectoryPathProbed(string filePath, int hResult, out QCallExceptionStatus qcallException); [RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")] private RuntimeAssembly InternalLoadFromPath(string? assemblyPath) @@ -85,7 +85,7 @@ internal unsafe Assembly InternalLoad(ReadOnlySpan arrAssembly, ReadOnlySp #if TARGET_WINDOWS [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_LoadFromInMemoryModule")] - private static partial IntPtr LoadFromInMemoryModuleInternal(IntPtr ptrNativeAssemblyBinder, IntPtr hModule, ObjectHandleOnStack retAssembly, out QCallException qcallException); + private static partial IntPtr LoadFromInMemoryModuleInternal(IntPtr ptrNativeAssemblyBinder, IntPtr hModule, ObjectHandleOnStack retAssembly, out QCallExceptionStatus qcallException); /// @@ -145,7 +145,7 @@ private static unsafe IntPtr ResolveUnmanagedDllUsingEvent(char* pUnmanagedDllNa } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetLoadContextForAssembly")] - private static partial IntPtr GetLoadContextForAssembly(QCallAssembly assembly, out QCallException qcallException); + private static partial IntPtr GetLoadContextForAssembly(QCallAssembly assembly, out QCallExceptionStatus qcallException); // Returns the load context in which the specified assembly has been loaded public static AssemblyLoadContext? GetLoadContext(Assembly assembly) diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs index 712dfd93461a40..ae3d3ee39d45a8 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs @@ -37,7 +37,7 @@ public static RuntimeTypeHandle FromIntPtr(IntPtr value) => private static partial void GetRuntimeTypeFromHandleSlow( IntPtr handle, ObjectHandleOnStack typeObject, - out QCallException qcallException); + out QCallExceptionStatus qcallException); [MethodImpl(MethodImplOptions.NoInlining)] private static RuntimeType GetRuntimeTypeFromHandleSlow(IntPtr handle) @@ -283,7 +283,7 @@ private static partial void CreateInstanceForAnotherGenericParameter( IntPtr* pTypeHandles, int cTypeHandles, ObjectHandleOnStack instantiatedObject, - out QCallException qcallException); + out QCallExceptionStatus qcallException); internal static unsafe object InternalAlloc(MethodTable* pMT) { @@ -301,7 +301,7 @@ internal static object InternalAlloc(RuntimeType type) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_InternalAlloc")] - private static unsafe partial void InternalAlloc(MethodTable* pMT, ObjectHandleOnStack result, out QCallException qcallException); + private static unsafe partial void InternalAlloc(MethodTable* pMT, ObjectHandleOnStack result, out QCallExceptionStatus qcallException); [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -319,7 +319,7 @@ static object InternalAllocNoChecksWorker(MethodTable* pMT) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_InternalAllocNoChecks")] - private static unsafe partial void InternalAllocNoChecks(MethodTable* pMT, ObjectHandleOnStack result, out QCallException qcallException); + private static unsafe partial void InternalAllocNoChecks(MethodTable* pMT, ObjectHandleOnStack result, out QCallExceptionStatus qcallException); [MethodImpl(MethodImplOptions.InternalCall)] private static extern object? InternalAllocNoChecks_FastPath(MethodTable* pMT); @@ -366,11 +366,11 @@ private static partial void GetActivationInfo( delegate** ppfnRefCtor, delegate** ppfnValueCtor, Interop.BOOL* pfCtorIsPublic, - out QCallException qcallException); + out QCallExceptionStatus qcallException); #if FEATURE_COMINTEROP [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_AllocateComObject")] - private static partial void AllocateComObject(void* pClassFactory, ObjectHandleOnStack result, out QCallException qcallException); + private static partial void AllocateComObject(void* pClassFactory, ObjectHandleOnStack result, out QCallExceptionStatus qcallException); // Referenced by unmanaged layer (see GetActivationInfo). // First parameter is ComClassFactory*. @@ -404,7 +404,7 @@ static RuntimeAssembly GetAssemblyWorker(RuntimeType type) private static extern RuntimeAssembly? GetAssemblyIfExists(RuntimeType type); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetAssemblySlow")] - private static partial void GetAssemblySlow(ObjectHandleOnStack type, ObjectHandleOnStack assembly, out QCallException qcallException); + private static partial void GetAssemblySlow(ObjectHandleOnStack type, ObjectHandleOnStack assembly, out QCallExceptionStatus qcallException); internal static RuntimeModule GetModule(RuntimeType type) { @@ -423,7 +423,7 @@ static RuntimeModule GetModuleWorker(RuntimeType type) private static extern RuntimeModule? GetModuleIfExists(RuntimeType type); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetModuleSlow")] - private static partial void GetModuleSlow(ObjectHandleOnStack type, ObjectHandleOnStack module, out QCallException qcallException); + private static partial void GetModuleSlow(ObjectHandleOnStack type, ObjectHandleOnStack module, out QCallExceptionStatus qcallException); public ModuleHandle GetModuleHandle() { @@ -464,7 +464,7 @@ public ModuleHandle GetModuleHandle() internal static extern int GetToken(RuntimeType type); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetMethodAt")] - private static unsafe partial IntPtr GetMethodAt(MethodTable* pMT, int slot, out QCallException qcallException); + private static unsafe partial IntPtr GetMethodAt(MethodTable* pMT, int slot, out QCallExceptionStatus qcallException); internal static RuntimeMethodHandleInternal GetMethodAt(RuntimeType type, int slot) { @@ -491,7 +491,7 @@ internal static Type[] GetArgumentTypesFromFunctionPointer(RuntimeType type) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetArgumentTypesFromFunctionPointer")] - private static partial void GetArgumentTypesFromFunctionPointer(QCallTypeHandle type, ObjectHandleOnStack argTypes, out QCallException qcallException); + private static partial void GetArgumentTypesFromFunctionPointer(QCallTypeHandle type, ObjectHandleOnStack argTypes, out QCallExceptionStatus qcallException); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern bool IsUnmanagedFunctionPointer(RuntimeType type); @@ -542,7 +542,7 @@ internal static IntroducedMethodEnumerator GetIntroducedMethods(RuntimeType type private static extern void GetNextIntroducedMethod(ref RuntimeMethodHandleInternal method); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetFields")] - private static partial Interop.BOOL GetFields(MethodTable* pMT, Span data, ref int usedCount, out QCallException qcallException); + private static partial Interop.BOOL GetFields(MethodTable* pMT, Span data, ref int usedCount, out QCallExceptionStatus qcallException); internal static bool GetFields(RuntimeType type, Span buffer, out int count) { @@ -563,7 +563,7 @@ internal static bool GetFields(RuntimeType type, Span buffer, out int co } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetInterfaces")] - private static unsafe partial void GetInterfaces(MethodTable* pMT, ObjectHandleOnStack result, out QCallException qcallException); + private static unsafe partial void GetInterfaces(MethodTable* pMT, ObjectHandleOnStack result, out QCallExceptionStatus qcallException); internal static Type[] GetInterfaces(RuntimeType type) { @@ -582,7 +582,7 @@ internal static Type[] GetInterfaces(RuntimeType type) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetConstraints")] - private static partial void GetConstraints(QCallTypeHandle handle, ObjectHandleOnStack types, out QCallException qcallException); + private static partial void GetConstraints(QCallTypeHandle handle, ObjectHandleOnStack types, out QCallExceptionStatus qcallException); internal Type[]? GetConstraints() { @@ -595,7 +595,7 @@ internal static Type[] GetInterfaces(RuntimeType type) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "QCall_GetGCHandleForTypeHandle")] - private static partial IntPtr GetGCHandle(QCallTypeHandle handle, GCHandleType type, out QCallException qcallException); + private static partial IntPtr GetGCHandle(QCallTypeHandle handle, GCHandleType type, out QCallExceptionStatus qcallException); internal IntPtr GetGCHandle(GCHandleType type) { @@ -604,7 +604,7 @@ internal IntPtr GetGCHandle(GCHandleType type) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "QCall_FreeGCHandleForTypeHandle")] - private static partial IntPtr FreeGCHandle(QCallTypeHandle typeHandle, IntPtr objHandle, out QCallException qcallException); + private static partial IntPtr FreeGCHandle(QCallTypeHandle typeHandle, IntPtr objHandle, out QCallExceptionStatus qcallException); internal IntPtr FreeGCHandle(IntPtr objHandle) { @@ -616,7 +616,7 @@ internal IntPtr FreeGCHandle(IntPtr objHandle) internal static extern int GetNumVirtuals(RuntimeType type); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals")] - private static partial int GetNumVirtualsAndStaticVirtuals(QCallTypeHandle type, out QCallException qcallException); + private static partial int GetNumVirtualsAndStaticVirtuals(QCallTypeHandle type, out QCallExceptionStatus qcallException); internal static int GetNumVirtualsAndStaticVirtuals(RuntimeType type) { @@ -625,7 +625,7 @@ internal static int GetNumVirtualsAndStaticVirtuals(RuntimeType type) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_VerifyInterfaceIsImplemented")] - private static partial void VerifyInterfaceIsImplemented(QCallTypeHandle handle, QCallTypeHandle interfaceHandle, out QCallException qcallException); + private static partial void VerifyInterfaceIsImplemented(QCallTypeHandle handle, QCallTypeHandle interfaceHandle, out QCallExceptionStatus qcallException); internal void VerifyInterfaceIsImplemented(RuntimeTypeHandle interfaceHandle) { @@ -635,7 +635,7 @@ internal void VerifyInterfaceIsImplemented(RuntimeTypeHandle interfaceHandle) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetInterfaceMethodImplementation")] - private static partial RuntimeMethodHandleInternal GetInterfaceMethodImplementation(QCallTypeHandle handle, QCallTypeHandle interfaceHandle, RuntimeMethodHandleInternal interfaceMethodHandle, out QCallException qcallException); + private static partial RuntimeMethodHandleInternal GetInterfaceMethodImplementation(QCallTypeHandle handle, QCallTypeHandle interfaceHandle, RuntimeMethodHandleInternal interfaceMethodHandle, out QCallExceptionStatus qcallException); internal RuntimeMethodHandleInternal GetInterfaceMethodImplementation(RuntimeTypeHandle interfaceHandle, RuntimeMethodHandleInternal interfaceMethodHandle) { @@ -646,7 +646,7 @@ internal RuntimeMethodHandleInternal GetInterfaceMethodImplementation(RuntimeTyp [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_IsVisible")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool _IsVisible(QCallTypeHandle typeHandle, out QCallException qcallException); + private static partial bool _IsVisible(QCallTypeHandle typeHandle, out QCallExceptionStatus qcallException); internal static bool IsVisible(RuntimeType type) { @@ -654,7 +654,7 @@ internal static bool IsVisible(RuntimeType type) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_ConstructName")] - private static partial void ConstructName(QCallTypeHandle handle, TypeNameFormatFlags formatFlags, StringHandleOnStack retString, out QCallException qcallException); + private static partial void ConstructName(QCallTypeHandle handle, TypeNameFormatFlags formatFlags, StringHandleOnStack retString, out QCallExceptionStatus qcallException); internal string ConstructName(TypeNameFormatFlags formatFlags) { @@ -695,10 +695,10 @@ internal static bool CanCastTo(RuntimeType type, RuntimeType target) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetDeclaringTypeHandleForGenericVariable")] - private static partial IntPtr GetDeclaringTypeHandleForGenericVariable(IntPtr typeHandle, out QCallException qcallException); + private static partial IntPtr GetDeclaringTypeHandleForGenericVariable(IntPtr typeHandle, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetDeclaringTypeHandle")] - private static partial IntPtr GetDeclaringTypeHandle(IntPtr typeHandle, out QCallException qcallException); + private static partial IntPtr GetDeclaringTypeHandle(IntPtr typeHandle, out QCallExceptionStatus qcallException); internal static RuntimeType? GetDeclaringType(RuntimeType type) { @@ -728,7 +728,7 @@ internal static bool CanCastTo(RuntimeType type, RuntimeType target) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetDeclaringMethodForGenericParameter")] - private static partial void GetDeclaringMethodForGenericParameter(QCallTypeHandle typeHandle, ObjectHandleOnStack result, out QCallException qcallException); + private static partial void GetDeclaringMethodForGenericParameter(QCallTypeHandle typeHandle, ObjectHandleOnStack result, out QCallExceptionStatus qcallException); internal static IRuntimeMethodInfo? GetDeclaringMethodForGenericParameter(RuntimeType type) { @@ -740,7 +740,7 @@ internal static bool CanCastTo(RuntimeType type, RuntimeType target) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetInstantiation")] - internal static partial void GetInstantiation(QCallTypeHandle type, ObjectHandleOnStack types, Interop.BOOL fAsRuntimeTypeArray, out QCallException qcallException); + internal static partial void GetInstantiation(QCallTypeHandle type, ObjectHandleOnStack types, Interop.BOOL fAsRuntimeTypeArray, out QCallExceptionStatus qcallException); internal RuntimeType[] GetInstantiationInternal() { @@ -759,7 +759,7 @@ internal RuntimeType[] GetInstantiationInternal() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_Instantiate")] - private static partial void Instantiate(QCallTypeHandle handle, IntPtr* pInst, int numGenericArgs, ObjectHandleOnStack type, out QCallException qcallException); + private static partial void Instantiate(QCallTypeHandle handle, IntPtr* pInst, int numGenericArgs, ObjectHandleOnStack type, out QCallExceptionStatus qcallException); internal RuntimeType Instantiate(RuntimeType inst) { @@ -787,7 +787,7 @@ internal RuntimeType Instantiate(Type[]? inst) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_MakeArray")] - private static partial void MakeArray(QCallTypeHandle handle, int rank, ObjectHandleOnStack type, out QCallException qcallException); + private static partial void MakeArray(QCallTypeHandle handle, int rank, ObjectHandleOnStack type, out QCallExceptionStatus qcallException); internal RuntimeType MakeArray(int rank) { @@ -798,7 +798,7 @@ internal RuntimeType MakeArray(int rank) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_MakeSZArray")] - private static partial void MakeSZArray(QCallTypeHandle handle, ObjectHandleOnStack type, out QCallException qcallException); + private static partial void MakeSZArray(QCallTypeHandle handle, ObjectHandleOnStack type, out QCallExceptionStatus qcallException); internal RuntimeType MakeSZArray() { @@ -809,7 +809,7 @@ internal RuntimeType MakeSZArray() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_MakeByRef")] - private static partial void MakeByRef(QCallTypeHandle handle, ObjectHandleOnStack type, out QCallException qcallException); + private static partial void MakeByRef(QCallTypeHandle handle, ObjectHandleOnStack type, out QCallExceptionStatus qcallException); internal RuntimeType MakeByRef() { @@ -820,7 +820,7 @@ internal RuntimeType MakeByRef() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_MakeFunctionPointer")] - private static partial void MakeFunctionPointer(nint* retAndParamTypes, int numArgs, [MarshalAs(UnmanagedType.Bool)] bool isUnmanaged, ObjectHandleOnStack type, out QCallException qcallException); + private static partial void MakeFunctionPointer(nint* retAndParamTypes, int numArgs, [MarshalAs(UnmanagedType.Bool)] bool isUnmanaged, ObjectHandleOnStack type, out QCallExceptionStatus qcallException); internal RuntimeType MakeFunctionPointer(Type[] parameterTypes, bool isUnmanaged) { @@ -843,7 +843,7 @@ internal RuntimeType MakeFunctionPointer(Type[] parameterTypes, bool isUnmanaged } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_MakePointer")] - private static partial void MakePointer(QCallTypeHandle handle, ObjectHandleOnStack type, out QCallException qcallException); + private static partial void MakePointer(QCallTypeHandle handle, ObjectHandleOnStack type, out QCallExceptionStatus qcallException); internal RuntimeType MakePointer() { @@ -854,7 +854,7 @@ internal RuntimeType MakePointer() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetGenericTypeDefinition")] - internal static partial void GetGenericTypeDefinition(QCallTypeHandle type, ObjectHandleOnStack retType, out QCallException qcallException); + internal static partial void GetGenericTypeDefinition(QCallTypeHandle type, ObjectHandleOnStack retType, out QCallExceptionStatus qcallException); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern bool IsGenericVariable(RuntimeType type); @@ -881,7 +881,7 @@ internal bool ContainsGenericVariables() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_SatisfiesConstraints")] - private static partial Interop.BOOL SatisfiesConstraints(QCallTypeHandle paramType, QCallTypeHandle pTypeContext, RuntimeMethodHandleInternal pMethodContext, QCallTypeHandle toType, out QCallException qcallException); + private static partial Interop.BOOL SatisfiesConstraints(QCallTypeHandle paramType, QCallTypeHandle pTypeContext, RuntimeMethodHandleInternal pMethodContext, QCallTypeHandle toType, out QCallExceptionStatus qcallException); internal static bool SatisfiesConstraints(RuntimeType paramType, RuntimeType? typeContext, RuntimeMethodInfo? methodContext, RuntimeType toType) { @@ -892,7 +892,7 @@ internal static bool SatisfiesConstraints(RuntimeType paramType, RuntimeType? ty } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_RegisterCollectibleTypeDependency")] - private static partial void RegisterCollectibleTypeDependency(QCallTypeHandle type, QCallAssembly assembly, out QCallException qcallException); + private static partial void RegisterCollectibleTypeDependency(QCallTypeHandle type, QCallAssembly assembly, out QCallExceptionStatus qcallException); internal static void RegisterCollectibleTypeDependency(RuntimeType type, RuntimeAssembly? assembly) { @@ -908,7 +908,7 @@ public void GetObjectData(SerializationInfo info, StreamingContext context) #if FEATURE_TYPEEQUIVALENCE [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_IsEquivalentTo")] - private static partial Interop.BOOL IsEquivalentTo(QCallTypeHandle rtType1, QCallTypeHandle rtType2, out QCallException qcallException); + private static partial Interop.BOOL IsEquivalentTo(QCallTypeHandle rtType1, QCallTypeHandle rtType2, out QCallExceptionStatus qcallException); internal static bool IsEquivalentTo(RuntimeType rtType1, RuntimeType rtType2) => IsEquivalentTo(new QCallTypeHandle(ref rtType1), new QCallTypeHandle(ref rtType2), out _) == Interop.BOOL.TRUE; @@ -1069,7 +1069,7 @@ internal bool IsNullHandle() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetFunctionPointer")] - internal static partial IntPtr GetFunctionPointer(RuntimeMethodHandleInternal handle, out QCallException qcallException); + internal static partial IntPtr GetFunctionPointer(RuntimeMethodHandleInternal handle, out QCallExceptionStatus qcallException); public IntPtr GetFunctionPointer() { @@ -1087,7 +1087,7 @@ internal static partial Interop.BOOL IsCAVisibleFromDecoratedType( RuntimeMethodHandleInternal attrCtor, QCallTypeHandle sourceTypeHandle, QCallModule sourceModule, - out QCallException qcallException); + out QCallExceptionStatus qcallException); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern MethodAttributes GetAttributes(RuntimeMethodHandleInternal method); @@ -1103,7 +1103,7 @@ internal static MethodAttributes GetAttributes(IRuntimeMethodInfo method) internal static extern MethodImplAttributes GetImplAttributes(IRuntimeMethodInfo method); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_ConstructInstantiation")] - private static partial void ConstructInstantiation(RuntimeMethodHandleInternal method, TypeNameFormatFlags format, StringHandleOnStack retString, out QCallException qcallException); + private static partial void ConstructInstantiation(RuntimeMethodHandleInternal method, TypeNameFormatFlags format, StringHandleOnStack retString, out QCallExceptionStatus qcallException); internal static string ConstructInstantiation(IRuntimeMethodInfo method, TypeNameFormatFlags format) { @@ -1184,7 +1184,7 @@ internal static MdUtf8String GetUtf8Name(RuntimeMethodHandleInternal method) [DebuggerStepThrough] [DebuggerHidden] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_InvokeMethod")] - private static partial void InvokeMethod(ObjectHandleOnStack target, void** arguments, ObjectHandleOnStack sig, Interop.BOOL isConstructor, ObjectHandleOnStack result, out QCallException qcallException); + private static partial void InvokeMethod(ObjectHandleOnStack target, void** arguments, ObjectHandleOnStack sig, Interop.BOOL isConstructor, ObjectHandleOnStack result, out QCallExceptionStatus qcallException); [DebuggerStepThrough] [DebuggerHidden] @@ -1239,7 +1239,7 @@ ref obj.GetRawData(), } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetMethodInstantiation")] - private static partial void GetMethodInstantiation(RuntimeMethodHandleInternal method, ObjectHandleOnStack types, Interop.BOOL fAsRuntimeTypeArray, out QCallException qcallException); + private static partial void GetMethodInstantiation(RuntimeMethodHandleInternal method, ObjectHandleOnStack types, Interop.BOOL fAsRuntimeTypeArray, out QCallExceptionStatus qcallException); internal static RuntimeType[] GetMethodInstantiationInternal(IRuntimeMethodInfo method) { @@ -1278,7 +1278,7 @@ internal static bool HasMethodInstantiation(IRuntimeMethodInfo method) private static extern RuntimeMethodHandleInternal GetStubIfNeededInternal(RuntimeMethodHandleInternal method, RuntimeType declaringType); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetStubIfNeededSlow")] - private static partial RuntimeMethodHandleInternal GetStubIfNeededSlow(RuntimeMethodHandleInternal method, QCallTypeHandle declaringTypeHandle, ObjectHandleOnStack methodInstantiation, out QCallException qcallException); + private static partial RuntimeMethodHandleInternal GetStubIfNeededSlow(RuntimeMethodHandleInternal method, QCallTypeHandle declaringTypeHandle, ObjectHandleOnStack methodInstantiation, out QCallExceptionStatus qcallException); internal static RuntimeMethodHandleInternal GetStubIfNeeded(RuntimeMethodHandleInternal method, RuntimeType declaringType, RuntimeType[]? methodInstantiation) { @@ -1300,7 +1300,7 @@ static RuntimeMethodHandleInternal GetStubIfNeededWorker(RuntimeMethodHandleInte internal static extern RuntimeMethodHandleInternal GetMethodFromCanonical(RuntimeMethodHandleInternal method, RuntimeType declaringType); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetNativeCode")] - private static partial IntPtr GetNativeCode(RuntimeMethodHandleInternal method, out QCallException qcallException); + private static partial IntPtr GetNativeCode(RuntimeMethodHandleInternal method, out QCallExceptionStatus qcallException); internal static IntPtr GetNativeCodeInternal(IRuntimeMethodInfo method) { @@ -1323,7 +1323,7 @@ internal static bool IsGenericMethodDefinition(IRuntimeMethodInfo method) private static extern bool IsTypicalMethodDefinition(IRuntimeMethodInfo method); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetTypicalMethodDefinition")] - private static partial void GetTypicalMethodDefinition(RuntimeMethodHandleInternal method, ObjectHandleOnStack outMethod, out QCallException qcallException); + private static partial void GetTypicalMethodDefinition(RuntimeMethodHandleInternal method, ObjectHandleOnStack outMethod, out QCallExceptionStatus qcallException); internal static IRuntimeMethodInfo GetTypicalMethodDefinition(IRuntimeMethodInfo method) { @@ -1342,7 +1342,7 @@ internal static IRuntimeMethodInfo GetTypicalMethodDefinition(IRuntimeMethodInfo internal static int GetGenericParameterCount(IRuntimeMethodInfo method) => GetGenericParameterCount(IRuntimeMethodInfo.GetValue(method)); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_StripMethodInstantiation")] - private static partial void StripMethodInstantiation(RuntimeMethodHandleInternal method, ObjectHandleOnStack outMethod, out QCallException qcallException); + private static partial void StripMethodInstantiation(RuntimeMethodHandleInternal method, ObjectHandleOnStack outMethod, out QCallExceptionStatus qcallException); internal static IRuntimeMethodInfo StripMethodInstantiation(IRuntimeMethodInfo method) { @@ -1358,13 +1358,13 @@ internal static IRuntimeMethodInfo StripMethodInstantiation(IRuntimeMethodInfo m internal static extern bool IsDynamicMethod(RuntimeMethodHandleInternal method); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_Destroy")] - internal static partial void Destroy(RuntimeMethodHandleInternal method, out QCallException qcallException); + internal static partial void Destroy(RuntimeMethodHandleInternal method, out QCallExceptionStatus qcallException); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern Resolver GetResolver(RuntimeMethodHandleInternal method); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetMethodBody")] - private static partial void GetMethodBody(RuntimeMethodHandleInternal method, QCallTypeHandle declaringType, ObjectHandleOnStack result, out QCallException qcallException); + private static partial void GetMethodBody(RuntimeMethodHandleInternal method, QCallTypeHandle declaringType, ObjectHandleOnStack result, out QCallExceptionStatus qcallException); internal static RuntimeMethodBody? GetMethodBody(IRuntimeMethodInfo method, RuntimeType declaringType) { @@ -1587,7 +1587,7 @@ internal static RuntimeType GetApproxDeclaringType(IRuntimeFieldInfo field) [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeFieldHandle_GetRVAFieldInfo")] [return: MarshalAs(UnmanagedType.Bool)] - internal static partial bool GetRVAFieldInfo(RuntimeFieldHandleInternal field, out void* address, out uint size, out QCallException qcallException); + internal static partial bool GetRVAFieldInfo(RuntimeFieldHandleInternal field, out void* address, out uint size, out QCallExceptionStatus qcallException); internal static ref byte GetFieldDataReference(object target, RuntimeFieldInfo field) { @@ -1606,7 +1606,7 @@ internal static ref byte GetFieldDataReference(ref byte target, RuntimeFieldInfo } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeFieldHandle_GetFieldDataReference")] - private static unsafe partial void GetFieldDataReference(IntPtr fieldDesc, ObjectHandleOnStack target, ByteRefOnStack fieldDataRef, out QCallException qcallException); + private static unsafe partial void GetFieldDataReference(IntPtr fieldDesc, ObjectHandleOnStack target, ByteRefOnStack fieldDataRef, out QCallExceptionStatus qcallException); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern int GetToken(IntPtr fieldDesc); @@ -1626,7 +1626,7 @@ private static partial void GetValue( QCallTypeHandle declaringType, [MarshalAs(UnmanagedType.Bool)] ref bool isClassInitialized, ObjectHandleOnStack result, - out QCallException qcallException); + out QCallExceptionStatus qcallException); internal static object? GetValue(RtFieldInfo field, object? instance, RuntimeType fieldType, RuntimeType? declaringType, ref bool isClassInitialized) { @@ -1648,7 +1648,7 @@ private static partial void GetValueDirect( QCallTypeHandle fieldType, QCallTypeHandle declaringType, ObjectHandleOnStack result, - out QCallException qcallException); + out QCallExceptionStatus qcallException); internal static object? GetValueDirect(RtFieldInfo field, RuntimeType fieldType, TypedReference typedRef, RuntimeType? contextType) { @@ -1671,7 +1671,7 @@ private static partial void SetValue( QCallTypeHandle fieldType, QCallTypeHandle declaringType, [MarshalAs(UnmanagedType.Bool)] ref bool isClassInitialized, - out QCallException qcallException); + out QCallExceptionStatus qcallException); internal static void SetValue(RtFieldInfo field, object? obj, object? value, RuntimeType fieldType, RuntimeType? declaringType, ref bool isClassInitialized) { @@ -1691,7 +1691,7 @@ private static partial void SetValueDirect( ObjectHandleOnStack value, QCallTypeHandle fieldType, QCallTypeHandle declaringType, - out QCallException qcallException); + out QCallExceptionStatus qcallException); internal static void SetValueDirect(RtFieldInfo field, RuntimeType fieldType, TypedReference typedRef, object? value, RuntimeType? contextType) { @@ -1739,7 +1739,7 @@ public void GetObjectData(SerializationInfo info, StreamingContext context) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeFieldHandle_GetEnCFieldAddr")] - private static partial void* GetEnCFieldAddr(ObjectHandleOnStack tgt, void* pFD, out QCallException qcallException); + private static partial void* GetEnCFieldAddr(ObjectHandleOnStack tgt, void* pFD, out QCallExceptionStatus qcallException); // implementation of CORINFO_HELP_GETFIELDADDR [StackTraceHidden] @@ -1821,7 +1821,7 @@ private static partial void GetDynamicMethod( int sigLen, ObjectHandleOnStack resolver, ObjectHandleOnStack result, - out QCallException qcallException); + out QCallExceptionStatus qcallException); internal static IRuntimeMethodInfo GetDynamicMethod(RuntimeModule module, string name, byte[] sig, Resolver resolver) { @@ -1912,7 +1912,7 @@ private static partial void ResolveType(QCallModule module, IntPtr* methodInstArgs, int methodInstCount, ObjectHandleOnStack type, - out QCallException qcallException); + out QCallExceptionStatus qcallException); // SQL-CLR LKG9 Compiler dependency [RequiresUnreferencedCode("Trimming changes metadata tokens")] @@ -1964,7 +1964,7 @@ private static partial RuntimeMethodHandleInternal ResolveMethod(QCallModule mod int typeInstCount, IntPtr* methodInstArgs, int methodInstCount, - out QCallException qcallException); + out QCallExceptionStatus qcallException); // SQL-CLR LKG9 Compiler dependency [RequiresUnreferencedCode("Trimming changes metadata tokens")] @@ -2020,10 +2020,10 @@ private static partial void ResolveField(QCallModule module, IntPtr* methodInstArgs, int methodInstCount, ObjectHandleOnStack retField, - out QCallException qcallException); + out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleHandle_GetModuleType")] - internal static partial void GetModuleType(QCallModule handle, ObjectHandleOnStack type, out QCallException qcallException); + internal static partial void GetModuleType(QCallModule handle, ObjectHandleOnStack type, out QCallExceptionStatus qcallException); internal static RuntimeType GetModuleType(RuntimeModule module) { @@ -2033,7 +2033,7 @@ internal static RuntimeType GetModuleType(RuntimeModule module) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleHandle_GetPEKind")] - private static partial void GetPEKind(QCallModule handle, int* peKind, int* machine, out QCallException qcallException); + private static partial void GetPEKind(QCallModule handle, int* peKind, int* machine, out QCallExceptionStatus qcallException); // making this internal, used by Module.GetPEKind internal static void GetPEKind(RuntimeModule module, out PortableExecutableKinds peKind, out ImageFileMachine machine) @@ -2081,7 +2081,7 @@ private static partial void Init( void* pCorSig, int cCorSig, RuntimeFieldHandleInternal fieldHandle, RuntimeMethodHandleInternal methodHandle, - out QCallException qcallException); + out QCallExceptionStatus qcallException); [MemberNotNull(nameof(_returnTypeORfieldType))] private void Init( @@ -2154,7 +2154,7 @@ internal RuntimeType[] Arguments private static partial Interop.BOOL AreEqual( void* sig1, int csig1, QCallTypeHandle type1, void* sig2, int csig2, QCallTypeHandle type2, - out QCallException qcallException); + out QCallExceptionStatus qcallException); internal static bool AreEqual(Signature sig1, Signature sig2) { @@ -2221,7 +2221,7 @@ private static partial void GetCustomModifiersAtOffset( int offset, Interop.BOOL required, ObjectHandleOnStack result, - out QCallException qcallException); + out QCallExceptionStatus qcallException); internal Type[] GetCustomModifiersAtOffset(int offset, bool required) { diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.BoxCache.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.BoxCache.cs index f3d4a30943007a..5c427ab5ee670a 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.BoxCache.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.BoxCache.cs @@ -138,7 +138,7 @@ private static partial void GetBoxInfo( void** pvAllocatorFirstArg, int* pNullableValueOffset, uint* pValueTypeSize, - out QCallException qcallException); + out QCallExceptionStatus qcallException); } internal object? Box(ref byte data) diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs index e550685dfd7e3a..4f99059e63f54c 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs @@ -3415,7 +3415,7 @@ public override unsafe Guid GUID } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ReflectionInvocation_GetGuid")] - private static unsafe partial void GetGuid(MethodTable* pMT, Guid* result, out QCallException qcallException); + private static unsafe partial void GetGuid(MethodTable* pMT, Guid* result, out QCallExceptionStatus qcallException); #if FEATURE_COMINTEROP [MethodImpl(MethodImplOptions.NoInlining)] @@ -3427,7 +3427,7 @@ private static unsafe void GetComObjectGuidWorker(RuntimeType type, Guid* result } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ReflectionInvocation_GetComObjectGuid")] - private static unsafe partial void GetComObjectGuid(ObjectHandleOnStack type, Guid* result, out QCallException qcallException); + private static unsafe partial void GetComObjectGuid(ObjectHandleOnStack type, Guid* result, out QCallExceptionStatus qcallException); #endif // FEATURE_COMINTEROP protected override unsafe bool IsValueTypeImpl() @@ -4147,7 +4147,7 @@ private static partial void InvokeDispMethod( int lcid, ObjectHandleOnStack namedParameters, ObjectHandleOnStack result, - out QCallException qcallException); + out QCallExceptionStatus qcallException); private object InvokeDispMethod( string name, @@ -4370,7 +4370,7 @@ internal readonly unsafe partial struct MdUtf8String { [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MdUtf8String_EqualsCaseInsensitive")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool EqualsCaseInsensitive(void* szLhs, void* szRhs, int cSz, out QCallException qcallException); + private static partial bool EqualsCaseInsensitive(void* szLhs, void* szRhs, int cSz, out QCallExceptionStatus qcallException); private readonly byte* m_pStringHeap; // This is the raw UTF8 string. private readonly int m_StringHeapByteLength; diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CreateUninitializedCache.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CreateUninitializedCache.CoreCLR.cs index 68761ae52f4090..d4aa0a407df58f 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CreateUninitializedCache.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CreateUninitializedCache.CoreCLR.cs @@ -81,7 +81,7 @@ private static partial void GetCreateUninitializedInfo( QCallTypeHandle type, delegate** ppfnAllocator, void** pvAllocatorFirstArg, - out QCallException qcallException); + out QCallExceptionStatus qcallException); } } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/String.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/String.CoreCLR.cs index caae0f87cf3600..5165db97afa454 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/String.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/String.CoreCLR.cs @@ -23,7 +23,7 @@ internal static unsafe string FastAllocateString(nint length) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "String_Intern")] - private static partial void Intern(StringHandleOnStack src, out QCallException qcallException); + private static partial void Intern(StringHandleOnStack src, out QCallExceptionStatus qcallException); public static string Intern(string str) { @@ -33,7 +33,7 @@ public static string Intern(string str) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "String_IsInterned")] - private static partial void IsInterned(StringHandleOnStack src, out QCallException qcallException); + private static partial void IsInterned(StringHandleOnStack src, out QCallExceptionStatus qcallException); public static string? IsInterned(string str) { diff --git a/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs index 33c8b6b84332f0..38b4609bfe7885 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs @@ -539,7 +539,7 @@ internal static void ConvertToNative(object objSrc, IntPtr pDstVariant) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjectMarshaler_ConvertToNative")] - private static partial void ConvertToNative(ObjectHandleOnStack objSrc, IntPtr pDstVariant, out QCallException qcallException); + private static partial void ConvertToNative(ObjectHandleOnStack objSrc, IntPtr pDstVariant, out QCallExceptionStatus qcallException); internal static object ConvertToManaged(IntPtr pSrcVariant) { @@ -549,7 +549,7 @@ internal static object ConvertToManaged(IntPtr pSrcVariant) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjectMarshaler_ConvertToManaged")] - private static partial void ConvertToManaged(IntPtr pSrcVariant, ObjectHandleOnStack retObject, out QCallException qcallException); + private static partial void ConvertToManaged(IntPtr pSrcVariant, ObjectHandleOnStack retObject, out QCallExceptionStatus qcallException); internal static unsafe void ClearNative(IntPtr pVariant) { @@ -632,7 +632,7 @@ internal static IntPtr ConvertToNative(object? objSrc, IntPtr itfMT, IntPtr clas } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "InterfaceMarshaler_ConvertToNative")] - private static partial IntPtr ConvertToNative(ObjectHandleOnStack objSrc, IntPtr itfMT, IntPtr classMT, int flag, out QCallException qcallException); + private static partial IntPtr ConvertToNative(ObjectHandleOnStack objSrc, IntPtr itfMT, IntPtr classMT, int flag, out QCallExceptionStatus qcallException); internal static object? ConvertToManaged(ref IntPtr ppUnk, IntPtr itfMT, IntPtr classMT, int flags) { @@ -645,7 +645,7 @@ internal static IntPtr ConvertToNative(object? objSrc, IntPtr itfMT, IntPtr clas } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "InterfaceMarshaler_ConvertToManaged")] - private static partial void ConvertToManaged(ref IntPtr ppUnk, IntPtr itfMT, IntPtr classMT, int flags, ObjectHandleOnStack retObject, out QCallException qcallException); + private static partial void ConvertToManaged(ref IntPtr ppUnk, IntPtr itfMT, IntPtr classMT, int flags, ObjectHandleOnStack retObject, out QCallExceptionStatus qcallException); internal static void ClearNative(IntPtr pUnk) { @@ -663,10 +663,10 @@ internal static object GetObjectForComCallableWrapperIUnknown(IntPtr unk) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "InterfaceMarshaler_GetObjectForComCallableWrapperIUnknown")] - private static partial void GetObjectForComCallableWrapperIUnknown(IntPtr unk, ObjectHandleOnStack retObject, out QCallException qcallException); + private static partial void GetObjectForComCallableWrapperIUnknown(IntPtr unk, ObjectHandleOnStack retObject, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "InterfaceMarshaler_ValidateComVisibilityForIUnknown")] - internal static partial void ValidateComVisibilityForIUnknown(IntPtr unk, out QCallException qcallException); + internal static partial void ValidateComVisibilityForIUnknown(IntPtr unk, out QCallExceptionStatus qcallException); internal static void ValidateComVisibilityForIUnknown(IntPtr unk) { @@ -690,7 +690,7 @@ internal static void ConvertSpaceToNative(IntPtr pMarshalState, in object pManag } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MngdSafeArrayMarshaler_ConvertSpaceToNative")] - private static partial void ConvertSpaceToNative(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome, out QCallException qcallException); + private static partial void ConvertSpaceToNative(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome, out QCallExceptionStatus qcallException); internal static void ConvertContentsToNative(IntPtr pMarshalState, in object pManagedHome, IntPtr pNativeHome, object pOriginalManagedObject) { @@ -700,7 +700,7 @@ internal static void ConvertContentsToNative(IntPtr pMarshalState, in object pMa } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MngdSafeArrayMarshaler_ConvertContentsToNative")] - private static partial void ConvertContentsToNative(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome, ObjectHandleOnStack pOriginalManagedObject, out QCallException qcallException); + private static partial void ConvertContentsToNative(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome, ObjectHandleOnStack pOriginalManagedObject, out QCallExceptionStatus qcallException); internal static void ConvertSpaceToManaged(IntPtr pMarshalState, ref object? pManagedHome, IntPtr pNativeHome) { @@ -710,7 +710,7 @@ internal static void ConvertSpaceToManaged(IntPtr pMarshalState, ref object? pMa } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MngdSafeArrayMarshaler_ConvertSpaceToManaged")] - private static partial void ConvertSpaceToManaged(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome, out QCallException qcallException); + private static partial void ConvertSpaceToManaged(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome, out QCallExceptionStatus qcallException); internal static void ConvertContentsToManaged(IntPtr pMarshalState, in object pManagedHome, IntPtr pNativeHome) { @@ -719,7 +719,7 @@ internal static void ConvertContentsToManaged(IntPtr pMarshalState, in object pM } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MngdSafeArrayMarshaler_ConvertContentsToManaged")] - private static partial void ConvertContentsToManaged(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome, out QCallException qcallException); + private static partial void ConvertContentsToManaged(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome, out QCallExceptionStatus qcallException); #pragma warning disable IDE0060 // Remove unused parameter. These APIs need to match a the shape of a "managed" marshaler. internal static void ClearNative(IntPtr pMarshalState, in object pManagedHome, IntPtr pNativeHome) @@ -729,7 +729,7 @@ internal static void ClearNative(IntPtr pMarshalState, in object pManagedHome, I #pragma warning restore IDE0060 // Remove unused parameter [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MngdSafeArrayMarshaler_ClearNative")] - private static partial void ClearNative(IntPtr pMarshalState, IntPtr pNativeHome, out QCallException qcallException); + private static partial void ClearNative(IntPtr pMarshalState, IntPtr pNativeHome, out QCallExceptionStatus qcallException); } // class MngdSafeArrayMarshaler #endif // FEATURE_COMINTEROP @@ -2182,7 +2182,7 @@ internal static partial class StubHelpers /// QCall that throws an interop parameter exception selected by integer resource and parameter indices; it accesses no caller-supplied memory. [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_ThrowInteropParamException")] - internal static safe partial void ThrowInteropParamException(int resID, int paramIdx, out QCallException qcallException); + internal static safe partial void ThrowInteropParamException(int resID, int paramIdx, out QCallExceptionStatus qcallException); internal static safe void ThrowInteropParamException(int resID, int paramIdx) => ThrowInteropParamException(resID, paramIdx, out _); @@ -2246,7 +2246,7 @@ internal static void SetPendingExceptionObject(Exception? exception) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_CreateCustomMarshaler")] - internal static partial void CreateCustomMarshaler(IntPtr pMD, int paramToken, IntPtr hndManagedType, ObjectHandleOnStack customMarshaler, out QCallException qcallException); + internal static partial void CreateCustomMarshaler(IntPtr pMD, int paramToken, IntPtr hndManagedType, ObjectHandleOnStack customMarshaler, out QCallExceptionStatus qcallException); #if FEATURE_COMINTEROP [SupportedOSPlatform("windows")] @@ -2353,7 +2353,7 @@ internal static void SafeHandleRelease(SafeHandle pHandle) private static extern IntPtr GetCOMIPFromRCW(object objSrc, IntPtr pCPCMD, out IntPtr ppTarget); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_GetCOMIPFromRCWSlow")] - private static partial IntPtr GetCOMIPFromRCWSlow(ObjectHandleOnStack objSrc, IntPtr pCPCMD, out IntPtr ppTarget, [MarshalAs(UnmanagedType.Bool)] out bool pfNeedsRelease, out QCallException qcallException); + private static partial IntPtr GetCOMIPFromRCWSlow(ObjectHandleOnStack objSrc, IntPtr pCPCMD, out IntPtr ppTarget, [MarshalAs(UnmanagedType.Bool)] out bool pfNeedsRelease, out QCallExceptionStatus qcallException); internal static IntPtr GetCOMIPFromRCW(object objSrc, IntPtr pCPCMD, out IntPtr ppTarget, out bool pfNeedsRelease) { @@ -2379,13 +2379,13 @@ static IntPtr GetCOMIPFromRCWWorker(object objSrc, IntPtr pCPCMD, out IntPtr ppT // Profiler helpers //------------------------------------------------------- [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_ProfilerBeginTransitionCallback")] - internal static unsafe partial void* ProfilerBeginTransitionCallback(void* pTargetMD, out QCallException qcallException); + internal static unsafe partial void* ProfilerBeginTransitionCallback(void* pTargetMD, out QCallExceptionStatus qcallException); internal static unsafe void* ProfilerBeginTransitionCallback(void* pTargetMD) => ProfilerBeginTransitionCallback(pTargetMD, out _); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_ProfilerEndTransitionCallback")] - internal static unsafe partial void ProfilerEndTransitionCallback(void* pTargetMD, out QCallException qcallException); + internal static unsafe partial void ProfilerEndTransitionCallback(void* pTargetMD, out QCallExceptionStatus qcallException); internal static unsafe void ProfilerEndTransitionCallback(void* pTargetMD) => ProfilerEndTransitionCallback(pTargetMD, out _); @@ -2408,7 +2408,7 @@ internal static void CheckStringLength(uint length) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_CreateLayoutClassMarshalStubs")] - internal static unsafe partial void CreateLayoutClassMarshalStubs(QCallTypeHandle th, out delegate* pConvertToUnmanaged, out delegate* pConvertToManaged, out delegate* pFree, out QCallException qcallException); + internal static unsafe partial void CreateLayoutClassMarshalStubs(QCallTypeHandle th, out delegate* pConvertToUnmanaged, out delegate* pConvertToManaged, out delegate* pFree, out QCallExceptionStatus qcallException); internal static unsafe void LayoutTypeConvertToUnmanaged(object obj, byte* pNative, ref CleanupWorkListElement? pCleanupWorkList) { @@ -2521,13 +2521,13 @@ internal static void ThrowWrongSizeArrayInNativeStruct() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_MarshalToManagedVaList")] - internal static partial void MarshalToManagedVaList(IntPtr va_list, IntPtr pArgIterator, out QCallException qcallException); + internal static partial void MarshalToManagedVaList(IntPtr va_list, IntPtr pArgIterator, out QCallExceptionStatus qcallException); internal static void MarshalToManagedVaList(IntPtr va_list, IntPtr pArgIterator) => MarshalToManagedVaList(va_list, pArgIterator, out _); [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_MarshalToUnmanagedVaList")] - internal static partial void MarshalToUnmanagedVaList(IntPtr va_list, uint vaListSize, IntPtr pArgIterator, out QCallException qcallException); + internal static partial void MarshalToUnmanagedVaList(IntPtr va_list, uint vaListSize, IntPtr pArgIterator, out QCallExceptionStatus qcallException); internal static void MarshalToUnmanagedVaList(IntPtr va_list, uint vaListSize, IntPtr pArgIterator) => MarshalToUnmanagedVaList(va_list, vaListSize, pArgIterator, out _); @@ -2539,13 +2539,13 @@ internal static void MarshalToUnmanagedVaList(IntPtr va_list, uint vaListSize, I internal static extern void LogPinnedArgument(IntPtr localDesc, IntPtr nativeArg); [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_ValidateObject")] - private static partial void ValidateObject(ObjectHandleOnStack obj, IntPtr pMD, out QCallException qcallException); + private static partial void ValidateObject(ObjectHandleOnStack obj, IntPtr pMD, out QCallExceptionStatus qcallException); internal static void ValidateObject(object obj, IntPtr pMD) => ValidateObject(ObjectHandleOnStack.Create(ref obj), pMD, out _); [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_ValidateByref")] - internal static partial void ValidateByref(IntPtr byref, IntPtr pMD, out QCallException qcallException); // the byref is pinned so we can safely "cast" it to IntPtr + internal static partial void ValidateByref(IntPtr byref, IntPtr pMD, out QCallExceptionStatus qcallException); // the byref is pinned so we can safely "cast" it to IntPtr internal static void ValidateByref(IntPtr byref, IntPtr pMD) => ValidateByref(byref, pMD, out _); @@ -2560,7 +2560,7 @@ internal static void MulticastDebuggerTraceHelper(object o, int count) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_MulticastDebuggerTraceHelper")] - private static partial void MulticastDebuggerTraceHelperQCall(ObjectHandleOnStack obj, int count, out QCallException qcallException); + private static partial void MulticastDebuggerTraceHelperQCall(ObjectHandleOnStack obj, int count, out QCallExceptionStatus qcallException); [Intrinsic] internal static IntPtr NextCallReturnAddress() => throw new UnreachableException(); // Unconditionally expanded intrinsic diff --git a/src/coreclr/System.Private.CoreLib/src/System/Threading/ObjectHeader.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Threading/ObjectHeader.CoreCLR.cs index 456147b90a87cc..cc93dc7df8f7c8 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Threading/ObjectHeader.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Threading/ObjectHeader.CoreCLR.cs @@ -89,7 +89,7 @@ static Lock GetLockObjectFallback(object obj) private static extern IntPtr GetLockHandleIfExists(object obj); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjectHeader_GetOrCreateLockObject")] - private static partial void GetOrCreateLockObject(ObjectHandleOnStack obj, ObjectHandleOnStack lockObj, out QCallException qcallException); + private static partial void GetOrCreateLockObject(ObjectHandleOnStack obj, ObjectHandleOnStack lockObj, out QCallExceptionStatus qcallException); // // A few words about spinning choices: diff --git a/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs index 1baad1c8fc8b63..afa0e2b2814e0b 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs @@ -112,7 +112,7 @@ private unsafe void StartCore() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_Start")] - private static unsafe partial Interop.BOOL StartInternal(ThreadHandle t, int stackSize, int priority, Interop.BOOL isThreadPool, char* pThreadName, ObjectHandleOnStack exception, out QCallException qcallException); + private static unsafe partial Interop.BOOL StartInternal(ThreadHandle t, int stackSize, int priority, Interop.BOOL isThreadPool, char* pThreadName, ObjectHandleOnStack exception, out QCallExceptionStatus qcallException); [UnmanagedCallersOnly] private static unsafe void StartCallback(Thread* pThread) @@ -162,7 +162,7 @@ public static void SpinWait(int iterations) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_YieldThread")] - private static partial Interop.BOOL YieldInternal(out QCallException qcallException); + private static partial Interop.BOOL YieldInternal(out QCallExceptionStatus qcallException); public static bool Yield() => YieldInternal(out _) != Interop.BOOL.FALSE; @@ -175,7 +175,7 @@ private static Thread InitializeCurrentThread() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetCurrentThread")] - private static partial void GetCurrentThread(ObjectHandleOnStack thread, out QCallException qcallException); + private static partial void GetCurrentThread(ObjectHandleOnStack thread, out QCallExceptionStatus qcallException); private void Initialize() { @@ -184,7 +184,7 @@ private void Initialize() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_Initialize")] - private static partial void Initialize(ObjectHandleOnStack thread, out QCallException qcallException); + private static partial void Initialize(ObjectHandleOnStack thread, out QCallExceptionStatus qcallException); /// Clean up the thread when it goes away. ~Thread() => InternalFinalize(); // Delegate to the unmanaged portion. @@ -199,7 +199,7 @@ private void ThreadNameChanged(string? value) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_InformThreadNameChange", StringMarshalling = StringMarshalling.Utf16)] - private static partial void InformThreadNameChange(ThreadHandle t, string? name, int len, out QCallException qcallException); + private static partial void InformThreadNameChange(ThreadHandle t, string? name, int len, out QCallExceptionStatus qcallException); /// Returns true if the thread has been started and is not dead. public bool IsAlive => (ThreadState & (ThreadState.Unstarted | ThreadState.Stopped | ThreadState.Aborted)) == 0; @@ -242,7 +242,7 @@ public bool IsBackground private static partial Interop.BOOL GetIsBackground(ThreadHandle t); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_SetIsBackground")] - private static partial void SetIsBackground(ThreadHandle t, Interop.BOOL value, out QCallException qcallException); + private static partial void SetIsBackground(ThreadHandle t, Interop.BOOL value, out QCallExceptionStatus qcallException); /// Returns true if the thread is a threadpool thread. public bool IsThreadPoolThread @@ -271,7 +271,7 @@ internal set [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_SetPriority")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial void SetPriority(ObjectHandleOnStack thread, int priority, out QCallException qcallException); + private static partial void SetPriority(ObjectHandleOnStack thread, int priority, out QCallExceptionStatus qcallException); /// Returns the priority of the thread. public ThreadPriority Priority @@ -293,7 +293,7 @@ public ThreadPriority Priority } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetCurrentOSThreadId")] - private static partial ulong GetCurrentOSThreadId(out QCallException qcallException); + private static partial ulong GetCurrentOSThreadId(out QCallExceptionStatus qcallException); /// /// Return the thread state as a consistent set of bits. This is more @@ -348,10 +348,10 @@ internal void ClearWaitSleepJoinState() /// #if FEATURE_COMINTEROP_APARTMENT_SUPPORT [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetApartmentState")] - private static partial int GetApartmentState(ObjectHandleOnStack t, out QCallException qcallException); + private static partial int GetApartmentState(ObjectHandleOnStack t, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_SetApartmentState")] - private static partial int SetApartmentState(ObjectHandleOnStack t, int state, out QCallException qcallException); + private static partial int SetApartmentState(ObjectHandleOnStack t, int state, out QCallExceptionStatus qcallException); public ApartmentState GetApartmentState() { @@ -446,10 +446,10 @@ public void Interrupt() #if TARGET_WINDOWS [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_Interrupt")] - private static partial void Interrupt(ThreadHandle t, out QCallException qcallException); + private static partial void Interrupt(ThreadHandle t, out QCallExceptionStatus qcallException); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetOSHandle")] - private static partial SafeWaitHandle GetOSHandle(ThreadHandle t, out QCallException qcallException); + private static partial SafeWaitHandle GetOSHandle(ThreadHandle t, out QCallExceptionStatus qcallException); private SafeWaitHandle GetJoinHandle() { @@ -612,7 +612,7 @@ private static unsafe void OnThreadExited(Thread* pThread, Exception* pException } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_ReentrantWaitAny")] - internal static unsafe partial int ReentrantWaitAny([MarshalAs(UnmanagedType.Bool)] bool alertable, int timeout, int count, IntPtr* handles, out QCallException qcallException); + internal static unsafe partial int ReentrantWaitAny([MarshalAs(UnmanagedType.Bool)] bool alertable, int timeout, int count, IntPtr* handles, out QCallExceptionStatus qcallException); internal static void CheckForPendingInterrupt() { @@ -621,7 +621,7 @@ internal static void CheckForPendingInterrupt() } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_CheckForPendingInterrupt")] - private static partial void CheckForPendingInterrupt(ThreadHandle t, out QCallException qcallException); + private static partial void CheckForPendingInterrupt(ThreadHandle t, out QCallExceptionStatus qcallException); [StructLayout(LayoutKind.Sequential)] private struct NativeThreadClass diff --git a/src/coreclr/System.Private.CoreLib/src/System/TypeLoadException.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/TypeLoadException.CoreCLR.cs index 684e94c0aa3e5f..347bec9d7bee7b 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/TypeLoadException.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/TypeLoadException.CoreCLR.cs @@ -46,7 +46,7 @@ private void SetMessageField() } [LibraryImport(RuntimeHelpers.QCall)] - private static partial void GetTypeLoadExceptionMessage(int resourceId, StringHandleOnStack retString, out QCallException qcallException); + private static partial void GetTypeLoadExceptionMessage(int resourceId, StringHandleOnStack retString, out QCallExceptionStatus qcallException); [UnmanagedCallersOnly] internal static unsafe void Create(char* pClassName, char* pAssemblyName, char* pMessageArg, int resourceId, object* pResult, Exception* pException) diff --git a/src/coreclr/System.Private.CoreLib/src/System/ValueType.cs b/src/coreclr/System.Private.CoreLib/src/System/ValueType.cs index 9dfc1d99e9f388..570d4747519761 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/ValueType.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/ValueType.cs @@ -84,7 +84,7 @@ private static unsafe bool CanCompareBitsOrUseFastGetHashCode(MethodTable* pMT) [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MethodTable_CanCompareBitsOrUseFastGetHashCode")] [return: MarshalAs(UnmanagedType.Bool)] - private static unsafe partial bool CanCompareBitsOrUseFastGetHashCodeHelper(MethodTable* pMT, out QCallException qcallException); + private static unsafe partial bool CanCompareBitsOrUseFastGetHashCodeHelper(MethodTable* pMT, out QCallExceptionStatus qcallException); /*=================================GetHashCode================================== **Action: Our algorithm for returning the hashcode is a little bit complex. We look @@ -165,7 +165,7 @@ private enum ValueTypeHashCodeStrategy [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ValueType_GetHashCodeStrategy")] private static unsafe partial ValueTypeHashCodeStrategy GetHashCodeStrategy( MethodTable* pMT, ObjectHandleOnStack objHandle, out uint fieldOffset, out uint fieldSize, out MethodTable* fieldMT, - out QCallException qcallException); + out QCallExceptionStatus qcallException); public override string? ToString() { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Variant.cs b/src/coreclr/System.Private.CoreLib/src/System/Variant.cs index 44b32faa103ac9..9d514f8165f574 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Variant.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Variant.cs @@ -19,7 +19,7 @@ internal static partial class Variant internal static bool IsSystemDrawingColor(Type type) => type.FullName == "System.Drawing.Color"; // Matches the behavior of IsTypeRefOrDef [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Variant_ConvertValueTypeToRecord")] - private static partial void ConvertValueTypeToRecord(ObjectHandleOnStack obj, out ComVariant pOle, out QCallException qcallException); + private static partial void ConvertValueTypeToRecord(ObjectHandleOnStack obj, out ComVariant pOle, out QCallExceptionStatus qcallException); internal static ComVariant GetIUnknownOrIDispatchFromObject(object? obj) { @@ -28,7 +28,7 @@ internal static ComVariant GetIUnknownOrIDispatchFromObject(object? obj) } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetIUnknownOrIDispatchForObject")] - private static partial IntPtr GetIUnknownOrIDispatchForObject(ObjectHandleOnStack o, [MarshalAs(UnmanagedType.Bool)] out bool isIDispatch, out QCallException qcallException); + private static partial IntPtr GetIUnknownOrIDispatchForObject(ObjectHandleOnStack o, [MarshalAs(UnmanagedType.Bool)] out bool isIDispatch, out QCallExceptionStatus qcallException); private static object? GetObjectFromIUnknown(IntPtr pUnk) { diff --git a/src/coreclr/vm/JitQCallHelpers.h b/src/coreclr/vm/JitQCallHelpers.h index 991d23980902d4..13b7b0e47db25f 100644 --- a/src/coreclr/vm/JitQCallHelpers.h +++ b/src/coreclr/vm/JitQCallHelpers.h @@ -18,12 +18,12 @@ class Module; class MethodTable; class MethodDesc; -extern "C" void * QCALLTYPE ResolveVirtualFunctionPointer(QCall::ObjectHandleOnStack obj, CORINFO_CLASS_HANDLE classHnd, CORINFO_METHOD_HANDLE methodHnd, QCallException* qcallError); -extern "C" CORINFO_GENERIC_HANDLE QCALLTYPE GenericHandleWorker(MethodDesc * pMD, MethodTable * pMT, LPVOID signature, DWORD dictionaryIndexAndSlot, Module* pModule, QCallException* qcallError); -extern "C" void QCALLTYPE InitClassHelper(MethodTable* pMT, QCallException* qcallError); -extern "C" void QCALLTYPE ThrowInvalidCastException(CORINFO_CLASS_HANDLE pTargetType, CORINFO_CLASS_HANDLE pSourceType, QCallException* qcallError); -extern "C" void QCALLTYPE GetThreadStaticsByMethodTable(QCall::ByteRefOnStack refHandle, MethodTable* pMT, bool gcStatic, QCallException* qcallError); -extern "C" void QCALLTYPE GetThreadStaticsByIndex(QCall::ByteRefOnStack refHandle, uint32_t staticBlockIndex, bool gcStatic, QCallException* qcallError); -extern "C" BOOL QCALLTYPE IsInstanceOf_NoCacheLookup(CORINFO_CLASS_HANDLE type, BOOL throwCastException, QCall::ObjectHandleOnStack objOnStack, QCallException* qcallError); +extern "C" void * QCALLTYPE ResolveVirtualFunctionPointer(QCall::ObjectHandleOnStack obj, CORINFO_CLASS_HANDLE classHnd, CORINFO_METHOD_HANDLE methodHnd, QCallExceptionStatus* qcallError); +extern "C" CORINFO_GENERIC_HANDLE QCALLTYPE GenericHandleWorker(MethodDesc * pMD, MethodTable * pMT, LPVOID signature, DWORD dictionaryIndexAndSlot, Module* pModule, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE InitClassHelper(MethodTable* pMT, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ThrowInvalidCastException(CORINFO_CLASS_HANDLE pTargetType, CORINFO_CLASS_HANDLE pSourceType, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE GetThreadStaticsByMethodTable(QCall::ByteRefOnStack refHandle, MethodTable* pMT, bool gcStatic, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE GetThreadStaticsByIndex(QCall::ByteRefOnStack refHandle, uint32_t staticBlockIndex, bool gcStatic, QCallExceptionStatus* qcallError); +extern "C" BOOL QCALLTYPE IsInstanceOf_NoCacheLookup(CORINFO_CLASS_HANDLE type, BOOL throwCastException, QCall::ObjectHandleOnStack objOnStack, QCallExceptionStatus* qcallError); #endif //_JITQCALLHELPERS_H diff --git a/src/coreclr/vm/appdomainnative.cpp b/src/coreclr/vm/appdomainnative.cpp index 0ef8a2afa404ee..092505035a63d8 100644 --- a/src/coreclr/vm/appdomainnative.cpp +++ b/src/coreclr/vm/appdomainnative.cpp @@ -16,7 +16,7 @@ #include "stringarraylist.h" // static -extern "C" void QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnStack assemblyLoadContext, NativeAssemblyNameParts* pAssemblyNameParts, INT32 hashAlgorithm, INT32 access, QCall::ObjectHandleOnStack retAssembly, QCallException* qcallError) +extern "C" void QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnStack assemblyLoadContext, NativeAssemblyNameParts* pAssemblyNameParts, INT32 hashAlgorithm, INT32 access, QCall::ObjectHandleOnStack retAssembly, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -41,7 +41,7 @@ extern "C" void QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnS END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetLoadedAssemblies(QCall::ObjectHandleOnStack retAssemblies, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_GetLoadedAssemblies(QCall::ObjectHandleOnStack retAssemblies, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -141,7 +141,7 @@ namespace } // Get the value of a known host property from the binder/AppDomain state. -extern "C" BOOL QCALLTYPE AppContext_TryGetHostPropertyValue(LPCWSTR name, QCall::StringHandleOnStack retValue, QCallException* qcallError) +extern "C" BOOL QCALLTYPE AppContext_TryGetHostPropertyValue(LPCWSTR name, QCall::StringHandleOnStack retValue, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -234,7 +234,7 @@ extern "C" BOOL QCALLTYPE AppContext_TryGetHostPropertyValue(LPCWSTR name, QCall return found; } -extern "C" void QCALLTYPE String_IsInterned(QCall::StringHandleOnStack str, QCallException* qcallError) +extern "C" void QCALLTYPE String_IsInterned(QCall::StringHandleOnStack str, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -251,7 +251,7 @@ extern "C" void QCALLTYPE String_IsInterned(QCall::StringHandleOnStack str, QCal END_QCALL; } -extern "C" void QCALLTYPE String_Intern(QCall::StringHandleOnStack str, QCallException* qcallError) +extern "C" void QCALLTYPE String_Intern(QCall::StringHandleOnStack str, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/appdomainnative.hpp b/src/coreclr/vm/appdomainnative.hpp index 7622b81fcb0e81..bc7eed9d818f92 100644 --- a/src/coreclr/vm/appdomainnative.hpp +++ b/src/coreclr/vm/appdomainnative.hpp @@ -16,13 +16,13 @@ #include "qcall.h" -extern "C" void QCALLTYPE String_Intern(QCall::StringHandleOnStack str, QCallException* qcallError); -extern "C" void QCALLTYPE String_IsInterned(QCall::StringHandleOnStack str, QCallException* qcallError); +extern "C" void QCALLTYPE String_Intern(QCall::StringHandleOnStack str, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE String_IsInterned(QCall::StringHandleOnStack str, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnStack assemblyLoadContext, NativeAssemblyNameParts* pAssemblyName, INT32 hashAlgorithm, INT32 access, QCall::ObjectHandleOnStack retAssembly, QCallException* qcallError); +extern "C" void QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnStack assemblyLoadContext, NativeAssemblyNameParts* pAssemblyName, INT32 hashAlgorithm, INT32 access, QCall::ObjectHandleOnStack retAssembly, QCallExceptionStatus* qcallError); extern "C" void QCALLTYPE AppContext_SetFirstChanceExceptionHandler(); -extern "C" BOOL QCALLTYPE AppContext_TryGetHostPropertyValue(LPCWSTR name, QCall::StringHandleOnStack retValue, QCallException* qcallError); +extern "C" BOOL QCALLTYPE AppContext_TryGetHostPropertyValue(LPCWSTR name, QCall::StringHandleOnStack retValue, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetLoadedAssemblies(QCall::ObjectHandleOnStack retAssemblies, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_GetLoadedAssemblies(QCall::ObjectHandleOnStack retAssemblies, QCallExceptionStatus* qcallError); #endif diff --git a/src/coreclr/vm/arraynative.cpp b/src/coreclr/vm/arraynative.cpp index 2f5d2c0473cf41..4986e61dd4c996 100644 --- a/src/coreclr/vm/arraynative.cpp +++ b/src/coreclr/vm/arraynative.cpp @@ -28,7 +28,7 @@ FCIMPL1(INT32, ArrayNative::GetCorElementTypeOfElementType, ArrayBase* arrayUNSA } FCIMPLEND -extern "C" PCODE QCALLTYPE Array_GetElementConstructorEntrypoint(QCall::TypeHandle pArrayTypeHnd, QCallException* qcallError) +extern "C" PCODE QCALLTYPE Array_GetElementConstructorEntrypoint(QCall::TypeHandle pArrayTypeHnd, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -107,7 +107,7 @@ static void CheckElementType(TypeHandle elementType) } } -extern "C" void QCALLTYPE Array_CreateInstance(QCall::TypeHandle pTypeHnd, INT32 rank, INT32* pLengths, INT32* pLowerBounds, BOOL createFromArrayType, QCall::ObjectHandleOnStack retArray, QCallException* qcallError) +extern "C" void QCALLTYPE Array_CreateInstance(QCall::TypeHandle pTypeHnd, INT32 rank, INT32* pLengths, INT32* pLowerBounds, BOOL createFromArrayType, QCall::ObjectHandleOnStack retArray, QCallExceptionStatus* qcallError) { CONTRACTL { QCALL_CHECK; @@ -203,7 +203,7 @@ Done: ; END_QCALL; } -extern "C" void QCALLTYPE Array_Ctor(MethodTable* pArrayMT, UINT32 dwNumArgs, INT32* pArgList, QCall::ObjectHandleOnStack retArray, QCallException* qcallError) +extern "C" void QCALLTYPE Array_Ctor(MethodTable* pArrayMT, UINT32 dwNumArgs, INT32* pArgList, QCall::ObjectHandleOnStack retArray, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/arraynative.h b/src/coreclr/vm/arraynative.h index 5fcf51cb46a0c3..3bb51b91d67063 100644 --- a/src/coreclr/vm/arraynative.h +++ b/src/coreclr/vm/arraynative.h @@ -21,8 +21,8 @@ class ArrayNative FCDECL1(static INT32, GetCorElementTypeOfElementType, ArrayBase* arrayUNSAFE); }; -extern "C" PCODE QCALLTYPE Array_GetElementConstructorEntrypoint(QCall::TypeHandle pArrayTypeHnd, QCallException* qcallError); -extern "C" void QCALLTYPE Array_CreateInstance(QCall::TypeHandle pTypeHnd, INT32 rank, INT32* pLengths, INT32* pBounds, BOOL createFromArrayType, QCall::ObjectHandleOnStack retArray, QCallException* qcallError); -extern "C" void QCALLTYPE Array_Ctor(MethodTable* pArrayMT, UINT32 dwNumArgs, INT32* pArgList, QCall::ObjectHandleOnStack retArray, QCallException* qcallError); +extern "C" PCODE QCALLTYPE Array_GetElementConstructorEntrypoint(QCall::TypeHandle pArrayTypeHnd, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE Array_CreateInstance(QCall::TypeHandle pTypeHnd, INT32 rank, INT32* pLengths, INT32* pBounds, BOOL createFromArrayType, QCall::ObjectHandleOnStack retArray, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE Array_Ctor(MethodTable* pArrayMT, UINT32 dwNumArgs, INT32* pArgList, QCall::ObjectHandleOnStack retArray, QCallExceptionStatus* qcallError); #endif // _ARRAYNATIVE_H_ diff --git a/src/coreclr/vm/assemblynative.cpp b/src/coreclr/vm/assemblynative.cpp index f7d0a41e2aae8c..a30f9c2842b3fa 100644 --- a/src/coreclr/vm/assemblynative.cpp +++ b/src/coreclr/vm/assemblynative.cpp @@ -37,7 +37,7 @@ extern "C" void QCALLTYPE AssemblyNative_InternalLoad(NativeAssemblyNameParts* p BOOL fThrowOnFileNotFound, QCall::ObjectHandleOnStack assemblyLoadContext, QCall::ObjectHandleOnStack retAssembly, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -188,7 +188,7 @@ Assembly* AssemblyNative::LoadFromPEImage(AssemblyBinder* pBinder, PEImage *pIma return pCurDomain->LoadAssembly(&spec, pPEAssembly, FILE_LOADED); } -extern "C" void QCALLTYPE AssemblyNative_LoadFromPath(INT_PTR ptrNativeAssemblyBinder, LPCWSTR pwzILPath, QCall::ObjectHandleOnStack retLoadedAssembly, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_LoadFromPath(INT_PTR ptrNativeAssemblyBinder, LPCWSTR pwzILPath, QCall::ObjectHandleOnStack retLoadedAssembly, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -240,7 +240,7 @@ extern "C" void QCALLTYPE AssemblyNative_LoadFromPath(INT_PTR ptrNativeAssemblyB extern "C" void QCALLTYPE AssemblyNative_LoadFromStream(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrAssemblyArray, INT32 cbAssemblyArrayLength, INT_PTR ptrSymbolArray, INT32 cbSymbolArrayLength, QCall::ObjectHandleOnStack retLoadedAssembly, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -304,7 +304,7 @@ extern "C" void QCALLTYPE AssemblyNative_LoadFromStream(INT_PTR ptrNativeAssembl #ifdef TARGET_WINDOWS /*static */ -extern "C" void QCALLTYPE AssemblyNative_LoadFromInMemoryModule(INT_PTR ptrNativeAssemblyBinder, INT_PTR hModule, QCall::ObjectHandleOnStack retLoadedAssembly, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_LoadFromInMemoryModule(INT_PTR ptrNativeAssemblyBinder, INT_PTR hModule, QCall::ObjectHandleOnStack retLoadedAssembly, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -338,7 +338,7 @@ extern "C" void QCALLTYPE AssemblyNative_LoadFromInMemoryModule(INT_PTR ptrNativ } #endif -extern "C" void QCALLTYPE AssemblyNative_GetLocation(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_GetLocation(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -356,7 +356,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetTypeCore(QCall::AssemblyHandle pAsse LPCSTR * rgszNestedTypeNames, int32_t cNestedTypeNamesLength, QCall::ObjectHandleOnStack retType, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { CONTRACTL { @@ -425,7 +425,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetTypeCoreIgnoreCase(QCall::AssemblyHa LPCWSTR* rgwszNestedTypeNames, int32_t cNestedTypeNamesLength, QCall::ObjectHandleOnStack retType, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { CONTRACTL { @@ -500,7 +500,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetTypeCoreIgnoreCase(QCall::AssemblyHa END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetForwardedType(QCall::AssemblyHandle pAssembly, mdToken mdtExternalType, QCall::ObjectHandleOnStack retType, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_GetForwardedType(QCall::AssemblyHandle pAssembly, mdToken mdtExternalType, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -543,7 +543,7 @@ FCIMPL1(FC_BOOL_RET, AssemblyNative::GetIsDynamic, Assembly* pAssembly) } FCIMPLEND -extern "C" void QCALLTYPE AssemblyNative_GetVersion(QCall::AssemblyHandle pAssembly, INT32* pMajorVersion, INT32* pMinorVersion, INT32*pBuildNumber, INT32* pRevisionNumber, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_GetVersion(QCall::AssemblyHandle pAssembly, INT32* pMajorVersion, INT32* pMinorVersion, INT32*pBuildNumber, INT32* pRevisionNumber, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -561,7 +561,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetVersion(QCall::AssemblyHandle pAssem END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetPublicKey(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retPublicKey, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_GetPublicKey(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retPublicKey, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -574,7 +574,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetPublicKey(QCall::AssemblyHandle pAss END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetSimpleName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retSimpleName, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_GetSimpleName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retSimpleName, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -583,7 +583,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetSimpleName(QCall::AssemblyHandle pAs END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetLocale(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_GetLocale(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -598,7 +598,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetLocale(QCall::AssemblyHandle pAssemb END_QCALL; } -extern "C" BOOL QCALLTYPE AssemblyNative_GetCodeBase(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallException* qcallError) +extern "C" BOOL QCALLTYPE AssemblyNative_GetCodeBase(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -618,7 +618,7 @@ extern "C" BOOL QCALLTYPE AssemblyNative_GetCodeBase(QCall::AssemblyHandle pAsse return ret; } -extern "C" INT32 QCALLTYPE AssemblyNative_GetHashAlgorithm(QCall::AssemblyHandle pAssembly, QCallException* qcallError) +extern "C" INT32 QCALLTYPE AssemblyNative_GetHashAlgorithm(QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -629,7 +629,7 @@ extern "C" INT32 QCALLTYPE AssemblyNative_GetHashAlgorithm(QCall::AssemblyHandle return retVal; } -extern "C" INT32 QCALLTYPE AssemblyNative_GetFlags(QCall::AssemblyHandle pAssembly, QCallException* qcallError) +extern "C" INT32 QCALLTYPE AssemblyNative_GetFlags(QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -640,7 +640,7 @@ extern "C" INT32 QCALLTYPE AssemblyNative_GetFlags(QCall::AssemblyHandle pAssemb return retVal; } -extern "C" BYTE * QCALLTYPE AssemblyNative_GetResource(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, DWORD * length, QCallException* qcallError) +extern "C" BYTE * QCALLTYPE AssemblyNative_GetResource(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, DWORD * length, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -670,7 +670,7 @@ extern "C" BYTE * QCALLTYPE AssemblyNative_GetResource(QCall::AssemblyHandle pAs return pbInMemoryResource; } -extern "C" INT32 QCALLTYPE AssemblyNative_GetManifestResourceInfo(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, QCall::ObjectHandleOnStack retAssembly, QCall::StringHandleOnStack retFileName, QCallException* qcallError) +extern "C" INT32 QCALLTYPE AssemblyNative_GetManifestResourceInfo(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, QCall::ObjectHandleOnStack retAssembly, QCall::StringHandleOnStack retFileName, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -712,7 +712,7 @@ extern "C" INT32 QCALLTYPE AssemblyNative_GetManifestResourceInfo(QCall::Assembl return rv; } -extern "C" void QCALLTYPE AssemblyNative_GetModules(QCall::AssemblyHandle pAssembly, BOOL fLoadIfNotFound, BOOL fGetResourceModules, QCall::ObjectHandleOnStack retModules, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_GetModules(QCall::AssemblyHandle pAssembly, BOOL fLoadIfNotFound, BOOL fGetResourceModules, QCall::ObjectHandleOnStack retModules, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -783,7 +783,7 @@ extern "C" uint32_t QCALLTYPE AssemblyNative_GetAssemblyCount() return g_cAssemblies; } -extern "C" void QCALLTYPE AssemblyNative_GetModule(QCall::AssemblyHandle pAssembly, LPCWSTR wszFileName, QCall::ObjectHandleOnStack retModule, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_GetModule(QCall::AssemblyHandle pAssembly, LPCWSTR wszFileName, QCall::ObjectHandleOnStack retModule, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -820,7 +820,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetModule(QCall::AssemblyHandle pAssemb END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -937,7 +937,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetForwardedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_GetForwardedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1005,7 +1005,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetForwardedTypes(QCall::AssemblyHandle END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetManifestResourceNames(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retResourceNames, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_GetManifestResourceNames(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retResourceNames, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1047,7 +1047,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetManifestResourceNames(QCall::Assembl END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetReferencedAssemblies(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retReferencedAssemblies, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_GetReferencedAssemblies(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retReferencedAssemblies, QCallExceptionStatus* qcallError) { BEGIN_QCALL; @@ -1093,7 +1093,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetReferencedAssemblies(QCall::Assembly END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetEntryPoint(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retMethod, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_GetEntryPoint(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retMethod, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1117,7 +1117,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetEntryPoint(QCall::AssemblyHandle pAs // // -extern "C" void QCALLTYPE AssemblyNative_GetFullName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_GetFullName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1130,7 +1130,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetFullName(QCall::AssemblyHandle pAsse END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetExecutingAssembly(QCall::StackCrawlMarkHandle stackMark, QCall::ObjectHandleOnStack retAssembly, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_GetExecutingAssembly(QCall::StackCrawlMarkHandle stackMark, QCall::ObjectHandleOnStack retAssembly, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1146,7 +1146,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetExecutingAssembly(QCall::StackCrawlM END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetEntryAssembly(QCall::ObjectHandleOnStack retAssembly, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_GetEntryAssembly(QCall::ObjectHandleOnStack retAssembly, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1162,7 +1162,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetEntryAssembly(QCall::ObjectHandleOnS END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetImageRuntimeVersion(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_GetImageRuntimeVersion(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1185,7 +1185,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetImageRuntimeVersion(QCall::AssemblyH /*static*/ -extern "C" INT_PTR QCALLTYPE AssemblyNative_InitializeAssemblyLoadContext(INT_PTR ptrAssemblyLoadContext, BOOL fRepresentsTPALoadContext, BOOL fIsCollectible, QCallException* qcallError) +extern "C" INT_PTR QCALLTYPE AssemblyNative_InitializeAssemblyLoadContext(INT_PTR ptrAssemblyLoadContext, BOOL fRepresentsTPALoadContext, BOOL fIsCollectible, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1257,7 +1257,7 @@ extern "C" INT_PTR QCALLTYPE AssemblyNative_InitializeAssemblyLoadContext(INT_PT } /*static*/ -extern "C" void QCALLTYPE AssemblyNative_PrepareForAssemblyLoadContextRelease(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrManagedStrongAssemblyLoadContext, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_PrepareForAssemblyLoadContextRelease(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrManagedStrongAssemblyLoadContext, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1275,7 +1275,7 @@ extern "C" void QCALLTYPE AssemblyNative_PrepareForAssemblyLoadContextRelease(IN } /*static*/ -extern "C" INT_PTR QCALLTYPE AssemblyNative_GetLoadContextForAssembly(QCall::AssemblyHandle pAssembly, QCallException* qcallError) +extern "C" INT_PTR QCALLTYPE AssemblyNative_GetLoadContextForAssembly(QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1304,7 +1304,7 @@ extern "C" BOOL QCALLTYPE AssemblyNative_InternalTryGetRawMetadata( QCall::AssemblyHandle assembly, UINT8 **blobRef, INT32 *lengthRef, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1336,7 +1336,7 @@ FCIMPL0(FC_BOOL_RET, AssemblyNative::IsTracingEnabled) FCIMPLEND // static -extern "C" void QCALLTYPE AssemblyNative_TraceResolvingHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR alcName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_TraceResolvingHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR alcName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1348,7 +1348,7 @@ extern "C" void QCALLTYPE AssemblyNative_TraceResolvingHandlerInvoked(LPCWSTR as } // static -extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyResolveHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyResolveHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1360,7 +1360,7 @@ extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyResolveHandlerInvoked(LPCW } // static -extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyLoadFromResolveHandlerInvoked(LPCWSTR assemblyName, bool isTrackedAssembly, LPCWSTR requestingAssemblyPath, LPCWSTR requestedAssemblyPath, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyLoadFromResolveHandlerInvoked(LPCWSTR assemblyName, bool isTrackedAssembly, LPCWSTR requestingAssemblyPath, LPCWSTR requestedAssemblyPath, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1372,7 +1372,7 @@ extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyLoadFromResolveHandlerInvo } // static -extern "C" void QCALLTYPE AssemblyNative_TraceSatelliteSubdirectoryPathProbed(LPCWSTR filePath, HRESULT hr, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyNative_TraceSatelliteSubdirectoryPathProbed(LPCWSTR filePath, HRESULT hr, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1392,7 +1392,7 @@ extern "C" void QCALLTYPE AssemblyNative_ApplyUpdate( INT32 ilDeltaLength, UINT8* pdbDelta, INT32 pdbDeltaLength, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1430,7 +1430,7 @@ extern "C" void QCALLTYPE AssemblyNative_ApplyUpdate( } // static -extern "C" BOOL QCALLTYPE AssemblyNative_IsApplyUpdateSupported(QCallException* qcallError) +extern "C" BOOL QCALLTYPE AssemblyNative_IsApplyUpdateSupported(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1711,7 +1711,7 @@ extern "C" void QCALLTYPE TypeMapLazyDictionary_ProcessAttributes( BOOL (*newPrecachedExternalTypeMap)(CallbackContext* context), BOOL (*newPrecachedProxyTypeMap)(CallbackContext* context), CallbackContext* context, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(pAssembly != NULL); @@ -1839,7 +1839,7 @@ extern "C" TADDR QCALLTYPE TypeMapLazyDictionary_FindPrecachedExternalTypeMapEnt QCall::ModuleHandle pModule, QCall::TypeHandle pGroupType, LPCUTF8 key, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(pModule != NULL); @@ -1873,7 +1873,7 @@ extern "C" TADDR QCALLTYPE TypeMapLazyDictionary_FindPrecachedProxyTypeMapEntry( QCall::ModuleHandle pModule, QCall::TypeHandle pGroupType, QCall::TypeHandle pType, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(pModule != NULL); diff --git a/src/coreclr/vm/assemblynative.hpp b/src/coreclr/vm/assemblynative.hpp index 3228204aa974ef..8aabb16ea12de5 100644 --- a/src/coreclr/vm/assemblynative.hpp +++ b/src/coreclr/vm/assemblynative.hpp @@ -37,111 +37,111 @@ class AssemblyNative extern "C" uint32_t QCALLTYPE AssemblyNative_GetAssemblyCount(); -extern "C" void QCALLTYPE AssemblyNative_GetEntryAssembly(QCall::ObjectHandleOnStack retAssembly, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_GetEntryAssembly(QCall::ObjectHandleOnStack retAssembly, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetExecutingAssembly(QCall::StackCrawlMarkHandle stackMark, QCall::ObjectHandleOnStack retAssembly, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_GetExecutingAssembly(QCall::StackCrawlMarkHandle stackMark, QCall::ObjectHandleOnStack retAssembly, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetLocale(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_GetLocale(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); -extern "C" INT32 QCALLTYPE AssemblyNative_GetHashAlgorithm(QCall::AssemblyHandle pAssembly, QCallException* qcallError); +extern "C" INT32 QCALLTYPE AssemblyNative_GetHashAlgorithm(QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetSimpleName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retSimpleName, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_GetSimpleName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retSimpleName, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetPublicKey(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retPublicKey, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_GetPublicKey(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retPublicKey, QCallExceptionStatus* qcallError); -extern "C" INT32 QCALLTYPE AssemblyNative_GetFlags(QCall::AssemblyHandle pAssembly, QCallException* qcallError); +extern "C" INT32 QCALLTYPE AssemblyNative_GetFlags(QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetFullName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_GetFullName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetLocation(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_GetLocation(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); -extern "C" BOOL QCALLTYPE AssemblyNative_GetCodeBase(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallException* qcallError); +extern "C" BOOL QCALLTYPE AssemblyNative_GetCodeBase(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); -extern "C" BYTE * QCALLTYPE AssemblyNative_GetResource(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, DWORD * length, QCallException* qcallError); +extern "C" BYTE * QCALLTYPE AssemblyNative_GetResource(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, DWORD * length, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetVersion(QCall::AssemblyHandle pAssembly, INT32* pMajorVersion, INT32* pMinorVersion, INT32*pBuildNumber, INT32* pRevisionNumber, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_GetVersion(QCall::AssemblyHandle pAssembly, INT32* pMajorVersion, INT32* pMinorVersion, INT32*pBuildNumber, INT32* pRevisionNumber, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetTypeCore(QCall::AssemblyHandle pAssembly, LPCSTR szTypeName, LPCSTR* rgszNestedTypeNames, int32_t cNestedTypeNamesLength, QCall::ObjectHandleOnStack retType, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_GetTypeCore(QCall::AssemblyHandle pAssembly, LPCSTR szTypeName, LPCSTR* rgszNestedTypeNames, int32_t cNestedTypeNamesLength, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetTypeCoreIgnoreCase(QCall::AssemblyHandle pAssembly, LPCWSTR wszTypeName, LPCWSTR* rgwszNestedTypeNames, int32_t cNestedTypeNamesLength, QCall::ObjectHandleOnStack retType, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_GetTypeCoreIgnoreCase(QCall::AssemblyHandle pAssembly, LPCWSTR wszTypeName, LPCWSTR* rgwszNestedTypeNames, int32_t cNestedTypeNamesLength, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetForwardedType(QCall::AssemblyHandle pAssembly, mdToken mdtExternalType, QCall::ObjectHandleOnStack retType, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_GetForwardedType(QCall::AssemblyHandle pAssembly, mdToken mdtExternalType, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); -extern "C" INT32 QCALLTYPE AssemblyNative_GetManifestResourceInfo(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, QCall::ObjectHandleOnStack retAssembly, QCall::StringHandleOnStack retFileName, QCallException* qcallError); +extern "C" INT32 QCALLTYPE AssemblyNative_GetManifestResourceInfo(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, QCall::ObjectHandleOnStack retAssembly, QCall::StringHandleOnStack retFileName, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetModules(QCall::AssemblyHandle pAssembly, BOOL fLoadIfNotFound, BOOL fGetResourceModules, QCall::ObjectHandleOnStack retModules, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_GetModules(QCall::AssemblyHandle pAssembly, BOOL fLoadIfNotFound, BOOL fGetResourceModules, QCall::ObjectHandleOnStack retModules, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetModule(QCall::AssemblyHandle pAssembly, LPCWSTR wszFileName, QCall::ObjectHandleOnStack retModule, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_GetModule(QCall::AssemblyHandle pAssembly, LPCWSTR wszFileName, QCall::ObjectHandleOnStack retModule, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetForwardedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_GetForwardedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetManifestResourceNames(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retResourceNames, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_GetManifestResourceNames(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retResourceNames, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetReferencedAssemblies(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retReferencedAssemblies, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_GetReferencedAssemblies(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retReferencedAssemblies, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetEntryPoint(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retMethod, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_GetEntryPoint(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retMethod, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_GetImageRuntimeVersion(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_GetImageRuntimeVersion(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); -extern "C" INT_PTR QCALLTYPE AssemblyNative_InitializeAssemblyLoadContext(INT_PTR ptrAssemblyLoadContext, BOOL fRepresentsTPALoadContext, BOOL fIsCollectible, QCallException* qcallError); +extern "C" INT_PTR QCALLTYPE AssemblyNative_InitializeAssemblyLoadContext(INT_PTR ptrAssemblyLoadContext, BOOL fRepresentsTPALoadContext, BOOL fIsCollectible, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_PrepareForAssemblyLoadContextRelease(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrManagedStrongAssemblyLoadContext, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_PrepareForAssemblyLoadContextRelease(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrManagedStrongAssemblyLoadContext, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_InternalLoad(NativeAssemblyNameParts* pAssemblyName, QCall::ObjectHandleOnStack requestingAssembly, QCall::StackCrawlMarkHandle stackMark,BOOL fThrowOnFileNotFound, QCall::ObjectHandleOnStack assemblyLoadContext, QCall::ObjectHandleOnStack retAssembly, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_InternalLoad(NativeAssemblyNameParts* pAssemblyName, QCall::ObjectHandleOnStack requestingAssembly, QCall::StackCrawlMarkHandle stackMark,BOOL fThrowOnFileNotFound, QCall::ObjectHandleOnStack assemblyLoadContext, QCall::ObjectHandleOnStack retAssembly, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_LoadFromPath(INT_PTR ptrNativeAssemblyBinder, LPCWSTR pwzILPath, QCall::ObjectHandleOnStack retLoadedAssembly, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_LoadFromPath(INT_PTR ptrNativeAssemblyBinder, LPCWSTR pwzILPath, QCall::ObjectHandleOnStack retLoadedAssembly, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_LoadFromStream(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrAssemblyArray, INT32 cbAssemblyArrayLength, INT_PTR ptrSymbolArray, INT32 cbSymbolArrayLength, QCall::ObjectHandleOnStack retLoadedAssembly, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_LoadFromStream(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrAssemblyArray, INT32 cbAssemblyArrayLength, INT_PTR ptrSymbolArray, INT32 cbSymbolArrayLength, QCall::ObjectHandleOnStack retLoadedAssembly, QCallExceptionStatus* qcallError); #ifdef TARGET_WINDOWS -extern "C" void QCALLTYPE AssemblyNative_LoadFromInMemoryModule(INT_PTR ptrNativeAssemblyBinder, INT_PTR hModule, QCall::ObjectHandleOnStack retLoadedAssembly, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_LoadFromInMemoryModule(INT_PTR ptrNativeAssemblyBinder, INT_PTR hModule, QCall::ObjectHandleOnStack retLoadedAssembly, QCallExceptionStatus* qcallError); #endif -extern "C" INT_PTR QCALLTYPE AssemblyNative_GetLoadContextForAssembly(QCall::AssemblyHandle pAssembly, QCallException* qcallError); +extern "C" INT_PTR QCALLTYPE AssemblyNative_GetLoadContextForAssembly(QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError); -extern "C" BOOL QCALLTYPE AssemblyNative_InternalTryGetRawMetadata(QCall::AssemblyHandle assembly, UINT8 **blobRef, INT32 *lengthRef, QCallException* qcallError); +extern "C" BOOL QCALLTYPE AssemblyNative_InternalTryGetRawMetadata(QCall::AssemblyHandle assembly, UINT8 **blobRef, INT32 *lengthRef, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_TraceResolvingHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR alcName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_TraceResolvingHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR alcName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyResolveHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyResolveHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyLoadFromResolveHandlerInvoked(LPCWSTR assemblyName, bool isTrackedAssembly, LPCWSTR requestingAssemblyPath, LPCWSTR requestedAssemblyPath, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyLoadFromResolveHandlerInvoked(LPCWSTR assemblyName, bool isTrackedAssembly, LPCWSTR requestingAssemblyPath, LPCWSTR requestedAssemblyPath, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_TraceSatelliteSubdirectoryPathProbed(LPCWSTR filePath, HRESULT hr, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_TraceSatelliteSubdirectoryPathProbed(LPCWSTR filePath, HRESULT hr, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyNative_ApplyUpdate(QCall::AssemblyHandle assembly, UINT8* metadataDelta, INT32 metadataDeltaLength, UINT8* ilDelta, INT32 ilDeltaLength, UINT8* pdbDelta, INT32 pdbDeltaLength, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyNative_ApplyUpdate(QCall::AssemblyHandle assembly, UINT8* metadataDelta, INT32 metadataDeltaLength, UINT8* ilDelta, INT32 ilDeltaLength, UINT8* pdbDelta, INT32 pdbDeltaLength, QCallExceptionStatus* qcallError); -extern "C" BOOL QCALLTYPE AssemblyNative_IsApplyUpdateSupported(QCallException* qcallError); +extern "C" BOOL QCALLTYPE AssemblyNative_IsApplyUpdateSupported(QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AssemblyName_InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, BaseAssemblySpec* pAssemblySpec); +extern "C" void QCALLTYPE AssemblyName_InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, BaseAssemblySpec* pAssemblySpec, QCallExceptionStatus* qcallError); // See TypeMapLazyDictionary.cs for managed version. struct CallbackContext final @@ -169,18 +169,18 @@ extern "C" void QCALLTYPE TypeMapLazyDictionary_ProcessAttributes( BOOL (*newProxyTypeEntry)(CallbackContext* context, ProcessAttributesCallbackArg* arg), BOOL (*newPrecachedExternalTypeMap)(CallbackContext* context), BOOL (*newPrecachedProxyTypeMap)(CallbackContext* context), - CallbackContext* context, QCallException* qcallError); + CallbackContext* context, QCallExceptionStatus* qcallError); extern "C" TADDR QCALLTYPE TypeMapLazyDictionary_FindPrecachedExternalTypeMapEntry( QCall::ModuleHandle pModule, QCall::TypeHandle pGroupType, LPCUTF8 key -, QCallException* qcallError); +, QCallExceptionStatus* qcallError); extern "C" TADDR QCALLTYPE TypeMapLazyDictionary_FindPrecachedProxyTypeMapEntry( QCall::ModuleHandle pModule, QCall::TypeHandle pGroupType, QCall::TypeHandle pType -, QCallException* qcallError); +, QCallExceptionStatus* qcallError); #endif diff --git a/src/coreclr/vm/clrconfignative.cpp b/src/coreclr/vm/clrconfignative.cpp index a4abed392bd397..7bef596edb0380 100644 --- a/src/coreclr/vm/clrconfignative.cpp +++ b/src/coreclr/vm/clrconfignative.cpp @@ -8,7 +8,7 @@ #include "clrconfignative.h" #include -extern "C" BOOL QCALLTYPE ClrConfig_GetConfigBoolValue(LPCWSTR name, BOOL *exist, QCallException* qcallError) +extern "C" BOOL QCALLTYPE ClrConfig_GetConfigBoolValue(LPCWSTR name, BOOL *exist, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/clrconfignative.h b/src/coreclr/vm/clrconfignative.h index 655a1ceb012e55..d363a2745e9e3c 100644 --- a/src/coreclr/vm/clrconfignative.h +++ b/src/coreclr/vm/clrconfignative.h @@ -4,5 +4,5 @@ #ifndef _CLRCONFIGNATIVE_H_ #define _CLRCONFIGNATIVE_H_ -extern "C" BOOL QCALLTYPE ClrConfig_GetConfigBoolValue(LPCWSTR name, BOOL *exist, QCallException* qcallError); +extern "C" BOOL QCALLTYPE ClrConfig_GetConfigBoolValue(LPCWSTR name, BOOL *exist, QCallExceptionStatus* qcallError); #endif // _CLRCONFIGNATIVE_H_ diff --git a/src/coreclr/vm/comdelegate.cpp b/src/coreclr/vm/comdelegate.cpp index dbc955dd51ad32..077a892f0051d2 100644 --- a/src/coreclr/vm/comdelegate.cpp +++ b/src/coreclr/vm/comdelegate.cpp @@ -974,7 +974,7 @@ static PCODE GetVirtualCallStub(MethodDesc *method, TypeHandle scopeType) extern "C" BOOL QCALLTYPE Delegate_BindToMethodName(MethodTable* pDelegateMT, MethodTable *pTargetMT, QCall::TypeHandle pMethodType, LPCUTF8 pszMethodName, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1080,7 +1080,7 @@ extern "C" BOOL QCALLTYPE Delegate_BindToMethodName(MethodTable* pDelegateMT, Me extern "C" BOOL QCALLTYPE Delegate_BindToMethodInfo(MethodTable* pDelegateMT, MethodTable *pTargetMT, MethodDesc * method, QCall::TypeHandle pMethodType, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1530,7 +1530,7 @@ MethodDesc* COMDelegate::GetILStubMethodDesc(EEImplMethodDesc* pDelegateMD, DWOR return PInvoke::CreateCLRToNativeILStub(&sigInfo, dwStubFlags, pDelegateMD); } -extern "C" void QCALLTYPE Delegate_InitializeVirtualCallStub(QCall::ObjectHandleOnStack d, PCODE method, QCallException* qcallError) +extern "C" void QCALLTYPE Delegate_InitializeVirtualCallStub(QCall::ObjectHandleOnStack d, PCODE method, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1550,7 +1550,7 @@ extern "C" void QCALLTYPE Delegate_InitializeVirtualCallStub(QCall::ObjectHandle END_QCALL; } -extern "C" PCODE QCALLTYPE Delegate_AdjustTarget(MethodTable* pMTTarg, PCODE method, QCallException* qcallError) +extern "C" PCODE QCALLTYPE Delegate_AdjustTarget(MethodTable* pMTTarg, PCODE method, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1608,7 +1608,7 @@ uint32_t MethodDescToNumFixedArgs(MethodDesc *pMD) // This is the single constructor for all Delegates. The compiler // doesn't provide an implementation of the Delegate constructor. We // provide that implementation through a QCall call to this method. -extern "C" void QCALLTYPE Delegate_Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, PCODE method, BindToMethodDetails *pBindToMethodDetails, QCallException* qcallError) +extern "C" void QCALLTYPE Delegate_Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, PCODE method, BindToMethodDetails *pBindToMethodDetails, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1911,7 +1911,7 @@ void COMDelegate::ThrowIfInvalidUnmanagedCallersOnlyUsage(MethodDesc* pMD) } // This method will get the MethodInfo for a delegate -extern "C" void QCALLTYPE Delegate_CreateMethodInfo(MethodDesc* methodDesc, QCall::ObjectHandleOnStack retMethodInfo, QCallException* qcallError) +extern "C" void QCALLTYPE Delegate_CreateMethodInfo(MethodDesc* methodDesc, QCall::ObjectHandleOnStack retMethodInfo, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1926,7 +1926,7 @@ extern "C" void QCALLTYPE Delegate_CreateMethodInfo(MethodDesc* methodDesc, QCal END_QCALL; } -extern "C" MethodDesc* QCALLTYPE Delegate_GetMethodDesc(QCall::ObjectHandleOnStack instance, QCallException* qcallError) +extern "C" MethodDesc* QCALLTYPE Delegate_GetMethodDesc(QCall::ObjectHandleOnStack instance, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1964,7 +1964,7 @@ FCIMPL1(PCODE, COMDelegate::GetMulticastInvoke, MethodTable* pDelegateMT) } FCIMPLEND -extern "C" PCODE QCALLTYPE Delegate_GetMulticastInvokeSlow(MethodTable* pDelegateMT, QCallException* qcallError) +extern "C" PCODE QCALLTYPE Delegate_GetMulticastInvokeSlow(MethodTable* pDelegateMT, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(pDelegateMT != NULL); diff --git a/src/coreclr/vm/comdelegate.h b/src/coreclr/vm/comdelegate.h index dcb6d8e4439458..1f35fc0ade8ff6 100644 --- a/src/coreclr/vm/comdelegate.h +++ b/src/coreclr/vm/comdelegate.h @@ -96,13 +96,13 @@ class COMDelegate BindToMethodDetails *pBindToMethodDetails); }; -extern "C" void QCALLTYPE Delegate_Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, PCODE method, BindToMethodDetails *pBindToMethodDetails, QCallException* qcallError); +extern "C" void QCALLTYPE Delegate_Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, PCODE method, BindToMethodDetails *pBindToMethodDetails, QCallExceptionStatus* qcallError); -extern "C" PCODE QCALLTYPE Delegate_GetMulticastInvokeSlow(MethodTable* pDelegateMT, QCallException* qcallError); +extern "C" PCODE QCALLTYPE Delegate_GetMulticastInvokeSlow(MethodTable* pDelegateMT, QCallExceptionStatus* qcallError); -extern "C" PCODE QCALLTYPE Delegate_AdjustTarget(MethodTable* pMTTarg, PCODE method, QCallException* qcallError); +extern "C" PCODE QCALLTYPE Delegate_AdjustTarget(MethodTable* pMTTarg, PCODE method, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE Delegate_InitializeVirtualCallStub(QCall::ObjectHandleOnStack d, PCODE method, QCallException* qcallError); +extern "C" void QCALLTYPE Delegate_InitializeVirtualCallStub(QCall::ObjectHandleOnStack d, PCODE method, QCallExceptionStatus* qcallError); // These flags effect the way BindToMethodInfo and BindToMethodName are allowed to bind a delegate to a target method. Their // values must be kept in sync with the definition in bcl\system\delegate.cs. @@ -119,15 +119,15 @@ enum DelegateBindingFlags extern "C" BOOL QCALLTYPE Delegate_BindToMethodName(MethodTable* pDelegateMT, MethodTable *pTargetMT, QCall::TypeHandle pMethodType, LPCUTF8 pszMethodName, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, - QCallException* qcallError); + QCallExceptionStatus* qcallError); extern "C" BOOL QCALLTYPE Delegate_BindToMethodInfo(MethodTable* pDelegateMT, MethodTable *pTargetMT, MethodDesc * method, QCall::TypeHandle pMethodType, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, - QCallException* qcallError); + QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE Delegate_CreateMethodInfo(MethodDesc* methodDesc, QCall::ObjectHandleOnStack retMethodInfo, QCallException* qcallError); +extern "C" void QCALLTYPE Delegate_CreateMethodInfo(MethodDesc* methodDesc, QCall::ObjectHandleOnStack retMethodInfo, QCallExceptionStatus* qcallError); -extern "C" MethodDesc* QCALLTYPE Delegate_GetMethodDesc(QCall::ObjectHandleOnStack instance, QCallException* qcallError); +extern "C" MethodDesc* QCALLTYPE Delegate_GetMethodDesc(QCall::ObjectHandleOnStack instance, QCallExceptionStatus* qcallError); void DistributeEvent(OBJECTREF *pDelegate, OBJECTREF *pDomain); diff --git a/src/coreclr/vm/comdependenthandle.cpp b/src/coreclr/vm/comdependenthandle.cpp index 6d338782b41af4..c2b18b039910b4 100644 --- a/src/coreclr/vm/comdependenthandle.cpp +++ b/src/coreclr/vm/comdependenthandle.cpp @@ -26,7 +26,7 @@ FCIMPL2(OBJECTHANDLE, DependentHandle::InternalAlloc, Object *target, Object *de } FCIMPLEND -extern "C" OBJECTHANDLE QCALLTYPE DependentHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack target, QCall::ObjectHandleOnStack dependent, QCallException* qcallError) +extern "C" OBJECTHANDLE QCALLTYPE DependentHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack target, QCall::ObjectHandleOnStack dependent, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -122,7 +122,7 @@ FCIMPL1(FC_BOOL_RET, DependentHandle::InternalFree, OBJECTHANDLE handle) } FCIMPLEND -extern "C" void QCALLTYPE DependentHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle, QCallException* qcallError) +extern "C" void QCALLTYPE DependentHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/comdependenthandle.h b/src/coreclr/vm/comdependenthandle.h index 9b13b2b0d236e9..ec47f3368d4167 100644 --- a/src/coreclr/vm/comdependenthandle.h +++ b/src/coreclr/vm/comdependenthandle.h @@ -49,7 +49,7 @@ class DependentHandle FCDECL1(static FC_BOOL_RET, InternalFree, OBJECTHANDLE handle); }; -extern "C" OBJECTHANDLE QCALLTYPE DependentHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack target, QCall::ObjectHandleOnStack dependent, QCallException* qcallError); -extern "C" void QCALLTYPE DependentHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle, QCallException* qcallError); +extern "C" OBJECTHANDLE QCALLTYPE DependentHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack target, QCall::ObjectHandleOnStack dependent, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE DependentHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle, QCallExceptionStatus* qcallError); #endif diff --git a/src/coreclr/vm/comdynamic.cpp b/src/coreclr/vm/comdynamic.cpp index 02640a98e44f87..91ed0bba68a556 100644 --- a/src/coreclr/vm/comdynamic.cpp +++ b/src/coreclr/vm/comdynamic.cpp @@ -43,7 +43,7 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineGenericParam(QCall::ModuleHandle pM INT32 attributes, INT32 position, INT32 * pConstraintTokens, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -68,7 +68,7 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineType(QCall::ModuleHandle pModule, INT32 attributes, INT32 tkEnclosingType, INT32 * pInterfaceTokens, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -89,7 +89,7 @@ INT32 COMDynamicWrite::DefineType(Module* pModule, INT32 attributes, INT32 tkEnclosingType, INT32 * pInterfaceTokens, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -144,7 +144,7 @@ INT32 COMDynamicWrite::DefineType(Module* pModule, } // This function will reset the parent class in metadata -extern "C" void QCALLTYPE TypeBuilder_SetParentType(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkParent, QCallException* qcallError) +extern "C" void QCALLTYPE TypeBuilder_SetParentType(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkParent, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -159,7 +159,7 @@ extern "C" void QCALLTYPE TypeBuilder_SetParentType(QCall::ModuleHandle pModule, } // This function will add another interface impl -extern "C" void QCALLTYPE TypeBuilder_AddInterfaceImpl(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkInterface, QCallException* qcallError) +extern "C" void QCALLTYPE TypeBuilder_AddInterfaceImpl(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkInterface, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -174,7 +174,7 @@ extern "C" void QCALLTYPE TypeBuilder_AddInterfaceImpl(QCall::ModuleHandle pModu } // This function will create a method within the class -extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethodSpec(QCall::ModuleHandle pModule, INT32 tkParent, LPCBYTE pSignature, INT32 sigLength, QCallException* qcallError) +extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethodSpec(QCall::ModuleHandle pModule, INT32 tkParent, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -196,7 +196,7 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethodSpec(QCall::ModuleHandle pMod return (INT32) memberE; } -extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethod(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attributes, QCallException* qcallError) +extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethod(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attributes, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -228,7 +228,7 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethod(QCall::ModuleHandle pModule, **Arguments: **Exceptions: ==============================================================================*/ -extern "C" mdFieldDef QCALLTYPE TypeBuilder_DefineField(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attr, QCallException* qcallError) +extern "C" mdFieldDef QCALLTYPE TypeBuilder_DefineField(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attr, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -314,7 +314,7 @@ extern "C" void QCALLTYPE TypeBuilder_SetMethodIL(QCall::ModuleHandle pModule, INT32 numExceptions, INT32 * pTokenFixups, INT32 numTokenFixups, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -473,7 +473,7 @@ extern "C" void QCALLTYPE TypeBuilder_SetMethodIL(QCall::ModuleHandle pModule, END_QCALL; } -extern "C" void QCALLTYPE TypeBuilder_TermCreateClass(QCall::ModuleHandle pModule, INT32 tk, QCall::ObjectHandleOnStack retType, QCallException* qcallError) +extern "C" void QCALLTYPE TypeBuilder_TermCreateClass(QCall::ModuleHandle pModule, INT32 tk, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -515,7 +515,7 @@ void COMDynamicWrite::TermCreateClass(Module* pModule, INT32 tk, QCall::ObjectHa **Arguments: **Exceptions: ==============================================================================*/ -extern "C" void QCALLTYPE TypeBuilder_SetPInvokeData(QCall::ModuleHandle pModule, LPCWSTR wszDllName, LPCWSTR wszFunctionName, INT32 token, INT32 linkFlags, QCallException* qcallError) +extern "C" void QCALLTYPE TypeBuilder_SetPInvokeData(QCall::ModuleHandle pModule, LPCWSTR wszDllName, LPCWSTR wszFunctionName, INT32 token, INT32 linkFlags, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -544,7 +544,7 @@ extern "C" void QCALLTYPE TypeBuilder_SetPInvokeData(QCall::ModuleHandle pModule **Arguments: **Exceptions: ==============================================================================*/ -extern "C" INT32 QCALLTYPE TypeBuilder_DefineProperty(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, LPCBYTE pSignature, INT32 sigLength, QCallException* qcallError) +extern "C" INT32 QCALLTYPE TypeBuilder_DefineProperty(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -581,7 +581,7 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineProperty(QCall::ModuleHandle pModul **Arguments: **Exceptions: ==============================================================================*/ -extern "C" INT32 QCALLTYPE TypeBuilder_DefineEvent(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, INT32 tkEventType, QCallException* qcallError) +extern "C" INT32 QCALLTYPE TypeBuilder_DefineEvent(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, INT32 tkEventType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -611,7 +611,7 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineEvent(QCall::ModuleHandle pModule, **Arguments: **Exceptions: ==============================================================================*/ -extern "C" void QCALLTYPE TypeBuilder_DefineMethodSemantics(QCall::ModuleHandle pModule, INT32 tkAssociation, INT32 attr, INT32 tkMethod, QCallException* qcallError) +extern "C" void QCALLTYPE TypeBuilder_DefineMethodSemantics(QCall::ModuleHandle pModule, INT32 tkAssociation, INT32 attr, INT32 tkMethod, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -632,7 +632,7 @@ extern "C" void QCALLTYPE TypeBuilder_DefineMethodSemantics(QCall::ModuleHandle /*============================SetMethodImpl============================ ** To set a Method's Implementation flags ==============================================================================*/ -extern "C" void QCALLTYPE TypeBuilder_SetMethodImpl(QCall::ModuleHandle pModule, INT32 tkMethod, INT32 attr, QCallException* qcallError) +extern "C" void QCALLTYPE TypeBuilder_SetMethodImpl(QCall::ModuleHandle pModule, INT32 tkMethod, INT32 attr, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -652,7 +652,7 @@ extern "C" void QCALLTYPE TypeBuilder_SetMethodImpl(QCall::ModuleHandle pModule, /*============================DefineMethodImpl============================ ** Define a MethodImpl record ==============================================================================*/ -extern "C" void QCALLTYPE TypeBuilder_DefineMethodImpl(QCall::ModuleHandle pModule, UINT32 tkType, UINT32 tkBody, UINT32 tkDecl, QCallException* qcallError) +extern "C" void QCALLTYPE TypeBuilder_DefineMethodImpl(QCall::ModuleHandle pModule, UINT32 tkType, UINT32 tkBody, UINT32 tkDecl, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -676,7 +676,7 @@ extern "C" void QCALLTYPE TypeBuilder_DefineMethodImpl(QCall::ModuleHandle pModu **Arguments: **Exceptions: ==============================================================================*/ -extern "C" INT32 QCALLTYPE TypeBuilder_GetTokenFromSig(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, QCallException* qcallError) +extern "C" INT32 QCALLTYPE TypeBuilder_GetTokenFromSig(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -706,7 +706,7 @@ extern "C" INT32 QCALLTYPE TypeBuilder_GetTokenFromSig(QCall::ModuleHandle pModu **Arguments: **Exceptions: ==============================================================================*/ -extern "C" INT32 QCALLTYPE TypeBuilder_SetParamInfo(QCall::ModuleHandle pModule, UINT32 tkMethod, UINT32 iSequence, UINT32 iAttributes, LPCWSTR wszParamName, QCallException* qcallError) +extern "C" INT32 QCALLTYPE TypeBuilder_SetParamInfo(QCall::ModuleHandle pModule, UINT32 tkMethod, UINT32 iSequence, UINT32 iAttributes, LPCWSTR wszParamName, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -740,7 +740,7 @@ extern "C" INT32 QCALLTYPE TypeBuilder_SetParamInfo(QCall::ModuleHandle pModule, **Arguments: **Exceptions: ==============================================================================*/ -extern "C" void QCALLTYPE TypeBuilder_SetConstantValue(QCall::ModuleHandle pModule, UINT32 tk, DWORD valueCorType, LPVOID pValue, QCallException* qcallError) +extern "C" void QCALLTYPE TypeBuilder_SetConstantValue(QCall::ModuleHandle pModule, UINT32 tk, DWORD valueCorType, LPVOID pValue, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -796,7 +796,7 @@ extern "C" void QCALLTYPE TypeBuilder_SetConstantValue(QCall::ModuleHandle pModu **Arguments: **Exceptions: ==============================================================================*/ -extern "C" void QCALLTYPE TypeBuilder_SetFieldLayoutOffset(QCall::ModuleHandle pModule, INT32 tkField, INT32 iOffset, QCallException* qcallError) +extern "C" void QCALLTYPE TypeBuilder_SetFieldLayoutOffset(QCall::ModuleHandle pModule, INT32 tkField, INT32 iOffset, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -820,7 +820,7 @@ extern "C" void QCALLTYPE TypeBuilder_SetFieldLayoutOffset(QCall::ModuleHandle p **Arguments: **Exceptions: ==============================================================================*/ -extern "C" void QCALLTYPE TypeBuilder_SetClassLayout(QCall::ModuleHandle pModule, INT32 tk, INT32 iPackSize, UINT32 iTotalSize, QCallException* qcallError) +extern "C" void QCALLTYPE TypeBuilder_SetClassLayout(QCall::ModuleHandle pModule, INT32 tk, INT32 iPackSize, UINT32 iTotalSize, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -915,7 +915,7 @@ void UpdateRuntimeStateForAssemblyCustomAttribute(Module* pModule, mdToken tkCus } } -extern "C" void QCALLTYPE TypeBuilder_DefineCustomAttribute(QCall::ModuleHandle pModule, INT32 token, INT32 conTok, LPCBYTE pBlob, INT32 cbBlob, QCallException* qcallError) +extern "C" void QCALLTYPE TypeBuilder_DefineCustomAttribute(QCall::ModuleHandle pModule, INT32 token, INT32 conTok, LPCBYTE pBlob, INT32 cbBlob, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/comdynamic.h b/src/coreclr/vm/comdynamic.h index 8056a4b20b4af4..db257034698556 100644 --- a/src/coreclr/vm/comdynamic.h +++ b/src/coreclr/vm/comdynamic.h @@ -32,7 +32,7 @@ class COMDynamicWrite INT32 attributes, INT32 tkEnclosingType, INT32 * pInterfaceTokens, - QCallException* qcallError); + QCallExceptionStatus* qcallError); static void TermCreateClass(Module* pModule, INT32 tk, QCall::ObjectHandleOnStack retType); }; @@ -45,7 +45,7 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineType(QCall::ModuleHandle pModule, INT32 attributes, INT32 tkEnclosingType, INT32 * pInterfaceTokens, - QCallException* qcallError); + QCallExceptionStatus* qcallError); extern "C" INT32 QCALLTYPE TypeBuilder_DefineGenericParam(QCall::ModuleHandle pModule, @@ -54,22 +54,22 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineGenericParam(QCall::ModuleHandle pM INT32 attributes, INT32 position, INT32 * pConstraintTokens, - QCallException* qcallError); + QCallExceptionStatus* qcallError); // This function will reset the parent class in metadata -extern "C" void QCALLTYPE TypeBuilder_SetParentType(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkParent, QCallException* qcallError); +extern "C" void QCALLTYPE TypeBuilder_SetParentType(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkParent, QCallExceptionStatus* qcallError); // This function will add another interface impl -extern "C" void QCALLTYPE TypeBuilder_AddInterfaceImpl(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkInterface, QCallException* qcallError); +extern "C" void QCALLTYPE TypeBuilder_AddInterfaceImpl(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkInterface, QCallExceptionStatus* qcallError); // This function will create a method within the class -extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethod(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attributes, QCallException* qcallError); +extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethod(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attributes, QCallExceptionStatus* qcallError); -extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethodSpec(QCall::ModuleHandle pModule, INT32 tkParent, LPCBYTE pSignature, INT32 sigLength, QCallException* qcallError); +extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethodSpec(QCall::ModuleHandle pModule, INT32 tkParent, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError); // This function will create a method within the class @@ -85,57 +85,57 @@ extern "C" void QCALLTYPE TypeBuilder_SetMethodIL(QCall::ModuleHandle pModule, INT32 numExceptions, INT32 * pTokenFixups, INT32 numTokenFixups, - QCallException* qcallError); + QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE TypeBuilder_TermCreateClass(QCall::ModuleHandle pModule, INT32 tk, QCall::ObjectHandleOnStack retType, QCallException* qcallError); +extern "C" void QCALLTYPE TypeBuilder_TermCreateClass(QCall::ModuleHandle pModule, INT32 tk, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); -extern "C" mdFieldDef QCALLTYPE TypeBuilder_DefineField(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attr, QCallException* qcallError); +extern "C" mdFieldDef QCALLTYPE TypeBuilder_DefineField(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attr, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE TypeBuilder_SetPInvokeData(QCall::ModuleHandle pModule, LPCWSTR wszDllName, LPCWSTR wszFunctionName, INT32 token, INT32 linkFlags, QCallException* qcallError); +extern "C" void QCALLTYPE TypeBuilder_SetPInvokeData(QCall::ModuleHandle pModule, LPCWSTR wszDllName, LPCWSTR wszFunctionName, INT32 token, INT32 linkFlags, QCallExceptionStatus* qcallError); -extern "C" INT32 QCALLTYPE TypeBuilder_DefineProperty(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, LPCBYTE pSignature, INT32 sigLength, QCallException* qcallError); +extern "C" INT32 QCALLTYPE TypeBuilder_DefineProperty(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError); -extern "C" INT32 QCALLTYPE TypeBuilder_DefineEvent(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, INT32 tkEventType, QCallException* qcallError); +extern "C" INT32 QCALLTYPE TypeBuilder_DefineEvent(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, INT32 tkEventType, QCallExceptionStatus* qcallError); // functions to set Setter, Getter, Reset, TestDefault, and other methods -extern "C" void QCALLTYPE TypeBuilder_DefineMethodSemantics(QCall::ModuleHandle pModule, INT32 tkAssociation, INT32 attr, INT32 tkMethod, QCallException* qcallError); +extern "C" void QCALLTYPE TypeBuilder_DefineMethodSemantics(QCall::ModuleHandle pModule, INT32 tkAssociation, INT32 attr, INT32 tkMethod, QCallExceptionStatus* qcallError); // functions to set method's implementation flag -extern "C" void QCALLTYPE TypeBuilder_SetMethodImpl(QCall::ModuleHandle pModule, INT32 tkMethod, INT32 attr, QCallException* qcallError); +extern "C" void QCALLTYPE TypeBuilder_SetMethodImpl(QCall::ModuleHandle pModule, INT32 tkMethod, INT32 attr, QCallExceptionStatus* qcallError); // functions to create MethodImpl record -extern "C" void QCALLTYPE TypeBuilder_DefineMethodImpl(QCall::ModuleHandle pModule, UINT32 tkType, UINT32 tkBody, UINT32 tkDecl, QCallException* qcallError); +extern "C" void QCALLTYPE TypeBuilder_DefineMethodImpl(QCall::ModuleHandle pModule, UINT32 tkType, UINT32 tkBody, UINT32 tkDecl, QCallExceptionStatus* qcallError); // GetTokenFromSig's argument -extern "C" INT32 QCALLTYPE TypeBuilder_GetTokenFromSig(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, QCallException* qcallError); +extern "C" INT32 QCALLTYPE TypeBuilder_GetTokenFromSig(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError); // Set Field offset -extern "C" void QCALLTYPE TypeBuilder_SetFieldLayoutOffset(QCall::ModuleHandle pModule, INT32 tkField, INT32 iOffset, QCallException* qcallError); +extern "C" void QCALLTYPE TypeBuilder_SetFieldLayoutOffset(QCall::ModuleHandle pModule, INT32 tkField, INT32 iOffset, QCallExceptionStatus* qcallError); // Set classlayout info -extern "C" void QCALLTYPE TypeBuilder_SetClassLayout(QCall::ModuleHandle pModule, INT32 tk, INT32 iPackSize, UINT32 iTotalSize, QCallException* qcallError); +extern "C" void QCALLTYPE TypeBuilder_SetClassLayout(QCall::ModuleHandle pModule, INT32 tk, INT32 iPackSize, UINT32 iTotalSize, QCallExceptionStatus* qcallError); // Set a custom attribute -extern "C" void QCALLTYPE TypeBuilder_DefineCustomAttribute(QCall::ModuleHandle pModule, INT32 token, INT32 conTok, LPCBYTE pBlob, INT32 cbBlob, QCallException* qcallError); +extern "C" void QCALLTYPE TypeBuilder_DefineCustomAttribute(QCall::ModuleHandle pModule, INT32 token, INT32 conTok, LPCBYTE pBlob, INT32 cbBlob, QCallExceptionStatus* qcallError); // functions to set ParamInfo -extern "C" INT32 QCALLTYPE TypeBuilder_SetParamInfo(QCall::ModuleHandle pModule, UINT32 tkMethod, UINT32 iSequence, UINT32 iAttributes, LPCWSTR wszParamName, QCallException* qcallError); +extern "C" INT32 QCALLTYPE TypeBuilder_SetParamInfo(QCall::ModuleHandle pModule, UINT32 tkMethod, UINT32 iSequence, UINT32 iAttributes, LPCWSTR wszParamName, QCallExceptionStatus* qcallError); // functions to set default value -extern "C" void QCALLTYPE TypeBuilder_SetConstantValue(QCall::ModuleHandle pModule, UINT32 tk, DWORD valueType, LPVOID pValue, QCallException* qcallError); +extern "C" void QCALLTYPE TypeBuilder_SetConstantValue(QCall::ModuleHandle pModule, UINT32 tk, DWORD valueType, LPVOID pValue, QCallExceptionStatus* qcallError); #endif // _COMDYNAMIC_H_ diff --git a/src/coreclr/vm/commodule.cpp b/src/coreclr/vm/commodule.cpp index 63df7f97f3f65d..61b48f17a6de50 100644 --- a/src/coreclr/vm/commodule.cpp +++ b/src/coreclr/vm/commodule.cpp @@ -25,7 +25,7 @@ extern "C" mdTypeRef QCALLTYPE ModuleBuilder_GetTypeRef(QCall::ModuleHandle pMod LPCWSTR wszFullName, QCall::ModuleHandle pRefedModule, INT32 tkResolutionArg, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -130,7 +130,7 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetArrayMethodToken(QCall::ModuleHandle LPCWSTR wszMethodName, LPCBYTE pSignature, INT32 sigLength, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -205,7 +205,7 @@ namespace // This function will return a MemberRef token given a MethodDef token and the module where the MethodDef/FieldDef is defined. // //****************************************************************************** -extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRef(QCall::ModuleHandle pModule, QCall::ModuleHandle pRefedModule, INT32 tr, INT32 token, QCallException* qcallError) +extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRef(QCall::ModuleHandle pModule, QCall::ModuleHandle pRefedModule, INT32 tr, INT32 token, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -286,7 +286,7 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRef(QCall::ModuleHandle pModul // Return a MemberRef token given a RuntimeMethodInfo // //****************************************************************************** -extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo(QCall::ModuleHandle pModule, INT32 tr, MethodDesc * pMeth, QCallException* qcallError) +extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo(QCall::ModuleHandle pModule, INT32 tr, MethodDesc * pMeth, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -365,7 +365,7 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo(QCall::ModuleH // Return a MemberRef token given a RuntimeFieldInfo // //****************************************************************************** -extern "C" mdMemberRef QCALLTYPE ModuleBuilder_GetMemberRefOfFieldInfo(QCall::ModuleHandle pModule, mdTypeDef tr, QCall::TypeHandle th, mdFieldDef tkField, QCallException* qcallError) +extern "C" mdMemberRef QCALLTYPE ModuleBuilder_GetMemberRefOfFieldInfo(QCall::ModuleHandle pModule, mdTypeDef tr, QCall::TypeHandle th, mdFieldDef tkField, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -444,7 +444,7 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefFromSignature(QCall::Module LPCWSTR wszMemberName, LPCBYTE pSignature, INT32 sigLength, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -472,7 +472,7 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefFromSignature(QCall::Module // This function is used to set the FieldRVA with the content data // //****************************************************************************** -extern "C" void QCALLTYPE ModuleBuilder_SetFieldRVAContent(QCall::ModuleHandle pModule, INT32 tkField, LPCBYTE pContent, INT32 length, QCallException* qcallError) +extern "C" void QCALLTYPE ModuleBuilder_SetFieldRVAContent(QCall::ModuleHandle pModule, INT32 tkField, LPCBYTE pContent, INT32 length, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -528,7 +528,7 @@ extern "C" void QCALLTYPE ModuleBuilder_SetFieldRVAContent(QCall::ModuleHandle p // string constant or return the token of an existing constant. // //****************************************************************************** -extern "C" mdString QCALLTYPE ModuleBuilder_GetStringConstant(QCall::ModuleHandle pModule, LPCWSTR pwzValue, INT32 iLength, QCallException* qcallError) +extern "C" mdString QCALLTYPE ModuleBuilder_GetStringConstant(QCall::ModuleHandle pModule, LPCWSTR pwzValue, INT32 iLength, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -555,7 +555,7 @@ extern "C" mdString QCALLTYPE ModuleBuilder_GetStringConstant(QCall::ModuleHandl /*=============================SetModuleName==================================== // SetModuleName ==============================================================================*/ -extern "C" void QCALLTYPE ModuleBuilder_SetModuleName(QCall::ModuleHandle pModule, LPCWSTR wszModuleName, QCallException* qcallError) +extern "C" void QCALLTYPE ModuleBuilder_SetModuleName(QCall::ModuleHandle pModule, LPCWSTR wszModuleName, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -574,7 +574,7 @@ extern "C" void QCALLTYPE ModuleBuilder_SetModuleName(QCall::ModuleHandle pModul // Return a type spec token given a byte array // //****************************************************************************** -extern "C" mdTypeSpec QCALLTYPE ModuleBuilder_GetTokenFromTypeSpec(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, QCallException* qcallError) +extern "C" mdTypeSpec QCALLTYPE ModuleBuilder_GetTokenFromTypeSpec(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -595,7 +595,7 @@ extern "C" mdTypeSpec QCALLTYPE ModuleBuilder_GetTokenFromTypeSpec(QCall::Module // GetName // This routine will return the name of the module as a String -extern "C" void QCALLTYPE RuntimeModule_GetScopeName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeModule_GetScopeName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -619,7 +619,7 @@ extern "C" void QCALLTYPE RuntimeModule_GetScopeName(QCall::ModuleHandle pModule **Arguments: **Exceptions: ==============================================================================*/ -extern "C" void QCALLTYPE RuntimeModule_GetFullyQualifiedName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeModule_GetFullyQualifiedName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -653,7 +653,7 @@ extern "C" void QCALLTYPE RuntimeModule_GetFullyQualifiedName(QCall::ModuleHandl **Arguments: refThis **Exceptions: None. ==============================================================================*/ -extern "C" HINSTANCE QCALLTYPE MarshalNative_GetHINSTANCE(QCall::ModuleHandle pModule, QCallException* qcallError) +extern "C" HINSTANCE QCALLTYPE MarshalNative_GetHINSTANCE(QCall::ModuleHandle pModule, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -681,7 +681,7 @@ extern "C" HINSTANCE QCALLTYPE MarshalNative_GetHINSTANCE(QCall::ModuleHandle pM // Get class will return an array contain all of the classes // that are defined within this Module. -extern "C" void QCALLTYPE RuntimeModule_GetTypes(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retTypes, QCall::ObjectHandleOnStack retExceptions, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeModule_GetTypes(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retTypes, QCall::ObjectHandleOnStack retExceptions, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/commodule.h b/src/coreclr/vm/commodule.h index e68052da2c8b13..7e365f4515cdbf 100644 --- a/src/coreclr/vm/commodule.h +++ b/src/coreclr/vm/commodule.h @@ -23,11 +23,11 @@ extern "C" mdTypeRef QCALLTYPE ModuleBuilder_GetTypeRef(QCall::ModuleHandle pMod LPCWSTR wszFullName, QCall::ModuleHandle pRefedModule, INT32 tkResolution, - QCallException* qcallError); + QCallExceptionStatus* qcallError); // SetFieldRVAContent // This function is used to set the FieldRVA with the content data -extern "C" void QCALLTYPE ModuleBuilder_SetFieldRVAContent(QCall::ModuleHandle pModule, INT32 tkField, LPCBYTE pContent, INT32 length, QCallException* qcallError); +extern "C" void QCALLTYPE ModuleBuilder_SetFieldRVAContent(QCall::ModuleHandle pModule, INT32 tkField, LPCBYTE pContent, INT32 length, QCallExceptionStatus* qcallError); //GetArrayMethodToken @@ -36,19 +36,19 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetArrayMethodToken(QCall::ModuleHandle LPCWSTR wszMethodName, LPCBYTE pSignature, INT32 sigLength, - QCallException* qcallError); + QCallExceptionStatus* qcallError); // GetMemberRefToken // This function will return the MemberRef token -extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRef(QCall::ModuleHandle pModule, QCall::ModuleHandle pRefedModule, INT32 tr, INT32 token, QCallException* qcallError); +extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRef(QCall::ModuleHandle pModule, QCall::ModuleHandle pRefedModule, INT32 tr, INT32 token, QCallExceptionStatus* qcallError); // This function return a MemberRef token given a MethodInfo describing an array method -extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo(QCall::ModuleHandle pModule, INT32 tr, MethodDesc * method, QCallException* qcallError); +extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo(QCall::ModuleHandle pModule, INT32 tr, MethodDesc * method, QCallExceptionStatus* qcallError); // GetMemberRefOfFieldInfo // This function will return a memberRef token given a FieldInfo -extern "C" mdMemberRef QCALLTYPE ModuleBuilder_GetMemberRefOfFieldInfo(QCall::ModuleHandle pModule, mdTypeDef tr, QCall::TypeHandle th, mdFieldDef tkField, QCallException* qcallError); +extern "C" mdMemberRef QCALLTYPE ModuleBuilder_GetMemberRefOfFieldInfo(QCall::ModuleHandle pModule, mdTypeDef tr, QCall::TypeHandle th, mdFieldDef tkField, QCallExceptionStatus* qcallError); // GetMemberRefFromSignature // This function will return the MemberRef token given the signature from managed code @@ -57,25 +57,25 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefFromSignature(QCall::Module LPCWSTR wszMemberName, LPCBYTE pSignature, INT32 sigLength, - QCallException* qcallError); + QCallExceptionStatus* qcallError); // GetTokenFromTypeSpec -extern "C" mdTypeSpec QCALLTYPE ModuleBuilder_GetTokenFromTypeSpec(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, QCallException* qcallError); +extern "C" mdTypeSpec QCALLTYPE ModuleBuilder_GetTokenFromTypeSpec(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError); // GetStringConstant // If this is a dynamic module, this routine will define a new // string constant or return the token of an existing constant. -extern "C" mdString QCALLTYPE ModuleBuilder_GetStringConstant(QCall::ModuleHandle pModule, LPCWSTR pwzValue, INT32 iLength, QCallException* qcallError); +extern "C" mdString QCALLTYPE ModuleBuilder_GetStringConstant(QCall::ModuleHandle pModule, LPCWSTR pwzValue, INT32 iLength, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ModuleBuilder_SetModuleName(QCall::ModuleHandle pModule, LPCWSTR wszModuleName, QCallException* qcallError); +extern "C" void QCALLTYPE ModuleBuilder_SetModuleName(QCall::ModuleHandle pModule, LPCWSTR wszModuleName, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeModule_GetScopeName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeModule_GetScopeName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeModule_GetFullyQualifiedName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeModule_GetFullyQualifiedName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); // GetTypes will return an array containing all of the types that are defined within this Module. -extern "C" void QCALLTYPE RuntimeModule_GetTypes(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retTypes, QCall::ObjectHandleOnStack retExceptions, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeModule_GetTypes(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retTypes, QCall::ObjectHandleOnStack retExceptions, QCallExceptionStatus* qcallError); -extern "C" HINSTANCE QCALLTYPE MarshalNative_GetHINSTANCE(QCall::ModuleHandle pModule, QCallException* qcallError); +extern "C" HINSTANCE QCALLTYPE MarshalNative_GetHINSTANCE(QCall::ModuleHandle pModule, QCallExceptionStatus* qcallError); #endif diff --git a/src/coreclr/vm/comsynchronizable.cpp b/src/coreclr/vm/comsynchronizable.cpp index 0b7e6563823665..6476972fdc5c83 100644 --- a/src/coreclr/vm/comsynchronizable.cpp +++ b/src/coreclr/vm/comsynchronizable.cpp @@ -197,7 +197,7 @@ static ULONG WINAPI KickOffThread(void* pass) return 0; } -extern "C" BOOL QCALLTYPE ThreadNative_Start(QCall::ThreadHandle thread, int threadStackSize, int priority, BOOL isThreadPool, PCWSTR pThreadName, QCall::ObjectHandleOnStack exception, QCallException* qcallError) +extern "C" BOOL QCALLTYPE ThreadNative_Start(QCall::ThreadHandle thread, int threadStackSize, int priority, BOOL isThreadPool, PCWSTR pThreadName, QCall::ObjectHandleOnStack exception, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -287,7 +287,7 @@ extern "C" BOOL QCALLTYPE ThreadNative_Start(QCall::ThreadHandle thread, int thr return result; } -extern "C" void QCALLTYPE ThreadNative_SetPriority(QCall::ObjectHandleOnStack thread, INT32 iPriority, QCallException* qcallError) +extern "C" void QCALLTYPE ThreadNative_SetPriority(QCall::ObjectHandleOnStack thread, INT32 iPriority, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -328,7 +328,7 @@ extern "C" void QCALLTYPE ThreadNative_SetPriority(QCall::ObjectHandleOnStack th END_QCALL; } -extern "C" void QCALLTYPE ThreadNative_GetCurrentThread(QCall::ObjectHandleOnStack thread, QCallException* qcallError) +extern "C" void QCALLTYPE ThreadNative_GetCurrentThread(QCall::ObjectHandleOnStack thread, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -340,7 +340,7 @@ extern "C" void QCALLTYPE ThreadNative_GetCurrentThread(QCall::ObjectHandleOnSta END_QCALL; } -extern "C" UINT64 QCALLTYPE ThreadNative_GetCurrentOSThreadId(QCallException* qcallError) +extern "C" UINT64 QCALLTYPE ThreadNative_GetCurrentOSThreadId(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -362,7 +362,7 @@ extern "C" UINT64 QCALLTYPE ThreadNative_GetCurrentOSThreadId(QCallException* qc return threadId; } -extern "C" void QCALLTYPE ThreadNative_Initialize(QCall::ObjectHandleOnStack t, QCallException* qcallError) +extern "C" void QCALLTYPE ThreadNative_Initialize(QCall::ObjectHandleOnStack t, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -457,7 +457,7 @@ extern "C" void QCALLTYPE ThreadNative_ClearWaitSleepJoinState(QCall::ThreadHand // Return whether the thread hosts an STA, is a member of the MTA or is not // currently initialized for COM. -extern "C" INT32 QCALLTYPE ThreadNative_GetApartmentState(QCall::ObjectHandleOnStack t, QCallException* qcallError) +extern "C" INT32 QCALLTYPE ThreadNative_GetApartmentState(QCall::ObjectHandleOnStack t, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -487,7 +487,7 @@ extern "C" INT32 QCALLTYPE ThreadNative_GetApartmentState(QCall::ObjectHandleOnS // Indicate whether the thread will host an STA (this may fail if the thread has // already been made part of the MTA, use GetApartmentState or the return state // from this routine to check for this). -extern "C" INT32 QCALLTYPE ThreadNative_SetApartmentState(QCall::ObjectHandleOnStack t, INT32 iState, QCallException* qcallError) +extern "C" INT32 QCALLTYPE ThreadNative_SetApartmentState(QCall::ObjectHandleOnStack t, INT32 iState, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -532,7 +532,7 @@ extern "C" INT32 QCALLTYPE ThreadNative_SetApartmentState(QCall::ObjectHandleOnS #endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT #if TARGET_WINDOWS -extern "C" HANDLE QCALLTYPE ThreadNative_GetOSHandle(QCall::ThreadHandle t, QCallException* qcallError) +extern "C" HANDLE QCALLTYPE ThreadNative_GetOSHandle(QCall::ThreadHandle t, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -658,7 +658,7 @@ extern "C" BOOL QCALLTYPE ThreadNative_GetIsBackground(QCall::ThreadHandle threa } // Set whether or not this is a background thread. -extern "C" void QCALLTYPE ThreadNative_SetIsBackground(QCall::ThreadHandle thread, BOOL value, QCallException* qcallError) +extern "C" void QCALLTYPE ThreadNative_SetIsBackground(QCall::ThreadHandle thread, BOOL value, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -674,7 +674,7 @@ extern "C" void QCALLTYPE ThreadNative_SetIsBackground(QCall::ThreadHandle threa END_QCALL; } -extern "C" void QCALLTYPE ThreadNative_InformThreadNameChange(QCall::ThreadHandle thread, LPCWSTR name, INT32 len, QCallException* qcallError) +extern "C" void QCALLTYPE ThreadNative_InformThreadNameChange(QCall::ThreadHandle thread, LPCWSTR name, INT32 len, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -761,7 +761,7 @@ extern "C" void QCALLTYPE ThreadNative_SpinWait(INT32 iterations) #ifdef TARGET_WINDOWS // This service can be called on unstarted and dead threads. For unstarted ones, the // next wait will be interrupted. For dead ones, this service quietly does nothing. -extern "C" void QCALLTYPE ThreadNative_Interrupt(QCall::ThreadHandle thread, QCallException* qcallError) +extern "C" void QCALLTYPE ThreadNative_Interrupt(QCall::ThreadHandle thread, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -777,7 +777,7 @@ extern "C" void QCALLTYPE ThreadNative_Interrupt(QCall::ThreadHandle thread, QCa END_QCALL; } -extern "C" void QCALLTYPE ThreadNative_CheckForPendingInterrupt(QCall::ThreadHandle thread, QCallException* qcallError) +extern "C" void QCALLTYPE ThreadNative_CheckForPendingInterrupt(QCall::ThreadHandle thread, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -809,7 +809,7 @@ extern "C" void QCALLTYPE ThreadNative_PollGC() // and is thus marked as a GC safe point, and that the p/invoke rare path will kick in } -extern "C" BOOL QCALLTYPE ThreadNative_YieldThread(QCallException* qcallError) +extern "C" BOOL QCALLTYPE ThreadNative_YieldThread(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -824,7 +824,7 @@ extern "C" BOOL QCALLTYPE ThreadNative_YieldThread(QCallException* qcallError) return ret; } -extern "C" void QCALLTYPE ThreadNative_Abort(QCall::ThreadHandle thread, QCallException* qcallError) +extern "C" void QCALLTYPE ThreadNative_Abort(QCall::ThreadHandle thread, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -869,7 +869,7 @@ FCIMPL1(OBJECTHANDLE, ObjectHeader_GetLockHandleIfExists, Object* pObj) } FCIMPLEND -extern "C" void QCALLTYPE ObjectHeader_GetOrCreateLockObject(QCall::ObjectHandleOnStack obj, QCall::ObjectHandleOnStack lockObj, QCallException* qcallError) +extern "C" void QCALLTYPE ObjectHeader_GetOrCreateLockObject(QCall::ObjectHandleOnStack obj, QCall::ObjectHandleOnStack lockObj, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -884,7 +884,7 @@ extern "C" void QCALLTYPE ObjectHeader_GetOrCreateLockObject(QCall::ObjectHandle END_QCALL; } -extern "C" INT32 QCALLTYPE ThreadNative_ReentrantWaitAny(BOOL alertable, INT32 timeout, INT32 count, HANDLE *handles, QCallException* qcallError) +extern "C" INT32 QCALLTYPE ThreadNative_ReentrantWaitAny(BOOL alertable, INT32 timeout, INT32 count, HANDLE *handles, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/comsynchronizable.h b/src/coreclr/vm/comsynchronizable.h index 4aaff4e1a8f75b..f634a9e6f85908 100644 --- a/src/coreclr/vm/comsynchronizable.h +++ b/src/coreclr/vm/comsynchronizable.h @@ -49,42 +49,42 @@ class ThreadNative FCDECL0(static Object*, GetAndClearQCallException); }; -extern "C" BOOL QCALLTYPE ThreadNative_Start(QCall::ThreadHandle thread, int threadStackSize, int priority, BOOL isThreadPool, PCWSTR pThreadName, QCall::ObjectHandleOnStack exception, QCallException* qcallError); -extern "C" void QCALLTYPE ThreadNative_SetPriority(QCall::ObjectHandleOnStack thread, INT32 iPriority, QCallException* qcallError); -extern "C" void QCALLTYPE ThreadNative_GetCurrentThread(QCall::ObjectHandleOnStack thread, QCallException* qcallError); +extern "C" BOOL QCALLTYPE ThreadNative_Start(QCall::ThreadHandle thread, int threadStackSize, int priority, BOOL isThreadPool, PCWSTR pThreadName, QCall::ObjectHandleOnStack exception, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ThreadNative_SetPriority(QCall::ObjectHandleOnStack thread, INT32 iPriority, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ThreadNative_GetCurrentThread(QCall::ObjectHandleOnStack thread, QCallExceptionStatus* qcallError); extern "C" BOOL QCALLTYPE ThreadNative_GetIsBackground(QCall::ThreadHandle thread); -extern "C" void QCALLTYPE ThreadNative_SetIsBackground(QCall::ThreadHandle thread, BOOL value, QCallException* qcallError); -extern "C" void QCALLTYPE ThreadNative_InformThreadNameChange(QCall::ThreadHandle thread, LPCWSTR name, INT32 len, QCallException* qcallError); -extern "C" BOOL QCALLTYPE ThreadNative_YieldThread(QCallException* qcallError); +extern "C" void QCALLTYPE ThreadNative_SetIsBackground(QCall::ThreadHandle thread, BOOL value, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ThreadNative_InformThreadNameChange(QCall::ThreadHandle thread, LPCWSTR name, INT32 len, QCallExceptionStatus* qcallError); +extern "C" BOOL QCALLTYPE ThreadNative_YieldThread(QCallExceptionStatus* qcallError); extern "C" void QCALLTYPE ThreadNative_PollGC(); -extern "C" UINT64 QCALLTYPE ThreadNative_GetCurrentOSThreadId(QCallException* qcallError); -extern "C" void QCALLTYPE ThreadNative_Initialize(QCall::ObjectHandleOnStack t, QCallException* qcallError); +extern "C" UINT64 QCALLTYPE ThreadNative_GetCurrentOSThreadId(QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ThreadNative_Initialize(QCall::ObjectHandleOnStack t, QCallExceptionStatus* qcallError); extern "C" INT32 QCALLTYPE ThreadNative_GetThreadState(QCall::ThreadHandle thread); extern "C" void QCALLTYPE ThreadNative_SetWaitSleepJoinState(QCall::ThreadHandle thread); extern "C" void QCALLTYPE ThreadNative_ClearWaitSleepJoinState(QCall::ThreadHandle thread); -extern "C" INT32 QCALLTYPE ThreadNative_ReentrantWaitAny(BOOL alertable, INT32 timeout, INT32 count, HANDLE *handles, QCallException* qcallError); +extern "C" INT32 QCALLTYPE ThreadNative_ReentrantWaitAny(BOOL alertable, INT32 timeout, INT32 count, HANDLE *handles, QCallExceptionStatus* qcallError); #ifdef TARGET_WINDOWS -extern "C" void QCALLTYPE ThreadNative_Interrupt(QCall::ThreadHandle thread, QCallException* qcallError); -extern "C" void QCALLTYPE ThreadNative_CheckForPendingInterrupt(QCall::ThreadHandle thread, QCallException* qcallError); +extern "C" void QCALLTYPE ThreadNative_Interrupt(QCall::ThreadHandle thread, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ThreadNative_CheckForPendingInterrupt(QCall::ThreadHandle thread, QCallExceptionStatus* qcallError); #endif // TARGET_WINDOWS #ifdef FEATURE_COMINTEROP_APARTMENT_SUPPORT -extern "C" INT32 QCALLTYPE ThreadNative_GetApartmentState(QCall::ObjectHandleOnStack t, QCallException* qcallError); -extern "C" INT32 QCALLTYPE ThreadNative_SetApartmentState(QCall::ObjectHandleOnStack t, INT32 iState, QCallException* qcallError); +extern "C" INT32 QCALLTYPE ThreadNative_GetApartmentState(QCall::ObjectHandleOnStack t, QCallExceptionStatus* qcallError); +extern "C" INT32 QCALLTYPE ThreadNative_SetApartmentState(QCall::ObjectHandleOnStack t, INT32 iState, QCallExceptionStatus* qcallError); #endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT #ifdef TARGET_WINDOWS -extern "C" HANDLE QCALLTYPE ThreadNative_GetOSHandle(QCall::ThreadHandle t, QCallException* qcallError); +extern "C" HANDLE QCALLTYPE ThreadNative_GetOSHandle(QCall::ThreadHandle t, QCallExceptionStatus* qcallError); #endif // TARGET_WINDOWS -extern "C" void QCALLTYPE ThreadNative_Abort(QCall::ThreadHandle thread, QCallException* qcallError); +extern "C" void QCALLTYPE ThreadNative_Abort(QCall::ThreadHandle thread, QCallExceptionStatus* qcallError); extern "C" void QCALLTYPE ThreadNative_ResetAbort(); extern "C" void QCALLTYPE ThreadNative_SpinWait(INT32 iterations); #ifdef FEATURE_COMINTEROP extern "C" void QCALLTYPE ThreadNative_DisableComObjectEagerCleanup(QCall::ThreadHandle thread); #endif // FEATURE_COMINTEROP -extern "C" void QCALLTYPE ObjectHeader_GetOrCreateLockObject(QCall::ObjectHandleOnStack obj, QCall::ObjectHandleOnStack lockObj, QCallException* qcallError); +extern "C" void QCALLTYPE ObjectHeader_GetOrCreateLockObject(QCall::ObjectHandleOnStack obj, QCall::ObjectHandleOnStack lockObj, QCallExceptionStatus* qcallError); FCDECL1(OBJECTHANDLE, ObjectHeader_GetLockHandleIfExists, Object* obj); #endif // _COMSYNCHRONIZABLE_H diff --git a/src/coreclr/vm/comutilnative.cpp b/src/coreclr/vm/comutilnative.cpp index 2821c44e98f956..b3f3c0a155d94a 100644 --- a/src/coreclr/vm/comutilnative.cpp +++ b/src/coreclr/vm/comutilnative.cpp @@ -82,7 +82,7 @@ FCIMPLEND // Given an exception object, this method will mark its stack trace as frozen and return it to the caller. // Frozen stack traces are immutable, when a thread attempts to add a frame to it, the stack trace is cloned first. -extern "C" void QCALLTYPE ExceptionNative_GetFrozenStackTrace(QCall::ObjectHandleOnStack exception, QCall::ObjectHandleOnStack ret, QCallException* qcallError) +extern "C" void QCALLTYPE ExceptionNative_GetFrozenStackTrace(QCall::ObjectHandleOnStack exception, QCall::ObjectHandleOnStack ret, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -313,7 +313,7 @@ FCIMPLEND // our locks within CER's to avoid this problem - just use the CLR's // unmanaged resources. // -extern "C" void QCALLTYPE ExceptionNative_GetMessageFromNativeResources(ExceptionMessageKind kind, QCall::StringHandleOnStack retMesg, QCallException* qcallError) +extern "C" void QCALLTYPE ExceptionNative_GetMessageFromNativeResources(ExceptionMessageKind kind, QCall::StringHandleOnStack retMesg, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -360,7 +360,7 @@ extern "C" void QCALLTYPE ExceptionNative_GetMessageFromNativeResources(Exceptio END_QCALL; } -extern "C" void QCALLTYPE ExceptionNative_GetMethodFromStackTrace(QCall::ObjectHandleOnStack stacktrace, QCall::ObjectHandleOnStack retMethodInfo, QCallException* qcallError) +extern "C" void QCALLTYPE ExceptionNative_GetMethodFromStackTrace(QCall::ObjectHandleOnStack stacktrace, QCall::ObjectHandleOnStack retMethodInfo, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -405,7 +405,7 @@ extern "C" void QCALLTYPE ExceptionNative_ThrowAmbiguousResolutionException( MethodTable* pTargetClass, MethodTable* pInterfaceMT, MethodDesc* pInterfaceMD, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -420,7 +420,7 @@ extern "C" void QCALLTYPE ExceptionNative_ThrowEntryPointNotFoundException( MethodTable* pTargetClass, MethodTable* pInterfaceMT, MethodDesc* pInterfaceMD, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -431,7 +431,7 @@ extern "C" void QCALLTYPE ExceptionNative_ThrowEntryPointNotFoundException( END_QCALL; } -extern "C" void QCALLTYPE ExceptionNative_ThrowMethodAccessException(MethodDesc* caller, MethodDesc* callee, QCallException* qcallError) +extern "C" void QCALLTYPE ExceptionNative_ThrowMethodAccessException(MethodDesc* caller, MethodDesc* callee, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -444,7 +444,7 @@ extern "C" void QCALLTYPE ExceptionNative_ThrowMethodAccessException(MethodDesc* END_QCALL; } -extern "C" void QCALLTYPE ExceptionNative_ThrowFieldAccessException(MethodDesc* caller, FieldDesc* callee, QCallException* qcallError) +extern "C" void QCALLTYPE ExceptionNative_ThrowFieldAccessException(MethodDesc* caller, FieldDesc* callee, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -457,7 +457,7 @@ extern "C" void QCALLTYPE ExceptionNative_ThrowFieldAccessException(MethodDesc* END_QCALL; } -extern "C" void QCALLTYPE ExceptionNative_ThrowClassAccessException(MethodDesc* caller, EnregisteredTypeHandle callee, QCallException* qcallError) +extern "C" void QCALLTYPE ExceptionNative_ThrowClassAccessException(MethodDesc* caller, EnregisteredTypeHandle callee, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -588,7 +588,7 @@ FCIMPL0(FC_BOOL_RET, GCInterface::CancelFullGCNotification) } FCIMPLEND -extern "C" int QCALLTYPE GCInterface_WaitForFullGCApproach(int millisecondsTimeout, QCallException* qcallError) +extern "C" int QCALLTYPE GCInterface_WaitForFullGCApproach(int millisecondsTimeout, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -606,7 +606,7 @@ extern "C" int QCALLTYPE GCInterface_WaitForFullGCApproach(int millisecondsTimeo return result; } -extern "C" int QCALLTYPE GCInterface_WaitForFullGCComplete(int millisecondsTimeout, QCallException* qcallError) +extern "C" int QCALLTYPE GCInterface_WaitForFullGCComplete(int millisecondsTimeout, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -673,7 +673,7 @@ FCIMPL2(int, GCInterface::CollectionCount, INT32 generation, INT32 getSpecialGCC } FCIMPLEND -extern "C" int QCALLTYPE GCInterface_StartNoGCRegion(INT64 totalSize, BOOL lohSizeKnown, INT64 lohSize, BOOL disallowFullBlockingGC, QCallException* qcallError) +extern "C" int QCALLTYPE GCInterface_StartNoGCRegion(INT64 totalSize, BOOL lohSizeKnown, INT64 lohSize, BOOL disallowFullBlockingGC, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -693,7 +693,7 @@ extern "C" int QCALLTYPE GCInterface_StartNoGCRegion(INT64 totalSize, BOOL lohSi return retVal; } -extern "C" int QCALLTYPE GCInterface_EndNoGCRegion(QCallException* qcallError) +extern "C" int QCALLTYPE GCInterface_EndNoGCRegion(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -730,7 +730,7 @@ FCIMPLEND **Arguments: None **Exceptions: None ==============================================================================*/ -extern "C" INT64 QCALLTYPE GCInterface_GetTotalMemory(QCallException* qcallError) +extern "C" INT64 QCALLTYPE GCInterface_GetTotalMemory(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -752,7 +752,7 @@ extern "C" INT64 QCALLTYPE GCInterface_GetTotalMemory(QCallException* qcallError **Arguments: args->generation: The maximum generation to collect **Exceptions: Argument exception if args->generation is < 0 or > GetMaxGeneration(); ==============================================================================*/ -extern "C" void QCALLTYPE GCInterface_Collect(INT32 generation, INT32 mode, CLR_BOOL lowMemoryPressure, QCallException* qcallError) +extern "C" void QCALLTYPE GCInterface_Collect(INT32 generation, INT32 mode, CLR_BOOL lowMemoryPressure, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -769,7 +769,7 @@ extern "C" void QCALLTYPE GCInterface_Collect(INT32 generation, INT32 mode, CLR_ END_QCALL; } -extern "C" void* QCALLTYPE GCInterface_GetNextFinalizableObject(QCall::ObjectHandleOnStack pObj, QCallException* qcallError) +extern "C" void* QCALLTYPE GCInterface_GetNextFinalizableObject(QCall::ObjectHandleOnStack pObj, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -811,7 +811,7 @@ extern "C" void* QCALLTYPE GCInterface_GetNextFinalizableObject(QCall::ObjectHan **Arguments: None **Exceptions: None ==============================================================================*/ -extern "C" void QCALLTYPE GCInterface_WaitForPendingFinalizers(QCallException* qcallError) +extern "C" void QCALLTYPE GCInterface_WaitForPendingFinalizers(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -878,7 +878,7 @@ FCIMPLEND ** ret -> The allocated array. **Exceptions: IDS_EE_ARRAY_DIMENSIONS_EXCEEDED when size is too large. OOM if can't allocate. ==============================================================================*/ -extern "C" void QCALLTYPE GCInterface_AllocateNewArray(void* typeHandlePtr, INT32 length, INT32 flags, QCall::ObjectHandleOnStack ret, QCallException* qcallError) +extern "C" void QCALLTYPE GCInterface_AllocateNewArray(void* typeHandlePtr, INT32 length, INT32 flags, QCall::ObjectHandleOnStack ret, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(typeHandlePtr != NULL); @@ -928,7 +928,7 @@ FCIMPL0(INT64, GCInterface::GetTotalAllocatedBytesApproximate) } FCIMPLEND; -extern "C" INT64 QCALLTYPE GCInterface_GetTotalAllocatedBytesPrecise(QCallException* qcallError) +extern "C" INT64 QCALLTYPE GCInterface_GetTotalAllocatedBytesPrecise(QCallExceptionStatus* qcallError) { INT64 allocated = 0; @@ -966,7 +966,7 @@ extern "C" INT64 QCALLTYPE GCInterface_GetTotalAllocatedBytesPrecise(QCallExcept **Arguments: args-> pointer to section, size of section **Exceptions: None ==============================================================================*/ -extern "C" void* QCALLTYPE GCInterface_RegisterFrozenSegment(void* pSection, SIZE_T sizeSection, QCallException* qcallError) +extern "C" void* QCALLTYPE GCInterface_RegisterFrozenSegment(void* pSection, SIZE_T sizeSection, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -999,7 +999,7 @@ extern "C" void* QCALLTYPE GCInterface_RegisterFrozenSegment(void* pSection, SIZ **Arguments: args-> segment handle **Exceptions: None ==============================================================================*/ -extern "C" void QCALLTYPE GCInterface_UnregisterFrozenSegment(void* segment, QCallException* qcallError) +extern "C" void QCALLTYPE GCInterface_UnregisterFrozenSegment(void* segment, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1035,7 +1035,7 @@ FCIMPLEND **Arguments: Object of interest **Exceptions: None ==============================================================================*/ -extern "C" void QCALLTYPE GCInterface_ReRegisterForFinalize(QCall::ObjectHandleOnStack pObj, QCallException* qcallError) +extern "C" void QCALLTYPE GCInterface_ReRegisterForFinalize(QCall::ObjectHandleOnStack pObj, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1093,7 +1093,7 @@ FORCEINLINE UINT64 GCInterface::InterlockedSub(UINT64 *pMinuend, UINT64 subtrahe return newMemValue; } -extern "C" void QCALLTYPE GCInterface_AddMemoryPressure(UINT64 bytesAllocated, QCallException* qcallError) +extern "C" void QCALLTYPE GCInterface_AddMemoryPressure(UINT64 bytesAllocated, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1102,7 +1102,7 @@ extern "C" void QCALLTYPE GCInterface_AddMemoryPressure(UINT64 bytesAllocated, Q END_QCALL; } -extern "C" void QCALLTYPE GCInterface_EnumerateConfigurationValues(void* configurationContext, EnumerateConfigurationValuesCallback callback, QCallException* qcallError) +extern "C" void QCALLTYPE GCInterface_EnumerateConfigurationValues(void* configurationContext, EnumerateConfigurationValuesCallback callback, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1130,7 +1130,7 @@ void GCInterface::EnumerateConfigurationValues(void* configurationContext, Enume GCHeapHardLimitInfo g_gcHeapHardLimitInfo; bool g_gcHeapHardLimitInfoSpecified = false; -extern "C" int QCALLTYPE GCInterface_RefreshMemoryLimit(GCHeapHardLimitInfo heapHardLimitInfo, QCallException* qcallError) +extern "C" int QCALLTYPE GCInterface_RefreshMemoryLimit(GCHeapHardLimitInfo heapHardLimitInfo, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1158,7 +1158,7 @@ int GCInterface::RefreshMemoryLimit() return GCHeapUtilities::GetGCHeap()->RefreshMemoryLimit(); } -extern "C" enable_no_gc_region_callback_status QCALLTYPE GCInterface_EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, INT64 totalSize, QCallException* qcallError) +extern "C" enable_no_gc_region_callback_status QCALLTYPE GCInterface_EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, INT64 totalSize, QCallExceptionStatus* qcallError) { enable_no_gc_region_callback_status status = enable_no_gc_region_callback_status::succeed; QCALL_CONTRACT; @@ -1182,7 +1182,7 @@ enable_no_gc_region_callback_status GCInterface::EnableNoGCRegionCallback(NoGCRe return GCHeapUtilities::GetGCHeap()->EnableNoGCRegionCallback(callback, totalSize); } -extern "C" uint64_t QCALLTYPE GCInterface_GetGenerationBudget(int generation, QCallException* qcallError) +extern "C" uint64_t QCALLTYPE GCInterface_GetGenerationBudget(int generation, QCallExceptionStatus* qcallError) { uint64_t result = 0; QCALL_CONTRACT; @@ -1331,7 +1331,7 @@ void GCInterface::AddMemoryPressure(UINT64 bytesAllocated) } } -extern "C" void QCALLTYPE GCInterface_RemoveMemoryPressure(UINT64 bytesAllocated, QCallException* qcallError) +extern "C" void QCALLTYPE GCInterface_RemoveMemoryPressure(UINT64 bytesAllocated, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1415,7 +1415,7 @@ NOINLINE void GCInterface::GarbageCollectModeAny(int generation) // // EnvironmentNative // -extern "C" VOID QCALLTYPE Environment_Exit(INT32 exitcode, QCallException* qcallError) +extern "C" VOID QCALLTYPE Environment_Exit(INT32 exitcode, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1453,7 +1453,7 @@ FCIMPL0(INT32, EnvironmentNative::GetExitCode) } FCIMPLEND -extern "C" INT32 QCALLTYPE Environment_GetProcessorCount(QCallException* qcallError) +extern "C" INT32 QCALLTYPE Environment_GetProcessorCount(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1502,7 +1502,7 @@ static StackWalkAction FindFailFastCallerCallback(CrawlFrame* frame, VOID* data) static thread_local int8_t alreadyFailing = 0; -extern "C" void QCALLTYPE Environment_FailFast(QCall::StackCrawlMarkHandle mark, PCWSTR message, QCall::ObjectHandleOnStack exception, PCWSTR errorSource, QCallException* qcallError) +extern "C" void QCALLTYPE Environment_FailFast(QCall::StackCrawlMarkHandle mark, PCWSTR message, QCall::ObjectHandleOnStack exception, PCWSTR errorSource, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1577,7 +1577,7 @@ extern "C" void QCALLTYPE Environment_FailFast(QCall::StackCrawlMarkHandle mark, // // ObjectNative // -extern "C" INT32 QCALLTYPE ObjectNative_GetHashCodeSlow(QCall::ObjectHandleOnStack objHandle, QCallException* qcallError) +extern "C" INT32 QCALLTYPE ObjectNative_GetHashCodeSlow(QCall::ObjectHandleOnStack objHandle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1628,7 +1628,7 @@ FCIMPL2(FC_BOOL_RET, ObjectNative::ContentEquals, Object *pThisRef, Object *pCom } FCIMPLEND -extern "C" void QCALLTYPE ObjectNative_AllocateUninitializedClone(QCall::ObjectHandleOnStack objHandle, QCallException* qcallError) +extern "C" void QCALLTYPE ObjectNative_AllocateUninitializedClone(QCall::ObjectHandleOnStack objHandle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1844,7 +1844,7 @@ BOOL CanCompareBitsOrUseFastGetHashCode(MethodTable* mt) return canCompareBitsOrUseFastGetHashCode; } -extern "C" BOOL QCALLTYPE MethodTable_CanCompareBitsOrUseFastGetHashCode(MethodTable* mt, QCallException* qcallError) +extern "C" BOOL QCALLTYPE MethodTable_CanCompareBitsOrUseFastGetHashCode(MethodTable* mt, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1963,7 +1963,7 @@ static ValueTypeHashCodeStrategy GetHashCodeStrategy(MethodTable* mt, QCall::Obj return ret; } -extern "C" INT32 QCALLTYPE ValueType_GetHashCodeStrategy(MethodTable* mt, QCall::ObjectHandleOnStack objHandle, UINT32* fieldOffset, UINT32* fieldSize, MethodTable** fieldMT, QCallException* qcallError) +extern "C" INT32 QCALLTYPE ValueType_GetHashCodeStrategy(MethodTable* mt, QCall::ObjectHandleOnStack objHandle, UINT32* fieldOffset, UINT32* fieldSize, MethodTable** fieldMT, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -2024,7 +2024,7 @@ FCIMPL1(OBJECTHANDLE, MethodTableNative::GetLoaderAllocatorHandle, MethodTable * } FCIMPLEND -extern "C" BOOL QCALLTYPE MethodTable_AreTypesEquivalent(MethodTable* mta, MethodTable* mtb, QCallException* qcallError) +extern "C" BOOL QCALLTYPE MethodTable_AreTypesEquivalent(MethodTable* mta, MethodTable* mtb, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -2039,7 +2039,7 @@ extern "C" BOOL QCALLTYPE MethodTable_AreTypesEquivalent(MethodTable* mta, Metho return bResult; } -extern "C" BOOL QCALLTYPE TypeHandle_CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd, QCallException* qcallError) +extern "C" BOOL QCALLTYPE TypeHandle_CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -2097,7 +2097,7 @@ static bool HasOverriddenStreamMethod(MethodTable* streamMT, MethodTable* pMT, W return NonVirtualEntry2MethodDesc(actual) != NonVirtualEntry2MethodDesc(base); } -extern "C" BOOL QCALLTYPE Stream_HasOverriddenSlow(MethodTable* pMT, BOOL isRead, QCallException* qcallError) +extern "C" BOOL QCALLTYPE Stream_HasOverriddenSlow(MethodTable* pMT, BOOL isRead, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(pMT != NULL); diff --git a/src/coreclr/vm/comutilnative.h b/src/coreclr/vm/comutilnative.h index 9996b6ffc7625f..e68ede7b519e0b 100644 --- a/src/coreclr/vm/comutilnative.h +++ b/src/coreclr/vm/comutilnative.h @@ -48,32 +48,32 @@ class ExceptionNative FCDECL0(static UINT32, GetExceptionCount); }; -extern "C" void QCALLTYPE ExceptionNative_GetFrozenStackTrace(QCall::ObjectHandleOnStack exception, QCall::ObjectHandleOnStack ret, QCallException* qcallError); +extern "C" void QCALLTYPE ExceptionNative_GetFrozenStackTrace(QCall::ObjectHandleOnStack exception, QCall::ObjectHandleOnStack ret, QCallExceptionStatus* qcallError); enum class ExceptionMessageKind { ThreadAbort = 1, ThreadInterrupted = 2, OutOfMemory = 3 }; -extern "C" void QCALLTYPE ExceptionNative_GetMessageFromNativeResources(ExceptionMessageKind kind, QCall::StringHandleOnStack retMesg, QCallException* qcallError); +extern "C" void QCALLTYPE ExceptionNative_GetMessageFromNativeResources(ExceptionMessageKind kind, QCall::StringHandleOnStack retMesg, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ExceptionNative_GetMethodFromStackTrace(QCall::ObjectHandleOnStack array, QCall::ObjectHandleOnStack retMethodInfo, QCallException* qcallError); +extern "C" void QCALLTYPE ExceptionNative_GetMethodFromStackTrace(QCall::ObjectHandleOnStack array, QCall::ObjectHandleOnStack retMethodInfo, QCallExceptionStatus* qcallError); extern "C" void QCALLTYPE ExceptionNative_ThrowAmbiguousResolutionException( MethodTable* pTargetClass, MethodTable* pInterfaceMT, MethodDesc* pInterfaceMD, - QCallException* qcallError); + QCallExceptionStatus* qcallError); extern "C" void QCALLTYPE ExceptionNative_ThrowEntryPointNotFoundException( MethodTable* pTargetClass, MethodTable* pInterfaceMT, MethodDesc* pInterfaceMD, - QCallException* qcallError); + QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ExceptionNative_ThrowMethodAccessException(MethodDesc* caller, MethodDesc* callee, QCallException* qcallError); -extern "C" void QCALLTYPE ExceptionNative_ThrowFieldAccessException(MethodDesc* caller, FieldDesc* callee, QCallException* qcallError); -extern "C" void QCALLTYPE ExceptionNative_ThrowClassAccessException(MethodDesc* caller, EnregisteredTypeHandle callee, QCallException* qcallError); +extern "C" void QCALLTYPE ExceptionNative_ThrowMethodAccessException(MethodDesc* caller, MethodDesc* callee, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ExceptionNative_ThrowFieldAccessException(MethodDesc* caller, FieldDesc* callee, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ExceptionNative_ThrowClassAccessException(MethodDesc* caller, EnregisteredTypeHandle callee, QCallExceptionStatus* qcallError); // // Buffer @@ -193,42 +193,42 @@ class GCInterface { NOINLINE static void GarbageCollectModeAny(int generation); }; -extern "C" INT64 QCALLTYPE GCInterface_GetTotalAllocatedBytesPrecise(QCallException* qcallError); +extern "C" INT64 QCALLTYPE GCInterface_GetTotalAllocatedBytesPrecise(QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE GCInterface_AllocateNewArray(void* typeHandlePtr, INT32 length, INT32 flags, QCall::ObjectHandleOnStack ret, QCallException* qcallError); +extern "C" void QCALLTYPE GCInterface_AllocateNewArray(void* typeHandlePtr, INT32 length, INT32 flags, QCall::ObjectHandleOnStack ret, QCallExceptionStatus* qcallError); -extern "C" INT64 QCALLTYPE GCInterface_GetTotalMemory(QCallException* qcallError); +extern "C" INT64 QCALLTYPE GCInterface_GetTotalMemory(QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE GCInterface_Collect(INT32 generation, INT32 mode, CLR_BOOL lowMemoryPressure, QCallException* qcallError); +extern "C" void QCALLTYPE GCInterface_Collect(INT32 generation, INT32 mode, CLR_BOOL lowMemoryPressure, QCallExceptionStatus* qcallError); -extern "C" void* QCALLTYPE GCInterface_GetNextFinalizableObject(QCall::ObjectHandleOnStack pObj, QCallException* qcallError); +extern "C" void* QCALLTYPE GCInterface_GetNextFinalizableObject(QCall::ObjectHandleOnStack pObj, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE GCInterface_WaitForPendingFinalizers(QCallException* qcallError); -extern "C" void* QCALLTYPE GCInterface_RegisterFrozenSegment(void *pSection, SIZE_T sizeSection, QCallException* qcallError); +extern "C" void QCALLTYPE GCInterface_WaitForPendingFinalizers(QCallExceptionStatus* qcallError); +extern "C" void* QCALLTYPE GCInterface_RegisterFrozenSegment(void *pSection, SIZE_T sizeSection, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE GCInterface_UnregisterFrozenSegment(void *segmentHandle, QCallException* qcallError); +extern "C" void QCALLTYPE GCInterface_UnregisterFrozenSegment(void *segmentHandle, QCallExceptionStatus* qcallError); -extern "C" int QCALLTYPE GCInterface_WaitForFullGCApproach(int millisecondsTimeout, QCallException* qcallError); +extern "C" int QCALLTYPE GCInterface_WaitForFullGCApproach(int millisecondsTimeout, QCallExceptionStatus* qcallError); -extern "C" int QCALLTYPE GCInterface_WaitForFullGCComplete(int millisecondsTimeout, QCallException* qcallError); +extern "C" int QCALLTYPE GCInterface_WaitForFullGCComplete(int millisecondsTimeout, QCallExceptionStatus* qcallError); -extern "C" int QCALLTYPE GCInterface_StartNoGCRegion(INT64 totalSize, BOOL lohSizeKnown, INT64 lohSize, BOOL disallowFullBlockingGC, QCallException* qcallError); +extern "C" int QCALLTYPE GCInterface_StartNoGCRegion(INT64 totalSize, BOOL lohSizeKnown, INT64 lohSize, BOOL disallowFullBlockingGC, QCallExceptionStatus* qcallError); -extern "C" int QCALLTYPE GCInterface_EndNoGCRegion(QCallException* qcallError); +extern "C" int QCALLTYPE GCInterface_EndNoGCRegion(QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE GCInterface_AddMemoryPressure(UINT64 bytesAllocated, QCallException* qcallError); +extern "C" void QCALLTYPE GCInterface_AddMemoryPressure(UINT64 bytesAllocated, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE GCInterface_RemoveMemoryPressure(UINT64 bytesAllocated, QCallException* qcallError); +extern "C" void QCALLTYPE GCInterface_RemoveMemoryPressure(UINT64 bytesAllocated, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE GCInterface_ReRegisterForFinalize(QCall::ObjectHandleOnStack pObj, QCallException* qcallError); +extern "C" void QCALLTYPE GCInterface_ReRegisterForFinalize(QCall::ObjectHandleOnStack pObj, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE GCInterface_EnumerateConfigurationValues(void* configurationContext, EnumerateConfigurationValuesCallback callback, QCallException* qcallError); +extern "C" void QCALLTYPE GCInterface_EnumerateConfigurationValues(void* configurationContext, EnumerateConfigurationValuesCallback callback, QCallExceptionStatus* qcallError); -extern "C" int QCALLTYPE GCInterface_RefreshMemoryLimit(GCHeapHardLimitInfo heapHardLimitInfo, QCallException* qcallError); +extern "C" int QCALLTYPE GCInterface_RefreshMemoryLimit(GCHeapHardLimitInfo heapHardLimitInfo, QCallExceptionStatus* qcallError); -extern "C" enable_no_gc_region_callback_status QCALLTYPE GCInterface_EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, INT64 totalSize, QCallException* qcallError); +extern "C" enable_no_gc_region_callback_status QCALLTYPE GCInterface_EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, INT64 totalSize, QCallExceptionStatus* qcallError); -extern "C" uint64_t QCALLTYPE GCInterface_GetGenerationBudget(int generation, QCallException* qcallError); +extern "C" uint64_t QCALLTYPE GCInterface_GetGenerationBudget(int generation, QCallExceptionStatus* qcallError); // // EnvironmentNative @@ -241,18 +241,18 @@ class EnvironmentNative FCDECL0(static INT32, GetExitCode); }; -extern "C" void QCALLTYPE Environment_Exit(INT32 exitcode, QCallException* qcallError); +extern "C" void QCALLTYPE Environment_Exit(INT32 exitcode, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE Environment_FailFast(QCall::StackCrawlMarkHandle mark, PCWSTR message, QCall::ObjectHandleOnStack exception, PCWSTR errorSource, QCallException* qcallError); +extern "C" void QCALLTYPE Environment_FailFast(QCall::StackCrawlMarkHandle mark, PCWSTR message, QCall::ObjectHandleOnStack exception, PCWSTR errorSource, QCallExceptionStatus* qcallError); // Returns the number of logical processors that can be used by managed code -extern "C" INT32 QCALLTYPE Environment_GetProcessorCount(QCallException* qcallError); +extern "C" INT32 QCALLTYPE Environment_GetProcessorCount(QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE GetTypeLoadExceptionMessage(UINT32 resId, QCall::StringHandleOnStack retString, QCallException* qcallError); +extern "C" void QCALLTYPE GetTypeLoadExceptionMessage(UINT32 resId, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE GetFileLoadExceptionMessage(UINT32 hr, QCall::StringHandleOnStack retString, QCallException* qcallError); +extern "C" void QCALLTYPE GetFileLoadExceptionMessage(UINT32 hr, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE FileLoadException_GetMessageForHR(UINT32 hresult, QCall::StringHandleOnStack retString, QCallException* qcallError); +extern "C" void QCALLTYPE FileLoadException_GetMessageForHR(UINT32 hresult, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); class ObjectNative { @@ -261,8 +261,8 @@ class ObjectNative FCDECL2(static FC_BOOL_RET, ContentEquals, Object *pThisRef, Object *pCompareRef); }; -extern "C" INT32 QCALLTYPE ObjectNative_GetHashCodeSlow(QCall::ObjectHandleOnStack objHandle, QCallException* qcallError); -extern "C" void QCALLTYPE ObjectNative_AllocateUninitializedClone(QCall::ObjectHandleOnStack objHandle, QCallException* qcallError); +extern "C" INT32 QCALLTYPE ObjectNative_GetHashCodeSlow(QCall::ObjectHandleOnStack objHandle, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ObjectNative_AllocateUninitializedClone(QCall::ObjectHandleOnStack objHandle, QCallExceptionStatus* qcallError); class COMInterlocked { @@ -286,14 +286,14 @@ class MethodTableNative { FCDECL1(static OBJECTHANDLE, GetLoaderAllocatorHandle, MethodTable* mt); }; -extern "C" BOOL QCALLTYPE MethodTable_AreTypesEquivalent(MethodTable* mta, MethodTable* mtb, QCallException* qcallError); -extern "C" BOOL QCALLTYPE MethodTable_CanCompareBitsOrUseFastGetHashCode(MethodTable* mt, QCallException* qcallError); -extern "C" BOOL QCALLTYPE TypeHandle_CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd, QCallException* qcallError); +extern "C" BOOL QCALLTYPE MethodTable_AreTypesEquivalent(MethodTable* mta, MethodTable* mtb, QCallExceptionStatus* qcallError); +extern "C" BOOL QCALLTYPE MethodTable_CanCompareBitsOrUseFastGetHashCode(MethodTable* mt, QCallExceptionStatus* qcallError); +extern "C" BOOL QCALLTYPE TypeHandle_CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd, QCallExceptionStatus* qcallError); extern "C" INT32 QCALLTYPE TypeHandle_GetCorElementType(void* typeHnd); -extern "C" INT32 QCALLTYPE ValueType_GetHashCodeStrategy(MethodTable* mt, QCall::ObjectHandleOnStack objHandle, UINT32* fieldOffset, UINT32* fieldSize, MethodTable** fieldMT, QCallException* qcallError); +extern "C" INT32 QCALLTYPE ValueType_GetHashCodeStrategy(MethodTable* mt, QCall::ObjectHandleOnStack objHandle, UINT32* fieldOffset, UINT32* fieldSize, MethodTable** fieldMT, QCallExceptionStatus* qcallError); BOOL CanCompareBitsOrUseFastGetHashCode(MethodTable* mt); -extern "C" BOOL QCALLTYPE Stream_HasOverriddenSlow(MethodTable* pMT, BOOL isRead, QCallException* qcallError); +extern "C" BOOL QCALLTYPE Stream_HasOverriddenSlow(MethodTable* pMT, BOOL isRead, QCallExceptionStatus* qcallError); #endif // _COMUTILNATIVE_H_ diff --git a/src/coreclr/vm/coreassemblyspec.cpp b/src/coreclr/vm/coreassemblyspec.cpp index 8d8d5899c0c628..30d16fcd2196a3 100644 --- a/src/coreclr/vm/coreassemblyspec.cpp +++ b/src/coreclr/vm/coreassemblyspec.cpp @@ -184,7 +184,7 @@ void BaseAssemblySpec::Init(SString& assemblyDisplayName) parseAsAssemblySpec.InvokeThrowing(pAssemblyDisplayName, (void*)this); } -extern "C" void QCALLTYPE AssemblyName_InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, BaseAssemblySpec* pAssemblySpec, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyName_InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, BaseAssemblySpec* pAssemblySpec, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/customattribute.cpp b/src/coreclr/vm/customattribute.cpp index 8a6438827922dc..8896cf37f7a3b6 100644 --- a/src/coreclr/vm/customattribute.cpp +++ b/src/coreclr/vm/customattribute.cpp @@ -905,7 +905,7 @@ extern "C" void QCALLTYPE CustomAttribute_CreateCustomAttributeInstance( BYTE* pEndBlob, INT32* pcNamedArgs, QCall::ObjectHandleOnStack result, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1035,7 +1035,7 @@ extern "C" void QCALLTYPE CustomAttribute_CreatePropertyOrFieldData( BOOL* pbIsProperty, QCall::ObjectHandleOnStack pType, QCall::ObjectHandleOnStack pValue, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/customattribute.h b/src/coreclr/vm/customattribute.h index a1dfffe41de868..210cd238d85f07 100644 --- a/src/coreclr/vm/customattribute.h +++ b/src/coreclr/vm/customattribute.h @@ -38,7 +38,7 @@ extern "C" void QCALLTYPE CustomAttribute_CreateCustomAttributeInstance( BYTE* pEndBlob, INT32* pcNamedArgs, QCall::ObjectHandleOnStack result, - QCallException* qcallError); + QCallExceptionStatus* qcallError); extern "C" void QCALLTYPE CustomAttribute_CreatePropertyOrFieldData( QCall::ModuleHandle pModule, @@ -48,6 +48,6 @@ extern "C" void QCALLTYPE CustomAttribute_CreatePropertyOrFieldData( BOOL* pbIsProperty, QCall::ObjectHandleOnStack pType, QCall::ObjectHandleOnStack value, - QCallException* qcallError); + QCallExceptionStatus* qcallError); #endif // _CUSTOMATTRIBUTE_H_ diff --git a/src/coreclr/vm/debugdebugger.cpp b/src/coreclr/vm/debugdebugger.cpp index e8329647ef4bd7..043c9a486ef081 100644 --- a/src/coreclr/vm/debugdebugger.cpp +++ b/src/coreclr/vm/debugdebugger.cpp @@ -38,7 +38,7 @@ // Else if a native debugger is attached, this should send a native break event (kernel32!DebugBreak) // Else, this should invoke Watson. // -extern "C" void QCALLTYPE DebugDebugger_Break(QCallException* qcallError) +extern "C" void QCALLTYPE DebugDebugger_Break(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -294,7 +294,7 @@ static void GetStackFrames(DebugStackTrace::GetStackFramesData *pData) extern "C" void QCALLTYPE AsyncHelpers_AddContinuationToExInternal( void* diagnosticIP, QCall::ObjectHandleOnStack exception, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -323,7 +323,7 @@ extern "C" void QCALLTYPE StackTrace_GetStackFramesInternal( QCall::ObjectHandleOnStack stackFrameHelper, BOOL fNeedFileInfo, QCall::ObjectHandleOnStack exception, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -826,7 +826,7 @@ extern "C" void QCALLTYPE StackTrace_GetStackFramesInternal( END_QCALL; } -extern "C" MethodDesc* QCALLTYPE StackFrame_GetMethodDescFromNativeIP(LPVOID ip, QCallException* qcallError) +extern "C" MethodDesc* QCALLTYPE StackFrame_GetMethodDescFromNativeIP(LPVOID ip, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -865,7 +865,7 @@ using StrongHandleHolder = LifetimeHolder; // receives a custom notification object from the target and sends it to the RS via // code:Debugger::SendCustomDebuggerNotification // Argument: dataUNSAFE - a pointer the custom notification object being sent -extern "C" void QCALLTYPE DebugDebugger_CustomNotification(QCall::ObjectHandleOnStack data, QCallException* qcallError) +extern "C" void QCALLTYPE DebugDebugger_CustomNotification(QCall::ObjectHandleOnStack data, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/debugdebugger.h b/src/coreclr/vm/debugdebugger.h index 4eb9d455267cfd..d8d6cbc3f927df 100644 --- a/src/coreclr/vm/debugdebugger.h +++ b/src/coreclr/vm/debugdebugger.h @@ -13,10 +13,10 @@ #define __DEBUG_DEBUGGER_h__ #include -extern "C" void QCALLTYPE DebugDebugger_Break(QCallException* qcallError); +extern "C" void QCALLTYPE DebugDebugger_Break(QCallExceptionStatus* qcallError); extern "C" BOOL QCALLTYPE DebugDebugger_Launch(); extern "C" void QCALLTYPE DebugDebugger_Log(INT32 Level, PCWSTR pwzModule, PCWSTR pwzMessage); -extern "C" void QCALLTYPE DebugDebugger_CustomNotification(QCall::ObjectHandleOnStack data, QCallException* qcallError); +extern "C" void QCALLTYPE DebugDebugger_CustomNotification(QCall::ObjectHandleOnStack data, QCallExceptionStatus* qcallError); extern "C" BOOL QCALLTYPE DebugDebugger_IsLoggingHelper(); extern "C" BOOL QCALLTYPE DebugDebugger_IsManagedDebuggerAttached(); @@ -134,14 +134,14 @@ extern "C" void QCALLTYPE StackTrace_GetStackFramesInternal( QCall::ObjectHandleOnStack stackFrameHelper, BOOL fNeedFileInfo, QCall::ObjectHandleOnStack exception, - QCallException* qcallError); + QCallExceptionStatus* qcallError); extern "C" void QCALLTYPE AsyncHelpers_AddContinuationToExInternal( void* diagnosticIP, QCall::ObjectHandleOnStack exception, - QCallException* qcallError); + QCallExceptionStatus* qcallError); -extern "C" MethodDesc* QCALLTYPE StackFrame_GetMethodDescFromNativeIP(LPVOID ip, QCallException* qcallError); +extern "C" MethodDesc* QCALLTYPE StackFrame_GetMethodDescFromNativeIP(LPVOID ip, QCallExceptionStatus* qcallError); class ILToNativeMapArrays diff --git a/src/coreclr/vm/eventpipeinternal.cpp b/src/coreclr/vm/eventpipeinternal.cpp index dd5c5c08e8758c..7318261dd94110 100644 --- a/src/coreclr/vm/eventpipeinternal.cpp +++ b/src/coreclr/vm/eventpipeinternal.cpp @@ -20,7 +20,7 @@ extern "C" UINT64 QCALLTYPE EventPipeInternal_Enable( UINT32 circularBufferSizeInMB, /* COR_PRF_EVENTPIPE_PROVIDER_CONFIG */ LPCVOID pProviders, UINT32 numProviders, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -59,7 +59,7 @@ extern "C" UINT64 QCALLTYPE EventPipeInternal_Enable( return sessionID; } -extern "C" void QCALLTYPE EventPipeInternal_Disable(UINT64 sessionID, QCallException* qcallError) +extern "C" void QCALLTYPE EventPipeInternal_Disable(UINT64 sessionID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -68,7 +68,7 @@ extern "C" void QCALLTYPE EventPipeInternal_Disable(UINT64 sessionID, QCallExcep END_QCALL; } -extern "C" BOOL QCALLTYPE EventPipeInternal_GetSessionInfo(UINT64 sessionID, EventPipeSessionInfo *pSessionInfo, QCallException* qcallError) +extern "C" BOOL QCALLTYPE EventPipeInternal_GetSessionInfo(UINT64 sessionID, EventPipeSessionInfo *pSessionInfo, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -95,7 +95,7 @@ extern "C" INT_PTR QCALLTYPE EventPipeInternal_CreateProvider( _In_z_ LPCWSTR providerName, EventPipeCallback pCallbackFunc, void* pCallbackContext, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -118,7 +118,7 @@ extern "C" INT_PTR QCALLTYPE EventPipeInternal_DefineEvent( UINT32 level, void *pMetadata, UINT32 metadataLength, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -136,7 +136,7 @@ extern "C" INT_PTR QCALLTYPE EventPipeInternal_DefineEvent( return reinterpret_cast(pEvent); } -extern "C" INT_PTR QCALLTYPE EventPipeInternal_GetProvider(_In_z_ LPCWSTR providerName, QCallException* qcallError) +extern "C" INT_PTR QCALLTYPE EventPipeInternal_GetProvider(_In_z_ LPCWSTR providerName, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -151,7 +151,7 @@ extern "C" INT_PTR QCALLTYPE EventPipeInternal_GetProvider(_In_z_ LPCWSTR provid return reinterpret_cast(pProvider); } -extern "C" void QCALLTYPE EventPipeInternal_DeleteProvider(INT_PTR provHandle, QCallException* qcallError) +extern "C" void QCALLTYPE EventPipeInternal_DeleteProvider(INT_PTR provHandle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -165,7 +165,7 @@ extern "C" void QCALLTYPE EventPipeInternal_DeleteProvider(INT_PTR provHandle, Q END_QCALL; } -extern "C" int QCALLTYPE EventPipeInternal_EventActivityIdControl(uint32_t controlCode, GUID *pActivityId, QCallException* qcallError) +extern "C" int QCALLTYPE EventPipeInternal_EventActivityIdControl(uint32_t controlCode, GUID *pActivityId, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -229,7 +229,7 @@ extern "C" void QCALLTYPE EventPipeInternal_WriteEventData( UINT32 eventDataCount, LPCGUID pActivityId, LPCGUID pRelatedActivityId, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -241,7 +241,7 @@ extern "C" void QCALLTYPE EventPipeInternal_WriteEventData( END_QCALL; } -extern "C" BOOL QCALLTYPE EventPipeInternal_GetNextEvent(UINT64 sessionID, EventPipeEventInstanceData *pInstance, QCallException* qcallError) +extern "C" BOOL QCALLTYPE EventPipeInternal_GetNextEvent(UINT64 sessionID, EventPipeEventInstanceData *pInstance, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -267,7 +267,7 @@ extern "C" BOOL QCALLTYPE EventPipeInternal_GetNextEvent(UINT64 sessionID, Event return pNextInstance != NULL; } -extern "C" BOOL QCALLTYPE EventPipeInternal_SignalSession(UINT64 sessionID, QCallException* qcallError) +extern "C" BOOL QCALLTYPE EventPipeInternal_SignalSession(UINT64 sessionID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -280,7 +280,7 @@ extern "C" BOOL QCALLTYPE EventPipeInternal_SignalSession(UINT64 sessionID, QCal return result; } -extern "C" BOOL QCALLTYPE EventPipeInternal_WaitForSessionSignal(UINT64 sessionID, INT32 timeoutMs, QCallException* qcallError) +extern "C" BOOL QCALLTYPE EventPipeInternal_WaitForSessionSignal(UINT64 sessionID, INT32 timeoutMs, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/eventpipeinternal.h b/src/coreclr/vm/eventpipeinternal.h index 8ded1c2ca5d138..09cb9acedaca28 100644 --- a/src/coreclr/vm/eventpipeinternal.h +++ b/src/coreclr/vm/eventpipeinternal.h @@ -45,20 +45,20 @@ extern "C" UINT64 QCALLTYPE EventPipeInternal_Enable( UINT32 circularBufferSizeInMB, /* COR_PRF_EVENTPIPE_PROVIDER_CONFIG */ LPCVOID pProviders, UINT32 numProviders, - QCallException* qcallError); + QCallExceptionStatus* qcallError); //! //! Disables the specified session Id. //! -extern "C" void QCALLTYPE EventPipeInternal_Disable(UINT64 sessionID, QCallException* qcallError); +extern "C" void QCALLTYPE EventPipeInternal_Disable(UINT64 sessionID, QCallExceptionStatus* qcallError); -extern "C" BOOL QCALLTYPE EventPipeInternal_GetSessionInfo(UINT64 sessionID, EventPipeSessionInfo *pSessionInfo, QCallException* qcallError); +extern "C" BOOL QCALLTYPE EventPipeInternal_GetSessionInfo(UINT64 sessionID, EventPipeSessionInfo *pSessionInfo, QCallExceptionStatus* qcallError); extern "C" INT_PTR QCALLTYPE EventPipeInternal_CreateProvider( _In_z_ LPCWSTR providerName, EventPipeCallback pCallbackFunc, void* pCallbackContext, - QCallException* qcallError); + QCallExceptionStatus* qcallError); extern "C" INT_PTR QCALLTYPE EventPipeInternal_DefineEvent( INT_PTR provHandle, @@ -68,41 +68,41 @@ extern "C" INT_PTR QCALLTYPE EventPipeInternal_DefineEvent( UINT32 level, void *pMetadata, UINT32 metadataLength, - QCallException* qcallError); + QCallExceptionStatus* qcallError); extern "C" INT_PTR QCALLTYPE EventPipeInternal_GetProvider( _In_z_ LPCWSTR providerName, - QCallException* qcallError); + QCallExceptionStatus* qcallError); extern "C" void QCALLTYPE EventPipeInternal_DeleteProvider( INT_PTR provHandle, - QCallException* qcallError); + QCallExceptionStatus* qcallError); extern "C" int QCALLTYPE EventPipeInternal_EventActivityIdControl( UINT32 controlCode, GUID *pActivityId, - QCallException* qcallError); + QCallExceptionStatus* qcallError); extern "C" void QCALLTYPE EventPipeInternal_WriteEventData( INT_PTR eventHandle, EventData *pEventData, UINT32 eventDataCount, LPCGUID pActivityId, LPCGUID pRelatedActivityId, - QCallException* qcallError); + QCallExceptionStatus* qcallError); extern "C" BOOL QCALLTYPE EventPipeInternal_GetNextEvent( UINT64 sessionID, EventPipeEventInstanceData *pInstance, - QCallException* qcallError); + QCallExceptionStatus* qcallError); extern "C" BOOL QCALLTYPE EventPipeInternal_SignalSession( UINT64 sessionID, - QCallException* qcallError); + QCallExceptionStatus* qcallError); extern "C" BOOL QCALLTYPE EventPipeInternal_WaitForSessionSignal( UINT64 sessionID, INT32 timeoutMs, - QCallException* qcallError); + QCallExceptionStatus* qcallError); #endif // FEATURE_PERFTRACING diff --git a/src/coreclr/vm/excep.cpp b/src/coreclr/vm/excep.cpp index 6e41fe3800b79b..a2565a2808d087 100644 --- a/src/coreclr/vm/excep.cpp +++ b/src/coreclr/vm/excep.cpp @@ -4736,7 +4736,7 @@ static BOOL GetManagedFormatStringForResourceID(UINT32 resId, SString & converte //========================================================================== // Private helper for TypeLoadException. //========================================================================== -extern "C" void QCALLTYPE GetTypeLoadExceptionMessage(UINT32 resId, QCall::StringHandleOnStack retString, QCallException* qcallError) +extern "C" void QCALLTYPE GetTypeLoadExceptionMessage(UINT32 resId, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -4755,7 +4755,7 @@ extern "C" void QCALLTYPE GetTypeLoadExceptionMessage(UINT32 resId, QCall::Strin // Private helper for FileLoadException and FileNotFoundException. //========================================================================== -extern "C" void QCALLTYPE GetFileLoadExceptionMessage(UINT32 hr, QCall::StringHandleOnStack retString, QCallException* qcallError) +extern "C" void QCALLTYPE GetFileLoadExceptionMessage(UINT32 hr, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -4771,7 +4771,7 @@ extern "C" void QCALLTYPE GetFileLoadExceptionMessage(UINT32 hr, QCall::StringHa //========================================================================== // Private helper for FileLoadException and FileNotFoundException. //========================================================================== -extern "C" void QCALLTYPE FileLoadException_GetMessageForHR(UINT32 hresult, QCall::StringHandleOnStack retString, QCallException* qcallError) +extern "C" void QCALLTYPE FileLoadException_GetMessageForHR(UINT32 hresult, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -6656,7 +6656,7 @@ void UnwindAndContinueRethrowHelperInsideCatch(Frame* pEntryFrame, Exception* pE // void UnwindAndContinueRethrowHelperInsideQcallCatch( Exception* pException, - QCallException* pQCallException DEBUG_ARG(Frame* pEntryFrame)) + QCallExceptionStatus* pQCallException DEBUG_ARG(Frame* pEntryFrame)) { STATIC_CONTRACT_NOTHROW; STATIC_CONTRACT_GC_TRIGGERS; @@ -6701,7 +6701,7 @@ void UnwindAndContinueRethrowHelperInsideQcallCatch( } #ifdef TARGET_UNIX -void CaptureQCallExceptionFromPALException(PAL_SEHException& exception, QCallException* pQCallException) +void CaptureQCallExceptionFromPALException(PAL_SEHException& exception, QCallExceptionStatus* pQCallException) { STATIC_CONTRACT_NOTHROW; STATIC_CONTRACT_GC_TRIGGERS; diff --git a/src/coreclr/vm/exceptionhandling.cpp b/src/coreclr/vm/exceptionhandling.cpp index d8e536ccf7c59e..4a7aa0696858a1 100644 --- a/src/coreclr/vm/exceptionhandling.cpp +++ b/src/coreclr/vm/exceptionhandling.cpp @@ -3133,7 +3133,7 @@ static TADDR GetSpForDiagnosticReporting(REGDISPLAY *pRD) #endif } -extern "C" void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo, QCallException* qcallError) +extern "C" void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -3530,7 +3530,7 @@ void CallFinallyFunclet(BYTE* pHandlerIP, REGDISPLAY* pvRegDisplay, ExInfo* exIn exInfo->MakeCallbacksRelatedToHandler(false, pThread, pMD, &exInfo->m_CurrentClause, (DWORD_PTR)pHandlerIP, spForDebugger); } -extern "C" CLR_BOOL QCALLTYPE CallFilterFunclet(QCall::ObjectHandleOnStack exceptionObj, BYTE* pFilterIP, REGDISPLAY* pvRegDisplay, QCallException* qcallError) +extern "C" CLR_BOOL QCALLTYPE CallFilterFunclet(QCall::ObjectHandleOnStack exceptionObj, BYTE* pFilterIP, REGDISPLAY* pvRegDisplay, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -3698,7 +3698,7 @@ CLR_BOOL EHEnumNextWorker(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClause* pEHClause, return result; } -extern "C" CLR_BOOL QCALLTYPE EHEnumNext(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClause* pEHClause, QCallException* qcallError) +extern "C" CLR_BOOL QCALLTYPE EHEnumNext(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClause* pEHClause, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -4050,7 +4050,7 @@ CLR_BOOL SfiInitWorker(StackFrameIterator* pThis, CONTEXT* pStackwalkCtx, CLR_BO return result; } -extern "C" CLR_BOOL QCALLTYPE SfiInit(StackFrameIterator* pThis, CONTEXT* pStackwalkCtx, CLR_BOOL instructionFault, CLR_BOOL* pfIsExceptionIntercepted, QCallException* qcallError) +extern "C" CLR_BOOL QCALLTYPE SfiInit(StackFrameIterator* pThis, CONTEXT* pStackwalkCtx, CLR_BOOL instructionFault, CLR_BOOL* pfIsExceptionIntercepted, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -4372,7 +4372,7 @@ Exit:; return success; } -extern "C" CLR_BOOL QCALLTYPE SfiNext(StackFrameIterator* pThis, uint* uExCollideClauseIdx, CLR_BOOL* fUnwoundReversePInvoke, CLR_BOOL* pfIsExceptionIntercepted, QCallException* qcallError) +extern "C" CLR_BOOL QCALLTYPE SfiNext(StackFrameIterator* pThis, uint* uExCollideClauseIdx, CLR_BOOL* fUnwoundReversePInvoke, CLR_BOOL* pfIsExceptionIntercepted, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/exceptionhandlingqcalls.h b/src/coreclr/vm/exceptionhandlingqcalls.h index b0a933a8aa3fcf..ddb20be42aa651 100644 --- a/src/coreclr/vm/exceptionhandlingqcalls.h +++ b/src/coreclr/vm/exceptionhandlingqcalls.h @@ -9,12 +9,12 @@ struct ExInfo; #ifndef DACCESS_COMPILE -extern "C" CLR_BOOL QCALLTYPE CallFilterFunclet(QCall::ObjectHandleOnStack exceptionObj, BYTE* pFilterP, REGDISPLAY* pvRegDisplay, QCallException* qcallError); -extern "C" void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo, QCallException* qcallError); +extern "C" CLR_BOOL QCALLTYPE CallFilterFunclet(QCall::ObjectHandleOnStack exceptionObj, BYTE* pFilterP, REGDISPLAY* pvRegDisplay, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo, QCallExceptionStatus* qcallError); extern "C" CLR_BOOL QCALLTYPE EHEnumInitFromStackFrameIterator(StackFrameIterator *pFrameIter, IJitManager::MethodRegionInfo *pMethodRegionInfo, EH_CLAUSE_ENUMERATOR * pEHEnum); -extern "C" CLR_BOOL QCALLTYPE EHEnumNext(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClause* pEHClause, QCallException* qcallError); -extern "C" CLR_BOOL QCALLTYPE SfiInit(StackFrameIterator* pThis, CONTEXT* pStackwalkCtx, CLR_BOOL instructionFault, CLR_BOOL* pIsExceptionIntercepted, QCallException* qcallError); -extern "C" CLR_BOOL QCALLTYPE SfiNext(StackFrameIterator* pThis, unsigned int* uExCollideClauseIdx, CLR_BOOL* fUnwoundReversePInvoke, CLR_BOOL* pIsExceptionIntercepted, QCallException* qcallError); +extern "C" CLR_BOOL QCALLTYPE EHEnumNext(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClause* pEHClause, QCallExceptionStatus* qcallError); +extern "C" CLR_BOOL QCALLTYPE SfiInit(StackFrameIterator* pThis, CONTEXT* pStackwalkCtx, CLR_BOOL instructionFault, CLR_BOOL* pIsExceptionIntercepted, QCallExceptionStatus* qcallError); +extern "C" CLR_BOOL QCALLTYPE SfiNext(StackFrameIterator* pThis, unsigned int* uExCollideClauseIdx, CLR_BOOL* fUnwoundReversePInvoke, CLR_BOOL* pIsExceptionIntercepted, QCallExceptionStatus* qcallError); #endif // DACCESS_COMPILE #endif // EXCEPTION_HANDLING_QCALLS_H diff --git a/src/coreclr/vm/exceptmacros.h b/src/coreclr/vm/exceptmacros.h index 79255431d8c077..b6d4184387542b 100644 --- a/src/coreclr/vm/exceptmacros.h +++ b/src/coreclr/vm/exceptmacros.h @@ -193,7 +193,7 @@ extern LONG InternalUnhandledExceptionFilter_Worker(PEXCEPTION_POINTERS pExcepti VOID DECLSPEC_NORETURN RaiseTheExceptionInternalOnly(OBJECTREF throwable); -struct QCallException; +struct QCallExceptionStatus; #if defined(DACCESS_COMPILE) @@ -204,7 +204,7 @@ struct QCallException; #define UNINSTALL_UNWIND_AND_CONTINUE_HANDLER_EX #else // DACCESS_COMPILE -struct QCallException +struct QCallExceptionStatus { private: INT32 m_exceptionPending; @@ -221,10 +221,10 @@ struct QCallException void UnwindAndContinueRethrowHelperInsideCatch(Frame* pEntryFrame, Exception* pException); void UnwindAndContinueRethrowHelperInsideQcallCatch( Exception* pException, - QCallException* pQCallException DEBUG_ARG(Frame* pEntryFrame)); + QCallExceptionStatus* pQCallException DEBUG_ARG(Frame* pEntryFrame)); #ifdef TARGET_UNIX -void CaptureQCallExceptionFromPALException(PAL_SEHException& exception, QCallException* pQCallException); +void CaptureQCallExceptionFromPALException(PAL_SEHException& exception, QCallExceptionStatus* pQCallException); #endif VOID DECLSPEC_NORETURN UnwindAndContinueRethrowHelperAfterCatch(Frame* pEntryFrame, Exception* pException, bool nativeRethrow); diff --git a/src/coreclr/vm/finalizerthread.cpp b/src/coreclr/vm/finalizerthread.cpp index 44151fbf24a41c..5cdc4ed9438027 100644 --- a/src/coreclr/vm/finalizerthread.cpp +++ b/src/coreclr/vm/finalizerthread.cpp @@ -87,7 +87,7 @@ extern "C" void SystemJS_ExecuteFinalizationCallback() RunFinalizerIterationOnCurrentThread(); } #else // TARGET_WASI -extern "C" void QCALLTYPE WasiFinalizer_RunWorker(QCallException* qcallError) +extern "C" void QCALLTYPE WasiFinalizer_RunWorker(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -128,7 +128,7 @@ extern "C" void WasiFinalizer_Schedule() s_finalizationPending = true; } -extern "C" CLR_BOOL QCALLTYPE WasiFinalizer_TryClearPending(QCallException* qcallError) +extern "C" CLR_BOOL QCALLTYPE WasiFinalizer_TryClearPending(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; CLR_BOOL pending = FALSE; diff --git a/src/coreclr/vm/ilmarshalers.cpp b/src/coreclr/vm/ilmarshalers.cpp index b81cc6e6b6cb72..eda4968a4b558c 100644 --- a/src/coreclr/vm/ilmarshalers.cpp +++ b/src/coreclr/vm/ilmarshalers.cpp @@ -4759,7 +4759,7 @@ extern "C" void QCALLTYPE MngdSafeArrayMarshaler_CreateMarshaler(MngdSafeArrayMa pThis->m_pConvertContentsToManagedCode = pConvertToManaged; } -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallException* qcallError) +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -4797,7 +4797,7 @@ extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToNative(MngdSafeAr END_QCALL; } -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCall::ObjectHandleOnStack pOriginalManaged, QCallException* qcallError) +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCall::ObjectHandleOnStack pOriginalManaged, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -4840,7 +4840,7 @@ extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToNative(MngdSaf END_QCALL; } -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallException* qcallError) +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -4897,7 +4897,7 @@ extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToManaged(MngdSafeA END_QCALL; } -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallException* qcallError) +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -4934,7 +4934,7 @@ extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToManaged(MngdSa END_QCALL; } -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ClearNative(MngdSafeArrayMarshaler* pThis, void** pNativeHome, QCallException* qcallError) +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ClearNative(MngdSafeArrayMarshaler* pThis, void** pNativeHome, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/ilmarshalers.h b/src/coreclr/vm/ilmarshalers.h index 25241db22e94d0..28145ae40ca3a1 100644 --- a/src/coreclr/vm/ilmarshalers.h +++ b/src/coreclr/vm/ilmarshalers.h @@ -3463,11 +3463,11 @@ class MngdSafeArrayMarshaler }; extern "C" void QCALLTYPE MngdSafeArrayMarshaler_CreateMarshaler(MngdSafeArrayMarshaler* pThis, MethodTable* pMT, UINT32 iRank, UINT32 dwFlags, PCODE pConvertToNative, PCODE pConvertToManaged); -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallException* qcallError); -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCall::ObjectHandleOnStack pOriginalManaged, QCallException* qcallError); -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallException* qcallError); -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallException* qcallError); -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ClearNative(MngdSafeArrayMarshaler* pThis, void** pNativeHome, QCallException* qcallError); +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCall::ObjectHandleOnStack pOriginalManaged, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ClearNative(MngdSafeArrayMarshaler* pThis, void** pNativeHome, QCallExceptionStatus* qcallError); #endif // FEATURE_COMINTEROP class ILReferenceCustomMarshaler : public ILMngdMarshaler diff --git a/src/coreclr/vm/interoplibinterface.h b/src/coreclr/vm/interoplibinterface.h index 0a0e3194b76611..c9da0f7eaeeef3 100644 --- a/src/coreclr/vm/interoplibinterface.h +++ b/src/coreclr/vm/interoplibinterface.h @@ -72,9 +72,9 @@ extern "C" BOOL QCALLTYPE ObjCMarshal_TryInitializeReferenceTracker( _In_ ObjCMarshalNative::IsReferencedCallback isReferencedCallback, _In_ ObjCMarshalNative::EnteredFinalizationCallback trackedObjectEnteredFinalization, _In_ QCall::ObjectHandleOnStack objectTrackingInfoTable, - QCallException* qcallError); + QCallExceptionStatus* qcallError); -extern "C" void* QCALLTYPE ObjCMarshal_AllocateReferenceTrackingHandle(_In_ QCall::ObjectHandleOnStack obj, QCallException* qcallError); +extern "C" void* QCALLTYPE ObjCMarshal_AllocateReferenceTrackingHandle(_In_ QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError); extern "C" void QCALLTYPE ObjCMarshal_GetOrCreateReferenceTrackingMemory( _In_ QCall::ObjectHandleOnStack obj, @@ -84,7 +84,7 @@ extern "C" void QCALLTYPE ObjCMarshal_GetOrCreateReferenceTrackingMemory( extern "C" BOOL QCALLTYPE ObjCMarshal_TrySetGlobalMessageSendCallback( _In_ ObjCMarshalNative::MessageSendFunction msgSendFunction, _In_ void* fptr, - QCallException* qcallError); + QCallExceptionStatus* qcallError); #endif // FEATURE_OBJCMARSHAL @@ -98,18 +98,18 @@ class JavaNative extern "C" BOOL QCALLTYPE JavaMarshal_Initialize( _In_ void* markCrossReferences, - QCallException* qcallError); + QCallExceptionStatus* qcallError); extern "C" void* QCALLTYPE JavaMarshal_CreateReferenceTrackingHandle( _In_ QCall::ObjectHandleOnStack obj, _In_ void* context, - QCallException* qcallError); + QCallExceptionStatus* qcallError); extern "C" void QCALLTYPE JavaMarshal_FinishCrossReferenceProcessing( _In_ MarkCrossReferencesArgs *crossReferences, _In_ size_t length, _In_ void* unreachableObjectHandles, - QCallException* qcallError); + QCallExceptionStatus* qcallError); extern "C" BOOL QCALLTYPE JavaMarshal_GetContext( _In_ OBJECTHANDLE handle, diff --git a/src/coreclr/vm/interoplibinterface_comwrappers.cpp b/src/coreclr/vm/interoplibinterface_comwrappers.cpp index d31df184d3534a..6ec4e56fc28f16 100644 --- a/src/coreclr/vm/interoplibinterface_comwrappers.cpp +++ b/src/coreclr/vm/interoplibinterface_comwrappers.cpp @@ -112,7 +112,7 @@ bool GlobalComWrappersForMarshalling::TryGetOrCreateObjectForComInstance( return obj != NULL; } -extern "C" void* QCALLTYPE ComWrappers_AllocateRefCountedHandle(_In_ QCall::ObjectHandleOnStack obj, QCallException* qcallError) +extern "C" void* QCALLTYPE ComWrappers_AllocateRefCountedHandle(_In_ QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -564,7 +564,7 @@ void ComWrappersNative::OnAfterGCScanRoots() (void)InteropLib::Com::DetachNonPromotedObjects(&cxt); } -extern "C" void QCALLTYPE ComWrappers_RegisterIsRootedCallback(QCallException* qcallError) +extern "C" void QCALLTYPE ComWrappers_RegisterIsRootedCallback(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -576,7 +576,7 @@ extern "C" void QCALLTYPE ComWrappers_RegisterIsRootedCallback(QCallException* q END_QCALL; } -extern "C" void QCALLTYPE TrackerObjectManager_RegisterNativeObjectWrapperCache(_In_ QCall::ObjectHandleOnStack cache, QCallException* qcallError) +extern "C" void QCALLTYPE TrackerObjectManager_RegisterNativeObjectWrapperCache(_In_ QCall::ObjectHandleOnStack cache, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/interoplibinterface_comwrappers.h b/src/coreclr/vm/interoplibinterface_comwrappers.h index 2bb07e40b30c91..61e414b1389f78 100644 --- a/src/coreclr/vm/interoplibinterface_comwrappers.h +++ b/src/coreclr/vm/interoplibinterface_comwrappers.h @@ -34,19 +34,19 @@ extern "C" void QCALLTYPE ComWrappers_GetIUnknownImpl( extern "C" void* QCALLTYPE ComWrappers_GetUntrackedAddRefRelease(); -extern "C" void* QCALLTYPE ComWrappers_AllocateRefCountedHandle(_In_ QCall::ObjectHandleOnStack obj, QCallException* qcallError); +extern "C" void* QCALLTYPE ComWrappers_AllocateRefCountedHandle(_In_ QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError); extern "C" void const* QCALLTYPE ComWrappers_GetIReferenceTrackerTargetVftbl(); extern "C" void const* QCALLTYPE ComWrappers_GetTaggedImpl(); -extern "C" void QCALLTYPE ComWrappers_RegisterIsRootedCallback(QCallException* qcallError); +extern "C" void QCALLTYPE ComWrappers_RegisterIsRootedCallback(QCallExceptionStatus* qcallError); extern "C" CLR_BOOL QCALLTYPE TrackerObjectManager_HasReferenceTrackerManager(); extern "C" CLR_BOOL QCALLTYPE TrackerObjectManager_TryRegisterReferenceTrackerManager(_In_ void* manager); -extern "C" void QCALLTYPE TrackerObjectManager_RegisterNativeObjectWrapperCache(_In_ QCall::ObjectHandleOnStack cache, QCallException* qcallError); +extern "C" void QCALLTYPE TrackerObjectManager_RegisterNativeObjectWrapperCache(_In_ QCall::ObjectHandleOnStack cache, QCallExceptionStatus* qcallError); extern "C" CLR_BOOL QCALLTYPE TrackerObjectManager_IsGlobalPeggingEnabled(); diff --git a/src/coreclr/vm/interoplibinterface_java.cpp b/src/coreclr/vm/interoplibinterface_java.cpp index fd1635b9d812f6..59784c08d20192 100644 --- a/src/coreclr/vm/interoplibinterface_java.cpp +++ b/src/coreclr/vm/interoplibinterface_java.cpp @@ -136,7 +136,7 @@ void Interop::FinishCrossReferenceProcessing( extern "C" BOOL QCALLTYPE JavaMarshal_Initialize( _In_ void* markCrossReferences, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(markCrossReferences != NULL); @@ -166,7 +166,7 @@ extern "C" BOOL QCALLTYPE JavaMarshal_Initialize( extern "C" void* QCALLTYPE JavaMarshal_CreateReferenceTrackingHandle( _In_ QCall::ObjectHandleOnStack obj, _In_ void* context, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -186,7 +186,7 @@ extern "C" void QCALLTYPE JavaMarshal_FinishCrossReferenceProcessing( _In_ MarkCrossReferencesArgs *crossReferences, _In_ size_t length, _In_ void* unreachableObjectHandles, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(crossReferences->ComponentCount >= 0); diff --git a/src/coreclr/vm/interoplibinterface_objc.cpp b/src/coreclr/vm/interoplibinterface_objc.cpp index 99421808548dc1..18330649847af3 100644 --- a/src/coreclr/vm/interoplibinterface_objc.cpp +++ b/src/coreclr/vm/interoplibinterface_objc.cpp @@ -29,7 +29,7 @@ extern "C" BOOL QCALLTYPE ObjCMarshal_TryInitializeReferenceTracker( _In_ ObjCMarshalNative::IsReferencedCallback isReferencedCallback, _In_ ObjCMarshalNative::EnteredFinalizationCallback trackedObjectEnteredFinalization, _In_ QCall::ObjectHandleOnStack objectTrackingInfoTable, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(beginEndCallback != NULL @@ -61,7 +61,7 @@ extern "C" BOOL QCALLTYPE ObjCMarshal_TryInitializeReferenceTracker( return success; } -extern "C" void* QCALLTYPE ObjCMarshal_AllocateReferenceTrackingHandle(_In_ QCall::ObjectHandleOnStack obj, QCallException* qcallError) +extern "C" void* QCALLTYPE ObjCMarshal_AllocateReferenceTrackingHandle(_In_ QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -123,7 +123,7 @@ namespace extern "C" BOOL QCALLTYPE ObjCMarshal_TrySetGlobalMessageSendCallback( _In_ ObjCMarshalNative::MessageSendFunction msgSendFunction, _In_ void* fptr, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/jithelpers.cpp b/src/coreclr/vm/jithelpers.cpp index 013fec944749d6..0689a5b57b0648 100644 --- a/src/coreclr/vm/jithelpers.cpp +++ b/src/coreclr/vm/jithelpers.cpp @@ -245,7 +245,7 @@ HCIMPLEND #include // Helper for the managed InitClass implementations -extern "C" void QCALLTYPE InitClassHelper(MethodTable* pMT, QCallException* qcallError) +extern "C" void QCALLTYPE InitClassHelper(MethodTable* pMT, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -318,7 +318,7 @@ __declspec(selectany) #endif // _MSC_VER PLATFORM_THREAD_LOCAL ThreadLocalData t_ThreadStatics; -extern "C" void QCALLTYPE GetThreadStaticsByMethodTable(QCall::ByteRefOnStack refHandle, MethodTable* pMT, bool gcStatic, QCallException* qcallError) +extern "C" void QCALLTYPE GetThreadStaticsByMethodTable(QCall::ByteRefOnStack refHandle, MethodTable* pMT, bool gcStatic, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -339,7 +339,7 @@ extern "C" void QCALLTYPE GetThreadStaticsByMethodTable(QCall::ByteRefOnStack re END_QCALL; } -extern "C" void QCALLTYPE GetThreadStaticsByIndex(QCall::ByteRefOnStack refHandle, uint32_t staticBlockIndex, bool gcStatic, QCallException* qcallError) +extern "C" void QCALLTYPE GetThreadStaticsByIndex(QCall::ByteRefOnStack refHandle, uint32_t staticBlockIndex, bool gcStatic, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -473,7 +473,7 @@ BOOL ObjIsInstanceOf(Object* pObject, TypeHandle toTypeHnd, BOOL throwCastExcept return ObjIsInstanceOfCore(pObject, toTypeHnd, throwCastException); } -extern "C" BOOL QCALLTYPE IsInstanceOf_NoCacheLookup(EnregisteredTypeHandle type, BOOL throwCastException, QCall::ObjectHandleOnStack objOnStack, QCallException* qcallError) +extern "C" BOOL QCALLTYPE IsInstanceOf_NoCacheLookup(EnregisteredTypeHandle type, BOOL throwCastException, QCall::ObjectHandleOnStack objOnStack, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BOOL result = FALSE; @@ -502,7 +502,7 @@ HCIMPL2(BOOL, JIT_IsInstanceOfException, EnregisteredTypeHandle type, Object* ob } HCIMPLEND -extern "C" void QCALLTYPE ThrowInvalidCastException(EnregisteredTypeHandle pSourceType, EnregisteredTypeHandle pTargetType, QCallException* qcallError) +extern "C" void QCALLTYPE ThrowInvalidCastException(EnregisteredTypeHandle pSourceType, EnregisteredTypeHandle pTargetType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -600,7 +600,7 @@ DictionaryEntry GenericHandleWorkerCore(MethodDesc * pMD, MethodTable * pMT, LPV return result; } -extern "C" void* QCALLTYPE GenericHandleWorker(MethodDesc * pMD, MethodTable * pMT, LPVOID signature, DWORD dictionaryIndexAndSlot, Module* pModule, QCallException* qcallError) +extern "C" void* QCALLTYPE GenericHandleWorker(MethodDesc * pMD, MethodTable * pMT, LPVOID signature, DWORD dictionaryIndexAndSlot, Module* pModule, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -676,7 +676,7 @@ void FlushVirtualFunctionPointerCaches() extern "C" PCODE QCALLTYPE ResolveVirtualFunctionPointer(QCall::ObjectHandleOnStack obj, EnregisteredTypeHandle classHnd, MethodDesc* pStaticMD, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/loaderallocator.cpp b/src/coreclr/vm/loaderallocator.cpp index ee39679533296a..0612b3eb784253 100644 --- a/src/coreclr/vm/loaderallocator.cpp +++ b/src/coreclr/vm/loaderallocator.cpp @@ -757,7 +757,7 @@ BOOL LoaderAllocator::Destroy(QCall::LoaderAllocatorHandle pLoaderAllocator) return FALSE; } // LoaderAllocator::Destroy -extern "C" BOOL QCALLTYPE LoaderAllocator_Destroy(QCall::LoaderAllocatorHandle pLoaderAllocator, QCallException* qcallError) +extern "C" BOOL QCALLTYPE LoaderAllocator_Destroy(QCall::LoaderAllocatorHandle pLoaderAllocator, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/loaderallocator.hpp b/src/coreclr/vm/loaderallocator.hpp index f9cc45d613af1b..5c717beebad038 100644 --- a/src/coreclr/vm/loaderallocator.hpp +++ b/src/coreclr/vm/loaderallocator.hpp @@ -960,7 +960,7 @@ struct cdac_data typedef VPTR(LoaderAllocator) PTR_LoaderAllocator; -extern "C" BOOL QCALLTYPE LoaderAllocator_Destroy(QCall::LoaderAllocatorHandle pLoaderAllocator, QCallException* qcallError); +extern "C" BOOL QCALLTYPE LoaderAllocator_Destroy(QCall::LoaderAllocatorHandle pLoaderAllocator, QCallExceptionStatus* qcallError); class GlobalLoaderAllocator : public LoaderAllocator { diff --git a/src/coreclr/vm/managedmdimport.cpp b/src/coreclr/vm/managedmdimport.cpp index 85dfbf5e222291..e83ccc2ae32517 100644 --- a/src/coreclr/vm/managedmdimport.cpp +++ b/src/coreclr/vm/managedmdimport.cpp @@ -540,7 +540,7 @@ extern "C" void QCALLTYPE MetadataImport_Enum( /* in/out */ INT32* length, INT32* shortResult, QCall::ObjectHandleOnStack longResult, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { CONTRACTL { diff --git a/src/coreclr/vm/managedmdimport.hpp b/src/coreclr/vm/managedmdimport.hpp index 0ed23a3fcc517d..b0d8fcf67f1ee6 100644 --- a/src/coreclr/vm/managedmdimport.hpp +++ b/src/coreclr/vm/managedmdimport.hpp @@ -79,6 +79,6 @@ extern "C" void QCALLTYPE MetadataImport_Enum( INT32* length, INT32* shortResult, QCall::ObjectHandleOnStack longResult, - QCallException* qcallError); + QCallExceptionStatus* qcallError); #endif diff --git a/src/coreclr/vm/marshalnative.cpp b/src/coreclr/vm/marshalnative.cpp index 205e865d8a68a4..9ad0896140dd2b 100644 --- a/src/coreclr/vm/marshalnative.cpp +++ b/src/coreclr/vm/marshalnative.cpp @@ -50,7 +50,7 @@ // Prelink // Does advance loading of an PInvoke library -extern "C" VOID QCALLTYPE MarshalNative_Prelink(MethodDesc * pMD, QCallException* qcallError) +extern "C" VOID QCALLTYPE MarshalNative_Prelink(MethodDesc * pMD, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -83,7 +83,7 @@ extern "C" VOID QCALLTYPE MarshalNative_Prelink(MethodDesc * pMD, QCallException // IsBuiltInComSupported // Built-in COM support is only checked from the native side to ensure the runtime // is in a consistent state -extern "C" BOOL QCALLTYPE MarshalNative_IsBuiltInComSupported(QCallException* qcallError) +extern "C" BOOL QCALLTYPE MarshalNative_IsBuiltInComSupported(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -102,7 +102,7 @@ extern "C" BOOL QCALLTYPE MarshalNative_IsBuiltInComSupported(QCallException* qc return ret; } -extern "C" BOOL QCALLTYPE MarshalNative_HasLayout(QCall::TypeHandle t, BOOL* pIsBlittable, DWORD* pNativeSize, QCallException* qcallError) +extern "C" BOOL QCALLTYPE MarshalNative_HasLayout(QCall::TypeHandle t, BOOL* pIsBlittable, DWORD* pNativeSize, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -139,7 +139,7 @@ extern "C" BOOL QCALLTYPE MarshalNative_HasLayout(QCall::TypeHandle t, BOOL* pIs /************************************************************************ * PInvoke.SizeOf(Class) */ -extern "C" INT32 QCALLTYPE MarshalNative_SizeOfHelper(QCall::TypeHandle t, BOOL throwIfNotMarshalable, QCallException* qcallError) +extern "C" INT32 QCALLTYPE MarshalNative_SizeOfHelper(QCall::TypeHandle t, BOOL throwIfNotMarshalable, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -169,7 +169,7 @@ extern "C" INT32 QCALLTYPE MarshalNative_SizeOfHelper(QCall::TypeHandle t, BOOL return rv; } -extern "C" SIZE_T QCALLTYPE MarshalNative_OffsetOf(FieldDesc* pFD, QCallException* qcallError) +extern "C" SIZE_T QCALLTYPE MarshalNative_OffsetOf(FieldDesc* pFD, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -221,7 +221,7 @@ extern "C" SIZE_T QCALLTYPE MarshalNative_OffsetOf(FieldDesc* pFD, QCallExceptio return offset; } -extern "C" void QCALLTYPE MarshalNative_GetDelegateForFunctionPointerInternal(PVOID FPtr, QCall::TypeHandle t, QCall::ObjectHandleOnStack retDelegate, QCallException* qcallError) +extern "C" void QCALLTYPE MarshalNative_GetDelegateForFunctionPointerInternal(PVOID FPtr, QCall::TypeHandle t, QCall::ObjectHandleOnStack retDelegate, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -238,7 +238,7 @@ extern "C" void QCALLTYPE MarshalNative_GetDelegateForFunctionPointerInternal(PV END_QCALL; } -extern "C" PVOID QCALLTYPE MarshalNative_GetFunctionPointerForDelegateInternal(QCall::ObjectHandleOnStack d, QCallException* qcallError) +extern "C" PVOID QCALLTYPE MarshalNative_GetFunctionPointerForDelegateInternal(QCall::ObjectHandleOnStack d, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -263,19 +263,11 @@ namespace } } -extern "C" IsInCooperativeGCMode_fn QCALLTYPE MarshalNative_GetIsInCooperativeGCModeFunctionPointer(QCallException* qcallError) +extern "C" IsInCooperativeGCMode_fn QCALLTYPE MarshalNative_GetIsInCooperativeGCModeFunctionPointer() { QCALL_CONTRACT; - IsInCooperativeGCMode_fn ret = NULL; - - BEGIN_QCALL; - - ret = IsInCooperativeGCMode; - - END_QCALL; - - return ret; + return IsInCooperativeGCMode; } #endif @@ -325,7 +317,7 @@ DWORD STDMETHODCALLTYPE FalseGetLastError() * Support for the GCHandle class. */ -extern "C" OBJECTHANDLE QCALLTYPE GCHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack obj, int type, QCallException* qcallError) +extern "C" OBJECTHANDLE QCALLTYPE GCHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack obj, int type, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -356,7 +348,7 @@ FCIMPL2(LPVOID, MarshalNative::GCHandleInternalAlloc, Object *obj, int type) } FCIMPLEND -extern "C" void QCALLTYPE GCHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle, QCallException* qcallError) +extern "C" void QCALLTYPE GCHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -416,7 +408,7 @@ FCIMPL2(FC_BOOL_RET, MarshalNative::GCHandleInternalTryGetBridgeWait, OBJECTHAND FCIMPLEND // Unlike the fast call above, this can block -extern "C" void QCALLTYPE GCHandle_InternalGetBridgeWait(OBJECTHANDLE handle, QCall::ObjectHandleOnStack result, QCallException* qcallError) +extern "C" void QCALLTYPE GCHandle_InternalGetBridgeWait(OBJECTHANDLE handle, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -466,7 +458,7 @@ FCIMPLEND // *** Interop Helpers *** //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetExceptionForHR(INT32 errorCode, LPVOID errorInfo, QCall::ObjectHandleOnStack retVal, QCallException* qcallError) +extern "C" void QCALLTYPE MarshalNative_GetExceptionForHR(INT32 errorCode, LPVOID errorInfo, QCall::ObjectHandleOnStack retVal, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -508,7 +500,7 @@ extern "C" void QCALLTYPE MarshalNative_GetExceptionForHR(INT32 errorCode, LPVOI } #ifdef FEATURE_COMINTEROP -extern "C" int32_t QCALLTYPE MarshalNative_GetHRForException(QCall::ObjectHandleOnStack obj, QCallException* qcallError) +extern "C" int32_t QCALLTYPE MarshalNative_GetHRForException(QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -533,7 +525,7 @@ extern "C" int32_t QCALLTYPE MarshalNative_GetHRForException(QCall::ObjectHandle //==================================================================== // return the IUnknown* for an Object. //==================================================================== -extern "C" IUnknown* QCALLTYPE MarshalNative_GetIUnknownForObject(QCall::ObjectHandleOnStack o, QCallException* qcallError) +extern "C" IUnknown* QCALLTYPE MarshalNative_GetIUnknownForObject(QCall::ObjectHandleOnStack o, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -558,7 +550,7 @@ extern "C" IUnknown* QCALLTYPE MarshalNative_GetIUnknownForObject(QCall::ObjectH //==================================================================== // return the IDispatch* for an Object. //==================================================================== -extern "C" IDispatch* QCALLTYPE MarshalNative_GetIDispatchForObject(QCall::ObjectHandleOnStack o, QCallException* qcallError) +extern "C" IDispatch* QCALLTYPE MarshalNative_GetIDispatchForObject(QCall::ObjectHandleOnStack o, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -583,7 +575,7 @@ extern "C" IDispatch* QCALLTYPE MarshalNative_GetIDispatchForObject(QCall::Objec //==================================================================== // return the IUnknown* or IDispatch* for an Object. //==================================================================== -extern "C" void* QCALLTYPE MarshalNative_GetIUnknownOrIDispatchForObject(QCall::ObjectHandleOnStack o, BOOL* isIDispatch, QCallException* qcallError) +extern "C" void* QCALLTYPE MarshalNative_GetIUnknownOrIDispatchForObject(QCall::ObjectHandleOnStack o, BOOL* isIDispatch, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -611,7 +603,7 @@ extern "C" void* QCALLTYPE MarshalNative_GetIUnknownOrIDispatchForObject(QCall:: // return the IUnknown* representing the interface for the Object // Object o should support Type T //==================================================================== -extern "C" IUnknown* QCALLTYPE MarshalNative_GetComInterfaceForObject(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, BOOL bEnableCustomizedQueryInterface, QCallException* qcallError) +extern "C" IUnknown* QCALLTYPE MarshalNative_GetComInterfaceForObject(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, BOOL bEnableCustomizedQueryInterface, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -657,7 +649,7 @@ extern "C" IUnknown* QCALLTYPE MarshalNative_GetComInterfaceForObject(QCall::Obj //==================================================================== // return an Object for IUnknown //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject, QCallException* qcallError) +extern "C" void QCALLTYPE MarshalNative_GetObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -682,7 +674,7 @@ extern "C" void QCALLTYPE MarshalNative_GetObjectForIUnknown(IUnknown* pUnk, QCa END_QCALL; } -extern "C" void QCALLTYPE MarshalNative_GetUniqueObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject, QCallException* qcallError) +extern "C" void QCALLTYPE MarshalNative_GetUniqueObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -712,7 +704,7 @@ extern "C" void QCALLTYPE MarshalNative_GetUniqueObjectForIUnknown(IUnknown* pUn // NOTE: // Type T should be either a COM imported Type or a sub-type of COM imported Type //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetTypedObjectForIUnknown(IUnknown* pUnk, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject, QCallException* qcallError) +extern "C" void QCALLTYPE MarshalNative_GetTypedObjectForIUnknown(IUnknown* pUnk, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -744,7 +736,7 @@ extern "C" void QCALLTYPE MarshalNative_GetTypedObjectForIUnknown(IUnknown* pUnk END_QCALL; } -extern "C" IUnknown* QCALLTYPE MarshalNative_CreateAggregatedObject(IUnknown* pOuter, QCall::ObjectHandleOnStack o, QCallException* qcallError) +extern "C" IUnknown* QCALLTYPE MarshalNative_CreateAggregatedObject(IUnknown* pOuter, QCall::ObjectHandleOnStack o, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -787,7 +779,7 @@ extern "C" IUnknown* QCALLTYPE MarshalNative_CreateAggregatedObject(IUnknown* pO //==================================================================== // Free unused RCWs in the current CLR context. //==================================================================== -extern "C" void QCALLTYPE MarshalNative_CleanupUnusedObjectsInCurrentContext(QCallException* qcallError) +extern "C" void QCALLTYPE MarshalNative_CleanupUnusedObjectsInCurrentContext(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -826,7 +818,7 @@ FCIMPLEND // free the COM component and zombie this object if the ref count hits 0 // further usage of this Object might throw an exception, //==================================================================== -extern "C" INT32 QCALLTYPE MarshalNative_ReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, QCallException* qcallError) +extern "C" INT32 QCALLTYPE MarshalNative_ReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -858,7 +850,7 @@ extern "C" INT32 QCALLTYPE MarshalNative_ReleaseComObject(QCall::ObjectHandleOnS // free the COM component and zombie this object // further usage of this Object might throw an exception, //==================================================================== -extern "C" void QCALLTYPE MarshalNative_FinalReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, QCallException* qcallError) +extern "C" void QCALLTYPE MarshalNative_FinalReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -886,7 +878,7 @@ extern "C" void QCALLTYPE MarshalNative_FinalReleaseComObject(QCall::ObjectHandl // This method takes the given COM object and wraps it in an object // of the specified type. The type must be derived from __ComObject. //==================================================================== -extern "C" void QCALLTYPE MarshalNative_InternalCreateWrapperOfType(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject, QCallException* qcallError) +extern "C" void QCALLTYPE MarshalNative_InternalCreateWrapperOfType(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -948,7 +940,7 @@ extern "C" void QCALLTYPE MarshalNative_InternalCreateWrapperOfType(QCall::Objec //==================================================================== // check if the type is visible from COM. //==================================================================== -extern "C" BOOL QCALLTYPE MarshalNative_IsTypeVisibleFromCom(QCall::TypeHandle t, QCallException* qcallError) +extern "C" BOOL QCALLTYPE MarshalNative_IsTypeVisibleFromCom(QCall::TypeHandle t, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -964,7 +956,7 @@ extern "C" BOOL QCALLTYPE MarshalNative_IsTypeVisibleFromCom(QCall::TypeHandle t return retVal; } -extern "C" void QCALLTYPE MarshalNative_GetNativeVariantForObject(QCall::ObjectHandleOnStack ObjUNSAFE, LPVOID pDestNativeVariant, QCallException* qcallError) +extern "C" void QCALLTYPE MarshalNative_GetNativeVariantForObject(QCall::ObjectHandleOnStack ObjUNSAFE, LPVOID pDestNativeVariant, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -998,7 +990,7 @@ extern "C" void QCALLTYPE MarshalNative_GetNativeVariantForObject(QCall::ObjectH END_QCALL; } -extern "C" void QCALLTYPE MarshalNative_GetObjectForNativeVariant(LPVOID pSrcNativeVariant, QCall::ObjectHandleOnStack retObject, QCallException* qcallError) +extern "C" void QCALLTYPE MarshalNative_GetObjectForNativeVariant(LPVOID pSrcNativeVariant, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -1021,7 +1013,7 @@ extern "C" void QCALLTYPE MarshalNative_GetObjectForNativeVariant(LPVOID pSrcNat } -extern "C" void QCALLTYPE MarshalNative_GetObjectsForNativeVariants(VARIANT* aSrcNativeVariant, int cVars, QCall::ObjectHandleOnStack retArray, QCallException* qcallError) +extern "C" void QCALLTYPE MarshalNative_GetObjectsForNativeVariants(VARIANT* aSrcNativeVariant, int cVars, QCall::ObjectHandleOnStack retArray, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -1108,7 +1100,7 @@ static int GetComSlotInfo(MethodTable *pMT, MethodTable **ppDefItfMT) } } -extern "C" INT32 QCALLTYPE MarshalNative_GetStartComSlot(QCall::TypeHandle t, QCallException* qcallError) +extern "C" INT32 QCALLTYPE MarshalNative_GetStartComSlot(QCall::TypeHandle t, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1131,7 +1123,7 @@ extern "C" INT32 QCALLTYPE MarshalNative_GetStartComSlot(QCall::TypeHandle t, QC return retVal; } -extern "C" INT32 QCALLTYPE MarshalNative_GetEndComSlot(QCall::TypeHandle t, QCallException* qcallError) +extern "C" INT32 QCALLTYPE MarshalNative_GetEndComSlot(QCall::TypeHandle t, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1170,7 +1162,7 @@ extern "C" INT32 QCALLTYPE MarshalNative_GetEndComSlot(QCall::TypeHandle t, QCal return retVal; } -extern "C" VOID QCALLTYPE MarshalNative_ChangeWrapperHandleStrength(QCall::ObjectHandleOnStack otp, BOOL fIsWeak, QCallException* qcallError) +extern "C" VOID QCALLTYPE MarshalNative_ChangeWrapperHandleStrength(QCall::ObjectHandleOnStack otp, BOOL fIsWeak, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1196,7 +1188,7 @@ extern "C" VOID QCALLTYPE MarshalNative_ChangeWrapperHandleStrength(QCall::Objec END_QCALL; } -extern "C" void QCALLTYPE MarshalNative_GetTypeFromCLSID(REFCLSID clsid, PCWSTR wszServer, QCall::ObjectHandleOnStack retType, QCallException* qcallError) +extern "C" void QCALLTYPE MarshalNative_GetTypeFromCLSID(REFCLSID clsid, PCWSTR wszServer, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/marshalnative.h b/src/coreclr/vm/marshalnative.h index 94632ecfe0434f..01a9cb3c8e58c5 100644 --- a/src/coreclr/vm/marshalnative.h +++ b/src/coreclr/vm/marshalnative.h @@ -37,122 +37,122 @@ class MarshalNative #endif // FEATURE_COMINTEROP }; -extern "C" SIZE_T QCALLTYPE MarshalNative_OffsetOf(FieldDesc* pFD, QCallException* qcallError); +extern "C" SIZE_T QCALLTYPE MarshalNative_OffsetOf(FieldDesc* pFD, QCallExceptionStatus* qcallError); -extern "C" VOID QCALLTYPE MarshalNative_Prelink(MethodDesc * pMD, QCallException* qcallError); -extern "C" BOOL QCALLTYPE MarshalNative_IsBuiltInComSupported(QCallException* qcallError); +extern "C" VOID QCALLTYPE MarshalNative_Prelink(MethodDesc * pMD, QCallExceptionStatus* qcallError); +extern "C" BOOL QCALLTYPE MarshalNative_IsBuiltInComSupported(QCallExceptionStatus* qcallError); -extern "C" BOOL QCALLTYPE MarshalNative_HasLayout(QCall::TypeHandle t, BOOL* pIsBlittable, DWORD* pNativeSize, QCallException* qcallError); -extern "C" INT32 QCALLTYPE MarshalNative_SizeOfHelper(QCall::TypeHandle t, BOOL throwIfNotMarshalable, QCallException* qcallError); +extern "C" BOOL QCALLTYPE MarshalNative_HasLayout(QCall::TypeHandle t, BOOL* pIsBlittable, DWORD* pNativeSize, QCallExceptionStatus* qcallError); +extern "C" INT32 QCALLTYPE MarshalNative_SizeOfHelper(QCall::TypeHandle t, BOOL throwIfNotMarshalable, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE MarshalNative_GetDelegateForFunctionPointerInternal(PVOID FPtr, QCall::TypeHandle t, QCall::ObjectHandleOnStack retDelegate, QCallException* qcallError); -extern "C" PVOID QCALLTYPE MarshalNative_GetFunctionPointerForDelegateInternal(QCall::ObjectHandleOnStack delegate, QCallException* qcallError); +extern "C" void QCALLTYPE MarshalNative_GetDelegateForFunctionPointerInternal(PVOID FPtr, QCall::TypeHandle t, QCall::ObjectHandleOnStack retDelegate, QCallExceptionStatus* qcallError); +extern "C" PVOID QCALLTYPE MarshalNative_GetFunctionPointerForDelegateInternal(QCall::ObjectHandleOnStack delegate, QCallExceptionStatus* qcallError); //==================================================================== // These methods convert between an HR and and a managed exception. //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetExceptionForHR(INT32 errorCode, LPVOID errorInfo, QCall::ObjectHandleOnStack obj, QCallException* qcallError); +extern "C" void QCALLTYPE MarshalNative_GetExceptionForHR(INT32 errorCode, LPVOID errorInfo, QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError); #ifdef FEATURE_COMINTEROP -extern "C" int32_t QCALLTYPE MarshalNative_GetHRForException(QCall::ObjectHandleOnStack obj, QCallException* qcallError); +extern "C" int32_t QCALLTYPE MarshalNative_GetHRForException(QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError); #endif // FEATURE_COMINTEROP -extern "C" OBJECTHANDLE QCALLTYPE GCHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack obj, int type, QCallException* qcallError); -extern "C" void QCALLTYPE GCHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle, QCallException* qcallError); +extern "C" OBJECTHANDLE QCALLTYPE GCHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack obj, int type, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE GCHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle, QCallExceptionStatus* qcallError); #ifdef FEATURE_JAVAMARSHAL -extern "C" void QCALLTYPE GCHandle_InternalGetBridgeWait(OBJECTHANDLE handle, QCall::ObjectHandleOnStack result, QCallException* qcallError); +extern "C" void QCALLTYPE GCHandle_InternalGetBridgeWait(OBJECTHANDLE handle, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); #endif #ifdef _DEBUG using IsInCooperativeGCMode_fn = BOOL(STDMETHODCALLTYPE*)(void); -extern "C" IsInCooperativeGCMode_fn QCALLTYPE MarshalNative_GetIsInCooperativeGCModeFunctionPointer(QCallException* qcallError); +extern "C" IsInCooperativeGCMode_fn QCALLTYPE MarshalNative_GetIsInCooperativeGCModeFunctionPointer(); #endif #ifdef FEATURE_COMINTEROP //==================================================================== // Create type for given CLSID. //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetTypeFromCLSID(REFCLSID clsid, PCWSTR wszServer, QCall::ObjectHandleOnStack retType, QCallException* qcallError); +extern "C" void QCALLTYPE MarshalNative_GetTypeFromCLSID(REFCLSID clsid, PCWSTR wszServer, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); //==================================================================== // return the IUnknown* for an Object //==================================================================== -extern "C" IUnknown* QCALLTYPE MarshalNative_GetIUnknownForObject(QCall::ObjectHandleOnStack o, QCallException* qcallError); +extern "C" IUnknown* QCALLTYPE MarshalNative_GetIUnknownForObject(QCall::ObjectHandleOnStack o, QCallExceptionStatus* qcallError); //==================================================================== // return the IDispatch* for an Object //==================================================================== -extern "C" IDispatch* QCALLTYPE MarshalNative_GetIDispatchForObject(QCall::ObjectHandleOnStack o, QCallException* qcallError); +extern "C" IDispatch* QCALLTYPE MarshalNative_GetIDispatchForObject(QCall::ObjectHandleOnStack o, QCallExceptionStatus* qcallError); //==================================================================== // return the IUnknown* or IDispatch* for an Object. //==================================================================== -extern "C" void* QCALLTYPE MarshalNative_GetIUnknownOrIDispatchForObject(QCall::ObjectHandleOnStack o, BOOL* isIDispatch, QCallException* qcallError); +extern "C" void* QCALLTYPE MarshalNative_GetIUnknownOrIDispatchForObject(QCall::ObjectHandleOnStack o, BOOL* isIDispatch, QCallExceptionStatus* qcallError); //==================================================================== // return the IUnknown* representing the interface for the Object // Object o should support Type T //==================================================================== -extern "C" IUnknown* QCALLTYPE MarshalNative_GetComInterfaceForObject(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, BOOL bEnableCustomizedQueryInterface, QCallException* qcallError); +extern "C" IUnknown* QCALLTYPE MarshalNative_GetComInterfaceForObject(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, BOOL bEnableCustomizedQueryInterface, QCallExceptionStatus* qcallError); //==================================================================== // return an Object for IUnknown //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject, QCallException* qcallError); +extern "C" void QCALLTYPE MarshalNative_GetObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); //==================================================================== // return a unique cacheless Object for IUnknown //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetUniqueObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject, QCallException* qcallError); +extern "C" void QCALLTYPE MarshalNative_GetUniqueObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); //==================================================================== // return an Object for IUnknown, using the Type T, // NOTE: // Type T should be either a COM imported Type or a sub-type of COM imported Type //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetTypedObjectForIUnknown(IUnknown* pUnk, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject, QCallException* qcallError); +extern "C" void QCALLTYPE MarshalNative_GetTypedObjectForIUnknown(IUnknown* pUnk, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); //==================================================================== // Create an object and aggregate it, then return the inner unknown. //==================================================================== -extern "C" IUnknown* QCALLTYPE MarshalNative_CreateAggregatedObject(IUnknown* pOuter, QCall::ObjectHandleOnStack o, QCallException* qcallError); +extern "C" IUnknown* QCALLTYPE MarshalNative_CreateAggregatedObject(IUnknown* pOuter, QCall::ObjectHandleOnStack o, QCallExceptionStatus* qcallError); //==================================================================== // Free unused RCWs in the current CLR context. //==================================================================== -extern "C" void QCALLTYPE MarshalNative_CleanupUnusedObjectsInCurrentContext(QCallException* qcallError); +extern "C" void QCALLTYPE MarshalNative_CleanupUnusedObjectsInCurrentContext(QCallExceptionStatus* qcallError); //==================================================================== // free the COM component and zombie this object // further usage of this Object might throw an exception, //==================================================================== -extern "C" INT32 QCALLTYPE MarshalNative_ReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, QCallException* qcallError); -extern "C" void QCALLTYPE MarshalNative_FinalReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, QCallException* qcallError); +extern "C" INT32 QCALLTYPE MarshalNative_ReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE MarshalNative_FinalReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, QCallExceptionStatus* qcallError); //==================================================================== // This method takes the given COM object and wraps it in an object // of the specified type. The type must be derived from __ComObject. //==================================================================== -extern "C" void QCALLTYPE MarshalNative_InternalCreateWrapperOfType(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject, QCallException* qcallError); +extern "C" void QCALLTYPE MarshalNative_InternalCreateWrapperOfType(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); //==================================================================== // check if the type is visible from COM. //==================================================================== -extern "C" BOOL QCALLTYPE MarshalNative_IsTypeVisibleFromCom(QCall::TypeHandle t, QCallException* qcallError); +extern "C" BOOL QCALLTYPE MarshalNative_IsTypeVisibleFromCom(QCall::TypeHandle t, QCallExceptionStatus* qcallError); //==================================================================== // These methods convert OLE variants to and from objects. //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetNativeVariantForObject(QCall::ObjectHandleOnStack ObjUNSAFE, LPVOID pDestNativeVariant, QCallException* qcallError); -extern "C" void QCALLTYPE MarshalNative_GetObjectForNativeVariant(LPVOID pSrcNativeVariant, QCall::ObjectHandleOnStack retObject, QCallException* qcallError); -extern "C" void QCALLTYPE MarshalNative_GetObjectsForNativeVariants(VARIANT* aSrcNativeVariant, int cVars, QCall::ObjectHandleOnStack retArray, QCallException* qcallError); +extern "C" void QCALLTYPE MarshalNative_GetNativeVariantForObject(QCall::ObjectHandleOnStack ObjUNSAFE, LPVOID pDestNativeVariant, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE MarshalNative_GetObjectForNativeVariant(LPVOID pSrcNativeVariant, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE MarshalNative_GetObjectsForNativeVariants(VARIANT* aSrcNativeVariant, int cVars, QCall::ObjectHandleOnStack retArray, QCallExceptionStatus* qcallError); //==================================================================== // These methods are used to map COM slots to method info's. //==================================================================== -extern "C" INT32 QCALLTYPE MarshalNative_GetStartComSlot(QCall::TypeHandle t, QCallException* qcallError); -extern "C" INT32 QCALLTYPE MarshalNative_GetEndComSlot(QCall::TypeHandle t, QCallException* qcallError); +extern "C" INT32 QCALLTYPE MarshalNative_GetStartComSlot(QCall::TypeHandle t, QCallExceptionStatus* qcallError); +extern "C" INT32 QCALLTYPE MarshalNative_GetEndComSlot(QCall::TypeHandle t, QCallExceptionStatus* qcallError); -extern "C" VOID QCALLTYPE MarshalNative_ChangeWrapperHandleStrength(QCall::ObjectHandleOnStack otp, BOOL fIsWeak, QCallException* qcallError); +extern "C" VOID QCALLTYPE MarshalNative_ChangeWrapperHandleStrength(QCall::ObjectHandleOnStack otp, BOOL fIsWeak, QCallExceptionStatus* qcallError); #endif // FEATURE_COMINTEROP #endif diff --git a/src/coreclr/vm/method.hpp b/src/coreclr/vm/method.hpp index 869e5f3ceddad9..ec09d57be93bdf 100644 --- a/src/coreclr/vm/method.hpp +++ b/src/coreclr/vm/method.hpp @@ -2399,7 +2399,7 @@ class MethodDesc }; #ifndef DACCESS_COMPILE -extern "C" void* QCALLTYPE UnsafeAccessors_ResolveGenericParamToTypeHandle(MethodDesc* unsafeAccessorMethod, BOOL isMethodParam, DWORD paramIndex, QCallException* qcallError); +extern "C" void* QCALLTYPE UnsafeAccessors_ResolveGenericParamToTypeHandle(MethodDesc* unsafeAccessorMethod, BOOL isMethodParam, DWORD paramIndex, QCallExceptionStatus* qcallError); #endif // DACCESS_COMPILE template<> struct cdac_data diff --git a/src/coreclr/vm/mlinfo.cpp b/src/coreclr/vm/mlinfo.cpp index 44c9c8e305e243..2e79296f139930 100644 --- a/src/coreclr/vm/mlinfo.cpp +++ b/src/coreclr/vm/mlinfo.cpp @@ -3585,7 +3585,7 @@ bool IsUnsupportedTypedrefReturn(MetaSig& msig) #include "stubhelpers.h" -extern "C" void QCALLTYPE StubHelpers_CreateCustomMarshaler(MethodDesc* pMD, mdToken paramToken, TypeHandle hndManagedType, QCall::ObjectHandleOnStack retObject, QCallException* qcallError) +extern "C" void QCALLTYPE StubHelpers_CreateCustomMarshaler(MethodDesc* pMD, mdToken paramToken, TypeHandle hndManagedType, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/multicorejit.cpp b/src/coreclr/vm/multicorejit.cpp index 1c93fbacee23f0..b3fbd479b7de31 100644 --- a/src/coreclr/vm/multicorejit.cpp +++ b/src/coreclr/vm/multicorejit.cpp @@ -1548,7 +1548,7 @@ DWORD MulticoreJitManager::EncodeModuleHelper(void * pModuleContext, Module * pR // wszProfile - profile name // ptrNativeAssemblyBinder - the binding context // -extern "C" void QCALLTYPE MultiCoreJIT_InternalStartProfile(_In_z_ LPCWSTR wszProfile, INT_PTR ptrNativeAssemblyBinder, QCallException* qcallError) +extern "C" void QCALLTYPE MultiCoreJIT_InternalStartProfile(_In_z_ LPCWSTR wszProfile, INT_PTR ptrNativeAssemblyBinder, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1567,7 +1567,7 @@ extern "C" void QCALLTYPE MultiCoreJIT_InternalStartProfile(_In_z_ LPCWSTR wszPr } -extern "C" void QCALLTYPE MultiCoreJIT_InternalSetProfileRoot(_In_z_ LPCWSTR wszProfilePath, QCallException* qcallError) +extern "C" void QCALLTYPE MultiCoreJIT_InternalSetProfileRoot(_In_z_ LPCWSTR wszProfilePath, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/multicorejit.h b/src/coreclr/vm/multicorejit.h index 199ba19ab7725b..5577d1c77e3c11 100644 --- a/src/coreclr/vm/multicorejit.h +++ b/src/coreclr/vm/multicorejit.h @@ -315,7 +315,7 @@ class MulticoreJitManager // For qcallentrypoints.cpp -extern "C" void QCALLTYPE MultiCoreJIT_InternalSetProfileRoot(_In_z_ LPCWSTR directoryPath, QCallException* qcallError); -extern "C" void QCALLTYPE MultiCoreJIT_InternalStartProfile(_In_z_ LPCWSTR wszProfile, INT_PTR ptrNativeAssemblyBinder, QCallException* qcallError); +extern "C" void QCALLTYPE MultiCoreJIT_InternalSetProfileRoot(_In_z_ LPCWSTR directoryPath, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE MultiCoreJIT_InternalStartProfile(_In_z_ LPCWSTR wszProfile, INT_PTR ptrNativeAssemblyBinder, QCallExceptionStatus* qcallError); #endif // __MULTICORE_JIT_H__ diff --git a/src/coreclr/vm/nativeeventsource.cpp b/src/coreclr/vm/nativeeventsource.cpp index 14796c32419816..f73c0b640488ae 100644 --- a/src/coreclr/vm/nativeeventsource.cpp +++ b/src/coreclr/vm/nativeeventsource.cpp @@ -13,7 +13,7 @@ #if defined(FEATURE_EVENTSOURCE_XPLAT) -extern "C" void QCALLTYPE LogEventSource(_In_z_ int eventID, _In_z_ LPCWSTR eventName, _In_z_ LPCWSTR eventSourceName, _In_z_ LPCWSTR payload, QCallException* qcallError) +extern "C" void QCALLTYPE LogEventSource(_In_z_ int eventID, _In_z_ LPCWSTR eventName, _In_z_ LPCWSTR eventSourceName, _In_z_ LPCWSTR payload, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -21,7 +21,7 @@ extern "C" void QCALLTYPE LogEventSource(_In_z_ int eventID, _In_z_ LPCWSTR even END_QCALL; } -extern "C" BOOL QCALLTYPE IsEventSourceLoggingEnabled(QCallException* qcallError) +extern "C" BOOL QCALLTYPE IsEventSourceLoggingEnabled(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -34,7 +34,7 @@ extern "C" BOOL QCALLTYPE IsEventSourceLoggingEnabled(QCallException* qcallError return retVal; } -extern "C" LPWSTR QCALLTYPE EventSource_GetClrConfig(LPCWSTR configName, QCallException* qcallError) +extern "C" LPWSTR QCALLTYPE EventSource_GetClrConfig(LPCWSTR configName, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -60,7 +60,7 @@ extern "C" LPWSTR QCALLTYPE EventSource_GetClrConfig(LPCWSTR configName, QCallEx // change genRuntimeEventSources.py script to not emit the body that throws NotImplementedException for the event that // want to be fired from managed code. // See https://github.com/dotnet/runtime/pull/47829 for an example of how to do this. -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStart(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallException* qcallError) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStart(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -70,7 +70,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStar END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallException* qcallError) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -80,7 +80,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallException* qcallError) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -90,7 +90,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolMinMaxThreads(_In_z_ short minWorkerThreads, _In_z_ short maxWorkerThreads, _In_z_ short minIOCompletionThreads, _In_z_ short maxIOCompletionThreads, _In_z_ short clrInstanceID, QCallException* qcallError) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolMinMaxThreads(_In_z_ short minWorkerThreads, _In_z_ short maxWorkerThreads, _In_z_ short minIOCompletionThreads, _In_z_ short maxIOCompletionThreads, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -100,7 +100,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolMinMaxThreads(_I END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentSample(_In_z_ double throughput, _In_z_ short clrInstanceID, QCallException* qcallError) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentSample(_In_z_ double throughput, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -110,7 +110,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdju END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentAdjustment(_In_z_ double averageThroughput, _In_z_ uint newWorkerThreadCount, _In_z_ uint reason, _In_z_ short clrInstanceID, QCallException* qcallError) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentAdjustment(_In_z_ double averageThroughput, _In_z_ uint newWorkerThreadCount, _In_z_ uint reason, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -120,7 +120,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdju END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentStats(_In_z_ double duration, _In_z_ double throughput, _In_z_ double threadWave, _In_z_ double throughputWave, _In_z_ double throughputErrorEstimate, _In_z_ double AverageThroughputErrorEstimate, _In_z_ double ThroughputRatio, _In_z_ double confidence, _In_z_ double newControlSetting, _In_z_ short newThreadWaveMagnitude, _In_z_ short ClrInstanceID, QCallException* qcallError) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentStats(_In_z_ double duration, _In_z_ double throughput, _In_z_ double threadWave, _In_z_ double throughputWave, _In_z_ double throughputErrorEstimate, _In_z_ double AverageThroughputErrorEstimate, _In_z_ double ThroughputRatio, _In_z_ double confidence, _In_z_ double newControlSetting, _In_z_ short newThreadWaveMagnitude, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -130,7 +130,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdju END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOEnqueue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ bool multiDequeues, _In_z_ short ClrInstanceID, QCallException* qcallError) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOEnqueue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ bool multiDequeues, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -140,7 +140,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOEnqueue(_In_z_ END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIODequeue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID, QCallException* qcallError) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIODequeue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -150,7 +150,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIODequeue(_In_z_ END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkingThreadCount(_In_z_ uint count, _In_z_ short ClrInstanceID, QCallException* qcallError) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkingThreadCount(_In_z_ uint count, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -160,7 +160,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkingThreadCou END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOPack(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID, QCallException* qcallError) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOPack(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -170,7 +170,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOPack(_In_z_ vo END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionLockCreated(void* LockID, void* AssociatedObjectID, uint16_t ClrInstanceID, QCallException* qcallError) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionLockCreated(void* LockID, void* AssociatedObjectID, uint16_t ClrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -186,7 +186,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStart( void* LockID, void* AssociatedObjectID, uint64_t LockOwnerThreadID, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -196,7 +196,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStart( END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStop(uint8_t ContentionFlags, uint16_t ClrInstanceID, double DurationNs, QCallException* qcallError) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStop(uint8_t ContentionFlags, uint16_t ClrInstanceID, double DurationNs, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -206,7 +206,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStop(uint8_t Con END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStart(uint8_t WaitSource, intptr_t AssociatedObjectID, uint16_t ClrInstanceID, QCallException* qcallError) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStart(uint8_t WaitSource, intptr_t AssociatedObjectID, uint16_t ClrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -216,7 +216,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStart(uint8_ END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStop(uint16_t ClrInstanceID, QCallException* qcallError) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStop(uint16_t ClrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; diff --git a/src/coreclr/vm/nativeeventsource.h b/src/coreclr/vm/nativeeventsource.h index 8fc0d5e9b4819b..b4d47990441b4a 100644 --- a/src/coreclr/vm/nativeeventsource.h +++ b/src/coreclr/vm/nativeeventsource.h @@ -15,28 +15,28 @@ #include "qcall.h" #if defined(FEATURE_EVENTSOURCE_XPLAT) -extern "C" void QCALLTYPE LogEventSource(_In_z_ int eventID, _In_z_ LPCWSTR eventName, _In_z_ LPCWSTR eventSourceName, _In_z_ LPCWSTR payload, QCallException* qcallError); -extern "C" BOOL QCALLTYPE IsEventSourceLoggingEnabled(QCallException* qcallError); -extern "C" LPWSTR QCALLTYPE EventSource_GetClrConfig(LPCWSTR configName, QCallException* qcallError); +extern "C" void QCALLTYPE LogEventSource(_In_z_ int eventID, _In_z_ LPCWSTR eventName, _In_z_ LPCWSTR eventSourceName, _In_z_ LPCWSTR payload, QCallExceptionStatus* qcallError); +extern "C" BOOL QCALLTYPE IsEventSourceLoggingEnabled(QCallExceptionStatus* qcallError); +extern "C" LPWSTR QCALLTYPE EventSource_GetClrConfig(LPCWSTR configName, QCallExceptionStatus* qcallError); #endif //defined(FEATURE_EVENTSOURCE_XPLAT) #if defined(FEATURE_PERFTRACING) -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStart(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallException* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallException* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallException* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolMinMaxThreads(_In_z_ short minWorkerThreads, _In_z_ short maxWorkerThreads, _In_z_ short minIOCompletionThreads, _In_z_ short maxIOCompletionThreads, _In_z_ short clrInstanceID, QCallException* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentSample(_In_z_ double throughput, _In_z_ short clrInstanceID, QCallException* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentAdjustment(_In_z_ double averageThroughput, _In_z_ uint newWorkerThreadCount, _In_z_ uint reason, _In_z_ short clrInstanceID, QCallException* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentStats(_In_z_ double duration, _In_z_ double throughput, _In_z_ double threadWave, _In_z_ double throughputWave, _In_z_ double throughputErrorEstimate, _In_z_ double AverageThroughputErrorEstimate, _In_z_ double ThroughputRatio, _In_z_ double confidence, _In_z_ double newControlSetting, _In_z_ short newThreadWaveMagnitude, _In_z_ short ClrInstanceID, QCallException* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOEnqueue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ bool multiDequeues, _In_z_ short ClrInstanceID, QCallException* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIODequeue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID, QCallException* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkingThreadCount(_In_z_ uint count, _In_z_ short ClrInstanceID, QCallException* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOPack(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID, QCallException* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionLockCreated(void* LockID, void* AssociatedObjectID, uint16_t ClrInstanceID, QCallException* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStart(uint8_t ContentionFlags, uint16_t ClrInstanceID, void* LockID, void* AssociatedObjectID, uint64_t LockOwnerThreadID, QCallException* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStop(uint8_t ContentionFlags, uint16_t ClrInstanceID, double DurationNs, QCallException* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStart(uint8_t WaitSource, intptr_t AssociatedObjectID, uint16_t ClrInstanceID, QCallException* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStop(uint16_t ClrInstanceID, QCallException* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStart(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolMinMaxThreads(_In_z_ short minWorkerThreads, _In_z_ short maxWorkerThreads, _In_z_ short minIOCompletionThreads, _In_z_ short maxIOCompletionThreads, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentSample(_In_z_ double throughput, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentAdjustment(_In_z_ double averageThroughput, _In_z_ uint newWorkerThreadCount, _In_z_ uint reason, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentStats(_In_z_ double duration, _In_z_ double throughput, _In_z_ double threadWave, _In_z_ double throughputWave, _In_z_ double throughputErrorEstimate, _In_z_ double AverageThroughputErrorEstimate, _In_z_ double ThroughputRatio, _In_z_ double confidence, _In_z_ double newControlSetting, _In_z_ short newThreadWaveMagnitude, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOEnqueue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ bool multiDequeues, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIODequeue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkingThreadCount(_In_z_ uint count, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOPack(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionLockCreated(void* LockID, void* AssociatedObjectID, uint16_t ClrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStart(uint8_t ContentionFlags, uint16_t ClrInstanceID, void* LockID, void* AssociatedObjectID, uint64_t LockOwnerThreadID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStop(uint8_t ContentionFlags, uint16_t ClrInstanceID, double DurationNs, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStart(uint8_t WaitSource, intptr_t AssociatedObjectID, uint16_t ClrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStop(uint16_t ClrInstanceID, QCallExceptionStatus* qcallError); #endif // defined(FEATURE_PERFTRACING) diff --git a/src/coreclr/vm/nativelibrarynative.cpp b/src/coreclr/vm/nativelibrarynative.cpp index baa35600dc7887..713ae1b62ec097 100644 --- a/src/coreclr/vm/nativelibrarynative.cpp +++ b/src/coreclr/vm/nativelibrarynative.cpp @@ -12,7 +12,7 @@ extern "C" INT_PTR QCALLTYPE NativeLibrary_LoadByName(LPCWSTR name, QCall::AssemblyHandle callingAssembly, BOOL hasDllImportSearchPathFlag, DWORD dllImportSearchPathFlag, BOOL throwOnError, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/nativelibrarynative.h b/src/coreclr/vm/nativelibrarynative.h index d4f6c09231144f..a30217d657e30b 100644 --- a/src/coreclr/vm/nativelibrarynative.h +++ b/src/coreclr/vm/nativelibrarynative.h @@ -13,6 +13,6 @@ extern "C" INT_PTR QCALLTYPE NativeLibrary_LoadByName(LPCWSTR name, QCall::AssemblyHandle callingAssembly, BOOL hasDllImportSearchPathFlag, DWORD dllImportSearchPathFlag, BOOL throwOnError, - QCallException* qcallError); + QCallExceptionStatus* qcallError); #endif // __NATIVELIBRARYNATIVE_H__ diff --git a/src/coreclr/vm/olevariant.cpp b/src/coreclr/vm/olevariant.cpp index 89e8e243235cc8..040c35638bc4c8 100644 --- a/src/coreclr/vm/olevariant.cpp +++ b/src/coreclr/vm/olevariant.cpp @@ -2666,7 +2666,7 @@ BSTR OleVariant::ConvertStringToBSTR(STRINGREF *pStringObj) return result; } -extern "C" void QCALLTYPE Variant_ConvertValueTypeToRecord(QCall::ObjectHandleOnStack obj, VARIANT * pOle, QCallException* qcallError) +extern "C" void QCALLTYPE Variant_ConvertValueTypeToRecord(QCall::ObjectHandleOnStack obj, VARIANT * pOle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/olevariant.h b/src/coreclr/vm/olevariant.h index 3ff901c5029daa..ba83ded23c7941 100644 --- a/src/coreclr/vm/olevariant.h +++ b/src/coreclr/vm/olevariant.h @@ -107,6 +107,6 @@ class OleVariant // SAFEARRAY VARTYPE and element MethodTable. MethodDesc* GetInstantiatedSafeArrayMethod(BinderMethodID methodId, VARTYPE vt, MethodTable* pElementMT, BOOL bHeterogeneous, BOOL bNativeDataValid = FALSE); -extern "C" void QCALLTYPE Variant_ConvertValueTypeToRecord(QCall::ObjectHandleOnStack obj, VARIANT* pOle, QCallException* qcallError); +extern "C" void QCALLTYPE Variant_ConvertValueTypeToRecord(QCall::ObjectHandleOnStack obj, VARIANT* pOle, QCallExceptionStatus* qcallError); #endif diff --git a/src/coreclr/vm/qcall.cpp b/src/coreclr/vm/qcall.cpp index 7f06c10c5adfd2..e1b25f061ea37c 100644 --- a/src/coreclr/vm/qcall.cpp +++ b/src/coreclr/vm/qcall.cpp @@ -8,7 +8,7 @@ #include "common.h" #include "threadstatics.h" -void QCallException::SetThrowable(OBJECTREF throwable) +void QCallExceptionStatus::SetThrowable(OBJECTREF throwable) { LIMITED_METHOD_CONTRACT; diff --git a/src/coreclr/vm/qcall.h b/src/coreclr/vm/qcall.h index f3614683b5868e..a8193f823eaf67 100644 --- a/src/coreclr/vm/qcall.h +++ b/src/coreclr/vm/qcall.h @@ -39,9 +39,9 @@ // class Foo // { // -// // All QCalls that use BEGIN_QCALL must have a final QCallException out parameter. +// // All QCalls that use BEGIN_QCALL must have a final QCallExceptionStatus out parameter. // [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "FooNative_Bar", StringMarshalling = StringMarshalling.Utf16)] -// private static partial bool Bar(int flags, string inString, StringHandleOnStack retString, out QCallException qcallException); +// private static partial bool Bar(int flags, string inString, StringHandleOnStack retString, out QCallExceptionStatus qcallException); // // // Many QCalls have a thin managed wrapper around them to expose them to the world in more meaningful way. // public string Bar(int flags) @@ -65,7 +65,7 @@ // The entrypoints of all QCalls has to be registered in tables in vm\qcallentrypoints.cpp using the DllImportEntry macro, // For example: DllImportEntry(FooNative_Bar) // -// extern "C" BOOL QCALLTYPE FooNative_Bar(int flags, LPCWSTR wszString, QCall::StringHandleOnStack retString, QCallException* qcallError) +// extern "C" BOOL QCALLTYPE FooNative_Bar(int flags, LPCWSTR wszString, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) // { // // All QCalls should have QCALL_CONTRACT. It is alias for THROWS; GC_TRIGGERS; MODE_PREEMPTIVE. // QCALL_CONTRACT; diff --git a/src/coreclr/vm/reflectioninvocation.cpp b/src/coreclr/vm/reflectioninvocation.cpp index 21ea154848915b..9889f958cd5242 100644 --- a/src/coreclr/vm/reflectioninvocation.cpp +++ b/src/coreclr/vm/reflectioninvocation.cpp @@ -27,7 +27,7 @@ #include "interpexec.h" -extern "C" void QCALLTYPE RuntimeFieldHandle_GetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized, QCall::ObjectHandleOnStack result, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeFieldHandle_GetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -45,7 +45,7 @@ extern "C" void QCALLTYPE RuntimeFieldHandle_GetValue(FieldDesc* fieldDesc, QCal END_QCALL; } -extern "C" void QCALLTYPE RuntimeFieldHandle_SetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::ObjectHandleOnStack value, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeFieldHandle_SetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::ObjectHandleOnStack value, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -74,7 +74,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_CreateInstanceForAnotherGenericParam TypeHandle* pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack pInstantiatedObject, - QCallException* qcallError + QCallExceptionStatus* qcallError ) { CONTRACTL @@ -119,7 +119,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_CreateInstanceForAnotherGenericParam END_QCALL; } -extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAlloc(MethodTable* pMT, QCall::ObjectHandleOnStack allocated, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAlloc(MethodTable* pMT, QCall::ObjectHandleOnStack allocated, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -134,7 +134,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAlloc(MethodTable* pMT, QCal END_QCALL; } -extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAllocNoChecks(MethodTable* pMT, QCall::ObjectHandleOnStack allocated, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAllocNoChecks(MethodTable* pMT, QCall::ObjectHandleOnStack allocated, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -331,7 +331,7 @@ extern "C" void QCALLTYPE RuntimeMethodHandle_InvokeMethod( QCall::ObjectHandleOnStack pSig, BOOL fConstructor, QCall::ObjectHandleOnStack result, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -795,7 +795,7 @@ static StackWalkAction SkipMethods(CrawlFrame* frame, VOID* data) { } // Return the MethodInfo that represents the current method (two above this one) -extern "C" MethodDesc* QCALLTYPE MethodBase_GetCurrentMethod(QCall::StackCrawlMarkHandle stackMark, QCallException* qcallError) { +extern "C" MethodDesc* QCALLTYPE MethodBase_GetCurrentMethod(QCall::StackCrawlMarkHandle stackMark, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -844,7 +844,7 @@ static OBJECTREF DirectObjectFieldGet(FieldDesc *pField, TypeHandle fieldType, T return refRet; } -extern "C" void QCALLTYPE RuntimeFieldHandle_GetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack result, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeFieldHandle_GetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -949,7 +949,7 @@ static void DirectObjectFieldSet(FieldDesc *pField, TypeHandle fieldType, TypeHa GCPROTECT_END(); } -extern "C" void QCALLTYPE RuntimeFieldHandle_SetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::ObjectHandleOnStack newValue, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringType, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeFieldHandle_SetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::ObjectHandleOnStack newValue, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1193,7 +1193,7 @@ FCIMPLEND // Returns the address of the EnC instance field in the object (This is an interior // pointer and the caller has to use it appropriately) or an EnC static field. -extern "C" void* QCALLTYPE RuntimeFieldHandle_GetEnCFieldAddr(QCall::ObjectHandleOnStack target, FieldDesc* pFD, QCallException* qcallError) +extern "C" void* QCALLTYPE RuntimeFieldHandle_GetEnCFieldAddr(QCall::ObjectHandleOnStack target, FieldDesc* pFD, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -1220,7 +1220,7 @@ extern "C" void* QCALLTYPE RuntimeFieldHandle_GetEnCFieldAddr(QCall::ObjectHandl return ret; } -extern "C" BOOL QCALLTYPE RuntimeFieldHandle_GetRVAFieldInfo(FieldDesc* pField, void** address, UINT* size, QCallException* qcallError) +extern "C" BOOL QCALLTYPE RuntimeFieldHandle_GetRVAFieldInfo(FieldDesc* pField, void** address, UINT* size, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1240,7 +1240,7 @@ extern "C" BOOL QCALLTYPE RuntimeFieldHandle_GetRVAFieldInfo(FieldDesc* pField, return ret; } -extern "C" void QCALLTYPE RuntimeFieldHandle_GetFieldDataReference(FieldDesc* pField, QCall::ObjectHandleOnStack instance, QCall::ByteRefOnStack fieldDataRef, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeFieldHandle_GetFieldDataReference(FieldDesc* pField, QCall::ObjectHandleOnStack instance, QCall::ByteRefOnStack fieldDataRef, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -1259,7 +1259,7 @@ extern "C" void QCALLTYPE RuntimeFieldHandle_GetFieldDataReference(FieldDesc* pF END_QCALL; } -extern "C" void QCALLTYPE ReflectionInvocation_CompileMethod(MethodDesc * pMD, QCallException* qcallError) +extern "C" void QCALLTYPE ReflectionInvocation_CompileMethod(MethodDesc * pMD, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1278,7 +1278,7 @@ extern "C" void QCALLTYPE ReflectionInvocation_CompileMethod(MethodDesc * pMD, Q } // This method triggers the class constructor for a give type -extern "C" void QCALLTYPE ReflectionInvocation_RunClassConstructor(QCall::TypeHandle pType, QCallException* qcallError) +extern "C" void QCALLTYPE ReflectionInvocation_RunClassConstructor(QCall::TypeHandle pType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1305,7 +1305,7 @@ extern "C" void QCALLTYPE ReflectionInvocation_RunClassConstructor(QCall::TypeHa } // This method triggers the module constructor for a given module -extern "C" void QCALLTYPE ReflectionInvocation_RunModuleConstructor(QCall::ModuleHandle pModule, QCallException* qcallError) +extern "C" void QCALLTYPE ReflectionInvocation_RunModuleConstructor(QCall::ModuleHandle pModule, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1354,7 +1354,7 @@ static void PrepareMethodHelper(MethodDesc * pMD) // This method triggers a given method to be jitted. CoreCLR implementation of this method triggers jiting of the given method only. // It does not walk a subset of callgraph to provide CER guarantees. -extern "C" void QCALLTYPE ReflectionInvocation_PrepareMethod(MethodDesc *pMD, TypeHandle *pInstantiation, UINT32 cInstantiation, QCallException* qcallError) +extern "C" void QCALLTYPE ReflectionInvocation_PrepareMethod(MethodDesc *pMD, TypeHandle *pInstantiation, UINT32 cInstantiation, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -1407,7 +1407,7 @@ extern "C" void QCALLTYPE ReflectionInvocation_PrepareMethod(MethodDesc *pMD, Ty // This method triggers target of a given method to be jitted. // In the case of a multi-cast delegate, we rely on the fact that each individual component // was prepared prior to the Combine. -extern "C" void QCALLTYPE ReflectionInvocation_PrepareDelegate(QCall::ObjectHandleOnStack delegate, QCallException* qcallError) +extern "C" void QCALLTYPE ReflectionInvocation_PrepareDelegate(QCall::ObjectHandleOnStack delegate, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1470,7 +1470,7 @@ extern "C" void QCALLTYPE ReflectionInvocation_InvokeDispMethod( LCID lcid, QCall::ObjectHandleOnStack namedParameters, QCall::ObjectHandleOnStack result, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1531,7 +1531,7 @@ extern "C" void QCALLTYPE ReflectionInvocation_InvokeDispMethod( END_QCALL; } -extern "C" void QCALLTYPE ReflectionInvocation_GetComObjectGuid(QCall::ObjectHandleOnStack type, GUID* result, QCallException* qcallError) +extern "C" void QCALLTYPE ReflectionInvocation_GetComObjectGuid(QCall::ObjectHandleOnStack type, GUID* result, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -1564,7 +1564,7 @@ extern "C" void QCALLTYPE ReflectionInvocation_GetComObjectGuid(QCall::ObjectHan } #endif // FEATURE_COMINTEROP -extern "C" void QCALLTYPE ReflectionInvocation_GetGuid(MethodTable* pMT, GUID* result, QCallException* qcallError) +extern "C" void QCALLTYPE ReflectionInvocation_GetGuid(MethodTable* pMT, GUID* result, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -1677,7 +1677,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_GetActivationInfo( PCODE* ppfnRefCtor, PCODE* ppfnValueCtor, BOOL* pfCtorIsPublic, - QCallException* qcallError + QCallExceptionStatus* qcallError ) { CONTRACTL @@ -1814,7 +1814,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_GetActivationInfo( * Given a ComClassFactory*, calls the COM allocator * and returns a RCW. */ -extern "C" void QCALLTYPE RuntimeTypeHandle_AllocateComObject(void* pClassFactory, QCall::ObjectHandleOnStack result, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeTypeHandle_AllocateComObject(void* pClassFactory, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1847,7 +1847,7 @@ extern "C" void QCALLTYPE ReflectionSerialization_GetCreateUninitializedObjectIn QCall::TypeHandle pType, PCODE* ppfnAllocator, void** pvAllocatorFirstArg, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { CONTRACTL { @@ -1899,7 +1899,7 @@ struct TempEnumValue UINT64 value; }; -extern "C" void QCALLTYPE Enum_GetValuesAndNames(QCall::TypeHandle pEnumType, QCall::ObjectHandleOnStack pReturnValues, QCall::ObjectHandleOnStack pReturnNames, BOOL fGetNames, QCallException* qcallError) +extern "C" void QCALLTYPE Enum_GetValuesAndNames(QCall::TypeHandle pEnumType, QCall::ObjectHandleOnStack pReturnValues, QCall::ObjectHandleOnStack pReturnNames, BOOL fGetNames, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -2022,7 +2022,7 @@ extern "C" void QCALLTYPE ReflectionInvocation_GetBoxInfo( void** pvAllocatorFirstArg, int32_t* pValueOffset, uint32_t* pValueSize, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { CONTRACTL { diff --git a/src/coreclr/vm/reflectioninvocation.h b/src/coreclr/vm/reflectioninvocation.h index 3dd84a0b1a0de4..3d553fab1d1f80 100644 --- a/src/coreclr/vm/reflectioninvocation.h +++ b/src/coreclr/vm/reflectioninvocation.h @@ -48,15 +48,15 @@ class ReflectionInvocation FCDECL0(static FC_BOOL_RET, TryEnsureSufficientExecutionStack); }; -extern "C" void QCALLTYPE ReflectionInvocation_CompileMethod(MethodDesc * pMD, QCallException* qcallError); +extern "C" void QCALLTYPE ReflectionInvocation_CompileMethod(MethodDesc * pMD, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ReflectionInvocation_RunClassConstructor(QCall::TypeHandle pType, QCallException* qcallError); +extern "C" void QCALLTYPE ReflectionInvocation_RunClassConstructor(QCall::TypeHandle pType, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ReflectionInvocation_RunModuleConstructor(QCall::ModuleHandle pModule, QCallException* qcallError); +extern "C" void QCALLTYPE ReflectionInvocation_RunModuleConstructor(QCall::ModuleHandle pModule, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ReflectionInvocation_PrepareMethod(MethodDesc* pMD, TypeHandle *pInstantiation, UINT32 cInstantiation, QCallException* qcallError); +extern "C" void QCALLTYPE ReflectionInvocation_PrepareMethod(MethodDesc* pMD, TypeHandle *pInstantiation, UINT32 cInstantiation, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ReflectionInvocation_PrepareDelegate(QCall::ObjectHandleOnStack delegate, QCallException* qcallError); +extern "C" void QCALLTYPE ReflectionInvocation_PrepareDelegate(QCall::ObjectHandleOnStack delegate, QCallExceptionStatus* qcallError); #ifdef FEATURE_COMINTEROP extern "C" void QCALLTYPE ReflectionInvocation_InvokeDispMethod( @@ -69,14 +69,14 @@ extern "C" void QCALLTYPE ReflectionInvocation_InvokeDispMethod( LCID lcid, QCall::ObjectHandleOnStack namedParameters, QCall::ObjectHandleOnStack result, - QCallException* qcallError); + QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ReflectionInvocation_GetComObjectGuid(QCall::ObjectHandleOnStack type, GUID* result, QCallException* qcallError); +extern "C" void QCALLTYPE ReflectionInvocation_GetComObjectGuid(QCall::ObjectHandleOnStack type, GUID* result, QCallExceptionStatus* qcallError); #endif // FEATURE_COMINTEROP -extern "C" void QCALLTYPE ReflectionInvocation_GetGuid(MethodTable* pMT, GUID* result, QCallException* qcallError); +extern "C" void QCALLTYPE ReflectionInvocation_GetGuid(MethodTable* pMT, GUID* result, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ReflectionSerialization_GetCreateUninitializedObjectInfo(QCall::TypeHandle pType, PCODE* ppfnAllocator, void** pvAllocatorFirstArg, QCallException* qcallError); +extern "C" void QCALLTYPE ReflectionSerialization_GetCreateUninitializedObjectInfo(QCall::TypeHandle pType, PCODE* ppfnAllocator, void** pvAllocatorFirstArg, QCallExceptionStatus* qcallError); extern "C" void QCALLTYPE ReflectionInvocation_GetBoxInfo( QCall::TypeHandle pType, @@ -84,9 +84,9 @@ extern "C" void QCALLTYPE ReflectionInvocation_GetBoxInfo( void** pvAllocatorFirstArg, int32_t* pValueOffset, uint32_t* pValueSize, - QCallException* qcallError); + QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE Enum_GetValuesAndNames(QCall::TypeHandle pEnumType, QCall::ObjectHandleOnStack pReturnValues, QCall::ObjectHandleOnStack pReturnNames, BOOL fGetNames, QCallException* qcallError); +extern "C" void QCALLTYPE Enum_GetValuesAndNames(QCall::TypeHandle pEnumType, QCall::ObjectHandleOnStack pReturnValues, QCall::ObjectHandleOnStack pReturnNames, BOOL fGetNames, QCallExceptionStatus* qcallError); extern "C" int32_t QCALLTYPE ReflectionInvocation_SizeOf(QCall::TypeHandle pType); diff --git a/src/coreclr/vm/runtimehandles.cpp b/src/coreclr/vm/runtimehandles.cpp index f2ed15a7455b21..e3d7f3b5ce82d2 100644 --- a/src/coreclr/vm/runtimehandles.cpp +++ b/src/coreclr/vm/runtimehandles.cpp @@ -33,7 +33,7 @@ #include "finalizerthread.h" #include "pregeneratedstringthunks.h" -extern "C" BOOL QCALLTYPE MdUtf8String_EqualsCaseInsensitive(LPCUTF8 szLhs, LPCUTF8 szRhs, INT32 stringNumBytes, QCallException* qcallError) +extern "C" BOOL QCALLTYPE MdUtf8String_EqualsCaseInsensitive(LPCUTF8 szLhs, LPCUTF8 szRhs, INT32 stringNumBytes, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -99,7 +99,7 @@ extern "C" BOOL QCALLTYPE RuntimeMethodHandle_IsCAVisibleFromDecoratedType( MethodDesc * pTargetCtor, QCall::TypeHandle sourceTypeHandle, QCall::ModuleHandle sourceModuleHandle, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -142,7 +142,7 @@ extern "C" BOOL QCALLTYPE RuntimeMethodHandle_IsCAVisibleFromDecoratedType( extern "C" void QCALLTYPE RuntimeTypeHandle_GetRuntimeTypeFromHandleSlow( EnregisteredTypeHandle typeHandleRaw, QCall::ObjectHandleOnStack result, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -160,7 +160,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_GetRuntimeTypeFromHandleSlow( } #ifdef FEATURE_TYPEEQUIVALENCE -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsEquivalentTo(QCall::TypeHandle rtType1, QCall::TypeHandle rtType2, QCallException* qcallError) +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsEquivalentTo(QCall::TypeHandle rtType1, QCall::TypeHandle rtType2, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -234,7 +234,7 @@ FCIMPL1(AssemblyBaseObject*, RuntimeTypeHandle::GetAssemblyIfExists, ReflectClas } FCIMPLEND -extern "C" void QCALLTYPE RuntimeTypeHandle_GetAssemblySlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack assembly, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetAssemblySlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack assembly, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -291,7 +291,7 @@ FCIMPL1(ReflectModuleBaseObject*, RuntimeTypeHandle::GetModuleIfExists, ReflectC } FCIMPLEND -extern "C" void QCALLTYPE RuntimeTypeHandle_GetModuleSlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack module, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetModuleSlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack module, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -364,7 +364,7 @@ FCIMPL1(INT32, RuntimeTypeHandle::GetNumVirtuals, ReflectClassBaseObject* pTypeU } FCIMPLEND -extern "C" INT32 QCALLTYPE RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals(QCall::TypeHandle pTypeHandle, QCallException* qcallError) +extern "C" INT32 QCALLTYPE RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals(QCall::TypeHandle pTypeHandle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -398,7 +398,7 @@ extern "C" INT32 QCALLTYPE RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals(QCa return numVirtuals; } -extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetMethodAt(MethodTable* pMT, INT32 slot, QCallException* qcallError) +extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetMethodAt(MethodTable* pMT, INT32 slot, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -457,7 +457,7 @@ extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetMethodAt(MethodTable* pMT, return pRetMethod; } -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_GetFields(MethodTable* pMT, intptr_t* result, INT32* pCount, QCallException* qcallError) +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_GetFields(MethodTable* pMT, intptr_t* result, INT32* pCount, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -491,7 +491,7 @@ extern "C" BOOL QCALLTYPE RuntimeTypeHandle_GetFields(MethodTable* pMT, intptr_t return retVal; } -extern "C" void QCALLTYPE RuntimeMethodHandle_ConstructInstantiation(MethodDesc * pMethod, DWORD format, QCall::StringHandleOnStack retString, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeMethodHandle_ConstructInstantiation(MethodDesc * pMethod, DWORD format, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -504,7 +504,7 @@ extern "C" void QCALLTYPE RuntimeMethodHandle_ConstructInstantiation(MethodDesc END_QCALL; } -extern "C" void QCALLTYPE RuntimeTypeHandle_ConstructName(QCall::TypeHandle pTypeHandle, DWORD format, QCall::StringHandleOnStack retString, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeTypeHandle_ConstructName(QCall::TypeHandle pTypeHandle, DWORD format, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -517,7 +517,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_ConstructName(QCall::TypeHandle pTyp END_QCALL; } -extern "C" void QCALLTYPE RuntimeTypeHandle_GetInterfaces(MethodTable* pMT, QCall::ObjectHandleOnStack result, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetInterfaces(MethodTable* pMT, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -598,7 +598,7 @@ static PTRARRAYREF CopyRuntimeTypeHandles(TypeHandle * prgTH, INT32 numTypeHandl return refReturn; } -extern "C" void QCALLTYPE RuntimeTypeHandle_GetConstraints(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retTypeArray, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetConstraints(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retTypeArray, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -646,7 +646,7 @@ FCIMPL1(INT32, RuntimeTypeHandle::GetAttributes, ReflectClassBaseObject *pTypeUN } FCIMPLEND -extern "C" void QCALLTYPE RuntimeTypeHandle_GetArgumentTypesFromFunctionPointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack argTypes, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetArgumentTypesFromFunctionPointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack argTypes, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -708,7 +708,7 @@ FCIMPL1(FC_BOOL_RET, RuntimeTypeHandle::IsUnmanagedFunctionPointer, ReflectClass } FCIMPLEND -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsVisible(QCall::TypeHandle pTypeHandle, QCallException* qcallError) +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsVisible(QCall::TypeHandle pTypeHandle, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -777,7 +777,7 @@ FCIMPL1(INT32, RuntimeTypeHandle::GetToken, ReflectClassBaseObject *pTypeUNSAFE) } FCIMPLEND -extern "C" PVOID QCALLTYPE QCall_GetGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, INT32 handleType, QCallException* qcallError) +extern "C" PVOID QCALLTYPE QCall_GetGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, INT32 handleType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -798,7 +798,7 @@ extern "C" PVOID QCALLTYPE QCall_GetGCHandleForTypeHandle(QCall::TypeHandle pTyp return objHandle; } -extern "C" void QCALLTYPE QCall_FreeGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, OBJECTHANDLE objHandle, QCallException* qcallError) +extern "C" void QCALLTYPE QCall_FreeGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, OBJECTHANDLE objHandle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -813,7 +813,7 @@ extern "C" void QCALLTYPE QCall_FreeGCHandleForTypeHandle(QCall::TypeHandle pTyp END_QCALL; } -extern "C" void QCALLTYPE RuntimeTypeHandle_VerifyInterfaceIsImplemented(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pIFaceHandle, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeTypeHandle_VerifyInterfaceIsImplemented(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pIFaceHandle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -849,7 +849,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_VerifyInterfaceIsImplemented(QCall:: END_QCALL; } -extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetInterfaceMethodImplementation(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pOwner, MethodDesc * pMD, QCallException* qcallError) +extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetInterfaceMethodImplementation(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pOwner, MethodDesc * pMD, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -885,7 +885,7 @@ extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetInterfaceMethodImplementat return pResult; } -extern "C" void QCALLTYPE RuntimeTypeHandle_GetDeclaringMethodForGenericParameter(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack result, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetDeclaringMethodForGenericParameter(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -907,7 +907,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_GetDeclaringMethodForGenericParamete END_QCALL; } -extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandleForGenericVariable(EnregisteredTypeHandle pTypeHandle, QCallException* qcallError) +extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandleForGenericVariable(EnregisteredTypeHandle pTypeHandle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -952,7 +952,7 @@ extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHa return (EnregisteredTypeHandle)retTypeHandle.AsTAddr(); } -extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandle(EnregisteredTypeHandle pTypeHandle, QCallException* qcallError) +extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandle(EnregisteredTypeHandle pTypeHandle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -986,7 +986,7 @@ extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHa return (EnregisteredTypeHandle)retTypeHandle.AsTAddr(); } -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_SatisfiesConstraints(QCall::TypeHandle paramType, QCall::TypeHandle typeContext, MethodDesc* methodContext, QCall::TypeHandle toType, QCallException* qcallError) +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_SatisfiesConstraints(QCall::TypeHandle paramType, QCall::TypeHandle typeContext, MethodDesc* methodContext, QCall::TypeHandle toType, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -1019,7 +1019,7 @@ extern "C" BOOL QCALLTYPE RuntimeTypeHandle_SatisfiesConstraints(QCall::TypeHand return bResult; } -extern "C" void QCALLTYPE RuntimeTypeHandle_GetInstantiation(QCall::TypeHandle pType, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetInstantiation(QCall::TypeHandle pType, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1034,7 +1034,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_GetInstantiation(QCall::TypeHandle p return; } -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeArray(QCall::TypeHandle pTypeHandle, INT32 rank, QCall::ObjectHandleOnStack retType, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeArray(QCall::TypeHandle pTypeHandle, INT32 rank, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1049,7 +1049,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_MakeArray(QCall::TypeHandle pTypeHan return; } -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeSZArray(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeSZArray(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1064,7 +1064,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_MakeSZArray(QCall::TypeHandle pTypeH return; } -extern "C" void QCALLTYPE RuntimeTypeHandle_MakePointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeTypeHandle_MakePointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1079,7 +1079,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_MakePointer(QCall::TypeHandle pTypeH return; } -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1094,7 +1094,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHan return; } -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeFunctionPointer(TypeHandle* pRetAndArgTypes, INT32 numArgs, BOOL isUnmanaged, QCall::ObjectHandleOnStack retType, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeFunctionPointer(TypeHandle* pRetAndArgTypes, INT32 numArgs, BOOL isUnmanaged, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1110,7 +1110,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_MakeFunctionPointer(TypeHandle* pRet return; } -extern "C" void QCALLTYPE RuntimeTypeHandle_Instantiate(QCall::TypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeTypeHandle_Instantiate(QCall::TypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1125,7 +1125,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_Instantiate(QCall::TypeHandle pTypeH return; } -extern "C" void QCALLTYPE RuntimeTypeHandle_GetGenericTypeDefinition(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetGenericTypeDefinition(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1229,7 +1229,7 @@ FCIMPL1(FC_BOOL_RET, RuntimeTypeHandle::ContainsGenericVariables, PTR_ReflectCla } FCIMPLEND -extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemory(QCall::TypeHandle type, uint32_t size, QCallException* qcallError) +extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemory(QCall::TypeHandle type, uint32_t size, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1252,7 +1252,7 @@ extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemory(QCall: return allocatedMemory; } -extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemoryAligned(QCall::TypeHandle type, uint32_t size, uint32_t alignment, QCallException* qcallError) +extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemoryAligned(QCall::TypeHandle type, uint32_t size, uint32_t alignment, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1278,7 +1278,7 @@ extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemoryAligned return allocatedMemory; } -extern "C" void QCALLTYPE RuntimeTypeHandle_RegisterCollectibleTypeDependency(QCall::TypeHandle pTypeHandle, QCall::AssemblyHandle pAssembly, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeTypeHandle_RegisterCollectibleTypeDependency(QCall::TypeHandle pTypeHandle, QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1305,7 +1305,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_RegisterCollectibleTypeDependency(QC //*********************************************************************************** //*********************************************************************************** -extern "C" void * QCALLTYPE RuntimeMethodHandle_GetFunctionPointer(MethodDesc * pMethod, QCallException* qcallError) +extern "C" void * QCALLTYPE RuntimeMethodHandle_GetFunctionPointer(MethodDesc * pMethod, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1488,7 +1488,7 @@ extern "C" void QCALLTYPE Signature_GetCustomModifiersAtOffset( INT32 offset, BOOL fRequired, QCall::ObjectHandleOnStack result, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1613,7 +1613,7 @@ extern "C" void QCALLTYPE Signature_Init( PCCOR_SIGNATURE pCorSig, DWORD cCorSig, FieldDesc* pFieldDesc, MethodDesc* pMethodDesc, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1715,7 +1715,7 @@ extern "C" void QCALLTYPE Signature_Init( extern "C" BOOL QCALLTYPE Signature_AreEqual( PCCOR_SIGNATURE sig1, INT32 cSig1, QCall::TypeHandle handle1, PCCOR_SIGNATURE sig2, INT32 cSig2, QCall::TypeHandle handle2, - QCallException* qcallError) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1733,7 +1733,7 @@ extern "C" BOOL QCALLTYPE Signature_AreEqual( return ret; } -extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1793,7 +1793,7 @@ FCIMPL1(Object*, RuntimeMethodHandle::GetResolver, MethodDesc * pMethod) } FCIMPLEND -extern "C" void QCALLTYPE RuntimeMethodHandle_Destroy(MethodDesc * pMethod, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeMethodHandle_Destroy(MethodDesc * pMethod, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(pMethod != NULL); @@ -1837,7 +1837,7 @@ FCIMPL1(FC_BOOL_RET, RuntimeMethodHandle::IsTypicalMethodDefinition, ReflectMeth } FCIMPLEND -extern "C" void QCALLTYPE RuntimeMethodHandle_GetTypicalMethodDefinition(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeMethodHandle_GetTypicalMethodDefinition(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1859,7 +1859,7 @@ extern "C" void QCALLTYPE RuntimeMethodHandle_GetTypicalMethodDefinition(MethodD return; } -extern "C" void QCALLTYPE RuntimeMethodHandle_StripMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeMethodHandle_StripMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1944,7 +1944,7 @@ FCIMPL2(MethodDesc*, RuntimeMethodHandle::GetStubIfNeededInternal, FCIMPLEND // See RuntimeMethodHandle::GetStubIfNeededInternal for more details. -extern "C" MethodDesc* QCALLTYPE RuntimeMethodHandle_GetStubIfNeededSlow(MethodDesc* pMethod, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack methodInstantiation, QCallException* qcallError) +extern "C" MethodDesc* QCALLTYPE RuntimeMethodHandle_GetStubIfNeededSlow(MethodDesc* pMethod, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack methodInstantiation, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -2011,7 +2011,7 @@ FCIMPL2(MethodDesc*, RuntimeMethodHandle::GetMethodFromCanonical, MethodDesc *pM } FCIMPLEND -extern "C" PCODE QCALLTYPE RuntimeMethodHandle_GetNativeCode(MethodDesc* pMethod, QCallException* qcallError) +extern "C" PCODE QCALLTYPE RuntimeMethodHandle_GetNativeCode(MethodDesc* pMethod, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -2038,7 +2038,7 @@ extern "C" PCODE QCALLTYPE RuntimeMethodHandle_GetNativeCode(MethodDesc* pMethod return result; } -extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodBody(MethodDesc* pMethod, QCall::TypeHandle pDeclaringType, QCall::ObjectHandleOnStack result, QCallException* qcallError) +extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodBody(MethodDesc* pMethod, QCall::TypeHandle pDeclaringType, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -2337,7 +2337,7 @@ FCIMPL1(INT32, AssemblyHandle::GetTokenInternal, AssemblyBaseObject* pAssemblyUN } FCIMPLEND -extern "C" void QCALLTYPE AssemblyHandle_GetManifestModuleSlow(QCall::ObjectHandleOnStack assembly, QCall::ObjectHandleOnStack module, QCallException* qcallError) +extern "C" void QCALLTYPE AssemblyHandle_GetManifestModuleSlow(QCall::ObjectHandleOnStack assembly, QCall::ObjectHandleOnStack module, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -2352,7 +2352,7 @@ extern "C" void QCALLTYPE AssemblyHandle_GetManifestModuleSlow(QCall::ObjectHand END_QCALL; } -extern "C" void QCALLTYPE ModuleHandle_GetPEKind(QCall::ModuleHandle pModule, DWORD* pdwPEKind, DWORD* pdwMachine, QCallException* qcallError) +extern "C" void QCALLTYPE ModuleHandle_GetPEKind(QCall::ModuleHandle pModule, DWORD* pdwPEKind, DWORD* pdwMachine, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -2368,7 +2368,7 @@ extern "C" INT32 QCALLTYPE ModuleHandle_GetMDStreamVersion(QCall::ModuleHandle p return pModule->GetMDImport()->GetMetadataStreamVersion(); } -extern "C" void QCALLTYPE ModuleHandle_GetModuleType(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retType, QCallException* qcallError) +extern "C" void QCALLTYPE ModuleHandle_GetModuleType(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -2400,7 +2400,7 @@ extern "C" INT32 QCALLTYPE ModuleHandle_GetToken(QCall::ModuleHandle pModule) return pModule->GetMDImport()->GetModuleFromScope(); } -extern "C" void QCALLTYPE ModuleHandle_ResolveType(QCall::ModuleHandle pModule, INT32 tkType, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retType, QCallException* qcallError) +extern "C" void QCALLTYPE ModuleHandle_ResolveType(QCall::ModuleHandle pModule, INT32 tkType, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -2421,7 +2421,7 @@ extern "C" void QCALLTYPE ModuleHandle_ResolveType(QCall::ModuleHandle pModule, return; } -extern "C" MethodDesc *QCALLTYPE ModuleHandle_ResolveMethod(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCallException* qcallError) +extern "C" MethodDesc *QCALLTYPE ModuleHandle_ResolveMethod(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -2442,7 +2442,7 @@ extern "C" MethodDesc *QCALLTYPE ModuleHandle_ResolveMethod(QCall::ModuleHandle return pMD; } -extern "C" void QCALLTYPE ModuleHandle_ResolveField(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retField, QCallException* qcallError) +extern "C" void QCALLTYPE ModuleHandle_ResolveField(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retField, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -2460,7 +2460,7 @@ extern "C" void QCALLTYPE ModuleHandle_ResolveField(QCall::ModuleHandle pModule, return; } -extern "C" void QCALLTYPE ModuleHandle_GetDynamicMethod(QCall::ModuleHandle pModule, const char* name, byte* sig, INT32 sigLen, QCall::ObjectHandleOnStack resolver, QCall::ObjectHandleOnStack result, QCallException* qcallError) +extern "C" void QCALLTYPE ModuleHandle_GetDynamicMethod(QCall::ModuleHandle pModule, const char* name, byte* sig, INT32 sigLen, QCall::ObjectHandleOnStack resolver, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) { CONTRACTL { diff --git a/src/coreclr/vm/runtimehandles.h b/src/coreclr/vm/runtimehandles.h index e75ed28afc6dc5..0d366b257f5ab1 100644 --- a/src/coreclr/vm/runtimehandles.h +++ b/src/coreclr/vm/runtimehandles.h @@ -96,7 +96,7 @@ class RuntimeLocalVariableInfo : public Object CLR_BOOL _isPinned; }; -extern "C" BOOL QCALLTYPE MdUtf8String_EqualsCaseInsensitive(LPCUTF8 szLhs, LPCUTF8 szRhs, INT32 stringNumBytes, QCallException* qcallError); +extern "C" BOOL QCALLTYPE MdUtf8String_EqualsCaseInsensitive(LPCUTF8 szLhs, LPCUTF8 szRhs, INT32 stringNumBytes, QCallExceptionStatus* qcallError); class RuntimeTypeHandle { @@ -129,19 +129,19 @@ class RuntimeTypeHandle FCDECL1(static void, GetNextIntroducedMethod, MethodDesc **ppMethod); }; -extern "C" void QCALLTYPE RuntimeTypeHandle_GetRuntimeTypeFromHandleSlow(void* typeHandleRaw, QCall::ObjectHandleOnStack result, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetRuntimeTypeFromHandleSlow(void* typeHandleRaw, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); #ifdef FEATURE_TYPEEQUIVALENCE -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsEquivalentTo(QCall::TypeHandle rtType1, QCall::TypeHandle rtType2, QCallException* qcallError); +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsEquivalentTo(QCall::TypeHandle rtType1, QCall::TypeHandle rtType2, QCallExceptionStatus* qcallError); #endif // FEATURE_TYPEEQUIVALENCE -extern "C" void QCALLTYPE RuntimeTypeHandle_CreateInstanceForAnotherGenericParameter(QCall::TypeHandle pTypeHandle, TypeHandle *pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack pInstantiatedObject, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAlloc(MethodTable* pMT, QCall::ObjectHandleOnStack allocated, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_CreateInstanceForAnotherGenericParameter(QCall::TypeHandle pTypeHandle, TypeHandle *pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack pInstantiatedObject, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAlloc(MethodTable* pMT, QCall::ObjectHandleOnStack allocated, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAllocNoChecks(MethodTable* pMT, QCall::ObjectHandleOnStack allocated, QCallException* qcallError); -extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemory(QCall::TypeHandle type, uint32_t size, QCallException* qcallError); -extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemoryAligned(QCall::TypeHandle type, uint32_t size, uint32_t alignment, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAllocNoChecks(MethodTable* pMT, QCall::ObjectHandleOnStack allocated, QCallExceptionStatus* qcallError); +extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemory(QCall::TypeHandle type, uint32_t size, QCallExceptionStatus* qcallError); +extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemoryAligned(QCall::TypeHandle type, uint32_t size, uint32_t alignment, QCallExceptionStatus* qcallError); -extern "C" PVOID QCALLTYPE QCall_GetGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, INT32 handleType, QCallException* qcallError); -extern "C" void QCALLTYPE QCall_FreeGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, OBJECTHANDLE objHandle, QCallException* qcallError); +extern "C" PVOID QCALLTYPE QCall_GetGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, INT32 handleType, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE QCall_FreeGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, OBJECTHANDLE objHandle, QCallExceptionStatus* qcallError); extern "C" void QCALLTYPE RuntimeTypeHandle_GetActivationInfo( QCall::ObjectHandleOnStack pRuntimeType, @@ -150,36 +150,36 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_GetActivationInfo( PCODE* ppfnCtor, PCODE* ppfnValueCtor, BOOL* pfCtorIsPublic, - QCallException* qcallError); + QCallExceptionStatus* qcallError); #ifdef FEATURE_COMINTEROP -extern "C" void QCALLTYPE RuntimeTypeHandle_AllocateComObject(void* pClassFactory, QCall::ObjectHandleOnStack result, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_AllocateComObject(void* pClassFactory, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); #endif // FEATURE_COMINTEROP -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_MakePointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeSZArray(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeArray(QCall::TypeHandle pTypeHandle, INT32 rank, QCall::ObjectHandleOnStack retType, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeFunctionPointer(TypeHandle* pRetAndArgTypes, INT32 numArgs, BOOL isUnmanaged, QCall::ObjectHandleOnStack retType, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_MakePointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeSZArray(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeArray(QCall::TypeHandle pTypeHandle, INT32 rank, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeFunctionPointer(TypeHandle* pRetAndArgTypes, INT32 numArgs, BOOL isUnmanaged, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); extern "C" void QCALLTYPE RuntimeTypeHandle_PrepareMemberInfoCache(QCall::TypeHandle pMemberInfoCache); -extern "C" void QCALLTYPE RuntimeTypeHandle_ConstructName(QCall::TypeHandle pTypeHandle, DWORD format, QCall::StringHandleOnStack retString, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetInterfaces(MethodTable* pMT, QCall::ObjectHandleOnStack result, QCallException* qcallError); -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsVisible(QCall::TypeHandle pTypeHandle, QCallException* qcallError); -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_SatisfiesConstraints(QCall::TypeHandle paramType, QCall::TypeHandle typeContext, MethodDesc* methodContext, QCall::TypeHandle toType, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetInstantiation(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, BOOL fAsRuntimeTypeArray, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_Instantiate(QCall::TypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetGenericTypeDefinition(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetConstraints(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retTypes, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetArgumentTypesFromFunctionPointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack argTypes, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetAssemblySlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack assembly, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetModuleSlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack module, QCallException* qcallError); -extern "C" INT32 QCALLTYPE RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals(QCall::TypeHandle pTypeHandle, QCallException* qcallError); -extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetMethodAt(MethodTable* pMT, INT32 slot, QCallException* qcallError); -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_GetFields(MethodTable* pMT, intptr_t* result, INT32* pCount, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_VerifyInterfaceIsImplemented(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pIFaceHandle, QCallException* qcallError); -extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetInterfaceMethodImplementation(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pOwner, MethodDesc * pMD, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetDeclaringMethodForGenericParameter(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack result, QCallException* qcallError); -extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandleForGenericVariable(EnregisteredTypeHandle pTypeHandle, QCallException* qcallError); -extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandle(EnregisteredTypeHandle pTypeHandle, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_RegisterCollectibleTypeDependency(QCall::TypeHandle pTypeHandle, QCall::AssemblyHandle pAssembly, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_ConstructName(QCall::TypeHandle pTypeHandle, DWORD format, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetInterfaces(MethodTable* pMT, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsVisible(QCall::TypeHandle pTypeHandle, QCallExceptionStatus* qcallError); +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_SatisfiesConstraints(QCall::TypeHandle paramType, QCall::TypeHandle typeContext, MethodDesc* methodContext, QCall::TypeHandle toType, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetInstantiation(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, BOOL fAsRuntimeTypeArray, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_Instantiate(QCall::TypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetGenericTypeDefinition(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetConstraints(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retTypes, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetArgumentTypesFromFunctionPointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack argTypes, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetAssemblySlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack assembly, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetModuleSlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack module, QCallExceptionStatus* qcallError); +extern "C" INT32 QCALLTYPE RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals(QCall::TypeHandle pTypeHandle, QCallExceptionStatus* qcallError); +extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetMethodAt(MethodTable* pMT, INT32 slot, QCallExceptionStatus* qcallError); +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_GetFields(MethodTable* pMT, intptr_t* result, INT32* pCount, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_VerifyInterfaceIsImplemented(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pIFaceHandle, QCallExceptionStatus* qcallError); +extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetInterfaceMethodImplementation(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pOwner, MethodDesc * pMD, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetDeclaringMethodForGenericParameter(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); +extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandleForGenericVariable(EnregisteredTypeHandle pTypeHandle, QCallExceptionStatus* qcallError); +extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandle(EnregisteredTypeHandle pTypeHandle, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_RegisterCollectibleTypeDependency(QCall::TypeHandle pTypeHandle, QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError); class RuntimeMethodHandle { @@ -214,16 +214,16 @@ class RuntimeMethodHandle FCDECL1(static Object*, GetLoaderAllocatorInternal, MethodDesc *pMethod); }; -extern "C" MethodDesc* QCALLTYPE MethodBase_GetCurrentMethod(QCall::StackCrawlMarkHandle stackMark, QCallException* qcallError); +extern "C" MethodDesc* QCALLTYPE MethodBase_GetCurrentMethod(QCall::StackCrawlMarkHandle stackMark, QCallExceptionStatus* qcallError); extern "C" BOOL QCALLTYPE RuntimeMethodHandle_IsCAVisibleFromDecoratedType( QCall::TypeHandle targetTypeHandle, MethodDesc * pTargetCtor, QCall::TypeHandle sourceTypeHandle, QCall::ModuleHandle sourceModuleHandle, - QCallException* qcallError); + QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray, QCallExceptionStatus* qcallError); extern "C" void QCALLTYPE RuntimeMethodHandle_InvokeMethod( QCall::ObjectHandleOnStack target, @@ -231,17 +231,17 @@ extern "C" void QCALLTYPE RuntimeMethodHandle_InvokeMethod( QCall::ObjectHandleOnStack pSigUNSAFE, BOOL fConstructor, QCall::ObjectHandleOnStack result, - QCallException* qcallError); + QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeMethodHandle_ConstructInstantiation(MethodDesc * pMethod, DWORD format, QCall::StringHandleOnStack retString, QCallException* qcallError); -extern "C" void* QCALLTYPE RuntimeMethodHandle_GetFunctionPointer(MethodDesc * pMethod, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeMethodHandle_ConstructInstantiation(MethodDesc * pMethod, DWORD format, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); +extern "C" void* QCALLTYPE RuntimeMethodHandle_GetFunctionPointer(MethodDesc * pMethod, QCallExceptionStatus* qcallError); extern "C" BOOL QCALLTYPE RuntimeMethodHandle_GetIsCollectible(MethodDesc * pMethod); -extern "C" void QCALLTYPE RuntimeMethodHandle_GetTypicalMethodDefinition(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeMethodHandle_StripMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeMethodHandle_Destroy(MethodDesc * pMethod, QCallException* qcallError); -extern "C" MethodDesc* QCALLTYPE RuntimeMethodHandle_GetStubIfNeededSlow(MethodDesc* pMethod, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack methodInstantiation, QCallException* qcallError); -extern "C" PCODE QCALLTYPE RuntimeMethodHandle_GetNativeCode(MethodDesc* pMethod, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodBody(MethodDesc* pMethod, QCall::TypeHandle pDeclaringType, QCall::ObjectHandleOnStack result, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeMethodHandle_GetTypicalMethodDefinition(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeMethodHandle_StripMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeMethodHandle_Destroy(MethodDesc * pMethod, QCallExceptionStatus* qcallError); +extern "C" MethodDesc* QCALLTYPE RuntimeMethodHandle_GetStubIfNeededSlow(MethodDesc* pMethod, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack methodInstantiation, QCallExceptionStatus* qcallError); +extern "C" PCODE QCALLTYPE RuntimeMethodHandle_GetNativeCode(MethodDesc* pMethod, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodBody(MethodDesc* pMethod, QCall::TypeHandle pDeclaringType, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); class RuntimeFieldHandle { @@ -259,28 +259,28 @@ class RuntimeFieldHandle FCDECL1(static Object*, GetLoaderAllocatorInternal, FieldDesc *pField); }; -extern "C" void QCALLTYPE RuntimeFieldHandle_GetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL *pIsClassInitialized, QCall::ObjectHandleOnStack result, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeFieldHandle_SetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::ObjectHandleOnStack value, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeFieldHandle_GetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack result, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeFieldHandle_SetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::ObjectHandleOnStack newValue, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, QCallException* qcallError); -extern "C" void* QCALLTYPE RuntimeFieldHandle_GetEnCFieldAddr(QCall::ObjectHandleOnStack target, FieldDesc* pFD, QCallException* qcallError); -extern "C" BOOL QCALLTYPE RuntimeFieldHandle_GetRVAFieldInfo(FieldDesc* pField, void** address, UINT* size, QCallException* qcallError); -extern "C" void QCALLTYPE RuntimeFieldHandle_GetFieldDataReference(FieldDesc* pField, QCall::ObjectHandleOnStack instance, QCall::ByteRefOnStack offset, QCallException* qcallError); +extern "C" void QCALLTYPE RuntimeFieldHandle_GetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL *pIsClassInitialized, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeFieldHandle_SetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::ObjectHandleOnStack value, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeFieldHandle_GetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeFieldHandle_SetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::ObjectHandleOnStack newValue, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, QCallExceptionStatus* qcallError); +extern "C" void* QCALLTYPE RuntimeFieldHandle_GetEnCFieldAddr(QCall::ObjectHandleOnStack target, FieldDesc* pFD, QCallExceptionStatus* qcallError); +extern "C" BOOL QCALLTYPE RuntimeFieldHandle_GetRVAFieldInfo(FieldDesc* pField, void** address, UINT* size, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeFieldHandle_GetFieldDataReference(FieldDesc* pField, QCall::ObjectHandleOnStack instance, QCall::ByteRefOnStack offset, QCallExceptionStatus* qcallError); extern "C" INT32 QCALLTYPE ModuleHandle_GetMDStreamVersion(QCall::ModuleHandle pModule); -extern "C" void QCALLTYPE ModuleHandle_GetModuleType(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retType, QCallException* qcallError); +extern "C" void QCALLTYPE ModuleHandle_GetModuleType(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); extern "C" INT32 QCALLTYPE ModuleHandle_GetToken(QCall::ModuleHandle pModule); -extern "C" void QCALLTYPE ModuleHandle_ResolveType(QCall::ModuleHandle pModule, INT32 tkType, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retType, QCallException* qcallError); +extern "C" void QCALLTYPE ModuleHandle_ResolveType(QCall::ModuleHandle pModule, INT32 tkType, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); -extern "C" MethodDesc * QCALLTYPE ModuleHandle_ResolveMethod(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCallException* qcallError); +extern "C" MethodDesc * QCALLTYPE ModuleHandle_ResolveMethod(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ModuleHandle_ResolveField(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retField, QCallException* qcallError); +extern "C" void QCALLTYPE ModuleHandle_ResolveField(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retField, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ModuleHandle_GetPEKind(QCall::ModuleHandle pModule, DWORD* pdwPEKind, DWORD* pdwMachine, QCallException* qcallError); +extern "C" void QCALLTYPE ModuleHandle_GetPEKind(QCall::ModuleHandle pModule, DWORD* pdwPEKind, DWORD* pdwMachine, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ModuleHandle_GetDynamicMethod(QCall::ModuleHandle pModule, const char* name, byte* sig, INT32 sigLen, QCall::ObjectHandleOnStack resolver, QCall::ObjectHandleOnStack result, QCallException* qcallError); +extern "C" void QCALLTYPE ModuleHandle_GetDynamicMethod(QCall::ModuleHandle pModule, const char* name, byte* sig, INT32 sigLen, QCall::ObjectHandleOnStack resolver, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); class AssemblyHandle { @@ -289,26 +289,26 @@ class AssemblyHandle FCDECL1(static INT32, GetTokenInternal, AssemblyBaseObject *pAssemblyUNSAFE); }; -extern "C" void QCALLTYPE AssemblyHandle_GetManifestModuleSlow(QCall::ObjectHandleOnStack assembly, QCall::ObjectHandleOnStack module, QCallException* qcallError); +extern "C" void QCALLTYPE AssemblyHandle_GetManifestModuleSlow(QCall::ObjectHandleOnStack assembly, QCall::ObjectHandleOnStack module, QCallExceptionStatus* qcallError); extern "C" void QCALLTYPE Signature_Init( QCall::ObjectHandleOnStack sigObj, PCCOR_SIGNATURE pCorSig, DWORD cCorSig, FieldDesc* pFieldDesc, MethodDesc* pMethodDesc, - QCallException* qcallError); + QCallExceptionStatus* qcallError); extern "C" BOOL QCALLTYPE Signature_AreEqual( PCCOR_SIGNATURE sig1, INT32 cSig1, QCall::TypeHandle handle1, PCCOR_SIGNATURE sig2, INT32 cSig2, QCall::TypeHandle handle2, - QCallException* qcallError); + QCallExceptionStatus* qcallError); extern "C" void QCALLTYPE Signature_GetCustomModifiersAtOffset( QCall::ObjectHandleOnStack sigObj, INT32 offset, BOOL fRequired, QCall::ObjectHandleOnStack result, - QCallException* qcallError); + QCallExceptionStatus* qcallError); class SignatureNative : public Object { @@ -317,7 +317,7 @@ class SignatureNative : public Object PCCOR_SIGNATURE pCorSig, DWORD cCorSig, FieldDesc* pFieldDesc, MethodDesc* pMethodDesc, - QCallException* qcallError); + QCallExceptionStatus* qcallError); friend class ArgIteratorForMethodInvoke; public: diff --git a/src/coreclr/vm/stackwalk.h b/src/coreclr/vm/stackwalk.h index af1cbefbb59857..dc6ae465668ea8 100644 --- a/src/coreclr/vm/stackwalk.h +++ b/src/coreclr/vm/stackwalk.h @@ -40,7 +40,7 @@ namespace AsmOffsetsAsserts class AsmOffsets; }; -extern "C" void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo, QCallException* qcallError); +extern "C" void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo, QCallExceptionStatus* qcallError); class CrawlFrame { @@ -403,7 +403,7 @@ class CrawlFrame friend class EECodeManager; friend class StackFrameIterator; friend struct ExInfo; - friend void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo, QCallException* qcallError); + friend void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo, QCallExceptionStatus* qcallError); bool isFrameless; bool isFirst; diff --git a/src/coreclr/vm/stubhelpers.cpp b/src/coreclr/vm/stubhelpers.cpp index b2847025a7ee4e..e5032d80610206 100644 --- a/src/coreclr/vm/stubhelpers.cpp +++ b/src/coreclr/vm/stubhelpers.cpp @@ -313,7 +313,7 @@ FCIMPLEND #include -extern "C" IUnknown* QCALLTYPE StubHelpers_GetCOMIPFromRCWSlow(QCall::ObjectHandleOnStack pSrc, MethodDesc* pMD, void** ppTarget, BOOL* pfNeedsRelease, QCallException* qcallError) +extern "C" IUnknown* QCALLTYPE StubHelpers_GetCOMIPFromRCWSlow(QCall::ObjectHandleOnStack pSrc, MethodDesc* pMD, void** ppTarget, BOOL* pfNeedsRelease, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(pMD != NULL); @@ -360,7 +360,7 @@ extern "C" IUnknown* QCALLTYPE StubHelpers_GetCOMIPFromRCWSlow(QCall::ObjectHand return pIntf; } -extern "C" void QCALLTYPE ObjectMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pSrcUNSAFE, VARIANT* pDest, QCallException* qcallError) +extern "C" void QCALLTYPE ObjectMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pSrcUNSAFE, VARIANT* pDest, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -385,7 +385,7 @@ extern "C" void QCALLTYPE ObjectMarshaler_ConvertToNative(QCall::ObjectHandleOnS END_QCALL; } -extern "C" void QCALLTYPE ObjectMarshaler_ConvertToManaged(VARIANT* pSrc, QCall::ObjectHandleOnStack retObject, QCallException* qcallError) +extern "C" void QCALLTYPE ObjectMarshaler_ConvertToManaged(VARIANT* pSrc, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -407,7 +407,7 @@ extern "C" void QCALLTYPE ObjectMarshaler_ConvertToManaged(VARIANT* pSrc, QCall: } #include -extern "C" IUnknown* QCALLTYPE InterfaceMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pObjUNSAFE, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCallException* qcallError) +extern "C" IUnknown* QCALLTYPE InterfaceMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pObjUNSAFE, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -431,7 +431,7 @@ extern "C" IUnknown* QCALLTYPE InterfaceMarshaler_ConvertToNative(QCall::ObjectH return pIntf; } -extern "C" void QCALLTYPE InterfaceMarshaler_ConvertToManaged(IUnknown** ppUnk, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCall::ObjectHandleOnStack retObject, QCallException* qcallError) +extern "C" void QCALLTYPE InterfaceMarshaler_ConvertToManaged(IUnknown** ppUnk, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -454,7 +454,7 @@ extern "C" void QCALLTYPE InterfaceMarshaler_ConvertToManaged(IUnknown** ppUnk, } #include -extern "C" void QCALLTYPE InterfaceMarshaler_GetObjectForComCallableWrapperIUnknown(IUnknown* unk, QCall::ObjectHandleOnStack retObject, QCallException* qcallError) +extern "C" void QCALLTYPE InterfaceMarshaler_GetObjectForComCallableWrapperIUnknown(IUnknown* unk, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -467,7 +467,7 @@ extern "C" void QCALLTYPE InterfaceMarshaler_GetObjectForComCallableWrapperIUnkn END_QCALL; } -extern "C" void QCALLTYPE InterfaceMarshaler_ValidateComVisibilityForIUnknown(IUnknown* unk, QCallException* qcallError) +extern "C" void QCALLTYPE InterfaceMarshaler_ValidateComVisibilityForIUnknown(IUnknown* unk, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -493,7 +493,7 @@ FCIMPL0(void, StubHelpers::ClearLastError) } FCIMPLEND -extern "C" void QCALLTYPE StubHelpers_ThrowInteropParamException(INT resID, INT paramIdx, QCallException* qcallError) +extern "C" void QCALLTYPE StubHelpers_ThrowInteropParamException(INT resID, INT paramIdx, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -503,7 +503,7 @@ extern "C" void QCALLTYPE StubHelpers_ThrowInteropParamException(INT resID, INT } #ifdef PROFILING_SUPPORTED -extern "C" void* QCALLTYPE StubHelpers_ProfilerBeginTransitionCallback(MethodDesc* pTargetMD, QCallException* qcallError) +extern "C" void* QCALLTYPE StubHelpers_ProfilerBeginTransitionCallback(MethodDesc* pTargetMD, QCallExceptionStatus* qcallError) { PreserveLastErrorHolder preserveLastError; @@ -518,7 +518,7 @@ extern "C" void* QCALLTYPE StubHelpers_ProfilerBeginTransitionCallback(MethodDes return pTargetMD; } -extern "C" void QCALLTYPE StubHelpers_ProfilerEndTransitionCallback(MethodDesc* pTargetMD, QCallException* qcallError) +extern "C" void QCALLTYPE StubHelpers_ProfilerEndTransitionCallback(MethodDesc* pTargetMD, QCallExceptionStatus* qcallError) { PreserveLastErrorHolder preserveLastError; @@ -532,7 +532,7 @@ extern "C" void QCALLTYPE StubHelpers_ProfilerEndTransitionCallback(MethodDesc* } #endif // PROFILING_SUPPORTED -extern "C" void QCALLTYPE StubHelpers_MarshalToManagedVaList(va_list va, VARARGS* pArgIterator, QCallException* qcallError) +extern "C" void QCALLTYPE StubHelpers_MarshalToManagedVaList(va_list va, VARARGS* pArgIterator, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -541,7 +541,7 @@ extern "C" void QCALLTYPE StubHelpers_MarshalToManagedVaList(va_list va, VARARGS END_QCALL; } -extern "C" void QCALLTYPE StubHelpers_MarshalToUnmanagedVaList(va_list va, DWORD cbVaListSize, const VARARGS* pArgIterator, QCallException* qcallError) +extern "C" void QCALLTYPE StubHelpers_MarshalToUnmanagedVaList(va_list va, DWORD cbVaListSize, const VARARGS* pArgIterator, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -550,7 +550,7 @@ extern "C" void QCALLTYPE StubHelpers_MarshalToUnmanagedVaList(va_list va, DWORD END_QCALL; } -extern "C" void QCALLTYPE StubHelpers_ValidateObject(QCall::ObjectHandleOnStack pObj, MethodDesc *pMD, QCallException* qcallError) +extern "C" void QCALLTYPE StubHelpers_ValidateObject(QCall::ObjectHandleOnStack pObj, MethodDesc *pMD, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -581,7 +581,7 @@ extern "C" void QCALLTYPE StubHelpers_ValidateObject(QCall::ObjectHandleOnStack END_QCALL; } -extern "C" void QCALLTYPE StubHelpers_ValidateByref(void *pByref, MethodDesc *pMD, QCallException* qcallError) +extern "C" void QCALLTYPE StubHelpers_ValidateByref(void *pByref, MethodDesc *pMD, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -670,7 +670,7 @@ FCIMPL1(DWORD, StubHelpers::CalcVaListSize, VARARGS *varargs) } FCIMPLEND -extern "C" void QCALLTYPE StubHelpers_MulticastDebuggerTraceHelper(QCall::ObjectHandleOnStack element, INT32 count, QCallException* qcallError) +extern "C" void QCALLTYPE StubHelpers_MulticastDebuggerTraceHelper(QCall::ObjectHandleOnStack element, INT32 count, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -683,7 +683,7 @@ extern "C" void QCALLTYPE StubHelpers_MulticastDebuggerTraceHelper(QCall::Object END_QCALL; } -extern "C" void QCALLTYPE StubHelpers_CreateLayoutClassMarshalStubs(QCall::TypeHandle th, PCODE* pConvertToUnmanaged, PCODE* pConvertToManaged, PCODE* pFree, QCallException* qcallError) +extern "C" void QCALLTYPE StubHelpers_CreateLayoutClassMarshalStubs(QCall::TypeHandle th, PCODE* pConvertToUnmanaged, PCODE* pConvertToManaged, PCODE* pFree, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/stubhelpers.h b/src/coreclr/vm/stubhelpers.h index 87114099ae24ac..028a918acd471d 100644 --- a/src/coreclr/vm/stubhelpers.h +++ b/src/coreclr/vm/stubhelpers.h @@ -37,34 +37,34 @@ class StubHelpers FCDECL1(static DWORD, CalcVaListSize, VARARGS *varargs); }; -extern "C" void QCALLTYPE StubHelpers_CreateCustomMarshaler(MethodDesc* pMD, mdToken paramToken, TypeHandle hndManagedType, QCall::ObjectHandleOnStack retObject, QCallException* qcallError); +extern "C" void QCALLTYPE StubHelpers_CreateCustomMarshaler(MethodDesc* pMD, mdToken paramToken, TypeHandle hndManagedType, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); #ifdef PROFILING_SUPPORTED -extern "C" void* QCALLTYPE StubHelpers_ProfilerBeginTransitionCallback(MethodDesc* pTargetMD, QCallException* qcallError); -extern "C" void QCALLTYPE StubHelpers_ProfilerEndTransitionCallback(MethodDesc* pTargetMD, QCallException* qcallError); +extern "C" void* QCALLTYPE StubHelpers_ProfilerBeginTransitionCallback(MethodDesc* pTargetMD, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE StubHelpers_ProfilerEndTransitionCallback(MethodDesc* pTargetMD, QCallExceptionStatus* qcallError); #endif #ifdef FEATURE_COMINTEROP -extern "C" IUnknown* QCALLTYPE StubHelpers_GetCOMIPFromRCWSlow(QCall::ObjectHandleOnStack pSrc, MethodDesc* pMD, void** ppTarget, BOOL* pfNeedsRelease, QCallException* qcallError); +extern "C" IUnknown* QCALLTYPE StubHelpers_GetCOMIPFromRCWSlow(QCall::ObjectHandleOnStack pSrc, MethodDesc* pMD, void** ppTarget, BOOL* pfNeedsRelease, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ObjectMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pSrcUNSAFE, VARIANT* pDest, QCallException* qcallError); -extern "C" void QCALLTYPE ObjectMarshaler_ConvertToManaged(VARIANT* pSrc, QCall::ObjectHandleOnStack retObject, QCallException* qcallError); +extern "C" void QCALLTYPE ObjectMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pSrcUNSAFE, VARIANT* pDest, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ObjectMarshaler_ConvertToManaged(VARIANT* pSrc, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); -extern "C" IUnknown* QCALLTYPE InterfaceMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pObjUNSAFE, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCallException* qcallError); -extern "C" void QCALLTYPE InterfaceMarshaler_ConvertToManaged(IUnknown** ppUnk, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCall::ObjectHandleOnStack retObject, QCallException* qcallError); -extern "C" void QCALLTYPE InterfaceMarshaler_GetObjectForComCallableWrapperIUnknown(IUnknown* unk, QCall::ObjectHandleOnStack retObject, QCallException* qcallError); -extern "C" void QCALLTYPE InterfaceMarshaler_ValidateComVisibilityForIUnknown(IUnknown* unk, QCallException* qcallError); +extern "C" IUnknown* QCALLTYPE InterfaceMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pObjUNSAFE, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE InterfaceMarshaler_ConvertToManaged(IUnknown** ppUnk, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE InterfaceMarshaler_GetObjectForComCallableWrapperIUnknown(IUnknown* unk, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE InterfaceMarshaler_ValidateComVisibilityForIUnknown(IUnknown* unk, QCallExceptionStatus* qcallError); #endif -extern "C" void QCALLTYPE StubHelpers_ThrowInteropParamException(INT resID, INT paramIdx, QCallException* qcallError); +extern "C" void QCALLTYPE StubHelpers_ThrowInteropParamException(INT resID, INT paramIdx, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE StubHelpers_MarshalToManagedVaList(va_list va, VARARGS* pArgIterator, QCallException* qcallError); -extern "C" void QCALLTYPE StubHelpers_MarshalToUnmanagedVaList(va_list va, DWORD cbVaListSize, const VARARGS* pArgIterator, QCallException* qcallError); +extern "C" void QCALLTYPE StubHelpers_MarshalToManagedVaList(va_list va, VARARGS* pArgIterator, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE StubHelpers_MarshalToUnmanagedVaList(va_list va, DWORD cbVaListSize, const VARARGS* pArgIterator, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE StubHelpers_ValidateObject(QCall::ObjectHandleOnStack pObj, MethodDesc *pMD, QCallException* qcallError); -extern "C" void QCALLTYPE StubHelpers_ValidateByref(void *pByref, MethodDesc *pMD, QCallException* qcallError); +extern "C" void QCALLTYPE StubHelpers_ValidateObject(QCall::ObjectHandleOnStack pObj, MethodDesc *pMD, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE StubHelpers_ValidateByref(void *pByref, MethodDesc *pMD, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE StubHelpers_MulticastDebuggerTraceHelper(QCall::ObjectHandleOnStack element, INT32 count, QCallException* qcallError); +extern "C" void QCALLTYPE StubHelpers_MulticastDebuggerTraceHelper(QCall::ObjectHandleOnStack element, INT32 count, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE StubHelpers_CreateLayoutClassMarshalStubs(QCall::TypeHandle th, PCODE* pConvertToUnmanaged, PCODE* pConvertToManaged, PCODE* pFree, QCallException* qcallError); +extern "C" void QCALLTYPE StubHelpers_CreateLayoutClassMarshalStubs(QCall::TypeHandle th, PCODE* pConvertToUnmanaged, PCODE* pConvertToManaged, PCODE* pFree, QCallExceptionStatus* qcallError); #endif // __STUBHELPERS_h__ diff --git a/src/coreclr/vm/tailcallhelp.cpp b/src/coreclr/vm/tailcallhelp.cpp index bb239f7c78e7f8..97a1080187a262 100644 --- a/src/coreclr/vm/tailcallhelp.cpp +++ b/src/coreclr/vm/tailcallhelp.cpp @@ -21,7 +21,7 @@ FCIMPL0(void*, TailCallHelp::GetTailCallArgBuffer) } FCIMPLEND -extern "C" void* QCALLTYPE TailCallHelp_AllocTailCallArgBufferInternal(int size, QCallException* qcallError) +extern "C" void* QCALLTYPE TailCallHelp_AllocTailCallArgBufferInternal(int size, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/tailcallhelp.h b/src/coreclr/vm/tailcallhelp.h index c064587abf08b5..a5bc1c76a89af4 100644 --- a/src/coreclr/vm/tailcallhelp.h +++ b/src/coreclr/vm/tailcallhelp.h @@ -47,6 +47,6 @@ class TailCallHelp static void* AllocateBlob(LoaderAllocator* alloc, const void* blob, size_t blobLen); }; -extern "C" void* QCALLTYPE TailCallHelp_AllocTailCallArgBufferInternal(int size, QCallException* qcallError); +extern "C" void* QCALLTYPE TailCallHelp_AllocTailCallArgBufferInternal(int size, QCallExceptionStatus* qcallError); #endif diff --git a/src/coreclr/vm/unsafeaccessors.cpp b/src/coreclr/vm/unsafeaccessors.cpp index f79e2e28c6a787..d0e89005dfb1b6 100644 --- a/src/coreclr/vm/unsafeaccessors.cpp +++ b/src/coreclr/vm/unsafeaccessors.cpp @@ -1172,7 +1172,7 @@ bool MethodDesc::TryGenerateUnsafeAccessor(DynamicResolver** resolver, COR_ILMET return true; } -extern "C" void* QCALLTYPE UnsafeAccessors_ResolveGenericParamToTypeHandle(MethodDesc* unsafeAccessorMethod, BOOL isMethodParam, DWORD paramIndex, QCallException* qcallError) +extern "C" void* QCALLTYPE UnsafeAccessors_ResolveGenericParamToTypeHandle(MethodDesc* unsafeAccessorMethod, BOOL isMethodParam, DWORD paramIndex, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(unsafeAccessorMethod != NULL); diff --git a/src/coreclr/vm/varargsnative.cpp b/src/coreclr/vm/varargsnative.cpp index 393add49ffb9d0..1306ef9cc61b7d 100644 --- a/src/coreclr/vm/varargsnative.cpp +++ b/src/coreclr/vm/varargsnative.cpp @@ -167,7 +167,7 @@ static void AdvanceArgPtr(VARARGS *data) // ArgIterator constructor that initializes the state to support iteration // of the args starting at the first optional argument. //////////////////////////////////////////////////////////////////////////////// -extern "C" void QCALLTYPE ArgIterator_Init(VARARGS* data, PVOID cookie, QCallException* qcallError) +extern "C" void QCALLTYPE ArgIterator_Init(VARARGS* data, PVOID cookie, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -197,7 +197,7 @@ extern "C" void QCALLTYPE ArgIterator_Init(VARARGS* data, PVOID cookie, QCallExc // Specifying NULL as the firstArg parameter causes it to start at the first // argument to the call. //////////////////////////////////////////////////////////////////////////////// -extern "C" void QCALLTYPE ArgIterator_Init2(VARARGS* data, PVOID cookie, PVOID firstArg, QCallException* qcallError) +extern "C" void QCALLTYPE ArgIterator_Init2(VARARGS* data, PVOID cookie, PVOID firstArg, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -469,7 +469,7 @@ static void GetNextArgHelper(VARARGS* data, TypedByRef* value, BOOL fData) //////////////////////////////////////////////////////////////////////////////// // Retrieve the type of the next argument without consuming it. //////////////////////////////////////////////////////////////////////////////// -extern "C" void* QCALLTYPE ArgIterator_GetNextArgType(VARARGS* data, QCallException* qcallError) +extern "C" void* QCALLTYPE ArgIterator_GetNextArgType(VARARGS* data, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -498,7 +498,7 @@ extern "C" void* QCALLTYPE ArgIterator_GetNextArgType(VARARGS* data, QCallExcept // Retrieve the next argument and return it in a TypedByRef and advance the // next argument pointer. //////////////////////////////////////////////////////////////////////////////// -extern "C" void QCALLTYPE ArgIterator_GetNextArg(VARARGS* data, TypedByRef* pResult, QCallException* qcallError) +extern "C" void QCALLTYPE ArgIterator_GetNextArg(VARARGS* data, TypedByRef* pResult, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -514,7 +514,7 @@ extern "C" void QCALLTYPE ArgIterator_GetNextArg(VARARGS* data, TypedByRef* pRes // Retrieve the next argument and return it in a TypedByRef and advance the // next argument pointer. //////////////////////////////////////////////////////////////////////////////// -extern "C" void QCALLTYPE ArgIterator_GetNextArg2(VARARGS* data, QCall::TypeHandle pType, TypedByRef* pResult, QCallException* qcallError) +extern "C" void QCALLTYPE ArgIterator_GetNextArg2(VARARGS* data, QCall::TypeHandle pType, TypedByRef* pResult, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/varargsnative.h b/src/coreclr/vm/varargsnative.h index 4209dde33e0bc9..0c80adb1f2ad46 100644 --- a/src/coreclr/vm/varargsnative.h +++ b/src/coreclr/vm/varargsnative.h @@ -14,10 +14,10 @@ #include "clrvarargs.h" -extern "C" void QCALLTYPE ArgIterator_Init(VARARGS* thisPtr, PVOID cookie, QCallException* qcallError); -extern "C" void QCALLTYPE ArgIterator_Init2(VARARGS* thisPtr, PVOID cookie, PVOID firstArg, QCallException* qcallError); -extern "C" void* QCALLTYPE ArgIterator_GetNextArgType(VARARGS* thisPtr, QCallException* qcallError); -extern "C" void QCALLTYPE ArgIterator_GetNextArg(VARARGS* thisPtr, TypedByRef* pResult, QCallException* qcallError); -extern "C" void QCALLTYPE ArgIterator_GetNextArg2(VARARGS* thisPtr, QCall::TypeHandle pType, TypedByRef* pResult, QCallException* qcallError); +extern "C" void QCALLTYPE ArgIterator_Init(VARARGS* thisPtr, PVOID cookie, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ArgIterator_Init2(VARARGS* thisPtr, PVOID cookie, PVOID firstArg, QCallExceptionStatus* qcallError); +extern "C" void* QCALLTYPE ArgIterator_GetNextArgType(VARARGS* thisPtr, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ArgIterator_GetNextArg(VARARGS* thisPtr, TypedByRef* pResult, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ArgIterator_GetNextArg2(VARARGS* thisPtr, QCall::TypeHandle pType, TypedByRef* pResult, QCallExceptionStatus* qcallError); #endif // _VARARGSNATIVE_H_ diff --git a/src/coreclr/vm/versionresilienthashcode.cpp b/src/coreclr/vm/versionresilienthashcode.cpp index 846b83b2fcae48..442c691f706616 100644 --- a/src/coreclr/vm/versionresilienthashcode.cpp +++ b/src/coreclr/vm/versionresilienthashcode.cpp @@ -450,7 +450,7 @@ bool GetVersionResilientILCodeHashCode(MethodDesc *pMD, const COR_ILMETHOD_DECOD return true; } -extern "C" INT32 QCALLTYPE VersionResilientHashCode_TypeHashCode(QCall::TypeHandle pTypeHandle, QCallException* qcallError) +extern "C" INT32 QCALLTYPE VersionResilientHashCode_TypeHashCode(QCall::TypeHandle pTypeHandle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/versionresilienthashcode.h b/src/coreclr/vm/versionresilienthashcode.h index a05c672f3b8881..da36794166ec14 100644 --- a/src/coreclr/vm/versionresilienthashcode.h +++ b/src/coreclr/vm/versionresilienthashcode.h @@ -14,4 +14,4 @@ int GetVersionResilientModuleHashCode(Module* pModule); bool GetVersionResilientILCodeHashCode(MethodDesc *pMD, const COR_ILMETHOD_DECODER* header, int* hashCode, unsigned* ilSize); -extern "C" INT32 QCALLTYPE VersionResilientHashCode_TypeHashCode(QCall::TypeHandle pTypeHandle, QCallException* qcallError); +extern "C" INT32 QCALLTYPE VersionResilientHashCode_TypeHashCode(QCall::TypeHandle pTypeHandle, QCallExceptionStatus* qcallError); diff --git a/src/coreclr/vm/wasm/entrypoints.h b/src/coreclr/vm/wasm/entrypoints.h index ec32d573b1394a..b7a92b9cc60af1 100644 --- a/src/coreclr/vm/wasm/entrypoints.h +++ b/src/coreclr/vm/wasm/entrypoints.h @@ -22,11 +22,11 @@ extern "C" void SystemJS_DiagnosticServerQueueJob(size_t (*cb)(void *data), void // the WasiEventLoop pump when WasiFinalizer_TryClearPending returns true. // Same implementation as browser's SystemJS_ExecuteFinalizationCallback, just // exported under a WASI-specific symbol; see src/coreclr/vm/finalizerthread.cpp. -extern "C" void QCALLTYPE WasiFinalizer_RunWorker(QCallException* qcallError); +extern "C" void QCALLTYPE WasiFinalizer_RunWorker(QCallExceptionStatus* qcallError); // Atomic-flag drain used by managed WasiEventLoop to learn whether a GC has // requested finalization since the last poll. Returns TRUE once per scheduled // finalization, FALSE otherwise. -extern "C" CLR_BOOL QCALLTYPE WasiFinalizer_TryClearPending(QCallException* qcallError); +extern "C" CLR_BOOL QCALLTYPE WasiFinalizer_TryClearPending(QCallExceptionStatus* qcallError); #endif // TARGET_WASI #endif // HAVE_WASM_ENTRYPOINTS_H \ No newline at end of file diff --git a/src/coreclr/vm/weakreferencenative.cpp b/src/coreclr/vm/weakreferencenative.cpp index db690b48c07f4a..69be1f3c8a16b7 100644 --- a/src/coreclr/vm/weakreferencenative.cpp +++ b/src/coreclr/vm/weakreferencenative.cpp @@ -47,7 +47,7 @@ void FinalizeWeakReference(Object* obj) #if defined(FEATURE_COMINTEROP) -extern "C" void QCALLTYPE ComWeakRefToObject(IWeakReference* pComWeakReference, QCall::ObjectHandleOnStack retRcw, QCallException* qcallError) +extern "C" void QCALLTYPE ComWeakRefToObject(IWeakReference* pComWeakReference, QCall::ObjectHandleOnStack retRcw, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -88,7 +88,7 @@ extern "C" void QCALLTYPE ComWeakRefToObject(IWeakReference* pComWeakReference, return; } -extern "C" IWeakReference * QCALLTYPE ObjectToComWeakRef(QCall::ObjectHandleOnStack obj, QCallException* qcallError) +extern "C" IWeakReference * QCALLTYPE ObjectToComWeakRef(QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/weakreferencenative.h b/src/coreclr/vm/weakreferencenative.h index e0646511f98381..d871a7c6780896 100644 --- a/src/coreclr/vm/weakreferencenative.h +++ b/src/coreclr/vm/weakreferencenative.h @@ -15,8 +15,8 @@ #ifdef FEATURE_COMINTEROP -extern "C" void QCALLTYPE ComWeakRefToObject(IWeakReference * pComWeakReference, QCall::ObjectHandleOnStack retRcw, QCallException* qcallError); -extern "C" IWeakReference * QCALLTYPE ObjectToComWeakRef(QCall::ObjectHandleOnStack obj, QCallException* qcallError); +extern "C" void QCALLTYPE ComWeakRefToObject(IWeakReference * pComWeakReference, QCall::ObjectHandleOnStack retRcw, QCallExceptionStatus* qcallError); +extern "C" IWeakReference * QCALLTYPE ObjectToComWeakRef(QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError); #endif // FEATURE_COMINTEROP diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.Internal.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.Internal.cs index 2e408295c81fc9..19ffec5b8b2c4c 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.Internal.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.Internal.cs @@ -24,7 +24,7 @@ private static unsafe partial ulong Enable( uint numProviders #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -33,7 +33,7 @@ uint numProviders internal static partial void Disable(ulong sessionID #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -47,7 +47,7 @@ internal static unsafe partial IntPtr CreateProvider(string providerName, void* callbackContext #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -56,7 +56,7 @@ internal static unsafe partial IntPtr CreateProvider(string providerName, internal static unsafe partial IntPtr DefineEvent(IntPtr provHandle, uint eventID, long keywords, uint eventVersion, uint level, void *pMetadata, uint metadataLength #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -65,7 +65,7 @@ internal static unsafe partial IntPtr DefineEvent(IntPtr provHandle, uint eventI internal static partial IntPtr GetProvider(string providerName #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -74,7 +74,7 @@ internal static partial IntPtr GetProvider(string providerName internal static partial void DeleteProvider(IntPtr provHandle #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -83,7 +83,7 @@ internal static partial void DeleteProvider(IntPtr provHandle internal static partial int EventActivityIdControl(uint controlCode, ref Guid activityId #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -92,7 +92,7 @@ internal static partial int EventActivityIdControl(uint controlCode, ref Guid ac internal static unsafe partial void WriteEventData(IntPtr eventHandle, EventProvider.EventData* pEventData, uint dataCount, Guid* activityId, Guid* relatedActivityId #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -105,7 +105,7 @@ internal static unsafe partial void WriteEventData(IntPtr eventHandle, EventProv internal static unsafe partial bool GetSessionInfo(ulong sessionID, EventPipeSessionInfo* pSessionInfo #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -115,7 +115,7 @@ internal static unsafe partial bool GetSessionInfo(ulong sessionID, EventPipeSes internal static unsafe partial bool GetNextEvent(ulong sessionID, EventPipeEventInstanceData* pInstance #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -125,7 +125,7 @@ internal static unsafe partial bool GetNextEvent(ulong sessionID, EventPipeEvent internal static unsafe partial bool SignalSession(ulong sessionID #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -135,7 +135,7 @@ internal static unsafe partial bool SignalSession(ulong sessionID internal static unsafe partial bool WaitForSessionSignal(ulong sessionID, int timeoutMs #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs index 94b9de9f1a4dac..bd5a4724450510 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs @@ -13,7 +13,7 @@ internal sealed partial class NativeRuntimeEventSource : EventSource private static partial void LogContentionLockCreated(nint LockID, nint AssociatedObjectID, ushort ClrInstanceID #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -28,7 +28,7 @@ private static partial void LogContentionStart( ulong LockOwnerThreadID #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -41,7 +41,7 @@ private static partial void LogContentionStop( double DurationNs #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -51,7 +51,7 @@ double DurationNs private static partial void LogThreadPoolWorkerThreadStart(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -61,7 +61,7 @@ private static partial void LogThreadPoolWorkerThreadStart(uint ActiveWorkerThre private static partial void LogThreadPoolWorkerThreadStop(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -71,7 +71,7 @@ private static partial void LogThreadPoolWorkerThreadStop(uint ActiveWorkerThrea private static partial void LogThreadPoolWorkerThreadWait(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -81,7 +81,7 @@ private static partial void LogThreadPoolWorkerThreadWait(uint ActiveWorkerThrea private static partial void LogThreadPoolMinMaxThreads(ushort MinWorkerThreads, ushort MaxWorkerThreads, ushort MinIOCompletionThreads, ushort MaxIOCompletionThreads, ushort ClrInstanceID #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -91,7 +91,7 @@ private static partial void LogThreadPoolMinMaxThreads(ushort MinWorkerThreads, private static partial void LogThreadPoolWorkerThreadAdjustmentSample(double Throughput, ushort ClrInstanceID #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -101,7 +101,7 @@ private static partial void LogThreadPoolWorkerThreadAdjustmentSample(double Thr private static partial void LogThreadPoolWorkerThreadAdjustmentAdjustment(double AverageThroughput, uint NewWorkerThreadCount, ThreadAdjustmentReasonMap Reason, ushort ClrInstanceID #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -122,7 +122,7 @@ private static partial void LogThreadPoolWorkerThreadAdjustmentStats( ushort ClrInstanceID #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -136,7 +136,7 @@ private static partial void LogThreadPoolIOEnqueue( ushort ClrInstanceID #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -149,7 +149,7 @@ private static partial void LogThreadPoolIODequeue( ushort ClrInstanceID #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -161,7 +161,7 @@ private static partial void LogThreadPoolWorkingThreadCount( ushort ClrInstanceID #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -174,7 +174,7 @@ private static partial void LogThreadPoolIOPack( ushort ClrInstanceID #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -187,7 +187,7 @@ private static partial void LogWaitHandleWaitStart( ushort ClrInstanceID #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -197,7 +197,7 @@ ushort ClrInstanceID private static partial void LogWaitHandleWaitStop(ushort ClrInstanceID #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs index c932bea5aaf380..50b4df7f0117bc 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs @@ -31,7 +31,7 @@ public XplatEventLogger() { } private static unsafe partial char* EventSource_GetClrConfig(string configName #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -64,7 +64,7 @@ out _ private static partial bool IsEventSourceLoggingEnabled( #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - out QCallException qcallException + out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -73,7 +73,7 @@ out QCallException qcallException private static partial void LogEventSource(int eventID, string? eventName, string eventSourceName, string payload #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveC/ObjectiveCMarshal.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveC/ObjectiveCMarshal.cs index 5b955267475753..44cf38cf81a131 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveC/ObjectiveCMarshal.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveC/ObjectiveCMarshal.cs @@ -121,11 +121,7 @@ public static GCHandle CreateReferenceTrackingHandle( { // Defer to GetOrCreateReferenceTrackingMemory for argument/state validation. taggedMemory = GetOrCreateReferenceTrackingMemory(obj); - return GCHandle.FromIntPtr(AllocateReferenceTrackingHandle(obj -#if CORECLR - , out _ -#endif - )); + return GCHandle.FromIntPtr(AllocateReferenceTrackingHandle(obj)); } /// @@ -220,11 +216,7 @@ public static void SetMessageSendCallback(MessageSendFunction msgSendFunction, I if (msgSendFunction < MessageSendFunction.MsgSend || msgSendFunction > MessageSendFunction.MsgSendSuperStret) throw new ArgumentOutOfRangeException(nameof(msgSendFunction)); - if (!TrySetGlobalMessageSendCallback(msgSendFunction, func -#if CORECLR - , out _ -#endif - )) + if (!TrySetGlobalMessageSendCallback(msgSendFunction, func)) throw new InvalidOperationException(SR.InvalidOperation_ResetGlobalObjectiveCMsgSend); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/TypeMapLazyDictionary.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/TypeMapLazyDictionary.cs index 9f64de489bf780..829e30f8cced89 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/TypeMapLazyDictionary.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/TypeMapLazyDictionary.cs @@ -91,7 +91,7 @@ private static unsafe partial void ProcessAttributes( CallbackContext* context #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -100,7 +100,7 @@ private static unsafe partial void ProcessAttributes( private static unsafe partial IntPtr FindPrecachedExternalTypeMapEntry(QCallModule module, QCallTypeHandle groupType, string key #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); @@ -109,7 +109,7 @@ private static unsafe partial IntPtr FindPrecachedExternalTypeMapEntry(QCallModu private static unsafe partial IntPtr FindPrecachedProxyTypeMapEntry(QCallModule module, QCallTypeHandle groupType, QCallTypeHandle type #if CORECLR #pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallException qcallException + , out QCallExceptionStatus qcallException #pragma warning restore SA1001, SA1113, SA1115 #endif ); diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiFinalizerScheduler.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiFinalizerScheduler.cs index af443c656c677a..1be3042915a05e 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiFinalizerScheduler.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiFinalizerScheduler.cs @@ -25,14 +25,14 @@ internal static void DrainIfPending() { } [return: MarshalAs(UnmanagedType.Bool)] internal static partial bool TryClearPendingFinalization( #if CORECLR - out QCallException qcallException + out QCallExceptionStatus qcallException #endif ); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "WasiFinalizer_RunWorker")] internal static partial void ExecuteFinalizationCallback( #if CORECLR - out QCallException qcallException + out QCallExceptionStatus qcallException #endif ); From a0f7ea8b9a32865097974b1b8dc483c168798a8e Mon Sep 17 00:00:00 2001 From: David Wrighton Date: Mon, 24 Aug 2026 17:09:00 -0700 Subject: [PATCH 13/23] Add LibraryImport error handler support Squash the LibraryImportErrorHandler branch changes into one independently revertable commit, including hidden-return-value handling and generator tests. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 97d405de-8e39-4e76-afe4-2f94b74ecfa2 --- .../LibraryImportDiagnosticsAnalyzer.cs | 5 +- .../ErrorHandlingInfoParser.cs | 73 +++++ .../LibraryImportGenerator.cs | 5 +- .../BoundGenerators.cs | 21 ++ .../GeneratedStatements.cs | 6 + .../ManagedToNativeStubGenerator.cs | 27 +- .../ManualTypeMarshallingHelper.cs | 37 +++ .../Marshalling/MarshallerHelpers.cs | 7 + .../SignatureContext.cs | 125 +++++++- .../TypeNames.cs | 1 + .../TypePositionInfo.cs | 22 +- .../VariableDeclarations.cs | 19 +- .../ErrorHandlingTests.cs | 284 ++++++++++++++++++ .../tests/TestAssets/NativeExports/Error.cs | 55 ++++ 14 files changed, 676 insertions(+), 11 deletions(-) create mode 100644 src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/ErrorHandlingInfoParser.cs create mode 100644 src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.Tests/ErrorHandlingTests.cs diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/LibraryImportDiagnosticsAnalyzer.cs b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/LibraryImportDiagnosticsAnalyzer.cs index 5bab2d5e2d65f3..e1c35531c02ce7 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/LibraryImportDiagnosticsAnalyzer.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/LibraryImportDiagnosticsAnalyzer.cs @@ -286,13 +286,16 @@ private static ImmutableArray CalculateDiagnostics( } } + ErrorHandlingInfo? errorHandlingInfo = ErrorHandlingInfoParser.Parse(symbol, environment, generatorDiagnostics); + // Create the signature context to collect marshalling-related diagnostics var signatureContext = SignatureContext.Create( symbol, DefaultMarshallingInfoParser.Create(environment, generatorDiagnostics, symbol, libraryImportData, libraryImportAttr), environment, new CodeEmitOptions(SkipInit: true), - typeof(LibraryImportGenerator).Assembly); + typeof(LibraryImportGenerator).Assembly, + errorHandlingInfo); // If forwarders are not being generated, we need to run stub generation logic to get those diagnostics too if (!options.GenerateForwarders) diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/ErrorHandlingInfoParser.cs b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/ErrorHandlingInfoParser.cs new file mode 100644 index 00000000000000..fd218fd3d69bd0 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/ErrorHandlingInfoParser.cs @@ -0,0 +1,73 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Microsoft.CodeAnalysis; + +namespace Microsoft.Interop +{ + internal static class ErrorHandlingInfoParser + { + public static ErrorHandlingInfo? Parse( + IMethodSymbol method, + StubEnvironment environment, + GeneratorDiagnosticsBag diagnostics) + { + AttributeData? attribute = null; + foreach (AttributeData candidate in method.GetAttributes()) + { + if (candidate.AttributeClass?.ToDisplayString() == TypeNames.ErrorHandlerAttribute) + { + attribute = candidate; + break; + } + } + + if (attribute is null) + { + return null; + } + + if (attribute.AttributeConstructor is null + || attribute.ConstructorArguments.Length != 2 + || attribute.ConstructorArguments[0].Value is not INamedTypeSymbol marshallerType + || attribute.ConstructorArguments[1].Value is not int locationValue + || locationValue is < (int)ErrorHandlingLocation.ReturnValue or > (int)ErrorHandlingLocation.HiddenReturnValue) + { + return null; + } + + if (!ManualTypeMarshallingHelper.TryGetManagedTypeFromEntryType(marshallerType, environment.Compilation, out ITypeSymbol? managedType)) + { + diagnostics.ReportConfigurationNotSupported(attribute, nameof(TypeNames.ErrorHandlerAttribute)); + return null; + } + + ErrorHandlingLocation location = (ErrorHandlingLocation)locationValue; + if (location == ErrorHandlingLocation.ReturnValue + && method.ReturnType.SpecialType != SpecialType.System_Void + && !SymbolEqualityComparer.Default.Equals(method.ReturnType, managedType)) + { + diagnostics.ReportConfigurationNotSupported(attribute, nameof(ErrorHandlingLocation.ReturnValue)); + return null; + } + + MarshallingInfo marshallingInfo = CustomMarshallingInfoHelper.CreateNativeMarshallingInfoForNonSignatureElement( + managedType, + marshallerType, + attribute, + environment.Compilation, + diagnostics); + + if (marshallingInfo == NoMarshallingInfo.Instance) + { + diagnostics.ReportConfigurationNotSupported(attribute, nameof(TypeNames.ErrorHandlerAttribute)); + return null; + } + + return new ErrorHandlingInfo( + ManagedTypeInfo.CreateTypeInfoForTypeSymbol(managedType), + marshallingInfo, + location); + } + } +} diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.cs b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.cs index e0a8747d9081ba..c3418def8e6b48 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.cs @@ -267,6 +267,7 @@ private static IncrementalStubGenerationContext CalculateStubInformation( // Create a diagnostics bag that discards all diagnostics. // Diagnostics are now reported by the analyzer, not the generator. var discardedDiagnostics = new GeneratorDiagnosticsBag(new DiagnosticDescriptorProvider(), locations, SR.ResourceManager, typeof(FxResources.Microsoft.Interop.LibraryImportGenerator.SR)); + ErrorHandlingInfo? errorHandlingInfo = ErrorHandlingInfoParser.Parse(symbol, environment, discardedDiagnostics); // Create the stub. var signatureContext = SignatureContext.Create( @@ -274,7 +275,8 @@ private static IncrementalStubGenerationContext CalculateStubInformation( DefaultMarshallingInfoParser.Create(environment, discardedDiagnostics, symbol, libraryImportData, generatedDllImportAttr), environment, new CodeEmitOptions(SkipInit: true), - typeof(LibraryImportGenerator).Assembly); + typeof(LibraryImportGenerator).Assembly, + errorHandlingInfo); var containingTypeContext = new ContainingSyntaxContext(originalSyntax); @@ -290,6 +292,7 @@ private static IncrementalStubGenerationContext CalculateStubInformation( LibraryImportData.From(libraryImportData), options, environment.EnvironmentFlags); + } private static MemberDeclarationSyntax GenerateSource( diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/BoundGenerators.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/BoundGenerators.cs index c517a0c0353999..c8294e8f9e87a3 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/BoundGenerators.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/BoundGenerators.cs @@ -30,6 +30,7 @@ public static BoundGenerators Create(ImmutableArray elementTyp IBoundMarshallingGenerator managedReturnMarshaller = defaultBoundGenerator; IBoundMarshallingGenerator nativeReturnMarshaller = defaultBoundGenerator; IBoundMarshallingGenerator managedExceptionMarshaller = defaultBoundGenerator; + IBoundMarshallingGenerator errorHandlerMarshaller = defaultBoundGenerator; TypePositionInfo? managedExceptionInfo = null; foreach (TypePositionInfo argType in elementTypeInfo) @@ -46,6 +47,11 @@ public static BoundGenerators Create(ImmutableArray elementTyp IBoundMarshallingGenerator generator = CreateGenerator(argType, generatorResolver); signatureMarshallers.Add(generator); + if (argType.IsErrorHandlingPosition) + { + Debug.Assert(errorHandlerMarshaller == defaultBoundGenerator); + errorHandlerMarshaller = generator; + } if (argType.IsManagedReturnPosition) { Debug.Assert(managedReturnMarshaller == defaultBoundGenerator); @@ -156,6 +162,7 @@ public static BoundGenerators Create(ImmutableArray elementTyp ManagedReturnMarshaller = managedReturnMarshaller, NativeReturnMarshaller = nativeReturnMarshaller, ManagedExceptionMarshaller = managedExceptionMarshaller, + ErrorHandlerMarshaller = errorHandlerMarshaller, }; static IEnumerable<(bool IsManagedIndex, int Index)> GetInfoDependencies(TypePositionInfo info) @@ -185,6 +192,16 @@ public static BoundGenerators Create(ImmutableArray elementTyp IBoundMarshallingGenerator CreateGenerator(TypePositionInfo p, IMarshallingGeneratorResolver factory) { ResolvedGenerator generator = factory.Create(p, context); + if (generator.IsResolvedWithoutErrors + && p is { IsErrorHandlingPosition: true, ErrorHandlingLocation: ErrorHandlingLocation.SystemError } + && generator.Generator.NativeType != SpecialTypeInfo.Int32) + { + generator = ResolvedGenerator.NotSupported(p, context, new(p) + { + NotSupportedDetails = SR.MarshallerInOverlappingNativePositionMustMatchNativeType + }); + } + generatorDiagnostics.AddRange(generator.Diagnostics); return generator.IsResolvedWithoutErrors ? generator.Generator : fallbackGenerator.Bind(p, context); } @@ -196,6 +213,8 @@ IBoundMarshallingGenerator CreateGenerator(TypePositionInfo p, IMarshallingGener public IBoundMarshallingGenerator ManagedExceptionMarshaller { get; private init; } + public IBoundMarshallingGenerator ErrorHandlerMarshaller { get; private init; } + public ImmutableArray SignatureMarshallers { get; private init; } public ImmutableArray ManagedParameterMarshallers { get; private init; } @@ -221,6 +240,8 @@ IBoundMarshallingGenerator CreateGenerator(TypePositionInfo p, IMarshallingGener public bool HasManagedExceptionMarshaller => !ManagedExceptionMarshaller.IsForwarder(); + public bool HasErrorHandler => !ErrorHandlerMarshaller.IsForwarder(); + /// /// Validate that the resolved generator resolves to the same native type. /// diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/GeneratedStatements.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/GeneratedStatements.cs index acdf733b4d11f5..3899e8caec95d7 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/GeneratedStatements.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/GeneratedStatements.cs @@ -95,6 +95,12 @@ private static ImmutableArray GenerateStatementsForStubContext( ImmutableArray.Builder statementsToUpdate = ImmutableArray.CreateBuilder(); foreach (IBoundMarshallingGenerator marshaller in marshallers.SignatureMarshallers) { + if (marshaller.TypeInfo.IsErrorHandlingPosition + && context.CurrentStage is StubIdentifierContext.Stage.UnmarshalCapture or StubIdentifierContext.Stage.Unmarshal) + { + continue; + } + statementsToUpdate.AddRange(marshaller.Generate(context)); } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/ManagedToNativeStubGenerator.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/ManagedToNativeStubGenerator.cs index 392b83946a5b1a..e05309506a601b 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/ManagedToNativeStubGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/ManagedToNativeStubGenerator.cs @@ -89,6 +89,7 @@ public ManagedToNativeStubGenerator( } NoMarshallingRequired = !setLastError + && !_marshallers.HasErrorHandler && _marshallers.ManagedNativeSameReturn && noMarshallingNeeded; } @@ -109,12 +110,14 @@ public string GetNativeIdentifier(TypePositionInfo info) public BlockSyntax GenerateStubBody(string targetIdentifier) { GeneratedStatements statements = GeneratedStatements.Create(_marshallers, StubCodeContext.DefaultManagedToNativeStub, _context, IdentifierName(targetIdentifier)); + IBoundMarshallingGenerator? errorMarshaller = _marshallers.HasErrorHandler ? _marshallers.ErrorHandlerMarshaller : null; + bool capturesSystemError = errorMarshaller?.TypeInfo.ErrorHandlingLocation == ErrorHandlingLocation.SystemError; bool shouldInitializeVariables = !statements.GuaranteedUnmarshal.IsEmpty || !statements.CleanupCallerAllocated.IsEmpty || !statements.CleanupCalleeAllocated.IsEmpty; VariableDeclarations declarations = VariableDeclarations.GenerateDeclarationsForManagedToUnmanaged(_marshallers, _context, shouldInitializeVariables); List setupStatements = []; - if (_setLastError) + if (_setLastError || capturesSystemError) { // Declare variable for last error setupStatements.Add(Declare( @@ -135,7 +138,7 @@ public BlockSyntax GenerateStubBody(string targetIdentifier) List tryStatements = [.. statements.Marshal]; BlockSyntax fixedBlock = Block(statements.PinnedMarshal); - if (_setLastError) + if (_setLastError || capturesSystemError) { StatementSyntax clearLastError = MarshallerHelpers.CreateClearLastSystemErrorStatement(SuccessErrorCode); @@ -151,6 +154,26 @@ public BlockSyntax GenerateStubBody(string targetIdentifier) tryStatements.AddRange(statements.NotifyForSuccessfulInvoke); + if (capturesSystemError) + { + tryStatements.Add(ExpressionStatement( + AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + IdentifierName(_context.GetIdentifiers(errorMarshaller!.TypeInfo).native), + IdentifierName(LastErrorIdentifier)))); + } + + if (_setLastError && errorMarshaller is not null) + { + tryStatements.Add(MarshallerHelpers.CreateSetLastPInvokeErrorStatement(LastErrorIdentifier)); + } + + if (errorMarshaller is not null) + { + tryStatements.AddRange(errorMarshaller.Generate(_context with { CurrentStage = StubIdentifierContext.Stage.UnmarshalCapture })); + tryStatements.AddRange(errorMarshaller.Generate(_context with { CurrentStage = StubIdentifierContext.Stage.Unmarshal })); + } + // = true; if (!(statements.GuaranteedUnmarshal.IsEmpty && statements.CleanupCalleeAllocated.IsEmpty)) { diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/ManualTypeMarshallingHelper.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/ManualTypeMarshallingHelper.cs index ce3c82b40fd734..8188e45bf3975f 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/ManualTypeMarshallingHelper.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/ManualTypeMarshallingHelper.cs @@ -102,6 +102,43 @@ public static bool TryGetValueMarshallersFromEntryType( return TryGetMarshallersFromEntryType(entryPointType, managedType, isLinearCollectionMarshalling: false, compilation, getMarshallingInfoForElement: null, IgnoreArityMismatch, out marshallers); } + public static bool TryGetManagedTypeFromEntryType( + INamedTypeSymbol entryPointType, + Compilation compilation, + [NotNullWhen(true)] out ITypeSymbol? managedType) + { + managedType = null; + + foreach (AttributeData attr in entryPointType.GetAttributes()) + { + if (attr.AttributeClass?.ToDisplayString() != TypeNames.CustomMarshallerAttribute + || attr.AttributeConstructor is null + || attr.ConstructorArguments.Length != 3 + || attr.ConstructorArguments[0].Value is not ITypeSymbol managedTypeOnAttribute) + { + continue; + } + + ITypeSymbol resolvedManagedType = ReplaceGenericPlaceholderInType(managedTypeOnAttribute, entryPointType, compilation); + if (!TryResolveManagedType(entryPointType, resolvedManagedType, isLinearCollectionMarshalling: false, IgnoreArityMismatch, out resolvedManagedType)) + { + continue; + } + + if (managedType is null) + { + managedType = resolvedManagedType; + } + else if (!SymbolEqualityComparer.Default.Equals(managedType, resolvedManagedType)) + { + managedType = null; + return false; + } + } + + return managedType is not null; + } + public static bool TryGetValueMarshallersFromEntryType( INamedTypeSymbol entryPointType, ITypeSymbol managedType, diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshallerHelpers.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshallerHelpers.cs index b6bf201d03b235..d856fa2228c717 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshallerHelpers.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshallerHelpers.cs @@ -277,6 +277,13 @@ public static MarshalDirection GetMarshalDirection(TypePositionInfo info, StubCo if (context.Direction == MarshalDirection.ManagedToUnmanaged) { + if (info.IsErrorHandlingPosition) + { + return info.RefKind == RefKind.Ref + ? MarshalDirection.Bidirectional + : MarshalDirection.UnmanagedToManaged; + } + if (info.IsManagedReturnPosition) { return MarshalDirection.UnmanagedToManaged; diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/SignatureContext.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/SignatureContext.cs index 96932bf8569eb4..51a7e7eea1c17d 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/SignatureContext.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/SignatureContext.cs @@ -39,8 +39,7 @@ public IEnumerable StubParameters { foreach (TypePositionInfo typeInfo in ElementTypeInformation) { - if (typeInfo.ManagedIndex != TypePositionInfo.UnsetIndex - && typeInfo.ManagedIndex != TypePositionInfo.ReturnIndex) + if (!TypePositionInfo.IsSpecialIndex(typeInfo.ManagedIndex)) { yield return Parameter(Identifier(typeInfo.InstanceIdentifier)) .WithType(typeInfo.ManagedType.Syntax) @@ -59,7 +58,18 @@ public static SignatureContext Create( CodeEmitOptions options, Assembly generatorInfoAssembly) { - ImmutableArray typeInfos = GenerateTypeInformation(method, marshallingInfoParser, env); + return Create(method, marshallingInfoParser, env, options, generatorInfoAssembly, errorHandlingInfo: null); + } + + public static SignatureContext Create( + IMethodSymbol method, + MarshallingInfoParser marshallingInfoParser, + StubEnvironment env, + CodeEmitOptions options, + Assembly generatorInfoAssembly, + ErrorHandlingInfo? errorHandlingInfo) + { + ImmutableArray typeInfos = GenerateTypeInformation(method, marshallingInfoParser, env, errorHandlingInfo); ImmutableArray.Builder additionalAttrs = ImmutableArray.CreateBuilder(); @@ -101,7 +111,8 @@ public static SignatureContext Create( private static ImmutableArray GenerateTypeInformation( IMethodSymbol method, MarshallingInfoParser marshallingInfoParser, - StubEnvironment env) + StubEnvironment env, + ErrorHandlingInfo? errorHandlingInfo) { // When the underlying method is a property accessor, bare attributes on the property declaration // (e.g. `[MarshalUsing(typeof(X))] string Prop { get; set; }`) land on the property symbol and @@ -151,7 +162,113 @@ private static ImmutableArray GenerateTypeInformation( typeInfos.Add(retTypeInfo); + if (errorHandlingInfo is not null) + { + ApplyErrorHandlingInfo(typeInfos, errorHandlingInfo); + } + return typeInfos.ToImmutable(); + + void ApplyErrorHandlingInfo(ImmutableArray.Builder infos, ErrorHandlingInfo errorInfo) + { + TypePositionInfo CreateInjectedErrorInfo(int nativeIndex) + { + return new TypePositionInfo(errorInfo.ManagedType, errorInfo.MarshallingInfo) + { + InstanceIdentifier = "__error", + RefKind = nativeIndex == TypePositionInfo.ReturnIndex ? RefKind.None : RefKind.Out, + ManagedIndex = TypePositionInfo.ErrorIndex, + NativeIndex = nativeIndex, + IsErrorHandlingPosition = true, + ErrorHandlingLocation = errorInfo.Location, + }; + } + + bool MatchesManagedType(TypePositionInfo info) => info.ManagedType == errorInfo.ManagedType; + + switch (errorInfo.Location) + { + case ErrorHandlingLocation.ReturnValue: + int returnIndex = infos.Count - 1; + TypePositionInfo returnInfo = infos[returnIndex]; + if (MatchesManagedType(returnInfo)) + { + infos[returnIndex] = returnInfo with + { + MarshallingAttributeInfo = errorInfo.MarshallingInfo, + IsErrorHandlingPosition = true, + ErrorHandlingLocation = errorInfo.Location, + }; + } + else if (returnInfo.ManagedType == SpecialTypeInfo.Void) + { + infos[returnIndex] = returnInfo with { NativeIndex = TypePositionInfo.UnsetIndex }; + infos.Add(CreateInjectedErrorInfo(TypePositionInfo.ReturnIndex)); + } + break; + + case ErrorHandlingLocation.HiddenReturnValue: + int hiddenReturnIndex = infos.Count - 1; + TypePositionInfo hiddenReturnInfo = infos[hiddenReturnIndex]; + if (hiddenReturnInfo.ManagedType == SpecialTypeInfo.Void) + { + infos[hiddenReturnIndex] = hiddenReturnInfo with { NativeIndex = TypePositionInfo.UnsetIndex }; + } + else + { + // Match the COM ABI transformation: keep the value in the managed return + // position while moving it to a final out parameter in the native signature. + infos[hiddenReturnIndex] = hiddenReturnInfo with + { + RefKind = RefKind.Out, + NativeIndex = method.Parameters.Length, + }; + } + + infos.Add(CreateInjectedErrorInfo(TypePositionInfo.ReturnIndex)); + break; + + case ErrorHandlingLocation.LastParameter: + int lastParameterIndex = infos.Count - 2; + if (infos.Count > 1 + && infos[lastParameterIndex] is { RefKind: RefKind.Out or RefKind.Ref } lastParameter + && MatchesManagedType(lastParameter)) + { + infos[lastParameterIndex] = lastParameter with + { + MarshallingAttributeInfo = errorInfo.MarshallingInfo, + IsErrorHandlingPosition = true, + ErrorHandlingLocation = errorInfo.Location, + }; + } + else + { + infos.Add(CreateInjectedErrorInfo(method.Parameters.Length)); + } + break; + + case ErrorHandlingLocation.SystemError: + int systemErrorParameterIndex = infos.Count - 2; + if (errorInfo.ManagedType != SpecialTypeInfo.Int32 + && infos.Count > 1 + && infos[systemErrorParameterIndex] is { RefKind: RefKind.Out } systemErrorParameter + && MatchesManagedType(systemErrorParameter)) + { + infos[systemErrorParameterIndex] = systemErrorParameter with + { + NativeIndex = TypePositionInfo.UnsetIndex, + MarshallingAttributeInfo = errorInfo.MarshallingInfo, + IsErrorHandlingPosition = true, + ErrorHandlingLocation = errorInfo.Location, + }; + } + else + { + infos.Add(CreateInjectedErrorInfo(TypePositionInfo.UnsetIndex)); + } + break; + } + } } private static ImmutableArray MergeAccessorAndPropertyAttributes( diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/TypeNames.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/TypeNames.cs index d8393b0d100a1b..9fb3278db822c2 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/TypeNames.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/TypeNames.cs @@ -113,6 +113,7 @@ public static class TypeNames public const string GlobalAlias = "global::"; public const string DllImportAttribute = "System.Runtime.InteropServices.DllImportAttribute"; + public const string ErrorHandlerAttribute = "System.Runtime.InteropServices.ErrorHandlerAttribute"; public const string LibraryImportAttribute = "System.Runtime.InteropServices.LibraryImportAttribute"; public const string LibraryImportAttribute_ShortName = "LibraryImportAttribute"; public const string StringMarshalling = "System.Runtime.InteropServices.StringMarshalling"; diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/TypePositionInfo.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/TypePositionInfo.cs index 3e374ad827aefc..f01348b9a52d07 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/TypePositionInfo.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/TypePositionInfo.cs @@ -49,10 +49,11 @@ public sealed record TypePositionInfo(ManagedTypeInfo ManagedType, MarshallingIn public const int UnsetIndex = int.MinValue; public const int ReturnIndex = UnsetIndex + 1; public const int ExceptionIndex = UnsetIndex + 2; + public const int ErrorIndex = UnsetIndex + 3; public static bool IsSpecialIndex(int index) { - return index is UnsetIndex or ReturnIndex or ExceptionIndex; + return index is UnsetIndex or ReturnIndex or ExceptionIndex or ErrorIndex; } public static int IncrementIndex(int index) @@ -73,6 +74,8 @@ public static int IncrementIndex(int index) public bool IsManagedReturnPosition { get => ManagedIndex == ReturnIndex; } public bool IsNativeReturnPosition { get => NativeIndex == ReturnIndex; } public bool IsManagedExceptionPosition { get => ManagedIndex == ExceptionIndex; } + public bool IsErrorHandlingPosition { get; init; } + public ErrorHandlingLocation ErrorHandlingLocation { get; init; } public int ManagedIndex { get; init; } = UnsetIndex; public int NativeIndex { get; init; } = UnsetIndex; @@ -102,7 +105,7 @@ public static Location GetLocation(TypePositionInfo info, IMethodSymbol methodSy if (info.ManagedIndex is UnsetIndex) return Location.None; - if (info.ManagedIndex is ReturnIndex or ExceptionIndex) + if (info.ManagedIndex is ReturnIndex or ExceptionIndex or ErrorIndex) return methodSymbol.Locations[0]; return methodSymbol.Parameters[info.ManagedIndex].Locations[0]; @@ -125,9 +128,24 @@ private static ByValueContentsMarshalKind GetByValueContentsMarshalKind(IEnumera { marshalKind |= ByValueContentsMarshalKind.In; } + } return marshalKind; } } + + public enum ErrorHandlingLocation + { + None = -1, + ReturnValue = 0, + LastParameter = 1, + SystemError = 2, + HiddenReturnValue = 3, + } + + public sealed record ErrorHandlingInfo( + ManagedTypeInfo ManagedType, + MarshallingInfo MarshallingInfo, + ErrorHandlingLocation Location); } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/VariableDeclarations.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/VariableDeclarations.cs index db65df307c5eb2..afaa06090c49c1 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/VariableDeclarations.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/VariableDeclarations.cs @@ -24,7 +24,7 @@ public static VariableDeclarations GenerateDeclarationsForManagedToUnmanaged(Bou if (info.IsManagedReturnPosition) continue; - if (info.RefKind == RefKind.Out) + if (info.RefKind == RefKind.Out && info.ManagedIndex != TypePositionInfo.ErrorIndex) { initializations.Add(MarshallerHelpers.DefaultInit(info, context)); } @@ -46,6 +46,23 @@ public static VariableDeclarations GenerateDeclarationsForManagedToUnmanaged(Bou AppendVariableDeclarations(variables, marshallers.NativeReturnMarshaller, context, initializeToDefault: initializeDeclarations); } + if (marshallers.HasErrorHandler) + { + IBoundMarshallingGenerator errorMarshaller = marshallers.ErrorHandlerMarshaller; + TypePositionInfo errorInfo = errorMarshaller.TypeInfo; + (string managed, string native) = context.GetIdentifiers(errorInfo); + + if (errorInfo.ManagedIndex == TypePositionInfo.ErrorIndex && !errorInfo.IsNativeReturnPosition) + { + variables.Add(Declare(errorInfo.ManagedType.Syntax, managed, initializeDeclarations)); + } + + if (errorInfo.NativeIndex == TypePositionInfo.UnsetIndex && errorMarshaller.UsesNativeIdentifier) + { + variables.Add(Declare(errorMarshaller.NativeType.Syntax, native, initializeDeclarations)); + } + } + return new VariableDeclarations { Initializations = initializations.ToImmutable(), diff --git a/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.Tests/ErrorHandlingTests.cs b/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.Tests/ErrorHandlingTests.cs new file mode 100644 index 00000000000000..6fa3af38e543c2 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.Tests/ErrorHandlingTests.cs @@ -0,0 +1,284 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Runtime.InteropServices; +using System.Runtime.InteropServices.Marshalling; +using Xunit; + +namespace System.Runtime.InteropServices +{ + internal enum ErrorLocation + { + ReturnValue = 0, + LastParameter = 1, + SystemError = 2, + HiddenReturnValue = 3, + } + + [AttributeUsage(AttributeTargets.Method)] + internal sealed class ErrorHandlerAttribute : Attribute + { + public ErrorHandlerAttribute(Type marshallerType, ErrorLocation errorLocation) + { + } + } +} + +namespace LibraryImportGenerator.IntegrationTests +{ + internal readonly record struct CustomError(int Value); + internal readonly record struct CleanupInput(int Value); + internal readonly record struct SystemError(int Value); + internal readonly record struct TrackedOutput(int Value); + + internal sealed class CustomErrorException(int error) : Exception + { + public int Error { get; } = error; + } + + [CustomMarshaller(typeof(CustomError), MarshalMode.Default, typeof(CustomErrorMarshaller))] + internal static class CustomErrorMarshaller + { + public static int ConvertToUnmanaged(CustomError error) => error.Value; + + public static CustomError ConvertToManaged(int error) + { + if (error < 0) + { + throw new CustomErrorException(error); + } + + return new CustomError(error); + } + } + + [CustomMarshaller(typeof(SystemError), MarshalMode.Default, typeof(SystemErrorMarshaller))] + internal static class SystemErrorMarshaller + { + public static int ConvertToUnmanaged(SystemError error) => error.Value; + + public static SystemError ConvertToManaged(int error) + { + if (error < 0) + { + throw new CustomErrorException(error); + } + + return new SystemError(error); + } + } + + [CustomMarshaller(typeof(CleanupInput), MarshalMode.ManagedToUnmanagedIn, typeof(CleanupInputMarshaller))] + internal static class CleanupInputMarshaller + { + public static bool FreeCalled { get; set; } + + public static nint ConvertToUnmanaged(CleanupInput input) + { + nint value = Marshal.AllocCoTaskMem(sizeof(int)); + Marshal.WriteInt32(value, input.Value); + return value; + } + + public static void Free(nint value) + { + FreeCalled = true; + Marshal.FreeCoTaskMem(value); + } + } + + [CustomMarshaller(typeof(TrackedOutput), MarshalMode.Default, typeof(TrackedOutputMarshaller))] + internal static class TrackedOutputMarshaller + { + public static bool ConvertToManagedCalled { get; set; } + + public static int ConvertToUnmanaged(TrackedOutput value) => value.Value; + + public static TrackedOutput ConvertToManaged(int value) + { + ConvertToManagedCalled = true; + return new TrackedOutput(value); + } + } + + partial class NativeExportsNE + { + internal static partial class ErrorHandling + { + [LibraryImport(NativeExportsNE_Binary, EntryPoint = "return_error")] + [ErrorHandler(typeof(CustomErrorMarshaller), ErrorLocation.ReturnValue)] + public static partial CustomError ReturnError(int error); + + [LibraryImport(NativeExportsNE_Binary, EntryPoint = "return_error")] + [ErrorHandler(typeof(CustomErrorMarshaller), ErrorLocation.ReturnValue)] + public static partial void HandleReturnError(int error); + + [LibraryImport(NativeExportsNE_Binary, EntryPoint = "set_error_out")] + [ErrorHandler(typeof(CustomErrorMarshaller), ErrorLocation.LastParameter)] + public static partial void ErrorInOutParameter(int error, out CustomError errorValue); + + [LibraryImport(NativeExportsNE_Binary, EntryPoint = "set_error_ref")] + [ErrorHandler(typeof(CustomErrorMarshaller), ErrorLocation.LastParameter)] + public static partial void ErrorInRefParameter(int error, ref CustomError errorValue); + + [LibraryImport(NativeExportsNE_Binary, EntryPoint = "set_constant_error_out")] + [ErrorHandler(typeof(CustomErrorMarshaller), ErrorLocation.LastParameter)] + public static partial void InjectedErrorParameter(); + + [LibraryImport(NativeExportsNE_Binary, EntryPoint = "set_error")] + [ErrorHandler(typeof(SystemErrorMarshaller), ErrorLocation.SystemError)] + public static partial void HandleSystemError(int error, byte shouldSetError); + + [LibraryImport(NativeExportsNE_Binary, EntryPoint = "set_error")] + [ErrorHandler(typeof(SystemErrorMarshaller), ErrorLocation.SystemError)] + public static partial void ReturnSystemError(int error, byte shouldSetError, out SystemError errorValue); + + [LibraryImport(NativeExportsNE_Binary, EntryPoint = "return_error_with_output")] + [ErrorHandler(typeof(CustomErrorMarshaller), ErrorLocation.ReturnValue)] + public static partial void ReturnErrorBeforeOutput( + int error, + [MarshalUsing(typeof(TrackedOutputMarshaller))] out TrackedOutput output); + + [LibraryImport(NativeExportsNE_Binary, EntryPoint = "return_error_with_input")] + [ErrorHandler(typeof(CustomErrorMarshaller), ErrorLocation.ReturnValue)] + public static partial void ReturnErrorWithAllocatedInput( + int error, + [MarshalUsing(typeof(CleanupInputMarshaller))] CleanupInput input); + + [LibraryImport(NativeExportsNE_Binary, EntryPoint = "set_output_and_error_out")] + [ErrorHandler(typeof(CustomErrorMarshaller), ErrorLocation.LastParameter)] + public static partial void LastParameterErrorBeforeOutput( + int error, + [MarshalUsing(typeof(TrackedOutputMarshaller))] out TrackedOutput output); + + [LibraryImport(NativeExportsNE_Binary, EntryPoint = "set_error_with_output")] + [ErrorHandler(typeof(SystemErrorMarshaller), ErrorLocation.SystemError)] + public static partial void SystemErrorBeforeOutput( + int error, + [MarshalUsing(typeof(TrackedOutputMarshaller))] out TrackedOutput output); + + [LibraryImport(NativeExportsNE_Binary, EntryPoint = "return_error")] + [ErrorHandler(typeof(CustomErrorMarshaller), ErrorLocation.HiddenReturnValue)] + public static partial void HandleHiddenReturnError(int error); + + [LibraryImport(NativeExportsNE_Binary, EntryPoint = "return_error_with_hidden_return")] + [ErrorHandler(typeof(CustomErrorMarshaller), ErrorLocation.HiddenReturnValue)] + [return: MarshalUsing(typeof(TrackedOutputMarshaller))] + public static partial TrackedOutput HiddenReturnValue(int error); + } + } + + public class ErrorHandlingTests + { + [Fact] + public void ReturnValueCanBeObserved() + { + Assert.Equal(new CustomError(42), NativeExportsNE.ErrorHandling.ReturnError(42)); + } + + [Fact] + public void ReturnValueCanBeHandledWithoutManagedReturn() + { + NativeExportsNE.ErrorHandling.HandleReturnError(0); + CustomErrorException exception = Assert.Throws( + () => NativeExportsNE.ErrorHandling.HandleReturnError(-1)); + Assert.Equal(-1, exception.Error); + } + + [Fact] + public void LastOutParameterCanBeObserved() + { + NativeExportsNE.ErrorHandling.ErrorInOutParameter(42, out CustomError error); + Assert.Equal(new CustomError(42), error); + } + + [Fact] + public void LastRefParameterCanBeObserved() + { + CustomError error = new(1); + NativeExportsNE.ErrorHandling.ErrorInRefParameter(42, ref error); + Assert.Equal(new CustomError(43), error); + } + + [Fact] + public void LastParameterIsInjectedWhenMissing() + { + NativeExportsNE.ErrorHandling.InjectedErrorParameter(); + } + + [Fact] + public void SystemErrorCanBeHandledWithoutManagedOutput() + { + NativeExportsNE.ErrorHandling.HandleSystemError(0, shouldSetError: 1); + CustomErrorException exception = Assert.Throws( + () => NativeExportsNE.ErrorHandling.HandleSystemError(-2, shouldSetError: 1)); + Assert.Equal(-2, exception.Error); + } + + [Fact] + public void SystemErrorCanBeObservedThroughLastOutParameter() + { + NativeExportsNE.ErrorHandling.ReturnSystemError(42, shouldSetError: 1, out SystemError error); + Assert.Equal(new SystemError(42), error); + } + + [Theory] + [InlineData(0)] + [InlineData(1)] + [InlineData(2)] + public void ErrorHandlingPrecedesOtherOutMarshalling(int location) + { + TrackedOutputMarshaller.ConvertToManagedCalled = false; + + CustomErrorException exception = location switch + { + 0 => Assert.Throws( + () => NativeExportsNE.ErrorHandling.ReturnErrorBeforeOutput(-3, out _)), + 1 => Assert.Throws( + () => NativeExportsNE.ErrorHandling.LastParameterErrorBeforeOutput(-3, out _)), + 2 => Assert.Throws( + () => NativeExportsNE.ErrorHandling.SystemErrorBeforeOutput(-3, out _)), + _ => throw new ArgumentOutOfRangeException(nameof(location)), + }; + + Assert.Equal(-3, exception.Error); + Assert.False(TrackedOutputMarshaller.ConvertToManagedCalled); + } + + [Fact] + public void ErrorHandlingExceptionCleansUpCallerAllocatedMemory() + { + CleanupInputMarshaller.FreeCalled = false; + + CustomErrorException exception = Assert.Throws( + () => NativeExportsNE.ErrorHandling.ReturnErrorWithAllocatedInput(-4, new CleanupInput(42))); + + Assert.Equal(-4, exception.Error); + Assert.True(CleanupInputMarshaller.FreeCalled); + } + + [Fact] + public void HiddenReturnValueWithVoidManagedReturnHandlesNativeReturnError() + { + NativeExportsNE.ErrorHandling.HandleHiddenReturnError(0); + CustomErrorException exception = Assert.Throws( + () => NativeExportsNE.ErrorHandling.HandleHiddenReturnError(-5)); + Assert.Equal(-5, exception.Error); + } + + [Fact] + public void HiddenReturnValueMovesManagedReturnToNativeOutParameter() + { + TrackedOutputMarshaller.ConvertToManagedCalled = false; + Assert.Equal(new TrackedOutput(42), NativeExportsNE.ErrorHandling.HiddenReturnValue(0)); + Assert.True(TrackedOutputMarshaller.ConvertToManagedCalled); + + TrackedOutputMarshaller.ConvertToManagedCalled = false; + CustomErrorException exception = Assert.Throws( + () => NativeExportsNE.ErrorHandling.HiddenReturnValue(-5)); + Assert.Equal(-5, exception.Error); + Assert.False(TrackedOutputMarshaller.ConvertToManagedCalled); + } + } +} diff --git a/src/libraries/System.Runtime.InteropServices/tests/TestAssets/NativeExports/Error.cs b/src/libraries/System.Runtime.InteropServices/tests/TestAssets/NativeExports/Error.cs index cbbac4e31d2b36..eec70e7f75a306 100644 --- a/src/libraries/System.Runtime.InteropServices/tests/TestAssets/NativeExports/Error.cs +++ b/src/libraries/System.Runtime.InteropServices/tests/TestAssets/NativeExports/Error.cs @@ -35,6 +35,61 @@ public static int SetError(int error, byte shouldSetError) return error; } + [UnmanagedCallersOnly(EntryPoint = "return_error")] + public static int ReturnError(int error) => error; + + [UnmanagedCallersOnly(EntryPoint = "set_error_out")] + public static void SetErrorOut(int error, int* errorValue) + { + *errorValue = error; + } + + [UnmanagedCallersOnly(EntryPoint = "set_error_ref")] + public static void SetErrorRef(int error, int* errorValue) + { + *errorValue += error; + } + + [UnmanagedCallersOnly(EntryPoint = "set_constant_error_out")] + public static void SetConstantErrorOut(int* errorValue) + { + *errorValue = 0; + } + + [UnmanagedCallersOnly(EntryPoint = "return_error_with_output")] + public static int ReturnErrorWithOutput(int error, int* output) + { + *output = 42; + return error; + } + + [UnmanagedCallersOnly(EntryPoint = "return_error_with_input")] + public static int ReturnErrorWithInput(int error, int* input) + { + return *input == 42 ? error : -1; + } + + [UnmanagedCallersOnly(EntryPoint = "return_error_with_hidden_return")] + public static int ReturnErrorWithHiddenReturn(int error, int* value) + { + *value = 42; + return error; + } + + [UnmanagedCallersOnly(EntryPoint = "set_output_and_error_out")] + public static void SetOutputAndErrorOut(int error, int* output, int* errorValue) + { + *output = 42; + *errorValue = error; + } + + [UnmanagedCallersOnly(EntryPoint = "set_error_with_output")] + public static void SetErrorWithOutput(int error, int* output) + { + *output = 42; + SetLastError(error); + } + [UnmanagedCallersOnly(EntryPoint = "set_error_return_string")] public static ushort* SetErrorReturnString(int error, byte shouldSetError, ushort* errorString) { From 6ba4092a3ff22448a5724ec6c8ecb414c20d22fd Mon Sep 17 00:00:00 2001 From: David Wrighton Date: Mon, 24 Aug 2026 20:40:04 -0700 Subject: [PATCH 14/23] Use hidden return values for QCall exceptions Return pointer-sized exception statuses from native QCalls and process them through LibraryImport hidden-return error handlers. Preserve exact exceptions with GC handles, recreate special exceptions through the runtime, remove thread-local storage, and regenerate WebAssembly helpers. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 97d405de-8e39-4e76-afe4-2f94b74ecfa2 --- .../Runtime/CompilerHelpers/ThrowHelpers.cs | 25 +- .../VersionResilientHashCode.CoreCLR.cs | 5 +- .../src/System/AppContext.CoreCLR.cs | 3 +- .../src/System/ArgIterator.cs | 25 +- .../src/System/Array.CoreCLR.cs | 20 +- .../src/System/CLRConfig.cs | 5 +- .../System/ComAwareWeakReference.CoreCLR.cs | 10 +- .../src/System/Delegate.CoreCLR.cs | 45 +-- .../src/System/Diagnostics/Debugger.cs | 10 +- .../System/Diagnostics/StackFrame.CoreCLR.cs | 5 +- .../System/Diagnostics/StackTrace.CoreCLR.cs | 5 +- .../src/System/Enum.CoreCLR.cs | 6 +- .../src/System/Environment.CoreCLR.cs | 13 +- .../src/System/Exception.CoreCLR.cs | 15 +- .../src/System/GC.CoreCLR.cs | 101 +++--- .../System/IO/FileLoadException.CoreCLR.cs | 10 +- .../src/System/IO/Stream.CoreCLR.cs | 7 +- .../src/System/Object.CoreCLR.cs | 2 +- .../src/System/Reflection/Assembly.CoreCLR.cs | 10 +- .../System/Reflection/AssemblyName.CoreCLR.cs | 5 +- .../Reflection/Emit/DynamicILGenerator.cs | 2 +- .../Reflection/Emit/DynamicMethod.CoreCLR.cs | 2 +- .../Reflection/Emit/RuntimeAssemblyBuilder.cs | 7 +- .../Reflection/Emit/RuntimeEventBuilder.cs | 3 +- .../Reflection/Emit/RuntimeFieldBuilder.cs | 6 +- .../Reflection/Emit/RuntimeMethodBuilder.cs | 6 +- .../Reflection/Emit/RuntimeModuleBuilder.cs | 52 +-- .../Emit/RuntimeParameterBuilder.cs | 3 +- .../Reflection/Emit/RuntimePropertyBuilder.cs | 3 +- .../Reflection/Emit/RuntimeTypeBuilder.cs | 111 +++--- .../src/System/Reflection/LoaderAllocator.cs | 5 +- .../src/System/Reflection/MdImport.cs | 5 +- .../Reflection/Metadata/AssemblyExtensions.cs | 5 +- .../Reflection/Metadata/MetadataUpdater.cs | 10 +- .../System/Reflection/MethodBase.CoreCLR.cs | 5 +- .../src/System/Reflection/RuntimeAssembly.cs | 127 ++++--- .../Reflection/RuntimeCustomAttributeData.cs | 17 +- .../src/System/Reflection/RuntimeModule.cs | 15 +- .../Reflection/TypeNameResolver.CoreCLR.cs | 5 +- .../CompilerServices/AsyncHelpers.CoreCLR.cs | 5 +- .../Runtime/CompilerServices/CastHelpers.cs | 16 +- .../CompilerServices/GenericsHelpers.cs | 11 +- .../Runtime/CompilerServices/InitHelpers.cs | 5 +- .../CompilerServices/QCallExceptionStatus.cs | 45 ++- .../RuntimeHelpers.CoreCLR.cs | 58 +-- .../CompilerServices/StaticsHelpers.cs | 14 +- .../VirtualDispatchHelpers.cs | 5 +- .../Runtime/ControlledExecution.CoreCLR.cs | 5 +- .../src/System/Runtime/DependentHandle.cs | 10 +- .../ExceptionServices/InternalCalls.cs | 16 +- .../InteropServices/ComWrappers.CoreCLR.cs | 8 +- .../InteropServices/GCHandle.CoreCLR.cs | 15 +- .../Java/JavaMarshal.CoreCLR.cs | 16 +- .../InteropServices/Marshal.CoreCLR.cs | 145 +++++--- .../InteropServices/NativeLibrary.CoreCLR.cs | 7 +- .../ObjectiveCMarshal.CoreCLR.cs | 19 +- .../TrackerObjectManager.CoreCLR.cs | 5 +- .../Loader/AssemblyLoadContext.CoreCLR.cs | 67 ++-- .../src/System/RuntimeHandles.cs | 332 ++++++++++-------- .../src/System/RuntimeType.BoxCache.cs | 7 +- .../src/System/RuntimeType.CoreCLR.cs | 24 +- ...meType.CreateUninitializedCache.CoreCLR.cs | 7 +- .../src/System/String.CoreCLR.cs | 10 +- .../src/System/StubHelpers.cs | 123 ++++--- .../System/Threading/ObjectHeader.CoreCLR.cs | 5 +- .../src/System/Threading/Thread.CoreCLR.cs | 79 +++-- .../src/System/TypeLoadException.CoreCLR.cs | 5 +- .../src/System/ValueType.cs | 11 +- .../src/System/Variant.cs | 10 +- .../src/System/Runtime/ExceptionHandling.cs | 15 - .../src/System/Runtime/StackFrameIterator.cs | 10 - src/coreclr/vm/JitQCallHelpers.h | 14 +- src/coreclr/vm/appdomainnative.cpp | 14 +- src/coreclr/vm/appdomainnative.hpp | 10 +- src/coreclr/vm/arraynative.cpp | 10 +- src/coreclr/vm/arraynative.h | 6 +- src/coreclr/vm/assemblynative.cpp | 154 ++++---- src/coreclr/vm/assemblynative.hpp | 92 +++-- src/coreclr/vm/clrconfignative.cpp | 5 +- src/coreclr/vm/clrconfignative.h | 2 +- src/coreclr/vm/comdelegate.cpp | 42 ++- src/coreclr/vm/comdelegate.h | 22 +- src/coreclr/vm/comdependenthandle.cpp | 8 +- src/coreclr/vm/comdependenthandle.h | 4 +- src/coreclr/vm/comdynamic.cpp | 96 +++-- src/coreclr/vm/comdynamic.h | 54 ++- src/coreclr/vm/commodule.cpp | 76 ++-- src/coreclr/vm/commodule.h | 37 +- src/coreclr/vm/comsynchronizable.cpp | 88 +++-- src/coreclr/vm/comsynchronizable.h | 34 +- src/coreclr/vm/comutilnative.cpp | 151 ++++---- src/coreclr/vm/comutilnative.h | 86 +++-- src/coreclr/vm/coreassemblyspec.cpp | 2 +- src/coreclr/vm/customattribute.cpp | 10 +- src/coreclr/vm/customattribute.h | 10 +- src/coreclr/vm/debugdebugger.cpp | 27 +- src/coreclr/vm/debugdebugger.h | 16 +- src/coreclr/vm/ecalllist.h | 1 - src/coreclr/vm/eventpipeinternal.cpp | 71 ++-- src/coreclr/vm/eventpipeinternal.h | 54 ++- src/coreclr/vm/excep.cpp | 10 +- src/coreclr/vm/exceptionhandling.cpp | 26 +- src/coreclr/vm/exceptionhandlingqcalls.h | 10 +- src/coreclr/vm/exceptmacros.h | 17 +- src/coreclr/vm/finalizerthread.cpp | 7 +- src/coreclr/vm/ilmarshalers.cpp | 17 +- src/coreclr/vm/ilmarshalers.h | 10 +- src/coreclr/vm/interoplibinterface.h | 27 +- .../vm/interoplibinterface_comwrappers.cpp | 10 +- .../vm/interoplibinterface_comwrappers.h | 6 +- src/coreclr/vm/interoplibinterface_java.cpp | 23 +- src/coreclr/vm/interoplibinterface_objc.cpp | 24 +- src/coreclr/vm/jithelpers.cpp | 29 +- src/coreclr/vm/loaderallocator.cpp | 6 +- src/coreclr/vm/loaderallocator.hpp | 2 +- src/coreclr/vm/managedmdimport.cpp | 5 +- src/coreclr/vm/managedmdimport.hpp | 5 +- src/coreclr/vm/marshalnative.cpp | 130 +++---- src/coreclr/vm/marshalnative.h | 64 ++-- src/coreclr/vm/method.hpp | 2 +- src/coreclr/vm/mlinfo.cpp | 2 +- src/coreclr/vm/multicorejit.cpp | 4 +- src/coreclr/vm/multicorejit.h | 4 +- src/coreclr/vm/nativeeventsource.cpp | 49 ++- src/coreclr/vm/nativeeventsource.h | 38 +- src/coreclr/vm/nativelibrarynative.cpp | 9 +- src/coreclr/vm/nativelibrarynative.h | 5 +- src/coreclr/vm/olevariant.cpp | 2 +- src/coreclr/vm/olevariant.h | 2 +- src/coreclr/vm/qcall.cpp | 43 ++- src/coreclr/vm/qcall.h | 24 +- src/coreclr/vm/qcallentrypoints.cpp | 1 + src/coreclr/vm/reflectioninvocation.cpp | 94 +++-- src/coreclr/vm/reflectioninvocation.h | 28 +- src/coreclr/vm/runtimehandles.cpp | 225 ++++++------ src/coreclr/vm/runtimehandles.h | 155 ++++---- src/coreclr/vm/stackwalk.h | 4 +- src/coreclr/vm/stubhelpers.cpp | 47 ++- src/coreclr/vm/stubhelpers.h | 34 +- src/coreclr/vm/tailcallhelp.cpp | 6 +- src/coreclr/vm/tailcallhelp.h | 2 +- src/coreclr/vm/threadstatics.cpp | 2 - src/coreclr/vm/threadstatics.h | 1 - src/coreclr/vm/unsafeaccessors.cpp | 6 +- src/coreclr/vm/varargsnative.cpp | 14 +- src/coreclr/vm/varargsnative.h | 10 +- src/coreclr/vm/versionresilienthashcode.cpp | 6 +- src/coreclr/vm/versionresilienthashcode.h | 2 +- .../browser/callhelpers-interp-to-managed.cpp | 266 ++++++-------- src/coreclr/vm/wasm/entrypoints.h | 4 +- .../wasi/callhelpers-interp-to-managed.cpp | 182 +++------- src/coreclr/vm/weakreferencenative.cpp | 9 +- src/coreclr/vm/weakreferencenative.h | 4 +- .../System.Private.CoreLib.Shared.projitems | 1 + .../src/System/AppContext.cs | 5 - .../Diagnostics/Tracing/EventPipe.Internal.cs | 108 +++--- .../System/Diagnostics/Tracing/EventPipe.cs | 5 - .../EventPipeEventDispatcher.Threads.cs | 10 - .../Tracing/EventPipeEventDispatcher.Wasm.cs | 5 - .../Tracing/EventPipeEventDispatcher.cs | 20 -- .../Tracing/EventPipeEventProvider.cs | 30 -- ...ntSource.Threading.NativeSinks.Internal.cs | 144 +++----- ...untimeEventSource.Threading.NativeSinks.cs | 80 ----- .../Tracing/TraceLogging/XplatEventLogger.cs | 36 +- .../src/System/Environment.cs | 2 +- .../Runtime/InteropServices/ComWrappers.cs | 2 +- .../InteropServices/ErrorHandlerAttribute.cs | 27 ++ .../InteropServices/TypeMapLazyDictionary.cs | 41 +-- .../Runtime/Loader/AssemblyLoadContext.cs | 10 - .../src/System/Threading/Lock.cs | 2 +- .../src/System/Threading/Thread.cs | 2 +- .../System/Threading/WaitHandle.Windows.cs | 5 - .../Threading/Wasi/WasiFinalizerScheduler.cs | 28 +- .../CompilerServices/RuntimeHelpersTests.cs | 31 ++ 174 files changed, 2558 insertions(+), 2772 deletions(-) create mode 100644 src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ErrorHandlerAttribute.cs diff --git a/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs b/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs index 1a11f8992c40b3..8cef1a4eee0165 100644 --- a/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs @@ -11,8 +11,9 @@ namespace Internal.Runtime.CompilerHelpers internal static unsafe partial class ThrowHelpers { [DoesNotReturn] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowAmbiguousResolutionException")] - private static partial void ThrowAmbiguousResolutionException(MethodTable* targetType, MethodTable* interfaceType, void* methodDesc, out QCallExceptionStatus qcallException); + private static partial void ThrowAmbiguousResolutionException(MethodTable* targetType, MethodTable* interfaceType, void* methodDesc); [DoesNotReturn] [DebuggerHidden] @@ -21,12 +22,13 @@ internal static void ThrowAmbiguousResolutionException( void* interfaceType, // MethodTable* void* targetType) // MethodTable* { - ThrowAmbiguousResolutionException((MethodTable*)targetType, (MethodTable*)interfaceType, method, out _); + ThrowAmbiguousResolutionException((MethodTable*)targetType, (MethodTable*)interfaceType, method); } [DoesNotReturn] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowEntryPointNotFoundException")] - private static partial void ThrowEntryPointNotFoundException(MethodTable* targetType, MethodTable* interfaceType, void* methodDesc, out QCallExceptionStatus qcallException); + private static partial void ThrowEntryPointNotFoundException(MethodTable* targetType, MethodTable* interfaceType, void* methodDesc); [DoesNotReturn] [DebuggerHidden] @@ -35,12 +37,13 @@ internal static void ThrowEntryPointNotFoundException( void* interfaceType, // MethodTable* void* targetType) // MethodTable* { - ThrowEntryPointNotFoundException((MethodTable*)targetType, (MethodTable*)interfaceType, method, out _); + ThrowEntryPointNotFoundException((MethodTable*)targetType, (MethodTable*)interfaceType, method); } [DoesNotReturn] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowMethodAccessException")] - private static partial void ThrowMethodAccessExceptionInternal(void* caller, void* callee, out QCallExceptionStatus qcallException); + private static partial void ThrowMethodAccessExceptionInternal(void* caller, void* callee); // implementation of CORINFO_HELP_METHOD_ACCESS_EXCEPTION [DoesNotReturn] @@ -49,12 +52,13 @@ internal static void ThrowMethodAccessException( void* caller, // MethodDesc* void* callee) // MethodDesc* { - ThrowMethodAccessExceptionInternal(caller, callee, out _); + ThrowMethodAccessExceptionInternal(caller, callee); } [DoesNotReturn] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowFieldAccessException")] - private static partial void ThrowFieldAccessExceptionInternal(void* caller, void* callee, out QCallExceptionStatus qcallException); + private static partial void ThrowFieldAccessExceptionInternal(void* caller, void* callee); // implementation of CORINFO_HELP_FIELD_ACCESS_EXCEPTION [DoesNotReturn] @@ -63,12 +67,13 @@ internal static void ThrowFieldAccessException( void* caller, // MethodDesc* void* callee) // FieldDesc* { - ThrowFieldAccessExceptionInternal(caller, callee, out _); + ThrowFieldAccessExceptionInternal(caller, callee); } [DoesNotReturn] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowClassAccessException")] - private static partial void ThrowClassAccessExceptionInternal(void* caller, void* callee, out QCallExceptionStatus qcallException); + private static partial void ThrowClassAccessExceptionInternal(void* caller, void* callee); // implementation of CORINFO_HELP_CLASS_ACCESS_EXCEPTION [DoesNotReturn] @@ -77,7 +82,7 @@ internal static void ThrowClassAccessException( void* caller, // MethodDesc* void* callee) // Type handle { - ThrowClassAccessExceptionInternal(caller, callee, out _); + ThrowClassAccessExceptionInternal(caller, callee); } } } diff --git a/src/coreclr/System.Private.CoreLib/src/Internal/VersionResilientHashCode.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/Internal/VersionResilientHashCode.CoreCLR.cs index d537c3f22631e1..e510aa9e7901ce 100644 --- a/src/coreclr/System.Private.CoreLib/src/Internal/VersionResilientHashCode.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/Internal/VersionResilientHashCode.CoreCLR.cs @@ -13,11 +13,12 @@ namespace Internal /// internal static partial class VersionResilientHashCode { + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "VersionResilientHashCode_TypeHashCode")] - private static partial int TypeHashCode(QCallTypeHandle typeHandle, out QCallExceptionStatus qcallException); + private static partial int TypeHashCode(QCallTypeHandle typeHandle); public static int TypeHashCode(RuntimeType type) - => TypeHashCode(new QCallTypeHandle(ref type), out _); + => TypeHashCode(new QCallTypeHandle(ref type)); private static int NameHashCode(string s1, string s2) => NameHashCode(System.Text.Encoding.UTF8.GetBytes(s1), System.Text.Encoding.UTF8.GetBytes(s2)); diff --git a/src/coreclr/System.Private.CoreLib/src/System/AppContext.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/AppContext.CoreCLR.cs index 1aab2c72fa12ce..1ba73e0499d2dc 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/AppContext.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/AppContext.CoreCLR.cs @@ -16,9 +16,10 @@ private static bool IsKnownHostProperty(string name) or "PLATFORM_RESOURCE_ROOTS" or "APP_PATHS"; + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AppContext_TryGetHostPropertyValue", StringMarshalling = StringMarshalling.Utf16)] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool TryGetHostPropertyValue(string name, StringHandleOnStack retValue, out QCallExceptionStatus qcallException); + private static partial bool TryGetHostPropertyValue(string name, StringHandleOnStack retValue); [UnmanagedCallersOnly] private static unsafe void OnProcessExit(Exception* pException) diff --git a/src/coreclr/System.Private.CoreLib/src/System/ArgIterator.cs b/src/coreclr/System.Private.CoreLib/src/System/ArgIterator.cs index a9bba91a3da2fa..f42d79aafebfce 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/ArgIterator.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/ArgIterator.cs @@ -37,11 +37,12 @@ public ArgIterator(RuntimeArgumentHandle arglist) IntPtr cookie = arglist.Value; if (cookie == 0) throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized); - Init(ThisPtr, cookie, out _); + Init(ThisPtr, cookie); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_Init")] - private static partial void Init(ArgIterator* thisPtr, IntPtr cookie, out QCallExceptionStatus qcallException); + private static partial void Init(ArgIterator* thisPtr, IntPtr cookie); // create an arg iterator that points just past 'firstArg'. // 'arglist' is the value returned by the ARGLIST instruction @@ -53,11 +54,12 @@ public ArgIterator(RuntimeArgumentHandle arglist, void* ptr) IntPtr cookie = arglist.Value; if (cookie == 0) throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized); - Init(ThisPtr, cookie, ptr, out _); + Init(ThisPtr, cookie, ptr); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_Init2")] - private static partial void Init(ArgIterator* thisPtr, IntPtr cookie, void* ptr, out QCallExceptionStatus qcallException); + private static partial void Init(ArgIterator* thisPtr, IntPtr cookie, void* ptr); // Fetch an argument as a typed referece, advance the iterator. // Throws an exception if past end of argument list @@ -78,12 +80,13 @@ public TypedReference GetNextArg() } TypedReference result = default; - GetNextArg(ThisPtr, &result, out _); + GetNextArg(ThisPtr, &result); return result; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_GetNextArg")] - private static partial void GetNextArg(ArgIterator* thisPtr, TypedReference* pResult, out QCallExceptionStatus qcallException); + private static partial void GetNextArg(ArgIterator* thisPtr, TypedReference* pResult); // Alternate version of GetNextArg() intended primarily for IJW code // generated by VC's "va_arg()" construct. @@ -113,12 +116,13 @@ public TypedReference GetNextArg(RuntimeTypeHandle rth) } TypedReference result = default; - GetNextArg(ThisPtr, new QCallTypeHandle(ref rth), &result, out _); + GetNextArg(ThisPtr, new QCallTypeHandle(ref rth), &result); return result; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_GetNextArg2")] - private static partial void GetNextArg(ArgIterator* thisPtr, QCallTypeHandle rth, TypedReference* pResult, out QCallExceptionStatus qcallException); + private static partial void GetNextArg(ArgIterator* thisPtr, QCallTypeHandle rth, TypedReference* pResult); // This method should invalidate the iterator (va_end). It is not supported yet. public void End() @@ -139,11 +143,12 @@ public int GetRemainingCount() // Gets the type of the current arg, does NOT advance the iterator public RuntimeTypeHandle GetNextArgType() { - return RuntimeTypeHandle.FromIntPtr(GetNextArgType(ThisPtr, out _)); + return RuntimeTypeHandle.FromIntPtr(GetNextArgType(ThisPtr)); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_GetNextArgType")] - private static partial IntPtr GetNextArgType(ArgIterator* thisPtr, out QCallExceptionStatus qcallException); + private static partial IntPtr GetNextArgType(ArgIterator* thisPtr); public override int GetHashCode() { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Array.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Array.CoreCLR.cs index d655ac4176c6f3..4d19dc30fed964 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Array.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Array.CoreCLR.cs @@ -15,17 +15,16 @@ namespace System // IList and IReadOnlyList, where T : U dynamically. See the SZArrayHelper class for details. public abstract partial class Array : ICloneable, IList, IStructuralComparable, IStructuralEquatable { + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Array_CreateInstance")] private static unsafe partial void InternalCreate(QCallTypeHandle type, int rank, int* pLengths, int* pLowerBounds, - [MarshalAs(UnmanagedType.Bool)] bool fromArrayType, ObjectHandleOnStack retArray, - out QCallExceptionStatus qcallException); + [MarshalAs(UnmanagedType.Bool)] bool fromArrayType, ObjectHandleOnStack retArray); private static unsafe Array InternalCreate(RuntimeType elementType, int rank, int* pLengths, int* pLowerBounds) { Array? retArray = null; InternalCreate(new QCallTypeHandle(ref elementType), rank, pLengths, pLowerBounds, - fromArrayType: false, ObjectHandleOnStack.Create(ref retArray), - out _); + fromArrayType: false, ObjectHandleOnStack.Create(ref retArray)); return retArray!; } @@ -33,13 +32,13 @@ private static unsafe Array InternalCreateFromArrayType(RuntimeType arrayType, i { Array? retArray = null; InternalCreate(new QCallTypeHandle(ref arrayType), rank, pLengths, pLowerBounds, - fromArrayType: true, ObjectHandleOnStack.Create(ref retArray), - out _); + fromArrayType: true, ObjectHandleOnStack.Create(ref retArray)); return retArray!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Array_Ctor")] - private static unsafe partial void Ctor(MethodTable* pArrayMT, uint dwNumArgs, int* pArgList, ObjectHandleOnStack retArray, out QCallExceptionStatus qcallException); + private static unsafe partial void Ctor(MethodTable* pArrayMT, uint dwNumArgs, int* pArgList, ObjectHandleOnStack retArray); // implementation of CORINFO_HELP_NEW_MDARR and CORINFO_HELP_NEW_MDARR_RARE. [StackTraceHidden] @@ -48,7 +47,7 @@ private static unsafe Array InternalCreateFromArrayType(RuntimeType arrayType, i internal static unsafe Array Ctor(MethodTable* pArrayMT, uint dwNumArgs, int* pArgList) { Array? arr = null; - Ctor(pArrayMT, dwNumArgs, pArgList, ObjectHandleOnStack.Create(ref arr), out _); + Ctor(pArrayMT, dwNumArgs, pArgList, ObjectHandleOnStack.Create(ref arr)); return arr!; } @@ -352,15 +351,16 @@ internal sealed unsafe partial class ArrayInitializeCache : RuntimeType.IGeneric { internal readonly delegate* ConstructorEntrypoint; + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Array_GetElementConstructorEntrypoint")] - private static partial delegate* GetElementConstructorEntrypoint(QCallTypeHandle arrayType, out QCallExceptionStatus qcallException); + private static partial delegate* GetElementConstructorEntrypoint(QCallTypeHandle arrayType); private ArrayInitializeCache(delegate* constructorEntrypoint) { ConstructorEntrypoint = constructorEntrypoint; } - public static ArrayInitializeCache Create(RuntimeType arrayType) => new(GetElementConstructorEntrypoint(new QCallTypeHandle(ref arrayType), out _)); + public static ArrayInitializeCache Create(RuntimeType arrayType) => new(GetElementConstructorEntrypoint(new QCallTypeHandle(ref arrayType))); public void InitializeCompositeCache(RuntimeType.CompositeCacheEntry compositeEntry) => compositeEntry._arrayInitializeCache = this; public static ref ArrayInitializeCache? GetStorageRef(RuntimeType.CompositeCacheEntry compositeEntry) => ref compositeEntry._arrayInitializeCache; } diff --git a/src/coreclr/System.Private.CoreLib/src/System/CLRConfig.cs b/src/coreclr/System.Private.CoreLib/src/System/CLRConfig.cs index cd48a17172e0b9..0afc5076184407 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/CLRConfig.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/CLRConfig.cs @@ -12,11 +12,12 @@ internal static partial class CLRConfig { internal static bool GetBoolValue(string switchName, out bool exist) { - return GetConfigBoolValue(switchName, out exist, out _); + return GetConfigBoolValue(switchName, out exist); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ClrConfig_GetConfigBoolValue", StringMarshalling = StringMarshalling.Utf16)] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool GetConfigBoolValue(string configSwitchName, [MarshalAs(UnmanagedType.Bool)] out bool exist, out QCallExceptionStatus qcallException); + private static partial bool GetConfigBoolValue(string configSwitchName, [MarshalAs(UnmanagedType.Bool)] out bool exist); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/ComAwareWeakReference.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/ComAwareWeakReference.CoreCLR.cs index 095861d08a5fc4..87d3b5a4bd80ff 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/ComAwareWeakReference.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/ComAwareWeakReference.CoreCLR.cs @@ -9,8 +9,9 @@ namespace System { internal sealed partial class ComAwareWeakReference { + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ComWeakRefToObject")] - private static partial void ComWeakRefToObject(IntPtr pComWeakRef, ObjectHandleOnStack retRcw, out QCallExceptionStatus qcallException); + private static partial void ComWeakRefToObject(IntPtr pComWeakRef, ObjectHandleOnStack retRcw); internal static object? ComWeakRefToObject(IntPtr pComWeakRef, object? context) { @@ -19,7 +20,7 @@ internal sealed partial class ComAwareWeakReference { // This wrapper was not created by ComWrappers, so we try to rehydrate using built-in COM. object? retRcw = null; - ComWeakRefToObject(pComWeakRef, ObjectHandleOnStack.Create(ref retRcw), out _); + ComWeakRefToObject(pComWeakRef, ObjectHandleOnStack.Create(ref retRcw)); return retRcw; } #endif // FEATURE_COMINTEROP @@ -38,8 +39,9 @@ internal static bool PossiblyComObject(object target) #endif // FEATURE_COMINTEROP } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjectToComWeakRef")] - private static partial IntPtr ObjectToComWeakRef(ObjectHandleOnStack retRcw, out QCallExceptionStatus qcallException); + private static partial IntPtr ObjectToComWeakRef(ObjectHandleOnStack retRcw); internal static nint ObjectToComWeakRef(object target, out object? context) { @@ -48,7 +50,7 @@ internal static nint ObjectToComWeakRef(object target, out object? context) { // This object is using built-in COM, so use built-in COM to create the weak reference. context = null; - return ObjectToComWeakRef(ObjectHandleOnStack.Create(ref target), out _); + return ObjectToComWeakRef(ObjectHandleOnStack.Create(ref target)); } #endif // FEATURE_COMINTEROP diff --git a/src/coreclr/System.Private.CoreLib/src/System/Delegate.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Delegate.CoreCLR.cs index 5c72d4a5032c48..16f91d84a5d0a8 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Delegate.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Delegate.CoreCLR.cs @@ -500,8 +500,7 @@ private bool BindToMethodName(object? target, [DynamicallyAccessedMembers(Dynami unsafe { ret = BindToMethodName(RuntimeHelpers.GetMethodTable(this), (target != null) ? RuntimeHelpers.GetMethodTable(target) : null, - new QCallTypeHandle(ref methodType), method, flags, ObjectHandleOnStack.Create(ref target), out bindToMethodDetails, - out _); + new QCallTypeHandle(ref methodType), method, flags, ObjectHandleOnStack.Create(ref target), out bindToMethodDetails); } if (ret) @@ -533,9 +532,10 @@ private struct BindToMethodDetails public GCHandle loaderAllocatorGCHandle; // The loader allocator needed if the delegate needs to keep it alive } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_BindToMethodName", StringMarshalling = StringMarshalling.Utf8)] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool BindToMethodName(MethodTable* pDelegateMT, MethodTable *pTargetMT, QCallTypeHandle methodType, string method, DelegateBindingFlags flags, ObjectHandleOnStack targetParameter, out BindToMethodDetails bindToMethodDetails, out QCallExceptionStatus qcallException); + private static partial bool BindToMethodName(MethodTable* pDelegateMT, MethodTable *pTargetMT, QCallTypeHandle methodType, string method, DelegateBindingFlags flags, ObjectHandleOnStack targetParameter, out BindToMethodDetails bindToMethodDetails); private bool BindToMethodInfo(object? target, IRuntimeMethodInfo method, RuntimeType methodType, DelegateBindingFlags flags) { @@ -545,8 +545,7 @@ private bool BindToMethodInfo(object? target, IRuntimeMethodInfo method, Runtime unsafe { ret = BindToMethodInfo(RuntimeHelpers.GetMethodTable(this), (target != null) ? RuntimeHelpers.GetMethodTable(target) : null, - IRuntimeMethodInfo.GetValue(method), new QCallTypeHandle(ref methodType), flags, ObjectHandleOnStack.Create(ref target), out bindToMethodDetails, - out _); + IRuntimeMethodInfo.GetValue(method), new QCallTypeHandle(ref methodType), flags, ObjectHandleOnStack.Create(ref target), out bindToMethodDetails); } if (ret) @@ -569,9 +568,10 @@ private bool BindToMethodInfo(object? target, IRuntimeMethodInfo method, Runtime return ret; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_BindToMethodInfo")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool BindToMethodInfo(MethodTable* pDelegateMT, MethodTable *pTargetMT, RuntimeMethodHandleInternal method, QCallTypeHandle methodType, DelegateBindingFlags flags, ObjectHandleOnStack targetParameter, out BindToMethodDetails bindToMethodDetails, out QCallExceptionStatus qcallException); + private static partial bool BindToMethodInfo(MethodTable* pDelegateMT, MethodTable *pTargetMT, RuntimeMethodHandleInternal method, QCallTypeHandle methodType, DelegateBindingFlags flags, ObjectHandleOnStack targetParameter, out BindToMethodDetails bindToMethodDetails); private static Delegate InternalAlloc(RuntimeType type) { @@ -597,7 +597,7 @@ private static unsafe bool InternalEqualTypes(object a, object b) bool ret = pMTa->HasTypeEquivalence && pMTb->HasTypeEquivalence && // only use QCall to check the type equivalence scenario - RuntimeHelpers.AreTypesEquivalent(pMTa, pMTb, out _); + RuntimeHelpers.AreTypesEquivalent(pMTa, pMTb); GC.KeepAlive(a); GC.KeepAlive(b); @@ -624,8 +624,7 @@ private void DelegateConstruct(object target, IntPtr method) unsafe { Construct(RuntimeHelpers.GetMethodTable(this), (target != null) ? RuntimeHelpers.GetMethodTable(target) : null, - method, out bindToMethodDetails, - out _); + method, out bindToMethodDetails); } // Apply the results of the QCall to the delegate instance. @@ -643,14 +642,16 @@ private void DelegateConstruct(object target, IntPtr method) _target = target; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_Construct")] - private static partial void Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, IntPtr method, out BindToMethodDetails bindToMethodDetails, out QCallExceptionStatus qcallException); + private static partial void Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, IntPtr method, out BindToMethodDetails bindToMethodDetails); [MethodImpl(MethodImplOptions.InternalCall)] private static extern unsafe void* GetMulticastInvoke(MethodTable* pMT); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_GetMulticastInvokeSlow")] - private static unsafe partial void* GetMulticastInvokeSlow(MethodTable* pMT, out QCallExceptionStatus qcallException); + private static unsafe partial void* GetMulticastInvokeSlow(MethodTable* pMT); private unsafe IntPtr GetMulticastInvoke() { @@ -658,7 +659,7 @@ private unsafe IntPtr GetMulticastInvoke() void* ptr = GetMulticastInvoke(pMT); if (ptr == null) { - ptr = GetMulticastInvokeSlow(pMT, out _); + ptr = GetMulticastInvokeSlow(pMT); Debug.Assert(ptr != null); Debug.Assert(ptr == GetMulticastInvoke(pMT)); } @@ -680,22 +681,24 @@ private unsafe IntPtr GetInvokeMethod() private static unsafe IRuntimeMethodInfo CreateMethodInfo(MethodDesc* methodDesc) { IRuntimeMethodInfo? methodInfo = null; - CreateMethodInfo(methodDesc, ObjectHandleOnStack.Create(ref methodInfo), out _); + CreateMethodInfo(methodDesc, ObjectHandleOnStack.Create(ref methodInfo)); return methodInfo!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_CreateMethodInfo")] - private static unsafe partial void CreateMethodInfo(MethodDesc* methodDesc, ObjectHandleOnStack retMethodInfo, out QCallExceptionStatus qcallException); + private static unsafe partial void CreateMethodInfo(MethodDesc* methodDesc, ObjectHandleOnStack retMethodInfo); [MethodImpl(MethodImplOptions.NoInlining)] private unsafe MethodDesc* GetMethodDesc() { Delegate instance = this; - return GetMethodDesc(ObjectHandleOnStack.Create(ref instance), out _); + return GetMethodDesc(ObjectHandleOnStack.Create(ref instance)); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_GetMethodDesc")] - private static unsafe partial MethodDesc* GetMethodDesc(ObjectHandleOnStack instance, out QCallExceptionStatus qcallException); + private static unsafe partial MethodDesc* GetMethodDesc(ObjectHandleOnStack instance); internal struct Wrapper(Delegate? value) : IEquatable { @@ -884,23 +887,25 @@ internal static IntPtr AdjustTarget(object target, IntPtr methodPtr) { unsafe { - IntPtr result = AdjustTarget(RuntimeHelpers.GetMethodTable(target), methodPtr, out _); + IntPtr result = AdjustTarget(RuntimeHelpers.GetMethodTable(target), methodPtr); GC.KeepAlive(target); return result; } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_AdjustTarget")] - private static partial IntPtr AdjustTarget(MethodTable* targetMT, IntPtr methodPtr, out QCallExceptionStatus qcallException); + private static partial IntPtr AdjustTarget(MethodTable* targetMT, IntPtr methodPtr); internal void InitializeVirtualCallStub(IntPtr methodPtr) { Delegate d = this; - InitializeVirtualCallStub(ObjectHandleOnStack.Create(ref d), methodPtr, out _); + InitializeVirtualCallStub(ObjectHandleOnStack.Create(ref d), methodPtr); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_InitializeVirtualCallStub")] - private static partial void InitializeVirtualCallStub(ObjectHandleOnStack d, IntPtr methodPtr, out QCallExceptionStatus qcallException); + private static partial void InitializeVirtualCallStub(ObjectHandleOnStack d, IntPtr methodPtr); [DoesNotReturn] [DebuggerNonUserCode] diff --git a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs index f36a9bda972708..0e5f3bd160fe4d 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs @@ -11,14 +11,15 @@ namespace System.Diagnostics { public static partial class Debugger { + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DebugDebugger_Break")] - private static partial void BreakInternal(out QCallExceptionStatus qcallException); + private static partial void BreakInternal(); // Break causes a breakpoint to be signalled to an attached debugger. If no debugger // is attached, the user is asked if they want to attach a debugger. If yes, then the // debugger is launched. [MethodImpl(MethodImplOptions.NoInlining)] - public static void Break() => BreakInternal(out _); + public static void Break() => BreakInternal(); // Launch launches & attaches a debugger to the process. If a debugger is already attached, // nothing happens. @@ -50,7 +51,7 @@ public static void NotifyOfCrossThreadDependency() static void NotifyOfCrossThreadDependencySlow() { var notify = new CrossThreadDependencyNotification(); - CustomNotification(ObjectHandleOnStack.Create(ref notify), out _); + CustomNotification(ObjectHandleOnStack.Create(ref notify)); } } @@ -83,8 +84,9 @@ static void NotifyOfCrossThreadDependencySlow() // Posts a custom notification for the attached debugger. If there is no // debugger attached, has no effect. The debugger may or may not // report the notification depending on its settings. + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DebugDebugger_CustomNotification")] - private static partial void CustomNotification(ObjectHandleOnStack data, out QCallExceptionStatus qcallException); + private static partial void CustomNotification(ObjectHandleOnStack data); // implementation of CORINFO_HELP_USER_BREAKPOINT [StackTraceHidden] diff --git a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrame.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrame.CoreCLR.cs index c761e3fab6fdba..d94c2e2b6cb2a0 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrame.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrame.CoreCLR.cs @@ -56,8 +56,9 @@ private void BuildStackFrame(int skipFrames, bool needFileInfo) private static bool AppendStackFrameWithoutMethodBase(StringBuilder sb) => false; #pragma warning restore IDE0060 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StackFrame_GetMethodDescFromNativeIP")] - private static partial RuntimeMethodHandleInternal GetMethodDescFromNativeIP(IntPtr ip, out QCallExceptionStatus qcallException); + private static partial RuntimeMethodHandleInternal GetMethodDescFromNativeIP(IntPtr ip); /// /// Returns the MethodBase instance for the managed code IP address. @@ -68,7 +69,7 @@ private void BuildStackFrame(int skipFrames, bool needFileInfo) /// MethodBase instance for the method or null if IP not found internal static MethodBase? GetMethodFromNativeIP(IntPtr ip) { - RuntimeMethodHandleInternal method = GetMethodDescFromNativeIP(ip, out _); + RuntimeMethodHandleInternal method = GetMethodDescFromNativeIP(ip); if (method.Value == IntPtr.Zero) return null; diff --git a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackTrace.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackTrace.CoreCLR.cs index d352d7d855728b..f014696495dcb4 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackTrace.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackTrace.CoreCLR.cs @@ -9,11 +9,12 @@ namespace System.Diagnostics { public partial class StackTrace { + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StackTrace_GetStackFramesInternal")] - private static partial void GetStackFramesInternal(ObjectHandleOnStack sfh, [MarshalAs(UnmanagedType.Bool)] bool fNeedFileInfo, ObjectHandleOnStack e, out QCallExceptionStatus qcallException); + private static partial void GetStackFramesInternal(ObjectHandleOnStack sfh, [MarshalAs(UnmanagedType.Bool)] bool fNeedFileInfo, ObjectHandleOnStack e); internal static void GetStackFramesInternal(StackFrameHelper sfh, bool fNeedFileInfo, Exception? e) - => GetStackFramesInternal(ObjectHandleOnStack.Create(ref sfh), fNeedFileInfo, ObjectHandleOnStack.Create(ref e), out _); + => GetStackFramesInternal(ObjectHandleOnStack.Create(ref sfh), fNeedFileInfo, ObjectHandleOnStack.Create(ref e)); internal static int CalculateFramesToSkip(StackFrameHelper StackF, int iNumFrames) { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs index 117e5a97cdd831..c852c9186827ae 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs @@ -11,8 +11,9 @@ namespace System { public abstract partial class Enum { + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Enum_GetValuesAndNames")] - private static partial void GetEnumValuesAndNames(QCallTypeHandle enumType, ObjectHandleOnStack values, ObjectHandleOnStack names, Interop.BOOL getNames, out QCallExceptionStatus qcallException); + private static partial void GetEnumValuesAndNames(QCallTypeHandle enumType, ObjectHandleOnStack values, ObjectHandleOnStack names, Interop.BOOL getNames); [MethodImpl(MethodImplOptions.AggressiveInlining)] private static unsafe CorElementType InternalGetCorElementType(RuntimeType rt) @@ -111,8 +112,7 @@ public static EnumInfo Create(RuntimeType type, bool getNames) new QCallTypeHandle(ref type), ObjectHandleOnStack.Create(ref values), ObjectHandleOnStack.Create(ref names), - getNames ? Interop.BOOL.TRUE : Interop.BOOL.FALSE, - out _); + getNames ? Interop.BOOL.TRUE : Interop.BOOL.FALSE); Debug.Assert(values!.GetType() == typeof(TStorage[])); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Environment.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Environment.CoreCLR.cs index 37621d0bd59139..4f4bbfc6d18790 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Environment.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Environment.CoreCLR.cs @@ -20,12 +20,13 @@ public static int CurrentManagedThreadId // Terminates this process with the given exit code. /// QCall that passes the integer exit code to the runtime to terminate the process; it accesses no caller-supplied memory. + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Environment_Exit")] [DoesNotReturn] - private static safe partial void _Exit(int exitCode, out QCallExceptionStatus qcallException); + private static safe partial void _Exit(int exitCode); [DoesNotReturn] - public static void Exit(int exitCode) => _Exit(exitCode, out _); + public static void Exit(int exitCode) => _Exit(exitCode); /// Runtime FCall get/set of the process-wide exit code (an int); it accesses no caller-supplied memory. public static extern safe int ExitCode @@ -82,12 +83,13 @@ internal static void FailFast(string? message, Exception? exception, string? err [DoesNotReturn] private static void FailFast(ref StackCrawlMark mark, string? message, Exception? exception, string? errorMessage) { - FailFast(new StackCrawlMarkHandle(ref mark), message, ObjectHandleOnStack.Create(ref exception), errorMessage, out _); + FailFast(new StackCrawlMarkHandle(ref mark), message, ObjectHandleOnStack.Create(ref exception), errorMessage); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Environment_FailFast", StringMarshalling = StringMarshalling.Utf16)] [DoesNotReturn] - private static partial void FailFast(StackCrawlMarkHandle mark, string? message, ObjectHandleOnStack exception, string? errorMessage, out QCallExceptionStatus qcallException); + private static partial void FailFast(StackCrawlMarkHandle mark, string? message, ObjectHandleOnStack exception, string? errorMessage); private static unsafe string[] InitializeCommandLineArgs(char* exePath, int argc, char** argv) // invoked from VM { @@ -119,8 +121,9 @@ private static unsafe void InitializeCommandLineArgs(char* exePath, int argc, ch } /// QCall that returns the available processor count as an int; it accesses no caller-supplied memory. + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Environment_GetProcessorCount")] - internal static safe partial int GetProcessorCount(out QCallExceptionStatus qcallException); + internal static safe partial int GetProcessorCount(); [UnmanagedCallersOnly] private static unsafe void GetResourceString(char* pKey, string* pResult, Exception* pException) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Exception.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Exception.CoreCLR.cs index 92726a5edb8824..35fa99aa941c3c 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Exception.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Exception.CoreCLR.cs @@ -55,8 +55,9 @@ private IDictionary CreateDataContainer() [MethodImpl(MethodImplOptions.InternalCall)] private static extern bool IsImmutableAgileException(Exception e); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_GetMethodFromStackTrace")] - private static partial void GetMethodFromStackTrace(ObjectHandleOnStack stackTrace, ObjectHandleOnStack method, out QCallExceptionStatus qcallException); + private static partial void GetMethodFromStackTrace(ObjectHandleOnStack stackTrace, ObjectHandleOnStack method); private MethodBase? GetExceptionMethodFromStackTrace() { @@ -67,7 +68,7 @@ private IDictionary CreateDataContainer() } IRuntimeMethodInfo? methodInfo = null; - GetMethodFromStackTrace(ObjectHandleOnStack.Create(ref stackTraceLocal), ObjectHandleOnStack.Create(ref methodInfo), out _); + GetMethodFromStackTrace(ObjectHandleOnStack.Create(ref stackTraceLocal), ObjectHandleOnStack.Create(ref methodInfo)); Debug.Assert(methodInfo != null); return RuntimeType.GetMethodBase(methodInfo); @@ -209,12 +210,13 @@ internal enum ExceptionMessageKind internal static string GetMessageFromNativeResources(ExceptionMessageKind kind) { string? retMesg = null; - GetMessageFromNativeResources(kind, new StringHandleOnStack(ref retMesg), out _); + GetMessageFromNativeResources(kind, new StringHandleOnStack(ref retMesg)); return retMesg!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_GetMessageFromNativeResources")] - private static partial void GetMessageFromNativeResources(ExceptionMessageKind kind, StringHandleOnStack retMesg, out QCallExceptionStatus qcallException); + private static partial void GetMessageFromNativeResources(ExceptionMessageKind kind, StringHandleOnStack retMesg); internal readonly struct DispatchState { @@ -236,14 +238,15 @@ public DispatchState( } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_GetFrozenStackTrace")] - private static partial void GetFrozenStackTrace(ObjectHandleOnStack exception, ObjectHandleOnStack stackTrace, out QCallExceptionStatus qcallException); + private static partial void GetFrozenStackTrace(ObjectHandleOnStack exception, ObjectHandleOnStack stackTrace); internal DispatchState CaptureDispatchState() { Exception _this = this; object? stackTrace = null; - GetFrozenStackTrace(ObjectHandleOnStack.Create(ref _this), ObjectHandleOnStack.Create(ref stackTrace), out _); + GetFrozenStackTrace(ObjectHandleOnStack.Create(ref _this), ObjectHandleOnStack.Create(ref stackTrace)); return new DispatchState(stackTrace, _remoteStackTraceString, _ipForWatsonBuckets, _watsonBuckets); diff --git a/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs index caddcbb85f4b89..c46537e24e1542 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs @@ -91,12 +91,14 @@ public static GCMemoryInfo GetGCMemoryInfo(GCKind kind) /// the caller must pass a positive and a that does not /// exceed it. is the audited entry point that /// validates both. + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_StartNoGCRegion")] - internal static unsafe partial int _StartNoGCRegion(long totalSize, [MarshalAs(UnmanagedType.Bool)] bool lohSizeKnown, long lohSize, [MarshalAs(UnmanagedType.Bool)] bool disallowFullBlockingGC, out QCallExceptionStatus qcallException); + internal static unsafe partial int _StartNoGCRegion(long totalSize, [MarshalAs(UnmanagedType.Bool)] bool lohSizeKnown, long lohSize, [MarshalAs(UnmanagedType.Bool)] bool disallowFullBlockingGC); /// QCall that ends the no-GC region and returns a status code; it takes no arguments and accesses no caller-supplied memory. + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_EndNoGCRegion")] - internal static safe partial int _EndNoGCRegion(out QCallExceptionStatus qcallException); + internal static safe partial int _EndNoGCRegion(); // keep in sync with GC_ALLOC_FLAGS in gcinterface.h internal enum GC_ALLOC_FLAGS @@ -106,18 +108,21 @@ internal enum GC_ALLOC_FLAGS GC_ALLOC_PINNED_OBJECT_HEAP = 64, }; + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_AllocateNewArray")] - private static partial void AllocateNewArray(IntPtr typeHandlePtr, int length, GC_ALLOC_FLAGS flags, ObjectHandleOnStack ret, out QCallExceptionStatus qcallException); + private static partial void AllocateNewArray(IntPtr typeHandlePtr, int length, GC_ALLOC_FLAGS flags, ObjectHandleOnStack ret); /// QCall that returns the total managed heap byte count as a scalar; it takes no arguments and accesses no caller-supplied memory. + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_GetTotalMemory")] - private static safe partial long GetTotalMemory(out QCallExceptionStatus qcallException); + private static safe partial long GetTotalMemory(); /// The runtime only asserts that is at least -1 before handing it to the /// GC, so the caller must not pass a smaller value. /// is the audited entry point that validates it. + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_Collect")] - private static unsafe partial void _Collect(int generation, int mode, [MarshalAs(UnmanagedType.U1)] bool lowMemoryPressure, out QCallExceptionStatus qcallException); + private static unsafe partial void _Collect(int generation, int mode, [MarshalAs(UnmanagedType.U1)] bool lowMemoryPressure); /// FCall that returns the maximum supported generation number as a scalar; it takes no arguments and accesses no caller-supplied memory. [MethodImpl(MethodImplOptions.InternalCall)] @@ -143,12 +148,14 @@ internal enum GC_ALLOC_FLAGS internal static extern unsafe ulong GetGenerationSize(int gen); /// QCall that records added memory pressure from a scalar byte count; it accesses no caller-supplied memory. + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_AddMemoryPressure")] - private static safe partial void _AddMemoryPressure(ulong bytesAllocated, out QCallExceptionStatus qcallException); + private static safe partial void _AddMemoryPressure(ulong bytesAllocated); /// QCall that records removed memory pressure from a scalar byte count; it accesses no caller-supplied memory. + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_RemoveMemoryPressure")] - private static safe partial void _RemoveMemoryPressure(ulong bytesAllocated, out QCallExceptionStatus qcallException); + private static safe partial void _RemoveMemoryPressure(ulong bytesAllocated); public static void AddMemoryPressure(long bytesAllocated) { @@ -158,7 +165,7 @@ public static void AddMemoryPressure(long bytesAllocated) ArgumentOutOfRangeException.ThrowIfGreaterThan(bytesAllocated, int.MaxValue); } - _AddMemoryPressure((ulong)bytesAllocated, out _); + _AddMemoryPressure((ulong)bytesAllocated); } public static void RemoveMemoryPressure(long bytesAllocated) @@ -169,7 +176,7 @@ public static void RemoveMemoryPressure(long bytesAllocated) ArgumentOutOfRangeException.ThrowIfGreaterThan(bytesAllocated, int.MaxValue); } - _RemoveMemoryPressure((ulong)bytesAllocated, out _); + _RemoveMemoryPressure((ulong)bytesAllocated); } // Returns the generation that obj is currently in. @@ -195,7 +202,7 @@ public static void Collect(int generation) public static void Collect() { // -1 says to GC all generations. - _Collect(-1, (int)InternalGCCollectionMode.Blocking, lowMemoryPressure: false, out _); + _Collect(-1, (int)InternalGCCollectionMode.Blocking, lowMemoryPressure: false); } public static void Collect(int generation, GCCollectionMode mode) @@ -260,7 +267,7 @@ internal static void Collect(int generation, GCCollectionMode mode, bool blockin iInternalModes |= (int)InternalGCCollectionMode.NonBlocking; } - _Collect(generation, (int)iInternalModes, lowMemoryPressure, out _); + _Collect(generation, (int)iInternalModes, lowMemoryPressure); } public static int CollectionCount(int generation) @@ -327,8 +334,9 @@ public static int GetGeneration(WeakReference wo) // public static int MaxGeneration => GetMaxGeneration(); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_GetNextFinalizableObject")] - private static unsafe partial void* GetNextFinalizeableObject(ObjectHandleOnStack target, out QCallExceptionStatus qcallException); + private static unsafe partial void* GetNextFinalizeableObject(ObjectHandleOnStack target); [UnmanagedCallersOnly] private static unsafe uint RunFinalizers() @@ -339,7 +347,7 @@ private static unsafe uint RunFinalizers() while (true) { object? target = null; - void* fptr = GetNextFinalizeableObject(ObjectHandleOnStack.Create(ref target), out _); + void* fptr = GetNextFinalizeableObject(ObjectHandleOnStack.Create(ref target)); if (fptr == null) break; @@ -360,13 +368,14 @@ private static unsafe uint RunFinalizers() } /// QCall that blocks until pending finalizers drain; it takes no arguments and accesses no caller-supplied memory. + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_WaitForPendingFinalizers")] - private static safe partial void _WaitForPendingFinalizers(out QCallExceptionStatus qcallException); + private static safe partial void _WaitForPendingFinalizers(); public static void WaitForPendingFinalizers() { // QCalls can not be exposed directly, need to wrap it. - _WaitForPendingFinalizers(out _); + _WaitForPendingFinalizers(); } // Indicates that the system should not call the Finalize() method on @@ -389,8 +398,9 @@ public static unsafe void SuppressFinalize(object obj) // for which SuppressFinalize has already been called. The other situation // where calling ReRegisterForFinalize is useful is inside a finalizer that // needs to resurrect itself or an object that it references. + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_ReRegisterForFinalize")] - private static partial void ReRegisterForFinalize(ObjectHandleOnStack o, out QCallExceptionStatus qcallException); + private static partial void ReRegisterForFinalize(ObjectHandleOnStack o); public static unsafe void ReRegisterForFinalize(object obj) { @@ -399,7 +409,7 @@ public static unsafe void ReRegisterForFinalize(object obj) MethodTable* pMT = RuntimeHelpers.GetMethodTable(obj); if (pMT->HasFinalizer) { - ReRegisterForFinalize(ObjectHandleOnStack.Create(ref obj), out _); + ReRegisterForFinalize(ObjectHandleOnStack.Create(ref obj)); } // GC.KeepAlive(obj) not required. pMT kept alive via ObjectHandleOnStack @@ -411,7 +421,7 @@ public static unsafe void ReRegisterForFinalize(object obj) // public static long GetTotalMemory(bool forceFullCollection) { - long size = GetTotalMemory(out _); + long size = GetTotalMemory(); if (!forceFullCollection) return size; // If we force a full collection, we will run the finalizers on all @@ -427,17 +437,19 @@ public static long GetTotalMemory(bool forceFullCollection) WaitForPendingFinalizers(); Collect(); size = newSize; - newSize = GetTotalMemory(out _); + newSize = GetTotalMemory(); diff = ((float)(newSize - size)) / size; } while (reps-- > 0 && !(-.05 < diff && diff < .05)); return newSize; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_RegisterFrozenSegment")] - private static partial IntPtr _RegisterFrozenSegment(IntPtr sectionAddress, nint sectionSize, out QCallExceptionStatus qcallException); + private static partial IntPtr _RegisterFrozenSegment(IntPtr sectionAddress, nint sectionSize); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_UnregisterFrozenSegment")] - private static partial void _UnregisterFrozenSegment(IntPtr segmentHandle, out QCallExceptionStatus qcallException); + private static partial void _UnregisterFrozenSegment(IntPtr segmentHandle); /// FCall that returns the current thread's allocated byte count as a scalar; it takes no arguments and accesses no caller-supplied memory. [MethodImpl(MethodImplOptions.InternalCall)] @@ -448,15 +460,16 @@ public static long GetTotalMemory(bool forceFullCollection) /// Get a count of the bytes allocated over the lifetime of the process. /// /// If true, gather a precise number, otherwise gather a fairly count. Gathering a precise value triggers at a significant performance penalty. - public static long GetTotalAllocatedBytes(bool precise = false) => precise ? GetTotalAllocatedBytesPrecise(out _) : GetTotalAllocatedBytesApproximate(); + public static long GetTotalAllocatedBytes(bool precise = false) => precise ? GetTotalAllocatedBytesPrecise() : GetTotalAllocatedBytesApproximate(); /// FCall that returns an approximate process-wide allocated byte count as a scalar; it takes no arguments and accesses no caller-supplied memory. [MethodImpl(MethodImplOptions.InternalCall)] private static extern safe long GetTotalAllocatedBytesApproximate(); /// QCall that returns a precise process-wide allocated byte count as a scalar; it takes no arguments and accesses no caller-supplied memory. + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_GetTotalAllocatedBytesPrecise")] - private static safe partial long GetTotalAllocatedBytesPrecise(out QCallExceptionStatus qcallException); + private static safe partial long GetTotalAllocatedBytesPrecise(); /// FCall that enables full-GC notifications from scalar percentage arguments and returns a status flag; it accesses no caller-supplied memory. [MethodImpl(MethodImplOptions.InternalCall)] @@ -467,12 +480,14 @@ public static long GetTotalMemory(bool forceFullCollection) private static extern safe bool _CancelFullGCNotification(); /// QCall that waits for an approaching full GC using a scalar timeout and returns a status code; it accesses no caller-supplied memory. + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_WaitForFullGCApproach")] - private static safe partial int _WaitForFullGCApproach(int millisecondsTimeout, out QCallExceptionStatus qcallException); + private static safe partial int _WaitForFullGCApproach(int millisecondsTimeout); /// QCall that waits for full-GC completion using a scalar timeout and returns a status code; it accesses no caller-supplied memory. + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_WaitForFullGCComplete")] - private static safe partial int _WaitForFullGCComplete(int millisecondsTimeout, out QCallExceptionStatus qcallException); + private static safe partial int _WaitForFullGCComplete(int millisecondsTimeout); public static void RegisterForFullGCNotification(int maxGenerationThreshold, int largeObjectHeapThreshold) { @@ -510,25 +525,25 @@ public static void CancelFullGCNotification() public static GCNotificationStatus WaitForFullGCApproach() { - return (GCNotificationStatus)_WaitForFullGCApproach(-1, out _); + return (GCNotificationStatus)_WaitForFullGCApproach(-1); } public static GCNotificationStatus WaitForFullGCApproach(int millisecondsTimeout) { ArgumentOutOfRangeException.ThrowIfLessThan(millisecondsTimeout, -1); - return (GCNotificationStatus)_WaitForFullGCApproach(millisecondsTimeout, out _); + return (GCNotificationStatus)_WaitForFullGCApproach(millisecondsTimeout); } public static GCNotificationStatus WaitForFullGCComplete() { - return (GCNotificationStatus)_WaitForFullGCComplete(-1, out _); + return (GCNotificationStatus)_WaitForFullGCComplete(-1); } public static GCNotificationStatus WaitForFullGCComplete(int millisecondsTimeout) { ArgumentOutOfRangeException.ThrowIfLessThan(millisecondsTimeout, -1); - return (GCNotificationStatus)_WaitForFullGCComplete(millisecondsTimeout, out _); + return (GCNotificationStatus)_WaitForFullGCComplete(millisecondsTimeout); } private enum StartNoGCRegionStatus @@ -558,7 +573,7 @@ private static bool StartNoGCRegionWorker(long totalSize, bool hasLohSize, long ArgumentOutOfRangeException.ThrowIfGreaterThan(lohSize, totalSize); } - StartNoGCRegionStatus status = (StartNoGCRegionStatus)_StartNoGCRegion(totalSize, hasLohSize, lohSize, disallowFullBlockingGC, out _); + StartNoGCRegionStatus status = (StartNoGCRegionStatus)_StartNoGCRegion(totalSize, hasLohSize, lohSize, disallowFullBlockingGC); switch (status) { case StartNoGCRegionStatus.NotEnoughMemory: @@ -595,7 +610,7 @@ public static bool TryStartNoGCRegion(long totalSize, long lohSize, bool disallo public static void EndNoGCRegion() { - EndNoGCRegionStatus status = (EndNoGCRegionStatus)_EndNoGCRegion(out _); + EndNoGCRegionStatus status = (EndNoGCRegionStatus)_EndNoGCRegion(); if (status == EndNoGCRegionStatus.NotInProgress) throw new InvalidOperationException(SR.InvalidOperationException_NoGCRegionNotInProgress); else if (status == EndNoGCRegionStatus.GCInduced) @@ -751,7 +766,7 @@ public static unsafe void RegisterNoGCRegionCallback(long totalSize, Action call pWorkItem->action = new GCHandle(callback); pWorkItem->callback = &Callback; - EnableNoGCRegionCallbackStatus status = (EnableNoGCRegionCallbackStatus)_EnableNoGCRegionCallback(pWorkItem, totalSize, out _); + EnableNoGCRegionCallbackStatus status = (EnableNoGCRegionCallbackStatus)_EnableNoGCRegionCallback(pWorkItem, totalSize); if (status != EnableNoGCRegionCallbackStatus.Success) { switch (status) @@ -789,18 +804,20 @@ static void Free(NoGCRegionCallbackFinalizerWorkItem* pWorkItem) } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_EnableNoGCRegionCallback")] - private static unsafe partial EnableNoGCRegionCallbackStatus _EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, long totalSize, out QCallExceptionStatus qcallException); + private static unsafe partial EnableNoGCRegionCallbackStatus _EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, long totalSize); internal static long GetGenerationBudget(int generation) { - return _GetGenerationBudget(generation, out _); + return _GetGenerationBudget(generation); } /// The GC indexes its per-generation dynamic data with without /// bounds-checking it, so the caller must pass an existing generation number. + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_GetGenerationBudget")] - internal static unsafe partial long _GetGenerationBudget(int generation, out QCallExceptionStatus qcallException); + internal static unsafe partial long _GetGenerationBudget(int generation); internal static void UnregisterMemoryLoadChangeNotification(Action notification) { @@ -861,7 +878,7 @@ static T[] AllocateNewArrayWorker(int length, bool pinned) } T[]? result = null; - AllocateNewArray(RuntimeTypeHandle.ToIntPtr(typeof(T[]).TypeHandle), length, flags, ObjectHandleOnStack.Create(ref result), out _); + AllocateNewArray(RuntimeTypeHandle.ToIntPtr(typeof(T[]).TypeHandle), length, flags, ObjectHandleOnStack.Create(ref result)); return result!; } } @@ -882,7 +899,7 @@ public static T[] AllocateArray(int length, bool pinned = false) // T[] rathe } T[]? result = null; - AllocateNewArray(RuntimeTypeHandle.ToIntPtr(typeof(T[]).TypeHandle), length, flags, ObjectHandleOnStack.Create(ref result), out _); + AllocateNewArray(RuntimeTypeHandle.ToIntPtr(typeof(T[]).TypeHandle), length, flags, ObjectHandleOnStack.Create(ref result)); return result!; } @@ -953,7 +970,7 @@ public static unsafe IReadOnlyDictionary GetConfigurationVariabl Configurations = new Dictionary() }; - _EnumerateConfigurationValues(&context, &ConfigCallback, out _); + _EnumerateConfigurationValues(&context, &ConfigCallback); return context.Configurations!; } @@ -965,8 +982,9 @@ internal enum GCConfigurationType Boolean } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_EnumerateConfigurationValues")] - internal static unsafe partial void _EnumerateConfigurationValues(void* configurationDictionary, delegate* unmanaged callback, out QCallExceptionStatus qcallException); + internal static unsafe partial void _EnumerateConfigurationValues(void* configurationDictionary, delegate* unmanaged callback); internal enum RefreshMemoryStatus { @@ -1021,7 +1039,7 @@ public static void RefreshMemoryLimit() HeapHardLimitLOHPercent = heapHardLimitLOHPercent, HeapHardLimitPOHPercent = heapHardLimitPOHPercent, }; - RefreshMemoryStatus status = (RefreshMemoryStatus)_RefreshMemoryLimit(heapHardLimitInfo, out _); + RefreshMemoryStatus status = (RefreshMemoryStatus)_RefreshMemoryLimit(heapHardLimitInfo); switch (status) { case RefreshMemoryStatus.HardLimitTooLow: @@ -1032,8 +1050,9 @@ public static void RefreshMemoryLimit() Debug.Assert(status == RefreshMemoryStatus.Succeeded); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_RefreshMemoryLimit")] - internal static partial int _RefreshMemoryLimit(GCHeapHardLimitInfo heapHardLimitInfo, out QCallExceptionStatus qcallException); + internal static partial int _RefreshMemoryLimit(GCHeapHardLimitInfo heapHardLimitInfo); internal struct GCHeapHardLimitInfo { diff --git a/src/coreclr/System.Private.CoreLib/src/System/IO/FileLoadException.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/IO/FileLoadException.CoreCLR.cs index 60a25971de983f..f000167e64b4e4 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/IO/FileLoadException.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/IO/FileLoadException.CoreCLR.cs @@ -21,22 +21,24 @@ private FileLoadException(string? fileName, string? requestingAssemblyChain, int internal static string FormatFileLoadExceptionMessage(string? fileName, int hResult) { string? format = null; - GetFileLoadExceptionMessage(hResult, new StringHandleOnStack(ref format), out _); + GetFileLoadExceptionMessage(hResult, new StringHandleOnStack(ref format)); string? message = null; if (hResult == HResults.COR_E_BADEXEFORMAT) message = SR.Arg_BadImageFormatException; else - GetMessageForHR(hResult, new StringHandleOnStack(ref message), out _); + GetMessageForHR(hResult, new StringHandleOnStack(ref message)); return string.Format(format!, fileName, message); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall)] - private static partial void GetFileLoadExceptionMessage(int hResult, StringHandleOnStack retString, out QCallExceptionStatus qcallException); + private static partial void GetFileLoadExceptionMessage(int hResult, StringHandleOnStack retString); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "FileLoadException_GetMessageForHR")] - private static partial void GetMessageForHR(int hresult, StringHandleOnStack retString, out QCallExceptionStatus qcallException); + private static partial void GetMessageForHR(int hresult, StringHandleOnStack retString); // See clrex.cpp for native version. internal enum FileLoadExceptionKind diff --git a/src/coreclr/System.Private.CoreLib/src/System/IO/Stream.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/IO/Stream.CoreCLR.cs index 5129259fe35a87..d61c486966a6f2 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/IO/Stream.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/IO/Stream.CoreCLR.cs @@ -9,9 +9,10 @@ namespace System.IO { public abstract unsafe partial class Stream { + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Stream_HasOverriddenSlow")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool HasOverriddenSlow(MethodTable* pMT, [MarshalAs(UnmanagedType.Bool)] bool isRead, out QCallExceptionStatus qcallException); + private static partial bool HasOverriddenSlow(MethodTable* pMT, [MarshalAs(UnmanagedType.Bool)] bool isRead); private bool HasOverriddenBeginEndRead() { @@ -24,7 +25,7 @@ private bool HasOverriddenBeginEndRead() [MethodImpl(MethodImplOptions.NoInlining)] static bool HasOverriddenReadSlow(MethodTable* pMT) - => HasOverriddenSlow(pMT, isRead: true, out _); + => HasOverriddenSlow(pMT, isRead: true); } private bool HasOverriddenBeginEndWrite() @@ -38,7 +39,7 @@ private bool HasOverriddenBeginEndWrite() [MethodImpl(MethodImplOptions.NoInlining)] static bool HasOverriddenWriteSlow(MethodTable* pMT) - => HasOverriddenSlow(pMT, isRead: false, out _); + => HasOverriddenSlow(pMT, isRead: false); } } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Object.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Object.CoreCLR.cs index 156c52f9091631..445666ea916fc0 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Object.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Object.CoreCLR.cs @@ -27,7 +27,7 @@ public unsafe Type GetType() protected internal unsafe object MemberwiseClone() { object clone = this; - RuntimeHelpers.AllocateUninitializedClone(ObjectHandleOnStack.Create(ref clone), out _); + RuntimeHelpers.AllocateUninitializedClone(ObjectHandleOnStack.Create(ref clone)); Debug.Assert(clone != this); // copy contents of "this" to the clone diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Assembly.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Assembly.CoreCLR.cs index 40d731fbf389f3..d1559e1ff58e35 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Assembly.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Assembly.CoreCLR.cs @@ -54,13 +54,14 @@ public static Assembly Load(AssemblyName assemblyRef) return RuntimeAssembly.InternalLoad(assemblyRef, ref stackMark, AssemblyLoadContext.CurrentContextualReflectionContext); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetExecutingAssembly")] - private static partial void GetExecutingAssemblyNative(StackCrawlMarkHandle stackMark, ObjectHandleOnStack retAssembly, out QCallExceptionStatus qcallException); + private static partial void GetExecutingAssemblyNative(StackCrawlMarkHandle stackMark, ObjectHandleOnStack retAssembly); internal static RuntimeAssembly GetExecutingAssembly(ref StackCrawlMark stackMark) { RuntimeAssembly? retAssembly = null; - GetExecutingAssemblyNative(new StackCrawlMarkHandle(ref stackMark), ObjectHandleOnStack.Create(ref retAssembly), out _); + GetExecutingAssemblyNative(new StackCrawlMarkHandle(ref stackMark), ObjectHandleOnStack.Create(ref retAssembly)); return retAssembly!; } @@ -85,13 +86,14 @@ public static Assembly GetCallingAssembly() return GetExecutingAssembly(ref stackMark); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetEntryAssembly")] - private static partial void GetEntryAssemblyNative(ObjectHandleOnStack retAssembly, out QCallExceptionStatus qcallException); + private static partial void GetEntryAssemblyNative(ObjectHandleOnStack retAssembly); private static RuntimeAssembly? GetEntryAssemblyInternal() { RuntimeAssembly? entryAssembly = null; - GetEntryAssemblyNative(ObjectHandleOnStack.Create(ref entryAssembly), out _); + GetEntryAssemblyNative(ObjectHandleOnStack.Create(ref entryAssembly)); return entryAssembly; } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs index 6a19fa743b77e5..da5072d621e99a 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs @@ -170,7 +170,7 @@ private static unsafe void ParseAsAssemblySpec(char* pAssemblyName, void* pAssem nameParts.SetVersion(parts._version, defaultValue: ushort.MaxValue); - InitializeAssemblySpec(&nameParts, pAssemblySpec, out _); + InitializeAssemblySpec(&nameParts, pAssemblySpec); } } catch (Exception ex) @@ -192,7 +192,8 @@ private static unsafe void CreateAssemblyName(AssemblyName* pResult, NativeAssem } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyName_InitializeAssemblySpec")] - private static unsafe partial void InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, void* pAssemblySpec, out QCallExceptionStatus qcallException); + private static unsafe partial void InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, void* pAssemblySpec); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicILGenerator.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicILGenerator.cs index 9744d4c9c62b36..42fad545acf345 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicILGenerator.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicILGenerator.cs @@ -673,7 +673,7 @@ private sealed class DestroyScout return; } - RuntimeMethodHandle.Destroy(m_methodHandle, out _); + RuntimeMethodHandle.Destroy(m_methodHandle); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicMethod.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicMethod.CoreCLR.cs index bcfe81973b792f..b337fa3dd8d25e 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicMethod.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicMethod.CoreCLR.cs @@ -51,7 +51,7 @@ public sealed override Delegate CreateDelegate(Type delegateType, object? target // Compile the method since accessibility checks are done as part of compilation GetMethodDescriptor(); IRuntimeMethodInfo? methodHandle = _methodHandle; - CompileMethod(methodHandle != null ? IRuntimeMethodInfo.GetValue(methodHandle) : RuntimeMethodHandleInternal.EmptyHandle, out _); + CompileMethod(methodHandle != null ? IRuntimeMethodInfo.GetValue(methodHandle) : RuntimeMethodHandleInternal.EmptyHandle); GC.KeepAlive(methodHandle); } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeAssemblyBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeAssemblyBuilder.cs index b2168540caf705..fc6e638c5a9fe2 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeAssemblyBuilder.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeAssemblyBuilder.cs @@ -112,13 +112,13 @@ internal RuntimeAssemblyBuilder(AssemblyName name, #region DefineDynamicAssembly + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AppDomain_CreateDynamicAssembly")] private static unsafe partial void CreateDynamicAssembly(ObjectHandleOnStack assemblyLoadContext, NativeAssemblyNameParts* pAssemblyName, AssemblyHashAlgorithm hashAlgId, AssemblyBuilderAccess access, - ObjectHandleOnStack retAssembly, - out QCallExceptionStatus qcallException); + ObjectHandleOnStack retAssembly); private static unsafe RuntimeAssembly CreateDynamicAssembly(AssemblyLoadContext assemblyLoadContext, AssemblyName name, AssemblyBuilderAccess access) { @@ -146,8 +146,7 @@ private static unsafe RuntimeAssembly CreateDynamicAssembly(AssemblyLoadContext &nameParts, name.HashAlgorithm, access, - ObjectHandleOnStack.Create(ref retAssembly), - out _); + ObjectHandleOnStack.Create(ref retAssembly)); #pragma warning restore SYSLIB0037 } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeEventBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeEventBuilder.cs index 1aacb3d27edd3a..cf3da5e026c41a 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeEventBuilder.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeEventBuilder.cs @@ -55,8 +55,7 @@ private void SetMethodSemantics(MethodBuilder mdBuilder, MethodSemanticsAttribut new QCallModule(ref module), m_evToken, semantics, - mdBuilder.MetadataToken, - out _); + mdBuilder.MetadataToken); } protected override void SetAddOnMethodCore(MethodBuilder mdBuilder) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeFieldBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeFieldBuilder.cs index adbecceef032a5..e607b1523d7653 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeFieldBuilder.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeFieldBuilder.cs @@ -38,7 +38,7 @@ internal RuntimeFieldBuilder(RuntimeTypeBuilder typeBuilder, string fieldName, T RuntimeModuleBuilder module = m_typeBuilder.GetModuleBuilder(); m_fieldTok = RuntimeTypeBuilder.DefineField(new QCallModule(ref module), - typeBuilder.TypeToken, fieldName, signature, sigLength, m_Attributes, out _); + typeBuilder.TypeToken, fieldName, signature, sigLength, m_Attributes); } #endregion @@ -47,7 +47,7 @@ internal RuntimeFieldBuilder(RuntimeTypeBuilder typeBuilder, string fieldName, T internal void SetData(byte[]? data, int size) { RuntimeModuleBuilder module = m_typeBuilder.GetModuleBuilder(); - RuntimeModuleBuilder.SetFieldRVAContent(new QCallModule(ref module), m_fieldTok, data, size, out _); + RuntimeModuleBuilder.SetFieldRVAContent(new QCallModule(ref module), m_fieldTok, data, size); } #endregion @@ -133,7 +133,7 @@ protected override void SetOffsetCore(int iOffset) m_typeBuilder.ThrowIfCreated(); RuntimeModuleBuilder module = m_typeBuilder.GetModuleBuilder(); - RuntimeTypeBuilder.SetFieldLayoutOffset(new QCallModule(ref module), m_fieldTok, iOffset, out _); + RuntimeTypeBuilder.SetFieldLayoutOffset(new QCallModule(ref module), m_fieldTok, iOffset); } protected override void SetConstantCore(object? defaultValue) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeMethodBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeMethodBuilder.cs index abbb99da5426db..6ee68d1843e80b 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeMethodBuilder.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeMethodBuilder.cs @@ -596,14 +596,14 @@ private int GetTokenNoLock() byte[] sigBytes = GetMethodSignature().InternalGetSignature(out int sigLength); RuntimeModuleBuilder module = m_module; - int token = RuntimeTypeBuilder.DefineMethod(new QCallModule(ref module), m_containingType.MetadataToken, m_strName, sigBytes, sigLength, Attributes, out _); + int token = RuntimeTypeBuilder.DefineMethod(new QCallModule(ref module), m_containingType.MetadataToken, m_strName, sigBytes, sigLength, Attributes); m_token = token; if (m_inst != null) foreach (RuntimeGenericTypeParameterBuilder tb in m_inst) if (!tb.m_type.IsCreated()) tb.m_type.CreateType(); - RuntimeTypeBuilder.SetMethodImpl(new QCallModule(ref module), token, m_dwMethodImplFlags, out _); + RuntimeTypeBuilder.SetMethodImpl(new QCallModule(ref module), token, m_dwMethodImplFlags); return m_token; } @@ -658,7 +658,7 @@ protected override void SetImplementationFlagsCore(MethodImplAttributes attribut m_dwMethodImplFlags = attributes; RuntimeModuleBuilder module = m_module; - RuntimeTypeBuilder.SetMethodImpl(new QCallModule(ref module), MetadataToken, attributes, out _); + RuntimeTypeBuilder.SetMethodImpl(new QCallModule(ref module), MetadataToken, attributes); } protected override ILGenerator GetILGeneratorCore(int size) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeModuleBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeModuleBuilder.cs index 038d61b1656e5b..a6b7251bdeddd7 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeModuleBuilder.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeModuleBuilder.cs @@ -98,38 +98,42 @@ internal void CheckTypeNameConflict(string strTypeName, Type? enclosingType) return SymbolType.FormCompoundType(strFormat, baseType, 0); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetTypeRef", StringMarshalling = StringMarshalling.Utf16)] - private static partial int GetTypeRef(QCallModule module, string strFullName, QCallModule refedModule, int tkResolution, out QCallExceptionStatus qcallException); + private static partial int GetTypeRef(QCallModule module, string strFullName, QCallModule refedModule, int tkResolution); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetMemberRef")] - private static partial int GetMemberRef(QCallModule module, QCallModule refedModule, int tr, int defToken, out QCallExceptionStatus qcallException); + private static partial int GetMemberRef(QCallModule module, QCallModule refedModule, int tr, int defToken); private int GetMemberRef(Module? refedModule, int tr, int defToken) { RuntimeModuleBuilder thisModule = this; RuntimeModule refedRuntimeModule = GetRuntimeModuleFromModule(refedModule); - return GetMemberRef(new QCallModule(ref thisModule), new QCallModule(ref refedRuntimeModule), tr, defToken, out _); + return GetMemberRef(new QCallModule(ref thisModule), new QCallModule(ref refedRuntimeModule), tr, defToken); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetMemberRefFromSignature", StringMarshalling = StringMarshalling.Utf16)] - private static partial int GetMemberRefFromSignature(QCallModule module, int tr, string methodName, byte[] signature, int length, out QCallExceptionStatus qcallException); + private static partial int GetMemberRefFromSignature(QCallModule module, int tr, string methodName, byte[] signature, int length); private int GetMemberRefFromSignature(int tr, string methodName, byte[] signature, int length) { RuntimeModuleBuilder thisModule = this; - return GetMemberRefFromSignature(new QCallModule(ref thisModule), tr, methodName, signature, length, out _); + return GetMemberRefFromSignature(new QCallModule(ref thisModule), tr, methodName, signature, length); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetMemberRefOfMethodInfo")] - private static partial int GetMemberRefOfMethodInfo(QCallModule module, int tr, RuntimeMethodHandleInternal method, out QCallExceptionStatus qcallException); + private static partial int GetMemberRefOfMethodInfo(QCallModule module, int tr, RuntimeMethodHandleInternal method); private int GetMemberRefOfMethodInfo(int tr, RuntimeMethodInfo method) { Debug.Assert(method != null); RuntimeModuleBuilder thisModule = this; - int result = GetMemberRefOfMethodInfo(new QCallModule(ref thisModule), tr, IRuntimeMethodInfo.GetValue(method), out _); + int result = GetMemberRefOfMethodInfo(new QCallModule(ref thisModule), tr, IRuntimeMethodInfo.GetValue(method)); GC.KeepAlive(method); return result; } @@ -139,39 +143,44 @@ private int GetMemberRefOfMethodInfo(int tr, RuntimeConstructorInfo method) Debug.Assert(method != null); RuntimeModuleBuilder thisModule = this; - int result = GetMemberRefOfMethodInfo(new QCallModule(ref thisModule), tr, IRuntimeMethodInfo.GetValue(method), out _); + int result = GetMemberRefOfMethodInfo(new QCallModule(ref thisModule), tr, IRuntimeMethodInfo.GetValue(method)); GC.KeepAlive(method); return result; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetMemberRefOfFieldInfo")] - private static partial int GetMemberRefOfFieldInfo(QCallModule module, int tkType, QCallTypeHandle declaringType, int tkField, out QCallExceptionStatus qcallException); + private static partial int GetMemberRefOfFieldInfo(QCallModule module, int tkType, QCallTypeHandle declaringType, int tkField); private int GetMemberRefOfFieldInfo(int tkType, RuntimeTypeHandle declaringType, RuntimeFieldInfo runtimeField) { Debug.Assert(runtimeField != null); RuntimeModuleBuilder thisModule = this; - return GetMemberRefOfFieldInfo(new QCallModule(ref thisModule), tkType, new QCallTypeHandle(ref declaringType), runtimeField.MetadataToken, out _); + return GetMemberRefOfFieldInfo(new QCallModule(ref thisModule), tkType, new QCallTypeHandle(ref declaringType), runtimeField.MetadataToken); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetTokenFromTypeSpec")] - private static partial int GetTokenFromTypeSpec(QCallModule pModule, byte[] signature, int length, out QCallExceptionStatus qcallException); + private static partial int GetTokenFromTypeSpec(QCallModule pModule, byte[] signature, int length); private int GetTokenFromTypeSpec(byte[] signature, int length) { RuntimeModuleBuilder thisModule = this; - return GetTokenFromTypeSpec(new QCallModule(ref thisModule), signature, length, out _); + return GetTokenFromTypeSpec(new QCallModule(ref thisModule), signature, length); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetArrayMethodToken", StringMarshalling = StringMarshalling.Utf16)] - private static partial int GetArrayMethodToken(QCallModule module, int tkTypeSpec, string methodName, byte[] signature, int sigLength, out QCallExceptionStatus qcallException); + private static partial int GetArrayMethodToken(QCallModule module, int tkTypeSpec, string methodName, byte[] signature, int sigLength); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetStringConstant", StringMarshalling = StringMarshalling.Utf16)] - private static partial int GetStringConstant(QCallModule module, string str, int length, out QCallExceptionStatus qcallException); + private static partial int GetStringConstant(QCallModule module, string str, int length); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_SetFieldRVAContent")] - internal static partial void SetFieldRVAContent(QCallModule module, int fdToken, byte[]? data, int length, out QCallExceptionStatus qcallException); + internal static partial void SetFieldRVAContent(QCallModule module, int fdToken, byte[]? data, int length); #endregion @@ -218,7 +227,7 @@ private int GetTypeRefNested(Type type, Module? refedModule) RuntimeModuleBuilder thisModule = this; RuntimeModule refedRuntimeModule = GetRuntimeModuleFromModule(refedModule); - return GetTypeRef(new QCallModule(ref thisModule), typeName, new QCallModule(ref refedRuntimeModule), tkResolution, out _); + return GetTypeRef(new QCallModule(ref thisModule), typeName, new QCallModule(ref refedRuntimeModule), tkResolution); } public override int GetMethodMetadataToken(ConstructorInfo constructor) @@ -1094,7 +1103,7 @@ internal int GetMethodTokenInternal(MethodBase method, Type[]? optionalParameter byte[] sigBytes = SignatureHelper.GetMethodSpecSigHelper( this, methodInfo.GetGenericArguments()).InternalGetSignature(out int sigLength); RuntimeModuleBuilder thisModule = this; - tk = RuntimeTypeBuilder.DefineMethodSpec(new QCallModule(ref thisModule), tk, sigBytes, sigLength, out _); + tk = RuntimeTypeBuilder.DefineMethodSpec(new QCallModule(ref thisModule), tk, sigBytes, sigLength); } else { @@ -1145,8 +1154,7 @@ private int GetArrayMethodTokenNoLock(Type arrayClass, string methodName, Callin RuntimeModuleBuilder thisModule = this; return GetArrayMethodToken(new QCallModule(ref thisModule), - typeSpec, methodName, sigBytes, length, - out _); + typeSpec, methodName, sigBytes, length); } protected override MethodInfo GetArrayMethodCore(Type arrayClass, string methodName, CallingConventions callingConvention, @@ -1252,7 +1260,7 @@ public override int GetStringMetadataToken(string stringConstant) // Returns a token representing a String constant. If the string // value has already been defined, the existing token will be returned. RuntimeModuleBuilder thisModule = this; - return GetStringConstant(new QCallModule(ref thisModule), stringConstant, stringConstant.Length, out _); + return GetStringConstant(new QCallModule(ref thisModule), stringConstant, stringConstant.Length); } public override int GetSignatureMetadataToken(SignatureHelper signature) @@ -1264,7 +1272,7 @@ public override int GetSignatureMetadataToken(SignatureHelper signature) // Get the signature in byte form. byte[] sigBytes = signature.InternalGetSignature(out int sigLength); RuntimeModuleBuilder thisModule = this; - return RuntimeTypeBuilder.GetTokenFromSig(new QCallModule(ref thisModule), sigBytes, sigLength, out _); + return RuntimeTypeBuilder.GetTokenFromSig(new QCallModule(ref thisModule), sigBytes, sigLength); } internal int GetSignatureToken(byte[] sigBytes, int sigLength) @@ -1275,7 +1283,7 @@ internal int GetSignatureToken(byte[] sigBytes, int sigLength) Buffer.BlockCopy(sigBytes, 0, localSigBytes, 0, sigBytes.Length); RuntimeModuleBuilder thisModule = this; - return RuntimeTypeBuilder.GetTokenFromSig(new QCallModule(ref thisModule), localSigBytes, sigLength, out _); + return RuntimeTypeBuilder.GetTokenFromSig(new QCallModule(ref thisModule), localSigBytes, sigLength); } #endregion diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeParameterBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeParameterBuilder.cs index c5bcbc88be5d8c..71980345a00776 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeParameterBuilder.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeParameterBuilder.cs @@ -42,8 +42,7 @@ internal RuntimeParameterBuilder( _methodBuilder.MetadataToken, sequence, attributes, - paramName, - out _); + paramName); } internal int GetToken() diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimePropertyBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimePropertyBuilder.cs index c1947acbae873d..9c6bad8f0bb00a 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimePropertyBuilder.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimePropertyBuilder.cs @@ -76,8 +76,7 @@ private void SetMethodSemantics(MethodBuilder mdBuilder, MethodSemanticsAttribut new QCallModule(ref module), m_tkProperty, semantics, - mdBuilder.MetadataToken, - out _); + mdBuilder.MetadataToken); } protected override void SetGetMethodCore(MethodBuilder mdBuilder) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeTypeBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeTypeBuilder.cs index 51ffc5cf9ff3d1..5806b18a1792e4 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeTypeBuilder.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeTypeBuilder.cs @@ -57,87 +57,97 @@ public void Bake(RuntimeModuleBuilder module, int token) #endregion #region Private Static FCalls + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetParentType")] - private static partial void SetParentType(QCallModule module, int tdTypeDef, int tkParent, out QCallExceptionStatus qcallException); + private static partial void SetParentType(QCallModule module, int tdTypeDef, int tkParent); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_AddInterfaceImpl")] - private static partial void AddInterfaceImpl(QCallModule module, int tdTypeDef, int tkInterface, out QCallExceptionStatus qcallException); + private static partial void AddInterfaceImpl(QCallModule module, int tdTypeDef, int tkInterface); #endregion #region Internal Static FCalls + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineMethod", StringMarshalling = StringMarshalling.Utf16)] internal static partial int DefineMethod(QCallModule module, int tkParent, string name, byte[] signature, int sigLength, - MethodAttributes attributes, - out QCallExceptionStatus qcallException); + MethodAttributes attributes); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineMethodSpec")] - internal static partial int DefineMethodSpec(QCallModule module, int tkParent, byte[] signature, int sigLength, out QCallExceptionStatus qcallException); + internal static partial int DefineMethodSpec(QCallModule module, int tkParent, byte[] signature, int sigLength); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineField", StringMarshalling = StringMarshalling.Utf16)] internal static partial int DefineField(QCallModule module, int tkParent, string name, byte[] signature, int sigLength, - FieldAttributes attributes, - out QCallExceptionStatus qcallException); + FieldAttributes attributes); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetMethodIL")] private static partial void SetMethodIL(QCallModule module, int tk, [MarshalAs(UnmanagedType.Bool)] bool isInitLocals, byte[]? body, int bodyLength, byte[] LocalSig, int sigLength, int maxStackSize, ExceptionHandler[]? exceptions, int numExceptions, - int[]? tokenFixups, int numTokenFixups, - out QCallExceptionStatus qcallException); + int[]? tokenFixups, int numTokenFixups); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineCustomAttribute")] private static partial void DefineCustomAttribute(QCallModule module, int tkAssociate, int tkConstructor, - ReadOnlySpan attr, int attrLength, - out QCallExceptionStatus qcallException); + ReadOnlySpan attr, int attrLength); internal static void DefineCustomAttribute(RuntimeModuleBuilder module, int tkAssociate, int tkConstructor, ReadOnlySpan attr) { DefineCustomAttribute(new QCallModule(ref module), tkAssociate, tkConstructor, - attr, attr.Length, - out _); + attr, attr.Length); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineProperty", StringMarshalling = StringMarshalling.Utf16)] internal static partial int DefineProperty(QCallModule module, int tkParent, string name, PropertyAttributes attributes, - byte[] signature, int sigLength, - out QCallExceptionStatus qcallException); + byte[] signature, int sigLength); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineEvent", StringMarshalling = StringMarshalling.Utf16)] - internal static partial int DefineEvent(QCallModule module, int tkParent, string name, EventAttributes attributes, int tkEventType, out QCallExceptionStatus qcallException); + internal static partial int DefineEvent(QCallModule module, int tkParent, string name, EventAttributes attributes, int tkEventType); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineMethodSemantics")] internal static partial void DefineMethodSemantics(QCallModule module, int tkAssociation, - MethodSemanticsAttributes semantics, int tkMethod, - out QCallExceptionStatus qcallException); + MethodSemanticsAttributes semantics, int tkMethod); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineMethodImpl")] - internal static partial void DefineMethodImpl(QCallModule module, int tkType, int tkBody, int tkDecl, out QCallExceptionStatus qcallException); + internal static partial void DefineMethodImpl(QCallModule module, int tkType, int tkBody, int tkDecl); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetMethodImpl")] - internal static partial void SetMethodImpl(QCallModule module, int tkMethod, MethodImplAttributes MethodImplAttributes, out QCallExceptionStatus qcallException); + internal static partial void SetMethodImpl(QCallModule module, int tkMethod, MethodImplAttributes MethodImplAttributes); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetParamInfo", StringMarshalling = StringMarshalling.Utf16)] internal static partial int SetParamInfo(QCallModule module, int tkMethod, int iSequence, - ParameterAttributes iParamAttributes, string? strParamName, - out QCallExceptionStatus qcallException); + ParameterAttributes iParamAttributes, string? strParamName); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_GetTokenFromSig")] - internal static partial int GetTokenFromSig(QCallModule module, byte[] signature, int sigLength, out QCallExceptionStatus qcallException); + internal static partial int GetTokenFromSig(QCallModule module, byte[] signature, int sigLength); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetFieldLayoutOffset")] - internal static partial void SetFieldLayoutOffset(QCallModule module, int fdToken, int iOffset, out QCallExceptionStatus qcallException); + internal static partial void SetFieldLayoutOffset(QCallModule module, int fdToken, int iOffset); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetClassLayout")] - internal static partial void SetClassLayout(QCallModule module, int tk, PackingSize iPackingSize, int iTypeSize, out QCallExceptionStatus qcallException); + internal static partial void SetClassLayout(QCallModule module, int tk, PackingSize iPackingSize, int iTypeSize); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetConstantValue")] - private static unsafe partial void SetConstantValue(QCallModule module, int tk, int corType, void* pValue, out QCallExceptionStatus qcallException); + private static unsafe partial void SetConstantValue(QCallModule module, int tk, int corType, void* pValue); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetPInvokeData", StringMarshalling = StringMarshalling.Utf16)] - private static partial void SetPInvokeData(QCallModule module, string DllName, string name, int token, int linkFlags, out QCallExceptionStatus qcallException); + private static partial void SetPInvokeData(QCallModule module, string DllName, string name, int token, int linkFlags); #endregion #region Internal\Private Static Members @@ -274,20 +284,20 @@ internal static unsafe void SetConstantValue(RuntimeModuleBuilder module, int tk case CorElementType.ELEMENT_TYPE_U8: case CorElementType.ELEMENT_TYPE_R8: fixed (byte* pData = &value.GetRawData()) - SetConstantValue(new QCallModule(ref module), tk, (int)corType, pData, out _); + SetConstantValue(new QCallModule(ref module), tk, (int)corType, pData); break; default: if (type == typeof(string)) { fixed (char* pString = (string)value) - SetConstantValue(new QCallModule(ref module), tk, (int)CorElementType.ELEMENT_TYPE_STRING, pString, out _); + SetConstantValue(new QCallModule(ref module), tk, (int)CorElementType.ELEMENT_TYPE_STRING, pString); } else if (type == typeof(DateTime)) { // date is a I8 representation long ticks = ((DateTime)value).Ticks; - SetConstantValue(new QCallModule(ref module), tk, (int)CorElementType.ELEMENT_TYPE_I8, &ticks, out _); + SetConstantValue(new QCallModule(ref module), tk, (int)CorElementType.ELEMENT_TYPE_I8, &ticks); } else { @@ -302,7 +312,7 @@ internal static unsafe void SetConstantValue(RuntimeModuleBuilder module, int tk // (See ECMA-335 II.15.4.1.4 "The .param directive" and II.22.9 "Constant" for details.) // This is how the Roslyn compilers generally encode `default(TValueType)` default values. - SetConstantValue(new QCallModule(ref module), tk, (int)CorElementType.ELEMENT_TYPE_CLASS, null, out _); + SetConstantValue(new QCallModule(ref module), tk, (int)CorElementType.ELEMENT_TYPE_CLASS, null); } } @@ -458,13 +468,12 @@ internal RuntimeTypeBuilder( } m_tdType = DefineType(new QCallModule(ref module), - name, tkParent, m_iAttr, tkEnclosingType, interfaceTokens!, - out _); + name, tkParent, m_iAttr, tkEnclosingType, interfaceTokens!); m_iPackingSize = iPackingSize; m_iTypeSize = iTypeSize; if ((m_iPackingSize != 0) || (m_iTypeSize != 0)) - SetClassLayout(new QCallModule(ref module), m_tdType, m_iPackingSize, m_iTypeSize, out _); + SetClassLayout(new QCallModule(ref module), m_tdType, m_iPackingSize, m_iTypeSize); m_module.AddType(FullName!, this); } @@ -542,18 +551,19 @@ protected override bool IsCreatedCore() #endregion #region FCalls + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineType", StringMarshalling = StringMarshalling.Utf16)] private static partial int DefineType(QCallModule module, - string fullname, int tkParent, TypeAttributes attributes, int tkEnclosingType, int[] interfaceTokens, - out QCallExceptionStatus qcallException); + string fullname, int tkParent, TypeAttributes attributes, int tkEnclosingType, int[] interfaceTokens); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineGenericParam", StringMarshalling = StringMarshalling.Utf16)] private static partial int DefineGenericParam(QCallModule module, - string name, int tkParent, GenericParameterAttributes attributes, int position, int[] constraints, - out QCallExceptionStatus qcallException); + string name, int tkParent, GenericParameterAttributes attributes, int position, int[] constraints); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_TermCreateClass")] - private static partial void TermCreateClass(QCallModule module, int tk, ObjectHandleOnStack type, out QCallExceptionStatus qcallException); + private static partial void TermCreateClass(QCallModule module, int tk, ObjectHandleOnStack type); #endregion #region Internal Methods @@ -1082,7 +1092,7 @@ protected override void DefineMethodOverrideCore(MethodInfo methodInfoBody, Meth int tkDecl = m_module.GetMethodMetadataToken(methodInfoDeclaration); RuntimeModuleBuilder module = m_module; - DefineMethodImpl(new QCallModule(ref module), m_tdType, tkBody, tkDecl, out _); + DefineMethodImpl(new QCallModule(ref module), m_tdType, tkBody, tkDecl); } } @@ -1193,8 +1203,7 @@ protected override MethodBuilder DefinePInvokeMethodCore(string name, string dll dllName, entryName, token, - linkFlags, - out _); + linkFlags); method.SetToken(token); @@ -1421,8 +1430,7 @@ protected override PropertyBuilder DefinePropertyCore(string name, PropertyAttri name, attributes, sigBytes, - sigLength, - out _); + sigLength); // create the property builder now. return new RuntimePropertyBuilder( @@ -1458,8 +1466,7 @@ protected override EventBuilder DefineEventCore(string name, EventAttributes att m_tdType, name, attributes, - tkType, - out _); + tkType); // create the property builder now. return new RuntimeEventBuilder( @@ -1541,8 +1548,7 @@ protected override TypeInfo CreateTypeInfoCore() int declMember = m_declMeth == null ? m_DeclaringType!.m_tdType : m_declMeth.MetadataToken; m_tdType = DefineGenericParam(new QCallModule(ref module), - m_strName!, declMember, m_genParamAttributes, m_genParamPos, constraints, - out _); + m_strName!, declMember, m_genParamAttributes, m_genParamPos, constraints); if (m_ca != null) { @@ -1561,7 +1567,7 @@ protected override TypeInfo CreateTypeInfoCore() // Check for global typebuilder if (((m_tdType & 0x00FFFFFF) != 0) && ((tkParent & 0x00FFFFFF) != 0)) { - SetParentType(new QCallModule(ref module), m_tdType, tkParent, out _); + SetParentType(new QCallModule(ref module), m_tdType, tkParent); } if (m_inst != null) @@ -1636,8 +1642,7 @@ protected override TypeInfo CreateTypeInfoCore() body, (body != null) ? body.Length : 0, localSig, sigLength, maxStack, exceptions, (exceptions != null) ? exceptions.Length : 0, - tokenFixups, (tokenFixups != null) ? tokenFixups.Length : 0, - out _); + tokenFixups, (tokenFixups != null) ? tokenFixups.Length : 0); if (m_module.ContainingAssemblyBuilder._access == AssemblyBuilderAccess.Run) { @@ -1651,7 +1656,7 @@ protected override TypeInfo CreateTypeInfoCore() // Terminate the process. RuntimeType? cls = null; - TermCreateClass(new QCallModule(ref module), m_tdType, ObjectHandleOnStack.Create(ref cls), out _); + TermCreateClass(new QCallModule(ref module), m_tdType, ObjectHandleOnStack.Create(ref cls)); if (!m_isHiddenGlobalType) { @@ -1712,7 +1717,7 @@ protected override void AddInterfaceImplementationCore([DynamicallyAccessedMembe int tkInterface = m_module.GetTypeTokenInternal(interfaceType); RuntimeModuleBuilder module = m_module; - AddInterfaceImpl(new QCallModule(ref module), m_tdType, tkInterface, out _); + AddInterfaceImpl(new QCallModule(ref module), m_tdType, tkInterface); m_typeInterfaces!.Add(interfaceType); } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/LoaderAllocator.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/LoaderAllocator.cs index 6e9ca1a9552238..24c8857db08a53 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/LoaderAllocator.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/LoaderAllocator.cs @@ -26,9 +26,10 @@ internal sealed partial class LoaderAllocatorScout // This field is set by the VM to atomically transfer the ownership to the managed loader allocator internal IntPtr m_nativeLoaderAllocator; + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "LoaderAllocator_Destroy")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool Destroy(IntPtr nativeLoaderAllocator, out QCallExceptionStatus qcallException); + private static partial bool Destroy(IntPtr nativeLoaderAllocator); ~LoaderAllocatorScout() { @@ -36,7 +37,7 @@ internal sealed partial class LoaderAllocatorScout return; // Destroy returns false if the managed LoaderAllocator is still alive. - if (!Destroy(m_nativeLoaderAllocator, out _)) + if (!Destroy(m_nativeLoaderAllocator)) { // Somebody might have been holding a reference on us via weak handle. // We will keep trying. It will be hopefully released eventually. diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs index ea71f4c1f7d24c..a2376da50571f0 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs @@ -333,8 +333,9 @@ internal MetadataImport(RuntimeModule module) } #endregion + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MetadataImport_Enum")] - private static unsafe partial void Enum(IntPtr scope, int type, int parent, ref int length, int* shortResult, ObjectHandleOnStack longResult, out QCallExceptionStatus qcallException); + private static unsafe partial void Enum(IntPtr scope, int type, int parent, ref int length, int* shortResult, ObjectHandleOnStack longResult); public unsafe void Enum(MetadataTokenType type, int parent, out MetadataEnumResult result) { @@ -342,7 +343,7 @@ public unsafe void Enum(MetadataTokenType type, int parent, out MetadataEnumResu int length = MetadataEnumResult.SmallIntArrayLength; fixed (int* p = &result._smallResult.e) { - Enum(m_metadataImport2, (int)type, parent, ref length, p, ObjectHandleOnStack.Create(ref result._largeResult), out _); + Enum(m_metadataImport2, (int)type, parent, ref length, p, ObjectHandleOnStack.Create(ref result._largeResult)); } result._length = length; } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/AssemblyExtensions.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/AssemblyExtensions.cs index 4874d76c63c491..f38f9fe5041647 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/AssemblyExtensions.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/AssemblyExtensions.cs @@ -9,9 +9,10 @@ namespace System.Reflection.Metadata { public static partial class AssemblyExtensions { + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_InternalTryGetRawMetadata")] [return: MarshalAs(UnmanagedType.Bool)] - private static unsafe partial bool InternalTryGetRawMetadata(QCallAssembly assembly, ref byte* blob, ref int length, out QCallExceptionStatus qcallException); + private static unsafe partial bool InternalTryGetRawMetadata(QCallAssembly assembly, ref byte* blob, ref int length); /// /// Retrieves the metadata section of the assembly, for use with . @@ -44,7 +45,7 @@ public static unsafe bool TryGetRawMetadata(this Assembly assembly, out byte* bl RuntimeAssembly rtAsm = runtimeAssembly; - return InternalTryGetRawMetadata(new QCallAssembly(ref rtAsm), ref blob, ref length, out _); + return InternalTryGetRawMetadata(new QCallAssembly(ref rtAsm), ref blob, ref length); } } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs index 5faa207513eb12..967802a8b3d920 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs @@ -10,12 +10,14 @@ namespace System.Reflection.Metadata { public static partial class MetadataUpdater { + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_ApplyUpdate")] - private static unsafe partial void ApplyUpdate(QCallAssembly assembly, byte* metadataDelta, int metadataDeltaLength, byte* ilDelta, int ilDeltaLength, byte* pdbDelta, int pdbDeltaLength, out QCallExceptionStatus qcallException); + private static unsafe partial void ApplyUpdate(QCallAssembly assembly, byte* metadataDelta, int metadataDeltaLength, byte* ilDelta, int ilDeltaLength, byte* pdbDelta, int pdbDeltaLength); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_IsApplyUpdateSupported")] [return: MarshalAs(UnmanagedType.Bool)] - private static unsafe partial bool IsApplyUpdateSupported(out QCallExceptionStatus qcallException); + private static unsafe partial bool IsApplyUpdateSupported(); /// /// Updates the specified assembly using the provided metadata, IL and PDB deltas. @@ -47,7 +49,7 @@ public static void ApplyUpdate(Assembly assembly, ReadOnlySpan metadataDel RuntimeAssembly rtAsm = runtimeAssembly; fixed (byte* metadataDeltaPtr = metadataDelta, ilDeltaPtr = ilDelta, pdbDeltaPtr = pdbDelta) { - ApplyUpdate(new QCallAssembly(ref rtAsm), metadataDeltaPtr, metadataDelta.Length, ilDeltaPtr, ilDelta.Length, pdbDeltaPtr, pdbDelta.Length, out _); + ApplyUpdate(new QCallAssembly(ref rtAsm), metadataDeltaPtr, metadataDelta.Length, ilDeltaPtr, ilDelta.Length, pdbDeltaPtr, pdbDelta.Length); } } } @@ -61,6 +63,6 @@ public static void ApplyUpdate(Assembly assembly, ReadOnlySpan metadataDel /// Returns true if the apply assembly update is enabled and available. /// [FeatureSwitchDefinition("System.Reflection.Metadata.MetadataUpdater.IsSupported")] - public static bool IsSupported { get; } = IsApplyUpdateSupported(out _); + public static bool IsSupported { get; } = IsApplyUpdateSupported(); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MethodBase.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MethodBase.CoreCLR.cs index ecbc4e4a4f2fbb..c4db36642bfcf5 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MethodBase.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MethodBase.CoreCLR.cs @@ -36,15 +36,16 @@ public abstract partial class MethodBase : MemberInfo return RuntimeType.GetMethodBase(declaringType.GetRuntimeType(), handle.GetMethodInfo()); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MethodBase_GetCurrentMethod")] - private static partial RuntimeMethodHandleInternal GetCurrentMethod(StackCrawlMarkHandle stackMark, out QCallExceptionStatus qcallException); + private static partial RuntimeMethodHandleInternal GetCurrentMethod(StackCrawlMarkHandle stackMark); [RequiresUnreferencedCode("Metadata for the method might be incomplete or removed")] [DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod public static MethodBase? GetCurrentMethod() { StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; - RuntimeMethodHandleInternal methodHandle = GetCurrentMethod(new StackCrawlMarkHandle(ref stackMark), out _); + RuntimeMethodHandleInternal methodHandle = GetCurrentMethod(new StackCrawlMarkHandle(ref stackMark)); return methodHandle.IsNullHandle() ? null : RuntimeType.GetMethodBase(null, methodHandle); } #endregion diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs index b09c14ebd5206d..521d5f8759658c 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs @@ -67,17 +67,17 @@ public override event ModuleResolveEventHandler? ModuleResolve } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetCodeBase")] [return: MarshalAs(UnmanagedType.Bool)] private static partial bool GetCodeBase(QCallAssembly assembly, - StringHandleOnStack retString, - out QCallExceptionStatus qcallException); + StringHandleOnStack retString); internal string? GetCodeBase() { string? codeBase = null; RuntimeAssembly runtimeAssembly = this; - if (GetCodeBase(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref codeBase), out _)) + if (GetCodeBase(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref codeBase))) { return codeBase; } @@ -139,8 +139,9 @@ public override AssemblyName GetName(bool copiedName) return an; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetFullName")] - private static partial void GetFullName(QCallAssembly assembly, StringHandleOnStack retString, out QCallExceptionStatus qcallException); + private static partial void GetFullName(QCallAssembly assembly, StringHandleOnStack retString); public override string? FullName { @@ -151,7 +152,7 @@ public override string? FullName { string? s = null; RuntimeAssembly runtimeAssembly = this; - GetFullName(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref s), out _); + GetFullName(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref s)); Interlocked.CompareExchange(ref m_fullname, s, null); } @@ -159,8 +160,9 @@ public override string? FullName } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetEntryPoint")] - private static partial void GetEntryPoint(QCallAssembly assembly, ObjectHandleOnStack retMethod, out QCallExceptionStatus qcallException); + private static partial void GetEntryPoint(QCallAssembly assembly, ObjectHandleOnStack retMethod); public override MethodInfo? EntryPoint { @@ -168,7 +170,7 @@ public override MethodInfo? EntryPoint { IRuntimeMethodInfo? methodHandle = null; RuntimeAssembly runtimeAssembly = this; - GetEntryPoint(new QCallAssembly(ref runtimeAssembly), ObjectHandleOnStack.Create(ref methodHandle), out _); + GetEntryPoint(new QCallAssembly(ref runtimeAssembly), ObjectHandleOnStack.Create(ref methodHandle)); if (methodHandle == null) return null; @@ -178,21 +180,21 @@ public override MethodInfo? EntryPoint } // For case-sensitive lookups, marshal the strings directly to Utf8 to avoid unnecessary string copies. + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetTypeCore", StringMarshalling = StringMarshalling.Utf8)] private static partial void GetTypeCore(QCallAssembly assembly, string typeName, ReadOnlySpan nestedTypeNames, int nestedTypeNamesLength, - ObjectHandleOnStack retType, - out QCallExceptionStatus qcallException); + ObjectHandleOnStack retType); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetTypeCoreIgnoreCase", StringMarshalling = StringMarshalling.Utf16)] private static partial void GetTypeCoreIgnoreCase(QCallAssembly assembly, string typeName, ReadOnlySpan nestedTypeNames, int nestedTypeNamesLength, - ObjectHandleOnStack retType, - out QCallExceptionStatus qcallException); + ObjectHandleOnStack retType); internal Type? GetTypeCore(string typeName, ReadOnlySpan nestedTypeNames, bool throwOnFileNotFound, bool ignoreCase) { @@ -207,8 +209,7 @@ private static partial void GetTypeCoreIgnoreCase(QCallAssembly assembly, typeName, nestedTypeNames, nestedTypeNames.Length, - ObjectHandleOnStack.Create(ref type), - out _); + ObjectHandleOnStack.Create(ref type)); } else { @@ -216,8 +217,7 @@ private static partial void GetTypeCoreIgnoreCase(QCallAssembly assembly, typeName, nestedTypeNames, nestedTypeNames.Length, - ObjectHandleOnStack.Create(ref type), - out _); + ObjectHandleOnStack.Create(ref type)); } } catch (FileNotFoundException) when (!throwOnFileNotFound) @@ -239,15 +239,16 @@ private static partial void GetTypeCoreIgnoreCase(QCallAssembly assembly, throwOnError: throwOnError, ignoreCase: ignoreCase); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetExportedTypes")] - private static partial void GetExportedTypes(QCallAssembly assembly, ObjectHandleOnStack retTypes, out QCallExceptionStatus qcallException); + private static partial void GetExportedTypes(QCallAssembly assembly, ObjectHandleOnStack retTypes); [RequiresUnreferencedCode("Types might be removed")] public override Type[] GetExportedTypes() { Type[]? types = null; RuntimeAssembly runtimeAssembly = this; - GetExportedTypes(new QCallAssembly(ref runtimeAssembly), ObjectHandleOnStack.Create(ref types), out _); + GetExportedTypes(new QCallAssembly(ref runtimeAssembly), ObjectHandleOnStack.Create(ref types)); return types!; } @@ -271,11 +272,11 @@ public override bool IsCollectible } // GetResource will return a pointer to the resources in memory. + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetResource", StringMarshalling = StringMarshalling.Utf16)] private static unsafe partial byte* GetResource(QCallAssembly assembly, string resourceName, - out uint length, - out QCallExceptionStatus qcallException); + out uint length); // Load a resource based on the NameSpace of the type. public override Stream? GetManifestResourceStream(Type type, string name) @@ -296,7 +297,7 @@ public override bool IsCollectible public override unsafe Stream? GetManifestResourceStream(string name) { RuntimeAssembly runtimeAssembly = this; - byte* pbInMemoryResource = GetResource(new QCallAssembly(ref runtimeAssembly), name, out uint length, out _); + byte* pbInMemoryResource = GetResource(new QCallAssembly(ref runtimeAssembly), name, out uint length); if (pbInMemoryResource != null) { @@ -394,34 +395,34 @@ internal static unsafe RuntimeAssembly InternalLoad(AssemblyName assemblyName, new StackCrawlMarkHandle(ref stackMark), throwOnFileNotFound, ObjectHandleOnStack.Create(ref assemblyLoadContext), - ObjectHandleOnStack.Create(ref retAssembly), - out _); + ObjectHandleOnStack.Create(ref retAssembly)); } return retAssembly!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_InternalLoad")] private static unsafe partial void InternalLoad(NativeAssemblyNameParts* pAssemblyNameParts, ObjectHandleOnStack requestingAssembly, StackCrawlMarkHandle stackMark, [MarshalAs(UnmanagedType.Bool)] bool throwOnFileNotFound, ObjectHandleOnStack assemblyLoadContext, - ObjectHandleOnStack retAssembly, - out QCallExceptionStatus qcallException); + ObjectHandleOnStack retAssembly); public override bool ReflectionOnly => false; // Returns the module in this assembly with name 'name' + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetModule", StringMarshalling = StringMarshalling.Utf16)] - private static partial void GetModule(QCallAssembly assembly, string name, ObjectHandleOnStack retModule, out QCallExceptionStatus qcallException); + private static partial void GetModule(QCallAssembly assembly, string name, ObjectHandleOnStack retModule); public override Module? GetModule(string name) { Module? retModule = null; RuntimeAssembly runtimeAssembly = this; - GetModule(new QCallAssembly(ref runtimeAssembly), name, ObjectHandleOnStack.Create(ref retModule), out _); + GetModule(new QCallAssembly(ref runtimeAssembly), name, ObjectHandleOnStack.Create(ref retModule)); return retModule; } @@ -468,37 +469,39 @@ public override FileStream[] GetFiles(bool getResourceModules) } // Returns the names of all the resources + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetManifestResourceNames")] - private static partial void GetManifestResourceNames(QCallAssembly assembly, ObjectHandleOnStack retResourceNames, out QCallExceptionStatus qcallException); + private static partial void GetManifestResourceNames(QCallAssembly assembly, ObjectHandleOnStack retResourceNames); // Returns the names of all the resources public override string[] GetManifestResourceNames() { string[]? resourceNames = null; RuntimeAssembly runtimeAssembly = this; - GetManifestResourceNames(new QCallAssembly(ref runtimeAssembly), ObjectHandleOnStack.Create(ref resourceNames), out _); + GetManifestResourceNames(new QCallAssembly(ref runtimeAssembly), ObjectHandleOnStack.Create(ref resourceNames)); return resourceNames!; } // Returns the names of all the resources + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetReferencedAssemblies")] - private static partial void GetReferencedAssemblies(QCallAssembly assembly, ObjectHandleOnStack retReferencedAssemblies, out QCallExceptionStatus qcallException); + private static partial void GetReferencedAssemblies(QCallAssembly assembly, ObjectHandleOnStack retReferencedAssemblies); [RequiresUnreferencedCode("Assembly references might be removed")] public override AssemblyName[] GetReferencedAssemblies() { AssemblyName[]? referencedAssemblies = null; RuntimeAssembly runtimeAssembly = this; - GetReferencedAssemblies(new QCallAssembly(ref runtimeAssembly), ObjectHandleOnStack.Create(ref referencedAssemblies), out _); + GetReferencedAssemblies(new QCallAssembly(ref runtimeAssembly), ObjectHandleOnStack.Create(ref referencedAssemblies)); return referencedAssemblies!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetManifestResourceInfo", StringMarshalling = StringMarshalling.Utf16)] private static partial int GetManifestResourceInfo(QCallAssembly assembly, string resourceName, ObjectHandleOnStack assemblyRef, - StringHandleOnStack retFileName, - out QCallExceptionStatus qcallException); + StringHandleOnStack retFileName); public override ManifestResourceInfo? GetManifestResourceInfo(string resourceName) { @@ -507,8 +510,7 @@ private static partial int GetManifestResourceInfo(QCallAssembly assembly, RuntimeAssembly runtimeAssembly = this; int location = GetManifestResourceInfo(new QCallAssembly(ref runtimeAssembly), resourceName, ObjectHandleOnStack.Create(ref retAssembly), - new StringHandleOnStack(ref fileName), - out _); + new StringHandleOnStack(ref fileName)); if (location == -1) return null; @@ -517,8 +519,9 @@ private static partial int GetManifestResourceInfo(QCallAssembly assembly, (ResourceLocation)location); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetLocation")] - private static partial void GetLocation(QCallAssembly assembly, StringHandleOnStack retString, out QCallExceptionStatus qcallException); + private static partial void GetLocation(QCallAssembly assembly, StringHandleOnStack retString); public override string Location { @@ -527,14 +530,15 @@ public override string Location string? location = null; RuntimeAssembly runtimeAssembly = this; - GetLocation(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref location), out _); + GetLocation(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref location)); return AssemblyLoadContext.ResolveAssemblyLocation(this, location!); } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetImageRuntimeVersion")] - private static partial void GetImageRuntimeVersion(QCallAssembly assembly, StringHandleOnStack retString, out QCallExceptionStatus qcallException); + private static partial void GetImageRuntimeVersion(QCallAssembly assembly, StringHandleOnStack retString); public override string ImageRuntimeVersion { @@ -542,7 +546,7 @@ public override string ImageRuntimeVersion { string? s = null; RuntimeAssembly runtimeAssembly = this; - GetImageRuntimeVersion(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref s), out _); + GetImageRuntimeVersion(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref s)); return s!; } } @@ -552,30 +556,31 @@ public override string ImageRuntimeVersion public override long HostContext => 0; + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetVersion")] private static partial void GetVersion(QCallAssembly assembly, out int majVer, out int minVer, out int buildNum, - out int revNum, - out QCallExceptionStatus qcallException); + out int revNum); private Version GetVersion() { RuntimeAssembly runtimeAssembly = this; - GetVersion(new QCallAssembly(ref runtimeAssembly), out int majorVer, out int minorVer, out int build, out int revision, out _); + GetVersion(new QCallAssembly(ref runtimeAssembly), out int majorVer, out int minorVer, out int build, out int revision); return new Version(majorVer, minorVer, build, revision); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetLocale")] - private static partial void GetLocale(QCallAssembly assembly, StringHandleOnStack retString, out QCallExceptionStatus qcallException); + private static partial void GetLocale(QCallAssembly assembly, StringHandleOnStack retString); private CultureInfo GetLocale() { string? locale = null; RuntimeAssembly runtimeAssembly = this; - GetLocale(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref locale), out _); + GetLocale(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref locale)); if (locale == null) return CultureInfo.InvariantCulture; @@ -596,43 +601,47 @@ public override bool IsDynamic } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetSimpleName")] - private static partial void GetSimpleName(QCallAssembly assembly, StringHandleOnStack retSimpleName, out QCallExceptionStatus qcallException); + private static partial void GetSimpleName(QCallAssembly assembly, StringHandleOnStack retSimpleName); internal string GetSimpleName() { RuntimeAssembly runtimeAssembly = this; string? name = null; - GetSimpleName(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref name), out _); + GetSimpleName(new QCallAssembly(ref runtimeAssembly), new StringHandleOnStack(ref name)); return name!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetHashAlgorithm")] - private static partial AssemblyHashAlgorithm GetHashAlgorithm(QCallAssembly assembly, out QCallExceptionStatus qcallException); + private static partial AssemblyHashAlgorithm GetHashAlgorithm(QCallAssembly assembly); private AssemblyHashAlgorithm GetHashAlgorithm() { RuntimeAssembly runtimeAssembly = this; - return GetHashAlgorithm(new QCallAssembly(ref runtimeAssembly), out _); + return GetHashAlgorithm(new QCallAssembly(ref runtimeAssembly)); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetFlags")] - private static partial AssemblyNameFlags GetFlags(QCallAssembly assembly, out QCallExceptionStatus qcallException); + private static partial AssemblyNameFlags GetFlags(QCallAssembly assembly); private AssemblyNameFlags GetFlags() { RuntimeAssembly runtimeAssembly = this; - return GetFlags(new QCallAssembly(ref runtimeAssembly), out _); + return GetFlags(new QCallAssembly(ref runtimeAssembly)); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetPublicKey")] - private static partial void GetPublicKey(QCallAssembly assembly, ObjectHandleOnStack retPublicKey, out QCallExceptionStatus qcallException); + private static partial void GetPublicKey(QCallAssembly assembly, ObjectHandleOnStack retPublicKey); internal byte[]? GetPublicKey() { byte[]? publicKey = null; RuntimeAssembly runtimeAssembly = this; - GetPublicKey(new QCallAssembly(ref runtimeAssembly), ObjectHandleOnStack.Create(ref publicKey), out _); + GetPublicKey(new QCallAssembly(ref runtimeAssembly), ObjectHandleOnStack.Create(ref publicKey)); return publicKey; } @@ -681,12 +690,12 @@ public override Assembly GetSatelliteAssembly(CultureInfo culture, Version? vers return retAssembly; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetModules")] private static partial void GetModules(QCallAssembly assembly, [MarshalAs(UnmanagedType.Bool)] bool loadIfNotFound, [MarshalAs(UnmanagedType.Bool)] bool getResourceModules, - ObjectHandleOnStack retModuleHandles, - out QCallExceptionStatus qcallException); + ObjectHandleOnStack retModuleHandles); private RuntimeModule[] GetModulesInternal(bool loadIfNotFound, bool getResourceModules) @@ -694,7 +703,7 @@ private RuntimeModule[] GetModulesInternal(bool loadIfNotFound, RuntimeModule[]? modules = null; RuntimeAssembly runtimeAssembly = this; - GetModules(new QCallAssembly(ref runtimeAssembly), loadIfNotFound, getResourceModules, ObjectHandleOnStack.Create(ref modules), out _); + GetModules(new QCallAssembly(ref runtimeAssembly), loadIfNotFound, getResourceModules, ObjectHandleOnStack.Create(ref modules)); return modules!; } @@ -716,7 +725,7 @@ private RuntimeModule GetManifestModule() static RuntimeModule GetManifestModuleWorker(RuntimeAssembly assembly) { RuntimeModule? module = null; - GetManifestModuleSlow(ObjectHandleOnStack.Create(ref assembly), ObjectHandleOnStack.Create(ref module), out _); + GetManifestModuleSlow(ObjectHandleOnStack.Create(ref assembly), ObjectHandleOnStack.Create(ref module)); return module!; } } @@ -724,8 +733,9 @@ static RuntimeModule GetManifestModuleWorker(RuntimeAssembly assembly) [MethodImpl(MethodImplOptions.InternalCall)] private static extern RuntimeModule? GetManifestModule(RuntimeAssembly assembly); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyHandle_GetManifestModuleSlow")] - private static partial void GetManifestModuleSlow(ObjectHandleOnStack assembly, ObjectHandleOnStack module, out QCallExceptionStatus qcallException); + private static partial void GetManifestModuleSlow(ObjectHandleOnStack assembly, ObjectHandleOnStack module); [MethodImpl(MethodImplOptions.InternalCall)] private static extern int GetTokenInternal(RuntimeAssembly assembly); @@ -757,7 +767,7 @@ public sealed override Type[] GetForwardedTypes() ObjectHandleOnStack pType = ObjectHandleOnStack.Create(ref type); try { - GetForwardedType(pAssembly, mdtExternalType, pType, out _); + GetForwardedType(pAssembly, mdtExternalType, pType); if (type == null) continue; // mdtExternalType was not a forwarder entry. } @@ -812,7 +822,8 @@ private static void AddPublicNestedTypes(Type type, List types, List GetFullyQualifiedName(); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeModule_GetTypes")] - private static partial void GetTypes(QCallModule module, ObjectHandleOnStack retTypes, ObjectHandleOnStack retExceptions, out QCallExceptionStatus qcallException); + private static partial void GetTypes(QCallModule module, ObjectHandleOnStack retTypes, ObjectHandleOnStack retExceptions); internal RuntimeType[] GetDefinedTypes() { RuntimeType[]? types = null; Exception[]? exceptions = null; RuntimeModule thisAsLocal = this; - GetTypes(new QCallModule(ref thisAsLocal), ObjectHandleOnStack.Create(ref types), ObjectHandleOnStack.Create(ref exceptions), out _); + GetTypes(new QCallModule(ref thisAsLocal), ObjectHandleOnStack.Create(ref types), ObjectHandleOnStack.Create(ref exceptions)); if (exceptions is not null) throw new ReflectionTypeLoadException(types, exceptions, SR.ReflectionTypeLoad_LoadFailed); @@ -481,8 +483,9 @@ public override MethodInfo[] GetMethods(BindingFlags bindingFlags) return RuntimeType.GetMethods(bindingFlags); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeModule_GetScopeName")] - private static partial void GetScopeName(QCallModule module, StringHandleOnStack retString, out QCallExceptionStatus qcallException); + private static partial void GetScopeName(QCallModule module, StringHandleOnStack retString); public override string ScopeName { @@ -490,7 +493,7 @@ public override string ScopeName { string? scopeName = null; RuntimeModule thisAsLocal = this; - GetScopeName(new QCallModule(ref thisAsLocal), new StringHandleOnStack(ref scopeName), out _); + GetScopeName(new QCallModule(ref thisAsLocal), new StringHandleOnStack(ref scopeName)); return scopeName!; } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs index 08296d3afd61b1..0074c6a8f5deb1 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs @@ -197,8 +197,9 @@ private static unsafe void GetTypeHelper(char* pTypeName, RuntimeAssembly* pRequ return assembly; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "UnsafeAccessors_ResolveGenericParamToTypeHandle")] - private static partial IntPtr ResolveGenericParamToTypeHandle(IntPtr unsafeAccessorMethod, [MarshalAs(UnmanagedType.Bool)] bool isMethodParam, uint paramIndex, out QCallExceptionStatus qcallException); + private static partial IntPtr ResolveGenericParamToTypeHandle(IntPtr unsafeAccessorMethod, [MarshalAs(UnmanagedType.Bool)] bool isMethodParam, uint paramIndex); [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "TypeNameResolver.GetType is marked as RequiresUnreferencedCode.")] @@ -269,7 +270,7 @@ private static unsafe void GetTypeHelper(char* pTypeName, RuntimeAssembly* pRequ } Debug.Assert(_unsafeAccessorMethod != IntPtr.Zero); - IntPtr typeHandle = ResolveGenericParamToTypeHandle(_unsafeAccessorMethod, isMethodParam, paramIndex, out _); + IntPtr typeHandle = ResolveGenericParamToTypeHandle(_unsafeAccessorMethod, isMethodParam, paramIndex); if (typeHandle == IntPtr.Zero) { throw new TypeLoadException(SR.Format(SR.TypeLoad_ResolveType, escapedTypeName), typeName: escapedTypeName); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs index 9ebcb53ba218e6..8a84de892363f9 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs @@ -320,11 +320,12 @@ internal static void ReturnTaskContinuation(RuntimeAsyncTaskContinuation continu } #if !NATIVEAOT + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AsyncHelpers_AddContinuationToExInternal")] - private static unsafe partial void AddContinuationToExInternal(void* diagnosticIP, ObjectHandleOnStack ex, out QCallExceptionStatus qcallException); + private static unsafe partial void AddContinuationToExInternal(void* diagnosticIP, ObjectHandleOnStack ex); internal static unsafe void AddContinuationToExInternal(void* diagnosticIP, Exception e) - => AddContinuationToExInternal(diagnosticIP, ObjectHandleOnStack.Create(ref e), out _); + => AddContinuationToExInternal(diagnosticIP, ObjectHandleOnStack.Create(ref e)); #endif private static unsafe Continuation AllocContinuation(Continuation prevContinuation, MethodTable* contMT) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastHelpers.cs index aa2ff46d32c59a..e75c682b500c9f 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastHelpers.cs @@ -14,32 +14,34 @@ internal static unsafe partial class CastHelpers // In coreclr the table is allocated and written to on the native side. internal static int[]? s_table; + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThrowInvalidCastException")] - private static partial void ThrowInvalidCastExceptionInternal(void* fromTypeHnd, void* toTypeHnd, out QCallExceptionStatus qcallException); + private static partial void ThrowInvalidCastExceptionInternal(void* fromTypeHnd, void* toTypeHnd); [DoesNotReturn] internal static void ThrowInvalidCastException(void* fromTypeHnd, void* toTypeHnd) { - ThrowInvalidCastExceptionInternal(fromTypeHnd, toTypeHnd, out _); + ThrowInvalidCastExceptionInternal(fromTypeHnd, toTypeHnd); throw null!; // Provide hint to the inliner that this method does not return } [DoesNotReturn] internal static void ThrowInvalidCastException(object fromType, void* toTypeHnd) { - ThrowInvalidCastExceptionInternal(RuntimeHelpers.GetMethodTable(fromType), toTypeHnd, out _); + ThrowInvalidCastExceptionInternal(RuntimeHelpers.GetMethodTable(fromType), toTypeHnd); GC.KeepAlive(fromType); throw null!; // Provide hint to the inliner that this method does not return } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall)] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool IsInstanceOf_NoCacheLookup(void *toTypeHnd, [MarshalAs(UnmanagedType.Bool)] bool throwCastException, ObjectHandleOnStack obj, out QCallExceptionStatus qcallException); + private static partial bool IsInstanceOf_NoCacheLookup(void *toTypeHnd, [MarshalAs(UnmanagedType.Bool)] bool throwCastException, ObjectHandleOnStack obj); [MethodImpl(MethodImplOptions.NoInlining)] private static object? IsInstanceOfAny_NoCacheLookup(void* toTypeHnd, object obj) { - if (IsInstanceOf_NoCacheLookup(toTypeHnd, false, ObjectHandleOnStack.Create(ref obj), out _)) + if (IsInstanceOf_NoCacheLookup(toTypeHnd, false, ObjectHandleOnStack.Create(ref obj))) { return obj; } @@ -49,7 +51,7 @@ internal static void ThrowInvalidCastException(object fromType, void* toTypeHnd) [MethodImpl(MethodImplOptions.NoInlining)] private static object ChkCastAny_NoCacheLookup(void* toTypeHnd, object obj) { - IsInstanceOf_NoCacheLookup(toTypeHnd, true, ObjectHandleOnStack.Create(ref obj), out _); + IsInstanceOf_NoCacheLookup(toTypeHnd, true, ObjectHandleOnStack.Create(ref obj)); return obj; } @@ -577,7 +579,7 @@ private static bool AreTypesEquivalent(MethodTable* pMTa, MethodTable* pMTb) return false; } - return RuntimeHelpers.AreTypesEquivalent(pMTa, pMTb, out _); + return RuntimeHelpers.AreTypesEquivalent(pMTa, pMTb); } #endif // FEATURE_TYPEEQUIVALENCE diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/GenericsHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/GenericsHelpers.cs index f9a5b332da833d..f4a4b9e5965bcf 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/GenericsHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/GenericsHelpers.cs @@ -12,8 +12,9 @@ namespace System.Runtime.CompilerServices; [DebuggerStepThrough] internal static unsafe partial class GenericsHelpers { + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall)] - private static partial IntPtr GenericHandleWorker(IntPtr pMD, IntPtr pMT, IntPtr signature, uint dictionaryIndexAndSlot, IntPtr pModule, out QCallExceptionStatus qcallException); + private static partial IntPtr GenericHandleWorker(IntPtr pMD, IntPtr pMT, IntPtr signature, uint dictionaryIndexAndSlot, IntPtr pModule); public struct GenericHandleArgs { @@ -25,24 +26,24 @@ public struct GenericHandleArgs [DebuggerHidden] public static IntPtr Method(IntPtr methodHnd, IntPtr signature) { - return GenericHandleWorker(methodHnd, IntPtr.Zero, signature, 0xFFFFFFFF, IntPtr.Zero, out _); + return GenericHandleWorker(methodHnd, IntPtr.Zero, signature, 0xFFFFFFFF, IntPtr.Zero); } [DebuggerHidden] public static IntPtr MethodWithSlotAndModule(IntPtr methodHnd, GenericHandleArgs * pArgs) { - return GenericHandleWorker(methodHnd, IntPtr.Zero, pArgs->signature, pArgs->dictionaryIndexAndSlot, pArgs->module, out _); + return GenericHandleWorker(methodHnd, IntPtr.Zero, pArgs->signature, pArgs->dictionaryIndexAndSlot, pArgs->module); } [DebuggerHidden] public static IntPtr Class(IntPtr classHnd, IntPtr signature) { - return GenericHandleWorker(IntPtr.Zero, classHnd, signature, 0xFFFFFFFF, IntPtr.Zero, out _); + return GenericHandleWorker(IntPtr.Zero, classHnd, signature, 0xFFFFFFFF, IntPtr.Zero); } [DebuggerHidden] public static IntPtr ClassWithSlotAndModule(IntPtr classHnd, GenericHandleArgs * pArgs) { - return GenericHandleWorker(IntPtr.Zero, classHnd, pArgs->signature, pArgs->dictionaryIndexAndSlot, pArgs->module, out _); + return GenericHandleWorker(IntPtr.Zero, classHnd, pArgs->signature, pArgs->dictionaryIndexAndSlot, pArgs->module); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/InitHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/InitHelpers.cs index 05c1f0cdfd7210..cdea275bb4855d 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/InitHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/InitHelpers.cs @@ -11,14 +11,15 @@ namespace System.Runtime.CompilerServices [DebuggerStepThrough] internal static unsafe partial class InitHelpers { + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall)] - private static partial void InitClassHelper(MethodTable* mt, out QCallExceptionStatus qcallException); + private static partial void InitClassHelper(MethodTable* mt); [DebuggerHidden] [MethodImpl(MethodImplOptions.NoInlining)] internal static void InitClassSlow(MethodTable* mt) { - InitClassHelper(mt, out _); + InitClassHelper(mt); } [DebuggerHidden] diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallExceptionStatus.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallExceptionStatus.cs index 87ce08f6d9e9d5..e3357a71ab26e9 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallExceptionStatus.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallExceptionStatus.cs @@ -1,40 +1,57 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System.Diagnostics; using System.Runtime.ExceptionServices; +using System.Runtime.InteropServices; using System.Runtime.InteropServices.Marshalling; using System.Threading; namespace System.Runtime.CompilerServices { [NativeMarshalling(typeof(QCallExceptionStatusMarshaller))] + [StructLayout(LayoutKind.Sequential)] internal readonly struct QCallExceptionStatus { + private readonly nint _value; } - [CustomMarshaller(typeof(QCallExceptionStatus), MarshalMode.ManagedToUnmanagedOut, typeof(QCallExceptionStatusMarshaller))] - internal struct QCallExceptionStatusMarshaller + [CustomMarshaller(typeof(QCallExceptionStatus), MarshalMode.Default, typeof(QCallExceptionStatusMarshaller))] + internal static class QCallExceptionStatusMarshaller { [MethodImpl(MethodImplOptions.AggressiveInlining)] - public void FromUnmanaged(int exceptionPending) + public static nint ConvertToUnmanaged(QCallExceptionStatus _) => 0; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static QCallExceptionStatus ConvertToManaged(nint status) { - if (exceptionPending == 1) + if (status != 0) { - HandleException(); + HandleException(status); } - } - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public QCallExceptionStatus ToManaged() => default; - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public void Free() { } + return default; + } [MethodImpl(MethodImplOptions.NoInlining)] - private static void HandleException() + private static void HandleException(nint status) { - Exception exception = Thread.GetAndClearQCallException(); + Exception exception; + if ((nuint)status <= 2) + { + exception = Thread.GetQCallSpecialException(status); + } + else + { + GCHandle exceptionHandle = GCHandle.FromIntPtr(status); + try + { + exception = (Exception)exceptionHandle.Target!; + } + finally + { + exceptionHandle.Free(); + } + } // Throw during unmarshalling so QCall exception propagation remains as close as // possible to throwing directly from native code, as QCalls did previously. diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs index e03dda41a12694..0f2bffcf77076a 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs @@ -26,7 +26,7 @@ public static unsafe void InitializeArray(Array array, RuntimeFieldHandle fldHan IRuntimeFieldInfo fldInfo = fldHandle.GetRuntimeFieldInfo(); - if (!RuntimeFieldHandle.GetRVAFieldInfo(fldInfo.Value, out void* address, out uint size, out _)) + if (!RuntimeFieldHandle.GetRVAFieldInfo(fldInfo.Value, out void* address, out uint size)) throw new ArgumentException(SR.Argument_BadFieldForInitializeArray); // Note that we do not check that the field is actually in the PE file that is initializing @@ -96,7 +96,7 @@ private static unsafe ref byte GetSpanDataFrom( IRuntimeFieldInfo fldInfo = fldHandle.GetRuntimeFieldInfo(); - if (!RuntimeFieldHandle.GetRVAFieldInfo(fldInfo.Value, out void* data, out uint totalSize, out _)) + if (!RuntimeFieldHandle.GetRVAFieldInfo(fldInfo.Value, out void* data, out uint totalSize)) throw new ArgumentException(SR.Argument_BadFieldForInitializeArray); TypeHandle th = targetTypeHandle.GetRuntimeType().GetNativeTypeHandle(); @@ -163,8 +163,9 @@ private static unsafe ref byte GetSpanDataFrom( // This call will generate an exception if the specified class constructor threw an // exception when it ran. + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(QCall, EntryPoint = "ReflectionInvocation_RunClassConstructor")] - private static partial void RunClassConstructor(QCallTypeHandle type, out QCallExceptionStatus qcallException); + private static partial void RunClassConstructor(QCallTypeHandle type); [RequiresUnreferencedCode("Trimmer can't guarantee existence of class constructor")] public static void RunClassConstructor(RuntimeTypeHandle type) @@ -172,7 +173,7 @@ public static void RunClassConstructor(RuntimeTypeHandle type) RuntimeType rt = type.GetRuntimeType() ?? throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized, nameof(type)); - RunClassConstructor(new QCallTypeHandle(ref rt), out _); + RunClassConstructor(new QCallTypeHandle(ref rt)); } // RunModuleConstructor causes the module constructor for the given type to be triggered @@ -183,22 +184,25 @@ public static void RunClassConstructor(RuntimeTypeHandle type) // This call will generate an exception if the specified module constructor threw an // exception when it ran. + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(QCall, EntryPoint = "ReflectionInvocation_RunModuleConstructor")] - private static partial void RunModuleConstructor(QCallModule module, out QCallExceptionStatus qcallException); + private static partial void RunModuleConstructor(QCallModule module); public static void RunModuleConstructor(ModuleHandle module) { RuntimeModule rm = module.GetRuntimeModule() ?? throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized, nameof(module)); - RunModuleConstructor(new QCallModule(ref rm), out _); + RunModuleConstructor(new QCallModule(ref rm)); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(QCall, EntryPoint = "ReflectionInvocation_CompileMethod")] - internal static partial void CompileMethod(RuntimeMethodHandleInternal method, out QCallExceptionStatus qcallException); + internal static partial void CompileMethod(RuntimeMethodHandleInternal method); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(QCall, EntryPoint = "ReflectionInvocation_PrepareMethod")] - private static unsafe partial void PrepareMethod(RuntimeMethodHandleInternal method, IntPtr* pInstantiation, int cInstantiation, out QCallExceptionStatus qcallException); + private static unsafe partial void PrepareMethod(RuntimeMethodHandleInternal method, IntPtr* pInstantiation, int cInstantiation); public static void PrepareMethod(RuntimeMethodHandle method) => PrepareMethod(method, null); @@ -213,14 +217,15 @@ public static unsafe void PrepareMethod(RuntimeMethodHandle method, RuntimeTypeH ReadOnlySpan instantiationHandles = RuntimeTypeHandle.CopyRuntimeTypeHandles(instantiation, stackScratch: stackalloc IntPtr[8]); fixed (IntPtr* pInstantiation = instantiationHandles) { - PrepareMethod(IRuntimeMethodInfo.GetValue(methodInfo), pInstantiation, instantiationHandles.Length, out _); + PrepareMethod(IRuntimeMethodInfo.GetValue(methodInfo), pInstantiation, instantiationHandles.Length); GC.KeepAlive(instantiation); GC.KeepAlive(methodInfo); } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(QCall, EntryPoint = "ReflectionInvocation_PrepareDelegate")] - private static partial void PrepareDelegate(ObjectHandleOnStack d, out QCallExceptionStatus qcallException); + private static partial void PrepareDelegate(ObjectHandleOnStack d); public static void PrepareDelegate(Delegate d) { @@ -229,7 +234,7 @@ public static void PrepareDelegate(Delegate d) return; } - PrepareDelegate(ObjectHandleOnStack.Create(ref d), out _); + PrepareDelegate(ObjectHandleOnStack.Create(ref d)); } /// @@ -240,8 +245,9 @@ public static void PrepareDelegate(Delegate d) [MethodImpl(MethodImplOptions.InternalCall)] internal static extern safe int TryGetHashCode(object? o); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(QCall, EntryPoint = "ObjectNative_GetHashCodeSlow")] - private static partial int GetHashCodeSlow(ObjectHandleOnStack o, out QCallExceptionStatus qcallException); + private static partial int GetHashCodeSlow(ObjectHandleOnStack o); public static int GetHashCode(object? o) { @@ -259,7 +265,7 @@ static int GetHashCodeWorker(object? o) { return 0; } - return GetHashCodeSlow(ObjectHandleOnStack.Create(ref o), out _); + return GetHashCodeSlow(ObjectHandleOnStack.Create(ref o)); } } @@ -349,8 +355,9 @@ public static object GetUninitializedObject( return rt.GetUninitializedObject(); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(QCall, EntryPoint = "ObjectNative_AllocateUninitializedClone")] - internal static partial void AllocateUninitializedClone(ObjectHandleOnStack objHandle, out QCallExceptionStatus qcallException); + internal static partial void AllocateUninitializedClone(ObjectHandleOnStack objHandle); /// true if given type is bitwise equatable (memcmp can be used for equality checking) /// @@ -482,9 +489,10 @@ internal static unsafe bool ObjectHasFinalizer(object obj) [Intrinsic] internal static unsafe MethodTable* GetMethodTable(object obj) => GetMethodTable(obj); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(QCall, EntryPoint = "MethodTable_AreTypesEquivalent")] [return: MarshalAs(UnmanagedType.Bool)] - internal static unsafe partial bool AreTypesEquivalent(MethodTable* pMTa, MethodTable* pMTb, out QCallExceptionStatus qcallException); + internal static unsafe partial bool AreTypesEquivalent(MethodTable* pMTa, MethodTable* pMTb); /// Allocates memory that's associated with the and is freed if and when the is unloaded. /// The type associated with the allocated memory. @@ -501,7 +509,7 @@ public static IntPtr AllocateTypeAssociatedMemory(Type type, int size) ArgumentOutOfRangeException.ThrowIfNegative(size); - return AllocateTypeAssociatedMemory(new QCallTypeHandle(ref rt), (uint)size, out _); + return AllocateTypeAssociatedMemory(new QCallTypeHandle(ref rt), (uint)size); } /// Allocates aligned memory that's associated with the and is freed if and when the is unloaded. @@ -527,20 +535,23 @@ public static IntPtr AllocateTypeAssociatedMemory(Type type, int size, int align ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_AlignmentMustBePow2); } - return AllocateTypeAssociatedMemoryAligned(new QCallTypeHandle(ref rt), (uint)size, (uint)alignment, out _); + return AllocateTypeAssociatedMemoryAligned(new QCallTypeHandle(ref rt), (uint)size, (uint)alignment); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(QCall, EntryPoint = "RuntimeTypeHandle_AllocateTypeAssociatedMemory")] - private static partial IntPtr AllocateTypeAssociatedMemory(QCallTypeHandle type, uint size, out QCallExceptionStatus qcallException); + private static partial IntPtr AllocateTypeAssociatedMemory(QCallTypeHandle type, uint size); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(QCall, EntryPoint = "RuntimeTypeHandle_AllocateTypeAssociatedMemoryAligned")] - private static partial IntPtr AllocateTypeAssociatedMemoryAligned(QCallTypeHandle type, uint size, uint alignment, out QCallExceptionStatus qcallException); + private static partial IntPtr AllocateTypeAssociatedMemoryAligned(QCallTypeHandle type, uint size, uint alignment); [MethodImpl(MethodImplOptions.InternalCall)] private static extern unsafe TailCallArgBuffer* GetTailCallArgBuffer(); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(QCall, EntryPoint = "TailCallHelp_AllocTailCallArgBufferInternal")] - private static unsafe partial TailCallArgBuffer* AllocTailCallArgBufferInternal(int size, out QCallExceptionStatus qcallException); + private static unsafe partial TailCallArgBuffer* AllocTailCallArgBufferInternal(int size); private const int TAILCALLARGBUFFER_ACTIVE = 0; // private const int TAILCALLARGBUFFER_INSTARG_ONLY = 1; @@ -559,7 +570,7 @@ public static IntPtr AllocateTypeAssociatedMemory(Type type, int size, int align buffer = AllocTailCallArgBufferWorker(size); [MethodImpl(MethodImplOptions.NoInlining)] - static TailCallArgBuffer* AllocTailCallArgBufferWorker(int size) => AllocTailCallArgBufferInternal(size, out _); + static TailCallArgBuffer* AllocTailCallArgBufferWorker(int size) => AllocTailCallArgBufferInternal(size); } Debug.Assert(buffer != null); Debug.Assert(buffer->Size >= size); @@ -1326,11 +1337,12 @@ private static bool CanCastToWorker(TypeHandle srcTH, TypeHandle destTH, bool nu return nullableCast; } - return CanCastTo_NoCacheLookup(srcTH.m_asTAddr, destTH.m_asTAddr, out _) != Interop.BOOL.FALSE; + return CanCastTo_NoCacheLookup(srcTH.m_asTAddr, destTH.m_asTAddr) != Interop.BOOL.FALSE; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeHandle_CanCastTo_NoCacheLookup")] - private static partial Interop.BOOL CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd, out QCallExceptionStatus qcallException); + private static partial Interop.BOOL CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd); [SuppressGCTransition] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeHandle_GetCorElementType")] diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/StaticsHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/StaticsHelpers.cs index d5d9d31de32485..7b6debe52cc9b7 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/StaticsHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/StaticsHelpers.cs @@ -11,11 +11,13 @@ namespace System.Runtime.CompilerServices [DebuggerStepThrough] internal static unsafe partial class StaticsHelpers { + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall)] - private static partial void GetThreadStaticsByIndex(ByteRefOnStack result, int index, [MarshalAs(UnmanagedType.Bool)] bool gcStatics, out QCallExceptionStatus qcallException); + private static partial void GetThreadStaticsByIndex(ByteRefOnStack result, int index, [MarshalAs(UnmanagedType.Bool)] bool gcStatics); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall)] - private static partial void GetThreadStaticsByMethodTable(ByteRefOnStack result, MethodTable* pMT, [MarshalAs(UnmanagedType.Bool)] bool gcStatics, out QCallExceptionStatus qcallException); + private static partial void GetThreadStaticsByMethodTable(ByteRefOnStack result, MethodTable* pMT, [MarshalAs(UnmanagedType.Bool)] bool gcStatics); [Intrinsic] private static ref byte VolatileReadAsByref(ref IntPtr address) => ref VolatileReadAsByref(ref address); @@ -140,7 +142,7 @@ private static bool IsIndexAllocated(int index) private static ref byte GetNonGCThreadStaticsByIndexSlow(int index) { ByteRef result = default; - GetThreadStaticsByIndex(ByteRefOnStack.Create(ref result), index, false, out _); + GetThreadStaticsByIndex(ByteRefOnStack.Create(ref result), index, false); return ref result.Value; } @@ -149,7 +151,7 @@ private static ref byte GetNonGCThreadStaticsByIndexSlow(int index) private static ref byte GetGCThreadStaticsByIndexSlow(int index) { ByteRef result = default; - GetThreadStaticsByIndex(ByteRefOnStack.Create(ref result), index, true, out _); + GetThreadStaticsByIndex(ByteRefOnStack.Create(ref result), index, true); return ref result.Value; } @@ -158,7 +160,7 @@ private static ref byte GetGCThreadStaticsByIndexSlow(int index) private static ref byte GetNonGCThreadStaticBaseSlow(MethodTable* mt) { ByteRef result = default; - GetThreadStaticsByMethodTable(ByteRefOnStack.Create(ref result), mt, false, out _); + GetThreadStaticsByMethodTable(ByteRefOnStack.Create(ref result), mt, false); return ref result.Value; } @@ -167,7 +169,7 @@ private static ref byte GetNonGCThreadStaticBaseSlow(MethodTable* mt) private static ref byte GetGCThreadStaticBaseSlow(MethodTable* mt) { ByteRef result = default; - GetThreadStaticsByMethodTable(ByteRefOnStack.Create(ref result), mt, true, out _); + GetThreadStaticsByMethodTable(ByteRefOnStack.Create(ref result), mt, true); return ref result.Value; } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/VirtualDispatchHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/VirtualDispatchHelpers.cs index b0ecc2c2816fae..19b4212830545e 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/VirtualDispatchHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/VirtualDispatchHelpers.cs @@ -58,14 +58,15 @@ private struct VirtualFunctionPointerArgs private static GenericCache s_virtualFunctionPointerCache = new GenericCache(InitialCacheSize, MaximumCacheSize); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall)] - private static unsafe partial IntPtr ResolveVirtualFunctionPointer(ObjectHandleOnStack obj, IntPtr classHandle, IntPtr methodHandle, out QCallExceptionStatus qcallException); + private static unsafe partial IntPtr ResolveVirtualFunctionPointer(ObjectHandleOnStack obj, IntPtr classHandle, IntPtr methodHandle); [MethodImpl(MethodImplOptions.NoInlining)] [DebuggerHidden] private static IntPtr VirtualFunctionPointerSlow(object obj, IntPtr classHandle, IntPtr methodHandle) { - IntPtr result = ResolveVirtualFunctionPointer(ObjectHandleOnStack.Create(ref obj), classHandle, methodHandle, out _); + IntPtr result = ResolveVirtualFunctionPointer(ObjectHandleOnStack.Create(ref obj), classHandle, methodHandle); s_virtualFunctionPointerCache.TrySet(new VirtualResolutionData(RuntimeHelpers.GetMethodTable(obj), classHandle, methodHandle), result); GC.KeepAlive(obj); return result; diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/ControlledExecution.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/ControlledExecution.CoreCLR.cs index 092bf1eb701687..59368cf338bf97 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/ControlledExecution.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/ControlledExecution.CoreCLR.cs @@ -118,8 +118,9 @@ public static void Run(Action action, CancellationToken cancellationToken) } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_Abort")] - private static partial void AbortThread(ThreadHandle thread, out QCallExceptionStatus qcallException); + private static partial void AbortThread(ThreadHandle thread); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_ResetAbort")] [SuppressGCTransition] @@ -142,7 +143,7 @@ public void Cancel() try { // Abort the thread executing the action (which may be the current thread). - AbortThread(_thread.GetNativeHandle(), out _); + AbortThread(_thread.GetNativeHandle()); } finally { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/DependentHandle.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/DependentHandle.cs index a5f955fb64c8f9..0bb61f692e8c83 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/DependentHandle.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/DependentHandle.cs @@ -241,10 +241,11 @@ public void Dispose() [MethodImpl(MethodImplOptions.NoInlining)] private static IntPtr InternalAllocWithGCTransition(object? target, object? dependent) - => _InternalAllocWithGCTransition(ObjectHandleOnStack.Create(ref target), ObjectHandleOnStack.Create(ref dependent), out _); + => _InternalAllocWithGCTransition(ObjectHandleOnStack.Create(ref target), ObjectHandleOnStack.Create(ref dependent)); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DependentHandle_InternalAllocWithGCTransition")] - private static partial IntPtr _InternalAllocWithGCTransition(ObjectHandleOnStack target, ObjectHandleOnStack dependent, out QCallExceptionStatus qcallException); + private static partial IntPtr _InternalAllocWithGCTransition(ObjectHandleOnStack target, ObjectHandleOnStack dependent); #if DEBUG [MethodImpl(MethodImplOptions.InternalCall)] @@ -273,9 +274,10 @@ private static IntPtr InternalAllocWithGCTransition(object? target, object? depe [MethodImpl(MethodImplOptions.NoInlining)] private static void InternalFreeWithGCTransition(IntPtr dependentHandle) - => _InternalFreeWithGCTransition(dependentHandle, out _); + => _InternalFreeWithGCTransition(dependentHandle); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DependentHandle_InternalFreeWithGCTransition")] - private static partial void _InternalFreeWithGCTransition(IntPtr dependentHandle, out QCallExceptionStatus qcallException); + private static partial void _InternalFreeWithGCTransition(IntPtr dependentHandle); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/ExceptionServices/InternalCalls.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/ExceptionServices/InternalCalls.cs index a1d166c3aafc41..95a6088aa49c8f 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/ExceptionServices/InternalCalls.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/ExceptionServices/InternalCalls.cs @@ -16,28 +16,31 @@ internal static partial class InternalCalls { [StackTraceHidden] [DebuggerHidden] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "SfiInit")] [return: MarshalAs(UnmanagedType.U1)] - internal static unsafe partial bool RhpSfiInit(ref StackFrameIterator pThis, void* pStackwalkCtx, [MarshalAs(UnmanagedType.U1)] bool instructionFault, bool* fIsExceptionIntercepted, out QCallExceptionStatus qcallException); + internal static unsafe partial bool RhpSfiInit(ref StackFrameIterator pThis, void* pStackwalkCtx, [MarshalAs(UnmanagedType.U1)] bool instructionFault, bool* fIsExceptionIntercepted); [StackTraceHidden] [DebuggerHidden] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "SfiNext")] [return: MarshalAs(UnmanagedType.U1)] - internal static unsafe partial bool RhpSfiNext(ref StackFrameIterator pThis, uint* uExCollideClauseIdx, bool* fUnwoundReversePInvoke, bool* fIsExceptionIntercepted, out QCallExceptionStatus qcallException); + internal static unsafe partial bool RhpSfiNext(ref StackFrameIterator pThis, uint* uExCollideClauseIdx, bool* fUnwoundReversePInvoke, bool* fIsExceptionIntercepted); [StackTraceHidden] [DebuggerHidden] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "CallFilterFunclet")] [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool RhpCallFilterFunclet( - ObjectHandleOnStack exceptionObj, byte* pFilterIP, void* pvRegDisplay, - out QCallExceptionStatus qcallException); + ObjectHandleOnStack exceptionObj, byte* pFilterIP, void* pvRegDisplay); [StackTraceHidden] [DebuggerHidden] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AppendExceptionStackFrame")] - internal static unsafe partial void RhpAppendExceptionStackFrame(ObjectHandleOnStack exceptionObj, IntPtr ip, UIntPtr sp, int flags, EH.ExInfo* exInfo, out QCallExceptionStatus qcallException); + internal static unsafe partial void RhpAppendExceptionStackFrame(ObjectHandleOnStack exceptionObj, IntPtr ip, UIntPtr sp, int flags, EH.ExInfo* exInfo); [StackTraceHidden] [DebuggerHidden] @@ -48,8 +51,9 @@ internal static unsafe partial bool RhpCallFilterFunclet( [StackTraceHidden] [DebuggerHidden] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EHEnumNext")] [return: MarshalAs(UnmanagedType.U1)] - internal static unsafe partial bool RhpEHEnumNext(void* pEHEnum, void* pEHClause, out QCallExceptionStatus qcallException); + internal static unsafe partial bool RhpEHEnumNext(void* pEHEnum, void* pEHClause); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.CoreCLR.cs index 0d6efe6dda1d66..710687ab3b6378 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.CoreCLR.cs @@ -162,16 +162,18 @@ private static IntPtr GetTaggedImplCurrentVersion() internal sealed partial class ManagedObjectWrapperHolder { + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ComWrappers_RegisterIsRootedCallback")] - private static partial void RegisterIsRootedCallback(out QCallExceptionStatus qcallException); + private static partial void RegisterIsRootedCallback(); private static IntPtr AllocateRefCountedHandle(ManagedObjectWrapperHolder holder) { - return AllocateRefCountedHandle(ObjectHandleOnStack.Create(ref holder), out _); + return AllocateRefCountedHandle(ObjectHandleOnStack.Create(ref holder)); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ComWrappers_AllocateRefCountedHandle")] - private static partial IntPtr AllocateRefCountedHandle(ObjectHandleOnStack obj, out QCallExceptionStatus qcallException); + private static partial IntPtr AllocateRefCountedHandle(ObjectHandleOnStack obj); } } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/GCHandle.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/GCHandle.CoreCLR.cs index 8fb3b7dab91de2..b8067a4fa7a932 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/GCHandle.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/GCHandle.CoreCLR.cs @@ -20,10 +20,11 @@ internal static IntPtr InternalAlloc(object? value, GCHandleType type) [MethodImpl(MethodImplOptions.NoInlining)] private static IntPtr InternalAllocWithGCTransition(object? value, GCHandleType type) - => _InternalAllocWithGCTransition(ObjectHandleOnStack.Create(ref value), type, out _); + => _InternalAllocWithGCTransition(ObjectHandleOnStack.Create(ref value), type); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCHandle_InternalAllocWithGCTransition")] - private static partial IntPtr _InternalAllocWithGCTransition(ObjectHandleOnStack value, GCHandleType type, out QCallExceptionStatus qcallException); + private static partial IntPtr _InternalAllocWithGCTransition(ObjectHandleOnStack value, GCHandleType type); internal static void InternalFree(IntPtr handle) { @@ -36,10 +37,11 @@ internal static void InternalFree(IntPtr handle) [MethodImpl(MethodImplOptions.NoInlining)] private static void InternalFreeWithGCTransition(IntPtr dependentHandle) - => _InternalFreeWithGCTransition(dependentHandle, out _); + => _InternalFreeWithGCTransition(dependentHandle); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCHandle_InternalFreeWithGCTransition")] - private static partial void _InternalFreeWithGCTransition(IntPtr dependentHandle, out QCallExceptionStatus qcallException); + private static partial void _InternalFreeWithGCTransition(IntPtr dependentHandle); #if FEATURE_JAVAMARSHAL internal static object? InternalGetBridgeWait(IntPtr handle) @@ -49,7 +51,7 @@ private static void InternalFreeWithGCTransition(IntPtr dependentHandle) if (GCHandle.InternalTryGetBridgeWait(handle, ref target)) return target; - InternalGetBridgeWait(handle, ObjectHandleOnStack.Create(ref target), out _); + InternalGetBridgeWait(handle, ObjectHandleOnStack.Create(ref target)); return target; } @@ -57,8 +59,9 @@ private static void InternalFreeWithGCTransition(IntPtr dependentHandle) [MethodImpl(MethodImplOptions.InternalCall)] private static extern bool InternalTryGetBridgeWait(IntPtr handle, ref object? result); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCHandle_InternalGetBridgeWait")] - private static partial void InternalGetBridgeWait(IntPtr handle, ObjectHandleOnStack result, out QCallExceptionStatus qcallException); + private static partial void InternalGetBridgeWait(IntPtr handle, ObjectHandleOnStack result); #endif #if DEBUG diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Java/JavaMarshal.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Java/JavaMarshal.CoreCLR.cs index 83f36ac71313d0..785b39e89a07e5 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Java/JavaMarshal.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Java/JavaMarshal.CoreCLR.cs @@ -42,7 +42,7 @@ public static unsafe void Initialize(delegate* unmanaged SizeOfHelper(new QCallTypeHandle(ref t), throwIfNotMarshalable, out _); + => SizeOfHelper(new QCallTypeHandle(ref t), throwIfNotMarshalable); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_SizeOfHelper")] - private static partial int SizeOfHelper(QCallTypeHandle t, [MarshalAs(UnmanagedType.Bool)] bool throwIfNotMarshalable, out QCallExceptionStatus qcallException); + private static partial int SizeOfHelper(QCallTypeHandle t, [MarshalAs(UnmanagedType.Bool)] bool throwIfNotMarshalable); [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern", Justification = "Trimming doesn't affect types eligible for marshalling. Different exception for invalid inputs doesn't matter.")] @@ -50,13 +51,14 @@ public static IntPtr OffsetOf(Type t, string fieldName) throw new ArgumentException(SR.Argument_MustBeRuntimeFieldInfo, nameof(fieldName)); } - nint offset = OffsetOf(rtField.GetFieldDesc(), out _); + nint offset = OffsetOf(rtField.GetFieldDesc()); GC.KeepAlive(rtField); return offset; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_OffsetOf")] - private static partial nint OffsetOf(IntPtr pFD, out QCallExceptionStatus qcallException); + private static partial nint OffsetOf(IntPtr pFD); [EditorBrowsable(EditorBrowsableState.Never)] [Obsolete("ReadByte(Object, Int32) may be unavailable in future releases.")] @@ -219,12 +221,13 @@ private static void PrelinkCore(MethodInfo m) throw new ArgumentException(SR.Argument_MustBeRuntimeMethodInfo, nameof(m)); } - InternalPrelink(IRuntimeMethodInfo.GetValue(rmi), out _); + InternalPrelink(IRuntimeMethodInfo.GetValue(rmi)); GC.KeepAlive(rmi); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_Prelink")] - private static partial void InternalPrelink(RuntimeMethodHandleInternal m, out QCallExceptionStatus qcallException); + private static partial void InternalPrelink(RuntimeMethodHandleInternal m); [MethodImpl(MethodImplOptions.InternalCall)] public static extern /* struct _EXCEPTION_POINTERS* */ IntPtr GetExceptionPointers(); @@ -287,7 +290,7 @@ internal static LayoutTypeMarshalerMethods GetMarshalMethodsForType(RuntimeType [RequiresDynamicCode("Marshalling code for the object might not be available.")] public static LayoutTypeMarshalerMethods Create(RuntimeType type) { - if (!HasLayout(new QCallTypeHandle(ref type), out bool isBlittable, out _, out _)) + if (!HasLayout(new QCallTypeHandle(ref type), out bool isBlittable, out _)) throw new ArgumentException(SR.Argument_MustHaveLayoutOrBeBlittable, nameof(type)); Type instantiatedMarshaler = typeof(BoxedLayoutTypeMarshaler<>).MakeGenericType([type]); @@ -305,9 +308,10 @@ public void InitializeCompositeCache(RuntimeType.CompositeCacheEntry compositeEn } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_HasLayout")] [return: MarshalAs(UnmanagedType.Bool)] - internal static partial bool HasLayout(QCallTypeHandle t, [MarshalAs(UnmanagedType.Bool)] out bool isBlittable, out int nativeSize, out QCallExceptionStatus qcallException); + internal static partial bool HasLayout(QCallTypeHandle t, [MarshalAs(UnmanagedType.Bool)] out bool isBlittable, out int nativeSize); /// /// Marshals data from a structure class to a native memory block. If the @@ -405,11 +409,12 @@ internal static unsafe bool IsPinnable(object? obj) #if TARGET_WINDOWS [FeatureSwitchDefinition("System.Runtime.InteropServices.BuiltInComInterop.IsSupported")] - internal static bool IsBuiltInComSupported { get; } = IsBuiltInComSupportedInternal(out _); + internal static bool IsBuiltInComSupported { get; } = IsBuiltInComSupportedInternal(); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_IsBuiltInComSupported")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool IsBuiltInComSupportedInternal(out QCallExceptionStatus qcallException); + private static partial bool IsBuiltInComSupportedInternal(); /// /// Returns the HInstance for this module. Returns -1 if the module doesn't have @@ -423,26 +428,28 @@ public static IntPtr GetHINSTANCE(Module m) if (m is RuntimeModule rtModule) { - return GetHINSTANCE(new QCallModule(ref rtModule), out _); + return GetHINSTANCE(new QCallModule(ref rtModule)); } return (IntPtr)(-1); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetHINSTANCE")] - private static partial IntPtr GetHINSTANCE(QCallModule m, out QCallExceptionStatus qcallException); + private static partial IntPtr GetHINSTANCE(QCallModule m); #endif // TARGET_WINDOWS internal static Exception GetExceptionForHRInternal(int errorCode, IntPtr errorInfo) { Exception? exception = null; - GetExceptionForHRInternal(errorCode, errorInfo, ObjectHandleOnStack.Create(ref exception), out _); + GetExceptionForHRInternal(errorCode, errorInfo, ObjectHandleOnStack.Create(ref exception)); return exception!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetExceptionForHR")] - private static partial void GetExceptionForHRInternal(int errorCode, IntPtr errorInfo, ObjectHandleOnStack exception, out QCallExceptionStatus qcallException); + private static partial void GetExceptionForHRInternal(int errorCode, IntPtr errorInfo, ObjectHandleOnStack exception); #if FEATURE_COMINTEROP /// @@ -450,10 +457,11 @@ internal static Exception GetExceptionForHRInternal(int errorCode, IntPtr errorI /// up an IErrorInfo for the exception. /// public static int GetHRForException(Exception? e) - => GetHRForException(ObjectHandleOnStack.Create(ref e), out _); + => GetHRForException(ObjectHandleOnStack.Create(ref e)); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetHRForException")] - private static partial int GetHRForException(ObjectHandleOnStack exception, out QCallExceptionStatus qcallException); + private static partial int GetHRForException(ObjectHandleOnStack exception); /// /// Given a managed object that wraps an ITypeInfo, return its name. @@ -481,13 +489,14 @@ public static string GetTypeInfoName(ITypeInfo typeInfo) // on the Activator.CreateInstance() call. GetTypeFromCLSID() merely wraps the data in a Type object without any validation. Type? type = null; - GetTypeFromCLSID(clsid, server, ObjectHandleOnStack.Create(ref type), out _); + GetTypeFromCLSID(clsid, server, ObjectHandleOnStack.Create(ref type)); return type; } #pragma warning restore IDE0060 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetTypeFromCLSID", StringMarshalling = StringMarshalling.Utf16)] - private static partial void GetTypeFromCLSID(in Guid clsid, string? server, ObjectHandleOnStack retType, out QCallExceptionStatus qcallException); + private static partial void GetTypeFromCLSID(in Guid clsid, string? server, ObjectHandleOnStack retType); /// /// Return the IUnknown* for an Object if the current context is the one @@ -498,11 +507,12 @@ public static string GetTypeInfoName(ITypeInfo typeInfo) { ArgumentNullException.ThrowIfNull(o); - return GetIUnknownForObject(ObjectHandleOnStack.Create(ref o), out _); + return GetIUnknownForObject(ObjectHandleOnStack.Create(ref o)); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetIUnknownForObject")] - private static partial IntPtr /* IUnknown* */ GetIUnknownForObject(ObjectHandleOnStack o, out QCallExceptionStatus qcallException); + private static partial IntPtr /* IUnknown* */ GetIUnknownForObject(ObjectHandleOnStack o); /// /// Return the IDispatch* for an Object. @@ -512,11 +522,12 @@ public static string GetTypeInfoName(ITypeInfo typeInfo) { ArgumentNullException.ThrowIfNull(o); - return GetIDispatchForObject(ObjectHandleOnStack.Create(ref o), out _); + return GetIDispatchForObject(ObjectHandleOnStack.Create(ref o)); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetIDispatchForObject")] - private static partial IntPtr /* IDispatch* */ GetIDispatchForObject(ObjectHandleOnStack o, out QCallExceptionStatus qcallException); + private static partial IntPtr /* IDispatch* */ GetIDispatchForObject(ObjectHandleOnStack o); /// /// Return the IUnknown* representing the interface for the Object. @@ -546,11 +557,12 @@ public static IntPtr GetComInterfaceForObject([DisallowNull] T o) if (T is not RuntimeType rt) throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(T)); - return GetComInterfaceForObject(ObjectHandleOnStack.Create(ref o), new QCallTypeHandle(ref rt), fEnableCustomizedQueryInterface: mode == CustomQueryInterfaceMode.Allow, out _); + return GetComInterfaceForObject(ObjectHandleOnStack.Create(ref o), new QCallTypeHandle(ref rt), fEnableCustomizedQueryInterface: mode == CustomQueryInterfaceMode.Allow); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetComInterfaceForObject")] - private static partial IntPtr /* IUnknown* */ GetComInterfaceForObject(ObjectHandleOnStack o, QCallTypeHandle t, [MarshalAs(UnmanagedType.Bool)] bool fEnableCustomizedQueryInterface, out QCallExceptionStatus qcallException); + private static partial IntPtr /* IUnknown* */ GetComInterfaceForObject(ObjectHandleOnStack o, QCallTypeHandle t, [MarshalAs(UnmanagedType.Bool)] bool fEnableCustomizedQueryInterface); /// /// Return the managed object representing the IUnknown* @@ -561,12 +573,13 @@ public static object GetObjectForIUnknown(IntPtr /* IUnknown* */ pUnk) ArgumentNullException.ThrowIfNull(pUnk); object? retObject = null; - GetObjectForIUnknown(pUnk, ObjectHandleOnStack.Create(ref retObject), out _); + GetObjectForIUnknown(pUnk, ObjectHandleOnStack.Create(ref retObject)); return retObject!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetObjectForIUnknown")] - private static partial void GetObjectForIUnknown(IntPtr /* IUnknown* */ pUnk, ObjectHandleOnStack retObject, out QCallExceptionStatus qcallException); + private static partial void GetObjectForIUnknown(IntPtr /* IUnknown* */ pUnk, ObjectHandleOnStack retObject); [SupportedOSPlatform("windows")] public static object GetUniqueObjectForIUnknown(IntPtr unknown) @@ -574,7 +587,7 @@ public static object GetUniqueObjectForIUnknown(IntPtr unknown) ArgumentNullException.ThrowIfNull(unknown); object? retObject = null; - GetUniqueObjectForIUnknown(unknown, ObjectHandleOnStack.Create(ref retObject), out _); + GetUniqueObjectForIUnknown(unknown, ObjectHandleOnStack.Create(ref retObject)); return retObject!; } @@ -584,8 +597,9 @@ public static object GetUniqueObjectForIUnknown(IntPtr unknown) /// existing object). This is useful in cases where you want to be able to call /// ReleaseComObject on a RCW and not worry about other active uses ofsaid RCW. /// + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetUniqueObjectForIUnknown")] - private static partial void GetUniqueObjectForIUnknown(IntPtr unknown, ObjectHandleOnStack retObject, out QCallExceptionStatus qcallException); + private static partial void GetUniqueObjectForIUnknown(IntPtr unknown, ObjectHandleOnStack retObject); /// /// Return an Object for IUnknown, using the Type T. @@ -601,12 +615,13 @@ public static object GetTypedObjectForIUnknown(IntPtr /* IUnknown* */ pUnk, Type throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(t)); object? retObject = null; - GetTypedObjectForIUnknown(pUnk, new QCallTypeHandle(ref rt), ObjectHandleOnStack.Create(ref retObject), out _); + GetTypedObjectForIUnknown(pUnk, new QCallTypeHandle(ref rt), ObjectHandleOnStack.Create(ref retObject)); return retObject!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetTypedObjectForIUnknown")] - private static partial void GetTypedObjectForIUnknown(IntPtr /* IUnknown* */ pUnk, QCallTypeHandle t, ObjectHandleOnStack retObject, out QCallExceptionStatus qcallException); + private static partial void GetTypedObjectForIUnknown(IntPtr /* IUnknown* */ pUnk, QCallTypeHandle t, ObjectHandleOnStack retObject); [SupportedOSPlatform("windows")] [EditorBrowsable(EditorBrowsableState.Never)] @@ -620,11 +635,12 @@ public static IntPtr CreateAggregatedObject(IntPtr pOuter, object o) ArgumentNullException.ThrowIfNull(pOuter); ArgumentNullException.ThrowIfNull(o); - return CreateAggregatedObject(pOuter, ObjectHandleOnStack.Create(ref o), out _); + return CreateAggregatedObject(pOuter, ObjectHandleOnStack.Create(ref o)); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_CreateAggregatedObject")] - private static partial IntPtr CreateAggregatedObject(IntPtr pOuter, ObjectHandleOnStack o, out QCallExceptionStatus qcallException); + private static partial IntPtr CreateAggregatedObject(IntPtr pOuter, ObjectHandleOnStack o); [SupportedOSPlatform("windows")] public static IntPtr CreateAggregatedObject(IntPtr pOuter, T o) where T : notnull @@ -638,10 +654,11 @@ public static IntPtr CreateAggregatedObject(IntPtr pOuter, T o) where T : not } public static void CleanupUnusedObjectsInCurrentContext() - => InternalCleanupUnusedObjectsInCurrentContext(out _); + => InternalCleanupUnusedObjectsInCurrentContext(); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_CleanupUnusedObjectsInCurrentContext")] - private static partial void InternalCleanupUnusedObjectsInCurrentContext(out QCallExceptionStatus qcallException); + private static partial void InternalCleanupUnusedObjectsInCurrentContext(); /// Returns a Boolean computed from runtime COM-cleanup state; it takes no arguments and dereferences no caller-supplied memory. [MethodImpl(MethodImplOptions.InternalCall)] @@ -679,11 +696,12 @@ public static int ReleaseComObject(object o) throw new ArgumentException(SR.Argument_ObjNotComObject, nameof(o)); } - return ReleaseComObject(ObjectHandleOnStack.Create(ref co), out _); + return ReleaseComObject(ObjectHandleOnStack.Create(ref co)); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_ReleaseComObject")] - private static partial int ReleaseComObject(ObjectHandleOnStack o, out QCallExceptionStatus qcallException); + private static partial int ReleaseComObject(ObjectHandleOnStack o); /// /// Release the COM component and zombie this object. @@ -703,12 +721,13 @@ public static int FinalReleaseComObject(object o) throw new ArgumentException(SR.Argument_ObjNotComObject, nameof(o)); } - FinalReleaseComObject(ObjectHandleOnStack.Create(ref co), out _); + FinalReleaseComObject(ObjectHandleOnStack.Create(ref co)); return 0; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_FinalReleaseComObject")] - private static partial void FinalReleaseComObject(ObjectHandleOnStack o, out QCallExceptionStatus qcallException); + private static partial void FinalReleaseComObject(ObjectHandleOnStack o); [SupportedOSPlatform("windows")] public static object? GetComObjectData(object obj, object key) @@ -829,12 +848,13 @@ private static object InternalCreateWrapperOfType(object o, Type t) throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(t)); object? retObject = null; - InternalCreateWrapperOfType(ObjectHandleOnStack.Create(ref o), new QCallTypeHandle(ref rt), ObjectHandleOnStack.Create(ref retObject), out _); + InternalCreateWrapperOfType(ObjectHandleOnStack.Create(ref o), new QCallTypeHandle(ref rt), ObjectHandleOnStack.Create(ref retObject)); return retObject!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_InternalCreateWrapperOfType")] - private static partial void InternalCreateWrapperOfType(ObjectHandleOnStack o, QCallTypeHandle rt, ObjectHandleOnStack retObject, out QCallExceptionStatus qcallException); + private static partial void InternalCreateWrapperOfType(ObjectHandleOnStack o, QCallTypeHandle rt, ObjectHandleOnStack retObject); /// /// check if the type is visible from COM. @@ -846,12 +866,13 @@ public static bool IsTypeVisibleFromCom(Type t) if (t is not RuntimeType rt) throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(t)); - return IsTypeVisibleFromCom(new QCallTypeHandle(ref rt), out _); + return IsTypeVisibleFromCom(new QCallTypeHandle(ref rt)); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_IsTypeVisibleFromCom")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool IsTypeVisibleFromCom(QCallTypeHandle rt, out QCallExceptionStatus qcallException); + private static partial bool IsTypeVisibleFromCom(QCallTypeHandle rt); [SupportedOSPlatform("windows")] [EditorBrowsable(EditorBrowsableState.Never)] @@ -864,11 +885,12 @@ public static void GetNativeVariantForObject(object? obj, /* VARIANT * */ IntPtr ArgumentNullException.ThrowIfNull(pDstNativeVariant); - GetNativeVariantForObject(ObjectHandleOnStack.Create(ref obj), pDstNativeVariant, out _); + GetNativeVariantForObject(ObjectHandleOnStack.Create(ref obj), pDstNativeVariant); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetNativeVariantForObject")] - private static partial void GetNativeVariantForObject(ObjectHandleOnStack obj, /* VARIANT * */ IntPtr pDstNativeVariant, out QCallExceptionStatus qcallException); + private static partial void GetNativeVariantForObject(ObjectHandleOnStack obj, /* VARIANT * */ IntPtr pDstNativeVariant); [SupportedOSPlatform("windows")] [EditorBrowsable(EditorBrowsableState.Never)] @@ -894,12 +916,13 @@ public static void GetNativeVariantForObject(T? obj, IntPtr pDstNativeVariant ArgumentNullException.ThrowIfNull(pSrcNativeVariant); object? retObject = null; - GetObjectForNativeVariant(pSrcNativeVariant, ObjectHandleOnStack.Create(ref retObject), out _); + GetObjectForNativeVariant(pSrcNativeVariant, ObjectHandleOnStack.Create(ref retObject)); return retObject; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetObjectForNativeVariant")] - private static partial void GetObjectForNativeVariant(/* VARIANT * */ IntPtr pSrcNativeVariant, ObjectHandleOnStack retObject, out QCallExceptionStatus qcallException); + private static partial void GetObjectForNativeVariant(/* VARIANT * */ IntPtr pSrcNativeVariant, ObjectHandleOnStack retObject); [SupportedOSPlatform("windows")] [EditorBrowsable(EditorBrowsableState.Never)] @@ -926,12 +949,13 @@ public static void GetNativeVariantForObject(T? obj, IntPtr pDstNativeVariant ArgumentOutOfRangeException.ThrowIfNegative(cVars); object?[]? retArray = null; - GetObjectsForNativeVariants(aSrcNativeVariant, cVars, ObjectHandleOnStack.Create(ref retArray), out _); + GetObjectsForNativeVariants(aSrcNativeVariant, cVars, ObjectHandleOnStack.Create(ref retArray)); return retArray!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetObjectsForNativeVariants")] - private static partial void GetObjectsForNativeVariants(/* VARIANT * */ IntPtr aSrcNativeVariant, int cVars, ObjectHandleOnStack retArray, out QCallExceptionStatus qcallException); + private static partial void GetObjectsForNativeVariants(/* VARIANT * */ IntPtr aSrcNativeVariant, int cVars, ObjectHandleOnStack retArray); [SupportedOSPlatform("windows")] [EditorBrowsable(EditorBrowsableState.Never)] @@ -962,11 +986,12 @@ public static int GetStartComSlot(Type t) if (t is not RuntimeType rt) throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(t)); - return GetStartComSlot(new QCallTypeHandle(ref rt), out _); + return GetStartComSlot(new QCallTypeHandle(ref rt)); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetStartComSlot")] - private static partial int GetStartComSlot(QCallTypeHandle rt, out QCallExceptionStatus qcallException); + private static partial int GetStartComSlot(QCallTypeHandle rt); /// /// Returns the last valid COM slot that GetMethodInfoForSlot will work on. @@ -979,11 +1004,12 @@ public static int GetEndComSlot(Type t) if (t is not RuntimeType rt) throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(t)); - return GetEndComSlot(new QCallTypeHandle(ref rt), out _); + return GetEndComSlot(new QCallTypeHandle(ref rt)); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetEndComSlot")] - private static partial int GetEndComSlot(QCallTypeHandle rt, out QCallExceptionStatus qcallException); + private static partial int GetEndComSlot(QCallTypeHandle rt); [RequiresUnreferencedCode("Built-in COM support is not trim compatible", Url = "https://aka.ms/dotnet-illink/com")] [SupportedOSPlatform("windows")] @@ -1035,30 +1061,33 @@ public static void ChangeWrapperHandleStrength(object otp, bool fIsWeak) { ArgumentNullException.ThrowIfNull(otp); - ChangeWrapperHandleStrength(ObjectHandleOnStack.Create(ref otp), fIsWeak, out _); + ChangeWrapperHandleStrength(ObjectHandleOnStack.Create(ref otp), fIsWeak); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_ChangeWrapperHandleStrength")] - private static partial void ChangeWrapperHandleStrength(ObjectHandleOnStack otp, [MarshalAs(UnmanagedType.Bool)] bool fIsWeak, out QCallExceptionStatus qcallException); + private static partial void ChangeWrapperHandleStrength(ObjectHandleOnStack otp, [MarshalAs(UnmanagedType.Bool)] bool fIsWeak); #endif // FEATURE_COMINTEROP internal static Delegate GetDelegateForFunctionPointerInternal(IntPtr ptr, RuntimeType t) { Delegate? retDelegate = null; - GetDelegateForFunctionPointerInternal(ptr, new QCallTypeHandle(ref t), ObjectHandleOnStack.Create(ref retDelegate), out _); + GetDelegateForFunctionPointerInternal(ptr, new QCallTypeHandle(ref t), ObjectHandleOnStack.Create(ref retDelegate)); return retDelegate!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetDelegateForFunctionPointerInternal")] - private static partial void GetDelegateForFunctionPointerInternal(IntPtr ptr, QCallTypeHandle t, ObjectHandleOnStack retDelegate, out QCallExceptionStatus qcallException); + private static partial void GetDelegateForFunctionPointerInternal(IntPtr ptr, QCallTypeHandle t, ObjectHandleOnStack retDelegate); internal static IntPtr GetFunctionPointerForDelegateInternal(Delegate d) { - return GetFunctionPointerForDelegateInternal(ObjectHandleOnStack.Create(ref d), out _); + return GetFunctionPointerForDelegateInternal(ObjectHandleOnStack.Create(ref d)); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetFunctionPointerForDelegateInternal")] - private static partial IntPtr GetFunctionPointerForDelegateInternal(ObjectHandleOnStack d, out QCallExceptionStatus qcallException); + private static partial IntPtr GetFunctionPointerForDelegateInternal(ObjectHandleOnStack d); #if DEBUG // Used for testing in Checked or Debug [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetIsInCooperativeGCModeFunctionPointer")] diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs index e0a5600a1faedf..7c51da1cc7dde0 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs @@ -16,17 +16,16 @@ internal static IntPtr LoadLibraryByName(string libraryName, Assembly assembly, new QCallAssembly(ref rtAsm), searchPath.HasValue, (uint)searchPath.GetValueOrDefault(), - throwOnError, - out _); + throwOnError); } /// External functions that implement the NativeLibrary interface + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeLibrary_LoadByName", StringMarshalling = StringMarshalling.Utf16)] internal static partial IntPtr LoadByName(string libraryName, QCallAssembly callingAssembly, [MarshalAs(UnmanagedType.Bool)] bool hasDllImportSearchPathFlag, uint dllImportSearchPathFlag, - [MarshalAs(UnmanagedType.Bool)] bool throwOnError, - out QCallExceptionStatus qcallException); + [MarshalAs(UnmanagedType.Bool)] bool throwOnError); [UnmanagedCallersOnly] private static unsafe IntPtr LoadLibraryCallbackStub(char* pLibraryName, Assembly* pAssembly, bool hasDllImportSearchPathFlags, uint dllImportSearchPathFlags, Exception* pException) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveCMarshal.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveCMarshal.CoreCLR.cs index 5d05cbde453c7d..dc4a7dce94cca0 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveCMarshal.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveCMarshal.CoreCLR.cs @@ -21,24 +21,21 @@ public static void SetMessageSendPendingException(Exception? exception) System.StubHelpers.StubHelpers.SetPendingExceptionObject(exception); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjCMarshal_TrySetGlobalMessageSendCallback")] [return: MarshalAs(UnmanagedType.Bool)] private static partial bool TrySetGlobalMessageSendCallback( MessageSendFunction msgSendFunction, - IntPtr func, - out QCallExceptionStatus qcallException); - - private static bool TrySetGlobalMessageSendCallback(MessageSendFunction msgSendFunction, IntPtr func) - => TrySetGlobalMessageSendCallback(msgSendFunction, func, out _); + IntPtr func); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjCMarshal_TryInitializeReferenceTracker")] [return: MarshalAs(UnmanagedType.Bool)] private static unsafe partial bool TryInitializeReferenceTracker( delegate* unmanaged beginEndCallback, delegate* unmanaged isReferencedCallback, delegate* unmanaged trackedObjectEnteredFinalization, - ObjectHandleOnStack objectTrackingInfoTable, - out QCallExceptionStatus qcallException); + ObjectHandleOnStack objectTrackingInfoTable); private static unsafe bool TryInitializeReferenceTracker( delegate* unmanaged beginEndCallback, @@ -52,18 +49,18 @@ private static unsafe bool TryInitializeReferenceTracker( beginEndCallback, isReferencedCallback, trackedObjectEnteredFinalization, - ObjectHandleOnStack.Create(ref objects), - out _); + ObjectHandleOnStack.Create(ref objects)); Debug.Assert(object.ReferenceEquals(objects, s_objects)); return result; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjCMarshal_AllocateReferenceTrackingHandle")] - private static partial IntPtr AllocateReferenceTrackingHandle(ObjectHandleOnStack obj, out QCallExceptionStatus qcallException); + private static partial IntPtr AllocateReferenceTrackingHandle(ObjectHandleOnStack obj); private static IntPtr AllocateReferenceTrackingHandle(object obj) - => AllocateReferenceTrackingHandle(ObjectHandleOnStack.Create(ref obj), out _); + => AllocateReferenceTrackingHandle(ObjectHandleOnStack.Create(ref obj)); private static unsafe bool IsTrackedReferenceWithFinalizer(object obj) => RuntimeHelpers.GetMethodTable(obj)->IsTrackedReferenceWithFinalizer; diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/TrackerObjectManager.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/TrackerObjectManager.CoreCLR.cs index 5a10882a87c072..f7874d29e3160b 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/TrackerObjectManager.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/TrackerObjectManager.CoreCLR.cs @@ -36,10 +36,11 @@ private static void RegisterGCCallbacks() // CoreCLR doesn't have GC callbacks, but we do need to register the GC handle set with the runtime for enumeration // during GC. GCHandleSet handleSet = s_referenceTrackerNativeObjectWrapperCache; - RegisterNativeObjectWrapperCache(ObjectHandleOnStack.Create(ref handleSet), out _); + RegisterNativeObjectWrapperCache(ObjectHandleOnStack.Create(ref handleSet)); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TrackerObjectManager_RegisterNativeObjectWrapperCache")] - private static partial void RegisterNativeObjectWrapperCache(ObjectHandleOnStack nativeObjectWrapperCache, out QCallExceptionStatus qcallException); + private static partial void RegisterNativeObjectWrapperCache(ObjectHandleOnStack nativeObjectWrapperCache); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs index c29e6a9864995b..1f6b908dec25a2 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs @@ -11,68 +11,67 @@ namespace System.Runtime.Loader { public partial class AssemblyLoadContext { + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_InitializeAssemblyLoadContext")] - private static partial IntPtr InitializeAssemblyLoadContext(IntPtr ptrAssemblyLoadContext, [MarshalAs(UnmanagedType.Bool)] bool fRepresentsTPALoadContext, [MarshalAs(UnmanagedType.Bool)] bool isCollectible, out QCallExceptionStatus qcallException); + private static partial IntPtr InitializeAssemblyLoadContext(IntPtr ptrAssemblyLoadContext, [MarshalAs(UnmanagedType.Bool)] bool fRepresentsTPALoadContext, [MarshalAs(UnmanagedType.Bool)] bool isCollectible); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_PrepareForAssemblyLoadContextRelease")] - private static partial void PrepareForAssemblyLoadContextRelease(IntPtr ptrNativeAssemblyBinder, IntPtr ptrAssemblyLoadContextStrong, out QCallExceptionStatus qcallException); + private static partial void PrepareForAssemblyLoadContextRelease(IntPtr ptrNativeAssemblyBinder, IntPtr ptrAssemblyLoadContextStrong); [RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_LoadFromStream")] - private static partial void LoadFromStream(IntPtr ptrNativeAssemblyBinder, IntPtr ptrAssemblyArray, int iAssemblyArrayLen, IntPtr ptrSymbols, int iSymbolArrayLen, ObjectHandleOnStack retAssembly, out QCallExceptionStatus qcallException); + private static partial void LoadFromStream(IntPtr ptrNativeAssemblyBinder, IntPtr ptrAssemblyArray, int iAssemblyArrayLen, IntPtr ptrSymbols, int iSymbolArrayLen, ObjectHandleOnStack retAssembly); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MultiCoreJIT_InternalSetProfileRoot", StringMarshalling = StringMarshalling.Utf16)] - internal static partial void InternalSetProfileRoot(string directoryPath, out QCallExceptionStatus qcallException); + internal static partial void InternalSetProfileRoot(string directoryPath); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MultiCoreJIT_InternalStartProfile", StringMarshalling = StringMarshalling.Utf16)] - internal static partial void InternalStartProfile(string? profile, IntPtr ptrNativeAssemblyBinder, out QCallExceptionStatus qcallException); + internal static partial void InternalStartProfile(string? profile, IntPtr ptrNativeAssemblyBinder); [RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_LoadFromPath", StringMarshalling = StringMarshalling.Utf16)] - private static partial void LoadFromPath(IntPtr ptrNativeAssemblyBinder, string? ilPath, ObjectHandleOnStack retAssembly, out QCallExceptionStatus qcallException); + private static partial void LoadFromPath(IntPtr ptrNativeAssemblyBinder, string? ilPath, ObjectHandleOnStack retAssembly); internal static Assembly[] GetLoadedAssemblies() { Assembly[]? assemblies = null; - GetLoadedAssemblies(ObjectHandleOnStack.Create(ref assemblies), out _); + GetLoadedAssemblies(ObjectHandleOnStack.Create(ref assemblies)); return assemblies!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetLoadedAssemblies")] - private static partial void GetLoadedAssemblies(ObjectHandleOnStack retAssemblies, out QCallExceptionStatus qcallException); + private static partial void GetLoadedAssemblies(ObjectHandleOnStack retAssemblies); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern bool IsTracingEnabled(); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_TraceResolvingHandlerInvoked", StringMarshalling = StringMarshalling.Utf16)] - private static partial void TraceResolvingHandlerInvoked(string assemblyName, string handlerName, string? alcName, string? resultAssemblyName, string? resultAssemblyPath, out QCallExceptionStatus qcallException); - - internal static void TraceResolvingHandlerInvoked(string assemblyName, string handlerName, string? alcName, string? resultAssemblyName, string? resultAssemblyPath) - => TraceResolvingHandlerInvoked(assemblyName, handlerName, alcName, resultAssemblyName, resultAssemblyPath, out _); + internal static partial void TraceResolvingHandlerInvoked(string assemblyName, string handlerName, string? alcName, string? resultAssemblyName, string? resultAssemblyPath); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_TraceAssemblyResolveHandlerInvoked", StringMarshalling = StringMarshalling.Utf16)] - private static partial void TraceAssemblyResolveHandlerInvoked(string assemblyName, string handlerName, string? resultAssemblyName, string? resultAssemblyPath, out QCallExceptionStatus qcallException); - - internal static void TraceAssemblyResolveHandlerInvoked(string assemblyName, string handlerName, string? resultAssemblyName, string? resultAssemblyPath) - => TraceAssemblyResolveHandlerInvoked(assemblyName, handlerName, resultAssemblyName, resultAssemblyPath, out _); + internal static partial void TraceAssemblyResolveHandlerInvoked(string assemblyName, string handlerName, string? resultAssemblyName, string? resultAssemblyPath); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_TraceAssemblyLoadFromResolveHandlerInvoked", StringMarshalling = StringMarshalling.Utf16)] - private static partial void TraceAssemblyLoadFromResolveHandlerInvoked(string assemblyName, [MarshalAs(UnmanagedType.Bool)] bool isTrackedAssembly, string requestingAssemblyPath, string? requestedAssemblyPath, out QCallExceptionStatus qcallException); - - internal static void TraceAssemblyLoadFromResolveHandlerInvoked(string assemblyName, bool isTrackedAssembly, string requestingAssemblyPath, string? requestedAssemblyPath) - => TraceAssemblyLoadFromResolveHandlerInvoked(assemblyName, isTrackedAssembly, requestingAssemblyPath, requestedAssemblyPath, out _); + internal static partial void TraceAssemblyLoadFromResolveHandlerInvoked(string assemblyName, [MarshalAs(UnmanagedType.Bool)] bool isTrackedAssembly, string requestingAssemblyPath, string? requestedAssemblyPath); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_TraceSatelliteSubdirectoryPathProbed", StringMarshalling = StringMarshalling.Utf16)] - private static partial void TraceSatelliteSubdirectoryPathProbed(string filePath, int hResult, out QCallExceptionStatus qcallException); - - internal static void TraceSatelliteSubdirectoryPathProbed(string filePath, int hResult) - => TraceSatelliteSubdirectoryPathProbed(filePath, hResult, out _); + internal static partial void TraceSatelliteSubdirectoryPathProbed(string filePath, int hResult); [RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")] private RuntimeAssembly InternalLoadFromPath(string? assemblyPath) { RuntimeAssembly? loadedAssembly = null; - LoadFromPath(_nativeAssemblyLoadContext, assemblyPath, ObjectHandleOnStack.Create(ref loadedAssembly), out _); + LoadFromPath(_nativeAssemblyLoadContext, assemblyPath, ObjectHandleOnStack.Create(ref loadedAssembly)); return loadedAssembly!; } @@ -84,16 +83,16 @@ internal unsafe Assembly InternalLoad(ReadOnlySpan arrAssembly, ReadOnlySp fixed (byte* ptrAssembly = arrAssembly, ptrSymbols = arrSymbols) { LoadFromStream(_nativeAssemblyLoadContext, new IntPtr(ptrAssembly), arrAssembly.Length, - new IntPtr(ptrSymbols), arrSymbols.Length, ObjectHandleOnStack.Create(ref loadedAssembly), - out _); + new IntPtr(ptrSymbols), arrSymbols.Length, ObjectHandleOnStack.Create(ref loadedAssembly)); } return loadedAssembly!; } #if TARGET_WINDOWS + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_LoadFromInMemoryModule")] - private static partial IntPtr LoadFromInMemoryModuleInternal(IntPtr ptrNativeAssemblyBinder, IntPtr hModule, ObjectHandleOnStack retAssembly, out QCallExceptionStatus qcallException); + private static partial IntPtr LoadFromInMemoryModuleInternal(IntPtr ptrNativeAssemblyBinder, IntPtr hModule, ObjectHandleOnStack retAssembly); /// @@ -111,8 +110,7 @@ internal Assembly LoadFromInMemoryModule(IntPtr moduleHandle) LoadFromInMemoryModuleInternal( _nativeAssemblyLoadContext, moduleHandle, - ObjectHandleOnStack.Create(ref loadedAssembly), - out _); + ObjectHandleOnStack.Create(ref loadedAssembly)); return loadedAssembly!; } } @@ -152,8 +150,9 @@ private static unsafe IntPtr ResolveUnmanagedDllUsingEvent(char* pUnmanagedDllNa } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetLoadContextForAssembly")] - private static partial IntPtr GetLoadContextForAssembly(QCallAssembly assembly, out QCallExceptionStatus qcallException); + private static partial IntPtr GetLoadContextForAssembly(QCallAssembly assembly); // Returns the load context in which the specified assembly has been loaded public static AssemblyLoadContext? GetLoadContext(Assembly assembly) @@ -167,7 +166,7 @@ private static unsafe IntPtr ResolveUnmanagedDllUsingEvent(char* pUnmanagedDllNa if (rtAsm != null) { RuntimeAssembly runtimeAssembly = rtAsm; - IntPtr ptrAssemblyLoadContext = GetLoadContextForAssembly(new QCallAssembly(ref runtimeAssembly), out _); + IntPtr ptrAssemblyLoadContext = GetLoadContextForAssembly(new QCallAssembly(ref runtimeAssembly)); if (ptrAssemblyLoadContext == IntPtr.Zero) { // If the load context is returned null, then the assembly was bound using the TPA binder @@ -186,13 +185,13 @@ private static unsafe IntPtr ResolveUnmanagedDllUsingEvent(char* pUnmanagedDllNa // Set the root directory path for profile optimization. public void SetProfileOptimizationRoot(string directoryPath) { - InternalSetProfileRoot(directoryPath, out _); + InternalSetProfileRoot(directoryPath); } // Start profile optimization for the specified profile name. public void StartProfileOptimization(string? profile) { - InternalStartProfile(profile, _nativeAssemblyLoadContext, out _); + InternalStartProfile(profile, _nativeAssemblyLoadContext); } private static RuntimeAssembly? GetRuntimeAssembly(Assembly? asm) diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs index ae3d3ee39d45a8..5d5794893a66c1 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs @@ -33,17 +33,17 @@ internal RuntimeType GetRuntimeTypeChecked() => public static RuntimeTypeHandle FromIntPtr(IntPtr value) => new RuntimeTypeHandle(GetRuntimeTypeFromHandleMaybeNull(value)); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetRuntimeTypeFromHandleSlow")] private static partial void GetRuntimeTypeFromHandleSlow( IntPtr handle, - ObjectHandleOnStack typeObject, - out QCallExceptionStatus qcallException); + ObjectHandleOnStack typeObject); [MethodImpl(MethodImplOptions.NoInlining)] private static RuntimeType GetRuntimeTypeFromHandleSlow(IntPtr handle) { RuntimeType? typeObject = null; - GetRuntimeTypeFromHandleSlow(handle, ObjectHandleOnStack.Create(ref typeObject), out _); + GetRuntimeTypeFromHandleSlow(handle, ObjectHandleOnStack.Create(ref typeObject)); return typeObject!; } @@ -238,8 +238,7 @@ internal static object CreateInstanceForAnotherGenericParameter( new QCallTypeHandle(ref type), &typeHandle, 1, - ObjectHandleOnStack.Create(ref instantiatedObject), - out _); + ObjectHandleOnStack.Create(ref instantiatedObject)); GC.KeepAlive(genericParameter); return instantiatedObject!; @@ -268,8 +267,7 @@ internal static object CreateInstanceForAnotherGenericParameter( new QCallTypeHandle(ref type), pTypeHandles, 2, - ObjectHandleOnStack.Create(ref instantiatedObject), - out _); + ObjectHandleOnStack.Create(ref instantiatedObject)); GC.KeepAlive(genericParameter1); GC.KeepAlive(genericParameter2); @@ -277,18 +275,18 @@ internal static object CreateInstanceForAnotherGenericParameter( return instantiatedObject!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_CreateInstanceForAnotherGenericParameter")] private static partial void CreateInstanceForAnotherGenericParameter( QCallTypeHandle baseType, IntPtr* pTypeHandles, int cTypeHandles, - ObjectHandleOnStack instantiatedObject, - out QCallExceptionStatus qcallException); + ObjectHandleOnStack instantiatedObject); internal static unsafe object InternalAlloc(MethodTable* pMT) { object? result = null; - InternalAlloc(pMT, ObjectHandleOnStack.Create(ref result), out _); + InternalAlloc(pMT, ObjectHandleOnStack.Create(ref result)); return result!; } @@ -300,8 +298,9 @@ internal static object InternalAlloc(RuntimeType type) return result; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_InternalAlloc")] - private static unsafe partial void InternalAlloc(MethodTable* pMT, ObjectHandleOnStack result, out QCallExceptionStatus qcallException); + private static unsafe partial void InternalAlloc(MethodTable* pMT, ObjectHandleOnStack result); [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -313,13 +312,14 @@ internal static object InternalAllocNoChecks(MethodTable* pMT) static object InternalAllocNoChecksWorker(MethodTable* pMT) { object? result = null; - InternalAllocNoChecks(pMT, ObjectHandleOnStack.Create(ref result), out _); + InternalAllocNoChecks(pMT, ObjectHandleOnStack.Create(ref result)); return result!; } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_InternalAllocNoChecks")] - private static unsafe partial void InternalAllocNoChecks(MethodTable* pMT, ObjectHandleOnStack result, out QCallExceptionStatus qcallException); + private static unsafe partial void InternalAllocNoChecks(MethodTable* pMT, ObjectHandleOnStack result); [MethodImpl(MethodImplOptions.InternalCall)] private static extern object? InternalAllocNoChecks_FastPath(MethodTable* pMT); @@ -348,8 +348,7 @@ internal static void GetActivationInfo( GetActivationInfo( ObjectHandleOnStack.Create(ref rt), &pfnAllocatorTemp, &vAllocatorFirstArgTemp, - &pfnRefCtorTemp, &pfnValueCtorTemp, &fCtorIsPublicTemp, - out _); + &pfnRefCtorTemp, &pfnValueCtorTemp, &fCtorIsPublicTemp); pfnAllocator = pfnAllocatorTemp; vAllocatorFirstArg = vAllocatorFirstArgTemp; @@ -358,6 +357,7 @@ internal static void GetActivationInfo( ctorIsPublic = fCtorIsPublicTemp != Interop.BOOL.FALSE; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetActivationInfo")] private static partial void GetActivationInfo( ObjectHandleOnStack pRuntimeType, @@ -365,19 +365,19 @@ private static partial void GetActivationInfo( void** pvAllocatorFirstArg, delegate** ppfnRefCtor, delegate** ppfnValueCtor, - Interop.BOOL* pfCtorIsPublic, - out QCallExceptionStatus qcallException); + Interop.BOOL* pfCtorIsPublic); #if FEATURE_COMINTEROP + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_AllocateComObject")] - private static partial void AllocateComObject(void* pClassFactory, ObjectHandleOnStack result, out QCallExceptionStatus qcallException); + private static partial void AllocateComObject(void* pClassFactory, ObjectHandleOnStack result); // Referenced by unmanaged layer (see GetActivationInfo). // First parameter is ComClassFactory*. private static object AllocateComObject(void* pClassFactory) { object? result = null; - AllocateComObject(pClassFactory, ObjectHandleOnStack.Create(ref result), out _); + AllocateComObject(pClassFactory, ObjectHandleOnStack.Create(ref result)); return result!; } #endif // FEATURE_COMINTEROP @@ -395,7 +395,7 @@ internal static RuntimeAssembly GetAssembly(RuntimeType type) static RuntimeAssembly GetAssemblyWorker(RuntimeType type) { RuntimeAssembly? assembly = null; - GetAssemblySlow(ObjectHandleOnStack.Create(ref type), ObjectHandleOnStack.Create(ref assembly), out _); + GetAssemblySlow(ObjectHandleOnStack.Create(ref type), ObjectHandleOnStack.Create(ref assembly)); return assembly!; } } @@ -403,8 +403,9 @@ static RuntimeAssembly GetAssemblyWorker(RuntimeType type) [MethodImpl(MethodImplOptions.InternalCall)] private static extern RuntimeAssembly? GetAssemblyIfExists(RuntimeType type); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetAssemblySlow")] - private static partial void GetAssemblySlow(ObjectHandleOnStack type, ObjectHandleOnStack assembly, out QCallExceptionStatus qcallException); + private static partial void GetAssemblySlow(ObjectHandleOnStack type, ObjectHandleOnStack assembly); internal static RuntimeModule GetModule(RuntimeType type) { @@ -414,7 +415,7 @@ internal static RuntimeModule GetModule(RuntimeType type) static RuntimeModule GetModuleWorker(RuntimeType type) { RuntimeModule? module = null; - GetModuleSlow(ObjectHandleOnStack.Create(ref type), ObjectHandleOnStack.Create(ref module), out _); + GetModuleSlow(ObjectHandleOnStack.Create(ref type), ObjectHandleOnStack.Create(ref module)); return module!; } } @@ -422,8 +423,9 @@ static RuntimeModule GetModuleWorker(RuntimeType type) [MethodImpl(MethodImplOptions.InternalCall)] private static extern RuntimeModule? GetModuleIfExists(RuntimeType type); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetModuleSlow")] - private static partial void GetModuleSlow(ObjectHandleOnStack type, ObjectHandleOnStack module, out QCallExceptionStatus qcallException); + private static partial void GetModuleSlow(ObjectHandleOnStack type, ObjectHandleOnStack module); public ModuleHandle GetModuleHandle() { @@ -463,8 +465,9 @@ public ModuleHandle GetModuleHandle() [MethodImpl(MethodImplOptions.InternalCall)] internal static extern int GetToken(RuntimeType type); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetMethodAt")] - private static unsafe partial IntPtr GetMethodAt(MethodTable* pMT, int slot, out QCallExceptionStatus qcallException); + private static unsafe partial IntPtr GetMethodAt(MethodTable* pMT, int slot); internal static RuntimeMethodHandleInternal GetMethodAt(RuntimeType type, int slot) { @@ -479,19 +482,20 @@ internal static RuntimeMethodHandleInternal GetMethodAt(RuntimeType type, int sl throw new ArgumentException(SR.Arg_ArgumentOutOfRangeException); } - return new RuntimeMethodHandleInternal(GetMethodAt(typeHandle.AsMethodTable(), slot, out _)); + return new RuntimeMethodHandleInternal(GetMethodAt(typeHandle.AsMethodTable(), slot)); } internal static Type[] GetArgumentTypesFromFunctionPointer(RuntimeType type) { Debug.Assert(type.IsFunctionPointer); Type[]? argTypes = null; - GetArgumentTypesFromFunctionPointer(new QCallTypeHandle(ref type), ObjectHandleOnStack.Create(ref argTypes), out _); + GetArgumentTypesFromFunctionPointer(new QCallTypeHandle(ref type), ObjectHandleOnStack.Create(ref argTypes)); return argTypes!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetArgumentTypesFromFunctionPointer")] - private static partial void GetArgumentTypesFromFunctionPointer(QCallTypeHandle type, ObjectHandleOnStack argTypes, out QCallExceptionStatus qcallException); + private static partial void GetArgumentTypesFromFunctionPointer(QCallTypeHandle type, ObjectHandleOnStack argTypes); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern bool IsUnmanagedFunctionPointer(RuntimeType type); @@ -541,8 +545,9 @@ internal static IntroducedMethodEnumerator GetIntroducedMethods(RuntimeType type [MethodImpl(MethodImplOptions.InternalCall)] private static extern void GetNextIntroducedMethod(ref RuntimeMethodHandleInternal method); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetFields")] - private static partial Interop.BOOL GetFields(MethodTable* pMT, Span data, ref int usedCount, out QCallExceptionStatus qcallException); + private static partial Interop.BOOL GetFields(MethodTable* pMT, Span data, ref int usedCount); internal static bool GetFields(RuntimeType type, Span buffer, out int count) { @@ -556,14 +561,15 @@ internal static bool GetFields(RuntimeType type, Span buffer, out int co } int countLocal = buffer.Length; - bool success = GetFields(typeHandle.AsMethodTable(), buffer, ref countLocal, out _) != Interop.BOOL.FALSE; + bool success = GetFields(typeHandle.AsMethodTable(), buffer, ref countLocal) != Interop.BOOL.FALSE; GC.KeepAlive(type); count = countLocal; return success; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetInterfaces")] - private static unsafe partial void GetInterfaces(MethodTable* pMT, ObjectHandleOnStack result, out QCallExceptionStatus qcallException); + private static unsafe partial void GetInterfaces(MethodTable* pMT, ObjectHandleOnStack result); internal static Type[] GetInterfaces(RuntimeType type) { @@ -576,91 +582,99 @@ internal static Type[] GetInterfaces(RuntimeType type) } Type[] result = []; - GetInterfaces(typeHandle.AsMethodTable(), ObjectHandleOnStack.Create(ref result), out _); + GetInterfaces(typeHandle.AsMethodTable(), ObjectHandleOnStack.Create(ref result)); GC.KeepAlive(type); return result; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetConstraints")] - private static partial void GetConstraints(QCallTypeHandle handle, ObjectHandleOnStack types, out QCallExceptionStatus qcallException); + private static partial void GetConstraints(QCallTypeHandle handle, ObjectHandleOnStack types); internal Type[]? GetConstraints() { Type[]? types = null; RuntimeTypeHandle nativeHandle = GetNativeHandle(); - GetConstraints(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref types), out _); + GetConstraints(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref types)); return types; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "QCall_GetGCHandleForTypeHandle")] - private static partial IntPtr GetGCHandle(QCallTypeHandle handle, GCHandleType type, out QCallExceptionStatus qcallException); + private static partial IntPtr GetGCHandle(QCallTypeHandle handle, GCHandleType type); internal IntPtr GetGCHandle(GCHandleType type) { RuntimeTypeHandle nativeHandle = GetNativeHandle(); - return GetGCHandle(new QCallTypeHandle(ref nativeHandle), type, out _); + return GetGCHandle(new QCallTypeHandle(ref nativeHandle), type); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "QCall_FreeGCHandleForTypeHandle")] - private static partial IntPtr FreeGCHandle(QCallTypeHandle typeHandle, IntPtr objHandle, out QCallExceptionStatus qcallException); + private static partial IntPtr FreeGCHandle(QCallTypeHandle typeHandle, IntPtr objHandle); internal IntPtr FreeGCHandle(IntPtr objHandle) { RuntimeTypeHandle nativeHandle = GetNativeHandle(); - return FreeGCHandle(new QCallTypeHandle(ref nativeHandle), objHandle, out _); + return FreeGCHandle(new QCallTypeHandle(ref nativeHandle), objHandle); } [MethodImpl(MethodImplOptions.InternalCall)] internal static extern int GetNumVirtuals(RuntimeType type); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals")] - private static partial int GetNumVirtualsAndStaticVirtuals(QCallTypeHandle type, out QCallExceptionStatus qcallException); + private static partial int GetNumVirtualsAndStaticVirtuals(QCallTypeHandle type); internal static int GetNumVirtualsAndStaticVirtuals(RuntimeType type) { Debug.Assert(type != null); - return GetNumVirtualsAndStaticVirtuals(new QCallTypeHandle(ref type), out _); + return GetNumVirtualsAndStaticVirtuals(new QCallTypeHandle(ref type)); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_VerifyInterfaceIsImplemented")] - private static partial void VerifyInterfaceIsImplemented(QCallTypeHandle handle, QCallTypeHandle interfaceHandle, out QCallExceptionStatus qcallException); + private static partial void VerifyInterfaceIsImplemented(QCallTypeHandle handle, QCallTypeHandle interfaceHandle); internal void VerifyInterfaceIsImplemented(RuntimeTypeHandle interfaceHandle) { RuntimeTypeHandle nativeHandle = GetNativeHandle(); RuntimeTypeHandle nativeInterfaceHandle = interfaceHandle.GetNativeHandle(); - VerifyInterfaceIsImplemented(new QCallTypeHandle(ref nativeHandle), new QCallTypeHandle(ref nativeInterfaceHandle), out _); + VerifyInterfaceIsImplemented(new QCallTypeHandle(ref nativeHandle), new QCallTypeHandle(ref nativeInterfaceHandle)); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetInterfaceMethodImplementation")] - private static partial RuntimeMethodHandleInternal GetInterfaceMethodImplementation(QCallTypeHandle handle, QCallTypeHandle interfaceHandle, RuntimeMethodHandleInternal interfaceMethodHandle, out QCallExceptionStatus qcallException); + private static partial RuntimeMethodHandleInternal GetInterfaceMethodImplementation(QCallTypeHandle handle, QCallTypeHandle interfaceHandle, RuntimeMethodHandleInternal interfaceMethodHandle); internal RuntimeMethodHandleInternal GetInterfaceMethodImplementation(RuntimeTypeHandle interfaceHandle, RuntimeMethodHandleInternal interfaceMethodHandle) { RuntimeTypeHandle nativeHandle = GetNativeHandle(); RuntimeTypeHandle nativeInterfaceHandle = interfaceHandle.GetNativeHandle(); - return GetInterfaceMethodImplementation(new QCallTypeHandle(ref nativeHandle), new QCallTypeHandle(ref nativeInterfaceHandle), interfaceMethodHandle, out _); + return GetInterfaceMethodImplementation(new QCallTypeHandle(ref nativeHandle), new QCallTypeHandle(ref nativeInterfaceHandle), interfaceMethodHandle); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_IsVisible")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool _IsVisible(QCallTypeHandle typeHandle, out QCallExceptionStatus qcallException); + private static partial bool _IsVisible(QCallTypeHandle typeHandle); internal static bool IsVisible(RuntimeType type) { - return _IsVisible(new QCallTypeHandle(ref type), out _); + return _IsVisible(new QCallTypeHandle(ref type)); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_ConstructName")] - private static partial void ConstructName(QCallTypeHandle handle, TypeNameFormatFlags formatFlags, StringHandleOnStack retString, out QCallExceptionStatus qcallException); + private static partial void ConstructName(QCallTypeHandle handle, TypeNameFormatFlags formatFlags, StringHandleOnStack retString); internal string ConstructName(TypeNameFormatFlags formatFlags) { string? name = null; RuntimeTypeHandle nativeHandle = GetNativeHandle(); - ConstructName(new QCallTypeHandle(ref nativeHandle), formatFlags, new StringHandleOnStack(ref name), out _); + ConstructName(new QCallTypeHandle(ref nativeHandle), formatFlags, new StringHandleOnStack(ref name)); return name!; } @@ -694,11 +708,13 @@ internal static bool CanCastTo(RuntimeType type, RuntimeType target) return ret; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetDeclaringTypeHandleForGenericVariable")] - private static partial IntPtr GetDeclaringTypeHandleForGenericVariable(IntPtr typeHandle, out QCallExceptionStatus qcallException); + private static partial IntPtr GetDeclaringTypeHandleForGenericVariable(IntPtr typeHandle); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetDeclaringTypeHandle")] - private static partial IntPtr GetDeclaringTypeHandle(IntPtr typeHandle, out QCallExceptionStatus qcallException); + private static partial IntPtr GetDeclaringTypeHandle(IntPtr typeHandle); internal static RuntimeType? GetDeclaringType(RuntimeType type) { @@ -709,12 +725,12 @@ internal static bool CanCastTo(RuntimeType type, RuntimeType target) CorElementType elementType = (CorElementType)typeHandle.GetCorElementType(); if (elementType is CorElementType.ELEMENT_TYPE_VAR or CorElementType.ELEMENT_TYPE_MVAR) { - retTypeHandle = GetDeclaringTypeHandleForGenericVariable(type.GetUnderlyingNativeHandle(), out _); + retTypeHandle = GetDeclaringTypeHandleForGenericVariable(type.GetUnderlyingNativeHandle()); } } else { - retTypeHandle = GetDeclaringTypeHandle(type.GetUnderlyingNativeHandle(), out _); + retTypeHandle = GetDeclaringTypeHandle(type.GetUnderlyingNativeHandle()); } if (retTypeHandle == IntPtr.Zero) @@ -727,26 +743,28 @@ internal static bool CanCastTo(RuntimeType type, RuntimeType target) return result; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetDeclaringMethodForGenericParameter")] - private static partial void GetDeclaringMethodForGenericParameter(QCallTypeHandle typeHandle, ObjectHandleOnStack result, out QCallExceptionStatus qcallException); + private static partial void GetDeclaringMethodForGenericParameter(QCallTypeHandle typeHandle, ObjectHandleOnStack result); internal static IRuntimeMethodInfo? GetDeclaringMethodForGenericParameter(RuntimeType type) { Debug.Assert(IsGenericVariable(type)); IRuntimeMethodInfo? method = null; - GetDeclaringMethodForGenericParameter(new QCallTypeHandle(ref type), ObjectHandleOnStack.Create(ref method), out _); + GetDeclaringMethodForGenericParameter(new QCallTypeHandle(ref type), ObjectHandleOnStack.Create(ref method)); return method; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetInstantiation")] - internal static partial void GetInstantiation(QCallTypeHandle type, ObjectHandleOnStack types, Interop.BOOL fAsRuntimeTypeArray, out QCallExceptionStatus qcallException); + internal static partial void GetInstantiation(QCallTypeHandle type, ObjectHandleOnStack types, Interop.BOOL fAsRuntimeTypeArray); internal RuntimeType[] GetInstantiationInternal() { RuntimeType[]? types = null; RuntimeTypeHandle nativeHandle = GetNativeHandle(); - GetInstantiation(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref types), Interop.BOOL.TRUE, out _); + GetInstantiation(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref types), Interop.BOOL.TRUE); return types!; } @@ -754,12 +772,13 @@ internal RuntimeType[] GetInstantiationInternal() { Type[]? types = null; RuntimeTypeHandle nativeHandle = GetNativeHandle(); - GetInstantiation(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref types), Interop.BOOL.FALSE, out _); + GetInstantiation(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref types), Interop.BOOL.FALSE); return types; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_Instantiate")] - private static partial void Instantiate(QCallTypeHandle handle, IntPtr* pInst, int numGenericArgs, ObjectHandleOnStack type, out QCallExceptionStatus qcallException); + private static partial void Instantiate(QCallTypeHandle handle, IntPtr* pInst, int numGenericArgs, ObjectHandleOnStack type); internal RuntimeType Instantiate(RuntimeType inst) { @@ -767,7 +786,7 @@ internal RuntimeType Instantiate(RuntimeType inst) RuntimeType? type = null; RuntimeTypeHandle nativeHandle = GetNativeHandle(); - Instantiate(new QCallTypeHandle(ref nativeHandle), &ptr, 1, ObjectHandleOnStack.Create(ref type), out _); + Instantiate(new QCallTypeHandle(ref nativeHandle), &ptr, 1, ObjectHandleOnStack.Create(ref type)); GC.KeepAlive(inst); return type!; } @@ -780,47 +799,51 @@ internal RuntimeType Instantiate(Type[]? inst) { RuntimeType? type = null; RuntimeTypeHandle nativeHandle = GetNativeHandle(); - Instantiate(new QCallTypeHandle(ref nativeHandle), pInst, instCount, ObjectHandleOnStack.Create(ref type), out _); + Instantiate(new QCallTypeHandle(ref nativeHandle), pInst, instCount, ObjectHandleOnStack.Create(ref type)); GC.KeepAlive(inst); return type!; } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_MakeArray")] - private static partial void MakeArray(QCallTypeHandle handle, int rank, ObjectHandleOnStack type, out QCallExceptionStatus qcallException); + private static partial void MakeArray(QCallTypeHandle handle, int rank, ObjectHandleOnStack type); internal RuntimeType MakeArray(int rank) { RuntimeType? type = null; RuntimeTypeHandle nativeHandle = GetNativeHandle(); - MakeArray(new QCallTypeHandle(ref nativeHandle), rank, ObjectHandleOnStack.Create(ref type), out _); + MakeArray(new QCallTypeHandle(ref nativeHandle), rank, ObjectHandleOnStack.Create(ref type)); return type!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_MakeSZArray")] - private static partial void MakeSZArray(QCallTypeHandle handle, ObjectHandleOnStack type, out QCallExceptionStatus qcallException); + private static partial void MakeSZArray(QCallTypeHandle handle, ObjectHandleOnStack type); internal RuntimeType MakeSZArray() { RuntimeType? type = null; RuntimeTypeHandle nativeHandle = GetNativeHandle(); - MakeSZArray(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref type), out _); + MakeSZArray(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref type)); return type!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_MakeByRef")] - private static partial void MakeByRef(QCallTypeHandle handle, ObjectHandleOnStack type, out QCallExceptionStatus qcallException); + private static partial void MakeByRef(QCallTypeHandle handle, ObjectHandleOnStack type); internal RuntimeType MakeByRef() { RuntimeType? type = null; RuntimeTypeHandle nativeHandle = GetNativeHandle(); - MakeByRef(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref type), out _); + MakeByRef(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref type)); return type!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_MakeFunctionPointer")] - private static partial void MakeFunctionPointer(nint* retAndParamTypes, int numArgs, [MarshalAs(UnmanagedType.Bool)] bool isUnmanaged, ObjectHandleOnStack type, out QCallExceptionStatus qcallException); + private static partial void MakeFunctionPointer(nint* retAndParamTypes, int numArgs, [MarshalAs(UnmanagedType.Bool)] bool isUnmanaged, ObjectHandleOnStack type); internal RuntimeType MakeFunctionPointer(Type[] parameterTypes, bool isUnmanaged) { @@ -834,7 +857,7 @@ internal RuntimeType MakeFunctionPointer(Type[] parameterTypes, bool isUnmanaged RuntimeType? type = null; fixed (nint* pRetAndParamTypeHandles = retAndParamTypeHandles) { - MakeFunctionPointer(pRetAndParamTypeHandles, parameterTypes.Length, isUnmanaged, ObjectHandleOnStack.Create(ref type), out _); + MakeFunctionPointer(pRetAndParamTypeHandles, parameterTypes.Length, isUnmanaged, ObjectHandleOnStack.Create(ref type)); } GC.KeepAlive(m_type); @@ -842,19 +865,21 @@ internal RuntimeType MakeFunctionPointer(Type[] parameterTypes, bool isUnmanaged return type!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_MakePointer")] - private static partial void MakePointer(QCallTypeHandle handle, ObjectHandleOnStack type, out QCallExceptionStatus qcallException); + private static partial void MakePointer(QCallTypeHandle handle, ObjectHandleOnStack type); internal RuntimeType MakePointer() { RuntimeType? type = null; RuntimeTypeHandle nativeHandle = GetNativeHandle(); - MakePointer(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref type), out _); + MakePointer(new QCallTypeHandle(ref nativeHandle), ObjectHandleOnStack.Create(ref type)); return type!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetGenericTypeDefinition")] - internal static partial void GetGenericTypeDefinition(QCallTypeHandle type, ObjectHandleOnStack retType, out QCallExceptionStatus qcallException); + internal static partial void GetGenericTypeDefinition(QCallTypeHandle type, ObjectHandleOnStack retType); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern bool IsGenericVariable(RuntimeType type); @@ -880,23 +905,25 @@ internal bool ContainsGenericVariables() return ContainsGenericVariables(GetRuntimeTypeChecked()); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_SatisfiesConstraints")] - private static partial Interop.BOOL SatisfiesConstraints(QCallTypeHandle paramType, QCallTypeHandle pTypeContext, RuntimeMethodHandleInternal pMethodContext, QCallTypeHandle toType, out QCallExceptionStatus qcallException); + private static partial Interop.BOOL SatisfiesConstraints(QCallTypeHandle paramType, QCallTypeHandle pTypeContext, RuntimeMethodHandleInternal pMethodContext, QCallTypeHandle toType); internal static bool SatisfiesConstraints(RuntimeType paramType, RuntimeType? typeContext, RuntimeMethodInfo? methodContext, RuntimeType toType) { RuntimeMethodHandleInternal methodContextRaw = (methodContext == null) ? RuntimeMethodHandleInternal.EmptyHandle : IRuntimeMethodInfo.GetValue(methodContext); - bool result = SatisfiesConstraints(new QCallTypeHandle(ref paramType), new QCallTypeHandle(ref typeContext!), methodContextRaw, new QCallTypeHandle(ref toType), out _) != Interop.BOOL.FALSE; + bool result = SatisfiesConstraints(new QCallTypeHandle(ref paramType), new QCallTypeHandle(ref typeContext!), methodContextRaw, new QCallTypeHandle(ref toType)) != Interop.BOOL.FALSE; GC.KeepAlive(methodContext); return result; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_RegisterCollectibleTypeDependency")] - private static partial void RegisterCollectibleTypeDependency(QCallTypeHandle type, QCallAssembly assembly, out QCallExceptionStatus qcallException); + private static partial void RegisterCollectibleTypeDependency(QCallTypeHandle type, QCallAssembly assembly); internal static void RegisterCollectibleTypeDependency(RuntimeType type, RuntimeAssembly? assembly) { - RegisterCollectibleTypeDependency(new QCallTypeHandle(ref type), new QCallAssembly(ref assembly!), out _); + RegisterCollectibleTypeDependency(new QCallTypeHandle(ref type), new QCallAssembly(ref assembly!)); } [Obsolete(Obsoletions.LegacyFormatterImplMessage, DiagnosticId = Obsoletions.LegacyFormatterImplDiagId, UrlFormat = Obsoletions.SharedUrlFormat)] @@ -907,11 +934,12 @@ public void GetObjectData(SerializationInfo info, StreamingContext context) } #if FEATURE_TYPEEQUIVALENCE + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_IsEquivalentTo")] - private static partial Interop.BOOL IsEquivalentTo(QCallTypeHandle rtType1, QCallTypeHandle rtType2, out QCallExceptionStatus qcallException); + private static partial Interop.BOOL IsEquivalentTo(QCallTypeHandle rtType1, QCallTypeHandle rtType2); internal static bool IsEquivalentTo(RuntimeType rtType1, RuntimeType rtType2) - => IsEquivalentTo(new QCallTypeHandle(ref rtType1), new QCallTypeHandle(ref rtType2), out _) == Interop.BOOL.TRUE; + => IsEquivalentTo(new QCallTypeHandle(ref rtType1), new QCallTypeHandle(ref rtType2)) == Interop.BOOL.TRUE; #endif // FEATURE_TYPEEQUIVALENCE } @@ -1068,12 +1096,13 @@ internal bool IsNullHandle() return m_value == null; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetFunctionPointer")] - internal static partial IntPtr GetFunctionPointer(RuntimeMethodHandleInternal handle, out QCallExceptionStatus qcallException); + internal static partial IntPtr GetFunctionPointer(RuntimeMethodHandleInternal handle); public IntPtr GetFunctionPointer() { - IntPtr ptr = GetFunctionPointer(IRuntimeMethodInfo.GetValue(EnsureNonNullMethodInfo(m_value)), out _); + IntPtr ptr = GetFunctionPointer(IRuntimeMethodInfo.GetValue(EnsureNonNullMethodInfo(m_value))); GC.KeepAlive(m_value); return ptr; } @@ -1081,13 +1110,13 @@ public IntPtr GetFunctionPointer() [MethodImpl(MethodImplOptions.InternalCall)] internal static extern bool IsCollectible(RuntimeMethodHandleInternal method); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_IsCAVisibleFromDecoratedType")] internal static partial Interop.BOOL IsCAVisibleFromDecoratedType( QCallTypeHandle attrTypeHandle, RuntimeMethodHandleInternal attrCtor, QCallTypeHandle sourceTypeHandle, - QCallModule sourceModule, - out QCallExceptionStatus qcallException); + QCallModule sourceModule); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern MethodAttributes GetAttributes(RuntimeMethodHandleInternal method); @@ -1102,14 +1131,15 @@ internal static MethodAttributes GetAttributes(IRuntimeMethodInfo method) [MethodImpl(MethodImplOptions.InternalCall)] internal static extern MethodImplAttributes GetImplAttributes(IRuntimeMethodInfo method); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_ConstructInstantiation")] - private static partial void ConstructInstantiation(RuntimeMethodHandleInternal method, TypeNameFormatFlags format, StringHandleOnStack retString, out QCallExceptionStatus qcallException); + private static partial void ConstructInstantiation(RuntimeMethodHandleInternal method, TypeNameFormatFlags format, StringHandleOnStack retString); internal static string ConstructInstantiation(IRuntimeMethodInfo method, TypeNameFormatFlags format) { string? name = null; IRuntimeMethodInfo methodInfo = EnsureNonNullMethodInfo(method); - ConstructInstantiation(IRuntimeMethodInfo.GetValue(methodInfo), format, new StringHandleOnStack(ref name), out _); + ConstructInstantiation(IRuntimeMethodInfo.GetValue(methodInfo), format, new StringHandleOnStack(ref name)); GC.KeepAlive(methodInfo); return name!; } @@ -1183,8 +1213,9 @@ internal static MdUtf8String GetUtf8Name(RuntimeMethodHandleInternal method) [DebuggerStepThrough] [DebuggerHidden] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_InvokeMethod")] - private static partial void InvokeMethod(ObjectHandleOnStack target, void** arguments, ObjectHandleOnStack sig, Interop.BOOL isConstructor, ObjectHandleOnStack result, out QCallExceptionStatus qcallException); + private static partial void InvokeMethod(ObjectHandleOnStack target, void** arguments, ObjectHandleOnStack sig, Interop.BOOL isConstructor, ObjectHandleOnStack result); [DebuggerStepThrough] [DebuggerHidden] @@ -1196,8 +1227,7 @@ internal static MdUtf8String GetUtf8Name(RuntimeMethodHandleInternal method) arguments, ObjectHandleOnStack.Create(ref sig), isConstructor ? Interop.BOOL.TRUE : Interop.BOOL.FALSE, - ObjectHandleOnStack.Create(ref result), - out _); + ObjectHandleOnStack.Create(ref result)); return result; } @@ -1238,13 +1268,14 @@ ref obj.GetRawData(), return obj; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetMethodInstantiation")] - private static partial void GetMethodInstantiation(RuntimeMethodHandleInternal method, ObjectHandleOnStack types, Interop.BOOL fAsRuntimeTypeArray, out QCallExceptionStatus qcallException); + private static partial void GetMethodInstantiation(RuntimeMethodHandleInternal method, ObjectHandleOnStack types, Interop.BOOL fAsRuntimeTypeArray); internal static RuntimeType[] GetMethodInstantiationInternal(IRuntimeMethodInfo method) { RuntimeType[]? types = null; - GetMethodInstantiation(IRuntimeMethodInfo.GetValue(EnsureNonNullMethodInfo(method)), ObjectHandleOnStack.Create(ref types), Interop.BOOL.TRUE, out _); + GetMethodInstantiation(IRuntimeMethodInfo.GetValue(EnsureNonNullMethodInfo(method)), ObjectHandleOnStack.Create(ref types), Interop.BOOL.TRUE); GC.KeepAlive(method); return types!; } @@ -1252,14 +1283,14 @@ internal static RuntimeType[] GetMethodInstantiationInternal(IRuntimeMethodInfo internal static RuntimeType[] GetMethodInstantiationInternal(RuntimeMethodHandleInternal method) { RuntimeType[]? types = null; - GetMethodInstantiation(method, ObjectHandleOnStack.Create(ref types), Interop.BOOL.TRUE, out _); + GetMethodInstantiation(method, ObjectHandleOnStack.Create(ref types), Interop.BOOL.TRUE); return types!; } internal static Type[]? GetMethodInstantiationPublic(IRuntimeMethodInfo method) { Type[]? types = null; - GetMethodInstantiation(IRuntimeMethodInfo.GetValue(EnsureNonNullMethodInfo(method)), ObjectHandleOnStack.Create(ref types), Interop.BOOL.FALSE, out _); + GetMethodInstantiation(IRuntimeMethodInfo.GetValue(EnsureNonNullMethodInfo(method)), ObjectHandleOnStack.Create(ref types), Interop.BOOL.FALSE); GC.KeepAlive(method); return types; } @@ -1277,8 +1308,9 @@ internal static bool HasMethodInstantiation(IRuntimeMethodInfo method) [MethodImpl(MethodImplOptions.InternalCall)] private static extern RuntimeMethodHandleInternal GetStubIfNeededInternal(RuntimeMethodHandleInternal method, RuntimeType declaringType); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetStubIfNeededSlow")] - private static partial RuntimeMethodHandleInternal GetStubIfNeededSlow(RuntimeMethodHandleInternal method, QCallTypeHandle declaringTypeHandle, ObjectHandleOnStack methodInstantiation, out QCallExceptionStatus qcallException); + private static partial RuntimeMethodHandleInternal GetStubIfNeededSlow(RuntimeMethodHandleInternal method, QCallTypeHandle declaringTypeHandle, ObjectHandleOnStack methodInstantiation); internal static RuntimeMethodHandleInternal GetStubIfNeeded(RuntimeMethodHandleInternal method, RuntimeType declaringType, RuntimeType[]? methodInstantiation) { @@ -1293,18 +1325,19 @@ internal static RuntimeMethodHandleInternal GetStubIfNeeded(RuntimeMethodHandleI [MethodImpl(MethodImplOptions.NoInlining)] static RuntimeMethodHandleInternal GetStubIfNeededWorker(RuntimeMethodHandleInternal method, RuntimeType declaringType, RuntimeType[]? methodInstantiation) - => GetStubIfNeededSlow(method, new QCallTypeHandle(ref declaringType), ObjectHandleOnStack.Create(ref methodInstantiation), out _); + => GetStubIfNeededSlow(method, new QCallTypeHandle(ref declaringType), ObjectHandleOnStack.Create(ref methodInstantiation)); } [MethodImpl(MethodImplOptions.InternalCall)] internal static extern RuntimeMethodHandleInternal GetMethodFromCanonical(RuntimeMethodHandleInternal method, RuntimeType declaringType); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetNativeCode")] - private static partial IntPtr GetNativeCode(RuntimeMethodHandleInternal method, out QCallExceptionStatus qcallException); + private static partial IntPtr GetNativeCode(RuntimeMethodHandleInternal method); internal static IntPtr GetNativeCodeInternal(IRuntimeMethodInfo method) { - IntPtr value = GetNativeCode(IRuntimeMethodInfo.GetValue(method), out _); + IntPtr value = GetNativeCode(IRuntimeMethodInfo.GetValue(method)); GC.KeepAlive(method); return value; } @@ -1322,14 +1355,15 @@ internal static bool IsGenericMethodDefinition(IRuntimeMethodInfo method) [MethodImpl(MethodImplOptions.InternalCall)] private static extern bool IsTypicalMethodDefinition(IRuntimeMethodInfo method); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetTypicalMethodDefinition")] - private static partial void GetTypicalMethodDefinition(RuntimeMethodHandleInternal method, ObjectHandleOnStack outMethod, out QCallExceptionStatus qcallException); + private static partial void GetTypicalMethodDefinition(RuntimeMethodHandleInternal method, ObjectHandleOnStack outMethod); internal static IRuntimeMethodInfo GetTypicalMethodDefinition(IRuntimeMethodInfo method) { if (!IsTypicalMethodDefinition(method)) { - GetTypicalMethodDefinition(IRuntimeMethodInfo.GetValue(method), ObjectHandleOnStack.Create(ref method), out _); + GetTypicalMethodDefinition(IRuntimeMethodInfo.GetValue(method), ObjectHandleOnStack.Create(ref method)); GC.KeepAlive(method); } @@ -1341,14 +1375,15 @@ internal static IRuntimeMethodInfo GetTypicalMethodDefinition(IRuntimeMethodInfo internal static int GetGenericParameterCount(IRuntimeMethodInfo method) => GetGenericParameterCount(IRuntimeMethodInfo.GetValue(method)); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_StripMethodInstantiation")] - private static partial void StripMethodInstantiation(RuntimeMethodHandleInternal method, ObjectHandleOnStack outMethod, out QCallExceptionStatus qcallException); + private static partial void StripMethodInstantiation(RuntimeMethodHandleInternal method, ObjectHandleOnStack outMethod); internal static IRuntimeMethodInfo StripMethodInstantiation(IRuntimeMethodInfo method) { IRuntimeMethodInfo strippedMethod = method; - StripMethodInstantiation(IRuntimeMethodInfo.GetValue(method), ObjectHandleOnStack.Create(ref strippedMethod), out _); + StripMethodInstantiation(IRuntimeMethodInfo.GetValue(method), ObjectHandleOnStack.Create(ref strippedMethod)); GC.KeepAlive(method); return strippedMethod; @@ -1357,19 +1392,21 @@ internal static IRuntimeMethodInfo StripMethodInstantiation(IRuntimeMethodInfo m [MethodImpl(MethodImplOptions.InternalCall)] internal static extern bool IsDynamicMethod(RuntimeMethodHandleInternal method); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_Destroy")] - internal static partial void Destroy(RuntimeMethodHandleInternal method, out QCallExceptionStatus qcallException); + internal static partial void Destroy(RuntimeMethodHandleInternal method); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern Resolver GetResolver(RuntimeMethodHandleInternal method); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetMethodBody")] - private static partial void GetMethodBody(RuntimeMethodHandleInternal method, QCallTypeHandle declaringType, ObjectHandleOnStack result, out QCallExceptionStatus qcallException); + private static partial void GetMethodBody(RuntimeMethodHandleInternal method, QCallTypeHandle declaringType, ObjectHandleOnStack result); internal static RuntimeMethodBody? GetMethodBody(IRuntimeMethodInfo method, RuntimeType declaringType) { RuntimeMethodBody? result = null; - GetMethodBody(IRuntimeMethodInfo.GetValue(method), new QCallTypeHandle(ref declaringType), ObjectHandleOnStack.Create(ref result), out _); + GetMethodBody(IRuntimeMethodInfo.GetValue(method), new QCallTypeHandle(ref declaringType), ObjectHandleOnStack.Create(ref result)); GC.KeepAlive(method); return result; } @@ -1585,14 +1622,15 @@ internal static RuntimeType GetApproxDeclaringType(IRuntimeFieldInfo field) [MethodImpl(MethodImplOptions.InternalCall)] internal static extern IntPtr GetStaticFieldAddress(RtFieldInfo field); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeFieldHandle_GetRVAFieldInfo")] [return: MarshalAs(UnmanagedType.Bool)] - internal static partial bool GetRVAFieldInfo(RuntimeFieldHandleInternal field, out void* address, out uint size, out QCallExceptionStatus qcallException); + internal static partial bool GetRVAFieldInfo(RuntimeFieldHandleInternal field, out void* address, out uint size); internal static ref byte GetFieldDataReference(object target, RuntimeFieldInfo field) { ByteRef fieldDataRef = default; - GetFieldDataReference(((RtFieldInfo)field).GetFieldDesc(), ObjectHandleOnStack.Create(ref target), ByteRefOnStack.Create(ref fieldDataRef), out _); + GetFieldDataReference(((RtFieldInfo)field).GetFieldDesc(), ObjectHandleOnStack.Create(ref target), ByteRefOnStack.Create(ref fieldDataRef)); Debug.Assert(!Unsafe.IsNullRef(ref fieldDataRef.Value)); GC.KeepAlive(field); return ref fieldDataRef.Value; @@ -1605,8 +1643,9 @@ internal static ref byte GetFieldDataReference(ref byte target, RuntimeFieldInfo return ref Unsafe.AddByteOffset(ref target, offset); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeFieldHandle_GetFieldDataReference")] - private static unsafe partial void GetFieldDataReference(IntPtr fieldDesc, ObjectHandleOnStack target, ByteRefOnStack fieldDataRef, out QCallExceptionStatus qcallException); + private static unsafe partial void GetFieldDataReference(IntPtr fieldDesc, ObjectHandleOnStack target, ByteRefOnStack fieldDataRef); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern int GetToken(IntPtr fieldDesc); @@ -1618,6 +1657,7 @@ internal static int GetToken(RtFieldInfo field) return tk; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeFieldHandle_GetValue")] private static partial void GetValue( IntPtr fieldDesc, @@ -1625,8 +1665,7 @@ private static partial void GetValue( QCallTypeHandle fieldType, QCallTypeHandle declaringType, [MarshalAs(UnmanagedType.Bool)] ref bool isClassInitialized, - ObjectHandleOnStack result, - out QCallExceptionStatus qcallException); + ObjectHandleOnStack result); internal static object? GetValue(RtFieldInfo field, object? instance, RuntimeType fieldType, RuntimeType? declaringType, ref bool isClassInitialized) { @@ -1636,19 +1675,19 @@ private static partial void GetValue( } object? result = null; - GetValue(field.GetFieldDesc(), ObjectHandleOnStack.Create(ref instance), new QCallTypeHandle(ref fieldType), new QCallTypeHandle(ref declaringType!), ref isClassInitialized, ObjectHandleOnStack.Create(ref result), out _); + GetValue(field.GetFieldDesc(), ObjectHandleOnStack.Create(ref instance), new QCallTypeHandle(ref fieldType), new QCallTypeHandle(ref declaringType!), ref isClassInitialized, ObjectHandleOnStack.Create(ref result)); GC.KeepAlive(field); return result; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeFieldHandle_GetValueDirect")] private static partial void GetValueDirect( IntPtr fieldDesc, void* pTypedRef, QCallTypeHandle fieldType, QCallTypeHandle declaringType, - ObjectHandleOnStack result, - out QCallExceptionStatus qcallException); + ObjectHandleOnStack result); internal static object? GetValueDirect(RtFieldInfo field, RuntimeType fieldType, TypedReference typedRef, RuntimeType? contextType) { @@ -1658,11 +1697,12 @@ private static partial void GetValueDirect( } object? result = null; - GetValueDirect(field.GetFieldDesc(), &typedRef, new QCallTypeHandle(ref fieldType), new QCallTypeHandle(ref contextType!), ObjectHandleOnStack.Create(ref result), out _); + GetValueDirect(field.GetFieldDesc(), &typedRef, new QCallTypeHandle(ref fieldType), new QCallTypeHandle(ref contextType!), ObjectHandleOnStack.Create(ref result)); GC.KeepAlive(field); return result; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeFieldHandle_SetValue")] private static partial void SetValue( IntPtr fieldDesc, @@ -1670,8 +1710,7 @@ private static partial void SetValue( ObjectHandleOnStack value, QCallTypeHandle fieldType, QCallTypeHandle declaringType, - [MarshalAs(UnmanagedType.Bool)] ref bool isClassInitialized, - out QCallExceptionStatus qcallException); + [MarshalAs(UnmanagedType.Bool)] ref bool isClassInitialized); internal static void SetValue(RtFieldInfo field, object? obj, object? value, RuntimeType fieldType, RuntimeType? declaringType, ref bool isClassInitialized) { @@ -1680,18 +1719,18 @@ internal static void SetValue(RtFieldInfo field, object? obj, object? value, Run throw new ArgumentNullException(SR.Arg_InvalidHandle); } - SetValue(field.GetFieldDesc(), ObjectHandleOnStack.Create(ref obj), ObjectHandleOnStack.Create(ref value), new QCallTypeHandle(ref fieldType), new QCallTypeHandle(ref declaringType!), ref isClassInitialized, out _); + SetValue(field.GetFieldDesc(), ObjectHandleOnStack.Create(ref obj), ObjectHandleOnStack.Create(ref value), new QCallTypeHandle(ref fieldType), new QCallTypeHandle(ref declaringType!), ref isClassInitialized); GC.KeepAlive(field); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeFieldHandle_SetValueDirect")] private static partial void SetValueDirect( IntPtr fieldDesc, void* pTypedRef, ObjectHandleOnStack value, QCallTypeHandle fieldType, - QCallTypeHandle declaringType, - out QCallExceptionStatus qcallException); + QCallTypeHandle declaringType); internal static void SetValueDirect(RtFieldInfo field, RuntimeType fieldType, TypedReference typedRef, object? value, RuntimeType? contextType) { @@ -1700,7 +1739,7 @@ internal static void SetValueDirect(RtFieldInfo field, RuntimeType fieldType, Ty throw new ArgumentNullException(SR.Arg_InvalidHandle); } - SetValueDirect(field.GetFieldDesc(), &typedRef, ObjectHandleOnStack.Create(ref value), new QCallTypeHandle(ref fieldType), new QCallTypeHandle(ref contextType!), out _); + SetValueDirect(field.GetFieldDesc(), &typedRef, ObjectHandleOnStack.Create(ref value), new QCallTypeHandle(ref fieldType), new QCallTypeHandle(ref contextType!)); GC.KeepAlive(field); } @@ -1738,8 +1777,9 @@ public void GetObjectData(SerializationInfo info, StreamingContext context) throw new PlatformNotSupportedException(); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeFieldHandle_GetEnCFieldAddr")] - private static partial void* GetEnCFieldAddr(ObjectHandleOnStack tgt, void* pFD, out QCallExceptionStatus qcallException); + private static partial void* GetEnCFieldAddr(ObjectHandleOnStack tgt, void* pFD); // implementation of CORINFO_HELP_GETFIELDADDR [StackTraceHidden] @@ -1747,7 +1787,7 @@ public void GetObjectData(SerializationInfo info, StreamingContext context) [DebuggerHidden] internal static unsafe void* GetFieldAddr(object tgt, void* pFD) { - void* addr = GetEnCFieldAddr(ObjectHandleOnStack.Create(ref tgt), pFD, out _); + void* addr = GetEnCFieldAddr(ObjectHandleOnStack.Create(ref tgt), pFD); if (addr == null) throw new NullReferenceException(); return addr; @@ -1760,7 +1800,7 @@ public void GetObjectData(SerializationInfo info, StreamingContext context) internal static unsafe void* GetStaticFieldAddr(void* pFD) { object? nullTarget = null; - void* addr = GetEnCFieldAddr(ObjectHandleOnStack.Create(ref nullTarget), pFD, out _); + void* addr = GetEnCFieldAddr(ObjectHandleOnStack.Create(ref nullTarget), pFD); if (addr == null) throw new NullReferenceException(); return addr; @@ -1813,6 +1853,7 @@ public bool Equals(ModuleHandle handle) public static bool operator !=(ModuleHandle left, ModuleHandle right) => !left.Equals(right); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleHandle_GetDynamicMethod", StringMarshalling = StringMarshalling.Utf8)] private static partial void GetDynamicMethod( QCallModule module, @@ -1820,8 +1861,7 @@ private static partial void GetDynamicMethod( byte[] sig, int sigLen, ObjectHandleOnStack resolver, - ObjectHandleOnStack result, - out QCallExceptionStatus qcallException); + ObjectHandleOnStack result); internal static IRuntimeMethodInfo GetDynamicMethod(RuntimeModule module, string name, byte[] sig, Resolver resolver) { @@ -1832,8 +1872,7 @@ internal static IRuntimeMethodInfo GetDynamicMethod(RuntimeModule module, string sig, sig.Length, ObjectHandleOnStack.Create(ref resolver), - ObjectHandleOnStack.Create(ref methodInfo), - out _); + ObjectHandleOnStack.Create(ref methodInfo)); return methodInfo!; } @@ -1889,7 +1928,7 @@ public RuntimeTypeHandle ResolveTypeHandle(int typeToken, RuntimeTypeHandle[]? t try { RuntimeType? type = null; - ResolveType(new QCallModule(ref module), typeToken, typeInstArgs, typeInstantiationContextHandles.Length, methodInstArgs, methodInstantiationContextHandles.Length, ObjectHandleOnStack.Create(ref type), out _); + ResolveType(new QCallModule(ref module), typeToken, typeInstArgs, typeInstantiationContextHandles.Length, methodInstArgs, methodInstantiationContextHandles.Length, ObjectHandleOnStack.Create(ref type)); GC.KeepAlive(typeInstantiationContext); GC.KeepAlive(methodInstantiationContext); return new RuntimeTypeHandle(type!); @@ -1904,6 +1943,7 @@ public RuntimeTypeHandle ResolveTypeHandle(int typeToken, RuntimeTypeHandle[]? t } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleHandle_ResolveType")] private static partial void ResolveType(QCallModule module, int typeToken, @@ -1911,8 +1951,7 @@ private static partial void ResolveType(QCallModule module, int typeInstCount, IntPtr* methodInstArgs, int methodInstCount, - ObjectHandleOnStack type, - out QCallExceptionStatus qcallException); + ObjectHandleOnStack type); // SQL-CLR LKG9 Compiler dependency [RequiresUnreferencedCode("Trimming changes metadata tokens")] @@ -1945,7 +1984,7 @@ internal static RuntimeMethodHandleInternal ResolveMethodHandleInternal(RuntimeM { fixed (IntPtr* typeInstArgs = typeInstantiationContext, methodInstArgs = methodInstantiationContext) { - return ResolveMethod(new QCallModule(ref module), methodToken, typeInstArgs, typeInstantiationContext.Length, methodInstArgs, methodInstantiationContext.Length, out _); + return ResolveMethod(new QCallModule(ref module), methodToken, typeInstArgs, typeInstantiationContext.Length, methodInstArgs, methodInstantiationContext.Length); } } catch (Exception) @@ -1957,14 +1996,14 @@ internal static RuntimeMethodHandleInternal ResolveMethodHandleInternal(RuntimeM } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleHandle_ResolveMethod")] private static partial RuntimeMethodHandleInternal ResolveMethod(QCallModule module, int methodToken, IntPtr* typeInstArgs, int typeInstCount, IntPtr* methodInstArgs, - int methodInstCount, - out QCallExceptionStatus qcallException); + int methodInstCount); // SQL-CLR LKG9 Compiler dependency [RequiresUnreferencedCode("Trimming changes metadata tokens")] @@ -1997,7 +2036,7 @@ public RuntimeFieldHandle ResolveFieldHandle(int fieldToken, RuntimeTypeHandle[] try { IRuntimeFieldInfo? field = null; - ResolveField(new QCallModule(ref module), fieldToken, typeInstArgs, typeInstantiationContextHandles.Length, methodInstArgs, methodInstantiationContextHandles.Length, ObjectHandleOnStack.Create(ref field), out _); + ResolveField(new QCallModule(ref module), fieldToken, typeInstArgs, typeInstantiationContextHandles.Length, methodInstArgs, methodInstantiationContextHandles.Length, ObjectHandleOnStack.Create(ref field)); GC.KeepAlive(typeInstantiationContext); GC.KeepAlive(methodInstantiationContext); return new RuntimeFieldHandle(field!); @@ -2012,6 +2051,7 @@ public RuntimeFieldHandle ResolveFieldHandle(int fieldToken, RuntimeTypeHandle[] } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleHandle_ResolveField")] private static partial void ResolveField(QCallModule module, int fieldToken, @@ -2019,27 +2059,28 @@ private static partial void ResolveField(QCallModule module, int typeInstCount, IntPtr* methodInstArgs, int methodInstCount, - ObjectHandleOnStack retField, - out QCallExceptionStatus qcallException); + ObjectHandleOnStack retField); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleHandle_GetModuleType")] - internal static partial void GetModuleType(QCallModule handle, ObjectHandleOnStack type, out QCallExceptionStatus qcallException); + internal static partial void GetModuleType(QCallModule handle, ObjectHandleOnStack type); internal static RuntimeType GetModuleType(RuntimeModule module) { RuntimeType? type = null; - GetModuleType(new QCallModule(ref module), ObjectHandleOnStack.Create(ref type), out _); + GetModuleType(new QCallModule(ref module), ObjectHandleOnStack.Create(ref type)); return type!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleHandle_GetPEKind")] - private static partial void GetPEKind(QCallModule handle, int* peKind, int* machine, out QCallExceptionStatus qcallException); + private static partial void GetPEKind(QCallModule handle, int* peKind, int* machine); // making this internal, used by Module.GetPEKind internal static void GetPEKind(RuntimeModule module, out PortableExecutableKinds peKind, out ImageFileMachine machine) { int lKind, lMachine; - GetPEKind(new QCallModule(ref module), &lKind, &lMachine, out _); + GetPEKind(new QCallModule(ref module), &lKind, &lMachine); peKind = (PortableExecutableKinds)lKind; machine = (ImageFileMachine)lMachine; } @@ -2075,13 +2116,13 @@ internal sealed unsafe partial class Signature private RuntimeMethodHandleInternal _pMethod; #endregion + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Signature_Init")] private static partial void Init( ObjectHandleOnStack _this, void* pCorSig, int cCorSig, RuntimeFieldHandleInternal fieldHandle, - RuntimeMethodHandleInternal methodHandle, - out QCallExceptionStatus qcallException); + RuntimeMethodHandleInternal methodHandle); [MemberNotNull(nameof(_returnTypeORfieldType))] private void Init( @@ -2093,8 +2134,7 @@ private void Init( Init(ObjectHandleOnStack.Create(ref _this), pCorSig, cCorSig, fieldHandle, - methodHandle, - out _); + methodHandle); Debug.Assert(_returnTypeORfieldType != null); } @@ -2150,18 +2190,17 @@ internal RuntimeType[] Arguments internal RuntimeType ReturnType => _returnTypeORfieldType; internal RuntimeType FieldType => _returnTypeORfieldType; + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Signature_AreEqual")] private static partial Interop.BOOL AreEqual( void* sig1, int csig1, QCallTypeHandle type1, - void* sig2, int csig2, QCallTypeHandle type2, - out QCallExceptionStatus qcallException); + void* sig2, int csig2, QCallTypeHandle type2); internal static bool AreEqual(Signature sig1, Signature sig2) { return AreEqual( sig1._sig, sig1._csig, new QCallTypeHandle(ref sig1._declaringType), - sig2._sig, sig2._csig, new QCallTypeHandle(ref sig2._declaringType), - out _) != Interop.BOOL.FALSE; + sig2._sig, sig2._csig, new QCallTypeHandle(ref sig2._declaringType)) != Interop.BOOL.FALSE; } [MethodImpl(MethodImplOptions.InternalCall)] @@ -2215,13 +2254,13 @@ internal SignatureCallingConvention GetCallingConventionFromFunctionPointerAtOff internal Type[] GetCustomModifiers(int parameterIndex, bool required) => GetCustomModifiersAtOffset(GetParameterOffset(parameterIndex), required); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Signature_GetCustomModifiersAtOffset")] private static partial void GetCustomModifiersAtOffset( ObjectHandleOnStack sigObj, int offset, Interop.BOOL required, - ObjectHandleOnStack result, - out QCallExceptionStatus qcallException); + ObjectHandleOnStack result); internal Type[] GetCustomModifiersAtOffset(int offset, bool required) { @@ -2231,8 +2270,7 @@ internal Type[] GetCustomModifiersAtOffset(int offset, bool required) ObjectHandleOnStack.Create(ref _this), offset, required ? Interop.BOOL.TRUE : Interop.BOOL.FALSE, - ObjectHandleOnStack.Create(ref result), - out _); + ObjectHandleOnStack.Create(ref result)); return result!; } #endregion diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.BoxCache.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.BoxCache.cs index 5c427ab5ee670a..59078611610d4d 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.BoxCache.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.BoxCache.cs @@ -122,8 +122,7 @@ private static void GetBoxInfo( GetBoxInfo( new QCallTypeHandle(ref rt), &pfnAllocatorTemp, &vAllocatorFirstArgTemp, - &nullableValueOffsetTemp, &valueTypeSizeTemp, - out _); + &nullableValueOffsetTemp, &valueTypeSizeTemp); pfnAllocator = pfnAllocatorTemp; vAllocatorFirstArg = vAllocatorFirstArgTemp; @@ -131,14 +130,14 @@ private static void GetBoxInfo( valueTypeSize = valueTypeSizeTemp; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ReflectionInvocation_GetBoxInfo")] private static partial void GetBoxInfo( QCallTypeHandle type, delegate** ppfnAllocator, void** pvAllocatorFirstArg, int* pNullableValueOffset, - uint* pValueTypeSize, - out QCallExceptionStatus qcallException); + uint* pValueTypeSize); } internal object? Box(ref byte data) diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs index 4f99059e63f54c..4e5cb256acbe6f 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs @@ -1651,7 +1651,7 @@ RuntimeType CacheGenericDefinition() else { RuntimeType type = m_runtimeType; - RuntimeTypeHandle.GetGenericTypeDefinition(new QCallTypeHandle(ref type), ObjectHandleOnStack.Create(ref genericDefinition), out _); + RuntimeTypeHandle.GetGenericTypeDefinition(new QCallTypeHandle(ref type), ObjectHandleOnStack.Create(ref genericDefinition)); } return _genericTypeDefinition = genericDefinition; } @@ -3407,15 +3407,16 @@ public override unsafe Guid GUID else #endif // FEATURE_COMINTEROP { - GetGuid(th.AsMethodTable(), &result, out _); + GetGuid(th.AsMethodTable(), &result); } GC.KeepAlive(this); // Ensure TypeHandle remains alive. return result; } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ReflectionInvocation_GetGuid")] - private static unsafe partial void GetGuid(MethodTable* pMT, Guid* result, out QCallExceptionStatus qcallException); + private static unsafe partial void GetGuid(MethodTable* pMT, Guid* result); #if FEATURE_COMINTEROP [MethodImpl(MethodImplOptions.NoInlining)] @@ -3423,11 +3424,12 @@ private static unsafe void GetComObjectGuidWorker(RuntimeType type, Guid* result { Debug.Assert(type.IsGenericCOMObjectImpl()); Debug.Assert(result is not null); - GetComObjectGuid(ObjectHandleOnStack.Create(ref type), result, out _); + GetComObjectGuid(ObjectHandleOnStack.Create(ref type), result); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ReflectionInvocation_GetComObjectGuid")] - private static unsafe partial void GetComObjectGuid(ObjectHandleOnStack type, Guid* result, out QCallExceptionStatus qcallException); + private static unsafe partial void GetComObjectGuid(ObjectHandleOnStack type, Guid* result); #endif // FEATURE_COMINTEROP protected override unsafe bool IsValueTypeImpl() @@ -4136,6 +4138,7 @@ internal void CallDefaultStructConstructor(ref byte data) #endregion #if FEATURE_COMINTEROP + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ReflectionInvocation_InvokeDispMethod")] private static partial void InvokeDispMethod( ObjectHandleOnStack type, @@ -4146,8 +4149,7 @@ private static partial void InvokeDispMethod( ObjectHandleOnStack byrefModifiers, int lcid, ObjectHandleOnStack namedParameters, - ObjectHandleOnStack result, - out QCallExceptionStatus qcallException); + ObjectHandleOnStack result); private object InvokeDispMethod( string name, @@ -4169,8 +4171,7 @@ private object InvokeDispMethod( ObjectHandleOnStack.Create(ref byrefModifiers), culture, ObjectHandleOnStack.Create(ref namedParameters), - ObjectHandleOnStack.Create(ref result), - out _); + ObjectHandleOnStack.Create(ref result)); return result!; } @@ -4368,9 +4369,10 @@ private enum DispatchWrapperType : int #region Library internal readonly unsafe partial struct MdUtf8String { + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MdUtf8String_EqualsCaseInsensitive")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool EqualsCaseInsensitive(void* szLhs, void* szRhs, int cSz, out QCallExceptionStatus qcallException); + private static partial bool EqualsCaseInsensitive(void* szLhs, void* szRhs, int cSz); private readonly byte* m_pStringHeap; // This is the raw UTF8 string. private readonly int m_StringHeapByteLength; @@ -4418,7 +4420,7 @@ internal bool EqualsCaseInsensitive(MdUtf8String s) } else { - return (m_StringHeapByteLength == 0) || EqualsCaseInsensitive(s.m_pStringHeap, m_pStringHeap, m_StringHeapByteLength, out _); + return (m_StringHeapByteLength == 0) || EqualsCaseInsensitive(s.m_pStringHeap, m_pStringHeap, m_StringHeapByteLength); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CreateUninitializedCache.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CreateUninitializedCache.CoreCLR.cs index d4aa0a407df58f..39e7a2801cc573 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CreateUninitializedCache.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CreateUninitializedCache.CoreCLR.cs @@ -69,19 +69,18 @@ private static void GetCreateUninitializedInfo( GetCreateUninitializedInfo( new QCallTypeHandle(ref rt), - &pfnAllocatorTemp, &vAllocatorFirstArgTemp, - out _); + &pfnAllocatorTemp, &vAllocatorFirstArgTemp); pfnAllocator = pfnAllocatorTemp; vAllocatorFirstArg = vAllocatorFirstArgTemp; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ReflectionSerialization_GetCreateUninitializedObjectInfo")] private static partial void GetCreateUninitializedInfo( QCallTypeHandle type, delegate** ppfnAllocator, - void** pvAllocatorFirstArg, - out QCallExceptionStatus qcallException); + void** pvAllocatorFirstArg); } } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/String.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/String.CoreCLR.cs index 5165db97afa454..1b30862f88f118 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/String.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/String.CoreCLR.cs @@ -22,23 +22,25 @@ internal static unsafe string FastAllocateString(nint length) return FastAllocateString(TypeHandle.TypeHandleOf().AsMethodTable(), length); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "String_Intern")] - private static partial void Intern(StringHandleOnStack src, out QCallExceptionStatus qcallException); + private static partial void Intern(StringHandleOnStack src); public static string Intern(string str) { ArgumentNullException.ThrowIfNull(str); - Intern(new StringHandleOnStack(ref str!), out _); + Intern(new StringHandleOnStack(ref str!)); return str; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "String_IsInterned")] - private static partial void IsInterned(StringHandleOnStack src, out QCallExceptionStatus qcallException); + private static partial void IsInterned(StringHandleOnStack src); public static string? IsInterned(string str) { ArgumentNullException.ThrowIfNull(str); - IsInterned(new StringHandleOnStack(ref str!), out _); + IsInterned(new StringHandleOnStack(ref str!)); return str; } diff --git a/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs index 38b4609bfe7885..67e61da11fb5ae 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs @@ -535,21 +535,23 @@ internal static partial class ObjectMarshaler { internal static void ConvertToNative(object objSrc, IntPtr pDstVariant) { - ConvertToNative(ObjectHandleOnStack.Create(ref objSrc), pDstVariant, out _); + ConvertToNative(ObjectHandleOnStack.Create(ref objSrc), pDstVariant); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjectMarshaler_ConvertToNative")] - private static partial void ConvertToNative(ObjectHandleOnStack objSrc, IntPtr pDstVariant, out QCallExceptionStatus qcallException); + private static partial void ConvertToNative(ObjectHandleOnStack objSrc, IntPtr pDstVariant); internal static object ConvertToManaged(IntPtr pSrcVariant) { object? retObject = null; - ConvertToManaged(pSrcVariant, ObjectHandleOnStack.Create(ref retObject), out _); + ConvertToManaged(pSrcVariant, ObjectHandleOnStack.Create(ref retObject)); return retObject!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjectMarshaler_ConvertToManaged")] - private static partial void ConvertToManaged(IntPtr pSrcVariant, ObjectHandleOnStack retObject, out QCallExceptionStatus qcallException); + private static partial void ConvertToManaged(IntPtr pSrcVariant, ObjectHandleOnStack retObject); internal static unsafe void ClearNative(IntPtr pVariant) { @@ -628,11 +630,12 @@ internal static IntPtr ConvertToNative(object? objSrc, IntPtr itfMT, IntPtr clas if (objSrc == null) return IntPtr.Zero; - return ConvertToNative(ObjectHandleOnStack.Create(ref objSrc), itfMT, classMT, flags, out _); + return ConvertToNative(ObjectHandleOnStack.Create(ref objSrc), itfMT, classMT, flags); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "InterfaceMarshaler_ConvertToNative")] - private static partial IntPtr ConvertToNative(ObjectHandleOnStack objSrc, IntPtr itfMT, IntPtr classMT, int flag, out QCallExceptionStatus qcallException); + private static partial IntPtr ConvertToNative(ObjectHandleOnStack objSrc, IntPtr itfMT, IntPtr classMT, int flag); internal static object? ConvertToManaged(ref IntPtr ppUnk, IntPtr itfMT, IntPtr classMT, int flags) { @@ -640,12 +643,13 @@ internal static IntPtr ConvertToNative(object? objSrc, IntPtr itfMT, IntPtr clas return null; object? retObject = null; - ConvertToManaged(ref ppUnk, itfMT, classMT, flags, ObjectHandleOnStack.Create(ref retObject), out _); + ConvertToManaged(ref ppUnk, itfMT, classMT, flags, ObjectHandleOnStack.Create(ref retObject)); return retObject; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "InterfaceMarshaler_ConvertToManaged")] - private static partial void ConvertToManaged(ref IntPtr ppUnk, IntPtr itfMT, IntPtr classMT, int flags, ObjectHandleOnStack retObject, out QCallExceptionStatus qcallException); + private static partial void ConvertToManaged(ref IntPtr ppUnk, IntPtr itfMT, IntPtr classMT, int flags, ObjectHandleOnStack retObject); internal static void ClearNative(IntPtr pUnk) { @@ -658,20 +662,17 @@ internal static void ClearNative(IntPtr pUnk) internal static object GetObjectForComCallableWrapperIUnknown(IntPtr unk) { object? retObject = null; - GetObjectForComCallableWrapperIUnknown(unk, ObjectHandleOnStack.Create(ref retObject), out _); + GetObjectForComCallableWrapperIUnknown(unk, ObjectHandleOnStack.Create(ref retObject)); return retObject!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "InterfaceMarshaler_GetObjectForComCallableWrapperIUnknown")] - private static partial void GetObjectForComCallableWrapperIUnknown(IntPtr unk, ObjectHandleOnStack retObject, out QCallExceptionStatus qcallException); + private static partial void GetObjectForComCallableWrapperIUnknown(IntPtr unk, ObjectHandleOnStack retObject); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "InterfaceMarshaler_ValidateComVisibilityForIUnknown")] - internal static partial void ValidateComVisibilityForIUnknown(IntPtr unk, out QCallExceptionStatus qcallException); - - internal static void ValidateComVisibilityForIUnknown(IntPtr unk) - { - ValidateComVisibilityForIUnknown(unk, out _); - } + internal static partial void ValidateComVisibilityForIUnknown(IntPtr unk); } // class InterfaceMarshaler #endif // FEATURE_COMINTEROP @@ -686,50 +687,55 @@ internal static partial class MngdSafeArrayMarshaler internal static void ConvertSpaceToNative(IntPtr pMarshalState, in object pManagedHome, IntPtr pNativeHome) { object managedHome = pManagedHome; - ConvertSpaceToNative(pMarshalState, ObjectHandleOnStack.Create(ref managedHome), pNativeHome, out _); + ConvertSpaceToNative(pMarshalState, ObjectHandleOnStack.Create(ref managedHome), pNativeHome); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MngdSafeArrayMarshaler_ConvertSpaceToNative")] - private static partial void ConvertSpaceToNative(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome, out QCallExceptionStatus qcallException); + private static partial void ConvertSpaceToNative(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome); internal static void ConvertContentsToNative(IntPtr pMarshalState, in object pManagedHome, IntPtr pNativeHome, object pOriginalManagedObject) { object managedHome = pManagedHome; object originalManagedObject = pOriginalManagedObject; - ConvertContentsToNative(pMarshalState, ObjectHandleOnStack.Create(ref managedHome), pNativeHome, ObjectHandleOnStack.Create(ref originalManagedObject), out _); + ConvertContentsToNative(pMarshalState, ObjectHandleOnStack.Create(ref managedHome), pNativeHome, ObjectHandleOnStack.Create(ref originalManagedObject)); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MngdSafeArrayMarshaler_ConvertContentsToNative")] - private static partial void ConvertContentsToNative(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome, ObjectHandleOnStack pOriginalManagedObject, out QCallExceptionStatus qcallException); + private static partial void ConvertContentsToNative(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome, ObjectHandleOnStack pOriginalManagedObject); internal static void ConvertSpaceToManaged(IntPtr pMarshalState, ref object? pManagedHome, IntPtr pNativeHome) { object? managedHome = null; - ConvertSpaceToManaged(pMarshalState, ObjectHandleOnStack.Create(ref managedHome), pNativeHome, out _); + ConvertSpaceToManaged(pMarshalState, ObjectHandleOnStack.Create(ref managedHome), pNativeHome); pManagedHome = managedHome; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MngdSafeArrayMarshaler_ConvertSpaceToManaged")] - private static partial void ConvertSpaceToManaged(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome, out QCallExceptionStatus qcallException); + private static partial void ConvertSpaceToManaged(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome); internal static void ConvertContentsToManaged(IntPtr pMarshalState, in object pManagedHome, IntPtr pNativeHome) { object managedHome = pManagedHome; - ConvertContentsToManaged(pMarshalState, ObjectHandleOnStack.Create(ref managedHome), pNativeHome, out _); + ConvertContentsToManaged(pMarshalState, ObjectHandleOnStack.Create(ref managedHome), pNativeHome); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MngdSafeArrayMarshaler_ConvertContentsToManaged")] - private static partial void ConvertContentsToManaged(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome, out QCallExceptionStatus qcallException); + private static partial void ConvertContentsToManaged(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome); #pragma warning disable IDE0060 // Remove unused parameter. These APIs need to match a the shape of a "managed" marshaler. internal static void ClearNative(IntPtr pMarshalState, in object pManagedHome, IntPtr pNativeHome) { - ClearNative(pMarshalState, pNativeHome, out _); + ClearNative(pMarshalState, pNativeHome); } #pragma warning restore IDE0060 // Remove unused parameter + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MngdSafeArrayMarshaler_ClearNative")] - private static partial void ClearNative(IntPtr pMarshalState, IntPtr pNativeHome, out QCallExceptionStatus qcallException); + private static partial void ClearNative(IntPtr pMarshalState, IntPtr pNativeHome); } // class MngdSafeArrayMarshaler #endif // FEATURE_COMINTEROP @@ -1404,7 +1410,7 @@ private static void Validate() { Debug.Assert(typeof(T).IsValueType, "StructureMarshaler can only be used for value types"); RuntimeType type = (RuntimeType)typeof(T); - bool hasLayout = Marshal.HasLayout(new QCallTypeHandle(ref type), out bool isBlittable, out int _, out _); + bool hasLayout = Marshal.HasLayout(new QCallTypeHandle(ref type), out bool isBlittable, out int _); Debug.Assert(hasLayout, "Non-layout classes should not use the layout class marshaler."); Debug.Assert(isBlittable, "Non-blittable structs should have a custom IL body generated with the marshaling logic."); } @@ -1478,7 +1484,7 @@ private static class Methods static Methods() { RuntimeTypeHandle th = typeof(T).TypeHandle; - bool hasLayout = Marshal.HasLayout(new QCallTypeHandle(ref th), out bool isBlittable, out int nativeSize, out _); + bool hasLayout = Marshal.HasLayout(new QCallTypeHandle(ref th), out bool isBlittable, out int nativeSize); Debug.Assert(hasLayout, "Non-layout classes should not use the layout class marshaler."); s_unmanagedSize = (nuint)nativeSize; if (isBlittable) @@ -1489,7 +1495,7 @@ static Methods() } else { - StubHelpers.CreateLayoutClassMarshalStubs(new QCallTypeHandle(ref th), out _convertToUnmanaged, out _convertToManaged, out _free, out _); + StubHelpers.CreateLayoutClassMarshalStubs(new QCallTypeHandle(ref th), out _convertToUnmanaged, out _convertToManaged, out _free); } } #pragma warning restore CA1810 @@ -2181,11 +2187,9 @@ internal static partial class StubHelpers internal static extern safe void SetLastError(); /// QCall that throws an interop parameter exception selected by integer resource and parameter indices; it accesses no caller-supplied memory. + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_ThrowInteropParamException")] - internal static safe partial void ThrowInteropParamException(int resID, int paramIdx, out QCallExceptionStatus qcallException); - - internal static safe void ThrowInteropParamException(int resID, int paramIdx) - => ThrowInteropParamException(resID, paramIdx, out _); + internal static safe partial void ThrowInteropParamException(int resID, int paramIdx); internal static IntPtr AddToCleanupList(ref CleanupWorkListElement? pCleanupWorkList, SafeHandle handle) { @@ -2245,8 +2249,9 @@ internal static void SetPendingExceptionObject(Exception? exception) s_pendingExceptionObject = exception; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_CreateCustomMarshaler")] - internal static partial void CreateCustomMarshaler(IntPtr pMD, int paramToken, IntPtr hndManagedType, ObjectHandleOnStack customMarshaler, out QCallExceptionStatus qcallException); + internal static partial void CreateCustomMarshaler(IntPtr pMD, int paramToken, IntPtr hndManagedType, ObjectHandleOnStack customMarshaler); #if FEATURE_COMINTEROP [SupportedOSPlatform("windows")] @@ -2317,7 +2322,7 @@ internal static object CreateCustomMarshaler(IntPtr pMD, int paramToken, IntPtr #endif object? retVal = null; - CreateCustomMarshaler(pMD, paramToken, hndManagedType, ObjectHandleOnStack.Create(ref retVal), out _); + CreateCustomMarshaler(pMD, paramToken, hndManagedType, ObjectHandleOnStack.Create(ref retVal)); return retVal!; } @@ -2352,8 +2357,9 @@ internal static void SafeHandleRelease(SafeHandle pHandle) [MethodImpl(MethodImplOptions.InternalCall)] private static extern IntPtr GetCOMIPFromRCW(object objSrc, IntPtr pCPCMD, out IntPtr ppTarget); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_GetCOMIPFromRCWSlow")] - private static partial IntPtr GetCOMIPFromRCWSlow(ObjectHandleOnStack objSrc, IntPtr pCPCMD, out IntPtr ppTarget, [MarshalAs(UnmanagedType.Bool)] out bool pfNeedsRelease, out QCallExceptionStatus qcallException); + private static partial IntPtr GetCOMIPFromRCWSlow(ObjectHandleOnStack objSrc, IntPtr pCPCMD, out IntPtr ppTarget, [MarshalAs(UnmanagedType.Bool)] out bool pfNeedsRelease); internal static IntPtr GetCOMIPFromRCW(object objSrc, IntPtr pCPCMD, out IntPtr ppTarget, out bool pfNeedsRelease) { @@ -2370,7 +2376,7 @@ internal static IntPtr GetCOMIPFromRCW(object objSrc, IntPtr pCPCMD, out IntPtr [MethodImpl(MethodImplOptions.NoInlining)] static IntPtr GetCOMIPFromRCWWorker(object objSrc, IntPtr pCPCMD, out IntPtr ppTarget, out bool pfNeedsRelease) - => GetCOMIPFromRCWSlow(ObjectHandleOnStack.Create(ref objSrc), pCPCMD, out ppTarget, out pfNeedsRelease, out _); + => GetCOMIPFromRCWSlow(ObjectHandleOnStack.Create(ref objSrc), pCPCMD, out ppTarget, out pfNeedsRelease); } #endif // FEATURE_COMINTEROP @@ -2378,17 +2384,13 @@ static IntPtr GetCOMIPFromRCWWorker(object objSrc, IntPtr pCPCMD, out IntPtr ppT //------------------------------------------------------- // Profiler helpers //------------------------------------------------------- + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_ProfilerBeginTransitionCallback")] - internal static unsafe partial void* ProfilerBeginTransitionCallback(void* pTargetMD, out QCallExceptionStatus qcallException); - - internal static unsafe void* ProfilerBeginTransitionCallback(void* pTargetMD) - => ProfilerBeginTransitionCallback(pTargetMD, out _); + internal static unsafe partial void* ProfilerBeginTransitionCallback(void* pTargetMD); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_ProfilerEndTransitionCallback")] - internal static unsafe partial void ProfilerEndTransitionCallback(void* pTargetMD, out QCallExceptionStatus qcallException); - - internal static unsafe void ProfilerEndTransitionCallback(void* pTargetMD) - => ProfilerEndTransitionCallback(pTargetMD, out _); + internal static unsafe partial void ProfilerEndTransitionCallback(void* pTargetMD); #endif // PROFILING_SUPPORTED //------------------------------------------------------ @@ -2407,8 +2409,9 @@ internal static void CheckStringLength(uint length) } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_CreateLayoutClassMarshalStubs")] - internal static unsafe partial void CreateLayoutClassMarshalStubs(QCallTypeHandle th, out delegate* pConvertToUnmanaged, out delegate* pConvertToManaged, out delegate* pFree, out QCallExceptionStatus qcallException); + internal static unsafe partial void CreateLayoutClassMarshalStubs(QCallTypeHandle th, out delegate* pConvertToUnmanaged, out delegate* pConvertToManaged, out delegate* pFree); internal static unsafe void LayoutTypeConvertToUnmanaged(object obj, byte* pNative, ref CleanupWorkListElement? pCleanupWorkList) { @@ -2520,17 +2523,13 @@ internal static void ThrowWrongSizeArrayInNativeStruct() throw new ArgumentException(SR.Argument_WrongSizeArrayInNativeStruct); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_MarshalToManagedVaList")] - internal static partial void MarshalToManagedVaList(IntPtr va_list, IntPtr pArgIterator, out QCallExceptionStatus qcallException); - - internal static void MarshalToManagedVaList(IntPtr va_list, IntPtr pArgIterator) - => MarshalToManagedVaList(va_list, pArgIterator, out _); + internal static partial void MarshalToManagedVaList(IntPtr va_list, IntPtr pArgIterator); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_MarshalToUnmanagedVaList")] - internal static partial void MarshalToUnmanagedVaList(IntPtr va_list, uint vaListSize, IntPtr pArgIterator, out QCallExceptionStatus qcallException); - - internal static void MarshalToUnmanagedVaList(IntPtr va_list, uint vaListSize, IntPtr pArgIterator) - => MarshalToUnmanagedVaList(va_list, vaListSize, pArgIterator, out _); + internal static partial void MarshalToUnmanagedVaList(IntPtr va_list, uint vaListSize, IntPtr pArgIterator); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern uint CalcVaListSize(IntPtr va_list); @@ -2538,17 +2537,16 @@ internal static void MarshalToUnmanagedVaList(IntPtr va_list, uint vaListSize, I [MethodImpl(MethodImplOptions.InternalCall)] internal static extern void LogPinnedArgument(IntPtr localDesc, IntPtr nativeArg); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_ValidateObject")] - private static partial void ValidateObject(ObjectHandleOnStack obj, IntPtr pMD, out QCallExceptionStatus qcallException); + private static partial void ValidateObject(ObjectHandleOnStack obj, IntPtr pMD); internal static void ValidateObject(object obj, IntPtr pMD) - => ValidateObject(ObjectHandleOnStack.Create(ref obj), pMD, out _); + => ValidateObject(ObjectHandleOnStack.Create(ref obj), pMD); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_ValidateByref")] - internal static partial void ValidateByref(IntPtr byref, IntPtr pMD, out QCallExceptionStatus qcallException); // the byref is pinned so we can safely "cast" it to IntPtr - - internal static void ValidateByref(IntPtr byref, IntPtr pMD) - => ValidateByref(byref, pMD, out _); + internal static partial void ValidateByref(IntPtr byref, IntPtr pMD); // the byref is pinned so we can safely "cast" it to IntPtr [Intrinsic] internal static IntPtr GetStubContext() => throw new UnreachableException(); // Unconditionally expanded intrinsic @@ -2556,11 +2554,12 @@ internal static void ValidateByref(IntPtr byref, IntPtr pMD) [MethodImpl(MethodImplOptions.NoInlining)] internal static void MulticastDebuggerTraceHelper(object o, int count) { - MulticastDebuggerTraceHelperQCall(ObjectHandleOnStack.Create(ref o), count, out _); + MulticastDebuggerTraceHelperQCall(ObjectHandleOnStack.Create(ref o), count); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_MulticastDebuggerTraceHelper")] - private static partial void MulticastDebuggerTraceHelperQCall(ObjectHandleOnStack obj, int count, out QCallExceptionStatus qcallException); + private static partial void MulticastDebuggerTraceHelperQCall(ObjectHandleOnStack obj, int count); [Intrinsic] internal static IntPtr NextCallReturnAddress() => throw new UnreachableException(); // Unconditionally expanded intrinsic diff --git a/src/coreclr/System.Private.CoreLib/src/System/Threading/ObjectHeader.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Threading/ObjectHeader.CoreCLR.cs index cc93dc7df8f7c8..ec3891fa11c48a 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Threading/ObjectHeader.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Threading/ObjectHeader.CoreCLR.cs @@ -80,7 +80,7 @@ static Lock GetLockObjectFallback(object obj) #pragma warning disable CS9216 // A value of type 'System.Threading.Lock' converted to a different type will use likely unintended monitor-based locking in 'lock' statement. object lockObj = new Lock(); #pragma warning restore CS9216 - GetOrCreateLockObject(ObjectHandleOnStack.Create(ref obj), ObjectHandleOnStack.Create(ref lockObj), out _); + GetOrCreateLockObject(ObjectHandleOnStack.Create(ref obj), ObjectHandleOnStack.Create(ref lockObj)); return (Lock)lockObj!; } } @@ -88,8 +88,9 @@ static Lock GetLockObjectFallback(object obj) [MethodImpl(MethodImplOptions.InternalCall)] private static extern IntPtr GetLockHandleIfExists(object obj); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjectHeader_GetOrCreateLockObject")] - private static partial void GetOrCreateLockObject(ObjectHandleOnStack obj, ObjectHandleOnStack lockObj, out QCallExceptionStatus qcallException); + private static partial void GetOrCreateLockObject(ObjectHandleOnStack obj, ObjectHandleOnStack lockObj); // // A few words about spinning choices: diff --git a/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs index 557495f1ec424a..f3905111f54321 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs @@ -57,8 +57,16 @@ public sealed partial class Thread private Thread() { } - [MethodImpl(MethodImplOptions.InternalCall)] - internal static extern Exception GetAndClearQCallException(); + internal static Exception GetQCallSpecialException(nint status) + { + Exception? exception = null; + GetQCallSpecialException(status, ObjectHandleOnStack.Create(ref exception)); + return exception!; + } + + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetQCallSpecialException")] + private static partial void GetQCallSpecialException(nint status, ObjectHandleOnStack exception); public int ManagedThreadId { @@ -87,7 +95,7 @@ private unsafe void StartCore() fixed (char* pThreadName = _name) { Exception? exception = null; - if (StartInternal(GetNativeHandle(), _startHelper?._maxStackSize ?? 0, _priority, _isThreadPool ? Interop.BOOL.TRUE : Interop.BOOL.FALSE, pThreadName, ObjectHandleOnStack.Create(ref exception), out _) == Interop.BOOL.FALSE) + if (StartInternal(GetNativeHandle(), _startHelper?._maxStackSize ?? 0, _priority, _isThreadPool ? Interop.BOOL.TRUE : Interop.BOOL.FALSE, pThreadName, ObjectHandleOnStack.Create(ref exception)) == Interop.BOOL.FALSE) { throw new ThreadStartException(exception); } @@ -95,8 +103,9 @@ private unsafe void StartCore() } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_Start")] - private static unsafe partial Interop.BOOL StartInternal(ThreadHandle t, int stackSize, int priority, Interop.BOOL isThreadPool, char* pThreadName, ObjectHandleOnStack exception, out QCallExceptionStatus qcallException); + private static unsafe partial Interop.BOOL StartInternal(ThreadHandle t, int stackSize, int priority, Interop.BOOL isThreadPool, char* pThreadName, ObjectHandleOnStack exception); [UnmanagedCallersOnly] private static unsafe void StartCallback(Thread* pThread) @@ -145,30 +154,33 @@ public static void SpinWait(int iterations) } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_YieldThread")] - private static partial Interop.BOOL YieldInternal(out QCallExceptionStatus qcallException); + private static partial Interop.BOOL YieldInternal(); - public static bool Yield() => YieldInternal(out _) != Interop.BOOL.FALSE; + public static bool Yield() => YieldInternal() != Interop.BOOL.FALSE; [MethodImpl(MethodImplOptions.NoInlining)] private static Thread InitializeCurrentThread() { Thread? thread = null; - GetCurrentThread(ObjectHandleOnStack.Create(ref thread), out _); + GetCurrentThread(ObjectHandleOnStack.Create(ref thread)); return t_currentThread = thread!; } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetCurrentThread")] - private static partial void GetCurrentThread(ObjectHandleOnStack thread, out QCallExceptionStatus qcallException); + private static partial void GetCurrentThread(ObjectHandleOnStack thread); private void Initialize() { Thread _this = this; - Initialize(ObjectHandleOnStack.Create(ref _this), out _); + Initialize(ObjectHandleOnStack.Create(ref _this)); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_Initialize")] - private static partial void Initialize(ObjectHandleOnStack thread, out QCallExceptionStatus qcallException); + private static partial void Initialize(ObjectHandleOnStack thread); /// Clean up the thread when it goes away. ~Thread() => InternalFinalize(); // Delegate to the unmanaged portion. @@ -178,12 +190,13 @@ private void Initialize() private void ThreadNameChanged(string? value) { - InformThreadNameChange(GetNativeHandle(), value, value?.Length ?? 0, out _); + InformThreadNameChange(GetNativeHandle(), value, value?.Length ?? 0); GC.KeepAlive(this); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_InformThreadNameChange", StringMarshalling = StringMarshalling.Utf16)] - private static partial void InformThreadNameChange(ThreadHandle t, string? name, int len, out QCallExceptionStatus qcallException); + private static partial void InformThreadNameChange(ThreadHandle t, string? name, int len); /// Returns true if the thread has been started and is not dead. public bool IsAlive => (ThreadState & (ThreadState.Unstarted | ThreadState.Stopped | ThreadState.Aborted)) == 0; @@ -212,7 +225,7 @@ public bool IsBackground throw new ThreadStateException(SR.ThreadState_Dead_State); } - SetIsBackground(GetNativeHandle(), value ? Interop.BOOL.TRUE : Interop.BOOL.FALSE, out _); + SetIsBackground(GetNativeHandle(), value ? Interop.BOOL.TRUE : Interop.BOOL.FALSE); GC.KeepAlive(this); if (!value) { @@ -225,8 +238,9 @@ public bool IsBackground [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetIsBackground")] private static partial Interop.BOOL GetIsBackground(ThreadHandle t); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_SetIsBackground")] - private static partial void SetIsBackground(ThreadHandle t, Interop.BOOL value, out QCallExceptionStatus qcallException); + private static partial void SetIsBackground(ThreadHandle t, Interop.BOOL value); /// Returns true if the thread is a threadpool thread. public bool IsThreadPoolThread @@ -253,9 +267,10 @@ internal set } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_SetPriority")] [return: MarshalAs(UnmanagedType.Bool)] - private static partial void SetPriority(ObjectHandleOnStack thread, int priority, out QCallExceptionStatus qcallException); + private static partial void SetPriority(ObjectHandleOnStack thread, int priority); /// Returns the priority of the thread. public ThreadPriority Priority @@ -271,13 +286,14 @@ public ThreadPriority Priority set { Thread _this = this; - SetPriority(ObjectHandleOnStack.Create(ref _this), (int)value, out _); + SetPriority(ObjectHandleOnStack.Create(ref _this), (int)value); _mayNeedResetForThreadPool = true; } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetCurrentOSThreadId")] - private static partial ulong GetCurrentOSThreadId(out QCallExceptionStatus qcallException); + private static partial ulong GetCurrentOSThreadId(); /// /// Return the thread state as a consistent set of bits. This is more @@ -323,16 +339,18 @@ internal unsafe void ClearWaitSleepJoinState() /// single-threaded or multi-threaded apartment. /// #if FEATURE_COMINTEROP_APARTMENT_SUPPORT + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetApartmentState")] - private static partial int GetApartmentState(ObjectHandleOnStack t, out QCallExceptionStatus qcallException); + private static partial int GetApartmentState(ObjectHandleOnStack t); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_SetApartmentState")] - private static partial int SetApartmentState(ObjectHandleOnStack t, int state, out QCallExceptionStatus qcallException); + private static partial int SetApartmentState(ObjectHandleOnStack t, int state); public ApartmentState GetApartmentState() { Thread _this = this; - return (ApartmentState)GetApartmentState(ObjectHandleOnStack.Create(ref _this), out _); + return (ApartmentState)GetApartmentState(ObjectHandleOnStack.Create(ref _this)); } private bool SetApartmentStateUnchecked(ApartmentState state, bool throwOnError) @@ -341,7 +359,7 @@ private bool SetApartmentStateUnchecked(ApartmentState state, bool throwOnError) lock (this) // This lock is only needed when the this is not the current thread. { Thread _this = this; - retState = (ApartmentState)SetApartmentState(ObjectHandleOnStack.Create(ref _this), (int)state, out _); + retState = (ApartmentState)SetApartmentState(ObjectHandleOnStack.Create(ref _this), (int)state); } // Special case where we pass in Unknown and get back MTA. @@ -415,21 +433,23 @@ public void Interrupt() #if TARGET_UNIX || TARGET_BROWSER || TARGET_WASI WaitSubsystem.Interrupt(this); #else - Interrupt(GetNativeHandle(), out _); + Interrupt(GetNativeHandle()); GC.KeepAlive(this); #endif } #if TARGET_WINDOWS + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_Interrupt")] - private static partial void Interrupt(ThreadHandle t, out QCallExceptionStatus qcallException); + private static partial void Interrupt(ThreadHandle t); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetOSHandle")] - private static partial SafeWaitHandle GetOSHandle(ThreadHandle t, out QCallExceptionStatus qcallException); + private static partial SafeWaitHandle GetOSHandle(ThreadHandle t); private SafeWaitHandle GetJoinHandle() { - SafeWaitHandle handle = GetOSHandle(GetNativeHandle(), out _); + SafeWaitHandle handle = GetOSHandle(GetNativeHandle()); GC.KeepAlive(this); return handle; } @@ -587,14 +607,13 @@ private static unsafe void OnThreadExited(Thread* pThread, Exception* pException } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_ReentrantWaitAny")] - internal static unsafe partial int ReentrantWaitAny([MarshalAs(UnmanagedType.Bool)] bool alertable, int timeout, int count, IntPtr* handles, out QCallExceptionStatus qcallException); - - internal static void CheckForPendingInterrupt() - => CheckForPendingInterrupt(out _); + internal static unsafe partial int ReentrantWaitAny([MarshalAs(UnmanagedType.Bool)] bool alertable, int timeout, int count, IntPtr* handles); + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_CheckForPendingInterrupt")] - private static partial void CheckForPendingInterrupt(out QCallExceptionStatus qcallException); + internal static partial void CheckForPendingInterrupt(); private unsafe NativeThread* GetNativeThreadForCurrentThread() { diff --git a/src/coreclr/System.Private.CoreLib/src/System/TypeLoadException.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/TypeLoadException.CoreCLR.cs index 347bec9d7bee7b..13fd8d3513efbd 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/TypeLoadException.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/TypeLoadException.CoreCLR.cs @@ -39,14 +39,15 @@ private void SetMessageField() _className ??= SR.IO_UnknownFileName; string? format = null; - GetTypeLoadExceptionMessage(_resourceId, new StringHandleOnStack(ref format), out _); + GetTypeLoadExceptionMessage(_resourceId, new StringHandleOnStack(ref format)); _message = string.Format(format!, _className, _assemblyName, _messageArg); } } } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall)] - private static partial void GetTypeLoadExceptionMessage(int resourceId, StringHandleOnStack retString, out QCallExceptionStatus qcallException); + private static partial void GetTypeLoadExceptionMessage(int resourceId, StringHandleOnStack retString); [UnmanagedCallersOnly] internal static unsafe void Create(char* pClassName, char* pAssemblyName, char* pMessageArg, int resourceId, object* pResult, Exception* pException) diff --git a/src/coreclr/System.Private.CoreLib/src/System/ValueType.cs b/src/coreclr/System.Private.CoreLib/src/System/ValueType.cs index 570d4747519761..abfe65d6d4bf41 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/ValueType.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/ValueType.cs @@ -79,12 +79,13 @@ private static unsafe bool CanCompareBitsOrUseFastGetHashCode(MethodTable* pMT) return pAuxData->CanCompareBitsOrUseFastGetHashCode; } - return CanCompareBitsOrUseFastGetHashCodeHelper(pMT, out _); + return CanCompareBitsOrUseFastGetHashCodeHelper(pMT); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MethodTable_CanCompareBitsOrUseFastGetHashCode")] [return: MarshalAs(UnmanagedType.Bool)] - private static unsafe partial bool CanCompareBitsOrUseFastGetHashCodeHelper(MethodTable* pMT, out QCallExceptionStatus qcallException); + private static unsafe partial bool CanCompareBitsOrUseFastGetHashCodeHelper(MethodTable* pMT); /*=================================GetHashCode================================== **Action: Our algorithm for returning the hashcode is a little bit complex. We look @@ -120,7 +121,7 @@ public override unsafe int GetHashCode() else { object thisRef = this; - switch (GetHashCodeStrategy(pMT, ObjectHandleOnStack.Create(ref thisRef), out uint fieldOffset, out uint fieldSize, out MethodTable* fieldMT, out _)) + switch (GetHashCodeStrategy(pMT, ObjectHandleOnStack.Create(ref thisRef), out uint fieldOffset, out uint fieldSize, out MethodTable* fieldMT)) { case ValueTypeHashCodeStrategy.ReferenceField: hashCode.Add(Unsafe.As(ref Unsafe.AddByteOffset(ref rawData, fieldOffset)).GetHashCode()); @@ -162,10 +163,10 @@ private enum ValueTypeHashCodeStrategy ValueTypeOverride, } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ValueType_GetHashCodeStrategy")] private static unsafe partial ValueTypeHashCodeStrategy GetHashCodeStrategy( - MethodTable* pMT, ObjectHandleOnStack objHandle, out uint fieldOffset, out uint fieldSize, out MethodTable* fieldMT, - out QCallExceptionStatus qcallException); + MethodTable* pMT, ObjectHandleOnStack objHandle, out uint fieldOffset, out uint fieldSize, out MethodTable* fieldMT); public override string? ToString() { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Variant.cs b/src/coreclr/System.Private.CoreLib/src/System/Variant.cs index 9d514f8165f574..f88a6fbe5515a1 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Variant.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Variant.cs @@ -18,17 +18,19 @@ internal static partial class Variant { internal static bool IsSystemDrawingColor(Type type) => type.FullName == "System.Drawing.Color"; // Matches the behavior of IsTypeRefOrDef + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Variant_ConvertValueTypeToRecord")] - private static partial void ConvertValueTypeToRecord(ObjectHandleOnStack obj, out ComVariant pOle, out QCallExceptionStatus qcallException); + private static partial void ConvertValueTypeToRecord(ObjectHandleOnStack obj, out ComVariant pOle); internal static ComVariant GetIUnknownOrIDispatchFromObject(object? obj) { - IntPtr pUnk = GetIUnknownOrIDispatchForObject(ObjectHandleOnStack.Create(ref obj), out bool isIDispatch, out _); + IntPtr pUnk = GetIUnknownOrIDispatchForObject(ObjectHandleOnStack.Create(ref obj), out bool isIDispatch); return ComVariant.CreateRaw(isIDispatch ? VarEnum.VT_DISPATCH : VarEnum.VT_UNKNOWN, pUnk); } + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetIUnknownOrIDispatchForObject")] - private static partial IntPtr GetIUnknownOrIDispatchForObject(ObjectHandleOnStack o, [MarshalAs(UnmanagedType.Bool)] out bool isIDispatch, out QCallExceptionStatus qcallException); + private static partial IntPtr GetIUnknownOrIDispatchForObject(ObjectHandleOnStack o, [MarshalAs(UnmanagedType.Bool)] out bool isIDispatch); private static object? GetObjectFromIUnknown(IntPtr pUnk) { @@ -170,7 +172,7 @@ internal static void MarshalHelperConvertObjectToVariant(object? o, out ComVaria // Enums handled by IConvertible case case ValueType: - ConvertValueTypeToRecord(ObjectHandleOnStack.Create(ref o), out pOle, out _); + ConvertValueTypeToRecord(ObjectHandleOnStack.Create(ref o), out pOle); break; // SafeHandle's or CriticalHandle's cannot be stored in VARIANT's. diff --git a/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/ExceptionHandling.cs b/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/ExceptionHandling.cs index 140e02acd797e3..77c1b53582118f 100644 --- a/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/ExceptionHandling.cs +++ b/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/ExceptionHandling.cs @@ -284,11 +284,6 @@ private static void AppendExceptionStackFrameViaClasslib(object exception, IntPt fixed (EH.ExInfo* pExInfo = &exInfo) { InternalCalls.RhpAppendExceptionStackFrame(ObjectHandleOnStack.Create(ref exception), ip, sp, flags, pExInfo -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } @@ -1045,11 +1040,6 @@ private static bool FindFirstPassHandler(object exception, uint idxStart, // Search the clauses for one that contains the current offset. RhEHClause ehClause; for (uint curIdx = 0; InternalCalls.RhpEHEnumNext(&ehEnum, &ehClause -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); curIdx++) { // @@ -1116,11 +1106,6 @@ private static bool FindFirstPassHandler(object exception, uint idxStart, #else // NATIVEAOT shouldInvokeHandler = InternalCalls.RhpCallFilterFunclet(ObjectHandleOnStack.Create(ref exception), pFilterFunclet, frameIter.RegisterSet -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); #endif // NATIVEAOT diff --git a/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/StackFrameIterator.cs b/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/StackFrameIterator.cs index 705c6ac443f745..1597c9b9332beb 100644 --- a/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/StackFrameIterator.cs +++ b/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/StackFrameIterator.cs @@ -66,11 +66,6 @@ internal unsafe struct StackFrameIterator internal bool Init(EH.PAL_LIMITED_CONTEXT* pStackwalkCtx, bool instructionFault = false, bool* fIsExceptionIntercepted = null) { return InternalCalls.RhpSfiInit(ref this, pStackwalkCtx, instructionFault, fIsExceptionIntercepted -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } @@ -93,11 +88,6 @@ internal bool Next(uint* uExCollideClauseIdx, bool* fIsExceptionIntercepted) internal bool Next(uint* uExCollideClauseIdx, bool* fUnwoundReversePInvoke, bool* fIsExceptionIntercepted) { return InternalCalls.RhpSfiNext(ref this, uExCollideClauseIdx, fUnwoundReversePInvoke, fIsExceptionIntercepted -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } } diff --git a/src/coreclr/vm/JitQCallHelpers.h b/src/coreclr/vm/JitQCallHelpers.h index 589be9d0722388..3ccc1361ad6e4b 100644 --- a/src/coreclr/vm/JitQCallHelpers.h +++ b/src/coreclr/vm/JitQCallHelpers.h @@ -18,12 +18,12 @@ class Module; class MethodTable; class MethodDesc; -extern "C" void * QCALLTYPE ResolveVirtualFunctionPointer(QCall::ObjectHandleOnStack obj, CORINFO_CLASS_HANDLE classHnd, CORINFO_METHOD_HANDLE methodHnd, QCallExceptionStatus* qcallError); -extern "C" CORINFO_GENERIC_HANDLE QCALLTYPE GenericHandleWorker(MethodDesc * pMD, MethodTable * pMT, LPVOID signature, DWORD dictionaryIndexAndSlot, Module* pModule, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE InitClassHelper(MethodTable* pMT, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ThrowInvalidCastException(CORINFO_CLASS_HANDLE pTargetType, CORINFO_CLASS_HANDLE pSourceType, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE GetThreadStaticsByMethodTable(QCall::ByteRefOnStack refHandle, MethodTable* pMT, BOOL gcStatic, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE GetThreadStaticsByIndex(QCall::ByteRefOnStack refHandle, uint32_t staticBlockIndex, BOOL gcStatic, QCallExceptionStatus* qcallError); -extern "C" BOOL QCALLTYPE IsInstanceOf_NoCacheLookup(CORINFO_CLASS_HANDLE type, BOOL throwCastException, QCall::ObjectHandleOnStack objOnStack, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ResolveVirtualFunctionPointer(QCall::ObjectHandleOnStack obj, CORINFO_CLASS_HANDLE classHnd, CORINFO_METHOD_HANDLE methodHnd, PCODE* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE GenericHandleWorker(MethodDesc * pMD, MethodTable * pMT, LPVOID signature, DWORD dictionaryIndexAndSlot, Module* pModule, void** pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE InitClassHelper(MethodTable* pMT); +extern "C" QCallExceptionStatus QCALLTYPE ThrowInvalidCastException(CORINFO_CLASS_HANDLE pTargetType, CORINFO_CLASS_HANDLE pSourceType); +extern "C" QCallExceptionStatus QCALLTYPE GetThreadStaticsByMethodTable(QCall::ByteRefOnStack refHandle, MethodTable* pMT, BOOL gcStatic); +extern "C" QCallExceptionStatus QCALLTYPE GetThreadStaticsByIndex(QCall::ByteRefOnStack refHandle, uint32_t staticBlockIndex, BOOL gcStatic); +extern "C" QCallExceptionStatus QCALLTYPE IsInstanceOf_NoCacheLookup(CORINFO_CLASS_HANDLE type, BOOL throwCastException, QCall::ObjectHandleOnStack objOnStack, BOOL* pReturnValue); #endif //_JITQCALLHELPERS_H diff --git a/src/coreclr/vm/appdomainnative.cpp b/src/coreclr/vm/appdomainnative.cpp index 092505035a63d8..f792d5ef9ec834 100644 --- a/src/coreclr/vm/appdomainnative.cpp +++ b/src/coreclr/vm/appdomainnative.cpp @@ -16,7 +16,7 @@ #include "stringarraylist.h" // static -extern "C" void QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnStack assemblyLoadContext, NativeAssemblyNameParts* pAssemblyNameParts, INT32 hashAlgorithm, INT32 access, QCall::ObjectHandleOnStack retAssembly, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnStack assemblyLoadContext, NativeAssemblyNameParts* pAssemblyNameParts, INT32 hashAlgorithm, INT32 access, QCall::ObjectHandleOnStack retAssembly) { QCALL_CONTRACT; @@ -41,7 +41,7 @@ extern "C" void QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnS END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetLoadedAssemblies(QCall::ObjectHandleOnStack retAssemblies, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetLoadedAssemblies(QCall::ObjectHandleOnStack retAssemblies) { QCALL_CONTRACT; @@ -141,7 +141,7 @@ namespace } // Get the value of a known host property from the binder/AppDomain state. -extern "C" BOOL QCALLTYPE AppContext_TryGetHostPropertyValue(LPCWSTR name, QCall::StringHandleOnStack retValue, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AppContext_TryGetHostPropertyValue(LPCWSTR name, QCall::StringHandleOnStack retValue, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -229,12 +229,12 @@ extern "C" BOOL QCALLTYPE AppContext_TryGetHostPropertyValue(LPCWSTR name, QCall _ASSERTE(!"AppContext_TryGetHostPropertyValue called with unknown name"); } - END_QCALL; + *pReturnValue = found; - return found; + END_QCALL; } -extern "C" void QCALLTYPE String_IsInterned(QCall::StringHandleOnStack str, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE String_IsInterned(QCall::StringHandleOnStack str) { QCALL_CONTRACT; @@ -251,7 +251,7 @@ extern "C" void QCALLTYPE String_IsInterned(QCall::StringHandleOnStack str, QCal END_QCALL; } -extern "C" void QCALLTYPE String_Intern(QCall::StringHandleOnStack str, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE String_Intern(QCall::StringHandleOnStack str) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/appdomainnative.hpp b/src/coreclr/vm/appdomainnative.hpp index bc7eed9d818f92..b8d9880cf5b17b 100644 --- a/src/coreclr/vm/appdomainnative.hpp +++ b/src/coreclr/vm/appdomainnative.hpp @@ -16,13 +16,13 @@ #include "qcall.h" -extern "C" void QCALLTYPE String_Intern(QCall::StringHandleOnStack str, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE String_IsInterned(QCall::StringHandleOnStack str, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE String_Intern(QCall::StringHandleOnStack str); +extern "C" QCallExceptionStatus QCALLTYPE String_IsInterned(QCall::StringHandleOnStack str); -extern "C" void QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnStack assemblyLoadContext, NativeAssemblyNameParts* pAssemblyName, INT32 hashAlgorithm, INT32 access, QCall::ObjectHandleOnStack retAssembly, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnStack assemblyLoadContext, NativeAssemblyNameParts* pAssemblyName, INT32 hashAlgorithm, INT32 access, QCall::ObjectHandleOnStack retAssembly); extern "C" void QCALLTYPE AppContext_SetFirstChanceExceptionHandler(); -extern "C" BOOL QCALLTYPE AppContext_TryGetHostPropertyValue(LPCWSTR name, QCall::StringHandleOnStack retValue, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AppContext_TryGetHostPropertyValue(LPCWSTR name, QCall::StringHandleOnStack retValue, BOOL* pReturnValue); -extern "C" void QCALLTYPE AssemblyNative_GetLoadedAssemblies(QCall::ObjectHandleOnStack retAssemblies, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetLoadedAssemblies(QCall::ObjectHandleOnStack retAssemblies); #endif diff --git a/src/coreclr/vm/arraynative.cpp b/src/coreclr/vm/arraynative.cpp index 4986e61dd4c996..727cd098143cbe 100644 --- a/src/coreclr/vm/arraynative.cpp +++ b/src/coreclr/vm/arraynative.cpp @@ -28,7 +28,7 @@ FCIMPL1(INT32, ArrayNative::GetCorElementTypeOfElementType, ArrayBase* arrayUNSA } FCIMPLEND -extern "C" PCODE QCALLTYPE Array_GetElementConstructorEntrypoint(QCall::TypeHandle pArrayTypeHnd, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE Array_GetElementConstructorEntrypoint(QCall::TypeHandle pArrayTypeHnd, PCODE* pReturnValue) { QCALL_CONTRACT; @@ -42,9 +42,9 @@ extern "C" PCODE QCALLTYPE Array_GetElementConstructorEntrypoint(QCall::TypeHand pElemMT->EnsureInstanceActive(); - END_QCALL; + *pReturnValue = ctorEntrypoint; - return ctorEntrypoint; + END_QCALL; } // @@ -107,7 +107,7 @@ static void CheckElementType(TypeHandle elementType) } } -extern "C" void QCALLTYPE Array_CreateInstance(QCall::TypeHandle pTypeHnd, INT32 rank, INT32* pLengths, INT32* pLowerBounds, BOOL createFromArrayType, QCall::ObjectHandleOnStack retArray, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE Array_CreateInstance(QCall::TypeHandle pTypeHnd, INT32 rank, INT32* pLengths, INT32* pLowerBounds, BOOL createFromArrayType, QCall::ObjectHandleOnStack retArray) { CONTRACTL { QCALL_CHECK; @@ -203,7 +203,7 @@ Done: ; END_QCALL; } -extern "C" void QCALLTYPE Array_Ctor(MethodTable* pArrayMT, UINT32 dwNumArgs, INT32* pArgList, QCall::ObjectHandleOnStack retArray, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE Array_Ctor(MethodTable* pArrayMT, UINT32 dwNumArgs, INT32* pArgList, QCall::ObjectHandleOnStack retArray) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/arraynative.h b/src/coreclr/vm/arraynative.h index 3bb51b91d67063..8905f6a6cfdde6 100644 --- a/src/coreclr/vm/arraynative.h +++ b/src/coreclr/vm/arraynative.h @@ -21,8 +21,8 @@ class ArrayNative FCDECL1(static INT32, GetCorElementTypeOfElementType, ArrayBase* arrayUNSAFE); }; -extern "C" PCODE QCALLTYPE Array_GetElementConstructorEntrypoint(QCall::TypeHandle pArrayTypeHnd, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE Array_CreateInstance(QCall::TypeHandle pTypeHnd, INT32 rank, INT32* pLengths, INT32* pBounds, BOOL createFromArrayType, QCall::ObjectHandleOnStack retArray, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE Array_Ctor(MethodTable* pArrayMT, UINT32 dwNumArgs, INT32* pArgList, QCall::ObjectHandleOnStack retArray, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE Array_GetElementConstructorEntrypoint(QCall::TypeHandle pArrayTypeHnd, PCODE* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE Array_CreateInstance(QCall::TypeHandle pTypeHnd, INT32 rank, INT32* pLengths, INT32* pBounds, BOOL createFromArrayType, QCall::ObjectHandleOnStack retArray); +extern "C" QCallExceptionStatus QCALLTYPE Array_Ctor(MethodTable* pArrayMT, UINT32 dwNumArgs, INT32* pArgList, QCall::ObjectHandleOnStack retArray); #endif // _ARRAYNATIVE_H_ diff --git a/src/coreclr/vm/assemblynative.cpp b/src/coreclr/vm/assemblynative.cpp index df4df39d3651be..c98305b66e8e78 100644 --- a/src/coreclr/vm/assemblynative.cpp +++ b/src/coreclr/vm/assemblynative.cpp @@ -31,13 +31,12 @@ #include "../binder/inc/bindertracing.h" #include "../binder/inc/defaultassemblybinder.h" -extern "C" void QCALLTYPE AssemblyNative_InternalLoad(NativeAssemblyNameParts* pAssemblyNameParts, +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_InternalLoad(NativeAssemblyNameParts* pAssemblyNameParts, QCall::ObjectHandleOnStack requestingAssembly, QCall::StackCrawlMarkHandle stackMark, BOOL fThrowOnFileNotFound, QCall::ObjectHandleOnStack assemblyLoadContext, - QCall::ObjectHandleOnStack retAssembly, - QCallExceptionStatus* qcallError) + QCall::ObjectHandleOnStack retAssembly) { QCALL_CONTRACT; @@ -188,7 +187,7 @@ Assembly* AssemblyNative::LoadFromPEImage(AssemblyBinder* pBinder, PEImage *pIma return pCurDomain->LoadAssembly(&spec, pPEAssembly, FILE_LOADED); } -extern "C" void QCALLTYPE AssemblyNative_LoadFromPath(INT_PTR ptrNativeAssemblyBinder, LPCWSTR pwzILPath, QCall::ObjectHandleOnStack retLoadedAssembly, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_LoadFromPath(INT_PTR ptrNativeAssemblyBinder, LPCWSTR pwzILPath, QCall::ObjectHandleOnStack retLoadedAssembly) { QCALL_CONTRACT; @@ -237,10 +236,9 @@ extern "C" void QCALLTYPE AssemblyNative_LoadFromPath(INT_PTR ptrNativeAssemblyB } /*static */ -extern "C" void QCALLTYPE AssemblyNative_LoadFromStream(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrAssemblyArray, +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_LoadFromStream(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrAssemblyArray, INT32 cbAssemblyArrayLength, INT_PTR ptrSymbolArray, INT32 cbSymbolArrayLength, - QCall::ObjectHandleOnStack retLoadedAssembly, - QCallExceptionStatus* qcallError) + QCall::ObjectHandleOnStack retLoadedAssembly) { QCALL_CONTRACT; @@ -304,7 +302,7 @@ extern "C" void QCALLTYPE AssemblyNative_LoadFromStream(INT_PTR ptrNativeAssembl #ifdef TARGET_WINDOWS /*static */ -extern "C" void QCALLTYPE AssemblyNative_LoadFromInMemoryModule(INT_PTR ptrNativeAssemblyBinder, INT_PTR hModule, QCall::ObjectHandleOnStack retLoadedAssembly, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_LoadFromInMemoryModule(INT_PTR ptrNativeAssemblyBinder, INT_PTR hModule, QCall::ObjectHandleOnStack retLoadedAssembly) { QCALL_CONTRACT; @@ -338,7 +336,7 @@ extern "C" void QCALLTYPE AssemblyNative_LoadFromInMemoryModule(INT_PTR ptrNativ } #endif -extern "C" void QCALLTYPE AssemblyNative_GetLocation(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetLocation(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString) { QCALL_CONTRACT; @@ -351,12 +349,11 @@ extern "C" void QCALLTYPE AssemblyNative_GetLocation(QCall::AssemblyHandle pAsse END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetTypeCore(QCall::AssemblyHandle pAssembly, +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetTypeCore(QCall::AssemblyHandle pAssembly, LPCSTR szTypeName, LPCSTR * rgszNestedTypeNames, int32_t cNestedTypeNamesLength, - QCall::ObjectHandleOnStack retType, - QCallExceptionStatus* qcallError) + QCall::ObjectHandleOnStack retType) { CONTRACTL { @@ -420,12 +417,11 @@ extern "C" void QCALLTYPE AssemblyNative_GetTypeCore(QCall::AssemblyHandle pAsse END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetTypeCoreIgnoreCase(QCall::AssemblyHandle assemblyHandle, +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetTypeCoreIgnoreCase(QCall::AssemblyHandle assemblyHandle, LPCWSTR wszTypeName, LPCWSTR* rgwszNestedTypeNames, int32_t cNestedTypeNamesLength, - QCall::ObjectHandleOnStack retType, - QCallExceptionStatus* qcallError) + QCall::ObjectHandleOnStack retType) { CONTRACTL { @@ -500,7 +496,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetTypeCoreIgnoreCase(QCall::AssemblyHa END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetForwardedType(QCall::AssemblyHandle pAssembly, mdToken mdtExternalType, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetForwardedType(QCall::AssemblyHandle pAssembly, mdToken mdtExternalType, QCall::ObjectHandleOnStack retType) { CONTRACTL { @@ -543,7 +539,7 @@ FCIMPL1(FC_BOOL_RET, AssemblyNative::GetIsDynamic, Assembly* pAssembly) } FCIMPLEND -extern "C" void QCALLTYPE AssemblyNative_GetVersion(QCall::AssemblyHandle pAssembly, INT32* pMajorVersion, INT32* pMinorVersion, INT32*pBuildNumber, INT32* pRevisionNumber, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetVersion(QCall::AssemblyHandle pAssembly, INT32* pMajorVersion, INT32* pMinorVersion, INT32*pBuildNumber, INT32* pRevisionNumber) { QCALL_CONTRACT; @@ -561,7 +557,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetVersion(QCall::AssemblyHandle pAssem END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetPublicKey(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retPublicKey, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetPublicKey(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retPublicKey) { QCALL_CONTRACT; @@ -574,7 +570,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetPublicKey(QCall::AssemblyHandle pAss END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetSimpleName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retSimpleName, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetSimpleName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retSimpleName) { QCALL_CONTRACT; @@ -583,7 +579,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetSimpleName(QCall::AssemblyHandle pAs END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetLocale(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetLocale(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString) { QCALL_CONTRACT; @@ -598,7 +594,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetLocale(QCall::AssemblyHandle pAssemb END_QCALL; } -extern "C" BOOL QCALLTYPE AssemblyNative_GetCodeBase(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetCodeBase(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -613,34 +609,36 @@ extern "C" BOOL QCALLTYPE AssemblyNative_GetCodeBase(QCall::AssemblyHandle pAsse } retString.Set(codebase); - END_QCALL; + *pReturnValue = ret; - return ret; + END_QCALL; } -extern "C" INT32 QCALLTYPE AssemblyNative_GetHashAlgorithm(QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetHashAlgorithm(QCall::AssemblyHandle pAssembly, INT32* pReturnValue) { QCALL_CONTRACT; INT32 retVal=0; BEGIN_QCALL; retVal = pAssembly->GetPEAssembly()->GetHashAlgId(); + *pReturnValue = retVal; + END_QCALL; - return retVal; } -extern "C" INT32 QCALLTYPE AssemblyNative_GetFlags(QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetFlags(QCall::AssemblyHandle pAssembly, INT32* pReturnValue) { QCALL_CONTRACT; INT32 retVal=0; BEGIN_QCALL; retVal = pAssembly->GetPEAssembly()->GetFlags(); + *pReturnValue = retVal; + END_QCALL; - return retVal; } -extern "C" BYTE * QCALLTYPE AssemblyNative_GetResource(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, DWORD * length, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetResource(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, DWORD * length, BYTE ** pReturnValue) { QCALL_CONTRACT; @@ -664,13 +662,14 @@ extern "C" BYTE * QCALLTYPE AssemblyNative_GetResource(QCall::AssemblyHandle pAs &pbInMemoryResource, NULL, NULL, NULL, pAssembly); - END_QCALL; - // Can return null if resource file is zero-length - return pbInMemoryResource; + + *pReturnValue = pbInMemoryResource; + + END_QCALL; } -extern "C" INT32 QCALLTYPE AssemblyNative_GetManifestResourceInfo(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, QCall::ObjectHandleOnStack retAssembly, QCall::StringHandleOnStack retFileName, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetManifestResourceInfo(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, QCall::ObjectHandleOnStack retAssembly, QCall::StringHandleOnStack retFileName, INT32* pReturnValue) { QCALL_CONTRACT; @@ -707,12 +706,12 @@ extern "C" INT32 QCALLTYPE AssemblyNative_GetManifestResourceInfo(QCall::Assembl rv = dwLocation; } - END_QCALL; + *pReturnValue = rv; - return rv; + END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetModules(QCall::AssemblyHandle pAssembly, BOOL fLoadIfNotFound, BOOL fGetResourceModules, QCall::ObjectHandleOnStack retModules, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetModules(QCall::AssemblyHandle pAssembly, BOOL fLoadIfNotFound, BOOL fGetResourceModules, QCall::ObjectHandleOnStack retModules) { QCALL_CONTRACT; @@ -783,7 +782,7 @@ extern "C" uint32_t QCALLTYPE AssemblyNative_GetAssemblyCount() return g_cAssemblies; } -extern "C" void QCALLTYPE AssemblyNative_GetModule(QCall::AssemblyHandle pAssembly, LPCWSTR wszFileName, QCall::ObjectHandleOnStack retModule, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetModule(QCall::AssemblyHandle pAssembly, LPCWSTR wszFileName, QCall::ObjectHandleOnStack retModule) { QCALL_CONTRACT; @@ -820,7 +819,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetModule(QCall::AssemblyHandle pAssemb END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes) { QCALL_CONTRACT; @@ -937,7 +936,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetForwardedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetForwardedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes) { QCALL_CONTRACT; @@ -1005,7 +1004,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetForwardedTypes(QCall::AssemblyHandle END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetManifestResourceNames(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retResourceNames, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetManifestResourceNames(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retResourceNames) { QCALL_CONTRACT; @@ -1047,7 +1046,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetManifestResourceNames(QCall::Assembl END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetReferencedAssemblies(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retReferencedAssemblies, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetReferencedAssemblies(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retReferencedAssemblies) { BEGIN_QCALL; @@ -1093,7 +1092,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetReferencedAssemblies(QCall::Assembly END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetEntryPoint(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retMethod, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetEntryPoint(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retMethod) { QCALL_CONTRACT; @@ -1117,7 +1116,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetEntryPoint(QCall::AssemblyHandle pAs // // -extern "C" void QCALLTYPE AssemblyNative_GetFullName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetFullName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString) { QCALL_CONTRACT; @@ -1130,7 +1129,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetFullName(QCall::AssemblyHandle pAsse END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetExecutingAssembly(QCall::StackCrawlMarkHandle stackMark, QCall::ObjectHandleOnStack retAssembly, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetExecutingAssembly(QCall::StackCrawlMarkHandle stackMark, QCall::ObjectHandleOnStack retAssembly) { QCALL_CONTRACT; @@ -1146,7 +1145,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetExecutingAssembly(QCall::StackCrawlM END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetEntryAssembly(QCall::ObjectHandleOnStack retAssembly, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetEntryAssembly(QCall::ObjectHandleOnStack retAssembly) { QCALL_CONTRACT; @@ -1162,7 +1161,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetEntryAssembly(QCall::ObjectHandleOnS END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetImageRuntimeVersion(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetImageRuntimeVersion(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString) { QCALL_CONTRACT; @@ -1185,7 +1184,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetImageRuntimeVersion(QCall::AssemblyH /*static*/ -extern "C" INT_PTR QCALLTYPE AssemblyNative_InitializeAssemblyLoadContext(INT_PTR ptrAssemblyLoadContext, BOOL fRepresentsTPALoadContext, BOOL fIsCollectible, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_InitializeAssemblyLoadContext(INT_PTR ptrAssemblyLoadContext, BOOL fRepresentsTPALoadContext, BOOL fIsCollectible, INT_PTR* pReturnValue) { QCALL_CONTRACT; @@ -1251,13 +1250,13 @@ extern "C" INT_PTR QCALLTYPE AssemblyNative_InitializeAssemblyLoadContext(INT_PT ptrNativeAssemblyBinder = reinterpret_cast(pDefaultBinder); } - END_QCALL; + *pReturnValue = ptrNativeAssemblyBinder; - return ptrNativeAssemblyBinder; + END_QCALL; } /*static*/ -extern "C" void QCALLTYPE AssemblyNative_PrepareForAssemblyLoadContextRelease(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrManagedStrongAssemblyLoadContext, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_PrepareForAssemblyLoadContextRelease(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrManagedStrongAssemblyLoadContext) { QCALL_CONTRACT; @@ -1275,7 +1274,7 @@ extern "C" void QCALLTYPE AssemblyNative_PrepareForAssemblyLoadContextRelease(IN } /*static*/ -extern "C" INT_PTR QCALLTYPE AssemblyNative_GetLoadContextForAssembly(QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetLoadContextForAssembly(QCall::AssemblyHandle pAssembly, INT_PTR* pReturnValue) { QCALL_CONTRACT; @@ -1294,17 +1293,16 @@ extern "C" INT_PTR QCALLTYPE AssemblyNative_GetLoadContextForAssembly(QCall::Ass _ASSERTE(ptrAssemblyLoadContext != (INT_PTR)NULL); } - END_QCALL; + *pReturnValue = ptrAssemblyLoadContext; - return ptrAssemblyLoadContext; + END_QCALL; } // static -extern "C" BOOL QCALLTYPE AssemblyNative_InternalTryGetRawMetadata( +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_InternalTryGetRawMetadata( QCall::AssemblyHandle assembly, UINT8 **blobRef, - INT32 *lengthRef, - QCallExceptionStatus* qcallError) + INT32 *lengthRef, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -1321,9 +1319,9 @@ extern "C" BOOL QCALLTYPE AssemblyNative_InternalTryGetRawMetadata( *blobRef = reinterpret_cast(const_cast(metadata)); _ASSERTE(*lengthRef >= 0); - END_QCALL; + *pReturnValue = metadata != nullptr; - return metadata != nullptr; + END_QCALL; } // static @@ -1336,7 +1334,7 @@ FCIMPL0(FC_BOOL_RET, AssemblyNative::IsTracingEnabled) FCIMPLEND // static -extern "C" void QCALLTYPE AssemblyNative_TraceResolvingHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR alcName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_TraceResolvingHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR alcName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath) { QCALL_CONTRACT; @@ -1348,7 +1346,7 @@ extern "C" void QCALLTYPE AssemblyNative_TraceResolvingHandlerInvoked(LPCWSTR as } // static -extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyResolveHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_TraceAssemblyResolveHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath) { QCALL_CONTRACT; @@ -1360,7 +1358,7 @@ extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyResolveHandlerInvoked(LPCW } // static -extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyLoadFromResolveHandlerInvoked(LPCWSTR assemblyName, BOOL isTrackedAssembly, LPCWSTR requestingAssemblyPath, LPCWSTR requestedAssemblyPath, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_TraceAssemblyLoadFromResolveHandlerInvoked(LPCWSTR assemblyName, BOOL isTrackedAssembly, LPCWSTR requestingAssemblyPath, LPCWSTR requestedAssemblyPath) { QCALL_CONTRACT; @@ -1372,7 +1370,7 @@ extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyLoadFromResolveHandlerInvo } // static -extern "C" void QCALLTYPE AssemblyNative_TraceSatelliteSubdirectoryPathProbed(LPCWSTR filePath, HRESULT hr, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_TraceSatelliteSubdirectoryPathProbed(LPCWSTR filePath, HRESULT hr) { QCALL_CONTRACT; @@ -1384,15 +1382,14 @@ extern "C" void QCALLTYPE AssemblyNative_TraceSatelliteSubdirectoryPathProbed(LP } // static -extern "C" void QCALLTYPE AssemblyNative_ApplyUpdate( +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_ApplyUpdate( QCall::AssemblyHandle assembly, UINT8* metadataDelta, INT32 metadataDeltaLength, UINT8* ilDelta, INT32 ilDeltaLength, UINT8* pdbDelta, - INT32 pdbDeltaLength, - QCallExceptionStatus* qcallError) + INT32 pdbDeltaLength) { QCALL_CONTRACT; @@ -1430,7 +1427,7 @@ extern "C" void QCALLTYPE AssemblyNative_ApplyUpdate( } // static -extern "C" BOOL QCALLTYPE AssemblyNative_IsApplyUpdateSupported(QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_IsApplyUpdateSupported(BOOL* pReturnValue) { QCALL_CONTRACT; @@ -1443,9 +1440,9 @@ extern "C" BOOL QCALLTYPE AssemblyNative_IsApplyUpdateSupported(QCallExceptionSt (CORDebuggerAttached() || g_pConfig->ModifiableAssemblies() == MODIFIABLE_ASSM_DEBUG); #endif - END_QCALL; + *pReturnValue = result; - return result; + END_QCALL; } namespace @@ -1703,15 +1700,14 @@ namespace }; } -extern "C" void QCALLTYPE TypeMapLazyDictionary_ProcessAttributes( +extern "C" QCallExceptionStatus QCALLTYPE TypeMapLazyDictionary_ProcessAttributes( QCall::AssemblyHandle pAssembly, QCall::TypeHandle pGroupType, BOOL (*newExternalTypeEntry)(CallbackContext* context, ProcessAttributesCallbackArg* arg), BOOL (*newProxyTypeEntry)(CallbackContext* context, ProcessAttributesCallbackArg* arg), BOOL (*newPrecachedExternalTypeMap)(CallbackContext* context), BOOL (*newPrecachedProxyTypeMap)(CallbackContext* context), - CallbackContext* context, - QCallExceptionStatus* qcallError) + CallbackContext* context) { QCALL_CONTRACT; _ASSERTE(pAssembly != NULL); @@ -1835,11 +1831,10 @@ extern "C" void QCALLTYPE TypeMapLazyDictionary_ProcessAttributes( END_QCALL; } -extern "C" TADDR QCALLTYPE TypeMapLazyDictionary_FindPrecachedExternalTypeMapEntry( +extern "C" QCallExceptionStatus QCALLTYPE TypeMapLazyDictionary_FindPrecachedExternalTypeMapEntry( QCall::ModuleHandle pModule, QCall::TypeHandle pGroupType, - LPCUTF8 key, - QCallExceptionStatus* qcallError) + LPCUTF8 key, TADDR* pReturnValue) { QCALL_CONTRACT; _ASSERTE(pModule != NULL); @@ -1864,16 +1859,15 @@ extern "C" TADDR QCALLTYPE TypeMapLazyDictionary_FindPrecachedExternalTypeMapEnt } #endif // FEATURE_READYTORUN - END_QCALL; + *pReturnValue = resultTypeHnd.AsTAddr(); - return resultTypeHnd.AsTAddr(); + END_QCALL; } -extern "C" TADDR QCALLTYPE TypeMapLazyDictionary_FindPrecachedProxyTypeMapEntry( +extern "C" QCallExceptionStatus QCALLTYPE TypeMapLazyDictionary_FindPrecachedProxyTypeMapEntry( QCall::ModuleHandle pModule, QCall::TypeHandle pGroupType, - QCall::TypeHandle pType, - QCallExceptionStatus* qcallError) + QCall::TypeHandle pType, TADDR* pReturnValue) { QCALL_CONTRACT; _ASSERTE(pModule != NULL); @@ -1898,7 +1892,7 @@ extern "C" TADDR QCALLTYPE TypeMapLazyDictionary_FindPrecachedProxyTypeMapEntry( } #endif // FEATURE_READYTORUN - END_QCALL; + *pReturnValue = resultTypeHnd.AsTAddr(); - return resultTypeHnd.AsTAddr(); + END_QCALL; } diff --git a/src/coreclr/vm/assemblynative.hpp b/src/coreclr/vm/assemblynative.hpp index 0ea20803c8a68b..2e94e50a762550 100644 --- a/src/coreclr/vm/assemblynative.hpp +++ b/src/coreclr/vm/assemblynative.hpp @@ -37,111 +37,111 @@ class AssemblyNative extern "C" uint32_t QCALLTYPE AssemblyNative_GetAssemblyCount(); -extern "C" void QCALLTYPE AssemblyNative_GetEntryAssembly(QCall::ObjectHandleOnStack retAssembly, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetEntryAssembly(QCall::ObjectHandleOnStack retAssembly); -extern "C" void QCALLTYPE AssemblyNative_GetExecutingAssembly(QCall::StackCrawlMarkHandle stackMark, QCall::ObjectHandleOnStack retAssembly, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetExecutingAssembly(QCall::StackCrawlMarkHandle stackMark, QCall::ObjectHandleOnStack retAssembly); -extern "C" void QCALLTYPE AssemblyNative_GetLocale(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetLocale(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString); -extern "C" INT32 QCALLTYPE AssemblyNative_GetHashAlgorithm(QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetHashAlgorithm(QCall::AssemblyHandle pAssembly, INT32* pReturnValue); -extern "C" void QCALLTYPE AssemblyNative_GetSimpleName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retSimpleName, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetSimpleName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retSimpleName); -extern "C" void QCALLTYPE AssemblyNative_GetPublicKey(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retPublicKey, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetPublicKey(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retPublicKey); -extern "C" INT32 QCALLTYPE AssemblyNative_GetFlags(QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetFlags(QCall::AssemblyHandle pAssembly, INT32* pReturnValue); -extern "C" void QCALLTYPE AssemblyNative_GetFullName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetFullName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString); -extern "C" void QCALLTYPE AssemblyNative_GetLocation(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetLocation(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString); -extern "C" BOOL QCALLTYPE AssemblyNative_GetCodeBase(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetCodeBase(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, BOOL* pReturnValue); -extern "C" BYTE * QCALLTYPE AssemblyNative_GetResource(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, DWORD * length, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetResource(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, DWORD * length, BYTE ** pReturnValue); -extern "C" void QCALLTYPE AssemblyNative_GetVersion(QCall::AssemblyHandle pAssembly, INT32* pMajorVersion, INT32* pMinorVersion, INT32*pBuildNumber, INT32* pRevisionNumber, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetVersion(QCall::AssemblyHandle pAssembly, INT32* pMajorVersion, INT32* pMinorVersion, INT32*pBuildNumber, INT32* pRevisionNumber); -extern "C" void QCALLTYPE AssemblyNative_GetTypeCore(QCall::AssemblyHandle pAssembly, LPCSTR szTypeName, LPCSTR* rgszNestedTypeNames, int32_t cNestedTypeNamesLength, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetTypeCore(QCall::AssemblyHandle pAssembly, LPCSTR szTypeName, LPCSTR* rgszNestedTypeNames, int32_t cNestedTypeNamesLength, QCall::ObjectHandleOnStack retType); -extern "C" void QCALLTYPE AssemblyNative_GetTypeCoreIgnoreCase(QCall::AssemblyHandle pAssembly, LPCWSTR wszTypeName, LPCWSTR* rgwszNestedTypeNames, int32_t cNestedTypeNamesLength, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetTypeCoreIgnoreCase(QCall::AssemblyHandle pAssembly, LPCWSTR wszTypeName, LPCWSTR* rgwszNestedTypeNames, int32_t cNestedTypeNamesLength, QCall::ObjectHandleOnStack retType); -extern "C" void QCALLTYPE AssemblyNative_GetForwardedType(QCall::AssemblyHandle pAssembly, mdToken mdtExternalType, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetForwardedType(QCall::AssemblyHandle pAssembly, mdToken mdtExternalType, QCall::ObjectHandleOnStack retType); -extern "C" INT32 QCALLTYPE AssemblyNative_GetManifestResourceInfo(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, QCall::ObjectHandleOnStack retAssembly, QCall::StringHandleOnStack retFileName, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetManifestResourceInfo(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, QCall::ObjectHandleOnStack retAssembly, QCall::StringHandleOnStack retFileName, INT32* pReturnValue); -extern "C" void QCALLTYPE AssemblyNative_GetModules(QCall::AssemblyHandle pAssembly, BOOL fLoadIfNotFound, BOOL fGetResourceModules, QCall::ObjectHandleOnStack retModules, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetModules(QCall::AssemblyHandle pAssembly, BOOL fLoadIfNotFound, BOOL fGetResourceModules, QCall::ObjectHandleOnStack retModules); -extern "C" void QCALLTYPE AssemblyNative_GetModule(QCall::AssemblyHandle pAssembly, LPCWSTR wszFileName, QCall::ObjectHandleOnStack retModule, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetModule(QCall::AssemblyHandle pAssembly, LPCWSTR wszFileName, QCall::ObjectHandleOnStack retModule); -extern "C" void QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes); -extern "C" void QCALLTYPE AssemblyNative_GetForwardedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetForwardedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes); -extern "C" void QCALLTYPE AssemblyNative_GetManifestResourceNames(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retResourceNames, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetManifestResourceNames(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retResourceNames); -extern "C" void QCALLTYPE AssemblyNative_GetReferencedAssemblies(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retReferencedAssemblies, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetReferencedAssemblies(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retReferencedAssemblies); -extern "C" void QCALLTYPE AssemblyNative_GetEntryPoint(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retMethod, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetEntryPoint(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retMethod); -extern "C" void QCALLTYPE AssemblyNative_GetImageRuntimeVersion(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetImageRuntimeVersion(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString); -extern "C" INT_PTR QCALLTYPE AssemblyNative_InitializeAssemblyLoadContext(INT_PTR ptrAssemblyLoadContext, BOOL fRepresentsTPALoadContext, BOOL fIsCollectible, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_InitializeAssemblyLoadContext(INT_PTR ptrAssemblyLoadContext, BOOL fRepresentsTPALoadContext, BOOL fIsCollectible, INT_PTR* pReturnValue); -extern "C" void QCALLTYPE AssemblyNative_PrepareForAssemblyLoadContextRelease(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrManagedStrongAssemblyLoadContext, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_PrepareForAssemblyLoadContextRelease(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrManagedStrongAssemblyLoadContext); -extern "C" void QCALLTYPE AssemblyNative_InternalLoad(NativeAssemblyNameParts* pAssemblyName, QCall::ObjectHandleOnStack requestingAssembly, QCall::StackCrawlMarkHandle stackMark,BOOL fThrowOnFileNotFound, QCall::ObjectHandleOnStack assemblyLoadContext, QCall::ObjectHandleOnStack retAssembly, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_InternalLoad(NativeAssemblyNameParts* pAssemblyName, QCall::ObjectHandleOnStack requestingAssembly, QCall::StackCrawlMarkHandle stackMark,BOOL fThrowOnFileNotFound, QCall::ObjectHandleOnStack assemblyLoadContext, QCall::ObjectHandleOnStack retAssembly); -extern "C" void QCALLTYPE AssemblyNative_LoadFromPath(INT_PTR ptrNativeAssemblyBinder, LPCWSTR pwzILPath, QCall::ObjectHandleOnStack retLoadedAssembly, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_LoadFromPath(INT_PTR ptrNativeAssemblyBinder, LPCWSTR pwzILPath, QCall::ObjectHandleOnStack retLoadedAssembly); -extern "C" void QCALLTYPE AssemblyNative_LoadFromStream(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrAssemblyArray, INT32 cbAssemblyArrayLength, INT_PTR ptrSymbolArray, INT32 cbSymbolArrayLength, QCall::ObjectHandleOnStack retLoadedAssembly, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_LoadFromStream(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrAssemblyArray, INT32 cbAssemblyArrayLength, INT_PTR ptrSymbolArray, INT32 cbSymbolArrayLength, QCall::ObjectHandleOnStack retLoadedAssembly); #ifdef TARGET_WINDOWS -extern "C" void QCALLTYPE AssemblyNative_LoadFromInMemoryModule(INT_PTR ptrNativeAssemblyBinder, INT_PTR hModule, QCall::ObjectHandleOnStack retLoadedAssembly, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_LoadFromInMemoryModule(INT_PTR ptrNativeAssemblyBinder, INT_PTR hModule, QCall::ObjectHandleOnStack retLoadedAssembly); #endif -extern "C" INT_PTR QCALLTYPE AssemblyNative_GetLoadContextForAssembly(QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetLoadContextForAssembly(QCall::AssemblyHandle pAssembly, INT_PTR* pReturnValue); -extern "C" BOOL QCALLTYPE AssemblyNative_InternalTryGetRawMetadata(QCall::AssemblyHandle assembly, UINT8 **blobRef, INT32 *lengthRef, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_InternalTryGetRawMetadata(QCall::AssemblyHandle assembly, UINT8 **blobRef, INT32 *lengthRef, BOOL* pReturnValue); -extern "C" void QCALLTYPE AssemblyNative_TraceResolvingHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR alcName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_TraceResolvingHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR alcName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath); -extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyResolveHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_TraceAssemblyResolveHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath); -extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyLoadFromResolveHandlerInvoked(LPCWSTR assemblyName, BOOL isTrackedAssembly, LPCWSTR requestingAssemblyPath, LPCWSTR requestedAssemblyPath, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_TraceAssemblyLoadFromResolveHandlerInvoked(LPCWSTR assemblyName, BOOL isTrackedAssembly, LPCWSTR requestingAssemblyPath, LPCWSTR requestedAssemblyPath); -extern "C" void QCALLTYPE AssemblyNative_TraceSatelliteSubdirectoryPathProbed(LPCWSTR filePath, HRESULT hr, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_TraceSatelliteSubdirectoryPathProbed(LPCWSTR filePath, HRESULT hr); -extern "C" void QCALLTYPE AssemblyNative_ApplyUpdate(QCall::AssemblyHandle assembly, UINT8* metadataDelta, INT32 metadataDeltaLength, UINT8* ilDelta, INT32 ilDeltaLength, UINT8* pdbDelta, INT32 pdbDeltaLength, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_ApplyUpdate(QCall::AssemblyHandle assembly, UINT8* metadataDelta, INT32 metadataDeltaLength, UINT8* ilDelta, INT32 ilDeltaLength, UINT8* pdbDelta, INT32 pdbDeltaLength); -extern "C" BOOL QCALLTYPE AssemblyNative_IsApplyUpdateSupported(QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_IsApplyUpdateSupported(BOOL* pReturnValue); -extern "C" void QCALLTYPE AssemblyName_InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, BaseAssemblySpec* pAssemblySpec, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyName_InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, BaseAssemblySpec* pAssemblySpec); // See TypeMapLazyDictionary.cs for managed version. struct CallbackContext final @@ -162,25 +162,23 @@ struct ProcessAttributesCallbackArg final int32_t StringLen2; }; -extern "C" void QCALLTYPE TypeMapLazyDictionary_ProcessAttributes( +extern "C" QCallExceptionStatus QCALLTYPE TypeMapLazyDictionary_ProcessAttributes( QCall::AssemblyHandle pAssembly, QCall::TypeHandle pTypeGroup, BOOL (*newExternalTypeEntry)(CallbackContext* context, ProcessAttributesCallbackArg* arg), BOOL (*newProxyTypeEntry)(CallbackContext* context, ProcessAttributesCallbackArg* arg), BOOL (*newPrecachedExternalTypeMap)(CallbackContext* context), BOOL (*newPrecachedProxyTypeMap)(CallbackContext* context), - CallbackContext* context, QCallExceptionStatus* qcallError); + CallbackContext* context); -extern "C" TADDR QCALLTYPE TypeMapLazyDictionary_FindPrecachedExternalTypeMapEntry( +extern "C" QCallExceptionStatus QCALLTYPE TypeMapLazyDictionary_FindPrecachedExternalTypeMapEntry( QCall::ModuleHandle pModule, QCall::TypeHandle pGroupType, - LPCUTF8 key -, QCallExceptionStatus* qcallError); + LPCUTF8 key, TADDR* pReturnValue); -extern "C" TADDR QCALLTYPE TypeMapLazyDictionary_FindPrecachedProxyTypeMapEntry( +extern "C" QCallExceptionStatus QCALLTYPE TypeMapLazyDictionary_FindPrecachedProxyTypeMapEntry( QCall::ModuleHandle pModule, QCall::TypeHandle pGroupType, - QCall::TypeHandle pType -, QCallExceptionStatus* qcallError); + QCall::TypeHandle pType, TADDR* pReturnValue); #endif diff --git a/src/coreclr/vm/clrconfignative.cpp b/src/coreclr/vm/clrconfignative.cpp index 7bef596edb0380..921214905040d5 100644 --- a/src/coreclr/vm/clrconfignative.cpp +++ b/src/coreclr/vm/clrconfignative.cpp @@ -8,7 +8,7 @@ #include "clrconfignative.h" #include -extern "C" BOOL QCALLTYPE ClrConfig_GetConfigBoolValue(LPCWSTR name, BOOL *exist, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ClrConfig_GetConfigBoolValue(LPCWSTR name, BOOL *exist, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -21,6 +21,7 @@ extern "C" BOOL QCALLTYPE ClrConfig_GetConfigBoolValue(LPCWSTR name, BOOL *exist *exist = TRUE; retValue = Configuration::GetKnobBooleanValue(name, FALSE); } + *pReturnValue = (retValue); + END_QCALL; - return(retValue); } diff --git a/src/coreclr/vm/clrconfignative.h b/src/coreclr/vm/clrconfignative.h index d363a2745e9e3c..5597f1744ecd7c 100644 --- a/src/coreclr/vm/clrconfignative.h +++ b/src/coreclr/vm/clrconfignative.h @@ -4,5 +4,5 @@ #ifndef _CLRCONFIGNATIVE_H_ #define _CLRCONFIGNATIVE_H_ -extern "C" BOOL QCALLTYPE ClrConfig_GetConfigBoolValue(LPCWSTR name, BOOL *exist, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ClrConfig_GetConfigBoolValue(LPCWSTR name, BOOL *exist, BOOL* pReturnValue); #endif // _CLRCONFIGNATIVE_H_ diff --git a/src/coreclr/vm/comdelegate.cpp b/src/coreclr/vm/comdelegate.cpp index 16230726e974bf..e309f4c92ec8ed 100644 --- a/src/coreclr/vm/comdelegate.cpp +++ b/src/coreclr/vm/comdelegate.cpp @@ -970,9 +970,8 @@ static PCODE GetVirtualCallStub(MethodDesc *method, TypeHandle scopeType) ); } -extern "C" BOOL QCALLTYPE Delegate_BindToMethodName(MethodTable* pDelegateMT, MethodTable *pTargetMT, - QCall::TypeHandle pMethodType, LPCUTF8 pszMethodName, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, - QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE Delegate_BindToMethodName(MethodTable* pDelegateMT, MethodTable *pTargetMT, + QCall::TypeHandle pMethodType, LPCUTF8 pszMethodName, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -1071,14 +1070,13 @@ extern "C" BOOL QCALLTYPE Delegate_BindToMethodName(MethodTable* pDelegateMT, Me ; - END_QCALL; + *pReturnValue = pMatchingMethod != NULL; - return pMatchingMethod != NULL; + END_QCALL; } -extern "C" BOOL QCALLTYPE Delegate_BindToMethodInfo(MethodTable* pDelegateMT, MethodTable *pTargetMT, - MethodDesc * method, QCall::TypeHandle pMethodType, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, - QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE Delegate_BindToMethodInfo(MethodTable* pDelegateMT, MethodTable *pTargetMT, + MethodDesc * method, QCall::TypeHandle pMethodType, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -1130,9 +1128,9 @@ extern "C" BOOL QCALLTYPE Delegate_BindToMethodInfo(MethodTable* pDelegateMT, Me result = FALSE; } - END_QCALL; + *pReturnValue = result; - return result; + END_QCALL; } // This method is called (in the late bound case only) once a target method has been decided on. All the consistency checks @@ -1527,7 +1525,7 @@ MethodDesc* COMDelegate::GetILStubMethodDesc(EEImplMethodDesc* pDelegateMD, DWOR return PInvoke::CreateCLRToNativeILStub(&sigInfo, dwStubFlags, pDelegateMD); } -extern "C" void QCALLTYPE Delegate_InitializeVirtualCallStub(QCall::ObjectHandleOnStack d, PCODE method, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE Delegate_InitializeVirtualCallStub(QCall::ObjectHandleOnStack d, PCODE method) { QCALL_CONTRACT; @@ -1547,7 +1545,7 @@ extern "C" void QCALLTYPE Delegate_InitializeVirtualCallStub(QCall::ObjectHandle END_QCALL; } -extern "C" PCODE QCALLTYPE Delegate_AdjustTarget(MethodTable* pMTTarg, PCODE method, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE Delegate_AdjustTarget(MethodTable* pMTTarg, PCODE method, PCODE* pReturnValue) { QCALL_CONTRACT; @@ -1578,9 +1576,9 @@ extern "C" PCODE QCALLTYPE Delegate_AdjustTarget(MethodTable* pMTTarg, PCODE met method = pCorrectedMethod->GetMultiCallableAddrOfCode(); } - END_QCALL; + *pReturnValue = method; - return method; + END_QCALL; } uint32_t MethodDescToNumFixedArgs(MethodDesc *pMD) @@ -1605,7 +1603,7 @@ uint32_t MethodDescToNumFixedArgs(MethodDesc *pMD) // This is the single constructor for all Delegates. The compiler // doesn't provide an implementation of the Delegate constructor. We // provide that implementation through a QCall call to this method. -extern "C" void QCALLTYPE Delegate_Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, PCODE method, BindToMethodDetails *pBindToMethodDetails, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE Delegate_Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, PCODE method, BindToMethodDetails *pBindToMethodDetails) { QCALL_CONTRACT; @@ -1908,7 +1906,7 @@ void COMDelegate::ThrowIfInvalidUnmanagedCallersOnlyUsage(MethodDesc* pMD) } // This method will get the MethodInfo for a delegate -extern "C" void QCALLTYPE Delegate_CreateMethodInfo(MethodDesc* methodDesc, QCall::ObjectHandleOnStack retMethodInfo, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE Delegate_CreateMethodInfo(MethodDesc* methodDesc, QCall::ObjectHandleOnStack retMethodInfo) { QCALL_CONTRACT; @@ -1923,7 +1921,7 @@ extern "C" void QCALLTYPE Delegate_CreateMethodInfo(MethodDesc* methodDesc, QCal END_QCALL; } -extern "C" MethodDesc* QCALLTYPE Delegate_GetMethodDesc(QCall::ObjectHandleOnStack instance, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE Delegate_GetMethodDesc(QCall::ObjectHandleOnStack instance, MethodDesc** pReturnValue) { QCALL_CONTRACT; @@ -1935,9 +1933,9 @@ extern "C" MethodDesc* QCALLTYPE Delegate_GetMethodDesc(QCall::ObjectHandleOnSta pMD = COMDelegate::GetMethodDesc(instance.Get()); - END_QCALL; + *pReturnValue = pMD; - return pMD; + END_QCALL; } FCIMPL1(MethodDesc*, COMDelegate::GetInvokeMethod, MethodTable* pDelegateMT) @@ -1961,7 +1959,7 @@ FCIMPL1(PCODE, COMDelegate::GetMulticastInvoke, MethodTable* pDelegateMT) } FCIMPLEND -extern "C" PCODE QCALLTYPE Delegate_GetMulticastInvokeSlow(MethodTable* pDelegateMT, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE Delegate_GetMulticastInvokeSlow(MethodTable* pDelegateMT, PCODE* pReturnValue) { QCALL_CONTRACT; _ASSERTE(pDelegateMT != NULL); @@ -2081,9 +2079,9 @@ extern "C" PCODE QCALLTYPE Delegate_GetMulticastInvokeSlow(MethodTable* pDelegat pStub = delegateEEClass->m_pMultiCastInvokeStub; } - END_QCALL; + *pReturnValue = pStub; - return pStub; + END_QCALL; } static bool IsLocationAssignable(TypeHandle fromHandle, TypeHandle toHandle, bool relaxedMatch, bool fromHandleIsBoxed) diff --git a/src/coreclr/vm/comdelegate.h b/src/coreclr/vm/comdelegate.h index 1f35fc0ade8ff6..a029c6dc0c037e 100644 --- a/src/coreclr/vm/comdelegate.h +++ b/src/coreclr/vm/comdelegate.h @@ -96,13 +96,13 @@ class COMDelegate BindToMethodDetails *pBindToMethodDetails); }; -extern "C" void QCALLTYPE Delegate_Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, PCODE method, BindToMethodDetails *pBindToMethodDetails, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE Delegate_Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, PCODE method, BindToMethodDetails *pBindToMethodDetails); -extern "C" PCODE QCALLTYPE Delegate_GetMulticastInvokeSlow(MethodTable* pDelegateMT, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE Delegate_GetMulticastInvokeSlow(MethodTable* pDelegateMT, PCODE* pReturnValue); -extern "C" PCODE QCALLTYPE Delegate_AdjustTarget(MethodTable* pMTTarg, PCODE method, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE Delegate_AdjustTarget(MethodTable* pMTTarg, PCODE method, PCODE* pReturnValue); -extern "C" void QCALLTYPE Delegate_InitializeVirtualCallStub(QCall::ObjectHandleOnStack d, PCODE method, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE Delegate_InitializeVirtualCallStub(QCall::ObjectHandleOnStack d, PCODE method); // These flags effect the way BindToMethodInfo and BindToMethodName are allowed to bind a delegate to a target method. Their // values must be kept in sync with the definition in bcl\system\delegate.cs. @@ -117,17 +117,15 @@ enum DelegateBindingFlags DBF_RelaxedSignature = 0x00000040, // Allow relaxed signature matching (co/contra variance) }; -extern "C" BOOL QCALLTYPE Delegate_BindToMethodName(MethodTable* pDelegateMT, MethodTable *pTargetMT, - QCall::TypeHandle pMethodType, LPCUTF8 pszMethodName, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, - QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE Delegate_BindToMethodName(MethodTable* pDelegateMT, MethodTable *pTargetMT, + QCall::TypeHandle pMethodType, LPCUTF8 pszMethodName, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, BOOL* pReturnValue); -extern "C" BOOL QCALLTYPE Delegate_BindToMethodInfo(MethodTable* pDelegateMT, MethodTable *pTargetMT, - MethodDesc * method, QCall::TypeHandle pMethodType, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, - QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE Delegate_BindToMethodInfo(MethodTable* pDelegateMT, MethodTable *pTargetMT, + MethodDesc * method, QCall::TypeHandle pMethodType, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, BOOL* pReturnValue); -extern "C" void QCALLTYPE Delegate_CreateMethodInfo(MethodDesc* methodDesc, QCall::ObjectHandleOnStack retMethodInfo, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE Delegate_CreateMethodInfo(MethodDesc* methodDesc, QCall::ObjectHandleOnStack retMethodInfo); -extern "C" MethodDesc* QCALLTYPE Delegate_GetMethodDesc(QCall::ObjectHandleOnStack instance, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE Delegate_GetMethodDesc(QCall::ObjectHandleOnStack instance, MethodDesc** pReturnValue); void DistributeEvent(OBJECTREF *pDelegate, OBJECTREF *pDomain); diff --git a/src/coreclr/vm/comdependenthandle.cpp b/src/coreclr/vm/comdependenthandle.cpp index c2b18b039910b4..4174b5c2f9c786 100644 --- a/src/coreclr/vm/comdependenthandle.cpp +++ b/src/coreclr/vm/comdependenthandle.cpp @@ -26,7 +26,7 @@ FCIMPL2(OBJECTHANDLE, DependentHandle::InternalAlloc, Object *target, Object *de } FCIMPLEND -extern "C" OBJECTHANDLE QCALLTYPE DependentHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack target, QCall::ObjectHandleOnStack dependent, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE DependentHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack target, QCall::ObjectHandleOnStack dependent, OBJECTHANDLE* pReturnValue) { QCALL_CONTRACT; @@ -37,9 +37,9 @@ extern "C" OBJECTHANDLE QCALLTYPE DependentHandle_InternalAllocWithGCTransition( GCX_COOP(); result = GetAppDomain()->CreateDependentHandle(target.Get(), dependent.Get()); - END_QCALL; + *pReturnValue = result; - return result; + END_QCALL; } FCIMPL1(Object*, DependentHandle::InternalGetTarget, OBJECTHANDLE handle) @@ -122,7 +122,7 @@ FCIMPL1(FC_BOOL_RET, DependentHandle::InternalFree, OBJECTHANDLE handle) } FCIMPLEND -extern "C" void QCALLTYPE DependentHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE DependentHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/comdependenthandle.h b/src/coreclr/vm/comdependenthandle.h index ec47f3368d4167..8bc950199db7cf 100644 --- a/src/coreclr/vm/comdependenthandle.h +++ b/src/coreclr/vm/comdependenthandle.h @@ -49,7 +49,7 @@ class DependentHandle FCDECL1(static FC_BOOL_RET, InternalFree, OBJECTHANDLE handle); }; -extern "C" OBJECTHANDLE QCALLTYPE DependentHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack target, QCall::ObjectHandleOnStack dependent, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE DependentHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE DependentHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack target, QCall::ObjectHandleOnStack dependent, OBJECTHANDLE* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE DependentHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle); #endif diff --git a/src/coreclr/vm/comdynamic.cpp b/src/coreclr/vm/comdynamic.cpp index 91ed0bba68a556..8dac62c7c7d265 100644 --- a/src/coreclr/vm/comdynamic.cpp +++ b/src/coreclr/vm/comdynamic.cpp @@ -37,13 +37,12 @@ struct ExceptionInstance { // Defining a type into metadata of this dynamic module // //************************************************************* -extern "C" INT32 QCALLTYPE TypeBuilder_DefineGenericParam(QCall::ModuleHandle pModule, +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineGenericParam(QCall::ModuleHandle pModule, LPCWSTR wszFullName, INT32 tkParent, INT32 attributes, INT32 position, - INT32 * pConstraintTokens, - QCallExceptionStatus* qcallError) + INT32 * pConstraintTokens, INT32* pReturnValue) { QCALL_CONTRACT; @@ -57,18 +56,17 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineGenericParam(QCall::ModuleHandle pM IfFailThrow(pRCW->GetEmitter()->DefineGenericParam( tkParent, position, attributes, wszFullName, 0, (mdToken *)pConstraintTokens, &classE)); - END_QCALL; + *pReturnValue = (INT32)classE; - return (INT32)classE; + END_QCALL; } -extern "C" INT32 QCALLTYPE TypeBuilder_DefineType(QCall::ModuleHandle pModule, +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineType(QCall::ModuleHandle pModule, LPCWSTR wszFullName, INT32 tkParent, INT32 attributes, INT32 tkEnclosingType, - INT32 * pInterfaceTokens, - QCallExceptionStatus* qcallError) + INT32 * pInterfaceTokens, INT32* pReturnValue) { QCALL_CONTRACT; @@ -76,11 +74,11 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineType(QCall::ModuleHandle pModule, BEGIN_QCALL; - classE = COMDynamicWrite::DefineType(pModule, wszFullName, tkParent, attributes, tkEnclosingType, pInterfaceTokens, qcallError); + classE = COMDynamicWrite::DefineType(pModule, wszFullName, tkParent, attributes, tkEnclosingType, pInterfaceTokens); - END_QCALL; + *pReturnValue = (INT32)classE; - return (INT32)classE; + END_QCALL; } INT32 COMDynamicWrite::DefineType(Module* pModule, @@ -88,15 +86,12 @@ INT32 COMDynamicWrite::DefineType(Module* pModule, INT32 tkParent, INT32 attributes, INT32 tkEnclosingType, - INT32 * pInterfaceTokens, - QCallExceptionStatus* qcallError) + INT32 * pInterfaceTokens) { QCALL_CONTRACT; mdTypeDef classE = mdTokenNil; - BEGIN_QCALL; - RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); @@ -138,13 +133,11 @@ INT32 COMDynamicWrite::DefineType(Module* pModule, &amTracker); amTracker.SuppressRelease(); - END_QCALL; - return (INT32)classE; } // This function will reset the parent class in metadata -extern "C" void QCALLTYPE TypeBuilder_SetParentType(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkParent, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetParentType(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkParent) { QCALL_CONTRACT; @@ -159,7 +152,7 @@ extern "C" void QCALLTYPE TypeBuilder_SetParentType(QCall::ModuleHandle pModule, } // This function will add another interface impl -extern "C" void QCALLTYPE TypeBuilder_AddInterfaceImpl(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkInterface, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_AddInterfaceImpl(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkInterface) { QCALL_CONTRACT; @@ -174,7 +167,7 @@ extern "C" void QCALLTYPE TypeBuilder_AddInterfaceImpl(QCall::ModuleHandle pModu } // This function will create a method within the class -extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethodSpec(QCall::ModuleHandle pModule, INT32 tkParent, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineMethodSpec(QCall::ModuleHandle pModule, INT32 tkParent, LPCBYTE pSignature, INT32 sigLength, INT32* pReturnValue) { QCALL_CONTRACT; @@ -191,12 +184,12 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethodSpec(QCall::ModuleHandle pMod sigLength, //Size of the signature blob &memberE) ); //[OUT]methodToken - END_QCALL; + *pReturnValue = (INT32) memberE; - return (INT32) memberE; + END_QCALL; } -extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethod(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attributes, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineMethod(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attributes, INT32* pReturnValue) { QCALL_CONTRACT; @@ -217,9 +210,9 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethod(QCall::ModuleHandle pModule, miIL | miManaged, //Implementation Flags is default to managed IL &memberE) ); //[OUT]methodToken - END_QCALL; + *pReturnValue = (INT32) memberE; - return (INT32) memberE; + END_QCALL; } /*================================DefineField================================= @@ -228,7 +221,7 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethod(QCall::ModuleHandle pModule, **Arguments: **Exceptions: ==============================================================================*/ -extern "C" mdFieldDef QCALLTYPE TypeBuilder_DefineField(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attr, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineField(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attr, mdFieldDef* pReturnValue) { QCALL_CONTRACT; @@ -247,9 +240,9 @@ extern "C" mdFieldDef QCALLTYPE TypeBuilder_DefineField(QCall::ModuleHandle pMod (ULONG) -1, &retVal) ); - END_QCALL; + *pReturnValue = retVal; - return retVal; + END_QCALL; } // This method computes the same result as COR_ILMETHOD_SECT_EH::Size(...) but @@ -302,7 +295,7 @@ UINT32 ExceptionHandlingSize(unsigned uNumExceptions, COR_ILMETHOD_SECT_EH_CLAUS // SetMethodIL -- This function will create a method within the class -extern "C" void QCALLTYPE TypeBuilder_SetMethodIL(QCall::ModuleHandle pModule, +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetMethodIL(QCall::ModuleHandle pModule, INT32 tk, BOOL fIsInitLocal, LPCBYTE pBody, @@ -313,8 +306,7 @@ extern "C" void QCALLTYPE TypeBuilder_SetMethodIL(QCall::ModuleHandle pModule, ExceptionInstance * pExceptions, INT32 numExceptions, INT32 * pTokenFixups, - INT32 numTokenFixups, - QCallExceptionStatus* qcallError) + INT32 numTokenFixups) { QCALL_CONTRACT; @@ -473,7 +465,7 @@ extern "C" void QCALLTYPE TypeBuilder_SetMethodIL(QCall::ModuleHandle pModule, END_QCALL; } -extern "C" void QCALLTYPE TypeBuilder_TermCreateClass(QCall::ModuleHandle pModule, INT32 tk, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_TermCreateClass(QCall::ModuleHandle pModule, INT32 tk, QCall::ObjectHandleOnStack retType) { QCALL_CONTRACT; @@ -515,7 +507,7 @@ void COMDynamicWrite::TermCreateClass(Module* pModule, INT32 tk, QCall::ObjectHa **Arguments: **Exceptions: ==============================================================================*/ -extern "C" void QCALLTYPE TypeBuilder_SetPInvokeData(QCall::ModuleHandle pModule, LPCWSTR wszDllName, LPCWSTR wszFunctionName, INT32 token, INT32 linkFlags, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetPInvokeData(QCall::ModuleHandle pModule, LPCWSTR wszDllName, LPCWSTR wszFunctionName, INT32 token, INT32 linkFlags) { QCALL_CONTRACT; @@ -544,7 +536,7 @@ extern "C" void QCALLTYPE TypeBuilder_SetPInvokeData(QCall::ModuleHandle pModule **Arguments: **Exceptions: ==============================================================================*/ -extern "C" INT32 QCALLTYPE TypeBuilder_DefineProperty(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineProperty(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, LPCBYTE pSignature, INT32 sigLength, INT32* pReturnValue) { QCALL_CONTRACT; @@ -570,9 +562,9 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineProperty(QCall::ModuleHandle pModul NULL, // no other methods &pr)); - END_QCALL; + *pReturnValue = (INT32)pr; - return (INT32)pr; + END_QCALL; } /*============================DefineEvent============================ @@ -581,7 +573,7 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineProperty(QCall::ModuleHandle pModul **Arguments: **Exceptions: ==============================================================================*/ -extern "C" INT32 QCALLTYPE TypeBuilder_DefineEvent(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, INT32 tkEventType, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineEvent(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, INT32 tkEventType, INT32* pReturnValue) { QCALL_CONTRACT; @@ -600,9 +592,9 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineEvent(QCall::ModuleHandle pModule, tkEventType, // the event type. Can be TypeDef or TypeRef &ev)); - END_QCALL; + *pReturnValue = (INT32)ev; - return (INT32)ev; + END_QCALL; } /*============================DefineMethodSemantics============================ @@ -611,7 +603,7 @@ extern "C" INT32 QCALLTYPE TypeBuilder_DefineEvent(QCall::ModuleHandle pModule, **Arguments: **Exceptions: ==============================================================================*/ -extern "C" void QCALLTYPE TypeBuilder_DefineMethodSemantics(QCall::ModuleHandle pModule, INT32 tkAssociation, INT32 attr, INT32 tkMethod, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineMethodSemantics(QCall::ModuleHandle pModule, INT32 tkAssociation, INT32 attr, INT32 tkMethod) { QCALL_CONTRACT; @@ -632,7 +624,7 @@ extern "C" void QCALLTYPE TypeBuilder_DefineMethodSemantics(QCall::ModuleHandle /*============================SetMethodImpl============================ ** To set a Method's Implementation flags ==============================================================================*/ -extern "C" void QCALLTYPE TypeBuilder_SetMethodImpl(QCall::ModuleHandle pModule, INT32 tkMethod, INT32 attr, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetMethodImpl(QCall::ModuleHandle pModule, INT32 tkMethod, INT32 attr) { QCALL_CONTRACT; @@ -652,7 +644,7 @@ extern "C" void QCALLTYPE TypeBuilder_SetMethodImpl(QCall::ModuleHandle pModule, /*============================DefineMethodImpl============================ ** Define a MethodImpl record ==============================================================================*/ -extern "C" void QCALLTYPE TypeBuilder_DefineMethodImpl(QCall::ModuleHandle pModule, UINT32 tkType, UINT32 tkBody, UINT32 tkDecl, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineMethodImpl(QCall::ModuleHandle pModule, UINT32 tkType, UINT32 tkBody, UINT32 tkDecl) { QCALL_CONTRACT; @@ -676,7 +668,7 @@ extern "C" void QCALLTYPE TypeBuilder_DefineMethodImpl(QCall::ModuleHandle pModu **Arguments: **Exceptions: ==============================================================================*/ -extern "C" INT32 QCALLTYPE TypeBuilder_GetTokenFromSig(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_GetTokenFromSig(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, INT32* pReturnValue) { QCALL_CONTRACT; @@ -695,9 +687,9 @@ extern "C" INT32 QCALLTYPE TypeBuilder_GetTokenFromSig(QCall::ModuleHandle pModu sigLength, // blob length &retVal)); // returned token - END_QCALL; + *pReturnValue = (INT32)retVal; - return (INT32)retVal; + END_QCALL; } /*============================SetParamInfo============================ @@ -706,7 +698,7 @@ extern "C" INT32 QCALLTYPE TypeBuilder_GetTokenFromSig(QCall::ModuleHandle pModu **Arguments: **Exceptions: ==============================================================================*/ -extern "C" INT32 QCALLTYPE TypeBuilder_SetParamInfo(QCall::ModuleHandle pModule, UINT32 tkMethod, UINT32 iSequence, UINT32 iAttributes, LPCWSTR wszParamName, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetParamInfo(QCall::ModuleHandle pModule, UINT32 tkMethod, UINT32 iSequence, UINT32 iAttributes, LPCWSTR wszParamName, INT32* pReturnValue) { QCALL_CONTRACT; @@ -728,9 +720,9 @@ extern "C" INT32 QCALLTYPE TypeBuilder_SetParamInfo(QCall::ModuleHandle pModule, (ULONG) -1, &retVal)); - END_QCALL; + *pReturnValue = (INT32)retVal; - return (INT32)retVal; + END_QCALL; } @@ -740,7 +732,7 @@ extern "C" INT32 QCALLTYPE TypeBuilder_SetParamInfo(QCall::ModuleHandle pModule, **Arguments: **Exceptions: ==============================================================================*/ -extern "C" void QCALLTYPE TypeBuilder_SetConstantValue(QCall::ModuleHandle pModule, UINT32 tk, DWORD valueCorType, LPVOID pValue, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetConstantValue(QCall::ModuleHandle pModule, UINT32 tk, DWORD valueCorType, LPVOID pValue) { QCALL_CONTRACT; @@ -796,7 +788,7 @@ extern "C" void QCALLTYPE TypeBuilder_SetConstantValue(QCall::ModuleHandle pModu **Arguments: **Exceptions: ==============================================================================*/ -extern "C" void QCALLTYPE TypeBuilder_SetFieldLayoutOffset(QCall::ModuleHandle pModule, INT32 tkField, INT32 iOffset, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetFieldLayoutOffset(QCall::ModuleHandle pModule, INT32 tkField, INT32 iOffset) { QCALL_CONTRACT; @@ -820,7 +812,7 @@ extern "C" void QCALLTYPE TypeBuilder_SetFieldLayoutOffset(QCall::ModuleHandle p **Arguments: **Exceptions: ==============================================================================*/ -extern "C" void QCALLTYPE TypeBuilder_SetClassLayout(QCall::ModuleHandle pModule, INT32 tk, INT32 iPackSize, UINT32 iTotalSize, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetClassLayout(QCall::ModuleHandle pModule, INT32 tk, INT32 iPackSize, UINT32 iTotalSize) { QCALL_CONTRACT; @@ -915,7 +907,7 @@ void UpdateRuntimeStateForAssemblyCustomAttribute(Module* pModule, mdToken tkCus } } -extern "C" void QCALLTYPE TypeBuilder_DefineCustomAttribute(QCall::ModuleHandle pModule, INT32 token, INT32 conTok, LPCBYTE pBlob, INT32 cbBlob, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineCustomAttribute(QCall::ModuleHandle pModule, INT32 token, INT32 conTok, LPCBYTE pBlob, INT32 cbBlob) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/comdynamic.h b/src/coreclr/vm/comdynamic.h index db257034698556..2f124a4d3a2b1b 100644 --- a/src/coreclr/vm/comdynamic.h +++ b/src/coreclr/vm/comdynamic.h @@ -31,49 +31,46 @@ class COMDynamicWrite INT32 tkParent, INT32 attributes, INT32 tkEnclosingType, - INT32 * pInterfaceTokens, - QCallExceptionStatus* qcallError); + INT32 * pInterfaceTokens); static void TermCreateClass(Module* pModule, INT32 tk, QCall::ObjectHandleOnStack retType); }; // This function will create the class's metadata definition -extern "C" INT32 QCALLTYPE TypeBuilder_DefineType(QCall::ModuleHandle pModule, +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineType(QCall::ModuleHandle pModule, LPCWSTR wszFullName, INT32 tkParent, INT32 attributes, INT32 tkEnclosingType, - INT32 * pInterfaceTokens, - QCallExceptionStatus* qcallError); + INT32 * pInterfaceTokens, INT32* pReturnValue); -extern "C" INT32 QCALLTYPE TypeBuilder_DefineGenericParam(QCall::ModuleHandle pModule, +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineGenericParam(QCall::ModuleHandle pModule, LPCWSTR wszFullName, INT32 tkParent, INT32 attributes, INT32 position, - INT32 * pConstraintTokens, - QCallExceptionStatus* qcallError); + INT32 * pConstraintTokens, INT32* pReturnValue); // This function will reset the parent class in metadata -extern "C" void QCALLTYPE TypeBuilder_SetParentType(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkParent, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetParentType(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkParent); // This function will add another interface impl -extern "C" void QCALLTYPE TypeBuilder_AddInterfaceImpl(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkInterface, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_AddInterfaceImpl(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkInterface); // This function will create a method within the class -extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethod(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attributes, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineMethod(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attributes, INT32* pReturnValue); -extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethodSpec(QCall::ModuleHandle pModule, INT32 tkParent, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineMethodSpec(QCall::ModuleHandle pModule, INT32 tkParent, LPCBYTE pSignature, INT32 sigLength, INT32* pReturnValue); // This function will create a method within the class -extern "C" void QCALLTYPE TypeBuilder_SetMethodIL(QCall::ModuleHandle pModule, +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetMethodIL(QCall::ModuleHandle pModule, INT32 tk, BOOL fIsInitLocal, LPCBYTE pBody, @@ -84,58 +81,57 @@ extern "C" void QCALLTYPE TypeBuilder_SetMethodIL(QCall::ModuleHandle pModule, ExceptionInstance * pExceptions, INT32 numExceptions, INT32 * pTokenFixups, - INT32 numTokenFixups, - QCallExceptionStatus* qcallError); + INT32 numTokenFixups); -extern "C" void QCALLTYPE TypeBuilder_TermCreateClass(QCall::ModuleHandle pModule, INT32 tk, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_TermCreateClass(QCall::ModuleHandle pModule, INT32 tk, QCall::ObjectHandleOnStack retType); -extern "C" mdFieldDef QCALLTYPE TypeBuilder_DefineField(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attr, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineField(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attr, mdFieldDef* pReturnValue); -extern "C" void QCALLTYPE TypeBuilder_SetPInvokeData(QCall::ModuleHandle pModule, LPCWSTR wszDllName, LPCWSTR wszFunctionName, INT32 token, INT32 linkFlags, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetPInvokeData(QCall::ModuleHandle pModule, LPCWSTR wszDllName, LPCWSTR wszFunctionName, INT32 token, INT32 linkFlags); -extern "C" INT32 QCALLTYPE TypeBuilder_DefineProperty(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineProperty(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, LPCBYTE pSignature, INT32 sigLength, INT32* pReturnValue); -extern "C" INT32 QCALLTYPE TypeBuilder_DefineEvent(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, INT32 tkEventType, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineEvent(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, INT32 tkEventType, INT32* pReturnValue); // functions to set Setter, Getter, Reset, TestDefault, and other methods -extern "C" void QCALLTYPE TypeBuilder_DefineMethodSemantics(QCall::ModuleHandle pModule, INT32 tkAssociation, INT32 attr, INT32 tkMethod, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineMethodSemantics(QCall::ModuleHandle pModule, INT32 tkAssociation, INT32 attr, INT32 tkMethod); // functions to set method's implementation flag -extern "C" void QCALLTYPE TypeBuilder_SetMethodImpl(QCall::ModuleHandle pModule, INT32 tkMethod, INT32 attr, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetMethodImpl(QCall::ModuleHandle pModule, INT32 tkMethod, INT32 attr); // functions to create MethodImpl record -extern "C" void QCALLTYPE TypeBuilder_DefineMethodImpl(QCall::ModuleHandle pModule, UINT32 tkType, UINT32 tkBody, UINT32 tkDecl, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineMethodImpl(QCall::ModuleHandle pModule, UINT32 tkType, UINT32 tkBody, UINT32 tkDecl); // GetTokenFromSig's argument -extern "C" INT32 QCALLTYPE TypeBuilder_GetTokenFromSig(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_GetTokenFromSig(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, INT32* pReturnValue); // Set Field offset -extern "C" void QCALLTYPE TypeBuilder_SetFieldLayoutOffset(QCall::ModuleHandle pModule, INT32 tkField, INT32 iOffset, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetFieldLayoutOffset(QCall::ModuleHandle pModule, INT32 tkField, INT32 iOffset); // Set classlayout info -extern "C" void QCALLTYPE TypeBuilder_SetClassLayout(QCall::ModuleHandle pModule, INT32 tk, INT32 iPackSize, UINT32 iTotalSize, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetClassLayout(QCall::ModuleHandle pModule, INT32 tk, INT32 iPackSize, UINT32 iTotalSize); // Set a custom attribute -extern "C" void QCALLTYPE TypeBuilder_DefineCustomAttribute(QCall::ModuleHandle pModule, INT32 token, INT32 conTok, LPCBYTE pBlob, INT32 cbBlob, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineCustomAttribute(QCall::ModuleHandle pModule, INT32 token, INT32 conTok, LPCBYTE pBlob, INT32 cbBlob); // functions to set ParamInfo -extern "C" INT32 QCALLTYPE TypeBuilder_SetParamInfo(QCall::ModuleHandle pModule, UINT32 tkMethod, UINT32 iSequence, UINT32 iAttributes, LPCWSTR wszParamName, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetParamInfo(QCall::ModuleHandle pModule, UINT32 tkMethod, UINT32 iSequence, UINT32 iAttributes, LPCWSTR wszParamName, INT32* pReturnValue); // functions to set default value -extern "C" void QCALLTYPE TypeBuilder_SetConstantValue(QCall::ModuleHandle pModule, UINT32 tk, DWORD valueType, LPVOID pValue, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetConstantValue(QCall::ModuleHandle pModule, UINT32 tk, DWORD valueType, LPVOID pValue); #endif // _COMDYNAMIC_H_ diff --git a/src/coreclr/vm/commodule.cpp b/src/coreclr/vm/commodule.cpp index 61b48f17a6de50..5021a667cf45dd 100644 --- a/src/coreclr/vm/commodule.cpp +++ b/src/coreclr/vm/commodule.cpp @@ -21,11 +21,10 @@ // wszFullName is escaped (TYPE_NAME_RESERVED_CHAR). It should not be byref or contain enclosing type name, // assembly name, and generic argument list. //************************************************** -extern "C" mdTypeRef QCALLTYPE ModuleBuilder_GetTypeRef(QCall::ModuleHandle pModule, +extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetTypeRef(QCall::ModuleHandle pModule, LPCWSTR wszFullName, QCall::ModuleHandle pRefedModule, - INT32 tkResolutionArg, - QCallExceptionStatus* qcallError) + INT32 tkResolutionArg, mdTypeRef* pReturnValue) { QCALL_CONTRACT; @@ -110,9 +109,9 @@ extern "C" mdTypeRef QCALLTYPE ModuleBuilder_GetTypeRef(QCall::ModuleHandle pMod IfFailThrow( pEmit->DefineTypeRefByName(tkResolution, wszFullNameUnescaped, &tr) ); } - END_QCALL; + *pReturnValue = tr; - return tr; + END_QCALL; } @@ -125,12 +124,11 @@ extern "C" mdTypeRef QCALLTYPE ModuleBuilder_GetTypeRef(QCall::ModuleHandle pMod ** int tkTypeSpec **Exceptions: ==============================================================================*/ -extern "C" INT32 QCALLTYPE ModuleBuilder_GetArrayMethodToken(QCall::ModuleHandle pModule, +extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetArrayMethodToken(QCall::ModuleHandle pModule, INT32 tkTypeSpec, LPCWSTR wszMethodName, LPCBYTE pSignature, - INT32 sigLength, - QCallExceptionStatus* qcallError) + INT32 sigLength, INT32* pReturnValue) { QCALL_CONTRACT; @@ -153,9 +151,9 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetArrayMethodToken(QCall::ModuleHandle COMPlusThrowHR(hr); } - END_QCALL; + *pReturnValue = (INT32)memberRefE; - return (INT32)memberRefE; + END_QCALL; } namespace @@ -205,7 +203,7 @@ namespace // This function will return a MemberRef token given a MethodDef token and the module where the MethodDef/FieldDef is defined. // //****************************************************************************** -extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRef(QCall::ModuleHandle pModule, QCall::ModuleHandle pRefedModule, INT32 tr, INT32 token, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRef(QCall::ModuleHandle pModule, QCall::ModuleHandle pRefedModule, INT32 tr, INT32 token, INT32* pReturnValue) { QCALL_CONTRACT; @@ -275,10 +273,11 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRef(QCall::ModuleHandle pModul // Define the memberRef IfFailThrow( pRCW->GetEmitter()->DefineMemberRef(tref, wzName, (PCCOR_SIGNATURE) qbNewSig.Ptr(), cbNewSig, &memberRefE) ); - END_QCALL; - // assign output parameter - return (INT32)memberRefE; + + *pReturnValue = (INT32)memberRefE; + + END_QCALL; } //****************************************************************************** @@ -286,7 +285,7 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRef(QCall::ModuleHandle pModul // Return a MemberRef token given a RuntimeMethodInfo // //****************************************************************************** -extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo(QCall::ModuleHandle pModule, INT32 tr, MethodDesc * pMeth, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo(QCall::ModuleHandle pModule, INT32 tr, MethodDesc * pMeth, INT32* pReturnValue) { QCALL_CONTRACT; @@ -354,9 +353,9 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo(QCall::ModuleH IfFailThrow( pRCW->GetEmitter()->DefineMemberRef(tr, wszName, (PCCOR_SIGNATURE) qbNewSig.Ptr(), cbNewSig, &memberRefE) ); } - END_QCALL; + *pReturnValue = memberRefE; - return memberRefE; + END_QCALL; } @@ -365,7 +364,7 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo(QCall::ModuleH // Return a MemberRef token given a RuntimeFieldInfo // //****************************************************************************** -extern "C" mdMemberRef QCALLTYPE ModuleBuilder_GetMemberRefOfFieldInfo(QCall::ModuleHandle pModule, mdTypeDef tr, QCall::TypeHandle th, mdFieldDef tkField, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRefOfFieldInfo(QCall::ModuleHandle pModule, mdTypeDef tr, QCall::TypeHandle th, mdFieldDef tkField, mdMemberRef* pReturnValue) { QCALL_CONTRACT; @@ -429,9 +428,9 @@ extern "C" mdMemberRef QCALLTYPE ModuleBuilder_GetMemberRefOfFieldInfo(QCall::Mo IfFailThrow( pRCW->GetEmitter()->DefineMemberRef(tr, wszName, (PCCOR_SIGNATURE) qbNewSig.Ptr(), cbNewSig, &memberRefE) ); } - END_QCALL; + *pReturnValue = memberRefE; - return memberRefE; + END_QCALL; } //****************************************************************************** @@ -439,12 +438,11 @@ extern "C" mdMemberRef QCALLTYPE ModuleBuilder_GetMemberRefOfFieldInfo(QCall::Mo // Return a MemberRef token given a Signature // //****************************************************************************** -extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefFromSignature(QCall::ModuleHandle pModule, +extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRefFromSignature(QCall::ModuleHandle pModule, INT32 tr, LPCWSTR wszMemberName, LPCBYTE pSignature, - INT32 sigLength, - QCallExceptionStatus* qcallError) + INT32 sigLength, INT32* pReturnValue) { QCALL_CONTRACT; @@ -461,9 +459,9 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefFromSignature(QCall::Module sigLength, &memberRefE) ); - END_QCALL; + *pReturnValue = memberRefE; - return memberRefE; + END_QCALL; } //****************************************************************************** @@ -472,7 +470,7 @@ extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefFromSignature(QCall::Module // This function is used to set the FieldRVA with the content data // //****************************************************************************** -extern "C" void QCALLTYPE ModuleBuilder_SetFieldRVAContent(QCall::ModuleHandle pModule, INT32 tkField, LPCBYTE pContent, INT32 length, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_SetFieldRVAContent(QCall::ModuleHandle pModule, INT32 tkField, LPCBYTE pContent, INT32 length) { QCALL_CONTRACT; @@ -528,7 +526,7 @@ extern "C" void QCALLTYPE ModuleBuilder_SetFieldRVAContent(QCall::ModuleHandle p // string constant or return the token of an existing constant. // //****************************************************************************** -extern "C" mdString QCALLTYPE ModuleBuilder_GetStringConstant(QCall::ModuleHandle pModule, LPCWSTR pwzValue, INT32 iLength, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetStringConstant(QCall::ModuleHandle pModule, LPCWSTR pwzValue, INT32 iLength, mdString* pReturnValue) { QCALL_CONTRACT; @@ -546,16 +544,16 @@ extern "C" mdString QCALLTYPE ModuleBuilder_GetStringConstant(QCall::ModuleHandl COMPlusThrowHR(hr); } - END_QCALL; + *pReturnValue = strRef; - return strRef; + END_QCALL; } /*=============================SetModuleName==================================== // SetModuleName ==============================================================================*/ -extern "C" void QCALLTYPE ModuleBuilder_SetModuleName(QCall::ModuleHandle pModule, LPCWSTR wszModuleName, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_SetModuleName(QCall::ModuleHandle pModule, LPCWSTR wszModuleName) { QCALL_CONTRACT; @@ -574,7 +572,7 @@ extern "C" void QCALLTYPE ModuleBuilder_SetModuleName(QCall::ModuleHandle pModul // Return a type spec token given a byte array // //****************************************************************************** -extern "C" mdTypeSpec QCALLTYPE ModuleBuilder_GetTokenFromTypeSpec(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetTokenFromTypeSpec(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, mdTypeSpec* pReturnValue) { QCALL_CONTRACT; @@ -587,15 +585,15 @@ extern "C" mdTypeSpec QCALLTYPE ModuleBuilder_GetTokenFromTypeSpec(QCall::Module IfFailThrow(pRCW->GetEmitter()->GetTokenFromTypeSpec((PCCOR_SIGNATURE)pSignature, sigLength, &ts)); - END_QCALL; + *pReturnValue = ts; - return ts; + END_QCALL; } // GetName // This routine will return the name of the module as a String -extern "C" void QCALLTYPE RuntimeModule_GetScopeName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeModule_GetScopeName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString) { QCALL_CONTRACT; @@ -619,7 +617,7 @@ extern "C" void QCALLTYPE RuntimeModule_GetScopeName(QCall::ModuleHandle pModule **Arguments: **Exceptions: ==============================================================================*/ -extern "C" void QCALLTYPE RuntimeModule_GetFullyQualifiedName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeModule_GetFullyQualifiedName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString) { QCALL_CONTRACT; @@ -653,7 +651,7 @@ extern "C" void QCALLTYPE RuntimeModule_GetFullyQualifiedName(QCall::ModuleHandl **Arguments: refThis **Exceptions: None. ==============================================================================*/ -extern "C" HINSTANCE QCALLTYPE MarshalNative_GetHINSTANCE(QCall::ModuleHandle pModule, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetHINSTANCE(QCall::ModuleHandle pModule, HINSTANCE* pReturnValue) { QCALL_CONTRACT; @@ -674,14 +672,14 @@ extern "C" HINSTANCE QCALLTYPE MarshalNative_GetHINSTANCE(QCall::ModuleHandle pM hMod = (HMODULE)-1; } - END_QCALL; + *pReturnValue = (HINSTANCE)hMod; - return (HINSTANCE)hMod; + END_QCALL; } // Get class will return an array contain all of the classes // that are defined within this Module. -extern "C" void QCALLTYPE RuntimeModule_GetTypes(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retTypes, QCall::ObjectHandleOnStack retExceptions, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeModule_GetTypes(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retTypes, QCall::ObjectHandleOnStack retExceptions) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/commodule.h b/src/coreclr/vm/commodule.h index 7e365f4515cdbf..8780c4d251ce52 100644 --- a/src/coreclr/vm/commodule.h +++ b/src/coreclr/vm/commodule.h @@ -19,63 +19,60 @@ class COMModule // GetTypeRef // This function will return the class token for the named element. -extern "C" mdTypeRef QCALLTYPE ModuleBuilder_GetTypeRef(QCall::ModuleHandle pModule, +extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetTypeRef(QCall::ModuleHandle pModule, LPCWSTR wszFullName, QCall::ModuleHandle pRefedModule, - INT32 tkResolution, - QCallExceptionStatus* qcallError); + INT32 tkResolution, mdTypeRef* pReturnValue); // SetFieldRVAContent // This function is used to set the FieldRVA with the content data -extern "C" void QCALLTYPE ModuleBuilder_SetFieldRVAContent(QCall::ModuleHandle pModule, INT32 tkField, LPCBYTE pContent, INT32 length, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_SetFieldRVAContent(QCall::ModuleHandle pModule, INT32 tkField, LPCBYTE pContent, INT32 length); //GetArrayMethodToken -extern "C" INT32 QCALLTYPE ModuleBuilder_GetArrayMethodToken(QCall::ModuleHandle pModule, +extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetArrayMethodToken(QCall::ModuleHandle pModule, INT32 tkTypeSpec, LPCWSTR wszMethodName, LPCBYTE pSignature, - INT32 sigLength, - QCallExceptionStatus* qcallError); + INT32 sigLength, INT32* pReturnValue); // GetMemberRefToken // This function will return the MemberRef token -extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRef(QCall::ModuleHandle pModule, QCall::ModuleHandle pRefedModule, INT32 tr, INT32 token, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRef(QCall::ModuleHandle pModule, QCall::ModuleHandle pRefedModule, INT32 tr, INT32 token, INT32* pReturnValue); // This function return a MemberRef token given a MethodInfo describing an array method -extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo(QCall::ModuleHandle pModule, INT32 tr, MethodDesc * method, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo(QCall::ModuleHandle pModule, INT32 tr, MethodDesc * method, INT32* pReturnValue); // GetMemberRefOfFieldInfo // This function will return a memberRef token given a FieldInfo -extern "C" mdMemberRef QCALLTYPE ModuleBuilder_GetMemberRefOfFieldInfo(QCall::ModuleHandle pModule, mdTypeDef tr, QCall::TypeHandle th, mdFieldDef tkField, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRefOfFieldInfo(QCall::ModuleHandle pModule, mdTypeDef tr, QCall::TypeHandle th, mdFieldDef tkField, mdMemberRef* pReturnValue); // GetMemberRefFromSignature // This function will return the MemberRef token given the signature from managed code -extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefFromSignature(QCall::ModuleHandle pModule, +extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRefFromSignature(QCall::ModuleHandle pModule, INT32 tr, LPCWSTR wszMemberName, LPCBYTE pSignature, - INT32 sigLength, - QCallExceptionStatus* qcallError); + INT32 sigLength, INT32* pReturnValue); // GetTokenFromTypeSpec -extern "C" mdTypeSpec QCALLTYPE ModuleBuilder_GetTokenFromTypeSpec(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetTokenFromTypeSpec(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, mdTypeSpec* pReturnValue); // GetStringConstant // If this is a dynamic module, this routine will define a new // string constant or return the token of an existing constant. -extern "C" mdString QCALLTYPE ModuleBuilder_GetStringConstant(QCall::ModuleHandle pModule, LPCWSTR pwzValue, INT32 iLength, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetStringConstant(QCall::ModuleHandle pModule, LPCWSTR pwzValue, INT32 iLength, mdString* pReturnValue); -extern "C" void QCALLTYPE ModuleBuilder_SetModuleName(QCall::ModuleHandle pModule, LPCWSTR wszModuleName, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_SetModuleName(QCall::ModuleHandle pModule, LPCWSTR wszModuleName); -extern "C" void QCALLTYPE RuntimeModule_GetScopeName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeModule_GetScopeName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString); -extern "C" void QCALLTYPE RuntimeModule_GetFullyQualifiedName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeModule_GetFullyQualifiedName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString); // GetTypes will return an array containing all of the types that are defined within this Module. -extern "C" void QCALLTYPE RuntimeModule_GetTypes(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retTypes, QCall::ObjectHandleOnStack retExceptions, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeModule_GetTypes(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retTypes, QCall::ObjectHandleOnStack retExceptions); -extern "C" HINSTANCE QCALLTYPE MarshalNative_GetHINSTANCE(QCall::ModuleHandle pModule, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetHINSTANCE(QCall::ModuleHandle pModule, HINSTANCE* pReturnValue); #endif diff --git a/src/coreclr/vm/comsynchronizable.cpp b/src/coreclr/vm/comsynchronizable.cpp index 66a807075cffa8..085b41aaf80ec2 100644 --- a/src/coreclr/vm/comsynchronizable.cpp +++ b/src/coreclr/vm/comsynchronizable.cpp @@ -197,7 +197,7 @@ static ULONG WINAPI KickOffThread(void* pass) return 0; } -extern "C" BOOL QCALLTYPE ThreadNative_Start(QCall::ThreadHandle thread, int threadStackSize, int priority, BOOL isThreadPool, PCWSTR pThreadName, QCall::ObjectHandleOnStack exception, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_Start(QCall::ThreadHandle thread, int threadStackSize, int priority, BOOL isThreadPool, PCWSTR pThreadName, QCall::ObjectHandleOnStack exception, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -282,12 +282,12 @@ extern "C" BOOL QCALLTYPE ThreadNative_Start(QCall::ThreadHandle thread, int thr exception.Set(pNewThread->GetExceptionDuringStartup()); } - END_QCALL; + *pReturnValue = result; - return result; + END_QCALL; } -extern "C" void QCALLTYPE ThreadNative_SetPriority(QCall::ObjectHandleOnStack thread, INT32 iPriority, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_SetPriority(QCall::ObjectHandleOnStack thread, INT32 iPriority) { QCALL_CONTRACT; @@ -328,7 +328,7 @@ extern "C" void QCALLTYPE ThreadNative_SetPriority(QCall::ObjectHandleOnStack th END_QCALL; } -extern "C" void QCALLTYPE ThreadNative_GetCurrentThread(QCall::ObjectHandleOnStack thread, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetCurrentThread(QCall::ObjectHandleOnStack thread) { QCALL_CONTRACT; @@ -340,7 +340,7 @@ extern "C" void QCALLTYPE ThreadNative_GetCurrentThread(QCall::ObjectHandleOnSta END_QCALL; } -extern "C" UINT64 QCALLTYPE ThreadNative_GetCurrentOSThreadId(QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetCurrentOSThreadId(UINT64* pReturnValue) { QCALL_CONTRACT; @@ -357,12 +357,12 @@ extern "C" UINT64 QCALLTYPE ThreadNative_GetCurrentOSThreadId(QCallExceptionStat #else threadId = (UINT64) PAL_GetCurrentOSThreadId(); #endif - END_QCALL; + *pReturnValue = threadId; - return threadId; + END_QCALL; } -extern "C" void QCALLTYPE ThreadNative_Initialize(QCall::ObjectHandleOnStack t, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_Initialize(QCall::ObjectHandleOnStack t) { QCALL_CONTRACT; @@ -431,7 +431,7 @@ extern "C" INT32 QCALLTYPE ThreadNative_GetThreadState(QCall::ThreadHandle threa // Return whether the thread hosts an STA, is a member of the MTA or is not // currently initialized for COM. -extern "C" INT32 QCALLTYPE ThreadNative_GetApartmentState(QCall::ObjectHandleOnStack t, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetApartmentState(QCall::ObjectHandleOnStack t, INT32* pReturnValue) { QCALL_CONTRACT; @@ -454,14 +454,15 @@ extern "C" INT32 QCALLTYPE ThreadNative_GetApartmentState(QCall::ObjectHandleOnS retVal = thread->GetApartment(); + *pReturnValue = retVal; + END_QCALL; - return retVal; } // Indicate whether the thread will host an STA (this may fail if the thread has // already been made part of the MTA, use GetApartmentState or the return state // from this routine to check for this). -extern "C" INT32 QCALLTYPE ThreadNative_SetApartmentState(QCall::ObjectHandleOnStack t, INT32 iState, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_SetApartmentState(QCall::ObjectHandleOnStack t, INT32 iState, INT32* pReturnValue) { QCALL_CONTRACT; @@ -500,13 +501,14 @@ extern "C" INT32 QCALLTYPE ThreadNative_SetApartmentState(QCall::ObjectHandleOnS retVal = thread->SetApartment((Thread::ApartmentState)iState); } + *pReturnValue = retVal; + END_QCALL; - return retVal; } #endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT #if TARGET_WINDOWS -extern "C" HANDLE QCALLTYPE ThreadNative_GetOSHandle(QCall::ThreadHandle t, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetOSHandle(QCall::ThreadHandle t, HANDLE* pReturnValue) { QCALL_CONTRACT; @@ -530,9 +532,9 @@ extern "C" HANDLE QCALLTYPE ThreadNative_GetOSHandle(QCall::ThreadHandle t, QCal } } - END_QCALL; + *pReturnValue = retVal; - return retVal; + END_QCALL; } #endif @@ -635,7 +637,7 @@ extern "C" BOOL QCALLTYPE ThreadNative_GetIsBackground(QCall::ThreadHandle threa } // Set whether or not this is a background thread. -extern "C" void QCALLTYPE ThreadNative_SetIsBackground(QCall::ThreadHandle thread, BOOL value, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_SetIsBackground(QCall::ThreadHandle thread, BOOL value) { CONTRACTL { @@ -651,7 +653,7 @@ extern "C" void QCALLTYPE ThreadNative_SetIsBackground(QCall::ThreadHandle threa END_QCALL; } -extern "C" void QCALLTYPE ThreadNative_InformThreadNameChange(QCall::ThreadHandle thread, LPCWSTR name, INT32 len, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_InformThreadNameChange(QCall::ThreadHandle thread, LPCWSTR name, INT32 len) { QCALL_CONTRACT; @@ -700,16 +702,34 @@ FCIMPL0(INT32, ThreadNative::GetOptimalMaxSpinWaitsPerSpinIteration) } FCIMPLEND -FCIMPL0(Object*, ThreadNative::GetAndClearQCallException) +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetQCallSpecialException( + INT_PTR status, + QCall::ObjectHandleOnStack exception) { - FCALL_CONTRACT; + QCALL_CONTRACT; + + _ASSERTE(status == QCallOutOfMemoryException || + status == QCallStackOverflowException); - Object *result = t_ThreadStatics.pQCallException; - t_ThreadStatics.pQCallException = NULL; + BEGIN_QCALL; + + GCX_COOP(); - return result; + OBJECTREF throwable; + if (status == QCallOutOfMemoryException) + { + throwable = CLRException::GetPreallocatedOutOfMemoryException(); + } + else + { + EEException stackOverflowException(kStackOverflowException); + throwable = stackOverflowException.CreateThrowable(); + } + + exception.Set(throwable); + + END_QCALL; } -FCIMPLEND // Returns the address of the current thread's ThreadLocalData (&t_ThreadStatics). Used on wasm to break // the thread-static bootstrap recursion in Thread.GetThreadStaticsBase (see the managed counterpart). @@ -738,7 +758,7 @@ extern "C" void QCALLTYPE ThreadNative_SpinWait(INT32 iterations) #ifdef TARGET_WINDOWS // This service can be called on unstarted and dead threads. For unstarted ones, the // next wait will be interrupted. For dead ones, this service quietly does nothing. -extern "C" void QCALLTYPE ThreadNative_Interrupt(QCall::ThreadHandle thread, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_Interrupt(QCall::ThreadHandle thread) { CONTRACTL { @@ -754,7 +774,7 @@ extern "C" void QCALLTYPE ThreadNative_Interrupt(QCall::ThreadHandle thread, QCa END_QCALL; } -extern "C" void QCALLTYPE ThreadNative_CheckForPendingInterrupt(QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_CheckForPendingInterrupt() { QCALL_CONTRACT; @@ -786,7 +806,7 @@ extern "C" void QCALLTYPE ThreadNative_PollGC() // and is thus marked as a GC safe point, and that the p/invoke rare path will kick in } -extern "C" BOOL QCALLTYPE ThreadNative_YieldThread(QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_YieldThread(BOOL* pReturnValue) { QCALL_CONTRACT; @@ -796,12 +816,12 @@ extern "C" BOOL QCALLTYPE ThreadNative_YieldThread(QCallExceptionStatus* qcallEr ret = __SwitchToThread(0, CALLER_LIMITS_SPINNING); - END_QCALL; + *pReturnValue = ret; - return ret; + END_QCALL; } -extern "C" void QCALLTYPE ThreadNative_Abort(QCall::ThreadHandle thread, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_Abort(QCall::ThreadHandle thread) { QCALL_CONTRACT; @@ -846,7 +866,7 @@ FCIMPL1(OBJECTHANDLE, ObjectHeader_GetLockHandleIfExists, Object* pObj) } FCIMPLEND -extern "C" void QCALLTYPE ObjectHeader_GetOrCreateLockObject(QCall::ObjectHandleOnStack obj, QCall::ObjectHandleOnStack lockObj, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ObjectHeader_GetOrCreateLockObject(QCall::ObjectHandleOnStack obj, QCall::ObjectHandleOnStack lockObj) { QCALL_CONTRACT; @@ -861,7 +881,7 @@ extern "C" void QCALLTYPE ObjectHeader_GetOrCreateLockObject(QCall::ObjectHandle END_QCALL; } -extern "C" INT32 QCALLTYPE ThreadNative_ReentrantWaitAny(BOOL alertable, INT32 timeout, INT32 count, HANDLE *handles, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_ReentrantWaitAny(BOOL alertable, INT32 timeout, INT32 count, HANDLE *handles, INT32* pReturnValue) { QCALL_CONTRACT; @@ -873,7 +893,7 @@ extern "C" INT32 QCALLTYPE ThreadNative_ReentrantWaitAny(BOOL alertable, INT32 t WaitMode mode = alertable ? WaitMode_Alertable : WaitMode_None; retVal = (INT32)pThread->DoReentrantWaitAny(count, handles, timeout, mode); - END_QCALL; + *pReturnValue = retVal; - return retVal; + END_QCALL; } diff --git a/src/coreclr/vm/comsynchronizable.h b/src/coreclr/vm/comsynchronizable.h index 347d8e8cd396ee..002107c28700fb 100644 --- a/src/coreclr/vm/comsynchronizable.h +++ b/src/coreclr/vm/comsynchronizable.h @@ -46,43 +46,43 @@ class ThreadNative FCDECL1(static void, Finalize, ThreadBaseObject* pThis); FCDECL0(static FC_BOOL_RET, CatchAtSafePoint); FCDECL0(static FC_BOOL_RET, CurrentThreadIsFinalizerThread); - FCDECL0(static Object*, GetAndClearQCallException); }; -extern "C" BOOL QCALLTYPE ThreadNative_Start(QCall::ThreadHandle thread, int threadStackSize, int priority, BOOL isThreadPool, PCWSTR pThreadName, QCall::ObjectHandleOnStack exception, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ThreadNative_SetPriority(QCall::ObjectHandleOnStack thread, INT32 iPriority, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ThreadNative_GetCurrentThread(QCall::ObjectHandleOnStack thread, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetQCallSpecialException(INT_PTR status, QCall::ObjectHandleOnStack exception); +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_Start(QCall::ThreadHandle thread, int threadStackSize, int priority, BOOL isThreadPool, PCWSTR pThreadName, QCall::ObjectHandleOnStack exception, BOOL* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_SetPriority(QCall::ObjectHandleOnStack thread, INT32 iPriority); +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetCurrentThread(QCall::ObjectHandleOnStack thread); extern "C" BOOL QCALLTYPE ThreadNative_GetIsBackground(QCall::ThreadHandle thread); -extern "C" void QCALLTYPE ThreadNative_SetIsBackground(QCall::ThreadHandle thread, BOOL value, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ThreadNative_InformThreadNameChange(QCall::ThreadHandle thread, LPCWSTR name, INT32 len, QCallExceptionStatus* qcallError); -extern "C" BOOL QCALLTYPE ThreadNative_YieldThread(QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_SetIsBackground(QCall::ThreadHandle thread, BOOL value); +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_InformThreadNameChange(QCall::ThreadHandle thread, LPCWSTR name, INT32 len); +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_YieldThread(BOOL* pReturnValue); extern "C" void QCALLTYPE ThreadNative_PollGC(); -extern "C" UINT64 QCALLTYPE ThreadNative_GetCurrentOSThreadId(QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ThreadNative_Initialize(QCall::ObjectHandleOnStack t, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetCurrentOSThreadId(UINT64* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_Initialize(QCall::ObjectHandleOnStack t); extern "C" INT32 QCALLTYPE ThreadNative_GetThreadState(QCall::ThreadHandle thread); -extern "C" INT32 QCALLTYPE ThreadNative_ReentrantWaitAny(BOOL alertable, INT32 timeout, INT32 count, HANDLE *handles, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_ReentrantWaitAny(BOOL alertable, INT32 timeout, INT32 count, HANDLE *handles, INT32* pReturnValue); #ifdef TARGET_WINDOWS -extern "C" void QCALLTYPE ThreadNative_Interrupt(QCall::ThreadHandle thread, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ThreadNative_CheckForPendingInterrupt(QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_Interrupt(QCall::ThreadHandle thread); +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_CheckForPendingInterrupt(); #endif // TARGET_WINDOWS #ifdef FEATURE_COMINTEROP_APARTMENT_SUPPORT -extern "C" INT32 QCALLTYPE ThreadNative_GetApartmentState(QCall::ObjectHandleOnStack t, QCallExceptionStatus* qcallError); -extern "C" INT32 QCALLTYPE ThreadNative_SetApartmentState(QCall::ObjectHandleOnStack t, INT32 iState, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetApartmentState(QCall::ObjectHandleOnStack t, INT32* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_SetApartmentState(QCall::ObjectHandleOnStack t, INT32 iState, INT32* pReturnValue); #endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT #ifdef TARGET_WINDOWS -extern "C" HANDLE QCALLTYPE ThreadNative_GetOSHandle(QCall::ThreadHandle t, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetOSHandle(QCall::ThreadHandle t, HANDLE* pReturnValue); #endif // TARGET_WINDOWS -extern "C" void QCALLTYPE ThreadNative_Abort(QCall::ThreadHandle thread, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_Abort(QCall::ThreadHandle thread); extern "C" void QCALLTYPE ThreadNative_ResetAbort(); extern "C" void QCALLTYPE ThreadNative_SpinWait(INT32 iterations); #ifdef FEATURE_COMINTEROP extern "C" void QCALLTYPE ThreadNative_DisableComObjectEagerCleanup(QCall::ThreadHandle thread); #endif // FEATURE_COMINTEROP -extern "C" void QCALLTYPE ObjectHeader_GetOrCreateLockObject(QCall::ObjectHandleOnStack obj, QCall::ObjectHandleOnStack lockObj, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ObjectHeader_GetOrCreateLockObject(QCall::ObjectHandleOnStack obj, QCall::ObjectHandleOnStack lockObj); FCDECL1(OBJECTHANDLE, ObjectHeader_GetLockHandleIfExists, Object* obj); #endif // _COMSYNCHRONIZABLE_H diff --git a/src/coreclr/vm/comutilnative.cpp b/src/coreclr/vm/comutilnative.cpp index acfa64a9f722bb..963f7e0c73a5a4 100644 --- a/src/coreclr/vm/comutilnative.cpp +++ b/src/coreclr/vm/comutilnative.cpp @@ -82,7 +82,7 @@ FCIMPLEND // Given an exception object, this method will mark its stack trace as frozen and return it to the caller. // Frozen stack traces are immutable, when a thread attempts to add a frame to it, the stack trace is cloned first. -extern "C" void QCALLTYPE ExceptionNative_GetFrozenStackTrace(QCall::ObjectHandleOnStack exception, QCall::ObjectHandleOnStack ret, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_GetFrozenStackTrace(QCall::ObjectHandleOnStack exception, QCall::ObjectHandleOnStack ret) { QCALL_CONTRACT; @@ -312,7 +312,7 @@ FCIMPLEND // our locks within CER's to avoid this problem - just use the CLR's // unmanaged resources. // -extern "C" void QCALLTYPE ExceptionNative_GetMessageFromNativeResources(ExceptionMessageKind kind, QCall::StringHandleOnStack retMesg, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_GetMessageFromNativeResources(ExceptionMessageKind kind, QCall::StringHandleOnStack retMesg) { QCALL_CONTRACT; @@ -359,7 +359,7 @@ extern "C" void QCALLTYPE ExceptionNative_GetMessageFromNativeResources(Exceptio END_QCALL; } -extern "C" void QCALLTYPE ExceptionNative_GetMethodFromStackTrace(QCall::ObjectHandleOnStack stacktrace, QCall::ObjectHandleOnStack retMethodInfo, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_GetMethodFromStackTrace(QCall::ObjectHandleOnStack stacktrace, QCall::ObjectHandleOnStack retMethodInfo) { QCALL_CONTRACT; @@ -400,11 +400,10 @@ extern "C" void QCALLTYPE ExceptionNative_GetMethodFromStackTrace(QCall::ObjectH END_QCALL; } -extern "C" void QCALLTYPE ExceptionNative_ThrowAmbiguousResolutionException( +extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowAmbiguousResolutionException( MethodTable* pTargetClass, MethodTable* pInterfaceMT, - MethodDesc* pInterfaceMD, - QCallExceptionStatus* qcallError) + MethodDesc* pInterfaceMD) { QCALL_CONTRACT; @@ -415,11 +414,10 @@ extern "C" void QCALLTYPE ExceptionNative_ThrowAmbiguousResolutionException( END_QCALL; } -extern "C" void QCALLTYPE ExceptionNative_ThrowEntryPointNotFoundException( +extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowEntryPointNotFoundException( MethodTable* pTargetClass, MethodTable* pInterfaceMT, - MethodDesc* pInterfaceMD, - QCallExceptionStatus* qcallError) + MethodDesc* pInterfaceMD) { QCALL_CONTRACT; @@ -430,7 +428,7 @@ extern "C" void QCALLTYPE ExceptionNative_ThrowEntryPointNotFoundException( END_QCALL; } -extern "C" void QCALLTYPE ExceptionNative_ThrowMethodAccessException(MethodDesc* caller, MethodDesc* callee, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowMethodAccessException(MethodDesc* caller, MethodDesc* callee) { QCALL_CONTRACT; @@ -443,7 +441,7 @@ extern "C" void QCALLTYPE ExceptionNative_ThrowMethodAccessException(MethodDesc* END_QCALL; } -extern "C" void QCALLTYPE ExceptionNative_ThrowFieldAccessException(MethodDesc* caller, FieldDesc* callee, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowFieldAccessException(MethodDesc* caller, FieldDesc* callee) { QCALL_CONTRACT; @@ -456,7 +454,7 @@ extern "C" void QCALLTYPE ExceptionNative_ThrowFieldAccessException(MethodDesc* END_QCALL; } -extern "C" void QCALLTYPE ExceptionNative_ThrowClassAccessException(MethodDesc* caller, EnregisteredTypeHandle callee, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowClassAccessException(MethodDesc* caller, EnregisteredTypeHandle callee) { QCALL_CONTRACT; @@ -587,7 +585,7 @@ FCIMPL0(FC_BOOL_RET, GCInterface::CancelFullGCNotification) } FCIMPLEND -extern "C" int QCALLTYPE GCInterface_WaitForFullGCApproach(int millisecondsTimeout, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_WaitForFullGCApproach(int millisecondsTimeout, int* pReturnValue) { QCALL_CONTRACT; @@ -600,12 +598,12 @@ extern "C" int QCALLTYPE GCInterface_WaitForFullGCApproach(int millisecondsTimeo DWORD dwMilliseconds = ((millisecondsTimeout == -1) ? INFINITE : millisecondsTimeout); result = GCHeapUtilities::GetGCHeap()->WaitForFullGCApproach(dwMilliseconds); - END_QCALL; + *pReturnValue = result; - return result; + END_QCALL; } -extern "C" int QCALLTYPE GCInterface_WaitForFullGCComplete(int millisecondsTimeout, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_WaitForFullGCComplete(int millisecondsTimeout, int* pReturnValue) { QCALL_CONTRACT; @@ -618,9 +616,9 @@ extern "C" int QCALLTYPE GCInterface_WaitForFullGCComplete(int millisecondsTimeo DWORD dwMilliseconds = ((millisecondsTimeout == -1) ? INFINITE : millisecondsTimeout); result = GCHeapUtilities::GetGCHeap()->WaitForFullGCComplete(dwMilliseconds); - END_QCALL; + *pReturnValue = result; - return result; + END_QCALL; } /*================================GetGenerationInternal================================= @@ -672,7 +670,7 @@ FCIMPL2(int, GCInterface::CollectionCount, INT32 generation, INT32 getSpecialGCC } FCIMPLEND -extern "C" int QCALLTYPE GCInterface_StartNoGCRegion(INT64 totalSize, BOOL lohSizeKnown, INT64 lohSize, BOOL disallowFullBlockingGC, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_StartNoGCRegion(INT64 totalSize, BOOL lohSizeKnown, INT64 lohSize, BOOL disallowFullBlockingGC, int* pReturnValue) { QCALL_CONTRACT; @@ -687,12 +685,12 @@ extern "C" int QCALLTYPE GCInterface_StartNoGCRegion(INT64 totalSize, BOOL lohSi (ULONGLONG)lohSize, !!disallowFullBlockingGC); - END_QCALL; + *pReturnValue = retVal; - return retVal; + END_QCALL; } -extern "C" int QCALLTYPE GCInterface_EndNoGCRegion(QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_EndNoGCRegion(int* pReturnValue) { QCALL_CONTRACT; @@ -702,9 +700,9 @@ extern "C" int QCALLTYPE GCInterface_EndNoGCRegion(QCallExceptionStatus* qcallEr retVal = GCHeapUtilities::GetGCHeap()->EndNoGCRegion(); - END_QCALL; + *pReturnValue = retVal; - return retVal; + END_QCALL; } FCIMPL0(int, GCInterface::GetLastGCPercentTimeInGC) @@ -729,7 +727,7 @@ FCIMPLEND **Arguments: None **Exceptions: None ==============================================================================*/ -extern "C" INT64 QCALLTYPE GCInterface_GetTotalMemory(QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_GetTotalMemory(INT64* pReturnValue) { QCALL_CONTRACT; @@ -740,9 +738,9 @@ extern "C" INT64 QCALLTYPE GCInterface_GetTotalMemory(QCallExceptionStatus* qcal GCX_COOP(); iRetVal = (INT64) GCHeapUtilities::GetGCHeap()->GetTotalBytesInUse(); - END_QCALL; + *pReturnValue = iRetVal; - return iRetVal; + END_QCALL; } /*==============================Collect========================================= @@ -751,7 +749,7 @@ extern "C" INT64 QCALLTYPE GCInterface_GetTotalMemory(QCallExceptionStatus* qcal **Arguments: args->generation: The maximum generation to collect **Exceptions: Argument exception if args->generation is < 0 or > GetMaxGeneration(); ==============================================================================*/ -extern "C" void QCALLTYPE GCInterface_Collect(INT32 generation, INT32 mode, CLR_BOOL lowMemoryPressure, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_Collect(INT32 generation, INT32 mode, CLR_BOOL lowMemoryPressure) { QCALL_CONTRACT; @@ -768,7 +766,7 @@ extern "C" void QCALLTYPE GCInterface_Collect(INT32 generation, INT32 mode, CLR_ END_QCALL; } -extern "C" void* QCALLTYPE GCInterface_GetNextFinalizableObject(QCall::ObjectHandleOnStack pObj, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_GetNextFinalizableObject(QCall::ObjectHandleOnStack pObj, void** pReturnValue) { QCALL_CONTRACT; @@ -800,9 +798,9 @@ extern "C" void* QCALLTYPE GCInterface_GetNextFinalizableObject(QCall::ObjectHan #endif // FEATURE_PORTABLE_ENTRYPOINTS } - END_QCALL; + *pReturnValue = (void*)funcPtr; - return (void*)funcPtr; + END_QCALL; } /*==========================WaitForPendingFinalizers============================ @@ -810,7 +808,7 @@ extern "C" void* QCALLTYPE GCInterface_GetNextFinalizableObject(QCall::ObjectHan **Arguments: None **Exceptions: None ==============================================================================*/ -extern "C" void QCALLTYPE GCInterface_WaitForPendingFinalizers(QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_WaitForPendingFinalizers() { QCALL_CONTRACT; @@ -877,7 +875,7 @@ FCIMPLEND ** ret -> The allocated array. **Exceptions: IDS_EE_ARRAY_DIMENSIONS_EXCEEDED when size is too large. OOM if can't allocate. ==============================================================================*/ -extern "C" void QCALLTYPE GCInterface_AllocateNewArray(void* typeHandlePtr, INT32 length, INT32 flags, QCall::ObjectHandleOnStack ret, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_AllocateNewArray(void* typeHandlePtr, INT32 length, INT32 flags, QCall::ObjectHandleOnStack ret) { QCALL_CONTRACT; _ASSERTE(typeHandlePtr != NULL); @@ -927,7 +925,7 @@ FCIMPL0(INT64, GCInterface::GetTotalAllocatedBytesApproximate) } FCIMPLEND; -extern "C" INT64 QCALLTYPE GCInterface_GetTotalAllocatedBytesPrecise(QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_GetTotalAllocatedBytesPrecise(INT64* pReturnValue) { INT64 allocated = 0; @@ -953,9 +951,9 @@ extern "C" INT64 QCALLTYPE GCInterface_GetTotalAllocatedBytesPrecise(QCallExcept ThreadSuspend::RestartEE(true /* SuspendSucceeded */); - END_QCALL; + *pReturnValue = allocated; - return allocated; + END_QCALL; } @@ -965,7 +963,7 @@ extern "C" INT64 QCALLTYPE GCInterface_GetTotalAllocatedBytesPrecise(QCallExcept **Arguments: args-> pointer to section, size of section **Exceptions: None ==============================================================================*/ -extern "C" void* QCALLTYPE GCInterface_RegisterFrozenSegment(void* pSection, SIZE_T sizeSection, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_RegisterFrozenSegment(void* pSection, SIZE_T sizeSection, void** pReturnValue) { QCALL_CONTRACT; @@ -987,9 +985,9 @@ extern "C" void* QCALLTYPE GCInterface_RegisterFrozenSegment(void* pSection, SIZ retVal = (void*)GCHeapUtilities::GetGCHeap()->RegisterFrozenSegment(&seginfo); - END_QCALL; + *pReturnValue = retVal; - return retVal; + END_QCALL; } /*===============================UnregisterFrozenSegment=============================== @@ -998,7 +996,7 @@ extern "C" void* QCALLTYPE GCInterface_RegisterFrozenSegment(void* pSection, SIZ **Arguments: args-> segment handle **Exceptions: None ==============================================================================*/ -extern "C" void QCALLTYPE GCInterface_UnregisterFrozenSegment(void* segment, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_UnregisterFrozenSegment(void* segment) { QCALL_CONTRACT; @@ -1034,7 +1032,7 @@ FCIMPLEND **Arguments: Object of interest **Exceptions: None ==============================================================================*/ -extern "C" void QCALLTYPE GCInterface_ReRegisterForFinalize(QCall::ObjectHandleOnStack pObj, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_ReRegisterForFinalize(QCall::ObjectHandleOnStack pObj) { QCALL_CONTRACT; @@ -1092,7 +1090,7 @@ FORCEINLINE UINT64 GCInterface::InterlockedSub(UINT64 *pMinuend, UINT64 subtrahe return newMemValue; } -extern "C" void QCALLTYPE GCInterface_AddMemoryPressure(UINT64 bytesAllocated, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_AddMemoryPressure(UINT64 bytesAllocated) { QCALL_CONTRACT; @@ -1101,7 +1099,7 @@ extern "C" void QCALLTYPE GCInterface_AddMemoryPressure(UINT64 bytesAllocated, Q END_QCALL; } -extern "C" void QCALLTYPE GCInterface_EnumerateConfigurationValues(void* configurationContext, EnumerateConfigurationValuesCallback callback, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_EnumerateConfigurationValues(void* configurationContext, EnumerateConfigurationValuesCallback callback) { QCALL_CONTRACT; @@ -1129,7 +1127,7 @@ void GCInterface::EnumerateConfigurationValues(void* configurationContext, Enume GCHeapHardLimitInfo g_gcHeapHardLimitInfo; bool g_gcHeapHardLimitInfoSpecified = false; -extern "C" int QCALLTYPE GCInterface_RefreshMemoryLimit(GCHeapHardLimitInfo heapHardLimitInfo, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_RefreshMemoryLimit(GCHeapHardLimitInfo heapHardLimitInfo, int* pReturnValue) { QCALL_CONTRACT; @@ -1139,9 +1137,9 @@ extern "C" int QCALLTYPE GCInterface_RefreshMemoryLimit(GCHeapHardLimitInfo heap g_gcHeapHardLimitInfo = heapHardLimitInfo; g_gcHeapHardLimitInfoSpecified = true; result = GCInterface::RefreshMemoryLimit(); - END_QCALL; + *pReturnValue = result; - return result; + END_QCALL; } int GCInterface::RefreshMemoryLimit() @@ -1157,15 +1155,16 @@ int GCInterface::RefreshMemoryLimit() return GCHeapUtilities::GetGCHeap()->RefreshMemoryLimit(); } -extern "C" enable_no_gc_region_callback_status QCALLTYPE GCInterface_EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, INT64 totalSize, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, INT64 totalSize, enable_no_gc_region_callback_status* pReturnValue) { enable_no_gc_region_callback_status status = enable_no_gc_region_callback_status::succeed; QCALL_CONTRACT; BEGIN_QCALL; status = GCInterface::EnableNoGCRegionCallback(callback, totalSize); + *pReturnValue = status; + END_QCALL; - return status; } enable_no_gc_region_callback_status GCInterface::EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, INT64 totalSize) @@ -1181,16 +1180,16 @@ enable_no_gc_region_callback_status GCInterface::EnableNoGCRegionCallback(NoGCRe return GCHeapUtilities::GetGCHeap()->EnableNoGCRegionCallback(callback, totalSize); } -extern "C" uint64_t QCALLTYPE GCInterface_GetGenerationBudget(int generation, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_GetGenerationBudget(int generation, uint64_t* pReturnValue) { uint64_t result = 0; QCALL_CONTRACT; BEGIN_QCALL; result = GCInterface::GetGenerationBudget(generation); - END_QCALL; + *pReturnValue = result; - return result; + END_QCALL; } uint64_t GCInterface::GetGenerationBudget(int generation) @@ -1330,7 +1329,7 @@ void GCInterface::AddMemoryPressure(UINT64 bytesAllocated) } } -extern "C" void QCALLTYPE GCInterface_RemoveMemoryPressure(UINT64 bytesAllocated, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_RemoveMemoryPressure(UINT64 bytesAllocated) { QCALL_CONTRACT; @@ -1414,7 +1413,7 @@ NOINLINE void GCInterface::GarbageCollectModeAny(int generation) // // EnvironmentNative // -extern "C" VOID QCALLTYPE Environment_Exit(INT32 exitcode, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE Environment_Exit(INT32 exitcode) { QCALL_CONTRACT; @@ -1452,7 +1451,7 @@ FCIMPL0(INT32, EnvironmentNative::GetExitCode) } FCIMPLEND -extern "C" INT32 QCALLTYPE Environment_GetProcessorCount(QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE Environment_GetProcessorCount(INT32* pReturnValue) { QCALL_CONTRACT; @@ -1462,9 +1461,9 @@ extern "C" INT32 QCALLTYPE Environment_GetProcessorCount(QCallExceptionStatus* q processorCount = GetCurrentProcessCpuCount(); - END_QCALL; + *pReturnValue = processorCount; - return processorCount; + END_QCALL; } struct FindFailFastCallerStruct { @@ -1501,7 +1500,7 @@ static StackWalkAction FindFailFastCallerCallback(CrawlFrame* frame, VOID* data) static thread_local int8_t alreadyFailing = 0; -extern "C" void QCALLTYPE Environment_FailFast(QCall::StackCrawlMarkHandle mark, PCWSTR message, QCall::ObjectHandleOnStack exception, PCWSTR errorSource, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE Environment_FailFast(QCall::StackCrawlMarkHandle mark, PCWSTR message, QCall::ObjectHandleOnStack exception, PCWSTR errorSource) { QCALL_CONTRACT; @@ -1576,7 +1575,7 @@ extern "C" void QCALLTYPE Environment_FailFast(QCall::StackCrawlMarkHandle mark, // // ObjectNative // -extern "C" INT32 QCALLTYPE ObjectNative_GetHashCodeSlow(QCall::ObjectHandleOnStack objHandle, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ObjectNative_GetHashCodeSlow(QCall::ObjectHandleOnStack objHandle, INT32* pReturnValue) { QCALL_CONTRACT; @@ -1589,9 +1588,9 @@ extern "C" INT32 QCALLTYPE ObjectNative_GetHashCodeSlow(QCall::ObjectHandleOnSta _ASSERTE(objHandle.Get() != NULL); idx = objHandle.Get()->GetHashCodeEx(); - END_QCALL; + *pReturnValue = idx; - return idx; + END_QCALL; } FCIMPL1(INT32, ObjectNative::TryGetHashCode, Object* obj) @@ -1627,7 +1626,7 @@ FCIMPL2(FC_BOOL_RET, ObjectNative::ContentEquals, Object *pThisRef, Object *pCom } FCIMPLEND -extern "C" void QCALLTYPE ObjectNative_AllocateUninitializedClone(QCall::ObjectHandleOnStack objHandle, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ObjectNative_AllocateUninitializedClone(QCall::ObjectHandleOnStack objHandle) { QCALL_CONTRACT; @@ -1843,7 +1842,7 @@ BOOL CanCompareBitsOrUseFastGetHashCode(MethodTable* mt) return canCompareBitsOrUseFastGetHashCode; } -extern "C" BOOL QCALLTYPE MethodTable_CanCompareBitsOrUseFastGetHashCode(MethodTable* mt, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MethodTable_CanCompareBitsOrUseFastGetHashCode(MethodTable* mt, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -1856,9 +1855,9 @@ extern "C" BOOL QCALLTYPE MethodTable_CanCompareBitsOrUseFastGetHashCode(MethodT ret = CanCompareBitsOrUseFastGetHashCode(mt); - END_QCALL; + *pReturnValue = ret; - return ret; + END_QCALL; } enum ValueTypeHashCodeStrategy @@ -1962,7 +1961,7 @@ static ValueTypeHashCodeStrategy GetHashCodeStrategy(MethodTable* mt, QCall::Obj return ret; } -extern "C" INT32 QCALLTYPE ValueType_GetHashCodeStrategy(MethodTable* mt, QCall::ObjectHandleOnStack objHandle, UINT32* fieldOffset, UINT32* fieldSize, MethodTable** fieldMT, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ValueType_GetHashCodeStrategy(MethodTable* mt, QCall::ObjectHandleOnStack objHandle, UINT32* fieldOffset, UINT32* fieldSize, MethodTable** fieldMT, INT32* pReturnValue) { QCALL_CONTRACT; @@ -1975,9 +1974,9 @@ extern "C" INT32 QCALLTYPE ValueType_GetHashCodeStrategy(MethodTable* mt, QCall: ret = GetHashCodeStrategy(mt, objHandle, fieldOffset, fieldSize, fieldMT); - END_QCALL; + *pReturnValue = ret; - return ret; + END_QCALL; } FCIMPL1(UINT32, MethodTableNative::GetNumInstanceFieldBytes, MethodTable* mt) @@ -2023,7 +2022,7 @@ FCIMPL1(OBJECTHANDLE, MethodTableNative::GetLoaderAllocatorHandle, MethodTable * } FCIMPLEND -extern "C" BOOL QCALLTYPE MethodTable_AreTypesEquivalent(MethodTable* mta, MethodTable* mtb, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MethodTable_AreTypesEquivalent(MethodTable* mta, MethodTable* mtb, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -2033,12 +2032,12 @@ extern "C" BOOL QCALLTYPE MethodTable_AreTypesEquivalent(MethodTable* mta, Metho bResult = mta->IsEquivalentTo(mtb); - END_QCALL; + *pReturnValue = bResult; - return bResult; + END_QCALL; } -extern "C" BOOL QCALLTYPE TypeHandle_CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE TypeHandle_CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -2063,9 +2062,9 @@ extern "C" BOOL QCALLTYPE TypeHandle_CanCastTo_NoCacheLookup(void* fromTypeHnd, ret = fromTH.AsMethodTable()->CanCastTo(toTH.AsMethodTable(), NULL); } - END_QCALL; + *pReturnValue = ret; - return ret; + END_QCALL; } extern "C" INT32 QCALLTYPE TypeHandle_GetCorElementType(void* typeHnd) @@ -2096,7 +2095,7 @@ static bool HasOverriddenStreamMethod(MethodTable* streamMT, MethodTable* pMT, W return NonVirtualEntry2MethodDesc(actual) != NonVirtualEntry2MethodDesc(base); } -extern "C" BOOL QCALLTYPE Stream_HasOverriddenSlow(MethodTable* pMT, BOOL isRead, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE Stream_HasOverriddenSlow(MethodTable* pMT, BOOL isRead, BOOL* pReturnValue) { QCALL_CONTRACT; _ASSERTE(pMT != NULL); @@ -2117,7 +2116,7 @@ extern "C" BOOL QCALLTYPE Stream_HasOverriddenSlow(MethodTable* pMT, BOOL isRead writeOverride = HasOverriddenStreamMethod(pStreamMT, pMT, slotBeginWrite) || HasOverriddenStreamMethod(pStreamMT, pMT, slotEndWrite); pMT->GetAuxiliaryDataForWrite()->SetStreamOverrideState(readOverride, writeOverride); - END_QCALL; + *pReturnValue = isRead ? readOverride : writeOverride; - return isRead ? readOverride : writeOverride; + END_QCALL; } diff --git a/src/coreclr/vm/comutilnative.h b/src/coreclr/vm/comutilnative.h index e68ede7b519e0b..f6c65fa4121457 100644 --- a/src/coreclr/vm/comutilnative.h +++ b/src/coreclr/vm/comutilnative.h @@ -48,32 +48,30 @@ class ExceptionNative FCDECL0(static UINT32, GetExceptionCount); }; -extern "C" void QCALLTYPE ExceptionNative_GetFrozenStackTrace(QCall::ObjectHandleOnStack exception, QCall::ObjectHandleOnStack ret, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_GetFrozenStackTrace(QCall::ObjectHandleOnStack exception, QCall::ObjectHandleOnStack ret); enum class ExceptionMessageKind { ThreadAbort = 1, ThreadInterrupted = 2, OutOfMemory = 3 }; -extern "C" void QCALLTYPE ExceptionNative_GetMessageFromNativeResources(ExceptionMessageKind kind, QCall::StringHandleOnStack retMesg, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_GetMessageFromNativeResources(ExceptionMessageKind kind, QCall::StringHandleOnStack retMesg); -extern "C" void QCALLTYPE ExceptionNative_GetMethodFromStackTrace(QCall::ObjectHandleOnStack array, QCall::ObjectHandleOnStack retMethodInfo, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_GetMethodFromStackTrace(QCall::ObjectHandleOnStack array, QCall::ObjectHandleOnStack retMethodInfo); -extern "C" void QCALLTYPE ExceptionNative_ThrowAmbiguousResolutionException( +extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowAmbiguousResolutionException( MethodTable* pTargetClass, MethodTable* pInterfaceMT, - MethodDesc* pInterfaceMD, - QCallExceptionStatus* qcallError); + MethodDesc* pInterfaceMD); -extern "C" void QCALLTYPE ExceptionNative_ThrowEntryPointNotFoundException( +extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowEntryPointNotFoundException( MethodTable* pTargetClass, MethodTable* pInterfaceMT, - MethodDesc* pInterfaceMD, - QCallExceptionStatus* qcallError); + MethodDesc* pInterfaceMD); -extern "C" void QCALLTYPE ExceptionNative_ThrowMethodAccessException(MethodDesc* caller, MethodDesc* callee, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ExceptionNative_ThrowFieldAccessException(MethodDesc* caller, FieldDesc* callee, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ExceptionNative_ThrowClassAccessException(MethodDesc* caller, EnregisteredTypeHandle callee, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowMethodAccessException(MethodDesc* caller, MethodDesc* callee); +extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowFieldAccessException(MethodDesc* caller, FieldDesc* callee); +extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowClassAccessException(MethodDesc* caller, EnregisteredTypeHandle callee); // // Buffer @@ -193,42 +191,42 @@ class GCInterface { NOINLINE static void GarbageCollectModeAny(int generation); }; -extern "C" INT64 QCALLTYPE GCInterface_GetTotalAllocatedBytesPrecise(QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_GetTotalAllocatedBytesPrecise(INT64* pReturnValue); -extern "C" void QCALLTYPE GCInterface_AllocateNewArray(void* typeHandlePtr, INT32 length, INT32 flags, QCall::ObjectHandleOnStack ret, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_AllocateNewArray(void* typeHandlePtr, INT32 length, INT32 flags, QCall::ObjectHandleOnStack ret); -extern "C" INT64 QCALLTYPE GCInterface_GetTotalMemory(QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_GetTotalMemory(INT64* pReturnValue); -extern "C" void QCALLTYPE GCInterface_Collect(INT32 generation, INT32 mode, CLR_BOOL lowMemoryPressure, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_Collect(INT32 generation, INT32 mode, CLR_BOOL lowMemoryPressure); -extern "C" void* QCALLTYPE GCInterface_GetNextFinalizableObject(QCall::ObjectHandleOnStack pObj, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_GetNextFinalizableObject(QCall::ObjectHandleOnStack pObj, void** pReturnValue); -extern "C" void QCALLTYPE GCInterface_WaitForPendingFinalizers(QCallExceptionStatus* qcallError); -extern "C" void* QCALLTYPE GCInterface_RegisterFrozenSegment(void *pSection, SIZE_T sizeSection, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_WaitForPendingFinalizers(); +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_RegisterFrozenSegment(void *pSection, SIZE_T sizeSection, void** pReturnValue); -extern "C" void QCALLTYPE GCInterface_UnregisterFrozenSegment(void *segmentHandle, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_UnregisterFrozenSegment(void *segmentHandle); -extern "C" int QCALLTYPE GCInterface_WaitForFullGCApproach(int millisecondsTimeout, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_WaitForFullGCApproach(int millisecondsTimeout, int* pReturnValue); -extern "C" int QCALLTYPE GCInterface_WaitForFullGCComplete(int millisecondsTimeout, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_WaitForFullGCComplete(int millisecondsTimeout, int* pReturnValue); -extern "C" int QCALLTYPE GCInterface_StartNoGCRegion(INT64 totalSize, BOOL lohSizeKnown, INT64 lohSize, BOOL disallowFullBlockingGC, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_StartNoGCRegion(INT64 totalSize, BOOL lohSizeKnown, INT64 lohSize, BOOL disallowFullBlockingGC, int* pReturnValue); -extern "C" int QCALLTYPE GCInterface_EndNoGCRegion(QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_EndNoGCRegion(int* pReturnValue); -extern "C" void QCALLTYPE GCInterface_AddMemoryPressure(UINT64 bytesAllocated, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_AddMemoryPressure(UINT64 bytesAllocated); -extern "C" void QCALLTYPE GCInterface_RemoveMemoryPressure(UINT64 bytesAllocated, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_RemoveMemoryPressure(UINT64 bytesAllocated); -extern "C" void QCALLTYPE GCInterface_ReRegisterForFinalize(QCall::ObjectHandleOnStack pObj, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_ReRegisterForFinalize(QCall::ObjectHandleOnStack pObj); -extern "C" void QCALLTYPE GCInterface_EnumerateConfigurationValues(void* configurationContext, EnumerateConfigurationValuesCallback callback, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_EnumerateConfigurationValues(void* configurationContext, EnumerateConfigurationValuesCallback callback); -extern "C" int QCALLTYPE GCInterface_RefreshMemoryLimit(GCHeapHardLimitInfo heapHardLimitInfo, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_RefreshMemoryLimit(GCHeapHardLimitInfo heapHardLimitInfo, int* pReturnValue); -extern "C" enable_no_gc_region_callback_status QCALLTYPE GCInterface_EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, INT64 totalSize, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, INT64 totalSize, enable_no_gc_region_callback_status* pReturnValue); -extern "C" uint64_t QCALLTYPE GCInterface_GetGenerationBudget(int generation, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE GCInterface_GetGenerationBudget(int generation, uint64_t* pReturnValue); // // EnvironmentNative @@ -241,18 +239,18 @@ class EnvironmentNative FCDECL0(static INT32, GetExitCode); }; -extern "C" void QCALLTYPE Environment_Exit(INT32 exitcode, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE Environment_Exit(INT32 exitcode); -extern "C" void QCALLTYPE Environment_FailFast(QCall::StackCrawlMarkHandle mark, PCWSTR message, QCall::ObjectHandleOnStack exception, PCWSTR errorSource, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE Environment_FailFast(QCall::StackCrawlMarkHandle mark, PCWSTR message, QCall::ObjectHandleOnStack exception, PCWSTR errorSource); // Returns the number of logical processors that can be used by managed code -extern "C" INT32 QCALLTYPE Environment_GetProcessorCount(QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE Environment_GetProcessorCount(INT32* pReturnValue); -extern "C" void QCALLTYPE GetTypeLoadExceptionMessage(UINT32 resId, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE GetTypeLoadExceptionMessage(UINT32 resId, QCall::StringHandleOnStack retString); -extern "C" void QCALLTYPE GetFileLoadExceptionMessage(UINT32 hr, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE GetFileLoadExceptionMessage(UINT32 hr, QCall::StringHandleOnStack retString); -extern "C" void QCALLTYPE FileLoadException_GetMessageForHR(UINT32 hresult, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE FileLoadException_GetMessageForHR(UINT32 hresult, QCall::StringHandleOnStack retString); class ObjectNative { @@ -261,8 +259,8 @@ class ObjectNative FCDECL2(static FC_BOOL_RET, ContentEquals, Object *pThisRef, Object *pCompareRef); }; -extern "C" INT32 QCALLTYPE ObjectNative_GetHashCodeSlow(QCall::ObjectHandleOnStack objHandle, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ObjectNative_AllocateUninitializedClone(QCall::ObjectHandleOnStack objHandle, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ObjectNative_GetHashCodeSlow(QCall::ObjectHandleOnStack objHandle, INT32* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE ObjectNative_AllocateUninitializedClone(QCall::ObjectHandleOnStack objHandle); class COMInterlocked { @@ -286,14 +284,14 @@ class MethodTableNative { FCDECL1(static OBJECTHANDLE, GetLoaderAllocatorHandle, MethodTable* mt); }; -extern "C" BOOL QCALLTYPE MethodTable_AreTypesEquivalent(MethodTable* mta, MethodTable* mtb, QCallExceptionStatus* qcallError); -extern "C" BOOL QCALLTYPE MethodTable_CanCompareBitsOrUseFastGetHashCode(MethodTable* mt, QCallExceptionStatus* qcallError); -extern "C" BOOL QCALLTYPE TypeHandle_CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MethodTable_AreTypesEquivalent(MethodTable* mta, MethodTable* mtb, BOOL* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE MethodTable_CanCompareBitsOrUseFastGetHashCode(MethodTable* mt, BOOL* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE TypeHandle_CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd, BOOL* pReturnValue); extern "C" INT32 QCALLTYPE TypeHandle_GetCorElementType(void* typeHnd); -extern "C" INT32 QCALLTYPE ValueType_GetHashCodeStrategy(MethodTable* mt, QCall::ObjectHandleOnStack objHandle, UINT32* fieldOffset, UINT32* fieldSize, MethodTable** fieldMT, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ValueType_GetHashCodeStrategy(MethodTable* mt, QCall::ObjectHandleOnStack objHandle, UINT32* fieldOffset, UINT32* fieldSize, MethodTable** fieldMT, INT32* pReturnValue); BOOL CanCompareBitsOrUseFastGetHashCode(MethodTable* mt); -extern "C" BOOL QCALLTYPE Stream_HasOverriddenSlow(MethodTable* pMT, BOOL isRead, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE Stream_HasOverriddenSlow(MethodTable* pMT, BOOL isRead, BOOL* pReturnValue); #endif // _COMUTILNATIVE_H_ diff --git a/src/coreclr/vm/coreassemblyspec.cpp b/src/coreclr/vm/coreassemblyspec.cpp index 30d16fcd2196a3..3e00bd69e6a722 100644 --- a/src/coreclr/vm/coreassemblyspec.cpp +++ b/src/coreclr/vm/coreassemblyspec.cpp @@ -184,7 +184,7 @@ void BaseAssemblySpec::Init(SString& assemblyDisplayName) parseAsAssemblySpec.InvokeThrowing(pAssemblyDisplayName, (void*)this); } -extern "C" void QCALLTYPE AssemblyName_InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, BaseAssemblySpec* pAssemblySpec, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyName_InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, BaseAssemblySpec* pAssemblySpec) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/customattribute.cpp b/src/coreclr/vm/customattribute.cpp index 8896cf37f7a3b6..d179e1c274bc69 100644 --- a/src/coreclr/vm/customattribute.cpp +++ b/src/coreclr/vm/customattribute.cpp @@ -897,15 +897,14 @@ extern "C" BOOL QCALLTYPE CustomAttribute_ParseAttributeUsageAttribute( return TRUE; } -extern "C" void QCALLTYPE CustomAttribute_CreateCustomAttributeInstance( +extern "C" QCallExceptionStatus QCALLTYPE CustomAttribute_CreateCustomAttributeInstance( QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack pCaType, QCall::ObjectHandleOnStack pMethod, BYTE** ppBlob, BYTE* pEndBlob, INT32* pcNamedArgs, - QCall::ObjectHandleOnStack result, - QCallExceptionStatus* qcallError) + QCall::ObjectHandleOnStack result) { QCALL_CONTRACT; @@ -1027,15 +1026,14 @@ extern "C" void QCALLTYPE CustomAttribute_CreateCustomAttributeInstance( END_QCALL; } -extern "C" void QCALLTYPE CustomAttribute_CreatePropertyOrFieldData( +extern "C" QCallExceptionStatus QCALLTYPE CustomAttribute_CreatePropertyOrFieldData( QCall::ModuleHandle pModule, BYTE** ppBlobStart, BYTE* pBlobEnd, QCall::StringHandleOnStack pName, BOOL* pbIsProperty, QCall::ObjectHandleOnStack pType, - QCall::ObjectHandleOnStack pValue, - QCallExceptionStatus* qcallError) + QCall::ObjectHandleOnStack pValue) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/customattribute.h b/src/coreclr/vm/customattribute.h index 210cd238d85f07..3b647364a5e1c1 100644 --- a/src/coreclr/vm/customattribute.h +++ b/src/coreclr/vm/customattribute.h @@ -30,24 +30,22 @@ extern "C" BOOL QCALLTYPE CustomAttribute_ParseAttributeUsageAttribute( BOOL* pAllowMultiple, BOOL* pInherited); -extern "C" void QCALLTYPE CustomAttribute_CreateCustomAttributeInstance( +extern "C" QCallExceptionStatus QCALLTYPE CustomAttribute_CreateCustomAttributeInstance( QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack pCaType, QCall::ObjectHandleOnStack pMethod, BYTE** ppBlob, BYTE* pEndBlob, INT32* pcNamedArgs, - QCall::ObjectHandleOnStack result, - QCallExceptionStatus* qcallError); + QCall::ObjectHandleOnStack result); -extern "C" void QCALLTYPE CustomAttribute_CreatePropertyOrFieldData( +extern "C" QCallExceptionStatus QCALLTYPE CustomAttribute_CreatePropertyOrFieldData( QCall::ModuleHandle pModule, BYTE** ppBlobStart, BYTE* pBlobEnd, QCall::StringHandleOnStack pName, BOOL* pbIsProperty, QCall::ObjectHandleOnStack pType, - QCall::ObjectHandleOnStack value, - QCallExceptionStatus* qcallError); + QCall::ObjectHandleOnStack value); #endif // _CUSTOMATTRIBUTE_H_ diff --git a/src/coreclr/vm/debugdebugger.cpp b/src/coreclr/vm/debugdebugger.cpp index 043c9a486ef081..2a43c5b49b12d8 100644 --- a/src/coreclr/vm/debugdebugger.cpp +++ b/src/coreclr/vm/debugdebugger.cpp @@ -38,7 +38,7 @@ // Else if a native debugger is attached, this should send a native break event (kernel32!DebugBreak) // Else, this should invoke Watson. // -extern "C" void QCALLTYPE DebugDebugger_Break(QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE DebugDebugger_Break() { QCALL_CONTRACT; @@ -81,7 +81,7 @@ extern "C" void QCALLTYPE DebugDebugger_Break(QCallExceptionStatus* qcallError) END_QCALL; #else - qcallError->SetNoException(); + return QCallExceptionStatus(); #endif // DEBUGGING_SUPPORTED } @@ -291,10 +291,9 @@ static void GetStackFrames(DebugStackTrace::GetStackFramesData *pData) } } -extern "C" void QCALLTYPE AsyncHelpers_AddContinuationToExInternal( +extern "C" QCallExceptionStatus QCALLTYPE AsyncHelpers_AddContinuationToExInternal( void* diagnosticIP, - QCall::ObjectHandleOnStack exception, - QCallExceptionStatus* qcallError) + QCall::ObjectHandleOnStack exception) { QCALL_CONTRACT; @@ -319,11 +318,10 @@ extern "C" void QCALLTYPE AsyncHelpers_AddContinuationToExInternal( END_QCALL; } -extern "C" void QCALLTYPE StackTrace_GetStackFramesInternal( +extern "C" QCallExceptionStatus QCALLTYPE StackTrace_GetStackFramesInternal( QCall::ObjectHandleOnStack stackFrameHelper, BOOL fNeedFileInfo, - QCall::ObjectHandleOnStack exception, - QCallExceptionStatus* qcallError) + QCall::ObjectHandleOnStack exception) { QCALL_CONTRACT; @@ -826,7 +824,7 @@ extern "C" void QCALLTYPE StackTrace_GetStackFramesInternal( END_QCALL; } -extern "C" MethodDesc* QCALLTYPE StackFrame_GetMethodDescFromNativeIP(LPVOID ip, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE StackFrame_GetMethodDescFromNativeIP(LPVOID ip, MethodDesc** pReturnValue) { QCALL_CONTRACT; @@ -843,9 +841,9 @@ extern "C" MethodDesc* QCALLTYPE StackFrame_GetMethodDescFromNativeIP(LPVOID ip, pResult = codeInfo.GetMethodDesc(); } - END_QCALL; + *pReturnValue = pResult; - return pResult; + END_QCALL; } struct StrongHandleHolderTraits final @@ -865,7 +863,7 @@ using StrongHandleHolder = LifetimeHolder; // receives a custom notification object from the target and sends it to the RS via // code:Debugger::SendCustomDebuggerNotification // Argument: dataUNSAFE - a pointer the custom notification object being sent -extern "C" void QCALLTYPE DebugDebugger_CustomNotification(QCall::ObjectHandleOnStack data, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE DebugDebugger_CustomNotification(QCall::ObjectHandleOnStack data) { QCALL_CONTRACT; @@ -873,8 +871,7 @@ extern "C" void QCALLTYPE DebugDebugger_CustomNotification(QCall::ObjectHandleOn // Send notification only if the debugger is attached if (!CORDebuggerAttached()) { - qcallError->SetNoException(); - return; + return QCallExceptionStatus(); } BEGIN_QCALL; @@ -901,7 +898,7 @@ extern "C" void QCALLTYPE DebugDebugger_CustomNotification(QCall::ObjectHandleOn END_QCALL; #else - qcallError->SetNoException(); + return QCallExceptionStatus(); #endif // DEBUGGING_SUPPORTED } diff --git a/src/coreclr/vm/debugdebugger.h b/src/coreclr/vm/debugdebugger.h index d8d6cbc3f927df..c4015a4ff73602 100644 --- a/src/coreclr/vm/debugdebugger.h +++ b/src/coreclr/vm/debugdebugger.h @@ -13,10 +13,10 @@ #define __DEBUG_DEBUGGER_h__ #include -extern "C" void QCALLTYPE DebugDebugger_Break(QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE DebugDebugger_Break(); extern "C" BOOL QCALLTYPE DebugDebugger_Launch(); extern "C" void QCALLTYPE DebugDebugger_Log(INT32 Level, PCWSTR pwzModule, PCWSTR pwzMessage); -extern "C" void QCALLTYPE DebugDebugger_CustomNotification(QCall::ObjectHandleOnStack data, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE DebugDebugger_CustomNotification(QCall::ObjectHandleOnStack data); extern "C" BOOL QCALLTYPE DebugDebugger_IsLoggingHelper(); extern "C" BOOL QCALLTYPE DebugDebugger_IsManagedDebuggerAttached(); @@ -130,18 +130,16 @@ class DebugStackTrace static void GetStackFramesFromException(OBJECTREF * e, GetStackFramesData *pData, PTRARRAYREF * pDynamicMethodArray = NULL); }; -extern "C" void QCALLTYPE StackTrace_GetStackFramesInternal( +extern "C" QCallExceptionStatus QCALLTYPE StackTrace_GetStackFramesInternal( QCall::ObjectHandleOnStack stackFrameHelper, BOOL fNeedFileInfo, - QCall::ObjectHandleOnStack exception, - QCallExceptionStatus* qcallError); + QCall::ObjectHandleOnStack exception); -extern "C" void QCALLTYPE AsyncHelpers_AddContinuationToExInternal( +extern "C" QCallExceptionStatus QCALLTYPE AsyncHelpers_AddContinuationToExInternal( void* diagnosticIP, - QCall::ObjectHandleOnStack exception, - QCallExceptionStatus* qcallError); + QCall::ObjectHandleOnStack exception); -extern "C" MethodDesc* QCALLTYPE StackFrame_GetMethodDescFromNativeIP(LPVOID ip, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE StackFrame_GetMethodDescFromNativeIP(LPVOID ip, MethodDesc** pReturnValue); class ILToNativeMapArrays diff --git a/src/coreclr/vm/ecalllist.h b/src/coreclr/vm/ecalllist.h index 47cd2b5530d465..d64b8c7dab8ffa 100644 --- a/src/coreclr/vm/ecalllist.h +++ b/src/coreclr/vm/ecalllist.h @@ -257,7 +257,6 @@ FCFuncStart(gThreadFuncs) FCFuncElement("CatchAtSafePoint", ThreadNative::CatchAtSafePoint) FCFuncElement("CurrentThreadIsFinalizerThread", ThreadNative::CurrentThreadIsFinalizerThread) FCFuncElement("get_OptimalMaxSpinWaitsPerSpinIteration", ThreadNative::GetOptimalMaxSpinWaitsPerSpinIteration) - FCFuncElement("GetAndClearQCallException", ThreadNative::GetAndClearQCallException) #ifdef TARGET_WASM FCFuncElement("GetThreadStaticsBaseNative", ThreadNative::GetThreadStaticsBaseNative) #endif diff --git a/src/coreclr/vm/eventpipeinternal.cpp b/src/coreclr/vm/eventpipeinternal.cpp index 7318261dd94110..046917d2a770d4 100644 --- a/src/coreclr/vm/eventpipeinternal.cpp +++ b/src/coreclr/vm/eventpipeinternal.cpp @@ -14,13 +14,12 @@ #ifdef FEATURE_PERFTRACING -extern "C" UINT64 QCALLTYPE EventPipeInternal_Enable( +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_Enable( _In_z_ LPCWSTR outputFile, EventPipeSerializationFormat format, UINT32 circularBufferSizeInMB, /* COR_PRF_EVENTPIPE_PROVIDER_CONFIG */ LPCVOID pProviders, - UINT32 numProviders, - QCallExceptionStatus* qcallError) + UINT32 numProviders, UINT64* pReturnValue) { QCALL_CONTRACT; @@ -32,8 +31,8 @@ extern "C" UINT64 QCALLTYPE EventPipeInternal_Enable( numProviders == 0 || pProviders == nullptr) { - qcallError->SetNoException(); - return 0; + *pReturnValue = 0; + return QCallExceptionStatus(); } BEGIN_QCALL; @@ -54,12 +53,12 @@ extern "C" UINT64 QCALLTYPE EventPipeInternal_Enable( EventPipeAdapter::StartStreaming(sessionID); } } - END_QCALL; + *pReturnValue = sessionID; - return sessionID; + END_QCALL; } -extern "C" void QCALLTYPE EventPipeInternal_Disable(UINT64 sessionID, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_Disable(UINT64 sessionID) { QCALL_CONTRACT; @@ -68,7 +67,7 @@ extern "C" void QCALLTYPE EventPipeInternal_Disable(UINT64 sessionID, QCallExcep END_QCALL; } -extern "C" BOOL QCALLTYPE EventPipeInternal_GetSessionInfo(UINT64 sessionID, EventPipeSessionInfo *pSessionInfo, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_GetSessionInfo(UINT64 sessionID, EventPipeSessionInfo *pSessionInfo, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -87,15 +86,15 @@ extern "C" BOOL QCALLTYPE EventPipeInternal_GetSessionInfo(UINT64 sessionID, Eve } } + *pReturnValue = retVal; + END_QCALL; - return retVal; } -extern "C" INT_PTR QCALLTYPE EventPipeInternal_CreateProvider( +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_CreateProvider( _In_z_ LPCWSTR providerName, EventPipeCallback pCallbackFunc, - void* pCallbackContext, - QCallExceptionStatus* qcallError) + void* pCallbackContext, INT_PTR* pReturnValue) { QCALL_CONTRACT; @@ -105,20 +104,19 @@ extern "C" INT_PTR QCALLTYPE EventPipeInternal_CreateProvider( pProvider = EventPipeAdapter::CreateProvider(providerName, pCallbackFunc, pCallbackContext); - END_QCALL; + *pReturnValue = reinterpret_cast(pProvider); - return reinterpret_cast(pProvider); + END_QCALL; } -extern "C" INT_PTR QCALLTYPE EventPipeInternal_DefineEvent( +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_DefineEvent( INT_PTR provHandle, UINT32 eventID, int64_t keywords, UINT32 eventVersion, UINT32 level, void *pMetadata, - UINT32 metadataLength, - QCallExceptionStatus* qcallError) + UINT32 metadataLength, INT_PTR* pReturnValue) { QCALL_CONTRACT; @@ -131,12 +129,12 @@ extern "C" INT_PTR QCALLTYPE EventPipeInternal_DefineEvent( pEvent = EventPipeAdapter::AddEvent(pProvider, eventID, keywords, eventVersion, (EventPipeEventLevel)level, /* needStack = */ true, (BYTE *)pMetadata, metadataLength); _ASSERTE(pEvent != NULL); - END_QCALL; + *pReturnValue = reinterpret_cast(pEvent); - return reinterpret_cast(pEvent); + END_QCALL; } -extern "C" INT_PTR QCALLTYPE EventPipeInternal_GetProvider(_In_z_ LPCWSTR providerName, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_GetProvider(_In_z_ LPCWSTR providerName, INT_PTR* pReturnValue) { QCALL_CONTRACT; @@ -146,12 +144,12 @@ extern "C" INT_PTR QCALLTYPE EventPipeInternal_GetProvider(_In_z_ LPCWSTR provid pProvider = EventPipeAdapter::GetProvider(providerName); - END_QCALL; + *pReturnValue = reinterpret_cast(pProvider); - return reinterpret_cast(pProvider); + END_QCALL; } -extern "C" void QCALLTYPE EventPipeInternal_DeleteProvider(INT_PTR provHandle, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_DeleteProvider(INT_PTR provHandle) { QCALL_CONTRACT; BEGIN_QCALL; @@ -165,7 +163,7 @@ extern "C" void QCALLTYPE EventPipeInternal_DeleteProvider(INT_PTR provHandle, Q END_QCALL; } -extern "C" int QCALLTYPE EventPipeInternal_EventActivityIdControl(uint32_t controlCode, GUID *pActivityId, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_EventActivityIdControl(uint32_t controlCode, GUID *pActivityId, int* pReturnValue) { QCALL_CONTRACT; @@ -219,17 +217,17 @@ extern "C" int QCALLTYPE EventPipeInternal_EventActivityIdControl(uint32_t contr } } + *pReturnValue = retVal; + END_QCALL; - return retVal; } -extern "C" void QCALLTYPE EventPipeInternal_WriteEventData( +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_WriteEventData( INT_PTR eventHandle, EventData *pEventData, UINT32 eventDataCount, LPCGUID pActivityId, - LPCGUID pRelatedActivityId, - QCallExceptionStatus* qcallError) + LPCGUID pRelatedActivityId) { QCALL_CONTRACT; BEGIN_QCALL; @@ -241,7 +239,7 @@ extern "C" void QCALLTYPE EventPipeInternal_WriteEventData( END_QCALL; } -extern "C" BOOL QCALLTYPE EventPipeInternal_GetNextEvent(UINT64 sessionID, EventPipeEventInstanceData *pInstance, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_GetNextEvent(UINT64 sessionID, EventPipeEventInstanceData *pInstance, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -263,11 +261,12 @@ extern "C" BOOL QCALLTYPE EventPipeInternal_GetNextEvent(UINT64 sessionID, Event pInstance->PayloadLength = EventPipeAdapter::GetEventDataLen(pNextInstance); } + *pReturnValue = pNextInstance != NULL; + END_QCALL; - return pNextInstance != NULL; } -extern "C" BOOL QCALLTYPE EventPipeInternal_SignalSession(UINT64 sessionID, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_SignalSession(UINT64 sessionID, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -276,11 +275,12 @@ extern "C" BOOL QCALLTYPE EventPipeInternal_SignalSession(UINT64 sessionID, QCal result = EventPipeAdapter::SignalSession(sessionID); + *pReturnValue = result; + END_QCALL; - return result; } -extern "C" BOOL QCALLTYPE EventPipeInternal_WaitForSessionSignal(UINT64 sessionID, INT32 timeoutMs, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_WaitForSessionSignal(UINT64 sessionID, INT32 timeoutMs, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -289,8 +289,9 @@ extern "C" BOOL QCALLTYPE EventPipeInternal_WaitForSessionSignal(UINT64 sessionI result = EventPipeAdapter::WaitForSessionSignal(sessionID, timeoutMs); + *pReturnValue = result; + END_QCALL; - return result; } #endif // FEATURE_PERFTRACING diff --git a/src/coreclr/vm/eventpipeinternal.h b/src/coreclr/vm/eventpipeinternal.h index 09cb9acedaca28..53989396f51133 100644 --- a/src/coreclr/vm/eventpipeinternal.h +++ b/src/coreclr/vm/eventpipeinternal.h @@ -39,70 +39,60 @@ struct EventPipeSessionInfo //! //! Sets the sampling rate and enables the event pipe for the specified configuration. //! -extern "C" UINT64 QCALLTYPE EventPipeInternal_Enable( +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_Enable( _In_z_ LPCWSTR outputFile, EventPipeSerializationFormat format, UINT32 circularBufferSizeInMB, /* COR_PRF_EVENTPIPE_PROVIDER_CONFIG */ LPCVOID pProviders, - UINT32 numProviders, - QCallExceptionStatus* qcallError); + UINT32 numProviders, UINT64* pReturnValue); //! //! Disables the specified session Id. //! -extern "C" void QCALLTYPE EventPipeInternal_Disable(UINT64 sessionID, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_Disable(UINT64 sessionID); -extern "C" BOOL QCALLTYPE EventPipeInternal_GetSessionInfo(UINT64 sessionID, EventPipeSessionInfo *pSessionInfo, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_GetSessionInfo(UINT64 sessionID, EventPipeSessionInfo *pSessionInfo, BOOL* pReturnValue); -extern "C" INT_PTR QCALLTYPE EventPipeInternal_CreateProvider( +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_CreateProvider( _In_z_ LPCWSTR providerName, EventPipeCallback pCallbackFunc, - void* pCallbackContext, - QCallExceptionStatus* qcallError); + void* pCallbackContext, INT_PTR* pReturnValue); -extern "C" INT_PTR QCALLTYPE EventPipeInternal_DefineEvent( +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_DefineEvent( INT_PTR provHandle, UINT32 eventID, int64_t keywords, UINT32 eventVersion, UINT32 level, void *pMetadata, - UINT32 metadataLength, - QCallExceptionStatus* qcallError); + UINT32 metadataLength, INT_PTR* pReturnValue); -extern "C" INT_PTR QCALLTYPE EventPipeInternal_GetProvider( - _In_z_ LPCWSTR providerName, - QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_GetProvider( + _In_z_ LPCWSTR providerName, INT_PTR* pReturnValue); -extern "C" void QCALLTYPE EventPipeInternal_DeleteProvider( - INT_PTR provHandle, - QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_DeleteProvider( + INT_PTR provHandle); -extern "C" int QCALLTYPE EventPipeInternal_EventActivityIdControl( +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_EventActivityIdControl( UINT32 controlCode, - GUID *pActivityId, - QCallExceptionStatus* qcallError); + GUID *pActivityId, int* pReturnValue); -extern "C" void QCALLTYPE EventPipeInternal_WriteEventData( +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_WriteEventData( INT_PTR eventHandle, EventData *pEventData, UINT32 eventDataCount, - LPCGUID pActivityId, LPCGUID pRelatedActivityId, - QCallExceptionStatus* qcallError); + LPCGUID pActivityId, LPCGUID pRelatedActivityId); -extern "C" BOOL QCALLTYPE EventPipeInternal_GetNextEvent( +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_GetNextEvent( UINT64 sessionID, - EventPipeEventInstanceData *pInstance, - QCallExceptionStatus* qcallError); + EventPipeEventInstanceData *pInstance, BOOL* pReturnValue); -extern "C" BOOL QCALLTYPE EventPipeInternal_SignalSession( - UINT64 sessionID, - QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_SignalSession( + UINT64 sessionID, BOOL* pReturnValue); -extern "C" BOOL QCALLTYPE EventPipeInternal_WaitForSessionSignal( +extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_WaitForSessionSignal( UINT64 sessionID, - INT32 timeoutMs, - QCallExceptionStatus* qcallError); + INT32 timeoutMs, BOOL* pReturnValue); #endif // FEATURE_PERFTRACING diff --git a/src/coreclr/vm/excep.cpp b/src/coreclr/vm/excep.cpp index 684f1c6a87ed9d..9e467a17f4958e 100644 --- a/src/coreclr/vm/excep.cpp +++ b/src/coreclr/vm/excep.cpp @@ -4718,7 +4718,7 @@ static BOOL GetManagedFormatStringForResourceID(UINT32 resId, SString & converte //========================================================================== // Private helper for TypeLoadException. //========================================================================== -extern "C" void QCALLTYPE GetTypeLoadExceptionMessage(UINT32 resId, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GetTypeLoadExceptionMessage(UINT32 resId, QCall::StringHandleOnStack retString) { QCALL_CONTRACT; @@ -4737,7 +4737,7 @@ extern "C" void QCALLTYPE GetTypeLoadExceptionMessage(UINT32 resId, QCall::Strin // Private helper for FileLoadException and FileNotFoundException. //========================================================================== -extern "C" void QCALLTYPE GetFileLoadExceptionMessage(UINT32 hr, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GetFileLoadExceptionMessage(UINT32 hr, QCall::StringHandleOnStack retString) { QCALL_CONTRACT; @@ -4753,7 +4753,7 @@ extern "C" void QCALLTYPE GetFileLoadExceptionMessage(UINT32 hr, QCall::StringHa //========================================================================== // Private helper for FileLoadException and FileNotFoundException. //========================================================================== -extern "C" void QCALLTYPE FileLoadException_GetMessageForHR(UINT32 hresult, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE FileLoadException_GetMessageForHR(UINT32 hresult, QCall::StringHandleOnStack retString) { QCALL_CONTRACT; @@ -6659,7 +6659,7 @@ void UnwindAndContinueRethrowHelperInsideQcallCatch( // cases where the last thrown object is NULL. OBJECTREF orThrowable = CLRException::GetThrowableFromException(pException); CONSISTENCY_CHECK(orThrowable != NULL); - pQCallException->SetThrowable(orThrowable); + SetQCallExceptionStatusThrowable(pQCallException, orThrowable); } #ifdef TARGET_UNIX @@ -6672,7 +6672,7 @@ void CaptureQCallExceptionFromPALException(PAL_SEHException& exception, QCallExc GCX_COOP(); OBJECTREF throwable = ExInfo::CreateThrowable(exception.GetExceptionRecord(), FALSE); - pQCallException->SetThrowable(throwable); + SetQCallExceptionStatusThrowable(pQCallException, throwable); } #endif diff --git a/src/coreclr/vm/exceptionhandling.cpp b/src/coreclr/vm/exceptionhandling.cpp index 403b3bd5162f73..3bd2e54a49f076 100644 --- a/src/coreclr/vm/exceptionhandling.cpp +++ b/src/coreclr/vm/exceptionhandling.cpp @@ -3133,7 +3133,7 @@ static TADDR GetSpForDiagnosticReporting(REGDISPLAY *pRD) #endif } -extern "C" void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo) { QCALL_CONTRACT; @@ -3531,7 +3531,7 @@ void CallFinallyFunclet(BYTE* pHandlerIP, REGDISPLAY* pvRegDisplay, ExInfo* exIn exInfo->MakeCallbacksRelatedToHandler(false, pThread, pMD, &exInfo->m_CurrentClause, (DWORD_PTR)pHandlerIP, spForDebugger); } -extern "C" CLR_BOOL QCALLTYPE CallFilterFunclet(QCall::ObjectHandleOnStack exceptionObj, BYTE* pFilterIP, REGDISPLAY* pvRegDisplay, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE CallFilterFunclet(QCall::ObjectHandleOnStack exceptionObj, BYTE* pFilterIP, REGDISPLAY* pvRegDisplay, CLR_BOOL* pReturnValue) { QCALL_CONTRACT; @@ -3572,9 +3572,9 @@ extern "C" CLR_BOOL QCALLTYPE CallFilterFunclet(QCall::ObjectHandleOnStack excep // Profiler, debugger and ETW events pExInfo->MakeCallbacksRelatedToHandler(false, pThread, pMD, &pExInfo->m_CurrentClause, (DWORD_PTR)pFilterIP, spForDebugger); - END_QCALL; + *pReturnValue = dwResult == EXCEPTION_EXECUTE_HANDLER; - return dwResult == EXCEPTION_EXECUTE_HANDLER; + END_QCALL; } @@ -3700,7 +3700,7 @@ CLR_BOOL EHEnumNextWorker(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClause* pEHClause, return result; } -extern "C" CLR_BOOL QCALLTYPE EHEnumNext(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClause* pEHClause, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE EHEnumNext(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClause* pEHClause, CLR_BOOL* pReturnValue) { QCALL_CONTRACT; @@ -3714,9 +3714,9 @@ extern "C" CLR_BOOL QCALLTYPE EHEnumNext(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClau MarkInlinedCallFrameAsEHHelperCall(pFrame); result = EHEnumNextWorker(pEHEnum, pEHClause); - END_QCALL; + *pReturnValue = result; - return result; + END_QCALL; } extern uint32_t g_exceptionCount; @@ -4052,7 +4052,7 @@ CLR_BOOL SfiInitWorker(StackFrameIterator* pThis, CONTEXT* pStackwalkCtx, CLR_BO return result; } -extern "C" CLR_BOOL QCALLTYPE SfiInit(StackFrameIterator* pThis, CONTEXT* pStackwalkCtx, CLR_BOOL instructionFault, CLR_BOOL* pfIsExceptionIntercepted, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE SfiInit(StackFrameIterator* pThis, CONTEXT* pStackwalkCtx, CLR_BOOL instructionFault, CLR_BOOL* pfIsExceptionIntercepted, CLR_BOOL* pReturnValue) { QCALL_CONTRACT; @@ -4066,9 +4066,9 @@ extern "C" CLR_BOOL QCALLTYPE SfiInit(StackFrameIterator* pThis, CONTEXT* pStack GCX_COOP(); result = SfiInitWorker(pThis, pStackwalkCtx, instructionFault, pfIsExceptionIntercepted); - END_QCALL; + *pReturnValue = result; - return result; + END_QCALL; } static StackWalkAction MoveToNextNonSkippedFrame(StackFrameIterator* pStackFrameIterator) @@ -4373,7 +4373,7 @@ Exit:; return success; } -extern "C" CLR_BOOL QCALLTYPE SfiNext(StackFrameIterator* pThis, uint* uExCollideClauseIdx, CLR_BOOL* fUnwoundReversePInvoke, CLR_BOOL* pfIsExceptionIntercepted, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE SfiNext(StackFrameIterator* pThis, uint* uExCollideClauseIdx, CLR_BOOL* fUnwoundReversePInvoke, CLR_BOOL* pfIsExceptionIntercepted, CLR_BOOL* pReturnValue) { QCALL_CONTRACT; @@ -4389,9 +4389,9 @@ extern "C" CLR_BOOL QCALLTYPE SfiNext(StackFrameIterator* pThis, uint* uExCollid GCX_COOP(); result = SfiNextWorker(pThis, uExCollideClauseIdx, fUnwoundReversePInvoke, pfIsExceptionIntercepted); - END_QCALL; + *pReturnValue = result; - return result; + END_QCALL; } static uint32_t CalculateCodeOffset(PCODE pbControlPC, IJitManager::MethodRegionInfo *pMethodRegionInfo) diff --git a/src/coreclr/vm/exceptionhandlingqcalls.h b/src/coreclr/vm/exceptionhandlingqcalls.h index ddb20be42aa651..cfaef62e6255d1 100644 --- a/src/coreclr/vm/exceptionhandlingqcalls.h +++ b/src/coreclr/vm/exceptionhandlingqcalls.h @@ -9,12 +9,12 @@ struct ExInfo; #ifndef DACCESS_COMPILE -extern "C" CLR_BOOL QCALLTYPE CallFilterFunclet(QCall::ObjectHandleOnStack exceptionObj, BYTE* pFilterP, REGDISPLAY* pvRegDisplay, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE CallFilterFunclet(QCall::ObjectHandleOnStack exceptionObj, BYTE* pFilterP, REGDISPLAY* pvRegDisplay, CLR_BOOL* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo); extern "C" CLR_BOOL QCALLTYPE EHEnumInitFromStackFrameIterator(StackFrameIterator *pFrameIter, IJitManager::MethodRegionInfo *pMethodRegionInfo, EH_CLAUSE_ENUMERATOR * pEHEnum); -extern "C" CLR_BOOL QCALLTYPE EHEnumNext(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClause* pEHClause, QCallExceptionStatus* qcallError); -extern "C" CLR_BOOL QCALLTYPE SfiInit(StackFrameIterator* pThis, CONTEXT* pStackwalkCtx, CLR_BOOL instructionFault, CLR_BOOL* pIsExceptionIntercepted, QCallExceptionStatus* qcallError); -extern "C" CLR_BOOL QCALLTYPE SfiNext(StackFrameIterator* pThis, unsigned int* uExCollideClauseIdx, CLR_BOOL* fUnwoundReversePInvoke, CLR_BOOL* pIsExceptionIntercepted, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE EHEnumNext(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClause* pEHClause, CLR_BOOL* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE SfiInit(StackFrameIterator* pThis, CONTEXT* pStackwalkCtx, CLR_BOOL instructionFault, CLR_BOOL* pIsExceptionIntercepted, CLR_BOOL* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE SfiNext(StackFrameIterator* pThis, unsigned int* uExCollideClauseIdx, CLR_BOOL* fUnwoundReversePInvoke, CLR_BOOL* pIsExceptionIntercepted, CLR_BOOL* pReturnValue); #endif // DACCESS_COMPILE #endif // EXCEPTION_HANDLING_QCALLS_H diff --git a/src/coreclr/vm/exceptmacros.h b/src/coreclr/vm/exceptmacros.h index b6d4184387542b..852b93ee04d6c1 100644 --- a/src/coreclr/vm/exceptmacros.h +++ b/src/coreclr/vm/exceptmacros.h @@ -193,7 +193,7 @@ extern LONG InternalUnhandledExceptionFilter_Worker(PEXCEPTION_POINTERS pExcepti VOID DECLSPEC_NORETURN RaiseTheExceptionInternalOnly(OBJECTREF throwable); -struct QCallExceptionStatus; +typedef UINT_PTR QCallExceptionStatus; #if defined(DACCESS_COMPILE) @@ -204,19 +204,12 @@ struct QCallExceptionStatus; #define UNINSTALL_UNWIND_AND_CONTINUE_HANDLER_EX #else // DACCESS_COMPILE -struct QCallExceptionStatus -{ -private: - INT32 m_exceptionPending; +constexpr QCallExceptionStatus QCallOutOfMemoryException = 1; +constexpr QCallExceptionStatus QCallStackOverflowException = 2; -public: - void SetNoException() - { - m_exceptionPending = 0; - } +void SetQCallExceptionStatusThrowable(QCallExceptionStatus* pStatus, OBJECTREF throwable); - void SetThrowable(OBJECTREF throwable); -}; +static_assert(sizeof(QCallExceptionStatus) == sizeof(void*)); void UnwindAndContinueRethrowHelperInsideCatch(Frame* pEntryFrame, Exception* pException); void UnwindAndContinueRethrowHelperInsideQcallCatch( diff --git a/src/coreclr/vm/finalizerthread.cpp b/src/coreclr/vm/finalizerthread.cpp index 5cdc4ed9438027..bf9bd058b654d5 100644 --- a/src/coreclr/vm/finalizerthread.cpp +++ b/src/coreclr/vm/finalizerthread.cpp @@ -87,7 +87,7 @@ extern "C" void SystemJS_ExecuteFinalizationCallback() RunFinalizerIterationOnCurrentThread(); } #else // TARGET_WASI -extern "C" void QCALLTYPE WasiFinalizer_RunWorker(QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE WasiFinalizer_RunWorker() { QCALL_CONTRACT; BEGIN_QCALL; @@ -128,7 +128,7 @@ extern "C" void WasiFinalizer_Schedule() s_finalizationPending = true; } -extern "C" CLR_BOOL QCALLTYPE WasiFinalizer_TryClearPending(QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE WasiFinalizer_TryClearPending(CLR_BOOL* pReturnValue) { QCALL_CONTRACT; CLR_BOOL pending = FALSE; @@ -139,8 +139,9 @@ extern "C" CLR_BOOL QCALLTYPE WasiFinalizer_TryClearPending(QCallExceptionStatus { s_finalizationPending = false; } + *pReturnValue = pending; + END_QCALL; - return pending; } #endif // TARGET_WASI diff --git a/src/coreclr/vm/ilmarshalers.cpp b/src/coreclr/vm/ilmarshalers.cpp index eda4968a4b558c..d33098de76f2b2 100644 --- a/src/coreclr/vm/ilmarshalers.cpp +++ b/src/coreclr/vm/ilmarshalers.cpp @@ -4759,7 +4759,7 @@ extern "C" void QCALLTYPE MngdSafeArrayMarshaler_CreateMarshaler(MngdSafeArrayMa pThis->m_pConvertContentsToManagedCode = pConvertToManaged; } -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome) { CONTRACTL { @@ -4771,8 +4771,7 @@ extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToNative(MngdSafeAr if (pThis->m_fStatic & MngdSafeArrayMarshaler::SCSF_IsStatic) { - qcallError->SetNoException(); - return; + return QCallExceptionStatus(); } BEGIN_QCALL; @@ -4797,7 +4796,7 @@ extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToNative(MngdSafeAr END_QCALL; } -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCall::ObjectHandleOnStack pOriginalManaged, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCall::ObjectHandleOnStack pOriginalManaged) { CONTRACTL { @@ -4840,7 +4839,7 @@ extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToNative(MngdSaf END_QCALL; } -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome) { CONTRACTL { @@ -4897,7 +4896,7 @@ extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToManaged(MngdSafeA END_QCALL; } -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome) { CONTRACTL { @@ -4934,14 +4933,13 @@ extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToManaged(MngdSa END_QCALL; } -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ClearNative(MngdSafeArrayMarshaler* pThis, void** pNativeHome, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ClearNative(MngdSafeArrayMarshaler* pThis, void** pNativeHome) { QCALL_CONTRACT; if (pThis->m_fStatic & MngdSafeArrayMarshaler::SCSF_IsStatic) { - qcallError->SetNoException(); - return; + return QCallExceptionStatus(); } BEGIN_QCALL; @@ -4987,4 +4985,3 @@ void ILReferenceCustomMarshaler::EmitCreateMngdMarshaler(ILCodeStream* pslILEmit pslILEmit->EmitSTLOC(m_dwMngdMarshalerLocalNum); // Store the ICustomMarshaler as our marshaler state } - diff --git a/src/coreclr/vm/ilmarshalers.h b/src/coreclr/vm/ilmarshalers.h index 28145ae40ca3a1..7c7354ff470851 100644 --- a/src/coreclr/vm/ilmarshalers.h +++ b/src/coreclr/vm/ilmarshalers.h @@ -3463,11 +3463,11 @@ class MngdSafeArrayMarshaler }; extern "C" void QCALLTYPE MngdSafeArrayMarshaler_CreateMarshaler(MngdSafeArrayMarshaler* pThis, MethodTable* pMT, UINT32 iRank, UINT32 dwFlags, PCODE pConvertToNative, PCODE pConvertToManaged); -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCall::ObjectHandleOnStack pOriginalManaged, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ClearNative(MngdSafeArrayMarshaler* pThis, void** pNativeHome, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome); +extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCall::ObjectHandleOnStack pOriginalManaged); +extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome); +extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome); +extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ClearNative(MngdSafeArrayMarshaler* pThis, void** pNativeHome); #endif // FEATURE_COMINTEROP class ILReferenceCustomMarshaler : public ILMngdMarshaler diff --git a/src/coreclr/vm/interoplibinterface.h b/src/coreclr/vm/interoplibinterface.h index c9da0f7eaeeef3..e353c00dfd27e3 100644 --- a/src/coreclr/vm/interoplibinterface.h +++ b/src/coreclr/vm/interoplibinterface.h @@ -67,24 +67,22 @@ using OBJC_TRACKING_INFO_REF = DPTR(ObjcTrackingInformationObject); #endif -extern "C" BOOL QCALLTYPE ObjCMarshal_TryInitializeReferenceTracker( +extern "C" QCallExceptionStatus QCALLTYPE ObjCMarshal_TryInitializeReferenceTracker( _In_ ObjCMarshalNative::BeginEndCallback beginEndCallback, _In_ ObjCMarshalNative::IsReferencedCallback isReferencedCallback, _In_ ObjCMarshalNative::EnteredFinalizationCallback trackedObjectEnteredFinalization, - _In_ QCall::ObjectHandleOnStack objectTrackingInfoTable, - QCallExceptionStatus* qcallError); + _In_ QCall::ObjectHandleOnStack objectTrackingInfoTable, BOOL* pReturnValue); -extern "C" void* QCALLTYPE ObjCMarshal_AllocateReferenceTrackingHandle(_In_ QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ObjCMarshal_AllocateReferenceTrackingHandle(_In_ QCall::ObjectHandleOnStack obj, void** pReturnValue); extern "C" void QCALLTYPE ObjCMarshal_GetOrCreateReferenceTrackingMemory( _In_ QCall::ObjectHandleOnStack obj, _Out_ int* memInSizeT, _Outptr_ void** mem); -extern "C" BOOL QCALLTYPE ObjCMarshal_TrySetGlobalMessageSendCallback( +extern "C" QCallExceptionStatus QCALLTYPE ObjCMarshal_TrySetGlobalMessageSendCallback( _In_ ObjCMarshalNative::MessageSendFunction msgSendFunction, - _In_ void* fptr, - QCallExceptionStatus* qcallError); + _In_ void* fptr, BOOL* pReturnValue); #endif // FEATURE_OBJCMARSHAL @@ -96,20 +94,17 @@ class JavaNative _In_ MarkCrossReferencesArgs* args); }; -extern "C" BOOL QCALLTYPE JavaMarshal_Initialize( - _In_ void* markCrossReferences, - QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE JavaMarshal_Initialize( + _In_ void* markCrossReferences, BOOL* pReturnValue); -extern "C" void* QCALLTYPE JavaMarshal_CreateReferenceTrackingHandle( +extern "C" QCallExceptionStatus QCALLTYPE JavaMarshal_CreateReferenceTrackingHandle( _In_ QCall::ObjectHandleOnStack obj, - _In_ void* context, - QCallExceptionStatus* qcallError); + _In_ void* context, void** pReturnValue); -extern "C" void QCALLTYPE JavaMarshal_FinishCrossReferenceProcessing( +extern "C" QCallExceptionStatus QCALLTYPE JavaMarshal_FinishCrossReferenceProcessing( _In_ MarkCrossReferencesArgs *crossReferences, _In_ size_t length, - _In_ void* unreachableObjectHandles, - QCallExceptionStatus* qcallError); + _In_ void* unreachableObjectHandles); extern "C" BOOL QCALLTYPE JavaMarshal_GetContext( _In_ OBJECTHANDLE handle, diff --git a/src/coreclr/vm/interoplibinterface_comwrappers.cpp b/src/coreclr/vm/interoplibinterface_comwrappers.cpp index 1666f2f33ad9d6..940d914f0e1100 100644 --- a/src/coreclr/vm/interoplibinterface_comwrappers.cpp +++ b/src/coreclr/vm/interoplibinterface_comwrappers.cpp @@ -112,7 +112,7 @@ bool GlobalComWrappersForMarshalling::TryGetOrCreateObjectForComInstance( return obj != NULL; } -extern "C" void* QCALLTYPE ComWrappers_AllocateRefCountedHandle(_In_ QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ComWrappers_AllocateRefCountedHandle(_In_ QCall::ObjectHandleOnStack obj, void** pReturnValue) { QCALL_CONTRACT; @@ -126,9 +126,9 @@ extern "C" void* QCALLTYPE ComWrappers_AllocateRefCountedHandle(_In_ QCall::Obje handle = GetAppDomain()->CreateTypedHandle(obj.Get(), HNDTYPE_REFCOUNTED); } - END_QCALL; + *pReturnValue = handle; - return handle; + END_QCALL; } extern "C" void const* QCALLTYPE ComWrappers_GetIReferenceTrackerTargetVftbl() @@ -567,7 +567,7 @@ void ComWrappersNative::OnAfterGCScanRoots() (void)InteropLib::Com::DetachNonPromotedObjects(&cxt); } -extern "C" void QCALLTYPE ComWrappers_RegisterIsRootedCallback(QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ComWrappers_RegisterIsRootedCallback() { QCALL_CONTRACT; @@ -579,7 +579,7 @@ extern "C" void QCALLTYPE ComWrappers_RegisterIsRootedCallback(QCallExceptionSta END_QCALL; } -extern "C" void QCALLTYPE TrackerObjectManager_RegisterNativeObjectWrapperCache(_In_ QCall::ObjectHandleOnStack cache, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE TrackerObjectManager_RegisterNativeObjectWrapperCache(_In_ QCall::ObjectHandleOnStack cache) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/interoplibinterface_comwrappers.h b/src/coreclr/vm/interoplibinterface_comwrappers.h index 61e414b1389f78..2dd7c9109c337b 100644 --- a/src/coreclr/vm/interoplibinterface_comwrappers.h +++ b/src/coreclr/vm/interoplibinterface_comwrappers.h @@ -34,19 +34,19 @@ extern "C" void QCALLTYPE ComWrappers_GetIUnknownImpl( extern "C" void* QCALLTYPE ComWrappers_GetUntrackedAddRefRelease(); -extern "C" void* QCALLTYPE ComWrappers_AllocateRefCountedHandle(_In_ QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ComWrappers_AllocateRefCountedHandle(_In_ QCall::ObjectHandleOnStack obj, void** pReturnValue); extern "C" void const* QCALLTYPE ComWrappers_GetIReferenceTrackerTargetVftbl(); extern "C" void const* QCALLTYPE ComWrappers_GetTaggedImpl(); -extern "C" void QCALLTYPE ComWrappers_RegisterIsRootedCallback(QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ComWrappers_RegisterIsRootedCallback(); extern "C" CLR_BOOL QCALLTYPE TrackerObjectManager_HasReferenceTrackerManager(); extern "C" CLR_BOOL QCALLTYPE TrackerObjectManager_TryRegisterReferenceTrackerManager(_In_ void* manager); -extern "C" void QCALLTYPE TrackerObjectManager_RegisterNativeObjectWrapperCache(_In_ QCall::ObjectHandleOnStack cache, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE TrackerObjectManager_RegisterNativeObjectWrapperCache(_In_ QCall::ObjectHandleOnStack cache); extern "C" CLR_BOOL QCALLTYPE TrackerObjectManager_IsGlobalPeggingEnabled(); diff --git a/src/coreclr/vm/interoplibinterface_java.cpp b/src/coreclr/vm/interoplibinterface_java.cpp index 59784c08d20192..6bac5a02876ea1 100644 --- a/src/coreclr/vm/interoplibinterface_java.cpp +++ b/src/coreclr/vm/interoplibinterface_java.cpp @@ -134,9 +134,8 @@ void Interop::FinishCrossReferenceProcessing( ReleaseGCBridgeArgumentsWorker(args); } -extern "C" BOOL QCALLTYPE JavaMarshal_Initialize( - _In_ void* markCrossReferences, - QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE JavaMarshal_Initialize( + _In_ void* markCrossReferences, BOOL* pReturnValue) { QCALL_CONTRACT; _ASSERTE(markCrossReferences != NULL); @@ -158,15 +157,14 @@ extern "C" BOOL QCALLTYPE JavaMarshal_Initialize( } } - END_QCALL; + *pReturnValue = success; - return success; + END_QCALL; } -extern "C" void* QCALLTYPE JavaMarshal_CreateReferenceTrackingHandle( +extern "C" QCallExceptionStatus QCALLTYPE JavaMarshal_CreateReferenceTrackingHandle( _In_ QCall::ObjectHandleOnStack obj, - _In_ void* context, - QCallExceptionStatus* qcallError) + _In_ void* context, void** pReturnValue) { QCALL_CONTRACT; @@ -177,16 +175,15 @@ extern "C" void* QCALLTYPE JavaMarshal_CreateReferenceTrackingHandle( GCX_COOP(); instHandle = GetAppDomain()->CreateCrossReferenceHandle(obj.Get(), context); - END_QCALL; + *pReturnValue = (void*)instHandle; - return (void*)instHandle; + END_QCALL; } -extern "C" void QCALLTYPE JavaMarshal_FinishCrossReferenceProcessing( +extern "C" QCallExceptionStatus QCALLTYPE JavaMarshal_FinishCrossReferenceProcessing( _In_ MarkCrossReferencesArgs *crossReferences, _In_ size_t length, - _In_ void* unreachableObjectHandles, - QCallExceptionStatus* qcallError) + _In_ void* unreachableObjectHandles) { QCALL_CONTRACT; _ASSERTE(crossReferences->ComponentCount >= 0); diff --git a/src/coreclr/vm/interoplibinterface_objc.cpp b/src/coreclr/vm/interoplibinterface_objc.cpp index 18330649847af3..36bc28d23c4847 100644 --- a/src/coreclr/vm/interoplibinterface_objc.cpp +++ b/src/coreclr/vm/interoplibinterface_objc.cpp @@ -24,12 +24,11 @@ namespace ObjCMarshalNative::EnteredFinalizationCallback g_TrackedObjectEnteredFinalizationCallback; } -extern "C" BOOL QCALLTYPE ObjCMarshal_TryInitializeReferenceTracker( +extern "C" QCallExceptionStatus QCALLTYPE ObjCMarshal_TryInitializeReferenceTracker( _In_ ObjCMarshalNative::BeginEndCallback beginEndCallback, _In_ ObjCMarshalNative::IsReferencedCallback isReferencedCallback, _In_ ObjCMarshalNative::EnteredFinalizationCallback trackedObjectEnteredFinalization, - _In_ QCall::ObjectHandleOnStack objectTrackingInfoTable, - QCallExceptionStatus* qcallError) + _In_ QCall::ObjectHandleOnStack objectTrackingInfoTable, BOOL* pReturnValue) { QCALL_CONTRACT; _ASSERTE(beginEndCallback != NULL @@ -56,12 +55,12 @@ extern "C" BOOL QCALLTYPE ObjCMarshal_TryInitializeReferenceTracker( } } - END_QCALL; + *pReturnValue = success; - return success; + END_QCALL; } -extern "C" void* QCALLTYPE ObjCMarshal_AllocateReferenceTrackingHandle(_In_ QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ObjCMarshal_AllocateReferenceTrackingHandle(_In_ QCall::ObjectHandleOnStack obj, void** pReturnValue) { QCALL_CONTRACT; @@ -74,9 +73,9 @@ extern "C" void* QCALLTYPE ObjCMarshal_AllocateReferenceTrackingHandle(_In_ QCal GCX_COOP(); instHandle = GetAppDomain()->CreateTypedHandle(obj.Get(), HNDTYPE_REFCOUNTED); - END_QCALL; + *pReturnValue = (void*)instHandle; - return (void*)instHandle; + END_QCALL; } namespace @@ -120,10 +119,9 @@ namespace } } -extern "C" BOOL QCALLTYPE ObjCMarshal_TrySetGlobalMessageSendCallback( +extern "C" QCallExceptionStatus QCALLTYPE ObjCMarshal_TrySetGlobalMessageSendCallback( _In_ ObjCMarshalNative::MessageSendFunction msgSendFunction, - _In_ void* fptr, - QCallExceptionStatus* qcallError) + _In_ void* fptr, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -138,9 +136,9 @@ extern "C" BOOL QCALLTYPE ObjCMarshal_TrySetGlobalMessageSendCallback( if (success && FALSE == InterlockedCompareExchange((LONG*)&s_msgSendOverridden, TRUE, FALSE)) PInvokeOverride::SetPInvokeOverride(&MessageSendPInvokeOverride, PInvokeOverride::Source::ObjectiveCInterop); - END_QCALL; + *pReturnValue = success ? TRUE : FALSE; - return success ? TRUE : FALSE; + END_QCALL; } namespace diff --git a/src/coreclr/vm/jithelpers.cpp b/src/coreclr/vm/jithelpers.cpp index 00d7eaf15de06a..08c04122ff395a 100644 --- a/src/coreclr/vm/jithelpers.cpp +++ b/src/coreclr/vm/jithelpers.cpp @@ -245,7 +245,7 @@ HCIMPLEND #include // Helper for the managed InitClass implementations -extern "C" void QCALLTYPE InitClassHelper(MethodTable* pMT, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE InitClassHelper(MethodTable* pMT) { QCALL_CONTRACT; BEGIN_QCALL; @@ -318,7 +318,7 @@ __declspec(selectany) #endif // _MSC_VER PLATFORM_THREAD_LOCAL ThreadLocalData t_ThreadStatics; -extern "C" void QCALLTYPE GetThreadStaticsByMethodTable(QCall::ByteRefOnStack refHandle, MethodTable* pMT, BOOL gcStatic, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GetThreadStaticsByMethodTable(QCall::ByteRefOnStack refHandle, MethodTable* pMT, BOOL gcStatic) { QCALL_CONTRACT; @@ -339,7 +339,7 @@ extern "C" void QCALLTYPE GetThreadStaticsByMethodTable(QCall::ByteRefOnStack re END_QCALL; } -extern "C" void QCALLTYPE GetThreadStaticsByIndex(QCall::ByteRefOnStack refHandle, uint32_t staticBlockIndex, BOOL gcStatic, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GetThreadStaticsByIndex(QCall::ByteRefOnStack refHandle, uint32_t staticBlockIndex, BOOL gcStatic) { QCALL_CONTRACT; @@ -473,7 +473,7 @@ BOOL ObjIsInstanceOf(Object* pObject, TypeHandle toTypeHnd, BOOL throwCastExcept return ObjIsInstanceOfCore(pObject, toTypeHnd, throwCastException); } -extern "C" BOOL QCALLTYPE IsInstanceOf_NoCacheLookup(EnregisteredTypeHandle type, BOOL throwCastException, QCall::ObjectHandleOnStack objOnStack, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE IsInstanceOf_NoCacheLookup(EnregisteredTypeHandle type, BOOL throwCastException, QCall::ObjectHandleOnStack objOnStack, BOOL* pReturnValue) { QCALL_CONTRACT; BOOL result = FALSE; @@ -484,9 +484,9 @@ extern "C" BOOL QCALLTYPE IsInstanceOf_NoCacheLookup(EnregisteredTypeHandle type result = ObjIsInstanceOfCore(OBJECTREFToObject(objOnStack.Get()), TypeHandle::FromPtr(type), throwCastException); - END_QCALL; + *pReturnValue = result; - return result; + END_QCALL; } //======================================================================== @@ -502,7 +502,7 @@ HCIMPL2(BOOL, JIT_IsInstanceOfException, EnregisteredTypeHandle type, Object* ob } HCIMPLEND -extern "C" void QCALLTYPE ThrowInvalidCastException(EnregisteredTypeHandle pSourceType, EnregisteredTypeHandle pTargetType, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ThrowInvalidCastException(EnregisteredTypeHandle pSourceType, EnregisteredTypeHandle pTargetType) { QCALL_CONTRACT; @@ -600,7 +600,7 @@ DictionaryEntry GenericHandleWorkerCore(MethodDesc * pMD, MethodTable * pMT, LPV return result; } -extern "C" void* QCALLTYPE GenericHandleWorker(MethodDesc * pMD, MethodTable * pMT, LPVOID signature, DWORD dictionaryIndexAndSlot, Module* pModule, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GenericHandleWorker(MethodDesc * pMD, MethodTable * pMT, LPVOID signature, DWORD dictionaryIndexAndSlot, Module* pModule, void** pReturnValue) { QCALL_CONTRACT; @@ -610,9 +610,9 @@ extern "C" void* QCALLTYPE GenericHandleWorker(MethodDesc * pMD, MethodTable * p result = GenericHandleWorkerCore(pMD, pMT, signature, dictionaryIndexAndSlot, pModule); - END_QCALL; + *pReturnValue = result; - return result; + END_QCALL; } // GenericHandleWorker FieldDesc* g_pVirtualFunctionPointerCache; @@ -673,10 +673,9 @@ void FlushVirtualFunctionPointerCaches() // static method signature (i.e. might be for a superclass of classHnd) // slow helper to call from the fast one -extern "C" PCODE QCALLTYPE ResolveVirtualFunctionPointer(QCall::ObjectHandleOnStack obj, +extern "C" QCallExceptionStatus QCALLTYPE ResolveVirtualFunctionPointer(QCall::ObjectHandleOnStack obj, EnregisteredTypeHandle classHnd, - MethodDesc* pStaticMD, - QCallExceptionStatus* qcallError) + MethodDesc* pStaticMD, PCODE* pReturnValue) { QCALL_CONTRACT; @@ -741,9 +740,9 @@ extern "C" PCODE QCALLTYPE ResolveVirtualFunctionPointer(QCall::ObjectHandleOnSt } GCPROTECT_END(); - END_QCALL; + *pReturnValue = addr; - return addr; + END_QCALL; } HCIMPL3(void, Jit_NativeMemSet, void* pDest, int value, size_t length) diff --git a/src/coreclr/vm/loaderallocator.cpp b/src/coreclr/vm/loaderallocator.cpp index 656a9b21624f18..46aa21e02af132 100644 --- a/src/coreclr/vm/loaderallocator.cpp +++ b/src/coreclr/vm/loaderallocator.cpp @@ -757,7 +757,7 @@ BOOL LoaderAllocator::Destroy(QCall::LoaderAllocatorHandle pLoaderAllocator) return FALSE; } // LoaderAllocator::Destroy -extern "C" BOOL QCALLTYPE LoaderAllocator_Destroy(QCall::LoaderAllocatorHandle pLoaderAllocator, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE LoaderAllocator_Destroy(QCall::LoaderAllocatorHandle pLoaderAllocator, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -767,9 +767,9 @@ extern "C" BOOL QCALLTYPE LoaderAllocator_Destroy(QCall::LoaderAllocatorHandle p ret = LoaderAllocator::Destroy(pLoaderAllocator); - END_QCALL; + *pReturnValue = ret; - return ret; + END_QCALL; } #define MAX_LOADERALLOCATOR_HANDLE 0x40000000 diff --git a/src/coreclr/vm/loaderallocator.hpp b/src/coreclr/vm/loaderallocator.hpp index 5c717beebad038..0ba75c0e8a6a40 100644 --- a/src/coreclr/vm/loaderallocator.hpp +++ b/src/coreclr/vm/loaderallocator.hpp @@ -960,7 +960,7 @@ struct cdac_data typedef VPTR(LoaderAllocator) PTR_LoaderAllocator; -extern "C" BOOL QCALLTYPE LoaderAllocator_Destroy(QCall::LoaderAllocatorHandle pLoaderAllocator, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE LoaderAllocator_Destroy(QCall::LoaderAllocatorHandle pLoaderAllocator, BOOL* pReturnValue); class GlobalLoaderAllocator : public LoaderAllocator { diff --git a/src/coreclr/vm/managedmdimport.cpp b/src/coreclr/vm/managedmdimport.cpp index e83ccc2ae32517..c7154088656c44 100644 --- a/src/coreclr/vm/managedmdimport.cpp +++ b/src/coreclr/vm/managedmdimport.cpp @@ -533,14 +533,13 @@ static void* EnsureResultSize( return p; } -extern "C" void QCALLTYPE MetadataImport_Enum( +extern "C" QCallExceptionStatus QCALLTYPE MetadataImport_Enum( IMDInternalImport* pScope, mdToken type, mdToken tkParent, /* in/out */ INT32* length, INT32* shortResult, - QCall::ObjectHandleOnStack longResult, - QCallExceptionStatus* qcallError) + QCall::ObjectHandleOnStack longResult) { CONTRACTL { diff --git a/src/coreclr/vm/managedmdimport.hpp b/src/coreclr/vm/managedmdimport.hpp index b0d8fcf67f1ee6..cd71a13298683b 100644 --- a/src/coreclr/vm/managedmdimport.hpp +++ b/src/coreclr/vm/managedmdimport.hpp @@ -72,13 +72,12 @@ extern "C" BOOL QCALLTYPE MetadataImport_GetMarshalAs( INT32* marshalCookieLength, INT32* iidParamIndex); -extern "C" void QCALLTYPE MetadataImport_Enum( +extern "C" QCallExceptionStatus QCALLTYPE MetadataImport_Enum( IMDInternalImport* pScope, mdToken type, mdToken tkParent, INT32* length, INT32* shortResult, - QCall::ObjectHandleOnStack longResult, - QCallExceptionStatus* qcallError); + QCall::ObjectHandleOnStack longResult); #endif diff --git a/src/coreclr/vm/marshalnative.cpp b/src/coreclr/vm/marshalnative.cpp index 9ad0896140dd2b..8b52eba0631621 100644 --- a/src/coreclr/vm/marshalnative.cpp +++ b/src/coreclr/vm/marshalnative.cpp @@ -50,7 +50,7 @@ // Prelink // Does advance loading of an PInvoke library -extern "C" VOID QCALLTYPE MarshalNative_Prelink(MethodDesc * pMD, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_Prelink(MethodDesc * pMD) { QCALL_CONTRACT; @@ -61,15 +61,13 @@ extern "C" VOID QCALLTYPE MarshalNative_Prelink(MethodDesc * pMD, QCallException // This is a perf thing since it's always safe to execute the prestub twice. if (!pMD->ShouldCallPrestub()) { - qcallError->SetNoException(); - return; + return QCallExceptionStatus(); } // Silently ignore if not PInvoke and not runtime generated. if (!(pMD->IsPInvoke()) && !(pMD->IsRuntimeSupplied())) { - qcallError->SetNoException(); - return; + return QCallExceptionStatus(); } BEGIN_QCALL; @@ -83,7 +81,7 @@ extern "C" VOID QCALLTYPE MarshalNative_Prelink(MethodDesc * pMD, QCallException // IsBuiltInComSupported // Built-in COM support is only checked from the native side to ensure the runtime // is in a consistent state -extern "C" BOOL QCALLTYPE MarshalNative_IsBuiltInComSupported(QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_IsBuiltInComSupported(BOOL* pReturnValue) { QCALL_CONTRACT; @@ -97,12 +95,12 @@ extern "C" BOOL QCALLTYPE MarshalNative_IsBuiltInComSupported(QCallExceptionStat ret = FALSE; #endif // FEATURE_COMINTEROP - END_QCALL; + *pReturnValue = ret; - return ret; + END_QCALL; } -extern "C" BOOL QCALLTYPE MarshalNative_HasLayout(QCall::TypeHandle t, BOOL* pIsBlittable, DWORD* pNativeSize, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_HasLayout(QCall::TypeHandle t, BOOL* pIsBlittable, DWORD* pNativeSize, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -131,15 +129,15 @@ extern "C" BOOL QCALLTYPE MarshalNative_HasLayout(QCall::TypeHandle t, BOOL* pIs *pNativeSize = 0; } - END_QCALL; + *pReturnValue = ret; - return ret; + END_QCALL; } /************************************************************************ * PInvoke.SizeOf(Class) */ -extern "C" INT32 QCALLTYPE MarshalNative_SizeOfHelper(QCall::TypeHandle t, BOOL throwIfNotMarshalable, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_SizeOfHelper(QCall::TypeHandle t, BOOL throwIfNotMarshalable, INT32* pReturnValue) { QCALL_CONTRACT; @@ -165,11 +163,12 @@ extern "C" INT32 QCALLTYPE MarshalNative_SizeOfHelper(QCall::TypeHandle t, BOOL // The type is marshalable or we don't care so return its size. rv = th.GetMethodTable()->GetNativeSize(); + *pReturnValue = rv; + END_QCALL; - return rv; } -extern "C" SIZE_T QCALLTYPE MarshalNative_OffsetOf(FieldDesc* pFD, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_OffsetOf(FieldDesc* pFD, SIZE_T* pReturnValue) { CONTRACTL { @@ -216,12 +215,12 @@ extern "C" SIZE_T QCALLTYPE MarshalNative_OffsetOf(FieldDesc* pFD, QCallExceptio CONSISTENCY_CHECK_MSG(foundField, "We should never hit this point since we already verified that the requested field was present from managed code"); } - END_QCALL; + *pReturnValue = offset; - return offset; + END_QCALL; } -extern "C" void QCALLTYPE MarshalNative_GetDelegateForFunctionPointerInternal(PVOID FPtr, QCall::TypeHandle t, QCall::ObjectHandleOnStack retDelegate, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetDelegateForFunctionPointerInternal(PVOID FPtr, QCall::TypeHandle t, QCall::ObjectHandleOnStack retDelegate) { QCALL_CONTRACT; @@ -238,7 +237,7 @@ extern "C" void QCALLTYPE MarshalNative_GetDelegateForFunctionPointerInternal(PV END_QCALL; } -extern "C" PVOID QCALLTYPE MarshalNative_GetFunctionPointerForDelegateInternal(QCall::ObjectHandleOnStack d, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetFunctionPointerForDelegateInternal(QCall::ObjectHandleOnStack d, PVOID* pReturnValue) { QCALL_CONTRACT; @@ -249,9 +248,9 @@ extern "C" PVOID QCALLTYPE MarshalNative_GetFunctionPointerForDelegateInternal(Q GCX_COOP(); pFPtr = COMDelegate::ConvertToCallback(d.Get()); - END_QCALL; + *pReturnValue = pFPtr; - return pFPtr; + END_QCALL; } #ifdef _DEBUG @@ -317,7 +316,7 @@ DWORD STDMETHODCALLTYPE FalseGetLastError() * Support for the GCHandle class. */ -extern "C" OBJECTHANDLE QCALLTYPE GCHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack obj, int type, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GCHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack obj, int type, OBJECTHANDLE* pReturnValue) { QCALL_CONTRACT; @@ -328,9 +327,9 @@ extern "C" OBJECTHANDLE QCALLTYPE GCHandle_InternalAllocWithGCTransition(QCall:: GCX_COOP(); hnd = GetAppDomain()->CreateTypedHandle(obj.Get(), static_cast(type)); - END_QCALL; + *pReturnValue = hnd; - return hnd; + END_QCALL; } FCIMPL2(LPVOID, MarshalNative::GCHandleInternalAlloc, Object *obj, int type) @@ -348,7 +347,7 @@ FCIMPL2(LPVOID, MarshalNative::GCHandleInternalAlloc, Object *obj, int type) } FCIMPLEND -extern "C" void QCALLTYPE GCHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GCHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle) { QCALL_CONTRACT; @@ -408,7 +407,7 @@ FCIMPL2(FC_BOOL_RET, MarshalNative::GCHandleInternalTryGetBridgeWait, OBJECTHAND FCIMPLEND // Unlike the fast call above, this can block -extern "C" void QCALLTYPE GCHandle_InternalGetBridgeWait(OBJECTHANDLE handle, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE GCHandle_InternalGetBridgeWait(OBJECTHANDLE handle, QCall::ObjectHandleOnStack result) { QCALL_CONTRACT; @@ -458,7 +457,7 @@ FCIMPLEND // *** Interop Helpers *** //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetExceptionForHR(INT32 errorCode, LPVOID errorInfo, QCall::ObjectHandleOnStack retVal, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetExceptionForHR(INT32 errorCode, LPVOID errorInfo, QCall::ObjectHandleOnStack retVal) { CONTRACTL { @@ -500,7 +499,7 @@ extern "C" void QCALLTYPE MarshalNative_GetExceptionForHR(INT32 errorCode, LPVOI } #ifdef FEATURE_COMINTEROP -extern "C" int32_t QCALLTYPE MarshalNative_GetHRForException(QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetHRForException(QCall::ObjectHandleOnStack obj, int32_t* pReturnValue) { CONTRACTL { @@ -517,15 +516,15 @@ extern "C" int32_t QCALLTYPE MarshalNative_GetHRForException(QCall::ObjectHandle hr = SetupErrorInfo(obj.Get()); - END_QCALL; + *pReturnValue = hr; - return hr; + END_QCALL; } //==================================================================== // return the IUnknown* for an Object. //==================================================================== -extern "C" IUnknown* QCALLTYPE MarshalNative_GetIUnknownForObject(QCall::ObjectHandleOnStack o, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetIUnknownForObject(QCall::ObjectHandleOnStack o, IUnknown** pReturnValue) { QCALL_CONTRACT; @@ -543,14 +542,15 @@ extern "C" IUnknown* QCALLTYPE MarshalNative_GetIUnknownForObject(QCall::ObjectH retVal = GetComIPFromObjectRef(&oref, ComIpType_OuterUnknown, NULL); GCPROTECT_END(); + *pReturnValue = retVal; + END_QCALL; - return retVal; } //==================================================================== // return the IDispatch* for an Object. //==================================================================== -extern "C" IDispatch* QCALLTYPE MarshalNative_GetIDispatchForObject(QCall::ObjectHandleOnStack o, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetIDispatchForObject(QCall::ObjectHandleOnStack o, IDispatch** pReturnValue) { QCALL_CONTRACT; @@ -568,14 +568,15 @@ extern "C" IDispatch* QCALLTYPE MarshalNative_GetIDispatchForObject(QCall::Objec retVal = (IDispatch*)GetComIPFromObjectRef(&oref, ComIpType_Dispatch, NULL); GCPROTECT_END(); + *pReturnValue = retVal; + END_QCALL; - return retVal; } //==================================================================== // return the IUnknown* or IDispatch* for an Object. //==================================================================== -extern "C" void* QCALLTYPE MarshalNative_GetIUnknownOrIDispatchForObject(QCall::ObjectHandleOnStack o, BOOL* isIDispatch, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetIUnknownOrIDispatchForObject(QCall::ObjectHandleOnStack o, BOOL* isIDispatch, void** pReturnValue) { QCALL_CONTRACT; @@ -595,15 +596,16 @@ extern "C" void* QCALLTYPE MarshalNative_GetIUnknownOrIDispatchForObject(QCall:: *isIDispatch = fetchedIpType == ComIpType_Dispatch; GCPROTECT_END(); + *pReturnValue = retVal; + END_QCALL; - return retVal; } //==================================================================== // return the IUnknown* representing the interface for the Object // Object o should support Type T //==================================================================== -extern "C" IUnknown* QCALLTYPE MarshalNative_GetComInterfaceForObject(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, BOOL bEnableCustomizedQueryInterface, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetComInterfaceForObject(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, BOOL bEnableCustomizedQueryInterface, IUnknown** pReturnValue) { QCALL_CONTRACT; @@ -641,15 +643,15 @@ extern "C" IUnknown* QCALLTYPE MarshalNative_GetComInterfaceForObject(QCall::Obj GCPROTECT_END(); - END_QCALL; + *pReturnValue = retVal; - return retVal; + END_QCALL; } //==================================================================== // return an Object for IUnknown //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject) { CONTRACTL { @@ -674,7 +676,7 @@ extern "C" void QCALLTYPE MarshalNative_GetObjectForIUnknown(IUnknown* pUnk, QCa END_QCALL; } -extern "C" void QCALLTYPE MarshalNative_GetUniqueObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetUniqueObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject) { CONTRACTL { @@ -704,7 +706,7 @@ extern "C" void QCALLTYPE MarshalNative_GetUniqueObjectForIUnknown(IUnknown* pUn // NOTE: // Type T should be either a COM imported Type or a sub-type of COM imported Type //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetTypedObjectForIUnknown(IUnknown* pUnk, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetTypedObjectForIUnknown(IUnknown* pUnk, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject) { CONTRACTL { @@ -736,7 +738,7 @@ extern "C" void QCALLTYPE MarshalNative_GetTypedObjectForIUnknown(IUnknown* pUnk END_QCALL; } -extern "C" IUnknown* QCALLTYPE MarshalNative_CreateAggregatedObject(IUnknown* pOuter, QCall::ObjectHandleOnStack o, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_CreateAggregatedObject(IUnknown* pOuter, QCall::ObjectHandleOnStack o, IUnknown** pReturnValue) { CONTRACTL { @@ -771,15 +773,15 @@ extern "C" IUnknown* QCALLTYPE MarshalNative_CreateAggregatedObject(IUnknown* pO GCPROTECT_END(); - END_QCALL; + *pReturnValue = pInner; - return pInner; + END_QCALL; } //==================================================================== // Free unused RCWs in the current CLR context. //==================================================================== -extern "C" void QCALLTYPE MarshalNative_CleanupUnusedObjectsInCurrentContext(QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_CleanupUnusedObjectsInCurrentContext() { QCALL_CONTRACT; @@ -818,7 +820,7 @@ FCIMPLEND // free the COM component and zombie this object if the ref count hits 0 // further usage of this Object might throw an exception, //==================================================================== -extern "C" INT32 QCALLTYPE MarshalNative_ReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_ReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, INT32* pReturnValue) { QCALL_CONTRACT; @@ -841,16 +843,16 @@ extern "C" INT32 QCALLTYPE MarshalNative_ReleaseComObject(QCall::ObjectHandleOnS GCPROTECT_END(); - END_QCALL; + *pReturnValue = retVal; - return retVal; + END_QCALL; } //==================================================================== // free the COM component and zombie this object // further usage of this Object might throw an exception, //==================================================================== -extern "C" void QCALLTYPE MarshalNative_FinalReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_FinalReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE) { QCALL_CONTRACT; @@ -878,7 +880,7 @@ extern "C" void QCALLTYPE MarshalNative_FinalReleaseComObject(QCall::ObjectHandl // This method takes the given COM object and wraps it in an object // of the specified type. The type must be derived from __ComObject. //==================================================================== -extern "C" void QCALLTYPE MarshalNative_InternalCreateWrapperOfType(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_InternalCreateWrapperOfType(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject) { QCALL_CONTRACT; @@ -940,7 +942,7 @@ extern "C" void QCALLTYPE MarshalNative_InternalCreateWrapperOfType(QCall::Objec //==================================================================== // check if the type is visible from COM. //==================================================================== -extern "C" BOOL QCALLTYPE MarshalNative_IsTypeVisibleFromCom(QCall::TypeHandle t, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_IsTypeVisibleFromCom(QCall::TypeHandle t, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -951,12 +953,12 @@ extern "C" BOOL QCALLTYPE MarshalNative_IsTypeVisibleFromCom(QCall::TypeHandle t // Call the internal version of IsTypeVisibleFromCom. retVal = ::IsTypeVisibleFromCom(t.AsTypeHandle()); - END_QCALL; + *pReturnValue = retVal; - return retVal; + END_QCALL; } -extern "C" void QCALLTYPE MarshalNative_GetNativeVariantForObject(QCall::ObjectHandleOnStack ObjUNSAFE, LPVOID pDestNativeVariant, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetNativeVariantForObject(QCall::ObjectHandleOnStack ObjUNSAFE, LPVOID pDestNativeVariant) { CONTRACTL { @@ -990,7 +992,7 @@ extern "C" void QCALLTYPE MarshalNative_GetNativeVariantForObject(QCall::ObjectH END_QCALL; } -extern "C" void QCALLTYPE MarshalNative_GetObjectForNativeVariant(LPVOID pSrcNativeVariant, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetObjectForNativeVariant(LPVOID pSrcNativeVariant, QCall::ObjectHandleOnStack retObject) { CONTRACTL { @@ -1013,7 +1015,7 @@ extern "C" void QCALLTYPE MarshalNative_GetObjectForNativeVariant(LPVOID pSrcNat } -extern "C" void QCALLTYPE MarshalNative_GetObjectsForNativeVariants(VARIANT* aSrcNativeVariant, int cVars, QCall::ObjectHandleOnStack retArray, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetObjectsForNativeVariants(VARIANT* aSrcNativeVariant, int cVars, QCall::ObjectHandleOnStack retArray) { CONTRACTL { @@ -1100,7 +1102,7 @@ static int GetComSlotInfo(MethodTable *pMT, MethodTable **ppDefItfMT) } } -extern "C" INT32 QCALLTYPE MarshalNative_GetStartComSlot(QCall::TypeHandle t, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetStartComSlot(QCall::TypeHandle t, INT32* pReturnValue) { QCALL_CONTRACT; @@ -1118,12 +1120,12 @@ extern "C" INT32 QCALLTYPE MarshalNative_GetStartComSlot(QCall::TypeHandle t, QC retVal = GetComSlotInfo(pMT, &pMT); - END_QCALL; + *pReturnValue = retVal; - return retVal; + END_QCALL; } -extern "C" INT32 QCALLTYPE MarshalNative_GetEndComSlot(QCall::TypeHandle t, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetEndComSlot(QCall::TypeHandle t, INT32* pReturnValue) { QCALL_CONTRACT; @@ -1157,12 +1159,12 @@ extern "C" INT32 QCALLTYPE MarshalNative_GetEndComSlot(QCall::TypeHandle t, QCal retVal = int(StartSlot + MemberMap.GetMethods().Size() - 1); } - END_QCALL; + *pReturnValue = retVal; - return retVal; + END_QCALL; } -extern "C" VOID QCALLTYPE MarshalNative_ChangeWrapperHandleStrength(QCall::ObjectHandleOnStack otp, BOOL fIsWeak, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_ChangeWrapperHandleStrength(QCall::ObjectHandleOnStack otp, BOOL fIsWeak) { QCALL_CONTRACT; @@ -1188,7 +1190,7 @@ extern "C" VOID QCALLTYPE MarshalNative_ChangeWrapperHandleStrength(QCall::Objec END_QCALL; } -extern "C" void QCALLTYPE MarshalNative_GetTypeFromCLSID(REFCLSID clsid, PCWSTR wszServer, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetTypeFromCLSID(REFCLSID clsid, PCWSTR wszServer, QCall::ObjectHandleOnStack retType) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/marshalnative.h b/src/coreclr/vm/marshalnative.h index 01a9cb3c8e58c5..df8d706193b711 100644 --- a/src/coreclr/vm/marshalnative.h +++ b/src/coreclr/vm/marshalnative.h @@ -37,29 +37,29 @@ class MarshalNative #endif // FEATURE_COMINTEROP }; -extern "C" SIZE_T QCALLTYPE MarshalNative_OffsetOf(FieldDesc* pFD, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_OffsetOf(FieldDesc* pFD, SIZE_T* pReturnValue); -extern "C" VOID QCALLTYPE MarshalNative_Prelink(MethodDesc * pMD, QCallExceptionStatus* qcallError); -extern "C" BOOL QCALLTYPE MarshalNative_IsBuiltInComSupported(QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_Prelink(MethodDesc * pMD); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_IsBuiltInComSupported(BOOL* pReturnValue); -extern "C" BOOL QCALLTYPE MarshalNative_HasLayout(QCall::TypeHandle t, BOOL* pIsBlittable, DWORD* pNativeSize, QCallExceptionStatus* qcallError); -extern "C" INT32 QCALLTYPE MarshalNative_SizeOfHelper(QCall::TypeHandle t, BOOL throwIfNotMarshalable, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_HasLayout(QCall::TypeHandle t, BOOL* pIsBlittable, DWORD* pNativeSize, BOOL* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_SizeOfHelper(QCall::TypeHandle t, BOOL throwIfNotMarshalable, INT32* pReturnValue); -extern "C" void QCALLTYPE MarshalNative_GetDelegateForFunctionPointerInternal(PVOID FPtr, QCall::TypeHandle t, QCall::ObjectHandleOnStack retDelegate, QCallExceptionStatus* qcallError); -extern "C" PVOID QCALLTYPE MarshalNative_GetFunctionPointerForDelegateInternal(QCall::ObjectHandleOnStack delegate, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetDelegateForFunctionPointerInternal(PVOID FPtr, QCall::TypeHandle t, QCall::ObjectHandleOnStack retDelegate); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetFunctionPointerForDelegateInternal(QCall::ObjectHandleOnStack delegate, PVOID* pReturnValue); //==================================================================== // These methods convert between an HR and and a managed exception. //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetExceptionForHR(INT32 errorCode, LPVOID errorInfo, QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetExceptionForHR(INT32 errorCode, LPVOID errorInfo, QCall::ObjectHandleOnStack obj); #ifdef FEATURE_COMINTEROP -extern "C" int32_t QCALLTYPE MarshalNative_GetHRForException(QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetHRForException(QCall::ObjectHandleOnStack obj, int32_t* pReturnValue); #endif // FEATURE_COMINTEROP -extern "C" OBJECTHANDLE QCALLTYPE GCHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack obj, int type, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE GCHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE GCHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack obj, int type, OBJECTHANDLE* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE GCHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle); #ifdef FEATURE_JAVAMARSHAL -extern "C" void QCALLTYPE GCHandle_InternalGetBridgeWait(OBJECTHANDLE handle, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE GCHandle_InternalGetBridgeWait(OBJECTHANDLE handle, QCall::ObjectHandleOnStack result); #endif #ifdef _DEBUG @@ -71,88 +71,88 @@ extern "C" IsInCooperativeGCMode_fn QCALLTYPE MarshalNative_GetIsInCooperativeGC //==================================================================== // Create type for given CLSID. //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetTypeFromCLSID(REFCLSID clsid, PCWSTR wszServer, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetTypeFromCLSID(REFCLSID clsid, PCWSTR wszServer, QCall::ObjectHandleOnStack retType); //==================================================================== // return the IUnknown* for an Object //==================================================================== -extern "C" IUnknown* QCALLTYPE MarshalNative_GetIUnknownForObject(QCall::ObjectHandleOnStack o, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetIUnknownForObject(QCall::ObjectHandleOnStack o, IUnknown** pReturnValue); //==================================================================== // return the IDispatch* for an Object //==================================================================== -extern "C" IDispatch* QCALLTYPE MarshalNative_GetIDispatchForObject(QCall::ObjectHandleOnStack o, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetIDispatchForObject(QCall::ObjectHandleOnStack o, IDispatch** pReturnValue); //==================================================================== // return the IUnknown* or IDispatch* for an Object. //==================================================================== -extern "C" void* QCALLTYPE MarshalNative_GetIUnknownOrIDispatchForObject(QCall::ObjectHandleOnStack o, BOOL* isIDispatch, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetIUnknownOrIDispatchForObject(QCall::ObjectHandleOnStack o, BOOL* isIDispatch, void** pReturnValue); //==================================================================== // return the IUnknown* representing the interface for the Object // Object o should support Type T //==================================================================== -extern "C" IUnknown* QCALLTYPE MarshalNative_GetComInterfaceForObject(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, BOOL bEnableCustomizedQueryInterface, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetComInterfaceForObject(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, BOOL bEnableCustomizedQueryInterface, IUnknown** pReturnValue); //==================================================================== // return an Object for IUnknown //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject); //==================================================================== // return a unique cacheless Object for IUnknown //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetUniqueObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetUniqueObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject); //==================================================================== // return an Object for IUnknown, using the Type T, // NOTE: // Type T should be either a COM imported Type or a sub-type of COM imported Type //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetTypedObjectForIUnknown(IUnknown* pUnk, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetTypedObjectForIUnknown(IUnknown* pUnk, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject); //==================================================================== // Create an object and aggregate it, then return the inner unknown. //==================================================================== -extern "C" IUnknown* QCALLTYPE MarshalNative_CreateAggregatedObject(IUnknown* pOuter, QCall::ObjectHandleOnStack o, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_CreateAggregatedObject(IUnknown* pOuter, QCall::ObjectHandleOnStack o, IUnknown** pReturnValue); //==================================================================== // Free unused RCWs in the current CLR context. //==================================================================== -extern "C" void QCALLTYPE MarshalNative_CleanupUnusedObjectsInCurrentContext(QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_CleanupUnusedObjectsInCurrentContext(); //==================================================================== // free the COM component and zombie this object // further usage of this Object might throw an exception, //==================================================================== -extern "C" INT32 QCALLTYPE MarshalNative_ReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE MarshalNative_FinalReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_ReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, INT32* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_FinalReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE); //==================================================================== // This method takes the given COM object and wraps it in an object // of the specified type. The type must be derived from __ComObject. //==================================================================== -extern "C" void QCALLTYPE MarshalNative_InternalCreateWrapperOfType(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_InternalCreateWrapperOfType(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject); //==================================================================== // check if the type is visible from COM. //==================================================================== -extern "C" BOOL QCALLTYPE MarshalNative_IsTypeVisibleFromCom(QCall::TypeHandle t, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_IsTypeVisibleFromCom(QCall::TypeHandle t, BOOL* pReturnValue); //==================================================================== // These methods convert OLE variants to and from objects. //==================================================================== -extern "C" void QCALLTYPE MarshalNative_GetNativeVariantForObject(QCall::ObjectHandleOnStack ObjUNSAFE, LPVOID pDestNativeVariant, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE MarshalNative_GetObjectForNativeVariant(LPVOID pSrcNativeVariant, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE MarshalNative_GetObjectsForNativeVariants(VARIANT* aSrcNativeVariant, int cVars, QCall::ObjectHandleOnStack retArray, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetNativeVariantForObject(QCall::ObjectHandleOnStack ObjUNSAFE, LPVOID pDestNativeVariant); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetObjectForNativeVariant(LPVOID pSrcNativeVariant, QCall::ObjectHandleOnStack retObject); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetObjectsForNativeVariants(VARIANT* aSrcNativeVariant, int cVars, QCall::ObjectHandleOnStack retArray); //==================================================================== // These methods are used to map COM slots to method info's. //==================================================================== -extern "C" INT32 QCALLTYPE MarshalNative_GetStartComSlot(QCall::TypeHandle t, QCallExceptionStatus* qcallError); -extern "C" INT32 QCALLTYPE MarshalNative_GetEndComSlot(QCall::TypeHandle t, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetStartComSlot(QCall::TypeHandle t, INT32* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetEndComSlot(QCall::TypeHandle t, INT32* pReturnValue); -extern "C" VOID QCALLTYPE MarshalNative_ChangeWrapperHandleStrength(QCall::ObjectHandleOnStack otp, BOOL fIsWeak, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_ChangeWrapperHandleStrength(QCall::ObjectHandleOnStack otp, BOOL fIsWeak); #endif // FEATURE_COMINTEROP #endif diff --git a/src/coreclr/vm/method.hpp b/src/coreclr/vm/method.hpp index ec09d57be93bdf..1ec6a13e484e94 100644 --- a/src/coreclr/vm/method.hpp +++ b/src/coreclr/vm/method.hpp @@ -2399,7 +2399,7 @@ class MethodDesc }; #ifndef DACCESS_COMPILE -extern "C" void* QCALLTYPE UnsafeAccessors_ResolveGenericParamToTypeHandle(MethodDesc* unsafeAccessorMethod, BOOL isMethodParam, DWORD paramIndex, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE UnsafeAccessors_ResolveGenericParamToTypeHandle(MethodDesc* unsafeAccessorMethod, BOOL isMethodParam, DWORD paramIndex, void** pReturnValue); #endif // DACCESS_COMPILE template<> struct cdac_data diff --git a/src/coreclr/vm/mlinfo.cpp b/src/coreclr/vm/mlinfo.cpp index 0a41c849467ef4..d029c0c2f634ba 100644 --- a/src/coreclr/vm/mlinfo.cpp +++ b/src/coreclr/vm/mlinfo.cpp @@ -3579,7 +3579,7 @@ bool IsUnsupportedTypedrefReturn(MetaSig& msig) #include "stubhelpers.h" -extern "C" void QCALLTYPE StubHelpers_CreateCustomMarshaler(MethodDesc* pMD, mdToken paramToken, TypeHandle hndManagedType, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_CreateCustomMarshaler(MethodDesc* pMD, mdToken paramToken, TypeHandle hndManagedType, QCall::ObjectHandleOnStack retObject) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/multicorejit.cpp b/src/coreclr/vm/multicorejit.cpp index 3196553ba423fe..3c7b47fb3be10f 100644 --- a/src/coreclr/vm/multicorejit.cpp +++ b/src/coreclr/vm/multicorejit.cpp @@ -1546,7 +1546,7 @@ DWORD MulticoreJitManager::EncodeModuleHelper(void * pModuleContext, Module * pR // wszProfile - profile name // ptrNativeAssemblyBinder - the binding context // -extern "C" void QCALLTYPE MultiCoreJIT_InternalStartProfile(_In_z_ LPCWSTR wszProfile, INT_PTR ptrNativeAssemblyBinder, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MultiCoreJIT_InternalStartProfile(_In_z_ LPCWSTR wszProfile, INT_PTR ptrNativeAssemblyBinder) { QCALL_CONTRACT; @@ -1565,7 +1565,7 @@ extern "C" void QCALLTYPE MultiCoreJIT_InternalStartProfile(_In_z_ LPCWSTR wszPr } -extern "C" void QCALLTYPE MultiCoreJIT_InternalSetProfileRoot(_In_z_ LPCWSTR wszProfilePath, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MultiCoreJIT_InternalSetProfileRoot(_In_z_ LPCWSTR wszProfilePath) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/multicorejit.h b/src/coreclr/vm/multicorejit.h index 5577d1c77e3c11..3489fec61be51a 100644 --- a/src/coreclr/vm/multicorejit.h +++ b/src/coreclr/vm/multicorejit.h @@ -315,7 +315,7 @@ class MulticoreJitManager // For qcallentrypoints.cpp -extern "C" void QCALLTYPE MultiCoreJIT_InternalSetProfileRoot(_In_z_ LPCWSTR directoryPath, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE MultiCoreJIT_InternalStartProfile(_In_z_ LPCWSTR wszProfile, INT_PTR ptrNativeAssemblyBinder, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MultiCoreJIT_InternalSetProfileRoot(_In_z_ LPCWSTR directoryPath); +extern "C" QCallExceptionStatus QCALLTYPE MultiCoreJIT_InternalStartProfile(_In_z_ LPCWSTR wszProfile, INT_PTR ptrNativeAssemblyBinder); #endif // __MULTICORE_JIT_H__ diff --git a/src/coreclr/vm/nativeeventsource.cpp b/src/coreclr/vm/nativeeventsource.cpp index f267b25ed95e7b..2c349daad79ad4 100644 --- a/src/coreclr/vm/nativeeventsource.cpp +++ b/src/coreclr/vm/nativeeventsource.cpp @@ -13,7 +13,7 @@ #if defined(FEATURE_EVENTSOURCE_XPLAT) -extern "C" void QCALLTYPE LogEventSource(_In_z_ int eventID, _In_z_ LPCWSTR eventName, _In_z_ LPCWSTR eventSourceName, _In_z_ LPCWSTR payload, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE LogEventSource(_In_z_ int eventID, _In_z_ LPCWSTR eventName, _In_z_ LPCWSTR eventSourceName, _In_z_ LPCWSTR payload) { QCALL_CONTRACT; BEGIN_QCALL; @@ -21,7 +21,7 @@ extern "C" void QCALLTYPE LogEventSource(_In_z_ int eventID, _In_z_ LPCWSTR even END_QCALL; } -extern "C" BOOL QCALLTYPE IsEventSourceLoggingEnabled(QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE IsEventSourceLoggingEnabled(BOOL* pReturnValue) { QCALL_CONTRACT; @@ -29,12 +29,12 @@ extern "C" BOOL QCALLTYPE IsEventSourceLoggingEnabled(QCallExceptionStatus* qcal BEGIN_QCALL; retVal = XplatEventLogger::IsEventLoggingEnabled(); - END_QCALL; + *pReturnValue = retVal; - return retVal; + END_QCALL; } -extern "C" LPWSTR QCALLTYPE EventSource_GetClrConfig(LPCWSTR configName, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE EventSource_GetClrConfig(LPCWSTR configName, LPWSTR* pReturnValue) { QCALL_CONTRACT; @@ -45,9 +45,9 @@ extern "C" LPWSTR QCALLTYPE EventSource_GetClrConfig(LPCWSTR configName, QCallEx info.name = configName; info.options = CLRConfig::LookupOptions::Default; ret = CLRConfig::GetConfigValue(info); - END_QCALL; + *pReturnValue = ret; - return ret; + END_QCALL; } #endif //defined(FEATURE_EVENTSOURCE_XPLAT) @@ -60,7 +60,7 @@ extern "C" LPWSTR QCALLTYPE EventSource_GetClrConfig(LPCWSTR configName, QCallEx // change genRuntimeEventSources.py script to not emit the body that throws NotImplementedException for the event that // want to be fired from managed code. // See https://github.com/dotnet/runtime/pull/47829 for an example of how to do this. -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStart(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStart(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID) { QCALL_CONTRACT; BEGIN_QCALL; @@ -70,7 +70,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStar END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID) { QCALL_CONTRACT; BEGIN_QCALL; @@ -80,7 +80,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID) { QCALL_CONTRACT; BEGIN_QCALL; @@ -90,7 +90,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolMinMaxThreads(_In_z_ short minWorkerThreads, _In_z_ short maxWorkerThreads, _In_z_ short minIOCompletionThreads, _In_z_ short maxIOCompletionThreads, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolMinMaxThreads(_In_z_ short minWorkerThreads, _In_z_ short maxWorkerThreads, _In_z_ short minIOCompletionThreads, _In_z_ short maxIOCompletionThreads, _In_z_ short clrInstanceID) { QCALL_CONTRACT; BEGIN_QCALL; @@ -100,7 +100,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolMinMaxThreads(_I END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentSample(_In_z_ double throughput, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentSample(_In_z_ double throughput, _In_z_ short clrInstanceID) { QCALL_CONTRACT; BEGIN_QCALL; @@ -110,7 +110,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdju END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentAdjustment(_In_z_ double averageThroughput, _In_z_ uint newWorkerThreadCount, _In_z_ uint reason, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentAdjustment(_In_z_ double averageThroughput, _In_z_ uint newWorkerThreadCount, _In_z_ uint reason, _In_z_ short clrInstanceID) { QCALL_CONTRACT; BEGIN_QCALL; @@ -120,7 +120,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdju END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentStats(_In_z_ double duration, _In_z_ double throughput, _In_z_ double threadWave, _In_z_ double throughputWave, _In_z_ double throughputErrorEstimate, _In_z_ double AverageThroughputErrorEstimate, _In_z_ double ThroughputRatio, _In_z_ double confidence, _In_z_ double newControlSetting, _In_z_ short newThreadWaveMagnitude, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentStats(_In_z_ double duration, _In_z_ double throughput, _In_z_ double threadWave, _In_z_ double throughputWave, _In_z_ double throughputErrorEstimate, _In_z_ double AverageThroughputErrorEstimate, _In_z_ double ThroughputRatio, _In_z_ double confidence, _In_z_ double newControlSetting, _In_z_ short newThreadWaveMagnitude, _In_z_ short ClrInstanceID) { QCALL_CONTRACT; BEGIN_QCALL; @@ -130,7 +130,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdju END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOEnqueue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ BOOL multiDequeues, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOEnqueue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ BOOL multiDequeues, _In_z_ short ClrInstanceID) { QCALL_CONTRACT; BEGIN_QCALL; @@ -140,7 +140,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOEnqueue(_In_z_ END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIODequeue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIODequeue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID) { QCALL_CONTRACT; BEGIN_QCALL; @@ -150,7 +150,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIODequeue(_In_z_ END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkingThreadCount(_In_z_ uint count, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkingThreadCount(_In_z_ uint count, _In_z_ short ClrInstanceID) { QCALL_CONTRACT; BEGIN_QCALL; @@ -160,7 +160,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkingThreadCou END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOPack(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOPack(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID) { QCALL_CONTRACT; BEGIN_QCALL; @@ -170,7 +170,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOPack(_In_z_ vo END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionLockCreated(void* LockID, void* AssociatedObjectID, uint16_t ClrInstanceID, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogContentionLockCreated(void* LockID, void* AssociatedObjectID, uint16_t ClrInstanceID) { QCALL_CONTRACT; BEGIN_QCALL; @@ -180,13 +180,12 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionLockCreated(void END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStart( +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogContentionStart( uint8_t ContentionFlags, uint16_t ClrInstanceID, void* LockID, void* AssociatedObjectID, - uint64_t LockOwnerThreadID, - QCallExceptionStatus* qcallError) + uint64_t LockOwnerThreadID) { QCALL_CONTRACT; BEGIN_QCALL; @@ -196,7 +195,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStart( END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStop(uint8_t ContentionFlags, uint16_t ClrInstanceID, double DurationNs, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogContentionStop(uint8_t ContentionFlags, uint16_t ClrInstanceID, double DurationNs) { QCALL_CONTRACT; BEGIN_QCALL; @@ -206,7 +205,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStop(uint8_t Con END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStart(uint8_t WaitSource, intptr_t AssociatedObjectID, uint16_t ClrInstanceID, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStart(uint8_t WaitSource, intptr_t AssociatedObjectID, uint16_t ClrInstanceID) { QCALL_CONTRACT; BEGIN_QCALL; @@ -216,7 +215,7 @@ extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStart(uint8_ END_QCALL; } -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStop(uint16_t ClrInstanceID, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStop(uint16_t ClrInstanceID) { QCALL_CONTRACT; BEGIN_QCALL; diff --git a/src/coreclr/vm/nativeeventsource.h b/src/coreclr/vm/nativeeventsource.h index 66785fc054a55c..64d78273314592 100644 --- a/src/coreclr/vm/nativeeventsource.h +++ b/src/coreclr/vm/nativeeventsource.h @@ -15,28 +15,28 @@ #include "qcall.h" #if defined(FEATURE_EVENTSOURCE_XPLAT) -extern "C" void QCALLTYPE LogEventSource(_In_z_ int eventID, _In_z_ LPCWSTR eventName, _In_z_ LPCWSTR eventSourceName, _In_z_ LPCWSTR payload, QCallExceptionStatus* qcallError); -extern "C" BOOL QCALLTYPE IsEventSourceLoggingEnabled(QCallExceptionStatus* qcallError); -extern "C" LPWSTR QCALLTYPE EventSource_GetClrConfig(LPCWSTR configName, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE LogEventSource(_In_z_ int eventID, _In_z_ LPCWSTR eventName, _In_z_ LPCWSTR eventSourceName, _In_z_ LPCWSTR payload); +extern "C" QCallExceptionStatus QCALLTYPE IsEventSourceLoggingEnabled(BOOL* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE EventSource_GetClrConfig(LPCWSTR configName, LPWSTR* pReturnValue); #endif //defined(FEATURE_EVENTSOURCE_XPLAT) #if defined(FEATURE_PERFTRACING) -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStart(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolMinMaxThreads(_In_z_ short minWorkerThreads, _In_z_ short maxWorkerThreads, _In_z_ short minIOCompletionThreads, _In_z_ short maxIOCompletionThreads, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentSample(_In_z_ double throughput, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentAdjustment(_In_z_ double averageThroughput, _In_z_ uint newWorkerThreadCount, _In_z_ uint reason, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentStats(_In_z_ double duration, _In_z_ double throughput, _In_z_ double threadWave, _In_z_ double throughputWave, _In_z_ double throughputErrorEstimate, _In_z_ double AverageThroughputErrorEstimate, _In_z_ double ThroughputRatio, _In_z_ double confidence, _In_z_ double newControlSetting, _In_z_ short newThreadWaveMagnitude, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOEnqueue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ BOOL multiDequeues, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIODequeue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkingThreadCount(_In_z_ uint count, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOPack(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionLockCreated(void* LockID, void* AssociatedObjectID, uint16_t ClrInstanceID, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStart(uint8_t ContentionFlags, uint16_t ClrInstanceID, void* LockID, void* AssociatedObjectID, uint64_t LockOwnerThreadID, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStop(uint8_t ContentionFlags, uint16_t ClrInstanceID, double DurationNs, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStart(uint8_t WaitSource, intptr_t AssociatedObjectID, uint16_t ClrInstanceID, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStop(uint16_t ClrInstanceID, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStart(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID); +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID); +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID); +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolMinMaxThreads(_In_z_ short minWorkerThreads, _In_z_ short maxWorkerThreads, _In_z_ short minIOCompletionThreads, _In_z_ short maxIOCompletionThreads, _In_z_ short clrInstanceID); +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentSample(_In_z_ double throughput, _In_z_ short clrInstanceID); +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentAdjustment(_In_z_ double averageThroughput, _In_z_ uint newWorkerThreadCount, _In_z_ uint reason, _In_z_ short clrInstanceID); +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentStats(_In_z_ double duration, _In_z_ double throughput, _In_z_ double threadWave, _In_z_ double throughputWave, _In_z_ double throughputErrorEstimate, _In_z_ double AverageThroughputErrorEstimate, _In_z_ double ThroughputRatio, _In_z_ double confidence, _In_z_ double newControlSetting, _In_z_ short newThreadWaveMagnitude, _In_z_ short ClrInstanceID); +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOEnqueue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ BOOL multiDequeues, _In_z_ short ClrInstanceID); +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIODequeue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID); +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkingThreadCount(_In_z_ uint count, _In_z_ short ClrInstanceID); +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOPack(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID); +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogContentionLockCreated(void* LockID, void* AssociatedObjectID, uint16_t ClrInstanceID); +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogContentionStart(uint8_t ContentionFlags, uint16_t ClrInstanceID, void* LockID, void* AssociatedObjectID, uint64_t LockOwnerThreadID); +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogContentionStop(uint8_t ContentionFlags, uint16_t ClrInstanceID, double DurationNs); +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStart(uint8_t WaitSource, intptr_t AssociatedObjectID, uint16_t ClrInstanceID); +extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStop(uint16_t ClrInstanceID); #endif // defined(FEATURE_PERFTRACING) diff --git a/src/coreclr/vm/nativelibrarynative.cpp b/src/coreclr/vm/nativelibrarynative.cpp index 713ae1b62ec097..0ad7ed07839b98 100644 --- a/src/coreclr/vm/nativelibrarynative.cpp +++ b/src/coreclr/vm/nativelibrarynative.cpp @@ -9,10 +9,9 @@ #include "nativelibrarynative.h" // static -extern "C" INT_PTR QCALLTYPE NativeLibrary_LoadByName(LPCWSTR name, QCall::AssemblyHandle callingAssembly, +extern "C" QCallExceptionStatus QCALLTYPE NativeLibrary_LoadByName(LPCWSTR name, QCall::AssemblyHandle callingAssembly, BOOL hasDllImportSearchPathFlag, DWORD dllImportSearchPathFlag, - BOOL throwOnError, - QCallExceptionStatus* qcallError) + BOOL throwOnError, INT_PTR* pReturnValue) { QCALL_CONTRACT; @@ -22,7 +21,7 @@ extern "C" INT_PTR QCALLTYPE NativeLibrary_LoadByName(LPCWSTR name, QCall::Assem handle = NativeLibrary::LoadLibraryByName(name, callingAssembly, hasDllImportSearchPathFlag, dllImportSearchPathFlag, throwOnError); - END_QCALL; + *pReturnValue = reinterpret_cast(handle); - return reinterpret_cast(handle); + END_QCALL; } diff --git a/src/coreclr/vm/nativelibrarynative.h b/src/coreclr/vm/nativelibrarynative.h index a30217d657e30b..2b71a7267d4efd 100644 --- a/src/coreclr/vm/nativelibrarynative.h +++ b/src/coreclr/vm/nativelibrarynative.h @@ -10,9 +10,8 @@ #ifndef __NATIVELIBRARYNATIVE_H__ #define __NATIVELIBRARYNATIVE_H__ -extern "C" INT_PTR QCALLTYPE NativeLibrary_LoadByName(LPCWSTR name, QCall::AssemblyHandle callingAssembly, +extern "C" QCallExceptionStatus QCALLTYPE NativeLibrary_LoadByName(LPCWSTR name, QCall::AssemblyHandle callingAssembly, BOOL hasDllImportSearchPathFlag, DWORD dllImportSearchPathFlag, - BOOL throwOnError, - QCallExceptionStatus* qcallError); + BOOL throwOnError, INT_PTR* pReturnValue); #endif // __NATIVELIBRARYNATIVE_H__ diff --git a/src/coreclr/vm/olevariant.cpp b/src/coreclr/vm/olevariant.cpp index 270d982f1e0d4d..0c4aa2735e5103 100644 --- a/src/coreclr/vm/olevariant.cpp +++ b/src/coreclr/vm/olevariant.cpp @@ -2662,7 +2662,7 @@ BSTR OleVariant::ConvertStringToBSTR(STRINGREF *pStringObj) return result; } -extern "C" void QCALLTYPE Variant_ConvertValueTypeToRecord(QCall::ObjectHandleOnStack obj, VARIANT * pOle, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE Variant_ConvertValueTypeToRecord(QCall::ObjectHandleOnStack obj, VARIANT * pOle) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/olevariant.h b/src/coreclr/vm/olevariant.h index ba83ded23c7941..2c7650c5032ee6 100644 --- a/src/coreclr/vm/olevariant.h +++ b/src/coreclr/vm/olevariant.h @@ -107,6 +107,6 @@ class OleVariant // SAFEARRAY VARTYPE and element MethodTable. MethodDesc* GetInstantiatedSafeArrayMethod(BinderMethodID methodId, VARTYPE vt, MethodTable* pElementMT, BOOL bHeterogeneous, BOOL bNativeDataValid = FALSE); -extern "C" void QCALLTYPE Variant_ConvertValueTypeToRecord(QCall::ObjectHandleOnStack obj, VARIANT* pOle, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE Variant_ConvertValueTypeToRecord(QCall::ObjectHandleOnStack obj, VARIANT* pOle); #endif diff --git a/src/coreclr/vm/qcall.cpp b/src/coreclr/vm/qcall.cpp index e1b25f061ea37c..2a1a4292a96084 100644 --- a/src/coreclr/vm/qcall.cpp +++ b/src/coreclr/vm/qcall.cpp @@ -6,18 +6,45 @@ #include "common.h" -#include "threadstatics.h" -void QCallExceptionStatus::SetThrowable(OBJECTREF throwable) +void SetQCallExceptionStatusThrowable(QCallExceptionStatus* pStatus, OBJECTREF throwable) { - LIMITED_METHOD_CONTRACT; + CONTRACTL + { + NOTHROW; + GC_NOTRIGGER; + MODE_COOPERATIVE; + } + CONTRACTL_END; _ASSERTE(throwable != NULL); - _ASSERTE(m_exceptionPending == 0); - - _ASSERTE(t_ThreadStatics.pQCallException == NULL); - t_ThreadStatics.pQCallException = OBJECTREFToObject(throwable); - VolatileStore(&m_exceptionPending, 1); + _ASSERTE(*pStatus == 0); + + MethodTable* exceptionType = throwable->GetMethodTable(); + if (exceptionType == g_pOutOfMemoryExceptionClass) + { + *pStatus = QCallOutOfMemoryException; + return; + } + + if (exceptionType == g_pStackOverflowExceptionClass) + { + *pStatus = QCallStackOverflowException; + return; + } + + OBJECTHANDLE exceptionHandle = GetAppDomain()->GetHandleStore()->CreateHandleOfType( + OBJECTREFToObject(throwable), + HNDTYPE_DEFAULT); + if (exceptionHandle == NULL) + { + *pStatus = QCallOutOfMemoryException; + return; + } + + DiagHandleCreated(exceptionHandle, throwable); + _ASSERTE(reinterpret_cast(exceptionHandle) > QCallStackOverflowException); + *pStatus = reinterpret_cast(exceptionHandle); } // diff --git a/src/coreclr/vm/qcall.h b/src/coreclr/vm/qcall.h index a8193f823eaf67..af8b79385e6b42 100644 --- a/src/coreclr/vm/qcall.h +++ b/src/coreclr/vm/qcall.h @@ -39,9 +39,10 @@ // class Foo // { // -// // All QCalls that use BEGIN_QCALL must have a final QCallExceptionStatus out parameter. +// // All QCalls that use BEGIN_QCALL must use the hidden return value error handler. +// [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] // [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "FooNative_Bar", StringMarshalling = StringMarshalling.Utf16)] -// private static partial bool Bar(int flags, string inString, StringHandleOnStack retString, out QCallExceptionStatus qcallException); +// private static partial bool Bar(int flags, string inString, StringHandleOnStack retString); // // // Many QCalls have a thin managed wrapper around them to expose them to the world in more meaningful way. // public string Bar(int flags) @@ -50,7 +51,7 @@ // // // The strings are returned from QCalls by taking address // // of a local variable using JitHelpers.GetStringHandleOnStack method -// if (!Bar(flags, this.Id, StringHandleOnStack.Create(ref retString), out _)) +// if (!Bar(flags, this.Id, StringHandleOnStack.Create(ref retString))) // FatalError(); // // return retString; @@ -65,7 +66,8 @@ // The entrypoints of all QCalls has to be registered in tables in vm\qcallentrypoints.cpp using the DllImportEntry macro, // For example: DllImportEntry(FooNative_Bar) // -// extern "C" BOOL QCALLTYPE FooNative_Bar(int flags, LPCWSTR wszString, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) +// extern "C" QCallExceptionStatus QCALLTYPE FooNative_Bar( +// int flags, LPCWSTR wszString, QCall::StringHandleOnStack retString, BOOL* pReturnValue) // { // // All QCalls should have QCALL_CONTRACT. It is alias for THROWS; GC_TRIGGERS; MODE_PREEMPTIVE. // QCALL_CONTRACT; @@ -76,10 +78,6 @@ // // PRECONDITION(wszString != NULL); // // } CONTRACTL_END; // -// // The only line between QCALL_CONTRACT and BEGIN_QCALL -// // should be the return value declaration if there is one. -// BOOL retVal = FALSE; -// // // The body has to be enclosed in BEGIN_QCALL/END_QCALL macro. It is necessary to make the exception handling work. // BEGIN_QCALL; // @@ -95,11 +93,9 @@ // retString.Set(L"Hello"); // // // You can not return from inside of BEGIN_QCALL/END_QCALL. The return value has to be passed out in helper variable. -// retVal = TRUE; +// *pReturnValue = TRUE; // // END_QCALL; -// -// return retVal; // } @@ -110,13 +106,15 @@ #endif // !TARGET_UNIX #define BEGIN_QCALL \ - qcallError->SetNoException(); \ + QCallExceptionStatus qcallExceptionStatus = 0; \ + QCallExceptionStatus* qcallError = &qcallExceptionStatus; \ INSTALL_RESUME_AFTER_CATCH_HANDLER_WITH_FRAME(GetThread()->GetFrame()) \ INSTALL_MANAGED_EXCEPTION_CAPTURE_DISPATCHER #define END_QCALL \ UNINSTALL_MANAGED_EXCEPTION_CAPTURE_DISPATCHER \ - UNINSTALL_RESUME_AFTER_CATCH_HANDLER_WITH_FRAME + UNINSTALL_RESUME_AFTER_CATCH_HANDLER_WITH_FRAME \ + return qcallExceptionStatus #define QCALL_CHECK \ THROWS; \ diff --git a/src/coreclr/vm/qcallentrypoints.cpp b/src/coreclr/vm/qcallentrypoints.cpp index 0e9fd51fbbdd30..79c1961da98fb1 100644 --- a/src/coreclr/vm/qcallentrypoints.cpp +++ b/src/coreclr/vm/qcallentrypoints.cpp @@ -297,6 +297,7 @@ static const Entry s_QCall[] = DllImportEntry(AppDomain_CreateDynamicAssembly) DllImportEntry(AppContext_SetFirstChanceExceptionHandler) DllImportEntry(AppContext_TryGetHostPropertyValue) + DllImportEntry(ThreadNative_GetQCallSpecialException) DllImportEntry(ThreadNative_Start) DllImportEntry(ThreadNative_SetPriority) DllImportEntry(ThreadNative_GetCurrentThread) diff --git a/src/coreclr/vm/reflectioninvocation.cpp b/src/coreclr/vm/reflectioninvocation.cpp index 9889f958cd5242..e0014cb2079014 100644 --- a/src/coreclr/vm/reflectioninvocation.cpp +++ b/src/coreclr/vm/reflectioninvocation.cpp @@ -27,7 +27,7 @@ #include "interpexec.h" -extern "C" void QCALLTYPE RuntimeFieldHandle_GetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized, QCall::ObjectHandleOnStack result) { QCALL_CONTRACT; @@ -45,7 +45,7 @@ extern "C" void QCALLTYPE RuntimeFieldHandle_GetValue(FieldDesc* fieldDesc, QCal END_QCALL; } -extern "C" void QCALLTYPE RuntimeFieldHandle_SetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::ObjectHandleOnStack value, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_SetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::ObjectHandleOnStack value, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized) { QCALL_CONTRACT; @@ -69,13 +69,11 @@ extern "C" void QCALLTYPE RuntimeFieldHandle_SetValue(FieldDesc* fieldDesc, QCal END_QCALL; } -extern "C" void QCALLTYPE RuntimeTypeHandle_CreateInstanceForAnotherGenericParameter( +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_CreateInstanceForAnotherGenericParameter( QCall::TypeHandle pTypeHandle, TypeHandle* pInstArray, INT32 cInstArray, - QCall::ObjectHandleOnStack pInstantiatedObject, - QCallExceptionStatus* qcallError -) + QCall::ObjectHandleOnStack pInstantiatedObject) { CONTRACTL { @@ -119,7 +117,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_CreateInstanceForAnotherGenericParam END_QCALL; } -extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAlloc(MethodTable* pMT, QCall::ObjectHandleOnStack allocated, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_InternalAlloc(MethodTable* pMT, QCall::ObjectHandleOnStack allocated) { QCALL_CONTRACT; @@ -134,7 +132,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAlloc(MethodTable* pMT, QCal END_QCALL; } -extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAllocNoChecks(MethodTable* pMT, QCall::ObjectHandleOnStack allocated, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_InternalAllocNoChecks(MethodTable* pMT, QCall::ObjectHandleOnStack allocated) { QCALL_CONTRACT; @@ -325,13 +323,12 @@ class ArgIteratorForMethodInvoke : public ArgIteratorTemplateLoadTypicalMethodDefinition(); - END_QCALL; + *pReturnValue = pRet; - return pRet; + END_QCALL; } static OBJECTREF DirectObjectFieldGet(FieldDesc *pField, TypeHandle fieldType, TypeHandle enclosingType, TypedByRef *pTarget) @@ -844,7 +841,7 @@ static OBJECTREF DirectObjectFieldGet(FieldDesc *pField, TypeHandle fieldType, T return refRet; } -extern "C" void QCALLTYPE RuntimeFieldHandle_GetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack result) { QCALL_CONTRACT; @@ -949,7 +946,7 @@ static void DirectObjectFieldSet(FieldDesc *pField, TypeHandle fieldType, TypeHa GCPROTECT_END(); } -extern "C" void QCALLTYPE RuntimeFieldHandle_SetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::ObjectHandleOnStack newValue, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringType, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_SetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::ObjectHandleOnStack newValue, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringType) { QCALL_CONTRACT; @@ -1193,7 +1190,7 @@ FCIMPLEND // Returns the address of the EnC instance field in the object (This is an interior // pointer and the caller has to use it appropriately) or an EnC static field. -extern "C" void* QCALLTYPE RuntimeFieldHandle_GetEnCFieldAddr(QCall::ObjectHandleOnStack target, FieldDesc* pFD, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetEnCFieldAddr(QCall::ObjectHandleOnStack target, FieldDesc* pFD, void** pReturnValue) { CONTRACTL { @@ -1215,12 +1212,12 @@ extern "C" void* QCALLTYPE RuntimeFieldHandle_GetEnCFieldAddr(QCall::ObjectHandl if (pFD->IsStatic() || target.Get() != NULL) ret = pFD->GetAddress(OBJECTREFToObject(target.Get())); - END_QCALL; + *pReturnValue = ret; - return ret; + END_QCALL; } -extern "C" BOOL QCALLTYPE RuntimeFieldHandle_GetRVAFieldInfo(FieldDesc* pField, void** address, UINT* size, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetRVAFieldInfo(FieldDesc* pField, void** address, UINT* size, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -1235,12 +1232,12 @@ extern "C" BOOL QCALLTYPE RuntimeFieldHandle_GetRVAFieldInfo(FieldDesc* pField, ret = TRUE; } - END_QCALL; + *pReturnValue = ret; - return ret; + END_QCALL; } -extern "C" void QCALLTYPE RuntimeFieldHandle_GetFieldDataReference(FieldDesc* pField, QCall::ObjectHandleOnStack instance, QCall::ByteRefOnStack fieldDataRef, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetFieldDataReference(FieldDesc* pField, QCall::ObjectHandleOnStack instance, QCall::ByteRefOnStack fieldDataRef) { CONTRACTL { @@ -1259,7 +1256,7 @@ extern "C" void QCALLTYPE RuntimeFieldHandle_GetFieldDataReference(FieldDesc* pF END_QCALL; } -extern "C" void QCALLTYPE ReflectionInvocation_CompileMethod(MethodDesc * pMD, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_CompileMethod(MethodDesc * pMD) { QCALL_CONTRACT; @@ -1268,8 +1265,7 @@ extern "C" void QCALLTYPE ReflectionInvocation_CompileMethod(MethodDesc * pMD, Q if (!pMD->ShouldCallPrestub()) { - qcallError->SetNoException(); - return; + return QCallExceptionStatus(); } BEGIN_QCALL; @@ -1278,23 +1274,21 @@ extern "C" void QCALLTYPE ReflectionInvocation_CompileMethod(MethodDesc * pMD, Q } // This method triggers the class constructor for a give type -extern "C" void QCALLTYPE ReflectionInvocation_RunClassConstructor(QCall::TypeHandle pType, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_RunClassConstructor(QCall::TypeHandle pType) { QCALL_CONTRACT; TypeHandle typeHnd = pType.AsTypeHandle(); if (typeHnd.IsTypeDesc()) { - qcallError->SetNoException(); - return; + return QCallExceptionStatus(); } MethodTable *pMT = typeHnd.AsMethodTable(); // The ContainsGenericVariables check is to preserve back-compat where we assume the generic type is already initialized if (pMT->IsClassInited() || pMT->ContainsGenericVariables()) { - qcallError->SetNoException(); - return; + return QCallExceptionStatus(); } BEGIN_QCALL; @@ -1305,15 +1299,14 @@ extern "C" void QCALLTYPE ReflectionInvocation_RunClassConstructor(QCall::TypeHa } // This method triggers the module constructor for a given module -extern "C" void QCALLTYPE ReflectionInvocation_RunModuleConstructor(QCall::ModuleHandle pModule, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_RunModuleConstructor(QCall::ModuleHandle pModule) { QCALL_CONTRACT; Assembly *pAssembly = pModule->GetAssembly(); if (pAssembly != NULL && pAssembly->IsActive()) { - qcallError->SetNoException(); - return; + return QCallExceptionStatus(); } BEGIN_QCALL; @@ -1354,7 +1347,7 @@ static void PrepareMethodHelper(MethodDesc * pMD) // This method triggers a given method to be jitted. CoreCLR implementation of this method triggers jiting of the given method only. // It does not walk a subset of callgraph to provide CER guarantees. -extern "C" void QCALLTYPE ReflectionInvocation_PrepareMethod(MethodDesc *pMD, TypeHandle *pInstantiation, UINT32 cInstantiation, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_PrepareMethod(MethodDesc *pMD, TypeHandle *pInstantiation, UINT32 cInstantiation) { CONTRACTL { @@ -1407,7 +1400,7 @@ extern "C" void QCALLTYPE ReflectionInvocation_PrepareMethod(MethodDesc *pMD, Ty // This method triggers target of a given method to be jitted. // In the case of a multi-cast delegate, we rely on the fact that each individual component // was prepared prior to the Combine. -extern "C" void QCALLTYPE ReflectionInvocation_PrepareDelegate(QCall::ObjectHandleOnStack delegate, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_PrepareDelegate(QCall::ObjectHandleOnStack delegate) { QCALL_CONTRACT; @@ -1460,7 +1453,7 @@ FCIMPL0(FC_BOOL_RET, ReflectionInvocation::TryEnsureSufficientExecutionStack) FCIMPLEND #ifdef FEATURE_COMINTEROP -extern "C" void QCALLTYPE ReflectionInvocation_InvokeDispMethod( +extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_InvokeDispMethod( QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack name, INT32 invokeAttr, @@ -1469,8 +1462,7 @@ extern "C" void QCALLTYPE ReflectionInvocation_InvokeDispMethod( QCall::ObjectHandleOnStack byrefModifiers, LCID lcid, QCall::ObjectHandleOnStack namedParameters, - QCall::ObjectHandleOnStack result, - QCallExceptionStatus* qcallError) + QCall::ObjectHandleOnStack result) { QCALL_CONTRACT; @@ -1531,7 +1523,7 @@ extern "C" void QCALLTYPE ReflectionInvocation_InvokeDispMethod( END_QCALL; } -extern "C" void QCALLTYPE ReflectionInvocation_GetComObjectGuid(QCall::ObjectHandleOnStack type, GUID* result, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_GetComObjectGuid(QCall::ObjectHandleOnStack type, GUID* result) { CONTRACTL { @@ -1564,7 +1556,7 @@ extern "C" void QCALLTYPE ReflectionInvocation_GetComObjectGuid(QCall::ObjectHan } #endif // FEATURE_COMINTEROP -extern "C" void QCALLTYPE ReflectionInvocation_GetGuid(MethodTable* pMT, GUID* result, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_GetGuid(MethodTable* pMT, GUID* result) { CONTRACTL { @@ -1670,15 +1662,13 @@ static void ValidateTypeAbleToBeInstantiated( * This method will not run the type's static cctor. * This method will not allocate an instance of the target type. */ -extern "C" void QCALLTYPE RuntimeTypeHandle_GetActivationInfo( +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetActivationInfo( QCall::ObjectHandleOnStack pRuntimeType, PCODE* ppfnAllocator, void** pvAllocatorFirstArg, PCODE* ppfnRefCtor, PCODE* ppfnValueCtor, - BOOL* pfCtorIsPublic, - QCallExceptionStatus* qcallError -) + BOOL* pfCtorIsPublic) { CONTRACTL { @@ -1814,7 +1804,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_GetActivationInfo( * Given a ComClassFactory*, calls the COM allocator * and returns a RCW. */ -extern "C" void QCALLTYPE RuntimeTypeHandle_AllocateComObject(void* pClassFactory, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_AllocateComObject(void* pClassFactory, QCall::ObjectHandleOnStack result) { QCALL_CONTRACT; @@ -1843,11 +1833,10 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_AllocateComObject(void* pClassFactor //************************************************************************************************* //************************************************************************************************* //************************************************************************************************* -extern "C" void QCALLTYPE ReflectionSerialization_GetCreateUninitializedObjectInfo( +extern "C" QCallExceptionStatus QCALLTYPE ReflectionSerialization_GetCreateUninitializedObjectInfo( QCall::TypeHandle pType, PCODE* ppfnAllocator, - void** pvAllocatorFirstArg, - QCallExceptionStatus* qcallError) + void** pvAllocatorFirstArg) { CONTRACTL { @@ -1899,7 +1888,7 @@ struct TempEnumValue UINT64 value; }; -extern "C" void QCALLTYPE Enum_GetValuesAndNames(QCall::TypeHandle pEnumType, QCall::ObjectHandleOnStack pReturnValues, QCall::ObjectHandleOnStack pReturnNames, BOOL fGetNames, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE Enum_GetValuesAndNames(QCall::TypeHandle pEnumType, QCall::ObjectHandleOnStack pReturnValues, QCall::ObjectHandleOnStack pReturnNames, BOOL fGetNames) { QCALL_CONTRACT; @@ -2016,13 +2005,12 @@ extern "C" int32_t QCALLTYPE ReflectionInvocation_SizeOf(QCall::TypeHandle pType return handle.GetSize(); } -extern "C" void QCALLTYPE ReflectionInvocation_GetBoxInfo( +extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_GetBoxInfo( QCall::TypeHandle pType, PCODE* ppfnAllocator, void** pvAllocatorFirstArg, int32_t* pValueOffset, - uint32_t* pValueSize, - QCallExceptionStatus* qcallError) + uint32_t* pValueSize) { CONTRACTL { diff --git a/src/coreclr/vm/reflectioninvocation.h b/src/coreclr/vm/reflectioninvocation.h index 3d553fab1d1f80..a3e355d991e973 100644 --- a/src/coreclr/vm/reflectioninvocation.h +++ b/src/coreclr/vm/reflectioninvocation.h @@ -48,18 +48,18 @@ class ReflectionInvocation FCDECL0(static FC_BOOL_RET, TryEnsureSufficientExecutionStack); }; -extern "C" void QCALLTYPE ReflectionInvocation_CompileMethod(MethodDesc * pMD, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_CompileMethod(MethodDesc * pMD); -extern "C" void QCALLTYPE ReflectionInvocation_RunClassConstructor(QCall::TypeHandle pType, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_RunClassConstructor(QCall::TypeHandle pType); -extern "C" void QCALLTYPE ReflectionInvocation_RunModuleConstructor(QCall::ModuleHandle pModule, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_RunModuleConstructor(QCall::ModuleHandle pModule); -extern "C" void QCALLTYPE ReflectionInvocation_PrepareMethod(MethodDesc* pMD, TypeHandle *pInstantiation, UINT32 cInstantiation, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_PrepareMethod(MethodDesc* pMD, TypeHandle *pInstantiation, UINT32 cInstantiation); -extern "C" void QCALLTYPE ReflectionInvocation_PrepareDelegate(QCall::ObjectHandleOnStack delegate, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_PrepareDelegate(QCall::ObjectHandleOnStack delegate); #ifdef FEATURE_COMINTEROP -extern "C" void QCALLTYPE ReflectionInvocation_InvokeDispMethod( +extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_InvokeDispMethod( QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack name, INT32 invokeAttr, @@ -68,25 +68,23 @@ extern "C" void QCALLTYPE ReflectionInvocation_InvokeDispMethod( QCall::ObjectHandleOnStack byrefModifiers, LCID lcid, QCall::ObjectHandleOnStack namedParameters, - QCall::ObjectHandleOnStack result, - QCallExceptionStatus* qcallError); + QCall::ObjectHandleOnStack result); -extern "C" void QCALLTYPE ReflectionInvocation_GetComObjectGuid(QCall::ObjectHandleOnStack type, GUID* result, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_GetComObjectGuid(QCall::ObjectHandleOnStack type, GUID* result); #endif // FEATURE_COMINTEROP -extern "C" void QCALLTYPE ReflectionInvocation_GetGuid(MethodTable* pMT, GUID* result, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_GetGuid(MethodTable* pMT, GUID* result); -extern "C" void QCALLTYPE ReflectionSerialization_GetCreateUninitializedObjectInfo(QCall::TypeHandle pType, PCODE* ppfnAllocator, void** pvAllocatorFirstArg, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ReflectionSerialization_GetCreateUninitializedObjectInfo(QCall::TypeHandle pType, PCODE* ppfnAllocator, void** pvAllocatorFirstArg); -extern "C" void QCALLTYPE ReflectionInvocation_GetBoxInfo( +extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_GetBoxInfo( QCall::TypeHandle pType, PCODE* ppfnAllocator, void** pvAllocatorFirstArg, int32_t* pValueOffset, - uint32_t* pValueSize, - QCallExceptionStatus* qcallError); + uint32_t* pValueSize); -extern "C" void QCALLTYPE Enum_GetValuesAndNames(QCall::TypeHandle pEnumType, QCall::ObjectHandleOnStack pReturnValues, QCall::ObjectHandleOnStack pReturnNames, BOOL fGetNames, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE Enum_GetValuesAndNames(QCall::TypeHandle pEnumType, QCall::ObjectHandleOnStack pReturnValues, QCall::ObjectHandleOnStack pReturnNames, BOOL fGetNames); extern "C" int32_t QCALLTYPE ReflectionInvocation_SizeOf(QCall::TypeHandle pType); diff --git a/src/coreclr/vm/runtimehandles.cpp b/src/coreclr/vm/runtimehandles.cpp index e3d7f3b5ce82d2..46281912aa473b 100644 --- a/src/coreclr/vm/runtimehandles.cpp +++ b/src/coreclr/vm/runtimehandles.cpp @@ -33,7 +33,7 @@ #include "finalizerthread.h" #include "pregeneratedstringthunks.h" -extern "C" BOOL QCALLTYPE MdUtf8String_EqualsCaseInsensitive(LPCUTF8 szLhs, LPCUTF8 szRhs, INT32 stringNumBytes, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE MdUtf8String_EqualsCaseInsensitive(LPCUTF8 szLhs, LPCUTF8 szRhs, INT32 stringNumBytes, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -55,9 +55,9 @@ extern "C" BOOL QCALLTYPE MdUtf8String_EqualsCaseInsensitive(LPCUTF8 szLhs, LPCU // We can use SString for simple case insensitive compares fStringsEqual = lhs.EqualsCaseInsensitive(rhs); - END_QCALL; + *pReturnValue = fStringsEqual; - return fStringsEqual; + END_QCALL; } static BOOL CheckCAVisibilityFromDecoratedType(MethodTable* pCAMT, MethodDesc* pCACtor, MethodTable* pDecoratedMT, Module* pDecoratedModule) @@ -94,12 +94,11 @@ static BOOL CheckCAVisibilityFromDecoratedType(MethodTable* pCAMT, MethodDesc* p *AccessCheckOptions::s_pNormalAccessChecks); } -extern "C" BOOL QCALLTYPE RuntimeMethodHandle_IsCAVisibleFromDecoratedType( +extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_IsCAVisibleFromDecoratedType( QCall::TypeHandle targetTypeHandle, MethodDesc * pTargetCtor, QCall::TypeHandle sourceTypeHandle, - QCall::ModuleHandle sourceModuleHandle, - QCallExceptionStatus* qcallError) + QCall::ModuleHandle sourceModuleHandle, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -134,15 +133,14 @@ extern "C" BOOL QCALLTYPE RuntimeMethodHandle_IsCAVisibleFromDecoratedType( } bResult = CheckCAVisibilityFromDecoratedType(targetHandle.AsMethodTable(), pTargetCtor, sourceHandle.AsMethodTable(), sourceModuleHandle); - END_QCALL; + *pReturnValue = bResult; - return bResult; + END_QCALL; } -extern "C" void QCALLTYPE RuntimeTypeHandle_GetRuntimeTypeFromHandleSlow( +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetRuntimeTypeFromHandleSlow( EnregisteredTypeHandle typeHandleRaw, - QCall::ObjectHandleOnStack result, - QCallExceptionStatus* qcallError) + QCall::ObjectHandleOnStack result) { QCALL_CONTRACT; @@ -160,7 +158,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_GetRuntimeTypeFromHandleSlow( } #ifdef FEATURE_TYPEEQUIVALENCE -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsEquivalentTo(QCall::TypeHandle rtType1, QCall::TypeHandle rtType2, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_IsEquivalentTo(QCall::TypeHandle rtType1, QCall::TypeHandle rtType2, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -170,9 +168,9 @@ extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsEquivalentTo(QCall::TypeHandle rtT areEquivalent = rtType1.AsTypeHandle().IsEquivalentTo(rtType2.AsTypeHandle()); - END_QCALL; + *pReturnValue = areEquivalent; - return areEquivalent; + END_QCALL; } #endif // FEATURE_TYPEEQUIVALENCE @@ -234,7 +232,7 @@ FCIMPL1(AssemblyBaseObject*, RuntimeTypeHandle::GetAssemblyIfExists, ReflectClas } FCIMPLEND -extern "C" void QCALLTYPE RuntimeTypeHandle_GetAssemblySlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack assembly, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetAssemblySlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack assembly) { QCALL_CONTRACT; @@ -291,7 +289,7 @@ FCIMPL1(ReflectModuleBaseObject*, RuntimeTypeHandle::GetModuleIfExists, ReflectC } FCIMPLEND -extern "C" void QCALLTYPE RuntimeTypeHandle_GetModuleSlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack module, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetModuleSlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack module) { QCALL_CONTRACT; @@ -364,7 +362,7 @@ FCIMPL1(INT32, RuntimeTypeHandle::GetNumVirtuals, ReflectClassBaseObject* pTypeU } FCIMPLEND -extern "C" INT32 QCALLTYPE RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals(QCall::TypeHandle pTypeHandle, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals(QCall::TypeHandle pTypeHandle, INT32* pReturnValue) { QCALL_CONTRACT; @@ -393,12 +391,12 @@ extern "C" INT32 QCALLTYPE RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals(QCa } } - END_QCALL; + *pReturnValue = numVirtuals; - return numVirtuals; + END_QCALL; } -extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetMethodAt(MethodTable* pMT, INT32 slot, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetMethodAt(MethodTable* pMT, INT32 slot, MethodDesc** pReturnValue) { QCALL_CONTRACT; @@ -452,12 +450,12 @@ extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetMethodAt(MethodTable* pMT, pRetMethod = NULL; } - END_QCALL; + *pReturnValue = pRetMethod; - return pRetMethod; + END_QCALL; } -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_GetFields(MethodTable* pMT, intptr_t* result, INT32* pCount, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetFields(MethodTable* pMT, intptr_t* result, INT32* pCount, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -486,12 +484,12 @@ extern "C" BOOL QCALLTYPE RuntimeTypeHandle_GetFields(MethodTable* pMT, intptr_t retVal = TRUE; } - END_QCALL; + *pReturnValue = retVal; - return retVal; + END_QCALL; } -extern "C" void QCALLTYPE RuntimeMethodHandle_ConstructInstantiation(MethodDesc * pMethod, DWORD format, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_ConstructInstantiation(MethodDesc * pMethod, DWORD format, QCall::StringHandleOnStack retString) { QCALL_CONTRACT; @@ -504,7 +502,7 @@ extern "C" void QCALLTYPE RuntimeMethodHandle_ConstructInstantiation(MethodDesc END_QCALL; } -extern "C" void QCALLTYPE RuntimeTypeHandle_ConstructName(QCall::TypeHandle pTypeHandle, DWORD format, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_ConstructName(QCall::TypeHandle pTypeHandle, DWORD format, QCall::StringHandleOnStack retString) { QCALL_CONTRACT; @@ -517,7 +515,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_ConstructName(QCall::TypeHandle pTyp END_QCALL; } -extern "C" void QCALLTYPE RuntimeTypeHandle_GetInterfaces(MethodTable* pMT, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetInterfaces(MethodTable* pMT, QCall::ObjectHandleOnStack result) { QCALL_CONTRACT; @@ -598,7 +596,7 @@ static PTRARRAYREF CopyRuntimeTypeHandles(TypeHandle * prgTH, INT32 numTypeHandl return refReturn; } -extern "C" void QCALLTYPE RuntimeTypeHandle_GetConstraints(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retTypeArray, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetConstraints(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retTypeArray) { QCALL_CONTRACT; @@ -621,7 +619,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_GetConstraints(QCall::TypeHandle pTy END_QCALL; - return; + } FCIMPL1(INT32, RuntimeTypeHandle::GetAttributes, ReflectClassBaseObject *pTypeUNSAFE) @@ -646,7 +644,7 @@ FCIMPL1(INT32, RuntimeTypeHandle::GetAttributes, ReflectClassBaseObject *pTypeUN } FCIMPLEND -extern "C" void QCALLTYPE RuntimeTypeHandle_GetArgumentTypesFromFunctionPointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack argTypes, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetArgumentTypesFromFunctionPointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack argTypes) { QCALL_CONTRACT; @@ -708,7 +706,7 @@ FCIMPL1(FC_BOOL_RET, RuntimeTypeHandle::IsUnmanagedFunctionPointer, ReflectClass } FCIMPLEND -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsVisible(QCall::TypeHandle pTypeHandle, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_IsVisible(QCall::TypeHandle pTypeHandle, BOOL* pReturnValue) { CONTRACTL { @@ -726,9 +724,9 @@ extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsVisible(QCall::TypeHandle pTypeHan fIsExternallyVisible = typeHandle.IsExternallyVisible(); - END_QCALL; + *pReturnValue = fIsExternallyVisible; - return fIsExternallyVisible; + END_QCALL; } FCIMPL1(LPCUTF8, RuntimeTypeHandle::GetUtf8Name, MethodTable* pMT) @@ -777,7 +775,7 @@ FCIMPL1(INT32, RuntimeTypeHandle::GetToken, ReflectClassBaseObject *pTypeUNSAFE) } FCIMPLEND -extern "C" PVOID QCALLTYPE QCall_GetGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, INT32 handleType, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE QCall_GetGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, INT32 handleType, PVOID* pReturnValue) { QCALL_CONTRACT; @@ -793,12 +791,12 @@ extern "C" PVOID QCALLTYPE QCall_GetGCHandleForTypeHandle(QCall::TypeHandle pTyp objHandle = AppDomain::GetCurrentDomain()->CreateTypedHandle(NULL, static_cast(handleType)); th.GetLoaderAllocator()->RegisterHandleForCleanup(objHandle); - END_QCALL; + *pReturnValue = objHandle; - return objHandle; + END_QCALL; } -extern "C" void QCALLTYPE QCall_FreeGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, OBJECTHANDLE objHandle, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE QCall_FreeGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, OBJECTHANDLE objHandle) { QCALL_CONTRACT; @@ -813,7 +811,7 @@ extern "C" void QCALLTYPE QCall_FreeGCHandleForTypeHandle(QCall::TypeHandle pTyp END_QCALL; } -extern "C" void QCALLTYPE RuntimeTypeHandle_VerifyInterfaceIsImplemented(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pIFaceHandle, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_VerifyInterfaceIsImplemented(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pIFaceHandle) { QCALL_CONTRACT; @@ -849,7 +847,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_VerifyInterfaceIsImplemented(QCall:: END_QCALL; } -extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetInterfaceMethodImplementation(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pOwner, MethodDesc * pMD, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetInterfaceMethodImplementation(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pOwner, MethodDesc * pMD, MethodDesc** pReturnValue) { QCALL_CONTRACT; @@ -880,12 +878,12 @@ extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetInterfaceMethodImplementat pResult = slot.GetMethodDesc(); } - END_QCALL; + *pReturnValue = pResult; - return pResult; + END_QCALL; } -extern "C" void QCALLTYPE RuntimeTypeHandle_GetDeclaringMethodForGenericParameter(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetDeclaringMethodForGenericParameter(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack result) { QCALL_CONTRACT; @@ -907,7 +905,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_GetDeclaringMethodForGenericParamete END_QCALL; } -extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandleForGenericVariable(EnregisteredTypeHandle pTypeHandle, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandleForGenericVariable(EnregisteredTypeHandle pTypeHandle, EnregisteredTypeHandle* pReturnValue) { QCALL_CONTRACT; @@ -947,12 +945,12 @@ extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHa retTypeHandle.CheckRestore(); } - END_QCALL; + *pReturnValue = (EnregisteredTypeHandle)retTypeHandle.AsTAddr(); - return (EnregisteredTypeHandle)retTypeHandle.AsTAddr(); + END_QCALL; } -extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandle(EnregisteredTypeHandle pTypeHandle, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandle(EnregisteredTypeHandle pTypeHandle, EnregisteredTypeHandle* pReturnValue) { QCALL_CONTRACT; @@ -981,12 +979,12 @@ extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHa } } - END_QCALL; + *pReturnValue = (EnregisteredTypeHandle)retTypeHandle.AsTAddr(); - return (EnregisteredTypeHandle)retTypeHandle.AsTAddr(); + END_QCALL; } -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_SatisfiesConstraints(QCall::TypeHandle paramType, QCall::TypeHandle typeContext, MethodDesc* methodContext, QCall::TypeHandle toType, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_SatisfiesConstraints(QCall::TypeHandle paramType, QCall::TypeHandle typeContext, MethodDesc* methodContext, QCall::TypeHandle toType, BOOL* pReturnValue) { CONTRACTL { @@ -1014,12 +1012,12 @@ extern "C" BOOL QCALLTYPE RuntimeTypeHandle_SatisfiesConstraints(QCall::TypeHand TypeHandle thGenericArgument = toType.AsTypeHandle(); bResult = thGenericParameter.AsGenericVariable()->SatisfiesConstraints(&typeContext, thGenericArgument); - END_QCALL; + *pReturnValue = bResult; - return bResult; + END_QCALL; } -extern "C" void QCALLTYPE RuntimeTypeHandle_GetInstantiation(QCall::TypeHandle pType, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetInstantiation(QCall::TypeHandle pType, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray) { QCALL_CONTRACT; @@ -1031,10 +1029,10 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_GetInstantiation(QCall::TypeHandle p retTypes.Set(CopyRuntimeTypeHandles(inst.GetRawArgs(), inst.GetNumArgs(), fAsRuntimeTypeArray ? CLASS__CLASS : CLASS__TYPE)); END_QCALL; - return; + } -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeArray(QCall::TypeHandle pTypeHandle, INT32 rank, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakeArray(QCall::TypeHandle pTypeHandle, INT32 rank, QCall::ObjectHandleOnStack retType) { QCALL_CONTRACT; @@ -1046,10 +1044,10 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_MakeArray(QCall::TypeHandle pTypeHan retType.Set(arrayHandle.GetManagedClassObject()); END_QCALL; - return; + } -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeSZArray(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakeSZArray(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType) { QCALL_CONTRACT; @@ -1061,10 +1059,10 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_MakeSZArray(QCall::TypeHandle pTypeH retType.Set(arrayHandle.GetManagedClassObject()); END_QCALL; - return; + } -extern "C" void QCALLTYPE RuntimeTypeHandle_MakePointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakePointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType) { QCALL_CONTRACT; @@ -1076,10 +1074,10 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_MakePointer(QCall::TypeHandle pTypeH retType.Set(pointerHandle.GetManagedClassObject()); END_QCALL; - return; + } -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType) { QCALL_CONTRACT; @@ -1091,10 +1089,10 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHan retType.Set(byRefHandle.GetManagedClassObject()); END_QCALL; - return; + } -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeFunctionPointer(TypeHandle* pRetAndArgTypes, INT32 numArgs, BOOL isUnmanaged, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakeFunctionPointer(TypeHandle* pRetAndArgTypes, INT32 numArgs, BOOL isUnmanaged, QCall::ObjectHandleOnStack retType) { QCALL_CONTRACT; @@ -1107,10 +1105,10 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_MakeFunctionPointer(TypeHandle* pRet retType.Set(fnPtrHandle.GetManagedClassObject()); END_QCALL; - return; + } -extern "C" void QCALLTYPE RuntimeTypeHandle_Instantiate(QCall::TypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_Instantiate(QCall::TypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType) { QCALL_CONTRACT; @@ -1122,10 +1120,10 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_Instantiate(QCall::TypeHandle pTypeH retType.Set(type.GetManagedClassObject()); END_QCALL; - return; + } -extern "C" void QCALLTYPE RuntimeTypeHandle_GetGenericTypeDefinition(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetGenericTypeDefinition(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType) { QCALL_CONTRACT; @@ -1145,7 +1143,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_GetGenericTypeDefinition(QCall::Type END_QCALL; - return; + } FCIMPL2(FC_BOOL_RET, RuntimeTypeHandle::CompareCanonicalHandles, ReflectClassBaseObject *pLeftUNSAFE, ReflectClassBaseObject *pRightUNSAFE) @@ -1229,7 +1227,7 @@ FCIMPL1(FC_BOOL_RET, RuntimeTypeHandle::ContainsGenericVariables, PTR_ReflectCla } FCIMPLEND -extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemory(QCall::TypeHandle type, uint32_t size, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemory(QCall::TypeHandle type, uint32_t size, void** pReturnValue) { QCALL_CONTRACT; @@ -1247,12 +1245,12 @@ extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemory(QCall: LoaderHeap* loaderHeap = loaderAllocator->GetHighFrequencyHeap(); allocatedMemory = loaderHeap->AllocMem(S_SIZE_T(size)); - END_QCALL; + *pReturnValue = allocatedMemory; - return allocatedMemory; + END_QCALL; } -extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemoryAligned(QCall::TypeHandle type, uint32_t size, uint32_t alignment, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemoryAligned(QCall::TypeHandle type, uint32_t size, uint32_t alignment, void** pReturnValue) { QCALL_CONTRACT; @@ -1273,12 +1271,12 @@ extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemoryAligned LoaderHeap* loaderHeap = loaderAllocator->GetHighFrequencyHeap(); allocatedMemory = loaderHeap->AllocAlignedMem(size, alignment); - END_QCALL; + *pReturnValue = allocatedMemory; - return allocatedMemory; + END_QCALL; } -extern "C" void QCALLTYPE RuntimeTypeHandle_RegisterCollectibleTypeDependency(QCall::TypeHandle pTypeHandle, QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_RegisterCollectibleTypeDependency(QCall::TypeHandle pTypeHandle, QCall::AssemblyHandle pAssembly) { QCALL_CONTRACT; @@ -1305,7 +1303,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_RegisterCollectibleTypeDependency(QC //*********************************************************************************** //*********************************************************************************** -extern "C" void * QCALLTYPE RuntimeMethodHandle_GetFunctionPointer(MethodDesc * pMethod, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetFunctionPointer(MethodDesc * pMethod, void ** pReturnValue) { QCALL_CONTRACT; @@ -1318,9 +1316,9 @@ extern "C" void * QCALLTYPE RuntimeMethodHandle_GetFunctionPointer(MethodDesc * pMethod->PrepareForUseAsAFunctionPointer(); funcPtr = (void*)pMethod->GetMultiCallableAddrOfCode(CORINFO_ACCESS_UNMANAGED_CALLER_MAYBE); - END_QCALL; + *pReturnValue = funcPtr; - return funcPtr; + END_QCALL; } FCIMPL1(LPCUTF8, RuntimeMethodHandle::GetUtf8Name, MethodDesc* pMethod) @@ -1483,12 +1481,11 @@ FCIMPL3(INT32, SignatureNative::GetCallingConventionFromFunctionPointerAtOffsetI } FCIMPLEND -extern "C" void QCALLTYPE Signature_GetCustomModifiersAtOffset( +extern "C" QCallExceptionStatus QCALLTYPE Signature_GetCustomModifiersAtOffset( QCall::ObjectHandleOnStack sigObj, INT32 offset, BOOL fRequired, - QCall::ObjectHandleOnStack result, - QCallExceptionStatus* qcallError) + QCall::ObjectHandleOnStack result) { QCALL_CONTRACT; @@ -1608,12 +1605,11 @@ FCIMPL1(INT32, RuntimeMethodHandle::GetMethodDef, MethodDesc* pMethod) } FCIMPLEND -extern "C" void QCALLTYPE Signature_Init( +extern "C" QCallExceptionStatus QCALLTYPE Signature_Init( QCall::ObjectHandleOnStack sigObj, PCCOR_SIGNATURE pCorSig, DWORD cCorSig, FieldDesc* pFieldDesc, - MethodDesc* pMethodDesc, - QCallExceptionStatus* qcallError) + MethodDesc* pMethodDesc) { QCALL_CONTRACT; @@ -1712,10 +1708,9 @@ extern "C" void QCALLTYPE Signature_Init( END_QCALL; } -extern "C" BOOL QCALLTYPE Signature_AreEqual( +extern "C" QCallExceptionStatus QCALLTYPE Signature_AreEqual( PCCOR_SIGNATURE sig1, INT32 cSig1, QCall::TypeHandle handle1, - PCCOR_SIGNATURE sig2, INT32 cSig2, QCall::TypeHandle handle2, - QCallExceptionStatus* qcallError) + PCCOR_SIGNATURE sig2, INT32 cSig2, QCall::TypeHandle handle2, BOOL* pReturnValue) { QCALL_CONTRACT; @@ -1728,12 +1723,12 @@ extern "C" BOOL QCALLTYPE Signature_AreEqual( sig2, cSig2, handle2.AsTypeHandle().GetModule(), NULL, FALSE); - END_QCALL; + *pReturnValue = ret; - return ret; + END_QCALL; } -extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray) { QCALL_CONTRACT; @@ -1744,7 +1739,7 @@ extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodInstantiation(MethodDesc retTypes.Set(CopyRuntimeTypeHandles(inst.GetRawArgs(), inst.GetNumArgs(), fAsRuntimeTypeArray ? CLASS__CLASS : CLASS__TYPE)); END_QCALL; - return; + } FCIMPL1(FC_BOOL_RET, RuntimeMethodHandle::HasMethodInstantiation, MethodDesc * pMethod) @@ -1793,7 +1788,7 @@ FCIMPL1(Object*, RuntimeMethodHandle::GetResolver, MethodDesc * pMethod) } FCIMPLEND -extern "C" void QCALLTYPE RuntimeMethodHandle_Destroy(MethodDesc * pMethod, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_Destroy(MethodDesc * pMethod) { QCALL_CONTRACT; _ASSERTE(pMethod != NULL); @@ -1837,7 +1832,7 @@ FCIMPL1(FC_BOOL_RET, RuntimeMethodHandle::IsTypicalMethodDefinition, ReflectMeth } FCIMPLEND -extern "C" void QCALLTYPE RuntimeMethodHandle_GetTypicalMethodDefinition(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetTypicalMethodDefinition(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod) { QCALL_CONTRACT; @@ -1856,10 +1851,10 @@ extern "C" void QCALLTYPE RuntimeMethodHandle_GetTypicalMethodDefinition(MethodD } END_QCALL; - return; + } -extern "C" void QCALLTYPE RuntimeMethodHandle_StripMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_StripMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod) { QCALL_CONTRACT; @@ -1882,7 +1877,7 @@ extern "C" void QCALLTYPE RuntimeMethodHandle_StripMethodInstantiation(MethodDes } END_QCALL; - return; + } // In the VM there might be more than one MethodDescs for a "method" @@ -1944,7 +1939,7 @@ FCIMPL2(MethodDesc*, RuntimeMethodHandle::GetStubIfNeededInternal, FCIMPLEND // See RuntimeMethodHandle::GetStubIfNeededInternal for more details. -extern "C" MethodDesc* QCALLTYPE RuntimeMethodHandle_GetStubIfNeededSlow(MethodDesc* pMethod, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack methodInstantiation, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetStubIfNeededSlow(MethodDesc* pMethod, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack methodInstantiation, MethodDesc** pReturnValue) { QCALL_CONTRACT; @@ -1988,9 +1983,9 @@ extern "C" MethodDesc* QCALLTYPE RuntimeMethodHandle_GetStubIfNeededSlow(MethodD pNewMethod = MethodDesc::FindOrCreateAssociatedMethodDescForReflection(pMethod, instType, Instantiation(inst, ntypars)); - END_QCALL; + *pReturnValue = pNewMethod; - return pNewMethod; + END_QCALL; } FCIMPL2(MethodDesc*, RuntimeMethodHandle::GetMethodFromCanonical, MethodDesc *pMethod, ReflectClassBaseObject *pTypeUNSAFE) @@ -2011,7 +2006,7 @@ FCIMPL2(MethodDesc*, RuntimeMethodHandle::GetMethodFromCanonical, MethodDesc *pM } FCIMPLEND -extern "C" PCODE QCALLTYPE RuntimeMethodHandle_GetNativeCode(MethodDesc* pMethod, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetNativeCode(MethodDesc* pMethod, PCODE* pReturnValue) { QCALL_CONTRACT; @@ -2033,12 +2028,12 @@ extern "C" PCODE QCALLTYPE RuntimeMethodHandle_GetNativeCode(MethodDesc* pMethod result = GetInterpreterCodeFromEntryPointIfPresent(pMethod->GetNativeCodeAnyVersion()); - END_QCALL; + *pReturnValue = result; - return result; + END_QCALL; } -extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodBody(MethodDesc* pMethod, QCall::TypeHandle pDeclaringType, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetMethodBody(MethodDesc* pMethod, QCall::TypeHandle pDeclaringType, QCall::ObjectHandleOnStack result) { QCALL_CONTRACT; @@ -2337,7 +2332,7 @@ FCIMPL1(INT32, AssemblyHandle::GetTokenInternal, AssemblyBaseObject* pAssemblyUN } FCIMPLEND -extern "C" void QCALLTYPE AssemblyHandle_GetManifestModuleSlow(QCall::ObjectHandleOnStack assembly, QCall::ObjectHandleOnStack module, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE AssemblyHandle_GetManifestModuleSlow(QCall::ObjectHandleOnStack assembly, QCall::ObjectHandleOnStack module) { QCALL_CONTRACT; @@ -2352,7 +2347,7 @@ extern "C" void QCALLTYPE AssemblyHandle_GetManifestModuleSlow(QCall::ObjectHand END_QCALL; } -extern "C" void QCALLTYPE ModuleHandle_GetPEKind(QCall::ModuleHandle pModule, DWORD* pdwPEKind, DWORD* pdwMachine, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_GetPEKind(QCall::ModuleHandle pModule, DWORD* pdwPEKind, DWORD* pdwMachine) { QCALL_CONTRACT; @@ -2368,7 +2363,7 @@ extern "C" INT32 QCALLTYPE ModuleHandle_GetMDStreamVersion(QCall::ModuleHandle p return pModule->GetMDImport()->GetMetadataStreamVersion(); } -extern "C" void QCALLTYPE ModuleHandle_GetModuleType(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_GetModuleType(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retType) { QCALL_CONTRACT; @@ -2390,7 +2385,7 @@ extern "C" void QCALLTYPE ModuleHandle_GetModuleType(QCall::ModuleHandle pModule END_QCALL; - return; + } extern "C" INT32 QCALLTYPE ModuleHandle_GetToken(QCall::ModuleHandle pModule) @@ -2400,7 +2395,7 @@ extern "C" INT32 QCALLTYPE ModuleHandle_GetToken(QCall::ModuleHandle pModule) return pModule->GetMDImport()->GetModuleFromScope(); } -extern "C" void QCALLTYPE ModuleHandle_ResolveType(QCall::ModuleHandle pModule, INT32 tkType, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_ResolveType(QCall::ModuleHandle pModule, INT32 tkType, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retType) { QCALL_CONTRACT; @@ -2418,10 +2413,10 @@ extern "C" void QCALLTYPE ModuleHandle_ResolveType(QCall::ModuleHandle pModule, END_QCALL; - return; + } -extern "C" MethodDesc *QCALLTYPE ModuleHandle_ResolveMethod(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_ResolveMethod(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, MethodDesc ** pReturnValue) { QCALL_CONTRACT; @@ -2437,12 +2432,12 @@ extern "C" MethodDesc *QCALLTYPE ModuleHandle_ResolveMethod(QCall::ModuleHandle // This will get us the instantiating or unboxing stub if needed pMD = MethodDesc::FindOrCreateAssociatedMethodDescForReflection(pMD, pMD->GetMethodTable(), pMD->GetMethodInstantiation()); - END_QCALL; + *pReturnValue = pMD; - return pMD; + END_QCALL; } -extern "C" void QCALLTYPE ModuleHandle_ResolveField(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retField, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_ResolveField(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retField) { QCALL_CONTRACT; @@ -2457,10 +2452,10 @@ extern "C" void QCALLTYPE ModuleHandle_ResolveField(QCall::ModuleHandle pModule, END_QCALL; - return; + } -extern "C" void QCALLTYPE ModuleHandle_GetDynamicMethod(QCall::ModuleHandle pModule, const char* name, byte* sig, INT32 sigLen, QCall::ObjectHandleOnStack resolver, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_GetDynamicMethod(QCall::ModuleHandle pModule, const char* name, byte* sig, INT32 sigLen, QCall::ObjectHandleOnStack resolver, QCall::ObjectHandleOnStack result) { CONTRACTL { diff --git a/src/coreclr/vm/runtimehandles.h b/src/coreclr/vm/runtimehandles.h index 0d366b257f5ab1..aa8516ca7e041c 100644 --- a/src/coreclr/vm/runtimehandles.h +++ b/src/coreclr/vm/runtimehandles.h @@ -96,7 +96,7 @@ class RuntimeLocalVariableInfo : public Object CLR_BOOL _isPinned; }; -extern "C" BOOL QCALLTYPE MdUtf8String_EqualsCaseInsensitive(LPCUTF8 szLhs, LPCUTF8 szRhs, INT32 stringNumBytes, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MdUtf8String_EqualsCaseInsensitive(LPCUTF8 szLhs, LPCUTF8 szRhs, INT32 stringNumBytes, BOOL* pReturnValue); class RuntimeTypeHandle { @@ -129,57 +129,56 @@ class RuntimeTypeHandle FCDECL1(static void, GetNextIntroducedMethod, MethodDesc **ppMethod); }; -extern "C" void QCALLTYPE RuntimeTypeHandle_GetRuntimeTypeFromHandleSlow(void* typeHandleRaw, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetRuntimeTypeFromHandleSlow(void* typeHandleRaw, QCall::ObjectHandleOnStack result); #ifdef FEATURE_TYPEEQUIVALENCE -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsEquivalentTo(QCall::TypeHandle rtType1, QCall::TypeHandle rtType2, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_IsEquivalentTo(QCall::TypeHandle rtType1, QCall::TypeHandle rtType2, BOOL* pReturnValue); #endif // FEATURE_TYPEEQUIVALENCE -extern "C" void QCALLTYPE RuntimeTypeHandle_CreateInstanceForAnotherGenericParameter(QCall::TypeHandle pTypeHandle, TypeHandle *pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack pInstantiatedObject, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAlloc(MethodTable* pMT, QCall::ObjectHandleOnStack allocated, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_CreateInstanceForAnotherGenericParameter(QCall::TypeHandle pTypeHandle, TypeHandle *pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack pInstantiatedObject); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_InternalAlloc(MethodTable* pMT, QCall::ObjectHandleOnStack allocated); -extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAllocNoChecks(MethodTable* pMT, QCall::ObjectHandleOnStack allocated, QCallExceptionStatus* qcallError); -extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemory(QCall::TypeHandle type, uint32_t size, QCallExceptionStatus* qcallError); -extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemoryAligned(QCall::TypeHandle type, uint32_t size, uint32_t alignment, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_InternalAllocNoChecks(MethodTable* pMT, QCall::ObjectHandleOnStack allocated); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemory(QCall::TypeHandle type, uint32_t size, void** pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemoryAligned(QCall::TypeHandle type, uint32_t size, uint32_t alignment, void** pReturnValue); -extern "C" PVOID QCALLTYPE QCall_GetGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, INT32 handleType, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE QCall_FreeGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, OBJECTHANDLE objHandle, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE QCall_GetGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, INT32 handleType, PVOID* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE QCall_FreeGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, OBJECTHANDLE objHandle); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetActivationInfo( +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetActivationInfo( QCall::ObjectHandleOnStack pRuntimeType, PCODE* ppfnAllocator, void** pvAllocatorFirstArg, PCODE* ppfnCtor, PCODE* ppfnValueCtor, - BOOL* pfCtorIsPublic, - QCallExceptionStatus* qcallError); + BOOL* pfCtorIsPublic); #ifdef FEATURE_COMINTEROP -extern "C" void QCALLTYPE RuntimeTypeHandle_AllocateComObject(void* pClassFactory, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_AllocateComObject(void* pClassFactory, QCall::ObjectHandleOnStack result); #endif // FEATURE_COMINTEROP -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_MakePointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeSZArray(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeArray(QCall::TypeHandle pTypeHandle, INT32 rank, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_MakeFunctionPointer(TypeHandle* pRetAndArgTypes, INT32 numArgs, BOOL isUnmanaged, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakePointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakeSZArray(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakeArray(QCall::TypeHandle pTypeHandle, INT32 rank, QCall::ObjectHandleOnStack retType); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakeFunctionPointer(TypeHandle* pRetAndArgTypes, INT32 numArgs, BOOL isUnmanaged, QCall::ObjectHandleOnStack retType); extern "C" void QCALLTYPE RuntimeTypeHandle_PrepareMemberInfoCache(QCall::TypeHandle pMemberInfoCache); -extern "C" void QCALLTYPE RuntimeTypeHandle_ConstructName(QCall::TypeHandle pTypeHandle, DWORD format, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetInterfaces(MethodTable* pMT, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsVisible(QCall::TypeHandle pTypeHandle, QCallExceptionStatus* qcallError); -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_SatisfiesConstraints(QCall::TypeHandle paramType, QCall::TypeHandle typeContext, MethodDesc* methodContext, QCall::TypeHandle toType, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetInstantiation(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, BOOL fAsRuntimeTypeArray, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_Instantiate(QCall::TypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetGenericTypeDefinition(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetConstraints(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retTypes, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetArgumentTypesFromFunctionPointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack argTypes, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetAssemblySlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack assembly, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetModuleSlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack module, QCallExceptionStatus* qcallError); -extern "C" INT32 QCALLTYPE RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals(QCall::TypeHandle pTypeHandle, QCallExceptionStatus* qcallError); -extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetMethodAt(MethodTable* pMT, INT32 slot, QCallExceptionStatus* qcallError); -extern "C" BOOL QCALLTYPE RuntimeTypeHandle_GetFields(MethodTable* pMT, intptr_t* result, INT32* pCount, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_VerifyInterfaceIsImplemented(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pIFaceHandle, QCallExceptionStatus* qcallError); -extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetInterfaceMethodImplementation(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pOwner, MethodDesc * pMD, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_GetDeclaringMethodForGenericParameter(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); -extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandleForGenericVariable(EnregisteredTypeHandle pTypeHandle, QCallExceptionStatus* qcallError); -extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandle(EnregisteredTypeHandle pTypeHandle, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeTypeHandle_RegisterCollectibleTypeDependency(QCall::TypeHandle pTypeHandle, QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_ConstructName(QCall::TypeHandle pTypeHandle, DWORD format, QCall::StringHandleOnStack retString); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetInterfaces(MethodTable* pMT, QCall::ObjectHandleOnStack result); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_IsVisible(QCall::TypeHandle pTypeHandle, BOOL* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_SatisfiesConstraints(QCall::TypeHandle paramType, QCall::TypeHandle typeContext, MethodDesc* methodContext, QCall::TypeHandle toType, BOOL* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetInstantiation(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, BOOL fAsRuntimeTypeArray); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_Instantiate(QCall::TypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetGenericTypeDefinition(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetConstraints(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retTypes); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetArgumentTypesFromFunctionPointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack argTypes); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetAssemblySlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack assembly); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetModuleSlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack module); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals(QCall::TypeHandle pTypeHandle, INT32* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetMethodAt(MethodTable* pMT, INT32 slot, MethodDesc** pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetFields(MethodTable* pMT, intptr_t* result, INT32* pCount, BOOL* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_VerifyInterfaceIsImplemented(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pIFaceHandle); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetInterfaceMethodImplementation(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pOwner, MethodDesc * pMD, MethodDesc** pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetDeclaringMethodForGenericParameter(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack result); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandleForGenericVariable(EnregisteredTypeHandle pTypeHandle, EnregisteredTypeHandle* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandle(EnregisteredTypeHandle pTypeHandle, EnregisteredTypeHandle* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_RegisterCollectibleTypeDependency(QCall::TypeHandle pTypeHandle, QCall::AssemblyHandle pAssembly); class RuntimeMethodHandle { @@ -214,34 +213,32 @@ class RuntimeMethodHandle FCDECL1(static Object*, GetLoaderAllocatorInternal, MethodDesc *pMethod); }; -extern "C" MethodDesc* QCALLTYPE MethodBase_GetCurrentMethod(QCall::StackCrawlMarkHandle stackMark, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE MethodBase_GetCurrentMethod(QCall::StackCrawlMarkHandle stackMark, MethodDesc** pReturnValue); -extern "C" BOOL QCALLTYPE RuntimeMethodHandle_IsCAVisibleFromDecoratedType( +extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_IsCAVisibleFromDecoratedType( QCall::TypeHandle targetTypeHandle, MethodDesc * pTargetCtor, QCall::TypeHandle sourceTypeHandle, - QCall::ModuleHandle sourceModuleHandle, - QCallExceptionStatus* qcallError); + QCall::ModuleHandle sourceModuleHandle, BOOL* pReturnValue); -extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray); -extern "C" void QCALLTYPE RuntimeMethodHandle_InvokeMethod( +extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_InvokeMethod( QCall::ObjectHandleOnStack target, PVOID* args, QCall::ObjectHandleOnStack pSigUNSAFE, BOOL fConstructor, - QCall::ObjectHandleOnStack result, - QCallExceptionStatus* qcallError); + QCall::ObjectHandleOnStack result); -extern "C" void QCALLTYPE RuntimeMethodHandle_ConstructInstantiation(MethodDesc * pMethod, DWORD format, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); -extern "C" void* QCALLTYPE RuntimeMethodHandle_GetFunctionPointer(MethodDesc * pMethod, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_ConstructInstantiation(MethodDesc * pMethod, DWORD format, QCall::StringHandleOnStack retString); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetFunctionPointer(MethodDesc * pMethod, void ** pReturnValue); extern "C" BOOL QCALLTYPE RuntimeMethodHandle_GetIsCollectible(MethodDesc * pMethod); -extern "C" void QCALLTYPE RuntimeMethodHandle_GetTypicalMethodDefinition(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeMethodHandle_StripMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeMethodHandle_Destroy(MethodDesc * pMethod, QCallExceptionStatus* qcallError); -extern "C" MethodDesc* QCALLTYPE RuntimeMethodHandle_GetStubIfNeededSlow(MethodDesc* pMethod, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack methodInstantiation, QCallExceptionStatus* qcallError); -extern "C" PCODE QCALLTYPE RuntimeMethodHandle_GetNativeCode(MethodDesc* pMethod, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodBody(MethodDesc* pMethod, QCall::TypeHandle pDeclaringType, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetTypicalMethodDefinition(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_StripMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_Destroy(MethodDesc * pMethod); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetStubIfNeededSlow(MethodDesc* pMethod, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack methodInstantiation, MethodDesc** pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetNativeCode(MethodDesc* pMethod, PCODE* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetMethodBody(MethodDesc* pMethod, QCall::TypeHandle pDeclaringType, QCall::ObjectHandleOnStack result); class RuntimeFieldHandle { @@ -259,28 +256,28 @@ class RuntimeFieldHandle FCDECL1(static Object*, GetLoaderAllocatorInternal, FieldDesc *pField); }; -extern "C" void QCALLTYPE RuntimeFieldHandle_GetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL *pIsClassInitialized, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeFieldHandle_SetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::ObjectHandleOnStack value, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeFieldHandle_GetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeFieldHandle_SetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::ObjectHandleOnStack newValue, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, QCallExceptionStatus* qcallError); -extern "C" void* QCALLTYPE RuntimeFieldHandle_GetEnCFieldAddr(QCall::ObjectHandleOnStack target, FieldDesc* pFD, QCallExceptionStatus* qcallError); -extern "C" BOOL QCALLTYPE RuntimeFieldHandle_GetRVAFieldInfo(FieldDesc* pField, void** address, UINT* size, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE RuntimeFieldHandle_GetFieldDataReference(FieldDesc* pField, QCall::ObjectHandleOnStack instance, QCall::ByteRefOnStack offset, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL *pIsClassInitialized, QCall::ObjectHandleOnStack result); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_SetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::ObjectHandleOnStack value, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack result); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_SetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::ObjectHandleOnStack newValue, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetEnCFieldAddr(QCall::ObjectHandleOnStack target, FieldDesc* pFD, void** pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetRVAFieldInfo(FieldDesc* pField, void** address, UINT* size, BOOL* pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetFieldDataReference(FieldDesc* pField, QCall::ObjectHandleOnStack instance, QCall::ByteRefOnStack offset); extern "C" INT32 QCALLTYPE ModuleHandle_GetMDStreamVersion(QCall::ModuleHandle pModule); -extern "C" void QCALLTYPE ModuleHandle_GetModuleType(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_GetModuleType(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retType); extern "C" INT32 QCALLTYPE ModuleHandle_GetToken(QCall::ModuleHandle pModule); -extern "C" void QCALLTYPE ModuleHandle_ResolveType(QCall::ModuleHandle pModule, INT32 tkType, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_ResolveType(QCall::ModuleHandle pModule, INT32 tkType, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retType); -extern "C" MethodDesc * QCALLTYPE ModuleHandle_ResolveMethod(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_ResolveMethod(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, MethodDesc ** pReturnValue); -extern "C" void QCALLTYPE ModuleHandle_ResolveField(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retField, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_ResolveField(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retField); -extern "C" void QCALLTYPE ModuleHandle_GetPEKind(QCall::ModuleHandle pModule, DWORD* pdwPEKind, DWORD* pdwMachine, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_GetPEKind(QCall::ModuleHandle pModule, DWORD* pdwPEKind, DWORD* pdwMachine); -extern "C" void QCALLTYPE ModuleHandle_GetDynamicMethod(QCall::ModuleHandle pModule, const char* name, byte* sig, INT32 sigLen, QCall::ObjectHandleOnStack resolver, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_GetDynamicMethod(QCall::ModuleHandle pModule, const char* name, byte* sig, INT32 sigLen, QCall::ObjectHandleOnStack resolver, QCall::ObjectHandleOnStack result); class AssemblyHandle { @@ -289,35 +286,31 @@ class AssemblyHandle FCDECL1(static INT32, GetTokenInternal, AssemblyBaseObject *pAssemblyUNSAFE); }; -extern "C" void QCALLTYPE AssemblyHandle_GetManifestModuleSlow(QCall::ObjectHandleOnStack assembly, QCall::ObjectHandleOnStack module, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AssemblyHandle_GetManifestModuleSlow(QCall::ObjectHandleOnStack assembly, QCall::ObjectHandleOnStack module); -extern "C" void QCALLTYPE Signature_Init( +extern "C" QCallExceptionStatus QCALLTYPE Signature_Init( QCall::ObjectHandleOnStack sigObj, PCCOR_SIGNATURE pCorSig, DWORD cCorSig, FieldDesc* pFieldDesc, - MethodDesc* pMethodDesc, - QCallExceptionStatus* qcallError); + MethodDesc* pMethodDesc); -extern "C" BOOL QCALLTYPE Signature_AreEqual( +extern "C" QCallExceptionStatus QCALLTYPE Signature_AreEqual( PCCOR_SIGNATURE sig1, INT32 cSig1, QCall::TypeHandle handle1, - PCCOR_SIGNATURE sig2, INT32 cSig2, QCall::TypeHandle handle2, - QCallExceptionStatus* qcallError); + PCCOR_SIGNATURE sig2, INT32 cSig2, QCall::TypeHandle handle2, BOOL* pReturnValue); -extern "C" void QCALLTYPE Signature_GetCustomModifiersAtOffset( +extern "C" QCallExceptionStatus QCALLTYPE Signature_GetCustomModifiersAtOffset( QCall::ObjectHandleOnStack sigObj, INT32 offset, BOOL fRequired, - QCall::ObjectHandleOnStack result, - QCallExceptionStatus* qcallError); + QCall::ObjectHandleOnStack result); class SignatureNative : public Object { - friend void QCALLTYPE Signature_Init( + friend QCallExceptionStatus QCALLTYPE Signature_Init( QCall::ObjectHandleOnStack sigObj, PCCOR_SIGNATURE pCorSig, DWORD cCorSig, FieldDesc* pFieldDesc, - MethodDesc* pMethodDesc, - QCallExceptionStatus* qcallError); + MethodDesc* pMethodDesc); friend class ArgIteratorForMethodInvoke; public: diff --git a/src/coreclr/vm/stackwalk.h b/src/coreclr/vm/stackwalk.h index dc6ae465668ea8..463e34ba9f8887 100644 --- a/src/coreclr/vm/stackwalk.h +++ b/src/coreclr/vm/stackwalk.h @@ -40,7 +40,7 @@ namespace AsmOffsetsAsserts class AsmOffsets; }; -extern "C" void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo); class CrawlFrame { @@ -403,7 +403,7 @@ class CrawlFrame friend class EECodeManager; friend class StackFrameIterator; friend struct ExInfo; - friend void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo, QCallExceptionStatus* qcallError); + friend QCallExceptionStatus QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo); bool isFrameless; bool isFirst; diff --git a/src/coreclr/vm/stubhelpers.cpp b/src/coreclr/vm/stubhelpers.cpp index e5032d80610206..76caa04833d811 100644 --- a/src/coreclr/vm/stubhelpers.cpp +++ b/src/coreclr/vm/stubhelpers.cpp @@ -313,7 +313,7 @@ FCIMPLEND #include -extern "C" IUnknown* QCALLTYPE StubHelpers_GetCOMIPFromRCWSlow(QCall::ObjectHandleOnStack pSrc, MethodDesc* pMD, void** ppTarget, BOOL* pfNeedsRelease, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_GetCOMIPFromRCWSlow(QCall::ObjectHandleOnStack pSrc, MethodDesc* pMD, void** ppTarget, BOOL* pfNeedsRelease, IUnknown** pReturnValue) { QCALL_CONTRACT; _ASSERTE(pMD != NULL); @@ -355,12 +355,12 @@ extern "C" IUnknown* QCALLTYPE StubHelpers_GetCOMIPFromRCWSlow(QCall::ObjectHand GCPROTECT_END(); - END_QCALL; + *pReturnValue = pIntf; - return pIntf; + END_QCALL; } -extern "C" void QCALLTYPE ObjectMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pSrcUNSAFE, VARIANT* pDest, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ObjectMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pSrcUNSAFE, VARIANT* pDest) { QCALL_CONTRACT; @@ -385,7 +385,7 @@ extern "C" void QCALLTYPE ObjectMarshaler_ConvertToNative(QCall::ObjectHandleOnS END_QCALL; } -extern "C" void QCALLTYPE ObjectMarshaler_ConvertToManaged(VARIANT* pSrc, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ObjectMarshaler_ConvertToManaged(VARIANT* pSrc, QCall::ObjectHandleOnStack retObject) { QCALL_CONTRACT; @@ -407,7 +407,7 @@ extern "C" void QCALLTYPE ObjectMarshaler_ConvertToManaged(VARIANT* pSrc, QCall: } #include -extern "C" IUnknown* QCALLTYPE InterfaceMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pObjUNSAFE, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE InterfaceMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pObjUNSAFE, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, IUnknown** pReturnValue) { QCALL_CONTRACT; @@ -426,12 +426,12 @@ extern "C" IUnknown* QCALLTYPE InterfaceMarshaler_ConvertToNative(QCall::ObjectH GCPROTECT_END(); - END_QCALL; + *pReturnValue = pIntf; - return pIntf; + END_QCALL; } -extern "C" void QCALLTYPE InterfaceMarshaler_ConvertToManaged(IUnknown** ppUnk, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE InterfaceMarshaler_ConvertToManaged(IUnknown** ppUnk, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCall::ObjectHandleOnStack retObject) { QCALL_CONTRACT; @@ -454,7 +454,7 @@ extern "C" void QCALLTYPE InterfaceMarshaler_ConvertToManaged(IUnknown** ppUnk, } #include -extern "C" void QCALLTYPE InterfaceMarshaler_GetObjectForComCallableWrapperIUnknown(IUnknown* unk, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE InterfaceMarshaler_GetObjectForComCallableWrapperIUnknown(IUnknown* unk, QCall::ObjectHandleOnStack retObject) { QCALL_CONTRACT; @@ -467,7 +467,7 @@ extern "C" void QCALLTYPE InterfaceMarshaler_GetObjectForComCallableWrapperIUnkn END_QCALL; } -extern "C" void QCALLTYPE InterfaceMarshaler_ValidateComVisibilityForIUnknown(IUnknown* unk, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE InterfaceMarshaler_ValidateComVisibilityForIUnknown(IUnknown* unk) { QCALL_CONTRACT; @@ -493,7 +493,7 @@ FCIMPL0(void, StubHelpers::ClearLastError) } FCIMPLEND -extern "C" void QCALLTYPE StubHelpers_ThrowInteropParamException(INT resID, INT paramIdx, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ThrowInteropParamException(INT resID, INT paramIdx) { QCALL_CONTRACT; @@ -503,7 +503,7 @@ extern "C" void QCALLTYPE StubHelpers_ThrowInteropParamException(INT resID, INT } #ifdef PROFILING_SUPPORTED -extern "C" void* QCALLTYPE StubHelpers_ProfilerBeginTransitionCallback(MethodDesc* pTargetMD, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ProfilerBeginTransitionCallback(MethodDesc* pTargetMD, void** pReturnValue) { PreserveLastErrorHolder preserveLastError; @@ -513,12 +513,12 @@ extern "C" void* QCALLTYPE StubHelpers_ProfilerBeginTransitionCallback(MethodDes ProfilerManagedToUnmanagedTransitionMD(pTargetMD, COR_PRF_TRANSITION_CALL); - END_QCALL; + *pReturnValue = pTargetMD; - return pTargetMD; + END_QCALL; } -extern "C" void QCALLTYPE StubHelpers_ProfilerEndTransitionCallback(MethodDesc* pTargetMD, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ProfilerEndTransitionCallback(MethodDesc* pTargetMD) { PreserveLastErrorHolder preserveLastError; @@ -532,7 +532,7 @@ extern "C" void QCALLTYPE StubHelpers_ProfilerEndTransitionCallback(MethodDesc* } #endif // PROFILING_SUPPORTED -extern "C" void QCALLTYPE StubHelpers_MarshalToManagedVaList(va_list va, VARARGS* pArgIterator, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_MarshalToManagedVaList(va_list va, VARARGS* pArgIterator) { QCALL_CONTRACT; @@ -541,7 +541,7 @@ extern "C" void QCALLTYPE StubHelpers_MarshalToManagedVaList(va_list va, VARARGS END_QCALL; } -extern "C" void QCALLTYPE StubHelpers_MarshalToUnmanagedVaList(va_list va, DWORD cbVaListSize, const VARARGS* pArgIterator, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_MarshalToUnmanagedVaList(va_list va, DWORD cbVaListSize, const VARARGS* pArgIterator) { QCALL_CONTRACT; @@ -550,7 +550,7 @@ extern "C" void QCALLTYPE StubHelpers_MarshalToUnmanagedVaList(va_list va, DWORD END_QCALL; } -extern "C" void QCALLTYPE StubHelpers_ValidateObject(QCall::ObjectHandleOnStack pObj, MethodDesc *pMD, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ValidateObject(QCall::ObjectHandleOnStack pObj, MethodDesc *pMD) { QCALL_CONTRACT; @@ -581,15 +581,14 @@ extern "C" void QCALLTYPE StubHelpers_ValidateObject(QCall::ObjectHandleOnStack END_QCALL; } -extern "C" void QCALLTYPE StubHelpers_ValidateByref(void *pByref, MethodDesc *pMD, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ValidateByref(void *pByref, MethodDesc *pMD) { QCALL_CONTRACT; // Skip byref if is not pointing inside managed heap if (!GCHeapUtilities::GetGCHeap()->IsHeapPointer(pByref)) { - qcallError->SetNoException(); - return; + return QCallExceptionStatus(); } BEGIN_QCALL; @@ -670,7 +669,7 @@ FCIMPL1(DWORD, StubHelpers::CalcVaListSize, VARARGS *varargs) } FCIMPLEND -extern "C" void QCALLTYPE StubHelpers_MulticastDebuggerTraceHelper(QCall::ObjectHandleOnStack element, INT32 count, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_MulticastDebuggerTraceHelper(QCall::ObjectHandleOnStack element, INT32 count) { QCALL_CONTRACT; @@ -683,7 +682,7 @@ extern "C" void QCALLTYPE StubHelpers_MulticastDebuggerTraceHelper(QCall::Object END_QCALL; } -extern "C" void QCALLTYPE StubHelpers_CreateLayoutClassMarshalStubs(QCall::TypeHandle th, PCODE* pConvertToUnmanaged, PCODE* pConvertToManaged, PCODE* pFree, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_CreateLayoutClassMarshalStubs(QCall::TypeHandle th, PCODE* pConvertToUnmanaged, PCODE* pConvertToManaged, PCODE* pFree) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/stubhelpers.h b/src/coreclr/vm/stubhelpers.h index 028a918acd471d..0f8d4217fb68ce 100644 --- a/src/coreclr/vm/stubhelpers.h +++ b/src/coreclr/vm/stubhelpers.h @@ -37,34 +37,34 @@ class StubHelpers FCDECL1(static DWORD, CalcVaListSize, VARARGS *varargs); }; -extern "C" void QCALLTYPE StubHelpers_CreateCustomMarshaler(MethodDesc* pMD, mdToken paramToken, TypeHandle hndManagedType, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_CreateCustomMarshaler(MethodDesc* pMD, mdToken paramToken, TypeHandle hndManagedType, QCall::ObjectHandleOnStack retObject); #ifdef PROFILING_SUPPORTED -extern "C" void* QCALLTYPE StubHelpers_ProfilerBeginTransitionCallback(MethodDesc* pTargetMD, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE StubHelpers_ProfilerEndTransitionCallback(MethodDesc* pTargetMD, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ProfilerBeginTransitionCallback(MethodDesc* pTargetMD, void** pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ProfilerEndTransitionCallback(MethodDesc* pTargetMD); #endif #ifdef FEATURE_COMINTEROP -extern "C" IUnknown* QCALLTYPE StubHelpers_GetCOMIPFromRCWSlow(QCall::ObjectHandleOnStack pSrc, MethodDesc* pMD, void** ppTarget, BOOL* pfNeedsRelease, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_GetCOMIPFromRCWSlow(QCall::ObjectHandleOnStack pSrc, MethodDesc* pMD, void** ppTarget, BOOL* pfNeedsRelease, IUnknown** pReturnValue); -extern "C" void QCALLTYPE ObjectMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pSrcUNSAFE, VARIANT* pDest, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ObjectMarshaler_ConvertToManaged(VARIANT* pSrc, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ObjectMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pSrcUNSAFE, VARIANT* pDest); +extern "C" QCallExceptionStatus QCALLTYPE ObjectMarshaler_ConvertToManaged(VARIANT* pSrc, QCall::ObjectHandleOnStack retObject); -extern "C" IUnknown* QCALLTYPE InterfaceMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pObjUNSAFE, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE InterfaceMarshaler_ConvertToManaged(IUnknown** ppUnk, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE InterfaceMarshaler_GetObjectForComCallableWrapperIUnknown(IUnknown* unk, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE InterfaceMarshaler_ValidateComVisibilityForIUnknown(IUnknown* unk, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE InterfaceMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pObjUNSAFE, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, IUnknown** pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE InterfaceMarshaler_ConvertToManaged(IUnknown** ppUnk, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCall::ObjectHandleOnStack retObject); +extern "C" QCallExceptionStatus QCALLTYPE InterfaceMarshaler_GetObjectForComCallableWrapperIUnknown(IUnknown* unk, QCall::ObjectHandleOnStack retObject); +extern "C" QCallExceptionStatus QCALLTYPE InterfaceMarshaler_ValidateComVisibilityForIUnknown(IUnknown* unk); #endif -extern "C" void QCALLTYPE StubHelpers_ThrowInteropParamException(INT resID, INT paramIdx, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ThrowInteropParamException(INT resID, INT paramIdx); -extern "C" void QCALLTYPE StubHelpers_MarshalToManagedVaList(va_list va, VARARGS* pArgIterator, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE StubHelpers_MarshalToUnmanagedVaList(va_list va, DWORD cbVaListSize, const VARARGS* pArgIterator, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_MarshalToManagedVaList(va_list va, VARARGS* pArgIterator); +extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_MarshalToUnmanagedVaList(va_list va, DWORD cbVaListSize, const VARARGS* pArgIterator); -extern "C" void QCALLTYPE StubHelpers_ValidateObject(QCall::ObjectHandleOnStack pObj, MethodDesc *pMD, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE StubHelpers_ValidateByref(void *pByref, MethodDesc *pMD, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ValidateObject(QCall::ObjectHandleOnStack pObj, MethodDesc *pMD); +extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ValidateByref(void *pByref, MethodDesc *pMD); -extern "C" void QCALLTYPE StubHelpers_MulticastDebuggerTraceHelper(QCall::ObjectHandleOnStack element, INT32 count, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_MulticastDebuggerTraceHelper(QCall::ObjectHandleOnStack element, INT32 count); -extern "C" void QCALLTYPE StubHelpers_CreateLayoutClassMarshalStubs(QCall::TypeHandle th, PCODE* pConvertToUnmanaged, PCODE* pConvertToManaged, PCODE* pFree, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_CreateLayoutClassMarshalStubs(QCall::TypeHandle th, PCODE* pConvertToUnmanaged, PCODE* pConvertToManaged, PCODE* pFree); #endif // __STUBHELPERS_h__ diff --git a/src/coreclr/vm/tailcallhelp.cpp b/src/coreclr/vm/tailcallhelp.cpp index 0f6beee9c1a902..e4faa888dbc5b5 100644 --- a/src/coreclr/vm/tailcallhelp.cpp +++ b/src/coreclr/vm/tailcallhelp.cpp @@ -21,7 +21,7 @@ FCIMPL0(void*, TailCallHelp::GetTailCallArgBuffer) } FCIMPLEND -extern "C" void* QCALLTYPE TailCallHelp_AllocTailCallArgBufferInternal(int size, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE TailCallHelp_AllocTailCallArgBufferInternal(int size, void** pReturnValue) { QCALL_CONTRACT; @@ -31,9 +31,9 @@ extern "C" void* QCALLTYPE TailCallHelp_AllocTailCallArgBufferInternal(int size, retVal = GetThread()->GetTailCallTls()->AllocArgBuffer(size); - END_QCALL; + *pReturnValue = retVal; - return retVal; + END_QCALL; } FCIMPL2(void*, TailCallHelp::GetTailCallInfo, void** retAddrSlot, void** retAddr) diff --git a/src/coreclr/vm/tailcallhelp.h b/src/coreclr/vm/tailcallhelp.h index a5bc1c76a89af4..fe4703994cfac0 100644 --- a/src/coreclr/vm/tailcallhelp.h +++ b/src/coreclr/vm/tailcallhelp.h @@ -47,6 +47,6 @@ class TailCallHelp static void* AllocateBlob(LoaderAllocator* alloc, const void* blob, size_t blobLen); }; -extern "C" void* QCALLTYPE TailCallHelp_AllocTailCallArgBufferInternal(int size, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE TailCallHelp_AllocTailCallArgBufferInternal(int size, void** pReturnValue); #endif diff --git a/src/coreclr/vm/threadstatics.cpp b/src/coreclr/vm/threadstatics.cpp index 958706b4846ea2..7c37a2d4ca4e79 100644 --- a/src/coreclr/vm/threadstatics.cpp +++ b/src/coreclr/vm/threadstatics.cpp @@ -203,8 +203,6 @@ void ScanThreadStaticRoots(Thread* pThread, promote_func* fn, ScanContext* sc) // Report non-collectible object array fn(&pThreadLocalData->pNonCollectibleTlsArrayData, sc, 0); - // Report qcall exception object - fn(&pThreadLocalData->pQCallException, sc, 0); } #endif // DACCESS_COMPILE diff --git a/src/coreclr/vm/threadstatics.h b/src/coreclr/vm/threadstatics.h index 8a96b691c63951..0a77a356e33db4 100644 --- a/src/coreclr/vm/threadstatics.h +++ b/src/coreclr/vm/threadstatics.h @@ -90,7 +90,6 @@ struct ThreadLocalData PTR_Object pNonCollectibleTlsArrayData; DPTR(OBJECTHANDLE) pCollectibleTlsArrayData; // Points at the Thread local array data. PTR_Thread pThread; // This starts the region of ThreadLocalData which is referenceable by TLSIndexType::DirectOnThreadLocalData - PTR_Object pQCallException; // This is used to store an exception that is thrown in a QCall, so that it can be rethrown in managed code. It is stored here because this is the only place that is guaranteed to be allocated for the lifetime of the thread, and it is not used for anything else. uint32_t managedThreadId; PTR_InFlightTLSData pInFlightData; // Points at the in-flight TLS data (TLS data that exists before the class constructor finishes running) BYTE ExtendedDirectThreadLocalTLSData[EXTENDED_DIRECT_THREAD_LOCAL_SIZE]; diff --git a/src/coreclr/vm/unsafeaccessors.cpp b/src/coreclr/vm/unsafeaccessors.cpp index d0e89005dfb1b6..fa3ea873cd021f 100644 --- a/src/coreclr/vm/unsafeaccessors.cpp +++ b/src/coreclr/vm/unsafeaccessors.cpp @@ -1172,7 +1172,7 @@ bool MethodDesc::TryGenerateUnsafeAccessor(DynamicResolver** resolver, COR_ILMET return true; } -extern "C" void* QCALLTYPE UnsafeAccessors_ResolveGenericParamToTypeHandle(MethodDesc* unsafeAccessorMethod, BOOL isMethodParam, DWORD paramIndex, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE UnsafeAccessors_ResolveGenericParamToTypeHandle(MethodDesc* unsafeAccessorMethod, BOOL isMethodParam, DWORD paramIndex, void** pReturnValue) { QCALL_CONTRACT; _ASSERTE(unsafeAccessorMethod != NULL); @@ -1189,7 +1189,7 @@ extern "C" void* QCALLTYPE UnsafeAccessors_ResolveGenericParamToTypeHandle(Metho if (0 <= paramIndex && paramIndex < genericParams.GetNumArgs()) ret = genericParams[paramIndex]; - END_QCALL; + *pReturnValue = ret.AsPtr(); - return ret.AsPtr(); + END_QCALL; } diff --git a/src/coreclr/vm/varargsnative.cpp b/src/coreclr/vm/varargsnative.cpp index 1306ef9cc61b7d..2144b8b9f05a4d 100644 --- a/src/coreclr/vm/varargsnative.cpp +++ b/src/coreclr/vm/varargsnative.cpp @@ -167,7 +167,7 @@ static void AdvanceArgPtr(VARARGS *data) // ArgIterator constructor that initializes the state to support iteration // of the args starting at the first optional argument. //////////////////////////////////////////////////////////////////////////////// -extern "C" void QCALLTYPE ArgIterator_Init(VARARGS* data, PVOID cookie, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_Init(VARARGS* data, PVOID cookie) { QCALL_CONTRACT; @@ -197,7 +197,7 @@ extern "C" void QCALLTYPE ArgIterator_Init(VARARGS* data, PVOID cookie, QCallExc // Specifying NULL as the firstArg parameter causes it to start at the first // argument to the call. //////////////////////////////////////////////////////////////////////////////// -extern "C" void QCALLTYPE ArgIterator_Init2(VARARGS* data, PVOID cookie, PVOID firstArg, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_Init2(VARARGS* data, PVOID cookie, PVOID firstArg) { QCALL_CONTRACT; @@ -469,7 +469,7 @@ static void GetNextArgHelper(VARARGS* data, TypedByRef* value, BOOL fData) //////////////////////////////////////////////////////////////////////////////// // Retrieve the type of the next argument without consuming it. //////////////////////////////////////////////////////////////////////////////// -extern "C" void* QCALLTYPE ArgIterator_GetNextArgType(VARARGS* data, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_GetNextArgType(VARARGS* data, void** pReturnValue) { QCALL_CONTRACT; @@ -489,16 +489,16 @@ extern "C" void* QCALLTYPE ArgIterator_GetNextArgType(VARARGS* data, QCallExcept GCPROTECT_END(); - END_QCALL; + *pReturnValue = value.type.AsPtr(); - return value.type.AsPtr(); + END_QCALL; } //////////////////////////////////////////////////////////////////////////////// // Retrieve the next argument and return it in a TypedByRef and advance the // next argument pointer. //////////////////////////////////////////////////////////////////////////////// -extern "C" void QCALLTYPE ArgIterator_GetNextArg(VARARGS* data, TypedByRef* pResult, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_GetNextArg(VARARGS* data, TypedByRef* pResult) { QCALL_CONTRACT; @@ -514,7 +514,7 @@ extern "C" void QCALLTYPE ArgIterator_GetNextArg(VARARGS* data, TypedByRef* pRes // Retrieve the next argument and return it in a TypedByRef and advance the // next argument pointer. //////////////////////////////////////////////////////////////////////////////// -extern "C" void QCALLTYPE ArgIterator_GetNextArg2(VARARGS* data, QCall::TypeHandle pType, TypedByRef* pResult, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_GetNextArg2(VARARGS* data, QCall::TypeHandle pType, TypedByRef* pResult) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/varargsnative.h b/src/coreclr/vm/varargsnative.h index 0c80adb1f2ad46..93bf2f6db65916 100644 --- a/src/coreclr/vm/varargsnative.h +++ b/src/coreclr/vm/varargsnative.h @@ -14,10 +14,10 @@ #include "clrvarargs.h" -extern "C" void QCALLTYPE ArgIterator_Init(VARARGS* thisPtr, PVOID cookie, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ArgIterator_Init2(VARARGS* thisPtr, PVOID cookie, PVOID firstArg, QCallExceptionStatus* qcallError); -extern "C" void* QCALLTYPE ArgIterator_GetNextArgType(VARARGS* thisPtr, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ArgIterator_GetNextArg(VARARGS* thisPtr, TypedByRef* pResult, QCallExceptionStatus* qcallError); -extern "C" void QCALLTYPE ArgIterator_GetNextArg2(VARARGS* thisPtr, QCall::TypeHandle pType, TypedByRef* pResult, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_Init(VARARGS* thisPtr, PVOID cookie); +extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_Init2(VARARGS* thisPtr, PVOID cookie, PVOID firstArg); +extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_GetNextArgType(VARARGS* thisPtr, void** pReturnValue); +extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_GetNextArg(VARARGS* thisPtr, TypedByRef* pResult); +extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_GetNextArg2(VARARGS* thisPtr, QCall::TypeHandle pType, TypedByRef* pResult); #endif // _VARARGSNATIVE_H_ diff --git a/src/coreclr/vm/versionresilienthashcode.cpp b/src/coreclr/vm/versionresilienthashcode.cpp index 442c691f706616..d45b11f6d2a56b 100644 --- a/src/coreclr/vm/versionresilienthashcode.cpp +++ b/src/coreclr/vm/versionresilienthashcode.cpp @@ -450,7 +450,7 @@ bool GetVersionResilientILCodeHashCode(MethodDesc *pMD, const COR_ILMETHOD_DECOD return true; } -extern "C" INT32 QCALLTYPE VersionResilientHashCode_TypeHashCode(QCall::TypeHandle pTypeHandle, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE VersionResilientHashCode_TypeHashCode(QCall::TypeHandle pTypeHandle, INT32* pReturnValue) { QCALL_CONTRACT; @@ -460,9 +460,9 @@ extern "C" INT32 QCALLTYPE VersionResilientHashCode_TypeHashCode(QCall::TypeHand hashCode = GetVersionResilientTypeHashCode(pTypeHandle.AsTypeHandle()); - END_QCALL; + *pReturnValue = hashCode; - return hashCode; + END_QCALL; } #endif // DACCESS_COMPILE diff --git a/src/coreclr/vm/versionresilienthashcode.h b/src/coreclr/vm/versionresilienthashcode.h index da36794166ec14..bb92e56d668eb1 100644 --- a/src/coreclr/vm/versionresilienthashcode.h +++ b/src/coreclr/vm/versionresilienthashcode.h @@ -14,4 +14,4 @@ int GetVersionResilientModuleHashCode(Module* pModule); bool GetVersionResilientILCodeHashCode(MethodDesc *pMD, const COR_ILMETHOD_DECODER* header, int* hashCode, unsigned* ilSize); -extern "C" INT32 QCALLTYPE VersionResilientHashCode_TypeHashCode(QCall::TypeHandle pTypeHandle, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE VersionResilientHashCode_TypeHashCode(QCall::TypeHandle pTypeHandle, INT32* pReturnValue); diff --git a/src/coreclr/vm/wasm/browser/callhelpers-interp-to-managed.cpp b/src/coreclr/vm/wasm/browser/callhelpers-interp-to-managed.cpp index d6570db6f62385..02b8d1b233ed28 100644 --- a/src/coreclr/vm/wasm/browser/callhelpers-interp-to-managed.cpp +++ b/src/coreclr/vm/wasm/browser/callhelpers-interp-to-managed.cpp @@ -100,6 +100,12 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_IND(0)); } + static void CallFunc_S8_S8_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(int32_t, int32_t) = (int32_t (*)(int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1)); + } + static void CallFunc_S8_S8_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t))pcode; @@ -124,6 +130,12 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_I32(3), ARG_I32(4)); } + static void CallFunc_S8_S8_I32_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); + } + static void CallFunc_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t, int32_t) = (int32_t (*)(int32_t, int32_t))pcode; @@ -172,6 +184,12 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); } + static void CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7), ARG_I32(8), ARG_I32(9), ARG_I32(10), ARG_I32(11)); + } + NOINLINE static void CallFunc_This_I32_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; @@ -186,12 +204,36 @@ namespace *((int32_t*)pRet) = (*fptr)(&framePointer, ARG_I32(0), pPortableEntryPoint); } + static void CallFunc_F64_F64_F64_F64_F64_F64_F64_F64_F64_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(double, double, double, double, double, double, double, double, double, int32_t, int32_t) = (int32_t (*)(double, double, double, double, double, double, double, double, double, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_F64(0), ARG_F64(1), ARG_F64(2), ARG_F64(3), ARG_F64(4), ARG_F64(5), ARG_F64(6), ARG_F64(7), ARG_F64(8), ARG_I32(9), ARG_I32(10)); + } + + static void CallFunc_F64_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(double, int32_t) = (int32_t (*)(double, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_F64(0), ARG_I32(1)); + } + + static void CallFunc_F64_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(double, int32_t, int32_t, int32_t) = (int32_t (*)(double, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_F64(0), ARG_I32(1), ARG_I32(2), ARG_I32(3)); + } + static void CallFunc_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t) = (int32_t (*)(int32_t))pcode; *((int32_t*)pRet) = (*fptr)(ARG_I32(0)); } + static void CallFunc_I32_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_IND(1), ARG_I32(2)); + } + static void CallFunc_I32_S8_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t))pcode; @@ -210,6 +252,18 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1)); } + static void CallFunc_I32_I32_S8_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_IND(3), ARG_I32(4)); + } + + static void CallFunc_I32_I32_S8_S8_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_IND(3), ARG_I32(4), ARG_I32(5)); + } + static void CallFunc_I32_I32_S8_I32_I32_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; @@ -222,12 +276,30 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7)); } + static void CallFunc_I32_I32_F64_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(int32_t, int32_t, double) = (int32_t (*)(int32_t, int32_t, double))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_F64(2)); + } + static void CallFunc_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t))pcode; *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2)); } + static void CallFunc_I32_I32_I32_S8_S8_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_IND(4)); + } + + static void CallFunc_I32_I32_I32_S8_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_IND(4), ARG_I32(5)); + } + static void CallFunc_I32_I32_I32_S8_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; @@ -278,6 +350,12 @@ namespace *((int32_t*)pRet) = (*fptr)(&framePointer, ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), pPortableEntryPoint); } + static void CallFunc_I32_I32_I32_I32_I64_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int64_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int64_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I64(4)); + } + NOINLINE static void CallFunc_I32_I32_I32_I32_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; @@ -354,6 +432,12 @@ namespace *((int32_t*)pRet) = (*fptr)(&framePointer, ARG_I32(0), pPortableEntryPoint); } + static void CallFunc_I64_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(int64_t) = (int32_t (*)(int64_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I64(0)); + } + static void CallFunc_I64_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int64_t, int32_t) = (int32_t (*)(int64_t, int32_t))pcode; @@ -397,12 +481,6 @@ namespace *((int64_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2)); } - static void CallFunc_I32_I32_I32_I32_I32_I32_RetI64(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int64_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int64_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int64_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5)); - } - static void CallFunc_I32_I32_I32_I64_RetI64(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int64_t (*fptr)(int32_t, int32_t, int32_t, int64_t) = (int64_t (*)(int32_t, int32_t, int32_t, int64_t))pcode; @@ -456,66 +534,6 @@ namespace (*fptr)(); } - static void CallFunc_S8_S8_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2)); - } - - static void CallFunc_S8_S8_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7)); - } - - static void CallFunc_S8_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t) = (void (*)(int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_I32(1)); - } - - static void CallFunc_S8_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2)); - } - - static void CallFunc_S8_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3)); - } - - static void CallFunc_S8_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4)); - } - - static void CallFunc_S8_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5)); - } - - static void CallFunc_S8_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); - } - - static void CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7)); - } - - static void CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7), ARG_I32(8), ARG_I32(9), ARG_I32(10), ARG_I32(11), ARG_I32(12)); - } - NOINLINE static void CallFunc_This_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; @@ -523,24 +541,6 @@ namespace (*fptr)(&framePointer, ARG_I32(0), pPortableEntryPoint); } - static void CallFunc_F64_F64_F64_F64_F64_F64_F64_F64_F64_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(double, double, double, double, double, double, double, double, double, int32_t, int32_t, int32_t) = (void (*)(double, double, double, double, double, double, double, double, double, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_F64(0), ARG_F64(1), ARG_F64(2), ARG_F64(3), ARG_F64(4), ARG_F64(5), ARG_F64(6), ARG_F64(7), ARG_F64(8), ARG_I32(9), ARG_I32(10), ARG_I32(11)); - } - - static void CallFunc_F64_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(double, int32_t, int32_t) = (void (*)(double, int32_t, int32_t))pcode; - (*fptr)(ARG_F64(0), ARG_I32(1), ARG_I32(2)); - } - - static void CallFunc_F64_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(double, int32_t, int32_t, int32_t, int32_t) = (void (*)(double, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_F64(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4)); - } - NOINLINE static void CallFunc_F64_I32_I32_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; @@ -561,54 +561,18 @@ namespace (*fptr)(ARG_I32(0)); } - static void CallFunc_I32_S8_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_IND(1), ARG_I32(2), ARG_I32(3)); - } - static void CallFunc_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { void (*fptr)(int32_t, int32_t) = (void (*)(int32_t, int32_t))pcode; (*fptr)(ARG_I32(0), ARG_I32(1)); } - static void CallFunc_I32_I32_S8_S8_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_IND(3), ARG_I32(4), ARG_I32(5)); - } - - static void CallFunc_I32_I32_S8_S8_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_IND(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); - } - - static void CallFunc_I32_I32_F64_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, double, int32_t) = (void (*)(int32_t, int32_t, double, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_I32(1), ARG_F64(2), ARG_I32(3)); - } - static void CallFunc_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { void (*fptr)(int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t))pcode; (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2)); } - static void CallFunc_I32_I32_I32_S8_S8_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_IND(4), ARG_I32(5)); - } - - static void CallFunc_I32_I32_I32_S8_S8_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_IND(4), ARG_I32(5), ARG_I32(6)); - } - static void CallFunc_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { void (*fptr)(int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t))pcode; @@ -621,24 +585,6 @@ namespace (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4)); } - static void CallFunc_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5)); - } - - static void CallFunc_I32_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); - } - - static void CallFunc_I32_I32_I32_I32_I64_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int64_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int64_t, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I64(4), ARG_I32(5)); - } - NOINLINE static void CallFunc_I32_I32_I32_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; @@ -660,12 +606,6 @@ namespace (*fptr)(&framePointer, ARG_I32(0), pPortableEntryPoint); } - static void CallFunc_I64_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int64_t, int32_t) = (void (*)(int64_t, int32_t))pcode; - (*fptr)(ARG_I64(0), ARG_I32(1)); - } - NOINLINE static void CallFunc_Void_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; @@ -687,10 +627,12 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "Mi", (void*)&CallFunc_Void_RetI32 }, { "MiS64i", (void*)&CallFunc_S64_I32_RetI32 }, { "MiS8", (void*)&CallFunc_S8_RetI32 }, + { "MiS8S8", (void*)&CallFunc_S8_S8_RetI32 }, { "MiS8S8S8i", (void*)&CallFunc_S8_S8_S8_I32_RetI32 }, { "MiS8S8iS8i", (void*)&CallFunc_S8_S8_I32_S8_I32_RetI32 }, { "MiS8S8ii", (void*)&CallFunc_S8_S8_I32_I32_RetI32 }, { "MiS8S8iii", (void*)&CallFunc_S8_S8_I32_I32_I32_RetI32 }, + { "MiS8S8iiiii", (void*)&CallFunc_S8_S8_I32_I32_I32_I32_I32_RetI32 }, { "MiS8i", (void*)&CallFunc_S8_I32_RetI32 }, { "MiS8iS8S8i", (void*)&CallFunc_S8_I32_S8_S8_I32_RetI32 }, { "MiS8iS8ii", (void*)&CallFunc_S8_I32_S8_I32_I32_RetI32 }, @@ -699,15 +641,25 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "MiS8iiii", (void*)&CallFunc_S8_I32_I32_I32_I32_RetI32 }, { "MiS8iiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_RetI32 }, { "MiS8iiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_RetI32 }, + { "MiS8iiiiiiiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetI32 }, { "MiTip", (void*)&CallFunc_This_I32_RetI32_PE }, { "MiTp", (void*)&CallFunc_This_RetI32_PE }, + { "Midddddddddii", (void*)&CallFunc_F64_F64_F64_F64_F64_F64_F64_F64_F64_I32_I32_RetI32 }, + { "Midi", (void*)&CallFunc_F64_I32_RetI32 }, + { "Midiii", (void*)&CallFunc_F64_I32_I32_I32_RetI32 }, { "Mii", (void*)&CallFunc_I32_RetI32 }, + { "MiiS8i", (void*)&CallFunc_I32_S8_I32_RetI32 }, { "MiiS8ii", (void*)&CallFunc_I32_S8_I32_I32_RetI32 }, { "MiiS8iiii", (void*)&CallFunc_I32_S8_I32_I32_I32_I32_RetI32 }, { "Miii", (void*)&CallFunc_I32_I32_RetI32 }, + { "MiiiS8S8i", (void*)&CallFunc_I32_I32_S8_S8_I32_RetI32 }, + { "MiiiS8S8ii", (void*)&CallFunc_I32_I32_S8_S8_I32_I32_RetI32 }, { "MiiiS8iiS8i", (void*)&CallFunc_I32_I32_S8_I32_I32_S8_I32_RetI32 }, { "MiiiS8iiiii", (void*)&CallFunc_I32_I32_S8_I32_I32_I32_I32_I32_RetI32 }, + { "Miiid", (void*)&CallFunc_I32_I32_F64_RetI32 }, { "Miiii", (void*)&CallFunc_I32_I32_I32_RetI32 }, + { "MiiiiS8S8", (void*)&CallFunc_I32_I32_I32_S8_S8_RetI32 }, + { "MiiiiS8S8i", (void*)&CallFunc_I32_I32_I32_S8_S8_I32_RetI32 }, { "MiiiiS8iiii", (void*)&CallFunc_I32_I32_I32_S8_I32_I32_I32_I32_RetI32 }, { "Miiiii", (void*)&CallFunc_I32_I32_I32_I32_RetI32 }, { "Miiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_RetI32 }, @@ -716,6 +668,7 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "Miiiiiiiiiiiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetI32 }, { "Miiiiiiip", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_RetI32_PE }, { "Miiiiiip", (void*)&CallFunc_I32_I32_I32_I32_I32_RetI32_PE }, + { "Miiiiil", (void*)&CallFunc_I32_I32_I32_I32_I64_RetI32 }, { "Miiiiip", (void*)&CallFunc_I32_I32_I32_I32_RetI32_PE }, { "Miiiil", (void*)&CallFunc_I32_I32_I32_I64_RetI32 }, { "Miiiip", (void*)&CallFunc_I32_I32_I32_RetI32_PE }, @@ -728,6 +681,7 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "Miill", (void*)&CallFunc_I32_I64_I64_RetI32 }, { "Miilli", (void*)&CallFunc_I32_I64_I64_I32_RetI32 }, { "Miip", (void*)&CallFunc_I32_RetI32_PE }, + { "Mil", (void*)&CallFunc_I64_RetI32 }, { "Mili", (void*)&CallFunc_I64_I32_RetI32 }, { "Milii", (void*)&CallFunc_I64_I32_I32_RetI32 }, { "Mililii", (void*)&CallFunc_I64_I32_I64_I32_I32_RetI32 }, @@ -735,7 +689,6 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "Ml", (void*)&CallFunc_Void_RetI64 }, { "Mli", (void*)&CallFunc_I32_RetI64 }, { "Mliii", (void*)&CallFunc_I32_I32_I32_RetI64 }, - { "Mliiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_RetI64 }, { "Mliiil", (void*)&CallFunc_I32_I32_I32_I64_RetI64 }, { "Mlili", (void*)&CallFunc_I32_I64_I32_RetI64 }, { "Mlillp", (void*)&CallFunc_I32_I64_I64_RetI64_PE }, @@ -744,40 +697,17 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "Mlllp", (void*)&CallFunc_I64_I64_RetI64_PE }, { "Mlp", (void*)&CallFunc_Void_RetI64_PE }, { "Mv", (void*)&CallFunc_Void_RetVoid }, - { "MvS8S8i", (void*)&CallFunc_S8_S8_I32_RetVoid }, - { "MvS8S8iiiiii", (void*)&CallFunc_S8_S8_I32_I32_I32_I32_I32_I32_RetVoid }, - { "MvS8i", (void*)&CallFunc_S8_I32_RetVoid }, - { "MvS8ii", (void*)&CallFunc_S8_I32_I32_RetVoid }, - { "MvS8iii", (void*)&CallFunc_S8_I32_I32_I32_RetVoid }, - { "MvS8iiii", (void*)&CallFunc_S8_I32_I32_I32_I32_RetVoid }, - { "MvS8iiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_RetVoid }, - { "MvS8iiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_RetVoid }, - { "MvS8iiiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_RetVoid }, - { "MvS8iiiiiiiiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetVoid }, { "MvTp", (void*)&CallFunc_This_RetVoid_PE }, - { "Mvdddddddddiii", (void*)&CallFunc_F64_F64_F64_F64_F64_F64_F64_F64_F64_I32_I32_I32_RetVoid }, - { "Mvdii", (void*)&CallFunc_F64_I32_I32_RetVoid }, - { "Mvdiiii", (void*)&CallFunc_F64_I32_I32_I32_I32_RetVoid }, { "Mvdiip", (void*)&CallFunc_F64_I32_I32_RetVoid_PE }, { "Mvfiip", (void*)&CallFunc_F32_I32_I32_RetVoid_PE }, { "Mvi", (void*)&CallFunc_I32_RetVoid }, - { "MviS8ii", (void*)&CallFunc_I32_S8_I32_I32_RetVoid }, { "Mvii", (void*)&CallFunc_I32_I32_RetVoid }, - { "MviiS8S8ii", (void*)&CallFunc_I32_I32_S8_S8_I32_I32_RetVoid }, - { "MviiS8S8iii", (void*)&CallFunc_I32_I32_S8_S8_I32_I32_I32_RetVoid }, - { "Mviidi", (void*)&CallFunc_I32_I32_F64_I32_RetVoid }, { "Mviii", (void*)&CallFunc_I32_I32_I32_RetVoid }, - { "MviiiS8S8i", (void*)&CallFunc_I32_I32_I32_S8_S8_I32_RetVoid }, - { "MviiiS8S8ii", (void*)&CallFunc_I32_I32_I32_S8_S8_I32_I32_RetVoid }, { "Mviiii", (void*)&CallFunc_I32_I32_I32_I32_RetVoid }, { "Mviiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_RetVoid }, - { "Mviiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_RetVoid }, - { "Mviiiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_I32_RetVoid }, - { "Mviiiili", (void*)&CallFunc_I32_I32_I32_I32_I64_I32_RetVoid }, { "Mviiip", (void*)&CallFunc_I32_I32_I32_RetVoid_PE }, { "Mviip", (void*)&CallFunc_I32_I32_RetVoid_PE }, { "Mvip", (void*)&CallFunc_I32_RetVoid_PE }, - { "Mvli", (void*)&CallFunc_I64_I32_RetVoid }, { "Mvp", (void*)&CallFunc_Void_RetVoid_PE } }; diff --git a/src/coreclr/vm/wasm/entrypoints.h b/src/coreclr/vm/wasm/entrypoints.h index b7a92b9cc60af1..01c87fb061efab 100644 --- a/src/coreclr/vm/wasm/entrypoints.h +++ b/src/coreclr/vm/wasm/entrypoints.h @@ -22,11 +22,11 @@ extern "C" void SystemJS_DiagnosticServerQueueJob(size_t (*cb)(void *data), void // the WasiEventLoop pump when WasiFinalizer_TryClearPending returns true. // Same implementation as browser's SystemJS_ExecuteFinalizationCallback, just // exported under a WASI-specific symbol; see src/coreclr/vm/finalizerthread.cpp. -extern "C" void QCALLTYPE WasiFinalizer_RunWorker(QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE WasiFinalizer_RunWorker(); // Atomic-flag drain used by managed WasiEventLoop to learn whether a GC has // requested finalization since the last poll. Returns TRUE once per scheduled // finalization, FALSE otherwise. -extern "C" CLR_BOOL QCALLTYPE WasiFinalizer_TryClearPending(QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE WasiFinalizer_TryClearPending(CLR_BOOL* pReturnValue); #endif // TARGET_WASI #endif // HAVE_WASM_ENTRYPOINTS_H \ No newline at end of file diff --git a/src/coreclr/vm/wasm/wasi/callhelpers-interp-to-managed.cpp b/src/coreclr/vm/wasm/wasi/callhelpers-interp-to-managed.cpp index 073e10d6b3cf57..b5ae76b7b92d5e 100644 --- a/src/coreclr/vm/wasm/wasi/callhelpers-interp-to-managed.cpp +++ b/src/coreclr/vm/wasm/wasi/callhelpers-interp-to-managed.cpp @@ -100,6 +100,12 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_IND(0)); } + static void CallFunc_S8_S8_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(int32_t, int32_t) = (int32_t (*)(int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1)); + } + static void CallFunc_S8_S8_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t))pcode; @@ -124,6 +130,12 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_I32(3), ARG_I32(4)); } + static void CallFunc_S8_S8_I32_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); + } + static void CallFunc_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t, int32_t) = (int32_t (*)(int32_t, int32_t))pcode; @@ -172,6 +184,12 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); } + static void CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7), ARG_I32(8), ARG_I32(9), ARG_I32(10), ARG_I32(11)); + } + NOINLINE static void CallFunc_This_I32_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; @@ -192,6 +210,12 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_I32(0)); } + static void CallFunc_I32_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_IND(1), ARG_I32(2)); + } + static void CallFunc_I32_S8_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t))pcode; @@ -210,6 +234,18 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1)); } + static void CallFunc_I32_I32_S8_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_IND(3), ARG_I32(4)); + } + + static void CallFunc_I32_I32_S8_S8_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_IND(3), ARG_I32(4), ARG_I32(5)); + } + static void CallFunc_I32_I32_S8_I32_I32_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; @@ -228,6 +264,18 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2)); } + static void CallFunc_I32_I32_I32_S8_S8_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_IND(4)); + } + + static void CallFunc_I32_I32_I32_S8_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_IND(4), ARG_I32(5)); + } + static void CallFunc_I32_I32_I32_S8_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; @@ -456,66 +504,6 @@ namespace (*fptr)(); } - static void CallFunc_S8_S8_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2)); - } - - static void CallFunc_S8_S8_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7)); - } - - static void CallFunc_S8_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t) = (void (*)(int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_I32(1)); - } - - static void CallFunc_S8_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2)); - } - - static void CallFunc_S8_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3)); - } - - static void CallFunc_S8_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4)); - } - - static void CallFunc_S8_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5)); - } - - static void CallFunc_S8_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); - } - - static void CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7)); - } - - static void CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7), ARG_I32(8), ARG_I32(9), ARG_I32(10), ARG_I32(11), ARG_I32(12)); - } - NOINLINE static void CallFunc_This_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; @@ -543,48 +531,18 @@ namespace (*fptr)(ARG_I32(0)); } - static void CallFunc_I32_S8_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_IND(1), ARG_I32(2), ARG_I32(3)); - } - static void CallFunc_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { void (*fptr)(int32_t, int32_t) = (void (*)(int32_t, int32_t))pcode; (*fptr)(ARG_I32(0), ARG_I32(1)); } - static void CallFunc_I32_I32_S8_S8_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_IND(3), ARG_I32(4), ARG_I32(5)); - } - - static void CallFunc_I32_I32_S8_S8_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_IND(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); - } - static void CallFunc_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { void (*fptr)(int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t))pcode; (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2)); } - static void CallFunc_I32_I32_I32_S8_S8_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_IND(4), ARG_I32(5)); - } - - static void CallFunc_I32_I32_I32_S8_S8_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_IND(4), ARG_I32(5), ARG_I32(6)); - } - static void CallFunc_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { void (*fptr)(int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t))pcode; @@ -597,18 +555,6 @@ namespace (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4)); } - static void CallFunc_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5)); - } - - static void CallFunc_I32_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); - } - NOINLINE static void CallFunc_I32_I32_I32_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; @@ -636,12 +582,6 @@ namespace (*fptr)(&framePointer, ARG_I32(0), pPortableEntryPoint); } - static void CallFunc_I64_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - void (*fptr)(int64_t, int32_t) = (void (*)(int64_t, int32_t))pcode; - (*fptr)(ARG_I64(0), ARG_I32(1)); - } - NOINLINE static void CallFunc_Void_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; @@ -663,10 +603,12 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "Mi", (void*)&CallFunc_Void_RetI32 }, { "MiS64i", (void*)&CallFunc_S64_I32_RetI32 }, { "MiS8", (void*)&CallFunc_S8_RetI32 }, + { "MiS8S8", (void*)&CallFunc_S8_S8_RetI32 }, { "MiS8S8S8i", (void*)&CallFunc_S8_S8_S8_I32_RetI32 }, { "MiS8S8iS8i", (void*)&CallFunc_S8_S8_I32_S8_I32_RetI32 }, { "MiS8S8ii", (void*)&CallFunc_S8_S8_I32_I32_RetI32 }, { "MiS8S8iii", (void*)&CallFunc_S8_S8_I32_I32_I32_RetI32 }, + { "MiS8S8iiiii", (void*)&CallFunc_S8_S8_I32_I32_I32_I32_I32_RetI32 }, { "MiS8i", (void*)&CallFunc_S8_I32_RetI32 }, { "MiS8iS8S8i", (void*)&CallFunc_S8_I32_S8_S8_I32_RetI32 }, { "MiS8iS8ii", (void*)&CallFunc_S8_I32_S8_I32_I32_RetI32 }, @@ -675,15 +617,21 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "MiS8iiii", (void*)&CallFunc_S8_I32_I32_I32_I32_RetI32 }, { "MiS8iiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_RetI32 }, { "MiS8iiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_RetI32 }, + { "MiS8iiiiiiiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetI32 }, { "MiTip", (void*)&CallFunc_This_I32_RetI32_PE }, { "MiTp", (void*)&CallFunc_This_RetI32_PE }, { "Mii", (void*)&CallFunc_I32_RetI32 }, + { "MiiS8i", (void*)&CallFunc_I32_S8_I32_RetI32 }, { "MiiS8ii", (void*)&CallFunc_I32_S8_I32_I32_RetI32 }, { "MiiS8iiii", (void*)&CallFunc_I32_S8_I32_I32_I32_I32_RetI32 }, { "Miii", (void*)&CallFunc_I32_I32_RetI32 }, + { "MiiiS8S8i", (void*)&CallFunc_I32_I32_S8_S8_I32_RetI32 }, + { "MiiiS8S8ii", (void*)&CallFunc_I32_I32_S8_S8_I32_I32_RetI32 }, { "MiiiS8iiS8i", (void*)&CallFunc_I32_I32_S8_I32_I32_S8_I32_RetI32 }, { "MiiiS8iiiii", (void*)&CallFunc_I32_I32_S8_I32_I32_I32_I32_I32_RetI32 }, { "Miiii", (void*)&CallFunc_I32_I32_I32_RetI32 }, + { "MiiiiS8S8", (void*)&CallFunc_I32_I32_I32_S8_S8_RetI32 }, + { "MiiiiS8S8i", (void*)&CallFunc_I32_I32_I32_S8_S8_I32_RetI32 }, { "MiiiiS8iiii", (void*)&CallFunc_I32_I32_I32_S8_I32_I32_I32_I32_RetI32 }, { "Miiiii", (void*)&CallFunc_I32_I32_I32_I32_RetI32 }, { "Miiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_RetI32 }, @@ -720,36 +668,18 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "Mlllp", (void*)&CallFunc_I64_I64_RetI64_PE }, { "Mlp", (void*)&CallFunc_Void_RetI64_PE }, { "Mv", (void*)&CallFunc_Void_RetVoid }, - { "MvS8S8i", (void*)&CallFunc_S8_S8_I32_RetVoid }, - { "MvS8S8iiiiii", (void*)&CallFunc_S8_S8_I32_I32_I32_I32_I32_I32_RetVoid }, - { "MvS8i", (void*)&CallFunc_S8_I32_RetVoid }, - { "MvS8ii", (void*)&CallFunc_S8_I32_I32_RetVoid }, - { "MvS8iii", (void*)&CallFunc_S8_I32_I32_I32_RetVoid }, - { "MvS8iiii", (void*)&CallFunc_S8_I32_I32_I32_I32_RetVoid }, - { "MvS8iiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_RetVoid }, - { "MvS8iiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_RetVoid }, - { "MvS8iiiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_RetVoid }, - { "MvS8iiiiiiiiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetVoid }, { "MvTp", (void*)&CallFunc_This_RetVoid_PE }, { "Mvdiip", (void*)&CallFunc_F64_I32_I32_RetVoid_PE }, { "Mvfiip", (void*)&CallFunc_F32_I32_I32_RetVoid_PE }, { "Mvi", (void*)&CallFunc_I32_RetVoid }, - { "MviS8ii", (void*)&CallFunc_I32_S8_I32_I32_RetVoid }, { "Mvii", (void*)&CallFunc_I32_I32_RetVoid }, - { "MviiS8S8ii", (void*)&CallFunc_I32_I32_S8_S8_I32_I32_RetVoid }, - { "MviiS8S8iii", (void*)&CallFunc_I32_I32_S8_S8_I32_I32_I32_RetVoid }, { "Mviii", (void*)&CallFunc_I32_I32_I32_RetVoid }, - { "MviiiS8S8i", (void*)&CallFunc_I32_I32_I32_S8_S8_I32_RetVoid }, - { "MviiiS8S8ii", (void*)&CallFunc_I32_I32_I32_S8_S8_I32_I32_RetVoid }, { "Mviiii", (void*)&CallFunc_I32_I32_I32_I32_RetVoid }, { "Mviiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_RetVoid }, - { "Mviiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_RetVoid }, - { "Mviiiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_I32_RetVoid }, { "Mviiip", (void*)&CallFunc_I32_I32_I32_RetVoid_PE }, { "Mviip", (void*)&CallFunc_I32_I32_RetVoid_PE }, { "Mvili", (void*)&CallFunc_I32_I64_I32_RetVoid }, { "Mvip", (void*)&CallFunc_I32_RetVoid_PE }, - { "Mvli", (void*)&CallFunc_I64_I32_RetVoid }, { "Mvp", (void*)&CallFunc_Void_RetVoid_PE } }; diff --git a/src/coreclr/vm/weakreferencenative.cpp b/src/coreclr/vm/weakreferencenative.cpp index 69be1f3c8a16b7..e92d63b518df48 100644 --- a/src/coreclr/vm/weakreferencenative.cpp +++ b/src/coreclr/vm/weakreferencenative.cpp @@ -47,7 +47,7 @@ void FinalizeWeakReference(Object* obj) #if defined(FEATURE_COMINTEROP) -extern "C" void QCALLTYPE ComWeakRefToObject(IWeakReference* pComWeakReference, QCall::ObjectHandleOnStack retRcw, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ComWeakRefToObject(IWeakReference* pComWeakReference, QCall::ObjectHandleOnStack retRcw) { QCALL_CONTRACT; BEGIN_QCALL; @@ -85,10 +85,10 @@ extern "C" void QCALLTYPE ComWeakRefToObject(IWeakReference* pComWeakReference, } END_QCALL; - return; + } -extern "C" IWeakReference * QCALLTYPE ObjectToComWeakRef(QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError) +extern "C" QCallExceptionStatus QCALLTYPE ObjectToComWeakRef(QCall::ObjectHandleOnStack obj, IWeakReference ** pReturnValue) { QCALL_CONTRACT; @@ -127,7 +127,8 @@ extern "C" IWeakReference * QCALLTYPE ObjectToComWeakRef(QCall::ObjectHandleOnSt } } + *pReturnValue = pWeakReference; + END_QCALL; - return pWeakReference; } #endif // FEATURE_COMINTEROP diff --git a/src/coreclr/vm/weakreferencenative.h b/src/coreclr/vm/weakreferencenative.h index d871a7c6780896..9ff92dd1fa89e2 100644 --- a/src/coreclr/vm/weakreferencenative.h +++ b/src/coreclr/vm/weakreferencenative.h @@ -15,8 +15,8 @@ #ifdef FEATURE_COMINTEROP -extern "C" void QCALLTYPE ComWeakRefToObject(IWeakReference * pComWeakReference, QCall::ObjectHandleOnStack retRcw, QCallExceptionStatus* qcallError); -extern "C" IWeakReference * QCALLTYPE ObjectToComWeakRef(QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError); +extern "C" QCallExceptionStatus QCALLTYPE ComWeakRefToObject(IWeakReference * pComWeakReference, QCall::ObjectHandleOnStack retRcw); +extern "C" QCallExceptionStatus QCALLTYPE ObjectToComWeakRef(QCall::ObjectHandleOnStack obj, IWeakReference ** pReturnValue); #endif // FEATURE_COMINTEROP diff --git a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems index 3a09bcb0146c72..2a189b726e28e8 100644 --- a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems +++ b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems @@ -1034,6 +1034,7 @@ + diff --git a/src/libraries/System.Private.CoreLib/src/System/AppContext.cs b/src/libraries/System.Private.CoreLib/src/System/AppContext.cs index e98da2b103c95b..55828ebf107788 100644 --- a/src/libraries/System.Private.CoreLib/src/System/AppContext.cs +++ b/src/libraries/System.Private.CoreLib/src/System/AppContext.cs @@ -54,11 +54,6 @@ public static partial class AppContext { string? value = null; if (TryGetHostPropertyValue(name, new StringHandleOnStack(ref value) -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif )) { lock (s_dataStore) diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.Internal.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.Internal.cs index 19ffec5b8b2c4c..69e68ba7187ba3 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.Internal.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.Internal.cs @@ -15,129 +15,105 @@ internal static partial class EventPipeInternal // // These PInvokes are used by the configuration APIs to interact with EventPipe. // - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_Enable")] +#if CORECLR + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] +#endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_Enable")] private static unsafe partial ulong Enable( char* outputFile, EventPipeSerializationFormat format, uint circularBufferSizeInMB, EventPipeProviderConfigurationNative* providers, uint numProviders -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_Disable")] - internal static partial void Disable(ulong sessionID #if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_Disable")] + internal static partial void Disable(ulong sessionID ); // // These PInvokes are used by EventSource to interact with the EventPipe. // - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_CreateProvider", StringMarshalling = StringMarshalling.Utf16)] +#if CORECLR + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] +#endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_CreateProvider", StringMarshalling = StringMarshalling.Utf16)] internal static unsafe partial IntPtr CreateProvider(string providerName, delegate* unmanaged callbackFunc, void* callbackContext -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_DefineEvent")] - internal static unsafe partial IntPtr DefineEvent(IntPtr provHandle, uint eventID, long keywords, uint eventVersion, uint level, void *pMetadata, uint metadataLength #if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_DefineEvent")] + internal static unsafe partial IntPtr DefineEvent(IntPtr provHandle, uint eventID, long keywords, uint eventVersion, uint level, void *pMetadata, uint metadataLength ); - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_GetProvider", StringMarshalling = StringMarshalling.Utf16)] - internal static partial IntPtr GetProvider(string providerName #if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_GetProvider", StringMarshalling = StringMarshalling.Utf16)] + internal static partial IntPtr GetProvider(string providerName ); - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_DeleteProvider")] - internal static partial void DeleteProvider(IntPtr provHandle #if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_DeleteProvider")] + internal static partial void DeleteProvider(IntPtr provHandle ); - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_EventActivityIdControl")] - internal static partial int EventActivityIdControl(uint controlCode, ref Guid activityId #if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_EventActivityIdControl")] + internal static partial int EventActivityIdControl(uint controlCode, ref Guid activityId ); - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_WriteEventData")] - internal static unsafe partial void WriteEventData(IntPtr eventHandle, EventProvider.EventData* pEventData, uint dataCount, Guid* activityId, Guid* relatedActivityId #if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_WriteEventData")] + internal static unsafe partial void WriteEventData(IntPtr eventHandle, EventProvider.EventData* pEventData, uint dataCount, Guid* activityId, Guid* relatedActivityId ); // // These PInvokes are used as part of the EventPipeEventDispatcher. // - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_GetSessionInfo")] - [return: MarshalAs(UnmanagedType.Bool)] - internal static unsafe partial bool GetSessionInfo(ulong sessionID, EventPipeSessionInfo* pSessionInfo #if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_GetSessionInfo")] + [return: MarshalAs(UnmanagedType.Bool)] + internal static unsafe partial bool GetSessionInfo(ulong sessionID, EventPipeSessionInfo* pSessionInfo ); - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_GetNextEvent")] - [return: MarshalAs(UnmanagedType.Bool)] - internal static unsafe partial bool GetNextEvent(ulong sessionID, EventPipeEventInstanceData* pInstance #if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_GetNextEvent")] + [return: MarshalAs(UnmanagedType.Bool)] + internal static unsafe partial bool GetNextEvent(ulong sessionID, EventPipeEventInstanceData* pInstance ); - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_SignalSession")] - [return: MarshalAs(UnmanagedType.Bool)] - internal static unsafe partial bool SignalSession(ulong sessionID #if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_SignalSession")] + [return: MarshalAs(UnmanagedType.Bool)] + internal static unsafe partial bool SignalSession(ulong sessionID ); - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_WaitForSessionSignal")] - [return: MarshalAs(UnmanagedType.Bool)] - internal static unsafe partial bool WaitForSessionSignal(ulong sessionID, int timeoutMs #if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_WaitForSessionSignal")] + [return: MarshalAs(UnmanagedType.Bool)] + internal static unsafe partial bool WaitForSessionSignal(ulong sessionID, int timeoutMs ); #else #pragma warning disable IDE0060 diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.cs index a022b61b7c3ddb..e52efc6d1c2324 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.cs @@ -132,11 +132,6 @@ internal static unsafe ulong Enable( fixed (EventPipeProviderConfigurationNative* providersNativePointer = providersNative) { return Enable(outputFilePath, format, circularBufferSizeInMB, providersNativePointer, (uint)providersNative.Length -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Threads.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Threads.cs index ebbec167c960d3..dc2b4fdff89f12 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Threads.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Threads.cs @@ -35,11 +35,6 @@ private void DispatchEventsToEventListeners(ulong sessionID, DateTime syncTimeUt if (!eventsReceived) { EventPipeInternal.WaitForSessionSignal(sessionID, Timeout.Infinite -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } @@ -58,11 +53,6 @@ private void DispatchEventsToEventListeners(ulong sessionID, DateTime syncTimeUt // Disable the old session. This can happen asynchronously since we aren't using the old session // anymore. EventPipeInternal.Disable(sessionID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Wasm.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Wasm.cs index 677894c0d87f5d..79adf7f53dee7f 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Wasm.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Wasm.cs @@ -45,11 +45,6 @@ private async Task DispatchEventsToEventListeners(ulong sessionID, DateTime sync await Task.Yield(); EventPipeInternal.Disable(sessionID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.cs index 573f1d7c426e1a..aaccb4137c9db0 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.cs @@ -42,11 +42,6 @@ private EventPipeEventDispatcher() { // Get the ID of the runtime provider so that it can be used as a filter when processing events. m_RuntimeProviderID = EventPipeInternal.GetProvider(NativeRuntimeEventSource.EventSourceName -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } @@ -119,11 +114,6 @@ private void CommitDispatchConfiguration() unsafe { if (!EventPipeInternal.GetSessionInfo(sessionID, &sessionInfo -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif )) { Debug.Fail("GetSessionInfo returned false."); @@ -155,11 +145,6 @@ private void SetStopDispatchTask() Debug.Assert(sessionID != 0); m_dispatchTaskCancellationSource.Cancel(); EventPipeInternal.SignalSession(sessionID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); Volatile.Write(ref m_sessionID, 0); } @@ -173,11 +158,6 @@ private unsafe bool DispatchEventsToEventListenersOnce(ulong sessionID, DateTime // Get the next event. while (!token.IsCancellationRequested && EventPipeInternal.GetNextEvent(sessionID, &instanceData -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif )) { eventsReceived = true; diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventProvider.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventProvider.cs index 7c4ea276846c98..8a058cb6c4eb16 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventProvider.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventProvider.cs @@ -77,11 +77,6 @@ internal override unsafe void Register(Guid id, string name) _gcHandle = new GCHandle(this); _provHandle = EventPipeInternal.CreateProvider(name, &Callback, (void*)GCHandle.ToIntPtr(_gcHandle) -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); if (_provHandle == 0) { @@ -100,11 +95,6 @@ internal override void Unregister() if (_provHandle != 0) { EventPipeInternal.DeleteProvider(_provHandle -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); _provHandle = 0; } @@ -125,11 +115,6 @@ internal override unsafe EventProvider.WriteEventErrorCode EventWriteTransfer( if (userDataCount == 0) { EventPipeInternal.WriteEventData(eventHandle, null, 0, activityId, relatedActivityId -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); return EventProvider.WriteEventErrorCode.NoError; } @@ -144,11 +129,6 @@ internal override unsafe EventProvider.WriteEventErrorCode EventWriteTransfer( Debug.Assert(userDataCount >= 0); } EventPipeInternal.WriteEventData(eventHandle, userData, (uint)userDataCount, activityId, relatedActivityId -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } @@ -166,11 +146,6 @@ internal override unsafe IntPtr DefineEventHandle(uint eventID, string eventName byte* pMetadata, uint metadataLength) { return EventPipeInternal.DefineEvent(_provHandle, eventID, keywords, eventVersion, level, pMetadata, metadataLength -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } @@ -178,11 +153,6 @@ internal override unsafe IntPtr DefineEventHandle(uint eventID, string eventName internal static int EventActivityIdControl(Interop.Advapi32.ActivityControl controlCode, ref Guid activityId) { return EventPipeInternal.EventActivityIdControl((uint)controlCode, ref activityId -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs index bd5a4724450510..f04ab4cada5fe5 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs @@ -9,105 +9,90 @@ namespace System.Diagnostics.Tracing internal sealed partial class NativeRuntimeEventSource : EventSource { [NonEvent] - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogContentionLockCreated")] - private static partial void LogContentionLockCreated(nint LockID, nint AssociatedObjectID, ushort ClrInstanceID #if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogContentionLockCreated")] + private static partial void LogContentionLockCreated(nint LockID, nint AssociatedObjectID, ushort ClrInstanceID ); [NonEvent] - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogContentionStart")] +#if CORECLR + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] +#endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogContentionStart")] private static partial void LogContentionStart( ContentionFlagsMap ContentionFlags, ushort ClrInstanceID, nint LockID, nint AssociatedObjectID, ulong LockOwnerThreadID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); [NonEvent] - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogContentionStop")] +#if CORECLR + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] +#endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogContentionStop")] private static partial void LogContentionStop( ContentionFlagsMap ContentionFlags, ushort ClrInstanceID, double DurationNs -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); [NonEvent] - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadStart")] - private static partial void LogThreadPoolWorkerThreadStart(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID #if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadStart")] + private static partial void LogThreadPoolWorkerThreadStart(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID ); [NonEvent] - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop")] - private static partial void LogThreadPoolWorkerThreadStop(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID #if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop")] + private static partial void LogThreadPoolWorkerThreadStop(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID ); [NonEvent] - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait")] - private static partial void LogThreadPoolWorkerThreadWait(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID #if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait")] + private static partial void LogThreadPoolWorkerThreadWait(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID ); [NonEvent] - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolMinMaxThreads")] - private static partial void LogThreadPoolMinMaxThreads(ushort MinWorkerThreads, ushort MaxWorkerThreads, ushort MinIOCompletionThreads, ushort MaxIOCompletionThreads, ushort ClrInstanceID #if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolMinMaxThreads")] + private static partial void LogThreadPoolMinMaxThreads(ushort MinWorkerThreads, ushort MaxWorkerThreads, ushort MinIOCompletionThreads, ushort MaxIOCompletionThreads, ushort ClrInstanceID ); [NonEvent] - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentSample")] - private static partial void LogThreadPoolWorkerThreadAdjustmentSample(double Throughput, ushort ClrInstanceID #if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentSample")] + private static partial void LogThreadPoolWorkerThreadAdjustmentSample(double Throughput, ushort ClrInstanceID ); [NonEvent] - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentAdjustment")] - private static partial void LogThreadPoolWorkerThreadAdjustmentAdjustment(double AverageThroughput, uint NewWorkerThreadCount, ThreadAdjustmentReasonMap Reason, ushort ClrInstanceID #if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentAdjustment")] + private static partial void LogThreadPoolWorkerThreadAdjustmentAdjustment(double AverageThroughput, uint NewWorkerThreadCount, ThreadAdjustmentReasonMap Reason, ushort ClrInstanceID ); [NonEvent] - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentStats")] +#if CORECLR + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] +#endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentStats")] private static partial void LogThreadPoolWorkerThreadAdjustmentStats( double Duration, double Throughput, @@ -120,86 +105,69 @@ private static partial void LogThreadPoolWorkerThreadAdjustmentStats( double NewControlSetting, ushort NewThreadWaveMagnitude, ushort ClrInstanceID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); [NonEvent] - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolIOEnqueue")] +#if CORECLR + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] +#endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolIOEnqueue")] private static partial void LogThreadPoolIOEnqueue( IntPtr NativeOverlapped, IntPtr Overlapped, [MarshalAs(UnmanagedType.Bool)] bool MultiDequeues, ushort ClrInstanceID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); [NonEvent] - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolIODequeue")] +#if CORECLR + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] +#endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolIODequeue")] private static partial void LogThreadPoolIODequeue( IntPtr NativeOverlapped, IntPtr Overlapped, ushort ClrInstanceID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); [NonEvent] - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkingThreadCount")] +#if CORECLR + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] +#endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkingThreadCount")] private static partial void LogThreadPoolWorkingThreadCount( uint Count, ushort ClrInstanceID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); [NonEvent] - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolIOPack")] +#if CORECLR + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] +#endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolIOPack")] private static partial void LogThreadPoolIOPack( IntPtr NativeOverlapped, IntPtr Overlapped, ushort ClrInstanceID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); [NonEvent] - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogWaitHandleWaitStart")] +#if CORECLR + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] +#endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogWaitHandleWaitStart")] private static partial void LogWaitHandleWaitStart( WaitHandleWaitSourceMap WaitSource, IntPtr AssociatedObjectID, ushort ClrInstanceID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); [NonEvent] - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogWaitHandleWaitStop")] - private static partial void LogWaitHandleWaitStop(ushort ClrInstanceID #if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogWaitHandleWaitStop")] + private static partial void LogWaitHandleWaitStop(ushort ClrInstanceID ); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.cs index 1268029df94ef3..c11b1f7dabbeea 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.cs @@ -81,11 +81,6 @@ private void ContentionLockCreated(nint LockID, nint AssociatedObjectID, ushort { Debug.Assert(IsEnabled(EventLevel.Informational, Keywords.ContentionKeyword)); LogContentionLockCreated(LockID, AssociatedObjectID, ClrInstanceID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } @@ -108,11 +103,6 @@ private void ContentionStart( { Debug.Assert(IsEnabled(EventLevel.Informational, Keywords.ContentionKeyword)); LogContentionStart(ContentionFlags, ClrInstanceID, LockID, AssociatedObjectID, LockOwnerThreadID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } @@ -133,11 +123,6 @@ private void ContentionStop(ContentionFlagsMap ContentionFlags, ushort ClrInstan { Debug.Assert(IsEnabled(EventLevel.Informational, Keywords.ContentionKeyword)); LogContentionStop(ContentionFlags, ClrInstanceID, DurationNs -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } @@ -155,11 +140,6 @@ public void ThreadPoolWorkerThreadStart( if (IsEnabled(EventLevel.Informational, Keywords.ThreadingKeyword)) { LogThreadPoolWorkerThreadStart(ActiveWorkerThreadCount, RetiredWorkerThreadCount, ClrInstanceID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } } @@ -173,11 +153,6 @@ public void ThreadPoolWorkerThreadStop( if (IsEnabled(EventLevel.Informational, Keywords.ThreadingKeyword)) { LogThreadPoolWorkerThreadStop(ActiveWorkerThreadCount, RetiredWorkerThreadCount, ClrInstanceID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } } @@ -192,11 +167,6 @@ public void ThreadPoolWorkerThreadWait( if (IsEnabled(EventLevel.Informational, Keywords.ThreadingKeyword)) { LogThreadPoolWorkerThreadWait(ActiveWorkerThreadCount, RetiredWorkerThreadCount, ClrInstanceID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } } @@ -211,11 +181,6 @@ public void ThreadPoolWorkerThreadAdjustmentSample( return; } LogThreadPoolWorkerThreadAdjustmentSample(Throughput, ClrInstanceID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } @@ -231,11 +196,6 @@ public void ThreadPoolWorkerThreadAdjustmentAdjustment( return; } LogThreadPoolWorkerThreadAdjustmentAdjustment(AverageThroughput, NewWorkerThreadCount, Reason, ClrInstanceID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } @@ -258,11 +218,6 @@ public void ThreadPoolWorkerThreadAdjustmentStats( return; } LogThreadPoolWorkerThreadAdjustmentStats(Duration, Throughput, ThreadWave, ThroughputWave, ThroughputErrorEstimate, AverageThroughputErrorEstimate, ThroughputRatio, Confidence, NewControlSetting, NewThreadWaveMagnitude, ClrInstanceID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } @@ -274,11 +229,6 @@ private void ThreadPoolIOEnqueue( ushort ClrInstanceID = DefaultClrInstanceId) { LogThreadPoolIOEnqueue(NativeOverlapped, Overlapped, MultiDequeues, ClrInstanceID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } @@ -321,11 +271,6 @@ private void ThreadPoolIODequeue( ushort ClrInstanceID = DefaultClrInstanceId) { LogThreadPoolIODequeue(NativeOverlapped, Overlapped, ClrInstanceID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } @@ -366,11 +311,6 @@ public void ThreadPoolWorkingThreadCount(uint Count, ushort ClrInstanceID = Defa return; } LogThreadPoolWorkingThreadCount(Count, ClrInstanceID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } @@ -398,11 +338,6 @@ private void ThreadPoolIOPack( ushort ClrInstanceID = DefaultClrInstanceId) { LogThreadPoolIOPack(NativeOverlapped, Overlapped, ClrInstanceID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } @@ -418,11 +353,6 @@ public void ThreadPoolMinMaxThreads( if (IsEnabled(EventLevel.Informational, Keywords.ThreadingKeyword)) { LogThreadPoolMinMaxThreads(MinWorkerThreads, MaxWorkerThreads, MinIOCompletionThreads, MaxIOCompletionThreads, ClrInstanceID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } } @@ -435,11 +365,6 @@ private void WaitHandleWaitStart( { Debug.Assert(IsEnabled(EventLevel.Verbose, Keywords.WaitHandleKeyword)); LogWaitHandleWaitStart(WaitSource, AssociatedObjectID, ClrInstanceID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } @@ -455,11 +380,6 @@ public void WaitHandleWaitStop(ushort ClrInstanceID = DefaultClrInstanceId) { Debug.Assert(IsEnabled(EventLevel.Verbose, Keywords.WaitHandleKeyword)); LogWaitHandleWaitStop(ClrInstanceID -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs index 50b4df7f0117bc..67f8b3fea5cf65 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs @@ -20,20 +20,13 @@ public XplatEventLogger() { } private static readonly string s_eventSourceEventFilter = GetClrConfig("EventNameFilter"); private static unsafe string GetClrConfig(string configName) => new string(EventSource_GetClrConfig(configName -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif )); - [LibraryImport(RuntimeHelpers.QCall, StringMarshalling = StringMarshalling.Utf16)] - private static unsafe partial char* EventSource_GetClrConfig(string configName #if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif + [LibraryImport(RuntimeHelpers.QCall, StringMarshalling = StringMarshalling.Utf16)] + private static unsafe partial char* EventSource_GetClrConfig(string configName ); private static bool initializedPersistentListener; @@ -59,23 +52,19 @@ out _ return null; } - [LibraryImport(RuntimeHelpers.QCall)] - [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool IsEventSourceLoggingEnabled( #if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif + [LibraryImport(RuntimeHelpers.QCall)] + [return: MarshalAs(UnmanagedType.Bool)] + private static partial bool IsEventSourceLoggingEnabled( ); - [LibraryImport(RuntimeHelpers.QCall, StringMarshalling = StringMarshalling.Utf16)] - private static partial void LogEventSource(int eventID, string? eventName, string eventSourceName, string payload #if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif + [LibraryImport(RuntimeHelpers.QCall, StringMarshalling = StringMarshalling.Utf16)] + private static partial void LogEventSource(int eventID, string? eventName, string eventSourceName, string payload ); private static readonly List escape_seq = new List { '\b', '\f', '\n', '\r', '\t', '\"', '\\' }; @@ -226,11 +215,6 @@ private static void LogOnEventWritten(EventWrittenEventArgs eventData) } LogEventSource(eventData.EventId, eventData.EventName, eventData.EventSource.Name, payload -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Environment.cs b/src/libraries/System.Private.CoreLib/src/System/Environment.cs index 451a290a48f07a..1e5eb2333e2b47 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Environment.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Environment.cs @@ -40,7 +40,7 @@ public readonly struct ProcessCpuUsage /// internal static bool IsSingleProcessor => RuntimeFeature.IsMultithreadingSupported ? ProcessorCount == 1 : true; #if CORECLR - public static int ProcessorCount { get; } = RuntimeFeature.IsMultithreadingSupported ? GetProcessorCount(out _) : 1; + public static int ProcessorCount { get; } = RuntimeFeature.IsMultithreadingSupported ? GetProcessorCount() : 1; #else public static int ProcessorCount { get; } = RuntimeFeature.IsMultithreadingSupported ? GetProcessorCount() : 1; #endif diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.cs index a214becae7b9f2..cf36be5c39edc6 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.cs @@ -480,7 +480,7 @@ internal sealed unsafe partial class ManagedObjectWrapperHolder static ManagedObjectWrapperHolder() { #if CORECLR - RegisterIsRootedCallback(out _); + RegisterIsRootedCallback(); #else RegisterIsRootedCallback(); #endif diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ErrorHandlerAttribute.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ErrorHandlerAttribute.cs new file mode 100644 index 00000000000000..90073a27d34ead --- /dev/null +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ErrorHandlerAttribute.cs @@ -0,0 +1,27 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#if CORECLR + +namespace System.Runtime.InteropServices +{ + internal enum ErrorLocation + { + ReturnValue = 0, + LastParameter = 1, + SystemError = 2, + HiddenReturnValue = 3, + } + + [AttributeUsage(AttributeTargets.Method)] + internal sealed class ErrorHandlerAttribute : Attribute + { + public ErrorHandlerAttribute(Type marshallerType, ErrorLocation errorLocation) + { + _ = marshallerType; + _ = errorLocation; + } + } +} + +#endif diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/TypeMapLazyDictionary.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/TypeMapLazyDictionary.cs index 829e30f8cced89..13f58b9002474c 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/TypeMapLazyDictionary.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/TypeMapLazyDictionary.cs @@ -80,7 +80,10 @@ public unsafe struct ProcessAttributesCallbackArg public int StringLen2; } - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeMapLazyDictionary_ProcessAttributes")] +#if CORECLR + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] +#endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeMapLazyDictionary_ProcessAttributes")] private static unsafe partial void ProcessAttributes( QCallAssembly assembly, QCallTypeHandle groupType, @@ -89,29 +92,20 @@ private static unsafe partial void ProcessAttributes( delegate* unmanaged newPrecachedExternalTypeMap, delegate* unmanaged newPrecachedProxyTypeMap, CallbackContext* context -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeMapLazyDictionary_FindPrecachedExternalTypeMapEntry", StringMarshalling = StringMarshalling.Utf8)] - private static unsafe partial IntPtr FindPrecachedExternalTypeMapEntry(QCallModule module, QCallTypeHandle groupType, string key #if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeMapLazyDictionary_FindPrecachedExternalTypeMapEntry", StringMarshalling = StringMarshalling.Utf8)] + private static unsafe partial IntPtr FindPrecachedExternalTypeMapEntry(QCallModule module, QCallTypeHandle groupType, string key ); - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeMapLazyDictionary_FindPrecachedProxyTypeMapEntry")] - private static unsafe partial IntPtr FindPrecachedProxyTypeMapEntry(QCallModule module, QCallTypeHandle groupType, QCallTypeHandle type #if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out QCallExceptionStatus qcallException -#pragma warning restore SA1001, SA1113, SA1115 + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeMapLazyDictionary_FindPrecachedProxyTypeMapEntry")] + private static unsafe partial IntPtr FindPrecachedProxyTypeMapEntry(QCallModule module, QCallTypeHandle groupType, QCallTypeHandle type ); public ref struct Utf16SharedBuffer @@ -283,11 +277,6 @@ private static unsafe CallbackContext CreateMaps( &NewPrecachedExternalTypeMap, &NewPrecachedProxyTypeMap, &context -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); // If an exception was thrown during the processing of @@ -434,11 +423,6 @@ private sealed class LazyExternalTypeDictionary : LazyTypeLoadDictionary protected override bool TryGetOrLoadTypeFromPreCachedDictionary(RuntimeModule module, string key, [NotNullWhen(true)] out Type? type) { IntPtr handle = FindPrecachedExternalTypeMapEntry(new QCallModule(ref module), new QCallTypeHandle(ref _groupType), key -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); type = RuntimeTypeHandle.GetRuntimeTypeFromHandleMaybeNull(handle); return type != null; @@ -515,11 +499,6 @@ protected override bool TryGetOrLoadTypeFromPreCachedDictionary(RuntimeModule mo { RuntimeType rtKey = (RuntimeType)key; IntPtr handle = FindPrecachedProxyTypeMapEntry(new QCallModule(ref module), new QCallTypeHandle(ref _groupType), new QCallTypeHandle(ref rtKey) -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); type = RuntimeTypeHandle.GetRuntimeTypeFromHandleMaybeNull(handle); return type != null; diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.cs index d60b38ff7c1378..603d9eae3f5704 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.cs @@ -102,11 +102,6 @@ private protected AssemblyLoadContext(bool representsTPALoadContext, bool isColl var thisHandle = GCHandle.Alloc(this, IsCollectible ? GCHandleType.WeakTrackResurrection : GCHandleType.Normal); var thisHandlePtr = GCHandle.ToIntPtr(thisHandle); _nativeAssemblyLoadContext = InitializeAssemblyLoadContext(thisHandlePtr, representsTPALoadContext, isCollectible -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); // Add this instance to the list of alive ALC @@ -156,11 +151,6 @@ private void InitiateUnload() // The underlying code will transform the original weak handle // created by InitializeLoadContext to a strong handle PrepareForAssemblyLoadContextRelease(_nativeAssemblyLoadContext, thisStrongHandlePtr -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); _state = InternalState.Unloading; diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Lock.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Lock.cs index 81d6f57369fd14..1bbdbd8d2b5a92 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Lock.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Lock.cs @@ -876,7 +876,7 @@ private static bool TryInitializeStatics() // already being constructed earlier in the stack on the same thread, it would return the default value // here. Initialize s_isSingleProcessor first, as it may be used by other initialization afterwards. #if CORECLR - s_isSingleProcessor = Environment.GetProcessorCount(out _) == 1; + s_isSingleProcessor = Environment.GetProcessorCount() == 1; #else s_isSingleProcessor = Environment.GetProcessorCount() == 1; #endif diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.cs index 47db205e0c69dc..d52396d7e851a6 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.cs @@ -377,7 +377,7 @@ public static void Sleep(int millisecondsTimeout) #if !NATIVEAOT /// Returns the operating system identifier for the current thread. #if CORECLR - internal static ulong CurrentOSThreadId => GetCurrentOSThreadId(out _); + internal static ulong CurrentOSThreadId => GetCurrentOSThreadId(); #else internal static ulong CurrentOSThreadId => GetCurrentOSThreadId(); #endif diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.Windows.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.Windows.cs index 7ad7c9e9354bdc..c4eb1ecde674f9 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.Windows.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.Windows.cs @@ -66,11 +66,6 @@ private static unsafe int WaitForMultipleObjectsIgnoringSyncContext(IntPtr* pHan { Debug.Assert(!waitAll); result = Thread.ReentrantWaitAny(true, millisecondsTimeout, numHandles, pHandles -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - , out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif ); } else diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiFinalizerScheduler.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiFinalizerScheduler.cs index 1be3042915a05e..eaf190d0a5159b 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiFinalizerScheduler.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiFinalizerScheduler.cs @@ -21,34 +21,24 @@ internal static partial class WasiFinalizerScheduler // event-loop drain is a no-op here. internal static void DrainIfPending() { } #else - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "WasiFinalizer_TryClearPending")] - [return: MarshalAs(UnmanagedType.Bool)] - internal static partial bool TryClearPendingFinalization( #if CORECLR - out QCallExceptionStatus qcallException + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - ); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "WasiFinalizer_TryClearPending")] + [return: MarshalAs(UnmanagedType.Bool)] + internal static partial bool TryClearPendingFinalization(); - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "WasiFinalizer_RunWorker")] - internal static partial void ExecuteFinalizationCallback( #if CORECLR - out QCallExceptionStatus qcallException + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - ); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "WasiFinalizer_RunWorker")] + internal static partial void ExecuteFinalizationCallback(); internal static void DrainIfPending() { - if (TryClearPendingFinalization( -#if CORECLR - out _ -#endif - )) + if (TryClearPendingFinalization()) { - ExecuteFinalizationCallback( -#if CORECLR - out _ -#endif - ); + ExecuteFinalizationCallback(); } } #endif diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Runtime/CompilerServices/RuntimeHelpersTests.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Runtime/CompilerServices/RuntimeHelpersTests.cs index 2076198d225a39..36286da70b6663 100644 --- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Runtime/CompilerServices/RuntimeHelpersTests.cs +++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Runtime/CompilerServices/RuntimeHelpersTests.cs @@ -761,6 +761,37 @@ public static void BoxVoid() RuntimeHelpers.Box(ref value, typeof(void).TypeHandle); }); } + + [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsCoreCLR))] + [InlineData(1, typeof(OutOfMemoryException))] + [InlineData(2, typeof(StackOverflowException))] + public static void QCallExceptionStatus_ThrowsSpecialException(int status, Type exceptionType) + { + TargetInvocationException exception = Assert.Throws( + () => GetQCallExceptionStatusMarshaller().Invoke(null, [(nint)status])); + + Assert.IsType(exceptionType, exception.InnerException); + } + + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsCoreCLR))] + public static void QCallExceptionStatus_ThrowsExactExceptionFromHandle() + { + InvalidOperationException expected = new(); + GCHandle handle = GCHandle.Alloc(expected); + + TargetInvocationException exception = Assert.Throws( + () => GetQCallExceptionStatusMarshaller().Invoke(null, [GCHandle.ToIntPtr(handle)])); + + Assert.Same(expected, exception.InnerException); + } + + private static MethodInfo GetQCallExceptionStatusMarshaller() + { + Type marshallerType = typeof(object).Assembly.GetType( + "System.Runtime.CompilerServices.QCallExceptionStatusMarshaller", + throwOnError: true); + return marshallerType.GetMethod("ConvertToManaged", BindingFlags.Public | BindingFlags.Static); + } } public struct Age From 351c207fb0af79c6ac64e8b2972cc9f06a708f4c Mon Sep 17 00:00:00 2001 From: David Wrighton Date: Tue, 25 Aug 2026 16:19:44 -0700 Subject: [PATCH 15/23] Fix Unix XplatEventLogger QCall invocation Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 97d405de-8e39-4e76-afe4-2f94b74ecfa2 --- .../Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs index 67f8b3fea5cf65..f5e532cc46004f 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs @@ -35,13 +35,7 @@ public XplatEventLogger() { } { try { - if (!initializedPersistentListener && XplatEventLogger.IsEventSourceLoggingEnabled( -#if CORECLR -#pragma warning disable SA1001, SA1113, SA1115 // Conditional QCall exception argument. - out _ -#pragma warning restore SA1001, SA1113, SA1115 -#endif - )) + if (!initializedPersistentListener && XplatEventLogger.IsEventSourceLoggingEnabled()) { initializedPersistentListener = true; return new XplatEventLogger(); From 55f244826506c95eaf1ea1bdd7026c8bc58360f2 Mon Sep 17 00:00:00 2001 From: David Wrighton Date: Fri, 28 Aug 2026 17:34:30 -0700 Subject: [PATCH 16/23] Fix QCall exception handle lifetime Release the caught native exception after transferring its throwable to the QCall status, and preserve the previous customer-visible COM exception stack trace. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: df97bfcc-e3cb-470b-be04-ac63dfebcb4a --- .../CompilerServices/QCallExceptionStatus.cs | 3 +++ src/coreclr/vm/excep.cpp | 4 ++++ .../COM/NETClients/Primitives/StringTests.cs | 17 ++++++++++++++++- 3 files changed, 23 insertions(+), 1 deletion(-) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallExceptionStatus.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallExceptionStatus.cs index e3357a71ab26e9..9d7dcde2c8b1af 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallExceptionStatus.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallExceptionStatus.cs @@ -1,6 +1,7 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System.Diagnostics; using System.Runtime.ExceptionServices; using System.Runtime.InteropServices; using System.Runtime.InteropServices.Marshalling; @@ -21,6 +22,7 @@ internal static class QCallExceptionStatusMarshaller [MethodImpl(MethodImplOptions.AggressiveInlining)] public static nint ConvertToUnmanaged(QCallExceptionStatus _) => 0; + [StackTraceHidden] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static QCallExceptionStatus ConvertToManaged(nint status) { @@ -32,6 +34,7 @@ public static QCallExceptionStatus ConvertToManaged(nint status) return default; } + [StackTraceHidden] [MethodImpl(MethodImplOptions.NoInlining)] private static void HandleException(nint status) { diff --git a/src/coreclr/vm/excep.cpp b/src/coreclr/vm/excep.cpp index 9e467a17f4958e..bc3a83e9bfe2ae 100644 --- a/src/coreclr/vm/excep.cpp +++ b/src/coreclr/vm/excep.cpp @@ -6660,6 +6660,10 @@ void UnwindAndContinueRethrowHelperInsideQcallCatch( OBJECTREF orThrowable = CLRException::GetThrowableFromException(pException); CONSISTENCY_CHECK(orThrowable != NULL); SetQCallExceptionStatusThrowable(pQCallException, orThrowable); + + // The exception status now owns a handle to the throwable. Release the native + // exception and its cached throwable handle, as the normal rethrow path does. + Exception::Delete(pException); } #ifdef TARGET_UNIX diff --git a/src/tests/Interop/COM/NETClients/Primitives/StringTests.cs b/src/tests/Interop/COM/NETClients/Primitives/StringTests.cs index 1de229f27cc284..baa976e5ae2b0f 100644 --- a/src/tests/Interop/COM/NETClients/Primitives/StringTests.cs +++ b/src/tests/Interop/COM/NETClients/Primitives/StringTests.cs @@ -193,7 +193,22 @@ private void Marshal_LPWString() Assert.Equal(expected, actual); actual = local; - Assert.Throws( () => this.server.Reverse_LPWStr_OutAttr(local, actual)); + MarshalDirectiveException exception = Assert.Throws(() => this.server.Reverse_LPWStr_OutAttr(local, actual)); + string[] expectedStackTrace = + { + "System.StubHelpers.StubHelpers.ThrowInteropParamException", + "Server.Contract.IStringTesting.Reverse_LPWStr_OutAttr", + "Xunit.Assert.RecordException", + }; + string[] actualStackTrace = exception.StackTrace! + .Split(Environment.NewLine) + .Select(static frame => + { + int methodStart = frame.IndexOf("at ", StringComparison.Ordinal) + "at ".Length; + return frame.Substring(methodStart, frame.IndexOf('(') - methodStart); + }) + .ToArray(); + Assert.Equal(expectedStackTrace, actualStackTrace); } foreach (var s in reversibleStrings) From 6061a857b091fc0c004f162ac92dc5de8b1bea23 Mon Sep 17 00:00:00 2001 From: David Wrighton Date: Mon, 31 Aug 2026 16:29:11 -0700 Subject: [PATCH 17/23] Address some formatting issues --- .../src/System/Runtime/ExceptionHandling.cs | 9 +-- .../src/System/Runtime/StackFrameIterator.cs | 6 +- src/coreclr/vm/appdomainnative.cpp | 4 +- src/coreclr/vm/arraynative.cpp | 4 +- src/coreclr/vm/assemblynative.cpp | 36 +++++++----- src/coreclr/vm/clrconfignative.cpp | 3 +- src/coreclr/vm/comdelegate.cpp | 12 ++-- src/coreclr/vm/comdependenthandle.cpp | 4 +- src/coreclr/vm/comdynamic.cpp | 36 ++++++------ src/coreclr/vm/commodule.cpp | 36 ++++++------ src/coreclr/vm/comsynchronizable.cpp | 28 ++++----- src/coreclr/vm/comutilnative.cpp | 58 ++++++++++--------- src/coreclr/vm/debugdebugger.cpp | 4 +- src/coreclr/vm/eventpipeinternal.cpp | 13 +++-- src/coreclr/vm/exceptionhandling.cpp | 14 +++-- src/coreclr/vm/finalizerthread.cpp | 4 +- .../vm/interoplibinterface_comwrappers.cpp | 4 +- src/coreclr/vm/interoplibinterface_java.cpp | 8 +-- src/coreclr/vm/interoplibinterface_objc.cpp | 12 ++-- src/coreclr/vm/jithelpers.cpp | 11 ++-- src/coreclr/vm/loaderallocator.cpp | 4 +- src/coreclr/vm/marshalnative.cpp | 52 ++++++++--------- src/coreclr/vm/nativeeventsource.cpp | 6 +- src/coreclr/vm/nativelibrarynative.cpp | 4 +- src/coreclr/vm/reflectioninvocation.cpp | 8 +-- src/coreclr/vm/runtimehandles.cpp | 56 +++++++++--------- src/coreclr/vm/tailcallhelp.cpp | 4 +- src/coreclr/vm/unsafeaccessors.cpp | 4 +- src/coreclr/vm/varargsnative.cpp | 4 +- src/coreclr/vm/versionresilienthashcode.cpp | 4 +- src/coreclr/vm/weakreferencenative.cpp | 3 +- 31 files changed, 234 insertions(+), 221 deletions(-) diff --git a/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/ExceptionHandling.cs b/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/ExceptionHandling.cs index 77c1b53582118f..7b1d9ac811835e 100644 --- a/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/ExceptionHandling.cs +++ b/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/ExceptionHandling.cs @@ -283,8 +283,7 @@ private static void AppendExceptionStackFrameViaClasslib(object exception, IntPt #else fixed (EH.ExInfo* pExInfo = &exInfo) { - InternalCalls.RhpAppendExceptionStackFrame(ObjectHandleOnStack.Create(ref exception), ip, sp, flags, pExInfo - ); + InternalCalls.RhpAppendExceptionStackFrame(ObjectHandleOnStack.Create(ref exception), ip, sp, flags, pExInfo); } // Clear flags only if we called the function @@ -1039,8 +1038,7 @@ private static bool FindFirstPassHandler(object exception, uint idxStart, // Search the clauses for one that contains the current offset. RhEHClause ehClause; - for (uint curIdx = 0; InternalCalls.RhpEHEnumNext(&ehEnum, &ehClause - ); curIdx++) + for (uint curIdx = 0; InternalCalls.RhpEHEnumNext(&ehEnum, &ehClause); curIdx++) { // // Skip to the starting try region. This is used by collided unwinds and rethrows to pickup where @@ -1105,8 +1103,7 @@ private static bool FindFirstPassHandler(object exception, uint idxStart, } #else // NATIVEAOT shouldInvokeHandler = - InternalCalls.RhpCallFilterFunclet(ObjectHandleOnStack.Create(ref exception), pFilterFunclet, frameIter.RegisterSet - ); + InternalCalls.RhpCallFilterFunclet(ObjectHandleOnStack.Create(ref exception), pFilterFunclet, frameIter.RegisterSet); #endif // NATIVEAOT if (shouldInvokeHandler) diff --git a/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/StackFrameIterator.cs b/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/StackFrameIterator.cs index 1597c9b9332beb..6a9577fd935b36 100644 --- a/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/StackFrameIterator.cs +++ b/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/StackFrameIterator.cs @@ -65,8 +65,7 @@ internal unsafe struct StackFrameIterator [DebuggerHidden] internal bool Init(EH.PAL_LIMITED_CONTEXT* pStackwalkCtx, bool instructionFault = false, bool* fIsExceptionIntercepted = null) { - return InternalCalls.RhpSfiInit(ref this, pStackwalkCtx, instructionFault, fIsExceptionIntercepted - ); + return InternalCalls.RhpSfiInit(ref this, pStackwalkCtx, instructionFault, fIsExceptionIntercepted); } [StackTraceHidden] @@ -87,8 +86,7 @@ internal bool Next(uint* uExCollideClauseIdx, bool* fIsExceptionIntercepted) [DebuggerHidden] internal bool Next(uint* uExCollideClauseIdx, bool* fUnwoundReversePInvoke, bool* fIsExceptionIntercepted) { - return InternalCalls.RhpSfiNext(ref this, uExCollideClauseIdx, fUnwoundReversePInvoke, fIsExceptionIntercepted - ); + return InternalCalls.RhpSfiNext(ref this, uExCollideClauseIdx, fUnwoundReversePInvoke, fIsExceptionIntercepted); } } } diff --git a/src/coreclr/vm/appdomainnative.cpp b/src/coreclr/vm/appdomainnative.cpp index f792d5ef9ec834..a42c0c16b93216 100644 --- a/src/coreclr/vm/appdomainnative.cpp +++ b/src/coreclr/vm/appdomainnative.cpp @@ -145,10 +145,10 @@ extern "C" QCallExceptionStatus QCALLTYPE AppContext_TryGetHostPropertyValue(LPC { QCALL_CONTRACT; - BOOL found = FALSE; - BEGIN_QCALL; + BOOL found = FALSE; + AppDomain* pDomain = AppDomain::GetCurrentDomain(); DefaultAssemblyBinder* pBinder = pDomain->GetDefaultBinder(); BINDER_SPACE::ApplicationContext* pAppContext = pBinder->GetAppContext(); diff --git a/src/coreclr/vm/arraynative.cpp b/src/coreclr/vm/arraynative.cpp index 727cd098143cbe..e531390928bd72 100644 --- a/src/coreclr/vm/arraynative.cpp +++ b/src/coreclr/vm/arraynative.cpp @@ -32,10 +32,10 @@ extern "C" QCallExceptionStatus QCALLTYPE Array_GetElementConstructorEntrypoint( { QCALL_CONTRACT; - PCODE ctorEntrypoint = (PCODE)NULL; - BEGIN_QCALL; + PCODE ctorEntrypoint = (PCODE)NULL; + TypeHandle th = pArrayTypeHnd.AsTypeHandle(); MethodTable* pElemMT = th.GetArrayElementTypeHandle().AsMethodTable(); ctorEntrypoint = pElemMT->GetDefaultConstructor()->GetMultiCallableAddrOfCode(); diff --git a/src/coreclr/vm/assemblynative.cpp b/src/coreclr/vm/assemblynative.cpp index c98305b66e8e78..d6c612626cceb8 100644 --- a/src/coreclr/vm/assemblynative.cpp +++ b/src/coreclr/vm/assemblynative.cpp @@ -598,10 +598,10 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetCodeBase(QCall::Asse { QCALL_CONTRACT; - BOOL ret = TRUE; - BEGIN_QCALL; + BOOL ret = TRUE; + StackSString codebase; { @@ -618,8 +618,10 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetHashAlgorithm(QCall: { QCALL_CONTRACT; - INT32 retVal=0; BEGIN_QCALL; + + INT32 retVal=0; + retVal = pAssembly->GetPEAssembly()->GetHashAlgId(); *pReturnValue = retVal; @@ -630,8 +632,10 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetFlags(QCall::Assembl { QCALL_CONTRACT; - INT32 retVal=0; BEGIN_QCALL; + + INT32 retVal=0; + retVal = pAssembly->GetPEAssembly()->GetFlags(); *pReturnValue = retVal; @@ -642,10 +646,10 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetResource(QCall::Asse { QCALL_CONTRACT; - PBYTE pbInMemoryResource = NULL; - BEGIN_QCALL; + PBYTE pbInMemoryResource = NULL; + if (wszName == NULL) COMPlusThrow(kArgumentNullException, W("ArgumentNull_String")); @@ -673,10 +677,10 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetManifestResourceInfo { QCALL_CONTRACT; - INT32 rv = -1; - BEGIN_QCALL; + INT32 rv = -1; + if (wszName == NULL) COMPlusThrow(kArgumentNullException, W("ArgumentNull_String")); @@ -1188,10 +1192,10 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_InitializeAssemblyLoadC { QCALL_CONTRACT; - INT_PTR ptrNativeAssemblyBinder = 0; - BEGIN_QCALL; + INT_PTR ptrNativeAssemblyBinder = 0; + // We do not need to take a lock since this method is invoked from the ctor of AssemblyLoadContext managed type and // only one thread is ever executing a ctor for a given instance. // @@ -1278,10 +1282,10 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetLoadContextForAssemb { QCALL_CONTRACT; - INT_PTR ptrAssemblyLoadContext = 0; - BEGIN_QCALL; + INT_PTR ptrAssemblyLoadContext = 0; + _ASSERTE(pAssembly != NULL); AssemblyBinder* pAssemblyBinder = pAssembly->GetPEAssembly()->GetAssemblyBinder(); @@ -1306,10 +1310,10 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_InternalTryGetRawMetada { QCALL_CONTRACT; - PTR_CVOID metadata = nullptr; - BEGIN_QCALL; + PTR_CVOID metadata = nullptr; + _ASSERTE(assembly != nullptr); _ASSERTE(blobRef != nullptr); _ASSERTE(lengthRef != nullptr); @@ -1431,10 +1435,10 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_IsApplyUpdateSupported( { QCALL_CONTRACT; - BOOL result = false; - BEGIN_QCALL; + BOOL result = false; + #ifdef FEATURE_METADATA_UPDATER result = (g_pConfig->ModifiableAssemblies() != MODIFIABLE_ASSM_NONE) && (CORDebuggerAttached() || g_pConfig->ModifiableAssemblies() == MODIFIABLE_ASSM_DEBUG); diff --git a/src/coreclr/vm/clrconfignative.cpp b/src/coreclr/vm/clrconfignative.cpp index 921214905040d5..a15e2cb0f0cbaa 100644 --- a/src/coreclr/vm/clrconfignative.cpp +++ b/src/coreclr/vm/clrconfignative.cpp @@ -12,10 +12,11 @@ extern "C" QCallExceptionStatus QCALLTYPE ClrConfig_GetConfigBoolValue(LPCWSTR n { QCALL_CONTRACT; - BOOL retValue = FALSE; *exist = FALSE; BEGIN_QCALL; + BOOL retValue = FALSE; + if (Configuration::GetKnobStringValue(name) != nullptr) { *exist = TRUE; diff --git a/src/coreclr/vm/comdelegate.cpp b/src/coreclr/vm/comdelegate.cpp index 858377e25d60d7..2cddb86433b53c 100644 --- a/src/coreclr/vm/comdelegate.cpp +++ b/src/coreclr/vm/comdelegate.cpp @@ -1047,10 +1047,10 @@ extern "C" QCallExceptionStatus QCALLTYPE Delegate_BindToMethodInfo(MethodTable* { QCALL_CONTRACT; - BOOL result = TRUE; - BEGIN_QCALL; + BOOL result = TRUE; + MethodTable *pMethMT = pMethodType.AsTypeHandle().GetMethodTable(); // A generic method had better be instantiated (we can't dispatch to an uninstantiated one). @@ -1892,10 +1892,10 @@ extern "C" QCallExceptionStatus QCALLTYPE Delegate_GetMethodDesc(QCall::ObjectHa { QCALL_CONTRACT; - MethodDesc* pMD = nullptr; - BEGIN_QCALL; + MethodDesc* pMD = nullptr; + GCX_COOP(); pMD = COMDelegate::GetMethodDesc(instance.Get()); @@ -1931,10 +1931,10 @@ extern "C" QCallExceptionStatus QCALLTYPE Delegate_GetMulticastInvokeSlow(Method QCALL_CONTRACT; _ASSERTE(pDelegateMT != NULL); - PCODE pStub = (PCODE)NULL; - BEGIN_QCALL; + PCODE pStub = (PCODE)NULL; + DelegateEEClass *delegateEEClass = (DelegateEEClass*)pDelegateMT->GetClass(); pStub = delegateEEClass->m_pMultiCastInvokeStub; if (pStub == (PCODE)NULL) diff --git a/src/coreclr/vm/comdependenthandle.cpp b/src/coreclr/vm/comdependenthandle.cpp index 4174b5c2f9c786..b6a5e0bd9ebbc5 100644 --- a/src/coreclr/vm/comdependenthandle.cpp +++ b/src/coreclr/vm/comdependenthandle.cpp @@ -30,10 +30,10 @@ extern "C" QCallExceptionStatus QCALLTYPE DependentHandle_InternalAllocWithGCTra { QCALL_CONTRACT; - OBJECTHANDLE result = NULL; - BEGIN_QCALL; + OBJECTHANDLE result = NULL; + GCX_COOP(); result = GetAppDomain()->CreateDependentHandle(target.Get(), dependent.Get()); diff --git a/src/coreclr/vm/comdynamic.cpp b/src/coreclr/vm/comdynamic.cpp index 8dac62c7c7d265..791fa5b6754a83 100644 --- a/src/coreclr/vm/comdynamic.cpp +++ b/src/coreclr/vm/comdynamic.cpp @@ -46,10 +46,10 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineGenericParam(QCall:: { QCALL_CONTRACT; - mdTypeDef classE = mdTokenNil; - BEGIN_QCALL; + mdTypeDef classE = mdTokenNil; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); @@ -70,10 +70,10 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineType(QCall::ModuleHa { QCALL_CONTRACT; - int classE = mdTokenNil; - BEGIN_QCALL; + int classE = mdTokenNil; + classE = COMDynamicWrite::DefineType(pModule, wszFullName, tkParent, attributes, tkEnclosingType, pInterfaceTokens); *pReturnValue = (INT32)classE; @@ -171,10 +171,10 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineMethodSpec(QCall::Mo { QCALL_CONTRACT; - mdMethodDef memberE = mdTokenNil; - BEGIN_QCALL; + mdMethodDef memberE = mdTokenNil; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); @@ -193,10 +193,10 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineMethod(QCall::Module { QCALL_CONTRACT; - mdMethodDef memberE = mdTokenNil; - BEGIN_QCALL; + mdMethodDef memberE = mdTokenNil; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); @@ -225,10 +225,10 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineField(QCall::ModuleH { QCALL_CONTRACT; - mdFieldDef retVal = mdTokenNil; - BEGIN_QCALL; + mdFieldDef retVal = mdTokenNil; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); @@ -540,10 +540,10 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineProperty(QCall::Modu { QCALL_CONTRACT; - mdProperty pr = mdTokenNil; - BEGIN_QCALL; + mdProperty pr = mdTokenNil; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); @@ -577,10 +577,10 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineEvent(QCall::ModuleH { QCALL_CONTRACT; - mdProperty ev = mdTokenNil; - BEGIN_QCALL; + mdProperty ev = mdTokenNil; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); @@ -672,10 +672,10 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_GetTokenFromSig(QCall::Mod { QCALL_CONTRACT; - mdSignature retVal = 0; - BEGIN_QCALL; + mdSignature retVal = 0; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); @@ -702,10 +702,10 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetParamInfo(QCall::Module { QCALL_CONTRACT; - mdParamDef retVal = 0; - BEGIN_QCALL; + mdParamDef retVal = 0; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); diff --git a/src/coreclr/vm/commodule.cpp b/src/coreclr/vm/commodule.cpp index 5021a667cf45dd..48f2ccd2a73619 100644 --- a/src/coreclr/vm/commodule.cpp +++ b/src/coreclr/vm/commodule.cpp @@ -28,10 +28,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetTypeRef(QCall::Module { QCALL_CONTRACT; - mdTypeRef tr = 0; - BEGIN_QCALL; + mdTypeRef tr = 0; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); @@ -132,10 +132,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetArrayMethodToken(QCal { QCALL_CONTRACT; - mdMemberRef memberRefE = mdTokenNil; - BEGIN_QCALL; + mdMemberRef memberRefE = mdTokenNil; + if (!wszMethodName) COMPlusThrow(kArgumentNullException, W("ArgumentNull_String")); if (!tkTypeSpec) @@ -207,10 +207,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRef(QCall::Modu { QCALL_CONTRACT; - mdMemberRef memberRefE = 0; - BEGIN_QCALL; + mdMemberRef memberRefE = 0; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE( pRCW ); @@ -289,10 +289,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo { QCALL_CONTRACT; - mdMemberRef memberRefE = 0; - BEGIN_QCALL; + mdMemberRef memberRefE = 0; + if (!pMeth) COMPlusThrow(kArgumentNullException); @@ -368,10 +368,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRefOfFieldInfo( { QCALL_CONTRACT; - mdMemberRef memberRefE = 0; - BEGIN_QCALL; + mdMemberRef memberRefE = 0; + if (TypeFromToken(tr) == mdtTypeDef) { // If the passed in method is defined in the same module, just return the FieldDef token @@ -446,10 +446,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRefFromSignatur { QCALL_CONTRACT; - mdMemberRef memberRefE = mdTokenNil; - BEGIN_QCALL; + mdMemberRef memberRefE = mdTokenNil; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); @@ -530,10 +530,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetStringConstant(QCall: { QCALL_CONTRACT; - mdString strRef = mdTokenNil; - BEGIN_QCALL; + mdString strRef = mdTokenNil; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); @@ -576,10 +576,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetTokenFromTypeSpec(QCa { QCALL_CONTRACT; - mdTypeSpec ts = mdTokenNil; - BEGIN_QCALL; + mdTypeSpec ts = mdTokenNil; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); @@ -655,10 +655,10 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetHINSTANCE(QCall::Modu { QCALL_CONTRACT; - HMODULE hMod = (HMODULE)0; - BEGIN_QCALL; + HMODULE hMod = (HMODULE)0; + // This returns the base address // Other modules should have zero base if (!pModule->IsReflectionEmit()) diff --git a/src/coreclr/vm/comsynchronizable.cpp b/src/coreclr/vm/comsynchronizable.cpp index 085b41aaf80ec2..eb4e56be9fe0a1 100644 --- a/src/coreclr/vm/comsynchronizable.cpp +++ b/src/coreclr/vm/comsynchronizable.cpp @@ -201,10 +201,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_Start(QCall::ThreadHandle { QCALL_CONTRACT; - BOOL result = TRUE; - BEGIN_QCALL; + BOOL result = TRUE; + Thread* pNewThread = thread; _ASSERTE(pNewThread != NULL); @@ -344,14 +344,14 @@ extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetCurrentOSThreadId(UINT { QCALL_CONTRACT; + BEGIN_QCALL; + // The Windows API GetCurrentThreadId returns a 32-bit integer thread ID. // On some non-Windows platforms (e.g. OSX), the thread ID is a 64-bit value. // We special case the API for non-Windows to get the 64-bit value and zero-extend // the Windows value to return a single data type on all platforms. - UINT64 threadId = 0; - BEGIN_QCALL; #ifndef TARGET_UNIX threadId = (UINT64) GetCurrentThreadId(); #else @@ -435,10 +435,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetApartmentState(QCall:: { QCALL_CONTRACT; - INT32 retVal = 0; - BEGIN_QCALL; + INT32 retVal = 0; + Thread* thread = NULL; { GCX_COOP(); @@ -466,10 +466,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_SetApartmentState(QCall:: { QCALL_CONTRACT; - INT32 retVal = 0; - BEGIN_QCALL; + INT32 retVal = 0; + Thread* thread = NULL; { GCX_COOP(); @@ -512,10 +512,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetOSHandle(QCall::Thread { QCALL_CONTRACT; - HANDLE retVal = INVALID_HANDLE_VALUE; - BEGIN_QCALL; + HANDLE retVal = INVALID_HANDLE_VALUE; + HANDLE currentHandle = t->GetThreadHandle(); if (currentHandle != INVALID_HANDLE_VALUE) { @@ -810,10 +810,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_YieldThread(BOOL* pReturn { QCALL_CONTRACT; - BOOL ret = FALSE; - BEGIN_QCALL; + BOOL ret = FALSE; + ret = __SwitchToThread(0, CALLER_LIMITS_SPINNING); *pReturnValue = ret; @@ -885,10 +885,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_ReentrantWaitAny(BOOL ale { QCALL_CONTRACT; - INT32 retVal = 0; - BEGIN_QCALL; + INT32 retVal = 0; + Thread *pThread = GetThread(); WaitMode mode = alertable ? WaitMode_Alertable : WaitMode_None; retVal = (INT32)pThread->DoReentrantWaitAny(count, handles, timeout, mode); diff --git a/src/coreclr/vm/comutilnative.cpp b/src/coreclr/vm/comutilnative.cpp index 963f7e0c73a5a4..d9bb0e4c9fc915 100644 --- a/src/coreclr/vm/comutilnative.cpp +++ b/src/coreclr/vm/comutilnative.cpp @@ -589,10 +589,10 @@ extern "C" QCallExceptionStatus QCALLTYPE GCInterface_WaitForFullGCApproach(int { QCALL_CONTRACT; - int result = 0; - BEGIN_QCALL; + int result = 0; + GCX_COOP(); DWORD dwMilliseconds = ((millisecondsTimeout == -1) ? INFINITE : millisecondsTimeout); @@ -607,10 +607,10 @@ extern "C" QCallExceptionStatus QCALLTYPE GCInterface_WaitForFullGCComplete(int { QCALL_CONTRACT; - int result = 0; - BEGIN_QCALL; + int result = 0; + GCX_COOP(); DWORD dwMilliseconds = ((millisecondsTimeout == -1) ? INFINITE : millisecondsTimeout); @@ -674,10 +674,10 @@ extern "C" QCallExceptionStatus QCALLTYPE GCInterface_StartNoGCRegion(INT64 tota { QCALL_CONTRACT; - int retVal = 0; - BEGIN_QCALL; + int retVal = 0; + GCX_COOP(); retVal = GCHeapUtilities::GetGCHeap()->StartNoGCRegion((ULONGLONG)totalSize, @@ -694,10 +694,10 @@ extern "C" QCallExceptionStatus QCALLTYPE GCInterface_EndNoGCRegion(int* pReturn { QCALL_CONTRACT; - int retVal = FALSE; - BEGIN_QCALL; + int retVal = FALSE; + retVal = GCHeapUtilities::GetGCHeap()->EndNoGCRegion(); *pReturnValue = retVal; @@ -731,10 +731,10 @@ extern "C" QCallExceptionStatus QCALLTYPE GCInterface_GetTotalMemory(INT64* pRet { QCALL_CONTRACT; - INT64 iRetVal = 0; - BEGIN_QCALL; + INT64 iRetVal = 0; + GCX_COOP(); iRetVal = (INT64) GCHeapUtilities::GetGCHeap()->GetTotalBytesInUse(); @@ -770,10 +770,10 @@ extern "C" QCallExceptionStatus QCALLTYPE GCInterface_GetNextFinalizableObject(Q { QCALL_CONTRACT; - PCODE funcPtr = 0; - BEGIN_QCALL; + PCODE funcPtr = 0; + MethodTable *pTargetMT = NULL; { GCX_COOP(); @@ -967,10 +967,10 @@ extern "C" QCallExceptionStatus QCALLTYPE GCInterface_RegisterFrozenSegment(void { QCALL_CONTRACT; - void* retVal = nullptr; - BEGIN_QCALL; + void* retVal = nullptr; + _ASSERTE(pSection != nullptr); _ASSERTE(sizeSection > 0); @@ -1131,9 +1131,10 @@ extern "C" QCallExceptionStatus QCALLTYPE GCInterface_RefreshMemoryLimit(GCHeapH { QCALL_CONTRACT; + BEGIN_QCALL; + int result = 0; - BEGIN_QCALL; g_gcHeapHardLimitInfo = heapHardLimitInfo; g_gcHeapHardLimitInfoSpecified = true; result = GCInterface::RefreshMemoryLimit(); @@ -1455,10 +1456,10 @@ extern "C" QCallExceptionStatus QCALLTYPE Environment_GetProcessorCount(INT32* p { QCALL_CONTRACT; - INT32 processorCount = 0; - BEGIN_QCALL; + INT32 processorCount = 0; + processorCount = GetCurrentProcessCpuCount(); *pReturnValue = processorCount; @@ -1579,10 +1580,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ObjectNative_GetHashCodeSlow(QCall::Ob { QCALL_CONTRACT; - INT32 idx = 0; - BEGIN_QCALL; + INT32 idx = 0; + GCX_COOP(); _ASSERTE(objHandle.Get() != NULL); @@ -1846,10 +1847,10 @@ extern "C" QCallExceptionStatus QCALLTYPE MethodTable_CanCompareBitsOrUseFastGet { QCALL_CONTRACT; - BOOL ret = FALSE; - BEGIN_QCALL; + BOOL ret = FALSE; + if (mt->GetClass()->IsInlineArray()) COMPlusThrow(kNotSupportedException, W("NotSupported_InlineArrayEqualsGetHashCode")); @@ -1965,13 +1966,14 @@ extern "C" QCallExceptionStatus QCALLTYPE ValueType_GetHashCodeStrategy(MethodTa { QCALL_CONTRACT; - ValueTypeHashCodeStrategy ret = ValueTypeHashCodeStrategy::None; *fieldOffset = 0; *fieldSize = 0; *fieldMT = NULL; BEGIN_QCALL; + ValueTypeHashCodeStrategy ret = ValueTypeHashCodeStrategy::None; + ret = GetHashCodeStrategy(mt, objHandle, fieldOffset, fieldSize, fieldMT); *pReturnValue = ret; @@ -2026,10 +2028,10 @@ extern "C" QCallExceptionStatus QCALLTYPE MethodTable_AreTypesEquivalent(MethodT { QCALL_CONTRACT; - BOOL bResult = FALSE; - BEGIN_QCALL; + BOOL bResult = FALSE; + bResult = mta->IsEquivalentTo(mtb); *pReturnValue = bResult; @@ -2041,10 +2043,10 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeHandle_CanCastTo_NoCacheLookup(voi { QCALL_CONTRACT; - BOOL ret = false; - BEGIN_QCALL; + BOOL ret = false; + // Cache lookup and trivial cases are already handled at managed side. Call the uncached versions directly. _ASSERTE(fromTypeHnd != toTypeHnd); @@ -2100,11 +2102,11 @@ extern "C" QCallExceptionStatus QCALLTYPE Stream_HasOverriddenSlow(MethodTable* QCALL_CONTRACT; _ASSERTE(pMT != NULL); + BEGIN_QCALL; + BOOL readOverride = FALSE; BOOL writeOverride = FALSE; - BEGIN_QCALL; - MethodTable* pStreamMT = CoreLibBinder::GetClass(CLASS__STREAM); WORD slotBeginRead = CoreLibBinder::GetMethod(METHOD__STREAM__BEGIN_READ)->GetSlot(); WORD slotEndRead = CoreLibBinder::GetMethod(METHOD__STREAM__END_READ)->GetSlot(); diff --git a/src/coreclr/vm/debugdebugger.cpp b/src/coreclr/vm/debugdebugger.cpp index 2a43c5b49b12d8..808ab698da09b9 100644 --- a/src/coreclr/vm/debugdebugger.cpp +++ b/src/coreclr/vm/debugdebugger.cpp @@ -828,10 +828,10 @@ extern "C" QCallExceptionStatus QCALLTYPE StackFrame_GetMethodDescFromNativeIP(L { QCALL_CONTRACT; - MethodDesc* pResult = nullptr; - BEGIN_QCALL; + MethodDesc* pResult = nullptr; + // TODO: There is a race for dynamic and collectible methods here between getting // the MethodDesc here and when the managed wrapper converts it into a MethodBase // where the method could be collected. diff --git a/src/coreclr/vm/eventpipeinternal.cpp b/src/coreclr/vm/eventpipeinternal.cpp index 046917d2a770d4..b181a3a329294e 100644 --- a/src/coreclr/vm/eventpipeinternal.cpp +++ b/src/coreclr/vm/eventpipeinternal.cpp @@ -71,9 +71,10 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_GetSessionInfo(UINT6 { QCALL_CONTRACT; - bool retVal = false; BEGIN_QCALL; + bool retVal = false; + if (pSessionInfo != NULL) { EventPipeSession *pSession = EventPipeAdapter::GetSession(sessionID); @@ -168,10 +169,10 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_EventActivityIdContr QCALL_CONTRACT; - int retVal = 0; - BEGIN_QCALL; + int retVal = 0; + Thread *pThread = GetThreadNULLOk(); if (pThread == NULL || pActivityId == NULL) { @@ -270,9 +271,10 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_SignalSession(UINT64 { QCALL_CONTRACT; - bool result = false; BEGIN_QCALL; + bool result = false; + result = EventPipeAdapter::SignalSession(sessionID); *pReturnValue = result; @@ -284,9 +286,10 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_WaitForSessionSignal { QCALL_CONTRACT; - bool result = false; BEGIN_QCALL; + bool result = false; + result = EventPipeAdapter::WaitForSessionSignal(sessionID, timeoutMs); *pReturnValue = result; diff --git a/src/coreclr/vm/exceptionhandling.cpp b/src/coreclr/vm/exceptionhandling.cpp index 3bd2e54a49f076..a633564f3da0a8 100644 --- a/src/coreclr/vm/exceptionhandling.cpp +++ b/src/coreclr/vm/exceptionhandling.cpp @@ -3535,9 +3535,10 @@ extern "C" QCallExceptionStatus QCALLTYPE CallFilterFunclet(QCall::ObjectHandleO { QCALL_CONTRACT; + BEGIN_QCALL; + DWORD_PTR dwResult = 0; - BEGIN_QCALL; MAKE_CURRENT_THREAD_AVAILABLE(); GCX_COOP(); @@ -3704,10 +3705,10 @@ extern "C" QCallExceptionStatus QCALLTYPE EHEnumNext(EH_CLAUSE_ENUMERATOR* pEHEn { QCALL_CONTRACT; - CLR_BOOL result = FALSE; - BEGIN_QCALL; + CLR_BOOL result = FALSE; + MAKE_CURRENT_THREAD_AVAILABLE(); Thread* pThread = GET_THREAD(); Frame* pFrame = pThread->GetFrame(); @@ -4056,9 +4057,10 @@ extern "C" QCallExceptionStatus QCALLTYPE SfiInit(StackFrameIterator* pThis, CON { QCALL_CONTRACT; - CLR_BOOL result = FALSE; BEGIN_QCALL; + CLR_BOOL result = FALSE; + MAKE_CURRENT_THREAD_AVAILABLE(); Thread* pThread = GET_THREAD(); Frame* pFrame = pThread->GetFrame(); @@ -4377,10 +4379,10 @@ extern "C" QCallExceptionStatus QCALLTYPE SfiNext(StackFrameIterator* pThis, uin { QCALL_CONTRACT; - CLR_BOOL result = FALSE; - BEGIN_QCALL; + CLR_BOOL result = FALSE; + MAKE_CURRENT_THREAD_AVAILABLE(); Thread* pThread = GET_THREAD(); Frame* pFrame = pThread->GetFrame(); diff --git a/src/coreclr/vm/finalizerthread.cpp b/src/coreclr/vm/finalizerthread.cpp index bf9bd058b654d5..5f5dfa4fa2d7fc 100644 --- a/src/coreclr/vm/finalizerthread.cpp +++ b/src/coreclr/vm/finalizerthread.cpp @@ -131,8 +131,10 @@ extern "C" void WasiFinalizer_Schedule() extern "C" QCallExceptionStatus QCALLTYPE WasiFinalizer_TryClearPending(CLR_BOOL* pReturnValue) { QCALL_CONTRACT; - CLR_BOOL pending = FALSE; BEGIN_QCALL; + + CLR_BOOL pending = FALSE; + // Volatile load + clear. Single-threaded WASI: no atomic swap needed. pending = s_finalizationPending ? TRUE : FALSE; if (pending) diff --git a/src/coreclr/vm/interoplibinterface_comwrappers.cpp b/src/coreclr/vm/interoplibinterface_comwrappers.cpp index 940d914f0e1100..216cda7f4f8d22 100644 --- a/src/coreclr/vm/interoplibinterface_comwrappers.cpp +++ b/src/coreclr/vm/interoplibinterface_comwrappers.cpp @@ -116,10 +116,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ComWrappers_AllocateRefCountedHandle(_ { QCALL_CONTRACT; - void* handle = NULL; - BEGIN_QCALL; + void* handle = NULL; + { GCX_COOP(); diff --git a/src/coreclr/vm/interoplibinterface_java.cpp b/src/coreclr/vm/interoplibinterface_java.cpp index 6bac5a02876ea1..68858bcffe8de3 100644 --- a/src/coreclr/vm/interoplibinterface_java.cpp +++ b/src/coreclr/vm/interoplibinterface_java.cpp @@ -140,10 +140,10 @@ extern "C" QCallExceptionStatus QCALLTYPE JavaMarshal_Initialize( QCALL_CONTRACT; _ASSERTE(markCrossReferences != NULL); - BOOL success = FALSE; - BEGIN_QCALL; + BOOL success = FALSE; + // Switch to Cooperative mode since we are setting callbacks that // will be used during a GC and we want to ensure a GC isn't occurring // while they are being set. @@ -168,10 +168,10 @@ extern "C" QCallExceptionStatus QCALLTYPE JavaMarshal_CreateReferenceTrackingHan { QCALL_CONTRACT; - OBJECTHANDLE instHandle = NULL; - BEGIN_QCALL; + OBJECTHANDLE instHandle = NULL; + GCX_COOP(); instHandle = GetAppDomain()->CreateCrossReferenceHandle(obj.Get(), context); diff --git a/src/coreclr/vm/interoplibinterface_objc.cpp b/src/coreclr/vm/interoplibinterface_objc.cpp index 36bc28d23c4847..75647cc72916af 100644 --- a/src/coreclr/vm/interoplibinterface_objc.cpp +++ b/src/coreclr/vm/interoplibinterface_objc.cpp @@ -35,10 +35,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ObjCMarshal_TryInitializeReferenceTrac && isReferencedCallback != NULL && trackedObjectEnteredFinalization != NULL); - BOOL success = FALSE; - BEGIN_QCALL; + BOOL success = FALSE; + // Switch to Cooperative mode since we are setting callbacks that // will be used during a GC and we want to ensure a GC isn't occurring // while they are being set. @@ -64,10 +64,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ObjCMarshal_AllocateReferenceTrackingH { QCALL_CONTRACT; - OBJECTHANDLE instHandle; - BEGIN_QCALL; + OBJECTHANDLE instHandle; + // Switch to Cooperative mode since object references // are being manipulated. GCX_COOP(); @@ -125,10 +125,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ObjCMarshal_TrySetGlobalMessageSendCal { QCALL_CONTRACT; - bool success; - BEGIN_QCALL; + bool success; + _ASSERTE(msgSendFunction >= 0 && msgSendFunction < ARRAY_SIZE(s_msgSendOverrides)); success = InterlockedCompareExchangeT(&s_msgSendOverrides[msgSendFunction], fptr, NULL) == NULL; diff --git a/src/coreclr/vm/jithelpers.cpp b/src/coreclr/vm/jithelpers.cpp index 08c04122ff395a..21cd85f5047739 100644 --- a/src/coreclr/vm/jithelpers.cpp +++ b/src/coreclr/vm/jithelpers.cpp @@ -476,10 +476,11 @@ BOOL ObjIsInstanceOf(Object* pObject, TypeHandle toTypeHnd, BOOL throwCastExcept extern "C" QCallExceptionStatus QCALLTYPE IsInstanceOf_NoCacheLookup(EnregisteredTypeHandle type, BOOL throwCastException, QCall::ObjectHandleOnStack objOnStack, BOOL* pReturnValue) { QCALL_CONTRACT; - BOOL result = FALSE; BEGIN_QCALL; + BOOL result = FALSE; + GCX_COOP(); result = ObjIsInstanceOfCore(OBJECTREFToObject(objOnStack.Get()), TypeHandle::FromPtr(type), throwCastException); @@ -604,10 +605,10 @@ extern "C" QCallExceptionStatus QCALLTYPE GenericHandleWorker(MethodDesc * pMD, { QCALL_CONTRACT; - void* result = NULL; - BEGIN_QCALL; + void* result = NULL; + result = GenericHandleWorkerCore(pMD, pMT, signature, dictionaryIndexAndSlot, pModule); *pReturnValue = result; @@ -679,11 +680,11 @@ extern "C" QCallExceptionStatus QCALLTYPE ResolveVirtualFunctionPointer(QCall::O { QCALL_CONTRACT; + BEGIN_QCALL; + // The address of the method that's returned. PCODE addr = (PCODE)NULL; - BEGIN_QCALL; - if (VolatileLoadWithoutBarrier(&g_pVirtualFunctionPointerCache) == NULL) { CoreLibBinder::GetClass(CLASS__VIRTUALDISPATCHHELPERS)->CheckRunClassInitThrowing(); diff --git a/src/coreclr/vm/loaderallocator.cpp b/src/coreclr/vm/loaderallocator.cpp index 46aa21e02af132..caad062144634b 100644 --- a/src/coreclr/vm/loaderallocator.cpp +++ b/src/coreclr/vm/loaderallocator.cpp @@ -761,10 +761,10 @@ extern "C" QCallExceptionStatus QCALLTYPE LoaderAllocator_Destroy(QCall::LoaderA { QCALL_CONTRACT; - BOOL ret = FALSE; - BEGIN_QCALL; + BOOL ret = FALSE; + ret = LoaderAllocator::Destroy(pLoaderAllocator); *pReturnValue = ret; diff --git a/src/coreclr/vm/marshalnative.cpp b/src/coreclr/vm/marshalnative.cpp index 8b52eba0631621..8b37f2ee4870c1 100644 --- a/src/coreclr/vm/marshalnative.cpp +++ b/src/coreclr/vm/marshalnative.cpp @@ -85,10 +85,10 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_IsBuiltInComSupported(BO { QCALL_CONTRACT; - BOOL ret = TRUE; - BEGIN_QCALL; + BOOL ret = TRUE; + #ifdef FEATURE_COMINTEROP ret = g_pConfig->IsBuiltInCOMSupported(); #else // FEATURE_COMINTEROP @@ -104,10 +104,10 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_HasLayout(QCall::TypeHan { QCALL_CONTRACT; - BOOL ret = FALSE; - BEGIN_QCALL; + BOOL ret = FALSE; + TypeHandle th = t.AsTypeHandle(); if (th.IsEnum()) @@ -141,10 +141,10 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_SizeOfHelper(QCall::Type { QCALL_CONTRACT; - INT32 rv = 0; - BEGIN_QCALL; + INT32 rv = 0; + // refClass is validated to be non-NULL RuntimeType by callers TypeHandle th = t.AsTypeHandle(); @@ -241,10 +241,10 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetFunctionPointerForDel { QCALL_CONTRACT; - PVOID pFPtr = NULL; - BEGIN_QCALL; + PVOID pFPtr = NULL; + GCX_COOP(); pFPtr = COMDelegate::ConvertToCallback(d.Get()); @@ -320,10 +320,10 @@ extern "C" QCallExceptionStatus QCALLTYPE GCHandle_InternalAllocWithGCTransition { QCALL_CONTRACT; - OBJECTHANDLE hnd = NULL; - BEGIN_QCALL; + OBJECTHANDLE hnd = NULL; + GCX_COOP(); hnd = GetAppDomain()->CreateTypedHandle(obj.Get(), static_cast(type)); @@ -528,10 +528,10 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetIUnknownForObject(QCa { QCALL_CONTRACT; - IUnknown* retVal = NULL; - BEGIN_QCALL; + IUnknown* retVal = NULL; + // Ensure COM is started up. EnsureComStarted(); @@ -554,10 +554,10 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetIDispatchForObject(QC { QCALL_CONTRACT; - IDispatch* retVal = NULL; - BEGIN_QCALL; + IDispatch* retVal = NULL; + // Ensure COM is started up. EnsureComStarted(); @@ -580,10 +580,10 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetIUnknownOrIDispatchFo { QCALL_CONTRACT; - void* retVal = NULL; - BEGIN_QCALL; + void* retVal = NULL; + // Ensure COM is started up. EnsureComStarted(); @@ -609,10 +609,10 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetComInterfaceForObject { QCALL_CONTRACT; - IUnknown* retVal = NULL; - BEGIN_QCALL; + IUnknown* retVal = NULL; + // Ensure COM is started up. EnsureComStarted(); @@ -824,10 +824,10 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_ReleaseComObject(QCall:: { QCALL_CONTRACT; - INT32 retVal = 0; - BEGIN_QCALL; + INT32 retVal = 0; + GCX_COOP(); OBJECTREF obj = objUNSAFE.Get(); @@ -946,10 +946,10 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_IsTypeVisibleFromCom(QCa { QCALL_CONTRACT; - BOOL retVal = FALSE; - BEGIN_QCALL; + BOOL retVal = FALSE; + // Call the internal version of IsTypeVisibleFromCom. retVal = ::IsTypeVisibleFromCom(t.AsTypeHandle()); @@ -1106,10 +1106,10 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetStartComSlot(QCall::T { QCALL_CONTRACT; - int retVal = 0; - BEGIN_QCALL; + int retVal = 0; + MethodTable *pMT = t.AsTypeHandle().GetMethodTable(); if (NULL == pMT) COMPlusThrow(kArgumentNullException); @@ -1129,10 +1129,10 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetEndComSlot(QCall::Typ { QCALL_CONTRACT; - int retVal = 0; - BEGIN_QCALL; + int retVal = 0; + int StartSlot = -1; MethodTable *pMT = t.AsTypeHandle().GetMethodTable(); diff --git a/src/coreclr/vm/nativeeventsource.cpp b/src/coreclr/vm/nativeeventsource.cpp index 2c349daad79ad4..237128fe6b40ec 100644 --- a/src/coreclr/vm/nativeeventsource.cpp +++ b/src/coreclr/vm/nativeeventsource.cpp @@ -25,9 +25,10 @@ extern "C" QCallExceptionStatus QCALLTYPE IsEventSourceLoggingEnabled(BOOL* pRet { QCALL_CONTRACT; + BEGIN_QCALL; + BOOL retVal = FALSE; - BEGIN_QCALL; retVal = XplatEventLogger::IsEventLoggingEnabled(); *pReturnValue = retVal; @@ -38,9 +39,10 @@ extern "C" QCallExceptionStatus QCALLTYPE EventSource_GetClrConfig(LPCWSTR confi { QCALL_CONTRACT; + BEGIN_QCALL; + LPWSTR ret = NULL; - BEGIN_QCALL; CLRConfig::ConfigStringInfo info; info.name = configName; info.options = CLRConfig::LookupOptions::Default; diff --git a/src/coreclr/vm/nativelibrarynative.cpp b/src/coreclr/vm/nativelibrarynative.cpp index 0ad7ed07839b98..d089f600a31aa3 100644 --- a/src/coreclr/vm/nativelibrarynative.cpp +++ b/src/coreclr/vm/nativelibrarynative.cpp @@ -15,10 +15,10 @@ extern "C" QCallExceptionStatus QCALLTYPE NativeLibrary_LoadByName(LPCWSTR name, { QCALL_CONTRACT; - NATIVE_LIBRARY_HANDLE handle = nullptr; - BEGIN_QCALL; + NATIVE_LIBRARY_HANDLE handle = nullptr; + handle = NativeLibrary::LoadLibraryByName(name, callingAssembly, hasDllImportSearchPathFlag, dllImportSearchPathFlag, throwOnError); *pReturnValue = reinterpret_cast(handle); diff --git a/src/coreclr/vm/reflectioninvocation.cpp b/src/coreclr/vm/reflectioninvocation.cpp index e0014cb2079014..1929cfdb9f8c04 100644 --- a/src/coreclr/vm/reflectioninvocation.cpp +++ b/src/coreclr/vm/reflectioninvocation.cpp @@ -796,10 +796,10 @@ extern "C" QCallExceptionStatus QCALLTYPE MethodBase_GetCurrentMethod(QCall::Sta QCALL_CONTRACT; - MethodDesc* pRet = nullptr; - BEGIN_QCALL; + MethodDesc* pRet = nullptr; + PTR_Thread pThread = GetThread(); SkipStruct skip(stackMark, pThread); pThread->StackWalkFrames(SkipMethods, &skip, FUNCTIONSONLY | LIGHTUNWIND); @@ -1221,10 +1221,10 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetRVAFieldInfo(Fie { QCALL_CONTRACT; - BOOL ret = FALSE; - BEGIN_QCALL; + BOOL ret = FALSE; + if (pField != NULL && pField->IsRVA()) { *address = pField->GetStaticAddressHandle(NULL); diff --git a/src/coreclr/vm/runtimehandles.cpp b/src/coreclr/vm/runtimehandles.cpp index 253467c01409e8..b79516d895d9f9 100644 --- a/src/coreclr/vm/runtimehandles.cpp +++ b/src/coreclr/vm/runtimehandles.cpp @@ -37,13 +37,12 @@ extern "C" QCallExceptionStatus QCALLTYPE MdUtf8String_EqualsCaseInsensitive(LPC { QCALL_CONTRACT; + BEGIN_QCALL; + // Important: the string in pSsz isn't null terminated so the length must be used // when performing operations on the string. - BOOL fStringsEqual = FALSE; - BEGIN_QCALL; - _ASSERTE(CheckPointer(szLhs)); _ASSERTE(CheckPointer(szRhs)); @@ -102,9 +101,10 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_IsCAVisibleFromDec { QCALL_CONTRACT; + BEGIN_QCALL; + BOOL bResult = TRUE; - BEGIN_QCALL; TypeHandle sourceHandle = sourceTypeHandle.AsTypeHandle(); TypeHandle targetHandle = targetTypeHandle.AsTypeHandle(); @@ -162,10 +162,10 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_IsEquivalentTo(QCall { QCALL_CONTRACT; - BOOL areEquivalent = FALSE; - BEGIN_QCALL; + BOOL areEquivalent = FALSE; + areEquivalent = rtType1.AsTypeHandle().IsEquivalentTo(rtType2.AsTypeHandle()); *pReturnValue = areEquivalent; @@ -366,10 +366,10 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetNumVirtualsAndSta { QCALL_CONTRACT; - INT32 numVirtuals = 0; - BEGIN_QCALL; + INT32 numVirtuals = 0; + TypeHandle typeHandle = pTypeHandle.AsTypeHandle(); _ASSERTE(!typeHandle.IsGenericVariable()); @@ -403,10 +403,10 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetMethodAt(MethodTa _ASSERTE(pMT != NULL); _ASSERTE(slot >= 0); - MethodDesc* pRetMethod = NULL; - BEGIN_QCALL; + MethodDesc* pRetMethod = NULL; + INT32 numVirtuals = (INT32)pMT->GetNumVirtuals(); if (slot < numVirtuals) { @@ -463,10 +463,10 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetFields(MethodTabl _ASSERTE(result != NULL); _ASSERTE(pCount != NULL); - BOOL retVal = FALSE; - BEGIN_QCALL; + BOOL retVal = FALSE; + EncApproxFieldDescIterator fdIterator(pMT, ApproxFieldDescIterator::ALL_FIELDS, EncApproxFieldDescIterator::FixUpEncFields); INT32 count = (INT32)fdIterator.Count(); @@ -779,10 +779,10 @@ extern "C" QCallExceptionStatus QCALLTYPE QCall_GetGCHandleForTypeHandle(QCall:: { QCALL_CONTRACT; - OBJECTHANDLE objHandle = NULL; - BEGIN_QCALL; + OBJECTHANDLE objHandle = NULL; + GCX_COOP(); TypeHandle th = pTypeHandle.AsTypeHandle(); @@ -851,10 +851,10 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetInterfaceMethodIm { QCALL_CONTRACT; - MethodDesc* pResult = nullptr; - BEGIN_QCALL; + MethodDesc* pResult = nullptr; + TypeHandle typeHandle = pTypeHandle.AsTypeHandle(); TypeHandle thOwnerOfMD = pOwner.AsTypeHandle(); @@ -909,10 +909,10 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHand { QCALL_CONTRACT; - TypeHandle retTypeHandle; - BEGIN_QCALL; + TypeHandle retTypeHandle; + TypeHandle typeHandle = TypeHandle::FromPtr(pTypeHandle); _ASSERTE(typeHandle.IsGenericVariable()); @@ -954,10 +954,10 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHand { QCALL_CONTRACT; - TypeHandle retTypeHandle; - BEGIN_QCALL; + TypeHandle retTypeHandle; + TypeHandle typeHandle = TypeHandle::FromPtr(pTypeHandle); _ASSERTE(!typeHandle.IsTypeDesc()); @@ -1302,10 +1302,10 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetFunctionPointer { QCALL_CONTRACT; - void* funcPtr = NULL; - BEGIN_QCALL; + void* funcPtr = NULL; + // Ensure the method is active and all types have been loaded so the function pointer can be used. pMethod->EnsureActive(); pMethod->PrepareForUseAsAFunctionPointer(); @@ -1709,10 +1709,10 @@ extern "C" QCallExceptionStatus QCALLTYPE Signature_AreEqual( { QCALL_CONTRACT; - BOOL ret = FALSE; - BEGIN_QCALL; + BOOL ret = FALSE; + ret = MetaSig::CompareMethodSigs( sig1, cSig1, handle1.AsTypeHandle().GetModule(), NULL, sig2, cSig2, handle2.AsTypeHandle().GetModule(), NULL, @@ -2005,10 +2005,10 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetNativeCode(Meth { QCALL_CONTRACT; - PCODE result = (PCODE)NULL; - BEGIN_QCALL; + PCODE result = (PCODE)NULL; + _ASSERTE(pMethod != NULL); while (pMethod->IsWrapperStub()) @@ -2415,10 +2415,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_ResolveMethod(QCall::Modu { QCALL_CONTRACT; - MethodDesc* pMD = NULL; - BEGIN_QCALL; + MethodDesc* pMD = NULL; + BOOL strictMetadataChecks = (TypeFromToken(tkMemberRef) == mdtMethodSpec); SigTypeContext typeContext(Instantiation(typeArgs, typeArgsCount), Instantiation(methodArgs, methodArgsCount)); diff --git a/src/coreclr/vm/tailcallhelp.cpp b/src/coreclr/vm/tailcallhelp.cpp index e4faa888dbc5b5..05227b70fd9e3c 100644 --- a/src/coreclr/vm/tailcallhelp.cpp +++ b/src/coreclr/vm/tailcallhelp.cpp @@ -25,10 +25,10 @@ extern "C" QCallExceptionStatus QCALLTYPE TailCallHelp_AllocTailCallArgBufferInt { QCALL_CONTRACT; - void* retVal = NULL; - BEGIN_QCALL; + void* retVal = NULL; + retVal = GetThread()->GetTailCallTls()->AllocArgBuffer(size); *pReturnValue = retVal; diff --git a/src/coreclr/vm/unsafeaccessors.cpp b/src/coreclr/vm/unsafeaccessors.cpp index fa3ea873cd021f..76a0c2f716eb58 100644 --- a/src/coreclr/vm/unsafeaccessors.cpp +++ b/src/coreclr/vm/unsafeaccessors.cpp @@ -1177,10 +1177,10 @@ extern "C" QCallExceptionStatus QCALLTYPE UnsafeAccessors_ResolveGenericParamToT QCALL_CONTRACT; _ASSERTE(unsafeAccessorMethod != NULL); - TypeHandle ret; - BEGIN_QCALL; + TypeHandle ret; + MethodDesc* typicalMD = unsafeAccessorMethod->LoadTypicalMethodDefinition(); Instantiation genericParams = isMethodParam ? typicalMD->GetMethodInstantiation() diff --git a/src/coreclr/vm/varargsnative.cpp b/src/coreclr/vm/varargsnative.cpp index 1075a2a99f9377..19efbfa37281f3 100644 --- a/src/coreclr/vm/varargsnative.cpp +++ b/src/coreclr/vm/varargsnative.cpp @@ -465,10 +465,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_GetNextArgType(VARARGS* da { QCALL_CONTRACT; - TypedByRef value = { }; - BEGIN_QCALL; + TypedByRef value = { }; + GCX_COOP(); _ASSERT(value.data == NULL); diff --git a/src/coreclr/vm/versionresilienthashcode.cpp b/src/coreclr/vm/versionresilienthashcode.cpp index d45b11f6d2a56b..f117a8c2618a63 100644 --- a/src/coreclr/vm/versionresilienthashcode.cpp +++ b/src/coreclr/vm/versionresilienthashcode.cpp @@ -454,10 +454,10 @@ extern "C" QCallExceptionStatus QCALLTYPE VersionResilientHashCode_TypeHashCode( { QCALL_CONTRACT; - INT32 hashCode = 0; - BEGIN_QCALL; + INT32 hashCode = 0; + hashCode = GetVersionResilientTypeHashCode(pTypeHandle.AsTypeHandle()); *pReturnValue = hashCode; diff --git a/src/coreclr/vm/weakreferencenative.cpp b/src/coreclr/vm/weakreferencenative.cpp index e92d63b518df48..ccf5f22102f74b 100644 --- a/src/coreclr/vm/weakreferencenative.cpp +++ b/src/coreclr/vm/weakreferencenative.cpp @@ -92,9 +92,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ObjectToComWeakRef(QCall::ObjectHandle { QCALL_CONTRACT; - IWeakReference* pWeakReference = nullptr; BEGIN_QCALL; + IWeakReference* pWeakReference = nullptr; + IWeakReferenceSource* pWeakReferenceSourceRaw = nullptr; { // COM helpers assume COOP mode and the arguments are protected refs. From 20497186436c79c15d823c14b3cc49cfed39347c Mon Sep 17 00:00:00 2001 From: David Wrighton Date: Mon, 31 Aug 2026 16:46:11 -0700 Subject: [PATCH 18/23] More formatting fixes --- src/coreclr/vm/assemblynative.cpp | 9 ++- src/coreclr/vm/comdynamic.cpp | 6 +- src/coreclr/vm/comdynamic.h | 6 +- src/coreclr/vm/commodule.cpp | 9 ++- src/coreclr/vm/commodule.h | 9 ++- src/coreclr/vm/eventpipeinternal.cpp | 14 ++-- src/coreclr/vm/eventpipeinternal.h | 24 ++++-- src/coreclr/vm/interoplibinterface.h | 12 ++- src/coreclr/vm/interoplibinterface_java.cpp | 6 +- src/coreclr/vm/interoplibinterface_objc.cpp | 6 +- src/coreclr/vm/jithelpers.cpp | 3 +- src/coreclr/vm/runtimehandles.cpp | 3 +- src/coreclr/vm/runtimehandles.h | 3 +- .../Diagnostics/Tracing/EventPipe.Internal.cs | 60 ++++++-------- .../System/Diagnostics/Tracing/EventPipe.cs | 3 +- .../EventPipeEventDispatcher.Threads.cs | 6 +- .../Tracing/EventPipeEventDispatcher.Wasm.cs | 3 +- .../Tracing/EventPipeEventDispatcher.cs | 6 +- .../Tracing/EventPipeEventProvider.cs | 18 ++--- ...ntSource.Threading.NativeSinks.Internal.cs | 80 ++++++++----------- ...untimeEventSource.Threading.NativeSinks.cs | 48 ++++------- .../Tracing/TraceLogging/XplatEventLogger.cs | 18 ++--- .../InteropServices/TypeMapLazyDictionary.cs | 24 +++--- .../Runtime/Loader/AssemblyLoadContext.cs | 6 +- .../System/Threading/WaitHandle.Windows.cs | 3 +- 25 files changed, 176 insertions(+), 209 deletions(-) diff --git a/src/coreclr/vm/assemblynative.cpp b/src/coreclr/vm/assemblynative.cpp index d6c612626cceb8..0f0a988a32e081 100644 --- a/src/coreclr/vm/assemblynative.cpp +++ b/src/coreclr/vm/assemblynative.cpp @@ -1306,7 +1306,8 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetLoadContextForAssemb extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_InternalTryGetRawMetadata( QCall::AssemblyHandle assembly, UINT8 **blobRef, - INT32 *lengthRef, BOOL* pReturnValue) + INT32 *lengthRef, + BOOL* pReturnValue) { QCALL_CONTRACT; @@ -1838,7 +1839,8 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeMapLazyDictionary_ProcessAttribute extern "C" QCallExceptionStatus QCALLTYPE TypeMapLazyDictionary_FindPrecachedExternalTypeMapEntry( QCall::ModuleHandle pModule, QCall::TypeHandle pGroupType, - LPCUTF8 key, TADDR* pReturnValue) + LPCUTF8 key, + TADDR* pReturnValue) { QCALL_CONTRACT; _ASSERTE(pModule != NULL); @@ -1871,7 +1873,8 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeMapLazyDictionary_FindPrecachedExt extern "C" QCallExceptionStatus QCALLTYPE TypeMapLazyDictionary_FindPrecachedProxyTypeMapEntry( QCall::ModuleHandle pModule, QCall::TypeHandle pGroupType, - QCall::TypeHandle pType, TADDR* pReturnValue) + QCall::TypeHandle pType, + TADDR* pReturnValue) { QCALL_CONTRACT; _ASSERTE(pModule != NULL); diff --git a/src/coreclr/vm/comdynamic.cpp b/src/coreclr/vm/comdynamic.cpp index 791fa5b6754a83..c9978507ebaf9b 100644 --- a/src/coreclr/vm/comdynamic.cpp +++ b/src/coreclr/vm/comdynamic.cpp @@ -42,7 +42,8 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineGenericParam(QCall:: INT32 tkParent, INT32 attributes, INT32 position, - INT32 * pConstraintTokens, INT32* pReturnValue) + INT32 * pConstraintTokens, + INT32* pReturnValue) { QCALL_CONTRACT; @@ -66,7 +67,8 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineType(QCall::ModuleHa INT32 tkParent, INT32 attributes, INT32 tkEnclosingType, - INT32 * pInterfaceTokens, INT32* pReturnValue) + INT32 * pInterfaceTokens, + INT32* pReturnValue) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/comdynamic.h b/src/coreclr/vm/comdynamic.h index 2f124a4d3a2b1b..82c3817b43d88c 100644 --- a/src/coreclr/vm/comdynamic.h +++ b/src/coreclr/vm/comdynamic.h @@ -43,7 +43,8 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineType(QCall::ModuleHa INT32 tkParent, INT32 attributes, INT32 tkEnclosingType, - INT32 * pInterfaceTokens, INT32* pReturnValue); + INT32 * pInterfaceTokens, + INT32* pReturnValue); extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineGenericParam(QCall::ModuleHandle pModule, @@ -51,7 +52,8 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineGenericParam(QCall:: INT32 tkParent, INT32 attributes, INT32 position, - INT32 * pConstraintTokens, INT32* pReturnValue); + INT32 * pConstraintTokens, + INT32* pReturnValue); // This function will reset the parent class in metadata diff --git a/src/coreclr/vm/commodule.cpp b/src/coreclr/vm/commodule.cpp index 48f2ccd2a73619..b36f85544f25d9 100644 --- a/src/coreclr/vm/commodule.cpp +++ b/src/coreclr/vm/commodule.cpp @@ -24,7 +24,8 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetTypeRef(QCall::ModuleHandle pModule, LPCWSTR wszFullName, QCall::ModuleHandle pRefedModule, - INT32 tkResolutionArg, mdTypeRef* pReturnValue) + INT32 tkResolutionArg, + mdTypeRef* pReturnValue) { QCALL_CONTRACT; @@ -128,7 +129,8 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetArrayMethodToken(QCal INT32 tkTypeSpec, LPCWSTR wszMethodName, LPCBYTE pSignature, - INT32 sigLength, INT32* pReturnValue) + INT32 sigLength, + INT32* pReturnValue) { QCALL_CONTRACT; @@ -442,7 +444,8 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRefFromSignatur INT32 tr, LPCWSTR wszMemberName, LPCBYTE pSignature, - INT32 sigLength, INT32* pReturnValue) + INT32 sigLength, + INT32* pReturnValue) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/commodule.h b/src/coreclr/vm/commodule.h index 8780c4d251ce52..5fed6705a745b7 100644 --- a/src/coreclr/vm/commodule.h +++ b/src/coreclr/vm/commodule.h @@ -22,7 +22,8 @@ class COMModule extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetTypeRef(QCall::ModuleHandle pModule, LPCWSTR wszFullName, QCall::ModuleHandle pRefedModule, - INT32 tkResolution, mdTypeRef* pReturnValue); + INT32 tkResolution, + mdTypeRef* pReturnValue); // SetFieldRVAContent // This function is used to set the FieldRVA with the content data @@ -34,7 +35,8 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetArrayMethodToken(QCal INT32 tkTypeSpec, LPCWSTR wszMethodName, LPCBYTE pSignature, - INT32 sigLength, INT32* pReturnValue); + INT32 sigLength, + INT32* pReturnValue); // GetMemberRefToken // This function will return the MemberRef token @@ -54,7 +56,8 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRefFromSignatur INT32 tr, LPCWSTR wszMemberName, LPCBYTE pSignature, - INT32 sigLength, INT32* pReturnValue); + INT32 sigLength, + INT32* pReturnValue); // GetTokenFromTypeSpec extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetTokenFromTypeSpec(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, mdTypeSpec* pReturnValue); diff --git a/src/coreclr/vm/eventpipeinternal.cpp b/src/coreclr/vm/eventpipeinternal.cpp index b181a3a329294e..06dcdbeae9b07a 100644 --- a/src/coreclr/vm/eventpipeinternal.cpp +++ b/src/coreclr/vm/eventpipeinternal.cpp @@ -19,12 +19,11 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_Enable( EventPipeSerializationFormat format, UINT32 circularBufferSizeInMB, /* COR_PRF_EVENTPIPE_PROVIDER_CONFIG */ LPCVOID pProviders, - UINT32 numProviders, UINT64* pReturnValue) + UINT32 numProviders, + UINT64* pReturnValue) { QCALL_CONTRACT; - UINT64 sessionID = 0; - // Invalid input! if (circularBufferSizeInMB == 0 || format >= EP_SERIALIZATION_FORMAT_COUNT || @@ -36,6 +35,9 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_Enable( } BEGIN_QCALL; + + UINT64 sessionID = 0; + { EventPipeProviderConfigurationAdapter configAdapter(reinterpret_cast(pProviders), numProviders); sessionID = EventPipeAdapter::Enable( @@ -95,7 +97,8 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_GetSessionInfo(UINT6 extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_CreateProvider( _In_z_ LPCWSTR providerName, EventPipeCallback pCallbackFunc, - void* pCallbackContext, INT_PTR* pReturnValue) + void* pCallbackContext, + INT_PTR* pReturnValue) { QCALL_CONTRACT; @@ -117,7 +120,8 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_DefineEvent( UINT32 eventVersion, UINT32 level, void *pMetadata, - UINT32 metadataLength, INT_PTR* pReturnValue) + UINT32 metadataLength, + INT_PTR* pReturnValue) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/eventpipeinternal.h b/src/coreclr/vm/eventpipeinternal.h index 53989396f51133..723e35842706d9 100644 --- a/src/coreclr/vm/eventpipeinternal.h +++ b/src/coreclr/vm/eventpipeinternal.h @@ -44,7 +44,8 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_Enable( EventPipeSerializationFormat format, UINT32 circularBufferSizeInMB, /* COR_PRF_EVENTPIPE_PROVIDER_CONFIG */ LPCVOID pProviders, - UINT32 numProviders, UINT64* pReturnValue); + UINT32 numProviders, + UINT64* pReturnValue); //! //! Disables the specified session Id. @@ -56,7 +57,8 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_GetSessionInfo(UINT6 extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_CreateProvider( _In_z_ LPCWSTR providerName, EventPipeCallback pCallbackFunc, - void* pCallbackContext, INT_PTR* pReturnValue); + void* pCallbackContext, + INT_PTR* pReturnValue); extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_DefineEvent( INT_PTR provHandle, @@ -65,17 +67,20 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_DefineEvent( UINT32 eventVersion, UINT32 level, void *pMetadata, - UINT32 metadataLength, INT_PTR* pReturnValue); + UINT32 metadataLength, + INT_PTR* pReturnValue); extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_GetProvider( - _In_z_ LPCWSTR providerName, INT_PTR* pReturnValue); + _In_z_ LPCWSTR providerName, + INT_PTR* pReturnValue); extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_DeleteProvider( INT_PTR provHandle); extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_EventActivityIdControl( UINT32 controlCode, - GUID *pActivityId, int* pReturnValue); + GUID *pActivityId, + int* pReturnValue); extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_WriteEventData( INT_PTR eventHandle, @@ -85,14 +90,17 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_WriteEventData( extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_GetNextEvent( UINT64 sessionID, - EventPipeEventInstanceData *pInstance, BOOL* pReturnValue); + EventPipeEventInstanceData *pInstance, + BOOL* pReturnValue); extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_SignalSession( - UINT64 sessionID, BOOL* pReturnValue); + UINT64 sessionID, + BOOL* pReturnValue); extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_WaitForSessionSignal( UINT64 sessionID, - INT32 timeoutMs, BOOL* pReturnValue); + INT32 timeoutMs, + BOOL* pReturnValue); #endif // FEATURE_PERFTRACING diff --git a/src/coreclr/vm/interoplibinterface.h b/src/coreclr/vm/interoplibinterface.h index e353c00dfd27e3..375689563ecff1 100644 --- a/src/coreclr/vm/interoplibinterface.h +++ b/src/coreclr/vm/interoplibinterface.h @@ -71,7 +71,8 @@ extern "C" QCallExceptionStatus QCALLTYPE ObjCMarshal_TryInitializeReferenceTrac _In_ ObjCMarshalNative::BeginEndCallback beginEndCallback, _In_ ObjCMarshalNative::IsReferencedCallback isReferencedCallback, _In_ ObjCMarshalNative::EnteredFinalizationCallback trackedObjectEnteredFinalization, - _In_ QCall::ObjectHandleOnStack objectTrackingInfoTable, BOOL* pReturnValue); + _In_ QCall::ObjectHandleOnStack objectTrackingInfoTable, + BOOL* pReturnValue); extern "C" QCallExceptionStatus QCALLTYPE ObjCMarshal_AllocateReferenceTrackingHandle(_In_ QCall::ObjectHandleOnStack obj, void** pReturnValue); @@ -82,7 +83,8 @@ extern "C" void QCALLTYPE ObjCMarshal_GetOrCreateReferenceTrackingMemory( extern "C" QCallExceptionStatus QCALLTYPE ObjCMarshal_TrySetGlobalMessageSendCallback( _In_ ObjCMarshalNative::MessageSendFunction msgSendFunction, - _In_ void* fptr, BOOL* pReturnValue); + _In_ void* fptr, + BOOL* pReturnValue); #endif // FEATURE_OBJCMARSHAL @@ -95,11 +97,13 @@ class JavaNative }; extern "C" QCallExceptionStatus QCALLTYPE JavaMarshal_Initialize( - _In_ void* markCrossReferences, BOOL* pReturnValue); + _In_ void* markCrossReferences, + BOOL* pReturnValue); extern "C" QCallExceptionStatus QCALLTYPE JavaMarshal_CreateReferenceTrackingHandle( _In_ QCall::ObjectHandleOnStack obj, - _In_ void* context, void** pReturnValue); + _In_ void* context, + void** pReturnValue); extern "C" QCallExceptionStatus QCALLTYPE JavaMarshal_FinishCrossReferenceProcessing( _In_ MarkCrossReferencesArgs *crossReferences, diff --git a/src/coreclr/vm/interoplibinterface_java.cpp b/src/coreclr/vm/interoplibinterface_java.cpp index 68858bcffe8de3..b7abac33b1cad6 100644 --- a/src/coreclr/vm/interoplibinterface_java.cpp +++ b/src/coreclr/vm/interoplibinterface_java.cpp @@ -135,7 +135,8 @@ void Interop::FinishCrossReferenceProcessing( } extern "C" QCallExceptionStatus QCALLTYPE JavaMarshal_Initialize( - _In_ void* markCrossReferences, BOOL* pReturnValue) + _In_ void* markCrossReferences, + BOOL* pReturnValue) { QCALL_CONTRACT; _ASSERTE(markCrossReferences != NULL); @@ -164,7 +165,8 @@ extern "C" QCallExceptionStatus QCALLTYPE JavaMarshal_Initialize( extern "C" QCallExceptionStatus QCALLTYPE JavaMarshal_CreateReferenceTrackingHandle( _In_ QCall::ObjectHandleOnStack obj, - _In_ void* context, void** pReturnValue) + _In_ void* context, + void** pReturnValue) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/interoplibinterface_objc.cpp b/src/coreclr/vm/interoplibinterface_objc.cpp index 75647cc72916af..3d0397f87a1617 100644 --- a/src/coreclr/vm/interoplibinterface_objc.cpp +++ b/src/coreclr/vm/interoplibinterface_objc.cpp @@ -28,7 +28,8 @@ extern "C" QCallExceptionStatus QCALLTYPE ObjCMarshal_TryInitializeReferenceTrac _In_ ObjCMarshalNative::BeginEndCallback beginEndCallback, _In_ ObjCMarshalNative::IsReferencedCallback isReferencedCallback, _In_ ObjCMarshalNative::EnteredFinalizationCallback trackedObjectEnteredFinalization, - _In_ QCall::ObjectHandleOnStack objectTrackingInfoTable, BOOL* pReturnValue) + _In_ QCall::ObjectHandleOnStack objectTrackingInfoTable, + BOOL* pReturnValue) { QCALL_CONTRACT; _ASSERTE(beginEndCallback != NULL @@ -121,7 +122,8 @@ namespace extern "C" QCallExceptionStatus QCALLTYPE ObjCMarshal_TrySetGlobalMessageSendCallback( _In_ ObjCMarshalNative::MessageSendFunction msgSendFunction, - _In_ void* fptr, BOOL* pReturnValue) + _In_ void* fptr, + BOOL* pReturnValue) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/jithelpers.cpp b/src/coreclr/vm/jithelpers.cpp index 21cd85f5047739..53c27a6547a30a 100644 --- a/src/coreclr/vm/jithelpers.cpp +++ b/src/coreclr/vm/jithelpers.cpp @@ -676,7 +676,8 @@ void FlushVirtualFunctionPointerCaches() // slow helper to call from the fast one extern "C" QCallExceptionStatus QCALLTYPE ResolveVirtualFunctionPointer(QCall::ObjectHandleOnStack obj, EnregisteredTypeHandle classHnd, - MethodDesc* pStaticMD, PCODE* pReturnValue) + MethodDesc* pStaticMD, + PCODE* pReturnValue) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/runtimehandles.cpp b/src/coreclr/vm/runtimehandles.cpp index b79516d895d9f9..3368a85887a34f 100644 --- a/src/coreclr/vm/runtimehandles.cpp +++ b/src/coreclr/vm/runtimehandles.cpp @@ -97,7 +97,8 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_IsCAVisibleFromDec QCall::TypeHandle targetTypeHandle, MethodDesc * pTargetCtor, QCall::TypeHandle sourceTypeHandle, - QCall::ModuleHandle sourceModuleHandle, BOOL* pReturnValue) + QCall::ModuleHandle sourceModuleHandle, + BOOL* pReturnValue) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/runtimehandles.h b/src/coreclr/vm/runtimehandles.h index aa8516ca7e041c..fbfdff19835ce8 100644 --- a/src/coreclr/vm/runtimehandles.h +++ b/src/coreclr/vm/runtimehandles.h @@ -219,7 +219,8 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_IsCAVisibleFromDec QCall::TypeHandle targetTypeHandle, MethodDesc * pTargetCtor, QCall::TypeHandle sourceTypeHandle, - QCall::ModuleHandle sourceModuleHandle, BOOL* pReturnValue); + QCall::ModuleHandle sourceModuleHandle, + BOOL* pReturnValue); extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray); diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.Internal.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.Internal.cs index 69e68ba7187ba3..624d976c171b3a 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.Internal.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.Internal.cs @@ -18,21 +18,19 @@ internal static partial class EventPipeInternal #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_Enable")] + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_Enable")] private static unsafe partial ulong Enable( char* outputFile, EventPipeSerializationFormat format, uint circularBufferSizeInMB, EventPipeProviderConfigurationNative* providers, - uint numProviders - ); + uint numProviders); #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_Disable")] - internal static partial void Disable(ulong sessionID - ); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_Disable")] + internal static partial void Disable(ulong sessionID); // // These PInvokes are used by EventSource to interact with the EventPipe. @@ -40,46 +38,40 @@ internal static partial void Disable(ulong sessionID #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_CreateProvider", StringMarshalling = StringMarshalling.Utf16)] + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_CreateProvider", StringMarshalling = StringMarshalling.Utf16)] internal static unsafe partial IntPtr CreateProvider(string providerName, delegate* unmanaged callbackFunc, - void* callbackContext - ); + void* callbackContext); #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_DefineEvent")] - internal static unsafe partial IntPtr DefineEvent(IntPtr provHandle, uint eventID, long keywords, uint eventVersion, uint level, void *pMetadata, uint metadataLength - ); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_DefineEvent")] + internal static unsafe partial IntPtr DefineEvent(IntPtr provHandle, uint eventID, long keywords, uint eventVersion, uint level, void *pMetadata, uint metadataLength); #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_GetProvider", StringMarshalling = StringMarshalling.Utf16)] - internal static partial IntPtr GetProvider(string providerName - ); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_GetProvider", StringMarshalling = StringMarshalling.Utf16)] + internal static partial IntPtr GetProvider(string providerName); #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_DeleteProvider")] - internal static partial void DeleteProvider(IntPtr provHandle - ); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_DeleteProvider")] + internal static partial void DeleteProvider(IntPtr provHandle); #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_EventActivityIdControl")] - internal static partial int EventActivityIdControl(uint controlCode, ref Guid activityId - ); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_EventActivityIdControl")] + internal static partial int EventActivityIdControl(uint controlCode, ref Guid activityId); #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_WriteEventData")] - internal static unsafe partial void WriteEventData(IntPtr eventHandle, EventProvider.EventData* pEventData, uint dataCount, Guid* activityId, Guid* relatedActivityId - ); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_WriteEventData")] + internal static unsafe partial void WriteEventData(IntPtr eventHandle, EventProvider.EventData* pEventData, uint dataCount, Guid* activityId, Guid* relatedActivityId); // // These PInvokes are used as part of the EventPipeEventDispatcher. @@ -87,34 +79,30 @@ internal static unsafe partial void WriteEventData(IntPtr eventHandle, EventProv #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_GetSessionInfo")] + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_GetSessionInfo")] [return: MarshalAs(UnmanagedType.Bool)] - internal static unsafe partial bool GetSessionInfo(ulong sessionID, EventPipeSessionInfo* pSessionInfo - ); + internal static unsafe partial bool GetSessionInfo(ulong sessionID, EventPipeSessionInfo* pSessionInfo); #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_GetNextEvent")] + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_GetNextEvent")] [return: MarshalAs(UnmanagedType.Bool)] - internal static unsafe partial bool GetNextEvent(ulong sessionID, EventPipeEventInstanceData* pInstance - ); + internal static unsafe partial bool GetNextEvent(ulong sessionID, EventPipeEventInstanceData* pInstance); #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_SignalSession")] + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_SignalSession")] [return: MarshalAs(UnmanagedType.Bool)] - internal static unsafe partial bool SignalSession(ulong sessionID - ); + internal static unsafe partial bool SignalSession(ulong sessionID); #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_WaitForSessionSignal")] + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_WaitForSessionSignal")] [return: MarshalAs(UnmanagedType.Bool)] - internal static unsafe partial bool WaitForSessionSignal(ulong sessionID, int timeoutMs - ); + internal static unsafe partial bool WaitForSessionSignal(ulong sessionID, int timeoutMs); #else #pragma warning disable IDE0060 private static unsafe ulong Enable( diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.cs index e52efc6d1c2324..a4a2513525150b 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.cs @@ -131,8 +131,7 @@ internal static unsafe ulong Enable( fixed (char* outputFilePath = outputFile) fixed (EventPipeProviderConfigurationNative* providersNativePointer = providersNative) { - return Enable(outputFilePath, format, circularBufferSizeInMB, providersNativePointer, (uint)providersNative.Length - ); + return Enable(outputFilePath, format, circularBufferSizeInMB, providersNativePointer, (uint)providersNative.Length); } } finally diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Threads.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Threads.cs index dc2b4fdff89f12..adf851c68f911c 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Threads.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Threads.cs @@ -34,8 +34,7 @@ private void DispatchEventsToEventListeners(ulong sessionID, DateTime syncTimeUt { if (!eventsReceived) { - EventPipeInternal.WaitForSessionSignal(sessionID, Timeout.Infinite - ); + EventPipeInternal.WaitForSessionSignal(sessionID, Timeout.Infinite); } Thread.Sleep(10); @@ -52,8 +51,7 @@ private void DispatchEventsToEventListeners(ulong sessionID, DateTime syncTimeUt // Disable the old session. This can happen asynchronously since we aren't using the old session // anymore. - EventPipeInternal.Disable(sessionID - ); + EventPipeInternal.Disable(sessionID); } } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Wasm.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Wasm.cs index 79adf7f53dee7f..b9d9acb6db8b51 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Wasm.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.Wasm.cs @@ -44,8 +44,7 @@ private async Task DispatchEventsToEventListeners(ulong sessionID, DateTime sync // the SignalSession() call could be on a disabled session. await Task.Yield(); - EventPipeInternal.Disable(sessionID - ); + EventPipeInternal.Disable(sessionID); } } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.cs index aaccb4137c9db0..dad79d25eaa4c4 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.cs @@ -41,8 +41,7 @@ internal EventListenerSubscription(EventKeywords matchAnyKeywords, EventLevel le private EventPipeEventDispatcher() { // Get the ID of the runtime provider so that it can be used as a filter when processing events. - m_RuntimeProviderID = EventPipeInternal.GetProvider(NativeRuntimeEventSource.EventSourceName - ); + m_RuntimeProviderID = EventPipeInternal.GetProvider(NativeRuntimeEventSource.EventSourceName); } internal void SendCommand(EventListener eventListener, EventCommand command, bool enable, EventLevel level, EventKeywords matchAnyKeywords) @@ -144,8 +143,7 @@ private void SetStopDispatchTask() ulong sessionID = Volatile.Read(ref m_sessionID); Debug.Assert(sessionID != 0); m_dispatchTaskCancellationSource.Cancel(); - EventPipeInternal.SignalSession(sessionID - ); + EventPipeInternal.SignalSession(sessionID); Volatile.Write(ref m_sessionID, 0); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventProvider.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventProvider.cs index 8a058cb6c4eb16..2e49aba519abbc 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventProvider.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventProvider.cs @@ -76,8 +76,7 @@ internal override unsafe void Register(Guid id, string name) Debug.Assert(!_gcHandle.IsAllocated); _gcHandle = new GCHandle(this); - _provHandle = EventPipeInternal.CreateProvider(name, &Callback, (void*)GCHandle.ToIntPtr(_gcHandle) - ); + _provHandle = EventPipeInternal.CreateProvider(name, &Callback, (void*)GCHandle.ToIntPtr(_gcHandle)); if (_provHandle == 0) { // Unable to create the provider. @@ -94,8 +93,7 @@ internal override void Unregister() { if (_provHandle != 0) { - EventPipeInternal.DeleteProvider(_provHandle - ); + EventPipeInternal.DeleteProvider(_provHandle); _provHandle = 0; } _gcHandle.Dispose(); @@ -114,8 +112,7 @@ internal override unsafe EventProvider.WriteEventErrorCode EventWriteTransfer( { if (userDataCount == 0) { - EventPipeInternal.WriteEventData(eventHandle, null, 0, activityId, relatedActivityId - ); + EventPipeInternal.WriteEventData(eventHandle, null, 0, activityId, relatedActivityId); return EventProvider.WriteEventErrorCode.NoError; } @@ -128,8 +125,7 @@ internal override unsafe EventProvider.WriteEventErrorCode EventWriteTransfer( userDataCount -= 3; Debug.Assert(userDataCount >= 0); } - EventPipeInternal.WriteEventData(eventHandle, userData, (uint)userDataCount, activityId, relatedActivityId - ); + EventPipeInternal.WriteEventData(eventHandle, userData, (uint)userDataCount, activityId, relatedActivityId); } return EventProvider.WriteEventErrorCode.NoError; @@ -145,15 +141,13 @@ internal override int ActivityIdControl(Interop.Advapi32.ActivityControl control internal override unsafe IntPtr DefineEventHandle(uint eventID, string eventName, long keywords, uint eventVersion, uint level, byte* pMetadata, uint metadataLength) { - return EventPipeInternal.DefineEvent(_provHandle, eventID, keywords, eventVersion, level, pMetadata, metadataLength - ); + return EventPipeInternal.DefineEvent(_provHandle, eventID, keywords, eventVersion, level, pMetadata, metadataLength); } // Get or set the per-thread activity ID. internal static int EventActivityIdControl(Interop.Advapi32.ActivityControl controlCode, ref Guid activityId) { - return EventPipeInternal.EventActivityIdControl((uint)controlCode, ref activityId - ); + return EventPipeInternal.EventActivityIdControl((uint)controlCode, ref activityId); } } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs index f04ab4cada5fe5..9db66551b9a8fc 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs @@ -12,87 +12,78 @@ internal sealed partial class NativeRuntimeEventSource : EventSource #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogContentionLockCreated")] - private static partial void LogContentionLockCreated(nint LockID, nint AssociatedObjectID, ushort ClrInstanceID - ); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogContentionLockCreated")] + private static partial void LogContentionLockCreated(nint LockID, nint AssociatedObjectID, ushort ClrInstanceID); [NonEvent] #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogContentionStart")] + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogContentionStart")] private static partial void LogContentionStart( ContentionFlagsMap ContentionFlags, ushort ClrInstanceID, nint LockID, nint AssociatedObjectID, - ulong LockOwnerThreadID - ); + ulong LockOwnerThreadID); [NonEvent] #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogContentionStop")] + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogContentionStop")] private static partial void LogContentionStop( ContentionFlagsMap ContentionFlags, ushort ClrInstanceID, - double DurationNs - ); + double DurationNs); [NonEvent] #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadStart")] - private static partial void LogThreadPoolWorkerThreadStart(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID - ); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadStart")] + private static partial void LogThreadPoolWorkerThreadStart(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID); [NonEvent] #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop")] - private static partial void LogThreadPoolWorkerThreadStop(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID - ); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop")] + private static partial void LogThreadPoolWorkerThreadStop(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID); [NonEvent] #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait")] - private static partial void LogThreadPoolWorkerThreadWait(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID - ); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait")] + private static partial void LogThreadPoolWorkerThreadWait(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID); [NonEvent] #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolMinMaxThreads")] - private static partial void LogThreadPoolMinMaxThreads(ushort MinWorkerThreads, ushort MaxWorkerThreads, ushort MinIOCompletionThreads, ushort MaxIOCompletionThreads, ushort ClrInstanceID - ); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolMinMaxThreads")] + private static partial void LogThreadPoolMinMaxThreads(ushort MinWorkerThreads, ushort MaxWorkerThreads, ushort MinIOCompletionThreads, ushort MaxIOCompletionThreads, ushort ClrInstanceID); [NonEvent] #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentSample")] - private static partial void LogThreadPoolWorkerThreadAdjustmentSample(double Throughput, ushort ClrInstanceID - ); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentSample")] + private static partial void LogThreadPoolWorkerThreadAdjustmentSample(double Throughput, ushort ClrInstanceID); [NonEvent] #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentAdjustment")] - private static partial void LogThreadPoolWorkerThreadAdjustmentAdjustment(double AverageThroughput, uint NewWorkerThreadCount, ThreadAdjustmentReasonMap Reason, ushort ClrInstanceID - ); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentAdjustment")] + private static partial void LogThreadPoolWorkerThreadAdjustmentAdjustment(double AverageThroughput, uint NewWorkerThreadCount, ThreadAdjustmentReasonMap Reason, ushort ClrInstanceID); [NonEvent] #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentStats")] + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentStats")] private static partial void LogThreadPoolWorkerThreadAdjustmentStats( double Duration, double Throughput, @@ -104,70 +95,63 @@ private static partial void LogThreadPoolWorkerThreadAdjustmentStats( double Confidence, double NewControlSetting, ushort NewThreadWaveMagnitude, - ushort ClrInstanceID - ); + ushort ClrInstanceID); [NonEvent] #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolIOEnqueue")] + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolIOEnqueue")] private static partial void LogThreadPoolIOEnqueue( IntPtr NativeOverlapped, IntPtr Overlapped, [MarshalAs(UnmanagedType.Bool)] bool MultiDequeues, - ushort ClrInstanceID - ); + ushort ClrInstanceID); [NonEvent] #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolIODequeue")] + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolIODequeue")] private static partial void LogThreadPoolIODequeue( IntPtr NativeOverlapped, IntPtr Overlapped, - ushort ClrInstanceID - ); + ushort ClrInstanceID); [NonEvent] #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkingThreadCount")] + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkingThreadCount")] private static partial void LogThreadPoolWorkingThreadCount( uint Count, - ushort ClrInstanceID - ); + ushort ClrInstanceID); [NonEvent] #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolIOPack")] + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolIOPack")] private static partial void LogThreadPoolIOPack( IntPtr NativeOverlapped, IntPtr Overlapped, - ushort ClrInstanceID - ); + ushort ClrInstanceID); [NonEvent] #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogWaitHandleWaitStart")] + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogWaitHandleWaitStart")] private static partial void LogWaitHandleWaitStart( WaitHandleWaitSourceMap WaitSource, IntPtr AssociatedObjectID, - ushort ClrInstanceID - ); + ushort ClrInstanceID); [NonEvent] #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogWaitHandleWaitStop")] - private static partial void LogWaitHandleWaitStop(ushort ClrInstanceID - ); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogWaitHandleWaitStop")] + private static partial void LogWaitHandleWaitStop(ushort ClrInstanceID); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.cs index c11b1f7dabbeea..1fc333603fdd0a 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.cs @@ -80,8 +80,7 @@ public enum WaitHandleWaitSourceMap : byte private void ContentionLockCreated(nint LockID, nint AssociatedObjectID, ushort ClrInstanceID = DefaultClrInstanceId) { Debug.Assert(IsEnabled(EventLevel.Informational, Keywords.ContentionKeyword)); - LogContentionLockCreated(LockID, AssociatedObjectID, ClrInstanceID - ); + LogContentionLockCreated(LockID, AssociatedObjectID, ClrInstanceID); } [NonEvent] @@ -102,8 +101,7 @@ private void ContentionStart( ulong LockOwnerThreadID) { Debug.Assert(IsEnabled(EventLevel.Informational, Keywords.ContentionKeyword)); - LogContentionStart(ContentionFlags, ClrInstanceID, LockID, AssociatedObjectID, LockOwnerThreadID - ); + LogContentionStart(ContentionFlags, ClrInstanceID, LockID, AssociatedObjectID, LockOwnerThreadID); } [NonEvent] @@ -122,8 +120,7 @@ public void ContentionStart(Lock lockObj) => private void ContentionStop(ContentionFlagsMap ContentionFlags, ushort ClrInstanceID, double DurationNs) { Debug.Assert(IsEnabled(EventLevel.Informational, Keywords.ContentionKeyword)); - LogContentionStop(ContentionFlags, ClrInstanceID, DurationNs - ); + LogContentionStop(ContentionFlags, ClrInstanceID, DurationNs); } [NonEvent] @@ -139,8 +136,7 @@ public void ThreadPoolWorkerThreadStart( { if (IsEnabled(EventLevel.Informational, Keywords.ThreadingKeyword)) { - LogThreadPoolWorkerThreadStart(ActiveWorkerThreadCount, RetiredWorkerThreadCount, ClrInstanceID - ); + LogThreadPoolWorkerThreadStart(ActiveWorkerThreadCount, RetiredWorkerThreadCount, ClrInstanceID); } } @@ -152,8 +148,7 @@ public void ThreadPoolWorkerThreadStop( { if (IsEnabled(EventLevel.Informational, Keywords.ThreadingKeyword)) { - LogThreadPoolWorkerThreadStop(ActiveWorkerThreadCount, RetiredWorkerThreadCount, ClrInstanceID - ); + LogThreadPoolWorkerThreadStop(ActiveWorkerThreadCount, RetiredWorkerThreadCount, ClrInstanceID); } } @@ -166,8 +161,7 @@ public void ThreadPoolWorkerThreadWait( { if (IsEnabled(EventLevel.Informational, Keywords.ThreadingKeyword)) { - LogThreadPoolWorkerThreadWait(ActiveWorkerThreadCount, RetiredWorkerThreadCount, ClrInstanceID - ); + LogThreadPoolWorkerThreadWait(ActiveWorkerThreadCount, RetiredWorkerThreadCount, ClrInstanceID); } } @@ -180,8 +174,7 @@ public void ThreadPoolWorkerThreadAdjustmentSample( { return; } - LogThreadPoolWorkerThreadAdjustmentSample(Throughput, ClrInstanceID - ); + LogThreadPoolWorkerThreadAdjustmentSample(Throughput, ClrInstanceID); } [Event(55, Level = EventLevel.Informational, Message = Messages.WorkerThreadAdjustmentAdjustment, Task = Tasks.ThreadPoolWorkerThreadAdjustment, Opcode = Opcodes.Adjustment, Version = 0, Keywords = Keywords.ThreadingKeyword)] @@ -195,8 +188,7 @@ public void ThreadPoolWorkerThreadAdjustmentAdjustment( { return; } - LogThreadPoolWorkerThreadAdjustmentAdjustment(AverageThroughput, NewWorkerThreadCount, Reason, ClrInstanceID - ); + LogThreadPoolWorkerThreadAdjustmentAdjustment(AverageThroughput, NewWorkerThreadCount, Reason, ClrInstanceID); } [Event(56, Level = EventLevel.Verbose, Message = Messages.WorkerThreadAdjustmentStats, Task = Tasks.ThreadPoolWorkerThreadAdjustment, Opcode = Opcodes.Stats, Version = 0, Keywords = Keywords.ThreadingKeyword)] @@ -217,8 +209,7 @@ public void ThreadPoolWorkerThreadAdjustmentStats( { return; } - LogThreadPoolWorkerThreadAdjustmentStats(Duration, Throughput, ThreadWave, ThroughputWave, ThroughputErrorEstimate, AverageThroughputErrorEstimate, ThroughputRatio, Confidence, NewControlSetting, NewThreadWaveMagnitude, ClrInstanceID - ); + LogThreadPoolWorkerThreadAdjustmentStats(Duration, Throughput, ThreadWave, ThroughputWave, ThroughputErrorEstimate, AverageThroughputErrorEstimate, ThroughputRatio, Confidence, NewControlSetting, NewThreadWaveMagnitude, ClrInstanceID); } [Event(63, Level = EventLevel.Verbose, Message = Messages.IOEnqueue, Task = Tasks.ThreadPool, Opcode = Opcodes.IOEnqueue, Version = 0, Keywords = Keywords.ThreadingKeyword | Keywords.ThreadTransferKeyword)] @@ -228,8 +219,7 @@ private void ThreadPoolIOEnqueue( bool MultiDequeues, ushort ClrInstanceID = DefaultClrInstanceId) { - LogThreadPoolIOEnqueue(NativeOverlapped, Overlapped, MultiDequeues, ClrInstanceID - ); + LogThreadPoolIOEnqueue(NativeOverlapped, Overlapped, MultiDequeues, ClrInstanceID); } [NonEvent] @@ -270,8 +260,7 @@ private void ThreadPoolIODequeue( IntPtr Overlapped, // 0 if the Windows thread pool is used, the relevant info could be obtained from the NativeOverlapped* if necessary ushort ClrInstanceID = DefaultClrInstanceId) { - LogThreadPoolIODequeue(NativeOverlapped, Overlapped, ClrInstanceID - ); + LogThreadPoolIODequeue(NativeOverlapped, Overlapped, ClrInstanceID); } [NonEvent] @@ -310,8 +299,7 @@ public void ThreadPoolWorkingThreadCount(uint Count, ushort ClrInstanceID = Defa { return; } - LogThreadPoolWorkingThreadCount(Count, ClrInstanceID - ); + LogThreadPoolWorkingThreadCount(Count, ClrInstanceID); } [NonEvent] @@ -337,8 +325,7 @@ private void ThreadPoolIOPack( IntPtr Overlapped, // 0 if the Windows thread pool is used, the relevant info could be obtained from the NativeOverlapped* if necessary ushort ClrInstanceID = DefaultClrInstanceId) { - LogThreadPoolIOPack(NativeOverlapped, Overlapped, ClrInstanceID - ); + LogThreadPoolIOPack(NativeOverlapped, Overlapped, ClrInstanceID); } @@ -352,8 +339,7 @@ public void ThreadPoolMinMaxThreads( { if (IsEnabled(EventLevel.Informational, Keywords.ThreadingKeyword)) { - LogThreadPoolMinMaxThreads(MinWorkerThreads, MaxWorkerThreads, MinIOCompletionThreads, MaxIOCompletionThreads, ClrInstanceID - ); + LogThreadPoolMinMaxThreads(MinWorkerThreads, MaxWorkerThreads, MinIOCompletionThreads, MaxIOCompletionThreads, ClrInstanceID); } } @@ -364,8 +350,7 @@ private void WaitHandleWaitStart( ushort ClrInstanceID = DefaultClrInstanceId) { Debug.Assert(IsEnabled(EventLevel.Verbose, Keywords.WaitHandleKeyword)); - LogWaitHandleWaitStart(WaitSource, AssociatedObjectID, ClrInstanceID - ); + LogWaitHandleWaitStart(WaitSource, AssociatedObjectID, ClrInstanceID); } [NonEvent] @@ -379,8 +364,7 @@ public void WaitHandleWaitStart( public void WaitHandleWaitStop(ushort ClrInstanceID = DefaultClrInstanceId) { Debug.Assert(IsEnabled(EventLevel.Verbose, Keywords.WaitHandleKeyword)); - LogWaitHandleWaitStop(ClrInstanceID - ); + LogWaitHandleWaitStop(ClrInstanceID); } } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs index f5e532cc46004f..d6415941ca6e17 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs @@ -25,9 +25,8 @@ public XplatEventLogger() { } #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, StringMarshalling = StringMarshalling.Utf16)] - private static unsafe partial char* EventSource_GetClrConfig(string configName - ); + [LibraryImport(RuntimeHelpers.QCall, StringMarshalling = StringMarshalling.Utf16)] + private static unsafe partial char* EventSource_GetClrConfig(string configName); private static bool initializedPersistentListener; @@ -49,17 +48,15 @@ public XplatEventLogger() { } #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall)] + [LibraryImport(RuntimeHelpers.QCall)] [return: MarshalAs(UnmanagedType.Bool)] - private static partial bool IsEventSourceLoggingEnabled( - ); + private static partial bool IsEventSourceLoggingEnabled(); #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, StringMarshalling = StringMarshalling.Utf16)] - private static partial void LogEventSource(int eventID, string? eventName, string eventSourceName, string payload - ); + [LibraryImport(RuntimeHelpers.QCall, StringMarshalling = StringMarshalling.Utf16)] + private static partial void LogEventSource(int eventID, string? eventName, string eventSourceName, string payload); private static readonly List escape_seq = new List { '\b', '\f', '\n', '\r', '\t', '\"', '\\' }; private static readonly Dictionary seq_mapping = new Dictionary() @@ -208,8 +205,7 @@ private static void LogOnEventWritten(EventWrittenEventArgs eventData) } } - LogEventSource(eventData.EventId, eventData.EventName, eventData.EventSource.Name, payload - ); + LogEventSource(eventData.EventId, eventData.EventName, eventData.EventSource.Name, payload); } } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/TypeMapLazyDictionary.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/TypeMapLazyDictionary.cs index 13f58b9002474c..c6d87ed3a2b956 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/TypeMapLazyDictionary.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/TypeMapLazyDictionary.cs @@ -83,7 +83,7 @@ public unsafe struct ProcessAttributesCallbackArg #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeMapLazyDictionary_ProcessAttributes")] + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeMapLazyDictionary_ProcessAttributes")] private static unsafe partial void ProcessAttributes( QCallAssembly assembly, QCallTypeHandle groupType, @@ -91,22 +91,19 @@ private static unsafe partial void ProcessAttributes( delegate* unmanaged newProxyTypeEntry, delegate* unmanaged newPrecachedExternalTypeMap, delegate* unmanaged newPrecachedProxyTypeMap, - CallbackContext* context - ); + CallbackContext* context); #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeMapLazyDictionary_FindPrecachedExternalTypeMapEntry", StringMarshalling = StringMarshalling.Utf8)] - private static unsafe partial IntPtr FindPrecachedExternalTypeMapEntry(QCallModule module, QCallTypeHandle groupType, string key - ); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeMapLazyDictionary_FindPrecachedExternalTypeMapEntry", StringMarshalling = StringMarshalling.Utf8)] + private static unsafe partial IntPtr FindPrecachedExternalTypeMapEntry(QCallModule module, QCallTypeHandle groupType, string key); #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] #endif - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeMapLazyDictionary_FindPrecachedProxyTypeMapEntry")] - private static unsafe partial IntPtr FindPrecachedProxyTypeMapEntry(QCallModule module, QCallTypeHandle groupType, QCallTypeHandle type - ); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeMapLazyDictionary_FindPrecachedProxyTypeMapEntry")] + private static unsafe partial IntPtr FindPrecachedProxyTypeMapEntry(QCallModule module, QCallTypeHandle groupType, QCallTypeHandle type); public ref struct Utf16SharedBuffer { @@ -276,8 +273,7 @@ private static unsafe CallbackContext CreateMaps( newProxyTypeEntry, &NewPrecachedExternalTypeMap, &NewPrecachedProxyTypeMap, - &context - ); + &context); // If an exception was thrown during the processing of // the attributes, rethrow it. @@ -422,8 +418,7 @@ private sealed class LazyExternalTypeDictionary : LazyTypeLoadDictionary protected override bool TryGetOrLoadTypeFromPreCachedDictionary(RuntimeModule module, string key, [NotNullWhen(true)] out Type? type) { - IntPtr handle = FindPrecachedExternalTypeMapEntry(new QCallModule(ref module), new QCallTypeHandle(ref _groupType), key - ); + IntPtr handle = FindPrecachedExternalTypeMapEntry(new QCallModule(ref module), new QCallTypeHandle(ref _groupType), key); type = RuntimeTypeHandle.GetRuntimeTypeFromHandleMaybeNull(handle); return type != null; } @@ -498,8 +493,7 @@ public void Add(SourceProxyPair newEntryMaybe) protected override bool TryGetOrLoadTypeFromPreCachedDictionary(RuntimeModule module, Type key, [NotNullWhen(true)] out Type? type) { RuntimeType rtKey = (RuntimeType)key; - IntPtr handle = FindPrecachedProxyTypeMapEntry(new QCallModule(ref module), new QCallTypeHandle(ref _groupType), new QCallTypeHandle(ref rtKey) - ); + IntPtr handle = FindPrecachedProxyTypeMapEntry(new QCallModule(ref module), new QCallTypeHandle(ref _groupType), new QCallTypeHandle(ref rtKey)); type = RuntimeTypeHandle.GetRuntimeTypeFromHandleMaybeNull(handle); return type != null; } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.cs index 603d9eae3f5704..8064d2a46a7bd1 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.cs @@ -101,8 +101,7 @@ private protected AssemblyLoadContext(bool representsTPALoadContext, bool isColl // If this is a collectible ALC, we are creating a weak handle tracking resurrection otherwise we use a strong handle var thisHandle = GCHandle.Alloc(this, IsCollectible ? GCHandleType.WeakTrackResurrection : GCHandleType.Normal); var thisHandlePtr = GCHandle.ToIntPtr(thisHandle); - _nativeAssemblyLoadContext = InitializeAssemblyLoadContext(thisHandlePtr, representsTPALoadContext, isCollectible - ); + _nativeAssemblyLoadContext = InitializeAssemblyLoadContext(thisHandlePtr, representsTPALoadContext, isCollectible); // Add this instance to the list of alive ALC Dictionary> allContexts = AllContexts; @@ -150,8 +149,7 @@ private void InitiateUnload() var thisStrongHandlePtr = GCHandle.ToIntPtr(thisStrongHandle); // The underlying code will transform the original weak handle // created by InitializeLoadContext to a strong handle - PrepareForAssemblyLoadContextRelease(_nativeAssemblyLoadContext, thisStrongHandlePtr - ); + PrepareForAssemblyLoadContextRelease(_nativeAssemblyLoadContext, thisStrongHandlePtr); _state = InternalState.Unloading; } diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.Windows.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.Windows.cs index c4eb1ecde674f9..18373595f96c3c 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.Windows.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.Windows.cs @@ -65,8 +65,7 @@ private static unsafe int WaitForMultipleObjectsIgnoringSyncContext(IntPtr* pHan if (reentrantWait) { Debug.Assert(!waitAll); - result = Thread.ReentrantWaitAny(true, millisecondsTimeout, numHandles, pHandles - ); + result = Thread.ReentrantWaitAny(true, millisecondsTimeout, numHandles, pHandles); } else { From aa5802e137ac6f829a2b7e7ff885a0f2e39c8cf9 Mon Sep 17 00:00:00 2001 From: David Wrighton Date: Tue, 1 Sep 2026 12:19:47 -0700 Subject: [PATCH 19/23] Address QCall review feedback Clean up accidental formatting and redundant conditionals introduced by the QCall migration. Make the COM stack trace assertion tolerate non-frame and additional lines while preserving frame-order validation. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 31769fe8-86a0-4379-91f3-5353097eb47c --- src/coreclr/vm/excep.cpp | 6 +++--- .../src/System/AppContext.cs | 3 +-- .../Tracing/EventPipeEventDispatcher.cs | 6 ++---- .../Tracing/TraceLogging/XplatEventLogger.cs | 3 +-- .../src/System/Environment.cs | 4 ---- .../Runtime/InteropServices/ComWrappers.cs | 4 ---- .../src/System/Threading/Lock.cs | 4 ---- .../src/System/Threading/Thread.cs | 4 ---- .../COM/NETClients/Primitives/StringTests.cs | 17 +++++++++++------ 9 files changed, 18 insertions(+), 33 deletions(-) diff --git a/src/coreclr/vm/excep.cpp b/src/coreclr/vm/excep.cpp index bc3a83e9bfe2ae..c274760bb9566a 100644 --- a/src/coreclr/vm/excep.cpp +++ b/src/coreclr/vm/excep.cpp @@ -6575,7 +6575,7 @@ void CLRAddVectoredHandlers(void) } // -// This does the work of the Unwind and Continue Hanlder inside the catch clause of that handler. The stack has not +// This does the work of the Unwind and Continue Handler inside the catch clause of that handler. The stack has not // been unwound when this is called. Keep that in mind when deciding where to put new code :) // void UnwindAndContinueRethrowHelperInsideCatch(Frame* pEntryFrame, Exception* pException) @@ -6613,7 +6613,7 @@ void UnwindAndContinueRethrowHelperInsideCatch(Frame* pEntryFrame, Exception* pE } // -// This does the work of the Unwind and Continue Hanlder inside the catch clause of that handler. The stack has not +// This does the work of the Unwind and Continue Handler inside the catch clause of that handler. The stack has not // been unwound when this is called. Keep that in mind when deciding where to put new code :) // void UnwindAndContinueRethrowHelperInsideQcallCatch( @@ -6681,7 +6681,7 @@ void CaptureQCallExceptionFromPALException(PAL_SEHException& exception, QCallExc #endif // -// This does the work of the Unwind and Continue Hanlder after the catch clause of that handler. The stack has been +// This does the work of the Unwind and Continue Handler after the catch clause of that handler. The stack has been // unwound by the time this is called. Keep that in mind when deciding where to put new code :) // VOID DECLSPEC_NORETURN UnwindAndContinueRethrowHelperAfterCatch(Frame* pEntryFrame, Exception* pException, bool nativeRethrow) diff --git a/src/libraries/System.Private.CoreLib/src/System/AppContext.cs b/src/libraries/System.Private.CoreLib/src/System/AppContext.cs index 500aaee87d3ad2..d6ec02150e2a49 100644 --- a/src/libraries/System.Private.CoreLib/src/System/AppContext.cs +++ b/src/libraries/System.Private.CoreLib/src/System/AppContext.cs @@ -53,8 +53,7 @@ public static partial class AppContext if (IsKnownHostProperty(name)) { string? value = null; - if (TryGetHostPropertyValue(name, new StringHandleOnStack(ref value) - )) + if (TryGetHostPropertyValue(name, new StringHandleOnStack(ref value))) { lock (s_dataStore) { diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.cs index dad79d25eaa4c4..ec8091cfc34453 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipeEventDispatcher.cs @@ -112,8 +112,7 @@ private void CommitDispatchConfiguration() EventPipeSessionInfo sessionInfo; unsafe { - if (!EventPipeInternal.GetSessionInfo(sessionID, &sessionInfo - )) + if (!EventPipeInternal.GetSessionInfo(sessionID, &sessionInfo)) { Debug.Fail("GetSessionInfo returned false."); } @@ -155,8 +154,7 @@ private unsafe bool DispatchEventsToEventListenersOnce(ulong sessionID, DateTime EventPipeEventInstanceData instanceData; // Get the next event. - while (!token.IsCancellationRequested && EventPipeInternal.GetNextEvent(sessionID, &instanceData - )) + while (!token.IsCancellationRequested && EventPipeInternal.GetNextEvent(sessionID, &instanceData)) { eventsReceived = true; diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs index d6415941ca6e17..51b638c07d2acb 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs @@ -19,8 +19,7 @@ public XplatEventLogger() { } private static readonly string s_eventSourceNameFilter = GetClrConfig("EventSourceFilter"); private static readonly string s_eventSourceEventFilter = GetClrConfig("EventNameFilter"); - private static unsafe string GetClrConfig(string configName) => new string(EventSource_GetClrConfig(configName - )); + private static unsafe string GetClrConfig(string configName) => new string(EventSource_GetClrConfig(configName)); #if CORECLR [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] diff --git a/src/libraries/System.Private.CoreLib/src/System/Environment.cs b/src/libraries/System.Private.CoreLib/src/System/Environment.cs index 1e5eb2333e2b47..dabc44cab4c4bf 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Environment.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Environment.cs @@ -39,11 +39,7 @@ public readonly struct ProcessCpuUsage /// Gets whether the current machine has only a single processor. /// internal static bool IsSingleProcessor => RuntimeFeature.IsMultithreadingSupported ? ProcessorCount == 1 : true; -#if CORECLR public static int ProcessorCount { get; } = RuntimeFeature.IsMultithreadingSupported ? GetProcessorCount() : 1; -#else - public static int ProcessorCount { get; } = RuntimeFeature.IsMultithreadingSupported ? GetProcessorCount() : 1; -#endif private static NullableBool s_privilegedProcess; diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.cs index cf36be5c39edc6..8362b47016ee07 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.cs @@ -479,11 +479,7 @@ internal sealed unsafe partial class ManagedObjectWrapperHolder { static ManagedObjectWrapperHolder() { -#if CORECLR RegisterIsRootedCallback(); -#else - RegisterIsRootedCallback(); -#endif } private readonly ManagedObjectWrapperReleaser _releaser; diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Lock.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Lock.cs index 1bbdbd8d2b5a92..bf3a2a70ec5b60 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Lock.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Lock.cs @@ -875,11 +875,7 @@ private static bool TryInitializeStatics() // Not using Environment.ProcessorCount here as it involves class construction, and if that property is // already being constructed earlier in the stack on the same thread, it would return the default value // here. Initialize s_isSingleProcessor first, as it may be used by other initialization afterwards. -#if CORECLR - s_isSingleProcessor = Environment.GetProcessorCount() == 1; -#else s_isSingleProcessor = Environment.GetProcessorCount() == 1; -#endif s_maxSpinCount = DetermineMaxSpinCount(); s_minSpinCountForAdaptiveSpin = DetermineMinSpinCountForAdaptiveSpin(); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.cs index d52396d7e851a6..ea1a24b625f4fd 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.cs @@ -376,11 +376,7 @@ public static void Sleep(int millisecondsTimeout) #if !NATIVEAOT /// Returns the operating system identifier for the current thread. -#if CORECLR internal static ulong CurrentOSThreadId => GetCurrentOSThreadId(); -#else - internal static ulong CurrentOSThreadId => GetCurrentOSThreadId(); -#endif #endif #if !MONO diff --git a/src/tests/Interop/COM/NETClients/Primitives/StringTests.cs b/src/tests/Interop/COM/NETClients/Primitives/StringTests.cs index baa976e5ae2b0f..331d3bec9be560 100644 --- a/src/tests/Interop/COM/NETClients/Primitives/StringTests.cs +++ b/src/tests/Interop/COM/NETClients/Primitives/StringTests.cs @@ -202,13 +202,18 @@ private void Marshal_LPWString() }; string[] actualStackTrace = exception.StackTrace! .Split(Environment.NewLine) - .Select(static frame => - { - int methodStart = frame.IndexOf("at ", StringComparison.Ordinal) + "at ".Length; - return frame.Substring(methodStart, frame.IndexOf('(') - methodStart); - }) + .Select(static frame => frame.TrimStart()) + .Where(static frame => frame.StartsWith("at ", StringComparison.Ordinal) && frame.Contains('(')) + .Select(static frame => frame.Substring("at ".Length, frame.IndexOf('(') - "at ".Length)) .ToArray(); - Assert.Equal(expectedStackTrace, actualStackTrace); + + int actualFrameIndex = 0; + foreach (string expectedFrame in expectedStackTrace) + { + actualFrameIndex = Array.IndexOf(actualStackTrace, expectedFrame, actualFrameIndex); + Assert.True(actualFrameIndex >= 0, $"Expected stack frame '{expectedFrame}' was not found in order."); + actualFrameIndex++; + } } foreach (var s in reversibleStrings) From b5c08b0907a09bd7701074e2f582ad398c14225d Mon Sep 17 00:00:00 2001 From: David Wrighton Date: Tue, 1 Sep 2026 19:19:30 -0700 Subject: [PATCH 20/23] Use hidden last parameter for QCall errors Restore normal native QCall return values and pass exception status through a hidden final parameter. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 3bf4a72c-55aa-4b64-8dc3-c0fbeb82730c --- .../Runtime/CompilerHelpers/ThrowHelpers.cs | 10 +- .../VersionResilientHashCode.CoreCLR.cs | 2 +- .../src/System/AppContext.CoreCLR.cs | 2 +- .../src/System/ArgIterator.cs | 10 +- .../src/System/Array.CoreCLR.cs | 6 +- .../src/System/CLRConfig.cs | 2 +- .../System/ComAwareWeakReference.CoreCLR.cs | 4 +- .../src/System/Delegate.CoreCLR.cs | 16 +- .../src/System/Diagnostics/Debugger.cs | 4 +- .../System/Diagnostics/StackFrame.CoreCLR.cs | 2 +- .../System/Diagnostics/StackTrace.CoreCLR.cs | 2 +- .../src/System/Enum.CoreCLR.cs | 2 +- .../src/System/Environment.CoreCLR.cs | 6 +- .../src/System/Exception.CoreCLR.cs | 6 +- .../src/System/GC.CoreCLR.cs | 38 +- .../System/IO/FileLoadException.CoreCLR.cs | 4 +- .../src/System/IO/Stream.CoreCLR.cs | 2 +- .../src/System/Reflection/Assembly.CoreCLR.cs | 4 +- .../System/Reflection/AssemblyName.CoreCLR.cs | 2 +- .../Reflection/Emit/RuntimeAssemblyBuilder.cs | 2 +- .../Reflection/Emit/RuntimeModuleBuilder.cs | 18 +- .../Reflection/Emit/RuntimeTypeBuilder.cs | 42 +-- .../src/System/Reflection/LoaderAllocator.cs | 2 +- .../src/System/Reflection/MdImport.cs | 2 +- .../Reflection/Metadata/AssemblyExtensions.cs | 2 +- .../Reflection/Metadata/MetadataUpdater.cs | 4 +- .../System/Reflection/MethodBase.CoreCLR.cs | 2 +- .../src/System/Reflection/RuntimeAssembly.cs | 46 +-- .../Reflection/RuntimeCustomAttributeData.cs | 4 +- .../src/System/Reflection/RuntimeModule.cs | 6 +- .../Reflection/TypeNameResolver.CoreCLR.cs | 2 +- .../CompilerServices/AsyncHelpers.CoreCLR.cs | 2 +- .../Runtime/CompilerServices/CastHelpers.cs | 4 +- .../CompilerServices/GenericsHelpers.cs | 2 +- .../Runtime/CompilerServices/InitHelpers.cs | 2 +- .../RuntimeHelpers.CoreCLR.cs | 24 +- .../CompilerServices/StaticsHelpers.cs | 4 +- .../VirtualDispatchHelpers.cs | 2 +- .../Runtime/ControlledExecution.CoreCLR.cs | 2 +- .../src/System/Runtime/DependentHandle.cs | 4 +- .../ExceptionServices/InternalCalls.cs | 10 +- .../InteropServices/ComWrappers.CoreCLR.cs | 4 +- .../InteropServices/GCHandle.CoreCLR.cs | 6 +- .../Java/JavaMarshal.CoreCLR.cs | 6 +- .../InteropServices/Marshal.CoreCLR.cs | 58 +-- .../InteropServices/NativeLibrary.CoreCLR.cs | 2 +- .../ObjectiveCMarshal.CoreCLR.cs | 6 +- .../TrackerObjectManager.CoreCLR.cs | 2 +- .../Loader/AssemblyLoadContext.CoreCLR.cs | 26 +- .../src/System/RuntimeHandles.cs | 122 +++--- .../src/System/RuntimeType.BoxCache.cs | 2 +- .../src/System/RuntimeType.CoreCLR.cs | 8 +- ...meType.CreateUninitializedCache.CoreCLR.cs | 2 +- .../src/System/String.CoreCLR.cs | 4 +- .../src/System/StubHelpers.cs | 46 +-- .../System/Threading/ObjectHeader.CoreCLR.cs | 2 +- .../src/System/Threading/Thread.CoreCLR.cs | 30 +- .../src/System/TypeLoadException.CoreCLR.cs | 2 +- .../src/System/ValueType.cs | 4 +- .../src/System/Variant.cs | 4 +- src/coreclr/vm/JitQCallHelpers.h | 14 +- src/coreclr/vm/appdomainnative.cpp | 18 +- src/coreclr/vm/appdomainnative.hpp | 10 +- src/coreclr/vm/arraynative.cpp | 14 +- src/coreclr/vm/arraynative.h | 6 +- src/coreclr/vm/assemblynative.cpp | 188 +++++----- src/coreclr/vm/assemblynative.hpp | 92 ++--- src/coreclr/vm/clrconfignative.cpp | 9 +- src/coreclr/vm/clrconfignative.h | 2 +- src/coreclr/vm/comdelegate.cpp | 55 +-- src/coreclr/vm/comdelegate.h | 22 +- src/coreclr/vm/comdependenthandle.cpp | 12 +- src/coreclr/vm/comdependenthandle.h | 4 +- src/coreclr/vm/comdynamic.cpp | 121 +++--- src/coreclr/vm/comdynamic.h | 49 +-- src/coreclr/vm/commodule.cpp | 109 +++--- src/coreclr/vm/commodule.h | 34 +- src/coreclr/vm/comsynchronizable.cpp | 90 ++--- src/coreclr/vm/comsynchronizable.h | 34 +- src/coreclr/vm/comutilnative.cpp | 211 +++++------ src/coreclr/vm/comutilnative.h | 86 ++--- src/coreclr/vm/coreassemblyspec.cpp | 2 +- src/coreclr/vm/customattribute.cpp | 10 +- src/coreclr/vm/customattribute.h | 10 +- src/coreclr/vm/debugdebugger.cpp | 31 +- src/coreclr/vm/debugdebugger.h | 16 +- src/coreclr/vm/eventpipeinternal.cpp | 89 +++-- src/coreclr/vm/eventpipeinternal.h | 46 +-- src/coreclr/vm/excep.cpp | 6 +- src/coreclr/vm/exceptionhandling.cpp | 42 +-- src/coreclr/vm/exceptionhandlingqcalls.h | 10 +- src/coreclr/vm/finalizerthread.cpp | 11 +- src/coreclr/vm/ilmarshalers.cpp | 16 +- src/coreclr/vm/ilmarshalers.h | 10 +- src/coreclr/vm/interoplibinterface.h | 23 +- .../vm/interoplibinterface_comwrappers.cpp | 14 +- .../vm/interoplibinterface_comwrappers.h | 6 +- src/coreclr/vm/interoplibinterface_java.cpp | 29 +- src/coreclr/vm/interoplibinterface_objc.cpp | 34 +- src/coreclr/vm/jithelpers.cpp | 40 +- src/coreclr/vm/loaderallocator.cpp | 10 +- src/coreclr/vm/loaderallocator.hpp | 2 +- src/coreclr/vm/managedmdimport.cpp | 5 +- src/coreclr/vm/managedmdimport.hpp | 5 +- src/coreclr/vm/marshalnative.cpp | 182 +++++---- src/coreclr/vm/marshalnative.h | 64 ++-- src/coreclr/vm/method.hpp | 2 +- src/coreclr/vm/mlinfo.cpp | 2 +- src/coreclr/vm/multicorejit.cpp | 4 +- src/coreclr/vm/multicorejit.h | 4 +- src/coreclr/vm/nativeeventsource.cpp | 57 +-- src/coreclr/vm/nativeeventsource.h | 38 +- src/coreclr/vm/nativelibrarynative.cpp | 13 +- src/coreclr/vm/nativelibrarynative.h | 5 +- src/coreclr/vm/olevariant.cpp | 2 +- src/coreclr/vm/olevariant.h | 2 +- src/coreclr/vm/qcall.h | 20 +- src/coreclr/vm/reflectioninvocation.cpp | 102 ++--- src/coreclr/vm/reflectioninvocation.h | 28 +- src/coreclr/vm/runtimehandles.cpp | 278 +++++++------- src/coreclr/vm/runtimehandles.h | 154 ++++---- src/coreclr/vm/stackwalk.h | 4 +- src/coreclr/vm/stubhelpers.cpp | 49 +-- src/coreclr/vm/stubhelpers.h | 36 +- src/coreclr/vm/tailcallhelp.cpp | 10 +- src/coreclr/vm/tailcallhelp.h | 2 +- src/coreclr/vm/unsafeaccessors.cpp | 10 +- src/coreclr/vm/varargsnative.cpp | 18 +- src/coreclr/vm/varargsnative.h | 10 +- src/coreclr/vm/versionresilienthashcode.cpp | 10 +- src/coreclr/vm/versionresilienthashcode.h | 2 +- .../browser/callhelpers-interp-to-managed.cpp | 266 ++++++++----- src/coreclr/vm/wasm/entrypoints.h | 4 +- .../wasi/callhelpers-interp-to-managed.cpp | 352 ++++++++---------- src/coreclr/vm/weakreferencenative.cpp | 13 +- src/coreclr/vm/weakreferencenative.h | 4 +- .../Diagnostics/Tracing/EventPipe.Internal.cs | 24 +- ...ntSource.Threading.NativeSinks.Internal.cs | 32 +- .../Tracing/TraceLogging/XplatEventLogger.cs | 6 +- .../InteropServices/TypeMapLazyDictionary.cs | 6 +- .../Threading/Wasi/WasiFinalizerScheduler.cs | 4 +- 141 files changed, 2091 insertions(+), 2023 deletions(-) diff --git a/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs b/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs index 8cef1a4eee0165..da33b9dae93f37 100644 --- a/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs @@ -11,7 +11,7 @@ namespace Internal.Runtime.CompilerHelpers internal static unsafe partial class ThrowHelpers { [DoesNotReturn] - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowAmbiguousResolutionException")] private static partial void ThrowAmbiguousResolutionException(MethodTable* targetType, MethodTable* interfaceType, void* methodDesc); @@ -26,7 +26,7 @@ internal static void ThrowAmbiguousResolutionException( } [DoesNotReturn] - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowEntryPointNotFoundException")] private static partial void ThrowEntryPointNotFoundException(MethodTable* targetType, MethodTable* interfaceType, void* methodDesc); @@ -41,7 +41,7 @@ internal static void ThrowEntryPointNotFoundException( } [DoesNotReturn] - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowMethodAccessException")] private static partial void ThrowMethodAccessExceptionInternal(void* caller, void* callee); @@ -56,7 +56,7 @@ internal static void ThrowMethodAccessException( } [DoesNotReturn] - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowFieldAccessException")] private static partial void ThrowFieldAccessExceptionInternal(void* caller, void* callee); @@ -71,7 +71,7 @@ internal static void ThrowFieldAccessException( } [DoesNotReturn] - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowClassAccessException")] private static partial void ThrowClassAccessExceptionInternal(void* caller, void* callee); diff --git a/src/coreclr/System.Private.CoreLib/src/Internal/VersionResilientHashCode.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/Internal/VersionResilientHashCode.CoreCLR.cs index e510aa9e7901ce..536df305c19fba 100644 --- a/src/coreclr/System.Private.CoreLib/src/Internal/VersionResilientHashCode.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/Internal/VersionResilientHashCode.CoreCLR.cs @@ -13,7 +13,7 @@ namespace Internal /// internal static partial class VersionResilientHashCode { - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "VersionResilientHashCode_TypeHashCode")] private static partial int TypeHashCode(QCallTypeHandle typeHandle); diff --git a/src/coreclr/System.Private.CoreLib/src/System/AppContext.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/AppContext.CoreCLR.cs index 08d00252cc4e86..b6ad69578ddc66 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/AppContext.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/AppContext.CoreCLR.cs @@ -16,7 +16,7 @@ private static bool IsKnownHostProperty(string name) or "PLATFORM_RESOURCE_ROOTS" or "APP_PATHS"; - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AppContext_TryGetHostPropertyValue", StringMarshalling = StringMarshalling.Utf16)] [return: MarshalAs(UnmanagedType.Bool)] private static partial bool TryGetHostPropertyValue(string name, StringHandleOnStack retValue); diff --git a/src/coreclr/System.Private.CoreLib/src/System/ArgIterator.cs b/src/coreclr/System.Private.CoreLib/src/System/ArgIterator.cs index 463326f6b5679c..f896f0b44e3e42 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/ArgIterator.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/ArgIterator.cs @@ -39,7 +39,7 @@ public ArgIterator(RuntimeArgumentHandle arglist) Init(ThisPtr, cookie); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_Init")] private static partial void Init(ArgIterator* thisPtr, IntPtr cookie); @@ -56,7 +56,7 @@ public ArgIterator(RuntimeArgumentHandle arglist, void* ptr) Init(ThisPtr, cookie, ptr); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_Init2")] private static partial void Init(ArgIterator* thisPtr, IntPtr cookie, void* ptr); @@ -83,7 +83,7 @@ public TypedReference GetNextArg() return result; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_GetNextArg")] private static partial void GetNextArg(ArgIterator* thisPtr, TypedReference* pResult); @@ -119,7 +119,7 @@ public TypedReference GetNextArg(RuntimeTypeHandle rth) return result; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_GetNextArg2")] private static partial void GetNextArg(ArgIterator* thisPtr, QCallTypeHandle rth, TypedReference* pResult); @@ -145,7 +145,7 @@ public RuntimeTypeHandle GetNextArgType() return RuntimeTypeHandle.FromIntPtr(GetNextArgType(ThisPtr)); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_GetNextArgType")] private static partial IntPtr GetNextArgType(ArgIterator* thisPtr); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Array.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Array.CoreCLR.cs index 4d19dc30fed964..509af347e014a1 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Array.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Array.CoreCLR.cs @@ -15,7 +15,7 @@ namespace System // IList and IReadOnlyList, where T : U dynamically. See the SZArrayHelper class for details. public abstract partial class Array : ICloneable, IList, IStructuralComparable, IStructuralEquatable { - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Array_CreateInstance")] private static unsafe partial void InternalCreate(QCallTypeHandle type, int rank, int* pLengths, int* pLowerBounds, [MarshalAs(UnmanagedType.Bool)] bool fromArrayType, ObjectHandleOnStack retArray); @@ -36,7 +36,7 @@ private static unsafe Array InternalCreateFromArrayType(RuntimeType arrayType, i return retArray!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Array_Ctor")] private static unsafe partial void Ctor(MethodTable* pArrayMT, uint dwNumArgs, int* pArgList, ObjectHandleOnStack retArray); @@ -351,7 +351,7 @@ internal sealed unsafe partial class ArrayInitializeCache : RuntimeType.IGeneric { internal readonly delegate* ConstructorEntrypoint; - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Array_GetElementConstructorEntrypoint")] private static partial delegate* GetElementConstructorEntrypoint(QCallTypeHandle arrayType); diff --git a/src/coreclr/System.Private.CoreLib/src/System/CLRConfig.cs b/src/coreclr/System.Private.CoreLib/src/System/CLRConfig.cs index 0afc5076184407..25883ec8bebaff 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/CLRConfig.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/CLRConfig.cs @@ -15,7 +15,7 @@ internal static bool GetBoolValue(string switchName, out bool exist) return GetConfigBoolValue(switchName, out exist); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ClrConfig_GetConfigBoolValue", StringMarshalling = StringMarshalling.Utf16)] [return: MarshalAs(UnmanagedType.Bool)] private static partial bool GetConfigBoolValue(string configSwitchName, [MarshalAs(UnmanagedType.Bool)] out bool exist); diff --git a/src/coreclr/System.Private.CoreLib/src/System/ComAwareWeakReference.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/ComAwareWeakReference.CoreCLR.cs index 87d3b5a4bd80ff..c2a30fdbee0fba 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/ComAwareWeakReference.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/ComAwareWeakReference.CoreCLR.cs @@ -9,7 +9,7 @@ namespace System { internal sealed partial class ComAwareWeakReference { - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ComWeakRefToObject")] private static partial void ComWeakRefToObject(IntPtr pComWeakRef, ObjectHandleOnStack retRcw); @@ -39,7 +39,7 @@ internal static bool PossiblyComObject(object target) #endif // FEATURE_COMINTEROP } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjectToComWeakRef")] private static partial IntPtr ObjectToComWeakRef(ObjectHandleOnStack retRcw); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Delegate.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Delegate.CoreCLR.cs index 16f91d84a5d0a8..7b3f589273e10f 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Delegate.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Delegate.CoreCLR.cs @@ -532,7 +532,7 @@ private struct BindToMethodDetails public GCHandle loaderAllocatorGCHandle; // The loader allocator needed if the delegate needs to keep it alive } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_BindToMethodName", StringMarshalling = StringMarshalling.Utf8)] [return: MarshalAs(UnmanagedType.Bool)] private static partial bool BindToMethodName(MethodTable* pDelegateMT, MethodTable *pTargetMT, QCallTypeHandle methodType, string method, DelegateBindingFlags flags, ObjectHandleOnStack targetParameter, out BindToMethodDetails bindToMethodDetails); @@ -568,7 +568,7 @@ private bool BindToMethodInfo(object? target, IRuntimeMethodInfo method, Runtime return ret; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_BindToMethodInfo")] [return: MarshalAs(UnmanagedType.Bool)] private static partial bool BindToMethodInfo(MethodTable* pDelegateMT, MethodTable *pTargetMT, RuntimeMethodHandleInternal method, QCallTypeHandle methodType, DelegateBindingFlags flags, ObjectHandleOnStack targetParameter, out BindToMethodDetails bindToMethodDetails); @@ -642,14 +642,14 @@ private void DelegateConstruct(object target, IntPtr method) _target = target; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_Construct")] private static partial void Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, IntPtr method, out BindToMethodDetails bindToMethodDetails); [MethodImpl(MethodImplOptions.InternalCall)] private static extern unsafe void* GetMulticastInvoke(MethodTable* pMT); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_GetMulticastInvokeSlow")] private static unsafe partial void* GetMulticastInvokeSlow(MethodTable* pMT); @@ -685,7 +685,7 @@ private static unsafe IRuntimeMethodInfo CreateMethodInfo(MethodDesc* methodDesc return methodInfo!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_CreateMethodInfo")] private static unsafe partial void CreateMethodInfo(MethodDesc* methodDesc, ObjectHandleOnStack retMethodInfo); @@ -696,7 +696,7 @@ private static unsafe IRuntimeMethodInfo CreateMethodInfo(MethodDesc* methodDesc return GetMethodDesc(ObjectHandleOnStack.Create(ref instance)); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_GetMethodDesc")] private static unsafe partial MethodDesc* GetMethodDesc(ObjectHandleOnStack instance); @@ -893,7 +893,7 @@ internal static IntPtr AdjustTarget(object target, IntPtr methodPtr) } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_AdjustTarget")] private static partial IntPtr AdjustTarget(MethodTable* targetMT, IntPtr methodPtr); @@ -903,7 +903,7 @@ internal void InitializeVirtualCallStub(IntPtr methodPtr) InitializeVirtualCallStub(ObjectHandleOnStack.Create(ref d), methodPtr); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_InitializeVirtualCallStub")] private static partial void InitializeVirtualCallStub(ObjectHandleOnStack d, IntPtr methodPtr); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs index 0e5f3bd160fe4d..c05fa93c540e9c 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs @@ -11,7 +11,7 @@ namespace System.Diagnostics { public static partial class Debugger { - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DebugDebugger_Break")] private static partial void BreakInternal(); @@ -84,7 +84,7 @@ static void NotifyOfCrossThreadDependencySlow() // Posts a custom notification for the attached debugger. If there is no // debugger attached, has no effect. The debugger may or may not // report the notification depending on its settings. - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DebugDebugger_CustomNotification")] private static partial void CustomNotification(ObjectHandleOnStack data); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrame.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrame.CoreCLR.cs index d94c2e2b6cb2a0..1995aa7f8321e6 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrame.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrame.CoreCLR.cs @@ -56,7 +56,7 @@ private void BuildStackFrame(int skipFrames, bool needFileInfo) private static bool AppendStackFrameWithoutMethodBase(StringBuilder sb) => false; #pragma warning restore IDE0060 - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StackFrame_GetMethodDescFromNativeIP")] private static partial RuntimeMethodHandleInternal GetMethodDescFromNativeIP(IntPtr ip); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackTrace.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackTrace.CoreCLR.cs index f014696495dcb4..32d1cc583662b2 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackTrace.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackTrace.CoreCLR.cs @@ -9,7 +9,7 @@ namespace System.Diagnostics { public partial class StackTrace { - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StackTrace_GetStackFramesInternal")] private static partial void GetStackFramesInternal(ObjectHandleOnStack sfh, [MarshalAs(UnmanagedType.Bool)] bool fNeedFileInfo, ObjectHandleOnStack e); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs index c852c9186827ae..bae8139426b253 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Enum.CoreCLR.cs @@ -11,7 +11,7 @@ namespace System { public abstract partial class Enum { - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Enum_GetValuesAndNames")] private static partial void GetEnumValuesAndNames(QCallTypeHandle enumType, ObjectHandleOnStack values, ObjectHandleOnStack names, Interop.BOOL getNames); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Environment.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Environment.CoreCLR.cs index 4f4bbfc6d18790..b399e195478eb0 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Environment.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Environment.CoreCLR.cs @@ -20,7 +20,7 @@ public static int CurrentManagedThreadId // Terminates this process with the given exit code. /// QCall that passes the integer exit code to the runtime to terminate the process; it accesses no caller-supplied memory. - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Environment_Exit")] [DoesNotReturn] private static safe partial void _Exit(int exitCode); @@ -86,7 +86,7 @@ private static void FailFast(ref StackCrawlMark mark, string? message, Exception FailFast(new StackCrawlMarkHandle(ref mark), message, ObjectHandleOnStack.Create(ref exception), errorMessage); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Environment_FailFast", StringMarshalling = StringMarshalling.Utf16)] [DoesNotReturn] private static partial void FailFast(StackCrawlMarkHandle mark, string? message, ObjectHandleOnStack exception, string? errorMessage); @@ -121,7 +121,7 @@ private static unsafe void InitializeCommandLineArgs(char* exePath, int argc, ch } /// QCall that returns the available processor count as an int; it accesses no caller-supplied memory. - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Environment_GetProcessorCount")] internal static safe partial int GetProcessorCount(); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Exception.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Exception.CoreCLR.cs index 35fa99aa941c3c..e47402b4cc08cb 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Exception.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Exception.CoreCLR.cs @@ -55,7 +55,7 @@ private IDictionary CreateDataContainer() [MethodImpl(MethodImplOptions.InternalCall)] private static extern bool IsImmutableAgileException(Exception e); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_GetMethodFromStackTrace")] private static partial void GetMethodFromStackTrace(ObjectHandleOnStack stackTrace, ObjectHandleOnStack method); @@ -214,7 +214,7 @@ internal static string GetMessageFromNativeResources(ExceptionMessageKind kind) return retMesg!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_GetMessageFromNativeResources")] private static partial void GetMessageFromNativeResources(ExceptionMessageKind kind, StringHandleOnStack retMesg); @@ -238,7 +238,7 @@ public DispatchState( } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_GetFrozenStackTrace")] private static partial void GetFrozenStackTrace(ObjectHandleOnStack exception, ObjectHandleOnStack stackTrace); diff --git a/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs index c46537e24e1542..fa43541492e372 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs @@ -91,12 +91,12 @@ public static GCMemoryInfo GetGCMemoryInfo(GCKind kind) /// the caller must pass a positive and a that does not /// exceed it. is the audited entry point that /// validates both. - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_StartNoGCRegion")] internal static unsafe partial int _StartNoGCRegion(long totalSize, [MarshalAs(UnmanagedType.Bool)] bool lohSizeKnown, long lohSize, [MarshalAs(UnmanagedType.Bool)] bool disallowFullBlockingGC); /// QCall that ends the no-GC region and returns a status code; it takes no arguments and accesses no caller-supplied memory. - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_EndNoGCRegion")] internal static safe partial int _EndNoGCRegion(); @@ -108,19 +108,19 @@ internal enum GC_ALLOC_FLAGS GC_ALLOC_PINNED_OBJECT_HEAP = 64, }; - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_AllocateNewArray")] private static partial void AllocateNewArray(IntPtr typeHandlePtr, int length, GC_ALLOC_FLAGS flags, ObjectHandleOnStack ret); /// QCall that returns the total managed heap byte count as a scalar; it takes no arguments and accesses no caller-supplied memory. - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_GetTotalMemory")] private static safe partial long GetTotalMemory(); /// The runtime only asserts that is at least -1 before handing it to the /// GC, so the caller must not pass a smaller value. /// is the audited entry point that validates it. - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_Collect")] private static unsafe partial void _Collect(int generation, int mode, [MarshalAs(UnmanagedType.U1)] bool lowMemoryPressure); @@ -148,12 +148,12 @@ internal enum GC_ALLOC_FLAGS internal static extern unsafe ulong GetGenerationSize(int gen); /// QCall that records added memory pressure from a scalar byte count; it accesses no caller-supplied memory. - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_AddMemoryPressure")] private static safe partial void _AddMemoryPressure(ulong bytesAllocated); /// QCall that records removed memory pressure from a scalar byte count; it accesses no caller-supplied memory. - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_RemoveMemoryPressure")] private static safe partial void _RemoveMemoryPressure(ulong bytesAllocated); @@ -334,7 +334,7 @@ public static int GetGeneration(WeakReference wo) // public static int MaxGeneration => GetMaxGeneration(); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_GetNextFinalizableObject")] private static unsafe partial void* GetNextFinalizeableObject(ObjectHandleOnStack target); @@ -368,7 +368,7 @@ private static unsafe uint RunFinalizers() } /// QCall that blocks until pending finalizers drain; it takes no arguments and accesses no caller-supplied memory. - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_WaitForPendingFinalizers")] private static safe partial void _WaitForPendingFinalizers(); @@ -398,7 +398,7 @@ public static unsafe void SuppressFinalize(object obj) // for which SuppressFinalize has already been called. The other situation // where calling ReRegisterForFinalize is useful is inside a finalizer that // needs to resurrect itself or an object that it references. - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_ReRegisterForFinalize")] private static partial void ReRegisterForFinalize(ObjectHandleOnStack o); @@ -443,11 +443,11 @@ public static long GetTotalMemory(bool forceFullCollection) return newSize; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_RegisterFrozenSegment")] private static partial IntPtr _RegisterFrozenSegment(IntPtr sectionAddress, nint sectionSize); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_UnregisterFrozenSegment")] private static partial void _UnregisterFrozenSegment(IntPtr segmentHandle); @@ -467,7 +467,7 @@ public static long GetTotalMemory(bool forceFullCollection) private static extern safe long GetTotalAllocatedBytesApproximate(); /// QCall that returns a precise process-wide allocated byte count as a scalar; it takes no arguments and accesses no caller-supplied memory. - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_GetTotalAllocatedBytesPrecise")] private static safe partial long GetTotalAllocatedBytesPrecise(); @@ -480,12 +480,12 @@ public static long GetTotalMemory(bool forceFullCollection) private static extern safe bool _CancelFullGCNotification(); /// QCall that waits for an approaching full GC using a scalar timeout and returns a status code; it accesses no caller-supplied memory. - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_WaitForFullGCApproach")] private static safe partial int _WaitForFullGCApproach(int millisecondsTimeout); /// QCall that waits for full-GC completion using a scalar timeout and returns a status code; it accesses no caller-supplied memory. - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_WaitForFullGCComplete")] private static safe partial int _WaitForFullGCComplete(int millisecondsTimeout); @@ -804,7 +804,7 @@ static void Free(NoGCRegionCallbackFinalizerWorkItem* pWorkItem) } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_EnableNoGCRegionCallback")] private static unsafe partial EnableNoGCRegionCallbackStatus _EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, long totalSize); @@ -815,7 +815,7 @@ internal static long GetGenerationBudget(int generation) /// The GC indexes its per-generation dynamic data with without /// bounds-checking it, so the caller must pass an existing generation number. - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_GetGenerationBudget")] internal static unsafe partial long _GetGenerationBudget(int generation); @@ -982,7 +982,7 @@ internal enum GCConfigurationType Boolean } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_EnumerateConfigurationValues")] internal static unsafe partial void _EnumerateConfigurationValues(void* configurationDictionary, delegate* unmanaged callback); @@ -1050,7 +1050,7 @@ public static void RefreshMemoryLimit() Debug.Assert(status == RefreshMemoryStatus.Succeeded); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_RefreshMemoryLimit")] internal static partial int _RefreshMemoryLimit(GCHeapHardLimitInfo heapHardLimitInfo); diff --git a/src/coreclr/System.Private.CoreLib/src/System/IO/FileLoadException.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/IO/FileLoadException.CoreCLR.cs index f000167e64b4e4..3ee05fc25b97da 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/IO/FileLoadException.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/IO/FileLoadException.CoreCLR.cs @@ -32,11 +32,11 @@ internal static string FormatFileLoadExceptionMessage(string? fileName, int hRes return string.Format(format!, fileName, message); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall)] private static partial void GetFileLoadExceptionMessage(int hResult, StringHandleOnStack retString); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "FileLoadException_GetMessageForHR")] private static partial void GetMessageForHR(int hresult, StringHandleOnStack retString); diff --git a/src/coreclr/System.Private.CoreLib/src/System/IO/Stream.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/IO/Stream.CoreCLR.cs index d61c486966a6f2..ac7bc1b8383ebf 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/IO/Stream.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/IO/Stream.CoreCLR.cs @@ -9,7 +9,7 @@ namespace System.IO { public abstract unsafe partial class Stream { - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Stream_HasOverriddenSlow")] [return: MarshalAs(UnmanagedType.Bool)] private static partial bool HasOverriddenSlow(MethodTable* pMT, [MarshalAs(UnmanagedType.Bool)] bool isRead); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Assembly.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Assembly.CoreCLR.cs index d1559e1ff58e35..a0b0f5b174d69c 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Assembly.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Assembly.CoreCLR.cs @@ -54,7 +54,7 @@ public static Assembly Load(AssemblyName assemblyRef) return RuntimeAssembly.InternalLoad(assemblyRef, ref stackMark, AssemblyLoadContext.CurrentContextualReflectionContext); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetExecutingAssembly")] private static partial void GetExecutingAssemblyNative(StackCrawlMarkHandle stackMark, ObjectHandleOnStack retAssembly); @@ -86,7 +86,7 @@ public static Assembly GetCallingAssembly() return GetExecutingAssembly(ref stackMark); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetEntryAssembly")] private static partial void GetEntryAssemblyNative(ObjectHandleOnStack retAssembly); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs index da5072d621e99a..3b0d6f3786d1fe 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs @@ -192,7 +192,7 @@ private static unsafe void CreateAssemblyName(AssemblyName* pResult, NativeAssem } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyName_InitializeAssemblySpec")] private static unsafe partial void InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, void* pAssemblySpec); } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeAssemblyBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeAssemblyBuilder.cs index fc6e638c5a9fe2..35e845c8a8f1de 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeAssemblyBuilder.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeAssemblyBuilder.cs @@ -112,7 +112,7 @@ internal RuntimeAssemblyBuilder(AssemblyName name, #region DefineDynamicAssembly - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AppDomain_CreateDynamicAssembly")] private static unsafe partial void CreateDynamicAssembly(ObjectHandleOnStack assemblyLoadContext, NativeAssemblyNameParts* pAssemblyName, diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeModuleBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeModuleBuilder.cs index a6b7251bdeddd7..bc15a724eb3251 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeModuleBuilder.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeModuleBuilder.cs @@ -98,11 +98,11 @@ internal void CheckTypeNameConflict(string strTypeName, Type? enclosingType) return SymbolType.FormCompoundType(strFormat, baseType, 0); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetTypeRef", StringMarshalling = StringMarshalling.Utf16)] private static partial int GetTypeRef(QCallModule module, string strFullName, QCallModule refedModule, int tkResolution); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetMemberRef")] private static partial int GetMemberRef(QCallModule module, QCallModule refedModule, int tr, int defToken); @@ -114,7 +114,7 @@ private int GetMemberRef(Module? refedModule, int tr, int defToken) return GetMemberRef(new QCallModule(ref thisModule), new QCallModule(ref refedRuntimeModule), tr, defToken); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetMemberRefFromSignature", StringMarshalling = StringMarshalling.Utf16)] private static partial int GetMemberRefFromSignature(QCallModule module, int tr, string methodName, byte[] signature, int length); @@ -124,7 +124,7 @@ private int GetMemberRefFromSignature(int tr, string methodName, byte[] signatur return GetMemberRefFromSignature(new QCallModule(ref thisModule), tr, methodName, signature, length); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetMemberRefOfMethodInfo")] private static partial int GetMemberRefOfMethodInfo(QCallModule module, int tr, RuntimeMethodHandleInternal method); @@ -148,7 +148,7 @@ private int GetMemberRefOfMethodInfo(int tr, RuntimeConstructorInfo method) return result; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetMemberRefOfFieldInfo")] private static partial int GetMemberRefOfFieldInfo(QCallModule module, int tkType, QCallTypeHandle declaringType, int tkField); @@ -160,7 +160,7 @@ private int GetMemberRefOfFieldInfo(int tkType, RuntimeTypeHandle declaringType, return GetMemberRefOfFieldInfo(new QCallModule(ref thisModule), tkType, new QCallTypeHandle(ref declaringType), runtimeField.MetadataToken); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetTokenFromTypeSpec")] private static partial int GetTokenFromTypeSpec(QCallModule pModule, byte[] signature, int length); @@ -170,15 +170,15 @@ private int GetTokenFromTypeSpec(byte[] signature, int length) return GetTokenFromTypeSpec(new QCallModule(ref thisModule), signature, length); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetArrayMethodToken", StringMarshalling = StringMarshalling.Utf16)] private static partial int GetArrayMethodToken(QCallModule module, int tkTypeSpec, string methodName, byte[] signature, int sigLength); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_GetStringConstant", StringMarshalling = StringMarshalling.Utf16)] private static partial int GetStringConstant(QCallModule module, string str, int length); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleBuilder_SetFieldRVAContent")] internal static partial void SetFieldRVAContent(QCallModule module, int fdToken, byte[]? data, int length); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeTypeBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeTypeBuilder.cs index 5806b18a1792e4..dc4c74c1f776ac 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeTypeBuilder.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeTypeBuilder.cs @@ -57,31 +57,31 @@ public void Bake(RuntimeModuleBuilder module, int token) #endregion #region Private Static FCalls - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetParentType")] private static partial void SetParentType(QCallModule module, int tdTypeDef, int tkParent); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_AddInterfaceImpl")] private static partial void AddInterfaceImpl(QCallModule module, int tdTypeDef, int tkInterface); #endregion #region Internal Static FCalls - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineMethod", StringMarshalling = StringMarshalling.Utf16)] internal static partial int DefineMethod(QCallModule module, int tkParent, string name, byte[] signature, int sigLength, MethodAttributes attributes); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineMethodSpec")] internal static partial int DefineMethodSpec(QCallModule module, int tkParent, byte[] signature, int sigLength); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineField", StringMarshalling = StringMarshalling.Utf16)] internal static partial int DefineField(QCallModule module, int tkParent, string name, byte[] signature, int sigLength, FieldAttributes attributes); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetMethodIL")] private static partial void SetMethodIL(QCallModule module, int tk, [MarshalAs(UnmanagedType.Bool)] bool isInitLocals, byte[]? body, int bodyLength, @@ -90,7 +90,7 @@ private static partial void SetMethodIL(QCallModule module, int tk, [MarshalAs(U ExceptionHandler[]? exceptions, int numExceptions, int[]? tokenFixups, int numTokenFixups); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineCustomAttribute")] private static partial void DefineCustomAttribute(QCallModule module, int tkAssociate, int tkConstructor, ReadOnlySpan attr, int attrLength); @@ -102,50 +102,50 @@ internal static void DefineCustomAttribute(RuntimeModuleBuilder module, int tkAs attr, attr.Length); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineProperty", StringMarshalling = StringMarshalling.Utf16)] internal static partial int DefineProperty(QCallModule module, int tkParent, string name, PropertyAttributes attributes, byte[] signature, int sigLength); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineEvent", StringMarshalling = StringMarshalling.Utf16)] internal static partial int DefineEvent(QCallModule module, int tkParent, string name, EventAttributes attributes, int tkEventType); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineMethodSemantics")] internal static partial void DefineMethodSemantics(QCallModule module, int tkAssociation, MethodSemanticsAttributes semantics, int tkMethod); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineMethodImpl")] internal static partial void DefineMethodImpl(QCallModule module, int tkType, int tkBody, int tkDecl); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetMethodImpl")] internal static partial void SetMethodImpl(QCallModule module, int tkMethod, MethodImplAttributes MethodImplAttributes); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetParamInfo", StringMarshalling = StringMarshalling.Utf16)] internal static partial int SetParamInfo(QCallModule module, int tkMethod, int iSequence, ParameterAttributes iParamAttributes, string? strParamName); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_GetTokenFromSig")] internal static partial int GetTokenFromSig(QCallModule module, byte[] signature, int sigLength); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetFieldLayoutOffset")] internal static partial void SetFieldLayoutOffset(QCallModule module, int fdToken, int iOffset); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetClassLayout")] internal static partial void SetClassLayout(QCallModule module, int tk, PackingSize iPackingSize, int iTypeSize); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetConstantValue")] private static unsafe partial void SetConstantValue(QCallModule module, int tk, int corType, void* pValue); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_SetPInvokeData", StringMarshalling = StringMarshalling.Utf16)] private static partial void SetPInvokeData(QCallModule module, string DllName, string name, int token, int linkFlags); @@ -551,17 +551,17 @@ protected override bool IsCreatedCore() #endregion #region FCalls - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineType", StringMarshalling = StringMarshalling.Utf16)] private static partial int DefineType(QCallModule module, string fullname, int tkParent, TypeAttributes attributes, int tkEnclosingType, int[] interfaceTokens); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_DefineGenericParam", StringMarshalling = StringMarshalling.Utf16)] private static partial int DefineGenericParam(QCallModule module, string name, int tkParent, GenericParameterAttributes attributes, int position, int[] constraints); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeBuilder_TermCreateClass")] private static partial void TermCreateClass(QCallModule module, int tk, ObjectHandleOnStack type); #endregion diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/LoaderAllocator.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/LoaderAllocator.cs index 24c8857db08a53..5bcad648b210b2 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/LoaderAllocator.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/LoaderAllocator.cs @@ -26,7 +26,7 @@ internal sealed partial class LoaderAllocatorScout // This field is set by the VM to atomically transfer the ownership to the managed loader allocator internal IntPtr m_nativeLoaderAllocator; - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "LoaderAllocator_Destroy")] [return: MarshalAs(UnmanagedType.Bool)] private static partial bool Destroy(IntPtr nativeLoaderAllocator); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs index a2376da50571f0..63b6ba35c62637 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MdImport.cs @@ -333,7 +333,7 @@ internal MetadataImport(RuntimeModule module) } #endregion - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MetadataImport_Enum")] private static unsafe partial void Enum(IntPtr scope, int type, int parent, ref int length, int* shortResult, ObjectHandleOnStack longResult); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/AssemblyExtensions.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/AssemblyExtensions.cs index f38f9fe5041647..19071f18a75ca6 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/AssemblyExtensions.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/AssemblyExtensions.cs @@ -9,7 +9,7 @@ namespace System.Reflection.Metadata { public static partial class AssemblyExtensions { - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_InternalTryGetRawMetadata")] [return: MarshalAs(UnmanagedType.Bool)] private static unsafe partial bool InternalTryGetRawMetadata(QCallAssembly assembly, ref byte* blob, ref int length); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs index 967802a8b3d920..400188d223d238 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs @@ -10,11 +10,11 @@ namespace System.Reflection.Metadata { public static partial class MetadataUpdater { - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_ApplyUpdate")] private static unsafe partial void ApplyUpdate(QCallAssembly assembly, byte* metadataDelta, int metadataDeltaLength, byte* ilDelta, int ilDeltaLength, byte* pdbDelta, int pdbDeltaLength); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_IsApplyUpdateSupported")] [return: MarshalAs(UnmanagedType.Bool)] private static unsafe partial bool IsApplyUpdateSupported(); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MethodBase.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MethodBase.CoreCLR.cs index c4db36642bfcf5..e2265815e3c1f2 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/MethodBase.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/MethodBase.CoreCLR.cs @@ -36,7 +36,7 @@ public abstract partial class MethodBase : MemberInfo return RuntimeType.GetMethodBase(declaringType.GetRuntimeType(), handle.GetMethodInfo()); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MethodBase_GetCurrentMethod")] private static partial RuntimeMethodHandleInternal GetCurrentMethod(StackCrawlMarkHandle stackMark); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs index 521d5f8759658c..d9f951f9432677 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs @@ -67,7 +67,7 @@ public override event ModuleResolveEventHandler? ModuleResolve } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetCodeBase")] [return: MarshalAs(UnmanagedType.Bool)] private static partial bool GetCodeBase(QCallAssembly assembly, @@ -139,7 +139,7 @@ public override AssemblyName GetName(bool copiedName) return an; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetFullName")] private static partial void GetFullName(QCallAssembly assembly, StringHandleOnStack retString); @@ -160,7 +160,7 @@ public override string? FullName } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetEntryPoint")] private static partial void GetEntryPoint(QCallAssembly assembly, ObjectHandleOnStack retMethod); @@ -180,7 +180,7 @@ public override MethodInfo? EntryPoint } // For case-sensitive lookups, marshal the strings directly to Utf8 to avoid unnecessary string copies. - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetTypeCore", StringMarshalling = StringMarshalling.Utf8)] private static partial void GetTypeCore(QCallAssembly assembly, string typeName, @@ -188,7 +188,7 @@ private static partial void GetTypeCore(QCallAssembly assembly, int nestedTypeNamesLength, ObjectHandleOnStack retType); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetTypeCoreIgnoreCase", StringMarshalling = StringMarshalling.Utf16)] private static partial void GetTypeCoreIgnoreCase(QCallAssembly assembly, string typeName, @@ -239,7 +239,7 @@ private static partial void GetTypeCoreIgnoreCase(QCallAssembly assembly, throwOnError: throwOnError, ignoreCase: ignoreCase); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetExportedTypes")] private static partial void GetExportedTypes(QCallAssembly assembly, ObjectHandleOnStack retTypes); @@ -272,7 +272,7 @@ public override bool IsCollectible } // GetResource will return a pointer to the resources in memory. - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetResource", StringMarshalling = StringMarshalling.Utf16)] private static unsafe partial byte* GetResource(QCallAssembly assembly, string resourceName, @@ -401,7 +401,7 @@ internal static unsafe RuntimeAssembly InternalLoad(AssemblyName assemblyName, return retAssembly!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_InternalLoad")] private static unsafe partial void InternalLoad(NativeAssemblyNameParts* pAssemblyNameParts, ObjectHandleOnStack requestingAssembly, @@ -414,7 +414,7 @@ private static unsafe partial void InternalLoad(NativeAssemblyNameParts* pAssemb // Returns the module in this assembly with name 'name' - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetModule", StringMarshalling = StringMarshalling.Utf16)] private static partial void GetModule(QCallAssembly assembly, string name, ObjectHandleOnStack retModule); @@ -469,7 +469,7 @@ public override FileStream[] GetFiles(bool getResourceModules) } // Returns the names of all the resources - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetManifestResourceNames")] private static partial void GetManifestResourceNames(QCallAssembly assembly, ObjectHandleOnStack retResourceNames); @@ -483,7 +483,7 @@ public override string[] GetManifestResourceNames() } // Returns the names of all the resources - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetReferencedAssemblies")] private static partial void GetReferencedAssemblies(QCallAssembly assembly, ObjectHandleOnStack retReferencedAssemblies); @@ -496,7 +496,7 @@ public override AssemblyName[] GetReferencedAssemblies() return referencedAssemblies!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetManifestResourceInfo", StringMarshalling = StringMarshalling.Utf16)] private static partial int GetManifestResourceInfo(QCallAssembly assembly, string resourceName, @@ -519,7 +519,7 @@ private static partial int GetManifestResourceInfo(QCallAssembly assembly, (ResourceLocation)location); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetLocation")] private static partial void GetLocation(QCallAssembly assembly, StringHandleOnStack retString); @@ -536,7 +536,7 @@ public override string Location } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetImageRuntimeVersion")] private static partial void GetImageRuntimeVersion(QCallAssembly assembly, StringHandleOnStack retString); @@ -556,7 +556,7 @@ public override string ImageRuntimeVersion public override long HostContext => 0; - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetVersion")] private static partial void GetVersion(QCallAssembly assembly, out int majVer, @@ -571,7 +571,7 @@ private Version GetVersion() return new Version(majorVer, minorVer, build, revision); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetLocale")] private static partial void GetLocale(QCallAssembly assembly, StringHandleOnStack retString); @@ -601,7 +601,7 @@ public override bool IsDynamic } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetSimpleName")] private static partial void GetSimpleName(QCallAssembly assembly, StringHandleOnStack retSimpleName); @@ -613,7 +613,7 @@ internal string GetSimpleName() return name!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetHashAlgorithm")] private static partial AssemblyHashAlgorithm GetHashAlgorithm(QCallAssembly assembly); @@ -623,7 +623,7 @@ private AssemblyHashAlgorithm GetHashAlgorithm() return GetHashAlgorithm(new QCallAssembly(ref runtimeAssembly)); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetFlags")] private static partial AssemblyNameFlags GetFlags(QCallAssembly assembly); @@ -633,7 +633,7 @@ private AssemblyNameFlags GetFlags() return GetFlags(new QCallAssembly(ref runtimeAssembly)); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetPublicKey")] private static partial void GetPublicKey(QCallAssembly assembly, ObjectHandleOnStack retPublicKey); @@ -690,7 +690,7 @@ public override Assembly GetSatelliteAssembly(CultureInfo culture, Version? vers return retAssembly; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetModules")] private static partial void GetModules(QCallAssembly assembly, [MarshalAs(UnmanagedType.Bool)] bool loadIfNotFound, @@ -733,7 +733,7 @@ static RuntimeModule GetManifestModuleWorker(RuntimeAssembly assembly) [MethodImpl(MethodImplOptions.InternalCall)] private static extern RuntimeModule? GetManifestModule(RuntimeAssembly assembly); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyHandle_GetManifestModuleSlow")] private static partial void GetManifestModuleSlow(ObjectHandleOnStack assembly, ObjectHandleOnStack module); @@ -822,7 +822,7 @@ private static void AddPublicNestedTypes(Type type, List types, List GetFullyQualifiedName(); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeModule_GetTypes")] private static partial void GetTypes(QCallModule module, ObjectHandleOnStack retTypes, ObjectHandleOnStack retExceptions); @@ -483,7 +483,7 @@ public override MethodInfo[] GetMethods(BindingFlags bindingFlags) return RuntimeType.GetMethods(bindingFlags); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeModule_GetScopeName")] private static partial void GetScopeName(QCallModule module, StringHandleOnStack retString); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs index 0074c6a8f5deb1..7cf4d31e1fee6b 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs @@ -197,7 +197,7 @@ private static unsafe void GetTypeHelper(char* pTypeName, RuntimeAssembly* pRequ return assembly; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "UnsafeAccessors_ResolveGenericParamToTypeHandle")] private static partial IntPtr ResolveGenericParamToTypeHandle(IntPtr unsafeAccessorMethod, [MarshalAs(UnmanagedType.Bool)] bool isMethodParam, uint paramIndex); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs index 8a84de892363f9..992e964f2cc53d 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncHelpers.CoreCLR.cs @@ -320,7 +320,7 @@ internal static void ReturnTaskContinuation(RuntimeAsyncTaskContinuation continu } #if !NATIVEAOT - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AsyncHelpers_AddContinuationToExInternal")] private static unsafe partial void AddContinuationToExInternal(void* diagnosticIP, ObjectHandleOnStack ex); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastHelpers.cs index e75c682b500c9f..87334a0e180f58 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastHelpers.cs @@ -14,7 +14,7 @@ internal static unsafe partial class CastHelpers // In coreclr the table is allocated and written to on the native side. internal static int[]? s_table; - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThrowInvalidCastException")] private static partial void ThrowInvalidCastExceptionInternal(void* fromTypeHnd, void* toTypeHnd); @@ -33,7 +33,7 @@ internal static void ThrowInvalidCastException(object fromType, void* toTypeHnd) throw null!; // Provide hint to the inliner that this method does not return } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall)] [return: MarshalAs(UnmanagedType.Bool)] private static partial bool IsInstanceOf_NoCacheLookup(void *toTypeHnd, [MarshalAs(UnmanagedType.Bool)] bool throwCastException, ObjectHandleOnStack obj); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/GenericsHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/GenericsHelpers.cs index f4a4b9e5965bcf..3c7afaa50de995 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/GenericsHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/GenericsHelpers.cs @@ -12,7 +12,7 @@ namespace System.Runtime.CompilerServices; [DebuggerStepThrough] internal static unsafe partial class GenericsHelpers { - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall)] private static partial IntPtr GenericHandleWorker(IntPtr pMD, IntPtr pMT, IntPtr signature, uint dictionaryIndexAndSlot, IntPtr pModule); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/InitHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/InitHelpers.cs index cdea275bb4855d..ce7c9a800f124e 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/InitHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/InitHelpers.cs @@ -11,7 +11,7 @@ namespace System.Runtime.CompilerServices [DebuggerStepThrough] internal static unsafe partial class InitHelpers { - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall)] private static partial void InitClassHelper(MethodTable* mt); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs index 0f2bffcf77076a..849aad3e82dfc3 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs @@ -163,7 +163,7 @@ private static unsafe ref byte GetSpanDataFrom( // This call will generate an exception if the specified class constructor threw an // exception when it ran. - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(QCall, EntryPoint = "ReflectionInvocation_RunClassConstructor")] private static partial void RunClassConstructor(QCallTypeHandle type); @@ -184,7 +184,7 @@ public static void RunClassConstructor(RuntimeTypeHandle type) // This call will generate an exception if the specified module constructor threw an // exception when it ran. - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(QCall, EntryPoint = "ReflectionInvocation_RunModuleConstructor")] private static partial void RunModuleConstructor(QCallModule module); @@ -196,11 +196,11 @@ public static void RunModuleConstructor(ModuleHandle module) RunModuleConstructor(new QCallModule(ref rm)); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(QCall, EntryPoint = "ReflectionInvocation_CompileMethod")] internal static partial void CompileMethod(RuntimeMethodHandleInternal method); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(QCall, EntryPoint = "ReflectionInvocation_PrepareMethod")] private static unsafe partial void PrepareMethod(RuntimeMethodHandleInternal method, IntPtr* pInstantiation, int cInstantiation); @@ -223,7 +223,7 @@ public static unsafe void PrepareMethod(RuntimeMethodHandle method, RuntimeTypeH } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(QCall, EntryPoint = "ReflectionInvocation_PrepareDelegate")] private static partial void PrepareDelegate(ObjectHandleOnStack d); @@ -245,7 +245,7 @@ public static void PrepareDelegate(Delegate d) [MethodImpl(MethodImplOptions.InternalCall)] internal static extern safe int TryGetHashCode(object? o); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(QCall, EntryPoint = "ObjectNative_GetHashCodeSlow")] private static partial int GetHashCodeSlow(ObjectHandleOnStack o); @@ -355,7 +355,7 @@ public static object GetUninitializedObject( return rt.GetUninitializedObject(); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(QCall, EntryPoint = "ObjectNative_AllocateUninitializedClone")] internal static partial void AllocateUninitializedClone(ObjectHandleOnStack objHandle); @@ -489,7 +489,7 @@ internal static unsafe bool ObjectHasFinalizer(object obj) [Intrinsic] internal static unsafe MethodTable* GetMethodTable(object obj) => GetMethodTable(obj); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(QCall, EntryPoint = "MethodTable_AreTypesEquivalent")] [return: MarshalAs(UnmanagedType.Bool)] internal static unsafe partial bool AreTypesEquivalent(MethodTable* pMTa, MethodTable* pMTb); @@ -538,18 +538,18 @@ public static IntPtr AllocateTypeAssociatedMemory(Type type, int size, int align return AllocateTypeAssociatedMemoryAligned(new QCallTypeHandle(ref rt), (uint)size, (uint)alignment); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(QCall, EntryPoint = "RuntimeTypeHandle_AllocateTypeAssociatedMemory")] private static partial IntPtr AllocateTypeAssociatedMemory(QCallTypeHandle type, uint size); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(QCall, EntryPoint = "RuntimeTypeHandle_AllocateTypeAssociatedMemoryAligned")] private static partial IntPtr AllocateTypeAssociatedMemoryAligned(QCallTypeHandle type, uint size, uint alignment); [MethodImpl(MethodImplOptions.InternalCall)] private static extern unsafe TailCallArgBuffer* GetTailCallArgBuffer(); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(QCall, EntryPoint = "TailCallHelp_AllocTailCallArgBufferInternal")] private static unsafe partial TailCallArgBuffer* AllocTailCallArgBufferInternal(int size); @@ -1340,7 +1340,7 @@ private static bool CanCastToWorker(TypeHandle srcTH, TypeHandle destTH, bool nu return CanCastTo_NoCacheLookup(srcTH.m_asTAddr, destTH.m_asTAddr) != Interop.BOOL.FALSE; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeHandle_CanCastTo_NoCacheLookup")] private static partial Interop.BOOL CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/StaticsHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/StaticsHelpers.cs index 7b6debe52cc9b7..408dfc33b90168 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/StaticsHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/StaticsHelpers.cs @@ -11,11 +11,11 @@ namespace System.Runtime.CompilerServices [DebuggerStepThrough] internal static unsafe partial class StaticsHelpers { - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall)] private static partial void GetThreadStaticsByIndex(ByteRefOnStack result, int index, [MarshalAs(UnmanagedType.Bool)] bool gcStatics); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall)] private static partial void GetThreadStaticsByMethodTable(ByteRefOnStack result, MethodTable* pMT, [MarshalAs(UnmanagedType.Bool)] bool gcStatics); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/VirtualDispatchHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/VirtualDispatchHelpers.cs index 19b4212830545e..b91829a2a29909 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/VirtualDispatchHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/VirtualDispatchHelpers.cs @@ -58,7 +58,7 @@ private struct VirtualFunctionPointerArgs private static GenericCache s_virtualFunctionPointerCache = new GenericCache(InitialCacheSize, MaximumCacheSize); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall)] private static unsafe partial IntPtr ResolveVirtualFunctionPointer(ObjectHandleOnStack obj, IntPtr classHandle, IntPtr methodHandle); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/ControlledExecution.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/ControlledExecution.CoreCLR.cs index 59368cf338bf97..e26f2804219649 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/ControlledExecution.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/ControlledExecution.CoreCLR.cs @@ -118,7 +118,7 @@ public static void Run(Action action, CancellationToken cancellationToken) } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_Abort")] private static partial void AbortThread(ThreadHandle thread); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/DependentHandle.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/DependentHandle.cs index 0bb61f692e8c83..adb67b4d0782c0 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/DependentHandle.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/DependentHandle.cs @@ -243,7 +243,7 @@ public void Dispose() private static IntPtr InternalAllocWithGCTransition(object? target, object? dependent) => _InternalAllocWithGCTransition(ObjectHandleOnStack.Create(ref target), ObjectHandleOnStack.Create(ref dependent)); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DependentHandle_InternalAllocWithGCTransition")] private static partial IntPtr _InternalAllocWithGCTransition(ObjectHandleOnStack target, ObjectHandleOnStack dependent); @@ -276,7 +276,7 @@ private static IntPtr InternalAllocWithGCTransition(object? target, object? depe private static void InternalFreeWithGCTransition(IntPtr dependentHandle) => _InternalFreeWithGCTransition(dependentHandle); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DependentHandle_InternalFreeWithGCTransition")] private static partial void _InternalFreeWithGCTransition(IntPtr dependentHandle); } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/ExceptionServices/InternalCalls.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/ExceptionServices/InternalCalls.cs index 95a6088aa49c8f..c295689780aa6b 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/ExceptionServices/InternalCalls.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/ExceptionServices/InternalCalls.cs @@ -16,21 +16,21 @@ internal static partial class InternalCalls { [StackTraceHidden] [DebuggerHidden] - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "SfiInit")] [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool RhpSfiInit(ref StackFrameIterator pThis, void* pStackwalkCtx, [MarshalAs(UnmanagedType.U1)] bool instructionFault, bool* fIsExceptionIntercepted); [StackTraceHidden] [DebuggerHidden] - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "SfiNext")] [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool RhpSfiNext(ref StackFrameIterator pThis, uint* uExCollideClauseIdx, bool* fUnwoundReversePInvoke, bool* fIsExceptionIntercepted); [StackTraceHidden] [DebuggerHidden] - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "CallFilterFunclet")] [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool RhpCallFilterFunclet( @@ -38,7 +38,7 @@ internal static unsafe partial bool RhpCallFilterFunclet( [StackTraceHidden] [DebuggerHidden] - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AppendExceptionStackFrame")] internal static unsafe partial void RhpAppendExceptionStackFrame(ObjectHandleOnStack exceptionObj, IntPtr ip, UIntPtr sp, int flags, EH.ExInfo* exInfo); @@ -51,7 +51,7 @@ internal static unsafe partial bool RhpCallFilterFunclet( [StackTraceHidden] [DebuggerHidden] - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EHEnumNext")] [return: MarshalAs(UnmanagedType.U1)] internal static unsafe partial bool RhpEHEnumNext(void* pEHEnum, void* pEHClause); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.CoreCLR.cs index b9419fc7d196ff..466da113acd50f 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.CoreCLR.cs @@ -162,7 +162,7 @@ private static IntPtr GetTaggedImplCurrentVersion() internal sealed partial class ManagedObjectWrapperHolder { - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ComWrappers_RegisterIsRootedCallback")] private static partial void RegisterIsRootedCallback(); @@ -171,7 +171,7 @@ private static IntPtr AllocateRefCountedHandle(ManagedObjectWrapperHolder holder return AllocateRefCountedHandle(ObjectHandleOnStack.Create(ref holder)); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ComWrappers_AllocateRefCountedHandle")] private static partial IntPtr AllocateRefCountedHandle(ObjectHandleOnStack obj); } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/GCHandle.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/GCHandle.CoreCLR.cs index b8067a4fa7a932..8cf8f9981e99fa 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/GCHandle.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/GCHandle.CoreCLR.cs @@ -22,7 +22,7 @@ internal static IntPtr InternalAlloc(object? value, GCHandleType type) private static IntPtr InternalAllocWithGCTransition(object? value, GCHandleType type) => _InternalAllocWithGCTransition(ObjectHandleOnStack.Create(ref value), type); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCHandle_InternalAllocWithGCTransition")] private static partial IntPtr _InternalAllocWithGCTransition(ObjectHandleOnStack value, GCHandleType type); @@ -39,7 +39,7 @@ internal static void InternalFree(IntPtr handle) private static void InternalFreeWithGCTransition(IntPtr dependentHandle) => _InternalFreeWithGCTransition(dependentHandle); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCHandle_InternalFreeWithGCTransition")] private static partial void _InternalFreeWithGCTransition(IntPtr dependentHandle); @@ -59,7 +59,7 @@ private static void InternalFreeWithGCTransition(IntPtr dependentHandle) [MethodImpl(MethodImplOptions.InternalCall)] private static extern bool InternalTryGetBridgeWait(IntPtr handle, ref object? result); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCHandle_InternalGetBridgeWait")] private static partial void InternalGetBridgeWait(IntPtr handle, ObjectHandleOnStack result); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Java/JavaMarshal.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Java/JavaMarshal.CoreCLR.cs index 785b39e89a07e5..e2561f08f3f6d0 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Java/JavaMarshal.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Java/JavaMarshal.CoreCLR.cs @@ -116,16 +116,16 @@ public static unsafe void FinishCrossReferenceProcessing( } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "JavaMarshal_Initialize")] [return: MarshalAs(UnmanagedType.Bool)] private static partial bool InitializeInternal(IntPtr callback); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "JavaMarshal_CreateReferenceTrackingHandle")] private static unsafe partial IntPtr CreateReferenceTrackingHandleInternal(ObjectHandleOnStack obj, void* context); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "JavaMarshal_FinishCrossReferenceProcessing")] private static unsafe partial void FinishCrossReferenceProcessing(MarkCrossReferencesArgs* crossReferences, nuint length, void* unreachableObjectHandles); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.CoreCLR.cs index 924d61215ef863..a1d8d9ab6441a0 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.CoreCLR.cs @@ -32,7 +32,7 @@ public static partial class Marshal internal static int SizeOfHelper(RuntimeType t, [MarshalAs(UnmanagedType.Bool)] bool throwIfNotMarshalable) => SizeOfHelper(new QCallTypeHandle(ref t), throwIfNotMarshalable); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_SizeOfHelper")] private static partial int SizeOfHelper(QCallTypeHandle t, [MarshalAs(UnmanagedType.Bool)] bool throwIfNotMarshalable); @@ -56,7 +56,7 @@ public static IntPtr OffsetOf(Type t, string fieldName) return offset; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_OffsetOf")] private static partial nint OffsetOf(IntPtr pFD); @@ -225,7 +225,7 @@ private static void PrelinkCore(MethodInfo m) GC.KeepAlive(rmi); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_Prelink")] private static partial void InternalPrelink(RuntimeMethodHandleInternal m); @@ -308,7 +308,7 @@ public void InitializeCompositeCache(RuntimeType.CompositeCacheEntry compositeEn } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_HasLayout")] [return: MarshalAs(UnmanagedType.Bool)] internal static partial bool HasLayout(QCallTypeHandle t, [MarshalAs(UnmanagedType.Bool)] out bool isBlittable, out int nativeSize); @@ -411,7 +411,7 @@ internal static unsafe bool IsPinnable(object? obj) [FeatureSwitchDefinition("System.Runtime.InteropServices.BuiltInComInterop.IsSupported")] internal static bool IsBuiltInComSupported { get; } = IsBuiltInComSupportedInternal(); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_IsBuiltInComSupported")] [return: MarshalAs(UnmanagedType.Bool)] private static partial bool IsBuiltInComSupportedInternal(); @@ -434,7 +434,7 @@ public static IntPtr GetHINSTANCE(Module m) return (IntPtr)(-1); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetHINSTANCE")] private static partial IntPtr GetHINSTANCE(QCallModule m); @@ -447,7 +447,7 @@ internal static Exception GetExceptionForHRInternal(int errorCode, IntPtr errorI return exception!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetExceptionForHR")] private static partial void GetExceptionForHRInternal(int errorCode, IntPtr errorInfo, ObjectHandleOnStack exception); @@ -459,7 +459,7 @@ internal static Exception GetExceptionForHRInternal(int errorCode, IntPtr errorI public static int GetHRForException(Exception? e) => GetHRForException(ObjectHandleOnStack.Create(ref e)); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetHRForException")] private static partial int GetHRForException(ObjectHandleOnStack exception); @@ -494,7 +494,7 @@ public static string GetTypeInfoName(ITypeInfo typeInfo) } #pragma warning restore IDE0060 - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetTypeFromCLSID", StringMarshalling = StringMarshalling.Utf16)] private static partial void GetTypeFromCLSID(in Guid clsid, string? server, ObjectHandleOnStack retType); @@ -510,7 +510,7 @@ public static string GetTypeInfoName(ITypeInfo typeInfo) return GetIUnknownForObject(ObjectHandleOnStack.Create(ref o)); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetIUnknownForObject")] private static partial IntPtr /* IUnknown* */ GetIUnknownForObject(ObjectHandleOnStack o); @@ -525,7 +525,7 @@ public static string GetTypeInfoName(ITypeInfo typeInfo) return GetIDispatchForObject(ObjectHandleOnStack.Create(ref o)); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetIDispatchForObject")] private static partial IntPtr /* IDispatch* */ GetIDispatchForObject(ObjectHandleOnStack o); @@ -560,7 +560,7 @@ public static IntPtr GetComInterfaceForObject([DisallowNull] T o) return GetComInterfaceForObject(ObjectHandleOnStack.Create(ref o), new QCallTypeHandle(ref rt), fEnableCustomizedQueryInterface: mode == CustomQueryInterfaceMode.Allow); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetComInterfaceForObject")] private static partial IntPtr /* IUnknown* */ GetComInterfaceForObject(ObjectHandleOnStack o, QCallTypeHandle t, [MarshalAs(UnmanagedType.Bool)] bool fEnableCustomizedQueryInterface); @@ -577,7 +577,7 @@ public static object GetObjectForIUnknown(IntPtr /* IUnknown* */ pUnk) return retObject!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetObjectForIUnknown")] private static partial void GetObjectForIUnknown(IntPtr /* IUnknown* */ pUnk, ObjectHandleOnStack retObject); @@ -597,7 +597,7 @@ public static object GetUniqueObjectForIUnknown(IntPtr unknown) /// existing object). This is useful in cases where you want to be able to call /// ReleaseComObject on a RCW and not worry about other active uses ofsaid RCW. /// - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetUniqueObjectForIUnknown")] private static partial void GetUniqueObjectForIUnknown(IntPtr unknown, ObjectHandleOnStack retObject); @@ -619,7 +619,7 @@ public static object GetTypedObjectForIUnknown(IntPtr /* IUnknown* */ pUnk, Type return retObject!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetTypedObjectForIUnknown")] private static partial void GetTypedObjectForIUnknown(IntPtr /* IUnknown* */ pUnk, QCallTypeHandle t, ObjectHandleOnStack retObject); @@ -638,7 +638,7 @@ public static IntPtr CreateAggregatedObject(IntPtr pOuter, object o) return CreateAggregatedObject(pOuter, ObjectHandleOnStack.Create(ref o)); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_CreateAggregatedObject")] private static partial IntPtr CreateAggregatedObject(IntPtr pOuter, ObjectHandleOnStack o); @@ -656,7 +656,7 @@ public static IntPtr CreateAggregatedObject(IntPtr pOuter, T o) where T : not public static void CleanupUnusedObjectsInCurrentContext() => InternalCleanupUnusedObjectsInCurrentContext(); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_CleanupUnusedObjectsInCurrentContext")] private static partial void InternalCleanupUnusedObjectsInCurrentContext(); @@ -699,7 +699,7 @@ public static int ReleaseComObject(object o) return ReleaseComObject(ObjectHandleOnStack.Create(ref co)); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_ReleaseComObject")] private static partial int ReleaseComObject(ObjectHandleOnStack o); @@ -725,7 +725,7 @@ public static int FinalReleaseComObject(object o) return 0; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_FinalReleaseComObject")] private static partial void FinalReleaseComObject(ObjectHandleOnStack o); @@ -852,7 +852,7 @@ private static object InternalCreateWrapperOfType(object o, Type t) return retObject!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_InternalCreateWrapperOfType")] private static partial void InternalCreateWrapperOfType(ObjectHandleOnStack o, QCallTypeHandle rt, ObjectHandleOnStack retObject); @@ -869,7 +869,7 @@ public static bool IsTypeVisibleFromCom(Type t) return IsTypeVisibleFromCom(new QCallTypeHandle(ref rt)); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_IsTypeVisibleFromCom")] [return: MarshalAs(UnmanagedType.Bool)] private static partial bool IsTypeVisibleFromCom(QCallTypeHandle rt); @@ -888,7 +888,7 @@ public static void GetNativeVariantForObject(object? obj, /* VARIANT * */ IntPtr GetNativeVariantForObject(ObjectHandleOnStack.Create(ref obj), pDstNativeVariant); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetNativeVariantForObject")] private static partial void GetNativeVariantForObject(ObjectHandleOnStack obj, /* VARIANT * */ IntPtr pDstNativeVariant); @@ -920,7 +920,7 @@ public static void GetNativeVariantForObject(T? obj, IntPtr pDstNativeVariant return retObject; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetObjectForNativeVariant")] private static partial void GetObjectForNativeVariant(/* VARIANT * */ IntPtr pSrcNativeVariant, ObjectHandleOnStack retObject); @@ -953,7 +953,7 @@ public static void GetNativeVariantForObject(T? obj, IntPtr pDstNativeVariant return retArray!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetObjectsForNativeVariants")] private static partial void GetObjectsForNativeVariants(/* VARIANT * */ IntPtr aSrcNativeVariant, int cVars, ObjectHandleOnStack retArray); @@ -989,7 +989,7 @@ public static int GetStartComSlot(Type t) return GetStartComSlot(new QCallTypeHandle(ref rt)); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetStartComSlot")] private static partial int GetStartComSlot(QCallTypeHandle rt); @@ -1007,7 +1007,7 @@ public static int GetEndComSlot(Type t) return GetEndComSlot(new QCallTypeHandle(ref rt)); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetEndComSlot")] private static partial int GetEndComSlot(QCallTypeHandle rt); @@ -1064,7 +1064,7 @@ public static void ChangeWrapperHandleStrength(object otp, bool fIsWeak) ChangeWrapperHandleStrength(ObjectHandleOnStack.Create(ref otp), fIsWeak); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_ChangeWrapperHandleStrength")] private static partial void ChangeWrapperHandleStrength(ObjectHandleOnStack otp, [MarshalAs(UnmanagedType.Bool)] bool fIsWeak); #endif // FEATURE_COMINTEROP @@ -1076,7 +1076,7 @@ internal static Delegate GetDelegateForFunctionPointerInternal(IntPtr ptr, Runti return retDelegate!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetDelegateForFunctionPointerInternal")] private static partial void GetDelegateForFunctionPointerInternal(IntPtr ptr, QCallTypeHandle t, ObjectHandleOnStack retDelegate); @@ -1085,7 +1085,7 @@ internal static IntPtr GetFunctionPointerForDelegateInternal(Delegate d) return GetFunctionPointerForDelegateInternal(ObjectHandleOnStack.Create(ref d)); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetFunctionPointerForDelegateInternal")] private static partial IntPtr GetFunctionPointerForDelegateInternal(ObjectHandleOnStack d); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs index 7c51da1cc7dde0..223270eaa79d1b 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs @@ -21,7 +21,7 @@ internal static IntPtr LoadLibraryByName(string libraryName, Assembly assembly, /// External functions that implement the NativeLibrary interface - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeLibrary_LoadByName", StringMarshalling = StringMarshalling.Utf16)] internal static partial IntPtr LoadByName(string libraryName, QCallAssembly callingAssembly, [MarshalAs(UnmanagedType.Bool)] bool hasDllImportSearchPathFlag, uint dllImportSearchPathFlag, diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveCMarshal.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveCMarshal.CoreCLR.cs index dc4a7dce94cca0..3da512e52de25b 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveCMarshal.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ObjectiveCMarshal.CoreCLR.cs @@ -21,14 +21,14 @@ public static void SetMessageSendPendingException(Exception? exception) System.StubHelpers.StubHelpers.SetPendingExceptionObject(exception); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjCMarshal_TrySetGlobalMessageSendCallback")] [return: MarshalAs(UnmanagedType.Bool)] private static partial bool TrySetGlobalMessageSendCallback( MessageSendFunction msgSendFunction, IntPtr func); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjCMarshal_TryInitializeReferenceTracker")] [return: MarshalAs(UnmanagedType.Bool)] private static unsafe partial bool TryInitializeReferenceTracker( @@ -55,7 +55,7 @@ private static unsafe bool TryInitializeReferenceTracker( return result; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjCMarshal_AllocateReferenceTrackingHandle")] private static partial IntPtr AllocateReferenceTrackingHandle(ObjectHandleOnStack obj); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/TrackerObjectManager.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/TrackerObjectManager.CoreCLR.cs index f7874d29e3160b..7b0c073725c459 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/TrackerObjectManager.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/TrackerObjectManager.CoreCLR.cs @@ -39,7 +39,7 @@ private static void RegisterGCCallbacks() RegisterNativeObjectWrapperCache(ObjectHandleOnStack.Create(ref handleSet)); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TrackerObjectManager_RegisterNativeObjectWrapperCache")] private static partial void RegisterNativeObjectWrapperCache(ObjectHandleOnStack nativeObjectWrapperCache); } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs index 1f6b908dec25a2..5211e252a82b35 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs @@ -11,29 +11,29 @@ namespace System.Runtime.Loader { public partial class AssemblyLoadContext { - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_InitializeAssemblyLoadContext")] private static partial IntPtr InitializeAssemblyLoadContext(IntPtr ptrAssemblyLoadContext, [MarshalAs(UnmanagedType.Bool)] bool fRepresentsTPALoadContext, [MarshalAs(UnmanagedType.Bool)] bool isCollectible); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_PrepareForAssemblyLoadContextRelease")] private static partial void PrepareForAssemblyLoadContextRelease(IntPtr ptrNativeAssemblyBinder, IntPtr ptrAssemblyLoadContextStrong); [RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")] - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_LoadFromStream")] private static partial void LoadFromStream(IntPtr ptrNativeAssemblyBinder, IntPtr ptrAssemblyArray, int iAssemblyArrayLen, IntPtr ptrSymbols, int iSymbolArrayLen, ObjectHandleOnStack retAssembly); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MultiCoreJIT_InternalSetProfileRoot", StringMarshalling = StringMarshalling.Utf16)] internal static partial void InternalSetProfileRoot(string directoryPath); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MultiCoreJIT_InternalStartProfile", StringMarshalling = StringMarshalling.Utf16)] internal static partial void InternalStartProfile(string? profile, IntPtr ptrNativeAssemblyBinder); [RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")] - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_LoadFromPath", StringMarshalling = StringMarshalling.Utf16)] private static partial void LoadFromPath(IntPtr ptrNativeAssemblyBinder, string? ilPath, ObjectHandleOnStack retAssembly); @@ -44,26 +44,26 @@ internal static Assembly[] GetLoadedAssemblies() return assemblies!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetLoadedAssemblies")] private static partial void GetLoadedAssemblies(ObjectHandleOnStack retAssemblies); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern bool IsTracingEnabled(); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_TraceResolvingHandlerInvoked", StringMarshalling = StringMarshalling.Utf16)] internal static partial void TraceResolvingHandlerInvoked(string assemblyName, string handlerName, string? alcName, string? resultAssemblyName, string? resultAssemblyPath); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_TraceAssemblyResolveHandlerInvoked", StringMarshalling = StringMarshalling.Utf16)] internal static partial void TraceAssemblyResolveHandlerInvoked(string assemblyName, string handlerName, string? resultAssemblyName, string? resultAssemblyPath); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_TraceAssemblyLoadFromResolveHandlerInvoked", StringMarshalling = StringMarshalling.Utf16)] internal static partial void TraceAssemblyLoadFromResolveHandlerInvoked(string assemblyName, [MarshalAs(UnmanagedType.Bool)] bool isTrackedAssembly, string requestingAssemblyPath, string? requestedAssemblyPath); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_TraceSatelliteSubdirectoryPathProbed", StringMarshalling = StringMarshalling.Utf16)] internal static partial void TraceSatelliteSubdirectoryPathProbed(string filePath, int hResult); @@ -90,7 +90,7 @@ internal unsafe Assembly InternalLoad(ReadOnlySpan arrAssembly, ReadOnlySp } #if TARGET_WINDOWS - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_LoadFromInMemoryModule")] private static partial IntPtr LoadFromInMemoryModuleInternal(IntPtr ptrNativeAssemblyBinder, IntPtr hModule, ObjectHandleOnStack retAssembly); @@ -150,7 +150,7 @@ private static unsafe IntPtr ResolveUnmanagedDllUsingEvent(char* pUnmanagedDllNa } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetLoadContextForAssembly")] private static partial IntPtr GetLoadContextForAssembly(QCallAssembly assembly); diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs index 068b6c83d61075..4c2e270b14d9ce 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs @@ -33,7 +33,7 @@ internal RuntimeType GetRuntimeTypeChecked() => public static RuntimeTypeHandle FromIntPtr(IntPtr value) => new RuntimeTypeHandle(value != IntPtr.Zero ? GetRuntimeTypeFromHandle(value) : null); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetRuntimeTypeFromHandleSlow")] private static partial void GetRuntimeTypeFromHandleSlow( IntPtr handle, @@ -264,7 +264,7 @@ internal static object CreateInstanceForAnotherGenericParameter( return instantiatedObject!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_CreateInstanceForAnotherGenericParameter")] private static partial void CreateInstanceForAnotherGenericParameter( QCallTypeHandle baseType, @@ -287,7 +287,7 @@ internal static object InternalAlloc(RuntimeType type) return result; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_InternalAlloc")] private static unsafe partial void InternalAlloc(MethodTable* pMT, ObjectHandleOnStack result); @@ -306,7 +306,7 @@ static object InternalAllocNoChecksWorker(MethodTable* pMT) } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_InternalAllocNoChecks")] private static unsafe partial void InternalAllocNoChecks(MethodTable* pMT, ObjectHandleOnStack result); @@ -346,7 +346,7 @@ internal static void GetActivationInfo( ctorIsPublic = fCtorIsPublicTemp != Interop.BOOL.FALSE; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetActivationInfo")] private static partial void GetActivationInfo( ObjectHandleOnStack pRuntimeType, @@ -357,7 +357,7 @@ private static partial void GetActivationInfo( Interop.BOOL* pfCtorIsPublic); #if FEATURE_COMINTEROP - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_AllocateComObject")] private static partial void AllocateComObject(void* pClassFactory, ObjectHandleOnStack result); @@ -392,7 +392,7 @@ static RuntimeAssembly GetAssemblyWorker(RuntimeType type) [MethodImpl(MethodImplOptions.InternalCall)] private static extern RuntimeAssembly? GetAssemblyIfExists(RuntimeType type); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetAssemblySlow")] private static partial void GetAssemblySlow(ObjectHandleOnStack type, ObjectHandleOnStack assembly); @@ -412,7 +412,7 @@ static RuntimeModule GetModuleWorker(RuntimeType type) [MethodImpl(MethodImplOptions.InternalCall)] private static extern RuntimeModule? GetModuleIfExists(RuntimeType type); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetModuleSlow")] private static partial void GetModuleSlow(ObjectHandleOnStack type, ObjectHandleOnStack module); @@ -454,7 +454,7 @@ public ModuleHandle GetModuleHandle() [MethodImpl(MethodImplOptions.InternalCall)] internal static extern int GetToken(RuntimeType type); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetMethodAt")] private static unsafe partial IntPtr GetMethodAt(MethodTable* pMT, int slot); @@ -482,7 +482,7 @@ internal static Type[] GetArgumentTypesFromFunctionPointer(RuntimeType type) return argTypes!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetArgumentTypesFromFunctionPointer")] private static partial void GetArgumentTypesFromFunctionPointer(QCallTypeHandle type, ObjectHandleOnStack argTypes); @@ -534,7 +534,7 @@ internal static IntroducedMethodEnumerator GetIntroducedMethods(RuntimeType type [MethodImpl(MethodImplOptions.InternalCall)] private static extern void GetNextIntroducedMethod(ref RuntimeMethodHandleInternal method); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetFields")] private static partial Interop.BOOL GetFields(MethodTable* pMT, Span data, ref int usedCount); @@ -556,7 +556,7 @@ internal static bool GetFields(RuntimeType type, Span buffer, out int co return success; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetInterfaces")] private static unsafe partial void GetInterfaces(MethodTable* pMT, ObjectHandleOnStack result); @@ -576,7 +576,7 @@ internal static Type[] GetInterfaces(RuntimeType type) return result; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetConstraints")] private static partial void GetConstraints(QCallTypeHandle handle, ObjectHandleOnStack types); @@ -590,7 +590,7 @@ internal static Type[] GetInterfaces(RuntimeType type) return types; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "QCall_GetGCHandleForTypeHandle")] private static partial IntPtr GetGCHandle(QCallTypeHandle handle, GCHandleType type); @@ -600,7 +600,7 @@ internal IntPtr GetGCHandle(GCHandleType type) return GetGCHandle(new QCallTypeHandle(ref nativeHandle), type); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "QCall_FreeGCHandleForTypeHandle")] private static partial IntPtr FreeGCHandle(QCallTypeHandle typeHandle, IntPtr objHandle); @@ -613,7 +613,7 @@ internal IntPtr FreeGCHandle(IntPtr objHandle) [MethodImpl(MethodImplOptions.InternalCall)] internal static extern int GetNumVirtuals(RuntimeType type); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals")] private static partial int GetNumVirtualsAndStaticVirtuals(QCallTypeHandle type); @@ -623,7 +623,7 @@ internal static int GetNumVirtualsAndStaticVirtuals(RuntimeType type) return GetNumVirtualsAndStaticVirtuals(new QCallTypeHandle(ref type)); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_VerifyInterfaceIsImplemented")] private static partial void VerifyInterfaceIsImplemented(QCallTypeHandle handle, QCallTypeHandle interfaceHandle); @@ -634,7 +634,7 @@ internal void VerifyInterfaceIsImplemented(RuntimeTypeHandle interfaceHandle) VerifyInterfaceIsImplemented(new QCallTypeHandle(ref nativeHandle), new QCallTypeHandle(ref nativeInterfaceHandle)); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetInterfaceMethodImplementation")] private static partial RuntimeMethodHandleInternal GetInterfaceMethodImplementation(QCallTypeHandle handle, QCallTypeHandle interfaceHandle, RuntimeMethodHandleInternal interfaceMethodHandle); @@ -645,7 +645,7 @@ internal RuntimeMethodHandleInternal GetInterfaceMethodImplementation(RuntimeTyp return GetInterfaceMethodImplementation(new QCallTypeHandle(ref nativeHandle), new QCallTypeHandle(ref nativeInterfaceHandle), interfaceMethodHandle); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_IsVisible")] [return: MarshalAs(UnmanagedType.Bool)] private static partial bool _IsVisible(QCallTypeHandle typeHandle); @@ -655,7 +655,7 @@ internal static bool IsVisible(RuntimeType type) return _IsVisible(new QCallTypeHandle(ref type)); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_ConstructName")] private static partial void ConstructName(QCallTypeHandle handle, TypeNameFormatFlags formatFlags, StringHandleOnStack retString); @@ -697,11 +697,11 @@ internal static bool CanCastTo(RuntimeType type, RuntimeType target) return ret; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetDeclaringTypeHandleForGenericVariable")] private static partial IntPtr GetDeclaringTypeHandleForGenericVariable(IntPtr typeHandle); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetDeclaringTypeHandle")] private static partial IntPtr GetDeclaringTypeHandle(IntPtr typeHandle); @@ -732,7 +732,7 @@ internal static bool CanCastTo(RuntimeType type, RuntimeType target) return result; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetDeclaringMethodForGenericParameter")] private static partial void GetDeclaringMethodForGenericParameter(QCallTypeHandle typeHandle, ObjectHandleOnStack result); @@ -745,7 +745,7 @@ internal static bool CanCastTo(RuntimeType type, RuntimeType target) return method; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetInstantiation")] internal static partial void GetInstantiation(QCallTypeHandle type, ObjectHandleOnStack types, Interop.BOOL fAsRuntimeTypeArray); @@ -765,7 +765,7 @@ internal RuntimeType[] GetInstantiationInternal() return types; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_Instantiate")] private static partial void Instantiate(QCallTypeHandle handle, IntPtr* pInst, int numGenericArgs, ObjectHandleOnStack type); @@ -794,7 +794,7 @@ internal RuntimeType Instantiate(Type[]? inst) } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_MakeArray")] private static partial void MakeArray(QCallTypeHandle handle, int rank, ObjectHandleOnStack type); @@ -806,7 +806,7 @@ internal RuntimeType MakeArray(int rank) return type!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_MakeSZArray")] private static partial void MakeSZArray(QCallTypeHandle handle, ObjectHandleOnStack type); @@ -818,7 +818,7 @@ internal RuntimeType MakeSZArray() return type!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_MakeByRef")] private static partial void MakeByRef(QCallTypeHandle handle, ObjectHandleOnStack type); @@ -830,7 +830,7 @@ internal RuntimeType MakeByRef() return type!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_MakeFunctionPointer")] private static partial void MakeFunctionPointer(nint* retAndParamTypes, int numArgs, [MarshalAs(UnmanagedType.Bool)] bool isUnmanaged, ObjectHandleOnStack type); @@ -854,7 +854,7 @@ internal RuntimeType MakeFunctionPointer(Type[] parameterTypes, bool isUnmanaged return type!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_MakePointer")] private static partial void MakePointer(QCallTypeHandle handle, ObjectHandleOnStack type); @@ -866,7 +866,7 @@ internal RuntimeType MakePointer() return type!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetGenericTypeDefinition")] internal static partial void GetGenericTypeDefinition(QCallTypeHandle type, ObjectHandleOnStack retType); @@ -894,7 +894,7 @@ internal bool ContainsGenericVariables() return ContainsGenericVariables(GetRuntimeTypeChecked()); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_SatisfiesConstraints")] private static partial Interop.BOOL SatisfiesConstraints(QCallTypeHandle paramType, QCallTypeHandle pTypeContext, RuntimeMethodHandleInternal pMethodContext, QCallTypeHandle toType); @@ -906,7 +906,7 @@ internal static bool SatisfiesConstraints(RuntimeType paramType, RuntimeType? ty return result; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_RegisterCollectibleTypeDependency")] private static partial void RegisterCollectibleTypeDependency(QCallTypeHandle type, QCallAssembly assembly); @@ -923,7 +923,7 @@ public void GetObjectData(SerializationInfo info, StreamingContext context) } #if FEATURE_TYPEEQUIVALENCE - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_IsEquivalentTo")] private static partial Interop.BOOL IsEquivalentTo(QCallTypeHandle rtType1, QCallTypeHandle rtType2); @@ -1085,7 +1085,7 @@ internal bool IsNullHandle() return m_value == null; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetFunctionPointer")] internal static partial IntPtr GetFunctionPointer(RuntimeMethodHandleInternal handle); @@ -1099,7 +1099,7 @@ public IntPtr GetFunctionPointer() [MethodImpl(MethodImplOptions.InternalCall)] internal static extern bool IsCollectible(RuntimeMethodHandleInternal method); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_IsCAVisibleFromDecoratedType")] internal static partial Interop.BOOL IsCAVisibleFromDecoratedType( QCallTypeHandle attrTypeHandle, @@ -1120,7 +1120,7 @@ internal static MethodAttributes GetAttributes(IRuntimeMethodInfo method) [MethodImpl(MethodImplOptions.InternalCall)] internal static extern MethodImplAttributes GetImplAttributes(IRuntimeMethodInfo method); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_ConstructInstantiation")] private static partial void ConstructInstantiation(RuntimeMethodHandleInternal method, TypeNameFormatFlags format, StringHandleOnStack retString); @@ -1202,7 +1202,7 @@ internal static MdUtf8String GetUtf8Name(RuntimeMethodHandleInternal method) [DebuggerStepThrough] [DebuggerHidden] - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_InvokeMethod")] private static partial void InvokeMethod(ObjectHandleOnStack target, void** arguments, ObjectHandleOnStack sig, Interop.BOOL isConstructor, ObjectHandleOnStack result); @@ -1257,7 +1257,7 @@ ref obj.GetRawData(), return obj; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetMethodInstantiation")] private static partial void GetMethodInstantiation(RuntimeMethodHandleInternal method, ObjectHandleOnStack types, Interop.BOOL fAsRuntimeTypeArray); @@ -1297,7 +1297,7 @@ internal static bool HasMethodInstantiation(IRuntimeMethodInfo method) [MethodImpl(MethodImplOptions.InternalCall)] private static extern RuntimeMethodHandleInternal GetStubIfNeededInternal(RuntimeMethodHandleInternal method, RuntimeType declaringType); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetStubIfNeededSlow")] private static partial RuntimeMethodHandleInternal GetStubIfNeededSlow(RuntimeMethodHandleInternal method, QCallTypeHandle declaringTypeHandle, ObjectHandleOnStack methodInstantiation); @@ -1320,7 +1320,7 @@ static RuntimeMethodHandleInternal GetStubIfNeededWorker(RuntimeMethodHandleInte [MethodImpl(MethodImplOptions.InternalCall)] internal static extern RuntimeMethodHandleInternal GetMethodFromCanonical(RuntimeMethodHandleInternal method, RuntimeType declaringType); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetNativeCode")] private static partial IntPtr GetNativeCode(RuntimeMethodHandleInternal method); @@ -1344,7 +1344,7 @@ internal static bool IsGenericMethodDefinition(IRuntimeMethodInfo method) [MethodImpl(MethodImplOptions.InternalCall)] private static extern bool IsTypicalMethodDefinition(IRuntimeMethodInfo method); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetTypicalMethodDefinition")] private static partial void GetTypicalMethodDefinition(RuntimeMethodHandleInternal method, ObjectHandleOnStack outMethod); @@ -1364,7 +1364,7 @@ internal static IRuntimeMethodInfo GetTypicalMethodDefinition(IRuntimeMethodInfo internal static int GetGenericParameterCount(IRuntimeMethodInfo method) => GetGenericParameterCount(IRuntimeMethodInfo.GetValue(method)); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_StripMethodInstantiation")] private static partial void StripMethodInstantiation(RuntimeMethodHandleInternal method, ObjectHandleOnStack outMethod); @@ -1381,14 +1381,14 @@ internal static IRuntimeMethodInfo StripMethodInstantiation(IRuntimeMethodInfo m [MethodImpl(MethodImplOptions.InternalCall)] internal static extern bool IsDynamicMethod(RuntimeMethodHandleInternal method); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_Destroy")] internal static partial void Destroy(RuntimeMethodHandleInternal method); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern Resolver GetResolver(RuntimeMethodHandleInternal method); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetMethodBody")] private static partial void GetMethodBody(RuntimeMethodHandleInternal method, QCallTypeHandle declaringType, ObjectHandleOnStack result); @@ -1611,7 +1611,7 @@ internal static RuntimeType GetApproxDeclaringType(IRuntimeFieldInfo field) [MethodImpl(MethodImplOptions.InternalCall)] internal static extern IntPtr GetStaticFieldAddress(RtFieldInfo field); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeFieldHandle_GetRVAFieldInfo")] [return: MarshalAs(UnmanagedType.Bool)] internal static partial bool GetRVAFieldInfo(RuntimeFieldHandleInternal field, out void* address, out uint size); @@ -1632,7 +1632,7 @@ internal static ref byte GetFieldDataReference(ref byte target, RuntimeFieldInfo return ref Unsafe.AddByteOffset(ref target, offset); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeFieldHandle_GetFieldDataReference")] private static unsafe partial void GetFieldDataReference(IntPtr fieldDesc, ObjectHandleOnStack target, ByteRefOnStack fieldDataRef); @@ -1646,7 +1646,7 @@ internal static int GetToken(RtFieldInfo field) return tk; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeFieldHandle_GetValue")] private static partial void GetValue( IntPtr fieldDesc, @@ -1669,7 +1669,7 @@ private static partial void GetValue( return result; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeFieldHandle_GetValueDirect")] private static partial void GetValueDirect( IntPtr fieldDesc, @@ -1691,7 +1691,7 @@ private static partial void GetValueDirect( return result; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeFieldHandle_SetValue")] private static partial void SetValue( IntPtr fieldDesc, @@ -1712,7 +1712,7 @@ internal static void SetValue(RtFieldInfo field, object? obj, object? value, Run GC.KeepAlive(field); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeFieldHandle_SetValueDirect")] private static partial void SetValueDirect( IntPtr fieldDesc, @@ -1766,7 +1766,7 @@ public void GetObjectData(SerializationInfo info, StreamingContext context) throw new PlatformNotSupportedException(); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeFieldHandle_GetEnCFieldAddr")] private static partial void* GetEnCFieldAddr(ObjectHandleOnStack tgt, void* pFD); @@ -1842,7 +1842,7 @@ public bool Equals(ModuleHandle handle) public static bool operator !=(ModuleHandle left, ModuleHandle right) => !left.Equals(right); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleHandle_GetDynamicMethod", StringMarshalling = StringMarshalling.Utf8)] private static partial void GetDynamicMethod( QCallModule module, @@ -1932,7 +1932,7 @@ public RuntimeTypeHandle ResolveTypeHandle(int typeToken, RuntimeTypeHandle[]? t } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleHandle_ResolveType")] private static partial void ResolveType(QCallModule module, int typeToken, @@ -1985,7 +1985,7 @@ internal static RuntimeMethodHandleInternal ResolveMethodHandleInternal(RuntimeM } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleHandle_ResolveMethod")] private static partial RuntimeMethodHandleInternal ResolveMethod(QCallModule module, int methodToken, @@ -2040,7 +2040,7 @@ public RuntimeFieldHandle ResolveFieldHandle(int fieldToken, RuntimeTypeHandle[] } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleHandle_ResolveField")] private static partial void ResolveField(QCallModule module, int fieldToken, @@ -2050,7 +2050,7 @@ private static partial void ResolveField(QCallModule module, int methodInstCount, ObjectHandleOnStack retField); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleHandle_GetModuleType")] internal static partial void GetModuleType(QCallModule handle, ObjectHandleOnStack type); @@ -2061,7 +2061,7 @@ internal static RuntimeType GetModuleType(RuntimeModule module) return type!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ModuleHandle_GetPEKind")] private static partial void GetPEKind(QCallModule handle, int* peKind, int* machine); @@ -2105,7 +2105,7 @@ internal sealed unsafe partial class Signature private RuntimeMethodHandleInternal _pMethod; #endregion - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Signature_Init")] private static partial void Init( ObjectHandleOnStack _this, @@ -2179,7 +2179,7 @@ internal RuntimeType[] Arguments internal RuntimeType ReturnType => _returnTypeORfieldType; internal RuntimeType FieldType => _returnTypeORfieldType; - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Signature_AreEqual")] private static partial Interop.BOOL AreEqual( void* sig1, int csig1, QCallTypeHandle type1, @@ -2243,7 +2243,7 @@ internal SignatureCallingConvention GetCallingConventionFromFunctionPointerAtOff internal Type[] GetCustomModifiers(int parameterIndex, bool required) => GetCustomModifiersAtOffset(GetParameterOffset(parameterIndex), required); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Signature_GetCustomModifiersAtOffset")] private static partial void GetCustomModifiersAtOffset( ObjectHandleOnStack sigObj, diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.BoxCache.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.BoxCache.cs index 59078611610d4d..3518f1af6df0f3 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.BoxCache.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.BoxCache.cs @@ -130,7 +130,7 @@ private static void GetBoxInfo( valueTypeSize = valueTypeSizeTemp; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ReflectionInvocation_GetBoxInfo")] private static partial void GetBoxInfo( QCallTypeHandle type, diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs index 4e5cb256acbe6f..3e4d90b0cb8161 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs @@ -3414,7 +3414,7 @@ public override unsafe Guid GUID } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ReflectionInvocation_GetGuid")] private static unsafe partial void GetGuid(MethodTable* pMT, Guid* result); @@ -3427,7 +3427,7 @@ private static unsafe void GetComObjectGuidWorker(RuntimeType type, Guid* result GetComObjectGuid(ObjectHandleOnStack.Create(ref type), result); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ReflectionInvocation_GetComObjectGuid")] private static unsafe partial void GetComObjectGuid(ObjectHandleOnStack type, Guid* result); #endif // FEATURE_COMINTEROP @@ -4138,7 +4138,7 @@ internal void CallDefaultStructConstructor(ref byte data) #endregion #if FEATURE_COMINTEROP - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ReflectionInvocation_InvokeDispMethod")] private static partial void InvokeDispMethod( ObjectHandleOnStack type, @@ -4369,7 +4369,7 @@ private enum DispatchWrapperType : int #region Library internal readonly unsafe partial struct MdUtf8String { - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MdUtf8String_EqualsCaseInsensitive")] [return: MarshalAs(UnmanagedType.Bool)] private static partial bool EqualsCaseInsensitive(void* szLhs, void* szRhs, int cSz); diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CreateUninitializedCache.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CreateUninitializedCache.CoreCLR.cs index 39e7a2801cc573..17eab423c66f7d 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CreateUninitializedCache.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CreateUninitializedCache.CoreCLR.cs @@ -75,7 +75,7 @@ private static void GetCreateUninitializedInfo( vAllocatorFirstArg = vAllocatorFirstArgTemp; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ReflectionSerialization_GetCreateUninitializedObjectInfo")] private static partial void GetCreateUninitializedInfo( QCallTypeHandle type, diff --git a/src/coreclr/System.Private.CoreLib/src/System/String.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/String.CoreCLR.cs index 1b30862f88f118..e0101ede01e40d 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/String.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/String.CoreCLR.cs @@ -22,7 +22,7 @@ internal static unsafe string FastAllocateString(nint length) return FastAllocateString(TypeHandle.TypeHandleOf().AsMethodTable(), length); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "String_Intern")] private static partial void Intern(StringHandleOnStack src); @@ -33,7 +33,7 @@ public static string Intern(string str) return str; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "String_IsInterned")] private static partial void IsInterned(StringHandleOnStack src); diff --git a/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs index 9f35eafd7394c5..ec8d4191b8052d 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs @@ -538,7 +538,7 @@ internal static void ConvertToNative(object objSrc, IntPtr pDstVariant) ConvertToNative(ObjectHandleOnStack.Create(ref objSrc), pDstVariant); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjectMarshaler_ConvertToNative")] private static partial void ConvertToNative(ObjectHandleOnStack objSrc, IntPtr pDstVariant); @@ -549,7 +549,7 @@ internal static object ConvertToManaged(IntPtr pSrcVariant) return retObject!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjectMarshaler_ConvertToManaged")] private static partial void ConvertToManaged(IntPtr pSrcVariant, ObjectHandleOnStack retObject); @@ -633,7 +633,7 @@ internal static IntPtr ConvertToNative(object? objSrc, IntPtr itfMT, IntPtr clas return ConvertToNative(ObjectHandleOnStack.Create(ref objSrc), itfMT, classMT, flags); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "InterfaceMarshaler_ConvertToNative")] private static partial IntPtr ConvertToNative(ObjectHandleOnStack objSrc, IntPtr itfMT, IntPtr classMT, int flag); @@ -647,7 +647,7 @@ internal static IntPtr ConvertToNative(object? objSrc, IntPtr itfMT, IntPtr clas return retObject; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "InterfaceMarshaler_ConvertToManaged")] private static partial void ConvertToManaged(ref IntPtr ppUnk, IntPtr itfMT, IntPtr classMT, int flags, ObjectHandleOnStack retObject); @@ -666,11 +666,11 @@ internal static object GetObjectForComCallableWrapperIUnknown(IntPtr unk) return retObject!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "InterfaceMarshaler_GetObjectForComCallableWrapperIUnknown")] private static partial void GetObjectForComCallableWrapperIUnknown(IntPtr unk, ObjectHandleOnStack retObject); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "InterfaceMarshaler_ValidateComVisibilityForIUnknown")] internal static partial void ValidateComVisibilityForIUnknown(IntPtr unk); } // class InterfaceMarshaler @@ -690,7 +690,7 @@ internal static void ConvertSpaceToNative(IntPtr pMarshalState, in object pManag ConvertSpaceToNative(pMarshalState, ObjectHandleOnStack.Create(ref managedHome), pNativeHome); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MngdSafeArrayMarshaler_ConvertSpaceToNative")] private static partial void ConvertSpaceToNative(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome); @@ -701,7 +701,7 @@ internal static void ConvertContentsToNative(IntPtr pMarshalState, in object pMa ConvertContentsToNative(pMarshalState, ObjectHandleOnStack.Create(ref managedHome), pNativeHome, ObjectHandleOnStack.Create(ref originalManagedObject)); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MngdSafeArrayMarshaler_ConvertContentsToNative")] private static partial void ConvertContentsToNative(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome, ObjectHandleOnStack pOriginalManagedObject); @@ -712,7 +712,7 @@ internal static void ConvertSpaceToManaged(IntPtr pMarshalState, ref object? pMa pManagedHome = managedHome; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MngdSafeArrayMarshaler_ConvertSpaceToManaged")] private static partial void ConvertSpaceToManaged(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome); @@ -722,7 +722,7 @@ internal static void ConvertContentsToManaged(IntPtr pMarshalState, in object pM ConvertContentsToManaged(pMarshalState, ObjectHandleOnStack.Create(ref managedHome), pNativeHome); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MngdSafeArrayMarshaler_ConvertContentsToManaged")] private static partial void ConvertContentsToManaged(IntPtr pMarshalState, ObjectHandleOnStack pManagedHome, IntPtr pNativeHome); @@ -733,7 +733,7 @@ internal static void ClearNative(IntPtr pMarshalState, in object pManagedHome, I } #pragma warning restore IDE0060 // Remove unused parameter - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MngdSafeArrayMarshaler_ClearNative")] private static partial void ClearNative(IntPtr pMarshalState, IntPtr pNativeHome); } // class MngdSafeArrayMarshaler @@ -2187,11 +2187,11 @@ internal static partial class StubHelpers internal static extern safe void SetLastError(); /// QCall that throws an interop parameter exception selected by integer resource and parameter indices; it accesses no caller-supplied memory. - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_ThrowInteropParamException")] internal static safe partial void ThrowInteropParamException(int resID, int paramIdx); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_ThrowInteropException")] internal static partial void ThrowInteropException(int exceptionKind, int resID); @@ -2248,7 +2248,7 @@ internal static void SetPendingExceptionObject(Exception? exception) s_pendingExceptionObject = exception; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_CreateCustomMarshaler")] internal static partial void CreateCustomMarshaler(IntPtr pMD, int paramToken, IntPtr hndManagedType, ObjectHandleOnStack customMarshaler); @@ -2356,7 +2356,7 @@ internal static void SafeHandleRelease(SafeHandle pHandle) [MethodImpl(MethodImplOptions.InternalCall)] private static extern IntPtr GetCOMIPFromRCW(object objSrc, IntPtr pInterfaceMT, int comSlot, out IntPtr ppTarget); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_GetCOMIPFromRCWSlow")] private static partial IntPtr GetCOMIPFromRCWSlow(ObjectHandleOnStack objSrc, IntPtr pInterfaceMT, int comSlot, out IntPtr ppTarget, [MarshalAs(UnmanagedType.Bool)] out bool pfNeedsRelease); @@ -2383,11 +2383,11 @@ static IntPtr GetCOMIPFromRCWWorker(object objSrc, IntPtr pInterfaceMT, int comS //------------------------------------------------------- // Profiler helpers //------------------------------------------------------- - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_ProfilerBeginTransitionCallback")] internal static unsafe partial void* ProfilerBeginTransitionCallback(void* pTargetMD); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_ProfilerEndTransitionCallback")] internal static unsafe partial void ProfilerEndTransitionCallback(void* pTargetMD); #endif // PROFILING_SUPPORTED @@ -2408,7 +2408,7 @@ internal static void CheckStringLength(uint length) } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_CreateLayoutClassMarshalStubs")] internal static unsafe partial void CreateLayoutClassMarshalStubs(QCallTypeHandle th, out delegate* pConvertToUnmanaged, out delegate* pConvertToManaged, out delegate* pFree); @@ -2523,11 +2523,11 @@ internal static void ThrowWrongSizeArrayInNativeStruct() } #if FEATURE_VARARGS - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_MarshalToManagedVaList")] internal static partial void MarshalToManagedVaList(IntPtr va_list, IntPtr pArgIterator); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_MarshalToUnmanagedVaList")] internal static partial void MarshalToUnmanagedVaList(IntPtr va_list, uint vaListSize, IntPtr pArgIterator); @@ -2538,14 +2538,14 @@ internal static void ThrowWrongSizeArrayInNativeStruct() [MethodImpl(MethodImplOptions.InternalCall)] internal static extern void LogPinnedArgument(IntPtr localDesc, IntPtr nativeArg); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_ValidateObject")] private static partial void ValidateObject(ObjectHandleOnStack obj, IntPtr pMD); internal static void ValidateObject(object obj, IntPtr pMD) => ValidateObject(ObjectHandleOnStack.Create(ref obj), pMD); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_ValidateByref")] internal static partial void ValidateByref(IntPtr byref, IntPtr pMD); // the byref is pinned so we can safely "cast" it to IntPtr @@ -2558,7 +2558,7 @@ internal static void MulticastDebuggerTraceHelper(object o, int count) MulticastDebuggerTraceHelperQCall(ObjectHandleOnStack.Create(ref o), count); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_MulticastDebuggerTraceHelper")] private static partial void MulticastDebuggerTraceHelperQCall(ObjectHandleOnStack obj, int count); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Threading/ObjectHeader.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Threading/ObjectHeader.CoreCLR.cs index ec3891fa11c48a..fd0a9d8cbd6840 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Threading/ObjectHeader.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Threading/ObjectHeader.CoreCLR.cs @@ -88,7 +88,7 @@ static Lock GetLockObjectFallback(object obj) [MethodImpl(MethodImplOptions.InternalCall)] private static extern IntPtr GetLockHandleIfExists(object obj); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjectHeader_GetOrCreateLockObject")] private static partial void GetOrCreateLockObject(ObjectHandleOnStack obj, ObjectHandleOnStack lockObj); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs index f3905111f54321..924f431c2e83fb 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs @@ -64,7 +64,7 @@ internal static Exception GetQCallSpecialException(nint status) return exception!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetQCallSpecialException")] private static partial void GetQCallSpecialException(nint status, ObjectHandleOnStack exception); @@ -103,7 +103,7 @@ private unsafe void StartCore() } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_Start")] private static unsafe partial Interop.BOOL StartInternal(ThreadHandle t, int stackSize, int priority, Interop.BOOL isThreadPool, char* pThreadName, ObjectHandleOnStack exception); @@ -154,7 +154,7 @@ public static void SpinWait(int iterations) } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_YieldThread")] private static partial Interop.BOOL YieldInternal(); @@ -168,7 +168,7 @@ private static Thread InitializeCurrentThread() return t_currentThread = thread!; } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetCurrentThread")] private static partial void GetCurrentThread(ObjectHandleOnStack thread); @@ -178,7 +178,7 @@ private void Initialize() Initialize(ObjectHandleOnStack.Create(ref _this)); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_Initialize")] private static partial void Initialize(ObjectHandleOnStack thread); @@ -194,7 +194,7 @@ private void ThreadNameChanged(string? value) GC.KeepAlive(this); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_InformThreadNameChange", StringMarshalling = StringMarshalling.Utf16)] private static partial void InformThreadNameChange(ThreadHandle t, string? name, int len); @@ -238,7 +238,7 @@ public bool IsBackground [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetIsBackground")] private static partial Interop.BOOL GetIsBackground(ThreadHandle t); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_SetIsBackground")] private static partial void SetIsBackground(ThreadHandle t, Interop.BOOL value); @@ -267,7 +267,7 @@ internal set } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_SetPriority")] [return: MarshalAs(UnmanagedType.Bool)] private static partial void SetPriority(ObjectHandleOnStack thread, int priority); @@ -291,7 +291,7 @@ public ThreadPriority Priority } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetCurrentOSThreadId")] private static partial ulong GetCurrentOSThreadId(); @@ -339,11 +339,11 @@ internal unsafe void ClearWaitSleepJoinState() /// single-threaded or multi-threaded apartment. /// #if FEATURE_COMINTEROP_APARTMENT_SUPPORT - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetApartmentState")] private static partial int GetApartmentState(ObjectHandleOnStack t); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_SetApartmentState")] private static partial int SetApartmentState(ObjectHandleOnStack t, int state); @@ -439,11 +439,11 @@ public void Interrupt() } #if TARGET_WINDOWS - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_Interrupt")] private static partial void Interrupt(ThreadHandle t); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetOSHandle")] private static partial SafeWaitHandle GetOSHandle(ThreadHandle t); @@ -607,11 +607,11 @@ private static unsafe void OnThreadExited(Thread* pThread, Exception* pException } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_ReentrantWaitAny")] internal static unsafe partial int ReentrantWaitAny([MarshalAs(UnmanagedType.Bool)] bool alertable, int timeout, int count, IntPtr* handles); - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_CheckForPendingInterrupt")] internal static partial void CheckForPendingInterrupt(); diff --git a/src/coreclr/System.Private.CoreLib/src/System/TypeLoadException.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/TypeLoadException.CoreCLR.cs index 13fd8d3513efbd..6dc54827aa3dae 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/TypeLoadException.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/TypeLoadException.CoreCLR.cs @@ -45,7 +45,7 @@ private void SetMessageField() } } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall)] private static partial void GetTypeLoadExceptionMessage(int resourceId, StringHandleOnStack retString); diff --git a/src/coreclr/System.Private.CoreLib/src/System/ValueType.cs b/src/coreclr/System.Private.CoreLib/src/System/ValueType.cs index abfe65d6d4bf41..270be212a2286b 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/ValueType.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/ValueType.cs @@ -82,7 +82,7 @@ private static unsafe bool CanCompareBitsOrUseFastGetHashCode(MethodTable* pMT) return CanCompareBitsOrUseFastGetHashCodeHelper(pMT); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MethodTable_CanCompareBitsOrUseFastGetHashCode")] [return: MarshalAs(UnmanagedType.Bool)] private static unsafe partial bool CanCompareBitsOrUseFastGetHashCodeHelper(MethodTable* pMT); @@ -163,7 +163,7 @@ private enum ValueTypeHashCodeStrategy ValueTypeOverride, } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ValueType_GetHashCodeStrategy")] private static unsafe partial ValueTypeHashCodeStrategy GetHashCodeStrategy( MethodTable* pMT, ObjectHandleOnStack objHandle, out uint fieldOffset, out uint fieldSize, out MethodTable* fieldMT); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Variant.cs b/src/coreclr/System.Private.CoreLib/src/System/Variant.cs index f88a6fbe5515a1..b7105f82049c2e 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Variant.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Variant.cs @@ -18,7 +18,7 @@ internal static partial class Variant { internal static bool IsSystemDrawingColor(Type type) => type.FullName == "System.Drawing.Color"; // Matches the behavior of IsTypeRefOrDef - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Variant_ConvertValueTypeToRecord")] private static partial void ConvertValueTypeToRecord(ObjectHandleOnStack obj, out ComVariant pOle); @@ -28,7 +28,7 @@ internal static ComVariant GetIUnknownOrIDispatchFromObject(object? obj) return ComVariant.CreateRaw(isIDispatch ? VarEnum.VT_DISPATCH : VarEnum.VT_UNKNOWN, pUnk); } - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetIUnknownOrIDispatchForObject")] private static partial IntPtr GetIUnknownOrIDispatchForObject(ObjectHandleOnStack o, [MarshalAs(UnmanagedType.Bool)] out bool isIDispatch); diff --git a/src/coreclr/vm/JitQCallHelpers.h b/src/coreclr/vm/JitQCallHelpers.h index 3ccc1361ad6e4b..589be9d0722388 100644 --- a/src/coreclr/vm/JitQCallHelpers.h +++ b/src/coreclr/vm/JitQCallHelpers.h @@ -18,12 +18,12 @@ class Module; class MethodTable; class MethodDesc; -extern "C" QCallExceptionStatus QCALLTYPE ResolveVirtualFunctionPointer(QCall::ObjectHandleOnStack obj, CORINFO_CLASS_HANDLE classHnd, CORINFO_METHOD_HANDLE methodHnd, PCODE* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE GenericHandleWorker(MethodDesc * pMD, MethodTable * pMT, LPVOID signature, DWORD dictionaryIndexAndSlot, Module* pModule, void** pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE InitClassHelper(MethodTable* pMT); -extern "C" QCallExceptionStatus QCALLTYPE ThrowInvalidCastException(CORINFO_CLASS_HANDLE pTargetType, CORINFO_CLASS_HANDLE pSourceType); -extern "C" QCallExceptionStatus QCALLTYPE GetThreadStaticsByMethodTable(QCall::ByteRefOnStack refHandle, MethodTable* pMT, BOOL gcStatic); -extern "C" QCallExceptionStatus QCALLTYPE GetThreadStaticsByIndex(QCall::ByteRefOnStack refHandle, uint32_t staticBlockIndex, BOOL gcStatic); -extern "C" QCallExceptionStatus QCALLTYPE IsInstanceOf_NoCacheLookup(CORINFO_CLASS_HANDLE type, BOOL throwCastException, QCall::ObjectHandleOnStack objOnStack, BOOL* pReturnValue); +extern "C" void * QCALLTYPE ResolveVirtualFunctionPointer(QCall::ObjectHandleOnStack obj, CORINFO_CLASS_HANDLE classHnd, CORINFO_METHOD_HANDLE methodHnd, QCallExceptionStatus* qcallError); +extern "C" CORINFO_GENERIC_HANDLE QCALLTYPE GenericHandleWorker(MethodDesc * pMD, MethodTable * pMT, LPVOID signature, DWORD dictionaryIndexAndSlot, Module* pModule, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE InitClassHelper(MethodTable* pMT, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ThrowInvalidCastException(CORINFO_CLASS_HANDLE pTargetType, CORINFO_CLASS_HANDLE pSourceType, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE GetThreadStaticsByMethodTable(QCall::ByteRefOnStack refHandle, MethodTable* pMT, BOOL gcStatic, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE GetThreadStaticsByIndex(QCall::ByteRefOnStack refHandle, uint32_t staticBlockIndex, BOOL gcStatic, QCallExceptionStatus* qcallError); +extern "C" BOOL QCALLTYPE IsInstanceOf_NoCacheLookup(CORINFO_CLASS_HANDLE type, BOOL throwCastException, QCall::ObjectHandleOnStack objOnStack, QCallExceptionStatus* qcallError); #endif //_JITQCALLHELPERS_H diff --git a/src/coreclr/vm/appdomainnative.cpp b/src/coreclr/vm/appdomainnative.cpp index a42c0c16b93216..092505035a63d8 100644 --- a/src/coreclr/vm/appdomainnative.cpp +++ b/src/coreclr/vm/appdomainnative.cpp @@ -16,7 +16,7 @@ #include "stringarraylist.h" // static -extern "C" QCallExceptionStatus QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnStack assemblyLoadContext, NativeAssemblyNameParts* pAssemblyNameParts, INT32 hashAlgorithm, INT32 access, QCall::ObjectHandleOnStack retAssembly) +extern "C" void QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnStack assemblyLoadContext, NativeAssemblyNameParts* pAssemblyNameParts, INT32 hashAlgorithm, INT32 access, QCall::ObjectHandleOnStack retAssembly, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -41,7 +41,7 @@ extern "C" QCallExceptionStatus QCALLTYPE AppDomain_CreateDynamicAssembly(QCall: END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetLoadedAssemblies(QCall::ObjectHandleOnStack retAssemblies) +extern "C" void QCALLTYPE AssemblyNative_GetLoadedAssemblies(QCall::ObjectHandleOnStack retAssemblies, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -141,14 +141,14 @@ namespace } // Get the value of a known host property from the binder/AppDomain state. -extern "C" QCallExceptionStatus QCALLTYPE AppContext_TryGetHostPropertyValue(LPCWSTR name, QCall::StringHandleOnStack retValue, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE AppContext_TryGetHostPropertyValue(LPCWSTR name, QCall::StringHandleOnStack retValue, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - BOOL found = FALSE; + BEGIN_QCALL; + AppDomain* pDomain = AppDomain::GetCurrentDomain(); DefaultAssemblyBinder* pBinder = pDomain->GetDefaultBinder(); BINDER_SPACE::ApplicationContext* pAppContext = pBinder->GetAppContext(); @@ -229,12 +229,12 @@ extern "C" QCallExceptionStatus QCALLTYPE AppContext_TryGetHostPropertyValue(LPC _ASSERTE(!"AppContext_TryGetHostPropertyValue called with unknown name"); } - *pReturnValue = found; - END_QCALL; + + return found; } -extern "C" QCallExceptionStatus QCALLTYPE String_IsInterned(QCall::StringHandleOnStack str) +extern "C" void QCALLTYPE String_IsInterned(QCall::StringHandleOnStack str, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -251,7 +251,7 @@ extern "C" QCallExceptionStatus QCALLTYPE String_IsInterned(QCall::StringHandleO END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE String_Intern(QCall::StringHandleOnStack str) +extern "C" void QCALLTYPE String_Intern(QCall::StringHandleOnStack str, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/appdomainnative.hpp b/src/coreclr/vm/appdomainnative.hpp index b8d9880cf5b17b..bc7eed9d818f92 100644 --- a/src/coreclr/vm/appdomainnative.hpp +++ b/src/coreclr/vm/appdomainnative.hpp @@ -16,13 +16,13 @@ #include "qcall.h" -extern "C" QCallExceptionStatus QCALLTYPE String_Intern(QCall::StringHandleOnStack str); -extern "C" QCallExceptionStatus QCALLTYPE String_IsInterned(QCall::StringHandleOnStack str); +extern "C" void QCALLTYPE String_Intern(QCall::StringHandleOnStack str, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE String_IsInterned(QCall::StringHandleOnStack str, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnStack assemblyLoadContext, NativeAssemblyNameParts* pAssemblyName, INT32 hashAlgorithm, INT32 access, QCall::ObjectHandleOnStack retAssembly); +extern "C" void QCALLTYPE AppDomain_CreateDynamicAssembly(QCall::ObjectHandleOnStack assemblyLoadContext, NativeAssemblyNameParts* pAssemblyName, INT32 hashAlgorithm, INT32 access, QCall::ObjectHandleOnStack retAssembly, QCallExceptionStatus* qcallError); extern "C" void QCALLTYPE AppContext_SetFirstChanceExceptionHandler(); -extern "C" QCallExceptionStatus QCALLTYPE AppContext_TryGetHostPropertyValue(LPCWSTR name, QCall::StringHandleOnStack retValue, BOOL* pReturnValue); +extern "C" BOOL QCALLTYPE AppContext_TryGetHostPropertyValue(LPCWSTR name, QCall::StringHandleOnStack retValue, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetLoadedAssemblies(QCall::ObjectHandleOnStack retAssemblies); +extern "C" void QCALLTYPE AssemblyNative_GetLoadedAssemblies(QCall::ObjectHandleOnStack retAssemblies, QCallExceptionStatus* qcallError); #endif diff --git a/src/coreclr/vm/arraynative.cpp b/src/coreclr/vm/arraynative.cpp index e531390928bd72..4986e61dd4c996 100644 --- a/src/coreclr/vm/arraynative.cpp +++ b/src/coreclr/vm/arraynative.cpp @@ -28,23 +28,23 @@ FCIMPL1(INT32, ArrayNative::GetCorElementTypeOfElementType, ArrayBase* arrayUNSA } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE Array_GetElementConstructorEntrypoint(QCall::TypeHandle pArrayTypeHnd, PCODE* pReturnValue) +extern "C" PCODE QCALLTYPE Array_GetElementConstructorEntrypoint(QCall::TypeHandle pArrayTypeHnd, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - PCODE ctorEntrypoint = (PCODE)NULL; + BEGIN_QCALL; + TypeHandle th = pArrayTypeHnd.AsTypeHandle(); MethodTable* pElemMT = th.GetArrayElementTypeHandle().AsMethodTable(); ctorEntrypoint = pElemMT->GetDefaultConstructor()->GetMultiCallableAddrOfCode(); pElemMT->EnsureInstanceActive(); - *pReturnValue = ctorEntrypoint; - END_QCALL; + + return ctorEntrypoint; } // @@ -107,7 +107,7 @@ static void CheckElementType(TypeHandle elementType) } } -extern "C" QCallExceptionStatus QCALLTYPE Array_CreateInstance(QCall::TypeHandle pTypeHnd, INT32 rank, INT32* pLengths, INT32* pLowerBounds, BOOL createFromArrayType, QCall::ObjectHandleOnStack retArray) +extern "C" void QCALLTYPE Array_CreateInstance(QCall::TypeHandle pTypeHnd, INT32 rank, INT32* pLengths, INT32* pLowerBounds, BOOL createFromArrayType, QCall::ObjectHandleOnStack retArray, QCallExceptionStatus* qcallError) { CONTRACTL { QCALL_CHECK; @@ -203,7 +203,7 @@ Done: ; END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE Array_Ctor(MethodTable* pArrayMT, UINT32 dwNumArgs, INT32* pArgList, QCall::ObjectHandleOnStack retArray) +extern "C" void QCALLTYPE Array_Ctor(MethodTable* pArrayMT, UINT32 dwNumArgs, INT32* pArgList, QCall::ObjectHandleOnStack retArray, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/arraynative.h b/src/coreclr/vm/arraynative.h index 8905f6a6cfdde6..3bb51b91d67063 100644 --- a/src/coreclr/vm/arraynative.h +++ b/src/coreclr/vm/arraynative.h @@ -21,8 +21,8 @@ class ArrayNative FCDECL1(static INT32, GetCorElementTypeOfElementType, ArrayBase* arrayUNSAFE); }; -extern "C" QCallExceptionStatus QCALLTYPE Array_GetElementConstructorEntrypoint(QCall::TypeHandle pArrayTypeHnd, PCODE* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE Array_CreateInstance(QCall::TypeHandle pTypeHnd, INT32 rank, INT32* pLengths, INT32* pBounds, BOOL createFromArrayType, QCall::ObjectHandleOnStack retArray); -extern "C" QCallExceptionStatus QCALLTYPE Array_Ctor(MethodTable* pArrayMT, UINT32 dwNumArgs, INT32* pArgList, QCall::ObjectHandleOnStack retArray); +extern "C" PCODE QCALLTYPE Array_GetElementConstructorEntrypoint(QCall::TypeHandle pArrayTypeHnd, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE Array_CreateInstance(QCall::TypeHandle pTypeHnd, INT32 rank, INT32* pLengths, INT32* pBounds, BOOL createFromArrayType, QCall::ObjectHandleOnStack retArray, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE Array_Ctor(MethodTable* pArrayMT, UINT32 dwNumArgs, INT32* pArgList, QCall::ObjectHandleOnStack retArray, QCallExceptionStatus* qcallError); #endif // _ARRAYNATIVE_H_ diff --git a/src/coreclr/vm/assemblynative.cpp b/src/coreclr/vm/assemblynative.cpp index 0f0a988a32e081..e190e0fc631733 100644 --- a/src/coreclr/vm/assemblynative.cpp +++ b/src/coreclr/vm/assemblynative.cpp @@ -31,12 +31,13 @@ #include "../binder/inc/bindertracing.h" #include "../binder/inc/defaultassemblybinder.h" -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_InternalLoad(NativeAssemblyNameParts* pAssemblyNameParts, +extern "C" void QCALLTYPE AssemblyNative_InternalLoad(NativeAssemblyNameParts* pAssemblyNameParts, QCall::ObjectHandleOnStack requestingAssembly, QCall::StackCrawlMarkHandle stackMark, BOOL fThrowOnFileNotFound, QCall::ObjectHandleOnStack assemblyLoadContext, - QCall::ObjectHandleOnStack retAssembly) + QCall::ObjectHandleOnStack retAssembly, + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -187,7 +188,7 @@ Assembly* AssemblyNative::LoadFromPEImage(AssemblyBinder* pBinder, PEImage *pIma return pCurDomain->LoadAssembly(&spec, pPEAssembly, FILE_LOADED); } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_LoadFromPath(INT_PTR ptrNativeAssemblyBinder, LPCWSTR pwzILPath, QCall::ObjectHandleOnStack retLoadedAssembly) +extern "C" void QCALLTYPE AssemblyNative_LoadFromPath(INT_PTR ptrNativeAssemblyBinder, LPCWSTR pwzILPath, QCall::ObjectHandleOnStack retLoadedAssembly, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -236,9 +237,10 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_LoadFromPath(INT_PTR pt } /*static */ -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_LoadFromStream(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrAssemblyArray, +extern "C" void QCALLTYPE AssemblyNative_LoadFromStream(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrAssemblyArray, INT32 cbAssemblyArrayLength, INT_PTR ptrSymbolArray, INT32 cbSymbolArrayLength, - QCall::ObjectHandleOnStack retLoadedAssembly) + QCall::ObjectHandleOnStack retLoadedAssembly, + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -302,7 +304,7 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_LoadFromStream(INT_PTR #ifdef TARGET_WINDOWS /*static */ -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_LoadFromInMemoryModule(INT_PTR ptrNativeAssemblyBinder, INT_PTR hModule, QCall::ObjectHandleOnStack retLoadedAssembly) +extern "C" void QCALLTYPE AssemblyNative_LoadFromInMemoryModule(INT_PTR ptrNativeAssemblyBinder, INT_PTR hModule, QCall::ObjectHandleOnStack retLoadedAssembly, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -336,7 +338,7 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_LoadFromInMemoryModule( } #endif -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetLocation(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString) +extern "C" void QCALLTYPE AssemblyNative_GetLocation(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -349,11 +351,12 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetLocation(QCall::Asse END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetTypeCore(QCall::AssemblyHandle pAssembly, +extern "C" void QCALLTYPE AssemblyNative_GetTypeCore(QCall::AssemblyHandle pAssembly, LPCSTR szTypeName, LPCSTR * rgszNestedTypeNames, int32_t cNestedTypeNamesLength, - QCall::ObjectHandleOnStack retType) + QCall::ObjectHandleOnStack retType, + QCallExceptionStatus* qcallError) { CONTRACTL { @@ -417,11 +420,12 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetTypeCore(QCall::Asse END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetTypeCoreIgnoreCase(QCall::AssemblyHandle assemblyHandle, +extern "C" void QCALLTYPE AssemblyNative_GetTypeCoreIgnoreCase(QCall::AssemblyHandle assemblyHandle, LPCWSTR wszTypeName, LPCWSTR* rgwszNestedTypeNames, int32_t cNestedTypeNamesLength, - QCall::ObjectHandleOnStack retType) + QCall::ObjectHandleOnStack retType, + QCallExceptionStatus* qcallError) { CONTRACTL { @@ -496,7 +500,7 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetTypeCoreIgnoreCase(Q END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetForwardedType(QCall::AssemblyHandle pAssembly, mdToken mdtExternalType, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE AssemblyNative_GetForwardedType(QCall::AssemblyHandle pAssembly, mdToken mdtExternalType, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -539,7 +543,7 @@ FCIMPL1(FC_BOOL_RET, AssemblyNative::GetIsDynamic, Assembly* pAssembly) } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetVersion(QCall::AssemblyHandle pAssembly, INT32* pMajorVersion, INT32* pMinorVersion, INT32*pBuildNumber, INT32* pRevisionNumber) +extern "C" void QCALLTYPE AssemblyNative_GetVersion(QCall::AssemblyHandle pAssembly, INT32* pMajorVersion, INT32* pMinorVersion, INT32*pBuildNumber, INT32* pRevisionNumber, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -557,7 +561,7 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetVersion(QCall::Assem END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetPublicKey(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retPublicKey) +extern "C" void QCALLTYPE AssemblyNative_GetPublicKey(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retPublicKey, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -570,7 +574,7 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetPublicKey(QCall::Ass END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetSimpleName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retSimpleName) +extern "C" void QCALLTYPE AssemblyNative_GetSimpleName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retSimpleName, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -579,7 +583,7 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetSimpleName(QCall::As END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetLocale(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString) +extern "C" void QCALLTYPE AssemblyNative_GetLocale(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -594,14 +598,14 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetLocale(QCall::Assemb END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetCodeBase(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE AssemblyNative_GetCodeBase(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - BOOL ret = TRUE; + BEGIN_QCALL; + StackSString codebase; { @@ -609,47 +613,45 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetCodeBase(QCall::Asse } retString.Set(codebase); - *pReturnValue = ret; - END_QCALL; + + return ret; } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetHashAlgorithm(QCall::AssemblyHandle pAssembly, INT32* pReturnValue) +extern "C" INT32 QCALLTYPE AssemblyNative_GetHashAlgorithm(QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - INT32 retVal=0; - retVal = pAssembly->GetPEAssembly()->GetHashAlgId(); - *pReturnValue = retVal; + BEGIN_QCALL; + retVal = pAssembly->GetPEAssembly()->GetHashAlgId(); END_QCALL; + return retVal; } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetFlags(QCall::AssemblyHandle pAssembly, INT32* pReturnValue) +extern "C" INT32 QCALLTYPE AssemblyNative_GetFlags(QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - INT32 retVal=0; - retVal = pAssembly->GetPEAssembly()->GetFlags(); - *pReturnValue = retVal; + BEGIN_QCALL; + retVal = pAssembly->GetPEAssembly()->GetFlags(); END_QCALL; + return retVal; } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetResource(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, DWORD * length, BYTE ** pReturnValue) +extern "C" BYTE * QCALLTYPE AssemblyNative_GetResource(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, DWORD * length, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - PBYTE pbInMemoryResource = NULL; + BEGIN_QCALL; + if (wszName == NULL) COMPlusThrow(kArgumentNullException, W("ArgumentNull_String")); @@ -666,21 +668,20 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetResource(QCall::Asse &pbInMemoryResource, NULL, NULL, NULL, pAssembly); - // Can return null if resource file is zero-length - - *pReturnValue = pbInMemoryResource; - END_QCALL; + + // Can return null if resource file is zero-length + return pbInMemoryResource; } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetManifestResourceInfo(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, QCall::ObjectHandleOnStack retAssembly, QCall::StringHandleOnStack retFileName, INT32* pReturnValue) +extern "C" INT32 QCALLTYPE AssemblyNative_GetManifestResourceInfo(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, QCall::ObjectHandleOnStack retAssembly, QCall::StringHandleOnStack retFileName, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - INT32 rv = -1; + BEGIN_QCALL; + if (wszName == NULL) COMPlusThrow(kArgumentNullException, W("ArgumentNull_String")); @@ -710,12 +711,12 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetManifestResourceInfo rv = dwLocation; } - *pReturnValue = rv; - END_QCALL; + + return rv; } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetModules(QCall::AssemblyHandle pAssembly, BOOL fLoadIfNotFound, BOOL fGetResourceModules, QCall::ObjectHandleOnStack retModules) +extern "C" void QCALLTYPE AssemblyNative_GetModules(QCall::AssemblyHandle pAssembly, BOOL fLoadIfNotFound, BOOL fGetResourceModules, QCall::ObjectHandleOnStack retModules, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -786,7 +787,7 @@ extern "C" uint32_t QCALLTYPE AssemblyNative_GetAssemblyCount() return g_cAssemblies; } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetModule(QCall::AssemblyHandle pAssembly, LPCWSTR wszFileName, QCall::ObjectHandleOnStack retModule) +extern "C" void QCALLTYPE AssemblyNative_GetModule(QCall::AssemblyHandle pAssembly, LPCWSTR wszFileName, QCall::ObjectHandleOnStack retModule, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -823,7 +824,7 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetModule(QCall::Assemb END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes) +extern "C" void QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -940,7 +941,7 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetExportedTypes(QCall: END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetForwardedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes) +extern "C" void QCALLTYPE AssemblyNative_GetForwardedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1008,7 +1009,7 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetForwardedTypes(QCall END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetManifestResourceNames(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retResourceNames) +extern "C" void QCALLTYPE AssemblyNative_GetManifestResourceNames(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retResourceNames, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1050,7 +1051,7 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetManifestResourceName END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetReferencedAssemblies(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retReferencedAssemblies) +extern "C" void QCALLTYPE AssemblyNative_GetReferencedAssemblies(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retReferencedAssemblies, QCallExceptionStatus* qcallError) { BEGIN_QCALL; @@ -1096,7 +1097,7 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetReferencedAssemblies END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetEntryPoint(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retMethod) +extern "C" void QCALLTYPE AssemblyNative_GetEntryPoint(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retMethod, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1120,7 +1121,7 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetEntryPoint(QCall::As // // -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetFullName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString) +extern "C" void QCALLTYPE AssemblyNative_GetFullName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1133,7 +1134,7 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetFullName(QCall::Asse END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetExecutingAssembly(QCall::StackCrawlMarkHandle stackMark, QCall::ObjectHandleOnStack retAssembly) +extern "C" void QCALLTYPE AssemblyNative_GetExecutingAssembly(QCall::StackCrawlMarkHandle stackMark, QCall::ObjectHandleOnStack retAssembly, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1149,7 +1150,7 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetExecutingAssembly(QC END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetEntryAssembly(QCall::ObjectHandleOnStack retAssembly) +extern "C" void QCALLTYPE AssemblyNative_GetEntryAssembly(QCall::ObjectHandleOnStack retAssembly, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1165,7 +1166,7 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetEntryAssembly(QCall: END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetImageRuntimeVersion(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString) +extern "C" void QCALLTYPE AssemblyNative_GetImageRuntimeVersion(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1188,14 +1189,14 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetImageRuntimeVersion( /*static*/ -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_InitializeAssemblyLoadContext(INT_PTR ptrAssemblyLoadContext, BOOL fRepresentsTPALoadContext, BOOL fIsCollectible, INT_PTR* pReturnValue) +extern "C" INT_PTR QCALLTYPE AssemblyNative_InitializeAssemblyLoadContext(INT_PTR ptrAssemblyLoadContext, BOOL fRepresentsTPALoadContext, BOOL fIsCollectible, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - INT_PTR ptrNativeAssemblyBinder = 0; + BEGIN_QCALL; + // We do not need to take a lock since this method is invoked from the ctor of AssemblyLoadContext managed type and // only one thread is ever executing a ctor for a given instance. // @@ -1254,13 +1255,13 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_InitializeAssemblyLoadC ptrNativeAssemblyBinder = reinterpret_cast(pDefaultBinder); } - *pReturnValue = ptrNativeAssemblyBinder; - END_QCALL; + + return ptrNativeAssemblyBinder; } /*static*/ -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_PrepareForAssemblyLoadContextRelease(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrManagedStrongAssemblyLoadContext) +extern "C" void QCALLTYPE AssemblyNative_PrepareForAssemblyLoadContextRelease(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrManagedStrongAssemblyLoadContext, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1268,7 +1269,6 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_PrepareForAssemblyLoadC BEGIN_QCALL; - { GCX_COOP(); reinterpret_cast(ptrNativeAssemblyBinder)->PrepareForLoadContextRelease(ptrManagedStrongAssemblyLoadContext); @@ -1278,14 +1278,14 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_PrepareForAssemblyLoadC } /*static*/ -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetLoadContextForAssembly(QCall::AssemblyHandle pAssembly, INT_PTR* pReturnValue) +extern "C" INT_PTR QCALLTYPE AssemblyNative_GetLoadContextForAssembly(QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - INT_PTR ptrAssemblyLoadContext = 0; + BEGIN_QCALL; + _ASSERTE(pAssembly != NULL); AssemblyBinder* pAssemblyBinder = pAssembly->GetPEAssembly()->GetAssemblyBinder(); @@ -1297,24 +1297,24 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetLoadContextForAssemb _ASSERTE(ptrAssemblyLoadContext != (INT_PTR)NULL); } - *pReturnValue = ptrAssemblyLoadContext; - END_QCALL; + + return ptrAssemblyLoadContext; } // static -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_InternalTryGetRawMetadata( +extern "C" BOOL QCALLTYPE AssemblyNative_InternalTryGetRawMetadata( QCall::AssemblyHandle assembly, UINT8 **blobRef, INT32 *lengthRef, - BOOL* pReturnValue) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - PTR_CVOID metadata = nullptr; + BEGIN_QCALL; + _ASSERTE(assembly != nullptr); _ASSERTE(blobRef != nullptr); _ASSERTE(lengthRef != nullptr); @@ -1324,9 +1324,9 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_InternalTryGetRawMetada *blobRef = reinterpret_cast(const_cast(metadata)); _ASSERTE(*lengthRef >= 0); - *pReturnValue = metadata != nullptr; - END_QCALL; + + return metadata != nullptr; } // static @@ -1339,7 +1339,7 @@ FCIMPL0(FC_BOOL_RET, AssemblyNative::IsTracingEnabled) FCIMPLEND // static -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_TraceResolvingHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR alcName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath) +extern "C" void QCALLTYPE AssemblyNative_TraceResolvingHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR alcName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1351,7 +1351,7 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_TraceResolvingHandlerIn } // static -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_TraceAssemblyResolveHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath) +extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyResolveHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1363,7 +1363,7 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_TraceAssemblyResolveHan } // static -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_TraceAssemblyLoadFromResolveHandlerInvoked(LPCWSTR assemblyName, BOOL isTrackedAssembly, LPCWSTR requestingAssemblyPath, LPCWSTR requestedAssemblyPath) +extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyLoadFromResolveHandlerInvoked(LPCWSTR assemblyName, BOOL isTrackedAssembly, LPCWSTR requestingAssemblyPath, LPCWSTR requestedAssemblyPath, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1375,7 +1375,7 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_TraceAssemblyLoadFromRe } // static -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_TraceSatelliteSubdirectoryPathProbed(LPCWSTR filePath, HRESULT hr) +extern "C" void QCALLTYPE AssemblyNative_TraceSatelliteSubdirectoryPathProbed(LPCWSTR filePath, HRESULT hr, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1387,14 +1387,15 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_TraceSatelliteSubdirect } // static -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_ApplyUpdate( +extern "C" void QCALLTYPE AssemblyNative_ApplyUpdate( QCall::AssemblyHandle assembly, UINT8* metadataDelta, INT32 metadataDeltaLength, UINT8* ilDelta, INT32 ilDeltaLength, UINT8* pdbDelta, - INT32 pdbDeltaLength) + INT32 pdbDeltaLength, + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1432,22 +1433,22 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_ApplyUpdate( } // static -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_IsApplyUpdateSupported(BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE AssemblyNative_IsApplyUpdateSupported(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - BOOL result = false; + BEGIN_QCALL; + #ifdef FEATURE_METADATA_UPDATER result = (g_pConfig->ModifiableAssemblies() != MODIFIABLE_ASSM_NONE) && (CORDebuggerAttached() || g_pConfig->ModifiableAssemblies() == MODIFIABLE_ASSM_DEBUG); #endif - *pReturnValue = result; - END_QCALL; + + return result; } namespace @@ -1705,14 +1706,15 @@ namespace }; } -extern "C" QCallExceptionStatus QCALLTYPE TypeMapLazyDictionary_ProcessAttributes( +extern "C" void QCALLTYPE TypeMapLazyDictionary_ProcessAttributes( QCall::AssemblyHandle pAssembly, QCall::TypeHandle pGroupType, BOOL (*newExternalTypeEntry)(CallbackContext* context, ProcessAttributesCallbackArg* arg), BOOL (*newProxyTypeEntry)(CallbackContext* context, ProcessAttributesCallbackArg* arg), BOOL (*newPrecachedExternalTypeMap)(CallbackContext* context), BOOL (*newPrecachedProxyTypeMap)(CallbackContext* context), - CallbackContext* context) + CallbackContext* context, + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(pAssembly != NULL); @@ -1836,11 +1838,11 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeMapLazyDictionary_ProcessAttribute END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE TypeMapLazyDictionary_FindPrecachedExternalTypeMapEntry( +extern "C" TADDR QCALLTYPE TypeMapLazyDictionary_FindPrecachedExternalTypeMapEntry( QCall::ModuleHandle pModule, QCall::TypeHandle pGroupType, LPCUTF8 key, - TADDR* pReturnValue) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(pModule != NULL); @@ -1865,16 +1867,16 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeMapLazyDictionary_FindPrecachedExt } #endif // FEATURE_READYTORUN - *pReturnValue = resultTypeHnd.AsTAddr(); - END_QCALL; + + return resultTypeHnd.AsTAddr(); } -extern "C" QCallExceptionStatus QCALLTYPE TypeMapLazyDictionary_FindPrecachedProxyTypeMapEntry( +extern "C" TADDR QCALLTYPE TypeMapLazyDictionary_FindPrecachedProxyTypeMapEntry( QCall::ModuleHandle pModule, QCall::TypeHandle pGroupType, QCall::TypeHandle pType, - TADDR* pReturnValue) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(pModule != NULL); @@ -1899,7 +1901,7 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeMapLazyDictionary_FindPrecachedPro } #endif // FEATURE_READYTORUN - *pReturnValue = resultTypeHnd.AsTAddr(); - END_QCALL; + + return resultTypeHnd.AsTAddr(); } diff --git a/src/coreclr/vm/assemblynative.hpp b/src/coreclr/vm/assemblynative.hpp index 2e94e50a762550..0ea20803c8a68b 100644 --- a/src/coreclr/vm/assemblynative.hpp +++ b/src/coreclr/vm/assemblynative.hpp @@ -37,111 +37,111 @@ class AssemblyNative extern "C" uint32_t QCALLTYPE AssemblyNative_GetAssemblyCount(); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetEntryAssembly(QCall::ObjectHandleOnStack retAssembly); +extern "C" void QCALLTYPE AssemblyNative_GetEntryAssembly(QCall::ObjectHandleOnStack retAssembly, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetExecutingAssembly(QCall::StackCrawlMarkHandle stackMark, QCall::ObjectHandleOnStack retAssembly); +extern "C" void QCALLTYPE AssemblyNative_GetExecutingAssembly(QCall::StackCrawlMarkHandle stackMark, QCall::ObjectHandleOnStack retAssembly, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetLocale(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString); +extern "C" void QCALLTYPE AssemblyNative_GetLocale(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetHashAlgorithm(QCall::AssemblyHandle pAssembly, INT32* pReturnValue); +extern "C" INT32 QCALLTYPE AssemblyNative_GetHashAlgorithm(QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetSimpleName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retSimpleName); +extern "C" void QCALLTYPE AssemblyNative_GetSimpleName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retSimpleName, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetPublicKey(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retPublicKey); +extern "C" void QCALLTYPE AssemblyNative_GetPublicKey(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retPublicKey, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetFlags(QCall::AssemblyHandle pAssembly, INT32* pReturnValue); +extern "C" INT32 QCALLTYPE AssemblyNative_GetFlags(QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetFullName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString); +extern "C" void QCALLTYPE AssemblyNative_GetFullName(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetLocation(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString); +extern "C" void QCALLTYPE AssemblyNative_GetLocation(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetCodeBase(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, BOOL* pReturnValue); +extern "C" BOOL QCALLTYPE AssemblyNative_GetCodeBase(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetResource(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, DWORD * length, BYTE ** pReturnValue); +extern "C" BYTE * QCALLTYPE AssemblyNative_GetResource(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, DWORD * length, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetVersion(QCall::AssemblyHandle pAssembly, INT32* pMajorVersion, INT32* pMinorVersion, INT32*pBuildNumber, INT32* pRevisionNumber); +extern "C" void QCALLTYPE AssemblyNative_GetVersion(QCall::AssemblyHandle pAssembly, INT32* pMajorVersion, INT32* pMinorVersion, INT32*pBuildNumber, INT32* pRevisionNumber, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetTypeCore(QCall::AssemblyHandle pAssembly, LPCSTR szTypeName, LPCSTR* rgszNestedTypeNames, int32_t cNestedTypeNamesLength, QCall::ObjectHandleOnStack retType); +extern "C" void QCALLTYPE AssemblyNative_GetTypeCore(QCall::AssemblyHandle pAssembly, LPCSTR szTypeName, LPCSTR* rgszNestedTypeNames, int32_t cNestedTypeNamesLength, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetTypeCoreIgnoreCase(QCall::AssemblyHandle pAssembly, LPCWSTR wszTypeName, LPCWSTR* rgwszNestedTypeNames, int32_t cNestedTypeNamesLength, QCall::ObjectHandleOnStack retType); +extern "C" void QCALLTYPE AssemblyNative_GetTypeCoreIgnoreCase(QCall::AssemblyHandle pAssembly, LPCWSTR wszTypeName, LPCWSTR* rgwszNestedTypeNames, int32_t cNestedTypeNamesLength, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetForwardedType(QCall::AssemblyHandle pAssembly, mdToken mdtExternalType, QCall::ObjectHandleOnStack retType); +extern "C" void QCALLTYPE AssemblyNative_GetForwardedType(QCall::AssemblyHandle pAssembly, mdToken mdtExternalType, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetManifestResourceInfo(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, QCall::ObjectHandleOnStack retAssembly, QCall::StringHandleOnStack retFileName, INT32* pReturnValue); +extern "C" INT32 QCALLTYPE AssemblyNative_GetManifestResourceInfo(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, QCall::ObjectHandleOnStack retAssembly, QCall::StringHandleOnStack retFileName, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetModules(QCall::AssemblyHandle pAssembly, BOOL fLoadIfNotFound, BOOL fGetResourceModules, QCall::ObjectHandleOnStack retModules); +extern "C" void QCALLTYPE AssemblyNative_GetModules(QCall::AssemblyHandle pAssembly, BOOL fLoadIfNotFound, BOOL fGetResourceModules, QCall::ObjectHandleOnStack retModules, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetModule(QCall::AssemblyHandle pAssembly, LPCWSTR wszFileName, QCall::ObjectHandleOnStack retModule); +extern "C" void QCALLTYPE AssemblyNative_GetModule(QCall::AssemblyHandle pAssembly, LPCWSTR wszFileName, QCall::ObjectHandleOnStack retModule, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes); +extern "C" void QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetForwardedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes); +extern "C" void QCALLTYPE AssemblyNative_GetForwardedTypes(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retTypes, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetManifestResourceNames(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retResourceNames); +extern "C" void QCALLTYPE AssemblyNative_GetManifestResourceNames(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retResourceNames, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetReferencedAssemblies(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retReferencedAssemblies); +extern "C" void QCALLTYPE AssemblyNative_GetReferencedAssemblies(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retReferencedAssemblies, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetEntryPoint(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retMethod); +extern "C" void QCALLTYPE AssemblyNative_GetEntryPoint(QCall::AssemblyHandle pAssembly, QCall::ObjectHandleOnStack retMethod, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetImageRuntimeVersion(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString); +extern "C" void QCALLTYPE AssemblyNative_GetImageRuntimeVersion(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_InitializeAssemblyLoadContext(INT_PTR ptrAssemblyLoadContext, BOOL fRepresentsTPALoadContext, BOOL fIsCollectible, INT_PTR* pReturnValue); +extern "C" INT_PTR QCALLTYPE AssemblyNative_InitializeAssemblyLoadContext(INT_PTR ptrAssemblyLoadContext, BOOL fRepresentsTPALoadContext, BOOL fIsCollectible, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_PrepareForAssemblyLoadContextRelease(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrManagedStrongAssemblyLoadContext); +extern "C" void QCALLTYPE AssemblyNative_PrepareForAssemblyLoadContextRelease(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrManagedStrongAssemblyLoadContext, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_InternalLoad(NativeAssemblyNameParts* pAssemblyName, QCall::ObjectHandleOnStack requestingAssembly, QCall::StackCrawlMarkHandle stackMark,BOOL fThrowOnFileNotFound, QCall::ObjectHandleOnStack assemblyLoadContext, QCall::ObjectHandleOnStack retAssembly); +extern "C" void QCALLTYPE AssemblyNative_InternalLoad(NativeAssemblyNameParts* pAssemblyName, QCall::ObjectHandleOnStack requestingAssembly, QCall::StackCrawlMarkHandle stackMark,BOOL fThrowOnFileNotFound, QCall::ObjectHandleOnStack assemblyLoadContext, QCall::ObjectHandleOnStack retAssembly, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_LoadFromPath(INT_PTR ptrNativeAssemblyBinder, LPCWSTR pwzILPath, QCall::ObjectHandleOnStack retLoadedAssembly); +extern "C" void QCALLTYPE AssemblyNative_LoadFromPath(INT_PTR ptrNativeAssemblyBinder, LPCWSTR pwzILPath, QCall::ObjectHandleOnStack retLoadedAssembly, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_LoadFromStream(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrAssemblyArray, INT32 cbAssemblyArrayLength, INT_PTR ptrSymbolArray, INT32 cbSymbolArrayLength, QCall::ObjectHandleOnStack retLoadedAssembly); +extern "C" void QCALLTYPE AssemblyNative_LoadFromStream(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrAssemblyArray, INT32 cbAssemblyArrayLength, INT_PTR ptrSymbolArray, INT32 cbSymbolArrayLength, QCall::ObjectHandleOnStack retLoadedAssembly, QCallExceptionStatus* qcallError); #ifdef TARGET_WINDOWS -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_LoadFromInMemoryModule(INT_PTR ptrNativeAssemblyBinder, INT_PTR hModule, QCall::ObjectHandleOnStack retLoadedAssembly); +extern "C" void QCALLTYPE AssemblyNative_LoadFromInMemoryModule(INT_PTR ptrNativeAssemblyBinder, INT_PTR hModule, QCall::ObjectHandleOnStack retLoadedAssembly, QCallExceptionStatus* qcallError); #endif -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_GetLoadContextForAssembly(QCall::AssemblyHandle pAssembly, INT_PTR* pReturnValue); +extern "C" INT_PTR QCALLTYPE AssemblyNative_GetLoadContextForAssembly(QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_InternalTryGetRawMetadata(QCall::AssemblyHandle assembly, UINT8 **blobRef, INT32 *lengthRef, BOOL* pReturnValue); +extern "C" BOOL QCALLTYPE AssemblyNative_InternalTryGetRawMetadata(QCall::AssemblyHandle assembly, UINT8 **blobRef, INT32 *lengthRef, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_TraceResolvingHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR alcName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath); +extern "C" void QCALLTYPE AssemblyNative_TraceResolvingHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR alcName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_TraceAssemblyResolveHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath); +extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyResolveHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_TraceAssemblyLoadFromResolveHandlerInvoked(LPCWSTR assemblyName, BOOL isTrackedAssembly, LPCWSTR requestingAssemblyPath, LPCWSTR requestedAssemblyPath); +extern "C" void QCALLTYPE AssemblyNative_TraceAssemblyLoadFromResolveHandlerInvoked(LPCWSTR assemblyName, BOOL isTrackedAssembly, LPCWSTR requestingAssemblyPath, LPCWSTR requestedAssemblyPath, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_TraceSatelliteSubdirectoryPathProbed(LPCWSTR filePath, HRESULT hr); +extern "C" void QCALLTYPE AssemblyNative_TraceSatelliteSubdirectoryPathProbed(LPCWSTR filePath, HRESULT hr, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_ApplyUpdate(QCall::AssemblyHandle assembly, UINT8* metadataDelta, INT32 metadataDeltaLength, UINT8* ilDelta, INT32 ilDeltaLength, UINT8* pdbDelta, INT32 pdbDeltaLength); +extern "C" void QCALLTYPE AssemblyNative_ApplyUpdate(QCall::AssemblyHandle assembly, UINT8* metadataDelta, INT32 metadataDeltaLength, UINT8* ilDelta, INT32 ilDeltaLength, UINT8* pdbDelta, INT32 pdbDeltaLength, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyNative_IsApplyUpdateSupported(BOOL* pReturnValue); +extern "C" BOOL QCALLTYPE AssemblyNative_IsApplyUpdateSupported(QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AssemblyName_InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, BaseAssemblySpec* pAssemblySpec); +extern "C" void QCALLTYPE AssemblyName_InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, BaseAssemblySpec* pAssemblySpec, QCallExceptionStatus* qcallError); // See TypeMapLazyDictionary.cs for managed version. struct CallbackContext final @@ -162,23 +162,25 @@ struct ProcessAttributesCallbackArg final int32_t StringLen2; }; -extern "C" QCallExceptionStatus QCALLTYPE TypeMapLazyDictionary_ProcessAttributes( +extern "C" void QCALLTYPE TypeMapLazyDictionary_ProcessAttributes( QCall::AssemblyHandle pAssembly, QCall::TypeHandle pTypeGroup, BOOL (*newExternalTypeEntry)(CallbackContext* context, ProcessAttributesCallbackArg* arg), BOOL (*newProxyTypeEntry)(CallbackContext* context, ProcessAttributesCallbackArg* arg), BOOL (*newPrecachedExternalTypeMap)(CallbackContext* context), BOOL (*newPrecachedProxyTypeMap)(CallbackContext* context), - CallbackContext* context); + CallbackContext* context, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE TypeMapLazyDictionary_FindPrecachedExternalTypeMapEntry( +extern "C" TADDR QCALLTYPE TypeMapLazyDictionary_FindPrecachedExternalTypeMapEntry( QCall::ModuleHandle pModule, QCall::TypeHandle pGroupType, - LPCUTF8 key, TADDR* pReturnValue); + LPCUTF8 key +, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE TypeMapLazyDictionary_FindPrecachedProxyTypeMapEntry( +extern "C" TADDR QCALLTYPE TypeMapLazyDictionary_FindPrecachedProxyTypeMapEntry( QCall::ModuleHandle pModule, QCall::TypeHandle pGroupType, - QCall::TypeHandle pType, TADDR* pReturnValue); + QCall::TypeHandle pType +, QCallExceptionStatus* qcallError); #endif diff --git a/src/coreclr/vm/clrconfignative.cpp b/src/coreclr/vm/clrconfignative.cpp index a15e2cb0f0cbaa..dc15ba957a611f 100644 --- a/src/coreclr/vm/clrconfignative.cpp +++ b/src/coreclr/vm/clrconfignative.cpp @@ -8,21 +8,20 @@ #include "clrconfignative.h" #include -extern "C" QCallExceptionStatus QCALLTYPE ClrConfig_GetConfigBoolValue(LPCWSTR name, BOOL *exist, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE ClrConfig_GetConfigBoolValue(LPCWSTR name, BOOL *exist, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; *exist = FALSE; - BEGIN_QCALL; - BOOL retValue = FALSE; + BEGIN_QCALL; + if (Configuration::GetKnobStringValue(name) != nullptr) { *exist = TRUE; retValue = Configuration::GetKnobBooleanValue(name, FALSE); } - *pReturnValue = (retValue); - END_QCALL; + return(retValue); } diff --git a/src/coreclr/vm/clrconfignative.h b/src/coreclr/vm/clrconfignative.h index 5597f1744ecd7c..d363a2745e9e3c 100644 --- a/src/coreclr/vm/clrconfignative.h +++ b/src/coreclr/vm/clrconfignative.h @@ -4,5 +4,5 @@ #ifndef _CLRCONFIGNATIVE_H_ #define _CLRCONFIGNATIVE_H_ -extern "C" QCallExceptionStatus QCALLTYPE ClrConfig_GetConfigBoolValue(LPCWSTR name, BOOL *exist, BOOL* pReturnValue); +extern "C" BOOL QCALLTYPE ClrConfig_GetConfigBoolValue(LPCWSTR name, BOOL *exist, QCallExceptionStatus* qcallError); #endif // _CLRCONFIGNATIVE_H_ diff --git a/src/coreclr/vm/comdelegate.cpp b/src/coreclr/vm/comdelegate.cpp index 2cddb86433b53c..00e41198d7ad95 100644 --- a/src/coreclr/vm/comdelegate.cpp +++ b/src/coreclr/vm/comdelegate.cpp @@ -937,8 +937,9 @@ static PCODE GetVirtualCallStub(MethodDesc *method, TypeHandle scopeType) ); } -extern "C" QCallExceptionStatus QCALLTYPE Delegate_BindToMethodName(MethodTable* pDelegateMT, MethodTable *pTargetMT, - QCall::TypeHandle pMethodType, LPCUTF8 pszMethodName, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE Delegate_BindToMethodName(MethodTable* pDelegateMT, MethodTable *pTargetMT, + QCall::TypeHandle pMethodType, LPCUTF8 pszMethodName, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -946,7 +947,6 @@ extern "C" QCallExceptionStatus QCALLTYPE Delegate_BindToMethodName(MethodTable* BEGIN_QCALL; - TypeHandle methodType = pMethodType.AsTypeHandle(); // get the invoke of the delegate @@ -1037,20 +1037,21 @@ extern "C" QCallExceptionStatus QCALLTYPE Delegate_BindToMethodName(MethodTable* ; - *pReturnValue = pMatchingMethod != NULL; - END_QCALL; + + return pMatchingMethod != NULL; } -extern "C" QCallExceptionStatus QCALLTYPE Delegate_BindToMethodInfo(MethodTable* pDelegateMT, MethodTable *pTargetMT, - MethodDesc * method, QCall::TypeHandle pMethodType, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE Delegate_BindToMethodInfo(MethodTable* pDelegateMT, MethodTable *pTargetMT, + MethodDesc * method, QCall::TypeHandle pMethodType, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - BOOL result = TRUE; + BEGIN_QCALL; + MethodTable *pMethMT = pMethodType.AsTypeHandle().GetMethodTable(); // A generic method had better be instantiated (we can't dispatch to an uninstantiated one). @@ -1095,9 +1096,9 @@ extern "C" QCallExceptionStatus QCALLTYPE Delegate_BindToMethodInfo(MethodTable* result = FALSE; } - *pReturnValue = result; - END_QCALL; + + return result; } // This method is called (in the late bound case only) once a target method has been decided on. All the consistency checks @@ -1492,7 +1493,7 @@ MethodDesc* COMDelegate::GetILStubMethodDesc(EEImplMethodDesc* pDelegateMD, DWOR return PInvoke::CreateCLRToNativeILStub(&sigInfo, dwStubFlags, pDelegateMD); } -extern "C" QCallExceptionStatus QCALLTYPE Delegate_InitializeVirtualCallStub(QCall::ObjectHandleOnStack d, PCODE method) +extern "C" void QCALLTYPE Delegate_InitializeVirtualCallStub(QCall::ObjectHandleOnStack d, PCODE method, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1512,7 +1513,7 @@ extern "C" QCallExceptionStatus QCALLTYPE Delegate_InitializeVirtualCallStub(QCa END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE Delegate_AdjustTarget(MethodTable* pMTTarg, PCODE method, PCODE* pReturnValue) +extern "C" PCODE QCALLTYPE Delegate_AdjustTarget(MethodTable* pMTTarg, PCODE method, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1543,9 +1544,9 @@ extern "C" QCallExceptionStatus QCALLTYPE Delegate_AdjustTarget(MethodTable* pMT method = pCorrectedMethod->GetMultiCallableAddrOfCode(); } - *pReturnValue = method; - END_QCALL; + + return method; } uint32_t MethodDescToNumFixedArgs(MethodDesc *pMD) @@ -1570,7 +1571,7 @@ uint32_t MethodDescToNumFixedArgs(MethodDesc *pMD) // This is the single constructor for all Delegates. The compiler // doesn't provide an implementation of the Delegate constructor. We // provide that implementation through a QCall call to this method. -extern "C" QCallExceptionStatus QCALLTYPE Delegate_Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, PCODE method, BindToMethodDetails *pBindToMethodDetails) +extern "C" void QCALLTYPE Delegate_Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, PCODE method, BindToMethodDetails *pBindToMethodDetails, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1873,7 +1874,7 @@ void COMDelegate::ThrowIfInvalidUnmanagedCallersOnlyUsage(MethodDesc* pMD) } // This method will get the MethodInfo for a delegate -extern "C" QCallExceptionStatus QCALLTYPE Delegate_CreateMethodInfo(MethodDesc* methodDesc, QCall::ObjectHandleOnStack retMethodInfo) +extern "C" void QCALLTYPE Delegate_CreateMethodInfo(MethodDesc* methodDesc, QCall::ObjectHandleOnStack retMethodInfo, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1888,21 +1889,21 @@ extern "C" QCallExceptionStatus QCALLTYPE Delegate_CreateMethodInfo(MethodDesc* END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE Delegate_GetMethodDesc(QCall::ObjectHandleOnStack instance, MethodDesc** pReturnValue) +extern "C" MethodDesc* QCALLTYPE Delegate_GetMethodDesc(QCall::ObjectHandleOnStack instance, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - MethodDesc* pMD = nullptr; + BEGIN_QCALL; + GCX_COOP(); pMD = COMDelegate::GetMethodDesc(instance.Get()); - *pReturnValue = pMD; - END_QCALL; + + return pMD; } FCIMPL1(MethodDesc*, COMDelegate::GetInvokeMethod, MethodTable* pDelegateMT) @@ -1926,15 +1927,15 @@ FCIMPL1(PCODE, COMDelegate::GetMulticastInvoke, MethodTable* pDelegateMT) } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE Delegate_GetMulticastInvokeSlow(MethodTable* pDelegateMT, PCODE* pReturnValue) +extern "C" PCODE QCALLTYPE Delegate_GetMulticastInvokeSlow(MethodTable* pDelegateMT, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(pDelegateMT != NULL); - BEGIN_QCALL; - PCODE pStub = (PCODE)NULL; + BEGIN_QCALL; + DelegateEEClass *delegateEEClass = (DelegateEEClass*)pDelegateMT->GetClass(); pStub = delegateEEClass->m_pMultiCastInvokeStub; if (pStub == (PCODE)NULL) @@ -2046,9 +2047,9 @@ extern "C" QCallExceptionStatus QCALLTYPE Delegate_GetMulticastInvokeSlow(Method pStub = delegateEEClass->m_pMultiCastInvokeStub; } - *pReturnValue = pStub; - END_QCALL; + + return pStub; } static bool IsLocationAssignable(TypeHandle fromHandle, TypeHandle toHandle, bool relaxedMatch, bool fromHandleIsBoxed) diff --git a/src/coreclr/vm/comdelegate.h b/src/coreclr/vm/comdelegate.h index 8a515fa407b941..b3b7e8120fc64b 100644 --- a/src/coreclr/vm/comdelegate.h +++ b/src/coreclr/vm/comdelegate.h @@ -92,13 +92,13 @@ class COMDelegate BindToMethodDetails *pBindToMethodDetails); }; -extern "C" QCallExceptionStatus QCALLTYPE Delegate_Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, PCODE method, BindToMethodDetails *pBindToMethodDetails); +extern "C" void QCALLTYPE Delegate_Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, PCODE method, BindToMethodDetails *pBindToMethodDetails, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE Delegate_GetMulticastInvokeSlow(MethodTable* pDelegateMT, PCODE* pReturnValue); +extern "C" PCODE QCALLTYPE Delegate_GetMulticastInvokeSlow(MethodTable* pDelegateMT, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE Delegate_AdjustTarget(MethodTable* pMTTarg, PCODE method, PCODE* pReturnValue); +extern "C" PCODE QCALLTYPE Delegate_AdjustTarget(MethodTable* pMTTarg, PCODE method, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE Delegate_InitializeVirtualCallStub(QCall::ObjectHandleOnStack d, PCODE method); +extern "C" void QCALLTYPE Delegate_InitializeVirtualCallStub(QCall::ObjectHandleOnStack d, PCODE method, QCallExceptionStatus* qcallError); // These flags effect the way BindToMethodInfo and BindToMethodName are allowed to bind a delegate to a target method. Their // values must be kept in sync with the definition in bcl\system\delegate.cs. @@ -113,15 +113,17 @@ enum DelegateBindingFlags DBF_RelaxedSignature = 0x00000040, // Allow relaxed signature matching (co/contra variance) }; -extern "C" QCallExceptionStatus QCALLTYPE Delegate_BindToMethodName(MethodTable* pDelegateMT, MethodTable *pTargetMT, - QCall::TypeHandle pMethodType, LPCUTF8 pszMethodName, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, BOOL* pReturnValue); +extern "C" BOOL QCALLTYPE Delegate_BindToMethodName(MethodTable* pDelegateMT, MethodTable *pTargetMT, + QCall::TypeHandle pMethodType, LPCUTF8 pszMethodName, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE Delegate_BindToMethodInfo(MethodTable* pDelegateMT, MethodTable *pTargetMT, - MethodDesc * method, QCall::TypeHandle pMethodType, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, BOOL* pReturnValue); +extern "C" BOOL QCALLTYPE Delegate_BindToMethodInfo(MethodTable* pDelegateMT, MethodTable *pTargetMT, + MethodDesc * method, QCall::TypeHandle pMethodType, DelegateBindingFlags flags, QCall::ObjectHandleOnStack targetParameter, BindToMethodDetails *pBindToMethodDetails, + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE Delegate_CreateMethodInfo(MethodDesc* methodDesc, QCall::ObjectHandleOnStack retMethodInfo); +extern "C" void QCALLTYPE Delegate_CreateMethodInfo(MethodDesc* methodDesc, QCall::ObjectHandleOnStack retMethodInfo, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE Delegate_GetMethodDesc(QCall::ObjectHandleOnStack instance, MethodDesc** pReturnValue); +extern "C" MethodDesc* QCALLTYPE Delegate_GetMethodDesc(QCall::ObjectHandleOnStack instance, QCallExceptionStatus* qcallError); void DistributeEvent(OBJECTREF *pDelegate, OBJECTREF *pDomain); diff --git a/src/coreclr/vm/comdependenthandle.cpp b/src/coreclr/vm/comdependenthandle.cpp index b6a5e0bd9ebbc5..c2b18b039910b4 100644 --- a/src/coreclr/vm/comdependenthandle.cpp +++ b/src/coreclr/vm/comdependenthandle.cpp @@ -26,20 +26,20 @@ FCIMPL2(OBJECTHANDLE, DependentHandle::InternalAlloc, Object *target, Object *de } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE DependentHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack target, QCall::ObjectHandleOnStack dependent, OBJECTHANDLE* pReturnValue) +extern "C" OBJECTHANDLE QCALLTYPE DependentHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack target, QCall::ObjectHandleOnStack dependent, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - OBJECTHANDLE result = NULL; + BEGIN_QCALL; + GCX_COOP(); result = GetAppDomain()->CreateDependentHandle(target.Get(), dependent.Get()); - *pReturnValue = result; - END_QCALL; + + return result; } FCIMPL1(Object*, DependentHandle::InternalGetTarget, OBJECTHANDLE handle) @@ -122,7 +122,7 @@ FCIMPL1(FC_BOOL_RET, DependentHandle::InternalFree, OBJECTHANDLE handle) } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE DependentHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle) +extern "C" void QCALLTYPE DependentHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/comdependenthandle.h b/src/coreclr/vm/comdependenthandle.h index 8bc950199db7cf..ec47f3368d4167 100644 --- a/src/coreclr/vm/comdependenthandle.h +++ b/src/coreclr/vm/comdependenthandle.h @@ -49,7 +49,7 @@ class DependentHandle FCDECL1(static FC_BOOL_RET, InternalFree, OBJECTHANDLE handle); }; -extern "C" QCallExceptionStatus QCALLTYPE DependentHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack target, QCall::ObjectHandleOnStack dependent, OBJECTHANDLE* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE DependentHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle); +extern "C" OBJECTHANDLE QCALLTYPE DependentHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack target, QCall::ObjectHandleOnStack dependent, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE DependentHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle, QCallExceptionStatus* qcallError); #endif diff --git a/src/coreclr/vm/comdynamic.cpp b/src/coreclr/vm/comdynamic.cpp index c9978507ebaf9b..a951046046d49c 100644 --- a/src/coreclr/vm/comdynamic.cpp +++ b/src/coreclr/vm/comdynamic.cpp @@ -37,50 +37,50 @@ struct ExceptionInstance { // Defining a type into metadata of this dynamic module // //************************************************************* -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineGenericParam(QCall::ModuleHandle pModule, +extern "C" INT32 QCALLTYPE TypeBuilder_DefineGenericParam(QCall::ModuleHandle pModule, LPCWSTR wszFullName, INT32 tkParent, INT32 attributes, INT32 position, INT32 * pConstraintTokens, - INT32* pReturnValue) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - mdTypeDef classE = mdTokenNil; + BEGIN_QCALL; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); IfFailThrow(pRCW->GetEmitter()->DefineGenericParam( tkParent, position, attributes, wszFullName, 0, (mdToken *)pConstraintTokens, &classE)); - *pReturnValue = (INT32)classE; - END_QCALL; + + return (INT32)classE; } -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineType(QCall::ModuleHandle pModule, +extern "C" INT32 QCALLTYPE TypeBuilder_DefineType(QCall::ModuleHandle pModule, LPCWSTR wszFullName, INT32 tkParent, INT32 attributes, INT32 tkEnclosingType, INT32 * pInterfaceTokens, - INT32* pReturnValue) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - int classE = mdTokenNil; - classE = COMDynamicWrite::DefineType(pModule, wszFullName, tkParent, attributes, tkEnclosingType, pInterfaceTokens); + BEGIN_QCALL; - *pReturnValue = (INT32)classE; + classE = COMDynamicWrite::DefineType(pModule, wszFullName, tkParent, attributes, tkEnclosingType, pInterfaceTokens); END_QCALL; + + return (INT32)classE; } INT32 COMDynamicWrite::DefineType(Module* pModule, @@ -139,7 +139,7 @@ INT32 COMDynamicWrite::DefineType(Module* pModule, } // This function will reset the parent class in metadata -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetParentType(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkParent) +extern "C" void QCALLTYPE TypeBuilder_SetParentType(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkParent, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -154,7 +154,7 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetParentType(QCall::Modul } // This function will add another interface impl -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_AddInterfaceImpl(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkInterface) +extern "C" void QCALLTYPE TypeBuilder_AddInterfaceImpl(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkInterface, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -169,14 +169,14 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_AddInterfaceImpl(QCall::Mo } // This function will create a method within the class -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineMethodSpec(QCall::ModuleHandle pModule, INT32 tkParent, LPCBYTE pSignature, INT32 sigLength, INT32* pReturnValue) +extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethodSpec(QCall::ModuleHandle pModule, INT32 tkParent, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - mdMethodDef memberE = mdTokenNil; + BEGIN_QCALL; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); @@ -186,19 +186,19 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineMethodSpec(QCall::Mo sigLength, //Size of the signature blob &memberE) ); //[OUT]methodToken - *pReturnValue = (INT32) memberE; - END_QCALL; + + return (INT32) memberE; } -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineMethod(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attributes, INT32* pReturnValue) +extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethod(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attributes, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - mdMethodDef memberE = mdTokenNil; + BEGIN_QCALL; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); @@ -212,9 +212,9 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineMethod(QCall::Module miIL | miManaged, //Implementation Flags is default to managed IL &memberE) ); //[OUT]methodToken - *pReturnValue = (INT32) memberE; - END_QCALL; + + return (INT32) memberE; } /*================================DefineField================================= @@ -223,14 +223,14 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineMethod(QCall::Module **Arguments: **Exceptions: ==============================================================================*/ -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineField(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attr, mdFieldDef* pReturnValue) +extern "C" mdFieldDef QCALLTYPE TypeBuilder_DefineField(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attr, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - mdFieldDef retVal = mdTokenNil; + BEGIN_QCALL; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); @@ -242,9 +242,9 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineField(QCall::ModuleH (ULONG) -1, &retVal) ); - *pReturnValue = retVal; - END_QCALL; + + return retVal; } // This method computes the same result as COR_ILMETHOD_SECT_EH::Size(...) but @@ -297,7 +297,7 @@ UINT32 ExceptionHandlingSize(unsigned uNumExceptions, COR_ILMETHOD_SECT_EH_CLAUS // SetMethodIL -- This function will create a method within the class -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetMethodIL(QCall::ModuleHandle pModule, +extern "C" void QCALLTYPE TypeBuilder_SetMethodIL(QCall::ModuleHandle pModule, INT32 tk, BOOL fIsInitLocal, LPCBYTE pBody, @@ -308,7 +308,8 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetMethodIL(QCall::ModuleH ExceptionInstance * pExceptions, INT32 numExceptions, INT32 * pTokenFixups, - INT32 numTokenFixups) + INT32 numTokenFixups, + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -467,7 +468,7 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetMethodIL(QCall::ModuleH END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_TermCreateClass(QCall::ModuleHandle pModule, INT32 tk, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE TypeBuilder_TermCreateClass(QCall::ModuleHandle pModule, INT32 tk, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -509,7 +510,7 @@ void COMDynamicWrite::TermCreateClass(Module* pModule, INT32 tk, QCall::ObjectHa **Arguments: **Exceptions: ==============================================================================*/ -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetPInvokeData(QCall::ModuleHandle pModule, LPCWSTR wszDllName, LPCWSTR wszFunctionName, INT32 token, INT32 linkFlags) +extern "C" void QCALLTYPE TypeBuilder_SetPInvokeData(QCall::ModuleHandle pModule, LPCWSTR wszDllName, LPCWSTR wszFunctionName, INT32 token, INT32 linkFlags, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -538,14 +539,14 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetPInvokeData(QCall::Modu **Arguments: **Exceptions: ==============================================================================*/ -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineProperty(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, LPCBYTE pSignature, INT32 sigLength, INT32* pReturnValue) +extern "C" INT32 QCALLTYPE TypeBuilder_DefineProperty(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - mdProperty pr = mdTokenNil; + BEGIN_QCALL; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); @@ -564,9 +565,9 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineProperty(QCall::Modu NULL, // no other methods &pr)); - *pReturnValue = (INT32)pr; - END_QCALL; + + return (INT32)pr; } /*============================DefineEvent============================ @@ -575,14 +576,14 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineProperty(QCall::Modu **Arguments: **Exceptions: ==============================================================================*/ -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineEvent(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, INT32 tkEventType, INT32* pReturnValue) +extern "C" INT32 QCALLTYPE TypeBuilder_DefineEvent(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, INT32 tkEventType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - mdProperty ev = mdTokenNil; + BEGIN_QCALL; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); @@ -594,9 +595,9 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineEvent(QCall::ModuleH tkEventType, // the event type. Can be TypeDef or TypeRef &ev)); - *pReturnValue = (INT32)ev; - END_QCALL; + + return (INT32)ev; } /*============================DefineMethodSemantics============================ @@ -605,7 +606,7 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineEvent(QCall::ModuleH **Arguments: **Exceptions: ==============================================================================*/ -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineMethodSemantics(QCall::ModuleHandle pModule, INT32 tkAssociation, INT32 attr, INT32 tkMethod) +extern "C" void QCALLTYPE TypeBuilder_DefineMethodSemantics(QCall::ModuleHandle pModule, INT32 tkAssociation, INT32 attr, INT32 tkMethod, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -626,7 +627,7 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineMethodSemantics(QCal /*============================SetMethodImpl============================ ** To set a Method's Implementation flags ==============================================================================*/ -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetMethodImpl(QCall::ModuleHandle pModule, INT32 tkMethod, INT32 attr) +extern "C" void QCALLTYPE TypeBuilder_SetMethodImpl(QCall::ModuleHandle pModule, INT32 tkMethod, INT32 attr, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -646,7 +647,7 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetMethodImpl(QCall::Modul /*============================DefineMethodImpl============================ ** Define a MethodImpl record ==============================================================================*/ -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineMethodImpl(QCall::ModuleHandle pModule, UINT32 tkType, UINT32 tkBody, UINT32 tkDecl) +extern "C" void QCALLTYPE TypeBuilder_DefineMethodImpl(QCall::ModuleHandle pModule, UINT32 tkType, UINT32 tkBody, UINT32 tkDecl, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -670,14 +671,14 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineMethodImpl(QCall::Mo **Arguments: **Exceptions: ==============================================================================*/ -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_GetTokenFromSig(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, INT32* pReturnValue) +extern "C" INT32 QCALLTYPE TypeBuilder_GetTokenFromSig(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - mdSignature retVal = 0; + BEGIN_QCALL; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); @@ -689,9 +690,9 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_GetTokenFromSig(QCall::Mod sigLength, // blob length &retVal)); // returned token - *pReturnValue = (INT32)retVal; - END_QCALL; + + return (INT32)retVal; } /*============================SetParamInfo============================ @@ -700,14 +701,14 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_GetTokenFromSig(QCall::Mod **Arguments: **Exceptions: ==============================================================================*/ -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetParamInfo(QCall::ModuleHandle pModule, UINT32 tkMethod, UINT32 iSequence, UINT32 iAttributes, LPCWSTR wszParamName, INT32* pReturnValue) +extern "C" INT32 QCALLTYPE TypeBuilder_SetParamInfo(QCall::ModuleHandle pModule, UINT32 tkMethod, UINT32 iSequence, UINT32 iAttributes, LPCWSTR wszParamName, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - mdParamDef retVal = 0; + BEGIN_QCALL; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); @@ -722,9 +723,9 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetParamInfo(QCall::Module (ULONG) -1, &retVal)); - *pReturnValue = (INT32)retVal; - END_QCALL; + + return (INT32)retVal; } @@ -734,7 +735,7 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetParamInfo(QCall::Module **Arguments: **Exceptions: ==============================================================================*/ -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetConstantValue(QCall::ModuleHandle pModule, UINT32 tk, DWORD valueCorType, LPVOID pValue) +extern "C" void QCALLTYPE TypeBuilder_SetConstantValue(QCall::ModuleHandle pModule, UINT32 tk, DWORD valueCorType, LPVOID pValue, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -790,7 +791,7 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetConstantValue(QCall::Mo **Arguments: **Exceptions: ==============================================================================*/ -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetFieldLayoutOffset(QCall::ModuleHandle pModule, INT32 tkField, INT32 iOffset) +extern "C" void QCALLTYPE TypeBuilder_SetFieldLayoutOffset(QCall::ModuleHandle pModule, INT32 tkField, INT32 iOffset, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -814,7 +815,7 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetFieldLayoutOffset(QCall **Arguments: **Exceptions: ==============================================================================*/ -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetClassLayout(QCall::ModuleHandle pModule, INT32 tk, INT32 iPackSize, UINT32 iTotalSize) +extern "C" void QCALLTYPE TypeBuilder_SetClassLayout(QCall::ModuleHandle pModule, INT32 tk, INT32 iPackSize, UINT32 iTotalSize, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -909,7 +910,7 @@ void UpdateRuntimeStateForAssemblyCustomAttribute(Module* pModule, mdToken tkCus } } -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineCustomAttribute(QCall::ModuleHandle pModule, INT32 token, INT32 conTok, LPCBYTE pBlob, INT32 cbBlob) +extern "C" void QCALLTYPE TypeBuilder_DefineCustomAttribute(QCall::ModuleHandle pModule, INT32 token, INT32 conTok, LPCBYTE pBlob, INT32 cbBlob, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/comdynamic.h b/src/coreclr/vm/comdynamic.h index 82c3817b43d88c..f94c4df55c7ee9 100644 --- a/src/coreclr/vm/comdynamic.h +++ b/src/coreclr/vm/comdynamic.h @@ -38,41 +38,41 @@ class COMDynamicWrite // This function will create the class's metadata definition -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineType(QCall::ModuleHandle pModule, +extern "C" INT32 QCALLTYPE TypeBuilder_DefineType(QCall::ModuleHandle pModule, LPCWSTR wszFullName, INT32 tkParent, INT32 attributes, INT32 tkEnclosingType, INT32 * pInterfaceTokens, - INT32* pReturnValue); + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineGenericParam(QCall::ModuleHandle pModule, +extern "C" INT32 QCALLTYPE TypeBuilder_DefineGenericParam(QCall::ModuleHandle pModule, LPCWSTR wszFullName, INT32 tkParent, INT32 attributes, INT32 position, INT32 * pConstraintTokens, - INT32* pReturnValue); + QCallExceptionStatus* qcallError); // This function will reset the parent class in metadata -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetParentType(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkParent); +extern "C" void QCALLTYPE TypeBuilder_SetParentType(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkParent, QCallExceptionStatus* qcallError); // This function will add another interface impl -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_AddInterfaceImpl(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkInterface); +extern "C" void QCALLTYPE TypeBuilder_AddInterfaceImpl(QCall::ModuleHandle pModule, INT32 tdType, INT32 tkInterface, QCallExceptionStatus* qcallError); // This function will create a method within the class -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineMethod(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attributes, INT32* pReturnValue); +extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethod(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attributes, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineMethodSpec(QCall::ModuleHandle pModule, INT32 tkParent, LPCBYTE pSignature, INT32 sigLength, INT32* pReturnValue); +extern "C" INT32 QCALLTYPE TypeBuilder_DefineMethodSpec(QCall::ModuleHandle pModule, INT32 tkParent, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError); // This function will create a method within the class -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetMethodIL(QCall::ModuleHandle pModule, +extern "C" void QCALLTYPE TypeBuilder_SetMethodIL(QCall::ModuleHandle pModule, INT32 tk, BOOL fIsInitLocal, LPCBYTE pBody, @@ -83,57 +83,58 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetMethodIL(QCall::ModuleH ExceptionInstance * pExceptions, INT32 numExceptions, INT32 * pTokenFixups, - INT32 numTokenFixups); + INT32 numTokenFixups, + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_TermCreateClass(QCall::ModuleHandle pModule, INT32 tk, QCall::ObjectHandleOnStack retType); +extern "C" void QCALLTYPE TypeBuilder_TermCreateClass(QCall::ModuleHandle pModule, INT32 tk, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineField(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attr, mdFieldDef* pReturnValue); +extern "C" mdFieldDef QCALLTYPE TypeBuilder_DefineField(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, LPCBYTE pSignature, INT32 sigLength, INT32 attr, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetPInvokeData(QCall::ModuleHandle pModule, LPCWSTR wszDllName, LPCWSTR wszFunctionName, INT32 token, INT32 linkFlags); +extern "C" void QCALLTYPE TypeBuilder_SetPInvokeData(QCall::ModuleHandle pModule, LPCWSTR wszDllName, LPCWSTR wszFunctionName, INT32 token, INT32 linkFlags, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineProperty(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, LPCBYTE pSignature, INT32 sigLength, INT32* pReturnValue); +extern "C" INT32 QCALLTYPE TypeBuilder_DefineProperty(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineEvent(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, INT32 tkEventType, INT32* pReturnValue); +extern "C" INT32 QCALLTYPE TypeBuilder_DefineEvent(QCall::ModuleHandle pModule, INT32 tkParent, LPCWSTR wszName, INT32 attr, INT32 tkEventType, QCallExceptionStatus* qcallError); // functions to set Setter, Getter, Reset, TestDefault, and other methods -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineMethodSemantics(QCall::ModuleHandle pModule, INT32 tkAssociation, INT32 attr, INT32 tkMethod); +extern "C" void QCALLTYPE TypeBuilder_DefineMethodSemantics(QCall::ModuleHandle pModule, INT32 tkAssociation, INT32 attr, INT32 tkMethod, QCallExceptionStatus* qcallError); // functions to set method's implementation flag -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetMethodImpl(QCall::ModuleHandle pModule, INT32 tkMethod, INT32 attr); +extern "C" void QCALLTYPE TypeBuilder_SetMethodImpl(QCall::ModuleHandle pModule, INT32 tkMethod, INT32 attr, QCallExceptionStatus* qcallError); // functions to create MethodImpl record -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineMethodImpl(QCall::ModuleHandle pModule, UINT32 tkType, UINT32 tkBody, UINT32 tkDecl); +extern "C" void QCALLTYPE TypeBuilder_DefineMethodImpl(QCall::ModuleHandle pModule, UINT32 tkType, UINT32 tkBody, UINT32 tkDecl, QCallExceptionStatus* qcallError); // GetTokenFromSig's argument -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_GetTokenFromSig(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, INT32* pReturnValue); +extern "C" INT32 QCALLTYPE TypeBuilder_GetTokenFromSig(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError); // Set Field offset -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetFieldLayoutOffset(QCall::ModuleHandle pModule, INT32 tkField, INT32 iOffset); +extern "C" void QCALLTYPE TypeBuilder_SetFieldLayoutOffset(QCall::ModuleHandle pModule, INT32 tkField, INT32 iOffset, QCallExceptionStatus* qcallError); // Set classlayout info -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetClassLayout(QCall::ModuleHandle pModule, INT32 tk, INT32 iPackSize, UINT32 iTotalSize); +extern "C" void QCALLTYPE TypeBuilder_SetClassLayout(QCall::ModuleHandle pModule, INT32 tk, INT32 iPackSize, UINT32 iTotalSize, QCallExceptionStatus* qcallError); // Set a custom attribute -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_DefineCustomAttribute(QCall::ModuleHandle pModule, INT32 token, INT32 conTok, LPCBYTE pBlob, INT32 cbBlob); +extern "C" void QCALLTYPE TypeBuilder_DefineCustomAttribute(QCall::ModuleHandle pModule, INT32 token, INT32 conTok, LPCBYTE pBlob, INT32 cbBlob, QCallExceptionStatus* qcallError); // functions to set ParamInfo -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetParamInfo(QCall::ModuleHandle pModule, UINT32 tkMethod, UINT32 iSequence, UINT32 iAttributes, LPCWSTR wszParamName, INT32* pReturnValue); +extern "C" INT32 QCALLTYPE TypeBuilder_SetParamInfo(QCall::ModuleHandle pModule, UINT32 tkMethod, UINT32 iSequence, UINT32 iAttributes, LPCWSTR wszParamName, QCallExceptionStatus* qcallError); // functions to set default value -extern "C" QCallExceptionStatus QCALLTYPE TypeBuilder_SetConstantValue(QCall::ModuleHandle pModule, UINT32 tk, DWORD valueType, LPVOID pValue); +extern "C" void QCALLTYPE TypeBuilder_SetConstantValue(QCall::ModuleHandle pModule, UINT32 tk, DWORD valueType, LPVOID pValue, QCallExceptionStatus* qcallError); #endif // _COMDYNAMIC_H_ diff --git a/src/coreclr/vm/commodule.cpp b/src/coreclr/vm/commodule.cpp index b36f85544f25d9..61b48f17a6de50 100644 --- a/src/coreclr/vm/commodule.cpp +++ b/src/coreclr/vm/commodule.cpp @@ -21,18 +21,18 @@ // wszFullName is escaped (TYPE_NAME_RESERVED_CHAR). It should not be byref or contain enclosing type name, // assembly name, and generic argument list. //************************************************** -extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetTypeRef(QCall::ModuleHandle pModule, +extern "C" mdTypeRef QCALLTYPE ModuleBuilder_GetTypeRef(QCall::ModuleHandle pModule, LPCWSTR wszFullName, QCall::ModuleHandle pRefedModule, INT32 tkResolutionArg, - mdTypeRef* pReturnValue) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - mdTypeRef tr = 0; + BEGIN_QCALL; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); @@ -110,9 +110,9 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetTypeRef(QCall::Module IfFailThrow( pEmit->DefineTypeRefByName(tkResolution, wszFullNameUnescaped, &tr) ); } - *pReturnValue = tr; - END_QCALL; + + return tr; } @@ -125,19 +125,19 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetTypeRef(QCall::Module ** int tkTypeSpec **Exceptions: ==============================================================================*/ -extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetArrayMethodToken(QCall::ModuleHandle pModule, +extern "C" INT32 QCALLTYPE ModuleBuilder_GetArrayMethodToken(QCall::ModuleHandle pModule, INT32 tkTypeSpec, LPCWSTR wszMethodName, LPCBYTE pSignature, INT32 sigLength, - INT32* pReturnValue) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - mdMemberRef memberRefE = mdTokenNil; + BEGIN_QCALL; + if (!wszMethodName) COMPlusThrow(kArgumentNullException, W("ArgumentNull_String")); if (!tkTypeSpec) @@ -153,9 +153,9 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetArrayMethodToken(QCal COMPlusThrowHR(hr); } - *pReturnValue = (INT32)memberRefE; - END_QCALL; + + return (INT32)memberRefE; } namespace @@ -205,14 +205,14 @@ namespace // This function will return a MemberRef token given a MethodDef token and the module where the MethodDef/FieldDef is defined. // //****************************************************************************** -extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRef(QCall::ModuleHandle pModule, QCall::ModuleHandle pRefedModule, INT32 tr, INT32 token, INT32* pReturnValue) +extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRef(QCall::ModuleHandle pModule, QCall::ModuleHandle pRefedModule, INT32 tr, INT32 token, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - mdMemberRef memberRefE = 0; + BEGIN_QCALL; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE( pRCW ); @@ -275,11 +275,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRef(QCall::Modu // Define the memberRef IfFailThrow( pRCW->GetEmitter()->DefineMemberRef(tref, wzName, (PCCOR_SIGNATURE) qbNewSig.Ptr(), cbNewSig, &memberRefE) ); - // assign output parameter - - *pReturnValue = (INT32)memberRefE; - END_QCALL; + + // assign output parameter + return (INT32)memberRefE; } //****************************************************************************** @@ -287,14 +286,14 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRef(QCall::Modu // Return a MemberRef token given a RuntimeMethodInfo // //****************************************************************************** -extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo(QCall::ModuleHandle pModule, INT32 tr, MethodDesc * pMeth, INT32* pReturnValue) +extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo(QCall::ModuleHandle pModule, INT32 tr, MethodDesc * pMeth, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - mdMemberRef memberRefE = 0; + BEGIN_QCALL; + if (!pMeth) COMPlusThrow(kArgumentNullException); @@ -355,9 +354,9 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo IfFailThrow( pRCW->GetEmitter()->DefineMemberRef(tr, wszName, (PCCOR_SIGNATURE) qbNewSig.Ptr(), cbNewSig, &memberRefE) ); } - *pReturnValue = memberRefE; - END_QCALL; + + return memberRefE; } @@ -366,14 +365,14 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo // Return a MemberRef token given a RuntimeFieldInfo // //****************************************************************************** -extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRefOfFieldInfo(QCall::ModuleHandle pModule, mdTypeDef tr, QCall::TypeHandle th, mdFieldDef tkField, mdMemberRef* pReturnValue) +extern "C" mdMemberRef QCALLTYPE ModuleBuilder_GetMemberRefOfFieldInfo(QCall::ModuleHandle pModule, mdTypeDef tr, QCall::TypeHandle th, mdFieldDef tkField, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - mdMemberRef memberRefE = 0; + BEGIN_QCALL; + if (TypeFromToken(tr) == mdtTypeDef) { // If the passed in method is defined in the same module, just return the FieldDef token @@ -430,9 +429,9 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRefOfFieldInfo( IfFailThrow( pRCW->GetEmitter()->DefineMemberRef(tr, wszName, (PCCOR_SIGNATURE) qbNewSig.Ptr(), cbNewSig, &memberRefE) ); } - *pReturnValue = memberRefE; - END_QCALL; + + return memberRefE; } //****************************************************************************** @@ -440,19 +439,19 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRefOfFieldInfo( // Return a MemberRef token given a Signature // //****************************************************************************** -extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRefFromSignature(QCall::ModuleHandle pModule, +extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefFromSignature(QCall::ModuleHandle pModule, INT32 tr, LPCWSTR wszMemberName, LPCBYTE pSignature, INT32 sigLength, - INT32* pReturnValue) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - mdMemberRef memberRefE = mdTokenNil; + BEGIN_QCALL; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); @@ -462,9 +461,9 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRefFromSignatur sigLength, &memberRefE) ); - *pReturnValue = memberRefE; - END_QCALL; + + return memberRefE; } //****************************************************************************** @@ -473,7 +472,7 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRefFromSignatur // This function is used to set the FieldRVA with the content data // //****************************************************************************** -extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_SetFieldRVAContent(QCall::ModuleHandle pModule, INT32 tkField, LPCBYTE pContent, INT32 length) +extern "C" void QCALLTYPE ModuleBuilder_SetFieldRVAContent(QCall::ModuleHandle pModule, INT32 tkField, LPCBYTE pContent, INT32 length, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -529,14 +528,14 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_SetFieldRVAContent(QCall // string constant or return the token of an existing constant. // //****************************************************************************** -extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetStringConstant(QCall::ModuleHandle pModule, LPCWSTR pwzValue, INT32 iLength, mdString* pReturnValue) +extern "C" mdString QCALLTYPE ModuleBuilder_GetStringConstant(QCall::ModuleHandle pModule, LPCWSTR pwzValue, INT32 iLength, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - mdString strRef = mdTokenNil; + BEGIN_QCALL; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); @@ -547,16 +546,16 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetStringConstant(QCall: COMPlusThrowHR(hr); } - *pReturnValue = strRef; - END_QCALL; + + return strRef; } /*=============================SetModuleName==================================== // SetModuleName ==============================================================================*/ -extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_SetModuleName(QCall::ModuleHandle pModule, LPCWSTR wszModuleName) +extern "C" void QCALLTYPE ModuleBuilder_SetModuleName(QCall::ModuleHandle pModule, LPCWSTR wszModuleName, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -575,28 +574,28 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_SetModuleName(QCall::Mod // Return a type spec token given a byte array // //****************************************************************************** -extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetTokenFromTypeSpec(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, mdTypeSpec* pReturnValue) +extern "C" mdTypeSpec QCALLTYPE ModuleBuilder_GetTokenFromTypeSpec(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - mdTypeSpec ts = mdTokenNil; + BEGIN_QCALL; + RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter(); _ASSERTE(pRCW); IfFailThrow(pRCW->GetEmitter()->GetTokenFromTypeSpec((PCCOR_SIGNATURE)pSignature, sigLength, &ts)); - *pReturnValue = ts; - END_QCALL; + + return ts; } // GetName // This routine will return the name of the module as a String -extern "C" QCallExceptionStatus QCALLTYPE RuntimeModule_GetScopeName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString) +extern "C" void QCALLTYPE RuntimeModule_GetScopeName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -620,7 +619,7 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeModule_GetScopeName(QCall::Modu **Arguments: **Exceptions: ==============================================================================*/ -extern "C" QCallExceptionStatus QCALLTYPE RuntimeModule_GetFullyQualifiedName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString) +extern "C" void QCALLTYPE RuntimeModule_GetFullyQualifiedName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -654,14 +653,14 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeModule_GetFullyQualifiedName(QC **Arguments: refThis **Exceptions: None. ==============================================================================*/ -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetHINSTANCE(QCall::ModuleHandle pModule, HINSTANCE* pReturnValue) +extern "C" HINSTANCE QCALLTYPE MarshalNative_GetHINSTANCE(QCall::ModuleHandle pModule, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - HMODULE hMod = (HMODULE)0; + BEGIN_QCALL; + // This returns the base address // Other modules should have zero base if (!pModule->IsReflectionEmit()) @@ -675,14 +674,14 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetHINSTANCE(QCall::Modu hMod = (HMODULE)-1; } - *pReturnValue = (HINSTANCE)hMod; - END_QCALL; + + return (HINSTANCE)hMod; } // Get class will return an array contain all of the classes // that are defined within this Module. -extern "C" QCallExceptionStatus QCALLTYPE RuntimeModule_GetTypes(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retTypes, QCall::ObjectHandleOnStack retExceptions) +extern "C" void QCALLTYPE RuntimeModule_GetTypes(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retTypes, QCall::ObjectHandleOnStack retExceptions, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/commodule.h b/src/coreclr/vm/commodule.h index 5fed6705a745b7..7e365f4515cdbf 100644 --- a/src/coreclr/vm/commodule.h +++ b/src/coreclr/vm/commodule.h @@ -19,63 +19,63 @@ class COMModule // GetTypeRef // This function will return the class token for the named element. -extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetTypeRef(QCall::ModuleHandle pModule, +extern "C" mdTypeRef QCALLTYPE ModuleBuilder_GetTypeRef(QCall::ModuleHandle pModule, LPCWSTR wszFullName, QCall::ModuleHandle pRefedModule, INT32 tkResolution, - mdTypeRef* pReturnValue); + QCallExceptionStatus* qcallError); // SetFieldRVAContent // This function is used to set the FieldRVA with the content data -extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_SetFieldRVAContent(QCall::ModuleHandle pModule, INT32 tkField, LPCBYTE pContent, INT32 length); +extern "C" void QCALLTYPE ModuleBuilder_SetFieldRVAContent(QCall::ModuleHandle pModule, INT32 tkField, LPCBYTE pContent, INT32 length, QCallExceptionStatus* qcallError); //GetArrayMethodToken -extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetArrayMethodToken(QCall::ModuleHandle pModule, +extern "C" INT32 QCALLTYPE ModuleBuilder_GetArrayMethodToken(QCall::ModuleHandle pModule, INT32 tkTypeSpec, LPCWSTR wszMethodName, LPCBYTE pSignature, INT32 sigLength, - INT32* pReturnValue); + QCallExceptionStatus* qcallError); // GetMemberRefToken // This function will return the MemberRef token -extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRef(QCall::ModuleHandle pModule, QCall::ModuleHandle pRefedModule, INT32 tr, INT32 token, INT32* pReturnValue); +extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRef(QCall::ModuleHandle pModule, QCall::ModuleHandle pRefedModule, INT32 tr, INT32 token, QCallExceptionStatus* qcallError); // This function return a MemberRef token given a MethodInfo describing an array method -extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo(QCall::ModuleHandle pModule, INT32 tr, MethodDesc * method, INT32* pReturnValue); +extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefOfMethodInfo(QCall::ModuleHandle pModule, INT32 tr, MethodDesc * method, QCallExceptionStatus* qcallError); // GetMemberRefOfFieldInfo // This function will return a memberRef token given a FieldInfo -extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRefOfFieldInfo(QCall::ModuleHandle pModule, mdTypeDef tr, QCall::TypeHandle th, mdFieldDef tkField, mdMemberRef* pReturnValue); +extern "C" mdMemberRef QCALLTYPE ModuleBuilder_GetMemberRefOfFieldInfo(QCall::ModuleHandle pModule, mdTypeDef tr, QCall::TypeHandle th, mdFieldDef tkField, QCallExceptionStatus* qcallError); // GetMemberRefFromSignature // This function will return the MemberRef token given the signature from managed code -extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetMemberRefFromSignature(QCall::ModuleHandle pModule, +extern "C" INT32 QCALLTYPE ModuleBuilder_GetMemberRefFromSignature(QCall::ModuleHandle pModule, INT32 tr, LPCWSTR wszMemberName, LPCBYTE pSignature, INT32 sigLength, - INT32* pReturnValue); + QCallExceptionStatus* qcallError); // GetTokenFromTypeSpec -extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetTokenFromTypeSpec(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, mdTypeSpec* pReturnValue); +extern "C" mdTypeSpec QCALLTYPE ModuleBuilder_GetTokenFromTypeSpec(QCall::ModuleHandle pModule, LPCBYTE pSignature, INT32 sigLength, QCallExceptionStatus* qcallError); // GetStringConstant // If this is a dynamic module, this routine will define a new // string constant or return the token of an existing constant. -extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_GetStringConstant(QCall::ModuleHandle pModule, LPCWSTR pwzValue, INT32 iLength, mdString* pReturnValue); +extern "C" mdString QCALLTYPE ModuleBuilder_GetStringConstant(QCall::ModuleHandle pModule, LPCWSTR pwzValue, INT32 iLength, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE ModuleBuilder_SetModuleName(QCall::ModuleHandle pModule, LPCWSTR wszModuleName); +extern "C" void QCALLTYPE ModuleBuilder_SetModuleName(QCall::ModuleHandle pModule, LPCWSTR wszModuleName, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeModule_GetScopeName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString); +extern "C" void QCALLTYPE RuntimeModule_GetScopeName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeModule_GetFullyQualifiedName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString); +extern "C" void QCALLTYPE RuntimeModule_GetFullyQualifiedName(QCall::ModuleHandle pModule, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); // GetTypes will return an array containing all of the types that are defined within this Module. -extern "C" QCallExceptionStatus QCALLTYPE RuntimeModule_GetTypes(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retTypes, QCall::ObjectHandleOnStack retExceptions); +extern "C" void QCALLTYPE RuntimeModule_GetTypes(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retTypes, QCall::ObjectHandleOnStack retExceptions, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetHINSTANCE(QCall::ModuleHandle pModule, HINSTANCE* pReturnValue); +extern "C" HINSTANCE QCALLTYPE MarshalNative_GetHINSTANCE(QCall::ModuleHandle pModule, QCallExceptionStatus* qcallError); #endif diff --git a/src/coreclr/vm/comsynchronizable.cpp b/src/coreclr/vm/comsynchronizable.cpp index eb4e56be9fe0a1..f83f92b732babd 100644 --- a/src/coreclr/vm/comsynchronizable.cpp +++ b/src/coreclr/vm/comsynchronizable.cpp @@ -197,14 +197,14 @@ static ULONG WINAPI KickOffThread(void* pass) return 0; } -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_Start(QCall::ThreadHandle thread, int threadStackSize, int priority, BOOL isThreadPool, PCWSTR pThreadName, QCall::ObjectHandleOnStack exception, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE ThreadNative_Start(QCall::ThreadHandle thread, int threadStackSize, int priority, BOOL isThreadPool, PCWSTR pThreadName, QCall::ObjectHandleOnStack exception, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - BOOL result = TRUE; + BEGIN_QCALL; + Thread* pNewThread = thread; _ASSERTE(pNewThread != NULL); @@ -282,12 +282,12 @@ extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_Start(QCall::ThreadHandle exception.Set(pNewThread->GetExceptionDuringStartup()); } - *pReturnValue = result; - END_QCALL; + + return result; } -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_SetPriority(QCall::ObjectHandleOnStack thread, INT32 iPriority) +extern "C" void QCALLTYPE ThreadNative_SetPriority(QCall::ObjectHandleOnStack thread, INT32 iPriority, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -328,7 +328,7 @@ extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_SetPriority(QCall::Object END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetCurrentThread(QCall::ObjectHandleOnStack thread) +extern "C" void QCALLTYPE ThreadNative_GetCurrentThread(QCall::ObjectHandleOnStack thread, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -340,29 +340,30 @@ extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetCurrentThread(QCall::O END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetCurrentOSThreadId(UINT64* pReturnValue) +extern "C" UINT64 QCALLTYPE ThreadNative_GetCurrentOSThreadId(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; + UINT64 threadId = 0; + BEGIN_QCALL; // The Windows API GetCurrentThreadId returns a 32-bit integer thread ID. // On some non-Windows platforms (e.g. OSX), the thread ID is a 64-bit value. // We special case the API for non-Windows to get the 64-bit value and zero-extend // the Windows value to return a single data type on all platforms. - UINT64 threadId = 0; #ifndef TARGET_UNIX threadId = (UINT64) GetCurrentThreadId(); #else threadId = (UINT64) PAL_GetCurrentOSThreadId(); #endif - *pReturnValue = threadId; - END_QCALL; + + return threadId; } -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_Initialize(QCall::ObjectHandleOnStack t) +extern "C" void QCALLTYPE ThreadNative_Initialize(QCall::ObjectHandleOnStack t, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -431,14 +432,14 @@ extern "C" INT32 QCALLTYPE ThreadNative_GetThreadState(QCall::ThreadHandle threa // Return whether the thread hosts an STA, is a member of the MTA or is not // currently initialized for COM. -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetApartmentState(QCall::ObjectHandleOnStack t, INT32* pReturnValue) +extern "C" INT32 QCALLTYPE ThreadNative_GetApartmentState(QCall::ObjectHandleOnStack t, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - INT32 retVal = 0; + BEGIN_QCALL; + Thread* thread = NULL; { GCX_COOP(); @@ -454,22 +455,21 @@ extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetApartmentState(QCall:: retVal = thread->GetApartment(); - *pReturnValue = retVal; - END_QCALL; + return retVal; } // Indicate whether the thread will host an STA (this may fail if the thread has // already been made part of the MTA, use GetApartmentState or the return state // from this routine to check for this). -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_SetApartmentState(QCall::ObjectHandleOnStack t, INT32 iState, INT32* pReturnValue) +extern "C" INT32 QCALLTYPE ThreadNative_SetApartmentState(QCall::ObjectHandleOnStack t, INT32 iState, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - INT32 retVal = 0; + BEGIN_QCALL; + Thread* thread = NULL; { GCX_COOP(); @@ -501,21 +501,20 @@ extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_SetApartmentState(QCall:: retVal = thread->SetApartment((Thread::ApartmentState)iState); } - *pReturnValue = retVal; - END_QCALL; + return retVal; } #endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT #if TARGET_WINDOWS -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetOSHandle(QCall::ThreadHandle t, HANDLE* pReturnValue) +extern "C" HANDLE QCALLTYPE ThreadNative_GetOSHandle(QCall::ThreadHandle t, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - HANDLE retVal = INVALID_HANDLE_VALUE; + BEGIN_QCALL; + HANDLE currentHandle = t->GetThreadHandle(); if (currentHandle != INVALID_HANDLE_VALUE) { @@ -532,9 +531,9 @@ extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetOSHandle(QCall::Thread } } - *pReturnValue = retVal; - END_QCALL; + + return retVal; } #endif @@ -637,7 +636,7 @@ extern "C" BOOL QCALLTYPE ThreadNative_GetIsBackground(QCall::ThreadHandle threa } // Set whether or not this is a background thread. -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_SetIsBackground(QCall::ThreadHandle thread, BOOL value) +extern "C" void QCALLTYPE ThreadNative_SetIsBackground(QCall::ThreadHandle thread, BOOL value, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -653,7 +652,7 @@ extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_SetIsBackground(QCall::Th END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_InformThreadNameChange(QCall::ThreadHandle thread, LPCWSTR name, INT32 len) +extern "C" void QCALLTYPE ThreadNative_InformThreadNameChange(QCall::ThreadHandle thread, LPCWSTR name, INT32 len, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -702,9 +701,10 @@ FCIMPL0(INT32, ThreadNative::GetOptimalMaxSpinWaitsPerSpinIteration) } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetQCallSpecialException( +extern "C" void QCALLTYPE ThreadNative_GetQCallSpecialException( INT_PTR status, - QCall::ObjectHandleOnStack exception) + QCall::ObjectHandleOnStack exception, + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -758,7 +758,7 @@ extern "C" void QCALLTYPE ThreadNative_SpinWait(INT32 iterations) #ifdef TARGET_WINDOWS // This service can be called on unstarted and dead threads. For unstarted ones, the // next wait will be interrupted. For dead ones, this service quietly does nothing. -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_Interrupt(QCall::ThreadHandle thread) +extern "C" void QCALLTYPE ThreadNative_Interrupt(QCall::ThreadHandle thread, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -774,7 +774,7 @@ extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_Interrupt(QCall::ThreadHa END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_CheckForPendingInterrupt() +extern "C" void QCALLTYPE ThreadNative_CheckForPendingInterrupt(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -806,22 +806,22 @@ extern "C" void QCALLTYPE ThreadNative_PollGC() // and is thus marked as a GC safe point, and that the p/invoke rare path will kick in } -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_YieldThread(BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE ThreadNative_YieldThread(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - BOOL ret = FALSE; - ret = __SwitchToThread(0, CALLER_LIMITS_SPINNING); + BEGIN_QCALL; - *pReturnValue = ret; + ret = __SwitchToThread(0, CALLER_LIMITS_SPINNING); END_QCALL; + + return ret; } -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_Abort(QCall::ThreadHandle thread) +extern "C" void QCALLTYPE ThreadNative_Abort(QCall::ThreadHandle thread, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -866,7 +866,7 @@ FCIMPL1(OBJECTHANDLE, ObjectHeader_GetLockHandleIfExists, Object* pObj) } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE ObjectHeader_GetOrCreateLockObject(QCall::ObjectHandleOnStack obj, QCall::ObjectHandleOnStack lockObj) +extern "C" void QCALLTYPE ObjectHeader_GetOrCreateLockObject(QCall::ObjectHandleOnStack obj, QCall::ObjectHandleOnStack lockObj, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -881,19 +881,19 @@ extern "C" QCallExceptionStatus QCALLTYPE ObjectHeader_GetOrCreateLockObject(QCa END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_ReentrantWaitAny(BOOL alertable, INT32 timeout, INT32 count, HANDLE *handles, INT32* pReturnValue) +extern "C" INT32 QCALLTYPE ThreadNative_ReentrantWaitAny(BOOL alertable, INT32 timeout, INT32 count, HANDLE *handles, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - INT32 retVal = 0; + BEGIN_QCALL; + Thread *pThread = GetThread(); WaitMode mode = alertable ? WaitMode_Alertable : WaitMode_None; retVal = (INT32)pThread->DoReentrantWaitAny(count, handles, timeout, mode); - *pReturnValue = retVal; - END_QCALL; + + return retVal; } diff --git a/src/coreclr/vm/comsynchronizable.h b/src/coreclr/vm/comsynchronizable.h index 002107c28700fb..af320d49ae4d48 100644 --- a/src/coreclr/vm/comsynchronizable.h +++ b/src/coreclr/vm/comsynchronizable.h @@ -48,41 +48,41 @@ class ThreadNative FCDECL0(static FC_BOOL_RET, CurrentThreadIsFinalizerThread); }; -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetQCallSpecialException(INT_PTR status, QCall::ObjectHandleOnStack exception); -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_Start(QCall::ThreadHandle thread, int threadStackSize, int priority, BOOL isThreadPool, PCWSTR pThreadName, QCall::ObjectHandleOnStack exception, BOOL* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_SetPriority(QCall::ObjectHandleOnStack thread, INT32 iPriority); -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetCurrentThread(QCall::ObjectHandleOnStack thread); +extern "C" void QCALLTYPE ThreadNative_GetQCallSpecialException(INT_PTR status, QCall::ObjectHandleOnStack exception, QCallExceptionStatus* qcallError); +extern "C" BOOL QCALLTYPE ThreadNative_Start(QCall::ThreadHandle thread, int threadStackSize, int priority, BOOL isThreadPool, PCWSTR pThreadName, QCall::ObjectHandleOnStack exception, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ThreadNative_SetPriority(QCall::ObjectHandleOnStack thread, INT32 iPriority, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ThreadNative_GetCurrentThread(QCall::ObjectHandleOnStack thread, QCallExceptionStatus* qcallError); extern "C" BOOL QCALLTYPE ThreadNative_GetIsBackground(QCall::ThreadHandle thread); -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_SetIsBackground(QCall::ThreadHandle thread, BOOL value); -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_InformThreadNameChange(QCall::ThreadHandle thread, LPCWSTR name, INT32 len); -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_YieldThread(BOOL* pReturnValue); +extern "C" void QCALLTYPE ThreadNative_SetIsBackground(QCall::ThreadHandle thread, BOOL value, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ThreadNative_InformThreadNameChange(QCall::ThreadHandle thread, LPCWSTR name, INT32 len, QCallExceptionStatus* qcallError); +extern "C" BOOL QCALLTYPE ThreadNative_YieldThread(QCallExceptionStatus* qcallError); extern "C" void QCALLTYPE ThreadNative_PollGC(); -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetCurrentOSThreadId(UINT64* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_Initialize(QCall::ObjectHandleOnStack t); +extern "C" UINT64 QCALLTYPE ThreadNative_GetCurrentOSThreadId(QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ThreadNative_Initialize(QCall::ObjectHandleOnStack t, QCallExceptionStatus* qcallError); extern "C" INT32 QCALLTYPE ThreadNative_GetThreadState(QCall::ThreadHandle thread); -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_ReentrantWaitAny(BOOL alertable, INT32 timeout, INT32 count, HANDLE *handles, INT32* pReturnValue); +extern "C" INT32 QCALLTYPE ThreadNative_ReentrantWaitAny(BOOL alertable, INT32 timeout, INT32 count, HANDLE *handles, QCallExceptionStatus* qcallError); #ifdef TARGET_WINDOWS -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_Interrupt(QCall::ThreadHandle thread); -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_CheckForPendingInterrupt(); +extern "C" void QCALLTYPE ThreadNative_Interrupt(QCall::ThreadHandle thread, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ThreadNative_CheckForPendingInterrupt(QCallExceptionStatus* qcallError); #endif // TARGET_WINDOWS #ifdef FEATURE_COMINTEROP_APARTMENT_SUPPORT -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetApartmentState(QCall::ObjectHandleOnStack t, INT32* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_SetApartmentState(QCall::ObjectHandleOnStack t, INT32 iState, INT32* pReturnValue); +extern "C" INT32 QCALLTYPE ThreadNative_GetApartmentState(QCall::ObjectHandleOnStack t, QCallExceptionStatus* qcallError); +extern "C" INT32 QCALLTYPE ThreadNative_SetApartmentState(QCall::ObjectHandleOnStack t, INT32 iState, QCallExceptionStatus* qcallError); #endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT #ifdef TARGET_WINDOWS -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_GetOSHandle(QCall::ThreadHandle t, HANDLE* pReturnValue); +extern "C" HANDLE QCALLTYPE ThreadNative_GetOSHandle(QCall::ThreadHandle t, QCallExceptionStatus* qcallError); #endif // TARGET_WINDOWS -extern "C" QCallExceptionStatus QCALLTYPE ThreadNative_Abort(QCall::ThreadHandle thread); +extern "C" void QCALLTYPE ThreadNative_Abort(QCall::ThreadHandle thread, QCallExceptionStatus* qcallError); extern "C" void QCALLTYPE ThreadNative_ResetAbort(); extern "C" void QCALLTYPE ThreadNative_SpinWait(INT32 iterations); #ifdef FEATURE_COMINTEROP extern "C" void QCALLTYPE ThreadNative_DisableComObjectEagerCleanup(QCall::ThreadHandle thread); #endif // FEATURE_COMINTEROP -extern "C" QCallExceptionStatus QCALLTYPE ObjectHeader_GetOrCreateLockObject(QCall::ObjectHandleOnStack obj, QCall::ObjectHandleOnStack lockObj); +extern "C" void QCALLTYPE ObjectHeader_GetOrCreateLockObject(QCall::ObjectHandleOnStack obj, QCall::ObjectHandleOnStack lockObj, QCallExceptionStatus* qcallError); FCDECL1(OBJECTHANDLE, ObjectHeader_GetLockHandleIfExists, Object* obj); #endif // _COMSYNCHRONIZABLE_H diff --git a/src/coreclr/vm/comutilnative.cpp b/src/coreclr/vm/comutilnative.cpp index d9bb0e4c9fc915..3e9b9993c5c814 100644 --- a/src/coreclr/vm/comutilnative.cpp +++ b/src/coreclr/vm/comutilnative.cpp @@ -82,7 +82,7 @@ FCIMPLEND // Given an exception object, this method will mark its stack trace as frozen and return it to the caller. // Frozen stack traces are immutable, when a thread attempts to add a frame to it, the stack trace is cloned first. -extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_GetFrozenStackTrace(QCall::ObjectHandleOnStack exception, QCall::ObjectHandleOnStack ret) +extern "C" void QCALLTYPE ExceptionNative_GetFrozenStackTrace(QCall::ObjectHandleOnStack exception, QCall::ObjectHandleOnStack ret, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -312,7 +312,7 @@ FCIMPLEND // our locks within CER's to avoid this problem - just use the CLR's // unmanaged resources. // -extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_GetMessageFromNativeResources(ExceptionMessageKind kind, QCall::StringHandleOnStack retMesg) +extern "C" void QCALLTYPE ExceptionNative_GetMessageFromNativeResources(ExceptionMessageKind kind, QCall::StringHandleOnStack retMesg, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -359,7 +359,7 @@ extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_GetMessageFromNativeRe END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_GetMethodFromStackTrace(QCall::ObjectHandleOnStack stacktrace, QCall::ObjectHandleOnStack retMethodInfo) +extern "C" void QCALLTYPE ExceptionNative_GetMethodFromStackTrace(QCall::ObjectHandleOnStack stacktrace, QCall::ObjectHandleOnStack retMethodInfo, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -400,10 +400,11 @@ extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_GetMethodFromStackTrac END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowAmbiguousResolutionException( +extern "C" void QCALLTYPE ExceptionNative_ThrowAmbiguousResolutionException( MethodTable* pTargetClass, MethodTable* pInterfaceMT, - MethodDesc* pInterfaceMD) + MethodDesc* pInterfaceMD, + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -414,10 +415,11 @@ extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowAmbiguousResoluti END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowEntryPointNotFoundException( +extern "C" void QCALLTYPE ExceptionNative_ThrowEntryPointNotFoundException( MethodTable* pTargetClass, MethodTable* pInterfaceMT, - MethodDesc* pInterfaceMD) + MethodDesc* pInterfaceMD, + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -428,7 +430,7 @@ extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowEntryPointNotFoun END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowMethodAccessException(MethodDesc* caller, MethodDesc* callee) +extern "C" void QCALLTYPE ExceptionNative_ThrowMethodAccessException(MethodDesc* caller, MethodDesc* callee, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -441,7 +443,7 @@ extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowMethodAccessExcep END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowFieldAccessException(MethodDesc* caller, FieldDesc* callee) +extern "C" void QCALLTYPE ExceptionNative_ThrowFieldAccessException(MethodDesc* caller, FieldDesc* callee, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -454,7 +456,7 @@ extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowFieldAccessExcept END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowClassAccessException(MethodDesc* caller, EnregisteredTypeHandle callee) +extern "C" void QCALLTYPE ExceptionNative_ThrowClassAccessException(MethodDesc* caller, EnregisteredTypeHandle callee, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -585,40 +587,40 @@ FCIMPL0(FC_BOOL_RET, GCInterface::CancelFullGCNotification) } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_WaitForFullGCApproach(int millisecondsTimeout, int* pReturnValue) +extern "C" int QCALLTYPE GCInterface_WaitForFullGCApproach(int millisecondsTimeout, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - int result = 0; + BEGIN_QCALL; + GCX_COOP(); DWORD dwMilliseconds = ((millisecondsTimeout == -1) ? INFINITE : millisecondsTimeout); result = GCHeapUtilities::GetGCHeap()->WaitForFullGCApproach(dwMilliseconds); - *pReturnValue = result; - END_QCALL; + + return result; } -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_WaitForFullGCComplete(int millisecondsTimeout, int* pReturnValue) +extern "C" int QCALLTYPE GCInterface_WaitForFullGCComplete(int millisecondsTimeout, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - int result = 0; + BEGIN_QCALL; + GCX_COOP(); DWORD dwMilliseconds = ((millisecondsTimeout == -1) ? INFINITE : millisecondsTimeout); result = GCHeapUtilities::GetGCHeap()->WaitForFullGCComplete(dwMilliseconds); - *pReturnValue = result; - END_QCALL; + + return result; } /*================================GetGenerationInternal================================= @@ -670,14 +672,14 @@ FCIMPL2(int, GCInterface::CollectionCount, INT32 generation, INT32 getSpecialGCC } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_StartNoGCRegion(INT64 totalSize, BOOL lohSizeKnown, INT64 lohSize, BOOL disallowFullBlockingGC, int* pReturnValue) +extern "C" int QCALLTYPE GCInterface_StartNoGCRegion(INT64 totalSize, BOOL lohSizeKnown, INT64 lohSize, BOOL disallowFullBlockingGC, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - int retVal = 0; + BEGIN_QCALL; + GCX_COOP(); retVal = GCHeapUtilities::GetGCHeap()->StartNoGCRegion((ULONGLONG)totalSize, @@ -685,24 +687,24 @@ extern "C" QCallExceptionStatus QCALLTYPE GCInterface_StartNoGCRegion(INT64 tota (ULONGLONG)lohSize, !!disallowFullBlockingGC); - *pReturnValue = retVal; - END_QCALL; + + return retVal; } -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_EndNoGCRegion(int* pReturnValue) +extern "C" int QCALLTYPE GCInterface_EndNoGCRegion(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - int retVal = FALSE; - retVal = GCHeapUtilities::GetGCHeap()->EndNoGCRegion(); + BEGIN_QCALL; - *pReturnValue = retVal; + retVal = GCHeapUtilities::GetGCHeap()->EndNoGCRegion(); END_QCALL; + + return retVal; } FCIMPL0(int, GCInterface::GetLastGCPercentTimeInGC) @@ -727,20 +729,20 @@ FCIMPLEND **Arguments: None **Exceptions: None ==============================================================================*/ -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_GetTotalMemory(INT64* pReturnValue) +extern "C" INT64 QCALLTYPE GCInterface_GetTotalMemory(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - INT64 iRetVal = 0; + BEGIN_QCALL; + GCX_COOP(); iRetVal = (INT64) GCHeapUtilities::GetGCHeap()->GetTotalBytesInUse(); - *pReturnValue = iRetVal; - END_QCALL; + + return iRetVal; } /*==============================Collect========================================= @@ -749,7 +751,7 @@ extern "C" QCallExceptionStatus QCALLTYPE GCInterface_GetTotalMemory(INT64* pRet **Arguments: args->generation: The maximum generation to collect **Exceptions: Argument exception if args->generation is < 0 or > GetMaxGeneration(); ==============================================================================*/ -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_Collect(INT32 generation, INT32 mode, CLR_BOOL lowMemoryPressure) +extern "C" void QCALLTYPE GCInterface_Collect(INT32 generation, INT32 mode, CLR_BOOL lowMemoryPressure, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -766,14 +768,14 @@ extern "C" QCallExceptionStatus QCALLTYPE GCInterface_Collect(INT32 generation, END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_GetNextFinalizableObject(QCall::ObjectHandleOnStack pObj, void** pReturnValue) +extern "C" void* QCALLTYPE GCInterface_GetNextFinalizableObject(QCall::ObjectHandleOnStack pObj, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - PCODE funcPtr = 0; + BEGIN_QCALL; + MethodTable *pTargetMT = NULL; { GCX_COOP(); @@ -798,9 +800,9 @@ extern "C" QCallExceptionStatus QCALLTYPE GCInterface_GetNextFinalizableObject(Q #endif // FEATURE_PORTABLE_ENTRYPOINTS } - *pReturnValue = (void*)funcPtr; - END_QCALL; + + return (void*)funcPtr; } /*==========================WaitForPendingFinalizers============================ @@ -808,7 +810,7 @@ extern "C" QCallExceptionStatus QCALLTYPE GCInterface_GetNextFinalizableObject(Q **Arguments: None **Exceptions: None ==============================================================================*/ -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_WaitForPendingFinalizers() +extern "C" void QCALLTYPE GCInterface_WaitForPendingFinalizers(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -875,7 +877,7 @@ FCIMPLEND ** ret -> The allocated array. **Exceptions: IDS_EE_ARRAY_DIMENSIONS_EXCEEDED when size is too large. OOM if can't allocate. ==============================================================================*/ -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_AllocateNewArray(void* typeHandlePtr, INT32 length, INT32 flags, QCall::ObjectHandleOnStack ret) +extern "C" void QCALLTYPE GCInterface_AllocateNewArray(void* typeHandlePtr, INT32 length, INT32 flags, QCall::ObjectHandleOnStack ret, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(typeHandlePtr != NULL); @@ -925,7 +927,7 @@ FCIMPL0(INT64, GCInterface::GetTotalAllocatedBytesApproximate) } FCIMPLEND; -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_GetTotalAllocatedBytesPrecise(INT64* pReturnValue) +extern "C" INT64 QCALLTYPE GCInterface_GetTotalAllocatedBytesPrecise(QCallExceptionStatus* qcallError) { INT64 allocated = 0; @@ -951,9 +953,9 @@ extern "C" QCallExceptionStatus QCALLTYPE GCInterface_GetTotalAllocatedBytesPrec ThreadSuspend::RestartEE(true /* SuspendSucceeded */); - *pReturnValue = allocated; - END_QCALL; + + return allocated; } @@ -963,14 +965,14 @@ extern "C" QCallExceptionStatus QCALLTYPE GCInterface_GetTotalAllocatedBytesPrec **Arguments: args-> pointer to section, size of section **Exceptions: None ==============================================================================*/ -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_RegisterFrozenSegment(void* pSection, SIZE_T sizeSection, void** pReturnValue) +extern "C" void* QCALLTYPE GCInterface_RegisterFrozenSegment(void* pSection, SIZE_T sizeSection, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - void* retVal = nullptr; + BEGIN_QCALL; + _ASSERTE(pSection != nullptr); _ASSERTE(sizeSection > 0); @@ -985,9 +987,9 @@ extern "C" QCallExceptionStatus QCALLTYPE GCInterface_RegisterFrozenSegment(void retVal = (void*)GCHeapUtilities::GetGCHeap()->RegisterFrozenSegment(&seginfo); - *pReturnValue = retVal; - END_QCALL; + + return retVal; } /*===============================UnregisterFrozenSegment=============================== @@ -996,7 +998,7 @@ extern "C" QCallExceptionStatus QCALLTYPE GCInterface_RegisterFrozenSegment(void **Arguments: args-> segment handle **Exceptions: None ==============================================================================*/ -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_UnregisterFrozenSegment(void* segment) +extern "C" void QCALLTYPE GCInterface_UnregisterFrozenSegment(void* segment, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1032,7 +1034,7 @@ FCIMPLEND **Arguments: Object of interest **Exceptions: None ==============================================================================*/ -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_ReRegisterForFinalize(QCall::ObjectHandleOnStack pObj) +extern "C" void QCALLTYPE GCInterface_ReRegisterForFinalize(QCall::ObjectHandleOnStack pObj, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1090,7 +1092,7 @@ FORCEINLINE UINT64 GCInterface::InterlockedSub(UINT64 *pMinuend, UINT64 subtrahe return newMemValue; } -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_AddMemoryPressure(UINT64 bytesAllocated) +extern "C" void QCALLTYPE GCInterface_AddMemoryPressure(UINT64 bytesAllocated, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1099,7 +1101,7 @@ extern "C" QCallExceptionStatus QCALLTYPE GCInterface_AddMemoryPressure(UINT64 b END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_EnumerateConfigurationValues(void* configurationContext, EnumerateConfigurationValuesCallback callback) +extern "C" void QCALLTYPE GCInterface_EnumerateConfigurationValues(void* configurationContext, EnumerateConfigurationValuesCallback callback, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1127,20 +1129,20 @@ void GCInterface::EnumerateConfigurationValues(void* configurationContext, Enume GCHeapHardLimitInfo g_gcHeapHardLimitInfo; bool g_gcHeapHardLimitInfoSpecified = false; -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_RefreshMemoryLimit(GCHeapHardLimitInfo heapHardLimitInfo, int* pReturnValue) +extern "C" int QCALLTYPE GCInterface_RefreshMemoryLimit(GCHeapHardLimitInfo heapHardLimitInfo, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - int result = 0; + BEGIN_QCALL; + g_gcHeapHardLimitInfo = heapHardLimitInfo; g_gcHeapHardLimitInfoSpecified = true; result = GCInterface::RefreshMemoryLimit(); - *pReturnValue = result; - END_QCALL; + + return result; } int GCInterface::RefreshMemoryLimit() @@ -1156,16 +1158,15 @@ int GCInterface::RefreshMemoryLimit() return GCHeapUtilities::GetGCHeap()->RefreshMemoryLimit(); } -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, INT64 totalSize, enable_no_gc_region_callback_status* pReturnValue) +extern "C" enable_no_gc_region_callback_status QCALLTYPE GCInterface_EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, INT64 totalSize, QCallExceptionStatus* qcallError) { enable_no_gc_region_callback_status status = enable_no_gc_region_callback_status::succeed; QCALL_CONTRACT; BEGIN_QCALL; status = GCInterface::EnableNoGCRegionCallback(callback, totalSize); - *pReturnValue = status; - END_QCALL; + return status; } enable_no_gc_region_callback_status GCInterface::EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, INT64 totalSize) @@ -1181,16 +1182,16 @@ enable_no_gc_region_callback_status GCInterface::EnableNoGCRegionCallback(NoGCRe return GCHeapUtilities::GetGCHeap()->EnableNoGCRegionCallback(callback, totalSize); } -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_GetGenerationBudget(int generation, uint64_t* pReturnValue) +extern "C" uint64_t QCALLTYPE GCInterface_GetGenerationBudget(int generation, QCallExceptionStatus* qcallError) { uint64_t result = 0; QCALL_CONTRACT; BEGIN_QCALL; result = GCInterface::GetGenerationBudget(generation); - *pReturnValue = result; - END_QCALL; + + return result; } uint64_t GCInterface::GetGenerationBudget(int generation) @@ -1330,7 +1331,7 @@ void GCInterface::AddMemoryPressure(UINT64 bytesAllocated) } } -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_RemoveMemoryPressure(UINT64 bytesAllocated) +extern "C" void QCALLTYPE GCInterface_RemoveMemoryPressure(UINT64 bytesAllocated, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1414,7 +1415,7 @@ NOINLINE void GCInterface::GarbageCollectModeAny(int generation) // // EnvironmentNative // -extern "C" QCallExceptionStatus QCALLTYPE Environment_Exit(INT32 exitcode) +extern "C" VOID QCALLTYPE Environment_Exit(INT32 exitcode, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1452,19 +1453,19 @@ FCIMPL0(INT32, EnvironmentNative::GetExitCode) } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE Environment_GetProcessorCount(INT32* pReturnValue) +extern "C" INT32 QCALLTYPE Environment_GetProcessorCount(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - INT32 processorCount = 0; - processorCount = GetCurrentProcessCpuCount(); + BEGIN_QCALL; - *pReturnValue = processorCount; + processorCount = GetCurrentProcessCpuCount(); END_QCALL; + + return processorCount; } struct FindFailFastCallerStruct { @@ -1501,7 +1502,7 @@ static StackWalkAction FindFailFastCallerCallback(CrawlFrame* frame, VOID* data) static thread_local int8_t alreadyFailing = 0; -extern "C" QCallExceptionStatus QCALLTYPE Environment_FailFast(QCall::StackCrawlMarkHandle mark, PCWSTR message, QCall::ObjectHandleOnStack exception, PCWSTR errorSource) +extern "C" void QCALLTYPE Environment_FailFast(QCall::StackCrawlMarkHandle mark, PCWSTR message, QCall::ObjectHandleOnStack exception, PCWSTR errorSource, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1576,22 +1577,22 @@ extern "C" QCallExceptionStatus QCALLTYPE Environment_FailFast(QCall::StackCrawl // // ObjectNative // -extern "C" QCallExceptionStatus QCALLTYPE ObjectNative_GetHashCodeSlow(QCall::ObjectHandleOnStack objHandle, INT32* pReturnValue) +extern "C" INT32 QCALLTYPE ObjectNative_GetHashCodeSlow(QCall::ObjectHandleOnStack objHandle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - INT32 idx = 0; + BEGIN_QCALL; + GCX_COOP(); _ASSERTE(objHandle.Get() != NULL); idx = objHandle.Get()->GetHashCodeEx(); - *pReturnValue = idx; - END_QCALL; + + return idx; } FCIMPL1(INT32, ObjectNative::TryGetHashCode, Object* obj) @@ -1627,7 +1628,7 @@ FCIMPL2(FC_BOOL_RET, ObjectNative::ContentEquals, Object *pThisRef, Object *pCom } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE ObjectNative_AllocateUninitializedClone(QCall::ObjectHandleOnStack objHandle) +extern "C" void QCALLTYPE ObjectNative_AllocateUninitializedClone(QCall::ObjectHandleOnStack objHandle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1843,22 +1844,22 @@ BOOL CanCompareBitsOrUseFastGetHashCode(MethodTable* mt) return canCompareBitsOrUseFastGetHashCode; } -extern "C" QCallExceptionStatus QCALLTYPE MethodTable_CanCompareBitsOrUseFastGetHashCode(MethodTable* mt, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE MethodTable_CanCompareBitsOrUseFastGetHashCode(MethodTable* mt, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - BOOL ret = FALSE; + BEGIN_QCALL; + if (mt->GetClass()->IsInlineArray()) COMPlusThrow(kNotSupportedException, W("NotSupported_InlineArrayEqualsGetHashCode")); ret = CanCompareBitsOrUseFastGetHashCode(mt); - *pReturnValue = ret; - END_QCALL; + + return ret; } enum ValueTypeHashCodeStrategy @@ -1962,7 +1963,7 @@ static ValueTypeHashCodeStrategy GetHashCodeStrategy(MethodTable* mt, QCall::Obj return ret; } -extern "C" QCallExceptionStatus QCALLTYPE ValueType_GetHashCodeStrategy(MethodTable* mt, QCall::ObjectHandleOnStack objHandle, UINT32* fieldOffset, UINT32* fieldSize, MethodTable** fieldMT, INT32* pReturnValue) +extern "C" INT32 QCALLTYPE ValueType_GetHashCodeStrategy(MethodTable* mt, QCall::ObjectHandleOnStack objHandle, UINT32* fieldOffset, UINT32* fieldSize, MethodTable** fieldMT, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1970,15 +1971,15 @@ extern "C" QCallExceptionStatus QCALLTYPE ValueType_GetHashCodeStrategy(MethodTa *fieldSize = 0; *fieldMT = NULL; - BEGIN_QCALL; - ValueTypeHashCodeStrategy ret = ValueTypeHashCodeStrategy::None; - ret = GetHashCodeStrategy(mt, objHandle, fieldOffset, fieldSize, fieldMT); + BEGIN_QCALL; - *pReturnValue = ret; + ret = GetHashCodeStrategy(mt, objHandle, fieldOffset, fieldSize, fieldMT); END_QCALL; + + return ret; } FCIMPL1(UINT32, MethodTableNative::GetNumInstanceFieldBytes, MethodTable* mt) @@ -2024,29 +2025,29 @@ FCIMPL1(OBJECTHANDLE, MethodTableNative::GetLoaderAllocatorHandle, MethodTable * } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE MethodTable_AreTypesEquivalent(MethodTable* mta, MethodTable* mtb, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE MethodTable_AreTypesEquivalent(MethodTable* mta, MethodTable* mtb, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - BOOL bResult = FALSE; - bResult = mta->IsEquivalentTo(mtb); + BEGIN_QCALL; - *pReturnValue = bResult; + bResult = mta->IsEquivalentTo(mtb); END_QCALL; + + return bResult; } -extern "C" QCallExceptionStatus QCALLTYPE TypeHandle_CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE TypeHandle_CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - BOOL ret = false; + BEGIN_QCALL; + // Cache lookup and trivial cases are already handled at managed side. Call the uncached versions directly. _ASSERTE(fromTypeHnd != toTypeHnd); @@ -2064,9 +2065,9 @@ extern "C" QCallExceptionStatus QCALLTYPE TypeHandle_CanCastTo_NoCacheLookup(voi ret = fromTH.AsMethodTable()->CanCastTo(toTH.AsMethodTable(), NULL); } - *pReturnValue = ret; - END_QCALL; + + return ret; } extern "C" INT32 QCALLTYPE TypeHandle_GetCorElementType(void* typeHnd) @@ -2097,16 +2098,16 @@ static bool HasOverriddenStreamMethod(MethodTable* streamMT, MethodTable* pMT, W return NonVirtualEntry2MethodDesc(actual) != NonVirtualEntry2MethodDesc(base); } -extern "C" QCallExceptionStatus QCALLTYPE Stream_HasOverriddenSlow(MethodTable* pMT, BOOL isRead, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE Stream_HasOverriddenSlow(MethodTable* pMT, BOOL isRead, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(pMT != NULL); - BEGIN_QCALL; - BOOL readOverride = FALSE; BOOL writeOverride = FALSE; + BEGIN_QCALL; + MethodTable* pStreamMT = CoreLibBinder::GetClass(CLASS__STREAM); WORD slotBeginRead = CoreLibBinder::GetMethod(METHOD__STREAM__BEGIN_READ)->GetSlot(); WORD slotEndRead = CoreLibBinder::GetMethod(METHOD__STREAM__END_READ)->GetSlot(); @@ -2118,7 +2119,7 @@ extern "C" QCallExceptionStatus QCALLTYPE Stream_HasOverriddenSlow(MethodTable* writeOverride = HasOverriddenStreamMethod(pStreamMT, pMT, slotBeginWrite) || HasOverriddenStreamMethod(pStreamMT, pMT, slotEndWrite); pMT->GetAuxiliaryDataForWrite()->SetStreamOverrideState(readOverride, writeOverride); - *pReturnValue = isRead ? readOverride : writeOverride; - END_QCALL; + + return isRead ? readOverride : writeOverride; } diff --git a/src/coreclr/vm/comutilnative.h b/src/coreclr/vm/comutilnative.h index f6c65fa4121457..e68ede7b519e0b 100644 --- a/src/coreclr/vm/comutilnative.h +++ b/src/coreclr/vm/comutilnative.h @@ -48,30 +48,32 @@ class ExceptionNative FCDECL0(static UINT32, GetExceptionCount); }; -extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_GetFrozenStackTrace(QCall::ObjectHandleOnStack exception, QCall::ObjectHandleOnStack ret); +extern "C" void QCALLTYPE ExceptionNative_GetFrozenStackTrace(QCall::ObjectHandleOnStack exception, QCall::ObjectHandleOnStack ret, QCallExceptionStatus* qcallError); enum class ExceptionMessageKind { ThreadAbort = 1, ThreadInterrupted = 2, OutOfMemory = 3 }; -extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_GetMessageFromNativeResources(ExceptionMessageKind kind, QCall::StringHandleOnStack retMesg); +extern "C" void QCALLTYPE ExceptionNative_GetMessageFromNativeResources(ExceptionMessageKind kind, QCall::StringHandleOnStack retMesg, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_GetMethodFromStackTrace(QCall::ObjectHandleOnStack array, QCall::ObjectHandleOnStack retMethodInfo); +extern "C" void QCALLTYPE ExceptionNative_GetMethodFromStackTrace(QCall::ObjectHandleOnStack array, QCall::ObjectHandleOnStack retMethodInfo, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowAmbiguousResolutionException( +extern "C" void QCALLTYPE ExceptionNative_ThrowAmbiguousResolutionException( MethodTable* pTargetClass, MethodTable* pInterfaceMT, - MethodDesc* pInterfaceMD); + MethodDesc* pInterfaceMD, + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowEntryPointNotFoundException( +extern "C" void QCALLTYPE ExceptionNative_ThrowEntryPointNotFoundException( MethodTable* pTargetClass, MethodTable* pInterfaceMT, - MethodDesc* pInterfaceMD); + MethodDesc* pInterfaceMD, + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowMethodAccessException(MethodDesc* caller, MethodDesc* callee); -extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowFieldAccessException(MethodDesc* caller, FieldDesc* callee); -extern "C" QCallExceptionStatus QCALLTYPE ExceptionNative_ThrowClassAccessException(MethodDesc* caller, EnregisteredTypeHandle callee); +extern "C" void QCALLTYPE ExceptionNative_ThrowMethodAccessException(MethodDesc* caller, MethodDesc* callee, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ExceptionNative_ThrowFieldAccessException(MethodDesc* caller, FieldDesc* callee, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ExceptionNative_ThrowClassAccessException(MethodDesc* caller, EnregisteredTypeHandle callee, QCallExceptionStatus* qcallError); // // Buffer @@ -191,42 +193,42 @@ class GCInterface { NOINLINE static void GarbageCollectModeAny(int generation); }; -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_GetTotalAllocatedBytesPrecise(INT64* pReturnValue); +extern "C" INT64 QCALLTYPE GCInterface_GetTotalAllocatedBytesPrecise(QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_AllocateNewArray(void* typeHandlePtr, INT32 length, INT32 flags, QCall::ObjectHandleOnStack ret); +extern "C" void QCALLTYPE GCInterface_AllocateNewArray(void* typeHandlePtr, INT32 length, INT32 flags, QCall::ObjectHandleOnStack ret, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_GetTotalMemory(INT64* pReturnValue); +extern "C" INT64 QCALLTYPE GCInterface_GetTotalMemory(QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_Collect(INT32 generation, INT32 mode, CLR_BOOL lowMemoryPressure); +extern "C" void QCALLTYPE GCInterface_Collect(INT32 generation, INT32 mode, CLR_BOOL lowMemoryPressure, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_GetNextFinalizableObject(QCall::ObjectHandleOnStack pObj, void** pReturnValue); +extern "C" void* QCALLTYPE GCInterface_GetNextFinalizableObject(QCall::ObjectHandleOnStack pObj, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_WaitForPendingFinalizers(); -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_RegisterFrozenSegment(void *pSection, SIZE_T sizeSection, void** pReturnValue); +extern "C" void QCALLTYPE GCInterface_WaitForPendingFinalizers(QCallExceptionStatus* qcallError); +extern "C" void* QCALLTYPE GCInterface_RegisterFrozenSegment(void *pSection, SIZE_T sizeSection, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_UnregisterFrozenSegment(void *segmentHandle); +extern "C" void QCALLTYPE GCInterface_UnregisterFrozenSegment(void *segmentHandle, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_WaitForFullGCApproach(int millisecondsTimeout, int* pReturnValue); +extern "C" int QCALLTYPE GCInterface_WaitForFullGCApproach(int millisecondsTimeout, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_WaitForFullGCComplete(int millisecondsTimeout, int* pReturnValue); +extern "C" int QCALLTYPE GCInterface_WaitForFullGCComplete(int millisecondsTimeout, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_StartNoGCRegion(INT64 totalSize, BOOL lohSizeKnown, INT64 lohSize, BOOL disallowFullBlockingGC, int* pReturnValue); +extern "C" int QCALLTYPE GCInterface_StartNoGCRegion(INT64 totalSize, BOOL lohSizeKnown, INT64 lohSize, BOOL disallowFullBlockingGC, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_EndNoGCRegion(int* pReturnValue); +extern "C" int QCALLTYPE GCInterface_EndNoGCRegion(QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_AddMemoryPressure(UINT64 bytesAllocated); +extern "C" void QCALLTYPE GCInterface_AddMemoryPressure(UINT64 bytesAllocated, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_RemoveMemoryPressure(UINT64 bytesAllocated); +extern "C" void QCALLTYPE GCInterface_RemoveMemoryPressure(UINT64 bytesAllocated, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_ReRegisterForFinalize(QCall::ObjectHandleOnStack pObj); +extern "C" void QCALLTYPE GCInterface_ReRegisterForFinalize(QCall::ObjectHandleOnStack pObj, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_EnumerateConfigurationValues(void* configurationContext, EnumerateConfigurationValuesCallback callback); +extern "C" void QCALLTYPE GCInterface_EnumerateConfigurationValues(void* configurationContext, EnumerateConfigurationValuesCallback callback, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_RefreshMemoryLimit(GCHeapHardLimitInfo heapHardLimitInfo, int* pReturnValue); +extern "C" int QCALLTYPE GCInterface_RefreshMemoryLimit(GCHeapHardLimitInfo heapHardLimitInfo, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, INT64 totalSize, enable_no_gc_region_callback_status* pReturnValue); +extern "C" enable_no_gc_region_callback_status QCALLTYPE GCInterface_EnableNoGCRegionCallback(NoGCRegionCallbackFinalizerWorkItem* callback, INT64 totalSize, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE GCInterface_GetGenerationBudget(int generation, uint64_t* pReturnValue); +extern "C" uint64_t QCALLTYPE GCInterface_GetGenerationBudget(int generation, QCallExceptionStatus* qcallError); // // EnvironmentNative @@ -239,18 +241,18 @@ class EnvironmentNative FCDECL0(static INT32, GetExitCode); }; -extern "C" QCallExceptionStatus QCALLTYPE Environment_Exit(INT32 exitcode); +extern "C" void QCALLTYPE Environment_Exit(INT32 exitcode, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE Environment_FailFast(QCall::StackCrawlMarkHandle mark, PCWSTR message, QCall::ObjectHandleOnStack exception, PCWSTR errorSource); +extern "C" void QCALLTYPE Environment_FailFast(QCall::StackCrawlMarkHandle mark, PCWSTR message, QCall::ObjectHandleOnStack exception, PCWSTR errorSource, QCallExceptionStatus* qcallError); // Returns the number of logical processors that can be used by managed code -extern "C" QCallExceptionStatus QCALLTYPE Environment_GetProcessorCount(INT32* pReturnValue); +extern "C" INT32 QCALLTYPE Environment_GetProcessorCount(QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE GetTypeLoadExceptionMessage(UINT32 resId, QCall::StringHandleOnStack retString); +extern "C" void QCALLTYPE GetTypeLoadExceptionMessage(UINT32 resId, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE GetFileLoadExceptionMessage(UINT32 hr, QCall::StringHandleOnStack retString); +extern "C" void QCALLTYPE GetFileLoadExceptionMessage(UINT32 hr, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE FileLoadException_GetMessageForHR(UINT32 hresult, QCall::StringHandleOnStack retString); +extern "C" void QCALLTYPE FileLoadException_GetMessageForHR(UINT32 hresult, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); class ObjectNative { @@ -259,8 +261,8 @@ class ObjectNative FCDECL2(static FC_BOOL_RET, ContentEquals, Object *pThisRef, Object *pCompareRef); }; -extern "C" QCallExceptionStatus QCALLTYPE ObjectNative_GetHashCodeSlow(QCall::ObjectHandleOnStack objHandle, INT32* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE ObjectNative_AllocateUninitializedClone(QCall::ObjectHandleOnStack objHandle); +extern "C" INT32 QCALLTYPE ObjectNative_GetHashCodeSlow(QCall::ObjectHandleOnStack objHandle, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ObjectNative_AllocateUninitializedClone(QCall::ObjectHandleOnStack objHandle, QCallExceptionStatus* qcallError); class COMInterlocked { @@ -284,14 +286,14 @@ class MethodTableNative { FCDECL1(static OBJECTHANDLE, GetLoaderAllocatorHandle, MethodTable* mt); }; -extern "C" QCallExceptionStatus QCALLTYPE MethodTable_AreTypesEquivalent(MethodTable* mta, MethodTable* mtb, BOOL* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE MethodTable_CanCompareBitsOrUseFastGetHashCode(MethodTable* mt, BOOL* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE TypeHandle_CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd, BOOL* pReturnValue); +extern "C" BOOL QCALLTYPE MethodTable_AreTypesEquivalent(MethodTable* mta, MethodTable* mtb, QCallExceptionStatus* qcallError); +extern "C" BOOL QCALLTYPE MethodTable_CanCompareBitsOrUseFastGetHashCode(MethodTable* mt, QCallExceptionStatus* qcallError); +extern "C" BOOL QCALLTYPE TypeHandle_CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd, QCallExceptionStatus* qcallError); extern "C" INT32 QCALLTYPE TypeHandle_GetCorElementType(void* typeHnd); -extern "C" QCallExceptionStatus QCALLTYPE ValueType_GetHashCodeStrategy(MethodTable* mt, QCall::ObjectHandleOnStack objHandle, UINT32* fieldOffset, UINT32* fieldSize, MethodTable** fieldMT, INT32* pReturnValue); +extern "C" INT32 QCALLTYPE ValueType_GetHashCodeStrategy(MethodTable* mt, QCall::ObjectHandleOnStack objHandle, UINT32* fieldOffset, UINT32* fieldSize, MethodTable** fieldMT, QCallExceptionStatus* qcallError); BOOL CanCompareBitsOrUseFastGetHashCode(MethodTable* mt); -extern "C" QCallExceptionStatus QCALLTYPE Stream_HasOverriddenSlow(MethodTable* pMT, BOOL isRead, BOOL* pReturnValue); +extern "C" BOOL QCALLTYPE Stream_HasOverriddenSlow(MethodTable* pMT, BOOL isRead, QCallExceptionStatus* qcallError); #endif // _COMUTILNATIVE_H_ diff --git a/src/coreclr/vm/coreassemblyspec.cpp b/src/coreclr/vm/coreassemblyspec.cpp index 3e00bd69e6a722..30d16fcd2196a3 100644 --- a/src/coreclr/vm/coreassemblyspec.cpp +++ b/src/coreclr/vm/coreassemblyspec.cpp @@ -184,7 +184,7 @@ void BaseAssemblySpec::Init(SString& assemblyDisplayName) parseAsAssemblySpec.InvokeThrowing(pAssemblyDisplayName, (void*)this); } -extern "C" QCallExceptionStatus QCALLTYPE AssemblyName_InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, BaseAssemblySpec* pAssemblySpec) +extern "C" void QCALLTYPE AssemblyName_InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, BaseAssemblySpec* pAssemblySpec, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/customattribute.cpp b/src/coreclr/vm/customattribute.cpp index d179e1c274bc69..8896cf37f7a3b6 100644 --- a/src/coreclr/vm/customattribute.cpp +++ b/src/coreclr/vm/customattribute.cpp @@ -897,14 +897,15 @@ extern "C" BOOL QCALLTYPE CustomAttribute_ParseAttributeUsageAttribute( return TRUE; } -extern "C" QCallExceptionStatus QCALLTYPE CustomAttribute_CreateCustomAttributeInstance( +extern "C" void QCALLTYPE CustomAttribute_CreateCustomAttributeInstance( QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack pCaType, QCall::ObjectHandleOnStack pMethod, BYTE** ppBlob, BYTE* pEndBlob, INT32* pcNamedArgs, - QCall::ObjectHandleOnStack result) + QCall::ObjectHandleOnStack result, + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1026,14 +1027,15 @@ extern "C" QCallExceptionStatus QCALLTYPE CustomAttribute_CreateCustomAttributeI END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE CustomAttribute_CreatePropertyOrFieldData( +extern "C" void QCALLTYPE CustomAttribute_CreatePropertyOrFieldData( QCall::ModuleHandle pModule, BYTE** ppBlobStart, BYTE* pBlobEnd, QCall::StringHandleOnStack pName, BOOL* pbIsProperty, QCall::ObjectHandleOnStack pType, - QCall::ObjectHandleOnStack pValue) + QCall::ObjectHandleOnStack pValue, + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/customattribute.h b/src/coreclr/vm/customattribute.h index 3b647364a5e1c1..210cd238d85f07 100644 --- a/src/coreclr/vm/customattribute.h +++ b/src/coreclr/vm/customattribute.h @@ -30,22 +30,24 @@ extern "C" BOOL QCALLTYPE CustomAttribute_ParseAttributeUsageAttribute( BOOL* pAllowMultiple, BOOL* pInherited); -extern "C" QCallExceptionStatus QCALLTYPE CustomAttribute_CreateCustomAttributeInstance( +extern "C" void QCALLTYPE CustomAttribute_CreateCustomAttributeInstance( QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack pCaType, QCall::ObjectHandleOnStack pMethod, BYTE** ppBlob, BYTE* pEndBlob, INT32* pcNamedArgs, - QCall::ObjectHandleOnStack result); + QCall::ObjectHandleOnStack result, + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE CustomAttribute_CreatePropertyOrFieldData( +extern "C" void QCALLTYPE CustomAttribute_CreatePropertyOrFieldData( QCall::ModuleHandle pModule, BYTE** ppBlobStart, BYTE* pBlobEnd, QCall::StringHandleOnStack pName, BOOL* pbIsProperty, QCall::ObjectHandleOnStack pType, - QCall::ObjectHandleOnStack value); + QCall::ObjectHandleOnStack value, + QCallExceptionStatus* qcallError); #endif // _CUSTOMATTRIBUTE_H_ diff --git a/src/coreclr/vm/debugdebugger.cpp b/src/coreclr/vm/debugdebugger.cpp index 808ab698da09b9..500560c8284927 100644 --- a/src/coreclr/vm/debugdebugger.cpp +++ b/src/coreclr/vm/debugdebugger.cpp @@ -38,7 +38,7 @@ // Else if a native debugger is attached, this should send a native break event (kernel32!DebugBreak) // Else, this should invoke Watson. // -extern "C" QCallExceptionStatus QCALLTYPE DebugDebugger_Break() +extern "C" void QCALLTYPE DebugDebugger_Break(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -81,7 +81,7 @@ extern "C" QCallExceptionStatus QCALLTYPE DebugDebugger_Break() END_QCALL; #else - return QCallExceptionStatus(); + *qcallError = 0; #endif // DEBUGGING_SUPPORTED } @@ -291,9 +291,10 @@ static void GetStackFrames(DebugStackTrace::GetStackFramesData *pData) } } -extern "C" QCallExceptionStatus QCALLTYPE AsyncHelpers_AddContinuationToExInternal( +extern "C" void QCALLTYPE AsyncHelpers_AddContinuationToExInternal( void* diagnosticIP, - QCall::ObjectHandleOnStack exception) + QCall::ObjectHandleOnStack exception, + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -318,10 +319,11 @@ extern "C" QCallExceptionStatus QCALLTYPE AsyncHelpers_AddContinuationToExIntern END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE StackTrace_GetStackFramesInternal( +extern "C" void QCALLTYPE StackTrace_GetStackFramesInternal( QCall::ObjectHandleOnStack stackFrameHelper, BOOL fNeedFileInfo, - QCall::ObjectHandleOnStack exception) + QCall::ObjectHandleOnStack exception, + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -824,14 +826,14 @@ extern "C" QCallExceptionStatus QCALLTYPE StackTrace_GetStackFramesInternal( END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE StackFrame_GetMethodDescFromNativeIP(LPVOID ip, MethodDesc** pReturnValue) +extern "C" MethodDesc* QCALLTYPE StackFrame_GetMethodDescFromNativeIP(LPVOID ip, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - MethodDesc* pResult = nullptr; + BEGIN_QCALL; + // TODO: There is a race for dynamic and collectible methods here between getting // the MethodDesc here and when the managed wrapper converts it into a MethodBase // where the method could be collected. @@ -841,9 +843,9 @@ extern "C" QCallExceptionStatus QCALLTYPE StackFrame_GetMethodDescFromNativeIP(L pResult = codeInfo.GetMethodDesc(); } - *pReturnValue = pResult; - END_QCALL; + + return pResult; } struct StrongHandleHolderTraits final @@ -863,7 +865,7 @@ using StrongHandleHolder = LifetimeHolder; // receives a custom notification object from the target and sends it to the RS via // code:Debugger::SendCustomDebuggerNotification // Argument: dataUNSAFE - a pointer the custom notification object being sent -extern "C" QCallExceptionStatus QCALLTYPE DebugDebugger_CustomNotification(QCall::ObjectHandleOnStack data) +extern "C" void QCALLTYPE DebugDebugger_CustomNotification(QCall::ObjectHandleOnStack data, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -871,7 +873,8 @@ extern "C" QCallExceptionStatus QCALLTYPE DebugDebugger_CustomNotification(QCall // Send notification only if the debugger is attached if (!CORDebuggerAttached()) { - return QCallExceptionStatus(); + *qcallError = 0; + return; } BEGIN_QCALL; @@ -898,7 +901,7 @@ extern "C" QCallExceptionStatus QCALLTYPE DebugDebugger_CustomNotification(QCall END_QCALL; #else - return QCallExceptionStatus(); + *qcallError = 0; #endif // DEBUGGING_SUPPORTED } diff --git a/src/coreclr/vm/debugdebugger.h b/src/coreclr/vm/debugdebugger.h index c4015a4ff73602..d8d6cbc3f927df 100644 --- a/src/coreclr/vm/debugdebugger.h +++ b/src/coreclr/vm/debugdebugger.h @@ -13,10 +13,10 @@ #define __DEBUG_DEBUGGER_h__ #include -extern "C" QCallExceptionStatus QCALLTYPE DebugDebugger_Break(); +extern "C" void QCALLTYPE DebugDebugger_Break(QCallExceptionStatus* qcallError); extern "C" BOOL QCALLTYPE DebugDebugger_Launch(); extern "C" void QCALLTYPE DebugDebugger_Log(INT32 Level, PCWSTR pwzModule, PCWSTR pwzMessage); -extern "C" QCallExceptionStatus QCALLTYPE DebugDebugger_CustomNotification(QCall::ObjectHandleOnStack data); +extern "C" void QCALLTYPE DebugDebugger_CustomNotification(QCall::ObjectHandleOnStack data, QCallExceptionStatus* qcallError); extern "C" BOOL QCALLTYPE DebugDebugger_IsLoggingHelper(); extern "C" BOOL QCALLTYPE DebugDebugger_IsManagedDebuggerAttached(); @@ -130,16 +130,18 @@ class DebugStackTrace static void GetStackFramesFromException(OBJECTREF * e, GetStackFramesData *pData, PTRARRAYREF * pDynamicMethodArray = NULL); }; -extern "C" QCallExceptionStatus QCALLTYPE StackTrace_GetStackFramesInternal( +extern "C" void QCALLTYPE StackTrace_GetStackFramesInternal( QCall::ObjectHandleOnStack stackFrameHelper, BOOL fNeedFileInfo, - QCall::ObjectHandleOnStack exception); + QCall::ObjectHandleOnStack exception, + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE AsyncHelpers_AddContinuationToExInternal( +extern "C" void QCALLTYPE AsyncHelpers_AddContinuationToExInternal( void* diagnosticIP, - QCall::ObjectHandleOnStack exception); + QCall::ObjectHandleOnStack exception, + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE StackFrame_GetMethodDescFromNativeIP(LPVOID ip, MethodDesc** pReturnValue); +extern "C" MethodDesc* QCALLTYPE StackFrame_GetMethodDescFromNativeIP(LPVOID ip, QCallExceptionStatus* qcallError); class ILToNativeMapArrays diff --git a/src/coreclr/vm/eventpipeinternal.cpp b/src/coreclr/vm/eventpipeinternal.cpp index 06dcdbeae9b07a..5a2dc9933c800c 100644 --- a/src/coreclr/vm/eventpipeinternal.cpp +++ b/src/coreclr/vm/eventpipeinternal.cpp @@ -14,30 +14,29 @@ #ifdef FEATURE_PERFTRACING -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_Enable( +extern "C" UINT64 QCALLTYPE EventPipeInternal_Enable( _In_z_ LPCWSTR outputFile, EventPipeSerializationFormat format, UINT32 circularBufferSizeInMB, /* COR_PRF_EVENTPIPE_PROVIDER_CONFIG */ LPCVOID pProviders, UINT32 numProviders, - UINT64* pReturnValue) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; + UINT64 sessionID = 0; + // Invalid input! if (circularBufferSizeInMB == 0 || format >= EP_SERIALIZATION_FORMAT_COUNT || numProviders == 0 || pProviders == nullptr) { - *pReturnValue = 0; - return QCallExceptionStatus(); + *qcallError = 0; + return 0; } BEGIN_QCALL; - - UINT64 sessionID = 0; - { EventPipeProviderConfigurationAdapter configAdapter(reinterpret_cast(pProviders), numProviders); sessionID = EventPipeAdapter::Enable( @@ -55,12 +54,12 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_Enable( EventPipeAdapter::StartStreaming(sessionID); } } - *pReturnValue = sessionID; - END_QCALL; + + return sessionID; } -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_Disable(UINT64 sessionID) +extern "C" void QCALLTYPE EventPipeInternal_Disable(UINT64 sessionID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -69,14 +68,14 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_Disable(UINT64 sessi END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_GetSessionInfo(UINT64 sessionID, EventPipeSessionInfo *pSessionInfo, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE EventPipeInternal_GetSessionInfo(UINT64 sessionID, EventPipeSessionInfo *pSessionInfo, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - bool retVal = false; + BEGIN_QCALL; + if (pSessionInfo != NULL) { EventPipeSession *pSession = EventPipeAdapter::GetSession(sessionID); @@ -89,16 +88,15 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_GetSessionInfo(UINT6 } } - *pReturnValue = retVal; - END_QCALL; + return retVal; } -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_CreateProvider( +extern "C" INT_PTR QCALLTYPE EventPipeInternal_CreateProvider( _In_z_ LPCWSTR providerName, EventPipeCallback pCallbackFunc, void* pCallbackContext, - INT_PTR* pReturnValue) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -108,12 +106,12 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_CreateProvider( pProvider = EventPipeAdapter::CreateProvider(providerName, pCallbackFunc, pCallbackContext); - *pReturnValue = reinterpret_cast(pProvider); - END_QCALL; + + return reinterpret_cast(pProvider); } -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_DefineEvent( +extern "C" INT_PTR QCALLTYPE EventPipeInternal_DefineEvent( INT_PTR provHandle, UINT32 eventID, int64_t keywords, @@ -121,7 +119,7 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_DefineEvent( UINT32 level, void *pMetadata, UINT32 metadataLength, - INT_PTR* pReturnValue) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -134,12 +132,12 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_DefineEvent( pEvent = EventPipeAdapter::AddEvent(pProvider, eventID, keywords, eventVersion, (EventPipeEventLevel)level, /* needStack = */ true, (BYTE *)pMetadata, metadataLength); _ASSERTE(pEvent != NULL); - *pReturnValue = reinterpret_cast(pEvent); - END_QCALL; + + return reinterpret_cast(pEvent); } -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_GetProvider(_In_z_ LPCWSTR providerName, INT_PTR* pReturnValue) +extern "C" INT_PTR QCALLTYPE EventPipeInternal_GetProvider(_In_z_ LPCWSTR providerName, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -149,12 +147,12 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_GetProvider(_In_z_ L pProvider = EventPipeAdapter::GetProvider(providerName); - *pReturnValue = reinterpret_cast(pProvider); - END_QCALL; + + return reinterpret_cast(pProvider); } -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_DeleteProvider(INT_PTR provHandle) +extern "C" void QCALLTYPE EventPipeInternal_DeleteProvider(INT_PTR provHandle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -168,15 +166,15 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_DeleteProvider(INT_P END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_EventActivityIdControl(uint32_t controlCode, GUID *pActivityId, int* pReturnValue) +extern "C" int QCALLTYPE EventPipeInternal_EventActivityIdControl(uint32_t controlCode, GUID *pActivityId, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - int retVal = 0; + BEGIN_QCALL; + Thread *pThread = GetThreadNULLOk(); if (pThread == NULL || pActivityId == NULL) { @@ -222,17 +220,17 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_EventActivityIdContr } } - *pReturnValue = retVal; - END_QCALL; + return retVal; } -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_WriteEventData( +extern "C" void QCALLTYPE EventPipeInternal_WriteEventData( INT_PTR eventHandle, EventData *pEventData, UINT32 eventDataCount, LPCGUID pActivityId, - LPCGUID pRelatedActivityId) + LPCGUID pRelatedActivityId, + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -244,7 +242,7 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_WriteEventData( END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_GetNextEvent(UINT64 sessionID, EventPipeEventInstanceData *pInstance, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE EventPipeInternal_GetNextEvent(UINT64 sessionID, EventPipeEventInstanceData *pInstance, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -266,39 +264,36 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_GetNextEvent(UINT64 pInstance->PayloadLength = EventPipeAdapter::GetEventDataLen(pNextInstance); } - *pReturnValue = pNextInstance != NULL; - END_QCALL; + return pNextInstance != NULL; } -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_SignalSession(UINT64 sessionID, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE EventPipeInternal_SignalSession(UINT64 sessionID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - bool result = false; - result = EventPipeAdapter::SignalSession(sessionID); + BEGIN_QCALL; - *pReturnValue = result; + result = EventPipeAdapter::SignalSession(sessionID); END_QCALL; + return result; } -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_WaitForSessionSignal(UINT64 sessionID, INT32 timeoutMs, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE EventPipeInternal_WaitForSessionSignal(UINT64 sessionID, INT32 timeoutMs, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - bool result = false; - result = EventPipeAdapter::WaitForSessionSignal(sessionID, timeoutMs); + BEGIN_QCALL; - *pReturnValue = result; + result = EventPipeAdapter::WaitForSessionSignal(sessionID, timeoutMs); END_QCALL; + return result; } #endif // FEATURE_PERFTRACING diff --git a/src/coreclr/vm/eventpipeinternal.h b/src/coreclr/vm/eventpipeinternal.h index 723e35842706d9..09cb9acedaca28 100644 --- a/src/coreclr/vm/eventpipeinternal.h +++ b/src/coreclr/vm/eventpipeinternal.h @@ -39,28 +39,28 @@ struct EventPipeSessionInfo //! //! Sets the sampling rate and enables the event pipe for the specified configuration. //! -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_Enable( +extern "C" UINT64 QCALLTYPE EventPipeInternal_Enable( _In_z_ LPCWSTR outputFile, EventPipeSerializationFormat format, UINT32 circularBufferSizeInMB, /* COR_PRF_EVENTPIPE_PROVIDER_CONFIG */ LPCVOID pProviders, UINT32 numProviders, - UINT64* pReturnValue); + QCallExceptionStatus* qcallError); //! //! Disables the specified session Id. //! -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_Disable(UINT64 sessionID); +extern "C" void QCALLTYPE EventPipeInternal_Disable(UINT64 sessionID, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_GetSessionInfo(UINT64 sessionID, EventPipeSessionInfo *pSessionInfo, BOOL* pReturnValue); +extern "C" BOOL QCALLTYPE EventPipeInternal_GetSessionInfo(UINT64 sessionID, EventPipeSessionInfo *pSessionInfo, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_CreateProvider( +extern "C" INT_PTR QCALLTYPE EventPipeInternal_CreateProvider( _In_z_ LPCWSTR providerName, EventPipeCallback pCallbackFunc, void* pCallbackContext, - INT_PTR* pReturnValue); + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_DefineEvent( +extern "C" INT_PTR QCALLTYPE EventPipeInternal_DefineEvent( INT_PTR provHandle, UINT32 eventID, int64_t keywords, @@ -68,39 +68,41 @@ extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_DefineEvent( UINT32 level, void *pMetadata, UINT32 metadataLength, - INT_PTR* pReturnValue); + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_GetProvider( +extern "C" INT_PTR QCALLTYPE EventPipeInternal_GetProvider( _In_z_ LPCWSTR providerName, - INT_PTR* pReturnValue); + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_DeleteProvider( - INT_PTR provHandle); +extern "C" void QCALLTYPE EventPipeInternal_DeleteProvider( + INT_PTR provHandle, + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_EventActivityIdControl( +extern "C" int QCALLTYPE EventPipeInternal_EventActivityIdControl( UINT32 controlCode, GUID *pActivityId, - int* pReturnValue); + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_WriteEventData( +extern "C" void QCALLTYPE EventPipeInternal_WriteEventData( INT_PTR eventHandle, EventData *pEventData, UINT32 eventDataCount, - LPCGUID pActivityId, LPCGUID pRelatedActivityId); + LPCGUID pActivityId, LPCGUID pRelatedActivityId, + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_GetNextEvent( +extern "C" BOOL QCALLTYPE EventPipeInternal_GetNextEvent( UINT64 sessionID, EventPipeEventInstanceData *pInstance, - BOOL* pReturnValue); + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_SignalSession( +extern "C" BOOL QCALLTYPE EventPipeInternal_SignalSession( UINT64 sessionID, - BOOL* pReturnValue); + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE EventPipeInternal_WaitForSessionSignal( +extern "C" BOOL QCALLTYPE EventPipeInternal_WaitForSessionSignal( UINT64 sessionID, INT32 timeoutMs, - BOOL* pReturnValue); + QCallExceptionStatus* qcallError); #endif // FEATURE_PERFTRACING diff --git a/src/coreclr/vm/excep.cpp b/src/coreclr/vm/excep.cpp index c274760bb9566a..45c7b8415a7376 100644 --- a/src/coreclr/vm/excep.cpp +++ b/src/coreclr/vm/excep.cpp @@ -4718,7 +4718,7 @@ static BOOL GetManagedFormatStringForResourceID(UINT32 resId, SString & converte //========================================================================== // Private helper for TypeLoadException. //========================================================================== -extern "C" QCallExceptionStatus QCALLTYPE GetTypeLoadExceptionMessage(UINT32 resId, QCall::StringHandleOnStack retString) +extern "C" void QCALLTYPE GetTypeLoadExceptionMessage(UINT32 resId, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -4737,7 +4737,7 @@ extern "C" QCallExceptionStatus QCALLTYPE GetTypeLoadExceptionMessage(UINT32 res // Private helper for FileLoadException and FileNotFoundException. //========================================================================== -extern "C" QCallExceptionStatus QCALLTYPE GetFileLoadExceptionMessage(UINT32 hr, QCall::StringHandleOnStack retString) +extern "C" void QCALLTYPE GetFileLoadExceptionMessage(UINT32 hr, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -4753,7 +4753,7 @@ extern "C" QCallExceptionStatus QCALLTYPE GetFileLoadExceptionMessage(UINT32 hr, //========================================================================== // Private helper for FileLoadException and FileNotFoundException. //========================================================================== -extern "C" QCallExceptionStatus QCALLTYPE FileLoadException_GetMessageForHR(UINT32 hresult, QCall::StringHandleOnStack retString) +extern "C" void QCALLTYPE FileLoadException_GetMessageForHR(UINT32 hresult, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/exceptionhandling.cpp b/src/coreclr/vm/exceptionhandling.cpp index a633564f3da0a8..cab2ea575834a2 100644 --- a/src/coreclr/vm/exceptionhandling.cpp +++ b/src/coreclr/vm/exceptionhandling.cpp @@ -3133,7 +3133,7 @@ static TADDR GetSpForDiagnosticReporting(REGDISPLAY *pRD) #endif } -extern "C" QCallExceptionStatus QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo) +extern "C" void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -3531,14 +3531,14 @@ void CallFinallyFunclet(BYTE* pHandlerIP, REGDISPLAY* pvRegDisplay, ExInfo* exIn exInfo->MakeCallbacksRelatedToHandler(false, pThread, pMD, &exInfo->m_CurrentClause, (DWORD_PTR)pHandlerIP, spForDebugger); } -extern "C" QCallExceptionStatus QCALLTYPE CallFilterFunclet(QCall::ObjectHandleOnStack exceptionObj, BYTE* pFilterIP, REGDISPLAY* pvRegDisplay, CLR_BOOL* pReturnValue) +extern "C" CLR_BOOL QCALLTYPE CallFilterFunclet(QCall::ObjectHandleOnStack exceptionObj, BYTE* pFilterIP, REGDISPLAY* pvRegDisplay, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - DWORD_PTR dwResult = 0; + BEGIN_QCALL; + MAKE_CURRENT_THREAD_AVAILABLE(); GCX_COOP(); @@ -3573,9 +3573,9 @@ extern "C" QCallExceptionStatus QCALLTYPE CallFilterFunclet(QCall::ObjectHandleO // Profiler, debugger and ETW events pExInfo->MakeCallbacksRelatedToHandler(false, pThread, pMD, &pExInfo->m_CurrentClause, (DWORD_PTR)pFilterIP, spForDebugger); - *pReturnValue = dwResult == EXCEPTION_EXECUTE_HANDLER; - END_QCALL; + + return dwResult == EXCEPTION_EXECUTE_HANDLER; } @@ -3701,23 +3701,23 @@ CLR_BOOL EHEnumNextWorker(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClause* pEHClause, return result; } -extern "C" QCallExceptionStatus QCALLTYPE EHEnumNext(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClause* pEHClause, CLR_BOOL* pReturnValue) +extern "C" CLR_BOOL QCALLTYPE EHEnumNext(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClause* pEHClause, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - CLR_BOOL result = FALSE; + BEGIN_QCALL; + MAKE_CURRENT_THREAD_AVAILABLE(); Thread* pThread = GET_THREAD(); Frame* pFrame = pThread->GetFrame(); MarkInlinedCallFrameAsEHHelperCall(pFrame); result = EHEnumNextWorker(pEHEnum, pEHClause); - *pReturnValue = result; - END_QCALL; + + return result; } extern uint32_t g_exceptionCount; @@ -4053,14 +4053,14 @@ CLR_BOOL SfiInitWorker(StackFrameIterator* pThis, CONTEXT* pStackwalkCtx, CLR_BO return result; } -extern "C" QCallExceptionStatus QCALLTYPE SfiInit(StackFrameIterator* pThis, CONTEXT* pStackwalkCtx, CLR_BOOL instructionFault, CLR_BOOL* pfIsExceptionIntercepted, CLR_BOOL* pReturnValue) +extern "C" CLR_BOOL QCALLTYPE SfiInit(StackFrameIterator* pThis, CONTEXT* pStackwalkCtx, CLR_BOOL instructionFault, CLR_BOOL* pfIsExceptionIntercepted, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - CLR_BOOL result = FALSE; + BEGIN_QCALL; + MAKE_CURRENT_THREAD_AVAILABLE(); Thread* pThread = GET_THREAD(); Frame* pFrame = pThread->GetFrame(); @@ -4068,9 +4068,9 @@ extern "C" QCallExceptionStatus QCALLTYPE SfiInit(StackFrameIterator* pThis, CON GCX_COOP(); result = SfiInitWorker(pThis, pStackwalkCtx, instructionFault, pfIsExceptionIntercepted); - *pReturnValue = result; - END_QCALL; + + return result; } static StackWalkAction MoveToNextNonSkippedFrame(StackFrameIterator* pStackFrameIterator) @@ -4375,14 +4375,14 @@ Exit:; return success; } -extern "C" QCallExceptionStatus QCALLTYPE SfiNext(StackFrameIterator* pThis, uint* uExCollideClauseIdx, CLR_BOOL* fUnwoundReversePInvoke, CLR_BOOL* pfIsExceptionIntercepted, CLR_BOOL* pReturnValue) +extern "C" CLR_BOOL QCALLTYPE SfiNext(StackFrameIterator* pThis, uint* uExCollideClauseIdx, CLR_BOOL* fUnwoundReversePInvoke, CLR_BOOL* pfIsExceptionIntercepted, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - CLR_BOOL result = FALSE; + BEGIN_QCALL; + MAKE_CURRENT_THREAD_AVAILABLE(); Thread* pThread = GET_THREAD(); Frame* pFrame = pThread->GetFrame(); @@ -4391,9 +4391,9 @@ extern "C" QCallExceptionStatus QCALLTYPE SfiNext(StackFrameIterator* pThis, uin GCX_COOP(); result = SfiNextWorker(pThis, uExCollideClauseIdx, fUnwoundReversePInvoke, pfIsExceptionIntercepted); - *pReturnValue = result; - END_QCALL; + + return result; } static uint32_t CalculateCodeOffset(PCODE pbControlPC, IJitManager::MethodRegionInfo *pMethodRegionInfo) diff --git a/src/coreclr/vm/exceptionhandlingqcalls.h b/src/coreclr/vm/exceptionhandlingqcalls.h index cfaef62e6255d1..ddb20be42aa651 100644 --- a/src/coreclr/vm/exceptionhandlingqcalls.h +++ b/src/coreclr/vm/exceptionhandlingqcalls.h @@ -9,12 +9,12 @@ struct ExInfo; #ifndef DACCESS_COMPILE -extern "C" QCallExceptionStatus QCALLTYPE CallFilterFunclet(QCall::ObjectHandleOnStack exceptionObj, BYTE* pFilterP, REGDISPLAY* pvRegDisplay, CLR_BOOL* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo); +extern "C" CLR_BOOL QCALLTYPE CallFilterFunclet(QCall::ObjectHandleOnStack exceptionObj, BYTE* pFilterP, REGDISPLAY* pvRegDisplay, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo, QCallExceptionStatus* qcallError); extern "C" CLR_BOOL QCALLTYPE EHEnumInitFromStackFrameIterator(StackFrameIterator *pFrameIter, IJitManager::MethodRegionInfo *pMethodRegionInfo, EH_CLAUSE_ENUMERATOR * pEHEnum); -extern "C" QCallExceptionStatus QCALLTYPE EHEnumNext(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClause* pEHClause, CLR_BOOL* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE SfiInit(StackFrameIterator* pThis, CONTEXT* pStackwalkCtx, CLR_BOOL instructionFault, CLR_BOOL* pIsExceptionIntercepted, CLR_BOOL* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE SfiNext(StackFrameIterator* pThis, unsigned int* uExCollideClauseIdx, CLR_BOOL* fUnwoundReversePInvoke, CLR_BOOL* pIsExceptionIntercepted, CLR_BOOL* pReturnValue); +extern "C" CLR_BOOL QCALLTYPE EHEnumNext(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClause* pEHClause, QCallExceptionStatus* qcallError); +extern "C" CLR_BOOL QCALLTYPE SfiInit(StackFrameIterator* pThis, CONTEXT* pStackwalkCtx, CLR_BOOL instructionFault, CLR_BOOL* pIsExceptionIntercepted, QCallExceptionStatus* qcallError); +extern "C" CLR_BOOL QCALLTYPE SfiNext(StackFrameIterator* pThis, unsigned int* uExCollideClauseIdx, CLR_BOOL* fUnwoundReversePInvoke, CLR_BOOL* pIsExceptionIntercepted, QCallExceptionStatus* qcallError); #endif // DACCESS_COMPILE #endif // EXCEPTION_HANDLING_QCALLS_H diff --git a/src/coreclr/vm/finalizerthread.cpp b/src/coreclr/vm/finalizerthread.cpp index 5f5dfa4fa2d7fc..67aa221972e19c 100644 --- a/src/coreclr/vm/finalizerthread.cpp +++ b/src/coreclr/vm/finalizerthread.cpp @@ -87,7 +87,7 @@ extern "C" void SystemJS_ExecuteFinalizationCallback() RunFinalizerIterationOnCurrentThread(); } #else // TARGET_WASI -extern "C" QCallExceptionStatus QCALLTYPE WasiFinalizer_RunWorker() +extern "C" void QCALLTYPE WasiFinalizer_RunWorker(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -128,22 +128,21 @@ extern "C" void WasiFinalizer_Schedule() s_finalizationPending = true; } -extern "C" QCallExceptionStatus QCALLTYPE WasiFinalizer_TryClearPending(CLR_BOOL* pReturnValue) +extern "C" CLR_BOOL QCALLTYPE WasiFinalizer_TryClearPending(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - CLR_BOOL pending = FALSE; + BEGIN_QCALL; + // Volatile load + clear. Single-threaded WASI: no atomic swap needed. pending = s_finalizationPending ? TRUE : FALSE; if (pending) { s_finalizationPending = false; } - *pReturnValue = pending; - END_QCALL; + return pending; } #endif // TARGET_WASI diff --git a/src/coreclr/vm/ilmarshalers.cpp b/src/coreclr/vm/ilmarshalers.cpp index 8287b221370a6d..5bc11efd47995e 100644 --- a/src/coreclr/vm/ilmarshalers.cpp +++ b/src/coreclr/vm/ilmarshalers.cpp @@ -4761,7 +4761,7 @@ extern "C" void QCALLTYPE MngdSafeArrayMarshaler_CreateMarshaler(MngdSafeArrayMa pThis->m_pConvertContentsToManagedCode = pConvertToManaged; } -extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome) +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -4773,7 +4773,8 @@ extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToN if (pThis->m_fStatic & MngdSafeArrayMarshaler::SCSF_IsStatic) { - return QCallExceptionStatus(); + *qcallError = 0; + return; } BEGIN_QCALL; @@ -4798,7 +4799,7 @@ extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToN END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCall::ObjectHandleOnStack pOriginalManaged) +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCall::ObjectHandleOnStack pOriginalManaged, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -4841,7 +4842,7 @@ extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ConvertContents END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome) +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -4898,7 +4899,7 @@ extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToM END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome) +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -4935,13 +4936,14 @@ extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ConvertContents END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ClearNative(MngdSafeArrayMarshaler* pThis, void** pNativeHome) +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ClearNative(MngdSafeArrayMarshaler* pThis, void** pNativeHome, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; if (pThis->m_fStatic & MngdSafeArrayMarshaler::SCSF_IsStatic) { - return QCallExceptionStatus(); + *qcallError = 0; + return; } BEGIN_QCALL; diff --git a/src/coreclr/vm/ilmarshalers.h b/src/coreclr/vm/ilmarshalers.h index f25fda74de8934..523a7e5ea87e0d 100644 --- a/src/coreclr/vm/ilmarshalers.h +++ b/src/coreclr/vm/ilmarshalers.h @@ -3465,11 +3465,11 @@ class MngdSafeArrayMarshaler }; extern "C" void QCALLTYPE MngdSafeArrayMarshaler_CreateMarshaler(MngdSafeArrayMarshaler* pThis, MethodTable* pMT, UINT32 iRank, UINT32 dwFlags, PCODE pConvertToNative, PCODE pConvertToManaged); -extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome); -extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCall::ObjectHandleOnStack pOriginalManaged); -extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome); -extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome); -extern "C" QCallExceptionStatus QCALLTYPE MngdSafeArrayMarshaler_ClearNative(MngdSafeArrayMarshaler* pThis, void** pNativeHome); +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToNative(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCall::ObjectHandleOnStack pOriginalManaged, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertSpaceToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ConvertContentsToManaged(MngdSafeArrayMarshaler* pThis, QCall::ObjectHandleOnStack pManagedHome, void** pNativeHome, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE MngdSafeArrayMarshaler_ClearNative(MngdSafeArrayMarshaler* pThis, void** pNativeHome, QCallExceptionStatus* qcallError); #endif // FEATURE_COMINTEROP class ILReferenceCustomMarshaler : public ILMngdMarshaler diff --git a/src/coreclr/vm/interoplibinterface.h b/src/coreclr/vm/interoplibinterface.h index 375689563ecff1..c9da0f7eaeeef3 100644 --- a/src/coreclr/vm/interoplibinterface.h +++ b/src/coreclr/vm/interoplibinterface.h @@ -67,24 +67,24 @@ using OBJC_TRACKING_INFO_REF = DPTR(ObjcTrackingInformationObject); #endif -extern "C" QCallExceptionStatus QCALLTYPE ObjCMarshal_TryInitializeReferenceTracker( +extern "C" BOOL QCALLTYPE ObjCMarshal_TryInitializeReferenceTracker( _In_ ObjCMarshalNative::BeginEndCallback beginEndCallback, _In_ ObjCMarshalNative::IsReferencedCallback isReferencedCallback, _In_ ObjCMarshalNative::EnteredFinalizationCallback trackedObjectEnteredFinalization, _In_ QCall::ObjectHandleOnStack objectTrackingInfoTable, - BOOL* pReturnValue); + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE ObjCMarshal_AllocateReferenceTrackingHandle(_In_ QCall::ObjectHandleOnStack obj, void** pReturnValue); +extern "C" void* QCALLTYPE ObjCMarshal_AllocateReferenceTrackingHandle(_In_ QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError); extern "C" void QCALLTYPE ObjCMarshal_GetOrCreateReferenceTrackingMemory( _In_ QCall::ObjectHandleOnStack obj, _Out_ int* memInSizeT, _Outptr_ void** mem); -extern "C" QCallExceptionStatus QCALLTYPE ObjCMarshal_TrySetGlobalMessageSendCallback( +extern "C" BOOL QCALLTYPE ObjCMarshal_TrySetGlobalMessageSendCallback( _In_ ObjCMarshalNative::MessageSendFunction msgSendFunction, _In_ void* fptr, - BOOL* pReturnValue); + QCallExceptionStatus* qcallError); #endif // FEATURE_OBJCMARSHAL @@ -96,19 +96,20 @@ class JavaNative _In_ MarkCrossReferencesArgs* args); }; -extern "C" QCallExceptionStatus QCALLTYPE JavaMarshal_Initialize( +extern "C" BOOL QCALLTYPE JavaMarshal_Initialize( _In_ void* markCrossReferences, - BOOL* pReturnValue); + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE JavaMarshal_CreateReferenceTrackingHandle( +extern "C" void* QCALLTYPE JavaMarshal_CreateReferenceTrackingHandle( _In_ QCall::ObjectHandleOnStack obj, _In_ void* context, - void** pReturnValue); + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE JavaMarshal_FinishCrossReferenceProcessing( +extern "C" void QCALLTYPE JavaMarshal_FinishCrossReferenceProcessing( _In_ MarkCrossReferencesArgs *crossReferences, _In_ size_t length, - _In_ void* unreachableObjectHandles); + _In_ void* unreachableObjectHandles, + QCallExceptionStatus* qcallError); extern "C" BOOL QCALLTYPE JavaMarshal_GetContext( _In_ OBJECTHANDLE handle, diff --git a/src/coreclr/vm/interoplibinterface_comwrappers.cpp b/src/coreclr/vm/interoplibinterface_comwrappers.cpp index 216cda7f4f8d22..1666f2f33ad9d6 100644 --- a/src/coreclr/vm/interoplibinterface_comwrappers.cpp +++ b/src/coreclr/vm/interoplibinterface_comwrappers.cpp @@ -112,23 +112,23 @@ bool GlobalComWrappersForMarshalling::TryGetOrCreateObjectForComInstance( return obj != NULL; } -extern "C" QCallExceptionStatus QCALLTYPE ComWrappers_AllocateRefCountedHandle(_In_ QCall::ObjectHandleOnStack obj, void** pReturnValue) +extern "C" void* QCALLTYPE ComWrappers_AllocateRefCountedHandle(_In_ QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - void* handle = NULL; + BEGIN_QCALL; + { GCX_COOP(); handle = GetAppDomain()->CreateTypedHandle(obj.Get(), HNDTYPE_REFCOUNTED); } - *pReturnValue = handle; - END_QCALL; + + return handle; } extern "C" void const* QCALLTYPE ComWrappers_GetIReferenceTrackerTargetVftbl() @@ -567,7 +567,7 @@ void ComWrappersNative::OnAfterGCScanRoots() (void)InteropLib::Com::DetachNonPromotedObjects(&cxt); } -extern "C" QCallExceptionStatus QCALLTYPE ComWrappers_RegisterIsRootedCallback() +extern "C" void QCALLTYPE ComWrappers_RegisterIsRootedCallback(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -579,7 +579,7 @@ extern "C" QCallExceptionStatus QCALLTYPE ComWrappers_RegisterIsRootedCallback() END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE TrackerObjectManager_RegisterNativeObjectWrapperCache(_In_ QCall::ObjectHandleOnStack cache) +extern "C" void QCALLTYPE TrackerObjectManager_RegisterNativeObjectWrapperCache(_In_ QCall::ObjectHandleOnStack cache, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/interoplibinterface_comwrappers.h b/src/coreclr/vm/interoplibinterface_comwrappers.h index 2dd7c9109c337b..61e414b1389f78 100644 --- a/src/coreclr/vm/interoplibinterface_comwrappers.h +++ b/src/coreclr/vm/interoplibinterface_comwrappers.h @@ -34,19 +34,19 @@ extern "C" void QCALLTYPE ComWrappers_GetIUnknownImpl( extern "C" void* QCALLTYPE ComWrappers_GetUntrackedAddRefRelease(); -extern "C" QCallExceptionStatus QCALLTYPE ComWrappers_AllocateRefCountedHandle(_In_ QCall::ObjectHandleOnStack obj, void** pReturnValue); +extern "C" void* QCALLTYPE ComWrappers_AllocateRefCountedHandle(_In_ QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError); extern "C" void const* QCALLTYPE ComWrappers_GetIReferenceTrackerTargetVftbl(); extern "C" void const* QCALLTYPE ComWrappers_GetTaggedImpl(); -extern "C" QCallExceptionStatus QCALLTYPE ComWrappers_RegisterIsRootedCallback(); +extern "C" void QCALLTYPE ComWrappers_RegisterIsRootedCallback(QCallExceptionStatus* qcallError); extern "C" CLR_BOOL QCALLTYPE TrackerObjectManager_HasReferenceTrackerManager(); extern "C" CLR_BOOL QCALLTYPE TrackerObjectManager_TryRegisterReferenceTrackerManager(_In_ void* manager); -extern "C" QCallExceptionStatus QCALLTYPE TrackerObjectManager_RegisterNativeObjectWrapperCache(_In_ QCall::ObjectHandleOnStack cache); +extern "C" void QCALLTYPE TrackerObjectManager_RegisterNativeObjectWrapperCache(_In_ QCall::ObjectHandleOnStack cache, QCallExceptionStatus* qcallError); extern "C" CLR_BOOL QCALLTYPE TrackerObjectManager_IsGlobalPeggingEnabled(); diff --git a/src/coreclr/vm/interoplibinterface_java.cpp b/src/coreclr/vm/interoplibinterface_java.cpp index b7abac33b1cad6..59784c08d20192 100644 --- a/src/coreclr/vm/interoplibinterface_java.cpp +++ b/src/coreclr/vm/interoplibinterface_java.cpp @@ -134,17 +134,17 @@ void Interop::FinishCrossReferenceProcessing( ReleaseGCBridgeArgumentsWorker(args); } -extern "C" QCallExceptionStatus QCALLTYPE JavaMarshal_Initialize( +extern "C" BOOL QCALLTYPE JavaMarshal_Initialize( _In_ void* markCrossReferences, - BOOL* pReturnValue) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(markCrossReferences != NULL); - BEGIN_QCALL; - BOOL success = FALSE; + BEGIN_QCALL; + // Switch to Cooperative mode since we are setting callbacks that // will be used during a GC and we want to ensure a GC isn't occurring // while they are being set. @@ -158,34 +158,35 @@ extern "C" QCallExceptionStatus QCALLTYPE JavaMarshal_Initialize( } } - *pReturnValue = success; - END_QCALL; + + return success; } -extern "C" QCallExceptionStatus QCALLTYPE JavaMarshal_CreateReferenceTrackingHandle( +extern "C" void* QCALLTYPE JavaMarshal_CreateReferenceTrackingHandle( _In_ QCall::ObjectHandleOnStack obj, _In_ void* context, - void** pReturnValue) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - OBJECTHANDLE instHandle = NULL; + BEGIN_QCALL; + GCX_COOP(); instHandle = GetAppDomain()->CreateCrossReferenceHandle(obj.Get(), context); - *pReturnValue = (void*)instHandle; - END_QCALL; + + return (void*)instHandle; } -extern "C" QCallExceptionStatus QCALLTYPE JavaMarshal_FinishCrossReferenceProcessing( +extern "C" void QCALLTYPE JavaMarshal_FinishCrossReferenceProcessing( _In_ MarkCrossReferencesArgs *crossReferences, _In_ size_t length, - _In_ void* unreachableObjectHandles) + _In_ void* unreachableObjectHandles, + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(crossReferences->ComponentCount >= 0); diff --git a/src/coreclr/vm/interoplibinterface_objc.cpp b/src/coreclr/vm/interoplibinterface_objc.cpp index 3d0397f87a1617..18330649847af3 100644 --- a/src/coreclr/vm/interoplibinterface_objc.cpp +++ b/src/coreclr/vm/interoplibinterface_objc.cpp @@ -24,22 +24,22 @@ namespace ObjCMarshalNative::EnteredFinalizationCallback g_TrackedObjectEnteredFinalizationCallback; } -extern "C" QCallExceptionStatus QCALLTYPE ObjCMarshal_TryInitializeReferenceTracker( +extern "C" BOOL QCALLTYPE ObjCMarshal_TryInitializeReferenceTracker( _In_ ObjCMarshalNative::BeginEndCallback beginEndCallback, _In_ ObjCMarshalNative::IsReferencedCallback isReferencedCallback, _In_ ObjCMarshalNative::EnteredFinalizationCallback trackedObjectEnteredFinalization, _In_ QCall::ObjectHandleOnStack objectTrackingInfoTable, - BOOL* pReturnValue) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(beginEndCallback != NULL && isReferencedCallback != NULL && trackedObjectEnteredFinalization != NULL); - BEGIN_QCALL; - BOOL success = FALSE; + BEGIN_QCALL; + // Switch to Cooperative mode since we are setting callbacks that // will be used during a GC and we want to ensure a GC isn't occurring // while they are being set. @@ -56,27 +56,27 @@ extern "C" QCallExceptionStatus QCALLTYPE ObjCMarshal_TryInitializeReferenceTrac } } - *pReturnValue = success; - END_QCALL; + + return success; } -extern "C" QCallExceptionStatus QCALLTYPE ObjCMarshal_AllocateReferenceTrackingHandle(_In_ QCall::ObjectHandleOnStack obj, void** pReturnValue) +extern "C" void* QCALLTYPE ObjCMarshal_AllocateReferenceTrackingHandle(_In_ QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - OBJECTHANDLE instHandle; + BEGIN_QCALL; + // Switch to Cooperative mode since object references // are being manipulated. GCX_COOP(); instHandle = GetAppDomain()->CreateTypedHandle(obj.Get(), HNDTYPE_REFCOUNTED); - *pReturnValue = (void*)instHandle; - END_QCALL; + + return (void*)instHandle; } namespace @@ -120,17 +120,17 @@ namespace } } -extern "C" QCallExceptionStatus QCALLTYPE ObjCMarshal_TrySetGlobalMessageSendCallback( +extern "C" BOOL QCALLTYPE ObjCMarshal_TrySetGlobalMessageSendCallback( _In_ ObjCMarshalNative::MessageSendFunction msgSendFunction, _In_ void* fptr, - BOOL* pReturnValue) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - bool success; + BEGIN_QCALL; + _ASSERTE(msgSendFunction >= 0 && msgSendFunction < ARRAY_SIZE(s_msgSendOverrides)); success = InterlockedCompareExchangeT(&s_msgSendOverrides[msgSendFunction], fptr, NULL) == NULL; @@ -138,9 +138,9 @@ extern "C" QCallExceptionStatus QCALLTYPE ObjCMarshal_TrySetGlobalMessageSendCal if (success && FALSE == InterlockedCompareExchange((LONG*)&s_msgSendOverridden, TRUE, FALSE)) PInvokeOverride::SetPInvokeOverride(&MessageSendPInvokeOverride, PInvokeOverride::Source::ObjectiveCInterop); - *pReturnValue = success ? TRUE : FALSE; - END_QCALL; + + return success ? TRUE : FALSE; } namespace diff --git a/src/coreclr/vm/jithelpers.cpp b/src/coreclr/vm/jithelpers.cpp index 53c27a6547a30a..3075ed58850c7b 100644 --- a/src/coreclr/vm/jithelpers.cpp +++ b/src/coreclr/vm/jithelpers.cpp @@ -245,7 +245,7 @@ HCIMPLEND #include // Helper for the managed InitClass implementations -extern "C" QCallExceptionStatus QCALLTYPE InitClassHelper(MethodTable* pMT) +extern "C" void QCALLTYPE InitClassHelper(MethodTable* pMT, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -318,7 +318,7 @@ __declspec(selectany) #endif // _MSC_VER PLATFORM_THREAD_LOCAL ThreadLocalData t_ThreadStatics; -extern "C" QCallExceptionStatus QCALLTYPE GetThreadStaticsByMethodTable(QCall::ByteRefOnStack refHandle, MethodTable* pMT, BOOL gcStatic) +extern "C" void QCALLTYPE GetThreadStaticsByMethodTable(QCall::ByteRefOnStack refHandle, MethodTable* pMT, BOOL gcStatic, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -339,7 +339,7 @@ extern "C" QCallExceptionStatus QCALLTYPE GetThreadStaticsByMethodTable(QCall::B END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE GetThreadStaticsByIndex(QCall::ByteRefOnStack refHandle, uint32_t staticBlockIndex, BOOL gcStatic) +extern "C" void QCALLTYPE GetThreadStaticsByIndex(QCall::ByteRefOnStack refHandle, uint32_t staticBlockIndex, BOOL gcStatic, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -473,21 +473,21 @@ BOOL ObjIsInstanceOf(Object* pObject, TypeHandle toTypeHnd, BOOL throwCastExcept return ObjIsInstanceOfCore(pObject, toTypeHnd, throwCastException); } -extern "C" QCallExceptionStatus QCALLTYPE IsInstanceOf_NoCacheLookup(EnregisteredTypeHandle type, BOOL throwCastException, QCall::ObjectHandleOnStack objOnStack, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE IsInstanceOf_NoCacheLookup(EnregisteredTypeHandle type, BOOL throwCastException, QCall::ObjectHandleOnStack objOnStack, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - BOOL result = FALSE; + BEGIN_QCALL; + GCX_COOP(); result = ObjIsInstanceOfCore(OBJECTREFToObject(objOnStack.Get()), TypeHandle::FromPtr(type), throwCastException); - *pReturnValue = result; - END_QCALL; + + return result; } //======================================================================== @@ -503,7 +503,7 @@ HCIMPL2(BOOL, JIT_IsInstanceOfException, EnregisteredTypeHandle type, Object* ob } HCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE ThrowInvalidCastException(EnregisteredTypeHandle pSourceType, EnregisteredTypeHandle pTargetType) +extern "C" void QCALLTYPE ThrowInvalidCastException(EnregisteredTypeHandle pSourceType, EnregisteredTypeHandle pTargetType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -601,19 +601,19 @@ DictionaryEntry GenericHandleWorkerCore(MethodDesc * pMD, MethodTable * pMT, LPV return result; } -extern "C" QCallExceptionStatus QCALLTYPE GenericHandleWorker(MethodDesc * pMD, MethodTable * pMT, LPVOID signature, DWORD dictionaryIndexAndSlot, Module* pModule, void** pReturnValue) +extern "C" void* QCALLTYPE GenericHandleWorker(MethodDesc * pMD, MethodTable * pMT, LPVOID signature, DWORD dictionaryIndexAndSlot, Module* pModule, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - void* result = NULL; - result = GenericHandleWorkerCore(pMD, pMT, signature, dictionaryIndexAndSlot, pModule); + BEGIN_QCALL; - *pReturnValue = result; + result = GenericHandleWorkerCore(pMD, pMT, signature, dictionaryIndexAndSlot, pModule); END_QCALL; + + return result; } // GenericHandleWorker FieldDesc* g_pVirtualFunctionPointerCache; @@ -674,18 +674,18 @@ void FlushVirtualFunctionPointerCaches() // static method signature (i.e. might be for a superclass of classHnd) // slow helper to call from the fast one -extern "C" QCallExceptionStatus QCALLTYPE ResolveVirtualFunctionPointer(QCall::ObjectHandleOnStack obj, +extern "C" PCODE QCALLTYPE ResolveVirtualFunctionPointer(QCall::ObjectHandleOnStack obj, EnregisteredTypeHandle classHnd, MethodDesc* pStaticMD, - PCODE* pReturnValue) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - // The address of the method that's returned. PCODE addr = (PCODE)NULL; + BEGIN_QCALL; + if (VolatileLoadWithoutBarrier(&g_pVirtualFunctionPointerCache) == NULL) { CoreLibBinder::GetClass(CLASS__VIRTUALDISPATCHHELPERS)->CheckRunClassInitThrowing(); @@ -742,9 +742,9 @@ extern "C" QCallExceptionStatus QCALLTYPE ResolveVirtualFunctionPointer(QCall::O } GCPROTECT_END(); - *pReturnValue = addr; - END_QCALL; + + return addr; } HCIMPL3(void, Jit_NativeMemSet, void* pDest, int value, size_t length) diff --git a/src/coreclr/vm/loaderallocator.cpp b/src/coreclr/vm/loaderallocator.cpp index caad062144634b..656a9b21624f18 100644 --- a/src/coreclr/vm/loaderallocator.cpp +++ b/src/coreclr/vm/loaderallocator.cpp @@ -757,19 +757,19 @@ BOOL LoaderAllocator::Destroy(QCall::LoaderAllocatorHandle pLoaderAllocator) return FALSE; } // LoaderAllocator::Destroy -extern "C" QCallExceptionStatus QCALLTYPE LoaderAllocator_Destroy(QCall::LoaderAllocatorHandle pLoaderAllocator, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE LoaderAllocator_Destroy(QCall::LoaderAllocatorHandle pLoaderAllocator, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - BOOL ret = FALSE; - ret = LoaderAllocator::Destroy(pLoaderAllocator); + BEGIN_QCALL; - *pReturnValue = ret; + ret = LoaderAllocator::Destroy(pLoaderAllocator); END_QCALL; + + return ret; } #define MAX_LOADERALLOCATOR_HANDLE 0x40000000 diff --git a/src/coreclr/vm/loaderallocator.hpp b/src/coreclr/vm/loaderallocator.hpp index 0ba75c0e8a6a40..5c717beebad038 100644 --- a/src/coreclr/vm/loaderallocator.hpp +++ b/src/coreclr/vm/loaderallocator.hpp @@ -960,7 +960,7 @@ struct cdac_data typedef VPTR(LoaderAllocator) PTR_LoaderAllocator; -extern "C" QCallExceptionStatus QCALLTYPE LoaderAllocator_Destroy(QCall::LoaderAllocatorHandle pLoaderAllocator, BOOL* pReturnValue); +extern "C" BOOL QCALLTYPE LoaderAllocator_Destroy(QCall::LoaderAllocatorHandle pLoaderAllocator, QCallExceptionStatus* qcallError); class GlobalLoaderAllocator : public LoaderAllocator { diff --git a/src/coreclr/vm/managedmdimport.cpp b/src/coreclr/vm/managedmdimport.cpp index c7154088656c44..e83ccc2ae32517 100644 --- a/src/coreclr/vm/managedmdimport.cpp +++ b/src/coreclr/vm/managedmdimport.cpp @@ -533,13 +533,14 @@ static void* EnsureResultSize( return p; } -extern "C" QCallExceptionStatus QCALLTYPE MetadataImport_Enum( +extern "C" void QCALLTYPE MetadataImport_Enum( IMDInternalImport* pScope, mdToken type, mdToken tkParent, /* in/out */ INT32* length, INT32* shortResult, - QCall::ObjectHandleOnStack longResult) + QCall::ObjectHandleOnStack longResult, + QCallExceptionStatus* qcallError) { CONTRACTL { diff --git a/src/coreclr/vm/managedmdimport.hpp b/src/coreclr/vm/managedmdimport.hpp index cd71a13298683b..b0d8fcf67f1ee6 100644 --- a/src/coreclr/vm/managedmdimport.hpp +++ b/src/coreclr/vm/managedmdimport.hpp @@ -72,12 +72,13 @@ extern "C" BOOL QCALLTYPE MetadataImport_GetMarshalAs( INT32* marshalCookieLength, INT32* iidParamIndex); -extern "C" QCallExceptionStatus QCALLTYPE MetadataImport_Enum( +extern "C" void QCALLTYPE MetadataImport_Enum( IMDInternalImport* pScope, mdToken type, mdToken tkParent, INT32* length, INT32* shortResult, - QCall::ObjectHandleOnStack longResult); + QCall::ObjectHandleOnStack longResult, + QCallExceptionStatus* qcallError); #endif diff --git a/src/coreclr/vm/marshalnative.cpp b/src/coreclr/vm/marshalnative.cpp index 8b37f2ee4870c1..44fbaaac59f847 100644 --- a/src/coreclr/vm/marshalnative.cpp +++ b/src/coreclr/vm/marshalnative.cpp @@ -50,7 +50,7 @@ // Prelink // Does advance loading of an PInvoke library -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_Prelink(MethodDesc * pMD) +extern "C" VOID QCALLTYPE MarshalNative_Prelink(MethodDesc * pMD, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -61,13 +61,15 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_Prelink(MethodDesc * pMD // This is a perf thing since it's always safe to execute the prestub twice. if (!pMD->ShouldCallPrestub()) { - return QCallExceptionStatus(); + *qcallError = 0; + return; } // Silently ignore if not PInvoke and not runtime generated. if (!(pMD->IsPInvoke()) && !(pMD->IsRuntimeSupplied())) { - return QCallExceptionStatus(); + *qcallError = 0; + return; } BEGIN_QCALL; @@ -81,33 +83,33 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_Prelink(MethodDesc * pMD // IsBuiltInComSupported // Built-in COM support is only checked from the native side to ensure the runtime // is in a consistent state -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_IsBuiltInComSupported(BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE MarshalNative_IsBuiltInComSupported(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - BOOL ret = TRUE; + BEGIN_QCALL; + #ifdef FEATURE_COMINTEROP ret = g_pConfig->IsBuiltInCOMSupported(); #else // FEATURE_COMINTEROP ret = FALSE; #endif // FEATURE_COMINTEROP - *pReturnValue = ret; - END_QCALL; + + return ret; } -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_HasLayout(QCall::TypeHandle t, BOOL* pIsBlittable, DWORD* pNativeSize, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE MarshalNative_HasLayout(QCall::TypeHandle t, BOOL* pIsBlittable, DWORD* pNativeSize, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - BOOL ret = FALSE; + BEGIN_QCALL; + TypeHandle th = t.AsTypeHandle(); if (th.IsEnum()) @@ -129,22 +131,22 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_HasLayout(QCall::TypeHan *pNativeSize = 0; } - *pReturnValue = ret; - END_QCALL; + + return ret; } /************************************************************************ * PInvoke.SizeOf(Class) */ -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_SizeOfHelper(QCall::TypeHandle t, BOOL throwIfNotMarshalable, INT32* pReturnValue) +extern "C" INT32 QCALLTYPE MarshalNative_SizeOfHelper(QCall::TypeHandle t, BOOL throwIfNotMarshalable, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - INT32 rv = 0; + BEGIN_QCALL; + // refClass is validated to be non-NULL RuntimeType by callers TypeHandle th = t.AsTypeHandle(); @@ -163,12 +165,11 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_SizeOfHelper(QCall::Type // The type is marshalable or we don't care so return its size. rv = th.GetMethodTable()->GetNativeSize(); - *pReturnValue = rv; - END_QCALL; + return rv; } -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_OffsetOf(FieldDesc* pFD, SIZE_T* pReturnValue) +extern "C" SIZE_T QCALLTYPE MarshalNative_OffsetOf(FieldDesc* pFD, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -215,12 +216,12 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_OffsetOf(FieldDesc* pFD, CONSISTENCY_CHECK_MSG(foundField, "We should never hit this point since we already verified that the requested field was present from managed code"); } - *pReturnValue = offset; - END_QCALL; + + return offset; } -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetDelegateForFunctionPointerInternal(PVOID FPtr, QCall::TypeHandle t, QCall::ObjectHandleOnStack retDelegate) +extern "C" void QCALLTYPE MarshalNative_GetDelegateForFunctionPointerInternal(PVOID FPtr, QCall::TypeHandle t, QCall::ObjectHandleOnStack retDelegate, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -237,20 +238,20 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetDelegateForFunctionPo END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetFunctionPointerForDelegateInternal(QCall::ObjectHandleOnStack d, PVOID* pReturnValue) +extern "C" PVOID QCALLTYPE MarshalNative_GetFunctionPointerForDelegateInternal(QCall::ObjectHandleOnStack d, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - PVOID pFPtr = NULL; + BEGIN_QCALL; + GCX_COOP(); pFPtr = COMDelegate::ConvertToCallback(d.Get()); - *pReturnValue = pFPtr; - END_QCALL; + + return pFPtr; } #ifdef _DEBUG @@ -316,20 +317,20 @@ DWORD STDMETHODCALLTYPE FalseGetLastError() * Support for the GCHandle class. */ -extern "C" QCallExceptionStatus QCALLTYPE GCHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack obj, int type, OBJECTHANDLE* pReturnValue) +extern "C" OBJECTHANDLE QCALLTYPE GCHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack obj, int type, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - OBJECTHANDLE hnd = NULL; + BEGIN_QCALL; + GCX_COOP(); hnd = GetAppDomain()->CreateTypedHandle(obj.Get(), static_cast(type)); - *pReturnValue = hnd; - END_QCALL; + + return hnd; } FCIMPL2(LPVOID, MarshalNative::GCHandleInternalAlloc, Object *obj, int type) @@ -347,7 +348,7 @@ FCIMPL2(LPVOID, MarshalNative::GCHandleInternalAlloc, Object *obj, int type) } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE GCHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle) +extern "C" void QCALLTYPE GCHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -407,7 +408,7 @@ FCIMPL2(FC_BOOL_RET, MarshalNative::GCHandleInternalTryGetBridgeWait, OBJECTHAND FCIMPLEND // Unlike the fast call above, this can block -extern "C" QCallExceptionStatus QCALLTYPE GCHandle_InternalGetBridgeWait(OBJECTHANDLE handle, QCall::ObjectHandleOnStack result) +extern "C" void QCALLTYPE GCHandle_InternalGetBridgeWait(OBJECTHANDLE handle, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -457,7 +458,7 @@ FCIMPLEND // *** Interop Helpers *** //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetExceptionForHR(INT32 errorCode, LPVOID errorInfo, QCall::ObjectHandleOnStack retVal) +extern "C" void QCALLTYPE MarshalNative_GetExceptionForHR(INT32 errorCode, LPVOID errorInfo, QCall::ObjectHandleOnStack retVal, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -499,7 +500,7 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetExceptionForHR(INT32 } #ifdef FEATURE_COMINTEROP -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetHRForException(QCall::ObjectHandleOnStack obj, int32_t* pReturnValue) +extern "C" int32_t QCALLTYPE MarshalNative_GetHRForException(QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -516,22 +517,22 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetHRForException(QCall: hr = SetupErrorInfo(obj.Get()); - *pReturnValue = hr; - END_QCALL; + + return hr; } //==================================================================== // return the IUnknown* for an Object. //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetIUnknownForObject(QCall::ObjectHandleOnStack o, IUnknown** pReturnValue) +extern "C" IUnknown* QCALLTYPE MarshalNative_GetIUnknownForObject(QCall::ObjectHandleOnStack o, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - IUnknown* retVal = NULL; + BEGIN_QCALL; + // Ensure COM is started up. EnsureComStarted(); @@ -542,22 +543,21 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetIUnknownForObject(QCa retVal = GetComIPFromObjectRef(&oref, ComIpType_OuterUnknown, NULL); GCPROTECT_END(); - *pReturnValue = retVal; - END_QCALL; + return retVal; } //==================================================================== // return the IDispatch* for an Object. //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetIDispatchForObject(QCall::ObjectHandleOnStack o, IDispatch** pReturnValue) +extern "C" IDispatch* QCALLTYPE MarshalNative_GetIDispatchForObject(QCall::ObjectHandleOnStack o, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - IDispatch* retVal = NULL; + BEGIN_QCALL; + // Ensure COM is started up. EnsureComStarted(); @@ -568,22 +568,21 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetIDispatchForObject(QC retVal = (IDispatch*)GetComIPFromObjectRef(&oref, ComIpType_Dispatch, NULL); GCPROTECT_END(); - *pReturnValue = retVal; - END_QCALL; + return retVal; } //==================================================================== // return the IUnknown* or IDispatch* for an Object. //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetIUnknownOrIDispatchForObject(QCall::ObjectHandleOnStack o, BOOL* isIDispatch, void** pReturnValue) +extern "C" void* QCALLTYPE MarshalNative_GetIUnknownOrIDispatchForObject(QCall::ObjectHandleOnStack o, BOOL* isIDispatch, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - void* retVal = NULL; + BEGIN_QCALL; + // Ensure COM is started up. EnsureComStarted(); @@ -596,23 +595,22 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetIUnknownOrIDispatchFo *isIDispatch = fetchedIpType == ComIpType_Dispatch; GCPROTECT_END(); - *pReturnValue = retVal; - END_QCALL; + return retVal; } //==================================================================== // return the IUnknown* representing the interface for the Object // Object o should support Type T //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetComInterfaceForObject(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, BOOL bEnableCustomizedQueryInterface, IUnknown** pReturnValue) +extern "C" IUnknown* QCALLTYPE MarshalNative_GetComInterfaceForObject(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, BOOL bEnableCustomizedQueryInterface, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - IUnknown* retVal = NULL; + BEGIN_QCALL; + // Ensure COM is started up. EnsureComStarted(); @@ -643,15 +641,15 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetComInterfaceForObject GCPROTECT_END(); - *pReturnValue = retVal; - END_QCALL; + + return retVal; } //==================================================================== // return an Object for IUnknown //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject) +extern "C" void QCALLTYPE MarshalNative_GetObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -676,7 +674,7 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetObjectForIUnknown(IUn END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetUniqueObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject) +extern "C" void QCALLTYPE MarshalNative_GetUniqueObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -706,7 +704,7 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetUniqueObjectForIUnkno // NOTE: // Type T should be either a COM imported Type or a sub-type of COM imported Type //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetTypedObjectForIUnknown(IUnknown* pUnk, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject) +extern "C" void QCALLTYPE MarshalNative_GetTypedObjectForIUnknown(IUnknown* pUnk, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -738,7 +736,7 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetTypedObjectForIUnknow END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_CreateAggregatedObject(IUnknown* pOuter, QCall::ObjectHandleOnStack o, IUnknown** pReturnValue) +extern "C" IUnknown* QCALLTYPE MarshalNative_CreateAggregatedObject(IUnknown* pOuter, QCall::ObjectHandleOnStack o, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -773,15 +771,15 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_CreateAggregatedObject(I GCPROTECT_END(); - *pReturnValue = pInner; - END_QCALL; + + return pInner; } //==================================================================== // Free unused RCWs in the current CLR context. //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_CleanupUnusedObjectsInCurrentContext() +extern "C" void QCALLTYPE MarshalNative_CleanupUnusedObjectsInCurrentContext(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -820,14 +818,14 @@ FCIMPLEND // free the COM component and zombie this object if the ref count hits 0 // further usage of this Object might throw an exception, //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_ReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, INT32* pReturnValue) +extern "C" INT32 QCALLTYPE MarshalNative_ReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - INT32 retVal = 0; + BEGIN_QCALL; + GCX_COOP(); OBJECTREF obj = objUNSAFE.Get(); @@ -843,16 +841,16 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_ReleaseComObject(QCall:: GCPROTECT_END(); - *pReturnValue = retVal; - END_QCALL; + + return retVal; } //==================================================================== // free the COM component and zombie this object // further usage of this Object might throw an exception, //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_FinalReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE) +extern "C" void QCALLTYPE MarshalNative_FinalReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -880,7 +878,7 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_FinalReleaseComObject(QC // This method takes the given COM object and wraps it in an object // of the specified type. The type must be derived from __ComObject. //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_InternalCreateWrapperOfType(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject) +extern "C" void QCALLTYPE MarshalNative_InternalCreateWrapperOfType(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -942,23 +940,23 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_InternalCreateWrapperOfT //==================================================================== // check if the type is visible from COM. //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_IsTypeVisibleFromCom(QCall::TypeHandle t, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE MarshalNative_IsTypeVisibleFromCom(QCall::TypeHandle t, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - BOOL retVal = FALSE; + BEGIN_QCALL; + // Call the internal version of IsTypeVisibleFromCom. retVal = ::IsTypeVisibleFromCom(t.AsTypeHandle()); - *pReturnValue = retVal; - END_QCALL; + + return retVal; } -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetNativeVariantForObject(QCall::ObjectHandleOnStack ObjUNSAFE, LPVOID pDestNativeVariant) +extern "C" void QCALLTYPE MarshalNative_GetNativeVariantForObject(QCall::ObjectHandleOnStack ObjUNSAFE, LPVOID pDestNativeVariant, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -992,7 +990,7 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetNativeVariantForObjec END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetObjectForNativeVariant(LPVOID pSrcNativeVariant, QCall::ObjectHandleOnStack retObject) +extern "C" void QCALLTYPE MarshalNative_GetObjectForNativeVariant(LPVOID pSrcNativeVariant, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -1015,7 +1013,7 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetObjectForNativeVarian } -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetObjectsForNativeVariants(VARIANT* aSrcNativeVariant, int cVars, QCall::ObjectHandleOnStack retArray) +extern "C" void QCALLTYPE MarshalNative_GetObjectsForNativeVariants(VARIANT* aSrcNativeVariant, int cVars, QCall::ObjectHandleOnStack retArray, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -1102,14 +1100,14 @@ static int GetComSlotInfo(MethodTable *pMT, MethodTable **ppDefItfMT) } } -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetStartComSlot(QCall::TypeHandle t, INT32* pReturnValue) +extern "C" INT32 QCALLTYPE MarshalNative_GetStartComSlot(QCall::TypeHandle t, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - int retVal = 0; + BEGIN_QCALL; + MethodTable *pMT = t.AsTypeHandle().GetMethodTable(); if (NULL == pMT) COMPlusThrow(kArgumentNullException); @@ -1120,19 +1118,19 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetStartComSlot(QCall::T retVal = GetComSlotInfo(pMT, &pMT); - *pReturnValue = retVal; - END_QCALL; + + return retVal; } -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetEndComSlot(QCall::TypeHandle t, INT32* pReturnValue) +extern "C" INT32 QCALLTYPE MarshalNative_GetEndComSlot(QCall::TypeHandle t, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - int retVal = 0; + BEGIN_QCALL; + int StartSlot = -1; MethodTable *pMT = t.AsTypeHandle().GetMethodTable(); @@ -1159,12 +1157,12 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetEndComSlot(QCall::Typ retVal = int(StartSlot + MemberMap.GetMethods().Size() - 1); } - *pReturnValue = retVal; - END_QCALL; + + return retVal; } -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_ChangeWrapperHandleStrength(QCall::ObjectHandleOnStack otp, BOOL fIsWeak) +extern "C" VOID QCALLTYPE MarshalNative_ChangeWrapperHandleStrength(QCall::ObjectHandleOnStack otp, BOOL fIsWeak, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1190,7 +1188,7 @@ extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_ChangeWrapperHandleStren END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetTypeFromCLSID(REFCLSID clsid, PCWSTR wszServer, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE MarshalNative_GetTypeFromCLSID(REFCLSID clsid, PCWSTR wszServer, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/marshalnative.h b/src/coreclr/vm/marshalnative.h index df8d706193b711..01a9cb3c8e58c5 100644 --- a/src/coreclr/vm/marshalnative.h +++ b/src/coreclr/vm/marshalnative.h @@ -37,29 +37,29 @@ class MarshalNative #endif // FEATURE_COMINTEROP }; -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_OffsetOf(FieldDesc* pFD, SIZE_T* pReturnValue); +extern "C" SIZE_T QCALLTYPE MarshalNative_OffsetOf(FieldDesc* pFD, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_Prelink(MethodDesc * pMD); -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_IsBuiltInComSupported(BOOL* pReturnValue); +extern "C" VOID QCALLTYPE MarshalNative_Prelink(MethodDesc * pMD, QCallExceptionStatus* qcallError); +extern "C" BOOL QCALLTYPE MarshalNative_IsBuiltInComSupported(QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_HasLayout(QCall::TypeHandle t, BOOL* pIsBlittable, DWORD* pNativeSize, BOOL* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_SizeOfHelper(QCall::TypeHandle t, BOOL throwIfNotMarshalable, INT32* pReturnValue); +extern "C" BOOL QCALLTYPE MarshalNative_HasLayout(QCall::TypeHandle t, BOOL* pIsBlittable, DWORD* pNativeSize, QCallExceptionStatus* qcallError); +extern "C" INT32 QCALLTYPE MarshalNative_SizeOfHelper(QCall::TypeHandle t, BOOL throwIfNotMarshalable, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetDelegateForFunctionPointerInternal(PVOID FPtr, QCall::TypeHandle t, QCall::ObjectHandleOnStack retDelegate); -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetFunctionPointerForDelegateInternal(QCall::ObjectHandleOnStack delegate, PVOID* pReturnValue); +extern "C" void QCALLTYPE MarshalNative_GetDelegateForFunctionPointerInternal(PVOID FPtr, QCall::TypeHandle t, QCall::ObjectHandleOnStack retDelegate, QCallExceptionStatus* qcallError); +extern "C" PVOID QCALLTYPE MarshalNative_GetFunctionPointerForDelegateInternal(QCall::ObjectHandleOnStack delegate, QCallExceptionStatus* qcallError); //==================================================================== // These methods convert between an HR and and a managed exception. //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetExceptionForHR(INT32 errorCode, LPVOID errorInfo, QCall::ObjectHandleOnStack obj); +extern "C" void QCALLTYPE MarshalNative_GetExceptionForHR(INT32 errorCode, LPVOID errorInfo, QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError); #ifdef FEATURE_COMINTEROP -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetHRForException(QCall::ObjectHandleOnStack obj, int32_t* pReturnValue); +extern "C" int32_t QCALLTYPE MarshalNative_GetHRForException(QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError); #endif // FEATURE_COMINTEROP -extern "C" QCallExceptionStatus QCALLTYPE GCHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack obj, int type, OBJECTHANDLE* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE GCHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle); +extern "C" OBJECTHANDLE QCALLTYPE GCHandle_InternalAllocWithGCTransition(QCall::ObjectHandleOnStack obj, int type, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE GCHandle_InternalFreeWithGCTransition(OBJECTHANDLE handle, QCallExceptionStatus* qcallError); #ifdef FEATURE_JAVAMARSHAL -extern "C" QCallExceptionStatus QCALLTYPE GCHandle_InternalGetBridgeWait(OBJECTHANDLE handle, QCall::ObjectHandleOnStack result); +extern "C" void QCALLTYPE GCHandle_InternalGetBridgeWait(OBJECTHANDLE handle, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); #endif #ifdef _DEBUG @@ -71,88 +71,88 @@ extern "C" IsInCooperativeGCMode_fn QCALLTYPE MarshalNative_GetIsInCooperativeGC //==================================================================== // Create type for given CLSID. //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetTypeFromCLSID(REFCLSID clsid, PCWSTR wszServer, QCall::ObjectHandleOnStack retType); +extern "C" void QCALLTYPE MarshalNative_GetTypeFromCLSID(REFCLSID clsid, PCWSTR wszServer, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); //==================================================================== // return the IUnknown* for an Object //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetIUnknownForObject(QCall::ObjectHandleOnStack o, IUnknown** pReturnValue); +extern "C" IUnknown* QCALLTYPE MarshalNative_GetIUnknownForObject(QCall::ObjectHandleOnStack o, QCallExceptionStatus* qcallError); //==================================================================== // return the IDispatch* for an Object //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetIDispatchForObject(QCall::ObjectHandleOnStack o, IDispatch** pReturnValue); +extern "C" IDispatch* QCALLTYPE MarshalNative_GetIDispatchForObject(QCall::ObjectHandleOnStack o, QCallExceptionStatus* qcallError); //==================================================================== // return the IUnknown* or IDispatch* for an Object. //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetIUnknownOrIDispatchForObject(QCall::ObjectHandleOnStack o, BOOL* isIDispatch, void** pReturnValue); +extern "C" void* QCALLTYPE MarshalNative_GetIUnknownOrIDispatchForObject(QCall::ObjectHandleOnStack o, BOOL* isIDispatch, QCallExceptionStatus* qcallError); //==================================================================== // return the IUnknown* representing the interface for the Object // Object o should support Type T //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetComInterfaceForObject(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, BOOL bEnableCustomizedQueryInterface, IUnknown** pReturnValue); +extern "C" IUnknown* QCALLTYPE MarshalNative_GetComInterfaceForObject(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, BOOL bEnableCustomizedQueryInterface, QCallExceptionStatus* qcallError); //==================================================================== // return an Object for IUnknown //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject); +extern "C" void QCALLTYPE MarshalNative_GetObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); //==================================================================== // return a unique cacheless Object for IUnknown //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetUniqueObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject); +extern "C" void QCALLTYPE MarshalNative_GetUniqueObjectForIUnknown(IUnknown* pUnk, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); //==================================================================== // return an Object for IUnknown, using the Type T, // NOTE: // Type T should be either a COM imported Type or a sub-type of COM imported Type //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetTypedObjectForIUnknown(IUnknown* pUnk, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject); +extern "C" void QCALLTYPE MarshalNative_GetTypedObjectForIUnknown(IUnknown* pUnk, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); //==================================================================== // Create an object and aggregate it, then return the inner unknown. //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_CreateAggregatedObject(IUnknown* pOuter, QCall::ObjectHandleOnStack o, IUnknown** pReturnValue); +extern "C" IUnknown* QCALLTYPE MarshalNative_CreateAggregatedObject(IUnknown* pOuter, QCall::ObjectHandleOnStack o, QCallExceptionStatus* qcallError); //==================================================================== // Free unused RCWs in the current CLR context. //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_CleanupUnusedObjectsInCurrentContext(); +extern "C" void QCALLTYPE MarshalNative_CleanupUnusedObjectsInCurrentContext(QCallExceptionStatus* qcallError); //==================================================================== // free the COM component and zombie this object // further usage of this Object might throw an exception, //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_ReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, INT32* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_FinalReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE); +extern "C" INT32 QCALLTYPE MarshalNative_ReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE MarshalNative_FinalReleaseComObject(QCall::ObjectHandleOnStack objUNSAFE, QCallExceptionStatus* qcallError); //==================================================================== // This method takes the given COM object and wraps it in an object // of the specified type. The type must be derived from __ComObject. //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_InternalCreateWrapperOfType(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject); +extern "C" void QCALLTYPE MarshalNative_InternalCreateWrapperOfType(QCall::ObjectHandleOnStack o, QCall::TypeHandle t, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); //==================================================================== // check if the type is visible from COM. //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_IsTypeVisibleFromCom(QCall::TypeHandle t, BOOL* pReturnValue); +extern "C" BOOL QCALLTYPE MarshalNative_IsTypeVisibleFromCom(QCall::TypeHandle t, QCallExceptionStatus* qcallError); //==================================================================== // These methods convert OLE variants to and from objects. //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetNativeVariantForObject(QCall::ObjectHandleOnStack ObjUNSAFE, LPVOID pDestNativeVariant); -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetObjectForNativeVariant(LPVOID pSrcNativeVariant, QCall::ObjectHandleOnStack retObject); -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetObjectsForNativeVariants(VARIANT* aSrcNativeVariant, int cVars, QCall::ObjectHandleOnStack retArray); +extern "C" void QCALLTYPE MarshalNative_GetNativeVariantForObject(QCall::ObjectHandleOnStack ObjUNSAFE, LPVOID pDestNativeVariant, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE MarshalNative_GetObjectForNativeVariant(LPVOID pSrcNativeVariant, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE MarshalNative_GetObjectsForNativeVariants(VARIANT* aSrcNativeVariant, int cVars, QCall::ObjectHandleOnStack retArray, QCallExceptionStatus* qcallError); //==================================================================== // These methods are used to map COM slots to method info's. //==================================================================== -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetStartComSlot(QCall::TypeHandle t, INT32* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_GetEndComSlot(QCall::TypeHandle t, INT32* pReturnValue); +extern "C" INT32 QCALLTYPE MarshalNative_GetStartComSlot(QCall::TypeHandle t, QCallExceptionStatus* qcallError); +extern "C" INT32 QCALLTYPE MarshalNative_GetEndComSlot(QCall::TypeHandle t, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE MarshalNative_ChangeWrapperHandleStrength(QCall::ObjectHandleOnStack otp, BOOL fIsWeak); +extern "C" VOID QCALLTYPE MarshalNative_ChangeWrapperHandleStrength(QCall::ObjectHandleOnStack otp, BOOL fIsWeak, QCallExceptionStatus* qcallError); #endif // FEATURE_COMINTEROP #endif diff --git a/src/coreclr/vm/method.hpp b/src/coreclr/vm/method.hpp index 87d4fc130fee1e..5d7f9a475269b1 100644 --- a/src/coreclr/vm/method.hpp +++ b/src/coreclr/vm/method.hpp @@ -2394,7 +2394,7 @@ class MethodDesc }; #ifndef DACCESS_COMPILE -extern "C" QCallExceptionStatus QCALLTYPE UnsafeAccessors_ResolveGenericParamToTypeHandle(MethodDesc* unsafeAccessorMethod, BOOL isMethodParam, DWORD paramIndex, void** pReturnValue); +extern "C" void* QCALLTYPE UnsafeAccessors_ResolveGenericParamToTypeHandle(MethodDesc* unsafeAccessorMethod, BOOL isMethodParam, DWORD paramIndex, QCallExceptionStatus* qcallError); #endif // DACCESS_COMPILE template<> struct cdac_data diff --git a/src/coreclr/vm/mlinfo.cpp b/src/coreclr/vm/mlinfo.cpp index 2cd2e0b2babeec..7f88dec1f568f4 100644 --- a/src/coreclr/vm/mlinfo.cpp +++ b/src/coreclr/vm/mlinfo.cpp @@ -3589,7 +3589,7 @@ bool IsUnsupportedTypedrefReturn(MetaSig& msig) #include "stubhelpers.h" -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_CreateCustomMarshaler(MethodDesc* pMD, mdToken paramToken, TypeHandle hndManagedType, QCall::ObjectHandleOnStack retObject) +extern "C" void QCALLTYPE StubHelpers_CreateCustomMarshaler(MethodDesc* pMD, mdToken paramToken, TypeHandle hndManagedType, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/multicorejit.cpp b/src/coreclr/vm/multicorejit.cpp index 3c7b47fb3be10f..3196553ba423fe 100644 --- a/src/coreclr/vm/multicorejit.cpp +++ b/src/coreclr/vm/multicorejit.cpp @@ -1546,7 +1546,7 @@ DWORD MulticoreJitManager::EncodeModuleHelper(void * pModuleContext, Module * pR // wszProfile - profile name // ptrNativeAssemblyBinder - the binding context // -extern "C" QCallExceptionStatus QCALLTYPE MultiCoreJIT_InternalStartProfile(_In_z_ LPCWSTR wszProfile, INT_PTR ptrNativeAssemblyBinder) +extern "C" void QCALLTYPE MultiCoreJIT_InternalStartProfile(_In_z_ LPCWSTR wszProfile, INT_PTR ptrNativeAssemblyBinder, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1565,7 +1565,7 @@ extern "C" QCallExceptionStatus QCALLTYPE MultiCoreJIT_InternalStartProfile(_In_ } -extern "C" QCallExceptionStatus QCALLTYPE MultiCoreJIT_InternalSetProfileRoot(_In_z_ LPCWSTR wszProfilePath) +extern "C" void QCALLTYPE MultiCoreJIT_InternalSetProfileRoot(_In_z_ LPCWSTR wszProfilePath, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/multicorejit.h b/src/coreclr/vm/multicorejit.h index 3489fec61be51a..5577d1c77e3c11 100644 --- a/src/coreclr/vm/multicorejit.h +++ b/src/coreclr/vm/multicorejit.h @@ -315,7 +315,7 @@ class MulticoreJitManager // For qcallentrypoints.cpp -extern "C" QCallExceptionStatus QCALLTYPE MultiCoreJIT_InternalSetProfileRoot(_In_z_ LPCWSTR directoryPath); -extern "C" QCallExceptionStatus QCALLTYPE MultiCoreJIT_InternalStartProfile(_In_z_ LPCWSTR wszProfile, INT_PTR ptrNativeAssemblyBinder); +extern "C" void QCALLTYPE MultiCoreJIT_InternalSetProfileRoot(_In_z_ LPCWSTR directoryPath, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE MultiCoreJIT_InternalStartProfile(_In_z_ LPCWSTR wszProfile, INT_PTR ptrNativeAssemblyBinder, QCallExceptionStatus* qcallError); #endif // __MULTICORE_JIT_H__ diff --git a/src/coreclr/vm/nativeeventsource.cpp b/src/coreclr/vm/nativeeventsource.cpp index 237128fe6b40ec..232f09c208e06a 100644 --- a/src/coreclr/vm/nativeeventsource.cpp +++ b/src/coreclr/vm/nativeeventsource.cpp @@ -13,7 +13,7 @@ #if defined(FEATURE_EVENTSOURCE_XPLAT) -extern "C" QCallExceptionStatus QCALLTYPE LogEventSource(_In_z_ int eventID, _In_z_ LPCWSTR eventName, _In_z_ LPCWSTR eventSourceName, _In_z_ LPCWSTR payload) +extern "C" void QCALLTYPE LogEventSource(_In_z_ int eventID, _In_z_ LPCWSTR eventName, _In_z_ LPCWSTR eventSourceName, _In_z_ LPCWSTR payload, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -21,35 +21,35 @@ extern "C" QCallExceptionStatus QCALLTYPE LogEventSource(_In_z_ int eventID, _In END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE IsEventSourceLoggingEnabled(BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE IsEventSourceLoggingEnabled(QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - BOOL retVal = FALSE; - retVal = XplatEventLogger::IsEventLoggingEnabled(); - *pReturnValue = retVal; + BEGIN_QCALL; + retVal = XplatEventLogger::IsEventLoggingEnabled(); END_QCALL; + + return retVal; } -extern "C" QCallExceptionStatus QCALLTYPE EventSource_GetClrConfig(LPCWSTR configName, LPWSTR* pReturnValue) +extern "C" LPWSTR QCALLTYPE EventSource_GetClrConfig(LPCWSTR configName, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - LPWSTR ret = NULL; + BEGIN_QCALL; + CLRConfig::ConfigStringInfo info; info.name = configName; info.options = CLRConfig::LookupOptions::Default; ret = CLRConfig::GetConfigValue(info); - *pReturnValue = ret; - END_QCALL; + + return ret; } #endif //defined(FEATURE_EVENTSOURCE_XPLAT) @@ -62,7 +62,7 @@ extern "C" QCallExceptionStatus QCALLTYPE EventSource_GetClrConfig(LPCWSTR confi // change genRuntimeEventSources.py script to not emit the body that throws NotImplementedException for the event that // want to be fired from managed code. // See https://github.com/dotnet/runtime/pull/47829 for an example of how to do this. -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStart(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStart(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -72,7 +72,7 @@ extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPool END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -82,7 +82,7 @@ extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPool END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -92,7 +92,7 @@ extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPool END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolMinMaxThreads(_In_z_ short minWorkerThreads, _In_z_ short maxWorkerThreads, _In_z_ short minIOCompletionThreads, _In_z_ short maxIOCompletionThreads, _In_z_ short clrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolMinMaxThreads(_In_z_ short minWorkerThreads, _In_z_ short maxWorkerThreads, _In_z_ short minIOCompletionThreads, _In_z_ short maxIOCompletionThreads, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -102,7 +102,7 @@ extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPool END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentSample(_In_z_ double throughput, _In_z_ short clrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentSample(_In_z_ double throughput, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -112,7 +112,7 @@ extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPool END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentAdjustment(_In_z_ double averageThroughput, _In_z_ uint newWorkerThreadCount, _In_z_ uint reason, _In_z_ short clrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentAdjustment(_In_z_ double averageThroughput, _In_z_ uint newWorkerThreadCount, _In_z_ uint reason, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -122,7 +122,7 @@ extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPool END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentStats(_In_z_ double duration, _In_z_ double throughput, _In_z_ double threadWave, _In_z_ double throughputWave, _In_z_ double throughputErrorEstimate, _In_z_ double AverageThroughputErrorEstimate, _In_z_ double ThroughputRatio, _In_z_ double confidence, _In_z_ double newControlSetting, _In_z_ short newThreadWaveMagnitude, _In_z_ short ClrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentStats(_In_z_ double duration, _In_z_ double throughput, _In_z_ double threadWave, _In_z_ double throughputWave, _In_z_ double throughputErrorEstimate, _In_z_ double AverageThroughputErrorEstimate, _In_z_ double ThroughputRatio, _In_z_ double confidence, _In_z_ double newControlSetting, _In_z_ short newThreadWaveMagnitude, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -132,7 +132,7 @@ extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPool END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOEnqueue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ BOOL multiDequeues, _In_z_ short ClrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOEnqueue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ BOOL multiDequeues, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -142,7 +142,7 @@ extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPool END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIODequeue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIODequeue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -152,7 +152,7 @@ extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPool END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkingThreadCount(_In_z_ uint count, _In_z_ short ClrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkingThreadCount(_In_z_ uint count, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -162,7 +162,7 @@ extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPool END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOPack(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOPack(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -172,7 +172,7 @@ extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPool END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogContentionLockCreated(void* LockID, void* AssociatedObjectID, uint16_t ClrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionLockCreated(void* LockID, void* AssociatedObjectID, uint16_t ClrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -182,12 +182,13 @@ extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogContention END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogContentionStart( +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStart( uint8_t ContentionFlags, uint16_t ClrInstanceID, void* LockID, void* AssociatedObjectID, - uint64_t LockOwnerThreadID) + uint64_t LockOwnerThreadID, + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -197,7 +198,7 @@ extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogContention END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogContentionStop(uint8_t ContentionFlags, uint16_t ClrInstanceID, double DurationNs) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStop(uint8_t ContentionFlags, uint16_t ClrInstanceID, double DurationNs, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -207,7 +208,7 @@ extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogContention END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStart(uint8_t WaitSource, intptr_t AssociatedObjectID, uint16_t ClrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStart(uint8_t WaitSource, intptr_t AssociatedObjectID, uint16_t ClrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -217,7 +218,7 @@ extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogWaitHandle END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStop(uint16_t ClrInstanceID) +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStop(uint16_t ClrInstanceID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; diff --git a/src/coreclr/vm/nativeeventsource.h b/src/coreclr/vm/nativeeventsource.h index 64d78273314592..66785fc054a55c 100644 --- a/src/coreclr/vm/nativeeventsource.h +++ b/src/coreclr/vm/nativeeventsource.h @@ -15,28 +15,28 @@ #include "qcall.h" #if defined(FEATURE_EVENTSOURCE_XPLAT) -extern "C" QCallExceptionStatus QCALLTYPE LogEventSource(_In_z_ int eventID, _In_z_ LPCWSTR eventName, _In_z_ LPCWSTR eventSourceName, _In_z_ LPCWSTR payload); -extern "C" QCallExceptionStatus QCALLTYPE IsEventSourceLoggingEnabled(BOOL* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE EventSource_GetClrConfig(LPCWSTR configName, LPWSTR* pReturnValue); +extern "C" void QCALLTYPE LogEventSource(_In_z_ int eventID, _In_z_ LPCWSTR eventName, _In_z_ LPCWSTR eventSourceName, _In_z_ LPCWSTR payload, QCallExceptionStatus* qcallError); +extern "C" BOOL QCALLTYPE IsEventSourceLoggingEnabled(QCallExceptionStatus* qcallError); +extern "C" LPWSTR QCALLTYPE EventSource_GetClrConfig(LPCWSTR configName, QCallExceptionStatus* qcallError); #endif //defined(FEATURE_EVENTSOURCE_XPLAT) #if defined(FEATURE_PERFTRACING) -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStart(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID); -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID); -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID); -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolMinMaxThreads(_In_z_ short minWorkerThreads, _In_z_ short maxWorkerThreads, _In_z_ short minIOCompletionThreads, _In_z_ short maxIOCompletionThreads, _In_z_ short clrInstanceID); -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentSample(_In_z_ double throughput, _In_z_ short clrInstanceID); -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentAdjustment(_In_z_ double averageThroughput, _In_z_ uint newWorkerThreadCount, _In_z_ uint reason, _In_z_ short clrInstanceID); -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentStats(_In_z_ double duration, _In_z_ double throughput, _In_z_ double threadWave, _In_z_ double throughputWave, _In_z_ double throughputErrorEstimate, _In_z_ double AverageThroughputErrorEstimate, _In_z_ double ThroughputRatio, _In_z_ double confidence, _In_z_ double newControlSetting, _In_z_ short newThreadWaveMagnitude, _In_z_ short ClrInstanceID); -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOEnqueue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ BOOL multiDequeues, _In_z_ short ClrInstanceID); -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIODequeue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID); -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkingThreadCount(_In_z_ uint count, _In_z_ short ClrInstanceID); -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOPack(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID); -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogContentionLockCreated(void* LockID, void* AssociatedObjectID, uint16_t ClrInstanceID); -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogContentionStart(uint8_t ContentionFlags, uint16_t ClrInstanceID, void* LockID, void* AssociatedObjectID, uint64_t LockOwnerThreadID); -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogContentionStop(uint8_t ContentionFlags, uint16_t ClrInstanceID, double DurationNs); -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStart(uint8_t WaitSource, intptr_t AssociatedObjectID, uint16_t ClrInstanceID); -extern "C" QCallExceptionStatus QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStop(uint16_t ClrInstanceID); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStart(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait(_In_z_ uint activeWorkerThreadCount, _In_z_ uint retiredWorkerThreadCount, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolMinMaxThreads(_In_z_ short minWorkerThreads, _In_z_ short maxWorkerThreads, _In_z_ short minIOCompletionThreads, _In_z_ short maxIOCompletionThreads, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentSample(_In_z_ double throughput, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentAdjustment(_In_z_ double averageThroughput, _In_z_ uint newWorkerThreadCount, _In_z_ uint reason, _In_z_ short clrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentStats(_In_z_ double duration, _In_z_ double throughput, _In_z_ double threadWave, _In_z_ double throughputWave, _In_z_ double throughputErrorEstimate, _In_z_ double AverageThroughputErrorEstimate, _In_z_ double ThroughputRatio, _In_z_ double confidence, _In_z_ double newControlSetting, _In_z_ short newThreadWaveMagnitude, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOEnqueue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ BOOL multiDequeues, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIODequeue(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolWorkingThreadCount(_In_z_ uint count, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogThreadPoolIOPack(_In_z_ void* nativeOverlapped, _In_z_ void* overlapped, _In_z_ short ClrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionLockCreated(void* LockID, void* AssociatedObjectID, uint16_t ClrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStart(uint8_t ContentionFlags, uint16_t ClrInstanceID, void* LockID, void* AssociatedObjectID, uint64_t LockOwnerThreadID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogContentionStop(uint8_t ContentionFlags, uint16_t ClrInstanceID, double DurationNs, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStart(uint8_t WaitSource, intptr_t AssociatedObjectID, uint16_t ClrInstanceID, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE NativeRuntimeEventSource_LogWaitHandleWaitStop(uint16_t ClrInstanceID, QCallExceptionStatus* qcallError); #endif // defined(FEATURE_PERFTRACING) diff --git a/src/coreclr/vm/nativelibrarynative.cpp b/src/coreclr/vm/nativelibrarynative.cpp index d089f600a31aa3..713ae1b62ec097 100644 --- a/src/coreclr/vm/nativelibrarynative.cpp +++ b/src/coreclr/vm/nativelibrarynative.cpp @@ -9,19 +9,20 @@ #include "nativelibrarynative.h" // static -extern "C" QCallExceptionStatus QCALLTYPE NativeLibrary_LoadByName(LPCWSTR name, QCall::AssemblyHandle callingAssembly, +extern "C" INT_PTR QCALLTYPE NativeLibrary_LoadByName(LPCWSTR name, QCall::AssemblyHandle callingAssembly, BOOL hasDllImportSearchPathFlag, DWORD dllImportSearchPathFlag, - BOOL throwOnError, INT_PTR* pReturnValue) + BOOL throwOnError, + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - NATIVE_LIBRARY_HANDLE handle = nullptr; - handle = NativeLibrary::LoadLibraryByName(name, callingAssembly, hasDllImportSearchPathFlag, dllImportSearchPathFlag, throwOnError); + BEGIN_QCALL; - *pReturnValue = reinterpret_cast(handle); + handle = NativeLibrary::LoadLibraryByName(name, callingAssembly, hasDllImportSearchPathFlag, dllImportSearchPathFlag, throwOnError); END_QCALL; + + return reinterpret_cast(handle); } diff --git a/src/coreclr/vm/nativelibrarynative.h b/src/coreclr/vm/nativelibrarynative.h index 2b71a7267d4efd..a30217d657e30b 100644 --- a/src/coreclr/vm/nativelibrarynative.h +++ b/src/coreclr/vm/nativelibrarynative.h @@ -10,8 +10,9 @@ #ifndef __NATIVELIBRARYNATIVE_H__ #define __NATIVELIBRARYNATIVE_H__ -extern "C" QCallExceptionStatus QCALLTYPE NativeLibrary_LoadByName(LPCWSTR name, QCall::AssemblyHandle callingAssembly, +extern "C" INT_PTR QCALLTYPE NativeLibrary_LoadByName(LPCWSTR name, QCall::AssemblyHandle callingAssembly, BOOL hasDllImportSearchPathFlag, DWORD dllImportSearchPathFlag, - BOOL throwOnError, INT_PTR* pReturnValue); + BOOL throwOnError, + QCallExceptionStatus* qcallError); #endif // __NATIVELIBRARYNATIVE_H__ diff --git a/src/coreclr/vm/olevariant.cpp b/src/coreclr/vm/olevariant.cpp index 0c4aa2735e5103..270d982f1e0d4d 100644 --- a/src/coreclr/vm/olevariant.cpp +++ b/src/coreclr/vm/olevariant.cpp @@ -2662,7 +2662,7 @@ BSTR OleVariant::ConvertStringToBSTR(STRINGREF *pStringObj) return result; } -extern "C" QCallExceptionStatus QCALLTYPE Variant_ConvertValueTypeToRecord(QCall::ObjectHandleOnStack obj, VARIANT * pOle) +extern "C" void QCALLTYPE Variant_ConvertValueTypeToRecord(QCall::ObjectHandleOnStack obj, VARIANT * pOle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/olevariant.h b/src/coreclr/vm/olevariant.h index 2c7650c5032ee6..ba83ded23c7941 100644 --- a/src/coreclr/vm/olevariant.h +++ b/src/coreclr/vm/olevariant.h @@ -107,6 +107,6 @@ class OleVariant // SAFEARRAY VARTYPE and element MethodTable. MethodDesc* GetInstantiatedSafeArrayMethod(BinderMethodID methodId, VARTYPE vt, MethodTable* pElementMT, BOOL bHeterogeneous, BOOL bNativeDataValid = FALSE); -extern "C" QCallExceptionStatus QCALLTYPE Variant_ConvertValueTypeToRecord(QCall::ObjectHandleOnStack obj, VARIANT* pOle); +extern "C" void QCALLTYPE Variant_ConvertValueTypeToRecord(QCall::ObjectHandleOnStack obj, VARIANT* pOle, QCallExceptionStatus* qcallError); #endif diff --git a/src/coreclr/vm/qcall.h b/src/coreclr/vm/qcall.h index af8b79385e6b42..797d55a78a5bce 100644 --- a/src/coreclr/vm/qcall.h +++ b/src/coreclr/vm/qcall.h @@ -39,8 +39,8 @@ // class Foo // { // -// // All QCalls that use BEGIN_QCALL must use the hidden return value error handler. -// [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] +// // All QCalls that use BEGIN_QCALL must use the hidden last parameter error handler. +// [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] // [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "FooNative_Bar", StringMarshalling = StringMarshalling.Utf16)] // private static partial bool Bar(int flags, string inString, StringHandleOnStack retString); // @@ -66,8 +66,8 @@ // The entrypoints of all QCalls has to be registered in tables in vm\qcallentrypoints.cpp using the DllImportEntry macro, // For example: DllImportEntry(FooNative_Bar) // -// extern "C" QCallExceptionStatus QCALLTYPE FooNative_Bar( -// int flags, LPCWSTR wszString, QCall::StringHandleOnStack retString, BOOL* pReturnValue) +// extern "C" BOOL QCALLTYPE FooNative_Bar( +// int flags, LPCWSTR wszString, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) // { // // All QCalls should have QCALL_CONTRACT. It is alias for THROWS; GC_TRIGGERS; MODE_PREEMPTIVE. // QCALL_CONTRACT; @@ -78,6 +78,8 @@ // // PRECONDITION(wszString != NULL); // // } CONTRACTL_END; // +// BOOL retVal = FALSE; +// // // The body has to be enclosed in BEGIN_QCALL/END_QCALL macro. It is necessary to make the exception handling work. // BEGIN_QCALL; // @@ -93,9 +95,11 @@ // retString.Set(L"Hello"); // // // You can not return from inside of BEGIN_QCALL/END_QCALL. The return value has to be passed out in helper variable. -// *pReturnValue = TRUE; +// retVal = TRUE; // // END_QCALL; +// +// return retVal; // } @@ -106,15 +110,13 @@ #endif // !TARGET_UNIX #define BEGIN_QCALL \ - QCallExceptionStatus qcallExceptionStatus = 0; \ - QCallExceptionStatus* qcallError = &qcallExceptionStatus; \ + *qcallError = 0; \ INSTALL_RESUME_AFTER_CATCH_HANDLER_WITH_FRAME(GetThread()->GetFrame()) \ INSTALL_MANAGED_EXCEPTION_CAPTURE_DISPATCHER #define END_QCALL \ UNINSTALL_MANAGED_EXCEPTION_CAPTURE_DISPATCHER \ - UNINSTALL_RESUME_AFTER_CATCH_HANDLER_WITH_FRAME \ - return qcallExceptionStatus + UNINSTALL_RESUME_AFTER_CATCH_HANDLER_WITH_FRAME #define QCALL_CHECK \ THROWS; \ diff --git a/src/coreclr/vm/reflectioninvocation.cpp b/src/coreclr/vm/reflectioninvocation.cpp index 1929cfdb9f8c04..4cbf731fe16384 100644 --- a/src/coreclr/vm/reflectioninvocation.cpp +++ b/src/coreclr/vm/reflectioninvocation.cpp @@ -27,7 +27,7 @@ #include "interpexec.h" -extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized, QCall::ObjectHandleOnStack result) +extern "C" void QCALLTYPE RuntimeFieldHandle_GetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -45,7 +45,7 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetValue(FieldDesc* END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_SetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::ObjectHandleOnStack value, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized) +extern "C" void QCALLTYPE RuntimeFieldHandle_SetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::ObjectHandleOnStack value, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -69,11 +69,13 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_SetValue(FieldDesc* END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_CreateInstanceForAnotherGenericParameter( +extern "C" void QCALLTYPE RuntimeTypeHandle_CreateInstanceForAnotherGenericParameter( QCall::TypeHandle pTypeHandle, TypeHandle* pInstArray, INT32 cInstArray, - QCall::ObjectHandleOnStack pInstantiatedObject) + QCall::ObjectHandleOnStack pInstantiatedObject, + QCallExceptionStatus* qcallError +) { CONTRACTL { @@ -117,7 +119,7 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_CreateInstanceForAno END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_InternalAlloc(MethodTable* pMT, QCall::ObjectHandleOnStack allocated) +extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAlloc(MethodTable* pMT, QCall::ObjectHandleOnStack allocated, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -132,7 +134,7 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_InternalAlloc(Method END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_InternalAllocNoChecks(MethodTable* pMT, QCall::ObjectHandleOnStack allocated) +extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAllocNoChecks(MethodTable* pMT, QCall::ObjectHandleOnStack allocated, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -323,12 +325,13 @@ class ArgIteratorForMethodInvoke : public ArgIteratorTemplateStackWalkFrames(SkipMethods, &skip, FUNCTIONSONLY | LIGHTUNWIND); @@ -811,9 +814,9 @@ extern "C" QCallExceptionStatus QCALLTYPE MethodBase_GetCurrentMethod(QCall::Sta if (skip.pMeth != NULL) pRet = skip.pMeth->LoadTypicalMethodDefinition(); - *pReturnValue = pRet; - END_QCALL; + + return pRet; } static OBJECTREF DirectObjectFieldGet(FieldDesc *pField, TypeHandle fieldType, TypeHandle enclosingType, TypedByRef *pTarget) @@ -841,7 +844,7 @@ static OBJECTREF DirectObjectFieldGet(FieldDesc *pField, TypeHandle fieldType, T return refRet; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack result) +extern "C" void QCALLTYPE RuntimeFieldHandle_GetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -946,7 +949,7 @@ static void DirectObjectFieldSet(FieldDesc *pField, TypeHandle fieldType, TypeHa GCPROTECT_END(); } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_SetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::ObjectHandleOnStack newValue, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringType) +extern "C" void QCALLTYPE RuntimeFieldHandle_SetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::ObjectHandleOnStack newValue, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1190,7 +1193,7 @@ FCIMPLEND // Returns the address of the EnC instance field in the object (This is an interior // pointer and the caller has to use it appropriately) or an EnC static field. -extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetEnCFieldAddr(QCall::ObjectHandleOnStack target, FieldDesc* pFD, void** pReturnValue) +extern "C" void* QCALLTYPE RuntimeFieldHandle_GetEnCFieldAddr(QCall::ObjectHandleOnStack target, FieldDesc* pFD, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -1212,19 +1215,19 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetEnCFieldAddr(QCa if (pFD->IsStatic() || target.Get() != NULL) ret = pFD->GetAddress(OBJECTREFToObject(target.Get())); - *pReturnValue = ret; - END_QCALL; + + return ret; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetRVAFieldInfo(FieldDesc* pField, void** address, UINT* size, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE RuntimeFieldHandle_GetRVAFieldInfo(FieldDesc* pField, void** address, UINT* size, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - BOOL ret = FALSE; + BEGIN_QCALL; + if (pField != NULL && pField->IsRVA()) { *address = pField->GetStaticAddressHandle(NULL); @@ -1232,12 +1235,12 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetRVAFieldInfo(Fie ret = TRUE; } - *pReturnValue = ret; - END_QCALL; + + return ret; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetFieldDataReference(FieldDesc* pField, QCall::ObjectHandleOnStack instance, QCall::ByteRefOnStack fieldDataRef) +extern "C" void QCALLTYPE RuntimeFieldHandle_GetFieldDataReference(FieldDesc* pField, QCall::ObjectHandleOnStack instance, QCall::ByteRefOnStack fieldDataRef, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -1256,7 +1259,7 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetFieldDataReferen END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_CompileMethod(MethodDesc * pMD) +extern "C" void QCALLTYPE ReflectionInvocation_CompileMethod(MethodDesc * pMD, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1265,7 +1268,8 @@ extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_CompileMethod(Met if (!pMD->ShouldCallPrestub()) { - return QCallExceptionStatus(); + *qcallError = 0; + return; } BEGIN_QCALL; @@ -1274,21 +1278,23 @@ extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_CompileMethod(Met } // This method triggers the class constructor for a give type -extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_RunClassConstructor(QCall::TypeHandle pType) +extern "C" void QCALLTYPE ReflectionInvocation_RunClassConstructor(QCall::TypeHandle pType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; TypeHandle typeHnd = pType.AsTypeHandle(); if (typeHnd.IsTypeDesc()) { - return QCallExceptionStatus(); + *qcallError = 0; + return; } MethodTable *pMT = typeHnd.AsMethodTable(); // The ContainsGenericVariables check is to preserve back-compat where we assume the generic type is already initialized if (pMT->IsClassInited() || pMT->ContainsGenericVariables()) { - return QCallExceptionStatus(); + *qcallError = 0; + return; } BEGIN_QCALL; @@ -1299,14 +1305,15 @@ extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_RunClassConstruct } // This method triggers the module constructor for a given module -extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_RunModuleConstructor(QCall::ModuleHandle pModule) +extern "C" void QCALLTYPE ReflectionInvocation_RunModuleConstructor(QCall::ModuleHandle pModule, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; Assembly *pAssembly = pModule->GetAssembly(); if (pAssembly != NULL && pAssembly->IsActive()) { - return QCallExceptionStatus(); + *qcallError = 0; + return; } BEGIN_QCALL; @@ -1347,7 +1354,7 @@ static void PrepareMethodHelper(MethodDesc * pMD) // This method triggers a given method to be jitted. CoreCLR implementation of this method triggers jiting of the given method only. // It does not walk a subset of callgraph to provide CER guarantees. -extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_PrepareMethod(MethodDesc *pMD, TypeHandle *pInstantiation, UINT32 cInstantiation) +extern "C" void QCALLTYPE ReflectionInvocation_PrepareMethod(MethodDesc *pMD, TypeHandle *pInstantiation, UINT32 cInstantiation, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -1400,7 +1407,7 @@ extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_PrepareMethod(Met // This method triggers target of a given method to be jitted. // In the case of a multi-cast delegate, we rely on the fact that each individual component // was prepared prior to the Combine. -extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_PrepareDelegate(QCall::ObjectHandleOnStack delegate) +extern "C" void QCALLTYPE ReflectionInvocation_PrepareDelegate(QCall::ObjectHandleOnStack delegate, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1453,7 +1460,7 @@ FCIMPL0(FC_BOOL_RET, ReflectionInvocation::TryEnsureSufficientExecutionStack) FCIMPLEND #ifdef FEATURE_COMINTEROP -extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_InvokeDispMethod( +extern "C" void QCALLTYPE ReflectionInvocation_InvokeDispMethod( QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack name, INT32 invokeAttr, @@ -1462,7 +1469,8 @@ extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_InvokeDispMethod( QCall::ObjectHandleOnStack byrefModifiers, LCID lcid, QCall::ObjectHandleOnStack namedParameters, - QCall::ObjectHandleOnStack result) + QCall::ObjectHandleOnStack result, + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1523,7 +1531,7 @@ extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_InvokeDispMethod( END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_GetComObjectGuid(QCall::ObjectHandleOnStack type, GUID* result) +extern "C" void QCALLTYPE ReflectionInvocation_GetComObjectGuid(QCall::ObjectHandleOnStack type, GUID* result, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -1556,7 +1564,7 @@ extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_GetComObjectGuid( } #endif // FEATURE_COMINTEROP -extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_GetGuid(MethodTable* pMT, GUID* result) +extern "C" void QCALLTYPE ReflectionInvocation_GetGuid(MethodTable* pMT, GUID* result, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -1662,13 +1670,15 @@ static void ValidateTypeAbleToBeInstantiated( * This method will not run the type's static cctor. * This method will not allocate an instance of the target type. */ -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetActivationInfo( +extern "C" void QCALLTYPE RuntimeTypeHandle_GetActivationInfo( QCall::ObjectHandleOnStack pRuntimeType, PCODE* ppfnAllocator, void** pvAllocatorFirstArg, PCODE* ppfnRefCtor, PCODE* ppfnValueCtor, - BOOL* pfCtorIsPublic) + BOOL* pfCtorIsPublic, + QCallExceptionStatus* qcallError +) { CONTRACTL { @@ -1804,7 +1814,7 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetActivationInfo( * Given a ComClassFactory*, calls the COM allocator * and returns a RCW. */ -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_AllocateComObject(void* pClassFactory, QCall::ObjectHandleOnStack result) +extern "C" void QCALLTYPE RuntimeTypeHandle_AllocateComObject(void* pClassFactory, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1833,10 +1843,11 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_AllocateComObject(vo //************************************************************************************************* //************************************************************************************************* //************************************************************************************************* -extern "C" QCallExceptionStatus QCALLTYPE ReflectionSerialization_GetCreateUninitializedObjectInfo( +extern "C" void QCALLTYPE ReflectionSerialization_GetCreateUninitializedObjectInfo( QCall::TypeHandle pType, PCODE* ppfnAllocator, - void** pvAllocatorFirstArg) + void** pvAllocatorFirstArg, + QCallExceptionStatus* qcallError) { CONTRACTL { @@ -1888,7 +1899,7 @@ struct TempEnumValue UINT64 value; }; -extern "C" QCallExceptionStatus QCALLTYPE Enum_GetValuesAndNames(QCall::TypeHandle pEnumType, QCall::ObjectHandleOnStack pReturnValues, QCall::ObjectHandleOnStack pReturnNames, BOOL fGetNames) +extern "C" void QCALLTYPE Enum_GetValuesAndNames(QCall::TypeHandle pEnumType, QCall::ObjectHandleOnStack pReturnValues, QCall::ObjectHandleOnStack pReturnNames, BOOL fGetNames, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -2005,12 +2016,13 @@ extern "C" int32_t QCALLTYPE ReflectionInvocation_SizeOf(QCall::TypeHandle pType return handle.GetSize(); } -extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_GetBoxInfo( +extern "C" void QCALLTYPE ReflectionInvocation_GetBoxInfo( QCall::TypeHandle pType, PCODE* ppfnAllocator, void** pvAllocatorFirstArg, int32_t* pValueOffset, - uint32_t* pValueSize) + uint32_t* pValueSize, + QCallExceptionStatus* qcallError) { CONTRACTL { diff --git a/src/coreclr/vm/reflectioninvocation.h b/src/coreclr/vm/reflectioninvocation.h index a3e355d991e973..3d553fab1d1f80 100644 --- a/src/coreclr/vm/reflectioninvocation.h +++ b/src/coreclr/vm/reflectioninvocation.h @@ -48,18 +48,18 @@ class ReflectionInvocation FCDECL0(static FC_BOOL_RET, TryEnsureSufficientExecutionStack); }; -extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_CompileMethod(MethodDesc * pMD); +extern "C" void QCALLTYPE ReflectionInvocation_CompileMethod(MethodDesc * pMD, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_RunClassConstructor(QCall::TypeHandle pType); +extern "C" void QCALLTYPE ReflectionInvocation_RunClassConstructor(QCall::TypeHandle pType, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_RunModuleConstructor(QCall::ModuleHandle pModule); +extern "C" void QCALLTYPE ReflectionInvocation_RunModuleConstructor(QCall::ModuleHandle pModule, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_PrepareMethod(MethodDesc* pMD, TypeHandle *pInstantiation, UINT32 cInstantiation); +extern "C" void QCALLTYPE ReflectionInvocation_PrepareMethod(MethodDesc* pMD, TypeHandle *pInstantiation, UINT32 cInstantiation, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_PrepareDelegate(QCall::ObjectHandleOnStack delegate); +extern "C" void QCALLTYPE ReflectionInvocation_PrepareDelegate(QCall::ObjectHandleOnStack delegate, QCallExceptionStatus* qcallError); #ifdef FEATURE_COMINTEROP -extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_InvokeDispMethod( +extern "C" void QCALLTYPE ReflectionInvocation_InvokeDispMethod( QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack name, INT32 invokeAttr, @@ -68,23 +68,25 @@ extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_InvokeDispMethod( QCall::ObjectHandleOnStack byrefModifiers, LCID lcid, QCall::ObjectHandleOnStack namedParameters, - QCall::ObjectHandleOnStack result); + QCall::ObjectHandleOnStack result, + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_GetComObjectGuid(QCall::ObjectHandleOnStack type, GUID* result); +extern "C" void QCALLTYPE ReflectionInvocation_GetComObjectGuid(QCall::ObjectHandleOnStack type, GUID* result, QCallExceptionStatus* qcallError); #endif // FEATURE_COMINTEROP -extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_GetGuid(MethodTable* pMT, GUID* result); +extern "C" void QCALLTYPE ReflectionInvocation_GetGuid(MethodTable* pMT, GUID* result, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE ReflectionSerialization_GetCreateUninitializedObjectInfo(QCall::TypeHandle pType, PCODE* ppfnAllocator, void** pvAllocatorFirstArg); +extern "C" void QCALLTYPE ReflectionSerialization_GetCreateUninitializedObjectInfo(QCall::TypeHandle pType, PCODE* ppfnAllocator, void** pvAllocatorFirstArg, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE ReflectionInvocation_GetBoxInfo( +extern "C" void QCALLTYPE ReflectionInvocation_GetBoxInfo( QCall::TypeHandle pType, PCODE* ppfnAllocator, void** pvAllocatorFirstArg, int32_t* pValueOffset, - uint32_t* pValueSize); + uint32_t* pValueSize, + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE Enum_GetValuesAndNames(QCall::TypeHandle pEnumType, QCall::ObjectHandleOnStack pReturnValues, QCall::ObjectHandleOnStack pReturnNames, BOOL fGetNames); +extern "C" void QCALLTYPE Enum_GetValuesAndNames(QCall::TypeHandle pEnumType, QCall::ObjectHandleOnStack pReturnValues, QCall::ObjectHandleOnStack pReturnNames, BOOL fGetNames, QCallExceptionStatus* qcallError); extern "C" int32_t QCALLTYPE ReflectionInvocation_SizeOf(QCall::TypeHandle pType); diff --git a/src/coreclr/vm/runtimehandles.cpp b/src/coreclr/vm/runtimehandles.cpp index 3368a85887a34f..5dc686e5a71795 100644 --- a/src/coreclr/vm/runtimehandles.cpp +++ b/src/coreclr/vm/runtimehandles.cpp @@ -33,15 +33,16 @@ #include "finalizerthread.h" #include "pregeneratedstringthunks.h" -extern "C" QCallExceptionStatus QCALLTYPE MdUtf8String_EqualsCaseInsensitive(LPCUTF8 szLhs, LPCUTF8 szRhs, INT32 stringNumBytes, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE MdUtf8String_EqualsCaseInsensitive(LPCUTF8 szLhs, LPCUTF8 szRhs, INT32 stringNumBytes, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; + BOOL fStringsEqual = FALSE; + BEGIN_QCALL; // Important: the string in pSsz isn't null terminated so the length must be used // when performing operations on the string. - BOOL fStringsEqual = FALSE; _ASSERTE(CheckPointer(szLhs)); _ASSERTE(CheckPointer(szRhs)); @@ -54,9 +55,9 @@ extern "C" QCallExceptionStatus QCALLTYPE MdUtf8String_EqualsCaseInsensitive(LPC // We can use SString for simple case insensitive compares fStringsEqual = lhs.EqualsCaseInsensitive(rhs); - *pReturnValue = fStringsEqual; - END_QCALL; + + return fStringsEqual; } static BOOL CheckCAVisibilityFromDecoratedType(MethodTable* pCAMT, MethodDesc* pCACtor, MethodTable* pDecoratedMT, Module* pDecoratedModule) @@ -93,19 +94,18 @@ static BOOL CheckCAVisibilityFromDecoratedType(MethodTable* pCAMT, MethodDesc* p *AccessCheckOptions::s_pNormalAccessChecks); } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_IsCAVisibleFromDecoratedType( +extern "C" BOOL QCALLTYPE RuntimeMethodHandle_IsCAVisibleFromDecoratedType( QCall::TypeHandle targetTypeHandle, MethodDesc * pTargetCtor, QCall::TypeHandle sourceTypeHandle, QCall::ModuleHandle sourceModuleHandle, - BOOL* pReturnValue) + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - BOOL bResult = TRUE; + BEGIN_QCALL; TypeHandle sourceHandle = sourceTypeHandle.AsTypeHandle(); TypeHandle targetHandle = targetTypeHandle.AsTypeHandle(); @@ -134,14 +134,15 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_IsCAVisibleFromDec } bResult = CheckCAVisibilityFromDecoratedType(targetHandle.AsMethodTable(), pTargetCtor, sourceHandle.AsMethodTable(), sourceModuleHandle); - *pReturnValue = bResult; - END_QCALL; + + return bResult; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetRuntimeTypeFromHandleSlow( +extern "C" void QCALLTYPE RuntimeTypeHandle_GetRuntimeTypeFromHandleSlow( EnregisteredTypeHandle typeHandleRaw, - QCall::ObjectHandleOnStack result) + QCall::ObjectHandleOnStack result, + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -159,19 +160,19 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetRuntimeTypeFromHa } #ifdef FEATURE_TYPEEQUIVALENCE -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_IsEquivalentTo(QCall::TypeHandle rtType1, QCall::TypeHandle rtType2, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsEquivalentTo(QCall::TypeHandle rtType1, QCall::TypeHandle rtType2, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - BOOL areEquivalent = FALSE; - areEquivalent = rtType1.AsTypeHandle().IsEquivalentTo(rtType2.AsTypeHandle()); + BEGIN_QCALL; - *pReturnValue = areEquivalent; + areEquivalent = rtType1.AsTypeHandle().IsEquivalentTo(rtType2.AsTypeHandle()); END_QCALL; + + return areEquivalent; } #endif // FEATURE_TYPEEQUIVALENCE @@ -233,7 +234,7 @@ FCIMPL1(AssemblyBaseObject*, RuntimeTypeHandle::GetAssemblyIfExists, ReflectClas } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetAssemblySlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack assembly) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetAssemblySlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack assembly, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -290,7 +291,7 @@ FCIMPL1(ReflectModuleBaseObject*, RuntimeTypeHandle::GetModuleIfExists, ReflectC } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetModuleSlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack module) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetModuleSlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack module, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -363,14 +364,14 @@ FCIMPL1(INT32, RuntimeTypeHandle::GetNumVirtuals, ReflectClassBaseObject* pTypeU } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals(QCall::TypeHandle pTypeHandle, INT32* pReturnValue) +extern "C" INT32 QCALLTYPE RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals(QCall::TypeHandle pTypeHandle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - INT32 numVirtuals = 0; + BEGIN_QCALL; + TypeHandle typeHandle = pTypeHandle.AsTypeHandle(); _ASSERTE(!typeHandle.IsGenericVariable()); @@ -392,22 +393,22 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetNumVirtualsAndSta } } - *pReturnValue = numVirtuals; - END_QCALL; + + return numVirtuals; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetMethodAt(MethodTable* pMT, INT32 slot, MethodDesc** pReturnValue) +extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetMethodAt(MethodTable* pMT, INT32 slot, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(pMT != NULL); _ASSERTE(slot >= 0); - BEGIN_QCALL; - MethodDesc* pRetMethod = NULL; + BEGIN_QCALL; + INT32 numVirtuals = (INT32)pMT->GetNumVirtuals(); if (slot < numVirtuals) { @@ -451,12 +452,12 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetMethodAt(MethodTa pRetMethod = NULL; } - *pReturnValue = pRetMethod; - END_QCALL; + + return pRetMethod; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetFields(MethodTable* pMT, intptr_t* result, INT32* pCount, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_GetFields(MethodTable* pMT, intptr_t* result, INT32* pCount, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -464,10 +465,10 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetFields(MethodTabl _ASSERTE(result != NULL); _ASSERTE(pCount != NULL); - BEGIN_QCALL; - BOOL retVal = FALSE; + BEGIN_QCALL; + EncApproxFieldDescIterator fdIterator(pMT, ApproxFieldDescIterator::ALL_FIELDS, EncApproxFieldDescIterator::FixUpEncFields); INT32 count = (INT32)fdIterator.Count(); @@ -485,12 +486,12 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetFields(MethodTabl retVal = TRUE; } - *pReturnValue = retVal; - END_QCALL; + + return retVal; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_ConstructInstantiation(MethodDesc * pMethod, DWORD format, QCall::StringHandleOnStack retString) +extern "C" void QCALLTYPE RuntimeMethodHandle_ConstructInstantiation(MethodDesc * pMethod, DWORD format, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -503,7 +504,7 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_ConstructInstantia END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_ConstructName(QCall::TypeHandle pTypeHandle, DWORD format, QCall::StringHandleOnStack retString) +extern "C" void QCALLTYPE RuntimeTypeHandle_ConstructName(QCall::TypeHandle pTypeHandle, DWORD format, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -516,7 +517,7 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_ConstructName(QCall: END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetInterfaces(MethodTable* pMT, QCall::ObjectHandleOnStack result) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetInterfaces(MethodTable* pMT, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -597,7 +598,7 @@ static PTRARRAYREF CopyRuntimeTypeHandles(TypeHandle * prgTH, INT32 numTypeHandl return refReturn; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetConstraints(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retTypeArray) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetConstraints(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retTypeArray, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -620,7 +621,7 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetConstraints(QCall END_QCALL; - + return; } FCIMPL1(INT32, RuntimeTypeHandle::GetAttributes, ReflectClassBaseObject *pTypeUNSAFE) @@ -645,7 +646,7 @@ FCIMPL1(INT32, RuntimeTypeHandle::GetAttributes, ReflectClassBaseObject *pTypeUN } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetArgumentTypesFromFunctionPointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack argTypes) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetArgumentTypesFromFunctionPointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack argTypes, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -707,7 +708,7 @@ FCIMPL1(FC_BOOL_RET, RuntimeTypeHandle::IsUnmanagedFunctionPointer, ReflectClass } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_IsVisible(QCall::TypeHandle pTypeHandle, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsVisible(QCall::TypeHandle pTypeHandle, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -725,9 +726,9 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_IsVisible(QCall::Typ fIsExternallyVisible = typeHandle.IsExternallyVisible(); - *pReturnValue = fIsExternallyVisible; - END_QCALL; + + return fIsExternallyVisible; } FCIMPL1(LPCUTF8, RuntimeTypeHandle::GetUtf8Name, MethodTable* pMT) @@ -776,14 +777,14 @@ FCIMPL1(INT32, RuntimeTypeHandle::GetToken, ReflectClassBaseObject *pTypeUNSAFE) } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE QCall_GetGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, INT32 handleType, PVOID* pReturnValue) +extern "C" PVOID QCALLTYPE QCall_GetGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, INT32 handleType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - OBJECTHANDLE objHandle = NULL; + BEGIN_QCALL; + GCX_COOP(); TypeHandle th = pTypeHandle.AsTypeHandle(); @@ -792,12 +793,12 @@ extern "C" QCallExceptionStatus QCALLTYPE QCall_GetGCHandleForTypeHandle(QCall:: objHandle = AppDomain::GetCurrentDomain()->CreateTypedHandle(NULL, static_cast(handleType)); th.GetLoaderAllocator()->RegisterHandleForCleanup(objHandle); - *pReturnValue = objHandle; - END_QCALL; + + return objHandle; } -extern "C" QCallExceptionStatus QCALLTYPE QCall_FreeGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, OBJECTHANDLE objHandle) +extern "C" void QCALLTYPE QCall_FreeGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, OBJECTHANDLE objHandle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -812,7 +813,7 @@ extern "C" QCallExceptionStatus QCALLTYPE QCall_FreeGCHandleForTypeHandle(QCall: END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_VerifyInterfaceIsImplemented(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pIFaceHandle) +extern "C" void QCALLTYPE RuntimeTypeHandle_VerifyInterfaceIsImplemented(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pIFaceHandle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -848,14 +849,14 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_VerifyInterfaceIsImp END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetInterfaceMethodImplementation(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pOwner, MethodDesc * pMD, MethodDesc** pReturnValue) +extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetInterfaceMethodImplementation(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pOwner, MethodDesc * pMD, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - MethodDesc* pResult = nullptr; + BEGIN_QCALL; + TypeHandle typeHandle = pTypeHandle.AsTypeHandle(); TypeHandle thOwnerOfMD = pOwner.AsTypeHandle(); @@ -879,12 +880,12 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetInterfaceMethodIm pResult = slot.GetMethodDesc(); } - *pReturnValue = pResult; - END_QCALL; + + return pResult; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetDeclaringMethodForGenericParameter(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack result) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetDeclaringMethodForGenericParameter(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -906,14 +907,14 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetDeclaringMethodFo END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandleForGenericVariable(EnregisteredTypeHandle pTypeHandle, EnregisteredTypeHandle* pReturnValue) +extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandleForGenericVariable(EnregisteredTypeHandle pTypeHandle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - TypeHandle retTypeHandle; + BEGIN_QCALL; + TypeHandle typeHandle = TypeHandle::FromPtr(pTypeHandle); _ASSERTE(typeHandle.IsGenericVariable()); @@ -946,19 +947,19 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHand retTypeHandle.CheckRestore(); } - *pReturnValue = (EnregisteredTypeHandle)retTypeHandle.AsTAddr(); - END_QCALL; + + return (EnregisteredTypeHandle)retTypeHandle.AsTAddr(); } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandle(EnregisteredTypeHandle pTypeHandle, EnregisteredTypeHandle* pReturnValue) +extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandle(EnregisteredTypeHandle pTypeHandle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - TypeHandle retTypeHandle; + BEGIN_QCALL; + TypeHandle typeHandle = TypeHandle::FromPtr(pTypeHandle); _ASSERTE(!typeHandle.IsTypeDesc()); @@ -980,12 +981,12 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHand } } - *pReturnValue = (EnregisteredTypeHandle)retTypeHandle.AsTAddr(); - END_QCALL; + + return (EnregisteredTypeHandle)retTypeHandle.AsTAddr(); } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_SatisfiesConstraints(QCall::TypeHandle paramType, QCall::TypeHandle typeContext, MethodDesc* methodContext, QCall::TypeHandle toType, BOOL* pReturnValue) +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_SatisfiesConstraints(QCall::TypeHandle paramType, QCall::TypeHandle typeContext, MethodDesc* methodContext, QCall::TypeHandle toType, QCallExceptionStatus* qcallError) { CONTRACTL { @@ -1013,12 +1014,12 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_SatisfiesConstraints TypeHandle thGenericArgument = toType.AsTypeHandle(); bResult = thGenericParameter.AsGenericVariable()->SatisfiesConstraints(&typeContext, thGenericArgument); - *pReturnValue = bResult; - END_QCALL; + + return bResult; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetInstantiation(QCall::TypeHandle pType, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetInstantiation(QCall::TypeHandle pType, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1030,10 +1031,10 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetInstantiation(QCa retTypes.Set(CopyRuntimeTypeHandles(inst.GetRawArgs(), inst.GetNumArgs(), fAsRuntimeTypeArray ? CLASS__CLASS : CLASS__TYPE)); END_QCALL; - + return; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakeArray(QCall::TypeHandle pTypeHandle, INT32 rank, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeArray(QCall::TypeHandle pTypeHandle, INT32 rank, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1045,10 +1046,10 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakeArray(QCall::Typ retType.Set(arrayHandle.GetManagedClassObject()); END_QCALL; - + return; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakeSZArray(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeSZArray(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1060,10 +1061,10 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakeSZArray(QCall::T retType.Set(arrayHandle.GetManagedClassObject()); END_QCALL; - + return; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakePointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE RuntimeTypeHandle_MakePointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1075,10 +1076,10 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakePointer(QCall::T retType.Set(pointerHandle.GetManagedClassObject()); END_QCALL; - + return; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1090,10 +1091,10 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::Typ retType.Set(byRefHandle.GetManagedClassObject()); END_QCALL; - + return; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakeFunctionPointer(TypeHandle* pRetAndArgTypes, INT32 numArgs, BOOL isUnmanaged, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeFunctionPointer(TypeHandle* pRetAndArgTypes, INT32 numArgs, BOOL isUnmanaged, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1106,10 +1107,10 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakeFunctionPointer( retType.Set(fnPtrHandle.GetManagedClassObject()); END_QCALL; - + return; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_Instantiate(QCall::TypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE RuntimeTypeHandle_Instantiate(QCall::TypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1121,10 +1122,10 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_Instantiate(QCall::T retType.Set(type.GetManagedClassObject()); END_QCALL; - + return; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetGenericTypeDefinition(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE RuntimeTypeHandle_GetGenericTypeDefinition(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1144,7 +1145,7 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetGenericTypeDefini END_QCALL; - + return; } FCIMPL2(FC_BOOL_RET, RuntimeTypeHandle::CompareCanonicalHandles, ReflectClassBaseObject *pLeftUNSAFE, ReflectClassBaseObject *pRightUNSAFE) @@ -1223,7 +1224,7 @@ FCIMPL1(FC_BOOL_RET, RuntimeTypeHandle::ContainsGenericVariables, PTR_ReflectCla } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemory(QCall::TypeHandle type, uint32_t size, void** pReturnValue) +extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemory(QCall::TypeHandle type, uint32_t size, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1241,12 +1242,12 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociat LoaderHeap* loaderHeap = loaderAllocator->GetHighFrequencyHeap(); allocatedMemory = loaderHeap->AllocMem(S_SIZE_T(size)); - *pReturnValue = allocatedMemory; - END_QCALL; + + return allocatedMemory; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemoryAligned(QCall::TypeHandle type, uint32_t size, uint32_t alignment, void** pReturnValue) +extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemoryAligned(QCall::TypeHandle type, uint32_t size, uint32_t alignment, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1267,12 +1268,12 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociat LoaderHeap* loaderHeap = loaderAllocator->GetHighFrequencyHeap(); allocatedMemory = loaderHeap->AllocAlignedMem(size, alignment); - *pReturnValue = allocatedMemory; - END_QCALL; + + return allocatedMemory; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_RegisterCollectibleTypeDependency(QCall::TypeHandle pTypeHandle, QCall::AssemblyHandle pAssembly) +extern "C" void QCALLTYPE RuntimeTypeHandle_RegisterCollectibleTypeDependency(QCall::TypeHandle pTypeHandle, QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1299,22 +1300,22 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_RegisterCollectibleT //*********************************************************************************** //*********************************************************************************** -extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetFunctionPointer(MethodDesc * pMethod, void ** pReturnValue) +extern "C" void * QCALLTYPE RuntimeMethodHandle_GetFunctionPointer(MethodDesc * pMethod, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - void* funcPtr = NULL; + BEGIN_QCALL; + // Ensure the method is active and all types have been loaded so the function pointer can be used. pMethod->EnsureActive(); pMethod->PrepareForUseAsAFunctionPointer(); funcPtr = (void*)pMethod->GetMultiCallableAddrOfCode(CORINFO_ACCESS_UNMANAGED_CALLER_MAYBE); - *pReturnValue = funcPtr; - END_QCALL; + + return funcPtr; } FCIMPL1(LPCUTF8, RuntimeMethodHandle::GetUtf8Name, MethodDesc* pMethod) @@ -1477,11 +1478,12 @@ FCIMPL3(INT32, SignatureNative::GetCallingConventionFromFunctionPointerAtOffsetI } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE Signature_GetCustomModifiersAtOffset( +extern "C" void QCALLTYPE Signature_GetCustomModifiersAtOffset( QCall::ObjectHandleOnStack sigObj, INT32 offset, BOOL fRequired, - QCall::ObjectHandleOnStack result) + QCall::ObjectHandleOnStack result, + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1601,11 +1603,12 @@ FCIMPL1(INT32, RuntimeMethodHandle::GetMethodDef, MethodDesc* pMethod) } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE Signature_Init( +extern "C" void QCALLTYPE Signature_Init( QCall::ObjectHandleOnStack sigObj, PCCOR_SIGNATURE pCorSig, DWORD cCorSig, FieldDesc* pFieldDesc, - MethodDesc* pMethodDesc) + MethodDesc* pMethodDesc, + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1704,27 +1707,28 @@ extern "C" QCallExceptionStatus QCALLTYPE Signature_Init( END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE Signature_AreEqual( +extern "C" BOOL QCALLTYPE Signature_AreEqual( PCCOR_SIGNATURE sig1, INT32 cSig1, QCall::TypeHandle handle1, - PCCOR_SIGNATURE sig2, INT32 cSig2, QCall::TypeHandle handle2, BOOL* pReturnValue) + PCCOR_SIGNATURE sig2, INT32 cSig2, QCall::TypeHandle handle2, + QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - BOOL ret = FALSE; + BEGIN_QCALL; + ret = MetaSig::CompareMethodSigs( sig1, cSig1, handle1.AsTypeHandle().GetModule(), NULL, sig2, cSig2, handle2.AsTypeHandle().GetModule(), NULL, FALSE); - *pReturnValue = ret; - END_QCALL; + + return ret; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray) +extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1735,7 +1739,7 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetMethodInstantia retTypes.Set(CopyRuntimeTypeHandles(inst.GetRawArgs(), inst.GetNumArgs(), fAsRuntimeTypeArray ? CLASS__CLASS : CLASS__TYPE)); END_QCALL; - + return; } FCIMPL1(FC_BOOL_RET, RuntimeMethodHandle::HasMethodInstantiation, MethodDesc * pMethod) @@ -1784,7 +1788,7 @@ FCIMPL1(Object*, RuntimeMethodHandle::GetResolver, MethodDesc * pMethod) } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_Destroy(MethodDesc * pMethod) +extern "C" void QCALLTYPE RuntimeMethodHandle_Destroy(MethodDesc * pMethod, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(pMethod != NULL); @@ -1828,7 +1832,7 @@ FCIMPL1(FC_BOOL_RET, RuntimeMethodHandle::IsTypicalMethodDefinition, ReflectMeth } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetTypicalMethodDefinition(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod) +extern "C" void QCALLTYPE RuntimeMethodHandle_GetTypicalMethodDefinition(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1847,10 +1851,10 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetTypicalMethodDe } END_QCALL; - + return; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_StripMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod) +extern "C" void QCALLTYPE RuntimeMethodHandle_StripMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1873,7 +1877,7 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_StripMethodInstant } END_QCALL; - + return; } // In the VM there might be more than one MethodDescs for a "method" @@ -1935,7 +1939,7 @@ FCIMPL2(MethodDesc*, RuntimeMethodHandle::GetStubIfNeededInternal, FCIMPLEND // See RuntimeMethodHandle::GetStubIfNeededInternal for more details. -extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetStubIfNeededSlow(MethodDesc* pMethod, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack methodInstantiation, MethodDesc** pReturnValue) +extern "C" MethodDesc* QCALLTYPE RuntimeMethodHandle_GetStubIfNeededSlow(MethodDesc* pMethod, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack methodInstantiation, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -1979,9 +1983,9 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetStubIfNeededSlo pNewMethod = MethodDesc::FindOrCreateAssociatedMethodDescForReflection(pMethod, instType, Instantiation(inst, ntypars)); - *pReturnValue = pNewMethod; - END_QCALL; + + return pNewMethod; } FCIMPL2(MethodDesc*, RuntimeMethodHandle::GetMethodFromCanonical, MethodDesc *pMethod, ReflectClassBaseObject *pTypeUNSAFE) @@ -2002,14 +2006,14 @@ FCIMPL2(MethodDesc*, RuntimeMethodHandle::GetMethodFromCanonical, MethodDesc *pM } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetNativeCode(MethodDesc* pMethod, PCODE* pReturnValue) +extern "C" PCODE QCALLTYPE RuntimeMethodHandle_GetNativeCode(MethodDesc* pMethod, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - PCODE result = (PCODE)NULL; + BEGIN_QCALL; + _ASSERTE(pMethod != NULL); while (pMethod->IsWrapperStub()) @@ -2024,12 +2028,12 @@ extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetNativeCode(Meth result = GetInterpreterCodeFromEntryPointIfPresent(pMethod->GetNativeCodeAnyVersion()); - *pReturnValue = result; - END_QCALL; + + return result; } -extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetMethodBody(MethodDesc* pMethod, QCall::TypeHandle pDeclaringType, QCall::ObjectHandleOnStack result) +extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodBody(MethodDesc* pMethod, QCall::TypeHandle pDeclaringType, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -2328,7 +2332,7 @@ FCIMPL1(INT32, AssemblyHandle::GetTokenInternal, AssemblyBaseObject* pAssemblyUN } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE AssemblyHandle_GetManifestModuleSlow(QCall::ObjectHandleOnStack assembly, QCall::ObjectHandleOnStack module) +extern "C" void QCALLTYPE AssemblyHandle_GetManifestModuleSlow(QCall::ObjectHandleOnStack assembly, QCall::ObjectHandleOnStack module, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -2343,7 +2347,7 @@ extern "C" QCallExceptionStatus QCALLTYPE AssemblyHandle_GetManifestModuleSlow(Q END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_GetPEKind(QCall::ModuleHandle pModule, DWORD* pdwPEKind, DWORD* pdwMachine) +extern "C" void QCALLTYPE ModuleHandle_GetPEKind(QCall::ModuleHandle pModule, DWORD* pdwPEKind, DWORD* pdwMachine, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -2359,7 +2363,7 @@ extern "C" INT32 QCALLTYPE ModuleHandle_GetMDStreamVersion(QCall::ModuleHandle p return pModule->GetMDImport()->GetMetadataStreamVersion(); } -extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_GetModuleType(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE ModuleHandle_GetModuleType(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -2381,7 +2385,7 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_GetModuleType(QCall::Modu END_QCALL; - + return; } extern "C" INT32 QCALLTYPE ModuleHandle_GetToken(QCall::ModuleHandle pModule) @@ -2391,7 +2395,7 @@ extern "C" INT32 QCALLTYPE ModuleHandle_GetToken(QCall::ModuleHandle pModule) return pModule->GetMDImport()->GetModuleFromScope(); } -extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_ResolveType(QCall::ModuleHandle pModule, INT32 tkType, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retType) +extern "C" void QCALLTYPE ModuleHandle_ResolveType(QCall::ModuleHandle pModule, INT32 tkType, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -2409,17 +2413,17 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_ResolveType(QCall::Module END_QCALL; - + return; } -extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_ResolveMethod(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, MethodDesc ** pReturnValue) +extern "C" MethodDesc *QCALLTYPE ModuleHandle_ResolveMethod(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - MethodDesc* pMD = NULL; + BEGIN_QCALL; + BOOL strictMetadataChecks = (TypeFromToken(tkMemberRef) == mdtMethodSpec); SigTypeContext typeContext(Instantiation(typeArgs, typeArgsCount), Instantiation(methodArgs, methodArgsCount)); @@ -2428,12 +2432,12 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_ResolveMethod(QCall::Modu // This will get us the instantiating or unboxing stub if needed pMD = MethodDesc::FindOrCreateAssociatedMethodDescForReflection(pMD, pMD->GetMethodTable(), pMD->GetMethodInstantiation()); - *pReturnValue = pMD; - END_QCALL; + + return pMD; } -extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_ResolveField(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retField) +extern "C" void QCALLTYPE ModuleHandle_ResolveField(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retField, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -2448,10 +2452,10 @@ extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_ResolveField(QCall::Modul END_QCALL; - + return; } -extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_GetDynamicMethod(QCall::ModuleHandle pModule, const char* name, byte* sig, INT32 sigLen, QCall::ObjectHandleOnStack resolver, QCall::ObjectHandleOnStack result) +extern "C" void QCALLTYPE ModuleHandle_GetDynamicMethod(QCall::ModuleHandle pModule, const char* name, byte* sig, INT32 sigLen, QCall::ObjectHandleOnStack resolver, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError) { CONTRACTL { diff --git a/src/coreclr/vm/runtimehandles.h b/src/coreclr/vm/runtimehandles.h index fbfdff19835ce8..0d366b257f5ab1 100644 --- a/src/coreclr/vm/runtimehandles.h +++ b/src/coreclr/vm/runtimehandles.h @@ -96,7 +96,7 @@ class RuntimeLocalVariableInfo : public Object CLR_BOOL _isPinned; }; -extern "C" QCallExceptionStatus QCALLTYPE MdUtf8String_EqualsCaseInsensitive(LPCUTF8 szLhs, LPCUTF8 szRhs, INT32 stringNumBytes, BOOL* pReturnValue); +extern "C" BOOL QCALLTYPE MdUtf8String_EqualsCaseInsensitive(LPCUTF8 szLhs, LPCUTF8 szRhs, INT32 stringNumBytes, QCallExceptionStatus* qcallError); class RuntimeTypeHandle { @@ -129,56 +129,57 @@ class RuntimeTypeHandle FCDECL1(static void, GetNextIntroducedMethod, MethodDesc **ppMethod); }; -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetRuntimeTypeFromHandleSlow(void* typeHandleRaw, QCall::ObjectHandleOnStack result); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetRuntimeTypeFromHandleSlow(void* typeHandleRaw, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); #ifdef FEATURE_TYPEEQUIVALENCE -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_IsEquivalentTo(QCall::TypeHandle rtType1, QCall::TypeHandle rtType2, BOOL* pReturnValue); +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsEquivalentTo(QCall::TypeHandle rtType1, QCall::TypeHandle rtType2, QCallExceptionStatus* qcallError); #endif // FEATURE_TYPEEQUIVALENCE -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_CreateInstanceForAnotherGenericParameter(QCall::TypeHandle pTypeHandle, TypeHandle *pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack pInstantiatedObject); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_InternalAlloc(MethodTable* pMT, QCall::ObjectHandleOnStack allocated); +extern "C" void QCALLTYPE RuntimeTypeHandle_CreateInstanceForAnotherGenericParameter(QCall::TypeHandle pTypeHandle, TypeHandle *pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack pInstantiatedObject, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAlloc(MethodTable* pMT, QCall::ObjectHandleOnStack allocated, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_InternalAllocNoChecks(MethodTable* pMT, QCall::ObjectHandleOnStack allocated); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemory(QCall::TypeHandle type, uint32_t size, void** pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemoryAligned(QCall::TypeHandle type, uint32_t size, uint32_t alignment, void** pReturnValue); +extern "C" void QCALLTYPE RuntimeTypeHandle_InternalAllocNoChecks(MethodTable* pMT, QCall::ObjectHandleOnStack allocated, QCallExceptionStatus* qcallError); +extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemory(QCall::TypeHandle type, uint32_t size, QCallExceptionStatus* qcallError); +extern "C" void* QCALLTYPE RuntimeTypeHandle_AllocateTypeAssociatedMemoryAligned(QCall::TypeHandle type, uint32_t size, uint32_t alignment, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE QCall_GetGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, INT32 handleType, PVOID* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE QCall_FreeGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, OBJECTHANDLE objHandle); +extern "C" PVOID QCALLTYPE QCall_GetGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, INT32 handleType, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE QCall_FreeGCHandleForTypeHandle(QCall::TypeHandle pTypeHandle, OBJECTHANDLE objHandle, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetActivationInfo( +extern "C" void QCALLTYPE RuntimeTypeHandle_GetActivationInfo( QCall::ObjectHandleOnStack pRuntimeType, PCODE* ppfnAllocator, void** pvAllocatorFirstArg, PCODE* ppfnCtor, PCODE* ppfnValueCtor, - BOOL* pfCtorIsPublic); + BOOL* pfCtorIsPublic, + QCallExceptionStatus* qcallError); #ifdef FEATURE_COMINTEROP -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_AllocateComObject(void* pClassFactory, QCall::ObjectHandleOnStack result); +extern "C" void QCALLTYPE RuntimeTypeHandle_AllocateComObject(void* pClassFactory, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); #endif // FEATURE_COMINTEROP -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakePointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakeSZArray(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakeArray(QCall::TypeHandle pTypeHandle, INT32 rank, QCall::ObjectHandleOnStack retType); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_MakeFunctionPointer(TypeHandle* pRetAndArgTypes, INT32 numArgs, BOOL isUnmanaged, QCall::ObjectHandleOnStack retType); +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_MakePointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeSZArray(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeArray(QCall::TypeHandle pTypeHandle, INT32 rank, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_MakeFunctionPointer(TypeHandle* pRetAndArgTypes, INT32 numArgs, BOOL isUnmanaged, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); extern "C" void QCALLTYPE RuntimeTypeHandle_PrepareMemberInfoCache(QCall::TypeHandle pMemberInfoCache); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_ConstructName(QCall::TypeHandle pTypeHandle, DWORD format, QCall::StringHandleOnStack retString); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetInterfaces(MethodTable* pMT, QCall::ObjectHandleOnStack result); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_IsVisible(QCall::TypeHandle pTypeHandle, BOOL* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_SatisfiesConstraints(QCall::TypeHandle paramType, QCall::TypeHandle typeContext, MethodDesc* methodContext, QCall::TypeHandle toType, BOOL* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetInstantiation(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, BOOL fAsRuntimeTypeArray); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_Instantiate(QCall::TypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetGenericTypeDefinition(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetConstraints(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retTypes); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetArgumentTypesFromFunctionPointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack argTypes); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetAssemblySlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack assembly); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetModuleSlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack module); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals(QCall::TypeHandle pTypeHandle, INT32* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetMethodAt(MethodTable* pMT, INT32 slot, MethodDesc** pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetFields(MethodTable* pMT, intptr_t* result, INT32* pCount, BOOL* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_VerifyInterfaceIsImplemented(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pIFaceHandle); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetInterfaceMethodImplementation(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pOwner, MethodDesc * pMD, MethodDesc** pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetDeclaringMethodForGenericParameter(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack result); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandleForGenericVariable(EnregisteredTypeHandle pTypeHandle, EnregisteredTypeHandle* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandle(EnregisteredTypeHandle pTypeHandle, EnregisteredTypeHandle* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeTypeHandle_RegisterCollectibleTypeDependency(QCall::TypeHandle pTypeHandle, QCall::AssemblyHandle pAssembly); +extern "C" void QCALLTYPE RuntimeTypeHandle_ConstructName(QCall::TypeHandle pTypeHandle, DWORD format, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetInterfaces(MethodTable* pMT, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsVisible(QCall::TypeHandle pTypeHandle, QCallExceptionStatus* qcallError); +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_SatisfiesConstraints(QCall::TypeHandle paramType, QCall::TypeHandle typeContext, MethodDesc* methodContext, QCall::TypeHandle toType, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetInstantiation(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, BOOL fAsRuntimeTypeArray, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_Instantiate(QCall::TypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetGenericTypeDefinition(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetConstraints(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retTypes, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetArgumentTypesFromFunctionPointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack argTypes, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetAssemblySlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack assembly, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetModuleSlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack module, QCallExceptionStatus* qcallError); +extern "C" INT32 QCALLTYPE RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals(QCall::TypeHandle pTypeHandle, QCallExceptionStatus* qcallError); +extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetMethodAt(MethodTable* pMT, INT32 slot, QCallExceptionStatus* qcallError); +extern "C" BOOL QCALLTYPE RuntimeTypeHandle_GetFields(MethodTable* pMT, intptr_t* result, INT32* pCount, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_VerifyInterfaceIsImplemented(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pIFaceHandle, QCallExceptionStatus* qcallError); +extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetInterfaceMethodImplementation(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pOwner, MethodDesc * pMD, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetDeclaringMethodForGenericParameter(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); +extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandleForGenericVariable(EnregisteredTypeHandle pTypeHandle, QCallExceptionStatus* qcallError); +extern "C" EnregisteredTypeHandle QCALLTYPE RuntimeTypeHandle_GetDeclaringTypeHandle(EnregisteredTypeHandle pTypeHandle, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeTypeHandle_RegisterCollectibleTypeDependency(QCall::TypeHandle pTypeHandle, QCall::AssemblyHandle pAssembly, QCallExceptionStatus* qcallError); class RuntimeMethodHandle { @@ -213,33 +214,34 @@ class RuntimeMethodHandle FCDECL1(static Object*, GetLoaderAllocatorInternal, MethodDesc *pMethod); }; -extern "C" QCallExceptionStatus QCALLTYPE MethodBase_GetCurrentMethod(QCall::StackCrawlMarkHandle stackMark, MethodDesc** pReturnValue); +extern "C" MethodDesc* QCALLTYPE MethodBase_GetCurrentMethod(QCall::StackCrawlMarkHandle stackMark, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_IsCAVisibleFromDecoratedType( +extern "C" BOOL QCALLTYPE RuntimeMethodHandle_IsCAVisibleFromDecoratedType( QCall::TypeHandle targetTypeHandle, MethodDesc * pTargetCtor, QCall::TypeHandle sourceTypeHandle, QCall::ModuleHandle sourceModuleHandle, - BOOL* pReturnValue); + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray); +extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_InvokeMethod( +extern "C" void QCALLTYPE RuntimeMethodHandle_InvokeMethod( QCall::ObjectHandleOnStack target, PVOID* args, QCall::ObjectHandleOnStack pSigUNSAFE, BOOL fConstructor, - QCall::ObjectHandleOnStack result); + QCall::ObjectHandleOnStack result, + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_ConstructInstantiation(MethodDesc * pMethod, DWORD format, QCall::StringHandleOnStack retString); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetFunctionPointer(MethodDesc * pMethod, void ** pReturnValue); +extern "C" void QCALLTYPE RuntimeMethodHandle_ConstructInstantiation(MethodDesc * pMethod, DWORD format, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError); +extern "C" void* QCALLTYPE RuntimeMethodHandle_GetFunctionPointer(MethodDesc * pMethod, QCallExceptionStatus* qcallError); extern "C" BOOL QCALLTYPE RuntimeMethodHandle_GetIsCollectible(MethodDesc * pMethod); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetTypicalMethodDefinition(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_StripMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_Destroy(MethodDesc * pMethod); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetStubIfNeededSlow(MethodDesc* pMethod, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack methodInstantiation, MethodDesc** pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetNativeCode(MethodDesc* pMethod, PCODE* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeMethodHandle_GetMethodBody(MethodDesc* pMethod, QCall::TypeHandle pDeclaringType, QCall::ObjectHandleOnStack result); +extern "C" void QCALLTYPE RuntimeMethodHandle_GetTypicalMethodDefinition(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeMethodHandle_StripMethodInstantiation(MethodDesc * pMethod, QCall::ObjectHandleOnStack refMethod, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeMethodHandle_Destroy(MethodDesc * pMethod, QCallExceptionStatus* qcallError); +extern "C" MethodDesc* QCALLTYPE RuntimeMethodHandle_GetStubIfNeededSlow(MethodDesc* pMethod, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack methodInstantiation, QCallExceptionStatus* qcallError); +extern "C" PCODE QCALLTYPE RuntimeMethodHandle_GetNativeCode(MethodDesc* pMethod, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeMethodHandle_GetMethodBody(MethodDesc* pMethod, QCall::TypeHandle pDeclaringType, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); class RuntimeFieldHandle { @@ -257,28 +259,28 @@ class RuntimeFieldHandle FCDECL1(static Object*, GetLoaderAllocatorInternal, FieldDesc *pField); }; -extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL *pIsClassInitialized, QCall::ObjectHandleOnStack result); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_SetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::ObjectHandleOnStack value, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack result); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_SetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::ObjectHandleOnStack newValue, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetEnCFieldAddr(QCall::ObjectHandleOnStack target, FieldDesc* pFD, void** pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetRVAFieldInfo(FieldDesc* pField, void** address, UINT* size, BOOL* pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE RuntimeFieldHandle_GetFieldDataReference(FieldDesc* pField, QCall::ObjectHandleOnStack instance, QCall::ByteRefOnStack offset); +extern "C" void QCALLTYPE RuntimeFieldHandle_GetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL *pIsClassInitialized, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeFieldHandle_SetValue(FieldDesc* fieldDesc, QCall::ObjectHandleOnStack instance, QCall::ObjectHandleOnStack value, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, BOOL* pIsClassInitialized, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeFieldHandle_GetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::TypeHandle fieldTypeHandle, QCall::TypeHandle declaringTypeHandle, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeFieldHandle_SetValueDirect(FieldDesc* fieldDesc, TypedByRef *pTarget, QCall::ObjectHandleOnStack newValue, QCall::TypeHandle fieldType, QCall::TypeHandle declaringType, QCallExceptionStatus* qcallError); +extern "C" void* QCALLTYPE RuntimeFieldHandle_GetEnCFieldAddr(QCall::ObjectHandleOnStack target, FieldDesc* pFD, QCallExceptionStatus* qcallError); +extern "C" BOOL QCALLTYPE RuntimeFieldHandle_GetRVAFieldInfo(FieldDesc* pField, void** address, UINT* size, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE RuntimeFieldHandle_GetFieldDataReference(FieldDesc* pField, QCall::ObjectHandleOnStack instance, QCall::ByteRefOnStack offset, QCallExceptionStatus* qcallError); extern "C" INT32 QCALLTYPE ModuleHandle_GetMDStreamVersion(QCall::ModuleHandle pModule); -extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_GetModuleType(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retType); +extern "C" void QCALLTYPE ModuleHandle_GetModuleType(QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); extern "C" INT32 QCALLTYPE ModuleHandle_GetToken(QCall::ModuleHandle pModule); -extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_ResolveType(QCall::ModuleHandle pModule, INT32 tkType, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retType); +extern "C" void QCALLTYPE ModuleHandle_ResolveType(QCall::ModuleHandle pModule, INT32 tkType, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retType, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_ResolveMethod(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, MethodDesc ** pReturnValue); +extern "C" MethodDesc * QCALLTYPE ModuleHandle_ResolveMethod(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_ResolveField(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retField); +extern "C" void QCALLTYPE ModuleHandle_ResolveField(QCall::ModuleHandle pModule, INT32 tkMemberRef, TypeHandle *typeArgs, INT32 typeArgsCount, TypeHandle *methodArgs, INT32 methodArgsCount, QCall::ObjectHandleOnStack retField, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_GetPEKind(QCall::ModuleHandle pModule, DWORD* pdwPEKind, DWORD* pdwMachine); +extern "C" void QCALLTYPE ModuleHandle_GetPEKind(QCall::ModuleHandle pModule, DWORD* pdwPEKind, DWORD* pdwMachine, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE ModuleHandle_GetDynamicMethod(QCall::ModuleHandle pModule, const char* name, byte* sig, INT32 sigLen, QCall::ObjectHandleOnStack resolver, QCall::ObjectHandleOnStack result); +extern "C" void QCALLTYPE ModuleHandle_GetDynamicMethod(QCall::ModuleHandle pModule, const char* name, byte* sig, INT32 sigLen, QCall::ObjectHandleOnStack resolver, QCall::ObjectHandleOnStack result, QCallExceptionStatus* qcallError); class AssemblyHandle { @@ -287,31 +289,35 @@ class AssemblyHandle FCDECL1(static INT32, GetTokenInternal, AssemblyBaseObject *pAssemblyUNSAFE); }; -extern "C" QCallExceptionStatus QCALLTYPE AssemblyHandle_GetManifestModuleSlow(QCall::ObjectHandleOnStack assembly, QCall::ObjectHandleOnStack module); +extern "C" void QCALLTYPE AssemblyHandle_GetManifestModuleSlow(QCall::ObjectHandleOnStack assembly, QCall::ObjectHandleOnStack module, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE Signature_Init( +extern "C" void QCALLTYPE Signature_Init( QCall::ObjectHandleOnStack sigObj, PCCOR_SIGNATURE pCorSig, DWORD cCorSig, FieldDesc* pFieldDesc, - MethodDesc* pMethodDesc); + MethodDesc* pMethodDesc, + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE Signature_AreEqual( +extern "C" BOOL QCALLTYPE Signature_AreEqual( PCCOR_SIGNATURE sig1, INT32 cSig1, QCall::TypeHandle handle1, - PCCOR_SIGNATURE sig2, INT32 cSig2, QCall::TypeHandle handle2, BOOL* pReturnValue); + PCCOR_SIGNATURE sig2, INT32 cSig2, QCall::TypeHandle handle2, + QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE Signature_GetCustomModifiersAtOffset( +extern "C" void QCALLTYPE Signature_GetCustomModifiersAtOffset( QCall::ObjectHandleOnStack sigObj, INT32 offset, BOOL fRequired, - QCall::ObjectHandleOnStack result); + QCall::ObjectHandleOnStack result, + QCallExceptionStatus* qcallError); class SignatureNative : public Object { - friend QCallExceptionStatus QCALLTYPE Signature_Init( + friend void QCALLTYPE Signature_Init( QCall::ObjectHandleOnStack sigObj, PCCOR_SIGNATURE pCorSig, DWORD cCorSig, FieldDesc* pFieldDesc, - MethodDesc* pMethodDesc); + MethodDesc* pMethodDesc, + QCallExceptionStatus* qcallError); friend class ArgIteratorForMethodInvoke; public: diff --git a/src/coreclr/vm/stackwalk.h b/src/coreclr/vm/stackwalk.h index 463e34ba9f8887..dc6ae465668ea8 100644 --- a/src/coreclr/vm/stackwalk.h +++ b/src/coreclr/vm/stackwalk.h @@ -40,7 +40,7 @@ namespace AsmOffsetsAsserts class AsmOffsets; }; -extern "C" QCallExceptionStatus QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo); +extern "C" void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo, QCallExceptionStatus* qcallError); class CrawlFrame { @@ -403,7 +403,7 @@ class CrawlFrame friend class EECodeManager; friend class StackFrameIterator; friend struct ExInfo; - friend QCallExceptionStatus QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo); + friend void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack exceptionObj, SIZE_T ip, SIZE_T sp, int flags, ExInfo *pExInfo, QCallExceptionStatus* qcallError); bool isFrameless; bool isFirst; diff --git a/src/coreclr/vm/stubhelpers.cpp b/src/coreclr/vm/stubhelpers.cpp index 22a92f9c5374a1..3377c840b8a868 100644 --- a/src/coreclr/vm/stubhelpers.cpp +++ b/src/coreclr/vm/stubhelpers.cpp @@ -304,7 +304,7 @@ FCIMPLEND #include -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_GetCOMIPFromRCWSlow(QCall::ObjectHandleOnStack pSrc, MethodTable* pInterfaceMT, INT32 comSlot, void** ppTarget, BOOL* pfNeedsRelease, IUnknown** pReturnValue) +extern "C" IUnknown* QCALLTYPE StubHelpers_GetCOMIPFromRCWSlow(QCall::ObjectHandleOnStack pSrc, MethodTable* pInterfaceMT, INT32 comSlot, void** ppTarget, BOOL* pfNeedsRelease, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(pInterfaceMT != NULL); @@ -345,12 +345,12 @@ extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_GetCOMIPFromRCWSlow(QCall: GCPROTECT_END(); - *pReturnValue = pIntf; - END_QCALL; + + return pIntf; } -extern "C" QCallExceptionStatus QCALLTYPE ObjectMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pSrcUNSAFE, VARIANT* pDest) +extern "C" void QCALLTYPE ObjectMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pSrcUNSAFE, VARIANT* pDest, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -375,7 +375,7 @@ extern "C" QCallExceptionStatus QCALLTYPE ObjectMarshaler_ConvertToNative(QCall: END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE ObjectMarshaler_ConvertToManaged(VARIANT* pSrc, QCall::ObjectHandleOnStack retObject) +extern "C" void QCALLTYPE ObjectMarshaler_ConvertToManaged(VARIANT* pSrc, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -397,7 +397,7 @@ extern "C" QCallExceptionStatus QCALLTYPE ObjectMarshaler_ConvertToManaged(VARIA } #include -extern "C" QCallExceptionStatus QCALLTYPE InterfaceMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pObjUNSAFE, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, IUnknown** pReturnValue) +extern "C" IUnknown* QCALLTYPE InterfaceMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pObjUNSAFE, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -416,12 +416,12 @@ extern "C" QCallExceptionStatus QCALLTYPE InterfaceMarshaler_ConvertToNative(QCa GCPROTECT_END(); - *pReturnValue = pIntf; - END_QCALL; + + return pIntf; } -extern "C" QCallExceptionStatus QCALLTYPE InterfaceMarshaler_ConvertToManaged(IUnknown** ppUnk, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCall::ObjectHandleOnStack retObject) +extern "C" void QCALLTYPE InterfaceMarshaler_ConvertToManaged(IUnknown** ppUnk, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -444,7 +444,7 @@ extern "C" QCallExceptionStatus QCALLTYPE InterfaceMarshaler_ConvertToManaged(IU } #include -extern "C" QCallExceptionStatus QCALLTYPE InterfaceMarshaler_GetObjectForComCallableWrapperIUnknown(IUnknown* unk, QCall::ObjectHandleOnStack retObject) +extern "C" void QCALLTYPE InterfaceMarshaler_GetObjectForComCallableWrapperIUnknown(IUnknown* unk, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -457,7 +457,7 @@ extern "C" QCallExceptionStatus QCALLTYPE InterfaceMarshaler_GetObjectForComCall END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE InterfaceMarshaler_ValidateComVisibilityForIUnknown(IUnknown* unk) +extern "C" void QCALLTYPE InterfaceMarshaler_ValidateComVisibilityForIUnknown(IUnknown* unk, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -483,7 +483,7 @@ FCIMPL0(void, StubHelpers::ClearLastError) } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ThrowInteropParamException(INT resID, INT paramIdx) +extern "C" void QCALLTYPE StubHelpers_ThrowInteropParamException(INT resID, INT paramIdx, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -495,7 +495,7 @@ extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ThrowInteropParamException // Throws an interop failure that was detected while the stub was being generated. Stubs that are // created while their caller is being jitted report their failures this way so that a call site // that is never executed does not fail the compilation of the method containing it. -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ThrowInteropException(INT exceptionKind, INT resID) +extern "C" void QCALLTYPE StubHelpers_ThrowInteropException(INT exceptionKind, INT resID, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -505,7 +505,7 @@ extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ThrowInteropException(INT } #ifdef PROFILING_SUPPORTED -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ProfilerBeginTransitionCallback(MethodDesc* pTargetMD, void** pReturnValue) +extern "C" void* QCALLTYPE StubHelpers_ProfilerBeginTransitionCallback(MethodDesc* pTargetMD, QCallExceptionStatus* qcallError) { PreserveLastErrorHolder preserveLastError; @@ -515,12 +515,12 @@ extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ProfilerBeginTransitionCal ProfilerManagedToUnmanagedTransitionMD(pTargetMD, COR_PRF_TRANSITION_CALL); - *pReturnValue = pTargetMD; - END_QCALL; + + return pTargetMD; } -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ProfilerEndTransitionCallback(MethodDesc* pTargetMD) +extern "C" void QCALLTYPE StubHelpers_ProfilerEndTransitionCallback(MethodDesc* pTargetMD, QCallExceptionStatus* qcallError) { PreserveLastErrorHolder preserveLastError; @@ -535,7 +535,7 @@ extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ProfilerEndTransitionCallb #endif // PROFILING_SUPPORTED #ifdef FEATURE_VARARGS -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_MarshalToManagedVaList(va_list va, VARARGS* pArgIterator) +extern "C" void QCALLTYPE StubHelpers_MarshalToManagedVaList(va_list va, VARARGS* pArgIterator, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -544,7 +544,7 @@ extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_MarshalToManagedVaList(va_ END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_MarshalToUnmanagedVaList(va_list va, DWORD cbVaListSize, const VARARGS* pArgIterator) +extern "C" void QCALLTYPE StubHelpers_MarshalToUnmanagedVaList(va_list va, DWORD cbVaListSize, const VARARGS* pArgIterator, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -554,7 +554,7 @@ extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_MarshalToUnmanagedVaList(v } #endif // FEATURE_VARARGS -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ValidateObject(QCall::ObjectHandleOnStack pObj, MethodDesc *pMD) +extern "C" void QCALLTYPE StubHelpers_ValidateObject(QCall::ObjectHandleOnStack pObj, MethodDesc *pMD, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -585,14 +585,15 @@ extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ValidateObject(QCall::Obje END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ValidateByref(void *pByref, MethodDesc *pMD) +extern "C" void QCALLTYPE StubHelpers_ValidateByref(void *pByref, MethodDesc *pMD, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; // Skip byref if is not pointing inside managed heap if (!GCHeapUtilities::GetGCHeap()->IsHeapPointer(pByref)) { - return QCallExceptionStatus(); + *qcallError = 0; + return; } BEGIN_QCALL; @@ -675,7 +676,7 @@ FCIMPL1(DWORD, StubHelpers::CalcVaListSize, VARARGS *varargs) FCIMPLEND #endif // FEATURE_VARARGS -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_MulticastDebuggerTraceHelper(QCall::ObjectHandleOnStack element, INT32 count) +extern "C" void QCALLTYPE StubHelpers_MulticastDebuggerTraceHelper(QCall::ObjectHandleOnStack element, INT32 count, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -688,7 +689,7 @@ extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_MulticastDebuggerTraceHelp END_QCALL; } -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_CreateLayoutClassMarshalStubs(QCall::TypeHandle th, PCODE* pConvertToUnmanaged, PCODE* pConvertToManaged, PCODE* pFree) +extern "C" void QCALLTYPE StubHelpers_CreateLayoutClassMarshalStubs(QCall::TypeHandle th, PCODE* pConvertToUnmanaged, PCODE* pConvertToManaged, PCODE* pFree, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/stubhelpers.h b/src/coreclr/vm/stubhelpers.h index ee5d0b79a2a269..c18915952f3a53 100644 --- a/src/coreclr/vm/stubhelpers.h +++ b/src/coreclr/vm/stubhelpers.h @@ -38,37 +38,37 @@ class StubHelpers #endif // FEATURE_VARARGS }; -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_CreateCustomMarshaler(MethodDesc* pMD, mdToken paramToken, TypeHandle hndManagedType, QCall::ObjectHandleOnStack retObject); +extern "C" void QCALLTYPE StubHelpers_CreateCustomMarshaler(MethodDesc* pMD, mdToken paramToken, TypeHandle hndManagedType, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); #ifdef PROFILING_SUPPORTED -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ProfilerBeginTransitionCallback(MethodDesc* pTargetMD, void** pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ProfilerEndTransitionCallback(MethodDesc* pTargetMD); +extern "C" void* QCALLTYPE StubHelpers_ProfilerBeginTransitionCallback(MethodDesc* pTargetMD, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE StubHelpers_ProfilerEndTransitionCallback(MethodDesc* pTargetMD, QCallExceptionStatus* qcallError); #endif #ifdef FEATURE_COMINTEROP -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_GetCOMIPFromRCWSlow(QCall::ObjectHandleOnStack pSrc, MethodTable* pInterfaceMT, INT32 comSlot, void** ppTarget, BOOL* pfNeedsRelease, IUnknown** pReturnValue); +extern "C" IUnknown* QCALLTYPE StubHelpers_GetCOMIPFromRCWSlow(QCall::ObjectHandleOnStack pSrc, MethodTable* pInterfaceMT, INT32 comSlot, void** ppTarget, BOOL* pfNeedsRelease, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE ObjectMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pSrcUNSAFE, VARIANT* pDest); -extern "C" QCallExceptionStatus QCALLTYPE ObjectMarshaler_ConvertToManaged(VARIANT* pSrc, QCall::ObjectHandleOnStack retObject); +extern "C" void QCALLTYPE ObjectMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pSrcUNSAFE, VARIANT* pDest, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ObjectMarshaler_ConvertToManaged(VARIANT* pSrc, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE InterfaceMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pObjUNSAFE, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, IUnknown** pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE InterfaceMarshaler_ConvertToManaged(IUnknown** ppUnk, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCall::ObjectHandleOnStack retObject); -extern "C" QCallExceptionStatus QCALLTYPE InterfaceMarshaler_GetObjectForComCallableWrapperIUnknown(IUnknown* unk, QCall::ObjectHandleOnStack retObject); -extern "C" QCallExceptionStatus QCALLTYPE InterfaceMarshaler_ValidateComVisibilityForIUnknown(IUnknown* unk); +extern "C" IUnknown* QCALLTYPE InterfaceMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pObjUNSAFE, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE InterfaceMarshaler_ConvertToManaged(IUnknown** ppUnk, MethodTable* pItfMT, MethodTable* pClsMT, DWORD dwFlags, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE InterfaceMarshaler_GetObjectForComCallableWrapperIUnknown(IUnknown* unk, QCall::ObjectHandleOnStack retObject, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE InterfaceMarshaler_ValidateComVisibilityForIUnknown(IUnknown* unk, QCallExceptionStatus* qcallError); #endif -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ThrowInteropParamException(INT resID, INT paramIdx); -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ThrowInteropException(INT exceptionKind, INT resID); +extern "C" void QCALLTYPE StubHelpers_ThrowInteropParamException(INT resID, INT paramIdx, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE StubHelpers_ThrowInteropException(INT exceptionKind, INT resID, QCallExceptionStatus* qcallError); #ifdef FEATURE_VARARGS -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_MarshalToManagedVaList(va_list va, VARARGS* pArgIterator); -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_MarshalToUnmanagedVaList(va_list va, DWORD cbVaListSize, const VARARGS* pArgIterator); +extern "C" void QCALLTYPE StubHelpers_MarshalToManagedVaList(va_list va, VARARGS* pArgIterator, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE StubHelpers_MarshalToUnmanagedVaList(va_list va, DWORD cbVaListSize, const VARARGS* pArgIterator, QCallExceptionStatus* qcallError); #endif // FEATURE_VARARGS -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ValidateObject(QCall::ObjectHandleOnStack pObj, MethodDesc *pMD); -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_ValidateByref(void *pByref, MethodDesc *pMD); +extern "C" void QCALLTYPE StubHelpers_ValidateObject(QCall::ObjectHandleOnStack pObj, MethodDesc *pMD, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE StubHelpers_ValidateByref(void *pByref, MethodDesc *pMD, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_MulticastDebuggerTraceHelper(QCall::ObjectHandleOnStack element, INT32 count); +extern "C" void QCALLTYPE StubHelpers_MulticastDebuggerTraceHelper(QCall::ObjectHandleOnStack element, INT32 count, QCallExceptionStatus* qcallError); -extern "C" QCallExceptionStatus QCALLTYPE StubHelpers_CreateLayoutClassMarshalStubs(QCall::TypeHandle th, PCODE* pConvertToUnmanaged, PCODE* pConvertToManaged, PCODE* pFree); +extern "C" void QCALLTYPE StubHelpers_CreateLayoutClassMarshalStubs(QCall::TypeHandle th, PCODE* pConvertToUnmanaged, PCODE* pConvertToManaged, PCODE* pFree, QCallExceptionStatus* qcallError); #endif // __STUBHELPERS_h__ diff --git a/src/coreclr/vm/tailcallhelp.cpp b/src/coreclr/vm/tailcallhelp.cpp index 05227b70fd9e3c..0f6beee9c1a902 100644 --- a/src/coreclr/vm/tailcallhelp.cpp +++ b/src/coreclr/vm/tailcallhelp.cpp @@ -21,19 +21,19 @@ FCIMPL0(void*, TailCallHelp::GetTailCallArgBuffer) } FCIMPLEND -extern "C" QCallExceptionStatus QCALLTYPE TailCallHelp_AllocTailCallArgBufferInternal(int size, void** pReturnValue) +extern "C" void* QCALLTYPE TailCallHelp_AllocTailCallArgBufferInternal(int size, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - void* retVal = NULL; - retVal = GetThread()->GetTailCallTls()->AllocArgBuffer(size); + BEGIN_QCALL; - *pReturnValue = retVal; + retVal = GetThread()->GetTailCallTls()->AllocArgBuffer(size); END_QCALL; + + return retVal; } FCIMPL2(void*, TailCallHelp::GetTailCallInfo, void** retAddrSlot, void** retAddr) diff --git a/src/coreclr/vm/tailcallhelp.h b/src/coreclr/vm/tailcallhelp.h index fe4703994cfac0..a5bc1c76a89af4 100644 --- a/src/coreclr/vm/tailcallhelp.h +++ b/src/coreclr/vm/tailcallhelp.h @@ -47,6 +47,6 @@ class TailCallHelp static void* AllocateBlob(LoaderAllocator* alloc, const void* blob, size_t blobLen); }; -extern "C" QCallExceptionStatus QCALLTYPE TailCallHelp_AllocTailCallArgBufferInternal(int size, void** pReturnValue); +extern "C" void* QCALLTYPE TailCallHelp_AllocTailCallArgBufferInternal(int size, QCallExceptionStatus* qcallError); #endif diff --git a/src/coreclr/vm/unsafeaccessors.cpp b/src/coreclr/vm/unsafeaccessors.cpp index 76a0c2f716eb58..d0e89005dfb1b6 100644 --- a/src/coreclr/vm/unsafeaccessors.cpp +++ b/src/coreclr/vm/unsafeaccessors.cpp @@ -1172,15 +1172,15 @@ bool MethodDesc::TryGenerateUnsafeAccessor(DynamicResolver** resolver, COR_ILMET return true; } -extern "C" QCallExceptionStatus QCALLTYPE UnsafeAccessors_ResolveGenericParamToTypeHandle(MethodDesc* unsafeAccessorMethod, BOOL isMethodParam, DWORD paramIndex, void** pReturnValue) +extern "C" void* QCALLTYPE UnsafeAccessors_ResolveGenericParamToTypeHandle(MethodDesc* unsafeAccessorMethod, BOOL isMethodParam, DWORD paramIndex, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; _ASSERTE(unsafeAccessorMethod != NULL); - BEGIN_QCALL; - TypeHandle ret; + BEGIN_QCALL; + MethodDesc* typicalMD = unsafeAccessorMethod->LoadTypicalMethodDefinition(); Instantiation genericParams = isMethodParam ? typicalMD->GetMethodInstantiation() @@ -1189,7 +1189,7 @@ extern "C" QCallExceptionStatus QCALLTYPE UnsafeAccessors_ResolveGenericParamToT if (0 <= paramIndex && paramIndex < genericParams.GetNumArgs()) ret = genericParams[paramIndex]; - *pReturnValue = ret.AsPtr(); - END_QCALL; + + return ret.AsPtr(); } diff --git a/src/coreclr/vm/varargsnative.cpp b/src/coreclr/vm/varargsnative.cpp index 19efbfa37281f3..0dbc1c4c7c99d3 100644 --- a/src/coreclr/vm/varargsnative.cpp +++ b/src/coreclr/vm/varargsnative.cpp @@ -167,7 +167,7 @@ static void AdvanceArgPtr(VARARGS *data) // ArgIterator constructor that initializes the state to support iteration // of the args starting at the first optional argument. //////////////////////////////////////////////////////////////////////////////// -extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_Init(VARARGS* data, PVOID cookie) +extern "C" void QCALLTYPE ArgIterator_Init(VARARGS* data, PVOID cookie, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -189,7 +189,7 @@ extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_Init(VARARGS* data, PVOID // Specifying NULL as the firstArg parameter causes it to start at the first // argument to the call. //////////////////////////////////////////////////////////////////////////////// -extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_Init2(VARARGS* data, PVOID cookie, PVOID firstArg) +extern "C" void QCALLTYPE ArgIterator_Init2(VARARGS* data, PVOID cookie, PVOID firstArg, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -461,14 +461,14 @@ static void GetNextArgHelper(VARARGS* data, TypedByRef* value, BOOL fData) //////////////////////////////////////////////////////////////////////////////// // Retrieve the type of the next argument without consuming it. //////////////////////////////////////////////////////////////////////////////// -extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_GetNextArgType(VARARGS* data, void** pReturnValue) +extern "C" void* QCALLTYPE ArgIterator_GetNextArgType(VARARGS* data, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - TypedByRef value = { }; + BEGIN_QCALL; + GCX_COOP(); _ASSERT(value.data == NULL); @@ -481,16 +481,16 @@ extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_GetNextArgType(VARARGS* da GCPROTECT_END(); - *pReturnValue = value.type.AsPtr(); - END_QCALL; + + return value.type.AsPtr(); } //////////////////////////////////////////////////////////////////////////////// // Retrieve the next argument and return it in a TypedByRef and advance the // next argument pointer. //////////////////////////////////////////////////////////////////////////////// -extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_GetNextArg(VARARGS* data, TypedByRef* pResult) +extern "C" void QCALLTYPE ArgIterator_GetNextArg(VARARGS* data, TypedByRef* pResult, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; @@ -506,7 +506,7 @@ extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_GetNextArg(VARARGS* data, // Retrieve the next argument and return it in a TypedByRef and advance the // next argument pointer. //////////////////////////////////////////////////////////////////////////////// -extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_GetNextArg2(VARARGS* data, QCall::TypeHandle pType, TypedByRef* pResult) +extern "C" void QCALLTYPE ArgIterator_GetNextArg2(VARARGS* data, QCall::TypeHandle pType, TypedByRef* pResult, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; diff --git a/src/coreclr/vm/varargsnative.h b/src/coreclr/vm/varargsnative.h index 93bf2f6db65916..0c80adb1f2ad46 100644 --- a/src/coreclr/vm/varargsnative.h +++ b/src/coreclr/vm/varargsnative.h @@ -14,10 +14,10 @@ #include "clrvarargs.h" -extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_Init(VARARGS* thisPtr, PVOID cookie); -extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_Init2(VARARGS* thisPtr, PVOID cookie, PVOID firstArg); -extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_GetNextArgType(VARARGS* thisPtr, void** pReturnValue); -extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_GetNextArg(VARARGS* thisPtr, TypedByRef* pResult); -extern "C" QCallExceptionStatus QCALLTYPE ArgIterator_GetNextArg2(VARARGS* thisPtr, QCall::TypeHandle pType, TypedByRef* pResult); +extern "C" void QCALLTYPE ArgIterator_Init(VARARGS* thisPtr, PVOID cookie, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ArgIterator_Init2(VARARGS* thisPtr, PVOID cookie, PVOID firstArg, QCallExceptionStatus* qcallError); +extern "C" void* QCALLTYPE ArgIterator_GetNextArgType(VARARGS* thisPtr, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ArgIterator_GetNextArg(VARARGS* thisPtr, TypedByRef* pResult, QCallExceptionStatus* qcallError); +extern "C" void QCALLTYPE ArgIterator_GetNextArg2(VARARGS* thisPtr, QCall::TypeHandle pType, TypedByRef* pResult, QCallExceptionStatus* qcallError); #endif // _VARARGSNATIVE_H_ diff --git a/src/coreclr/vm/versionresilienthashcode.cpp b/src/coreclr/vm/versionresilienthashcode.cpp index f117a8c2618a63..442c691f706616 100644 --- a/src/coreclr/vm/versionresilienthashcode.cpp +++ b/src/coreclr/vm/versionresilienthashcode.cpp @@ -450,19 +450,19 @@ bool GetVersionResilientILCodeHashCode(MethodDesc *pMD, const COR_ILMETHOD_DECOD return true; } -extern "C" QCallExceptionStatus QCALLTYPE VersionResilientHashCode_TypeHashCode(QCall::TypeHandle pTypeHandle, INT32* pReturnValue) +extern "C" INT32 QCALLTYPE VersionResilientHashCode_TypeHashCode(QCall::TypeHandle pTypeHandle, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - INT32 hashCode = 0; - hashCode = GetVersionResilientTypeHashCode(pTypeHandle.AsTypeHandle()); + BEGIN_QCALL; - *pReturnValue = hashCode; + hashCode = GetVersionResilientTypeHashCode(pTypeHandle.AsTypeHandle()); END_QCALL; + + return hashCode; } #endif // DACCESS_COMPILE diff --git a/src/coreclr/vm/versionresilienthashcode.h b/src/coreclr/vm/versionresilienthashcode.h index bb92e56d668eb1..da36794166ec14 100644 --- a/src/coreclr/vm/versionresilienthashcode.h +++ b/src/coreclr/vm/versionresilienthashcode.h @@ -14,4 +14,4 @@ int GetVersionResilientModuleHashCode(Module* pModule); bool GetVersionResilientILCodeHashCode(MethodDesc *pMD, const COR_ILMETHOD_DECODER* header, int* hashCode, unsigned* ilSize); -extern "C" QCallExceptionStatus QCALLTYPE VersionResilientHashCode_TypeHashCode(QCall::TypeHandle pTypeHandle, INT32* pReturnValue); +extern "C" INT32 QCALLTYPE VersionResilientHashCode_TypeHashCode(QCall::TypeHandle pTypeHandle, QCallExceptionStatus* qcallError); diff --git a/src/coreclr/vm/wasm/browser/callhelpers-interp-to-managed.cpp b/src/coreclr/vm/wasm/browser/callhelpers-interp-to-managed.cpp index 02b8d1b233ed28..d6570db6f62385 100644 --- a/src/coreclr/vm/wasm/browser/callhelpers-interp-to-managed.cpp +++ b/src/coreclr/vm/wasm/browser/callhelpers-interp-to-managed.cpp @@ -100,12 +100,6 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_IND(0)); } - static void CallFunc_S8_S8_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t) = (int32_t (*)(int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1)); - } - static void CallFunc_S8_S8_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t))pcode; @@ -130,12 +124,6 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_I32(3), ARG_I32(4)); } - static void CallFunc_S8_S8_I32_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); - } - static void CallFunc_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t, int32_t) = (int32_t (*)(int32_t, int32_t))pcode; @@ -184,12 +172,6 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); } - static void CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7), ARG_I32(8), ARG_I32(9), ARG_I32(10), ARG_I32(11)); - } - NOINLINE static void CallFunc_This_I32_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; @@ -204,36 +186,12 @@ namespace *((int32_t*)pRet) = (*fptr)(&framePointer, ARG_I32(0), pPortableEntryPoint); } - static void CallFunc_F64_F64_F64_F64_F64_F64_F64_F64_F64_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(double, double, double, double, double, double, double, double, double, int32_t, int32_t) = (int32_t (*)(double, double, double, double, double, double, double, double, double, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_F64(0), ARG_F64(1), ARG_F64(2), ARG_F64(3), ARG_F64(4), ARG_F64(5), ARG_F64(6), ARG_F64(7), ARG_F64(8), ARG_I32(9), ARG_I32(10)); - } - - static void CallFunc_F64_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(double, int32_t) = (int32_t (*)(double, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_F64(0), ARG_I32(1)); - } - - static void CallFunc_F64_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(double, int32_t, int32_t, int32_t) = (int32_t (*)(double, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_F64(0), ARG_I32(1), ARG_I32(2), ARG_I32(3)); - } - static void CallFunc_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t) = (int32_t (*)(int32_t))pcode; *((int32_t*)pRet) = (*fptr)(ARG_I32(0)); } - static void CallFunc_I32_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_IND(1), ARG_I32(2)); - } - static void CallFunc_I32_S8_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t))pcode; @@ -252,18 +210,6 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1)); } - static void CallFunc_I32_I32_S8_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_IND(3), ARG_I32(4)); - } - - static void CallFunc_I32_I32_S8_S8_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_IND(3), ARG_I32(4), ARG_I32(5)); - } - static void CallFunc_I32_I32_S8_I32_I32_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; @@ -276,30 +222,12 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7)); } - static void CallFunc_I32_I32_F64_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, double) = (int32_t (*)(int32_t, int32_t, double))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_F64(2)); - } - static void CallFunc_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t))pcode; *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2)); } - static void CallFunc_I32_I32_I32_S8_S8_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_IND(4)); - } - - static void CallFunc_I32_I32_I32_S8_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_IND(4), ARG_I32(5)); - } - static void CallFunc_I32_I32_I32_S8_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; @@ -350,12 +278,6 @@ namespace *((int32_t*)pRet) = (*fptr)(&framePointer, ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), pPortableEntryPoint); } - static void CallFunc_I32_I32_I32_I32_I64_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int64_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int64_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I64(4)); - } - NOINLINE static void CallFunc_I32_I32_I32_I32_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; @@ -432,12 +354,6 @@ namespace *((int32_t*)pRet) = (*fptr)(&framePointer, ARG_I32(0), pPortableEntryPoint); } - static void CallFunc_I64_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int64_t) = (int32_t (*)(int64_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I64(0)); - } - static void CallFunc_I64_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int64_t, int32_t) = (int32_t (*)(int64_t, int32_t))pcode; @@ -481,6 +397,12 @@ namespace *((int64_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2)); } + static void CallFunc_I32_I32_I32_I32_I32_I32_RetI64(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + int64_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int64_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + *((int64_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5)); + } + static void CallFunc_I32_I32_I32_I64_RetI64(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int64_t (*fptr)(int32_t, int32_t, int32_t, int64_t) = (int64_t (*)(int32_t, int32_t, int32_t, int64_t))pcode; @@ -534,6 +456,66 @@ namespace (*fptr)(); } + static void CallFunc_S8_S8_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2)); + } + + static void CallFunc_S8_S8_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7)); + } + + static void CallFunc_S8_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t) = (void (*)(int32_t, int32_t))pcode; + (*fptr)(ARG_IND(0), ARG_I32(1)); + } + + static void CallFunc_S8_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2)); + } + + static void CallFunc_S8_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3)); + } + + static void CallFunc_S8_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4)); + } + + static void CallFunc_S8_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5)); + } + + static void CallFunc_S8_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); + } + + static void CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7)); + } + + static void CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7), ARG_I32(8), ARG_I32(9), ARG_I32(10), ARG_I32(11), ARG_I32(12)); + } + NOINLINE static void CallFunc_This_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; @@ -541,6 +523,24 @@ namespace (*fptr)(&framePointer, ARG_I32(0), pPortableEntryPoint); } + static void CallFunc_F64_F64_F64_F64_F64_F64_F64_F64_F64_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(double, double, double, double, double, double, double, double, double, int32_t, int32_t, int32_t) = (void (*)(double, double, double, double, double, double, double, double, double, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_F64(0), ARG_F64(1), ARG_F64(2), ARG_F64(3), ARG_F64(4), ARG_F64(5), ARG_F64(6), ARG_F64(7), ARG_F64(8), ARG_I32(9), ARG_I32(10), ARG_I32(11)); + } + + static void CallFunc_F64_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(double, int32_t, int32_t) = (void (*)(double, int32_t, int32_t))pcode; + (*fptr)(ARG_F64(0), ARG_I32(1), ARG_I32(2)); + } + + static void CallFunc_F64_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(double, int32_t, int32_t, int32_t, int32_t) = (void (*)(double, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_F64(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4)); + } + NOINLINE static void CallFunc_F64_I32_I32_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; @@ -561,18 +561,54 @@ namespace (*fptr)(ARG_I32(0)); } + static void CallFunc_I32_S8_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_I32(0), ARG_IND(1), ARG_I32(2), ARG_I32(3)); + } + static void CallFunc_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { void (*fptr)(int32_t, int32_t) = (void (*)(int32_t, int32_t))pcode; (*fptr)(ARG_I32(0), ARG_I32(1)); } + static void CallFunc_I32_I32_S8_S8_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_IND(3), ARG_I32(4), ARG_I32(5)); + } + + static void CallFunc_I32_I32_S8_S8_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_IND(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); + } + + static void CallFunc_I32_I32_F64_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, double, int32_t) = (void (*)(int32_t, int32_t, double, int32_t))pcode; + (*fptr)(ARG_I32(0), ARG_I32(1), ARG_F64(2), ARG_I32(3)); + } + static void CallFunc_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { void (*fptr)(int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t))pcode; (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2)); } + static void CallFunc_I32_I32_I32_S8_S8_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_IND(4), ARG_I32(5)); + } + + static void CallFunc_I32_I32_I32_S8_S8_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_IND(4), ARG_I32(5), ARG_I32(6)); + } + static void CallFunc_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { void (*fptr)(int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t))pcode; @@ -585,6 +621,24 @@ namespace (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4)); } + static void CallFunc_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5)); + } + + static void CallFunc_I32_I32_I32_I32_I32_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; + (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); + } + + static void CallFunc_I32_I32_I32_I32_I64_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int32_t, int32_t, int32_t, int32_t, int64_t, int32_t) = (void (*)(int32_t, int32_t, int32_t, int32_t, int64_t, int32_t))pcode; + (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I64(4), ARG_I32(5)); + } + NOINLINE static void CallFunc_I32_I32_I32_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; @@ -606,6 +660,12 @@ namespace (*fptr)(&framePointer, ARG_I32(0), pPortableEntryPoint); } + static void CallFunc_I64_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + { + void (*fptr)(int64_t, int32_t) = (void (*)(int64_t, int32_t))pcode; + (*fptr)(ARG_I64(0), ARG_I32(1)); + } + NOINLINE static void CallFunc_Void_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; @@ -627,12 +687,10 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "Mi", (void*)&CallFunc_Void_RetI32 }, { "MiS64i", (void*)&CallFunc_S64_I32_RetI32 }, { "MiS8", (void*)&CallFunc_S8_RetI32 }, - { "MiS8S8", (void*)&CallFunc_S8_S8_RetI32 }, { "MiS8S8S8i", (void*)&CallFunc_S8_S8_S8_I32_RetI32 }, { "MiS8S8iS8i", (void*)&CallFunc_S8_S8_I32_S8_I32_RetI32 }, { "MiS8S8ii", (void*)&CallFunc_S8_S8_I32_I32_RetI32 }, { "MiS8S8iii", (void*)&CallFunc_S8_S8_I32_I32_I32_RetI32 }, - { "MiS8S8iiiii", (void*)&CallFunc_S8_S8_I32_I32_I32_I32_I32_RetI32 }, { "MiS8i", (void*)&CallFunc_S8_I32_RetI32 }, { "MiS8iS8S8i", (void*)&CallFunc_S8_I32_S8_S8_I32_RetI32 }, { "MiS8iS8ii", (void*)&CallFunc_S8_I32_S8_I32_I32_RetI32 }, @@ -641,25 +699,15 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "MiS8iiii", (void*)&CallFunc_S8_I32_I32_I32_I32_RetI32 }, { "MiS8iiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_RetI32 }, { "MiS8iiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_RetI32 }, - { "MiS8iiiiiiiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetI32 }, { "MiTip", (void*)&CallFunc_This_I32_RetI32_PE }, { "MiTp", (void*)&CallFunc_This_RetI32_PE }, - { "Midddddddddii", (void*)&CallFunc_F64_F64_F64_F64_F64_F64_F64_F64_F64_I32_I32_RetI32 }, - { "Midi", (void*)&CallFunc_F64_I32_RetI32 }, - { "Midiii", (void*)&CallFunc_F64_I32_I32_I32_RetI32 }, { "Mii", (void*)&CallFunc_I32_RetI32 }, - { "MiiS8i", (void*)&CallFunc_I32_S8_I32_RetI32 }, { "MiiS8ii", (void*)&CallFunc_I32_S8_I32_I32_RetI32 }, { "MiiS8iiii", (void*)&CallFunc_I32_S8_I32_I32_I32_I32_RetI32 }, { "Miii", (void*)&CallFunc_I32_I32_RetI32 }, - { "MiiiS8S8i", (void*)&CallFunc_I32_I32_S8_S8_I32_RetI32 }, - { "MiiiS8S8ii", (void*)&CallFunc_I32_I32_S8_S8_I32_I32_RetI32 }, { "MiiiS8iiS8i", (void*)&CallFunc_I32_I32_S8_I32_I32_S8_I32_RetI32 }, { "MiiiS8iiiii", (void*)&CallFunc_I32_I32_S8_I32_I32_I32_I32_I32_RetI32 }, - { "Miiid", (void*)&CallFunc_I32_I32_F64_RetI32 }, { "Miiii", (void*)&CallFunc_I32_I32_I32_RetI32 }, - { "MiiiiS8S8", (void*)&CallFunc_I32_I32_I32_S8_S8_RetI32 }, - { "MiiiiS8S8i", (void*)&CallFunc_I32_I32_I32_S8_S8_I32_RetI32 }, { "MiiiiS8iiii", (void*)&CallFunc_I32_I32_I32_S8_I32_I32_I32_I32_RetI32 }, { "Miiiii", (void*)&CallFunc_I32_I32_I32_I32_RetI32 }, { "Miiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_RetI32 }, @@ -668,7 +716,6 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "Miiiiiiiiiiiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetI32 }, { "Miiiiiiip", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_RetI32_PE }, { "Miiiiiip", (void*)&CallFunc_I32_I32_I32_I32_I32_RetI32_PE }, - { "Miiiiil", (void*)&CallFunc_I32_I32_I32_I32_I64_RetI32 }, { "Miiiiip", (void*)&CallFunc_I32_I32_I32_I32_RetI32_PE }, { "Miiiil", (void*)&CallFunc_I32_I32_I32_I64_RetI32 }, { "Miiiip", (void*)&CallFunc_I32_I32_I32_RetI32_PE }, @@ -681,7 +728,6 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "Miill", (void*)&CallFunc_I32_I64_I64_RetI32 }, { "Miilli", (void*)&CallFunc_I32_I64_I64_I32_RetI32 }, { "Miip", (void*)&CallFunc_I32_RetI32_PE }, - { "Mil", (void*)&CallFunc_I64_RetI32 }, { "Mili", (void*)&CallFunc_I64_I32_RetI32 }, { "Milii", (void*)&CallFunc_I64_I32_I32_RetI32 }, { "Mililii", (void*)&CallFunc_I64_I32_I64_I32_I32_RetI32 }, @@ -689,6 +735,7 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "Ml", (void*)&CallFunc_Void_RetI64 }, { "Mli", (void*)&CallFunc_I32_RetI64 }, { "Mliii", (void*)&CallFunc_I32_I32_I32_RetI64 }, + { "Mliiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_RetI64 }, { "Mliiil", (void*)&CallFunc_I32_I32_I32_I64_RetI64 }, { "Mlili", (void*)&CallFunc_I32_I64_I32_RetI64 }, { "Mlillp", (void*)&CallFunc_I32_I64_I64_RetI64_PE }, @@ -697,17 +744,40 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "Mlllp", (void*)&CallFunc_I64_I64_RetI64_PE }, { "Mlp", (void*)&CallFunc_Void_RetI64_PE }, { "Mv", (void*)&CallFunc_Void_RetVoid }, + { "MvS8S8i", (void*)&CallFunc_S8_S8_I32_RetVoid }, + { "MvS8S8iiiiii", (void*)&CallFunc_S8_S8_I32_I32_I32_I32_I32_I32_RetVoid }, + { "MvS8i", (void*)&CallFunc_S8_I32_RetVoid }, + { "MvS8ii", (void*)&CallFunc_S8_I32_I32_RetVoid }, + { "MvS8iii", (void*)&CallFunc_S8_I32_I32_I32_RetVoid }, + { "MvS8iiii", (void*)&CallFunc_S8_I32_I32_I32_I32_RetVoid }, + { "MvS8iiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_RetVoid }, + { "MvS8iiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_RetVoid }, + { "MvS8iiiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_RetVoid }, + { "MvS8iiiiiiiiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetVoid }, { "MvTp", (void*)&CallFunc_This_RetVoid_PE }, + { "Mvdddddddddiii", (void*)&CallFunc_F64_F64_F64_F64_F64_F64_F64_F64_F64_I32_I32_I32_RetVoid }, + { "Mvdii", (void*)&CallFunc_F64_I32_I32_RetVoid }, + { "Mvdiiii", (void*)&CallFunc_F64_I32_I32_I32_I32_RetVoid }, { "Mvdiip", (void*)&CallFunc_F64_I32_I32_RetVoid_PE }, { "Mvfiip", (void*)&CallFunc_F32_I32_I32_RetVoid_PE }, { "Mvi", (void*)&CallFunc_I32_RetVoid }, + { "MviS8ii", (void*)&CallFunc_I32_S8_I32_I32_RetVoid }, { "Mvii", (void*)&CallFunc_I32_I32_RetVoid }, + { "MviiS8S8ii", (void*)&CallFunc_I32_I32_S8_S8_I32_I32_RetVoid }, + { "MviiS8S8iii", (void*)&CallFunc_I32_I32_S8_S8_I32_I32_I32_RetVoid }, + { "Mviidi", (void*)&CallFunc_I32_I32_F64_I32_RetVoid }, { "Mviii", (void*)&CallFunc_I32_I32_I32_RetVoid }, + { "MviiiS8S8i", (void*)&CallFunc_I32_I32_I32_S8_S8_I32_RetVoid }, + { "MviiiS8S8ii", (void*)&CallFunc_I32_I32_I32_S8_S8_I32_I32_RetVoid }, { "Mviiii", (void*)&CallFunc_I32_I32_I32_I32_RetVoid }, { "Mviiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_RetVoid }, + { "Mviiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_RetVoid }, + { "Mviiiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_I32_RetVoid }, + { "Mviiiili", (void*)&CallFunc_I32_I32_I32_I32_I64_I32_RetVoid }, { "Mviiip", (void*)&CallFunc_I32_I32_I32_RetVoid_PE }, { "Mviip", (void*)&CallFunc_I32_I32_RetVoid_PE }, { "Mvip", (void*)&CallFunc_I32_RetVoid_PE }, + { "Mvli", (void*)&CallFunc_I64_I32_RetVoid }, { "Mvp", (void*)&CallFunc_Void_RetVoid_PE } }; diff --git a/src/coreclr/vm/wasm/entrypoints.h b/src/coreclr/vm/wasm/entrypoints.h index 01c87fb061efab..b7a92b9cc60af1 100644 --- a/src/coreclr/vm/wasm/entrypoints.h +++ b/src/coreclr/vm/wasm/entrypoints.h @@ -22,11 +22,11 @@ extern "C" void SystemJS_DiagnosticServerQueueJob(size_t (*cb)(void *data), void // the WasiEventLoop pump when WasiFinalizer_TryClearPending returns true. // Same implementation as browser's SystemJS_ExecuteFinalizationCallback, just // exported under a WASI-specific symbol; see src/coreclr/vm/finalizerthread.cpp. -extern "C" QCallExceptionStatus QCALLTYPE WasiFinalizer_RunWorker(); +extern "C" void QCALLTYPE WasiFinalizer_RunWorker(QCallExceptionStatus* qcallError); // Atomic-flag drain used by managed WasiEventLoop to learn whether a GC has // requested finalization since the last poll. Returns TRUE once per scheduled // finalization, FALSE otherwise. -extern "C" QCallExceptionStatus QCALLTYPE WasiFinalizer_TryClearPending(CLR_BOOL* pReturnValue); +extern "C" CLR_BOOL QCALLTYPE WasiFinalizer_TryClearPending(QCallExceptionStatus* qcallError); #endif // TARGET_WASI #endif // HAVE_WASM_ENTRYPOINTS_H \ No newline at end of file diff --git a/src/coreclr/vm/wasm/wasi/callhelpers-interp-to-managed.cpp b/src/coreclr/vm/wasm/wasi/callhelpers-interp-to-managed.cpp index b5ae76b7b92d5e..56f77515c21288 100644 --- a/src/coreclr/vm/wasm/wasi/callhelpers-interp-to-managed.cpp +++ b/src/coreclr/vm/wasm/wasi/callhelpers-interp-to-managed.cpp @@ -88,106 +88,60 @@ namespace *((int32_t*)pRet) = (*fptr)(); } - static void CallFunc_S64_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + NOINLINE static void CallFunc_S8_S8_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t) = (int32_t (*)(int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(8)); - } - - static void CallFunc_S8_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t) = (int32_t (*)(int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0)); - } - - static void CallFunc_S8_S8_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t) = (int32_t (*)(int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1)); - } - - static void CallFunc_S8_S8_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_IND(2), ARG_I32(3)); - } - - static void CallFunc_S8_S8_I32_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_IND(3), ARG_I32(4)); - } - - static void CallFunc_S8_S8_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_I32(3)); - } - - static void CallFunc_S8_S8_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_I32(3), ARG_I32(4)); - } - - static void CallFunc_S8_S8_I32_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); - } - - static void CallFunc_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t) = (int32_t (*)(int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1)); - } - - static void CallFunc_S8_I32_S8_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_IND(2), ARG_IND(3), ARG_I32(4)); + alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; + int32_t (*fptr)(int*, int32_t, int32_t, PCODE) = *(int32_t (**)(int*, int32_t, int32_t, PCODE))(pPortableEntryPoint); + *((int32_t*)pRet) = (*fptr)(&framePointer, ARG_IND(0), ARG_IND(1), pPortableEntryPoint); } - static void CallFunc_S8_I32_S8_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + NOINLINE static void CallFunc_S8_I32_I32_I32_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_IND(2), ARG_I32(3), ARG_I32(4)); + alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; + int32_t (*fptr)(int*, int32_t, int32_t, int32_t, int32_t, PCODE) = *(int32_t (**)(int*, int32_t, int32_t, int32_t, int32_t, PCODE))(pPortableEntryPoint); + *((int32_t*)pRet) = (*fptr)(&framePointer, ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), pPortableEntryPoint); } - static void CallFunc_S8_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + NOINLINE static void CallFunc_S8_I32_I32_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2)); + alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; + int32_t (*fptr)(int*, int32_t, int32_t, int32_t, PCODE) = *(int32_t (**)(int*, int32_t, int32_t, int32_t, PCODE))(pPortableEntryPoint); + *((int32_t*)pRet) = (*fptr)(&framePointer, ARG_IND(0), ARG_I32(1), ARG_I32(2), pPortableEntryPoint); } - static void CallFunc_S8_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + NOINLINE static void CallFunc_S8_I32_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3)); + alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; + int32_t (*fptr)(int*, int32_t, int32_t, PCODE) = *(int32_t (**)(int*, int32_t, int32_t, PCODE))(pPortableEntryPoint); + *((int32_t*)pRet) = (*fptr)(&framePointer, ARG_IND(0), ARG_I32(1), pPortableEntryPoint); } - static void CallFunc_S8_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + NOINLINE static void CallFunc_S8_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4)); + alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; + int32_t (*fptr)(int*, int32_t, PCODE) = *(int32_t (**)(int*, int32_t, PCODE))(pPortableEntryPoint); + *((int32_t*)pRet) = (*fptr)(&framePointer, ARG_IND(0), pPortableEntryPoint); } - static void CallFunc_S8_I32_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + NOINLINE static void CallFunc_This_I32_I32_I32_I32_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5)); + alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; + int32_t (*fptr)(int*, int32_t, int32_t, int32_t, int32_t, int32_t, PCODE) = *(int32_t (**)(int*, int32_t, int32_t, int32_t, int32_t, int32_t, PCODE))(pPortableEntryPoint); + *((int32_t*)pRet) = (*fptr)(&framePointer, ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), pPortableEntryPoint); } - static void CallFunc_S8_I32_I32_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + NOINLINE static void CallFunc_This_I32_I32_I32_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6)); + alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; + int32_t (*fptr)(int*, int32_t, int32_t, int32_t, int32_t, PCODE) = *(int32_t (**)(int*, int32_t, int32_t, int32_t, int32_t, PCODE))(pPortableEntryPoint); + *((int32_t*)pRet) = (*fptr)(&framePointer, ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), pPortableEntryPoint); } - static void CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + NOINLINE static void CallFunc_This_I32_I32_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7), ARG_I32(8), ARG_I32(9), ARG_I32(10), ARG_I32(11)); + alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; + int32_t (*fptr)(int*, int32_t, int32_t, int32_t, PCODE) = *(int32_t (**)(int*, int32_t, int32_t, int32_t, PCODE))(pPortableEntryPoint); + *((int32_t*)pRet) = (*fptr)(&framePointer, ARG_I32(0), ARG_I32(1), ARG_I32(2), pPortableEntryPoint); } NOINLINE static void CallFunc_This_I32_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) @@ -210,78 +164,18 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_I32(0)); } - static void CallFunc_I32_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_IND(1), ARG_I32(2)); - } - - static void CallFunc_I32_S8_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_IND(1), ARG_I32(2), ARG_I32(3)); - } - - static void CallFunc_I32_S8_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_IND(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5)); - } - static void CallFunc_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t, int32_t) = (int32_t (*)(int32_t, int32_t))pcode; *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1)); } - static void CallFunc_I32_I32_S8_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_IND(3), ARG_I32(4)); - } - - static void CallFunc_I32_I32_S8_S8_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_IND(3), ARG_I32(4), ARG_I32(5)); - } - - static void CallFunc_I32_I32_S8_I32_I32_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_I32(3), ARG_I32(4), ARG_IND(5), ARG_I32(6)); - } - - static void CallFunc_I32_I32_S8_I32_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_IND(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7)); - } - static void CallFunc_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t))pcode; *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2)); } - static void CallFunc_I32_I32_I32_S8_S8_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_IND(4)); - } - - static void CallFunc_I32_I32_I32_S8_S8_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_IND(4), ARG_I32(5)); - } - - static void CallFunc_I32_I32_I32_S8_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_IND(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7)); - } - static void CallFunc_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) { int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t))pcode; @@ -318,17 +212,18 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7), ARG_I32(8)); } - static void CallFunc_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) + NOINLINE static void CallFunc_I32_I32_I32_I32_I32_I32_I32_I32_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { - int32_t (*fptr)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t) = (int32_t (*)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7), ARG_I32(8), ARG_I32(9), ARG_I32(10), ARG_I32(11), ARG_I32(12), ARG_I32(13)); + alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; + int32_t (*fptr)(int*, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, PCODE) = *(int32_t (**)(int*, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, PCODE))(pPortableEntryPoint); + *((int32_t*)pRet) = (*fptr)(&framePointer, ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), ARG_I32(7), pPortableEntryPoint); } - NOINLINE static void CallFunc_I32_I32_I32_I32_I32_I32_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) + NOINLINE static void CallFunc_I32_I32_I32_I32_I32_I32_I32_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; - int32_t (*fptr)(int*, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, PCODE) = *(int32_t (**)(int*, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, PCODE))(pPortableEntryPoint); - *((int32_t*)pRet) = (*fptr)(&framePointer, ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), pPortableEntryPoint); + int32_t (*fptr)(int*, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, PCODE) = *(int32_t (**)(int*, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, PCODE))(pPortableEntryPoint); + *((int32_t*)pRet) = (*fptr)(&framePointer, ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), pPortableEntryPoint); } NOINLINE static void CallFunc_I32_I32_I32_I32_I32_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) @@ -420,12 +315,6 @@ namespace *((int32_t*)pRet) = (*fptr)(ARG_I64(0)); } - static void CallFunc_I64_I32_I64_I32_I32_RetI32(PCODE pcode, int8_t* pArgs, int8_t* pRet) - { - int32_t (*fptr)(int64_t, int32_t, int64_t, int32_t, int32_t) = (int32_t (*)(int64_t, int32_t, int64_t, int32_t, int32_t))pcode; - *((int32_t*)pRet) = (*fptr)(ARG_I64(0), ARG_I32(1), ARG_I64(2), ARG_I32(3), ARG_I32(4)); - } - NOINLINE static void CallFunc_Void_RetI32_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; @@ -484,45 +373,74 @@ namespace *((int64_t*)pRet) = (*fptr)(&framePointer, ARG_I32(0), pPortableEntryPoint); } - NOINLINE static void CallFunc_I64_I64_RetI64_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) + NOINLINE static void CallFunc_Void_RetI64_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; - int64_t (*fptr)(int*, int64_t, int64_t, PCODE) = *(int64_t (**)(int*, int64_t, int64_t, PCODE))(pPortableEntryPoint); - *((int64_t*)pRet) = (*fptr)(&framePointer, ARG_I64(0), ARG_I64(1), pPortableEntryPoint); + int64_t (*fptr)(int*, PCODE) = *(int64_t (**)(int*, PCODE))(pPortableEntryPoint); + *((int64_t*)pRet) = (*fptr)(&framePointer, pPortableEntryPoint); } - NOINLINE static void CallFunc_Void_RetI64_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) + NOINLINE static void CallFunc_S8_S8_I32_I32_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; - int64_t (*fptr)(int*, PCODE) = *(int64_t (**)(int*, PCODE))(pPortableEntryPoint); - *((int64_t*)pRet) = (*fptr)(&framePointer, pPortableEntryPoint); + void (*fptr)(int*, int32_t, int32_t, int32_t, int32_t, PCODE) = *(void (**)(int*, int32_t, int32_t, int32_t, int32_t, PCODE))(pPortableEntryPoint); + (*fptr)(&framePointer, ARG_IND(0), ARG_IND(1), ARG_I32(2), ARG_I32(3), pPortableEntryPoint); } - static void CallFunc_Void_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) + NOINLINE static void CallFunc_S8_I32_I32_I32_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { - void (*fptr)() = (void (*)())pcode; - (*fptr)(); + alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; + void (*fptr)(int*, int32_t, int32_t, int32_t, int32_t, PCODE) = *(void (**)(int*, int32_t, int32_t, int32_t, int32_t, PCODE))(pPortableEntryPoint); + (*fptr)(&framePointer, ARG_IND(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), pPortableEntryPoint); } - NOINLINE static void CallFunc_This_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) + NOINLINE static void CallFunc_S8_I32_I32_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) + { + alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; + void (*fptr)(int*, int32_t, int32_t, int32_t, PCODE) = *(void (**)(int*, int32_t, int32_t, int32_t, PCODE))(pPortableEntryPoint); + (*fptr)(&framePointer, ARG_IND(0), ARG_I32(1), ARG_I32(2), pPortableEntryPoint); + } + + NOINLINE static void CallFunc_S8_I32_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) + { + alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; + void (*fptr)(int*, int32_t, int32_t, PCODE) = *(void (**)(int*, int32_t, int32_t, PCODE))(pPortableEntryPoint); + (*fptr)(&framePointer, ARG_IND(0), ARG_I32(1), pPortableEntryPoint); + } + + NOINLINE static void CallFunc_S8_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; void (*fptr)(int*, int32_t, PCODE) = *(void (**)(int*, int32_t, PCODE))(pPortableEntryPoint); - (*fptr)(&framePointer, ARG_I32(0), pPortableEntryPoint); + (*fptr)(&framePointer, ARG_IND(0), pPortableEntryPoint); } - NOINLINE static void CallFunc_F64_I32_I32_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) + NOINLINE static void CallFunc_This_I32_I32_I32_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; - void (*fptr)(int*, double, int32_t, int32_t, PCODE) = *(void (**)(int*, double, int32_t, int32_t, PCODE))(pPortableEntryPoint); - (*fptr)(&framePointer, ARG_F64(0), ARG_I32(1), ARG_I32(2), pPortableEntryPoint); + void (*fptr)(int*, int32_t, int32_t, int32_t, int32_t, PCODE) = *(void (**)(int*, int32_t, int32_t, int32_t, int32_t, PCODE))(pPortableEntryPoint); + (*fptr)(&framePointer, ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), pPortableEntryPoint); } - NOINLINE static void CallFunc_F32_I32_I32_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) + NOINLINE static void CallFunc_This_I32_I32_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; - void (*fptr)(int*, float, int32_t, int32_t, PCODE) = *(void (**)(int*, float, int32_t, int32_t, PCODE))(pPortableEntryPoint); - (*fptr)(&framePointer, ARG_F32(0), ARG_I32(1), ARG_I32(2), pPortableEntryPoint); + void (*fptr)(int*, int32_t, int32_t, int32_t, PCODE) = *(void (**)(int*, int32_t, int32_t, int32_t, PCODE))(pPortableEntryPoint); + (*fptr)(&framePointer, ARG_I32(0), ARG_I32(1), ARG_I32(2), pPortableEntryPoint); + } + + NOINLINE static void CallFunc_This_I32_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) + { + alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; + void (*fptr)(int*, int32_t, int32_t, PCODE) = *(void (**)(int*, int32_t, int32_t, PCODE))(pPortableEntryPoint); + (*fptr)(&framePointer, ARG_I32(0), ARG_I32(1), pPortableEntryPoint); + } + + NOINLINE static void CallFunc_This_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) + { + alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; + void (*fptr)(int*, int32_t, PCODE) = *(void (**)(int*, int32_t, PCODE))(pPortableEntryPoint); + (*fptr)(&framePointer, ARG_I32(0), pPortableEntryPoint); } static void CallFunc_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) @@ -531,6 +449,13 @@ namespace (*fptr)(ARG_I32(0)); } + NOINLINE static void CallFunc_I32_S8_I32_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) + { + alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; + void (*fptr)(int*, int32_t, int32_t, int32_t, PCODE) = *(void (**)(int*, int32_t, int32_t, int32_t, PCODE))(pPortableEntryPoint); + (*fptr)(&framePointer, ARG_I32(0), ARG_IND(1), ARG_I32(2), pPortableEntryPoint); + } + static void CallFunc_I32_I32_RetVoid(PCODE pcode, int8_t* pArgs, int8_t* pRet) { void (*fptr)(int32_t, int32_t) = (void (*)(int32_t, int32_t))pcode; @@ -555,6 +480,34 @@ namespace (*fptr)(ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4)); } + NOINLINE static void CallFunc_I32_I32_I32_I32_I32_I32_I32_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) + { + alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; + void (*fptr)(int*, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, PCODE) = *(void (**)(int*, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, PCODE))(pPortableEntryPoint); + (*fptr)(&framePointer, ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), ARG_I32(6), pPortableEntryPoint); + } + + NOINLINE static void CallFunc_I32_I32_I32_I32_I32_I32_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) + { + alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; + void (*fptr)(int*, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, PCODE) = *(void (**)(int*, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, PCODE))(pPortableEntryPoint); + (*fptr)(&framePointer, ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), ARG_I32(5), pPortableEntryPoint); + } + + NOINLINE static void CallFunc_I32_I32_I32_I32_I32_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) + { + alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; + void (*fptr)(int*, int32_t, int32_t, int32_t, int32_t, int32_t, PCODE) = *(void (**)(int*, int32_t, int32_t, int32_t, int32_t, int32_t, PCODE))(pPortableEntryPoint); + (*fptr)(&framePointer, ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), ARG_I32(4), pPortableEntryPoint); + } + + NOINLINE static void CallFunc_I32_I32_I32_I32_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) + { + alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; + void (*fptr)(int*, int32_t, int32_t, int32_t, int32_t, PCODE) = *(void (**)(int*, int32_t, int32_t, int32_t, int32_t, PCODE))(pPortableEntryPoint); + (*fptr)(&framePointer, ARG_I32(0), ARG_I32(1), ARG_I32(2), ARG_I32(3), pPortableEntryPoint); + } + NOINLINE static void CallFunc_I32_I32_I32_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; @@ -582,6 +535,13 @@ namespace (*fptr)(&framePointer, ARG_I32(0), pPortableEntryPoint); } + NOINLINE static void CallFunc_I64_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) + { + alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; + void (*fptr)(int*, int64_t, PCODE) = *(void (**)(int*, int64_t, PCODE))(pPortableEntryPoint); + (*fptr)(&framePointer, ARG_I64(0), pPortableEntryPoint); + } + NOINLINE static void CallFunc_Void_RetVoid_PE(PCODE pPortableEntryPoint, int8_t* pArgs, int8_t* pRet) { alignas(16) int framePointer = TERMINATE_R2R_STACK_WALK; @@ -601,46 +561,27 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "Mffip", (void*)&CallFunc_F32_I32_RetF32_PE }, { "Mffp", (void*)&CallFunc_F32_RetF32_PE }, { "Mi", (void*)&CallFunc_Void_RetI32 }, - { "MiS64i", (void*)&CallFunc_S64_I32_RetI32 }, - { "MiS8", (void*)&CallFunc_S8_RetI32 }, - { "MiS8S8", (void*)&CallFunc_S8_S8_RetI32 }, - { "MiS8S8S8i", (void*)&CallFunc_S8_S8_S8_I32_RetI32 }, - { "MiS8S8iS8i", (void*)&CallFunc_S8_S8_I32_S8_I32_RetI32 }, - { "MiS8S8ii", (void*)&CallFunc_S8_S8_I32_I32_RetI32 }, - { "MiS8S8iii", (void*)&CallFunc_S8_S8_I32_I32_I32_RetI32 }, - { "MiS8S8iiiii", (void*)&CallFunc_S8_S8_I32_I32_I32_I32_I32_RetI32 }, - { "MiS8i", (void*)&CallFunc_S8_I32_RetI32 }, - { "MiS8iS8S8i", (void*)&CallFunc_S8_I32_S8_S8_I32_RetI32 }, - { "MiS8iS8ii", (void*)&CallFunc_S8_I32_S8_I32_I32_RetI32 }, - { "MiS8ii", (void*)&CallFunc_S8_I32_I32_RetI32 }, - { "MiS8iii", (void*)&CallFunc_S8_I32_I32_I32_RetI32 }, - { "MiS8iiii", (void*)&CallFunc_S8_I32_I32_I32_I32_RetI32 }, - { "MiS8iiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_RetI32 }, - { "MiS8iiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_RetI32 }, - { "MiS8iiiiiiiiiii", (void*)&CallFunc_S8_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetI32 }, + { "MiS8S8p", (void*)&CallFunc_S8_S8_RetI32_PE }, + { "MiS8iiip", (void*)&CallFunc_S8_I32_I32_I32_RetI32_PE }, + { "MiS8iip", (void*)&CallFunc_S8_I32_I32_RetI32_PE }, + { "MiS8ip", (void*)&CallFunc_S8_I32_RetI32_PE }, + { "MiS8p", (void*)&CallFunc_S8_RetI32_PE }, + { "MiTiiiip", (void*)&CallFunc_This_I32_I32_I32_I32_RetI32_PE }, + { "MiTiiip", (void*)&CallFunc_This_I32_I32_I32_RetI32_PE }, + { "MiTiip", (void*)&CallFunc_This_I32_I32_RetI32_PE }, { "MiTip", (void*)&CallFunc_This_I32_RetI32_PE }, { "MiTp", (void*)&CallFunc_This_RetI32_PE }, { "Mii", (void*)&CallFunc_I32_RetI32 }, - { "MiiS8i", (void*)&CallFunc_I32_S8_I32_RetI32 }, - { "MiiS8ii", (void*)&CallFunc_I32_S8_I32_I32_RetI32 }, - { "MiiS8iiii", (void*)&CallFunc_I32_S8_I32_I32_I32_I32_RetI32 }, { "Miii", (void*)&CallFunc_I32_I32_RetI32 }, - { "MiiiS8S8i", (void*)&CallFunc_I32_I32_S8_S8_I32_RetI32 }, - { "MiiiS8S8ii", (void*)&CallFunc_I32_I32_S8_S8_I32_I32_RetI32 }, - { "MiiiS8iiS8i", (void*)&CallFunc_I32_I32_S8_I32_I32_S8_I32_RetI32 }, - { "MiiiS8iiiii", (void*)&CallFunc_I32_I32_S8_I32_I32_I32_I32_I32_RetI32 }, { "Miiii", (void*)&CallFunc_I32_I32_I32_RetI32 }, - { "MiiiiS8S8", (void*)&CallFunc_I32_I32_I32_S8_S8_RetI32 }, - { "MiiiiS8S8i", (void*)&CallFunc_I32_I32_I32_S8_S8_I32_RetI32 }, - { "MiiiiS8iiii", (void*)&CallFunc_I32_I32_I32_S8_I32_I32_I32_I32_RetI32 }, { "Miiiii", (void*)&CallFunc_I32_I32_I32_I32_RetI32 }, { "Miiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_RetI32 }, { "Miiiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_RetI32 }, { "Miiiiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_I32_RetI32 }, { "Miiiiiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_I32_I32_RetI32 }, { "Miiiiiiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetI32 }, - { "Miiiiiiiiiiiiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_I32_RetI32 }, - { "Miiiiiiip", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_RetI32_PE }, + { "Miiiiiiiiip", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_I32_I32_RetI32_PE }, + { "Miiiiiiiip", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_I32_RetI32_PE }, { "Miiiiiip", (void*)&CallFunc_I32_I32_I32_I32_I32_RetI32_PE }, { "Miiiiip", (void*)&CallFunc_I32_I32_I32_I32_RetI32_PE }, { "Miiiil", (void*)&CallFunc_I32_I32_I32_I64_RetI32 }, @@ -655,7 +596,6 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "Miilli", (void*)&CallFunc_I32_I64_I64_I32_RetI32 }, { "Miip", (void*)&CallFunc_I32_RetI32_PE }, { "Mil", (void*)&CallFunc_I64_RetI32 }, - { "Mililii", (void*)&CallFunc_I64_I32_I64_I32_I32_RetI32 }, { "Mip", (void*)&CallFunc_Void_RetI32_PE }, { "Ml", (void*)&CallFunc_Void_RetI64 }, { "Mli", (void*)&CallFunc_I32_RetI64 }, @@ -665,21 +605,31 @@ const StringToWasmSigThunk g_wasmThunks[] = { { "Mlillp", (void*)&CallFunc_I32_I64_I64_RetI64_PE }, { "Mlilp", (void*)&CallFunc_I32_I64_RetI64_PE }, { "Mlip", (void*)&CallFunc_I32_RetI64_PE }, - { "Mlllp", (void*)&CallFunc_I64_I64_RetI64_PE }, { "Mlp", (void*)&CallFunc_Void_RetI64_PE }, - { "Mv", (void*)&CallFunc_Void_RetVoid }, + { "MvS8S8iip", (void*)&CallFunc_S8_S8_I32_I32_RetVoid_PE }, + { "MvS8iiip", (void*)&CallFunc_S8_I32_I32_I32_RetVoid_PE }, + { "MvS8iip", (void*)&CallFunc_S8_I32_I32_RetVoid_PE }, + { "MvS8ip", (void*)&CallFunc_S8_I32_RetVoid_PE }, + { "MvS8p", (void*)&CallFunc_S8_RetVoid_PE }, + { "MvTiiip", (void*)&CallFunc_This_I32_I32_I32_RetVoid_PE }, + { "MvTiip", (void*)&CallFunc_This_I32_I32_RetVoid_PE }, + { "MvTip", (void*)&CallFunc_This_I32_RetVoid_PE }, { "MvTp", (void*)&CallFunc_This_RetVoid_PE }, - { "Mvdiip", (void*)&CallFunc_F64_I32_I32_RetVoid_PE }, - { "Mvfiip", (void*)&CallFunc_F32_I32_I32_RetVoid_PE }, { "Mvi", (void*)&CallFunc_I32_RetVoid }, + { "MviS8ip", (void*)&CallFunc_I32_S8_I32_RetVoid_PE }, { "Mvii", (void*)&CallFunc_I32_I32_RetVoid }, { "Mviii", (void*)&CallFunc_I32_I32_I32_RetVoid }, { "Mviiii", (void*)&CallFunc_I32_I32_I32_I32_RetVoid }, { "Mviiiii", (void*)&CallFunc_I32_I32_I32_I32_I32_RetVoid }, + { "Mviiiiiiip", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_I32_RetVoid_PE }, + { "Mviiiiiip", (void*)&CallFunc_I32_I32_I32_I32_I32_I32_RetVoid_PE }, + { "Mviiiiip", (void*)&CallFunc_I32_I32_I32_I32_I32_RetVoid_PE }, + { "Mviiiip", (void*)&CallFunc_I32_I32_I32_I32_RetVoid_PE }, { "Mviiip", (void*)&CallFunc_I32_I32_I32_RetVoid_PE }, { "Mviip", (void*)&CallFunc_I32_I32_RetVoid_PE }, { "Mvili", (void*)&CallFunc_I32_I64_I32_RetVoid }, { "Mvip", (void*)&CallFunc_I32_RetVoid_PE }, + { "Mvlp", (void*)&CallFunc_I64_RetVoid_PE }, { "Mvp", (void*)&CallFunc_Void_RetVoid_PE } }; diff --git a/src/coreclr/vm/weakreferencenative.cpp b/src/coreclr/vm/weakreferencenative.cpp index ccf5f22102f74b..78e641b4ffcb27 100644 --- a/src/coreclr/vm/weakreferencenative.cpp +++ b/src/coreclr/vm/weakreferencenative.cpp @@ -47,7 +47,7 @@ void FinalizeWeakReference(Object* obj) #if defined(FEATURE_COMINTEROP) -extern "C" QCallExceptionStatus QCALLTYPE ComWeakRefToObject(IWeakReference* pComWeakReference, QCall::ObjectHandleOnStack retRcw) +extern "C" void QCALLTYPE ComWeakRefToObject(IWeakReference* pComWeakReference, QCall::ObjectHandleOnStack retRcw, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; BEGIN_QCALL; @@ -85,17 +85,17 @@ extern "C" QCallExceptionStatus QCALLTYPE ComWeakRefToObject(IWeakReference* pCo } END_QCALL; - + return; } -extern "C" QCallExceptionStatus QCALLTYPE ObjectToComWeakRef(QCall::ObjectHandleOnStack obj, IWeakReference ** pReturnValue) +extern "C" IWeakReference * QCALLTYPE ObjectToComWeakRef(QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError) { QCALL_CONTRACT; - BEGIN_QCALL; - IWeakReference* pWeakReference = nullptr; + BEGIN_QCALL; + IWeakReferenceSource* pWeakReferenceSourceRaw = nullptr; { // COM helpers assume COOP mode and the arguments are protected refs. @@ -128,8 +128,7 @@ extern "C" QCallExceptionStatus QCALLTYPE ObjectToComWeakRef(QCall::ObjectHandle } } - *pReturnValue = pWeakReference; - END_QCALL; + return pWeakReference; } #endif // FEATURE_COMINTEROP diff --git a/src/coreclr/vm/weakreferencenative.h b/src/coreclr/vm/weakreferencenative.h index 9ff92dd1fa89e2..d871a7c6780896 100644 --- a/src/coreclr/vm/weakreferencenative.h +++ b/src/coreclr/vm/weakreferencenative.h @@ -15,8 +15,8 @@ #ifdef FEATURE_COMINTEROP -extern "C" QCallExceptionStatus QCALLTYPE ComWeakRefToObject(IWeakReference * pComWeakReference, QCall::ObjectHandleOnStack retRcw); -extern "C" QCallExceptionStatus QCALLTYPE ObjectToComWeakRef(QCall::ObjectHandleOnStack obj, IWeakReference ** pReturnValue); +extern "C" void QCALLTYPE ComWeakRefToObject(IWeakReference * pComWeakReference, QCall::ObjectHandleOnStack retRcw, QCallExceptionStatus* qcallError); +extern "C" IWeakReference * QCALLTYPE ObjectToComWeakRef(QCall::ObjectHandleOnStack obj, QCallExceptionStatus* qcallError); #endif // FEATURE_COMINTEROP diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.Internal.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.Internal.cs index 624d976c171b3a..a37e144506ba09 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.Internal.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventPipe.Internal.cs @@ -16,7 +16,7 @@ internal static partial class EventPipeInternal // These PInvokes are used by the configuration APIs to interact with EventPipe. // #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_Enable")] private static unsafe partial ulong Enable( @@ -27,7 +27,7 @@ private static unsafe partial ulong Enable( uint numProviders); #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_Disable")] internal static partial void Disable(ulong sessionID); @@ -36,7 +36,7 @@ private static unsafe partial ulong Enable( // These PInvokes are used by EventSource to interact with the EventPipe. // #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_CreateProvider", StringMarshalling = StringMarshalling.Utf16)] internal static unsafe partial IntPtr CreateProvider(string providerName, @@ -44,31 +44,31 @@ internal static unsafe partial IntPtr CreateProvider(string providerName, void* callbackContext); #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_DefineEvent")] internal static unsafe partial IntPtr DefineEvent(IntPtr provHandle, uint eventID, long keywords, uint eventVersion, uint level, void *pMetadata, uint metadataLength); #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_GetProvider", StringMarshalling = StringMarshalling.Utf16)] internal static partial IntPtr GetProvider(string providerName); #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_DeleteProvider")] internal static partial void DeleteProvider(IntPtr provHandle); #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_EventActivityIdControl")] internal static partial int EventActivityIdControl(uint controlCode, ref Guid activityId); #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_WriteEventData")] internal static unsafe partial void WriteEventData(IntPtr eventHandle, EventProvider.EventData* pEventData, uint dataCount, Guid* activityId, Guid* relatedActivityId); @@ -77,28 +77,28 @@ internal static unsafe partial IntPtr CreateProvider(string providerName, // These PInvokes are used as part of the EventPipeEventDispatcher. // #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_GetSessionInfo")] [return: MarshalAs(UnmanagedType.Bool)] internal static unsafe partial bool GetSessionInfo(ulong sessionID, EventPipeSessionInfo* pSessionInfo); #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_GetNextEvent")] [return: MarshalAs(UnmanagedType.Bool)] internal static unsafe partial bool GetNextEvent(ulong sessionID, EventPipeEventInstanceData* pInstance); #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_SignalSession")] [return: MarshalAs(UnmanagedType.Bool)] internal static unsafe partial bool SignalSession(ulong sessionID); #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "EventPipeInternal_WaitForSessionSignal")] [return: MarshalAs(UnmanagedType.Bool)] diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs index 9db66551b9a8fc..3ca9d1688fbca4 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs @@ -10,14 +10,14 @@ internal sealed partial class NativeRuntimeEventSource : EventSource { [NonEvent] #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogContentionLockCreated")] private static partial void LogContentionLockCreated(nint LockID, nint AssociatedObjectID, ushort ClrInstanceID); [NonEvent] #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogContentionStart")] private static partial void LogContentionStart( @@ -29,7 +29,7 @@ private static partial void LogContentionStart( [NonEvent] #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogContentionStop")] private static partial void LogContentionStop( @@ -39,49 +39,49 @@ private static partial void LogContentionStop( [NonEvent] #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadStart")] private static partial void LogThreadPoolWorkerThreadStart(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID); [NonEvent] #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadStop")] private static partial void LogThreadPoolWorkerThreadStop(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID); [NonEvent] #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadWait")] private static partial void LogThreadPoolWorkerThreadWait(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID); [NonEvent] #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolMinMaxThreads")] private static partial void LogThreadPoolMinMaxThreads(ushort MinWorkerThreads, ushort MaxWorkerThreads, ushort MinIOCompletionThreads, ushort MaxIOCompletionThreads, ushort ClrInstanceID); [NonEvent] #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentSample")] private static partial void LogThreadPoolWorkerThreadAdjustmentSample(double Throughput, ushort ClrInstanceID); [NonEvent] #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentAdjustment")] private static partial void LogThreadPoolWorkerThreadAdjustmentAdjustment(double AverageThroughput, uint NewWorkerThreadCount, ThreadAdjustmentReasonMap Reason, ushort ClrInstanceID); [NonEvent] #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkerThreadAdjustmentStats")] private static partial void LogThreadPoolWorkerThreadAdjustmentStats( @@ -99,7 +99,7 @@ private static partial void LogThreadPoolWorkerThreadAdjustmentStats( [NonEvent] #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolIOEnqueue")] private static partial void LogThreadPoolIOEnqueue( @@ -110,7 +110,7 @@ private static partial void LogThreadPoolIOEnqueue( [NonEvent] #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolIODequeue")] private static partial void LogThreadPoolIODequeue( @@ -120,7 +120,7 @@ private static partial void LogThreadPoolIODequeue( [NonEvent] #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolWorkingThreadCount")] private static partial void LogThreadPoolWorkingThreadCount( @@ -129,7 +129,7 @@ private static partial void LogThreadPoolWorkingThreadCount( [NonEvent] #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogThreadPoolIOPack")] private static partial void LogThreadPoolIOPack( @@ -139,7 +139,7 @@ private static partial void LogThreadPoolIOPack( [NonEvent] #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogWaitHandleWaitStart")] private static partial void LogWaitHandleWaitStart( @@ -149,7 +149,7 @@ private static partial void LogWaitHandleWaitStart( [NonEvent] #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogWaitHandleWaitStop")] private static partial void LogWaitHandleWaitStop(ushort ClrInstanceID); diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs index 51b638c07d2acb..7806bc66058370 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/TraceLogging/XplatEventLogger.cs @@ -22,7 +22,7 @@ public XplatEventLogger() { } private static unsafe string GetClrConfig(string configName) => new string(EventSource_GetClrConfig(configName)); #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, StringMarshalling = StringMarshalling.Utf16)] private static unsafe partial char* EventSource_GetClrConfig(string configName); @@ -45,14 +45,14 @@ public XplatEventLogger() { } } #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall)] [return: MarshalAs(UnmanagedType.Bool)] private static partial bool IsEventSourceLoggingEnabled(); #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, StringMarshalling = StringMarshalling.Utf16)] private static partial void LogEventSource(int eventID, string? eventName, string eventSourceName, string payload); diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/TypeMapLazyDictionary.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/TypeMapLazyDictionary.cs index 3501c49f90cbae..17f3d3f2089985 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/TypeMapLazyDictionary.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/TypeMapLazyDictionary.cs @@ -81,7 +81,7 @@ public unsafe struct ProcessAttributesCallbackArg } #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeMapLazyDictionary_ProcessAttributes")] private static unsafe partial void ProcessAttributes( @@ -94,13 +94,13 @@ private static unsafe partial void ProcessAttributes( CallbackContext* context); #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeMapLazyDictionary_FindPrecachedExternalTypeMapEntry", StringMarshalling = StringMarshalling.Utf8)] private static unsafe partial IntPtr FindPrecachedExternalTypeMapEntry(QCallModule module, QCallTypeHandle groupType, string key); #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "TypeMapLazyDictionary_FindPrecachedProxyTypeMapEntry")] private static unsafe partial IntPtr FindPrecachedProxyTypeMapEntry(QCallModule module, QCallTypeHandle groupType, QCallTypeHandle type); diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiFinalizerScheduler.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiFinalizerScheduler.cs index eaf190d0a5159b..bc9b9943a0181a 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiFinalizerScheduler.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiFinalizerScheduler.cs @@ -22,14 +22,14 @@ internal static partial class WasiFinalizerScheduler internal static void DrainIfPending() { } #else #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "WasiFinalizer_TryClearPending")] [return: MarshalAs(UnmanagedType.Bool)] internal static partial bool TryClearPendingFinalization(); #if CORECLR - [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenReturnValue)] + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] #endif [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "WasiFinalizer_RunWorker")] internal static partial void ExecuteFinalizationCallback(); From fa08375974d1749f0483a17f6272924e84154b50 Mon Sep 17 00:00:00 2001 From: David Wrighton Date: Wed, 2 Sep 2026 14:19:19 -0700 Subject: [PATCH 21/23] Use GetThread in QCall exception handling Avoid relying on GET_THREAD and explicit MAKE_CURRENT_THREAD_AVAILABLE calls in QCall exception and reflection paths. Retrieve the current thread directly with GetThread, and correct the QCall casing in the exception rethrow helper name. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 3bf4a72c-55aa-4b64-8dc3-c0fbeb82730c --- src/coreclr/vm/excep.cpp | 2 +- src/coreclr/vm/exceptionhandling.cpp | 27 ++++++++++--------------- src/coreclr/vm/exceptmacros.h | 10 ++++----- src/coreclr/vm/reflectioninvocation.cpp | 4 +--- 4 files changed, 18 insertions(+), 25 deletions(-) diff --git a/src/coreclr/vm/excep.cpp b/src/coreclr/vm/excep.cpp index 45c7b8415a7376..dc14556e81a602 100644 --- a/src/coreclr/vm/excep.cpp +++ b/src/coreclr/vm/excep.cpp @@ -6616,7 +6616,7 @@ void UnwindAndContinueRethrowHelperInsideCatch(Frame* pEntryFrame, Exception* pE // This does the work of the Unwind and Continue Handler inside the catch clause of that handler. The stack has not // been unwound when this is called. Keep that in mind when deciding where to put new code :) // -void UnwindAndContinueRethrowHelperInsideQcallCatch( +void UnwindAndContinueRethrowHelperInsideQCallCatch( Exception* pException, QCallExceptionStatus* pQCallException DEBUG_ARG(Frame* pEntryFrame)) { diff --git a/src/coreclr/vm/exceptionhandling.cpp b/src/coreclr/vm/exceptionhandling.cpp index cab2ea575834a2..e039dc2a146857 100644 --- a/src/coreclr/vm/exceptionhandling.cpp +++ b/src/coreclr/vm/exceptionhandling.cpp @@ -3139,8 +3139,7 @@ extern "C" void QCALLTYPE AppendExceptionStackFrame(QCall::ObjectHandleOnStack e BEGIN_QCALL; - MAKE_CURRENT_THREAD_AVAILABLE(); - Thread* pThread = GET_THREAD(); + Thread* pThread = GetThread(); { GCX_COOP_THREAD_EXISTS(pThread); @@ -3267,7 +3266,7 @@ void CallCatchFunclet(BYTE* pHandlerIP, REGDISPLAY* pvRegDisplay, ExInfo* exInfo } CONTRACTL_END; - Thread* pThread = GET_THREAD(); + Thread* pThread = GetThread(); pThread->DecPreventAbort(); exInfo->m_ScannedStackRange.ExtendUpperBound(exInfo->m_frameIter.m_crawl.GetRegisterSet()->SP); @@ -3457,7 +3456,7 @@ void CallCatchFunclet(BYTE* pHandlerIP, REGDISPLAY* pvRegDisplay, ExInfo* exInfo void ResumeAtInterceptionLocation(REGDISPLAY* pvRegDisplay) { - Thread* pThread = GET_THREAD(); + Thread* pThread = GetThread(); pThread->DecPreventAbort(); UINT_PTR targetSp = GetSP(pvRegDisplay->pCurrentContext); @@ -3510,7 +3509,7 @@ void CallFinallyFunclet(BYTE* pHandlerIP, REGDISPLAY* pvRegDisplay, ExInfo* exIn STATIC_CONTRACT_GC_TRIGGERS; STATIC_CONTRACT_MODE_COOPERATIVE; - Thread* pThread = GET_THREAD(); + Thread* pThread = GetThread(); pThread->DecPreventAbort(); exInfo->m_csfEnclosingClause = CallerStackFrame::FromRegDisplay(exInfo->m_frameIter.m_crawl.GetRegisterSet()); @@ -3539,10 +3538,9 @@ extern "C" CLR_BOOL QCALLTYPE CallFilterFunclet(QCall::ObjectHandleOnStack excep BEGIN_QCALL; - MAKE_CURRENT_THREAD_AVAILABLE(); GCX_COOP(); - Thread* pThread = GET_THREAD(); + Thread* pThread = GetThread(); Frame* pFrame = pThread->GetFrame(); MarkInlinedCallFrameAsEHHelperCall(pFrame); @@ -3624,7 +3622,7 @@ CLR_BOOL EHEnumNextWorker(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClause* pEHClause, EE_ILEXCEPTION_CLAUSE EHClause; memset(&EHClause, 0, sizeof(EE_ILEXCEPTION_CLAUSE)); PTR_EXCEPTION_CLAUSE_TOKEN pEHClauseToken = pJitMan->GetNextEHClause(pEHEnum, &EHClause); - Thread* pThread = GET_THREAD(); + Thread* pThread = GetThread(); ExInfo* pExInfo = (ExInfo*)pThread->GetExceptionState()->GetCurrentExceptionTracker(); pExInfo->m_CurrentClause = EHClause; @@ -3709,8 +3707,7 @@ extern "C" CLR_BOOL QCALLTYPE EHEnumNext(EH_CLAUSE_ENUMERATOR* pEHEnum, RhEHClau BEGIN_QCALL; - MAKE_CURRENT_THREAD_AVAILABLE(); - Thread* pThread = GET_THREAD(); + Thread* pThread = GetThread(); Frame* pFrame = pThread->GetFrame(); MarkInlinedCallFrameAsEHHelperCall(pFrame); @@ -3918,7 +3915,7 @@ CLR_BOOL SfiInitWorker(StackFrameIterator* pThis, CONTEXT* pStackwalkCtx, CLR_BO CONTRACTL_END; CLR_BOOL result = FALSE; - Thread* pThread = GET_THREAD(); + Thread* pThread = GetThread(); ExInfo* pExInfo = (ExInfo*)pThread->GetExceptionState()->GetCurrentExceptionTracker(); Frame* pFrame = pThread->GetFrame(); @@ -4061,8 +4058,7 @@ extern "C" CLR_BOOL QCALLTYPE SfiInit(StackFrameIterator* pThis, CONTEXT* pStack BEGIN_QCALL; - MAKE_CURRENT_THREAD_AVAILABLE(); - Thread* pThread = GET_THREAD(); + Thread* pThread = GetThread(); Frame* pFrame = pThread->GetFrame(); MarkInlinedCallFrameAsEHHelperCall(pFrame); @@ -4102,7 +4098,7 @@ CLR_BOOL SfiNextWorker(StackFrameIterator* pThis, uint* uExCollideClauseIdx, CLR StackWalkAction retVal = SWA_FAILED; CLR_BOOL success = FALSE; - Thread* pThread = GET_THREAD(); + Thread* pThread = GetThread(); ExInfo* pTopExInfo = (ExInfo*)pThread->GetExceptionState()->GetCurrentExceptionTracker(); Frame* pFrame = pThread->GetFrame(); @@ -4383,8 +4379,7 @@ extern "C" CLR_BOOL QCALLTYPE SfiNext(StackFrameIterator* pThis, uint* uExCollid BEGIN_QCALL; - MAKE_CURRENT_THREAD_AVAILABLE(); - Thread* pThread = GET_THREAD(); + Thread* pThread = GetThread(); Frame* pFrame = pThread->GetFrame(); MarkInlinedCallFrameAsEHHelperCall(pFrame); diff --git a/src/coreclr/vm/exceptmacros.h b/src/coreclr/vm/exceptmacros.h index 852b93ee04d6c1..f6e21f5c8cfcd6 100644 --- a/src/coreclr/vm/exceptmacros.h +++ b/src/coreclr/vm/exceptmacros.h @@ -212,7 +212,7 @@ void SetQCallExceptionStatusThrowable(QCallExceptionStatus* pStatus, OBJECTREF t static_assert(sizeof(QCallExceptionStatus) == sizeof(void*)); void UnwindAndContinueRethrowHelperInsideCatch(Frame* pEntryFrame, Exception* pException); -void UnwindAndContinueRethrowHelperInsideQcallCatch( +void UnwindAndContinueRethrowHelperInsideQCallCatch( Exception* pException, QCallExceptionStatus* pQCallException DEBUG_ARG(Frame* pEntryFrame)); @@ -353,12 +353,12 @@ VOID DECLSPEC_NORETURN DispatchManagedException(PAL_SEHException& ex, bool isHar } \ PAL_CPP_CATCH_NON_DERIVED_NOARG (const std::bad_alloc&) \ { \ - UnwindAndContinueRethrowHelperInsideQcallCatch(Exception::GetOOMException(), qcallError DEBUG_ARG(__pUnCEntryFrame)); \ + UnwindAndContinueRethrowHelperInsideQCallCatch(Exception::GetOOMException(), qcallError DEBUG_ARG(__pUnCEntryFrame)); \ } \ PAL_CPP_CATCH_DERIVED (Exception, __pException) \ { \ CONSISTENCY_CHECK(NULL != __pException); \ - UnwindAndContinueRethrowHelperInsideQcallCatch(__pException, qcallError DEBUG_ARG(__pUnCEntryFrame)); \ + UnwindAndContinueRethrowHelperInsideQCallCatch(__pException, qcallError DEBUG_ARG(__pUnCEntryFrame)); \ } \ PAL_CPP_ENDTRY \ } @@ -468,12 +468,12 @@ VOID DECLSPEC_NORETURN DispatchManagedException(PAL_SEHException& ex, bool isHar } \ PAL_CPP_CATCH_NON_DERIVED_NOARG (const std::bad_alloc&) \ { \ - UnwindAndContinueRethrowHelperInsideQcallCatch(Exception::GetOOMException(), qcallError DEBUG_ARG(__pUnCEntryFrame)); \ + UnwindAndContinueRethrowHelperInsideQCallCatch(Exception::GetOOMException(), qcallError DEBUG_ARG(__pUnCEntryFrame)); \ } \ PAL_CPP_CATCH_DERIVED (Exception, __pException) \ { \ CONSISTENCY_CHECK(NULL != __pException); \ - UnwindAndContinueRethrowHelperInsideQcallCatch(__pException, qcallError DEBUG_ARG(__pUnCEntryFrame)); \ + UnwindAndContinueRethrowHelperInsideQCallCatch(__pException, qcallError DEBUG_ARG(__pUnCEntryFrame)); \ } \ PAL_CPP_ENDTRY \ } diff --git a/src/coreclr/vm/reflectioninvocation.cpp b/src/coreclr/vm/reflectioninvocation.cpp index 4cbf731fe16384..973927d691fc82 100644 --- a/src/coreclr/vm/reflectioninvocation.cpp +++ b/src/coreclr/vm/reflectioninvocation.cpp @@ -337,7 +337,7 @@ extern "C" void QCALLTYPE RuntimeMethodHandle_InvokeMethod( BEGIN_QCALL; - MAKE_CURRENT_THREAD_AVAILABLE(); + Thread * pThread = GetThread(); GCX_COOP(); struct @@ -401,8 +401,6 @@ extern "C" void QCALLTYPE RuntimeMethodHandle_InvokeMethod( // Note that SizeOfFrameArgumentArray does overflow checks with sufficient margin to prevent overflows here SIZE_T nAllocaSize = TransitionBlock::GetNegSpaceSize() + sizeof(TransitionBlock) + nStackBytes; - Thread * pThread = GET_THREAD(); - LPBYTE pAlloc = (LPBYTE)_alloca(nAllocaSize); LPBYTE pTransitionBlock = pAlloc + TransitionBlock::GetNegSpaceSize(); From 1742816083bf19795bec83cbb47ce548db29bd9b Mon Sep 17 00:00:00 2001 From: David Wrighton Date: Wed, 2 Sep 2026 14:58:42 -0700 Subject: [PATCH 22/23] Restore CompressBound in WebAssembly P/Invoke tables Keep the CompressionNative_CompressBound entry in the browser and WASI static P/Invoke tables and update their entry counts. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 3bf4a72c-55aa-4b64-8dc3-c0fbeb82730c --- src/coreclr/vm/wasm/browser/callhelpers-pinvoke.cpp | 4 +++- src/coreclr/vm/wasm/wasi/callhelpers-pinvoke.cpp | 4 +++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/src/coreclr/vm/wasm/browser/callhelpers-pinvoke.cpp b/src/coreclr/vm/wasm/browser/callhelpers-pinvoke.cpp index 2248bb068804aa..e2744321b81d8d 100644 --- a/src/coreclr/vm/wasm/browser/callhelpers-pinvoke.cpp +++ b/src/coreclr/vm/wasm/browser/callhelpers-pinvoke.cpp @@ -11,6 +11,7 @@ #include extern "C" { + uint32_t CompressionNative_CompressBound (uint32_t); uint32_t CompressionNative_Crc32 (uint32_t, void *, int32_t); int32_t CompressionNative_Deflate (void *, int32_t); int32_t CompressionNative_DeflateEnd (void *); @@ -195,6 +196,7 @@ static const Entry s_libSystem_Globalization_Native [] = { }; static const Entry s_libSystem_IO_Compression_Native [] = { + DllImportEntry(CompressionNative_CompressBound) // System.IO.Compression DllImportEntry(CompressionNative_Crc32) // System.IO.Compression DllImportEntry(CompressionNative_Deflate) // System.IO.Compression, System.Net.WebSockets DllImportEntry(CompressionNative_DeflateEnd) // System.IO.Compression, System.Net.WebSockets @@ -324,7 +326,7 @@ typedef struct PInvokeTable { static PInvokeTable s_PInvokeTables[] = { {"libSystem.Globalization.Native", s_libSystem_Globalization_Native, 34}, - {"libSystem.IO.Compression.Native", s_libSystem_IO_Compression_Native, 9}, + {"libSystem.IO.Compression.Native", s_libSystem_IO_Compression_Native, 10}, {"libSystem.Native", s_libSystem_Native, 94}, {"libSystem.Native.Browser", s_libSystem_Native_Browser, 1}, {"libSystem.Runtime.InteropServices.JavaScript.Native", s_libSystem_Runtime_InteropServices_JavaScript_Native, 6} diff --git a/src/coreclr/vm/wasm/wasi/callhelpers-pinvoke.cpp b/src/coreclr/vm/wasm/wasi/callhelpers-pinvoke.cpp index 0a5a7cd5c3d52e..89b992b77aae8f 100644 --- a/src/coreclr/vm/wasm/wasi/callhelpers-pinvoke.cpp +++ b/src/coreclr/vm/wasm/wasi/callhelpers-pinvoke.cpp @@ -11,6 +11,7 @@ #include extern "C" { + uint32_t CompressionNative_CompressBound (uint32_t); uint32_t CompressionNative_Crc32 (uint32_t, void *, int32_t); int32_t CompressionNative_Deflate (void *, int32_t); int32_t CompressionNative_DeflateEnd (void *); @@ -290,6 +291,7 @@ static const Entry s_libSystem_Globalization_Native [] = { }; static const Entry s_libSystem_IO_Compression_Native [] = { + DllImportEntry(CompressionNative_CompressBound) // System.IO.Compression DllImportEntry(CompressionNative_Crc32) // System.IO.Compression DllImportEntry(CompressionNative_Deflate) // System.IO.Compression DllImportEntry(CompressionNative_DeflateEnd) // System.IO.Compression @@ -526,7 +528,7 @@ typedef struct PInvokeTable { static PInvokeTable s_PInvokeTables[] = { {"libSystem.Globalization.Native", s_libSystem_Globalization_Native, 34}, - {"libSystem.IO.Compression.Native", s_libSystem_IO_Compression_Native, 9}, + {"libSystem.IO.Compression.Native", s_libSystem_IO_Compression_Native, 10}, {"libSystem.Native", s_libSystem_Native, 148}, {"libSystem.Native.Browser", s_libSystem_Native_Browser, 0}, {"libSystem.Runtime.InteropServices.JavaScript.Native", s_libSystem_Runtime_InteropServices_JavaScript_Native, 0}, From e1b823a3d0a8241eaab5127a85fe773defa636f1 Mon Sep 17 00:00:00 2001 From: David Wrighton Date: Wed, 2 Sep 2026 19:56:41 -0700 Subject: [PATCH 23/23] Address QCall review feedback Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 3bf4a72c-55aa-4b64-8dc3-c0fbeb82730c --- docs/design/coreclr/botr/corelib.md | 30 +++++++++++-------- .../CompilerServices/QCallExceptionStatus.cs | 22 +++++++------- .../src/System/Threading/Thread.CoreCLR.cs | 3 +- .../COM/NETClients/Primitives/Program.cs | 1 + 4 files changed, 30 insertions(+), 26 deletions(-) diff --git a/docs/design/coreclr/botr/corelib.md b/docs/design/coreclr/botr/corelib.md index 1dd2fc60d4bb08..931deac35f29a6 100644 --- a/docs/design/coreclr/botr/corelib.md +++ b/docs/design/coreclr/botr/corelib.md @@ -77,29 +77,29 @@ QCalls should be implemented with a C-style method signature. This makes it easi Do not replicate the comments into your actual QCall implementation. This is for illustrative purposes. ```CSharp -class Foo +partial class Foo { - // All QCalls should have the following DllImport attribute - [DllImport(RuntimeHelpers.QCall, EntryPoint = "Foo_BarInternal", CharSet = CharSet.Unicode)] - - // QCalls should always be static extern. - private static extern bool BarInternal(int flags, string inString, StringHandleOnStack retString); + // QCalls that use BEGIN_QCALL must use the hidden last parameter error handler. + [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Foo_BarInternal", StringMarshalling = StringMarshalling.Utf16)] + [return: MarshalAs(UnmanagedType.Bool)] + private static partial bool BarInternal(int flags, string inString, StringHandleOnStack retString); // Many QCalls have a thin managed wrapper around them to perform // as much work prior to the transition as possible. An example would be // argument validation which is easier in managed than native code. - public string Bar(int flags) + public string Bar(int flags, string inString) { if (flags != 0) throw new ArgumentException("Invalid flags"); - string retString = null; + string? retString = null; // The strings are returned from QCalls by taking address - // of a local variable using StringHandleOnStack - if (!BarInternal(flags, this.Id, new StringHandleOnStack(ref retString))) + // of a local variable using StringHandleOnStack. + if (!BarInternal(flags, inString, new StringHandleOnStack(ref retString))) FatalError(); - return retString; + return retString!; } } ``` @@ -114,7 +114,8 @@ The QCall entrypoint has to be registered in tables in [vm\qcallentrypoints.cpp] ```C++ // All QCalls should be free functions and tagged with QCALLTYPE and extern "C" -extern "C" BOOL QCALLTYPE Foo_BarInternal(int flags, LPCWSTR wszString, QCall::StringHandleOnStack retString) +extern "C" BOOL QCALLTYPE Foo_BarInternal( + int flags, LPCWSTR wszString, QCall::StringHandleOnStack retString, QCallExceptionStatus* qcallError) { // All QCalls should have QCALL_CONTRACT. // It is alias for THROWS; GC_TRIGGERS; MODE_PREEMPTIVE. @@ -132,7 +133,7 @@ extern "C" BOOL QCALLTYPE Foo_BarInternal(int flags, LPCWSTR wszString, QCall::S BOOL retVal = FALSE; // The body has to be enclosed in BEGIN_QCALL/END_QCALL macro. - // It is necessary for exception handling. + // It initializes qcallError and captures exceptions for the managed error handler. BEGIN_QCALL; // Argument validation would ideally be in managed, but in some cases @@ -158,6 +159,9 @@ extern "C" BOOL QCALLTYPE Foo_BarInternal(int flags, LPCWSTR wszString, QCall::S } ``` +QCalls that return before entering `BEGIN_QCALL`, including no-op fast paths and code excluded +by platform conditionals, must explicitly set `*qcallError = 0` before returning. + ## FCall functional behavior FCalls allow more flexibility in terms of passing object references around, but with higher code complexity and more opportunities to make mistakes. Additionally, for any FCall of non-trivial length, explicitly poll for whether a garbage collection must occur. Failing to do so will lead to starvation issues if managed code repeatedly calls the FCall method in a tight loop, because FCalls execute while the thread only allows the GC to run in a cooperative manner. diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallExceptionStatus.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallExceptionStatus.cs index 9d7dcde2c8b1af..71d3c0e9b7e659 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallExceptionStatus.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/QCallExceptionStatus.cs @@ -38,22 +38,20 @@ public static QCallExceptionStatus ConvertToManaged(nint status) [MethodImpl(MethodImplOptions.NoInlining)] private static void HandleException(nint status) { - Exception exception; if ((nuint)status <= 2) { - exception = Thread.GetQCallSpecialException(status); + throw Thread.GetQCallSpecialException(status); + } + + Exception exception; + GCHandle exceptionHandle = GCHandle.FromIntPtr(status); + try + { + exception = (Exception)exceptionHandle.Target!; } - else + finally { - GCHandle exceptionHandle = GCHandle.FromIntPtr(status); - try - { - exception = (Exception)exceptionHandle.Target!; - } - finally - { - exceptionHandle.Free(); - } + exceptionHandle.Free(); } // Throw during unmarshalling so QCall exception propagation remains as close as diff --git a/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs index 924f431c2e83fb..e4571fbb2974cf 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs @@ -61,7 +61,8 @@ internal static Exception GetQCallSpecialException(nint status) { Exception? exception = null; GetQCallSpecialException(status, ObjectHandleOnStack.Create(ref exception)); - return exception!; + Debug.Assert(exception is not null); + return exception; } [ErrorHandler(typeof(QCallExceptionStatusMarshaller), ErrorLocation.HiddenLastParameter)] diff --git a/src/tests/Interop/COM/NETClients/Primitives/Program.cs b/src/tests/Interop/COM/NETClients/Primitives/Program.cs index e487e15d08de91..c6d12d07fbb7da 100644 --- a/src/tests/Interop/COM/NETClients/Primitives/Program.cs +++ b/src/tests/Interop/COM/NETClients/Primitives/Program.cs @@ -12,6 +12,7 @@ namespace NetClient public class Program { [Fact] + [SkipOnCoreClr("Stack trace assertions are unreliable under JIT stress due to aggressive inlining", RuntimeTestModes.JitStress)] public static int TestEntryPoint() { // RegFree COM is not supported on Windows Nano