diff --git a/src/mono/CMakeLists.txt b/src/mono/CMakeLists.txt index 64a979069c34d..c71ec9c40770f 100644 --- a/src/mono/CMakeLists.txt +++ b/src/mono/CMakeLists.txt @@ -707,7 +707,8 @@ endif() add_subdirectory(mono) if (ENABLE_MSCORDBI AND NOT TARGET_ARCH STREQUAL "arm64" AND NOT CMAKE_CROSSCOMPILING AND NOT TARGET_IOS AND NOT TARGET_ANDROID AND NOT TARGET_BROWSER AND NOT HOST_MACCATALYST) - add_subdirectory(dbi) + add_subdirectory(dlls/mscordbi) + add_subdirectory(dlls/dbgshim) endif() configure_file(cmake/config.h.in config.h) diff --git a/src/mono/dlls/dbgshim/CMakeLists.txt b/src/mono/dlls/dbgshim/CMakeLists.txt new file mode 100644 index 0000000000000..14b2a716260b6 --- /dev/null +++ b/src/mono/dlls/dbgshim/CMakeLists.txt @@ -0,0 +1,90 @@ +project(dbgshim) + +set(CMAKE_INCLUDE_CURRENT_DIR ON) + +set(CMAKE_EXPORT_COMPILE_COMMANDS ON) +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +set(CLR_DIR ${PROJECT_SOURCE_DIR}/../../coreclr) +set(VM_DIR ${PROJECT_SOURCE_DIR}/../../coreclr/vm) +set(CMAKE_OSX_ARCHITECTURES ${CMAKE_SYSTEM_PROCESSOR}) +set(CMAKE_EXE_LINKER_FLAGS_CHECKED "") +set(CMAKE_SHARED_LINKER_FLAGS_CHECKED "") +set(CLR_CMAKE_HOST_ARCH ${CMAKE_GENERATOR_PLATFORM}) +set(FEATURE_EVENT_TRACE 0) + +if(HOST_WIN32) + if(HOST_X86) + set(CLR_CMAKE_HOST_ARCH x86) + elseif(HOST_ARM64) + set(CLR_CMAKE_HOST_ARCH arm64) + elseif(HOST_ARM) + set(CLR_CMAKE_HOST_ARCH arm) + elseif(HOST_AMD64) + set(CLR_CMAKE_HOST_ARCH x64) + endif() +endif() + +include(${PROJECT_SOURCE_DIR}/../../../../eng/native/configuretools.cmake) +include(${PROJECT_SOURCE_DIR}/../../../../eng/native/configurepaths.cmake) +include(${PROJECT_SOURCE_DIR}/../../../../eng/native/configureplatform.cmake) +include(${PROJECT_SOURCE_DIR}/../../../../eng/native/configurecompiler.cmake) + + +add_definitions(-D_WIN32_WINNT=0x0602) + +include_directories( + ${CMAKE_CURRENT_SOURCE_DIR}/../../.. + ${PROJECT_SOURCE_DIR}/../../ + ${PROJECT_SOURCE_DIR}/../mscordbi + ${PROJECT_SOURCE_DIR}/../mscordbi/socket-dbi + ${PROJECT_SOURCE_DIR}/../../../coreclr/md/enc + ${PROJECT_SOURCE_DIR}/../../../coreclr/inc + ${PROJECT_SOURCE_DIR}/../../../coreclr/pal/inc + ${PROJECT_SOURCE_DIR}/../../../coreclr/md/inc + ${PROJECT_SOURCE_DIR}/../../../coreclr/md/compiler) + +include_directories("../../../coreclr/pal/prebuilt/inc") +include_directories("../../../coreclr/nativeresources") + +if (CLR_CMAKE_HOST_UNIX) + include_directories("${PROJECT_SOURCE_DIR}/../../../coreclr/pal/inc") + include_directories("${PROJECT_SOURCE_DIR}/../../../coreclr/pal/inc/rt") + include_directories("${PROJECT_SOURCE_DIR}/../../../coreclr/pal/src/safecrt") + + append("-Wno-missing-prototypes -Wno-pointer-arith -Wno-macro-redefined" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) + + include_directories("../../../coreclr/pal/inc/rt/cpp") +endif (CLR_CMAKE_HOST_UNIX) + +set(DBGSHIM_SOURCES + dbgshim.cpp +) + +add_library(dbgshim SHARED ${DBGSHIM_SOURCES}) + +if(HOST_DARWIN) +set(OS_LIBS "-framework CoreFoundation" "-framework Foundation") +elseif(HOST_LINUX) +set(OS_LIBS pthread m dl) +elseif(HOST_WIN32) +set(OS_LIBS bcrypt.lib Mswsock.lib ws2_32.lib psapi.lib version.lib advapi32.lib winmm.lib kernel32.lib) +endif() + + +set(DBGSHIM_LIBRARIES + ${OS_LIBS} + utilcodestaticnohost +) + +if(CLR_CMAKE_HOST_UNIX) + list(APPEND DBGSHIM_LIBRARIES + coreclrpal + palrt + nativeresourcestring + ) +endif() + +target_link_libraries(dbgshim ${DBGSHIM_LIBRARIES}) +install(TARGETS dbgshim DESTINATION lib) diff --git a/src/mono/dlls/dbgshim/dbgshim.cpp b/src/mono/dlls/dbgshim/dbgshim.cpp new file mode 100644 index 0000000000000..d83828baaf8d1 --- /dev/null +++ b/src/mono/dlls/dbgshim/dbgshim.cpp @@ -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. +//***************************************************************************** +// DbgShim.cpp +// +// dbgshim is responsible to start the debuggee process with debug parameters and to +// load the correct mscordbi that will connect with mono runtime. +//***************************************************************************** + +#include + +#include "dbgshim.h" + +#include "palclr.h" +#if defined(TARGET_WINDOWS) +#include +#else +#include +#define putenv _putenv +#endif + +#ifndef MAX_LONGPATH +#define MAX_LONGPATH 1024 +#endif + +#ifdef HOST_UNIX +#define INITIALIZE_SHIM { if (PAL_InitializeDLL() != 0) return E_FAIL; } +#else +#define INITIALIZE_SHIM +#endif + +// Contract for public APIs. These must be NOTHROW. +#define PUBLIC_CONTRACT \ + INITIALIZE_SHIM \ + CONTRACTL \ + { \ + NOTHROW; \ + } \ + CONTRACTL_END; + +// Functions that we'll look for in the loaded Mscordbi module. +typedef HRESULT (STDAPICALLTYPE *FPCoreCLRCreateCordbObject)( + int iDebuggerVersion, + DWORD pid, + HMODULE hmodTargetCLR, + IUnknown **ppCordb); + +//----------------------------------------------------------------------------- +// Public API. +// +// CreateProcessForLaunch - a stripped down version of the Windows CreateProcess +// that can be supported cross-platform. +// +//----------------------------------------------------------------------------- +MONO_API HRESULT +CreateProcessForLaunch( + __in LPWSTR lpCommandLine, + __in BOOL bSuspendProcess, + __in LPVOID lpEnvironment, + __in LPCWSTR lpCurrentDirectory, + __out PDWORD pProcessId, + __out HANDLE *pResumeHandle) +{ + PUBLIC_CONTRACT; + PROCESS_INFORMATION processInfo; + STARTUPINFOW startupInfo; + DWORD dwCreationFlags = 0; + + ZeroMemory(&processInfo, sizeof(processInfo)); + ZeroMemory(&startupInfo, sizeof(startupInfo)); + + startupInfo.cb = sizeof(startupInfo); + + putenv("MONO_ENV_OPTIONS='--debugger-agent=transport=dt_socket,address=127.0.0.1:pid_based,server=n,suspend=y,loglevel=10,timeout=100000'"); + + BOOL result = CreateProcessW( + NULL, + lpCommandLine, + NULL, + NULL, + FALSE, + dwCreationFlags, + NULL, + lpCurrentDirectory, + &startupInfo, + &processInfo); + + if (!result) { + *pProcessId = 0; + *pResumeHandle = NULL; + return HRESULT_FROM_WIN32(GetLastError()); + } + + if (processInfo.hProcess != NULL) + { + CloseHandle(processInfo.hProcess); + } + + *pProcessId = processInfo.dwProcessId; + *pResumeHandle = processInfo.hThread; + + return S_OK; +} + +MONO_API HRESULT +ResumeProcess( + __in HANDLE hResumeHandle) +{ + return S_OK; +} + +MONO_API HRESULT +CloseResumeHandle( + __in HANDLE hResumeHandle) +{ + return S_OK; +} + + +HRESULT CreateCoreDbg(HMODULE hDBIModule, DWORD processId, int iDebuggerVersion, IUnknown **ppCordb) +{ + HRESULT hr = S_OK; + +#if defined(TARGET_WINDOWS) + FPCoreCLRCreateCordbObject fpCreate = + (FPCoreCLRCreateCordbObject)GetProcAddress(hDBIModule, "CoreCLRCreateCordbObject"); +#else + FPCoreCLRCreateCordbObject fpCreate = (FPCoreCLRCreateCordbObject)dlsym (hDBIModule, "CoreCLRCreateCordbObject"); +#endif + + if (fpCreate == NULL) + { + return CORDBG_E_INCOMPATIBLE_PROTOCOL; + } + + return fpCreate(iDebuggerVersion, processId, NULL, ppCordb); + + return hr; +} + +char* convertC(const WCHAR * wString) +{ + int size; + char * MultiBuffer = NULL; + + size = WideCharToMultiByte(CP_ACP,0,wString,-1,MultiBuffer,0,NULL,NULL); + MultiBuffer = (char*) malloc(size); + if (MultiBuffer == NULL) + { + return NULL; + } + WideCharToMultiByte(CP_ACP,0,wString,-1,MultiBuffer,size,NULL,NULL); + return MultiBuffer; +} + +static IUnknown* pCordb = NULL; + +MONO_API HRESULT +RegisterForRuntimeStartup( + __in DWORD dwProcessId, + __in PSTARTUP_CALLBACK pfnCallback, + __in PVOID parameter, + __out PVOID *ppUnregisterToken) +{ + if (pCordb != NULL) + return S_OK; + + HRESULT hr = S_OK; + HMODULE hMod = NULL; + + char* msCorDbiPath = getenv("MSCORDBI_PATH"); +#ifdef TARGET_WINDOWS + hMod = LoadLibraryA(msCorDbiPath); +#else + hMod = dlopen(msCorDbiPath, RTLD_LAZY); +#endif + if (hMod == NULL) + { + hr = CORDBG_E_DEBUG_COMPONENT_MISSING; + goto exit; + } + + hr = CreateCoreDbg(hMod, dwProcessId, 0, &pCordb); + + exit: + if (FAILED(hr)) + { + _ASSERTE(pCordb == NULL); + + if (hMod != NULL) + { + FreeLibrary(hMod); + } + + // Invoke the callback on error + pfnCallback(NULL, parameter, hr); + return hr; + } + pfnCallback(pCordb, parameter, S_OK); + return S_OK; +} + +MONO_API HRESULT +RegisterForRuntimeStartupEx( + __in DWORD dwProcessId, + __in LPCWSTR szApplicationGroupId, + __in PSTARTUP_CALLBACK pfnCallback, + __in PVOID parameter, + __out PVOID *ppUnregisterToken) +{ + return S_OK; +} + +MONO_API HRESULT +UnregisterForRuntimeStartup( + __in PVOID pUnregisterToken) +{ + return S_OK; +} + +MONO_API HRESULT +GetStartupNotificationEvent( + __in DWORD debuggeePID, + __out HANDLE* phStartupEvent) +{ + return S_OK; +} + +MONO_API HRESULT +EnumerateCLRs(DWORD debuggeePID, + __out HANDLE** ppHandleArrayOut, + __out LPWSTR** ppStringArrayOut, + __out DWORD* pdwArrayLengthOut) +{ + return S_OK; +} + +MONO_API HRESULT +CloseCLREnumeration( + __in HANDLE* pHandleArray, + __in LPWSTR* pStringArray, + __in DWORD dwArrayLength) +{ + return S_OK; +} + +MONO_API HRESULT +CreateVersionStringFromModule( + __in DWORD pidDebuggee, + __in LPCWSTR szModuleName, + __out_ecount_part(cchBuffer, *pdwLength) LPWSTR pBuffer, + __in DWORD cchBuffer, + __out DWORD* pdwLength) +{ + return S_OK; +} + +MONO_API HRESULT +CreateDebuggingInterfaceFromVersionEx( + __in int iDebuggerVersion, + __in LPCWSTR szDebuggeeVersion, + __out IUnknown ** ppCordb) +{ + return S_OK; +} + +MONO_API +HRESULT +CreateDebuggingInterfaceFromVersion2( + __in int iDebuggerVersion, + __in LPCWSTR szDebuggeeVersion, + __in LPCWSTR szApplicationGroupId, + __out IUnknown ** ppCordb) +{ + return S_OK; +} + +MONO_API HRESULT +CreateDebuggingInterfaceFromVersion( + __in LPCWSTR szDebuggeeVersion, + __out IUnknown ** ppCordb) +{ + return S_OK; +} diff --git a/src/mono/dlls/dbgshim/dbgshim.h b/src/mono/dlls/dbgshim/dbgshim.h new file mode 100644 index 0000000000000..092671223dfa8 --- /dev/null +++ b/src/mono/dlls/dbgshim/dbgshim.h @@ -0,0 +1,98 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +//***************************************************************************** +// DbgShim.h +// +//***************************************************************************** + +#include + +#if defined(TARGET_WINDOWS) +#include +#include +#endif + +#include + +typedef VOID (*PSTARTUP_CALLBACK)(IUnknown *pCordb, PVOID parameter, HRESULT hr); + + +MONO_API HRESULT +CreateProcessForLaunch( + __in LPWSTR lpCommandLine, + __in BOOL bSuspendProcess, + __in LPVOID lpEnvironment, + __in LPCWSTR lpCurrentDirectory, + __out PDWORD pProcessId, + __out HANDLE *pResumeHandle); + +MONO_API HRESULT +ResumeProcess( + __in HANDLE hResumeHandle); + +MONO_API HRESULT +CloseResumeHandle( + __in HANDLE hResumeHandle); + +MONO_API HRESULT +RegisterForRuntimeStartup( + __in DWORD dwProcessId, + __in PSTARTUP_CALLBACK pfnCallback, + __in PVOID parameter, + __out PVOID *ppUnregisterToken); + +MONO_API HRESULT +RegisterForRuntimeStartupEx( + __in DWORD dwProcessId, + __in LPCWSTR szApplicationGroupId, + __in PSTARTUP_CALLBACK pfnCallback, + __in PVOID parameter, + __out PVOID *ppUnregisterToken); + +MONO_API HRESULT +UnregisterForRuntimeStartup( + __in PVOID pUnregisterToken); + +MONO_API HRESULT +GetStartupNotificationEvent( + __in DWORD debuggeePID, + __out HANDLE* phStartupEvent); + +MONO_API HRESULT +EnumerateCLRs(DWORD debuggeePID, + __out HANDLE** ppHandleArrayOut, + __out LPWSTR** ppStringArrayOut, + __out DWORD* pdwArrayLengthOut); + +MONO_API HRESULT +CloseCLREnumeration( + __in HANDLE* pHandleArray, + __in LPWSTR* pStringArray, + __in DWORD dwArrayLength); + +MONO_API HRESULT +CreateVersionStringFromModule( + __in DWORD pidDebuggee, + __in LPCWSTR szModuleName, + __out_ecount_part(cchBuffer, *pdwLength) LPWSTR pBuffer, + __in DWORD cchBuffer, + __out DWORD* pdwLength); + +MONO_API HRESULT +CreateDebuggingInterfaceFromVersionEx( + __in int iDebuggerVersion, + __in LPCWSTR szDebuggeeVersion, + __out IUnknown ** ppCordb); + +MONO_API +HRESULT +CreateDebuggingInterfaceFromVersion2( + __in int iDebuggerVersion, + __in LPCWSTR szDebuggeeVersion, + __in LPCWSTR szApplicationGroupId, + __out IUnknown ** ppCordb); + +MONO_API HRESULT +CreateDebuggingInterfaceFromVersion( + __in LPCWSTR szDebuggeeVersion, + __out IUnknown ** ppCordb); diff --git a/src/mono/dbi/CMakeLists.txt b/src/mono/dlls/mscordbi/CMakeLists.txt similarity index 56% rename from src/mono/dbi/CMakeLists.txt rename to src/mono/dlls/mscordbi/CMakeLists.txt index 5f8c0db8b8f14..db161e7b392ff 100644 --- a/src/mono/dbi/CMakeLists.txt +++ b/src/mono/dlls/mscordbi/CMakeLists.txt @@ -29,14 +29,14 @@ endif() add_definitions(-DDBI_COMPONENT_MONO) include_directories( - ${CMAKE_CURRENT_SOURCE_DIR}/../.. - ${PROJECT_SOURCE_DIR}/../ - ${PROJECT_SOURCE_DIR}/../dbi - ${PROJECT_SOURCE_DIR}/../dbi/socket-dbi - ${PROJECT_SOURCE_DIR}/../../coreclr/md/enc - ${PROJECT_SOURCE_DIR}/../../coreclr/inc - ${PROJECT_SOURCE_DIR}/../../coreclr/md/inc - ${PROJECT_SOURCE_DIR}/../../coreclr/md/compiler) + ${CMAKE_CURRENT_SOURCE_DIR}/../../.. + ${PROJECT_SOURCE_DIR}/../../ + ${PROJECT_SOURCE_DIR}/../mscordbi + ${PROJECT_SOURCE_DIR}/../mscordbi/socket-dbi + ${PROJECT_SOURCE_DIR}/../../../coreclr/md/enc + ${PROJECT_SOURCE_DIR}/../../../coreclr/inc + ${PROJECT_SOURCE_DIR}/../../../coreclr/md/inc + ${PROJECT_SOURCE_DIR}/../../../coreclr/md/compiler) set(mscorbi_sources_base cordb.cpp @@ -65,6 +65,8 @@ set(mscorbi_sources_base cordb-process.h cordb-register.cpp cordb-register.h + cordb-stackwalk.cpp + cordb-stackwalk.h cordb-stepper.cpp cordb-stepper.h cordb-thread.cpp @@ -84,54 +86,54 @@ elseif(HOST_WIN32) set(OS_LIBS bcrypt.lib Mswsock.lib ws2_32.lib psapi.lib version.lib advapi32.lib winmm.lib kernel32.lib) endif() -addprefix(mscorbi_sources ../dbi/ "${mscorbi_sources_base}") +addprefix(mscorbi_sources ../mscordbi/ "${mscorbi_sources_base}") add_subdirectory(${PROJECT_SOURCE_DIR}/socket-dbi) -include(${PROJECT_SOURCE_DIR}/../../../eng/native/configuretools.cmake) -include(${PROJECT_SOURCE_DIR}/../../../eng/native/configurepaths.cmake) -include(${PROJECT_SOURCE_DIR}/../../../eng/native/configureplatform.cmake) -include(${PROJECT_SOURCE_DIR}/../../../eng/native/configurecompiler.cmake) +include(${PROJECT_SOURCE_DIR}/../../../../eng/native/configuretools.cmake) +include(${PROJECT_SOURCE_DIR}/../../../../eng/native/configurepaths.cmake) +include(${PROJECT_SOURCE_DIR}/../../../../eng/native/configureplatform.cmake) +include(${PROJECT_SOURCE_DIR}/../../../../eng/native/configurecompiler.cmake) if (CLR_CMAKE_HOST_UNIX) # Add custom targets that the pal build expects. add_component(${CMAKE_INSTALL_DEFAULT_COMPONENT_NAME}) add_component(paltests_install) - include_directories("${PROJECT_SOURCE_DIR}/../../coreclr/pal/inc") - include_directories("${PROJECT_SOURCE_DIR}/../../coreclr/pal/inc/rt") - include_directories("${PROJECT_SOURCE_DIR}/../../coreclr/pal/src/safecrt") + include_directories("${PROJECT_SOURCE_DIR}/../../../coreclr/pal/inc") + include_directories("${PROJECT_SOURCE_DIR}/../../../coreclr/pal/inc/rt") + include_directories("${PROJECT_SOURCE_DIR}/../../../coreclr/pal/src/safecrt") append("-Wno-missing-prototypes -Wno-pointer-arith -Wno-macro-redefined" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) - add_subdirectory(${PROJECT_SOURCE_DIR}/../../coreclr/pal pal) + add_subdirectory(${PROJECT_SOURCE_DIR}/../../../coreclr/pal pal) - include_directories("../../coreclr/pal/inc/rt/cpp") + include_directories("../../../coreclr/pal/inc/rt/cpp") add_compile_options(-nostdinc) endif (CLR_CMAKE_HOST_UNIX) -include_directories("../../coreclr/pal/prebuilt/inc") -include_directories("../../coreclr/nativeresources") +include_directories("../../../coreclr/pal/prebuilt/inc") +include_directories("../../../coreclr/nativeresources") if (CLR_CMAKE_HOST_UNIX) - add_subdirectory(${PROJECT_SOURCE_DIR}/../../coreclr/nativeresources nativeresources) + add_subdirectory(${PROJECT_SOURCE_DIR}/../../../coreclr/nativeresources nativeresources) endif() -add_subdirectory(${PROJECT_SOURCE_DIR}/../../coreclr/md/runtime md/runtime) -add_subdirectory(${PROJECT_SOURCE_DIR}/../../coreclr/md/compiler md/compiler) +add_subdirectory(${PROJECT_SOURCE_DIR}/../../../coreclr/md/runtime md/runtime) +add_subdirectory(${PROJECT_SOURCE_DIR}/../../../coreclr/md/compiler md/compiler) -include(${PROJECT_SOURCE_DIR}/../../coreclr/clrdefinitions.cmake) -include_directories(${CMAKE_CURRENT_BINARY_DIR}/../) -include_directories(${CMAKE_CURRENT_BINARY_DIR}/../inc/) -add_subdirectory(${PROJECT_SOURCE_DIR}/../../coreclr/md/enc md/enc) -add_subdirectory(${PROJECT_SOURCE_DIR}/../../coreclr/utilcode utilcode) +include(${PROJECT_SOURCE_DIR}/../../../coreclr/clrdefinitions.cmake) +include_directories(${CMAKE_CURRENT_BINARY_DIR}/../../) +include_directories(${CMAKE_CURRENT_BINARY_DIR}/../../inc/) +add_subdirectory(${PROJECT_SOURCE_DIR}/../../../coreclr/md/enc md/enc) +add_subdirectory(${PROJECT_SOURCE_DIR}/../../../coreclr/utilcode utilcode) if (CLR_CMAKE_HOST_UNIX) - add_subdirectory(${PROJECT_SOURCE_DIR}/../../coreclr/palrt palrt) + add_subdirectory(${PROJECT_SOURCE_DIR}/../../../coreclr/palrt palrt) append("-Wno-strict-prototypes -Wno-deprecated -Wno-pointer-arith" CMAKE_C_FLAGS CMAKE_CXX_FLAGS) endif (CLR_CMAKE_HOST_UNIX) -add_library(mscordbi SHARED "${mscorbi_sources};${PROJECT_SOURCE_DIR}/../mono/mini/debugger-protocol.c;${PROJECT_SOURCE_DIR}/../../coreclr/pal/prebuilt/idl/xcordebug_i.cpp;${PROJECT_SOURCE_DIR}/../../coreclr/pal/prebuilt/idl/cordebug_i.cpp") +add_library(mscordbi SHARED "${mscorbi_sources};${PROJECT_SOURCE_DIR}/../../mono/mini/debugger-protocol.c;${PROJECT_SOURCE_DIR}/../../../coreclr/pal/prebuilt/idl/xcordebug_i.cpp;${PROJECT_SOURCE_DIR}/../../../coreclr/pal/prebuilt/idl/cordebug_i.cpp") #SET(CMAKE_C_COMPILER ${CMAKE_CXX_COMPILER}) -set_source_files_properties(${PROJECT_SOURCE_DIR}/../mono/mini/debugger-protocol.c PROPERTIES LANGUAGE CXX) +set_source_files_properties(${PROJECT_SOURCE_DIR}/../../mono/mini/debugger-protocol.c PROPERTIES LANGUAGE CXX) set(COREDBI_LIBRARIES utilcodestaticnohost diff --git a/src/mono/dbi/cordb-appdomain.cpp b/src/mono/dlls/mscordbi/cordb-appdomain.cpp similarity index 99% rename from src/mono/dbi/cordb-appdomain.cpp rename to src/mono/dlls/mscordbi/cordb-appdomain.cpp index d59b942fdcf53..a8f3953c60f85 100644 --- a/src/mono/dbi/cordb-appdomain.cpp +++ b/src/mono/dlls/mscordbi/cordb-appdomain.cpp @@ -179,7 +179,7 @@ HRESULT CordbAppDomain::GetObject(ICorDebugValue** ppObject) HRESULT CordbAppDomain::Attach(void) { LOG((LF_CORDB, LL_INFO100000, "CordbAppDomain - Attach - NOT IMPLEMENTED\n")); - return E_NOTIMPL; + return S_OK; } HRESULT CordbAppDomain::GetID(ULONG32* pId) diff --git a/src/mono/dbi/cordb-appdomain.h b/src/mono/dlls/mscordbi/cordb-appdomain.h similarity index 100% rename from src/mono/dbi/cordb-appdomain.h rename to src/mono/dlls/mscordbi/cordb-appdomain.h diff --git a/src/mono/dbi/cordb-assembly.cpp b/src/mono/dlls/mscordbi/cordb-assembly.cpp similarity index 86% rename from src/mono/dbi/cordb-assembly.cpp rename to src/mono/dlls/mscordbi/cordb-assembly.cpp index 95add50bb3b47..864fe4a5e9660 100644 --- a/src/mono/dbi/cordb-assembly.cpp +++ b/src/mono/dlls/mscordbi/cordb-assembly.cpp @@ -34,11 +34,14 @@ CordbAssembly::CordbAssembly(Connection* conn, CordbProcess* process, CordbAppDo m_pAppDomain = appDomain; m_pAppDomain->InternalAddRef(); m_debuggerId = id_assembly; + m_pAssemblyName = NULL; } CordbAssembly::~CordbAssembly() { m_pAppDomain->InternalRelease(); + if (m_pAssemblyName) + free(m_pAssemblyName); } HRESULT CordbAssembly::IsFullyTrusted(BOOL* pbFullyTrusted) @@ -69,8 +72,36 @@ HRESULT CordbAssembly::GetCodeBase(ULONG32 cchName, ULONG32* pcchName, WCHAR szN HRESULT CordbAssembly::GetName(ULONG32 cchName, ULONG32* pcchName, WCHAR szName[]) { - LOG((LF_CORDB, LL_INFO100000, "CorDebugAssembly - GetName - NOT IMPLEMENTED\n")); - return E_NOTIMPL; + HRESULT hr = S_OK; + EX_TRY + { + if (!m_pAssemblyName) { + LOG((LF_CORDB, LL_INFO1000000, "CordbAssembly - GetName - IMPLEMENTED\n")); + MdbgProtBuffer localbuf; + m_dbgprot_buffer_init(&localbuf, 128); + m_dbgprot_buffer_add_id(&localbuf, m_debuggerId); + int cmdId = conn->SendEvent(MDBGPROT_CMD_SET_ASSEMBLY, MDBGPROT_CMD_ASSEMBLY_GET_LOCATION, &localbuf); + m_dbgprot_buffer_free(&localbuf); + + ReceivedReplyPacket* received_reply_packet = conn->GetReplyWithError(cmdId); + CHECK_ERROR_RETURN_FALSE(received_reply_packet); + MdbgProtBuffer* pReply = received_reply_packet->Buffer(); + + m_pAssemblyName = m_dbgprot_decode_string_with_len(pReply->p, &pReply->p, pReply->end, &m_nAssemblyNameLen); + } + + if (cchName < (ULONG32) m_nAssemblyNameLen + 1) + { + *pcchName = m_nAssemblyNameLen + 1; + } + else + { + MultiByteToWideChar(CP_UTF8, 0, m_pAssemblyName, -1, szName, cchName); + *pcchName = m_nAssemblyNameLen + 1; + } + } + EX_CATCH_HRESULT(hr); + return hr; } HRESULT CordbAssembly::QueryInterface(REFIID id, _COM_Outptr_ void __RPC_FAR* __RPC_FAR* ppInterface) @@ -255,17 +286,17 @@ HRESULT CordbModule::GetName(ULONG32 cchName, ULONG32* pcchName, WCHAR szName[]) CHECK_ERROR_RETURN_FALSE(received_reply_packet); MdbgProtBuffer* pReply = received_reply_packet->Buffer(); - m_pAssemblyName = m_dbgprot_decode_string(pReply->p, &pReply->p, pReply->end); + m_pAssemblyName = m_dbgprot_decode_string_with_len(pReply->p, &pReply->p, pReply->end, &m_nAssemblyNameLen); } - if (cchName < strlen(m_pAssemblyName) + 1) + if (cchName < (ULONG32)m_nAssemblyNameLen + 1) { - *pcchName = (ULONG32)strlen(m_pAssemblyName) + 1; + *pcchName = (ULONG32)m_nAssemblyNameLen + 1; } else { MultiByteToWideChar(CP_UTF8, 0, m_pAssemblyName, -1, szName, cchName); - *pcchName = cchName; + *pcchName = (ULONG32)m_nAssemblyNameLen + 1; } } EX_CATCH_HRESULT(hr); @@ -298,17 +329,19 @@ HRESULT CordbModule::GetFunctionFromToken(mdMethodDef methodDef, ICorDebugFuncti m_dbgprot_buffer_free(&localbuf); ReceivedReplyPacket* received_reply_packet = conn->GetReplyWithError(cmdId); - CHECK_ERROR_RETURN_FALSE(received_reply_packet); - MdbgProtBuffer* pReply = received_reply_packet->Buffer(); - - int id = m_dbgprot_decode_id(pReply->p, &pReply->p, pReply->end); - CordbFunction* func = NULL; - func = m_pProcess->FindFunction(id); - if (func == NULL) + if (received_reply_packet->Error() == 0 && received_reply_packet->Error2() == 0) { - func = new CordbFunction(conn, methodDef, id, this); + MdbgProtBuffer* pReply = received_reply_packet->Buffer(); + + int id = m_dbgprot_decode_id(pReply->p, &pReply->p, pReply->end); + CordbFunction* func = NULL; + func = m_pProcess->FindFunction(id); + if (func == NULL) + { + func = new CordbFunction(conn, methodDef, id, this); + } + func->QueryInterface(IID_ICorDebugFunction, (void**)ppFunction); } - func->QueryInterface(IID_ICorDebugFunction, (void**)ppFunction); } EX_CATCH_HRESULT(hr); return hr; diff --git a/src/mono/dbi/cordb-assembly.h b/src/mono/dlls/mscordbi/cordb-assembly.h similarity index 97% rename from src/mono/dbi/cordb-assembly.h rename to src/mono/dlls/mscordbi/cordb-assembly.h index b5397bbe60e56..238decca1d25d 100644 --- a/src/mono/dbi/cordb-assembly.h +++ b/src/mono/dlls/mscordbi/cordb-assembly.h @@ -26,6 +26,7 @@ class CordbModule : public CordbBaseMono, int32_t m_nPeImageSize; unsigned long dwFlags; char * m_pAssemblyName; + int m_nAssemblyNameLen; public: CordbModule(Connection* conn, CordbProcess* process, CordbAssembly* assembly, int id_assembly); @@ -79,6 +80,8 @@ class CordbAssembly : public CordbBaseMono, public ICorDebugAssembly, public ICo CordbProcess* m_pProcess; CordbAppDomain* m_pAppDomain; int m_debuggerId; + char* m_pAssemblyName; + int m_nAssemblyNameLen; public: CordbAssembly(Connection* conn, CordbProcess* process, CordbAppDomain* appDomain, int id_assembly); diff --git a/src/mono/dbi/cordb-blocking-obj.cpp b/src/mono/dlls/mscordbi/cordb-blocking-obj.cpp similarity index 100% rename from src/mono/dbi/cordb-blocking-obj.cpp rename to src/mono/dlls/mscordbi/cordb-blocking-obj.cpp diff --git a/src/mono/dbi/cordb-blocking-obj.h b/src/mono/dlls/mscordbi/cordb-blocking-obj.h similarity index 100% rename from src/mono/dbi/cordb-blocking-obj.h rename to src/mono/dlls/mscordbi/cordb-blocking-obj.h diff --git a/src/mono/dbi/cordb-breakpoint.cpp b/src/mono/dlls/mscordbi/cordb-breakpoint.cpp similarity index 87% rename from src/mono/dbi/cordb-breakpoint.cpp rename to src/mono/dlls/mscordbi/cordb-breakpoint.cpp index 1d45b6e0fb6d3..06ae9bdc89f77 100644 --- a/src/mono/dbi/cordb-breakpoint.cpp +++ b/src/mono/dlls/mscordbi/cordb-breakpoint.cpp @@ -19,6 +19,7 @@ CordbFunctionBreakpoint::CordbFunctionBreakpoint(Connection* conn, CordbCode* co this->m_offset = offset; conn->GetProcess()->AddBreakpoint(this); m_debuggerId = -1; + m_bActive = false; } CordbFunctionBreakpoint::~CordbFunctionBreakpoint() {} @@ -38,6 +39,7 @@ HRESULT CordbFunctionBreakpoint::GetOffset(ULONG32* pnOffset) HRESULT CordbFunctionBreakpoint::Activate(BOOL bActive) { + m_bActive = bActive; if (bActive) { MdbgProtBuffer sendbuf; @@ -68,8 +70,9 @@ HRESULT CordbFunctionBreakpoint::Activate(BOOL bActive) HRESULT CordbFunctionBreakpoint::IsActive(BOOL* pbActive) { - LOG((LF_CORDB, LL_INFO100000, "CordbFunctionBreakpoint - IsActive - NOT IMPLEMENTED\n")); - return E_NOTIMPL; + LOG((LF_CORDB, LL_INFO100000, "CordbFunctionBreakpoint - IsActive - IMPLEMENTED\n")); + *pbActive = m_bActive; + return S_OK; } HRESULT CordbFunctionBreakpoint::QueryInterface(REFIID id, void** pInterface) @@ -78,11 +81,16 @@ HRESULT CordbFunctionBreakpoint::QueryInterface(REFIID id, void** pInterface) { *pInterface = static_cast(this); } + else if (id == IID_ICorDebugBreakpoint) + { + *pInterface = static_cast(this); + } + else if (id == IID_IUnknown) + *pInterface = static_cast(this); else { - // Not looking for a function breakpoint? See if the base class handles - // this interface. (issue 143976) - // return CordbBreakpoint::QueryInterface(id, pInterface); + *pInterface = NULL; + return E_NOINTERFACE; } AddRef(); return S_OK; diff --git a/src/mono/dbi/cordb-breakpoint.h b/src/mono/dlls/mscordbi/cordb-breakpoint.h similarity index 98% rename from src/mono/dbi/cordb-breakpoint.h rename to src/mono/dlls/mscordbi/cordb-breakpoint.h index ad3444551d504..5ea8af9b9de7a 100644 --- a/src/mono/dbi/cordb-breakpoint.h +++ b/src/mono/dlls/mscordbi/cordb-breakpoint.h @@ -14,6 +14,7 @@ class CordbFunctionBreakpoint : public CordbBaseMono, public ICorDebugFunctionBr CordbCode* m_pCode; ULONG32 m_offset; int m_debuggerId; + BOOL m_bActive; public: CordbFunctionBreakpoint(Connection* conn, CordbCode* code, ULONG32 offset); diff --git a/src/mono/dbi/cordb-chain.cpp b/src/mono/dlls/mscordbi/cordb-chain.cpp similarity index 100% rename from src/mono/dbi/cordb-chain.cpp rename to src/mono/dlls/mscordbi/cordb-chain.cpp diff --git a/src/mono/dbi/cordb-chain.h b/src/mono/dlls/mscordbi/cordb-chain.h similarity index 100% rename from src/mono/dbi/cordb-chain.h rename to src/mono/dlls/mscordbi/cordb-chain.h diff --git a/src/mono/dbi/cordb-class.cpp b/src/mono/dlls/mscordbi/cordb-class.cpp similarity index 58% rename from src/mono/dbi/cordb-class.cpp rename to src/mono/dlls/mscordbi/cordb-class.cpp index 61574859c11b8..1a8097176fe09 100644 --- a/src/mono/dbi/cordb-class.cpp +++ b/src/mono/dlls/mscordbi/cordb-class.cpp @@ -18,6 +18,27 @@ CordbClass::CordbClass(Connection* conn, mdToken token, int module_id) : CordbBa { this->m_metadataToken = token; this->m_debuggerModuleId = module_id; + m_debuggerId = -1; +} + +int CordbClass::GetDebuggerId() { + if (m_debuggerId != -1) + return m_debuggerId; + + MdbgProtBuffer localbuf; + m_dbgprot_buffer_init(&localbuf, 128); + m_dbgprot_buffer_add_int(&localbuf, m_debuggerModuleId); + m_dbgprot_buffer_add_int(&localbuf, m_metadataToken); + + int cmdId = conn->SendEvent(MDBGPROT_CMD_SET_ASSEMBLY, MDBGPROT_CMD_ASSEMBLY_GET_TYPE_FROM_TOKEN, &localbuf); + m_dbgprot_buffer_free(&localbuf); + + ReceivedReplyPacket* received_reply_packet = conn->GetReplyWithError(cmdId); + if (received_reply_packet->Error() > 0 || received_reply_packet->Error2() > 0) + return -1; + MdbgProtBuffer* pReply = received_reply_packet->Buffer(); + m_debuggerId = m_dbgprot_decode_int(pReply->p, &pReply->p, pReply->end); + return m_debuggerId; } HRESULT STDMETHODCALLTYPE CordbClass::GetModule(ICorDebugModule** pModule) @@ -47,8 +68,31 @@ HRESULT STDMETHODCALLTYPE CordbClass::GetStaticFieldValue(mdFieldDef field ICorDebugFrame* pFrame, ICorDebugValue** ppValue) { - LOG((LF_CORDB, LL_INFO100000, "CordbClass - GetStaticFieldValue - NOT IMPLEMENTED\n")); - return E_NOTIMPL; + GetDebuggerId(); + LOG((LF_CORDB, LL_INFO100000, "CordbClass - GetStaticFieldValue - IMPLEMENTED\n")); + HRESULT hr = S_OK; + EX_TRY + { + if (m_debuggerId == -1) + hr = S_FALSE; + else { + MdbgProtBuffer localbuf; + m_dbgprot_buffer_init(&localbuf, 128); + m_dbgprot_buffer_add_id(&localbuf, m_debuggerId); + m_dbgprot_buffer_add_int(&localbuf, fieldDef); + + int cmdId = conn->SendEvent(MDBGPROT_CMD_SET_TYPE, MDBGPROT_CMD_TYPE_GET_VALUES_ICORDBG, &localbuf); + m_dbgprot_buffer_free(&localbuf); + + ReceivedReplyPacket* received_reply_packet = conn->GetReplyWithError(cmdId); + CHECK_ERROR_RETURN_FALSE(received_reply_packet); + MdbgProtBuffer* pReply = received_reply_packet->Buffer(); + + hr = CordbObjectValue::CreateCordbValue(conn, pReply, ppValue); + } + } + EX_CATCH_HRESULT(hr); + return hr; } HRESULT STDMETHODCALLTYPE CordbClass::QueryInterface(REFIID id, void** pInterface) @@ -79,7 +123,9 @@ HRESULT STDMETHODCALLTYPE CordbClass::GetParameterizedType(CorElementType eleme ICorDebugType* ppTypeArgs[], ICorDebugType** ppType) { - LOG((LF_CORDB, LL_INFO100000, "CordbClass - GetParameterizedType - NOT IMPLEMENTED\n")); + LOG((LF_CORDB, LL_INFO100000, "CordbClass - GetParameterizedType - IMPLEMENTED\n")); + CordbType *ret = conn->GetProcess()->FindOrAddClassType(elementType, this); + ret->QueryInterface(IID_ICorDebugType, (void**)ppType); return S_OK; } diff --git a/src/mono/dbi/cordb-class.h b/src/mono/dlls/mscordbi/cordb-class.h similarity index 96% rename from src/mono/dbi/cordb-class.h rename to src/mono/dlls/mscordbi/cordb-class.h index d02daf05dabd5..73cd9b7dab4b0 100644 --- a/src/mono/dbi/cordb-class.h +++ b/src/mono/dlls/mscordbi/cordb-class.h @@ -13,9 +13,10 @@ class CordbClass : public CordbBaseMono, public ICorDebugClass, public ICorDebug { mdToken m_metadataToken; int m_debuggerModuleId; - + int m_debuggerId; public: CordbClass(Connection* conn, mdToken token, int module_id); + int GetDebuggerId(); ULONG STDMETHODCALLTYPE AddRef(void) { return (BaseAddRef()); diff --git a/src/mono/dbi/cordb-code.cpp b/src/mono/dlls/mscordbi/cordb-code.cpp similarity index 100% rename from src/mono/dbi/cordb-code.cpp rename to src/mono/dlls/mscordbi/cordb-code.cpp diff --git a/src/mono/dbi/cordb-code.h b/src/mono/dlls/mscordbi/cordb-code.h similarity index 100% rename from src/mono/dbi/cordb-code.h rename to src/mono/dlls/mscordbi/cordb-code.h diff --git a/src/mono/dbi/cordb-eval.cpp b/src/mono/dlls/mscordbi/cordb-eval.cpp similarity index 100% rename from src/mono/dbi/cordb-eval.cpp rename to src/mono/dlls/mscordbi/cordb-eval.cpp diff --git a/src/mono/dbi/cordb-eval.h b/src/mono/dlls/mscordbi/cordb-eval.h similarity index 100% rename from src/mono/dbi/cordb-eval.h rename to src/mono/dlls/mscordbi/cordb-eval.h diff --git a/src/mono/dbi/cordb-frame.cpp b/src/mono/dlls/mscordbi/cordb-frame.cpp similarity index 90% rename from src/mono/dbi/cordb-frame.cpp rename to src/mono/dlls/mscordbi/cordb-frame.cpp index 32c2a53c11ed0..c28858f0eabe8 100644 --- a/src/mono/dbi/cordb-frame.cpp +++ b/src/mono/dlls/mscordbi/cordb-frame.cpp @@ -155,8 +155,26 @@ HRESULT STDMETHODCALLTYPE CordbJITILFrame::GetFunction(ICorDebugFunction** ppFun HRESULT STDMETHODCALLTYPE CordbJITILFrame::GetFunctionToken(mdMethodDef* pToken) { - LOG((LF_CORDB, LL_INFO100000, "CordbFrame - GetFunctionToken - NOT IMPLEMENTED\n")); - return E_NOTIMPL; + LOG((LF_CORDB, LL_INFO100000, "CordbFrame - GetFunctionToken - IMPLEMENTED\n")); + HRESULT hr = S_OK; + EX_TRY + { + MdbgProtBuffer localbuf; + m_dbgprot_buffer_init(&localbuf, 128); + m_dbgprot_buffer_add_id(&localbuf, m_debuggerMethodId); + + int cmdId = conn->SendEvent(MDBGPROT_CMD_SET_METHOD, MDBGPROT_CMD_METHOD_GET_INFO, &localbuf); + m_dbgprot_buffer_free(&localbuf); + + ReceivedReplyPacket* received_reply_packet = conn->GetReplyWithError(cmdId); + CHECK_ERROR_RETURN_FALSE(received_reply_packet); + MdbgProtBuffer* pReply = received_reply_packet->Buffer(); + int flags = m_dbgprot_decode_int(pReply->p, &pReply->p, pReply->end); + int iflags = m_dbgprot_decode_int(pReply->p, &pReply->p, pReply->end); + *pToken = m_dbgprot_decode_int(pReply->p, &pReply->p, pReply->end); + } + EX_CATCH_HRESULT(hr); + return hr; } HRESULT STDMETHODCALLTYPE CordbJITILFrame::GetStackRange(CORDB_ADDRESS* pStart, CORDB_ADDRESS* pEnd) @@ -181,8 +199,8 @@ HRESULT STDMETHODCALLTYPE CordbJITILFrame::GetCallee(ICorDebugFrame** ppFrame) HRESULT STDMETHODCALLTYPE CordbJITILFrame::CreateStepper(ICorDebugStepper** ppStepper) { - LOG((LF_CORDB, LL_INFO100000, "CordbFrame - CreateStepper - NOT IMPLEMENTED\n")); - return E_NOTIMPL; + LOG((LF_CORDB, LL_INFO100000, "CordbJITILFrame - CreateStepper - IMPLEMENTED\n")); + return m_pThread->CreateStepper(ppStepper); } HRESULT STDMETHODCALLTYPE CordbJITILFrame::QueryInterface(REFIID id, _COM_Outptr_ void __RPC_FAR* __RPC_FAR* pInterface) @@ -221,7 +239,7 @@ HRESULT STDMETHODCALLTYPE CordbJITILFrame::RemapFunction(ULONG32 newILOffset) HRESULT STDMETHODCALLTYPE CordbJITILFrame::EnumerateTypeParameters(ICorDebugTypeEnum** ppTyParEnum) { LOG((LF_CORDB, LL_INFO100000, "CordbFrame - EnumerateTypeParameters - NOT IMPLEMENTED\n")); - return E_NOTIMPL; + return S_OK; } HRESULT STDMETHODCALLTYPE CordbJITILFrame::GetReturnValueForILOffset(ULONG32 ILoffset, ICorDebugValue** ppReturnValue) @@ -232,8 +250,9 @@ HRESULT STDMETHODCALLTYPE CordbJITILFrame::GetReturnValueForILOffset(ULONG32 ILo HRESULT STDMETHODCALLTYPE CordbJITILFrame::EnumerateLocalVariablesEx(ILCodeKind flags, ICorDebugValueEnum** ppValueEnum) { - LOG((LF_CORDB, LL_INFO100000, "CordbFrame - EnumerateLocalVariablesEx - NOT IMPLEMENTED\n")); - return E_NOTIMPL; + LOG((LF_CORDB, LL_INFO100000, "CordbFrame - EnumerateLocalVariablesEx - IMPLEMENTED\n")); + CordbValueEnum* pCordbValueEnum = new CordbValueEnum(conn, m_pThread->GetThreadId(), m_debuggerFrameId, false, flags); + return pCordbValueEnum->QueryInterface(IID_ICorDebugValueEnum, (void**)ppValueEnum); } HRESULT STDMETHODCALLTYPE CordbJITILFrame::GetLocalVariableEx(ILCodeKind flags, DWORD dwIndex, ICorDebugValue** ppValue) @@ -273,8 +292,9 @@ HRESULT STDMETHODCALLTYPE CordbJITILFrame::SetIP(ULONG32 nOffset) HRESULT STDMETHODCALLTYPE CordbJITILFrame::EnumerateLocalVariables(ICorDebugValueEnum** ppValueEnum) { - LOG((LF_CORDB, LL_INFO100000, "CordbFrame - EnumerateLocalVariables - NOT IMPLEMENTED\n")); - return E_NOTIMPL; + LOG((LF_CORDB, LL_INFO100000, "CordbFrame - EnumerateLocalVariables - IMPLEMENTED\n")); + CordbValueEnum *pCordbValueEnum = new CordbValueEnum(conn, m_pThread->GetThreadId(), false, m_debuggerFrameId); + return pCordbValueEnum->QueryInterface(IID_ICorDebugValueEnum, (void**)ppValueEnum); } HRESULT STDMETHODCALLTYPE CordbJITILFrame::GetLocalVariable(DWORD dwIndex, ICorDebugValue** ppValue) @@ -303,8 +323,9 @@ HRESULT STDMETHODCALLTYPE CordbJITILFrame::GetLocalVariable(DWORD dwIndex, ICorD HRESULT STDMETHODCALLTYPE CordbJITILFrame::EnumerateArguments(ICorDebugValueEnum** ppValueEnum) { - LOG((LF_CORDB, LL_INFO100000, "CordbFrame - EnumerateArguments - NOT IMPLEMENTED\n")); - return E_NOTIMPL; + LOG((LF_CORDB, LL_INFO100000, "CordbFrame - EnumerateArguments - IMPLEMENTED\n")); + CordbValueEnum* pCordbValueEnum = new CordbValueEnum(conn, m_pThread->GetThreadId(), m_debuggerFrameId, true); + return pCordbValueEnum->QueryInterface(IID_ICorDebugValueEnum, (void**)ppValueEnum); } HRESULT STDMETHODCALLTYPE CordbJITILFrame::GetArgument(DWORD dwIndex, ICorDebugValue** ppValue) @@ -458,8 +479,8 @@ HRESULT STDMETHODCALLTYPE CordbNativeFrame::GetFunction(ICorDebugFunction** ppFu HRESULT STDMETHODCALLTYPE CordbNativeFrame::GetFunctionToken(mdMethodDef* pToken) { - LOG((LF_CORDB, LL_INFO100000, "CordbNativeFrame - GetFunctionToken - NOT IMPLEMENTED\n")); - return E_NOTIMPL; + LOG((LF_CORDB, LL_INFO100000, "CordbNativeFrame - GetFunctionToken - IMPLEMENTED\n")); + return m_JITILFrame->GetFunctionToken(pToken); } HRESULT STDMETHODCALLTYPE CordbNativeFrame::GetStackRange(CORDB_ADDRESS* pStart, CORDB_ADDRESS* pEnd) @@ -481,8 +502,8 @@ HRESULT STDMETHODCALLTYPE CordbNativeFrame::GetCallee(ICorDebugFrame** ppFrame) HRESULT STDMETHODCALLTYPE CordbNativeFrame::CreateStepper(ICorDebugStepper** ppStepper) { - LOG((LF_CORDB, LL_INFO100000, "CordbNativeFrame - CreateStepper - NOT IMPLEMENTED\n")); - return E_NOTIMPL; + LOG((LF_CORDB, LL_INFO100000, "CordbNativeFrame - CreateStepper - IMPLEMENTED\n")); + return m_pThread->CreateStepper(ppStepper); } HRESULT STDMETHODCALLTYPE CordbNativeFrame::QueryInterface(REFIID id, void** pInterface) @@ -524,7 +545,7 @@ HRESULT STDMETHODCALLTYPE CordbNativeFrame::QueryInterface(REFIID id, void** pIn HRESULT STDMETHODCALLTYPE CordbNativeFrame::IsChild(BOOL* pIsChild) { LOG((LF_CORDB, LL_INFO100000, "CordbNativeFrame - IsChild - NOT IMPLEMENTED\n")); - return E_NOTIMPL; + return S_OK; } HRESULT STDMETHODCALLTYPE CordbNativeFrame::IsMatchingParentFrame(ICorDebugNativeFrame2* pPotentialParentFrame, diff --git a/src/mono/dbi/cordb-frame.h b/src/mono/dlls/mscordbi/cordb-frame.h similarity index 100% rename from src/mono/dbi/cordb-frame.h rename to src/mono/dlls/mscordbi/cordb-frame.h diff --git a/src/mono/dbi/cordb-function.cpp b/src/mono/dlls/mscordbi/cordb-function.cpp similarity index 81% rename from src/mono/dbi/cordb-function.cpp rename to src/mono/dlls/mscordbi/cordb-function.cpp index 4757db41fa9ad..61ceac25f7e13 100644 --- a/src/mono/dbi/cordb-function.cpp +++ b/src/mono/dlls/mscordbi/cordb-function.cpp @@ -8,6 +8,8 @@ #include #include #include +#include +#include #include using namespace std; @@ -99,8 +101,26 @@ HRESULT CordbFunction::GetModule(ICorDebugModule** ppModule) HRESULT CordbFunction::GetClass(ICorDebugClass** ppClass) { - LOG((LF_CORDB, LL_INFO100000, "CordbFunction - GetClass - NOT IMPLEMENTED\n")); - return E_NOTIMPL; + HRESULT hr = S_OK; + EX_TRY + { + MdbgProtBuffer localbuf; + m_dbgprot_buffer_init(&localbuf, 128); + m_dbgprot_buffer_add_id(&localbuf, m_debuggerId); + int cmdId = conn->SendEvent(MDBGPROT_CMD_SET_METHOD, MDBGPROT_CMD_METHOD_GET_CLASS_TOKEN, &localbuf); + m_dbgprot_buffer_free(&localbuf); + + ReceivedReplyPacket* received_reply_packet = conn->GetReplyWithError(cmdId); + CHECK_ERROR_RETURN_FALSE(received_reply_packet); + MdbgProtBuffer* pReply = received_reply_packet->Buffer(); + + int m_type = m_dbgprot_decode_int(pReply->p, &pReply->p, pReply->end); + CordbClass* m_pClass = conn->GetProcess()->FindOrAddClass(m_type, m_pModule->GetDebuggerId()); + hr = m_pClass->QueryInterface(IID_ICorDebugClass, (void**)ppClass); + } + EX_CATCH_HRESULT(hr); + LOG((LF_CORDB, LL_INFO100000, "CordbFunction - GetClass - IMPLEMENTED\n")); + return hr; } HRESULT CordbFunction::GetToken(mdMethodDef* pMethodDef) @@ -155,8 +175,15 @@ HRESULT CordbFunction::GetNativeCode(ICorDebugCode** ppCode) HRESULT CordbFunction::CreateBreakpoint(ICorDebugFunctionBreakpoint** ppBreakpoint) { - LOG((LF_CORDB, LL_INFO100000, "CordbFunction - CreateBreakpoint - NOT IMPLEMENTED\n")); - return E_NOTIMPL; + if (m_pCode == NULL) + { + m_pCode = new CordbCode(conn, this); + m_pCode->InternalAddRef(); + } + CordbFunctionBreakpoint* bp = new CordbFunctionBreakpoint(conn, m_pCode, 0); + bp->QueryInterface(IID_ICorDebugFunctionBreakpoint, (void**)ppBreakpoint); + LOG((LF_CORDB, LL_INFO1000000, "CordbFunction - CreateBreakpoint - IMPLEMENTED\n")); + return S_OK; } HRESULT CordbFunction::GetLocalVarSigToken(mdSignature* pmdSig) diff --git a/src/mono/dbi/cordb-function.h b/src/mono/dlls/mscordbi/cordb-function.h similarity index 100% rename from src/mono/dbi/cordb-function.h rename to src/mono/dlls/mscordbi/cordb-function.h diff --git a/src/mono/dbi/cordb-process.cpp b/src/mono/dlls/mscordbi/cordb-process.cpp similarity index 99% rename from src/mono/dbi/cordb-process.cpp rename to src/mono/dlls/mscordbi/cordb-process.cpp index 422fd02495fc0..150ac656906a0 100644 --- a/src/mono/dbi/cordb-process.cpp +++ b/src/mono/dlls/mscordbi/cordb-process.cpp @@ -531,7 +531,8 @@ HRESULT CordbProcess::HasQueuedCallbacks(ICorDebugThread* pThread, BOOL* pbQueue HRESULT CordbProcess::EnumerateThreads(ICorDebugThreadEnum** ppThreads) { - LOG((LF_CORDB, LL_INFO100000, "CordbProcess - EnumerateThreads - NOT IMPLEMENTED\n")); + *ppThreads = new CordbThreadEnum(conn); + (*ppThreads)->AddRef(); return S_OK; } diff --git a/src/mono/dbi/cordb-process.h b/src/mono/dlls/mscordbi/cordb-process.h similarity index 100% rename from src/mono/dbi/cordb-process.h rename to src/mono/dlls/mscordbi/cordb-process.h diff --git a/src/mono/dbi/cordb-register.cpp b/src/mono/dlls/mscordbi/cordb-register.cpp similarity index 76% rename from src/mono/dbi/cordb-register.cpp rename to src/mono/dlls/mscordbi/cordb-register.cpp index 78b5d43af2c79..747dc81f3fa39 100644 --- a/src/mono/dbi/cordb-register.cpp +++ b/src/mono/dlls/mscordbi/cordb-register.cpp @@ -24,8 +24,21 @@ CordbRegisterSet::CordbRegisterSet(Connection* conn, uint8_t* ctx, uint32_t ctx_ HRESULT CordbRegisterSet::QueryInterface(REFIID id, void** pInterface) { - LOG((LF_CORDB, LL_INFO100000, "CordbRegisterSet - QueryInterface - NOT IMPLEMENTED\n")); - return E_NOTIMPL; + if (id == IID_ICorDebugRegisterSet) + { + *pInterface = static_cast(static_cast(this)); + } + else if (id == IID_IUnknown) + { + *pInterface = static_cast(static_cast(this)); + } + else + { + *pInterface = NULL; + return E_NOINTERFACE; + } + AddRef(); + return S_OK; } HRESULT CordbRegisterSet::GetRegisters(ULONG64 mask, ULONG32 regCount, CORDB_REGISTER regBuffer[]) @@ -42,6 +55,8 @@ HRESULT STDMETHODCALLTYPE CordbRegisterSet::SetRegisters(ULONG64 mask, ULONG32 r HRESULT STDMETHODCALLTYPE CordbRegisterSet::GetThreadContext(ULONG32 contextSize, BYTE context[]) { + if (m_ctxLen < contextSize) + memcpy(context+POS_RAX, m_pCtx, m_ctxLen); LOG((LF_CORDB, LL_INFO100000, "CordbRegisterSet - GetThreadContext - NOT IMPLEMENTED\n")); return S_OK; } diff --git a/src/mono/dbi/cordb-register.h b/src/mono/dlls/mscordbi/cordb-register.h similarity index 100% rename from src/mono/dbi/cordb-register.h rename to src/mono/dlls/mscordbi/cordb-register.h diff --git a/src/mono/dlls/mscordbi/cordb-stackwalk.cpp b/src/mono/dlls/mscordbi/cordb-stackwalk.cpp new file mode 100644 index 0000000000000..d1658a2779b09 --- /dev/null +++ b/src/mono/dlls/mscordbi/cordb-stackwalk.cpp @@ -0,0 +1,175 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// +// File: CORDB-THREAD.CPP +// + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +CordbStackWalk::CordbStackWalk(Connection* conn, CordbThread* ppThread): CordbBaseMono(conn) +{ + m_pThread = ppThread; + m_pThread->InternalAddRef(); + m_nCurrentFrame = 0; + m_nFrames = 0; + m_ppFrames = NULL; +} + +CordbStackWalk::~CordbStackWalk() +{ + if (m_pThread) + m_pThread->InternalRelease(); + if (m_ppFrames != NULL) + { + for (int i = 0; i < m_nFrames; i++) + { + this->m_ppFrames[i]->InternalRelease(); + } + m_nFrames = 0; + free(m_ppFrames); + } +} + +void CordbStackWalk::Reset() +{ + m_nFrames = 0; + m_nCurrentFrame = 0; +} + +HRESULT STDMETHODCALLTYPE CordbStackWalk::GetContext(ULONG32 contextFlags, ULONG32 contextBufSize, ULONG32 *contextSize, BYTE contextBuf[ ]) +{ + if (m_nFrames != 0 && m_nCurrentFrame >= m_nFrames) + return S_OK; + HRESULT hr = S_OK; + EX_TRY + { + MdbgProtBuffer localbuf; + m_dbgprot_buffer_init(&localbuf, 128); + m_dbgprot_buffer_add_id(&localbuf, m_pThread->GetThreadId()); + m_dbgprot_buffer_add_int(&localbuf, m_nCurrentFrame); + + int cmdId = conn->SendEvent(MDBGPROT_CMD_SET_THREAD, MDBGPROT_CMD_THREAD_GET_CONTEXT, &localbuf); + m_dbgprot_buffer_free(&localbuf); + + ReceivedReplyPacket* received_reply_packet = conn->GetReplyWithError(cmdId); + CHECK_ERROR_RETURN_FALSE(received_reply_packet); + MdbgProtBuffer* pReply = received_reply_packet->Buffer(); + + int contextSizeReceived = 0; + uint8_t* contextMemoryReceived = m_dbgprot_decode_byte_array(pReply->p, &pReply->p, pReply->end, &contextSizeReceived); + *contextSize = contextSizeReceived; + memcpy(contextBuf+POS_RAX, contextMemoryReceived, contextSizeReceived); + free(contextMemoryReceived); + } + EX_CATCH_HRESULT(hr); + return hr; +} + +HRESULT STDMETHODCALLTYPE CordbStackWalk::SetContext(CorDebugSetContextFlag flag, ULONG32 contextSize, BYTE context[ ]) +{ + HRESULT hr = S_OK; + EX_TRY + { + MdbgProtBuffer localbuf; + m_dbgprot_buffer_init(&localbuf, 128); + m_dbgprot_buffer_add_id(&localbuf, m_pThread->GetThreadId()); + m_dbgprot_buffer_add_byte_array(&localbuf, context, contextSize); + + int cmdId = conn->SendEvent(MDBGPROT_CMD_SET_THREAD, MDBGPROT_CMD_THREAD_SET_CONTEXT, &localbuf); + m_dbgprot_buffer_free(&localbuf); + + ReceivedReplyPacket* received_reply_packet = conn->GetReplyWithError(cmdId); + CHECK_ERROR_RETURN_FALSE(received_reply_packet); + MdbgProtBuffer* pReply = received_reply_packet->Buffer(); + + m_nCurrentFrame = m_dbgprot_decode_int(pReply->p, &pReply->p, pReply->end); + } + EX_CATCH_HRESULT(hr); + return hr; +} + +HRESULT STDMETHODCALLTYPE CordbStackWalk::Next(void) +{ + PopulateStackWalk(); + if (m_nCurrentFrame + 1 >= m_nFrames) + return CORDBG_S_AT_END_OF_STACK; + m_nCurrentFrame++; + return S_OK; +} + +HRESULT CordbStackWalk::PopulateStackWalk() { + HRESULT hr = S_OK; + if (m_nFrames != 0) + return hr; + EX_TRY + { + MdbgProtBuffer localbuf; + m_dbgprot_buffer_init(&localbuf, 128); + m_dbgprot_buffer_add_id(&localbuf, m_pThread->GetThreadId()); + m_dbgprot_buffer_add_int(&localbuf, 0); + m_dbgprot_buffer_add_int(&localbuf, -1); + + int cmdId = conn->SendEvent(MDBGPROT_CMD_SET_THREAD, MDBGPROT_CMD_THREAD_GET_FRAME_INFO, &localbuf); + m_dbgprot_buffer_free(&localbuf); + + ReceivedReplyPacket* received_reply_packet = conn->GetReplyWithError(cmdId); + CHECK_ERROR_RETURN_FALSE(received_reply_packet); + MdbgProtBuffer* pReply = received_reply_packet->Buffer(); + + m_nFrames = m_dbgprot_decode_int(pReply->p, &pReply->p, pReply->end); + m_ppFrames = (CordbNativeFrame**)malloc(sizeof(CordbNativeFrame*) * m_nFrames); + + for (int i = 0; i < m_nFrames; i++) + { + int frameid = m_dbgprot_decode_int(pReply->p, &pReply->p, pReply->end); + int methodId = m_dbgprot_decode_id(pReply->p, &pReply->p, pReply->end); + int il_offset = m_dbgprot_decode_int(pReply->p, &pReply->p, pReply->end); + int flags = m_dbgprot_decode_byte(pReply->p, &pReply->p, pReply->end); + + CordbNativeFrame* frame = new CordbNativeFrame(conn, frameid, methodId, il_offset, flags, m_pThread); + frame->InternalAddRef(); + m_ppFrames[i] = frame; + } + } + EX_CATCH_HRESULT(hr); + return hr; +} + +HRESULT STDMETHODCALLTYPE CordbStackWalk::GetFrame(ICorDebugFrame **pFrame) +{ + PopulateStackWalk(); + if (m_nCurrentFrame >= m_nFrames) + return CORDBG_E_PAST_END_OF_STACK; + return this->m_ppFrames[m_nCurrentFrame]->QueryInterface(IID_ICorDebugFrame, (void**)pFrame); +} + +// standard QI function +HRESULT CordbStackWalk::QueryInterface(REFIID id, void **pInterface) +{ + if (id == IID_ICorDebugStackWalk) + { + *pInterface = static_cast(this); + } + else if (id == IID_IUnknown) + { + *pInterface = static_cast(static_cast(this)); + } + else + { + *pInterface = NULL; + return E_NOINTERFACE; + } + AddRef(); + return S_OK; +} diff --git a/src/mono/dlls/mscordbi/cordb-stackwalk.h b/src/mono/dlls/mscordbi/cordb-stackwalk.h new file mode 100644 index 0000000000000..2f23c69eeb272 --- /dev/null +++ b/src/mono/dlls/mscordbi/cordb-stackwalk.h @@ -0,0 +1,44 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// +// File: CORDB-STACKWALK.H +// + +#ifndef __MONO_DEBUGGER_CORDB_STACKWALK_H__ +#define __MONO_DEBUGGER_CORDB_STACKWALK_H__ + +#include + +class CordbStackWalk : public CordbBaseMono, + public ICorDebugStackWalk +{ + CordbThread* m_pThread; + int m_nCurrentFrame; + int m_nFrames; + CordbNativeFrame** m_ppFrames; + +public: + CordbStackWalk(Connection* conn, CordbThread* ppThread); + ~CordbStackWalk(); + HRESULT PopulateStackWalk(); + void Reset(); + HRESULT STDMETHODCALLTYPE GetContext(ULONG32 contextFlags, ULONG32 contextBufSize, ULONG32 *contextSize, BYTE contextBuf[ ]); + HRESULT STDMETHODCALLTYPE SetContext(CorDebugSetContextFlag flag, ULONG32 contextSize, BYTE context[ ]); + HRESULT STDMETHODCALLTYPE Next(void); + HRESULT STDMETHODCALLTYPE GetFrame(ICorDebugFrame **pFrame); + ULONG STDMETHODCALLTYPE AddRef(void) + { + return (BaseAddRef()); + } + ULONG STDMETHODCALLTYPE Release(void) + { + return (BaseRelease()); + } + const char* GetClassName() + { + return "CordbThread"; + } + HRESULT STDMETHODCALLTYPE QueryInterface(REFIID id, _COM_Outptr_ void __RPC_FAR* __RPC_FAR* pInterface); +}; + +#endif diff --git a/src/mono/dbi/cordb-stepper.cpp b/src/mono/dlls/mscordbi/cordb-stepper.cpp similarity index 94% rename from src/mono/dbi/cordb-stepper.cpp rename to src/mono/dlls/mscordbi/cordb-stepper.cpp index fba5d4c278a75..1a0d472360330 100644 --- a/src/mono/dbi/cordb-stepper.cpp +++ b/src/mono/dlls/mscordbi/cordb-stepper.cpp @@ -17,18 +17,23 @@ CordbStepper::CordbStepper(Connection* conn, CordbThread* thread) : CordbBaseMon m_pThread = thread; m_debuggerId = -1; conn->GetProcess()->AddStepper(this); + m_bIsActive = false; } CordbStepper::~CordbStepper() {} HRESULT STDMETHODCALLTYPE CordbStepper::IsActive(BOOL* pbActive) { - LOG((LF_CORDB, LL_INFO100000, "CordbStepper - IsActive - NOT IMPLEMENTED\n")); - return E_NOTIMPL; + *pbActive = m_bIsActive; + LOG((LF_CORDB, LL_INFO100000, "CordbStepper - IsActive - IMPLEMENTED\n")); + return S_OK; } HRESULT STDMETHODCALLTYPE CordbStepper::Deactivate(void) { + if (!m_bIsActive) + return S_OK; + m_bIsActive = false; LOG((LF_CORDB, LL_INFO1000000, "CordbStepper - Deactivate - IMPLEMENTED\n")); MdbgProtBuffer sendbuf; int buflen = 128; @@ -60,6 +65,7 @@ HRESULT STDMETHODCALLTYPE CordbStepper::Step(BOOL bStepIn) HRESULT STDMETHODCALLTYPE CordbStepper::StepRange(BOOL bStepIn, COR_DEBUG_STEP_RANGE ranges[], ULONG32 cRangeCount) { + m_bIsActive = true; LOG((LF_CORDB, LL_INFO1000000, "CordbStepper - StepRange - IMPLEMENTED\n")); HRESULT hr = S_OK; EX_TRY @@ -92,6 +98,7 @@ HRESULT STDMETHODCALLTYPE CordbStepper::StepRange(BOOL bStepIn, COR_DEBUG_STEP_R HRESULT STDMETHODCALLTYPE CordbStepper::StepOut(void) { + m_bIsActive = true; LOG((LF_CORDB, LL_INFO1000000, "CordbStepper - StepOut - IMPLEMENTED\n")); HRESULT hr = S_OK; EX_TRY @@ -123,7 +130,7 @@ HRESULT STDMETHODCALLTYPE CordbStepper::StepOut(void) HRESULT STDMETHODCALLTYPE CordbStepper::SetRangeIL(BOOL bIL) { LOG((LF_CORDB, LL_INFO100000, "CordbStepper - SetRangeIL - NOT IMPLEMENTED\n")); - return E_NOTIMPL; + return S_OK; } HRESULT STDMETHODCALLTYPE CordbStepper::QueryInterface(REFIID id, void** pInterface) diff --git a/src/mono/dbi/cordb-stepper.h b/src/mono/dlls/mscordbi/cordb-stepper.h similarity index 98% rename from src/mono/dbi/cordb-stepper.h rename to src/mono/dlls/mscordbi/cordb-stepper.h index c8d031bec52a9..3a393857a1302 100644 --- a/src/mono/dbi/cordb-stepper.h +++ b/src/mono/dlls/mscordbi/cordb-stepper.h @@ -13,6 +13,7 @@ class CordbStepper : public CordbBaseMono, public ICorDebugStepper, public ICorD { CordbThread* m_pThread; int m_debuggerId; + bool m_bIsActive; public: CordbStepper(Connection* conn, CordbThread* thread); diff --git a/src/mono/dbi/cordb-symbol.h b/src/mono/dlls/mscordbi/cordb-symbol.h similarity index 100% rename from src/mono/dbi/cordb-symbol.h rename to src/mono/dlls/mscordbi/cordb-symbol.h diff --git a/src/mono/dbi/cordb-thread.cpp b/src/mono/dlls/mscordbi/cordb-thread.cpp similarity index 76% rename from src/mono/dbi/cordb-thread.cpp rename to src/mono/dlls/mscordbi/cordb-thread.cpp index d7eccbbc3978f..ec5d8c22ebef9 100644 --- a/src/mono/dbi/cordb-thread.cpp +++ b/src/mono/dlls/mscordbi/cordb-thread.cpp @@ -13,10 +13,9 @@ #include #include #include +#include #include -using namespace std; - CordbThread::CordbThread(Connection* conn, CordbProcess* ppProcess, long thread_id) : CordbBaseMono(conn) { this->m_pProcess = ppProcess; @@ -73,8 +72,8 @@ HRESULT STDMETHODCALLTYPE CordbThread::GetCurrentCustomDebuggerNotification(ICor HRESULT STDMETHODCALLTYPE CordbThread::CreateStackWalk(ICorDebugStackWalk** ppStackWalk) { - LOG((LF_CORDB, LL_INFO100000, "CordbThread - CreateStackWalk - NOT IMPLEMENTED\n")); - return E_NOTIMPL; + ICorDebugStackWalk* stackWalk = new CordbStackWalk(conn, this); + return stackWalk->QueryInterface(IID_ICorDebugStackWalk, (void**)ppStackWalk); } HRESULT STDMETHODCALLTYPE CordbThread::GetActiveInternalFrames(ULONG32 cInternalFrames, @@ -82,7 +81,8 @@ HRESULT STDMETHODCALLTYPE CordbThread::GetActiveInternalFrames(ULONG32 ICorDebugInternalFrame2* ppInternalFrames[]) { LOG((LF_CORDB, LL_INFO100000, "CordbThread - GetActiveInternalFrames - NOT IMPLEMENTED\n")); - return E_NOTIMPL; + *pcInternalFrames = 0; + return S_OK; } HRESULT STDMETHODCALLTYPE CordbThread::GetActiveFunctions(ULONG32 cFunctions, @@ -107,8 +107,25 @@ HRESULT STDMETHODCALLTYPE CordbThread::GetTaskID(TASKID* pTaskId) HRESULT STDMETHODCALLTYPE CordbThread::GetVolatileOSThreadID(DWORD* pdwTid) { - LOG((LF_CORDB, LL_INFO100000, "CordbThread - GetVolatileOSThreadID - NOT IMPLEMENTED\n")); - return E_NOTIMPL; + LOG((LF_CORDB, LL_INFO1000000, "CordbThread - GetActiveFrame - IMPLEMENTED\n")); + HRESULT hr = S_OK; + EX_TRY + { + MdbgProtBuffer localbuf; + m_dbgprot_buffer_init(&localbuf, 128); + m_dbgprot_buffer_add_id(&localbuf, GetThreadId()); + + int cmdId = this->conn->SendEvent(MDBGPROT_CMD_SET_THREAD, MDBGPROT_CMD_THREAD_GET_TID, &localbuf); + m_dbgprot_buffer_free(&localbuf); + + ReceivedReplyPacket* received_reply_packet = conn->GetReplyWithError(cmdId); + CHECK_ERROR_RETURN_FALSE(received_reply_packet); + MdbgProtBuffer* pReply = received_reply_packet->Buffer(); + + *pdwTid = (DWORD) m_dbgprot_decode_long(pReply->p, &pReply->p, pReply->end); + } + EX_CATCH_HRESULT(hr); + return hr; } HRESULT STDMETHODCALLTYPE CordbThread::InterceptCurrentException( @@ -245,12 +262,32 @@ HRESULT STDMETHODCALLTYPE CordbThread::GetActiveFrame(ICorDebugFrame** ppFrame) HRESULT STDMETHODCALLTYPE CordbThread::GetRegisterSet(ICorDebugRegisterSet** ppRegisters) { LOG((LF_CORDB, LL_INFO1000000, "CordbThread - GetRegisterSet - IMPLEMENTED\n")); + if (m_pRegisterSet != NULL) + m_pRegisterSet->InternalRelease(); + HRESULT hr = S_OK; + EX_TRY + { + MdbgProtBuffer localbuf; + m_dbgprot_buffer_init(&localbuf, 128); + m_dbgprot_buffer_add_id(&localbuf, GetThreadId()); + m_dbgprot_buffer_add_int(&localbuf, 0); - if (!m_pRegisterSet) - SetRegisterSet(new CordbRegisterSet(conn, 0, 0)); - m_pRegisterSet->AddRef(); - *ppRegisters = static_cast(m_pRegisterSet); - return S_OK; + int cmdId = conn->SendEvent(MDBGPROT_CMD_SET_THREAD, MDBGPROT_CMD_THREAD_GET_CONTEXT, &localbuf); + m_dbgprot_buffer_free(&localbuf); + + ReceivedReplyPacket* received_reply_packet = conn->GetReplyWithError(cmdId); + CHECK_ERROR_RETURN_FALSE(received_reply_packet); + MdbgProtBuffer* pReply = received_reply_packet->Buffer(); + + int contextSizeReceived = 0; + uint8_t* contextMemoryReceived = m_dbgprot_decode_byte_array(pReply->p, &pReply->p, pReply->end, &contextSizeReceived); + m_pRegisterSet = new CordbRegisterSet(conn, contextMemoryReceived, contextSizeReceived); + m_pRegisterSet->InternalAddRef(); + } + EX_CATCH_HRESULT(hr); + + m_pRegisterSet->QueryInterface(IID_ICorDebugRegisterSet, (void**)ppRegisters); + return hr; } HRESULT STDMETHODCALLTYPE CordbThread::CreateEval(ICorDebugEval** ppEval) @@ -297,3 +334,45 @@ HRESULT STDMETHODCALLTYPE CordbThread::QueryInterface(REFIID id, _COM_Outptr_ vo AddRef(); return S_OK; } + +CordbThreadEnum::CordbThreadEnum(Connection* conn) : CordbBaseMono(conn) +{ + +} + +HRESULT STDMETHODCALLTYPE CordbThreadEnum::Next(ULONG celt, ICorDebugThread* values[], ULONG* pceltFetched) +{ + return E_NOTIMPL; +} +HRESULT STDMETHODCALLTYPE CordbThreadEnum::Skip(ULONG celt) +{ + return E_NOTIMPL; +} +HRESULT STDMETHODCALLTYPE CordbThreadEnum::Reset(void) +{ + return E_NOTIMPL; +} +HRESULT STDMETHODCALLTYPE CordbThreadEnum::Clone(ICorDebugEnum** ppEnum) +{ + return E_NOTIMPL; +} +HRESULT STDMETHODCALLTYPE CordbThreadEnum::GetCount(ULONG* pcelt) +{ + *pcelt = 0; + return S_OK; +} +HRESULT STDMETHODCALLTYPE CordbThreadEnum::QueryInterface(REFIID id, void** pInterface) +{ + if (id == IID_IUnknown) + *pInterface = static_cast(static_cast(this)); + else if (id == IID_ICorDebugThreadEnum) + *pInterface = static_cast(this); + else if (id == IID_ICorDebugEnum) + *pInterface = static_cast(this); + else + { + return E_NOINTERFACE; + } + AddRef(); + return S_OK; +} diff --git a/src/mono/dbi/cordb-thread.h b/src/mono/dlls/mscordbi/cordb-thread.h similarity index 82% rename from src/mono/dbi/cordb-thread.h rename to src/mono/dlls/mscordbi/cordb-thread.h index cb133ddc29b95..86cca50803ca7 100644 --- a/src/mono/dbi/cordb-thread.h +++ b/src/mono/dlls/mscordbi/cordb-thread.h @@ -74,4 +74,28 @@ class CordbThread : public CordbBaseMono, } }; +class CordbThreadEnum : public CordbBaseMono, public ICorDebugThreadEnum +{ +public: + CordbThreadEnum(Connection* conn); + ULONG STDMETHODCALLTYPE AddRef(void) + { + return (BaseAddRef()); + } + ULONG STDMETHODCALLTYPE Release(void) + { + return (BaseRelease()); + } + const char* GetClassName() + { + return "CordbThreadEnum"; + } + HRESULT STDMETHODCALLTYPE Next(ULONG celt, ICorDebugThread* values[], ULONG* pceltFetched); + HRESULT STDMETHODCALLTYPE Skip(ULONG celt); + HRESULT STDMETHODCALLTYPE Reset(void); + HRESULT STDMETHODCALLTYPE Clone(ICorDebugEnum** ppEnum); + HRESULT STDMETHODCALLTYPE GetCount(ULONG* pcelt); + HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject); +}; + #endif diff --git a/src/mono/dbi/cordb-type.cpp b/src/mono/dlls/mscordbi/cordb-type.cpp similarity index 95% rename from src/mono/dbi/cordb-type.cpp rename to src/mono/dlls/mscordbi/cordb-type.cpp index c0f1744494a80..4c96ea8400d5d 100644 --- a/src/mono/dbi/cordb-type.cpp +++ b/src/mono/dlls/mscordbi/cordb-type.cpp @@ -14,6 +14,8 @@ using namespace std; CordbType::CordbType(CorElementType type, Connection* conn, CordbClass* klass, CordbType* typeParameter) : CordbBaseMono(conn) { + if (type == ELEMENT_TYPE_CLASS && klass == NULL) + assert(0); this->m_pClass = klass; this->m_type = type; this->m_pTypeParameter = typeParameter; @@ -83,7 +85,9 @@ HRESULT STDMETHODCALLTYPE CordbType::GetStaticFieldValue(mdFieldDef fieldD ICorDebugFrame* pFrame, ICorDebugValue** ppValue) { - LOG((LF_CORDB, LL_INFO100000, "CordbType - GetStaticFieldValue - NOT IMPLEMENTED\n")); + if (m_pClass) { + return m_pClass->GetStaticFieldValue(fieldDef, pFrame, ppValue); + } return E_NOTIMPL; } @@ -131,9 +135,10 @@ CordbTypeEnum::~CordbTypeEnum() HRESULT STDMETHODCALLTYPE CordbTypeEnum::Next(ULONG celt, ICorDebugType* values[], ULONG* pceltFetched) { - *pceltFetched = celt; - if (m_pType != NULL) + if (m_pType != NULL) { m_pType->QueryInterface(IID_ICorDebugType, (void**)&values[0]); + *pceltFetched = celt; + } LOG((LF_CORDB, LL_INFO1000000, "CordbTypeEnum - Next - IMPLEMENTED\n")); return S_OK; } diff --git a/src/mono/dbi/cordb-type.h b/src/mono/dlls/mscordbi/cordb-type.h similarity index 100% rename from src/mono/dbi/cordb-type.h rename to src/mono/dlls/mscordbi/cordb-type.h diff --git a/src/mono/dbi/cordb-value.cpp b/src/mono/dlls/mscordbi/cordb-value.cpp similarity index 93% rename from src/mono/dbi/cordb-value.cpp rename to src/mono/dlls/mscordbi/cordb-value.cpp index 55943e53d1c71..0010ece0bd435 100644 --- a/src/mono/dbi/cordb-value.cpp +++ b/src/mono/dlls/mscordbi/cordb-value.cpp @@ -98,14 +98,16 @@ HRESULT STDMETHODCALLTYPE CordbValue::GetExactType(ICorDebugType** ppType) HRESULT STDMETHODCALLTYPE CordbValue::GetSize64(ULONG64* pSize) { - LOG((LF_CORDB, LL_INFO100000, "CordbValue - GetSize64 - NOT IMPLEMENTED\n")); - return E_NOTIMPL; + LOG((LF_CORDB, LL_INFO1000000, "CordbValue - GetSize64 - IMPLEMENTED\n")); + *pSize = m_size; + return S_OK; } HRESULT STDMETHODCALLTYPE CordbValue::GetValue(void* pTo) { LOG((LF_CORDB, LL_INFO1000000, "CordbValue - GetValue - IMPLEMENTED\n")); - memcpy(pTo, &m_value, m_size); + SIZE_T nSizeRead; + conn->GetProcess()->ReadMemory(m_value.pointerValue, m_size, (BYTE*)pTo, &nSizeRead); return S_OK; } @@ -339,6 +341,11 @@ HRESULT STDMETHODCALLTYPE CordbReferenceValue::Dereference(ICorDebugValue** ppVa { if (m_debuggerId == -1) return CORDBG_E_BAD_REFERENCE_VALUE; + if (!m_pClass) { + ICorDebugType* cordbType; + GetExactType(&cordbType); + cordbType->Release(); + } if (m_type == ELEMENT_TYPE_SZARRAY || m_type == ELEMENT_TYPE_ARRAY) { CordbArrayValue* objectValue = new CordbArrayValue(conn, m_pCordbType, m_debuggerId, m_pClass); @@ -694,7 +701,7 @@ HRESULT CordbObjectValue::CreateCordbValue(Connection* conn, MdbgProtBuffer* pRe int type_id2 = m_dbgprot_decode_id(pReply->p, &pReply->p, pReply->end); int token = m_dbgprot_decode_int(pReply->p, &pReply->p, pReply->end); - CordbClass* klass = conn->GetProcess()->FindOrAddClass(token, module_id); + CordbClass* klass = conn->GetProcess()->FindOrAddClass(token, assembly_id); CordbReferenceValue* refValue = new CordbReferenceValue(conn, type, -1, klass); refValue->QueryInterface(IID_ICorDebugValue, (void**)ppValue); free(namespace_str); @@ -1213,3 +1220,99 @@ HRESULT STDMETHODCALLTYPE CordbArrayValue::GetElementAtPosition(ULONG32 nPositio LOG((LF_CORDB, LL_INFO100000, "CordbArrayValue - GetElementAtPosition - NOT IMPLEMENTED\n")); return E_NOTIMPL; } + + +CordbValueEnum::CordbValueEnum(Connection* conn, long nThreadDebuggerId, long nFrameDebuggerId, bool bIsArgument, ILCodeKind nFlags):CordbBaseMono(conn) +{ + m_nThreadDebuggerId = nThreadDebuggerId; + m_nFrameDebuggerId = nFrameDebuggerId; + m_nCurrentValuePos = 0; + m_nCount = 0; + m_nFlags = nFlags; + m_bIsArgument = bIsArgument; + m_pValues = NULL; +} + +HRESULT STDMETHODCALLTYPE CordbValueEnum::Next(ULONG celt, ICorDebugValue* values[], ULONG* pceltFetched) +{ + LOG((LF_CORDB, LL_INFO100000, "CordbValueEnum - Next - NOT IMPLEMENTED\n")); + return E_NOTIMPL; +} + +HRESULT STDMETHODCALLTYPE CordbValueEnum::Skip(ULONG celt) +{ + LOG((LF_CORDB, LL_INFO100000, "CordbValueEnum - Skip - NOT IMPLEMENTED\n")); + return E_NOTIMPL; +} + +HRESULT STDMETHODCALLTYPE CordbValueEnum::Reset(void) +{ + LOG((LF_CORDB, LL_INFO100000, "CordbValueEnum - Reset - NOT IMPLEMENTED\n")); + return E_NOTIMPL; +} + +HRESULT STDMETHODCALLTYPE CordbValueEnum::Clone(ICorDebugEnum** ppEnum) +{ + LOG((LF_CORDB, LL_INFO100000, "CordbValueEnum - Clone - NOT IMPLEMENTED\n")); + return E_NOTIMPL; +} + +HRESULT STDMETHODCALLTYPE CordbValueEnum::GetCount(ULONG* pcelt) +{ + if (m_nFlags == ILCODE_REJIT_IL) + { + *pcelt = 0; + return S_OK; + } + if (m_bIsArgument) { + LOG((LF_CORDB, LL_INFO1000000, "CordbFrame - GetArgument - IMPLEMENTED\n")); + HRESULT hr = S_OK; + EX_TRY + { + MdbgProtBuffer localbuf; + m_dbgprot_buffer_init(&localbuf, 128); + m_dbgprot_buffer_add_id(&localbuf, m_nThreadDebuggerId); + m_dbgprot_buffer_add_id(&localbuf, m_nFrameDebuggerId); + int cmdId = conn->SendEvent(MDBGPROT_CMD_SET_STACK_FRAME, MDBGPROT_CMD_STACK_FRAME_GET_ARGUMENTS, &localbuf); + m_dbgprot_buffer_free(&localbuf); + + ReceivedReplyPacket* received_reply_packet = conn->GetReplyWithError(cmdId); + CHECK_ERROR_RETURN_FALSE(received_reply_packet); + MdbgProtBuffer* pReply = received_reply_packet->Buffer(); + m_nCount = m_dbgprot_decode_int(pReply->p, &pReply->p, pReply->end); + *pcelt = m_nCount; + m_pValues = new ICorDebugValue*[m_nCount]; + for (int i = 0; i < m_nCount; i++) + { + hr = CordbObjectValue::CreateCordbValue(conn, pReply, &m_pValues[i]); + } + } + EX_CATCH_HRESULT(hr); + return hr; + } + LOG((LF_CORDB, LL_INFO100000, "CordbValueEnum - GetCount - NOT IMPLEMENTED\n")); + return E_NOTIMPL; +} + +HRESULT STDMETHODCALLTYPE CordbValueEnum::QueryInterface(REFIID id, void** pInterface) +{ + if (id == IID_ICorDebugValueEnum) + { + *pInterface = static_cast(this); + } + else if (id == IID_ICorDebugEnum) + { + *pInterface = static_cast(this); + } + else if (id == IID_IUnknown) + { + *pInterface = static_cast(this); + } + else + { + *pInterface = NULL; + return E_NOINTERFACE; + } + AddRef(); + return S_OK; +} diff --git a/src/mono/dbi/cordb-value.h b/src/mono/dlls/mscordbi/cordb-value.h similarity index 91% rename from src/mono/dbi/cordb-value.h rename to src/mono/dlls/mscordbi/cordb-value.h index e31573c8d6e2a..fa43cc1464807 100644 --- a/src/mono/dbi/cordb-value.h +++ b/src/mono/dlls/mscordbi/cordb-value.h @@ -244,4 +244,39 @@ class CordbArrayValue : public CordbBaseMono, HRESULT STDMETHODCALLTYPE GetElement(ULONG32 cdim, ULONG32 indices[], ICorDebugValue** ppValue); HRESULT STDMETHODCALLTYPE GetElementAtPosition(ULONG32 nPosition, ICorDebugValue** ppValue); }; + +class CordbValueEnum : public CordbBaseMono, + public ICorDebugValueEnum +{ + long m_nThreadDebuggerId; + long m_nFrameDebuggerId; + int m_nCurrentValuePos; + int m_nCount; + ILCodeKind m_nFlags; + bool m_bIsArgument; + ICorDebugValue** m_pValues; +public: + ULONG STDMETHODCALLTYPE AddRef(void) + { + return (BaseAddRef()); + } + ULONG STDMETHODCALLTYPE Release(void) + { + return (BaseRelease()); + } + const char* GetClassName() + { + return "CordbValueEnum"; + } + + CordbValueEnum(Connection* conn, long nThreadDebuggerId, long nFrameDebuggerId, bool bIsArgument, ILCodeKind m_nFlags = ILCODE_ORIGINAL_IL); + HRESULT STDMETHODCALLTYPE Next(ULONG celt, ICorDebugValue* values[], ULONG* pceltFetched); + HRESULT STDMETHODCALLTYPE Skip(ULONG celt); + HRESULT STDMETHODCALLTYPE Reset(void); + HRESULT STDMETHODCALLTYPE Clone(ICorDebugEnum** ppEnum); + HRESULT STDMETHODCALLTYPE GetCount(ULONG* pcelt); + HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject); +}; + + #endif diff --git a/src/mono/dbi/cordb.cpp b/src/mono/dlls/mscordbi/cordb.cpp similarity index 95% rename from src/mono/dbi/cordb.cpp rename to src/mono/dlls/mscordbi/cordb.cpp index 0c1517900fabd..cccfb706e7039 100644 --- a/src/mono/dbi/cordb.cpp +++ b/src/mono/dlls/mscordbi/cordb.cpp @@ -17,13 +17,12 @@ #include #define DEBUG_ADDRESS "127.0.0.1" -#define DEBUG_PORT "4713" MONO_API HRESULT CoreCLRCreateCordbObjectEx( int iDebuggerVersion, DWORD pid, LPCWSTR lpApplicationGroupId, HMODULE hmodTargetCLR, void** ppCordb) { LOG((LF_CORDB, LL_INFO100000, "CoreCLRCreateCordbObjectEx\n")); - *ppCordb = new Cordb(); + *ppCordb = new Cordb(pid); return S_OK; } @@ -115,10 +114,16 @@ HRESULT Cordb::CanLaunchOrAttach(DWORD dwProcessId, BOOL win32DebuggingEnabled) return S_OK; } -Cordb::Cordb() : CordbBaseMono(NULL) +Cordb::Cordb(DWORD PID) : CordbBaseMono(NULL) { m_pCallback = NULL; m_pSemReadWrite = new UTSemReadWrite(); + m_nPID = PID; + +#ifndef TARGET_WINDOWS + PAL_InitializeDLL(); +#endif + #ifdef LOGGING InitializeLogging(); #endif @@ -135,9 +140,19 @@ Cordb::~Cordb() } HRESULT -Cordb::QueryInterface(REFIID riid, _COM_Outptr_ void __RPC_FAR* __RPC_FAR* ppvObject) +Cordb::QueryInterface(REFIID id, _COM_Outptr_ void __RPC_FAR* __RPC_FAR* pInterface) { - LOG((LF_CORDB, LL_INFO100000, "Cordb - QueryInterface - NOT IMPLEMENTED\n")); + if (id == IID_ICorDebug) + *pInterface = static_cast(this); + else if (id == IID_IUnknown) + *pInterface = static_cast(static_cast(this)); + else + { + *pInterface = NULL; + return E_NOINTERFACE; + } + + AddRef(); return S_OK; } @@ -252,7 +267,7 @@ void Connection::Receive() return; } - MdbgProtBuffer* recvbuf = new MdbgProtBuffer(); + MdbgProtBuffer* recvbuf = new MdbgProtBuffer(); m_dbgprot_buffer_init(recvbuf, header.len - HEADER_LENGTH); if (header.len - HEADER_LENGTH != 0) { @@ -391,6 +406,7 @@ void Connection::ProcessPacketInternal(MdbgProtBuffer* recvbuf) m_pCordb->GetCallback()->CreateThread(pCorDebugAppDomain, thread); } CordbStepper* stepper = GetProcess()->GetStepper(req_id); + stepper->Deactivate(); m_pCordb->GetCallback()->StepComplete(pCorDebugAppDomain, thread, stepper, STEP_NORMAL); } break; @@ -448,6 +464,7 @@ void Connection::LoopSendReceive() m_dbgprot_buffer_init(&localbuf, 128); m_dbgprot_buffer_add_int(&localbuf, MAJOR_VERSION); m_dbgprot_buffer_add_int(&localbuf, MINOR_VERSION); + m_dbgprot_buffer_add_byte(&localbuf, true); int cmdId = SendEvent(MDBGPROT_CMD_SET_VM, MDBGPROT_CMD_VM_SET_PROTOCOL_VERSION, &localbuf); m_dbgprot_buffer_free(&localbuf); @@ -466,10 +483,6 @@ void Connection::LoopSendReceive() MINOR_VERSION, major_version, minor_version)); free(vm_version); - m_dbgprot_buffer_init(&localbuf, 128); - SendEvent(MDBGPROT_CMD_SET_VM, MDBGPROT_CMD_VM_SET_USING_ICORDBG, &localbuf); - m_dbgprot_buffer_free(&localbuf); - int iResult = 0; // Receive until the peer closes the connection do @@ -501,10 +514,13 @@ void Connection::StartConnection() LOG((LF_CORDB, LL_INFO100000, "Start Connection\n")); m_socket = new Socket(); + int port = 56000 + (m_pCordb->PID() % 1000); + char* s_port = new char[10]; + sprintf_s(s_port, 10, "%d", port); + LOG((LF_CORDB, LL_INFO100000, "Listening to %s:%s\n", DEBUG_ADDRESS, s_port)); - LOG((LF_CORDB, LL_INFO100000, "Listening to %s:%s\n", DEBUG_ADDRESS, DEBUG_PORT)); - - int ret = m_socket->OpenSocketAcceptConnection(DEBUG_ADDRESS, DEBUG_PORT); + int ret = m_socket->OpenSocketAcceptConnection(DEBUG_ADDRESS, s_port); + delete[] s_port; if (ret == -1) exit(1); @@ -551,13 +567,13 @@ int Connection::SendEvent(int cmd_set, int cmd, MdbgProtBuffer* sendbuf) MONO_API HRESULT CoreCLRCreateCordbObject(int iDebuggerVersion, DWORD pid, HMODULE hmodTargetCLR, void** ppCordb) { - *ppCordb = new Cordb(); + *ppCordb = new Cordb(pid); return S_OK; } MONO_API HRESULT CreateCordbObject(int iDebuggerVersion, void** ppCordb) { - *ppCordb = new Cordb(); + *ppCordb = new Cordb(0); return S_OK; } diff --git a/src/mono/dbi/cordb.h b/src/mono/dlls/mscordbi/cordb.h similarity index 86% rename from src/mono/dbi/cordb.h rename to src/mono/dlls/mscordbi/cordb.h index 2bb47cbe7c312..384f46be33fa9 100644 --- a/src/mono/dbi/cordb.h +++ b/src/mono/dlls/mscordbi/cordb.h @@ -63,6 +63,7 @@ class CordbBlockingObjectEnum; class CordbFunctionBreakpoint; class CordbEval; class CordbType; +class CordbStackWalk; enum CordbTypeKind { CordbTypeKindSimpleType, @@ -159,13 +160,17 @@ class Cordb : public ICorDebug, public ICorDebugRemote, public CordbBaseMono { ICorDebugManagedCallback* m_pCallback; CordbProcess* m_pProcess; - + DWORD m_nPID; public: + DWORD PID() + { + return m_nPID; + } ICorDebugManagedCallback* GetCallback() const { return m_pCallback; } - Cordb(); + Cordb(DWORD pid); ULONG STDMETHODCALLTYPE AddRef(void) { return (BaseAddRef()); @@ -228,14 +233,21 @@ class Cordb : public ICorDebug, public ICorDebugRemote, public CordbBaseMono ICorDebugProcess** ppProcess); }; -#define CHECK_ERROR_RETURN_FALSE(localbuf) \ - do \ - { \ - if (localbuf->Error() > 0 || localbuf->Error2() > 0) \ - { \ - LOG((LF_CORDB, LL_INFO100000, "ERROR RECEIVED\n")); \ +#define CHECK_ERROR_RETURN_FALSE(localbuf) \ + do \ + { \ + if (localbuf->Error() > 0 || localbuf->Error2() > 0) \ + {\ + if (localbuf->Buffer()->end > localbuf->Buffer()->p) {\ + char *error_msg = m_dbgprot_decode_string(localbuf->Buffer()->p, &localbuf->Buffer()->p, localbuf->Buffer()->end); \ + LOG((LF_CORDB, LL_INFO100000, "ERROR RECEIVED - %s\n", error_msg)); \ + free(error_msg); \ + }\ + else {\ + LOG((LF_CORDB, LL_INFO100000, "ERROR RECEIVED - %d - %d\n", localbuf->Error(), localbuf->Error2())); \ + }\ EX_THROW(HRException, (E_FAIL)); \ - } \ + } \ } while (0) #endif diff --git a/src/mono/dbi/debugger-coreclr-compat.h b/src/mono/dlls/mscordbi/debugger-coreclr-compat.h similarity index 100% rename from src/mono/dbi/debugger-coreclr-compat.h rename to src/mono/dlls/mscordbi/debugger-coreclr-compat.h diff --git a/src/mono/dbi/socket-dbi/CMakeLists.txt b/src/mono/dlls/mscordbi/socket-dbi/CMakeLists.txt similarity index 100% rename from src/mono/dbi/socket-dbi/CMakeLists.txt rename to src/mono/dlls/mscordbi/socket-dbi/CMakeLists.txt diff --git a/src/mono/dbi/socket-dbi/socket.cpp b/src/mono/dlls/mscordbi/socket-dbi/socket.cpp similarity index 95% rename from src/mono/dbi/socket-dbi/socket.cpp rename to src/mono/dlls/mscordbi/socket-dbi/socket.cpp index 104a280ddf152..40ffe66d49cde 100644 --- a/src/mono/dbi/socket-dbi/socket.cpp +++ b/src/mono/dlls/mscordbi/socket-dbi/socket.cpp @@ -41,6 +41,16 @@ Socket::~Socket() int Socket::OpenSocketAcceptConnection(const char *address, const char *port) { socketId = -1; +#ifdef WIN32 + WSADATA wsadata; + int err; + + err = WSAStartup (2, &wsadata); + if (err) { + return -1; + } +#endif + struct addrinfo *result = NULL, *ptr = NULL, hints; int iResult; diff --git a/src/mono/dbi/socket-dbi/socket.h b/src/mono/dlls/mscordbi/socket-dbi/socket.h similarity index 100% rename from src/mono/dbi/socket-dbi/socket.h rename to src/mono/dlls/mscordbi/socket-dbi/socket.h diff --git a/src/mono/mono.proj b/src/mono/mono.proj index 2a296412d05dd..bf65784f99116 100644 --- a/src/mono/mono.proj +++ b/src/mono/mono.proj @@ -18,6 +18,13 @@ .exe .cmd .sh + .exe + .dll + .dylib + .dylib + .so + lib + lib \" python3 python @@ -659,6 +666,12 @@ <_MonoRuntimeArtifacts Condition="'$(TargetsBrowser)' == 'true' and '$(BuildMonoAOTCrossCompilerOnly)' != 'true'" Include="$(MonoObjDir)out\lib\libmono-profiler-aot.a"> $(RuntimeBinDir)libmono-profiler-aot.a + <_MonoICorDebugArtifacts Condition="'$(MonoMsCorDbi)' == 'true'" Include="$(MonoObjDir)out\lib\$(LibPrefix)dbgshim$(LibExt)"> + $(RuntimeBinDir)$(LibPrefix)dbgshim$(LibExt) + + <_MonoICorDebugArtifacts Condition="'$(MonoMsCorDbi)' == 'true'" Include="$(MonoObjDir)out\lib\$(LibPrefix)mscordbi$(LibExt)"> + $(RuntimeBinDir)$(LibPrefix)mscordbi$(LibExt) + <_IcuArtifacts Condition="'$(_MonoIncludeIcuFiles)' == 'true'" Include="$(_IcuLibdir)\libicuuc.a; @@ -677,6 +690,11 @@ Condition="'$(MonoGenerateOffsetsOSGroups)' == ''" SkipUnchangedFiles="true" /> + + handle->ppdb) { - res = mono_ppdb_lookup_locals (minfo); - } else { - if (!minfo->handle->symfile || !mono_debug_symfile_is_loaded (minfo->handle->symfile)) - res = NULL; - else - res = mono_debug_symfile_lookup_locals (minfo); + if (ignore_pdb) + res = mono_debug_symfile_lookup_locals (minfo); + else { + if (minfo->handle->ppdb) { + res = mono_ppdb_lookup_locals (minfo); + } else { + if (!minfo->handle->symfile || !mono_debug_symfile_is_loaded (minfo->handle->symfile)) + res = NULL; + else + res = mono_debug_symfile_lookup_locals (minfo); + } } mono_debugger_unlock (); diff --git a/src/mono/mono/metadata/mono-debug.h b/src/mono/mono/metadata/mono-debug.h index 3c888b927a3cf..4af24ca3d1a17 100644 --- a/src/mono/mono/metadata/mono-debug.h +++ b/src/mono/mono/metadata/mono-debug.h @@ -189,7 +189,7 @@ MONO_API void mono_debug_add_delegate_trampoline (void* code, int size); MONO_API MonoDebugLocalsInfo* -mono_debug_lookup_locals (MonoMethod *method); +mono_debug_lookup_locals (MonoMethod *method, mono_bool ignore_pdb); MonoDebugMethodAsyncInfo* mono_debug_lookup_method_async_debug_info (MonoMethod *method); diff --git a/src/mono/mono/mini/debugger-agent.c b/src/mono/mono/mini/debugger-agent.c index 4fe52904fa2ee..9f57bfac316c3 100644 --- a/src/mono/mono/mini/debugger-agent.c +++ b/src/mono/mono/mini/debugger-agent.c @@ -89,6 +89,14 @@ #include "mono/metadata/debug-mono-ppdb.h" #include "mono/metadata/custom-attrs-internals.h" +#ifdef HAVE_UCONTEXT_H +#include +#endif + +#ifdef HOST_WIN32 +#include +#endif + /* * On iOS we can't use System.Environment.Exit () as it will do the wrong * shutdown sequence. @@ -300,6 +308,9 @@ typedef struct { #define CHECK_PROTOCOL_VERSION(major,minor) \ (protocol_version_set && (major_version > (major) || (major_version == (major) && minor_version >= (minor)))) +#define CHECK_ICORDBG(status) \ + (protocol_version_set && using_icordbg == status) + /* * Globals */ @@ -374,6 +385,9 @@ static MonoCoopMutex debugger_thread_exited_mutex; /* The protocol version of the client */ static int major_version, minor_version; +/* If the debugger is using icordbg interface */ +static gboolean using_icordbg; + /* Whenever the variables above are set by the client */ static gboolean protocol_version_set; @@ -507,7 +521,10 @@ parse_address (char *address, char **host, int *port) memcpy (*host, address, len); (*host) [len] = '\0'; - *port = atoi (pos + 1); + if (!strcmp(pos + 1, "pid_based")) + *port = -1; + else + *port = atoi (pos + 1); return 0; } @@ -988,8 +1005,14 @@ socket_transport_connect (const char *address) port = 0; } + if (port == -1) { + port = 56000 + (mono_process_current_pid () % 1000); + } + conn_fd = -1; listen_fd = -1; + + mono_networking_init(); if (host) { int hints[] = { @@ -998,8 +1021,6 @@ socket_transport_connect (const char *address) MONO_HINT_UNSPECIFIED }; - mono_networking_init (); - for (int i = 0; i < sizeof(hints) / sizeof(int); i++) { /* Obtain address(es) matching host/port */ s = mono_get_address_info (host, port, hints[i], &result); @@ -1109,7 +1130,7 @@ socket_transport_connect (const char *address) uint32_t startTime = time(NULL); uint32_t elapsedTime; do { - PRINT_DEBUG_MSG (1, "Trying to connect.\n"); + PRINT_DEBUG_MSG (1, "Trying to connect - %d.\n", port); for (rp = result->entries; rp != NULL; rp = rp->next) { MonoSocketAddress sockaddr; socklen_t sock_len; @@ -1118,8 +1139,12 @@ socket_transport_connect (const char *address) sfd = socket (rp->family, rp->socktype, rp->protocol); - if (sfd == -1) + if (sfd == -1) { + perror("socket"); + fprintf(stderr, "socket() failed: %s\n", strerror(errno)); + PRINT_DEBUG_MSG(1, "socket() failed: %s\n", strerror(errno)); continue; + } MONO_ENTER_GC_SAFE; res = connect (sfd, &sockaddr.addr, sock_len); @@ -1358,6 +1383,7 @@ transport_handshake (void) */ major_version = MAJOR_VERSION; minor_version = MINOR_VERSION; + using_icordbg = FALSE; protocol_version_set = FALSE; #ifndef DISABLE_SOCKET_TRANSPORT @@ -4961,7 +4987,7 @@ buffer_add_value_full (Buffer *buf, MonoType *t, void *addr, MonoDomain *domain, return; } - if (agent_config.using_icordbg) { + if (CHECK_ICORDBG (TRUE)) { switch (t->type) { case MONO_TYPE_BOOLEAN: case MONO_TYPE_I1: @@ -5051,7 +5077,7 @@ buffer_add_value_full (Buffer *buf, MonoType *t, void *addr, MonoDomain *domain, buffer_add_byte (buf, m_class_get_byval_arg (obj->vtable->klass)->type); } buffer_add_objid (buf, obj); - if (agent_config.using_icordbg) + if (CHECK_ICORDBG (TRUE)) buffer_add_long (buf, (gssize) addr); } break; @@ -6561,6 +6587,8 @@ vm_commands (int command, int id, guint8 *p, guint8 *end, Buffer *buf) case CMD_VM_SET_PROTOCOL_VERSION: { major_version = decode_int (p, &p, end); minor_version = decode_int (p, &p, end); + if (p <= end) + using_icordbg = decode_byte (p, &p, end); protocol_version_set = TRUE; PRINT_DEBUG_MSG (1, "[dbg] Protocol version %d.%d, client protocol version %d.%d.\n", MAJOR_VERSION, MINOR_VERSION, major_version, minor_version); break; @@ -6884,13 +6912,10 @@ vm_commands (int command, int id, guint8 *p, guint8 *end, Buffer *buf) case MDBGPROT_CMD_VM_READ_MEMORY: { guint8* memory = (guint8*) decode_long (p, &p, end); int size = decode_int (p, &p, end); + PRINT_DEBUG_MSG(1, "MDBGPROT_CMD_VM_READ_MEMORY - [%p] - size - %d\n", memory, size); buffer_add_byte_array (buf, memory, size); break; } - case MDBGPROT_CMD_VM_SET_USING_ICORDBG: { - agent_config.using_icordbg = TRUE; - break; - } default: return ERR_NOT_IMPLEMENTED; } @@ -7492,14 +7517,19 @@ assembly_commands (int command, guint8 *p, guint8 *end, Buffer *buf) break; } case MDBGPROT_CMD_ASSEMBLY_GET_PEIMAGE_ADDRESS: { - MonoImage* image = ass->image; - if (ass->dynamic) { - return ERR_NOT_IMPLEMENTED; - } - buffer_add_long (buf, (guint64)(gsize)image->raw_data); - buffer_add_int (buf, image->raw_data_len); + MonoImage* image = ass->image; + if (ass->dynamic) { + return ERR_NOT_IMPLEMENTED; + } + + // Mdbg uses arithmetics with this pointer and RVA to get information using readmemory, + // but it doesn't work on mono, it should call mono_cli_rva_image_map to get the right offset and don't use pure RVA. + // To run the tests I changed mdbg but maybe in future we may need to find another solution + // PRINT_DEBUG_MSG(1, "MDBGPROT_CMD_ASSEMBLY_GET_PEIMAGE_ADDRESS - [%p] - %d\n", module_handle, image->raw_data_len); + buffer_add_long (buf, (gssize)image->raw_data); + buffer_add_int (buf, image->raw_data_len); break; - } + } default: return ERR_NOT_IMPLEMENTED; } @@ -7612,6 +7642,70 @@ collect_interfaces (MonoClass *klass, GHashTable *ifaces, MonoError *error) } } +static int get_static_field_value(MonoClassField* f, MonoClass* klass, MonoDomain* domain, MonoInternalThread* thread, Buffer* buf) +{ + MonoStringHandle string_handle = MONO_HANDLE_NEW(MonoString, NULL); // FIXME? Not always needed. + ERROR_DECL(error); + guint8* val; + MonoVTable* vtable; + MonoClass* k; + guint32 special_static_type; + gboolean found; + + if (!(f->type->attrs & FIELD_ATTRIBUTE_STATIC)) + return -1; + + special_static_type = mono_class_field_get_special_static_type(f); + if (special_static_type != SPECIAL_STATIC_NONE) { + if (!(thread && special_static_type == SPECIAL_STATIC_THREAD)) + return -1; + } + + /* Check that the field belongs to the object */ + found = FALSE; + for (k = klass; k; k = m_class_get_parent(k)) { + if (k == f->parent) { + found = TRUE; + break; + } + } + if (!found) + return -1; + + vtable = mono_class_vtable_checked(f->parent, error); + if (!is_ok(error)) + return -1; + + if (CHECK_ICORDBG (TRUE)) + { + void *src; + if (f->type->attrs & FIELD_ATTRIBUTE_LITERAL) { + return -1; + } + + if (f->offset == -1) { + /* Special static */ + gpointer addr = mono_special_static_field_get_offset (f, error); + mono_error_assert_ok (error); + src = mono_get_special_static_data_for_thread (thread, GPOINTER_TO_UINT (addr)); + } else { + src = (char*)mono_vtable_get_static_field_data (vtable) + f->offset; + } + buffer_add_value(buf, f->type, src, domain); + } + else + { + val = (guint8*)g_malloc(mono_class_instance_size(mono_class_from_mono_type_internal(f->type))); + mono_field_static_get_value_for_thread(thread ? thread : mono_thread_internal_current(), vtable, f, val, string_handle, error); + if (!is_ok(error)) + return -1; + + buffer_add_value(buf, f->type, val, domain); + g_free(val); + } + return 1; +} + static ErrorCode type_commands_internal (int command, MonoClass *klass, MonoDomain *domain, guint8 *p, guint8 *end, Buffer *buf) { @@ -7625,7 +7719,6 @@ type_commands_internal (int command, MonoClass *klass, MonoDomain *domain, guint int nnested; ErrorCode err; char *name; - MonoStringHandle string_handle = MONO_HANDLE_NEW (MonoString, NULL); // FIXME? Not always needed. switch (command) { case CMD_TYPE_GET_INFO: { @@ -7833,17 +7926,25 @@ type_commands_internal (int command, MonoClass *klass, MonoDomain *domain, guint goto exit; break; } + case MDBGPROT_CMD_TYPE_GET_VALUES_ICORDBG: { + MonoClass *dummy_class; + int field_token = decode_int (p, &p, end); + MonoClassField *f = mono_field_from_token_checked (m_class_get_image (klass), field_token, &dummy_class, NULL, error); + PRINT_DEBUG_MSG (1, "Getting value of field %s\n", f->name); + if (f) { + if (get_static_field_value(f, klass, domain, NULL, buf) == -1) + goto invalid_fieldid; + } + else + goto invalid_fieldid; + break; + } case CMD_TYPE_GET_VALUES: case CMD_TYPE_GET_VALUES_2: { - guint8 *val; MonoClassField *f; - MonoVTable *vtable; - MonoClass *k; int len, i; - gboolean found; MonoThread *thread_obj; MonoInternalThread *thread = NULL; - guint32 special_static_type; if (command == CMD_TYPE_GET_VALUES_2) { int objid = decode_objid (p, &p, end); @@ -7860,36 +7961,8 @@ type_commands_internal (int command, MonoClass *klass, MonoDomain *domain, guint f = decode_fieldid (p, &p, end, NULL, &err); if (err != ERR_NONE) goto exit; - - if (!(f->type->attrs & FIELD_ATTRIBUTE_STATIC)) - goto invalid_fieldid; - - special_static_type = mono_class_field_get_special_static_type (f); - if (special_static_type != SPECIAL_STATIC_NONE) { - if (!(thread && special_static_type == SPECIAL_STATIC_THREAD)) - goto invalid_fieldid; - } - - /* Check that the field belongs to the object */ - found = FALSE; - for (k = klass; k; k = m_class_get_parent (k)) { - if (k == f->parent) { - found = TRUE; - break; - } - } - if (!found) + if (get_static_field_value(f, klass, domain, thread, buf) == -1) goto invalid_fieldid; - - vtable = mono_class_vtable_checked (f->parent, error); - goto_if_nok (error, invalid_fieldid); - - val = (guint8 *)g_malloc (mono_class_instance_size (mono_class_from_mono_type_internal (f->type))); - mono_field_static_get_value_for_thread (thread ? thread : mono_thread_internal_current (), vtable, f, val, string_handle, error); - goto_if_nok (error, invalid_fieldid); - - buffer_add_value (buf, f->type, val, domain); - g_free (val); } break; } @@ -8153,6 +8226,9 @@ method_commands_internal (int command, MonoMethod *method, MonoDomain *domain, g buffer_add_string (buf, method->name); break; } + case MDBGPROT_CMD_METHOD_GET_CLASS_TOKEN: { + buffer_add_int (buf, m_class_get_type_token (method->klass)); + } case CMD_METHOD_GET_DECLARING_TYPE: { buffer_add_typeid (buf, domain, method->klass); break; @@ -8267,7 +8343,7 @@ method_commands_internal (int command, MonoMethod *method, MonoDomain *domain, g return ERR_INVALID_ARGUMENT; } - locals = mono_debug_lookup_locals (method); + locals = mono_debug_lookup_locals (method, FALSE); if (!locals) { if (CHECK_PROTOCOL_VERSION (2, 43)) { /* Scopes */ @@ -8645,6 +8721,59 @@ thread_commands (int command, guint8 *p, guint8 *end, Buffer *buf) } break; } + case MDBGPROT_CMD_THREAD_SET_CONTEXT: { + DebuggerTlsData* tls; + while (!is_suspended()) { + if (suspend_count) + wait_for_suspend(); + } + int context_size = 0; + uint8_t * contextMemoryReceived = m_dbgprot_decode_byte_array(p, &p, end, &context_size); + + mono_loader_lock(); + tls = (DebuggerTlsData*)mono_g_hash_table_lookup(thread_to_tls, thread); + mono_loader_unlock(); + if (tls == NULL) + return ERR_UNLOADED; + + compute_frame_info(thread, tls, TRUE); //the last parameter is TRUE to force that the frame info that will be send is synchronised with the debugged thread + + MonoContext ctx; + memcpy(&ctx, contextMemoryReceived+POS_RAX, sizeof(MonoContext)); + for (int i = 0; i < tls->frame_count; i++) + { + PRINT_DEBUG_MSG(1, "[dbg] Searching Context [%d] - [%p] - [%p]\n", i, MONO_CONTEXT_GET_SP(&tls->frames[i]->ctx), MONO_CONTEXT_GET_SP(&ctx)); + if (MONO_CONTEXT_GET_SP(&ctx) == MONO_CONTEXT_GET_SP(&tls->frames[i]->ctx)) { + buffer_add_int(buf, i); + break; + } + } + g_free (contextMemoryReceived); + break; + } + case MDBGPROT_CMD_THREAD_GET_CONTEXT: { + DebuggerTlsData *tls; + int start_frame; + while (!is_suspended ()) { + if (suspend_count) + wait_for_suspend (); + } + start_frame = decode_int (p, &p, end); + + mono_loader_lock (); + tls = (DebuggerTlsData *)mono_g_hash_table_lookup (thread_to_tls, thread); + mono_loader_unlock (); + if (tls == NULL) + return ERR_UNLOADED; + + compute_frame_info (thread, tls, TRUE); //the last parameter is TRUE to force that the frame info that will be send is synchronised with the debugged thread + + if (start_frame < tls->frame_count) + { + buffer_add_byte_array (buf, (uint8_t *)&tls->frames [start_frame]->ctx, sizeof(MonoContext)); + } + break; + } case CMD_THREAD_GET_FRAME_INFO: { DebuggerTlsData *tls; int i, start_frame, length; @@ -8901,6 +9030,16 @@ frame_commands (int command, guint8 *p, guint8 *end, Buffer *buf) return ERR_ABSENT_INFORMATION; switch (command) { + case MDBGPROT_CMD_STACK_FRAME_GET_ARGUMENTS: { + int i = 0; + buffer_add_int(buf, sig->hasthis ? sig->param_count + 1 : sig->param_count); + if (sig->hasthis) + cmd_stack_frame_get_this (frame, sig, buf, jit); + for (i = 0 ; i < sig->param_count; i++) { + cmd_stack_frame_get_parameter (frame, sig, i, buf, jit); + } + break; + } case CMD_STACK_FRAME_GET_ARGUMENT: { pos = decode_int (p, &p, end); if (sig->hasthis) { @@ -8910,7 +9049,6 @@ frame_commands (int command, guint8 *p, guint8 *end, Buffer *buf) pos--; } len = 1; - header = mono_method_get_header_checked (frame->actual_method, error); cmd_stack_frame_get_parameter (frame, sig, pos, buf, jit); break; } @@ -8928,7 +9066,7 @@ frame_commands (int command, guint8 *p, guint8 *end, Buffer *buf) } else { MonoDebugLocalsInfo *locals; - locals = mono_debug_lookup_locals (frame->de.method); + locals = mono_debug_lookup_locals (frame->de.method, TRUE); if (locals) { g_assert (pos < locals->num_locals); pos = locals->locals [pos].index; @@ -8982,7 +9120,7 @@ frame_commands (int command, guint8 *p, guint8 *end, Buffer *buf) } else { MonoDebugLocalsInfo *locals; - locals = mono_debug_lookup_locals (frame->de.method); + locals = mono_debug_lookup_locals (frame->de.method, TRUE); if (locals) { g_assert (pos < locals->num_locals); pos = locals->locals [pos].index; @@ -9504,7 +9642,11 @@ static const char* thread_cmds_str[] = { "GET_INFO", "GET_ID", "GET_TID", - "SET_IP" + "SET_IP", + "ELAPSED_TIME", + "GET_APPDOMAIN", + "GET_CONTEXT", + "SET_CONTEXT" }; static const char* event_cmds_str[] = { diff --git a/src/mono/mono/mini/debugger-protocol.c b/src/mono/mono/mini/debugger-protocol.c index 4495d756cf896..1402dae3d36ef 100644 --- a/src/mono/mono/mini/debugger-protocol.c +++ b/src/mono/mono/mini/debugger-protocol.c @@ -99,6 +99,28 @@ m_dbgprot_decode_string (uint8_t *buf, uint8_t **endbuf, uint8_t *limit) return s; } +char* +m_dbgprot_decode_string_with_len(uint8_t* buf, uint8_t** endbuf, uint8_t* limit, int *len) +{ + *len = m_dbgprot_decode_int(buf, &buf, limit); + char* s; + + if (*len < 0) { + *endbuf = buf; + return NULL; + } + + s = (char*)g_malloc(*len + 1); + g_assert(s); + + memcpy(s, buf, *len); + s[*len] = '\0'; + buf += *len; + *endbuf = buf; + + return s; +} + uint8_t* m_dbgprot_decode_byte_array (uint8_t *buf, uint8_t **endbuf, uint8_t *limit, int32_t *len) { diff --git a/src/mono/mono/mini/debugger-protocol.h b/src/mono/mono/mini/debugger-protocol.h index 2067874d105dc..b2c4cf454ed46 100644 --- a/src/mono/mono/mini/debugger-protocol.h +++ b/src/mono/mono/mini/debugger-protocol.h @@ -6,6 +6,13 @@ #define HEADER_LENGTH 11 #define REPLY_PACKET 0x80 +#ifdef TARGET_AMD64 +#define POS_RAX 0x78 +#else +#define POS_RAX 0 //TODO fix for other platforms +#endif + + /* * Wire Protocol definitions */ @@ -34,8 +41,7 @@ typedef enum { MDBGPROT_CMD_VM_START_BUFFERING = 14, MDBGPROT_CMD_VM_STOP_BUFFERING = 15, MDBGPROT_CMD_VM_READ_MEMORY = 16, - MDBGPROT_CMD_VM_WRITE_MEMORY = 17, - MDBGPROT_CMD_VM_SET_USING_ICORDBG = 18 + MDBGPROT_CMD_VM_WRITE_MEMORY = 17 } MdbgProtCmdVM; typedef enum { @@ -113,7 +119,9 @@ typedef enum { MDBGPROT_CMD_THREAD_GET_TID = 6, MDBGPROT_CMD_THREAD_SET_IP = 7, MDBGPROT_CMD_THREAD_ELAPSED_TIME = 8, - MDBGPROT_CMD_THREAD_GET_APPDOMAIN = 9 + MDBGPROT_CMD_THREAD_GET_APPDOMAIN = 9, + MDBGPROT_CMD_THREAD_GET_CONTEXT = 10, + MDBGPROT_CMD_THREAD_SET_CONTEXT = 11 } MdbgProtCmdThread; typedef enum { @@ -171,7 +179,8 @@ typedef enum { MDBGPROT_CMD_METHOD_GET_CATTRS = 9, MDBGPROT_CMD_METHOD_MAKE_GENERIC_METHOD = 10, MDBGPROT_CMD_METHOD_TOKEN = 11, - MDBGPROT_CMD_METHOD_ASSEMBLY = 12 + MDBGPROT_CMD_METHOD_ASSEMBLY = 12, + MDBGPROT_CMD_METHOD_GET_CLASS_TOKEN = 13 } MdbgProtCmdMethod; typedef enum { @@ -194,7 +203,8 @@ typedef enum { MDBGPROT_CMD_TYPE_GET_INTERFACE_MAP = 17, MDBGPROT_CMD_TYPE_IS_INITIALIZED = 18, MDBGPROT_CMD_TYPE_CREATE_INSTANCE = 19, - MDBGPROT_CMD_TYPE_GET_VALUE_SIZE = 20 + MDBGPROT_CMD_TYPE_GET_VALUE_SIZE = 20, + MDBGPROT_CMD_TYPE_GET_VALUES_ICORDBG = 21 } MdbgProtCmdType; typedef enum { @@ -204,6 +214,7 @@ typedef enum { MDBGPROT_CMD_STACK_FRAME_GET_DOMAIN = 4, MDBGPROT_CMD_STACK_FRAME_SET_THIS = 5, MDBGPROT_CMD_STACK_FRAME_GET_ARGUMENT = 6, + MDBGPROT_CMD_STACK_FRAME_GET_ARGUMENTS = 7 } MdbgProtCmdStackFrame; typedef enum { @@ -346,6 +357,7 @@ int m_dbgprot_decode_int (uint8_t *buf, uint8_t **endbuf, uint8_t *limit); int64_t m_dbgprot_decode_long (uint8_t *buf, uint8_t **endbuf, uint8_t *limit); int m_dbgprot_decode_id (uint8_t *buf, uint8_t **endbuf, uint8_t *limit); char* m_dbgprot_decode_string (uint8_t *buf, uint8_t **endbuf, uint8_t *limit); +char* m_dbgprot_decode_string_with_len(uint8_t* buf, uint8_t** endbuf, uint8_t* limit, int *len); uint8_t* m_dbgprot_decode_byte_array(uint8_t *buf, uint8_t **endbuf, uint8_t *limit, int32_t *len); /* diff --git a/src/mono/mono/mini/dwarfwriter.c b/src/mono/mono/mini/dwarfwriter.c index d23074199bc65..1bac0d946391e 100644 --- a/src/mono/mono/mini/dwarfwriter.c +++ b/src/mono/mono/mini/dwarfwriter.c @@ -1899,7 +1899,7 @@ mono_dwarf_writer_emit_method (MonoDwarfWriter *w, MonoCompile *cfg, MonoMethod g_free (names); /* Locals */ - locals_info = mono_debug_lookup_locals (method); + locals_info = mono_debug_lookup_locals (method, FALSE); for (i = 0; i < header->num_locals; ++i) { MonoInst *ins = locals [i];