pax_global_header00006660000000000000000000000064145770167300014524gustar00rootroot0000000000000052 comment=e4512506fd211493864c4187fb52ff1384af8f5e netcoredbg-3.1.0-1031/000077500000000000000000000000001457701673000142235ustar00rootroot00000000000000netcoredbg-3.1.0-1031/.ahub/000077500000000000000000000000001457701673000152205ustar00rootroot00000000000000netcoredbg-3.1.0-1031/.ahub/sam/000077500000000000000000000000001457701673000160005ustar00rootroot00000000000000netcoredbg-3.1.0-1031/.ahub/sam/exclude.txt000066400000000000000000000000301457701673000201630ustar00rootroot00000000000000/netcoredbg/third_party/netcoredbg-3.1.0-1031/.github/000077500000000000000000000000001457701673000155635ustar00rootroot00000000000000netcoredbg-3.1.0-1031/.github/pull_request_template.md000066400000000000000000000000241457701673000225200ustar00rootroot00000000000000Fixes # AHub link: netcoredbg-3.1.0-1031/.gitignore000066400000000000000000000011171457701673000162130ustar00rootroot00000000000000# Proposed build directory according to README /build/ # Visual Studio Code /.vscode/ # Visual Studio (directories) .vs # Qt Creator files CMakeLists.txt.user *.config *.creator *.files *.includes *.autosave # Build artifacts *.o *.so *.a *.dll *.pdb bin/ obj/ # .NET and CoreCLR downloaded by build system /.dotnet/ /.coreclr/ # cross-build related files /.tools/ # GDB-related .gdb_history # Vim swap files .*.sw? .sw? # miscellaneous backup files *~ # core dumps core core.* # ctags index (used to navigate in source code) tags # netcoregdb's command history .netcoredbg_hist netcoredbg-3.1.0-1031/AUTHORS000066400000000000000000000012071457701673000152730ustar00rootroot00000000000000Maintainers: Mikhail Kurinnoi (@viewizard) Alexander Soldatov (@alpencolt) Members: Gleb Balykov (@gbalykov) Oleg Lekarev (@o-lek) Alexander Shaurtaev (@ethe1erd) Contributors: Alexander Aksenov Mikhail Aksenov (@makxenov) Vladislav Andresov Petr Bred Jane Doe (@github-jane-doe) Kirill Frolov (@kfrolov) Mickael Istria (@mickaelistria) Yusuke Ito (@itn3000) Dmitry Kovalenko Igor Kulaychuk (@ayuckhulk) Hyungju Lee (@HJLeee) Andrey Okoshkin (@okodron) Pavel Orekhov (@pavel-orekhov) João Silva (@jamsilva) Anton Zhukov netcoredbg-3.1.0-1031/CMakeLists.txt000066400000000000000000000070551457701673000167720ustar00rootroot00000000000000cmake_minimum_required(VERSION 2.8.12.2) if (BUILD_TESTING) enable_testing() endif() project(netcoredbg) set(CORECLR_DIR "" CACHE FILEPATH "Path to CoreCLR source directory") set(DOTNET_DIR "" CACHE FILEPATH "Path to .NET SDK directory") set(CORECLR_BRANCH "release/8.0" CACHE STRING "CoreCLR source branch") # After move of dbgshim from runtime to diagnostics, this sdk is used only for build of managed part. set(DOTNET_CHANNEL "8.0" CACHE STRING ".NET SDK channel") set(BUILD_MANAGED ON CACHE BOOL "Build managed part") set(DBGSHIM_DIR "" CACHE FILEPATH "Path to dbgshim library directory") function(clr_unknown_arch) message(FATAL_ERROR "Only AMD64, ARM64, ARM, ARMEL, I386 and WASM are supported") endfunction() if (WIN32) # For windows it is expected that CLR_CMAKE_HOST_ARCH parameter is passed # to CMAKE to determine build arch. # If it is not passed, detect arch here. if ("${CLR_CMAKE_HOST_ARCH}" STREQUAL "") if ("${CMAKE_SIZEOF_VOID_P}" STREQUAL "4") set(CLR_CMAKE_HOST_ARCH x86) else() set(CLR_CMAKE_HOST_ARCH x64) endif() endif() endif() # Follow order as in root CoreCLR CMakeLists.txt include(detectplatform.cmake) # from root include(platformdefinitions.cmake) # from root include(compileoptions.cmake) # disabled setting arm compiler flags in Tizen build include(clrdefinitions.cmake) include(fetchdeps.cmake) set(CORECLR_SRC_DIR "${CORECLR_DIR}/src") set(VERSION_PROPS_PATH "${CORECLR_DIR}/eng/Versions.props") if (NOT EXISTS "${CORECLR_SRC_DIR}/pal") set(CORECLR_SRC_DIR "${CORECLR_DIR}") set(VERSION_PROPS_PATH "${CORECLR_DIR}/../../eng/Versions.props") endif() if (WIN32) execute_process( COMMAND powershell -Command "Select-Xml -Path ${VERSION_PROPS_PATH} -XPath '/Project/PropertyGroup/ProductVersion' | ForEach-Object { $_.Node.InnerXML }" WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} OUTPUT_VARIABLE CORECLR_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_VARIABLE errout RESULT_VARIABLE retcode) else() execute_process( COMMAND bash -c "grep ProductVersion ${VERSION_PROPS_PATH} | sed 's,,,'" WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} OUTPUT_VARIABLE CORECLR_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_VARIABLE errout RESULT_VARIABLE retcode) endif() if (NOT "${retcode}" STREQUAL "0" OR "${CORECLR_VERSION}" STREQUAL "") # For some version of runtime Versions.props file doesn't exist set(CORECLR_VERSION "unknown") endif() message("Building with ${CORECLR_VERSION} CoreCLR") # Basic checks for valid paths if (NOT IS_DIRECTORY "${CORECLR_SRC_DIR}/pal") message(FATAL_ERROR "Invalid CoreCLR source directory") endif() if (NOT "${DOTNET_DIR}" STREQUAL "") if (NOT IS_DIRECTORY "${DOTNET_DIR}/shared/Microsoft.NETCore.App") message(FATAL_ERROR "Invalid .NET SDK directory") endif() endif() # Determine version, VERSION macro might be passed via command line. include(rpmbuild.cmake) if("${VERSION}x" STREQUAL "x") # If not -- find *.spec file name (perhaps netcoredbg.spec) and extract version RPMVersion(VERSION) endif() # Get references to VCS revision for Netcoredbg itself and CoreCLR # (this used in src/debug/netcoredbg/CMakeLists.txt) include(vcsinfo.cmake) VCSInfo(NETCOREDBG_VCS_INFO) VCSInfo(CORECLR_VCS_INFO ${CORECLR_DIR}) add_subdirectory(third_party/linenoise-ng) if (INTEROP_DEBUGGING) add_subdirectory(third_party/libelfin) endif (INTEROP_DEBUGGING) add_subdirectory(src) netcoredbg-3.1.0-1031/Directory.Build.props000066400000000000000000000005451457701673000203160ustar00rootroot00000000000000 obj_netcoredbg obj_corguids netcoredbg-3.1.0-1031/LICENSE000066400000000000000000000020751457701673000152340ustar00rootroot00000000000000MIT License Copyright (c) 2017 Samsung Electronics Co., LTD Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. netcoredbg-3.1.0-1031/README.md000066400000000000000000000272011457701673000155040ustar00rootroot00000000000000# Debugger for .NET Core runtime The debugger provides [GDB/MI](https://sourceware.org/gdb/onlinedocs/gdb/GDB_002fMI.html) and [VSCode Debug Adapter Protocol](https://microsoft.github.io/debug-adapter-protocol/) and allows to debug .NET apps under .NET Core runtime. Also debugger allows debugging from command line (like as GDB). ## Copyright You can find licensing information in file [LICENSE](LICENSE), in root directory of Netcoredbg sources. ## Usage More details about usage of NCDB you can find in [CLI](docs/cli.md) manual. ## Building from source code Currently Netcoredbg can be built on Linux, MacOS or Windows. Instructions for building Netcoredbg on each platform is shown below. ### Unix Building of Netcoredbg requires Microsoft's .NET, so currently you can build Netcoredbg only in Linux. Microsoft supports at least few distributions, see details here: https://docs.microsoft.com/en-us/dotnet/core/install/linux #### Prerequisites 1. You need to install `cmake`, and `make` or `ninja`. 2. You need clang C++ compiler installed (Netcoredbg can't be built with gcc). 3. Microsoft's **.NET runtime** should be installed, you can download it here: https://dotnet.microsoft.com/download 4. May be you need to install some typical developers tools not mentioned here, like `git`, etc... 5. It is expected, that Netcoredbg sources placed to some directory; 6. Optional step: Netcoredbg requires **CoreCLR runtime source code**, which is typically downloaded automatically, but you can download it from here: https://github.com/dotnet/runtime For example, you can check out tag v8.x. 7. Optional step: Netcoredbg requires **.NET SDK**, which can be downloaded automatically, but you can download it manually from here: https://dotnet.microsoft.com/download #### Compiling Configure build with the following commands: ``` user@netcoredbg$ mkdir build user@netcoredbg$ cd build user@build$ CC=clang CXX=clang++ cmake .. ``` For running tests after build has succeed you need to add option `-DCMAKE_INSTALL_PREFIX=$PWD/../bin`. To enable the Source-based code coverage feature (https://clang.llvm.org/docs/SourceBasedCodeCoverage.html) add `-DCLR_CMAKE_ENABLE_CODE_COVERAGE` option. If you have previously downloaded .NET SDK or CoreCLR sources, then you should modify command line and add following options: `-DDOTNET_DIR=/path/to/sdk/dir -DCORECLR_DIR=/path/to/coreclr/sources` If cmake tries to download .NET SDK or CoreCLR sources and fails -- see bullets 6 and 7 above. You can download required files manually. After configuration has finished, you can build Netcoredbg: ``` user@netcoredbg$ make ... user@netcoredbg$ make install ``` To perform build from scratch (including configuration step) again you should delete artefacts with following commands: ``` user@build$ cd .. user@netcoredbg$ rm -rf build src/debug/netcoredbg/bin bin ``` > *Directory `bin` contains "installed" Netcoredbg's binaries for tests. If you have installed Netcoredbg in other place, for example in `/usr/local/bin`, you should remove it manually: currently Netcoredbg's build system doesn't performs "uninstalling".* #### Prerequisites and compiling with interop mode support (Linux and Tizen OSes only) Prerequisites and compiling process are the same as above with following changes: 1. You need to install `libunwind-dev` or `libunwind-devel` package, depends on your distro. 2. Configure build with the following commands: ``` user@build$ CC=clang CXX=clang++ cmake .. -DINTEROP_DEBUGGING=1 ``` More details about usage of NCDB you can find in [Interop mode](docs/interop.md). ### MacOS You need install homebrew from here: https://brew.sh/ After this, build instructions are same as for Unix (including prerequisites). **Note: MacOS arm64 build (M1) is community supported and may not work as expected, plus some tests might fail.** ### Windows #### Prerequisites: 1. Download and install **CMake** from here: https://cmake.org/download 2. Download and install **Microsoft's Visual Studio 2019** or newer: https://visualstudio.microsoft.com/downloads During installation of Visual Studio you should install all options required for C# and C++ development on windows. 3. Download and install **Git**, you have few options here: * use original Git: https://git-scm.com/download/win * use TortoiseGit: https://tortoisegit.org/download * or use git installed in cygwin: https://cygwin.com/install.html 4. Checkout Netcoredbg sources to some directory by using git. 5. This step might be omitted, in this case cmake automatically downloads necessary files. But if it fails, you should then checkout **CoreCLR sources** to another directory from here: https://github.com/dotnet/runtime For example, you can use latest tag **v8.x**. 6. This step might be omitted too, and cmake will automatically downloads that it needs. But in case of failure you need download and install **.NET SDK** from here: https://dotnet.microsoft.com/download #### Compiling Configure the build with the following commands given in Netcoredbg's source tree: ``` C:\Users\localuser\netcoredbg> md build C:\Users\localuser\netcoredbg> cd build C:\Users\localuser\netcoredbg\build> cmake .. -G "Visual Studio 16 2019" ``` You should run this command from cmd.exe, *not from cygwin's shell*. Option `-G` specifies which instance of Visual Studio should build the project. Note, minimum requirements for netcoredbg build is `Visual Studio 2019` version. If you want to run tests after build succeed, you should add following option: `-DCMAKE_INSTALL_PREFIX="%cd%\..\bin"` If you have downloaded .NET SDK or .NET Core sources manually, you should add following options: `-DDOTNET_DIR="c:\Program Files\dotnet" -DCORECLR_DIR="path\to\coreclr"` To compile and install give command: ``` C:\Users\localuser\netcoredbg\build> cmake --build . --target install ``` To perform build from scratch (including configuration step) again you should delete artefacts with following commands: ``` C:\Users\localuser\netcoredbg\build>cd .. C:\Users\localuser\netcoredbg>rmdir /s /q build src\debug\netcoredbg\bin bin ``` > *Directory `bin` contains "installed" Netcoredbg's binaries for tests. If you have installed Netcoredbg in other place, you should remove it manually: currently Netcoredbg's build system doesn't performs "uninstalling".* ## Running Netcoredbg In instructions shown above `netcoredbg` binary and additional libraries will be installed in some directory. For developing purposes (for running tests, debugging, etc...) directory `bin` in Netcoredbg's source tree is typically used. Now running the debugger with `--help` option should look like this: ``` $ ../bin/netcoredbg --help .NET Core debugger Options: --buildinfo Print build info. --attach Attach the debugger to the specified process id. --interpreter=cli Runs the debugger with Command Line Interface. --interpreter=mi Puts the debugger into MI mode. --interpreter=vscode Puts the debugger into VS Code Debugger mode. --command= Interpret commands file at the start. -ex "" Execute command at the start --run Run program without waiting commands --engineLogging[=] Enable logging to VsDbg-UI or file for the engine. Only supported by the VsCode interpreter. --server[=port_num] Start the debugger listening for requests on the specified TCP/IP port instead of stdin/out. If port is not specified TCP 4711 will be used. --log[=] Enable logging. Supported logging to file and to dlog (only for Tizen) File log by default. File is created in 'current' folder. --version Displays the current version. ``` Basically, to debug .NET code you should run Netcoredbg with the following command line: ``` $ /path/to/netcoredbg --interpreter=TYPE -- /path/to/dotnet /path/to/program.dll ``` ## Notes for developers ### Running the tests You can find detailed instruction how to run tests in `test-suite` directory, see [test-suite/README.md](test-suite/README.md). Basically you just need to build and install Netcoredbg into `bin` directory (in Netcoredbg source tree) and then change directory to `test-suite` and run script `/run_tests.sh` If you wish to get "Source-based code coverage" report, you can add an -c or --coverage option to the command line, i.e.: `./run_tests.sh -c [[testname1][testname2]..]` Note, for that case your build configuration should be done with `-DCLR_CMAKE_ENABLE_CODE_COVERAGE` option (see above). This feature is currently supported on Unix-like platforms only. ### Building and running unit tests To build unit tests you need to add following option to CMake: `-DBUILD_TESTING=ON`. After the build, you can run unit tests by the command: `make test`. See details in [src/unittests/README.md](src/unittests/README.md). ### Enabling logs On Tizen platform Netcoredbg will send logs to the system logger. On other platforms you should specify the file to which logs will be written. This can be done by setting environment variable, example: ``` export LOG_OUTPUT=/tmp/log.txt ``` Each line of the log lines has same format which is described below: ``` 5280715.183 D/NETCOREDBG(P12036, T12036): cliprotocol.cpp: evalCommands(1309) > evaluating: 'source file.txt' ^ ^ ^ ^ ^ ^ ^ ^ ^ | | | | | | | | `-- Message itself. | | | | | | | | | | | | | | | `-- Source line number. | | | | | | | | | | | | | `-- This is function name. | | | | | | | | | | | `-- This is file name in which logging is performed. | | | | | | | | | `-- This is thread ID. | | | | | | | `-- This is process PID | | | | | `-- This program name (always NETCOREDBG). | | | `-- This is log level: E is for error, W is for warnings, D is for debug... | `--- This is time in seconds from the boot time (might be wrapped around). ``` ### Selecting between Debug and Release builds You can select build type by providing one of the following options for CMake: * ` -DCMAKE_BUILD_TYPE=Debug ` for debug build (no optimizations, suitable for debugging); * ` -DCMAKE_BUILD_TYPE=Release ` for release builds (optimized, hard to debug). By default build system create release builds. ### Using address sanitizer Example: ``` CC=clang-10 CXX=clang++-10 cmake .. -DCMAKE_INSTALL_PREFIX=$PWD/../bin -DCMAKE_BUILD_TYPE=Debug -DCORECLR_DIR=/path/to/coreclr -DDOTNET_DIR=/usr/share/dotnet -DASAN=1 ``` ### Using clang-tidy Install clang-10. To use clang-tidy modify command used to configure the build: ``` CC=clang-10 CXX=clang++-10 cmake .. . -DCMAKE_CXX_CLANG_TIDY=clang-tidy-10 -DCMAKE_INSTALL_PREFIX=$PWD/../bin ``` Then just run `make`. All errors will be printed to stderr. See details here: https://blog.kitware.com/static-checks-with-cmake-cdash-iwyu-clang-tidy-lwyu-cpplint-and-cppcheck/ Note: clang-analyzer (scan-build), cpplint, cppcheck, iwyu -- these tools currently will not work with Netcoredbg sources due to miscellaneous problems. netcoredbg-3.1.0-1031/clrdefinitions.cmake000066400000000000000000000215011457701673000202400ustar00rootroot00000000000000include(clrfeatures.cmake) # If set, indicates that this is not an officially supported release # Keep in sync with IsPrerelease in dir.props set(PRERELEASE 1) # Features we're currently flighting, but don't intend to ship in officially supported releases if (PRERELEASE) add_definitions(-DFEATURE_DEFAULT_INTERFACES=1) endif (PRERELEASE) if (CLR_CMAKE_TARGET_ARCH_AMD64) if (CLR_CMAKE_PLATFORM_UNIX) add_definitions(-DDBG_TARGET_AMD64_UNIX) endif() add_definitions(-D_TARGET_AMD64_=1) add_definitions(-D_TARGET_64BIT_=1) add_definitions(-DDBG_TARGET_64BIT=1) add_definitions(-DDBG_TARGET_AMD64=1) add_definitions(-DDBG_TARGET_WIN64=1) elseif (CLR_CMAKE_TARGET_ARCH_ARM64) if (CLR_CMAKE_PLATFORM_UNIX) add_definitions(-DDBG_TARGET_ARM64_UNIX) endif() add_definitions(-D_TARGET_ARM64_=1) add_definitions(-D_TARGET_64BIT_=1) add_definitions(-DDBG_TARGET_64BIT=1) add_definitions(-DDBG_TARGET_ARM64=1) add_definitions(-DDBG_TARGET_WIN64=1) add_definitions(-DFEATURE_MULTIREG_RETURN) elseif (CLR_CMAKE_TARGET_ARCH_ARM) if (CLR_CMAKE_PLATFORM_UNIX) add_definitions(-DDBG_TARGET_ARM_UNIX) elseif (WIN32 AND NOT DEFINED CLR_CROSS_COMPONENTS_BUILD) # Set this to ensure we can use Arm SDK for Desktop binary linkage when doing native (Arm32) build add_definitions(-D_ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE=1) add_definitions(-D_ARM_WORKAROUND_) endif (CLR_CMAKE_PLATFORM_UNIX) add_definitions(-D_TARGET_ARM_=1) add_definitions(-DDBG_TARGET_32BIT=1) add_definitions(-DDBG_TARGET_ARM=1) elseif (CLR_CMAKE_TARGET_ARCH_I386) add_definitions(-D_TARGET_X86_=1) add_definitions(-DDBG_TARGET_32BIT=1) add_definitions(-DDBG_TARGET_X86=1) elseif (CLR_CMAKE_TARGET_ARCH_RISCV64) if (CLR_CMAKE_PLATFORM_UNIX) add_definitions(-DDBG_TARGET_RISCV64_UNIX) endif() add_definitions(-D_TARGET_RISCV64_=1) add_definitions(-D_TARGET_64BIT_=1) add_definitions(-DDBG_TARGET_64BIT=1) add_definitions(-DDBG_TARGET_RISCV64=1) add_definitions(-DDBG_TARGET_WIN64=1) add_definitions(-DFEATURE_MULTIREG_RETURN) else () clr_unknown_arch() endif (CLR_CMAKE_TARGET_ARCH_AMD64) if (CLR_CMAKE_PLATFORM_UNIX) if(CLR_CMAKE_PLATFORM_DARWIN) add_definitions(-D_XOPEN_SOURCE) add_definitions(-DFEATURE_DATATARGET4) endif(CLR_CMAKE_PLATFORM_DARWIN) if (CLR_CMAKE_TARGET_ARCH_AMD64) add_definitions(-DUNIX_AMD64_ABI) elseif (CLR_CMAKE_TARGET_ARCH_ARM) add_definitions(-DUNIX_ARM_ABI) add_definitions(-DFEATURE_DATATARGET4) elseif (CLR_CMAKE_TARGET_ARCH_I386) add_definitions(-DUNIX_X86_ABI) endif() endif(CLR_CMAKE_PLATFORM_UNIX) if(CLR_CMAKE_PLATFORM_ALPINE_LINUX) # Alpine Linux doesn't have fixed stack limit, this define disables some stack pointer # sanity checks in debug / checked build that rely on a fixed stack limit add_definitions(-DNO_FIXED_STACK_LIMIT) endif(CLR_CMAKE_PLATFORM_ALPINE_LINUX) add_definitions(-D_BLD_CLR) add_definitions(-DDEBUGGING_SUPPORTED) add_definitions(-DPROFILING_SUPPORTED) if(WIN32) add_definitions(-DWIN32) add_definitions(-D_WIN32) add_definitions(-DWINVER=0x0602) add_definitions(-D_WIN32_WINNT=0x0602) add_definitions(-DWIN32_LEAN_AND_MEAN=1) add_definitions(-D_CRT_SECURE_NO_WARNINGS) add_definitions(-DHOST_WINDOWS) if(CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_I386) # Only enable edit and continue on windows x86 and x64 # exclude Linux, arm & arm64 add_definitions(-DEnC_SUPPORTED) endif(CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_I386) endif(WIN32) # Features - please keep them alphabetically sorted if (FEATURE_APPDOMAIN_RESOURCE_MONITORING) add_definitions(-DFEATURE_APPDOMAIN_RESOURCE_MONITORING) endif(FEATURE_APPDOMAIN_RESOURCE_MONITORING) if(WIN32) add_definitions(-DFEATURE_APPX) if(NOT CLR_CMAKE_TARGET_ARCH_I386) add_definitions(-DFEATURE_ARRAYSTUB_AS_IL) add_definitions(-DFEATURE_MULTICASTSTUB_AS_IL) endif() else(WIN32) add_definitions(-DFEATURE_ARRAYSTUB_AS_IL) add_definitions(-DFEATURE_MULTICASTSTUB_AS_IL) endif(WIN32) add_definitions(-DFEATURE_CODE_VERSIONING) add_definitions(-DFEATURE_COLLECTIBLE_TYPES) if(WIN32) add_definitions(-DFEATURE_CLASSIC_COMINTEROP) add_definitions(-DFEATURE_COMINTEROP) add_definitions(-DFEATURE_COMINTEROP_APARTMENT_SUPPORT) add_definitions(-DFEATURE_COMINTEROP_UNMANAGED_ACTIVATION) add_definitions(-DFEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION) endif(WIN32) add_definitions(-DFEATURE_CORECLR) if (CLR_CMAKE_PLATFORM_UNIX) add_definitions(-DFEATURE_COREFX_GLOBALIZATION) endif(CLR_CMAKE_PLATFORM_UNIX) add_definitions(-DFEATURE_CORESYSTEM) add_definitions(-DFEATURE_CORRUPTING_EXCEPTIONS) if(FEATURE_DBGIPC) add_definitions(-DFEATURE_DBGIPC_TRANSPORT_DI) add_definitions(-DFEATURE_DBGIPC_TRANSPORT_VM) endif(FEATURE_DBGIPC) if(FEATURE_EVENT_TRACE) add_definitions(-DFEATURE_EVENT_TRACE=1) add_definitions(-DFEATURE_PERFTRACING=1) endif(FEATURE_EVENT_TRACE) if(FEATURE_GDBJIT) add_definitions(-DFEATURE_GDBJIT) endif() if(FEATURE_GDBJIT_FRAME) add_definitions(-DFEATURE_GDBJIT_FRAME) endif(FEATURE_GDBJIT_FRAME) if(FEATURE_GDBJIT_LANGID_CS) add_definitions(-DFEATURE_GDBJIT_LANGID_CS) endif(FEATURE_GDBJIT_LANGID_CS) if(FEATURE_GDBJIT_SYMTAB) add_definitions(-DFEATURE_GDBJIT_SYMTAB) endif(FEATURE_GDBJIT_SYMTAB) if(CLR_CMAKE_PLATFORM_UNIX) add_definitions(-DFEATURE_EVENTSOURCE_XPLAT=1) endif(CLR_CMAKE_PLATFORM_UNIX) # NetBSD doesn't implement this feature if(NOT CMAKE_SYSTEM_NAME STREQUAL NetBSD) add_definitions(-DFEATURE_HIJACK) endif(NOT CMAKE_SYSTEM_NAME STREQUAL NetBSD) add_definitions(-DFEATURE_ICASTABLE) if (WIN32 AND (CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_I386 OR CLR_CMAKE_TARGET_ARCH_ARM64)) add_definitions(-DFEATURE_INTEROP_DEBUGGING) endif (WIN32 AND (CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_I386 OR CLR_CMAKE_TARGET_ARCH_ARM64)) if(FEATURE_INTERPRETER) add_definitions(-DFEATURE_INTERPRETER) endif(FEATURE_INTERPRETER) add_definitions(-DFEATURE_ISYM_READER) if(CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_I386) add_definitions(-DFEATURE_JUMPSTAMP) endif(CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_I386) add_definitions(-DFEATURE_LOADER_OPTIMIZATION) if (CLR_CMAKE_PLATFORM_LINUX OR WIN32) add_definitions(-DFEATURE_MANAGED_ETW) endif(CLR_CMAKE_PLATFORM_LINUX OR WIN32) add_definitions(-DFEATURE_MANAGED_ETW_CHANNELS) if(FEATURE_MERGE_JIT_AND_ENGINE) add_definitions(-DFEATURE_MERGE_JIT_AND_ENGINE) endif(FEATURE_MERGE_JIT_AND_ENGINE) add_definitions(-DFEATURE_MULTICOREJIT) if (FEATURE_NI_BIND_FALLBACK) add_definitions(-DFEATURE_NI_BIND_FALLBACK) endif(FEATURE_NI_BIND_FALLBACK) if(CLR_CMAKE_PLATFORM_UNIX) add_definitions(-DFEATURE_PAL) add_definitions(-DFEATURE_PAL_SXS) add_definitions(-DFEATURE_PAL_ANSI) endif(CLR_CMAKE_PLATFORM_UNIX) if(CLR_CMAKE_PLATFORM_LINUX) add_definitions(-DFEATURE_PERFMAP) endif(CLR_CMAKE_PLATFORM_LINUX) add_definitions(-DFEATURE_PREJIT) add_definitions(-DFEATURE_READYTORUN) set(FEATURE_READYTORUN 1) if (CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_I386) add_definitions(-DFEATURE_REJIT) endif(CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_I386) add_definitions(-DFEATURE_STANDALONE_SN) add_definitions(-DFEATURE_STRONGNAME_DELAY_SIGNING_ALLOWED) add_definitions(-DFEATURE_STRONGNAME_MIGRATION) if (CLR_CMAKE_PLATFORM_UNIX OR CLR_CMAKE_TARGET_ARCH_ARM64) add_definitions(-DFEATURE_STUBS_AS_IL) endif () add_definitions(-DFEATURE_SVR_GC) add_definitions(-DFEATURE_SYMDIFF) add_definitions(-DFEATURE_TIERED_COMPILATION) if (CLR_CMAKE_PLATFORM_ARCH_AMD64) # Enable the AMD64 Unix struct passing JIT-EE interface for all AMD64 platforms, to enable altjit. add_definitions(-DUNIX_AMD64_ABI_ITF) endif (CLR_CMAKE_PLATFORM_ARCH_AMD64) if(CLR_CMAKE_PLATFORM_UNIX_AMD64) add_definitions(-DFEATURE_MULTIREG_RETURN) endif (CLR_CMAKE_PLATFORM_UNIX_AMD64) if(CLR_CMAKE_PLATFORM_UNIX AND CLR_CMAKE_TARGET_ARCH_AMD64) add_definitions(-DUNIX_AMD64_ABI) endif(CLR_CMAKE_PLATFORM_UNIX AND CLR_CMAKE_TARGET_ARCH_AMD64) add_definitions(-DFEATURE_USE_ASM_GC_WRITE_BARRIERS) if(CLR_CMAKE_PLATFORM_ARCH_AMD64 OR (CLR_CMAKE_PLATFORM_ARCH_ARM64 AND NOT WIN32)) add_definitions(-DFEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP) endif(CLR_CMAKE_PLATFORM_ARCH_AMD64 OR (CLR_CMAKE_PLATFORM_ARCH_ARM64 AND NOT WIN32)) if((CLR_CMAKE_PLATFORM_ARCH_AMD64 OR CLR_CMAKE_PLATFORM_ARCH_ARM64) AND NOT WIN32) add_definitions(-DFEATURE_MANUALLY_MANAGED_CARD_BUNDLES) endif((CLR_CMAKE_PLATFORM_ARCH_AMD64 OR CLR_CMAKE_PLATFORM_ARCH_ARM64) AND NOT WIN32) if(WIN32) add_definitions(-DFEATURE_VERSIONING_LOG) endif(WIN32) if(NOT CLR_CMAKE_PLATFORM_UNIX) add_definitions(-DFEATURE_WIN32_REGISTRY) endif(NOT CLR_CMAKE_PLATFORM_UNIX) add_definitions(-DFEATURE_LEGACYNETCF_DBG_HOST_CONTROL) add_definitions(-DFEATURE_WINDOWSPHONE) add_definitions(-DFEATURE_WINMD_RESILIENT) add_definitions(-D_SECURE_SCL=0) add_definitions(-DUNICODE) add_definitions(-D_UNICODE) netcoredbg-3.1.0-1031/clrfeatures.cmake000066400000000000000000000015551457701673000175520ustar00rootroot00000000000000if(CLR_CMAKE_TARGET_TIZEN_LINUX) set(FEATURE_GDBJIT_LANGID_CS 1) endif() if(NOT DEFINED FEATURE_EVENT_TRACE) set(FEATURE_EVENT_TRACE 1) endif(NOT DEFINED FEATURE_EVENT_TRACE) if(NOT DEFINED FEATURE_PERFTRACING AND FEATURE_EVENT_TRACE) set(FEATURE_PERFTRACING 1) endif(NOT DEFINED FEATURE_PERFTRACING AND FEATURE_EVENT_TRACE) if(NOT DEFINED FEATURE_DBGIPC) if(CLR_CMAKE_PLATFORM_UNIX AND (NOT CLR_CMAKE_PLATFORM_ANDROID)) set(FEATURE_DBGIPC 1) endif() endif(NOT DEFINED FEATURE_DBGIPC) if(NOT DEFINED FEATURE_INTERPRETER) set(FEATURE_INTERPRETER 0) endif(NOT DEFINED FEATURE_INTERPRETER) if(NOT DEFINED FEATURE_APPDOMAIN_RESOURCE_MONITORING) set(FEATURE_APPDOMAIN_RESOURCE_MONITORING 1) endif(NOT DEFINED FEATURE_APPDOMAIN_RESOURCE_MONITORING) if(NOT DEFINED FEATURE_STANDALONE_GC) set(FEATURE_STANDALONE_GC 1) endif(NOT DEFINED FEATURE_STANDALONE_GC) netcoredbg-3.1.0-1031/compileoptions.cmake000066400000000000000000000176231457701673000203020ustar00rootroot00000000000000if (CLR_CMAKE_PLATFORM_UNIX) if(CLR_CMAKE_PLATFORM_DARWIN) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -force_flat_namespace -std=c++14") else() set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") endif(CLR_CMAKE_PLATFORM_DARWIN) # this allows pretty-printers in gdb to work with clang set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -D_GLIBCXX_DEBUG") # Disable frame pointer optimizations so profilers can get better call stacks add_compile_options(-fno-omit-frame-pointer) # The -fms-extensions enable the stuff like __if_exists, __declspec(uuid()), etc. add_compile_options(-fms-extensions ) #-fms-compatibility Enable full Microsoft Visual C++ compatibility #-fms-extensions Accept some non-standard constructs supported by the Microsoft compiler # Make signed arithmetic overflow of addition, subtraction, and multiplication wrap around # using twos-complement representation (this is normally undefined according to the C++ spec). add_compile_options(-fwrapv) if(CLR_CMAKE_PLATFORM_DARWIN) # We cannot enable "stack-protector-strong" on OS X due to a bug in clang compiler (current version 7.0.2) add_compile_options(-fstack-protector) else() add_compile_options(-fstack-protector-strong) endif(CLR_CMAKE_PLATFORM_DARWIN) add_definitions(-DDISABLE_CONTRACTS) # The -ferror-limit is helpful during the porting, it makes sure the compiler doesn't stop # after hitting just about 20 errors. add_compile_options(-ferror-limit=4096) if (CLR_CMAKE_WARNINGS_ARE_ERRORS) # All warnings that are not explicitly disabled are reported as errors add_compile_options(-Werror) endif(CLR_CMAKE_WARNINGS_ARE_ERRORS) # Explicit constructor calls are not supported by clang (this->ClassName::ClassName()) add_compile_options(-Wno-microsoft) # There are constants of type BOOL used in a condition. But BOOL is defined as int # and so the compiler thinks that there is a mistake. add_compile_options(-Wno-constant-logical-operand) # We use pshpack1/2/4/8.h and poppack.h headers to set and restore packing. However # clang 6.0 complains when the packing change lifetime is not contained within # a header file. add_compile_options(-Wno-pragma-pack) add_compile_options(-Wno-unknown-warning-option) # The following warning indicates that an attribute __attribute__((__ms_struct__)) was applied # to a struct or a class that has virtual members or a base class. In that case, clang # may not generate the same object layout as MSVC. add_compile_options(-Wno-incompatible-ms-struct) # Some architectures (e.g., ARM) assume char type is unsigned while CoreCLR assumes char is signed # as x64 does. It has been causing issues in ARM (https://github.com/dotnet/coreclr/issues/4746) add_compile_options(-fsigned-char) add_compile_options(-Wall -Wextra -Walign-cast -Wstrict-aliasing -Wno-unused-parameter -Wnarrowing) endif(CLR_CMAKE_PLATFORM_UNIX) if(CLR_CMAKE_PLATFORM_UNIX_ARM AND NOT DEFINED CLR_CMAKE_TARGET_TIZEN_LINUX) # Because we don't use CMAKE_C_COMPILER/CMAKE_CXX_COMPILER to use clang # we have to set the triple by adding a compiler argument add_compile_options(-mthumb) add_compile_options(-mfpu=vfpv3) add_compile_options(-march=armv7-a) if(ARM_SOFTFP) add_definitions(-DARM_SOFTFP) add_compile_options(-mfloat-abi=softfp) endif(ARM_SOFTFP) endif() if (WIN32) # Compile options for targeting windows set(CMAKE_CXX_STANDARD 11) # The following options are set by the razzle build add_compile_options(/TP) # compile all files as C++ add_compile_options(/d2Zi+) # make optimized builds debugging easier add_compile_options(/nologo) # Suppress Startup Banner add_compile_options(/W3) # set warning level to 3 add_compile_options(/WX) # treat warnings as errors add_compile_options(/Oi) # enable intrinsics add_compile_options(/Oy-) # disable suppressing of the creation of frame pointers on the call stack for quicker function calls add_compile_options(/U_MT) # undefine the predefined _MT macro add_compile_options(/GF) # enable read-only string pooling add_compile_options(/Gm-) # disable minimal rebuild add_compile_options(/EHa) # enable C++ EH (w/ SEH exceptions) add_compile_options(/Zp8) # pack structs on 8-byte boundary add_compile_options(/Gy) # separate functions for linker add_compile_options(/Zc:wchar_t-) # C++ language conformance: wchar_t is NOT the native type, but a typedef add_compile_options(/Zc:forScope) # C++ language conformance: enforce Standard C++ for scoping rules add_compile_options(/FC) # use full pathnames in diagnostics add_compile_options(/MP) # Build with Multiple Processes (number of processes equal to the number of processors) add_compile_options(/GS) # Buffer Security Check add_compile_options(/Zm200) # Specify Precompiled Header Memory Allocation Limit of 150MB add_compile_options(/wd4960 /wd4961 /wd4603 /wd4627 /wd4838 /wd4456 /wd4457 /wd4458 /wd4459 /wd4091 /we4640) add_compile_options(/Zi) # enable debugging information add_compile_options(/ZH:SHA_256) # use SHA256 for generating hashes of compiler processed source files. add_compile_options(/source-charset:utf-8) # Force MSVC to compile source as UTF-8. if (CLR_CMAKE_PLATFORM_ARCH_I386) add_compile_options(/Gz) endif (CLR_CMAKE_PLATFORM_ARCH_I386) add_compile_options($<$,$>:/GL>) add_compile_options($<$,$>,$>:/O1>) if (CLR_CMAKE_PLATFORM_ARCH_AMD64) # The generator expression in the following command means that the /homeparams option is added only for debug builds add_compile_options($<$:/homeparams>) # Force parameters passed in registers to be written to the stack endif (CLR_CMAKE_PLATFORM_ARCH_AMD64) # enable control-flow-guard support for native components for non-Arm64 builds add_compile_options(/guard:cf) # Statically linked CRT (libcmt[d].lib, libvcruntime[d].lib and libucrt[d].lib) by default. This is done to avoid # linking in VCRUNTIME140.DLL for a simplified xcopy experience by reducing the dependency on VC REDIST. # # For Release builds, we shall dynamically link into uCRT [ucrtbase.dll] (which is pushed down as a Windows Update on downlevel OS) but # wont do the same for debug/checked builds since ucrtbased.dll is not redistributable and Debug/Checked builds are not # production-time scenarios. add_compile_options($<$,$>:/MT>) add_compile_options($<$,$>:/MTd>) set(CMAKE_ASM_MASM_FLAGS "${CMAKE_ASM_MASM_FLAGS} /ZH:SHA_256") endif (WIN32) if(CLR_CMAKE_ENABLE_CODE_COVERAGE) if(CLR_CMAKE_PLATFORM_UNIX) string(TOUPPER ${CMAKE_BUILD_TYPE} UPPERCASE_CMAKE_BUILD_TYPE) if(NOT UPPERCASE_CMAKE_BUILD_TYPE STREQUAL DEBUG) message( WARNING "Code coverage results with an optimised (non-Debug) build may be misleading" ) endif(NOT UPPERCASE_CMAKE_BUILD_TYPE STREQUAL DEBUG) add_compile_options(--coverage) set(CLANG_COVERAGE_LINK_FLAGS "--coverage") set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${CLANG_COVERAGE_LINK_FLAGS}") set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${CLANG_COVERAGE_LINK_FLAGS}") else() message(FATAL_ERROR "Code coverage builds not supported on current platform") endif(CLR_CMAKE_PLATFORM_UNIX) endif(CLR_CMAKE_ENABLE_CODE_COVERAGE) # inform C-preprocessor about debug type if (CMAKE_BUILD_TYPE STREQUAL "Debug") add_definitions(-DDEBUG) endif() # AddressSanitize if (ASAN) if (CLR_CMAKE_PLATFORM_UNIX) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address -fno-omit-frame-pointer -g ") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fno-omit-frame-pointer -g ") set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address -fno-omit-frame-pointer ") elseif (WIN32) add_compile_options(/fsanitize=address) endif() endif() netcoredbg-3.1.0-1031/detectplatform.cmake000066400000000000000000000156471457701673000202570ustar00rootroot00000000000000#---------------------------------------- # Detect and set platform variable names # - for non-windows build platform & architecture is detected using inbuilt CMAKE variables and cross target component configure # - for windows we use the passed in parameter to CMAKE to determine build arch #---------------------------------------- if(CMAKE_SYSTEM_NAME STREQUAL Linux) set(CLR_CMAKE_PLATFORM_UNIX 1) if(CLR_CROSS_COMPONENTS_BUILD) # CMAKE_HOST_SYSTEM_PROCESSOR returns the value of `uname -p` on host. if(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL x86_64 OR CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL amd64) if(CLR_CMAKE_TARGET_ARCH STREQUAL "arm") set(CLR_CMAKE_PLATFORM_UNIX_X86 1) else() set(CLR_CMAKE_PLATFORM_UNIX_AMD64 1) endif() elseif(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL i686) set(CLR_CMAKE_PLATFORM_UNIX_X86 1) else() clr_unknown_arch() endif() else() # CMAKE_SYSTEM_PROCESSOR returns the value of `uname -p` on target. # For the AMD/Intel 64bit architecture two different strings are common. # Linux and Darwin identify it as "x86_64" while FreeBSD and netbsd uses the # "amd64" string. Accept either of the two here. if(CMAKE_SYSTEM_PROCESSOR STREQUAL x86_64 OR CMAKE_SYSTEM_PROCESSOR STREQUAL amd64) set(CLR_CMAKE_PLATFORM_UNIX_AMD64 1) elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL armv7l) set(CLR_CMAKE_PLATFORM_UNIX_ARM 1) elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL arm) set(CLR_CMAKE_PLATFORM_UNIX_ARM 1) elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64) set(CLR_CMAKE_PLATFORM_UNIX_ARM64 1) elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL i686) set(CLR_CMAKE_PLATFORM_UNIX_X86 1) elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL riscv64) set(CLR_CMAKE_PLATFORM_UNIX_RISCV64 1) else() clr_unknown_arch() endif() endif() set(CLR_CMAKE_PLATFORM_LINUX 1) # Detect Linux ID if(DEFINED CLR_CMAKE_LINUX_ID) if(CLR_CMAKE_LINUX_ID STREQUAL ubuntu) set(CLR_CMAKE_TARGET_UBUNTU_LINUX 1) elseif(CLR_CMAKE_LINUX_ID STREQUAL tizen) set(CLR_CMAKE_TARGET_TIZEN_LINUX 1) elseif(CLR_CMAKE_LINUX_ID STREQUAL alpine) set(CLR_CMAKE_PLATFORM_ALPINE_LINUX 1) endif() if(CLR_CMAKE_LINUX_ID STREQUAL ubuntu) set(CLR_CMAKE_PLATFORM_UBUNTU_LINUX 1) endif() endif(DEFINED CLR_CMAKE_LINUX_ID) endif(CMAKE_SYSTEM_NAME STREQUAL Linux) if(CMAKE_SYSTEM_NAME STREQUAL Darwin) set(CLR_CMAKE_PLATFORM_UNIX 1) if(CMAKE_SYSTEM_PROCESSOR STREQUAL arm64) set(CLR_CMAKE_PLATFORM_UNIX_ARM64 1) else() set(CLR_CMAKE_PLATFORM_UNIX_AMD64 1) endif() set(CLR_CMAKE_PLATFORM_DARWIN 1) if(CMAKE_VERSION VERSION_LESS "3.4.0") set(CMAKE_ASM_COMPILE_OBJECT "${CMAKE_C_COMPILER} -o -c ") else() set(CMAKE_ASM_COMPILE_OBJECT "${CMAKE_C_COMPILER} -o -c ") endif(CMAKE_VERSION VERSION_LESS "3.4.0") endif(CMAKE_SYSTEM_NAME STREQUAL Darwin) if(CMAKE_SYSTEM_NAME STREQUAL FreeBSD) set(CLR_CMAKE_PLATFORM_UNIX 1) set(CLR_CMAKE_PLATFORM_UNIX_AMD64 1) set(CLR_CMAKE_PLATFORM_FREEBSD 1) endif(CMAKE_SYSTEM_NAME STREQUAL FreeBSD) if(CMAKE_SYSTEM_NAME STREQUAL OpenBSD) set(CLR_CMAKE_PLATFORM_UNIX 1) set(CLR_CMAKE_PLATFORM_UNIX_AMD64 1) set(CLR_CMAKE_PLATFORM_OPENBSD 1) endif(CMAKE_SYSTEM_NAME STREQUAL OpenBSD) if(CMAKE_SYSTEM_NAME STREQUAL NetBSD) set(CLR_CMAKE_PLATFORM_UNIX 1) set(CLR_CMAKE_PLATFORM_UNIX_AMD64 1) set(CLR_CMAKE_PLATFORM_NETBSD 1) endif(CMAKE_SYSTEM_NAME STREQUAL NetBSD) if(CMAKE_SYSTEM_NAME STREQUAL SunOS) set(CLR_CMAKE_PLATFORM_UNIX 1) EXECUTE_PROCESS( COMMAND isainfo -n OUTPUT_VARIABLE SUNOS_NATIVE_INSTRUCTION_SET ) if(SUNOS_NATIVE_INSTRUCTION_SET MATCHES "amd64") set(CLR_CMAKE_PLATFORM_UNIX_AMD64 1) set(CMAKE_SYSTEM_PROCESSOR "amd64") else() clr_unknown_arch() endif() set(CLR_CMAKE_PLATFORM_SUNOS 1) endif(CMAKE_SYSTEM_NAME STREQUAL SunOS) #-------------------------------------------- # This repo builds two set of binaries # 1. binaries which execute on target arch machine # - for such binaries host architecture & target architecture are same # - eg. coreclr.dll # 2. binaries which execute on host machine but target another architecture # - host architecture is different from target architecture # - eg. crossgen.exe - runs on x64 machine and generates nis targeting arm64 # - for complete list of such binaries refer to file crosscomponents.cmake #------------------------------------------------------------- # Set HOST architecture variables if(CLR_CMAKE_PLATFORM_UNIX_ARM) set(CLR_CMAKE_PLATFORM_ARCH_ARM 1) set(CLR_CMAKE_HOST_ARCH "arm") elseif(CLR_CMAKE_PLATFORM_UNIX_ARM64) set(CLR_CMAKE_PLATFORM_ARCH_ARM64 1) set(CLR_CMAKE_HOST_ARCH "arm64") elseif(CLR_CMAKE_PLATFORM_UNIX_AMD64) set(CLR_CMAKE_PLATFORM_ARCH_AMD64 1) set(CLR_CMAKE_HOST_ARCH "x64") elseif(CLR_CMAKE_PLATFORM_UNIX_X86) set(CLR_CMAKE_PLATFORM_ARCH_I386 1) set(CLR_CMAKE_HOST_ARCH "x86") elseif(CLR_CMAKE_PLATFORM_UNIX_RISCV64) set(CLR_CMAKE_PLATFORM_ARCH_RISCV64 1) set(CLR_CMAKE_HOST_ARCH "riscv64") elseif(WIN32) # CLR_CMAKE_HOST_ARCH is passed in as param to cmake if (CLR_CMAKE_HOST_ARCH STREQUAL x64) set(CLR_CMAKE_PLATFORM_ARCH_AMD64 1) elseif(CLR_CMAKE_HOST_ARCH STREQUAL x86) set(CLR_CMAKE_PLATFORM_ARCH_I386 1) elseif(CLR_CMAKE_HOST_ARCH STREQUAL arm) set(CLR_CMAKE_PLATFORM_ARCH_ARM 1) elseif(CLR_CMAKE_HOST_ARCH STREQUAL arm64) set(CLR_CMAKE_PLATFORM_ARCH_ARM64 1) else() clr_unknown_arch() endif() endif() # Set TARGET architecture variables # Target arch will be a cmake param (optional) for both windows as well as non-windows build # if target arch is not specified then host & target are same if(NOT DEFINED CLR_CMAKE_TARGET_ARCH OR CLR_CMAKE_TARGET_ARCH STREQUAL "" ) set(CLR_CMAKE_TARGET_ARCH ${CLR_CMAKE_HOST_ARCH}) endif() # Set target architecture variables if (CLR_CMAKE_TARGET_ARCH STREQUAL x64) set(CLR_CMAKE_TARGET_ARCH_AMD64 1) elseif(CLR_CMAKE_TARGET_ARCH STREQUAL x86) set(CLR_CMAKE_TARGET_ARCH_I386 1) elseif(CLR_CMAKE_TARGET_ARCH STREQUAL arm64) set(CLR_CMAKE_TARGET_ARCH_ARM64 1) elseif(CLR_CMAKE_TARGET_ARCH STREQUAL arm) set(CLR_CMAKE_TARGET_ARCH_ARM 1) elseif(CLR_CMAKE_TARGET_ARCH STREQUAL riscv64) set(CLR_CMAKE_TARGET_ARCH_RISCV64 1) else() clr_unknown_arch() endif() # check if host & target arch combination are valid if(NOT(CLR_CMAKE_TARGET_ARCH STREQUAL CLR_CMAKE_HOST_ARCH)) if(NOT((CLR_CMAKE_PLATFORM_ARCH_AMD64 AND CLR_CMAKE_TARGET_ARCH_ARM64) OR (CLR_CMAKE_PLATFORM_ARCH_I386 AND CLR_CMAKE_TARGET_ARCH_ARM))) message(FATAL_ERROR "Invalid host and target arch combination") endif() endif() netcoredbg-3.1.0-1031/docs/000077500000000000000000000000001457701673000151535ustar00rootroot00000000000000netcoredbg-3.1.0-1031/docs/cli.md000066400000000000000000000203231457701673000162440ustar00rootroot00000000000000# Using NetCoreDbg with CLI (Command Line Interface) ## Fast start To start debugger and run program with one command just type ``` $ netcoredbg --interpreter=cli -- dotnet hello.dll param1 param2 ``` Note: to debug Release build of dlls with pdbs Just-My-Code should be disabled, see below. ## Command reference ``` command alias args -------------------------------------- backtrace bt [all][--thread TID] Print backtrace info. break b Set breakpoint at specified location, where the location might be filename.cs:line or function name. Optional, module name also could be provided as part of location: module.dll!filename.cs:line GDB-like command syntax: break file_name:line_num break func_name break func_name(args) break assembly.dll!func_name break ... if condition catch Set exception breakpoints. continue c Continue debugging after stop/pause. delete clear Delete breakpoint with specified number. detach Detach from the debugged process. disable Disable breakpoint N. enable Enable breakpoint N. file load executable file to debug. finish Continue execution till end of the current function. frame f Select & display stack frame. interrupt Interrupt program execution, stop all threads. list l List source code lines, 5 by default. next n Step program, through function calls. print p Print variable value or evaluate an expression. quit q Quit the debugger. run r Start debugged program. attach Attach to the debugged process. detach Detach from the debugged process. step s Step program until a different source line. source Read commands from a file. wait Wait until debugee stops (in async. mode) command alias args --------------------------------------- set args... Set miscellaneous options (see 'help set') info Show misc. things about the program being debugged. save args... Save misc. things to the files. help [topic] Show help on specified topic or print this help message (if no argument specified). ``` ### Preparing debug information For showing classes and function names by NCDB required to have PDB files. But for showing source code of debuggee application also need to add tag EmbedAllSources to csproj file: ```true``` ### Start debugger To start the debugger in CLI mode just type ``` $ netcoredbg --interpreter=cli ``` To load the debugging program file command with the name of an executable used to start assembly as argument should be used, for example dotnet: ``` ncdb> file dotnet ``` The name of the assembly for debugging and all the required parameters could be set with "set args" command, for example: ``` ncdb> set args hello.dll param1 param2 ``` ### Debugging Release build of dlls To debug Release build of dlls with pdbs Just-My-Code should be disabled: ``` ncdb> set just-my-code 0 ``` ### Running debugging program Now the debugger is ready to run your assembly. The debugging information is not loaded at this moment and will be available after debuggee program starts. But breakpoints could be set here using `break` command (see below). Keep in mind that all breakpoints set here will have "pending" status until "hit entry point" event will occur. Debugging information is provided by *.pdb file. If the debugger can't find the correspoinding *.pdb the debugging will not be possible, even hitting the entry point will not pause the debuggee process. Example: ``` ncdb> run thread created, id: 15498 library loaded: /usr/share/dotnet/shared/Microsoft.NETCore.App/5.0.11/System.Private.CoreLib.dll no symbols loaded, base address: 0x7f69fe5b0000, size: 9470976(0x908400) library loaded: /home/user/src/sample/bin/Debug/net5.0/sample.dll symbols loaded, base address: 0x7f6a79e01000, size: 4608(0x1200) breakpoint modified, Breakpoint 2 at foo() breakpoint modified, Breakpoint 1 at Main() library loaded: /usr/share/dotnet/shared/Microsoft.NETCore.App/5.0.11/System.Runtime.dll no symbols loaded, base address: 0x7f69ff000000, size: 230912(0x38600) library loaded: /usr/share/dotnet/shared/Microsoft.NETCore.App/5.0.11/System.Console.dll no symbols loaded, base address: 0x7f69ff070000, size: 376832(0x5c000) stopped, reason: breakpoint 1 hit, thread id: 15498, stopped threads: all, times= 0, frame={sample.Program.Main() at /home/user/src/sample/Program.cs:13 ``` ### Setting breakpoints There are set 2 kinds of breakpoints - by function name and by filename:line-number. Examples: Set breakpoint at a line `66` of `Program.cs`: ``` ncdb> break Program.cs:66 ^done, Breakpoint 1 at /home/oleg/work/hello/Program.cs:66 ``` Set breakpoint at function `func2()`: ``` ncdb> b func2 ^done, Breakpoint 2 at func2() ``` Set breakpoint at `func1(int i)` member function of `Program` class of `hello` namespace: ``` ncdb> b hello.Program.func1(int) ^done, Breakpoint 3 at func1() ``` ### Deleting breakpoints To delete breakpoint just type `delete` and it number: ``` ncdb> delete 2 ^done ``` ### Showing all breakpoints `info` command with `break` argument shows all breakpoints. Information about hits and if this break point was resolved also will be shown: ``` ncdb> info break # Enb Rslvd Hits Source/Function --------------------------------------------- 1 y y 1 Main 2 y y 1 foo ``` ### Continue execution To continue program's execution type: ``` ncdb> continue ``` or ``` ncdb> c ``` ### Stepping There are 3 commands available for stepping your program: `step`, `next` and `finish`. `step` command executes program until it reaches the next source line. `next` command executes program until it reaches the source line below the current line. `finish` command continues execution until the current stack frame returns. ### Print variables To print a value of a variable type `print` or `p` and a variable's name, for example: ``` ncdb> print i ^done, i = 3 cli> p s.a ^done, s.a = 2 ``` ### Command history The CLI remembers the history of the commands which user used during the current and previous sessions. It's possible to move back and forth in the history pressing and arrows. Also possible to edit the command line and search history in forward -s or reverse -r directions. ### Showing source code NCDB allows to show source code of debuggee program, while execution stopped at breakpoint: ``` ncdb> list 8 Console.WriteLine("foo!!!"); 9 } 10 11 static int A = 10; 12 static void Main(string[] args) 13 { 14 Console.WriteLine("Hello World!"); 15 foo(); 16 } 17 } ``` `list` command also support various arguments: `list ,XX` - print 10 lines ending with `XX` `list XX,` - print 10 lines starting with `XX` line `list XX,YY` - print lines from `XX` to `YY` `list -` - print 10 lines just before the last printed `list +` - print 10 lines just after the last printed `list XX` - print 10 lines with `XX` centered ### Showing back trace To see stack of calls at the current break point type: ``` ncdb> bt #0 sample.Program.foo() at /home/alexander/src/sample/Program.cs:7 #1 sample.Program.Main() at /home/alexander/src/sample/Program.cs:15 ``` ### Quit To leave debugging session type: ``` ncdb> quit ``` netcoredbg-3.1.0-1031/docs/files/000077500000000000000000000000001457701673000162555ustar00rootroot00000000000000netcoredbg-3.1.0-1031/docs/files/stepping_callbacks_scheme.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-3.1.0-1031/docs/files/stepping_callbacks_scheme.png000066400000000000000000002372201457701673000241450ustar00rootroot00000000000000PNG  IHDRuAוtEXtmxfile%3Cmxfile%20host%3D%22app.diagrams.net%22%20modified%3D%222021-02-16T13%3A22%3A00.832Z%22%20agent%3D%225.0%20(Windows%20NT%2010.0%3B%20WOW64)%20AppleWebKit%2F537.36%20(KHTML%2C%20like%20Gecko)%20Chrome%2F88.0.4324.150%20Safari%2F537.36%22%20etag%3D%22Pn0s-R74HK7x9hE0wkCi%22%20version%3D%2214.3.2%22%20type%3D%22device%22%3E%3Cdiagram%20id%3D%22C5RBs43oDa-KdzZeNtuy%22%20name%3D%22Page-1%22%3E7V1tk5s4Ev41rsp%2BmCnebX%2FMzGRyuU22cjfZze19w7bGZoORF%2FDMOL%2F%2BJBAYJGEECLDPSqVqDJaFQP10tx51NxPzfvv2MXR3my9wBfyJoa3eJubDxDB0yzAm%2BL%2B2OqRnplNyYh16K9LoeOLJ%2BwnISY2c3XsrEJUaxhD6sbcrn1zCIADLuHTODUP4Wm72DP3yVXfuGjAnnpauz5797q3iTXp2ZkyP5%2F8BvPUmu7LuzNNvtm7WmNxJtHFX8LVwyvwwMe9DCOP00%2FbtHvj44WXP5funw3f%2F8w%2Fn4z%2F%2FFf3t%2Fn7367ff%2FrhJO3ts8pP8FkIQxHK7JnP54vp78rzIvcaH7AGGcB%2BsAO5Em5h3m3jro486%2BvgXiOMDmXB3H0N0CobxBq5h4PqfIdyRds8wiEkzHR%2BDYPUeTyw6Xvhw%2BSM99ej5PrkGOiLtZ%2BgoikP4I5873EE%2BEbix7y6Af%2Bcuf6yTgd5DH4boqwAGAHe1QsJA7uU4uA%2FHs%2BhicXj4D%2B7s1s4O%2F8wHgg4e3kpHh%2BzozYvTn2lTcoh%2Fpt9q2pwcH3%2BJD4o%2F%2FApCbwtiEJJzghNMBCGC%2B3BJZufxyXr8XV%2FMft6Yi%2BfH%2B5%2Ff%2FvvXr0QQtNgN1%2BBUf2baDj%2BkAliI%2BHwEEA0xPKAGIfDd2HspI8olwFzn7fKffoUeug9Dy5RIhiCiQuZauYf0fsiPihJc009%2BnHWU3jDTEfpQuJ3jqQQgDcBicsDi%2BOgB3%2B1KkHH%2B3mOdcOd7AbjZEOXyHjVBw7WPX6NPa%2FLXT%2F8%2B7uhzK%2B%2BF2%2FUiF%2FibZSrxuP9wvXhn2OgS6ELoFjXq8y%2F4APetYUjeRAnG8O90Y%2FeWf8eMWp%2Fjb%2BlRf4buClmLvQ%2Fe%2FVK4g2TAg9yD4DizUeBb5g6DfhYar5d3K7DYr9cAYJiGcAmiKOkM7nZgVbz%2F9DLMxHIeCzPX5fmv1MJYA75uvBg87dxEC7wiw13WzEWNi0B5t%2FbdKCKqpkad4p8%2BulvPxxj7A4QrN3BxG3QtL1h%2FS5S6djyBjozG%2BusFhDF4O6lxyLdWBeBfj5Zcd8i5TcGK21q1jipphaYqwGJUwJ%2FIubkyk5mMjrQQ9U04povbzhE0SURAbrRbaz6fl6WETH5bq5U1gc%2FPEWhmkUxnWItkM%2BL4G2SksX5CL1pey9LYxZeSJJCzmWGNJZCmVhZIYyYmkGi23EOh2Q43iKpdurxf6jpV46ppjz6kI5CKDodBh4et9tcH7D64L66HBAuLzSOrwDdwu9hH9ZZWxHbS1tj1vXWADpZIQPEKgCf%2BuXV1aOOLTFB%2F9tahZsni2FuDY29pKZNmb6f9utzCTqFR5QLjm351vTiDN8BnvOAZYi87hNsa17DbANBfd4slMlhEu7InWeGHMk4ncyIbUUbkZNfUq58iks9gsFUKPQg3OgTLLwAZpdVTDHY7BJRP6PGHW6RqYXDnw0Xh9tORMk%2Bl%2FmGdlzc%2BkLudezMF%2BOdtivC3JMD%2FFJHBgX%2FLRWUub7mwVUraiUVmIiWUHH66h%2BEDXiR%2BQXO0Bqt71%2FfxYKoWgV0lSsDQDCQmPCOhDyomOkdMrmtJdmQj7UmBjJycJCJbMp%2BSHWzCqtWSlaKOuGSyUqd9m9ZsZbZMlb825IJCUft8UGiioEBubREWmNmf1kAjOeqZ3DcdFjCnjGffgGFIumlLwNAddV66ykaUztsAuFZIaY5RtDQIHMZpYHG2vYaxQLVAMe2BTItmzm9tgxLyW22mHf9ZLY2NVkWVD2RtdJaKvHpmfAwXiz85U0Ek6DNBJBzZTtM09bLkDUi%2F01LPbC1LojuZC2U8q%2FDIqB90Jjz508cynmo%2FIDdZRR8w9wj5xqon%2FDWA1dy07ZIA3YyJK5P26SThak6tkTIXsGpgdPtsXP2iiiWhoxjsEp43uddDsER%2FtwkHqXYTCrNFb%2FpoHKaor%2B2Ek%2Fat%2FX6CbvJ3FP4NtvAljQ4BLx7cRz5%2BEMsQkC2BBfr0Y0ek%2BRnpK%2FRUPODjr1JA3l4z8Tyn9Y3OSkouPcNQinOOpFyXMyuTU0QWTcsd4jHJE1vUExY12Z3XhPTCjQ4hab8EFHSGpRGOvN0aBZk6yEiW8EwE%2B%2BfJaevelvfTdSrsoKeYFQYgVo23yQys8Q8kR7mcnHD5Ps2HrZcGJyTO7hJudz7SzFi2XpCsKoel6LDMx3ZYMmWrtO%2BZb4KeXJjU%2BiWDqXeGApDml4iSCdIUJBu0rdbvIkrOrmBnxlu%2FG%2BwuQ3kVndmkRZhZpMLCW01t5dRanFCvgaeW5a7lpO6Q6MwAxt6zt0yiAlkpIeAv8TRYXCpCBJUUcaXItEeXouqA4W5StHETdg8bjh3A7F28cXF3yMHBMeVYptCpJL4c%2B9dKeGqFZ6pTwjM6O2zwOL9mKymDv5K6T3jgxCuL9ltQMFcFhXPVCyqTUiU2T5VMh1xQmdXBx51yD55iGGIJWO7D5CEa2nvigX56UCJQ9Elmo4sAb03d0JroPGvy5CZK4DjxrEfiYlOSbSYpc9LYF7GnY5sTs3O9gCpz0lviTT95Urn1y3MknnI3Kt0KjTzMLRL%2F6gbuS7awIjuHl8tzhI9SpBzCZTxFyq7bpebx8TLbegcHFuJ7QoqXamDwJHMwqHIhwBuRKsuhynK03f2gtrkGrctxMilCXqZgnZxLKKFTN8KKbppkx9aqHzEDjhp5wT7Z%2BnsDy32RQ6vOquWAS3YS5GXYY8Ok4MLZLBw2YdLk0WRqs7DtZmFdZFMzwarNmBSN5jcHSpmk5dvSKLkV3SocqnoJE9dhnI7roMdFte8nrsPsHKt6hj7zXc52Ko9ZeczX4zHb2rl5zJlvcc0uwJmkn4om3XU00zYVsNm2sIFJbdzpZlcrLTvix1IFQbqXNR4tgtkUjoWzxgFOnuLaFDlMR4LIkYYLdkdCJWlfcthohoB6qFxWXVXaxDAho20RZ9L%2BVN%2BIY2NPVUZ2Bji9ALe6jOyLA1yLlG%2FNmo0GuCmFE9oyiQJuSndEc5iSKBz6OoOk2liq3vL%2Fl%2FkUZVIdUU%2FziOZy9YYBoTylTJ5Fm7y2UGZo3fHXeew2hvJnj%2BDSS9A6Im0gWkP07TKlWkJmSeSGLHrCBLO3fU2NPac66u%2BlAHxUVG8cqL3widoLH3UvfEoR4Q6n0sewe%2BGWqvTRzYXr08rUk4V8KyNgn1I1KZ8spLR%2F%2FvrApmbEoTpyTLH6wU1XUpZWdlWzVEDhzfCG7bP7qrzvWcf25gArwcynVkqjLYsztZyi4qgLoRmiOJAluvGgCXq2HVWJpZeRyZCXoqpkRqkSu6e4Gvo6FBTr2w8RV2Ozm4OKxLlkEke0HnpWPOASSZzWi1GGDRKsCz0ciZMVxFYkzvAkTj24ROvlmaI28VzYHlkxq3Rkl92ZJW12nabj6te2qjckXHLgjSZqSecjOcBtQ9bojphahT1TsjYbBnB1uBi%2FDPtYYmu33UynqRO7pzLsdLiNPT1tW2ra92Rb1Oa7vBeMnIG1EXctjcau5WjrNjrezG5L2dA0stUZ%2BtJtWnXKrWB%2B0nWWt1ClLSSWtsgYxvFKW9jsbrsyS82m%2FxIVu9NasVdsb0nnC%2Bjr1Ph0Ne178unYvXfF%2FXV36sZbYmW%2BWq1TZzdPSJjZ2UtZzoAvtFvnANFrOrqjnrb1s0CbXvGcRbopnmPMlZUwtiTzHE5bDp2R1Z5sYtV1mo6rXwwZHAyp8E0VvnkO6y86fHP8UkaOymnluZAtgrMkW6EWGXDMjvCADt6MTlxrG3Exo4oLiWbASbMfvL0mGTxXUtye1LjfRwm9pd6W0KHgvcULfR%2B0QrHTuSxrzavDSm89VW8Ncygdk6ccjfbWMIcl8ZX1vORoyEz716e0No%2BGHNU80y8Ra8u%2F0rVrh64I4bA5q2q%2FQGZFiLpMgtEAZzQG3NzSjbEAJy0CeU7nCwkCrnHyAV3U065JPqDaGzV5TEzFiXL7nsggXi7vdRnnM1jKCtvKcyFUmYSfnqqwzOhwl5oXJNe07wlDKsH3HDAkav4k59%2FO5rdTe174JwdRTA1AWYiirYxeg6jT7ZsiCh2GEK%2Fkj83RenvzBa4AbvE%2F%3C%2Fdiagram%3E%3C%2Fmxfile%3EԒ IDATx^ VUe3I^*40%jB.6 i%( M `NH&J$]3NʥJ"2I2 /tz[gﾭpλ.~:CߵvZrJu~Z @ @%8ꨣ)Əް -\zjjƌjذac)T @ @|In:/|A 8PxG#γ>n6A @ 8J`#ގYfm۶9j.fA @ h}U\s:hȑKeqA @ M@C}:ꨣ:n:n @ @@@@ׯ:H)e@ @  tA: @ @@:t @ @ !D @ @Q>@ @<$0 @   @ @u{衇,,:th{ ~?uSD)i#ի ɴW7H痲wyȐ!Amo{K.Ì4Ң.\>%,*HfFMmذK$7;(ӏDfV;I#uFS @@u@U&u¿QD<J/wJ*b:zffsLq#cF~u̶(\|yND-I,%"^:^^*˷DQ;"%ԑnD1}LU[MQGo  ,  rv{$$,؊1Y;ΖKZ:"CzV蕰l)YNTN?esLD19Д#W>̓ȸM!@(N>@@IOґ1z=um8_ ׊+M6H:[fРAr)3s=tttJxQ#OO;Q\&nWE~ʞ2=u_.-45kwӯ siOQǴ܋G Ep?HSd▅ @ :n+ @ GK WQ^^+7O /i§G'cI^SNe?"h!D/cϟ}`RxCfkDmː>huu[~er>Ӄj/^o.r;9>l??(3l3r2ٿЖv˰/Z5lOu፨e!@(N>@@ 8]  @} R#z^īJÛ(GE0m#C D @ @Nd@ @ C @ @@i @ @u @ @C:: !@ @} @ xHQCa2 @ @D:c֭c @ @|Iկ_?uȑ#;Əɘ@ @ rJvZuн1k,m6@ @ 8No߾kQuttt\zgUvfc @ @/ѣG#8Bx/:B͛73faÆN}- @ @!κu5p@Б!/Ke駟v|L @ @$pQGSN9%YEW'QhҷV\rz衇BN8D;zETUijN`ܸq oxyw^}ϫHq?L,Y;,Cɀ?⋕;\u]*}M}C98FQ1` ={ԱAɒ.AkUO=ZpaQcϟc,\y啹YO~uE)w ;y$gw}{spc@ هe/{N>d5}LB@^J=SE@tD[\xܢuu2 /T"pAg2<jꤓNRs%Zgb;$S0 HE@wq2~9? ŋկ~+ug-(3VX&LDEhA۷|#8.H *JGoW˖-SMf@1:9s $ 5\WDiӦ%. _ƍ׾5T@(4dOSYuan1NjtJر#sD.FsW?QUݺu ~6M @:Y(Dqj&r~z?O-oy v|jJ~rO@"D޽{1/Bc̐?۷/8lR/?A_"C)d@9yԆ7/b9o._zꩧٳ1Z!J@ԩ;i jI@6GK;wn}C>;kɇFg' RUSCd]vu[1Q'C_y԰aq 7){ MQ'oM`ԩ'>M7_~ibayQ'Cկ~Dႀu| Cm6bn1AU'Su߾Kr-j͚5WNϩ|;WN5|qk" xB'|R]Ro2BVA@D7 J"v MCL6R $u"m6mRgV񐀍!D ᷿z;ޡDႀu| Cm6bn1AU' $xjUo*+~5sLe˖j xBŧzJO Mx8I!C::~;շo_%? ;D=p[u@ TŷR^z\$`yQ'C_ٻworOg(p /^;#`!rh D共?&C:ʾ}T޽;\𝀈:s.@y@ uIM4)I6B)gj̘1?)*JN3Ϩ7J~rAw:{!61n  部SuGؾGyD{?yRUl<!dF>C)d?>Z@ o6b $!iرc:$'l<!d>:㕈;\~MC-:@ucaÆ_WNO#8B3:p:ÂoxbuEl-C DdH 4'rJ5m4ս{F"y)r衇6~.@> ַ.G^{;wzի^>"x_ON<.|GUR\ HQGevu);;'? D8sL?Y}_b\w/K1HԙUq @VRWXѥK.$}ʬՐ@iuJC_'L̉Ү3<3?^6׹1:xm#X{<`+ar\o^M@u$C~:@ >DHٜ/~ ]׿lW_|1&W 8 6җ԰H8ʚYf9b%f@ Uyk} A *Z( &LQ'gh7@dD*xѝ6Ⱦru]d֓N:I͘1$:`̧gy&x07. J畯|e>S J ?QqJ.@y:zkJN^d)(NVO=T??t%{VD|:gΜ@;v+s N2^hnM=(H 8NQqyhYfG?*dD8 L#˯M-[^WX3UA ӟ=.D '֑M ,Y^:y,@T:d 7ܠuV6ֽQ:?׿uqFsNiF|p}on Ye̗Un9mc,;B - x8qb"jn.>ϗE֭[6|`_Ns*V?jǎjڵÆ S7xc%su|Mh~!ޗ̗"9Kgl$Krw,r# 7I֯_/ ! e"pA 0_; |Ye@6:1_f_GҚ#bŊxHX[͝ s̎#L,ʺن1_: Bi /A&|iE~q{{^o~cǑ~ > ' Е |I(eĩ Db߇H_K+ĉ;dYfG 5\lMN X$M9DXSOn5 wK.ML.TȔK+[5k֨}怑" mȑ#M' +_JN+X(9nL{D܂5C/rHLaiWu|U7>̗VDTGGGGIc!`Sz,EqX+|R'u6mN|մgþuٙ}iNK]SD N`WIW&}@4uN:$%pL?^9p>}4h3fo߾9sC:uZx.mݻըQ̙3MI>ѩOڿ0u&x%]uUAR;^9R .TW5ǦF> ldw݈:!WUy̝9)mٲEr-{YL-φ}N:IĐ ,H8p;"QǎqMҎb e>JSK,qjFt% ' Е/㕞ז/_hD~ I筸}+Ƀ̅6m ^n)~#צ2dD(N4qW+GΝ967!=Rasmfgܹ3S]~7n\@SN '"""uf\`zk_EO2E=3 /La4I]"zd˕N'Kdo:t[ IDAT4!CBˌ@K2o\Qk6GCW^.bu||LpNԼ v|?{^‘2?]6XReS~VEٳgډKy-IdMTf*Y6lиtd|;ի^M?A=Ýi_mݺQ͛U3|7, /jVOK*o&5No-PcSǭt # К/UԲb/d^=sJ"zl ϛulkB洑#G\Č.5k3suDosb//>Kc@ )^ټ!ˇ̓y~~N{~{S7~{kD#Fe˖)i>jF1fŦV9ِ!Cn5R|i>oE={Ž9+egґD-ѣGPJ+B} ~~_U]tQ~ٮ~Q%4M~o$b Z=)f[Nnuu^;\@WWQ%G2YӒVyrɋ =9u< UGgcd χud rVsd"}_ 6G}Qe0^Es&ШHV`<37_D9|’`̼=W_3ޫN՜;kE *}nZFمaNXim 0{ LԑDo}[ꬳR*_0o촢qegAkm^nS{;:`ƍ _ƫ=uf(YtOT7~wPY#8=Hp9uQj?\,=:!ĮW=ün]zN$͗X=߭_Ӿp(1ligs<:ҷZb%y%(yݩfaע!S82%QǖD#KtZQ'âN7vVQR:u)G1@U!`[D3!(mjk c/u<-.#ts|Ui@ԉxIĩDV߻LQ~9eu/.j&ȁAKGԉ3*OcZiN<V6Rp5#7憎r36Q=kuVIE+Qrxm!7JϑVf_syᴨYKi\)7˗Nr{] !+Gr1H^ZQsK't$i/ -B:ќ8^5{RLO[-qOaW%j¦Y ;ڕzaN^3u9sfyeSf.{&e:9RPXpaܓrS+Z@A))Sԑ.AG"~䅉+ϗ6C)NNltj'?ҳ#g pT.wu#ԵnK!S+dN]!<7 ="ᑳ*h*NI@AWϗ6Cԩ`GI6:OwVG%.y~sZ> YN?~h!U  uJ%`S +;E Dh0^Wdφ}:uFvޘ?q@T @3@=::J,r}aT6:u r1*x)H#]?ٰQ&.u¾2 pIGQQǽ^Eϗ6CԡߗJF.AW?:힯yP7HQ'||)G?i1uPRQR몤 S7԰#<Iԇ|4zdcѦCEc'hlSx )xۮuQK&iF #l 3:iSX1:58mlN1vxOɃSՃl|ꩧ}chpV2_oƙQu/1oFXJ*Jj]Ԥ7m 23~hqKf:p~1bDjܸq-3:CDĉuQ,:H3E,:Q.*B'J( 5_!֘QF"uYoH_1@_:Ѿc*se׽4_ƹ?D<'ovD+Io?dk%A 8GX ԑKĉ,21l1Sd_>}=h{wq1mjwX4QKp̈}r=u4Y~ea#7gqFFE#}tyIi3)vYf=_\9ݽH.BQ'|C̗q'qDԌN^Psy/tI/NFgpJFϩё@ԡ@5#S3\ ]R56љ6$C 5sjtdu@ 5@T "dt d4HM!D P3"yj5k9͵Iqt/ۆu2ՆS2Dv&@N} Bԩm7qۄ-߆u2ԆS2Dv&@N}D9Bsz!uꩧnݺ5Jԡ_TI'd,[:h)M"{Bk׮U+WTz&yuQSNQǏWÇZhJ#|Y+f^-Vy^Eqyac=ַ5yM߯oMٚ!DΆS2D.Ryf5c 5l0u1$M*x'պu5p@u7V `,y)2J<"81nҤI굯}g?+B=3jٲe޴CuF0mLDq2'^uLi)M"{ -$  #a:Xu)Tp'ԴV_|WN:$O[٭u29Nhco1 Q> 0NqؤD;AQ6?Dζᔌ&=Iuȑn0, :MJAqyjo}KuYjƌ[1!ds6$ b@" }9`E_IU/:w2L>OV˾:z?E>}xETeR {fs[f*R+wXK,uX#<1*E6H9r:o߾Js"{4wu1%KF4W9iV"d d41 T#H;_95G' : Pƨϲe+BUGz&y5qKa^GJDSO=U[N]wuoo*# Ќeb/YӎPm8%IdA 8F?hР z%˂Ǝ|yyɛB:v {Gy3rQI:e;"$/4Q'il8%IdA , / QaϞ=ݻe["b-׬YrD bȋ/e)]'OwΝ^&P#vN2E"Y]wݥt9qO~@z衇:bWWݺu$K˵Z1KU IDAT$@pUI˼ʼꋨ\w ww.b"u=n]4R27;E+uCȘ;euPBHɽIo&y$6m%sc-7!@Hf{FDډ:Qv5kKC)i߯^WwD27vF4tDw.Imm Qǽ{O [}"jaR2M[y;NSw_۪YO3{7Xտ,jv ʊ)98cΗqCԉC Q'#%'Q /y2\ueLbK%XQVJzKŢU>-h YE8%!D;,7nie^}ii3{}=J[,RG`s95 'PdtNSWtSNJ:)=gˑ::ͩJbU N{A@H:B/I˼WQ{ꄗ]Ӱ$JG#Ǣ-r-J5{%/Q'%D˞fjwJ?i:_EfVQ'BYG̜93x SGүXBIMx)YxoI+m߾]}ف 'w߭N8 Yڦ!{-EsQsԞ:G/i3ʽ{O ͸[}*ia22x_5s݈:.zX\ibv qkK3_+Q6pJF@ZE-32O\jws&ySӯZ ]Nҡ[Q§X银dS$_'tI="e`/rƍӯDp2NsN$(@q &#e^$jN3:} 6sӮE ĄZdDbgEIf/[A{l8%IdAŀD  pegr egeʕzU3:",r9:Y}_QQ''m8%IdAŀDDr$#L¿:a_D9ȑ#iy=weYeu2zӆS2D[ H$Aԡ@ G9t(S6*E6H=z4}-/ӪR"˱1!d d41HC@ws`QA8lRU Ý,GӪRvz+Eu2ʆS2D[ H$Aԡ@ G9t(S6*QNiuhCs acC"Nhco1 Q> 0NqؤD;YFRfu2Dvttd,EoE>z7p[V_[dYnUl8)m<!!" d41iÇWǏ$u&rJvZuwm@f̗:]qʸ*ͫAqG>fUW]֬YV^zl٢6oެ PeE8p@M>] 4(`۷,nqjg!Dv|n)M"{ %}֬Yj۶m1R@`L·̫>x 4"S"̝;WM8Q]wu.Eԑ3f/ZHӧKniӦC9$^c]ԑf-xBNhcKճ>n9HV7GVGqt 0_ԹWssUm^EԉŴ#%:G.3RGGeɻWzTqLl:,#U\~X+m<!$?)GϞ=ծ]:OX*" 2j?l0)+k׭[(:9S"|镻r3y57)*Nn*#<$e駟<yjԨQj̙$I+"+ݻwWAT͢sv+{lʵ`uyuСCv=cǎ #".\|lYY8R'I^)79su۷/aÆN6^{:iI'NCڤ9{+tQ'riӦu`^xu衇6gܨ/HBŷzWH N8ꨣ),rU0KSi̫@*ϫ::5{i9"H4r|ժU D K.ͼNh-l~H.6wuWW"6J{z(ZB y(%P' 'Kd$iWXݻW͛7O-Y$k'/D!G C"i'O܈: o;9xNWyգGO߿0hvaOI@)SAk4eC/cZ؞j{F ?яþ7ŪZԹٳ˃l:ⅈ8 ˯CDw',lH&)fY"=ՌM':/%i*3lQ;o!D?z'3|]r%tWZ!`m_HֻӇmQ\ԇe}|MK 0Vg uDؽ{wcWqFKtL3QG Qz VX #y:lӖo9˯ߥ~-B]q27tO;QGG$ /ԧ>+Dzu9c<)Z( ~}뭷 . .IRnPg̫>Nr(9K$i_iްd+RGۡqZ,g_:&H'dEw*DG(G}z„ pIN*d ̗t`^us^$Fy2E۷w'N=xZeU8L_=D4 5Z|2u{r~;q~Sf 8G9䓉np?9/RC 0gEWǗZӎF1AgNVMXw3OYD->MG} ͝;Qe.s ~:$OEGv{N#˿Sqe_ru2!%3 ``;ԍj}<.$_tEϮOiYh1cFiV)ͨeې!CbGm;Q;#wPk3#3PC3.xO{ҀW@RDZNSlz5lku"ߤ^N5p!@D]:q`Ԝj:Nv%:VWG 8֧m̔)SԒ%K8)1`N{&ꜜ֞!) x/q"W_uPK\Qg"8;Eeַ:Rr:sj}WheV&. u˾7r#dzTò0iGsϩ7fiWyuq(!8.S7pPڧOG 'wJԳgOk׮NI @書I&e˖Ɩ̗iu̫{(_ _\cKad-QQ-QgjԨQj֭c&N:O[JO\hy^u]b9XVtYA&d*AٚyJF$uubhuѢ)aQN̞hF4{èGvbB%sl 25 }ƪ0ju_!HM:Ur _`ApT˧llСJĜ{vhVٛK#-_VGhQnji $KD**/E%:l :!P6,l 26l@<6KiQ;#KKBq+6p҈:z K8%#=E:EQ5Oޥl 20GvTZ*UW=]:p̳!IE:+V#F(9JD|j|.{ѣcG}tMy2˲1/ 2o!nG ӮN>!P۷8NCKJyڞGqӿ檤1O,كGoX,\_I}z#:,ON:ӃSc{dƿl uʊ)ݍu$`c#G *(+zzCT<Yl,FyEVWp5STpNF[[Qǖĥ(Ih6"@W3f_dkǞ)9̫3uDDm sYwtl u\q͞tݓ\U `cp-J5{/hw|̫YQMyVJ-Jg1g%AEp}$j@=Y 0f%v~D|g)BmD_a|3{w d\l'6A  ㋝z`^u/Q&t¹l u|Td}9.N)e1Ȕ&qx UU0Vœ /2~ІүfVYIi{ԋԤqAƭb  EWVju}+-C߿D!|6J:URԖo J̛A&o)ȏ@*%?SRWu-t揮ab٘*'T5wPr64vO-UmA 60ڠN:"KJy"M˰1/TFԩX6ڽ(L:(@:^Cmi 0%G>D?:un{>5yNݢXެ71įmub[{mON`KvijƍX6H|x.بR'[Jڛc뵨Sg5m^&l 2'P9m/a!P N1-:uhcYY6+oEU^&pp6D Z|)Jsjc1^y%Һ-m 2nk PDě/ک@+ODp }n*8jb HٕA@qⳆU|Vz~ ?OaÆH+qf@&lܿ΋:D36]uUj͚5jժwj˖-jjj &l 2N4 # PeE8p أfРAj̘1ޑɍһ(QپDbgNnq㕳V;::̀㼃\3Ж"+sU'NT2H<È:9?=6 I@3f(-Z9_r-jӦM}!,9^2Ei%e<_ (QQ].g5G5ulFTknU<#Jt\fܑׯSG 셀OFu|ָ<ە?gKtFDl~Rnעa\JSJgV畝?OVRy䑠IGq9r:#TFR3g %<{ec6l 2@',:gǎu֠ ;߆el;vlVG_J$?ppfKlÑ:IJQ6ϙ3's߾}\aÆN6^{:iI'NM&A[|`̿R"l(EDo8 MT~Y-Vw<0]6_gDIh FY={4!]ԪU_ҥKo' C 4&ƸqV~X~뮻,elիW hG 9"Q}#BQһ[p m9ôIҮXB1BݻW͛7O-Y$xa`'ɼ$9Z I;yF)mx |Q;̗(@Y/Aiuq7%SV8CmW:.(03*!ꫯVgV˗/lG)̅*1X3!P3ⅈ8 ˯CDy( @aaD,RG#)rY7s=9f^S1/ɛŋBQX쒴r;lbMFs%P ]ƺE~:WYAJu'u}ݍ~_+9m 2 ; 3Q#L:ZEyF/ :aa$OQGmr7TxԯE+"X+‘i'舤}".py̗q oum;zvuQm1^"{:Ս7XagNjɸ3k> z#H3^6Nzt67Z@1ZԜk֯_iU+F[:$f8#tM:fI K?;@Y/:2,N3F| u.y&g+NvQoƎ榐^_\[+[ 3?SSTpUO6zN it̑a3a„rsپ}{=q{ڃK,˯y%dJ $/^^vu{r~;q~S&i lz~Q瓟 苼jomb]yEUN&oaNjbMaO4C'1i#\0I+RܔdW:vqG|rUʕ+չ瞫;찖 1T @qΗfYӯ%GX7IdudFw} /l8wF5>@"Nԯ4i}T\/&ԋ@Y/r|@ԩW,GYl&olW:[\35F˃Ν;_ p$\7;NU/;4QG u kӪ>{ ~O 35Fk'NiyxU߾} "I$V3q W;(u %K~MC eDM @Y/:E.DT:DS81&VM0JѧX4ux(KXvd,_+Q ' .lڪVG՚DSIڝR۪-QSOU֭ NAcc>aZ\{惨Tj^kVʆz~AqGaW#N?ZʚJ}4E#<2h:5#|.]wFV IDATFHQQ{ +`rQCQǤcke$Z(3B"QԭTEvuuv裏ի3r ,[gGZkIK|ND쾣Q;DTwru⨉_kwFm6;1]>I۱`ƒ/q$s/ӬfGJQNj%JXΞ=[]}ժ{-vP¢n;%;h;~XOę/=i f|JW@9l|Iy1,ϧ~z乥)50I&e˖iz3x`%_ e3fẂM#,6$9RU+Jium:o<5eʔWz={wZ:Kc La_$ut޳>[޽['?iN;4u}^{F{o|:mi3_SSY-i&ky?yK9yzƍ6$Ai<.p"qr1^.yK^~֬Nӯ[ѣ!H~I#>묳'oNѢ24E/c[Uޫ-@N;BnN3_F'j>%ȼ7j(uSdXEɯuxx"m*3NVϑ?@YoCsu4Vkˣ6JKZ-'R'(+jOV\b*GH3y UVN|mwؤIђ%KZ.bbnnD^vOò1leC fhQG%E)_0_A:WQYuoj)?׍sY_k@UY]%{DdgJ WmA 9_BNXK%=2C%f ϫ{Nɋ˛~y1}暽iuXMߗ;|0ñ])eqFi>OCV$'`ÿVEDNH2sL-N߾} ͎2Gɟ;%B 2vK#G RÑTSLif͚F4FM>]S- e)q(ӰO2 z^/Z[g y̙@*QTb] -3N1[-eq.6[SVi]/oKVdnA*I#̝;f*MGhQ<ɱY$,Ȟ"RD[>U8#ߺ"YAQ:"UNU0|P^Uᢎ87\tCs d\h6@WE̗iD^zEF(9H*B)SnNyQgDb[Z?AB){م*xUANݒrXAvb|#`3:$u+Ԉ#PY̷_dO=z4إK7QHq!F kByeqF)ƿuEg} jǜC ̓Ju6orDܗm 2;!:[eRQG87˦:<\N2Ot,3RGV_ɩYJNҢ 5%/Bz7 ճgO%%/U_lOZ/jY-5L7<^Zݻ ٛN FNt=PKH6Eb:9p, jUE%6mZ.^xu衇6)"_Ə_ޖ_uJw}% 0sJS1/Q9""-}TacrFBb":X޾fcvCe̗Ct=U/>OG}T_ٳiUgwz~Aۓ':.j)rXAqOu4rv|D˳ʥd̋AlDx˳͟?_=J _\rI \yuDce= Xukm o%YRYݻWM<˒+G]ma:p㕓-dHtNvu+ S7E`N )%sǪxSQ:v{HY/:vZۉ:h!rzrt6+gEvuGsq{.Lݙ~E(tᖎ!Jn)E6Hg>m`[h#k\myQG\[VY+ !0g H@8ZGtN>`Ya0R"P N,(!sB3I z!h^D9D礼 `c/ P<OZ3O}n5:&Ld^P =ֹsvJؼY`RmXl 2&F .Kw{g-:z ұ_u,;ŗ՟kfwNK$)>t6JqQ)/9 t֊(:v=z4Q:}[ eִsMqlVu~ Y~ըBLT8KsFla3edұ_dٳg!CXnajoQe?xSڵߎ?vSmܿ^:u!:7z1Ȕ:[JKw<:2b֔STBsV\Mwިzk^}߾}WǏ/B̛Û:11$muKF0ߤIԲe˂-Z链`r6%P 2+ѣzՉ'إ89=jϞ=DeH~UeDF]Xq3l 2GF -FT]v9ϧDWzv[r%czUDV7tUjKun S]Z Sׂ߳8/N˧e=sWӐޘ,!}Z<)Z( =In[s<3+dABxh *KlǪIÒ>o&M_YlJ6ƫڋ:"ߊJ/J1T@e:cu|R5QK/U7oņ 9ľ |&Ou 8Px㍹7xc[sr'(0g6M8@glBLpMw͞*:"<~.\ 5:#rvlW:k㭈 o{1!A&N#`cnQd,.?ϧeqQoY/All{ꩧhV2n,5kڶm[2No߾ku)V0Diғɫ;"\R"zy睹a1^!pO".ɭGRPd*A]dJY.Y/Uu^ש[N# {Ow˭6+DIm4} HBd 1J '$qm5ϳRQ,~yʂ-yy'Fԉ8Q;E lA L"H xO NA4ރRR[t_ux@K!GB&};j@:up@y'URve=W]u:S⚚Kۛwy4H_kΜ9VZc5uTxbջwo+u]-ܢ6mڤYCŜCIf3j.S7pγӧOR do@e0&M-[h"˲RzR66e= t|;vl6oެ P'~uT fu7RqVZƍf̘xO"@%//O|̗ -nU NcFJlٲEM`c 56H@I!D_"qFuVBVe/:]{]xK"WD|իWCYpaCˆ^.]ѣG /f=lH "ZHaJYfM'EjƝ;w6I7p=ሧV?Iry䑝18p N "|.G4ɧҾL2E͛7/ֺ '_]ti ծ0k_e<뚽Ii]g|)u&RgE![&e/AW_|.ʻySnj&aA]G"†DhQ"^\L_FEC3"lٽ{w n,Y"[ypZ:t{mߵ-{m_"WeQQ|1ӢYvv*kĈ]|SHT+xJ0EB7an׮]4%P̧DR-yڒ[ ?iD-HYH!k!G -ͥM8IX/3˱>.bW^yeRA;iQ "u"OѮ|LGG?~T=uD'MXS_5D=ٳ1G=#y>׾;~z%S~ΰ(Ӫ>;R44+G_.OW=͛njS @4z|1î}fۊ o,[DD^Y/:EIKl6w<1*|u:SWڪ(A@̆pѥ"Xڕ/IHi(|Ux.4i %ԧTI{Z $rlSԉZ-SKLçh} / +ENӯ̲D4ˢ<ǗC)y&EN Sz0p93gq }y{h>T wfW ]~UuGO= _.Q'>!5;osOVdJwZ͗bYI%'OVWV+^%a\!I$kذaE T4mc(l)2"D۽!P>ǗCɡu<"1X7 /u8s:O,B*!r3nv$0 L3  mrQCEm!4bR0Q|]9Yz={zYgY TjTtmv휟^Ђ'v s{\ن׬"1PۮU!N65%d &hRD)-ˎ<˖-k3=ޔYjL2 6|IDÇ+-5_76_z)v@#dFL¶96 gY;}5P)AH)k{u;N/ Dn|L29φHJMKS*ve2SPA$ls-! ,鸙I#ՅE3" γy] KC!ۧп7qDYAq~^꺿Iƻo6jD);u7ڶە>/x?ϻdBFb uχk{uDGPE$s&lH / ؚ.aƍ[;>el۶M 0@-YDS܂7 d2"ވ o[ 2}]p^TMu.\*2GfE/u#4Q'C$\AԱ`(8n d" /"H@KH >%iFHs.J˯X*#.vV BT"Ա P ˯!ӾZs9a>aLHB#0Tf=0޺uU^"5Pԩf'uMWԱ% (GNWvi"k?g 4痦F>ߒ/gؙ:e=+-μv{=5b=al;E/uER6?+,ߦ0%ڢ;bINҦK2xΌ !b("#(Y5f'I}qb@ߤ=dOff1+_`Znf?\Gѫ IDATqAmÆ :Vq:ۖ-[7c,{ykޮ?Qq0h2x΄ $ %RUY;"={V;md, k)j~<ꃖȘ0wtpy:~Z?Lb-꘶MA"c J@"Fq…ӟcLFamA4$ΠA^`շ,m#j;E+ظ]/QqmAqM@&ϙ" x 3(gɮah»+#1 Dݻ*Eԑa.LԑZb\d/ e/ ul?$m|C#BQRQG 3~=sLK E,, u`Ov-uL!ID #.S^b R qU_|n //Rΐ@e )vr\rEٳ7n֮]fϞ]~n6W]wݥ~_toqs^zI/5jO~BQ Юfu{)sY;Sui6QL0H ,?2ZL!^e9L(?/,LQ.Rד'ixN D@LT?~\ >۹b] Q׋zQVo|Ŕ:=۶kRc,+)l^TKFDձA=:a˯lVSGIȮdfc173uѣG yfqiA-l@A]ɬc{M7u["&"C AufupmbN:Ai%^N p>P j7..E_"L2Ey܍KG/7E6#(mI 3x! @ٱc>}:t8Rb De5b'oLՏcqEMa‘9{]" 2[–CMQGvvAUpj_vNOlٲ.%!(0EdAd^@p_<.]T:u*n-(=,]j=]?N6]$sftH wܩM,Cjt"euOa} ~EPG9:8ojӦMNq( ǐ!CZSZ$P>&r^ I:Xv~EɶG (SAɰa3uc{LЈ'zeݥPS˒L,9sLd(5uLA:U1GkQ/uuD bĉYc|S"=L5t8P~̘1cb``M… rٳg ~Yv-פSC$S ^P_HK5]WsQ/uu0. |x+ǨQԅ Kd <<)*zB$?2#6nܨͯYFuttl@$U KuRGQ*c~5̴L}_:)#la_:w\-pWPyzidJ9:B$+d<:yѢEu;5$i$e @xuǏyE7>6-Ʒ_:)njqر.:I IS$@$?9Zj?ubX E!-t'Pxf,!#u2.([Y:@1ɔtH윰-1\,"U7nEݿP)bֿ͢sɖ>KQ'Clld`R?&􎞐 6;'Wv|6An'יOQ/u\R3CG|)ddرCM>Y:9r1ɔH骿S C&Eݿ@3|)kC>*`ٳǙ>&g @. S?s D-U?SB.*(Җ(j<3k߉/EЉ{G˲e4+WvYd7rH{#si(lp!}dAf˙3gt]2k,mXBKl:ϸ&hّ'O־L0A/wk͛7Z[ϹsZ˝p2*؟9sf=:s7Իwozj}*b0lذ.E[ڲc~<3ꡇR&MR7nԧx ^|E}]Z>|5ʺ 5vŋf 3hH+*_ESϩ_( TOw}wE熇'5J)ɭA E:R!\ AcZ`uSsf~-\zU_8Kp@sZm6mWD-|ĉ6.BځaLcKuJ8̚:Q Z~Gփ>H,1HZl9=v„!CtYZeAlݥj?X'|IzKwEZi@U^Oy@Q/P|͹ɚ5{)N@~a9Q^{,Vw|ķԢNP͕(A|]Ɖ:бEOz-A'TԗspQqE& L %BEgz)G)V1e6Iubq6??oQ}-tzRpm  @8:_pC@~hQ#r|G::_WNgB L)j<bMJ: q4E,2w?(DԱER/s~3]S~2_v] %SiX$&Ȓ.4:|:Q6?iD0uΎ>&̿ Ԏ@][گ wlY;Ή,EݿPԉ :gϞ;Zjd혙;Eg*>[ Q [6S\ނB2t\,Y d@`Jԑ=VKc 搶Yu ᎙:&'L:x6 oMſ }=Nn Y;GaQ/uǨgڢ#0 j]UE4kH`)c 湸\$=aEoM®][r&e#=SNR p,63{| e:h Xgہ =Pl*.q²Ɛ-pq5޾DS 9rD]t\I$JjܸqzGd]6hZK۴GavNxHJAQmݦ^{$.|AG/^5j(xp4UD5J",JE" ȲS>%6Knfs$K_ƌӪ#@xR08vZn]k7/kYv{i#l+/;Dۙ3QKvbMP1ygbĉov\qXώ}6mj&7bpJ!0$@\AjΝ:ɫHiӦ>}^ag<}dws&/I:+ HCG|);B^\ÒKSNy?@Ujwd'C>l6-R_򣨓3w sRQQʇR'vlp=)7e%FܲqU! ch͚5zC9qҿfOo= H޲e馛\(j<7{n_: {'sOI@TD(dgɓ'eE6zD6\_ ~ࡲuǬڇ{$xw ]"&m 3#񥨓O x!zR(=/kh$8 :'v##g̙W^Y;8{=/[L}v5c :tşQ,rvEb&*-<#aY;K?<:HҎI(CG|);B^'#<`n:l&ai?QE$ۧו+WjI|ǿZI>'736{=sΩS 6(,Zz[omR-9+|~\TmCfFSgΜco߾Ř{GՓO>pi?̦H'0<6nܨd&!vw EW$mEcȐ!<lH5꽏N<'-]Cn,YRFEp݇ a$_No8z)H#c#Ɗ:.d\ QEɴǹ>f 2,v|\#`cǎd>4#øI!O{Ib|h8q0aBϞE( oaCyJ0}S$B}_gQ=P7aG`~ޅ }Z/;(Y;>a; 2n{YgHƜn;Dk!ǏÇw;ＣFvj w|UzQGnky,7ԷrK _] V 1{q벏sCKLI>ܸ'}Ob|aNp$i|l-G2dÒ9sP!aWQbo؃M<[ C%L븉4%4XZ~o"4˂LsAAKLZ>f7}zd>={#u`2+,cqj.,+MJ3+\~{sׯ)nl :T [J1W+3/w)ooz|.Ynvϒ)j$|_24R=.3EcG Jqy}̝;W7{G=*!aW.>)7k>R:rhx;[\U+bF*[m [q9%zN#Va54ƜZT-=VmQ'- Q'AaOaS|CxP_a;_r>&Xd_g'~P131I?d~fwذaer u²׃2`4"믿h/ґ'đ앴DP%xp$BlulARd-\^AH 1UmYjLQx׭Ud 8P;vKtc uw&D,ԙb@s74{\gf<7luo%7HHX*~В$- 5YhG;C3M^ TqyݻA æ][3amb1mI> uK} {) f஼ge YD$lY؎2aHfIвi$Y.a.dPY$i g/2 ZdgLL<(c]|ϫlq')ˮ&T8ef^EsgaSNYC$^>_)ЊU!5$ƅcfA|Oc MIEy1^F9 ߫vbښie^I#:II8A:҉V}W1Rx SLJAtMtT m_bkYs=+Ue$fN,#LؾΨAEdIZn.#}ܬ` YD~ bW|0 IDATj[8̣ڶpK3;j-W]lJhc.1߷3>[af=d \#)T 5a>ԱӨ !:6s S%:L2ud%nL$=)l'#m~_wPVS'(SGC$ HF3ƬWSd23i"2~,HSSQ}m'FռY :a¬U:K>$~SA6ldeNƄ*+D ÿؼo&8= 3~YDS!Q.iBp_ T˧,@?2^lywt(pS, `c>ؿی͛$mp -uL78Q'C0DΠL#nM҇ؠm]O y qݯ? [1e>Qڛa([AK‚>q}gTjêYS'I݆-뮻42G۟v [R(wͥQf!oQ6$:]:BfvvvSN)ۊJ[xqbjf0&98LQ'(k=߱7%)Hk/9%<B :%YSc u0a/s2  ^pg#3EFuҤ'u%`N}[Ա$ -uL1uUĉ:/I3uҊ:aL]:Qc6c4ruL!A.5Shpn&uuDǿb&Bdcv?.e]W'މ`Ug6e^A_ISx B5{wi.&M.?~BNPx{i;l+sI\XmnŹiVr1ر ĉu3?{U7vyx$ۺ>}g"KkeW=|wٻy[6|<$%aAQ' %dرCM>Y:IU<Uc  LTGGG$awu1cf:iR:fJL{\DA(yL/4ػ坩c:5 Syqm]&/ 1GŲZs\G{){[ u59wޭE0whE!)I($s@Ν;մiӘ\1_E:"j3~+|XtSV%jUP- if}0QǮ`Gr8\a/"mk5b.i5@sT~dNf ogbTʎ9fe]SxE{5unL7QM*דBUhvQvLPnf战#r-0#)icavf{Gԡ^d\߿$NRRjacѻwN6h]|~{S[;FPsva?lAGet73 |/$w\nx̏J6@? $x>'LuEIl{960qG66Qt{rSO=1_%_ΝfÆ 1dTlS. tk~X6lzH2ԫ(ΘWTu]B>3~jy Ty >[W.ªy=1Dӧ;v(i^ &c m|v-~ 66Z>u|g " n@^߃{Zm Eq;V(_ppmO:/R'P6gP!P5>&]̂ l"T!Q2ud{[4߇_" 4Hp;vl}y( #('<@q5lM(7 b_7"ؙO8>1w& .Ԓd Ŭ1PQGD$KG@脠 $mqfV- )]yD((HQG@>io\7꼾4Eq7ŵ=-tvvvy#X'UcJ*H&C/ID\c/$l޼KwÖ˯e+fOl/\&4&2 ꨏA |^RQ~%H,52]~eb,-eY!l!FW8G2L'D}vMo١ #lcǎuaR4] /Mט@])L RrƍWaS4] /]wN:MHU5~.^X RIFJΊg#`g K[n˲XK'ˤgI. $c7#F$/).OFG>/LHNXZ: e8KR(ꄓ1:$l93-ꘛV]k_icFic~f]/Q:*tASՔ\<,/]T:u*'<!_WWZǺDQ2(/o$[gǎj*/Iݥ/D6}^;u~CYcuEz~qmN46]Hx7o|NOAe"0m4էOiӦ2f|-!l|aa%u:x8p:{B6BN޼y{oTf|ƌj8,L:UrJu=tym„ "O߾}gΜ5mOq7z駟Es][8`kٲe^G/~}׮]o:|p|=z薝0L۟۷3f( avU݆)Vfv=zV^b&+>3KxM549Bx/ŋ'N'PC駟73utZ3Tw'L]Wׯg-]%u:dUX<ř˯DȘ5kBm޷oh`.xeСZv  WǏҮ'rlBKr6|:q\{ZvI+VbbooG;;sL7v鯜k7[W*/X%GQ.]j,cvXWƍu*nӲU߸| @yꩧtD sΩ u6"i"!cرs!$@wgT]&[Ȉ6L&&8=S2cy1bK" ڕsm{ȨCQ')|MKzNj+0F6r2WǦ*<ڸqƚ5k*_xHQ'|D$%*,^$=%Xb b„S1?*H\:?Hԑef67 1BN~Z3 M%XuͲƭ2W%W@t ƨ1ubk2's~a {\F:uLL  ~˘#ʘ :?Hԑ웠 KC²pILd$Ed*{VQ_rp9^?ǨJ)N}H2CHQQ'n+dvΜ9ssV&vmǮIc=v?i3uLkv" `YhR4&y(n(^,D(#0k-[I&L~dE¯r=)긎z4%"qH!LO#O`n-UïOʡE}7Rԉuy-kJSSǬI|/l+k.Q2 %}k a׭$_ś:a>~e~_E&.gfajvݷS\NB׮k{u\G| v.9"G3G 7],*aV3ڹVuFH~:I1fWLoӵZDa8SU~õ=:U] }1h6*HAc{XY@ ʶqeq*껑NG^2Tz~qmNG߯c4[cR3FQ<,CgeCFXucY]ҹ[իZI7>(*Kv09'PTLQV5E}7@޽{ëN]JC!E EvH.||ԅ @Y;yfG'F Y;GMQߍuLjg@U _\ۣSՑEIKAca Ξm?sya#-KlqHQ>[(긍7 w>;jIG&Ny!PǬHQGFIT\/Q)p3$@$OA|< ʪqe", S?ĠknD-}N;$Pr(|=  " eh@;\ۮ߼8Vw#DSÆ E:uIu 7xmIj}5rHuEgt! x%4(E-s8B|'gT-껱.Δ)SԝwީfϞ2,E'uV/={8닏 'lId$9I| iթ/팂"uҥԩS턁ג@1BZJEWѡ ȁ/f $u-uWҡSwc]Dp7o|ڹsgR<jM`ڴiO>jӦMNc4D4F$@~ "17E7jXd4{҄> QKgoyDioN85v`@ (cƌq.>+:%TtHl>H|3<zDv|C"д,CROIDKPGȑ#ҥKI0 qR.\|SԩdGH@A->Mə+M{QKEeoQ㹌,蓏RԩHaHjKAmac"[pޙ&f)_(~*)EB:F}ėNL$P]>KWnU]_$RM`RBQ'9i 5_:bHH> m{>j޽jݺoHѣLJn@SR31w ב@7Eg">KQ'ر pBhb:˖-S6'NQ@2Q2 njdҎI(CG|);B$@N"p@FQ!;#;x}ȑ&@Tɻﾫ,X֭[>:z {%.+ye䕑Ww#EFl)j<7rq_:œ- @j>R; H L~[[ӧj])1 Q… -1"@9{ڶm[KC6߰a8y;$W}㓧:gF^Qߍu|f-j<7z~_:ŏ- @|| @aΓO>}QyfmN =%IvgDmʕBO?U-jGsLbU޽ի[cEv>Cav!}ԍ[%mϚ5KQv7;a„Dnv 䑑Ww# $KO%@QG_h;ÑF$@"㋠Bݧ&&Fɹst&AzlSl4hkD0l0'[X~5slX]jCjaǖ-[ԤI- [  YbZ~%:`$LGDϽm6H$@B T@Q7BDWKJc)[fu#P6rH{negֈ)eG6~%1Q:6rCRGyD}ǭbQv%^˕]ex}ȕE/u\EvH!@QzHr&Pԍkds5$[à:dYF-^ؑUEY;E/u|2%HCNZ<H &Pԍkf5 [ :B3?wv: TEJN 4@Q7M~#e,1;QT,Y;E/u1 ::U 'hn\uBbgȐ!ٳ]^|x75jpիWI5ydu4M.Y8;L#.uiKE$Ex @Nd&?:ڲeKΝE˗g͋O[c+;^U]I Qg߾}jΜ9ڔOMDQ'h$@>PA6IH:Ҭs8p:vXlf8G]Y2< b⋚ˮ]x 5zVˤIƍ{wV K6oެ_۾}{kӻﾫNN<[re++LիͷzK=zT/7kQ#>˯ ;o3fLk  Y=Zm۶u{+vTĵ+N& @E : ]UA: 1oQA@6 ^ǁ:5(-⇈(&-W+VP -φ Hd:'N"ཙ3g%ӏkKM7(;XReg|СCizvk@Pi^c S5uٱc>}:t:t݌,:"K2uPG?w IPљ:.Dvc&U N /I)#t8t$zȐ! HNFpHN>@~²s<`N~kK2Yr;B$:$P+ujNvr#/\[P p %Y%gL:I( (&L$P!u*,J%!6;'mWvJn@')- '@Q'=3^A%@QeH94XjCC&,EliH 9:YL=:1;HNΪm )5f|r;LQ _W @:$@-u8H?–瘗yGGC9^S9M{x[MPɓ6"#@QcH @,gj7O e4ED:Eg$@B E PeşY;(8nq7q ~N @:$@u8H -KlpT@]Xگ0:e#fӌ8$k$ēH?vj?w;mԗ}/(|Q5hР2CHJNCn@:$@UɆQ%P얪_ޑ3:YL (cK$P9u*2:LT*,`4@P}vS %h : :La(pl@3 T=7sԕUz?1-ZT. N.@ P)aP ENQ. CNש/Ō*cSA4( ҄#uzEM#@QigI EhfԵ_lY;)~LyoX^' @ Pԩ}AHNNrV<J 7UU Y;-u#zHM @Q QfI !/nݪ9.]#Fn _7N͞=[ynWZӲX ʹXTs1T(T#NNN#@ Dy7xC-^XM8Qp )$￯8e3Fmڴɝ[j/M{d\3kRCCQԩV- ԕEF" |:t._vܙ#^BL6MӧU>C˾vSZ:OĚ: =&ZSp3$ע\-]T:u=x5 x"0bjժZ./ x 5Ȭ1fBRhW!?8p`~q f$ЅkQgʔ)aKx@ ={ѽ>1+%dZ\e0;CNGI.(% 8 ZԹɓ'YCAlh9rxr_'xf0vP;2!@Q<'$du},E0A 8}'޽{ݻՍ7ި>Sh"uYϪ}p1ͬ'Z`ZnS!};v1cF>Cc=Fg$]l0afyi] gĉܒ9 ch͚5zC9q>EĊ@ Pԩst7HI mӮ%i@Zi)Sɓ'k7ƒO!?*;::.~Dp#Xt=ݣGP.̚H5dxr$c(9[-s1ԩV- ԎEڅ"<&iŵ$mHK 8P0sL+"H ^۾}\СC\y=Ae3S_ Mq :b'OqjavN55DǏĝIH:0 T@ڇ۸',ҎS76oެR,S@8wٰa^zj}[omR9p )|ݖ_ps~-ZR3sd.vQYKrJl`)믿qXbZP;AJ l;qKMSkLzƍY2H(;>BNS"~@inL',S3yc =2dH6 kwVlb ~z]\tu CI&uu$i֬Y]2j꘢Du[scQs箻ҢPKL3vY8g0Pj…ã~(/ TE*F>'Yn\qmSi0Q(آOa'mvVg v6AuƁ{IS'hy=pDoav/o߾D5u>iYDN(͐ DB$"ӵ=|2NmQ~!+DY!EDs^eYivsr5"w #d` QKKDOP8/~7qW$k"T.DaK'e~)@~3 (EBq(7핋 ,4HԱq ԒIeGNc/⧝gJj-YD:Adc=SYz//w~waH(2,t!ӵbպ(8"_vF dL2+;3'n{wӮd$8$,/'Nt*X~F9 u~)'yEQz1$PGuU2p}^n2$d~'WgNev,2mnH#P2lcv +svq[ۻlɎ\X%כ;ceIɒݯgsC RSE  2S(( 7 *YD( \ݰj<(S#Wg3"\ ڵR_8 lE٩N:g2/^N؅+~{+y 3ȬDX>qFmn;a ( ,P֭; ٻWޡm@޽{ݒ$ɴo.1x Au{YO~׷~!Fҗi8)|ͺA~IA>:&hPs9ÇM 2ċ;;]>>f$Դd~,W^yEgew|srSӸu A&@QgI "LƬD_5mAlaWpb ԁtQfٶo.x'm1Ww(2$p.˾b;KJL\,n{W?~\׾hO>Zqu@$җd7;vbo ;vіυ_q6.=V^}ոS~ ߫RS11 +Ø1cZ/'VstN. @ :"$@-euT~NЮ>&ѓ'Ovi*,=LH"l=hK,r!|lR|;Gie3%黙QK*xȯsND[ǵ33ujH"sG:a>v7(/&HN>@2:fvΰaúed1 <2u$ 7F8'H k>Rv\%~&uLka}xUuQ's4}9sS}`mjQI,5\RW,=zt3U(oo _BE<$@u$@QQeH #:x?|p|kرc[5`DAԅ1ke5u v) kodj$=Xa۬k*A5l x٣5:@qN$NW{…_~ vo|C*~Ů]ei "`w`bf,n5⣝%c]v̢x=hxPF_qvs%XD;GvuVobEjŋޒ@] Pԩkd/@,&_[7f |"l=\,OB- )BTԁMTnW؃,lš{9lٲV48A̙nߠ1/_'aATN򲥹:kVPKf!S _KQWux ]Uآ`H+n.n}zK8²\cbvN/]{aJ]:$Fӈ0$Og oI)ĝ^͞=.6]f~Y\qˢnhL1dҙh!̒%K:fqx#L1ip](i</:$@e @Q Q$Po>]+ ƹa?8 @Yǩ[L1wg M$|dk5EQǮoϜ9\:I.Ү::T`=S;h :M4I tm/Ax &PqnFHLvL,я~ﶖ " EguڍE jAK- H._}y &$`p}F>TafWvE.,Gَ1E!Qq5u_ :~*/O(Ϝ- t'@QHEͧk{  Pq%S\vf]Ѣ Eޫ![P1řg*)m~%aEóH(> mֈ{ץ7C Q1xD IDAT]$Pu A% ֵ 5$PqZŬ_4>c9Anݪ.\P[+W={v\{3%@Q]H:.( Ԅ[j(*,Y;Eb"GJ.yXFxq5|nywԨQԅ T^Yz [kp< JN8 [Eԅ@)I܎Bt˳quye˖nݟ;w}/_D43DW]w]-N TEjĉ^@.\?ܺ 68UU)cvNRM3p@uر.:ҩf<㼦G AN T[*nV@])L E7ƨ!&d4qCK_!Gי@~mԩ@bH(T Ht"@ /a] 5J3~Y, -jAkFH(40t @dR3n`;xm 퐢NG F!@Q:$n1j! zvKw9(LEn @]?{q34D$:m$P7 Qƨ1UtϾ = #5YOV>g%|lݺU}ݪW^PK??YS&S@ (7;e>0FM|5O~XYF-^8if"J}Bs7o Dd5$=l#䜤ǝ磭4·~Ů{L=:/_ S#FP80q1fC$@$`1A$"f%˟HyxF"4D%Qݰl+ȇ'e+կ~U8p@g}ڵ+TܡE;$@=^K5#P@Pzc - ;&Ǡ-sEq_|Q{eo:|ZlYodnf5uTuI}NXO}aҤIjƍݻՠA2/.ھ}{k׻ۥݕ+WW^m[zX޽kOɨ_:gdHAvx316=%o ,P֭S7x7T+YU̙3{kYO9RvSn=:uΞ= ;#v:EE (p< $!| < ҺєSl03rx4gutt$(rO"@D;S}Zg'GQ/_<^˱F~ӟ3gΰN<H:0 T@գcǏÇwk… ;t-@4/"9'1Eߢ3k,q$˺$BD)H̥I'[1#Œ|:Q33>4"K.tvvF~d@o}.8[! u8,HZ|` "TZYTLNв+ ^Qgnc+$@(pt P)@ձcǺd0KAk"9u쬞/̠Z/pXti5~.KD xc1F}vhY0R'd.k]wݥ/M0qe]fYS7#3n5A*zFE}&|>$S_5t)IK$`@$@Qc ([Y:%F~}̘1D@lYSǴo¶ڶ}6wr1 [xW{o7QG] )cפ0?`+W"ӿ_/AD\bפLjΈ#Ѕ9nWN3H1[ (a2 pA-ܢeٿ$DDlc-u:ED(#O<>v-$)n>lTpw~ǢD<^E$E7ijA N-:[N:sKXKbAla`fcgI޽[o-#GEc,ӧOy;MHjONC@rov3HΎ;ә@ok?@Qv®=<^ꂥymK8y$$AQaS$8urv !ksN5m4fEKk9uP8U8Ɓ fVln<9_&8W&Tt?u "$F @uK:;[@OG}Tm޼Y;AQXpo7ן:/ TED~@\. 9.]Co t'п5n85{luwQDs9ɓ\~fL|mIp?X:5u - F$Е>oQ1yZ!jŋK烢Nck$@(pd KSN2 #ԪU+踞_rpMs%Fs"AQ' Hu8@H:SL˨_ƒHu >ٳ'S3&MՎE v*IN%FI7;]w.|:~E@#G/oEIJ p +K|Z:ϟgMʎ :N @Qqd/H עk{N:I#$`8gHs>!gR=>23!\pAիz@1 @mPԩM(h.!-@w r·3kÙTju71 ԑE:F}"\?t[,:u^n}vu7w{ƌ9x l^Eie?fg+Inu9^+:U%\?tgw'P˖-k|R=zpJ xǜڭO?T-ZH;VAOE ,P֭S7xcV3{Kφ Ξ=״w o/^&NfŇL5t8~i5fi&PqI2/!ppڞp"γ>8zh!?bD/ :YjW,\P۷̕+WTϞ=[c]y b!GQ.]M@_7N1؉ǁZ:̹G;I$@Q(p| a\G|M"(0i$qFݻՠAtF͛kX&$˂CxoʕZ@[Oa!?=wXzu &t鏙ݙ~'h :Tv^|E]KÇ[Mp̙3qNA^zU}!mC}oYeſMkWZ]_S'| ? ;ＣFM$; ԀE] S $[q3" kG2y$kpՊ+ҞaÆa- u |P5hə3gZBҶmZ\̈kȴi+0hG1Ӗ[HùD ^f<7'NLWbQq$#iMY$duxTI2ul'Lԉ6;/wqG򫴢,C;:m3~yƁ˯Rldr-zY~A$@U&QooUH(Ṱ%GiJN*@زk꘵nmm}9sh6fm!mr9Ŗq*4u0$tIL$`1A$Pu@%!p+b{G-^XM8Q녉:^L Kdg&*6w`_{ "vx ʴe3HqY+l-y](Y_ږݯ҈:ghSVܖQܣ8;wPqE2؎dرCM>Y:~q: @(M A$"`>951v*Б u\Pl;wiӦ1K?n@$:9f3$@(p tu>c1GNAS'uG"n7[ ȇj\x5uVHBP "`u휯}kt $9P EZQ]|!mz` /` 1M4BŤPHRp B1P"@x1*iE,i1&xZ `[ /kۧ;眙s̋pΞ}sv7я~prA(u.]Zp((D&!qKNd2D?Q\ROC)9L.ǍX D 3 ВNKD @u4#yԥ*i8Ց\i^D:dMsDБ"P{B@Ɇ3@ B f_'Y(_eҚ+dlyHc.DTF9q k@@r:əqJKُ[sH>9NH,ВNZ5U4"Dk(2sez9@)A ĩXq׿k9m{-2@DڛW_}Uĉjĉ?VS3gά ٳg3fϟ/ZH=jȐ!Wm``@~zfgW@oܸQM-[f͚EYvlFod7T5߁ëeZ^$0IM'&pQGu.@y@ɋO׎aZB`T4*lҰYt& D3% 0-g\QA:۶msleEߵk-[5c$JԑgΜQF1Œ֭[k[uWRiVjҶ'MQ%:NQ2ȀeV1n!-*RG*z~__i:VC֩?*іsOSҎ^:_2r%+~&@X|m/OZQ͋?{\~}+U{x#={^ۚerxc*uv+uܿsAlSWQ}siʫz&ydm@D_#  IQiiC[҉:U{K1mڴZYmѽlO0a7~ӟu쓲aN͒)\f$_W119rvjDxUu,sON& )DN r? ؀@Iq^I0wFTO rgA"@hU2âMQ'zBQ'L ǭo{ D)`fBuNLS3E@=:q.@/D<BַB` NSSj1@ IDATcKO>N$1tBQz vĈj``@9d,.\ŋRq\("v:W\Q_W @ԩN- u䔧3fs3yرc:xڻwo3gѫ^0 G Dub0 DbE$[ԑ˫WVN*"|ǫ 6hW*]K"1Cu5|@ /D uđŋݻw7B sU]]]j֭ifY[W !PA:L:!C @:& 4D#8qBXBM>;y%y9t萒tPR8C^:׮]S_Ww @ԩl  %LK;vL]t ȅɓu*nZKCŤ0D '!D+ț@Nޱ1?Lʕ+Uk!D,(3 ЊN+B @ԩP 2VC%Ú@9P<):' M@Do_rޮ0? Pa:N>CQ5r%~>a#!h: @ :!d *uInK'TS{QcƌQ7nP˗/WgϞU/wOCq +*uX @uC :%W$9sYf5k֨7|S'N'TXB駟Vƍŏ"OJNȏN~DV P#b@kR3|^WϪ!C(Yv~m׮]j޼y?=rHgj=T<矯0a„Z5Qk+GY&rs5#ׯ"U;2 ҹ~:=uX@urNX0 -W۶mSx"bǵs9-lٲEoڸqYysΎj9"舀_%DrU=$,.^Dyꩧrݖ&ҥKպu9Il1N}ZrGSA@(Dԑ/~@$S2@am@ Sj*]c =[zzz-suU˭&1B"S-F`*%e˖闥H*DiӦՉOvl%,q^{Ms=5qp3U2bذau"a`{]]]JD4l~O-dGbk:rQ(TNON8NQ'@A4u(q}viT9ҮR|u6oެ+XD1UDC EXjy̙3z@lƞKxOu";q[=BQ,$NJQ+N@V}%Y"FyGuͤI"R'coMjZW@j$-aٲuj!Ӈ'KQ~+%*O@zNW /D|3;"T:pV@"#6lGQIE'$ԱfuwwkqH~uYfyT<#jǎJ&.2U)c"s\{#8&(qr#6)!UHK1ie P,:BuʚY@uڀ-HTQ+Vh9|SQU>{MN?KQ']X@ԉljQDJ $Pʏ*RsW<' UlBI $%xNKhruNIi1vڀ-(8:#CuAG:ab -PQ%BN˗S"@3"_R_@ 7:gbGQ'M2E;- |;-2XhWGqOG)[V^N:-I`jÆ ؊%tSK P:IB }3tr)OjG `]vyڕ,-<^~euquYu5m4%P'n|rm6=O=ztmn[dٴi{ĉՍ7{czJu֩~5tк{֯_֬YSl/'x›CuϞ=[H)\hF@-wƒQ? EQ'/ %r~:0F.]Ő˗/UЂ&%T!GD4q3BoDy=uԚxc h+u[^1B C'h^3auy*NSH(DR iZ!Gi ˶E~LٳG;go}&DL ׽e #uDT2cƌo7>?:OHQF%Ktf'N|^BJ>e ꄻ U"Sl+Z(CVMʜ+k#pk룏>>uU[_Ut*"b UzEW/Meήʲ^u ,B $g(-wZw}WoɈJ]cz4l_/b![|THLʂ滩*gY֋:~V 6 PFey*Sn>pG4nL!KVw"}fQG.jj.,x2W(Q݂e7V}k%ZJ֍+ Z*u쪠$ 0J"7.˿Jwe%@ W:grE!'<#uk?SuM7ʇ{gJ]d]5%ܤ` ƳHmmeY/SLQGd N8N,YkԨQonAV{=uw.7|Y1SV[DsY%l mZu*FYJ$rN9HB/#~ھ} >} jo>Oh],z)KU\ 2@)S6C).:zz뭷uIvAMfYSPD-ݦ:%%"Xʲ^(6Db!'^qz3UC71DI{[{ܻǪX)z)KUYw @)kf m hVH]wݥeK'h v' VXIwM~)p˖-':>GpO>>宻;3gC_/qA%2Ny+B\ǚԮYpޒE/X*9iO|Ə߆+W+V4wCĖ9s樁S'NP'NdQ"Tȵf_Dyi&/NGL6>Όp7  t!P&A gH'aXuvޭΝKNة ;R>O/K#={V,[?={tՎ]ߏ7n˗I&Fl ?~{ѢEz~{LͬYr_^WؔիW׶_#bիWնmԄ t\5+JGj1mڴۗL2\vv$;w5TC}&.u֭[Xvj񣧧nȑ#z-5ctu%]/Ig5,qdŋy t ($NNYt~8Nع ͻ*WT9Nס+{"<3^;rKm(qC[DT8,Ν;m#+Ĵ~%۷&@bĐׯڦd:ג%K=sLmjOE${+c'} jwi(_Ͷ_ :Nh3[l٢k5c,e %/f@P|89x𠒆ǎS.] *nÇɓ'>5cƌVZj&YSLQoF[y˗#w۱NK/%uLḮqn|lD Өk[IdʹujKxe DO>D}_Td7v6͜9a-&[+QG6cmƬQ+[=z" Pf:e.A !Dŋn)՟>}9rdB?.\HغuRʕ*钋}wɮr[Ա1/`E5f 9JivueNEW{zȷCN?@s:@F C~R\"\rE@H7QWWW%CYXN:+4=;8=uBԱ4ˍ3*mVR-dov_3v:YV Tc*Df!A Cy+JS:uPއ@. 6Tr+/SEKb>c|cύW'O]i*Jܰ7:?&ΦjfժU'SGo߾]I#cӧսޫEJ8=u8ƎIlF?#}QsTOli Q'O:s@U S,#bh硼ٳgҿ !>O">ݻ7D2-E?D[QGO+sӮ\؋3j}RӯL}Sӯ _r4I] [䭨SI[8W ]26f~]Nܒ/`_'vNBʜ@a@5>7B8b500@XǎPxb>fX+]sVl5O{>ﾖ'ŵ/ޯK5L@6u,(Y"N>eEz)~ |{B_~^p  !:j|?dG `Fz^H/qƥ-T紅mM׽o{~JX/f "@)b)^Jaάtzuhh0y)fjm/SL9Kș(1D' 8Z5LC2{Tkۮv#O1=nsV~)Djd'r3`vx޷=c1$/@ =|?d8ۤG6Cѩ#l!JYi:Qɩ.6mR=vINA T^U2yT\itRb`+_x MQ'2%!=sIjGĺ8q5uU%Dz"GǸQZ|a.Si̖+ĉ>؛5k#s%^=ÃSb}XZ\wyuYu}Ӟ={Ԙ1c S1wM~Xg@ *~j%RyuEm#r_E׎]"S'-/JiCT%O+:2lذXFŌLk"zRDi?ֱ #c!>,g#cǎM SXӨIfqfu^4-k3 Pf:e.A !YDV: ނeok$4KZɭTqĩ1D*\\4۝\nv%OQGu\&ƍuqa-XQ]y,goo.vu~;ƗéY~W*&{ŞJHQI%$KC:ٚ$"ōNժ*(I{qciV!f[sEmھfުRݤp^~|_'6[dfy{ݏ1B #G;4 t/)A(Db /! :9JNUrEWo߮)ӧad\TݟǶ%ӯǏQ3tA=uT긜Xdzڶd#ڎ$M_Nd&}#J+Dazv"rgyF\R=jŊ-:%~N:ٳՌ3T___[_1;vPT{X @ :p* IC~{z4:cNLrO-J|I]D~%ۧ/It4Aeou͛uc5'y͍c'cUaoժUt1ʶ+6NnZ#jD-sٶ~e1mdE2velB~sr:NM19_i}{zjuԩ0$?^mذA\ 9Db!!߷Ҁ.P I% aD$s:C)FU;T$giŋ+Wݻw26K@`ܹKmݺ 0 ꄑ@|?;V$5\QŰm9=zò=kܸqa;_r~aG*dSu' i?~Xv\K;vL]t '0|p5ydo-W_ BQ'@1 ~mT:tl2l8ǝ|%8@@uA S} fdolbɜY":->9.lƑl83  @ m:i> DCo{P죷}vMԱ47e&PξHC>p  @ o:yg!Be^f8q/IRQ'4VfP*'PQ7 N2J<耀|:vt9_0aڳg3fdڵu'#tr-jƍu>e͛ks?^={V2W> dt \IDAT۶mu_gΜO P-Rr$TѸ@H:?3gGiӦ)[wuׇk׮WG:"sěG>@%.9@ ~mJBEY|5jj#h4I|MsΚ"kذaDyψ%"۷NXd^gOOk2lQnj]`7ofݺu_2eX}}8>U޷}=z>S_=;.gwB;n9 %2/C ۞TNT)?:E8| >nOA_~] '61M6i}_q\\1IvB]iś(QG*Lɓ'u2L>CL@HNp1 ۞/DSb SGԑ{WsU!FTԱ+\QGܫQՃʌk$02񹢎]t-mEB]E`Fؐ']c*wu{d9ۘ@(Dr( |Tm[QcfUiVcoJªYUR#d":IWkl?ICRfRSNl[NVm-V\:цNX NysKdHLCo{jpC:oСCq̸8ƎSu\L_Yؑ9 .aآӧkL/wk݃ǭqߥ1i+>턺N}(QGֆsDđ"H#q,۲eKO !}H@@ugǝ(HV_5&"9=GOsRݵk\WU6;#:-UF_~ud,#[l;DzJ=c4usD, @)O.^@#)0\a)$:KqDKT 3̱fF@@@uNA [}˖F!di>ݭy4Qryaݧ  dEy P}+B\, i6Is6B>b @ l:a )#F)FiL.\˾xb[&/mmO| @ S<?{l5c ?@7;v{6=wF|tƏ!@@ %~ȗ˫WVN :\`ǏW6l#W|m!@ug@,i: @ ܀@zaGNYb>}:=vBHvE}:RV,_r1u%C ÇW'O}rm L=֐@` @ ;:ٱf&OSQ9hݰV+x@hN%$C~I%Gu.)B КNkF@e~Q9CD"K%| &Ӛ# P<䇟jr~Qk"d !@ fT᧚#sG={n-<Xa/A@ԉKqJ;#! @ D8!?D_vM5Jo{ｧNuyu7̼ @ )D!?䚊W^yET鄛*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-3.1.0-1031/docs/files/stepping_protocol_scheme.png000066400000000000000000002267771457701673000241060ustar00rootroot00000000000000PNG  IHDR"%9 }tEXtmxfile%3Cmxfile%20host%3D%22app.diagrams.net%22%20modified%3D%222021-02-16T09%3A08%3A42.734Z%22%20agent%3D%225.0%20(Windows%20NT%2010.0%3B%20WOW64)%20AppleWebKit%2F537.36%20(KHTML%2C%20like%20Gecko)%20Chrome%2F88.0.4324.150%20Safari%2F537.36%22%20etag%3D%22x8GlCYrDLk9rwGrylZmj%22%20version%3D%2214.3.2%22%20type%3D%22device%22%3E%3Cdiagram%20id%3D%22C5RBs43oDa-KdzZeNtuy%22%20name%3D%22Page-1%22%3E7Vxbd5u4Gv01Wad9sBd37MfWSdrpmWbaSdpOn7pkkG0ajCiXJJ5ffyQhMAIBwgYnOWnXamsJoet32d%2BWxJm%2B2D68i0C4%2BYhc6J9pivtwpp%2BfaZqqzkz8H8nZZTnm3Moy1pHnskL7jGvvX8gyFZabei6MuYIJQn7ihXymg4IAOgmXB6II3fPFVsjnWw3BGtYyrh3g13O%2FeW6yyXJnmr3Pfw%2B99SZvWbXm2ZMtyAuzkcQb4KL7UpZ%2BcaYvIoSS7Nf2YQF9Mnn5vHz7Y%2FfN%2F%2FPWevfhc%2FwLfHn735urr5Ossss%2BrxRDiGCQyFaNlj%2FJdGqKD5Z4SelbWT2tbWnFwIq%2Bxckun8wIpYELyfvKmf52k2xJxSr%2B%2BRMmyY4tPkgThLNQlGzQGgXA%2FxOhkJVboSBhxVSShoH7hiwyTi995NxmWZee77M2cIqVn%2BFUnETotlhHUkGxKKQwHepb4NyuaUcXyEcRfhSgAJKqXCwYbCz7zl3sc3FjSbT7h1Q2NfPk96IjOHH%2BwKV2eerBS9hris7S9L3pHGtLlt6%2FShLlNz%2FByNvCBEYsT3K1mVTEKI0ctjw%2Fd2m6dd4bd7d%2F3wDfv%2FyCjCsmFUoCojVsq4%2BpNZmlkuYwUXgHEe5itMMFIuiDxLvj1QswLV0X5YpXPyEvIHLILIpmsIaYPVENna8iGxB7q6wqlYpMvVKRrfEVZSOuVYTlDexKxUJSIC6XwD9KI95nUX3Ik0y%2FxGosXAiDLdhenbolklc4oUoJVK%2BkmHvRVC2LF01s6FpFs6QMmVTn6jBRpoo6l9CJqmT31HZa4XDaISyn17WjTYuG0w5O2PaSJecRWK%2FvgJ%2FC3LRbfsIMLCdk1q8U5Q8mMZ3cN7iAaoQP%2B4f415r9T2uJQxAcXsunCCXIQf5%2FYurXt1sQuMQREZnFM4TSxAvgNG8LT0DWHN8FnJ2NJc%2FWmlwREfP7jZfA6xDQtb7HSIbXgrLbMXB67YM4ZgLV4VPIq5dg6%2FlEsL%2FCyAUB6C2GdzBK4EOr4LCnM4UzagZL3u%2Bhi6ooLHNTwi26MpKoGTVR%2Bw7jltUYABgYTw4Y0N6xErJoTNYCWZL%2BWZU1QUySlKnG%2B0cG5A%2F133kRtFrFMKnJVau%2FlBM1syZqV%2Bhon3kKWTxK%2BnjZ2nvs%2FPf3PR5t8dU1v%2FlP2StndRhm8bTJaZ%2FA48rKu91P3DEomamWyon8ZDyZr8FRQ%2Bfb1kz7MFxrzKoVzU6Ga%2BX01GpEH6EQNPjY3U9yZ0VhA4mfzWb40Q%2FEZDKq1FtRxK3AB%2BhgCIIyhIPCEBJ04gV07naB04hAiuywmvcsxo2XfYNcCiawncKDvQceaY7aNCw0l70GXgUAG7RdpnE3FJMBV2UDjHXyLfC9dYATDrZAxCyJDC5u0AvWOGXtUzfUpE%2BMMfFaRVkVrQbYdF2A11R1AMB2%2FuFGQx9Wtrm513%2BZn9V3yeW%2FE816zDizj9cS%2BFnOi3V43YH9kqy%2FOZL%2FUBXT4EXGqkhCg32v1TS3Z1WPMzWlfM5QjsBudASudyc0ZMsCBU2cDAYRixWtl6800yQmTcM9USq%2FXxe2rp8dnIuC00UEQQLJHNGg1EHBylunEcn5Y4Gic7hM19cJxF4hog2Sf2NvG%2FqQDgiGReC6jAQWkg78ZYWsNcCiG7kclqygmdulshU0x4paZzKhxIsKWg8z0QPbWFWWjFbV3ujfnts6L4faWOC%2FGWrLxQY620OTjSUMy65oRNYDybf1CjE%2BsleY13RPxBg9xTh%2BQPUckzESaZEYCuq9tUgzOdk5ZQA94%2FkqwzKkcNFQYpvP6hFhbUPgNQw373Fs%2Bmgh6qhjIPhpQiPtDFeRJLojId3v4PP44FPPt1Y7g09ltOBTrS3OEw0%2BezqDoU24LL45Mto0eQkxjQqXKEtK1qJWw7KkrHNfqNTYkBD7DGb7c9Ubzfb321FlIe2h0XK1EzSoXcPor9U34CULRKJZRoBuwdpzikCX8Z%2FUMIfUor3p3qatuZqnG%2FznPUS%2B%2FFo01eF7wjqw6U4mzGeQSny4StqHMM4m%2FAJQscdJsCVekK0WS9EiyY8fy9TzXRhNr2FyhRJv5TmACMYlinhJeXXz95eL192yQCbleU1TTget0sAhIwVk1pY49zZklongFTZtwTIO%2BQGL5qGxR8cP%2BnqHVXM7vdngDrpYQac3IL6N6b9dBypG7BUVnV2TlXl1kNyQI1Z%2BF8FWmOg%2BYPH%2FlYWrnBzJ45kuDm68nQi1vlH4ApmAg3dGytRdw46%2BqZ54R7%2BVZhiD1dPs%2FKR2scN2MkZCN3hGwlQqjIT0lr5V0U1bbsvnWJ4xPyI7CM94ANZulZbjsXYfF5WxJ2lERR7LPoq9DAGLPXvZTWGTnxyAgkccjKiXaUw2rA7AKVmeg1zIcDSDPAo7L8BRM92DPxU1Q8z4ANRM2dIqJ%2BJpCqazm6ephOvD8TT2c%2BFpjjwkUDrFPle5U%2BzqVKH83qN7T0PoFCXOpGujUEY1BkbN3WDvAwoaX5FdZfSH24hqndnxWJ1G9oPPoqJJqoDCZrd4Pj0WfCmlv4ZS5oJQ5EJGmVBkmT8IgevmVI2itLmLJl6mGgAycyo41w%2BJ1GesAnu2Qei2XLKJSMrPW4QRciA9cMcdqqiTTYJpxLnlmZQJDeshZD3SLPu0gg7gGIBsTAGeprPKsTlyxUHax1bd886DPpmJDIpKXIgQsysHhvn5Kg%2FMNQ53vqZhHoTHbiT5g6fJFOQwhhIvj358xzYliYP5aJtIUhcBnjcp0H0XdX%2BntISWcuTUfWWvDHW67q8OdFhBmhx4D65%2FJK7640p34dXkfPv5awomWn9u4NHOKpjzSqBtHsgM1Cqaj3booW3STxuLu4hYF2LvN%2BAOVl3qgDF1jQSQivcjuAU0AM5i4sNIdbk4%2FndsPXRsbWmnjK2FOlWPOl7kNTY%2BTs8j%2F6lS%2BUJCxymNQb%2BPMJDfedx7ZirPJVv2wffMqhVZ1esDQ9HStS4Pe6RDuKzPhuASocpct840XaF%2FDlHngfXElNSToeknyz72%2FmPPhkYVy3po08XOPP6pmd9XZsberLdMvYZaRrswI5TL%2BoWZF7hVL73t3hFPHxK7j4Nquq8IiHcf2uDPXFf5izYnRD%2BayX%2F0yZgfuDehVyDcTKtUNNzeRNv3hEr6dn1z8QnnLP76%2BPHNFc5QXrnZgSpiRSltHsdnxY311y%2FFVFYspSo41iSM74b4II5w5czHBJa8RVFaLUqJDZxxdCAOwnS9y4SJdj5PdkG7ebtT4pSR7KWnwT%2FV1dZrAeDreSCzhsqwHnpBSqyD0FAUn7lo3lB5GRbEljEhA31TCyf3HwTNfMX%2Bs6r6xf8A%3C%2Fdiagram%3E%3C%2Fmxfile%3EAe IDATx^ UU? L5R+,L\$_΃4(3C Xc)X3983%AB4͠cRNI@$Eť>o:oӧOϴתl Ptz[!) Hݿ#x!]vnA-_A=8f    @.2jzjߏ=7YBL!߹sZf7r(!xʔ)GGј~n 9i-c[Y37]*X_җԂ P}aժU]]AsӦMޟͺ0aBo={g3fx׬X1AGi>e~X鲊W^벸fydcfZlٲŻNv'OVMv~]u4ĬَsW̞=[-[L37]?-jP7~ۆ ʕ+@GI~7>|oS#X?y*я]vu:tWh:]@@04E% BPdRQuFٖ@A-ostC5h:]@@"JuDPN[V&:hR* TR^f-Li "ܫh:}@@L5EPF;V2WR ^2  @ui"ք^VydT}Y}# E eQ.z5ڑZ   @ kxFPժUԎ;) uٳ9r^%\RWTN5)B~^P;w׼yTGGիW+L@V{9٩-ZƏ/^@ !(4 wXvmג%K͛ t@αcǪuz PbI| H}cܸq]rz֠T'qF!F(9]t|0MBA@!`wٳgב#GM ٯ_? PRWݒ6FFygܦ^SU@  @/ZPПWu " ](n?J@ujmm p# 9{P(@P@N @/wQz$@PSkSWhK]ܛ @DzDlѢEjjݺujذa]Vm޼Y-]4nݪd]NHJ$`MӦMS[lQG 'x%jd8O[p-{@hP?t萚:uڴiSК5k… s9sUVuS1cۧLvx͈#~,_ڿQʮ\u͛7s_Iov׼[ .ˁ<];`3]P}̜93Ԛz~HZeyܰdwE$߫W ^ı@zN1Ǝt|c-maO^K,Quмk /җ,X47?pBcr-}馛nMYfn!ց \{mv7Cr2<|5a„n'կ~K|u~ߨ{nl7l4Ձԣ=WϠ @zn|{4<1 U@qO`P2d<v#)_cJgyZbC{J.<Íi{HwÛ`f 3tnxd(AݬwTu]e˖un^g@2n^e+ԤIس$\oNlس5fyv]d;sa3:/ݻw{eǼy5xȬ}\y9uAn5ag[ۺFfaؾ~ee05/h\ bvl4~ЂnhjEHF9Ijs9wv~dｃ6R}f߶<+V0w~,99#>'sr+ot?lӭ5Ae؁9 mׅq‰yN#|waSn;Bl2mT6^M}Ol!W6'-Y%*ohCHVsI](a>~FÎ%6ouE=/H q۷z[(W:hnŋԣPmtp{a_ m pvM\k9q]hcߖC_}9ư辨S\_v}%i_L'{*鮝\u9ei>uJ ^ @UV?%w9 ;2Z>:OA#`ybf$]9&"y<<8.iKPz؇p *hu|Ot]1@ԁ0hj~1 #ʗk4RYkj+(_Vvru;}:dW_;G׾* ~}(n6n2!}"w@IgV<1jP2@9Y=X$޿T2>_:#0;OcРAkDo19[oCXPq/ly]ؽI2׼/hn(SoܩIޜfY. QL aav}a'˩A-\b{iG)jP;眢b߸>r"sȼ6hzb{XFQ-ybIsG] |'F0`o-<ݩQGy߅=twYir{noqFԥ :8ۏgƔU=x6.a&,fPg[WPWnl~Lv[z5Oh?$dB29Ue{{ҵXm?F'zA4}Q} z6m]}~o:Ϛ?D@nܗ,,Fwuשoq. Jz׫}C'mj#̾鷘 !?v3/D\ԯ^Sՠ58eϗ9j%0g9}>j]otO'zُ赨}(~\}Lߔ'vNZf@dw}kdx/;`F#x]fA=ُGV4 E+'>yMh*]Nj~ MJ,f ߽$˾@ 9߬l[pX~#U_>\™]MjnL(S,ZP&j ^{m @|Mc1hK@fա_~矇@x+%m<@ƍՅ^X#Dgcxh*@ s95 BKp< IDATԴGUa@@j O7 Ք5*@P*@@@ mS7dq,~Y(sXX\@@R2d˿Kk.o|##qL9Hz-^  i h,~z7I˿p?lzl26@@@d4}͚5j _3U'И=z{~l   zoYo?A=aPv  tqVi f   $MׯbTN,K/?x%@@@ kh.C[ Cx  $jڵj8ʕ+ZR۱%  '\-X@ 4~;%DcO>~iɲߖ-ӱ!  $, oڿ{A=3jUU!  @)h&   @-hf*&@P   A=+iShz!  P+z    PzQZr*@Pϕ#  !@P; " @@@(U+?G@@F4    PFԋ#Wz@@Q :}@@)z1ۅRe,z@@|tX>   1(J~]]]c   A=O}]za   P{z"@P   @QEi ʑA=W~  A#@@(A@AQ`D=?{  uz@@@@5EO92  0N@AN  E`D(-A9r @@@ u  H^Ơ( 0=GF@@f:=F   P z'z~@@Q MN@@@0^ s   `p:}@@ $@P/PcPdDcQo~@@@<ysB у^0  S^v:@@ @P/B+PB @@ ku  A^V  (   ׾ :}@@$@P/RkP\Qϕ#  uBm~ӟ6}j޽M{__[*  q9 vmꪫRo駟V|+!u7.,rx@@ANM]Վ;û?V#GTW}A@@L5* ԓO>nnEG>믿hŦ<   Pq_Օ8~2׾Vm߾iTt   ) AR2A=+i*Ug4=   @quQuM5j7%{Ӌ~@@* ԫت)9~{7=!/F@@ br Qo]]r%)5   W)H;2կ~Ug4HE@@m*Ȩe]n6MBR@@J,@P/qQ$y?GQS]tɵ@@@ A=[\ 6lh;O{ｍ>i$B{ۚ#  PFz[2\Qs 㮑sy~ @@@EzplV|ܯF5%D@@J*&uQI]Fh;@@@ z#W9=  N^&F jj  @En$PpNh"  @4Tgbe Ě!  P{z@ S@@2 Z.kU9!  A=%Xv.PpNh@@" 2 sφ ԝws3 @@B .ἵ%V  ]^,h 6 =YO  @EnpMڳq(  %@PK"%ې|9:  iP> l`B{1ۅR!  WWwI&yӧ*ŭ6mC@@ j4>H-@@#@PO[G).Si_D(8  @5jl hz;F@(AmJ iv6G@Ay5S@e   *K ]el┙S$   W WlT~UF   W QiȒTV   PhRBEV1   @!h E ?7   M ?%h$M~K@@@5zknoEId(@C! ^^&$1(Jjh1  @E97$% sۧ|Aw^uJՍ  @ƍ T .zH8C^Eᛨ,X>ѡ7?eP  /q٩=\u׫,3&d]ì]Vm޼Y-]Tի5Hȼ_7׬YO>ϪUN  S`ɒ%kQWVӦMuq^NPO-6nݪ-Z$`|Ԝ9sռyRT uCoX:Nw~>[;&]o~K/UwI! @mۦ|+޿CPO*\A=aƖwz[q)rZ_wyڰa.HM4w>}*A ox>.!@@wu?x≢Y>z͖t8#6mJ7cƌƴh u2c˖-jwڥLƈ~zs;wz/0a7Bcu-Ϟ=[-[{Ko'pB5w\oD}ر2QUV5C:ydR1bZn6lo2m<ƌӴLQVʢMz{ݻH2@UvA#m/Ϝ9vG+WeߦaP#eZ.s#=V^|r3k_Z*Fm@@ Q}޹Yo;#t8ŰCCo rυ޽{w FrclܸQzJ®=  //&aWm5,ߥ<ҳrteȅkJ\u$L.uWPiֲ+VxU^xv;>l {].΄M]]3Wwyꪫb4|MG@T@Fofufz$FPV87 HFlQZ;@sСM I+F7pCӨ 0i[ gNW@ Vگg/jY1dP.}˾v1%j6[]Na# '|O~ PP@HM@!7ÇvvLP"E0MP׼5MUSea2=u>.MFx̥~rqo;,,Sv]JY gy3\R΋/84V}n.vC#h>뵋wpu}ï!GhOC5}Cuuu_J (yAѵvP[9].yyOwX`AA][=m}V# \ǶHЁݜ!ϧZĠn =e\A^  r30,k{]۽ݩr1 lwF]X{A3{ղ2]/l71kamԈ9A;U^s9{!.&YL}NhTה @ A(|[rY ]K`Zx+{teƮ_/_~}H[fEVu 鰶}Pu7~.l{m ﮅ̲wV{a4YΜd3Wl5jTtH2ucq!EEt[?JP{,&W |-n>Z@z vA~SzRM7-˽{%̿v ,V dz0edz hl;1׹f3`?~̴~8n>,g?z^@2.Fy@ 7Zx $)PZ2$;#/6oz#{:9ڋW[\QJ @uzP٠N8-ԣx^6+n)  (yC:o4jIPWu;U^AhϿM%@@~e=o(}P'F(=(n>Z@z Ap^7GZ_ q$@e=o(MP'fC[kzH}١ 7b@(yC:<~@ cB{4Ç-ꬳR^{:s|7,n4 ^ I pA&MR]tO>}l3d*@hEnI1 FQYp3l @<7"y!@-~ug(Re˖y}ر^`韲~֭]ߢ}zax͚5Meݵk2eڹsg d̺u԰aZE &()S#;nIArg]P-PvڻC?YG6nu_}UC QÇW'3s ǏW?O\nڜBCY>.WD8O9~ձ1w5/$y~wՕ'G'VK.UzʤO.%9j[\.SZPg(m{̬_OPZ<-?Su{o>ϫO]zO;FnAt;${GeD]jK~_7eD]Fe sw}sg??oA]!vkQׯW2zƌmx{45bCo(=6;XR'W=M65(7f<߽{wcfJ&S?u\FQM=:7yd'r-cƌi ~}է>)euىޟٟ67߮ rJY(rlWzg0A3$\33]F7rDf1WWۻ~{3}nW,A)z]xg_jgy9;af~A=w|֕(-K=S#?r$a3zv[P7ݓ-6:.OxDFɭ7|+W]u>h_YS?=%YN6GWjɥ\ 3g:;S9caeeU7z'P#':ڣf.d5j_x_%P{F~QcȨy4t{[ůo[R/](r}⺸`E\mo_q}ldz~/^Josj>^PnWM>6rݻ׫V*۬t<9oيil?^\~占%#: NVѻGWEB{f@ c¹?JNZy]*>}M=G  e{~L4po֬Yɐyߪ}rmgU(A=laݻŦ}F }[ 7o65>+G .WSh{%3EL83HX]{5~ k{{yqޗa8KۯgCoDK54hP[<~n29Y3=פ\Ef 䟰~駕 P Ϸ-%y3 `uh?񏽕O_W{3 $c9]??,6/ء4Suz/ }-p*TW٧]'a ~~W2OyWȈ.zQoq6)kTVtuaR~Atzᇻ`3\_iAaV?|/q(E{ R٧~4n~4͠n3l Q?7z[i+hUdĉ6;Y>RgV̠Nh"PEyV}GނqA?E_;r,!Uk7Z˰cE t^n/–Ԉz~fjV8cPe~q_[ aG+hs;A]EG1~U1J{%mG;&<+iQ)rr+?r-l:_2kϝ(NJԥ4$ˆgRSq IDATQ}ůAZWPBR.8HnN}4\-lBu/#r a7,ogkGc- IaQ a\ kowW+ZP~.R5w\/K$wSʠnVre6_?q|QrI%Vi6 6iG8OK6xECAdz6?CdA#Woٟi.G{/Fe[xml+JO6r<ՠ.&=f;ʣlo}Ƭ[]G{+Vx'~.gWs[~~SߵYm"RMТc,WTWs=~{h-kz~Bqc7㜯^k>_ss{OFЁVѵ\fVqRZ.Iⶕ䱦By|_E;ox衇hr}n}ٟfUPٵ!A-RsBT*5-H@ y\7\o8b+:= Voc:ND׉`^YV셎Cv}8@[}u[DŵЋߨ6Q/'4]_\vDׯ]9WШyдOH8 E-)|V.{R~NWOnQnV9˶2y7T6=S̫nfm߼QjgS!XtgفRC+"AVЈ(3SæꅕUbQ &Ǩe{jy2N?^o_^~%E}eZ }'(ꩾg4ʹ%LlVod Gw |zݴʲ>~'"aɌ3^8^1r-aZW=^%NP7Eգ̫qڟyѡݠniZϨuC=_v%߿Yaڻ9 {f^%Dz~[)`H g9xlLAsMMsdZ'#/e=oň_s9r=Jil5vʔ⪃_ImDoTDC> ˗/WR紃z8e׽e~e,].2V~]VOTO=TSHw/kH(R87kg'uV}O]@A=z:^jP{NfAg2+ ȽzAA] ;Sյj9zA]EP/Bo v`z!"GI,j8 ꦥ+j]8[ 8@#Eu뙹f=]Ͼrfԏ =׽N[VNR>mHw:3gG+rE F )C8 {!#\}_Ig z@Pi߼Ƿejxس]E ~h4Zl-(x:m]A~k;AݼU~W~bFv ۷3VW5 RA3s<ܷ,!WpW0/~~<[?jYÞC캠`7r꿙#ܭ>k̑])LOgoX/-s8wui׽{zOʿ%SLQSπ,\szMV9dx_r.y睧*u\ E뮻7߬"Y6zMF8ɹ8|\K{˗+%k_Zi@@@ }}j̘1j֬Y,#mgwvض,T7A}scTD@M@F?'x"2s`z;z)nKI]g.@Μ7.R%~;YRA@.m6G}+_]z ZSFtuӧOWgW_? @`ɒ%kQWVӦM+AE$?%kY/@u Outt7/@( d%/\uvvs=W]o}kVO8TX)(g,@?A`߾}T{UG-B( d$pǪqƩAettCPO72@J)@@gBTn>0K@@ $@P/PcQU'>mMM@@#@P/N[^BWĕ8H%@@J,@P/qStX;zۖP6F   +9!-1Rv/UsQX@@ kQJxTоm;J  Pz}:vM u 'M."էOBB!  Pgz[?F 1 Ry"   ТAE:oFh/fKlذAy?2by1ۊR!  $@P%@ho m@@ '@P/\@lڎp3GA@@ /z^?.=&'@@(AȭS[kHyknl  @eo`uh  @ Pe4B B@@.tYN8/xx  (pug( Y`|U EJ  @<9fdvy   APvyiE@@B6 (Zh'G@@RyvyaC@@R7s  -@PO[&Cwީ6lؠ."I&>}D.<2/D@@ )%D@@, w{?2GC  #@PoGmK/`={!CKߪT@@r ~>A=zȮ@@@flQQzEj!  P2z'@POϖ=#  @tzt+^Yqz!  PzIb/@POߘ#   @A=܈WD^  \^x ԳH   /@Pw A  E (C!h   @h:}@@ @P/B+PB @@ kpڵKM2Ӻu԰aü~Ԝ9sԪUԚ5kԩSD@@ ',`]VM6M͘1C-]TKmݺU3we3eG@@ ԋ&(';[lQz7.o=~!w6mJpB5o޼F t׿SU9,  X^ơh Q7G/_"   3`EQ׾jMꌦ(    ׯͩ!Ug4.  y ع أ2>j(oJ<<@@Z kT0G/ro:   p#^Sڹ^n1˵^^۲eKc1~O "  @<zيێ @ 7x^t8%dȏ0$0ϝ;W@Od}ʏ?wիW>[ :ИZ zzWO͞=[-[̛o.yl]7.}Dݯ>|iN;1sO@@ [hF8bp-Awh(& [F͕6vPֵۡ}d?v90/qήKF„͋QfV׿ެkSo@@Zɨ]#潴ts]H:t3˾e6a|l NP}z+3^ckfԣ%  PEO``ju6 度LAjBAԠn_|`{{#ck@@l7+K>Z4uQn.LjzR?AX'2$k@@ZuPYͭu[A\ԍ7ި*(Tk{æq[G^N}ԨQ|~ww}Uw رľ}fϜp !  @={V62$]GIǩL[yqD5|<96TL@?B۶m[c1:kl  Pss1>ܴi֘s駣  @lIV/l$-gTҢ@@ჺ~-g3ZUNJ(߬%G?u   2?%oٲ^g` hg˞@@ &VT֋wqUs> Pc2[o߾x2E;UG@^-WRf84hPc|ȑ4 P;v4nٷo_pOOj@E@@ [PG]z9s7nm^Trw>~sW  @r EbD!@z~#2 UzUbѣJl@@ ܂]QO+O { @p &ӫ"K[new.^Kߍ DAݴ95T =G]hq'g^cz@hIAݮUgggv?- @?I4B@(]P7)6Z^3kת͛7K^z{.\z?cscѢE)o;um]M͈#Ժu԰au?|pܮsi5. ~酪/APAa@@_RuV~hJ#A7not0/ۅƶmĉSNI-2"  T&js:':ڵKM2Eܹӫ!=x3fLɚ5kԩS(1ÛO&;… ռy}أuΜ93:m}\{&X6 *_T]yˮ)ד)t@?JA@P/E3QH@@@U2}v%]۷iN8@&aQ, {~7.!]~t m$l):Qٿhvu :2O>8ҡtMٜR*_2XB͝;W=ΩﶝhL.N+={ZlYc]Xm_7Rgi>hРgȑ#KI@P/eQh@@-ٮ{i:֋ɿ R. tfE]A]ۣ~х7Ge;8q˾(uZk$b9ӢoT?U @&Pn6`G\Ԟm.WX̵?k;3(09^BmA]("x8[/imOK7g3/ ^97m\*0hos@u]NRvѸxW7}S@@ݨ{Pe]C-=A/UÂzнE μ[v n .JP7/fE)_n^Bs o߾ાA =:  @>l,a˜"_UvZ{z=2jȋ1we=V׽~ҜkR[)|QGSE~S!"Ë\DFPO!  #J7 ]8Ƃkخkd9 s:<[yxQxi뮻NxMuʔhY5^\B뛦 zӶuUyDGiLiG.|{I݂,l)r;~ӟTU/R! PAc9FtIz-,FS~_zOOq:;;@G;::8\#}Jr1l~gי?%fP}G}<}\]WAg3?cv;ZP/{7w%V+WTz{߫䖆38[0Tnu/}~@@rq7}%*PǏWW\qCPoeO/| //i-&Ԝro"_ ᝇnU"C$^Sՠ. (nܸQ:묳b  PV7.Bvު3jIy^jΈTXgi>hРƅ#GVVA]B܋.Ak; !%˽U ?)+G} PGzՂLw?uBz#  Pd ?Ub~! @No{g>R?gS{XW)#4?裍"2U 2~ard@(Eu]wzT^\FW:::JZ#]vd[ A}=gGQsL)! d.K/~)Yf?ԓPy^5=<V^]  ոqJe1쯺3Ttkz6 qME/~͒p_מm4e.]׌9_MƼx5`=fgkٶvuWXg} $Nb_3?7\OٟqRvs|{n}mZz6ի'mYpI'59SJS&2YTivˠHʏ}7km/ 增"eʶmï"rKc6\r}!(LQw !Q,ǑJP;wwqȴ=wnu1mt(k@X=tHSE=.q8蛮>d{⠃\ԖjAXrwƍSOmC6#BN2Rb~/;6gzP}VH]k f{xJ_fS/!Q\dڷG.zkʷ|O8 ?SjeQ2Zze.A=Z :Di2ƞJkaV|'kĺ´}Yfy5)7s'>ڇ>矯tE oQ5sf&fG]lm?J޽AOELuno]:t>]1,]@r]eig?=.kX2 s/a2b~/?sϾH 2w ,-l2ϑxnvd\_#4xGB\W_Vh6,#82] m=h:kܓKW0%E{Z.N+qoFoڻr=b'-zEdv߽慁V_k;NQ>}ì3{.ߠ.Q۠ ;{>~u $qMm7gӲ]S{=JP7/~Diju r,]Og~NHWw.؟!Q.>Eqk|CP{m@( {5-be"GqFNNX\'߮n3xKPObmѸvqtye5%K( 2Ҫ۴4{D=JPF^nқO1K~o0CXق$t[aH / _Bӣo QBQA=hS.|CPμ2@Ql|)rz1N;qO϶04e"GfaəR4uTO2=uqu~gs;PLk7W/}K.8ASgFG.eQKE!lt9aT.VtG}lduE٦.6}F~BiQzܩg@ahsO_X˅SQʫ|CPo&P z`>R1^eEPsl?,h1&{$caSoc^2kG5e߲ ~'㉦7-?zʬkUmY܏=?{UUk 8b A.$BA.RRnf*fs?֯HDG,iV)Q` 2htA@?*ss:yϽ;<<{ι{93iҤ=Cϛz?\T{JbcJ:|Q}yصZ۹th/ UOkU29{sқ$9dC}h4{nRƽOZgd}tWszc}ϧ3dtd>df ePϾ=ɤc Go>6L憝?x^ɄX2d]v8+dl-Y7YM-z_ή}v[~z̝OK9v|콷7>6vG )7ZoYρl7~M{NedqJ{ψM7^ [>$goRJz=糞#1ܺe}w#6s<[Ő>|}]M"SO}*g7iQ@_Vr j_BB\ߚ<ⷢsT9Ss҂B{jo<>i{%>3][ۡ'xb-oiph.OJK&B=ܑ-ZLqDX>4@_V   T@szei9wڋv~8ɗc!Y!:*i @uB [7.( V^mT f̘цXElh[c(h!Y!ԃz@> *mvy%&,E귂-e@_VrAZ@h'>vjᲷ@v%}\P>Pj!Y!K=4i @%B [2$(H{cѥe\eDv!f/R`KgeP̘V@@B Cy^zk0n#FZW]|E"BH# [ @ayPcaedt-DqȐ!^6U Ns΍曣뮻SPo`Z|7+|hٲeѣ]|S{ȑ#YXC7 Գ;*B "]D3$P1ގ6DHiu]=ʨEI7 Yy^zhwR+UVhҥKs/Ւ%K"ltG .0|v40OUԸqhe/`h]Oü[h}ь3b;]qmILy~EuY6ee{}uQј֧=r!a{C{F/ myvh̸bmxEgsZ됶L0W 7tIVF'ޫ6'}ѢE IAgK.WA}>뙰I2Ed IDATBֱg _v;w];}>qD-B]>>Y |; PoY _aUJ 9 \9!Yig Ze>k,u">(N߭7n4\c3mAzw?"m C1.Ĉե9 TtW*lq>\&>.N=ɕ]vE+Wrۙn}>|[dQb]Y}SOհli7]veee;@ʵR ^{Bҳ=i<{}w ێzǾ;NqU@ta~ΊUcB]"ҧs7jBPoY _XjlpJ*$yN}zdWn=-WF;(Ϟ@[iz}{:DXIٟ˚ KO.EDyBk"v\!w[' yPȡBpd{%+'|r/H YB=ON z~Q kpNJ#0Y9f/Z-|磱cFbەW^}K_ vzdd;y=U!&ɒW&ɵSZ4e%`~ӟHSN& vQ.mJpɻC/7s3֡=$&i{ou[Osu_nGq7v9^n]V+r|FlBߥ>;,3xڣ$۶{²"*=3G׎7wPG>= vzddsf9;wn/0qOOF_V* ?AE_*JhCŹ<ϱzVT4Kr!jx}SY&jjϬDQR6YuL4Ɉ'WʑEXhE >mحB-.L[ԐuӒ%,^$PWN/ ׎<4_Ij;_x,[\-}Bo̹!>_krz۟IQ nƾkK;"m-j٣.庎wY'"-|vjeB]W/Hk񮫇^+Y/-7y'> ݋)piX!/,nɗ|qI(aoeM\P#rwE;Mז .o6ZB՗ϸ"#+CC泄Lz̙}F_$)odb ?.>&vh*TmXnO٤ykctlvu$ϦrB:i'v[dq|B~aKyDlcFgu#M1⾯jylspjmeS:rP/ Wk92ַ}ߏA\bjuÇ2@^ /&Qy>4JYv}Æ >HS&+HTp Q]r @G:I3myg,ʮ5+#!s"^ꫯzM{GCYO~P/bbS{ *ԓm=P^xۯg ^B"w&YmE|ݍP/P&ylO=詧JT@B]:*-wA:2oҢ){FzmMjb+ mL(◕*dQᇣk&o~M6-Nr" D B]prFslJRY${8QC٣^- P`04:]Cm( ! (芟dr%41E|k@OE*?]m`A P<E7pz <$%(1 {I\(◕.G5ɥ!@Ge@@us=DsN4pDx7N@5b+eзs\,O_VҢ . EI^I@@U y',B|hq&|(Jݻwt*-4  2!}-\t7tS.뮻z/|!7pCћ}M /+znnɍ U!E^y'N;;wx;n3۳>]~… ѣG͢qFG.F"u];F\q >ut x+=$J!ETO> nUwy-.R}-X ߿۞,q6C(ʲ7-Y$袋gloqe˖.v9s[&^|i nֳyh=g/uQW\M2%ڱcGtǶS\{VY0q.]yѹ{tCn݇iv; SN9%z㾔˶rftH|Xee)eed ( 3g,DP1@szC #[I_xq8<{[I;E /Nzì~N{饗zpi,4Xإ^j#GJX$+8U-Z(4]qq'퐈zbuwóؑ3PT⶷v\2~se,B=-Nļ&JyPw賟,z@%DvmDtV)yį$b7xctcw_ʺ>rPwvn*|ue=Qϻ`f?]Vy[zW4Z[sFic=c&m}_+ˤ1iY (>F{ϗxտEg𦗢Gi@_Vڞv u_R;mKTkPOki Z%} #ԅU-GaB5L\EW aOMUV /Ovϟ_K:3@5oh z+Rfpī~Dw}7{Ӄ= K /v FDYk軛;+/Q+Ēz=.lPEwc`)=:fg̘ꫯ615z޷'AyPuawS۷/zᇣ˗GoFtGGԧO~ѠAR@(BjPפbdz9-*4+Cy}{pzÐ[%Գew?Sk-rW }O[@I:)*_}8-֓X:]@ϬKCј$v^og}O 9{~&${]]o2=>V.z[nXo$/Iu,&Kc[R P%!}Un={b.֭[ p;X&z:uذa&IC&Uc=Rg {Q(r+ŋ{[Ҟܣ'T|K.mEK]n;m[5z<[ڂAϼB>LfF[?+ڟO`y 1y=-]&dz @szcsصkoڴxE7G .}ĉ /  Z-CC@= )@@sz# s6m۶.$F>vXSGWWW@_V zE:fBc6%UfcǏ/T!Y!ԫ3Ni) @YB ԛ5 (%6ol<璕YrL(M$üO0!&`gIeP/  6yPo@|6l` s>y|21OBB3!@@sz-! ^gM'^grZY/92N3KzC(kߔ]!Y!:*i @uB [7.(9ڵkMHAP>n|h߾}&ڴi#4@_V *b? D\+6=-C )4~qܹ7|stu׵ސ85 8>hɒ%qO}ZƍkZS#U&g}va-`"5jygxYY@Jz~le]x㍹Z5Ix1^kKszF~Uo9UUT~rA B$^W^O*5$3C&䧅&MT ϛ#9y6\;TKDԣ+uh̙3s'g 4~Y`GSnF%s>ϴ˩HţUw{pyk?yBu}Bvǘ']{ư׷Yܓƭx}mivmO춺㫯jBy8\W/GnWt)CK[kRkL{NYB>iπnE}^cwτwѣuEW}+_1ϧ|V|嗣gF(T}-uH:6ir)O?;D#;{}]uU=ށx^s Is8z-d8x$p*$O8sCmy[ҩ]۷¸2$K/MY s=HH>#_\ɤϷםeG'^߉ywaZi '.ig u{KoGr|6d [#j&b-r,g=6#Fxbˌ<}`w׮]=g$AW#k.aruE;β*0Y[o+C *I}%vmTD]{ѭQ䞴m {!O_4ݗ{qe90ۉwN7:Oأm֛W' hnPKnfRajwB=i$oҼ$'D_^M~Uc- xiyƭ!uroW(m x< yě/\ OmְjO,g="Q4]萿c4YlP'6vQ-Sr Qi3O_FvT.4:=${oϥpc?yzR]^|Rc+?UcոI7;<~+fڪ.]nӧ'[>,k+ޓy;cOUkxl3jԣk07RC~^Nq%-nfq'[ ƘP[gYN_E'ĎUz3 Bf>,&->e=JtV>z̗$ty& >#ԳԖz[+ TB7o6PoR+Ϲ>pR y7{HCEB=à0@e?я"BY $r'Y㐄zPR޾ O"z}'lyt+jK kyĺ+Y(I@B=ˬvvZT]Hw__Hz5=Im|vm~6o]TĹ1)}o_]?tǴY_% 8]6Y mLYcǦfyxC 3o ,/u9.e[`ԩ- a7 7k幪!Y)PϤ7|R-[_`9͗4H~Lf+5#iⱼsd6I£Ϝ}0$h "'2٤I>+)}ƶ=%s;}"H~m){͚5&7KH=v[J’%[\`y~$vfsqFB{2;|"D?koJ]PKFlWlj;-Y;Nl*n彡830|p3\۲Ť)Ye(]ib_xc>w _dlw~YWv&ƔDO>[Yg1O0oH^0 IDATNv"2Z֯!21j>ߤ@'4㛚iA_VU:Q֣ΔAԄ_I|^dmLǢYB]E}|=m&?)ΣG'`w^ql*pYN<rǶǷEy=rԭ u`GYȖ{}mI+n/YǬ-t}'ERhGیw1iv_){z=yDŽ-Ý7>ru'hiVeӧOtСtFJɚДmJR6 ږPtYӄp&DjXrY2]OIݎtxCW}+bS{م{#τ%UXDΚ5˄.*eMkbhJ2'-r;rHwRӆK6| mǠ}‰2_8餓7 ۍВ?4YrAW6 =MH3b"`!p>J`q;Y^2x?E/KE*&7[_IV{N &t#Pl_wEI|}HewuW|*A@Hhnt dEц WS^ɓ'"oLv 97ZI;J'2uD ]bhA ^$ܠA_Wl BkR=x/ĊFyh~<<zR29ݿC8"IKL:re0773.@ c3 ^[v kU!<.xa!˛ xڴi$+ν&*PǢk&/Y1D!@?}߈<`! u =s 2m۶-D,PrN  ?~D.doEdgVkX;gV0$&6"r0WkI˞˿~EW` @@PH9mB==J~\uuuu*@ PAP5{S$ԥ$w??#9*  ػwoя~4`3۽PoX>to.ǩM8#F9K,XjEveM6OkӧO/}e뮋, =0 2"#B[niY=,b02=nذa-'.hٲeQUB51=s[5oj!"Bvir2dHkBݜcEz׻ @ wy'{ F'xb}-q>⤒Ĺ"uq+sn{D8U uWէy%\ TDWΝ[K=ճ^c };|_ ]Zy Z=AfDb @ _=^/~'?VXEK>'=YY"4]AQ̺BYM&(Yr' bGݓ$Xo1+ůUm'|r,mӘoVfH~.5jTlC-mK䄐gS3O:k?mN꫊PW(R_2z7x#/}.@O@">N>69WrABaB=Kj;o߾9Jh-SOXai~Ir nnߨP??a„^ b^ ƴ.c].0+}u;D-mkȮ) i) U굍 @!PO ds{^[ʝy{'+@YhPW|L }oP֒;>EӶ? }ecǎ5 nIP ^ Nnx'sm&^ҕ$Ե Y^N'ڋygoOn63Sjwg= }eokKZ;r.3#кe}z)ٗ]vtޣ>VLr&]/x_R\ gDe-ODvS_}$ZdzeEGH[9ćiڵfnFKBi @U Pyf#EH\“E +Z4hmٖ[aol0 ja7 @U#PjqFUɓϴ"Pg8J`Æ &KdoҤIO @ 7 u MCMnE 7%MDZtBa @ P n+4h Q?~|@4߅ݻi6mZ!ۃP/d` @E X^L͌[@B8A^q @@%ԫz1CdDt&g֬YmB &Pxb tر&!\WWWFr# N.]m۶̈́Ϟ=&!ێ !@@] ':d$l8q؎1F!@E k.~۴iK>}DzS @h B0Q:M:x· ֔R "سg[,HIk`P@ t/b3gСCP  PTZx8}{_F7 %A P$$WkO< p@!x[o5}{#9YG?H @(6 u<X@GcXtqǵj @( uo٫B ZLG]˿v @(2Bu{$#{Azd}Q.g߾}k){!@JLpBeOQ/Hi()99/ii @@ /=#&DxF >@y$QzE0'>ѼJ(  @v/^LnBHnjS΢a@q l߾{n8cƌe @$PiYxlWǏ/$tI֯_-X$Z(**VO>dt-DR!C*SN9{5ӧW4 @5J!m4"/_O%s&k0aBkRj!2Ġ+"H뮻a QO xעs=7fpibg+ԥs[Ǎ-[, }͛M4}L2ޮs @AtBn݆ K~D'O0(ffQ $M1B]N>d#̥ =K2$) @ 'R u!#S)Q$X.K9sD[nz/ݿ| .ҸKfpժUR{,Ym̙kwE}wO;ӾfpARk[EewWoFNsdO @@+ TFu_۷τN6*;PyNE|ܹ3".h…w ٖ{O?tpuֺ;<#rr)B]/Opl0Efر2z!@*NBkN>Yfuln-|!"}_1&{:+}vm=n4*UH::I\vRkn1~W꫽-tAEȂo'ԕƍ Hnʕ&DՄc/** @h*zN꺧]N~#`Ovj9VB]擲PnPh"uwUK29{ i|=-+*!o6>}x@ "@ވvIJd߷o%K-Bݮxf" }W/pG]B}YY|wRBGV}i #$MZCzԳ?xyn%RF8?ZY5eC @!ٳDŽʾjxׯ_ݗKi(5k֘,ow]uUO?{&vJ&K&Y'M#ك>#TN֨PWfOI=#Gf)PWw{Y܅ +Ny8`Oˢ.s.@ @@/ < #T4PrϏ!"¾cܾ#tu-u7(<dzGii{o{<[Qi uiI&/vZB~g勺Jۢdzټ}c x6{_ }߿-!sEЎ=ئ=@ v@7DPP.?mڴB$vZ0Dބr1 @,zgv9Zj'vKQpIbرo;  @@ MCəϙ]r k2 FXK0 @a@_MVz뮉'W X,舷\džu.@ @=\Zve٦MTkӧOaư8t8qk0bĈTB) @@M5*{1Β["g~ %bԩs>lذ  @(&z1VUV0a@ms>sL#Ώ= n@ @-[7=+[~ڞv9b VA @ B=A74vӬY :t(:LW^1*v$, 8Q= @ B=%zxڧLbBܾA/~Xn ir   @"PoɊs=\ё=Cv;[x ) @hzPW"MD'?wwwD~f*@ 4B@).ի>|cƌݟl߾,l޽,l̘1F @@ +Em5kLy9M?&̮[qw^1mڴI @@1 ԋ/j޿#'LPZ7o6m~M%{> @ P]}a[ai#%Yx'MTXqF9׶I&O @JN^yuֳC:PhC @ꝤO5زe ߷o_q],0 <V5u27C @BA$"fF'}C !@ P8u Jg?p=Z{!@ :TM"m۶ٳg7+V0acǎ5a"Թ @ 4J(A>_Xv2zӦM3 ߧOv:tȔ#'#F.!@ !PC{'gi_nڒ_~w.SN5aÆσ@ @%P/n`Y+Cj*i?33gA?tYC @z@3"*M@ydp[nƍgA*͆C @!P wj- #8":|p-$@ @JUmښJ @@^^B@0 @'Pk( IDAT@3 @ "@ @@ +?G1@ BH-%G @:C"&o믏n3hܹҥKs= @&Po!@.m}'N;-n6B,O; @ Pt@^>sX2+ԟ|O7Ꭵz@ FXanboףt o]+( @B=#ԗ/_-^8z饗e˖E7o6{:+,Yb_{x?zKA @@9 ٯyO߹sg,/SN}„ ќ9sI&E ,[^w{o{@ @"hM PqsY~g#G"Գqs @ @Ѐg[n?-Bw @ fPREK5]xI&W@# @ Q"UkUV,g+Rb  @#PϰE҄zX@ @ :C @(zz A^n@ TBCct: C @!Pv*4{' 2Ęh%Yܷs\ͥ~@ @Blgof4|詧>B_::SݻwG @ @ 5M7w^} _ 7P4 @(9z;%hƍ=x5 @@' ;I;NUǛn@ TBO]x'Mij7@ tBԩPl^ó7P]1 @zWn~o: @(zGSyQW{^|ozQ:; @ PQvvXijZ@ Tl3fL$]>ܮʨ}Y.B]͚5_r"ԵѣGn* @I^~-}onݻ@1cFھzj`0|p͗0.@ @y ⾎زe k߻wӦMmk׮5 6Ǐ/@ BX5͛7o)Sa~zi߿iÄ iB @#PokjI`Æ s.ѳ'M޶qFmM @@!Rmc+?mA:l'pMĺ7 @(.zq(W"!!@ zCa,^uֱ׹\kZ# - }ذa%m5͂ @@8UK,ầ.a}iIZsl, @.zwٳgWM ];DU5 P @@ <&ܹd5kVMXrwuu13zZY @(z9ۊ۷{n#f̘QVӴVXzY>|3Q& @*M^߲eTrGwygMmG :dĈ'/#jk{u]viM-bg3첞|[nhȐ!op%G^q'c׮]si&|S(/PgyftGwq<>l@@ h7o^ /D=Xoky>p oԩSco6lXjEbg:*X}gw^q]6n޳g:Ynӯ_vt uxe*u@@ \xᅱ'd:Bh=<3g4cС-wPlK9 {ǯZ}"ٓO:o' tI<uzFھ}zx%LW= jR-H_'x„ލ9sD[nK|azEӮܸqm駟N?fiݮZ%\Ww]|wL=guVwe5iҤg=0&Ϛ>sz޲l! tq5״J @oĉfC#Eڽ{IHT!% dϺOh(ʰŘ+f>kWR/RCꪫZy+_~… ߹bޭ#IKR ُeB2tTQ RǍ7~qȑf$+Խn{%lwe*z(^l>cUG},*R|nˢ$ @I$Ag/z{f%WsٞN U7M&J{嗣g=cz$˪f#<|ߥ.,Y QU{a']{q",ޟy׏Y/pn' I%%hR%'9!DwqMO@[=5B" GuT$?C9zMDLEYE˹}5[`In[o5׿]p؋>a„c_轔a#}avX+Ϫ yt-5kDwgHFh}i)},P#G\ĵ}"3ĉ|YlY-Es(i>e*GDRi+ @uyހPOt߹κqҲHuEQWn)"JOޣ^6y<꺷S7^qeY^$ =rF[ xrJt 7Dg0*7݈GB] V_=h1Юh60pá ryހPƠ:wwwTf*HQwiz!y={WX0u".Zz2˫uboz7ߌo~uek{6`|oV/e b9E{$wuugQ4B¥!@h/ ۷o7v^3fw5PoO/-O291Iz}{5\6H{ϟ͛7+ u;Q^Rqb{}q;wXWRVw7ifNw>wunu?i.l7!_#||60իW:⯞1cƴ*&nv fyPIe31ctb>mڴfa&ŋǂY!z<6 .N~u %P"%\B=Y1x$9ٛ뭷i'eAwCs()J@K;GQv<]ڞt<޻q^$m}lڵfn yA /b @@uiҤC VI@!tB/X=C@y Ht.Z y(  <B7B|y{ E@]H޽{K.mP_mDU ~ZLBL<{@'H)=$3z byPb x ۈYf.s=x≙|Bl7@ T! /WXa;$jj'R V.]m۶̈́Ϟ=YDW]uUt'#/ ;!@yP8~!#%aĉ7jĈLN`׮]i&n0>}Tϋ/}C>7?stWFÆ $/vpOFrKtGC RN^qђ%K'N;cT^{-:s뮻-tyΝ|7ǜts+G88 @Q sOt9DL\~&*^SϹopz@Qgi_nK"~U ?w̟??{E{챆GQp;a"DUc\Ƽ(6h,X?RyyV"L/]gΜ9֭[M7.ZlY4zwQC 9sf ..3ݶ 9>(G .lsTv=?|&"H"6|K_ u?6]^h2AСC.@% /b=mժU~gD{J&@K{ond}>:~Cu yvxԥn~X&ތul~z"D#}x{DŽi"YJ^{m$BFJ yT[o'] To_-^)ѫګv v ; urzi}V,r<1.|ƻPTEo,fz%C~F}ХWO[ovD^ƨF6$1o"/^!پe[q;#=iB?֎ZhѢ̅ O7";il~_DPB<{<}n׿]r%ŋ#yJݾ1u["LZ/R 8Se‰D1ϫ}c?L?qն%kG‹<.x zD~c'YPOkYrǎ:~w'nmŗ dYu^{Jػ OZϝϣ.ub־.f,*]jyƈ=Υ|yN| 6$zV0!~;ͤlc׎_|{5o޼#vjeWi{Գޛn{|}.v06$Wyo 2!u#[V?29S_~m8̲أ6T{E a!_~8=Em#~Ş4ap7F~I' .l{;ʮ^߄7PO-̣:*hn)yޣYH<yC/It$[y8^0֮]Yne}׽d}/0&@ /w竓DmSO]DIGinF1WVq0pE=vݰ`74SIM0eg%ٔ*e'A~~'D'2EkGP&I֬PzzW[Hu񰺉\ -N6~UR'Z&fDY < Uv}"lDDEŔn>pi+])C}opǃ$髤}޹I+AkA!=is>go~8ҤIbݷ ^/6ZC]e Tn⬺x벼ي$$l牔HzC[%]$\nr<6O~=,yڤczZOO]Emw V.g훸ec& -[_Rtmpϴ{;wn˾Q}$<6(r 4iItŶ+/W;~{YtVR۲(WWֳوP!$ wb 7K&u)vY'=c?o^D]U8o(9ݬ=vg*FH+z(R$O;=JmUV]y0S/mcBUݽyJ [52Ňm0馛" .Mwx{}y\ْɹ{ӻo,fq'' xļuƙܷ7ڧϗ//ۯ6ZIu^kO{,8W0W{3+Ҏgs*vePsu Ξs9'Hjȩ]Sj@VJܧܮZ<ɪ:Ǹsìy#cG=Yj=~ᶾP">|YNj[Z 9Cf!J'A aai߫}ɝ+ BZUmذx]"]q@_%EmϬPZ3D; .$dYzr14nz#?3RC7Z],{ g'5\-Q<#ao_l֭& !C~C)͛[PM_MڙTo/qWr3|!YaniwssNtNgGC_%GE%Ӻ]|RCf,vC5]juE}\H/IXV=WdķRm'M˪@G듿QBBvW6]>Qn_&yIj|YqbРA&].t.v)UGz2/ܪ t@J u{9c$h0 *V}!՗f++{0;.S-&ˊs !- $lϚAy<[BA yC兺=88jM r iW^ɛeإ%5*w/i{^ܣ9묳h[ڵ+3gNU\lg^1^=tx;} [#|B=-r> anı . qcm6NUjPz9(wSz(e$)P?"\G}zxT(O9 h}t,ϛ]!=Bm@I !z2yjl:Cee%se`e뷣,4J۲熂!@U&PKQOB:užں!\{1 4'n1)cNPPU=#$ @I?9g6ڡCz쥕,[,mCU $ O>P89^*{\ @ }g9B+V^s;+D`ǎY,` a9\|ѨQk&@@U |߈dyw^n[rIFe2ȋ e$ D̚5ͥMM"aÆӟt&1@@HI'=ɓlBݶzj#`n̘1c h-&A ?۷ݻ͂Ԍ3' ^uJt]wU @M /LM! >׮]k󦉴Ə_p1$en޽fiڴi @;MBE@<͋^x qo޿#x&LP+0 6olomLR6>]z饑lBdo| sR)[-Z}ړX`qFijP`~/d ɞ{7#Is*46B '}JtC%x/KЉ6(@;!@ M^8ΌOF n@ J^+'v@UpS9y @"P/Uw&73+Ml$sλLB8I@ Bul [$\Z|y,¶mfIB:jXbcǎ5' H.@ @=\Zve6m2^S9O>ÚCСCFĉ81bDs*@ @&p={Ģ][6ׯ܍P8`gNj* V!4 @$P/ft*jժt> {xgΜibZ[a @ BxQ}]Ļx%4^~4,a+t~+a'$@ R@[[(A, @@ ;X N5 v @z@3(JEۄo۶xgϞݴvX$;v kjZ@ TB}_ڵi&sާO?t>qD0bĈp# @ <y(qOc<֭3B[2ׯW8`D?M:x· <@ B}e-" ^<"WZesL#"k( @@OuFD ۷[Fƍ3}РAfC!@ @w;G>|a @ P%*6m_WEgMH YqH[6Td J0`݈EkQ&HY.ԅB`x7|̙9s||_Xܾsfy=ϜϼgSJN@ @@> ^ P 7` @&=o?_k@^B @o-܂Po0gC0 @&P{i\P/ʕ+>lΝ[+W͛7W_}<#UZ@ @Q(".,kfVZe֮]k{93uT'ŋdC;!@ n ԻL-B]=ͼy ._t۱cNJ޽l߾}V?3 @@%ۣ/XXI)ZۖŤ̏n ` @FB} #A tܞ={̎; WXad|ciVxל={HG{1 @@g* m@H+hѢn?~?cƌqi{|@ @ O<- uR~q'3gVOQ$ @zD#gҔTvzjj]+m`s7 @ G>z6"PUs;rHz7aE{  @B}ҸTRasNw!@ I>9N=BBX @$P6u4H @ 0i 'ihB=F!@ . ԻLY@g& @@ {bJJ 0?n>駟8~}ñ kL>|;4w}Y|y/!{VUB5h8pٷo6mŋͼy̌3̔)SFX @WgϞ5ywo6md֭[WQ>¾ ;CMEhg}f{B?fҥA ?<䓅`m6zFְ^B~U'pak !Q Pu@}~w'N cN@@X_l9uTi^%B}z AqW&ݽ{@iС\?\=ݍ@7!Ii{Z @@sf{j,PmzT)8~پ}9ydS" @!pBg|ڄPez[d)زe̶mۚ- @{<3ٵ 0-R.% ҥK- @IC*i ^tGo49sfwR @x[7|\m@Er!,)Sȿ| @@իW͵^k><@!(j8)  kKW@J} @_i @d@ NZL@諍0@@ :n@:,i\v*mZ}uxyf3k,?ɬ\ҼfѢEO>)akӧf|K.GyĬ^̙3lذ>|̝;km`iA m92sis.v۟\(GuJ N)$*ȩ@ݱc8jw6۷o͚ m馛wm6nhvYz>cƌ¾^x!8y  }yԩSDvDQ}+= G:4IA}cwɒ%dbן8v. aF u\;HAt@ *믿{V̈UP\7n3sݨ*)o Dm3;Ͱ|r?qB= ډ;E2]8{l.]RϜ9c^}bU cǎ׮];AoٲżƦg{z}]wΝ+VWX1:f̟?4MܶKm۶{vQө_~e2/ 6l .e˖+/ٵkw\gBSlSw^icZظ 6H6#4wuWwn f#1ub냍C-̷v▯}?|,m11U8&3A[jXhuڬy6 ,(n߿,l){>~"CٵMA/eYݷ1l3K3r7Êz7IG N<E'=jP!I˗/b… chp)C"$uݣ-{|V0tnuݗʬYԵII p󧏍ѣŠX>M̾}Kdy}DTۯ;y睢|}-O?m֯__AlѩڷVG-p'x)KߏXߴ%Xڦr _v{t_=tlGU{ϟ/b'eNx87f/ٷU?ĂnO߁eؾƐ/6D>\CΐzB O "S_ /@348Af@OV}H5`ܐzAR3}mԃV~p>6]7h.yn}LVU?eׇR}[ܶtY14{qB'W>T7}mcJ)=reԵ{&s)} we5>\b}@1sfŮqmM=}\em =_(mvyI//S֏{74np1 [ ΋@8/X W}inzshOٴϐPjtr)î\d:=NNfP9 Co@#ò]@#.'Vм| Ny m {L ^wuRsiew7%2(K}mq+)B"E;oMxNUeB[Ǯcτo}ܶ:mo^ϟ6[ӧǽ"| \#;m=ߪ u )#^Ӹ>rĽt@ /mZPB΅Vב#GK*ڥPsُ}EcjBKl+|b&4wSe߽NN!} nNgy }ѕPޔR& bY a u_n|˵u K}0zϡXK@[Bɬ:4n@W.O vI @N}P (K3H8E dP#r0]]v8w5l`]ŘI}~HYٮ"SM[JuVŖ)6=sbτ -nL &R}u/B^oQow %S~\WXGLIDATZR="Gi *ȩ &9ۮ{ۖpbQ>Rl+rYjulPo09+bN ɕ<|Y{vB!AXc:LNl~'̚5ks}kSg͚5.֡H`:mRi,HRBcxzkf[r|o3i ۃY?qĸgjkE]ϰXVM`l{Wwe&Wyx3 )'r9̀@-9պBfleNJI2aT&ԭS>ثBLr6z6-~S,e墙WY!)[C.ee~2o6mo~ u_{g N}-Ekjݺug+T,v}}lrX|NifޤPw):ffnyneQ/}==Nd ~x @ℯCΐzB O "@_ւMYH> L܈7FC߁`MS8Ե/RG])&DMބ)rĽO# P}^!\z}iW6!-*%ƽ~нmjC6z)bwTېb{J>Ew+T[ԱwOzS@9ȵg@"*Bbr>2oK:%xxa٥=)bK{ԕb{JRVos5Nuu܀Pm%\;q/A PBJx@ J qB=\{v;B@ u܀PO0@@ $^?vyA} @ @zrĽw + @5 :Gt8@E`E @Rz@ N4W+b@&>Öƻrx}uyBu܀Ps\;q@s %@_"@@:! ;1@_+桇2/Kn_D; @9u܀P)ʰUvVP8:"5lb?;}#P  @r7 {|4vfZO).K.5?s=g;}uv@@Nr7 s2lm@U(X~/.VvjGN@@:n@ hB3rʹR 0\Z[kD?7_矇k0C \, # _*<OnGyT;GA $9zhggB:MEr z^F@@~r]Qi0S' &ۣSk#_{5GgL:S#.]dy}vhѢNn2ajժݻw3\W\17o6K,)bi:b}O>16l(;wpcdd:x`?,XCw$4qC鬸 DW?Mcv1Η]5K" dk ؽM.iCy[ߗ_~i6md7+<0f#W.wj1L5X9]2ٯooU{}]oI5 gL "0JQArJs̙]9s[_uNqpҦ)kJU.6E2 0+ 3#5S|t3hΝ^x е]2śni\vo+56{GB=tV\ @`xWC=dl{]618_]*l=rXޛoYw]vw5~aTj~'{w_BP>Xbl̟;w p/g뫯:6XBۋ/.ڴuֱe[nNu"TۦDe|kms;n81;vmgL(-[`~k}z-:']Aw3fL6b땸>}Xz{/t1oBpɢ_6v*mwD!||[IBϚPLs.Obo,ƫʍEݗCĞw5qC"E@`HT.\0aOڽZȀ_VNi`/bpߊWVDT[h_]!c5fyv*l&UTO]~Yl6QГI&`kسbEfmk… MRժ1jE Oؒk$Bh92؄fcízٳfkS~koB76YI!Qm 7`zE";GNCܔg+RP7i"8|R}m09w@6离j;Wdq'Եw92 \s: Ŝ/}RdDa>ygO>;}}7ԩSEV}rC1"Wb,%vB.<C~4J$n:6|_:ޭ'}1q&L/U޽ٳџ_~qC("E@`HMx)uJ[^Ue߀֗i.;7vٓM^kGуsqwPߥPSN)Bݗ,e-e+Un-k޽Yfy7=ʷ~})1bWcbβKt'=_).珻-+!:Vb-C73ĸ&|mnodCb]ƪF7 L>]*ԫWń-=7ק=}|;\lfW8Μ9׿Χ' _=˚+"bBO +.u YH;Şl{|ĉb?;#uyM]we.^8a)T voy饗ƽ~.9ڠŲ`ĔeSB7UneQbw5nIzH  @W?)2Xϼyi1AKOIi.POM}/[i ,0r/ )rYөbO|bTRlDZ }zf`W_Hm\O6mL\VI}O=9=%vL}asMwe91P6z0T껎7m_lB*56bwχ@W|-Etx4єo[!nϟGXV}{mj-O޷:)풺DTM}@S^ڲlZ{țeS߭\EBNkU5 Z$&-|II} {>ua'ׯ__ =v'E͡ǀIe#gDĎo,[~a%<:LNyꩧ&&)lm۶ b)ge^oi=k3arK>YJo7-4UCښ74onC;0@^ v}kR%+\(}"6(D{ Sz6ꦣ'ksˋz1{N\ٿu*+$'λ#5l^s˖1 >.[S~k|B'ݘ MTm 4]Ā+DJޗ#n^V;>9+_٬~Y ({z&+BϜP=C޴?|Ϟ2~̙ $3l"Ŗ!in{/6yX-~-B}=}F?#!$YT HIT0nHPOgŕ KHhub '? рPOgŕ P' @IΊ+!@N @ PB=B=WBB @&z:8z:+ zc`TJ=Bbo=IR_M@`/~.ttV\ @ u,~~푔z]T\֦Q1ڵիW-ߤꔥ_y_QeJ:^aX' WJ,3*^ ؅}֯m.09vPB=tV\ @ u/[l=䃼[V̙cwG bpQ]-oذ>|̝;w 7|sEt;w~| O<9βzDnϡϤMuM7DSj;ʮC7Ae }POgŕ бP@믿'uVlٲV4k׮]?8W}75+]CڪWYs"eWޣst'uǎE͛7G_~}!pDɔ7-5>뮻*-vR꾿//k0:Μ9c~Yry'L4pY,u֙cǎRM̾}&(|1j|Ÿe++_裏{_.wuO3%sazl0\Ǣ(YjU7_kB2vh[۾[xqYW):~'POgPOgŕ t[73>{݅ | be ICVk=ZZ{|]㊥L}7o^a+}֬Y7w47U]7?C"͞]#DO`hQELIy:_6y>߻i_eJv["}1ƹ/k㢌/=g|tc _ŏnOu'S}㥙HO?t1%wm37cfdɒ́C_{ϟ?_J}}ԩwDqCGjz+X)  zJ11z*+cΝ^0ӧO/nKY7n,4hX[3%Z_;)+ξzlyu[jAP#>{G)Lbh*SlbGOhүrcPň޳[ݬgBbD=SKj |R&\fg׿<7}n{C~X])]NqCu GK dG\; R}!E[G(^c Y4f)X Aw2B}B0E^Wӹ]Re uz= x`¶6ۮPwY>}XwE^XuD3R&umA|{ƹm u M=:~]W]ɐݏ{w9nhP3@'~pz\&Nե 'skj]lufѡA^OZ=)I(;-| c$E hP/v"E+|VyY,IY={RVcB=0Ԗ`O׾2}!Sj_ոy˻/=sj ]ڽuV]eI}2{LPzrMJ`Vu=q[W>T> O2 tmsY3f̘G] .K}1Ly?ɑY!&OqC}FNhk dE؞*+Uo;d" $@[4rS~* 2Ù)tn긴·r|c^0AR]k| -F}֭[M)ߊlv[N-uYUzlvzWpuR}֣_c+-3>V}PC#6.bɥHOqoJO-sJV?#`lhbc& CIA&6pS ={GZe h-wOl,R1~WRwtdY;볤,RRz&k_NFu]׳e.tkY)tʄz]_ۯqK@LsBgKǕ]LbgsyH|nZW>cO}*ԭX)LO=RV1fe6Jeg=BDz듲3Bzb#Ի9nԄP3@%~p{,%Cfِ-BܹsZԔ-"-s,7gf9۞c̸!ݣtV\ @?0Ȫ{U0luѣGTiBi[^b7gJeܐΊ+!@N _zlYZ @ D@&;3)B=@Nj-3sw'NO@ Pe˖SNn * +R@8|p[o! @$' "7EnʕF#ԫ3@O@&)Iw_~y5c^A?cfڴigu@ LO<w$m߾}`87o<3c 3eA 1Wo֜={8(w-M8ݽ"H &pqO?|WҥK槟~ @k7lNsw˗gܢ2>Z@ @"ڑIENDB`netcoredbg-3.1.0-1031/docs/files/stepping_sequence_diagram.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netcoredbg-3.1.0-1031/docs/files/stepping_sequence_diagram.png000066400000000000000000006201771457701673000242050ustar00rootroot00000000000000PNG  IHDR^!)tEXtmxfile%3Cmxfile%20host%3D%22app.diagrams.net%22%20modified%3D%222021-03-01T11%3A04%3A26.626Z%22%20agent%3D%225.0%20(Windows%20NT%2010.0%3B%20WOW64)%20AppleWebKit%2F537.36%20(KHTML%2C%20like%20Gecko)%20Chrome%2F88.0.4324.190%20Safari%2F537.36%22%20etag%3D%22-EvpxrTjFn0ulqGwIdwm%22%20version%3D%2214.4.3%22%20type%3D%22device%22%3E%3Cdiagram%20name%3D%22Page-1%22%20id%3D%2213e1069c-82ec-6db2-03f1-153e76fe0fe0%22%3E7V1bd6M4tv41WWvmIV6Iq3hMKlXVNaerT02l59JPs7BNHK92jAfjquT8%2BgM2YNhbSFwkIDZZq7tsjC4gfVvfvmjrxvjw8vo59HbPX4Olv7nRteXrjfFwo%2BvEdoz4n%2BTK2%2BmKq9HThVW4XqY3nS88rv%2FPTy9q6dXDeunvSzdGQbCJ1rvyxUWw3fqLqHTNC8PgZ%2Fm2p2BTbnXnrXx04XHhbfDVf62X0XN6lWja%2BYdf%2FPXqOW2aWukPc2%2Fx5yoMDtu0vRvdeDr%2BnX5%2B8bK60vv3z94y%2BFm4ZHy8MT6EQRCdPr28fvA3ybvNXtup3KeKX%2FN%2Bh%2F42qlPAmXtzjyzM%2BUJ3nsy5dpsO3A9vc0jfRTy6h008GKf%2BRm%2FZO4q7vks%2BHl42v66f%2FM16G3%2B73%2Fnh%2BsWP%2FDD%2BZZNe%2Fna%2Bdv%2FzeR35jztvkRT9Gc%2Be%2BNpz9LKJv5H4YzygkRcXCfPvm42326%2Fnx1a1%2BEroLw7hfv3D%2F%2B7vT%2FMmuRocoqSlD%2Fl8ON6ajIO%2FTKvKX7V2rPdlvUg%2Fb7y5v7nPB%2B5DsAmS5rfB8YH2URj8mc%2BCpKKnuI%2BfvJf1Jpnc%2F%2FTDpbf10svpTCbxON57m%2FVqG39ZxENxfHQ8Nulw%2FfDDyH8tXErH6rMfxK8tfItvSX81jXTepLii6defhUmazdHnwvzU7fSilwJjlVd9nhzxh3R%2BsOfKxz%2F%2BN3z79P3fi7%2F9h2rf%2Fvv4sHz4n1uK5guaKIXh3QXrbXTsgnV%2FYz2A%2BRKE0XOwCrbepjhjzqOojXMUKzFUf1it0qgSnTWseFRdd2aQ7uOK%2Bm9hGRC%2FnJW%2F%2FOaF0SQHRiAH7NHJAYInzSQIrKbjCgWBdUa4QBboEgYW9d%2BuEgQP%2FvywWsWvYRIGwwsDk5SFgcGSBiZjzpgypMFyf6%2F%2Fy5vTx9e%2FGXd3j%2Bb3%2FYM%2FSQMemupLeSANtHq0wJAhC5jDms%2FNaVi7DGsZroS5eDMkvLphdadh7T6sVhmtRk20ypDBqPMOXri%2FfAuDKIiXzmnNHsGaDQk8c81mMXh1a%2FYkBKpx1JbA1xTthhIhwDLN2JsoGarSsNr%2FPSTmxvuz7fJ2cXrnd%2FF94Wr%2Bl6Nsi7sY90EDn%2F%2BafEnepZbA9jZ7qqQkcXev59rjT6v032MfkuFhdiP54fYkEY61EFYtqQLiJwMYBgt%2Fv0%2B6ethG8WTLWohf2KmRcsPx5d352iQLh5OFHJDYLAKUKzFSYTLJvWrRUVvuOa3knq7JGFG2Papf4QeFlp4IrXaCcb%2Fztk27aNJzt0y30EXtr5WyMyzKzlw0nlov92geTjJ0rDI0%2FZUSMQDVyVQmArEnsRMCc%2Fjl2KsEHgd1xykM8JDaND94m03Sh2mOj3SO5wYQzhzXWXNcmdPDnKgDF%2FptbSdubbeHOvGFLdi%2FBt7yFAzBG%2BXkodcLb3OXvrt5EEXBS%2FyDv13eJaEpybVNEMsZ0bDVHCR%2FufIf0674m3nw8%2BP5wv3xQvxD1qtjP%2BLX8%2B9k4sw0zcwu%2FJFeINmFh9d0bp2%2BvRW%2FFWbog8YD9z44hAufT7wjL1z5vNmUoix5zjpzKXkKPVXcQ3%2FjRbG4LHWKNVXS2r4lED1XlVtgMlOt45arOD1fWuo84VBFuaw6V4Rc96f3gOqK54z3VrgtlSLVfUZN0Rl1%2Bb1DjykuAuxXxLZBkfjDqeugguw5gqenvR%2FdQJjm49keudhrGfrRIdx2RW2w8%2BOf7pfe%2FjlfV%2BOfUyzSwfD8uo4SON%2FGE5846YU%2Fsv7Fn89ITr68Fb60wjEPo0UsV%2BFdiOOuoIWmVaIOa9VNVQIHkBhDc4RFALfXXVikCmtZBab4jVRIMlmYxA6JjGYv1z9UKOSqrJE6q5bfw7czOXh8e5kHm73YCnl88gr94l0RilQAkZmmmwX5o82IqTeWQTk9OcozvchPkiuaoYyg1BVsvDjIAUiK7oKlmBEWWJenmDDkgFGXJNlpatrMQI2ZfFFo6m0KWagQdUCh4dhKptVcI13R7U50JRcVpKi4nEQPtWi%2FgoLWFBR1tZmOUsFApEEdks3KpiohCULWdAqLCCiN6WjCx1NMaYh%2B0Zzmsx%2Fd7d%2B2i69%2B9Bws94%2BRv9utt6sv26fgiqhNiYy4wFhC1BlL2DOuLhnJsF%2BfjdiE2iVAZQ60jmLI0dyZW%2FijZdQa7amKDSWAAWwzkqSbrbPbqeyXAe%2FXuPc7WrP6qW4BNpO8RQEFohYqpI%2BIAmFX0UVToA4SwKorARoaTWP5ZuvEloN5A%2FABSxn1sC0NNsUHm9nsfgrBbDbkKTFahe9CKPF6QCArCGZy1k7OWnnO2rreWlNGmDtzkutY0%2BYtMNfjrs3R39ZfWzfMVd3Q4nCvGH7en7tcqF6GBpIbP%2F8o6RujcdVmAzyErxYs1S6M%2Bqjtq7UEFUniLlBCZu1U9stseD9QkFyT1iEu6slGJnavhe5nFs%2FuBs9a4OUCcxQOWmD8I%2Fn6IRthMEgha6jaOQsTMTilAiI%2FK9zZhx5MsUlSn2IuJxqvlMYTl5WbhBl1qY7sTWGXAvgr5vFE3dDiqMvE8fAheNlt4qG5HCavA3el7MBLMVMfLqqSApOYprVl6tA6h2qSRSSgjT5rqG6Ul7iABeUsHQtbv9JwykHZek9BAhCJSLDLipOE%2BMkaqo1sYQFoZ8%2BUjJrMHeIVvQnFzN3AOvHY9yuiVFAThR8lhTdHSOENlqI6UfiCHGhL4esmiVI3tFg7e%2FSjX7199BgFu52%2F%2FP059L3l%2B6by54hngxY4gjYjdsYZWoQx5hs4inpBz2GMGfUQKhAZhJUHMiKSX3NpZsQpimqSFRAJoxs1AXuBaX3FBWykX4xEXTCwBn8t6oJW3vzgulaPKkMGR3mKv3TcGu7MURSBzGmreisBNEPosIwoBhkp%2BYwnlKc3sBNt4piG1GD24m3f%2BSJ7XhZdFy2LPYfe6hhdvCRqQ1jVwOqGEsXVXSYdIqhIEmgpZbdT1S%2FXsGYxRvM%2Fp1lpq1Npyi09gGedLQ1wGMxFL76VeBavgv0sghRGwcEqZGGpop3qIHJzZhta%2FkfKpTU60zT4a2VdxOXU5bicugQLrA3sk1SdUY4NJ2yluJjFtbAL77SlNuetmtVJhXVd5NrSla3VvDVYuFY33yUjbbGGcesm1WamjjDUdOm2dFStEnFjw6Wb8kWEY8bLp8HsWmURu3kRFxexx7IyY6vYRa%2FMZ7XYLRrIOuzxLdnCUg3bNPuVLKztN53UgK5iBJiBqCL%2Ft2Xw6YLWgC7YXOrh0CbUw%2BZTD6c99bCI4M0qph7MGKdiftDUB5edzVaRvxPIlsn91r%2F7DebjGsHpLIwoK94ydJHeNz7q2h7RovfofWM%2BweRYlTe05swFe6atoUd3Om1REXANVkxEn0PLCLP7tN4uf%2FNfo7uf3jo65d24EIuDoZcsDobd3FNWtDg4QC%2FQNEuqXiCk%2B7V94fItCaYdU2CtkGGjNK1jcpzlfWhqS4gxFXfTKfBnC1ZdrlhWrK3rxnK30KzNbLbaCNClNNG6FTfj4nahuNmsuN2tuMsvTkZiC9FxMsirsIUQkJ%2B1XYhAySAC3KKm1bOpta8gINMpmxj08syOYWcaSAbKFkyULxtMfiqRW8cqdZKWuaVtNTGiEHNmFZBOHFCZ0cSK4vLr0ttbUWJNk7%2BGWP1aVRixiV%2F2pwRnv3g%2F%2FCPRuhiSpVslWaO5entZQ2DugVu1MRjc00eFdEwfzrEDonEtOX6dWwdVq0TEGcDqaQk8LrTZ7W6z20kiPApBFyDqQljc6VRc1%2FjFx%2BJZurqAy%2BI2Ss0tEyBCWxGggrfKKQZxStzzJRZahCm06shFSwnnAr4lW5FvCcocW7BT8ta2ZoZd4FEuLN6A%2BkBfVNmBZDVyRkFfFKirgzMKZnJBQ6GaNuHscJ%2F9KAmF%2Be5tV%2F6nMHj5cAiTKf%2Fl2%2FumTwWjEoVH45BWzuaS2aus%2FRlGc0bWgT3VDYsxhktlb5ax7LTd6XELU8w4pJyGVo2GCEWZIxBlIG%2B2I9j0AdiW6HZCLB6BERY3uhW3%2BcUH2K%2FCnO2Z5%2FVq6FPhsA5y04Xq8DLTzezTPrgeLVGM%2FPtcOah8%2FwtAKzyoTpbM0ZpJhVuXS58cswl9uoV1gQAcnumIIbQ1bs9IBzsU0QWjoZhBmZITc%2FWxvf%2FLtzCIgrj1aWf%2FzThDi2Bq%2Bp539rNnOitwrXolvZ4QBbNrcq78%2FOahQhRMbGn6%2BLLOtvV%2F%2FOFv37nxnH%2FYRyfLUm5Az7U%2Fu0WmgFr0qPa2fi5%2BB9D%2BDGAf1rWa6TOx6Qrt9Fe1EQLt9BdYldHpIMICaKf%2FWAzP5pUmBmNsmXLdDlumSHGH1Kk%2BasgNYBJqTyZDPAyaPQCl0CCKzM9IVBCB0caGp5tobpNMY0gAoAdTrYpUH8U6VlXkY9JXL4qbnjSR96GJ9HvaB3ueT7HSAgHwHlKMsZ8A%2B6O%2B7BMh8f2w3a63q8vRQqB%2FW9PzUOee8p5odfWG4bxGBhA%2BLmUGCzZOFwYPFOFXK%2B9YZNgqv5f44fn3o9NNRqJOZP26NnWCkTiMUjWWgW7A7XpMOUWriBpGD9P85Q1VA73cM7cRoYdiImmuhfiRBSP7%2FdH7ikTC85BxsPBE%2B8dE%2B%2BHiMwLab0%2B0XyAYlPsflI2to09jK2ls4UlVdU9wVDa02Jg8Da2Uoc2PDezjUB%2F2I2B1%2FZd1dLd%2F2y6SGNJLPKgTGPRHqrPbA%2Brs8LwbrWZEjtCAT45ZeG3lejo8xDB7gEotAxWwBI4GVOD4YPwySBmpUQauBfEYgzLDWQWyyPersQoUvIIgAN01XGVyhCse5J3621VowJlKFKUmRljVBfmBcQFHAG6tYQtIzBFRAWDVIKQsbxr6KZP2BjRrOJhDTCebTrYLmSebGiyizDJeWJCqSGPKFK92vHXuerSgHP6KTzY11Q0tTs1%2BIYpPLYJRdda4UEehdbmFfB0FnVOOrJa1DyqF2g6qSVaOEijUsoaqN8A2LeDAAmPZyUWxdfCyVYWqeERFJ5Vy4VnEcRXWVasHcJMPcRSpBwTCmQq4OIIlFRgL4O6x%2FFGqWwBs32nE9lEH0atTzO%2Fp%2B9sgNUUljp3io%2F1RY6D40%2F4ogQR4t2GJFO%2BPupqwxJ5TgbFoBxduA6gPKOAJKZdtIxGTmgYIRcwfoG4sorgA1ovGokxc2eamDlCsu7Owtibf1UuAVFq%2B5VpWIgZGs%2FzJjzRpgUMQo0XUAnQBmI2UAtxez%2Bk66RTLOCkLQ8UyjkJZmIIZBZJBdTCjIWNsfzsc%2FkH2D6tvLyuP3s7%2F%2FvW3TyTPQ1QY2wc%2F9J%2Fi%2F7YL%2F267%2FMd2Hrz%2B8%2FjrqBQHhm5QIBvnWVZkHLFc%2BZFLCyYNqD3oPOpuuCC%2FdDp4nU9rLNVqJGcMuNRyEroa%2Fz%2FTFxoftFwWOIbLr1aW8RLIuePTONyOoiIuLNILUWfCKFONrg9G%2Bz%2F9aPHMEtyKAJZo%2FiY8VEIOwgAU8nCaxsGAZaTGinOyZTKHVC%2BAyjpfF02mUYuU9wAl7KK%2BCraBSER3qNhQYA4cXk8x2bjkEOxSuia1EdhNTB11jCRUxHGURWBbNRORiA0ZqCZVOzstUa4WFMERMxdHcKYsMrbWKAMDU03qgDLDmTJdzJAmUyZX3R6PKRMFGiiKGzLRfrCmlnsqiBuyaMMCdtMWbJBOm1BSi1hV4R69a3nWTnYU%2FXWyr05GOwpSBtbPkSnDrsMcRjI5%2BFsYX4F0OB6mYdcaSsudGRzB2s1Gh4by03qzOdLmr8dTw%2FYJe96tt6vxHc%2Fah5mu7o7EuhuJTtjhsV8l1gfTLR%2Flp7dmwjCDaXK2Hjh%2FVdKKbeG8hfz1F94%2FGqvDNWOskw2PoVNWo49v1VODKjDjnNaoAhk3XTUkGEFEsIcP3V8vb5B6SOE4tIf13ptv%2FLvN5ggmP9xfGJDaLVZM5Y5YGFfsG4X%2BKNMpLyy5t6L7cbilek2IiLamGwsa3mXplwa7w3Uj3qx6qpx6YwphhaRM7F7A7uEsqxmpK8MczhSQOLhvEpANBKRTV0BWHExZZB6qJCQwaFltt%2B6hihSd44QknsDahe43R0I%2BcMjSox8ddgmsrhRSfIZQPjLrlshiCODEaJN7AGJrvmD3ca4imuuiQFl4vzMSbGSDO4FDDI7j6pDt6ZWNDjsPYMpPhLPL0VdmW4CYqGbKrVkWRnT2I%2FEju1il6HiCuwg2wJ7wsn7ZbfwJNYMqnXZrew6I0rIV2XNMsCfaFthz0P1jsecQbCOdYCBePJSpFuDYZqimtiVTDtxeowgHjtEMBzVTCfSAA%2BxanfT2OitCaThlwYAmB3wXttWVWyGaWaY9wA3WwKXGb8bmNiPPNTDL9g2WHpBPr5jFECsbEFBX6Cno7nJr4EqThTURCI47UloCTIBjkhxnQQrbUvoD2PmpGgHMhcUGBBi2NH%2F2T3HXX5bfs10qF4Yw%2BUuWKW3JgnNb1hoF6tV7WpQYjyNckRhdHctyhJ1rl4%2BWXtcjWUCCEx656hqsPqAmq7xlS9lyw36A2rjRR6MUYYdLBprf7w%2FrzTLJQnBRiJG%2FvmR5MmTDghhucppbxf7DtvFPhFi8aqVBBLaaPAz%2FKAFcxoJlBgzdYFiTeciYYjfYnCmzUg0VvEHwXsYLF3j9qqyyZCGcN3YHHRUJVrcfpbT6GeqLQDqIOlohAjHDThIUfjpsF9E66LwjcNjdv2k%2BZDLTDHpTPFDVtu2bpimRS%2FkOwWbiJNFIdkHKhuLm%2B4TJybLAoziyNgofjU%2FFv7JbhbTeLWE7kPtraqgM1cyZTVCUSuEBZuUk5rgGvXMNFrcGQulsLInUCUOluOgdw8VDl06i4wx1Gq%2BHSqEuDresgrpqXMdCJE3HKRuQaL%2B8Loh2pAYff3oNBLvcGgisoQp%2FWX0Ov75zj%2FrKlkgYxmYeYCf9pmIRqruFuBpw3Tad4jQ8l28FrRCOI%2FQZWIp8BtYwPgOrhc%2FAGpHPIJNxV4WWi%2FAZ2HonpzWozOrJS135DLXRY5sjMggw4DNxhqbZKki%2Bu2iwM7YJI53sZNnhW3YS9ccBhh1NsbYnNuzovWWAgwogypDc0q6TqEaGURlQFNc7S1LIZn9qVEyBzcfubPOpUwPf5mONyebDyKM72XyGs%2FlUSQHFkE9MPs55vqrJQI0yrdmizG5NCwjMRXZnc5HdylxUiLI0KnvUm7lInw4XkGAusgc3F%2BEY7gt3h1cI1RHG%2F1iGJFsRtEFZ%2FdiKYLNGDVsRq6tjsRVVR2NfKFQuInLEkhk5Yg0TOWK1iByxxhQ5opsTW%2BgePGcNHTyn4wCgKzkuRQZrUHS%2BEMOaXV7fJck%2B2%2BFVq8xGjhhAjTLoUKIBWQPWk64EMqrZQz95RwnKL9Hay%2BSQQTan2IJsiaiAM5p0iRo2K060obF%2FKU%2B1MhRtMLCRYcpA0pQtSEu8gFJMEceRY2g45346V%2B32YmswGC2LTyZkFhvT6YTY4nDZuFFOGRRBCk8j2vYMQhY%2BaR8HEbLAQEXHArDKjOZogCtNtiw4kFCUbJklEpXxh%2FhrGCRHoJ8HPvR2z1%2BDpZ%2Fc8f8%3D%3C%2Fdiagram%3E%3C%2Fmxfile%3Eh o IDATx^]Uy$A@4 Zk C;b[JJa5$X@45Ht $5LSi(>c;&cb-P%(=u]w}gOryu>۷o@ @@Gv7 O8ݻnwO?жYE4<*7}Fc~%h;aU/"m#nNK.mٲ]~NsGu4!P({s=nŊnԩ3LW1[պs<*?}{\1?zgˑx/8Bݜ ]ܭji-z&py繱c6D3z.dlr=*)̣AE\~9hso9G?~XATo'>Fm疭F̷Rˬ`MFG"?2.uN.|Oџ\PJ 9ߌ3r]*I@n̰u9d0ob=QRI$І0>KL+v'~~m۶qswf( & L<=nsGqc<=kb=XQzK˳֘EP, G1Vp97Yu煢Oo?)>^Mozoo\gm%U|Y|hIu0ճBY<? t\i@i/Mj!%pF!ZRG9Qȇ^S=+@ϔ"شˡr[N \gm%U|Y|hIu0ճBY< tLiHi/M*/'pF!ZRG9Qȇ^S=+@ϔ"شˡr[N \gm%U|Y|hIu0ճBY< tLiHi/M*/'pF!ZRG9Qȇ^S=+@ϔ"شˡr[N \gm%U|Y|hIu0ճBY< tLiHi/M*/'pF!ZRG9Qȇ^W_zY)'p(R0^SBƛ A~! r8k-rt(CKJ+)Z@J!P֋`)Qixn-[6lƍ^"cѢEnǎnnժUnҤIY \A~~Ν;ݬYXSL15٤,2gK}9 N檜~rTMGg4~zN|]ywHh9Wy-'\s[zug*b0$磌r_}_sX֋`(mcu+WtF95sLws󩌫U?Zql۶m-[t53]~ߺͣz$5B롔^Kmr2o?Xkb5!`@?33g1wulMɏs„ =h t,XK to~ӽ=2:}xY^@䄢ۋ̘5GxYY/dx瞛͵k=#ovo~}7d*7̩Ν;w,]'Ov7n̶Ca W?N>}A'wOfZ#~Gs<Xez-ܾ_ERUGYow '>8 >a=ϷN;/sSvH2vqQD_І%Xvi{vCvs7tk|K>n٪oai9ܺ;]$g{'w[[Ue1me%n}w}@p?٬ϻ;y}һNrK6/-_l[ou[nG?nROe֮?>\mK[r􁡲x{O'pgsݝ9l761nŊOeO |:,vgUyiۏu%+AWqNcc~w~)"sn߾}FlgErĉ>[d FQ^OX~;\؞'q~1NAoh8ٓ}nCFDNldk<:7хۉ<'>j՛oЇ7;1^297 1bرc5IrrM,FA7S*)~-(|,eF)t{9<}K_r'|rf eKyCN̙Yr.oO%<\|Y;g1])O.2%[vr+TUoZe|Z@I<'*} Եk \-A PgyW뮻ɿ֭s\pA{8/BΩhWʇe2o}J- $e#W't%5^jGco__!h_rN?վsZ}h$nkj,}R!j2Aeke1mgÕ8duZ5[~]_Mi,limްh5/{|x^ t+C'OY e1U9%>]>VtObRc[1}̓hqͰOJu"k|a C꾟'[:͢\ߠA.+r,@ 7doxb/71wዺoꩇ(_%Ϸz ?K/4{C-)M2cU5a\}ߤ/ tPWAxRW?UH-sKY/y^@ѽ'(﫭εx.+sZd2c:~c\P֋zVYm_&OP@'uʚ… m\2ؐJ&vw'?їO;ZVCmJhml :^T"jLeqV{ tx @>hG@k~{1S@-b۽t[oW{NWp/-qR,hvG_S]@(5Sa[cCߌL෾l˲_/-mʪ?:km' {~k-uحV~5_-k \cXJwr:&WA6pd=RVxwp<#'%[UMƋ -'Qkghv;D3kJLG ҿĴ[x'r _n"?D贅[ef5aSN9%klժU%Z~UIM.o7|]k/4Ns\憿?ip>Z* ~m7uiF=eqh.ܬM.wvn_l{F|ukג7{N7-|Kx{UHsW=c<~7w.n&b-} (x?? ݅ۛf?ʇ>t0;tív}7CV:݅;l]l9ߓ Wo>tzU_zQF&h2Y|1˱&qA >^tÇN7^?=-*w}CT!u紲H>Gua~䩎ǖtwmw'7*8=ŤWH>mOTH4mp/p.6 В*GG>ᬍB>@뉠]&#P֋`*d6T[i8Y|hI#pF!ZRzLPOҢ@^6^c9T^N~I!ᬍB>ёr8k-)zV('.)- 4Ei5C䷜¹(CK(6 В`gxҢ@^6^c9T^N~I!ᬍB>ёr8k-)zV('.)- 4Ei5C䷜¹(CK(6 В`gxҢ@^6^c9T^N~I!ᬍB>ёr8k-)zV('.)- 4Ei5C䷜¹(CK(6 В`gx>m۶uQGEt cɓ''x18|gXσ$hPGƥɅ #0? j?\i;?1cƾO?]xݏB |ssw} l59|K;G+1,x8E(dvjWZN~G?Qww?  $} eSnb=*̣AO''̏trO.po߾}.k.w뭷v? py繱cǺ|3V&oʗMg ~hGjk*S(vX̏/_ZI ә-[_N;4r ' s=nŊnԩ4**At#2u_>^#2?z%q̏r$5 5h7 4&["do7 OZG ?pw;޾I۶ہau-sa\y1?*BMA6h7h p+};3hGsrHvf̏䚑K7:'C0'@5Gr`~&uz 0@dx׺%Kl!PȌzQCQ GZ'G=ʨO? i @@݀$3D@ @O! rZ`~: .'GN^k̏Z s+?| tN\ ךep9 0?rZ`~: n[cs2sZ`~: .'GN^k̏Z s+?| tNl kMQ29rx 0?j^7@̭1 @ 4If @ :'CA&uz\N̏9N/ V~ ?'@5Gr`~&uz 0@dH&uz\N̏9N/ V~  ךep9 0?rZ`~: n[c3@ @h t!@ @ ? tNl kMQ29rx 0?j^7@̭19r!~N^k̏Z$ kMQ2`n减ɐ" kMQ29rx 0?j^7@̭19 "'@5Gr`~&uz 0@gH  @ $!B @@~  ךep9 0?rZ`~: n[cs2B9N/I ךep$!E ךep9 0?rZ`~: n[cs2dDN^k̏Z$ kMQ2`n减ϐ @ @0 H2C @ 09 "'@5Gr`~&uz 0@dȅ9rx 0?j^#'@5GH>:'C0'@5Gr`~&uz 0@d69N/I ךep$!-@ @@`d@ @ `s2dDN^k̏Z$ kMQ2`n减ɐ sZ`~: .'GN^k̏Z s+?| tNaN^k̏Z$ kMQ2`n减ɐm9rx 0?j^#'@5GH>P>>ۧ @ P(K8@jW!ڐ%mqiuIKOZ,;w[refxWb7n&Mͷ{6ki̞?3,mp7t# IDATӰm؝9s۶mP -CtCL-ܒSH @jG@Iq@h8mqiuIK;xVL飏>={;]|CfMk'LV+bo͟?߭[]p_9s2SbuisOi5M,*4py51ІJVgWbE;o0"4BZ+(V)g0%ΙB$G\JP hVWA}2ڀU[\Z!4R dɒl9~h^KuVl2a7nܸDĐCcǎnnժUnҤIn8sF #hXn_hVחNVQ !i B`ν}kmkuxΝU{-X~}wb`Aڙ8qb|nLgV}ۗ^ziK>K.Q-\&Ox۱ꤽ7j]ڀ %=.c VgֽVWĀo}i cn:y|7fpӦMˌY7iS#ƭ 9sm8c˿ҡAO0!3ƝbX g(+ckիsүV[yez_<~!-q|[{f=Å fǹ"4[n.^w(SDZu'{_\Z]}B !K B yںp;-m7 M0DW;jݵñَu p1rsYWJu}:lg͚5B?oߏE V@י}~s3jE|1+ ^Qae΅N{7G ~hVf1b5~VgֽVWĀ:4 hC۔mePh1~KvjN:"vG>ɶ뮻o#@{@?1Äp w?nx2炶O G*U&GZ]Yw :ChH"5`u*hov^Wmŭ t+nyiuc11<;CNj:ucQgjQ$iu*c*K+@2-.)'{[ t| n@{^| ' R_G)S o"zqvdr^^/*7Wc曝z^Upkw^"Oxm t5N v\Z_%6T:ChH"l1񵽡i0;7a5{(#t=w@K۝.\%\13&.mjn@w56m䚻py6⻣Qw@HKKaL)mȂ:ChH,&/^M-u'sآJ5@=\Z]գ ! B yںp|c5^UVug/Ju.2@E&# [mmqiuH!<mkuB 'BN^k̏ZD@;| !E B yں0@@wo|MLآj…a K8 9VחNVQ !i B yں0 ȍN;4~}cn 0hs.nI%>ڐ mqiuH!<mkuB 0Ч~{/}G?QwG 00s.n`I,0ڐmqiuH!<mkuB8 3dtAÌޒ[T)!': Kߣz6Q[\Z!4R$O@[;#GyqM)r׿us Hϛ7}ӟ1s&O!̏>@#q mmqiuH!<m݋{۷o߰1ߴ:m#u]Xv~k׺ݻwC=r!nҥ .PBF)52C@H+mmH:ChHL!s7ov?[ad ٳ3:C] 32hS2\hCťB#@u%?`:@]8CֽV|@@7[mȴ:ChHL!h٢-+ffjE[Z!@hSnw ! B yں0:Ch$pW2mt:1. ;hzmqiuH!<mkuB@@[Z!Iw{M/[,;~ѢEn֭6lpƍ3[UUq_r5jTaT_\ 2ΝݠO-"=tC Pi0 <S[\Z!4R$O@[Z]0ֽVgR* On$k 7Y?@өSF? ʎ;ݪUܤI2 Ν;1{C dF:t|Zx, {qgi)Z]yiLJ֒.RHH@5!c/mkuyIiah1bpvLk=/Z.L~zl\駟v~} t;*O?ؗe{JD>{l@7^( ! B yں0:Cvں[|pC:sLm۶L"K/͌"oC*:Y1cFR MTz.-N8wg1w}C+^»e˖8ٺ.ۅCu=f|O{~_1ɓƍU0~?Wsኻyg)Xb=VZ5e!}!\vj/dԮd+*оhuUfQd1 B yں0:C" %K.(q5 z5gΜlbp;Åf;\[ -oP~K;:ٵO=TW_u9;b%ﷴj lu9yî}1.ˌXod<;_{lk~\z„ Cd]Wo~G9Z*xv޼vbj%=w Ꭿ!}Qb&}Oj 08 ~}u="A h^!"`ں<_׼5N}k_;#;׽.9AY?rcf?*|XF•X5bi[<›F5 V?~|ڛxuhcC)J R1wu;3g=_ ۗtMbl_W}󉯁jĞ8qIV+u߾W\q0v.Xh tx=1gq7%C%{UhC%PXHGѸ3`CNl~/^z饡_|ѽ J={پ,?}W~:eyg-x}G#8=cWW{^|z*.ܡI V;쏕Vo|k _ngeUկ*ǫh߆{~u=jUsc-gϯ 91y0DC@ځ?8V;h3oy7}3LIh= 1h`~4. @ ]1bz!癑U}kMĀ xַ5o{eшlu=^VïWBÕk47+j:nwt]Wnr@@KfR{K"0ІLRXHGѸ3`G/@˶hY<3yeEW^qz׻[uSOͶR_|v[㯿-&;zӦMu+bjky|qxNۖ궿5Ē6;@VkO<ġmL>@{S- $W9WXsz w.\8ts t;k /@HK $m$EhqK96Hm~bCf͚l??zlZjje:ޒ_h⛑&Cs|nZ;sxnn.a_oʇ*wم1݅;<&uxNU]۱:s6 ,pdž[.܆+xVhN ]G `~1*L)CV[!}{߈̉ ꪫ_m?֯m\ܿ|2,caRmH`!mGR΀ 8?dP?.r2m@,ux8CwrS2N=ֳʾRDsw)'{.Ah^3O~w= /t:8CօviuuwhAmqiuH!<mkuB@@[Z!t|~闲;|󀀆@]fh Pw7PC @yhϹ<}ӱhC6ťB#@u%?`:&;۪~wqjH5.[:+J*|?޽{݂ ܴiܬY4 k׮usu+WtF*4A 9V/u:mȦ:ChHL!` Tsg}{ŋi'O:I&u<^L͛[yX56"c=vX |;0ƢEܔ)SH2Н)yiÃSf!"I[蕀Ku;mȨ:ChHL!` 4|_{_>?+-oA17|k;3mb,Y5w! kk ͛~oň>CnZ ?}HP.0=YSxɝ/.ЛH/˙y:#%\bV5]JӳxO=Tm۶lpyن f~Cۓi{6O~ÌQyꩧf:ݚ5kVǏ |U]>ɇo~}7d~xwOtw3f!K3uq꼯]7 'q۴_QoϽ܁~YW=VEnZaeul;*Ãٳg'u5VОsiu#6C6Y[\Z!4R$O@[Z]0(@q^bs+__ܛ&CK_}t7׿ug۴/5v+.lhK/iYlgyy5gΜa'N2g3kflJ b&.0GhiW>8䓳[-{ڗ~ʿro46 2mp13̮no y[nZ-Z>ho;6^?]wX ZXhϹ:K:k1ІjK3F h^K~tEhoe[>&}@{衇e1bd~wQG̮ݕkG5۴!:6Zv+áW:h}[VNf2[h9J[^[̰Gn%?r*9òk?pwGfY_֣lY t+s*}lu||KhsV/__ZQhi tlbWfkg5w]ƪ 1t2ia]ŹcYGОsiuu+ZR\~n߾}]6"{BCJ }/-Z~$^x[nY[[Ma^vmٵƭV)B_@Xڒc t'_,ڒi۲ѣGg+5!3_._qs-^wu| #p9<C#[DL;=@WU~՞siu#ۈ0n B yں0@^? o&+0¤q;\KPWpl7׮ WSmr3pKx=p@[S߅o[wOwINw t|ggi?pU?΅A|WoL|8xƽ%y9Sڬ՝%8q6IhJs.N2 ! B yں0@QڇL.܆WV*Rjqe`moEQCoVThϹ6Ⱦ` ťB#@u%?`: thShJHÛmWbdY:;+B@E@{Υթ6@6$Y[\Z!4R$O@[Z]0藁6t) 4Kk@*A[\Z!4R$O@[Z]0@`! BhϹB:UF0І$jK3F h^K~th, P9VWHjڐDmqiuH!<mkuB@mV6m>]v kر/Z@ %s.. /h}mqiuH!<mkuB@ 6B w=܈~pя~wީ"@ hϹ@*A[\Z!4R$O@[Z]0k@B"@4+2?4r̅$J'*B@{ΥUd}&ڀX[\Z!4R$O@[Z]0@`!@ۺ}_j@ rtVb VgֽV  0XHkE`ݺunܹk{ͳ}A@sFѕZ6S[\Z!4R$O@[Z]0@`!5ktY}A@ hVc7jwڐRmqiuH!<mkuB@mq Z]2`!3Z_%6T:ChHL!` 6BZ(;wYfE)SvQiE;:Σc $ťB#@u%?`: B ` Ic9VWh\mqiuH!<mkuB@m#;v3fd7>}۰a=z[`[vmv볕e˖e7yOXj4iۻwov9sUjion̘1nnҥnĉÞlRȪ}A W hVןskA[\Z:0BT .B@MF 13g l˖7&LȞUykƍ?~no;ٳg3bnݚsy~ܸq}_ru!P#9Mm-.)'{.A` v$_zṊz=hY^r5jT*ퟓbW^f!(9V0Kڀ\[\Z!4R$O@[Z]0@`!@˪mۆ+۵1K@{Υ5c -.)'{.A` dۭf 7+"O@{ΥUH1#@8jK3F h^K~th,f_- I޾};SM6--TSN9ޮ-ǰ„@hϹO1 B yں0 @DpO/ /+H}AKcT'3ZGF0ІOe_m~+H}AKcT'3ZGF0І}35d=5bNN֯_㌟o;vUVI&eA;wfc{C C Ehŋ>hͰ7gs8C\Zh_%6T:ChHL!` ֬v[)Gw޼ynʔ)*I@/]van QO?{CcngZ駟 tqy%kO>d'荀K; mȩ:ChHL!` Pm-+3;bgΜmۖI^z饙Sv+:Y1cFR MTz.-N8wg1w}C+^»e˖8ٺ.ۅCua̘1nٟyVm"+bUɓ'7fǫav_͕+G.%.Č{xǵW,Oq?9NlvBڕl4E Оsiu0p B yں0@ ,ދ.(#!7||͙3'3\;pW&C'FTo@I;:ٵO=TW_uֹ . oII?dK(F^6Kk#@*A[\Z!4R$O@[Z]0k%!?yk?s8s:#R~ɪ_zw!d?3>86|Du Ffk͚ o>0Z-o6koC#M1WbŐA뮻g>aMXؾ5 whcW:샀O| tVnK'i^}W c_މ@퉁p<[0%B\Z]#)V@mqiuH!<mkuB@ ޷o߈h?OS/g?/R /d?bbٓmcW~V7gy='p/bfƏ:(wǻ;C݇>L/|}_̮1Mt p[ꍯ} Ux8ېbUw|Zjn2!g?&oc}h[}h cV;i@˜m~w3aJ"@#hϹF@S 6@BX_ x- @bؽ-oqo}[__wcǎulmٵŲ9|7 ,oE#&bzYn*^ W㯥܅ku/^m+ t+-<s.)ܺݍPwmqiuH!<mkuB@J@ˊٟe_$&\C=wg[n['t;S_|qF:@Ɏ޴iSvݰ:ʣ|Z_Ӷemu t_bI,?$O{V!Y[\Z!4R$O@[Z]0ֽVg=p7ޘO 8ي;z蔻L$]L ]{VW9}0V[\Z!4R$O@[Z]N4Ng}}K_r]tQr;__ٳ~N4)!@M!P{OSXYƉ6Т 6?)߱c?1c;w>}۰aC'{k׮_>[y^l[xPgO<1kcժUc̙RK{r}1cҥKĉ=' nٲUӜg~q^b?s+dMozS=؋/>~}u{]wꩧ:? Z \ \1ІSXHGџ9sffe[<0aB:ϛ7/*;~[ de04bnݚsy~ܸql[e~x<3P \#sT~駟ήg t[8{ m nzy~mJ`!mGR_91j,+5-++WtFWs҆Ю^C-CIVCC2s?OSK/_~* /.bGLڵˉI?S'tO<{dzb>:3+[lk^(psF"J4viu#zhC%hK3F h^K~%uUm۶ l@cm݋NʶG!b{9':i1}k8 9:(PD~>l[~dرcݡ7;,3͇~;#2  v Ć@HK}em -.)'{.vjp]R:ֽ躭@Bɪh<<҃ pbX{d7 S 6?)oek%oN9aӦM˶r#6r=ԩSyk1l.6̏a\5Ŏ @`zyD?mEhqIy+-wΙ>I$O|`hVW!E :ChH;0ɧH jGQ2(lN>$ڐ" i9?HuǑC "ynVDڐIRԬYܢEܔ)S5Jh @@987g +Ehg)π{h4i46: M@ ?3l"42Jwϟf̘ΝO6lF,X֮]~lyٲenCQO<1kcժUnҤIn޽ٱsV͛71cƸ˗K'{NRbUۘ@KG4=< IDAT~C 0?x](< \@-.R1}be[<0aB:ϛ7ɧǏۛNz [f\A\{ P[Z]Aݢ$KljX $.TviuR0 k/ͯ sbneSO@ ʕ+ݨQ2~U?'1Š^m:mku!P9l\p%&Tm hϹڂ2 m-.vZVm6l]^Ih^Ko TKS :CKvn" tJI[Z]zJ @\Z]FqT k/mekoN9aӦM˶r#6r=ԩSyk1l.u3Z@آf^U wy&=Mc ,ťB^@ˠwpB{wV!B:'`~zT=yU@z6pVo}˝tI @uե;Rzb0H+$g^UH+F@r-nonŊ^rwyH!.nu{ե;RzbRȌzQK@{ΥՕta W;7_>#@ΏGG @@pn֟|a \{-Bod78# ^GeHG!@@pn֟da \Eq6EZyQ3$՜9 wJ"Y@c \-Exy繻}nɒ%s"{嗳Ϟ=kƌ3"yzF\]nڴɝyfԮ]رc='}fRԓ=gTLA@ ?<-` ynfO}ʽ+__d<o8xGqsL>kyooܨQPfōVguVF0 B6)0 )#Я@*A[\n-Y+цH!PYlQlx %@&De 0?*::^KBO+hCj!F) @ @+p@\Db B @=(»a .H{s_H!P-EZ`jV-T+_6MEz4G8^a )B,,wܦ ІҀ@{ hVGhmȣ:Ch$B%FK"( 4a*IQɴhV :Ch$V2mt$̏@LN֓hu o`@kK3F @ @@M@I:u 1ІkK3F @ @@M@I:u 1ІkK3F J.L.[TKMJiӉz. ;hzmqiuH!PI̅JNDQhTiӉ#. ;hzmqiuH!PI̅JNDQhTiӉ#. ;hzmqiuH!PIlQdtI%&L% 0?*6:'6Vg @֓hu5b Vg @֓hu5b Vg$]T+6:]0$G%F#$Z]bXw0 B L.$Є$G%F#GZ]bXw0 B L.$Є$G%F#GZ]bXw0 BآZɴ0?JMJ`~T2mt:1ZO%6um@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.) @ 5'ԁk.@-.in}}pO>d-pH~~ 駟^Uj,Je^1|֩ry;'Glmȳ:ChF\r۲ei:(c Fss[b:ug>S!&?e)*!gm3'* ťB#5]v[op&8رc1%&yY"슆b^8[q,{mzI@I"V0ІiK3F$ >я_yx>O`^&!|ϰHNDu;mȨ:ChJsNf:WD@n P}&35ϼ̟L[~E@=Evz%$Z]qhCFťB#U8#ܶm۸Yɫ2Vm'h2Rμ,s-0/aQ-PE^ h=Vk?vڐQmqiuH`,#@Sp.s]P/2 |>|M,YbY6dW[\Z!4R%+A!@Xa /ǯGDiB@[Z%vhCvťB#U2 t5,v BQ/|>|M,YbY6dW[\Z!4R%+A!@Xa /ǯGDiB@[Z%vhCvťB#U2 t5,v BQ/|>|M,YbY6dW[\Z!4R%+A!@Xa /ǯGDiB@[Z%vhCvťB#U2 t5,v BQ/|>|M,YbY6dW[\Z!4R%+A!@Xa /ǯGDiB@[Z%vhCvťB#U2 t5,v BQ/|>|M,YbY6dW[\Z!4R%Ν;ݬYܢEܔ)S:ܺu[l۰a7nveK99͛ʕ+ݨQr*u{P/2 c^ hOߣz6Q[\Z!4R%;uT~tϞ={Z/GW"={d{ɓƍݤIT]lj*p ^륄U"D{Ж-[}+xb'ϟp nnڵKfc=ӧ!,O1Gql3 hOk&ő@*A[\Z!4R% 'v[zu ,' sO?;k  +hz%Ǽu yke!Âبۏc,^륨UoH~R_|sf'v,YonXݻ73ӦMzw]rKO&~'WE#85":W޵ť $PUr,'I?'%*-s*'63gt۶mOSJx wzƉcՆ*dUj{l~EL؄Rw3f<š'~52vD)~:" ˛P}Qg+٭ƼjժlE۷3gΜUv}H1K>۽{wmm"I}?O>9;wM7 ]"1Ck?svIØ1cˇdt\饿 }^[E'?VEV yVgTIQu]uֹ . `h1\Nŀǟ[ tR N8ѝ}*?1{u*\Rꕳv^Hq/F΋Gy$PI BbC[<ͩvu[>}b'L0oّ"CLQ[/c ߭˘O~i+z^J*oʿ7}4haԥh 8qjn^veY=?~==:9IڦM)V˛ h_:c1ІjK3F$PUju]32@o SO=5lW=z[|Ā\tEaV'9YU%9]:+gÇ4ɼd&c9`[V}owWn:\)0 dZ vcƼVx7v!'? gջ^j_-7ВSxɟ;Z tVhbv`Hz# t''8bV YfM!5|fh՗mdh/mqiuH>4 z$Lr-tlfJ781 @mW6q5*j `r 颿w߰Hc~Kg_N[Vp˴uZ tZ淮:|-v}u$YTڀ.`DU@!IJϷCv:P/ڿ,r k1 M$E@z%5vm-.@Uٷ:q!'%e@'WcUtHF+g)ۛ-+᪘d tym5Ns V'u+^k$SHB+[Ǘ386YpQZ]eAq :ChJUe߫Qhu 1Q|WEpu_huIﹻ{ZS 0.u^ZExos*( &ZHzH.vf#9 XJ4*DCZC4RX)@O# E EĹ[{}=k=C3|o/{k鳿G;>KTMEsuJxX靏 wt "-2g@Q[i ~1fi^zm-k֭=eu(ʲF1,@eiIJ@M.T04 Gbt1V=.w赆:zGRe]f܅[գ&bتkel,0@uVh]ﶫG7mdjŷw:xMy։x͋U{t|^J{x4+Ҍ}nu{2K5ԓb+=ެ ف_K/ќF>j {j!MhM.T04 AQf0_yV2z]ec(&7J ёҘs^%3E\֣٢A5rv4PДE ts uXO\%,|i`YBXk=-4P]񣁮ÊɅ {  ڵ\;fl|[uW\ze.Cu.cYhE 9 M)HAP̗$97s^Fa$wkG?h:󬥁vX]4PДE tsu@9ⷈǯޭ&\\γauBuCS  {e4 ea`("zzԛ(s!s;ZhE 9 M)HAP@70X /~H~~ݚQoυe׋$IP]q ÊɅ$k_<` ʚq'w.|%Ku,<κ_M֛?z|IS+ԓZ[;hE 9 M/| oȏ~#V6?_: ۚiکΕu*L κ2Dz֞ϵcz@= glYaBuCSH@yXtL0A>OhG~yh?䦛n<Ȭ>$2b%Ƕ\3爕 Ց>4&s16跿+5&y"ЫW/9S<ʲ.cȬdW,xh U94&sR"$e"XiN>rF:BuN&iM.T04$E9酏I DӜ`}d!9T uRL@@;,\ahJI7M6&D.NsB4R%Ku2 Nhr:)%/I/|lL`]&#' iJ#Tda1BuCSJ^x @"X`e9!Br@= Ku2 Nhr:)%     IP6&D.NsB4R%Ku2 Nhr:)%/I/|lL`]&#' iJ#Tda1BuCSJ^x @"X`e9!Br@= Ku2 Nhr:)%     IP6&D.NsB4R%Ku2 Nhr:)%/I/|lL`]&#' iJ#Tda1BuCSJ^x @"X`e9!Br@= Ku2 Nhr:)%     IP6&D.NsB d˖-iӦGD|h#4&sR"$e"XiN4s}lܸQF)/.1cdƌұcGc5qĺ8p,X@_12fZځ\ahJIyccH24'>o.Ǐ!Cm_j:,chmuWvEyժUCX𢁦g@;D1sR    P:n8iii));ӊEٳ y -[͛ϣv[w Tn|G|ҥ~zYf1׾NʎL4Ɍ _}sb wӮ?64|pF_SN-ڕ/FUСCyLлB M.T04$@$@$@$@9'`j߾}dthkݧOc cʔ)S ; .,0\d q1br-Dk,jXXܴSw\mfL5{K/5ӷf]^nC t/Vc st¡wqځ\ahJI@$0e€} 4s}:k.kf_~Ɛ wTꫯܹs˚r}}G͹^{ y6&X۶G.(#hzH@5ƨahJIs @"X`e9!Bct)Cz:;Ptwj5к=sݫ^ tȺ=h2?44QД>6&D.NsB񏅌̖2qMJ;={,:6O4w+F @@Fh?ahJI@3$ epu 4k}a3g&6~L:~ mrJ6lX]R­7қK]5<7ڷ7V3k3_ POas/vXb4PД 䜀5n:3H wMN_N^@W wR:Boڴ 2StzrF類5 j󤁮F(s4PД 3z?796HIP]j l`hA 9 M) xh֣p^ؘ&L04x,zo1x:XW'Au~b@;E 9 M) x`NzccH24'P|7^ûw^yw9iP_4iMhr:)%/I/|lL`]&@:>cXos@$8 Ȏ#G4&sR"zk06&.!L5)rQ8[D4M,vY'AuD C&ɅHHHrI@oB_}za^j*I Eu7zϗvڥy:C@ý7F1H КAuYs#bv&sR  &% m)޻wڵKڷoߤ48<@oBuyd9@-КAuĐ64&sR  &#~zk[o5yfޒ:4 N7ߛP]Yqn$BT2v4&sR"zTk06&hC@?ך5k䦛neΝjj[[[K]r?}^>%zBh32w΃$J. W&,JIH |>?^usMuSNK!S@X[ @5nPn&Xlϟ/=z*S~@z|~o[ԧ>3D ԣ>Ѩ$!JfIҠwzˡ&sE3Ff̘Q8V=j(Yt 4%qF9r,^εLo%F?7GחKk+4\( A`JҪ#l1sZoZ5ydu׮]eĉU )?~ 2Ęh/ :,߿W,si5H d.CSg$(fP]fshB 9 M) x`Nzj\sLƍ]UVɈ#dŊGSN-Qcʂ q-Ct3g 믗3g~ہ^7mw^ɟ/ Jy[n+3kɦM[ʛoi)cǎŸ;w;dݻw˞={d޽}n-ZsEy"=΅|5|bS[hD 9 M) @F @4ǫZ)KV5qS-eiYjk0M]m{!I s*eիE t~;<JͱP]Vys]FX_'||CC9Dw.t1zMxΝ8Gլve,2Z J@3 >h͠:r}k+8i1 &#-_-@G+(:=oҤIm2c=gZw.'|R^x9c.qϞ=K.:;ݻwaR;r|a{.1HZ3.͹46wVM.T04$E9ϫ1rh7ȶ}da7n6+ǯVg}9G]=} 7Mwce+nD@6Js30>Fc3Y^䥎pe]wx1Z1.y1HZ3.2> JɅ0'y5v}tNѻAG;R^X0ѝx;{ )VNߺì;qN>z.iѣѻf~s݅;Fc)78'_'> sc15jm<~vqcş6N@|8hcGinGzJ)â .I2(0،rGT;@5N\ahJIHT2?9}w!]t ꂞ,#Ghޣ:)'@khɅHHmz~r盝,T93F@ yq#@k:?has Eihx;a<>4׭[gnZ ʼ' мGuȘԐ@3@k53d45hr:)%/I/|l#8˜g}FvV^h ̛qB{TI 4fP]30CHPvDic˜j%wؾ뮻̣B|i")k%G]yĆs!h͠:XԖa5BuCSJ^x FSOYf{"PJ r j$=1 6#@kPv&sR  賞W]uUL A@fRC@fY*hLBX @B~g-O=va R{>hڣcK.2"HZ3.Y7* ÚɅ>6ԩS,ZH9䐠"D?Բ1 Lashk+%v$tEiP *hCUL4IΝ+---r9 7`LfRÓ@X[, W&,J"nPA3w}Fo߾/Y_;OvZr(h^)>592NHk+4\( p &g6φ~73|ӟ|#uiڵr1Hvk &1>hۺO@мGu)NC@PКAuAM.`hɅHH 裏< ?<2h ?,'p: 襼D q'[nΝ;ݻi3;^K9"S39@ tHIR H / z˗;v?3zjy{c|qrK޽W^fdݻwnݺI.]SNr/:t0h;=5{쑫Hk֪&!߯d9͆`m%ځ+AH@w{9y__~Y6l 7n_߲ea޾}رCv)v2&Yfy&N{:5#߯f8X[ɬ W&,J"nPA3g5k֬?@s:b($~FLB`$fP]!fKheC 9 M) x`Nzcc(_=mʍp3H`!C X[d W&,J"#A-0ޅ;ËЃ%߯]qdځ+$@0iӦĉ6qa>-[&K=jCFǩg^A51`.ULk+4\(%0d<Ƙ1cdƌұcG~ZQdҥQPU@델F)/.sh,p`$@աRGy' ;/t~4()^@wz+RjV_R6>[םbɓM7z]otgG>?^ bL}gu߿._/"gJe Lpv$Gǯ\khLBXEݠI0kԈwfE`wWZ%#F+VM:`nכDeƸ!:F|G\c\p\2srW_qIKK1U{٦ɼy \GJm޼<:'Q>|h_q%گygǙ#Zo4.T33΍ T IDAT| | nOIҠT9 ?k,3[Uc8eʔiտ\R &-j-bXw /Y_|y5svm~ Us=טѣGq3Ъם}O.ckrcGǎkow.\X" :u֙/@۶: '`F nv3ZG:'Eix k+ťv$tEiPx;(gF9jULcȭGꎰۛ:jcV/=}5zͶ5eE7ݵJso?J~IPfg7F'yBc!4 5ҜKHc@;\ahJI2JuZ=^=tNqXjAnn)mL[ȲV[39nr]mof2#6dN r[zF}套^/拃?& ~az|֭m6gǎ[oɮ]̟ݻw>z޽揾Z[[f,w"I7&i@Uh͠6aBuCSJ$Q\5W\qEѱdx&MjCvs2$q>;~>S3Ϙwq޹s1z7C7\tE|nݤK.ҹsg2J^7v@]>눣 LD离z15xu8xh7zw9]ov{(~?\|,vʲԮk|Vm]cB&= yITCauBuCSJ^^>:~ݠ}{-^xa@Gw5X;},G}% :z45T Er@;pe:4(<r0@5(z}׿u9|Vm{'@56zF@kՅ;FFM.T04$@$@կ3ogGB?Ҫ14 Lqslk+v$tE) $D`Æ ~Pۘ^>hxH'%<@k前\hɅ>6UW]e|M7پp@| *>5B2CR@;pe:4(h4!2O}SA2B:cP)$dځ+A@s7 !pꩧ=cK }IY(9D{T'6 @kĒ4&sR"#^80\pL2E)ʇ~.L@{T I 4fP]S@&I @4PД M+_ytށ;+/seeތhޣ:dLjH5ꚁ2Gh4PД M`rqs9S2\@u4$2=fP]A M.T04$EGq~˥^*߳>;CB?P]f$@{T04$kh͠\r wC7|)՜I҆`N63i0_/Dիá5$ yŸ1#$@k5&GvX#4PД>6k&]w̘1C>E]$9sΓ]AT r@H.P5 dZ3.SO0Xhhr:)%/<텏3@^sw-6m2ҧ~?tA`ڵr1HvDQ=a„6F\@uN@ y>#` 5ꂝhv&sR  W7G}Tz)'p|c=V  G}o챲L l֭ҹsgٽ{w#~.NH hޣ@0H uh͠'H4 &sR   ?3ʕ+蝼G)};L=Pc9޽ٹV>2SNr ￿~ƒh={W_mvu{hԸ~lM.8C5Q󯢁vXc4PД9$w^y_^zI6l lܸQ^uy7dfW7ߔ۷ˎ;䭷ޒ;wʮ]A~l_:tN:I{1TM>Q>fP]g4BuCSJ^^ؘJP&Zw?"h& (TL% Z3.ߴ@hVE0&_@Gnۻr5Eivhޣf% #}h2M.T04$EG1 T$p3AH{󋆭I ?КAu!7h~hr:)% 0 7'IAКAu ;ahM.T04$@$@&~. `$ІI@kՑ\[[[[ #&F ?faڴi2iҤ´( ,WD1|Yd̘1C:vXlbIb\@uI>I -hޣqI 4h͠V<܁v &sR"tKe˖ɚ5kdȑ 5bnsHBu9D)@MКAu5F4&sR"TyǏ!CT4j\Ge،38[NF!+V0:TT7k,';wn͸qd}M:hŲjժÌOwu7{˖-ϳgtg7 Du= D{T IT\Ba5BuCSJ^x _5Vp²G՜YU}~.#?dtVӼqFӏALb_F` 钒54Q]aqr$@T0t4ˋ&sR h(uvYPGw6@W3кR:/( p]h|7pC]lrAɆ W^1F^M6?c;[n7|Sm&;v(ٹsڵٽ{賠k[ GCӜB{Tȴ NT a!BuCSJ$@º#|Wǟ/ka^p;:N4ݥ.gK>s='駟6FW^raɡj_w9޽1ݺu]JΝ50o?CҮ]">K-80 $@{T@2ITI MM.T04$EGH^{FtuUj;ЕƈvuwZEM]weo<5H~׻U5=mӝECOO;4Ї>d̳??.b5ꒊ@мGuíc@КAu!1hɅ0'5]͛WtWܚm=BmݩS±oe]fv;wxK.-nWEǻ {'> 9孷*[U:ɅFk%+&F@5:~G@kՅ:FE@M.T04$EGq;κc떿ozmرc͵˕^qǀ~.:NԒ@мGuϗ@5w@;\ahJIH j5>y~曥K.hE$PMs0Z3.644hhr:)% x>*9;Yx . sf$@աRGy' ;/t~4()A 9 M) xn/|luɜ9s|8( мGu@S@k54`4$+A 9 M) x`Nzcq6g!wuys/7ϪX(9D{T'6 @kĒ4&sR"#^80z̚5KپpπR:mgP$P#4Q]a Z3.wj 84PД M@|UW]$3:cP)$dځ+$@$rgSO=%vXBޭgڶؒ#= o! KgJ&hr:)%/<텏$0uT/~!-C9$@l &E>5b'Jfh2 `Q4w :#L6D:qDϟ/K,3fHǎ UVɸq㤥E_s&Ms~9眚wChMeOduΌA ehLBXEݠ#FȊ+rҥ2hРԜ5N jR/)m69r1ysJo.Ǐ5kֈѣG#gNwY}ʗe룓~#;<ڵkɡzNzVLV8I d@;pe:4(y=&? 8Pjɓ'ʕ+[nh@+ 7dرU$Ξ=<z2|p?-G|*vڵr1Hvk &1>hۺO@мGu)NC@PКAuAM.`hɅHR4[YW^m>ӌ!T|@n֢e˖vСfSNfGVZGyDlbL  G7nhv/^lws̘1Ƹ;ѱ(2S-.})7{D]i{\ׯ_O5SL1/[t^}kο#><˳>kp _:(ZR}q֭[sβ{6F RqL0p*$Pw#5@;pe:@ njfΜiuwyذaԣSqrE%\R0j/ @;½p"Y鶦;ڷQ{D:z 4b{r饗jXׯ_ouڰlT&zqnjug/6ƙ1]آ@cT w^|c39F3Wʹڜk# MIR hR>h&Ei.8-p& s hM.T04$E#---| @?x WKfK3#-zv$tEiPՠf(OS93 ! FJ2FFqH X[ɬ W&,J"7lݻy޽'?Aͅ@z9@Q|jQ1r"V2FIҠT:76p蠖dg6C8* T%=: $$КAuM4i"M.T04$C_g宻]viҥKٶm%{H?I[WZ V\hMM5m48 4as Z3.6,<hhr:)%B@+z\:Iwޜ?=@~ Y[hLBXFyz@ .u17wYsħѶa͘ѐ4Q_4lM! @;C 9 M) CuB:~ 6RrJ93 † br+nzy6<n2-| IDATt׉Cf™#!YhLBXFyz@Țh{ʂ ]AV;w+R6o.ܼ:uAm8e$$O{T{ |@k僊,hɅ`h:x` I 1a&LW)Z[܁ypz0k+Ev$tEij9&{ng?+<1ѕO msSkBhޣ&D)@Ih͠:bG!BuCSJ04P<0$x 馛*i )B|j"hRdځ+`7JFڧѶMSmhޣ&@)DT "hEF 9 M) Cu@(e;t Uip*" yIU 5$hF 9 M) 4\_oͣu)>WX_|O{nh] 7ɓ@Z3pv4PД>6& g=@>5A4 BuCSJ^^ؘ5L 3 /2D& 6EOM.T04$EL<٫6&]$PMG&fP]6)?jhhr:)% H"|{M.8A 5as/vXb4PД L`2ai߾}HπR:m(8< ԕ30fP]Q5thhr:)%/<텏I@턕cHkah2 `Q4w @F Ffu'S3u@YLhLBXEݠf0$Qh@gtv L݃a$#dځ+A䜀g69&#=k2|. % #}h2M.T04$@$@!~p:# 0'S3H X[, W&,JIHI |Vm-ShޣbHZ396vXX4PД$D VsLfrS#o-o%;v$tEiP *hC% tFaםO=vH9"Jf1i2 `Q4w @F Ffu'S3u@YLhLBXEُpo߾]Ə/C #G:eɒ%2c رsL6̈́8qĺjϞ=[ƌ[v|VmP = `J  bRAhr:)%5jTrС2gQX|r53 ԕk8 @;pe:R iz̙fvcǎ5ښ'[ĻRSHĆ@&<;&yR$ 5ꂜd A@;@G 9 M) xh# tuMOn.]h8?;jΝ+Ç 3/="݁;31{av£&xƍfGyĈNȳ}٘To|C&L 'O)SqW?Sc阫W6Gg:Ɗ+LSN-ٶf+0(CWbggwͣ'НlO1Gf "Y hLBXEݠ!GAUϚ\5@6VM 'Pd/\,X`n괢fT_~Dycxzۗmo WTh"0`ǚ[n|iPw5c, x`my#, W&,J" 駟]ʻ`H zj2FF1H X[ɬ W&,J"~ꩧ zM65CY YH(4Q:.u$wh͠BG׫j$tJi85<رwK֮]D| D tV&If}@ YAhLBXf?._%>`8i3 2@>h͐HfhޣaCfP]<hthr:)%kf9ٵklٲ\[o;Ws?h~jr*" {kl& T% :`hM.T04$P}1ǘgVzYŋ뮓zի D Asj\sEۈx2F^9C E #ބȕHd@;EFuCSJWm+Do4\;pY" @?ͬ! $ |%WvXA&,JS!P>#G?H|Vm"&= {GT׸a}BuCSJ_my'~ARD$gw5$O͐! @ydځ+N%xj]9rL8Q D"%Y(M% yꈙH_N%4tQДD:إq VsLfrS#o-okEؙI%kiZUVɸqd2f:t̟?_ٳM3;ӦMI&&x≦߿ɛ=z٥,Y"ݺuӧԩS{ҥKݠ@6h*B{Tא9 dZ3.SnH܁v&sR@C&R=bcXӧyOwǎ+SL={9mMx%=jԨ":޲eˌ97 RB?j"S35 F$$X[,4 W&,JS!@ ͯ KVw<̚ 6Ϙ1C:vhb=S ̙3i">hLC@y8" 5n£v@&sR@C&*guWZ}qm-M܁NtyLPIX[ v$tEi*hS^vrnp!Gֺ|VmÚ1!?hޣ:hؚCT2~3v&sR@C&*e@k0[rqaC 1G7z= <Ǐkkn t!S3̂@xX[ɬ W&,JS!@ 2*&ޅ{`smkUg}+͛7 7g}>+ж̖?4QDAT*v`&sR@C("|ߗ~Ҿ}@״ lC>5C ԍkn(:v$tEi*hSA\ 1{~gڶIsMB{T$8MJTWu&@;,4\ahJI"@ aj&|rȰŋX;!UtUD4 &T$8MJTWu&@;,4\ahJI"@ a cHHO0A:udE?h䄀OA`m%Uh2 `Q Ts&&SO#}}vu& Nݝrg$`m!54̘(M~{#ӟ/#01]V[x_u_RxO}{O?ty'(6?cE#E˿y.zy(__ .,ҟwyG};ѣG"_lWE9*+_J-[׾VxW_-?q/biӦ_fM!|;vnjf*㏛;t v[G}Լ;^}.z_+{.z_w_#<{ǼG]ww?|)R 7`'>Q^k?묳q;Q_;կ5wK_={H>}SOFWjf!߯e9F`m%Cځ+PݣGhΝ;AdPèo]:%M7dW}̙Ү];ctk_WSm?0𣏕ؼ=b}]zWQ>y_]t_}5ߘ88F?W}_w5~`Gk}_}uޟ:uj_~u5V}l7,/ߵkW}k-{?yF2 vLBaC<3ifW=IJ?;餓>^җ~aw({y~Pt\EK/Tj{[߱cGg/3z+0uEmE~a A h!LDLBXEL<9 ds='㭻3@fc'84Q л$4tQД @@woFsR3m @u#=[`2NTqu %\ahJIHR&׻r-ܫW4)/(O3 B`m%(4\( p &8 mF2lNDJ$PzhL@ 9 M) x`Nzccp"wRc>5c, x`my#,_+rd\L-~F$O7h!|j&8 Hk+!48X&!ΊʰwXhMmo]@5?Η@kՑ>< hr:)% 3;YP8I<8@&Jfh2 `QJ$@MJmۤh9@EКAu ¢Ʌ>6&'gwRc>5c, x`my#, W&,J"nPA3(h3 |jCV2IIҠT 2J7.0î;{0rDb@;pe:4(<r0@!dмGuM%КAuD C&ɅHH #@gdAf|j&8 dk+ţv$tE) @ZJƍ'---ҿ>m4ĉo|VmC;"ZyjmH КAuydT˜hɅ>ϗQFtR4hP~7n(#G4 PM#dŊ&SN5cb+Ř  UjLf̅s#_-_@;pe:4(htYl=zA|衇d 5Хn._j1jlR!F}E>52fhV2i2 `Q4w : њŋim;iҤyɉ'XtZ ѣG]jmeټy̞=[( ,0GK(~zYfhlםw)v[=\5k3f̘1C:vhҗ=]nb,D uŕTF ߬𩙬͕@# MIҠw:ao;m `5jbL"3g4w[&^pa4K,1FvݺuK^\@j^}GMG߾}XRc?d3RRs~W+XjaX.mT =KcB$ qiD@M.T04$@%zСSqd鍛R[s_@GqU}۶mmb\۾*Yw+X@2Ը~_W\avմkou'֭oOfǎ[oΝ;e׮]ݻeϞ=w^󧵵Rr:EͰN =@vH% (MM.T04$@9 ` NEwj/_.n3350j ǎkvKY[͎wv5jlΝk7\fi{ƨ8Ojt5oڵkolذAz-|;CWQ?C{O׮]͟.]HNQts?ӡCi׮]49(jN.|j.)V2 KIҠw81]red9J"Gr;q 1D@Wځ:>Rԗ ?7}͗O}SriQG%O@;k6^jwqV'|Μ9r%|zW|+ն_4R 7VfOdmI mhLBXEGZĂAݴiu]կ~\}AUN#*g6ud$4Q]Z$fP]hK+hhr:)% j /P>k]ȋD O ե?#F@a@kՅ1vX4PД @SGK}5G/f#ܙXN>5Ӏ8 dk+v$tEiPx;`0>govhm 9: ԗѱ7.fP]vI7rh IDAThr:)%/I/|l"}6?lnZo܁ʊ2Τ Lұ2V2GIҠT DcVWkkk%G] Q.8?@ 5q󮣁vXa4PД)УjY|pJQT5hA`P$P#4Q]a Z3.wj 84PД @Sgh]>uY2Rh<V2i2 `Q4w @W^)>|ߕO?=6hmf/ @{TW Z3.P0 hhr:)%/IƍeȑxBz3cǎc6mĉ jjS+jcگo˨Q:t=zj۷eԩS֩j'uG?ɓ'KɯAQ-[&z( ,={yל9s+{|-h8uHL(JMGIҠ$yǨN^mȐ!Em,uY<%a'U,Y} Qd_*(5h{ӧ˷mccsyNîڵkcv5\#&Lhc}>PSJ:gM J2 W&,J@9[jU;|®/׾5iii1f946j14ڲel޼J?nWm?i$3F{̚5KVXay$Gw㻼јhScVł3[}=&>__T3ZJL"3g4}9wwkS vnݺlcVS]}~O6l 'l̮b ]իWC_>d֭ҹsgٽ{w#@Lr:k+v$tEiSP4nܸfBP34wΠ~sMo߾ew_Z]ccرYcp‚ьm۶׽k/{&6jM=Wƍvr1W3q>Q?Sj54j?Mh@Sn5f\^c&=j׭['?;>Z׿dرk.O>(K.Dw.jлtbS/:t0Ӎh;5|ꫯHk֪es@y24uJ@k%l:vX,4PДpGwĺ˨;jL͐'57p[k;6|%՗N6~= 4nˇhR@k\ hZ$@tEGK{=l/'b~]r1ۼ/-JrLjk͚5տۿA$O?u]rKͮLx7;vΝ;e׮]$qq5׺>餓׉I@ Ց) >h͠:r}k+9i1 &?vͨ=\@aǯ@k#F0G/kKrjk+u}uظ=cŏ iWm@WtB T ޣǵR4':@96:}_朧W^Pn3J{TQ NTW3! ¡Ʌ`_~YۦRSW~Ȧ4,rGz!_@*Q׌ߛP]32IfP)#@ hr:)%{ǝv ($&!Roq&Ai61:jbl: T%ڪ& 6&,JS#PKYFܼ:%"PK@ghj|(9 dk+v$tEij|wNm8pF  tFaםO=vH9"Jf1i2 `Qziޞbp7ܧ'#pH) YvhLBXFyz܄| S.IH<V2AI0OSC_7n#GĉeРA5Æ'So4Ѝ_/&: sF Jfh2 `Qijkft77ԗB YhLBXFyVqe̘12tP?tIƏ/g6y晝iӦɤI O<"۷G6ߒ%K[n2}t:uׯ=pҥN0%|:aי"SG(%`m%ځ+`@1h=/kc]cʔ)SgϞmp[^@5 UeTx1JStt(cT@7+LY #0eBFЬn#jv1H :ڋg|[y;I[r7v|Ȑ!S 7 t!@yԧ.!*4a,#@v }N؎U@ ݀|dU:9f1͠/\]P[o肊eKG <*`Im$*6:+M iЧC@۪իk׬oR缪3Ƃ@[@p `!cF"lf30НA zW͛g~3fj7 tEa&g Pa̭bJB1ib@_~< ]a8}&g9('B 0)2:+M iЧCOHo6 &gtV1@p `!c \q{=5ݾ7 t#9Bt!V1E@p `!׉'n6N:$x_qwgO~n۶mMj@DԾWu%:BPQu&[c6 Гq2<[{np1Vi ZW@ sFՕHkF6 Гqrg$b˛J <- Иs@p `!^.r"Nu?~͊s6< A /<(ol·@ 0.:+M ) H==\tIH!ԊLEUL0\iXH!W\ѫqN}7@yD*FULA1\iXH"e2k֬qӧOw ,p#Gliכ5kVK/`c 9@ eJm6m-ZF.]d3i*h#<֭[,7Ww5lwd zꪫ ԩS WјXFkW+"j['׀@̣En4V1@p `!ʳmne;1xf3g[p]m͚zzٲe=/_هzoߞ0aB{h3깙Ӧ8cˌرciyXoZac^Wv|ƍ~O-[z=g_>{?m۶ݮe}i@(U]N(:gT]ɖbͥB#JJ {qzLiv5m:>hÔfMqs_@6㶪ތfnēk6f[E-z:{'x½=qr7–Ǟ{Ͳlvs;찃;ꨣܾk/}wuW7h 7p@׿;~vک1%yQ[$JJUL0\iXH"8ʑdVjWZƌ]rfj[apN6ͯj{K.įX+PmoFctfvFG?;cxǺ#l{t^< Λ#C vyQc#?ts4a,QP{7+Lz1Y3WoUm@gc9mm:1֊M£>귔vv{F~^fԹezy|D@{U$UɱP T]@hE̅'*WV{^sq=ChZ[M?x,mӱL紙-έ2Y㪎r-GR} 'k׺O#NyQa3Vz":+M iTݙr$7=ɱH'۝)ܶ}9};?q;OƱX:y];S}:\. 4R"@O$`s/[k۶m5RTGPߣT]Y97ZM@3zʩͥB#@.l΅;Hh"g,/=]g̙s(3V1@p `! }{ݫ^*}Wk%Wg$D@{}ړ5Q ?uΨGܞ 1RuBJWvGq{:[=li]@9P@1V1݁JBpGU $pu׹?tM <<!PU]qre:gT]F_\jsH!= 'G@>}4i={}#Ȫ~ |c:X 3mNp(V1@p `!ڻQ%M2.bpBwg=#l;'[?V#`̙HDZs2`҄FE-Qdr~/^lUr'x;G s>^Wv}:kWj<\1P^0&r@ 9bS 9`6 O~}/~k^w!#GWeCuO<4h{g3{+Эר_~d/V1@p `!ڻQ%M2g3Ѷ}ahV#*J !PuΨR,%1eSKF \\8=@n'S,@ Ϝ! Иs@p `![*ɔO.qH=Z|4$Vr̭b JB @;-,>_u =+NUL1\iXH!t)<]aW sF'P0UKF \ 'C =AXW@9Sa,  0r#{ tW0ҨU$P&3gZ @0)&:+M iTލ*i@I ]v 3-O BB[& 4*lᎪ$Sqy+s+uU]chH@3/@t\. 4R@( =4 'g Pb̭bJB @K yPR ԾWuİ L@3.8(\. 4R"\8AV"0M0_^sfYn!ClEV7o6m-Zԕ{[C2v@[@p `![*ɤ!^fm%/y_?ݮZseE#{znysMtS .b#U::\. 4R"@Ocj'> wG6>B RQuiaͥB#@.d.|!]zWwF:UH̙MhDOUL0\iXH"A29 ؃;0nر9W>kP^un$D@\9]@WKF @K`ҤIw{nLV,Iu@9Ӂt `nS* tW0R@n}v_@^?Kx}@9:;xcj6 ;>N ܄ ܝwQV{ڶm[*P^U c@QuyrҹjͥB#@.d.|'xM8}tR砪+˸ U :gT]70SƈV(Fm.U)r'svio|Ї>YfQ砪+IU :gT]W@ %T]@hE-ܹqrdV\N:$w#GF]tUWA$Dj߫:1,2T:gT]偉@L6 R//}k_sGuTlUIԾWuB9* +`pX/z>4aTH_>};묳ٳ]xOST]#k_D@9m@VKF \ 'GL`ݺu/v7p:u{{^׶=㫮n`3}Aյ} hOr%>k,7z CQ^ՕC9Z]y\. 4R"@O% pŋsMoz;G]Ӻ->3AUWD":Ҩ}!A39:3bj6 Гqrs=?뮻w^򒗸?ܽ5q|;蠃+^񊖍 G6o oiu%_ Yo巿nƍ,Yq9EQ/Xly޼y~V?Ƃ nϝ2e_-_nK.qsu#F9f[b})U]RT:gT]%!aPhjsH![sxs_7qf~ߺk׺!C~/~6l:tk{v}w7x`o͌ 0.nwv;:A5Pь?7m۲ÇcN@n˝@ d=m}y^Ios=[& 4*jF4@B9*t|]ve=+Ҷ{.{kOG@Hm.U)r'sd&`s0|ǝ|7[oq8{o~z~9{:= t?! P?:!dWH0eVKF \ 'CBr m?yHTOIYcͥB# @%6vg.m9I$TOJ2@ VKF @JG6|5`MtHP猪+(]P2T]@hEq2 !,+:bJWP=JuT]@hE̅!Pe!XhDnwQGaÆ:T]DH%UDP T]@hE̅!Pe!Xh sAՕ)CQu$Y‹b6 U4>N@!`%$~nRu%DP7l&Mf͚F]5QuΨn7:RuB JP?7JBdPH !U' PbT]@h @M Ԛ5k=m„ nԩnܸqnɒ%n-/^W͛fϞݓ?#5,XFnϝ2e_-_nK.qsu#F9f\b-:gT]+0SKF \* 'CBrP?7"Xf'N m˶Wb٪iܜ9sСC ɓk +WzsnLJ 1U UW5>}:\. 4R"@O(\ԹJc)gͯ%R[[5?~| @0`k*f.\na7sFյ0R_ P>T]@hE̅!Pe!Xh sAՕARndmUz5yvm tJէQu}J'a6 U4>N@!`%$~nRu%DбF"lf3%V猪(⋊\. 4R@ PI&UWIH mMw}N8? lر~+g3fL=v[ *hQu:(ͥB# @$~nRuTРh )ܣFrK.ON 钧swynӦM={ *b/U猪k⌈\. 4R"V\8`^IՕ)C _Goz=O3.( 1UKF \\8`^:T] 2{_z_\|uΨ$+,@Wm.U)r'sdByYV.ZB\Pu%D@&.]y=Fz:gT]p=PXT]@hEq2 !,+-!s+!R@ ǯ |5ǯ`/7t?n9}o[Rsns;찃O5~{l+VxQGUsg?~5_z\s5z!>|xG}Zs|ƍ^뮻駽_~5f|Sug?믑jc/zǯ^voZw'y$^˖-џr)w^^?cq[[mӟFa/j[muOjceן^?xO=?n:g~ 7=m۶z{]9:\. 4R@  $_;cH4h?n&0}vsz\Im?|wGկb}uZ@T U4>N@!`!H!F^گznƌu/Xn} 0LUcB#@.d.| B0/ E+BQB2 Z;Ûf߿#UW`JP(T]@hE̅!Pe!XhE0?*RHQێnG?Qq{/uS c 6 .>N@!`!H!F!%+TO L /(\. 4R@ @p}{P=kKBͥB# @ P=W\(\. 4R"V\8`^V"d%zUDP T]@hE̅!Pe!XhE0?*RHQN@!`!H!FG Hut0@Cm.U)r'sdByYV.Z̏at:T]GQp t@1RuB (\")$(Փ&bͥB# @ P=W\(\. 4R@ @2Փ:9pŅͥB# @ P=W\(\. 4R@ @2Փ:9pŅͥB# @ P=W\(\. 4R@ @2Փ:9pŅͥB# @ P=W\(\. 4R@ @2Փ:9pŅͥB# @ P=W\(\. 4R@ @2Փ:9pŅͥB# @ P=W\(\. 4R@ @2Փ:9pŅͥB# @ P=W\(\. 4R@ @2Փ:9pŅͥB# @ P=W\(\. 4R@ @2Փ:9pŅͥB# @ P=W\(\. 4R@ @2Փ:9pŅͥB# @ P=W\(\. 4R@ @2Փ:9pŅͥB# @ P=W\(\. 4R@ @2Փ:9pŅͥB# @ P=W\(\. 4R@ @2Փ:9pŅͥB# @ P=W\(\. 4R@ @2Փ:9pŅͥB# @ P=W\(\. 4R@ @2Փ:9pŅͥB# @ P=W\(\. 4R@ @2Փ:9pŅͥB# @ P=W\(\. 4R@ @2Փ:9pŅͥB# @ P=W\(\. 4R@ @2Փ:9pŅͥB# @ P=W\(\. 4R@ @2Փ:9pŅͥB# @ P=W\(\. 4R@ @2Փ:9pŅͥB# @ P=W\(\.ƣM IDAT 4R@ @2Փ:9pŅͥB# @ P=W\(\. 4R@ @2Փ:9pŅͥB# o]r_*8jivox>w'V{[Bu.(oWg~M'TO  t@'ͥB#3<ӭX͘1ýMoroFXt_ƌ㮹M#d~ tae~Ƕ]Wf~4qTO T]pP gƍnxsx;nA30?Z1K0?ZWGXr%G,f'Quդ>*VͥB#v}WȈFBCuΝ%9E~*#zG)^'Qu'Қ`8ͥB#N;,oW[V0?͡3?3 ̏X+STOO5#@pTKFZÆ sW3= mԨQG3$G{8w" #?uG~^keʟIT]fjsH+BިH! /lꛯB/o*g~j_rRh}jsH+BިH!1ЅQh.J}~~6BO+UWN Tm.UiE)$B2? EoR/ϦW}IYcͥB#z"@RHG!X(W 7 3?T]9)>k tST]@h!@oTB (k4J|b?^r+'g`6 "荊]H!`7_)_gS+TԾRu1LRuVQBb )$\+l{ʙWZ5:\. 4Ҋ7*RH t!d~5R|_>~M}cP9SJՕB@0UKFZFE .̏BFsQꛯ/o*g~j_rRh}jsH+Bzcʕn޼ynɒ%nȐ!*hױ׬Yܚ5k݂ ȑ#}g6lp&MFtnoQ\e~6/_ϟ  i,kuNH@+ ?n97vXn7Xng,cWJ2N灁\. 4Ҋhy;j>hi8q{_߲E#gq^'+U tՊa=4fxfF'O8FQ?޲ew#5j[t@+iQh!y@qNYu!uC[j_L1|RuV@0=m4׿͞=X_n=(N>| r3guU] d ܹs^{.\w2ȻҬZ3]Goh]Qv_+w%0o;3c&y @[m.UiE4owa /t=+^ jժ%hcbzޜjԩSk}6nWr~zu,^7n\lNt^6n:fGq֭+z9~-I^ OofH6zot~4hؓO>Bzg:'['L災̔'LlD{gv t6AIŢE|yhmL2rɿl{y_l9m޼mڴYٕIGi~lH~H*k:u̙ F{\Kҿm֯~v1gW cnGjsH+BYo$>0|pw7Ci8Xbk*{h$=fov6 nf&Ç{pcR>잭oڵ^Yk[WNˌjbjl|6fMή5kbb6[{͸շ"m\0O}S.r/}>1нn0m}ǽaq#FdNϚ@Kb߆F}ocN?' ky-!c/[VtGi~V|_6zr7mFIM~9}J~1tWfZgwsF}0v䈁6 "FC .p/}KJF!JС=+&76^uӫJ9ӱtz+!ItNw_݇%sf 6꫌5 r[ou'|@ۃnKte C=|3ϯ@ N/g龷ĘNf+c]z5d{ovw_{^_PH~t[z.7[Nl@zWU5gwWW.u* tyT]@h!Ь7:`|ЯV֒r%[ lѭg>,ɹf7;!:Rhfdқݢެ շ &Yz.mlG=3lNjg[G6銁N_qz~'OEg[3(73y]/V=h%>_FשۿB]S=G- j_N!Ƙ耪ͥB#f5a?'Rh!+![IN0Jnf+!.~M}cP9SJՕB@0UKFZFE .̏BFsQꛯ/o*g~j_rRh}jsH+BިH!1ЅQh.J}~~6BO+UWN Tm.UiE)$B2? EoR/ϦW}IYcͥB#z"@RHG!X(W 7 3?T]9)>k tST]@h!@oTB (k4J|b?^r+'g`6 "荊]H!`7_)_gS+TԾRu1LRuVaիݾ[1G7j(裏}WӘ0+0?bLR=+?֌Qm.UiEviOt{*2"o}WӘ0+0?bLR=+?֌Qm.UiE>~_UdD #!p衇$F7ne8J̏ c#ʔ?/Փi0RuVg6nn wkn-=#ua~e,Wb~RjzUWMJ@0SKFZ1!hŊnƌMozDv=w嗻1c`[XCG avȐ3?cۮ+3?E8'Qu}:RuVmdz.#{o7ζךz"X̏b}uGф~B@$PK' (B Fm%h+nd#( HE9$ ttT]@h(%B)Fm"hh”e#HE6@6 $p .4&(0/3GGP=e\PT]@h @d'Qur 1VKF @ @@&zU'P`T]@h(%l$&̏6&L) 0?JY6IT]dX:jsH!PJ̅RD&Є)%G)FґP瑪lxK^m.U)JIPʲt0?0$(eH:2KS4 @Փ0RuK#mvjtٲe5ۺx5&{Ĉ8Iѣ]bLc{WZ寑mwĉ@۽ɹvÇ{m@vVKӞ$ @IT]׀k2P t@'ͥBFZhK>5Vf8 }~b$_ve= zNΝ9s7򫮺ʇ43Nx3L]G4)FL@$.⡶55 tnT]@HF:1pz;tzuڐ}'[X m5<1Љ N 9s… 5-s5J 0?\]Ɩ#/A·s}:\. ti}YN vh}oK/7\?W9}-[}==i#5E>e4o([^A/H\e @@$.1Ő: jsХ6:=6a`Wv7gk3YhJ7tP1;/yX߷Bdg t)<4J @TO* +`pX/z۶m[3h¦"wt[ @&zUDP T]@h} ^N+G?Ѡ/.#貂3 ̏ \!PIT_ T]@h(oݽ-oq={l -#'@Q̏'xEHUKa`ͥB#@G yo}{nvqG-^̅`~D^ (GG"y*%00RuB:ID1lh9G"`~t?+B@$"XrPm..s3j]xm~'d~;Nw 7ᔇC@ g30:+GBZ) 4R%g0 ͊) :+M iԻ:01GJ`@-mL`~t$>S tW0JN9^TLs `~DW*!u"($e tVT]@h8fZ{U &\(0/5GGP瑪dXOPT]@h. z!rJ7o}[`9r$5@ic~B\iT4 t@IRuB zj߫L0:fߨQҥKǭ[ghѢ7Wli=pb~1*)tG@̥Go#@pSKF }0 FM@Y$zرnҤI-S=aӏ8 w;3̒huYInNpm7n֓_D[tpW \C2$:,jsH!=U]&A$\_d9dNL !!:H@GC*4:jsH!=U]&A$\Y}YhNw̙3ݎ;(ӈq~#@$y"V@@m.U)'~$آ w=X׿O}͘1C2̏R$#'~RumaPͥB#@ԾWu!@)'nܸqwvb@4$~Ru~:RuB zj߫L Д@@'btSl g.Uג*p t@RuB zjߛ tA'|rϝ|oa؟hB>14@#T]@h. r`. @N|*E5IlUW/:\. 4RDO@{UI9 0rRPV炪+@sFյ!R@Im.U)'~$xpN^ s;݀>M0M:Ս7-Y 8Нs9nѢEŋyٳ{x#8tAs#Gt[nN2ůR/_vm7w%s#F XfUkKM@}_PuAh!uΨVKaʧ6 P^E?`Zf'N m˶Wb٪iܜ9sСCm8餓m@O< N[r7v|Ȑ!][^~+?FP猪kMV :jsH!=U]&%@/X_{;fVǏ_@*vrF+^ɪtrbA_p!kWT]50 'U?j\PGT]@h.`hdmUz5\l6k[U'EP猪<0qhRuB zj߫L]Kn\!bnm @/9 t@'ͥB#@ԾWu@=v ';o嶗j7:yapk_۸;0?y͸?pUj??kqg5Ǐ |̙5?|sϭ9O~u>Og͚9>{l#H!PӧO9n^k۪MVs|ܹg]s|޼yYgUs.??폟y7SN9|~5?j_|Ўۃ :DjsH!=U]&A$\ +MQ26P瑪kSч@Hm.U)'~$ 9rz 0?*]^& :DjsH!=U]&A$՜9./k3kSч@Hm.U)'~$@"&~RuapͥB#@ԾWu!@@\.⡶55 tnT]@h. r`jN^ȉJKյ)`J6 P^E?`@N̅9./ku6} t@RuB zj߫LI Wepm"#Uצ(\. 4RDO@{UWԀ׬YO,XFYT+Xd[|?0`p&7oΚ5K;C*vGzfg%wEmOXV@P T: t@RuB zj߫ /:k(8#YY?~QV_f@'Uvi/b'&2;zfIާ]^hc[<^Z띎e˖eWߧcf{Xw[cxx_zs @T]xs t@RuB zj߫ /:lۜ W(jg>w'\oe:<1irl'ˮ|0IowNonn;ӲxF۱3ގngzW^!O?ܮ*o߇&3P瑪kMV :jsH!=U]n`>6 t1k=܃ T}. BmygT+`6 P^E?`o>`N;O|nƌf*-tP?sU :ͥB#@ԾWu!2'6ovuWsi@B ~RuEXkb6 P^E?`@@H ig.UP T]@hU s;պ; ߿{ꩧlOt?ꨣ]w%gm6YU%Vq@g3{`uV& 0?  =JvھW>:B+A@G9!:JjsH!=U]&A1Ѝn}`.TŒyڑsb`6 P^E?`@@7{ :pWŒU׎P%T]@h. RhU!@)Yn9:jsH!=U]&AP^nt޼yZf5{ʕ+|ɒ%nȐ!}a'򺹒d@m&6m8 t@iRuB zj߫L -Id3F;uT7|7`i:3ދ-,^ǀ[͛7M6d9Z &8V@?~|yT쒈:5J4! P瑪vPdT]@h. }BKF:}ײ{Ι3Ǵw;S-: oP3}W-Um3˗/[WZUsoYsGc\:S 2eJ6F|lOOC 1Çc-ӦMOV-[z!3ɹv^r2k3.5IEln3pU* @@S[* IDATKF }0 B 7a܎;N;~w.YA|g}{sOe׿uxr@>{Lc#LLgiBk+¶:B]J g۶m]J)|f4a,]Gu%g`sϹg}=3o{SO=̰דO>eۋkƍw=_M}k^~nw[lqvYNqg%9A͚jn=lNP'[m:1f&7)ɶd z=Cޒ䢌6nk׮ufCk>-m) %t abфvGו}~y~E{'?lݧlfﵕCN:zl߉9sfͶ+mioUmgճA@\7x@KF/e w%"릈M i`~t]p{Gq޹@]UV~GTTs@P?Ph :Orar:\%BASe5!'MN&"b~c~o/]k={=g9/{?}Z[՟/":ѫ\S5zolZ)FWWm=8ziӦQM6] 9v9z9߅j;I'Tˆb+\vL3(I@ը@m.TgM) O{T|L оGuАzu%ZMn'>!=W֭\{u:rtptY?W:zv 4UEm}M|5naT~ɐm.TgM) O{T|L оGuAH\p@$H\@jEG\y%84ІD BSJ@_0$\}CGA.ryGcǎ!pƂ$:P]rI7shOP!4$<Q]3A0gc9an-ZQUՑg$rc@Fm.TgM) O{T|L nիWO~5JIHJ!~Bu䒦@Fm.TgM) O{T|L l_˰a_޽{QJ$@$P 3+%40hs:ChJI xhߣ f$` U@nVO*W\qY'-Y_g.TWp h(ͅ )% }/ @ /~ u{$ v NGqh8ͅ )% }/ @ ݻeܹr7W_Ecq9 >2x{EꇘV:P]RNDh0ͅ )% }/ @ ӧ^СC?Y>я2*]os='>,YD7niG4n2@?s2@m.TgM) O{T|L eY ]m۶bŊ{Eڵkݕ_yy㎓ .@.Bׯ@R  J@?sJ盔@F m.TgM) O{T|L J5j7>|.S={DMoΝ}vٶmlٲE6o,6mo{_WiԨtIr)HϞ=N^z駟 4$@$@@?sp+nf4hs:ChJI xhߣ f$` P'?)?3h5C l}6iD5k͛7-ZH˖-UVҦMl׮o^:v(:uΝ;K׮]9j ZZPg̴@?sih=4rhs:ChJI xhߣ f$` P.mVO $+P"$PV|(+N,y2i 63'= `&H2>dW6O) p _@G|D𳙭yh BuД@оGuI@:jC$@$@U ~BuUH9!h Ä63'= `&H2ІJN:c„ >Vc,_\w3+S㖒_K$@&~Bu?x4ІA BSJ@_0$ ׫h2c wn}hl1B-[E ޮkO飵NCkPp5Htg.TWzF8 aBuД@оGuI@ :?.NJp.cg])ZO4Fo]g^ƍ8Eg>wkhCcWP 3CG.3JmP!4$<Q]3A0Hf2n,W׬Y#Æ +W?M21yY~[ӧ,X\:#"q|AkYfmg7m$cǎ3gL|t%T9s渗̛7΀k,;ߣ5ioȐ!NJ/jA[=31dRW?DL0yPrUR6`F BSJ@_0$R ={ܸܽqcCV={;1|ؙhYM4qϦMJfܳyҢE w>ur֭M6nsv}ҡCرtI=s1uEr@馛Lc>|-qsWhuEXW6\[5j5_3QӪ5[ρ(/ uI__C7$@%~BuxT4ІN@ BSJ@_0$R tx:tH<}DW=wUXo۶Mn*[lqߖw}י;έSMnޙm]yGt{VےU jFWssheڣ[uڛi5qk ߂G\rhn:Qm9+~7#$@!~BuVL袈!@ BSJ@_0$JhC ѭjP~#gu^pF\=묳;< {qǿ[mK.u:-;Z܉'US.S[dH񠥬@[ke\q;Q`I'~BuIQi $BuД@оGuI@ IڟO?_Y֕}spBwγ^ LVr)|]o+j߸,R?Z:u[uU+mաO8կ~%]t?ORwM:]9^EUx¬rK?VGG*Wã59ow[-+~kCK/{EC@G.%W%EhfP!4$<Q]3A0@J)*~nL-E_`AF}u%[+I 3 bu@#;\R. d@{,/z뭢:Gbɑ@'g) d e_zi 63'= `&HY4̟3ϸ[hA$@$Pg.TWÏBm#P!4$<Q]3A0ȲVLz/de@,,>k/3+W^I? aBuД@оGuI@ _}ރ@D &#TG6t\R. 3!QI\y裏J6m^ WT2C:P]ꁁ@ܷ f+vD{Tڙ+ #=+/[N:,ٽ{wh1@ p wôE}OAu*@ͅ )% }/ :7 }?a0  =eR# 4BP!4$<Q]3A0@B\z}=Ylt֭0  =e[:im.TgM) O{T|L оGu5n۶MƏ//<ҧO#-3f=ՅWam26pG BSJ@_0$Q!tեׯٳgˌ3k_jժU`dH\H04@Kr@m63'= `&Hh8p@K/"WGoȓO>)?d͚52rH5jݻ: 0Js&u (#t2C@m.TgM) O{T|L оϥS<}te?Y>яWzAYbϻs4i"eРAҟ Rp w)Z@)=d ;؄XfG憜4d~Ymjk.i۶36z 6[o%z *]a^vꫲqFwKs9G?|?~HH , y 06 ܐ`طo[q;ꌳU@:tHtuXW|s޽g{0ܹNJz[͛eӦMJNO|=SM7mT5k&͛7w-ZH˖-EZnzv9ܡCرt=vn5jI[kIBC: 4ΊXQ=G:{cΊq{|uXWCjpFj5$IK*AG9&4ІQC BSJ@_0$۷˴ijm(RtT$8J)!#T,%Am@63'= `&HhEnU eSJ &- F@R{1?hCw (Ώ 9 6(P#M7uHH ({ MlB,J3G#sC΂ 8? j,ի>\&L +)۸qdΜ92zhw[2$@$P | ehW6#!gI@>uotҜFQ6bYlYԀtԩ2qD|5 ;z B<ZCV^-YiYIIz$r@MhEip~dnY@R^G\5ЕB|QWb'M^BZ=D#_ tKe,X]Q,V$!.:gP s$Z@Uť6\R. } an<`(j>J dذarJj5kkFn5k>+xzэwرceȐ!.>LRGW2_4w=_e)kw4V4ڭǛ7o꿤(ZYu:#7x&X|n˼>$K__Bx≮\_jMSA!pW.{ "@:m.TgM) O{T|L оW>ٸqciԨ4iR+q7k=7o.-ZpO5lݺuSM}١CرtɭL_TojԬ[xQ@_3QM_sn;_VSطozF2>LLm;:ʛk>#e_ Ŀ~icwG],KkoU/tR/f TGoFTi.Y )% }/ tȡCre߾}`ٳ=w;wtO >m&[nuYjxֿ_tENp{G?K/@Uo*s訡Tc7?ڿnǻW5ሁrGse_hݦ5ѫl@GukV|ZI?t5b΀ۺqaQJ$@= 3؄XfG憜>?Ԁr뭷:Ӭۂz-Y~vZJ}97g>V#蕯93j8㌺T@;!+ыZAGz|zo/\b+/ m\U)pW7@=INm96#!gIWY>l3<#ڵ~[>Oze6mԝ7wq [lqWZmM_'1ƌd/\V\ 'Iժs:Yʻ7ԹV=#5r];_==Յ_qu26pF BSJ@_0$Q!tu\ :ک!r@+W^I? aBuД@оGuI@ WǑ#GPi/\yرc92p"`&%#T\͜m.TgM) O{T|L ha-~ۤErfpguYw9 %X4ІC BSJ@_0$h=y@R  RP])4ІD BSJ@_0$,_2l0ywj B̅J%M6&\R. d@?[oU~ӟW\a Fi p w; Օ#40hs:ChJI xhߣ f$` 5_BniӦu]rhQJ"|`@yJ(G6#\R. T@ܹS.\(_!H_}UYh̟?_9e ƣ+R?, yꪐr"B@ m.TgM) O{T|L m8O>]\^{MzaȨto!=<쳲diܸۦ^ Pz!;D̅ʔVCmBP!4$<Q]3A0(YEaݽ{&jժ{ʛo)jդ땴_yy㎓ .@.B߿?iR 3FIAm%P!4$<Q]3A0(@رí8G@r!9p{۷=L]De۶meټylܸQ}ywޑ&MI'$'|SN;4w%O?]=XJIHM̅ꪝh #63'= `&H.JMqZ hԨ[֧f͚gͥEҲeKiݺ{m=;t:uΝ;K׮][n A -ܵΘi#~Buizh BuД@оGuI@T]ln5x|@ "ɣC!#TJ]΃0hs:ChJI xhߣ f$` P>r䈋x0WhC@Y 𽢬8y@(ƣʦ6t\R. @!\P>$`&-fd| m>_f桁6B BSJ@_0$r訑> T U!D6 \R. T@R4 k֬c̙3UǍ=|ԫ'L B$:3 jGm 63'= `&Hi6ϗ#Fԣlٲf1g͘1]=5Æ +W _͛B]|48#*H3+/+64\R. @ݻ׭#jr~[ߒo+ߣ^|̝;ݧzҫW/Jf7~qtҺe9r>)W@+1 h8ͅ )% }/ @ ܩSBF9s8b~V_;q:[_,K,={[Սxjp.]D{o z;0ͣO>`:cqʔ)n˴>PB /f͚%6m*; _SsUn:qC+WMf@K1*Si4\hs:ChJI xhߣ f$` P޳g꽞7n\=YӇ7px׽{wS9f7׹իWh­қP5j*gَ:5'xB.2u5j9r5}k~qТI;!aB $~Bu DPi XBuД@оGuI@TfYoEoGڛh>6m͚5s͛K-S`VܳuҦMi۶{kN:t;vN:e#jXU]8p9W @ʱ<{5n1j`5nh;"|Æ G^G.d~_C t|e?jsGRж $ %Gҧ6D BSJ@_0$R tx>|X>9x`~ܷoj`sݲk.ܶm{nݺխvsƍ΀wM=X9 ' 'xŽtEW y|:jn-eʱ+NMa.5Z׺ur+ff;> xΑFpGͽ~7x 4ІII) d eT" 4C\R. T@R0KՀ{;o-oӵk׺U.H>l93ݹjκ|4E]:-$1z/ t"bz*o~q]@s y$p3#{#&!6!{ |Q!4$<$bPuwnj*y饗֕n]w~?oY18Ys,NUh=fh]*h=N4+VԻȚ==~ M{<0"anI!#T+'W BuД@оGuI@ ڗ*^*_^]mz/^7zH~K9i ]:th-jࣷʵ\]@GI?.G*sD4W~gpG1u_WU<Ӵ ?0@dWSGRTl%JIHI̅ʙ[Em=P!4$<Q]3A0֭~gR@>|X>9x{߿=랻w5z[)}걷l"7o7/-ZI'dzriI^Oc9@R  J@?sJ暤c@F m.TgM) O{T|L *auKJ qZmԨ{gӦMYfҼysg[j垺ݺm۶Ү];i߾tA:u$;w]Jncu?A&-ܕ&g eR# 4BP!4$<Q]3A0ӧ˝w.?G%pʦL F@t: BuД@оGuI@Z/~74І4H|rXT%Km@63'= `&H4>>tPMm@B) $-l( ՕQ:@mGP!4$<Q]3A0 ʗ%C եOC롁6C BSJ@_0$jhCZֈ/{ر2sLwEqɀdGeWBO0AWH \. *3 *\R. @ϟ?_FQƲeˊBMo5c iٲvR5Æ +W<֧Ž=o޼&8~c-QAP]xY; aBuД@оGuI@ Zo+\5ַo/x˫Bz2w\پ}L6m*͚5s͛K-!g֭Sݶm[i׮{vA:v(:urWs;~5ѕV2_7hРZWuֿtMV}^QqF;nq56l8j:Zk!?׭澡:5йVڣ|ah[JIN̅l@Pͅ )% }/ @% \~UY}ʵ3z׮]ۚ\m۶֭[e˖-ߗ}ɱVhO89Gӧ[@=Fq\گ꫿t2jX |[nu8Stϋ^xQH#[^|<hä2@̅2 *m.TgM) O{T|L i iwyG򗿸ZoN?ȪUg!gus9n[㣏>Lx>s"b~]ٍ&[DEWw~yVGW4@G-Bf?M[I! %~BuDwOx$W$tP@}Ć@ t+__|Q[z-wK.D^z%93]K[s?o{ָѕeG|*njk]ljbŊzYԸǷbA_ӿыρ=zx$+տy*Q.zL]s ~(4@ $:PAH hs:ChJI xhߣ f$` f`P#O?^կ"/3kt >(W1%-;f3 fBm63'= `&HY7 / z< ]v5P,._+  @?sUFm63'= `&H4anꪫw54+^f$#TW\tlhhͅ )% }/ @M](/ryꩧВWdhYjU,ф0`hs:ChJI xhߣ f$` \L{F޴i$Y!-YiYIdI:6 aBuД@оGuI@hX7tiFnIJIHPg.TM0hs:ChJI xhߣ f$` @]=#<,[LZnm I) J̅иi@Fm.TgM) O{T|L h?{-"o?N;@,,6k3TI;. aBuД@оGuI@ zڵ2{l~ z9jܸMf;v̜9Sze{qv]&LPtOVS䓲xbyeȑrKϞ=%|r߿QI͛7Oޠdz2bĈz8p;wܠ^@0ƋjEG?$@mP!4$<Q]3A0(V<}t;K= W~Yb轝ywnsVK/AɕW^7h54 ҥKeƌҲeh!W222I̅2 1G4ІN@ BSJ@_0$rqnԨڵ]zժU7۷o 69juk*[n>[99~BZMuFWr'Nǭm k>suf[խC ѣG8SL6 D~ʜ9s/,Y~ &+W͛ݶwƮ" D@?sD]$i BuД@оGuI@TgϞgo}BСCrAJsO=>Հsǎy۶m tIw.'x3맜rzB`{!BZs3fL<]tqÿ򕯸jyzןˈ\h5jzs߯_?v\Q_r*whBѺ@|ɮ}7N - H \.DS #\R. j/"pZM>>z.}6mڴټysg--z )}}۶mݳ}ұcGTìfk׮ҭ[7J<SϛVS]oŎM63΁Ua5 t9V3szSju˻Mr3xLnqTSP]T4hsz IDAT:ChJI xhߣ f$` PiӦg&MD suUXWSuIx;:joa\:9Х\1~"Q@a" 9NG.z 4\R. j9mٲ(#]s 嚤 ߶[t~V+epWnW$:P1 #]D@  H $.A3U(J\ikV-bZ[_gQgVSle:z~-^D̟Kk\۰@Vp5ݟKρoˤIU| @?s:R6\Μ_@@\*S#3rh^GnGs&ϝ{ofծb_z4Gկ~ݒ 1{LG=!WκNb/3g ՅV_nyP!4$<Q]3A06@) @P]- hs:ChJI xhߣ f$` @mEi?/~񋦺xn.I '3# @:m.TgM) O{T|L h (Mg}V.wq5]wT+ L@AoEilci'PNvV/][ƹSNX}ե !@ kx&z% a|ng_(RŐ@ 9JH%U/6 '\R. @`Q*6mo]&L qLf1@?sKIJ4hs:ChJI xhߣ f$` @mEi .sY0 !TG6t\R. @`UIyf>|[ׯ_2L.#e =^"@mÍ )% }/ V4U APtΠL@ y \R. @`5Pf;v 2DF-KVdܸq2gwy湕Sĉ?|w3gJ^d޽#GtzІH2B̅2h4EC63'= `&H2Q#h"5j!+Jsؼy >\&L + ޽{ݭ̙#G3fH˖-K:&_L$@(3C]GmaP!4$<Q]3A06RT O?]Eeҥ9mĈlٲi"N*'NtWS@Dk(ģ5duf$~Bu5IǦ6\R. $@/_\U#]-gu%֟ڶm[[h}!~)n&Y`ի`bՊA" C'#Tzʏ@m.TgM) O{T|L `v@FYWWr7l Æ +W8PPwY֬Y#>\s5rwˬY_Ǜ6mZ=ϗcʐ!C\|}L2)Gsej5hz<R hh~[7o<IQ&u~G1x`={_UӧO3GW -_%#H@yC4ІN@ BSJ@_0$$h5jfΜYpeUܹs̱Ҟ={:oگ`sGY;zE6m$'O3jUҿU+ɹV9tq@jNZ/ NJ^k׭[j&rO>mׇ_ckKO<ՙK CkWL-Cg e]Ri 63'= `&HhG>➍5ƍ=6m*ټysO5lժnZڴi#}]vҾ}{С{vɭرÙ_TojԬ[xQ@_3QM_sn;_VSطozF2>LLm;:ʛk>#5@ :&:{}⼴VB,i)A) @P]RNDh0ͅ )% }/ @ȑ#GEСCrAeR }2\knW5ሁrGse_hݦ5ѫl@GukV|ZI?t5b΀ۺqaQJ$ h 63'= `&H0Іԛ3DFW_@Qp:C եP 6C BSJ@_0$$hoWnS宻G}g=^SN9] Lb?#uG继7wqO_stv4BW^򽢢xy@e@E\R. $@)o+HHC̅ꪓuQh c63'= `&HY6ЊI/ Qeg"~Bu+ǡ6 \R. d@Wzj>H! 5$P:PyH hs:ChJI xhߣ f$` @8r* VwW_i&X8^X0@K.fNm63'= `&Hhߣ:C ֭:KvD>L"|1 ).! 3\R. } ~ߐ;wއ  @SP]u? aBuД@оGuI@{Tg]s}'dٲeҭ[HH +Tn꤁.F(wP!4$<Q]3A0@BLm6?~KK>}j 'p'o̘qxT^Ɉm.TgM) O{T|L оGuUPf̘!_DPV&@BG٧:P]hEP!4$<Q]͛e2aׯ_f'5 + .뮻.8po<䓲xbYv9RF%{.W& IF5̒jCG6U0&hs:ChJI xhߣ 8A\};SG5+b yw67iD>OˠADoW?AR$!R{0?hCw (Ώ 5kdر2d=z 8PϟŎ7N̙ϛ7ϭHH"А*3hø (Ώ aÆ9۲ pty̘12ydҥQ[ /dGQ nΜ;w\Sxd+η~{qH C8pTqgTO5۷ow-[M1&tAN>jfٴiSuYfҼyslѢOݭкukOiо}{g;vS]vuҿA$-ܵi!`yGg (#]1guUzʕvmʍEClg5ź? nUQFuOsБB%ΙPg^$tj !h(ͅ )% }/ 3Vs]D+UоtHyHWbt/~DV$@ 4佇<.ΨN&44s8?*7 th:e].6`[qS3߿vm} poLK:vӦMsFZZ/"Vy$hnn7Jy!_Lw?؄0* 3Hr@k4oU# ,pyYuߍ?]L*~n]q,Ћ}=r 7i>HHHrm 6#PxbXI&䐊~cXhQK$@${>Y ][&8p@u &  $gJ撦c@FMhEi4t~x#}A26.[T3=, NJ#@ƗMhEi:?xNtZ&s& 8?29,yʜ^bGm:P!4$<~ɽ@?LTBI 8?+WWnצ%оGuUȌHE`wmoUeǎG]@WоGuɒG%ppj8cL#ޘ0@?sL4hs!;wʢEdԨQ (%p }٣p+ef$P }n IDATȣG:ǕUU:P]u7 al*S<}t{mxC@1?­@ syDGc '#T~ɐm\q )% 2?®ّ@epje qd%fOmڐ&YWuřDhHTLHHHD*3X4&ԋWiСCo抳5#`GI^̘HHHD*3X4&kg~jgu>ğ'O}J:w,?x~8sM6G+Th -jJ[T:8?A:wg3[hqVՃYmKij p #8?$J'#TWzF8 a@s+6 ΙT"HHLp @P;, a*tnmNi p ^⇐TGЉ'!d(Ż~)@M@SJ$@$@$@$@$ . @MFzѢE2j(C @q.ţeGAmk6$ "܂6 8?$ Jw ]hW6$ _H ,a$ ՕQ:@mGP!4$H 6&]%U0$acҁ@ Cm@63I[T9lLJ8?aI#Ƥ#zTXy5Kڀm.TgM) PO)@m.TgM) PO)@m.TgM) $%rؘtp~T 4$G"IF$.j =\RH$΅DΏ*fDH1V^ҡ6G BSJ$acU"Q% H6&tʫY:4hs:ChJI /ƤDJ&8?9lL:0'AuWth BuД L$r! aBuД L$r! aBuД@" :T.\ܙ4 TG I&c@= ZAmP!4$H 6&]%U0$acҁ@ Cm@63I+6&]%U0$acҁ@= Cm@63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 63HHHHH`'Aup i 634~_C=$>lܸ1]'?I5j|3Iw50s|+}tΏJ=ԓ: BuД7(˖-oY.r9RVayw婧ӧK??_t* \Ώʱ֑9?EqPOHhs:s|A*臟۷ˣ>zXȿ˿Hi e!8?7 cʑ8?BtzTNJm`634%tݿ˪URRB+TL Ϛm.TgMiJ7R24HΏ` ҆J9P2C %B60E BS썔 $ tE"X9(Ƿ jo#оBuɤPi LBuД{#%I]`-m(ȯ4~%3?P]2)?khSP!4)!H@@Wd 9?*5r|K +_>B+TL Ϛm.TgMiJ7R24HΏ` ҆J9P2C %B60E BSY˗ԩSeҹsFP &Ț5kdر2sLիVRx2|p_~Cfi|M`@q\1bQYD ={\=O?tO>`F(KS|+Vh xcW̩=j_򯏮EWE;{VnӋǍ\@;~zR9hРz[}^[ OGMIW\zܹҷo_iݺݻwo!Cy5~, j횈|y+ś9s渼PqFYK9o@47^К5;wʎ;DsLr~6ujͯV7qFWq?A;y/WsͿE-֯յ_{|E}Ps5r6PF BSzhpB⋝1-_Pc~ПP᷁s4ŋ+_znvrM7m5x֭sߢ6mT\éz}QFZh}?:җVob| 2ρVƣP+ߔqgo6w#߇~X/.Z4~{ayڧ={3~Nߊ@+}u:wԬ?ys~6ujͯ t{27UBZ_߿Cw{)֯յ_{|E}Ps5r6PF BSz#!YK4itIn%Z`EҥQ,dt@F?nthb:7Ji9/r ׿ug,)6HY3/K+BBz:ߗ"^\7wq|߬;]Q5$/oѾןhọyGsӕКuMV߀x/s~6kͯ9о J=IݏU}b+Q.( Ji#SWz|SP]h*hyP!4)!P7s}Е5A.u1B~Gn._گ+ DZ t|._jįߢ^ og uJ@.[@wz2~{;: tԤ#:z|Eǿ̊V@M tt^5@W~ߗb+hO WV8#5uj=`F Ue_hx IV.`P˕T@52E .,j3yi MeάEC+BLSP s{:Kwy>rާоBu!Ƙ4ІQA BSz#i²7~[ߊfYlN3СIK l!@[լcZą[-+j0t|.Վ7'mܰ2*]Z`Y.w tJvڍmٵěfJhd>I8?j:W@5B/Kttrt+~W@B+TM Ϛm.TgMiN7r24 HΏ`چjG(}IY@ͅ ) FN!ќ[P_mb?e3?P]6)?khSP!49!@@7d 9?5r|k _Gs|cl&gMm`634'9H $GCFsRomCA~ho#оBu٤Pi LBuД{#'IݐhhNm(ȯ6~}W.5 )\Ҝ`od i2 I9 /9P6C eB60E BS썜 $ tC!X9)Ƿ ~47f~h_lR4hs:ChJsBcuX'/ʰa_&* p~T .q~>H3 LB= >T@m634'>G>sRN~&{/TIJp8AagudIP]ԧhGP!49!K__>' O3ΐo~>#Q,Q(q~03p~:2 $.DS #\ ;v9إ|򓟔>}wbCu)8?7 c˙8?b|zTOJh BuД挀 Zz\uUDgp|x@ϟ/#Fyr~fN8c۬3s~44㠞Ցa4ІN@ BSCO{/)J+wIs۶?֜g3r~46Gc6&{'Au$KmP9@#cM%T 10%t(lAR\6@G BSJ$acM"$ I6&tkY:4hs:ChJI ˬY2;&Fh4a?8?|x3=q6^v;Zq㜁kz|uA6i˝+ЙiO&J$@$@$@!zTWp 6t\:3Ҵk5p7i8KZf8M[ǹޯ/\kW_ s<\)_x f:yx54Хۓ[23uh p~:CfGfFL$.R 7\:343])xL C[CCn[=4z] ڛ`ogϞ--\B},y&em 't:2=L hs:CH &kr{-,V /ж5;+շ~\wu4z 4W[>E Y!b ꌙ71(, Ώ:K p~($PO0hC'ͅ )%xN:5\#W]ud9Z:l 9Ώ鵔GK3xNKe@ͅ )%P}gݻgϞrAHs.t$@$@$@$@Gx7g%lB,JsEYݻ7RQg1$@$@$@Y&@Ҙѣ6pe`Q+kӶns~jYLpj 3Df p~dvxDެ1Am&44Wps~jYLs 0 DG#!aB$#TA Iڀm.TgM) @Fյ`&@ &`<} p~dz|$y")i@m.TgM) DO{T}LXf̝;W/_.OU6cƍeԩpB2dnj2C#30( TI}υL#w@m.TgM) DO{T}L0Zj^G6lXyܷoL6M,YҮѣG5 t=Q+FIQG$@#Bu#T]E4nhs:ChJI zhߣ fQ@VoG)Ǐ[Mi:/,X@w^< x{.TG @:m.TgM) DO{T}L0jiZM̙3]~eNriz۶mTϘ1C Wt M<W2|3㏻-ޚ>4>K.u۲eۆ=vXCsi걻v풝;wp=]N7n[m|W^VԃrE[s5,E\EeD0$hs:ChJI zhߣ fQHАꊯ>ֿ5̛6mj3jٞ8q3Օ 7ryT2jj@N{=k۪9Z@ݻkH!Agr"׊\ 'it]XhÐͅ )% }/ FM iTn^޺u̞=[-Z$Zf5~E:J@/[L&L osyT2k׮mw3[<"C@G )g" aBuД@оGu&Pi nE­ ͪnfY;z _!]wu7@mJOu>9n&@s&4ІaB BSJ@E_0@7Kh-os4]\h^|뭷u VWD_ܨh i:0D,Vgr$@$P a4ІN@ BSJ@E_0@@5qպ5VNyw;_8@ 0i$;E W\!zMr3 wᶭ t&;!eA- Bu-(!ʐ4ІaA BSJ@E_0$ >55I& ZHGD0hs:ChJI zhߣ f$P#BwesƁrM7W_-;vi8?)$HERVӠ6 \R. H[Tk3AGnݺɵ^+W]ud9?21L2r{.TyMKڀm.TgM) DO{T}LHH"'xBF-۷o^zXt $BuD} BuД@оGuIH* HWF ԅ %0hs:ChJI zh߫  ٳٳ爂;w,_|\_' Fތs c*hv43'=`&H5\ dSN|dY#Πߨ|i dBuД@оGuIF 5 \T 0L@3 )g" aBuД@оGuIFpyx&9UBmCP!4$=Q]3+ .tWiSscƌI5кQjzW4E@Q8AU@9j(g6#\R.`a 2к*nݺv\t6 ta[TrO3.iAP*C BSJ@E_0,,RjpMĐ-z 4W f*}]@ubI tΠ:>L hs:ChJI zhߣ f%f@+MFn6rH[jh0yĈm?'k1]ؖ}=0H tΠ:0le4І!F BSJ@E_0,,40w6lX]' ݹu.eΝG܅+ЅmB.Bc$P:gPa&@mP!4$=ݮ]{/< TK_̚5y ޴mrСBH9oVOm)P!4$=8ϟ?_n5Av[u3A   x4 VcƕMhEi2?BO|]/wp Y0 @-EŚI%h ؄X@5g]ugµM B?TA$@ pnUfT@MhEiX,IM>/2ꪫ\a!);t.b}$@ C]GmaP!4$=UOZq9sWCCPIW aBuД@оGuIF 5&eqM"#TפCm"P!4$=Q]3AG5 5)@m.TgM) DO{T}LHHH"&Buh BuД@оGuIHHH b{.TqMMڀm.TgM) DO{T}Lj$-5&eqM"BuMJ;04І!B BSJ@E_0$ p.G5:P]Ҏ> aBuД@оGuIF 5&eqM"#TפCm"P!4$=Q]3AG5 5)@m.TgM) DO{T}LHHH"&Buh BuД@оGuIHHH b{.TqMMڀm.TgM) DO{T}Lj$-5&eqM"BuMJ;04І!B BSJ@E_0$ p.G5:P]Ҏ> aBuД@оGuIF 5&eqM"#TפCm"P!4$=Q] ޸qL:U.\(C iT |rYj,X@wIΝ3fh[T[a3A#$#'Bu۴h BuД@оGuo>6m9RƏvШmٲ.e6o,z|I.h3gl;װadŊzP_%KRcե$=b-z @# P]#sҹi 63'=`@'W:K(]֕;vȔ)SdդT1i&s͚5^?$ MW'a4(xhu$@$@Y#BuYQ@Ȣͅ )% })1 ֭[eĈm&OܶX͝lڴv`5ƍu9ɜ9s+pV {nꩧv޽{7[zu6SW}^hRr[ Vs{-ڶf'.]wv@W<HHP{.Tͻ0hs:ChJI zhߣj @' e<1cܵΟܟR_U@'Uco]Mdƴ|$'p]KlYV5r;wv7aK@'c&Dwr w wy T"Bu4ІF BSJ@USp5:\qm{tܹ]QnAկ]'2Mfh\-zsw6g$n.un=.nR۱xcjiϽ[ouאw:s[g]Kkɫ?1ܢj%F}o IDATp~iYkP]yi #63'= !׾&_kwl]Z\/6Ώb?td@m.TgM) DO{T}%L~Slu@7fD{8 Ud#s@ `_@yj(g6#\R. _c|2ܢ"8?$P;==|0hs:ChJI zhߣ f$bt"0i$  F@sFs@F m.TgM) DO{T}LR UhuUEHHHY\Yy0Bhs:ChJI zh%p#¬yꚑsb@F m.TgM) DO{T}LR tkѾGuOy'f} #T׌0Jhs:ChJI zhߣ f$bK݅{TG$wf} f䜅4ІQB BSJ@E_0$@F> T"JwhHͅ )% }/ R#m۶eƌ2|piӦɒ%Kdɲ`޽{M$@$@_SP7:hͅ )% }/ ,RW5˗/UVEۄ d5SsQ=`ܹ2sLSDk(ǣrpeYg# )f4ІB BSJ@E_0$Q!If1b&W>teܣaԕYfC{Vw[PR9CetWʊ+*~wXb Y`ItJwhHͅ )% }/ #G&ïnٲEƍ'֭s=z߿lܸQԧ>%7t,Z^oy3a~sL:UƎcΜ9Lqrfj50w=_eN~(;W|˖-s\iš|ΪK/ŋ;U0ְaL97S uH (EQTI@m.TgM) DO{T}L оGuаTM ]YUt6stZ+j'mdo6Q֭[emf[͠j\75ju%9m8׿xȐ!+XIk@V}!@9Xk=vӦM.o}M >7x&Xr)n˼>$K!N}G-}~`]hwUJ]A8\VfUMʕ+oߞ4i3oРA[Csi5g}v;#4SJ@i!*z2v\?H~~hc9t#nv~P9;g7M3L JI@sС&d4Іqd`QZ8rl P76o6wTPO4^{2}t&1*wkh~VuzhrûlH3n=o.eC\# uqaQJ$BBM'@m 6#Q!g5=\s54^6o,gqz/,G>묳 m|"+e~mԈ.u-w5+MVQܮ^v[ÇPv-6~``hJ,b*vhȱ (-Ώ 9 6H _e=3=yᇥw?Qzg꣎::px;1{u㦭N+⴯*gur߭ؖdPΓjP tk[g{S?ksƴ3iH) :P]( hs:ChJI zhߣ f$` =36KӾ:Zn.Ht{󫯾ꮯ^~ۚ OFcL2mɾ۾YJ [@y•oMZV=fݎ+P{Fj8Uy;=Mܒ㑼;wDr;̫]ûA0TOKM##T״#Dm P!4$=Q]3A0@B7USͣRz@塦 .hkw-!-+f/5[is36F BSJ@E_0$Q!tˤ9k, Wc­SO$@E&" k6t\R. } [.?ﮕ~Z   "@_SP]ؕ hs:ChJI zhߣ f$` =3B|F7(aLjO}MAuWܜ i BuД@оGuI@{TgtӦMrXy HԐ@+0hs:ChJI zhߣ f$` ;q!Tu]ҷohsdbkEoذAQJ$@$P =%<KmMP!4$=Q]3A0(~&ƍ'|RjF) @-\\t, a4BuД@оGuI@[\s5P."1JN[\94ІQD BSJ@E_0$rM7QG%7xuYZ_+$P;t3h 63'=`&H2лv풻[&MdȦ1wr=c/| 2~YsOb򗿔zH:vi#Gg(4n.:@s:@m.TgM) DO{T}L eqmjXI_!z߾}sωe5z'F?x9s1۴ @) 4 5#,Ġ6\R. jwVCç7|S<(p޽{޽{߱cl߾]^}Uٶm+/K/$/tIN:$9Sdri;i];@R  f@sfk<hȠͅ )% }/ @s_8PXctLSo.]ܳk׮ҭ[7޽={G}{O/s 8d>H3o\.o|@m.TgM) DO{T}L j5ЕV_-j ,kEGBG.Z aBuД@оGuI@V}!-y07hC@] 𵢮8y@+(#ʦ6t\R. @1܅P>$`&-fd<4zo{`{3[@xͅ )% }/ @ thchJIH@}υꚐr&B@ m.TgM) DO{T}L e )P7ԩSe….ӦMsߝ=~#Իg̘!Ç B$;=fGm 63'=`&Hy6˗/ &zf1ӯZ`{x3jpǍ'֭K m޼-[j'<]$P UW@Fm.TgM) DO{T}L hVN\5_w_UQ@YF.]꾧z2dJCZRJx\nO:'y*G,0hs:ChJI zhߣ f$` G&wܹFQqɒ%_cgΜF1\տ]pCۭ&Wu5xm[ [x~1l0YbE1O8geZN~ fÀE֭[nN[xj-]7rӤ|hj1t2Fm63'=`&Hy4jfo tj2LV]`oذDn5ބiןUs%8vrUWv}j޺sԟ~5j:dnho'NnkS?8Hihݐ0 @s "hH4hs:ChJI zhߣ f$` PPz}vСٱcGΝ;K.]ܳk׮ҭ[7T#أGٳuQٻwoӧ}ҷo_ׯ[Qߕ{UuѣJ_Ǎ3&@ʱ<{lەW^nX[՘oٲr:y[Uk+N[iPж d eGҧ6D BSJ@E_0$Z tx<(oo!h{߿_s޽={ݻS3S3~W_uWj=X9SWhO89Eou:Mr:4zq4Wuq:i ӌXצMrdCVtோ^rH#[Cs|$ t)A aRRJ Bu@H a:,B BSJ@E_0$FhCj_|E,/}Z3*5j_E>U:w!W1%-;f=fBm63'=`&HE6!&5cǎ3Ĥ;cGQE$@$Bud m.TgM) DO{T}L hzE/֭| 4 5&읕0fhs:ChJI zhߣ f$` @}$,]~{+_W $)- n.HF@sF暥s@F m.TgM) DO{T}L h_Z.X|@_+$P;t3h 63'=`&HV÷P;%[FPm|18QU볠6\R. X 4b0{ӟg=A@_+P] 4ІqD BSJ@E_0$#a;wtߋ @ P]3i 63'=`&H4as=SO '` I) J}υиy@Fm.TgM) DO{T}L h7M7o? .@""6km=kTY;/ aBuД@оGuI@Z{oQM7$|; )-VmYo#5",0jhs:ChJI zhߣ f$` Lk.eҤI #o~#]{r)???YsEN"+'|!ڥ<<_R~_HϞ=墋.~ryg( n.P@sS@ m.TgM) DO{T}L iq;v={QG%ׯo޻w aBuД@оGuI@ZJWCSJ3o{%{>}G-1~M[M/=+3Fh_5hs:ChJI zhߣ f$` ]iW­Z$|H1Ϙ \k3s6F BSJ@E_0$FC ›uԩ@ʦ&׊@h##TG @:m.TgM) DO{T}L i}1܅ۀR(K[ $P;==|0hs:ChJI zhߣ f$` XڀR  :@s:@m.TgM) DO{T}L i iQ"7nS… ͧM&#G ]?c >|x2fX ,@s,2hD4hs:ChJI zhߣ f$` g|r0aB;WhC7 ;7wܸqnݺ԰Z͛{ٲe&8yʣ-ܕQAP]xE; aBuД@оGuI@ z߾}nTU}Mz߿IJ 5kdҥc={V=BZRJy{\nO:'y*G,0hs:ChJI zhߣ f$` G&wܹFQqɒ%_cgΜF1\տ]pCۭ&Wu5Xo&7on_ǰadŊm<9sܖi}:@-Z$[n-;mܯ⩹*NtEMi(yrT \R. 4@ݻ}>w=wѐUmR5kF3l 4dN2ŭ*M7\ްa[+j, UӮ?K.qћ䪮k3͡ռu%?2j(u5ܪ5ވO8 g.א~pnZ{.T*WAm`63'=`&HV? IDAT0jzvZ Z;w.]g׮][ngϞyQGI^wҧO۷\}{GhXoѣJ_Ǎ3&@ʱ<{lەW^nX[՘oٲr:y[}:贕p5 mK) @ P]q-}hJP!4$=Q]3A0hV8xyySWe+{ݻwnkko._qVhO89OK@=G͸tkq+Ǻ84iF] kxkӦMm thLh!.zʕG\#lͽ~ؑ4Хx 4ІII)  T" 4m.TgM) DO{T}L i i^xA?ZoNz)Y~[>~=q+)wu3iMJ:\ N3z>+Uon^&bzp?y:yv_\]@ۤ|A#z5|;ݿ~a.!=~p w3O+|0C) #TGЇ @:m.TgM) DO{T}L l j@L>] 0FPq]ݱc@sx*km&4hs:ChJI zhߣ f$` PtQ=r5׸;vmr1(V& ^*HH \.l@xͅ )% }/ t{X_WGGy$+ h)% (A}υ0hC'ͅ )% }/ }-n׀ 2Kl8=kx @m(P!4$=Q]3A0>nK_4(ZQf$#T\tnhhͅ )% }/ @÷P~x-kE6:P]؉i 63'=`&HN;e^̓O>)jnj IiQp wQFu6kMm-P!4$=Q]3A0>֕W^)GutM \w aBuД@оGuI@=oY.Yz@R   աq󮣁60\R. @K/W_-=vipiYkP]yi #63'=`&HE7<,^Xo5\#j:vh hnܸQN* .!Cn]׌3!_kEƓմ:P]k/* aLBuД@оGuI@Qz߾}b g?kȦ9R5?Odʕ?Q&N(&MK`͚52bĈ#Zl?dz2a„v=z_UrxhfVxQMiyH0hC'ͅ )% }/ @  7 r'2_k׊~c=mѣ|C1c_\2h54izժU`޽{}O9[+ /@yB@sBBL) hs:ChJI zhߣ f$` P/:ݻݝׯ_pcٲel޼]ì]fw^{MՀsΝy //O $'x3x;SOu7:th<haʔ)2{lgß ඇssa 팯:͈\+h5jzs?|pBr*w0Nh]jO9W>M&#GzK{5cHO}υO>@8ͅ )% }/ @ΓzʙC b}[7gΝ۞]v}vL hs:ChJI zhߣ f$` @m$md>IQ&HHFmo  4?ܨR. @`5IJ$@u!)!B@ +4Hhͅ )% }/ Vҍ7ԩSeر2yd=z,_\z!ӦM%K3/[̭<ϝ;WfΜM9s,\!z߾}؉'Uj=ߪUwr7˜9sd~'\z5W ㈾.:ChJI 9r P AhQZ4?hXo @7~|@7hݖo ~SLٳgˀMx9=a„vYMu5k8s߿ Au K @ KR98 aBuД@оGuI@Jii~VWnjS H]~UNcA_h 48RF'T{``4 (ͅ )% }/ VRZW׭[]J 8 }]@u H$L@ $$Mm63'=`&H4XUJKRi7Cps*s!H$TM Ϛm.TgM) DO{T}L h 5zjmذAFn6rH[IS31vm=[0u՞@ T*WAm`63'=`&H4XUJ ʛhaÆɊ+]AV;wӧΝ; 7rJ.fdz@v seD}36D BSJ@E_0$F]v=#_~!+JI *fA'TȀ0hs:ChJI zhߣ f$` (yr-p YQJq@_P]U1 h=tΠWG4Іq@ BSJ@E_0$z8p4dD) C}]@uTLH9Z[Mh xT[CQ4l$=kdY:7 aBuД@оGuI@ +z͚52bĈ#LA}lG)è+z^zV=DTi:P@]y啲b 2dH2*j,kEF9NG.z 4\R. d@#G&ïnٲEƍ'֭s=z߿lܸQԧ>%7t,Z^oy3a~sL:UƎcΜ9Lqrfj50w=_eN~(;W|˖-s\iš|ΪK/ŋ;U0ְaL9nh|!O@#TG @:m.TgM) DO{T}L j5{uo١Cر!R5j.\XveUҥḴ;Wjگ`k'Nض;<^Du[nٳgm5s֕U0_c]1Nh5 +>di&W7j<oO9e^'x3Cxp71# V! 4 o{,w3'=`&Hh5[o"Y:urΝ;K.]ܳk׮ҭ[7g٣G9ꨣڞ{>}G-}~;v8z뭷 pJFMͪ+Wq ߾=i$g`CMߠART:j >vF29Li64ĕWyVCUd0 tL:zΒVri)A) @P]RDh0ͅ )% }/ @ԇ7x=8 {ҧ\sݢsNgk9W^yE^z%;ON8Vo .mҗ*>L3СTC4iF_k폽kenUM8bU04?ʭ@6wNfmzߪ]@5ɇnF n6nH a4ІN@ BSJ@E_0$FhC  qO,n޼Yyydg}ʨQjx#m wx0 MpRxr駷"Ել@7K[AGzrzoB}ڵ tAh[[asE}υrbh BuД@оGuI@ ]mʟ'?^[[W:aj>w*{cx 7ȽM[O_sm;̫]ûںRV4/O^k=W^Y? aBuД@оGuI@+j>H! 5$P:Py&@mP!4$=Q]3A0(eS:tF?i>HVT"Ŀ@eso[,X _EP=f@BG:P]ԣhEP!4$=Q]3A0@n߾}b g?kO~"+WgyF&N(_~ :9 0Js&w #t:S@m.TgM) DO{T}L оOөq?p rT> +}7dڵOc=mԩ|1cƈ~] B[kcI0Z^{Ȱ4hCw (-Ώ 9 6f~ƹC{nׯo޹slٲEyѯRӮ+6lW^y}%Yg%}{}{  TWqfCm6#Q!gw޶go}rúJSϧO5Tsc|Ws֭/^zI>h4hxάSO=UN;42dtP=$@$@ `y9tP+RdLhð (-Ώ 9 6̏;Oz)g5j[oY}vmҥt=u&ݻww7ٳ[g޽O>(Ws);$JJh|iqV?sV̏m۶ɼyS n5O<[i5XP F5̒ZCG5U0&hs:ChJI zhߣ f$` }ӭI#ݬk QJ !ΙII 'yr2h BuД@оGuI@4]h5>JB['-Z^{ T. (ܐ`z̏^{M.?wHHk IlB,J GpC΂ 8?Ú;w̜9SF-˗/w74+Cy?~̘1C^s7nS… [kM&#GtuA$<|i khW6#Q!gY=m 6LVX03fQ5͛k=i>P[h :g0qĒZ-PG d'kcHm16#Q!gYijpG!W iUVɂ Wne塦RsӞ2eJl`K`e0{lYhQ]htd_' :P]+j1& aTBuД@оGuI@{TgmN\%hɒ%˖-ss^z,^ͯ^Q0aɓ\resq+޴m~%tرo~ܛd>֭kz+\mO'?@zcӦMVuy׮]sNQFU|cܸq?Z=dMƼ=Wos[> .]VAד4L&Tob G}MAuz BuД@оGuI@{Tgm2>lwMAiԿ Dzsw)[Q^߬n& +&͛<5~MBC捵GMcx\iU3k,4i\v5U{;u:8Yg4}vjkCX?Vd]mm 5K?ǻG혗3^[|op=i2QL@_SP]%E aBuД@оGuI@{C;v:SNmOw.]ܳk׮ҭ[7TϞ={={%ӧ{}ҷo_ׯzG)%5pɛTyCW_}7J֪??\]%ھpI':m|Ø)G) W47@2R>Ώ!+hZ燾rA|7m_]VFuS{qOJOVW۷oJ,5nTӢ{L?sr>{';YMc%۸hSq' ޑ;|ڥ ^|b@p[wpux\rUfUI޵[oUj u]|\m~ۺ@-q>%PkO~V (ܐ`_|Q~5\rHWӺ}gu+E ц sF[W#mҝg&-MAWCuڝuΕ txdu>nJ\@:ɯ/$-캵:yt-+1nHzT_Yk6g`QZ8rl Q.?EQ}e];ϭwq/|!;@uɊns7J[N^z=>*@'c%@Oڭr<4hoNw9OQDx͹e:;ho`CRu}v"#\Nn;+Zw! =r%f$@J +=Y-hÈ (-Ώ 9 6@:yc=]S{nwP^q%ܝ5V-.ҥ8wܥü݅۟]^Z{15JIH@s$d4ІD BSJ@_0$<ŋȑ#^QJ$@$ %%Kϥ6&\R. @?oY~__l Fi p w; Օ#,0hs:ChJI xhߣ f$` 7O~9;3<@Rk@KQ6@mGP!4$<Q]3A0޹s|X:$p}Ǟ={޵k߾}l۶Mn*[lM6ƍ壏>>@Zh!z>}H߾}Oww>3S$@$@&Bu?x4ІA BSJ@_0$ .p_8~VC15kVe˖ѪU+iݺp Ҷm[h׮{t=:u$;w]JݝAA -ܵΘY#BuYzh BuД@оGuI@ .?mVǃLi= tPu4І@ BSJ@_0$ѣ.Za\k %RJe%׊rJG.MmP!4$<Q]3A0(!C |JIL[hh;N{3[@xͅ )% }/ @ tH= T U!T6 \R. T@RZ:}t2e :T,XnfC~>j(_}zkU㏻7")};C^`]h|1 SR nk 4TgM) O{T|L Bo>,ǁc߾}UW;w~Kn+޶m|'uVi&ٸq{N;M8 ۻwo[{o6޽{NJBq7fvo-;no.f[W£Ϗn<:j)?<8Pͪkw)Z{W-ԅoK֭:mC) 14ІN@ BSJ@_0$JhCxXfNGYiôn(Vr+৞z3W]ujJ֭]B_TNͅg!SMZ|;j7!+5QT^\@G:1z]]%n@:~7(/vZ~: @oLy 4 5=l=0hs:ChJI xhߣ f$` &_݌ޅϗ^{Mn&+k׮>]|Gn+~ jͬH,.Y1?YV@^ϡGx5sڭƌyk9_-VԪzcwcєpuN2ǯ9/Bc:n_V*=iL) ե@6E BSJ@_0$hCIE/<+9E@W;_cjO}υʟa:Hm7P!4$<Q]3A0ȓXx Eovz32$@$@#Bu)W\q!ruwgyF~m3f;V_%s9Y :P]SKh Ç63'= `&Hh۷OfΜ)~߿_;{m^^eŊk+mnѢ|k_aÆ~] $!-I$p@2,NlB,JsG#wC΂ 2?,s=8wCyժU7;v{O?~v]Y^zlڴ}%ՙg)g}{jxuVؼy3|GұcGٳ|άr)rꩧ駟.͛HH,=7 բc@FMhEip~nYe~|_tۣ 5j8r{NlRZj[N8īm۶n[۷:8|I'IΝݣk׮u[1U;wʎ;DW񵎑#GR+]tqz<#wqr|N{o݇ZOvXz>m&|3PӢƻ{L_^ȹVb{ f5mjۏnn@ޞrtw@ߪ]@5C#گGytuyURxtڛU'~Ro:zӯb[ 5;Eߖ[ t+g.=%2h?6#!g5~[r7Uoôn^v[?^z?vF[WQhԝ B֛woBV(t:jrC]NuΥ tUh ~cj-]o_n n_?dP7&m5۾+ٺ}O}Sr5N5j5z# tdfZ_z=V@Gϩ_k3Q﯁4~@D9@Ƿt>9z 7!I:uG]?Ljr@Ƿk Zw! =r%f$@J -=i-hÈ (Ώ 9 6H@:~nݺkw~]k[ݹ}q<ݹ]/ Fj.iۯZ}ݮvGӭb9K7vo? M nuy?~y5q?ukK/TUXު1$:iyIXhÈ (Ώ 9 6P#GSO=]7}HQJ6pH $d6 ݐ`<]Un%R΃HHzS 4lB,JsG#wC΂ ^Z{15JIH@s$d4ІD BSJ@_0$<ŋȑ#^QJ$@$ %%Kϥ6&\R. @?oY~__l Fi p w; Օ#,0hs:ChJI xhߣ f$` 7O~9;3<@Rk@KQ6@mGP!4$<Q]3A0޹s|X:$p}Ǟ={޵k߾}l۶Mn*[lM6ƍ壏>>@Zh!z>}H߾}Oww>3S$@$@&Bu?x4ІA BSJ@_0$ .p_8~VC15kVe˖ѪU+iݺp Ҷm[h׮{t=:u$;w]JݝAA -ܵΘY#BuYzh BuД@оGuI@ .?mVǃLi= tPu4І@ BSJ@_0$ѣ.Za\k %RJe%׊rJG.MmP!4$<Q]3A0(!C |JIL[hh;N{3[@xͅ )% }/ @ tH= T U!T6 \R. T@RZ:}t2e :T,XnfC~>j(_}zkU㏻7")};C^`]h|1 SR nk 4TgM) O{T|L Bo>,ǁc߾}UW;w~Kn+޶m|'uVi&ٸq{N;M8 ۻwo[{o6޽{NJBq7fvo-;no.f[W£Ϗn<:j)?<8Pͪkw)Z{W-ԅoK֭:mC) 14ІN@ BSJ@_0$JhCxXfNGYiôn(o;ϩ UW]徚hҺukB_TNͅg!SMZ|;j7!+5QT^\@G:1z]]%n@:~7(/vZ~: @oLy 4 5=l=0hs:ChJI xhߣ f$` &_݌ޅϗ^{Mn&+k׮>]|Gn+~ jͬH,.Y1?YV@^ϡGx5sڭƌyk9_-VԪzcwcєpuN2ǯ9/Bc:n_V*=iL) ե@6E BSJ@_0$hCIE/<+9E@W;_cjO}υʟa:Hm7P!4$<Q]3A0ȓXx Eovz32$@$@#Bu)W\q!ruwgyF~m3f;V_%s9Y :P]SKh Ç63'= `&Hh۷OfΜ)v8p@;{m^^eŊk+mnѢ|k_aÆ~] $!-I$p@2,NlB,JsG#wC΂ 2?/s~MЮ]w(Zzǎ{ɟgѯRӮ+˫WM6:3ϖs= @XVafCm6#!g]qهj@:tHtuXW|ygP5۷ow[͛1壏>;JϞ=OvfSNSO=UN?tׯ4oP=$@$@ `yAi50*lB,JsG#wC΂ ,_f8~VSǑ#GCͬ>?xue˖ҪU+hݺp &^m۶u+h߾tN:I:w]vu_5A$-ܵY!`yGg (ߘbe~J3ujaPꫯUf͚=x1>T:gQ $@ME6 \R. }mٲij]m(RtT$8OJ!#T,ˠ6 D BSJ@_0$ H}HvڊDP$P]ٰahnzG}T5 >\ΝVǍ'frߟPR9bJդAMٓB )tIt:=F hs:ChJI xhߣ f$` =3no.e<5jN:U̙W[&~L_t3۾=bĈ"2jh깚蹣ѧOK5C q5y͍XhaX,& jʞ-)0$5Yd 6@G BSJ@_0$UW͚5{4o\ZhQhٲwV[v+mڴqmۊ~wtvܣCѱcG9餓SNn tTzСu45oͺ⦸2sE͸{Ϟ= r^s5V7c!me~ 䔀ѣ9d/MhEip~nY@q9|{޽[vFcm6ѯ҇M69ݭ[7ѣ{S>H^wNtEP]]b ?5Ց- Bu.R } w>cO~F3 ː$Ak &h6P!4$<Q]3A0@BTw=z?^\HF}MAuyW^hC'ͅ )% }/ :^{ aLjO}MAuW\ i BuД@оGuI@{Tg_7|3|D:' DG.KlBm63'= `&H߷o %!Zn-=i>zŋ ^E|"l,t̂2Fm63'= `&H I'TFtTj"o+zn&4};}cƌ#BuUXh BuД@оGuI@ zҡC (% HB}υ䒥@Fm.TgM) O{T|L l}Q,3}hQJ"|`@r|s9 &-ܹ~_&{.TWRhͅ )% }/ @ t8hBOz1лvr~weڵ|MYrz2p@ dnՙ @8\.j ?\R. $5_Vq ÇˡC'w^ؽ{ܹ=o.۶m[ʖ-[dӦMG}$|nZz%r3̧~ϙ.]PJ$@$Pm{.TWCGmP!4$<Q]3A0Hjf\LqPXc4kL7o{lRZjVѦM9ݣ}ұcG-jv*ݺu=zHΝ URJ#-c3 di 63'= `&HI t~mVǃLi= tPu4І@ BSJ@_0$ZW5І)%kEYqd9%#TS ʦ6t\R. @!܅P>$`&-fd| 44z'G-IJ"'6B BSJ@_0$r訑{ 8(% =BʩAm&P!4$<Q]3A06Y5kd„ 2{lwrӧOw\R. @/_\tUM*+5/'V@2zS[VR9*r`hTJZacҁ@ Cm@63'= `&Hi3Јq^p$>wʔ)utϟ/sNmjՈ3ƭRsv);vyɀdѢEnKv!3E_s}a\> k>|̝;׭p7Nf͚3;ΡXͥr,D uz"C"#TPi5Mڀm.TgM) O{T|L fb[SFPMԩSeΜ9J|5nr 觟~4kK:#{#F(x-r!֯y;j}}qPc?dWC!m7ohV2^jڡc@sJi*4hs:ChJI xhߣ f$` @kN:$z}4kL7o-Zp?^ZlZ֭[G6mܣm۶r'}ҡCرtIҩS' K.ҭ[@:ΔW\M2߬+n ]_}!=WԌr{ikMܟu h+xH \.MmP!4$<Q]3A0HbAvqٿ{۷=G ݻe׮]u[umDKZ>6m$7n=g=ӟ|3^zI޽gϞpBguvŊ2x9-֜ƏV Y[3܊ѻpǷ][ 'x7j.thD|U^XFx @){.TW*^^~OmiP!4$<Q]3A06j׿Nu֭wyGVZL??8uVۜ UqZmEp@ PsZN 7ֈXC q!y[nxRHE PQ#@mP!4$<Q]3A0H%*Wz_C?>Y/YN99sK.wjЯFo<5Ud.Yzq t<Ʈ|54n^[e⯩/n5X|0@#hhsͅ $0Q]250H./>~i]j(~]ur&Mrw܎ޅ;z蝰qq x4_RwyVk'7~˶g瘛/OkEJiEG.j W BuД@оGuI@ mPZkuQ[W^Ytfk/tr@Fm.TgM) O{T|L  h仄5D֭e޽hIw%_~<3%nj$׊ I:P]ʯX4hs:ChJI xhߣ f$` =3B_tW˟ aLjO}MAuW\ i BuД@оGuI@{TgT_~r-  <@_SP]!5@#A BSJ@_0$Q!tͥSNlٲHH OT'vJmP!4$<Q]3A0@BL۵ȶm={,NnNߘ1). k ;\R. } .]j̝;W}QmUl\H4@K3rNm63'= ܲe5J&O, 8}c:o[7|wk*g>\L(9j% Ԇ:P]m/* aLBuД@оGup4 tw{G9t/ݻ׬={Ȋ+W_W^yE.]*:u.H V8;;;cJjG kO?2 a؄XG|͚52a1b7N* ,6mĉe޼y.eʔ)u 9wٳg! suPW|jڷo/3f̐iӦI߾}LO7⪶}2?8Ϝ9f͚[;z7П|aYn;o[o%;w/| rgg-w)$@$@ahkOX a\؄XG\ ȑ#mzx7fҟExܥK[ o@=AVS˝9ןwܹrg̖.͛7ݺ NчSj~w!۷ow7RuVټylܸQ>c裏\ioKz-rzr,g?Y @6 X^{=MMhEip~TnW#[]5-k+гfrzUi3=9s@2?tU7pf8~بQ7:Gq58Z}^[A'xk4Сtmև]m ZZg@N6#Q!/fuUzʕvmʍESl~u]LZlVfXoإ&WuG-GA@L3):P] e< hͅ )% }/ 3V D+Uоt;uFZ@זdE$P@S^{ȳ4ҌlB,JsGrC^@ǯ[z\xaC q[jyu<Ƿks|cd~Hyj}QH8nfw@rI^{Gh c&44w8?*7 F&߅{h"w'oU٤Iͤw5ЕȑM6o~+ܵ2A3(E@U(ԝ0dhs:ChJI xh߫No^Y^z\wu\q~`q$\n0kOeMhEiX_./e|뭷:^INꇯ|+2p@UQz,\PMN;4җ$=3n޽{\tz]~ayW $@$@Xޛ#h ( tڃ T 4>848+h+JG)@s+wz&sj;7FA 4Y? aلX@A#va='ğ@ p~3H 9te 4ІqD BSJ@1:afe$Ι2H 58?R3TL4`/8?0ʬ\ti9? aBuДlٲEF%'OAOоGuHHHH \. ʜ8 (\R{{T|LHHH&BuZh BuЙYF&L #FqСCeҦM8qU=ϟVO.SL??s9fϞ-{3ƭR.]*۷w:m4۷o -[U&t ))$*ܢbU&Qe I{.TIHM( m.Tgy#G:۲gϞgm{2uTҥK-ބ7fG] lΜ;wy,{TWx.BœB!H04@K3rNm63μ4n~B?SsÆ kYf 'Ui3}Μ94ƮCSN#!cU$QE Yt+N4hsEe]g?kN) M 2fG!-ʳfG6ƑUԖߛU? kSg]uggpJSE)#U2Y   H7`@ZPo^Y^z\wu\q64},ѣ+ @Ye҄_~Gɿ˿ȯko;w!7tNTh -jJ[T:8?A;w{3[hqV݃YmKif 3 @#8?$P@KQ6@mG5mMi&s&Ų00'wus'h Ώ*GH03p~:2 $.DS #\Ҍַ ^7#[zv}_*[UΏ*®r(Ώ9?3 LB= K?T@m634#u&+W5hzMۀdƍ:%q~Ts-p~$agudҟIP]hGP!4!@)l|/ПM6B䗌_>B+TN Ϛm.TgMiF7224HΏ` dCA~lo#оBuPi LBuДf{##I]`NM6䗌_>B+TN Ϛm.TgMiF7224HΏ` dCA~lo#оBuPi LBuДf{##I]`NM6䗌_>B+TN Ϛm.TgMiF7224HΏ` dCA~lo#оBuPi LBuДf{##I]`NM6䗌_>B+TN Ϛm.TgMiF7224HΏ` dCA~lo#оBuPi LBuДf{##I]`NM6䗌_>B+TN Ϛm.TgMiF7/_.ӧO HΝGɓ'˚5kd„ 2{lׯ(ߞe5j5h )4&08t,]Tf͚%'pH}8!Y_K j98%&@ 5!L>0hs:ChJ3BTox֧Ozo49R?4Bױrʺ˖-+iTi+=Za?>?,wjCѣ<* g5{q uȢE܇BQ7H~45yy^-;7eџuY2qD7oiӦ s :&`W_ jI+TN Ϛm.TgMiF }0~xٺu{sW@E7ߔ;@{3}#Ν;WFWh32JQ@N:ɜ9sN)2]Gc~S9y}㏋~BoVYz{uj޽D2nNw]迟x&ht9,7+w~i= aBuДf@.}CoX{=y衇N+Vޘ7ÇwTW{ǍWx_ϏEW}}n|E؊C6mi 6x=ZaÆ7jx;JoFڸbe2[WڶmE{ln.D߬gĈnW;}]ўol t2 oJ^tj>~?Ϙ1c}(#{Sk֜v);vpɦN-i[%կ~.uA }:ut4o^f̘Q7'[ߚbzOtG>d#YٵJsE+TVuˆm.TgMiF'|ҽaQc[JšB@} \]<߈뵙^۳gO"H_{u[M+57owrT͛Ok)eZJ_Z1_|m@QX+ߌq(fo,GyD{XOPzhJVc}s+jڧ}3նR+ 5z~{~.F6kO@@.~VtΏdSK/}}UW]e2v@eIOD_St}ի{G7 /нE_KZ&H>; оBui9@(ͅ )R}%69}#+MoL шl tͅ^zO:bX t4n|-Zo4'~X&gM~gڰz~_@;ovbjl^2Po]~Zl: vy^h.zjhőmՕ@k1 3G^ ~ID -YګAJ19SCByFK6bgb|mRFh_42D4hs:ChJ3BToD ݯ~Ư'o݆hVl5Q[@G}Fo<d:U ][z7)5i㊕јUUߛ. h!=RLn:sXWΣ7~j@?|+e::/Кi+6-N\/]F73к~.+}|E?4*fj }h[>jX!ME6 \Ҍ(q-;oK7p@[Z2Q/>>r ttuBW˱=ܲC2ڱf+VFc:ԥȮ o ;dRq5k]쒆R_9?MZhӥz>k~+z//@:m.TgMiF 0V,;n Cƍ_4iۮ7:,>R1hbwnokƶVWγK.G@_Z,x^-ܕ^?*:~ρߑG5kM%x6vZokd@ U0#@m.TgMiF @ZYoٳIumnwCZV|lcw6hoRM{^zMu)]n–Z5Bw֟W)i+3!jR*۳okyo椗WջSG t]wilr\(vջ==,5s2"t@jkD=܅;~}ޅɳIZ}  4ɩ؄X$P(3RiߐY*赒j%nc7,g͜Qi%dB67Jg~h_tR(4hs:ChJ3B Q32-# [Q O"?5~C|E,a5{zѕ9MR585&&&@KS8)KQMڀm.TgMiF722E&_K/gs|%9P:C եB60E BS썌 $ tE"X9)7P_2~?3?P]:)?khSP!4!@@Wd 9?*5r| %9P:C եB60E BS썌 $ tE"X9)7P_2~?3?P]:)?khSP!4!@@Wd 9?*5r| %9P:C եB60E BS썌 $ tE"X9)7P_2~?3?P]:)?khSP!4!@@Wd 9?*5r| %9P:C եB60E BS썌 $ tE"X9)7P_2~?3?P]:)?khSP!4!Э[7Yr## O?ƍ 8?.OH>HzΏPG&yեHy*6pD BSַ_;6# Oŋ˯~+Bi"Ώ&K8?Gr#ԑI^'Au'R h BuДfnAVZX'}N. h4<#(q~$g8?BzT~"婀m.TgMi\s5}vYpaw)CrD(NQ(PHd3ԓlRWEm`634cMвe뮓.Dp|{NfΜ)y.r~fNQ9c[3s~T4㠞Ց14ІN@ BSAO{zeӦM0%uU/ٹmcQ~<#Geis~ToQi<'zTG4@ ՙH e8R6`L8?RF#et$#Td5H+hs:ChJI 8R9lLJ8?aRI#Ƥ##TXy5Kڀm.TgM) ~#[S;&J4a?8?|̝;WV\)> nōZ˳HHHHwvTe"M IDAT5MbPVFJ hh[PX/himR hX(*B1F#ј6^ ]83gs޳׬>wqsڳ!$Փ$!M( \: ;vvUfng̘5\bEvڑ#;w_0vmڴizۙ^xqv5]ݽ.]:bL̙3K?cA /[,cq͛7G+& @ P=k=>vTK9BG#Skrʕ٦Ma?k֬G~8馛Jŋ4f֫mhȋ?2/ƭy3s(= ^4KD"$pRH)hDZL@$(:ځSm.U4]5#h沺 ۑ+?htCmzok6.>,ˎew@we-D@I*z览H1DNT]2`jvTK9BG+ker2}0wd .c >`ʫEQ 7C PבAhG'ͥ.k֬9眑!WMW?ݻwgo|GXW xO>W t#U# @I@$y, cRuIJ1Vn;%yqC m>6!B TO| js:Gh*k6|%=;Z5ҬN#'|HoXCODH%vhBT#4R W{fGuTfOW4kaF >" *P<:Ru`]ځPm.UC%P4y"P`}D>A7T'x"TOR \yc=6;,⋳u%8p@" @xޛ|1:+ iZh#֜S  @&{&tB3Ьb  X:3hW iR~Of}$5u4 ! GtSBB-$#UBI6sF {վWuC/ 0`fV`}zH>:Ru540Ў)PK9B#@ԾWuL= {m۶eӦMziZ~sOqlxqDuԉyL@}ϥb0js:GhYKF3gN}lemz#dK,㎑/_>bi>諯:/_o֭ig<@@KA  RuH!=U]? eP=޿jժllSO ?v]܁`;=G~+cAA@}ϥS c`6sF }UXf:KN~lٮ] ɷ~=;w1mbE-ߴiSr3)!w߾}]bl3>hw>^܁߳gOrlѢEv{zV}֕sʏpg)O϶lrys{NvG8_;78QB58K "6v̚\)'gfv1m37tvM?k֬`<;fme˖}ᇳkf7o 6{o|y9s星ѭVPk&*b] @i?G x8/Ŝ?5Θ1c$+V+뭷fsL5İ=uX$ 2vWHuDub'"TwT#4RDO@{U}8fۑ[nenj]I6]4@w[+\wQ3rw s嗇Rjޛs tX5(2-Avsa8ް kbl_$u̲PKiQQAԾWu: G^#..u.sV\~l;?we&7m/;3E;h]Yoex`;mܤgt87xcءUC@ ϏZWظVd]<:wF','\:20_,gG5W3 @=AhG'ͥB zj߫~\}J]<\:\| w6d8zQ r!3ėCwK'"yo}0:+ ?ݛs*vΝ+su`->u&rnC cRuH!=U]  & Hk!&H5sb`6sF }/!P 0SվWu@8 S_)%T#4RDO@{U}$3fd3gE{U|@D)nx]w cRuH!=U] ԾWuH!@)Gvt\)'|G%KdW͛qIM{UrTUSw? ST]?skXhͥB zj߫ 8A t|B2@ ˓ѺI@]GGWvt\)'ܳgOrlѢE˳ f۶mˎ8lժU_ٺuky^~}v%dhklM6eg]lYإlԩن uef*]wɮ$^{U7"Zhtlu"-0js:Gh.L ŋc =ʮٮ+kfӧOu;7K 5{Ps>mڴ ?D7)~Fiṿ\)'_ 뚙[5>S&emzƍٔ)SBut~bA߼y39j߫:gx AUA=K@;:Am.UP^E_p emWz׮]L6C}İ @)(Kc6sF }/2czrMnp22 8,M@Mc,RuH!=U]7`/] cݻwg'|rx@؂ Qn{UM}y#y׶{8ݿIV^/3F@X q YT]\h[T#4RDO@{U} &@[DO3gN} .:wE]ݻwS `&V{U7,`-3d^:Ru%1js:GhF$|/@@{Sե 0pO@gh<ͥB zjߏ׿]yc=]p&A(>8h @9~ 04>0Νk\g}tC@_/G vp vdǭvvַvwdG7P%z7Sa04𬏛n)۰aCx֛. oπ/>c{q% . ?._ׅwzk_~Wҿ5 뮒կ~u~IW*\Ki*oO=xxEt/yt/}i'~ϋǟ;wnӟ?w_I$\~Vn%}tqE/~/=9^y {iŸ_W%}n~}o~3goKןJןgJ̘1#\ֳ8p RQ{aƘhǬфXH;G`ÎCf;α`@ o}o]dn{'L vb)rXm({3 `A:`!~3Ӱ;;A@]3A`}O@]G~Fiṿ\)'`@M=i"#UPч@;Hm.UP^E_0 B&I`}$==k(`S6sF }/!@@\.RM 6sF }/!@@\.RM 6sF }/!PGTk >^kK5va0Ў)RK9B#@ԾWuLIP 'MR\CuJ;0hͥB zj߫ &A$Z ۓ&Hzz)!:Ru } cRuH!=U] jjMܞ4GKq PsҎ> 1Ejs:Gh.I DL@}ϥ".0js:Gh.I DL@}ϥ".0js:Gh.I5 pD&@nO#饸T]CiG"T#4RDO@{U}$X 5r{XIO/5D@]GvL\)'`@M=i"#UPч@;Hm.UP^E_0 B&I`}$==k(`S6sF }/!@@\.RM 6sF }/!@@\.RM 6sF }/!PGTk >^kK5va0Ў)RK9B#@ԾWuLIP 'MR\CuJ;0hͥB zj߫ &A$Z ۓ&Hzz)!:Ru } cRuH!=U]`߿?[jU`lɒ%CϿGTlٶm۲iӦ 6@]\us~KյC@;ͥB zj߫ &F/[p,V {'۸qc6eʔ͈^r%#?ϙ3'۾}{6{='H@q`˸k՞BT݀lݰhǔͥB zj߫ &F r׸u<vdi@7$@@&RurąhͥB zj߫ &FLd~ |K_ Νٝw9l?ϛ7/+5wlٮ]=}7cc={'?2]ܵ^n.lnNmذa$?g[l {q3ɱxDҥKG!ߕw{#?.`/kʕ٦M.X1sݢEBk-c׫u4,IGN=Rх@;Dm.UP^E_0 6B@1fLGT榹cl ?k7ٌ;Fƫ9Ѯucƌ&7ϧxzϜ93j~=Ka:=,|Yy@[U3t#K3A]љPב`.T#4RDO@{U}$>}>\}xR tq7zO/_Yͯh:mg tq78_)6vlaǺo@?#˖- ;U\iwǺ!H]RXuL=PhͥB zj߫ &F(;Ňz@ |Gj"ޢ_z8]4ЖM7v@ffcǴ@Ϛ5kib r{zwjŘFZ O#ܴPs11js:Gh.I6VdqW[n)xف>cF}]4E՝bkc6qNJY4;Ѝ,@4=t"݈vL\)'`l tubY&;sôUڮHt3A޷o_@W?S\ڊܺum{GOl' w1².Vn]嬨{?񏣾{@zx w## Nzz)!{.UPч@;Hm.U<5IDATP^E_0 B@ 0ޮCĄ!@]щiPבp*T#4RDO@{U}$Z$yлw]:]…= HՁ  RuH!=U] jjM ‘>f}bzI2r{.UyvVK9B#@ԾWuL 0![o5{ߞ͎:_Ϧ  $Ru>HT#4RDO@{=CǾ_Z~9^ d8~b.}su?砭c t#=~.x xޛٷ2`5NDž&@}oӧ[T6]Xtj׿=/r5cqu.בG=c Z=6l grPh){3֖>h i9#zQ%@kA bC QuT6L0js:Gh.I5 jVP>U 0$ kF5r+B`Ӥ6sF }/!PO [A  Ӟ1^PuChfT])"1Mjs:Gh.I$}{AII!@kFuT"ZtP6sF }/!@/ /I1 Uv`TK9B#@ԾWuL <#ْ%KիWg#"@dP/Q DQubehͥB zj߫ &A2Ь kA%! P׌&/@;Xm.UP^E_0 v={+Wf-ʖ/_-\0۶m[vGdVʮf֭ayIˮϝ;7;cݻwgg]lYإlԩ;r׭[͚5t۹sgiWB&^PuA#uͨ>0ЎSK9B#@ԾWuL%`z@۱l{xƌ:X"[vm6}QGmN;-4K.-d3k{o0v}ڴi o?k?*@kF'v̡\)'`,|zӦMګ53k|)4ж1ƍ)St~bA߼y3ݘFU@}Qu3Jc cRuH!=U]`g emWz׮]%.v\Vp{AՉaA yQu @L6sF }/;K`,=np)G3@w:U{Au B`Qu>HT#4RDO@{U}$Y t3tO>9< l(Tgϟ?sζ\򅫿T]("uͨ:1l2 cRuH!=U]`g 2#7S̙m߾=|N:7Ȧ˟mk!]tE޽{G=ζY W/NXC@]3 `6sF }ݶs=7I%|$[fdo>$C@޴>qفB 0hQuη-c36sF }?ΌW^On&A@G?eHkk0vp v@Q5\pAs )@ E^ kK%ahB,#0q\PpGi$0&&ښdh5 ixc=V:=֎sYaKϾMr!g?q=8vXysN8׿Jq'QΓp>ZG3up=5?4z=iO{ZOSiz>δiDKcO?\sOfL)~@ kFuet RuH!=Mw9d{lcǎP?@O|=_ve^Z{ |c+㽾aÆ0G?8_~ygq&s[4W\\ql8/t{սnO}wrq|O}Sa{Wq*s%^ߴiSgեqz]7i꯾0·?8nq>ټyssƹK\s5a׷l2~׆ql8]w]i{JL񷧵?\q.87pCsy{[3L{j cxxt7 xޛ@8b`{}܄g.]Z2f`iӒվWu̍ @@T]U/ js:GUkfvO9Ihہ޸qc6eʔ4ߕίYL37o@;N{U #M 7H lB%K@}ϥ, 6sN^:]]vZB{U_d`-'E|RpH bs6sN^:k7S#@ԾWu˔!B@q`}9/d.:Ru~pblRuK{g vޝ|a ,GU5y|z\wZK{U׿ qjBVq`}1dn{.Un`6sN^@[ѹΟ=gΜl)۹A6]tⵋ.(ۻw﨧pn0Y2* @=@OhD6{Go9; @U] @K_q3bOg+̮M7p#@?GՑO#gʈ`}3T2<7 { k&,3<3|~/x#:RM2`kf0q`}=?d:RuzYb*rlζqvG*Y*d!gsX@+>Z1M$9um,= \Wi;3 .gk#Yh_d >j2\RXIM' i³:+뮻᫖ɾ|ev'fw\O:\D_xS줓NC=4;󳫮4k| 88RB @<ޅf:_ J~z0;H!@ @i:&,~H $"D1 GHC&02[혦:MvF u$S0@AစsXr u!1ЎiSk<5B) 4n GgBH@]Gnjh cRtfovd"v6K,o]EqPMV`}rH:2:Ru7t0js:Ghh%B+"h4aZIi#HEV@;ЫͥB8i#>MV`}rH:2'Qu7t0js:Gh @d'QurąhͥB @ DɁb6sF @ @@&zU'N\vL\) @ IT8q!1js:Gh @d'QurąhͥB @ DɁb6sF @ @@&zU'N\vL\) @ IT8q!1js:Gh @d'QurąhͥB @ DɁb6sF @ @@&zU'N\vL\) @ IT8q!1js:Gh @d'QurąhͥB @ DɁb6sF @ @@&zU'N\vL\) @ IT8q!1js:Gh @d'QurąhͥB @ DɁb6sF @ @@&zU'N\vL\) @ IT8q!1js:Gh @d'QurąhͥB @ DɁb6sF @ @@&zU'N\vL\) @ IT8q!1js:Gh @d'QurąhͥB @ DɁb6sF @ @@&zU'N\vL\) @ IT8q!1js:Gh @d'QurąhͥB @ DɁb6sF @ @@&zU'N\vL\) @ IT8q!1js:Gh @d'QurąhͥB @ DɁb6sF @ @@&zU'N\vL\) @ IT8q!1js:Gh @d'QurąhͥB @ DɁb6sF @ @@&zU'N\vL\) @ IT8q!1js:Gh @d'QurąhͥB @ DɁb6sF @ @@&zU'N\vL\) @ IT8q!1js:Gh @d'QurąhͥB @ DɁb6sF @ @@&zU'N\vL\) @ IT8q!1js:Gh @d'QurąhͥB @ DɁb6sF @ @@&zU'N\vL\) @ IT8q!1js:Gh @d'QurąhͥB @ DɁb6sF @ @@&zU'N\vL\) @ IT8q!1js:Gh @d'QurąhͥB @ DɁb6sF @ @@&zU'N\vL\) @ IT8q!1js:Gh @d'QurąhͥB @ DɁblͥ8JA @+K_q  WF @ `kNG>l͚55Gv@ @%w]! !@ F]c@dH @@#.1ck2DM@ 4BR3>CF @ @w`) @@d1 @hޥ>f tM|&@n @!w]!MX C @njɐc5r; @ K}  @:@݁ID@ @O]! jv@ @x15A @hޥ>f tM4aM@ 4BR3&CA @@#.1c3d@ @ t&!@ @> t}@ @ pZ8IENDB`netcoredbg-3.1.0-1031/docs/guide/000077500000000000000000000000001457701673000162505ustar00rootroot00000000000000netcoredbg-3.1.0-1031/docs/guide/.gitignore000066400000000000000000000000601457701673000202340ustar00rootroot00000000000000*.aux *.idx *.ilg *.ind *.log *.out *.pdf *.toc netcoredbg-3.1.0-1031/docs/guide/Makefile000066400000000000000000000004151457701673000177100ustar00rootroot00000000000000 GUIDE:=netcoredbg-guide PROGRAM:=$(GUIDE).pdf SRC:=$(GUIDE).tex all: $(SRC) pdflatex $(SRC) makeindex -p 1 ${GUIDE}.idx makeindex -p 1 notion.idx pdflatex $(SRC) clean: @rm -rf *.blg *.bib *.aux *.bcf *.idx *.ind *.bbl *.dvi *.out *.svg *.pdf *.ilg *.log *.toc netcoredbg-3.1.0-1031/docs/guide/README.md000066400000000000000000000013661457701673000175350ustar00rootroot00000000000000# NetcoreDBG Developer's Guide. An easy guide to NetcoreDBG C# debugger. ## Downloads: Binary releases are available right here on github: https://github.com/Samsung/netcoredbg/releases ## Compiling: On Linux, Install `dia`, `rsvg-convert`, and most of LaTeX, then run `make`. $ sudo apt update $ sudo apt install dia $ sudo apt install texlive-latex-base texlive-fonts-recommended texlive-fonts-extra texlive-latex-extra $ sudo apt install texlive-binaries $ sudo apt install librsvg2-bin This automates generation of includable diagrams from the respective .dia files. If you manage to automate the process on any other OS, please share! ## Reporting issues: Please report issues with this guide here on github. Pull requests are also welcome. netcoredbg-3.1.0-1031/docs/guide/netcoredbg-guide.tex000066400000000000000000001131221457701673000222010ustar00rootroot00000000000000\documentclass[a4paper,12pt]{article} \usepackage[utf8]{inputenc} \usepackage[english]{babel} \usepackage{float} \usepackage{multicol} \usepackage{xurl} \usepackage{xltabular} \usepackage{tabularx} \usepackage{longtable} % Images \usepackage{graphicx} \def\imgscale{0.20} % Tables \usepackage{array} \renewcommand{\arraystretch}{2} % Index Module \usepackage{imakeidx} \makeindex[intoc,title=Index of classes] \makeindex[intoc,name=notion,title=Index of notions] % Fonts And Paragraph Styles \usepackage[a4paper, total={7.3in, 10.1in}]{geometry} \setlength\parindent{0pt} \setlength\parskip{1em} \renewcommand*{\familydefault}{\sfdefault} \usepackage[T1]{fontenc} \usepackage[default]{sourcesanspro} \usepackage{sfmath} \clubpenalty=10000 \widowpenalty=10000 \usepackage{dingbat} % No-Line-Break Sections That Hold The Listings Together \newenvironment{nobr}{\begin{minipage}{\textwidth}\setlength\parskip{1em} }{\end{minipage}\ignorespacesafterend} % Fancy Enumerations \usepackage{enumitem} \setlist{topsep=-3pt} % Colorful Section Styles \setcounter{section}{-1} \usepackage[usenames,dvipsnames]{xcolor} \definecolor{Section}{RGB}{0, 64, 128} \definecolor{SectionNumber}{RGB}{255, 255, 255} \usepackage{titlesec} \usepackage{needspace} \titleformat{\section} {\nopagebreak\parskip0.2em\color{Section}\titlerule\normalfont\Large\bfseries} {\parindent-2em\fcolorbox{Section}{Section}{\color{SectionNumber}\quad\thesection.\quad}} {1em}{} \titleformat{\subsection} {\nopagebreak\parskip0.2em\color{Section}\titlerule\normalfont\large\bfseries} {\fcolorbox{Section}{Section}{\color{SectionNumber}\ \ \thesubsection.\ \ }\nopagebreak} {1em}{} \titleformat{\subsubsection} {\nopagebreak\parskip0.2em\color{Section}\titlerule\normalfont\bfseries} {\fcolorbox{Section}{Section}{\color{SectionNumber}\thesubsubsection.}\nopagebreak} {1em}{} % Fancy Listings \usepackage{listings} \definecolor{InlineListing}{RGB}{0, 64, 128} \lstset{basicstyle=\ttfamily\color{InlineListing}} \definecolor{Command}{RGB}{0, 0, 0} \definecolor{CommandOutput}{RGB}{128, 128, 128} \definecolor{Console}{RGB}{240, 240, 240} \definecolor{Executable}{RGB}{0, 96, 0} \definecolor{Prompt}{RGB}{0, 64, 128} \definecolor{Rule}{RGB}{192, 192, 192} \lstdefinestyle{commandline}{ aboveskip=1.0em, backgroundcolor=\color{Console}, basicstyle=\ttfamily\color{Prompt}\footnotesize, belowskip=0.0em, breaklines=true, captionpos=b, emptylines=1, frame=single, moredelim=**[is][\color{Command}]{@}{@}, moredelim=**[is][\color{Executable}]{@@}{@@}, moredelim=**[is][\color{CommandOutput}]{@@@}{@@@}, rulecolor=\color{Rule}, xleftmargin=1.9em, xrightmargin=0.3em, } \definecolor{Background}{RGB}{240, 240, 240} \definecolor{Code}{RGB}{0, 0, 0} \definecolor{Comment}{RGB}{0, 128, 128} \definecolor{Keyword}{RGB}{0, 0, 128} \definecolor{String}{RGB}{192, 0, 192} \lstdefinestyle{cplusplus}{ aboveskip=1.5em, backgroundcolor=\color{Background}, basicstyle=\ttfamily\color{Code}\footnotesize, belowskip=0.0em, breaklines=true, captionpos=b, commentstyle=\color{Comment}, emptylines=1, frame=single, keywordstyle=\color{Keyword}, language=C++, numbers=left, rulecolor=\color{Rule}, showstringspaces=false, stringstyle=\color{String}, xleftmargin=1.9em, xrightmargin=0.3em, } %--------------------------------------------JSON----------------------------------------------------- % json highlight colors \usepackage{xcolor} \definecolor{Background}{RGB}{240, 240, 240} \colorlet{punct}{red!60!black} \definecolor{delim}{RGB}{20,105,176} \colorlet{numb}{magenta!60!black} \lstdefinelanguage{json}{ basicstyle=\ttfamily\footnotesize, keywordstyle=\bfseries, stringstyle=\ttfamily\color{BurntOrange}, backgroundcolor=\color{Background}, %%linewidth=\textwidth,captionpos=b %numbers=left, stepnumber=5, numbersep=10pt captionpos=b, aboveskip=1.5em, belowskip=0.0em, emptylines=1, numbers=left, breaklines=true, showstringspaces=false, frame=single, tabsize=2, xleftmargin=1.9em, xrightmargin=0.3em, literate= *{0}{{{\color{numb}0}}}{1} {1}{{{\color{numb}1}}}{1} {2}{{{\color{numb}2}}}{1} {3}{{{\color{numb}3}}}{1} {4}{{{\color{numb}4}}}{1} {5}{{{\color{numb}5}}}{1} {6}{{{\color{numb}6}}}{1} {7}{{{\color{numb}7}}}{1} {8}{{{\color{numb}8}}}{1} {9}{{{\color{numb}9}}}{1} {:}{{{\color{punct}{:}}}}{1} {,}{{{\color{punct}{,}}}}{1} {\{}{{{\color{delim}{\{}}}}{1} {\}}{{{\color{delim}{\}}}}}{1} {[}{{{\color{delim}{[}}}}{1} {]}{{{\color{delim}{]}}}}{1}, } % Hyper Reference Styles \definecolor{Url}{RGB}{0, 64, 128} \usepackage{hyperref} \hypersetup{ colorlinks, linkcolor={Url}, citecolor={Url}, urlcolor={Url} } % Fancy Table Of Contents \usepackage{tocloft} \renewcommand\cftbeforesecskip{10pt} \renewcommand\cftbeforesubsecskip{0pt} \renewcommand\cftsubsecafterpnum{\vskip0pt} \begin{document} \begin{center} \hrule\bigskip\bigskip {\Huge\textsc{Samsung NetcoreDBG\ \ C\#\ \ debugger}} \bigskip {\Large A\ \ Debugger \ \ Developer's\ \ Guide} \bigskip {Rev. --- \today} \bigskip\bigskip\hrule \end{center} \newpage \tableofcontents \newpage \section{Introduction to the Samsung NetcoreDBG C\# Debugger}\label{sec:intro} The Samsung NetcoreDBG debugger is an open source tool for debugging C\# Microsoft DotNet applications. Microsoft provides its own \emph{proprietary debugger}\index[notion]{Microsoft debugger|textbf} (VSDBG)\index[notion]{VSDBG|see{Microsoft debugger}} with the following limitations: provided only binary files, protected from using any other way across VSCode IDE or Microsoft Visual Studio. This project has been started as an alternative debugger for Samsung Tizen applications and can be used for some other tools and operating systems. NetcoreDBG can be built for Microsoft Windows, Linux, Tizen, MacOS. NETCoreDBG supports VSCode Debug Adapter and MI protocol. We have plans to implement gdb-like command line interface as well. The Main goal of the project - to develop the debugger with all CoreCLR provided debug features. This document describes the current status of implementation features and usage details. NetcoreDBG is an easy-to-use tool --- this guide should be able to help you. \newpage \subsection{FAQ: a quick guide through the guide} \begin{nobr} \begin{itemize} \item[\textbf{Q:}] \emph{Why do we need another debugger for Microsoft .NET C\# languages?} \item[\textbf{A:}] The Microsoft's vsdbg debugger is a commercial product with proprietary source code. In particular, vsdbg needs a special crypto handshake on startup, and can be used from VSCode IDE only. From the other hand vsdbg doesn't support ARM architecture. NetcoreDBG is an open source project for using widely with any IDE and any platform and architecture. \end{itemize} \medskip \end{nobr} \begin{nobr} \begin{itemize} \item[\textbf{Q:}] \emph{What platforms and architectures are supported?} \item[\textbf{A:}] Platforms: Windows 10 x64, Mac OS, Linux, Tizen and other platforms, which has compatibilities with .NET 2.1,2.2,2.2.105,3.0. Architectures: x86-32, x86-64, armv7l. \end{itemize} \medskip \end{nobr} \begin{nobr} \begin{itemize} \item[\textbf{Q:}] \emph{Do you provide features to debug native code?} \item[\textbf{A:}] No. Our experimental code for mixing lldb and NetcoreDBG works unstable and has not been merged to upstream yet. Now we have some ideas how to fix it properly. It is really difficult and interesting task. \end{itemize} \medskip \end{nobr} \begin{nobr} \begin{itemize} \item[\textbf{Q:}] \emph{What development plans do you have?} \item[\textbf{A:}] We are going to implement safety evaluation features to improve multithreading mode and we have plans to support C\# object's properties in the nearest future. \end{itemize} \medskip \end{nobr} \newpage \subsection{How to build NetcoreDBG from the source code?} Switch to netcoredbg directory, create build directory and switch into it: \begin{lstlisting}[style=commandline,numbers=none] mkdir build cd build \end{lstlisting} Proceed to build with cmake. Necessary dependencies (CoreCLR sources and .NET SDK binaries) are going to be downloaded during CMake configure step. It is possible to override them with CMake options -CORECLR\_DIR= and -DDOTNET\_DIR=. \textbf{Ubuntu:} \begin{lstlisting}[style=commandline,numbers=none] CC=clang CXX=clang++ cmake .. -DCMAKE_INSTALL_PREFIX=$PWD/../bin \end{lstlisting} \textbf{MacOS:} \begin{lstlisting}[style=commandline,numbers=none] cmake .. -DCMAKE_INSTALL_PREFIX=$PWD/../bin \end{lstlisting} \textbf{Windows:} \begin{lstlisting}[style=commandline,numbers=none] cmake .. -G "Visual Studio 15 2017 Win64" -DCMAKE_INSTALL_PREFIX="$pwd\..\bin" \end{lstlisting} \textbf{Compile and install:} \begin{lstlisting}[style=commandline,numbers=none] cmake --build . --target install \end{lstlisting} \subsection{Command line interface} The above commands create bin directory with netcoredbg binary and additional libraries. Now running the debugger with --help option should look like this: \begin{lstlisting}[style=commandline,numbers=none] $ ../bin/netcoredbg --help .NET Core debugger Options: --attach Attach the debugger to the specified process id. --interpreter=mi Puts the debugger into MI mode. --interpreter=vscode Puts the debugger into VS Code Debugger mode. --engineLogging[=] Enable logging to VsDbg-UI or file. Only supported by the VsCode interpreter. --server[=port_num] Start the debugger listening for requests on the specified TCP/IP port instead of stdin/out. If port is not specified, TCP 4711 will be used. \end{lstlisting} \subsection{How to use with IDE} Supported Microsoft VSCode IDE and Microsoft Visual Studio 2017 (and 2019) with Samsung Tizen Plugin. \newpage \section{Debugger features}\label{sec:features} NetcoreDBG is a project based on our work reengineering of Microsoft CoreCLR. ARM is not the priority platform for Microsoft CoreCLR and their proprietary VSCode debugger. As a result, Samsung contributes fixes and performance patches for ARM CoreCLR and develop flexible opensouce debugger from scratch. This section describes the current state of the project and our development plans. We try to prepare descriptions for architecture and main features behavior. The Debugger features have more interesting implementation and unique ideas too. Lets look under the hood. GDB/MI is a line-based machine oriented text interface to GDB. This chapter is a specification of the GDB/MI interface. \begin{xltabular}{\textwidth}{|l|X|c|c|} \hline &\lstinline|Feature|&\lstinline|VSCode|&\lstinline|GDB/MI|\\ \hline 1&Load binary file&\checkmark&\checkmark\\ \hline 2&Attach/detach to running process&\checkmark&\checkmark\\ \hline 3&Run/Pause/Continue/Break process&\checkmark&\checkmark\\ \hline 4&Step in/out&\checkmark&\checkmark\\ \hline 5&Step over&\checkmark&\checkmark\\ \hline 6&Display build-in types&NA&NA\\ \hline 7&Modify basic values (int, float, string)&\checkmark&\checkmark\\ \hline 8&Line breakpoint&\checkmark&\checkmark\\ \hline 9&Function breakpoint&\checkmark&\checkmark\\ \hline 10&Exception breakpoint&\checkmark&\checkmark\\ \hline 11&Exception breakpoint&\checkmark&\\ \hline 12&Conditional breakpoint (depends on C\# expression)&&\\ \hline 13&C\# expression&partial&partial\\ \hline 13&Call stack operations&\checkmark&\checkmark\\ \hline 14&Call stack operations&\checkmark&\checkmark\\ \hline 15&Capture stdout/stderr of launched application&\checkmark&\checkmark\\ \hline 16&Operate along with .NET Core profiler&NA&NA\\ \hline 17&Debug core dump file&partial&partial\\ \hline 18&Parameter "Just my code"&\checkmark&\checkmark\\ \hline 19&Threads info&&\\ \hline 20&Modules info&&\\ \hline 21&Process info&???&???\\ \hline 22&Tasks operations&&\\ \hline 23&CPU registers info&&\\ \hline 24&Modify user-space process memory&&\\ \hline 25&Show disassembly code&&\\ \hline 26&Follow to forked/created process&???&???\\ \hline 27&Tracepoint commands&&\\ \hline 28&Memory operations&&\\ \hline 29&Misc operations&&\\ \hline \caption{Debug features}\label{tab:debug_features} \end{xltabular} \subsection{Attach/detach to running process} This feature allows loading and setting arguments for executable file with managed code for running and debugging. \begin{xltabular}{\textwidth}{|l|X|l|c|} \hline &\lstinline|MI|&\lstinline|GDB alternative|&\begin{frame}{\bfseries\colorbox{yellow}{NOT SUPPORTED}} \end{frame}\\ \hline 1&file-exec-and-symbols &file&\\ \hline 2&exec-arguments [args...]&set args&\\ \hline 3&exec-run [opts...]&run&\\ \hline 4&environment-cd dir&cd&\\ \hline 5&environment-directory [-r] [dir...]&dir&\checkmark\\ \hline 6&environment-path [-r] [dir...]&path&\checkmark\\ \hline 7&environment-pwd&pwd&\checkmark\\ \hline 8&file-exec-file fname&exec-file&\checkmark\\ \hline 9&file-list-exec-source-file&info source&\checkmark\\ \hline 10&file-list-exec-source-files&info sources&\checkmark\\ \hline 11&file-list-shared-libraries [regex]&info shared&\checkmark\\ \hline 12&file-symbol-file fname&symbol-file&\checkmark\\ \hline 13&symbol-list-lines fname&&\checkmark\\ \hline 14&catch-load [-t] [-d] regexp&catch load&\checkmark\\ \hline 15&catch-unload [-t] [-d] regexp&catch unload&\checkmark\\ \hline \caption{MI load commands}\label{tab:mi_load_cmds} \end{xltabular} \subsection{Attach/detach to running process} These features allows attaching and detaching debugger to/from running C\# process. Attaching allows to enable a list of breakpoints on startup. Detaching continues execution flow of the process. \begin{xltabular}{\textwidth}{|l|X|l|c|} \hline &\lstinline|MI|&\lstinline|GDB alternative|&\begin{frame}{\bfseries\colorbox{yellow}{NOT SUPPORTED}} \end{frame}\\ \hline 1&target-attach (pid | gid | file)&attach&\\ \hline 2&target-detach [pid | gid]&detach&\\ \hline 3&target-disconnect&disconnect&\checkmark\\ \hline 4&target-download&load&\checkmark\\ \hline 5&target-flash-erase&flash-erase&\checkmark\\ \hline 6&target-select type [args...]&target&\checkmark\\ \hline 7&target-file-put host-file targ-file&remote put&\checkmark\\ \hline 8&target-file-get targ-file host-file&remote get&\checkmark\\ \hline 9&target-file-delete fname&remote delete&\checkmark\\ \hline 10&info-gdb-mi-command&cmdname&\checkmark\\ \hline 11&list-features&&\checkmark\\ \hline 12&list-target-features&&\checkmark\\ \hline \caption{MI exec attach commands}\label{tab:mi_attach_cmds} \end{xltabular} \subsection{Run/Pause/Continue/Break process} These features allows basic process operations: run, pause, continue and break. \begin{xltabular}{\textwidth}{|l|X|l|c|} \hline &\lstinline|MI|&\lstinline|GDB alternative|&\begin{frame}{\bfseries\colorbox{yellow}{NOT SUPPORTED}} \end{frame}\\ \hline 1&exec-finish&finish&\\ \hline 2&exec-interrupt [opts...]&interrupt&\\ \hline 3&gdb-exit&quit&\\ \hline 4&exec-continue [opts...]&continue&\\ \hline \caption{MI exec run/pause/continue/break commands}\label{tab:mi_rpcb_cmds} \end{xltabular} \subsection{Step in/out} "Step in" allows execution of a single line source code. In the case of a function call, execution stops at the first line inside the called function. "Step out" allows continuing execution until return from the function call. \begin{xltabular}{\textwidth}{|l|X|l|c|} \hline &\lstinline|MI|&\lstinline|GDB alternative|&\begin{frame}{\bfseries\colorbox{yellow}{NOT SUPPORTED}} \end{frame}\\ \hline 1&exec-step&step&\\ \hline 2&exec-step-instruction&stepi&\checkmark\\ \hline 3&exec-jump loc&jump&\checkmark\\ \hline 4&exec-return&return&\checkmark\\ \hline 5&exec-until [loc]&until&\checkmark\\ \hline 6&exec-abort&&\checkmark\\ \hline \caption{MI exec in/out commands}\label{tab:mi_execinout_cmds} \end{xltabular} \subsection{Step over} These features allows to continue execution until the next line of source code. In the case of a function call execution will not stop inside the function body, but continues until return from the function. \begin{frame} {\bfseries\colorbox{yellow}{\parbox{12cm}{TODO: \\ Limitations: Not supported: set and continue from any code positions.}}} \end{frame} \begin{xltabular}{\textwidth}{|l|X|l|c|} \hline &\lstinline|MI|&\lstinline|GDB alternative|&\begin{frame}{\bfseries\colorbox{yellow}{NOT SUPPORTED}} \end{frame}\\ \hline 1&exec-next&next&\\ \hline 2&exec-next-instruction&nexti&\checkmark\\ \hline \caption{MI exec commands}\label{tab:mi_exec_cmds} \end{xltabular} \subsection{Display built-in types} These features allows showing built-in types of objects and types. Please, find the table with the built-in types: \url{https://docs.microsoft.com/ru-ru/dotnet/csharp/language-reference/keywords/built-in-types-table}. \subsection{Modify basic values (int, float, string)} These feature allows modifying and creating objects of built-in types. \begin{xltabular}{\textwidth}{|l|X|X|c|} \hline &\lstinline|MI|&\lstinline|GDB alternative|&\begin{frame}{\bfseries\colorbox{yellow}{NOT SUPPORTED}} \end{frame}\\ \hline 1&gdb-set name=val&set&\\ \hline 2&var-assign name expr&&\\ \hline 3&var-create {name | -} {frame | * | @} expr&&\\ \hline 4&var-delete [-c] name&&\\ \hline 5&var-list-children [print] name [from to]&&\\ \hline 6&var-show-attributes name&&\\ \hline 7&interpreter-exec interp "command"&&\\ \hline 8&var-set-format name fmt-spec&&\checkmark\\ \hline 9&var-show-format name&&\checkmark\\ \hline 10&var-info-num-children name&&\checkmark\\ \hline 11&var-info-type name&&\checkmark\\ \hline 12&var-info-expression name&&\checkmark\\ \hline 13&var-info-path-expression name&&\checkmark\\ \hline 14&var-evaluate-expression [-f fmt-spec] name&&\checkmark\\ \hline 15&var-update [print] {name | *}&&\checkmark\\ \hline 16&var-set-frozen name flag&&\checkmark\\ \hline 17&var-set-update-range name from to&&\checkmark\\ \hline 18&var-set-visualizer name vis&(python)&\checkmark\\ \hline 19&enable-pretty-printing&&\checkmark\\ \hline \caption{MI modify value commands}\label{tab:mi_modify_cmds} \end{xltabular} \subsection{Breakpoint operations} Breakpoint is the basic idea of debugging. Implementation of this features are mean that we can support a many functions, like this: \textbf{'insert'}, \textbf{'delete'}, \textbf{'enable'}, \textbf{'disable'}, setting by conditions and some other. The next table consists commands for supporting this feature. \begin{xltabular}{\textwidth}{|l|X|X|c|} \hline &\lstinline|MI|&\lstinline|GDB alternative|&\begin{frame}{\bfseries\colorbox{yellow}{NOT SUPPORTED}} \end{frame}\\ \hline 1&break-insert [-opts] [loc] -t (temp), -h (hw), -f (pending), -d (disabled), -a (tracepoint), -c expr (condition), -i count (ign.count), -p thread-id&break, tbreak, hbreak, thbreak&\\ \hline 2&break-delete (breakpoint)+&delete&\\ \hline 3&break-condition number expr&condition&\\ \hline 4&break-exception-insert [--mda] throw+user-unhandled&catch throw , catch catch &\\ \hline 5&dprintf-insert [-opts] [loc] [fmt] [args...]&dprintf -t, -f, -d, -c expr, -i count, -p thread-id&\checkmark\\ \hline 6&break-after number count&ignore&\checkmark\\ \hline 7&break-commands number [command1 ... commandN]&commands&\checkmark\\ \hline 8&break-disable (breakpoint)+&disable&\checkmark\\ \hline 9&break-enable (breakpoint)+&enable&\checkmark\\ \hline 10&break-info breakpoint&info break breakpoint&\checkmark\\ \hline 11&break-list&info break&\checkmark\\ \hline 12&break-passcount tracepoint-number passcount&watch, awatch, rwatch&\checkmark\\ \hline 13&break-watch [-a | -r]&watch, awatch, rwatch&\checkmark\\ \hline \caption{MI breakpoint commands}\label{tab:mi_brekpoint_cmds} \end{xltabular} \subsection{Line breakpoint} These features allows setting a breakpoint by source line number through \textbf{'break-insert'} command (see \ref{tab:mi_brekpoint_cmds}). \subsection{Entry breakpoint} These features allows setting entry breakpoint before first line of Main functions. This is options is available from VScode config only: \begin{lstlisting}[style=cplusplus,numbers=none] "version": "0.2.0", "configurations": [ { "stopAtEntry": true }] \end{lstlisting} \subsection{Function breakpoint} These features allows setting breakpoint by function signature name. Function notation are useful as alternative variant for setting breakpoint, for example with using wildcard in name or in cases when source code is not readily available. Please look at the post about using function breakpoint in IDE \url{https://devblogs.microsoft.com/devops/function-breakpoints/}. \subsection{Exception breakpoint} Exception breakpoint feature it is mechanism of C\# debugger which immediately should break of execution (process or thread) before start of rewinding exception stack. Each stopped place should looks like breakpoint for user. Unfortunately, the Microsoft debugger does not provide of specifications for self-protocols (GDB/MI and VSCode). Moreover, for this case the current documents exists requirements given by some preliminary reverse engineering investigations. In addition, we has requirements to keep the same behavior for this feature with Microsoft vsdbg tool after complete implementation in NetcoreDBG. \begin{nobr} \subsubsection{Limitations} \begin{itemize} \item[---] Need for supported only CLR exceptions. MDA does not supported on the Tizen/Linux platforms, \item[---] For multithread managed code has a dead lock problem if several thread produced in one time exception breakpoint events. These problems expect some improvements in evaluation mechanism for keep in stop all managed threads before complete Exception Event, \item[---] VSCode not supported options (structre ExceptionBreakpointStorage) because current version of vsdbg ("C\# plugin of 1.17.1" version for "VSCode IDE 1.31.1") not supported this feature. \end{itemize} \end{nobr} \subsubsection{Requirements} Next details given for "C\# plugin of 1.17.1" version for "VSCode IDE 1.31.1". By default, exception breakpoints disabled. Both protocols should processed by the same engine. It means that the data after parsing and loading should putted in the same processing point. Next section contains the VSCode and MI specification details needed for implementation. The table below to get a big view for the main difference between two protocols implementation in vsdbg. MI implemented as simple breakpoint with insert and delete. VScode has ability for set group or subtree for filtering exceptions but this feature still not implemented in vsdbg 1.17.1. Insert or delete not supported for VSCode. Exception breakpoint can raised by any threads from managed code. \begin{xltabular}{\textwidth}{|l|X|X|X|} \hline &\textbf{VSDBG features}&\lstinline|VSCode|&\lstinline|MI|\\ \hline 1&Insert&&\checkmark\\ \hline 2&Delete&&\checkmark\\ \hline 3&InnerException&\checkmark&\checkmark\\ \hline 4&Group (options)&&\\ \hline 5&Name&\checkmark&\checkmark\\ \hline \caption{Main difference between protocols implementation in vsdbg}\label{tab:vsdbg_diffs} \end{xltabular} Next paragraph contains the details for VSCode. \subsubsection{VSCode format} VSCode format shared for free using only in json format \url{ https://github.com/Microsoft/vscode-debugadapter-node/blob/master/debugProtocol.json} without any details about policy of processing requests, responses and events. Please look at the json subset below. These structures shown the data model for VSCode protocols. \begin{lstlisting}[language=json,title=\lstinline|Code fragment from debugProtocol.json|,firstnumber=1] "ExceptionInfoResponse": { "allOf": [ { "$ref": "#/definitions/Response" }, { "type": "object", "description": "Response to 'exceptionInfo' request.", "properties": { "body": { "type": "object", "properties": { "exceptionId": { "type": "string", "description": "ID of the exception that was thrown." }, "description": { "type": "string", "description": "Descriptive text for the exception provided by the debug adapter." }, "breakMode": { "$ref": "#/definitions/ExceptionBreakMode", "description": "Mode that caused the exception notification to be raised." }, "details": { "$ref": "#/definitions/ExceptionDetails", "description": "Detailed information about the exception." }}, "required": [ "exceptionId", "breakMode" ] }}, "required": [ "body" ] }] }, "ExceptionBreakpointsFilter": { "type": "object", "description": "An ExceptionBreakpointsFilter is shown in the UI as an option for configuring how exceptions are dealt with.", "properties": { "filter": { "type": "string", "description": "The internal ID of the filter. This value is passed to the setExceptionBreakpoints request."}, "label": { "type": "string", "description": "The name of the filter. This will be shown in the UI." }, "default": { "type": "boolean", "description": "Initial value of the filter. If not specified a value 'false' is assumed." } }, "required": [ "filter", "label" ] }, "ExceptionDetails": { "type": "object", "description": "Detailed information about an exception that has occurred.", "properties": { "message": { "type": "string", "description": "Message contained in the exception."}, "typeName": { "type": "string", "description": "Short type name of the exception object."}, "fullTypeName": { "type": "string", "description": "Fully-qualified type name of the exception object."}, "evaluateName": { "type": "string", "description": "Optional expression that can be evaluated in the current scope to obtain the exception object."}, "stackTrace": { "type": "string", "description": "Stack trace at the time the exception was thrown." }, "innerException": { "type": "array", "items": { "$ref": "#/definitions/ExceptionDetails" }, "description": "Details of the exception contained by this exception, if any."}}}, "ExceptionBreakMode": { "type": "string", "description": "This enumeration defines all possible conditions when a thrown exception should result in a break.\nnever: never breaks,\nalways: always breaks,\nunhandled: breaks when excpetion unhandled,\nuserUnhandled: breaks if the exception is not handled by user code.", "enum": [ "never", "always", "unhandled", "userUnhandled" ] } \end{lstlisting} ExceptionInfoRequest, ExceptionInfoResponse structures already supported in NetcoreDBG side. \subsubsection{MI format} MI should have the same semantic behavior for processing exception breakpoint (see table 1). Current chapter provide all necessary information for implementation processing exception breakpoints by MI. This chapter uses the following notation: \begin{enumerate} \item \textbf{'|'} --- separates two alternatives, \item \textbf{'something'} --- indicates that something is optional: it may or may not be given, \item \textbf{'(group)* .'} --- means that group inside the parentheses may repeat zero or more times with space separator, \item \textbf{'(group)+'} --- means that group inside the parentheses may repeat one or more times with space separator, \item \textbf{''} --- means a notable string, but not any fixed keyword. \end{enumerate} \subsubsection{MI exception breakpoint commands} This section documents MI commands for manipulations exception breakpoints. \begin{nobr} \subsubsection{The break-exception-insert command} \textbf{Synopsis:} \begin{lstlisting}[style=cplusplus,numbers=none] -break-exception-insert [--mda] unhandled|user-unhandled|throw|throw+user-unhandled (|*)+ \end{lstlisting} \end{nobr} This command add a virtual breakpoint, which automatically setups by exception event and stop execution before start of unwinding exception stack. First argument \textbf{[--mda]} --- its optional argument for set filter especially for Managed Debugging Assistants (MDA) feature. Current feature it not fully tested. Moreover, not supported for Tizen/Linux platforms. For empty this arguments will be managed CLR exception only. (See \url{https://docs.microsoft.com/ru-ru/dotnet/framework/unmanaged-api/debugging/icordebugmanagedcallback2-mdanotification-method}, \url{https://docs.microsoft.com/ru-ru/dotnet/framework/debug-trace-profile/diagnosing-errors-with-managed-debugging-assistants#enable-and-disable-mdas)}. Second argument sets filter for source of produced Exception. Where values uses as follow: \begin{enumerate} \item \textbf{'unhandled'} --- system unhandled exception. This value always is on. User cannot change 2this value by any ways. Command interfaces provide this value for backward compatibilities with vsdbg debugger. For this case, exception breakpoint generated and we have StopAllThread state in NetcoreDBG before stack unwinding, \item \textbf{'user-unhandled'} --- unhandled exception of user type. This exception can only produce by user class usually inherited from System.Exception class, \item \textbf{'throw'} --- \sloppy{any unhandled exceptions activated by explicit throw() call. For example, if set only \textbf{'throw'} filter than will be catches only \textbf{'System.*'} exceptions. In addition, any \textbf{'user-unhandled'} exceptions will be ignored. If you want to catch unhandled exceptions with user type than use keyword \textbf{'throw+user-unhandled'},} \item \textbf{'throw+user-unhandled'} --- its value are needed for setting both previous filter via single command, \item \textbf{''} --- means a notable string, but not any fixed keyword. \end{enumerate} \sloppy{Third argument sets filter for exception class name. Value \textbf{'*'} means that name of exception are ignored. \textbf{''} --- it is a lists of exception names. Expected full class name. For example \textbf{'System.Exception.UserClass'}. The \textbf{'name\_list'} can not be empty. Second call of \textbf{'-break-exception-insert'} with the same exception name rewrite previous filter for that name. If we want to delete filter please use \textbf{'-break-exception-delete'} command.} All created exception breakpoints processed for each unhandled exception. \begin{nobr} \begin{lstlisting}[style=cplusplus,title=\lstinline|Example|,numbers=none] (gdb) -break-exception-insert throw+user-unhandled A B C ^done,bkpt=[{number="1"},{number="2"},{number="3"}] (gdb) \end{lstlisting} \end{nobr} \subsubsection{The break-exception-delete command} \textbf{Synopsis:} \begin{nobr} \begin{lstlisting}[style=cplusplus,numbers=none] -break-exception-delete ()+ \end{lstlisting} \end{nobr} This command delete of virtual breakpoints by index. Indexes it is a positive integers. Not any differences between deleting by single index or by list. \begin{nobr} \begin{lstlisting}[style=cplusplus,title=\lstinline|Example|,numbers=none] (gdb) -break-exception-delete 3 2 1 ^done (gdb) \end{lstlisting} \end{nobr} Links: \begin{enumerate} \item \url{https://sourceware.org/gdb/onlinedocs/gdb/GDB_002fMI.html#GDB_002fMI} \item \url{https://raw.githubusercontent.com/gregg-miskelly/MIEngine/f5f22f53908644aacffdc3f843fba20b639d07bb/src/MICore/MICommandFactory.cs} \item \url{https://github.com/OmniSharp/omnisharp-vscode/files/626936/vscodelog.txt} \item \url{https://docs.microsoft.com/ru-ru/dotnet/framework/unmanaged-api/debugging/icordebugmanagedcallback2-mdanotification-method} \item \url{https://docs.microsoft.com/ru-ru/dotnet/framework/debug-trace-profile/diagnosing-errors-with-managed-debugging-assistants#enable-and-disable-mdas} \item \url{https://github.com/Microsoft/vscode-debugadapter-node/blob/master/debugProtocol.json} \end{enumerate} \subsection{Conditional breakpoint (depends on C\# expression)} These features allows setting breakpoint by one of several conditionals. \url{https://www.c-sharpco\\ rner.com/UploadFile/b1df45/conditional-breakpoints-in-C-Sharp/} \begin{frame} {\bfseries\colorbox{yellow}{\parbox{12cm}{TODO: \\ Not implemented}}} \end{frame} \subsection{C\# expression} These features allows evaluating expressions and functions. \begin{frame} {\bfseries\colorbox{yellow}{\parbox{12cm}{TODO: \\ Limitations: Need implement function evaluations without \\ side-effect witch producing the managed process are continuing.}}} \end{frame} \subsection{Call stack operations} These features allows showing and moving by call stack of one thread. \begin{xltabular}{\textwidth}{|l|X|l|c|} \hline &\lstinline|MI|&\lstinline|GDB alternative|&\begin{frame}{\bfseries\colorbox{yellow}{NOT SUPPORTED}} \end{frame}\\ \hline 1&stack-list-frames backtrace&where&\\ \hline 2&stack-list-variables&print&\\ \hline 3&stack-select-frame \# frame&&\checkmark\\ \hline 4&enable-frame-filters&(python)&\checkmark\\ \hline 5&stack-info-frame info frame, frame&&\checkmark\\ \hline 6&stack-info-depth [max]&&\checkmark\\ \hline 7&stack-list-arguments print (0, 1, 2)&&\checkmark\\ \hline 8&stack-list-locals print info locals&&\checkmark\\ \hline \caption{MI call stack commands}\label{tab:mi_callstack_cmds} \end{xltabular} \subsection{Capture stdout/stderr of launched application} These features allows capturing any managed application output to 'stdout' and 'stderr' descriptors and redirecting it to debugger output. \begin{frame} {\bfseries\colorbox{yellow}{\parbox{12cm}{TODO: \\ Check processing for Trace.Write(), Debug.Write() messages.}}} \end{frame} \subsection{Operate along with .NET Core profiler} These features allows... \begin{frame} {\bfseries\colorbox{yellow}{\parbox{12cm}{TODO: \\ ...}}} \end{frame} \subsection{Debug core dump file} These features allows reading core dump file generated by CoreCLR for C\# process. Dump of dead processes provide data for inspect stack trace. \textbf{Limitations:} \begin{itemize} \item[---] Not available evaluation, \item[---] Not available object properties, \item[---] Complex object members has limitations during watching. \end{itemize} \begin{frame} {\bfseries\colorbox{yellow}{\parbox{12cm}{TODO: \\ Need list of commands and examples.}}} \end{frame} \subsection{Parameter "Just my code"} These features allows skipping system code and exceptions from debug. \begin{frame}{\bfseries\colorbox{yellow}{\parbox{12cm}{TODO: \\ Need test for checking all sensitive commands.}}}\end{frame} \subsection{Threads info} These features allows get info for threads. \begin{xltabular}{\textwidth}{|l|X|l|c|} \hline &\lstinline|MI|&\lstinline|GDB alternative|&\begin{frame}{\bfseries\colorbox{yellow}{NOT SUPPORTED}} \end{frame}\\ \hline 1&thread-info [tid]&info threads&\\ \hline 2&thread-list-ids&&\checkmark\\ \hline 3&thread-select tid thread&&\checkmark\\ \hline 4&list-thread-groups [args...]&&\checkmark\\ \hline \caption{MI thread commands}\label{tab:mi_thread_cmds} \end{xltabular} \subsection{Tracepoint commands} Table \ref{tab:mi_trace_cmds} shows trace control commands, provided by MI protocol. \begin{xltabular}{\textwidth}{|l|X|l|c|} \hline &\lstinline|MI|&\lstinline|GDB alternative|&\begin{frame}{\bfseries\colorbox{yellow}{NOT SUPPORTED}} \end{frame}\\ \hline 1&trace-find mode [args...] tfind&&\checkmark\\ \hline 2&trace-define-variable name [val] tvariable&&\checkmark\\ \hline 3&trace-frame-collected [args...]&&\checkmark\\ \hline 4&trace-list-variables tvariables&&\checkmark\\ \hline 5&trace-save [-r] [-ctf] fname tsave&&\checkmark\\ \hline 6&trace-start&&\checkmark\\ \hline 7&trace-status tstatus&&\checkmark\\ \hline 8&trace-stop tstop&&\checkmark\\ \hline \caption{MI trace commands}\label{tab:mi_trace_cmds} \end{xltabular} \subsection{Memory operations} Table \ref{tab:mi_memory_cmds} shows memory control commands, provided by MI protocol. \begin{xltabular}{\textwidth}{|l|X|l|c|} \hline &\lstinline|MI|&\lstinline|GDB alternative|&\begin{frame}{\bfseries\colorbox{yellow}{NOT SUPPORTED}} \end{frame}\\ \hline 1&data-disassemble [opts] mode disassemble&&\checkmark\\ \hline 2&data-evaluate-expression expr print, output, call&&\checkmark\\ \hline 3&data-list-changed-registers&&\checkmark\\ \hline 4&data-list-register-names [\#...]&&\checkmark\\ \hline 5&data-list-register-values fmt [\#...] info registers&&\checkmark\\ \hline 6&data-read-memory [-o offs] addr wfmt wsize rows cols [asc] x (gdb)&&\checkmark\\ \hline 7&data-read-memory-bytes [-o offs] addr count x&&\checkmark\\ \hline 8&data-write-memory-bytes addr hexstring [count]&&\checkmark\\ \hline \caption{MI memory commands}\label{tab:mi_memory_cmds} \end{xltabular} \subsection{Misc operations} Table \ref{tab:mi_misc_cmds} shows misc commands, provided by MI protocol. \begin{xltabular}{\textwidth}{|l|X|l|c|} \hline &\lstinline|MI|&\lstinline|GDB alternative|&\begin{frame}{\bfseries\colorbox{yellow}{NOT SUPPORTED}} \end{frame}\\ \hline 1&gdb-show name show&&\checkmark\\ \hline 2&gdb-version&&\checkmark\\ \hline 3&info-os&&\checkmark\\ \hline 4&add-inferior&&\checkmark\\ \hline 5&inferior-tty-set fname&&\checkmark\\ \hline 6&inferior-tty-show&&\checkmark\\ \hline 7&enable-timings [yes | no]&&\checkmark\\ \hline \caption{MI misc commands}\label{tab:mi_misc_cmds} \end{xltabular} \subsection{Modules info} \begin{frame}{\bfseries\colorbox{yellow}{\parbox{12cm}{TODO: \\ Add descriptions...}}}\end{frame} \subsection{Process info} \begin{frame}{\bfseries\colorbox{yellow}{\parbox{12cm}{TODO: \\ Add descriptions...}}}\end{frame} \subsection{Tasks operations} \begin{frame}{\bfseries\colorbox{yellow}{\parbox{12cm}{TODO: \\ Add descriptions...}}}\end{frame} \subsection{CPU register info} \begin{frame}{\bfseries\colorbox{yellow}{\parbox{12cm}{TODO: \\ Add descriptions...}}}\end{frame} \subsection{Modify user-space process memory} \begin{frame}{\bfseries\colorbox{yellow}{\parbox{12cm}{TODO: \\ Add descriptions...}}}\end{frame} \subsection{Show disassembly code} \begin{frame}{\bfseries\colorbox{yellow}{\parbox{12cm}{TODO: \\ Add descriptions...}}}\end{frame} \subsection{Follow to forked/created process} \begin{frame}{\bfseries\colorbox{yellow}{\parbox{12cm}{TODO: \\ Add descriptions...}}}\end{frame} \begin{frame}{\bfseries\colorbox{yellow}{\parbox{12cm}{TODO: \\ Additionally, can be added the next info and details: All possible proposals and improvements: VScode supporting: vsdbg features and details: any other details and descriptions...}}}\end{frame} \printindex[notion] \printindex \end{document} netcoredbg-3.1.0-1031/docs/interop.md000066400000000000000000000041611457701673000171570ustar00rootroot00000000000000# Using NetCoreDbg with interop mode Debug in interop mode or mixed native/managed mode (C#, C, C++). There are two interop mode debugging scenarios: - "native" app calls "managed" DLL (supported debug session type: attach). - "managed" app calls "native" dynamic library (supported debug session type: launch or attach). ## Restrictions **Interop mode is implemented for Linux and Tizen OSes only for amd64, x86, arm64 and arm32 architectures.** Since debugger uses CoreCLR Debug API, debug of CoreCLR itself is not allowed. This means that user can't stop at breakpoint, break, step, handle signal or exception in CoreCLR related dynamic libraries: - libclrjit.so - libcoreclr.so - libcoreclrtraceptprovider.so - libhostpolicy.so - System.Globalization.Native.so - System.Security.Cryptography.Native.OpenSsl.so - System.IO.Compression.Native.so - System.Net.Security.Native.so - System.Native.so - System.Net.Http.Native.so - libSystem.Native.so - libSystem.IO.Compression.Native.so - libSystem.Net.Security.Native.so - libSystem.Security.Cryptography.Native.OpenSsl.so - libSystem.Globalization.Native.so - libclrgc.so All native events will be forwarded to debuggee process runtime for handling. ## Start debug session To start debugger in interop mode and attach to process: ``` $ netcoredbg --interpreter=cli --interop-debugging --attach PID ``` To start debugger and run program with one command: ``` $ netcoredbg --interpreter=cli --interop-debugging -- dotnet hello.dll param1 param2 ``` ## Current interop mode status ### Supported - Source line breakpoints. - Native and mixed (managed and native) code backtraces. - User code breaks with `__builtin_debugtrap()` and `__builtin_trap()`. - User native code threads stop at native/manged events (Note, `libc` and `libstdc++` debug info must be provided). ### Not supported - Function breakpoints. - Function and line breakpoints conditions. - Stepping through code lines (native, native-managed and managed-native). - Stepping through native code instructions. - Signal handling (all signals handled by managed runtime now). - Exception handling. - Exception breakpoints. - Evaluation. netcoredbg-3.1.0-1031/docs/stepping.md000066400000000000000000000163101457701673000173270ustar00rootroot00000000000000# Stepping implementation in NetcoreDBG. ## Async method stepping. Overal info about async/await:
https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/async/
https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/async
Good article about async/await realization in Russian:
https://m.habr.com/ru/post/260217/ Main points about async/await in perspective of debugger work: * At compilation time, async method "converted" to state machine. * All user code moved into `MoveNext` method. * PDB provide asyncMethodSteppingInformationBlob with all information debugger need (yield and resume offsets). * During await execution, thread could be changed. * Since we have code changed into state machine and thread could be changed, debugger can't use ICorDebugStepper directly. * State machine's task builder provide `ObjectIdForDebugger` property's getter, that could be called by debugger on yield and resume offsets in order to get unique "async id". So, main difference that for async method stepping in case method have await block are breakpoints (for yield and resume offsets) and ICorDebugStepper usage instead of ICorDebugStepper only usage. In the same time, since debugger in case of async stepping use breakpoints and could have different thread at resume offset, plus, debuggee process could have parallel execution for same async method, `ObjectIdForDebugger` property's getter must be used in order to track and detect proper thread. ## Yield and resume offsets. **Yield offset** is point at the beginning of await block code, could be used in order to detect await related code start. **Resume offset** is point at the end of await block code, where debugger could use ICorDebugStepper for finish step (step from internal await code to closest user code line IL offset). Example of simple code with async `Main`: ```csharp static async Task Main(string[] args) { Console.WriteLine("Before await."); await Task.Delay(1000); Console.WriteLine("After await."); } ``` `Main` "converted" during compilation into state machine with `MoveNext` method (disassembled by ildasm): ``` .method private hidebysig newslot virtual final instance void MoveNext() cil managed { .override [System.Runtime]System.Runtime.CompilerServices.IAsyncStateMachine::MoveNext // Code size 181 (0xb5) .maxstack 3 .locals init (int32 V_0, valuetype [System.Runtime]System.Runtime.CompilerServices.TaskAwaiter V_1, class test.Program/'
d__0' V_2, class [System.Runtime]System.Exception V_3) IL_0000: ldarg.0 IL_0001: ldfld int32 test.Program/'
d__0'::'<>1__state' IL_0006: stloc.0 .try { IL_0007: ldloc.0 IL_0008: brfalse.s IL_000c IL_000a: br.s IL_000e IL_000c: br.s IL_0057 IL_000e: nop IL_000f: ldstr "Before await." IL_0014: call void [System.Console]System.Console::WriteLine(string) IL_0019: nop IL_001a: ldc.i4 0x3e8 IL_001f: call class [System.Runtime]System.Threading.Tasks.Task [System.Runtime]System.Threading.Tasks.Task::Delay(int32) IL_0024: callvirt instance valuetype [System.Runtime]System.Runtime.CompilerServices.TaskAwaiter [System.Runtime]System.Threading.Tasks.Task::GetAwaiter() IL_0029: stloc.1 IL_002a: ldloca.s V_1 IL_002c: call instance bool [System.Runtime]System.Runtime.CompilerServices.TaskAwaiter::get_IsCompleted() IL_0031: brtrue.s IL_0073 IL_0033: ldarg.0 IL_0034: ldc.i4.0 IL_0035: dup IL_0036: stloc.0 IL_0037: stfld int32 test.Program/'
d__0'::'<>1__state' IL_003c: ldarg.0 IL_003d: ldloc.1 IL_003e: stfld valuetype [System.Runtime]System.Runtime.CompilerServices.TaskAwaiter test.Program/'
d__0'::'<>u__1' IL_0043: ldarg.0 IL_0044: stloc.2 IL_0045: ldarg.0 IL_0046: ldflda valuetype [System.Runtime]System.Runtime.CompilerServices.AsyncTaskMethodBuilder test.Program/'
d__0'::'<>t__builder' IL_004b: ldloca.s V_1 IL_004d: ldloca.s V_2 IL_004f: call instance void [System.Runtime]System.Runtime.CompilerServices.AsyncTaskMethodBuilder::AwaitUnsafeOnCompletedd__0'>(!!0&, !!1&) IL_0054: nop IL_0055: leave.s IL_00b4 IL_0057: ldarg.0 IL_0058: ldfld valuetype [System.Runtime]System.Runtime.CompilerServices.TaskAwaiter test.Program/'
d__0'::'<>u__1' IL_005d: stloc.1 IL_005e: ldarg.0 IL_005f: ldflda valuetype [System.Runtime]System.Runtime.CompilerServices.TaskAwaiter test.Program/'
d__0'::'<>u__1' IL_0064: initobj [System.Runtime]System.Runtime.CompilerServices.TaskAwaiter IL_006a: ldarg.0 IL_006b: ldc.i4.m1 IL_006c: dup IL_006d: stloc.0 IL_006e: stfld int32 test.Program/'
d__0'::'<>1__state' IL_0073: ldloca.s V_1 IL_0075: call instance void [System.Runtime]System.Runtime.CompilerServices.TaskAwaiter::GetResult() IL_007a: nop IL_007b: ldstr "After await." IL_0080: call void [System.Console]System.Console::WriteLine(string) IL_0085: nop IL_0086: leave.s IL_00a0 } // end .try catch [System.Runtime]System.Exception { IL_0088: stloc.3 IL_0089: ldarg.0 IL_008a: ldc.i4.s -2 IL_008c: stfld int32 test.Program/'
d__0'::'<>1__state' IL_0091: ldarg.0 IL_0092: ldflda valuetype [System.Runtime]System.Runtime.CompilerServices.AsyncTaskMethodBuilder test.Program/'
d__0'::'<>t__builder' IL_0097: ldloc.3 IL_0098: call instance void [System.Runtime]System.Runtime.CompilerServices.AsyncTaskMethodBuilder::SetException(class [System.Runtime]System.Exception) IL_009d: nop IL_009e: leave.s IL_00b4 } // end handler IL_00a0: ldarg.0 IL_00a1: ldc.i4.s -2 IL_00a3: stfld int32 test.Program/'
d__0'::'<>1__state' IL_00a8: ldarg.0 IL_00a9: ldflda valuetype [System.Runtime]System.Runtime.CompilerServices.AsyncTaskMethodBuilder test.Program/'
d__0'::'<>t__builder' IL_00ae: call instance void [System.Runtime]System.Runtime.CompilerServices.AsyncTaskMethodBuilder::SetResult() IL_00b3: nop IL_00b4: ret } // end of method '
d__0'::MoveNext ``` In this case, PDB provide `yield` offset 60 (hex 3C, see `IL_003c` in IL code above) and `resume` offset 87 (hex 57, see `IL_0057` in IL code above). ## Stepping logic, protocol related part block-scheme. ![Stepping protocol scheme](./files/stepping_protocol_scheme.png) ## Stepping logic, runtime callbacks related part block-scheme. ![Stepping callbacks scheme](./files/stepping_callbacks_scheme.png) ## Sequence diagram for step over await line in async method. ![Stepping callbacks scheme](./files/stepping_sequence_diagram.png) netcoredbg-3.1.0-1031/fetchdeps.cmake000066400000000000000000000064471457701673000172050ustar00rootroot00000000000000# Fetch CoreCLR sources if necessary if ("${CORECLR_DIR}" STREQUAL "") set(CORECLR_DIR ${CMAKE_CURRENT_SOURCE_DIR}/.coreclr) find_package(Git REQUIRED) if (EXISTS "${CORECLR_DIR}/.git/config") execute_process( COMMAND ${GIT_EXECUTABLE} config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*" WORKING_DIRECTORY ${CORECLR_DIR}) execute_process( COMMAND ${GIT_EXECUTABLE} fetch --progress --depth 1 origin "${CORECLR_BRANCH}" WORKING_DIRECTORY ${CORECLR_DIR} RESULT_VARIABLE retcode) if (NOT "${retcode}" STREQUAL "0") message(FATAL_ERROR "Fatal error when fetching ${CORECLR_BRANCH} branch") endif() execute_process( COMMAND ${GIT_EXECUTABLE} checkout "${CORECLR_BRANCH}" WORKING_DIRECTORY ${CORECLR_DIR} RESULT_VARIABLE retcode) if (NOT "${retcode}" STREQUAL "0") message(FATAL_ERROR "Fatal error when cheking out ${CORECLR_BRANCH} branch") endif() else() if (IS_DIRECTORY "${CORECLR_DIR}") file(REMOVE_RECURSE "${CORECLR_DIR}") endif() execute_process( COMMAND ${GIT_EXECUTABLE} clone --progress --depth 1 https://github.com/dotnet/runtime "${CORECLR_DIR}" -b "${CORECLR_BRANCH}" WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} RESULT_VARIABLE retcode) if (NOT "${retcode}" STREQUAL "0") message(FATAL_ERROR "Fatal error when cloning coreclr sources") endif() endif() set(CORECLR_DIR ${CMAKE_CURRENT_SOURCE_DIR}/.coreclr/src/coreclr) endif() # Fetch .NET SDK binaries if necessary if ("${DOTNET_DIR}" STREQUAL "" AND ${BUILD_MANAGED}) set(DOTNET_DIR ${CMAKE_CURRENT_SOURCE_DIR}/.dotnet) if (WIN32) execute_process( COMMAND powershell -Command "[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12 ; (new-object System.Net.WebClient).DownloadFile('https://dot.net/v1/dotnet-install.ps1', '${CMAKE_CURRENT_BINARY_DIR}/dotnet-install.ps1')" WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} RESULT_VARIABLE retcode) if (NOT "${retcode}" STREQUAL "0") message(FATAL_ERROR "Fatal error when downloading dotnet install script") endif() if (CLR_CMAKE_PLATFORM_ARCH_I386) set(NETSDKARCH "x86") else() set(NETSDKARCH "x64") endif() execute_process( COMMAND powershell -File "${CMAKE_CURRENT_BINARY_DIR}/dotnet-install.ps1" -Channel "${DOTNET_CHANNEL}" -InstallDir "${DOTNET_DIR}" -Architecture ${NETSDKARCH} -Verbose WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} RESULT_VARIABLE retcode) if (NOT "${retcode}" STREQUAL "0") message(FATAL_ERROR "Fatal error when installing dotnet") endif() else() execute_process( COMMAND bash -c "curl -sSL \"https://dot.net/v1/dotnet-install.sh\" | bash /dev/stdin --channel \"${DOTNET_CHANNEL}\" --install-dir \"${DOTNET_DIR}\" --verbose" WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} RESULT_VARIABLE retcode) if (NOT "${retcode}" STREQUAL "0") message(FATAL_ERROR "Fatal error when installing dotnet") endif() endif() endif() netcoredbg-3.1.0-1031/packaging/000077500000000000000000000000001457701673000161475ustar00rootroot00000000000000netcoredbg-3.1.0-1031/packaging/microsoft.codeanalysis.csharp.scripting.2.3.1.nupkg000066400000000000000000000660631457701673000276320ustar00rootroot00000000000000PKuJ\" _rels/.relsj0E>-;~8dE7I~@lXiI(v9̜ýj>}rJЀڌ==EhfQt&I =btOp!M(gG[MVBpq:k6X3U%ea0Za1~#[+و%m.ۃ.&EfN!P"{J(J׈*fB(X pSwUx7Pu|9(,XZUc0Kp׎U %vbw]PKuJ{D.Microsoft.CodeAnalysis.CSharp.Scripting.nuspecTKn0Z-vAHAdStAS#H$gGJKHnӛ.whj%(T\BmQ㊳Y޾5Olӕ]DsGB,/Q2Kp1גtGɄD5Fly0*ѱ9Zyvsĸ9+Vd܈yLJ|n q<Jz3DYJm 2¿' ~o,sccLUx0URϕPOd|1tBɠ2`FCXp^Q2H E9N6/}),S|f6FKp%Ս W6EB:‘>K&|y$S,M4Y1&sJ<5H=ķWpe-*4pW1Wh#]nNLIw\vhàf?/P=mmֵB(:(lê f;f9S~`;z(;A '׫rlkb n)iI[O {"z娎=[J=a^dt`PKuJc7 t>lib/netstandard1.3/Microsoft.CodeAnalysis.CSharp.Scripting.dll| \SGܛ%@XT xHpeUT5!$hUVZ.պ[kUkֵmֺ[֪Uߙ7.}h=̜9s̽7d!!|>Eh;>П*+oCȎ7Nu?8T8Cd.U:JmJM3OYl7>M:r2N `=^BJ_A(P"Hp+;_&aU꽐fzIjrh.C.@O|}.5x;.|29bX0!޶ UYN?Z&Vl3+^f6fkRD To Mi?8_PSc7fqlW!^\(yaLAXXWH۽'G-NZZ^88y#:ߋb}0ܗ)퇽*GpM'6w/ MP T)RRi=SgQk>%:ZAV)  #0;؅\8N&p1 !-@~O?Yb4D[BnH2x??>/Gه'7VwFc ZuMpC:TkJ9"d>dǭaX7w>o="N6&ϥ>#G= +Ľ$b%T֯燡 p1zSuLF9d]?If/ǽ CKm_O2V˞‘عKoAYLa $DB 4PgdsA .O,#mCDy* ak* co k-Q`L}QG%T;xلkna4DB"~TEBM&}P8GB5S6h>Os d7CU^=CȤC B 륮PHSP(K&y)( RrQ&zKeWR-R-D=;^J-ET[QotKϼT7QtK DכVl0i{^P`S_ZO(OO$@4]kƍ;ez(!Q.}*PpLuPN\UҟhJ]8B 9 0PԂ@!.SRZ {Bܣx8 q:Dri?Wmx #u`5@=)f؋@U(R@= K-(AVI,= H x6:j!)z-'跨}x HK-"= YԘE}fKE7xD~ڝsAH@Y~qiZʢ:\?UhQtZO'Dݠ*zuxj }2*o4-,{ 51@J?~r8[t8a *ZI$,!L Vt=qz9=C`?M,'EDCI] 4i g%*(?A6 0 0@zB`"7 4h!p$8IN!p3JF?=@TDa\Fa<$xc x<&x/ ۟@GGh(N#[6Dl.lB` p?_1A>ۃQ[4` :lA#(5 "%@)U^&0lL%Heb%nD:Z4J1%R2ru@3 T'}`6p8)WN |J%?r0r?"pFDCa` 'c B2 {`J6a`D/ 'F Q2 bЗ T %0;Q Nz.xDǫ7]6@VwڿvL9g͟1/!//N^lYm"iark/ kz3.P vYw"_R`T(+VZ:x*䰔\ ^&-..uaPB5bcU[`-es 03B5jm7Z(bz|fZYb9;6a1\p[ 62Jq@\jά@\YjuyP-N'H̨]2LlCL#,L kIb%lC1iw\u8,tf7,683plzJJ]nX{ųYlp `1'n/,2a`Ycp8ټrǴ i2@6聍l]Cvu.b Le:<:K d(QY@Iqgk{;^2-Y0Hf>o2밸X&\+aM˺J6/j7N]F.b\E8xqNs`0[\vG>ʉJ&gJޞ\VG jv:k,-,m.!^sW H8QeWZe/f8rk9>O,[1l0E@cqZ|{s?sn!^Rl>e1ZW )/oI5z' `G3l00>v3 >A7=KXGFl^:w Ӭv3zI(˝g|Z^Qe?S+**]3ĩד9WC,+tsy\a8撂&bH?q`@e lpjV+=!zs{Vq9Z5mIYb-ì.*F8h?$\"lG!Yf6%.,Ϫ7sw Ą.#0=ut̬ը}$|ox:09{s!BU?SK-VByӋA(AE~{o/5fjpGl?5:W-!>Ys"-d7o3F2g!,e.{wU!rk9T6Y_1xaaթ;yպ$3E:|\K-%_M]RO߫乌Vw#vTo2vk0w=hMr6_6_gś`\j/*/ce;&3a qY-UV@W&G'*uJ.ºo/!U* B'=tWI'2Vu[YktNfV^l[u3FX^KS|MsɚŪK`i WY >3$<˪"yuH9`]0Z!83=97o-+q|;}nRj~ƭ{yZdfrṟ[0b|:v-K5%/Jr?XƯY6 +בgb9 i P8A`ұ܁6‡Ȫ,!ɻ}R[s!Gg\9;f.GLȎ̈7A*ȂL,p1*@.oq )Ȇ ȊAf/"A**4jsVN)MG@va2 %Qpw/owRTuIp-+݅|;w |CoǯVNZĮlE&FA zvЃz%b/Y} 9/E5j"R5 'G|!86E[J IHISr3*HQ (TUhzE{r$:Ӣi!z1CT" FAPQÎ("!"D * P_))F*JC)8A,B**˗ wPRkCqXb>˱JbNQDH5]$y8Kـ rryGɃ*VAnCiӴuAE wEK,ȝ]I# )n]?5&ABnV'Y$xFl.8P)by(9-@l!!@ ˠ}Qq5*FըF}QjԏC #J.Cir)xTq#BQ5ttSǡ$KU{t}J졭X9V 4#|K.[5=Qӿ;)}_9ygQ//֎T}?qX¸UݸM xOku׿&y1!77o}sdRhJV>#>f@31A08X|H (jsp0"xCɄLQPf#/3 58-{1 7A0. ?[1bDQx!qFUӊ8E)*B⃴#(r9DT) h@hJN<؃H<ԃ<(W\!l=1'2NKXX)&sRXԋbI70<@A,@)VJG`̧: %=n?.>II)D 550o@/Sky~"Γr49-9Fԍ-o0t(Idɵj&AQaMVq_g$FTKRIII2ѐ5ՌʜhVhJЫ*VӛL*M*AeF`RA;15I˲`*1Im'td:k43f$ Z. -`C Z5' -`umIbuFc%U 5 D&@d$%$iVOҚXJ/Hf4!Ѩ6*uBl$jIl#n;{Np&lKP[b4 #ۼGO d<7lYy$D Q֩@oЩ5,cJbfpZ$j@ŔdHJPTzcBAJOJұ,c(H cYcLdzN3t؝00PϨKdLD^i`FdNTD`@eJRkjDhLR ZVM(6t jq V]"W5@0*ÚD}FSXMt$ n+xqQ,5XS N`;O L?Lg0{ ?{7@8BW%v,~:exeժ$R8p`e9@ 5Dd-B#Ⱥ 8ŽSiεťOZ=Fs>hTi Ua x km(pJe"ZkAhQY=ZW5#$~"Y٦c Rg7Z'hlf%;"-o.(]vJbA#uz};2THnڡJE{SUe^\}W :ӢfJAο*Lv%WQv^4[,~rjGZa jK&ĭɧdb ~Eݥ;qJg ,6V=]Uz!*毰z^k%G.*?Cl1v\dl_HSzR8^j5+c"qxZXtLln %w T5Qָ3l,3{SƦ[೻>z@pIl늛^/ۊ+e sh]%WA$"e.`Y=u)Kx y}xbcyܟ";Z+/;rlx))O6l g}g^Wjה@td$1fE^7)m8nzdˏ_NQmrXUmMk2%5_?جD8C:js-%ԓ/B U&c-wLc} TNX:p%P/:"g_ I!+k$>"Qp.qLiӻ:ߋu_f] nڰ0o%g/:a[ n|7'p_T3g2bGr5Gt}_G =7$qkmﵯoMMyoiKD5`јs0F4. 4_F6g¼6RE"@Db0L2KR6mX)wG.p}ƃ^}KlߧNsݪ3v|eeԃlzOXz}u^o6Uf>"TM9 ݶ-gGԛ%{gs*x"()0Bɯ<[ ERH j&3޹/bpy&Ý7d,:~ΌNV4ABBY(1NweߩŸ`B\=qO:'^L{OS4ݦre1M6i9ym_N4VF8sY>GN^.raI9^Y+nbI|lɆ&|wx7 h~^ҫETﰾswj\ ^9 {˄'7S \܁Z[&j}#IbɅGל5seF,{v\lMSZ{-}Y5tVmo}lp7VO~m`"Ӷw,Sć2'g>H9'[O-[T[+9iəhnc;]&7(QI?eWͯG^t8}呙#:=}3qq>O2eX9C9EropYECݣ:,W?<'R7wQT&Op;wv-j}"i@N,tp/z}rjΫF)~Ӄ62 aop` lw5ܷpY&P<%ՔJԔ2m UB~?}7턟$Ԑi8nx*qB[,ҿA ]Y8cYO Ϥ0a%Wf<:\^ˋ<=2fN,IL;piOFduouK\}9M:Á%)eXVum+czn~k<@|*m\v`g)[<ʦo8Y 3} kA1c~Ue+%+k574Ah|:%?Ͷ'Jlvjy'O?w9SؖέkkvreNnΓ76ߌ' ~Iro,D- b*3#P`-TϜoESJ pĭZo L:ЙwZxHbJ3:۳_3ASU3~NBf{_}vWq7/r҂KV,olv]Ya̻~׷G:viv0"Utţ^9vwbjٱNR}9A.hڧVjL88᧤q:F\.޽6nu[G\;t● {7&it?V͛޿mK^Wwmml׾;'xp ΌAב%cxN7oѫ?Ao=g䕻oNܾbQNuo,`Lo#׋L aXt_8pSM}HRM9Q]w._$+g'g;.o10>jٔNn3z$iMjstC_umC"0rC&~X49i)wcqqDO-}Z^yr^ּO֐ח7nТaWG=:T01'6?~6{nі+'>}-.~ia:*R7m~EO ~b1!c{ wYj[l͐~nρ3?oQ׃&[oi]Wb o~}i~-JԋqC= UCHI; nf.<_:}qgW֭=Yտkufc|֥umwۈ#Έ6<8wڴɯZݶh'=";q{o^^O?(}մufԽ9sZM7ۗ=IcoȮ0~W;o[aAxĮwT.:}Y7ĭۼY=啂2BWh}E:7ixԣ(Μ[=m{޳ҽqej )Uk%WwB4ڇG|I4FYh e>]܃K+<;3Rs7Lޡ-VVzU!jwjBy还ק_ۮw+j~ɁG揶yIzT$wz@9ۜ'v%jmYMA7\vj':<502 z?Ztۀ'wnR|g#3bqOl&ΈGze`ӂ1*ŚF[vg˽FZӨOw {Z#UzІfgFhU%}f2fg7 y#R35?s?ͮ??^??6k/"jKAGC3+5*TI}qo5w]r΂V~Ӑۻ_]0mM[sʹ/>}+&QOF3cgu;^l_vTqpWwwYY 6F.:pW;,~k1#7w<4>}g^Wخh;g_.YCᓁR:+͙k@Wは7}/ygưv*FmX*m$w,o`D;̍G2CX/>z;CktyM'_PKuJ_4&>lib/netstandard1.3/Microsoft.CodeAnalysis.CSharp.Scripting.xmlZQO#7~0J%J$nsrAQzHp!L a!b{v8>M%LXՇnqPs1Rn#ə6OɒsnD[avaU1NG_/иثyb  M)3pF;mf0A-SC0R l0iCV}i4'ϊ&y˗u&Ф%)u;YO/m>R $-X!fM@5 3,-is1A:7ClV|͌p2(,K=`zAЃ?rò̔.tQ pi+c `Wky}ʥ<,'taA07_z) K߮ssXq"3hi}:sU/΄C X7Eb#x%g^YA0{[/±!s FF+m{cKR` #Gӹpxg~չuXP[;m3bs~6'6IsAK:SRdT˪qlfxB (ɴ ǛRBhtv`ʮ_݊o PKuJ<[Content_Types].xmlAN0EH%N@%A/`9<ܾӔu9zv9Bᘱ0>Ewዀ;;Ыs&=י ^,#>n4.d@au͘$1'EWyּ]_g=Qrw\3xwPKuJ$$Qpackage/services/metadata/core-properties/48d929fb727c4925bfe12a5f1698f6e3.psmdcpmQo0';xn KZBV4%zGbld|94Eٴ}ws~whjM)Q&F*]F]C.kZ^Pݍh}{yٚRp!Ỵ1דm Șypjɐ7Lbk;jZiQ :Wn;PuT6ݠТNJ3ސGu;Z[\a J k|/v߳$9aUrp=:(;U{i @'Xhﺒ pi&CU(ϳOb'bZte!<4Ϊ&i2x1])nBU.|#cږJv(RLY✿/؞?tTU5Yxk\=:% @*_)lߞΚo#6p9_x,> w:oNǍٓ^&qY%l2dOÌ3/(nDa5YvmK + rڞ`Ў5xU m I|13l"2Z9:r1u}"?F(yȱW~VŨ?_wOc0a0U0U00UE뢯˂1-Q!m0U#0E뢯˂1-Q!m0  *H rszdrf2BubV( `\LX=IEX5iGVyg <&, =(_"◄egI] *&x}?+&5m_I[=%̶odh-BbPglk 67|[mzF`'KΗg*h߀ 3f nc%mlaң&qÙQ+.P E/000 _ջfuSCoP0  *H  0e1 0 UUS10U  DigiCert Inc10U www.digicert.com1$0"UDigiCert Assured ID Root CA0 131022120000Z 281022120000Z0r1 0 UUS10U  DigiCert Inc10U www.digicert.com110/U(DigiCert SHA2 Assured ID Code Signing CA0"0  *H 0 ӳgw 1IE:D娝2qv.C7׶𜆥%y(:~g)'{##w#fT3Pt(&$iRgE-, J M`IJp1f3q>p|˒;1 WJt+l~t96 Nj gN %#d>RŎ,QsbsA8js ds<3%00U00U0U% 0 +0y+m0k0$+0http://ocsp.digicert.com0C+07http://cacerts.digicert.com/DigiCertAssuredIDRootCA.crt0Uz0x0:864http://crl4.digicert.com/DigiCertAssuredIDRootCA.crl0:864http://crl3.digicert.com/DigiCertAssuredIDRootCA.crl0OU H0F08 `Hl0*0(+https://www.digicert.com/CPS0 `Hl0UZĹ{* q`-euX0U#0E뢯˂1-Q!m0  *H  > Z$",|%)v]-:0a~ `=į* U7ђuQnZ^$N?qcK_Dy6FN\Q$$'*)(:q(<.%Gzhh\ \q h@@Dd %B26$/r~IEYtdkfCڳ  Ι1c=OƓIbnS.hlD2fdQ0P08fWpuqP7b;0  *H  0r1 0 UUS10U  DigiCert Inc10U www.digicert.com110/U(DigiCert SHA2 Assured ID Code Signing CA0 180410000000Z 210414120000Z01 0 UUS10U Washington10URedmond1*0(U !NuGet.org Repository by Microsoft1*0(U!NuGet.org Repository by Microsoft0"0  *H 0 xmfAVԚdڙGyMJX,YOXCZSe(xk*kRDzZXz%|ؽ~%`Ā4_00U#0ZĹ{* q`-euX0UݢI*k\`<أ0U0U% 0 +0wUp0n0531/http://crl3.digicert.com/sha2-assured-cs-g1.crl0531/http://crl4.digicert.com/sha2-assured-cs-g1.crl0LU E0C07 `Hl0*0(+https://www.digicert.com/CPS0g 0+x0v0$+0http://ocsp.digicert.com0N+0Bhttp://cacerts.digicert.com/DigiCertSHA2AssuredIDCodeSigningCA.crt0 U00  *H  h5Ix{3G:鮑CL!eT ogM3J(UmŮMW[!)^ʆMYlRP{xCQ(,(E NNqp`*k2GNX':8LBүp^p7HE $0wq6LSZLѡhSǫmQ iCU'^S8H˗y"M7<v>s\|z7m-8b,D.60MȌ1)0%ݢI*k\`<أ0  `He0 *H  1  *H 0 *H  1 181008122209Z0 *H  10  *H  0) +7T10 Microsoft RoslynTeam0/ *H  1" 2SʤeQr35~1gfQXY 05 +7T1%#https://api.nuget.org/v3/index.json0 *H  /10000  `He _8}IOOݘFv !}00vt0r1 0 UUS10U  DigiCert Inc10U www.digicert.com110/U(DigiCert SHA2 Assured ID Code Signing CAfWpuqP7b;0  *H F. Q %H֫@Nt1\.r{K\f Un<fAr 0F-]X>!ֲH^LMR@9 Jy_YH{0S_01 0 UUS10U Symantec Corporation10U Symantec Trust Network110/U(Symantec SHA256 TimeStamping Signer - G3H00@d!!0  *H  01 0 UUS10U VeriSign, Inc.10U VeriSign Trust Network1:08U 1(c) 2008 VeriSign, Inc. - For authorized use only1806U/VeriSign Universal Root Certification Authority0 080402000000Z 371201235959Z01 0 UUS10U VeriSign, Inc.10U VeriSign Trust Network1:08U 1(c) 2008 VeriSign, Inc. - For authorized use only1806U/VeriSign Universal Root Certification Authority0"0  *H 0 a7^4bXZ##`אzX8dqM-siq9M 3I;Kሙ3ǀۑWrwͨ 7jK _y5x2#2AY>+m:ɜHS6xš7w0s0U0U00fU _0]0[ `HE0L0#+https://d.symcb.com/cps0%+0https://d.symcb.com/rpa0.+"0 0+0http://s.symcd.com06U/0-0+)'%http://s.symcb.com/universal-root.crl0U% 0 +0(U!0010UTimeStamp-2048-30UcʣNrৼA)8ub0U#0wiHGS2vї0  *H  u-4\2EOxoOȁ@)]Vdq0*af V]q G̐/ lN3ִLcH9@!n< ɏSWA/MNxlBna\RNkJzS uu.fW:Ί۞8R` M'm2?@Ῑ9+ZXU}ǚ#*a0K03{寺?#"AM0  *H  0w1 0 UUS10U Symantec Corporation10U Symantec Trust Network1(0&USymantec SHA256 TimeStamping CA0 171223000000Z 290322235959Z01 0 UUS10U Symantec Corporation10U Symantec Trust Network110/U(Symantec SHA256 TimeStamping Signer - G30"0  *H 0 ܿi{TqG e$ m0?'J3Nm@" <$(rQ= &:C#uGp _[rHWeM<@28?,Y#ˀMɪ lUaW,ĵl#ҟ lbiNR1[tRWl"Uo?J"ve6򖕁&,8ӯ%@ S)WX^HA!޴&{@SXyR1ME<:"Ŵoﰊ00 U00fU _0]0[ `HE0L0#+https://d.symcb.com/cps0%+0https://d.symcb.com/rpa0@U9070531/http://ts-crl.ws.symantec.com/sha256-tss-ca.crl0U% 0 +0U0w+k0i0*+0http://ts-ocsp.ws.symantec.com0;+0/http://ts-aia.ws.symantec.com/sha256-tss-ca.cer0(U!0010UTimeStamp-2048-60Un_;1y6{0U#0cʣNrৼA)8ub0  *H  F_HϨ'K!Ͳrpc/U){9FN~eXW 6$ {;bJۊTm(gq?3 ٢YJekR)uJ+˛MYA÷?Dz"tG %t`n`Vz DXHwr$,?Kg_\T>3[ŷNqfE?v1Z0V00w1 0 UUS10U Symantec Corporation10U Symantec Trust Network1(0&USymantec SHA256 TimeStamping CA{寺?#"AM0  `He0 *H  1  *H  0 *H  1 181008122210Z0/ *H  1" Y4g0LjR(:'c}&9ź07 *H  /1(0&0$0" tv}9N |ƀvuPKuJ\" _rels/.relsPKuJ{D.KMicrosoft.CodeAnalysis.CSharp.Scripting.nuspecPKuJc7 t>lib/netstandard1.3/Microsoft.CodeAnalysis.CSharp.Scripting.dllPKuJ_4&>;lib/netstandard1.3/Microsoft.CodeAnalysis.CSharp.Scripting.xmlPKuJ<@[Content_Types].xmlPKuJ$$QApackage/services/metadata/core-properties/48d929fb727c4925bfe12a5f1698f6e3.psmdcpPK*HMF%%D.signature.p7sPKiinetcoredbg-3.1.0-1031/packaging/microsoft.codeanalysis.csharp.scripting.2.8.0.nupkg000066400000000000000000000716631457701673000276400ustar00rootroot00000000000000PK L& _rels/.relsj0E>b;]섒U$4EiI(v9̜ýL0Gr]ImZt~|wxo}$qsJ(f4 r@c'n4[ "T*3WaNKx X0&J&LeoI|pD~ڧ()zʁV r(:J_#83@B&\Ic)EG g-w#Tם[@+;Q#V*|4RkF5,閪.kǞ}w PK L+e,.Microsoft.CodeAnalysis.CSharp.Scripting.nuspecj0S{(^$؄P'diVcI$7CPZ 3gr|GcVh"@4jWFARSLW>]ET:W IJ%h 3-I d2OhNTckdrmϸ/6V*+Q;L Utƣtfƕ=8!+d&OKPY` kGԙf8WmTik_IUTB=|r6M2 \Dz[pe0\;xpQ $r_Ҳ+.EUBZA%jk>XQR/BވAaW"XC[&##8?#NNxY^ŞiO ǧ9H2#(d)uIZmM U3?⎮l ٷy'aZ]R+Sc}0cTن%뵣|D[!6$,grt y 5XCz7 "zc3[Jy_" mj; Nm7PKL=Iz85q>lib/netstandard1.3/Microsoft.CodeAnalysis.CSharp.Scripting.dll|XS7;@HI72eqhH0CEV몳QQQgVmmj[gVs2@_<:y{޳${tAqB&[%hpTFj)jdzlt0ˌfYZ|Y6rʢ8-̇bBdJ 8+USЮ Xz/nL?MZ/\J1~d^GtZΎõ_]._0Q$ڬz |D|!Dʚ,zgbg./Hi+I w['R$GKs8|N?b bR?44FZ4$`dËk%f1A r%\K0PX[a 7͎`G,D$˄DŽ. %_sⴴ#ܘp b"Џ-0X̱4f@%ԇ36.`K ,2v dXRQ!*On\) H@H84jsO4  @  §!< CCÃB-I /48o196D1q CeϞ=lA%n"v_qQV?QpQ`J\ -JDuX|% Zӡ4Xت^qJ$cqSx`q fɏ=6Ӗ9͌DzD:.SopbB> v&H%D ;NL0fLs&XεMe -pl%}V:+m,iK7vж%yK&tw \L  Ïʃr W* PW!^L::::::u8}0^1q04-QjK A!d gr_}9aq\R4/aB^dC EF^Hlz#AHo؂;؍<_"p# Htb c=O<71HQL!h~kc^߽ g:Z'Q)4C& 5)~|h.aA0ӭQ0ʵVGu흉ch4<ɢsExW$=T(̳k$va!H)@#XZH\3w_rZ]ᣅܣ|t˜@DU)X.?!+x'Fq@?9E9| .ĠS~bg<)(hgPG/ G >;"U+G~hx@p4HJ5AB 1&Z+hr~Fs>9+GgD}h<9mq?ck+p]}Dbxp :+怾?~ -s^"p)"pPf8*^ѷ4n[q[L;mQ;OM}EhusNP4^1"\v/犱ۻ$hD'>`a~_zGLv#Tvn<jU>.ƹ)hWjp5uD3j"D ܚJM-2t8&.jt嵰qvSo$j"> 65wvud1.J.-ϿMD^Gnrۡ^wng4KqyheT(/RMxY踗B~Rmy0C!{| K^Bkz)kT4^Y us!-VrM#]"Ӣ[OBՑB?R42pEf?ſXCs} )"-t^<|50.%kaHĎƞL$.ݞ`'` p>~ ZU" coR!0Ls Qk}CP EJ]Ԉ񚡃$Ag8 ٨?)53/R!2ZLѫh ?O ޣC/LCV$jJoNbhcx"? I0`x;PkCLE@ǃh(XQLx4ED ~@°))`XŰv`!N_9xgXv"19&8`V h F!03 vj}@?r y ?HC|`LC ✤ "AB?pТa9Hh[lyKC6FAm #:.|pJFxt'H u FcB5Zzv,NEYQk"8fv%,:k&#G1raeQpNJ7ke  4k(RV!z[b[:?54V()[̽m>!^  VhH8bZf{fհRl6o֊V]a:Zf" 1ڌHF {4# f[Cj,)'*+ך+j |Qg4xxyg.OB`{H< 3q0A(a Du7^&9FQo,v9Iphjr,'z!y7aЫnrMmrHhȢ7iMD uxʂb5)x(ULx3^@qɢ,v8pn &r1{T3M6؈/M]{例J,0KP$4i![kFx7R25#}n;1P\ЖxΒzƢ{.z#ӆcdbcZZkaޕAVtWABWDoڳXKȲ6}-'\WkhgU {Lj‹ށP'ztcM.)4#ӣXkEk`O= |$ Vgf̱Z1b.X ijh"'ly1H%0du` ,})kq(1fqVj$_ kwlj <Sd}4@NcmCr"B4^nuVTvgZ=SVN"c53wUxvmݵ'v򱕺;HN=?2VFS,ttOl9k5/+3eb7<,-ɥJ|:Cy.k!/kwq#rהkBٞې:,v2Q`)'SC>%6[2"/6AΦEo6VQl-ZOGY3^:lug՜5$0 .cd3@VO yV+DzĶX ˈArCy6pB 2#-2 %x0WOJ uy`I&HB<9n5AI%"6XDH`k1\u;B߁-f@߂_ԈCZi13/u ,vF/ۄ^>Xn9sZVD@^K~4xB2鹫xtriĕQ#C@LJx2HQ9'Cʇ>#e%V> x!RRVjb %tK9b1Jk.m"MBTj v(̈Dv$~EqEK+ՂU$0;B :B+(V,B+*;|3_qk;C,f1PC%X@F $KQ Cj A84KN:[$Dꌣ$N T-@FH!4hhZL[`HL:3A-[(@gnHIZR ?j,t'@T(]W tl.RB7LC;v? S&Np?p3Ψ|o;~*on

Ҁ=U+L~˃&l]p$.Y5󀚀LSW͡)R2|h.a@4uu;KKc>ѽAL &AZ[)"` H,f"i9o)bX jR[n`erIM)0?EQ(L8Z$cGs9 gfTQה(bcFV9]_vd؉15tކÏi+n;{;+W>}733?$EL\w'ϼopV/yy١6'<~lhKݕL'u2̤s >m(Ke3l JWEBD3M L7;)pO0XA ｧjZy[s"{OqLr% ?wO7WN" $/Obձe5 Z5C.[{n*Vhd3=3NL/&yŗ5bn|bp6||lD5Ic 𴌢x w =#FWkSvDQϸ4lyflfN8yл_;+69&7.mEe,{"mZѨWOA;7pN7 DܛЗn͹;Ro\N-hi+onXɡ=8wޖ/ +֬;.|r1SFR=8+E~oqt9g>5fɇYWQ6_=J;|֞C=ӣBٮξ-v56MfKc0spbo^9/NlC0U+u`r qqInTJYe )>FD}Vޜ2$7h߆F5~)<8ҒECUI )֏yrvlw "=' YjMoC io>-TB&.63}Ás3܉_|1ڻt:̚>ԑ pY(1NOp`8ae\l9qNGaN* UaU9=2 ->5'?R{[f"Zp/3kPh'4岈:s.tpV^F 0rsWz뷄gۼ5[z/wrōNI>jƩfϽkU;㸧ǣeeW N6Ɖ;~L`L]~/qq.}rLLIs7Ԥ{ĸԷ,_m֮GNl-8?chzbC:*no;"Zpf=2'C.-7|7',:q6/?,XuΕAxv^Kʩ'M8cW ;aM]ӆ_jKGKB%/{}|Qe5ai;o":7RTZ$~'M[rMae6֥iqEg&LjJ~ViQޭ]UWvq9ɳDZjFxg5Wvh}jF#I:vX$@ sEC*}uv׬7}?DZWQ {z<]ᶾi!v܉,(|k<G!ajKC\E3MN|M.š^[QrR"QVWJZ^F Bm玾Ր㿖x}gOm /hq;v[=z\vEcmgG}ƤI|\?{ٺ/@sm?-9ea>YM{:1k;7;o Ƀ_c{V*EVs,vh<&OqjY.o/]a|i_];ηw)y{bɹmr3U_h!/*,7ӮnqP;Ru۵t'??ȻدE纍 UALUP7 RO܁3"iSYEx:3ΜUT,Ķ% ݦ_/P847xuRQ6/< p.o /T)TJR)00S4uڹys#\ _F:,pRz*Z2.*Ҝj,/etYz~϶ ezRILKT2r5f/۵e2_VWIÆsl8{6"gkl8Dڳ2-.O#ndD䶲u8㬡KŨj7^.fϮhwԱ8v\EF#xY_Ǥ)z핂TSٛun檓6oxE~Ewu|%Ү-ys`ݗ3fڳ6/mkgjѼDj o:yMäݺ'#tױj.ٝs/w,wx'gN[G{<1_j-V>ۓǯ F6^{}WӶ.ajL4sǟ=췺Xcܾqw o5a+^G!K&y_,3O>~½P{'?m#O}6D7}lqQsF7-l{4n̜!G.+;~aÈɧg۷Tn=W) SUsQԋwJ N"aIDu._:xϽK߰) `pӊc+}Vu!N{g-(ڣԡc}.gmѼA綵r8ʫuD$֪tkSk^~-=_\[??*S~nm68NJϭoa}p|5jpÑ$&~Kl8rʂT(|/_LC<9ut}% sQOviyY'f&}(]h h6A?vȠ[;9o]`L\m©,Z;*dw0t/>`™ž{nİk;lD[k8w! ˫b;>о}~{h_Ɓ>}eѽF]YqAǶ)؜ݣW-`8}qbhϋpp)|ק,hּ7U;w1O81F,'T&&RUqtE,f7R Yֆ9M5YCk1h:vӬhT L7C `F{RxAbi;4lAo8ޥ0#X8xWkbKE=`ӄj>̳ 9a[₤l|rW~ۢs&o̝s"գkwq/[W7FOH+RѼdG:2'~]x{VkwQ}fV&+z6wɄz=Rx*3؎wo{#,"υ͛Uwo|6ASpmnĭdo^e 68(3hѴw[صvL5ӝ`|uƆ ~%o|yYŔntd {{/=[>TTa!Cowۚ(%^Fs3ܫ:~^ѷߢMɒLJϵ\=`©eU83/!ƹ\esg咱A6бǮs6 ȃ^Xtʹq7Ղﾨ%'Ʌ3}ԾS/ xyǞ;-ԽU&:NqS=9Ďܶɑse^s_Ӛq~n̄ڔ=?rvQʠJ )%ML%Xh?PKL_4 &>lib/netstandard1.3/Microsoft.CodeAnalysis.CSharp.Scripting.xmlZO8~?QOĦ=B[r BZuZBt$,W_IegN&dp%?uv?g'ưd*Vo$acN2*HP2DitF5O-~z5~O*zh7S|{ܩyL% U%o1VJՌ8$ r:ݏ~!MTjs$m}}2%љi[pwJ|*eI4ėlX݆$၀d׷t6`ӷD$gQ \k -ȑ0ۚ 5%8: B#韌6q2cUPx{pAl%#P2sy\n'C=&E'ԑ HlFG'Iޯ+ c+ihf-g"Zy6 4CUYԃT88jh:CL_ $CtSủOR~bHʄNsudT <+P pi0KpDSJ hE$bCN>#CM Y7hAOrL(95֭]ֵmʦ 7n+2GQV4Z,1'bҦo$gsT|Pܝ`^wPvaP1xKcGm؃YtTIn/! U.Pm6z(?+Ӭ'%3i{xRğ B×RRm8~'BJq֒nވ<6 r`DFuSL'jh\AKj8\=K.b!xCeBwoO7fVr39n# Is;v8LOǰ=AK)*ai%^UM*HL7nbIBKwн(>X wr:(47!lX/CN݅-alߡo$Ѡ%k^C֩ .t pd16R g[eׅ{.sv/[ p5cZr!)L㟏h˦yt|FJJ&;%xOLWjPKLV>lib/netstandard1.3/Microsoft.CodeAnalysis.CSharp.Scripting.pdbW PT>.pY.SXPD ,/F,}\}0{w1[,򈉎ic6jұDqvTc2Q;u8&MLf6'msw{i fWb~@fk>Lw!KP޹"a18&@`݀ DE] B]Q?'+#kq~wϩ91 FdeJ h1y%9eEnWqec6AyAވ8D$ix?8RTo$֒WR/A5Wqi*KPq3ܢᙠQFyKۛI\8G|XE|Y@Y ^P|6T_/ .q;T3AL5*kF9pj}xkC+4Rë4ܩ^&jx׫88@y QܯMެ-*~ Ъy6:C,WBe!bVrR*\ՙj {aP7DxdBڥU7A]bLdrPgk6)$EJT(ѷWC7u(Y9a<"< )n6z$`lBV%Ix1B&¤J~'ǂ!)"z%F  MD-3\jr.)sϜli~= }]ްst,EGw|!o4 #a1(5# x7@G7pBqC?t5kkWY-TV{F=NrzjFz'a;D"B( {TWxXp6VawKK^ KF#Oh 1IK>rѱ_x$bsT|?HŏQT|6P#:)e]Iv@ Ӎtt]sӵEi'+;bݡqR8 ſGhjM*4.jŃ*΢a"1'@|L\ςjcC /6_] Ҭ.,s9'kyG<Ҹ1X4LC|<ȢT à](dc"b}08Yj7) CN;I j|+kyϼќ}GOVL织Oa O4\PmG4t ;w-{f5'QuZb/G<6]'XjkMfY /׋9?|桫seקVI[7_i,OK!IKv{{:_>rlvЪcw5u2PA ! X5TGWvBGAV:9[#[Ɲ*e\Yoз!Оq8Va c6bÌ3/(nDa5YvmK + rڞ`Ў5xU m I|13l"2Z9:r1u}"?F(yȱW~VŨ?_wOc0a0U0U00UE뢯˂1-Q!m0U#0E뢯˂1-Q!m0  *H rszdrf2BubV( `\LX=IEX5iGVyg <&, =(_"◄egI] *&x}?+&5m_I[=%̶odh-BbPglk 67|[mzF`'KΗg*h߀ 3f nc%mlaң&qÙQ+.P E/000 _ջfuSCoP0  *H  0e1 0 UUS10U  DigiCert Inc10U www.digicert.com1$0"UDigiCert Assured ID Root CA0 131022120000Z 281022120000Z0r1 0 UUS10U  DigiCert Inc10U www.digicert.com110/U(DigiCert SHA2 Assured ID Code Signing CA0"0  *H 0 ӳgw 1IE:D娝2qv.C7׶𜆥%y(:~g)'{##w#fT3Pt(&$iRgE-, J M`IJp1f3q>p|˒;1 WJt+l~t96 Nj gN %#d>RŎ,QsbsA8js ds<3%00U00U0U% 0 +0y+m0k0$+0http://ocsp.digicert.com0C+07http://cacerts.digicert.com/DigiCertAssuredIDRootCA.crt0Uz0x0:864http://crl4.digicert.com/DigiCertAssuredIDRootCA.crl0:864http://crl3.digicert.com/DigiCertAssuredIDRootCA.crl0OU H0F08 `Hl0*0(+https://www.digicert.com/CPS0 `Hl0UZĹ{* q`-euX0U#0E뢯˂1-Q!m0  *H  > Z$",|%)v]-:0a~ `=į* U7ђuQnZ^$N?qcK_Dy6FN\Q$$'*)(:q(<.%Gzhh\ \q h@@Dd %B26$/r~IEYtdkfCڳ  Ι1c=OƓIbnS.hlD2fdQ070yPjH}p0  *H  0r1 0 UUS10U  DigiCert Inc10U www.digicert.com110/U(DigiCert SHA2 Assured ID Code Signing CA0 180226000000Z 210127120000Z0t1 0 UUS10U Washington10URedmond10U Microsoft Corporation10UMicrosoft Corporation0"0  *H 0 |W T&Iw{%`))'zҘbU2ЄP J,?pϝ^)z|w_/Չݰ`NWKPe44[{*0D;"Rs礑3Puh.1ǥA߁q.jt{y`+b>8mt^p>FEEӚa}4 A`$>d l UocֿNv;9; d_QAXE>\ 3Q,f9>)tȠXW!"&~#At:t<h7hXLtuK-Xh] 0ޒm"ʭ'10qSq@tx0 0  `Hea0 *H  1  *H 0 *H  1 180430232926Z0 *H  10  *H  0/ *H  1"  $ !?(ul+1~:\iZ/0 *H  /10000  `He ?`L;QC]4000vt0r1 0 UUS10U  DigiCert Inc10U www.digicert.com110/U(DigiCert SHA2 Assured ID Code Signing CAyPjH}p0  *H  #N<8޹/yv*5U@Vmf'18c(u3dpAOpԤ]45H~{J09+cjHXKMqo7 0׵AgTcPUe]pj6=kwܡ\9j\!h~+Jw_]o/{O?=0>"iU;Ⰳf@Wf87@:@5pg쫡0 *H  1 0 *H 01 0  `He03 *H  "0 `HE010  `He :% S2:Q}AؔC-{f QW7[)LfX'.20180430232927Z0 uߔnFֿf 1I01 0 UUS10U Symantec Corporation10U Symantec Trust Network110/U(Symantec SHA256 TimeStamping Signer - G3H00@d!!0  *H  01 0 UUS10U VeriSign, Inc.10U VeriSign Trust Network1:08U 1(c) 2008 VeriSign, Inc. - For authorized use only1806U/VeriSign Universal Root Certification Authority0 080402000000Z 371201235959Z01 0 UUS10U VeriSign, Inc.10U VeriSign Trust Network1:08U 1(c) 2008 VeriSign, Inc. - For authorized use only1806U/VeriSign Universal Root Certification Authority0"0  *H 0 a7^4bXZ##`אzX8dqM-siq9M 3I;Kሙ3ǀۑWrwͨ 7jK _y5x2#2AY>+m:ɜHS6xš7w0s0U0U00fU _0]0[ `HE0L0#+https://d.symcb.com/cps0%+0https://d.symcb.com/rpa0.+"0 0+0http://s.symcd.com06U/0-0+)'%http://s.symcb.com/universal-root.crl0U% 0 +0(U!0010UTimeStamp-2048-30UcʣNrৼA)8ub0U#0wiHGS2vї0  *H  u-4\2EOxoOȁ@)]Vdq0*af V]q G̐/ lN3ִLcH9@!n< ɏSWA/MNxlBna\RNkJzS uu.fW:Ί۞8R` M'm2?@Ῑ9+ZXU}ǚ#*a0K03{寺?#"AM0  *H  0w1 0 UUS10U Symantec Corporation10U Symantec Trust Network1(0&USymantec SHA256 TimeStamping CA0 171223000000Z 290322235959Z01 0 UUS10U Symantec Corporation10U Symantec Trust Network110/U(Symantec SHA256 TimeStamping Signer - G30"0  *H 0 ܿi{TqG e$ m0?'J3Nm@" <$(rQ= &:C#uGp _[rHWeM<@28?,Y#ˀMɪ lUaW,ĵl#ҟ lbiNR1[tRWl"Uo?J"ve6򖕁&,8ӯ%@ S)WX^HA!޴&{@SXyR1ME<:"Ŵoﰊ00 U00fU _0]0[ `HE0L0#+https://d.symcb.com/cps0%+0https://d.symcb.com/rpa0@U9070531/http://ts-crl.ws.symantec.com/sha256-tss-ca.crl0U% 0 +0U0w+k0i0*+0http://ts-ocsp.ws.symantec.com0;+0/http://ts-aia.ws.symantec.com/sha256-tss-ca.cer0(U!0010UTimeStamp-2048-60Un_;1y6{0U#0cʣNrৼA)8ub0  *H  F_HϨ'K!Ͳrpc/U){9FN~eXW 6$ {;bJۊTm(gq?3 ٢YJekR)uJ+˛MYA÷?Dz"tG %t`n`Vz DXHwr$,?Kg_\T>3[ŷNqfE?v1Z0V00w1 0 UUS10U Symantec Corporation10U Symantec Trust Network1(0&USymantec SHA256 TimeStamping CA{寺?#"AM0  `He0 *H  1  *H  0 *H  1 180430232927Z0/ *H  1" 3ss1k֬~R@Am07 *H  /1(0&0$0" tv}9N |ƀG CS%e3V>+1Dg!h S JZr@w r,]O_fҍN?R4`gtKi)!?!HфgQe&" yvpȽ:P!YeRMI`ǙgȜӦcwW^S8`PK L& _rels/.relsPK L+e,.OMicrosoft.CodeAnalysis.CSharp.Scripting.nuspecPKL=Iz85q>lib/netstandard1.3/Microsoft.CodeAnalysis.CSharp.Scripting.dllPKL_4 &>9lib/netstandard1.3/Microsoft.CodeAnalysis.CSharp.Scripting.xmlPKLV>D?lib/netstandard1.3/Microsoft.CodeAnalysis.CSharp.Scripting.pdbPK LOIH[Content_Types].xmlPK LPJQYIpackage/services/metadata/core-properties/bba30049fd0348d7a8d9c3bbe28f95f3.psmdcpPKL-}$$L.signature.p7sPKpnetcoredbg-3.1.0-1031/packaging/microsoft.codeanalysis.scripting.common.2.3.1.nupkg000066400000000000000000002417341457701673000276420ustar00rootroot00000000000000PKuJ  _rels/.relsJ1$3t"\}dl.$ioo*-"\sw{ 'x7Һ┠^7lA׫NڛH\>X{*ЕB.eXsⵃ+!7^=aFFΕ",eg4Lyy ɤUFraKZ*wL%%jNvo(a=_ 20#B,tU/:a<3Lw5ȎV jm,] *.ơEZ|f\>PKuJQ: .Microsoft.CodeAnalysis.Scripting.Common.nuspecVM6O[Zlv$\(id+ k='/t,^5܋`=g]U^pJoAW2~"e 7]2:W"e[$ʬ!S032S1 PY<`2B'sdǵJrO$vL2:ף|$H>+5#q Q7[(w*CMxeX;3m0Ϧ=m{6RqyUO.fi$zHU[fUQ[+KoHz,]Y-/+CKsn h@ir,mPIpp()sfjbB|GsI^Rf_n\iJ546mU'7N" Tʉb<_L|v1K\Jx^L|4.p|^UjJh$t+Q5)>Xoy+7 cԯ>&-ǵ;;Tu5|RkI*'Lj?oY rP{?]4쵓;HSE-ԗ5}F.ՏA?\ x=,U'UxUF;ܹ|wMYt1CjLK w%7Af3>GVfx&ژr0oJR6 P+Ag<,|*`9.~Kcp5Ր3IVl /´ZϦsZ~x}c}KE PKuJ=amE7lib/netstandard1.3/Microsoft.CodeAnalysis.Scripting.dll}y|}yٲN9us/1ĺː C'd"^Dy#}uFKoib@?/X S7o9-3.U?u͹ܩ䗸Q0}~ J77N蝪U/i ?,݌CѼ2.= -W҄OixzjZ 4SE烙n!=b%Z)=:l.AֵB#](z<1n(X{r08hqm$^]7UM#[蹍 V~Fr](63ޙpef&TjzGlF QT njJbP!n5FI^+=\P*IUz"EitRuUTH*i41% [I2gf^#5)e);r$^L&WV$ 0ltЖLb5wm4jՍ2*GAFIVz]0tw$[vޕ0Z" z D52k5娳7AݭfiE(Ǽ7wb"蝍3o7wNxțh-w7Rl3|5dmBZ"r\lY5*BP4Luto #EmPa@np[ȪJbeԪ**xX!dFu.&,exT(oՐVc´2%~*v]R He9Vv9R++lC叺+)c*p}ұc9K&zĠ&[@C`VZq׃z -eJ+ˀ%tL/=2~˝ )s1QCoHg"F"$i[%n6  p+두5mIq9{k+voDL3;<9@ ]}H)岜>.ܳr&6sw1JU#qV@/M 3TUIp\r]f컁 M1M;BSwC <[UAv6.]H b/{/ﵤx,Pk ՘k+0jTrV#ЊDtL¤@ )݈KBBNiuJw$jP/7s ʞxJyvлIo!WC^Pok,R5*3{- dTVvR]DAUcAz44 w#9ɝ|dB݄7cNKfD[07\n{幦߶[1A8"ri0ݘhėI6b}l<ݍ9.&rmLD!Iw$"(*5K{z75LO IL'xH/(\0SBa}G%2چezb6 ;y@d34vo}lYzݟ#v̮`?C/elRiYͼ'xQ؛4_1"újKKP,fӠSqaNeA*EfPlS~DzHK?39mz\~hT 9?K𜮻LRÒ Cb1yf?Z9k@1O t@,S}<}2#cx1%Q>)<68fTʦbfqm Hu"Fh /efe䒗\(^c>ݭҠ4 zϓ@aNeh|&Wj4C5$˪Aڬcw,D4VNDr1F%%&0k -FXTN -3]L-ij_*{M~Vw  s>`?rؚd 6j]dt"24PA+S2oF2gFjrk33 )hiS`s1FgPXImV t hP) T_n'bCn \O,/Fm䛥zo ӳk3 {mNo%FemMDu$I4L s&hZVO+OpSėۊDYazXIAmpq~˺[mV^ZD_Yp|A'Y($׍/5ؤq{TG!&I3w(oG3^5qO&hB)~!8Û.ɝM2u53) =NhlLg5Ta]UT(SZɕaOEBO-rij> Bs:P?Ky3!SRk48cg\2҆7oc-q8w,:j,qI$|]*, +d=s4Vn Xs!aM .(Lu*Iw `D>U*, +uH*tk D"] d9T9EUR.gIvYΒfM0l+;'`4ku-[[ύŖmFcg;E7^ldv,cBD]&I2]2ә2 "-pjBUշՄDuD88sRlX kD i23 fQ\ĴgI(rijmQ{2D o ˖xw46qydl-Htr5*o=)a0ה:Su1Ę:Ėw7Ӌl`u|;y!yHsQ·z;V&%{VsǪ/YwYH8tY蝁 Cd&o!FDɔ-$:7 "<ݗb!&NQlV6AU/΁cb,B>GCfQ,0rgUqPI u05Wdj*ûޏr9P4vN"%~8; r1pc5b9d^ځfKs1మ(DfȻ\IN,5QQјWqV'@xW8aP*]l^لykq$u6z=]/ʮkyc { |n.C ܉.tcŖC"w]LOO ?o.]ה,aA4pEPS oQ0|1J-Ze -= ,Τ~П.,>PҮaVNZ%`{)Mb,[c);Ȑ@nDTIQC@Xj.6]RN3y,c]f $: lٌi݃ oqPV~]w"mgSgAB?6x A,ڼ/W鏪XR-2/'ڵn{_t\4, *Tj{#1bܑ'#"PsRi.6=!U$W!f]iZW4)jwnyPP?+HiwU-=nJy::o#+nyTҌtyJ' /̗ 83flq\r/^0Y!yr)5bM1 |ֻBԕ)#KoBϷauj 08~"I#]qp{d̈[OI)E)&!^Z[N/}M0g%ʟ֧e:KF-?g*#)xV+#%P\ë@E(8l ɻTEɷO~z U+E%uWOEE<x-3:sLHM:jͿ_apkCN/(C]S(Yg1/Y~IȝPiгIY2`OkX;}H^C߹.uҼIFȮ13f":X r$C}h׆'1^)B^+x@\$mc3ѳtgD{0 U`{Vc$#0izNþKs:t5|AJDbQmftgn՝ksgPdбWO;KP xV݅9 r;ycQ(e) k1׊d}܁ ,sldଖ8y-D+]6*#-P5r0a+52VrnWx w_D %24{,-pr8. z+dxRskF4yȌy1 kr{-C3kiVPLJ4>hGvuh1ӄqm{Cɞd$1湐`Y 61[//,\;iakC:hrvm(5 [)PTĮ[ǷТDc؉ۼ`;RBćF1+р,-Y?3\0U^ݠEn +47z"eqOD#Kmjg*m4A+[b{o>~n[\aܰ [4y)x =8(7\b4?AݿֲL)K}}>%Uyt=3NQ x^>W~`zT"N`5Tmɢ#' u D5HȀ=i3NGvn0ʁ0> 7UZ|O4c0Z>깫(#'= j-l.7{od)=w#mM;?iTBna˼u',` `j02PٟPvvn<>TF6j_x,ɔ~FfH[@^,>Gay R^WT$ZҬ> z!4k8!)62fBN5c;!|\3%*C<DZ'ڽr=WCjJ]lzjip$D阂,llIcY D íU&'j>B!51Fxr!RM˯!2c! S8kXHLo^$Nf_xba'~I2n]_s*GUN v?2l+6;)KJVS]VQnCj(*x @ΖܱrEE*DV;6 Y*EbXL eCU1HA1]W ,L$ȬwExǠ$uiwt1Bl0?;쐞f(9=kpme*lEhᢈZޠyǭ.34gz@Py<f| $Jxd-Ϙ+$ ^ 5oAp)KOR[wt.KD[AG! A% \#&"o y[Zf+7 ΫFFf\BklY>1T{y &̌R# PpBZ# P(kxIM<K%%J'ZV7߫gTSJ;v限} H)V׉;/UA𾘲S`n븫.>TZ*אܞt]frb8(-o)(Vvd <Ԥ| sreCĦX\9{voVXu;$#gq=p01V $]Z~"흄=SbJ:$GrLL_, Ioh3< ||r4Yl|2w@yY1 YU:filù̆ tnmg d]X :ݵ< lJQTP%9o/Q fR5=ߠFVLDrOPl(f*L?2sRusE13VHq('o䷼➍* f"v_=b1QбU Չ!)bl< ZQ߃JEL RjݛP~ 5ɔ ͺ (oFr3&ܿ*vR.U HַB v~][y,hRBdzF&W%|@cok#nSS^ģW+̠wH ҋy5ζCy)]f[csSyTK8=V6ۖ4RP"nC=V;̊ x4&+i2^wɕZvZxȍQO=o_ؓe_<3G;df&ے /%&[ ?F:Pݢfi34q.k  E̔ZûQ(^* jSWۧ+/ů/^m"^cJ9w$GRXYRȽqr1֙@vťbB32K,Y=o:2~R)m%TG痤CKLJ3ekZNk* {+_{+5>`dZK$).van}V5_˽V/aԜzByΕkuwD%#VJuɗr~HtXY(g.ux1r*k [>qЮ8Ռȿzo633S+o_xS(AUlHczՀ9mw6S+ wsS?wo2AmLJNI4Tuu>+A^Z7VwL4 t/>T">+wBiﱆ+]L9ss|{wҍA z_sEj"\[uP=CUK4+= Hvm4Yn_C<3?tm x:ix{Exe+=I?"y盖|_RˤgfBx/kzbR|dI.)T{ a,tL1퉛iX0F:H*O'at8tY7.&S2 D#P~»-$24FSti8EO 󃢘E^~G4F#TؿEﾗs+U&*r`;$Wz7-XTXz݀+p,A⃃}JžgCe~Gw#ӋzD0XU zPV< >2ELu1kX6/0R%Hx-עgnˑD~=U}d: @䧺2Ke?QءT} nJl۫%9S'cކd釣O<-B$HVv̖l5]O`<^hIфy8gҷ?> AmE~ `" {ByNhֱ<'[Nϖms ق'aK#MhzaAm͇Uƴ2C=-\x``ܟq/FRÞ2"+j ^+c' D(/d2py踓iՇM~+ˏE0Htj;)R'XȗdfŽ.x 9d H{?ǔLq-i4Hov0=ͩ;P(kOK†m`}QVkF8,z% eJq |^6jB^m*_Sm:mZIlS?FM/6Vj演/S`B-Eڳ+ߞ j\Rš>+#tx;ɧ<~c  6U|hJ[{kRn )$W|AwUʺ&_rqdUd20لZ׷4y^YPwͩ9Q7F C޽$u\(KLp~E% hֻQ?*Hyh<_گ(+|L_ʗqJZYTYۄ)"9-$a}GQs5$7YwGh)Sza3Yx6lc,a\02B1U\P8Bɟrr`]LڤRz]w{oVF&bsqbAúJ*F&^HgeH3S󽮢ez](3m~; Iw#|c߿ĿizߣvVK3'[,k:JW j04FܥHJ\z`'ɮStῡy-#IKWŏ;m*K~w^Z%J x9l'jO7PJA+z7ލ&eGe%)!H|%bS4(aWJŅ{[A]qy!6 Uw=@C)~;\F kȜx* 7B(3Qa[{6KΤtSډP愐wP#0{c,s%52!nىAa;[8@v۪SVZ7RO~EtgPJT Zd:,6םAlU=Lܮy?\zc*dͭ|5ge%鄹^o'R)í,uP]Lp ?nn=_w)Oekb:Ing`J!j~i8fvP*jJ7v$Q:95H2m OdjQ".[e\b^N`JK^3ߋ1X+;{;spۑΏONHJ:l2Ւ_lQ1:pOkPjBez Acy&"$mXa[g|`L Jc+?@;.~ '~J*"ND^:vZ66(AyiN "i&ONId()*)AfF嶎ҥ"3Is,bLjZ,yTE(R=UQNSEt:h> 9!Ұrs)EE;!B:Ejx s"u E}+bEANW $t'JsJ)2|҉ oUQX0$?cɕTkA`gW^ ـ6 gC)Mq%ICM1A1xZrQzXXw3[Wn)98B\aP\&&֪+8ҷsP{+ylYE!LP"K*`k<@ J\D]bx+iJL ~R$|aUI n'T"8^"Z6OMy @6dKHkTn-2סGJȜOTF*H5z#yx|%~g:,$O@Y@OL]{E1 2I\xf \FX$BgQ""ioo];`>FD&(ny'vkuN"<]|~me/Fid5 ƴ'd2jf]UAC V6;4"Mrqu ѶXTxNj2R/Lzj̇V fK HJƑI{H "W)OʋW3+B ކj84"Ku',K]+>4'FLzSS~59EmXysV/:ߺc+T-Ҳōԉ |-rwL7NZ"@(^6PZt |9zU|ar_c~|1ѐ"\\ڑ|aaQ3ou6aPUkL!~(eΧJ QN0{Ke%nfGy2"O{W _oD#M'Ar'/P >='JΔI{-T՚5m$\ƿǿ;g?G<2wUR$) lNJ~i d֠EtnoHZ Ĕ?O7Zɔɯ7T'Zh|Q0OcRbydM\P;o\涱m-7eyɬ_>h'܆Mgبk!~R1M! z>~.<ڊ{BؠֆA (b )qq#}W.LpnsxaʟT_xp+ċiRKӧ[b7p sUg FZb%ǖ iăp+me{wa9*i !ʸ3T*\qvL|Բ0}zBgT6N6M}#PyqSk;k"7qZ6ak=REg[bag=FmGk[Gbxt*솅QG(mbR̈́{X6N#q<bI>U_^+,j8bh%꿟ę pT',F;:Q{KjOC,ξkBg7*sJ}kZJ7+Df1ל>=&W,:"cI~ϦbRNK<@,ϠY\ JYD)⤑_]Q*G޷)}LSF7׊6(*;g릵c;Phm~'b"(p3a~6hyx(KL6QΌWt+ƿk:!\/Oxl"\͜i1%&o1 L-77&ػkj> |r*T5iuqvX:Ԋ<x.0*٦[AM̻q\".qpXqT 7V CkobD8P ol%*P&Q>𿷀ckfj9|f8 nӞlX Zqlè3K[sϜ%I y'[-i.MiowO^JƝm(sbMbd=2m3__9 ҥi4Zq[fDg_\#KCy!,G mfqXE`"Msk0/e㐿qQ>QYI'NIx`u(zªVru%XC—4n[#sY@v zr* qMD}וB}o ~%}EdQ6ywD|nj!o9^=CB'PJ!5w7K8"'.+)num >q5n[޶BQ/xG\6ǥ!`!e4g"nհt@YWW?xa3T@BA^/R.#2 Gcт]6f_9bН&FN5OL.C24Ud4 J&r\}۾۴b<.&WgKSXA}h+r-8ߣ%~ҾGRb~n"bxl/"}. 2B+uW(C- ])JI{'+x%r|ƝEB7h:@tTbhda@wFA5,T񄂆P[5@~V;br)a·c6]_47 |Nyܾm1C_ T[P/ir 7h m9CU-J[UTm^Bq7Ca:NYF) c*&+ʗvpܛ\fvnPV]}t٢]Gi;9߷ʜ(SHٮ}S&ip\xMn-7U VѰqw;䶈iU} B޲VmbW^;^L9֪Mk~4l%zAl=:V눊$Ŏzr#j5qX|D鄩c(cxn3p~B*:ɽt5_.=/4LPrg|Dzk#66t3B)7BK6VhU e^fPru&`,?*{<\Qo&$;{礻]Yv/}[ N4iƋ:R C]\c؍0O4C!wvd9)!sv?nS&ٽݛ8fŮe;`m!7ܒoBZpa6nÝ[_cM?\M|;eU O_RX|? =sid>5qOB Yw> *dT&$ufr4}^EIXB-!pz|&\뗩beɲƹeC4qyoUdyN}(Z(FHwpFz:/`9`-IBK|)`'HgLtd7~5pWφ;$Rhȫ DlȱzM݉OJ7/CH缡keMj[ Bb4kۨ\}CrG ]d 5tlI^1a' ׅ+c5[#>А~&sKGKO"wy`Cb˃F4RA_]s/: U8u.] !a]} ]Xf[ +m2Coj>( ,ّ.'CznV3$)x7˭>qC=Pebw;bNW_!U,;QddVCggO+YΌu6&zJW]爪lw7W g7}&GxN| (kt1,iެ͍[Dk:q.n`kJt}MyS$;ERqPj)TQX[QXg۟g)jy[اZZ]؋lT]^b;8۠aWߍ1M5ao]d QdsdMX`SK[bwD}:}VP*s)U1+.Sx .=S/@X?-Kvxl;6CO*+>Qh3a3DZؙ߲2홧IElY@J2:AyYv;;L8|,I@j.Q8vܔ)Y nnLYk%bCAڕejK^$PJvg3m|]7@mQMv]Fտi(َ9,ߨdwL59ߦd9Y w*Yi@T`+ٖXO2#k7*+̑:);6+͑e&!9+{dHI~ IYnV"Рd%ud552BJR Ry\=43W\v}jd9{MY"k 2B6eԊ SE}83k߯}3=Ygcse&olR}SV&^S+HEelhP+yL0+7)jAֶ\KGy2]{W*/Yˬ">b/?u6/$ dMSD1(5y<3/x%O=kw*M27Q[#33'P$Ck|)na>,Q+YmYSk*#*\z9Ȧ>E+d/" J8o0 6=a.]祄UD=!0/ =)AN{9_Sԭ#/VJjĹg*j xR_w3VT5a!?FԵuZV% HQOXkU NX¿TwNXWn?1ϬڦQ&'dosK2_M8YQoyimI^XJ_(꜒l?-ora X>YW,0c ] XDmgȚxbv'[]0=_v|X6w`^X>Wqή/Ͼ@岪xB`U]f>FQQ 5AR,lf>^[M #2e]iE-* b[ť|f9\d9 g_ɜ-yKU<^R]3S>^dufNO~>z(<{ٷ3SoMRHIMR~cٿR.6ަ+ թ"-6i vG>2+9vSRY'JZ;Ͳ{v,V9Ǐqrh6h?٬S%d_+q䟨kb߯h cQ"e6iFZ9{eH~ɂi@AQ͹{iBƜ g+1K׸KAT[Ar@v DMRFӗ]s(C_~H+՛ڀƠ19-Μ'y ڀA݇_E7Ck:ҠƏTz-e͙r/,3.m5wIE<7d/ӵ~QL'9:ۖuoP5ԭ!הq~2YdS;?\u mKKK} =WRo~+%U4qFvDgKԩ+{SsGVʜmQJ~,Q[Y y s9=zm7X+ /6W<#򧨒y+)y5W)r|2䶼*YQw-̛/8S59^j[(b|)h/߻9-^QW"1? e,5vd772d֊uy-beN]D|'[]yKE};ӊJ|'Uw#IM&jKR5xG^X/{2.殗zY?)&ۗ*qlU"},ڦ6s#[%JeUuKjcy.1|^Wޱ.'Z\[ ~y,[#7P]3XQL_Qr#? # 1[JRx~PlT\JtzKQSFoͤmqѿ$RHԸͺ37ْbopv!ZnBNEʾ<nO*οX'/6뵂kD-pS"c R.݊ӲU\.U.%ߊZӊL`I*j~+ĕ_rVʕeEzN%!2?;ůSTV){,sFѫKR~*R'pN!/kmfIM|=#ZGӻ%! ߹l^IaAݘ^s^/z>eII-&:~ ÖoO[r}xaMw$^S ;8iſIq8=Krzb"Eso-5I0[Jv Kzo14ʊ>h{ *eu&4xAfξ5ߤߗߢ{s.1K{@^b.vYڻħחKpYڻDeRV=2w%v]fwx236=<Î[/)\t$nr3=-R峟c0S[d_a+6qqlrE}˿G4X޻WY޻Wtv^v)*A+ O\l qea]f +%ՙ~PLf,,# W!c2C>(!°EUfzK6X}Cj^x2!jCbNCw){XLƔ=,fGjm}L+/q5fG=VD_cqK*lxQES /xBQT&K,8&¯Sp\I=]h0dEϊ%q_Vx-z/,D.YyHyvIىω{ jf ":I]U_^Y"rU:WDg/(8t,;`^F951gzZ3y RF_CJvvf-ڱpsb ڽDdo__ >H>/ĭTOi _ /$2[%uQ_ NnEݻÂ=:oW\RRՊB66I&PmVTcXavؠ c_ev֯2Bg4XdqL%8E/V($'k-%h^]+\SM~f&iwXp0E{2Egtũh5%JՖnLVTא=9Ml ]B ݒ,+C{CR,e!Q9,C(i[w|v8-a}f}2mp6EQwLmͅYZVڗNUxoND|G6R9aaz!mixpn||#I(}/`Zl`ibH?1g¿ә5G}IkmͣPTȗoa%U&TԿ\!!04ARcWNL5oRK/Dіt9x̹5q3mƭ&Q{#΅f /zxSk3:?ՏUepn+|e`N|$^鎝%JY%ƿo4#u:@m{Z>ߕo홋fP(u800*#f%!9A`Q6-EO9̭l eRx^ g˳̾v9?Xf,: b8림2ɞYӨ-6-dguJl'Zl? iM unS)^;̺-Am>{&m =8C9fx;g` Z/*1&5PKX_^9P`9g5trNCY_);E*HD^nHA.(EKT}ug JѾ٨UҶqLKPk^˒~ 6j B~{-ٯ7,g7R 1]K2J_NǑQL4FJuʊ %B#dlۯ.x]lݐbzu)=99n^Pn.1KL<\#9E"gNY h{'˷Zޮ*h\B68nl_1*-a NXZ0+Pz?9%mș_׆jl5(hF#Ԍdui9 ^hTk&G٤z9,UrffU#}Zg 2B3";PF58[(;h]@ifVexJonF~RoJ%GTfO-V$Fؑ|`=ƞX6ej1Ķ(l%XsrFL =kV&"^O%-lŹÖHaR_)?M=0$Efk5CJ ibj7P&ā92f̉ Mj!iY9֚Lig& 9orT4ImYfk269WG >47΅dg6bX:2Z^t6)+eWp3 ~}[,~[>c~iZVǦEk_3"2ܛI%|(V ^)2\KNĒe>[_4𴼗fpѢA*'"q8q}|;V-*aGVT9+Z_"68ܭSpD}ٔ'"҈J1X;dbn{ }|}q, oM;ت+[%1~clwS-췣j@&DZYnk؈Oװ -#Wk{%^)4}CCgG3j˵͐cT#AG=j3s;~#v=%L M%l-Zq@8Ŷ=Vi{юr<)ϳ80^}ɮHȲo϶IΧGC9OSu= v~]n㨱\qVVt=W<g/oEmx .|*FOaǏ[;';ʻ:+90͞Dm9okKx7<=t5j/3+l}j[:Ǜw)9Ix&ݚDHy"{<دˌ/਍z( %s[LK8pIҙ719Ixgj +8d?ZCy'-z;mM678F{9x罍]Nh+'Nt3q?Dl1o~I=){Z< r>(W$} b-<{8ޑp܁ R>jX<79͑s# #6V䰍C{{xqE'"o=b?D_~-/́p9QaNs\ɱϵ-oOa+jğƅ9vITnXUB7V?* 8Lv(hTίJ]&&x7i~7i~/i~7ǛI{I{I󎰕K߅Gҕ!Eo~ coEv<jk3o~5x12⮹DAzt&2}IradC𘗩LC C]8-G%wY3ǯ4sx&x72S\_1aoYs5M`1S Iϧ))tyNtho#9/wtZKo)ܡ)PP#.*~]B`]u, k0Mu fix>i:)aƉ s>pN#?>{1o_ ]]姃}>T9ҿ<{8T;tT[09sL x=@M:%(5qxxwV<,7aJvE}7 9_RcC]B0mVӲ?h+[%*nq#J]uMѻZ8 ^S=hߍ:TNG8$k|}}=jhjo~\%b?c哇LMVDzWľAm +n[j?,jWRJkI,-;u)7fxk~6 aL7P;6%o\yH"`!-윇c1cj>OtQmb*ԲV>|HX,ֻ7Z"dZe|;q'Ok^6t {*3ߑ>Y,qNG>-l]+ԩ88q_RKMx#EՀ>*RmZڸTۖܵqXXfqN]B~5<4vi^Rs`|?M}4s wCtqῩ<Wj^<ijxĸpEqHe oڃ"xa}EjGDjVN| 4oG{s7&wܘ]q0>vI#{g3)'o!' ){R'sH,=XCM,eTQ Te3^ VŻR&OOakwP/[7O.HGQ ?rg#iw'@9dO}"!>bѳ_geS_5ZЯ'Q$4AhhՃĹ<ÖIJpxLDQÚHa'n϶}xá7@$L$i yI}SImōI;m#bCICۨ\.ݤJj 8]K$=H hYaoIU<,0=%[606a sfCORP=6<6,džR һAz7Hnm5m#]]IEhSm"]zmфi7W 톳oJ>hO Z풭v(wv]ih7L/|G£i{mǸ6l{Dm^}~ގT5vx&iq ,/+N@_yt680*ؿF#/w8.;NhKАBC^j6\yÆ^3l Oϵ=Zrmx39Նjgk-ncC[8J)"ϳtF`,,`:+GYk ."BpGXF"-]cƧ~E>Θ99I Mf4=g=4E#pA,Q`*ghԅ82b p"0bdz}8{)_b{!n瘸b*?A{_7|Yko }',qŃ?T0Q/œxZ<i/i0F{u>Rl0SCm^aY&j S?GCԜj=hTWttt'xl?"Aa$a ^`3lh-'.ф#Sp|Qߦ^X, ZM종s)e;?XZ]pg`/-"C('(o ,{ېSnC| {%x tC(SyI %x ?+#I#R'|'װu';XFۀ?T63":f|圠`G#ODP ׺y8o'~|$`9A'[n%x'"6AP#8xe : vBp+=|)o'2AqPEۖnѓߌ~_{{!bD(D RSBj-C/_p13ш#ލo#썺:j_TBUNi2W1oļ3a px#~6ľ;<.=n|ܢ8gܺn;a\q /"F''ܒ0;"!qEⅉ&ޞhOKLJA n ZP/<:OcMe=]`ZO;  𚊯 E=9 ǍYeb2곲2 ¼=e'bW0䥋>RpB.A* B_8) p)Y0hf'x7ӫͨx&[xS,AU%|kf./BN{ .c[Vc cЊ=bRځ3HQ?3彐5 ]@%5yq-p:0|Vxez, gj/*㔺 @Nd_ē?vECl:G*|z+[}R#eK;@VBF\Y6Ao}U@o}Un詂Y! z^:`Yu@[z 軳n`st+x>xn%i :C`+!#rv`|(cP>Ύ(X(`OB9;Pܜ= Pw܂}%S(`A)'?d}qC5h}xN`q|=x0`*`pp4 ,~1R<Ƿ,W` ?8X˯Xǯz?g& `+2 S~v+S~ߏ5ĚwaM{}XG~xR6~G^x? &a7@nO~ @~V6+E/|:x ~P[PmcŻ{'N@MOϰ/0x `;Wo@;}\s@ 269qi8ۖ p-<`K!-fÿs dzV&섐 X7\΃ 6`/\r ڦ\!ؕr;lwx xffk#,B+@nb=lB8ΞcR~5.hOkhٶgl.OV? &|lĢ #r#""EGE]?{7FW{D̘91+cb|1cΏy-1<uLaKV61'=>r+G؈Faě#Jcb'7.>7~A|cߎВ=S щg'%^t^Mz+齤"$7&w$_|M'i7#WSږڙ9`^jFZNZI4oiFmeԍzjtS71>y8Yyօw3+2%$ o)?bR?heU<f4* yq<3/; K?3xxw? "^3u0)y?Qo텫.ճGRos8zXz&HL2_Bkzoqler6_;k`7( bSGdj;#?_m|- ~lZ{-o KG†#a<7R4,}"g(})<* PG̥PfZHN>jwWiv֔wuISl BR|rOA9`PݾNҰˏo2^(Hʍ엑Ȋ a(@w+hDjb@z:uVy  G;;]ޠb ;~g/=Un/?&ɓX 'G rl+] 9U}x4ABWbhDQ 7UJFvN2=,Ja2kj  Xjgg/O=fa3k}}зXmڣ]yQ]WX>~fU%u5eQ5o/v1yeM5eM͵|~%jir׵W;8*j+YCY#p45ԔJVy}]se]s{sk+;+1[MUe5M2k (Yi-[P</eM IM\MVZ7̫q/lmo_XYǪ5͂ŕX8rYXeMMjZUCPEz`\-+k/kqԀZZjU6JNcbiM1+!jG]SKU܁Z(HЌFF#转5U6WTVҚjXcesYcue3krYPsee *bhR]ԴW>noW>.=>`RFHMl,[4Xo= 7[@b }<vx:]u>bPw (W>TFM(v5B PZv 6 27%!Fvu9;>?ZM7dD3g{^0NDm!ef ~_KzM-9+ă#%9].ƠN:SB\ :wzV.2m-0H,񩠽`L z{.h R5e+) 2fǿoUOTV[(G>WV\uv7PG w'[sYZOOji Y'CV:<0DwV]:i^>ٱzT{| 8;8Puo2]֠ ~w Sj8C2!Er[!o3X4b+N` 8T -8{ -Miugw0A B=nU}]jY"h|}ȲCw7j0(Do! NOh^8}iXe0enpQ;CJ =4 xܽz!н3JҠ\y*@0ߏvRt5šC {sTV;%>0 SE46 !3_ 1$ w`qjz.O/N/ .x-B7pQk-o~*R5:%1H gxCh|*28#?xarhEu ER"@P:dP= }N?(^w2;a׮cG s,Ҙa.S,}GٶM.Ԕy@k(}±"B@J%N7CUmhF4@۔ԑ5ꪐ\޲@< H546F /b{}抚d5;@[v:|spPbߍJA:%NaRiU8Hdo;ڕE.ww%-V=~ ~u-4R 1 + &Nv,l|LhXnVn|0*@5 M@q .*Yȑ j`HlzZg脣1Ks ؈ E`_ӛ/e +IJjj#t+Jx{ FjȉB0RmEiPv4w:hCj"Ӆ'X1+k۞gYmg*AiD U,\ŃY NdCI!oX"4.G+1mmn(ݚ~)襇r%S&e(D ѡvJ>Z<։.CBUqjK7]33M_ 8?vZ ʠ1sv/bbT2jfwi뤡ahЄ(Pi` jD.c\ Z {;(CQ!tJ#J|=>VjaPL 1zDЬ`#'}( J.&x܊S{#&` z%NY`@І`^{\Cʥ4vXxNS& \%0eq}~7p _+ҧo±MnYp Ψ{?Pj4qJ1 j}sNlﴎw8Х^еx\Tf4z[f ~W9re{ӿ)(_ }K9,tBg hpXdWv `BYuXɒnu=M9PWoH|v2 ::X>1AeZ\`ʡe80z䊄)ŀWYh( 2r Ru3rt'_38sݝT,9kҚ'ӱQkeB0CQ@XVh(n<ήIZN 4< }KAk-*Pdw*Rx^@ wI논YӼ~oh,"%KM% 3Ia%qBJ/ Cětv؏mXMn舠c>:ǷN\fDYKrC^ m#"#>ՌZSZy::FI\~5Jy.ݺ' kCH_W΅O@ JtDZ~__o=`zʑ1|ڨuX1^^(_C}U4H4/),O-prXer G3[6!@ VC܁"9HJL߆,1Zd]ŞMg>@w+ rDN:L0 -`7AjkhBp֍Duӄu=BxFhOe0TJ3:"tfrWYn`( J=寱XD|b`"KD:k{Dcc2Xs(N?lʚYlNU6tDzgzLJD]h5xMюNSԲ83 YO/̒2eϿH z17ֵz?qM=|T6EVMuQy*!ҫĮp}CH^d2Vs4\yMe%WGtKH,rbEb3VR(.Rg2&ZEc\qF-C,=Ph@-cnYo/.+EjT Q0zp|<}`niM#3 f=[At,dBW4  l_O0lU>:7Z.VN0ƬFM 򷥉ӗxuaNXuem%V y^¤qDƬ܇A?in Y?D a56UJ -0tJ+`Y DQe k˲9D1GqG-B19u Z`ZWtYqHgL^=HTg_(;.›$3xAʥ'?HbkCǥP:8x{¢j&d99kd۪22<&øt@>;a5n2Uɤȗ33-}٧-X`s=J;aQ 0ri1DXVpFQdQ$"-52Uֵ+nkQ1ڬO?f[r`:NYkYQJ!kDmHԁ;` )jp}W7i0AYa`hǑ@*M5OcM*c"ޛHWYb.1Q"+@A'BV/do`ȟ=_0C{.B*|c5]=ꉍ R{9yvZ6 _mu8Grhz2昧F#M\`~:B+Q WdMno cuH OQ5LZ0Ȕmrg <9P>P?=PdN'Cr?yRۅ^ %G fI{ .㠕!i ЪFH6+4-D_dZNޗCxfãyOj wuU #3*/-w$ +7L9㒅) \Z*雩o]ƙgXh K͞]c83$VG[, 9L14>˻;[n:;|~t=crPЌq1iw 8R:=X׭B'iAHZ7*Aҡhr4 m@2G.-~ dS'%*p75d:S!i+rOL_*1 tTu##Vl-Jр ;Eay8wH 5,M|k@-5\$DpLob-R1 ߢK EЦS& 5ȁifA~H9NA*қ@f鑖L.s̭I5aiIP!U` I&/BsX w]B@y\mȝuKIU9qG6BGќ8-Sn>*l)j\T_bw@[ck&Ѕh\xe<#PtgOqPjpajyDRPA5cٺP*?4IاSK:"T ۠< r4}|!>ܜE̲dDErUQh\M9+E 䬲~D!*KmWEx]0 71֓ijxՏ&4G8j cu)(Ј 'c}2zOV Bkq#L"&iC 8KMXC:X:C!IAF!yHudJMP}X7E/7,t6eb۽OвtZwDCDFkz{ >:_LJ,ct=t} zJG, )٪$np/eh:<4Qw?|-\ppJ߈HXMft c(x8WciMgxz}ADiƎ`Ρ[҉7"dPDF}tg }itX`|ظf oN+6 QrC9PLɥL@[!B5q v)$%=H\%Cl()$ j GH8“Vd #RZd2xR7 XK % 0y/$JBMbw2L #A {m$iyy MTH $Hy  ,Pfk)cX2VRFBޫMF! 8N%dPHĒrOvTBK>: S|3^i()$YWa5&UY}4/BFu{Aψ O0ݘ3>?<`NtwkFRunS^2X9E@{P!оq7&#PE\ \i K쒦Vd.v&?qdMFG1sX@a@bZr4 YB*[<Қq Q"(6Bs,:yݨfJ"!VO=҃/Z$'%xU21ܲ(׵bE fv@n#m D1W-M'QD: ݂5{kU^ vVm[YrX8*Vf:P֘wH).q%nu;SK(U'2ƿ xXeg%ۤI@ J.禪Y1vcridCaysN(Q[cuĈ{j2:0c3 i +Hx]$`ˬh!֡G4|"G%-`CK*K3 QH[MZ&'ߠVma,ba_&ÂzE)og/EXX>/̢$PDnMXC6cY34,?БaNfW 3 ( MPR(סGZ vE cPU  | w IҞP>Og5ˏ>*YHxk"*i^0A=bCP[\"?Ux &ҘD ĉ"C0&&F8ak,vdbɺuA*Gtq 2zKR&$1Q-z^&Y*z8&R9hMgGcǒ vYVѡ'Ns% 51C'2ؘ={Ӳ0#Mw-râ߹'f #¸(a8.g. Vx>Ku R9/2?8{Hf/c^j G2[ݘO)q'(-g+L'|c?xvߟ4pUE9պ׀ x$`>LHV'B,)HTjDSm: HD-dwQ6 mdf@t,[+@[*ޑesiB3׾O`d&J99pjzճ}wB52\?2 vH D(@~9i130H}4$TQ`ڄΒH* B"=tEJ쁤 w: O7%Kd#Ih$؋!BGx1Ą|!hD"hji%R 6,a@B -pB6'UC瘆\4Pi)AȑD ;l)aT(HIjV Ub;}R-MlPXVKXU I '.GA)Y-*g+ #V÷7 qĶ,+篪 ˄ iQhD`Tz TfWmʖV T: ؼ5O4e@*S q/4Pm¸`XT"aFLTJ M,\7^sXXzCV_hSyW)SVD̂>1D( h$8oHI"`r5`j9p}/gpAϫQ1O߭v:nk@0&TYuEdHT JZo^jZ+AzrU(Su4U+ XHu"D`S2JfI-MʤW1"'-ѧ(c*;ByL1bRRb }4QPPdbW2* ̩׌~G fj47ƛ r|DQҀ#QQ]A"Ʃ_"a$DE4*TRJh!2:IZ{ FU2:o 3Ba2e:ӑ&% jTX9 Ϥz%wT)l@ŔuVO:8b_YhT-LH$ ةAw $Rǩ}!LR:lD29K# X)D1$&QCP-3`0' bTo⼦L^drj1i6 IRFǑ!` WlsQQ`,bзR ~ eDN0Z mN?} g -QhNPV88tf+f151j ׭a2XQ "׍F~e:޺(MQh @)%Lp}VaQ)^وκDn |@|](_B L` Al=_`y?.xCns:Mi-*P& RMpxpZtOC9[A1zP`DڄZe/ә/(H@z0[{nA-&y:$~cD2Ħ@cǕ2Z0{Bqng 8}[K9: TB,g50A]@Q"~ įWlZѷG{w 4LvRnd{w L¡`3XR *W0 kxɉ'D88&d8E9]£T;KCyZ#,mTN LPXDVv83AwFXOtߨ40-dMa QH.FQ4 H-ht(EAH1Y) p`i^W"l)̄&ǰ(爮`1HI'Z[m@OAgQ2`@;BE)^. x+b$DzYfca⁚^6T%X 6 +eWuErt2Pp|z_ޗKB`nMڤUU8R5_:3n>!}T%eA)`F%Cs:0f&“e>F(o-&i#2|i@@xӛɏŪb}ZK(a͗vPa3E)ڏL$ՄĤ46H»RAfjأ _\VgHI0=G2F$4Ois^eߣ^dRH}%/ F ~˩2Tv|ŜI0 s|A$Ri@`i !yN,sф.$rp58h`$lD0pH(;OP 5sƔ͏s&XxF;hzoxhx5lP0b,AJXˆF]!z̠8B&QJ%'l"5gH^\X .< efK{|27xޫ%lu/{a Jq+0@S%7y13i M;[+S@y+6M֤عB]+ ڹ0Z ab7T_PdĦ2RzTZUTaRS&B a^;ҚՍ?C`@҃Lmo1ZcV9c5`F4A~%.s\ UJ|.t,y H{Zhgcg)q"-ydvGE,O0(2> 0# ,ZtGL N`av%TwU8EQaY#H ӈTk<4Σ>4h>X נul "DDH0ʡ399l=rׂ JfNH>qͳ4 D!d!D!=z& _Mɦf)8ѭfncX{8?x9m65¿fJ1ˮD y.+W,Qlxr[{Cg/:;JMV^F5_{cs]"zfֿn~}NF&qb0(=0LI-' 1ȰA[" 1h lR,c@ 1@A(: aPp jbP  jcP00$?H a)G( 7u T&|5f>i8{1vSUh]X7#% >ig+ō/uWX:( z(*y`RۚTHl`(& JW*+"y~‚=|7gW~ol{RUUe(Ep(V\uD$UJu%BXD0Z L7]@l()5m!-BU5UҬN[ <2{Y\:qhpy0dqt19ϟ-h?V,\IJDN/r1KρNHtDiaQ;5EpBo*6L!Hm?C#CLT8g)WF9z1AȠVlf#pMQE a&EL-;of1vD8D"DPHC^U,ġFYR*FyE"B@T=MFCD̥,Mr-$5aU:;{Cü5v_Sb@Df*UgA p߀b~h @([QJϧ9=ozXM+7Ng 3\+lTG}V ӈUFiS҂(nЦT"M ʐi"iqax Jǚ*nxSj?ĕOWqwkʁ"˖sZ_LK?,a`lVW:HGi6ɪdUO+j3̺L*gV:KƣN 8NхPS)Ԛ/TC_ŮJBo ݲSi%gk)MR &rJɉOT x׆BG>W1b=G2Cva7c ,/  85R/c  fh G8&'s+BIpK@Wo9^A132\5L,~A# fmFU ӂ+TQ |1HO5~ɑD{?r\-DX' `9$3yv9~N]24M/qzǨؙYDWg6.n3N!B I cd9ɶ2P?}3~|M'CD[qjGX >/WK0CT'gADξ#m,>nßJ8AB`'>D *24 GSYTq,eQpTlZU᳢ h0%dm=0Q9]-BwgƯ\bG~ 1'q5ædߧrbLFv, ,L;@mP>& c Qw$/t(ʊ4ЊN4zrA]BA-?`k4ƠAqcD; g çȈ;C&K-mB4RP%'exĐ)7annS}Z,ʄYRŧ1jn? |"Co> BglXA 1pb~FPEa0!m,NJVp) i)X՘'1ețoau p PKRoKK/R'a)%W2gYj!A(s hjTS$%;o_f-L_ I8+/=B8!"lbƚ,,|l9ޝ%'Ӟr{rY,g-Ǜ]aq;Ⳮxm;͖lsge,9l3tY.Œmss|Bˑ`Pfw\ q9q6== "99.vY]Nmf[ljvŒeśӝȱ9GB='`6G-;39V˝cϊse NW%c˶vfs9xˁ]֞Ü%E,xH܇}rKG:9Kso܇d:*!Y^N{ROuu5y`:`ҟ*YÊi<?Jy?b.-.-[in" x-'g76siL9͎,kNHHݼ3j.KVۑp-vӎ@#\=vĻqXef@9Ykv9;!Βǖ`ɶq1!WZR?/\b+&]zqapaTX04]T*<R:I (xB8lvo k "%[+ #Jy;!1+!i˶尀;ݙ%! B'«[R 9d^8i%עo=gNfkujz;|߰}ƚ1_S6=쭷<{|o >x$Y`,OC)!%cd ď" A||4_"#_>&߿-Y."0w]gm{&zh5q{ @ِn'h vAA{rMzYYhWBk&e,s`25khYfO023O΂2S4eMFeQ^r; *42ƦB'4 Ei+0M%2,ɍz[LSRX܇@+I4:lXHSʄWRkan1T2ERsi-C^UfZ8Κ_ZRգgJORq.?xO"ҁr ҁXP Q+"3W+pqk8EtJ^^30Ffe4Շqu >9,?gOP@%䜴"-8@c=;0;NDpdy&~8=O1|"^gS BUK)8zoOB<!^>x#8\ Y&`j ([ Q? 'DI8)c'P ZzFkpZ֢6CR5HZhiڐ6iڔ6i CciKS3j6O:h+mM飴 mKh;LSh*mO;4N;N3͠]hWڍv=hOڋ}h_ڏt ͤ`::iͦ.9t(Fsp:|Z@ i-%ёtMr:8H=z)Q:ɔNt*OP:ΠIJiJgR:ٔΡJR:g)Os.yJRŔ@鋔%.t/Qt)]C˔t)}W)} nuJߠt)}-n-Jߦt)}w)}}J?t)=t)=@AJQz##JQ1)SJ?Sz3)@EJ)+^Mה~C鷔~G5JJ'JSzҟ)I/?'P,FB"z<)؏CHdR.ZJy@,)DUDc$Ry?%@$)@'ba~ԠPI-> &w dU,f&%,Gɯd\Jf sgS2i%_"m(ۑgeX5!?9+|j,UƦNawAq6+խziav;Xī;!t!IChWqp?R >^۴ᢗaІ50ޚ*A)e)7^(a u^qkjiVy{,.2mTNob%$/ >@ha$KD@=6A&X.K,ȳAmCeey9Pή_A)@-ʆꮍWT/\ ö*SһtOSir2c<|𥍆@"!/ZP56fUJ~}Q$Cj4$TN usQ_ʖt;**)#d$›%RW0 L]ܝ5i @qsRH{a=a\/h.+,0ky f*Ô=ܮ97`:&|#,ի\rz-Et$SG 1Ǜ8a>I;'I;A00YFn=եhte?> j g ^+q6ݸ]ʇ nޞt{o6vS+jd4x Z?}OO9`ۣ+(U<Μ;YG8=snJ=sa&cvkQ۷O ea*q;W5~<ɸˣ^6o`jƂEc_Ņm{\ذ ӛŎxagj6ѼdUȁk]u:(246E5ҝ rR*XA#)fxs!^;,=X'ħ/V畕äX+wZaeeEZ.ɋfd,-J ]#J[ЀtlXFbX?724/ѣՅOas$Vl)ʥÓmO`l)-~A?{T6{NqVMkCǑc:5W}zWo1/Ծo^CMrۥY~YzҦ3:3l=|Zl7$~룵.=r+[g _tftqIjOt9-_^_ul=/+a\.ώ=.';Ǭ5#Yk\JÇyڎ OTp7>Eܣ33f;13q?cgXyEfIY]q=Ԣw'pcNjNG+hy7Mƫ>Qk^}3,e'k#/~>}G^{ ۍ[Э M3+W<;hm_$ݔ}lc=;h?Qo=z[gwz sOdJڭݓc~ـ S/֩Y3|zKs=~6` /EZJ4TRH*{ڡځ5$H5.N&I Cef*}9/G w>g]Y60ky80܂ԂV(>&wY./ &Y  NzDWZ|߮uJo*.mܭgK;92,vXY>6\[#LJC P6R'[zcMƻl.0Nٵ]1[M:sXhgxs\9y$y#[᫗&?;>yKd]粝կS.i9~J=+Oh^jziܧ([?\^(; *ZBZNJGgtW}IkCύX'tmzy^:5'>7Cv+?Yr7)7o̝Աm2FwKR?fWwԼaߢ;(rG{ϙN%~jJ=: g?5aGNYNYO-7>iP5etU3n>#؛W{d\-:eɠf~Nu4d}D7g߆ ^6~1Yα .l+0 4azf5CO8[6ǵO:MO{G?}_\9Nm>kxq;IW.=ߙj龼\Wzj0MK}a/,5}a63WYІECVJ^hkEZXhsmc(/_-X&+E / .<،|NC-U߫k" Ǚ56&z$ͼubc,H-.1L5Ҫ] .ܐ/觡n|wL2g~I%>ApQEwQUfEpQqfKwQ!i$?@xO>mnF+7=wy#ziPߔ_?S޿9Gs>gc^R:fw7)? 6Wr-vvRjȑnt|~CدԸɑeΡs{{m8<3;>XyVdw[S=ou~Gcc:Q3^-kC;r2v?XЉ7rޓOyڑNw .-ܷacE1g4veᵫle˔V]ܵ}9aRsmMTs1w;"A=j 쟒Ǎo_wecS{?tP:K?*/Oram^ZU+0sX~a_߹+g7~Wmߎ՗kݗukϧ\1@۶I>X돁ղ-hЧSٵv=;q&< CkhYufӈ/><󾱤 o+t;ENW[LYϙó&1hN ojw,~a\T_Z 2ow} ˷XYI[6yEM^r}sgo:6wԲ3B|˹JIM]G:rm¤?R:Y s~Z?'g4+mua̕_VyqkW9f7JoB#=֝ެc~~p|9KZjusϺ.5ٲaͩW[psSo5[.?vY\njl8HOΊ}btŝ߭쳴5lw `څ]/'EGhWǎ;27~b< R~ōoʼkGhL}{c3ۯh;F]\nqe5Zmy7}{Nww}ɳ^rc~%:>N?4GnJ{)_ɾFh٣nع[5W4bB̖އtW1j9},//:8sݱQ=Up~1#77aWy|I]>䱵۞xK;9w;\ܱǘILyU]HJځ[}7;>ܕM߮{iUg{[Uل5]}`W Ճyu`/׮o!{]GNfOeYtgTׯ`flrYWΧL%ԙD'v, M>v _/cZ=z]_n1GO i0ִ^Qհyȭ[vZjUi#6}+$-t5)t#cu?FZ3{Ί>('V^ ,k17^~mj4mŎt|=lw'}wwe^=(m cͩ|fM67 :JSO_F g)~_;90{DeIˉDNN } ŸBVKM5jzzFM(LJm%` %jfҚ,ǕKMez|h]K?㾩?Z-V|'VaF3]ǯOֿ6㙏عzZp@~}I/rmK:||6q-ΞW'kϯ}aU{i=.'zy}ӱ]o4s/ -]K{\|~뫗yVtlb [MF(nד;&:RVyA cCog.7'i_uO^nꨧ_mvg|ԴB9?q}ڠikuؒ2v1!PKuJ'J&37lib/netstandard1.3/Microsoft.CodeAnalysis.Scripting.xml=ks8߯Sq[6ɭ8Y3ںIH…"4i[~$HQ6%d4K"toQR"ѧU:zRD X p#^~!0W8gWF'9jG1_獒 etO&I  YVP:5vyKc_R[jB^7o T_>2ͯW`"]wĤ嶓ebTĮ wo\$SXO%mLTܕT Om8)"+ j|y̤_G#/~ʱ_o5j5@BƱFdsI6Vb1v.}ϔ|4l /v ~y71T }%X&i{Z(^< M29E=D2kp\R6H!V*Q1`@Ś6Y:0#`k% +-A `sf@M__,g8>#sIՔ崖 &JĴ4JXYŭºi\N_GtC{V֥Zȳ!C@h:] &#M `ڎ 5V7M TҨMhh%UKҡ#R#6zPH`}/Rzbn\5݅UX?Bߪt-֞!/e]q *ζ!QklfHS'PcN}FPqa|&hbu樸dQfSKN{}Ѽ8X(:<9L ӗKn"Ejw~0yS0=\X~(* wF@!ێ,k^'ٓ*Ķ&9AAbbzZ"B1*aT:P LH'F2T@k 鈃7x`TolD)98@'}ddz[]dҖQ-l|l՘"<'FOw:U#]ծjoZ1f=HІ(Sb[nf&f0GOtv f έR Lrì~1ޥX&Y4ߙ>GiJ0"Pa9ZU"+Rt'˱D@r,u7ę8p{0h TGH2 f$:ɽЍ4b)Z>&N7A(qwm\L/ǞGBK9*l*` G U],HS_dLdu_ݰbfƗOdx;W[g񹒱8g ;cf/*_t"WSÁˈ{=0E߀!*󼳧B"u,_:ӐC݋lD@i+ܽy`6qv=x~6 Dؔuxj܍1W1xax鉓(?o[s[[rAyF߿z .pL/`XvaDRE, St}k! u%+`9߅_u>9FV(*z)h['gL `Yƥn%r%hj:hdx!U?}KOdU:H)/25GQ$1TB9K- A)M<:~$=>5EHw쥁'+F#}#S&=*5iev 8X;Jf*%W"|_ЋD0N#iRb5K12<>tS@׮gF%(XG|ר'}#F>A({BSS~ 㳦r/3Y1/fKL.u!c71&%#7FFf~&HM`xQ]/}ec,CB-,Ș:h^Ef̲ՠɼnrd*u!PX_>e] lILYM'l(s#b}B&u2k/EhH4B&K+^;d#8ShiZm6V]i K6>Tpq\.W S>1~V=*f[EACj"+*&Hr)l$seR˘L8[]2Y p,QG(OLc=YlL+݆)6"́N޻Bso^VTv0I8s CM\x5!] !0a3>kkiG #ԥf9Q,mIFK3󉕣Eud_rDOaF2%'D)iUޠ^O@`8,qXrߙ5!ed>gɢ=x@sjAg}ki%ii&-UKS` .Qnw5Ag)rP7ypCZi%#lch=o5*5BaZ0jy4:wytupZ~̊.Hwh 4䒅U8vmq2M3 MdyX|,$Qg Xj|%d3sk_ YR6͓n]7Y3ǖx^G5<ņ[B瘢Djn :OlYSu.J[ @s\dPitX@MeGX8[!kIb]G8*2h!ߕٜ. ϖio4!W<uZú l zoli*Ջ?CjoZշlk}ZסY~ 4Ď{i >pR5PeкL{By۹-;}V1z䞤J+!Wg*s2 cCgқ -ܛ sn,/ISҍo졭\2{&|DZ MjTV,r_l_<6 ; toOUͩQ:Dɬt(j(|B4^iX*jt9Dߪ8JNAӸ+KLUnRRz {ՊC^|KkpcFGqZ)(BwAg*Ao6耵cxPNy&/>e3/wOn||*P>nQZU AS]j^ Ť\j39A=<ʒ*aj7YI/K y,'(;7lUhyuG]Ω2(rS,qh[J.gu>EDZJWÆw#@~QA~':> $}Em{! +pf9_+#zfʇ,As;bb"Q gEGB`8 s gPE.fM-Xr=np_ɛ5X7]PU|jMqjsgXF xNȊ◡./;$J .ʻ8(IQPހ&3T"HENdF%4aQA\A[ g2}Cl^?xgxy"m8p2qf{cXP6%< @z~2[rf쟨W2L!#P>~v_ M9޴W' BT/ٸiLڛ:c2k#"kh4DE̞e&pm8nsjxis)E5/p&[k[wdv`鍓 'OlDlIØ~n_~W^R뮨PV_~grc3ИU-t%_klm]⿀m$a?%dW \O ΊH-[:_uWq_Y]m\bfxc9BbpsSʕS vݱrU@F%ONJDݸ-p_] :wҗeenJx1.}%)nAnI)nMKUvֆe^?as2X,2;Lw}TG CYR؁O&4Y#(Z gyP ww =]sQCچFԨ($\%YXo!b{DAG(1׿NtNU!D fľaID S!KqG֘7\ Sl`q[eD%: U{G]PܵpQ bʾ>^// ƾs -3l%Ā՝?n.0d\'J2 >٣'WoLSdbaK#qGMH5+lDzZUw2Ab"ՙVV"- om5DBU<.xrjsrJ̩`2~ֶ+iutwQdR 5S, R,ld#S͌*{!ytM>-m1U;iHL q] ,ҔrsJHY[mHnRtuuUa6_-k_K<3-9aJyŽ͝AaP9%v~Y]NBZ9ZY#K>6y5\ ЖN '&Bt+/v܄6$m0Ԏ) Ï %{F۝PЈ<妳jQMNe7 0oeϟ\І#i5u8x!13 Jv%O-߶04jMX'LtnZ[5z'sok60Ɋխ կӴ2Xם!&&!pW/8gY%[Vx)̗ ħ1ѣ(+Vc!܄zV ohD/V(j!'T-m-[`J[_^{Sf-obo<0fy4 tàngzl>ɰ¥ITۚ uIƒU|_`JR*ݨ{YYf;K-΍\m+u:X-8HJ7,!WfebHdu9i'`Z`UQ@ qt(pκEdQt7trFKd"JӏyUu0QTd9F;_Hٲ-n怇7LTs{0 X/<⯵X~wa+WR6AGvn⛀+>t~FwN:53vJiJLs(88LE»m?NH!!wOټ)XK'Qw'ק !r̦[&b7\7*IC Vm-w8_ /3U0nпY%/) [ u&VҍT~ ~$`QZNXV?T! m͇="˒ Brw"̇A=H׃tejTwWN1[]< p4F*=;ӷ˶B~ DHtTVPxx,q0;U&;[+$9rRL^v:HA g{Va[N 3봏;9ך`QpRٜﺪO^cSC >Dc;_vqF\_֬vG7x3,A#-\gʵ[!*@|`aG8^J]R4rrl B1j`/ÔOHoN FP x%:ʃ[߮}ˆ)ⴃ쵙J]kʤg4l5@)547O\fc/@A+cF0!C ]49atW[EJKW/.V#UA)(Rõ& lx9C W8>B]F㾣f/^V.OkijP(jhڿߴt-q)jn?hK\K|+f%PZlM1lr'颵z5ozJlB> *CN.D@+t qqۜwlwqj߭.R%FH0DwZl]Wk䞦BbeƐ6wvE-&v0Jy#X -J&W歡5{^TF+ szUL;P@8/m5_Z'B=xKl8r=xAoU/nVЂE ohv!]:fYd!^CkUf-^)@OŸL Q $V`݀E 黼%>?`}yDr-v4wZTJK%j-3!EQ#u(@&Zzص) SVxXMgmVw8И$x')@Y)s 8rrCjS$1-^QYo׭_ۿ<+ Rk&&A˔B x7gRYFRl3/UD5MK MQwyuD6YT)vZ^[ng1N@['yda ah"fy-V:Iu'iS_*K}CFAŗS Rk^:OS5m?]8AxZ9luc]cc}p8/a2[;]Ocٲ"c?*g'ꁖq?HݟKR{`R@Dm'`=<ۣ}[yZܰ {g^h?o2t*>Q\]mF=bi*p{n\=nKX)PU}J1Uf~P'1Ly ZwYaޖnwso|L]N%L0y죄enYCԪˬ/)ަeW^hv7ƍ+=@j 8$OdzkF; jǸpewi ]*^=I`yeVDJl5͚Wsl/Ta9uYoy3vBYG OUi.vd1^:Wkr;GL*{n*#-uy41oU\/]z>Nق lxcv՜9٣\*c-A}\AOM-R̸/ŻSF>Z0wWKkV-{#eN4 s4Ojkx|KMBxzs7͠QsU_Ԇq4)[$7j= >7A}feSG_zM+5Vd]w3.]_:!ֳʡ1J%1H#c;`X )/S :{#&Ǚbypyf>Y6wJa&_H~mhu IrPqNᢘ]<W Br-<`}wO£:6EWF'9+ Wk˘;gȢ#Y7$ڀ{& =% ]+?t&,-6Y[3pYx҃;86i[WrVQ 6'`ï)ؕ ށaQèT,qBh(]} Y9Ķ@RD+( 4Y]Z 1kUJ:Ewዀ;;Ыs&=י ^,#>n4.d@au͘$1'EWyּ]_g=Qrw\3xwPKuJ:@WQpackage/services/metadata/core-properties/6b3a751ac50f4fd3961a5842287b2d52.psmdcpmT]o0}pM6uմR: X$vf; @ٴ<$8>ړ}ot^[3b֍J4Bv=fW&:\:[ =P7JNm erf݆+1M'v)?{D۾{xў^KX )>EyD X' >1_gjL{Xu'L t&Iof#Omز^2v`^r85X',46kC3i B o#Cekk)av8Q APKGM5밙%%.signature.p7s0% *H $0$10  `He0d *H WUVersion:1 2.16.840.1.101.3.4.2.1-Hash:uDMtMSc2WgeiFhbMb2A4AGqqKt8zBik3jkGc8AXKlN4= C00 F`090  *H 0e1 0 UUS10U  DigiCert Inc10U www.digicert.com1$0"UDigiCert Assured ID Root CA0 061110000000Z 311110000000Z0e1 0 UUS10U  DigiCert Inc10U www.digicert.com1$0"UDigiCert Assured ID Root CA0"0  *H 0 C\`q& 9(X` ک2a<(ܟ zyS\1*26vÌ3/(nDa5YvmK + rڞ`Ў5xU m I|13l"2Z9:r1u}"?F(yȱW~VŨ?_wOc0a0U0U00UE뢯˂1-Q!m0U#0E뢯˂1-Q!m0  *H rszdrf2BubV( `\LX=IEX5iGVyg <&, =(_"◄egI] *&x}?+&5m_I[=%̶odh-BbPglk 67|[mzF`'KΗg*h߀ 3f nc%mlaң&qÙQ+.P E/000 _ջfuSCoP0  *H  0e1 0 UUS10U  DigiCert Inc10U www.digicert.com1$0"UDigiCert Assured ID Root CA0 131022120000Z 281022120000Z0r1 0 UUS10U  DigiCert Inc10U www.digicert.com110/U(DigiCert SHA2 Assured ID Code Signing CA0"0  *H 0 ӳgw 1IE:D娝2qv.C7׶𜆥%y(:~g)'{##w#fT3Pt(&$iRgE-, J M`IJp1f3q>p|˒;1 WJt+l~t96 Nj gN %#d>RŎ,QsbsA8js ds<3%00U00U0U% 0 +0y+m0k0$+0http://ocsp.digicert.com0C+07http://cacerts.digicert.com/DigiCertAssuredIDRootCA.crt0Uz0x0:864http://crl4.digicert.com/DigiCertAssuredIDRootCA.crl0:864http://crl3.digicert.com/DigiCertAssuredIDRootCA.crl0OU H0F08 `Hl0*0(+https://www.digicert.com/CPS0 `Hl0UZĹ{* q`-euX0U#0E뢯˂1-Q!m0  *H  > Z$",|%)v]-:0a~ `=į* U7ђuQnZ^$N?qcK_Dy6FN\Q$$'*)(:q(<.%Gzhh\ \q h@@Dd %B26$/r~IEYtdkfCڳ  Ι1c=OƓIbnS.hlD2fdQ0P08fWpuqP7b;0  *H  0r1 0 UUS10U  DigiCert Inc10U www.digicert.com110/U(DigiCert SHA2 Assured ID Code Signing CA0 180410000000Z 210414120000Z01 0 UUS10U Washington10URedmond1*0(U !NuGet.org Repository by Microsoft1*0(U!NuGet.org Repository by Microsoft0"0  *H 0 xmfAVԚdڙGyMJX,YOXCZSe(xk*kRDzZXz%|ؽ~%`Ā4_00U#0ZĹ{* q`-euX0UݢI*k\`<أ0U0U% 0 +0wUp0n0531/http://crl3.digicert.com/sha2-assured-cs-g1.crl0531/http://crl4.digicert.com/sha2-assured-cs-g1.crl0LU E0C07 `Hl0*0(+https://www.digicert.com/CPS0g 0+x0v0$+0http://ocsp.digicert.com0N+0Bhttp://cacerts.digicert.com/DigiCertSHA2AssuredIDCodeSigningCA.crt0 U00  *H  h5Ix{3G:鮑CL!eT ogM3J(UmŮMW[!)^ʆMYlRP{xCQ(,(E NNqp`*k2GNX':8LBүp^p7HE $0wq6LSZLѡhSǫmQ iCU'^S8H˗y"M7<v>s\|z7m-8b,D.60MȌ1*0&ݢI*k\`<أ0  `He0 *H  1  *H 0 *H  1 181008045351Z0 *H  10  *H  0) +7T10 Microsoft RoslynTeam0/ *H  1" čY6rrښs(uA05 +7T1%#https://api.nuget.org/v3/index.json0 *H  /10000  `He _8}IOOݘFv !}00vt0r1 0 UUS10U  DigiCert Inc10U www.digicert.com110/U(DigiCert SHA2 Assured ID Code Signing CAfWpuqP7b;0  *H 0гu]T^\IE-gւW_;]r\C(-bqIj_ gFv+N=` Wʾ4'QXd 4?v3}/Pz她Wk/ETy I9ޠ01 0 UUS10U Symantec Corporation10U Symantec Trust Network110/U(Symantec SHA256 TimeStamping Signer - G2H00@d!!0  *H  01 0 UUS10U VeriSign, Inc.10U VeriSign Trust Network1:08U 1(c) 2008 VeriSign, Inc. - For authorized use only1806U/VeriSign Universal Root Certification Authority0 080402000000Z 371201235959Z01 0 UUS10U VeriSign, Inc.10U VeriSign Trust Network1:08U 1(c) 2008 VeriSign, Inc. - For authorized use only1806U/VeriSign Universal Root Certification Authority0"0  *H 0 a7^4bXZ##`אzX8dqM-siq9M 3I;Kሙ3ǀۑWrwͨ 7jK _y5x2#2AY>+m:ɜHS6xš7w0s0U0U00fU _0]0[ `HE0L0#+https://d.symcb.com/cps0%+0https://d.symcb.com/rpa0.+"0 0+0http://s.symcd.com06U/0-0+)'%http://s.symcb.com/universal-root.crl0U% 0 +0(U!0010UTimeStamp-2048-30UcʣNrৼA)8ub0U#0wiHGS2vї0  *H  u-4\2EOxoOȁ@)]Vdq0*af V]q G̐/ lN3ִLcH9@!n< ɏSWA/MNxlBna\RNkJzS uu.fW:Ί۞8R` M'm2?@Ῑ9+ZXU}ǚ#*a0K03TXAD{R0  *H  0w1 0 UUS10U Symantec Corporation10U Symantec Trust Network1(0&USymantec SHA256 TimeStamping CA0 170102000000Z 280401235959Z01 0 UUS10U Symantec Corporation10U Symantec Trust Network110/U(Symantec SHA256 TimeStamping Signer - G20"0  *H 0  \B||c]ߏ)ꔷװs J|9E" :p9E\EhF$cvl*VRq5F#H-͸v#>\ie^}.M5B(]rB DG-XD wCpnRqٺ"U훝;^L{ UN nGߥQU'pL*KᱹLUe_ixf?00 U00fU _0]0[ `HE0L0#+https://d.symcb.com/cps0%+0https://d.symcb.com/rpa0@U9070531/http://ts-crl.ws.symantec.com/sha256-tss-ca.crl0U% 0 +0U0w+k0i0*+0http://ts-ocsp.ws.symantec.com0;+0/http://ts-aia.ws.symantec.com/sha256-tss-ca.cer0(U!0010UTimeStamp-2048-50U r)C/0U#0cʣNrৼA)8ub0  *H   \Z^ k; lũ2ӱS?׼R~aԧɓ5= h ]V";Dz׿mQ2#87S+z+Mlz3|k X!e%,uɻ*h}ϣl wM1;nPBvrZoݮ"eỲؗGBqFSԲգPuHAO2~͕=g$LA`2KӼϤ1Z0V00w1 0 UUS10U Symantec Corporation10U Symantec Trust Network1(0&USymantec SHA256 TimeStamping CATXAD{R0  `He0 *H  1  *H  0 *H  1 181008045351Z0/ *H  1" :kaƲ̈́f~{407 *H  /1(0&0$0" zzGh"o+L^kKg0  *H  '.T95nc9,d8r[cW5j\T`fZ\D+RӔroM.L3.OTՍ<61q]q=A0ظ7s]ާ8-\KaR?oR禝36@gL'`-N&zUMAϹ<۳} #RWD[,RNh`Ek[QtbrFEW?NV>Anr5@LagdPKuJ  _rels/.relsPKuJQ: .IMicrosoft.CodeAnalysis.Scripting.Common.nuspecPKuJ=amE7lib/netstandard1.3/Microsoft.CodeAnalysis.Scripting.dllPKuJ'J&37ilib/netstandard1.3/Microsoft.CodeAnalysis.Scripting.xmlPKuJ<C[Content_Types].xmlPKuJ:@WQGpackage/services/metadata/core-properties/6b3a751ac50f4fd3961a5842287b2d52.psmdcpPKGM5밙%%9.signature.p7sPK[kAnetcoredbg-3.1.0-1031/packaging/microsoft.codeanalysis.scripting.common.2.8.0.nupkg000066400000000000000000003132651457701673000276450ustar00rootroot00000000000000PKLI$ _rels/.relsJ1$:I鴈+nj_ &'`s!'- XE]q~j] # ƅibgݬV[8Rwp 龔d &&ubc2O,)&`-=Zx;#F[EXJ_0o1xpF͋.ֶ14 4%Of[ځ v.I <eTQL + E#;ZI/h;$FKơe:0^|f\?PKL#;V% .Microsoft.CodeAnalysis.Scripting.Common.nuspecVMo8/a.4-di- $mQ,067TcaRB]{1Q_'ؔ >ui4O# B4H) Y1`-ehM-ggo=p(.K@W:zm<ٮY;öAQjHOq{\Y4t/cW)SA:>do:N9jNpKa, 6p6åt=n e^.m].ذaSd10NGco#F JS_VՕў6ǣ{+(ŗ18t¼R&C%?~(A3gl?Gw }tR.q\ww>GnnHl T)OaZ-l@www֙GC4+PKLB7lib/netstandard1.3/Microsoft.CodeAnalysis.Scripting.dllx?>;{Meӝ$۪"[,7mdcp6T S,K:7 5{B1@ @!${wMXμ3;NV_$t!A_-BXzm ˎSwl="{1uy{|݆[6m\Kq=(B,tѲ~hh&DPuI8엊n!_%UxzP?}\wfD['E>wQOrr ;x~9^--ٞ!WIax]%{.!Fze7v%C3s?&vMI!Sj^H\.f!RC48Th#| uC:t2/blĎCNXtƒ?Y;I|'*e2t]N 7*Of KOrtDOp r :22 Px)FVt) :>1ݱӿ*ߔI4_@!J$8k"=KqH)X@^];3"de@d&D2,؞ x[\ paF:Tl*=?Pl4T#Phe ϖuI :Jjh:ܾ1I v,0T1xWkS}gSenSڋ3"!?`=gLC_|C(Lc)2BjKEW P @S0U;MoDoTo_V&YS׻+/F΁.NߐK[o'n HXJ)6l|} }e Ő iXͱVڋ9ayXωM^ۛ "5nE ^$g ufs̚RgD?yҙMj,zn<5')6Ds!E1{_/?)4wN-dVO_/@LhݷC}?{Ff{: HSYY0+0^ɤc^=(zt`OߏHQ.WsX84`u{rV=No4D 4bΩB瀗)4;;IX2O-Ӡ˭R3-u&PeA,4ulw @xSKs{.R~UfA-z.@w:rs,B);^O0>5'?EcD3K|u.^(s18s)Fep&(f&[vi7|\WLji*:qtOָz.D;{@Fǜ p^_&[w"jh@h2u-kE81PNƒ |;]@|} ( R܆99GnDw?_д|Uú(Y6}?Å{4=<'ђhJ$12 \o6M2GfJA7O7DHF'1M*LB5ax.Mu@vܱiM21TAQ3cD6TBlP-s/g|#$}aau^F AVWUsbkYS`'K`'87zH?2FkQJ7%z'~X uX;lE2NCAN rҠ*#]R29JЃIOӃ׃CZAQo&+Ԡ)=ب ӊE <~hj'VdGX*_ba 7fI:YfhEY1 *25q,GA1=1tS!{ c{ pBcQ{ c-{ }oEƞB'1g?ZI>%H'MGR9;#adi):OŲ XYaJ*@W;@NGn- Yy>4=߀M ZSh}g'?eQv쪹 gz<LBf64`d@ӟPCPќapbsIJT}Pe-jLn*##= %xz^EU2{{?㽤z-Ep_*/-r?aηpR\wyDf>5>OA|@M| (0~ǔLQ@Ay %VMY\#5OF*F xt}[挴VeS,:ӛ;b0kpmF5l UFN-jS&_蜭jMx{h#οѰe­V $ M1gF ֧9n$^v}(?tGۤb2p5{vwǢ$A=,b3dztEݔ5eLFƢj=y_mi6j.Lzg~Î[,ywfOuGRbILZ K[4Xr8 j);v6 &[H.c #:Uԧ$ i3iURۆoth~>Kp赘5|J&^|9`0|z$$({e/r'klol/H8; Rυ¯%\eSi_N0։d2hGJwfLwo)F2 t瀬] GӃa)/b8$=4^ۗMP&@Cf7|ɼSQNN@_HW-tBނ/;u XP vje% (޼n?, 1[ߛ-Z!Y T>|jY2/8e||f}Y&{zNw5uɪ[t(MbXҒ)/I>S@|@P*1" JOnW;Aa_:+]$[XbR*m  )NU T [B eiR>FB]a3V}{z}{dԮU\i'O8&54Ed@M f JP֯0tޕf4Yq2ޓ@f ?/}Ȝ h͙ :"% HG51u1]Ka.{X7: i6FA\İgZAtk;u ?`t]i)!}=gFoCP{(0QG;^`&d|Mѱ ٷUNÒ&šp: bfFStá݌xI*ʔ즣^Z iD3 R5i 隑j5krQx,!Jn*xsdP:4Jcf[ù^tAǞ$@ fYG_M2'ef KC1gl;b}\l,tp"zd/tѨ`,c Q=!P*u+z/,c97Tr,*)ȋ5Ƌe:H^ȢQf[4jp42X|PqCR'd1\!Zf|6͚31lczٻ1eGP8"</7@orgƧ_VyE8>8DZ֕8K6 r:)T5ujpdJR̩hbAkYE=N?3 eYq#2ܽY\aŠ L[V%FLϷjrD z0螥fs6;Sk(7 y9N1D}RۢyFg)?͟Ot {U8'ؐ\zv{}22?)p$հ+%);Di ,j/P~'6R(Q6QtokLN5).aP epAkzzPD9GeSbjD<Bol9^ Q\tG9ҹBC-oTVXuQh9eXy}CUI}_{oD ޛYMǾf1X[bތԧc;q^n.G1ιB]4ׄ{+rProGk/u {<(}q)1%b"+~Ò~_MĹ6"l?!^trb-.E?ԝhv&mN +_oQf32!ݹ+kLMmqئ`rmhak<~طMFxfҫowKmhd/G3 *3<ï,,crkm͐'T WuK[n܏cdOݫ$Xy9|s%Zxmy+Q'IzBPHSE\\m5/EOT_'(h1TA҈DRHيL.-r:eNYfJ%4"1sQC<|7;v?{3Մ&dQ\YI^hS7Jv#M?R|c ?Ǯ &S&idwO|9"$#5"=wzid%g%Wk!왃G/ n d0[KjJ](F|dLH,ʫf4V+7c\"lNZH">8T O1ߢHDmklǫiд\' 8J$#S('4f[@lDy8EӭtNÉ3=%WUVγ?b1}ydno2kr,ZEf˛< >b&V5tzP^϶| Ya|"bM(Ý52 :?GY$A8h6Ǩ`7`|m$qㅲMD%C+zcEg~#9 gt?x*OG(|H+^؟4Rn$wnb]9lA?E/̆7ݙ 6 d@w?T*ԑ]$ Muf,'tZv+ŧ?c0xtB0BZ|u})5H73(c9MZ]h  ((||#˞0,uWF0\N:_P+Xs${{NBM*Ӌ΋?vwcZbx_Jg ms4]9Q4#AqpEYf>tCfN};SŻ<Vs6u% ’5Owh^Xg|"j;x JktJ,ohyօ 7 Rc;Fᘛ&y8ܠT"z5%䤪 =QEEQG j8qLcKj k6\I$cȉ@\@HB\;& 4=7C w|>d?ƸM<[6AmyM'uзap0=p^b0YD^w!#Q/{6k kת9-!Kau*Q8( R{@wx,vD/#p%Фɖ[!yyx0N@UQ[G dIz{%#Z'UE*u99ASJr8ԼC)q3odl*{W 4oW{ss<2d~U{&!g2V*in_Z4܂[U6GNک|`a}pFAmrz3qa J\nZ҄[ij@TiIK| f*InP+]+f3ao3Jv\ēX $p%M!:KSw : 217R΀s*jz橸wv~SR$w.͑'HuihpyZ.Uܹyd&wr@aby^ÔWrpx f2ȝ~-! 9ýR}}D{T?KY0+F.%( l:,kIB^I#)8oxq('ۛfӕXOdP.o vz½IBAHqwx3~V8$!l+=bb0hZPmgi 26tX3wP-k {TeK1Vm;=^PݝyRdCXF%sTD9 *\xف4u6wP4=(r^~ 2hQS<ͩqX bTfNXDZns6pވw?KQHzʺr& {ׂI>褮{ΫTOU4RkEf6VGߩ$^?2_@D)RO5:Næ~ D:w񷨨U=D,?c9zcOwEE}8v/o.@ѿE}{m^_ r7{Q=;^Ԏ>FD<8t%#Lf \NY!3o>\̑88@ߝG ^={rF1]KHDulьkGy 6ኊTS(+ol9\AW!]9 ]S٬,屘陿 G)O ŮtIF4L d8 ".`BmNД-%{4QPvI*tSH9qlGJ\F?c=nX+z:wΣd3.e同A\2X٘e+:ɐtW@5Ɠ2{;ٿ*%Nƅ}M)"/y G^B,Mϓ[~nK#z~d ?{ "BI ʍw䗅NbIS{Z͟;@t,Ktҗ FA CC҃aҍ``ܛZZ8%C^ bUi2)N̮ʌt 9o)UIXsd#_0ppmew` YMMVHL,;A7Adn_). ۿۇt]ˎ$xGIj.~r]u;@y!d0iDRߧl4#zw_Lw3Pu5v; ouu;OW!+u&LЖ X2PA"~i&L<ߞq89?3)i8'bF`nQ]-fva:H;F(cZԗm= %X2Mdm`ZHEn$XqPύ-9R m^4*4#V4X{K ,*cElj~8(Qt KQss]X-Jʝ1֏"ܾ1b%ZL%6>x"Icca.~%c=NLg\?7v5+qL욙a;f1Osskg~~_(NQo2v5e'kݓx i1}wN^XޟBVfu=]`#-"ixi9RQFTriw{&sEpBOc6ٞ!L#s@H;)&:!s^8_z~zzת:烚*?]#*D}ߣ7ú皩w'Sɂ$YbfF ߿{wp3_=]ib??o/]Ƌ|{z=$uy| b909Ub^I||v&OEM>Dx}kܯu%so^-޽h?Ou<,]Dzrֳ)z,.Ҡ{g4̞(6OYYg*,o6of)U/ .l/Q7+?ImGIDP?%F0GY. WJ \ ޢvWFoS"6nw.A g??Ɍw`&.-{/Oz"34Ϝp[=Q `Y=${_8R%D75U) e λɹdT,{g<8$|JobD,R2M6wh7ӱ1E0ꫂ+DbWZ%S!]xBT5*WC*2+<(o1,;Μ|ɹR0x)'iO>ykJ>yʏ^Q~® x\w\&wÃȹp7] A"-[fa^N!;Tq6NVx(IX i|כj*7e* ibÃO`b+ ޓTTr<,hoSwo쇶*lk Ǒpo>IOLH!0ӣȔ +:~Qȱ e HqnGw48"?>>%6Om d @$aB(&C"_8PΒX|_%Ue0ewIfO$@|yM8/^-Q# 2 g[z@3jX$'Ē?Zž)v&Ͳ攩;זcP\caqZ~ }ps/*lf dSɯ9Xf-hU{iKƨr4>Y;d>-+8p3ʫ/ *7^JV%ajOn_vARHC2ĉ屩M+ 27*EBh|sc6v8-i(/W;:2τMc)-2m&> 輢mJ%J>,@.%z47qc,m*Y*tu"'j|#IJBb'2\]AB)+>ԕ{9N˛BqD7DZ)iID,޲Au#`an~J ֽ\/۽*̏eY < ,ۤ3ph$rGEkTJ h=%E.Ɩ$IZ9w>v\I ׄܯu+ŎOJm8Hڱ* G;NmCù l P̓Ut3%m&4!P&71N[wND<,nfbI|Vŝ(a;ț#l-)d:Dyi]n_1q; ŏ&wnWbI7 -_"ufyKs.+ U]ʚXN[ŰX){aY5>;8bz{ʵ)/m+Oe<qiXfBijC+Au]4mw#2x/hϲJ*\;-\˷D&Dڲ^d F DAxBs*!_*iWTҫL2^U UIS|*~v#৾b$r}KQ&y7h7RȿDxWf/ wn 2]2"W- t[ZϫoUٛsv Fi|qV/4XSvʚ{(ͭ'%'fì|XBi`e@ JަW"WΉוGxúֈs\io-u>AeVQnV gp i4t91ufϰX <~y<>G#H5DS+,wtk@raM(2cW~S̨a1x;}c@A9lD[hə̷Aq\rnYP}KtxoɰշQt8UI/BG~هw<2?hTw.>Q1#o p,7IêT"W[$G'6e= YJ0R'K@% BЄ3\ĵTKTa9HъZ<'vGVg Zaֱ6,dg :Rog^Agy'3;ZE"}֝7qQ7/D~Jkk>z쉦HF l/vwL2^#Vmo~~լla5:͎Qg-atDJEXX~\ԭ@ԬXzF٥OR7'!չ@,m ︀7)כ$ԈX<4`yq6ޓ?c欺M*Tah8_j0.(V3k=C&90pɩ9 l8AN[Ij:OU Fj=MM{fy0.\N+5;_waLMsvr:t{v*ÏZB_o3RmJLWʶ8} p3kz{ٵġZWR!Ø6\z%U{T".kn얦h配7IW28]S.Q_ {]6KNu~*4{Iv ـK'Lh>? |i͉B4 ,}K"7g UDa,x k{o۟ཎ6bM!lTKkC\2͈MDF0Dg` o}@zxJ <ܫд)7|<͍pcϻEb6b6o6VSa{bńB$wIdz"2aOBbye~$0G½&>Z-j11/RY'ίp&{ƙݦ8njB(K]#Nh?]i)'֠OM4"ե-NK6w'Fxҕ3oyŢ#+oXY,ػk^R[cż1زEZA8ccuh[: ZmETq29qEr$Bj($LϿ"y{vA{Wկ6Q' ^#ڊųK[L-C$qZ'"&>?)z뿜R#.!:h/S|nv=2Tğ.]i-K>D'QTL|9aAFlnD%W-zo&bU`bl[L<2-FRnW4AD\}*/4QMD}e(}\;'L\Z;!|ȧ)pcwL%܏'Ksaq_} ͵3DqQm)C1fvC"|VHx]r ŵIす2D@UALHmC-C˫Վ`LCA;!mSAFh*h"%sM] ]qLKv%$Ԯ. UUS/>jee@r[ŌٕbQH*[3I|XE%aBҚF1s uDq^no$wF1Ǒ(zjw}L^x7VU_h}g6/ȭ_QHxyro-R š2J^q٠-nh9bϨ=Ud)fG)䄢Q[lve0˞ɝ_ jF-\/zqwai/)d{E)y_'Kr߭2kCUqrm&W^^NBŒhggU|:5_5fVPH@r\OLjzqa_;uS￯%wE鉵Ī%Uu6sv?ʥOJ]6ZRpc fŨŅ;IKGY|}v1nʥצwEgRMJ? ҩy+ЦSq-.vqYmuU>3:7͸\bIn,G[X9KCή1ŝms^o[KNtڸ8[{爪^%aϜ*:!ߐ{Upa R >l½/8d!XpQx_8 HB3E8| OHB3L,W^n̵c!7oY&[rbD-^9iyܱS$kL?FSt4qڊY-ǙDO[ln(\?F BY}&\҈|i<5qX*m*M2]F+2ŅE_:/!iHS8a]g]3͵k fSC[b\ť8m-pY,լ`\uuiC{ALmQ$K[Q#̃XOB#mv8]<rQ}ls^KNjj?!,6B>s9KF4¼]ENq1א%pK"O3=;tךWP]w%Νu'~ КG,[T]PFV!C΃ _?~vqݛoՕ3uQW. +ĕ ]Lqq$Coz/WwW5bg_[MԊT.(+!QlTvXS?F\A9׏ۛOitXAV8qY^?^oRwM}8߃Y}M}x7O#'y3Ѭ#ki}~XAOwU>X|T|u CU9E_\dþ>J/7tg*k/>ojX B+#P 1 {!E9DSImnXCK/؂gpyEe2_\mLgj1.ާa8VaGo ҭyqPNL)he 48N:l1 Yi:0qx:/e9uGWy>F3y,9*(hz#ooϬ q:A{Nj-{ [Ł-*ݒE4"񠻺$(+~"NR\ xq5;.lU{z%RqًMp&p-}-~n,Ak7>&'AO&愷[j9Zz󼳬e\zQ|9ї4(ry:|oKIu=1&QVWd'!YG@%@[2C22 3 %(Vq_PA(u XUB*j[.(9g$ؾ9ssϽ}{O|PqՎL!.qb7Zߌ{{C3Ns33Nh_gdk33sgXP>MOȤ88PuMetSY YKa['>b+ݡ+@wh,mET{ܙ|Z٧̡Y6{+]1uƍ8g[Bz=zlgM R.BQ$3hOF4UCdDhBODc(tHDO(8 VB%il~WH刚g!@#D覈3>cϖmgV{|җԁto)e|0У_9 -;o6sE+V"+\:"+֠ЕoY= u]IH3lD/ea{ gEDCJ%zR4gҕ>cJx-*7uWD ҅Gg Ok4]0XQ6~=9PRDzq;OQ!ٱǜ1a|z¯̡eg%Ɵ!%u y{8?WGT@ݥˇ$;uT;De:hY 2m WLf9b0/r=Sl|-Z.+KyBcG ii6!zI+WeX7OH~|]z6eO7u -~d| RѿߧЄ7/F:~9Wh[~TJ~iLak}r*~В¬v9O%A J;>IfN>g^/eYNެtM٬{VMVqٳ:̞_QE|7 > O8`7eQ9ex $k9*҂l@ }|Bd#S%kbR,THDZdHYGVwVe7nR%ˀyYϯSRr!?`IJo܅/EK,X.Y.& ]Oϗ=%Y duIO֏xD6f2dlޖA]u9?]-+xwvf]'ЇwRi:y_NάJIֵS/u[":>A,ɺӟ[d lMF5)rw+hJs!9"5a`^g2軸Ye/$ a39l|^,RD*TQBguYw eoI4k)"y繶%u2by~D]|{ 9v(+H6 ^T^9=!xJaYqyۓR}/^&G!, @fKDDfxYnyBoY׼+i~DlMg r껲Q$j3v G!˳+8j@Wq'W=4zկ~cmG2!s~';$ʝd̢9U]5vvq>)|{oN[5ٝzvIxuIsߠb-\-ki^М|BZ0PDTˏǟ{V=rdλ*EY93 ,F!-u(sEss'Kį(#>? ;dOeB,+wi?Gf&U;uTO)Kڜŝj?NON{!S~ӌ3~ӬfM|?R-M4ksnsu9rb>6K~L2cK?EHY9_Ȑ/f-hlgeH>mAKrο<[{L' =?uSwz;r xdT}@síhO:Iho͂~iAOXг9,襜x CN5'łI䌲/rXqfZPLnȖ~;#)7G5˞'vze'^5(4A|'x>g>kDV _cCЩ`Rx׏(̝(1#'ny]qhĞ6rg _"w9bB#ܹ狌D-Z ^T!ЦlН eߚ[!?sU<1*(k~iuUDq7j4ӫU,9Fr3Vʲ:ubCDy0^ܪO6==W<"FoS_](KԑZnH K#]&J.O$!/)lM6whS;As%"[.tr E΋eqۅf_w+. +@y O%\M;']%bnO$Kl.gG.[2uIew eb!;t_.l5yWV&d}{ԇoo+t`Qʕ"{Dߴ[!\emAQ+@wPrvH75]-zo3-g׊ @d^rEŋRv }w8Pg "()@ލbE|= 8竸\M J>(ξYg->">3V/`_z}mEC@#waiWܗgwmm3|)fk1[Ͳ[e EFH;Gm5?<=bBW.x7k08e||o E+^c+^&3ݖ^hiOL4+,u-}HqYڇŮ>,&_!KT۲?,f_aaQzYڇE}~~d+>,La+mfzh3;ߎWV7_i~@|~qZOWk2*O^%{A3σ.W(KLr#bG}*dBG-!(Z8}^ZΞ)WK^z/W=)&]m}3^Xd yP[BkThOAj3k?ּW M̯ך=-0{Zau!?,~F?#]'v+k?"#$Wnω:˞o[wu݊bDȹ p_o^/KIQެϗċ/c*3%q {Y8B/^HԽ"nD}+^,!_*d&*J|DBM'K$NH1g|8.!9bIǮHpyTS:uQ}DoS8.Gg?E׊n?!I`tVXe?7\Y?Cq @K?>%n'3"nD)qL۩_/.uwf0]=?uxM%y µ M,ԾR(eڌhmn,)-RY]S0L;yDk#џk {$vĂ-'M-3POH{2ZŽf=r뙬>ovȢ=tKDUX턡T0NJosx ?y[>>^[Ѵl6^{L_^0^˻O!?.3sL=G 'STmV/쎂\mB'Ş<>. _)^ O|BJ{sPW!_(bmJ|rz jR|[+bcC;fI-eL)Xr ?Jl,pʋIG-kS|tvxɿxE޿ӌ`)ɕ@Izgl5WdI&]OVS"CZtb})t3#+=,Md5/UhFjfr+G9Mu#S;s1"y,tif̒e &Lj/DM8S3o#PRh{rDBQYZKIEl峅KΕ5H4N5Ҟ'{~Q?$1CJk`ޥ1L~_@eMb%%2fN|`M*XHO^ii!/4i ٘6lx6Mbil-;~cr46`E+_6l>; fE~kAL_2*@VJ6 ~7~=[0;_=pG/TbAhDR@Dz$?A' ?d'=2_4䁖,3PέecA4Bv2cID |q蛻xQWa:;i<0糧쾆U~Qf~$~v9@\^ _ke={z!++keٺlvMjIbM"~0OߒSlb}۾>A)d,nc=`o.?tyQGp.`'+~sWNmCF'}lm7:j~&cmo=^ 4,cb94ũ=n?ţqx1B3}xf4]y8B-Zz/m>m# ;'8_iz"1oa7X}2:I\EDSm;~j(*imŸl{y'ǴȿSp.8<.qϋG9N:O5rqȩivGR܋4;0| HV&qw]Km|l萊 sͲt{s|?g^xw38>Xߛ $9tvsF:/mLs|,2lL; :ͱ6f)s;i2x*e$i_tUSKUs|w;b4|?No;9No;9e&^ <\#oࢹ0[Fl8^r`ԿQ%c>}ڧ/ Þ-0hRd/u{cK}ߏ|g)χ65a?4<-${rE6:sE6cW#dulN7rLҏ"o;.B[Y10*'lrDkcuT/?5#쑄50gmyQTC؊}q>u(.o~~c~UT{r|/^T{9ְw!9E=]㿋:J~ۊiZNr[# O3x(>:'⠓$nO} GHxoxxޅw-/RX;,97oQ=I⌘OQmi#&-gbuQҘOR? 1;bNSc-Mhޗ\08Ռ-"N˲GzY%1k"idlhO.0D!Fx s<;,0|2b(U& eW a¸k%e۴Y2mL`:~)ŝ!8Rn2C7fhsPG84-;N4d[Xk K# F$n$#lDO`n'6'Co focMZ=te}[* x܅$I$i7Hm<#gq =j8áUA*8?8=iذdR v 7qXa@[>m06|k[[1kmcoBY{Fj+a_#lW #}kK9F%zh}WѶ%+rƞw{",?}~L:&T~ =N 6i:E%:NN'o*k011OLnnZFCq>I6(P׫],2s7RoO_8uvf#f-*Kc[} ]>1n=nY[+]gi-"zehΡC~GJvcYY:6}Ź,髸UcW-VF/9WDNצۻGBIwONh׆LE6 aۗ^$5l|2k-r1g7?_^7GKwB{JgLR6Z÷kGj^\ ٚk\j_9x>u\Ur[N';Lwn2 T_p\hsGk-!svSh3lc÷];9Na}?b .S 7P ;)Ʀ~,7hOYى9Bdebݓ!q/ߚxa86JL ( +Y ;RHpV7GݶfUHy!1'ѿKP^⏐bܲ52qQ9鶈Gg}vtzlR+ĜIV.Ni2o㒰f |KUf$akEI6> sՔ #U)f:i72 hv%+΄I5Qu,@7>n֛'ۆ|E$ Κ#oGœA{_4P/=Bq؟=ܵ8sR-9'h|d2y$<vuR2gQvǨ`p[ O 'l(?aqtkw$?q.k̟fś۾S,h}Sl(mJ~ 19J[ yk8Ҝo FӚM᧩7,䓳qC͆6j?rhku+ቑylK5{vkخT-%~DZDہq)i]no[b6]6v f6T <-f[VƖQ4 TW;P]mᷯSnP]͠vk8C:6wcsoF]> >!* Y.Ъl{z [oݛx#3_yge~G1ҾAc;vfpnT)P #w.}^zRoz͖nÆÆr )*Gh\l췭+-۶/_~ koöos ,c}: M &/}x./Q`1l:&2thnd<yF) ,WϋaXj1cS!IFE}T'hNְk?~bv'HD#$:h&ѯ CChmH&GF ?&k/(~m 3/&o%~9.į%o#DwG`~z"ő͑x󣐶FalhD5-5h!&^/,di$qL;ROO@:s'C7iTMCz _Du6ү ]>s^ZVtG9ҴJQ ,_PJ@@ث RnH߲ jG%h)l\AwuL^Ӑ:l(bC~7񇉞 TcD:n&z 1]"R$:z"D7%%()T It.ѕD7MDߞN0D7ES DW>ZM!Mt.MHw}(0D]It]DY%!:J*IB tDW=k:^4ꏬ)D4  q8(N*ߴpV۝vMaaᯄ/눨aDvG]u_Լ蛣?̋s8/1qCF Y>C2m蜡UC]?tл 6m؅v fXA؛b_M[6>..>~r[ K$MHN,Ni7 i)kRLٓ˔'S^O9>ucԘ#NHNKOHVviڌ+]oIߞ7HfgQ0!l(3al"lƒt6r.XV3<9g,ղ\ֈ5Ykel ; ɦ6yLc3?dlNe؅l7eex^qaG. w 4! O/+QHghS@g g|hD!zw:қ!z|2Ң~G#-F!Ґ~OEH_AV42 #mm / -]Ii c)foN&z yD p+L0*S8üAtѯ.{1|<{eoA2Z$@Sϑ@?- =S06x3)1M1~d.}U9UQcxF,hK#+F0<¨Ƥ`l8>4Hױs|Un*؍0^ F`7x|UnQ+0f ^;NW];v)l{`,  Xe@ c[`)P~ykT` ~Ξ*AW`C8{`o0P~͖ P}Y=39Ԑ``u,jky|=F*X"f"b)Rf| LOˁm@U@񫁮m;]oV7i~;^~ ]@/!{*SlY~?Ыϱe>7e~l/0/>z}? aG@凱3x*?ɏ}_Kׁ *؛* 3*;*OX8H*7ub 84Rtxh>sŇ@'N:S )Ķ(Ԥ_|4 t[DS[sδ:6h-\[[2Y@ BV@WB BV0' 9 S6$\p} %|`OM\-qG⏒ )91>| zxdʬ-5:uTT_SM:U1vD׈#xxZV=ri_%3>m-ĿH0 XB,?[eHNZ!y8^;ߣskzxo͉eG ]5Pv|]feDp1e1Cvb` +s`2,=r`S˄!{9a`?65i͌W<;^``i[pW1Jt+_90 Wo [jkW sr̼06&q[`Zfݥ[#|9V ԕsZkOWzuA]oR[u'j0>+ wOS-n*uɥ;u=IBR5M]G9B!3Fݗ)d2΂k+Kt~ms0֊8=äξcMkv-7g938=k#6^l[mW#~ ag#{ώ G M$1_t΋gF')Q~l:bq2{dOL#GïE G4 [,gTuh;u/֦qq[-TҒ!X0:(W-),~Y[`{'~l[~{~ l^{$odalgALY/'e)r%]^+0:u=\oz/'~޴I㶂!r`]4mℶ lvs߷ju8nE@|"rAu$܁nAw;.uEmmJ_q'D5i03\KUx\혿 lL6MANjV]k\]\@psQ)Fȕ=bKꩃw~4d|^Y])I+]@V9]ޠ;v (QNwsutɻpg <\z`AHL7@]Z+R79J;]k\Nktv]v*!D_ : .3p֗{DzM=܁@q^fUOh􄉃zOAt)m$Z4DΫN%!@sxzh$BO(ĕeS@,DZ\R:*,_ )Pvw@fG`Mz[4 4! 氤~wA3wT.?*~G eP/Aʍ앑Ȋ aTmэlW[[xz'RXeqiyXK7kN$& `V0J*zpiq ޅЉ\Q275JFYHrO2˭R85u2 .XJG^`'_8,6t* ]sb=iu.tUy,eeujXuqmeKqeyUW4ؚ@JK۪kXqSM[iqrVTUWVVU7B貪V)*m.mnkn}c]iySS]cqc鼪R+mkS[EquSں JVEZj7σu 0ʶT5MUՐj3-լ$m-Mu5o)*m[P\UTUC47bᔨ"*nj*)nbW @;VnIqQJVQ)ayc#D]URQQUZT,hЌ:FFF?{qk*on++(J֤577V7ƺ:I-WXꚰH "&F]n+[vULHʨsi9>kevS^mp|~_!\߳ngnoyc@nyQ5ovz ɩLM1.!Aǵ% lrdHAfvu8ګ?M'd E6̄c6I)ef~_KúMDKǪ}zx0^d& oK:X[a!nkN*=]^ Hx֌M/[&@Z;Խ`) ݐ9,N-ހc+WL<Ռk{\Tv&u\oUhNvkk=]i̬ߋM@|:YvyqQѾTz|NhN7H@7m@z 85Ӝ%@so -N һCot}^*1vD$M9=ktPr8k/CWZD(SR]nhU=U JTE탖F@P !|=~Bc`p;Hl[OnJs So7L{3̵=q 3X`jf׆Atr9ŧ00@m.΢4V4%L~n T ZhZ!t,„킋s`^\@#T %$`[ ? Qodf)JZ6*HRP.\PZSB7jP.Ra)Q,Az~@xݣXj1ýΏ&K/XRY|5肀p-wa_#[ 'TZϰ*e?Ô+Gb aj_Vz:J8c ,aԆ%a-^4fKEg050;5kzp8􈜩]oGa3*)ޣb@xtRjf{kr#Q&:+.Iۦ^h 2`uV];zUH^dI8E~ q-5@ :^ Qzۼ>sNk{Uu>J\(*bJA%DcZiioahd`lvJr3R.wIa#c (Zp~_l1׀kUQ1؊e94ycAowBt׃tQVDqv%i|4TòE^8>TwmPǢ&1G[QsGs ؉*FZXӻ/e +ƲWk*nVvհΑ,`=iEm M Nwo[❾v1x$hsp+vp{%Mz  ͡E_J<{0KwLQ0h $hUŀq7rIlk=GխO}燪A颜 rS4ɪHLKP6t1d;'G6p2th,Po,[}j In?^$)KQa X&o^R(WTn@W Nx~a:uY⏕ƘoT]3 nfg ]ߺV neKDV~C7`'@T]UZWO6uy z7Aʵ.jWW@;T*EXtw % ems>魄@vG hHDw])kXSO77}H.oi'tn!Ed0^d`yŢabkqW)go 'Dpa҃-j  S lwjWnLfDSկ"MiI8(EksX4 <%g`KZd:=jҲ(( t}֜ЎMq0[rly E"(Y|{7> bGҕTҫ Jd$uŴĸ/9s+XUl 7H-ozD~xҔN*1+S\|r_#aJJ>}Bl"#9ՌNuUt`%=яRp5VMC7QL!X?Pn+DA`tF:]~_Owpzʥ1U)c CB56Q_A2 i@4o) ,-prXuE@.+fhǷ~Q'֗zz j~_:XH7ITBcy>th& ],v DNZ ; 9vn5cqG[@KV ~@U`W[CaU`}#!燶u]=u-rgj X>Cŝ sl[3 e4OU6l@;!#a4#hԛ"qRӅ % Raڭį$3oz=z:F_m3ǘ ^h36D:k9cg2& zYb*YbNM鎏e n$iB1!&7CͨK=Nw:z1UEk4 |aҸe%>W_7X@x)D $b‚YϮ4ր} :F+%M$4vʂDV} )s{O΍#cU#mi_kC AV,=IЁ!.Ӗ@6:!0X4X?1@VenA``XO4m59"cBG| n~y e1'Lq\h}[@cQ\\,?2qu*0AP@mp0Dh>kі[n;X;UN0jG4V逸,5r&>oֽ0t1q[[7iYJ$BVƓ;}=PU@ ʇwz^p$=lipİFTZ_X" !G[?;Dnju :B>vR;:+vf߷΍؉!KJpSxJPʤ^b9eN6.. R`YXH99sƴ)S Y0x(+tYPݱV ;J,N. mqQ7O:Qo7j,Jct\gw +ۀm~z:1"R{BZ+ĦPҭ\v F_R]RCh\T9Mٶ(`C<;C6ŊGUl=4UnA꯸0O(X˃G%&%*G}`.mL)tv=s xMR@y:BU!7rMi`uH k˭Bg/}r<:F}~\\侟O25ZO ~AGhdTqvдh3$$ YK9٢w ~ծ |: ÏvU_L|$(Y/8zz`)e&Sps4n09oPZϲ嫛+**IYG, 9L149˽WZGom!oϛcjmں2$ٓS5xRA>aK?KM!yH+Dfr_֗BEr!eo@(l?XS4܃ }6>kP;oĆph%tPԫ^J"3fl%>!y"i0mwhFtʸ|.w.tnKZ0ǤWAb *X9g68ҡr6k@PG.q["c#NR{܎|; H3U#Au)Wc'|rqc,)Т3֓n,|2br[[-c_:.e/6$.8R+s!h}P:hD |`X 3zEnU.EدG[2 by` TNd-:(+X2?~4?`a$]\"w*|vIx # ܂7GBT/C`2LS0F>w$`̗Ճ>9=ԭr%O(΢!yxu|_FVI,q^߈(CVug@" 9ȧԪum]eB>'t'&T7kmm%n٧2>$2:2T`*]2s< w;UjMPM mĢUDЪA|9$$n hBnEX7>R"<X0G%8qMeQT ~2s}^:E-ggP-4O{ôKV1O*^1X+tvѤ6}-"ek(϶Gq^vsJANw]|qx;z+Xp*dIBgQhyPQ'(Se#.e)~P.L v/A(=;7^|eUVY/TokY(B||o@*\ Bȍ0䫴J46֪^zL-z`$6IG{p V نɍ8sh&@CRVAk1qf.ҙ$&疀 a|CCeNH)l!]"ms{ڐVAYV |Hɶ>6_C1?#:m&Ɗۼ'jt[:BNdR*ZdXF-镛!1:*k]SH*[d6 uX|rž9{|wsmvZHr-m@K[Br)iJzp3 AD9A<ߛݤi?̛7o޼yf6x{+q| haZD7[ZU6($؜<\qҘr!#ŒMuSn;VE(+U_9x[6 R`93FX\@CQ4غqG u{ %]AV-2/Yg^Ymhe2HM$` ed~[uKu%,vӜk"Wnw^NZY[y? \HF8KI(ݬ~,*.r 5[r>1RHӝQe7l@Ex{%D3B\xjeB b›BdM$HN~\scH=.6Ѝ1"\7kN;"=H[MZ@\'Q̔=1-E|8"䡢+R#4qŲ8C!(TSTJ RzmH-K$KP-`1ԁP e@RJl4+% X2HE{ T|V ΄] ԌJ{C*HXȠY0Od ?x %Jy##hEPIʈ֜Nʨt/ wjɵդ/-gWl%JSiV]$9eF DE!OP9OE`9R&EP04.ÑzF@DȽ $֋Dt*|QW4Q"*+5b 2BRp VcQ >2.v0bked [C4Ê`V"0a bZbF b*cZ!Z:WTN҈wJ ok"6{舢y 6o XZ-* tN$!(o:hChjX)u*̊J72WzIGC\d7R*͂NR")Z%~aY %jh& C2{2*)UJR'JW"2Z0%X8%9pJ¦&Zf34I0FI x@cTM#j)qBQN%v' 7L2ΜRE%(thUAp`䣍F&Ie@w #c|iA轏 Z0 Mh 0 H 2% @lsCv0L"* 0FHHDK!B7QWHp:L8X4%(ZhJ:2%RGsBVWh1 R󢜦IrʰDQ+-(88pnw#p [ڨk4JY0! C؞+v.?'ԍ'[uj|FFw>=ft(/CޖPq~`0l4ADVLAk͛Tr.=}=N7,!?1Vj`1ZhЀc!dJ)A)BkA|PhB]n{7ۘ0p8CuӇ&4=!ZmxOw7Wi-򳁴?4Dy =\-rFN@6-Q@#&)w)7v!% DϨM9p)9 Ez)CCPSx%z_LWpZ͎QsJ (Q NK b60~?(D ñ~J4Gnɜ(Ə3AD+)W> `С2c[GX&\"?$zfP;0H$s@rf5d2^TDW*2PdY’jE=P­TjѤnZ91Yp Ip%S/B|>Zt{ ,@2v@@G}y"oR/*c$"Bzx"Zh^Έ%! c J&i]=5!F(Fzb@|jYV+AfjKldW1h 3'8>0 f%uG!rwT^[F&J2Ae2R%Y'V+dɋUvN\j%pP+Xf?R)H)Jȇ+6HNo "?8 B/r2ϞjI7/P +%_|bFr'ihFxI,4;nf%`_l4ĩBEY "& aF*Qf=%`B DM"Ff*iA `0 8c*aD΁!9*1rFd82**Y"ԧG*tN\"E Y*0M19H &2Bj8q1+ y 8ТHذd%PA1JcOJ)PCGr 2C=_"9,.}AN4h#X8JPh.Sɩ-{CuMBCvY&@>9X]ip }^h V\maeE@&=ÉiPID9R*> h -wG V}KlTps#PVoEt,072Sf4|q_¡7!Fe\ ͒ ԡ&QZ ^K.2`Գt}"D'B\%.>dĢ"D62V?!ACARM%z oO ?@I| 1!|ĶAhX\ Oo4~]HVҥppQ,0 NB%}TI FoMfK Η)1}YD -CTw>\я5`)^Mt"+*%117$Jӳ&y~JHG8%on QY4mf.PCoTsp(0'v`[ RqbH6QBn7 AƂsU8Prۈiάiw }mTK{(q \ > ;DPoi3U2wƑC>ctknuB[]lTQ2=ҮN>ZɁC}xUTՅ/ѺA<1W{?0QO2}} o;Լ*i i #祉ȑX/Zoy˱ dJl$ "@Z0A%^TxQ%/x pK^%/ /QxKc4/F +?ёJbs2JYdPoGvA%|1׊AlLIw8D7 ?c8^(B^TI`dW0 WcW2xUJbl\x ,qpeՎzXvNYWRIN TX#1?` \RCȇiȏ)dNsr`jF"S0 4> pv"KU)==ʡ$fHWPI+PIj&ҀK0  &:XqV /oJ\"=?/8f0UC[^".Q V o(Y^`^e4xOOg!{~r(P\u9uJC1F @9١&!邪 1@L<&8J\U2< P7e Z6F@P\La2zH(KR9ܝh3fz  -k`vX ٭Bl3uPb@Έ3n8K\ZIp k.hK$l-^p9}r%PfD"$ ۝,*mpοv&Ăv2Y}p(vֿ+ a{Htu ZbCNsՂE eVƾvo)s$ӀRwi8%GďjGdA(Wlٴ@h]5Հb}$ m3](92cݚd$>ȓk$Q$ad5Evb!] Ü"О'M)E*bLX*BKs'RY*.&A{KIw$#ds'H0Y8rƺj?Z5!Ó"-Rђ&34 t-zCh`ȋ^ȷ^ %򭗚?l1e9GLM|VPe4/]56! - q?6ĕ&XxĦЩؿ",q,d"^#3 bs, nJL6 R?񹡄dyW/*ep}}8C0-58AH=KC785BŽJATQAE֑ pb C[͡kYjd@^GŔ9> C`h`[$#f$[2╴Iu${*AF=,#ڌ0ߌtрXfSFYЯT!\_'חP$axdT*3.*^LdXWp2O; 鮔*JwtHwx 1t>?Pr L+h̊[EzV Ҍ, d dPCb7i^Im %tA^iY01o@Z^08Y`uHχpD`Fi Y ҂;4EP9xӐ'qDCLOu6SFT[5 MTcdu |%Zeg$@9@1'+QpD6 $Ŋt8 ڣ@0R$a(qA|&hXq#IÿVc@ZBC5\ e0EA!D;X Z%jkdqHVem)bX-m&n610^ӡ`gn0p\' Xb^/V(c`9HjrK"$5,?+U6+hR_OXPLu\f:umm@j@@X vrcC޹VNC>䋧踾9bQuq8 `i@y'Ҕ/g,z#x!BA0[X.!^01fY& sIv L#1N[&*s\Y0;vsNL;&Kjssm<8Bb8mn7bO0 D\rB9ls%&$$/e']Vbs[N=iY-B;m&Z&p;y6{|%>ϞLK&͞`s[fS=jsf9d&8\NK͜gsZDfs9ޗ߆x<.SnAcλ?Y^p?[eqAovw}p_s?݅Gyr+tr>p[{`;];^0ov? C'̼N;"Θ w?'[=qwl= =2Lr%) oP9)x] nLS§)Y( M]25O), FWerݮ8T9.1N7CC)?M&\w#>c8G*{9;nsBduyqْ3;.AQ}h팃²u^^p;$|SW׈&h}&M ̒aJ"R`?voD()M5timuKPx8EᏟv4lM❱Vܱ&&Xb)XyVkӝ $.wt9s@NsBlwkT1' ę*X{ZLit1gT]Xykґh˵ ѷni|C({v-oM3(;ENriGɎt\Kb؊2Ga~'w9mHP~7W?TFd+韒+yS7Y:׳e_N=C%O+kg{6/M${䁦 7Wxb'S+ E2&Op6^wp+N/wsgA~=q"*..WoCŢnB'r(?{-[P4?}W흾^)J[} $h"- }];}]bP<t|Þo:(aJnyI 7?&s-D?Lg|$aJFd҆wB<uBr WVRSڀŻ ȁ~|TREn.^:tw:TF _ge\̺%zc |AEr`TH<w:&Q\\RY'@e#uґؒb "Ji%RVҜ&YR&vS 8h,`emCvѨ T[vaƔE:ųx<Փ<,(vDnV ߼EpLs>(/*)sg_0w8\|y~IYq4<GzK:=wvc g -_ȻE ~Pl|A9$<G#K-d8&d}Dll;rrvqĶO3D*4( c OGC,zZACDd-T $Cr#S jyB|rs7.B HJ3L>M:=7|95-lz,._~ns/d|wVn{#|QD,$M5jl\ 6E:r<곢ؤ8"Tܮb)F0 Dq (S[5"|6xh6OM͸(̔ MfS ĠP'n.|t85a|4M?v&ֿ}!S|VT/⻕[V6pIU]N|Hm^)yUvi:pa *XA/Bڇ5!fmyھG#7uUٶ+Mf/6O{^{zn߭~{/eM{;t]e}%hohߋ_7YXRG?`'~Hyw:MPz8pdxil%VV(T2` Ёo'tff4:yau;)L g?PhQED"$:f/k4v6|Uwەf-__^/ MLʌ=gWTܩ0(ivSV(Gu j+A&>hZc^\`fu?~p) !i? uǪ %Km6_aIڃʆúW} !+Q.4^Z>ڢǪ Wp{ȸ)iG6u3Wz'yヌWffYS/MyΆ /}4fN\=uO?nu+c_rtzwXaMbjz*Z~vdnCtylר}qﻔY}tL=K~Yӗ>xЦ2=;Xצt; ^\=+c@ 5:QDz;fA5G%% w)c+KZ':3 V:l6u_imoyCMyW+#[ܸE?ݾ{Fr{g~Q>ӻ8HՙVŔ>~h۴/od?98эpn}u?oiwbΡݮ:lǗ(/a큹ˮъEsĖ˶9oi95Cm}kp͚Sg5=OhwsK?6߿aDĔ$m4TÁ܂ԂJZ(>l4mpWH4/. G̉ ^_C74ݶ3:JRgwrc ++@qFƘycGHUBv/aoIB7<_Io79a{SX{\?#ҺSb7J6VhyPߘ&gעsJ~-)f5af5s[;ܪXͪ?f3\(V|Q'˨utׁGtvk?rώ^)m6UݛziWۘ+Xg{+vt6eGϬڴeWT)1kbT NLδݗnc /o^>3G~fڸfW.ıO~Jz)gˀBĢctz<ׄG?;sC7xݧ,ۗ/is|n(׶U~$+gx+fI󪻫Š [ǿ/y%XF$o\>BfbGLJj0cG#\璕K]͎jߘhYL%ф}kĖ.=_9{G?p}]V7ղ{-rxc<դVi/*w>oL_vY-jGdy%'F j MEEE䕟?o_z~ySt>ͬHͯn[x |^?ǔ' +C~{K[uzUȺͭi~KWV&tMlҨG>h}ƲGw .JknKXZSwyu;>lR‰ʞW^8eF9mߠw54Svm7'w. *_DQ\6"pF4Pp$e3s6YB=cFF[48a++W{ -Ȱ 4 Kjj#c1ũce|Zv:ݷsBJw[996-Jh!6C-ڜ"wlvh /tp{ R08 N=18'іxopBԊQa?BikH24IEyBZ#gI 8s{"?*=jzzn9T/^=:g0!˗uG܃WF;avF-]iL1a} ?.wjcbxN^uFߛHZ6O:R-{G{sc6~<K?|Ki-uԬ>˴)O<8šc_7WyNĬջj<˚'Zw}wΡ'{𪆯9_ sg~pyS|xԦ1%~8G}Iza.\{׋WϔMu.ZzyeWϤc<6jcraL|űz%N߮N9m]ݿ勇7-k?sHtJY/}V'YasR͒9lm/}dҏW7˂3=#yי⊘NeuÉSm1k?=>330|=ԋ$ًgJ '^ [*+'~==ԛsض4i{#qe>ʏL|ykr0kJhvfkſΚ_}E평ߏ{K{k?1淇k^_h/]OÇfnh}~]i,̻kϚk ZA]kA+?,sO]sK[7)m=[=eYo]$)l im;Xf[s̿Re.ؼpTjxts ޻ZݍumŸzm?u=rf#/|rIU>YcwU{݃gZi j'cCFR+v7^w:SWz7V{w F&4btSugbr||29:X QPg%4 ~8~$ *ε~6u  `wQ +'m邩Ae\$ ,VuF`#WêU|=zɸ+BC-J[xp)Y!G^(Jp`cl?ubuxK#'6~xk85wFVɋ3z*{7V>v(}6=ݹ{N>AcޟS4ic?}hȧ}\Y=mЏ:R/v|*5oy}/.{mE70_vy_b=M}m맩w+,\uW'Qpc_ 6VO|lm?y5^soJ?B]6M"6 W,fܴPEuEc;+ +#F M&=&xރw],x=,i=Mn'}>6Χ=7Jsl K_~i_6"iRޣW]3ooy/V/}"\LJLye͆aOmhTͺ^{ڦzꗊR'3ɽ_Q1i Ƒf0lʽf~y^ybg)_Oy['?rf˹F]7K{/6cޫ7vg]u⾷Zp{::3̡  [xt&w+} |t\{jJePKkL/[d&|57lib/netstandard1.3/Microsoft.CodeAnalysis.Scripting.xml]oH~<8YM8Ndb؞ Mdn(Rö6~&2%e%ε? _0^"9M5 w,tQQ4R?{?Kp?yVa^{Xȡ^\<x:7ڏ8o=opGNԍ=ПQ'йRrbp'I݉r㇩]/^U^_hy*)hEɰg+yLN(I}/i l>;*69s{]YV5љJ m_x9nķcSN1 اhdC|ÓOqTc],Q+\=`Y/rű>;XI1`ys@Jf+iP1I4єèXk=(^9~!kZqM+dMG2C9?OD0fɘyb @fmBK?fj\ݩMwP6\eoJtI tPlu2CŢZY>$מKw A|40ň΄Tl DoUj%O )IbT;O B3n"Jxf<k"> ;2Vy&ݧblJ'EQ()L/'ӵ,-OjS9|p[k6G@*Mª֥[?fM911O_"}sWs%?FgK.uL7?D5@4l-p)|>lFf(R!\D.\Up۠`\mx#W,#4_V`"Kc/W6u?D{g+m^sjLpo9:U$0ӓ,9+̎[r^CMw 4.qRTx_x#M8sD$*:upI":#MYhv><1`<؉G^ц/S<Kyx`na%:{Ż4xiOnsw OqʛFzx~y S^|`)8M3C8b&@ tF0ȜwQ4h>u? n.Rj}<6 )+XG>1F4][S3boJ~Ȯ2? cpF)ZC?Ug &߃@k΢^,dRkw =EeD"KrJQҐכr't>ݷ4:\J怈7ըߍU4:'K5+7QMq û<y \(d͋]+ȇ`\zb񨘻 J1N%R$:dQ)k?~#J}/n7l_g=dzE*_̏ؒ\,nWJGl |)WWft_×)XK~g )~ae|uVqfe9,+ԉŅ/;/?d/;0Z˘忽|t `PAx0(H>"k 4 wGrPcEjM .#7 `b-$K jL N]. Q!D$Ftwo~:p.ݘz_wg(Y|рS94X!Fd dկm'wRBG$U0F.gtQ,>ʷoRuI~Z\{n8W`ORogeR..|L}5#&זM9N4s )IF0TsHAx'T< [g7?gi[#~,Fi|1(9zw FrHT9CS/jf|˓L=s)O 2(.I]. [)r]v(CUY~/Znop񵏣og. d.Y=CmCsN⅙e9|@rD:[yqL B %-eLXp0H¼LG s:97~«U:cwn4Ew$f'`~/Dvk49B.&tRuZZYN(4X8 3\b#38f!'Cأ"-+]6tIJǑ6}SZ4#JOʓM^C?|XaKw|hlQN@`qm74MƼg{j@ \ZKC6N@.);e./[P2w&,!;a͆%o5b$H–`Q1Td"0~}[KbBNΟ28NaBW;8^S,k']f_gxk!h~} 4ď%">|65h~ܺSfy:9 q-ЍS ?iQ2L ɇ(jRuut坁=Ȱz{xĆ@U9 ܔX<+ͬ5Ϫ)!1rQ#3BMϻ=ͯ7pI V Q-#=Nu<lb R ;w2f)rW_ѧqDE=FpWT۪l(x):`Pfjf G21*bKj%U#lTn Қh#?g ȋrR< YM]ʼnTQ糃wN9{%8ZkL"?5:yθtDy ;HBL-qh2dr~st~3Y?58ѡ# ~=8=YcV{)_Gz6U䐇Y!LБT 7uGtד'…,1|1 ʶ{fD4; ua&⁹6'XYSum֨pVUR~=QsÖ ꠱%ཷ:4/ T׃n "eRlr}O-d"[ѫdИ?(6΍gsK\_.Q7LLr݃GR`5 NQ*åe^WSqWQ@_ 6tZrfwZxOK["'qBОjHŎj򪸲s`Z , a]-}cu [s^-0r.|[xb;Hr,G/BDDrrI)l sK ԻZ*77*]~4Z"(‘j@2[>ږ &fTH Q!WtB7"½H͍MwD 3V.3q $p6g-OU aBgs=+Oi%谺ENj=H n+K@g͓;M?<1!]lQ[+\R[Ay^}MmRy62OM7UK{XS1oWҪhVW>}IhKsE&~csTG}ĚT޲RoiF1YjſzyG,H}uV_ |j!rpx6|p}O@"6 a6-[pU;꫹/m@oCPpr|ۺzum/3Z7drNʯɿ+Y~x9G`]@YB-VA=A ˝u`KmHuR]?m@\Nq2Lqf4myafSsMu-t+U:l J|0UkoZnfL#*֥|\U _YJ.Oipi,%6|*_οÂT A$BI-D.N{8\ 2:UxQ,i0z.elF>@x]I9S צgO+PRڢ#Cp#sQR!|TYQںޯL%FAM{΀l# R)h"Zæ ~\?P& sd0 :L V<nx9K=(@!av= {XO ǮIJU1Q|u$3 LLZiҘ!Ft}Y?T0;Ըtsa|.}rYGrI PPL|MO5_QSGxuJwq,MF[o4lR5(lJaPTW5?GKf_x!7)pa!/YUT^>&,Fn6.>I"F/w%Kq&fnO_RztH`(ԭn{v|,}D1)xPLf6?)X6f~l ߊ1]"_W~r2MI- e+nR.L>=54W#Fzn(2Lc.!_$&9ngUx͑{̒Z])0j֍]Frx'Mo4x$Hmߴ]OQs=nܕ{PNމ+ъN&Y(B<, lmI$$΍ ;13k1uܘ3Kbuu] g\'S6ݗ8sA$41ץ}=O&'iZs+ŽzG4Є|z1 N-MR q֛©eYX;xl\)35kXE)^e1\ \K>Av)2@3(Iv2"Pʏ-. PL-qXse(VFp+l܄eK,IW)Ѱp.p 1BnlSZb1u'ؗVyQ[w.mcK97<9ט}{ω7%_R;K8~KM :XTB0,J'QS(CmxQtEHC V1N<< x6 +c^HI#޿Q`A=ny]n]]cZDI?N^ͻIPYUcDJٹ!wt.*βEl݄LwP_A+\!Gؑ-n_5. u7%\{1ɀc"gϱU՛'>͵5]Me[>oMrDG*!a'5cnF 6 PoF@]iM; ]\iʓ%$>9K;|Gavo9qƵ}rA$Qz95v U1J%] atSCTB7zLN^*~-y& 3]}2Cn+M]Z7ϏbeIGVVCa6 g{…1e{tؙ&L(l@aů#?=JKI:)F j.JdP&>]GK̃7#_-]Ѽ*\&/FS6SpZHX|GIƹfub!A;úfayǷKH!"@MƪkU| 4/ʦ`]nG90w g]y& =RiRljM5>>`]zQۅJR^뇹Q됭 Ah[Yߕoir"+d?lQF[I5!_xv$EY!q ixS=&u:$ETcu Wli{g2f԰[C]CJ0{WN<$T(&H|~3Eΰk(dO<ĶĖ"-"Є`7QL ["ȫ3Ck8fٽc%S.Ǵ%4q{Ts s1WtCVĮ)dc׿5 NTkˆy Jq GV8ph>#8nT%:䢱Q~ ~md2H 0RV-rVKbipzruQGV>qJ%{MYҰ (Vnϑi*?#OgB Le:T3\Ld(8OBk1ÿ1Iri% s!z6\l<Ͱ* &HN|)j~{<Ӵ7r5:n孽<$cyk)rji{3,ݕm ߊ"/IdkR}6cPJkװU|BxcV4yƷ㡶ZWօo}[} Ej<śLZ]q"BԥR U&@vHTpO>pW_F07!x6L.J҄; &k".(6a{:)(LA=R5qQ~|9A0MAŠU 7:t>RUc;Ah -mt:-oPRCƂ&@͠vP/頽sA:zGu+(rrAŠ)*P-h h h=]p .AP4;.Bt?x!A">BvtHaH4Ph$.)nL9Q:?1ZD&#v&ň}@ׂ=z 譤X1&9VT&mW'ljc;@=/jR:PWJx+5Q%Q)y@r'BtJUAbmFwF,VdoA?ffݠ@1cH*'E| T84El zghMy1iݹbH^Z: .&f@@Ejm"kxA+A͠I éĜ,qt!.t<[ -FYbjPm "&GtRO"|6E@WKy7Tm..W="W|t <dx 1*Ot&unз|q}itO09@,#'7\<3fT2vhmm= }pqt+к 6 QB:>} 1P@CA@@&&Y,vL*;A= r+@} dL%LUA5D*AA @M!⦎l0BP=h=3:^4Ukg~͝f@:x*glaAe ( (6mXGj)mx`Zx4"W|]LPo(7y(e@ AGA7^%-.7TVɠ&P+Lե1T6ޞU* KEh.L͠9bPRt\ň};f8 0I L!CגH#SFhv~L I4C5z|l0*lPlA;P &HE*T0-Q ^ 6K|`R7Kl.E mJ,PC_"q0K<8R+: %ϓ" -q> u'6cCӀ,1&1ٕA8S4>YA8[T!T0)٠` "y#dR0w aG(9^+%{h) a&)'q)p)iQ*+SOV[qlΕFOSOEiSO4djV_cj V\O3'< U*|`2^ӂPԾE &~\|ӳHa_ e AxU^`zFS :&#cTQέ-Ƌgm &x=/&Z)˕^!o&NUIxy끩nS$nv7* LH ĤV0{\(9~{*`MLI94XQ0 >>/L _/  |q$_˂ |y" W᫂A |m ?oTp 蘂IoV0(VaZ|Vϕ|ZOY·"`Z{6J|$_"ϷI| sG|+tC{UAW+L`ҧfQ?tR`Z0OJ|l4>M|૕X$NG7뉟*|C"wI|0-C^⻁I9G{ R)}KKWIi~/~P$KR.s|67ߒ'6p  '۩#ew{:L21Vn$Y9F/ϒ̭zn ½f< ~Kv0vSLsdI{ g : § `; _uɿS Ag(zL_Jv0Ǟ{ _eg0L?p4i *<*E *q']OIyq;y=f>t O< 4fR[A |{p,34>)1*<Ѓ`7\!}ˤ@Es+!`,ևA;$~SH"^!hSA8>y8Vwq7'chc)A ~L?`ҏO`O+Ed`Zh{8E_#q*0oi< fWJxe ytYr<g;x&$_8\o8tWmS0Io*p?QL+q P܍}#3T0o#~[Կ7 :I`PdtcIgH)8\?7<o`*_*|ģ#'\ \*Gx pu xa@^~$Rp𙒟O>$ 'eyB$mӁ- y=L &~^ďQ0 0'S¿(㤂i` *6fP0h7j7Ǭ`o&Pmdo)dJ_+#Q0SIIe Jg'B-6^.&[es_9@}*Ǥx _ su4x) &{BK`LS0ٛL2wN˘&X/*ʯѲmIݙb+~ 3=2_ͧO6Y6+-Tڊ/Q0ͧ [KZ`+L[`LkSLQ]T:gnV07ihS0LOlԩ`.O[(&~ Bb7>SlQ0ɛ &bi<+mcء` S0տ_t ӀWK-xtfi#8Wʧ-y{ ? v?v)bq'0%:P/D]H'"5n<^ǟ|o$ӻVH|FOk`Oeg([$(%GbWJ* r&|cg-?Msʔ\yN26"|>LT9X^OeH|?T>,\/&Y4N#4~'W_+_#hO"SjLꐂi.V0~wiM<`ҷ.G}W+L>Rt?F+HLJa ܃5*~ ? 8~- 8Rh8Bߋɥ_8G_~6_T^{; nMFց{k-"H)=nw8WooG*lk,?).osxQ|~+ĽLm8= ~.oxftT.9(Y|8S}>+=}h-qM#l߹ӌ}u|Ve_ ۣܺ^(D_w9nq(V.؞IG̲׹4 ]y|k(I~m\75ieo0?pw#Xw4= GVZD/?q2ϋ*nF12K\;&~J|~8SFqYǒ7 T8ǭМK?R~^n8k',~ Ziz9ZqL=Hg8eaωz]ʙͳ<&J/g.?f Gx2@StQ$I@ 61G}E5 At=$d@?Ϛl(@"L v[tY$?}:nňiGrnj,UL"ׄL<,cޠy*C=m|Oc}Ao_ YyٸgJ8bd9r,nWfphgku9JH˓uhS:"ǝ ͿXwq\=(<|MuZc(kN^%rct/P#7uOxjfIYVq1KQ>4%Rn#: t 4j&LHaƕN񽍽b8kM,scgx?RJdн~{k%!]*tr˼\SR@Hl(ze1Jcngzu%UGɒ:ܰIeJfn : ĦB A|o vA\auJ#m1ҿA:Al K'} "/"E4#]ҟH6Aɟ#ntDRtE~AM7:ѸQҿM~S7l9^o&;a5J"sz O&nIU2r 2;Wu ⃤y2]'s YSi_MOOؒBU.؄A\J6^|Hˇ2H_/K5-2&ؓفmmjŹd  &IXA\R1S-8|'gO؀^$ 38[Ɣ(v|lov!"> i]:"IWJpZ1w#(zWKI *Ə41GCou2 9ߠc }2!7l(?2Ϋ˧A79_o|ʗ%+2nΠqo~>2~آ hP_fUX+ޯ WDjT"Nv7.{bի[<-]Ţr->rح6kihino͛ 7[ NOFiDSs6OW7v뻺ܭ -}ӛ[ <=Miq7 Og۵-ݼ5߽܊7ZMWz:]Mtզf*$z܎]͞ʶ&^im~}[݉z;==82^imFtEڰirN[75T֯Î[ߺzZݝ -nŻ ^}n^ituwzۺiOۈxsk u﫽YNWskmr:[7G8)ii uSsUu~[E=mͭrvw88*,K>F431f 9t_\D*&jbbB5.}g;xQPefupn_-\tAXo҇+&pbKd e"M;thMVD"*MpKgД ׄ " w`tayEVV4z8'яM $<% DBE.+FQ˳"w{_H2 DA㩚-3uhuڐ4Mu$*B#J gu>yPmr/m:dH3[wˢN>Lyy1MCxr[#Wgᑡ6aPMGmu"}{œTv/m]n=AOKSJXIc#oCx(&z#i尊L~h@.w4wYDg֕!\2x;ՌiݑJQM/zBp7gFTÅH4N7G0ab 5Лw&G7b7 {K\/izbڛlAY$Z!tNt ?&DF$PELvd?t3s f&t]c$hTvWy=u9ٓpHu+ [Yp5]gg֙Q PeI;hy[Þ"5.@8ֺxE.e_n9vEV6ض.=Hw~)O " _# 8 {`Z}{t};{_μzۼ?~ι/~2dB ܊JVfAAyzi`iJ.mb+MMmRNb t:S": EvB+mbw/&CTBFCr2Y=N[Cw!o5Dc"Գءg%P>8#Q"#Ȗ'gp(ԙ^Xaӝ3Y3,M,BO :Pu"5Cg,h}" KL=T@NToZm*©yY{NXw əXtUoq$]+}+yηύN^jfl *rtskymGV,Ʊ+"lE3tM,2CKȰ8aiG0n_bF;BD2w W)wgd2rs|b<_NB9Vх[CDTdM&=sQ&'[4ch^gD+5C}]NP\,bIF9zQ FPM#IyO1o5ӎH[WU'}ݞulVM4Vrbʞ)OVUY\j+fٛ<1z}gt~&<|0ًQ%qn$JB\=7?"R]V0'>t LR֣smHvlαVk,–0XGftP_E,&WX:s=bFS8bۂ<PgIn*XXAsBaI&oB5Qh]Ő7!U'kD:Z\x} X10̰,G< f: LE~IrTױ EtkZ .o~k싴H<r*}!.9DvL:fC_CXݸB 6~<62b )Ш PJBI^ }_"op v}x_[oK|5~I%r> 4y$Q5̞mbwD8']0\BfVb ˛y3e ojM'oʷL iۙ x{oxm^V{B*{uOy;,Gg3Syͭ畺Z9ioε)[?'_h͙+F.b֌+Lft)mcriėǡji)RɛH:=BR4P^tg\< <7O+MYT)ed$@mwڣhoG~q-=[Ki/T / D<ٮ \͘}Ŭ̶Zfh_Xh8F LKM|дU V3x+v_)o&:2/~8'SG] ?D>c'vG/xOuq';ƇF+2XutMs3 6fب )a1pY`zA)ZV>6SN; /pb?K0ŹxÛ0h/iBȫI<#s"r<ə, H;Wc.+dv6#fgBw6|Hl5N"ODzkwy]dYiHiK9diG2T'\#:E~Ym*Aޖ{{+oM>{6m|R~a[#oN!Ek/oi 쫧>xr\|}[n[}{~9K_".lXQJ!gtkbqcaSH{pFM^lֹ,4!d _ы/zڼi WR8Ёjyý;-@*CMS*"LX) Uo /Sk!uD)!ϔn'z`wSacϳS~^1;]aܨ~(PckAfF0WWiYO Bxޫy.vnR#ZLϴIgVo8?Tr5p3*>4ٕ|\I֯ʽ;nȁSF+wٖg=[Q>pԇ1$FDP?=HΛLL٢Z(hp :sKk=Xǫῴ{W积ꂽ?,&^WJP4:0ilǠ]u_|t#ٛo%RI_;F4}f8=9A. 19)FG{)%!m 7ޝV4mv_ zu/}ڹSP7#gC:ah>\(=J:|W_GuknuXmw_/wE*1*QMG9BC!gԑ=!tؤ0"LxIfUbo)Hm8RD"l÷ g=.o*##MWw{18+cJˑۚ`(yIdƇX aP'5Tjn tLREN ah!+֓^#+ #J_o4F?860Z_%'(GIҹl/bz&ͧhbHI7M$TMYא~8ra ACngʑ!E|6"+6эKM0Rb{b-4B Y:Mn[< ⪿D|{V·pWNܽF>| _ _.ZKBx2OZ2"Ѽ]?ǣ?u[uH_F&)E*zO G3 "Ci@ŸdM} +t=~wO4W;}mxտˋ]tK):e,b=׊, /\01͐?sl}Y$b52U?QE' 'H5׹Q7/,egQjn CƢDup Gu wa{I8l'jrn -$":yorJcBaϴ7Y7c&޻!".\pJnu7vG4 Q8"|)R-_`֧R,HȞJ}ǭ4b(]JI5nt { `b_M,LD^.ώR<_GO.(v9 MzA)qU\deA[Z[}$5nӀ5?]$‡*yY"YvrVQr.2O՛ 0͊+nf7Z)(mQD{u F3cj-_C` N"Gl$/eymD|5 \DlƱN Tσݟ925 Xpr -VQkTóXJCbkb61ԧ5*gʼn>v`#khxEV'WώODΙ)30p9?SM&?'ovlcה{Ϧ51y?k.0}3Wm#Wln{ΘLr}^,亓:[lI0*K=Șs*֩RkW]g`eq垼m]' 3gLXl4F92x@nVQ #Hw~~k⅒|Eou-yӸu O>n!ݙFS(ɒ2cʅ /e_qBD$JԐ1-<4aNs1bbX(@#3s2 " Je[;c| ,J IJ(Rf5GgChX^:bR»zE ɜI+#NJ?JefU YTjBc9mi%ޣ褣[#. zX644hrXن9F!weKfЬǏ)=.ڡ) +Qzd ˀY%p,]"{ tJH`!O.^RiKa(H0 ?o9,}V 4@Rk6RI0!}k aeD:`8Bך7-:DRtYG-wg-ZD;ϧXrz5o0 eHF\iA$9XqBۚg<<66F 0'nvX؛faцiZ9ű׽331/:8ᖛޤ]վj)wl)y}!4'D 8 [SrEtȎ\v85ԧ__W?cyv:rpQG;{)W8g'=uUpV(D}@I@f1Y M&nbwY׮:\O W> o[{JLn:rHb1py}Ƃ?7SA8ӦkkPM"~\SJ?̗\ʏuecώ3#:ªїd@! C( s_JjRf.4wdg"7,FĴbI`QH ab #^JɊ̚jum;w \umXJ㐮'NT]R{MMCubWwXn )Q_:O3䀞H?ĝJL;#|n>u?~޾> =o[G|/ض$8h '9 Jx<7z_v& tt0ޒtKtn˿<z.eK_[o~ӎ tW..m% ZM. t'(6ѲFD2if߄AZU7z#H@ y 8>Įe!'ͣ 3W!!GŷP9Ȫ RЄI4!!jfI8Ԃ^(,X& '[^ttlm9,:TEw&ZN3bxXzzkV_8/&im|oes^jȍ<,9~ѤCŕfo6G&렸cN ؆Jw2rC767~2N%!CZdYsB܃Zu.W8vL6zhYb_v䝏*^Nzqvƨ|&I,T?BMVbzJ?_bBo/Ӂ•ʼo~={ؗ?fol;s67 =$,˦$)jN'AzgsG&cI S%Rdѕp.YIDY(%d'jۍP}FF2D}d?+ H.2):P rjY$̒R7".7eXt#y47Cs YhvԹ 2܁\dI% M3DW4|ڞ!+}G%4jx$iL%ډM80PPK,@B7A#'I>:0@Euq!X}C(EO#}:B"_ sB):,ZJ12aJ F2jzr^iG4%} ET4(L3Սv~ȗH'qP]F$As0  5liRjlcO9y΍BWZI:2dRtk+/S{p/|*UBse)KV^3עۡugWD]/Ny8}[c֗(k?}JFe Ee;Q_y{Agi e6B7a[ /} ;, f< ˔(?g'|6 ?h?L=k^_8X |hBmJ~bw뵅RMZkՏ?츭/zn?<"t6Dc$OLrW)XA\oZ8߿#_ͫiSdNB[(27 x(1ԟ?gVݦHk䑝3~rwY |/w21=m5KQi3Xib%M' ݾHyO0W;i#%RUa[O+y%L<}G7^6tA:SX4 BMUW#e҆Ἃֹ+8t>[\[G4)o3QxT:za)&fS\n*VYh^1ʈM8(h[)X3Mfy&;zX _,c*ٚ) mOj`)*tH2 + {UG)"326 w!F%KJhke{9Ս;BS { qb$ Ł3wzA6xn>Tj|ŭ { ?U}Gzx$u-b #zבsX+na/ǰ,Zn ,ns)9]P9dDHĢQ\e8p8 :l҉qoR.W&cf7~za1UuѢ'=qݏGWyc?~31;9ʐ)u:o2vځN`34 HP^H:OU6)Vtstxf6%r~'lMDK3 < 0i4w;5p:f5ЄNY:qHf(h)ð ơ9 v\ 4 LQX戣l।y%H,Ơ;T4oA?PUZd!K13Ig,ަ\.gK8ᰎ սv~=`B. 17NߟDI]A*B=p~Oj`yD=W=76i[,O'bE]H$seG.w'Ø%FZb s RR}>ka#Q+"(V#^,mV+xd\\jÐgAq$cV9,FL>F| y8sq"""&QGK:&"8]A_CqM{n.}>Yļs듃wEiC\OXje7xWo4늛Vd|riWK׋"C픫4[dh'].]Hאg$B4 q:"VO%_b("-'93FqB$5tӋlΫHVSY<-/#}g#&L^E[BN)׷~ltSp.puUH$|XTu-]]_=ec7L:;)znqMGqb^OHd^YɈXgKGѿXF(qOML:G."! S;D:m|lH$]IB>{3/M~X ;qp asLa;Y ×Ff ήeUocPf2qcΡ (Ac7c?]^?۷s=dlIݐNԶCO&9嫻̒9TsȈ,';X7cvu{f`C_9%{G:'M?ڻݕ,E0!KIWa&c&+j Ӯ dicvGanf܁ [/KCO᷾Z,?qCĶiENu^I!wPT ?%rлV(H3̗i!y Ǒ#2E7q9]iY̅ fkWM;znzZ#!L$"9w9ͻ}eN_wc*L-<Rf"sREL_nC%OWQ,k1̩ZM*qE PE[L|=Oi 35!UL9` Ee&p&2((8]"ƇC CƊ 2v LDPbm4r!Z1{D#ˡp+=ՔLmpDGPX0Q]R+!:ZIQ#P, ꃿ}Fwc|_b0)Ś]apNbxT9-_GsuGѣgBw8(#rwJ9rh/W o6dә܇rIB $z(Cb,3H"ӕNcp>/`x5ʂPRmӆqMXt){oR7b IG/}pܯ%qp %jD  9j1s֌442ͧ:_@;̆%HTWO]t,kceG~O,!2zE83Ǒ$v [R2#Vd~:? f/\6KA/(#&1SlJq8Em$j g2Pяי.NtE86ҕFTv&wy,[35?wׂ7/w3*Φڤwi:K"sKGjnCX Y]_K1RX$_t\?p5j*ĂCcJ+_@SI8<ַ86cZgQ"UNFeq8{nǕw%z2lxjʇ8.+ 緱V1X'" M<sAq7^ĿkBv $¶Rt,r&sRiHRKNyi-n&Z=(-.&M7%H/6pEir% ymvңnU'Nħ>hg;0Aj̈́2ңߕ XF[K4K]0@hL<KF}Ltܪ;29A]!Wy[C*vdZr( 84Dݏt2dfi~'h4Na٘rkyb4~2 b}=نꦬajƬ'Ƣ;ϿMnyfo-Ś.u&msk%3;oX,ۍ ߟ[ηE=kKk,]I|e%inJK$lAظ;xmo]ʩ8X47G;'iGRG?O⋣9_כcPKLtO$$.signature.p7s0$ *H $w0$s10  `He0d *H WUVersion:1 2.16.840.1.101.3.4.2.1-Hash:eImo5azD4fshXMOjiBvhA4l2QkDKZ2TybdjBv1rgZis= *00 F`090  *H 0e1 0 UUS10U  DigiCert Inc10U www.digicert.com1$0"UDigiCert Assured ID Root CA0 061110000000Z 311110000000Z0e1 0 UUS10U  DigiCert Inc10U www.digicert.com1$0"UDigiCert Assured ID Root CA0"0  *H 0 C\`q& 9(X` ک2a<(ܟ zyS\1*26vÌ3/(nDa5YvmK + rڞ`Ў5xU m I|13l"2Z9:r1u}"?F(yȱW~VŨ?_wOc0a0U0U00UE뢯˂1-Q!m0U#0E뢯˂1-Q!m0  *H rszdrf2BubV( `\LX=IEX5iGVyg <&, =(_"◄egI] *&x}?+&5m_I[=%̶odh-BbPglk 67|[mzF`'KΗg*h߀ 3f nc%mlaң&qÙQ+.P E/000 _ջfuSCoP0  *H  0e1 0 UUS10U  DigiCert Inc10U www.digicert.com1$0"UDigiCert Assured ID Root CA0 131022120000Z 281022120000Z0r1 0 UUS10U  DigiCert Inc10U www.digicert.com110/U(DigiCert SHA2 Assured ID Code Signing CA0"0  *H 0 ӳgw 1IE:D娝2qv.C7׶𜆥%y(:~g)'{##w#fT3Pt(&$iRgE-, J M`IJp1f3q>p|˒;1 WJt+l~t96 Nj gN %#d>RŎ,QsbsA8js ds<3%00U00U0U% 0 +0y+m0k0$+0http://ocsp.digicert.com0C+07http://cacerts.digicert.com/DigiCertAssuredIDRootCA.crt0Uz0x0:864http://crl4.digicert.com/DigiCertAssuredIDRootCA.crl0:864http://crl3.digicert.com/DigiCertAssuredIDRootCA.crl0OU H0F08 `Hl0*0(+https://www.digicert.com/CPS0 `Hl0UZĹ{* q`-euX0U#0E뢯˂1-Q!m0  *H  > Z$",|%)v]-:0a~ `=į* U7ђuQnZ^$N?qcK_Dy6FN\Q$$'*)(:q(<.%Gzhh\ \q h@@Dd %B26$/r~IEYtdkfCڳ  Ι1c=OƓIbnS.hlD2fdQ070yPjH}p0  *H  0r1 0 UUS10U  DigiCert Inc10U www.digicert.com110/U(DigiCert SHA2 Assured ID Code Signing CA0 180226000000Z 210127120000Z0t1 0 UUS10U Washington10URedmond10U Microsoft Corporation10UMicrosoft Corporation0"0  *H 0 |W T&Iw{%`))'zҘbU2ЄP J,?pϝ^)z|w_/Չݰ`NWKPe44[{*0D;"Rs礑3Puh.1ǥA߁q.jt{y`+b>8mt^p>FEEӚa}4 A`$>d l UocֿNv;9; d_QAXE>\ 3Q,f9>)tȠXW!"&~#At:t<h7hXLtuK-Xh] 0ޒm"ʭ'10qSq@tx0 0  `Hea0 *H  1  *H 0 *H  1 180430232926Z0 *H  10  *H  0/ *H  1" f:Z(n8@ dt0 *H  /10000  `He ?`L;QC]4000vt0r1 0 UUS10U  DigiCert Inc10U www.digicert.com110/U(DigiCert SHA2 Assured ID Code Signing CAyPjH}p0  *H c\U 5om~l(m#gXB؍Тqb܀!Ow!z/mL'IcW<1K]r$s.wN H?%|0 \%Brg8Rڤ2^,UWU$D)a#@~9 k$}"Fa3j$ 9o: ު].s9]V㕬\G[@zpqڽwuk'*r͏ee$娙 0 *H  1 0 *H 01 0  `He03 *H  "0 `HE010  `He ͚ `?|],]W0)nF<7R=Cl/;T2ZBc20180430232926Z0 3݆,װ' Tuq Pc3Iڠ01 0 UUS10U Symantec Corporation10U Symantec Trust Network110/U(Symantec SHA256 TimeStamping Signer - G3H00@d!!0  *H  01 0 UUS10U VeriSign, Inc.10U VeriSign Trust Network1:08U 1(c) 2008 VeriSign, Inc. - For authorized use only1806U/VeriSign Universal Root Certification Authority0 080402000000Z 371201235959Z01 0 UUS10U VeriSign, Inc.10U VeriSign Trust Network1:08U 1(c) 2008 VeriSign, Inc. - For authorized use only1806U/VeriSign Universal Root Certification Authority0"0  *H 0 a7^4bXZ##`אzX8dqM-siq9M 3I;Kሙ3ǀۑWrwͨ 7jK _y5x2#2AY>+m:ɜHS6xš7w0s0U0U00fU _0]0[ `HE0L0#+https://d.symcb.com/cps0%+0https://d.symcb.com/rpa0.+"0 0+0http://s.symcd.com06U/0-0+)'%http://s.symcb.com/universal-root.crl0U% 0 +0(U!0010UTimeStamp-2048-30UcʣNrৼA)8ub0U#0wiHGS2vї0  *H  u-4\2EOxoOȁ@)]Vdq0*af V]q G̐/ lN3ִLcH9@!n< ɏSWA/MNxlBna\RNkJzS uu.fW:Ί۞8R` M'm2?@Ῑ9+ZXU}ǚ#*a0K03{寺?#"AM0  *H  0w1 0 UUS10U Symantec Corporation10U Symantec Trust Network1(0&USymantec SHA256 TimeStamping CA0 171223000000Z 290322235959Z01 0 UUS10U Symantec Corporation10U Symantec Trust Network110/U(Symantec SHA256 TimeStamping Signer - G30"0  *H 0 ܿi{TqG e$ m0?'J3Nm@" <$(rQ= &:C#uGp _[rHWeM<@28?,Y#ˀMɪ lUaW,ĵl#ҟ lbiNR1[tRWl"Uo?J"ve6򖕁&,8ӯ%@ S)WX^HA!޴&{@SXyR1ME<:"Ŵoﰊ00 U00fU _0]0[ `HE0L0#+https://d.symcb.com/cps0%+0https://d.symcb.com/rpa0@U9070531/http://ts-crl.ws.symantec.com/sha256-tss-ca.crl0U% 0 +0U0w+k0i0*+0http://ts-ocsp.ws.symantec.com0;+0/http://ts-aia.ws.symantec.com/sha256-tss-ca.cer0(U!0010UTimeStamp-2048-60Un_;1y6{0U#0cʣNrৼA)8ub0  *H  F_HϨ'K!Ͳrpc/U){9FN~eXW 6$ {;bJۊTm(gq?3 ٢YJekR)uJ+˛MYA÷?Dz"tG %t`n`Vz DXHwr$,?Kg_\T>3[ŷNqfE?v1Z0V00w1 0 UUS10U Symantec Corporation10U Symantec Trust Network1(0&USymantec SHA256 TimeStamping CA{寺?#"AM0  `He0 *H  1  *H  0 *H  1 180430232926Z0/ *H  1" ȽrL-u7SDVJ֔8J'X07 *H  /1(0&0$0" tv}9N |ƀ netcoredbg-3.1.0-1031/packaging/netcoredbg.spec000066400000000000000000000136651457701673000211520ustar00rootroot00000000000000Name: netcoredbg Summary: Managed code debugger for CoreCLR Version: 3.1.0 Release: 1 Group: Development/Toolchain License: MIT Source0: %{name}-%{version}.tar.gz Source1001: %{name}.manifest AutoReqProv: no %{!?coverage: %define coverage 0} # Accelerate clang %ifarch armv7l BuildRequires: clang-accel-armv7l-cross-arm %endif %ifarch aarch64 BuildRequires: clang-accel-aarch64-cross-aarch64 %endif %ifarch riscv64 BuildRequires: clang-accel-riscv64-cross-riscv64 %endif BuildRequires: cmake BuildRequires: clang >= 3.8 BuildRequires: clang-devel >= 3.8 BuildRequires: llvm >= 3.8 BuildRequires: llvm-devel >= 3.8 BuildRequires: libstdc++-devel BuildRequires: coreclr-devel BuildRequires: dotnet-build-tools BuildRequires: unzip BuildRequires: corefx-managed BuildRequires: libdlog-devel BuildRequires: libunwind-devel %if 0%{coverage} BuildRequires: compiler-rt %endif Requires: coreclr %{!?build_type:%define build_type Release} %{!?build_testing:%define build_testing OFF} # .NET Core Runtime %define dotnetdir dotnet %define netshareddir %{dotnetdir}/shared %define netcoreapp %{netshareddir}/Microsoft.NETCore.App/ %define netcoreappalias dotnet.tizen/netcoreapp %define sdktoolsdir /home/owner/share/tmp/sdk_tools %define netcoredbg_test %{sdktoolsdir}/netcoredbg-tests %define install_prefix /usr %define sdk_install_prefix /home/owner/share/tmp/sdk_tools/netcoredbg %define netcoreapp_hotreload_min_ver 6.0.0 %ifarch x86_64 %define ARCH AMD64 %endif %ifarch armv7l %define ARCH ARM %endif %ifarch %{ix86} %define ARCH I386 %endif %ifarch aarch64 %define ARCH ARM64 %endif %ifarch riscv64 %define ARCH RISCV64 %endif %description This is a CoreCLR debugger for Tizen. %package -n netcoredbg-test Summary: Native tests for netcoredbg Requires: netcoredbg AutoReqProv: no %description -n netcoredbg-test Tests native libs %prep %setup -q cp %{SOURCE1001} . mkdir packaging/pkgs ln -s /nuget packaging/pkgs/nuget export CSVER=$(ls /nuget/microsoft.codeanalysis.common.*.nupkg | sort -n | tail -1 | cut -d "." -f4-6) cp packaging/microsoft.codeanalysis.scripting.common.$CSVER.nupkg packaging/pkgs/ cp packaging/microsoft.codeanalysis.csharp.scripting.$CSVER.nupkg packaging/pkgs/ cp packaging/nuget.xml tools/generrmsg/nuget.xml %build set -- %{vcs} mkdir .git printf "%s\n" "${1#*#}" > .git/HEAD export CFLAGS=" --target=%{_host}" export CXXFLAGS=" --target=%{_host}" %ifarch %{ix86} export CFLAGS=$(echo $CFLAGS | sed -e 's/--target=i686/--target=i586/') export CXXFLAGS=$(echo $CXXFLAGS | sed -e 's/--target=i686/--target=i586/') %endif current_netcoreapp_version=$(for i in `find %{_datarootdir}/%{netcoreapp} -maxdepth 1 -type d -name '[0-9]*' -print`; do basename $i; done | sort -n | tail -1) export NETCOREAPPDIR=$(if [ -d %{_datarootdir}/%{netcoreappalias} ]; then echo %{_datarootdir}/%{netcoreappalias}; else echo %{_datarootdir}/%{netcoreapp}/${current_netcoreapp_version}; fi) echo "Building with .NET $current_netcoreapp_version" is_hot_reload_supported=$(echo "$current_netcoreapp_version" %{netcoreapp_hotreload_min_ver} | awk '{print ($1 >= $2)}') if [ "${is_hot_reload_supported}" == "1" ]; then STARTUP_HOOK=%{sdk_install_prefix}/ncdbhook.dll fi mkdir build cd build cmake .. \ -DCMAKE_C_COMPILER=clang \ -DCMAKE_CXX_COMPILER=clang++ \ -DCORECLR_DIR=$NETCOREAPPDIR \ -DCMAKE_INSTALL_PREFIX=%{install_prefix} \ -DCMAKE_BUILD_TYPE=%{build_type} \ -DCLR_CMAKE_LINUX_ID=tizen \ -DDBGSHIM_DIR=$NETCOREAPPDIR \ -DBUILD_MANAGED=OFF \ %ifnarch riscv64 -DNCDB_DOTNET_STARTUP_HOOK=$STARTUP_HOOK \ -DINTEROP_DEBUGGING=1 \ %endif -DBUILD_TESTING=%{build_testing} \ -DCLR_CMAKE_ENABLE_CODE_COVERAGE=%{coverage} make %{?jobs:-j%jobs} %{?verbose:VERBOSE=1} %define _dotnet_build_conf %{build_type} %dotnet_build -s ../packaging/pkgs ../src/managed # Build Debug only, code must be not optimized. if [ "${is_hot_reload_supported}" == "1" ]; then NCDB_HOOK_TargetFramework=net6.0 dotnet build -c Debug ../src/ncdbhook fi # Native tests # CLITestInteropBreakpoint g++ -g -fPIC -c "../test-suite/CLITestInteropBreakpoint/program.c" -o ./test_breakpoint.o g++ -g -fPIC -shared -o libtest_breakpoint.so test_breakpoint.o %install cd build %make_install mkdir -p %{buildroot}%{sdk_install_prefix} mv %{buildroot}%{install_prefix}/netcoredbg %{buildroot}%{sdk_install_prefix} install -p -m 644 ../src/managed/bin/*/*/ManagedPart.dll %{buildroot}%{sdk_install_prefix} if [ -f ../src/ncdbhook/bin/*/*/ncdbhook.dll ]; then install -p -m 644 ../src/ncdbhook/bin/*/*/ncdbhook.dll %{buildroot}%{sdk_install_prefix} fi export CSVER=$(ls /nuget/microsoft.codeanalysis.common.*.nupkg | sort -n | tail -1 | cut -d "." -f4-6) export SYSCODEPAGES=$(ls /nuget/system.text.encoding.codepages.4.*.nupkg | sort -n | tail -1) unzip /nuget/microsoft.codeanalysis.common.$CSVER.nupkg lib/netstandard1.3/Microsoft.CodeAnalysis.dll unzip /nuget/microsoft.codeanalysis.csharp.$CSVER.nupkg lib/netstandard1.3/Microsoft.CodeAnalysis.CSharp.dll unzip ../packaging/microsoft.codeanalysis.scripting.common.$CSVER.nupkg lib/netstandard1.3/Microsoft.CodeAnalysis.Scripting.dll unzip ../packaging/microsoft.codeanalysis.csharp.scripting.$CSVER.nupkg lib/netstandard1.3/Microsoft.CodeAnalysis.CSharp.Scripting.dll unzip $SYSCODEPAGES lib/netstandard1.3/System.Text.Encoding.CodePages.dll find lib/netstandard1.3/ -name '*.dll' -exec chmod 644 {} \; %ifnarch %{ix86} riscv64 find lib/netstandard1.3/ -name '*.dll' -exec %{_datarootdir}/%{netcoreappalias}/crossgen -ReadyToRun /Platform_Assemblies_Paths %{_datarootdir}/%{netcoreappalias}:$PWD/lib/netstandard1.3 {} \; %endif install -p -m 644 lib/netstandard1.3/*.dll %{buildroot}%{sdk_install_prefix} touch %{buildroot}%{sdk_install_prefix}/version-%{version}-%{release} mkdir -p %{buildroot}%{netcoredbg_test} install -p -m 644 libtest_breakpoint.so %{buildroot}%{netcoredbg_test} %files %manifest netcoredbg.manifest %{sdk_install_prefix}/* %files -n netcoredbg-test %manifest %{name}.manifest %{netcoredbg_test}/* netcoredbg-3.1.0-1031/packaging/nuget.xml000066400000000000000000000004121457701673000200100ustar00rootroot00000000000000 netcoredbg-3.1.0-1031/platformdefinitions.cmake000066400000000000000000000061061457701673000213100ustar00rootroot00000000000000#------------------------------------ # Definitions (for platform) #----------------------------------- if (CLR_CMAKE_PLATFORM_ARCH_AMD64) add_definitions(-D_AMD64_) add_definitions(-D_WIN64) add_definitions(-DAMD64) add_definitions(-DBIT64=1) # CoreClr <= 3.x add_definitions(-DHOST_64BIT=1) # CoreClr > 3.x add_definitions(-DHOST_AMD64) elseif (CLR_CMAKE_PLATFORM_ARCH_I386) add_definitions(-D_X86_) add_definitions(-DHOST_X86) elseif (CLR_CMAKE_PLATFORM_ARCH_ARM) add_definitions(-D_ARM_) add_definitions(-DARM) add_definitions(-DHOST_ARM) elseif (CLR_CMAKE_PLATFORM_ARCH_ARM64) add_definitions(-D_ARM64_) add_definitions(-DARM64) add_definitions(-D_WIN64) add_definitions(-DBIT64=1) # CoreClr <= 3.x add_definitions(-DHOST_64BIT=1) # CoreClr > 3.x add_definitions(-DHOST_ARM64) elseif (CLR_CMAKE_PLATFORM_ARCH_RISCV64) add_definitions(-D_RISCV64_) add_definitions(-DRISCV64) add_definitions(-D_WIN64) add_definitions(-DBIT64=1) # CoreClr <= 3.x add_definitions(-DHOST_64BIT=1) # CoreClr > 3.x add_definitions(-DHOST_RISCV64) else () clr_unknown_arch() endif () if (CLR_CMAKE_PLATFORM_UNIX) if(CLR_CMAKE_PLATFORM_LINUX) if(CLR_CMAKE_PLATFORM_UNIX_AMD64) message("Detected Linux x86_64") add_definitions(-DLINUX64) elseif(CLR_CMAKE_PLATFORM_UNIX_ARM) message("Detected Linux ARM") add_definitions(-DLINUX32) elseif(CLR_CMAKE_PLATFORM_UNIX_ARM64) message("Detected Linux ARM64") add_definitions(-DLINUX64) elseif(CLR_CMAKE_PLATFORM_UNIX_X86) message("Detected Linux i686") add_definitions(-DLINUX32) elseif(CLR_CMAKE_PLATFORM_UNIX_RISCV64) message("Detected Linux RiscV64") add_definitions(-DLINUX64) else() clr_unknown_arch() endif() endif(CLR_CMAKE_PLATFORM_LINUX) endif(CLR_CMAKE_PLATFORM_UNIX) if (CLR_CMAKE_PLATFORM_UNIX) add_definitions(-DPLATFORM_UNIX=1) if(CLR_CMAKE_PLATFORM_DARWIN) if(CLR_CMAKE_PLATFORM_UNIX_ARM64) message("Detected OSX ARM64") else() message("Detected OSX x86_64") endif() endif() if(CLR_CMAKE_PLATFORM_FREEBSD) message("Detected FreeBSD amd64") endif(CLR_CMAKE_PLATFORM_FREEBSD) if(CLR_CMAKE_PLATFORM_NETBSD) message("Detected NetBSD amd64") endif(CLR_CMAKE_PLATFORM_NETBSD) endif(CLR_CMAKE_PLATFORM_UNIX) if (WIN32) # Define the CRT lib references that link into Desktop imports set(STATIC_MT_CRT_LIB "libcmt$<$,$>:d>.lib") set(STATIC_MT_VCRT_LIB "libvcruntime$<$,$>:d>.lib") set(STATIC_MT_CPP_LIB "libcpmt$<$,$>:d>.lib") endif(WIN32) # Architecture specific files folder name if (CLR_CMAKE_TARGET_ARCH_AMD64) set(ARCH_SOURCES_DIR amd64) elseif (CLR_CMAKE_TARGET_ARCH_ARM64) set(ARCH_SOURCES_DIR arm64) elseif (CLR_CMAKE_TARGET_ARCH_ARM) set(ARCH_SOURCES_DIR arm) elseif (CLR_CMAKE_TARGET_ARCH_I386) set(ARCH_SOURCES_DIR i386) elseif (CLR_CMAKE_TARGET_ARCH_RISCV64) set(ARCH_SOURCES_DIR riscv64) else () clr_unknown_arch() endif () netcoredbg-3.1.0-1031/rpmbuild.cmake000066400000000000000000000027701457701673000170510ustar00rootroot00000000000000# This file contains function which extracts version information from rpmbuild's spec-file. # Find packaging/*.spec file and extract version from it ("Version:" entry), # file should be unique, empty string will be returned in case of error. function(RPMVersion result) set(pkg_path "${PROJECT_SOURCE_DIR}/packaging") set(version "") if (IS_DIRECTORY "${pkg_path}") file(GLOB spec_files RELATIVE "${pkg_path}" "${pkg_path}/*.spec") list(LENGTH spec_files n_spec) if (n_spec GREATER 1) message(WARNING "too many *.spec files found") elseif(NOT spec_files) message(WARNING "no *.spec file found in '${pkg_path}'.") else() set(specfile "${pkg_path}/${spec_files}") file(STRINGS ${specfile} ver REGEX "^Version:") if (NOT ver) message(WARNING "no Version in '${specfile}'.") else() string(REGEX REPLACE "^Version:[ \t]+([^[ \t\r\n]+).*" "\\1" version "${ver}") endif() file(STRINGS ${specfile} rel REGEX "^Release:") if (NOT rel) message(WARNING "no Release in '${specfile}'.") else() string(REGEX REPLACE "^Release:[ \t]+([^[ \t\r\n]+).*" "\\1" release "${rel}") set(version "${version}-${release}") endif() endif() else() message(WARNING "no '${pkg_path}' directory found!") endif() set(${result} "${version}" PARENT_SCOPE) endfunction(RPMVersion) netcoredbg-3.1.0-1031/src/000077500000000000000000000000001457701673000150125ustar00rootroot00000000000000netcoredbg-3.1.0-1031/src/.doxyfile000066400000000000000000000175721457701673000166520ustar00rootroot00000000000000DOXYFILE_ENCODING = UTF-8 PROJECT_NAME = "Netcoredbg" PROJECT_BRIEF = .NET debugger INPUT = @CMAKE_CURRENT_SOURCE_DIR@ OUTPUT_DIRECTORY = @CMAKE_CURRENT_BINARY_DIR@/doc EXCLUDE_PATTERNS = */unittests/* CREATE_SUBDIRS = NO ALLOW_UNICODE_NAMES = NO OUTPUT_LANGUAGE = English BRIEF_MEMBER_DESC = YES REPEAT_BRIEF = YES ABBREVIATE_BRIEF = "The $name class" \ "The $name widget" \ "The $name file" \ is \ provides \ specifies \ contains \ represents \ a \ an \ the ALWAYS_DETAILED_SEC = NO INLINE_INHERITED_MEMB = NO FULL_PATH_NAMES = NO STRIP_FROM_PATH = STRIP_FROM_INC_PATH = SHORT_NAMES = NO JAVADOC_AUTOBRIEF = YES QT_AUTOBRIEF = NO MULTILINE_CPP_IS_BRIEF = NO INHERIT_DOCS = YES SEPARATE_MEMBER_PAGES = NO TAB_SIZE = 4 ALIASES = TCL_SUBST = OPTIMIZE_OUTPUT_FOR_C = NO OPTIMIZE_OUTPUT_JAVA = NO OPTIMIZE_FOR_FORTRAN = NO OPTIMIZE_OUTPUT_VHDL = NO EXTENSION_MAPPING = MARKDOWN_SUPPORT = YES TOC_INCLUDE_HEADINGS = 0 AUTOLINK_SUPPORT = YES BUILTIN_STL_SUPPORT = NO CPP_CLI_SUPPORT = NO SIP_SUPPORT = NO IDL_PROPERTY_SUPPORT = YES DISTRIBUTE_GROUP_DOC = NO GROUP_NESTED_COMPOUNDS = NO SUBGROUPING = YES INLINE_GROUPED_CLASSES = NO INLINE_SIMPLE_STRUCTS = YES TYPEDEF_HIDES_STRUCT = NO LOOKUP_CACHE_SIZE = 0 EXTRACT_ALL = NO EXTRACT_PRIVATE = NO EXTRACT_PACKAGE = NO EXTRACT_STATIC = NO EXTRACT_LOCAL_CLASSES = YES EXTRACT_LOCAL_METHODS = NO EXTRACT_ANON_NSPACES = NO HIDE_UNDOC_MEMBERS = NO HIDE_UNDOC_CLASSES = NO HIDE_FRIEND_COMPOUNDS = NO HIDE_IN_BODY_DOCS = NO INTERNAL_DOCS = NO CASE_SENSE_NAMES = YES HIDE_SCOPE_NAMES = NO HIDE_COMPOUND_REFERENCE= NO SHOW_INCLUDE_FILES = YES SHOW_GROUPED_MEMB_INC = NO FORCE_LOCAL_INCLUDES = NO INLINE_INFO = YES SORT_MEMBER_DOCS = YES SORT_BRIEF_DOCS = NO SORT_MEMBERS_CTORS_1ST = NO SORT_GROUP_NAMES = NO SORT_BY_SCOPE_NAME = NO STRICT_PROTO_MATCHING = NO GENERATE_TODOLIST = YES GENERATE_TESTLIST = YES GENERATE_BUGLIST = YES GENERATE_DEPRECATEDLIST= YES ENABLED_SECTIONS = MAX_INITIALIZER_LINES = 30 SHOW_USED_FILES = YES SHOW_FILES = YES SHOW_NAMESPACES = YES FILE_VERSION_FILTER = LAYOUT_FILE = CITE_BIB_FILES = QUIET = NO WARNINGS = YES WARN_IF_UNDOCUMENTED = YES WARN_IF_DOC_ERROR = YES WARN_NO_PARAMDOC = NO WARN_AS_ERROR = NO WARN_FORMAT = "$file:$line: $text" WARN_LOGFILE = INPUT_ENCODING = UTF-8 FILE_PATTERNS = *.h *.cpp *.c *.cs *.cxx *.hxx *.hpp *.hh *.C *.cc RECURSIVE = YES EXCLUDE = Catch2 EXCLUDE_SYMLINKS = NO EXCLUDE_SYMBOLS = EXAMPLE_PATH = EXAMPLE_PATTERNS = * EXAMPLE_RECURSIVE = NO IMAGE_PATH = INPUT_FILTER = FILTER_PATTERNS = FILTER_SOURCE_FILES = NO FILTER_SOURCE_PATTERNS = USE_MDFILE_AS_MAINPAGE = SOURCE_BROWSER = NO INLINE_SOURCES = NO STRIP_CODE_COMMENTS = YES REFERENCED_BY_RELATION = NO REFERENCES_RELATION = NO REFERENCES_LINK_SOURCE = YES SOURCE_TOOLTIPS = YES USE_HTAGS = NO VERBATIM_HEADERS = YES CLANG_ASSISTED_PARSING = NO CLANG_OPTIONS = ALPHABETICAL_INDEX = YES COLS_IN_ALPHA_INDEX = 5 IGNORE_PREFIX = GENERATE_HTML = YES HTML_OUTPUT = html HTML_FILE_EXTENSION = .html HTML_HEADER = HTML_FOOTER = HTML_STYLESHEET = HTML_EXTRA_STYLESHEET = HTML_EXTRA_FILES = HTML_COLORSTYLE_HUE = 220 HTML_COLORSTYLE_SAT = 100 HTML_COLORSTYLE_GAMMA = 80 HTML_TIMESTAMP = NO HTML_DYNAMIC_SECTIONS = NO HTML_INDEX_NUM_ENTRIES = 100 GENERATE_DOCSET = NO DOCSET_FEEDNAME = "Doxygen generated docs" DOCSET_BUNDLE_ID = org.doxygen.Project DOCSET_PUBLISHER_ID = org.doxygen.Publisher DOCSET_PUBLISHER_NAME = Publisher GENERATE_HTMLHELP = NO CHM_FILE = HHC_LOCATION = GENERATE_CHI = NO CHM_INDEX_ENCODING = BINARY_TOC = NO TOC_EXPAND = NO GENERATE_QHP = NO QCH_FILE = QHP_NAMESPACE = org.doxygen.Project QHP_VIRTUAL_FOLDER = doc QHP_CUST_FILTER_NAME = QHP_CUST_FILTER_ATTRS = QHP_SECT_FILTER_ATTRS = QHG_LOCATION = GENERATE_ECLIPSEHELP = NO ECLIPSE_DOC_ID = org.doxygen.Project DISABLE_INDEX = NO GENERATE_TREEVIEW = NO ENUM_VALUES_PER_LINE = 4 TREEVIEW_WIDTH = 250 EXT_LINKS_IN_WINDOW = NO FORMULA_FONTSIZE = 10 FORMULA_TRANSPARENT = YES USE_MATHJAX = NO MATHJAX_FORMAT = HTML-CSS MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest MATHJAX_EXTENSIONS = MATHJAX_CODEFILE = SEARCHENGINE = YES SERVER_BASED_SEARCH = NO EXTERNAL_SEARCH = NO SEARCHENGINE_URL = SEARCHDATA_FILE = searchdata.xml EXTERNAL_SEARCH_ID = EXTRA_SEARCH_MAPPINGS = GENERATE_LATEX = NO LATEX_OUTPUT = latex LATEX_CMD_NAME = latex MAKEINDEX_CMD_NAME = makeindex COMPACT_LATEX = NO PAPER_TYPE = a4 EXTRA_PACKAGES = LATEX_HEADER = LATEX_FOOTER = LATEX_EXTRA_STYLESHEET = LATEX_EXTRA_FILES = PDF_HYPERLINKS = YES USE_PDFLATEX = YES LATEX_BATCHMODE = NO LATEX_HIDE_INDICES = NO LATEX_SOURCE_CODE = NO LATEX_BIB_STYLE = plain LATEX_TIMESTAMP = NO GENERATE_RTF = NO RTF_OUTPUT = rtf COMPACT_RTF = NO RTF_HYPERLINKS = NO RTF_STYLESHEET_FILE = RTF_EXTENSIONS_FILE = RTF_SOURCE_CODE = NO GENERATE_MAN = NO MAN_OUTPUT = man MAN_EXTENSION = .3 MAN_SUBDIR = MAN_LINKS = NO GENERATE_XML = NO XML_OUTPUT = xml XML_PROGRAMLISTING = YES GENERATE_DOCBOOK = NO DOCBOOK_OUTPUT = docbook DOCBOOK_PROGRAMLISTING = NO GENERATE_AUTOGEN_DEF = NO GENERATE_PERLMOD = NO PERLMOD_LATEX = NO PERLMOD_PRETTY = YES PERLMOD_MAKEVAR_PREFIX = ENABLE_PREPROCESSING = YES MACRO_EXPANSION = NO EXPAND_ONLY_PREDEF = NO SEARCH_INCLUDES = YES INCLUDE_PATH = INCLUDE_FILE_PATTERNS = PREDEFINED = EXPAND_AS_DEFINED = SKIP_FUNCTION_MACROS = YES TAGFILES = GENERATE_TAGFILE = ALLEXTERNALS = NO EXTERNAL_GROUPS = YES EXTERNAL_PAGES = YES PERL_PATH = /usr/bin/perl CLASS_DIAGRAMS = YES MSCGEN_PATH = DIA_PATH = HIDE_UNDOC_RELATIONS = YES HAVE_DOT = YES DOT_NUM_THREADS = 0 DOT_FONTNAME = Helvetica DOT_FONTSIZE = 10 DOT_FONTPATH = CLASS_GRAPH = YES COLLABORATION_GRAPH = YES GROUP_GRAPHS = YES UML_LOOK = NO UML_LIMIT_NUM_FIELDS = 10 TEMPLATE_RELATIONS = NO INCLUDE_GRAPH = YES INCLUDED_BY_GRAPH = YES CALL_GRAPH = NO CALLER_GRAPH = NO GRAPHICAL_HIERARCHY = YES DIRECTORY_GRAPH = YES DOT_IMAGE_FORMAT = png INTERACTIVE_SVG = NO DOT_PATH = DOTFILE_DIRS = MSCFILE_DIRS = DIAFILE_DIRS = PLANTUML_JAR_PATH = PLANTUML_CFG_FILE = PLANTUML_INCLUDE_PATH = DOT_GRAPH_MAX_NODES = 50 MAX_DOT_GRAPH_DEPTH = 0 DOT_TRANSPARENT = NO DOT_MULTI_TARGETS = NO GENERATE_LEGEND = YES DOT_CLEANUP = YES netcoredbg-3.1.0-1031/src/CMakeLists.txt000066400000000000000000000342051457701673000175560ustar00rootroot00000000000000# Locate dbgshim library # application name for tizens logger add_definitions(-DLOG_TAG="NETCOREDBG") if (NOT DBGSHIM_DIR STREQUAL "") add_definitions(-DDBGSHIM_DIR="${DBGSHIM_DIR}") endif() # Build corguids static library from coreclr source files if (NOT WIN32) add_compile_options(-Wno-extra-tokens) endif() add_compile_options(-D_MIDL_USE_GUIDDEF_) file(GLOB CORGUIDS_SOURCES "${CORECLR_SRC_DIR}/pal/prebuilt/idl/*_i.cpp") add_library(corguids STATIC ${CORGUIDS_SOURCES}) if (NOT WIN32) target_compile_options(corguids PRIVATE -Wno-unused-parameter) target_include_directories(corguids PRIVATE ${CORECLR_SRC_DIR}/pal/inc ${CORECLR_SRC_DIR}/pal/inc/rt) target_include_directories(corguids PRIVATE ${CORECLR_SRC_DIR}/inc ${CORECLR_SRC_DIR}/debug/inc) endif() # Include coreclr headers if (NOT WIN32) include_directories(${CORECLR_SRC_DIR}/pal/prebuilt/inc) include_directories(${CMAKE_CURRENT_SOURCE_DIR}/coreclr) else() include_directories(${CORECLR_SRC_DIR}/inc ${CORECLR_SRC_DIR}/debug/inc) endif() include_directories(${CORECLR_SRC_DIR}) include_directories(${CORECLR_SRC_DIR}/debug/shim) include_directories(${CORECLR_SRC_DIR}/dlls/dbgshim) # for CoreCLR <= 3.x include_directories(${CORECLR_SRC_DIR}/coreclr/hosts/inc) # for dotnet-runtime (> 3.x) include_directories(${CORECLR_SRC_DIR}/hosts/inc) # Build native part of the debugger include_directories(${PROJECT_SOURCE_DIR}/third_party) include_directories(${PROJECT_SOURCE_DIR}/third_party/linenoise-ng/include) include_directories(${CMAKE_CURRENT_SOURCE_DIR}) include_directories(${PROJECT_BINARY_DIR}/generated) include_directories(${PROJECT_SOURCE_DIR}/src/windows ${PROJECT_SOURCE_DIR}/src/unix) # Generate error messages from corerror.xml set(ERRORMESSAGE_DLL_NAME generrmsg/bin/generrmsg.dll) find_program(DOTNETCLI dotnet PATHS "${DOTNET_DIR}" ENV PATH NO_DEFAULT_PATH) add_custom_command( OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/generrmsg/generrmsg.csproj" COMMAND ${CMAKE_COMMAND} -E env DOTNET_CLI_TELEMETRY_OPTOUT=1 DOTNET_NEW_LOCAL_SEARCH_FILE_ONLY=1 ${DOTNETCLI} new console --force -n generrmsg WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" COMMENT "Creating new dotnet project" VERBATIM ) add_custom_command( OUTPUT ${ERRORMESSAGE_DLL_NAME} COMMAND ${CMAKE_COMMAND} -E copy ${PROJECT_SOURCE_DIR}/tools/generrmsg/GenErrMsg.cs Program.cs COMMAND ${CMAKE_COMMAND} -E copy ${PROJECT_SOURCE_DIR}/tools/generrmsg/nuget.xml nuget.config COMMAND ${DOTNETCLI} build -o bin/ WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/generrmsg" DEPENDS "${PROJECT_SOURCE_DIR}/tools/generrmsg/GenErrMsg.cs" "${CMAKE_CURRENT_BINARY_DIR}/generrmsg/generrmsg.csproj" COMMENT "Compiling ${ERRORMESSAGE_DLL_NAME}" VERBATIM ) add_custom_command( OUTPUT errormessage.cpp COMMAND ${DOTNETCLI} generrmsg/bin/generrmsg.dll ${CORECLR_SRC_DIR}/inc/corerror.xml ${CMAKE_CURRENT_BINARY_DIR}/errormessage.cpp ${CMAKE_CURRENT_BINARY_DIR}/errormessage.h WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" DEPENDS "${CORECLR_SRC_DIR}/inc/corerror.xml" ${ERRORMESSAGE_DLL_NAME} COMMENT "Extracting ${CORECLR_SRC_DIR}/inc/corerror.xml" VERBATIM ) set(netcoredbg_SRC debugger/breakpoint_break.cpp debugger/breakpoint_entry.cpp debugger/breakpoint_hotreload.cpp debugger/breakpoints_exception.cpp debugger/breakpoints_func.cpp debugger/breakpoints_line.cpp debugger/breakpoints.cpp debugger/breakpointutils.cpp debugger/callbacksqueue.cpp debugger/evalhelpers.cpp debugger/evalstackmachine.cpp debugger/evaluator.cpp debugger/evalwaiter.cpp debugger/evalutils.cpp debugger/frames.cpp debugger/hotreloadhelpers.cpp debugger/managedcallback.cpp debugger/manageddebugger.cpp debugger/threads.cpp debugger/stepper_async.cpp debugger/stepper_simple.cpp debugger/steppers.cpp debugger/valueprint.cpp debugger/variables.cpp debugger/waitpid.cpp interfaces/types.cpp managed/interop.cpp metadata/attributes.cpp metadata/async_info.cpp metadata/jmc.cpp metadata/modules.cpp metadata/modules_app_update.cpp metadata/modules_sources.cpp metadata/typeprinter.cpp protocols/cliprotocol.cpp protocols/escaped_string.cpp protocols/protocol_utils.cpp protocols/miprotocol.cpp protocols/tokenizer.cpp protocols/vscodeprotocol.cpp protocols/sourcestorage.cpp utils/utf.cpp errormessage.cpp main.cpp buildinfo.cpp utils/dynlibs_unix.cpp utils/dynlibs_win32.cpp utils/filesystem.cpp utils/filesystem_unix.cpp utils/filesystem_win32.cpp utils/ioredirect.cpp utils/iosystem_unix.cpp utils/iosystem_win32.cpp utils/interop_unix.cpp utils/interop_win32.cpp utils/platform_unix.cpp utils/platform_win32.cpp utils/streams.cpp ) set(CMAKE_INCLUDE_CURRENT_DIR OFF) if (NOT WIN32) add_definitions(-DPAL_STDCPP_COMPAT) endif() if (WIN32) # fix issue with std::numeric_limits::max() and std::max() add_definitions(-DNOMINMAX) endif() if (NOT CLR_CMAKE_TARGET_TIZEN_LINUX) list(APPEND netcoredbg_SRC utils/logger.cpp) endif() if (INTEROP_DEBUGGING) list(APPEND netcoredbg_SRC debugger/breakpoint_interop_rendezvous.cpp debugger/breakpoints_interop.cpp debugger/breakpoints_interop_line.cpp debugger/interop_brk_helpers.cpp debugger/interop_debugging.cpp debugger/interop_mem_helpers.cpp debugger/interop_ptrace_helpers.cpp debugger/interop_unwind.cpp debugger/sigaction.cpp metadata/interop_libraries.cpp ) if (CLR_CMAKE_PLATFORM_UNIX_ARM) list(APPEND netcoredbg_SRC debugger/interop_arm32_singlestep_helpers.cpp) endif() endif (INTEROP_DEBUGGING) # special threatment of buildinfo.cpp -- this file rebuilds every time, # whatever it changed or not (because it contains version information and # date/time of the build). cmake_host_system_information(RESULT fqdn QUERY FQDN) string(CONCAT buildinfo_flags " " -DVERSION=${VERSION} " " -DBUILD_TYPE=${CMAKE_BUILD_TYPE} " " -DNETCOREDBG_VCS_INFO=${NETCOREDBG_VCS_INFO} " " -DCORECLR_VCS_INFO=${CORECLR_VCS_INFO} " " -DOS_NAME=${CMAKE_SYSTEM_NAME} " " -DCPU_ARCH=${CLR_CMAKE_TARGET_ARCH} " " -DHOSTNAME=${fqdn} ) set_source_files_properties(buildinfo.cpp PROPERTIES COMPILE_FLAGS "${buildinfo_flags}") add_custom_target(buildinfo ALL COMMAND ${CMAKE_COMMAND} -E touch "${CMAKE_SOURCE_DIR}/src/buildinfo.cpp") add_executable(netcoredbg ${netcoredbg_SRC}) if (WIN32) target_link_libraries(netcoredbg corguids wsock32 ws2_32 linenoise) else() target_link_libraries(netcoredbg corguids dl pthread linenoise) endif() if (NCDB_DOTNET_STARTUP_HOOK) add_definitions(-DNCDB_DOTNET_STARTUP_HOOK="${NCDB_DOTNET_STARTUP_HOOK}") endif (NCDB_DOTNET_STARTUP_HOOK) if (INTEROP_DEBUGGING) if (NOT CLR_CMAKE_PLATFORM_LINUX) message(FATAL_ERROR "Interop debugging feature not implemented for this OS.") endif() if (CLR_CMAKE_PLATFORM_UNIX_RISCV64) message(FATAL_ERROR "Interop debugging feature not implemented for RISCV64.") endif() add_definitions(-DINTEROP_DEBUGGING) if (CLR_CMAKE_PLATFORM_UNIX_AMD64) add_definitions(-DDEBUGGER_UNIX_AMD64) elseif (CLR_CMAKE_PLATFORM_UNIX_X86) add_definitions(-DDEBUGGER_UNIX_X86) elseif (CLR_CMAKE_PLATFORM_UNIX_ARM64) add_definitions(-DDEBUGGER_UNIX_ARM64) elseif (CLR_CMAKE_PLATFORM_UNIX_ARM) add_definitions(-DDEBUGGER_UNIX_ARM) else() message(FATAL_ERROR "Interop debugging feature not implemented for this CPU architecture.") endif() target_link_libraries(netcoredbg elf++ dwarf++) include_directories(${PROJECT_SOURCE_DIR}/third_party/libelfin/elf ${PROJECT_SOURCE_DIR}/third_party/libelfin/dwarf) # libunwind find_path(LIBUNWIND_INCLUDE_DIRS NAMES libunwind.h) find_library(LIBUNWIND_LIBRARY unwind) find_library(LIBUNWIND_PTRACE_LIBRARY unwind-ptrace) if (CLR_CMAKE_PLATFORM_UNIX_AMD64) find_library(LIBUNWIND_LIBRARY_ARCH unwind-x86_64) elseif (CLR_CMAKE_PLATFORM_UNIX_X86) find_library(LIBUNWIND_LIBRARY_ARCH unwind-x86) elseif (CLR_CMAKE_PLATFORM_UNIX_ARM64) find_library(LIBUNWIND_LIBRARY_ARCH unwind-aarch64) elseif (CLR_CMAKE_PLATFORM_UNIX_ARM) find_library(LIBUNWIND_LIBRARY_ARCH unwind-arm) endif() if (${LIBUNWIND_INCLUDE_DIRS} STREQUAL "LIBUNWIND_INCLUDE_DIRS-NOTFOUND") message(FATAL_ERROR "Libunwind headers not found") endif() if (${LIBUNWIND_LIBRARY} STREQUAL "LIBUNWIND_LIBRARY-NOTFOUND") message(FATAL_ERROR "Libunwind lib not found") endif() if (${LIBUNWIND_PTRACE_LIBRARY} STREQUAL "LIBUNWIND_PTRACE_LIBRARY-NOTFOUND") message(FATAL_ERROR "Libunwind-ptrace libs not found") endif() if (${LIBUNWIND_LIBRARY_ARCH} STREQUAL "LIBUNWIND_LIBRARY_ARCH-NOTFOUND") message(FATAL_ERROR "Libunwind libs for this arch not found") endif() target_link_libraries(netcoredbg ${LIBUNWIND_LIBRARY} ${LIBUNWIND_PTRACE_LIBRARY} ${LIBUNWIND_LIBRARY_ARCH}) include_directories(${LIBUNWIND_INCLUDE_DIRS}) endif (INTEROP_DEBUGGING) if (CLR_CMAKE_TARGET_TIZEN_LINUX) add_definitions(-DDEBUGGER_FOR_TIZEN) target_link_libraries(netcoredbg dlog) endif (CLR_CMAKE_TARGET_TIZEN_LINUX) add_custom_command( TARGET netcoredbg PRE_BUILD COMMAND ${CMAKE_COMMAND} -E touch_nocreate ${ERRORMESSAGE_DLL_NAME} COMMAND ${CMAKE_COMMAND} -E remove -f obj/project.assets.json WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" ) install(TARGETS netcoredbg DESTINATION ${CMAKE_INSTALL_PREFIX}) # Build managed part of the debugger (ManagedPart.dll) if (BUILD_MANAGED) set(MANAGEDPART_PROJECT ${CMAKE_CURRENT_SOURCE_DIR}/managed/ManagedPart.csproj) set(MANAGEDPART_DLL_NAME ManagedPart.dll) set(DOTNET_BUILD_RESULT ${CMAKE_CURRENT_BINARY_DIR}/${MANAGEDPART_DLL_NAME}) find_program(DOTNETCLI dotnet PATHS "${DOTNET_DIR}" ENV PATH NO_DEFAULT_PATH) if (CMAKE_BUILD_TYPE STREQUAL "Debug") set(MANAGEDPART_BUILD_TYPE "Debug") else() # CMAKE_BUILD_TYPE not set or Release, RelWithDebInfo, MinSizeRel, ... set(MANAGEDPART_BUILD_TYPE "Release") endif() set(USE_DBGSHIM_DEPENDENCY "") if (DBGSHIM_DIR STREQUAL "") set(USE_DBGSHIM_DEPENDENCY "/p:UseDbgShimDependency=true") endif() if (NOT RID_NAME) if (CLR_CMAKE_PLATFORM_UNIX) if (CLR_CMAKE_PLATFORM_DARWIN) set(RID_NAME "osx") elseif (EXISTS "/etc/alpine-release") # Alpine use musl only. set(RID_NAME "linux-musl") else() set(RID_NAME "linux") endif() elseif (WIN32) set(RID_NAME "win") else() message(FATAL_ERROR "Unsupported platform") endif() endif() # NOT RID_NAME add_custom_command(OUTPUT ${DOTNET_BUILD_RESULT} COMMAND ${DOTNETCLI} publish ${MANAGEDPART_PROJECT} -r ${RID_NAME}-${CLR_CMAKE_TARGET_ARCH} --self-contained -c ${MANAGEDPART_BUILD_TYPE} -o ${CMAKE_CURRENT_BINARY_DIR} /p:BaseIntermediateOutputPath=${CMAKE_CURRENT_BINARY_DIR}/obj/ /p:BaseOutputPath=${CMAKE_CURRENT_BINARY_DIR}/bin/ ${USE_DBGSHIM_DEPENDENCY} WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/managed/*.cs" "${MANAGEDPART_PROJECT}" COMMENT "Compiling ${MANAGEDPART_DLL_NAME}" VERBATIM ) add_custom_target(managedpart_dll ALL DEPENDS ${DOTNET_BUILD_RESULT}) # Copy dlls set(ROSLYN_DLLS Microsoft.CodeAnalysis.dll Microsoft.CodeAnalysis.CSharp.dll Microsoft.CodeAnalysis.Scripting.dll Microsoft.CodeAnalysis.CSharp.Scripting.dll) set(DLLS_TO_DEPLOY ${DOTNET_BUILD_RESULT}) foreach(ITEM ${ROSLYN_DLLS}) list(APPEND DLLS_TO_DEPLOY "${CMAKE_CURRENT_BINARY_DIR}/${ITEM}") endforeach() install(FILES ${DLLS_TO_DEPLOY} DESTINATION ${CMAKE_INSTALL_PREFIX}) if (DBGSHIM_DIR STREQUAL "") if (CLR_CMAKE_PLATFORM_UNIX) if (CLR_CMAKE_PLATFORM_DARWIN) set(DBGSHIM_LIB_NAME "libdbgshim.dylib") else() set(DBGSHIM_LIB_NAME "libdbgshim.so") endif() elseif (WIN32) set(DBGSHIM_LIB_NAME "dbgshim.dll") else() message(FATAL_ERROR "Unsupported platform") endif() install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${DBGSHIM_LIB_NAME} DESTINATION ${CMAKE_INSTALL_PREFIX}) endif() endif() # Build Hot Reload managed dll (ncdbhook.dll) if (BUILD_MANAGED AND NCDB_DOTNET_STARTUP_HOOK) set(NCDBHOOK_PROJECT ${CMAKE_CURRENT_SOURCE_DIR}/ncdbhook/ncdbhook.csproj) set(NCDBHOOK_DLL_NAME ncdbhook.dll) set(NCDBHOOK_DOTNET_BUILD_RESULT ${CMAKE_CURRENT_BINARY_DIR}/${NCDBHOOK_DLL_NAME}) set(NCDB_HOOK_TargetFramework "net6.0") find_program(DOTNETCLI dotnet PATHS "${DOTNET_DIR}" ENV PATH NO_DEFAULT_PATH) # Build Debug only, code must be not optimized. add_custom_command(OUTPUT ${NCDBHOOK_DOTNET_BUILD_RESULT} COMMAND NCDB_HOOK_TargetFramework=${NCDB_HOOK_TargetFramework} ${DOTNETCLI} publish ${NCDBHOOK_PROJECT} -c Debug -o ${CMAKE_CURRENT_BINARY_DIR} /p:BaseIntermediateOutputPath=${CMAKE_CURRENT_BINARY_DIR}/obj/ /p:BaseOutputPath=${CMAKE_CURRENT_BINARY_DIR}/bin/ WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/ncdbhook/*.cs" "${NCDBHOOK_PROJECT}" COMMENT "Compiling ${NCDBHOOK_DLL_NAME}" VERBATIM ) add_custom_target(ncdbhook_dll ALL DEPENDS ${NCDBHOOK_DOTNET_BUILD_RESULT}) install(FILES ${NCDBHOOK_DOTNET_BUILD_RESULT} DESTINATION ${CMAKE_INSTALL_PREFIX}) endif() # documentation option(BUILD_DOC "Build documentation" OFF) if (BUILD_DOC) find_package(Doxygen) if (DOXYGEN_FOUND) configure_file(${CMAKE_CURRENT_SOURCE_DIR}/.doxyfile ${CMAKE_CURRENT_BINARY_DIR}/doxyfile) add_custom_target(doxygen ALL COMMAND ${DOXYGEN_EXECUTABLE} -s ${CMAKE_CURRENT_BINARY_DIR}/doxyfile WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} COMMENT "Generating doxygen documentation..." VERBATIM) else() message("Doxygen need to be installed to generate documentation") endif() endif() # unit tests if (BUILD_TESTING) add_subdirectory(unittests) endif() netcoredbg-3.1.0-1031/src/buildinfo.cpp000066400000000000000000000032271457701673000174750ustar00rootroot00000000000000// Copyright (C) 2020 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. // // Note: this file should be compiled with following C-preprocessor macros defined: // // * VERSION -- version for displaing (like x.y.z, short string); // // * BUILD_TYPE -- Debug, Release... // // * NETCOREDBG_VCS_INFO, CORECLR_VCS_INFO -- both should contain GIT revision hash, // tag name, SVN revision number, etc... might be empty, if revision isn't known; // // * OS_NAME should constain OS name for which project was build; // // * CPU_ARCH should contain name of the CPU architecture; // // * HOSTNAME should contain host name of the buildserver. // // All macros listed above must not have enclosing double quotes and typically // should be provided by buildsystem (CMake, etc...) #include "buildinfo.h" #include "version.h" #define STRINGIFY_(v) #v #define STRINGIFY(v) STRINGIFY_(v) namespace netcoredbg { namespace BuildInfo { const char version[] = STRINGIFY(VERSION); const char build_type[] = STRINGIFY(BUILD_TYPE); const char netcoredbg_vcs_info[] = STRINGIFY(NETCOREDBG_VCS_INFO); const char coreclr_vcs_info[] = STRINGIFY(CORECLR_VCS_INFO); const char os_name[] = STRINGIFY(OS_NAME); const char cpu_arch[] = STRINGIFY(CPU_ARCH); const char date[] = __DATE__; const char time[] = __TIME__; const char hostname[] = STRINGIFY(HOSTNAME); } } // netcoredbg // String containing version, build type and VCS revision combined (for external components, like logger). extern const char __version[] = STRINGIFY(VERSION) "-" STRINGIFY(BUILD_TYPE) "-" STRINGIFY(NETCOREDBG_VCS_INFO); netcoredbg-3.1.0-1031/src/buildinfo.h000066400000000000000000000017071457701673000171430ustar00rootroot00000000000000// Copyright (C) 2020 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #pragma once namespace netcoredbg { namespace BuildInfo { extern const char version[]; // version for displaying extern const char build_type[]; // build type (same version might have different build types) // Following two strings contain GIT revision hash, tag, SVN revision number, etc... extern const char netcoredbg_vcs_info[]; // for netcoredbg itself extern const char coreclr_vcs_info[]; // for CoreCLR (which might come from different source tree) extern const char os_name[]; // OS name for which project was build. extern const char cpu_arch[]; // CPU architecture name for which project was build. extern const char date[]; extern const char time[]; // Date and time of the build. extern const char hostname[]; // hostname of the buildserver. } } // namespace netcoredbg netcoredbg-3.1.0-1031/src/coreclr/000077500000000000000000000000001457701673000164435ustar00rootroot00000000000000netcoredbg-3.1.0-1031/src/coreclr/README.md000066400000000000000000000030251457701673000177220ustar00rootroot00000000000000This directory and files within this directory needed to resolve file name and identifier names clashing between CoreCLR and C/C++ libraries. In future (after dropping support of CoreCLR2.1) this directory might be removed and following directories should be added to global list of include-files directories: `${CORECLR_SRC_DIR}/pal/inc`, `${CORECLR_SRC_DIR}/pal/inc/rt`, `${CORECLR_SRC_DIR}/inc`, `${CORECLR_SRC_DIR}/debug/inc`. Originally few issues was exist with CoreCLR 2.1: 1) `specstrings.h` from CoreCLR defines `__deref` macros, which conflicts with some C++ code from `` (in case, when `_GLIBCXX_DEBUG` is defined); 2) `pal.h` from CoreCLR redefines few standard macroses from limits.h; 3) originally, CoreCLR source files tree was added to list of include directories, and `${CORECLR_SRC_DIR}src/pal/inc/rt` contains include-files with such names, that it clashes standard include files (especially, `assert.h`); 4) `pal.h` declares own version of mathematic functions with different exception specification (this brokes build with clang version >= 10). To solve issues 1, 2 and 3 this directory (`src/coreclr`) was created, which allows to include few coreclr files without file name clashing. And coreclr's paths was removed from global include directories list (from `src/CMakeLists.txt`). Issue 2 also fixed by ignoring warnings and redefinig macros back by including `limits.h` after inclusion of `pal.h`. Issue 4 can be fixed, if system `math.h` included before any of include file belonging to coreclr. netcoredbg-3.1.0-1031/src/coreclr/arrayholder.h000066400000000000000000000002241457701673000211260ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #include netcoredbg-3.1.0-1031/src/coreclr/cor.h000066400000000000000000000005171457701673000174020ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #pragma once #pragma warning (disable:4068) // Visual Studio should ignore GCC pragmas #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #include #pragma GCC diagnostic pop netcoredbg-3.1.0-1031/src/coreclr/cordebug.h000066400000000000000000000005451457701673000204120ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #pragma once #pragma warning (disable:4068) // Visual Studio should ignore GCC pragmas #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #include #pragma GCC diagnostic pop netcoredbg-3.1.0-1031/src/coreclr/corhdr.h000066400000000000000000000002171457701673000200750ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #include netcoredbg-3.1.0-1031/src/coreclr/no_sal2.h000066400000000000000000000002271457701673000201520ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #include netcoredbg-3.1.0-1031/src/coreclr/objidl.h000066400000000000000000000002261457701673000200570ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #include netcoredbg-3.1.0-1031/src/coreclr/ole2.h000066400000000000000000000002241457701673000174530ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #include netcoredbg-3.1.0-1031/src/coreclr/pal.h000066400000000000000000000005461457701673000173750ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #pragma once #pragma warning (disable:4068) // Visual Studio should ignore GCC pragmas #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wmacro-redefined" #include #include #pragma GCC diagnostic pop netcoredbg-3.1.0-1031/src/coreclr/pal_assert.h000066400000000000000000000002271457701673000207520ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #include netcoredbg-3.1.0-1031/src/coreclr/pal_char16.h000066400000000000000000000002271457701673000205350ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #include netcoredbg-3.1.0-1031/src/coreclr/pal_endian.h000066400000000000000000000002271457701673000207070ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #include netcoredbg-3.1.0-1031/src/coreclr/pal_error.h000066400000000000000000000002261457701673000206010ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #include netcoredbg-3.1.0-1031/src/coreclr/pal_mstypes.h000066400000000000000000000002301457701673000211470ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #include netcoredbg-3.1.0-1031/src/coreclr/palclr.h000066400000000000000000000002171457701673000200710ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #include netcoredbg-3.1.0-1031/src/coreclr/poppack.h000066400000000000000000000002271457701673000202520ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #include netcoredbg-3.1.0-1031/src/coreclr/pshpack1.h000066400000000000000000000002301457701673000203210ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #include netcoredbg-3.1.0-1031/src/coreclr/rpc.h000066400000000000000000000002231457701673000173750ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #include netcoredbg-3.1.0-1031/src/coreclr/rpcndr.h000066400000000000000000000002261457701673000201040ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #include netcoredbg-3.1.0-1031/src/coreclr/safemath.h000066400000000000000000000002211457701673000203770ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #include netcoredbg-3.1.0-1031/src/coreclr/sal.h000066400000000000000000000003111457701673000173660ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #include // Avoid name clashing with libstdc++ #undef __deref netcoredbg-3.1.0-1031/src/coreclr/specstrings.h000066400000000000000000000002331457701673000211560ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #include netcoredbg-3.1.0-1031/src/coreclr/specstrings_strict.h000066400000000000000000000002421457701673000225460ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #include netcoredbg-3.1.0-1031/src/coreclr/unknwn.h000066400000000000000000000002261457701673000201340ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #include netcoredbg-3.1.0-1031/src/coreclr/winerror.h000066400000000000000000000005161457701673000204650ustar00rootroot00000000000000// Copyright (C) 2021 Samsung Electronics Co., Ltd. // See the LICENSE file in the project root for more information. #pragma warning (disable:4068) // Visual Studio should ignore GCC pragmas #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" #include #pragma GCC diagnostic pop netcoredbg-3.1.0-1031/src/debugger/000077500000000000000000000000001457701673000165765ustar00rootroot00000000000000netcoredbg-3.1.0-1031/src/debugger/breakpoint_break.cpp000066400000000000000000000121201457701673000226000ustar00rootroot00000000000000// Copyright (c) 2021 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #include "debugger/breakpoint_break.h" #include "debugger/threads.h" #include "metadata/modules.h" #include "utils/torelease.h" namespace netcoredbg { HRESULT BreakBreakpoint::GetFullyQualifiedIlOffset(ICorDebugThread *pThread, FullyQualifiedIlOffset_t &fullyQualifiedIlOffset) { HRESULT Status; ToRelease pFrame; IfFailRet(pThread->GetActiveFrame(&pFrame)); if (pFrame == nullptr) return E_FAIL; mdMethodDef methodToken; IfFailRet(pFrame->GetFunctionToken(&methodToken)); ToRelease pFunc; IfFailRet(pFrame->GetFunction(&pFunc)); ToRelease pCode; IfFailRet(pFunc->GetILCode(&pCode)); ULONG32 methodVersion; IfFailRet(pCode->GetVersionNumber(&methodVersion)); ToRelease pModule; IfFailRet(pFunc->GetModule(&pModule)); CORDB_ADDRESS modAddress; IfFailRet(pModule->GetBaseAddress(&modAddress)); ToRelease pILFrame; IfFailRet(pFrame->QueryInterface(IID_ICorDebugILFrame, (LPVOID*) &pILFrame)); ULONG32 ilOffset; CorDebugMappingResult mappingResult; IfFailRet(pILFrame->GetIP(&ilOffset, &mappingResult)); if (mappingResult == MAPPING_UNMAPPED_ADDRESS || mappingResult == MAPPING_NO_INFO) return E_FAIL; fullyQualifiedIlOffset.modAddress = modAddress; fullyQualifiedIlOffset.methodToken = methodToken; fullyQualifiedIlOffset.methodVersion = methodVersion; fullyQualifiedIlOffset.ilOffset = ilOffset; return S_OK; } void BreakBreakpoint::SetLastStoppedIlOffset(ICorDebugProcess *pProcess, const ThreadId &lastStoppedThreadId) { std::lock_guard lock(m_breakMutex); m_lastStoppedIlOffset.Reset(); if (lastStoppedThreadId == ThreadId::AllThreads) return; ToRelease pThread; if (SUCCEEDED(pProcess->GetThread(int(lastStoppedThreadId), &pThread))) GetFullyQualifiedIlOffset(pThread, m_lastStoppedIlOffset); } HRESULT BreakBreakpoint::ManagedCallbackBreak(ICorDebugThread *pThread, const ThreadId &lastStoppedThreadId) { HRESULT Status; ToRelease iCorFrame; IfFailRet(pThread->GetActiveFrame(&iCorFrame)); // Ignore break on Break() outside of code with loaded PDB (see JMC setup during module load). if (iCorFrame != nullptr) { ToRelease iCorFunction; IfFailRet(iCorFrame->GetFunction(&iCorFunction)); ToRelease iCorFunction2; IfFailRet(iCorFunction->QueryInterface(IID_ICorDebugFunction2, (LPVOID*) &iCorFunction2)); BOOL JMCStatus; IfFailRet(iCorFunction2->GetJMCStatus(&JMCStatus)); if (JMCStatus == FALSE) return S_OK; } ThreadId threadId(getThreadId(pThread)); // Prevent stop event duplicate, if previous stop event was for same thread and same code point. // The idea is - store "fully qualified IL offset" (data for module + method + IL) on any stop event // and only at Break() callback check the real sequence point (required delegate call). // Note, that step/breakpoint/etc stop event at "Debugger.Break()" source line and stop event // generated by CoreCLR during Debugger.Break() execution in managed code have different IL offsets, // but same sequence point. std::lock_guard lock(m_breakMutex); if (threadId != lastStoppedThreadId || m_lastStoppedIlOffset.modAddress == 0 || m_lastStoppedIlOffset.methodToken == 0) return S_FALSE; FullyQualifiedIlOffset_t fullyQualifiedIlOffset; IfFailRet(GetFullyQualifiedIlOffset(pThread, fullyQualifiedIlOffset)); if (fullyQualifiedIlOffset.modAddress != m_lastStoppedIlOffset.modAddress || fullyQualifiedIlOffset.methodToken != m_lastStoppedIlOffset.methodToken || fullyQualifiedIlOffset.methodVersion != m_lastStoppedIlOffset.methodVersion) return S_FALSE; Modules::SequencePoint lastSP; IfFailRet(m_sharedModules->GetSequencePointByILOffset(m_lastStoppedIlOffset.modAddress, m_lastStoppedIlOffset.methodToken, m_lastStoppedIlOffset.methodVersion, m_lastStoppedIlOffset.ilOffset, lastSP)); Modules::SequencePoint curSP; IfFailRet(m_sharedModules->GetSequencePointByILOffset(fullyQualifiedIlOffset.modAddress, fullyQualifiedIlOffset.methodToken, fullyQualifiedIlOffset.methodVersion, fullyQualifiedIlOffset.ilOffset, curSP)); if (lastSP.startLine != curSP.startLine || lastSP.startColumn != curSP.startColumn || lastSP.endLine != curSP.endLine || lastSP.endColumn != curSP.endColumn || lastSP.offset != curSP.offset || lastSP.document != curSP.document) return S_FALSE; return S_OK; } } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/breakpoint_break.h000066400000000000000000000031721457701673000222540ustar00rootroot00000000000000// Copyright (c) 2021 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #pragma once #include "cor.h" #include "cordebug.h" #include #include #include "interfaces/types.h" namespace netcoredbg { class Modules; class BreakBreakpoint { public: BreakBreakpoint(std::shared_ptr &sharedModules) : m_sharedModules(sharedModules) {} void SetLastStoppedIlOffset(ICorDebugProcess *pProcess, const ThreadId &lastStoppedThreadId); // Important! Callbacks related methods must control return for succeeded return code. // Do not allow debugger API return succeeded (uncontrolled) return code. // Bad : // return pThread->GetID(&threadId); // Good: // IfFailRet(pThread->GetID(&threadId)); // return S_OK; HRESULT ManagedCallbackBreak(ICorDebugThread *pThread, const ThreadId &lastStoppedThreadId); private: std::mutex m_breakMutex; std::shared_ptr m_sharedModules; struct FullyQualifiedIlOffset_t { CORDB_ADDRESS modAddress = 0; mdMethodDef methodToken = 0; ULONG32 methodVersion = 0; ULONG32 ilOffset = 0; void Reset() { modAddress = 0; methodToken = 0; methodVersion = 0; ilOffset = 0; } }; FullyQualifiedIlOffset_t m_lastStoppedIlOffset; HRESULT GetFullyQualifiedIlOffset(ICorDebugThread *pThread, FullyQualifiedIlOffset_t &fullyQualifiedIlOffset); }; } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/breakpoint_entry.cpp000066400000000000000000000232761457701673000226730ustar00rootroot00000000000000// Copyright (c) 2021 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #include #include "debugger/breakpoint_entry.h" #include "debugger/breakpointutils.h" #include "metadata/modules.h" #include "utils/utf.h" namespace netcoredbg { static mdMethodDef GetEntryPointTokenFromFile(const std::string &path) { class scope_guard { private: FILE **ppFile_; public: scope_guard(FILE **ppFile) : ppFile_(ppFile) {} ~scope_guard() {if (*ppFile_) fclose(*ppFile_);} }; FILE *pFile = nullptr; scope_guard file(&pFile); #ifdef WIN32 if (_wfopen_s(&pFile, to_utf16(path).c_str(), L"rb") != 0) return mdMethodDefNil; #else pFile = fopen(path.c_str(), "rb"); #endif // WIN32 if (!pFile) return mdMethodDefNil; IMAGE_DOS_HEADER dosHeader; IMAGE_NT_HEADERS32 ntHeaders; if (fread(&dosHeader, sizeof(dosHeader), 1, pFile) != 1) return mdMethodDefNil; if (fseek(pFile, VAL32(dosHeader.e_lfanew), SEEK_SET) != 0) return mdMethodDefNil; if (fread(&ntHeaders, sizeof(ntHeaders), 1, pFile) != 1) return mdMethodDefNil; ULONG corRVA = 0; if (ntHeaders.OptionalHeader.Magic == VAL16(IMAGE_NT_OPTIONAL_HDR32_MAGIC)) { corRVA = VAL32(ntHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COMHEADER].VirtualAddress); } else { IMAGE_NT_HEADERS64 ntHeaders64; if (fseek(pFile, VAL32(dosHeader.e_lfanew), SEEK_SET) != 0) return mdMethodDefNil; if (fread(&ntHeaders64, sizeof(ntHeaders64), 1, pFile) != 1) return mdMethodDefNil; corRVA = VAL32(ntHeaders64.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COMHEADER].VirtualAddress); } constexpr DWORD DWORD_MAX = 4294967295; DWORD pos = VAL32(dosHeader.e_lfanew); if (pos > DWORD_MAX - sizeof(ntHeaders.Signature) - sizeof(ntHeaders.FileHeader) - VAL16(ntHeaders.FileHeader.SizeOfOptionalHeader)) return mdMethodDefNil; pos += sizeof(ntHeaders.Signature) + sizeof(ntHeaders.FileHeader) + VAL16(ntHeaders.FileHeader.SizeOfOptionalHeader); if (fseek(pFile, pos, SEEK_SET) != 0) return mdMethodDefNil; for (int i = 0; i < VAL16(ntHeaders.FileHeader.NumberOfSections); i++) { IMAGE_SECTION_HEADER sectionHeader; if (fread(§ionHeader, sizeof(sectionHeader), 1, pFile) != 1) return mdMethodDefNil; if (corRVA >= VAL32(sectionHeader.VirtualAddress) && corRVA < VAL32(sectionHeader.VirtualAddress) + VAL32(sectionHeader.SizeOfRawData)) { ULONG offset = (corRVA - VAL32(sectionHeader.VirtualAddress)) + VAL32(sectionHeader.PointerToRawData); IMAGE_COR20_HEADER corHeader; if (fseek(pFile, offset, SEEK_SET) != 0) return mdMethodDefNil; if (fread(&corHeader, sizeof(corHeader), 1, pFile) != 1) return mdMethodDefNil; if (VAL32(corHeader.Flags) & COMIMAGE_FLAGS_NATIVE_ENTRYPOINT) return mdMethodDefNil; return VAL32(corHeader.EntryPointToken); } } return mdMethodDefNil; } // Try to setup proper entry breakpoint method token and IL offset for async Main method. // [in] pModule - module with async Main method; // [in] pMD - metadata interface for pModule; // [in] pModules - all loaded modules debug related data; // [in] mdMainClass - class token with Main method in module pModule; // [out] entryPointToken - corrected method token; // [out] entryPointOffset - corrected IL offset on first user code line. static HRESULT TrySetupAsyncEntryBreakpoint(ICorDebugModule *pModule, IMetaDataImport *pMD, Modules *pModules, mdTypeDef mdMainClass, mdMethodDef &entryPointToken, ULONG32 &entryPointOffset) { // In case of async method, compiler use `Namespace.ClassName.

()` as entry method, that call // `Namespace.ClassName.Main()`, that create `Namespace.ClassName.
d__0` and start state machine routine. // In this case, "real entry method" with user code from initial `Main()` method will be in: // Namespace.ClassName.
d__0.MoveNext() // Note, number in "
d__0" class name could be different. // Note, `Namespace.ClassName` could be different (see `-main` compiler option). // Note, `Namespace.ClassName.
d__0` type have enclosing class as method `Namespace.ClassName.
()` class. HRESULT Status; ULONG numTypedefs = 0; HCORENUM hEnum = NULL; mdTypeDef typeDef; mdMethodDef resultToken = mdMethodDefNil; while(SUCCEEDED(pMD->EnumTypeDefs(&hEnum, &typeDef, 1, &numTypedefs)) && numTypedefs != 0 && resultToken == mdMethodDefNil) { mdTypeDef mdEnclosingClass; if (FAILED(pMD->GetNestedClassProps(typeDef, &mdEnclosingClass) || mdEnclosingClass != mdMainClass)) continue; DWORD flags; WCHAR className[mdNameLen]; ULONG classNameLen; IfFailRet(pMD->GetTypeDefProps(typeDef, className, _countof(className), &classNameLen, &flags, NULL)); if (!starts_with(className, W("
d__"))) continue; ULONG numMethods = 0; HCORENUM fEnum = NULL; mdMethodDef methodDef; while(SUCCEEDED(pMD->EnumMethods(&fEnum, typeDef, &methodDef, 1, &numMethods)) && numMethods != 0) { mdTypeDef memTypeDef; WCHAR funcName[mdNameLen]; ULONG funcNameLen; if (FAILED(pMD->GetMethodProps(methodDef, &memTypeDef, funcName, _countof(funcName), &funcNameLen, nullptr, nullptr, nullptr, nullptr, nullptr))) { continue; } if (str_equal(funcName, W("MoveNext"))) { resultToken = methodDef; break; } } pMD->CloseEnum(fEnum); } pMD->CloseEnum(hEnum); if (resultToken == mdMethodDefNil) return E_FAIL; // Note, in case of async `MoveNext` method, user code don't start from 0 IL offset. ULONG32 ilNextOffset = 0; const ULONG32 currentVersion = 1; // In case entry breakpoint, this can be only base PDB, not delta PDB for sure. IfFailRet(pModules->GetNextUserCodeILOffsetInMethod(pModule, resultToken, currentVersion, 0, ilNextOffset)); entryPointToken = resultToken; entryPointOffset = ilNextOffset; return S_OK; } HRESULT EntryBreakpoint::ManagedCallbackLoadModule(ICorDebugModule *pModule) { std::lock_guard lock(m_entryMutex); if (!m_stopAtEntry || m_iCorFuncBreakpoint) return S_FALSE; HRESULT Status; mdMethodDef entryPointToken = GetEntryPointTokenFromFile(GetModuleFileName(pModule)); // Note, by some reason, in CoreCLR 6.0 System.Private.CoreLib.dll have Token "0" as entry point RVA. if (entryPointToken == mdMethodDefNil || TypeFromToken(entryPointToken) != mdtMethodDef) return S_FALSE; ULONG32 entryPointOffset = 0; ToRelease pMDUnknown; ToRelease pMD; mdTypeDef mdMainClass; WCHAR funcName[mdNameLen]; ULONG funcNameLen; // If we can't setup entry point correctly for async method, leave it "as is". if (SUCCEEDED(pModule->GetMetaDataInterface(IID_IMetaDataImport, &pMDUnknown)) && SUCCEEDED(pMDUnknown->QueryInterface(IID_IMetaDataImport, (LPVOID*) &pMD)) && SUCCEEDED(pMD->GetMethodProps(entryPointToken, &mdMainClass, funcName, _countof(funcName), &funcNameLen, nullptr, nullptr, nullptr, nullptr, nullptr)) && // The `Main` method is the entry point of a C# application. (Libraries and services do not require a Main method as an entry point.) // https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/main-and-command-args/ // In case of async method as entry method, GetEntryPointTokenFromFile() should return compiler's generated method `
`, plus, // this should be method without user code. str_equal(funcName, W("
"))) { TrySetupAsyncEntryBreakpoint(pModule, pMD, m_sharedModules.get(), mdMainClass, entryPointToken, entryPointOffset); } ToRelease pFunction; IfFailRet(pModule->GetFunctionFromToken(entryPointToken, &pFunction)); ToRelease pCode; IfFailRet(pFunction->GetILCode(&pCode)); ToRelease iCorFuncBreakpoint; IfFailRet(pCode->CreateBreakpoint(entryPointOffset, &iCorFuncBreakpoint)); m_iCorFuncBreakpoint = iCorFuncBreakpoint.Detach(); return S_OK; } HRESULT EntryBreakpoint::CheckBreakpointHit(ICorDebugThread *pThread, ICorDebugBreakpoint *pBreakpoint) { std::lock_guard lock(m_entryMutex); if (!m_stopAtEntry || !m_iCorFuncBreakpoint) return S_FALSE; // S_FALSE - no error, but not affect on callback HRESULT Status; ToRelease pFunctionBreakpoint; IfFailRet(pBreakpoint->QueryInterface(IID_ICorDebugFunctionBreakpoint, (LPVOID*) &pFunctionBreakpoint)); IfFailRet(BreakpointUtils::IsSameFunctionBreakpoint(pFunctionBreakpoint, m_iCorFuncBreakpoint)); if (Status == S_FALSE) return S_FALSE; m_iCorFuncBreakpoint->Activate(FALSE); m_iCorFuncBreakpoint.Free(); return S_OK; } void EntryBreakpoint::Delete() { std::lock_guard lock(m_entryMutex); if (!m_iCorFuncBreakpoint) return; m_iCorFuncBreakpoint->Activate(FALSE); m_iCorFuncBreakpoint.Free(); } } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/breakpoint_entry.h000066400000000000000000000026141457701673000223310ustar00rootroot00000000000000// Copyright (c) 2021 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #pragma once #include "cor.h" #include "cordebug.h" #include #include #include "utils/torelease.h" namespace netcoredbg { class Modules; class EntryBreakpoint { public: EntryBreakpoint(std::shared_ptr &sharedModules) : m_sharedModules(sharedModules), m_stopAtEntry(false) {} void SetStopAtEntry(bool enable) { m_stopAtEntry = enable; } void Delete(); // Important! Must provide succeeded return code: // S_OK - breakpoint hit // S_FALSE - no breakpoint hit HRESULT CheckBreakpointHit(ICorDebugThread *pThread, ICorDebugBreakpoint *pBreakpoint); // Important! Callbacks related methods must control return for succeeded return code. // Do not allow debugger API return succeeded (uncontrolled) return code. // Bad : // return pThread->GetID(&threadId); // Good: // IfFailRet(pThread->GetID(&threadId)); // return S_OK; HRESULT ManagedCallbackLoadModule(ICorDebugModule *pModule); private: std::mutex m_entryMutex; std::shared_ptr m_sharedModules; ToRelease m_iCorFuncBreakpoint; bool m_stopAtEntry; }; } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/breakpoint_hotreload.cpp000066400000000000000000000074271457701673000235130ustar00rootroot00000000000000// Copyright (c) 2022 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #include "debugger/breakpoint_hotreload.h" #include "debugger/breakpointutils.h" #include "debugger/hotreloadhelpers.h" #include "debugger/evalhelpers.h" #include "metadata/modules.h" namespace netcoredbg { HRESULT HotReloadBreakpoint::SetHotReloadBreakpoint(const std::string &updatedDLL, const std::unordered_set &updatedTypeTokens) { #ifdef NCDB_DOTNET_STARTUP_HOOK std::lock_guard lock(m_reloadMutex); if (!m_iCorFunc) return E_FAIL; if (m_iCorFuncBreakpoint) { // Case with several deltas applyed during `pause`. // TODO (?) support several DLLs update. assert(m_updatedDLL == updatedDLL); for (const auto &typeTokens : updatedTypeTokens) { m_updatedTypeTokens.insert(typeTokens); } return S_OK; } HRESULT Status; IfFailRet(m_iCorFunc->CreateBreakpoint(&m_iCorFuncBreakpoint)); if (FAILED(Status = m_iCorFuncBreakpoint->Activate(TRUE))) { m_iCorFuncBreakpoint.Free(); return Status; } m_updatedDLL = updatedDLL; m_updatedTypeTokens = updatedTypeTokens; return S_OK; #else // NCDB_DOTNET_STARTUP_HOOK return E_NOTIMPL; #endif // NCDB_DOTNET_STARTUP_HOOK } HRESULT HotReloadBreakpoint::ManagedCallbackLoadModuleAll(ICorDebugModule *pModule) { #ifdef NCDB_DOTNET_STARTUP_HOOK static std::string dllName(NCDB_DOTNET_STARTUP_HOOK); std::lock_guard lock(m_reloadMutex); if (dllName != GetModuleFileName(pModule)) return S_OK; HRESULT Status; static const WCHAR className[] = W("StartupHook"); static const WCHAR methodName[] = W("ncdbfunc"); IfFailRet(FindFunction(pModule, className, methodName, &m_iCorFunc)); #endif // NCDB_DOTNET_STARTUP_HOOK return S_OK; } HRESULT HotReloadBreakpoint::CheckApplicationReload(ICorDebugThread *pThread, ICorDebugBreakpoint *pBreakpoint) { std::lock_guard lock(m_reloadMutex); if (!m_iCorFuncBreakpoint) return S_FALSE; // S_FALSE - no error, but not affect on callback HRESULT Status; HRESULT ReturnStatus; ToRelease pFunctionBreakpoint; IfFailRet(pBreakpoint->QueryInterface(IID_ICorDebugFunctionBreakpoint, (LPVOID*) &pFunctionBreakpoint)); IfFailRet(BreakpointUtils::IsSameFunctionBreakpoint(pFunctionBreakpoint, m_iCorFuncBreakpoint)); ReturnStatus = Status; // In case S_FALSE, probably, we stopped on another breakpoint, need check this and emit event. IfFailRet(HotReloadHelpers::UpdateApplication(pThread, m_sharedModules.get(), m_sharedEvaluator.get(), m_sharedEvalHelpers.get(), m_updatedDLL, m_updatedTypeTokens)); Clear(); return ReturnStatus; } void HotReloadBreakpoint::CheckApplicationReload(ICorDebugThread *pThread) { std::lock_guard lock(m_reloadMutex); if (!m_iCorFuncBreakpoint) return; HotReloadHelpers::UpdateApplication(pThread, m_sharedModules.get(), m_sharedEvaluator.get(), m_sharedEvalHelpers.get(), m_updatedDLL, m_updatedTypeTokens); Clear(); } void HotReloadBreakpoint::Delete() { std::lock_guard lock(m_reloadMutex); if (!m_iCorFuncBreakpoint) return; Clear(); } // Caller must care about m_reloadMutex. void HotReloadBreakpoint::Clear() { m_iCorFuncBreakpoint->Activate(FALSE); m_iCorFuncBreakpoint.Free(); m_updatedDLL.clear(); m_updatedTypeTokens.clear(); } } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/breakpoint_hotreload.h000066400000000000000000000033241457701673000231500ustar00rootroot00000000000000// Copyright (c) 2022 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #pragma once #include "cor.h" #include "cordebug.h" #include #include #include #include #include "utils/torelease.h" namespace netcoredbg { class Modules; class Evaluator; class EvalHelpers; class HotReloadBreakpoint { public: HotReloadBreakpoint(std::shared_ptr &sharedModules, std::shared_ptr &sharedEvaluator, std::shared_ptr &sharedEvalHelpers) : m_sharedModules(sharedModules), m_sharedEvaluator(sharedEvaluator), m_sharedEvalHelpers(sharedEvalHelpers) {} HRESULT SetHotReloadBreakpoint(const std::string &updatedDLL, const std::unordered_set &updatedTypeTokens); void Delete(); // Important! Must provide succeeded return code: // S_OK - internal HotReload breakpoint hit // S_FALSE - not internal HotReload breakpoint hit HRESULT CheckApplicationReload(ICorDebugThread *pThread, ICorDebugBreakpoint *pBreakpoint); void CheckApplicationReload(ICorDebugThread *pThread); HRESULT ManagedCallbackLoadModuleAll(ICorDebugModule *pModule); private: std::mutex m_reloadMutex; std::shared_ptr m_sharedModules; std::shared_ptr m_sharedEvaluator; std::shared_ptr m_sharedEvalHelpers; ToRelease m_iCorFunc; ToRelease m_iCorFuncBreakpoint; std::string m_updatedDLL; std::unordered_set m_updatedTypeTokens; void Clear(); }; } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/breakpoint_interop_rendezvous.cpp000066400000000000000000000107221457701673000254660ustar00rootroot00000000000000// Copyright (c) 2023 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #include "debugger/breakpoint_interop_rendezvous.h" #include "debugger/breakpoints_interop.h" #include "debugger/interop_brk_helpers.h" #include "debugger/interop_mem_helpers.h" #include "utils/logger.h" #include // r_debug::r_state enum (RT_CONSISTENT, RT_ADD, RT_DELETE) namespace netcoredbg { namespace InteropDebugging { // Must be called only in case all threads stopped during interop initialization. bool InteropRendezvousBreakpoint::SetupRendezvousBrk(pid_t pid, LoadLibCallback loadLibCB, UnloadLibCallback unloadLibCB, IsThumbCodeCallback isThumbCode, int &err_code) { m_loadLibCB = loadLibCB; m_unloadLibCB = unloadLibCB; // Libs load/unload related routine initialization. // TODO dlmopen() support with multiple load namespaces. if (!ResolveRendezvous(pid, m_rendezvousAddr)) { err_code = ENODATA; return false; } GetProcessLibs(pid, m_rendezvousAddr, [this, &pid] (const std::string &libName, std::uintptr_t startAddr) { std::string realLibName; std::uintptr_t endAddr = GetLibEndAddrAndRealName(pid, 0, realLibName, startAddr); if (endAddr == 0 || realLibName.empty()) // ignore in case error or linux-vdso.so return; m_loadLibCB(pid, libName, realLibName, startAddr, endAddr); m_libsNameToRealNameMap.emplace(libName, std::move(realLibName)); }); // Set break point on function that is called on each library load/unload. // For more information, see: // https://sourceware.org/git/?p=glibc.git;a=blob;f=elf/rtld-debugger-interface.txt // https://ypl.coffee/dl-resolve-full-relro/ m_brkAddr = GetRendezvousBrkAddr(pid, m_rendezvousAddr); err_code = m_sharedInteropBreakpoints->Add(pid, m_brkAddr, isThumbCode(m_brkAddr), [](){}); if (err_code != 0) return false; m_rendezvousBrkState = GetRendezvousBrkState(pid, m_rendezvousAddr); return true; } void InteropRendezvousBreakpoint::ChangeRendezvousState(pid_t TGID, pid_t pid) { // The logic is - at first method call type of incoming changed for list provided (add/delete) and at second method call libs list in consistent state. int state = GetRendezvousBrkState(TGID, m_rendezvousAddr); if (state == r_debug::RT_CONSISTENT) { if (m_rendezvousBrkState == r_debug::RT_ADD) { GetProcessLibs(TGID, m_rendezvousAddr, [this, &TGID, &pid] (const std::string &libName, std::uintptr_t startAddr) { if (m_libsNameToRealNameMap.find(libName) != m_libsNameToRealNameMap.end()) return; std::string realLibName; std::uintptr_t endAddr = GetLibEndAddrAndRealName(TGID, pid, realLibName, startAddr); if (endAddr == 0 || realLibName.empty()) // ignore in case error or linux-vdso.so return; m_loadLibCB(pid, libName, realLibName, startAddr, endAddr); m_libsNameToRealNameMap.emplace(libName, std::move(realLibName)); }); } else if (m_rendezvousBrkState == r_debug::RT_DELETE) { auto removeLibs = m_libsNameToRealNameMap; GetProcessLibs(TGID, m_rendezvousAddr, [&removeLibs] (const std::string &libName, std::uintptr_t) { removeLibs.erase(libName); }); for (auto &entry : removeLibs) { m_unloadLibCB(entry.second); m_libsNameToRealNameMap.erase(entry.first); } } } m_rendezvousBrkState = state; } bool InteropRendezvousBreakpoint::IsRendezvousBreakpoint(std::uintptr_t brkAddr) { if (m_brkAddr != 0 && brkAddr == m_brkAddr && m_sharedInteropBreakpoints->IsBreakpoint(m_brkAddr)) return true; return false; } // Must be called only in case all threads stopped and fixed (see InteropDebugger::StopAndDetach()). void InteropRendezvousBreakpoint::RemoveAtDetach(pid_t pid) { if (pid != 0) { m_sharedInteropBreakpoints->Remove(pid, m_brkAddr, [](){}, [](std::uintptr_t){}); } m_rendezvousAddr = 0; m_rendezvousBrkState = 0; m_brkAddr = 0; m_libsNameToRealNameMap.clear(); } } // namespace InteropDebugging } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/breakpoint_interop_rendezvous.h000066400000000000000000000034621457701673000251360ustar00rootroot00000000000000// Copyright (c) 2023 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #pragma once #ifdef INTEROP_DEBUGGING #include #include #include #include #include "debugger/interop_ptrace_helpers.h" namespace netcoredbg { namespace InteropDebugging { class InteropBreakpoints; class InteropRendezvousBreakpoint { public: typedef std::function LoadLibCallback; typedef std::function UnloadLibCallback; typedef std::function IsThumbCodeCallback; InteropRendezvousBreakpoint(std::shared_ptr &sharedInteropBreakpoints) : m_sharedInteropBreakpoints(sharedInteropBreakpoints), m_rendezvousAddr(0), m_rendezvousBrkState(0), m_brkAddr(0) {} // In case of error - return `false`. bool SetupRendezvousBrk(pid_t pid, LoadLibCallback loadLibCB, UnloadLibCallback unloadLibCB, IsThumbCodeCallback isThumbCode, int &err_code); bool IsRendezvousBreakpoint(std::uintptr_t brkAddr); void ChangeRendezvousState(pid_t TGID, pid_t pid); void RemoveAtDetach(pid_t pid); private: std::shared_ptr m_sharedInteropBreakpoints; std::uintptr_t m_rendezvousAddr; int m_rendezvousBrkState; std::uintptr_t m_brkAddr; LoadLibCallback m_loadLibCB; UnloadLibCallback m_unloadLibCB; // Mapping for lib's name stored in rendezvous linked list and real lib's full path. std::unordered_map m_libsNameToRealNameMap; }; } // namespace InteropDebugging } // namespace netcoredbg #endif // INTEROP_DEBUGGING netcoredbg-3.1.0-1031/src/debugger/breakpoints.cpp000066400000000000000000000356471457701673000216420ustar00rootroot00000000000000// Copyright (c) 2017 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #include "debugger/breakpoint_break.h" #include "debugger/breakpoint_entry.h" #include "debugger/breakpoints_exception.h" #include "debugger/breakpoints_func.h" #include "debugger/breakpoints_line.h" #include "debugger/breakpoint_hotreload.h" #include "debugger/breakpoint_interop_rendezvous.h" #include "debugger/breakpoints_interop.h" #include "debugger/breakpoints_interop_line.h" #include "debugger/breakpoints.h" #include "debugger/breakpointutils.h" #include "debugger/interop_brk_helpers.h" #include #include #include #include #include #include #include "metadata/modules.h" #include "metadata/typeprinter.h" #include "utils/logger.h" #include "utils/utf.h" #include "managed/interop.h" #include "utils/filesystem.h" #include namespace netcoredbg { Breakpoints::Breakpoints(std::shared_ptr &sharedModules, std::shared_ptr &sharedEvaluator, std::shared_ptr &sharedEvalHelpers, std::shared_ptr &sharedVariables) : m_uniqueBreakBreakpoint(new BreakBreakpoint(sharedModules)), m_uniqueEntryBreakpoint(new EntryBreakpoint(sharedModules)), m_uniqueExceptionBreakpoints(new ExceptionBreakpoints(sharedEvaluator)), m_uniqueFuncBreakpoints(new FuncBreakpoints(sharedModules, sharedVariables)), m_uniqueLineBreakpoints(new LineBreakpoints(sharedModules, sharedVariables)), m_uniqueHotReloadBreakpoint(new HotReloadBreakpoint(sharedModules, sharedEvaluator, sharedEvalHelpers)), #ifdef INTEROP_DEBUGGING m_sharedInteropBreakpoints(new InteropDebugging::InteropBreakpoints()), m_uniqueInteropRendezvousBreakpoint(new InteropDebugging::InteropRendezvousBreakpoint(m_sharedInteropBreakpoints)), m_sharedInteropLineBreakpoints(new InteropDebugging::InteropLineBreakpoints(m_sharedInteropBreakpoints)), #endif // INTEROP_DEBUGGING m_nextBreakpointId(1) {} void Breakpoints::SetJustMyCode(bool enable) { m_uniqueFuncBreakpoints->SetJustMyCode(enable); m_uniqueLineBreakpoints->SetJustMyCode(enable); m_uniqueExceptionBreakpoints->SetJustMyCode(enable); } void Breakpoints::SetLastStoppedIlOffset(ICorDebugProcess *pProcess, const ThreadId &lastStoppedThreadId) { m_uniqueBreakBreakpoint->SetLastStoppedIlOffset(pProcess, lastStoppedThreadId); } void Breakpoints::SetStopAtEntry(bool enable) { m_uniqueEntryBreakpoint->SetStopAtEntry(enable); } HRESULT Breakpoints::ManagedCallbackBreak(ICorDebugThread *pThread, const ThreadId &lastStoppedThreadId) { return m_uniqueBreakBreakpoint->ManagedCallbackBreak(pThread, lastStoppedThreadId); } void Breakpoints::DeleteAllManaged() { m_uniqueEntryBreakpoint->Delete(); m_uniqueFuncBreakpoints->DeleteAll(); m_uniqueLineBreakpoints->DeleteAll(); m_uniqueExceptionBreakpoints->DeleteAll(); m_uniqueHotReloadBreakpoint->Delete(); } HRESULT Breakpoints::DisableAllManaged(ICorDebugProcess *pProcess) { HRESULT Status; ToRelease domains; IfFailRet(pProcess->EnumerateAppDomains(&domains)); ICorDebugAppDomain *curDomain; ULONG domainsFetched; while (SUCCEEDED(domains->Next(1, &curDomain, &domainsFetched)) && domainsFetched == 1) { ToRelease pDomain(curDomain); ToRelease breakpoints; if (FAILED(pDomain->EnumerateBreakpoints(&breakpoints))) continue; ICorDebugBreakpoint *curBreakpoint; ULONG breakpointsFetched; while (SUCCEEDED(breakpoints->Next(1, &curBreakpoint, &breakpointsFetched)) && breakpointsFetched == 1) { ToRelease pBreakpoint(curBreakpoint); pBreakpoint->Activate(FALSE); } } return S_OK; } HRESULT Breakpoints::SetFuncBreakpoints(bool haveProcess, const std::vector &funcBreakpoints, std::vector &breakpoints) { return m_uniqueFuncBreakpoints->SetFuncBreakpoints(haveProcess, funcBreakpoints, breakpoints, [&]() -> uint32_t { std::lock_guard lock(m_nextBreakpointIdMutex); return m_nextBreakpointId++; }); } HRESULT Breakpoints::UpdateLineBreakpoint(bool haveProcess, int id, int linenum, Breakpoint &breakpoint) { return m_uniqueLineBreakpoints->UpdateLineBreakpoint(haveProcess, id, linenum, breakpoint); } HRESULT Breakpoints::SetLineBreakpoints(bool haveProcess, const std::string& filename, const std::vector &lineBreakpoints, std::vector &breakpoints) { return m_uniqueLineBreakpoints->SetLineBreakpoints(haveProcess, filename, lineBreakpoints, breakpoints, [&]() -> uint32_t { std::lock_guard lock(m_nextBreakpointIdMutex); return m_nextBreakpointId++; }); } HRESULT Breakpoints::SetExceptionBreakpoints(const std::vector &exceptionBreakpoints, std::vector &breakpoints) { return m_uniqueExceptionBreakpoints->SetExceptionBreakpoints(exceptionBreakpoints, breakpoints, [&]() -> uint32_t { std::lock_guard lock(m_nextBreakpointIdMutex); return m_nextBreakpointId++; }); } HRESULT Breakpoints::UpdateBreakpointsOnHotReload(ICorDebugModule *pModule, std::unordered_set &methodTokens, std::vector &events) { m_uniqueFuncBreakpoints->UpdateBreakpointsOnHotReload(pModule, methodTokens, events); m_uniqueLineBreakpoints->UpdateBreakpointsOnHotReload(pModule, methodTokens, events); return S_OK; } HRESULT Breakpoints::GetExceptionInfo(ICorDebugThread *pThread, ExceptionInfo &exceptionInfo) { return m_uniqueExceptionBreakpoints->GetExceptionInfo(pThread, exceptionInfo); } HRESULT Breakpoints::ManagedCallbackBreakpoint(ICorDebugThread *pThread, ICorDebugBreakpoint *pBreakpoint, Breakpoint &breakpoint, std::vector &bpChangeEvents, bool &atEntry) { // CheckBreakpointHit return: // S_OK - breakpoint hit // S_FALSE - no breakpoint hit. // ManagedCallbackBreakpoint return: // S_OK - callback should be interrupted without event emit // S_FALSE - callback should not be interrupted and emit stop event HRESULT Status; atEntry = false; if (SUCCEEDED(Status = m_uniqueEntryBreakpoint->CheckBreakpointHit(pThread, pBreakpoint)) && Status == S_OK) // S_FALSE - no breakpoint hit { atEntry = true; return S_FALSE; // S_FALSE - not affect on callback (callback will emit stop event) } // Don't stop at breakpoint in not JMC code, if possible (error here is not fatal for debug process). // We need this check here, since we can't guarantee this check in SkipBreakpoint(). ToRelease iCorFrame; ToRelease iCorFunction; ToRelease iCorFunction2; BOOL JMCStatus; if (SUCCEEDED(pThread->GetActiveFrame(&iCorFrame)) && iCorFrame != nullptr && SUCCEEDED(iCorFrame->GetFunction(&iCorFunction)) && SUCCEEDED(iCorFunction->QueryInterface(IID_ICorDebugFunction2, (LPVOID*) &iCorFunction2)) && SUCCEEDED(iCorFunction2->GetJMCStatus(&JMCStatus)) && JMCStatus == FALSE) { return S_OK; // forced to interrupt this callback (breakpoint in not user code, continue process execution) } if (SUCCEEDED(Status = m_uniqueLineBreakpoints->CheckBreakpointHit(pThread, pBreakpoint, breakpoint, bpChangeEvents)) && Status == S_OK) // S_FALSE - no breakpoint hit { return S_FALSE; // S_FALSE - not affect on callback (callback will emit stop event) } if (SUCCEEDED(Status = m_uniqueFuncBreakpoints->CheckBreakpointHit(pThread, pBreakpoint, breakpoint, bpChangeEvents)) && Status == S_OK) // S_FALSE - no breakpoint hit { return S_FALSE; // S_FALSE - not affect on callback (callback will emit stop event) } return S_OK; // no breakpoints hit, forced to interrupt this callback } HRESULT Breakpoints::ManagedCallbackLoadModule(ICorDebugModule *pModule, std::vector &events) { m_uniqueEntryBreakpoint->ManagedCallbackLoadModule(pModule); m_uniqueFuncBreakpoints->ManagedCallbackLoadModule(pModule, events); m_uniqueLineBreakpoints->ManagedCallbackLoadModule(pModule, events); return S_OK; } HRESULT Breakpoints::ManagedCallbackLoadModuleAll(ICorDebugModule *pModule) { m_uniqueHotReloadBreakpoint->ManagedCallbackLoadModuleAll(pModule); return S_OK; } HRESULT Breakpoints::ManagedCallbackException(ICorDebugThread *pThread, ExceptionCallbackType eventType, const std::string &excModule, StoppedEvent &event) { return m_uniqueExceptionBreakpoints->ManagedCallbackException(pThread, eventType, excModule, event); } HRESULT Breakpoints::AllBreakpointsActivate(bool act) { HRESULT Status1 = m_uniqueLineBreakpoints->AllBreakpointsActivate(act); HRESULT Status2 = m_uniqueFuncBreakpoints->AllBreakpointsActivate(act); return FAILED(Status1) ? Status1 : Status2; } HRESULT Breakpoints::BreakpointActivate(uint32_t id, bool act) { if (SUCCEEDED(m_uniqueLineBreakpoints->BreakpointActivate(id, act))) return S_OK; return m_uniqueFuncBreakpoints->BreakpointActivate(id, act); } // This function allows to enumerate breakpoints (sorted by number). // Callback which is called for each breakpoint might return `false` to stop iteration over breakpoints list. void Breakpoints::EnumerateBreakpoints(std::function&& callback) { std::vector list; m_uniqueLineBreakpoints->AddAllBreakpointsInfo(list); m_uniqueFuncBreakpoints->AddAllBreakpointsInfo(list); m_uniqueExceptionBreakpoints->AddAllBreakpointsInfo(list); #ifdef INTEROP_DEBUGGING m_sharedInteropLineBreakpoints->AddAllBreakpointsInfo(list); #endif // INTEROP_DEBUGGING // sort breakpoint list by ascending order, preserve order of elements with same number std::stable_sort(list.begin(), list.end()); // remove duplicates (ones from m_lineBreakpointMapping which have resolved pair in m_lineResolvedBreakpoints) list.erase(std::unique(list.begin(), list.end()), list.end()); for (const auto &item : list) { if (!callback(item)) break; } } HRESULT Breakpoints::ManagedCallbackExitThread(ICorDebugThread *pThread) { return m_uniqueExceptionBreakpoints->ManagedCallbackExitThread(pThread); } HRESULT Breakpoints::CheckApplicationReload(ICorDebugThread *pThread, ICorDebugBreakpoint *pBreakpoint) { return m_uniqueHotReloadBreakpoint->CheckApplicationReload(pThread, pBreakpoint); } void Breakpoints::CheckApplicationReload(ICorDebugThread *pThread) { m_uniqueHotReloadBreakpoint->CheckApplicationReload(pThread); } HRESULT Breakpoints::SetHotReloadBreakpoint(const std::string &updatedDLL, const std::unordered_set &updatedTypeTokens) { return m_uniqueHotReloadBreakpoint->SetHotReloadBreakpoint(updatedDLL, updatedTypeTokens); } #ifdef INTEROP_DEBUGGING HRESULT Breakpoints::InteropSetLineBreakpoints(pid_t pid, InteropDebugging::InteropLibraries *pInteropLibraries, const std::string& filename, const std::vector &lineBreakpoints, std::vector &breakpoints, std::function StopAllThreads, std::function FixAllThreads) { // NOTE interop code provide 'true' on success, we must convert it into HRESULT return m_sharedInteropLineBreakpoints->SetLineBreakpoints(pid, pInteropLibraries, filename, lineBreakpoints, breakpoints, StopAllThreads, FixAllThreads, [&]() -> uint32_t { std::lock_guard lock(m_nextBreakpointIdMutex); return m_nextBreakpointId++; }) ? S_OK : E_FAIL; } bool Breakpoints::InteropSetupRendezvousBrk(pid_t pid, LoadLibCallback loadLibCB, UnloadLibCallback unloadLibCB, IsThumbCodeCallback isThumbCode, int &err_code) { return m_uniqueInteropRendezvousBreakpoint->SetupRendezvousBrk(pid, loadLibCB, unloadLibCB, isThumbCode, err_code); } bool Breakpoints::IsInteropBreakpoint(std::uintptr_t brkAddr) { // Make sure we ignore all "internal" breakpoints here. if (m_uniqueInteropRendezvousBreakpoint->IsRendezvousBreakpoint(brkAddr)) return false; return m_sharedInteropBreakpoints->IsBreakpoint(brkAddr); } bool Breakpoints::IsInteropRendezvousBreakpoint(std::uintptr_t brkAddr) { return m_uniqueInteropRendezvousBreakpoint->IsRendezvousBreakpoint(brkAddr); } void Breakpoints::InteropChangeRendezvousState(pid_t TGID, pid_t pid) { m_uniqueInteropRendezvousBreakpoint->ChangeRendezvousState(TGID, pid); } bool Breakpoints::IsInteropLineBreakpoint(std::uintptr_t brkAddr, Breakpoint &breakpoint) { return m_sharedInteropLineBreakpoints->IsLineBreakpoint(brkAddr, breakpoint); } bool Breakpoints::InteropStepPrevToBrk(pid_t pid, std::uintptr_t brkAddr) { return m_sharedInteropBreakpoints->StepPrevToBrk(pid, brkAddr); } void Breakpoints::InteropStepOverBrk(pid_t pid, std::uintptr_t brkAddr, std::function SingleStepOnBrk) { m_sharedInteropBreakpoints->StepOverBrk(pid, brkAddr, SingleStepOnBrk); } // Must be called only in case all threads stopped and fixed (see InteropDebugger::StopAndDetach()). void Breakpoints::InteropRemoveAllAtDetach(pid_t pid) { m_sharedInteropBreakpoints->RemoveAllAtDetach(pid); m_uniqueInteropRendezvousBreakpoint->RemoveAtDetach(pid); m_sharedInteropLineBreakpoints->RemoveAllAtDetach(pid); } void Breakpoints::InteropLoadModule(pid_t pid, std::uintptr_t startAddr, InteropDebugging::InteropLibraries *pInteropLibraries, std::vector &events) { m_sharedInteropLineBreakpoints->LoadModule(pid, startAddr, pInteropLibraries, events); } void Breakpoints::InteropUnloadModule(std::uintptr_t startAddr, std::uintptr_t endAddr, std::vector &events) { m_sharedInteropBreakpoints->UnloadModule(startAddr, endAddr); m_sharedInteropLineBreakpoints->UnloadModule(startAddr, endAddr, events); } HRESULT Breakpoints::InteropAllBreakpointsActivate(pid_t pid, bool act, std::function StopAllThreads, std::function FixAllThreads) { // NOTE interop code provide error as `errno` code, we must convert it into HRESULT return m_sharedInteropLineBreakpoints->AllBreakpointsActivate(pid, act, StopAllThreads, FixAllThreads) == 0 ? S_OK : E_FAIL; } HRESULT Breakpoints::InteropBreakpointActivate(pid_t pid, uint32_t id, bool act, std::function StopAllThreads, std::function FixAllThreads) { // NOTE interop code provide error as `errno` code, we must convert it into HRESULT return m_sharedInteropLineBreakpoints->BreakpointActivate(pid, id, act, StopAllThreads, FixAllThreads) == 0 ? S_OK : E_FAIL; } #endif // INTEROP_DEBUGGING } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/breakpoints.h000066400000000000000000000165651457701673000213050ustar00rootroot00000000000000// Copyright (c) 2020 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #pragma once #include "cor.h" #include "cordebug.h" #include #include #include #include #include "interfaces/idebugger.h" #include "debugger/interop_ptrace_helpers.h" namespace netcoredbg { class Evaluator; class EvalHelpers; class Variables; class Modules; class BreakBreakpoint; class EntryBreakpoint; class ExceptionBreakpoints; class FuncBreakpoints; class LineBreakpoints; class HotReloadBreakpoint; #ifdef INTEROP_DEBUGGING namespace InteropDebugging { class InteropRendezvousBreakpoint; class InteropBreakpoints; class InteropLineBreakpoints; class InteropLibraries; } // namespace InteropDebugging #endif // INTEROP_DEBUGGING class Breakpoints { public: Breakpoints(std::shared_ptr &sharedModules, std::shared_ptr &sharedEvaluator, std::shared_ptr &sharedEvalHelpers, std::shared_ptr &sharedVariables); void SetJustMyCode(bool enable); void SetLastStoppedIlOffset(ICorDebugProcess *pProcess, const ThreadId &lastStoppedThreadId); void SetStopAtEntry(bool enable); void DeleteAllManaged(); HRESULT DisableAllManaged(ICorDebugProcess *pProcess); HRESULT UpdateLineBreakpoint(bool haveProcess, int id, int linenum, Breakpoint &breakpoint); HRESULT SetFuncBreakpoints(bool haveProcess, const std::vector &funcBreakpoints, std::vector &breakpoints); HRESULT SetLineBreakpoints(bool haveProcess, const std::string &filename, const std::vector &lineBreakpoints, std::vector &breakpoints); HRESULT SetExceptionBreakpoints(const std::vector &exceptionBreakpoints, std::vector &breakpoints); HRESULT SetHotReloadBreakpoint(const std::string &updatedDLL, const std::unordered_set &updatedTypeTokens); HRESULT UpdateBreakpointsOnHotReload(ICorDebugModule *pModule, std::unordered_set &methodTokens, std::vector &events); HRESULT GetExceptionInfo(ICorDebugThread *pThread, ExceptionInfo &exceptionInfo); void EnumerateBreakpoints(std::function&& callback); HRESULT BreakpointActivate(uint32_t id, bool act); HRESULT AllBreakpointsActivate(bool act); // Important! Callbacks related methods must control return for succeeded return code. // Do not allow debugger API return succeeded (uncontrolled) return code. // Bad : // return pThread->GetID(&threadId); // Good: // IfFailRet(pThread->GetID(&threadId)); // return S_OK; HRESULT ManagedCallbackBreak(ICorDebugThread *pThread, const ThreadId &lastStoppedThreadId); HRESULT ManagedCallbackBreakpoint(ICorDebugThread *pThread, ICorDebugBreakpoint *pBreakpoint, Breakpoint &breakpoint, std::vector &bpChangeEvents, bool &atEntry); HRESULT ManagedCallbackException(ICorDebugThread *pThread, ExceptionCallbackType eventType, const std::string &excModule, StoppedEvent &event); HRESULT ManagedCallbackLoadModule(ICorDebugModule *pModule, std::vector &events); HRESULT ManagedCallbackLoadModuleAll(ICorDebugModule *pModule); HRESULT ManagedCallbackExitThread(ICorDebugThread *pThread); // S_OK - internal HotReload breakpoint hit // S_FALSE - not internal HotReload breakpoint hit HRESULT CheckApplicationReload(ICorDebugThread *pThread, ICorDebugBreakpoint *pBreakpoint); void CheckApplicationReload(ICorDebugThread *pThread); #ifdef INTEROP_DEBUGGING HRESULT InteropSetLineBreakpoints(pid_t pid, InteropDebugging::InteropLibraries *pInteropLibraries, const std::string& filename, const std::vector &lineBreakpoints, std::vector &breakpoints, std::function StopAllThreads, std::function FixAllThreads); HRESULT InteropAllBreakpointsActivate(pid_t pid, bool act, std::function StopAllThreads, std::function FixAllThreads); HRESULT InteropBreakpointActivate(pid_t pid, uint32_t id, bool act, std::function StopAllThreads, std::function FixAllThreads); // In case of error - return `false`. typedef std::function LoadLibCallback; typedef std::function UnloadLibCallback; typedef std::function IsThumbCodeCallback; bool InteropSetupRendezvousBrk(pid_t pid, LoadLibCallback loadLibCB, UnloadLibCallback unloadLibCB, IsThumbCodeCallback isThumbCode, int &err_code); // Return true, if execution stop at user's native breakpoint (fast check). bool IsInteropBreakpoint(std::uintptr_t brkAddr); bool IsInteropRendezvousBreakpoint(std::uintptr_t brkAddr); void InteropChangeRendezvousState(pid_t TGID, pid_t pid); bool IsInteropLineBreakpoint(std::uintptr_t brkAddr, Breakpoint &breakpoint); // In case we stop at breakpoint and need just move PC before breakpoint. // Note, this method will reset PC in case thread stop at breakpoint and alter `regs`. bool InteropStepPrevToBrk(pid_t pid, std::uintptr_t brkAddr); // Execute real breakpoint's code with single step. void InteropStepOverBrk(pid_t pid, std::uintptr_t brkAddr, std::function SingleStepOnBrk); // Remove all native breakpoints at interop detach. void InteropRemoveAllAtDetach(pid_t pid); // Resolve breakpoints for module. void InteropLoadModule(pid_t pid, std::uintptr_t startAddr, InteropDebugging::InteropLibraries *pInteropLibraries, std::vector &events); // Remove all related to unloaded library breakpoints entries in data structures. void InteropUnloadModule(std::uintptr_t startAddr, std::uintptr_t endAddr, std::vector &events); #endif // INTEROP_DEBUGGING private: std::unique_ptr m_uniqueBreakBreakpoint; std::unique_ptr m_uniqueEntryBreakpoint; std::unique_ptr m_uniqueExceptionBreakpoints; std::unique_ptr m_uniqueFuncBreakpoints; std::unique_ptr m_uniqueLineBreakpoints; std::unique_ptr m_uniqueHotReloadBreakpoint; #ifdef INTEROP_DEBUGGING // "Low level" native breakpoints layer (related to memory patch). std::shared_ptr m_sharedInteropBreakpoints; // "Up level" rendezvous breakpoint connected to libs load/unload routine. std::unique_ptr m_uniqueInteropRendezvousBreakpoint; // "Up level" line breakpoints implementation. // m_sharedInteropBreakpoints is "low level" layer for work with memory directly. m_sharedInteropLineBreakpoints is top of m_sharedInteropBreakpoints // implementation for line breakpoint logic (close to managed line breakpoints we already have). In case of managed line breakpoints, // "low level" layer is CoreCLR debug API itself. std::unique_ptr m_sharedInteropLineBreakpoints; #endif // INTEROP_DEBUGGING std::mutex m_nextBreakpointIdMutex; uint32_t m_nextBreakpointId; }; } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/breakpoints_exception.cpp000066400000000000000000000517301457701673000237070ustar00rootroot00000000000000// Copyright (c) 2021 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #include "debugger/breakpoints_exception.h" #include "debugger/evaluator.h" #include "debugger/valueprint.h" #include "metadata/typeprinter.h" #include namespace netcoredbg { void ExceptionBreakpoints::ManagedExceptionBreakpoint::ToBreakpoint(Breakpoint &breakpoint) const { breakpoint.id = this->id; breakpoint.verified = true; } void ExceptionBreakpoints::DeleteAll() { m_breakpointsMutex.lock(); for (auto &filterMap : m_exceptionBreakpoints) { filterMap.clear(); } m_breakpointsMutex.unlock(); } static std::string CalculateExceptionBreakpointHash(const ExceptionBreakpoint &expb) { std::ostringstream ss; ss << (int)expb.categoryHint; if (expb.negativeCondition) ss << "!"; for (auto &entry : expb.condition) { ss << ":" << entry << ":"; } return ss.str(); } HRESULT ExceptionBreakpoints::SetExceptionBreakpoints(const std::vector &exceptionBreakpoints, std::vector &breakpoints, std::function getId) { std::lock_guard lock(m_breakpointsMutex); // Remove old breakpoints std::vector> expBreakpoints((size_t)ExceptionBreakpointFilter::Size); for (const auto &expb : exceptionBreakpoints) { expBreakpoints[(size_t)expb.filterId].insert(CalculateExceptionBreakpointHash(expb)); } for (size_t filter = 0; filter < (size_t)ExceptionBreakpointFilter::Size; ++filter) { for (auto it = m_exceptionBreakpoints[filter].begin(); it != m_exceptionBreakpoints[filter].end();) { if (expBreakpoints[filter].find(it->first) == expBreakpoints[filter].end()) it = m_exceptionBreakpoints[filter].erase(it); else ++it; } } if (exceptionBreakpoints.empty()) return S_OK; // Export exception breakpoints for (const auto &expb : exceptionBreakpoints) { std::string expHash(CalculateExceptionBreakpointHash(expb)); Breakpoint breakpoint; auto b = m_exceptionBreakpoints[(size_t)expb.filterId].find(expHash); if (b == m_exceptionBreakpoints[(size_t)expb.filterId].end()) { // New breakpoint ManagedExceptionBreakpoint bp; bp.id = getId(); bp.categoryHint = expb.categoryHint; bp.condition = expb.condition; bp.negativeCondition = expb.negativeCondition; bp.ToBreakpoint(breakpoint); m_exceptionBreakpoints[(size_t)expb.filterId].insert(std::make_pair(expHash, std::move(bp))); } else { ManagedExceptionBreakpoint &bp = b->second; bp.ToBreakpoint(breakpoint); } breakpoints.push_back(breakpoint); } return S_OK; } // Return: // true - covered by filter, need emit exception event // false - not covered by filter, ignore exception bool ExceptionBreakpoints::CoveredByFilter(ExceptionBreakpointFilter filterId, const std::string &excType, ExceptionCategory excCategory) { assert(excCategory != ExceptionCategory::ANY); // caller must know category: CLR = Exception() callback, MDA = MDANotification() callback std::lock_guard lock(m_breakpointsMutex); for (auto &expb : m_exceptionBreakpoints[(size_t)filterId]) { if (expb.second.categoryHint != excCategory && expb.second.categoryHint != ExceptionCategory::ANY) continue; if (expb.second.condition.empty()) return true; bool isCoveredByCondition = expb.second.condition.find(excType) == expb.second.condition.end() ? expb.second.negativeCondition : !expb.second.negativeCondition; if (isCoveredByCondition) return true; } return false; } static void GetExceptionShorDescription(ExceptionBreakMode breakMode, const std::string &excType, const std::string &excModule, std::string &result) { switch(breakMode) { case ExceptionBreakMode::THROW: result = "Exception thrown: '" + excType + "' in " + excModule; break; case ExceptionBreakMode::USER_UNHANDLED: result = "An exception of type '" + excType + "' occurred in " + excModule + " but was not handled in user code"; break; case ExceptionBreakMode::UNHANDLED: result = "An unhandled exception of type '" + excType + "' occurred in " + excModule; break; default: result = ""; break; } } static void GetExceptionStageName(ExceptionBreakMode breakMode, std::string &result) { switch(breakMode) { case ExceptionBreakMode::THROW: result = "throw"; break; case ExceptionBreakMode::USER_UNHANDLED: result = "user-unhandled"; break; case ExceptionBreakMode::UNHANDLED: result = "unhandled"; break; default: result = ""; break; } } static void GetExceptionBreakModeName(ExceptionBreakMode breakMode, std::string &result) { switch(breakMode) { case ExceptionBreakMode::THROW: result = "always"; break; case ExceptionBreakMode::USER_UNHANDLED: result = "userUnhandled"; break; case ExceptionBreakMode::UNHANDLED: result = "unhandled"; break; default: result = ""; break; } } HRESULT ExceptionBreakpoints::GetExceptionDetails(ICorDebugThread *pThread, ICorDebugValue *pExceptionValue, ExceptionDetails &details) { std::string excType; if (FAILED(TypePrinter::GetTypeOfValue(pExceptionValue, details.fullTypeName))) { excType = ""; } auto lastDotPosition = details.fullTypeName.find_last_of("."); if (lastDotPosition < details.fullTypeName.size()) details.typeName = details.fullTypeName.substr(lastDotPosition + 1); else details.typeName = details.fullTypeName; details.evaluateName = "$exception"; HRESULT Status; ToRelease iCorInnerExceptionValue; const bool escape = false; m_sharedEvaluator->WalkMembers(pExceptionValue, pThread, FrameLevel{0}, false, [&]( ICorDebugType*, bool, const std::string &memberName, Evaluator::GetValueCallback getValue, Evaluator::SetterData*) { auto getMemberWithName = [&](const std::string &name, std::string &result) -> HRESULT { if (memberName != name) return S_FALSE; ToRelease iCorResultValue; IfFailRet(getValue(&iCorResultValue, defaultEvalFlags)); BOOL isNull = TRUE; ToRelease iCorReferenceValue; if (SUCCEEDED(iCorResultValue->QueryInterface(IID_ICorDebugReferenceValue, (LPVOID*) &iCorReferenceValue)) && SUCCEEDED(iCorReferenceValue->IsNull(&isNull)) && isNull == FALSE) { PrintValue(iCorResultValue, result, escape); } return S_OK; }; IfFailRet(Status = getMemberWithName("_message", details.message)); if (Status == S_OK) return S_OK; IfFailRet(Status = getMemberWithName("StackTrace", details.stackTrace)); if (Status == S_OK) return S_OK; IfFailRet(Status = getMemberWithName("Source", details.source)); if (Status == S_OK) return S_OK; if (memberName == "InnerException") { IfFailRet(getValue(&iCorInnerExceptionValue, defaultEvalFlags)); BOOL isNull = FALSE; ToRelease iCorReferenceValue; if (SUCCEEDED(iCorInnerExceptionValue->QueryInterface(IID_ICorDebugReferenceValue, (LPVOID*) &iCorReferenceValue)) && SUCCEEDED(iCorReferenceValue->IsNull(&isNull)) && isNull == TRUE) { iCorInnerExceptionValue.Free(); } } return S_OK; }); details.formattedDescription = "**" + details.fullTypeName + "**"; if (!details.message.empty()) details.formattedDescription += " '" + details.message + "'"; if (iCorInnerExceptionValue != nullptr) { details.innerException.reset(new ExceptionDetails); GetExceptionDetails(pThread, iCorInnerExceptionValue, *details.innerException.get()); } return S_OK; } HRESULT ExceptionBreakpoints::GetExceptionInfo(ICorDebugThread *pThread, ExceptionInfo &exceptionInfo) { HRESULT Status; ToRelease iCorExceptionValue; IfFailRet(pThread->GetCurrentException(&iCorExceptionValue)); if (iCorExceptionValue == nullptr) return E_FAIL; DWORD tid = 0; IfFailRet(pThread->GetID(&tid)); std::lock_guard lock(m_threadsExceptionMutex); auto findBreakMode = m_threadsExceptionBreakMode.find(tid); if (findBreakMode == m_threadsExceptionBreakMode.end() || findBreakMode->second == ExceptionBreakMode::NEVER) return E_FAIL; IfFailRet(GetExceptionDetails(pThread, iCorExceptionValue, exceptionInfo.details)); std::string excModule; if (exceptionInfo.details.source.empty()) excModule = ""; else excModule = exceptionInfo.details.source + ".dll"; GetExceptionShorDescription(findBreakMode->second, exceptionInfo.details.fullTypeName, excModule, exceptionInfo.description); if (!exceptionInfo.details.message.empty()) exceptionInfo.description += ": '" + exceptionInfo.details.message + "'"; if (exceptionInfo.details.innerException != nullptr) { exceptionInfo.description += "\n Inner exceptions found, see $exception in variables window for more details.\n Innermost exception: " + exceptionInfo.details.innerException->fullTypeName; } GetExceptionBreakModeName(findBreakMode->second, exceptionInfo.breakMode); // CLR only for now, MDA not implemented // TODO need store info about category too (not only BreakMode) during Exception() (CLR) and MDANotification() (MDA) callbacks. exceptionInfo.exceptionId = "CLR/" + exceptionInfo.details.fullTypeName; return S_OK; } /* Implemented exception callback logic by dwEventType (CorDebugExceptionCallbackType): DEBUG_EXCEPTION_FIRST_CHANCE -> DEBUG_EXCEPTION_CATCH_HANDLER_FOUND enabled JMC: throw none (reset thread status) disabled JMC: throw none (reset thread status) * case with ICorDebugProcess8::EnableExceptionCallbacksOutsideOfMyCode(FALSE), not used in our debugger, but must be included DEBUG_EXCEPTION_USER_FIRST_CHANCE -> DEBUG_EXCEPTION_CATCH_HANDLER_FOUND enabled JMC: throw [outside JMC] user-unhandled (reset thread status) [inside JMC] none (reset thread status) disabled JMC: throw none (reset thread status) DEBUG_EXCEPTION_FIRST_CHANCE -> DEBUG_EXCEPTION_USER_FIRST_CHANCE -> DEBUG_EXCEPTION_CATCH_HANDLER_FOUND enabled JMC: throw none [outside JMC] user-unhandled (reset thread status) [inside JMC] none (reset thread status) disabled JMC: throw none none (reset thread status) * fatal exception from runtime itself DEBUG_EXCEPTION_UNHANDLED enabled JMC: unhandled (reset thread status) disabled JMC: unhandled (reset thread status) DEBUG_EXCEPTION_FIRST_CHANCE -> DEBUG_EXCEPTION_UNHANDLED enabled JMC: throw unhandled (reset thread status) disabled JMC: throw unhandled (reset thread status) * case with ICorDebugProcess8::EnableExceptionCallbacksOutsideOfMyCode(FALSE), not used in our debugger, but must be included DEBUG_EXCEPTION_USER_FIRST_CHANCE -> DEBUG_EXCEPTION_UNHANDLED enabled JMC: throw unhandled (reset thread status) disabled JMC: throw unhandled (reset thread status) DEBUG_EXCEPTION_FIRST_CHANCE -> DEBUG_EXCEPTION_USER_FIRST_CHANCE -> DEBUG_EXCEPTION_UNHANDLED enabled JMC: throw none unhandled (reset thread status) disabled JMC: throw none unhandled (reset thread status) Reset exception thread status not only for `catch` but for `unhandled` too, since we may have not fatal unhandled exceptions, for example, System.AppDomainUnloadedException (https://docs.microsoft.com/en-us/dotnet/api/system.appdomainunloadedexception). More related info: https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger.md#exception-settings https://docs.microsoft.com/en-us/visualstudio/debugger/managing-exceptions-with-the-debugger */ HRESULT ExceptionBreakpoints::ManagedCallbackException(ICorDebugThread *pThread, ExceptionCallbackType eventType, std::string excModule, StoppedEvent &event) { HRESULT Status; DWORD tid = 0; IfFailRet(pThread->GetID(&tid)); ToRelease iCorExceptionValue; IfFailRet(pThread->GetCurrentException(&iCorExceptionValue)); if (iCorExceptionValue == nullptr) return E_FAIL; std::string excType; if (FAILED(TypePrinter::GetTypeOfValue(iCorExceptionValue, excType))) { excType = ""; } std::lock_guard lock(m_threadsExceptionMutex); switch(eventType) { case ExceptionCallbackType::FIRST_CHANCE: { // Important, reset previous stage for this thread. m_threadsExceptionBreakMode[tid] = ExceptionBreakMode::NEVER; m_threadsExceptionStatus[tid].m_lastEvent = ExceptionCallbackType::FIRST_CHANCE; m_threadsExceptionStatus[tid].m_excModule = excModule; if (!CoveredByFilter(ExceptionBreakpointFilter::THROW, excType, ExceptionCategory::CLR) && !CoveredByFilter(ExceptionBreakpointFilter::THROW_USER_UNHANDLED, excType, ExceptionCategory::CLR)) return S_OK; m_threadsExceptionBreakMode[tid] = ExceptionBreakMode::THROW; break; } case ExceptionCallbackType::USER_FIRST_CHANCE: { // In case we already "THROW" at FIRST CHANCE, don't emit "THROW" event again. auto find = m_threadsExceptionStatus.find(tid); if (find != m_threadsExceptionStatus.end()) { m_threadsExceptionStatus[tid].m_lastEvent = ExceptionCallbackType::USER_FIRST_CHANCE; if (find->second.m_excModule.empty()) find->second.m_excModule = excModule; return S_OK; } m_threadsExceptionStatus[tid].m_lastEvent = ExceptionCallbackType::USER_FIRST_CHANCE; m_threadsExceptionStatus[tid].m_excModule = excModule; if (!CoveredByFilter(ExceptionBreakpointFilter::THROW, excType, ExceptionCategory::CLR) && !CoveredByFilter(ExceptionBreakpointFilter::THROW_USER_UNHANDLED, excType, ExceptionCategory::CLR)) return S_OK; m_threadsExceptionBreakMode[tid] = ExceptionBreakMode::THROW; break; } case ExceptionCallbackType::CATCH_HANDLER_FOUND: { assert(m_threadsExceptionStatus.find(tid) != m_threadsExceptionStatus.end()); if (!m_justMyCode || m_threadsExceptionStatus[tid].m_lastEvent == ExceptionCallbackType::FIRST_CHANCE) { m_threadsExceptionStatus.erase(tid); return S_OK; } if (!CoveredByFilter(ExceptionBreakpointFilter::USER_UNHANDLED, excType, ExceptionCategory::CLR) && !CoveredByFilter(ExceptionBreakpointFilter::THROW_USER_UNHANDLED, excType, ExceptionCategory::CLR)) { m_threadsExceptionStatus.erase(tid); return S_OK; } excModule = m_threadsExceptionStatus[tid].m_excModule; m_threadsExceptionStatus.erase(tid); m_threadsExceptionBreakMode[tid] = ExceptionBreakMode::USER_UNHANDLED; break; } case ExceptionCallbackType::USER_CATCH_HANDLER_FOUND: { assert(m_threadsExceptionStatus.find(tid) != m_threadsExceptionStatus.end()); assert(m_threadsExceptionStatus[tid].m_lastEvent == ExceptionCallbackType::USER_FIRST_CHANCE); m_threadsExceptionStatus.erase(tid); return S_OK; } case ExceptionCallbackType::UNHANDLED: { // By current logic, debugger must stop at all unhandled exception (that will crash application), no matter what user has configured. // TODO some exception like System.AppDomainUnloadedException or System.Threading.ThreadAbortException, could be ignored at unhandled, // since they don't crash application, in this case: // if (CoveredByFilter(ExceptionBreakpointFilter::UNHANDLED, excType, ExceptionCategory::CLR)) - forced to emit event auto find = m_threadsExceptionStatus.find(tid); if (find != m_threadsExceptionStatus.end()) { excModule = find->second.m_excModule; m_threadsExceptionStatus.erase(find); } m_threadsExceptionBreakMode[tid] = ExceptionBreakMode::UNHANDLED; break; } default: return E_INVALIDARG; } if (excModule.empty()) excModule = ""; // Custom message, provided by runtime (in case internal runtime exception) or directly by user as exception constructor argument on throw. // Note, this is optional field in exception object that could have nulled reference. std::string excMessage; const bool escape = false; m_sharedEvaluator->WalkMembers(iCorExceptionValue, pThread, FrameLevel{0}, false, [&]( ICorDebugType*, bool, const std::string &memberName, Evaluator::GetValueCallback getValue, Evaluator::SetterData*) { ToRelease pResultValue; if (memberName != "_message") return S_OK; IfFailRet(getValue(&pResultValue, defaultEvalFlags)); BOOL isNull = TRUE; ToRelease pReferenceValue; if (SUCCEEDED(pResultValue->QueryInterface(IID_ICorDebugReferenceValue, (LPVOID*) &pReferenceValue)) && SUCCEEDED(pReferenceValue->IsNull(&isNull)) && isNull == FALSE) { PrintValue(pResultValue, excMessage, escape); return E_ABORT; // Fast exit from cycle. } return S_OK; }); GetExceptionShorDescription(m_threadsExceptionBreakMode[tid], excType, excModule, event.text); GetExceptionStageName(m_threadsExceptionBreakMode[tid], event.exception_stage); event.exception_category = "clr"; // ManagedCallbackException() called for CLR exceptions only event.exception_name = excType; event.exception_message = excMessage; return S_FALSE; // S_FALSE - breakpoint hit, not affect on callback (callback will emit stop event) } HRESULT ExceptionBreakpoints::ManagedCallbackExitThread(ICorDebugThread *pThread) { HRESULT Status; DWORD tid = 0; IfFailRet(pThread->GetID(&tid)); m_threadsExceptionMutex.lock(); m_threadsExceptionBreakMode.erase(tid); m_threadsExceptionStatus.erase(tid); m_threadsExceptionMutex.unlock(); return S_OK; } void ExceptionBreakpoints::AddAllBreakpointsInfo(std::vector &list) { std::lock_guard lock(m_breakpointsMutex); static std::vectorFilters{ "throw", "user-unhandled", "throw+user-unhandled", "unhandled" }; std::string ss; list.reserve(list.size() + m_exceptionBreakpoints.size()); for (size_t filter = 0; filter < (size_t)ExceptionBreakpointFilter::Size; ++filter) { for (auto it = m_exceptionBreakpoints[filter].begin(); it != m_exceptionBreakpoints[filter].end();) { auto &bp = it->second; ss = Filters[filter]; for (auto &entry : bp.condition) { ss += " "; ss += entry; } list.emplace_back(IDebugger::BreakpointInfo{ bp.id, true, true, 0, "", "exception ", 0, 0, "", ss}); ++it; } } } } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/breakpoints_exception.h000066400000000000000000000067271457701673000233620ustar00rootroot00000000000000// Copyright (c) 2021 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #pragma once #include "cor.h" #include "cordebug.h" #include "interfaces/types.h" #include "interfaces/idebugger.h" #include #include #include #include #include namespace netcoredbg { class Evaluator; class IDebugger; class ExceptionBreakpoints { public: ExceptionBreakpoints(std::shared_ptr &sharedEvaluator) : m_sharedEvaluator(sharedEvaluator), m_justMyCode(true), m_exceptionBreakpoints((size_t)ExceptionBreakpointFilter::Size) {} void SetJustMyCode(bool enable) { m_justMyCode = enable; }; void DeleteAll(); HRESULT SetExceptionBreakpoints(const std::vector &exceptionBreakpoints, std::vector &breakpoints, std::function getId); HRESULT GetExceptionInfo(ICorDebugThread *pThread, ExceptionInfo &exceptionInfo); bool CoveredByFilter(ExceptionBreakpointFilter filterId, const std::string &excType, ExceptionCategory excCategory); // Important! Callbacks related methods must control return for succeeded return code. // Do not allow debugger API return succeeded (uncontrolled) return code. // Bad : // return pThread->GetID(&threadId); // Good: // IfFailRet(pThread->GetID(&threadId)); // return S_OK; HRESULT ManagedCallbackException(ICorDebugThread *pThread, ExceptionCallbackType eventType, std::string excModule, StoppedEvent &event); HRESULT ManagedCallbackExitThread(ICorDebugThread *pThread); void AddAllBreakpointsInfo(std::vector &list); private: std::shared_ptr m_sharedEvaluator; bool m_justMyCode; struct ExceptionStatus { ExceptionCallbackType m_lastEvent; std::string m_excModule; ExceptionStatus() : m_lastEvent(ExceptionCallbackType::FIRST_CHANCE) {} }; std::mutex m_threadsExceptionMutex; std::unordered_map m_threadsExceptionStatus; // Note, we have Exception callback called with different exception callback type, and we need know exception type that related to current stop event. std::unordered_map m_threadsExceptionBreakMode; HRESULT GetExceptionDetails(ICorDebugThread *pThread, ICorDebugValue *pExceptionValue, ExceptionDetails &details); struct ManagedExceptionBreakpoint { uint32_t id; ExceptionCategory categoryHint; std::unordered_set condition; // Note, only exception type related conditions allowed for now. bool negativeCondition; ManagedExceptionBreakpoint() : id(0), categoryHint(ExceptionCategory::ANY), negativeCondition(false) {} void ToBreakpoint(Breakpoint &breakpoint) const; ManagedExceptionBreakpoint(ManagedExceptionBreakpoint &&that) = default; ManagedExceptionBreakpoint(const ManagedExceptionBreakpoint &that) = delete; ManagedExceptionBreakpoint& operator=(ManagedExceptionBreakpoint &&that) = default; ManagedExceptionBreakpoint& operator=(const ManagedExceptionBreakpoint &that) = delete; }; std::mutex m_breakpointsMutex; std::vector> m_exceptionBreakpoints; }; } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/breakpoints_func.cpp000066400000000000000000000315501457701673000226420ustar00rootroot00000000000000// Copyright (c) 2021 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #include "debugger/breakpoints_func.h" #include "debugger/breakpointutils.h" #include "metadata/typeprinter.h" #include "metadata/modules.h" #include #include #include namespace netcoredbg { void FuncBreakpoints::ManagedFuncBreakpoint::ToBreakpoint(Breakpoint &breakpoint) const { breakpoint.id = this->id; breakpoint.verified = this->IsVerified(); breakpoint.condition = this->condition; breakpoint.module = this->module; breakpoint.funcname = this->name; breakpoint.params = this->params; } void FuncBreakpoints::DeleteAll() { m_breakpointsMutex.lock(); m_funcBreakpoints.clear(); m_breakpointsMutex.unlock(); } HRESULT FuncBreakpoints::CheckBreakpointHit(ICorDebugThread *pThread, ICorDebugBreakpoint *pBreakpoint, Breakpoint &breakpoint, std::vector &bpChangeEvents) { if (m_funcBreakpoints.empty()) return S_FALSE; // Stopped at break, but no breakpoints. HRESULT Status; ToRelease pFunctionBreakpoint; IfFailRet(pBreakpoint->QueryInterface(IID_ICorDebugFunctionBreakpoint, (LPVOID *) &pFunctionBreakpoint)); ToRelease pFrame; IfFailRet(pThread->GetActiveFrame(&pFrame)); if (pFrame == nullptr) return E_FAIL; ToRelease pILFrame; IfFailRet(pFrame->QueryInterface(IID_ICorDebugILFrame, (LPVOID *) &pILFrame)); ToRelease pParamEnum; IfFailRet(pILFrame->EnumerateArguments(&pParamEnum)); ULONG cParams = 0; IfFailRet(pParamEnum->GetCount(&cParams)); std::ostringstream ss; ss << "("; if (cParams > 0) { for (ULONG i = 0; i < cParams; ++i) { ToRelease pValue; ULONG cArgsFetched; if (FAILED(pParamEnum->Next(1, &pValue, &cArgsFetched))) continue; std::string param; IfFailRet(TypePrinter::GetTypeOfValue(pValue, param)); if (i > 0) ss << ","; ss << param; } } ss << ")"; std::string params = ss.str(); // Note, since IsEnableByCondition() during eval execution could neutered frame, all frame-related calculation // must be done before enter into this cycles. for (auto &fb : m_funcBreakpoints) { ManagedFuncBreakpoint &fbp = fb.second; if (!fbp.enabled || (!fbp.params.empty() && params != fbp.params)) continue; for (auto &funcBreakpoint : fbp.funcBreakpoints) { IfFailRet(BreakpointUtils::IsSameFunctionBreakpoint(pFunctionBreakpoint, funcBreakpoint.iCorFuncBreakpoint)); if (Status == S_FALSE) continue; std::string output; if (FAILED(Status = BreakpointUtils::IsEnableByCondition(fbp.condition, m_sharedVariables.get(), pThread, output))) { if (output.empty()) return Status; } if (Status == S_FALSE) continue; ++fbp.times; fbp.ToBreakpoint(breakpoint); if (!output.empty()) { breakpoint.message = "The condition for a breakpoint failed to execute. The condition was '" + fbp.condition + "'. The error returned was '" + output + "'."; bpChangeEvents.emplace_back(BreakpointChanged, breakpoint); } return S_OK; } } return S_FALSE; // Stopped at break, but breakpoint not found. } HRESULT FuncBreakpoints::ManagedCallbackLoadModule(ICorDebugModule *pModule, std::vector &events) { std::lock_guard lock(m_breakpointsMutex); for (auto &funcBreakpoints : m_funcBreakpoints) { ManagedFuncBreakpoint &fb = funcBreakpoints.second; if (fb.IsResolved() || FAILED(ResolveFuncBreakpointInModule(pModule, fb))) continue; Breakpoint breakpoint; fb.ToBreakpoint(breakpoint); events.emplace_back(BreakpointChanged, breakpoint); } return S_OK; } HRESULT FuncBreakpoints::SetFuncBreakpoints(bool haveProcess, const std::vector &funcBreakpoints, std::vector &breakpoints, std::function getId) { std::lock_guard lock(m_breakpointsMutex); // Remove old breakpoints std::unordered_set funcBreakpointFuncs; for (const auto &fb : funcBreakpoints) { std::string fullFuncName(""); if (!fb.module.empty()) { fullFuncName = fb.module + "!"; } fullFuncName += fb.func + fb.params; funcBreakpointFuncs.insert(fullFuncName); } for (auto it = m_funcBreakpoints.begin(); it != m_funcBreakpoints.end();) { if (funcBreakpointFuncs.find(it->first) == funcBreakpointFuncs.end()) it = m_funcBreakpoints.erase(it); else ++it; } if (funcBreakpoints.empty()) return S_OK; // Export function breakpoints // Note, VSCode and MI/GDB protocols requires, that "breakpoints" and "funcBreakpoints" must have same indexes for same breakpoints. for (const auto &fb : funcBreakpoints) { std::string fullFuncName(""); if (!fb.module.empty()) fullFuncName = fb.module + "!"; fullFuncName += fb.func + fb.params; Breakpoint breakpoint; auto b = m_funcBreakpoints.find(fullFuncName); if (b == m_funcBreakpoints.end()) { // New function breakpoint ManagedFuncBreakpoint fbp; fbp.id = getId(); fbp.module = fb.module; fbp.name = fb.func; fbp.params = fb.params; fbp.condition = fb.condition; if (haveProcess) ResolveFuncBreakpoint(fbp); fbp.ToBreakpoint(breakpoint); m_funcBreakpoints.insert(std::make_pair(fullFuncName, std::move(fbp))); } else { ManagedFuncBreakpoint &fbp = b->second; fbp.condition = fb.condition; fbp.ToBreakpoint(breakpoint); } breakpoints.push_back(breakpoint); } return S_OK; } HRESULT FuncBreakpoints::UpdateBreakpointsOnHotReload(ICorDebugModule *pModule, std::unordered_set &methodTokens, std::vector &events) { std::lock_guard lock(m_breakpointsMutex); HRESULT Status; for (auto &funcBreakpoints : m_funcBreakpoints) { ManagedFuncBreakpoint &fbp = funcBreakpoints.second; bool initiallyResolved = !fbp.funcBreakpoints.empty(); ResolvedFBP fbpResolved; IfFailRet(m_sharedModules->ResolveFuncBreakpointInModule( pModule, fbp.module, fbp.module_checked, fbp.name, [&](ICorDebugModule *pModule, mdMethodDef &methodToken) -> HRESULT { // Note, in case Hot Reload we ignore "resolved" status + setup breakpoints for new/changed methods only. if (methodTokens.find(methodToken) != methodTokens.end()) fbpResolved.emplace_back(std::make_pair(pModule, methodToken)); return S_OK; })); if (fbpResolved.empty() || FAILED(AddFuncBreakpoint(fbp, fbpResolved))) continue; // Remove breakpoints from old versions. for (auto &entry : fbpResolved) { auto is_method = [&entry](ManagedFuncBreakpoint::internalFuncBreakpoint &ifb){return ifb.methodToken == entry.second;}; auto findIter = std::find_if(fbp.funcBreakpoints.rbegin(), fbp.funcBreakpoints.rend(), is_method); mdMethodDef methodToken = findIter->methodToken; ULONG32 methodVersion = findIter->methodVersion; auto end_range = std::prev(fbp.funcBreakpoints.end(), fbpResolved.size()); // Skip added into list new/changed methods breakpoints. for (auto it = fbp.funcBreakpoints.begin(); it != end_range;) { if (it->methodToken == methodToken && it->methodVersion != methodVersion) it = fbp.funcBreakpoints.erase(it); else ++it; } } if (!initiallyResolved) { Breakpoint breakpoint; fbp.ToBreakpoint(breakpoint); events.emplace_back(BreakpointChanged, breakpoint); } } return S_OK; } HRESULT FuncBreakpoints::AddFuncBreakpoint(ManagedFuncBreakpoint &fbp, ResolvedFBP &fbpResolved) { HRESULT Status; for (auto &entry : fbpResolved) { IfFailRet(BreakpointUtils::SkipBreakpoint(entry.first, entry.second, m_justMyCode)); if (Status == S_OK) // S_FALSE - don't skip breakpoint return S_OK; ToRelease pFunc; IfFailRet(entry.first->GetFunctionFromToken(entry.second, &pFunc)); ULONG32 currentVersion; // Note, new breakpoints could be setup for last code version only, since protocols (MI, VSCode, ...) provide method name (sig) only. IfFailRet(pFunc->GetCurrentVersionNumber(¤tVersion)); ULONG32 ilNextOffset = 0; if (FAILED(m_sharedModules->GetNextUserCodeILOffsetInMethod(entry.first, entry.second, currentVersion, 0, ilNextOffset))) return S_OK; ToRelease pCode; IfFailRet(pFunc->GetILCode(&pCode)); ToRelease iCorFuncBreakpoint; IfFailRet(pCode->CreateBreakpoint(ilNextOffset, &iCorFuncBreakpoint)); IfFailRet(iCorFuncBreakpoint->Activate(fbp.enabled ? TRUE : FALSE)); fbp.funcBreakpoints.emplace_back(entry.second, currentVersion, iCorFuncBreakpoint.Detach()); } return S_OK; } HRESULT FuncBreakpoints::ResolveFuncBreakpoint(ManagedFuncBreakpoint &fbp) { HRESULT Status; ResolvedFBP fbpResolved; IfFailRet(m_sharedModules->ResolveFuncBreakpointInAny( fbp.module, fbp.module_checked, fbp.name, [&](ICorDebugModule *pModule, mdMethodDef &methodToken) -> HRESULT { fbpResolved.emplace_back(std::make_pair(pModule, methodToken)); return S_OK; })); return AddFuncBreakpoint(fbp, fbpResolved); } HRESULT FuncBreakpoints::ResolveFuncBreakpointInModule(ICorDebugModule *pModule, ManagedFuncBreakpoint &fbp) { HRESULT Status; ResolvedFBP fbpResolved; IfFailRet(m_sharedModules->ResolveFuncBreakpointInModule( pModule, fbp.module, fbp.module_checked, fbp.name, [&](ICorDebugModule *pModule, mdMethodDef &methodToken) -> HRESULT { fbpResolved.emplace_back(std::make_pair(pModule, methodToken)); return S_OK; })); return AddFuncBreakpoint(fbp, fbpResolved); } HRESULT FuncBreakpoints::AllBreakpointsActivate(bool act) { std::lock_guard lock(m_breakpointsMutex); HRESULT Status = S_OK; for (auto &fbp : m_funcBreakpoints) { for (auto &funcBreakpoint : fbp.second.funcBreakpoints) { if (!funcBreakpoint.iCorFuncBreakpoint) continue; HRESULT ret = funcBreakpoint.iCorFuncBreakpoint->Activate(act ? TRUE : FALSE); Status = FAILED(ret) ? ret : Status; } fbp.second.enabled = act; } return Status; } HRESULT FuncBreakpoints::BreakpointActivate(uint32_t id, bool act) { std::lock_guard lock(m_breakpointsMutex); for (auto &fbp : m_funcBreakpoints) { if (fbp.second.id != id) continue; HRESULT Status = S_OK; for (auto &funcBreakpoint : fbp.second.funcBreakpoints) { if (!funcBreakpoint.iCorFuncBreakpoint) continue; HRESULT ret = funcBreakpoint.iCorFuncBreakpoint->Activate(act ? TRUE : FALSE); Status = FAILED(ret) ? ret : Status; } fbp.second.enabled = act; return Status; } return E_FAIL; } void FuncBreakpoints::AddAllBreakpointsInfo(std::vector &list) { std::lock_guard lock(m_breakpointsMutex); list.reserve(list.size() + m_funcBreakpoints.size()); for (auto &pair_bp : m_funcBreakpoints) { auto &bp = pair_bp.second; list.emplace_back(IDebugger::BreakpointInfo{ bp.id, bp.IsVerified(), bp.enabled, bp.times, bp.condition, bp.name, 0, 0, bp.module, bp.params }); } } } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/breakpoints_func.h000066400000000000000000000114561457701673000223120ustar00rootroot00000000000000// Copyright (c) 2021 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #pragma once #include "cor.h" #include "cordebug.h" #include #include #include #include #include #include #include #include "interfaces/idebugger.h" #include "utils/torelease.h" namespace netcoredbg { class Variables; class Modules; class FuncBreakpoints { public: FuncBreakpoints(std::shared_ptr &sharedModules, std::shared_ptr &sharedVariables) : m_sharedModules(sharedModules), m_sharedVariables(sharedVariables), m_justMyCode(true) {} void SetJustMyCode(bool enable) { m_justMyCode = enable; }; void DeleteAll(); HRESULT SetFuncBreakpoints(bool haveProcess, const std::vector &funcBreakpoints, std::vector &breakpoints, std::function getId); HRESULT UpdateBreakpointsOnHotReload(ICorDebugModule *pModule, std::unordered_set &methodTokens, std::vector &events); HRESULT AllBreakpointsActivate(bool act); HRESULT BreakpointActivate(uint32_t id, bool act); void AddAllBreakpointsInfo(std::vector &list); // Important! Must provide succeeded return code: // S_OK - breakpoint hit // S_FALSE - no breakpoint hit HRESULT CheckBreakpointHit(ICorDebugThread *pThread, ICorDebugBreakpoint *pBreakpoint, Breakpoint &breakpoint, std::vector &bpChangeEvents); // Important! Callbacks related methods must control return for succeeded return code. // Do not allow debugger API return succeeded (uncontrolled) return code. // Bad : // return pThread->GetID(&threadId); // Good: // IfFailRet(pThread->GetID(&threadId)); // return S_OK; HRESULT ManagedCallbackLoadModule(ICorDebugModule *pModule, std::vector &events); private: std::shared_ptr m_sharedModules; std::shared_ptr m_sharedVariables; bool m_justMyCode; struct ManagedFuncBreakpoint { struct internalFuncBreakpoint { mdMethodDef methodToken; ULONG32 methodVersion; ToRelease iCorFuncBreakpoint; internalFuncBreakpoint(mdMethodDef methodToken_, ULONG32 methodVersion_, ICorDebugFunctionBreakpoint *pCorDebugFunctionBreakpoint) : methodToken(methodToken_), methodVersion(methodVersion_), iCorFuncBreakpoint(pCorDebugFunctionBreakpoint) {} internalFuncBreakpoint(internalFuncBreakpoint &&that) = default; internalFuncBreakpoint(const internalFuncBreakpoint &that) = delete; internalFuncBreakpoint& operator=(internalFuncBreakpoint &&that) = default; internalFuncBreakpoint& operator=(const internalFuncBreakpoint &that) = delete; }; uint32_t id; std::string module; bool module_checked; // in case "module" provided, we need mark that module was checked or not (since function could be not found by name) std::string name; std::string params; ULONG32 times; bool enabled; std::string condition; std::list funcBreakpoints; bool IsResolved() const { return module_checked; } bool IsVerified() const { return !funcBreakpoints.empty(); } ManagedFuncBreakpoint() : id(0), module_checked(false), times(0), enabled(true) {} ~ManagedFuncBreakpoint() { for (auto &funcBreakpoint : funcBreakpoints) { if (funcBreakpoint.iCorFuncBreakpoint) funcBreakpoint.iCorFuncBreakpoint->Activate(FALSE); } } void ToBreakpoint(Breakpoint &breakpoint) const; ManagedFuncBreakpoint(ManagedFuncBreakpoint &&that) = default; ManagedFuncBreakpoint(const ManagedFuncBreakpoint &that) = delete; ManagedFuncBreakpoint& operator=(ManagedFuncBreakpoint &&that) = default; ManagedFuncBreakpoint& operator=(const ManagedFuncBreakpoint &that) = delete; }; std::mutex m_breakpointsMutex; std::unordered_map m_funcBreakpoints; typedef std::vector > ResolvedFBP; HRESULT AddFuncBreakpoint(ManagedFuncBreakpoint &fbp, ResolvedFBP &fbpResolved); HRESULT ResolveFuncBreakpointInModule(ICorDebugModule *pModule, ManagedFuncBreakpoint &fbp); HRESULT ResolveFuncBreakpoint(ManagedFuncBreakpoint &fbp); }; } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/breakpoints_interop.cpp000066400000000000000000000143331457701673000233670ustar00rootroot00000000000000// Copyright (c) 2023 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #include "debugger/breakpoints_interop.h" #include "debugger/interop_brk_helpers.h" #include // iovec #include // NT_PRSTATUS #include #include #include #include "utils/logger.h" namespace netcoredbg { namespace InteropDebugging { int InteropBreakpoints::Add(pid_t pid, std::uintptr_t brkAddr, bool isThumbCode, std::function StopAllThreads) { m_breakpointsMutex.lock(); word_t savedData = 0; word_t dataWithBrk = 0; auto find = m_currentBreakpointsInMemory.find(brkAddr); if (find == m_currentBreakpointsInMemory.end()) { StopAllThreads(); errno = 0; // Since the value returned by a successful PTRACE_PEEK* request may be -1, the caller must clear errno before the call, // and then check it afterward to determine whether or not an error occurred. savedData = async_ptrace(PTRACE_PEEKDATA, pid, (void*)brkAddr, nullptr); if (errno != 0) { int err_code = errno; LOGE("Ptrace peekdata error: %s", strerror(err_code)); return err_code; } dataWithBrk = EncodeBrkOpcode(savedData, isThumbCode); if (async_ptrace(PTRACE_POKEDATA, pid, (void*)brkAddr, (void*)dataWithBrk) == -1) { int err_code = errno; LOGE("Ptrace pokedata error: %s", strerror(err_code)); return err_code; } m_currentBreakpointsInMemory[brkAddr].m_savedData = savedData; } m_currentBreakpointsInMemory[brkAddr].m_count++; m_breakpointsMutex.unlock(); return 0; } int InteropBreakpoints::Remove(pid_t pid, std::uintptr_t brkAddr, std::function StopAllThreads, std::function FixAllThreads) { std::lock_guard lock(m_breakpointsMutex); auto find = m_currentBreakpointsInMemory.find(brkAddr); if (find == m_currentBreakpointsInMemory.end()) return ENOENT; assert(find->second.m_count > 0); find->second.m_count--; if (find->second.m_count == 0) { StopAllThreads(); FixAllThreads(find->first); errno = 0; word_t brkData = async_ptrace(PTRACE_PEEKDATA, pid, (void*)find->first, nullptr); if (errno != 0) { int err_code = errno; LOGE("Ptrace peekdata error: %s", strerror(err_code)); return err_code; } word_t restoredData = RestoredOpcode(brkData, find->second.m_savedData); if (async_ptrace(PTRACE_POKEDATA, pid, (void*)find->first, (void*)restoredData) == -1) { int err_code = errno; LOGW("Ptrace pokedata error: %s\n", strerror(err_code)); return err_code; } m_currentBreakpointsInMemory.erase(find); } return 0; } // Must be called only in case all threads stopped and fixed (see InteropDebugger::StopAndDetach()). void InteropBreakpoints::RemoveAllAtDetach(pid_t pid) { m_breakpointsMutex.lock(); if (pid != 0) // In case we already don't have process, no need real remove from memory. { for (auto entry : m_currentBreakpointsInMemory) { errno = 0; word_t brkData = async_ptrace(PTRACE_PEEKDATA, pid, (void*)entry.first, nullptr); if (errno != 0) { LOGE("Ptrace peekdata error: %s", strerror(errno)); continue; } word_t restoredData = RestoredOpcode(brkData, entry.second.m_savedData); if (async_ptrace(PTRACE_POKEDATA, pid, (void*)entry.first, (void*)restoredData) == -1) { LOGE("Ptrace pokedata error: %s\n", strerror(errno)); } } } m_currentBreakpointsInMemory.clear(); m_breakpointsMutex.unlock(); } bool InteropBreakpoints::IsBreakpoint(std::uintptr_t brkAddr) { std::lock_guard lock(m_breakpointsMutex); return m_currentBreakpointsInMemory.find(brkAddr) != m_currentBreakpointsInMemory.end(); } void InteropBreakpoints::StepOverBrk(pid_t pid, std::uintptr_t brkAddr, std::function SingleStepOnBrk) { std::lock_guard lock(m_breakpointsMutex); auto find = m_currentBreakpointsInMemory.find(brkAddr); if (find == m_currentBreakpointsInMemory.end()) return; if (!InteropDebugging::StepOverBrk(pid, brkAddr, find->second.m_savedData, SingleStepOnBrk)) std::abort(); // Fatal error, we already logged all data about this error. } bool InteropBreakpoints::StepPrevToBrk(pid_t pid, std::uintptr_t brkAddr) { std::lock_guard lock(m_breakpointsMutex); auto find = m_currentBreakpointsInMemory.find(brkAddr); if (find == m_currentBreakpointsInMemory.end()) return false; if (!NeedSetPrevBrkPC()) return true; user_regs_struct regs; iovec iov; iov.iov_base = ®s; iov.iov_len = sizeof(user_regs_struct); if (async_ptrace(PTRACE_GETREGSET, pid, (void*)NT_PRSTATUS, &iov) == -1) { LOGE("Ptrace getregset error: %s\n", strerror(errno)); std::abort(); // Fatal error, we already logged all data about this error. } SetPrevBrkPC(regs); if (async_ptrace(PTRACE_SETREGSET, pid, (void*)NT_PRSTATUS, &iov) == -1) { LOGE("Ptrace setregset error: %s\n", strerror(errno)); std::abort(); // Fatal error, we already logged all data about this error. } return true; } void InteropBreakpoints::UnloadModule(std::uintptr_t startAddr, std::uintptr_t endAddr) { m_breakpointsMutex.lock(); for (auto it = m_currentBreakpointsInMemory.begin(); it != m_currentBreakpointsInMemory.end();) { if (it->first >= startAddr && it->first < endAddr) it = m_currentBreakpointsInMemory.erase(it); else ++it; } m_breakpointsMutex.unlock(); } } // namespace InteropDebugging } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/breakpoints_interop.h000066400000000000000000000033651457701673000230370ustar00rootroot00000000000000// Copyright (c) 2023 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #pragma once #ifdef INTEROP_DEBUGGING #include "debugger/interop_ptrace_helpers.h" #include #include #include #include namespace netcoredbg { namespace InteropDebugging { class InteropBreakpoints { public: // In case of error, return `errno`. int Add(pid_t pid, std::uintptr_t brkAddr, bool isThumbCode, std::function StopAllThreads); // In case of error, return `errno`. int Remove(pid_t pid, std::uintptr_t brkAddr, std::function StopAllThreads, std::function FixAllThreads); // Remove all native breakpoints at interop detach. void RemoveAllAtDetach(pid_t pid); bool IsBreakpoint(std::uintptr_t brkAddr); void StepOverBrk(pid_t pid, std::uintptr_t brkAddr, std::function SingleStepOnBrk); // Return `false` in case no breakpoint with this PC was found (step is not possible). bool StepPrevToBrk(pid_t pid, std::uintptr_t brkAddr); // Remove all related to unloaded library breakpoints entries in data structures. void UnloadModule(std::uintptr_t startAddr, std::uintptr_t endAddr); private: struct MemBrk { int m_count = 0; word_t m_savedData = 0; }; // NOTE we could recursively call `InteropBreakpoints` methods in StopAllThreads/FixAllThreads callbacks. std::recursive_mutex m_breakpointsMutex; std::unordered_map m_currentBreakpointsInMemory; }; } // namespace InteropDebugging } // namespace netcoredbg #endif // INTEROP_DEBUGGING netcoredbg-3.1.0-1031/src/debugger/breakpoints_interop_line.cpp000066400000000000000000000421631457701673000244000ustar00rootroot00000000000000// Copyright (c) 2023 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #include "debugger/breakpoints_interop_line.h" #include "debugger/breakpoints_interop.h" #include "metadata/interop_libraries.h" #include "utils/logger.h" #include namespace netcoredbg { namespace InteropDebugging { void InteropLineBreakpoints::InteropLineBreakpoint::ToBreakpoint(Breakpoint &breakpoint, bool verified) const { breakpoint.id = this->m_id; breakpoint.verified = verified; // TODO `breakpoint.condition = m_condition` support breakpoint.source = Source(m_sourceFullPath); breakpoint.line = this->m_linenum; breakpoint.endLine = this->m_endLine; breakpoint.hitCount = this->m_times; } // Must be called only in case all threads stopped and fixed (see InteropDebugger::StopAndDetach()). void InteropLineBreakpoints::RemoveAllAtDetach(pid_t pid) { m_breakpointsMutex.lock(); if (pid != 0) { for (const auto &entry : m_lineResolvedBreakpoints) { for (const auto &bp : entry.second) { if (bp.m_enabled) m_sharedInteropBreakpoints->Remove(pid, entry.first, [](){}, [](std::uintptr_t){}); } } } m_lineResolvedBreakpoints.clear(); m_lineBreakpointMapping.clear(); m_breakpointsMutex.unlock(); } int InteropLineBreakpoints::AllBreakpointsActivate(pid_t pid, bool act, std::function StopAllThreads, std::function FixAllThreads) { std::lock_guard lock(m_breakpointsMutex); int err_code = 0; std::unordered_set failedIDs; assert((pid == 0 && m_lineResolvedBreakpoints.empty()) || (pid != 0 && !m_lineResolvedBreakpoints.empty())); // resolved breakpoints for (auto &addr_bps : m_lineResolvedBreakpoints) { for (auto &bp : addr_bps.second) { int tmp = 0; if (bp.m_enabled && !act) tmp = m_sharedInteropBreakpoints->Remove(pid, addr_bps.first, StopAllThreads, FixAllThreads); else if (!bp.m_enabled && act) tmp = m_sharedInteropBreakpoints->Add(pid, addr_bps.first, bp.m_isThumbCode, StopAllThreads); if (tmp == 0) bp.m_enabled = act; else { err_code = tmp; failedIDs.emplace(bp.m_id); } } } // mapping (for both - resolved and unresolved breakpoints) for (auto &file_bps : m_lineBreakpointMapping) { for (auto &bp: file_bps.second) { // Note, in case m_enabled field in resolved breakpoint was not changed by error, don't change it here too. if (failedIDs.find(bp.m_id) != failedIDs.end()) continue; bp.m_enabled = act; } } return err_code; } int InteropLineBreakpoints::BreakpointActivate(pid_t pid, uint32_t id, bool act, std::function StopAllThreads, std::function FixAllThreads) { std::lock_guard lock(m_breakpointsMutex); assert((pid == 0 && m_lineResolvedBreakpoints.empty()) || (pid != 0 && !m_lineResolvedBreakpoints.empty())); auto activateResolved = [&](std::uintptr_t resolved_brkAddr) -> int { auto bList_it = m_lineResolvedBreakpoints.find(resolved_brkAddr); if (bList_it == m_lineResolvedBreakpoints.end()) return ENOENT; for (auto &bp : bList_it->second) { if (bp.m_id != id) continue; int err_code = 0; if (bp.m_enabled && !act) err_code = m_sharedInteropBreakpoints->Remove(pid, resolved_brkAddr, StopAllThreads, FixAllThreads); else if (!bp.m_enabled && act) err_code = m_sharedInteropBreakpoints->Add(pid, resolved_brkAddr, bp.m_isThumbCode, StopAllThreads); if (err_code == 0) bp.m_enabled = act; return err_code; } return ENOENT; }; auto activateAllMapped = [&]() -> int { for (auto &file_bps : m_lineBreakpointMapping) { for (auto &bp: file_bps.second) { if (bp.m_id != id) continue; int err_code = 0; if (bp.m_resolved_brkAddr) err_code = activateResolved(bp.m_resolved_brkAddr); // use mapped data for fast find resolved breakpoint if (err_code == 0) bp.m_enabled = act; return err_code; } } return ENOENT; }; return activateAllMapped(); } void InteropLineBreakpoints::AddAllBreakpointsInfo(std::vector &list) { std::lock_guard lock(m_breakpointsMutex); // m_lineResolvedBreakpoints should be first for (auto &addr_bps : m_lineResolvedBreakpoints) { list.reserve(list.size() + addr_bps.second.size()); for(auto &bp : addr_bps.second) { list.emplace_back(IDebugger::BreakpointInfo{ bp.m_id, true, bp.m_enabled, bp.m_times, "", // TODO bp.m_condition bp.m_sourceFullPath, bp.m_linenum, bp.m_endLine, bp.m_module, {} }); } } for (auto &file_bps : m_lineBreakpointMapping) { list.reserve(list.size() + file_bps.second.size()); for(auto &bp : file_bps.second) { list.emplace_back(IDebugger::BreakpointInfo{ bp.m_id, false, true, 0, bp.m_breakpoint.condition, file_bps.first, bp.m_breakpoint.line, 0, bp.m_breakpoint.module, {} }); } } } bool InteropLineBreakpoints::IsLineBreakpoint(std::uintptr_t addr, Breakpoint &breakpoint) { std::lock_guard lock(m_breakpointsMutex); auto find = m_lineResolvedBreakpoints.find(addr); if (find == m_lineResolvedBreakpoints.end()) return false; for (auto &br : find->second) { if (!br.m_enabled) continue; // TODO condition support ++br.m_times; br.ToBreakpoint(breakpoint, true); return true; } return false; } bool InteropLineBreakpoints::SetLineBreakpoints(pid_t pid, InteropLibraries *pInteropLibraries, const std::string &filename, const std::vector &lineBreakpoints, std::vector &breakpoints, std::function StopAllThreads, std::function FixAllThreads, std::function getId) { std::lock_guard lock(m_breakpointsMutex); auto RemoveResolvedByInitialBreakpoint = [&](InteropLineBreakpointMapping &initialBreakpoint) -> bool { if (!initialBreakpoint.m_resolved_brkAddr) return true; auto bList_it = m_lineResolvedBreakpoints.find(initialBreakpoint.m_resolved_brkAddr); if (bList_it == m_lineResolvedBreakpoints.end()) return false; for (auto itList = bList_it->second.begin(); itList != bList_it->second.end();) { if ((*itList).m_id == initialBreakpoint.m_id) { if ((*itList).m_enabled) m_sharedInteropBreakpoints->Remove(pid, initialBreakpoint.m_resolved_brkAddr, StopAllThreads, FixAllThreads); itList = bList_it->second.erase(itList); break; } else ++itList; } if (bList_it->second.empty()) m_lineResolvedBreakpoints.erase(initialBreakpoint.m_resolved_brkAddr); return true; }; if (lineBreakpoints.empty()) { auto it = m_lineBreakpointMapping.find(filename); if (it != m_lineBreakpointMapping.end()) { for (auto &initialBreakpoint : it->second) { if (!RemoveResolvedByInitialBreakpoint(initialBreakpoint)) { LOGE("Can't remove breakpoint id=%d", initialBreakpoint.m_id); return false; } } m_lineBreakpointMapping.erase(it); } return true; } auto &breakpointsInSource = m_lineBreakpointMapping[filename]; std::unordered_map breakpointsInSourceMap; // Remove old breakpoints std::unordered_set funcBreakpointLines; for (const auto &sb : lineBreakpoints) { funcBreakpointLines.insert(sb.line); } for (auto it = breakpointsInSource.begin(); it != breakpointsInSource.end();) { InteropLineBreakpointMapping &initialBreakpoint = *it; if (funcBreakpointLines.find(initialBreakpoint.m_breakpoint.line) == funcBreakpointLines.end()) { if (!RemoveResolvedByInitialBreakpoint(initialBreakpoint)) { LOGE("Can't remove breakpoint id=%d", initialBreakpoint.m_id); return false; } it = breakpointsInSource.erase(it); } else { breakpointsInSourceMap[initialBreakpoint.m_breakpoint.line] = &initialBreakpoint; ++it; } } // Export breakpoints // Note, VSCode and MI/GDB protocols requires, that "breakpoints" and "lineBreakpoints" must have same indexes for same breakpoints. for (const auto &sb : lineBreakpoints) { int line = sb.line; Breakpoint breakpoint; auto b = breakpointsInSourceMap.find(line); if (b == breakpointsInSourceMap.end()) { InteropLineBreakpointMapping initialBreakpoint; initialBreakpoint.m_breakpoint = sb; initialBreakpoint.m_id = getId(); // New breakpoint InteropLineBreakpoint bp; bp.m_id = initialBreakpoint.m_id; bp.m_module = initialBreakpoint.m_breakpoint.module; bp.m_linenum = line; bp.m_endLine = line; // TODO condition unsigned resolvedLineNum = 0; std::string resolvedFullPath; bool resolvedIsThumbCode = false; std::uintptr_t resolved_brkAddr = pInteropLibraries->FindAddrBySourceAndLine(filename, bp.m_linenum, resolvedLineNum, resolvedFullPath, resolvedIsThumbCode); // TODO add multi-line code support (endLine) if (pid && resolved_brkAddr) { if (bp.m_enabled) m_sharedInteropBreakpoints->Add(pid, resolved_brkAddr, resolvedIsThumbCode, StopAllThreads); bp.m_linenum = resolvedLineNum; // TODO bp.m_endLine -? bp.m_endLine = resolvedLineNum; bp.m_sourceFullPath = std::move(resolvedFullPath); bp.m_isThumbCode = resolvedIsThumbCode; initialBreakpoint.m_resolved_brkAddr = resolved_brkAddr; bp.ToBreakpoint(breakpoint, true); m_lineResolvedBreakpoints[resolved_brkAddr].push_back(std::move(bp)); } else { bp.m_sourceFullPath = filename; bp.ToBreakpoint(breakpoint, false); if (!pid) breakpoint.message = "The breakpoint is pending and will be resolved when debugging starts."; else breakpoint.message = "The breakpoint will not currently be hit. No symbols have been loaded for this document."; } breakpointsInSource.push_back(std::move(initialBreakpoint)); } else { InteropLineBreakpointMapping &initialBreakpoint = *b->second; // TODO condition if (initialBreakpoint.m_resolved_brkAddr) { auto bList_it = m_lineResolvedBreakpoints.find(initialBreakpoint.m_resolved_brkAddr); if (bList_it == m_lineResolvedBreakpoints.end()) return false; for (auto &bp : bList_it->second) { if (initialBreakpoint.m_id != bp.m_id) continue; // Existing breakpoint // TODO add condition change support bp.ToBreakpoint(breakpoint, true); break; } } else { // Was already added, but was not yet resolved. InteropLineBreakpoint bp; bp.m_id = initialBreakpoint.m_id; bp.m_module = initialBreakpoint.m_breakpoint.module; bp.m_linenum = line; bp.m_endLine = line; // TODO condition bp.m_sourceFullPath = filename; bp.ToBreakpoint(breakpoint, false); if (!pid) breakpoint.message = "The breakpoint is pending and will be resolved when debugging starts."; else breakpoint.message = "The breakpoint will not currently be hit. No symbols have been loaded for this document."; } } breakpoints.push_back(breakpoint); } return true; } void InteropLineBreakpoints::LoadModule(pid_t pid, std::uintptr_t startAddr, InteropLibraries *pInteropLibraries, std::vector &events) { std::lock_guard lock(m_breakpointsMutex); for (auto &initialBreakpoints : m_lineBreakpointMapping) { for (auto &initialBreakpoint : initialBreakpoints.second) { if (initialBreakpoint.m_resolved_brkAddr) continue; InteropLineBreakpoint bp; bp.m_id = initialBreakpoint.m_id; bp.m_module = initialBreakpoint.m_breakpoint.module; bp.m_enabled = initialBreakpoint.m_enabled; bp.m_linenum = initialBreakpoint.m_breakpoint.line; bp.m_endLine = initialBreakpoint.m_breakpoint.line; // TODO condition unsigned resolvedLineNum = 0; std::string resolvedFullPath; bool resolvedIsThumbCode = false; std::uintptr_t resolved_brkAddr = pInteropLibraries->FindAddrBySourceAndLineForLib(startAddr, initialBreakpoints.first, bp.m_linenum, resolvedLineNum, resolvedFullPath, resolvedIsThumbCode); // TODO add multi-line code support (endLine) if (!resolved_brkAddr) continue; if (bp.m_enabled) { // At this point we add breakpoint in unused memory (we are in the middle of lib load process now), no need to stop other threads. m_sharedInteropBreakpoints->Add(pid, resolved_brkAddr, resolvedIsThumbCode, [](){}); } bp.m_linenum = resolvedLineNum; // TODO bp.m_endLine -? bp.m_endLine = resolvedLineNum; bp.m_sourceFullPath = std::move(resolvedFullPath); bp.m_isThumbCode = resolvedIsThumbCode; initialBreakpoint.m_resolved_brkAddr = resolved_brkAddr; Breakpoint breakpoint; bp.ToBreakpoint(breakpoint, true); events.emplace_back(BreakpointChanged, breakpoint); m_lineResolvedBreakpoints[resolved_brkAddr].push_back(std::move(bp)); } } } void InteropLineBreakpoints::UnloadModule(std::uintptr_t startAddr, std::uintptr_t endAddr, std::vector &events) { std::lock_guard lock(m_breakpointsMutex); std::size_t rBrkCount = m_lineResolvedBreakpoints.size(); for (auto it = m_lineResolvedBreakpoints.begin(); it != m_lineResolvedBreakpoints.end();) { if (it->first >= startAddr && it->first < endAddr) it = m_lineResolvedBreakpoints.erase(it); else ++it; } if (rBrkCount == m_lineResolvedBreakpoints.size()) return; for (auto &file_bps : m_lineBreakpointMapping) { for (auto &bp : file_bps.second) { if (bp.m_resolved_brkAddr < startAddr || bp.m_resolved_brkAddr > endAddr) continue; Breakpoint breakpoint; breakpoint.id = bp.m_id; breakpoint.verified = false; breakpoint.condition = bp.m_breakpoint.condition; breakpoint.source = file_bps.first; breakpoint.line = bp.m_breakpoint.line; breakpoint.endLine = bp.m_breakpoint.line; breakpoint.hitCount = 0; breakpoint.message = "No executable code of the debugger's target code type is associated with this line."; events.emplace_back(BreakpointChanged, breakpoint); // reset resolve status bp.m_resolved_brkAddr = 0; } } } } // namespace InteropDebugging } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/breakpoints_interop_line.h000066400000000000000000000111011457701673000240310ustar00rootroot00000000000000// Copyright (c) 2023 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #pragma once #ifdef INTEROP_DEBUGGING #include "debugger/interop_ptrace_helpers.h" #include #include #include #include #include "interfaces/idebugger.h" namespace netcoredbg { namespace InteropDebugging { class InteropBreakpoints; class InteropLibraries; class InteropLineBreakpoints { public: InteropLineBreakpoints(std::shared_ptr &sharedInteropBreakpoints) : m_sharedInteropBreakpoints(sharedInteropBreakpoints) {} // Remove all native breakpoints at interop detach. void RemoveAllAtDetach(pid_t pid); // Return `false` in case of error, `pid` have `0` in case no debuggee process available. bool SetLineBreakpoints(pid_t pid, InteropLibraries *pInteropLibraries, const std::string &filename, const std::vector &lineBreakpoints, std::vector &breakpoints, std::function StopAllThreads, std::function FixAllThreads, std::function getId); // In case of error, return `errno` code. int AllBreakpointsActivate(pid_t pid, bool act, std::function StopAllThreads, std::function FixAllThreads); // In case of error, return `errno` code. int BreakpointActivate(pid_t pid, uint32_t id, bool act, std::function StopAllThreads, std::function FixAllThreads); void AddAllBreakpointsInfo(std::vector &list); bool IsLineBreakpoint(std::uintptr_t addr, Breakpoint &breakpoint); void LoadModule(pid_t pid, std::uintptr_t startAddr, InteropLibraries *pInteropLibraries, std::vector &events); // Remove all related to unloaded library breakpoints entries in data structures. void UnloadModule(std::uintptr_t startAddr, std::uintptr_t endAddr, std::vector &events); struct InteropLineBreakpoint { uint32_t m_id; std::string m_module; // dynamic library for interop std::string m_sourceFullPath; // resolved source full path int m_linenum; int m_endLine; bool m_enabled; bool m_isThumbCode; // Is resolved address is thumb code. ULONG32 m_times; // TODO `m_condition` support InteropLineBreakpoint() : m_id(0), m_linenum(0), m_endLine(0), m_enabled(true), m_isThumbCode(false), m_times(0) {} void ToBreakpoint(Breakpoint &breakpoint, bool verified) const; InteropLineBreakpoint(InteropLineBreakpoint &&that) = default; InteropLineBreakpoint(const InteropLineBreakpoint &that) = delete; InteropLineBreakpoint& operator=(InteropLineBreakpoint &&that) = default; InteropLineBreakpoint& operator=(const InteropLineBreakpoint &that) = delete; }; private: std::shared_ptr m_sharedInteropBreakpoints; struct InteropLineBreakpointMapping { LineBreakpoint m_breakpoint; uint32_t m_id; bool m_enabled; std::uintptr_t m_resolved_brkAddr; InteropLineBreakpointMapping() : m_breakpoint("", 0, ""), m_id(0), m_enabled(true), m_resolved_brkAddr(0) {} ~InteropLineBreakpointMapping() = default; }; std::mutex m_breakpointsMutex; // Resolved line breakpoints: // Mapped in order to fast search with mapping data (see container below): // resolved mem address -> list of all InteropLineBreakpoint resolved to this address. std::unordered_map > m_lineResolvedBreakpoints; // Mapping for input LineBreakpoint array (input from protocol) to InteropLineBreakpoint or unresolved breakpoint. // Note, instead of FuncBreakpoint for resolved breakpoint we could have changed source path and/or line number. // In this way we could connect new input data with previous data and properly add/remove resolved and unresolved breakpoints. // Container have structure for fast compare current breakpoints data with new breakpoints data from protocol: // path to source -> list of InteropLineBreakpointMapping that include LineBreakpoint (from protocol) and resolve related data. std::unordered_map > m_lineBreakpointMapping; }; } // namespace InteropDebugging } // namespace netcoredbg #endif // INTEROP_DEBUGGING netcoredbg-3.1.0-1031/src/debugger/breakpoints_line.cpp000066400000000000000000000702461457701673000226430ustar00rootroot00000000000000// Copyright (c) 2021 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #include "debugger/breakpoints_line.h" #include "debugger/breakpointutils.h" #include "metadata/modules.h" #include "utils/filesystem.h" #include #include namespace netcoredbg { void LineBreakpoints::ManagedLineBreakpoint::ToBreakpoint(Breakpoint &breakpoint, const std::string &fullname) { breakpoint.id = this->id; breakpoint.verified = this->IsVerified(); breakpoint.condition = this->condition; breakpoint.source = Source(fullname); breakpoint.line = this->linenum; breakpoint.endLine = this->endLine; breakpoint.hitCount = this->times; } void LineBreakpoints::DeleteAll() { m_breakpointsMutex.lock(); m_lineResolvedBreakpoints.clear(); m_lineBreakpointMapping.clear(); m_breakpointsMutex.unlock(); } HRESULT LineBreakpoints::CheckBreakpointHit(ICorDebugThread *pThread, ICorDebugBreakpoint *pBreakpoint, Breakpoint &breakpoint, std::vector &bpChangeEvents) { HRESULT Status; ToRelease pFunctionBreakpoint; IfFailRet(pBreakpoint->QueryInterface(IID_ICorDebugFunctionBreakpoint, (LPVOID *) &pFunctionBreakpoint)); ToRelease pFrame; IfFailRet(pThread->GetActiveFrame(&pFrame)); if (pFrame == nullptr) return E_FAIL; ULONG32 ilOffset; Modules::SequencePoint sp; IfFailRet(m_sharedModules->GetFrameILAndSequencePoint(pFrame, ilOffset, sp)); unsigned filenameIndex; IfFailRet(m_sharedModules->GetIndexBySourceFullPath(sp.document, filenameIndex)); auto breakpoints = m_lineResolvedBreakpoints.find(filenameIndex); if (breakpoints == m_lineResolvedBreakpoints.end()) return E_FAIL; auto &breakpointsInSource = breakpoints->second; auto it = breakpointsInSource.find(sp.startLine); if (it == breakpointsInSource.end()) return S_FALSE; // Stopped at break, but no breakpoints. std::list &bList = it->second; if (bList.empty()) return S_FALSE; // Stopped at break, but no breakpoints. mdMethodDef methodToken; IfFailRet(pFrame->GetFunctionToken(&methodToken)); // Same logic as provide vsdbg - only one breakpoint is active for one line, find first active in the list. for (auto &b : bList) { if (!b.enabled) continue; for (const auto &iCorFuncBreakpoint : b.iCorFuncBreakpoints) { IfFailRet(BreakpointUtils::IsSameFunctionBreakpoint(pFunctionBreakpoint, iCorFuncBreakpoint)); if (Status == S_FALSE) continue; std::string output; if (FAILED(Status = BreakpointUtils::IsEnableByCondition(b.condition, m_sharedVariables.get(), pThread, output))) { if (output.empty()) return Status; } if (Status == S_FALSE) continue; ++b.times; b.ToBreakpoint(breakpoint, sp.document); if (!output.empty()) { breakpoint.message = "The condition for a breakpoint failed to execute. The condition was '" + b.condition + "'. The error returned was '" + output + "'."; bpChangeEvents.emplace_back(BreakpointChanged, breakpoint); } return S_OK; } } return S_FALSE; // Stopped at break, but breakpoint not found. } static HRESULT EnableOneICorBreakpointForLine(std::list &bList) { // Same logic as provide vsdbg - only one breakpoint is active for one line. BOOL needEnable = TRUE; HRESULT Status = S_OK; for (auto it = bList.begin(); it != bList.end(); ++it) { if ((*it).iCorFuncBreakpoints.empty()) continue; if ((*it).enabled) { for (const auto &iCorFuncBreakpoint : (*it).iCorFuncBreakpoints) { HRESULT ret = iCorFuncBreakpoint->Activate(needEnable); Status = FAILED(ret) ? ret : Status; } needEnable = FALSE; } else { for (const auto &iCorFuncBreakpoint : (*it).iCorFuncBreakpoints) { iCorFuncBreakpoint->Activate(FALSE); } } } return Status; } // [in] pModule - optional, provide filter by module during resolve // [in,out] bp - breakpoint data for resolve static HRESULT ResolveLineBreakpoint(Modules *pModules, ICorDebugModule *pModule, LineBreakpoints::ManagedLineBreakpoint &bp, const std::string &bp_fullname, std::vector &resolvedPoints, unsigned &bp_fullname_index) { if (bp_fullname.empty() || bp.linenum <= 0 || bp.endLine <= 0) return E_INVALIDARG; HRESULT Status; CORDB_ADDRESS modAddress = 0; if (!bp.module.empty() && pModule) { IfFailRet(IsModuleHaveSameName(pModule, bp.module, IsFullPath(bp.module))); if (Status == S_FALSE) return E_FAIL; } else if (!bp.module.empty()) { bool isFullPath = IsFullPath(bp.module); pModules->ForEachModule([&bp, &modAddress, &isFullPath, &Status](ICorDebugModule *pModule) -> HRESULT { IfFailRet(IsModuleHaveSameName(pModule, bp.module, isFullPath)); if (Status == S_FALSE) return S_FALSE; IfFailRet(pModule->GetBaseAddress(&modAddress)); return E_ABORT; // Fast exit from cycle. }); if (!modAddress) return E_FAIL; } else if (pModule) // Filter data from only one module during resolve, if need. IfFailRet(pModule->GetBaseAddress(&modAddress)); IfFailRet(pModules->ResolveBreakpoint(modAddress, bp_fullname, bp_fullname_index, bp.linenum, resolvedPoints)); if (resolvedPoints.empty()) return E_FAIL; return S_OK; } static HRESULT ActivateLineBreakpoint(LineBreakpoints::ManagedLineBreakpoint &bp, const std::string &bp_fullname, bool justMyCode, const std::vector &resolvedPoints) { HRESULT Status; CORDB_ADDRESS modAddress = 0; CORDB_ADDRESS modAddressTrack = 0; bp.iCorFuncBreakpoints.reserve(resolvedPoints.size()); for (const auto &resolvedBP : resolvedPoints) { // Note, we might have situation with same source path in different modules. // VSCode/MI protocols and internal debugger routine don't support this case. IfFailRet(resolvedBP.iCorModule->GetBaseAddress(&modAddressTrack)); if (modAddress && modAddress != modAddressTrack) { LOGW("During breakpoint resolve, multiple modules with same source file path was detected."); LOGW("File name: %s", bp_fullname.c_str()); LOGW("Breakpoint activated in module: %s", GetModuleFileName(resolvedPoints[0].iCorModule).c_str()); LOGW("Ignored module: %s", GetModuleFileName(resolvedBP.iCorModule).c_str()); continue; } IfFailRet(BreakpointUtils::SkipBreakpoint(resolvedBP.iCorModule, resolvedBP.methodToken, justMyCode)); if (Status == S_OK) // S_FALSE - don't skip breakpoint continue; modAddress = modAddressTrack; ToRelease pFunc; IfFailRet(resolvedBP.iCorModule->GetFunctionFromToken(resolvedBP.methodToken, &pFunc)); ToRelease pCode; IfFailRet(pFunc->GetILCode(&pCode)); ToRelease iCorFuncBreakpoint; IfFailRet(pCode->CreateBreakpoint(resolvedBP.ilOffset, &iCorFuncBreakpoint)); IfFailRet(iCorFuncBreakpoint->Activate(bp.enabled ? TRUE : FALSE)); bp.iCorFuncBreakpoints.emplace_back(iCorFuncBreakpoint.Detach()); } if (modAddress == 0) return E_FAIL; // No reason leave extra space here, since breakpoint could be setup for 1 module only (no more breakpoints will be added). bp.iCorFuncBreakpoints.shrink_to_fit(); // same for multiple breakpoint resolve for one module bp.linenum = resolvedPoints[0].startLine; bp.endLine = resolvedPoints[0].endLine; bp.modAddress = modAddress; return S_OK; } HRESULT LineBreakpoints::ManagedCallbackLoadModule(ICorDebugModule *pModule, std::vector &events) { std::lock_guard lock(m_breakpointsMutex); for (auto &initialBreakpoints : m_lineBreakpointMapping) { for (auto &initialBreakpoint : initialBreakpoints.second) { if (initialBreakpoint.resolved_linenum) continue; ManagedLineBreakpoint bp; bp.id = initialBreakpoint.id; bp.module = initialBreakpoint.breakpoint.module; bp.enabled = initialBreakpoint.enabled; bp.linenum = initialBreakpoint.breakpoint.line; bp.endLine = initialBreakpoint.breakpoint.line; bp.condition = initialBreakpoint.breakpoint.condition; unsigned resolved_fullname_index = 0; std::vector resolvedPoints; if (FAILED(ResolveLineBreakpoint(m_sharedModules.get(), pModule, bp, initialBreakpoints.first, resolvedPoints, resolved_fullname_index)) || FAILED(ActivateLineBreakpoint(bp, initialBreakpoints.first, m_justMyCode, resolvedPoints))) continue; std::string resolved_fullname; m_sharedModules->GetSourceFullPathByIndex(resolved_fullname_index, resolved_fullname); Breakpoint breakpoint; bp.ToBreakpoint(breakpoint, resolved_fullname); events.emplace_back(BreakpointChanged, breakpoint); initialBreakpoint.resolved_fullname_index = resolved_fullname_index; initialBreakpoint.resolved_linenum = bp.linenum; m_lineResolvedBreakpoints[resolved_fullname_index][initialBreakpoint.resolved_linenum].push_back(std::move(bp)); EnableOneICorBreakpointForLine(m_lineResolvedBreakpoints[resolved_fullname_index][initialBreakpoint.resolved_linenum]); } } return S_OK; } HRESULT LineBreakpoints::UpdateLineBreakpoint(bool haveProcess, int id, int linenum, Breakpoint &breakpoint) { for (auto &initialBreakpoints : m_lineBreakpointMapping) { for (auto &initialBreakpoint : initialBreakpoints.second) { if (initialBreakpoint.id != (unsigned)id) continue; initialBreakpoint.breakpoint.line = linenum; if (!haveProcess) { initialBreakpoint.resolved_linenum = 0; initialBreakpoint.resolved_fullname_index = 0; breakpoint.message = "The breakpoint is pending and will be resolved when debugging starts."; return S_OK; } CORDB_ADDRESS modAddress = 0; if (initialBreakpoint.resolved_linenum) { auto bMap_it = m_lineResolvedBreakpoints.find(initialBreakpoint.resolved_fullname_index); if (bMap_it == m_lineResolvedBreakpoints.end()) return E_FAIL; auto bList_it = bMap_it->second.find(initialBreakpoint.resolved_linenum); if (bList_it == bMap_it->second.end()) return E_FAIL; for (auto itList = bList_it->second.begin(); itList != bList_it->second.end();) { if ((*itList).id == initialBreakpoint.id) { modAddress = (*itList).modAddress; bList_it->second.erase(itList); initialBreakpoint.resolved_linenum = 0; initialBreakpoint.resolved_fullname_index = 0; EnableOneICorBreakpointForLine(bList_it->second); break; } else ++itList; } } ManagedLineBreakpoint bp; bp.id = initialBreakpoint.id; bp.module = initialBreakpoint.breakpoint.module; bp.enabled = initialBreakpoint.enabled; bp.linenum = initialBreakpoint.breakpoint.line; bp.endLine = initialBreakpoint.breakpoint.line; bp.condition = initialBreakpoint.breakpoint.condition; unsigned resolved_fullname_index = 0; std::vector resolvedPoints; if (FAILED(m_sharedModules->ResolveBreakpoint(modAddress, initialBreakpoints.first, resolved_fullname_index, bp.linenum, resolvedPoints)) || FAILED(ActivateLineBreakpoint(bp, initialBreakpoints.first, m_justMyCode, resolvedPoints))) { return S_OK; } std::string resolved_fullname; m_sharedModules->GetSourceFullPathByIndex(resolved_fullname_index, resolved_fullname); initialBreakpoint.resolved_fullname_index = resolved_fullname_index; initialBreakpoint.resolved_linenum = bp.linenum; bp.ToBreakpoint(breakpoint, resolved_fullname); m_lineResolvedBreakpoints[resolved_fullname_index][initialBreakpoint.resolved_linenum].push_back(std::move(bp)); EnableOneICorBreakpointForLine(m_lineResolvedBreakpoints[resolved_fullname_index][initialBreakpoint.resolved_linenum]); return S_OK; } } LOGE("UpdateLineBreakpoint error, no line breakpoint with ID %i", id); return E_INVALIDARG; } HRESULT LineBreakpoints::SetLineBreakpoints(bool haveProcess, const std::string& filename, const std::vector &lineBreakpoints, std::vector &breakpoints, std::function getId) { std::lock_guard lock(m_breakpointsMutex); auto RemoveResolvedByInitialBreakpoint = [&](ManagedLineBreakpointMapping &initialBreakpoint) { if (!initialBreakpoint.resolved_linenum) return S_OK; auto bMap_it = m_lineResolvedBreakpoints.find(initialBreakpoint.resolved_fullname_index); if (bMap_it == m_lineResolvedBreakpoints.end()) return E_FAIL; auto bList_it = bMap_it->second.find(initialBreakpoint.resolved_linenum); if (bList_it == bMap_it->second.end()) return E_FAIL; for (auto itList = bList_it->second.begin(); itList != bList_it->second.end();) { if ((*itList).id == initialBreakpoint.id) { itList = bList_it->second.erase(itList); EnableOneICorBreakpointForLine(bList_it->second); break; } else ++itList; } if (bList_it->second.empty()) bMap_it->second.erase(bList_it); return S_OK; }; HRESULT Status; if (lineBreakpoints.empty()) { auto it = m_lineBreakpointMapping.find(filename); if (it != m_lineBreakpointMapping.end()) { for (auto &initialBreakpoint : it->second) { IfFailRet(RemoveResolvedByInitialBreakpoint(initialBreakpoint)); } m_lineBreakpointMapping.erase(it); } return S_OK; } auto &breakpointsInSource = m_lineBreakpointMapping[filename]; std::unordered_map breakpointsInSourceMap; // Remove old breakpoints std::unordered_set funcBreakpointLines; for (const auto &sb : lineBreakpoints) { funcBreakpointLines.insert(sb.line); } for (auto it = breakpointsInSource.begin(); it != breakpointsInSource.end();) { ManagedLineBreakpointMapping &initialBreakpoint = *it; if (funcBreakpointLines.find(initialBreakpoint.breakpoint.line) == funcBreakpointLines.end()) { IfFailRet(RemoveResolvedByInitialBreakpoint(initialBreakpoint)); it = breakpointsInSource.erase(it); } else { breakpointsInSourceMap[initialBreakpoint.breakpoint.line] = &initialBreakpoint; ++it; } } // Export breakpoints // Note, VSCode and MI/GDB protocols requires, that "breakpoints" and "lineBreakpoints" must have same indexes for same breakpoints. for (const auto &sb : lineBreakpoints) { int line = sb.line; Breakpoint breakpoint; auto b = breakpointsInSourceMap.find(line); if (b == breakpointsInSourceMap.end()) { ManagedLineBreakpointMapping initialBreakpoint; initialBreakpoint.breakpoint = sb; initialBreakpoint.id = getId(); // New breakpoint ManagedLineBreakpoint bp; bp.id = initialBreakpoint.id; bp.module = initialBreakpoint.breakpoint.module; bp.linenum = line; bp.endLine = line; bp.condition = initialBreakpoint.breakpoint.condition; unsigned resolved_fullname_index = 0; std::vector resolvedPoints; if (haveProcess && SUCCEEDED(ResolveLineBreakpoint(m_sharedModules.get(), nullptr, bp, filename, resolvedPoints, resolved_fullname_index)) && SUCCEEDED(ActivateLineBreakpoint(bp, filename, m_justMyCode, resolvedPoints))) { initialBreakpoint.resolved_fullname_index = resolved_fullname_index; initialBreakpoint.resolved_linenum = bp.linenum; std::string resolved_fullname; m_sharedModules->GetSourceFullPathByIndex(resolved_fullname_index, resolved_fullname); bp.ToBreakpoint(breakpoint, resolved_fullname); m_lineResolvedBreakpoints[resolved_fullname_index][initialBreakpoint.resolved_linenum].push_back(std::move(bp)); EnableOneICorBreakpointForLine(m_lineResolvedBreakpoints[resolved_fullname_index][initialBreakpoint.resolved_linenum]); } else { bp.ToBreakpoint(breakpoint, filename); if (!haveProcess) breakpoint.message = "The breakpoint is pending and will be resolved when debugging starts."; else breakpoint.message = "The breakpoint will not currently be hit. No symbols have been loaded for this document."; } breakpointsInSource.push_back(std::move(initialBreakpoint)); } else { ManagedLineBreakpointMapping &initialBreakpoint = *b->second; initialBreakpoint.breakpoint.condition = sb.condition; if (initialBreakpoint.resolved_linenum) { auto bMap_it = m_lineResolvedBreakpoints.find(initialBreakpoint.resolved_fullname_index); if (bMap_it == m_lineResolvedBreakpoints.end()) return E_FAIL; auto bList_it = bMap_it->second.find(initialBreakpoint.resolved_linenum); if (bList_it == bMap_it->second.end()) return E_FAIL; for (auto &bp : bList_it->second) { if (initialBreakpoint.id != bp.id) continue; // Existing breakpoint bp.condition = initialBreakpoint.breakpoint.condition; std::string resolved_fullname; m_sharedModules->GetSourceFullPathByIndex(initialBreakpoint.resolved_fullname_index, resolved_fullname); bp.ToBreakpoint(breakpoint, resolved_fullname); break; } } else { // Was already added, but was not yet resolved. ManagedLineBreakpoint bp; bp.id = initialBreakpoint.id; bp.module = initialBreakpoint.breakpoint.module; bp.linenum = line; bp.endLine = line; bp.condition = initialBreakpoint.breakpoint.condition; bp.ToBreakpoint(breakpoint, filename); if (!haveProcess) breakpoint.message = "The breakpoint is pending and will be resolved when debugging starts."; else breakpoint.message = "The breakpoint will not currently be hit. No symbols have been loaded for this document."; } } breakpoints.push_back(breakpoint); } return S_OK; } HRESULT LineBreakpoints::UpdateBreakpointsOnHotReload(ICorDebugModule *pModule, std::unordered_set &methodTokens, std::vector &events) { std::lock_guard lock(m_breakpointsMutex); HRESULT Status; CORDB_ADDRESS modAddress; IfFailRet(pModule->GetBaseAddress(&modAddress)); for (auto &initialBreakpoints : m_lineBreakpointMapping) { for (auto &initialBreakpoint : initialBreakpoints.second) { int initiallyResolved_linenum = initialBreakpoint.resolved_linenum; if (initialBreakpoint.resolved_linenum) { auto bMap_it = m_lineResolvedBreakpoints.find(initialBreakpoint.resolved_fullname_index); if (bMap_it == m_lineResolvedBreakpoints.end()) return E_FAIL; auto bList_it = bMap_it->second.find(initialBreakpoint.resolved_linenum); if (bList_it == bMap_it->second.end()) return E_FAIL; for (auto itList = bList_it->second.begin(); itList != bList_it->second.end();) { if ((*itList).id == initialBreakpoint.id && (*itList).modAddress == modAddress) { // Remove related resolved breakpoint and reset initial breakpoint to "unresolved" state. bList_it->second.erase(itList); initialBreakpoint.resolved_linenum = 0; initialBreakpoint.resolved_fullname_index = 0; EnableOneICorBreakpointForLine(bList_it->second); break; } else ++itList; } } if (initiallyResolved_linenum && initialBreakpoint.resolved_linenum) continue; ManagedLineBreakpoint bp; bp.id = initialBreakpoint.id; bp.module = initialBreakpoint.breakpoint.module; bp.enabled = initialBreakpoint.enabled; bp.linenum = initialBreakpoint.breakpoint.line; bp.endLine = initialBreakpoint.breakpoint.line; bp.condition = initialBreakpoint.breakpoint.condition; unsigned resolved_fullname_index = 0; Breakpoint breakpoint; std::vector resolvedPoints; if (FAILED(ResolveLineBreakpoint(m_sharedModules.get(), pModule, bp, initialBreakpoints.first, resolvedPoints, resolved_fullname_index)) || FAILED(ActivateLineBreakpoint(bp, initialBreakpoints.first, m_justMyCode, resolvedPoints))) { if (initiallyResolved_linenum) // Previously was resolved, need emit breakpoint changed event. { bp.ToBreakpoint(breakpoint, initialBreakpoints.first); events.emplace_back(BreakpointChanged, breakpoint); } continue; } std::string resolved_fullname; m_sharedModules->GetSourceFullPathByIndex(resolved_fullname_index, resolved_fullname); initialBreakpoint.resolved_fullname_index = resolved_fullname_index; initialBreakpoint.resolved_linenum = bp.linenum; if (initiallyResolved_linenum != initialBreakpoint.resolved_linenum) { bp.ToBreakpoint(breakpoint, resolved_fullname); events.emplace_back(BreakpointChanged, breakpoint); } m_lineResolvedBreakpoints[resolved_fullname_index][initialBreakpoint.resolved_linenum].push_back(std::move(bp)); EnableOneICorBreakpointForLine(m_lineResolvedBreakpoints[resolved_fullname_index][initialBreakpoint.resolved_linenum]); } } return S_OK; } HRESULT LineBreakpoints::AllBreakpointsActivate(bool act) { std::lock_guard lock(m_breakpointsMutex); HRESULT Status = S_OK; // resolved breakpoints for (auto &file_bps : m_lineResolvedBreakpoints) { for(auto &line_bps : file_bps.second) { for (auto &rbp : line_bps.second) { rbp.enabled = act; } HRESULT ret = EnableOneICorBreakpointForLine(line_bps.second); Status = FAILED(ret) ? ret : Status; } } // mapping (for both - resolved and unresolved breakpoints) for (auto &file_bps : m_lineBreakpointMapping) { for (auto &bp: file_bps.second) { bp.enabled = act; } } return Status; } HRESULT LineBreakpoints::BreakpointActivate(uint32_t id, bool act) { std::lock_guard lock(m_breakpointsMutex); auto activateResolved = [&](ManagedLineBreakpointMapping &bp) -> HRESULT { auto bMap_it = m_lineResolvedBreakpoints.find(bp.resolved_fullname_index); if (bMap_it == m_lineResolvedBreakpoints.end()) return E_FAIL; auto bList_it = bMap_it->second.find(bp.resolved_linenum); if (bList_it == bMap_it->second.end()) return E_FAIL; for(auto &rbp : bList_it->second) { if (rbp.id != bp.id) continue; rbp.enabled = act; return EnableOneICorBreakpointForLine(bList_it->second); } return E_FAIL; }; auto activateAllMapped = [&]() -> HRESULT { for (auto &file_bps : m_lineBreakpointMapping) { for (auto &bp: file_bps.second) { if (bp.id != id) continue; bp.enabled = act; if (!bp.resolved_linenum) return S_OK; // no resolved breakpoint, we done with success else return activateResolved(bp); // use mapped data for fast find resolved breakpoint } } return E_FAIL; }; return activateAllMapped(); } void LineBreakpoints::AddAllBreakpointsInfo(std::vector &list) { std::lock_guard lock(m_breakpointsMutex); // m_lineResolvedBreakpoints should be first for (auto &file_bps : m_lineResolvedBreakpoints) { list.reserve(list.size() + file_bps.second.size()); std::string resolved_fullname; m_sharedModules->GetSourceFullPathByIndex(file_bps.first, resolved_fullname); for(auto &line_bps : file_bps.second) { for(auto &bp : line_bps.second) { list.emplace_back(IDebugger::BreakpointInfo{ bp.id, bp.IsVerified(), bp.enabled, bp.times, bp.condition, resolved_fullname, bp.linenum, bp.endLine, bp.module, {} }); } } } for (auto &file_bps : m_lineBreakpointMapping) { list.reserve(list.size() + file_bps.second.size()); for(auto &bp : file_bps.second) { list.emplace_back(IDebugger::BreakpointInfo{ bp.id, false, true, 0, bp.breakpoint.condition, file_bps.first, bp.breakpoint.line, 0, bp.breakpoint.module, {} }); } } } } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/breakpoints_line.h000066400000000000000000000124241457701673000223020ustar00rootroot00000000000000// Copyright (c) 2021 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #pragma once #include "cor.h" #include "cordebug.h" #include #include #include #include #include #include #include "interfaces/idebugger.h" #include "utils/torelease.h" namespace netcoredbg { class Variables; class Modules; class LineBreakpoints { public: LineBreakpoints(std::shared_ptr &sharedModules, std::shared_ptr &sharedVariables) : m_sharedModules(sharedModules), m_sharedVariables(sharedVariables), m_justMyCode(true) {} void SetJustMyCode(bool enable) { m_justMyCode = enable; }; void DeleteAll(); HRESULT UpdateLineBreakpoint(bool haveProcess, int id, int linenum, Breakpoint &breakpoint); HRESULT SetLineBreakpoints(bool haveProcess, const std::string &filename, const std::vector &lineBreakpoints, std::vector &breakpoints, std::function getId); HRESULT UpdateBreakpointsOnHotReload(ICorDebugModule *pModule, std::unordered_set &methodTokens, std::vector &events); HRESULT AllBreakpointsActivate(bool act); HRESULT BreakpointActivate(uint32_t id, bool act); void AddAllBreakpointsInfo(std::vector &list); // Important! Must provide succeeded return code: // S_OK - breakpoint hit // S_FALSE - no breakpoint hit HRESULT CheckBreakpointHit(ICorDebugThread *pThread, ICorDebugBreakpoint *pBreakpoint, Breakpoint &breakpoint, std::vector &bpChangeEvents); // Important! Callbacks related methods must control return for succeeded return code. // Do not allow debugger API return succeeded (uncontrolled) return code. // Bad : // return pThread->GetID(&threadId); // Good: // IfFailRet(pThread->GetID(&threadId)); // return S_OK; HRESULT ManagedCallbackLoadModule(ICorDebugModule *pModule, std::vector &events); struct ManagedLineBreakpoint { uint32_t id; std::string module; CORDB_ADDRESS modAddress; int linenum; int endLine; bool enabled; ULONG32 times; std::string condition; // In case of code line in constructor, we could resolve multiple methods for breakpoints. // For example, `MyType obj = new MyType(1);` code will be added to all class constructors). std::vector > iCorFuncBreakpoints; bool IsVerified() const { return !iCorFuncBreakpoints.empty(); } ManagedLineBreakpoint() : id(0), modAddress(0), linenum(0), endLine(0), enabled(true), times(0) {} ~ManagedLineBreakpoint() { for (auto &iCorFuncBreakpoint : iCorFuncBreakpoints) { if (iCorFuncBreakpoint) iCorFuncBreakpoint->Activate(FALSE); } } void ToBreakpoint(Breakpoint &breakpoint, const std::string &fullname); ManagedLineBreakpoint(ManagedLineBreakpoint &&that) = default; ManagedLineBreakpoint(const ManagedLineBreakpoint &that) = delete; ManagedLineBreakpoint& operator=(ManagedLineBreakpoint &&that) = default; ManagedLineBreakpoint& operator=(const ManagedLineBreakpoint &that) = delete; }; private: std::shared_ptr m_sharedModules; std::shared_ptr m_sharedVariables; bool m_justMyCode; struct ManagedLineBreakpointMapping { LineBreakpoint breakpoint; uint32_t id; bool enabled; unsigned resolved_fullname_index; int resolved_linenum; // if int is 0 - no resolved breakpoint available in m_lineResolvedBreakpoints ManagedLineBreakpointMapping() : breakpoint("", 0, ""), id(0), enabled(true), resolved_fullname_index(0), resolved_linenum(0) {} ~ManagedLineBreakpointMapping() = default; }; std::mutex m_breakpointsMutex; // Resolved line breakpoints: // Mapped in order to fast search with mapping data (see container below): // resolved source full path index -> resolved line number -> list of all ManagedLineBreakpoint resolved to this line. std::unordered_map > > m_lineResolvedBreakpoints; // Mapping for input LineBreakpoint array (input from protocol) to ManagedLineBreakpoint or unresolved breakpoint. // Note, instead of FuncBreakpoint for resolved breakpoint we could have changed source path and/or line number. // In this way we could connect new input data with previous data and properly add/remove resolved and unresolved breakpoints. // Container have structure for fast compare current breakpoints data with new breakpoints data from protocol: // path to source -> list of ManagedLineBreakpointMapping that include LineBreakpoint (from protocol) and resolve related data. std::unordered_map > m_lineBreakpointMapping; }; } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/breakpointutils.cpp000066400000000000000000000107521457701673000225260ustar00rootroot00000000000000// Copyright (c) 2021 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #include "debugger/breakpointutils.h" #include "debugger/variables.h" #include "metadata/attributes.h" #include "utils/torelease.h" namespace netcoredbg { namespace BreakpointUtils { HRESULT IsSameFunctionBreakpoint(ICorDebugFunctionBreakpoint *pBreakpoint1, ICorDebugFunctionBreakpoint *pBreakpoint2) { HRESULT Status; if (!pBreakpoint1 || !pBreakpoint2) return E_FAIL; ULONG32 nOffset1; ULONG32 nOffset2; IfFailRet(pBreakpoint1->GetOffset(&nOffset1)); IfFailRet(pBreakpoint2->GetOffset(&nOffset2)); if (nOffset1 != nOffset2) return S_FALSE; ToRelease pFunction1; ToRelease pFunction2; IfFailRet(pBreakpoint1->GetFunction(&pFunction1)); IfFailRet(pBreakpoint2->GetFunction(&pFunction2)); mdMethodDef methodDef1; mdMethodDef methodDef2; IfFailRet(pFunction1->GetToken(&methodDef1)); IfFailRet(pFunction2->GetToken(&methodDef2)); if (methodDef1 != methodDef2) return S_FALSE; ToRelease pModule1; ToRelease pModule2; IfFailRet(pFunction1->GetModule(&pModule1)); IfFailRet(pFunction2->GetModule(&pModule2)); CORDB_ADDRESS modAddress1; IfFailRet(pModule1->GetBaseAddress(&modAddress1)); CORDB_ADDRESS modAddress2; IfFailRet(pModule2->GetBaseAddress(&modAddress2)); if (modAddress1 != modAddress2) return S_FALSE; ToRelease pCode1; IfFailRet(pFunction1->GetILCode(&pCode1)); ULONG32 methodVersion1; IfFailRet(pCode1->GetVersionNumber(&methodVersion1)); ToRelease pCode2; IfFailRet(pFunction2->GetILCode(&pCode2)); ULONG32 methodVersion2; IfFailRet(pCode2->GetVersionNumber(&methodVersion2)); if (methodVersion1 != methodVersion2) return S_FALSE; return S_OK; } HRESULT IsEnableByCondition(const std::string &condition, Variables *pVariables, ICorDebugThread *pThread, std::string &output) { if (condition.empty()) return S_OK; HRESULT Status; DWORD threadId = 0; IfFailRet(pThread->GetID(&threadId)); FrameId frameId(ThreadId{threadId}, FrameLevel{0}); ToRelease iCorProcess; IfFailRet(pThread->GetProcess(&iCorProcess)); Variable variable; if (FAILED(Status = pVariables->Evaluate(iCorProcess, frameId, condition, variable, output))) { if (output.empty()) output = "unknown error"; return Status; } if (variable.type != "bool") { if (output.empty()) output = "The breakpoint condition must evaluate to a boolean operation, result type is " + variable.type; return E_FAIL; } if (variable.value != "true") return S_FALSE; return S_OK; } HRESULT SkipBreakpoint(ICorDebugModule *pModule, mdMethodDef methodToken, bool justMyCode) { HRESULT Status; // Skip breakpoints outside of code with loaded PDB (see JMC setup during module load). ToRelease iCorFunction; IfFailRet(pModule->GetFunctionFromToken(methodToken, &iCorFunction)); ToRelease iCorFunction2; IfFailRet(iCorFunction->QueryInterface(IID_ICorDebugFunction2, (LPVOID*) &iCorFunction2)); BOOL JMCStatus = FALSE; // In case process was not stopped, GetJMCStatus() could return CORDBG_E_PROCESS_NOT_SYNCHRONIZED or another error code. // It is OK, check it as JMC code (pModule have symbols for sure), we will also check JMC status at breakpoint callback itself. if (FAILED(iCorFunction2->GetJMCStatus(&JMCStatus))) { JMCStatus = TRUE; } if (JMCStatus == FALSE) { return S_OK; // need skip breakpoint } // Care about attributes for "JMC disabled" case. if (!justMyCode) { ToRelease iUnknown; IfFailRet(pModule->GetMetaDataInterface(IID_IMetaDataImport, &iUnknown)); ToRelease iMD; IfFailRet(iUnknown->QueryInterface(IID_IMetaDataImport, (LPVOID*) &iMD)); if (HasAttribute(iMD, methodToken, DebuggerAttribute::Hidden)) return S_OK; // need skip breakpoint } return S_FALSE; // don't skip breakpoint } } // namespace BreakpointUtils } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/breakpointutils.h000066400000000000000000000013011457701673000221610ustar00rootroot00000000000000// Copyright (c) 2021 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #pragma once #include "cor.h" #include "cordebug.h" #include namespace netcoredbg { class Variables; namespace BreakpointUtils { HRESULT IsSameFunctionBreakpoint(ICorDebugFunctionBreakpoint *pBreakpoint1, ICorDebugFunctionBreakpoint *pBreakpoint2); HRESULT IsEnableByCondition(const std::string &condition, Variables *pVariables, ICorDebugThread *pThread, std::string &output); HRESULT SkipBreakpoint(ICorDebugModule *pModule, mdMethodDef methodToken, bool justMyCode); } } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/callbacksqueue.cpp000066400000000000000000000527361457701673000223030ustar00rootroot00000000000000// Copyright (c) 2020 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #ifdef _MSC_VER #include #endif #include "debugger/callbacksqueue.h" #include "debugger/threads.h" #include "debugger/evalwaiter.h" #include "debugger/breakpoints.h" #include "debugger/stepper_simple.h" #include "debugger/stepper_async.h" #include "debugger/steppers.h" #include "interfaces/iprotocol.h" #include #include namespace netcoredbg { bool CallbacksQueue::CallbacksWorkerBreakpoint(ICorDebugAppDomain *pAppDomain, ICorDebugThread *pThread, ICorDebugBreakpoint *pBreakpoint) { // S_FALSE or error - continue callback. // S_OK - this is internal Hot Reload breakpoint, ignore this callback call. if (S_OK == m_debugger.m_sharedBreakpoints->CheckApplicationReload(pThread, pBreakpoint)) return false; // S_FALSE - not error and steppers not affect on callback if (S_FALSE != m_debugger.m_uniqueSteppers->ManagedCallbackBreakpoint(pAppDomain, pThread)) return false; bool atEntry = false; ThreadId threadId(getThreadId(pThread)); StoppedEvent event(StopBreakpoint, threadId); std::vector bpChangeEvents; // S_FALSE - not error and not affect on callback (callback will emit stop event) if (S_FALSE != m_debugger.m_sharedBreakpoints->ManagedCallbackBreakpoint(pThread, pBreakpoint, event.breakpoint, bpChangeEvents, atEntry)) return false; // Disable all steppers if we stop at breakpoint during step. m_debugger.m_uniqueSteppers->DisableAllSteppers(pAppDomain); if (atEntry) event.reason = StopEntry; ToRelease pFrame; if (SUCCEEDED(pThread->GetActiveFrame(&pFrame)) && pFrame != nullptr) m_debugger.GetFrameLocation(pFrame, threadId, FrameLevel(0), event.frame); #ifdef INTEROP_DEBUGGING StopAllNativeThreads(); #endif // INTEROP_DEBUGGING m_debugger.SetLastStoppedThread(pThread); for (const BreakpointEvent &changeEvent : bpChangeEvents) { std::ostringstream ss; ss << "Breakpoint error: " << changeEvent.breakpoint.message << " - "; if(changeEvent.breakpoint.source.IsNull()) ss << changeEvent.breakpoint.funcname << "()\n"; else ss << changeEvent.breakpoint.source.path << ":" << changeEvent.breakpoint.line << "\n"; m_debugger.pProtocol->EmitOutputEvent(OutputStdErr, ss.str()); m_debugger.pProtocol->EmitBreakpointEvent(changeEvent); } m_debugger.pProtocol->EmitStoppedEvent(event); m_debugger.m_ioredirect.async_cancel(); return true; } bool CallbacksQueue::CallbacksWorkerStepComplete(ICorDebugAppDomain *pAppDomain, ICorDebugThread *pThread, CorDebugStepReason reason) { m_debugger.m_sharedBreakpoints->CheckApplicationReload(pThread); // S_FALSE - not error and steppers not affect on callback (callback will emit stop event) if (S_FALSE != m_debugger.m_uniqueSteppers->ManagedCallbackStepComplete(pThread, reason)) return false; StackFrame stackFrame; ToRelease iCorFrame; ThreadId threadId(getThreadId(pThread)); if (SUCCEEDED(pThread->GetActiveFrame(&iCorFrame)) && iCorFrame != nullptr) m_debugger.GetFrameLocation(iCorFrame, threadId, FrameLevel(0), stackFrame); StoppedEvent event(StopStep, threadId); event.frame = stackFrame; #ifdef INTEROP_DEBUGGING StopAllNativeThreads(); #endif // INTEROP_DEBUGGING m_debugger.SetLastStoppedThread(pThread); m_debugger.pProtocol->EmitStoppedEvent(event); m_debugger.m_ioredirect.async_cancel(); return true; } bool CallbacksQueue::CallbacksWorkerBreak(ICorDebugAppDomain *pAppDomain, ICorDebugThread *pThread) { m_debugger.m_sharedBreakpoints->CheckApplicationReload(pThread); // S_FALSE - not error and not affect on callback (callback will emit stop event) if (S_FALSE != m_debugger.m_sharedBreakpoints->ManagedCallbackBreak(pThread, m_debugger.GetLastStoppedThreadId())) return false; // Disable all steppers if we stop at break during step. m_debugger.m_uniqueSteppers->DisableAllSteppers(pAppDomain); m_debugger.SetLastStoppedThread(pThread); ThreadId threadId(getThreadId(pThread)); StackFrame stackFrame; ToRelease iCorFrame; if (SUCCEEDED(pThread->GetActiveFrame(&iCorFrame)) && iCorFrame != nullptr) m_debugger.GetFrameLocation(iCorFrame, threadId, FrameLevel(0), stackFrame); #ifdef INTEROP_DEBUGGING StopAllNativeThreads(); #endif // INTEROP_DEBUGGING StoppedEvent event(StopPause, threadId); event.frame = stackFrame; m_debugger.pProtocol->EmitStoppedEvent(event); m_debugger.m_ioredirect.async_cancel(); return true; } bool CallbacksQueue::CallbacksWorkerException(ICorDebugAppDomain *pAppDomain, ICorDebugThread *pThread, ExceptionCallbackType eventType, const std::string &excModule) { m_debugger.m_sharedBreakpoints->CheckApplicationReload(pThread); ThreadId threadId(getThreadId(pThread)); StoppedEvent event(StopException, threadId); // S_FALSE - not error and not affect on callback (callback will emit stop event) if (S_FALSE != m_debugger.m_sharedBreakpoints->ManagedCallbackException(pThread, eventType, excModule, event)) return false; ToRelease pActiveFrame; if (SUCCEEDED(pThread->GetActiveFrame(&pActiveFrame)) && pActiveFrame != nullptr) m_debugger.GetFrameLocation(pActiveFrame, threadId, FrameLevel(0), event.frame); // Disable all steppers if we stop during step. m_debugger.m_uniqueSteppers->DisableAllSteppers(pAppDomain); #ifdef INTEROP_DEBUGGING StopAllNativeThreads(); #endif // INTEROP_DEBUGGING m_debugger.SetLastStoppedThread(pThread); m_debugger.pProtocol->EmitStoppedEvent(event); m_debugger.m_ioredirect.async_cancel(); return true; } bool CallbacksQueue::CallbacksWorkerCreateProcess() { m_debugger.NotifyProcessCreated(); return false; } void CallbacksQueue::CallbacksWorker() { std::unique_lock lock(m_callbacksMutex); while (true) { while (m_callbacksQueue.empty() || m_stopEventInProcess) { // Note, during m_callbacksCV.wait() (waiting for notify_one call with entry added into queue), // m_callbacksMutex will be unlocked (see std::condition_variable for more info). m_callbacksCV.wait(lock); } auto &c = m_callbacksQueue.front(); switch (c.Call) { case CallbackQueueCall::Breakpoint: m_stopEventInProcess = CallbacksWorkerBreakpoint(c.iCorAppDomain, c.iCorThread, c.iCorBreakpoint); break; case CallbackQueueCall::StepComplete: m_stopEventInProcess = CallbacksWorkerStepComplete(c.iCorAppDomain, c.iCorThread, c.Reason); break; case CallbackQueueCall::Break: m_stopEventInProcess = CallbacksWorkerBreak(c.iCorAppDomain, c.iCorThread); break; case CallbackQueueCall::Exception: m_stopEventInProcess = CallbacksWorkerException(c.iCorAppDomain, c.iCorThread, c.EventType, c.ExcModule); break; case CallbackQueueCall::CreateProcess: m_stopEventInProcess = CallbacksWorkerCreateProcess(); break; #ifdef INTEROP_DEBUGGING case CallbackQueueCall::InteropBreakpoint: m_stopEventInProcess = CallbacksWorkerInteropBreakpoint(c.pid, c.addr); break; case CallbackQueueCall::InteropSignal: m_stopEventInProcess = CallbacksWorkerInteropSignal(c.pid, c.addr, c.signal); break; #endif // INTEROP_DEBUGGING default: // finish loop // called from destructor only, don't need call pop() return; } ToRelease iCorAppDomain(c.iCorAppDomain.Detach()); m_callbacksQueue.pop_front(); // Continue process execution only in case we don't have stop event emitted and queue is empty. // We safe here against fast Continue()/AddCallbackToQueue() call from new callback call, since we don't unlock m_callbacksMutex. // m_callbacksMutex will be unlocked only in m_callbacksCV.wait(), when CallbacksWorker will be ready for notify_one. if (m_callbacksQueue.empty() && !m_stopEventInProcess) { #ifdef INTEROP_DEBUGGING if (m_debugger.m_interopDebugging) m_debugger.m_sharedInteropDebugger->ContinueAllThreadsWithEvents(); if (iCorAppDomain) // last stop event was managed { iCorAppDomain->Continue(0); } else // last stop event was native { m_debugger.m_debugProcessRWLock.reader.lock(); if (m_debugger.m_iCorProcess) { m_debugger.m_iCorProcess->Continue(0); } m_debugger.m_debugProcessRWLock.reader.unlock(); } #else iCorAppDomain->Continue(0); #endif // INTEROP_DEBUGGING } } } bool CallbacksQueue::HasQueuedCallbacks(ICorDebugProcess *pProcess) { BOOL bQueued = FALSE; pProcess->HasQueuedCallbacks(NULL, &bQueued); return bQueued == TRUE; } HRESULT CallbacksQueue::AddCallbackToQueue(ICorDebugAppDomain *pAppDomain, std::function callback) { if (m_debugger.m_sharedEvalWaiter->IsEvalRunning()) { pAppDomain->Continue(0); return S_OK; } std::unique_lock lock(m_callbacksMutex); callback(); assert(!m_callbacksQueue.empty()); // Note, we don't check m_callbacksQueue.empty() here, since callback() must add entry to queue. ToRelease iCorProcess; if (SUCCEEDED(pAppDomain->GetProcess(&iCorProcess)) && HasQueuedCallbacks(iCorProcess)) pAppDomain->Continue(0); else m_callbacksCV.notify_one(); // notify_one with lock return S_OK; } HRESULT CallbacksQueue::ContinueAppDomain(ICorDebugAppDomain *pAppDomain) { if (m_debugger.m_sharedEvalWaiter->IsEvalRunning()) { if (!pAppDomain) return E_NOTIMPL; pAppDomain->Continue(0); return S_OK; } std::unique_lock lock(m_callbacksMutex); ToRelease iCorProcess; if (m_callbacksQueue.empty() || (pAppDomain && SUCCEEDED(pAppDomain->GetProcess(&iCorProcess)) && HasQueuedCallbacks(iCorProcess))) { if (!pAppDomain) return E_NOTIMPL; pAppDomain->Continue(0); } else m_callbacksCV.notify_one(); // notify_one with lock return S_OK; } HRESULT CallbacksQueue::ContinueProcess(ICorDebugProcess *pProcess) { if (m_debugger.m_sharedEvalWaiter->IsEvalRunning()) { if (!pProcess) return E_NOTIMPL; pProcess->Continue(0); return S_OK; } std::unique_lock lock(m_callbacksMutex); if (m_callbacksQueue.empty() || (pProcess && HasQueuedCallbacks(pProcess))) { if (!pProcess) return E_NOTIMPL; pProcess->Continue(0); } else m_callbacksCV.notify_one(); // notify_one with lock return S_OK; } bool CallbacksQueue::IsRunning() { std::unique_lock lock(m_callbacksMutex); return !m_stopEventInProcess; } HRESULT CallbacksQueue::Continue(ICorDebugProcess *pProcess) { std::unique_lock lock(m_callbacksMutex); assert(m_stopEventInProcess); m_stopEventInProcess = false; if (m_callbacksQueue.empty()) { #ifdef INTEROP_DEBUGGING if (m_debugger.m_interopDebugging) m_debugger.m_sharedInteropDebugger->ContinueAllThreadsWithEvents(); #endif // INTEROP_DEBUGGING return pProcess->Continue(0); } m_callbacksCV.notify_one(); // notify_one with lock return S_OK; } // NOTE caller must care about m_callbacksMutex. // Check stop status and stop, if need. // Return S_FALSE in case already was stopped, S_OK in case stopped by this call. static HRESULT InternalStop(ICorDebugProcess *pProcess, bool &stopEventInProcess) { if (stopEventInProcess) return S_FALSE; // Already stopped. HRESULT Status; IfFailRet(pProcess->Stop(0)); stopEventInProcess = true; return S_OK; } // Analog of "pProcess->Stop(0)" call that also care about callbacks. HRESULT CallbacksQueue::Stop(ICorDebugProcess *pProcess) { std::unique_lock lock(m_callbacksMutex); // DO NOT reset steppers here, this is "pProcess->Stop(0)" like call, that care about callbacks. return InternalStop(pProcess, m_stopEventInProcess); } // Stop process and set last stopped thread. If `lastStoppedThread` not passed value from protocol, find best thread. HRESULT CallbacksQueue::Pause(ICorDebugProcess *pProcess, ThreadId lastStoppedThread, EventFormat eventFormat) { // Must be real thread ID or ThreadId::AllThreads. if (!lastStoppedThread) return E_INVALIDARG; std::unique_lock lock(m_callbacksMutex); // Note, in case Stop() failed, no stop event will be emitted, don't set m_stopEventInProcess to "true" in this case. HRESULT Status; IfFailRet(InternalStop(pProcess, m_stopEventInProcess)); if (Status == S_FALSE) // Already stopped. return S_OK; #ifdef INTEROP_DEBUGGING if (m_debugger.m_interopDebugging) IfFailRet(m_debugger.m_sharedInteropDebugger->StopAllNativeThreads(pProcess)); #endif // INTEROP_DEBUGGING // Same logic as provide vsdbg in case of pause during stepping. m_debugger.m_uniqueSteppers->DisableAllSteppers(pProcess); // For Visual Studio, we have to report a thread ID in async stop event. // We have to find a thread which has a stack frame with valid location in its stack trace. std::vector threads; m_debugger.GetThreads(threads); // In case `lastStoppedThread` provided, just check that we really have it. if (lastStoppedThread != ThreadId::AllThreads) { // In case VSCode protocol, user provide "pause" thread id. if (std::find_if(threads.begin(), threads.end(), [&](Thread t){ return t.id == lastStoppedThread; }) != threads.end()) { // VSCode protocol event must provide thread only (VSCode count on this), even if this thread don't have user code. m_debugger.SetLastStoppedThreadId(lastStoppedThread); m_debugger.pProtocol->EmitStoppedEvent(StoppedEvent(StopPause, lastStoppedThread)); m_debugger.m_ioredirect.async_cancel(); return S_OK; } } else if (eventFormat == EventFormat::CLI) { // CLI protocol provide ThreadId::AllThreads as lastStoppedThread, stop at main thread with real top frame in event. m_debugger.SetLastStoppedThreadId(threads[0].id); int totalFrames = 0; std::vector stackFrames; if (SUCCEEDED(m_debugger.GetStackTrace(threads[0].id, FrameLevel(0), 1, stackFrames, totalFrames))) { StoppedEvent event(StopPause, threads[0].id); event.frame = stackFrames[0]; m_debugger.pProtocol->EmitStoppedEvent(event); m_debugger.m_ioredirect.async_cancel(); return S_OK; } } else { // MI protocol provide ThreadId::AllThreads as lastStoppedThread, this protocols require thread and frame with user code. // Note, MIEngine (MI/GDB) require frame connected to user source or it will crash Visual Studio. ThreadId lastStoppedId = m_debugger.GetLastStoppedThreadId(); // Reorder threads so that last stopped thread is checked first for (size_t i = 0; i < threads.size(); ++i) { if (threads[i].id == lastStoppedId) { std::swap(threads[0], threads[i]); break; } } // Now get stack trace for each thread and find a frame with valid source location. for (const Thread& thread : threads) { int totalFrames = 0; std::vector stackFrames; if (FAILED(m_debugger.GetStackTrace(thread.id, FrameLevel(0), 0, stackFrames, totalFrames))) continue; for (const StackFrame& stackFrame : stackFrames) { if (stackFrame.source.IsNull()) continue; StoppedEvent event(StopPause, thread.id); event.frame = stackFrame; m_debugger.SetLastStoppedThreadId(thread.id); m_debugger.pProtocol->EmitStoppedEvent(event); m_debugger.m_ioredirect.async_cancel(); return S_OK; } } } // Fatal error during stop, just fail Pause request and don't stop process. m_stopEventInProcess = false; IfFailRet(pProcess->Continue(0)); return E_FAIL; } CallbacksQueue::~CallbacksQueue() { std::unique_lock lock(m_callbacksMutex); // Clear queue and do notify_one call with FinishWorker request. m_callbacksQueue.clear(); m_callbacksQueue.emplace_front(CallbackQueueCall::FinishWorker, nullptr, nullptr, nullptr, STEP_NORMAL, ExceptionCallbackType::FIRST_CHANCE); m_stopEventInProcess = false; // forced to proceed during brake too m_callbacksCV.notify_one(); // notify_one with lock lock.unlock(); m_callbacksWorker.join(); } // NOTE caller must care about m_callbacksMutex. void CallbacksQueue::EmplaceBack(CallbackQueueCall Call, ICorDebugAppDomain *pAppDomain, ICorDebugThread *pThread, ICorDebugBreakpoint *pBreakpoint, CorDebugStepReason Reason, ExceptionCallbackType EventType, const std::string &ExcModule) { m_callbacksQueue.emplace_back(Call, pAppDomain, pThread, pBreakpoint, Reason, EventType, ExcModule); } #ifdef INTEROP_DEBUGGING bool CallbacksQueue::CallbacksWorkerInteropBreakpoint(pid_t pid, std::uintptr_t brkAddr) { ThreadId threadId(pid); StoppedEvent event(StopBreakpoint, threadId); if (!m_debugger.m_sharedBreakpoints->IsInteropLineBreakpoint(brkAddr, event.breakpoint)) return false; // Disable all steppers if we stop at breakpoint during step. m_debugger.m_debugProcessRWLock.reader.lock(); if (m_debugger.m_iCorProcess) { m_debugger.m_uniqueSteppers->DisableAllSteppers(m_debugger.m_iCorProcess); } m_debugger.m_debugProcessRWLock.reader.unlock(); m_debugger.SetLastStoppedThreadId(ThreadId(pid)); if (FAILED(m_debugger.m_sharedInteropDebugger->GetFrameForAddr(brkAddr, event.frame))) { event.frame.source = event.breakpoint.source; event.frame.line = event.breakpoint.line; } m_debugger.pProtocol->EmitStoppedEvent(event); m_debugger.m_ioredirect.async_cancel(); return true; } bool CallbacksQueue::CallbacksWorkerInteropSignal(pid_t pid, std::uintptr_t breakAddr, const std::string &signal) { ThreadId threadId(pid); StoppedEvent event(StopPause, threadId); // Disable all steppers if we stop at breakpoint during step. m_debugger.m_debugProcessRWLock.reader.lock(); if (m_debugger.m_iCorProcess) { m_debugger.m_uniqueSteppers->DisableAllSteppers(m_debugger.m_iCorProcess); } m_debugger.m_debugProcessRWLock.reader.unlock(); m_debugger.SetLastStoppedThreadId(ThreadId(pid)); if (FAILED(m_debugger.m_sharedInteropDebugger->GetFrameForAddr(breakAddr, event.frame))) { event.frame.source = event.breakpoint.source; event.frame.line = event.breakpoint.line; } event.signal_name = signal; m_debugger.pProtocol->EmitStoppedEvent(event); m_debugger.m_ioredirect.async_cancel(); return true; } HRESULT CallbacksQueue::AddInteropCallbackToQueue(std::function callback) { std::unique_lock lock(m_callbacksMutex); callback(); // Caller should add entries into m_callbacksQueue (this is why m_callbacksMutex cover this call). assert(!m_callbacksQueue.empty()); // NOTE // In case `m_stopEventInProcess` is `true`, process have "stopped" status for sure, but could already execute some eval (this is OK, do not stop managed part!). // No need to check `IsEvalRunning()` here, since this code covered by `m_callbacksMutex` (that mean, breakpoint condition check with eval not running now for sure). if (!m_stopEventInProcess) { BOOL procRunning = FALSE; m_debugger.m_debugProcessRWLock.reader.lock(); if (m_debugger.m_iCorProcess) { if (SUCCEEDED(m_debugger.m_iCorProcess->IsRunning(&procRunning)) && procRunning == TRUE) m_debugger.m_iCorProcess->Stop(0); // Early stop of native code at native event, in case this will be not stop event - we will silently continue native code execution. m_debugger.m_sharedInteropDebugger->StopAllNativeThreads(m_debugger.m_iCorProcess); } m_debugger.m_debugProcessRWLock.reader.unlock(); } m_callbacksCV.notify_one(); // notify_one with lock return S_OK; } // NOTE caller must care about m_callbacksMutex. void CallbacksQueue::EmplaceBackInterop(CallbackQueueCall Call, pid_t pid, std::uintptr_t addr, const std::string &signal) { m_callbacksQueue.emplace_back(Call, pid, addr, signal); } // NOTE caller must care about m_callbacksMutex. void CallbacksQueue::StopAllNativeThreads() { if (!m_debugger.m_interopDebugging || m_stopEventInProcess) return; m_debugger.m_debugProcessRWLock.reader.lock(); if (m_debugger.m_iCorProcess) { m_debugger.m_sharedInteropDebugger->StopAllNativeThreads(m_debugger.m_iCorProcess); } m_debugger.m_debugProcessRWLock.reader.unlock(); } #endif // INTEROP_DEBUGGING } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/callbacksqueue.h000066400000000000000000000140371457701673000217400ustar00rootroot00000000000000// Copyright (c) 2020 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #pragma once #include "debugger/manageddebugger.h" #include #include namespace netcoredbg { // https://docs.microsoft.com/en-us/dotnet/framework/unmanaged-api/debugging/icordebugcontroller-hasqueuedcallbacks-method // // Callbacks will be dispatched one at a time, each time ICorDebugController::Continue is called. // The debugger can check this flag if it wants to report multiple debugging events that occur simultaneously. // // When debugging events are queued, they have already occurred, so the debugger must drain the entire queue // to be sure of the state of the debuggee. (Call ICorDebugController::Continue to drain the queue.) For example, // if the queue contains two debugging events on thread X, and the debugger suspends thread X after the first debugging // event and then calls ICorDebugController::Continue, the second debugging event for thread X will be dispatched although // the thread has been suspended. enum class CallbackQueueCall { FinishWorker = 0, Breakpoint, StepComplete, Break, Exception, CreateProcess #ifdef INTEROP_DEBUGGING , InteropBreakpoint , InteropSignal #endif // INTEROP_DEBUGGING }; class CallbacksQueue { public: CallbacksQueue(ManagedDebuggerHelpers &debugger) : m_debugger(debugger), m_stopEventInProcess(false), m_callbacksWorker{&CallbacksQueue::CallbacksWorker, this} {} ~CallbacksQueue(); // Called from ManagedDebugger by protocol request (Continue/Pause). bool IsRunning(); HRESULT Continue(ICorDebugProcess *pProcess); // Stop process and set last stopped thread. If `lastStoppedThread` not passed value from protocol, find best thread. HRESULT Pause(ICorDebugProcess *pProcess, ThreadId lastStoppedThread, EventFormat eventFormat); // Analog of "pProcess->Stop(0)" call that also care about callbacks. HRESULT Stop(ICorDebugProcess *pProcess); HRESULT ContinueProcess(ICorDebugProcess *pProcess); HRESULT ContinueAppDomain(ICorDebugAppDomain *pAppDomain); HRESULT AddCallbackToQueue(ICorDebugAppDomain *pAppDomain, std::function callback); void EmplaceBack(CallbackQueueCall Call, ICorDebugAppDomain *pAppDomain, ICorDebugThread *pThread, ICorDebugBreakpoint *pBreakpoint, CorDebugStepReason Reason, ExceptionCallbackType EventType, const std::string &ExcModule = std::string{}); #ifdef INTEROP_DEBUGGING HRESULT AddInteropCallbackToQueue(std::function callback); void EmplaceBackInterop(CallbackQueueCall Call, pid_t pid, std::uintptr_t addr, const std::string &signal); #endif // INTEROP_DEBUGGING private: ManagedDebuggerHelpers &m_debugger; // NOTE we have one entry type for both (managed and interop) callbacks (stop events), // since almost all the time we have CallbackQueue with 1 entry only, no reason complicate code. // Probably in future we could reuse Reason, EventType and ExcModule fields for interop events too. // Each event use its own constructor. struct CallbackQueueEntry { CallbackQueueCall Call; ToRelease iCorAppDomain; ToRelease iCorThread; ToRelease iCorBreakpoint; CorDebugStepReason Reason = CorDebugStepReason::STEP_NORMAL; // Initial value in order to suppress static analyzer warnings. ExceptionCallbackType EventType = ExceptionCallbackType::FIRST_CHANCE; // Initial value in order to suppress static analyzer warnings. std::string ExcModule; CallbackQueueEntry(CallbackQueueCall call, ICorDebugAppDomain *pAppDomain, ICorDebugThread *pThread, ICorDebugBreakpoint *pBreakpoint, CorDebugStepReason reason, ExceptionCallbackType eventType, const std::string &excModule = "") : Call(call), iCorAppDomain(pAppDomain), iCorThread(pThread), iCorBreakpoint(pBreakpoint), Reason(reason), EventType(eventType), ExcModule(excModule) {} #ifdef INTEROP_DEBUGGING pid_t pid = 0; // Initial value in order to suppress static analyzer warnings. std::uintptr_t addr = 0; // Initial value in order to suppress static analyzer warnings. std::string signal; CallbackQueueEntry(CallbackQueueCall call, pid_t pid_, std::uintptr_t addr_, const std::string &signal_) : Call(call), pid(pid_), addr(addr_), signal(signal_) {} #endif // INTEROP_DEBUGGING }; std::mutex m_callbacksMutex; std::condition_variable m_callbacksCV; std::list m_callbacksQueue; // Make sure this one initialized before m_callbacksWorker. bool m_stopEventInProcess; // Make sure this one initialized before m_callbacksWorker. std::thread m_callbacksWorker; void CallbacksWorker(); bool CallbacksWorkerBreakpoint(ICorDebugAppDomain *pAppDomain, ICorDebugThread *pThread, ICorDebugBreakpoint *pBreakpoint); bool CallbacksWorkerStepComplete(ICorDebugAppDomain *pAppDomain, ICorDebugThread *pThread, CorDebugStepReason reason); bool CallbacksWorkerBreak(ICorDebugAppDomain *pAppDomain, ICorDebugThread *pThread); bool CallbacksWorkerException(ICorDebugAppDomain *pAppDomain, ICorDebugThread *pThread, ExceptionCallbackType eventType, const std::string &excModule); bool CallbacksWorkerCreateProcess(); bool HasQueuedCallbacks(ICorDebugProcess *pProcess); #ifdef INTEROP_DEBUGGING bool CallbacksWorkerInteropBreakpoint(pid_t pid, std::uintptr_t brkAddr); bool CallbacksWorkerInteropSignal(pid_t pid, std::uintptr_t breakAddr, const std::string &signal); void StopAllNativeThreads(); #endif // INTEROP_DEBUGGING }; } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/dbgshim.h000066400000000000000000000101451457701673000203650ustar00rootroot00000000000000// Copyright (c) 2020 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #pragma once #include "cor.h" #ifdef FEATURE_PAL #include #else #include #include "palclr.h" #endif #include "utils/filesystem.h" #include "utils/dynlibs.h" #include namespace netcoredbg { // Based on coreclr/src/dlls/dbgshim/dbgshim.h struct dbgshim_t { typedef VOID (*PSTARTUP_CALLBACK)(IUnknown *pCordb, PVOID parameter, HRESULT hr); HRESULT (*CreateProcessForLaunch)(LPWSTR lpCommandLine, BOOL bSuspendProcess, LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory, PDWORD pProcessId, HANDLE *pResumeHandle); HRESULT (*ResumeProcess)(HANDLE hResumeHandle); HRESULT (*CloseResumeHandle)(HANDLE hResumeHandle); HRESULT (*RegisterForRuntimeStartup)(DWORD dwProcessId, PSTARTUP_CALLBACK pfnCallback, PVOID parameter, PVOID *ppUnregisterToken); HRESULT (*UnregisterForRuntimeStartup)(PVOID pUnregisterToken); HRESULT (*EnumerateCLRs)(DWORD debuggeePID, HANDLE** ppHandleArrayOut, LPWSTR** ppStringArrayOut, DWORD* pdwArrayLengthOut); HRESULT (*CloseCLREnumeration)(HANDLE* pHandleArray, LPWSTR* pStringArray, DWORD dwArrayLength); HRESULT (*CreateVersionStringFromModule)(DWORD pidDebuggee, LPCWSTR szModuleName, LPWSTR pBuffer, DWORD cchBuffer, DWORD* pdwLength); HRESULT (*CreateDebuggingInterfaceFromVersionEx)(int iDebuggerVersion, LPCWSTR szDebuggeeVersion, IUnknown ** ppCordb); dbgshim_t() : CreateProcessForLaunch(nullptr), ResumeProcess(nullptr), CloseResumeHandle(nullptr), RegisterForRuntimeStartup(nullptr), UnregisterForRuntimeStartup(nullptr), EnumerateCLRs(nullptr), CloseCLREnumeration(nullptr), CreateVersionStringFromModule(nullptr), CreateDebuggingInterfaceFromVersionEx(nullptr), m_module(nullptr) { #ifdef DBGSHIM_DIR std::string libName(DBGSHIM_DIR); libName += DIRECTORY_SEPARATOR_STR_A; #else std::string exe = GetExeAbsPath(); if (exe.empty()) throw std::runtime_error("Unable to detect exe path"); std::size_t dirSepIndex = exe.rfind(DIRECTORY_SEPARATOR_STR_A); if (dirSepIndex == std::string::npos) return; std::string libName = exe.substr(0, dirSepIndex + 1); #endif #ifdef WIN32 libName += "dbgshim.dll"; #elif defined(__APPLE__) libName += "libdbgshim.dylib"; #else libName += "libdbgshim.so"; #endif m_module = DLOpen(libName); if (!m_module) throw std::invalid_argument("Unable to load " + libName); *((void**)&CreateProcessForLaunch) = DLSym(m_module, "CreateProcessForLaunch"); *((void**)&ResumeProcess) = DLSym(m_module, "ResumeProcess"); *((void**)&CloseResumeHandle) = DLSym(m_module, "CloseResumeHandle"); *((void**)&RegisterForRuntimeStartup) = DLSym(m_module, "RegisterForRuntimeStartup"); *((void**)&UnregisterForRuntimeStartup) = DLSym(m_module, "UnregisterForRuntimeStartup"); *((void**)&EnumerateCLRs) = DLSym(m_module, "EnumerateCLRs"); *((void**)&CloseCLREnumeration) = DLSym(m_module, "CloseCLREnumeration"); *((void**)&CreateVersionStringFromModule) = DLSym(m_module, "CreateVersionStringFromModule"); *((void**)&CreateDebuggingInterfaceFromVersionEx) = DLSym(m_module, "CreateDebuggingInterfaceFromVersionEx"); bool dlsym_ok = CreateProcessForLaunch && ResumeProcess && CloseResumeHandle && RegisterForRuntimeStartup && UnregisterForRuntimeStartup && EnumerateCLRs && CloseCLREnumeration && CreateVersionStringFromModule && CreateDebuggingInterfaceFromVersionEx; if (!dlsym_ok) throw std::invalid_argument("Unable to dlsym for dbgshim module"); } ~dbgshim_t() { if (m_module) DLClose(m_module); } private: DLHandle m_module; }; } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/evalhelpers.cpp000066400000000000000000000507701457701673000216250ustar00rootroot00000000000000// Copyright (c) 2021 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #include #include #include "debugger/evalhelpers.h" #include "debugger/evalwaiter.h" #include "debugger/evalutils.h" #include "utils/utf.h" #include "metadata/modules.h" #include "metadata/typeprinter.h" #include "valueprint.h" namespace netcoredbg { void EvalHelpers::Cleanup() { m_pSuppressFinalizeMutex.lock(); if (m_pSuppressFinalize) m_pSuppressFinalize.Free(); m_pSuppressFinalizeMutex.unlock(); m_typeObjectCacheMutex.lock(); m_typeObjectCache.clear(); m_typeObjectCacheMutex.unlock(); } HRESULT EvalHelpers::CreateString(ICorDebugThread *pThread, const std::string &value, ICorDebugValue **ppNewString) { auto value16t = to_utf16(value); return m_sharedEvalWaiter->WaitEvalResult(pThread, ppNewString, [&](ICorDebugEval *pEval) -> HRESULT { // Note, this code execution protected by EvalWaiter mutex. HRESULT Status; IfFailRet(pEval->NewString(value16t.c_str())); return S_OK; }); } // Call managed function in debuggee process. // [in] pThread - managed thread for evaluation; // [in] pFunc - function to call; // [in] ppArgsType - pointer to args Type array, could be nullptr; // [in] ArgsTypeCount - size of args Type array; // [in] ppArgsValue - pointer to args Value array, could be nullptr; // [in] ArgsValueCount - size of args Value array; // [out] ppEvalResult - return value; // [in] evalFlags - evaluation flags. HRESULT EvalHelpers::EvalFunction( ICorDebugThread *pThread, ICorDebugFunction *pFunc, ICorDebugType **ppArgsType, ULONG32 ArgsTypeCount, ICorDebugValue **ppArgsValue, ULONG32 ArgsValueCount, ICorDebugValue **ppEvalResult, int evalFlags) { assert((!ppArgsType && ArgsTypeCount == 0) || (ppArgsType && ArgsTypeCount > 0)); assert((!ppArgsValue && ArgsValueCount == 0) || (ppArgsValue && ArgsValueCount > 0)); if (evalFlags & EVAL_NOFUNCEVAL) return S_OK; std::vector< ToRelease > typeParams; // Reserve memory from the beginning, since typeParams will have ArgsTypeCount or more count of elements for sure. typeParams.reserve(ArgsTypeCount); for (ULONG32 i = 0; i < ArgsTypeCount; i++) { ToRelease pTypeEnum; if (SUCCEEDED(ppArgsType[i]->EnumerateTypeParameters(&pTypeEnum))) { ICorDebugType *curType; ULONG fetched = 0; while (SUCCEEDED(pTypeEnum->Next(1, &curType, &fetched)) && fetched == 1) { typeParams.emplace_back(curType); } } } return m_sharedEvalWaiter->WaitEvalResult(pThread, ppEvalResult, [&](ICorDebugEval *pEval) -> HRESULT { // Note, this code execution protected by EvalWaiter mutex. HRESULT Status; ToRelease pEval2; IfFailRet(pEval->QueryInterface(IID_ICorDebugEval2, (LPVOID*) &pEval2)); IfFailRet(pEval2->CallParameterizedFunction( pFunc, static_cast(typeParams.size()), (ICorDebugType **)typeParams.data(), ArgsValueCount, ppArgsValue)); return S_OK; }); } HRESULT EvalHelpers::EvalGenericFunction( ICorDebugThread *pThread, ICorDebugFunction *pFunc, ICorDebugType **ppTypes, ULONG32 typeCount, ICorDebugValue **ppValues, ULONG32 valueCount, ICorDebugValue **ppResult, int flags) { assert((!ppTypes && typeCount == 0) || (ppTypes && typeCount > 0)); assert((!ppValues && valueCount == 0) || (ppValues && valueCount > 0)); if (flags & EVAL_NOFUNCEVAL) return S_OK; return m_sharedEvalWaiter->WaitEvalResult(pThread, ppResult, [&](ICorDebugEval *pEval) -> HRESULT { // Note, this code execution protected by EvalWaiter mutex. HRESULT Status; ToRelease pEval2; IfFailRet(pEval->QueryInterface(IID_ICorDebugEval2, (LPVOID*) &pEval2)); IfFailRet(pEval2->CallParameterizedFunction( pFunc, typeCount, ppTypes, valueCount, ppValues)); return S_OK; }); } static HRESULT GetMethodToken(IMetaDataImport *pMD, mdTypeDef cl, const WCHAR *methodName) { ULONG numMethods = 0; HCORENUM mEnum = NULL; mdMethodDef methodDef = mdTypeDefNil; pMD->EnumMethodsWithName(&mEnum, cl, methodName, &methodDef, 1, &numMethods); pMD->CloseEnum(mEnum); return methodDef; } HRESULT FindFunction(ICorDebugModule *pModule, const WCHAR *typeName, const WCHAR *methodName, ICorDebugFunction **ppFunction) { HRESULT Status; ToRelease pMDUnknown; ToRelease pMD; IfFailRet(pModule->GetMetaDataInterface(IID_IMetaDataImport, &pMDUnknown)); IfFailRet(pMDUnknown->QueryInterface(IID_IMetaDataImport, (LPVOID*) &pMD)); mdTypeDef typeDef = mdTypeDefNil; IfFailRet(pMD->FindTypeDefByName(typeName, mdTypeDefNil, &typeDef)); mdMethodDef methodDef = GetMethodToken(pMD, typeDef, methodName); if (methodDef == mdMethodDefNil) return E_FAIL; return pModule->GetFunctionFromToken(methodDef, ppFunction); } HRESULT EvalHelpers::FindMethodInModule(const std::string &moduleName, const WCHAR className[], const WCHAR methodName[], ICorDebugFunction **ppFunction) { HRESULT Status; ToRelease pModule; IfFailRet(m_sharedModules->GetModuleWithName(moduleName, &pModule)); IfFailRet(FindFunction(pModule, className, methodName, ppFunction)); return S_OK; } static bool TypeHaveStaticMembers(ICorDebugType *pType) { HRESULT Status; ToRelease pClass; IfFailRet(pType->GetClass(&pClass)); mdTypeDef typeDef; IfFailRet(pClass->GetToken(&typeDef)); ToRelease pModule; IfFailRet(pClass->GetModule(&pModule)); ToRelease pMDUnknown; IfFailRet(pModule->GetMetaDataInterface(IID_IMetaDataImport, &pMDUnknown)); ToRelease pMD; IfFailRet(pMDUnknown->QueryInterface(IID_IMetaDataImport, (LPVOID*) &pMD)); ULONG numFields = 0; HCORENUM hEnum = NULL; mdFieldDef fieldDef; while(SUCCEEDED(pMD->EnumFields(&hEnum, typeDef, &fieldDef, 1, &numFields)) && numFields != 0) { DWORD fieldAttr = 0; if (FAILED(pMD->GetFieldProps(fieldDef, nullptr, nullptr, 0, nullptr, &fieldAttr, nullptr, nullptr, nullptr, nullptr, nullptr))) { continue; } if (fieldAttr & fdStatic) { pMD->CloseEnum(hEnum); return true; } } pMD->CloseEnum(hEnum); mdProperty propertyDef; ULONG numProperties = 0; HCORENUM propEnum = NULL; while(SUCCEEDED(pMD->EnumProperties(&propEnum, typeDef, &propertyDef, 1, &numProperties)) && numProperties != 0) { mdMethodDef mdGetter; if (FAILED(pMD->GetPropertyProps(propertyDef, nullptr, nullptr, 0, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, &mdGetter, nullptr, 0, nullptr))) { continue; } DWORD getterAttr = 0; if (FAILED(pMD->GetMethodProps(mdGetter, NULL, NULL, 0, NULL, &getterAttr, NULL, NULL, NULL, NULL))) { continue; } if (getterAttr & mdStatic) { pMD->CloseEnum(propEnum); return true; } } pMD->CloseEnum(propEnum); return false; } HRESULT EvalHelpers::TryReuseTypeObjectFromCache(ICorDebugType *pType, ICorDebugValue **ppTypeObjectResult) { std::lock_guard lock(m_typeObjectCacheMutex); HRESULT Status; ToRelease iCorType2; IfFailRet(pType->QueryInterface(IID_ICorDebugType2, (LPVOID*) &iCorType2)); COR_TYPEID typeID; IfFailRet(iCorType2->GetTypeID(&typeID)); auto is_same = [&typeID](type_object_t &typeObject){ return typeObject.id.token1 == typeID.token1 && typeObject.id.token2 == typeID.token2; }; auto it = std::find_if(m_typeObjectCache.begin(), m_typeObjectCache.end(), is_same); if (it == m_typeObjectCache.end()) return E_FAIL; // Move data to begin, so, last used will be on front. if (it != m_typeObjectCache.begin()) m_typeObjectCache.splice(m_typeObjectCache.begin(), m_typeObjectCache, it); if (ppTypeObjectResult) { // We don't check handle's status here, since we store only strong handles. // https://docs.microsoft.com/en-us/dotnet/framework/unmanaged-api/debugging/cordebughandletype-enumeration // The handle is strong, which prevents an object from being reclaimed by garbage collection. return m_typeObjectCache.front().typeObject->QueryInterface(IID_ICorDebugValue, (LPVOID *)ppTypeObjectResult); } return S_OK; } HRESULT EvalHelpers::AddTypeObjectToCache(ICorDebugType *pType, ICorDebugValue *pTypeObject) { std::lock_guard lock(m_typeObjectCacheMutex); HRESULT Status; ToRelease iCorType2; IfFailRet(pType->QueryInterface(IID_ICorDebugType2, (LPVOID*) &iCorType2)); COR_TYPEID typeID; IfFailRet(iCorType2->GetTypeID(&typeID)); auto is_same = [&typeID](type_object_t &typeObject){ return typeObject.id.token1 == typeID.token1 && typeObject.id.token2 == typeID.token2; }; auto it = std::find_if(m_typeObjectCache.begin(), m_typeObjectCache.end(), is_same); if (it != m_typeObjectCache.end()) return S_OK; ToRelease iCorHandleValue; IfFailRet(pTypeObject->QueryInterface(IID_ICorDebugHandleValue, (LPVOID *) &iCorHandleValue)); CorDebugHandleType handleType; if (FAILED(iCorHandleValue->GetHandleType(&handleType)) || handleType != HANDLE_STRONG) return E_FAIL; if (m_typeObjectCache.size() == m_typeObjectCacheSize) { // Re-use last list entry. m_typeObjectCache.back().id = typeID; m_typeObjectCache.back().typeObject.Free(); m_typeObjectCache.back().typeObject = iCorHandleValue.Detach(); assert(m_typeObjectCacheSize >= 2); m_typeObjectCache.splice(m_typeObjectCache.begin(), m_typeObjectCache, std::prev(m_typeObjectCache.end())); } else m_typeObjectCache.emplace_front(type_object_t{typeID, iCorHandleValue.Detach()}); return S_OK; } HRESULT EvalHelpers::CreatTypeObjectStaticConstructor( ICorDebugThread *pThread, ICorDebugType *pType, ICorDebugValue **ppTypeObjectResult, bool DetectStaticMembers) { HRESULT Status; CorElementType et; IfFailRet(pType->GetType(&et)); if (et != ELEMENT_TYPE_CLASS && et != ELEMENT_TYPE_VALUETYPE) return S_OK; // Check cache first, before check type for static members. if (SUCCEEDED(TryReuseTypeObjectFromCache(pType, ppTypeObjectResult))) return S_OK; // Create type object only in case type have static members. // Note, for some cases we have static members check outside this method. if (DetectStaticMembers && !TypeHaveStaticMembers(pType)) return S_FALSE; std::vector< ToRelease > typeParams; ToRelease pTypeEnum; if (SUCCEEDED(pType->EnumerateTypeParameters(&pTypeEnum))) { ICorDebugType *curType; ULONG fetched = 0; while (SUCCEEDED(pTypeEnum->Next(1, &curType, &fetched)) && fetched == 1) { typeParams.emplace_back(curType); } } ToRelease pClass; IfFailRet(pType->GetClass(&pClass)); ToRelease pTypeObject; IfFailRet(m_sharedEvalWaiter->WaitEvalResult(pThread, &pTypeObject, [&](ICorDebugEval *pEval) -> HRESULT { // Note, this code execution protected by EvalWaiter mutex. ToRelease pEval2; IfFailRet(pEval->QueryInterface(IID_ICorDebugEval2, (LPVOID*) &pEval2)); IfFailRet(pEval2->NewParameterizedObjectNoConstructor( pClass, static_cast(typeParams.size()), (ICorDebugType **)typeParams.data() )); return S_OK; })); if (et == ELEMENT_TYPE_CLASS) { std::lock_guard lock(m_pSuppressFinalizeMutex); if (!m_pSuppressFinalize) { static const std::string assemblyName = "System.Private.CoreLib.dll"; static const WCHAR gcName[] = W("System.GC"); static const WCHAR suppressFinalizeMethodName[] = W("SuppressFinalize"); IfFailRet(FindMethodInModule(assemblyName, gcName, suppressFinalizeMethodName, &m_pSuppressFinalize)); } if (!m_pSuppressFinalize) return E_FAIL; // Note, this call must ignore any eval flags. IfFailRet(EvalFunction(pThread, m_pSuppressFinalize, &pType, 1, pTypeObject.GetRef(), 1, nullptr, defaultEvalFlags)); } AddTypeObjectToCache(pType, pTypeObject); if (ppTypeObjectResult) *ppTypeObjectResult = pTypeObject.Detach(); return S_OK; } HRESULT EvalHelpers::GetLiteralValue( ICorDebugThread *pThread, ICorDebugType *pType, ICorDebugModule *pModule, PCCOR_SIGNATURE pSignatureBlob, ULONG sigBlobLength, UVCP_CONSTANT pRawValue, ULONG rawValueLength, ICorDebugValue **ppLiteralValue) { HRESULT Status = S_OK; if (!pRawValue || !pThread) return S_FALSE; CorSigUncompressCallingConv(pSignatureBlob); CorElementType underlyingType; CorSigUncompressElementType(pSignatureBlob, &underlyingType); ToRelease pMDUnknown; IfFailRet(pModule->GetMetaDataInterface(IID_IMetaDataImport, &pMDUnknown)); ToRelease pMD; IfFailRet(pMDUnknown->QueryInterface(IID_IMetaDataImport, (LPVOID*) &pMD)); switch(underlyingType) { case ELEMENT_TYPE_OBJECT: { ToRelease pEval; IfFailRet(pThread->CreateEval(&pEval)); IfFailRet(pEval->CreateValue(ELEMENT_TYPE_CLASS, nullptr, ppLiteralValue)); break; } case ELEMENT_TYPE_CLASS: { // Get token and create null reference mdTypeDef tk; CorSigUncompressElementType(pSignatureBlob); CorSigUncompressToken(pSignatureBlob, &tk); ToRelease pValueClass; IfFailRet(pModule->GetClassFromToken(tk, &pValueClass)); ToRelease pEval; IfFailRet(pThread->CreateEval(&pEval)); IfFailRet(pEval->CreateValue(ELEMENT_TYPE_CLASS, pValueClass, ppLiteralValue)); break; } case ELEMENT_TYPE_ARRAY: case ELEMENT_TYPE_SZARRAY: { // Get type name from signature and get its ICorDebugType std::string typeName; TypePrinter::NameForTypeSig(pSignatureBlob, pType, pMD, typeName); ToRelease pElementType; IfFailRet(EvalUtils::GetType(typeName, pThread, m_sharedModules.get(), &pElementType)); ToRelease pAppDomain; IfFailRet(pThread->GetAppDomain(&pAppDomain)); ToRelease pAppDomain2; IfFailRet(pAppDomain->QueryInterface(IID_ICorDebugAppDomain2, (LPVOID*) &pAppDomain2)); // We can not directly create null value of specific array type. // Instead, we create one element array with element type set to our specific array type. // Since array elements are initialized to null, we get our null value from the first array item. ULONG32 dims = 1; ULONG32 bounds = 0; ToRelease pTmpArrayValue; IfFailRet(m_sharedEvalWaiter->WaitEvalResult(pThread, &pTmpArrayValue, [&](ICorDebugEval *pEval) -> HRESULT { // Note, this code execution protected by EvalWaiter mutex. ToRelease pEval2; IfFailRet(pEval->QueryInterface(IID_ICorDebugEval2, (LPVOID*) &pEval2)); IfFailRet(pEval2->NewParameterizedArray(pElementType, 1, &dims, &bounds)); return S_OK; })); BOOL isNull = FALSE; ToRelease pUnboxedResult; IfFailRet(DereferenceAndUnboxValue(pTmpArrayValue, &pUnboxedResult, &isNull)); ToRelease pArray; IfFailRet(pUnboxedResult->QueryInterface(IID_ICorDebugArrayValue, (LPVOID*) &pArray)); IfFailRet(pArray->GetElementAtPosition(0, ppLiteralValue)); break; } case ELEMENT_TYPE_GENERICINST: { // Get type name from signature and get its ICorDebugType std::string typeName; TypePrinter::NameForTypeSig(pSignatureBlob, pType, pMD, typeName); ToRelease pValueType; IfFailRet(EvalUtils::GetType(typeName, pThread, m_sharedModules.get(), &pValueType)); // Create value from ICorDebugType ToRelease pEval; IfFailRet(pThread->CreateEval(&pEval)); ToRelease pEval2; IfFailRet(pEval->QueryInterface(IID_ICorDebugEval2, (LPVOID*) &pEval2)); IfFailRet(pEval2->CreateValueForType(pValueType, ppLiteralValue)); break; } case ELEMENT_TYPE_VALUETYPE: { // Get type token mdTypeDef tk; CorSigUncompressElementType(pSignatureBlob); CorSigUncompressToken(pSignatureBlob, &tk); ToRelease pValueClass; IfFailRet(pModule->GetClassFromToken(tk, &pValueClass)); // Create value (without calling a constructor) ToRelease pValue; IfFailRet(m_sharedEvalWaiter->WaitEvalResult(pThread, &pValue, [&](ICorDebugEval *pEval) -> HRESULT { // Note, this code execution protected by EvalWaiter mutex. ToRelease pEval2; IfFailRet(pEval->QueryInterface(IID_ICorDebugEval2, (LPVOID*) &pEval2)); IfFailRet(pEval2->NewParameterizedObjectNoConstructor(pValueClass, 0, nullptr)); return S_OK; })); // Set value BOOL isNull = FALSE; ToRelease pEditableValue; IfFailRet(DereferenceAndUnboxValue(pValue, &pEditableValue, &isNull)); ToRelease pGenericValue; IfFailRet(pEditableValue->QueryInterface(IID_ICorDebugGenericValue, (LPVOID*) &pGenericValue)); IfFailRet(pGenericValue->SetValue((LPVOID)pRawValue)); *ppLiteralValue = pValue.Detach(); break; } case ELEMENT_TYPE_STRING: { IfFailRet(m_sharedEvalWaiter->WaitEvalResult(pThread, ppLiteralValue, [&](ICorDebugEval *pEval) -> HRESULT { // Note, this code execution protected by EvalWaiter mutex. ToRelease pEval2; IfFailRet(pEval->QueryInterface(IID_ICorDebugEval2, (LPVOID*) &pEval2)); IfFailRet(pEval2->NewStringWithLength((LPCWSTR)pRawValue, rawValueLength)); return S_OK; })); break; } case ELEMENT_TYPE_BOOLEAN: case ELEMENT_TYPE_CHAR: case ELEMENT_TYPE_I1: case ELEMENT_TYPE_U1: case ELEMENT_TYPE_I2: case ELEMENT_TYPE_U2: case ELEMENT_TYPE_I4: case ELEMENT_TYPE_U4: case ELEMENT_TYPE_I8: case ELEMENT_TYPE_U8: case ELEMENT_TYPE_R4: case ELEMENT_TYPE_R8: { ToRelease pEval; IfFailRet(pThread->CreateEval(&pEval)); ToRelease pValue; IfFailRet(pEval->CreateValue(underlyingType, nullptr, &pValue)); ToRelease pGenericValue; IfFailRet(pValue->QueryInterface(IID_ICorDebugGenericValue, (LPVOID*) &pGenericValue)); IfFailRet(pGenericValue->SetValue((LPVOID)pRawValue)); *ppLiteralValue = pValue.Detach(); break; } default: return E_FAIL; } return S_OK; } } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/evalhelpers.h000066400000000000000000000070211457701673000212610ustar00rootroot00000000000000// Copyright (c) 2021 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #pragma once #include "cor.h" #include "cordebug.h" #include #include #include #include #include "utils/torelease.h" namespace netcoredbg { class Modules; class EvalWaiter; HRESULT FindFunction(ICorDebugModule *pModule, const WCHAR *typeName, const WCHAR *methodName, ICorDebugFunction **ppFunction); class EvalHelpers { public: EvalHelpers(std::shared_ptr &sharedModules, std::shared_ptr &sharedEvalWaiter) : m_sharedModules(sharedModules), m_sharedEvalWaiter(sharedEvalWaiter) {} HRESULT CreatTypeObjectStaticConstructor( ICorDebugThread *pThread, ICorDebugType *pType, ICorDebugValue **ppTypeObjectResult = nullptr, bool DetectStaticMembers = true); HRESULT EvalFunction( ICorDebugThread *pThread, ICorDebugFunction *pFunc, ICorDebugType **ppArgsType, ULONG32 ArgsTypeCount, ICorDebugValue **ppArgsValue, ULONG32 ArgsValueCount, ICorDebugValue **ppEvalResult, int evalFlags); HRESULT EvalGenericFunction( ICorDebugThread *pThread, ICorDebugFunction *pFunc, ICorDebugType **ppArgsType, ULONG32 ArgsTypeCount, ICorDebugValue **ppArgsValue, ULONG32 ArgsValueCount, ICorDebugValue **ppEvalResult, int evalFlags); HRESULT GetLiteralValue( ICorDebugThread *pThread, ICorDebugType *pType, ICorDebugModule *pModule, PCCOR_SIGNATURE pSignatureBlob, ULONG sigBlobLength, UVCP_CONSTANT pRawValue, ULONG rawValueLength, ICorDebugValue **ppLiteralValue); HRESULT CreateString(ICorDebugThread *pThread, const std::string &value, ICorDebugValue **ppNewString); HRESULT FindMethodInModule(const std::string &moduleName, const WCHAR className[], const WCHAR methodName[], ICorDebugFunction **ppFunction); void Cleanup(); private: std::shared_ptr m_sharedModules; std::shared_ptr m_sharedEvalWaiter; std::mutex m_pSuppressFinalizeMutex; ToRelease m_pSuppressFinalize; struct type_object_t { COR_TYPEID id; ToRelease typeObject; }; std::mutex m_typeObjectCacheMutex; // Because handles affect the performance of the garbage collector, the debugger should limit itself to a relatively // small number of handles (about 256) that are active at a time. // https://docs.microsoft.com/en-us/dotnet/framework/unmanaged-api/debugging/icordebugheapvalue2-createhandle-method // Note, we also use handles (results of eval) in var refs during brake (cleared at 'Continue'). // Warning! Since we use `std::prev(m_typeObjectCache.end())` without any check in code, make sure cache size is `2` or bigger. static const size_t m_typeObjectCacheSize = 100; // The idea of cache is not hold all type objects, but prevent numerous times same type objects creation during eval. // At access, element moved to front of list, new element also add to front. In this way, not used elements displaced from cache. std::list m_typeObjectCache; HRESULT TryReuseTypeObjectFromCache(ICorDebugType *pType, ICorDebugValue **ppTypeObjectResult); HRESULT AddTypeObjectToCache(ICorDebugType *pType, ICorDebugValue *pTypeObject); }; } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/evalstackmachine.cpp000066400000000000000000002647131457701673000226210ustar00rootroot00000000000000// Copyright (c) 2021 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #include #include #include #include #include #include "debugger/evalstackmachine.h" #include "debugger/evalhelpers.h" #include "debugger/evalwaiter.h" #include "debugger/valueprint.h" #include "debugger/evalutils.h" #include "managed/interop.h" #include "metadata/typeprinter.h" #include "utils/utf.h" namespace netcoredbg { namespace { struct FormatF { uint32_t Flags; }; struct FormatFS { uint32_t Flags; BSTR wString; }; struct FormatFI { uint32_t Flags; int32_t Int; }; struct FormatFIS { uint32_t Flags; int32_t Int; BSTR wString; }; struct FormatFIP { uint32_t Flags; int32_t Int; PVOID Ptr; }; // Keep in sync with BasicTypes enum in Evaluation.cs enum class BasicTypes : int32_t { TypeBoolean = 1, TypeByte, TypeSByte, TypeChar, TypeDouble, TypeSingle, TypeInt32, TypeUInt32, TypeInt64, TypeUInt64, TypeInt16, TypeUInt16, TypeString }; // Keep in sync with OperationType enum in Evaluation.cs enum class OperationType : int32_t { AddExpression = 1, SubtractExpression, MultiplyExpression, DivideExpression, ModuloExpression, RightShiftExpression, LeftShiftExpression, BitwiseNotExpression, LogicalAndExpression, LogicalOrExpression, ExclusiveOrExpression, BitwiseAndExpression, BitwiseOrExpression, LogicalNotExpression, EqualsExpression, NotEqualsExpression, LessThanExpression, GreaterThanExpression, LessThanOrEqualExpression, GreaterThanOrEqualExpression, UnaryPlusExpression, UnaryMinusExpression }; void ReplaceAllSubstring(std::string &str, const std::string &from, const std::string &to) { size_t start = 0; while (true) { start = str.find(from, start); if(start == std::string::npos) break; str.replace(start, from.length(), to); start += from.length(); } } void ReplaceInternalNames(std::string &expression, bool restore = false) { // TODO more internal names should be added: $thread, ... (see internal variables supported by MSVS C# debugger) static std::vector> internalNamesMap {{"$exception", "__INTERNAL_NCDB_EXCEPTION_VARIABLE"}}; for (auto &entry : internalNamesMap) { if (restore) ReplaceAllSubstring(expression, entry.second, entry.first); else ReplaceAllSubstring(expression, entry.first, entry.second); } } HRESULT CreatePrimitiveValue(ICorDebugThread *pThread, ICorDebugValue **ppValue, CorElementType type, PVOID ptr) { HRESULT Status; ToRelease iCorEval; IfFailRet(pThread->CreateEval(&iCorEval)); IfFailRet(iCorEval->CreateValue(type, nullptr, ppValue)); if (!ptr) return S_OK; ToRelease iCorGenValue; IfFailRet((*ppValue)->QueryInterface(IID_ICorDebugGenericValue, (LPVOID *) &iCorGenValue)); return iCorGenValue->SetValue(ptr); } HRESULT CreateBooleanValue(ICorDebugThread *pThread, ICorDebugValue **ppValue, bool setToTrue) { HRESULT Status; ToRelease iCorEval; IfFailRet(pThread->CreateEval(&iCorEval)); IfFailRet(iCorEval->CreateValue(ELEMENT_TYPE_BOOLEAN, nullptr, ppValue)); if (!setToTrue) return S_OK; ULONG32 cbSize; IfFailRet((*ppValue)->GetSize(&cbSize)); std::unique_ptr valueData(new (std::nothrow) BYTE[cbSize]); if (valueData == nullptr) return E_OUTOFMEMORY; memset(valueData.get(), 0, cbSize * sizeof(BYTE)); ToRelease iCorGenValue; IfFailRet((*ppValue)->QueryInterface(IID_ICorDebugGenericValue, (LPVOID *) &iCorGenValue)); IfFailRet(iCorGenValue->GetValue((LPVOID) &(valueData[0]))); valueData[0] = 1; // TRUE return iCorGenValue->SetValue((LPVOID) &(valueData[0])); } HRESULT CreateNullValue(ICorDebugThread *pThread, ICorDebugValue **ppValue) { HRESULT Status; ToRelease iCorEval; IfFailRet(pThread->CreateEval(&iCorEval)); // ICorDebugEval::CreateValue // If the value of elementType is ELEMENT_TYPE_CLASS, you get an "ICorDebugReferenceValue" (returned in ppValue) // representing the null object reference. You can use this object to pass null to a function evaluation that has // object reference parameters. You cannot set the ICorDebugValue to anything; it always remains null. return iCorEval->CreateValue(ELEMENT_TYPE_CLASS, nullptr, ppValue); } HRESULT CreateValueType(EvalWaiter *pEvalWaiter, ICorDebugThread *pThread, ICorDebugClass *pValueTypeClass, ICorDebugValue **ppValue, PVOID ptr) { HRESULT Status; // Create value (without calling a constructor) IfFailRet(pEvalWaiter->WaitEvalResult(pThread, ppValue, [&](ICorDebugEval *pEval) -> HRESULT { // Note, this code execution protected by EvalWaiter mutex. ToRelease pEval2; IfFailRet(pEval->QueryInterface(IID_ICorDebugEval2, (LPVOID*) &pEval2)); IfFailRet(pEval2->NewParameterizedObjectNoConstructor(pValueTypeClass, 0, nullptr)); return S_OK; })); if (!ptr) return S_OK; ToRelease pEditableValue; IfFailRet(DereferenceAndUnboxValue(*ppValue, &pEditableValue, nullptr)); ToRelease pGenericValue; IfFailRet(pEditableValue->QueryInterface(IID_ICorDebugGenericValue, (LPVOID*) &pGenericValue)); return pGenericValue->SetValue(ptr); } HRESULT GetElementIndex(ICorDebugValue *pInputValue, ULONG32 &index) { HRESULT Status; BOOL isNull = TRUE; ToRelease pValue; IfFailRet(DereferenceAndUnboxValue(pInputValue, &pValue, &isNull)); if(isNull) return E_INVALIDARG; ULONG32 cbSize; IfFailRet(pValue->GetSize(&cbSize)); ArrayHolder indexValue = new (std::nothrow) BYTE[cbSize]; if (indexValue == nullptr) return E_OUTOFMEMORY; memset(indexValue.GetPtr(), 0, cbSize * sizeof(BYTE)); ToRelease pGenericValue; IfFailRet(pValue->QueryInterface(IID_ICorDebugGenericValue, (LPVOID*) &pGenericValue)); IfFailRet(pGenericValue->GetValue((LPVOID) &(indexValue[0]))); CorElementType elemType; IfFailRet(pValue->GetType(&elemType)); switch (elemType) { case ELEMENT_TYPE_I1: { int8_t tmp = *(int8_t*) &(indexValue[0]); if (tmp < 0) return E_INVALIDARG; index = ULONG32((uint8_t)tmp); break; } case ELEMENT_TYPE_U1: { index = ULONG32(*(uint8_t*) &(indexValue[0])); break; } case ELEMENT_TYPE_I2: { int16_t tmp = *(int16_t*) &(indexValue[0]); if (tmp < 0) return E_INVALIDARG; index = ULONG32((uint16_t)tmp); break; } case ELEMENT_TYPE_U2: { index = ULONG32(*(uint16_t*) &(indexValue[0])); break; } case ELEMENT_TYPE_I4: { int32_t tmp = *(int32_t*) &(indexValue[0]); if (tmp < 0) return E_INVALIDARG; index = ULONG32(tmp); break; } case ELEMENT_TYPE_U4: { index = ULONG32(*(uint32_t*) &(indexValue[0])); break; } case ELEMENT_TYPE_I8: { int64_t tmp = *(int64_t*) &(indexValue[0]); if (tmp < 0) return E_INVALIDARG; index = ULONG32(tmp); break; } case ELEMENT_TYPE_U8: { index = ULONG32(*(uint64_t*) &(indexValue[0])); break; } default: return E_INVALIDARG; } return S_OK; } HRESULT GetFrontStackEntryValue(ICorDebugValue **ppResultValue, std::unique_ptr *resultSetterData, std::list &evalStack, EvalData &ed, std::string &output) { HRESULT Status; Evaluator::SetterData *inputPropertyData = nullptr; if (evalStack.front().editable) inputPropertyData = evalStack.front().setterData.get(); else resultSetterData = nullptr; if (FAILED(Status = ed.pEvaluator->ResolveIdentifiers(ed.pThread, ed.frameLevel, evalStack.front().iCorValue, inputPropertyData, evalStack.front().identifiers, ppResultValue, resultSetterData, nullptr, ed.evalFlags)) && !evalStack.front().identifiers.empty()) { std::ostringstream ss; for (size_t i = 0; i < evalStack.front().identifiers.size(); i++) { if (i != 0) ss << "."; ss << evalStack.front().identifiers[i]; } output = "error: The name '" + ss.str() + "' does not exist in the current context"; } return Status; } HRESULT GetFrontStackEntryType(ICorDebugType **ppResultType, std::list &evalStack, EvalData &ed, std::string &output) { HRESULT Status; ToRelease iCorValue; if ((FAILED(Status = ed.pEvaluator->ResolveIdentifiers(ed.pThread, ed.frameLevel, evalStack.front().iCorValue, nullptr, evalStack.front().identifiers, &iCorValue, nullptr, ppResultType, ed.evalFlags)) && !evalStack.front().identifiers.empty()) || iCorValue) { std::ostringstream ss; for (size_t i = 0; i < evalStack.front().identifiers.size(); i++) { if (i != 0) ss << "."; ss << evalStack.front().identifiers[i]; } if(!iCorValue) output = "error: The type or namespace name '" + ss.str() + "' couldn't be found"; else output = "error: '" + ss.str() + "' is a variable but is used like a type"; if (SUCCEEDED(Status)) Status = E_FAIL; } return Status; } HRESULT GetArgData(ICorDebugValue *pTypeValue, std::string &typeName, CorElementType &elemType) { HRESULT Status; IfFailRet(pTypeValue->GetType(&elemType)); if (elemType == ELEMENT_TYPE_CLASS || elemType == ELEMENT_TYPE_VALUETYPE) { ToRelease iCorTypeValue2; IfFailRet(pTypeValue->QueryInterface(IID_ICorDebugValue2, (LPVOID *) &iCorTypeValue2)); ToRelease iCorType; IfFailRet(iCorTypeValue2->GetExactType(&iCorType)); IfFailRet(TypePrinter::NameForTypeByType(iCorType, typeName)); } return S_OK; }; HRESULT CallUnaryOperator(const std::string &opName, ICorDebugValue *pValue, ICorDebugValue **pResultValue, EvalData &ed) { HRESULT Status; std::string typeName; CorElementType elemType; IfFailRet(GetArgData(pValue, typeName, elemType)); ToRelease iCorFunc; ed.pEvaluator->WalkMethods(pValue, [&]( bool is_static, const std::string &methodName, Evaluator::ReturnElementType&, std::vector &methodArgs, Evaluator::GetFunctionCallback getFunction) { if (!is_static || methodArgs.size() != 1 || opName != methodName || elemType != methodArgs[0].corType || typeName != methodArgs[0].typeName) return S_OK; IfFailRet(getFunction(&iCorFunc)); return E_ABORT; // Fast exit from cycle. }); if (!iCorFunc) return E_FAIL; return ed.pEvalHelpers->EvalFunction(ed.pThread, iCorFunc, nullptr, 0, &pValue, 1, pResultValue, ed.evalFlags); } HRESULT CallCastOperator(const std::string &opName, ICorDebugValue *pValue, CorElementType elemRetType, const std::string &typeRetName, ICorDebugValue *pTypeValue, ICorDebugValue **pResultValue, EvalData &ed) { HRESULT Status; std::string typeName; CorElementType elemType; IfFailRet(GetArgData(pTypeValue, typeName, elemType)); ToRelease iCorFunc; ed.pEvaluator->WalkMethods(pValue, [&]( bool is_static, const std::string &methodName, Evaluator::ReturnElementType& methodRet, std::vector &methodArgs, Evaluator::GetFunctionCallback getFunction) { if (!is_static || methodArgs.size() != 1 || opName != methodName || elemRetType != methodRet.corType || typeRetName != methodRet.typeName || elemType != methodArgs[0].corType || typeName != methodArgs[0].typeName) return S_OK; IfFailRet(getFunction(&iCorFunc)); return E_ABORT; // Fast exit from cycle. }); if (!iCorFunc) return E_FAIL; return ed.pEvalHelpers->EvalFunction(ed.pThread, iCorFunc, nullptr, 0, &pTypeValue, 1, pResultValue, ed.evalFlags); } HRESULT CallCastOperator(const std::string &opName, ICorDebugValue *pValue, ICorDebugValue *pTypeRetValue, ICorDebugValue *pTypeValue, ICorDebugValue **pResultValue, EvalData &ed) { HRESULT Status; std::string typeRetName; CorElementType elemRetType; IfFailRet(GetArgData(pTypeRetValue, typeRetName, elemRetType)); return CallCastOperator(opName, pValue, elemRetType, typeRetName, pTypeValue, pResultValue, ed); } template HRESULT ImplicitCastElemType(ICorDebugValue *pValue1, ICorDebugValue *pValue2, bool testRange) { HRESULT Status; ToRelease pGenericValue1; IfFailRet(pValue1->QueryInterface(IID_ICorDebugGenericValue, (LPVOID*) &pGenericValue1)); T1 value1 = 0; IfFailRet(pGenericValue1->GetValue(&value1)); if (testRange && ((value1 < 0 && (std::numeric_limits::min() == 0 || value1 - std::numeric_limits::min() < 0)) || (value1 > 0 && std::numeric_limits::max() - value1 < 0))) return E_INVALIDARG; ToRelease pGenericValue2; IfFailRet(pValue2->QueryInterface(IID_ICorDebugGenericValue, (LPVOID*) &pGenericValue2)); T2 value2 = (T2)value1; return pGenericValue2->SetValue(&value2); } typedef std::array< std::array, ELEMENT_TYPE_MAX>, ELEMENT_TYPE_MAX> ImplicitCastMap_t; ImplicitCastMap_t InitImplicitCastMap() { ImplicitCastMap_t implicitCastMap; implicitCastMap[ELEMENT_TYPE_CHAR][ELEMENT_TYPE_U2] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_CHAR][ELEMENT_TYPE_I4] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_CHAR][ELEMENT_TYPE_U4] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_CHAR][ELEMENT_TYPE_I8] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_CHAR][ELEMENT_TYPE_U8] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_CHAR][ELEMENT_TYPE_R4] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_CHAR][ELEMENT_TYPE_R8] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_I1][ELEMENT_TYPE_I2] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_I1][ELEMENT_TYPE_I4] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_I1][ELEMENT_TYPE_I8] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_I1][ELEMENT_TYPE_R4] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_I1][ELEMENT_TYPE_R8] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_U1][ELEMENT_TYPE_I2] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_U1][ELEMENT_TYPE_U2] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_U1][ELEMENT_TYPE_I4] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_U1][ELEMENT_TYPE_U4] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_U1][ELEMENT_TYPE_I8] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_U1][ELEMENT_TYPE_U8] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_U1][ELEMENT_TYPE_R4] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_U1][ELEMENT_TYPE_R8] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_I2][ELEMENT_TYPE_I4] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_I2][ELEMENT_TYPE_I8] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_I2][ELEMENT_TYPE_R4] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_I2][ELEMENT_TYPE_R8] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_U2][ELEMENT_TYPE_I4] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_U2][ELEMENT_TYPE_U4] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_U2][ELEMENT_TYPE_I8] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_U2][ELEMENT_TYPE_U8] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_U2][ELEMENT_TYPE_R4] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_U2][ELEMENT_TYPE_R8] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_I4][ELEMENT_TYPE_I8] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_I4][ELEMENT_TYPE_R4] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_I4][ELEMENT_TYPE_R8] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_U4][ELEMENT_TYPE_I8] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_U4][ELEMENT_TYPE_U8] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_U4][ELEMENT_TYPE_R4] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_U4][ELEMENT_TYPE_R8] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_I8][ELEMENT_TYPE_R4] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_I8][ELEMENT_TYPE_R8] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_U8][ELEMENT_TYPE_R4] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_U8][ELEMENT_TYPE_R8] = ImplicitCastElemType; implicitCastMap[ELEMENT_TYPE_R4][ELEMENT_TYPE_R8] = ImplicitCastElemType; return implicitCastMap; } ImplicitCastMap_t InitImplicitCastLiteralMap() { ImplicitCastMap_t implicitCastLiteralMap; implicitCastLiteralMap[ELEMENT_TYPE_I4][ELEMENT_TYPE_I1] = ImplicitCastElemType; implicitCastLiteralMap[ELEMENT_TYPE_I4][ELEMENT_TYPE_U1] = ImplicitCastElemType; implicitCastLiteralMap[ELEMENT_TYPE_I4][ELEMENT_TYPE_I2] = ImplicitCastElemType; implicitCastLiteralMap[ELEMENT_TYPE_I4][ELEMENT_TYPE_U2] = ImplicitCastElemType; implicitCastLiteralMap[ELEMENT_TYPE_I4][ELEMENT_TYPE_U4] = ImplicitCastElemType; implicitCastLiteralMap[ELEMENT_TYPE_I4][ELEMENT_TYPE_U8] = ImplicitCastElemType; return implicitCastLiteralMap; } HRESULT GetRealValueWithType(ICorDebugValue *pValue, ICorDebugValue **ppResultValue, CorElementType *pElemType = nullptr) { HRESULT Status; // Dereference and unbox value, since we need real value. ToRelease iCorRealValue; IfFailRet(DereferenceAndUnboxValue(pValue, &iCorRealValue)); CorElementType elemType; IfFailRet(iCorRealValue->GetType(&elemType)); // Note, in case of class (string is class), we must use reference instead. if (elemType == ELEMENT_TYPE_STRING || elemType == ELEMENT_TYPE_CLASS) { pValue->AddRef(); *ppResultValue = pValue; if (pElemType) *pElemType = elemType; } else { *ppResultValue = iCorRealValue.Detach(); if (pElemType) *pElemType = elemType; } return S_OK; } HRESULT CopyValue(ICorDebugValue *pSrcValue, ICorDebugValue *pDstValue, CorElementType elemTypeSrc, CorElementType elemTypeDst) { if (elemTypeSrc != elemTypeDst) return E_INVALIDARG; HRESULT Status; // Change address. if (elemTypeDst == ELEMENT_TYPE_STRING || elemTypeDst == ELEMENT_TYPE_CLASS) { ToRelease pRefNew; IfFailRet(pSrcValue->QueryInterface(IID_ICorDebugReferenceValue, (LPVOID *) &pRefNew)); ToRelease pRefOld; IfFailRet(pDstValue->QueryInterface(IID_ICorDebugReferenceValue, (LPVOID *) &pRefOld)); CORDB_ADDRESS addr; IfFailRet(pRefNew->GetValue(&addr)); return pRefOld->SetValue(addr); } // Copy data. if (elemTypeDst == ELEMENT_TYPE_BOOLEAN || elemTypeDst == ELEMENT_TYPE_CHAR || elemTypeDst == ELEMENT_TYPE_I1 || elemTypeDst == ELEMENT_TYPE_U1 || elemTypeDst == ELEMENT_TYPE_I2 || elemTypeDst == ELEMENT_TYPE_U2 || elemTypeDst == ELEMENT_TYPE_U4 || elemTypeDst == ELEMENT_TYPE_I4 || elemTypeDst == ELEMENT_TYPE_I8 || elemTypeDst == ELEMENT_TYPE_U8 || elemTypeDst == ELEMENT_TYPE_R4 || elemTypeDst == ELEMENT_TYPE_R8 || elemTypeDst == ELEMENT_TYPE_VALUETYPE) { ULONG32 cbSize; IfFailRet(pSrcValue->GetSize(&cbSize)); ArrayHolder elemValue = new (std::nothrow) BYTE[cbSize]; if (elemValue == nullptr) return E_OUTOFMEMORY; memset(elemValue.GetPtr(), 0, cbSize * sizeof(BYTE)); ToRelease pGenericValue; IfFailRet(pSrcValue->QueryInterface(IID_ICorDebugGenericValue, (LPVOID*) &pGenericValue)); IfFailRet(pGenericValue->GetValue((LPVOID) &(elemValue[0]))); pGenericValue.Free(); IfFailRet(pDstValue->QueryInterface(IID_ICorDebugGenericValue, (LPVOID*) &pGenericValue)); return pGenericValue->SetValue(elemValue.GetPtr()); } return E_NOTIMPL; } HRESULT ImplicitCast(ICorDebugValue *pSrcValue, ICorDebugValue *pDstValue, bool srcLiteral, EvalData &ed) { HRESULT Status; // Value with type was provided by caller, result must be implicitly cast to this type. // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/conversions#implicit-numeric-conversions // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/integral-numeric-types#integer-literals ToRelease iCorRealValue1; CorElementType elemType1; IfFailRet(GetRealValueWithType(pSrcValue, &iCorRealValue1, &elemType1)); ToRelease iCorRealValue2; CorElementType elemType2; IfFailRet(GetRealValueWithType(pDstValue, &iCorRealValue2, &elemType2)); bool haveSameType = true; if (elemType1 == elemType2) { if (elemType2 == ELEMENT_TYPE_VALUETYPE || elemType2 == ELEMENT_TYPE_CLASS) { std::string mdName1; IfFailRet(TypePrinter::NameForTypeByValue(iCorRealValue1, mdName1)); std::string mdName2; IfFailRet(TypePrinter::NameForTypeByValue(iCorRealValue2, mdName2)); if (mdName1 != mdName2) haveSameType = false; } } else { haveSameType = false; } if (!haveSameType && (elemType1 == ELEMENT_TYPE_VALUETYPE || elemType2 == ELEMENT_TYPE_VALUETYPE || elemType1 == ELEMENT_TYPE_CLASS || elemType2 == ELEMENT_TYPE_CLASS)) { ToRelease iCorResultValue; if (FAILED(Status = CallCastOperator("op_Implicit", iCorRealValue1, iCorRealValue2, iCorRealValue1, &iCorResultValue, ed)) && FAILED(Status = CallCastOperator("op_Implicit", iCorRealValue2, iCorRealValue2, iCorRealValue1, &iCorResultValue, ed))) return Status; iCorRealValue1.Free(); IfFailRet(GetRealValueWithType(iCorResultValue, &iCorRealValue1, &elemType1)); haveSameType = true; } if (haveSameType) return CopyValue(iCorRealValue1, iCorRealValue2, elemType1, elemType2); static ImplicitCastMap_t implicitCastMap = InitImplicitCastMap(); static ImplicitCastMap_t implicitCastLiteralMap = InitImplicitCastLiteralMap(); if (srcLiteral && implicitCastLiteralMap[elemType1][elemType2] != nullptr) return implicitCastLiteralMap[elemType1][elemType2](iCorRealValue1, iCorRealValue2, true); if (implicitCastMap[elemType1][elemType2] != nullptr) return implicitCastMap[elemType1][elemType2](iCorRealValue1, iCorRealValue2, false); return E_INVALIDARG; } HRESULT GetOperandDataTypeByValue(ICorDebugValue *pValue, CorElementType elemType, PVOID &resultData, int32_t &resultType) { HRESULT Status; if (elemType == ELEMENT_TYPE_STRING) { resultType = (int32_t)BasicTypes::TypeString; ToRelease iCorValue; BOOL isNull = FALSE; IfFailRet(DereferenceAndUnboxValue(pValue, &iCorValue, &isNull)); resultData = 0; if (!isNull) { std::string String; IfFailRet(PrintStringValue(iCorValue, String)); resultData = Interop::AllocString(String); } return S_OK; } static std::unordered_map basicTypesMap { {ELEMENT_TYPE_BOOLEAN, BasicTypes::TypeBoolean}, {ELEMENT_TYPE_U1, BasicTypes::TypeByte}, {ELEMENT_TYPE_I1, BasicTypes::TypeSByte}, {ELEMENT_TYPE_CHAR, BasicTypes::TypeChar}, {ELEMENT_TYPE_R8, BasicTypes::TypeDouble}, {ELEMENT_TYPE_R4, BasicTypes::TypeSingle}, {ELEMENT_TYPE_I4, BasicTypes::TypeInt32}, {ELEMENT_TYPE_U4, BasicTypes::TypeUInt32}, {ELEMENT_TYPE_I8, BasicTypes::TypeInt64}, {ELEMENT_TYPE_U8, BasicTypes::TypeUInt64}, {ELEMENT_TYPE_I2, BasicTypes::TypeInt16}, {ELEMENT_TYPE_U2, BasicTypes::TypeUInt16} }; auto findType = basicTypesMap.find(elemType); if (findType == basicTypesMap.end()) return E_FAIL; resultType = (int32_t)findType->second; ToRelease iCorGenValue; IfFailRet(pValue->QueryInterface(IID_ICorDebugGenericValue, (LPVOID *) &iCorGenValue)); return iCorGenValue->GetValue(resultData); } HRESULT GetValueByOperandDataType(PVOID valueData, BasicTypes valueType, ICorDebugValue **ppValue, EvalData &ed) { if (valueType == BasicTypes::TypeString) { std::string String = to_utf8((WCHAR*)valueData); return ed.pEvalHelpers->CreateString(ed.pThread, String, ppValue); } static std::unordered_map basicTypesMap { {BasicTypes::TypeBoolean, ELEMENT_TYPE_BOOLEAN}, {BasicTypes::TypeByte, ELEMENT_TYPE_U1}, {BasicTypes::TypeSByte, ELEMENT_TYPE_I1}, {BasicTypes::TypeChar, ELEMENT_TYPE_CHAR}, {BasicTypes::TypeDouble, ELEMENT_TYPE_R8}, {BasicTypes::TypeSingle, ELEMENT_TYPE_R4}, {BasicTypes::TypeInt32, ELEMENT_TYPE_I4}, {BasicTypes::TypeUInt32, ELEMENT_TYPE_U4}, {BasicTypes::TypeInt64, ELEMENT_TYPE_I8}, {BasicTypes::TypeUInt64, ELEMENT_TYPE_U8}, {BasicTypes::TypeInt16, ELEMENT_TYPE_I2}, {BasicTypes::TypeUInt16, ELEMENT_TYPE_U2} }; auto findType = basicTypesMap.find(valueType); if (findType == basicTypesMap.end()) return E_FAIL; return CreatePrimitiveValue(ed.pThread, ppValue, findType->second, valueData); } HRESULT CallBinaryOperator(const std::string &opName, ICorDebugValue *pValue, ICorDebugValue *pType1Value, ICorDebugValue *pType2Value, ICorDebugValue **pResultValue, EvalData &ed) { HRESULT Status; std::string typeName1; CorElementType elemType1; IfFailRet(GetArgData(pType1Value, typeName1, elemType1)); std::string typeName2; CorElementType elemType2; IfFailRet(GetArgData(pType2Value, typeName2, elemType2)); // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/operator-overloading // A unary operator has one input parameter. A binary operator has two input parameters. In each case, // at least one parameter must have type T or T? where T is the type that contains the operator declaration. std::string typeName; CorElementType elemType; IfFailRet(GetArgData(pValue, typeName, elemType)); if ((elemType != elemType1 || typeName != typeName1) && (elemType != elemType2 || typeName != typeName2)) return E_INVALIDARG; ToRelease iCorTypeValue; auto CallOperator = [&](std::function&)> cb) { ToRelease iCorFunc; ed.pEvaluator->WalkMethods(pValue, [&]( bool is_static, const std::string &methodName, Evaluator::ReturnElementType&, std::vector &methodArgs, Evaluator::GetFunctionCallback getFunction) { if (!is_static || methodArgs.size() != 2 || opName != methodName || FAILED(cb(methodArgs))) return S_OK; // Return with success to continue walk. IfFailRet(getFunction(&iCorFunc)); return E_ABORT; // Fast exit from cycle, since we already found iCorFunc. }); if (!iCorFunc) return E_INVALIDARG; ICorDebugValue *ppArgsValue[] = {pType1Value, pType2Value}; return ed.pEvalHelpers->EvalFunction(ed.pThread, iCorFunc, nullptr, 0, ppArgsValue, 2, pResultValue, ed.evalFlags); }; // Try execute operator for exact same type as provided values. if (SUCCEEDED(CallOperator([&](std::vector &methodArgs) { return elemType1 != methodArgs[0].corType || typeName1 != methodArgs[0].typeName || elemType2 != methodArgs[1].corType || typeName2 != methodArgs[1].typeName ? E_FAIL : S_OK; }))) return S_OK; // Try execute operator with implicit cast for second value. // Make sure we don't cast "base" struct/class value for this case, since "... at least one parameter must have type T...". if (elemType == elemType1 && typeName == typeName1 && SUCCEEDED(CallOperator([&](std::vector &methodArgs) { if (elemType1 != methodArgs[0].corType || typeName1 != methodArgs[0].typeName) return E_FAIL; ToRelease iCorResultValue; if (FAILED(CallCastOperator("op_Implicit", pType1Value, methodArgs[1].corType, methodArgs[1].typeName, pType2Value, &iCorResultValue, ed)) && FAILED(CallCastOperator("op_Implicit", pType2Value, methodArgs[1].corType, methodArgs[1].typeName, pType2Value, &iCorResultValue, ed))) return E_FAIL; IfFailRet(GetRealValueWithType(iCorResultValue, &iCorTypeValue)); pType2Value = iCorTypeValue.GetPtr(); return S_OK; }))) return S_OK; // Try execute operator with implicit cast for first value. return CallOperator([&](std::vector &methodArgs) { if (elemType2 != methodArgs[1].corType || typeName2 != methodArgs[1].typeName) return E_FAIL; ToRelease iCorResultValue; if (FAILED(CallCastOperator("op_Implicit", pType1Value, methodArgs[0].corType, methodArgs[0].typeName, pType1Value, &iCorResultValue, ed)) && FAILED(CallCastOperator("op_Implicit", pType2Value, methodArgs[0].corType, methodArgs[0].typeName, pType1Value, &iCorResultValue, ed))) return E_FAIL; iCorTypeValue.Free(); IfFailRet(GetRealValueWithType(iCorResultValue, &iCorTypeValue)); pType1Value = iCorTypeValue.GetPtr(); return S_OK; }); } bool SupportedByCalculationDelegateType(CorElementType elemType) { static std::unordered_set supportedElementTypes{ ELEMENT_TYPE_BOOLEAN, ELEMENT_TYPE_U1, ELEMENT_TYPE_I1, ELEMENT_TYPE_CHAR, ELEMENT_TYPE_R8, ELEMENT_TYPE_R4, ELEMENT_TYPE_I4, ELEMENT_TYPE_U4, ELEMENT_TYPE_I8, ELEMENT_TYPE_U8, ELEMENT_TYPE_I2, ELEMENT_TYPE_U2, ELEMENT_TYPE_STRING }; return supportedElementTypes.find(elemType) != supportedElementTypes.end(); } HRESULT CalculateTwoOparands(OperationType opType, std::list &evalStack, std::string &output, EvalData &ed) { HRESULT Status; ToRelease iCorValue2; IfFailRet(GetFrontStackEntryValue(&iCorValue2, nullptr, evalStack, ed, output)); evalStack.pop_front(); ToRelease iCorRealValue2; CorElementType elemType2; IfFailRet(GetRealValueWithType(iCorValue2, &iCorRealValue2, &elemType2)); ToRelease iCorValue1; IfFailRet(GetFrontStackEntryValue(&iCorValue1, nullptr, evalStack, ed, output)); evalStack.front().ResetEntry(); ToRelease iCorRealValue1; CorElementType elemType1; IfFailRet(GetRealValueWithType(iCorValue1, &iCorRealValue1, &elemType1)); if (elemType1 == ELEMENT_TYPE_VALUETYPE || elemType2 == ELEMENT_TYPE_VALUETYPE || elemType1 == ELEMENT_TYPE_CLASS || elemType2 == ELEMENT_TYPE_CLASS) { static std::unordered_map> opMap{ {OperationType::AddExpression, {"op_Addition", "+"}}, {OperationType::SubtractExpression, {"op_Subtraction", "-"}}, {OperationType::MultiplyExpression, {"op_Multiply", "*"}}, {OperationType::DivideExpression, {"op_Division", "/"}}, {OperationType::ModuloExpression, {"op_Modulus", "%"}}, {OperationType::RightShiftExpression, {"op_RightShift", ">>"}}, {OperationType::LeftShiftExpression, {"op_LeftShift", "<<"}}, {OperationType::LogicalAndExpression, {"op_LogicalAnd", "&&"}}, {OperationType::LogicalOrExpression, {"op_LogicalOr", "||"}}, {OperationType::ExclusiveOrExpression, {"op_ExclusiveOr", "^"}}, {OperationType::BitwiseAndExpression, {"op_BitwiseAnd", "&"}}, {OperationType::BitwiseOrExpression, {"op_BitwiseOr", "|"}}, {OperationType::EqualsExpression, {"op_Equality", "=="}}, {OperationType::NotEqualsExpression, {"op_Inequality", "!="}}, {OperationType::LessThanExpression, {"op_LessThan", "<"}}, {OperationType::GreaterThanExpression, {"op_GreaterThan", ">"}}, {OperationType::LessThanOrEqualExpression, {"op_LessThanOrEqual", "<="}}, {OperationType::GreaterThanOrEqualExpression, {"op_GreaterThanOrEqual", ">="}} }; auto findOpName = opMap.find(opType); if (findOpName == opMap.end()) return E_FAIL; if (((elemType1 == ELEMENT_TYPE_VALUETYPE || elemType1 == ELEMENT_TYPE_CLASS) && SUCCEEDED(CallBinaryOperator(findOpName->second.first, iCorRealValue1, iCorRealValue1, iCorRealValue2, &evalStack.front().iCorValue, ed))) || ((elemType2 == ELEMENT_TYPE_VALUETYPE || elemType2 == ELEMENT_TYPE_CLASS) && SUCCEEDED(CallBinaryOperator(findOpName->second.first, iCorRealValue2, iCorRealValue1, iCorRealValue2, &evalStack.front().iCorValue, ed)))) return S_OK; std::string typeRetName; CorElementType elemRetType; ToRelease iCorResultValue; // Try to implicitly cast struct/class object into build-in type supported by CalculationDelegate(). if (SupportedByCalculationDelegateType(elemType2) && // First is ELEMENT_TYPE_VALUETYPE or ELEMENT_TYPE_CLASS SUCCEEDED(GetArgData(iCorRealValue2, typeRetName, elemRetType)) && SUCCEEDED(CallCastOperator("op_Implicit", iCorRealValue1, elemRetType, typeRetName, iCorRealValue1, &iCorResultValue, ed))) { iCorRealValue1.Free(); IfFailRet(GetRealValueWithType(iCorResultValue, &iCorRealValue1, &elemType1)); // goto CalculationDelegate() related routine (see code below this 'if' statement scope) } else if (SupportedByCalculationDelegateType(elemType1) && // Second is ELEMENT_TYPE_VALUETYPE or ELEMENT_TYPE_CLASS SUCCEEDED(GetArgData(iCorRealValue1, typeRetName, elemRetType)) && SUCCEEDED(CallCastOperator("op_Implicit", iCorRealValue2, elemRetType, typeRetName, iCorRealValue2, &iCorResultValue, ed))) { iCorRealValue2.Free(); IfFailRet(GetRealValueWithType(iCorResultValue, &iCorRealValue2, &elemType2)); // goto CalculationDelegate() related routine (see code below this 'if' statement scope) } else { std::string typeName1; IfFailRet(TypePrinter::GetTypeOfValue(iCorRealValue1, typeName1)); std::string typeName2; IfFailRet(TypePrinter::GetTypeOfValue(iCorRealValue2, typeName2)); output = "error CS0019: Operator '" + findOpName->second.second + "' cannot be applied to operands of type '" + typeName1 + "' and '" + typeName2 + "'"; return E_INVALIDARG; } } else if (!SupportedByCalculationDelegateType(elemType1) || !SupportedByCalculationDelegateType(elemType2)) return E_INVALIDARG; int64_t valueDataHolder1 = 0; PVOID valueData1 = &valueDataHolder1; int32_t valueType1 = 0; int64_t valueDataHolder2 = 0; PVOID valueData2 = &valueDataHolder2; int32_t valueType2 = 0; PVOID resultData = NULL; int32_t resultType = 0; if (SUCCEEDED(Status = GetOperandDataTypeByValue(iCorRealValue1, elemType1, valueData1, valueType1)) && SUCCEEDED(Status = GetOperandDataTypeByValue(iCorRealValue2, elemType2, valueData2, valueType2)) && SUCCEEDED(Status = Interop::CalculationDelegate(valueData1, valueType1, valueData2, valueType2, (int32_t)opType, resultType, &resultData, output))) { Status = GetValueByOperandDataType(resultData, (BasicTypes)resultType, &evalStack.front().iCorValue, ed); if (resultType == (int32_t)BasicTypes::TypeString) Interop::SysFreeString((BSTR)resultData); else Interop::CoTaskMemFree(resultData); } if (valueType1 == (int32_t)BasicTypes::TypeString && valueData1) Interop::SysFreeString((BSTR)valueData1); if (valueType2 == (int32_t)BasicTypes::TypeString && valueData2) Interop::SysFreeString((BSTR)valueData2); return Status; } HRESULT CalculateOneOparand(OperationType opType, std::list &evalStack, std::string &output, EvalData &ed) { HRESULT Status; ToRelease iCorValue; IfFailRet(GetFrontStackEntryValue(&iCorValue, nullptr, evalStack, ed, output)); evalStack.front().ResetEntry(EvalStackEntry::ResetLiteralStatus::No); ToRelease iCorRealValue; CorElementType elemType; IfFailRet(GetRealValueWithType(iCorValue, &iCorRealValue, &elemType)); if (elemType == ELEMENT_TYPE_VALUETYPE || elemType == ELEMENT_TYPE_CLASS) { static std::unordered_map> opMap{ {OperationType::LogicalNotExpression, {"op_LogicalNot", "!"}}, {OperationType::BitwiseNotExpression, {"op_OnesComplement", "~"}}, {OperationType::UnaryPlusExpression, {"op_UnaryPlus", "+"}}, {OperationType::UnaryMinusExpression, {"op_UnaryNegation", "-"}} }; auto findOpName = opMap.find(opType); if (findOpName == opMap.end()) return E_FAIL; if (SUCCEEDED(CallUnaryOperator(findOpName->second.first, iCorRealValue, &evalStack.front().iCorValue, ed))) return S_OK; else { std::string typeName; IfFailRet(TypePrinter::GetTypeOfValue(iCorRealValue, typeName)); output = "error CS0023: Operator '" + findOpName->second.second + "' cannot be applied to operand of type '" + typeName + "'"; return E_INVALIDARG; } } else if (!SupportedByCalculationDelegateType(elemType)) return E_INVALIDARG; int64_t valueDataHolder1 = 0; PVOID valueData1 = &valueDataHolder1; int32_t valueType1 = 0; // Note, we need fake second operand for delegate. int64_t fakeValueData2 = 0; PVOID resultData = NULL; int32_t resultType = 0; if (SUCCEEDED(Status = GetOperandDataTypeByValue(iCorRealValue, elemType, valueData1, valueType1)) && SUCCEEDED(Status = Interop::CalculationDelegate(valueData1, valueType1, &fakeValueData2, (int32_t)BasicTypes::TypeInt64, (int32_t)opType, resultType, &resultData, output))) { Status = GetValueByOperandDataType(resultData, (BasicTypes)resultType, &evalStack.front().iCorValue, ed); if (resultType == (int32_t)BasicTypes::TypeString) Interop::SysFreeString((BSTR)resultData); else Interop::CoTaskMemFree(resultData); } if (valueType1 == (int32_t)BasicTypes::TypeString && valueData1) Interop::SysFreeString((BSTR)valueData1); return Status; } HRESULT IdentifierName(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { std::string String = to_utf8(((FormatFS*)pArguments)->wString); ReplaceInternalNames(String, true); evalStack.emplace_front(); evalStack.front().identifiers.emplace_back(std::move(String)); evalStack.front().editable = true; return S_OK; } HRESULT GenericName(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { HRESULT Status; int32_t Int = ((FormatFIS*)pArguments)->Int; std::string String = to_utf8(((FormatFIS*)pArguments)->wString); std::vector> genericValues; std::string generics = ">"; genericValues.reserve(Int); for(int i = 0; i < Int; i++) { ToRelease icdv; ToRelease icdt; ToRelease icdv2; std::string genericType; Status = GetFrontStackEntryValue(&icdv, nullptr, evalStack, ed, output); if(Status == S_OK) { IfFailRet(icdv->QueryInterface(IID_ICorDebugValue2, (LPVOID *) &icdv2)); IfFailRet(icdv2->GetExactType(&icdt)); } else { IfFailRet(GetFrontStackEntryType(&icdt, evalStack, ed, output)); } TypePrinter::GetTypeOfValue(icdt, genericType); generics = "," + genericType + generics; genericValues.emplace_back(icdt.Detach()); evalStack.pop_front(); } generics.erase(0,1); String += "<" + generics; evalStack.emplace_front(); evalStack.front().identifiers.emplace_back(std::move(String)); evalStack.front().genericTypeCache = std::move(genericValues); evalStack.front().editable = true; return S_OK; } HRESULT InvocationExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { int32_t Int = ((FormatFI*)pArguments)->Int; if (Int < 0) return E_INVALIDARG; HRESULT Status; bool idsEmpty = false; bool isInstance = true; std::vector> iCorArgs(Int); for (int32_t i = Int - 1; i >= 0; i--) { IfFailRet(GetFrontStackEntryValue(&iCorArgs[i], nullptr, evalStack, ed, output)); evalStack.pop_front(); } if (evalStack.front().preventBinding) return S_OK; assert(evalStack.front().identifiers.size() > 0); // We must have at least method name (identifier). // TODO local defined function (compiler will create such function with name like `g__Calc2|0_0`) std::string funcNameGenerics = evalStack.front().identifiers.back(); evalStack.front().identifiers.pop_back(); std::string funcName; std::vector methodGenericStrings = EvalUtils::ParseGenericParams(funcNameGenerics, funcName); size_t pos = funcName.find('`'); if (pos != std::string::npos) funcName.resize(pos); if (!evalStack.front().iCorValue && evalStack.front().identifiers.empty()) { std::string methodClass; idsEmpty = true; IfFailRet(ed.pEvaluator->GetMethodClass(ed.pThread, ed.frameLevel, methodClass, isInstance)); if (isInstance) { evalStack.front().identifiers.emplace_back("this"); } else { // here we add a full qualified "path" separated with dots (aka Class.Subclass.Subclass ..etc) // although usually contains a vector of components of the full name qualification // Anyway, our added component will be correctly processed by Evaluator::ResolveIdentifiers() for // that case as it seals all the qualification components into one with dots before using them. evalStack.front().identifiers.emplace_back(methodClass); } } ToRelease iCorValue; ToRelease iCorType; IfFailRet(ed.pEvaluator->ResolveIdentifiers(ed.pThread, ed.frameLevel, evalStack.front().iCorValue, nullptr, evalStack.front().identifiers, &iCorValue, nullptr, &iCorType, ed.evalFlags)); bool searchStatic = false; if (iCorType) { searchStatic = true; } else { CorElementType elemType; IfFailRet(iCorValue->GetType(&elemType)); // Boxing built-in element type into value type in order to call methods. auto entry = ed.corElementToValueClassMap.find(elemType); if (entry != ed.corElementToValueClassMap.end()) { ULONG32 cbSize; IfFailRet(iCorValue->GetSize(&cbSize)); ArrayHolder elemValue = new (std::nothrow) BYTE[cbSize]; if (elemValue == nullptr) return E_OUTOFMEMORY; memset(elemValue.GetPtr(), 0, cbSize * sizeof(BYTE)); ToRelease pGenericValue; IfFailRet(iCorValue->QueryInterface(IID_ICorDebugGenericValue, (LPVOID*) &pGenericValue)); IfFailRet(pGenericValue->GetValue((LPVOID) &(elemValue[0]))); iCorValue.Free(); IfFailRet(CreateValueType(ed.pEvalWaiter, ed.pThread, entry->second, &iCorValue, elemValue.GetPtr())); } ToRelease iCorValue2; IfFailRet(iCorValue->QueryInterface(IID_ICorDebugValue2, (LPVOID *) &iCorValue2)); IfFailRet(iCorValue2->GetExactType(&iCorType)); } std::vector funcArgs(Int); for (int32_t i = 0; i < Int; ++i) { ToRelease iCorValueArg; IfFailRet(DereferenceAndUnboxValue(iCorArgs[i].GetPtr(), &iCorValueArg, nullptr)); IfFailRet(iCorValueArg->GetType(&funcArgs[i].corType)); if (funcArgs[i].corType == ELEMENT_TYPE_VALUETYPE || funcArgs[i].corType == ELEMENT_TYPE_CLASS) IfFailRet(TypePrinter::NameForTypeByValue(iCorValueArg, funcArgs[i].typeName)); else if (funcArgs[i].corType == ELEMENT_TYPE_SZARRAY || funcArgs[i].corType == ELEMENT_TYPE_ARRAY) IfFailRet(TypePrinter::GetTypeOfValue(iCorValueArg, funcArgs[i].typeName)); } std::vector methodGenerics; methodGenerics.reserve(methodGenericStrings.size()); for(ULONG32 i = 0; i < methodGenericStrings.size(); i++) { methodGenerics.emplace_back(ed.pEvaluator->GetElementTypeByTypeName(methodGenericStrings[i])); } ToRelease iCorFunc; ToRelease iCorResultType; ed.pEvaluator->WalkMethods(iCorType, &iCorResultType, methodGenerics, [&]( bool is_static, const std::string &methodName, Evaluator::ReturnElementType&, std::vector &methodArgs, Evaluator::GetFunctionCallback getFunction) { if ( (searchStatic && !is_static) || (!searchStatic && is_static && !idsEmpty) || funcArgs.size() != methodArgs.size() || funcName != methodName) return S_OK; for (size_t i = 0; i < funcArgs.size(); ++i) { if (funcArgs[i] != methodArgs[i]) return S_OK; } IfFailRet(getFunction(&iCorFunc)); isInstance = !is_static; return E_ABORT; // Fast exit from cycle. }); if (!iCorFunc) { if(SUCCEEDED(ed.pEvaluator->LookupExtensionMethods(iCorType, funcName, funcArgs, methodGenerics, &iCorFunc))) isInstance = true; // Extension methods always require "this" as their first parameter else return E_FAIL; } if(iCorResultType) iCorType = iCorResultType.Detach(); size_t typeArgsCount = evalStack.front().genericTypeCache.size(); ULONG32 realArgsCount = Int + (isInstance ? 1 : 0); std::vector iCorTypeArgs; std::vector iCorValueArgs; iCorValueArgs.reserve(realArgsCount); iCorTypeArgs.reserve(typeArgsCount); // Place instance value ("this") if extension or not static method if (isInstance) { iCorValueArgs.emplace_back(iCorValue.GetPtr()); } // Add arguments values for (int32_t i = 0; i < Int; i++) { iCorValueArgs.emplace_back(iCorArgs[i].GetPtr()); } // Collect type(class)'s generic types if any ToRelease pTypeEnum; if (SUCCEEDED(iCorType->EnumerateTypeParameters(&pTypeEnum))) { ICorDebugType *curType; ULONG fetched = 0; while (SUCCEEDED(pTypeEnum->Next(1, &curType, &fetched)) && fetched == 1) { iCorTypeArgs.emplace_back(curType); } } // Add method's generic types if any for (size_t i = typeArgsCount; i > 0; i--) { iCorTypeArgs.emplace_back(evalStack.front().genericTypeCache[i-1].GetPtr()); } evalStack.front().ResetEntry(); Status = ed.pEvalHelpers->EvalGenericFunction(ed.pThread, iCorFunc, iCorTypeArgs.data(), (ULONG32)iCorTypeArgs.size(), iCorValueArgs.data(), (ULONG32)iCorValueArgs.size(), &evalStack.front().iCorValue, ed.evalFlags); // CORDBG_S_FUNC_EVAL_HAS_NO_RESULT: Some Func evals will lack a return value, such as those whose return type is void. if (Status == CORDBG_S_FUNC_EVAL_HAS_NO_RESULT) // We can't create ELEMENT_TYPE_VOID, so, we are forced to use System.Void instead. IfFailRet(CreateValueType(ed.pEvalWaiter, ed.pThread, ed.iCorVoidClass, &evalStack.front().iCorValue, nullptr)); return Status; } HRESULT ObjectCreationExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { // TODO uint32_t Flags = ((FormatFI*)pArguments)->Flags; // TODO int32_t Int = ((FormatFI*)pArguments)->Int; return E_NOTIMPL; } HRESULT ElementAccessExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { int32_t Int = ((FormatFI*)pArguments)->Int; HRESULT Status; std::vector> indexvalues(Int); for (int32_t i = Int - 1; i >= 0; i--) { ToRelease iCorValue; IfFailRet(GetFrontStackEntryValue(&indexvalues[i], nullptr, evalStack, ed, output)); evalStack.pop_front(); } if (evalStack.front().preventBinding) return S_OK; ToRelease iCorObjectValue; std::unique_ptr setterData; IfFailRet(GetFrontStackEntryValue(&iCorObjectValue, &setterData, evalStack, ed, output)); ToRelease iCorRealValue; CorElementType elemType; IfFailRet(GetRealValueWithType(iCorObjectValue, &iCorRealValue, &elemType)); std::vector indexes; if (elemType == ELEMENT_TYPE_SZARRAY || elemType == ELEMENT_TYPE_ARRAY) { for (int32_t i = Int - 1; i >= 0; i--) { ULONG32 result_index = 0; // TODO implicitly convert iCorValue to int, if type not int // at this moment GetElementIndex() work with integer types only IfFailRet(GetElementIndex(indexvalues[i], result_index)); indexes.insert(indexes.begin(), result_index); } evalStack.front().iCorValue.Free(); evalStack.front().identifiers.clear(); evalStack.front().setterData = std::move(setterData); Status = ed.pEvaluator->GetElement(iCorObjectValue, indexes, &evalStack.front().iCorValue); } else { std::vector funcArgs(Int); for (int32_t i = 0; i < Int; ++i) { ToRelease iCorValueArg; IfFailRet(DereferenceAndUnboxValue(indexvalues[i].GetPtr(), &iCorValueArg, nullptr)); IfFailRet(iCorValueArg->GetType(&funcArgs[i].corType)); if (funcArgs[i].corType == ELEMENT_TYPE_VALUETYPE || funcArgs[i].corType == ELEMENT_TYPE_CLASS) IfFailRet(TypePrinter::NameForTypeByValue(iCorValueArg, funcArgs[i].typeName)); } ToRelease iCorFunc; ed.pEvaluator->WalkMethods(iCorObjectValue, [&]( bool, const std::string &methodName, Evaluator::ReturnElementType& retType, std::vector &methodArgs, Evaluator::GetFunctionCallback getFunction) { std::string name = "get_Item"; std::size_t found = methodName.rfind(name); if (retType.corType == ELEMENT_TYPE_VOID || found == std::string::npos || found != methodName.length() - name.length() || funcArgs.size() != methodArgs.size()) return S_OK; // Return with success to continue walk. for (size_t i = 0; i < funcArgs.size(); ++i) { if (funcArgs[i].corType != methodArgs[i].corType || funcArgs[i].typeName != methodArgs[i].typeName) return S_OK; } IfFailRet(getFunction(&iCorFunc)); return E_ABORT; // Fast exit from cycle, since we already found iCorFunc. }); if (!iCorFunc) return E_INVALIDARG; evalStack.front().ResetEntry(); std::vector iCorValueArgs; iCorValueArgs.reserve(Int+1); iCorValueArgs.emplace_back(iCorObjectValue.GetPtr()); for (int32_t i = 0; i < Int; i++) { iCorValueArgs.emplace_back(indexvalues[i].GetPtr()); } ToRelease iCorValue2; IfFailRet(iCorObjectValue->QueryInterface(IID_ICorDebugValue2, (LPVOID *) &iCorValue2)); ToRelease iCorType; IfFailRet(iCorValue2->GetExactType(&iCorType)); Status = ed.pEvalHelpers->EvalFunction(ed.pThread, iCorFunc, iCorType.GetRef(), 1, iCorValueArgs.data(), Int + 1, &evalStack.front().iCorValue, ed.evalFlags); } return Status; } HRESULT ElementBindingExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { int32_t Int = ((FormatFI*)pArguments)->Int; HRESULT Status; std::vector> indexvalues(Int); for (int32_t i = Int - 1; i >= 0; i--) { ToRelease iCorValue; IfFailRet(GetFrontStackEntryValue(&indexvalues[i], nullptr, evalStack, ed, output)); evalStack.pop_front(); } if (evalStack.front().preventBinding) return S_OK; ToRelease iCorObjectValue; std::unique_ptr setterData; IfFailRet(GetFrontStackEntryValue(&iCorObjectValue, &setterData, evalStack, ed, output)); ToRelease pReferenceValue; IfFailRet(iCorObjectValue->QueryInterface(IID_ICorDebugReferenceValue, (LPVOID*) &pReferenceValue)); BOOL isNull = FALSE; IfFailRet(pReferenceValue->IsNull(&isNull)); if (isNull == TRUE) { evalStack.front().preventBinding = true; return S_OK; } ToRelease iCorRealValue; CorElementType elemType; IfFailRet(GetRealValueWithType(iCorObjectValue, &iCorRealValue, &elemType)); std::vector indexes; if (elemType == ELEMENT_TYPE_SZARRAY || elemType == ELEMENT_TYPE_ARRAY) { for (int32_t i = Int - 1; i >= 0; i--) { ULONG32 result_index = 0; // TODO implicitly convert iCorValue to int, if type not int // at this moment GetElementIndex() work with integer types only IfFailRet(GetElementIndex(indexvalues[i], result_index)); indexes.insert(indexes.begin(), result_index); } evalStack.front().iCorValue.Free(); evalStack.front().identifiers.clear(); evalStack.front().setterData = std::move(setterData); Status = ed.pEvaluator->GetElement(iCorObjectValue, indexes, &evalStack.front().iCorValue); } else { std::vector funcArgs(Int); for (int32_t i = 0; i < Int; ++i) { ToRelease iCorValueArg; IfFailRet(DereferenceAndUnboxValue(indexvalues[i].GetPtr(), &iCorValueArg, nullptr)); IfFailRet(iCorValueArg->GetType(&funcArgs[i].corType)); if (funcArgs[i].corType == ELEMENT_TYPE_VALUETYPE || funcArgs[i].corType == ELEMENT_TYPE_CLASS) IfFailRet(TypePrinter::NameForTypeByValue(iCorValueArg, funcArgs[i].typeName)); } ToRelease iCorFunc; ed.pEvaluator->WalkMethods(iCorObjectValue, [&]( bool, const std::string &methodName, Evaluator::ReturnElementType& retType, std::vector &methodArgs, Evaluator::GetFunctionCallback getFunction) { std::string name = "get_Item"; std::size_t found = methodName.rfind(name); if (retType.corType == ELEMENT_TYPE_VOID || found == std::string::npos || found != methodName.length() - name.length() || funcArgs.size() != methodArgs.size()) return S_OK; // Return with success to continue walk. for (size_t i = 0; i < funcArgs.size(); ++i) { if (funcArgs[i].corType != methodArgs[i].corType || funcArgs[i].typeName != methodArgs[i].typeName) return S_OK; } IfFailRet(getFunction(&iCorFunc)); return E_ABORT; // Fast exit from cycle, since we already found iCorFunc. }); if (!iCorFunc) return E_INVALIDARG; evalStack.front().ResetEntry(); std::vector iCorValueArgs; iCorValueArgs.reserve(Int+1); iCorValueArgs.emplace_back(iCorObjectValue.GetPtr()); for (int32_t i = 0; i < Int; i++) { iCorValueArgs.emplace_back(indexvalues[i].GetPtr()); } ToRelease iCorValue2; IfFailRet(iCorObjectValue->QueryInterface(IID_ICorDebugValue2, (LPVOID *) &iCorValue2)); ToRelease iCorType; IfFailRet(iCorValue2->GetExactType(&iCorType)); Status = ed.pEvalHelpers->EvalFunction(ed.pThread, iCorFunc, iCorType.GetRef(), 1, iCorValueArgs.data(), Int + 1, &evalStack.front().iCorValue, ed.evalFlags); } return Status; } HRESULT NumericLiteralExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { int32_t Int = ((FormatFIP*)pArguments)->Int; PVOID Ptr = ((FormatFIP*)pArguments)->Ptr; // StackMachine type to CorElementType map. static const CorElementType BasicTypesAlias[] { ELEMENT_TYPE_MAX, // Boolean - TrueLiteralExpression or FalseLiteralExpression ELEMENT_TYPE_MAX, // Byte - no literal suffix for byte ELEMENT_TYPE_MAX, // Char - CharacterLiteralExpression ELEMENT_TYPE_VALUETYPE, // Decimal ELEMENT_TYPE_R8, ELEMENT_TYPE_R4, ELEMENT_TYPE_I4, ELEMENT_TYPE_I8, ELEMENT_TYPE_MAX, // Object ELEMENT_TYPE_MAX, // SByte - no literal suffix for sbyte ELEMENT_TYPE_MAX, // Short - no literal suffix for short ELEMENT_TYPE_MAX, // String - StringLiteralExpression ELEMENT_TYPE_MAX, // UShort - no literal suffix for ushort ELEMENT_TYPE_U4, ELEMENT_TYPE_U8 }; evalStack.emplace_front(); evalStack.front().literal = true; if (BasicTypesAlias[Int] == ELEMENT_TYPE_VALUETYPE) return CreateValueType(ed.pEvalWaiter, ed.pThread, ed.iCorDecimalClass, &evalStack.front().iCorValue, Ptr); else return CreatePrimitiveValue(ed.pThread, &evalStack.front().iCorValue, BasicTypesAlias[Int], Ptr); } HRESULT StringLiteralExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { std::string String = to_utf8(((FormatFS*)pArguments)->wString); ReplaceInternalNames(String, true); evalStack.emplace_front(); evalStack.front().literal = true; return ed.pEvalHelpers->CreateString(ed.pThread, String, &evalStack.front().iCorValue); } HRESULT CharacterLiteralExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { PVOID Ptr = ((FormatFIP*)pArguments)->Ptr; evalStack.emplace_front(); evalStack.front().literal = true; return CreatePrimitiveValue(ed.pThread, &evalStack.front().iCorValue, ELEMENT_TYPE_CHAR, Ptr); } HRESULT PredefinedType(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { static const CorElementType BasicTypesAlias[] { ELEMENT_TYPE_BOOLEAN, // Boolean ELEMENT_TYPE_U1, // Byte ELEMENT_TYPE_CHAR, // Char ELEMENT_TYPE_VALUETYPE, // Decimal ELEMENT_TYPE_R8, // Double ELEMENT_TYPE_R4, // Float ELEMENT_TYPE_I4, // Int ELEMENT_TYPE_I8, // Long ELEMENT_TYPE_MAX, // Object ELEMENT_TYPE_I1, // SByte ELEMENT_TYPE_I2, // Short ELEMENT_TYPE_STRING, // String ELEMENT_TYPE_U2, // UShort ELEMENT_TYPE_U4, // UInt ELEMENT_TYPE_U8 // ULong }; // TODO uint32_t Flags = ((FormatFI*)pArguments)->Flags; int32_t Int = ((FormatFI*)pArguments)->Int; std::string String; evalStack.emplace_front(); if (BasicTypesAlias[Int] == ELEMENT_TYPE_VALUETYPE) return CreateValueType(ed.pEvalWaiter, ed.pThread, ed.iCorDecimalClass, &evalStack.front().iCorValue, nullptr); else if (BasicTypesAlias[Int] == ELEMENT_TYPE_STRING) return ed.pEvalHelpers->CreateString(ed.pThread, String, &evalStack.front().iCorValue); else return CreatePrimitiveValue(ed.pThread, &evalStack.front().iCorValue, BasicTypesAlias[Int], nullptr); } HRESULT AliasQualifiedName(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { // TODO uint32_t Flags = ((FormatF*)pArguments)->Flags; return E_NOTIMPL; } HRESULT MemberBindingExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { assert(evalStack.size() > 1); assert(evalStack.front().identifiers.size() == 1); // Only one unresolved identifier must be here. assert(!evalStack.front().iCorValue); // Should be unresolved identifier only front element. std::string identifier = std::move(evalStack.front().identifiers[0]); evalStack.pop_front(); if (evalStack.front().preventBinding) return S_OK; HRESULT Status; ToRelease iCorValue; std::unique_ptr setterData; IfFailRet(GetFrontStackEntryValue(&iCorValue, &setterData, evalStack, ed, output)); evalStack.front().iCorValue = iCorValue.Detach(); evalStack.front().identifiers.clear(); evalStack.front().setterData = std::move(setterData); ToRelease pReferenceValue; IfFailRet(evalStack.front().iCorValue->QueryInterface(IID_ICorDebugReferenceValue, (LPVOID*) &pReferenceValue)); BOOL isNull = FALSE; IfFailRet(pReferenceValue->IsNull(&isNull)); if (isNull == TRUE) evalStack.front().preventBinding = true; else evalStack.front().identifiers.emplace_back(std::move(identifier)); return S_OK; } HRESULT ConditionalExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { // TODO uint32_t Flags = ((FormatF*)pArguments)->Flags; return E_NOTIMPL; } HRESULT SimpleMemberAccessExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { assert(evalStack.size() > 1); assert(!evalStack.front().iCorValue); // Should be unresolved identifier only front element. assert(evalStack.front().identifiers.size() == 1); // Only one unresolved identifier must be here. std::string identifier = std::move(evalStack.front().identifiers[0]); std::vector> iCorDebugTypes; size_t genericsCount = evalStack.front().genericTypeCache.size(); if (genericsCount > 0) { iCorDebugTypes = std::move(evalStack.front().genericTypeCache); } evalStack.pop_front(); if (!evalStack.front().preventBinding) { evalStack.front().identifiers.emplace_back(std::move(identifier)); evalStack.front().genericTypeCache.clear(); // We need method's generics only, so remove all previous if exist. if (genericsCount > 0) { evalStack.front().genericTypeCache = std::move(iCorDebugTypes); } } return S_OK; } HRESULT QualifiedName(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { return SimpleMemberAccessExpression(evalStack, pArguments, output, ed); } HRESULT PointerMemberAccessExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { // TODO uint32_t Flags = ((FormatF*)pArguments)->Flags; return E_NOTIMPL; } HRESULT CastExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { // TODO uint32_t Flags = ((FormatF*)pArguments)->Flags; return E_NOTIMPL; } HRESULT AsExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { // TODO uint32_t Flags = ((FormatF*)pArguments)->Flags; return E_NOTIMPL; } HRESULT AddExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { return CalculateTwoOparands(OperationType::AddExpression, evalStack, output, ed); } HRESULT MultiplyExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { return CalculateTwoOparands(OperationType::MultiplyExpression, evalStack, output, ed); } HRESULT SubtractExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { return CalculateTwoOparands(OperationType::SubtractExpression, evalStack, output, ed); } HRESULT DivideExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { return CalculateTwoOparands(OperationType::DivideExpression, evalStack, output, ed); } HRESULT ModuloExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { return CalculateTwoOparands(OperationType::ModuloExpression, evalStack, output, ed); } HRESULT LeftShiftExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { return CalculateTwoOparands(OperationType::LeftShiftExpression, evalStack, output, ed); } HRESULT RightShiftExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { return CalculateTwoOparands(OperationType::RightShiftExpression, evalStack, output, ed); } HRESULT BitwiseAndExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { return CalculateTwoOparands(OperationType::BitwiseAndExpression, evalStack, output, ed); } HRESULT BitwiseOrExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { return CalculateTwoOparands(OperationType::BitwiseOrExpression, evalStack, output, ed); } HRESULT ExclusiveOrExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { return CalculateTwoOparands(OperationType::ExclusiveOrExpression, evalStack, output, ed); } HRESULT LogicalAndExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { return CalculateTwoOparands(OperationType::LogicalAndExpression, evalStack, output, ed); } HRESULT LogicalOrExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { return CalculateTwoOparands(OperationType::LogicalOrExpression, evalStack, output, ed); } HRESULT EqualsExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { return CalculateTwoOparands(OperationType::EqualsExpression, evalStack, output, ed); } HRESULT NotEqualsExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { return CalculateTwoOparands(OperationType::NotEqualsExpression, evalStack, output, ed); } HRESULT GreaterThanExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { return CalculateTwoOparands(OperationType::GreaterThanExpression, evalStack, output, ed); } HRESULT LessThanExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { return CalculateTwoOparands(OperationType::LessThanExpression, evalStack, output, ed); } HRESULT GreaterThanOrEqualExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { return CalculateTwoOparands(OperationType::GreaterThanOrEqualExpression, evalStack, output, ed); } HRESULT LessThanOrEqualExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { return CalculateTwoOparands(OperationType::LessThanOrEqualExpression, evalStack, output, ed); } HRESULT IsExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { // TODO uint32_t Flags = ((FormatF*)pArguments)->Flags; return E_NOTIMPL; } HRESULT UnaryPlusExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { return CalculateOneOparand(OperationType::UnaryPlusExpression, evalStack, output, ed); } HRESULT UnaryMinusExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { return CalculateOneOparand(OperationType::UnaryMinusExpression, evalStack, output, ed); } HRESULT LogicalNotExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { return CalculateOneOparand(OperationType::LogicalNotExpression, evalStack, output, ed); } HRESULT BitwiseNotExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { return CalculateOneOparand(OperationType::BitwiseNotExpression, evalStack, output, ed); } HRESULT TrueLiteralExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { evalStack.emplace_front(); evalStack.front().literal = true; return CreateBooleanValue(ed.pThread, &evalStack.front().iCorValue, true); } HRESULT FalseLiteralExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { evalStack.emplace_front(); evalStack.front().literal = true; return CreateBooleanValue(ed.pThread, &evalStack.front().iCorValue, false); } HRESULT NullLiteralExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { evalStack.emplace_front(); evalStack.front().literal = true; return CreateNullValue(ed.pThread, &evalStack.front().iCorValue); } HRESULT PreIncrementExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { // TODO uint32_t Flags = ((FormatF*)pArguments)->Flags; return E_NOTIMPL; } HRESULT PostIncrementExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { // TODO uint32_t Flags = ((FormatF*)pArguments)->Flags; return E_NOTIMPL; } HRESULT PreDecrementExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { // TODO uint32_t Flags = ((FormatF*)pArguments)->Flags; return E_NOTIMPL; } HRESULT PostDecrementExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { // TODO uint32_t Flags = ((FormatF*)pArguments)->Flags; return E_NOTIMPL; } HRESULT SizeOfExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { assert(evalStack.size() > 0); HRESULT Status; uint32_t size = 0; PVOID szPtr = &size; if (evalStack.front().iCorValue) { // predefined type CorElementType elType; IfFailRet(evalStack.front().iCorValue->GetType(&elType)); if(elType == ELEMENT_TYPE_CLASS) { ToRelease iCorValue; IfFailRet(DereferenceAndUnboxValue(evalStack.front().iCorValue, &iCorValue, nullptr)); IfFailRet(iCorValue->GetSize(&size)); } else { IfFailRet(evalStack.front().iCorValue->GetSize(&size)); } } else { ToRelease iCorType; ToRelease iCorValueRef, iCorValue; IfFailRet(GetFrontStackEntryType(&iCorType, evalStack, ed, output)); if(iCorType) { CorElementType elType; IfFailRet(iCorType->GetType(&elType)); if (elType == ELEMENT_TYPE_VALUETYPE) { // user defined type (structure) ToRelease iCorClass; IfFailRet(iCorType->GetClass(&iCorClass)); IfFailRet(CreateValueType(ed.pEvalWaiter, ed.pThread, iCorClass, &iCorValueRef, nullptr)); IfFailRet(DereferenceAndUnboxValue(iCorValueRef, &iCorValue, nullptr)); IfFailRet(iCorValue->GetSize(&size)); } else { return E_INVALIDARG; } } else { // TODO other cases return E_NOTIMPL; } } evalStack.front().ResetEntry(); return CreatePrimitiveValue(ed.pThread, &evalStack.front().iCorValue, ELEMENT_TYPE_U4, szPtr); } HRESULT TypeOfExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { // TODO uint32_t Flags = ((FormatF*)pArguments)->Flags; return E_NOTIMPL; } HRESULT CoalesceExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { HRESULT Status; ToRelease iCorRealValueRightOp; ToRelease iCorRightOpValue; CorElementType elemTypeRightOp; IfFailRet(GetFrontStackEntryValue(&iCorRightOpValue, nullptr, evalStack, ed, output)); IfFailRet(GetRealValueWithType(iCorRightOpValue, &iCorRealValueRightOp, &elemTypeRightOp)); auto rightOperand = std::move(evalStack.front()); evalStack.pop_front(); ToRelease iCorRealValueLeftOp; ToRelease iCorLeftOpValue; CorElementType elemTypeLeftOp; IfFailRet(GetFrontStackEntryValue(&iCorLeftOpValue, nullptr, evalStack, ed, output)); IfFailRet(GetRealValueWithType(iCorLeftOpValue, &iCorRealValueLeftOp, &elemTypeLeftOp)); std::string typeNameLeft; std::string typeNameRigth; //TODO add implementation for object type ?? other if((elemTypeRightOp == ELEMENT_TYPE_STRING && elemTypeLeftOp == ELEMENT_TYPE_STRING) || ((elemTypeRightOp == ELEMENT_TYPE_CLASS && elemTypeLeftOp == ELEMENT_TYPE_CLASS) && SUCCEEDED(TypePrinter::NameForTypeByValue(iCorRealValueLeftOp, typeNameLeft)) && SUCCEEDED(TypePrinter::NameForTypeByValue(iCorRealValueRightOp, typeNameRigth)) && typeNameLeft == typeNameRigth)) { ToRelease pRefValue; IfFailRet(iCorLeftOpValue->QueryInterface(IID_ICorDebugReferenceValue, (LPVOID*) &pRefValue)); BOOL isNull = FALSE; IfFailRet(pRefValue->IsNull(&isNull)); if (isNull == TRUE) { evalStack.pop_front(); evalStack.push_front(std::move(rightOperand)); } return S_OK; } //TODO add proccesing for parent-child class relationship std::string typeName1; std::string typeName2; IfFailRet(TypePrinter::GetTypeOfValue(iCorRealValueLeftOp, typeName1)); IfFailRet(TypePrinter::GetTypeOfValue(iCorRealValueRightOp, typeName2)); output = "error CS0019: Operator ?? cannot be applied to operands of type '" + typeName1 + "' and '" + typeName2 + "'"; return E_INVALIDARG; } HRESULT ThisExpression(std::list &evalStack, PVOID pArguments, std::string &output, EvalData &ed) { evalStack.emplace_front(); evalStack.front().identifiers.emplace_back("this"); evalStack.front().editable = true; return S_OK; } } // unnamed namespace HRESULT EvalStackMachine::Run(ICorDebugThread *pThread, FrameLevel frameLevel, int evalFlags, const std::string &expression, std::list &evalStack, std::string &output) { static const std::vector&, PVOID, std::string&, EvalData&)>> CommandImplementation = { IdentifierName, GenericName, InvocationExpression, ObjectCreationExpression, ElementAccessExpression, ElementBindingExpression, NumericLiteralExpression, StringLiteralExpression, CharacterLiteralExpression, PredefinedType, QualifiedName, AliasQualifiedName, MemberBindingExpression, ConditionalExpression, SimpleMemberAccessExpression, PointerMemberAccessExpression, CastExpression, AsExpression, AddExpression, MultiplyExpression, SubtractExpression, DivideExpression, ModuloExpression, LeftShiftExpression, RightShiftExpression, BitwiseAndExpression, BitwiseOrExpression, ExclusiveOrExpression, LogicalAndExpression, LogicalOrExpression, EqualsExpression, NotEqualsExpression, GreaterThanExpression, LessThanExpression, GreaterThanOrEqualExpression, LessThanOrEqualExpression, IsExpression, UnaryPlusExpression, UnaryMinusExpression, LogicalNotExpression, BitwiseNotExpression, TrueLiteralExpression, FalseLiteralExpression, NullLiteralExpression, PreIncrementExpression, PostIncrementExpression, PreDecrementExpression, PostDecrementExpression, SizeOfExpression, TypeOfExpression, CoalesceExpression, ThisExpression }; // Note, internal variables start with "$" and must be replaced before CSharp syntax analyzer. // This data will be restored after CSharp syntax analyzer in IdentifierName and StringLiteralExpression. std::string fixed_expression = expression; ReplaceInternalNames(fixed_expression); HRESULT Status; PVOID pStackProgram = nullptr; IfFailRet(Interop::GenerateStackMachineProgram(fixed_expression, &pStackProgram, output)); static constexpr int32_t ProgramFinished = -1; int32_t Command; PVOID pArguments; m_evalData.pThread = pThread; m_evalData.frameLevel = frameLevel; m_evalData.evalFlags = evalFlags; do { if (FAILED(Status = Interop::NextStackCommand(pStackProgram, Command, pArguments, output)) || Command == ProgramFinished || FAILED(Status = CommandImplementation[Command](evalStack, pArguments, output, m_evalData))) break; } while (1); switch (Status) { case CORDBG_E_ILLEGAL_IN_PROLOG: case CORDBG_E_ILLEGAL_IN_NATIVE_CODE: case CORDBG_E_ILLEGAL_IN_STACK_OVERFLOW: case CORDBG_E_ILLEGAL_IN_OPTIMIZED_CODE: case CORDBG_E_ILLEGAL_AT_GC_UNSAFE_POINT: output = "This expression causes side effects and will not be evaluated. "; output += errormessage(Status); LOGE("Eval error: %#x %s\n", Status, errormessage(Status)); break; case COR_E_TIMEOUT: output = "Evaluation timed out."; break; case COR_E_OPERATIONCANCELED: output = "Evaluation canceled by user."; break; case CORDBG_E_CANT_CALL_ON_THIS_THREAD: output = "The function evaluation requires all threads to run."; break; case E_UNEXPECTED: output = "Evaluation timed out, but function evaluation can't be completed or aborted. Debuggee have inconsistent state now."; break; case COR_E_THREADSTATE: output = "Thread is in an invalid state for this operation."; default: break; } Interop::ReleaseStackMachineProgram(pStackProgram); return Status; } HRESULT EvalStackMachine::EvaluateExpression(ICorDebugThread *pThread, FrameLevel frameLevel, int evalFlags, const std::string &expression, ICorDebugValue **ppResultValue, std::string &output, bool *editable, std::unique_ptr *resultSetterData) { HRESULT Status; std::list evalStack; IfFailRet(Run(pThread, frameLevel, evalFlags, expression, evalStack, output)); assert(evalStack.size() == 1); std::unique_ptr setterData; IfFailRet(GetFrontStackEntryValue(ppResultValue, &setterData, evalStack, m_evalData, output)); if (editable) *editable = setterData.get() && !setterData.get()->setterFunction ? false /*property don't have setter*/ : evalStack.front().editable; if (resultSetterData) *resultSetterData = std::move(setterData); return S_OK; } HRESULT EvalStackMachine::SetValueByExpression(ICorDebugThread *pThread, FrameLevel frameLevel, int evalFlags, ICorDebugValue *pValue, const std::string &expression, std::string &output) { HRESULT Status; std::list evalStack; IfFailRet(Run(pThread, frameLevel, evalFlags, expression, evalStack, output)); assert(evalStack.size() == 1); ToRelease iCorValue; IfFailRet(GetFrontStackEntryValue(&iCorValue, nullptr, evalStack, m_evalData, output)); return ImplicitCast(iCorValue, pValue, evalStack.front().literal, m_evalData); } HRESULT EvalStackMachine::FindPredefinedTypes(ICorDebugModule *pModule) { HRESULT Status; ToRelease pMDUnknown; IfFailRet(pModule->GetMetaDataInterface(IID_IMetaDataImport, &pMDUnknown)); ToRelease pMD; IfFailRet(pMDUnknown->QueryInterface(IID_IMetaDataImport, (LPVOID*) &pMD)); mdTypeDef typeDef = mdTypeDefNil; static const WCHAR strTypeDefDecimal[] = W("System.Decimal"); IfFailRet(pMD->FindTypeDefByName(strTypeDefDecimal, NULL, &typeDef)); IfFailRet(pModule->GetClassFromToken(typeDef, &m_evalData.iCorDecimalClass)); typeDef = mdTypeDefNil; static const WCHAR strTypeDefVoid[] = W("System.Void"); IfFailRet(pMD->FindTypeDefByName(strTypeDefVoid, NULL, &typeDef)); IfFailRet(pModule->GetClassFromToken(typeDef, &m_evalData.iCorVoidClass)); static const std::vector> corElementToValueNameMap{ {ELEMENT_TYPE_BOOLEAN, W("System.Boolean")}, {ELEMENT_TYPE_CHAR, W("System.Char")}, {ELEMENT_TYPE_I1, W("System.SByte")}, {ELEMENT_TYPE_U1, W("System.Byte")}, {ELEMENT_TYPE_I2, W("System.Int16")}, {ELEMENT_TYPE_U2, W("System.UInt16")}, {ELEMENT_TYPE_I4, W("System.Int32")}, {ELEMENT_TYPE_U4, W("System.UInt32")}, {ELEMENT_TYPE_I8, W("System.Int64")}, {ELEMENT_TYPE_U8, W("System.UInt64")}, {ELEMENT_TYPE_R4, W("System.Single")}, {ELEMENT_TYPE_R8, W("System.Double")} }; for (auto &entry : corElementToValueNameMap) { typeDef = mdTypeDefNil; IfFailRet(pMD->FindTypeDefByName(entry.second, NULL, &typeDef)); IfFailRet(pModule->GetClassFromToken(typeDef, &m_evalData.corElementToValueClassMap[entry.first])); } return S_OK; } } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/evalstackmachine.h000066400000000000000000000124711457701673000222560ustar00rootroot00000000000000// Copyright (c) 2021 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #pragma once #include "cor.h" #include "cordebug.h" #include #include #include #include #include #include "interfaces/types.h" #include "utils/torelease.h" #include "debugger/evaluator.h" namespace netcoredbg { class EvalHelpers; class EvalWaiter; struct EvalStackEntry { enum class ResetLiteralStatus { No = 0, Yes = 1 }; // Unresolved identifiers. // Note, in case we already have some resolved identifiers (iCorValue), unresolved identifiers must be resolved within iCorValue. std::vector identifiers; // Resolved to value identifiers. ToRelease iCorValue; // Generic types cache. Note, finally we need the method's generic types only, i.e. the last element of // identifiers vector. The other type(class)'s generics can easily be got from the corresponding iCorDebugType std::vector> genericTypeCache; // Prevent future binding in case of conditional access with nulled object (`a?.b`, `a?[1]`, ...). // Note, this state could be related to iCorValue only (iCorValue must be checked for null first). bool preventBinding; // This is literal entry (value was created from literal). bool literal; // This entry is real variable (not literal, not result of expression calculation, not result of function call, ...). bool editable; // In case iCorValue is editable and property, we need extra data in order to set value. // Note, this data directly connected with `iCorValue` and could be available only in case `editable` is true. std::unique_ptr setterData; EvalStackEntry() : preventBinding(false), literal(false), editable(false) {} void ResetEntry(ResetLiteralStatus resetLiteral = ResetLiteralStatus::Yes) { identifiers.clear(); iCorValue.Free(); genericTypeCache.clear(); preventBinding = false; if (resetLiteral == ResetLiteralStatus::Yes) literal = false; editable = false; setterData.reset(); } }; struct EvalData { ICorDebugThread *pThread; Evaluator *pEvaluator; EvalHelpers *pEvalHelpers; EvalWaiter *pEvalWaiter; // In case of NumericLiteralExpression with Decimal, NewParameterizedObjectNoConstructor() are used. // Proper ICorDebugClass must be provided for Decimal (will be found during FindPredefinedTypes() call). ToRelease iCorDecimalClass; // In case eval return void, we are forced to create System.Void value. ToRelease iCorVoidClass; std::unordered_map> corElementToValueClassMap; FrameLevel frameLevel; int evalFlags; EvalData() : pThread(nullptr), pEvaluator(nullptr), pEvalHelpers(nullptr), pEvalWaiter(nullptr), evalFlags(defaultEvalFlags) {} }; class EvalStackMachine { std::shared_ptr m_sharedEvaluator; std::shared_ptr m_sharedEvalHelpers; std::shared_ptr m_sharedEvalWaiter; EvalData m_evalData; // Run stack machine for particular expression. HRESULT Run(ICorDebugThread *pThread, FrameLevel frameLevel, int evalFlags, const std::string &expression, std::list &evalStack, std::string &output); public: void SetupEval(std::shared_ptr &sharedEvaluator, std::shared_ptr &sharedEvalHelpers, std::shared_ptr &sharedEvalWaiter) { m_sharedEvaluator = sharedEvaluator; m_sharedEvalHelpers = sharedEvalHelpers; m_sharedEvalWaiter = sharedEvalWaiter; m_evalData.pEvaluator = m_sharedEvaluator.get(); m_evalData.pEvalHelpers = m_sharedEvalHelpers.get(); m_evalData.pEvalWaiter = m_sharedEvalWaiter.get(); } void ResetEval() { m_sharedEvaluator.reset(); m_sharedEvalHelpers.reset(); m_sharedEvalWaiter.reset(); m_evalData.pEvaluator = nullptr; m_evalData.pEvalHelpers = nullptr; m_evalData.pEvalWaiter = nullptr; } // Evaluate expression. Optional, return `editable` state and in case result is property - setter related information. HRESULT EvaluateExpression(ICorDebugThread *pThread, FrameLevel frameLevel, int evalFlags, const std::string &expression, ICorDebugValue **ppResultValue, std::string &output, bool *editable = nullptr, std::unique_ptr *resultSetterData = nullptr); // Set value in pValue by expression with implicitly cast expression result to pValue type, if need. HRESULT SetValueByExpression(ICorDebugThread *pThread, FrameLevel frameLevel, int evalFlags, ICorDebugValue *pValue, const std::string &expression, std::string &output); // Find ICorDebugClass objects for all predefined types we need for stack machine during Private.CoreLib load. // See ManagedCallback::LoadModule(). HRESULT FindPredefinedTypes(ICorDebugModule *pModule); }; } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/evaluator.cpp000066400000000000000000002352171457701673000213160ustar00rootroot00000000000000// Copyright (c) 2020 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #include #include #include #include #include "debugger/evalhelpers.h" #include "debugger/evalutils.h" #include "debugger/evaluator.h" #include "debugger/evalstackmachine.h" #include "debugger/frames.h" #include "utils/utf.h" #include "metadata/modules.h" #include "metadata/typeprinter.h" #include "metadata/attributes.h" #include "valueprint.h" #include "managed/interop.h" namespace netcoredbg { bool Evaluator::ArgElementType::isAlias(const CorElementType type1, const CorElementType type2, const std::string& name2) { static const std::unordered_map aliases = { {ELEMENT_TYPE_BOOLEAN, {ELEMENT_TYPE_VALUETYPE, "System.Boolean"}}, {ELEMENT_TYPE_CHAR, {ELEMENT_TYPE_VALUETYPE, "System.Char"}}, {ELEMENT_TYPE_I1, {ELEMENT_TYPE_VALUETYPE, "System.Byte"}}, {ELEMENT_TYPE_U1, {ELEMENT_TYPE_VALUETYPE, "System.SByte"}}, {ELEMENT_TYPE_R8, {ELEMENT_TYPE_VALUETYPE, "System.Double"}}, {ELEMENT_TYPE_R4, {ELEMENT_TYPE_VALUETYPE, "System.Single"}}, {ELEMENT_TYPE_I4, {ELEMENT_TYPE_VALUETYPE, "System.Int32"}}, {ELEMENT_TYPE_U4, {ELEMENT_TYPE_VALUETYPE, "System.UInt32"}}, {ELEMENT_TYPE_I8, {ELEMENT_TYPE_VALUETYPE, "System.Int64"}}, {ELEMENT_TYPE_U8, {ELEMENT_TYPE_VALUETYPE, "System.UInt64"}}, {ELEMENT_TYPE_OBJECT, {ELEMENT_TYPE_CLASS, "System.Object"}}, {ELEMENT_TYPE_I2, {ELEMENT_TYPE_VALUETYPE, "System.Int16"}}, {ELEMENT_TYPE_U2, {ELEMENT_TYPE_VALUETYPE, "System.UInt16"}}, {ELEMENT_TYPE_STRING, {ELEMENT_TYPE_CLASS, "System.String"}} }; auto found = aliases.find(type1); if (found != aliases.end()) { if (found->second.corType == type2 && found->second.typeName == name2) return true; } return false; } bool Evaluator::ArgElementType::areEqual(const ArgElementType& arg) { if (corType == arg.corType && typeName == arg.typeName) return true; if (isAlias(corType, arg.corType, arg.typeName)) return true; if (isAlias(arg.corType, corType, typeName)) return true; return false; } Evaluator::ArgElementType Evaluator::GetElementTypeByTypeName(const std::string typeName) { static const std::unordered_map stypes = { {"void", {ELEMENT_TYPE_VALUETYPE, "System.Void"}}, {"bool", {ELEMENT_TYPE_VALUETYPE, "System.Boolean"}}, {"byte", {ELEMENT_TYPE_VALUETYPE, "System.Byte"}}, {"sbyte", {ELEMENT_TYPE_VALUETYPE, "System.SByte"}}, {"char", {ELEMENT_TYPE_VALUETYPE, "System.Char"}}, {"decimal", {ELEMENT_TYPE_VALUETYPE, "System.Decimal"}}, {"double", {ELEMENT_TYPE_VALUETYPE, "System.Double"}}, {"float", {ELEMENT_TYPE_VALUETYPE, "System.Single"}}, {"int", {ELEMENT_TYPE_VALUETYPE, "System.Int32"}}, {"uint", {ELEMENT_TYPE_VALUETYPE, "System.UInt32"}}, {"long", {ELEMENT_TYPE_VALUETYPE, "System.Int64"}}, {"ulong", {ELEMENT_TYPE_VALUETYPE, "System.UInt64"}}, {"object", {ELEMENT_TYPE_CLASS, "System.Object"}}, {"short", {ELEMENT_TYPE_VALUETYPE, "System.Int16"}}, {"ushort", {ELEMENT_TYPE_VALUETYPE, "System.UInt16"}}, {"string", {ELEMENT_TYPE_CLASS, "System.String"}}, {"IntPtr", {ELEMENT_TYPE_VALUETYPE, "System.IntPtr"}}, {"UIntPtr", {ELEMENT_TYPE_VALUETYPE, "System.UIntPtr"}} }; Evaluator::ArgElementType userType; auto found = stypes.find(typeName); if (found != stypes.end()) { return found->second; } userType.corType = ELEMENT_TYPE_CLASS; userType.typeName = typeName; return userType; } HRESULT Evaluator::GetElement(ICorDebugValue *pInputValue, std::vector &indexes, ICorDebugValue **ppResultValue) { HRESULT Status; if (indexes.empty()) return E_FAIL; BOOL isNull = FALSE; ToRelease pValue; IfFailRet(DereferenceAndUnboxValue(pInputValue, &pValue, &isNull)); if (isNull) return E_FAIL; ToRelease pArrayVal; IfFailRet(pValue->QueryInterface(IID_ICorDebugArrayValue, (LPVOID *) &pArrayVal)); ULONG32 nRank; IfFailRet(pArrayVal->GetRank(&nRank)); if (indexes.size() != nRank) return E_FAIL; return pArrayVal->GetElement(static_cast(indexes.size()), indexes.data(), ppResultValue); } static HRESULT FollowNestedFindType(ICorDebugThread *pThread, Modules *pModules, const std::string &methodClass, std::vector &identifiers, ICorDebugType **ppResultType) { HRESULT Status; std::vector ranks; std::vector classIdentifiers = EvalUtils::ParseType(methodClass, ranks); int nextClassIdentifier = 0; std::vector fullpath; ToRelease pModule; IfFailRet(EvalUtils::FindType(classIdentifiers, nextClassIdentifier, pThread, pModules, nullptr, nullptr, &pModule)); bool trim = false; while (!classIdentifiers.empty()) { if (trim) classIdentifiers.pop_back(); fullpath = classIdentifiers; for (auto &identifier : identifiers) fullpath.push_back(identifier); nextClassIdentifier = 0; ToRelease pType; if (FAILED(EvalUtils::FindType(fullpath, nextClassIdentifier, pThread, pModules, pModule, &pType))) // NOLINT(clang-analyzer-cplusplus.Move) break; if (nextClassIdentifier == (int)fullpath.size()) { *ppResultType = pType.Detach(); return S_OK; } trim = true; } return E_FAIL; } static void IncIndicies(std::vector &ind, const std::vector &dims) { int i = static_cast(ind.size()) - 1; while (i >= 0) { ind[i] += 1; if (ind[i] < dims[i]) return; ind[i] = 0; --i; } } static std::string IndiciesToStr(const std::vector &ind, const std::vector &base) { const size_t ind_size = ind.size(); if (ind_size < 1 || base.size() != ind_size) return std::string(); std::ostringstream ss; const char *sep = ""; for (size_t i = 0; i < ind_size; ++i) { ss << sep; sep = ", "; ss << (base[i] + ind[i]); } return ss.str(); } typedef std::function WalkFieldsCallback; typedef std::function WalkPropertiesCallback; static HRESULT ForEachFields(IMetaDataImport *pMD, mdTypeDef currentTypeDef, WalkFieldsCallback cb) { HRESULT Status = S_OK; ULONG numFields = 0; HCORENUM hEnum = NULL; mdFieldDef fieldDef; while(SUCCEEDED(pMD->EnumFields(&hEnum, currentTypeDef, &fieldDef, 1, &numFields)) && numFields != 0) { Status = cb(fieldDef); if (FAILED(Status)) break; } pMD->CloseEnum(hEnum); return Status; } static HRESULT ForEachProperties(IMetaDataImport *pMD, mdTypeDef currentTypeDef, WalkPropertiesCallback cb) { HRESULT Status = S_OK; mdProperty propertyDef; ULONG numProperties = 0; HCORENUM propEnum = NULL; while(SUCCEEDED(pMD->EnumProperties(&propEnum, currentTypeDef, &propertyDef, 1, &numProperties)) && numProperties != 0) { Status = cb(propertyDef); if (FAILED(Status)) break; } pMD->CloseEnum(propEnum); return Status; } // https://github.com/dotnet/runtime/blob/57bfe474518ab5b7cfe6bf7424a79ce3af9d6657/docs/design/coreclr/profiling/davbr-blog-archive/samples/sigparse.cpp // This blog post originally appeared on David Broman's blog on 10/13/2005 // Sig ::= MethodDefSig | MethodRefSig | StandAloneMethodSig | FieldSig | PropertySig | LocalVarSig // MethodDefSig ::= [[HASTHIS] [EXPLICITTHIS]] (DEFAULT|VARARG|GENERIC GenParamCount) ParamCount RetType Param* // MethodRefSig ::= [[HASTHIS] [EXPLICITTHIS]] VARARG ParamCount RetType Param* [SENTINEL Param+] // StandAloneMethodSig ::= [[HASTHIS] [EXPLICITTHIS]] (DEFAULT|VARARG|C|STDCALL|THISCALL|FASTCALL) ParamCount RetType Param* [SENTINEL Param+] // FieldSig ::= FIELD CustomMod* Type // PropertySig ::= PROPERTY [HASTHIS] ParamCount CustomMod* Type Param* // LocalVarSig ::= LOCAL_SIG Count (TYPEDBYREF | ([CustomMod] [Constraint])* [BYREF] Type)+ // ------------- // CustomMod ::= ( CMOD_OPT | CMOD_REQD ) ( TypeDefEncoded | TypeRefEncoded ) // Constraint ::= #define ELEMENT_TYPE_PINNED // Param ::= CustomMod* ( TYPEDBYREF | [BYREF] Type ) // RetType ::= CustomMod* ( VOID | TYPEDBYREF | [BYREF] Type ) // Type ::= ( BOOLEAN | CHAR | I1 | U1 | U2 | U2 | I4 | U4 | I8 | U8 | R4 | R8 | I | U | // | VALUETYPE TypeDefOrRefEncoded // | CLASS TypeDefOrRefEncoded // | STRING // | OBJECT // | PTR CustomMod* VOID // | PTR CustomMod* Type // | FNPTR MethodDefSig // | FNPTR MethodRefSig // | ARRAY Type ArrayShape // | SZARRAY CustomMod* Type // | GENERICINST (CLASS | VALUETYPE) TypeDefOrRefEncoded GenArgCount Type* // | VAR Number // | MVAR Number // ArrayShape ::= Rank NumSizes Size* NumLoBounds LoBound* // TypeDefOrRefEncoded ::= TypeDefEncoded | TypeRefEncoded // TypeDefEncoded ::= 32-bit-3-part-encoding-for-typedefs-and-typerefs // TypeRefEncoded ::= 32-bit-3-part-encoding-for-typedefs-and-typerefs // ParamCount ::= 29-bit-encoded-integer // GenArgCount ::= 29-bit-encoded-integer // Count ::= 29-bit-encoded-integer // Rank ::= 29-bit-encoded-integer // NumSizes ::= 29-bit-encoded-integer // Size ::= 29-bit-encoded-integer // NumLoBounds ::= 29-bit-encoded-integer // LoBounds ::= 29-bit-encoded-integer // Number ::= 29-bit-encoded-integer static void GetCorTypeName(ULONG corType, std::string &typeName) { switch (corType) { case ELEMENT_TYPE_VOID: typeName = "void"; break; case ELEMENT_TYPE_BOOLEAN: typeName = "bool"; break; case ELEMENT_TYPE_CHAR: typeName = "char"; break; case ELEMENT_TYPE_I1: typeName = "sbyte"; break; case ELEMENT_TYPE_U1: typeName = "byte"; break; case ELEMENT_TYPE_I2: typeName = "short"; break; case ELEMENT_TYPE_U2: typeName = "ushort"; break; case ELEMENT_TYPE_I4: typeName = "int"; break; case ELEMENT_TYPE_U4: typeName = "uint"; break; case ELEMENT_TYPE_I8: typeName = "long"; break; case ELEMENT_TYPE_U8: typeName = "ulong"; break; case ELEMENT_TYPE_R4: typeName = "float"; break; case ELEMENT_TYPE_R8: typeName = "double"; break; case ELEMENT_TYPE_STRING: typeName = "string"; break; case ELEMENT_TYPE_OBJECT: typeName = "object"; break; default: typeName = ""; break; } } static HRESULT ParseElementType(IMetaDataImport *pMD, PCCOR_SIGNATURE *ppSig, Evaluator::ArgElementType &argElementType, std::vector &typeGenerics, std::vector &methodGenerics, bool addCorTypeName = false) { HRESULT Status; ULONG corType; mdToken tk; *ppSig += CorSigUncompressData(*ppSig, &corType); argElementType.corType = (CorElementType)corType; ULONG argNum = 0; switch (argElementType.corType) { case ELEMENT_TYPE_VOID: case ELEMENT_TYPE_BOOLEAN: case ELEMENT_TYPE_CHAR: case ELEMENT_TYPE_I1: case ELEMENT_TYPE_U1: case ELEMENT_TYPE_I2: case ELEMENT_TYPE_U2: case ELEMENT_TYPE_I4: case ELEMENT_TYPE_U4: case ELEMENT_TYPE_I8: case ELEMENT_TYPE_U8: case ELEMENT_TYPE_R4: case ELEMENT_TYPE_R8: case ELEMENT_TYPE_STRING: case ELEMENT_TYPE_OBJECT: if (addCorTypeName) GetCorTypeName(argElementType.corType, argElementType.typeName); break; case ELEMENT_TYPE_VALUETYPE: case ELEMENT_TYPE_CLASS: *ppSig += CorSigUncompressToken(*ppSig, &tk); IfFailRet(TypePrinter::NameForTypeByToken(tk, pMD, argElementType.typeName, nullptr)); break; case ELEMENT_TYPE_SZARRAY: if (FAILED(Status = ParseElementType(pMD, ppSig, argElementType, typeGenerics, methodGenerics, true)) || Status == S_FALSE) return Status; argElementType.corType = (CorElementType)corType; argElementType.typeName += "[]"; break; case ELEMENT_TYPE_ARRAY: { if (FAILED(Status = ParseElementType(pMD, ppSig, argElementType, typeGenerics, methodGenerics, true)) || Status == S_FALSE) return Status; argElementType.corType = (CorElementType)corType; // Parse for the rank ULONG rank = 0; *ppSig += CorSigUncompressData(*ppSig, &rank); // if rank == 0, we are done if (rank == 0) break; // any size of dimension specified? ULONG sizeDim; ULONG ulTemp; *ppSig += CorSigUncompressData(*ppSig, &sizeDim); while (sizeDim--) { *ppSig += CorSigUncompressData(*ppSig, &ulTemp); } // any lower bound specified? ULONG lowerBound; int iTemp; *ppSig += CorSigUncompressData(*ppSig, &lowerBound); while (lowerBound--) { *ppSig += CorSigUncompressSignedInt(*ppSig, &iTemp); } argElementType.typeName += "[" + std::string(rank - 1, ',') + "]"; break; } case ELEMENT_TYPE_VAR: // Generic parameter in a generic type definition, represented as number *ppSig += CorSigUncompressData(*ppSig, &argNum); if (argNum >= typeGenerics.size()) return S_FALSE; else { argElementType = typeGenerics[argNum]; if (addCorTypeName && argElementType.typeName.empty()) GetCorTypeName(argElementType.corType, argElementType.typeName); } break; case ELEMENT_TYPE_MVAR: // Generic parameter in a generic method definition, represented as number *ppSig += CorSigUncompressData(*ppSig, &argNum); if (argNum >= methodGenerics.size()) return S_FALSE; else { argElementType = methodGenerics[argNum]; if (addCorTypeName && argElementType.typeName.empty()) GetCorTypeName(argElementType.corType, argElementType.typeName); } break; case ELEMENT_TYPE_GENERICINST: // A type modifier for generic types - List<>, Dictionary<>, ... ULONG number; mdToken token; *ppSig += CorSigUncompressData(*ppSig, &corType); if(corType != ELEMENT_TYPE_CLASS && corType != ELEMENT_TYPE_VALUETYPE) return S_FALSE; *ppSig += CorSigUncompressToken(*ppSig, &token); argElementType.corType = (CorElementType)corType; IfFailRet(TypePrinter::NameForTypeByToken(token, pMD, argElementType.typeName, nullptr)); *ppSig += CorSigUncompressData(*ppSig, &number); for(ULONG i = 0; i < number; i++) { Evaluator::ArgElementType mycop; // Not needed at the moment if (FAILED(Status = ParseElementType(pMD, ppSig, mycop, typeGenerics, methodGenerics, true)) || Status == S_FALSE) return Status; } break; // TODO case ELEMENT_TYPE_U: // "nuint" - error CS8652: The feature 'native-sized integers' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version. case ELEMENT_TYPE_I: // "nint" - error CS8652: The feature 'native-sized integers' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version. case ELEMENT_TYPE_TYPEDBYREF: case ELEMENT_TYPE_PTR: // int* ptr (unsafe code only) case ELEMENT_TYPE_BYREF: // ref, in, out case ELEMENT_TYPE_CMOD_REQD: case ELEMENT_TYPE_CMOD_OPT: return S_FALSE; default: return E_INVALIDARG; } return S_OK; } HRESULT Evaluator::WalkMethods(ICorDebugValue *pInputTypeValue, WalkMethodsCallback cb) { HRESULT Status; ToRelease iCorValue2; IfFailRet(pInputTypeValue->QueryInterface(IID_ICorDebugValue2, (LPVOID *) &iCorValue2)); ToRelease iCorType; IfFailRet(iCorValue2->GetExactType(&iCorType)); std::vector methodGenerics; ToRelease iCorResultType; return WalkMethods(iCorType, &iCorResultType, methodGenerics, cb); } // https://github.com/dotnet/runtime/blob/57bfe474518ab5b7cfe6bf7424a79ce3af9d6657/docs/design/coreclr/profiling/davbr-blog-archive/samples/sigparse.cpp static const ULONG SIG_METHOD_VARARG = 0x5; // vararg calling convention static const ULONG SIG_METHOD_GENERIC = 0x10; // used to indicate that the method has one or more generic parameters. static HRESULT InternalWalkMethods(ICorDebugType *pInputType, ICorDebugType **ppResultType, std::vector &methodGenerics, Evaluator::WalkMethodsCallback cb) { HRESULT Status; ToRelease pClass; IfFailRet(pInputType->GetClass(&pClass)); ToRelease pModule; IfFailRet(pClass->GetModule(&pModule)); mdTypeDef currentTypeDef; IfFailRet(pClass->GetToken(¤tTypeDef)); ToRelease pMDUnknown; IfFailRet(pModule->GetMetaDataInterface(IID_IMetaDataImport, &pMDUnknown)); ToRelease pMD; IfFailRet(pMDUnknown->QueryInterface(IID_IMetaDataImport, (LPVOID*) &pMD)); std::vector typeGenerics; ToRelease paramTypes; if (SUCCEEDED(pInputType->EnumerateTypeParameters(¶mTypes))) { ULONG fetched = 0; ToRelease pCurrentTypeParam; while (SUCCEEDED(paramTypes->Next(1, &pCurrentTypeParam, &fetched)) && fetched == 1) { Evaluator::ArgElementType argElType; pCurrentTypeParam->GetType(&argElType.corType); if(argElType.corType == ELEMENT_TYPE_VALUETYPE || argElType.corType == ELEMENT_TYPE_CLASS) IfFailRet(TypePrinter::NameForTypeByType(pCurrentTypeParam, argElType.typeName)); typeGenerics.emplace_back(argElType); pCurrentTypeParam.Free(); } } ULONG numMethods = 0; HCORENUM fEnum = NULL; mdMethodDef methodDef; while(SUCCEEDED(pMD->EnumMethods(&fEnum, currentTypeDef, &methodDef, 1, &numMethods)) && numMethods != 0) { mdTypeDef memTypeDef; ULONG nameLen; WCHAR szFunctionName[mdNameLen] = {0}; DWORD methodAttr = 0; PCCOR_SIGNATURE pSig = NULL; ULONG cbSig = 0; if (FAILED(pMD->GetMethodProps(methodDef, &memTypeDef, szFunctionName, _countof(szFunctionName), &nameLen, &methodAttr, &pSig, &cbSig, nullptr, nullptr))) continue; ULONG gParams; // Count of signature generics ULONG cParams; // Count of signature parameters. ULONG elementSize; ULONG convFlags; // 1. calling convention for MethodDefSig: // [[HASTHIS] [EXPLICITTHIS]] (DEFAULT|VARARG|GENERIC GenParamCount) elementSize = CorSigUncompressData(pSig, &convFlags); pSig += elementSize; // TODO add VARARG methods support. if (convFlags & SIG_METHOD_VARARG) continue; // 2. count of generics if any if (convFlags & SIG_METHOD_GENERIC) { elementSize = CorSigUncompressData(pSig, &gParams); pSig += elementSize; } // 3. count of params elementSize = CorSigUncompressData(pSig, &cParams); pSig += elementSize; // 4. return type Evaluator::ArgElementType returnElementType; IfFailRet(ParseElementType(pMD, &pSig, returnElementType, typeGenerics, methodGenerics)); if (Status == S_FALSE) continue; // 5. get next element from method signature std::vector argElementTypes(cParams); for (ULONG i = 0; i < cParams; ++i) { IfFailRet(ParseElementType(pMD, &pSig, argElementTypes[i], typeGenerics, methodGenerics)); if (Status == S_FALSE) break; } if (Status == S_FALSE) continue; bool is_static = (methodAttr & mdStatic); auto getFunction = [&](ICorDebugFunction **ppResultFunction) -> HRESULT { return pModule->GetFunctionFromToken(methodDef, ppResultFunction); }; Status = cb(is_static, to_utf8(szFunctionName), returnElementType, argElementTypes, getFunction); if (FAILED(Status)) { pInputType->AddRef(); *ppResultType = pInputType; pMD->CloseEnum(fEnum); return Status; } } pMD->CloseEnum(fEnum); ToRelease iCorBaseType; if(SUCCEEDED(pInputType->GetBase(&iCorBaseType)) && iCorBaseType != NULL) { IfFailRet(InternalWalkMethods(iCorBaseType, ppResultType, methodGenerics, cb)); } return S_OK; } HRESULT Evaluator::WalkMethods(ICorDebugType *pInputType, ICorDebugType **ppResultType, std::vector &methodGenerics, Evaluator::WalkMethodsCallback cb) { return InternalWalkMethods(pInputType, ppResultType, methodGenerics, cb); } static HRESULT InternalSetValue(EvalStackMachine *pEvalStackMachine, EvalHelpers *pEvalHelpers, ICorDebugThread *pThread, FrameLevel frameLevel, ICorDebugValue *pValue, Evaluator::SetterData *setterData, const std::string &value, int evalFlags, std::string &output) { if (!pThread) return E_FAIL; // In case this is not property, just change value itself. if (!setterData) return pEvalStackMachine->SetValueByExpression(pThread, frameLevel, evalFlags, pValue, value, output); HRESULT Status; pValue->AddRef(); ToRelease iCorValue(pValue); CorElementType corType; IfFailRet(iCorValue->GetType(&corType)); if (corType == ELEMENT_TYPE_STRING) { // FIXME investigate, why in this case we can't use ICorDebugReferenceValue::SetValue() for string in iCorValue iCorValue.Free(); IfFailRet(pEvalStackMachine->EvaluateExpression(pThread, frameLevel, evalFlags, value, &iCorValue, output)); CorElementType elemType; IfFailRet(iCorValue->GetType(&elemType)); if (elemType != ELEMENT_TYPE_STRING) return E_INVALIDARG; } else // Allow stack machine decide what types are supported. { IfFailRet(pEvalStackMachine->SetValueByExpression(pThread, frameLevel, evalFlags, iCorValue.GetPtr(), value, output)); } // Call setter. if (!setterData->thisValue) { return pEvalHelpers->EvalFunction(pThread, setterData->setterFunction, setterData->propertyType.GetRef(), 1, iCorValue.GetRef(), 1, nullptr, evalFlags); } else { ICorDebugValue *ppArgsValue[] = {setterData->thisValue, iCorValue}; return pEvalHelpers->EvalFunction(pThread, setterData->setterFunction, setterData->propertyType.GetRef(), 1, ppArgsValue, 2, nullptr, evalFlags); } } HRESULT Evaluator::SetValue(ICorDebugThread *pThread, FrameLevel frameLevel, ICorDebugValue *pValue, SetterData *setterData, const std::string &value, int evalFlags, std::string &output) { return InternalSetValue(m_sharedEvalStackMachine.get(), m_sharedEvalHelpers.get(), pThread, frameLevel, pValue, setterData, value, evalFlags, output); } // https://github.com/dotnet/roslyn/blob/d1e617ded188343ba43d24590802dd51e68e8e32/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNameParser.cs#L13 static bool IsSynthesizedLocalName(WCHAR *mdName, ULONG nameLen) { return (nameLen > 1 && starts_with(mdName, W("<"))) || (nameLen > 4 && starts_with(mdName, W("CS$<"))); } static HRESULT InternalWalkMembers(EvalHelpers *pEvalHelpers, ICorDebugValue *pInputValue, ICorDebugThread *pThread, FrameLevel frameLevel, ICorDebugType *pTypeCast, bool provideSetterData, Evaluator::WalkMembersCallback cb) { HRESULT Status = S_OK; BOOL isNull = FALSE; ToRelease pValue; IfFailRet(DereferenceAndUnboxValue(pInputValue, &pValue, &isNull)); if (isNull && !pValue.GetPtr()) return S_OK; else if (!pValue.GetPtr()) return E_FAIL; CorElementType inputCorType; IfFailRet(pInputValue->GetType(&inputCorType)); if (inputCorType == ELEMENT_TYPE_PTR) { auto getValue = [&](ICorDebugValue **ppResultValue, int) -> HRESULT { pValue->AddRef(); *ppResultValue = pValue; return S_OK; }; return cb(nullptr, false, "", getValue, nullptr); } ToRelease pArrayValue; if (SUCCEEDED(pValue->QueryInterface(IID_ICorDebugArrayValue, (LPVOID *) &pArrayValue))) { ULONG32 nRank; IfFailRet(pArrayValue->GetRank(&nRank)); ULONG32 cElements; IfFailRet(pArrayValue->GetCount(&cElements)); std::vector dims(nRank, 0); IfFailRet(pArrayValue->GetDimensions(nRank, &dims[0])); std::vector base(nRank, 0); BOOL hasBaseIndicies = FALSE; if (SUCCEEDED(pArrayValue->HasBaseIndicies(&hasBaseIndicies)) && hasBaseIndicies) IfFailRet(pArrayValue->GetBaseIndicies(nRank, &base[0])); std::vector ind(nRank, 0); for (ULONG32 i = 0; i < cElements; ++i) { auto getValue = [&](ICorDebugValue **ppResultValue, int) -> HRESULT { IfFailRet(pArrayValue->GetElementAtPosition(i, ppResultValue)); return S_OK; }; IfFailRet(cb(nullptr, false, "[" + IndiciesToStr(ind, base) + "]", getValue, nullptr)); IncIndicies(ind, dims); } return S_OK; } ToRelease pValue2; IfFailRet(pValue->QueryInterface(IID_ICorDebugValue2, (LPVOID *) &pValue2)); ToRelease pType; if(pTypeCast == nullptr) { IfFailRet(pValue2->GetExactType(&pType)); if (!pType) return E_FAIL; } else { pTypeCast->AddRef(); pType = pTypeCast; } std::string className; TypePrinter::GetTypeOfValue(pType, className); if (className == "decimal") // TODO: implement mechanism for walking over custom type fields return S_OK; CorElementType corElemType; IfFailRet(pType->GetType(&corElemType)); if (corElemType == ELEMENT_TYPE_STRING) return S_OK; ToRelease pClass; IfFailRet(pType->GetClass(&pClass)); ToRelease pModule; IfFailRet(pClass->GetModule(&pModule)); mdTypeDef currentTypeDef; IfFailRet(pClass->GetToken(¤tTypeDef)); ToRelease pMDUnknown; IfFailRet(pModule->GetMetaDataInterface(IID_IMetaDataImport, &pMDUnknown)); ToRelease pMD; IfFailRet(pMDUnknown->QueryInterface(IID_IMetaDataImport, (LPVOID*) &pMD)); IfFailRet(ForEachFields(pMD, currentTypeDef, [&](mdFieldDef fieldDef) -> HRESULT { ULONG nameLen = 0; DWORD fieldAttr = 0; WCHAR mdName[mdNameLen] = {0}; PCCOR_SIGNATURE pSignatureBlob = nullptr; ULONG sigBlobLength = 0; UVCP_CONSTANT pRawValue = nullptr; ULONG rawValueLength = 0; if (SUCCEEDED(pMD->GetFieldProps(fieldDef, nullptr, mdName, _countof(mdName), &nameLen, &fieldAttr, &pSignatureBlob, &sigBlobLength, nullptr, &pRawValue, &rawValueLength))) { // Prevent access to internal compiler added fields (without visible name). // Should be accessed by debugger routine only and hidden from user/ide. // More about compiler generated names in Roslyn sources: // https://github.com/dotnet/roslyn/blob/315c2e149ba7889b0937d872274c33fcbfe9af5f/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNames.cs // Note, uncontrolled access to internal compiler added field or its properties may break debugger work. if (IsSynthesizedLocalName(mdName, nameLen)) return S_OK; bool is_static = (fieldAttr & fdStatic); if (isNull && !is_static) return S_OK; std::string name = to_utf8(mdName); auto getValue = [&](ICorDebugValue **ppResultValue, int) -> HRESULT { if (fieldAttr & fdLiteral) { IfFailRet(pEvalHelpers->GetLiteralValue(pThread, pType, pModule, pSignatureBlob, sigBlobLength, pRawValue, rawValueLength, ppResultValue)); } else if (fieldAttr & fdStatic) { if (!pThread) return E_FAIL; ToRelease pFrame; IfFailRet(GetFrameAt(pThread, frameLevel, &pFrame)); if (pFrame == nullptr) return E_FAIL; IfFailRet(pType->GetStaticFieldValue(fieldDef, pFrame, ppResultValue)); } else { // Get pValue again, since it could be neutered at eval call in `cb` on previous cycle. pValue.Free(); IfFailRet(DereferenceAndUnboxValue(pInputValue, &pValue, &isNull)); ToRelease pObjValue; IfFailRet(pValue->QueryInterface(IID_ICorDebugObjectValue, (LPVOID*) &pObjValue)); IfFailRet(pObjValue->GetFieldValue(pClass, fieldDef, ppResultValue)); } return S_OK; }; IfFailRet(cb(pType, is_static, name, getValue, nullptr)); } return S_OK; })); IfFailRet(ForEachProperties(pMD, currentTypeDef, [&](mdProperty propertyDef) -> HRESULT { mdTypeDef propertyClass; ULONG propertyNameLen = 0; UVCP_CONSTANT pDefaultValue; ULONG cchDefaultValue; mdMethodDef mdGetter; mdMethodDef mdSetter; WCHAR propertyName[mdNameLen] = W("\0"); if (SUCCEEDED(pMD->GetPropertyProps(propertyDef, &propertyClass, propertyName, _countof(propertyName), &propertyNameLen, nullptr, nullptr, nullptr, nullptr, &pDefaultValue, &cchDefaultValue, &mdSetter, &mdGetter, nullptr, 0, nullptr))) { DWORD getterAttr = 0; if (FAILED(pMD->GetMethodProps(mdGetter, NULL, NULL, 0, NULL, &getterAttr, NULL, NULL, NULL, NULL))) return S_OK; bool is_static = (getterAttr & mdStatic); if (isNull && !is_static) return S_OK; // https://github.sec.samsung.net/dotnet/coreclr/blob/9df87a133b0f29f4932f38b7307c87d09ab80d5d/src/System.Private.CoreLib/shared/System/Diagnostics/DebuggerBrowsableAttribute.cs#L17 // Since we check only first byte, no reason store it as int (default enum type in c#) enum DebuggerBrowsableState : char { Never = 0, Expanded = 1, Collapsed = 2, RootHidden = 3 }; const char *g_DebuggerBrowsable = "System.Diagnostics.DebuggerBrowsableAttribute..ctor"; bool debuggerBrowsableState_Never = false; ULONG numAttributes = 0; HCORENUM hEnum = NULL; mdCustomAttribute attr; while(SUCCEEDED(pMD->EnumCustomAttributes(&hEnum, propertyDef, 0, &attr, 1, &numAttributes)) && numAttributes != 0) { mdToken ptkObj = mdTokenNil; mdToken ptkType = mdTokenNil; void const *ppBlob = 0; ULONG pcbSize = 0; if (FAILED(pMD->GetCustomAttributeProps(attr, &ptkObj, &ptkType, &ppBlob, &pcbSize))) continue; std::string mdName; if (FAILED(TypePrinter::NameForToken(ptkType, pMD, mdName, true, nullptr))) continue; if (mdName == g_DebuggerBrowsable // In case of DebuggerBrowsableAttribute blob is 8 bytes: // 2 bytes - blob prolog 0x0001 // 4 bytes - data (DebuggerBrowsableAttribute::State), default enum type (int) // 2 bytes - alignment // We check only one byte (first data byte), no reason check 4 bytes in our case. && pcbSize > 2 && ((char const *)ppBlob)[2] == DebuggerBrowsableState::Never) { debuggerBrowsableState_Never = true; break; } } pMD->CloseEnum(hEnum); if (debuggerBrowsableState_Never) return S_OK; std::string name = to_utf8(propertyName); auto getValue = [&](ICorDebugValue **ppResultValue, int evalFlags) -> HRESULT { if (!pThread) return E_FAIL; ToRelease iCorFunc; IfFailRet(pModule->GetFunctionFromToken(mdGetter, &iCorFunc)); return pEvalHelpers->EvalFunction(pThread, iCorFunc, pType.GetRef(), 1, is_static ? nullptr : &pInputValue, is_static ? 0 : 1, ppResultValue, evalFlags); }; if (provideSetterData) { ToRelease iCorFuncSetter; if (FAILED(pModule->GetFunctionFromToken(mdSetter, &iCorFuncSetter))) { iCorFuncSetter.Free(); } Evaluator::SetterData setterData(is_static ? nullptr : pInputValue, pType, iCorFuncSetter); IfFailRet(cb(pType, is_static, name, getValue, &setterData)); } else { IfFailRet(cb(pType, is_static, name, getValue, nullptr)); } } return S_OK; })); std::string baseTypeName; ToRelease pBaseType; if(SUCCEEDED(pType->GetBase(&pBaseType)) && pBaseType != NULL && SUCCEEDED(TypePrinter::GetTypeOfValue(pBaseType, baseTypeName))) { if(baseTypeName == "System.Enum") return S_OK; else if (baseTypeName != "object" && baseTypeName != "System.Object" && baseTypeName != "System.ValueType") { if (pThread) { // Note, this call could return S_FALSE without ICorDebugValue creation in case type don't have static members. IfFailRet(pEvalHelpers->CreatTypeObjectStaticConstructor(pThread, pBaseType)); } // Add fields of base class IfFailRet(InternalWalkMembers(pEvalHelpers, pInputValue, pThread, frameLevel, pBaseType, provideSetterData, cb)); } } return S_OK; } HRESULT Evaluator::WalkMembers( ICorDebugValue *pValue, ICorDebugThread *pThread, FrameLevel frameLevel, bool provideSetterData, WalkMembersCallback cb) { return InternalWalkMembers(m_sharedEvalHelpers.get(), pValue, pThread, frameLevel, nullptr, provideSetterData, cb); } enum class GeneratedCodeKind { Normal, Async, Lambda }; static HRESULT GetGeneratedCodeKind(IMetaDataImport *pMD, const WSTRING methodName, mdTypeDef typeDef, GeneratedCodeKind &result) { HRESULT Status; WCHAR name[mdNameLen]; ULONG nameLen; IfFailRet(pMD->GetTypeDefProps(typeDef, name, _countof(name), &nameLen, NULL, NULL)); WSTRING typeName(name); // https://github.com/dotnet/roslyn/blob/d1e617ded188343ba43d24590802dd51e68e8e32/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNameParser.cs#L20-L24 // Parse the generated name. Returns true for names of the form // [CS$]<[middle]>c[__[suffix]] where [CS$] is included for certain // generated names, where [middle] and [__[suffix]] are optional, // and where c is a single character in [1-9a-z] // (csharp\LanguageAnalysis\LIB\SpecialName.cpp). // https://github.com/dotnet/roslyn/blob/d1e617ded188343ba43d24590802dd51e68e8e32/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNameKind.cs#L13-L20 // LambdaMethod = 'b', // LambdaDisplayClass = 'c', // StateMachineType = 'd', // https://github.com/dotnet/roslyn/blob/21055e1858548dbd8f4c1fd5d25a9c9617873806/src/Compilers/Core/Portable/PublicAPI.Shipped.txt#L252 // const Microsoft.CodeAnalysis.WellKnownMemberNames.MoveNextMethodName = "MoveNext" -> string! // ... used in SynthesizedStateMachineMoveNextMethod class constructor. if (methodName.rfind(W("MoveNext"), 0) != WSTRING::npos && typeName.find(W(">d")) != WSTRING::npos) result = GeneratedCodeKind::Async; else if (methodName.find(W(">b")) != WSTRING::npos && typeName.find(W(">c")) != WSTRING::npos) result = GeneratedCodeKind::Lambda; else result = GeneratedCodeKind::Normal; return S_OK; } enum class GeneratedNameKind { None, ThisProxyField, HoistedLocalField, DisplayClassLocalOrField }; static GeneratedNameKind GetLocalOrFieldNameKind(const WSTRING &localOrFieldName) { // https://github.com/dotnet/roslyn/blob/d1e617ded188343ba43d24590802dd51e68e8e32/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNameParser.cs#L20-L24 // Parse the generated name. Returns true for names of the form // [CS$]<[middle]>c[__[suffix]] where [CS$] is included for certain // generated names, where [middle] and [__[suffix]] are optional, // and where c is a single character in [1-9a-z] // (csharp\LanguageAnalysis\LIB\SpecialName.cpp). // https://github.com/dotnet/roslyn/blob/d1e617ded188343ba43d24590802dd51e68e8e32/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNameKind.cs#L13-L20 // ThisProxyField = '4', // HoistedLocalField = '5', // DisplayClassLocalOrField = '8', if (localOrFieldName.find(W(">4")) != WSTRING::npos) return GeneratedNameKind::ThisProxyField; else if (localOrFieldName.find(W(">5")) != WSTRING::npos) return GeneratedNameKind::HoistedLocalField; else if (localOrFieldName.find(W(">8")) != WSTRING::npos) return GeneratedNameKind::DisplayClassLocalOrField; return GeneratedNameKind::None; } static HRESULT GetClassAndTypeDefByValue(ICorDebugValue *pValue, ICorDebugClass **ppClass, mdTypeDef &typeDef) { HRESULT Status; ToRelease iCorValue2; IfFailRet(pValue->QueryInterface(IID_ICorDebugValue2, (LPVOID *) &iCorValue2)); ToRelease iCorType; IfFailRet(iCorValue2->GetExactType(&iCorType)); IfFailRet(iCorType->GetClass(ppClass)); IfFailRet((*ppClass)->GetToken(&typeDef)); return S_OK; } static HRESULT FindThisProxyFieldValue(IMetaDataImport *pMD, ICorDebugClass *pClass, mdTypeDef typeDef, ICorDebugValue *pInputValue, ICorDebugValue **ppResultValue) { HRESULT Status; BOOL isNull = FALSE; ToRelease pValue; IfFailRet(DereferenceAndUnboxValue(pInputValue, &pValue, &isNull)); if (isNull == TRUE) return E_INVALIDARG; Status = ForEachFields(pMD, typeDef, [&](mdFieldDef fieldDef) -> HRESULT { WCHAR mdName[mdNameLen] = {0}; ULONG nameLen = 0; if (SUCCEEDED(pMD->GetFieldProps(fieldDef, nullptr, mdName, _countof(mdName), &nameLen, NULL, NULL, NULL, NULL, NULL, NULL))) { auto getValue = [&](ICorDebugValue **ppResultValue) -> HRESULT { ToRelease pObjValue; IfFailRet(pValue->QueryInterface(IID_ICorDebugObjectValue, (LPVOID*) &pObjValue)); IfFailRet(pObjValue->GetFieldValue(pClass, fieldDef, ppResultValue)); return S_OK; }; GeneratedNameKind generatedNameKind = GetLocalOrFieldNameKind(mdName); if (generatedNameKind == GeneratedNameKind::ThisProxyField) { IfFailRet(getValue(ppResultValue)); return E_ABORT; // Fast exit from cycle } else if (generatedNameKind == GeneratedNameKind::DisplayClassLocalOrField) { ToRelease iCorDisplayClassValue; IfFailRet(getValue(&iCorDisplayClassValue)); ToRelease iCorDisplayClass; mdTypeDef displayClassTypeDef; IfFailRet(GetClassAndTypeDefByValue(iCorDisplayClassValue, &iCorDisplayClass, displayClassTypeDef)); IfFailRet(FindThisProxyFieldValue(pMD, iCorDisplayClass, displayClassTypeDef, iCorDisplayClassValue, ppResultValue)); if (ppResultValue) return E_ABORT; // Fast exit from cycle } } return S_OK; // Return with success to continue walk. }); return Status == E_ABORT ? S_OK : Status; } // Note, this method return Class name, not Type name (will not provide generic initialization types if any). static HRESULT InternalGetMethodClass(ICorDebugThread *pThread, FrameLevel frameLevel, std::string &methodClass, bool &haveThis) { HRESULT Status; ToRelease pFrame; IfFailRet(GetFrameAt(pThread, frameLevel, &pFrame)); if (pFrame == nullptr) return E_FAIL; ToRelease pFunction; IfFailRet(pFrame->GetFunction(&pFunction)); ToRelease pModule; IfFailRet(pFunction->GetModule(&pModule)); ToRelease pMDUnknown; IfFailRet(pModule->GetMetaDataInterface(IID_IMetaDataImport, &pMDUnknown)); ToRelease pMD; IfFailRet(pMDUnknown->QueryInterface(IID_IMetaDataImport, (LPVOID*) &pMD)); mdMethodDef methodDef; IfFailRet(pFunction->GetToken(&methodDef)); DWORD methodAttr = 0; WCHAR szMethod[mdNameLen]; ULONG szMethodLen; IfFailRet(pMD->GetMethodProps(methodDef, NULL, szMethod, _countof(szMethod), &szMethodLen, &methodAttr, NULL, NULL, NULL, NULL)); ToRelease pClass; IfFailRet(pFunction->GetClass(&pClass)); mdTypeDef typeDef; IfFailRet(pClass->GetToken(&typeDef)); // We are inside method of this class, if typeDef is not TypeDef token - something definitely going wrong. if (TypeFromToken(typeDef) != mdtTypeDef) return E_FAIL; haveThis = (methodAttr & mdStatic) == 0; // In case this is static method, this is not async/lambda case for sure. if (!haveThis) return TypePrinter::NameForTypeDef(typeDef, pMD, methodClass, nullptr); GeneratedCodeKind generatedCodeKind; IfFailRet(GetGeneratedCodeKind(pMD, szMethod, typeDef, generatedCodeKind)); if (generatedCodeKind == GeneratedCodeKind::Normal) return TypePrinter::NameForTypeDef(typeDef, pMD, methodClass, nullptr); ToRelease pILFrame; IfFailRet(pFrame->QueryInterface(IID_ICorDebugILFrame, (LPVOID*) &pILFrame)); ToRelease currentThis; IfFailRet(pILFrame->GetArgument(0, ¤tThis)); // Check do we have real This value (that should be stored in ThisProxyField). ToRelease userThis; IfFailRet(FindThisProxyFieldValue(pMD, pClass, typeDef, currentThis, &userThis)); haveThis = !!userThis; // Find first user code enclosing class, since compiler add async/lambda as nested class. do { ULONG nameLen; WCHAR mdName[mdNameLen]; IfFailRet(pMD->GetTypeDefProps(typeDef, mdName, _countof(mdName), &nameLen, NULL, NULL)); if (!IsSynthesizedLocalName(mdName, nameLen)) break; mdTypeDef enclosingClass; if (SUCCEEDED(Status = pMD->GetNestedClassProps(typeDef, &enclosingClass))) typeDef = enclosingClass; else return Status; } while(1); return TypePrinter::NameForTypeDef(typeDef, pMD, methodClass, nullptr); } HRESULT Evaluator::GetMethodClass(ICorDebugThread *pThread, FrameLevel frameLevel, std::string &methodClass, bool &haveThis) { return InternalGetMethodClass(pThread, frameLevel, methodClass, haveThis); } // https://github.com/dotnet/roslyn/blob/3fdd28bc26238f717ec1124efc7e1f9c2158bce2/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNameParser.cs#L139-L159 static HRESULT TryParseSlotIndex(const WSTRING &mdName, int32_t &index) { // https://github.com/dotnet/roslyn/blob/d1e617ded188343ba43d24590802dd51e68e8e32/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNameConstants.cs#L11 const WSTRING suffixSeparator(W("__")); WSTRING::size_type suffixSeparatorOffset = mdName.rfind(suffixSeparator); if (suffixSeparatorOffset == WSTRING::npos) return E_FAIL; WSTRING slotIndexString = mdName.substr(suffixSeparatorOffset + 2 /* suffixSeparator size */); if (slotIndexString.empty() || // Slot index is positive 4 byte int, that mean max is 10 characters (2147483647). slotIndexString.size() > 10) return E_FAIL; int32_t slotIndex = 0; for (WSTRING::size_type i = 0; i < slotIndexString.size(); i++) { if (slotIndexString[i] < W('0') && slotIndexString[i] > W('9')) return E_FAIL; slotIndex = slotIndex * 10 + (int32_t)(slotIndexString[i] - W('0')); } if (slotIndex < 1) // Slot index start from 1. return E_FAIL; index = slotIndex - 1; return S_OK; } // https://github.com/dotnet/roslyn/blob/3fdd28bc26238f717ec1124efc7e1f9c2158bce2/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNameParser.cs#L20-L59 static HRESULT TryParseHoistedLocalName(const WSTRING &mdName, WSTRING &wLocalName) { WSTRING::size_type nameStartOffset; if (mdName.length() > 1 && starts_with(mdName.data(), W("<"))) nameStartOffset = 1; else if (mdName.length() > 4 && starts_with(mdName.data(), W("CS$<"))) nameStartOffset = 4; else return E_FAIL; WSTRING::size_type closeBracketOffset = mdName.find('>', nameStartOffset); if (closeBracketOffset == WSTRING::npos) return E_FAIL; wLocalName = mdName.substr(nameStartOffset, closeBracketOffset - nameStartOffset); return S_OK; } static HRESULT WalkGeneratedClassFields(IMetaDataImport *pMD, ICorDebugValue *pInputValue, ULONG32 currentIlOffset, std::unordered_set &usedNames, mdMethodDef methodDef, ULONG32 methodVersion, Modules *pModules, ICorDebugModule *pModule, Evaluator::WalkStackVarsCallback cb) { HRESULT Status; BOOL isNull = FALSE; ToRelease pValue; IfFailRet(DereferenceAndUnboxValue(pInputValue, &pValue, &isNull)); if (isNull == TRUE) return S_OK; ToRelease pClass; mdTypeDef currentTypeDef; IfFailRet(GetClassAndTypeDefByValue(pValue, &pClass, currentTypeDef)); struct hoisted_local_scope_t { uint32_t startOffset; uint32_t length; }; struct hoisted_local_scope_t_deleter { void operator()(hoisted_local_scope_t *p) const { Interop::CoTaskMemFree(p); } }; int32_t hoistedLocalScopesCount = -1; std::unique_ptr hoistedLocalScopes; IfFailRet(ForEachFields(pMD, currentTypeDef, [&](mdFieldDef fieldDef) -> HRESULT { WCHAR mdName[mdNameLen] = {0}; ULONG nameLen = 0; DWORD fieldAttr = 0; if (FAILED(pMD->GetFieldProps(fieldDef, nullptr, mdName, _countof(mdName), &nameLen, &fieldAttr, NULL, NULL, NULL, NULL, NULL))) return S_OK; // Return with success to continue walk. if ((fieldAttr & fdStatic) != 0 || (fieldAttr & fdLiteral) != 0 || usedNames.find(mdName) != usedNames.end()) return S_OK; // Return with success to continue walk. auto getValue = [&](ICorDebugValue **ppResultValue, int) -> HRESULT { // Get pValue again, since it could be neutered at eval call in `cb` on previous cycle. pValue.Free(); IfFailRet(DereferenceAndUnboxValue(pInputValue, &pValue, &isNull)); ToRelease pObjValue; IfFailRet(pValue->QueryInterface(IID_ICorDebugObjectValue, (LPVOID*) &pObjValue)); IfFailRet(pObjValue->GetFieldValue(pClass, fieldDef, ppResultValue)); return S_OK; }; GeneratedNameKind generatedNameKind = GetLocalOrFieldNameKind(mdName); if (generatedNameKind == GeneratedNameKind::DisplayClassLocalOrField) { ToRelease iCorDisplayClassValue; IfFailRet(getValue(&iCorDisplayClassValue, defaultEvalFlags)); IfFailRet(WalkGeneratedClassFields(pMD, iCorDisplayClassValue, currentIlOffset, usedNames, methodDef, methodVersion, pModules, pModule, cb)); } else if (generatedNameKind == GeneratedNameKind::HoistedLocalField) { if (hoistedLocalScopesCount == -1) { PVOID data = nullptr; if (SUCCEEDED(pModules->GetHoistedLocalScopes(pModule, methodDef, methodVersion, &data, hoistedLocalScopesCount)) && data) hoistedLocalScopes.reset((hoisted_local_scope_t*)data); else hoistedLocalScopesCount = 0; } // Check, that hoisted local is in scope. // Note, in case we have any issue - ignore this check and show variable, since this is not fatal error. int32_t index; if (hoistedLocalScopesCount > 0 && SUCCEEDED(TryParseSlotIndex(mdName, index)) && hoistedLocalScopesCount > index && (currentIlOffset < hoistedLocalScopes.get()[index].startOffset || currentIlOffset >= hoistedLocalScopes.get()[index].startOffset + hoistedLocalScopes.get()[index].length)) return S_OK; // Return with success to continue walk. WSTRING wLocalName; if (FAILED(TryParseHoistedLocalName(mdName, wLocalName))) return S_OK; // Return with success to continue walk. IfFailRet(cb(to_utf8(wLocalName.data()), getValue)); usedNames.insert(wLocalName); } // Ignore any other compiler generated fields, show only normal fields. else if (!IsSynthesizedLocalName(mdName, nameLen)) { IfFailRet(cb(to_utf8(mdName), getValue)); usedNames.insert(mdName); } return S_OK; // Return with success to continue walk. })); return S_OK; } static HRESULT InternalWalkStackVars(Modules *pModules, ICorDebugThread *pThread, FrameLevel frameLevel, Evaluator::WalkStackVarsCallback cb) { HRESULT Status; ToRelease pFrame; IfFailRet(GetFrameAt(pThread, frameLevel, &pFrame)); if (pFrame == nullptr) return E_FAIL; ULONG32 currentIlOffset; Modules::SequencePoint sp; // GetFrameILAndSequencePoint() return "success" code only in case it found sequence point // for current IP, that mean we stop inside user code. // Note, we could have request for not user code, we ignore it and this is OK. if (FAILED(pModules->GetFrameILAndSequencePoint(pFrame, currentIlOffset, sp))) return S_OK; ToRelease pFunction; IfFailRet(pFrame->GetFunction(&pFunction)); ToRelease pCode; IfFailRet(pFunction->GetILCode(&pCode)); ULONG32 methodVersion; IfFailRet(pCode->GetVersionNumber(&methodVersion)); ToRelease pModule; IfFailRet(pFunction->GetModule(&pModule)); ToRelease pMDUnknown; IfFailRet(pModule->GetMetaDataInterface(IID_IMetaDataImport, &pMDUnknown)); ToRelease pMD; IfFailRet(pMDUnknown->QueryInterface(IID_IMetaDataImport, (LPVOID*) &pMD)); mdMethodDef methodDef; IfFailRet(pFunction->GetToken(&methodDef)); ToRelease pILFrame; IfFailRet(pFrame->QueryInterface(IID_ICorDebugILFrame, (LPVOID*) &pILFrame)); ToRelease pLocalsEnum; IfFailRet(pILFrame->EnumerateLocalVariables(&pLocalsEnum)); ULONG cLocals = 0; IfFailRet(pLocalsEnum->GetCount(&cLocals)); ULONG cArguments = 0; ToRelease iCorArgumentEnum; IfFailRet(pILFrame->EnumerateArguments(&iCorArgumentEnum)); IfFailRet(iCorArgumentEnum->GetCount(&cArguments)); // Note, we use same order as vsdbg use: // 1. "this" (real or "this" proxy field in case async method and lambda). // 2. "real" argumens. // 3. "real" local variables. // 4. async/lambda object fields. DWORD methodAttr = 0; WCHAR szMethod[mdNameLen]; ULONG szMethodLen; IfFailRet(pMD->GetMethodProps(methodDef, NULL, szMethod, _countof(szMethod), &szMethodLen, &methodAttr, NULL, NULL, NULL, NULL)); GeneratedCodeKind generatedCodeKind = GeneratedCodeKind::Normal; ToRelease currentThis; // Current This. Note, in case async method or lambda - this is special object (not user's "this"). // In case this is static method, this is not async/lambda case for sure. if ((methodAttr & mdStatic) == 0) { ToRelease pClass; IfFailRet(pFunction->GetClass(&pClass)); mdTypeDef typeDef; IfFailRet(pClass->GetToken(&typeDef)); IfFailRet(GetGeneratedCodeKind(pMD, szMethod, typeDef, generatedCodeKind)); IfFailRet(pILFrame->GetArgument(0, ¤tThis)); ToRelease userThis; if (generatedCodeKind == GeneratedCodeKind::Normal) { currentThis->AddRef(); userThis = currentThis.GetPtr(); } else { // Check do we have real This value (that should be stored in ThisProxyField). IfFailRet(FindThisProxyFieldValue(pMD, pClass, typeDef, currentThis, &userThis)); } if (userThis) { auto getValue = [&](ICorDebugValue **ppResultValue, int) -> HRESULT { userThis->AddRef(); *ppResultValue = userThis; return S_OK; }; IfFailRet(cb("this", getValue)); // Reset pFrame/pILFrame, since it could be neutered at `cb` call, we need track this case. pFrame.Free(); pILFrame.Free(); } } // Lambda could duplicate arguments into display class local object. Make sure we call "cb" only once for unique name. // Note, we don't use usedNames with 'this' related code above, since it have logic "find first and return". // In the same time, all code below ignore 'this' argument/field check. std::unordered_set usedNames; for (ULONG i = (methodAttr & mdStatic) == 0 ? 1 : 0; i < cArguments; i++) { // https://docs.microsoft.com/en-us/dotnet/framework/unmanaged-api/metadata/imetadataimport-getparamformethodindex-method // The ordinal position in the parameter list where the requested parameter occurs. Parameters are numbered starting from one, with the method's return value in position zero. // Note, IMetaDataImport::GetParamForMethodIndex() don't include "this", but ICorDebugILFrame::GetArgument() do. This is why we have different logic here. int idx = ((methodAttr & mdStatic) == 0) ? i : (i + 1); WCHAR wParamName[mdNameLen] = W("\0"); ULONG paramNameLen = 0; mdParamDef paramDef; if(FAILED(pMD->GetParamForMethodIndex(methodDef, idx, ¶mDef)) || FAILED(pMD->GetParamProps(paramDef, NULL, NULL, wParamName, mdNameLen, ¶mNameLen, NULL, NULL, NULL, NULL))) continue; auto getValue = [&](ICorDebugValue **ppResultValue, int) -> HRESULT { if (!pFrame) // Forced to update pFrame/pILFrame. { IfFailRet(GetFrameAt(pThread, frameLevel, &pFrame)); if (pFrame == nullptr) return E_FAIL; IfFailRet(pFrame->QueryInterface(IID_ICorDebugILFrame, (LPVOID*) &pILFrame)); } return pILFrame->GetArgument(i, ppResultValue); }; IfFailRet(cb(to_utf8(wParamName), getValue)); usedNames.insert(wParamName); // Reset pFrame/pILFrame, since it could be neutered at `cb` call, we need track this case. pFrame.Free(); pILFrame.Free(); } for (ULONG i = 0; i < cLocals; i++) { WSTRING wLocalName; ULONG32 ilStart; ULONG32 ilEnd; if (FAILED(pModules->GetFrameNamedLocalVariable(pModule, methodDef, methodVersion, i, wLocalName, &ilStart, &ilEnd))) continue; if (currentIlOffset < ilStart || currentIlOffset >= ilEnd) continue; auto getValue = [&](ICorDebugValue **ppResultValue, int) -> HRESULT { if (!pFrame) // Forced to update pFrame/pILFrame. { IfFailRet(GetFrameAt(pThread, frameLevel, &pFrame)); if (pFrame == nullptr) return E_FAIL; IfFailRet(pFrame->QueryInterface(IID_ICorDebugILFrame, (LPVOID*) &pILFrame)); } return pILFrame->GetLocalVariable(i, ppResultValue); }; // Note, this method could have lambdas inside, display class local objects must be also checked, // since this objects could hold current method local variables too. if (GetLocalOrFieldNameKind(wLocalName) == GeneratedNameKind::DisplayClassLocalOrField) { ToRelease iCorDisplayClassValue; IfFailRet(getValue(&iCorDisplayClassValue, defaultEvalFlags)); IfFailRet(WalkGeneratedClassFields(pMD, iCorDisplayClassValue, currentIlOffset, usedNames, methodDef, methodVersion, pModules, pModule, cb)); continue; } IfFailRet(cb(to_utf8(wLocalName.data()), getValue)); usedNames.insert(wLocalName); // Reset pFrame/pILFrame, since it could be neutered at `cb` call, we need track this case. pFrame.Free(); pILFrame.Free(); } if (generatedCodeKind != GeneratedCodeKind::Normal) return WalkGeneratedClassFields(pMD, currentThis, currentIlOffset, usedNames, methodDef, methodVersion, pModules, pModule, cb); return S_OK; } HRESULT Evaluator::WalkStackVars(ICorDebugThread *pThread, FrameLevel frameLevel, WalkStackVarsCallback cb) { return InternalWalkStackVars(m_sharedModules.get(), pThread, frameLevel, cb); } static HRESULT FollowFields(EvalHelpers *pEvalHelpers, ICorDebugThread *pThread, FrameLevel frameLevel, ICorDebugValue *pValue, Evaluator::ValueKind valueKind, std::vector &identifiers, int nextIdentifier, ICorDebugValue **ppResult, std::unique_ptr *resultSetterData, int evalFlags) { HRESULT Status; // Note, in case of (nextIdentifier == identifiers.size()) result is pValue itself, so, we ok here. if (nextIdentifier > (int)identifiers.size()) return E_FAIL; pValue->AddRef(); ToRelease pResultValue(pValue); for (int i = nextIdentifier; i < (int)identifiers.size(); i++) { if (identifiers[i].empty()) return E_FAIL; ToRelease pClassValue(std::move(pResultValue)); InternalWalkMembers(pEvalHelpers, pClassValue, pThread, frameLevel, nullptr, !!resultSetterData, [&]( ICorDebugType *pType, bool is_static, const std::string &memberName, Evaluator::GetValueCallback getValue, Evaluator::SetterData *setterData) { if (is_static && valueKind == Evaluator::ValueIsVariable) return S_OK; if (!is_static && valueKind == Evaluator::ValueIsClass) return S_OK; if (memberName != identifiers[i]) return S_OK; IfFailRet(getValue(&pResultValue, evalFlags)); if (setterData && resultSetterData) (*resultSetterData).reset(new Evaluator::SetterData(*setterData)); return E_ABORT; // Fast exit from cycle with result. }); if (!pResultValue) return E_FAIL; valueKind = Evaluator::ValueIsVariable; // we can only follow through instance fields } *ppResult = pResultValue.Detach(); return S_OK; } static HRESULT FollowNestedFindValue(Modules *pModules, EvalHelpers *pEvalHelpers, ICorDebugThread *pThread, FrameLevel frameLevel, const std::string &methodClass, std::vector &identifiers, ICorDebugValue **ppResult, std::unique_ptr *resultSetterData, int evalFlags) { HRESULT Status; std::vector ranks; std::vector classIdentifiers = EvalUtils::ParseType(methodClass, ranks); int nextClassIdentifier = 0; int identifiersNum = (int)identifiers.size() - 1; std::vector fieldName {identifiers.back()}; std::vector fullpath; ToRelease pModule; IfFailRet(EvalUtils::FindType(classIdentifiers, nextClassIdentifier, pThread, pModules, nullptr, nullptr, &pModule)); bool trim = false; while (!classIdentifiers.empty()) { ToRelease pType; nextClassIdentifier = 0; if (trim) classIdentifiers.pop_back(); fullpath = classIdentifiers; for (int i = 0; i < identifiersNum; i++) fullpath.push_back(identifiers[i]); if (FAILED(EvalUtils::FindType(fullpath, nextClassIdentifier, pThread, pModules, pModule, &pType))) // NOLINT(clang-analyzer-cplusplus.Move) break; if (nextClassIdentifier < (int)fullpath.size()) { // try to check non-static fields inside a static member std::vector staticName; for (int i = nextClassIdentifier; i < (int)fullpath.size(); i++) { staticName.emplace_back(fullpath[i]); } staticName.emplace_back(fieldName[0]); ToRelease pTypeObject; if (S_OK == pEvalHelpers->CreatTypeObjectStaticConstructor(pThread, pType, &pTypeObject)) { if (SUCCEEDED(FollowFields(pEvalHelpers, pThread, frameLevel, pTypeObject, Evaluator::ValueIsClass, staticName, 0, ppResult, resultSetterData, evalFlags))) return S_OK; } trim = true; continue; } ToRelease pTypeObject; IfFailRet(pEvalHelpers->CreatTypeObjectStaticConstructor(pThread, pType, &pTypeObject)); if (Status == S_OK && // type have static members (S_FALSE if type don't have static members) SUCCEEDED(FollowFields(pEvalHelpers, pThread, frameLevel, pTypeObject, Evaluator::ValueIsClass, fieldName, 0, ppResult, resultSetterData, evalFlags))) return S_OK; trim = true; } return E_FAIL; } static HRESULT InternalResolveIdentifiers(Modules *pModules, EvalHelpers *pEvalHelpers, ICorDebugThread *pThread, FrameLevel frameLevel, ICorDebugValue *pInputValue, Evaluator::SetterData *inputSetterData, std::vector &identifiers, ICorDebugValue **ppResultValue, std::unique_ptr *resultSetterData, ICorDebugType **ppResultType, int evalFlags) { if (pInputValue && identifiers.empty()) { pInputValue->AddRef(); *ppResultValue = pInputValue; if (inputSetterData && resultSetterData) (*resultSetterData).reset(new Evaluator::SetterData(*inputSetterData)); return S_OK; } else if (pInputValue) { return FollowFields(pEvalHelpers, pThread, frameLevel, pInputValue, Evaluator::ValueIsVariable, identifiers, 0, ppResultValue, resultSetterData, evalFlags); } HRESULT Status; int nextIdentifier = 0; ToRelease pResolvedValue; ToRelease pThisValue; if (identifiers.at(nextIdentifier) == "$exception") { IfFailRet(pThread->GetCurrentException(&pResolvedValue)); if (pResolvedValue == nullptr) return E_FAIL; } else { // Note, we use E_ABORT error code as fast way to exit from stack vars walk routine here. if (FAILED(Status = InternalWalkStackVars(pModules, pThread, frameLevel, [&](const std::string &name, Evaluator::GetValueCallback getValue) -> HRESULT { if (name == "this") { if (FAILED(getValue(&pThisValue, evalFlags)) || !pThisValue) return S_OK; if (name == identifiers.at(nextIdentifier)) return E_ABORT; // Fast way to exit from stack vars walk routine. } else if (name == identifiers.at(nextIdentifier)) { if (FAILED(getValue(&pResolvedValue, evalFlags)) || !pResolvedValue) return S_OK; return E_ABORT; // Fast way to exit from stack vars walk routine. } return S_OK; })) && !pThisValue && !pResolvedValue) // Check, that we have fast exit instead of real error. { return Status; } } if (!pResolvedValue && pThisValue) // check this/this.* { if (identifiers[nextIdentifier] == "this") nextIdentifier++; // skip first identifier with "this" (we have it in pThisValue), check rest if (SUCCEEDED(FollowFields(pEvalHelpers, pThread, frameLevel, pThisValue, Evaluator::ValueIsVariable, identifiers, nextIdentifier, &pResolvedValue, resultSetterData, evalFlags))) { *ppResultValue = pResolvedValue.Detach(); return S_OK; } } if (!pResolvedValue) // check statics in nested classes { ToRelease pFrame; IfFailRet(GetFrameAt(pThread, frameLevel, &pFrame)); if (pFrame == nullptr) return E_FAIL; std::string methodClass; std::string methodName; TypePrinter::GetTypeAndMethod(pFrame, methodClass, methodName); if (SUCCEEDED(FollowNestedFindValue(pModules, pEvalHelpers, pThread, frameLevel, methodClass, identifiers, &pResolvedValue, resultSetterData, evalFlags))) { *ppResultValue = pResolvedValue.Detach(); return S_OK; } if (ppResultType && SUCCEEDED(FollowNestedFindType(pThread, pModules, methodClass, identifiers, ppResultType))) return S_OK; } Evaluator::ValueKind valueKind; if (pResolvedValue) { nextIdentifier++; if (nextIdentifier == (int)identifiers.size()) { *ppResultValue = pResolvedValue.Detach(); return S_OK; } valueKind = Evaluator::ValueIsVariable; } else { ToRelease pType; IfFailRet(EvalUtils::FindType(identifiers, nextIdentifier, pThread, pModules, nullptr, &pType)); IfFailRet(pEvalHelpers->CreatTypeObjectStaticConstructor(pThread, pType, &pResolvedValue)); // Identifiers resolved into type, not value. In case type could be result - provide type directly as result. // In this way caller will know, that no object instance here (should operate with static members/methods only). if (ppResultType && nextIdentifier == (int)identifiers.size()) { *ppResultType = pType.Detach(); return S_OK; } if (Status == S_FALSE || // type don't have static members, nothing explore here nextIdentifier == (int)identifiers.size()) // pResolvedValue is temporary object for members exploration, can't be result return E_INVALIDARG; valueKind = Evaluator::ValueIsClass; } ToRelease pValue(std::move(pResolvedValue)); IfFailRet(FollowFields(pEvalHelpers, pThread, frameLevel, pValue, valueKind, identifiers, nextIdentifier, &pResolvedValue, resultSetterData, evalFlags)); *ppResultValue = pResolvedValue.Detach(); return S_OK; } HRESULT Evaluator::ResolveIdentifiers(ICorDebugThread *pThread, FrameLevel frameLevel, ICorDebugValue *pInputValue, SetterData *inputSetterData, std::vector &identifiers, ICorDebugValue **ppResultValue, std::unique_ptr *resultSetterData, ICorDebugType **ppResultType, int evalFlags) { return InternalResolveIdentifiers(m_sharedModules.get(), m_sharedEvalHelpers.get(), pThread, frameLevel, pInputValue, inputSetterData, identifiers, ppResultValue, resultSetterData, ppResultType, evalFlags); } HRESULT Evaluator::LookupExtensionMethods(ICorDebugType *pType, const std::string &methodName, std::vector &methodArgs, std::vector &methodGenerics, ICorDebugFunction** ppCorFunc) { static const char* attributeName = "System.Runtime.CompilerServices.ExtensionAttribute..ctor"; HRESULT Status; std::vector typeGenerics; ToRelease paramTypes; if (SUCCEEDED(pType->EnumerateTypeParameters(¶mTypes))) { ULONG fetched = 0; ToRelease pCurrentTypeParam; while (SUCCEEDED(paramTypes->Next(1, &pCurrentTypeParam, &fetched)) && fetched == 1) { Evaluator::ArgElementType argElType; pCurrentTypeParam->GetType(&argElType.corType); if(argElType.corType == ELEMENT_TYPE_VALUETYPE || argElType.corType == ELEMENT_TYPE_CLASS) IfFailRet(TypePrinter::NameForTypeByType(pCurrentTypeParam, argElType.typeName)); typeGenerics.emplace_back(argElType); pCurrentTypeParam.Free(); } } m_sharedModules->ForEachModule([&](ICorDebugModule *pModule)->HRESULT { ULONG typesCnt = 0; HCORENUM fTypeEnum = NULL; mdTypeDef mdType = mdTypeDefNil; ToRelease pMDUnknown; IfFailRet(pModule->GetMetaDataInterface(IID_IMetaDataImport, &pMDUnknown)); ToRelease pMD; IfFailRet(pMDUnknown->QueryInterface(IID_IMetaDataImport, (LPVOID*) &pMD)); while (SUCCEEDED(pMD->EnumTypeDefs(&fTypeEnum, &mdType, 1, &typesCnt)) && typesCnt != 0) { std::string typeName; if (!HasAttribute(pMD, mdType, attributeName)) continue; if(FAILED(TypePrinter::NameForToken(mdType, pMD, typeName, false, nullptr))) continue; HCORENUM fFuncEnum = NULL; mdMethodDef mdMethod = mdMethodDefNil; ULONG methodsCnt = 0; while (SUCCEEDED(pMD->EnumMethods(&fFuncEnum, mdType, &mdMethod, 1, &methodsCnt)) && methodsCnt != 0) { mdTypeDef memTypeDef; ULONG nameLen; WCHAR szFuncName[mdNameLen] = {0}; PCCOR_SIGNATURE pSig = NULL; ULONG cbSig = 0; if(FAILED(pMD->GetMethodProps(mdMethod, &memTypeDef, szFuncName, _countof(szFuncName), &nameLen, nullptr, &pSig, &cbSig, nullptr, nullptr))) continue; if (!HasAttribute(pMD, mdMethod, attributeName)) continue; std::string fullName = to_utf8(szFuncName); if (fullName != methodName) continue; ULONG cParams; // Count of signature parameters. ULONG gParams; // count of generic parameters; ULONG elementSize; ULONG convFlags; // 1. calling convention for MethodDefSig: // [[HASTHIS] [EXPLICITTHIS]] (DEFAULT|VARARG|GENERIC GenParamCount) elementSize = CorSigUncompressData(pSig, &convFlags); pSig += elementSize; // 2. if method has generic params, count them if (convFlags & SIG_METHOD_GENERIC) { elementSize = CorSigUncompressData(pSig, &gParams); pSig += elementSize; } // 3. count of params elementSize = CorSigUncompressData(pSig, &cParams); pSig += elementSize; // 4. return type Evaluator::ArgElementType returnElementType; if(FAILED(ParseElementType(pMD, &pSig, returnElementType, typeGenerics, methodGenerics))) continue; // 5. get next element from method signature std::vector argElementTypes(cParams); for (ULONG i = 0; i < cParams; ++i) { if(FAILED(ParseElementType(pMD, &pSig, argElementTypes[i], typeGenerics, methodGenerics))) break; } std::string typeName; CorElementType ty; if(FAILED(pType->GetType(&ty))) continue; if(FAILED(TypePrinter::NameForTypeByType(pType, typeName))) continue; if (ty == ELEMENT_TYPE_CLASS || ty == ELEMENT_TYPE_VALUETYPE) { if (typeName != argElementTypes[0].typeName) { // if type names don't match check implemented interfaces names ToRelease iCorClass; if(FAILED(pType->GetClass(&iCorClass))) continue; ToRelease iCorModule; if(FAILED(iCorClass->GetModule(&iCorModule))) continue; mdTypeDef metaTypeDef; if(FAILED(iCorClass->GetToken(&metaTypeDef))) continue; ToRelease pMDUnk; if(FAILED(iCorModule->GetMetaDataInterface(IID_IMetaDataImport, &pMDUnk))) continue; ToRelease pMDI; if(FAILED(pMDUnk->QueryInterface(IID_IMetaDataImport, (LPVOID*) &pMDI))) continue; HCORENUM ifEnum = NULL; mdInterfaceImpl ifaceImpl; ULONG pcImpls = 0; while (SUCCEEDED(pMDI->EnumInterfaceImpls(&ifEnum, metaTypeDef, &ifaceImpl, 1, &pcImpls)) && pcImpls != 0) { mdTypeDef tkClass; mdToken tkIface; PCCOR_SIGNATURE pSig = NULL; ULONG pcbSig; Evaluator::ArgElementType ifaceElementType; if(FAILED(pMDI->GetInterfaceImplProps(ifaceImpl, &tkClass, &tkIface))) continue; if(TypeFromToken(tkIface) == mdtTypeSpec) { if(FAILED(pMDI->GetTypeSpecFromToken(tkIface, &pSig, &pcbSig))) continue; if(FAILED(ParseElementType(pMDI, &pSig, ifaceElementType, typeGenerics, methodGenerics, false))) continue; } else { if (FAILED(TypePrinter::NameForToken(tkIface, pMDI, ifaceElementType.typeName, true, nullptr))) continue; } if(ifaceElementType.typeName == argElementTypes[0].typeName && methodArgs.size() + 1 == argElementTypes.size()) { bool found = true; for(unsigned int i = 0; i < methodArgs.size(); i++) { if(methodArgs[i].corType != argElementTypes[i+1].corType) { found = false; break; } } if(found) { pModule->GetFunctionFromToken(mdMethod, ppCorFunc); pMDI->CloseEnum(ifEnum); pMD->CloseEnum(fFuncEnum); pMD->CloseEnum(fTypeEnum); return E_ABORT; } } } pMDI->CloseEnum(ifEnum); } } else if (ty != argElementTypes[0].corType || (methodArgs.size() + 1 != argElementTypes.size())) { continue; } else { bool found = true; for(unsigned int i = 0; i < methodArgs.size(); i++) { if(methodArgs[i].corType != argElementTypes[i+1].corType) { found = false; break; } } if(found) { pModule->GetFunctionFromToken(mdMethod, ppCorFunc); pMD->CloseEnum(fFuncEnum); pMD->CloseEnum(fTypeEnum); return E_ABORT; } } } pMD->CloseEnum(fFuncEnum); } pMD->CloseEnum(fTypeEnum); return S_OK; }); return S_OK; } } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/evaluator.h000066400000000000000000000116461457701673000207610ustar00rootroot00000000000000// Copyright (c) 2020 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #pragma once #include "cor.h" #include "cordebug.h" #include #include #include #include #include #include "interfaces/types.h" #include "utils/torelease.h" namespace netcoredbg { class Modules; class EvalHelpers; class EvalStackMachine; class Evaluator { public: struct ArgElementType { CorElementType corType; std::string typeName; ArgElementType() : corType(ELEMENT_TYPE_END) {} ArgElementType(CorElementType t, std::string n) { corType = t; typeName = n; } bool isAlias (const CorElementType type1, const CorElementType type2, const std::string& name2); bool areEqual(const ArgElementType& arg); inline bool operator==(const ArgElementType& arg) { return areEqual(arg); } inline bool operator!=(const ArgElementType& arg) { return !areEqual(arg); } }; typedef ArgElementType ReturnElementType; struct SetterData { ToRelease thisValue; ToRelease propertyType; ToRelease setterFunction; SetterData(ICorDebugValue *pValue, ICorDebugType *pType, ICorDebugFunction *pFunction) { Set(pValue, pType, pFunction); }; SetterData(SetterData &setterData) { Set(setterData.thisValue.GetPtr(), setterData.propertyType.GetPtr(), setterData.setterFunction.GetPtr()); }; void Set(ICorDebugValue *pValue, ICorDebugType *pType, ICorDebugFunction *pFunction) { if (pValue) pValue->AddRef(); thisValue = pValue; if (pType) pType->AddRef(); propertyType = pType; if (pFunction) pFunction->AddRef(); setterFunction = pFunction; } }; typedef std::function GetValueCallback; typedef std::function WalkMembersCallback; typedef std::function WalkStackVarsCallback; typedef std::function GetFunctionCallback; typedef std::function&,GetFunctionCallback)> WalkMethodsCallback; enum ValueKind { ValueIsScope, ValueIsClass, ValueIsVariable }; Evaluator(std::shared_ptr &sharedModules, std::shared_ptr &sharedEvalHelpers, std::shared_ptr &sharedEvalStackMachine) : m_sharedModules(sharedModules), m_sharedEvalHelpers(sharedEvalHelpers), m_sharedEvalStackMachine(sharedEvalStackMachine) {} HRESULT ResolveIdentifiers( ICorDebugThread *pThread, FrameLevel frameLevel, ICorDebugValue *pInputValue, SetterData *inputSetterData, std::vector &identifiers, ICorDebugValue **ppResultValue, std::unique_ptr *resultSetterData, ICorDebugType **ppResultType, int evalFlags); HRESULT WalkMembers( ICorDebugValue *pValue, ICorDebugThread *pThread, FrameLevel frameLevel, bool provideSetterData, WalkMembersCallback cb); HRESULT WalkStackVars( ICorDebugThread *pThread, FrameLevel frameLevel, WalkStackVarsCallback cb); HRESULT Evaluator::GetMethodClass( ICorDebugThread *pThread, FrameLevel frameLevel, std::string &methodClass, bool &thisParam); HRESULT Evaluator::LookupExtensionMethods( ICorDebugType *pType, const std::string &methodName, std::vector &methodArgs, std::vector &methodGenerics, ICorDebugFunction** ppCorFunc); HRESULT GetElement(ICorDebugValue *pInputValue, std::vector &indexes, ICorDebugValue **ppResultValue); HRESULT WalkMethods(ICorDebugType *pInputType, ICorDebugType **ppResultType, std::vector &methodGenerics, WalkMethodsCallback cb); HRESULT WalkMethods(ICorDebugValue *pInputTypeValue, WalkMethodsCallback cb); HRESULT SetValue(ICorDebugThread *pThread, FrameLevel frameLevel, ICorDebugValue *pValue, SetterData *setterData, const std::string &value, int evalFlags, std::string &output); ArgElementType GetElementTypeByTypeName(const std::string typeName); private: std::shared_ptr m_sharedModules; std::shared_ptr m_sharedEvalHelpers; std::shared_ptr m_sharedEvalStackMachine; }; } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/evalutils.cpp000066400000000000000000000237131457701673000213200ustar00rootroot00000000000000// Copyright (c) 2021 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #include "debugger/evalutils.h" #include "utils/utf.h" #include "metadata/modules.h" #include "metadata/typeprinter.h" namespace netcoredbg { namespace EvalUtils { std::vector ParseGenericParams(const std::string &identifier, std::string &typeName) { std::vector result; std::size_t start = identifier.find('<'); if (start == std::string::npos) { typeName = identifier; return result; } int paramDepth = 0; bool inArray = false; result.push_back(""); for (std::size_t i = start; i < identifier.size(); i++) { char c = identifier.at(i); switch(c) { case ',': if (paramDepth == 1 && !inArray) { result.push_back(""); continue; } break; case '[': inArray = true; break; case ']': inArray = false; break; case '<': paramDepth++; if (paramDepth == 1) continue; break; case '>': paramDepth--; if (paramDepth == 0) continue; break; default: break; } result.back() += c; } typeName = identifier.substr(0, start) + '`' + std::to_string(result.size()); return result; } static std::vector GatherParameters(const std::vector &identifiers, int indexEnd) { std::vector result; for (int i = 0; i < indexEnd; i++) { std::string typeName; std::vector params = ParseGenericParams(identifiers[i], typeName); result.insert(result.end(), params.begin(), params.end()); } return result; } static mdTypeDef GetTypeTokenForName(IMetaDataImport *pMD, mdTypeDef tkEnclosingClass, const std::string &name) { mdTypeDef typeToken = mdTypeDefNil; pMD->FindTypeDefByName(reinterpret_cast(to_utf16(name).c_str()), tkEnclosingClass, &typeToken); return typeToken; } static HRESULT FindTypeInModule(ICorDebugModule *pModule, const std::vector &identifiers, int &nextIdentifier, mdTypeDef &typeToken) { HRESULT Status; ToRelease pMDUnknown; ToRelease pMD; IfFailRet(pModule->GetMetaDataInterface(IID_IMetaDataImport, &pMDUnknown)); IfFailRet(pMDUnknown->QueryInterface(IID_IMetaDataImport, (LPVOID*) &pMD)); std::string currentTypeName; // Search for type in module for (int i = nextIdentifier; i < (int)identifiers.size(); i++) { std::string name; ParseGenericParams(identifiers[i], name); currentTypeName += (currentTypeName.empty() ? "" : ".") + name; typeToken = GetTypeTokenForName(pMD, mdTypeDefNil, currentTypeName); if (typeToken != mdTypeDefNil) { nextIdentifier = i + 1; break; } } if (typeToken == mdTypeDefNil) // type not found, continue search in next module return E_FAIL; // Resolve nested class for (int j = nextIdentifier; j < (int)identifiers.size(); j++) { std::string name; ParseGenericParams(identifiers[j], name); mdTypeDef classToken = GetTypeTokenForName(pMD, typeToken, name); if (classToken == mdTypeDefNil) break; typeToken = classToken; nextIdentifier = j + 1; } return S_OK; } HRESULT GetType(const std::string &typeName, ICorDebugThread *pThread, Modules *pModules, ICorDebugType **ppType) { HRESULT Status; std::vector ranks; std::vector classIdentifiers = ParseType(typeName, ranks); if (classIdentifiers.size() == 1) classIdentifiers[0] = TypePrinter::RenameToSystem(classIdentifiers[0]); ToRelease pType; int nextClassIdentifier = 0; IfFailRet(FindType(classIdentifiers, nextClassIdentifier, pThread, pModules, nullptr, &pType)); if (!ranks.empty()) { ToRelease pAppDomain2; ToRelease pAppDomain; IfFailRet(pThread->GetAppDomain(&pAppDomain)); IfFailRet(pAppDomain->QueryInterface(IID_ICorDebugAppDomain2, (LPVOID*) &pAppDomain2)); for (auto irank = ranks.rbegin(); irank != ranks.rend(); ++irank) { ToRelease pElementType(std::move(pType)); IfFailRet(pAppDomain2->GetArrayOrPointerType( *irank > 1 ? ELEMENT_TYPE_ARRAY : ELEMENT_TYPE_SZARRAY, *irank, pElementType, &pType)); // NOLINT(clang-analyzer-cplusplus.Move) } } *ppType = pType.Detach(); return S_OK; } std::vector ParseType(const std::string &expression, std::vector &ranks) { std::vector result; int paramDepth = 0; result.emplace_back(); for (char c : expression) { switch(c) { case '.': if (paramDepth == 0) { result.emplace_back(); continue; } break; case '[': if (paramDepth == 0) { ranks.push_back(1); continue; } break; case ']': if (paramDepth == 0) continue; break; case ',': if (paramDepth == 0) { if (!ranks.empty()) ranks.back()++; continue; } break; case '<': paramDepth++; break; case '>': paramDepth--; break; case ' ': continue; default: break; } result.back() += c; } return result; } static HRESULT ResolveParameters( const std::vector ¶ms, ICorDebugThread *pThread, Modules *pModules, std::vector< ToRelease > &types) { HRESULT Status; for (auto &p : params) { ICorDebugType *tmpType; IfFailRet(EvalUtils::GetType(p, pThread, pModules, &tmpType)); types.emplace_back(tmpType); } return S_OK; } HRESULT FindType(const std::vector &identifiers, int &nextIdentifier, ICorDebugThread *pThread, Modules *pModules, ICorDebugModule *pModule, ICorDebugType **ppType, ICorDebugModule **ppModule) { HRESULT Status; if (pModule) pModule->AddRef(); ToRelease pTypeModule(pModule); mdTypeDef typeToken = mdTypeDefNil; if (!pTypeModule) { pModules->ForEachModule([&](ICorDebugModule *pModule)->HRESULT { if (typeToken != mdTypeDefNil) // already found return S_OK; if (SUCCEEDED(FindTypeInModule(pModule, identifiers, nextIdentifier, typeToken))) { pModule->AddRef(); pTypeModule = pModule; } return S_OK; }); } else { FindTypeInModule(pTypeModule, identifiers, nextIdentifier, typeToken); } if (typeToken == mdTypeDefNil) return E_FAIL; if (ppType) { std::vector params = GatherParameters(identifiers, nextIdentifier); std::vector< ToRelease > types; IfFailRet(ResolveParameters(params, pThread, pModules, types)); ToRelease pClass; IfFailRet(pTypeModule->GetClassFromToken(typeToken, &pClass)); ToRelease pClass2; IfFailRet(pClass->QueryInterface(IID_ICorDebugClass2, (LPVOID*) &pClass2)); ToRelease pMDUnknown; IfFailRet(pTypeModule->GetMetaDataInterface(IID_IMetaDataImport, &pMDUnknown)); ToRelease pMD; IfFailRet(pMDUnknown->QueryInterface(IID_IMetaDataImport, (LPVOID*) &pMD)); DWORD flags; ULONG nameLen; mdToken tkExtends; IfFailRet(pMD->GetTypeDefProps(typeToken, nullptr, 0, &nameLen, &flags, &tkExtends)); std::string eTypeName; IfFailRet(TypePrinter::NameForToken(tkExtends, pMD, eTypeName, true, nullptr)); bool isValueType = eTypeName == "System.ValueType" || eTypeName == "System.Enum"; CorElementType et = isValueType ? ELEMENT_TYPE_VALUETYPE : ELEMENT_TYPE_CLASS; ToRelease pType; IfFailRet(pClass2->GetParameterizedType(et, static_cast(types.size()), (ICorDebugType **)types.data(), &pType)); *ppType = pType.Detach(); } if (ppModule) *ppModule = pTypeModule.Detach(); return S_OK; } } // namespace EvalUtils } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/evalutils.h000066400000000000000000000016021457701673000207560ustar00rootroot00000000000000// Copyright (c) 2021 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #pragma once #include "cor.h" #include "cordebug.h" #include #include namespace netcoredbg { class Modules; namespace EvalUtils { HRESULT GetType(const std::string &typeName, ICorDebugThread *pThread, Modules *pModules, ICorDebugType **ppType); std::vector ParseType(const std::string &expression, std::vector &ranks); HRESULT FindType(const std::vector &identifiers, int &nextIdentifier, ICorDebugThread *pThread, Modules *pModules, ICorDebugModule *pModule, ICorDebugType **ppType, ICorDebugModule **ppModule = nullptr); std::vector ParseGenericParams(const std::string &identifier, std::string &typeName); } } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/evalwaiter.cpp000066400000000000000000000310171457701673000214470ustar00rootroot00000000000000// Copyright (c) 2021 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #include "debugger/evalwaiter.h" #include "utils/platform.h" #include "debugger/threads.h" #ifdef INTEROP_DEBUGGING #include "debugger/interop_debugging.h" #endif // INTEROP_DEBUGGING namespace netcoredbg { void EvalWaiter::NotifyEvalComplete(ICorDebugThread *pThread, ICorDebugEval *pEval) { std::lock_guard lock(m_evalResultMutex); if (!pThread) { m_evalResult.reset(nullptr); return; } DWORD threadId = 0; pThread->GetID(&threadId); std::unique_ptr ppEvalResult(new evalResultData_t); if (pEval) { // CORDBG_S_FUNC_EVAL_HAS_NO_RESULT: Some Func evals will lack a return value, such as those whose return type is void. (*ppEvalResult).Status = pEval->GetResult(&((*ppEvalResult).iCorEval)); } if (!m_evalResult || m_evalResult->threadId != threadId) return; m_evalResult->promiseValue.set_value(std::move(ppEvalResult)); m_evalResult.reset(nullptr); } bool EvalWaiter::IsEvalRunning() { std::lock_guard lock(m_evalResultMutex); return !!m_evalResult; } #ifdef INTEROP_DEBUGGING // Return thread ID for running evaluation, or 0 in case no evaluation running now. DWORD EvalWaiter::GetEvalRunningThreadID() { std::lock_guard lock(m_evalResultMutex); return !!m_evalResult ? m_evalResult->threadId : 0; } void EvalWaiter::SetInteropDebugger(std::shared_ptr &sharedInteropDebugger) { m_sharedInteropDebugger = sharedInteropDebugger; } void EvalWaiter::ResetInteropDebugger() { m_sharedInteropDebugger.reset(); } #endif // INTEROP_DEBUGGING void EvalWaiter::CancelEvalRunning() { std::lock_guard lock(m_evalResultMutex); if (!m_evalResult) return; ToRelease iCorEval2; if (SUCCEEDED(m_evalResult->pEval->Abort()) || (SUCCEEDED(m_evalResult->pEval->QueryInterface(IID_ICorDebugEval2, (LPVOID*) &iCorEval2)) && SUCCEEDED(iCorEval2->RudeAbort()))) m_evalCanceled = true; } std::future > EvalWaiter::RunEval( HRESULT &Status, ICorDebugProcess *pProcess, ICorDebugThread *pThread, ICorDebugEval *pEval, WaitEvalResultCallback cbSetupEval) { std::promise > p; auto f = p.get_future(); if (!f.valid()) { LOGE("get_future() returns not valid promise object"); } DWORD threadId = 0; pThread->GetID(&threadId); std::lock_guard lock(m_evalResultMutex); assert(!m_evalResult); // We can have only 1 eval, and previous must be completed. m_evalResult.reset(new evalResult_t{threadId, pEval, std::move(p)}); // We don't have easy way to abort setuped eval in case of some error in debugger API, // try setup eval only if all is OK right before we run process. if (FAILED(Status = cbSetupEval(pEval))) { LOGE("Setup eval failed, %0x", Status); m_evalResult.reset(nullptr); } else if (FAILED(Status = pProcess->Continue(0))) { LOGE("Continue() failed, %0x", Status); m_evalResult.reset(nullptr); } return f; } ICorDebugEval *EvalWaiter::FindEvalForThread(ICorDebugThread *pThread) { std::lock_guard lock(m_evalResultMutex); DWORD threadId = 0; if (FAILED(pThread->GetID(&threadId)) || !m_evalResult) return nullptr; return m_evalResult->threadId == threadId ? m_evalResult->pEval : nullptr; } HRESULT EvalWaiter::WaitEvalResult(ICorDebugThread *pThread, ICorDebugValue **ppEvalResult, WaitEvalResultCallback cbSetupEval) { // Important! Evaluation should be proceed only for 1 thread. std::lock_guard lock(m_waitEvalResultMutex); // During evaluation could be implicitly executing user code, that could provoke callback calls like - breakpoints, exceptions, etc. // Make sure, that all managed callbacks ignore standard logic during evaluation and don't pause/interrupt managed code execution. HRESULT Status; ToRelease iCorProcess; IfFailRet(pThread->GetProcess(&iCorProcess)); if (!iCorProcess) return E_FAIL; DWORD evalThreadId = 0; IfFailRet(pThread->GetID(&evalThreadId)); #ifdef INTEROP_DEBUGGING assert(!!m_sharedInteropDebugger); if (m_sharedInteropDebugger->IsManagedThreadWasStoppedInNativeCode((pid_t)evalThreadId)) return COR_E_THREADSTATE; #endif // INTEROP_DEBUGGING // Note, we need suspend during eval all managed threads, that not used for eval (delegates, reverse pinvokes, managed threads). auto ChangeThreadsState = [&](CorDebugThreadState state) { ToRelease iCorThreadEnum; iCorProcess->EnumerateThreads(&iCorThreadEnum); ULONG fetched = 0; ToRelease iCorThread; while (SUCCEEDED(iCorThreadEnum->Next(1, &iCorThread, &fetched)) && fetched == 1) { DWORD tid = 0; if (SUCCEEDED(iCorThread->GetID(&tid)) && evalThreadId != tid) { if (FAILED(iCorThread->SetDebugState(state))) { if (state == THREAD_SUSPEND) LOGW("%s %s", "SetDebugState(THREAD_SUSPEND) during eval setup failed.", "This may change the state of the process and any breakpoints and exceptions encountered will be skipped."); else LOGW("SetDebugState(THREAD_RUN) during eval failed. Process state was not restored."); } } iCorThread.Free(); } }; bool evalTimeOut = false; auto WaitResult = [&]() -> HRESULT { ChangeThreadsState(THREAD_SUSPEND); ToRelease iCorEval; IfFailRet(pThread->CreateEval(&iCorEval)); try { auto f = RunEval(Status, iCorProcess, pThread, iCorEval, cbSetupEval); IfFailRet(Status); if (!f.valid()) return E_FAIL; // NOTE // MSVS 2017 debugger and newer use config file // C:\Program Files (x86)\Microsoft Visual Studio\YYYY\VERSION\Common7\IDE\Profiles\CSharp.vssettings // by default NormalEvalTimeout is 5000 milliseconds // // TODO add timeout configuration feature (care about VSCode, MSVS with Tizen plugin, standalone usage) std::future_status timeoutStatus = f.wait_for(std::chrono::milliseconds(5000)); if (timeoutStatus == std::future_status::timeout) { LOGW("Evaluation timed out."); LOGW("%s %s", "To prevent an unsafe abort when evaluating, all threads were allowed to run.", "This may have changed the state of the process and any breakpoints and exceptions encountered have been skipped."); // NOTE // All CoreCLR releases at least till version 3.1.3, don't have proper x86 implementation for ICorDebugEval::Abort(). // This issue looks like CoreCLR terminate managed process execution instead of abort evaluation. // In this case we have same behaviour as MS vsdbg and MSVS C# debugger - run all managed threads and try to abort eval by any cost. // Ignore errors here, this our last chance prevent debugger hangs. iCorProcess->Stop(0); ChangeThreadsState(THREAD_RUN); if (FAILED(iCorEval->Abort())) { ToRelease iCorEval2; if (SUCCEEDED(iCorEval->QueryInterface(IID_ICorDebugEval2, (LPVOID*) &iCorEval2))) iCorEval2->RudeAbort(); } evalTimeOut = true; iCorProcess->Continue(0); } // Wait for 5 more seconds, give `Abort()` a chance. timeoutStatus = f.wait_for(std::chrono::milliseconds(5000)); if (timeoutStatus == std::future_status::timeout) { // Looks like can't be aborted, this is fatal error for debugger (debuggee have inconsistent state now). iCorProcess->Stop(0); m_evalResultMutex.lock(); m_evalResult.reset(nullptr); m_evalResultMutex.unlock(); LOGE("Fatal error, eval abort failed."); return E_UNEXPECTED; } auto evalResult = f.get(); IfFailRet(evalResult.get()->Status); if (!ppEvalResult) return S_OK; *ppEvalResult = evalResult.get()->iCorEval.Detach(); return evalResult.get()->Status; } catch (const std::future_error&) { return E_FAIL; } }; SetEnableCustomNotification(iCorProcess, TRUE); m_evalCanceled = false; m_evalCrossThreadDependency = false; HRESULT ret = WaitResult(); SetEnableCustomNotification(iCorProcess, FALSE); if (ret == CORDBG_S_FUNC_EVAL_ABORTED) { if (m_evalCrossThreadDependency) ret = CORDBG_E_CANT_CALL_ON_THIS_THREAD; else ret = m_evalCanceled ? COR_E_OPERATIONCANCELED : COR_E_TIMEOUT; } // In this case we have same behaviour as MS vsdbg and MSVS C# debugger - in case it was aborted with timeout, show proper error. else if (evalTimeOut) { ret = (ret == E_UNEXPECTED) ? E_UNEXPECTED : COR_E_TIMEOUT; } ChangeThreadsState(THREAD_RUN); return ret; } HRESULT EvalWaiter::ManagedCallbackCustomNotification(ICorDebugThread *pThread) { // NOTE // All CoreCLR releases at least till version 3.1.3, don't have proper x86 implementation for ICorDebugEval::Abort(). // This issue looks like CoreCLR terminate managed process execution instead of abort evaluation. // Note, could by only one eval running, but we need ignore custom notification from threads created during eval. // In this case we have same behaviour as MSVS C# debugger (ATM vsdbg don't support Debugger.NotifyOfCrossThreadDependency). ICorDebugEval *pEval = FindEvalForThread(pThread); if (pEval == nullptr) return S_OK; HRESULT Status; ToRelease iCorEval2; if (FAILED(Status = pEval->Abort()) && (FAILED(Status = pEval->QueryInterface(IID_ICorDebugEval2, (LPVOID*) &iCorEval2)) || FAILED(Status = iCorEval2->RudeAbort()))) { LOGE("Can't abort evaluation in custom notification callback, %0x", Status); return Status; } m_evalCrossThreadDependency = true; return S_OK; } HRESULT EvalWaiter::SetupCrossThreadDependencyNotificationClass(ICorDebugModule *pModule) { HRESULT Status; ToRelease pMDUnknown; IfFailRet(pModule->GetMetaDataInterface(IID_IMetaDataImport, &pMDUnknown)); ToRelease pMD; IfFailRet(pMDUnknown->QueryInterface(IID_IMetaDataImport, (LPVOID*) &pMD)); // in order to make code simple and clear, we don't check enclosing classes with recursion here // since we know behaviour for sure, just find "System.Diagnostics.Debugger" first mdTypeDef typeDefParent = mdTypeDefNil; static const WCHAR strParentTypeDef[] = W("System.Diagnostics.Debugger"); IfFailRet(pMD->FindTypeDefByName(strParentTypeDef, mdTypeDefNil, &typeDefParent)); mdTypeDef typeDef = mdTypeDefNil; static const WCHAR strTypeDef[] = W("CrossThreadDependencyNotification"); IfFailRet(pMD->FindTypeDefByName(strTypeDef, typeDefParent, &typeDef)); m_iCorCrossThreadDependencyNotification.Free(); // allow re-setup if need return pModule->GetClassFromToken(typeDef, &m_iCorCrossThreadDependencyNotification); } HRESULT EvalWaiter::SetEnableCustomNotification(ICorDebugProcess *pProcess, BOOL fEnable) { HRESULT Status; ToRelease pProcess3; IfFailRet(pProcess->QueryInterface(IID_ICorDebugProcess3, (LPVOID*) &pProcess3)); return pProcess3->SetEnableCustomNotification(m_iCorCrossThreadDependencyNotification, fEnable); } } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/evalwaiter.h000066400000000000000000000064541457701673000211230ustar00rootroot00000000000000// Copyright (c) 2021 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #pragma once #include "cor.h" #include "cordebug.h" #include #include #include "utils/torelease.h" namespace netcoredbg { class Threads; #ifdef INTEROP_DEBUGGING namespace InteropDebugging { class InteropDebugger; } #endif // INTEROP_DEBUGGING class EvalWaiter { public: typedef std::function WaitEvalResultCallback; EvalWaiter() : m_evalCanceled(false), m_evalCrossThreadDependency(false) {} bool IsEvalRunning(); #ifdef INTEROP_DEBUGGING DWORD GetEvalRunningThreadID(); void SetInteropDebugger(std::shared_ptr &sharedInteropDebugger); void ResetInteropDebugger(); #endif // INTEROP_DEBUGGING void CancelEvalRunning(); ICorDebugEval *FindEvalForThread(ICorDebugThread *pThread); HRESULT WaitEvalResult(ICorDebugThread *pThread, ICorDebugValue **ppEvalResult, WaitEvalResultCallback cbSetupEval); // Should be called by ICorDebugManagedCallback. void NotifyEvalComplete(ICorDebugThread *pThread, ICorDebugEval *pEval); HRESULT ManagedCallbackCustomNotification(ICorDebugThread *pThread); HRESULT SetupCrossThreadDependencyNotificationClass(ICorDebugModule *pModule); private: bool m_evalCanceled; bool m_evalCrossThreadDependency; ToRelease m_iCorCrossThreadDependencyNotification; HRESULT SetEnableCustomNotification(ICorDebugProcess *pProcess, BOOL fEnable); #ifdef INTEROP_DEBUGGING std::shared_ptr m_sharedInteropDebugger; #endif // INTEROP_DEBUGGING struct evalResultData_t { ToRelease iCorEval; HRESULT Status = E_FAIL; }; struct evalResult_t { evalResult_t() = delete; evalResult_t(DWORD threadId_, ICorDebugEval *pEval_, const std::promise< std::unique_ptr > &promiseValue_) = delete; evalResult_t(const evalResult_t &B) = delete; evalResult_t& operator = (const evalResult_t &B) = delete; evalResult_t& operator = (evalResult_t &&B) = delete; evalResult_t(DWORD threadId_, ICorDebugEval *pEval_, std::promise< std::unique_ptr > &&promiseValue_) : threadId(threadId_), pEval(pEval_), promiseValue(std::move(promiseValue_)) {} evalResult_t(evalResult_t &&B) : threadId(B.threadId), pEval(B.pEval), promiseValue(std::move(B.promiseValue)) {} ~evalResult_t() = default; DWORD threadId; ICorDebugEval *pEval; std::promise< std::unique_ptr > promiseValue; }; std::mutex m_waitEvalResultMutex; std::mutex m_evalResultMutex; std::unique_ptr m_evalResult; std::future< std::unique_ptr > RunEval( HRESULT &Status, ICorDebugProcess *pProcess, ICorDebugThread *pThread, ICorDebugEval *pEval, WaitEvalResultCallback cbSetupEval); }; } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/frames.cpp000066400000000000000000000420031457701673000205560ustar00rootroot00000000000000// Copyright (c) 2017 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #include #include "debugger/frames.h" #include "metadata/typeprinter.h" #include "utils/platform.h" #include "utils/logger.h" #include "utils/torelease.h" #ifdef INTEROP_DEBUGGING #include "debugger/interop_debugging.h" #if DEBUGGER_UNIX_ARM #include "debugger/interop_ptrace_helpers.h" #include // iovec #include // NT_PRSTATUS #endif #endif // INTEROP_DEBUGGING namespace netcoredbg { #ifdef INTEROP_DEBUGGING namespace { std::mutex g_mutexInteropDebugger; InteropDebugging::InteropDebugger *g_pInteropDebugger = nullptr; } // unnamed namespace #endif // INTEROP_DEBUGGING static std::uintptr_t GetIP(CONTEXT *context) { #if defined(_TARGET_AMD64_) return (std::uintptr_t)context->Rip; #elif defined(_TARGET_X86_) return (std::uintptr_t)context->Eip; #elif defined(_TARGET_ARM_) return (std::uintptr_t)context->Pc; #elif defined(_TARGET_ARM64_) return (std::uintptr_t)context->Pc; #elif defined(_TARGET_RISCV64_) return (std::uintptr_t)context->Pc; #else #error "Unsupported platform" #endif } static std::uintptr_t GetSP(CONTEXT *context) { #if defined(_TARGET_AMD64_) return (std::uintptr_t)context->Rsp; #elif defined(_TARGET_X86_) return (std::uintptr_t)context->Esp; #elif defined(_TARGET_ARM_) return (std::uintptr_t)context->Sp; #elif defined(_TARGET_ARM64_) return (std::uintptr_t)context->Sp; #elif defined(_TARGET_RISCV64_) return (std::uintptr_t)context->Sp; #else #error "Unsupported platform" #endif } static std::uintptr_t GetFP(CONTEXT *context) { #if defined(_TARGET_AMD64_) return (std::uintptr_t)context->Rbp; #elif defined(_TARGET_X86_) return (std::uintptr_t)context->Ebp; #elif defined(_TARGET_ARM_) return (std::uintptr_t)context->R11; #elif defined(_TARGET_ARM64_) return (std::uintptr_t)context->Fp; #elif defined(_TARGET_RISCV64_) return (std::uintptr_t)context->Fp; #else #error "Unsupported platform" #endif } static void SetFP(CONTEXT *context, std::uintptr_t value) { #if defined(_TARGET_AMD64_) context->Rbp = value; #elif defined(_TARGET_X86_) context->Ebp = value; #elif defined(_TARGET_ARM_) context->R11 = value; #elif defined(_TARGET_ARM64_) context->Fp = value; #elif defined(_TARGET_RISCV64_) context->Fp = value; #else #error "Unsupported platform" #endif } #ifdef INTEROP_DEBUGGING #if DEBUGGER_UNIX_ARM static HRESULT EmptyContextForFrame(WalkFramesCallback cb) { NativeFrame result; result.unknownFrameAddr = true; result.procName = "[Native Frame(s), unwind failed - CoreCLR don't provide registers context]"; return cb(FrameNative, result.addr, nullptr, &result); } static HRESULT EmptyContextForTopFrame(ICorDebugThread *pThread, WalkFramesCallback cb) { std::lock_guard lock(g_mutexInteropDebugger); if (g_pInteropDebugger == nullptr) return EmptyContextForFrame(cb); DWORD threadId = 0; StackFrame frame; if (SUCCEEDED(pThread->GetID(&threadId))) { user_regs_struct regs; iovec iov; iov.iov_base = ®s; iov.iov_len = sizeof(user_regs_struct); if (InteropDebugging::async_ptrace(PTRACE_GETREGSET, threadId, (void*)NT_PRSTATUS, &iov) == -1) { LOGW("Ptrace getregset error: %s\n", strerror(errno)); } else { constexpr int REG_PC = 15; if (SUCCEEDED(g_pInteropDebugger->GetFrameForAddr(regs.uregs[REG_PC], frame))) { NativeFrame result; result.addr = regs.uregs[REG_PC]; result.libName = frame.moduleOrLibName; result.procName = frame.methodName; result.fullSourcePath = frame.source.path; result.lineNum = frame.line; HRESULT Status; IfFailRet(cb(FrameNative, result.addr, nullptr, &result)); } } } return EmptyContextForFrame(cb); } #endif // DEBUGGER_UNIX_ARM #endif // INTEROP_DEBUGGING static HRESULT UnwindNativeFrames(ICorDebugThread *pThread, bool firstFrame, CONTEXT *pStartContext, CONTEXT *pEndContext, WalkFramesCallback cb) { #ifdef INTEROP_DEBUGGING std::lock_guard lock(g_mutexInteropDebugger); if (g_pInteropDebugger == nullptr) return S_OK; // In case debug session without interop, we merge "[CoreCLR Native Frame]" and "user's native frame" into "[Native Frames]". DWORD threadId = 0; if (FAILED(pThread->GetID(&threadId))) { NativeFrame result; result.addr = pStartContext ? GetIP(pStartContext) : 0; result.unknownFrameAddr = !result.addr; result.procName = "[Native Frame(s)]"; return cb(FrameNative, result.addr, nullptr, &result); } std::uintptr_t endAddr = pEndContext ? GetIP(pEndContext) : 0; return g_pInteropDebugger->UnwindNativeFrames(threadId, firstFrame, endAddr, pStartContext, [&](NativeFrame &nativeFrame) { return cb(FrameNative, nativeFrame.addr, nullptr, &nativeFrame); }); #else // In case not interop build we merge "CoreCLR native frame" and "user's native frame" into "[Native Frames]". return S_OK; #endif // INTEROP_DEBUGGING } #ifdef INTEROP_DEBUGGING static HRESULT UnwindInlinedTopNativeFrames(ICorDebugThread *pThread, ICorDebugFunction *pFunction, CONTEXT ¤tCtx, WalkFramesCallback cb) { ToRelease iCorFunc2; BOOL bJustMyCode; if (SUCCEEDED(pFunction->QueryInterface(IID_ICorDebugFunction2, (LPVOID *)&iCorFunc2)) && SUCCEEDED(iCorFunc2->GetJMCStatus(&bJustMyCode)) && // Check for optimized code. In case of optimized code, JMC status can't be set to TRUE. // https://github.com/dotnet/runtime/blob/main/src/coreclr/debug/ee/debugger.cpp#L11257-L11260 SUCCEEDED(iCorFunc2->SetJMCStatus(TRUE))) { // Revert back JMC status if need. if (bJustMyCode != TRUE) iCorFunc2->SetJMCStatus(bJustMyCode); return S_OK; // not optimized code for sure, ignore native top frames. } // Prevent native top frame unwinding in case thread stopped by managed exception. ToRelease iCorExceptionValue; if (SUCCEEDED(pThread->GetCurrentException(&iCorExceptionValue)) && iCorExceptionValue != nullptr) return S_OK; std::lock_guard lock(g_mutexInteropDebugger); DWORD threadId = 0; if (g_pInteropDebugger == nullptr || FAILED(pThread->GetID(&threadId))) return S_OK; HRESULT Status; static const bool firstFrame = true; #if DEBUGGER_UNIX_ARM // Linux arm32 CoreCLR have issue: // - ICorDebugStackWalk::GetContext return empty registers context for all frames; if (GetIP(¤tCtx) == 0) IfFailRet(EmptyContextForTopFrame(pThread, cb)); else #endif // DEBUGGER_UNIX_ARM IfFailRet(g_pInteropDebugger->UnwindNativeFrames(threadId, firstFrame, GetIP(¤tCtx), nullptr, [&](NativeFrame &nativeFrame) { return cb(FrameNative, nativeFrame.addr, nullptr, &nativeFrame); })); return S_OK; } #endif // INTEROP_DEBUGGING // From https://github.com/SymbolSource/Microsoft.Samples.Debugging/blob/master/src/debugger/mdbgeng/FrameFactory.cs HRESULT WalkFrames(ICorDebugThread *pThread, WalkFramesCallback cb) { HRESULT Status; ToRelease iCorThread3; IfFailRet(pThread->QueryInterface(IID_ICorDebugThread3, (LPVOID *) &iCorThread3)); ToRelease iCorStackWalk; IfFailRet(iCorThread3->CreateStackWalk(&iCorStackWalk)); static const ULONG32 ctxFlags = CONTEXT_CONTROL | CONTEXT_INTEGER; CONTEXT ctxUnmanagedChain; bool ctxUnmanagedChainValid = false; CONTEXT currentCtx; ULONG32 contextSize; memset(&ctxUnmanagedChain, 0, sizeof(CONTEXT)); memset(¤tCtx, 0, sizeof(CONTEXT)); // TODO ICorDebugInternalFrame support for more info about CoreCLR related internal routine and call cb() with `FrameCLRInternal` // ICorDebugThread3::GetActiveInternalFrames // https://learn.microsoft.com/en-us/dotnet/framework/unmanaged-api/debugging/icordebugthread3-getactiveinternalframes-method int level = -1; static const bool firstFrame = true; for (Status = S_OK; ; Status = iCorStackWalk->Next()) { if (Status == CORDBG_S_AT_END_OF_STACK) break; level++; IfFailRet(Status); ToRelease iCorFrame; IfFailRet(iCorStackWalk->GetFrame(&iCorFrame)); if (Status == S_FALSE) // S_FALSE - The current frame is a native stack frame. { // We've hit a native frame, we need to store the CONTEXT memset(&ctxUnmanagedChain, 0, sizeof(CONTEXT)); IfFailRet(iCorStackWalk->GetContext(ctxFlags, sizeof(CONTEXT), &contextSize, (BYTE*) &ctxUnmanagedChain)); ctxUnmanagedChainValid = true; continue; } // At this point (Status == S_OK). // Accordingly to CoreCLR sources, S_OK could be with nulled iCorFrame, that must be skipped. // Related to `FrameType::kExplicitFrame` in runtime (skipped frame function with no-frame transition represents) if (iCorFrame == NULL) continue; // If we get a RuntimeUnwindableFrame, then the stackwalker is also stopped at a native // stack frame, but it's a native stack frame which requires special unwinding help from // the runtime. When a debugger gets a RuntimeUnwindableFrame, it should use the runtime // to unwind, but it has to do inspection on its own. It can call // ICorDebugStackWalk::GetContext() to retrieve the context of the native stack frame. ToRelease iCorRuntimeUnwindableFrame; if (SUCCEEDED(iCorFrame->QueryInterface(IID_ICorDebugRuntimeUnwindableFrame, (LPVOID *) &iCorRuntimeUnwindableFrame))) continue; // We need to store the CONTEXT when we're at a managed frame. memset(¤tCtx, 0, sizeof(CONTEXT)); IfFailRet(iCorStackWalk->GetContext(ctxFlags, sizeof(CONTEXT), &contextSize, (BYTE*) ¤tCtx)); // Note, we don't change top managed frame FP in case we don't have SP (for example, registers context related issue) // or CoreCLR was able to restore it. This case could happens only with "managed" top frame (`GetFrame()` return `S_OK`), // where real top frame is native (for example, optimized managed code with inlined pinvoke or CoreCLR native frame). if (level == 0 && GetSP(¤tCtx) != 0 && GetFP(¤tCtx) == 0) { SetFP(¤tCtx, GetSP(¤tCtx)); IfFailRet(iCorStackWalk->SetContext(SET_CONTEXT_FLAG_UNWIND_FRAME, sizeof(CONTEXT), (BYTE*) ¤tCtx)); } // Check if we have native frames to unwind if (ctxUnmanagedChainValid) { #ifdef INTEROP_DEBUGGING #if DEBUGGER_UNIX_ARM // Linux arm32 CoreCLR have issues: // - ICorDebugStackWalk::Next have first stack frame "native", ICorDebugStackWalk::GetFrame return S_FALSE; // - ICorDebugStackWalk::GetContext return empty registers context for all frames; if (GetIP(&ctxUnmanagedChain) == 0 || GetIP(¤tCtx) == 0) { if (level == 1) IfFailRet(EmptyContextForTopFrame(pThread, cb)); else IfFailRet(EmptyContextForFrame(cb)); } else #endif // DEBUGGER_UNIX_ARM #endif // INTEROP_DEBUGGING IfFailRet(UnwindNativeFrames(pThread, !firstFrame, &ctxUnmanagedChain, ¤tCtx, cb)); level++; // Clear out the CONTEXT memset(&ctxUnmanagedChain, 0, sizeof(CONTEXT)); ctxUnmanagedChainValid = false; } // Return the managed frame ToRelease iCorFunction; if (SUCCEEDED(iCorFrame->GetFunction(&iCorFunction))) { #ifdef INTEROP_DEBUGGING // In case of optimized managed code, top frame could be native (optimized code could have inlined pinvoke). // Note, breakpoint can't be set in optimized managed code and step can't stop here, since this code is not JMC for sure. if (level == 0 && FAILED(Status = UnwindInlinedTopNativeFrames(pThread, iCorFunction.GetPtr(), currentCtx, cb))) return Status; #endif // INTEROP_DEBUGGING ToRelease pILFrame; IfFailRet(iCorFrame->QueryInterface(IID_ICorDebugILFrame, (LPVOID*) &pILFrame)); ULONG32 nOffset; CorDebugMappingResult mappingResult; IfFailRet(pILFrame->GetIP(&nOffset, &mappingResult)); if (mappingResult == MAPPING_UNMAPPED_ADDRESS || mappingResult == MAPPING_NO_INFO) continue; IfFailRet(cb(FrameCLRManaged, GetIP(¤tCtx), iCorFrame, nullptr)); continue; } ToRelease iCorNativeFrame; if (FAILED(iCorFrame->QueryInterface(IID_ICorDebugNativeFrame, (LPVOID*) &iCorNativeFrame))) { IfFailRet(cb(FrameUnknown, GetIP(¤tCtx), iCorFrame, nullptr)); continue; } // If the first frame is CoreCLR native frame then we might be in a call to unmanaged code. // Note, in case start unwinding from native code we get CoreCLR native frame first, not some native frame at the top, // since CoreCLR debug API don't track native code execution and don't really "see" native code at the beginning of unwinding. if (level == 0) { #ifdef INTEROP_DEBUGGING #if DEBUGGER_UNIX_ARM // Linux arm32 CoreCLR have issue: // - ICorDebugStackWalk::GetContext return empty registers context for all frames; if (GetIP(¤tCtx) == 0) IfFailRet(EmptyContextForTopFrame(pThread, cb)); else #endif // DEBUGGER_UNIX_ARM #endif // INTEROP_DEBUGGING IfFailRet(UnwindNativeFrames(pThread, firstFrame, nullptr, ¤tCtx, cb)); } IfFailRet(cb(FrameCLRNative, GetIP(¤tCtx), iCorFrame, nullptr)); } // We may have native frames at the end of the stack if (ctxUnmanagedChainValid) { if (level == 0) // in case this is first and last frame - unwind all IfFailRet(UnwindNativeFrames(pThread, firstFrame, nullptr, nullptr, cb)); else { #ifdef INTEROP_DEBUGGING #if DEBUGGER_UNIX_ARM // Linux arm32 CoreCLR have issue: // - ICorDebugStackWalk::GetContext return empty registers context for all frames; if (GetIP(&ctxUnmanagedChain) == 0) IfFailRet(EmptyContextForFrame(cb)); else #endif // DEBUGGER_UNIX_ARM #endif // INTEROP_DEBUGGING IfFailRet(UnwindNativeFrames(pThread, !firstFrame, &ctxUnmanagedChain, nullptr, cb)); } } return S_OK; } HRESULT GetFrameAt(ICorDebugThread *pThread, FrameLevel level, ICorDebugFrame **ppFrame) { // Try get 0 (current active) frame in fast way, if possible. if (int(level) == 0 && SUCCEEDED(pThread->GetActiveFrame(ppFrame)) && *ppFrame != nullptr) return S_OK; int currentFrame = -1; WalkFrames(pThread, [&]( FrameType frameType, std::uintptr_t addr, ICorDebugFrame *pFrame, NativeFrame *pNative) { currentFrame++; if (currentFrame < int(level)) return S_OK; else if (currentFrame > int(level)) return E_FAIL; if (currentFrame != int(level) || frameType != FrameCLRManaged) return S_OK; pFrame->AddRef(); *ppFrame = pFrame; return E_ABORT; // Fast exit from cycle. }); return *ppFrame != nullptr ? S_OK : E_FAIL; } const char *GetInternalTypeName(CorDebugInternalFrameType frameType) { switch(frameType) { case STUBFRAME_M2U: return "Managed to Native Transition"; case STUBFRAME_U2M: return "Native to Managed Transition"; case STUBFRAME_APPDOMAIN_TRANSITION: return "Appdomain Transition"; case STUBFRAME_LIGHTWEIGHT_FUNCTION: return "Lightweight function"; case STUBFRAME_FUNC_EVAL: return "Func Eval"; case STUBFRAME_INTERNALCALL: return "Internal Call"; case STUBFRAME_CLASS_INIT: return "Class Init"; case STUBFRAME_EXCEPTION: return "Exception"; case STUBFRAME_SECURITY: return "Security"; case STUBFRAME_JIT_COMPILATION: return "JIT Compilation"; default: return "Unknown"; } } #ifdef INTEROP_DEBUGGING void InitNativeFramesUnwind(InteropDebugging::InteropDebugger *pInteropDebugger) { g_mutexInteropDebugger.lock(); g_pInteropDebugger = pInteropDebugger; g_mutexInteropDebugger.unlock(); } void ShutdownNativeFramesUnwind() { g_mutexInteropDebugger.lock(); g_pInteropDebugger = nullptr; g_mutexInteropDebugger.unlock(); } #endif // INTEROP_DEBUGGING } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/frames.h000066400000000000000000000022621457701673000202260ustar00rootroot00000000000000// Copyright (c) 2017 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #pragma once #include "cor.h" #include "cordebug.h" #include #include "interfaces/types.h" namespace netcoredbg { enum FrameType { FrameUnknown, FrameNative, FrameCLRNative, FrameCLRInternal, FrameCLRManaged }; struct NativeFrame { std::uintptr_t addr = 0; bool unknownFrameAddr = false; std::string libName; std::string procName; std::string fullSourcePath; int lineNum = 0; }; typedef std::function WalkFramesCallback; struct Thread; HRESULT GetFrameAt(ICorDebugThread *pThread, FrameLevel level, ICorDebugFrame **ppFrame); const char *GetInternalTypeName(CorDebugInternalFrameType frameType); HRESULT WalkFrames(ICorDebugThread *pThread, WalkFramesCallback cb); #ifdef INTEROP_DEBUGGING namespace InteropDebugging { class InteropDebugger; } void InitNativeFramesUnwind(InteropDebugging::InteropDebugger *pInteropDebugger); void ShutdownNativeFramesUnwind(); #endif // INTEROP_DEBUGGING } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/hotreloadhelpers.cpp000066400000000000000000000117151457701673000226530ustar00rootroot00000000000000// Copyright (c) 2022 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #include #include #include #include "debugger/hotreloadhelpers.h" #include "debugger/evaluator.h" #include "debugger/evalhelpers.h" #include "metadata/modules.h" #include "utils/torelease.h" namespace netcoredbg { namespace HotReloadHelpers { #ifdef NCDB_DOTNET_STARTUP_HOOK static std::string GetFileName(const std::string &path) { std::size_t i = path.find_last_of("/\\"); return i == std::string::npos ? path : path.substr(i + 1); } #endif // NCDB_DOTNET_STARTUP_HOOK // Get array of System.Type objects, that we will use as argument for `ClearCache()` and `UpdateApplication()` methods. static HRESULT GetMetadataUpdateTypes(ICorDebugThread *pThread, EvalHelpers *pEvalHelpers, const std::string &updatedDLL, const std::unordered_set &updatedTypeTokens, ICorDebugValue **ppResultValue) { #ifdef NCDB_DOTNET_STARTUP_HOOK HRESULT Status; ToRelease iCorArg1Value; pEvalHelpers->CreateString(pThread, updatedDLL, &iCorArg1Value); // For second argument we use string with class tokens separated by `;` symbol. // In this way we avoid creation bunch of `System.UInt32` objects (one for each token) and managed array (that will hold all this objects). std::ostringstream ss; for (const auto &typeToken : updatedTypeTokens) { if (!ss.str().empty()) ss << ";"; ss << typeToken; } ToRelease iCorArg2Value; pEvalHelpers->CreateString(pThread, ss.str(), &iCorArg2Value); static const std::string assemblyName = GetFileName(NCDB_DOTNET_STARTUP_HOOK); static const WCHAR className[] = W("StartupHook"); static const WCHAR methodName[] = W("ncdbGetMetadataUpdateTypes"); ToRelease iCorFunc; IfFailRet(pEvalHelpers->FindMethodInModule(assemblyName, className, methodName, &iCorFunc)); ICorDebugValue *ppArgsValue[] = {iCorArg1Value, iCorArg2Value}; IfFailRet(pEvalHelpers->EvalFunction(pThread, iCorFunc.GetPtr(), nullptr, 0, ppArgsValue, 2, ppResultValue, defaultEvalFlags)); return S_OK; #else // NCDB_DOTNET_STARTUP_HOOK return E_NOTIMPL; #endif // NCDB_DOTNET_STARTUP_HOOK } // Call all ClearCache() and UpdateApplication() methods from UpdateHandlerTypes. HRESULT UpdateApplication(ICorDebugThread *pThread, Modules *pModules, Evaluator *pEvaluator, EvalHelpers *pEvalHelpers, const std::string &updatedDLL, const std::unordered_set &updatedTypeTokens) { HRESULT Status; std::vector> modulesUpdateHandlerTypes; pModules->CopyModulesUpdateHandlerTypes(modulesUpdateHandlerTypes); std::list> listClearCache; std::list> listUpdateApplication; std::vector emptyVector; for (auto &updateHandlerType : modulesUpdateHandlerTypes) { ToRelease iCorResultType; pEvaluator->WalkMethods(updateHandlerType.GetPtr(), &iCorResultType, emptyVector, [&]( bool is_static, const std::string &methodName, Evaluator::ReturnElementType &methodRet, std::vector &methodArgs, Evaluator::GetFunctionCallback getFunction) { if (!is_static || methodRet.corType != ELEMENT_TYPE_VOID || methodArgs.size() != 1 || methodArgs[0].corType != ELEMENT_TYPE_SZARRAY || methodArgs[0].typeName != "System.Type[]") return S_OK; if (methodName == "ClearCache") { listClearCache.emplace_back(); IfFailRet(getFunction(&listClearCache.back())); } else if (methodName == "UpdateApplication") { listUpdateApplication.emplace_back(); IfFailRet(getFunction(&listUpdateApplication.back())); } return S_OK; }); } ToRelease iCorArgValue; if (FAILED(GetMetadataUpdateTypes(pThread, pEvalHelpers, updatedDLL, updatedTypeTokens, &iCorArgValue))) { // Create `null`. ToRelease iCorEval; IfFailRet(pThread->CreateEval(&iCorEval)); IfFailRet(iCorEval->CreateValue(ELEMENT_TYPE_CLASS, nullptr, &iCorArgValue)); } for (auto &func : listClearCache) { IfFailRet(pEvalHelpers->EvalFunction(pThread, func.GetPtr(), nullptr, 0, iCorArgValue.GetRef(), 1, nullptr, defaultEvalFlags)); } for (auto &func : listUpdateApplication) { IfFailRet(pEvalHelpers->EvalFunction(pThread, func.GetPtr(), nullptr, 0, iCorArgValue.GetRef(), 1, nullptr, defaultEvalFlags)); } return S_OK; } } // namespace HotReloadHelpers } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/hotreloadhelpers.h000066400000000000000000000013541457701673000223160ustar00rootroot00000000000000// Copyright (c) 2022 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #pragma once #include "cor.h" #include "cordebug.h" #include #include namespace netcoredbg { class Modules; class Evaluator; class EvalHelpers; namespace HotReloadHelpers { // Call all ClearCache() and UpdateApplication() methods from UpdateHandlerTypes. HRESULT UpdateApplication(ICorDebugThread *pThread, Modules *pModules, Evaluator *pEvaluator, EvalHelpers *pEvalHelpers, const std::string &updatedDLL, const std::unordered_set &updatedTypeTokens); } // namespace HotReloadHelpers } // namespace netcoredbg netcoredbg-3.1.0-1031/src/debugger/interop_arm32_singlestep_helpers.cpp000066400000000000000000001275231457701673000257570ustar00rootroot00000000000000// Copyright (c) 2023 Samsung Electronics Co., LTD // Distributed under the MIT License. // See the LICENSE file in the project root for more information. #include "debugger/interop_arm32_singlestep_helpers.h" #include "debugger/interop_brk_helpers.h" #include // iovec #include // NT_PRSTATUS #include #include #include #include #include "utils/logger.h" namespace netcoredbg { namespace InteropDebugging { struct sw_singlestep_nextpc_t { std::uintptr_t addr = 0; bool isThumb = false; sw_singlestep_nextpc_t(std::uintptr_t addr_, bool isThumb_) : addr(addr_), isThumb(isThumb_) {} }; constexpr int REG_SP = 13; constexpr int REG_LR = 14; constexpr int REG_PC = 15; constexpr int REG_CPSR = 16; // Return trueif the processor is currently executing in Thumb mode static bool IsExecutingThumb(const user_regs_struct ®s) { constexpr int REG_CPSR = 16; std::uintptr_t cpsr = regs.uregs[REG_CPSR]; // FIXME for `M profiles` (Cortex-M), XPSR_T_BIT must be used instead. // CPSR_T_BIT 0x20 // 5 bit // XPSR_T_BIT 0x01000000 // 25 bit return cpsr & 0x20; } template bool GetDataFromMemory(pid_t pid, std::uintptr_t addr, T &result) { errno = 0; word_t wData = async_ptrace(PTRACE_PEEKDATA, pid, (void*)addr, nullptr); if (errno != 0) { LOGE("Ptrace peekdata error: %s", strerror(errno)); return false; } // Note, little-endian only architectures are supported now. assert(sizeof(word_t) % sizeof(T) == 0); // result with type `T` must be element of `word_t`-size array result = ((T*)&wData)[0]; // just get first element of array return true; } static inline std::uint32_t MakeSubmask(std::uint32_t x) { return ((std::uint32_t)1 << (x + 1)) - 1; } static inline std::uint32_t GetBits(std::uint32_t val, std::uint32_t first, std::uint32_t last) { return (val >> first) & MakeSubmask(last - first); } static inline std::uint32_t GetBit(std::uint32_t val, std::uint32_t number) { return (val >> number) & 1; } static inline std::uint32_t GetSBits(std::uint32_t val, std::uint32_t first, std::uint32_t last) { return (std::int32_t)GetBits(val, first, last) | ((std::int32_t)GetBit(val, last) * ~MakeSubmask(last - first)); } static inline std::uintptr_t CalculateBranchDest(std::uint32_t addr, std::uint32_t instr) { // From "4.4 Branch and Branch with Link (B, BL)": // Branch instructions contain a signed 2’s complement 24 bit offset. This is shifted left // two bits, sign extended to 32 bits, and added to the PC. The instruction can therefore // specify a branch of +/- 32Mbytes. The branch offset must take account of the prefetch // operation, which causes the PC to be 2 words (8 bytes) ahead of the current instruction. return addr + 8 + (GetSBits(instr, 0, 23) << 2); } constexpr std::uint32_t INST_AL = 0xe; // allways constexpr std::uint32_t INST_NV = 0xf; // unconditional/allways constexpr std::uint32_t FLAG_N = 0x80000000; constexpr std::uint32_t FLAG_Z = 0x40000000; constexpr std::uint32_t FLAG_C = 0x20000000; constexpr std::uint32_t FLAG_V = 0x10000000; static bool IsConditionTrue(std::uint32_t cond, std::uint32_t regPS) { if (cond == INST_AL || cond == INST_NV) return true; static std::vector> conditionLogic { [](std::uint32_t regPS) {return ((regPS & FLAG_Z) != 0);}, // INST_EQ = 0x0 [](std::uint32_t regPS) {return ((regPS & FLAG_Z) == 0);}, // INST_NE = 0x1 [](std::uint32_t regPS) {return ((regPS & FLAG_C) != 0);}, // INST_CS = 0x2 [](std::uint32_t regPS) {return ((regPS & FLAG_C) == 0);}, // INST_CC = 0x3 [](std::uint32_t regPS) {return ((regPS & FLAG_N) != 0);}, // INST_MI = 0x4 [](std::uint32_t regPS) {return ((regPS & FLAG_N) == 0);}, // INST_PL = 0x5 [](std::uint32_t regPS) {return ((regPS & FLAG_V) != 0);}, // INST_VS = 0x6 [](std::uint32_t regPS) {return ((regPS & FLAG_V) == 0);}, // INST_VC = 0x7 [](std::uint32_t regPS) {return ((regPS & (FLAG_C | FLAG_Z)) == FLAG_C);}, // INST_HI = 0x8 [](std::uint32_t regPS) {return ((regPS & (FLAG_C | FLAG_Z)) != FLAG_C);}, // INST_LS = 0x9 [](std::uint32_t regPS) {return (((regPS & FLAG_N) == 0) == ((regPS & FLAG_V) == 0));}, // INST_GE = 0xa [](std::uint32_t regPS) {return (((regPS & FLAG_N) == 0) != ((regPS & FLAG_V) == 0));}, // INST_LT = 0xb [](std::uint32_t regPS) {return (((regPS & FLAG_Z) == 0) && (((regPS & FLAG_N) == 0) == ((regPS & FLAG_V) == 0)));}, // INST_GT = 0xc [](std::uint32_t regPS) {return (((regPS & FLAG_Z) != 0) || (((regPS & FLAG_N) == 0) != ((regPS & FLAG_V) == 0)));} // INST_LE = 0xd }; if (conditionLogic.size() < cond) return conditionLogic[cond](regPS); return true; } static std::uint32_t ShiftRegValue(const user_regs_struct ®s, std::uint32_t inst, bool carry, std::uint32_t regPC) { // if 4 bit == 0 // 11-7 bits - shift amount, 5 bit unsigned integer // if 4 bit == 1 // 11-8 bits - shift register // 7 bit is `0` // // 6-5 bits - shift type: // 00 = logical left // 01 = logical right // 10 = arithmetic right // 11 = rotate right // 3-0 bits - offset register std::uint32_t shift; if (GetBit(inst, 4)) { int shiftReg = GetBits(inst, 8, 11); shift = (shiftReg == REG_PC ? regPC + 8 : (std::uint32_t)(regs.uregs[shiftReg])) & 0xff; } else { shift = GetBits(inst, 7, 11); } int offsetReg = GetBits(inst, 0, 3); std::uint32_t result = (offsetReg == REG_PC ? (regPC + (GetBit(inst, 4) ? 12 : 8)) : (std::uint32_t)(regs.uregs[offsetReg])); static std::vector> shiftLogic { [](std::uint32_t shift, bool, std::uint32_t &result) { result = shift >= 32 ? 0 : result << shift;}, // LSL = 0 [](std::uint32_t shift, bool, std::uint32_t &result) { result = shift >= 32 ? 0 : result >> shift;}, // LSR = 1 [](std::uint32_t shift, bool, std::uint32_t &result) { if (shift >= 32) shift = 31; result = ((result & 0x80000000L) ? ~((~result) >> shift) : result >> shift); }, // ASR = 2 [](std::uint32_t shift, bool carry, std::uint32_t &result) { shift &= 31; if (shift == 0) result = (result >> 1) | (carry ? 0x80000000L : 0); else result = (result >> shift) | (result << (32 - shift)); } // ROR/RRX = 3 }; std::uint32_t shiftType = GetBits(inst, 5, 6); if (shiftLogic.size() < shiftType) shiftLogic[shiftType](shift, carry, result); return result; } static bool ArmUnconditional_Branches(std::uintptr_t currentPC, std::uint32_t currentInstr, std::uintptr_t &nextPC, bool &switchToThumbCode) { nextPC = CalculateBranchDest(currentPC, currentInstr); nextPC |= GetBit(currentInstr, 24) << 1; switchToThumbCode = true; return true; }; static bool ArmUnconditional_CoprocessorOperations(std::uintptr_t, std::uint32_t currentInstr, std::uintptr_t&, bool&) { if (GetBits(currentInstr, 12, 15) == REG_PC) { LOGE("Failed next PC calculation"); return false; } return true; }; static bool ArmConditionTrue_Miscellaneous(pid_t, const user_regs_struct ®s, std::uintptr_t currentPS, std::uintptr_t currentPC, std::uint32_t currentInstr, std::uintptr_t &nextPC, bool &switchToThumbCode) { // Multiply and Multiply-Accumulate (MUL, MLA) // 4.7.1 Operand restrictions // R15 must not be used as an operand or as the destination register. if (GetBits(currentInstr, 22, 27) == 0 && GetBits(currentInstr, 4, 7) == 9) return true; // Multiply Long and Multiply-Accumulate Long (MULL, MLAL) // 4.8.1 Operand restrictions // R15 must not be used as an operand or as a destination register. if (GetBits(currentInstr, 23, 27) == 1 && GetBits(currentInstr, 4, 7) == 9) return true; // Single Data Swap (SWP) // 4.12.2 Use of R15 // Do not use R15 as an operand (Rd, Rn or Rs) in a SWP instruction. if (GetBits(currentInstr, 23, 27) == 0x2 && GetBits(currentInstr, 20, 21) == 0 && GetBits(currentInstr, 4, 11) == 9) return true; // BX register, BLX register if (GetBits(currentInstr, 4, 27) == 0x12fff1 || GetBits(currentInstr, 4, 27) == 0x12fff3) { std::uintptr_t rn = GetBits(currentInstr, 0, 3); nextPC = ((rn == REG_PC) ? (currentPC + 8) : std::uintptr_t(regs.uregs[rn])); // This instruction also permits the instruction set to be exchanged. When the instruction is executed, // the value of Rn[0] determines whether the instruction stream will be decoded as ARM or THUMB instructions. switchToThumbCode = nextPC & 1; nextPC = nextPC & ~(std::uintptr_t(1)); // Remove useless bits from address. return true; } // Halfword and Signed Data Transfer (LDRH/STRH/LDRSB/LDRSH) if ((GetBits(currentInstr, 25, 27) == 0 && GetBit(currentInstr, 22) == 0 && GetBits(currentInstr, 7, 11) == 1 && GetBit(currentInstr, 4) == 1) || // register offset (GetBits(currentInstr, 25, 27) == 0 && GetBit(currentInstr, 22) == 1 && GetBit(currentInstr, 7) == 1 && GetBit(currentInstr, 4) == 1)) // immediate offset { // TODO (load from memory) if (GetBits(currentInstr, 12, 15) == REG_PC && GetBit(currentInstr, 21) == 1) { LOGE("Load PC register from memory for LDRH/LDRSB/LDRSH not implemented."); return false; } // 4.10.5 Use of R15 // Write-back should not be specified if R15 is specified as the base register (Rn). if (GetBits(currentInstr, 16, 19) == REG_PC && GetBit(currentInstr, 21) == 1) return false; return true; } // Parsing of data processing / PSR transfer instructions. // if dest register is not PC, just leave if (GetBits(currentInstr, 12, 15) != REG_PC) return true; bool carry = (currentPS & FLAG_C) == FLAG_C; std::uintptr_t rn = GetBits(currentInstr, 16, 19); std::uintptr_t operand1 = ((rn == REG_PC) ? (currentPC + 8) : std::uintptr_t(regs.uregs[rn])); std::uintptr_t operand2 = 0; if (GetBit(currentInstr, 25)) { std::uint32_t immval = GetBits(currentInstr, 0, 7); std::uint32_t rotate = 2 * GetBits(currentInstr, 8, 11); operand2 = ((immval >> rotate) | (immval << (32 - rotate))); } else // operand 2 is a shifted register. { operand2 = ShiftRegValue(regs, currentInstr, carry, currentPC); } static std::vector> dataOperations { [](std::uintptr_t, std::uintptr_t operand1, std::uintptr_t operand2, bool) { return operand1 & operand2; }, // and = 0x0 [](std::uintptr_t, std::uintptr_t operand1, std::uintptr_t operand2, bool) { return operand1 ^ operand2; }, // eor = 0x1 [](std::uintptr_t, std::uintptr_t operand1, std::uintptr_t operand2, bool) { return operand1 - operand2; }, // sub = 0x2 [](std::uintptr_t, std::uintptr_t operand1, std::uintptr_t operand2, bool) { return operand2 - operand1; }, // rsb = 0x3 [](std::uintptr_t, std::uintptr_t operand1, std::uintptr_t operand2, bool) { return operand1 + operand2; }, // add = 0x4 [](std::uintptr_t, std::uintptr_t operand1, std::uintptr_t operand2, bool carry) { return operand1 + operand2 + (carry ? 1 : 0); }, // adc = 0x5 [](std::uintptr_t, std::uintptr_t operand1, std::uintptr_t operand2, bool carry) { return operand1 - operand2 + (carry ? 1 : 0); }, // sbc = 0x6 [](std::uintptr_t, std::uintptr_t operand1, std::uintptr_t operand2, bool carry) { return operand2 - operand1 + (carry ? 1 : 0); }, // rsc = 0x7 // Note, we don't set condition codes, just "do nothing" for this OpCodes. [](std::uintptr_t nextPC, std::uintptr_t, std::uintptr_t, bool) { return nextPC; }, // tst = 0x8 [](std::uintptr_t nextPC, std::uintptr_t, std::uintptr_t, bool) { return nextPC; }, // teq = 0x9 [](std::uintptr_t nextPC, std::uintptr_t, std::uintptr_t, bool) { return nextPC; }, // cmp = 0xa [](std::uintptr_t nextPC, std::uintptr_t, std::uintptr_t, bool) { return nextPC; }, // cmn = 0xb [](std::uintptr_t, std::uintptr_t operand1, std::uintptr_t operand2, bool) { return operand1 | operand2; }, // orr = 0xc [](std::uintptr_t, std::uintptr_t, std::uintptr_t operand2, bool) { return operand2; }, // mov = 0xd [](std::uintptr_t, std::uintptr_t operand1, std::uintptr_t operand2, bool) { return operand1 & ~operand2; }, // bic = 0xe [](std::uintptr_t, std::uintptr_t, std::uintptr_t operand2, bool) { return ~operand2; }, // mvn = 0xf }; nextPC = dataOperations[GetBits(currentInstr, 21, 24)](nextPC, operand1, operand2, carry); nextPC = nextPC & ~(std::uintptr_t(1)); // Remove useless bits from address. Note, we don't support M-profiles here. return true; }; static bool ArmConditionTrue_MemoryOperations(pid_t pid, const user_regs_struct ®s, std::uintptr_t currentPS, std::uintptr_t currentPC, std::uint32_t currentInstr, std::uintptr_t &nextPC, bool&) { // We care about LDR only here. if (GetBits(currentInstr, 25, 27) == 0x3 && GetBit(currentInstr, 4) == 1) return true; if (GetBit(currentInstr, 20) && GetBits(currentInstr, 12, 15) == REG_PC) // LDR (in case PC is dest) { // 1 - transfer byte quantity if (GetBit(currentInstr, 22) == 1) { LOGE("Failed next PC calculation"); return false; } std::uint32_t baseReg = GetBits(currentInstr, 16, 19); std::uintptr_t baseData = ((baseReg == REG_PC) ? (currentPC + 8) : std::uintptr_t(regs.uregs[baseReg])); if (GetBit(currentInstr, 24)) // pre-index { bool carry = (currentPS & FLAG_C) == FLAG_C; std::uint32_t offset = (GetBit(currentInstr, 25) ? ShiftRegValue(regs, currentInstr, carry, currentPC) : // shift GetBits(currentInstr, 0, 11)); // 12-bit immediate if (GetBit(currentInstr, 23)) baseData += offset; // up else baseData -= offset; // down } if (!GetDataFromMemory(pid, baseData, nextPC)) { LOGE("Failed next PC calculation"); return false; } } return true; }; static bool ArmConditionTrue_MultipleMemoryOperations(pid_t pid, const user_regs_struct ®s, std::uintptr_t, std::uintptr_t, std::uint32_t currentInstr, std::uintptr_t &nextPC, bool&) { if (GetBit(currentInstr, 20) && GetBit(currentInstr, REG_PC)) // LDM (in case PC also included in register list) { int offset = 0; if (GetBit(currentInstr, 23)) // up { unsigned long reglist = GetBits(currentInstr, 0, 14); // in this case reglist is "array of bits" offset = __builtin_popcountl(reglist) * 4; // count offset for all registers that are set in register list if (GetBit(currentInstr, 24)) // pre-index offset += 4; // count offset for PC too } else if (GetBit(currentInstr, 24)) // down + pre-index { offset = -4; // count offset for PC only in this case } std::uint32_t baseReg = GetBits(currentInstr, 16, 19); std::uintptr_t addr = std::uintptr_t(regs.uregs[baseReg]) + offset; if (!GetDataFromMemory(pid, addr, nextPC)) { LOGE("Failed next PC calculation"); return false; } } return true; }; static bool ArmConditionTrue_Branches(pid_t, const user_regs_struct&, std::uintptr_t, std::uintptr_t currentPC, std::uint32_t currentInstr, std::uintptr_t &nextPC, bool&) { nextPC = CalculateBranchDest(currentPC, currentInstr); return true; }; // Get next possible addresses for Arm instruction subset. static bool GetArmCodeNextPCs(pid_t pid, const user_regs_struct ®s, std::vector &swSingleStepNextPCs) { std::uintptr_t currentPC = std::uintptr_t(regs.uregs[REG_PC]); std::uintptr_t nextPC = currentPC + 4; // default PC changes bool switchToThumbCode = false; std::uint32_t currentInstr = 0; if (!GetDataFromMemory(pid, currentPC, currentInstr)) return false; std::uintptr_t currentPS = regs.uregs[REG_CPSR]; constexpr unsigned unconditionalOpsShift = 0xa; static std::vector> unconditionalOperations { // branches ArmUnconditional_Branches, // 0xa - branch and change to Thumb ArmUnconditional_Branches, // 0xb - branch & link and change to Thumb // coprocessor operations ArmUnconditional_CoprocessorOperations, // 0xc ArmUnconditional_CoprocessorOperations, // 0xd ArmUnconditional_CoprocessorOperations // 0xe }; static std::vector> conditionTrueOperations { // miscellaneous instructions (multiply, swap, branch and exchange, data operations) ArmConditionTrue_Miscellaneous, // 0x0 ArmConditionTrue_Miscellaneous, // 0x1 ArmConditionTrue_Miscellaneous, // 0x2 ArmConditionTrue_Miscellaneous, // 0x3 // memory operations ArmConditionTrue_MemoryOperations, // 0x4 ArmConditionTrue_MemoryOperations, // 0x5 ArmConditionTrue_MemoryOperations, // 0x6 ArmConditionTrue_MemoryOperations, // 0x7 // block/multiple memory operations ArmConditionTrue_MultipleMemoryOperations, // 0x8 ArmConditionTrue_MultipleMemoryOperations, // 0x9 // branches ArmConditionTrue_Branches, // 0xa - branch ArmConditionTrue_Branches, // 0xb - branch & link // coprocessor operations (do nothing) // 0xc // 0xd // 0xe // system calls (do nothing) // 0xf - TODO care about SIGRETURN/RT_SIGRETURN syscalls. }; if (GetBits(currentInstr, 28, 31) == INST_NV) { unsigned op = GetBits(currentInstr, 24, 27); if (op > unconditionalOpsShift && op < unconditionalOpsShift + unconditionalOperations.size()) { if (!unconditionalOperations[op - unconditionalOpsShift](currentPC, currentInstr, nextPC, switchToThumbCode)) return false; } // Note, Linux kernel could offers some helpers/intrisics in a high page that we can't read (and write). // For BL and BLX move to address of following instruction, in case tail called functions return to the address in LR. if (nextPC > 0xffff0000) { switchToThumbCode = false; if (op == 0xb) // BLX