From 3d639f216f279e03098a1a5ba93fe764c370c281 Mon Sep 17 00:00:00 2001 From: Peter Sollich Date: Fri, 21 Aug 2020 14:57:06 +0200 Subject: [PATCH 01/16] delete backport.yml so I can push to master --- .github/workflows/backport.yml | 26 ------------------------ .gitignore | 37 ++++++++++++++++++++++++++++++++++ 2 files changed, 37 insertions(+), 26 deletions(-) delete mode 100644 .github/workflows/backport.yml diff --git a/.github/workflows/backport.yml b/.github/workflows/backport.yml deleted file mode 100644 index 79cde1d3ce293..0000000000000 --- a/.github/workflows/backport.yml +++ /dev/null @@ -1,26 +0,0 @@ -name: Backport PR to branch -on: - issue_comment: - types: [created] - -jobs: - backport: - if: github.event.issue.pull_request != '' && contains(github.event.comment.body, '/backport to') - runs-on: ubuntu-20.04 - steps: - - name: Checkout repo - uses: actions/checkout@v2 - - name: Run backport - uses: ./eng/actions/backport - with: - auth_token: ${{ secrets.GITHUB_TOKEN }} - pr_description_template: | - Backport of #%source_pr_number% to %target_branch% - - /cc %cc_users% - - ## Customer Impact - - ## Testing - - ## Risk diff --git a/.gitignore b/.gitignore index 7596f954d9512..0a77336126eb4 100644 --- a/.gitignore +++ b/.gitignore @@ -356,3 +356,40 @@ src/coreclr/src/System.Private.CoreLib/common # Mono Wasm-specific excludes src/mono/wasm/emsdk/ src/mono/wasm/.stamp-wasm-install-and-select* +/src/tests/readytorun/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt +/src/tests/readytorun/out/build/x64-Debug (Standard)/rules.ninja +/src/tests/readytorun/out/build/x64-Debug (Standard)/build.ninja +/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply/target-nativelibrary-Debug-db3cc60a4a30aa6ad4f9.json +/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply/index-2020-08-21T10-11-45-0169.json +/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply/codemodel-v2-54a6f181cd4cae4a23f1.json +/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply/cmakeFiles-v1-721ff5cc9aabe9506246.json +/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply/cache-v2-94dde366ed96f1844532.json +/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply +/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json +/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS +/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1 +/src/tests/readytorun/out/build/x64-Debug (Standard) +/src/tests/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt +/src/tests/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json +/src/tests/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS +/src/tests/out/build/x64-Debug (Standard) +/src/tests +/src/mono/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt +/src/mono/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json +/src/mono/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS +/src/mono/out/build/x64-Debug (Standard) +/src/libraries/Native/Windows/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt +/src/libraries/Native/Windows/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json +/src/libraries/Native/Windows/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS +/src/libraries/Native/Windows/out/build/x64-Debug (Standard) +/src/libraries/Native/Unix/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt +/src/libraries/Native/Unix/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json +/src/libraries/Native/Unix/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS +/src/libraries/Native/Unix/out/build/x64-Debug (Standard) +/src/libraries/Native +/src/installer/corehost/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt +/src/installer/corehost/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json +/src/installer/corehost/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS +/src/installer/corehost/out/build/x64-Debug (Standard) +/src/coreclr/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt +/src/coreclr/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json From 0fc9aebbf6d85d57e79c7ef5814e4fd1fec35813 Mon Sep 17 00:00:00 2001 From: Peter Sollich Date: Thu, 27 Aug 2020 11:36:14 +0200 Subject: [PATCH 02/16] Undo unintended changes --- .github/workflows/backport.yml | 26 ++++++++++++++++++++++++ .gitignore | 37 ---------------------------------- 2 files changed, 26 insertions(+), 37 deletions(-) create mode 100644 .github/workflows/backport.yml diff --git a/.github/workflows/backport.yml b/.github/workflows/backport.yml new file mode 100644 index 0000000000000..79cde1d3ce293 --- /dev/null +++ b/.github/workflows/backport.yml @@ -0,0 +1,26 @@ +name: Backport PR to branch +on: + issue_comment: + types: [created] + +jobs: + backport: + if: github.event.issue.pull_request != '' && contains(github.event.comment.body, '/backport to') + runs-on: ubuntu-20.04 + steps: + - name: Checkout repo + uses: actions/checkout@v2 + - name: Run backport + uses: ./eng/actions/backport + with: + auth_token: ${{ secrets.GITHUB_TOKEN }} + pr_description_template: | + Backport of #%source_pr_number% to %target_branch% + + /cc %cc_users% + + ## Customer Impact + + ## Testing + + ## Risk diff --git a/.gitignore b/.gitignore index 0a77336126eb4..7596f954d9512 100644 --- a/.gitignore +++ b/.gitignore @@ -356,40 +356,3 @@ src/coreclr/src/System.Private.CoreLib/common # Mono Wasm-specific excludes src/mono/wasm/emsdk/ src/mono/wasm/.stamp-wasm-install-and-select* -/src/tests/readytorun/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt -/src/tests/readytorun/out/build/x64-Debug (Standard)/rules.ninja -/src/tests/readytorun/out/build/x64-Debug (Standard)/build.ninja -/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply/target-nativelibrary-Debug-db3cc60a4a30aa6ad4f9.json -/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply/index-2020-08-21T10-11-45-0169.json -/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply/codemodel-v2-54a6f181cd4cae4a23f1.json -/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply/cmakeFiles-v1-721ff5cc9aabe9506246.json -/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply/cache-v2-94dde366ed96f1844532.json -/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply -/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json -/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS -/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1 -/src/tests/readytorun/out/build/x64-Debug (Standard) -/src/tests/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt -/src/tests/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json -/src/tests/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS -/src/tests/out/build/x64-Debug (Standard) -/src/tests -/src/mono/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt -/src/mono/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json -/src/mono/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS -/src/mono/out/build/x64-Debug (Standard) -/src/libraries/Native/Windows/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt -/src/libraries/Native/Windows/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json -/src/libraries/Native/Windows/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS -/src/libraries/Native/Windows/out/build/x64-Debug (Standard) -/src/libraries/Native/Unix/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt -/src/libraries/Native/Unix/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json -/src/libraries/Native/Unix/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS -/src/libraries/Native/Unix/out/build/x64-Debug (Standard) -/src/libraries/Native -/src/installer/corehost/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt -/src/installer/corehost/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json -/src/installer/corehost/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS -/src/installer/corehost/out/build/x64-Debug (Standard) -/src/coreclr/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt -/src/coreclr/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json From 15e891c1fda8171b2dda172ebbc706dc69573367 Mon Sep 17 00:00:00 2001 From: Peter Sollich Date: Mon, 30 Nov 2020 16:39:04 +0100 Subject: [PATCH 03/16] Merge from upstream/master --- src/mono/msvc/include/mono/cil/opcode.def | 349 ++++++++++++ src/mono/msvc/include/mono/jit/jit.h | 120 ++++ .../include/mono/jit/mono-private-unstable.h | 39 ++ .../msvc/include/mono/metadata/appdomain.h | 234 ++++++++ .../msvc/include/mono/metadata/assembly.h | 136 +++++ .../msvc/include/mono/metadata/attrdefs.h | 274 ++++++++++ src/mono/msvc/include/mono/metadata/blob.h | 118 ++++ src/mono/msvc/include/mono/metadata/class.h | 313 +++++++++++ .../include/mono/metadata/debug-helpers.h | 54 ++ .../mono/metadata/debug-mono-symfile.h | 114 ++++ .../msvc/include/mono/metadata/environment.h | 23 + .../msvc/include/mono/metadata/exception.h | 177 ++++++ src/mono/msvc/include/mono/metadata/image.h | 99 ++++ src/mono/msvc/include/mono/metadata/loader.h | 109 ++++ .../msvc/include/mono/metadata/metadata.h | 517 ++++++++++++++++++ .../msvc/include/mono/metadata/mono-config.h | 38 ++ .../msvc/include/mono/metadata/mono-debug.h | 231 ++++++++ src/mono/msvc/include/mono/metadata/mono-gc.h | 138 +++++ .../mono/metadata/mono-private-unstable.h | 41 ++ .../include/mono/metadata/object-forward.h | 22 + src/mono/msvc/include/mono/metadata/object.h | 408 ++++++++++++++ src/mono/msvc/include/mono/metadata/opcodes.h | 83 +++ .../include/mono/metadata/profiler-events.h | 108 ++++ .../msvc/include/mono/metadata/profiler.h | 248 +++++++++ .../msvc/include/mono/metadata/reflection.h | 174 ++++++ .../msvc/include/mono/metadata/row-indexes.h | 503 +++++++++++++++++ .../msvc/include/mono/metadata/sgen-bridge.h | 110 ++++ src/mono/msvc/include/mono/metadata/threads.h | 69 +++ .../msvc/include/mono/metadata/tokentype.h | 45 ++ src/mono/msvc/include/mono/metadata/verify.h | 66 +++ .../msvc/include/mono/utils/mono-counters.h | 105 ++++ .../include/mono/utils/mono-dl-fallback.h | 43 ++ src/mono/msvc/include/mono/utils/mono-error.h | 105 ++++ .../msvc/include/mono/utils/mono-forward.h | 15 + .../msvc/include/mono/utils/mono-jemalloc.h | 36 ++ .../msvc/include/mono/utils/mono-logger.h | 31 ++ .../mono/utils/mono-private-unstable.h | 19 + .../msvc/include/mono/utils/mono-publib.h | 187 +++++++ 38 files changed, 5501 insertions(+) create mode 100644 src/mono/msvc/include/mono/cil/opcode.def create mode 100644 src/mono/msvc/include/mono/jit/jit.h create mode 100644 src/mono/msvc/include/mono/jit/mono-private-unstable.h create mode 100644 src/mono/msvc/include/mono/metadata/appdomain.h create mode 100644 src/mono/msvc/include/mono/metadata/assembly.h create mode 100644 src/mono/msvc/include/mono/metadata/attrdefs.h create mode 100644 src/mono/msvc/include/mono/metadata/blob.h create mode 100644 src/mono/msvc/include/mono/metadata/class.h create mode 100644 src/mono/msvc/include/mono/metadata/debug-helpers.h create mode 100644 src/mono/msvc/include/mono/metadata/debug-mono-symfile.h create mode 100644 src/mono/msvc/include/mono/metadata/environment.h create mode 100644 src/mono/msvc/include/mono/metadata/exception.h create mode 100644 src/mono/msvc/include/mono/metadata/image.h create mode 100644 src/mono/msvc/include/mono/metadata/loader.h create mode 100644 src/mono/msvc/include/mono/metadata/metadata.h create mode 100644 src/mono/msvc/include/mono/metadata/mono-config.h create mode 100644 src/mono/msvc/include/mono/metadata/mono-debug.h create mode 100644 src/mono/msvc/include/mono/metadata/mono-gc.h create mode 100644 src/mono/msvc/include/mono/metadata/mono-private-unstable.h create mode 100644 src/mono/msvc/include/mono/metadata/object-forward.h create mode 100644 src/mono/msvc/include/mono/metadata/object.h create mode 100644 src/mono/msvc/include/mono/metadata/opcodes.h create mode 100644 src/mono/msvc/include/mono/metadata/profiler-events.h create mode 100644 src/mono/msvc/include/mono/metadata/profiler.h create mode 100644 src/mono/msvc/include/mono/metadata/reflection.h create mode 100644 src/mono/msvc/include/mono/metadata/row-indexes.h create mode 100644 src/mono/msvc/include/mono/metadata/sgen-bridge.h create mode 100644 src/mono/msvc/include/mono/metadata/threads.h create mode 100644 src/mono/msvc/include/mono/metadata/tokentype.h create mode 100644 src/mono/msvc/include/mono/metadata/verify.h create mode 100644 src/mono/msvc/include/mono/utils/mono-counters.h create mode 100644 src/mono/msvc/include/mono/utils/mono-dl-fallback.h create mode 100644 src/mono/msvc/include/mono/utils/mono-error.h create mode 100644 src/mono/msvc/include/mono/utils/mono-forward.h create mode 100644 src/mono/msvc/include/mono/utils/mono-jemalloc.h create mode 100644 src/mono/msvc/include/mono/utils/mono-logger.h create mode 100644 src/mono/msvc/include/mono/utils/mono-private-unstable.h create mode 100644 src/mono/msvc/include/mono/utils/mono-publib.h diff --git a/src/mono/msvc/include/mono/cil/opcode.def b/src/mono/msvc/include/mono/cil/opcode.def new file mode 100644 index 0000000000000..a39b315bac5e9 --- /dev/null +++ b/src/mono/msvc/include/mono/cil/opcode.def @@ -0,0 +1,349 @@ +/* GENERATED FILE, DO NOT EDIT. Edit cil-opcodes.xml instead and run "make opcode.def" to regenerate. */ +OPDEF(CEE_NOP, "nop", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0x00, NEXT) +OPDEF(CEE_BREAK, "break", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0x01, ERROR) +OPDEF(CEE_LDARG_0, "ldarg.0", Pop0, Push1, InlineNone, 0, 1, 0xFF, 0x02, NEXT) +OPDEF(CEE_LDARG_1, "ldarg.1", Pop0, Push1, InlineNone, 1, 1, 0xFF, 0x03, NEXT) +OPDEF(CEE_LDARG_2, "ldarg.2", Pop0, Push1, InlineNone, 2, 1, 0xFF, 0x04, NEXT) +OPDEF(CEE_LDARG_3, "ldarg.3", Pop0, Push1, InlineNone, 3, 1, 0xFF, 0x05, NEXT) +OPDEF(CEE_LDLOC_0, "ldloc.0", Pop0, Push1, InlineNone, 0, 1, 0xFF, 0x06, NEXT) +OPDEF(CEE_LDLOC_1, "ldloc.1", Pop0, Push1, InlineNone, 1, 1, 0xFF, 0x07, NEXT) +OPDEF(CEE_LDLOC_2, "ldloc.2", Pop0, Push1, InlineNone, 2, 1, 0xFF, 0x08, NEXT) +OPDEF(CEE_LDLOC_3, "ldloc.3", Pop0, Push1, InlineNone, 3, 1, 0xFF, 0x09, NEXT) +OPDEF(CEE_STLOC_0, "stloc.0", Pop1, Push0, InlineNone, 0, 1, 0xFF, 0x0A, NEXT) +OPDEF(CEE_STLOC_1, "stloc.1", Pop1, Push0, InlineNone, 1, 1, 0xFF, 0x0B, NEXT) +OPDEF(CEE_STLOC_2, "stloc.2", Pop1, Push0, InlineNone, 2, 1, 0xFF, 0x0C, NEXT) +OPDEF(CEE_STLOC_3, "stloc.3", Pop1, Push0, InlineNone, 3, 1, 0xFF, 0x0D, NEXT) +OPDEF(CEE_LDARG_S, "ldarg.s", Pop0, Push1, ShortInlineVar, 0, 1, 0xFF, 0x0E, NEXT) +OPDEF(CEE_LDARGA_S, "ldarga.s", Pop0, PushI, ShortInlineVar, 0, 1, 0xFF, 0x0F, NEXT) +OPDEF(CEE_STARG_S, "starg.s", Pop1, Push0, ShortInlineVar, 0, 1, 0xFF, 0x10, NEXT) +OPDEF(CEE_LDLOC_S, "ldloc.s", Pop0, Push1, ShortInlineVar, 0, 1, 0xFF, 0x11, NEXT) +OPDEF(CEE_LDLOCA_S, "ldloca.s", Pop0, PushI, ShortInlineVar, 0, 1, 0xFF, 0x12, NEXT) +OPDEF(CEE_STLOC_S, "stloc.s", Pop1, Push0, ShortInlineVar, 0, 1, 0xFF, 0x13, NEXT) +OPDEF(CEE_LDNULL, "ldnull", Pop0, PushRef, InlineNone, 0, 1, 0xFF, 0x14, NEXT) +OPDEF(CEE_LDC_I4_M1, "ldc.i4.m1", Pop0, PushI, InlineNone, -1, 1, 0xFF, 0x15, NEXT) +OPDEF(CEE_LDC_I4_0, "ldc.i4.0", Pop0, PushI, InlineNone, 0, 1, 0xFF, 0x16, NEXT) +OPDEF(CEE_LDC_I4_1, "ldc.i4.1", Pop0, PushI, InlineNone, 1, 1, 0xFF, 0x17, NEXT) +OPDEF(CEE_LDC_I4_2, "ldc.i4.2", Pop0, PushI, InlineNone, 2, 1, 0xFF, 0x18, NEXT) +OPDEF(CEE_LDC_I4_3, "ldc.i4.3", Pop0, PushI, InlineNone, 3, 1, 0xFF, 0x19, NEXT) +OPDEF(CEE_LDC_I4_4, "ldc.i4.4", Pop0, PushI, InlineNone, 4, 1, 0xFF, 0x1A, NEXT) +OPDEF(CEE_LDC_I4_5, "ldc.i4.5", Pop0, PushI, InlineNone, 5, 1, 0xFF, 0x1B, NEXT) +OPDEF(CEE_LDC_I4_6, "ldc.i4.6", Pop0, PushI, InlineNone, 6, 1, 0xFF, 0x1C, NEXT) +OPDEF(CEE_LDC_I4_7, "ldc.i4.7", Pop0, PushI, InlineNone, 7, 1, 0xFF, 0x1D, NEXT) +OPDEF(CEE_LDC_I4_8, "ldc.i4.8", Pop0, PushI, InlineNone, 8, 1, 0xFF, 0x1E, NEXT) +OPDEF(CEE_LDC_I4_S, "ldc.i4.s", Pop0, PushI, ShortInlineI, 0, 1, 0xFF, 0x1F, NEXT) +OPDEF(CEE_LDC_I4, "ldc.i4", Pop0, PushI, InlineI, 0, 1, 0xFF, 0x20, NEXT) +OPDEF(CEE_LDC_I8, "ldc.i8", Pop0, PushI8, InlineI8, 0, 1, 0xFF, 0x21, NEXT) +OPDEF(CEE_LDC_R4, "ldc.r4", Pop0, PushR4, ShortInlineR, 0, 1, 0xFF, 0x22, NEXT) +OPDEF(CEE_LDC_R8, "ldc.r8", Pop0, PushR8, InlineR, 0, 1, 0xFF, 0x23, NEXT) +OPDEF(CEE_UNUSED99, "unused99", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0x24, NEXT) +OPDEF(CEE_DUP, "dup", Pop1, Push1+Push1, InlineNone, 0, 1, 0xFF, 0x25, NEXT) +OPDEF(CEE_POP, "pop", Pop1, Push0, InlineNone, 0, 1, 0xFF, 0x26, NEXT) +OPDEF(CEE_JMP, "jmp", Pop0, Push0, InlineMethod, 0, 1, 0xFF, 0x27, CALL) +OPDEF(CEE_CALL, "call", VarPop, VarPush, InlineMethod, 0, 1, 0xFF, 0x28, CALL) +OPDEF(CEE_CALLI, "calli", VarPop, VarPush, InlineSig, 0, 1, 0xFF, 0x29, CALL) +OPDEF(CEE_RET, "ret", VarPop, Push0, InlineNone, 0, 1, 0xFF, 0x2A, RETURN) +OPDEF(CEE_BR_S, "br.s", Pop0, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x2B, BRANCH) +OPDEF(CEE_BRFALSE_S, "brfalse.s", PopI, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x2C, COND_BRANCH) +OPDEF(CEE_BRTRUE_S, "brtrue.s", PopI, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x2D, COND_BRANCH) +OPDEF(CEE_BEQ_S, "beq.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x2E, COND_BRANCH) +OPDEF(CEE_BGE_S, "bge.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x2F, COND_BRANCH) +OPDEF(CEE_BGT_S, "bgt.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x30, COND_BRANCH) +OPDEF(CEE_BLE_S, "ble.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x31, COND_BRANCH) +OPDEF(CEE_BLT_S, "blt.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x32, COND_BRANCH) +OPDEF(CEE_BNE_UN_S, "bne.un.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x33, COND_BRANCH) +OPDEF(CEE_BGE_UN_S, "bge.un.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x34, COND_BRANCH) +OPDEF(CEE_BGT_UN_S, "bgt.un.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x35, COND_BRANCH) +OPDEF(CEE_BLE_UN_S, "ble.un.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x36, COND_BRANCH) +OPDEF(CEE_BLT_UN_S, "blt.un.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x37, COND_BRANCH) +OPDEF(CEE_BR, "br", Pop0, Push0, InlineBrTarget, 0, 1, 0xFF, 0x38, BRANCH) +OPDEF(CEE_BRFALSE, "brfalse", PopI, Push0, InlineBrTarget, 0, 1, 0xFF, 0x39, COND_BRANCH) +OPDEF(CEE_BRTRUE, "brtrue", PopI, Push0, InlineBrTarget, 0, 1, 0xFF, 0x3A, COND_BRANCH) +OPDEF(CEE_BEQ, "beq", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x3B, COND_BRANCH) +OPDEF(CEE_BGE, "bge", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x3C, COND_BRANCH) +OPDEF(CEE_BGT, "bgt", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x3D, COND_BRANCH) +OPDEF(CEE_BLE, "ble", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x3E, COND_BRANCH) +OPDEF(CEE_BLT, "blt", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x3F, COND_BRANCH) +OPDEF(CEE_BNE_UN, "bne.un", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x40, COND_BRANCH) +OPDEF(CEE_BGE_UN, "bge.un", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x41, COND_BRANCH) +OPDEF(CEE_BGT_UN, "bgt.un", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x42, COND_BRANCH) +OPDEF(CEE_BLE_UN, "ble.un", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x43, COND_BRANCH) +OPDEF(CEE_BLT_UN, "blt.un", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x44, COND_BRANCH) +OPDEF(CEE_SWITCH, "switch", PopI, Push0, InlineSwitch, 0, 1, 0xFF, 0x45, COND_BRANCH) +OPDEF(CEE_LDIND_I1, "ldind.i1", PopI, PushI, InlineNone, 0, 1, 0xFF, 0x46, NEXT) +OPDEF(CEE_LDIND_U1, "ldind.u1", PopI, PushI, InlineNone, 0, 1, 0xFF, 0x47, NEXT) +OPDEF(CEE_LDIND_I2, "ldind.i2", PopI, PushI, InlineNone, 0, 1, 0xFF, 0x48, NEXT) +OPDEF(CEE_LDIND_U2, "ldind.u2", PopI, PushI, InlineNone, 0, 1, 0xFF, 0x49, NEXT) +OPDEF(CEE_LDIND_I4, "ldind.i4", PopI, PushI, InlineNone, 0, 1, 0xFF, 0x4A, NEXT) +OPDEF(CEE_LDIND_U4, "ldind.u4", PopI, PushI, InlineNone, 0, 1, 0xFF, 0x4B, NEXT) +OPDEF(CEE_LDIND_I8, "ldind.i8", PopI, PushI8, InlineNone, 0, 1, 0xFF, 0x4C, NEXT) +OPDEF(CEE_LDIND_I, "ldind.i", PopI, PushI, InlineNone, 0, 1, 0xFF, 0x4D, NEXT) +OPDEF(CEE_LDIND_R4, "ldind.r4", PopI, PushR4, InlineNone, 0, 1, 0xFF, 0x4E, NEXT) +OPDEF(CEE_LDIND_R8, "ldind.r8", PopI, PushR8, InlineNone, 0, 1, 0xFF, 0x4F, NEXT) +OPDEF(CEE_LDIND_REF, "ldind.ref", PopI, PushRef, InlineNone, 0, 1, 0xFF, 0x50, NEXT) +OPDEF(CEE_STIND_REF, "stind.ref", PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x51, NEXT) +OPDEF(CEE_STIND_I1, "stind.i1", PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x52, NEXT) +OPDEF(CEE_STIND_I2, "stind.i2", PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x53, NEXT) +OPDEF(CEE_STIND_I4, "stind.i4", PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x54, NEXT) +OPDEF(CEE_STIND_I8, "stind.i8", PopI+PopI8, Push0, InlineNone, 0, 1, 0xFF, 0x55, NEXT) +OPDEF(CEE_STIND_R4, "stind.r4", PopI+PopR4, Push0, InlineNone, 0, 1, 0xFF, 0x56, NEXT) +OPDEF(CEE_STIND_R8, "stind.r8", PopI+PopR8, Push0, InlineNone, 0, 1, 0xFF, 0x57, NEXT) +OPDEF(CEE_ADD, "add", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x58, NEXT) +OPDEF(CEE_SUB, "sub", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x59, NEXT) +OPDEF(CEE_MUL, "mul", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x5A, NEXT) +OPDEF(CEE_DIV, "div", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x5B, NEXT) +OPDEF(CEE_DIV_UN, "div.un", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x5C, NEXT) +OPDEF(CEE_REM, "rem", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x5D, NEXT) +OPDEF(CEE_REM_UN, "rem.un", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x5E, NEXT) +OPDEF(CEE_AND, "and", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x5F, NEXT) +OPDEF(CEE_OR, "or", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x60, NEXT) +OPDEF(CEE_XOR, "xor", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x61, NEXT) +OPDEF(CEE_SHL, "shl", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x62, NEXT) +OPDEF(CEE_SHR, "shr", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x63, NEXT) +OPDEF(CEE_SHR_UN, "shr.un", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x64, NEXT) +OPDEF(CEE_NEG, "neg", Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x65, NEXT) +OPDEF(CEE_NOT, "not", Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x66, NEXT) +OPDEF(CEE_CONV_I1, "conv.i1", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x67, NEXT) +OPDEF(CEE_CONV_I2, "conv.i2", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x68, NEXT) +OPDEF(CEE_CONV_I4, "conv.i4", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x69, NEXT) +OPDEF(CEE_CONV_I8, "conv.i8", Pop1, PushI8, InlineNone, 0, 1, 0xFF, 0x6A, NEXT) +OPDEF(CEE_CONV_R4, "conv.r4", Pop1, PushR4, InlineNone, 0, 1, 0xFF, 0x6B, NEXT) +OPDEF(CEE_CONV_R8, "conv.r8", Pop1, PushR8, InlineNone, 0, 1, 0xFF, 0x6C, NEXT) +OPDEF(CEE_CONV_U4, "conv.u4", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x6D, NEXT) +OPDEF(CEE_CONV_U8, "conv.u8", Pop1, PushI8, InlineNone, 0, 1, 0xFF, 0x6E, NEXT) +OPDEF(CEE_CALLVIRT, "callvirt", VarPop, VarPush, InlineMethod, 0, 1, 0xFF, 0x6F, CALL) +OPDEF(CEE_CPOBJ, "cpobj", PopI+PopI, Push0, InlineType, 0, 1, 0xFF, 0x70, NEXT) +OPDEF(CEE_LDOBJ, "ldobj", PopI, Push1, InlineType, 0, 1, 0xFF, 0x71, NEXT) +OPDEF(CEE_LDSTR, "ldstr", Pop0, PushRef, InlineString, 0, 1, 0xFF, 0x72, NEXT) +OPDEF(CEE_NEWOBJ, "newobj", VarPop, PushRef, InlineMethod, 0, 1, 0xFF, 0x73, CALL) +OPDEF(CEE_CASTCLASS, "castclass", PopRef, PushRef, InlineType, 0, 1, 0xFF, 0x74, NEXT) +OPDEF(CEE_ISINST, "isinst", PopRef, PushI, InlineType, 0, 1, 0xFF, 0x75, NEXT) +OPDEF(CEE_CONV_R_UN, "conv.r.un", Pop1, PushR8, InlineNone, 0, 1, 0xFF, 0x76, NEXT) +OPDEF(CEE_UNUSED58, "unused58", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0x77, NEXT) +OPDEF(CEE_UNUSED1, "unused1", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0x78, NEXT) +OPDEF(CEE_UNBOX, "unbox", PopRef, PushI, InlineType, 0, 1, 0xFF, 0x79, NEXT) +OPDEF(CEE_THROW, "throw", PopRef, Push0, InlineNone, 0, 1, 0xFF, 0x7A, ERROR) +OPDEF(CEE_LDFLD, "ldfld", PopRef, Push1, InlineField, 0, 1, 0xFF, 0x7B, NEXT) +OPDEF(CEE_LDFLDA, "ldflda", PopRef, PushI, InlineField, 0, 1, 0xFF, 0x7C, NEXT) +OPDEF(CEE_STFLD, "stfld", PopRef+Pop1, Push0, InlineField, 0, 1, 0xFF, 0x7D, NEXT) +OPDEF(CEE_LDSFLD, "ldsfld", Pop0, Push1, InlineField, 0, 1, 0xFF, 0x7E, NEXT) +OPDEF(CEE_LDSFLDA, "ldsflda", Pop0, PushI, InlineField, 0, 1, 0xFF, 0x7F, NEXT) +OPDEF(CEE_STSFLD, "stsfld", Pop1, Push0, InlineField, 0, 1, 0xFF, 0x80, NEXT) +OPDEF(CEE_STOBJ, "stobj", PopI+Pop1, Push0, InlineType, 0, 1, 0xFF, 0x81, NEXT) +OPDEF(CEE_CONV_OVF_I1_UN, "conv.ovf.i1.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x82, NEXT) +OPDEF(CEE_CONV_OVF_I2_UN, "conv.ovf.i2.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x83, NEXT) +OPDEF(CEE_CONV_OVF_I4_UN, "conv.ovf.i4.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x84, NEXT) +OPDEF(CEE_CONV_OVF_I8_UN, "conv.ovf.i8.un", Pop1, PushI8, InlineNone, 0, 1, 0xFF, 0x85, NEXT) +OPDEF(CEE_CONV_OVF_U1_UN, "conv.ovf.u1.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x86, NEXT) +OPDEF(CEE_CONV_OVF_U2_UN, "conv.ovf.u2.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x87, NEXT) +OPDEF(CEE_CONV_OVF_U4_UN, "conv.ovf.u4.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x88, NEXT) +OPDEF(CEE_CONV_OVF_U8_UN, "conv.ovf.u8.un", Pop1, PushI8, InlineNone, 0, 1, 0xFF, 0x89, NEXT) +OPDEF(CEE_CONV_OVF_I_UN, "conv.ovf.i.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x8A, NEXT) +OPDEF(CEE_CONV_OVF_U_UN, "conv.ovf.u.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x8B, NEXT) +OPDEF(CEE_BOX, "box", Pop1, PushRef, InlineType, 0, 1, 0xFF, 0x8C, NEXT) +OPDEF(CEE_NEWARR, "newarr", PopI, PushRef, InlineType, 0, 1, 0xFF, 0x8D, NEXT) +OPDEF(CEE_LDLEN, "ldlen", PopRef, PushI, InlineNone, 0, 1, 0xFF, 0x8E, NEXT) +OPDEF(CEE_LDELEMA, "ldelema", PopRef+PopI, PushI, InlineType, 0, 1, 0xFF, 0x8F, NEXT) +OPDEF(CEE_LDELEM_I1, "ldelem.i1", PopRef+PopI, PushI, InlineNone, 0, 1, 0xFF, 0x90, NEXT) +OPDEF(CEE_LDELEM_U1, "ldelem.u1", PopRef+PopI, PushI, InlineNone, 0, 1, 0xFF, 0x91, NEXT) +OPDEF(CEE_LDELEM_I2, "ldelem.i2", PopRef+PopI, PushI, InlineNone, 0, 1, 0xFF, 0x92, NEXT) +OPDEF(CEE_LDELEM_U2, "ldelem.u2", PopRef+PopI, PushI, InlineNone, 0, 1, 0xFF, 0x93, NEXT) +OPDEF(CEE_LDELEM_I4, "ldelem.i4", PopRef+PopI, PushI, InlineNone, 0, 1, 0xFF, 0x94, NEXT) +OPDEF(CEE_LDELEM_U4, "ldelem.u4", PopRef+PopI, PushI, InlineNone, 0, 1, 0xFF, 0x95, NEXT) +OPDEF(CEE_LDELEM_I8, "ldelem.i8", PopRef+PopI, PushI8, InlineNone, 0, 1, 0xFF, 0x96, NEXT) +OPDEF(CEE_LDELEM_I, "ldelem.i", PopRef+PopI, PushI, InlineNone, 0, 1, 0xFF, 0x97, NEXT) +OPDEF(CEE_LDELEM_R4, "ldelem.r4", PopRef+PopI, PushR4, InlineNone, 0, 1, 0xFF, 0x98, NEXT) +OPDEF(CEE_LDELEM_R8, "ldelem.r8", PopRef+PopI, PushR8, InlineNone, 0, 1, 0xFF, 0x99, NEXT) +OPDEF(CEE_LDELEM_REF, "ldelem.ref", PopRef+PopI, PushRef, InlineNone, 0, 1, 0xFF, 0x9A, NEXT) +OPDEF(CEE_STELEM_I, "stelem.i", PopRef+PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x9B, NEXT) +OPDEF(CEE_STELEM_I1, "stelem.i1", PopRef+PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x9C, NEXT) +OPDEF(CEE_STELEM_I2, "stelem.i2", PopRef+PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x9D, NEXT) +OPDEF(CEE_STELEM_I4, "stelem.i4", PopRef+PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x9E, NEXT) +OPDEF(CEE_STELEM_I8, "stelem.i8", PopRef+PopI+PopI8, Push0, InlineNone, 0, 1, 0xFF, 0x9F, NEXT) +OPDEF(CEE_STELEM_R4, "stelem.r4", PopRef+PopI+PopR4, Push0, InlineNone, 0, 1, 0xFF, 0xA0, NEXT) +OPDEF(CEE_STELEM_R8, "stelem.r8", PopRef+PopI+PopR8, Push0, InlineNone, 0, 1, 0xFF, 0xA1, NEXT) +OPDEF(CEE_STELEM_REF, "stelem.ref", PopRef+PopI+PopRef, Push0, InlineNone, 0, 1, 0xFF, 0xA2, NEXT) +OPDEF(CEE_LDELEM, "ldelem", PopRef+PopI, Push1, InlineType, 0, 1, 0xFF, 0xA3, NEXT) +OPDEF(CEE_STELEM, "stelem", PopRef+PopI+Pop1, Push0, InlineType, 0, 1, 0xFF, 0xA4, NEXT) +OPDEF(CEE_UNBOX_ANY, "unbox.any", PopRef, Push1, InlineType, 0, 1, 0xFF, 0xA5, NEXT) +OPDEF(CEE_UNUSED5, "unused5", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xA6, NEXT) +OPDEF(CEE_UNUSED6, "unused6", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xA7, NEXT) +OPDEF(CEE_UNUSED7, "unused7", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xA8, NEXT) +OPDEF(CEE_UNUSED8, "unused8", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xA9, NEXT) +OPDEF(CEE_UNUSED9, "unused9", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xAA, NEXT) +OPDEF(CEE_UNUSED10, "unused10", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xAB, NEXT) +OPDEF(CEE_UNUSED11, "unused11", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xAC, NEXT) +OPDEF(CEE_UNUSED12, "unused12", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xAD, NEXT) +OPDEF(CEE_UNUSED13, "unused13", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xAE, NEXT) +OPDEF(CEE_UNUSED14, "unused14", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xAF, NEXT) +OPDEF(CEE_UNUSED15, "unused15", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xB0, NEXT) +OPDEF(CEE_UNUSED16, "unused16", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xB1, NEXT) +OPDEF(CEE_UNUSED17, "unused17", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xB2, NEXT) +OPDEF(CEE_CONV_OVF_I1, "conv.ovf.i1", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xB3, NEXT) +OPDEF(CEE_CONV_OVF_U1, "conv.ovf.u1", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xB4, NEXT) +OPDEF(CEE_CONV_OVF_I2, "conv.ovf.i2", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xB5, NEXT) +OPDEF(CEE_CONV_OVF_U2, "conv.ovf.u2", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xB6, NEXT) +OPDEF(CEE_CONV_OVF_I4, "conv.ovf.i4", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xB7, NEXT) +OPDEF(CEE_CONV_OVF_U4, "conv.ovf.u4", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xB8, NEXT) +OPDEF(CEE_CONV_OVF_I8, "conv.ovf.i8", Pop1, PushI8, InlineNone, 0, 1, 0xFF, 0xB9, NEXT) +OPDEF(CEE_CONV_OVF_U8, "conv.ovf.u8", Pop1, PushI8, InlineNone, 0, 1, 0xFF, 0xBA, NEXT) +OPDEF(CEE_UNUSED50, "unused50", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xBB, NEXT) +OPDEF(CEE_UNUSED18, "unused18", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xBC, NEXT) +OPDEF(CEE_UNUSED19, "unused19", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xBD, NEXT) +OPDEF(CEE_UNUSED20, "unused20", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xBE, NEXT) +OPDEF(CEE_UNUSED21, "unused21", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xBF, NEXT) +OPDEF(CEE_UNUSED22, "unused22", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xC0, NEXT) +OPDEF(CEE_UNUSED23, "unused23", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xC1, NEXT) +OPDEF(CEE_REFANYVAL, "refanyval", Pop1, PushI, InlineType, 0, 1, 0xFF, 0xC2, NEXT) +OPDEF(CEE_CKFINITE, "ckfinite", Pop1, PushR8, InlineNone, 0, 1, 0xFF, 0xC3, NEXT) +OPDEF(CEE_UNUSED24, "unused24", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xC4, NEXT) +OPDEF(CEE_UNUSED25, "unused25", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xC5, NEXT) +OPDEF(CEE_MKREFANY, "mkrefany", PopI, Push1, InlineType, 0, 1, 0xFF, 0xC6, NEXT) +OPDEF(CEE_UNUSED59, "unused59", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xC7, NEXT) +OPDEF(CEE_UNUSED60, "unused60", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xC8, NEXT) +OPDEF(CEE_UNUSED61, "unused61", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xC9, NEXT) +OPDEF(CEE_UNUSED62, "unused62", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xCA, NEXT) +OPDEF(CEE_UNUSED63, "unused63", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xCB, NEXT) +OPDEF(CEE_UNUSED64, "unused64", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xCC, NEXT) +OPDEF(CEE_UNUSED65, "unused65", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xCD, NEXT) +OPDEF(CEE_UNUSED66, "unused66", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xCE, NEXT) +OPDEF(CEE_UNUSED67, "unused67", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xCF, NEXT) +OPDEF(CEE_LDTOKEN, "ldtoken", Pop0, PushI, InlineTok, 0, 1, 0xFF, 0xD0, NEXT) +OPDEF(CEE_CONV_U2, "conv.u2", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xD1, NEXT) +OPDEF(CEE_CONV_U1, "conv.u1", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xD2, NEXT) +OPDEF(CEE_CONV_I, "conv.i", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xD3, NEXT) +OPDEF(CEE_CONV_OVF_I, "conv.ovf.i", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xD4, NEXT) +OPDEF(CEE_CONV_OVF_U, "conv.ovf.u", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xD5, NEXT) +OPDEF(CEE_ADD_OVF, "add.ovf", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0xD6, NEXT) +OPDEF(CEE_ADD_OVF_UN, "add.ovf.un", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0xD7, NEXT) +OPDEF(CEE_MUL_OVF, "mul.ovf", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0xD8, NEXT) +OPDEF(CEE_MUL_OVF_UN, "mul.ovf.un", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0xD9, NEXT) +OPDEF(CEE_SUB_OVF, "sub.ovf", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0xDA, NEXT) +OPDEF(CEE_SUB_OVF_UN, "sub.ovf.un", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0xDB, NEXT) +OPDEF(CEE_ENDFINALLY, "endfinally", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xDC, RETURN) +OPDEF(CEE_LEAVE, "leave", Pop0, Push0, InlineBrTarget, 0, 1, 0xFF, 0xDD, BRANCH) +OPDEF(CEE_LEAVE_S, "leave.s", Pop0, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0xDE, BRANCH) +OPDEF(CEE_STIND_I, "stind.i", PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0xDF, NEXT) +OPDEF(CEE_CONV_U, "conv.u", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xE0, NEXT) +OPDEF(CEE_UNUSED26, "unused26", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE1, NEXT) +OPDEF(CEE_UNUSED27, "unused27", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE2, NEXT) +OPDEF(CEE_UNUSED28, "unused28", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE3, NEXT) +OPDEF(CEE_UNUSED29, "unused29", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE4, NEXT) +OPDEF(CEE_UNUSED30, "unused30", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE5, NEXT) +OPDEF(CEE_UNUSED31, "unused31", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE6, NEXT) +OPDEF(CEE_UNUSED32, "unused32", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE7, NEXT) +OPDEF(CEE_UNUSED33, "unused33", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE8, NEXT) +OPDEF(CEE_UNUSED34, "unused34", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE9, NEXT) +OPDEF(CEE_UNUSED35, "unused35", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xEA, NEXT) +OPDEF(CEE_UNUSED36, "unused36", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xEB, NEXT) +OPDEF(CEE_UNUSED37, "unused37", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xEC, NEXT) +OPDEF(CEE_UNUSED38, "unused38", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xED, NEXT) +OPDEF(CEE_UNUSED39, "unused39", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xEE, NEXT) +OPDEF(CEE_UNUSED40, "unused40", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xEF, NEXT) +OPDEF(CEE_UNUSED41, "unused41", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF0, NEXT) +OPDEF(CEE_UNUSED42, "unused42", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF1, NEXT) +OPDEF(CEE_UNUSED43, "unused43", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF2, NEXT) +OPDEF(CEE_UNUSED44, "unused44", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF3, NEXT) +OPDEF(CEE_UNUSED45, "unused45", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF4, NEXT) +OPDEF(CEE_UNUSED46, "unused46", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF5, NEXT) +OPDEF(CEE_UNUSED47, "unused47", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF6, NEXT) +OPDEF(CEE_UNUSED48, "unused48", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF7, NEXT) +OPDEF(CEE_PREFIX7, "prefix7", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF8, META) +OPDEF(CEE_PREFIX6, "prefix6", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF9, META) +OPDEF(CEE_PREFIX5, "prefix5", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xFA, META) +OPDEF(CEE_PREFIX4, "prefix4", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xFB, META) +OPDEF(CEE_PREFIX3, "prefix3", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xFC, META) +OPDEF(CEE_PREFIX2, "prefix2", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xFD, META) +OPDEF(CEE_PREFIX1, "prefix1", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xFE, META) +OPDEF(CEE_PREFIXREF, "prefixref", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xFF, META) +OPDEF(CEE_ARGLIST, "arglist", Pop0, PushI, InlineNone, 0, 2, 0xFE, 0x00, NEXT) +OPDEF(CEE_CEQ, "ceq", Pop1+Pop1, PushI, InlineNone, 0, 2, 0xFE, 0x01, NEXT) +OPDEF(CEE_CGT, "cgt", Pop1+Pop1, PushI, InlineNone, 0, 2, 0xFE, 0x02, NEXT) +OPDEF(CEE_CGT_UN, "cgt.un", Pop1+Pop1, PushI, InlineNone, 0, 2, 0xFE, 0x03, NEXT) +OPDEF(CEE_CLT, "clt", Pop1+Pop1, PushI, InlineNone, 0, 2, 0xFE, 0x04, NEXT) +OPDEF(CEE_CLT_UN, "clt.un", Pop1+Pop1, PushI, InlineNone, 0, 2, 0xFE, 0x05, NEXT) +OPDEF(CEE_LDFTN, "ldftn", Pop0, PushI, InlineMethod, 0, 2, 0xFE, 0x06, NEXT) +OPDEF(CEE_LDVIRTFTN, "ldvirtftn", PopRef, PushI, InlineMethod, 0, 2, 0xFE, 0x07, NEXT) +OPDEF(CEE_UNUSED56, "unused56", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x08, NEXT) +OPDEF(CEE_LDARG, "ldarg", Pop0, Push1, InlineVar, 0, 2, 0xFE, 0x09, NEXT) +OPDEF(CEE_LDARGA, "ldarga", Pop0, PushI, InlineVar, 0, 2, 0xFE, 0x0A, NEXT) +OPDEF(CEE_STARG, "starg", Pop1, Push0, InlineVar, 0, 2, 0xFE, 0x0B, NEXT) +OPDEF(CEE_LDLOC, "ldloc", Pop0, Push1, InlineVar, 0, 2, 0xFE, 0x0C, NEXT) +OPDEF(CEE_LDLOCA, "ldloca", Pop0, PushI, InlineVar, 0, 2, 0xFE, 0x0D, NEXT) +OPDEF(CEE_STLOC, "stloc", Pop1, Push0, InlineVar, 0, 2, 0xFE, 0x0E, NEXT) +OPDEF(CEE_LOCALLOC, "localloc", PopI, PushI, InlineNone, 0, 2, 0xFE, 0x0F, NEXT) +OPDEF(CEE_UNUSED57, "unused57", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x10, NEXT) +OPDEF(CEE_ENDFILTER, "endfilter", PopI, Push0, InlineNone, 0, 2, 0xFE, 0x11, RETURN) +OPDEF(CEE_UNALIGNED_, "unaligned.", Pop0, Push0, ShortInlineI, 0, 2, 0xFE, 0x12, META) +OPDEF(CEE_VOLATILE_, "volatile.", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x13, META) +OPDEF(CEE_TAIL_, "tail.", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x14, META) +OPDEF(CEE_INITOBJ, "initobj", PopI, Push0, InlineType, 0, 2, 0xFE, 0x15, NEXT) +OPDEF(CEE_CONSTRAINED_, "constrained.", Pop0, Push0, InlineType, 0, 2, 0xFE, 0x16, META) +OPDEF(CEE_CPBLK, "cpblk", PopI+PopI+PopI, Push0, InlineNone, 0, 2, 0xFE, 0x17, NEXT) +OPDEF(CEE_INITBLK, "initblk", PopI+PopI+PopI, Push0, InlineNone, 0, 2, 0xFE, 0x18, NEXT) +OPDEF(CEE_NO_, "no.", Pop0, Push0, ShortInlineI, 0, 2, 0xFE, 0x19, NEXT) +OPDEF(CEE_RETHROW, "rethrow", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x1A, ERROR) +OPDEF(CEE_UNUSED, "unused", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x1B, NEXT) +OPDEF(CEE_SIZEOF, "sizeof", Pop0, PushI, InlineType, 0, 2, 0xFE, 0x1C, NEXT) +OPDEF(CEE_REFANYTYPE, "refanytype", Pop1, PushI, InlineNone, 0, 2, 0xFE, 0x1D, NEXT) +OPDEF(CEE_READONLY_, "readonly.", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x1E, META) +OPDEF(CEE_UNUSED53, "unused53", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x1F, NEXT) +OPDEF(CEE_UNUSED54, "unused54", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x20, NEXT) +OPDEF(CEE_UNUSED55, "unused55", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x21, NEXT) +OPDEF(CEE_UNUSED70, "unused70", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x22, NEXT) +OPDEF(CEE_ILLEGAL, "illegal", Pop0, Push0, InlineNone, 0, 2, 0x00, 0x00, META) +OPDEF(CEE_ENDMAC, "endmac", Pop0, Push0, InlineNone, 0, 2, 0x00, 0x00, META) +OPDEF(CEE_MONO_ICALL, "mono_icall", VarPop, VarPush, InlineI, 0, 2, 0xF0, 0x00, NEXT) +OPDEF(CEE_MONO_OBJADDR, "mono_objaddr", Pop1, PushI, InlineNone, 0, 2, 0xF0, 0x01, NEXT) +OPDEF(CEE_MONO_LDPTR, "mono_ldptr", Pop0, PushI, InlineI, 0, 2, 0xF0, 0x02, NEXT) +OPDEF(CEE_MONO_VTADDR, "mono_vtaddr", Pop1, PushI, InlineNone, 0, 2, 0xF0, 0x03, NEXT) +OPDEF(CEE_MONO_NEWOBJ, "mono_newobj", Pop0, PushRef, InlineType, 0, 2, 0xF0, 0x04, NEXT) +OPDEF(CEE_MONO_RETOBJ, "mono_retobj", PopI, Push0, InlineType, 0, 2, 0xF0, 0x05, RETURN) +OPDEF(CEE_MONO_LDNATIVEOBJ, "mono_ldnativeobj", PopI, Push1, InlineType, 0, 2, 0xF0, 0x06, RETURN) +OPDEF(CEE_MONO_CISINST, "mono_cisinst", PopRef, Push1, InlineType, 0, 2, 0xF0, 0x07, NEXT) +OPDEF(CEE_MONO_CCASTCLASS, "mono_ccastclass", PopRef, Push1, InlineType, 0, 2, 0xF0, 0x08, NEXT) +OPDEF(CEE_MONO_SAVE_LMF, "mono_save_lmf", Pop0, Push0, InlineNone, 0, 2, 0xF0, 0x09, NEXT) +OPDEF(CEE_MONO_RESTORE_LMF, "mono_restore_lmf", Pop0, Push0, InlineNone, 0, 2, 0xF0, 0x0A, NEXT) +OPDEF(CEE_MONO_CLASSCONST, "mono_classconst", Pop0, PushI, InlineI, 0, 2, 0xF0, 0x0B, NEXT) +OPDEF(CEE_MONO_NOT_TAKEN, "mono_not_taken", Pop0, Push0, InlineNone, 0, 2, 0xF0, 0x0C, NEXT) +OPDEF(CEE_MONO_TLS, "mono_tls", Pop0, PushI, InlineI, 0, 2, 0xF0, 0x0D, NEXT) +OPDEF(CEE_MONO_ICALL_ADDR, "mono_icall_addr", Pop0, PushI, InlineI, 0, 2, 0xF0, 0x0E, NEXT) +OPDEF(CEE_MONO_DYN_CALL, "mono_dyn_call", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x0F, NEXT) +OPDEF(CEE_MONO_MEMORY_BARRIER, "mono_memory_barrier", Pop0, Push0, InlineI, 0, 2, 0xF0, 0x10, NEXT) +OPDEF(CEE_UNUSED71, "unused71", Pop0, Push0, InlineNone, 0, 2, 0xF0, 0x11, NEXT) +OPDEF(CEE_UNUSED72, "unused72", Pop0, Push0, InlineNone, 0, 2, 0xF0, 0x12, NEXT) +OPDEF(CEE_MONO_JIT_ICALL_ADDR, "mono_jit_icall_addr", Pop0, PushI, InlineI, 0, 2, 0xF0, 0x13, NEXT) +OPDEF(CEE_MONO_LDPTR_INT_REQ_FLAG, "mono_ldptr_int_req_flag", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x14, NEXT) +OPDEF(CEE_MONO_LDPTR_CARD_TABLE, "mono_ldptr_card_table", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x15, NEXT) +OPDEF(CEE_MONO_LDPTR_NURSERY_START, "mono_ldptr_nursery_start", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x16, NEXT) +OPDEF(CEE_MONO_LDPTR_NURSERY_BITS, "mono_ldptr_nursery_bits", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x17, NEXT) +OPDEF(CEE_MONO_CALLI_EXTRA_ARG, "mono_calli_extra_arg", VarPop, VarPush, InlineSig, 0, 2, 0xF0, 0x18, CALL) +OPDEF(CEE_MONO_LDDOMAIN, "mono_lddomain", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x19, NEXT) +OPDEF(CEE_MONO_ATOMIC_STORE_I4, "mono_atomic_store_i4", PopI+PopI, Push0, InlineI, 0, 2, 0xF0, 0x1A, NEXT) +OPDEF(CEE_MONO_SAVE_LAST_ERROR, "mono_save_last_error", Pop0, Push0, InlineNone, 0, 2, 0xF0, 0x1B, NEXT) +OPDEF(CEE_MONO_GET_RGCTX_ARG, "mono_get_rgctx_arg", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x1C, NEXT) +OPDEF(CEE_MONO_LDPTR_PROFILER_ALLOCATION_COUNT, "mono_ldptr_profiler_allocation_count", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x1D, NEXT) +OPDEF(CEE_MONO_LD_DELEGATE_METHOD_PTR, "mono_ld_delegate_method_ptr", Pop1, PushI, InlineNone, 0, 2, 0xF0, 0x1E, NEXT) +OPDEF(CEE_MONO_RETHROW, "mono_rethrow", PopRef, Push0, InlineNone, 0, 2, 0xF0, 0x1F, ERROR) +OPDEF(CEE_MONO_GET_SP, "mono_get_sp", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x20, NEXT) +OPDEF(CEE_MONO_METHODCONST, "mono_methodconst", Pop0, PushI, InlineI, 0, 2, 0xF0, 0x21, NEXT) +OPDEF(CEE_MONO_PINVOKE_ADDR_CACHE, "mono_pinvoke_addr_cache", Pop0, PushI, InlineI, 0, 2, 0xF0, 0x22, NEXT) +#ifndef OPALIAS +#define _MONO_CIL_OPALIAS_DEFINED_ +#define OPALIAS(a,s,r) +#endif + +OPALIAS(CEE_BRNULL, "brnull", CEE_BRFALSE) +OPALIAS(CEE_BRNULL_S, "brnull.s", CEE_BRFALSE_S) +OPALIAS(CEE_BRZERO, "brzero", CEE_BRFALSE) +OPALIAS(CEE_BRZERO_S, "brzero.s", CEE_BRFALSE_S) +OPALIAS(CEE_BRINST, "brinst", CEE_BRTRUE) +OPALIAS(CEE_BRINST_S, "brinst.s", CEE_BRTRUE_S) +OPALIAS(CEE_LDIND_U8, "ldind.u8", CEE_LDIND_I8) +OPALIAS(CEE_LDELEM_U8, "ldelem.u8", CEE_LDELEM_I8) +OPALIAS(CEE_LDX_I4_MIX, "ldc.i4.M1", CEE_LDC_I4_M1) +OPALIAS(CEE_ENDFAULT, "endfault", CEE_ENDFINALLY) + +#ifdef _MONO_CIL_OPALIAS_DEFINED_ +#undef OPALIAS +#undef _MONO_CIL_OPALIAS_DEFINED_ +#endif diff --git a/src/mono/msvc/include/mono/jit/jit.h b/src/mono/msvc/include/mono/jit/jit.h new file mode 100644 index 0000000000000..02639c95122de --- /dev/null +++ b/src/mono/msvc/include/mono/jit/jit.h @@ -0,0 +1,120 @@ +/** + * \file + * Author: + * Dietmar Maurer (dietmar@ximian.com) + * + * (C) 2001, 2002, 2003 Ximian, Inc. + */ + +#ifndef _MONO_JIT_JIT_H_ +#define _MONO_JIT_JIT_H_ + +#include + +MONO_BEGIN_DECLS + +MONO_API MONO_RT_EXTERNAL_ONLY MonoDomain * +mono_jit_init (const char *file); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoDomain * +mono_jit_init_version (const char *root_domain_name, const char *runtime_version); + +MONO_API MonoDomain * +mono_jit_init_version_for_test_only (const char *root_domain_name, const char *runtime_version); + +MONO_API int +mono_jit_exec (MonoDomain *domain, MonoAssembly *assembly, + int argc, char *argv[]); +MONO_API void +mono_jit_cleanup (MonoDomain *domain); + +MONO_API mono_bool +mono_jit_set_trace_options (const char* options); + +MONO_API void +mono_set_signal_chaining (mono_bool chain_signals); + +MONO_API void +mono_set_crash_chaining (mono_bool chain_signals); + +/** + * This function is deprecated, use mono_jit_set_aot_mode instead. + */ +MONO_API void +mono_jit_set_aot_only (mono_bool aot_only); + +/** + * Allows control over our AOT (Ahead-of-time) compilation mode. + */ +typedef enum { + /* Disables AOT mode */ + MONO_AOT_MODE_NONE, + /* Enables normal AOT mode, equivalent to mono_jit_set_aot_only (false) */ + MONO_AOT_MODE_NORMAL, + /* Enables hybrid AOT mode, JIT can still be used for wrappers */ + MONO_AOT_MODE_HYBRID, + /* Enables full AOT mode, JIT is disabled and not allowed, + * equivalent to mono_jit_set_aot_only (true) */ + MONO_AOT_MODE_FULL, + /* Same as full, but use only llvm compiled code */ + MONO_AOT_MODE_LLVMONLY, + /* Uses Interpreter, JIT is disabled and not allowed, + * equivalent to "--full-aot --interpreter" */ + MONO_AOT_MODE_INTERP, + /* Same as INTERP, but use only llvm compiled code */ + MONO_AOT_MODE_INTERP_LLVMONLY, + /* Use only llvm compiled code, fall back to the interpeter */ + MONO_AOT_MODE_LLVMONLY_INTERP, + /* Same as --interp */ + MONO_AOT_MODE_INTERP_ONLY, + /* Sentinel value used internally by the runtime. We use a large number to avoid clashing with some internal values. */ + MONO_AOT_MODE_LAST = 1000, +} MonoAotMode; + +MONO_API void +mono_jit_set_aot_mode (MonoAotMode mode); + +/* + * Returns whether the runtime was invoked for the purpose of AOT-compiling an + * assembly, i.e. no managed code will run. + */ +MONO_API mono_bool +mono_jit_aot_compiling (void); + +/* Allow embedders to decide wherther to actually obey breakpoint instructions + * in specific methods (works for both break IL instructions and Debugger.Break () + * method calls). + */ +typedef enum { + /* the default is to always obey the breakpoint */ + MONO_BREAK_POLICY_ALWAYS, + /* a nop is inserted instead of a breakpoint */ + MONO_BREAK_POLICY_NEVER, + /* the breakpoint is executed only if the program has ben started under + * the debugger (that is if a debugger was attached at the time the method + * was compiled). + */ + MONO_BREAK_POLICY_ON_DBG +} MonoBreakPolicy; + +typedef MonoBreakPolicy (*MonoBreakPolicyFunc) (MonoMethod *method); +MONO_API void mono_set_break_policy (MonoBreakPolicyFunc policy_callback); + +MONO_API void +mono_jit_parse_options (int argc, char * argv[]); + +MONO_API char* mono_get_runtime_build_info (void); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_set_use_llvm (mono_bool use_llvm); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_aot_register_module (void **aot_info); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoDomain* mono_jit_thread_attach (MonoDomain *domain); + +MONO_END_DECLS + +#endif + diff --git a/src/mono/msvc/include/mono/jit/mono-private-unstable.h b/src/mono/msvc/include/mono/jit/mono-private-unstable.h new file mode 100644 index 0000000000000..4d746dd00e258 --- /dev/null +++ b/src/mono/msvc/include/mono/jit/mono-private-unstable.h @@ -0,0 +1,39 @@ +/** + * \file + * + * Private unstable APIs. + * + * WARNING: The declarations and behavior of functions in this header are NOT STABLE and can be modified or removed at + * any time. + * + */ + + +#ifndef __MONO_JIT_MONO_PRIVATE_UNSTABLE_H__ +#define __MONO_JIT_MONO_PRIVATE_UNSTABLE_H__ + +#include +#include + +/* These are used to load the AOT data for aot images compiled with MONO_AOT_FILE_FLAG_SEPARATE_DATA */ +/* + * Return the AOT data for ASSEMBLY. SIZE is the size of the data. OUT_HANDLE should be set to a handle which is later + * passed to the free function. + */ +typedef unsigned char* (*MonoLoadAotDataFunc) (MonoAssembly *assembly, int size, void* user_data, void **out_handle); +/* Not yet used */ +typedef void (*MonoFreeAotDataFunc) (MonoAssembly *assembly, int size, void* user_data, void *handle); +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_install_load_aot_data_hook (MonoLoadAotDataFunc load_func, MonoFreeAotDataFunc free_func, void* user_data); + +MONO_API int +monovm_initialize (int propertyCount, const char **propertyKeys, const char **propertyValues); + +//#ifdef HOST_WASM +typedef void* (*MonoWasmGetNativeToInterpTramp) (MonoMethod *method, void *extra_arg); + +MONO_API void +mono_wasm_install_get_native_to_interp_tramp (MonoWasmGetNativeToInterpTramp cb); +//#endif + +#endif /*__MONO_JIT_MONO_PRIVATE_UNSTABLE_H__*/ diff --git a/src/mono/msvc/include/mono/metadata/appdomain.h b/src/mono/msvc/include/mono/metadata/appdomain.h new file mode 100644 index 0000000000000..bc8a1f2de199c --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/appdomain.h @@ -0,0 +1,234 @@ +/** + * \file + * AppDomain functions + * + * Author: + * Dietmar Maurer (dietmar@ximian.com) + * + * (C) 2001 Ximian, Inc. + */ + +#ifndef _MONO_METADATA_APPDOMAIN_H_ +#define _MONO_METADATA_APPDOMAIN_H_ + +#include + +#include +#include +#include + +MONO_BEGIN_DECLS + +typedef void (*MonoThreadStartCB) (intptr_t tid, void* stack_start, + void* func); +typedef void (*MonoThreadAttachCB) (intptr_t tid, void* stack_start); + +typedef struct _MonoAppDomain MonoAppDomain; + +typedef void (*MonoDomainFunc) (MonoDomain *domain, void* user_data); + +MONO_API MonoDomain* +mono_init (const char *filename); + +MONO_API MonoDomain * +mono_init_from_assembly (const char *domain_name, const char *filename); + +MONO_API MonoDomain * +mono_init_version (const char *domain_name, const char *version); + +MONO_API MonoDomain* +mono_get_root_domain (void); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_runtime_init (MonoDomain *domain, MonoThreadStartCB start_cb, + MonoThreadAttachCB attach_cb); + +MONO_API void +mono_runtime_cleanup (MonoDomain *domain); + +MONO_API void +mono_install_runtime_cleanup (MonoDomainFunc func); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_runtime_quit (void); + +MONO_API void +mono_runtime_set_shutting_down (void); + +MONO_API mono_bool +mono_runtime_is_shutting_down (void); + +MONO_API const char* +mono_check_corlib_version (void); + +MONO_API MonoDomain * +mono_domain_create (void); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoDomain * +mono_domain_create_appdomain (char *friendly_name, char *configuration_file); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_domain_set_config (MonoDomain *domain, const char *base_dir, const char *config_file_name); + +MONO_API MonoDomain * +mono_domain_get (void); + +MONO_API MonoDomain * +mono_domain_get_by_id (int32_t domainid); + +MONO_API int32_t +mono_domain_get_id (MonoDomain *domain); + +MONO_API const char * +mono_domain_get_friendly_name (MonoDomain *domain); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_domain_set (MonoDomain *domain, mono_bool force); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_domain_set_internal (MonoDomain *domain); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_domain_unload (MonoDomain *domain); + +MONO_API void +mono_domain_try_unload (MonoDomain *domain, MonoObject **exc); + +MONO_API mono_bool +mono_domain_is_unloading (MonoDomain *domain); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoDomain * +mono_domain_from_appdomain (MonoAppDomain *appdomain); + +MONO_API void +mono_domain_foreach (MonoDomainFunc func, void* user_data); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoAssembly * +mono_domain_assembly_open (MonoDomain *domain, const char *name); + +MONO_API void +mono_domain_ensure_entry_assembly (MonoDomain *domain, MonoAssembly *assembly); + +MONO_API mono_bool +mono_domain_finalize (MonoDomain *domain, uint32_t timeout); + +MONO_API void +mono_domain_free (MonoDomain *domain, mono_bool force); + +MONO_API mono_bool +mono_domain_has_type_resolve (MonoDomain *domain); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoReflectionAssembly * +mono_domain_try_type_resolve (MonoDomain *domain, char *name, MonoObject *tb); + +MONO_API mono_bool +mono_domain_owns_vtable_slot (MonoDomain *domain, void* vtable_slot); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_context_init (MonoDomain *domain); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_context_set (MonoAppContext *new_context); + +MONO_API MonoAppContext * +mono_context_get (void); + +MONO_API int32_t +mono_context_get_id (MonoAppContext *context); + +MONO_API int32_t +mono_context_get_domain_id (MonoAppContext *context); + +MONO_API MonoJitInfo * +mono_jit_info_table_find (MonoDomain *domain, void* addr); + +/* MonoJitInfo accessors */ + +MONO_API void* +mono_jit_info_get_code_start (MonoJitInfo* ji); + +MONO_API int +mono_jit_info_get_code_size (MonoJitInfo* ji); + +MONO_API MonoMethod* +mono_jit_info_get_method (MonoJitInfo* ji); + + +MONO_API MonoImage* +mono_get_corlib (void); + +MONO_API MonoClass* +mono_get_object_class (void); + +MONO_API MonoClass* +mono_get_byte_class (void); + +MONO_API MonoClass* +mono_get_void_class (void); + +MONO_API MonoClass* +mono_get_boolean_class (void); + +MONO_API MonoClass* +mono_get_sbyte_class (void); + +MONO_API MonoClass* +mono_get_int16_class (void); + +MONO_API MonoClass* +mono_get_uint16_class (void); + +MONO_API MonoClass* +mono_get_int32_class (void); + +MONO_API MonoClass* +mono_get_uint32_class (void); + +MONO_API MonoClass* +mono_get_intptr_class (void); + +MONO_API MonoClass* +mono_get_uintptr_class (void); + +MONO_API MonoClass* +mono_get_int64_class (void); + +MONO_API MonoClass* +mono_get_uint64_class (void); + +MONO_API MonoClass* +mono_get_single_class (void); + +MONO_API MonoClass* +mono_get_double_class (void); + +MONO_API MonoClass* +mono_get_char_class (void); + +MONO_API MonoClass* +mono_get_string_class (void); + +MONO_API MonoClass* +mono_get_enum_class (void); + +MONO_API MonoClass* +mono_get_array_class (void); + +MONO_API MonoClass* +mono_get_thread_class (void); + +MONO_API MonoClass* +mono_get_exception_class (void); + +MONO_API void +mono_security_enable_core_clr (void); + +typedef mono_bool (*MonoCoreClrPlatformCB) (const char *image_name); + +MONO_API void +mono_security_set_core_clr_platform_callback (MonoCoreClrPlatformCB callback); + +MONO_END_DECLS + +#endif /* _MONO_METADATA_APPDOMAIN_H_ */ + diff --git a/src/mono/msvc/include/mono/metadata/assembly.h b/src/mono/msvc/include/mono/metadata/assembly.h new file mode 100644 index 0000000000000..e9c02ee26f5be --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/assembly.h @@ -0,0 +1,136 @@ +/** + * \file + */ + +#ifndef _MONONET_METADATA_ASSEMBLY_H_ +#define _MONONET_METADATA_ASSEMBLY_H_ + +#include +#include + +MONO_BEGIN_DECLS + +MONO_API void mono_assemblies_init (void); +MONO_API void mono_assemblies_cleanup (void); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoAssembly *mono_assembly_open (const char *filename, + MonoImageOpenStatus *status); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoAssembly *mono_assembly_open_full (const char *filename, + MonoImageOpenStatus *status, + mono_bool refonly); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoAssembly* mono_assembly_load (MonoAssemblyName *aname, + const char *basedir, + MonoImageOpenStatus *status); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoAssembly* mono_assembly_load_full (MonoAssemblyName *aname, + const char *basedir, + MonoImageOpenStatus *status, + mono_bool refonly); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoAssembly* mono_assembly_load_from (MonoImage *image, const char *fname, + MonoImageOpenStatus *status); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoAssembly* mono_assembly_load_from_full (MonoImage *image, const char *fname, + MonoImageOpenStatus *status, + mono_bool refonly); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoAssembly* mono_assembly_load_with_partial_name (const char *name, MonoImageOpenStatus *status); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoAssembly* mono_assembly_loaded (MonoAssemblyName *aname); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoAssembly* mono_assembly_loaded_full (MonoAssemblyName *aname, mono_bool refonly); +MONO_API void mono_assembly_get_assemblyref (MonoImage *image, int index, MonoAssemblyName *aname); +MONO_API void mono_assembly_load_reference (MonoImage *image, int index); +MONO_API void mono_assembly_load_references (MonoImage *image, MonoImageOpenStatus *status); +MONO_API MONO_RT_EXTERNAL_ONLY MonoImage* mono_assembly_load_module (MonoAssembly *assembly, uint32_t idx); +MONO_API void mono_assembly_close (MonoAssembly *assembly); +MONO_API void mono_assembly_setrootdir (const char *root_dir); +MONO_API MONO_CONST_RETURN char *mono_assembly_getrootdir (void); +MONO_API char *mono_native_getrootdir (void); +MONO_API void mono_assembly_foreach (MonoFunc func, void* user_data); +MONO_API void mono_assembly_set_main (MonoAssembly *assembly); +MONO_API MonoAssembly *mono_assembly_get_main (void); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoImage *mono_assembly_get_image (MonoAssembly *assembly); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoAssemblyName *mono_assembly_get_name (MonoAssembly *assembly); +MONO_API mono_bool mono_assembly_fill_assembly_name (MonoImage *image, MonoAssemblyName *aname); +MONO_API mono_bool mono_assembly_names_equal (MonoAssemblyName *l, MonoAssemblyName *r); +MONO_API char* mono_stringify_assembly_name (MonoAssemblyName *aname); + +/* Installs a function which is called each time a new assembly is loaded. */ +typedef void (*MonoAssemblyLoadFunc) (MonoAssembly *assembly, void* user_data); +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_install_assembly_load_hook (MonoAssemblyLoadFunc func, void* user_data); + +/* + * Installs a new function which is used to search the list of loaded + * assemblies for a given assembly name. + */ +typedef MonoAssembly *(*MonoAssemblySearchFunc) (MonoAssemblyName *aname, void* user_data); +MONO_API MONO_RT_EXTERNAL_ONLY +void mono_install_assembly_search_hook (MonoAssemblySearchFunc func, void* user_data); +MONO_API MONO_RT_EXTERNAL_ONLY +void mono_install_assembly_refonly_search_hook (MonoAssemblySearchFunc func, void* user_data); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoAssembly* mono_assembly_invoke_search_hook (MonoAssemblyName *aname); + +/* + * Installs a new search function which is used as a last resort when loading + * an assembly fails. This could invoke AssemblyResolve events. + */ +MONO_API MONO_RT_EXTERNAL_ONLY +void +mono_install_assembly_postload_search_hook (MonoAssemblySearchFunc func, void* user_data); + +MONO_API MONO_RT_EXTERNAL_ONLY +void +mono_install_assembly_postload_refonly_search_hook (MonoAssemblySearchFunc func, void* user_data); + + +/* Installs a function which is called before a new assembly is loaded + * The hook are invoked from last hooked to first. If any of them returns + * a non-null value, that will be the value returned in mono_assembly_load */ +typedef MonoAssembly * (*MonoAssemblyPreLoadFunc) (MonoAssemblyName *aname, + char **assemblies_path, + void* user_data); + +MONO_API MONO_RT_EXTERNAL_ONLY +void mono_install_assembly_preload_hook (MonoAssemblyPreLoadFunc func, void* user_data); +MONO_API MONO_RT_EXTERNAL_ONLY +void mono_install_assembly_refonly_preload_hook (MonoAssemblyPreLoadFunc func, void* user_data); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_assembly_invoke_load_hook (MonoAssembly *ass); + +MONO_API MonoAssemblyName* mono_assembly_name_new (const char *name); +MONO_API const char* mono_assembly_name_get_name (MonoAssemblyName *aname); +MONO_API const char* mono_assembly_name_get_culture (MonoAssemblyName *aname); +MONO_API uint16_t mono_assembly_name_get_version (MonoAssemblyName *aname, + uint16_t *minor, uint16_t *build, uint16_t *revision); +MONO_API mono_byte* mono_assembly_name_get_pubkeytoken (MonoAssemblyName *aname); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_assembly_name_free (MonoAssemblyName *aname); + +typedef struct { + const char *name; + const unsigned char *data; + unsigned int size; +} MonoBundledAssembly; + +MONO_API void mono_register_bundled_assemblies (const MonoBundledAssembly **assemblies); +MONO_API void mono_register_config_for_assembly (const char* assembly_name, const char* config_xml); +MONO_API void mono_register_symfile_for_assembly (const char* assembly_name, const mono_byte *raw_contents, int size); +MONO_API void mono_register_machine_config (const char *config_xml); + +MONO_API void mono_set_rootdir (void); +MONO_API void mono_set_dirs (const char *assembly_dir, const char *config_dir); +MONO_API void mono_set_assemblies_path (const char* path); +MONO_END_DECLS + +#endif + diff --git a/src/mono/msvc/include/mono/metadata/attrdefs.h b/src/mono/msvc/include/mono/metadata/attrdefs.h new file mode 100644 index 0000000000000..504c6c65fc6d2 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/attrdefs.h @@ -0,0 +1,274 @@ +/** + * \file + * This file contains the various definitions for constants + * found on the metadata tables + * + * Author: + * Miguel de Icaza (miguel@ximian.com) + * Paolo Molaro (lupus@ximian.com) + * + * (C) 2001 Ximian, Inc. + * (C) 2006 Novell, Inc. + * + * From the ECMA documentation + */ + +#ifndef _MONO_METADATA_ATTRDEFS_H_ +#define _MONO_METADATA_ATTRDEFS_H_ + +/* + * 23.1.1 Values for AssemblyHashAlgorithm + */ +enum { + MONO_ASSEMBLY_HASH_NONE, + MONO_ASSEMBLY_HASH_MD5 = 0x8003, + MONO_ASSEMBLY_HASH_SHA1 = 0x8004 +}; + +/* + * 23.1.2 AssemblyRefs + */ +enum { + MONO_ASSEMBLYREF_FULL_PUBLIC_KEY = 0x0001, + MONO_ASSEMBLYREF_RETARGETABLE = 0x0100, + MONO_ASSEMBLYREF_JIT_TRACKING = 0x8000, + MONO_ASSEMBLYREF_NO_JIT_OPT = 0x4000 +}; + +/* + * 23.1.4 Flags for Event.EventAttributes + */ +enum { + MONO_EVENT_SPECIALNAME = 0x0200, + MONO_EVENT_RTSPECIALNAME = 0x0400 +}; + +/* + * Field Attributes (23.1.5). + */ +enum { + MONO_FIELD_ATTR_FIELD_ACCESS_MASK = 0x0007, + MONO_FIELD_ATTR_COMPILER_CONTROLLED = 0x0000, + MONO_FIELD_ATTR_PRIVATE = 0x0001, + MONO_FIELD_ATTR_FAM_AND_ASSEM = 0x0002, + MONO_FIELD_ATTR_ASSEMBLY = 0x0003, + MONO_FIELD_ATTR_FAMILY = 0x0004, + MONO_FIELD_ATTR_FAM_OR_ASSEM = 0x0005, + MONO_FIELD_ATTR_PUBLIC = 0x0006, + + MONO_FIELD_ATTR_STATIC = 0x0010, + MONO_FIELD_ATTR_INIT_ONLY = 0x0020, + MONO_FIELD_ATTR_LITERAL = 0x0040, + MONO_FIELD_ATTR_NOT_SERIALIZED = 0x0080, + MONO_FIELD_ATTR_SPECIAL_NAME = 0x0200, + MONO_FIELD_ATTR_PINVOKE_IMPL = 0x2000, + +/* For runtime use only */ + MONO_FIELD_ATTR_RESERVED_MASK = 0x9500, + MONO_FIELD_ATTR_RT_SPECIAL_NAME = 0x0400, + MONO_FIELD_ATTR_HAS_MARSHAL = 0x1000, + MONO_FIELD_ATTR_HAS_DEFAULT = 0x8000, + MONO_FIELD_ATTR_HAS_RVA = 0x0100 +}; + +/* + * 23.1.6 Flags for FileAttributes + */ +enum { + MONO_FILE_HAS_METADATA = 0, + MONO_FILE_HAS_NO_METADATA = 1 +}; + +/* + * 23.1.7 Flags for generic parameters + */ +enum { + MONO_GEN_PARAM_VARIANCE_MASK = 0x0003, + MONO_GEN_PARAM_NON_VARIANT = 0x0000, + MONO_GEN_PARAM_VARIANT = 0x0001, + MONO_GEN_PARAM_COVARIANT = 0x0002, + MONO_GEN_PARAM_CONSTRAINT_MASK = 0x001c, + MONO_GEN_PARAM_CONSTRAINT_CLASS = 0x0004, + MONO_GEN_PARAM_CONSTRAINT_VTYPE = 0x0008, + MONO_GEN_PARAM_CONSTRAINT_DCTOR = 0x0010 +}; + +/* + * 23.1.8 Flags for ImplMap [PInvokeAttributes] + */ +enum { + MONO_PINVOKE_NO_MANGLE = 0x0001, + MONO_PINVOKE_CHAR_SET_MASK = 0x0006, + MONO_PINVOKE_CHAR_SET_NOT_SPEC = 0x0000, + MONO_PINVOKE_CHAR_SET_ANSI = 0x0002, + MONO_PINVOKE_CHAR_SET_UNICODE = 0x0004, + MONO_PINVOKE_CHAR_SET_AUTO = 0x0006, + MONO_PINVOKE_BEST_FIT_ENABLED = 0x0010, + MONO_PINVOKE_BEST_FIT_DISABLED = 0x0020, + MONO_PINVOKE_BEST_FIT_MASK = 0x0030, + MONO_PINVOKE_SUPPORTS_LAST_ERROR = 0x0040, + MONO_PINVOKE_CALL_CONV_MASK = 0x0700, + MONO_PINVOKE_CALL_CONV_WINAPI = 0x0100, + MONO_PINVOKE_CALL_CONV_CDECL = 0x0200, + MONO_PINVOKE_CALL_CONV_STDCALL = 0x0300, + MONO_PINVOKE_CALL_CONV_THISCALL = 0x0400, + MONO_PINVOKE_CALL_CONV_FASTCALL = 0x0500, + MONO_PINVOKE_THROW_ON_UNMAPPABLE_ENABLED = 0x1000, + MONO_PINVOKE_THROW_ON_UNMAPPABLE_DISABLED = 0x2000, + MONO_PINVOKE_THROW_ON_UNMAPPABLE_MASK = 0x3000, + MONO_PINVOKE_CALL_CONV_GENERIC = 0x0010, + MONO_PINVOKE_CALL_CONV_GENERICINST = 0x000a +}; + +/* + * 23.1.9 Flags for ManifestResource + */ +enum { + MONO_MANIFEST_RESOURCE_VISIBILITY_MASK = 0x00000007, + MONO_MANIFEST_RESOURCE_PUBLIC = 0x00000001, + MONO_MANIFEST_RESOURCE_PRIVATE = 0x00000002 +}; + +/* + * Method Attributes (23.1.10) + */ +enum { + MONO_METHOD_ATTR_ACCESS_MASK = 0x0007, + MONO_METHOD_ATTR_COMPILER_CONTROLLED = 0x0000, + MONO_METHOD_ATTR_PRIVATE = 0x0001, + MONO_METHOD_ATTR_FAM_AND_ASSEM = 0x0002, + MONO_METHOD_ATTR_ASSEM = 0x0003, + MONO_METHOD_ATTR_FAMILY = 0x0004, + MONO_METHOD_ATTR_FAM_OR_ASSEM = 0x0005, + MONO_METHOD_ATTR_PUBLIC = 0x0006, + + MONO_METHOD_ATTR_STATIC = 0x0010, + MONO_METHOD_ATTR_FINAL = 0x0020, + MONO_METHOD_ATTR_VIRTUAL = 0x0040, + MONO_METHOD_ATTR_HIDE_BY_SIG = 0x0080, + + MONO_METHOD_ATTR_VTABLE_LAYOUT_MASK = 0x0100, + MONO_METHOD_ATTR_REUSE_SLOT = 0x0000, + MONO_METHOD_ATTR_NEW_SLOT = 0x0100, + MONO_METHOD_ATTR_STRICT = 0x0200, + MONO_METHOD_ATTR_ABSTRACT = 0x0400, + + MONO_METHOD_ATTR_SPECIAL_NAME = 0x0800, + + MONO_METHOD_ATTR_PINVOKE_IMPL = 0x2000, + MONO_METHOD_ATTR_UNMANAGED_EXPORT = 0x0008, + +/* + * For runtime use only + */ + MONO_METHOD_ATTR_RESERVED_MASK = 0xd000, + MONO_METHOD_ATTR_RT_SPECIAL_NAME = 0x1000, + MONO_METHOD_ATTR_HAS_SECURITY = 0x4000, + MONO_METHOD_ATTR_REQUIRE_SEC_OBJECT = 0x8000 +}; + +/* + * Method Impl Attributes (23.1.11) + */ +enum { + MONO_METHOD_IMPL_ATTR_CODE_TYPE_MASK = 0x0003, + MONO_METHOD_IMPL_ATTR_IL = 0x0000, + MONO_METHOD_IMPL_ATTR_NATIVE = 0x0001, + MONO_METHOD_IMPL_ATTR_OPTIL = 0x0002, + MONO_METHOD_IMPL_ATTR_RUNTIME = 0x0003, + + MONO_METHOD_IMPL_ATTR_MANAGED_MASK = 0x0004, + MONO_METHOD_IMPL_ATTR_UNMANAGED = 0x0004, + MONO_METHOD_IMPL_ATTR_MANAGED = 0x0000, + + MONO_METHOD_IMPL_ATTR_FORWARD_REF = 0x0010, + MONO_METHOD_IMPL_ATTR_PRESERVE_SIG = 0x0080, + MONO_METHOD_IMPL_ATTR_INTERNAL_CALL = 0x1000, + MONO_METHOD_IMPL_ATTR_SYNCHRONIZED = 0x0020, + MONO_METHOD_IMPL_ATTR_NOINLINING = 0x0008, + MONO_METHOD_IMPL_ATTR_NOOPTIMIZATION = 0x0040, + MONO_METHOD_IMPL_ATTR_MAX_METHOD_IMPL_VAL = 0xffff +}; + +/* + * Method Semantics ([MethodSemanticAttributes]) 23.1.12, + */ +enum { + MONO_METHOD_SEMANTIC_SETTER = 0x0001, + MONO_METHOD_SEMANTIC_GETTER = 0x0002, + MONO_METHOD_SEMANTIC_OTHER = 0x0004, + MONO_METHOD_SEMANTIC_ADD_ON = 0x0008, + MONO_METHOD_SEMANTIC_REMOVE_ON = 0x0010, + MONO_METHOD_SEMANTIC_FIRE = 0x0020 +}; + +/* + * Flags for Params (23.1.13) + */ +enum { + MONO_PARAM_ATTR_IN = 0x0001, + MONO_PARAM_ATTR_OUT = 0x0002, + MONO_PARAM_ATTR_OPTIONAL = 0x0010, + MONO_PARAM_ATTR_RESERVED_MASK = 0xf000, + MONO_PARAM_ATTR_HAS_DEFAULT = 0x1000, + MONO_PARAM_ATTR_HAS_MARSHAL = 0x2000, + MONO_PARAM_ATTR_UNUSED = 0xcfe0 +}; + +/* + * 23.1.14 PropertyAttributes + */ +enum { + MONO_PROPERTY_ATTR_SPECIAL_NAME = 0x0200, + MONO_PROPERTY_ATTR_RESERVED_MASK = 0xf400, + MONO_PROPERTY_ATTR_RT_SPECIAL_NAME = 0x0400, + MONO_PROPERTY_ATTR_HAS_DEFAULT = 0x1000, + MONO_PROPERTY_ATTR_UNUSED = 0xe9ff +}; + +/* + * Type Attributes (23.1.15). + */ +enum { + MONO_TYPE_ATTR_VISIBILITY_MASK = 0x00000007, + MONO_TYPE_ATTR_NOT_PUBLIC = 0x00000000, + MONO_TYPE_ATTR_PUBLIC = 0x00000001, + MONO_TYPE_ATTR_NESTED_PUBLIC = 0x00000002, + MONO_TYPE_ATTR_NESTED_PRIVATE = 0x00000003, + MONO_TYPE_ATTR_NESTED_FAMILY = 0x00000004, + MONO_TYPE_ATTR_NESTED_ASSEMBLY = 0x00000005, + MONO_TYPE_ATTR_NESTED_FAM_AND_ASSEM = 0x00000006, + MONO_TYPE_ATTR_NESTED_FAM_OR_ASSEM = 0x00000007, + + MONO_TYPE_ATTR_LAYOUT_MASK = 0x00000018, + MONO_TYPE_ATTR_AUTO_LAYOUT = 0x00000000, + MONO_TYPE_ATTR_SEQUENTIAL_LAYOUT = 0x00000008, + MONO_TYPE_ATTR_EXPLICIT_LAYOUT = 0x00000010, + + MONO_TYPE_ATTR_CLASS_SEMANTIC_MASK = 0x00000020, + MONO_TYPE_ATTR_CLASS = 0x00000000, + MONO_TYPE_ATTR_INTERFACE = 0x00000020, + + MONO_TYPE_ATTR_ABSTRACT = 0x00000080, + MONO_TYPE_ATTR_SEALED = 0x00000100, + MONO_TYPE_ATTR_SPECIAL_NAME = 0x00000400, + + MONO_TYPE_ATTR_IMPORT = 0x00001000, + MONO_TYPE_ATTR_SERIALIZABLE = 0x00002000, + + MONO_TYPE_ATTR_STRING_FORMAT_MASK = 0x00030000, + MONO_TYPE_ATTR_ANSI_CLASS = 0x00000000, + MONO_TYPE_ATTR_UNICODE_CLASS = 0x00010000, + MONO_TYPE_ATTR_AUTO_CLASS = 0x00020000, + MONO_TYPE_ATTR_CUSTOM_CLASS = 0x00030000, + MONO_TYPE_ATTR_CUSTOM_MASK = 0x00c00000, + + MONO_TYPE_ATTR_BEFORE_FIELD_INIT = 0x00100000, + MONO_TYPE_ATTR_FORWARDER = 0x00200000, + + MONO_TYPE_ATTR_RESERVED_MASK = 0x00040800, + MONO_TYPE_ATTR_RT_SPECIAL_NAME = 0x00000800, + MONO_TYPE_ATTR_HAS_SECURITY = 0x00040000 +}; + +#endif diff --git a/src/mono/msvc/include/mono/metadata/blob.h b/src/mono/msvc/include/mono/metadata/blob.h new file mode 100644 index 0000000000000..7405d54466499 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/blob.h @@ -0,0 +1,118 @@ +/** + * \file + * Definitions used to pull information out of the Blob + * + */ +#ifndef _MONO_METADATA_BLOB_H_ +#define _MONO_METADATA_BLOB_H_ + +/* + * Encoding for type signatures used in the Metadata + */ +typedef enum { + MONO_TYPE_END = 0x00, /* End of List */ + MONO_TYPE_VOID = 0x01, + MONO_TYPE_BOOLEAN = 0x02, + MONO_TYPE_CHAR = 0x03, + MONO_TYPE_I1 = 0x04, + MONO_TYPE_U1 = 0x05, + MONO_TYPE_I2 = 0x06, + MONO_TYPE_U2 = 0x07, + MONO_TYPE_I4 = 0x08, + MONO_TYPE_U4 = 0x09, + MONO_TYPE_I8 = 0x0a, + MONO_TYPE_U8 = 0x0b, + MONO_TYPE_R4 = 0x0c, + MONO_TYPE_R8 = 0x0d, + MONO_TYPE_STRING = 0x0e, + MONO_TYPE_PTR = 0x0f, /* arg: token */ + MONO_TYPE_BYREF = 0x10, /* arg: token */ + MONO_TYPE_VALUETYPE = 0x11, /* arg: token */ + MONO_TYPE_CLASS = 0x12, /* arg: token */ + MONO_TYPE_VAR = 0x13, /* number */ + MONO_TYPE_ARRAY = 0x14, /* type, rank, boundsCount, bound1, loCount, lo1 */ + MONO_TYPE_GENERICINST= 0x15, /* \x{2026} */ + MONO_TYPE_TYPEDBYREF = 0x16, + MONO_TYPE_I = 0x18, + MONO_TYPE_U = 0x19, + MONO_TYPE_FNPTR = 0x1b, /* arg: full method signature */ + MONO_TYPE_OBJECT = 0x1c, + MONO_TYPE_SZARRAY = 0x1d, /* 0-based one-dim-array */ + MONO_TYPE_MVAR = 0x1e, /* number */ + MONO_TYPE_CMOD_REQD = 0x1f, /* arg: typedef or typeref token */ + MONO_TYPE_CMOD_OPT = 0x20, /* optional arg: typedef or typref token */ + MONO_TYPE_INTERNAL = 0x21, /* CLR internal type */ + + MONO_TYPE_MODIFIER = 0x40, /* Or with the following types */ + MONO_TYPE_SENTINEL = 0x41, /* Sentinel for varargs method signature */ + MONO_TYPE_PINNED = 0x45, /* Local var that points to pinned object */ + + MONO_TYPE_ENUM = 0x55 /* an enumeration */ +} MonoTypeEnum; + +typedef enum { + MONO_TABLE_MODULE, + MONO_TABLE_TYPEREF, + MONO_TABLE_TYPEDEF, + MONO_TABLE_FIELD_POINTER, + MONO_TABLE_FIELD, + MONO_TABLE_METHOD_POINTER, + MONO_TABLE_METHOD, + MONO_TABLE_PARAM_POINTER, + MONO_TABLE_PARAM, + MONO_TABLE_INTERFACEIMPL, + MONO_TABLE_MEMBERREF, /* 0xa */ + MONO_TABLE_CONSTANT, + MONO_TABLE_CUSTOMATTRIBUTE, + MONO_TABLE_FIELDMARSHAL, + MONO_TABLE_DECLSECURITY, + MONO_TABLE_CLASSLAYOUT, + MONO_TABLE_FIELDLAYOUT, /* 0x10 */ + MONO_TABLE_STANDALONESIG, + MONO_TABLE_EVENTMAP, + MONO_TABLE_EVENT_POINTER, + MONO_TABLE_EVENT, + MONO_TABLE_PROPERTYMAP, + MONO_TABLE_PROPERTY_POINTER, + MONO_TABLE_PROPERTY, + MONO_TABLE_METHODSEMANTICS, + MONO_TABLE_METHODIMPL, + MONO_TABLE_MODULEREF, /* 0x1a */ + MONO_TABLE_TYPESPEC, + MONO_TABLE_IMPLMAP, + MONO_TABLE_FIELDRVA, + MONO_TABLE_ENCLOG, + MONO_TABLE_ENCMAP, + MONO_TABLE_ASSEMBLY, /* 0x20 */ + MONO_TABLE_ASSEMBLYPROCESSOR, + MONO_TABLE_ASSEMBLYOS, + MONO_TABLE_ASSEMBLYREF, + MONO_TABLE_ASSEMBLYREFPROCESSOR, + MONO_TABLE_ASSEMBLYREFOS, + MONO_TABLE_FILE, + MONO_TABLE_EXPORTEDTYPE, + MONO_TABLE_MANIFESTRESOURCE, + MONO_TABLE_NESTEDCLASS, + MONO_TABLE_GENERICPARAM, /* 0x2a */ + MONO_TABLE_METHODSPEC, + MONO_TABLE_GENERICPARAMCONSTRAINT, + MONO_TABLE_UNUSED8, + MONO_TABLE_UNUSED9, + MONO_TABLE_UNUSED10, + /* Portable PDB tables */ + MONO_TABLE_DOCUMENT, /* 0x30 */ + MONO_TABLE_METHODBODY, + MONO_TABLE_LOCALSCOPE, + MONO_TABLE_LOCALVARIABLE, + MONO_TABLE_LOCALCONSTANT, + MONO_TABLE_IMPORTSCOPE, + MONO_TABLE_STATEMACHINEMETHOD, + MONO_TABLE_CUSTOMDEBUGINFORMATION + +#define MONO_TABLE_LAST MONO_TABLE_CUSTOMDEBUGINFORMATION +#define MONO_TABLE_NUM (MONO_TABLE_LAST + 1) + +} MonoMetaTableEnum; + +#endif + diff --git a/src/mono/msvc/include/mono/metadata/class.h b/src/mono/msvc/include/mono/metadata/class.h new file mode 100644 index 0000000000000..8966e029b7c6c --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/class.h @@ -0,0 +1,313 @@ +/** + * \file + */ + +#ifndef _MONO_CLI_CLASS_H_ +#define _MONO_CLI_CLASS_H_ + +#include +#include +#include +#include + +MONO_BEGIN_DECLS + +typedef struct MonoVTable MonoVTable; + +typedef struct _MonoClassField MonoClassField; +typedef struct _MonoProperty MonoProperty; +typedef struct _MonoEvent MonoEvent; + +typedef enum { + MONO_TYPE_NAME_FORMAT_IL, + MONO_TYPE_NAME_FORMAT_REFLECTION, + MONO_TYPE_NAME_FORMAT_FULL_NAME, + MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED +} MonoTypeNameFormat; + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClass * +mono_class_get (MonoImage *image, uint32_t type_token); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClass * +mono_class_get_full (MonoImage *image, uint32_t type_token, MonoGenericContext *context); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_class_init (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoVTable * +mono_class_vtable (MonoDomain *domain, MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoClass * +mono_class_from_name (MonoImage *image, const char* name_space, const char *name); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoClass * +mono_class_from_name_case (MonoImage *image, const char* name_space, const char *name); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod * +mono_class_get_method_from_name_flags (MonoClass *klass, const char *name, int param_count, int flags); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoClass * +mono_class_from_typeref (MonoImage *image, uint32_t type_token); + +MONO_API MonoClass * +mono_class_from_typeref_checked (MonoImage *image, uint32_t type_token, MonoError *error); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClass * +mono_class_from_generic_parameter (MonoGenericParam *param, MonoImage *image, mono_bool is_mvar); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoType* +mono_class_inflate_generic_type (MonoType *type, MonoGenericContext *context) /* MONO_DEPRECATED */; + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoMethod* +mono_class_inflate_generic_method (MonoMethod *method, MonoGenericContext *context); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoMethod * +mono_get_inflated_method (MonoMethod *method); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClassField* +mono_field_from_token (MonoImage *image, uint32_t token, MonoClass **retklass, MonoGenericContext *context); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClass * +mono_bounded_array_class_get (MonoClass *element_class, uint32_t rank, mono_bool bounded); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClass * +mono_array_class_get (MonoClass *element_class, uint32_t rank); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClass * +mono_ptr_class_get (MonoType *type); + +MONO_API MonoClassField * +mono_class_get_field (MonoClass *klass, uint32_t field_token); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClassField * +mono_class_get_field_from_name (MonoClass *klass, const char *name); + +MONO_API uint32_t +mono_class_get_field_token (MonoClassField *field); + +MONO_API uint32_t +mono_class_get_event_token (MonoEvent *event); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoProperty * +mono_class_get_property_from_name (MonoClass *klass, const char *name); + +MONO_API uint32_t +mono_class_get_property_token (MonoProperty *prop); + +MONO_API int32_t +mono_array_element_size (MonoClass *ac); + +MONO_API int32_t +mono_class_instance_size (MonoClass *klass); + +MONO_API int32_t +mono_class_array_element_size (MonoClass *klass); + +MONO_API int32_t +mono_class_data_size (MonoClass *klass); + +MONO_API int32_t +mono_class_value_size (MonoClass *klass, uint32_t *align); + +MONO_API int32_t +mono_class_min_align (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoClass * +mono_class_from_mono_type (MonoType *type); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_class_is_subclass_of (MonoClass *klass, MonoClass *klassc, + mono_bool check_interfaces); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_class_is_assignable_from (MonoClass *klass, MonoClass *oklass); + +MONO_API MONO_RT_EXTERNAL_ONLY +void* +mono_ldtoken (MonoImage *image, uint32_t token, MonoClass **retclass, MonoGenericContext *context); + +MONO_API char * +mono_type_get_name_full (MonoType *type, MonoTypeNameFormat format); + +MONO_API char* +mono_type_get_name (MonoType *type); + +MONO_API MonoType* +mono_type_get_underlying_type (MonoType *type); + +/* MonoClass accessors */ +MONO_API MonoImage* +mono_class_get_image (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClass* +mono_class_get_element_class (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY +mono_bool +mono_class_is_valuetype (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY +mono_bool +mono_class_is_enum (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoType* +mono_class_enum_basetype (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClass* +mono_class_get_parent (MonoClass *klass); + +MONO_API MonoClass* +mono_class_get_nesting_type (MonoClass *klass); + +MONO_API int +mono_class_get_rank (MonoClass *klass); + +MONO_API uint32_t +mono_class_get_flags (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY +const char* +mono_class_get_name (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY +const char* +mono_class_get_namespace (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoType* +mono_class_get_type (MonoClass *klass); + +MONO_API uint32_t +mono_class_get_type_token (MonoClass *klass); + +MONO_API MonoType* +mono_class_get_byref_type (MonoClass *klass); + +MONO_API int +mono_class_num_fields (MonoClass *klass); + +MONO_API int +mono_class_num_methods (MonoClass *klass); + +MONO_API int +mono_class_num_properties (MonoClass *klass); + +MONO_API int +mono_class_num_events (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClassField* +mono_class_get_fields (MonoClass* klass, void **iter); + +MONO_API MonoMethod* +mono_class_get_methods (MonoClass* klass, void **iter); + +MONO_API MonoProperty* +mono_class_get_properties (MonoClass* klass, void **iter); + +MONO_API MonoEvent* +mono_class_get_events (MonoClass* klass, void **iter); + +MONO_API MonoClass* +mono_class_get_interfaces (MonoClass* klass, void **iter); + +MONO_API MonoClass* +mono_class_get_nested_types (MonoClass* klass, void **iter); + +MONO_API MONO_RT_EXTERNAL_ONLY +mono_bool +mono_class_is_delegate (MonoClass* klass); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_class_implements_interface (MonoClass* klass, MonoClass* iface); + +/* MonoClassField accessors */ +MONO_API const char* +mono_field_get_name (MonoClassField *field); + +MONO_API MonoType* +mono_field_get_type (MonoClassField *field); + +MONO_API MonoClass* +mono_field_get_parent (MonoClassField *field); + +MONO_API uint32_t +mono_field_get_flags (MonoClassField *field); + +MONO_API uint32_t +mono_field_get_offset (MonoClassField *field); + +MONO_API const char * +mono_field_get_data (MonoClassField *field); + +/* MonoProperty acessors */ +MONO_API const char* +mono_property_get_name (MonoProperty *prop); + +MONO_API MonoMethod* +mono_property_get_set_method (MonoProperty *prop); + +MONO_API MonoMethod* +mono_property_get_get_method (MonoProperty *prop); + +MONO_API MonoClass* +mono_property_get_parent (MonoProperty *prop); + +MONO_API uint32_t +mono_property_get_flags (MonoProperty *prop); + +/* MonoEvent accessors */ +MONO_API const char* +mono_event_get_name (MonoEvent *event); + +MONO_API MonoMethod* +mono_event_get_add_method (MonoEvent *event); + +MONO_API MonoMethod* +mono_event_get_remove_method (MonoEvent *event); + +MONO_API MonoMethod* +mono_event_get_remove_method (MonoEvent *event); + +MONO_API MonoMethod* +mono_event_get_raise_method (MonoEvent *event); + +MONO_API MonoClass* +mono_event_get_parent (MonoEvent *event); + +MONO_API uint32_t +mono_event_get_flags (MonoEvent *event); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod * +mono_class_get_method_from_name (MonoClass *klass, const char *name, int param_count); + +MONO_API char * +mono_class_name_from_token (MonoImage *image, uint32_t type_token); + +MONO_API mono_bool +mono_method_can_access_field (MonoMethod *method, MonoClassField *field); + +MONO_API mono_bool +mono_method_can_access_method (MonoMethod *method, MonoMethod *called); + +MONO_API mono_bool +mono_class_is_nullable (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoClass* +mono_class_get_nullable_param (MonoClass *klass); + +MONO_END_DECLS + +#endif /* _MONO_CLI_CLASS_H_ */ diff --git a/src/mono/msvc/include/mono/metadata/debug-helpers.h b/src/mono/msvc/include/mono/metadata/debug-helpers.h new file mode 100644 index 0000000000000..8ecdf8edc589f --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/debug-helpers.h @@ -0,0 +1,54 @@ +/** + * \file + */ + +#ifndef __MONO_DEBUG_HELPERS_H__ +#define __MONO_DEBUG_HELPERS_H__ + +#include + +MONO_BEGIN_DECLS + +typedef struct MonoDisHelper MonoDisHelper; + +typedef char* (*MonoDisIndenter) (MonoDisHelper *dh, MonoMethod *method, uint32_t ip_offset); +typedef char* (*MonoDisTokener) (MonoDisHelper *dh, MonoMethod *method, uint32_t token); + +struct MonoDisHelper { + const char *newline; + const char *label_format; + const char *label_target; + MonoDisIndenter indenter; + MonoDisTokener tokener; + void* user_data; +}; + +MONO_API char* mono_disasm_code_one (MonoDisHelper *dh, MonoMethod *method, const mono_byte *ip, const mono_byte** endp); +MONO_API char* mono_disasm_code (MonoDisHelper *dh, MonoMethod *method, const mono_byte *ip, const mono_byte* end); + +typedef struct MonoMethodDesc MonoMethodDesc; + +MONO_API char* mono_type_full_name (MonoType *type); + +MONO_API char* mono_signature_get_desc (MonoMethodSignature *sig, mono_bool include_namespace); + +MONO_API char* mono_context_get_desc (MonoGenericContext *context); + +MONO_API MonoMethodDesc* mono_method_desc_new (const char *name, mono_bool include_namespace); +MONO_API MonoMethodDesc* mono_method_desc_from_method (MonoMethod *method); +MONO_API void mono_method_desc_free (MonoMethodDesc *desc); +MONO_API mono_bool mono_method_desc_match (MonoMethodDesc *desc, MonoMethod *method); +MONO_API mono_bool mono_method_desc_is_full (MonoMethodDesc *desc); +MONO_API mono_bool mono_method_desc_full_match (MonoMethodDesc *desc, MonoMethod *method); +MONO_API MonoMethod* mono_method_desc_search_in_class (MonoMethodDesc *desc, MonoClass *klass); +MONO_API MonoMethod* mono_method_desc_search_in_image (MonoMethodDesc *desc, MonoImage *image); + +MONO_API char* mono_method_full_name (MonoMethod *method, mono_bool signature); +MONO_API char* mono_method_get_reflection_name (MonoMethod *method); + +MONO_API char* mono_field_full_name (MonoClassField *field); + +MONO_END_DECLS + +#endif /* __MONO_DEBUG_HELPERS_H__ */ + diff --git a/src/mono/msvc/include/mono/metadata/debug-mono-symfile.h b/src/mono/msvc/include/mono/metadata/debug-mono-symfile.h new file mode 100644 index 0000000000000..cebc943d8506c --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/debug-mono-symfile.h @@ -0,0 +1,114 @@ +/** + * \file + * This header is only installed for use by the debugger: + * the structures and the API declared here are not supported. + * Copyright 2012 Xamarin Inc (http://www.xamarin.com) + * Licensed under the MIT license. See LICENSE file in the project root for full license information. + */ + +#ifndef __MONO_DEBUG_MONO_SYMFILE_H__ +#define __MONO_DEBUG_MONO_SYMFILE_H__ + +#include +#include +#include +#include +#include + +typedef struct MonoSymbolFileOffsetTable MonoSymbolFileOffsetTable; +typedef struct MonoSymbolFileLineNumberEntry MonoSymbolFileLineNumberEntry; +typedef struct MonoSymbolFileMethodAddress MonoSymbolFileMethodAddress; +typedef struct MonoSymbolFileDynamicTable MonoSymbolFileDynamicTable; +typedef struct MonoSymbolFileSourceEntry MonoSymbolFileSourceEntry; +typedef struct MonoSymbolFileMethodEntry MonoSymbolFileMethodEntry; + +/* Keep in sync with OffsetTable in mcs/class/Mono.CSharp.Debugger/MonoSymbolTable.cs */ +struct MonoSymbolFileOffsetTable { + uint32_t _total_file_size; + uint32_t _data_section_offset; + uint32_t _data_section_size; + uint32_t _compile_unit_count; + uint32_t _compile_unit_table_offset; + uint32_t _compile_unit_table_size; + uint32_t _source_count; + uint32_t _source_table_offset; + uint32_t _source_table_size; + uint32_t _method_count; + uint32_t _method_table_offset; + uint32_t _method_table_size; + uint32_t _type_count; + uint32_t _anonymous_scope_count; + uint32_t _anonymous_scope_table_offset; + uint32_t _anonymous_scope_table_size; + uint32_t _line_number_table_line_base; + uint32_t _line_number_table_line_range; + uint32_t _line_number_table_opcode_base; + uint32_t _is_aspx_source; +}; + +struct MonoSymbolFileSourceEntry { + uint32_t _index; + uint32_t _data_offset; +}; + +struct MonoSymbolFileMethodEntry { + uint32_t _token; + uint32_t _data_offset; + uint32_t _line_number_table; +}; + +struct MonoSymbolFileMethodAddress { + uint32_t size; + const uint8_t *start_address; + const uint8_t *end_address; + const uint8_t *method_start_address; + const uint8_t *method_end_address; + const uint8_t *wrapper_address; + uint32_t has_this; + uint32_t num_params; + uint32_t variable_table_offset; + uint32_t type_table_offset; + uint32_t num_line_numbers; + uint32_t line_number_offset; + uint8_t data [MONO_ZERO_LEN_ARRAY]; +}; + +#define MONO_SYMBOL_FILE_MAJOR_VERSION 50 +#define MONO_SYMBOL_FILE_MINOR_VERSION 0 +#define MONO_SYMBOL_FILE_MAGIC 0x45e82623fd7fa614ULL + +MONO_BEGIN_DECLS + +MONO_API MonoSymbolFile * +mono_debug_open_mono_symbols (MonoDebugHandle *handle, + const uint8_t *raw_contents, + int size, + mono_bool in_the_debugger); + +MONO_API void +mono_debug_close_mono_symbol_file (MonoSymbolFile *symfile); + +MONO_API mono_bool +mono_debug_symfile_is_loaded (MonoSymbolFile *symfile); + +MONO_API MonoDebugSourceLocation * +mono_debug_symfile_lookup_location (MonoDebugMethodInfo *minfo, + uint32_t offset); + +MONO_API void +mono_debug_symfile_free_location (MonoDebugSourceLocation *location); + +MONO_API MonoDebugMethodInfo * +mono_debug_symfile_lookup_method (MonoDebugHandle *handle, + MonoMethod *method); + +MONO_API MonoDebugLocalsInfo* +mono_debug_symfile_lookup_locals (MonoDebugMethodInfo *minfo); + +void +mono_debug_symfile_get_seq_points (MonoDebugMethodInfo *minfo, char **source_file, GPtrArray **source_file_list, int **source_files, MonoSymSeqPoint **seq_points, int *n_seq_points); + +MONO_END_DECLS + +#endif /* __MONO_SYMFILE_H__ */ + diff --git a/src/mono/msvc/include/mono/metadata/environment.h b/src/mono/msvc/include/mono/metadata/environment.h new file mode 100644 index 0000000000000..1fb5a57b31ecb --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/environment.h @@ -0,0 +1,23 @@ +/** + * \file + * System.Environment support internal calls + * + * Author: + * Dick Porter (dick@ximian.com) + * + * (C) 2002 Ximian, Inc + */ + +#ifndef _MONO_METADATA_ENVIRONMENT_H_ +#define _MONO_METADATA_ENVIRONMENT_H_ + +#include + +MONO_BEGIN_DECLS + +MONO_API int32_t mono_environment_exitcode_get (void); +MONO_API void mono_environment_exitcode_set (int32_t value); + +MONO_END_DECLS + +#endif /* _MONO_METADATA_ENVIRONMENT_H_ */ diff --git a/src/mono/msvc/include/mono/metadata/exception.h b/src/mono/msvc/include/mono/metadata/exception.h new file mode 100644 index 0000000000000..155c23c7e7747 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/exception.h @@ -0,0 +1,177 @@ +/** + * \file + */ + +#ifndef _MONO_METADATA_EXCEPTION_H_ +#define _MONO_METADATA_EXCEPTION_H_ + +#include +#include +#include + +MONO_BEGIN_DECLS + +MONO_API MonoException * +mono_exception_from_name (MonoImage *image, + const char* name_space, + const char *name); + +MONO_API MonoException * +mono_exception_from_token (MonoImage *image, uint32_t token); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_exception_from_name_two_strings (MonoImage *image, const char *name_space, + const char *name, MonoString *a1, MonoString *a2); + +MONO_API MonoException * +mono_exception_from_name_msg (MonoImage *image, const char *name_space, + const char *name, const char *msg); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_exception_from_token_two_strings (MonoImage *image, uint32_t token, + MonoString *a1, MonoString *a2); + +MONO_API MonoException * +mono_exception_from_name_domain (MonoDomain *domain, MonoImage *image, + const char* name_space, + const char *name); + +MONO_API MonoException * +mono_get_exception_divide_by_zero (void); + +MONO_API MonoException * +mono_get_exception_security (void); + +MONO_API MonoException * +mono_get_exception_arithmetic (void); + +MONO_API MonoException * +mono_get_exception_overflow (void); + +MONO_API MonoException * +mono_get_exception_null_reference (void); + +MONO_API MonoException * +mono_get_exception_execution_engine (const char *msg); + +MONO_API MonoException * +mono_get_exception_thread_abort (void); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_thread_state (const char *msg); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_thread_interrupted (void); + +MONO_API MonoException * +mono_get_exception_serialization (const char *msg); + +MONO_API MonoException * +mono_get_exception_invalid_cast (void); + +MONO_API MonoException * +mono_get_exception_invalid_operation (const char *msg); + +MONO_API MonoException * +mono_get_exception_index_out_of_range (void); + +MONO_API MonoException * +mono_get_exception_array_type_mismatch (void); + +MONO_API MonoException * +mono_get_exception_type_load (MonoString *class_name, char *assembly_name); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_missing_method (const char *class_name, const char *member_name); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_missing_field (const char *class_name, const char *member_name); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_not_implemented (const char *msg); + +MONO_API MonoException * +mono_get_exception_not_supported (const char *msg); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoException* +mono_get_exception_argument_null (const char *arg); + +MONO_API MonoException * +mono_get_exception_argument (const char *arg, const char *msg); + +MONO_API MonoException * +mono_get_exception_argument_out_of_range (const char *arg); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_io (const char *msg); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_file_not_found (MonoString *fname); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_file_not_found2 (const char *msg, MonoString *fname); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_type_initialization (const char *type_name, MonoException *inner); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_synchronization_lock (const char *msg); + +MONO_API MonoException * +mono_get_exception_cannot_unload_appdomain (const char *msg); + +MONO_API MonoException * +mono_get_exception_appdomain_unloaded (void); + +MONO_API MonoException * +mono_get_exception_bad_image_format (const char *msg); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_bad_image_format2 (const char *msg, MonoString *fname); + +MONO_API MonoException * +mono_get_exception_stack_overflow (void); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_out_of_memory (void); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_field_access (void); + +MONO_API MonoException * +mono_get_exception_method_access (void); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_reflection_type_load (MonoArray *types, MonoArray *exceptions); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_runtime_wrapped (MonoObject *wrapped_exception); + +/* Installs a function which is called when the runtime encounters an unhandled exception. + * This hook isn't expected to return. + * If no hook has been installed, the runtime will print a message before aborting. + */ +typedef void (*MonoUnhandledExceptionFunc) (MonoObject *exc, void *user_data); +MONO_API void mono_install_unhandled_exception_hook (MonoUnhandledExceptionFunc func, void *user_data); +void mono_invoke_unhandled_exception_hook (MonoObject *exc); + +MONO_END_DECLS + +#endif /* _MONO_METADATA_EXCEPTION_H_ */ diff --git a/src/mono/msvc/include/mono/metadata/image.h b/src/mono/msvc/include/mono/metadata/image.h new file mode 100644 index 0000000000000..4ef0f5a341bd0 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/image.h @@ -0,0 +1,99 @@ +/** + * \file + */ + +#ifndef _MONONET_METADATA_IMAGE_H_ +#define _MONONET_METADATA_IMAGE_H_ + +#include +#include +#include +#include + +MONO_BEGIN_DECLS + +typedef struct _MonoAssembly MonoAssembly; +typedef struct _MonoAssemblyName MonoAssemblyName; +typedef struct _MonoTableInfo MonoTableInfo; + +typedef enum { + MONO_IMAGE_OK, + MONO_IMAGE_ERROR_ERRNO, + MONO_IMAGE_MISSING_ASSEMBLYREF, + MONO_IMAGE_IMAGE_INVALID +} MonoImageOpenStatus; + +MONO_API void mono_images_init (void); +MONO_API void mono_images_cleanup (void); + +MONO_API MonoImage *mono_image_open (const char *fname, + MonoImageOpenStatus *status); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoImage *mono_image_open_full (const char *fname, + MonoImageOpenStatus *status, mono_bool refonly); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoImage *mono_pe_file_open (const char *fname, + MonoImageOpenStatus *status); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoImage *mono_image_open_from_data (char *data, uint32_t data_len, mono_bool need_copy, + MonoImageOpenStatus *status); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoImage *mono_image_open_from_data_full (char *data, uint32_t data_len, mono_bool need_copy, + MonoImageOpenStatus *status, mono_bool refonly); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoImage *mono_image_open_from_data_with_name (char *data, uint32_t data_len, mono_bool need_copy, + MonoImageOpenStatus *status, mono_bool refonly, const char *name); +MONO_API void mono_image_fixup_vtable (MonoImage *image); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoImage *mono_image_loaded (const char *name); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoImage *mono_image_loaded_full (const char *name, mono_bool refonly); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoImage *mono_image_loaded_by_guid (const char *guid); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoImage *mono_image_loaded_by_guid_full (const char *guid, mono_bool refonly); +MONO_API void mono_image_init (MonoImage *image); +MONO_API void mono_image_close (MonoImage *image); +MONO_API void mono_image_addref (MonoImage *image); +MONO_API const char *mono_image_strerror (MonoImageOpenStatus status); + +MONO_API int mono_image_ensure_section (MonoImage *image, + const char *section); +MONO_API int mono_image_ensure_section_idx (MonoImage *image, + int section); + +MONO_API uint32_t mono_image_get_entry_point (MonoImage *image); +MONO_API const char *mono_image_get_resource (MonoImage *image, uint32_t offset, uint32_t *size); +MONO_API MONO_RT_EXTERNAL_ONLY MonoImage* mono_image_load_file_for_image (MonoImage *image, int fileidx); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoImage* mono_image_load_module (MonoImage *image, int idx); + +MONO_API const char* mono_image_get_name (MonoImage *image); +MONO_API const char* mono_image_get_filename (MonoImage *image); +MONO_API const char * mono_image_get_guid (MonoImage *image); +MONO_API MonoAssembly* mono_image_get_assembly (MonoImage *image); +MONO_API mono_bool mono_image_is_dynamic (MonoImage *image); +MONO_API char* mono_image_rva_map (MonoImage *image, uint32_t rva); + +MONO_API const MonoTableInfo *mono_image_get_table_info (MonoImage *image, int table_id); +MONO_API int mono_image_get_table_rows (MonoImage *image, int table_id); +MONO_API int mono_table_info_get_rows (const MonoTableInfo *table); + +/* This actually returns a MonoPEResourceDataEntry *, but declaring it + * causes an include file loop. + */ +MONO_API void* mono_image_lookup_resource (MonoImage *image, uint32_t res_id, + uint32_t lang_id, mono_unichar2 *name); + +MONO_API const char* mono_image_get_public_key (MonoImage *image, uint32_t *size); +MONO_API const char* mono_image_get_strong_name (MonoImage *image, uint32_t *size); +MONO_API uint32_t mono_image_strong_name_position (MonoImage *image, uint32_t *size); +MONO_API void mono_image_add_to_name_cache (MonoImage *image, + const char *nspace, const char *name, uint32_t idx); +MONO_API mono_bool mono_image_has_authenticode_entry (MonoImage *image); + +mono_bool mono_has_pdb_checksum (char *raw_data, uint32_t raw_data_len); + +MONO_END_DECLS + +#endif diff --git a/src/mono/msvc/include/mono/metadata/loader.h b/src/mono/msvc/include/mono/metadata/loader.h new file mode 100644 index 0000000000000..42c89288fcc6e --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/loader.h @@ -0,0 +1,109 @@ +/** + * \file + */ + +#ifndef _MONO_METADATA_LOADER_H_ +#define _MONO_METADATA_LOADER_H_ 1 + +#include +#include +#include +#include + +MONO_BEGIN_DECLS + +typedef mono_bool (*MonoStackWalk) (MonoMethod *method, int32_t native_offset, int32_t il_offset, mono_bool managed, void* data); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod * +mono_get_method (MonoImage *image, uint32_t token, MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod * +mono_get_method_full (MonoImage *image, uint32_t token, MonoClass *klass, + MonoGenericContext *context); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod * +mono_get_method_constrained (MonoImage *image, uint32_t token, MonoClass *constrained_class, + MonoGenericContext *context, MonoMethod **cil_method); + +MONO_API void +mono_free_method (MonoMethod *method); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethodSignature* +mono_method_get_signature_full (MonoMethod *method, MonoImage *image, uint32_t token, + MonoGenericContext *context); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethodSignature* +mono_method_get_signature (MonoMethod *method, MonoImage *image, uint32_t token); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethodSignature* +mono_method_signature (MonoMethod *method); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethodHeader* +mono_method_get_header (MonoMethod *method); + +MONO_API const char* +mono_method_get_name (MonoMethod *method); + +MONO_API MonoClass* +mono_method_get_class (MonoMethod *method); + +MONO_API uint32_t +mono_method_get_token (MonoMethod *method); + +MONO_API uint32_t +mono_method_get_flags (MonoMethod *method, uint32_t *iflags); + +MONO_API uint32_t +mono_method_get_index (MonoMethod *method); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_add_internal_call (const char *name, const void* method); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_dangerous_add_raw_internal_call (const char *name, const void* method); + +MONO_API void* +mono_lookup_internal_call (MonoMethod *method); + +MONO_API const char* +mono_lookup_icall_symbol (MonoMethod *m); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_dllmap_insert (MonoImage *assembly, const char *dll, const char *func, const char *tdll, const char *tfunc); + +MONO_API MONO_RT_EXTERNAL_ONLY void* +mono_lookup_pinvoke_call (MonoMethod *method, const char **exc_class, const char **exc_arg); + +MONO_API void +mono_method_get_param_names (MonoMethod *method, const char **names); + +MONO_API uint32_t +mono_method_get_param_token (MonoMethod *method, int idx); + +MONO_API void +mono_method_get_marshal_info (MonoMethod *method, MonoMarshalSpec **mspecs); + +MONO_API mono_bool +mono_method_has_marshal_info (MonoMethod *method); + +MONO_API MonoMethod* +mono_method_get_last_managed (void); + +MONO_API void +mono_stack_walk (MonoStackWalk func, void* user_data); + +/* Use this if the IL offset is not needed: it's faster */ +MONO_API void +mono_stack_walk_no_il (MonoStackWalk func, void* user_data); + +typedef mono_bool (*MonoStackWalkAsyncSafe) (MonoMethod *method, MonoDomain *domain, void *base_address, int offset, void* data); +MONO_API void +mono_stack_walk_async_safe (MonoStackWalkAsyncSafe func, void *initial_sig_context, void* user_data); + +MONO_API MonoMethodHeader* +mono_method_get_header_checked (MonoMethod *method, MonoError *error); + +MONO_END_DECLS + +#endif + diff --git a/src/mono/msvc/include/mono/metadata/metadata.h b/src/mono/msvc/include/mono/metadata/metadata.h new file mode 100644 index 0000000000000..965b06a86c195 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/metadata.h @@ -0,0 +1,517 @@ +/** + * \file + */ + +#ifndef __MONO_METADATA_H__ +#define __MONO_METADATA_H__ + +#include + +#include +#include +#include +#include +#include + +MONO_BEGIN_DECLS + +#define MONO_TYPE_ISSTRUCT(t) mono_type_is_struct (t) +#define MONO_TYPE_IS_VOID(t) mono_type_is_void (t) +#define MONO_TYPE_IS_POINTER(t) mono_type_is_pointer (t) +#define MONO_TYPE_IS_REFERENCE(t) mono_type_is_reference (t) + +#define MONO_CLASS_IS_INTERFACE(c) ((mono_class_get_flags (c) & TYPE_ATTRIBUTE_INTERFACE) || mono_type_is_generic_parameter (mono_class_get_type (c))) + +#define MONO_CLASS_IS_IMPORT(c) ((mono_class_get_flags (c) & TYPE_ATTRIBUTE_IMPORT)) + +typedef enum { + MONO_EXCEPTION_CLAUSE_NONE, + MONO_EXCEPTION_CLAUSE_FILTER, + MONO_EXCEPTION_CLAUSE_FINALLY, + MONO_EXCEPTION_CLAUSE_FAULT = 4 +} MonoExceptionEnum; + +typedef enum { + MONO_CALL_DEFAULT, + MONO_CALL_C, + MONO_CALL_STDCALL, + MONO_CALL_THISCALL, + MONO_CALL_FASTCALL, + MONO_CALL_VARARG +} MonoCallConvention; + +/* ECMA lamespec: the old spec had more info... */ +typedef enum { + MONO_NATIVE_BOOLEAN = 0x02, /* 4 bytes, 0 is false, != 0 is true */ + MONO_NATIVE_I1 = 0x03, + MONO_NATIVE_U1 = 0x04, + MONO_NATIVE_I2 = 0x05, + MONO_NATIVE_U2 = 0x06, + MONO_NATIVE_I4 = 0x07, + MONO_NATIVE_U4 = 0x08, + MONO_NATIVE_I8 = 0x09, + MONO_NATIVE_U8 = 0x0a, + MONO_NATIVE_R4 = 0x0b, + MONO_NATIVE_R8 = 0x0c, + MONO_NATIVE_CURRENCY = 0x0f, + MONO_NATIVE_BSTR = 0x13, /* prefixed length, Unicode */ + MONO_NATIVE_LPSTR = 0x14, /* ANSI, null terminated */ + MONO_NATIVE_LPWSTR = 0x15, /* UNICODE, null terminated */ + MONO_NATIVE_LPTSTR = 0x16, /* plattform dep., null terminated */ + MONO_NATIVE_BYVALTSTR = 0x17, + MONO_NATIVE_IUNKNOWN = 0x19, + MONO_NATIVE_IDISPATCH = 0x1a, + MONO_NATIVE_STRUCT = 0x1b, + MONO_NATIVE_INTERFACE = 0x1c, + MONO_NATIVE_SAFEARRAY = 0x1d, + MONO_NATIVE_BYVALARRAY = 0x1e, + MONO_NATIVE_INT = 0x1f, + MONO_NATIVE_UINT = 0x20, + MONO_NATIVE_VBBYREFSTR = 0x22, + MONO_NATIVE_ANSIBSTR = 0x23, /* prefixed length, ANSI */ + MONO_NATIVE_TBSTR = 0x24, /* prefixed length, plattform dep. */ + MONO_NATIVE_VARIANTBOOL = 0x25, + MONO_NATIVE_FUNC = 0x26, + MONO_NATIVE_ASANY = 0x28, + MONO_NATIVE_LPARRAY = 0x2a, + MONO_NATIVE_LPSTRUCT = 0x2b, + MONO_NATIVE_CUSTOM = 0x2c, + MONO_NATIVE_ERROR = 0x2d, + // TODO: MONO_NATIVE_IINSPECTABLE = 0x2e + // TODO: MONO_NATIVE_HSTRING = 0x2f + MONO_NATIVE_UTF8STR = 0x30, + MONO_NATIVE_MAX = 0x50 /* no info */ +} MonoMarshalNative; + +/* Used only in context of SafeArray */ +typedef enum { + MONO_VARIANT_EMPTY = 0x00, + MONO_VARIANT_NULL = 0x01, + MONO_VARIANT_I2 = 0x02, + MONO_VARIANT_I4 = 0x03, + MONO_VARIANT_R4 = 0x04, + MONO_VARIANT_R8 = 0x05, + MONO_VARIANT_CY = 0x06, + MONO_VARIANT_DATE = 0x07, + MONO_VARIANT_BSTR = 0x08, + MONO_VARIANT_DISPATCH = 0x09, + MONO_VARIANT_ERROR = 0x0a, + MONO_VARIANT_BOOL = 0x0b, + MONO_VARIANT_VARIANT = 0x0c, + MONO_VARIANT_UNKNOWN = 0x0d, + MONO_VARIANT_DECIMAL = 0x0e, + MONO_VARIANT_I1 = 0x10, + MONO_VARIANT_UI1 = 0x11, + MONO_VARIANT_UI2 = 0x12, + MONO_VARIANT_UI4 = 0x13, + MONO_VARIANT_I8 = 0x14, + MONO_VARIANT_UI8 = 0x15, + MONO_VARIANT_INT = 0x16, + MONO_VARIANT_UINT = 0x17, + MONO_VARIANT_VOID = 0x18, + MONO_VARIANT_HRESULT = 0x19, + MONO_VARIANT_PTR = 0x1a, + MONO_VARIANT_SAFEARRAY = 0x1b, + MONO_VARIANT_CARRAY = 0x1c, + MONO_VARIANT_USERDEFINED = 0x1d, + MONO_VARIANT_LPSTR = 0x1e, + MONO_VARIANT_LPWSTR = 0x1f, + MONO_VARIANT_RECORD = 0x24, + MONO_VARIANT_FILETIME = 0x40, + MONO_VARIANT_BLOB = 0x41, + MONO_VARIANT_STREAM = 0x42, + MONO_VARIANT_STORAGE = 0x43, + MONO_VARIANT_STREAMED_OBJECT = 0x44, + MONO_VARIANT_STORED_OBJECT = 0x45, + MONO_VARIANT_BLOB_OBJECT = 0x46, + MONO_VARIANT_CF = 0x47, + MONO_VARIANT_CLSID = 0x48, + MONO_VARIANT_VECTOR = 0x1000, + MONO_VARIANT_ARRAY = 0x2000, + MONO_VARIANT_BYREF = 0x4000 +} MonoMarshalVariant; + +typedef enum { + MONO_MARSHAL_CONV_NONE, + MONO_MARSHAL_CONV_BOOL_VARIANTBOOL, + MONO_MARSHAL_CONV_BOOL_I4, + MONO_MARSHAL_CONV_STR_BSTR, + MONO_MARSHAL_CONV_STR_LPSTR, + MONO_MARSHAL_CONV_LPSTR_STR, + MONO_MARSHAL_CONV_LPTSTR_STR, + MONO_MARSHAL_CONV_STR_LPWSTR, + MONO_MARSHAL_CONV_LPWSTR_STR, + MONO_MARSHAL_CONV_STR_LPTSTR, + MONO_MARSHAL_CONV_STR_ANSIBSTR, + MONO_MARSHAL_CONV_STR_TBSTR, + MONO_MARSHAL_CONV_STR_BYVALSTR, + MONO_MARSHAL_CONV_STR_BYVALWSTR, + MONO_MARSHAL_CONV_SB_LPSTR, + MONO_MARSHAL_CONV_SB_LPTSTR, + MONO_MARSHAL_CONV_SB_LPWSTR, + MONO_MARSHAL_CONV_LPSTR_SB, + MONO_MARSHAL_CONV_LPTSTR_SB, + MONO_MARSHAL_CONV_LPWSTR_SB, + MONO_MARSHAL_CONV_ARRAY_BYVALARRAY, + MONO_MARSHAL_CONV_ARRAY_BYVALCHARARRAY, + MONO_MARSHAL_CONV_ARRAY_SAVEARRAY, + MONO_MARSHAL_CONV_ARRAY_LPARRAY, + MONO_MARSHAL_FREE_LPARRAY, + MONO_MARSHAL_CONV_OBJECT_INTERFACE, + MONO_MARSHAL_CONV_OBJECT_IDISPATCH, + MONO_MARSHAL_CONV_OBJECT_IUNKNOWN, + MONO_MARSHAL_CONV_OBJECT_STRUCT, + MONO_MARSHAL_CONV_DEL_FTN, + MONO_MARSHAL_CONV_FTN_DEL, + MONO_MARSHAL_FREE_ARRAY, + MONO_MARSHAL_CONV_BSTR_STR, + MONO_MARSHAL_CONV_SAFEHANDLE, + MONO_MARSHAL_CONV_HANDLEREF, + MONO_MARSHAL_CONV_STR_UTF8STR, + MONO_MARSHAL_CONV_SB_UTF8STR, + MONO_MARSHAL_CONV_UTF8STR_STR, + MONO_MARSHAL_CONV_UTF8STR_SB, + MONO_MARSHAL_CONV_FIXED_BUFFER, + MONO_MARSHAL_CONV_ANSIBSTR_STR, + MONO_MARSHAL_CONV_TBSTR_STR +} MonoMarshalConv; + +#define MONO_MARSHAL_CONV_INVALID ((MonoMarshalConv)-1) + +typedef struct { + MonoMarshalNative native; + union { + struct { + MonoMarshalNative elem_type; + int32_t num_elem; /* -1 if not set */ + int16_t param_num; /* -1 if not set */ + int16_t elem_mult; /* -1 if not set */ + } array_data; + struct { + char *custom_name; + char *cookie; + MonoImage *image; + } custom_data; + struct { + MonoMarshalVariant elem_type; + int32_t num_elem; + } safearray_data; + } data; +} MonoMarshalSpec; + +MONO_API void mono_metadata_init (void); + +MONO_API void mono_metadata_decode_row (const MonoTableInfo *t, + int idx, + uint32_t *res, + int res_size); + +MONO_API uint32_t mono_metadata_decode_row_col (const MonoTableInfo *t, + int idx, + unsigned int col); + +/* + * This macro is used to extract the size of the table encoded in + * the size_bitfield of MonoTableInfo. + */ +#define mono_metadata_table_size(bitfield,table) ((((bitfield) >> ((table)*2)) & 0x3) + 1) +#define mono_metadata_table_count(bitfield) ((bitfield) >> 24) + +MONO_API int mono_metadata_compute_size (MonoImage *meta, + int tableindex, + uint32_t *result_bitfield); + +/* + * + */ +MONO_API const char *mono_metadata_locate (MonoImage *meta, int table, int idx); +MONO_API const char *mono_metadata_locate_token (MonoImage *meta, uint32_t token); + +MONO_API const char *mono_metadata_string_heap (MonoImage *meta, uint32_t table_index); +MONO_API const char *mono_metadata_blob_heap (MonoImage *meta, uint32_t table_index); +MONO_API const char *mono_metadata_user_string (MonoImage *meta, uint32_t table_index); +MONO_API const char *mono_metadata_guid_heap (MonoImage *meta, uint32_t table_index); + +MONO_API uint32_t mono_metadata_typedef_from_field (MonoImage *meta, uint32_t table_index); +MONO_API uint32_t mono_metadata_typedef_from_method (MonoImage *meta, uint32_t table_index); +MONO_API uint32_t mono_metadata_nested_in_typedef (MonoImage *meta, uint32_t table_index); +MONO_API uint32_t mono_metadata_nesting_typedef (MonoImage *meta, uint32_t table_index, uint32_t start_index); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClass** mono_metadata_interfaces_from_typedef (MonoImage *meta, uint32_t table_index, unsigned int *count); + +MONO_API uint32_t mono_metadata_events_from_typedef (MonoImage *meta, uint32_t table_index, unsigned int *end_idx); +MONO_API uint32_t mono_metadata_methods_from_event (MonoImage *meta, uint32_t table_index, unsigned int *end); +MONO_API uint32_t mono_metadata_properties_from_typedef (MonoImage *meta, uint32_t table_index, unsigned int *end); +MONO_API uint32_t mono_metadata_methods_from_property (MonoImage *meta, uint32_t table_index, unsigned int *end); +MONO_API uint32_t mono_metadata_packing_from_typedef (MonoImage *meta, uint32_t table_index, uint32_t *packing, uint32_t *size); +MONO_API const char* mono_metadata_get_marshal_info (MonoImage *meta, uint32_t idx, mono_bool is_field); +MONO_API uint32_t mono_metadata_custom_attrs_from_index (MonoImage *meta, uint32_t cattr_index); + +MONO_API MonoMarshalSpec *mono_metadata_parse_marshal_spec (MonoImage *image, const char *ptr); + +MONO_API void mono_metadata_free_marshal_spec (MonoMarshalSpec *spec); + +MONO_API uint32_t mono_metadata_implmap_from_method (MonoImage *meta, uint32_t method_idx); + +MONO_API void mono_metadata_field_info (MonoImage *meta, + uint32_t table_index, + uint32_t *offset, + uint32_t *rva, + MonoMarshalSpec **marshal_spec); + +MONO_API uint32_t mono_metadata_get_constant_index (MonoImage *meta, uint32_t token, uint32_t hint); + +/* + * Functions to extract information from the Blobs + */ +MONO_API uint32_t mono_metadata_decode_value (const char *ptr, + const char **rptr); +MONO_API int32_t mono_metadata_decode_signed_value (const char *ptr, const char **rptr); + +MONO_API uint32_t mono_metadata_decode_blob_size (const char *ptr, + const char **rptr); + +MONO_API void mono_metadata_encode_value (uint32_t value, char *bug, char **endbuf); + +#define MONO_OFFSET_IN_CLAUSE(clause,offset) \ + ((clause)->try_offset <= (offset) && (offset) < ((clause)->try_offset + (clause)->try_len)) +#define MONO_OFFSET_IN_HANDLER(clause,offset) \ + ((clause)->handler_offset <= (offset) && (offset) < ((clause)->handler_offset + (clause)->handler_len)) +#define MONO_OFFSET_IN_FILTER(clause,offset) \ + ((clause)->flags == MONO_EXCEPTION_CLAUSE_FILTER && (clause)->data.filter_offset <= (offset) && (offset) < ((clause)->handler_offset)) + +typedef struct { + uint32_t flags; + uint32_t try_offset; + uint32_t try_len; + uint32_t handler_offset; + uint32_t handler_len; + union { + uint32_t filter_offset; + MonoClass *catch_class; + } data; +} MonoExceptionClause; + +typedef struct _MonoType MonoType; +typedef struct _MonoGenericInst MonoGenericInst; +typedef struct _MonoGenericClass MonoGenericClass; +typedef struct _MonoGenericContext MonoGenericContext; +typedef struct _MonoGenericContainer MonoGenericContainer; +typedef struct _MonoGenericParam MonoGenericParam; +typedef struct _MonoArrayType MonoArrayType; +typedef struct _MonoMethodSignature MonoMethodSignature; + +/* FIXME: Keeping this name alive for now, since it is part of the exposed API, even though no entrypoint uses it. */ +typedef struct invalid_name MonoGenericMethod; + +typedef struct { + unsigned int required : 1; + unsigned int token : 31; +} MonoCustomMod; + +typedef struct _MonoCustomModContainer { + uint8_t count; /* max 64 modifiers follow at the end */ + MonoImage *image; /* Image containing types in modifiers array */ + MonoCustomMod modifiers [1]; /* Actual length is count */ +} MonoCustomModContainer; + +struct _MonoArrayType { + MonoClass *eklass; + // Number of dimensions of the array + uint8_t rank; + + // Arrays recording known upper and lower index bounds for each dimension + uint8_t numsizes; + uint8_t numlobounds; + int *sizes; + int *lobounds; +}; + +typedef struct _MonoMethodHeader MonoMethodHeader; + +typedef enum { + MONO_PARSE_TYPE, + MONO_PARSE_MOD_TYPE, + MONO_PARSE_LOCAL, + MONO_PARSE_PARAM, + MONO_PARSE_RET, + MONO_PARSE_FIELD +} MonoParseTypeMode; + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_type_is_byref (MonoType *type); + +MONO_API MONO_RT_EXTERNAL_ONLY int +mono_type_get_type (MonoType *type); + +/* For MONO_TYPE_FNPTR */ +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethodSignature* +mono_type_get_signature (MonoType *type); + +/* For MONO_TYPE_CLASS, VALUETYPE */ +MONO_API MONO_RT_EXTERNAL_ONLY MonoClass* +mono_type_get_class (MonoType *type); + +MONO_API MonoArrayType* +mono_type_get_array_type (MonoType *type); + +/* For MONO_TYPE_PTR */ +MONO_API MonoType* +mono_type_get_ptr_type (MonoType *type); + +MONO_API MonoClass* +mono_type_get_modifiers (MonoType *type, mono_bool *is_required, void **iter); + +MONO_API mono_bool mono_type_is_struct (MonoType *type); +MONO_API mono_bool mono_type_is_void (MonoType *type); +MONO_API mono_bool mono_type_is_pointer (MonoType *type); +MONO_API mono_bool mono_type_is_reference (MonoType *type); +MONO_API mono_bool mono_type_is_generic_parameter (MonoType *type); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoType* +mono_signature_get_return_type (MonoMethodSignature *sig); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoType* +mono_signature_get_params (MonoMethodSignature *sig, void **iter); + +MONO_API uint32_t +mono_signature_get_param_count (MonoMethodSignature *sig); + +MONO_API uint32_t +mono_signature_get_call_conv (MonoMethodSignature *sig); + +MONO_API int +mono_signature_vararg_start (MonoMethodSignature *sig); + +MONO_API mono_bool +mono_signature_is_instance (MonoMethodSignature *sig); + +MONO_API mono_bool +mono_signature_explicit_this (MonoMethodSignature *sig); + +MONO_API mono_bool +mono_signature_param_is_out (MonoMethodSignature *sig, int param_num); + +MONO_API uint32_t mono_metadata_parse_typedef_or_ref (MonoImage *m, + const char *ptr, + const char **rptr); +MONO_API int mono_metadata_parse_custom_mod (MonoImage *m, + MonoCustomMod *dest, + const char *ptr, + const char **rptr); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoArrayType *mono_metadata_parse_array (MonoImage *m, + const char *ptr, + const char **rptr); +MONO_API void mono_metadata_free_array (MonoArrayType *array); +MONO_API MONO_RT_EXTERNAL_ONLY MonoType *mono_metadata_parse_type (MonoImage *m, + MonoParseTypeMode mode, + short opt_attrs, + const char *ptr, + const char **rptr); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoType *mono_metadata_parse_param (MonoImage *m, + const char *ptr, + const char **rptr); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoType *mono_metadata_parse_field_type (MonoImage *m, + short field_flags, + const char *ptr, + const char **rptr); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoType *mono_type_create_from_typespec (MonoImage *image, + uint32_t type_spec); +MONO_API void mono_metadata_free_type (MonoType *type); +MONO_API int mono_type_size (MonoType *type, + int *alignment); +MONO_API int mono_type_stack_size (MonoType *type, + int *alignment); + +MONO_API mono_bool mono_type_generic_inst_is_valuetype (MonoType *type); +MONO_API mono_bool mono_metadata_generic_class_is_valuetype (MonoGenericClass *gclass); + +MONO_API unsigned int mono_metadata_type_hash (MonoType *t1); +MONO_API mono_bool mono_metadata_type_equal (MonoType *t1, MonoType *t2); + +MONO_API MonoMethodSignature *mono_metadata_signature_alloc (MonoImage *image, uint32_t nparams); + +MONO_API MonoMethodSignature *mono_metadata_signature_dup (MonoMethodSignature *sig); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoMethodSignature *mono_metadata_parse_signature (MonoImage *image, + uint32_t token); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoMethodSignature *mono_metadata_parse_method_signature (MonoImage *m, + int def, + const char *ptr, + const char **rptr); +MONO_API void mono_metadata_free_method_signature (MonoMethodSignature *method); + +MONO_API mono_bool mono_metadata_signature_equal (MonoMethodSignature *sig1, + MonoMethodSignature *sig2); + +MONO_API unsigned int mono_signature_hash (MonoMethodSignature *sig); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoMethodHeader *mono_metadata_parse_mh (MonoImage *m, const char *ptr); +MONO_API void mono_metadata_free_mh (MonoMethodHeader *mh); + +/* MonoMethodHeader accessors */ +MONO_API const unsigned char* +mono_method_header_get_code (MonoMethodHeader *header, uint32_t* code_size, uint32_t* max_stack); + +MONO_API MonoType** +mono_method_header_get_locals (MonoMethodHeader *header, uint32_t* num_locals, mono_bool *init_locals); + +MONO_API int +mono_method_header_get_num_clauses (MonoMethodHeader *header); + +MONO_API int +mono_method_header_get_clauses (MonoMethodHeader *header, MonoMethod *method, void **iter, MonoExceptionClause *clause); + +MONO_API uint32_t +mono_type_to_unmanaged (MonoType *type, MonoMarshalSpec *mspec, + mono_bool as_field, mono_bool unicode, MonoMarshalConv *conv); + +/* + * Makes a token based on a table and an index + */ +#define mono_metadata_make_token(table,idx) (((table) << 24)| (idx)) + +/* + * Returns the table index that this token encodes. + */ +#define mono_metadata_token_table(token) ((token) >> 24) + + /* + * Returns the index that a token refers to + */ +#define mono_metadata_token_index(token) ((token) & 0xffffff) + + +#define mono_metadata_token_code(token) ((token) & 0xff000000) + +MONO_API uint32_t mono_metadata_token_from_dor (uint32_t dor_index); + +MONO_API char *mono_guid_to_string (const uint8_t *guid); + +MONO_API char *mono_guid_to_string_minimal (const uint8_t *guid); + +MONO_API uint32_t mono_metadata_declsec_from_index (MonoImage *meta, uint32_t idx); + +MONO_API uint32_t mono_metadata_translate_token_index (MonoImage *image, int table, uint32_t idx); + +MONO_API void mono_metadata_decode_table_row (MonoImage *image, int table, + int idx, + uint32_t *res, + int res_size); + +MONO_API uint32_t mono_metadata_decode_table_row_col (MonoImage *image, int table, + int idx, + unsigned int col); + +MONO_END_DECLS + +#endif /* __MONO_METADATA_H__ */ diff --git a/src/mono/msvc/include/mono/metadata/mono-config.h b/src/mono/msvc/include/mono/metadata/mono-config.h new file mode 100644 index 0000000000000..91cdccd38e39d --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/mono-config.h @@ -0,0 +1,38 @@ +/** + * \file + * + * Author: Paolo Molaro (lupus@ximian.com) + * + * (C) 2002 Ximian, Inc. + */ +#ifndef __MONO_METADATA_CONFIG_H__ +#define __MONO_METADATA_CONFIG_H__ + +#include +#include + +MONO_BEGIN_DECLS + +MONO_API const char *mono_config_get_os (void); +MONO_API const char *mono_config_get_cpu (void); +MONO_API const char *mono_config_get_wordsize (void); + +MONO_API const char* mono_get_config_dir (void); +MONO_API void mono_set_config_dir (const char *dir); + +MONO_API const char* mono_get_machine_config (void); + +MONO_API void mono_config_cleanup (void); +MONO_API void mono_config_parse (const char *filename); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_config_for_assembly (MonoImage *assembly); +MONO_API void mono_config_parse_memory (const char *buffer); + +MONO_API const char* mono_config_string_for_assembly_file (const char *filename); + +MONO_API void mono_config_set_server_mode (mono_bool server_mode); +MONO_API mono_bool mono_config_is_server_mode (void); + +MONO_END_DECLS + +#endif /* __MONO_METADATA_CONFIG_H__ */ + diff --git a/src/mono/msvc/include/mono/metadata/mono-debug.h b/src/mono/msvc/include/mono/metadata/mono-debug.h new file mode 100644 index 0000000000000..c165db731154e --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/mono-debug.h @@ -0,0 +1,231 @@ +/** + * \file + * This header is only installed for use by the debugger: + * the structures and the API declared here are not supported. + */ + +#ifndef __MONO_DEBUG_H__ +#define __MONO_DEBUG_H__ + +#include +#include +#include + +MONO_BEGIN_DECLS + +typedef struct _MonoSymbolTable MonoSymbolTable; +typedef struct _MonoDebugDataTable MonoDebugDataTable; + +typedef struct _MonoSymbolFile MonoSymbolFile; +typedef struct _MonoPPDBFile MonoPPDBFile; + +typedef struct _MonoDebugHandle MonoDebugHandle; + +typedef struct _MonoDebugLineNumberEntry MonoDebugLineNumberEntry; + +typedef struct _MonoDebugVarInfo MonoDebugVarInfo; +typedef struct _MonoDebugMethodJitInfo MonoDebugMethodJitInfo; +typedef struct _MonoDebugMethodAddress MonoDebugMethodAddress; +typedef struct _MonoDebugMethodAddressList MonoDebugMethodAddressList; +typedef struct _MonoDebugClassEntry MonoDebugClassEntry; + +typedef struct _MonoDebugMethodInfo MonoDebugMethodInfo; +typedef struct _MonoDebugLocalsInfo MonoDebugLocalsInfo; +typedef struct _MonoDebugMethodAsyncInfo MonoDebugMethodAsyncInfo; +typedef struct _MonoDebugSourceLocation MonoDebugSourceLocation; + +typedef struct _MonoDebugList MonoDebugList; + +typedef enum { + MONO_DEBUG_FORMAT_NONE, + MONO_DEBUG_FORMAT_MONO, + /* Deprecated, the mdb debugger is not longer supported. */ + MONO_DEBUG_FORMAT_DEBUGGER +} MonoDebugFormat; + +/* + * NOTE: + * We intentionally do not use GList here since the debugger needs to know about + * the layout of the fields. +*/ +struct _MonoDebugList { + MonoDebugList *next; + const void* data; +}; + +struct _MonoSymbolTable { + uint64_t magic; + uint32_t version; + uint32_t total_size; + + /* + * Corlib and metadata info. + */ + MonoDebugHandle *corlib; + MonoDebugDataTable *global_data_table; + MonoDebugList *data_tables; + + /* + * The symbol files. + */ + MonoDebugList *symbol_files; +}; + +struct _MonoDebugHandle { + uint32_t index; + char *image_file; + MonoImage *image; + MonoDebugDataTable *type_table; + MonoSymbolFile *symfile; + MonoPPDBFile *ppdb; +}; + +struct _MonoDebugMethodJitInfo { + const mono_byte *code_start; + uint32_t code_size; + uint32_t prologue_end; + uint32_t epilogue_begin; + const mono_byte *wrapper_addr; + uint32_t num_line_numbers; + MonoDebugLineNumberEntry *line_numbers; + uint32_t has_var_info; + uint32_t num_params; + MonoDebugVarInfo *this_var; + MonoDebugVarInfo *params; + uint32_t num_locals; + MonoDebugVarInfo *locals; + MonoDebugVarInfo *gsharedvt_info_var; + MonoDebugVarInfo *gsharedvt_locals_var; +}; + +struct _MonoDebugMethodAddressList { + uint32_t size; + uint32_t count; + mono_byte data [MONO_ZERO_LEN_ARRAY]; +}; + +struct _MonoDebugSourceLocation { + char *source_file; + uint32_t row, column; + uint32_t il_offset; +}; + +MONO_API mono_bool mono_debug_enabled (void); + +/* + * These bits of the MonoDebugLocalInfo's "index" field are flags specifying + * where the variable is actually stored. + * + * See relocate_variable() in debug-symfile.c for more info. + */ +#define MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS 0xf0000000 + +/* The variable is in register "index". */ +#define MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER 0 + +/* The variable is at offset "offset" from register "index". */ +#define MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET 0x10000000 + +/* The variable is in the two registers "offset" and "index". */ +#define MONO_DEBUG_VAR_ADDRESS_MODE_TWO_REGISTERS 0x20000000 + +/* The variable is dead. */ +#define MONO_DEBUG_VAR_ADDRESS_MODE_DEAD 0x30000000 + +/* Same as REGOFFSET, but do an indirection */ +#define MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET_INDIR 0x40000000 + +/* gsharedvt local */ +#define MONO_DEBUG_VAR_ADDRESS_MODE_GSHAREDVT_LOCAL 0x50000000 + +/* variable is a vt address */ +#define MONO_DEBUG_VAR_ADDRESS_MODE_VTADDR 0x60000000 + +struct _MonoDebugVarInfo { + uint32_t index; + uint32_t offset; + uint32_t size; + uint32_t begin_scope; + uint32_t end_scope; + MonoType *type; +}; + +#define MONO_DEBUGGER_MAJOR_VERSION 81 +#define MONO_DEBUGGER_MINOR_VERSION 6 +#define MONO_DEBUGGER_MAGIC 0x7aff65af4253d427ULL + +MONO_API void mono_debug_init (MonoDebugFormat format); +MONO_API void mono_debug_open_image_from_memory (MonoImage *image, const mono_byte *raw_contents, int size); +MONO_API void mono_debug_cleanup (void); + +MONO_API void mono_debug_close_image (MonoImage *image); + +MONO_API void mono_debug_domain_unload (MonoDomain *domain); +MONO_API void mono_debug_domain_create (MonoDomain *domain); + +MONO_API MonoDebugMethodAddress * +mono_debug_add_method (MonoMethod *method, MonoDebugMethodJitInfo *jit, MonoDomain *domain); + +MONO_API void +mono_debug_remove_method (MonoMethod *method, MonoDomain *domain); + +MONO_API MonoDebugMethodInfo * +mono_debug_lookup_method (MonoMethod *method); + +MONO_API MonoDebugMethodAddressList * +mono_debug_lookup_method_addresses (MonoMethod *method); + +MONO_API MonoDebugMethodJitInfo* +mono_debug_find_method (MonoMethod *method, MonoDomain *domain); + +MONO_API MonoDebugHandle * +mono_debug_get_handle (MonoImage *image); + +MONO_API void +mono_debug_free_method_jit_info (MonoDebugMethodJitInfo *jit); + + +MONO_API void +mono_debug_add_delegate_trampoline (void* code, int size); + +MONO_API MonoDebugLocalsInfo* +mono_debug_lookup_locals (MonoMethod *method); + +MonoDebugMethodAsyncInfo* +mono_debug_lookup_method_async_debug_info (MonoMethod *method); + +MONO_API +MonoDebugSourceLocation * +mono_debug_method_lookup_location (MonoDebugMethodInfo *minfo, int il_offset); + +/* + * Line number support. + */ + +MONO_API MonoDebugSourceLocation * +mono_debug_lookup_source_location (MonoMethod *method, uint32_t address, MonoDomain *domain); + +MONO_API int32_t +mono_debug_il_offset_from_address (MonoMethod *method, MonoDomain *domain, uint32_t native_offset); + +MONO_API void +mono_debug_free_source_location (MonoDebugSourceLocation *location); + +MONO_API char * +mono_debug_print_stack_frame (MonoMethod *method, uint32_t native_offset, MonoDomain *domain); + +/* + * Mono Debugger support functions + * + * These methods are used by the JIT while running inside the Mono Debugger. + */ + +MONO_API int mono_debugger_method_has_breakpoint (MonoMethod *method); +MONO_API int mono_debugger_insert_breakpoint (const char *method_name, mono_bool include_namespace); + +MONO_API void mono_set_is_debugger_attached (mono_bool attached); +MONO_API mono_bool mono_is_debugger_attached (void); + +MONO_END_DECLS + +#endif /* __MONO_DEBUG_H__ */ diff --git a/src/mono/msvc/include/mono/metadata/mono-gc.h b/src/mono/msvc/include/mono/metadata/mono-gc.h new file mode 100644 index 0000000000000..7d072a8108e95 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/mono-gc.h @@ -0,0 +1,138 @@ +/** + * \file + * GC related public interface + * + */ +#ifndef __METADATA_MONO_GC_H__ +#define __METADATA_MONO_GC_H__ + +#include + +MONO_BEGIN_DECLS + +typedef int (*MonoGCReferences) (MonoObject *obj, MonoClass *klass, uintptr_t size, uintptr_t num, MonoObject **refs, uintptr_t *offsets, void *data); + +/** + * This enum is used by the profiler API when reporting root registration. + */ +typedef enum { + /** + * Roots external to Mono. Embedders may only use this value. + */ + MONO_ROOT_SOURCE_EXTERNAL = 0, + /** + * Thread call stack. + * + * The \c key parameter is a thread ID as a \c uintptr_t. + */ + MONO_ROOT_SOURCE_STACK = 1, + /** + * Roots in the finalizer queue. This is a pseudo-root. + */ + MONO_ROOT_SOURCE_FINALIZER_QUEUE = 2, + /** + * Managed \c static variables. + * + * The \c key parameter is a \c MonoVTable pointer. + */ + MONO_ROOT_SOURCE_STATIC = 3, + /** + * Managed \c static variables with \c ThreadStaticAttribute. + * + * The \c key parameter is a thread ID as a \c uintptr_t. + */ + MONO_ROOT_SOURCE_THREAD_STATIC = 4, + /** + * Managed \c static variables with \c ContextStaticAttribute. + * + * The \c key parameter is a \c MonoAppContext pointer. + */ + MONO_ROOT_SOURCE_CONTEXT_STATIC = 5, + /** + * \c GCHandle structures. + */ + MONO_ROOT_SOURCE_GC_HANDLE = 6, + /** + * Roots in the just-in-time compiler. + */ + MONO_ROOT_SOURCE_JIT = 7, + /** + * Roots in the threading subsystem. + * + * The \c key parameter, if not \c NULL, is a thread ID as a \c uintptr_t. + */ + MONO_ROOT_SOURCE_THREADING = 8, + /** + * Roots in application domains. + * + * The \c key parameter, if not \c NULL, is a \c MonoDomain pointer. + */ + MONO_ROOT_SOURCE_DOMAIN = 9, + /** + * Roots in reflection code. + * + * The \c key parameter, if not \c NULL, is a \c MonoVTable pointer. + */ + MONO_ROOT_SOURCE_REFLECTION = 10, + /** + * Roots from P/Invoke or other marshaling infrastructure. + */ + MONO_ROOT_SOURCE_MARSHAL = 11, + /** + * Roots in the thread pool data structures. + */ + MONO_ROOT_SOURCE_THREAD_POOL = 12, + /** + * Roots in the debugger agent. + */ + MONO_ROOT_SOURCE_DEBUGGER = 13, + /** + * Roots in the runtime handle stack. This is a pseudo-root. + * + * The \c key parameter is a thread ID as a \c uintptr_t. + */ + MONO_ROOT_SOURCE_HANDLE = 14, + /** + * Roots in the ephemeron arrays. This is a pseudo-root. + */ + MONO_ROOT_SOURCE_EPHEMERON = 15, + /** + * Roots in the toggleref arrays. This is a pseudo-root. + */ + MONO_ROOT_SOURCE_TOGGLEREF = 16, +} MonoGCRootSource; + +typedef enum { + MONO_GC_HANDLE_TYPE_MIN = 0, + MONO_GC_HANDLE_WEAK = MONO_GC_HANDLE_TYPE_MIN, + MONO_GC_HANDLE_WEAK_TRACK_RESURRECTION, + MONO_GC_HANDLE_NORMAL, + MONO_GC_HANDLE_PINNED, + MONO_GC_HANDLE_TYPE_MAX, +} MonoGCHandleType; + +MONO_API void mono_gc_collect (int generation); +MONO_API int mono_gc_max_generation (void); +MONO_API int mono_gc_get_generation (MonoObject *object); +MONO_API int mono_gc_collection_count (int generation); +MONO_API int64_t mono_gc_get_used_size (void); +MONO_API int64_t mono_gc_get_heap_size (void); +MONO_API MonoBoolean mono_gc_pending_finalizers (void); +MONO_API void mono_gc_finalize_notify (void); +MONO_API int mono_gc_invoke_finalizers (void); +/* heap walking is only valid in the pre-stop-world event callback */ +MONO_API int mono_gc_walk_heap (int flags, MonoGCReferences callback, void *data); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_gc_init_finalizer_thread (void); + +/* + * Only supported under SGen. These two with Sgen will take and release the LOCK_GC + */ +void mono_gc_stop_world (void); +void mono_gc_restart_world (void); + +MONO_END_DECLS + +#endif /* __METADATA_MONO_GC_H__ */ + diff --git a/src/mono/msvc/include/mono/metadata/mono-private-unstable.h b/src/mono/msvc/include/mono/metadata/mono-private-unstable.h new file mode 100644 index 0000000000000..7b214bf70adbf --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/mono-private-unstable.h @@ -0,0 +1,41 @@ +/** + * \file + * + * Private unstable APIs. + * + * WARNING: The declarations and behavior of functions in this header are NOT STABLE and can be modified or removed at + * any time. + * + */ + + +#ifndef __MONO_METADATA_MONO_PRIVATE_UNSTABLE_H__ +#define __MONO_METADATA_MONO_PRIVATE_UNSTABLE_H__ + +#include + +typedef MonoGCHandle MonoAssemblyLoadContextGCHandle; + +MONO_API MONO_RT_EXTERNAL_ONLY MonoAssembly * +mono_assembly_load_full_alc (MonoAssemblyLoadContextGCHandle alc_gchandle, MonoAssemblyName *aname, const char *basedir, MonoImageOpenStatus *status); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoImage * +mono_image_open_from_data_alc (MonoAssemblyLoadContextGCHandle alc_gchandle, char *data, uint32_t data_len, mono_bool need_copy, MonoImageOpenStatus *status, const char *name); + +typedef MonoAssembly * (*MonoAssemblyPreLoadFuncV3) (MonoAssemblyLoadContextGCHandle alc_gchandle, MonoAssemblyName *aname, char **assemblies_path, void *user_data, MonoError *error); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_install_assembly_preload_hook_v3 (MonoAssemblyPreLoadFuncV3 func, void *user_data, mono_bool append); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoAssemblyLoadContextGCHandle +mono_alc_get_default_gchandle (void); + +typedef struct _MonoBundledSatelliteAssembly MonoBundledSatelliteAssembly; + +MONO_API void +mono_register_bundled_satellite_assemblies (const MonoBundledSatelliteAssembly **assemblies); + +MONO_API MonoBundledSatelliteAssembly * +mono_create_new_bundled_satellite_assembly (const char *name, const char *culture, const unsigned char *data, unsigned int size); + +#endif /*__MONO_METADATA_MONO_PRIVATE_UNSTABLE_H__*/ diff --git a/src/mono/msvc/include/mono/metadata/object-forward.h b/src/mono/msvc/include/mono/metadata/object-forward.h new file mode 100644 index 0000000000000..010dc8b0f76e4 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/object-forward.h @@ -0,0 +1,22 @@ +/** + * \file + * + * Forward declarations of opaque types, and typedefs thereof. + * + */ + +#ifndef __MONO_OBJECT_FORWARD_H__ +#define __MONO_OBJECT_FORWARD_H__ + +#include + +typedef struct _MonoClass MonoClass; +typedef struct _MonoImage MonoImage; +typedef struct _MonoMethod MonoMethod; + +typedef struct _MonoObject MONO_RT_MANAGED_ATTR MonoObject; +typedef struct _MonoException MONO_RT_MANAGED_ATTR MonoException; +typedef struct _MonoReflectionAssembly MONO_RT_MANAGED_ATTR MonoReflectionAssembly; +typedef struct _MonoReflectionTypeBuilder MONO_RT_MANAGED_ATTR MonoReflectionTypeBuilder; + +#endif /* __MONO_OBJECT_FORWARD_H__ */ diff --git a/src/mono/msvc/include/mono/metadata/object.h b/src/mono/msvc/include/mono/metadata/object.h new file mode 100644 index 0000000000000..f421c6c1a33be --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/object.h @@ -0,0 +1,408 @@ +/** + * \file + */ + +#ifndef _MONO_CLI_OBJECT_H_ +#define _MONO_CLI_OBJECT_H_ + +#include +#include +#include +#include + +MONO_BEGIN_DECLS + +typedef struct _MonoString MONO_RT_MANAGED_ATTR MonoString; +typedef struct _MonoArray MONO_RT_MANAGED_ATTR MonoArray; +typedef struct _MonoReflectionMethod MONO_RT_MANAGED_ATTR MonoReflectionMethod; +typedef struct _MonoReflectionModule MONO_RT_MANAGED_ATTR MonoReflectionModule; +typedef struct _MonoReflectionField MONO_RT_MANAGED_ATTR MonoReflectionField; +typedef struct _MonoReflectionProperty MONO_RT_MANAGED_ATTR MonoReflectionProperty; +typedef struct _MonoReflectionEvent MONO_RT_MANAGED_ATTR MonoReflectionEvent; +typedef struct _MonoReflectionType MONO_RT_MANAGED_ATTR MonoReflectionType; +typedef struct _MonoDelegate MONO_RT_MANAGED_ATTR MonoDelegate; +typedef struct _MonoThreadsSync MonoThreadsSync; +#ifdef ENABLE_NETCORE +typedef struct _MonoInternalThread MONO_RT_MANAGED_ATTR MonoThread; +#else +typedef struct _MonoThread MONO_RT_MANAGED_ATTR MonoThread; +#endif +typedef struct _MonoDynamicAssembly MonoDynamicAssembly; +typedef struct _MonoDynamicImage MonoDynamicImage; +typedef struct _MonoReflectionMethodBody MONO_RT_MANAGED_ATTR MonoReflectionMethodBody; +typedef struct _MonoAppContext MONO_RT_MANAGED_ATTR MonoAppContext; + +struct _MonoObject { + MonoVTable *vtable; + MonoThreadsSync *synchronisation; +}; + +typedef MonoObject* (*MonoInvokeFunc) (MonoMethod *method, void *obj, void **params, MonoObject **exc, MonoError *error); +typedef void* (*MonoCompileFunc) (MonoMethod *method); +typedef void (*MonoMainThreadFunc) (void* user_data); + +#define MONO_OBJECT_SETREF(obj,fieldname,value) do { \ + mono_gc_wbarrier_set_field ((MonoObject*)(obj), &((obj)->fieldname), (MonoObject*)value); \ + /*(obj)->fieldname = (value);*/ \ + } while (0) + +/* This should be used if 's' can reside on the heap */ +#define MONO_STRUCT_SETREF(s,field,value) do { \ + mono_gc_wbarrier_generic_store (&((s)->field), (MonoObject*)(value)); \ + } while (0) + +#define mono_array_addr(array,type,index) ((type*)mono_array_addr_with_size ((array), sizeof (type), (index))) +#define mono_array_get(array,type,index) ( *(type*)mono_array_addr ((array), type, (index)) ) +#define mono_array_set(array,type,index,value) \ + do { \ + type *__p = (type *) mono_array_addr ((array), type, (index)); \ + *__p = (value); \ + } while (0) +#define mono_array_setref(array,index,value) \ + do { \ + void **__p = (void **) mono_array_addr ((array), void*, (index)); \ + mono_gc_wbarrier_set_arrayref ((array), __p, (MonoObject*)(value)); \ + /* *__p = (value);*/ \ + } while (0) +#define mono_array_memcpy_refs(dest,destidx,src,srcidx,count) \ + do { \ + void **__p = (void **) mono_array_addr ((dest), void*, (destidx)); \ + void **__s = mono_array_addr ((src), void*, (srcidx)); \ + mono_gc_wbarrier_arrayref_copy (__p, __s, (count)); \ + } while (0) + +MONO_API MONO_RT_EXTERNAL_ONLY mono_unichar2 *mono_string_chars (MonoString *s); +MONO_API MONO_RT_EXTERNAL_ONLY int mono_string_length (MonoString *s); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * +mono_object_new (MonoDomain *domain, MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoObject * +mono_object_new_specific (MonoVTable *vtable); + +/* can be used for classes without finalizer in non-profiling mode */ +MONO_API MONO_RT_EXTERNAL_ONLY +MonoObject * +mono_object_new_fast (MonoVTable *vtable); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoObject * +mono_object_new_alloc_specific (MonoVTable *vtable); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoObject * +mono_object_new_from_token (MonoDomain *domain, MonoImage *image, uint32_t token); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoArray* +mono_array_new (MonoDomain *domain, MonoClass *eclass, uintptr_t n); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoArray* +mono_array_new_full (MonoDomain *domain, MonoClass *array_class, + uintptr_t *lengths, intptr_t *lower_bounds); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoArray * +mono_array_new_specific (MonoVTable *vtable, uintptr_t n); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoArray* +mono_array_clone (MonoArray *array); + +MONO_API MONO_RT_EXTERNAL_ONLY char* +mono_array_addr_with_size (MonoArray *array, int size, uintptr_t idx); + +MONO_API MONO_RT_EXTERNAL_ONLY uintptr_t +mono_array_length (MonoArray *array); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoString* +mono_string_empty (MonoDomain *domain); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoString* +mono_string_empty_wrapper (void); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoString* +mono_string_new_utf16 (MonoDomain *domain, const mono_unichar2 *text, int32_t len); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoString* +mono_string_new_size (MonoDomain *domain, int32_t len); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoString* +mono_ldstr (MonoDomain *domain, MonoImage *image, uint32_t str_index); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoString* +mono_string_is_interned (MonoString *str); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoString* +mono_string_intern (MonoString *str); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoString* +mono_string_new (MonoDomain *domain, const char *text); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoString* +mono_string_new_wrapper (const char *text); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoString* +mono_string_new_len (MonoDomain *domain, const char *text, unsigned int length); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoString* +mono_string_new_utf32 (MonoDomain *domain, const mono_unichar4 *text, int32_t len); + +MONO_API MONO_RT_EXTERNAL_ONLY +char * +mono_string_to_utf8 (MonoString *string_obj); + +MONO_API MONO_RT_EXTERNAL_ONLY char * +mono_string_to_utf8_checked (MonoString *string_obj, MonoError *error); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_unichar2 * +mono_string_to_utf16 (MonoString *string_obj); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_unichar4 * +mono_string_to_utf32 (MonoString *string_obj); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoString * +mono_string_from_utf16 (/*const*/ mono_unichar2 *data); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoString * +mono_string_from_utf32 (/*const*/ mono_unichar4 *data); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_string_equal (MonoString *s1, MonoString *s2); + +MONO_API MONO_RT_EXTERNAL_ONLY unsigned int +mono_string_hash (MonoString *s); + +MONO_API MONO_RT_EXTERNAL_ONLY int +mono_object_hash (MonoObject* obj); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoString * +mono_object_to_string (MonoObject *obj, MonoObject **exc); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * +mono_value_box (MonoDomain *domain, MonoClass *klass, void* val); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_value_copy (void* dest, /*const*/ void* src, MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_value_copy_array (MonoArray *dest, int dest_idx, void* src, int count); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoVTable* +mono_object_get_vtable (MonoObject *obj); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoDomain* +mono_object_get_domain (MonoObject *obj); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoClass* +mono_object_get_class (MonoObject *obj); + +MONO_API MONO_RT_EXTERNAL_ONLY void* +mono_object_unbox (MonoObject *obj); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * +mono_object_clone (MonoObject *obj); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * +mono_object_isinst (MonoObject *obj, MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * +mono_object_isinst_mbyref (MonoObject *obj, MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * +mono_object_castclass_mbyref (MonoObject *obj, MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_monitor_try_enter (MonoObject *obj, uint32_t ms); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_monitor_enter (MonoObject *obj); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_monitor_enter_v4 (MonoObject *obj, char *lock_taken); + +MONO_API MONO_RT_EXTERNAL_ONLY unsigned int +mono_object_get_size (MonoObject *o); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_monitor_exit (MonoObject *obj); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_raise_exception (MonoException *ex); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_runtime_set_pending_exception (MonoException *exc, mono_bool overwrite); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_reraise_exception (MonoException *ex); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_runtime_object_init (MonoObject *this_obj); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_runtime_class_init (MonoVTable *vtable); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoDomain* +mono_vtable_domain (MonoVTable *vtable); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoClass* +mono_vtable_class (MonoVTable *vtable); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod* +mono_object_get_virtual_method (MonoObject *obj, MonoMethod *method); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject* +mono_runtime_invoke (MonoMethod *method, void *obj, void **params, + MonoObject **exc); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod* +mono_get_delegate_invoke (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod* +mono_get_delegate_begin_invoke (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod* +mono_get_delegate_end_invoke (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject* +mono_runtime_delegate_invoke (MonoObject *delegate, void **params, + MonoObject **exc); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject* +mono_runtime_invoke_array (MonoMethod *method, void *obj, MonoArray *params, + MonoObject **exc); + +MONO_API MONO_RT_EXTERNAL_ONLY void* +mono_method_get_unmanaged_thunk (MonoMethod *method); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoArray* +mono_runtime_get_main_args (void); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_runtime_exec_managed_code (MonoDomain *domain, + MonoMainThreadFunc main_func, + void* main_args); + +MONO_API MONO_RT_EXTERNAL_ONLY int +mono_runtime_run_main (MonoMethod *method, int argc, char* argv[], + MonoObject **exc); + +MONO_API MONO_RT_EXTERNAL_ONLY int +mono_runtime_exec_main (MonoMethod *method, MonoArray *args, + MonoObject **exc); + +MONO_API MONO_RT_EXTERNAL_ONLY int +mono_runtime_set_main_args (int argc, char* argv[]); + +/* The following functions won't be available with mono was configured with remoting disabled. */ +/*#ifndef DISABLE_REMOTING */ +MONO_API MONO_RT_EXTERNAL_ONLY void* +mono_load_remote_field (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, void **res); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * +mono_load_remote_field_new (MonoObject *this_obj, MonoClass *klass, MonoClassField *field); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_store_remote_field (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, void* val); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_store_remote_field_new (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, MonoObject *arg); + +/* #endif */ + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_unhandled_exception (MonoObject *exc); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_print_unhandled_exception (MonoObject *exc); + +MONO_API MONO_RT_EXTERNAL_ONLY +void* +mono_compile_method (MonoMethod *method); + +/* accessors for fields and properties */ +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_field_set_value (MonoObject *obj, MonoClassField *field, void *value); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_field_static_set_value (MonoVTable *vt, MonoClassField *field, void *value); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_field_get_value (MonoObject *obj, MonoClassField *field, void *value); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_field_static_get_value (MonoVTable *vt, MonoClassField *field, void *value); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * +mono_field_get_value_object (MonoDomain *domain, MonoClassField *field, MonoObject *obj); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_property_set_value (MonoProperty *prop, void *obj, void **params, MonoObject **exc); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject* +mono_property_get_value (MonoProperty *prop, void *obj, void **params, MonoObject **exc); + +/* GC handles support + * + * A handle can be created to refer to a managed object and either prevent it + * from being garbage collected or moved or to be able to know if it has been + * collected or not (weak references). + * mono_gchandle_new () is used to prevent an object from being garbage collected + * until mono_gchandle_free() is called. Use a TRUE value for the pinned argument to + * prevent the object from being moved (this should be avoided as much as possible + * and this should be used only for shorts periods of time or performance will suffer). + * To create a weakref use mono_gchandle_new_weakref (): track_resurrection should + * usually be false (see the GC docs for more details). + * mono_gchandle_get_target () can be used to get the object referenced by both kinds + * of handle: for a weakref handle, if an object has been collected, it will return NULL. + */ +MONO_API MONO_RT_EXTERNAL_ONLY uint32_t mono_gchandle_new (MonoObject *obj, mono_bool pinned); +MONO_API MONO_RT_EXTERNAL_ONLY uint32_t mono_gchandle_new_weakref (MonoObject *obj, mono_bool track_resurrection); +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject* mono_gchandle_get_target (uint32_t gchandle); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_gchandle_free (uint32_t gchandle); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoGCHandle mono_gchandle_new_v2 (MonoObject *obj, mono_bool pinned); +MONO_API MONO_RT_EXTERNAL_ONLY MonoGCHandle mono_gchandle_new_weakref_v2 (MonoObject *obj, mono_bool track_resurrection); +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject* mono_gchandle_get_target_v2 (MonoGCHandle gchandle); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_gchandle_free_v2 (MonoGCHandle gchandle); + +/* Reference queue support + * + * A reference queue is used to get notifications of when objects are collected. + * Call mono_gc_reference_queue_new to create a new queue and pass the callback that + * will be invoked when registered objects are collected. + * Call mono_gc_reference_queue_add to register a pair of objects and data within a queue. + * The callback will be triggered once an object is both unreachable and finalized. + */ + +typedef void (*mono_reference_queue_callback) (void *user_data); +typedef struct _MonoReferenceQueue MonoReferenceQueue; + +MONO_API MONO_RT_EXTERNAL_ONLY MonoReferenceQueue* mono_gc_reference_queue_new (mono_reference_queue_callback callback); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_reference_queue_free (MonoReferenceQueue *queue); +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool mono_gc_reference_queue_add (MonoReferenceQueue *queue, MonoObject *obj, void *user_data); + +/* GC write barriers support */ +MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_set_field (MonoObject *obj, void* field_ptr, MonoObject* value); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_set_arrayref (MonoArray *arr, void* slot_ptr, MonoObject* value); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_arrayref_copy (void* dest_ptr, /*const*/ void* src_ptr, int count); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_generic_store (void* ptr, MonoObject* value); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_generic_store_atomic (void *ptr, MonoObject *value); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_generic_nostore (void* ptr); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_value_copy (void* dest, /*const*/ void* src, int count, MonoClass *klass); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_object_copy (MonoObject* obj, MonoObject *src); + +MONO_END_DECLS + +#endif diff --git a/src/mono/msvc/include/mono/metadata/opcodes.h b/src/mono/msvc/include/mono/metadata/opcodes.h new file mode 100644 index 0000000000000..bcaf099a44bc1 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/opcodes.h @@ -0,0 +1,83 @@ +/** + * \file + */ + +#ifndef __MONO_METADATA_OPCODES_H__ +#define __MONO_METADATA_OPCODES_H__ + +/* + * opcodes.h: CIL instruction information + * + * Author: + * Paolo Molaro (lupus@ximian.com) + * + * (C) 2002 Ximian, Inc. + */ + +#include + +MONO_BEGIN_DECLS + +#define MONO_CUSTOM_PREFIX 0xf0 + +#define OPDEF(a,b,c,d,e,f,g,h,i,j) \ + MONO_ ## a, + +typedef enum MonoOpcodeEnum { + MonoOpcodeEnum_Invalid = -1, +#include "mono/cil/opcode.def" + MONO_CEE_LAST +} MonoOpcodeEnum; + +#undef OPDEF + +enum { + MONO_FLOW_NEXT, + MONO_FLOW_BRANCH, + MONO_FLOW_COND_BRANCH, + MONO_FLOW_ERROR, + MONO_FLOW_CALL, + MONO_FLOW_RETURN, + MONO_FLOW_META +}; + +enum { + MonoInlineNone = 0, + MonoInlineType = 1, + MonoInlineField = 2, + MonoInlineMethod = 3, + MonoInlineTok = 4, + MonoInlineString = 5, + MonoInlineSig = 6, + MonoInlineVar = 7, + MonoShortInlineVar = 8, + MonoInlineBrTarget = 9, + MonoShortInlineBrTarget = 10, + MonoInlineSwitch = 11, + MonoInlineR = 12, + MonoShortInlineR = 13, + MonoInlineI = 14, + MonoShortInlineI = 15, + MonoInlineI8 = 16, +}; + +typedef struct { + unsigned char argument; + unsigned char flow_type; + unsigned short opval; +} MonoOpcode; + +MONO_BEGIN_DECLS +MONO_API_DATA const MonoOpcode mono_opcodes []; +MONO_END_DECLS + +MONO_API const char* +mono_opcode_name (int opcode); + +MONO_API MonoOpcodeEnum +mono_opcode_value (const mono_byte **ip, const mono_byte *end); + +MONO_END_DECLS + +#endif /* __MONO_METADATA_OPCODES_H__ */ + diff --git a/src/mono/msvc/include/mono/metadata/profiler-events.h b/src/mono/msvc/include/mono/metadata/profiler-events.h new file mode 100644 index 0000000000000..c7ab3f66d516d --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/profiler-events.h @@ -0,0 +1,108 @@ +/* + * Licensed to the .NET Foundation under one or more agreements. + * The .NET Foundation licenses this file to you under the MIT license. + */ + +/* + * To #include this file, #define the following macros first: + * + * MONO_PROFILER_EVENT_0(name, type) + * MONO_PROFILER_EVENT_1(name, type, arg1_type, arg1_name) + * MONO_PROFILER_EVENT_2(name, type, arg1_type, arg1_name, arg2_type, arg2_name) + * MONO_PROFILER_EVENT_3(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name) + * MONO_PROFILER_EVENT_4(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name, arg4_type, arg4_name) + * MONO_PROFILER_EVENT_5(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name, arg4_type, arg4_name, arg5_type, arg5_name) + * + * To add new callbacks to the API, simply add a line in this file and use + * MONO_PROFILER_RAISE to raise the event wherever. + * + * If you need more arguments then the current macros provide, add another + * macro and update all areas where the macros are used. Remember that this is + * a public header and not all users will be defining the newly added macro. So + * to prevent errors in existing code, you must add something like this at the + * beginning of this file: + * + * #ifndef MONO_PROFILER_EVENT_6 + * #define MONO_PROFILER_EVENT_6(...) # Do nothing. + * #endif + */ + +#ifndef MONO_PROFILER_EVENT_5 +#define MONO_PROFILER_EVENT_5(...) +#endif + +MONO_PROFILER_EVENT_0(runtime_initialized, RuntimeInitialized) +MONO_PROFILER_EVENT_0(runtime_shutdown_begin, RuntimeShutdownBegin) +MONO_PROFILER_EVENT_0(runtime_shutdown_end, RuntimeShutdownEnd) + +MONO_PROFILER_EVENT_1(context_loaded, ContextLoaded, MonoAppContext *, context) +MONO_PROFILER_EVENT_1(context_unloaded, ContextUnloaded, MonoAppContext *, context) + +MONO_PROFILER_EVENT_1(domain_loading, DomainLoading, MonoDomain *, domain) +MONO_PROFILER_EVENT_1(domain_loaded, DomainLoaded, MonoDomain *, domain) +MONO_PROFILER_EVENT_1(domain_unloading, DomainUnloading, MonoDomain *, domain) +MONO_PROFILER_EVENT_1(domain_unloaded, DomainUnloaded, MonoDomain *, domain) +MONO_PROFILER_EVENT_2(domain_name, DomainName, MonoDomain *, domain, const char *, name) + +MONO_PROFILER_EVENT_1(jit_begin, JitBegin, MonoMethod *, method) +MONO_PROFILER_EVENT_1(jit_failed, JitFailed, MonoMethod *, method) +MONO_PROFILER_EVENT_2(jit_done, JitDone, MonoMethod *, method, MonoJitInfo *, jinfo) +MONO_PROFILER_EVENT_2(jit_chunk_created, JitChunkCreated, const mono_byte *, chunk, uintptr_t, size) +MONO_PROFILER_EVENT_1(jit_chunk_destroyed, JitChunkDestroyed, const mono_byte *, chunk) +MONO_PROFILER_EVENT_4(jit_code_buffer, JitCodeBuffer, const mono_byte *, buffer, uint64_t, size, MonoProfilerCodeBufferType, type, const void *, data) + +MONO_PROFILER_EVENT_1(class_loading, ClassLoading, MonoClass *, klass) +MONO_PROFILER_EVENT_1(class_failed, ClassFailed, MonoClass *, klass) +MONO_PROFILER_EVENT_1(class_loaded, ClassLoaded, MonoClass *, klass) + +MONO_PROFILER_EVENT_1(vtable_loading, VTableLoading, MonoVTable *, vtable) +MONO_PROFILER_EVENT_1(vtable_failed, VTableFailed, MonoVTable *, vtable) +MONO_PROFILER_EVENT_1(vtable_loaded, VTableLoaded, MonoVTable *, vtable) + +MONO_PROFILER_EVENT_1(image_loading, ModuleLoading, MonoImage *, image) +MONO_PROFILER_EVENT_1(image_failed, ModuleFailed, MonoImage *, image) +MONO_PROFILER_EVENT_1(image_loaded, ModuleLoaded, MonoImage *, image) +MONO_PROFILER_EVENT_1(image_unloading, ModuleUnloading, MonoImage *, image) +MONO_PROFILER_EVENT_1(image_unloaded, ModuleUnloaded, MonoImage *, image) + +MONO_PROFILER_EVENT_1(assembly_loading, AssemblyLoading, MonoAssembly *, assembly) +MONO_PROFILER_EVENT_1(assembly_loaded, AssemblyLLoaded, MonoAssembly *, assembly) +MONO_PROFILER_EVENT_1(assembly_unloading, AssemblyLUnloading, MonoAssembly *, assembly) +MONO_PROFILER_EVENT_1(assembly_unloaded, AssemblyLUnloaded, MonoAssembly *, assembly) + +MONO_PROFILER_EVENT_2(method_enter, MethodEnter, MonoMethod *, method, MonoProfilerCallContext *, context) +MONO_PROFILER_EVENT_2(method_leave, MethodLeave, MonoMethod *, method, MonoProfilerCallContext *, context) +MONO_PROFILER_EVENT_2(method_tail_call, MethodTailCall, MonoMethod *, method, MonoMethod *, target) +MONO_PROFILER_EVENT_2(method_exception_leave, MethodExceptionLeave, MonoMethod *, method, MonoObject *, exception) +MONO_PROFILER_EVENT_1(method_free, MethodFree, MonoMethod *, method) +MONO_PROFILER_EVENT_1(method_begin_invoke, MethodBeginInvoke, MonoMethod *, method) +MONO_PROFILER_EVENT_1(method_end_invoke, MethodEndInvoke, MonoMethod *, method) + +MONO_PROFILER_EVENT_1(exception_throw, ExceptionThrow, MonoObject *, exception) +MONO_PROFILER_EVENT_4(exception_clause, ExceptionClause, MonoMethod *, method, uint32_t, index, MonoExceptionEnum, type, MonoObject *, exception) + +MONO_PROFILER_EVENT_3(gc_event, GCEvent2, MonoProfilerGCEvent, event, uint32_t, generation, mono_bool, is_serial) +MONO_PROFILER_EVENT_1(gc_allocation, GCAllocation, MonoObject *, object) +MONO_PROFILER_EVENT_2(gc_moves, GCMoves, MonoObject *const *, objects, uint64_t, count) +MONO_PROFILER_EVENT_1(gc_resize, GCResize, uintptr_t, size) +MONO_PROFILER_EVENT_3(gc_handle_created, GCHandleCreated, uint32_t, handle, MonoGCHandleType, type, MonoObject *, object) +MONO_PROFILER_EVENT_2(gc_handle_deleted, GCHandleDeleted, uint32_t, handle, MonoGCHandleType, type) +MONO_PROFILER_EVENT_0(gc_finalizing, GCFinalizing) +MONO_PROFILER_EVENT_0(gc_finalized, GCFinalized) +MONO_PROFILER_EVENT_1(gc_finalizing_object, GCFinalizingObject, MonoObject *, object) +MONO_PROFILER_EVENT_1(gc_finalized_object, GCFinalizedObject, MonoObject *, object) +MONO_PROFILER_EVENT_5(gc_root_register, RootRegister, const mono_byte *, start, uintptr_t, size, MonoGCRootSource, source, const void *, key, const char *, name) +MONO_PROFILER_EVENT_1(gc_root_unregister, RootUnregister, const mono_byte *, start) +MONO_PROFILER_EVENT_3(gc_roots, GCRoots, uint64_t, count, const mono_byte *const *, addresses, MonoObject *const *, objects) + +MONO_PROFILER_EVENT_1(monitor_contention, MonitorContention, MonoObject *, object) +MONO_PROFILER_EVENT_1(monitor_failed, MonitorFailed, MonoObject *, object) +MONO_PROFILER_EVENT_1(monitor_acquired, MonitorAcquired, MonoObject *, object) + +MONO_PROFILER_EVENT_1(thread_started, ThreadStarted, uintptr_t, tid) +MONO_PROFILER_EVENT_1(thread_stopping, ThreadStopping, uintptr_t, tid) +MONO_PROFILER_EVENT_1(thread_stopped, ThreadStopped, uintptr_t, tid) +MONO_PROFILER_EVENT_1(thread_exited, ThreadExited, uintptr_t, tid) +MONO_PROFILER_EVENT_2(thread_name, ThreadName, uintptr_t, tid, const char *, name) + +MONO_PROFILER_EVENT_2(sample_hit, SampleHit, const mono_byte *, ip, const void *, context) diff --git a/src/mono/msvc/include/mono/metadata/profiler.h b/src/mono/msvc/include/mono/metadata/profiler.h new file mode 100644 index 0000000000000..2fd2d840f82a5 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/profiler.h @@ -0,0 +1,248 @@ +/* + * Licensed to the .NET Foundation under one or more agreements. + * The .NET Foundation licenses this file to you under the MIT license. + */ + +#ifndef __MONO_PROFILER_H__ +#define __MONO_PROFILER_H__ + +#include +#include +#include + +MONO_BEGIN_DECLS + +/** + * This value will be incremented whenever breaking changes to the profiler API + * are made. This macro is intended for use in profiler modules that wish to + * support older versions of the profiler API. + * + * Version 2: + * - Major overhaul of the profiler API. + * Version 3: + * - Added mono_profiler_enable_clauses (). This must now be called to enable + * raising exception_clause events. + * - The exception argument to exception_clause events can now be NULL for + * finally clauses invoked in the non-exceptional case. + * - The type argument to exception_clause events will now correctly indicate + * that the catch portion of the clause is being executed in the case of + * try-filter-catch clauses. + * - Removed the iomap_report event. + * - Removed the old gc_event event and renamed gc_event2 to gc_event. + */ +#define MONO_PROFILER_API_VERSION 3 + +typedef struct _MonoProfiler MonoProfiler; +typedef struct _MonoProfilerDesc *MonoProfilerHandle; + +typedef void (*MonoProfilerCleanupCallback) (MonoProfiler *prof); + +MONO_API void mono_profiler_load (const char *desc); +MONO_API MonoProfilerHandle mono_profiler_create (MonoProfiler *prof); +MONO_API void mono_profiler_set_cleanup_callback (MonoProfilerHandle handle, MonoProfilerCleanupCallback cb); + +typedef struct { + MonoMethod *method; + uint32_t il_offset; + uint32_t counter; + const char *file_name; + uint32_t line; + uint32_t column; +} MonoProfilerCoverageData; + +typedef mono_bool (*MonoProfilerCoverageFilterCallback) (MonoProfiler *prof, MonoMethod *method); +typedef void (*MonoProfilerCoverageCallback) (MonoProfiler *prof, const MonoProfilerCoverageData *data); + +MONO_API mono_bool mono_profiler_enable_coverage (void); +MONO_API void mono_profiler_set_coverage_filter_callback (MonoProfilerHandle handle, MonoProfilerCoverageFilterCallback cb); +MONO_API mono_bool mono_profiler_get_coverage_data (MonoProfilerHandle handle, MonoMethod *method, MonoProfilerCoverageCallback cb); + +typedef enum { + /** + * Do not perform sampling. Will make the sampling thread sleep until the + * sampling mode is changed to one of the below modes. + */ + MONO_PROFILER_SAMPLE_MODE_NONE = 0, + /** + * Try to base sampling frequency on process activity. Falls back to + * MONO_PROFILER_SAMPLE_MODE_REAL if such a clock is not available. + */ + MONO_PROFILER_SAMPLE_MODE_PROCESS = 1, + /** + * Base sampling frequency on wall clock time. Uses a monotonic clock when + * available (all major platforms). + */ + MONO_PROFILER_SAMPLE_MODE_REAL = 2, +} MonoProfilerSampleMode; + +MONO_API mono_bool mono_profiler_enable_sampling (MonoProfilerHandle handle); +MONO_API mono_bool mono_profiler_set_sample_mode (MonoProfilerHandle handle, MonoProfilerSampleMode mode, uint32_t freq); +MONO_API mono_bool mono_profiler_get_sample_mode (MonoProfilerHandle handle, MonoProfilerSampleMode *mode, uint32_t *freq); + +MONO_API mono_bool mono_profiler_enable_allocations (void); +MONO_API mono_bool mono_profiler_enable_clauses (void); + +typedef struct _MonoProfilerCallContext MonoProfilerCallContext; + +typedef enum { + /** + * Do not instrument calls. + */ + MONO_PROFILER_CALL_INSTRUMENTATION_NONE = 0, + /** + * Instrument method entries. + */ + MONO_PROFILER_CALL_INSTRUMENTATION_ENTER = 1 << 1, + /** + * Also capture a call context for method entries. + */ + MONO_PROFILER_CALL_INSTRUMENTATION_ENTER_CONTEXT = 1 << 2, + /** + * Instrument method exits. + */ + MONO_PROFILER_CALL_INSTRUMENTATION_LEAVE = 1 << 3, + /** + * Also capture a call context for method exits. + */ + MONO_PROFILER_CALL_INSTRUMENTATION_LEAVE_CONTEXT = 1 << 4, + /** + * Instrument method exits as a result of a tail call. + */ + MONO_PROFILER_CALL_INSTRUMENTATION_TAIL_CALL = 1 << 5, + /** + * Instrument exceptional method exits. + */ + MONO_PROFILER_CALL_INSTRUMENTATION_EXCEPTION_LEAVE = 1 << 6, +} MonoProfilerCallInstrumentationFlags; + +typedef MonoProfilerCallInstrumentationFlags (*MonoProfilerCallInstrumentationFilterCallback) (MonoProfiler *prof, MonoMethod *method); + +MONO_API void mono_profiler_set_call_instrumentation_filter_callback (MonoProfilerHandle handle, MonoProfilerCallInstrumentationFilterCallback cb); +MONO_API mono_bool mono_profiler_enable_call_context_introspection (void); +MONO_API void *mono_profiler_call_context_get_this (MonoProfilerCallContext *context); +MONO_API void *mono_profiler_call_context_get_argument (MonoProfilerCallContext *context, uint32_t position); +MONO_API void *mono_profiler_call_context_get_local (MonoProfilerCallContext *context, uint32_t position); +MONO_API void *mono_profiler_call_context_get_result (MonoProfilerCallContext *context); +MONO_API void mono_profiler_call_context_free_buffer (void *buffer); + +typedef enum { + /** + * The \c data parameter is a \c MonoMethod pointer. + */ + MONO_PROFILER_CODE_BUFFER_METHOD = 0, + /** + * \deprecated No longer used. + */ + MONO_PROFILER_CODE_BUFFER_METHOD_TRAMPOLINE = 1, + /** + * The \c data parameter is a \c MonoMethod pointer. + */ + MONO_PROFILER_CODE_BUFFER_UNBOX_TRAMPOLINE = 2, + MONO_PROFILER_CODE_BUFFER_IMT_TRAMPOLINE = 3, + MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE = 4, + /** + * The \c data parameter is a C string. + */ + MONO_PROFILER_CODE_BUFFER_SPECIFIC_TRAMPOLINE = 5, + MONO_PROFILER_CODE_BUFFER_HELPER = 6, + /** + * \deprecated No longer used. + */ + MONO_PROFILER_CODE_BUFFER_MONITOR = 7, + MONO_PROFILER_CODE_BUFFER_DELEGATE_INVOKE = 8, + MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING = 9, +} MonoProfilerCodeBufferType; + +typedef enum { + MONO_GC_EVENT_PRE_STOP_WORLD = 6, + /** + * When this event arrives, the GC and suspend locks are acquired. + */ + MONO_GC_EVENT_PRE_STOP_WORLD_LOCKED = 10, + MONO_GC_EVENT_POST_STOP_WORLD = 7, + MONO_GC_EVENT_START = 0, + MONO_GC_EVENT_END = 5, + MONO_GC_EVENT_PRE_START_WORLD = 8, + /** + * When this event arrives, the GC and suspend locks are released. + */ + MONO_GC_EVENT_POST_START_WORLD_UNLOCKED = 11, + MONO_GC_EVENT_POST_START_WORLD = 9, +} MonoProfilerGCEvent; + +/* + * The macros below will generate the majority of the callback API. Refer to + * mono/metadata/profiler-events.h for a list of callbacks. They are expanded + * like so: + * + * typedef void (*MonoProfilerRuntimeInitializedCallback (MonoProfiler *prof); + * MONO_API void mono_profiler_set_runtime_initialized_callback (MonoProfiler *prof, MonoProfilerRuntimeInitializedCallback cb); + * + * typedef void (*MonoProfilerRuntimeShutdownCallback (MonoProfiler *prof); + * MONO_API void mono_profiler_set_runtime_shutdown_callback (MonoProfiler *prof, MonoProfilerRuntimeShutdownCallback cb); + * + * typedef void (*MonoProfilerContextLoadedCallback (MonoProfiler *prof); + * MONO_API void mono_profiler_set_context_loaded_callback (MonoProfiler *prof, MonoProfilerContextLoadedCallback cb); + * + * typedef void (*MonoProfilerContextUnloadedCallback (MonoProfiler *prof); + * MONO_API void mono_profiler_set_context_unloaded_callback (MonoProfiler *prof, MonoProfilerContextUnloadedCallback cb); + * + * Etc. + * + * To remove a callback, pass NULL instead of a valid function pointer. + * Callbacks can be changed at any point, but note that doing so is inherently + * racy with respect to threads that aren't suspended, i.e. you may still see a + * call from another thread right after you change a callback. + * + * These functions are async safe. + */ + +#define _MONO_PROFILER_EVENT(type, ...) \ + typedef void (*MonoProfiler ## type ## Callback) (__VA_ARGS__); +#define MONO_PROFILER_EVENT_0(name, type) \ + _MONO_PROFILER_EVENT(type, MonoProfiler *prof) +#define MONO_PROFILER_EVENT_1(name, type, arg1_type, arg1_name) \ + _MONO_PROFILER_EVENT(type, MonoProfiler *prof, arg1_type arg1_name) +#define MONO_PROFILER_EVENT_2(name, type, arg1_type, arg1_name, arg2_type, arg2_name) \ + _MONO_PROFILER_EVENT(type, MonoProfiler *prof, arg1_type arg1_name, arg2_type arg2_name) +#define MONO_PROFILER_EVENT_3(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name) \ + _MONO_PROFILER_EVENT(type, MonoProfiler *prof, arg1_type arg1_name, arg2_type arg2_name, arg3_type arg3_name) +#define MONO_PROFILER_EVENT_4(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name, arg4_type, arg4_name) \ + _MONO_PROFILER_EVENT(type, MonoProfiler *prof, arg1_type arg1_name, arg2_type arg2_name, arg3_type arg3_name, arg4_type arg4_name) +#define MONO_PROFILER_EVENT_5(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name, arg4_type, arg4_name, arg5_type, arg5_name) \ + _MONO_PROFILER_EVENT(type, MonoProfiler *prof, arg1_type arg1_name, arg2_type arg2_name, arg3_type arg3_name, arg4_type arg4_name, arg5_type arg5_name) +#include +#undef MONO_PROFILER_EVENT_0 +#undef MONO_PROFILER_EVENT_1 +#undef MONO_PROFILER_EVENT_2 +#undef MONO_PROFILER_EVENT_3 +#undef MONO_PROFILER_EVENT_4 +#undef MONO_PROFILER_EVENT_5 +#undef _MONO_PROFILER_EVENT + +#define _MONO_PROFILER_EVENT(name, type) \ + MONO_API void mono_profiler_set_ ## name ## _callback (MonoProfilerHandle handle, MonoProfiler ## type ## Callback cb); +#define MONO_PROFILER_EVENT_0(name, type) \ + _MONO_PROFILER_EVENT(name, type) +#define MONO_PROFILER_EVENT_1(name, type, arg1_type, arg1_name) \ + _MONO_PROFILER_EVENT(name, type) +#define MONO_PROFILER_EVENT_2(name, type, arg1_type, arg1_name, arg2_type, arg2_name) \ + _MONO_PROFILER_EVENT(name, type) +#define MONO_PROFILER_EVENT_3(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name) \ + _MONO_PROFILER_EVENT(name, type) +#define MONO_PROFILER_EVENT_4(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name, arg4_type, arg4_name) \ + _MONO_PROFILER_EVENT(name, type) +#define MONO_PROFILER_EVENT_5(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name, arg4_type, arg4_name, arg5_type, arg5_name) \ + _MONO_PROFILER_EVENT(name, type) +#include +#undef MONO_PROFILER_EVENT_0 +#undef MONO_PROFILER_EVENT_1 +#undef MONO_PROFILER_EVENT_2 +#undef MONO_PROFILER_EVENT_3 +#undef MONO_PROFILER_EVENT_4 +#undef MONO_PROFILER_EVENT_5 +#undef _MONO_PROFILER_EVENT + +MONO_END_DECLS + +#endif // __MONO_PROFILER_H__ diff --git a/src/mono/msvc/include/mono/metadata/reflection.h b/src/mono/msvc/include/mono/metadata/reflection.h new file mode 100644 index 0000000000000..83bcfccd657bf --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/reflection.h @@ -0,0 +1,174 @@ +/** + * \file + */ + +#ifndef __METADATA_REFLECTION_H__ +#define __METADATA_REFLECTION_H__ + +#include +#include + +MONO_BEGIN_DECLS + +typedef struct MonoTypeNameParse MonoTypeNameParse; + +typedef struct { + MonoMethod *ctor; + uint32_t data_size; + const mono_byte* data; +} MonoCustomAttrEntry; + +typedef struct { + int num_attrs; + int cached; + MonoImage *image; + MonoCustomAttrEntry attrs [MONO_ZERO_LEN_ARRAY]; +} MonoCustomAttrInfo; + +#define MONO_SIZEOF_CUSTOM_ATTR_INFO (offsetof (MonoCustomAttrInfo, attrs)) + +/* + * Information which isn't in the MonoMethod structure is stored here for + * dynamic methods. + */ +typedef struct { + char **param_names; + MonoMarshalSpec **param_marshall; + MonoCustomAttrInfo **param_cattr; + uint8_t** param_defaults; + uint32_t *param_default_types; + char *dllentry, *dll; +} MonoReflectionMethodAux; + +typedef enum { + ResolveTokenError_OutOfRange, + ResolveTokenError_BadTable, + ResolveTokenError_Other +} MonoResolveTokenError; + +MONO_API MONO_RT_EXTERNAL_ONLY +int mono_reflection_parse_type (char *name, MonoTypeNameParse *info); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoType* mono_reflection_get_type (MonoImage* image, MonoTypeNameParse *info, mono_bool ignorecase, mono_bool *type_resolve); +MONO_API void mono_reflection_free_type_info (MonoTypeNameParse *info); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoType* mono_reflection_type_from_name (char *name, MonoImage *image); +MONO_API MONO_RT_EXTERNAL_ONLY +uint32_t mono_reflection_get_token (MonoObject *obj); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoReflectionAssembly* mono_assembly_get_object (MonoDomain *domain, MonoAssembly *assembly); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoReflectionModule* mono_module_get_object (MonoDomain *domain, MonoImage *image); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoReflectionModule* mono_module_file_get_object (MonoDomain *domain, MonoImage *image, int table_index); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoReflectionType* mono_type_get_object (MonoDomain *domain, MonoType *type); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoReflectionMethod* mono_method_get_object (MonoDomain *domain, MonoMethod *method, MonoClass *refclass); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoReflectionField* mono_field_get_object (MonoDomain *domain, MonoClass *klass, MonoClassField *field); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoReflectionProperty* mono_property_get_object (MonoDomain *domain, MonoClass *klass, MonoProperty *property); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoReflectionEvent* mono_event_get_object (MonoDomain *domain, MonoClass *klass, MonoEvent *event); +/* note: this one is slightly different: we keep the whole array of params in the cache */ +MONO_API MONO_RT_EXTERNAL_ONLY +MonoArray* mono_param_get_objects (MonoDomain *domain, MonoMethod *method); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoReflectionMethodBody* mono_method_body_get_object (MonoDomain *domain, MonoMethod *method); + +MONO_API MonoObject *mono_get_dbnull_object (MonoDomain *domain); + +MONO_API MonoArray* mono_reflection_get_custom_attrs_by_type (MonoObject *obj, MonoClass *attr_klass, MonoError *error); +MONO_API MonoArray* mono_reflection_get_custom_attrs (MonoObject *obj); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoArray* mono_reflection_get_custom_attrs_data (MonoObject *obj); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoArray* mono_reflection_get_custom_attrs_blob (MonoReflectionAssembly *assembly, MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *porpValues, MonoArray *fields, MonoArray* fieldValues); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoCustomAttrInfo* mono_reflection_get_custom_attrs_info (MonoObject *obj); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoArray* mono_custom_attrs_construct (MonoCustomAttrInfo *cinfo); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoCustomAttrInfo* mono_custom_attrs_from_index (MonoImage *image, uint32_t idx); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoCustomAttrInfo* mono_custom_attrs_from_method (MonoMethod *method); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoCustomAttrInfo* mono_custom_attrs_from_class (MonoClass *klass); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoCustomAttrInfo* mono_custom_attrs_from_assembly (MonoAssembly *assembly); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoCustomAttrInfo* mono_custom_attrs_from_property (MonoClass *klass, MonoProperty *property); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoCustomAttrInfo* mono_custom_attrs_from_event (MonoClass *klass, MonoEvent *event); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoCustomAttrInfo* mono_custom_attrs_from_field (MonoClass *klass, MonoClassField *field); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoCustomAttrInfo* mono_custom_attrs_from_param (MonoMethod *method, uint32_t param); +MONO_API mono_bool mono_custom_attrs_has_attr (MonoCustomAttrInfo *ainfo, MonoClass *attr_klass); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoObject* mono_custom_attrs_get_attr (MonoCustomAttrInfo *ainfo, MonoClass *attr_klass); +MONO_API void mono_custom_attrs_free (MonoCustomAttrInfo *ainfo); + + +#define MONO_DECLSEC_ACTION_MIN 0x1 +#define MONO_DECLSEC_ACTION_MAX 0x12 + +enum { + MONO_DECLSEC_FLAG_REQUEST = 0x00000001, + MONO_DECLSEC_FLAG_DEMAND = 0x00000002, + MONO_DECLSEC_FLAG_ASSERT = 0x00000004, + MONO_DECLSEC_FLAG_DENY = 0x00000008, + MONO_DECLSEC_FLAG_PERMITONLY = 0x00000010, + MONO_DECLSEC_FLAG_LINKDEMAND = 0x00000020, + MONO_DECLSEC_FLAG_INHERITANCEDEMAND = 0x00000040, + MONO_DECLSEC_FLAG_REQUEST_MINIMUM = 0x00000080, + MONO_DECLSEC_FLAG_REQUEST_OPTIONAL = 0x00000100, + MONO_DECLSEC_FLAG_REQUEST_REFUSE = 0x00000200, + MONO_DECLSEC_FLAG_PREJIT_GRANT = 0x00000400, + MONO_DECLSEC_FLAG_PREJIT_DENY = 0x00000800, + MONO_DECLSEC_FLAG_NONCAS_DEMAND = 0x00001000, + MONO_DECLSEC_FLAG_NONCAS_LINKDEMAND = 0x00002000, + MONO_DECLSEC_FLAG_NONCAS_INHERITANCEDEMAND = 0x00004000, + MONO_DECLSEC_FLAG_LINKDEMAND_CHOICE = 0x00008000, + MONO_DECLSEC_FLAG_INHERITANCEDEMAND_CHOICE = 0x00010000, + MONO_DECLSEC_FLAG_DEMAND_CHOICE = 0x00020000 +}; + +MONO_API uint32_t mono_declsec_flags_from_method (MonoMethod *method); +MONO_API uint32_t mono_declsec_flags_from_class (MonoClass *klass); +MONO_API uint32_t mono_declsec_flags_from_assembly (MonoAssembly *assembly); + +/* this structure MUST be kept in synch with RuntimeDeclSecurityEntry + * located in /mcs/class/corlib/System.Security/SecurityFrame.cs */ +typedef struct { + char *blob; /* pointer to metadata blob */ + uint32_t size; /* size of the metadata blob */ + uint32_t index; +} MonoDeclSecurityEntry; + +typedef struct { + MonoDeclSecurityEntry demand; + MonoDeclSecurityEntry noncasdemand; + MonoDeclSecurityEntry demandchoice; +} MonoDeclSecurityActions; + +MONO_API MonoBoolean mono_declsec_get_demands (MonoMethod *callee, MonoDeclSecurityActions* demands); +MONO_API MonoBoolean mono_declsec_get_linkdemands (MonoMethod *callee, MonoDeclSecurityActions* klass, MonoDeclSecurityActions* cmethod); +MONO_API MonoBoolean mono_declsec_get_inheritdemands_class (MonoClass *klass, MonoDeclSecurityActions* demands); +MONO_API MonoBoolean mono_declsec_get_inheritdemands_method (MonoMethod *callee, MonoDeclSecurityActions* demands); + +MONO_API MonoBoolean mono_declsec_get_method_action (MonoMethod *method, uint32_t action, MonoDeclSecurityEntry *entry); +MONO_API MonoBoolean mono_declsec_get_class_action (MonoClass *klass, uint32_t action, MonoDeclSecurityEntry *entry); +MONO_API MonoBoolean mono_declsec_get_assembly_action (MonoAssembly *assembly, uint32_t action, MonoDeclSecurityEntry *entry); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoType* mono_reflection_type_get_type (MonoReflectionType *reftype); + +MONO_API MonoAssembly* mono_reflection_assembly_get_assembly (MonoReflectionAssembly *refassembly); + +MONO_END_DECLS + +#endif /* __METADATA_REFLECTION_H__ */ diff --git a/src/mono/msvc/include/mono/metadata/row-indexes.h b/src/mono/msvc/include/mono/metadata/row-indexes.h new file mode 100644 index 0000000000000..b0f5dc072d681 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/row-indexes.h @@ -0,0 +1,503 @@ +/** + * \file + */ + +#ifndef __MONO_METADATA_ROW_INDEXES_H__ +#define __MONO_METADATA_ROW_INDEXES_H__ + +/* + * The last entry in the enum is used to give the number + * of columns in the row. + */ + +enum { + MONO_ASSEMBLY_HASH_ALG, + MONO_ASSEMBLY_MAJOR_VERSION, + MONO_ASSEMBLY_MINOR_VERSION, + MONO_ASSEMBLY_BUILD_NUMBER, + MONO_ASSEMBLY_REV_NUMBER, + MONO_ASSEMBLY_FLAGS, + MONO_ASSEMBLY_PUBLIC_KEY, + MONO_ASSEMBLY_NAME, + MONO_ASSEMBLY_CULTURE, + MONO_ASSEMBLY_SIZE +}; + +enum { + MONO_ASSEMBLYOS_PLATFORM, + MONO_ASSEMBLYOS_MAJOR_VERSION, + MONO_ASSEMBLYOS_MINOR_VERSION, + MONO_ASSEMBLYOS_SIZE +}; + +enum { + MONO_ASSEMBLY_PROCESSOR, + MONO_ASSEMBLY_PROCESSOR_SIZE +}; + +enum { + MONO_ASSEMBLYREF_MAJOR_VERSION, + MONO_ASSEMBLYREF_MINOR_VERSION, + MONO_ASSEMBLYREF_BUILD_NUMBER, + MONO_ASSEMBLYREF_REV_NUMBER, + MONO_ASSEMBLYREF_FLAGS, + MONO_ASSEMBLYREF_PUBLIC_KEY, + MONO_ASSEMBLYREF_NAME, + MONO_ASSEMBLYREF_CULTURE, + MONO_ASSEMBLYREF_HASH_VALUE, + MONO_ASSEMBLYREF_SIZE +}; + +enum { + MONO_ASSEMBLYREFOS_PLATFORM, + MONO_ASSEMBLYREFOS_MAJOR_VERSION, + MONO_ASSEMBLYREFOS_MINOR_VERSION, + MONO_ASSEMBLYREFOS_ASSEMBLYREF, + MONO_ASSEMBLYREFOS_SIZE +}; + +enum { + MONO_ASSEMBLYREFPROC_PROCESSOR, + MONO_ASSEMBLYREFPROC_ASSEMBLYREF, + MONO_ASSEMBLYREFPROC_SIZE +}; + +enum { + MONO_CLASS_LAYOUT_PACKING_SIZE, + MONO_CLASS_LAYOUT_CLASS_SIZE, + MONO_CLASS_LAYOUT_PARENT, + MONO_CLASS_LAYOUT_SIZE +}; + +enum { + MONO_CONSTANT_TYPE, + MONO_CONSTANT_PADDING, + MONO_CONSTANT_PARENT, + MONO_CONSTANT_VALUE, + MONO_CONSTANT_SIZE +}; + +enum { + MONO_CUSTOM_ATTR_PARENT, + MONO_CUSTOM_ATTR_TYPE, + MONO_CUSTOM_ATTR_VALUE, + MONO_CUSTOM_ATTR_SIZE +}; + +enum { + MONO_DECL_SECURITY_ACTION, + MONO_DECL_SECURITY_PARENT, + MONO_DECL_SECURITY_PERMISSIONSET, + MONO_DECL_SECURITY_SIZE +}; + +enum { + MONO_EVENT_MAP_PARENT, + MONO_EVENT_MAP_EVENTLIST, + MONO_EVENT_MAP_SIZE +}; + +enum { + MONO_EVENT_FLAGS, + MONO_EVENT_NAME, + MONO_EVENT_TYPE, + MONO_EVENT_SIZE +}; + +enum { + MONO_EVENT_POINTER_EVENT, + MONO_EVENT_POINTER_SIZE +}; + +enum { + MONO_EXP_TYPE_FLAGS, + MONO_EXP_TYPE_TYPEDEF, + MONO_EXP_TYPE_NAME, + MONO_EXP_TYPE_NAMESPACE, + MONO_EXP_TYPE_IMPLEMENTATION, + MONO_EXP_TYPE_SIZE +}; + +enum { + MONO_FIELD_FLAGS, + MONO_FIELD_NAME, + MONO_FIELD_SIGNATURE, + MONO_FIELD_SIZE +}; + +enum { + MONO_FIELD_LAYOUT_OFFSET, + MONO_FIELD_LAYOUT_FIELD, + MONO_FIELD_LAYOUT_SIZE +}; + +enum { + MONO_FIELD_MARSHAL_PARENT, + MONO_FIELD_MARSHAL_NATIVE_TYPE, + MONO_FIELD_MARSHAL_SIZE +}; + +enum { + MONO_FIELD_POINTER_FIELD, + MONO_FIELD_POINTER_SIZE +}; + +enum { + MONO_FIELD_RVA_RVA, + MONO_FIELD_RVA_FIELD, + MONO_FIELD_RVA_SIZE +}; + +enum { + MONO_ENCLOG_TOKEN, + MONO_ENCLOG_FUNC_CODE, + MONO_ENCLOG_SIZE +}; + +enum { + MONO_ENCMAP_TOKEN, + MONO_ENCMAP_SIZE +}; + +enum { + MONO_FILE_FLAGS, + MONO_FILE_NAME, + MONO_FILE_HASH_VALUE, + MONO_FILE_SIZE +}; + +enum { + MONO_IMPLMAP_FLAGS, + MONO_IMPLMAP_MEMBER, + MONO_IMPLMAP_NAME, + MONO_IMPLMAP_SCOPE, + MONO_IMPLMAP_SIZE +}; + +enum { + MONO_INTERFACEIMPL_CLASS, + MONO_INTERFACEIMPL_INTERFACE, + MONO_INTERFACEIMPL_SIZE +}; + +enum { + MONO_MANIFEST_OFFSET, + MONO_MANIFEST_FLAGS, + MONO_MANIFEST_NAME, + MONO_MANIFEST_IMPLEMENTATION, + MONO_MANIFEST_SIZE +}; + +enum { + MONO_MEMBERREF_CLASS, + MONO_MEMBERREF_NAME, + MONO_MEMBERREF_SIGNATURE, + MONO_MEMBERREF_SIZE +}; + +enum { + MONO_METHOD_RVA, + MONO_METHOD_IMPLFLAGS, + MONO_METHOD_FLAGS, + MONO_METHOD_NAME, + MONO_METHOD_SIGNATURE, + MONO_METHOD_PARAMLIST, + MONO_METHOD_SIZE +}; + +enum { + MONO_METHODIMPL_CLASS, + MONO_METHODIMPL_BODY, + MONO_METHODIMPL_DECLARATION, + MONO_METHODIMPL_SIZE +}; + +enum { + MONO_METHOD_POINTER_METHOD, + MONO_METHOD_POINTER_SIZE +}; + +enum { + MONO_METHOD_SEMA_SEMANTICS, + MONO_METHOD_SEMA_METHOD, + MONO_METHOD_SEMA_ASSOCIATION, + MONO_METHOD_SEMA_SIZE +}; + +enum { + MONO_MODULE_GENERATION, + MONO_MODULE_NAME, + MONO_MODULE_MVID, + MONO_MODULE_ENC, + MONO_MODULE_ENCBASE, + MONO_MODULE_SIZE +}; + +enum { + MONO_MODULEREF_NAME, + MONO_MODULEREF_SIZE +}; + +enum { + MONO_NESTED_CLASS_NESTED, + MONO_NESTED_CLASS_ENCLOSING, + MONO_NESTED_CLASS_SIZE +}; + +enum { + MONO_PARAM_FLAGS, + MONO_PARAM_SEQUENCE, + MONO_PARAM_NAME, + MONO_PARAM_SIZE +}; + +enum { + MONO_PARAM_POINTER_PARAM, + MONO_PARAM_POINTER_SIZE +}; + +enum { + MONO_PROPERTY_FLAGS, + MONO_PROPERTY_NAME, + MONO_PROPERTY_TYPE, + MONO_PROPERTY_SIZE +}; + +enum { + MONO_PROPERTY_POINTER_PROPERTY, + MONO_PROPERTY_POINTER_SIZE +}; + +enum { + MONO_PROPERTY_MAP_PARENT, + MONO_PROPERTY_MAP_PROPERTY_LIST, + MONO_PROPERTY_MAP_SIZE +}; + +enum { + MONO_STAND_ALONE_SIGNATURE, + MONO_STAND_ALONE_SIGNATURE_SIZE +}; + +enum { + MONO_TYPEDEF_FLAGS, + MONO_TYPEDEF_NAME, + MONO_TYPEDEF_NAMESPACE, + MONO_TYPEDEF_EXTENDS, + MONO_TYPEDEF_FIELD_LIST, + MONO_TYPEDEF_METHOD_LIST, + MONO_TYPEDEF_SIZE +}; + +enum { + MONO_TYPEREF_SCOPE, + MONO_TYPEREF_NAME, + MONO_TYPEREF_NAMESPACE, + MONO_TYPEREF_SIZE +}; + +enum { + MONO_TYPESPEC_SIGNATURE, + MONO_TYPESPEC_SIZE +}; + +enum { + MONO_GENERICPARAM_NUMBER, + MONO_GENERICPARAM_FLAGS, + MONO_GENERICPARAM_OWNER, + MONO_GENERICPARAM_NAME, + + MONO_GENERICPARAM_SIZE +}; + +enum { + MONO_METHODSPEC_METHOD, + MONO_METHODSPEC_SIGNATURE, + MONO_METHODSPEC_SIZE +}; + +enum { + MONO_GENPARCONSTRAINT_GENERICPAR, + MONO_GENPARCONSTRAINT_CONSTRAINT, + MONO_GENPARCONSTRAINT_SIZE +}; + +enum { + MONO_DOCUMENT_NAME, + MONO_DOCUMENT_HASHALG, + MONO_DOCUMENT_HASH, + MONO_DOCUMENT_LANGUAGE, + MONO_DOCUMENT_SIZE +}; + +enum { + MONO_METHODBODY_DOCUMENT, + MONO_METHODBODY_SEQ_POINTS, + MONO_METHODBODY_SIZE +}; + +enum { + MONO_LOCALSCOPE_METHOD, + MONO_LOCALSCOPE_IMPORTSCOPE, + MONO_LOCALSCOPE_VARIABLELIST, + MONO_LOCALSCOPE_CONSTANTLIST, + MONO_LOCALSCOPE_STARTOFFSET, + MONO_LOCALSCOPE_LENGTH, + MONO_LOCALSCOPE_SIZE +}; + +enum { + MONO_LOCALVARIABLE_ATTRIBUTES, + MONO_LOCALVARIABLE_INDEX, + MONO_LOCALVARIABLE_NAME, + MONO_LOCALVARIABLE_SIZE +}; + +enum { + MONO_CUSTOMDEBUGINFORMATION_PARENT, + MONO_CUSTOMDEBUGINFORMATION_KIND, + MONO_CUSTOMDEBUGINFORMATION_VALUE, + MONO_CUSTOMDEBUGINFORMATION_SIZE +}; + +/* + * Coded Tokens + * The _BITS entry is for the bits used in the token. + * The _MASK entry is for mask the index out. + */ + +enum { + MONO_TYPEDEFORREF_TYPEDEF, + MONO_TYPEDEFORREF_TYPEREF, + MONO_TYPEDEFORREF_TYPESPEC, + MONO_TYPEDEFORREF_BITS = 2, + MONO_TYPEDEFORREF_MASK = 3 +}; + +enum { + MONO_HASCONSTANT_FIEDDEF, + MONO_HASCONSTANT_PARAM, + MONO_HASCONSTANT_PROPERTY, + MONO_HASCONSTANT_BITS = 2, + MONO_HASCONSTANT_MASK = 3 +}; + +enum { + MONO_CUSTOM_ATTR_METHODDEF, + MONO_CUSTOM_ATTR_FIELDDEF, + MONO_CUSTOM_ATTR_TYPEREF, + MONO_CUSTOM_ATTR_TYPEDEF, + MONO_CUSTOM_ATTR_PARAMDEF, + MONO_CUSTOM_ATTR_INTERFACE, + MONO_CUSTOM_ATTR_MEMBERREF, + MONO_CUSTOM_ATTR_MODULE, + MONO_CUSTOM_ATTR_PERMISSION, + MONO_CUSTOM_ATTR_PROPERTY, + MONO_CUSTOM_ATTR_EVENT, + MONO_CUSTOM_ATTR_SIGNATURE, + MONO_CUSTOM_ATTR_MODULEREF, + MONO_CUSTOM_ATTR_TYPESPEC, + MONO_CUSTOM_ATTR_ASSEMBLY, + MONO_CUSTOM_ATTR_ASSEMBLYREF, + MONO_CUSTOM_ATTR_FILE, + MONO_CUSTOM_ATTR_EXP_TYPE, + MONO_CUSTOM_ATTR_MANIFEST, + MONO_CUSTOM_ATTR_GENERICPAR, + MONO_CUSTOM_ATTR_GENERICPARAMCONSTRAINT, + MONO_CUSTOM_ATTR_BITS = 5, + MONO_CUSTOM_ATTR_MASK = 0x1F +}; + +enum { + MONO_HAS_FIELD_MARSHAL_FIELDSREF, + MONO_HAS_FIELD_MARSHAL_PARAMDEF, + MONO_HAS_FIELD_MARSHAL_BITS = 1, + MONO_HAS_FIELD_MARSHAL_MASK = 1 +}; + +enum { + MONO_HAS_DECL_SECURITY_TYPEDEF, + MONO_HAS_DECL_SECURITY_METHODDEF, + MONO_HAS_DECL_SECURITY_ASSEMBLY, + MONO_HAS_DECL_SECURITY_BITS = 2, + MONO_HAS_DECL_SECURITY_MASK = 3 +}; + +enum { + MONO_MEMBERREF_PARENT_TYPEDEF, /* not used */ + MONO_MEMBERREF_PARENT_TYPEREF, + MONO_MEMBERREF_PARENT_MODULEREF, + MONO_MEMBERREF_PARENT_METHODDEF, + MONO_MEMBERREF_PARENT_TYPESPEC, + MONO_MEMBERREF_PARENT_BITS = 3, + MONO_MEMBERREF_PARENT_MASK = 7 +}; + +enum { + MONO_HAS_SEMANTICS_EVENT, + MONO_HAS_SEMANTICS_PROPERTY, + MONO_HAS_SEMANTICS_BITS = 1, + MONO_HAS_SEMANTICS_MASK = 1 +}; + +enum { + MONO_METHODDEFORREF_METHODDEF, + MONO_METHODDEFORREF_METHODREF, + MONO_METHODDEFORREF_BITS = 1, + MONO_METHODDEFORREF_MASK = 1 +}; + +enum { + MONO_MEMBERFORWD_FIELDDEF, + MONO_MEMBERFORWD_METHODDEF, + MONO_MEMBERFORWD_BITS = 1, + MONO_MEMBERFORWD_MASK = 1 +}; + +enum { + MONO_IMPLEMENTATION_FILE, + MONO_IMPLEMENTATION_ASSEMBLYREF, + MONO_IMPLEMENTATION_EXP_TYPE, + MONO_IMPLEMENTATION_BITS = 2, + MONO_IMPLEMENTATION_MASK = 3 +}; + +enum { + MONO_CUSTOM_ATTR_TYPE_TYPEREF, /* not used */ + MONO_CUSTOM_ATTR_TYPE_TYPEDEF, /* not used */ + MONO_CUSTOM_ATTR_TYPE_METHODDEF, + MONO_CUSTOM_ATTR_TYPE_MEMBERREF, + MONO_CUSTOM_ATTR_TYPE_STRING, /* not used */ + MONO_CUSTOM_ATTR_TYPE_BITS = 3, + MONO_CUSTOM_ATTR_TYPE_MASK = 7 +}; + +enum { + MONO_RESOLUTION_SCOPE_MODULE, + MONO_RESOLUTION_SCOPE_MODULEREF, + MONO_RESOLUTION_SCOPE_ASSEMBLYREF, + MONO_RESOLUTION_SCOPE_TYPEREF, + MONO_RESOLUTION_SCOPE_BITS = 2, + MONO_RESOLUTION_SCOPE_MASK = 3 +}; + +/* Kept for compatibility since this is a public header file */ +enum { + MONO_RESOLTION_SCOPE_MODULE, + MONO_RESOLTION_SCOPE_MODULEREF, + MONO_RESOLTION_SCOPE_ASSEMBLYREF, + MONO_RESOLTION_SCOPE_TYPEREF, + MONO_RESOLTION_SCOPE_BITS = 2, + MONO_RESOLTION_SCOPE_MASK = 3 +}; + +enum { + MONO_TYPEORMETHOD_TYPE, + MONO_TYPEORMETHOD_METHOD, + MONO_TYPEORMETHOD_BITS = 1, + MONO_TYPEORMETHOD_MASK = 1 +}; + +#endif /* __MONO_METADATA_ROW_INDEXES_H__ */ + + diff --git a/src/mono/msvc/include/mono/metadata/sgen-bridge.h b/src/mono/msvc/include/mono/metadata/sgen-bridge.h new file mode 100644 index 0000000000000..c131f3066914e --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/sgen-bridge.h @@ -0,0 +1,110 @@ +/** + * \file + * Copyright 2011 Novell, Inc. + * + * Licensed under the MIT license. See LICENSE file in the project root for full license information. + */ + +/* + * The bridge is a mechanism for SGen to let clients override the death of some + * unreachable objects. We use it in monodroid to do garbage collection across + * the Mono and Java heaps. + * + * The client (Monodroid) can designate some objects as "bridged", which means + * that they participate in the bridge processing step once SGen considers them + * unreachable, i.e., dead. Bridged objects must be registered for + * finalization. + * + * When SGen is done marking, it puts together a list of all dead bridged + * objects. This is passed to the bridge processor, which does an analysis to + * simplify the graph: It replaces strongly-connected components with single + * nodes, and may remove nodes corresponding to components which do not contain + * bridged objects. + * + * The output of the SCC analysis is passed to the client's `cross_references()` + * callback. This consists of 2 arrays, an array of SCCs (MonoGCBridgeSCC), + * and an array of "xrefs" (edges between SCCs, MonoGCBridgeXRef). Edges are + * encoded as pairs of "API indices", ie indexes in the SCC array. The client + * is expected to set the `is_alive` flag on those strongly connected components + * that it wishes to be kept alive. + * + * In monodroid each bridged object has a corresponding Java mirror object. In + * the bridge callback it reifies the Mono object graph in the Java heap so that + * the full, combined object graph is now instantiated on the Java side. Then + * it triggers a Java GC, waits for it to finish, and checks which of the Java + * mirror objects are still alive. For those it sets the `is_alive` flag and + * returns from the callback. + * + * The SCC analysis is done while the world is stopped, but the callback is made + * with the world running again. Weak links to bridged objects and other + * objects reachable from them are kept until the callback returns, at which + * point all links to bridged objects that don't have `is_alive` set are nulled. + * Note that weak links to non-bridged objects reachable from bridged objects + * are not nulled. This might be considered a bug. + * + * There are three different implementations of the bridge processor, each of + * which implements 8 callbacks (see SgenBridgeProcessor). The implementations + * differ in the algorithm they use to compute the "simplified" SCC graph. + */ + +#ifndef _MONO_SGEN_BRIDGE_H_ +#define _MONO_SGEN_BRIDGE_H_ + +#include + +MONO_BEGIN_DECLS + +enum { + SGEN_BRIDGE_VERSION = 5 +}; + +typedef enum { + /* Instances of this class should be scanned when computing the transitive dependency among bridges. E.g. List*/ + GC_BRIDGE_TRANSPARENT_CLASS, + /* Instances of this class should not be scanned when computing the transitive dependency among bridges. E.g. String*/ + GC_BRIDGE_OPAQUE_CLASS, + /* Instances of this class should be bridged and have their dependency computed. */ + GC_BRIDGE_TRANSPARENT_BRIDGE_CLASS, + /* Instances of this class should be bridged but no dependencies should not be calculated. */ + GC_BRIDGE_OPAQUE_BRIDGE_CLASS, +} MonoGCBridgeObjectKind; + +typedef struct { + mono_bool is_alive; /* to be set by the cross reference callback */ + int num_objs; + MonoObject *objs [MONO_ZERO_LEN_ARRAY]; +} MonoGCBridgeSCC; + +typedef struct { + int src_scc_index; + int dst_scc_index; +} MonoGCBridgeXRef; + +typedef struct { + int bridge_version; + /* + * Tells the runtime which classes to even consider when looking for + * bridged objects. If subclasses are to be considered as well, the + * subclass check must be done in the callback. + */ + MonoGCBridgeObjectKind (*bridge_class_kind) (MonoClass *klass); + /* + * This is only called on objects for whose classes + * `bridge_class_kind()` returned `XXX_BRIDGE_CLASS`. + */ + mono_bool (*is_bridge_object) (MonoObject *object); + void (*cross_references) (int num_sccs, MonoGCBridgeSCC **sccs, int num_xrefs, MonoGCBridgeXRef *xrefs); +} MonoGCBridgeCallbacks; + +/* + * Note: This may be called at any time, but cannot be called concurrently + * with (during and on a separate thread from) sgen init. Callers are + * responsible for enforcing this. + */ +MONO_API void mono_gc_register_bridge_callbacks (MonoGCBridgeCallbacks *callbacks); + +MONO_API void mono_gc_wait_for_bridge_processing (void); + +MONO_END_DECLS + +#endif diff --git a/src/mono/msvc/include/mono/metadata/threads.h b/src/mono/msvc/include/mono/metadata/threads.h new file mode 100644 index 0000000000000..89be80f5a024b --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/threads.h @@ -0,0 +1,69 @@ +/** + * \file + * Threading API + * + * Author: + * Dick Porter (dick@ximian.com) + * Patrik Torstensson (patrik.torstensson@labs2.com) + * + * (C) 2001 Ximian, Inc + */ + +#ifndef _MONO_METADATA_THREADS_H_ +#define _MONO_METADATA_THREADS_H_ + +#include +#include +#include + +MONO_BEGIN_DECLS + +/* This callback should return TRUE if the runtime must wait for the thread, FALSE otherwise */ +typedef mono_bool (*MonoThreadManageCallback) (MonoThread* thread); + +MONO_API void mono_thread_init (MonoThreadStartCB start_cb, + MonoThreadAttachCB attach_cb); +MONO_API void mono_thread_cleanup (void); +MONO_API MONO_RT_EXTERNAL_ONLY +void mono_thread_manage(void); + +MONO_API MonoThread *mono_thread_current (void); + +MONO_API void mono_thread_set_main (MonoThread *thread); +MONO_API MonoThread *mono_thread_get_main (void); + +MONO_API MONO_RT_EXTERNAL_ONLY void mono_thread_stop (MonoThread *thread); + +MONO_API void mono_thread_new_init (intptr_t tid, void* stack_start, + void* func); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_thread_create (MonoDomain *domain, void* func, void* arg); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoThread * +mono_thread_attach (MonoDomain *domain); +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_thread_detach (MonoThread *thread); +MONO_API void mono_thread_exit (void); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_threads_attach_tools_thread (void); + +MONO_API char *mono_thread_get_name_utf8 (MonoThread *thread); +MONO_API int32_t mono_thread_get_managed_id (MonoThread *thread); + +MONO_API void mono_thread_set_manage_callback (MonoThread *thread, MonoThreadManageCallback func); + +MONO_API void mono_threads_set_default_stacksize (uint32_t stacksize); +MONO_API uint32_t mono_threads_get_default_stacksize (void); + +MONO_API void mono_threads_request_thread_dump (void); + +MONO_API mono_bool mono_thread_is_foreign (MonoThread *thread); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_thread_detach_if_exiting (void); + +MONO_END_DECLS + +#endif /* _MONO_METADATA_THREADS_H_ */ diff --git a/src/mono/msvc/include/mono/metadata/tokentype.h b/src/mono/msvc/include/mono/metadata/tokentype.h new file mode 100644 index 0000000000000..a1c58944d7404 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/tokentype.h @@ -0,0 +1,45 @@ +/** + * \file + */ + +#ifndef _MONO_METADATA_TOKENTYPE_H_ +#define _MONO_METADATA_TOKENTYPE_H_ + +/* + * These tokens match the table ID except for the last + * three (string, name and base type which are special) + */ + +typedef enum { + MONO_TOKEN_MODULE = 0x00000000, + MONO_TOKEN_TYPE_REF = 0x01000000, + MONO_TOKEN_TYPE_DEF = 0x02000000, + MONO_TOKEN_FIELD_DEF = 0x04000000, + MONO_TOKEN_METHOD_DEF = 0x06000000, + MONO_TOKEN_PARAM_DEF = 0x08000000, + MONO_TOKEN_INTERFACE_IMPL = 0x09000000, + MONO_TOKEN_MEMBER_REF = 0x0a000000, + MONO_TOKEN_CUSTOM_ATTRIBUTE = 0x0c000000, + MONO_TOKEN_PERMISSION = 0x0e000000, + MONO_TOKEN_SIGNATURE = 0x11000000, + MONO_TOKEN_EVENT = 0x14000000, + MONO_TOKEN_PROPERTY = 0x17000000, + MONO_TOKEN_MODULE_REF = 0x1a000000, + MONO_TOKEN_TYPE_SPEC = 0x1b000000, + MONO_TOKEN_ASSEMBLY = 0x20000000, + MONO_TOKEN_ASSEMBLY_REF = 0x23000000, + MONO_TOKEN_FILE = 0x26000000, + MONO_TOKEN_EXPORTED_TYPE = 0x27000000, + MONO_TOKEN_MANIFEST_RESOURCE = 0x28000000, + MONO_TOKEN_GENERIC_PARAM = 0x2a000000, + MONO_TOKEN_METHOD_SPEC = 0x2b000000, + + /* + * These do not match metadata tables directly + */ + MONO_TOKEN_STRING = 0x70000000, + MONO_TOKEN_NAME = 0x71000000, + MONO_TOKEN_BASE_TYPE = 0x72000000 +} MonoTokenType; + +#endif /* _MONO_METADATA_TOKENTYPE_H_ */ diff --git a/src/mono/msvc/include/mono/metadata/verify.h b/src/mono/msvc/include/mono/metadata/verify.h new file mode 100644 index 0000000000000..162ef4434e682 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/verify.h @@ -0,0 +1,66 @@ +/** + * \file + */ + +#ifndef __MONO_METADATA_VERIFY_H__ +#define __MONO_METADATA_VERIFY_H__ + +#include +#include +#include +#include /* GSList dep */ + +MONO_BEGIN_DECLS + +typedef enum { + MONO_VERIFY_OK, + MONO_VERIFY_ERROR, + MONO_VERIFY_WARNING, + MONO_VERIFY_CLS = 4, + MONO_VERIFY_ALL = 7, + + /* Status signaling code that is not verifiable.*/ + MONO_VERIFY_NOT_VERIFIABLE = 8, + + /*OR it with other flags*/ + + /* Abort the verification if the code is not verifiable. + * The standard behavior is to abort if the code is not valid. + * */ + MONO_VERIFY_FAIL_FAST = 16, + + + /* Perform less verification of the code. This flag should be used + * if one wants the verifier to be more compatible to the MS runtime. + * Mind that this is not to be more compatible with MS peverify, but + * with the runtime itself, that has a less strict verifier. + */ + MONO_VERIFY_NON_STRICT = 32, + + /*Skip all visibility related checks*/ + MONO_VERIFY_SKIP_VISIBILITY = 64, + + /*Skip all visibility related checks*/ + MONO_VERIFY_REPORT_ALL_ERRORS = 128 + +} MonoVerifyStatus; + +typedef struct { + char *message; + MonoVerifyStatus status; +} MonoVerifyInfo; + +typedef struct { + MonoVerifyInfo info; + int8_t exception_type; /*should be one of MONO_EXCEPTION_* */ +} MonoVerifyInfoExtended; + + +MONO_API GSList* mono_method_verify (MonoMethod *method, int level); +MONO_API void mono_free_verify_list (GSList *list); +MONO_API char* mono_verify_corlib (void); + +MONO_END_DECLS + +#endif /* __MONO_METADATA_VERIFY_H__ */ + diff --git a/src/mono/msvc/include/mono/utils/mono-counters.h b/src/mono/msvc/include/mono/utils/mono-counters.h new file mode 100644 index 0000000000000..77175b35f49a8 --- /dev/null +++ b/src/mono/msvc/include/mono/utils/mono-counters.h @@ -0,0 +1,105 @@ +/** + * \file + */ + +#ifndef __MONO_COUNTERS_H__ +#define __MONO_COUNTERS_H__ + +#include +#include + +enum { + /* Counter type, bits 0-7. */ + MONO_COUNTER_INT, /* 32 bit int */ + MONO_COUNTER_UINT, /* 32 bit uint */ + MONO_COUNTER_WORD, /* pointer-sized int */ + MONO_COUNTER_LONG, /* 64 bit int */ + MONO_COUNTER_ULONG, /* 64 bit uint */ + MONO_COUNTER_DOUBLE, + MONO_COUNTER_STRING, /* char* */ + MONO_COUNTER_TIME_INTERVAL, /* 64 bits signed int holding usecs. */ + MONO_COUNTER_TYPE_MASK = 0xf, + MONO_COUNTER_CALLBACK = 128, /* ORed with the other values */ + MONO_COUNTER_SECTION_MASK = 0x00ffff00, + /* Sections, bits 8-23 (16 bits) */ + MONO_COUNTER_JIT = 1 << 8, + MONO_COUNTER_GC = 1 << 9, + MONO_COUNTER_METADATA = 1 << 10, + MONO_COUNTER_GENERICS = 1 << 11, + MONO_COUNTER_SECURITY = 1 << 12, + MONO_COUNTER_RUNTIME = 1 << 13, + MONO_COUNTER_SYSTEM = 1 << 14, + MONO_COUNTER_PERFCOUNTERS = 1 << 15, + MONO_COUNTER_PROFILER = 1 << 16, + MONO_COUNTER_INTERP = 1 << 17, + MONO_COUNTER_TIERED = 1 << 18, + MONO_COUNTER_LAST_SECTION, + + /* Unit, bits 24-27 (4 bits) */ + MONO_COUNTER_UNIT_SHIFT = 24, + MONO_COUNTER_UNIT_MASK = 0xFu << MONO_COUNTER_UNIT_SHIFT, + MONO_COUNTER_RAW = 0 << 24, /* Raw value */ + MONO_COUNTER_BYTES = 1 << 24, /* Quantity of bytes. RSS, active heap, etc */ + MONO_COUNTER_TIME = 2 << 24, /* Time interval in 100ns units. Minor pause, JIT compilation*/ + MONO_COUNTER_COUNT = 3 << 24, /* Number of things (threads, queued jobs) or Number of events triggered (Major collections, Compiled methods).*/ + MONO_COUNTER_PERCENTAGE = 4 << 24, /* [0-1] Fraction Percentage of something. Load average. */ + + /* Monotonicity, bits 28-31 (4 bits) */ + MONO_COUNTER_VARIANCE_SHIFT = 28, + MONO_COUNTER_VARIANCE_MASK = 0xFu << MONO_COUNTER_VARIANCE_SHIFT, + MONO_COUNTER_MONOTONIC = 1 << 28, /* This counter value always increase/decreases over time. Reported by --stat. */ + MONO_COUNTER_CONSTANT = 1 << 29, /* Fixed value. Used by configuration data. */ + MONO_COUNTER_VARIABLE = 1 << 30, /* This counter value can be anything on each sampling. Only interesting when sampling. */ +}; + +typedef struct _MonoCounter MonoCounter; + +MONO_API void mono_counters_enable (int section_mask); +MONO_API void mono_counters_init (void); + +/* + * register addr as the address of a counter of type type. + * It may be a function pointer if MONO_COUNTER_CALLBACK is specified: + * the function should return the value and take no arguments. + */ +MONO_API void mono_counters_register (const char* descr, int type, void *addr); +MONO_API void mono_counters_register_with_size (const char *name, int type, void *addr, int size); + +typedef void (*MonoCounterRegisterCallback) (MonoCounter*); +MONO_API void mono_counters_on_register (MonoCounterRegisterCallback callback); + +/* + * Create a readable dump of the counters for section_mask sections (ORed section values) + */ +MONO_API void mono_counters_dump (int section_mask, FILE *outfile); + +MONO_API void mono_counters_cleanup (void); + +typedef mono_bool (*CountersEnumCallback) (MonoCounter *counter, void *user_data); + +MONO_API void mono_counters_foreach (CountersEnumCallback cb, void *user_data); + +MONO_API int mono_counters_sample (MonoCounter *counter, void *buffer, int buffer_size); + +MONO_API const char* mono_counter_get_name (MonoCounter *name); +MONO_API int mono_counter_get_type (MonoCounter *counter); +MONO_API int mono_counter_get_section (MonoCounter *counter); +MONO_API int mono_counter_get_unit (MonoCounter *counter); +MONO_API int mono_counter_get_variance (MonoCounter *counter); +MONO_API size_t mono_counter_get_size (MonoCounter *counter); + +typedef enum { + MONO_RESOURCE_JIT_CODE, /* bytes */ + MONO_RESOURCE_METADATA, /* bytes */ + MONO_RESOURCE_GC_HEAP, /* bytes */ + MONO_RESOURCE_COUNT /* non-ABI value */ +} MonoResourceType; + +typedef void (*MonoResourceCallback) (int resource_type, uintptr_t value, int is_soft); + +MONO_API int mono_runtime_resource_limit (int resource_type, uintptr_t soft_limit, uintptr_t hard_limit); +MONO_API void mono_runtime_resource_set_callback (MonoResourceCallback callback); +MONO_API void mono_runtime_resource_check_limit (int resource_type, uintptr_t value); + +#endif /* __MONO_COUNTERS_H__ */ + diff --git a/src/mono/msvc/include/mono/utils/mono-dl-fallback.h b/src/mono/msvc/include/mono/utils/mono-dl-fallback.h new file mode 100644 index 0000000000000..11ec4f30b8ac0 --- /dev/null +++ b/src/mono/msvc/include/mono/utils/mono-dl-fallback.h @@ -0,0 +1,43 @@ +/** + * \file + */ + +#ifndef __MONO_UTILS_DL_FALLBACK_H__ +#define __MONO_UTILS_DL_FALLBACK_H__ + +#include + +MONO_BEGIN_DECLS + +enum { + MONO_DL_EAGER = 0, + MONO_DL_LAZY = 1, + // If MONO_DL_LOCAL is set, it will trump MONO_DL_GLOBAL. + MONO_DL_LOCAL = 2, + // MONO_DL_MASK is unused internally and no longer a full mask on netcore, given the introduction of MONO_DL_GLOBAL. Avoid. + MONO_DL_MASK = 3, + // Only applicable when building Mono in netcore mode. + MONO_DL_GLOBAL = 4 +}; + +/* + * This is the dynamic loader fallback API + */ +typedef struct MonoDlFallbackHandler MonoDlFallbackHandler; + +/* + * The "err" variable contents must be allocated using g_malloc or g_strdup + */ +typedef void* (*MonoDlFallbackLoad) (const char *name, int flags, char **err, void *user_data); +typedef void* (*MonoDlFallbackSymbol) (void *handle, const char *name, char **err, void *user_data); +typedef void* (*MonoDlFallbackClose) (void *handle, void *user_data); + +MONO_API MonoDlFallbackHandler *mono_dl_fallback_register (MonoDlFallbackLoad load_func, MonoDlFallbackSymbol symbol_func, + MonoDlFallbackClose close_func, void *user_data); + +MONO_API void mono_dl_fallback_unregister (MonoDlFallbackHandler *handler); + +MONO_END_DECLS + +#endif /* __MONO_UTILS_DL_FALLBACK_H__ */ + diff --git a/src/mono/msvc/include/mono/utils/mono-error.h b/src/mono/msvc/include/mono/utils/mono-error.h new file mode 100644 index 0000000000000..69bfb8a47346f --- /dev/null +++ b/src/mono/msvc/include/mono/utils/mono-error.h @@ -0,0 +1,105 @@ +/** + * \file + */ + +#ifndef __MONO_ERROR_H__ +#define __MONO_ERROR_H__ + +#include + +enum { + /* + The supplied strings were dup'd by means of calling mono_error_dup_strings. + */ + MONO_ERROR_FREE_STRINGS = 0x0001, + + /* + Something happened while processing the error and the resulting message is incomplete. + */ + MONO_ERROR_INCOMPLETE = 0x0002, + /* + This MonoError is heap allocated in a mempool + */ + MONO_ERROR_MEMPOOL_BOXED = 0x0004 +}; + +enum { + MONO_ERROR_NONE = 0, + MONO_ERROR_MISSING_METHOD = 1, + MONO_ERROR_MISSING_FIELD = 2, + MONO_ERROR_TYPE_LOAD = 3, + MONO_ERROR_FILE_NOT_FOUND = 4, + MONO_ERROR_BAD_IMAGE = 5, + MONO_ERROR_OUT_OF_MEMORY = 6, + MONO_ERROR_ARGUMENT = 7, + MONO_ERROR_ARGUMENT_NULL = 11, + MONO_ERROR_ARGUMENT_OUT_OF_RANGE = 14, + MONO_ERROR_NOT_VERIFIABLE = 8, + MONO_ERROR_INVALID_PROGRAM = 12, + MONO_ERROR_MEMBER_ACCESS = 13, + + /* + * This is a generic error mechanism is you need to raise an arbitrary corlib exception. + * You must pass the exception name otherwise prepare_exception will fail with internal execution. + */ + MONO_ERROR_GENERIC = 9, + /* This one encapsulates a managed exception instance */ + MONO_ERROR_EXCEPTION_INSTANCE = 10, + + /* Not a valid error code - indicates that the error was cleaned up and reused */ + MONO_ERROR_CLEANUP_CALLED_SENTINEL = 0xffff +}; + +#ifdef _MSC_VER +__pragma(warning (push)) +__pragma(warning (disable:4201)) +#endif + +/*Keep in sync with MonoErrorInternal*/ +typedef union _MonoError { + // Merge two uint16 into one uint32 so it can be initialized + // with one instruction instead of two. + uint32_t init; + struct { + uint16_t error_code; + uint16_t private_flags; /*DON'T TOUCH */ + void *hidden_1 [12]; /*DON'T TOUCH */ + }; +} MonoErrorExternal; + +#ifdef _MSC_VER +__pragma(warning (pop)) +#endif + +#ifdef MONO_INSIDE_RUNTIME +typedef union _MonoErrorInternal MonoError; +#else +typedef MonoErrorExternal MonoError; +#endif + +/* Mempool-allocated MonoError.*/ +typedef struct _MonoErrorBoxed MonoErrorBoxed; + +MONO_BEGIN_DECLS + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_error_init (MonoError *error); + +MONO_API void +mono_error_init_flags (MonoError *error, unsigned short flags); + +MONO_API void +mono_error_cleanup (MonoError *error); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_error_ok (MonoError *error); + +MONO_API unsigned short +mono_error_get_error_code (MonoError *error); + +MONO_API const char* +mono_error_get_message (MonoError *error); + +MONO_END_DECLS + +#endif diff --git a/src/mono/msvc/include/mono/utils/mono-forward.h b/src/mono/msvc/include/mono/utils/mono-forward.h new file mode 100644 index 0000000000000..784f6e080921a --- /dev/null +++ b/src/mono/msvc/include/mono/utils/mono-forward.h @@ -0,0 +1,15 @@ +/** + * \file + * + * (C) 2018 Microsoft, Inc. + * + */ +#ifndef _MONO_UTILS_FORWARD_ +#define _MONO_UTILS_FORWARD_ + +typedef struct _MonoDomain MonoDomain; +typedef struct _MonoJitInfo MonoJitInfo; + +typedef void * MonoGCHandle; + +#endif diff --git a/src/mono/msvc/include/mono/utils/mono-jemalloc.h b/src/mono/msvc/include/mono/utils/mono-jemalloc.h new file mode 100644 index 0000000000000..6721877f51428 --- /dev/null +++ b/src/mono/msvc/include/mono/utils/mono-jemalloc.h @@ -0,0 +1,36 @@ +/** + * \file + * + * Header for jemalloc registration code + */ + +#ifndef __MONO_JEMALLOC_H__ +#define __MONO_JEMALLOC_H__ + +#if defined(MONO_JEMALLOC_ENABLED) + +#include + +/* Jemalloc can be configured in three ways. + * 1. You can use it with library loading hacks at run-time + * 2. You can use it as a global malloc replacement + * 3. You can use it with a prefix. If you use it with a prefix, you have to explicitly name the malloc function. + * + * In order to make this feature able to be toggled at run-time, I chose to use a prefix of mono_je. + * This mapping is captured below in the header, in the spirit of "no magic constants". + * + * The place that configures jemalloc and sets this prefix is in the Makefile in + * mono/jemalloc/Makefile.am + * + */ +#define MONO_JEMALLOC_MALLOC mono_jemalloc +#define MONO_JEMALLOC_REALLOC mono_jerealloc +#define MONO_JEMALLOC_FREE mono_jefree +#define MONO_JEMALLOC_CALLOC mono_jecalloc + +void mono_init_jemalloc (void); + +#endif + +#endif + diff --git a/src/mono/msvc/include/mono/utils/mono-logger.h b/src/mono/msvc/include/mono/utils/mono-logger.h new file mode 100644 index 0000000000000..a90e6c54cf365 --- /dev/null +++ b/src/mono/msvc/include/mono/utils/mono-logger.h @@ -0,0 +1,31 @@ +/** + * \file + */ + +#ifndef __MONO_LOGGER_H__ +#define __MONO_LOGGER_H__ + +#include +MONO_BEGIN_DECLS + +MONO_API void +mono_trace_set_level_string (const char *value); + +MONO_API void +mono_trace_set_mask_string (const char *value); + +typedef void (*MonoPrintCallback) (const char *string, mono_bool is_stdout); +typedef void (*MonoLogCallback) (const char *log_domain, const char *log_level, const char *message, mono_bool fatal, void *user_data); + +MONO_API void +mono_trace_set_log_handler (MonoLogCallback callback, void *user_data); + +MONO_API void +mono_trace_set_print_handler (MonoPrintCallback callback); + +MONO_API void +mono_trace_set_printerr_handler (MonoPrintCallback callback); + +MONO_END_DECLS + +#endif /* __MONO_LOGGER_H__ */ diff --git a/src/mono/msvc/include/mono/utils/mono-private-unstable.h b/src/mono/msvc/include/mono/utils/mono-private-unstable.h new file mode 100644 index 0000000000000..241a723447957 --- /dev/null +++ b/src/mono/msvc/include/mono/utils/mono-private-unstable.h @@ -0,0 +1,19 @@ +/** + * \file + * + * Private unstable APIs. + * + * WARNING: The declarations and behavior of functions in this header are NOT STABLE and can be modified or removed at + * any time. + * + */ + + +#ifndef __MONO_UTILS_MONO_PRIVATE_UNSTABLE_H__ +#define __MONO_UTILS_MONO_PRIVATE_UNSTABLE_H__ + +#include + + + +#endif /*__MONO_UTILS_MONO_PRIVATE_UNSTABLE_H__*/ diff --git a/src/mono/msvc/include/mono/utils/mono-publib.h b/src/mono/msvc/include/mono/utils/mono-publib.h new file mode 100644 index 0000000000000..b01438e52cf1c --- /dev/null +++ b/src/mono/msvc/include/mono/utils/mono-publib.h @@ -0,0 +1,187 @@ +/** + * \file + */ + +#ifndef __MONO_PUBLIB_H__ +#define __MONO_PUBLIB_H__ + +/* + * Minimal general purpose header for use in public mono header files. + * We can't include config.h, so we use compiler-specific preprocessor + * directives where needed. + */ + +#ifdef __cplusplus +#define MONO_BEGIN_DECLS extern "C" { +#define MONO_END_DECLS } +#else +#define MONO_BEGIN_DECLS /* nothing */ +#define MONO_END_DECLS /* nothing */ +#endif + +MONO_BEGIN_DECLS + +/* VS 2010 and later have stdint.h */ +#if defined(_MSC_VER) + +#if _MSC_VER < 1600 + +typedef __int8 int8_t; +typedef unsigned __int8 uint8_t; +typedef __int16 int16_t; +typedef unsigned __int16 uint16_t; +typedef __int32 int32_t; +typedef unsigned __int32 uint32_t; +typedef __int64 int64_t; +typedef unsigned __int64 uint64_t; + +#else + +#include + +#endif + +#define MONO_API_EXPORT __declspec(dllexport) +#define MONO_API_IMPORT __declspec(dllimport) + +#else + +#include + +#if defined (__clang__) || defined (__GNUC__) +#define MONO_API_EXPORT __attribute__ ((__visibility__ ("default"))) +#else +#define MONO_API_EXPORT +#endif +#define MONO_API_IMPORT + +#endif /* end of compiler-specific stuff */ + +#include + +#ifdef __cplusplus +#define MONO_EXTERN_C extern "C" +#else +#define MONO_EXTERN_C /* nothing */ +#endif + +#if defined(MONO_DLL_EXPORT) + #define MONO_API_NO_EXTERN_C MONO_API_EXPORT +#elif defined(MONO_DLL_IMPORT) + #define MONO_API_NO_EXTERN_C MONO_API_IMPORT +#else + #define MONO_API_NO_EXTERN_C /* nothing */ +#endif + +#define MONO_API MONO_EXTERN_C MONO_API_NO_EXTERN_C + +// Should (but not must) wrap in extern "C" (MONO_BEGIN_DECLS, MONO_END_DECLS). +#define MONO_API_DATA MONO_API_NO_EXTERN_C extern + +typedef int32_t mono_bool; +typedef uint8_t mono_byte; +typedef mono_byte MonoBoolean; +#ifdef _WIN32 +MONO_END_DECLS +#include +typedef wchar_t mono_unichar2; +MONO_BEGIN_DECLS +#else +typedef uint16_t mono_unichar2; +#endif +typedef uint32_t mono_unichar4; + +typedef void (*MonoFunc) (void* data, void* user_data); +typedef void (*MonoHFunc) (void* key, void* value, void* user_data); + +MONO_API void mono_free (void *); + +#define MONO_ALLOCATOR_VTABLE_VERSION 1 + +typedef struct { + int version; + void *(*malloc) (size_t size); + void *(*realloc) (void *mem, size_t count); + void (*free) (void *mem); + void *(*calloc) (size_t count, size_t size); +} MonoAllocatorVTable; + +MONO_API mono_bool +mono_set_allocator_vtable (MonoAllocatorVTable* vtable); + + +#define MONO_CONST_RETURN const + +/* + * When embedding, you have to define MONO_ZERO_LEN_ARRAY before including any + * other Mono header file if you use a different compiler from the one used to + * build Mono. + */ +#ifndef MONO_ZERO_LEN_ARRAY +#ifdef __GNUC__ +#define MONO_ZERO_LEN_ARRAY 0 +#else +#define MONO_ZERO_LEN_ARRAY 1 +#endif +#endif + +#if defined (MONO_INSIDE_RUNTIME) + +#if defined (__CENTRINEL__) +/* Centrinel is an analyzer that warns about raw pointer to managed objects + * inside Mono. + */ +#define MONO_RT_MANAGED_ATTR __CENTRINEL_MANAGED_ATTR +#define MONO_RT_CENTRINEL_SUPPRESS __CENTRINEL_SUPPRESS_ATTR(1) +#else +#define MONO_RT_MANAGED_ATTR +#define MONO_RT_CENTRINEL_SUPPRESS +#endif + +#if defined (__clang__) || defined (__GNUC__) +// attribute(deprecated(message)) was introduced in gcc 4.5. +// attribute(deprecated)) was introduced in gcc 4.0. +// Compare: https://gcc.gnu.org/onlinedocs/gcc-3.4.6/gcc/Function-Attributes.html +// https://gcc.gnu.org/onlinedocs/gcc-4.4.0/gcc/Function-Attributes.html +// https://gcc.gnu.org/onlinedocs/gcc-4.5.0/gcc/Function-Attributes.html +#if defined (__clang__) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5) +#define MONO_RT_EXTERNAL_ONLY \ + __attribute__ ((__deprecated__ ("The mono runtime must not call this function."))) \ + MONO_RT_CENTRINEL_SUPPRESS +#elif __GNUC__ >= 4 +#define MONO_RT_EXTERNAL_ONLY __attribute__ ((__deprecated__)) MONO_RT_CENTRINEL_SUPPRESS +#else +#define MONO_RT_EXTERNAL_ONLY MONO_RT_CENTRINEL_SUPPRESS +#endif + +#if defined (__clang__) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2) +// Pragmas for controlling diagnostics appear to be from gcc 4.2. +// This is used in place of configure gcc -Werror=deprecated-declarations: +// 1. To be portable across build systems. +// 2. configure is very sensitive to compiler flags; they break autoconf's probes. +// Though #2 can be mitigated by being late in configure. +#pragma GCC diagnostic error "-Wdeprecated-declarations" +#endif + +#else +#define MONO_RT_EXTERNAL_ONLY MONO_RT_CENTRINEL_SUPPRESS +#endif // clang or gcc + +#else +#define MONO_RT_EXTERNAL_ONLY +#define MONO_RT_MANAGED_ATTR +#endif /* MONO_INSIDE_RUNTIME */ + +#if defined (__clang__) || defined (__GNUC__) +#define _MONO_DEPRECATED __attribute__ ((__deprecated__)) +#elif defined (_MSC_VER) +#define _MONO_DEPRECATED __declspec (deprecated) +#else +#define _MONO_DEPRECATED +#endif + +#define MONO_DEPRECATED MONO_API MONO_RT_EXTERNAL_ONLY _MONO_DEPRECATED + +MONO_END_DECLS + +#endif /* __MONO_PUBLIB_H__ */ From bdeba609724318f2f6a41b3318312ac095be1ff5 Mon Sep 17 00:00:00 2001 From: Peter Sollich Date: Fri, 21 Aug 2020 14:57:06 +0200 Subject: [PATCH 04/16] delete backport.yml so I can push to master --- .github/workflows/backport.yml | 26 ------------------------ .gitignore | 37 ++++++++++++++++++++++++++++++++++ 2 files changed, 37 insertions(+), 26 deletions(-) delete mode 100644 .github/workflows/backport.yml diff --git a/.github/workflows/backport.yml b/.github/workflows/backport.yml deleted file mode 100644 index 79cde1d3ce293..0000000000000 --- a/.github/workflows/backport.yml +++ /dev/null @@ -1,26 +0,0 @@ -name: Backport PR to branch -on: - issue_comment: - types: [created] - -jobs: - backport: - if: github.event.issue.pull_request != '' && contains(github.event.comment.body, '/backport to') - runs-on: ubuntu-20.04 - steps: - - name: Checkout repo - uses: actions/checkout@v2 - - name: Run backport - uses: ./eng/actions/backport - with: - auth_token: ${{ secrets.GITHUB_TOKEN }} - pr_description_template: | - Backport of #%source_pr_number% to %target_branch% - - /cc %cc_users% - - ## Customer Impact - - ## Testing - - ## Risk diff --git a/.gitignore b/.gitignore index 15c6de9d52edf..19e45b4ebe0d3 100644 --- a/.gitignore +++ b/.gitignore @@ -359,3 +359,40 @@ src/coreclr/src/System.Private.CoreLib/common # Mono Wasm-specific excludes src/mono/wasm/emsdk/ src/mono/wasm/.stamp-wasm-install-and-select* +/src/tests/readytorun/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt +/src/tests/readytorun/out/build/x64-Debug (Standard)/rules.ninja +/src/tests/readytorun/out/build/x64-Debug (Standard)/build.ninja +/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply/target-nativelibrary-Debug-db3cc60a4a30aa6ad4f9.json +/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply/index-2020-08-21T10-11-45-0169.json +/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply/codemodel-v2-54a6f181cd4cae4a23f1.json +/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply/cmakeFiles-v1-721ff5cc9aabe9506246.json +/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply/cache-v2-94dde366ed96f1844532.json +/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply +/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json +/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS +/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1 +/src/tests/readytorun/out/build/x64-Debug (Standard) +/src/tests/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt +/src/tests/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json +/src/tests/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS +/src/tests/out/build/x64-Debug (Standard) +/src/tests +/src/mono/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt +/src/mono/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json +/src/mono/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS +/src/mono/out/build/x64-Debug (Standard) +/src/libraries/Native/Windows/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt +/src/libraries/Native/Windows/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json +/src/libraries/Native/Windows/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS +/src/libraries/Native/Windows/out/build/x64-Debug (Standard) +/src/libraries/Native/Unix/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt +/src/libraries/Native/Unix/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json +/src/libraries/Native/Unix/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS +/src/libraries/Native/Unix/out/build/x64-Debug (Standard) +/src/libraries/Native +/src/installer/corehost/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt +/src/installer/corehost/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json +/src/installer/corehost/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS +/src/installer/corehost/out/build/x64-Debug (Standard) +/src/coreclr/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt +/src/coreclr/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json From e5afb5156262e2692ec42c9b0c9f371ef459a026 Mon Sep 17 00:00:00 2001 From: Peter Sollich Date: Thu, 27 Aug 2020 11:36:14 +0200 Subject: [PATCH 05/16] Undo unintended changes --- .github/workflows/backport.yml | 26 ++++++++++++++++++++++++ .gitignore | 37 ---------------------------------- 2 files changed, 26 insertions(+), 37 deletions(-) create mode 100644 .github/workflows/backport.yml diff --git a/.github/workflows/backport.yml b/.github/workflows/backport.yml new file mode 100644 index 0000000000000..79cde1d3ce293 --- /dev/null +++ b/.github/workflows/backport.yml @@ -0,0 +1,26 @@ +name: Backport PR to branch +on: + issue_comment: + types: [created] + +jobs: + backport: + if: github.event.issue.pull_request != '' && contains(github.event.comment.body, '/backport to') + runs-on: ubuntu-20.04 + steps: + - name: Checkout repo + uses: actions/checkout@v2 + - name: Run backport + uses: ./eng/actions/backport + with: + auth_token: ${{ secrets.GITHUB_TOKEN }} + pr_description_template: | + Backport of #%source_pr_number% to %target_branch% + + /cc %cc_users% + + ## Customer Impact + + ## Testing + + ## Risk diff --git a/.gitignore b/.gitignore index 19e45b4ebe0d3..15c6de9d52edf 100644 --- a/.gitignore +++ b/.gitignore @@ -359,40 +359,3 @@ src/coreclr/src/System.Private.CoreLib/common # Mono Wasm-specific excludes src/mono/wasm/emsdk/ src/mono/wasm/.stamp-wasm-install-and-select* -/src/tests/readytorun/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt -/src/tests/readytorun/out/build/x64-Debug (Standard)/rules.ninja -/src/tests/readytorun/out/build/x64-Debug (Standard)/build.ninja -/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply/target-nativelibrary-Debug-db3cc60a4a30aa6ad4f9.json -/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply/index-2020-08-21T10-11-45-0169.json -/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply/codemodel-v2-54a6f181cd4cae4a23f1.json -/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply/cmakeFiles-v1-721ff5cc9aabe9506246.json -/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply/cache-v2-94dde366ed96f1844532.json -/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/reply -/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json -/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS -/src/tests/readytorun/out/build/x64-Debug (Standard)/.cmake/api/v1 -/src/tests/readytorun/out/build/x64-Debug (Standard) -/src/tests/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt -/src/tests/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json -/src/tests/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS -/src/tests/out/build/x64-Debug (Standard) -/src/tests -/src/mono/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt -/src/mono/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json -/src/mono/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS -/src/mono/out/build/x64-Debug (Standard) -/src/libraries/Native/Windows/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt -/src/libraries/Native/Windows/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json -/src/libraries/Native/Windows/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS -/src/libraries/Native/Windows/out/build/x64-Debug (Standard) -/src/libraries/Native/Unix/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt -/src/libraries/Native/Unix/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json -/src/libraries/Native/Unix/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS -/src/libraries/Native/Unix/out/build/x64-Debug (Standard) -/src/libraries/Native -/src/installer/corehost/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt -/src/installer/corehost/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json -/src/installer/corehost/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS -/src/installer/corehost/out/build/x64-Debug (Standard) -/src/coreclr/out/build/x64-Debug (Standard)/VSInheritEnvironments.txt -/src/coreclr/out/build/x64-Debug (Standard)/.cmake/api/v1/query/client-MicrosoftVS/query.json From 6887c3265deabe1dd0d4a589d8fc360a1db84ef1 Mon Sep 17 00:00:00 2001 From: Peter Sollich Date: Mon, 30 Nov 2020 16:39:04 +0100 Subject: [PATCH 06/16] Merge from upstream/master --- src/mono/msvc/include/mono/cil/opcode.def | 349 ++++++++++++ src/mono/msvc/include/mono/jit/jit.h | 120 ++++ .../include/mono/jit/mono-private-unstable.h | 39 ++ .../msvc/include/mono/metadata/appdomain.h | 234 ++++++++ .../msvc/include/mono/metadata/assembly.h | 136 +++++ .../msvc/include/mono/metadata/attrdefs.h | 274 ++++++++++ src/mono/msvc/include/mono/metadata/blob.h | 118 ++++ src/mono/msvc/include/mono/metadata/class.h | 313 +++++++++++ .../include/mono/metadata/debug-helpers.h | 54 ++ .../mono/metadata/debug-mono-symfile.h | 114 ++++ .../msvc/include/mono/metadata/environment.h | 23 + .../msvc/include/mono/metadata/exception.h | 177 ++++++ src/mono/msvc/include/mono/metadata/image.h | 99 ++++ src/mono/msvc/include/mono/metadata/loader.h | 109 ++++ .../msvc/include/mono/metadata/metadata.h | 517 ++++++++++++++++++ .../msvc/include/mono/metadata/mono-config.h | 38 ++ .../msvc/include/mono/metadata/mono-debug.h | 231 ++++++++ src/mono/msvc/include/mono/metadata/mono-gc.h | 138 +++++ .../mono/metadata/mono-private-unstable.h | 41 ++ .../include/mono/metadata/object-forward.h | 22 + src/mono/msvc/include/mono/metadata/object.h | 408 ++++++++++++++ src/mono/msvc/include/mono/metadata/opcodes.h | 83 +++ .../include/mono/metadata/profiler-events.h | 108 ++++ .../msvc/include/mono/metadata/profiler.h | 248 +++++++++ .../msvc/include/mono/metadata/reflection.h | 174 ++++++ .../msvc/include/mono/metadata/row-indexes.h | 503 +++++++++++++++++ .../msvc/include/mono/metadata/sgen-bridge.h | 110 ++++ src/mono/msvc/include/mono/metadata/threads.h | 69 +++ .../msvc/include/mono/metadata/tokentype.h | 45 ++ src/mono/msvc/include/mono/metadata/verify.h | 66 +++ .../msvc/include/mono/utils/mono-counters.h | 105 ++++ .../include/mono/utils/mono-dl-fallback.h | 43 ++ src/mono/msvc/include/mono/utils/mono-error.h | 105 ++++ .../msvc/include/mono/utils/mono-forward.h | 15 + .../msvc/include/mono/utils/mono-jemalloc.h | 36 ++ .../msvc/include/mono/utils/mono-logger.h | 31 ++ .../mono/utils/mono-private-unstable.h | 19 + .../msvc/include/mono/utils/mono-publib.h | 187 +++++++ 38 files changed, 5501 insertions(+) create mode 100644 src/mono/msvc/include/mono/cil/opcode.def create mode 100644 src/mono/msvc/include/mono/jit/jit.h create mode 100644 src/mono/msvc/include/mono/jit/mono-private-unstable.h create mode 100644 src/mono/msvc/include/mono/metadata/appdomain.h create mode 100644 src/mono/msvc/include/mono/metadata/assembly.h create mode 100644 src/mono/msvc/include/mono/metadata/attrdefs.h create mode 100644 src/mono/msvc/include/mono/metadata/blob.h create mode 100644 src/mono/msvc/include/mono/metadata/class.h create mode 100644 src/mono/msvc/include/mono/metadata/debug-helpers.h create mode 100644 src/mono/msvc/include/mono/metadata/debug-mono-symfile.h create mode 100644 src/mono/msvc/include/mono/metadata/environment.h create mode 100644 src/mono/msvc/include/mono/metadata/exception.h create mode 100644 src/mono/msvc/include/mono/metadata/image.h create mode 100644 src/mono/msvc/include/mono/metadata/loader.h create mode 100644 src/mono/msvc/include/mono/metadata/metadata.h create mode 100644 src/mono/msvc/include/mono/metadata/mono-config.h create mode 100644 src/mono/msvc/include/mono/metadata/mono-debug.h create mode 100644 src/mono/msvc/include/mono/metadata/mono-gc.h create mode 100644 src/mono/msvc/include/mono/metadata/mono-private-unstable.h create mode 100644 src/mono/msvc/include/mono/metadata/object-forward.h create mode 100644 src/mono/msvc/include/mono/metadata/object.h create mode 100644 src/mono/msvc/include/mono/metadata/opcodes.h create mode 100644 src/mono/msvc/include/mono/metadata/profiler-events.h create mode 100644 src/mono/msvc/include/mono/metadata/profiler.h create mode 100644 src/mono/msvc/include/mono/metadata/reflection.h create mode 100644 src/mono/msvc/include/mono/metadata/row-indexes.h create mode 100644 src/mono/msvc/include/mono/metadata/sgen-bridge.h create mode 100644 src/mono/msvc/include/mono/metadata/threads.h create mode 100644 src/mono/msvc/include/mono/metadata/tokentype.h create mode 100644 src/mono/msvc/include/mono/metadata/verify.h create mode 100644 src/mono/msvc/include/mono/utils/mono-counters.h create mode 100644 src/mono/msvc/include/mono/utils/mono-dl-fallback.h create mode 100644 src/mono/msvc/include/mono/utils/mono-error.h create mode 100644 src/mono/msvc/include/mono/utils/mono-forward.h create mode 100644 src/mono/msvc/include/mono/utils/mono-jemalloc.h create mode 100644 src/mono/msvc/include/mono/utils/mono-logger.h create mode 100644 src/mono/msvc/include/mono/utils/mono-private-unstable.h create mode 100644 src/mono/msvc/include/mono/utils/mono-publib.h diff --git a/src/mono/msvc/include/mono/cil/opcode.def b/src/mono/msvc/include/mono/cil/opcode.def new file mode 100644 index 0000000000000..a39b315bac5e9 --- /dev/null +++ b/src/mono/msvc/include/mono/cil/opcode.def @@ -0,0 +1,349 @@ +/* GENERATED FILE, DO NOT EDIT. Edit cil-opcodes.xml instead and run "make opcode.def" to regenerate. */ +OPDEF(CEE_NOP, "nop", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0x00, NEXT) +OPDEF(CEE_BREAK, "break", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0x01, ERROR) +OPDEF(CEE_LDARG_0, "ldarg.0", Pop0, Push1, InlineNone, 0, 1, 0xFF, 0x02, NEXT) +OPDEF(CEE_LDARG_1, "ldarg.1", Pop0, Push1, InlineNone, 1, 1, 0xFF, 0x03, NEXT) +OPDEF(CEE_LDARG_2, "ldarg.2", Pop0, Push1, InlineNone, 2, 1, 0xFF, 0x04, NEXT) +OPDEF(CEE_LDARG_3, "ldarg.3", Pop0, Push1, InlineNone, 3, 1, 0xFF, 0x05, NEXT) +OPDEF(CEE_LDLOC_0, "ldloc.0", Pop0, Push1, InlineNone, 0, 1, 0xFF, 0x06, NEXT) +OPDEF(CEE_LDLOC_1, "ldloc.1", Pop0, Push1, InlineNone, 1, 1, 0xFF, 0x07, NEXT) +OPDEF(CEE_LDLOC_2, "ldloc.2", Pop0, Push1, InlineNone, 2, 1, 0xFF, 0x08, NEXT) +OPDEF(CEE_LDLOC_3, "ldloc.3", Pop0, Push1, InlineNone, 3, 1, 0xFF, 0x09, NEXT) +OPDEF(CEE_STLOC_0, "stloc.0", Pop1, Push0, InlineNone, 0, 1, 0xFF, 0x0A, NEXT) +OPDEF(CEE_STLOC_1, "stloc.1", Pop1, Push0, InlineNone, 1, 1, 0xFF, 0x0B, NEXT) +OPDEF(CEE_STLOC_2, "stloc.2", Pop1, Push0, InlineNone, 2, 1, 0xFF, 0x0C, NEXT) +OPDEF(CEE_STLOC_3, "stloc.3", Pop1, Push0, InlineNone, 3, 1, 0xFF, 0x0D, NEXT) +OPDEF(CEE_LDARG_S, "ldarg.s", Pop0, Push1, ShortInlineVar, 0, 1, 0xFF, 0x0E, NEXT) +OPDEF(CEE_LDARGA_S, "ldarga.s", Pop0, PushI, ShortInlineVar, 0, 1, 0xFF, 0x0F, NEXT) +OPDEF(CEE_STARG_S, "starg.s", Pop1, Push0, ShortInlineVar, 0, 1, 0xFF, 0x10, NEXT) +OPDEF(CEE_LDLOC_S, "ldloc.s", Pop0, Push1, ShortInlineVar, 0, 1, 0xFF, 0x11, NEXT) +OPDEF(CEE_LDLOCA_S, "ldloca.s", Pop0, PushI, ShortInlineVar, 0, 1, 0xFF, 0x12, NEXT) +OPDEF(CEE_STLOC_S, "stloc.s", Pop1, Push0, ShortInlineVar, 0, 1, 0xFF, 0x13, NEXT) +OPDEF(CEE_LDNULL, "ldnull", Pop0, PushRef, InlineNone, 0, 1, 0xFF, 0x14, NEXT) +OPDEF(CEE_LDC_I4_M1, "ldc.i4.m1", Pop0, PushI, InlineNone, -1, 1, 0xFF, 0x15, NEXT) +OPDEF(CEE_LDC_I4_0, "ldc.i4.0", Pop0, PushI, InlineNone, 0, 1, 0xFF, 0x16, NEXT) +OPDEF(CEE_LDC_I4_1, "ldc.i4.1", Pop0, PushI, InlineNone, 1, 1, 0xFF, 0x17, NEXT) +OPDEF(CEE_LDC_I4_2, "ldc.i4.2", Pop0, PushI, InlineNone, 2, 1, 0xFF, 0x18, NEXT) +OPDEF(CEE_LDC_I4_3, "ldc.i4.3", Pop0, PushI, InlineNone, 3, 1, 0xFF, 0x19, NEXT) +OPDEF(CEE_LDC_I4_4, "ldc.i4.4", Pop0, PushI, InlineNone, 4, 1, 0xFF, 0x1A, NEXT) +OPDEF(CEE_LDC_I4_5, "ldc.i4.5", Pop0, PushI, InlineNone, 5, 1, 0xFF, 0x1B, NEXT) +OPDEF(CEE_LDC_I4_6, "ldc.i4.6", Pop0, PushI, InlineNone, 6, 1, 0xFF, 0x1C, NEXT) +OPDEF(CEE_LDC_I4_7, "ldc.i4.7", Pop0, PushI, InlineNone, 7, 1, 0xFF, 0x1D, NEXT) +OPDEF(CEE_LDC_I4_8, "ldc.i4.8", Pop0, PushI, InlineNone, 8, 1, 0xFF, 0x1E, NEXT) +OPDEF(CEE_LDC_I4_S, "ldc.i4.s", Pop0, PushI, ShortInlineI, 0, 1, 0xFF, 0x1F, NEXT) +OPDEF(CEE_LDC_I4, "ldc.i4", Pop0, PushI, InlineI, 0, 1, 0xFF, 0x20, NEXT) +OPDEF(CEE_LDC_I8, "ldc.i8", Pop0, PushI8, InlineI8, 0, 1, 0xFF, 0x21, NEXT) +OPDEF(CEE_LDC_R4, "ldc.r4", Pop0, PushR4, ShortInlineR, 0, 1, 0xFF, 0x22, NEXT) +OPDEF(CEE_LDC_R8, "ldc.r8", Pop0, PushR8, InlineR, 0, 1, 0xFF, 0x23, NEXT) +OPDEF(CEE_UNUSED99, "unused99", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0x24, NEXT) +OPDEF(CEE_DUP, "dup", Pop1, Push1+Push1, InlineNone, 0, 1, 0xFF, 0x25, NEXT) +OPDEF(CEE_POP, "pop", Pop1, Push0, InlineNone, 0, 1, 0xFF, 0x26, NEXT) +OPDEF(CEE_JMP, "jmp", Pop0, Push0, InlineMethod, 0, 1, 0xFF, 0x27, CALL) +OPDEF(CEE_CALL, "call", VarPop, VarPush, InlineMethod, 0, 1, 0xFF, 0x28, CALL) +OPDEF(CEE_CALLI, "calli", VarPop, VarPush, InlineSig, 0, 1, 0xFF, 0x29, CALL) +OPDEF(CEE_RET, "ret", VarPop, Push0, InlineNone, 0, 1, 0xFF, 0x2A, RETURN) +OPDEF(CEE_BR_S, "br.s", Pop0, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x2B, BRANCH) +OPDEF(CEE_BRFALSE_S, "brfalse.s", PopI, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x2C, COND_BRANCH) +OPDEF(CEE_BRTRUE_S, "brtrue.s", PopI, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x2D, COND_BRANCH) +OPDEF(CEE_BEQ_S, "beq.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x2E, COND_BRANCH) +OPDEF(CEE_BGE_S, "bge.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x2F, COND_BRANCH) +OPDEF(CEE_BGT_S, "bgt.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x30, COND_BRANCH) +OPDEF(CEE_BLE_S, "ble.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x31, COND_BRANCH) +OPDEF(CEE_BLT_S, "blt.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x32, COND_BRANCH) +OPDEF(CEE_BNE_UN_S, "bne.un.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x33, COND_BRANCH) +OPDEF(CEE_BGE_UN_S, "bge.un.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x34, COND_BRANCH) +OPDEF(CEE_BGT_UN_S, "bgt.un.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x35, COND_BRANCH) +OPDEF(CEE_BLE_UN_S, "ble.un.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x36, COND_BRANCH) +OPDEF(CEE_BLT_UN_S, "blt.un.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x37, COND_BRANCH) +OPDEF(CEE_BR, "br", Pop0, Push0, InlineBrTarget, 0, 1, 0xFF, 0x38, BRANCH) +OPDEF(CEE_BRFALSE, "brfalse", PopI, Push0, InlineBrTarget, 0, 1, 0xFF, 0x39, COND_BRANCH) +OPDEF(CEE_BRTRUE, "brtrue", PopI, Push0, InlineBrTarget, 0, 1, 0xFF, 0x3A, COND_BRANCH) +OPDEF(CEE_BEQ, "beq", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x3B, COND_BRANCH) +OPDEF(CEE_BGE, "bge", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x3C, COND_BRANCH) +OPDEF(CEE_BGT, "bgt", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x3D, COND_BRANCH) +OPDEF(CEE_BLE, "ble", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x3E, COND_BRANCH) +OPDEF(CEE_BLT, "blt", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x3F, COND_BRANCH) +OPDEF(CEE_BNE_UN, "bne.un", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x40, COND_BRANCH) +OPDEF(CEE_BGE_UN, "bge.un", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x41, COND_BRANCH) +OPDEF(CEE_BGT_UN, "bgt.un", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x42, COND_BRANCH) +OPDEF(CEE_BLE_UN, "ble.un", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x43, COND_BRANCH) +OPDEF(CEE_BLT_UN, "blt.un", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x44, COND_BRANCH) +OPDEF(CEE_SWITCH, "switch", PopI, Push0, InlineSwitch, 0, 1, 0xFF, 0x45, COND_BRANCH) +OPDEF(CEE_LDIND_I1, "ldind.i1", PopI, PushI, InlineNone, 0, 1, 0xFF, 0x46, NEXT) +OPDEF(CEE_LDIND_U1, "ldind.u1", PopI, PushI, InlineNone, 0, 1, 0xFF, 0x47, NEXT) +OPDEF(CEE_LDIND_I2, "ldind.i2", PopI, PushI, InlineNone, 0, 1, 0xFF, 0x48, NEXT) +OPDEF(CEE_LDIND_U2, "ldind.u2", PopI, PushI, InlineNone, 0, 1, 0xFF, 0x49, NEXT) +OPDEF(CEE_LDIND_I4, "ldind.i4", PopI, PushI, InlineNone, 0, 1, 0xFF, 0x4A, NEXT) +OPDEF(CEE_LDIND_U4, "ldind.u4", PopI, PushI, InlineNone, 0, 1, 0xFF, 0x4B, NEXT) +OPDEF(CEE_LDIND_I8, "ldind.i8", PopI, PushI8, InlineNone, 0, 1, 0xFF, 0x4C, NEXT) +OPDEF(CEE_LDIND_I, "ldind.i", PopI, PushI, InlineNone, 0, 1, 0xFF, 0x4D, NEXT) +OPDEF(CEE_LDIND_R4, "ldind.r4", PopI, PushR4, InlineNone, 0, 1, 0xFF, 0x4E, NEXT) +OPDEF(CEE_LDIND_R8, "ldind.r8", PopI, PushR8, InlineNone, 0, 1, 0xFF, 0x4F, NEXT) +OPDEF(CEE_LDIND_REF, "ldind.ref", PopI, PushRef, InlineNone, 0, 1, 0xFF, 0x50, NEXT) +OPDEF(CEE_STIND_REF, "stind.ref", PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x51, NEXT) +OPDEF(CEE_STIND_I1, "stind.i1", PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x52, NEXT) +OPDEF(CEE_STIND_I2, "stind.i2", PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x53, NEXT) +OPDEF(CEE_STIND_I4, "stind.i4", PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x54, NEXT) +OPDEF(CEE_STIND_I8, "stind.i8", PopI+PopI8, Push0, InlineNone, 0, 1, 0xFF, 0x55, NEXT) +OPDEF(CEE_STIND_R4, "stind.r4", PopI+PopR4, Push0, InlineNone, 0, 1, 0xFF, 0x56, NEXT) +OPDEF(CEE_STIND_R8, "stind.r8", PopI+PopR8, Push0, InlineNone, 0, 1, 0xFF, 0x57, NEXT) +OPDEF(CEE_ADD, "add", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x58, NEXT) +OPDEF(CEE_SUB, "sub", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x59, NEXT) +OPDEF(CEE_MUL, "mul", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x5A, NEXT) +OPDEF(CEE_DIV, "div", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x5B, NEXT) +OPDEF(CEE_DIV_UN, "div.un", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x5C, NEXT) +OPDEF(CEE_REM, "rem", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x5D, NEXT) +OPDEF(CEE_REM_UN, "rem.un", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x5E, NEXT) +OPDEF(CEE_AND, "and", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x5F, NEXT) +OPDEF(CEE_OR, "or", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x60, NEXT) +OPDEF(CEE_XOR, "xor", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x61, NEXT) +OPDEF(CEE_SHL, "shl", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x62, NEXT) +OPDEF(CEE_SHR, "shr", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x63, NEXT) +OPDEF(CEE_SHR_UN, "shr.un", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x64, NEXT) +OPDEF(CEE_NEG, "neg", Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x65, NEXT) +OPDEF(CEE_NOT, "not", Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x66, NEXT) +OPDEF(CEE_CONV_I1, "conv.i1", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x67, NEXT) +OPDEF(CEE_CONV_I2, "conv.i2", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x68, NEXT) +OPDEF(CEE_CONV_I4, "conv.i4", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x69, NEXT) +OPDEF(CEE_CONV_I8, "conv.i8", Pop1, PushI8, InlineNone, 0, 1, 0xFF, 0x6A, NEXT) +OPDEF(CEE_CONV_R4, "conv.r4", Pop1, PushR4, InlineNone, 0, 1, 0xFF, 0x6B, NEXT) +OPDEF(CEE_CONV_R8, "conv.r8", Pop1, PushR8, InlineNone, 0, 1, 0xFF, 0x6C, NEXT) +OPDEF(CEE_CONV_U4, "conv.u4", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x6D, NEXT) +OPDEF(CEE_CONV_U8, "conv.u8", Pop1, PushI8, InlineNone, 0, 1, 0xFF, 0x6E, NEXT) +OPDEF(CEE_CALLVIRT, "callvirt", VarPop, VarPush, InlineMethod, 0, 1, 0xFF, 0x6F, CALL) +OPDEF(CEE_CPOBJ, "cpobj", PopI+PopI, Push0, InlineType, 0, 1, 0xFF, 0x70, NEXT) +OPDEF(CEE_LDOBJ, "ldobj", PopI, Push1, InlineType, 0, 1, 0xFF, 0x71, NEXT) +OPDEF(CEE_LDSTR, "ldstr", Pop0, PushRef, InlineString, 0, 1, 0xFF, 0x72, NEXT) +OPDEF(CEE_NEWOBJ, "newobj", VarPop, PushRef, InlineMethod, 0, 1, 0xFF, 0x73, CALL) +OPDEF(CEE_CASTCLASS, "castclass", PopRef, PushRef, InlineType, 0, 1, 0xFF, 0x74, NEXT) +OPDEF(CEE_ISINST, "isinst", PopRef, PushI, InlineType, 0, 1, 0xFF, 0x75, NEXT) +OPDEF(CEE_CONV_R_UN, "conv.r.un", Pop1, PushR8, InlineNone, 0, 1, 0xFF, 0x76, NEXT) +OPDEF(CEE_UNUSED58, "unused58", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0x77, NEXT) +OPDEF(CEE_UNUSED1, "unused1", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0x78, NEXT) +OPDEF(CEE_UNBOX, "unbox", PopRef, PushI, InlineType, 0, 1, 0xFF, 0x79, NEXT) +OPDEF(CEE_THROW, "throw", PopRef, Push0, InlineNone, 0, 1, 0xFF, 0x7A, ERROR) +OPDEF(CEE_LDFLD, "ldfld", PopRef, Push1, InlineField, 0, 1, 0xFF, 0x7B, NEXT) +OPDEF(CEE_LDFLDA, "ldflda", PopRef, PushI, InlineField, 0, 1, 0xFF, 0x7C, NEXT) +OPDEF(CEE_STFLD, "stfld", PopRef+Pop1, Push0, InlineField, 0, 1, 0xFF, 0x7D, NEXT) +OPDEF(CEE_LDSFLD, "ldsfld", Pop0, Push1, InlineField, 0, 1, 0xFF, 0x7E, NEXT) +OPDEF(CEE_LDSFLDA, "ldsflda", Pop0, PushI, InlineField, 0, 1, 0xFF, 0x7F, NEXT) +OPDEF(CEE_STSFLD, "stsfld", Pop1, Push0, InlineField, 0, 1, 0xFF, 0x80, NEXT) +OPDEF(CEE_STOBJ, "stobj", PopI+Pop1, Push0, InlineType, 0, 1, 0xFF, 0x81, NEXT) +OPDEF(CEE_CONV_OVF_I1_UN, "conv.ovf.i1.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x82, NEXT) +OPDEF(CEE_CONV_OVF_I2_UN, "conv.ovf.i2.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x83, NEXT) +OPDEF(CEE_CONV_OVF_I4_UN, "conv.ovf.i4.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x84, NEXT) +OPDEF(CEE_CONV_OVF_I8_UN, "conv.ovf.i8.un", Pop1, PushI8, InlineNone, 0, 1, 0xFF, 0x85, NEXT) +OPDEF(CEE_CONV_OVF_U1_UN, "conv.ovf.u1.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x86, NEXT) +OPDEF(CEE_CONV_OVF_U2_UN, "conv.ovf.u2.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x87, NEXT) +OPDEF(CEE_CONV_OVF_U4_UN, "conv.ovf.u4.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x88, NEXT) +OPDEF(CEE_CONV_OVF_U8_UN, "conv.ovf.u8.un", Pop1, PushI8, InlineNone, 0, 1, 0xFF, 0x89, NEXT) +OPDEF(CEE_CONV_OVF_I_UN, "conv.ovf.i.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x8A, NEXT) +OPDEF(CEE_CONV_OVF_U_UN, "conv.ovf.u.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x8B, NEXT) +OPDEF(CEE_BOX, "box", Pop1, PushRef, InlineType, 0, 1, 0xFF, 0x8C, NEXT) +OPDEF(CEE_NEWARR, "newarr", PopI, PushRef, InlineType, 0, 1, 0xFF, 0x8D, NEXT) +OPDEF(CEE_LDLEN, "ldlen", PopRef, PushI, InlineNone, 0, 1, 0xFF, 0x8E, NEXT) +OPDEF(CEE_LDELEMA, "ldelema", PopRef+PopI, PushI, InlineType, 0, 1, 0xFF, 0x8F, NEXT) +OPDEF(CEE_LDELEM_I1, "ldelem.i1", PopRef+PopI, PushI, InlineNone, 0, 1, 0xFF, 0x90, NEXT) +OPDEF(CEE_LDELEM_U1, "ldelem.u1", PopRef+PopI, PushI, InlineNone, 0, 1, 0xFF, 0x91, NEXT) +OPDEF(CEE_LDELEM_I2, "ldelem.i2", PopRef+PopI, PushI, InlineNone, 0, 1, 0xFF, 0x92, NEXT) +OPDEF(CEE_LDELEM_U2, "ldelem.u2", PopRef+PopI, PushI, InlineNone, 0, 1, 0xFF, 0x93, NEXT) +OPDEF(CEE_LDELEM_I4, "ldelem.i4", PopRef+PopI, PushI, InlineNone, 0, 1, 0xFF, 0x94, NEXT) +OPDEF(CEE_LDELEM_U4, "ldelem.u4", PopRef+PopI, PushI, InlineNone, 0, 1, 0xFF, 0x95, NEXT) +OPDEF(CEE_LDELEM_I8, "ldelem.i8", PopRef+PopI, PushI8, InlineNone, 0, 1, 0xFF, 0x96, NEXT) +OPDEF(CEE_LDELEM_I, "ldelem.i", PopRef+PopI, PushI, InlineNone, 0, 1, 0xFF, 0x97, NEXT) +OPDEF(CEE_LDELEM_R4, "ldelem.r4", PopRef+PopI, PushR4, InlineNone, 0, 1, 0xFF, 0x98, NEXT) +OPDEF(CEE_LDELEM_R8, "ldelem.r8", PopRef+PopI, PushR8, InlineNone, 0, 1, 0xFF, 0x99, NEXT) +OPDEF(CEE_LDELEM_REF, "ldelem.ref", PopRef+PopI, PushRef, InlineNone, 0, 1, 0xFF, 0x9A, NEXT) +OPDEF(CEE_STELEM_I, "stelem.i", PopRef+PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x9B, NEXT) +OPDEF(CEE_STELEM_I1, "stelem.i1", PopRef+PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x9C, NEXT) +OPDEF(CEE_STELEM_I2, "stelem.i2", PopRef+PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x9D, NEXT) +OPDEF(CEE_STELEM_I4, "stelem.i4", PopRef+PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x9E, NEXT) +OPDEF(CEE_STELEM_I8, "stelem.i8", PopRef+PopI+PopI8, Push0, InlineNone, 0, 1, 0xFF, 0x9F, NEXT) +OPDEF(CEE_STELEM_R4, "stelem.r4", PopRef+PopI+PopR4, Push0, InlineNone, 0, 1, 0xFF, 0xA0, NEXT) +OPDEF(CEE_STELEM_R8, "stelem.r8", PopRef+PopI+PopR8, Push0, InlineNone, 0, 1, 0xFF, 0xA1, NEXT) +OPDEF(CEE_STELEM_REF, "stelem.ref", PopRef+PopI+PopRef, Push0, InlineNone, 0, 1, 0xFF, 0xA2, NEXT) +OPDEF(CEE_LDELEM, "ldelem", PopRef+PopI, Push1, InlineType, 0, 1, 0xFF, 0xA3, NEXT) +OPDEF(CEE_STELEM, "stelem", PopRef+PopI+Pop1, Push0, InlineType, 0, 1, 0xFF, 0xA4, NEXT) +OPDEF(CEE_UNBOX_ANY, "unbox.any", PopRef, Push1, InlineType, 0, 1, 0xFF, 0xA5, NEXT) +OPDEF(CEE_UNUSED5, "unused5", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xA6, NEXT) +OPDEF(CEE_UNUSED6, "unused6", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xA7, NEXT) +OPDEF(CEE_UNUSED7, "unused7", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xA8, NEXT) +OPDEF(CEE_UNUSED8, "unused8", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xA9, NEXT) +OPDEF(CEE_UNUSED9, "unused9", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xAA, NEXT) +OPDEF(CEE_UNUSED10, "unused10", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xAB, NEXT) +OPDEF(CEE_UNUSED11, "unused11", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xAC, NEXT) +OPDEF(CEE_UNUSED12, "unused12", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xAD, NEXT) +OPDEF(CEE_UNUSED13, "unused13", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xAE, NEXT) +OPDEF(CEE_UNUSED14, "unused14", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xAF, NEXT) +OPDEF(CEE_UNUSED15, "unused15", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xB0, NEXT) +OPDEF(CEE_UNUSED16, "unused16", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xB1, NEXT) +OPDEF(CEE_UNUSED17, "unused17", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xB2, NEXT) +OPDEF(CEE_CONV_OVF_I1, "conv.ovf.i1", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xB3, NEXT) +OPDEF(CEE_CONV_OVF_U1, "conv.ovf.u1", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xB4, NEXT) +OPDEF(CEE_CONV_OVF_I2, "conv.ovf.i2", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xB5, NEXT) +OPDEF(CEE_CONV_OVF_U2, "conv.ovf.u2", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xB6, NEXT) +OPDEF(CEE_CONV_OVF_I4, "conv.ovf.i4", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xB7, NEXT) +OPDEF(CEE_CONV_OVF_U4, "conv.ovf.u4", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xB8, NEXT) +OPDEF(CEE_CONV_OVF_I8, "conv.ovf.i8", Pop1, PushI8, InlineNone, 0, 1, 0xFF, 0xB9, NEXT) +OPDEF(CEE_CONV_OVF_U8, "conv.ovf.u8", Pop1, PushI8, InlineNone, 0, 1, 0xFF, 0xBA, NEXT) +OPDEF(CEE_UNUSED50, "unused50", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xBB, NEXT) +OPDEF(CEE_UNUSED18, "unused18", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xBC, NEXT) +OPDEF(CEE_UNUSED19, "unused19", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xBD, NEXT) +OPDEF(CEE_UNUSED20, "unused20", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xBE, NEXT) +OPDEF(CEE_UNUSED21, "unused21", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xBF, NEXT) +OPDEF(CEE_UNUSED22, "unused22", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xC0, NEXT) +OPDEF(CEE_UNUSED23, "unused23", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xC1, NEXT) +OPDEF(CEE_REFANYVAL, "refanyval", Pop1, PushI, InlineType, 0, 1, 0xFF, 0xC2, NEXT) +OPDEF(CEE_CKFINITE, "ckfinite", Pop1, PushR8, InlineNone, 0, 1, 0xFF, 0xC3, NEXT) +OPDEF(CEE_UNUSED24, "unused24", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xC4, NEXT) +OPDEF(CEE_UNUSED25, "unused25", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xC5, NEXT) +OPDEF(CEE_MKREFANY, "mkrefany", PopI, Push1, InlineType, 0, 1, 0xFF, 0xC6, NEXT) +OPDEF(CEE_UNUSED59, "unused59", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xC7, NEXT) +OPDEF(CEE_UNUSED60, "unused60", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xC8, NEXT) +OPDEF(CEE_UNUSED61, "unused61", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xC9, NEXT) +OPDEF(CEE_UNUSED62, "unused62", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xCA, NEXT) +OPDEF(CEE_UNUSED63, "unused63", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xCB, NEXT) +OPDEF(CEE_UNUSED64, "unused64", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xCC, NEXT) +OPDEF(CEE_UNUSED65, "unused65", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xCD, NEXT) +OPDEF(CEE_UNUSED66, "unused66", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xCE, NEXT) +OPDEF(CEE_UNUSED67, "unused67", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xCF, NEXT) +OPDEF(CEE_LDTOKEN, "ldtoken", Pop0, PushI, InlineTok, 0, 1, 0xFF, 0xD0, NEXT) +OPDEF(CEE_CONV_U2, "conv.u2", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xD1, NEXT) +OPDEF(CEE_CONV_U1, "conv.u1", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xD2, NEXT) +OPDEF(CEE_CONV_I, "conv.i", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xD3, NEXT) +OPDEF(CEE_CONV_OVF_I, "conv.ovf.i", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xD4, NEXT) +OPDEF(CEE_CONV_OVF_U, "conv.ovf.u", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xD5, NEXT) +OPDEF(CEE_ADD_OVF, "add.ovf", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0xD6, NEXT) +OPDEF(CEE_ADD_OVF_UN, "add.ovf.un", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0xD7, NEXT) +OPDEF(CEE_MUL_OVF, "mul.ovf", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0xD8, NEXT) +OPDEF(CEE_MUL_OVF_UN, "mul.ovf.un", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0xD9, NEXT) +OPDEF(CEE_SUB_OVF, "sub.ovf", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0xDA, NEXT) +OPDEF(CEE_SUB_OVF_UN, "sub.ovf.un", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0xDB, NEXT) +OPDEF(CEE_ENDFINALLY, "endfinally", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xDC, RETURN) +OPDEF(CEE_LEAVE, "leave", Pop0, Push0, InlineBrTarget, 0, 1, 0xFF, 0xDD, BRANCH) +OPDEF(CEE_LEAVE_S, "leave.s", Pop0, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0xDE, BRANCH) +OPDEF(CEE_STIND_I, "stind.i", PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0xDF, NEXT) +OPDEF(CEE_CONV_U, "conv.u", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xE0, NEXT) +OPDEF(CEE_UNUSED26, "unused26", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE1, NEXT) +OPDEF(CEE_UNUSED27, "unused27", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE2, NEXT) +OPDEF(CEE_UNUSED28, "unused28", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE3, NEXT) +OPDEF(CEE_UNUSED29, "unused29", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE4, NEXT) +OPDEF(CEE_UNUSED30, "unused30", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE5, NEXT) +OPDEF(CEE_UNUSED31, "unused31", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE6, NEXT) +OPDEF(CEE_UNUSED32, "unused32", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE7, NEXT) +OPDEF(CEE_UNUSED33, "unused33", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE8, NEXT) +OPDEF(CEE_UNUSED34, "unused34", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE9, NEXT) +OPDEF(CEE_UNUSED35, "unused35", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xEA, NEXT) +OPDEF(CEE_UNUSED36, "unused36", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xEB, NEXT) +OPDEF(CEE_UNUSED37, "unused37", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xEC, NEXT) +OPDEF(CEE_UNUSED38, "unused38", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xED, NEXT) +OPDEF(CEE_UNUSED39, "unused39", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xEE, NEXT) +OPDEF(CEE_UNUSED40, "unused40", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xEF, NEXT) +OPDEF(CEE_UNUSED41, "unused41", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF0, NEXT) +OPDEF(CEE_UNUSED42, "unused42", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF1, NEXT) +OPDEF(CEE_UNUSED43, "unused43", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF2, NEXT) +OPDEF(CEE_UNUSED44, "unused44", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF3, NEXT) +OPDEF(CEE_UNUSED45, "unused45", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF4, NEXT) +OPDEF(CEE_UNUSED46, "unused46", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF5, NEXT) +OPDEF(CEE_UNUSED47, "unused47", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF6, NEXT) +OPDEF(CEE_UNUSED48, "unused48", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF7, NEXT) +OPDEF(CEE_PREFIX7, "prefix7", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF8, META) +OPDEF(CEE_PREFIX6, "prefix6", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF9, META) +OPDEF(CEE_PREFIX5, "prefix5", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xFA, META) +OPDEF(CEE_PREFIX4, "prefix4", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xFB, META) +OPDEF(CEE_PREFIX3, "prefix3", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xFC, META) +OPDEF(CEE_PREFIX2, "prefix2", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xFD, META) +OPDEF(CEE_PREFIX1, "prefix1", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xFE, META) +OPDEF(CEE_PREFIXREF, "prefixref", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xFF, META) +OPDEF(CEE_ARGLIST, "arglist", Pop0, PushI, InlineNone, 0, 2, 0xFE, 0x00, NEXT) +OPDEF(CEE_CEQ, "ceq", Pop1+Pop1, PushI, InlineNone, 0, 2, 0xFE, 0x01, NEXT) +OPDEF(CEE_CGT, "cgt", Pop1+Pop1, PushI, InlineNone, 0, 2, 0xFE, 0x02, NEXT) +OPDEF(CEE_CGT_UN, "cgt.un", Pop1+Pop1, PushI, InlineNone, 0, 2, 0xFE, 0x03, NEXT) +OPDEF(CEE_CLT, "clt", Pop1+Pop1, PushI, InlineNone, 0, 2, 0xFE, 0x04, NEXT) +OPDEF(CEE_CLT_UN, "clt.un", Pop1+Pop1, PushI, InlineNone, 0, 2, 0xFE, 0x05, NEXT) +OPDEF(CEE_LDFTN, "ldftn", Pop0, PushI, InlineMethod, 0, 2, 0xFE, 0x06, NEXT) +OPDEF(CEE_LDVIRTFTN, "ldvirtftn", PopRef, PushI, InlineMethod, 0, 2, 0xFE, 0x07, NEXT) +OPDEF(CEE_UNUSED56, "unused56", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x08, NEXT) +OPDEF(CEE_LDARG, "ldarg", Pop0, Push1, InlineVar, 0, 2, 0xFE, 0x09, NEXT) +OPDEF(CEE_LDARGA, "ldarga", Pop0, PushI, InlineVar, 0, 2, 0xFE, 0x0A, NEXT) +OPDEF(CEE_STARG, "starg", Pop1, Push0, InlineVar, 0, 2, 0xFE, 0x0B, NEXT) +OPDEF(CEE_LDLOC, "ldloc", Pop0, Push1, InlineVar, 0, 2, 0xFE, 0x0C, NEXT) +OPDEF(CEE_LDLOCA, "ldloca", Pop0, PushI, InlineVar, 0, 2, 0xFE, 0x0D, NEXT) +OPDEF(CEE_STLOC, "stloc", Pop1, Push0, InlineVar, 0, 2, 0xFE, 0x0E, NEXT) +OPDEF(CEE_LOCALLOC, "localloc", PopI, PushI, InlineNone, 0, 2, 0xFE, 0x0F, NEXT) +OPDEF(CEE_UNUSED57, "unused57", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x10, NEXT) +OPDEF(CEE_ENDFILTER, "endfilter", PopI, Push0, InlineNone, 0, 2, 0xFE, 0x11, RETURN) +OPDEF(CEE_UNALIGNED_, "unaligned.", Pop0, Push0, ShortInlineI, 0, 2, 0xFE, 0x12, META) +OPDEF(CEE_VOLATILE_, "volatile.", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x13, META) +OPDEF(CEE_TAIL_, "tail.", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x14, META) +OPDEF(CEE_INITOBJ, "initobj", PopI, Push0, InlineType, 0, 2, 0xFE, 0x15, NEXT) +OPDEF(CEE_CONSTRAINED_, "constrained.", Pop0, Push0, InlineType, 0, 2, 0xFE, 0x16, META) +OPDEF(CEE_CPBLK, "cpblk", PopI+PopI+PopI, Push0, InlineNone, 0, 2, 0xFE, 0x17, NEXT) +OPDEF(CEE_INITBLK, "initblk", PopI+PopI+PopI, Push0, InlineNone, 0, 2, 0xFE, 0x18, NEXT) +OPDEF(CEE_NO_, "no.", Pop0, Push0, ShortInlineI, 0, 2, 0xFE, 0x19, NEXT) +OPDEF(CEE_RETHROW, "rethrow", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x1A, ERROR) +OPDEF(CEE_UNUSED, "unused", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x1B, NEXT) +OPDEF(CEE_SIZEOF, "sizeof", Pop0, PushI, InlineType, 0, 2, 0xFE, 0x1C, NEXT) +OPDEF(CEE_REFANYTYPE, "refanytype", Pop1, PushI, InlineNone, 0, 2, 0xFE, 0x1D, NEXT) +OPDEF(CEE_READONLY_, "readonly.", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x1E, META) +OPDEF(CEE_UNUSED53, "unused53", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x1F, NEXT) +OPDEF(CEE_UNUSED54, "unused54", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x20, NEXT) +OPDEF(CEE_UNUSED55, "unused55", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x21, NEXT) +OPDEF(CEE_UNUSED70, "unused70", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x22, NEXT) +OPDEF(CEE_ILLEGAL, "illegal", Pop0, Push0, InlineNone, 0, 2, 0x00, 0x00, META) +OPDEF(CEE_ENDMAC, "endmac", Pop0, Push0, InlineNone, 0, 2, 0x00, 0x00, META) +OPDEF(CEE_MONO_ICALL, "mono_icall", VarPop, VarPush, InlineI, 0, 2, 0xF0, 0x00, NEXT) +OPDEF(CEE_MONO_OBJADDR, "mono_objaddr", Pop1, PushI, InlineNone, 0, 2, 0xF0, 0x01, NEXT) +OPDEF(CEE_MONO_LDPTR, "mono_ldptr", Pop0, PushI, InlineI, 0, 2, 0xF0, 0x02, NEXT) +OPDEF(CEE_MONO_VTADDR, "mono_vtaddr", Pop1, PushI, InlineNone, 0, 2, 0xF0, 0x03, NEXT) +OPDEF(CEE_MONO_NEWOBJ, "mono_newobj", Pop0, PushRef, InlineType, 0, 2, 0xF0, 0x04, NEXT) +OPDEF(CEE_MONO_RETOBJ, "mono_retobj", PopI, Push0, InlineType, 0, 2, 0xF0, 0x05, RETURN) +OPDEF(CEE_MONO_LDNATIVEOBJ, "mono_ldnativeobj", PopI, Push1, InlineType, 0, 2, 0xF0, 0x06, RETURN) +OPDEF(CEE_MONO_CISINST, "mono_cisinst", PopRef, Push1, InlineType, 0, 2, 0xF0, 0x07, NEXT) +OPDEF(CEE_MONO_CCASTCLASS, "mono_ccastclass", PopRef, Push1, InlineType, 0, 2, 0xF0, 0x08, NEXT) +OPDEF(CEE_MONO_SAVE_LMF, "mono_save_lmf", Pop0, Push0, InlineNone, 0, 2, 0xF0, 0x09, NEXT) +OPDEF(CEE_MONO_RESTORE_LMF, "mono_restore_lmf", Pop0, Push0, InlineNone, 0, 2, 0xF0, 0x0A, NEXT) +OPDEF(CEE_MONO_CLASSCONST, "mono_classconst", Pop0, PushI, InlineI, 0, 2, 0xF0, 0x0B, NEXT) +OPDEF(CEE_MONO_NOT_TAKEN, "mono_not_taken", Pop0, Push0, InlineNone, 0, 2, 0xF0, 0x0C, NEXT) +OPDEF(CEE_MONO_TLS, "mono_tls", Pop0, PushI, InlineI, 0, 2, 0xF0, 0x0D, NEXT) +OPDEF(CEE_MONO_ICALL_ADDR, "mono_icall_addr", Pop0, PushI, InlineI, 0, 2, 0xF0, 0x0E, NEXT) +OPDEF(CEE_MONO_DYN_CALL, "mono_dyn_call", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x0F, NEXT) +OPDEF(CEE_MONO_MEMORY_BARRIER, "mono_memory_barrier", Pop0, Push0, InlineI, 0, 2, 0xF0, 0x10, NEXT) +OPDEF(CEE_UNUSED71, "unused71", Pop0, Push0, InlineNone, 0, 2, 0xF0, 0x11, NEXT) +OPDEF(CEE_UNUSED72, "unused72", Pop0, Push0, InlineNone, 0, 2, 0xF0, 0x12, NEXT) +OPDEF(CEE_MONO_JIT_ICALL_ADDR, "mono_jit_icall_addr", Pop0, PushI, InlineI, 0, 2, 0xF0, 0x13, NEXT) +OPDEF(CEE_MONO_LDPTR_INT_REQ_FLAG, "mono_ldptr_int_req_flag", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x14, NEXT) +OPDEF(CEE_MONO_LDPTR_CARD_TABLE, "mono_ldptr_card_table", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x15, NEXT) +OPDEF(CEE_MONO_LDPTR_NURSERY_START, "mono_ldptr_nursery_start", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x16, NEXT) +OPDEF(CEE_MONO_LDPTR_NURSERY_BITS, "mono_ldptr_nursery_bits", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x17, NEXT) +OPDEF(CEE_MONO_CALLI_EXTRA_ARG, "mono_calli_extra_arg", VarPop, VarPush, InlineSig, 0, 2, 0xF0, 0x18, CALL) +OPDEF(CEE_MONO_LDDOMAIN, "mono_lddomain", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x19, NEXT) +OPDEF(CEE_MONO_ATOMIC_STORE_I4, "mono_atomic_store_i4", PopI+PopI, Push0, InlineI, 0, 2, 0xF0, 0x1A, NEXT) +OPDEF(CEE_MONO_SAVE_LAST_ERROR, "mono_save_last_error", Pop0, Push0, InlineNone, 0, 2, 0xF0, 0x1B, NEXT) +OPDEF(CEE_MONO_GET_RGCTX_ARG, "mono_get_rgctx_arg", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x1C, NEXT) +OPDEF(CEE_MONO_LDPTR_PROFILER_ALLOCATION_COUNT, "mono_ldptr_profiler_allocation_count", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x1D, NEXT) +OPDEF(CEE_MONO_LD_DELEGATE_METHOD_PTR, "mono_ld_delegate_method_ptr", Pop1, PushI, InlineNone, 0, 2, 0xF0, 0x1E, NEXT) +OPDEF(CEE_MONO_RETHROW, "mono_rethrow", PopRef, Push0, InlineNone, 0, 2, 0xF0, 0x1F, ERROR) +OPDEF(CEE_MONO_GET_SP, "mono_get_sp", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x20, NEXT) +OPDEF(CEE_MONO_METHODCONST, "mono_methodconst", Pop0, PushI, InlineI, 0, 2, 0xF0, 0x21, NEXT) +OPDEF(CEE_MONO_PINVOKE_ADDR_CACHE, "mono_pinvoke_addr_cache", Pop0, PushI, InlineI, 0, 2, 0xF0, 0x22, NEXT) +#ifndef OPALIAS +#define _MONO_CIL_OPALIAS_DEFINED_ +#define OPALIAS(a,s,r) +#endif + +OPALIAS(CEE_BRNULL, "brnull", CEE_BRFALSE) +OPALIAS(CEE_BRNULL_S, "brnull.s", CEE_BRFALSE_S) +OPALIAS(CEE_BRZERO, "brzero", CEE_BRFALSE) +OPALIAS(CEE_BRZERO_S, "brzero.s", CEE_BRFALSE_S) +OPALIAS(CEE_BRINST, "brinst", CEE_BRTRUE) +OPALIAS(CEE_BRINST_S, "brinst.s", CEE_BRTRUE_S) +OPALIAS(CEE_LDIND_U8, "ldind.u8", CEE_LDIND_I8) +OPALIAS(CEE_LDELEM_U8, "ldelem.u8", CEE_LDELEM_I8) +OPALIAS(CEE_LDX_I4_MIX, "ldc.i4.M1", CEE_LDC_I4_M1) +OPALIAS(CEE_ENDFAULT, "endfault", CEE_ENDFINALLY) + +#ifdef _MONO_CIL_OPALIAS_DEFINED_ +#undef OPALIAS +#undef _MONO_CIL_OPALIAS_DEFINED_ +#endif diff --git a/src/mono/msvc/include/mono/jit/jit.h b/src/mono/msvc/include/mono/jit/jit.h new file mode 100644 index 0000000000000..02639c95122de --- /dev/null +++ b/src/mono/msvc/include/mono/jit/jit.h @@ -0,0 +1,120 @@ +/** + * \file + * Author: + * Dietmar Maurer (dietmar@ximian.com) + * + * (C) 2001, 2002, 2003 Ximian, Inc. + */ + +#ifndef _MONO_JIT_JIT_H_ +#define _MONO_JIT_JIT_H_ + +#include + +MONO_BEGIN_DECLS + +MONO_API MONO_RT_EXTERNAL_ONLY MonoDomain * +mono_jit_init (const char *file); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoDomain * +mono_jit_init_version (const char *root_domain_name, const char *runtime_version); + +MONO_API MonoDomain * +mono_jit_init_version_for_test_only (const char *root_domain_name, const char *runtime_version); + +MONO_API int +mono_jit_exec (MonoDomain *domain, MonoAssembly *assembly, + int argc, char *argv[]); +MONO_API void +mono_jit_cleanup (MonoDomain *domain); + +MONO_API mono_bool +mono_jit_set_trace_options (const char* options); + +MONO_API void +mono_set_signal_chaining (mono_bool chain_signals); + +MONO_API void +mono_set_crash_chaining (mono_bool chain_signals); + +/** + * This function is deprecated, use mono_jit_set_aot_mode instead. + */ +MONO_API void +mono_jit_set_aot_only (mono_bool aot_only); + +/** + * Allows control over our AOT (Ahead-of-time) compilation mode. + */ +typedef enum { + /* Disables AOT mode */ + MONO_AOT_MODE_NONE, + /* Enables normal AOT mode, equivalent to mono_jit_set_aot_only (false) */ + MONO_AOT_MODE_NORMAL, + /* Enables hybrid AOT mode, JIT can still be used for wrappers */ + MONO_AOT_MODE_HYBRID, + /* Enables full AOT mode, JIT is disabled and not allowed, + * equivalent to mono_jit_set_aot_only (true) */ + MONO_AOT_MODE_FULL, + /* Same as full, but use only llvm compiled code */ + MONO_AOT_MODE_LLVMONLY, + /* Uses Interpreter, JIT is disabled and not allowed, + * equivalent to "--full-aot --interpreter" */ + MONO_AOT_MODE_INTERP, + /* Same as INTERP, but use only llvm compiled code */ + MONO_AOT_MODE_INTERP_LLVMONLY, + /* Use only llvm compiled code, fall back to the interpeter */ + MONO_AOT_MODE_LLVMONLY_INTERP, + /* Same as --interp */ + MONO_AOT_MODE_INTERP_ONLY, + /* Sentinel value used internally by the runtime. We use a large number to avoid clashing with some internal values. */ + MONO_AOT_MODE_LAST = 1000, +} MonoAotMode; + +MONO_API void +mono_jit_set_aot_mode (MonoAotMode mode); + +/* + * Returns whether the runtime was invoked for the purpose of AOT-compiling an + * assembly, i.e. no managed code will run. + */ +MONO_API mono_bool +mono_jit_aot_compiling (void); + +/* Allow embedders to decide wherther to actually obey breakpoint instructions + * in specific methods (works for both break IL instructions and Debugger.Break () + * method calls). + */ +typedef enum { + /* the default is to always obey the breakpoint */ + MONO_BREAK_POLICY_ALWAYS, + /* a nop is inserted instead of a breakpoint */ + MONO_BREAK_POLICY_NEVER, + /* the breakpoint is executed only if the program has ben started under + * the debugger (that is if a debugger was attached at the time the method + * was compiled). + */ + MONO_BREAK_POLICY_ON_DBG +} MonoBreakPolicy; + +typedef MonoBreakPolicy (*MonoBreakPolicyFunc) (MonoMethod *method); +MONO_API void mono_set_break_policy (MonoBreakPolicyFunc policy_callback); + +MONO_API void +mono_jit_parse_options (int argc, char * argv[]); + +MONO_API char* mono_get_runtime_build_info (void); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_set_use_llvm (mono_bool use_llvm); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_aot_register_module (void **aot_info); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoDomain* mono_jit_thread_attach (MonoDomain *domain); + +MONO_END_DECLS + +#endif + diff --git a/src/mono/msvc/include/mono/jit/mono-private-unstable.h b/src/mono/msvc/include/mono/jit/mono-private-unstable.h new file mode 100644 index 0000000000000..4d746dd00e258 --- /dev/null +++ b/src/mono/msvc/include/mono/jit/mono-private-unstable.h @@ -0,0 +1,39 @@ +/** + * \file + * + * Private unstable APIs. + * + * WARNING: The declarations and behavior of functions in this header are NOT STABLE and can be modified or removed at + * any time. + * + */ + + +#ifndef __MONO_JIT_MONO_PRIVATE_UNSTABLE_H__ +#define __MONO_JIT_MONO_PRIVATE_UNSTABLE_H__ + +#include +#include + +/* These are used to load the AOT data for aot images compiled with MONO_AOT_FILE_FLAG_SEPARATE_DATA */ +/* + * Return the AOT data for ASSEMBLY. SIZE is the size of the data. OUT_HANDLE should be set to a handle which is later + * passed to the free function. + */ +typedef unsigned char* (*MonoLoadAotDataFunc) (MonoAssembly *assembly, int size, void* user_data, void **out_handle); +/* Not yet used */ +typedef void (*MonoFreeAotDataFunc) (MonoAssembly *assembly, int size, void* user_data, void *handle); +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_install_load_aot_data_hook (MonoLoadAotDataFunc load_func, MonoFreeAotDataFunc free_func, void* user_data); + +MONO_API int +monovm_initialize (int propertyCount, const char **propertyKeys, const char **propertyValues); + +//#ifdef HOST_WASM +typedef void* (*MonoWasmGetNativeToInterpTramp) (MonoMethod *method, void *extra_arg); + +MONO_API void +mono_wasm_install_get_native_to_interp_tramp (MonoWasmGetNativeToInterpTramp cb); +//#endif + +#endif /*__MONO_JIT_MONO_PRIVATE_UNSTABLE_H__*/ diff --git a/src/mono/msvc/include/mono/metadata/appdomain.h b/src/mono/msvc/include/mono/metadata/appdomain.h new file mode 100644 index 0000000000000..bc8a1f2de199c --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/appdomain.h @@ -0,0 +1,234 @@ +/** + * \file + * AppDomain functions + * + * Author: + * Dietmar Maurer (dietmar@ximian.com) + * + * (C) 2001 Ximian, Inc. + */ + +#ifndef _MONO_METADATA_APPDOMAIN_H_ +#define _MONO_METADATA_APPDOMAIN_H_ + +#include + +#include +#include +#include + +MONO_BEGIN_DECLS + +typedef void (*MonoThreadStartCB) (intptr_t tid, void* stack_start, + void* func); +typedef void (*MonoThreadAttachCB) (intptr_t tid, void* stack_start); + +typedef struct _MonoAppDomain MonoAppDomain; + +typedef void (*MonoDomainFunc) (MonoDomain *domain, void* user_data); + +MONO_API MonoDomain* +mono_init (const char *filename); + +MONO_API MonoDomain * +mono_init_from_assembly (const char *domain_name, const char *filename); + +MONO_API MonoDomain * +mono_init_version (const char *domain_name, const char *version); + +MONO_API MonoDomain* +mono_get_root_domain (void); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_runtime_init (MonoDomain *domain, MonoThreadStartCB start_cb, + MonoThreadAttachCB attach_cb); + +MONO_API void +mono_runtime_cleanup (MonoDomain *domain); + +MONO_API void +mono_install_runtime_cleanup (MonoDomainFunc func); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_runtime_quit (void); + +MONO_API void +mono_runtime_set_shutting_down (void); + +MONO_API mono_bool +mono_runtime_is_shutting_down (void); + +MONO_API const char* +mono_check_corlib_version (void); + +MONO_API MonoDomain * +mono_domain_create (void); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoDomain * +mono_domain_create_appdomain (char *friendly_name, char *configuration_file); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_domain_set_config (MonoDomain *domain, const char *base_dir, const char *config_file_name); + +MONO_API MonoDomain * +mono_domain_get (void); + +MONO_API MonoDomain * +mono_domain_get_by_id (int32_t domainid); + +MONO_API int32_t +mono_domain_get_id (MonoDomain *domain); + +MONO_API const char * +mono_domain_get_friendly_name (MonoDomain *domain); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_domain_set (MonoDomain *domain, mono_bool force); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_domain_set_internal (MonoDomain *domain); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_domain_unload (MonoDomain *domain); + +MONO_API void +mono_domain_try_unload (MonoDomain *domain, MonoObject **exc); + +MONO_API mono_bool +mono_domain_is_unloading (MonoDomain *domain); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoDomain * +mono_domain_from_appdomain (MonoAppDomain *appdomain); + +MONO_API void +mono_domain_foreach (MonoDomainFunc func, void* user_data); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoAssembly * +mono_domain_assembly_open (MonoDomain *domain, const char *name); + +MONO_API void +mono_domain_ensure_entry_assembly (MonoDomain *domain, MonoAssembly *assembly); + +MONO_API mono_bool +mono_domain_finalize (MonoDomain *domain, uint32_t timeout); + +MONO_API void +mono_domain_free (MonoDomain *domain, mono_bool force); + +MONO_API mono_bool +mono_domain_has_type_resolve (MonoDomain *domain); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoReflectionAssembly * +mono_domain_try_type_resolve (MonoDomain *domain, char *name, MonoObject *tb); + +MONO_API mono_bool +mono_domain_owns_vtable_slot (MonoDomain *domain, void* vtable_slot); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_context_init (MonoDomain *domain); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_context_set (MonoAppContext *new_context); + +MONO_API MonoAppContext * +mono_context_get (void); + +MONO_API int32_t +mono_context_get_id (MonoAppContext *context); + +MONO_API int32_t +mono_context_get_domain_id (MonoAppContext *context); + +MONO_API MonoJitInfo * +mono_jit_info_table_find (MonoDomain *domain, void* addr); + +/* MonoJitInfo accessors */ + +MONO_API void* +mono_jit_info_get_code_start (MonoJitInfo* ji); + +MONO_API int +mono_jit_info_get_code_size (MonoJitInfo* ji); + +MONO_API MonoMethod* +mono_jit_info_get_method (MonoJitInfo* ji); + + +MONO_API MonoImage* +mono_get_corlib (void); + +MONO_API MonoClass* +mono_get_object_class (void); + +MONO_API MonoClass* +mono_get_byte_class (void); + +MONO_API MonoClass* +mono_get_void_class (void); + +MONO_API MonoClass* +mono_get_boolean_class (void); + +MONO_API MonoClass* +mono_get_sbyte_class (void); + +MONO_API MonoClass* +mono_get_int16_class (void); + +MONO_API MonoClass* +mono_get_uint16_class (void); + +MONO_API MonoClass* +mono_get_int32_class (void); + +MONO_API MonoClass* +mono_get_uint32_class (void); + +MONO_API MonoClass* +mono_get_intptr_class (void); + +MONO_API MonoClass* +mono_get_uintptr_class (void); + +MONO_API MonoClass* +mono_get_int64_class (void); + +MONO_API MonoClass* +mono_get_uint64_class (void); + +MONO_API MonoClass* +mono_get_single_class (void); + +MONO_API MonoClass* +mono_get_double_class (void); + +MONO_API MonoClass* +mono_get_char_class (void); + +MONO_API MonoClass* +mono_get_string_class (void); + +MONO_API MonoClass* +mono_get_enum_class (void); + +MONO_API MonoClass* +mono_get_array_class (void); + +MONO_API MonoClass* +mono_get_thread_class (void); + +MONO_API MonoClass* +mono_get_exception_class (void); + +MONO_API void +mono_security_enable_core_clr (void); + +typedef mono_bool (*MonoCoreClrPlatformCB) (const char *image_name); + +MONO_API void +mono_security_set_core_clr_platform_callback (MonoCoreClrPlatformCB callback); + +MONO_END_DECLS + +#endif /* _MONO_METADATA_APPDOMAIN_H_ */ + diff --git a/src/mono/msvc/include/mono/metadata/assembly.h b/src/mono/msvc/include/mono/metadata/assembly.h new file mode 100644 index 0000000000000..e9c02ee26f5be --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/assembly.h @@ -0,0 +1,136 @@ +/** + * \file + */ + +#ifndef _MONONET_METADATA_ASSEMBLY_H_ +#define _MONONET_METADATA_ASSEMBLY_H_ + +#include +#include + +MONO_BEGIN_DECLS + +MONO_API void mono_assemblies_init (void); +MONO_API void mono_assemblies_cleanup (void); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoAssembly *mono_assembly_open (const char *filename, + MonoImageOpenStatus *status); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoAssembly *mono_assembly_open_full (const char *filename, + MonoImageOpenStatus *status, + mono_bool refonly); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoAssembly* mono_assembly_load (MonoAssemblyName *aname, + const char *basedir, + MonoImageOpenStatus *status); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoAssembly* mono_assembly_load_full (MonoAssemblyName *aname, + const char *basedir, + MonoImageOpenStatus *status, + mono_bool refonly); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoAssembly* mono_assembly_load_from (MonoImage *image, const char *fname, + MonoImageOpenStatus *status); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoAssembly* mono_assembly_load_from_full (MonoImage *image, const char *fname, + MonoImageOpenStatus *status, + mono_bool refonly); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoAssembly* mono_assembly_load_with_partial_name (const char *name, MonoImageOpenStatus *status); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoAssembly* mono_assembly_loaded (MonoAssemblyName *aname); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoAssembly* mono_assembly_loaded_full (MonoAssemblyName *aname, mono_bool refonly); +MONO_API void mono_assembly_get_assemblyref (MonoImage *image, int index, MonoAssemblyName *aname); +MONO_API void mono_assembly_load_reference (MonoImage *image, int index); +MONO_API void mono_assembly_load_references (MonoImage *image, MonoImageOpenStatus *status); +MONO_API MONO_RT_EXTERNAL_ONLY MonoImage* mono_assembly_load_module (MonoAssembly *assembly, uint32_t idx); +MONO_API void mono_assembly_close (MonoAssembly *assembly); +MONO_API void mono_assembly_setrootdir (const char *root_dir); +MONO_API MONO_CONST_RETURN char *mono_assembly_getrootdir (void); +MONO_API char *mono_native_getrootdir (void); +MONO_API void mono_assembly_foreach (MonoFunc func, void* user_data); +MONO_API void mono_assembly_set_main (MonoAssembly *assembly); +MONO_API MonoAssembly *mono_assembly_get_main (void); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoImage *mono_assembly_get_image (MonoAssembly *assembly); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoAssemblyName *mono_assembly_get_name (MonoAssembly *assembly); +MONO_API mono_bool mono_assembly_fill_assembly_name (MonoImage *image, MonoAssemblyName *aname); +MONO_API mono_bool mono_assembly_names_equal (MonoAssemblyName *l, MonoAssemblyName *r); +MONO_API char* mono_stringify_assembly_name (MonoAssemblyName *aname); + +/* Installs a function which is called each time a new assembly is loaded. */ +typedef void (*MonoAssemblyLoadFunc) (MonoAssembly *assembly, void* user_data); +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_install_assembly_load_hook (MonoAssemblyLoadFunc func, void* user_data); + +/* + * Installs a new function which is used to search the list of loaded + * assemblies for a given assembly name. + */ +typedef MonoAssembly *(*MonoAssemblySearchFunc) (MonoAssemblyName *aname, void* user_data); +MONO_API MONO_RT_EXTERNAL_ONLY +void mono_install_assembly_search_hook (MonoAssemblySearchFunc func, void* user_data); +MONO_API MONO_RT_EXTERNAL_ONLY +void mono_install_assembly_refonly_search_hook (MonoAssemblySearchFunc func, void* user_data); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoAssembly* mono_assembly_invoke_search_hook (MonoAssemblyName *aname); + +/* + * Installs a new search function which is used as a last resort when loading + * an assembly fails. This could invoke AssemblyResolve events. + */ +MONO_API MONO_RT_EXTERNAL_ONLY +void +mono_install_assembly_postload_search_hook (MonoAssemblySearchFunc func, void* user_data); + +MONO_API MONO_RT_EXTERNAL_ONLY +void +mono_install_assembly_postload_refonly_search_hook (MonoAssemblySearchFunc func, void* user_data); + + +/* Installs a function which is called before a new assembly is loaded + * The hook are invoked from last hooked to first. If any of them returns + * a non-null value, that will be the value returned in mono_assembly_load */ +typedef MonoAssembly * (*MonoAssemblyPreLoadFunc) (MonoAssemblyName *aname, + char **assemblies_path, + void* user_data); + +MONO_API MONO_RT_EXTERNAL_ONLY +void mono_install_assembly_preload_hook (MonoAssemblyPreLoadFunc func, void* user_data); +MONO_API MONO_RT_EXTERNAL_ONLY +void mono_install_assembly_refonly_preload_hook (MonoAssemblyPreLoadFunc func, void* user_data); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_assembly_invoke_load_hook (MonoAssembly *ass); + +MONO_API MonoAssemblyName* mono_assembly_name_new (const char *name); +MONO_API const char* mono_assembly_name_get_name (MonoAssemblyName *aname); +MONO_API const char* mono_assembly_name_get_culture (MonoAssemblyName *aname); +MONO_API uint16_t mono_assembly_name_get_version (MonoAssemblyName *aname, + uint16_t *minor, uint16_t *build, uint16_t *revision); +MONO_API mono_byte* mono_assembly_name_get_pubkeytoken (MonoAssemblyName *aname); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_assembly_name_free (MonoAssemblyName *aname); + +typedef struct { + const char *name; + const unsigned char *data; + unsigned int size; +} MonoBundledAssembly; + +MONO_API void mono_register_bundled_assemblies (const MonoBundledAssembly **assemblies); +MONO_API void mono_register_config_for_assembly (const char* assembly_name, const char* config_xml); +MONO_API void mono_register_symfile_for_assembly (const char* assembly_name, const mono_byte *raw_contents, int size); +MONO_API void mono_register_machine_config (const char *config_xml); + +MONO_API void mono_set_rootdir (void); +MONO_API void mono_set_dirs (const char *assembly_dir, const char *config_dir); +MONO_API void mono_set_assemblies_path (const char* path); +MONO_END_DECLS + +#endif + diff --git a/src/mono/msvc/include/mono/metadata/attrdefs.h b/src/mono/msvc/include/mono/metadata/attrdefs.h new file mode 100644 index 0000000000000..504c6c65fc6d2 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/attrdefs.h @@ -0,0 +1,274 @@ +/** + * \file + * This file contains the various definitions for constants + * found on the metadata tables + * + * Author: + * Miguel de Icaza (miguel@ximian.com) + * Paolo Molaro (lupus@ximian.com) + * + * (C) 2001 Ximian, Inc. + * (C) 2006 Novell, Inc. + * + * From the ECMA documentation + */ + +#ifndef _MONO_METADATA_ATTRDEFS_H_ +#define _MONO_METADATA_ATTRDEFS_H_ + +/* + * 23.1.1 Values for AssemblyHashAlgorithm + */ +enum { + MONO_ASSEMBLY_HASH_NONE, + MONO_ASSEMBLY_HASH_MD5 = 0x8003, + MONO_ASSEMBLY_HASH_SHA1 = 0x8004 +}; + +/* + * 23.1.2 AssemblyRefs + */ +enum { + MONO_ASSEMBLYREF_FULL_PUBLIC_KEY = 0x0001, + MONO_ASSEMBLYREF_RETARGETABLE = 0x0100, + MONO_ASSEMBLYREF_JIT_TRACKING = 0x8000, + MONO_ASSEMBLYREF_NO_JIT_OPT = 0x4000 +}; + +/* + * 23.1.4 Flags for Event.EventAttributes + */ +enum { + MONO_EVENT_SPECIALNAME = 0x0200, + MONO_EVENT_RTSPECIALNAME = 0x0400 +}; + +/* + * Field Attributes (23.1.5). + */ +enum { + MONO_FIELD_ATTR_FIELD_ACCESS_MASK = 0x0007, + MONO_FIELD_ATTR_COMPILER_CONTROLLED = 0x0000, + MONO_FIELD_ATTR_PRIVATE = 0x0001, + MONO_FIELD_ATTR_FAM_AND_ASSEM = 0x0002, + MONO_FIELD_ATTR_ASSEMBLY = 0x0003, + MONO_FIELD_ATTR_FAMILY = 0x0004, + MONO_FIELD_ATTR_FAM_OR_ASSEM = 0x0005, + MONO_FIELD_ATTR_PUBLIC = 0x0006, + + MONO_FIELD_ATTR_STATIC = 0x0010, + MONO_FIELD_ATTR_INIT_ONLY = 0x0020, + MONO_FIELD_ATTR_LITERAL = 0x0040, + MONO_FIELD_ATTR_NOT_SERIALIZED = 0x0080, + MONO_FIELD_ATTR_SPECIAL_NAME = 0x0200, + MONO_FIELD_ATTR_PINVOKE_IMPL = 0x2000, + +/* For runtime use only */ + MONO_FIELD_ATTR_RESERVED_MASK = 0x9500, + MONO_FIELD_ATTR_RT_SPECIAL_NAME = 0x0400, + MONO_FIELD_ATTR_HAS_MARSHAL = 0x1000, + MONO_FIELD_ATTR_HAS_DEFAULT = 0x8000, + MONO_FIELD_ATTR_HAS_RVA = 0x0100 +}; + +/* + * 23.1.6 Flags for FileAttributes + */ +enum { + MONO_FILE_HAS_METADATA = 0, + MONO_FILE_HAS_NO_METADATA = 1 +}; + +/* + * 23.1.7 Flags for generic parameters + */ +enum { + MONO_GEN_PARAM_VARIANCE_MASK = 0x0003, + MONO_GEN_PARAM_NON_VARIANT = 0x0000, + MONO_GEN_PARAM_VARIANT = 0x0001, + MONO_GEN_PARAM_COVARIANT = 0x0002, + MONO_GEN_PARAM_CONSTRAINT_MASK = 0x001c, + MONO_GEN_PARAM_CONSTRAINT_CLASS = 0x0004, + MONO_GEN_PARAM_CONSTRAINT_VTYPE = 0x0008, + MONO_GEN_PARAM_CONSTRAINT_DCTOR = 0x0010 +}; + +/* + * 23.1.8 Flags for ImplMap [PInvokeAttributes] + */ +enum { + MONO_PINVOKE_NO_MANGLE = 0x0001, + MONO_PINVOKE_CHAR_SET_MASK = 0x0006, + MONO_PINVOKE_CHAR_SET_NOT_SPEC = 0x0000, + MONO_PINVOKE_CHAR_SET_ANSI = 0x0002, + MONO_PINVOKE_CHAR_SET_UNICODE = 0x0004, + MONO_PINVOKE_CHAR_SET_AUTO = 0x0006, + MONO_PINVOKE_BEST_FIT_ENABLED = 0x0010, + MONO_PINVOKE_BEST_FIT_DISABLED = 0x0020, + MONO_PINVOKE_BEST_FIT_MASK = 0x0030, + MONO_PINVOKE_SUPPORTS_LAST_ERROR = 0x0040, + MONO_PINVOKE_CALL_CONV_MASK = 0x0700, + MONO_PINVOKE_CALL_CONV_WINAPI = 0x0100, + MONO_PINVOKE_CALL_CONV_CDECL = 0x0200, + MONO_PINVOKE_CALL_CONV_STDCALL = 0x0300, + MONO_PINVOKE_CALL_CONV_THISCALL = 0x0400, + MONO_PINVOKE_CALL_CONV_FASTCALL = 0x0500, + MONO_PINVOKE_THROW_ON_UNMAPPABLE_ENABLED = 0x1000, + MONO_PINVOKE_THROW_ON_UNMAPPABLE_DISABLED = 0x2000, + MONO_PINVOKE_THROW_ON_UNMAPPABLE_MASK = 0x3000, + MONO_PINVOKE_CALL_CONV_GENERIC = 0x0010, + MONO_PINVOKE_CALL_CONV_GENERICINST = 0x000a +}; + +/* + * 23.1.9 Flags for ManifestResource + */ +enum { + MONO_MANIFEST_RESOURCE_VISIBILITY_MASK = 0x00000007, + MONO_MANIFEST_RESOURCE_PUBLIC = 0x00000001, + MONO_MANIFEST_RESOURCE_PRIVATE = 0x00000002 +}; + +/* + * Method Attributes (23.1.10) + */ +enum { + MONO_METHOD_ATTR_ACCESS_MASK = 0x0007, + MONO_METHOD_ATTR_COMPILER_CONTROLLED = 0x0000, + MONO_METHOD_ATTR_PRIVATE = 0x0001, + MONO_METHOD_ATTR_FAM_AND_ASSEM = 0x0002, + MONO_METHOD_ATTR_ASSEM = 0x0003, + MONO_METHOD_ATTR_FAMILY = 0x0004, + MONO_METHOD_ATTR_FAM_OR_ASSEM = 0x0005, + MONO_METHOD_ATTR_PUBLIC = 0x0006, + + MONO_METHOD_ATTR_STATIC = 0x0010, + MONO_METHOD_ATTR_FINAL = 0x0020, + MONO_METHOD_ATTR_VIRTUAL = 0x0040, + MONO_METHOD_ATTR_HIDE_BY_SIG = 0x0080, + + MONO_METHOD_ATTR_VTABLE_LAYOUT_MASK = 0x0100, + MONO_METHOD_ATTR_REUSE_SLOT = 0x0000, + MONO_METHOD_ATTR_NEW_SLOT = 0x0100, + MONO_METHOD_ATTR_STRICT = 0x0200, + MONO_METHOD_ATTR_ABSTRACT = 0x0400, + + MONO_METHOD_ATTR_SPECIAL_NAME = 0x0800, + + MONO_METHOD_ATTR_PINVOKE_IMPL = 0x2000, + MONO_METHOD_ATTR_UNMANAGED_EXPORT = 0x0008, + +/* + * For runtime use only + */ + MONO_METHOD_ATTR_RESERVED_MASK = 0xd000, + MONO_METHOD_ATTR_RT_SPECIAL_NAME = 0x1000, + MONO_METHOD_ATTR_HAS_SECURITY = 0x4000, + MONO_METHOD_ATTR_REQUIRE_SEC_OBJECT = 0x8000 +}; + +/* + * Method Impl Attributes (23.1.11) + */ +enum { + MONO_METHOD_IMPL_ATTR_CODE_TYPE_MASK = 0x0003, + MONO_METHOD_IMPL_ATTR_IL = 0x0000, + MONO_METHOD_IMPL_ATTR_NATIVE = 0x0001, + MONO_METHOD_IMPL_ATTR_OPTIL = 0x0002, + MONO_METHOD_IMPL_ATTR_RUNTIME = 0x0003, + + MONO_METHOD_IMPL_ATTR_MANAGED_MASK = 0x0004, + MONO_METHOD_IMPL_ATTR_UNMANAGED = 0x0004, + MONO_METHOD_IMPL_ATTR_MANAGED = 0x0000, + + MONO_METHOD_IMPL_ATTR_FORWARD_REF = 0x0010, + MONO_METHOD_IMPL_ATTR_PRESERVE_SIG = 0x0080, + MONO_METHOD_IMPL_ATTR_INTERNAL_CALL = 0x1000, + MONO_METHOD_IMPL_ATTR_SYNCHRONIZED = 0x0020, + MONO_METHOD_IMPL_ATTR_NOINLINING = 0x0008, + MONO_METHOD_IMPL_ATTR_NOOPTIMIZATION = 0x0040, + MONO_METHOD_IMPL_ATTR_MAX_METHOD_IMPL_VAL = 0xffff +}; + +/* + * Method Semantics ([MethodSemanticAttributes]) 23.1.12, + */ +enum { + MONO_METHOD_SEMANTIC_SETTER = 0x0001, + MONO_METHOD_SEMANTIC_GETTER = 0x0002, + MONO_METHOD_SEMANTIC_OTHER = 0x0004, + MONO_METHOD_SEMANTIC_ADD_ON = 0x0008, + MONO_METHOD_SEMANTIC_REMOVE_ON = 0x0010, + MONO_METHOD_SEMANTIC_FIRE = 0x0020 +}; + +/* + * Flags for Params (23.1.13) + */ +enum { + MONO_PARAM_ATTR_IN = 0x0001, + MONO_PARAM_ATTR_OUT = 0x0002, + MONO_PARAM_ATTR_OPTIONAL = 0x0010, + MONO_PARAM_ATTR_RESERVED_MASK = 0xf000, + MONO_PARAM_ATTR_HAS_DEFAULT = 0x1000, + MONO_PARAM_ATTR_HAS_MARSHAL = 0x2000, + MONO_PARAM_ATTR_UNUSED = 0xcfe0 +}; + +/* + * 23.1.14 PropertyAttributes + */ +enum { + MONO_PROPERTY_ATTR_SPECIAL_NAME = 0x0200, + MONO_PROPERTY_ATTR_RESERVED_MASK = 0xf400, + MONO_PROPERTY_ATTR_RT_SPECIAL_NAME = 0x0400, + MONO_PROPERTY_ATTR_HAS_DEFAULT = 0x1000, + MONO_PROPERTY_ATTR_UNUSED = 0xe9ff +}; + +/* + * Type Attributes (23.1.15). + */ +enum { + MONO_TYPE_ATTR_VISIBILITY_MASK = 0x00000007, + MONO_TYPE_ATTR_NOT_PUBLIC = 0x00000000, + MONO_TYPE_ATTR_PUBLIC = 0x00000001, + MONO_TYPE_ATTR_NESTED_PUBLIC = 0x00000002, + MONO_TYPE_ATTR_NESTED_PRIVATE = 0x00000003, + MONO_TYPE_ATTR_NESTED_FAMILY = 0x00000004, + MONO_TYPE_ATTR_NESTED_ASSEMBLY = 0x00000005, + MONO_TYPE_ATTR_NESTED_FAM_AND_ASSEM = 0x00000006, + MONO_TYPE_ATTR_NESTED_FAM_OR_ASSEM = 0x00000007, + + MONO_TYPE_ATTR_LAYOUT_MASK = 0x00000018, + MONO_TYPE_ATTR_AUTO_LAYOUT = 0x00000000, + MONO_TYPE_ATTR_SEQUENTIAL_LAYOUT = 0x00000008, + MONO_TYPE_ATTR_EXPLICIT_LAYOUT = 0x00000010, + + MONO_TYPE_ATTR_CLASS_SEMANTIC_MASK = 0x00000020, + MONO_TYPE_ATTR_CLASS = 0x00000000, + MONO_TYPE_ATTR_INTERFACE = 0x00000020, + + MONO_TYPE_ATTR_ABSTRACT = 0x00000080, + MONO_TYPE_ATTR_SEALED = 0x00000100, + MONO_TYPE_ATTR_SPECIAL_NAME = 0x00000400, + + MONO_TYPE_ATTR_IMPORT = 0x00001000, + MONO_TYPE_ATTR_SERIALIZABLE = 0x00002000, + + MONO_TYPE_ATTR_STRING_FORMAT_MASK = 0x00030000, + MONO_TYPE_ATTR_ANSI_CLASS = 0x00000000, + MONO_TYPE_ATTR_UNICODE_CLASS = 0x00010000, + MONO_TYPE_ATTR_AUTO_CLASS = 0x00020000, + MONO_TYPE_ATTR_CUSTOM_CLASS = 0x00030000, + MONO_TYPE_ATTR_CUSTOM_MASK = 0x00c00000, + + MONO_TYPE_ATTR_BEFORE_FIELD_INIT = 0x00100000, + MONO_TYPE_ATTR_FORWARDER = 0x00200000, + + MONO_TYPE_ATTR_RESERVED_MASK = 0x00040800, + MONO_TYPE_ATTR_RT_SPECIAL_NAME = 0x00000800, + MONO_TYPE_ATTR_HAS_SECURITY = 0x00040000 +}; + +#endif diff --git a/src/mono/msvc/include/mono/metadata/blob.h b/src/mono/msvc/include/mono/metadata/blob.h new file mode 100644 index 0000000000000..7405d54466499 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/blob.h @@ -0,0 +1,118 @@ +/** + * \file + * Definitions used to pull information out of the Blob + * + */ +#ifndef _MONO_METADATA_BLOB_H_ +#define _MONO_METADATA_BLOB_H_ + +/* + * Encoding for type signatures used in the Metadata + */ +typedef enum { + MONO_TYPE_END = 0x00, /* End of List */ + MONO_TYPE_VOID = 0x01, + MONO_TYPE_BOOLEAN = 0x02, + MONO_TYPE_CHAR = 0x03, + MONO_TYPE_I1 = 0x04, + MONO_TYPE_U1 = 0x05, + MONO_TYPE_I2 = 0x06, + MONO_TYPE_U2 = 0x07, + MONO_TYPE_I4 = 0x08, + MONO_TYPE_U4 = 0x09, + MONO_TYPE_I8 = 0x0a, + MONO_TYPE_U8 = 0x0b, + MONO_TYPE_R4 = 0x0c, + MONO_TYPE_R8 = 0x0d, + MONO_TYPE_STRING = 0x0e, + MONO_TYPE_PTR = 0x0f, /* arg: token */ + MONO_TYPE_BYREF = 0x10, /* arg: token */ + MONO_TYPE_VALUETYPE = 0x11, /* arg: token */ + MONO_TYPE_CLASS = 0x12, /* arg: token */ + MONO_TYPE_VAR = 0x13, /* number */ + MONO_TYPE_ARRAY = 0x14, /* type, rank, boundsCount, bound1, loCount, lo1 */ + MONO_TYPE_GENERICINST= 0x15, /* \x{2026} */ + MONO_TYPE_TYPEDBYREF = 0x16, + MONO_TYPE_I = 0x18, + MONO_TYPE_U = 0x19, + MONO_TYPE_FNPTR = 0x1b, /* arg: full method signature */ + MONO_TYPE_OBJECT = 0x1c, + MONO_TYPE_SZARRAY = 0x1d, /* 0-based one-dim-array */ + MONO_TYPE_MVAR = 0x1e, /* number */ + MONO_TYPE_CMOD_REQD = 0x1f, /* arg: typedef or typeref token */ + MONO_TYPE_CMOD_OPT = 0x20, /* optional arg: typedef or typref token */ + MONO_TYPE_INTERNAL = 0x21, /* CLR internal type */ + + MONO_TYPE_MODIFIER = 0x40, /* Or with the following types */ + MONO_TYPE_SENTINEL = 0x41, /* Sentinel for varargs method signature */ + MONO_TYPE_PINNED = 0x45, /* Local var that points to pinned object */ + + MONO_TYPE_ENUM = 0x55 /* an enumeration */ +} MonoTypeEnum; + +typedef enum { + MONO_TABLE_MODULE, + MONO_TABLE_TYPEREF, + MONO_TABLE_TYPEDEF, + MONO_TABLE_FIELD_POINTER, + MONO_TABLE_FIELD, + MONO_TABLE_METHOD_POINTER, + MONO_TABLE_METHOD, + MONO_TABLE_PARAM_POINTER, + MONO_TABLE_PARAM, + MONO_TABLE_INTERFACEIMPL, + MONO_TABLE_MEMBERREF, /* 0xa */ + MONO_TABLE_CONSTANT, + MONO_TABLE_CUSTOMATTRIBUTE, + MONO_TABLE_FIELDMARSHAL, + MONO_TABLE_DECLSECURITY, + MONO_TABLE_CLASSLAYOUT, + MONO_TABLE_FIELDLAYOUT, /* 0x10 */ + MONO_TABLE_STANDALONESIG, + MONO_TABLE_EVENTMAP, + MONO_TABLE_EVENT_POINTER, + MONO_TABLE_EVENT, + MONO_TABLE_PROPERTYMAP, + MONO_TABLE_PROPERTY_POINTER, + MONO_TABLE_PROPERTY, + MONO_TABLE_METHODSEMANTICS, + MONO_TABLE_METHODIMPL, + MONO_TABLE_MODULEREF, /* 0x1a */ + MONO_TABLE_TYPESPEC, + MONO_TABLE_IMPLMAP, + MONO_TABLE_FIELDRVA, + MONO_TABLE_ENCLOG, + MONO_TABLE_ENCMAP, + MONO_TABLE_ASSEMBLY, /* 0x20 */ + MONO_TABLE_ASSEMBLYPROCESSOR, + MONO_TABLE_ASSEMBLYOS, + MONO_TABLE_ASSEMBLYREF, + MONO_TABLE_ASSEMBLYREFPROCESSOR, + MONO_TABLE_ASSEMBLYREFOS, + MONO_TABLE_FILE, + MONO_TABLE_EXPORTEDTYPE, + MONO_TABLE_MANIFESTRESOURCE, + MONO_TABLE_NESTEDCLASS, + MONO_TABLE_GENERICPARAM, /* 0x2a */ + MONO_TABLE_METHODSPEC, + MONO_TABLE_GENERICPARAMCONSTRAINT, + MONO_TABLE_UNUSED8, + MONO_TABLE_UNUSED9, + MONO_TABLE_UNUSED10, + /* Portable PDB tables */ + MONO_TABLE_DOCUMENT, /* 0x30 */ + MONO_TABLE_METHODBODY, + MONO_TABLE_LOCALSCOPE, + MONO_TABLE_LOCALVARIABLE, + MONO_TABLE_LOCALCONSTANT, + MONO_TABLE_IMPORTSCOPE, + MONO_TABLE_STATEMACHINEMETHOD, + MONO_TABLE_CUSTOMDEBUGINFORMATION + +#define MONO_TABLE_LAST MONO_TABLE_CUSTOMDEBUGINFORMATION +#define MONO_TABLE_NUM (MONO_TABLE_LAST + 1) + +} MonoMetaTableEnum; + +#endif + diff --git a/src/mono/msvc/include/mono/metadata/class.h b/src/mono/msvc/include/mono/metadata/class.h new file mode 100644 index 0000000000000..8966e029b7c6c --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/class.h @@ -0,0 +1,313 @@ +/** + * \file + */ + +#ifndef _MONO_CLI_CLASS_H_ +#define _MONO_CLI_CLASS_H_ + +#include +#include +#include +#include + +MONO_BEGIN_DECLS + +typedef struct MonoVTable MonoVTable; + +typedef struct _MonoClassField MonoClassField; +typedef struct _MonoProperty MonoProperty; +typedef struct _MonoEvent MonoEvent; + +typedef enum { + MONO_TYPE_NAME_FORMAT_IL, + MONO_TYPE_NAME_FORMAT_REFLECTION, + MONO_TYPE_NAME_FORMAT_FULL_NAME, + MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED +} MonoTypeNameFormat; + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClass * +mono_class_get (MonoImage *image, uint32_t type_token); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClass * +mono_class_get_full (MonoImage *image, uint32_t type_token, MonoGenericContext *context); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_class_init (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoVTable * +mono_class_vtable (MonoDomain *domain, MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoClass * +mono_class_from_name (MonoImage *image, const char* name_space, const char *name); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoClass * +mono_class_from_name_case (MonoImage *image, const char* name_space, const char *name); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod * +mono_class_get_method_from_name_flags (MonoClass *klass, const char *name, int param_count, int flags); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoClass * +mono_class_from_typeref (MonoImage *image, uint32_t type_token); + +MONO_API MonoClass * +mono_class_from_typeref_checked (MonoImage *image, uint32_t type_token, MonoError *error); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClass * +mono_class_from_generic_parameter (MonoGenericParam *param, MonoImage *image, mono_bool is_mvar); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoType* +mono_class_inflate_generic_type (MonoType *type, MonoGenericContext *context) /* MONO_DEPRECATED */; + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoMethod* +mono_class_inflate_generic_method (MonoMethod *method, MonoGenericContext *context); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoMethod * +mono_get_inflated_method (MonoMethod *method); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClassField* +mono_field_from_token (MonoImage *image, uint32_t token, MonoClass **retklass, MonoGenericContext *context); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClass * +mono_bounded_array_class_get (MonoClass *element_class, uint32_t rank, mono_bool bounded); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClass * +mono_array_class_get (MonoClass *element_class, uint32_t rank); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClass * +mono_ptr_class_get (MonoType *type); + +MONO_API MonoClassField * +mono_class_get_field (MonoClass *klass, uint32_t field_token); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClassField * +mono_class_get_field_from_name (MonoClass *klass, const char *name); + +MONO_API uint32_t +mono_class_get_field_token (MonoClassField *field); + +MONO_API uint32_t +mono_class_get_event_token (MonoEvent *event); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoProperty * +mono_class_get_property_from_name (MonoClass *klass, const char *name); + +MONO_API uint32_t +mono_class_get_property_token (MonoProperty *prop); + +MONO_API int32_t +mono_array_element_size (MonoClass *ac); + +MONO_API int32_t +mono_class_instance_size (MonoClass *klass); + +MONO_API int32_t +mono_class_array_element_size (MonoClass *klass); + +MONO_API int32_t +mono_class_data_size (MonoClass *klass); + +MONO_API int32_t +mono_class_value_size (MonoClass *klass, uint32_t *align); + +MONO_API int32_t +mono_class_min_align (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoClass * +mono_class_from_mono_type (MonoType *type); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_class_is_subclass_of (MonoClass *klass, MonoClass *klassc, + mono_bool check_interfaces); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_class_is_assignable_from (MonoClass *klass, MonoClass *oklass); + +MONO_API MONO_RT_EXTERNAL_ONLY +void* +mono_ldtoken (MonoImage *image, uint32_t token, MonoClass **retclass, MonoGenericContext *context); + +MONO_API char * +mono_type_get_name_full (MonoType *type, MonoTypeNameFormat format); + +MONO_API char* +mono_type_get_name (MonoType *type); + +MONO_API MonoType* +mono_type_get_underlying_type (MonoType *type); + +/* MonoClass accessors */ +MONO_API MonoImage* +mono_class_get_image (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClass* +mono_class_get_element_class (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY +mono_bool +mono_class_is_valuetype (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY +mono_bool +mono_class_is_enum (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoType* +mono_class_enum_basetype (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClass* +mono_class_get_parent (MonoClass *klass); + +MONO_API MonoClass* +mono_class_get_nesting_type (MonoClass *klass); + +MONO_API int +mono_class_get_rank (MonoClass *klass); + +MONO_API uint32_t +mono_class_get_flags (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY +const char* +mono_class_get_name (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY +const char* +mono_class_get_namespace (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoType* +mono_class_get_type (MonoClass *klass); + +MONO_API uint32_t +mono_class_get_type_token (MonoClass *klass); + +MONO_API MonoType* +mono_class_get_byref_type (MonoClass *klass); + +MONO_API int +mono_class_num_fields (MonoClass *klass); + +MONO_API int +mono_class_num_methods (MonoClass *klass); + +MONO_API int +mono_class_num_properties (MonoClass *klass); + +MONO_API int +mono_class_num_events (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClassField* +mono_class_get_fields (MonoClass* klass, void **iter); + +MONO_API MonoMethod* +mono_class_get_methods (MonoClass* klass, void **iter); + +MONO_API MonoProperty* +mono_class_get_properties (MonoClass* klass, void **iter); + +MONO_API MonoEvent* +mono_class_get_events (MonoClass* klass, void **iter); + +MONO_API MonoClass* +mono_class_get_interfaces (MonoClass* klass, void **iter); + +MONO_API MonoClass* +mono_class_get_nested_types (MonoClass* klass, void **iter); + +MONO_API MONO_RT_EXTERNAL_ONLY +mono_bool +mono_class_is_delegate (MonoClass* klass); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_class_implements_interface (MonoClass* klass, MonoClass* iface); + +/* MonoClassField accessors */ +MONO_API const char* +mono_field_get_name (MonoClassField *field); + +MONO_API MonoType* +mono_field_get_type (MonoClassField *field); + +MONO_API MonoClass* +mono_field_get_parent (MonoClassField *field); + +MONO_API uint32_t +mono_field_get_flags (MonoClassField *field); + +MONO_API uint32_t +mono_field_get_offset (MonoClassField *field); + +MONO_API const char * +mono_field_get_data (MonoClassField *field); + +/* MonoProperty acessors */ +MONO_API const char* +mono_property_get_name (MonoProperty *prop); + +MONO_API MonoMethod* +mono_property_get_set_method (MonoProperty *prop); + +MONO_API MonoMethod* +mono_property_get_get_method (MonoProperty *prop); + +MONO_API MonoClass* +mono_property_get_parent (MonoProperty *prop); + +MONO_API uint32_t +mono_property_get_flags (MonoProperty *prop); + +/* MonoEvent accessors */ +MONO_API const char* +mono_event_get_name (MonoEvent *event); + +MONO_API MonoMethod* +mono_event_get_add_method (MonoEvent *event); + +MONO_API MonoMethod* +mono_event_get_remove_method (MonoEvent *event); + +MONO_API MonoMethod* +mono_event_get_remove_method (MonoEvent *event); + +MONO_API MonoMethod* +mono_event_get_raise_method (MonoEvent *event); + +MONO_API MonoClass* +mono_event_get_parent (MonoEvent *event); + +MONO_API uint32_t +mono_event_get_flags (MonoEvent *event); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod * +mono_class_get_method_from_name (MonoClass *klass, const char *name, int param_count); + +MONO_API char * +mono_class_name_from_token (MonoImage *image, uint32_t type_token); + +MONO_API mono_bool +mono_method_can_access_field (MonoMethod *method, MonoClassField *field); + +MONO_API mono_bool +mono_method_can_access_method (MonoMethod *method, MonoMethod *called); + +MONO_API mono_bool +mono_class_is_nullable (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoClass* +mono_class_get_nullable_param (MonoClass *klass); + +MONO_END_DECLS + +#endif /* _MONO_CLI_CLASS_H_ */ diff --git a/src/mono/msvc/include/mono/metadata/debug-helpers.h b/src/mono/msvc/include/mono/metadata/debug-helpers.h new file mode 100644 index 0000000000000..8ecdf8edc589f --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/debug-helpers.h @@ -0,0 +1,54 @@ +/** + * \file + */ + +#ifndef __MONO_DEBUG_HELPERS_H__ +#define __MONO_DEBUG_HELPERS_H__ + +#include + +MONO_BEGIN_DECLS + +typedef struct MonoDisHelper MonoDisHelper; + +typedef char* (*MonoDisIndenter) (MonoDisHelper *dh, MonoMethod *method, uint32_t ip_offset); +typedef char* (*MonoDisTokener) (MonoDisHelper *dh, MonoMethod *method, uint32_t token); + +struct MonoDisHelper { + const char *newline; + const char *label_format; + const char *label_target; + MonoDisIndenter indenter; + MonoDisTokener tokener; + void* user_data; +}; + +MONO_API char* mono_disasm_code_one (MonoDisHelper *dh, MonoMethod *method, const mono_byte *ip, const mono_byte** endp); +MONO_API char* mono_disasm_code (MonoDisHelper *dh, MonoMethod *method, const mono_byte *ip, const mono_byte* end); + +typedef struct MonoMethodDesc MonoMethodDesc; + +MONO_API char* mono_type_full_name (MonoType *type); + +MONO_API char* mono_signature_get_desc (MonoMethodSignature *sig, mono_bool include_namespace); + +MONO_API char* mono_context_get_desc (MonoGenericContext *context); + +MONO_API MonoMethodDesc* mono_method_desc_new (const char *name, mono_bool include_namespace); +MONO_API MonoMethodDesc* mono_method_desc_from_method (MonoMethod *method); +MONO_API void mono_method_desc_free (MonoMethodDesc *desc); +MONO_API mono_bool mono_method_desc_match (MonoMethodDesc *desc, MonoMethod *method); +MONO_API mono_bool mono_method_desc_is_full (MonoMethodDesc *desc); +MONO_API mono_bool mono_method_desc_full_match (MonoMethodDesc *desc, MonoMethod *method); +MONO_API MonoMethod* mono_method_desc_search_in_class (MonoMethodDesc *desc, MonoClass *klass); +MONO_API MonoMethod* mono_method_desc_search_in_image (MonoMethodDesc *desc, MonoImage *image); + +MONO_API char* mono_method_full_name (MonoMethod *method, mono_bool signature); +MONO_API char* mono_method_get_reflection_name (MonoMethod *method); + +MONO_API char* mono_field_full_name (MonoClassField *field); + +MONO_END_DECLS + +#endif /* __MONO_DEBUG_HELPERS_H__ */ + diff --git a/src/mono/msvc/include/mono/metadata/debug-mono-symfile.h b/src/mono/msvc/include/mono/metadata/debug-mono-symfile.h new file mode 100644 index 0000000000000..cebc943d8506c --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/debug-mono-symfile.h @@ -0,0 +1,114 @@ +/** + * \file + * This header is only installed for use by the debugger: + * the structures and the API declared here are not supported. + * Copyright 2012 Xamarin Inc (http://www.xamarin.com) + * Licensed under the MIT license. See LICENSE file in the project root for full license information. + */ + +#ifndef __MONO_DEBUG_MONO_SYMFILE_H__ +#define __MONO_DEBUG_MONO_SYMFILE_H__ + +#include +#include +#include +#include +#include + +typedef struct MonoSymbolFileOffsetTable MonoSymbolFileOffsetTable; +typedef struct MonoSymbolFileLineNumberEntry MonoSymbolFileLineNumberEntry; +typedef struct MonoSymbolFileMethodAddress MonoSymbolFileMethodAddress; +typedef struct MonoSymbolFileDynamicTable MonoSymbolFileDynamicTable; +typedef struct MonoSymbolFileSourceEntry MonoSymbolFileSourceEntry; +typedef struct MonoSymbolFileMethodEntry MonoSymbolFileMethodEntry; + +/* Keep in sync with OffsetTable in mcs/class/Mono.CSharp.Debugger/MonoSymbolTable.cs */ +struct MonoSymbolFileOffsetTable { + uint32_t _total_file_size; + uint32_t _data_section_offset; + uint32_t _data_section_size; + uint32_t _compile_unit_count; + uint32_t _compile_unit_table_offset; + uint32_t _compile_unit_table_size; + uint32_t _source_count; + uint32_t _source_table_offset; + uint32_t _source_table_size; + uint32_t _method_count; + uint32_t _method_table_offset; + uint32_t _method_table_size; + uint32_t _type_count; + uint32_t _anonymous_scope_count; + uint32_t _anonymous_scope_table_offset; + uint32_t _anonymous_scope_table_size; + uint32_t _line_number_table_line_base; + uint32_t _line_number_table_line_range; + uint32_t _line_number_table_opcode_base; + uint32_t _is_aspx_source; +}; + +struct MonoSymbolFileSourceEntry { + uint32_t _index; + uint32_t _data_offset; +}; + +struct MonoSymbolFileMethodEntry { + uint32_t _token; + uint32_t _data_offset; + uint32_t _line_number_table; +}; + +struct MonoSymbolFileMethodAddress { + uint32_t size; + const uint8_t *start_address; + const uint8_t *end_address; + const uint8_t *method_start_address; + const uint8_t *method_end_address; + const uint8_t *wrapper_address; + uint32_t has_this; + uint32_t num_params; + uint32_t variable_table_offset; + uint32_t type_table_offset; + uint32_t num_line_numbers; + uint32_t line_number_offset; + uint8_t data [MONO_ZERO_LEN_ARRAY]; +}; + +#define MONO_SYMBOL_FILE_MAJOR_VERSION 50 +#define MONO_SYMBOL_FILE_MINOR_VERSION 0 +#define MONO_SYMBOL_FILE_MAGIC 0x45e82623fd7fa614ULL + +MONO_BEGIN_DECLS + +MONO_API MonoSymbolFile * +mono_debug_open_mono_symbols (MonoDebugHandle *handle, + const uint8_t *raw_contents, + int size, + mono_bool in_the_debugger); + +MONO_API void +mono_debug_close_mono_symbol_file (MonoSymbolFile *symfile); + +MONO_API mono_bool +mono_debug_symfile_is_loaded (MonoSymbolFile *symfile); + +MONO_API MonoDebugSourceLocation * +mono_debug_symfile_lookup_location (MonoDebugMethodInfo *minfo, + uint32_t offset); + +MONO_API void +mono_debug_symfile_free_location (MonoDebugSourceLocation *location); + +MONO_API MonoDebugMethodInfo * +mono_debug_symfile_lookup_method (MonoDebugHandle *handle, + MonoMethod *method); + +MONO_API MonoDebugLocalsInfo* +mono_debug_symfile_lookup_locals (MonoDebugMethodInfo *minfo); + +void +mono_debug_symfile_get_seq_points (MonoDebugMethodInfo *minfo, char **source_file, GPtrArray **source_file_list, int **source_files, MonoSymSeqPoint **seq_points, int *n_seq_points); + +MONO_END_DECLS + +#endif /* __MONO_SYMFILE_H__ */ + diff --git a/src/mono/msvc/include/mono/metadata/environment.h b/src/mono/msvc/include/mono/metadata/environment.h new file mode 100644 index 0000000000000..1fb5a57b31ecb --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/environment.h @@ -0,0 +1,23 @@ +/** + * \file + * System.Environment support internal calls + * + * Author: + * Dick Porter (dick@ximian.com) + * + * (C) 2002 Ximian, Inc + */ + +#ifndef _MONO_METADATA_ENVIRONMENT_H_ +#define _MONO_METADATA_ENVIRONMENT_H_ + +#include + +MONO_BEGIN_DECLS + +MONO_API int32_t mono_environment_exitcode_get (void); +MONO_API void mono_environment_exitcode_set (int32_t value); + +MONO_END_DECLS + +#endif /* _MONO_METADATA_ENVIRONMENT_H_ */ diff --git a/src/mono/msvc/include/mono/metadata/exception.h b/src/mono/msvc/include/mono/metadata/exception.h new file mode 100644 index 0000000000000..155c23c7e7747 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/exception.h @@ -0,0 +1,177 @@ +/** + * \file + */ + +#ifndef _MONO_METADATA_EXCEPTION_H_ +#define _MONO_METADATA_EXCEPTION_H_ + +#include +#include +#include + +MONO_BEGIN_DECLS + +MONO_API MonoException * +mono_exception_from_name (MonoImage *image, + const char* name_space, + const char *name); + +MONO_API MonoException * +mono_exception_from_token (MonoImage *image, uint32_t token); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_exception_from_name_two_strings (MonoImage *image, const char *name_space, + const char *name, MonoString *a1, MonoString *a2); + +MONO_API MonoException * +mono_exception_from_name_msg (MonoImage *image, const char *name_space, + const char *name, const char *msg); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_exception_from_token_two_strings (MonoImage *image, uint32_t token, + MonoString *a1, MonoString *a2); + +MONO_API MonoException * +mono_exception_from_name_domain (MonoDomain *domain, MonoImage *image, + const char* name_space, + const char *name); + +MONO_API MonoException * +mono_get_exception_divide_by_zero (void); + +MONO_API MonoException * +mono_get_exception_security (void); + +MONO_API MonoException * +mono_get_exception_arithmetic (void); + +MONO_API MonoException * +mono_get_exception_overflow (void); + +MONO_API MonoException * +mono_get_exception_null_reference (void); + +MONO_API MonoException * +mono_get_exception_execution_engine (const char *msg); + +MONO_API MonoException * +mono_get_exception_thread_abort (void); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_thread_state (const char *msg); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_thread_interrupted (void); + +MONO_API MonoException * +mono_get_exception_serialization (const char *msg); + +MONO_API MonoException * +mono_get_exception_invalid_cast (void); + +MONO_API MonoException * +mono_get_exception_invalid_operation (const char *msg); + +MONO_API MonoException * +mono_get_exception_index_out_of_range (void); + +MONO_API MonoException * +mono_get_exception_array_type_mismatch (void); + +MONO_API MonoException * +mono_get_exception_type_load (MonoString *class_name, char *assembly_name); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_missing_method (const char *class_name, const char *member_name); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_missing_field (const char *class_name, const char *member_name); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_not_implemented (const char *msg); + +MONO_API MonoException * +mono_get_exception_not_supported (const char *msg); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoException* +mono_get_exception_argument_null (const char *arg); + +MONO_API MonoException * +mono_get_exception_argument (const char *arg, const char *msg); + +MONO_API MonoException * +mono_get_exception_argument_out_of_range (const char *arg); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_io (const char *msg); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_file_not_found (MonoString *fname); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_file_not_found2 (const char *msg, MonoString *fname); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_type_initialization (const char *type_name, MonoException *inner); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_synchronization_lock (const char *msg); + +MONO_API MonoException * +mono_get_exception_cannot_unload_appdomain (const char *msg); + +MONO_API MonoException * +mono_get_exception_appdomain_unloaded (void); + +MONO_API MonoException * +mono_get_exception_bad_image_format (const char *msg); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_bad_image_format2 (const char *msg, MonoString *fname); + +MONO_API MonoException * +mono_get_exception_stack_overflow (void); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_out_of_memory (void); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_field_access (void); + +MONO_API MonoException * +mono_get_exception_method_access (void); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_reflection_type_load (MonoArray *types, MonoArray *exceptions); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoException * +mono_get_exception_runtime_wrapped (MonoObject *wrapped_exception); + +/* Installs a function which is called when the runtime encounters an unhandled exception. + * This hook isn't expected to return. + * If no hook has been installed, the runtime will print a message before aborting. + */ +typedef void (*MonoUnhandledExceptionFunc) (MonoObject *exc, void *user_data); +MONO_API void mono_install_unhandled_exception_hook (MonoUnhandledExceptionFunc func, void *user_data); +void mono_invoke_unhandled_exception_hook (MonoObject *exc); + +MONO_END_DECLS + +#endif /* _MONO_METADATA_EXCEPTION_H_ */ diff --git a/src/mono/msvc/include/mono/metadata/image.h b/src/mono/msvc/include/mono/metadata/image.h new file mode 100644 index 0000000000000..4ef0f5a341bd0 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/image.h @@ -0,0 +1,99 @@ +/** + * \file + */ + +#ifndef _MONONET_METADATA_IMAGE_H_ +#define _MONONET_METADATA_IMAGE_H_ + +#include +#include +#include +#include + +MONO_BEGIN_DECLS + +typedef struct _MonoAssembly MonoAssembly; +typedef struct _MonoAssemblyName MonoAssemblyName; +typedef struct _MonoTableInfo MonoTableInfo; + +typedef enum { + MONO_IMAGE_OK, + MONO_IMAGE_ERROR_ERRNO, + MONO_IMAGE_MISSING_ASSEMBLYREF, + MONO_IMAGE_IMAGE_INVALID +} MonoImageOpenStatus; + +MONO_API void mono_images_init (void); +MONO_API void mono_images_cleanup (void); + +MONO_API MonoImage *mono_image_open (const char *fname, + MonoImageOpenStatus *status); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoImage *mono_image_open_full (const char *fname, + MonoImageOpenStatus *status, mono_bool refonly); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoImage *mono_pe_file_open (const char *fname, + MonoImageOpenStatus *status); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoImage *mono_image_open_from_data (char *data, uint32_t data_len, mono_bool need_copy, + MonoImageOpenStatus *status); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoImage *mono_image_open_from_data_full (char *data, uint32_t data_len, mono_bool need_copy, + MonoImageOpenStatus *status, mono_bool refonly); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoImage *mono_image_open_from_data_with_name (char *data, uint32_t data_len, mono_bool need_copy, + MonoImageOpenStatus *status, mono_bool refonly, const char *name); +MONO_API void mono_image_fixup_vtable (MonoImage *image); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoImage *mono_image_loaded (const char *name); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoImage *mono_image_loaded_full (const char *name, mono_bool refonly); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoImage *mono_image_loaded_by_guid (const char *guid); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoImage *mono_image_loaded_by_guid_full (const char *guid, mono_bool refonly); +MONO_API void mono_image_init (MonoImage *image); +MONO_API void mono_image_close (MonoImage *image); +MONO_API void mono_image_addref (MonoImage *image); +MONO_API const char *mono_image_strerror (MonoImageOpenStatus status); + +MONO_API int mono_image_ensure_section (MonoImage *image, + const char *section); +MONO_API int mono_image_ensure_section_idx (MonoImage *image, + int section); + +MONO_API uint32_t mono_image_get_entry_point (MonoImage *image); +MONO_API const char *mono_image_get_resource (MonoImage *image, uint32_t offset, uint32_t *size); +MONO_API MONO_RT_EXTERNAL_ONLY MonoImage* mono_image_load_file_for_image (MonoImage *image, int fileidx); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoImage* mono_image_load_module (MonoImage *image, int idx); + +MONO_API const char* mono_image_get_name (MonoImage *image); +MONO_API const char* mono_image_get_filename (MonoImage *image); +MONO_API const char * mono_image_get_guid (MonoImage *image); +MONO_API MonoAssembly* mono_image_get_assembly (MonoImage *image); +MONO_API mono_bool mono_image_is_dynamic (MonoImage *image); +MONO_API char* mono_image_rva_map (MonoImage *image, uint32_t rva); + +MONO_API const MonoTableInfo *mono_image_get_table_info (MonoImage *image, int table_id); +MONO_API int mono_image_get_table_rows (MonoImage *image, int table_id); +MONO_API int mono_table_info_get_rows (const MonoTableInfo *table); + +/* This actually returns a MonoPEResourceDataEntry *, but declaring it + * causes an include file loop. + */ +MONO_API void* mono_image_lookup_resource (MonoImage *image, uint32_t res_id, + uint32_t lang_id, mono_unichar2 *name); + +MONO_API const char* mono_image_get_public_key (MonoImage *image, uint32_t *size); +MONO_API const char* mono_image_get_strong_name (MonoImage *image, uint32_t *size); +MONO_API uint32_t mono_image_strong_name_position (MonoImage *image, uint32_t *size); +MONO_API void mono_image_add_to_name_cache (MonoImage *image, + const char *nspace, const char *name, uint32_t idx); +MONO_API mono_bool mono_image_has_authenticode_entry (MonoImage *image); + +mono_bool mono_has_pdb_checksum (char *raw_data, uint32_t raw_data_len); + +MONO_END_DECLS + +#endif diff --git a/src/mono/msvc/include/mono/metadata/loader.h b/src/mono/msvc/include/mono/metadata/loader.h new file mode 100644 index 0000000000000..42c89288fcc6e --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/loader.h @@ -0,0 +1,109 @@ +/** + * \file + */ + +#ifndef _MONO_METADATA_LOADER_H_ +#define _MONO_METADATA_LOADER_H_ 1 + +#include +#include +#include +#include + +MONO_BEGIN_DECLS + +typedef mono_bool (*MonoStackWalk) (MonoMethod *method, int32_t native_offset, int32_t il_offset, mono_bool managed, void* data); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod * +mono_get_method (MonoImage *image, uint32_t token, MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod * +mono_get_method_full (MonoImage *image, uint32_t token, MonoClass *klass, + MonoGenericContext *context); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod * +mono_get_method_constrained (MonoImage *image, uint32_t token, MonoClass *constrained_class, + MonoGenericContext *context, MonoMethod **cil_method); + +MONO_API void +mono_free_method (MonoMethod *method); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethodSignature* +mono_method_get_signature_full (MonoMethod *method, MonoImage *image, uint32_t token, + MonoGenericContext *context); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethodSignature* +mono_method_get_signature (MonoMethod *method, MonoImage *image, uint32_t token); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethodSignature* +mono_method_signature (MonoMethod *method); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethodHeader* +mono_method_get_header (MonoMethod *method); + +MONO_API const char* +mono_method_get_name (MonoMethod *method); + +MONO_API MonoClass* +mono_method_get_class (MonoMethod *method); + +MONO_API uint32_t +mono_method_get_token (MonoMethod *method); + +MONO_API uint32_t +mono_method_get_flags (MonoMethod *method, uint32_t *iflags); + +MONO_API uint32_t +mono_method_get_index (MonoMethod *method); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_add_internal_call (const char *name, const void* method); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_dangerous_add_raw_internal_call (const char *name, const void* method); + +MONO_API void* +mono_lookup_internal_call (MonoMethod *method); + +MONO_API const char* +mono_lookup_icall_symbol (MonoMethod *m); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_dllmap_insert (MonoImage *assembly, const char *dll, const char *func, const char *tdll, const char *tfunc); + +MONO_API MONO_RT_EXTERNAL_ONLY void* +mono_lookup_pinvoke_call (MonoMethod *method, const char **exc_class, const char **exc_arg); + +MONO_API void +mono_method_get_param_names (MonoMethod *method, const char **names); + +MONO_API uint32_t +mono_method_get_param_token (MonoMethod *method, int idx); + +MONO_API void +mono_method_get_marshal_info (MonoMethod *method, MonoMarshalSpec **mspecs); + +MONO_API mono_bool +mono_method_has_marshal_info (MonoMethod *method); + +MONO_API MonoMethod* +mono_method_get_last_managed (void); + +MONO_API void +mono_stack_walk (MonoStackWalk func, void* user_data); + +/* Use this if the IL offset is not needed: it's faster */ +MONO_API void +mono_stack_walk_no_il (MonoStackWalk func, void* user_data); + +typedef mono_bool (*MonoStackWalkAsyncSafe) (MonoMethod *method, MonoDomain *domain, void *base_address, int offset, void* data); +MONO_API void +mono_stack_walk_async_safe (MonoStackWalkAsyncSafe func, void *initial_sig_context, void* user_data); + +MONO_API MonoMethodHeader* +mono_method_get_header_checked (MonoMethod *method, MonoError *error); + +MONO_END_DECLS + +#endif + diff --git a/src/mono/msvc/include/mono/metadata/metadata.h b/src/mono/msvc/include/mono/metadata/metadata.h new file mode 100644 index 0000000000000..965b06a86c195 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/metadata.h @@ -0,0 +1,517 @@ +/** + * \file + */ + +#ifndef __MONO_METADATA_H__ +#define __MONO_METADATA_H__ + +#include + +#include +#include +#include +#include +#include + +MONO_BEGIN_DECLS + +#define MONO_TYPE_ISSTRUCT(t) mono_type_is_struct (t) +#define MONO_TYPE_IS_VOID(t) mono_type_is_void (t) +#define MONO_TYPE_IS_POINTER(t) mono_type_is_pointer (t) +#define MONO_TYPE_IS_REFERENCE(t) mono_type_is_reference (t) + +#define MONO_CLASS_IS_INTERFACE(c) ((mono_class_get_flags (c) & TYPE_ATTRIBUTE_INTERFACE) || mono_type_is_generic_parameter (mono_class_get_type (c))) + +#define MONO_CLASS_IS_IMPORT(c) ((mono_class_get_flags (c) & TYPE_ATTRIBUTE_IMPORT)) + +typedef enum { + MONO_EXCEPTION_CLAUSE_NONE, + MONO_EXCEPTION_CLAUSE_FILTER, + MONO_EXCEPTION_CLAUSE_FINALLY, + MONO_EXCEPTION_CLAUSE_FAULT = 4 +} MonoExceptionEnum; + +typedef enum { + MONO_CALL_DEFAULT, + MONO_CALL_C, + MONO_CALL_STDCALL, + MONO_CALL_THISCALL, + MONO_CALL_FASTCALL, + MONO_CALL_VARARG +} MonoCallConvention; + +/* ECMA lamespec: the old spec had more info... */ +typedef enum { + MONO_NATIVE_BOOLEAN = 0x02, /* 4 bytes, 0 is false, != 0 is true */ + MONO_NATIVE_I1 = 0x03, + MONO_NATIVE_U1 = 0x04, + MONO_NATIVE_I2 = 0x05, + MONO_NATIVE_U2 = 0x06, + MONO_NATIVE_I4 = 0x07, + MONO_NATIVE_U4 = 0x08, + MONO_NATIVE_I8 = 0x09, + MONO_NATIVE_U8 = 0x0a, + MONO_NATIVE_R4 = 0x0b, + MONO_NATIVE_R8 = 0x0c, + MONO_NATIVE_CURRENCY = 0x0f, + MONO_NATIVE_BSTR = 0x13, /* prefixed length, Unicode */ + MONO_NATIVE_LPSTR = 0x14, /* ANSI, null terminated */ + MONO_NATIVE_LPWSTR = 0x15, /* UNICODE, null terminated */ + MONO_NATIVE_LPTSTR = 0x16, /* plattform dep., null terminated */ + MONO_NATIVE_BYVALTSTR = 0x17, + MONO_NATIVE_IUNKNOWN = 0x19, + MONO_NATIVE_IDISPATCH = 0x1a, + MONO_NATIVE_STRUCT = 0x1b, + MONO_NATIVE_INTERFACE = 0x1c, + MONO_NATIVE_SAFEARRAY = 0x1d, + MONO_NATIVE_BYVALARRAY = 0x1e, + MONO_NATIVE_INT = 0x1f, + MONO_NATIVE_UINT = 0x20, + MONO_NATIVE_VBBYREFSTR = 0x22, + MONO_NATIVE_ANSIBSTR = 0x23, /* prefixed length, ANSI */ + MONO_NATIVE_TBSTR = 0x24, /* prefixed length, plattform dep. */ + MONO_NATIVE_VARIANTBOOL = 0x25, + MONO_NATIVE_FUNC = 0x26, + MONO_NATIVE_ASANY = 0x28, + MONO_NATIVE_LPARRAY = 0x2a, + MONO_NATIVE_LPSTRUCT = 0x2b, + MONO_NATIVE_CUSTOM = 0x2c, + MONO_NATIVE_ERROR = 0x2d, + // TODO: MONO_NATIVE_IINSPECTABLE = 0x2e + // TODO: MONO_NATIVE_HSTRING = 0x2f + MONO_NATIVE_UTF8STR = 0x30, + MONO_NATIVE_MAX = 0x50 /* no info */ +} MonoMarshalNative; + +/* Used only in context of SafeArray */ +typedef enum { + MONO_VARIANT_EMPTY = 0x00, + MONO_VARIANT_NULL = 0x01, + MONO_VARIANT_I2 = 0x02, + MONO_VARIANT_I4 = 0x03, + MONO_VARIANT_R4 = 0x04, + MONO_VARIANT_R8 = 0x05, + MONO_VARIANT_CY = 0x06, + MONO_VARIANT_DATE = 0x07, + MONO_VARIANT_BSTR = 0x08, + MONO_VARIANT_DISPATCH = 0x09, + MONO_VARIANT_ERROR = 0x0a, + MONO_VARIANT_BOOL = 0x0b, + MONO_VARIANT_VARIANT = 0x0c, + MONO_VARIANT_UNKNOWN = 0x0d, + MONO_VARIANT_DECIMAL = 0x0e, + MONO_VARIANT_I1 = 0x10, + MONO_VARIANT_UI1 = 0x11, + MONO_VARIANT_UI2 = 0x12, + MONO_VARIANT_UI4 = 0x13, + MONO_VARIANT_I8 = 0x14, + MONO_VARIANT_UI8 = 0x15, + MONO_VARIANT_INT = 0x16, + MONO_VARIANT_UINT = 0x17, + MONO_VARIANT_VOID = 0x18, + MONO_VARIANT_HRESULT = 0x19, + MONO_VARIANT_PTR = 0x1a, + MONO_VARIANT_SAFEARRAY = 0x1b, + MONO_VARIANT_CARRAY = 0x1c, + MONO_VARIANT_USERDEFINED = 0x1d, + MONO_VARIANT_LPSTR = 0x1e, + MONO_VARIANT_LPWSTR = 0x1f, + MONO_VARIANT_RECORD = 0x24, + MONO_VARIANT_FILETIME = 0x40, + MONO_VARIANT_BLOB = 0x41, + MONO_VARIANT_STREAM = 0x42, + MONO_VARIANT_STORAGE = 0x43, + MONO_VARIANT_STREAMED_OBJECT = 0x44, + MONO_VARIANT_STORED_OBJECT = 0x45, + MONO_VARIANT_BLOB_OBJECT = 0x46, + MONO_VARIANT_CF = 0x47, + MONO_VARIANT_CLSID = 0x48, + MONO_VARIANT_VECTOR = 0x1000, + MONO_VARIANT_ARRAY = 0x2000, + MONO_VARIANT_BYREF = 0x4000 +} MonoMarshalVariant; + +typedef enum { + MONO_MARSHAL_CONV_NONE, + MONO_MARSHAL_CONV_BOOL_VARIANTBOOL, + MONO_MARSHAL_CONV_BOOL_I4, + MONO_MARSHAL_CONV_STR_BSTR, + MONO_MARSHAL_CONV_STR_LPSTR, + MONO_MARSHAL_CONV_LPSTR_STR, + MONO_MARSHAL_CONV_LPTSTR_STR, + MONO_MARSHAL_CONV_STR_LPWSTR, + MONO_MARSHAL_CONV_LPWSTR_STR, + MONO_MARSHAL_CONV_STR_LPTSTR, + MONO_MARSHAL_CONV_STR_ANSIBSTR, + MONO_MARSHAL_CONV_STR_TBSTR, + MONO_MARSHAL_CONV_STR_BYVALSTR, + MONO_MARSHAL_CONV_STR_BYVALWSTR, + MONO_MARSHAL_CONV_SB_LPSTR, + MONO_MARSHAL_CONV_SB_LPTSTR, + MONO_MARSHAL_CONV_SB_LPWSTR, + MONO_MARSHAL_CONV_LPSTR_SB, + MONO_MARSHAL_CONV_LPTSTR_SB, + MONO_MARSHAL_CONV_LPWSTR_SB, + MONO_MARSHAL_CONV_ARRAY_BYVALARRAY, + MONO_MARSHAL_CONV_ARRAY_BYVALCHARARRAY, + MONO_MARSHAL_CONV_ARRAY_SAVEARRAY, + MONO_MARSHAL_CONV_ARRAY_LPARRAY, + MONO_MARSHAL_FREE_LPARRAY, + MONO_MARSHAL_CONV_OBJECT_INTERFACE, + MONO_MARSHAL_CONV_OBJECT_IDISPATCH, + MONO_MARSHAL_CONV_OBJECT_IUNKNOWN, + MONO_MARSHAL_CONV_OBJECT_STRUCT, + MONO_MARSHAL_CONV_DEL_FTN, + MONO_MARSHAL_CONV_FTN_DEL, + MONO_MARSHAL_FREE_ARRAY, + MONO_MARSHAL_CONV_BSTR_STR, + MONO_MARSHAL_CONV_SAFEHANDLE, + MONO_MARSHAL_CONV_HANDLEREF, + MONO_MARSHAL_CONV_STR_UTF8STR, + MONO_MARSHAL_CONV_SB_UTF8STR, + MONO_MARSHAL_CONV_UTF8STR_STR, + MONO_MARSHAL_CONV_UTF8STR_SB, + MONO_MARSHAL_CONV_FIXED_BUFFER, + MONO_MARSHAL_CONV_ANSIBSTR_STR, + MONO_MARSHAL_CONV_TBSTR_STR +} MonoMarshalConv; + +#define MONO_MARSHAL_CONV_INVALID ((MonoMarshalConv)-1) + +typedef struct { + MonoMarshalNative native; + union { + struct { + MonoMarshalNative elem_type; + int32_t num_elem; /* -1 if not set */ + int16_t param_num; /* -1 if not set */ + int16_t elem_mult; /* -1 if not set */ + } array_data; + struct { + char *custom_name; + char *cookie; + MonoImage *image; + } custom_data; + struct { + MonoMarshalVariant elem_type; + int32_t num_elem; + } safearray_data; + } data; +} MonoMarshalSpec; + +MONO_API void mono_metadata_init (void); + +MONO_API void mono_metadata_decode_row (const MonoTableInfo *t, + int idx, + uint32_t *res, + int res_size); + +MONO_API uint32_t mono_metadata_decode_row_col (const MonoTableInfo *t, + int idx, + unsigned int col); + +/* + * This macro is used to extract the size of the table encoded in + * the size_bitfield of MonoTableInfo. + */ +#define mono_metadata_table_size(bitfield,table) ((((bitfield) >> ((table)*2)) & 0x3) + 1) +#define mono_metadata_table_count(bitfield) ((bitfield) >> 24) + +MONO_API int mono_metadata_compute_size (MonoImage *meta, + int tableindex, + uint32_t *result_bitfield); + +/* + * + */ +MONO_API const char *mono_metadata_locate (MonoImage *meta, int table, int idx); +MONO_API const char *mono_metadata_locate_token (MonoImage *meta, uint32_t token); + +MONO_API const char *mono_metadata_string_heap (MonoImage *meta, uint32_t table_index); +MONO_API const char *mono_metadata_blob_heap (MonoImage *meta, uint32_t table_index); +MONO_API const char *mono_metadata_user_string (MonoImage *meta, uint32_t table_index); +MONO_API const char *mono_metadata_guid_heap (MonoImage *meta, uint32_t table_index); + +MONO_API uint32_t mono_metadata_typedef_from_field (MonoImage *meta, uint32_t table_index); +MONO_API uint32_t mono_metadata_typedef_from_method (MonoImage *meta, uint32_t table_index); +MONO_API uint32_t mono_metadata_nested_in_typedef (MonoImage *meta, uint32_t table_index); +MONO_API uint32_t mono_metadata_nesting_typedef (MonoImage *meta, uint32_t table_index, uint32_t start_index); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoClass** mono_metadata_interfaces_from_typedef (MonoImage *meta, uint32_t table_index, unsigned int *count); + +MONO_API uint32_t mono_metadata_events_from_typedef (MonoImage *meta, uint32_t table_index, unsigned int *end_idx); +MONO_API uint32_t mono_metadata_methods_from_event (MonoImage *meta, uint32_t table_index, unsigned int *end); +MONO_API uint32_t mono_metadata_properties_from_typedef (MonoImage *meta, uint32_t table_index, unsigned int *end); +MONO_API uint32_t mono_metadata_methods_from_property (MonoImage *meta, uint32_t table_index, unsigned int *end); +MONO_API uint32_t mono_metadata_packing_from_typedef (MonoImage *meta, uint32_t table_index, uint32_t *packing, uint32_t *size); +MONO_API const char* mono_metadata_get_marshal_info (MonoImage *meta, uint32_t idx, mono_bool is_field); +MONO_API uint32_t mono_metadata_custom_attrs_from_index (MonoImage *meta, uint32_t cattr_index); + +MONO_API MonoMarshalSpec *mono_metadata_parse_marshal_spec (MonoImage *image, const char *ptr); + +MONO_API void mono_metadata_free_marshal_spec (MonoMarshalSpec *spec); + +MONO_API uint32_t mono_metadata_implmap_from_method (MonoImage *meta, uint32_t method_idx); + +MONO_API void mono_metadata_field_info (MonoImage *meta, + uint32_t table_index, + uint32_t *offset, + uint32_t *rva, + MonoMarshalSpec **marshal_spec); + +MONO_API uint32_t mono_metadata_get_constant_index (MonoImage *meta, uint32_t token, uint32_t hint); + +/* + * Functions to extract information from the Blobs + */ +MONO_API uint32_t mono_metadata_decode_value (const char *ptr, + const char **rptr); +MONO_API int32_t mono_metadata_decode_signed_value (const char *ptr, const char **rptr); + +MONO_API uint32_t mono_metadata_decode_blob_size (const char *ptr, + const char **rptr); + +MONO_API void mono_metadata_encode_value (uint32_t value, char *bug, char **endbuf); + +#define MONO_OFFSET_IN_CLAUSE(clause,offset) \ + ((clause)->try_offset <= (offset) && (offset) < ((clause)->try_offset + (clause)->try_len)) +#define MONO_OFFSET_IN_HANDLER(clause,offset) \ + ((clause)->handler_offset <= (offset) && (offset) < ((clause)->handler_offset + (clause)->handler_len)) +#define MONO_OFFSET_IN_FILTER(clause,offset) \ + ((clause)->flags == MONO_EXCEPTION_CLAUSE_FILTER && (clause)->data.filter_offset <= (offset) && (offset) < ((clause)->handler_offset)) + +typedef struct { + uint32_t flags; + uint32_t try_offset; + uint32_t try_len; + uint32_t handler_offset; + uint32_t handler_len; + union { + uint32_t filter_offset; + MonoClass *catch_class; + } data; +} MonoExceptionClause; + +typedef struct _MonoType MonoType; +typedef struct _MonoGenericInst MonoGenericInst; +typedef struct _MonoGenericClass MonoGenericClass; +typedef struct _MonoGenericContext MonoGenericContext; +typedef struct _MonoGenericContainer MonoGenericContainer; +typedef struct _MonoGenericParam MonoGenericParam; +typedef struct _MonoArrayType MonoArrayType; +typedef struct _MonoMethodSignature MonoMethodSignature; + +/* FIXME: Keeping this name alive for now, since it is part of the exposed API, even though no entrypoint uses it. */ +typedef struct invalid_name MonoGenericMethod; + +typedef struct { + unsigned int required : 1; + unsigned int token : 31; +} MonoCustomMod; + +typedef struct _MonoCustomModContainer { + uint8_t count; /* max 64 modifiers follow at the end */ + MonoImage *image; /* Image containing types in modifiers array */ + MonoCustomMod modifiers [1]; /* Actual length is count */ +} MonoCustomModContainer; + +struct _MonoArrayType { + MonoClass *eklass; + // Number of dimensions of the array + uint8_t rank; + + // Arrays recording known upper and lower index bounds for each dimension + uint8_t numsizes; + uint8_t numlobounds; + int *sizes; + int *lobounds; +}; + +typedef struct _MonoMethodHeader MonoMethodHeader; + +typedef enum { + MONO_PARSE_TYPE, + MONO_PARSE_MOD_TYPE, + MONO_PARSE_LOCAL, + MONO_PARSE_PARAM, + MONO_PARSE_RET, + MONO_PARSE_FIELD +} MonoParseTypeMode; + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_type_is_byref (MonoType *type); + +MONO_API MONO_RT_EXTERNAL_ONLY int +mono_type_get_type (MonoType *type); + +/* For MONO_TYPE_FNPTR */ +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethodSignature* +mono_type_get_signature (MonoType *type); + +/* For MONO_TYPE_CLASS, VALUETYPE */ +MONO_API MONO_RT_EXTERNAL_ONLY MonoClass* +mono_type_get_class (MonoType *type); + +MONO_API MonoArrayType* +mono_type_get_array_type (MonoType *type); + +/* For MONO_TYPE_PTR */ +MONO_API MonoType* +mono_type_get_ptr_type (MonoType *type); + +MONO_API MonoClass* +mono_type_get_modifiers (MonoType *type, mono_bool *is_required, void **iter); + +MONO_API mono_bool mono_type_is_struct (MonoType *type); +MONO_API mono_bool mono_type_is_void (MonoType *type); +MONO_API mono_bool mono_type_is_pointer (MonoType *type); +MONO_API mono_bool mono_type_is_reference (MonoType *type); +MONO_API mono_bool mono_type_is_generic_parameter (MonoType *type); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoType* +mono_signature_get_return_type (MonoMethodSignature *sig); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoType* +mono_signature_get_params (MonoMethodSignature *sig, void **iter); + +MONO_API uint32_t +mono_signature_get_param_count (MonoMethodSignature *sig); + +MONO_API uint32_t +mono_signature_get_call_conv (MonoMethodSignature *sig); + +MONO_API int +mono_signature_vararg_start (MonoMethodSignature *sig); + +MONO_API mono_bool +mono_signature_is_instance (MonoMethodSignature *sig); + +MONO_API mono_bool +mono_signature_explicit_this (MonoMethodSignature *sig); + +MONO_API mono_bool +mono_signature_param_is_out (MonoMethodSignature *sig, int param_num); + +MONO_API uint32_t mono_metadata_parse_typedef_or_ref (MonoImage *m, + const char *ptr, + const char **rptr); +MONO_API int mono_metadata_parse_custom_mod (MonoImage *m, + MonoCustomMod *dest, + const char *ptr, + const char **rptr); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoArrayType *mono_metadata_parse_array (MonoImage *m, + const char *ptr, + const char **rptr); +MONO_API void mono_metadata_free_array (MonoArrayType *array); +MONO_API MONO_RT_EXTERNAL_ONLY MonoType *mono_metadata_parse_type (MonoImage *m, + MonoParseTypeMode mode, + short opt_attrs, + const char *ptr, + const char **rptr); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoType *mono_metadata_parse_param (MonoImage *m, + const char *ptr, + const char **rptr); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoType *mono_metadata_parse_field_type (MonoImage *m, + short field_flags, + const char *ptr, + const char **rptr); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoType *mono_type_create_from_typespec (MonoImage *image, + uint32_t type_spec); +MONO_API void mono_metadata_free_type (MonoType *type); +MONO_API int mono_type_size (MonoType *type, + int *alignment); +MONO_API int mono_type_stack_size (MonoType *type, + int *alignment); + +MONO_API mono_bool mono_type_generic_inst_is_valuetype (MonoType *type); +MONO_API mono_bool mono_metadata_generic_class_is_valuetype (MonoGenericClass *gclass); + +MONO_API unsigned int mono_metadata_type_hash (MonoType *t1); +MONO_API mono_bool mono_metadata_type_equal (MonoType *t1, MonoType *t2); + +MONO_API MonoMethodSignature *mono_metadata_signature_alloc (MonoImage *image, uint32_t nparams); + +MONO_API MonoMethodSignature *mono_metadata_signature_dup (MonoMethodSignature *sig); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoMethodSignature *mono_metadata_parse_signature (MonoImage *image, + uint32_t token); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoMethodSignature *mono_metadata_parse_method_signature (MonoImage *m, + int def, + const char *ptr, + const char **rptr); +MONO_API void mono_metadata_free_method_signature (MonoMethodSignature *method); + +MONO_API mono_bool mono_metadata_signature_equal (MonoMethodSignature *sig1, + MonoMethodSignature *sig2); + +MONO_API unsigned int mono_signature_hash (MonoMethodSignature *sig); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoMethodHeader *mono_metadata_parse_mh (MonoImage *m, const char *ptr); +MONO_API void mono_metadata_free_mh (MonoMethodHeader *mh); + +/* MonoMethodHeader accessors */ +MONO_API const unsigned char* +mono_method_header_get_code (MonoMethodHeader *header, uint32_t* code_size, uint32_t* max_stack); + +MONO_API MonoType** +mono_method_header_get_locals (MonoMethodHeader *header, uint32_t* num_locals, mono_bool *init_locals); + +MONO_API int +mono_method_header_get_num_clauses (MonoMethodHeader *header); + +MONO_API int +mono_method_header_get_clauses (MonoMethodHeader *header, MonoMethod *method, void **iter, MonoExceptionClause *clause); + +MONO_API uint32_t +mono_type_to_unmanaged (MonoType *type, MonoMarshalSpec *mspec, + mono_bool as_field, mono_bool unicode, MonoMarshalConv *conv); + +/* + * Makes a token based on a table and an index + */ +#define mono_metadata_make_token(table,idx) (((table) << 24)| (idx)) + +/* + * Returns the table index that this token encodes. + */ +#define mono_metadata_token_table(token) ((token) >> 24) + + /* + * Returns the index that a token refers to + */ +#define mono_metadata_token_index(token) ((token) & 0xffffff) + + +#define mono_metadata_token_code(token) ((token) & 0xff000000) + +MONO_API uint32_t mono_metadata_token_from_dor (uint32_t dor_index); + +MONO_API char *mono_guid_to_string (const uint8_t *guid); + +MONO_API char *mono_guid_to_string_minimal (const uint8_t *guid); + +MONO_API uint32_t mono_metadata_declsec_from_index (MonoImage *meta, uint32_t idx); + +MONO_API uint32_t mono_metadata_translate_token_index (MonoImage *image, int table, uint32_t idx); + +MONO_API void mono_metadata_decode_table_row (MonoImage *image, int table, + int idx, + uint32_t *res, + int res_size); + +MONO_API uint32_t mono_metadata_decode_table_row_col (MonoImage *image, int table, + int idx, + unsigned int col); + +MONO_END_DECLS + +#endif /* __MONO_METADATA_H__ */ diff --git a/src/mono/msvc/include/mono/metadata/mono-config.h b/src/mono/msvc/include/mono/metadata/mono-config.h new file mode 100644 index 0000000000000..91cdccd38e39d --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/mono-config.h @@ -0,0 +1,38 @@ +/** + * \file + * + * Author: Paolo Molaro (lupus@ximian.com) + * + * (C) 2002 Ximian, Inc. + */ +#ifndef __MONO_METADATA_CONFIG_H__ +#define __MONO_METADATA_CONFIG_H__ + +#include +#include + +MONO_BEGIN_DECLS + +MONO_API const char *mono_config_get_os (void); +MONO_API const char *mono_config_get_cpu (void); +MONO_API const char *mono_config_get_wordsize (void); + +MONO_API const char* mono_get_config_dir (void); +MONO_API void mono_set_config_dir (const char *dir); + +MONO_API const char* mono_get_machine_config (void); + +MONO_API void mono_config_cleanup (void); +MONO_API void mono_config_parse (const char *filename); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_config_for_assembly (MonoImage *assembly); +MONO_API void mono_config_parse_memory (const char *buffer); + +MONO_API const char* mono_config_string_for_assembly_file (const char *filename); + +MONO_API void mono_config_set_server_mode (mono_bool server_mode); +MONO_API mono_bool mono_config_is_server_mode (void); + +MONO_END_DECLS + +#endif /* __MONO_METADATA_CONFIG_H__ */ + diff --git a/src/mono/msvc/include/mono/metadata/mono-debug.h b/src/mono/msvc/include/mono/metadata/mono-debug.h new file mode 100644 index 0000000000000..c165db731154e --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/mono-debug.h @@ -0,0 +1,231 @@ +/** + * \file + * This header is only installed for use by the debugger: + * the structures and the API declared here are not supported. + */ + +#ifndef __MONO_DEBUG_H__ +#define __MONO_DEBUG_H__ + +#include +#include +#include + +MONO_BEGIN_DECLS + +typedef struct _MonoSymbolTable MonoSymbolTable; +typedef struct _MonoDebugDataTable MonoDebugDataTable; + +typedef struct _MonoSymbolFile MonoSymbolFile; +typedef struct _MonoPPDBFile MonoPPDBFile; + +typedef struct _MonoDebugHandle MonoDebugHandle; + +typedef struct _MonoDebugLineNumberEntry MonoDebugLineNumberEntry; + +typedef struct _MonoDebugVarInfo MonoDebugVarInfo; +typedef struct _MonoDebugMethodJitInfo MonoDebugMethodJitInfo; +typedef struct _MonoDebugMethodAddress MonoDebugMethodAddress; +typedef struct _MonoDebugMethodAddressList MonoDebugMethodAddressList; +typedef struct _MonoDebugClassEntry MonoDebugClassEntry; + +typedef struct _MonoDebugMethodInfo MonoDebugMethodInfo; +typedef struct _MonoDebugLocalsInfo MonoDebugLocalsInfo; +typedef struct _MonoDebugMethodAsyncInfo MonoDebugMethodAsyncInfo; +typedef struct _MonoDebugSourceLocation MonoDebugSourceLocation; + +typedef struct _MonoDebugList MonoDebugList; + +typedef enum { + MONO_DEBUG_FORMAT_NONE, + MONO_DEBUG_FORMAT_MONO, + /* Deprecated, the mdb debugger is not longer supported. */ + MONO_DEBUG_FORMAT_DEBUGGER +} MonoDebugFormat; + +/* + * NOTE: + * We intentionally do not use GList here since the debugger needs to know about + * the layout of the fields. +*/ +struct _MonoDebugList { + MonoDebugList *next; + const void* data; +}; + +struct _MonoSymbolTable { + uint64_t magic; + uint32_t version; + uint32_t total_size; + + /* + * Corlib and metadata info. + */ + MonoDebugHandle *corlib; + MonoDebugDataTable *global_data_table; + MonoDebugList *data_tables; + + /* + * The symbol files. + */ + MonoDebugList *symbol_files; +}; + +struct _MonoDebugHandle { + uint32_t index; + char *image_file; + MonoImage *image; + MonoDebugDataTable *type_table; + MonoSymbolFile *symfile; + MonoPPDBFile *ppdb; +}; + +struct _MonoDebugMethodJitInfo { + const mono_byte *code_start; + uint32_t code_size; + uint32_t prologue_end; + uint32_t epilogue_begin; + const mono_byte *wrapper_addr; + uint32_t num_line_numbers; + MonoDebugLineNumberEntry *line_numbers; + uint32_t has_var_info; + uint32_t num_params; + MonoDebugVarInfo *this_var; + MonoDebugVarInfo *params; + uint32_t num_locals; + MonoDebugVarInfo *locals; + MonoDebugVarInfo *gsharedvt_info_var; + MonoDebugVarInfo *gsharedvt_locals_var; +}; + +struct _MonoDebugMethodAddressList { + uint32_t size; + uint32_t count; + mono_byte data [MONO_ZERO_LEN_ARRAY]; +}; + +struct _MonoDebugSourceLocation { + char *source_file; + uint32_t row, column; + uint32_t il_offset; +}; + +MONO_API mono_bool mono_debug_enabled (void); + +/* + * These bits of the MonoDebugLocalInfo's "index" field are flags specifying + * where the variable is actually stored. + * + * See relocate_variable() in debug-symfile.c for more info. + */ +#define MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS 0xf0000000 + +/* The variable is in register "index". */ +#define MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER 0 + +/* The variable is at offset "offset" from register "index". */ +#define MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET 0x10000000 + +/* The variable is in the two registers "offset" and "index". */ +#define MONO_DEBUG_VAR_ADDRESS_MODE_TWO_REGISTERS 0x20000000 + +/* The variable is dead. */ +#define MONO_DEBUG_VAR_ADDRESS_MODE_DEAD 0x30000000 + +/* Same as REGOFFSET, but do an indirection */ +#define MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET_INDIR 0x40000000 + +/* gsharedvt local */ +#define MONO_DEBUG_VAR_ADDRESS_MODE_GSHAREDVT_LOCAL 0x50000000 + +/* variable is a vt address */ +#define MONO_DEBUG_VAR_ADDRESS_MODE_VTADDR 0x60000000 + +struct _MonoDebugVarInfo { + uint32_t index; + uint32_t offset; + uint32_t size; + uint32_t begin_scope; + uint32_t end_scope; + MonoType *type; +}; + +#define MONO_DEBUGGER_MAJOR_VERSION 81 +#define MONO_DEBUGGER_MINOR_VERSION 6 +#define MONO_DEBUGGER_MAGIC 0x7aff65af4253d427ULL + +MONO_API void mono_debug_init (MonoDebugFormat format); +MONO_API void mono_debug_open_image_from_memory (MonoImage *image, const mono_byte *raw_contents, int size); +MONO_API void mono_debug_cleanup (void); + +MONO_API void mono_debug_close_image (MonoImage *image); + +MONO_API void mono_debug_domain_unload (MonoDomain *domain); +MONO_API void mono_debug_domain_create (MonoDomain *domain); + +MONO_API MonoDebugMethodAddress * +mono_debug_add_method (MonoMethod *method, MonoDebugMethodJitInfo *jit, MonoDomain *domain); + +MONO_API void +mono_debug_remove_method (MonoMethod *method, MonoDomain *domain); + +MONO_API MonoDebugMethodInfo * +mono_debug_lookup_method (MonoMethod *method); + +MONO_API MonoDebugMethodAddressList * +mono_debug_lookup_method_addresses (MonoMethod *method); + +MONO_API MonoDebugMethodJitInfo* +mono_debug_find_method (MonoMethod *method, MonoDomain *domain); + +MONO_API MonoDebugHandle * +mono_debug_get_handle (MonoImage *image); + +MONO_API void +mono_debug_free_method_jit_info (MonoDebugMethodJitInfo *jit); + + +MONO_API void +mono_debug_add_delegate_trampoline (void* code, int size); + +MONO_API MonoDebugLocalsInfo* +mono_debug_lookup_locals (MonoMethod *method); + +MonoDebugMethodAsyncInfo* +mono_debug_lookup_method_async_debug_info (MonoMethod *method); + +MONO_API +MonoDebugSourceLocation * +mono_debug_method_lookup_location (MonoDebugMethodInfo *minfo, int il_offset); + +/* + * Line number support. + */ + +MONO_API MonoDebugSourceLocation * +mono_debug_lookup_source_location (MonoMethod *method, uint32_t address, MonoDomain *domain); + +MONO_API int32_t +mono_debug_il_offset_from_address (MonoMethod *method, MonoDomain *domain, uint32_t native_offset); + +MONO_API void +mono_debug_free_source_location (MonoDebugSourceLocation *location); + +MONO_API char * +mono_debug_print_stack_frame (MonoMethod *method, uint32_t native_offset, MonoDomain *domain); + +/* + * Mono Debugger support functions + * + * These methods are used by the JIT while running inside the Mono Debugger. + */ + +MONO_API int mono_debugger_method_has_breakpoint (MonoMethod *method); +MONO_API int mono_debugger_insert_breakpoint (const char *method_name, mono_bool include_namespace); + +MONO_API void mono_set_is_debugger_attached (mono_bool attached); +MONO_API mono_bool mono_is_debugger_attached (void); + +MONO_END_DECLS + +#endif /* __MONO_DEBUG_H__ */ diff --git a/src/mono/msvc/include/mono/metadata/mono-gc.h b/src/mono/msvc/include/mono/metadata/mono-gc.h new file mode 100644 index 0000000000000..7d072a8108e95 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/mono-gc.h @@ -0,0 +1,138 @@ +/** + * \file + * GC related public interface + * + */ +#ifndef __METADATA_MONO_GC_H__ +#define __METADATA_MONO_GC_H__ + +#include + +MONO_BEGIN_DECLS + +typedef int (*MonoGCReferences) (MonoObject *obj, MonoClass *klass, uintptr_t size, uintptr_t num, MonoObject **refs, uintptr_t *offsets, void *data); + +/** + * This enum is used by the profiler API when reporting root registration. + */ +typedef enum { + /** + * Roots external to Mono. Embedders may only use this value. + */ + MONO_ROOT_SOURCE_EXTERNAL = 0, + /** + * Thread call stack. + * + * The \c key parameter is a thread ID as a \c uintptr_t. + */ + MONO_ROOT_SOURCE_STACK = 1, + /** + * Roots in the finalizer queue. This is a pseudo-root. + */ + MONO_ROOT_SOURCE_FINALIZER_QUEUE = 2, + /** + * Managed \c static variables. + * + * The \c key parameter is a \c MonoVTable pointer. + */ + MONO_ROOT_SOURCE_STATIC = 3, + /** + * Managed \c static variables with \c ThreadStaticAttribute. + * + * The \c key parameter is a thread ID as a \c uintptr_t. + */ + MONO_ROOT_SOURCE_THREAD_STATIC = 4, + /** + * Managed \c static variables with \c ContextStaticAttribute. + * + * The \c key parameter is a \c MonoAppContext pointer. + */ + MONO_ROOT_SOURCE_CONTEXT_STATIC = 5, + /** + * \c GCHandle structures. + */ + MONO_ROOT_SOURCE_GC_HANDLE = 6, + /** + * Roots in the just-in-time compiler. + */ + MONO_ROOT_SOURCE_JIT = 7, + /** + * Roots in the threading subsystem. + * + * The \c key parameter, if not \c NULL, is a thread ID as a \c uintptr_t. + */ + MONO_ROOT_SOURCE_THREADING = 8, + /** + * Roots in application domains. + * + * The \c key parameter, if not \c NULL, is a \c MonoDomain pointer. + */ + MONO_ROOT_SOURCE_DOMAIN = 9, + /** + * Roots in reflection code. + * + * The \c key parameter, if not \c NULL, is a \c MonoVTable pointer. + */ + MONO_ROOT_SOURCE_REFLECTION = 10, + /** + * Roots from P/Invoke or other marshaling infrastructure. + */ + MONO_ROOT_SOURCE_MARSHAL = 11, + /** + * Roots in the thread pool data structures. + */ + MONO_ROOT_SOURCE_THREAD_POOL = 12, + /** + * Roots in the debugger agent. + */ + MONO_ROOT_SOURCE_DEBUGGER = 13, + /** + * Roots in the runtime handle stack. This is a pseudo-root. + * + * The \c key parameter is a thread ID as a \c uintptr_t. + */ + MONO_ROOT_SOURCE_HANDLE = 14, + /** + * Roots in the ephemeron arrays. This is a pseudo-root. + */ + MONO_ROOT_SOURCE_EPHEMERON = 15, + /** + * Roots in the toggleref arrays. This is a pseudo-root. + */ + MONO_ROOT_SOURCE_TOGGLEREF = 16, +} MonoGCRootSource; + +typedef enum { + MONO_GC_HANDLE_TYPE_MIN = 0, + MONO_GC_HANDLE_WEAK = MONO_GC_HANDLE_TYPE_MIN, + MONO_GC_HANDLE_WEAK_TRACK_RESURRECTION, + MONO_GC_HANDLE_NORMAL, + MONO_GC_HANDLE_PINNED, + MONO_GC_HANDLE_TYPE_MAX, +} MonoGCHandleType; + +MONO_API void mono_gc_collect (int generation); +MONO_API int mono_gc_max_generation (void); +MONO_API int mono_gc_get_generation (MonoObject *object); +MONO_API int mono_gc_collection_count (int generation); +MONO_API int64_t mono_gc_get_used_size (void); +MONO_API int64_t mono_gc_get_heap_size (void); +MONO_API MonoBoolean mono_gc_pending_finalizers (void); +MONO_API void mono_gc_finalize_notify (void); +MONO_API int mono_gc_invoke_finalizers (void); +/* heap walking is only valid in the pre-stop-world event callback */ +MONO_API int mono_gc_walk_heap (int flags, MonoGCReferences callback, void *data); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_gc_init_finalizer_thread (void); + +/* + * Only supported under SGen. These two with Sgen will take and release the LOCK_GC + */ +void mono_gc_stop_world (void); +void mono_gc_restart_world (void); + +MONO_END_DECLS + +#endif /* __METADATA_MONO_GC_H__ */ + diff --git a/src/mono/msvc/include/mono/metadata/mono-private-unstable.h b/src/mono/msvc/include/mono/metadata/mono-private-unstable.h new file mode 100644 index 0000000000000..7b214bf70adbf --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/mono-private-unstable.h @@ -0,0 +1,41 @@ +/** + * \file + * + * Private unstable APIs. + * + * WARNING: The declarations and behavior of functions in this header are NOT STABLE and can be modified or removed at + * any time. + * + */ + + +#ifndef __MONO_METADATA_MONO_PRIVATE_UNSTABLE_H__ +#define __MONO_METADATA_MONO_PRIVATE_UNSTABLE_H__ + +#include + +typedef MonoGCHandle MonoAssemblyLoadContextGCHandle; + +MONO_API MONO_RT_EXTERNAL_ONLY MonoAssembly * +mono_assembly_load_full_alc (MonoAssemblyLoadContextGCHandle alc_gchandle, MonoAssemblyName *aname, const char *basedir, MonoImageOpenStatus *status); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoImage * +mono_image_open_from_data_alc (MonoAssemblyLoadContextGCHandle alc_gchandle, char *data, uint32_t data_len, mono_bool need_copy, MonoImageOpenStatus *status, const char *name); + +typedef MonoAssembly * (*MonoAssemblyPreLoadFuncV3) (MonoAssemblyLoadContextGCHandle alc_gchandle, MonoAssemblyName *aname, char **assemblies_path, void *user_data, MonoError *error); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_install_assembly_preload_hook_v3 (MonoAssemblyPreLoadFuncV3 func, void *user_data, mono_bool append); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoAssemblyLoadContextGCHandle +mono_alc_get_default_gchandle (void); + +typedef struct _MonoBundledSatelliteAssembly MonoBundledSatelliteAssembly; + +MONO_API void +mono_register_bundled_satellite_assemblies (const MonoBundledSatelliteAssembly **assemblies); + +MONO_API MonoBundledSatelliteAssembly * +mono_create_new_bundled_satellite_assembly (const char *name, const char *culture, const unsigned char *data, unsigned int size); + +#endif /*__MONO_METADATA_MONO_PRIVATE_UNSTABLE_H__*/ diff --git a/src/mono/msvc/include/mono/metadata/object-forward.h b/src/mono/msvc/include/mono/metadata/object-forward.h new file mode 100644 index 0000000000000..010dc8b0f76e4 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/object-forward.h @@ -0,0 +1,22 @@ +/** + * \file + * + * Forward declarations of opaque types, and typedefs thereof. + * + */ + +#ifndef __MONO_OBJECT_FORWARD_H__ +#define __MONO_OBJECT_FORWARD_H__ + +#include + +typedef struct _MonoClass MonoClass; +typedef struct _MonoImage MonoImage; +typedef struct _MonoMethod MonoMethod; + +typedef struct _MonoObject MONO_RT_MANAGED_ATTR MonoObject; +typedef struct _MonoException MONO_RT_MANAGED_ATTR MonoException; +typedef struct _MonoReflectionAssembly MONO_RT_MANAGED_ATTR MonoReflectionAssembly; +typedef struct _MonoReflectionTypeBuilder MONO_RT_MANAGED_ATTR MonoReflectionTypeBuilder; + +#endif /* __MONO_OBJECT_FORWARD_H__ */ diff --git a/src/mono/msvc/include/mono/metadata/object.h b/src/mono/msvc/include/mono/metadata/object.h new file mode 100644 index 0000000000000..f421c6c1a33be --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/object.h @@ -0,0 +1,408 @@ +/** + * \file + */ + +#ifndef _MONO_CLI_OBJECT_H_ +#define _MONO_CLI_OBJECT_H_ + +#include +#include +#include +#include + +MONO_BEGIN_DECLS + +typedef struct _MonoString MONO_RT_MANAGED_ATTR MonoString; +typedef struct _MonoArray MONO_RT_MANAGED_ATTR MonoArray; +typedef struct _MonoReflectionMethod MONO_RT_MANAGED_ATTR MonoReflectionMethod; +typedef struct _MonoReflectionModule MONO_RT_MANAGED_ATTR MonoReflectionModule; +typedef struct _MonoReflectionField MONO_RT_MANAGED_ATTR MonoReflectionField; +typedef struct _MonoReflectionProperty MONO_RT_MANAGED_ATTR MonoReflectionProperty; +typedef struct _MonoReflectionEvent MONO_RT_MANAGED_ATTR MonoReflectionEvent; +typedef struct _MonoReflectionType MONO_RT_MANAGED_ATTR MonoReflectionType; +typedef struct _MonoDelegate MONO_RT_MANAGED_ATTR MonoDelegate; +typedef struct _MonoThreadsSync MonoThreadsSync; +#ifdef ENABLE_NETCORE +typedef struct _MonoInternalThread MONO_RT_MANAGED_ATTR MonoThread; +#else +typedef struct _MonoThread MONO_RT_MANAGED_ATTR MonoThread; +#endif +typedef struct _MonoDynamicAssembly MonoDynamicAssembly; +typedef struct _MonoDynamicImage MonoDynamicImage; +typedef struct _MonoReflectionMethodBody MONO_RT_MANAGED_ATTR MonoReflectionMethodBody; +typedef struct _MonoAppContext MONO_RT_MANAGED_ATTR MonoAppContext; + +struct _MonoObject { + MonoVTable *vtable; + MonoThreadsSync *synchronisation; +}; + +typedef MonoObject* (*MonoInvokeFunc) (MonoMethod *method, void *obj, void **params, MonoObject **exc, MonoError *error); +typedef void* (*MonoCompileFunc) (MonoMethod *method); +typedef void (*MonoMainThreadFunc) (void* user_data); + +#define MONO_OBJECT_SETREF(obj,fieldname,value) do { \ + mono_gc_wbarrier_set_field ((MonoObject*)(obj), &((obj)->fieldname), (MonoObject*)value); \ + /*(obj)->fieldname = (value);*/ \ + } while (0) + +/* This should be used if 's' can reside on the heap */ +#define MONO_STRUCT_SETREF(s,field,value) do { \ + mono_gc_wbarrier_generic_store (&((s)->field), (MonoObject*)(value)); \ + } while (0) + +#define mono_array_addr(array,type,index) ((type*)mono_array_addr_with_size ((array), sizeof (type), (index))) +#define mono_array_get(array,type,index) ( *(type*)mono_array_addr ((array), type, (index)) ) +#define mono_array_set(array,type,index,value) \ + do { \ + type *__p = (type *) mono_array_addr ((array), type, (index)); \ + *__p = (value); \ + } while (0) +#define mono_array_setref(array,index,value) \ + do { \ + void **__p = (void **) mono_array_addr ((array), void*, (index)); \ + mono_gc_wbarrier_set_arrayref ((array), __p, (MonoObject*)(value)); \ + /* *__p = (value);*/ \ + } while (0) +#define mono_array_memcpy_refs(dest,destidx,src,srcidx,count) \ + do { \ + void **__p = (void **) mono_array_addr ((dest), void*, (destidx)); \ + void **__s = mono_array_addr ((src), void*, (srcidx)); \ + mono_gc_wbarrier_arrayref_copy (__p, __s, (count)); \ + } while (0) + +MONO_API MONO_RT_EXTERNAL_ONLY mono_unichar2 *mono_string_chars (MonoString *s); +MONO_API MONO_RT_EXTERNAL_ONLY int mono_string_length (MonoString *s); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * +mono_object_new (MonoDomain *domain, MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoObject * +mono_object_new_specific (MonoVTable *vtable); + +/* can be used for classes without finalizer in non-profiling mode */ +MONO_API MONO_RT_EXTERNAL_ONLY +MonoObject * +mono_object_new_fast (MonoVTable *vtable); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoObject * +mono_object_new_alloc_specific (MonoVTable *vtable); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoObject * +mono_object_new_from_token (MonoDomain *domain, MonoImage *image, uint32_t token); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoArray* +mono_array_new (MonoDomain *domain, MonoClass *eclass, uintptr_t n); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoArray* +mono_array_new_full (MonoDomain *domain, MonoClass *array_class, + uintptr_t *lengths, intptr_t *lower_bounds); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoArray * +mono_array_new_specific (MonoVTable *vtable, uintptr_t n); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoArray* +mono_array_clone (MonoArray *array); + +MONO_API MONO_RT_EXTERNAL_ONLY char* +mono_array_addr_with_size (MonoArray *array, int size, uintptr_t idx); + +MONO_API MONO_RT_EXTERNAL_ONLY uintptr_t +mono_array_length (MonoArray *array); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoString* +mono_string_empty (MonoDomain *domain); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoString* +mono_string_empty_wrapper (void); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoString* +mono_string_new_utf16 (MonoDomain *domain, const mono_unichar2 *text, int32_t len); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoString* +mono_string_new_size (MonoDomain *domain, int32_t len); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoString* +mono_ldstr (MonoDomain *domain, MonoImage *image, uint32_t str_index); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoString* +mono_string_is_interned (MonoString *str); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoString* +mono_string_intern (MonoString *str); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoString* +mono_string_new (MonoDomain *domain, const char *text); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoString* +mono_string_new_wrapper (const char *text); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoString* +mono_string_new_len (MonoDomain *domain, const char *text, unsigned int length); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoString* +mono_string_new_utf32 (MonoDomain *domain, const mono_unichar4 *text, int32_t len); + +MONO_API MONO_RT_EXTERNAL_ONLY +char * +mono_string_to_utf8 (MonoString *string_obj); + +MONO_API MONO_RT_EXTERNAL_ONLY char * +mono_string_to_utf8_checked (MonoString *string_obj, MonoError *error); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_unichar2 * +mono_string_to_utf16 (MonoString *string_obj); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_unichar4 * +mono_string_to_utf32 (MonoString *string_obj); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoString * +mono_string_from_utf16 (/*const*/ mono_unichar2 *data); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoString * +mono_string_from_utf32 (/*const*/ mono_unichar4 *data); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_string_equal (MonoString *s1, MonoString *s2); + +MONO_API MONO_RT_EXTERNAL_ONLY unsigned int +mono_string_hash (MonoString *s); + +MONO_API MONO_RT_EXTERNAL_ONLY int +mono_object_hash (MonoObject* obj); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoString * +mono_object_to_string (MonoObject *obj, MonoObject **exc); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * +mono_value_box (MonoDomain *domain, MonoClass *klass, void* val); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_value_copy (void* dest, /*const*/ void* src, MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_value_copy_array (MonoArray *dest, int dest_idx, void* src, int count); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoVTable* +mono_object_get_vtable (MonoObject *obj); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoDomain* +mono_object_get_domain (MonoObject *obj); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoClass* +mono_object_get_class (MonoObject *obj); + +MONO_API MONO_RT_EXTERNAL_ONLY void* +mono_object_unbox (MonoObject *obj); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * +mono_object_clone (MonoObject *obj); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * +mono_object_isinst (MonoObject *obj, MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * +mono_object_isinst_mbyref (MonoObject *obj, MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * +mono_object_castclass_mbyref (MonoObject *obj, MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_monitor_try_enter (MonoObject *obj, uint32_t ms); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_monitor_enter (MonoObject *obj); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_monitor_enter_v4 (MonoObject *obj, char *lock_taken); + +MONO_API MONO_RT_EXTERNAL_ONLY unsigned int +mono_object_get_size (MonoObject *o); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_monitor_exit (MonoObject *obj); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_raise_exception (MonoException *ex); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_runtime_set_pending_exception (MonoException *exc, mono_bool overwrite); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_reraise_exception (MonoException *ex); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_runtime_object_init (MonoObject *this_obj); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_runtime_class_init (MonoVTable *vtable); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoDomain* +mono_vtable_domain (MonoVTable *vtable); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoClass* +mono_vtable_class (MonoVTable *vtable); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod* +mono_object_get_virtual_method (MonoObject *obj, MonoMethod *method); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject* +mono_runtime_invoke (MonoMethod *method, void *obj, void **params, + MonoObject **exc); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod* +mono_get_delegate_invoke (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod* +mono_get_delegate_begin_invoke (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod* +mono_get_delegate_end_invoke (MonoClass *klass); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject* +mono_runtime_delegate_invoke (MonoObject *delegate, void **params, + MonoObject **exc); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject* +mono_runtime_invoke_array (MonoMethod *method, void *obj, MonoArray *params, + MonoObject **exc); + +MONO_API MONO_RT_EXTERNAL_ONLY void* +mono_method_get_unmanaged_thunk (MonoMethod *method); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoArray* +mono_runtime_get_main_args (void); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_runtime_exec_managed_code (MonoDomain *domain, + MonoMainThreadFunc main_func, + void* main_args); + +MONO_API MONO_RT_EXTERNAL_ONLY int +mono_runtime_run_main (MonoMethod *method, int argc, char* argv[], + MonoObject **exc); + +MONO_API MONO_RT_EXTERNAL_ONLY int +mono_runtime_exec_main (MonoMethod *method, MonoArray *args, + MonoObject **exc); + +MONO_API MONO_RT_EXTERNAL_ONLY int +mono_runtime_set_main_args (int argc, char* argv[]); + +/* The following functions won't be available with mono was configured with remoting disabled. */ +/*#ifndef DISABLE_REMOTING */ +MONO_API MONO_RT_EXTERNAL_ONLY void* +mono_load_remote_field (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, void **res); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * +mono_load_remote_field_new (MonoObject *this_obj, MonoClass *klass, MonoClassField *field); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_store_remote_field (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, void* val); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_store_remote_field_new (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, MonoObject *arg); + +/* #endif */ + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_unhandled_exception (MonoObject *exc); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_print_unhandled_exception (MonoObject *exc); + +MONO_API MONO_RT_EXTERNAL_ONLY +void* +mono_compile_method (MonoMethod *method); + +/* accessors for fields and properties */ +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_field_set_value (MonoObject *obj, MonoClassField *field, void *value); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_field_static_set_value (MonoVTable *vt, MonoClassField *field, void *value); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_field_get_value (MonoObject *obj, MonoClassField *field, void *value); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_field_static_get_value (MonoVTable *vt, MonoClassField *field, void *value); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * +mono_field_get_value_object (MonoDomain *domain, MonoClassField *field, MonoObject *obj); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_property_set_value (MonoProperty *prop, void *obj, void **params, MonoObject **exc); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject* +mono_property_get_value (MonoProperty *prop, void *obj, void **params, MonoObject **exc); + +/* GC handles support + * + * A handle can be created to refer to a managed object and either prevent it + * from being garbage collected or moved or to be able to know if it has been + * collected or not (weak references). + * mono_gchandle_new () is used to prevent an object from being garbage collected + * until mono_gchandle_free() is called. Use a TRUE value for the pinned argument to + * prevent the object from being moved (this should be avoided as much as possible + * and this should be used only for shorts periods of time or performance will suffer). + * To create a weakref use mono_gchandle_new_weakref (): track_resurrection should + * usually be false (see the GC docs for more details). + * mono_gchandle_get_target () can be used to get the object referenced by both kinds + * of handle: for a weakref handle, if an object has been collected, it will return NULL. + */ +MONO_API MONO_RT_EXTERNAL_ONLY uint32_t mono_gchandle_new (MonoObject *obj, mono_bool pinned); +MONO_API MONO_RT_EXTERNAL_ONLY uint32_t mono_gchandle_new_weakref (MonoObject *obj, mono_bool track_resurrection); +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject* mono_gchandle_get_target (uint32_t gchandle); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_gchandle_free (uint32_t gchandle); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoGCHandle mono_gchandle_new_v2 (MonoObject *obj, mono_bool pinned); +MONO_API MONO_RT_EXTERNAL_ONLY MonoGCHandle mono_gchandle_new_weakref_v2 (MonoObject *obj, mono_bool track_resurrection); +MONO_API MONO_RT_EXTERNAL_ONLY MonoObject* mono_gchandle_get_target_v2 (MonoGCHandle gchandle); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_gchandle_free_v2 (MonoGCHandle gchandle); + +/* Reference queue support + * + * A reference queue is used to get notifications of when objects are collected. + * Call mono_gc_reference_queue_new to create a new queue and pass the callback that + * will be invoked when registered objects are collected. + * Call mono_gc_reference_queue_add to register a pair of objects and data within a queue. + * The callback will be triggered once an object is both unreachable and finalized. + */ + +typedef void (*mono_reference_queue_callback) (void *user_data); +typedef struct _MonoReferenceQueue MonoReferenceQueue; + +MONO_API MONO_RT_EXTERNAL_ONLY MonoReferenceQueue* mono_gc_reference_queue_new (mono_reference_queue_callback callback); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_reference_queue_free (MonoReferenceQueue *queue); +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool mono_gc_reference_queue_add (MonoReferenceQueue *queue, MonoObject *obj, void *user_data); + +/* GC write barriers support */ +MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_set_field (MonoObject *obj, void* field_ptr, MonoObject* value); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_set_arrayref (MonoArray *arr, void* slot_ptr, MonoObject* value); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_arrayref_copy (void* dest_ptr, /*const*/ void* src_ptr, int count); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_generic_store (void* ptr, MonoObject* value); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_generic_store_atomic (void *ptr, MonoObject *value); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_generic_nostore (void* ptr); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_value_copy (void* dest, /*const*/ void* src, int count, MonoClass *klass); +MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_object_copy (MonoObject* obj, MonoObject *src); + +MONO_END_DECLS + +#endif diff --git a/src/mono/msvc/include/mono/metadata/opcodes.h b/src/mono/msvc/include/mono/metadata/opcodes.h new file mode 100644 index 0000000000000..bcaf099a44bc1 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/opcodes.h @@ -0,0 +1,83 @@ +/** + * \file + */ + +#ifndef __MONO_METADATA_OPCODES_H__ +#define __MONO_METADATA_OPCODES_H__ + +/* + * opcodes.h: CIL instruction information + * + * Author: + * Paolo Molaro (lupus@ximian.com) + * + * (C) 2002 Ximian, Inc. + */ + +#include + +MONO_BEGIN_DECLS + +#define MONO_CUSTOM_PREFIX 0xf0 + +#define OPDEF(a,b,c,d,e,f,g,h,i,j) \ + MONO_ ## a, + +typedef enum MonoOpcodeEnum { + MonoOpcodeEnum_Invalid = -1, +#include "mono/cil/opcode.def" + MONO_CEE_LAST +} MonoOpcodeEnum; + +#undef OPDEF + +enum { + MONO_FLOW_NEXT, + MONO_FLOW_BRANCH, + MONO_FLOW_COND_BRANCH, + MONO_FLOW_ERROR, + MONO_FLOW_CALL, + MONO_FLOW_RETURN, + MONO_FLOW_META +}; + +enum { + MonoInlineNone = 0, + MonoInlineType = 1, + MonoInlineField = 2, + MonoInlineMethod = 3, + MonoInlineTok = 4, + MonoInlineString = 5, + MonoInlineSig = 6, + MonoInlineVar = 7, + MonoShortInlineVar = 8, + MonoInlineBrTarget = 9, + MonoShortInlineBrTarget = 10, + MonoInlineSwitch = 11, + MonoInlineR = 12, + MonoShortInlineR = 13, + MonoInlineI = 14, + MonoShortInlineI = 15, + MonoInlineI8 = 16, +}; + +typedef struct { + unsigned char argument; + unsigned char flow_type; + unsigned short opval; +} MonoOpcode; + +MONO_BEGIN_DECLS +MONO_API_DATA const MonoOpcode mono_opcodes []; +MONO_END_DECLS + +MONO_API const char* +mono_opcode_name (int opcode); + +MONO_API MonoOpcodeEnum +mono_opcode_value (const mono_byte **ip, const mono_byte *end); + +MONO_END_DECLS + +#endif /* __MONO_METADATA_OPCODES_H__ */ + diff --git a/src/mono/msvc/include/mono/metadata/profiler-events.h b/src/mono/msvc/include/mono/metadata/profiler-events.h new file mode 100644 index 0000000000000..c7ab3f66d516d --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/profiler-events.h @@ -0,0 +1,108 @@ +/* + * Licensed to the .NET Foundation under one or more agreements. + * The .NET Foundation licenses this file to you under the MIT license. + */ + +/* + * To #include this file, #define the following macros first: + * + * MONO_PROFILER_EVENT_0(name, type) + * MONO_PROFILER_EVENT_1(name, type, arg1_type, arg1_name) + * MONO_PROFILER_EVENT_2(name, type, arg1_type, arg1_name, arg2_type, arg2_name) + * MONO_PROFILER_EVENT_3(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name) + * MONO_PROFILER_EVENT_4(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name, arg4_type, arg4_name) + * MONO_PROFILER_EVENT_5(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name, arg4_type, arg4_name, arg5_type, arg5_name) + * + * To add new callbacks to the API, simply add a line in this file and use + * MONO_PROFILER_RAISE to raise the event wherever. + * + * If you need more arguments then the current macros provide, add another + * macro and update all areas where the macros are used. Remember that this is + * a public header and not all users will be defining the newly added macro. So + * to prevent errors in existing code, you must add something like this at the + * beginning of this file: + * + * #ifndef MONO_PROFILER_EVENT_6 + * #define MONO_PROFILER_EVENT_6(...) # Do nothing. + * #endif + */ + +#ifndef MONO_PROFILER_EVENT_5 +#define MONO_PROFILER_EVENT_5(...) +#endif + +MONO_PROFILER_EVENT_0(runtime_initialized, RuntimeInitialized) +MONO_PROFILER_EVENT_0(runtime_shutdown_begin, RuntimeShutdownBegin) +MONO_PROFILER_EVENT_0(runtime_shutdown_end, RuntimeShutdownEnd) + +MONO_PROFILER_EVENT_1(context_loaded, ContextLoaded, MonoAppContext *, context) +MONO_PROFILER_EVENT_1(context_unloaded, ContextUnloaded, MonoAppContext *, context) + +MONO_PROFILER_EVENT_1(domain_loading, DomainLoading, MonoDomain *, domain) +MONO_PROFILER_EVENT_1(domain_loaded, DomainLoaded, MonoDomain *, domain) +MONO_PROFILER_EVENT_1(domain_unloading, DomainUnloading, MonoDomain *, domain) +MONO_PROFILER_EVENT_1(domain_unloaded, DomainUnloaded, MonoDomain *, domain) +MONO_PROFILER_EVENT_2(domain_name, DomainName, MonoDomain *, domain, const char *, name) + +MONO_PROFILER_EVENT_1(jit_begin, JitBegin, MonoMethod *, method) +MONO_PROFILER_EVENT_1(jit_failed, JitFailed, MonoMethod *, method) +MONO_PROFILER_EVENT_2(jit_done, JitDone, MonoMethod *, method, MonoJitInfo *, jinfo) +MONO_PROFILER_EVENT_2(jit_chunk_created, JitChunkCreated, const mono_byte *, chunk, uintptr_t, size) +MONO_PROFILER_EVENT_1(jit_chunk_destroyed, JitChunkDestroyed, const mono_byte *, chunk) +MONO_PROFILER_EVENT_4(jit_code_buffer, JitCodeBuffer, const mono_byte *, buffer, uint64_t, size, MonoProfilerCodeBufferType, type, const void *, data) + +MONO_PROFILER_EVENT_1(class_loading, ClassLoading, MonoClass *, klass) +MONO_PROFILER_EVENT_1(class_failed, ClassFailed, MonoClass *, klass) +MONO_PROFILER_EVENT_1(class_loaded, ClassLoaded, MonoClass *, klass) + +MONO_PROFILER_EVENT_1(vtable_loading, VTableLoading, MonoVTable *, vtable) +MONO_PROFILER_EVENT_1(vtable_failed, VTableFailed, MonoVTable *, vtable) +MONO_PROFILER_EVENT_1(vtable_loaded, VTableLoaded, MonoVTable *, vtable) + +MONO_PROFILER_EVENT_1(image_loading, ModuleLoading, MonoImage *, image) +MONO_PROFILER_EVENT_1(image_failed, ModuleFailed, MonoImage *, image) +MONO_PROFILER_EVENT_1(image_loaded, ModuleLoaded, MonoImage *, image) +MONO_PROFILER_EVENT_1(image_unloading, ModuleUnloading, MonoImage *, image) +MONO_PROFILER_EVENT_1(image_unloaded, ModuleUnloaded, MonoImage *, image) + +MONO_PROFILER_EVENT_1(assembly_loading, AssemblyLoading, MonoAssembly *, assembly) +MONO_PROFILER_EVENT_1(assembly_loaded, AssemblyLLoaded, MonoAssembly *, assembly) +MONO_PROFILER_EVENT_1(assembly_unloading, AssemblyLUnloading, MonoAssembly *, assembly) +MONO_PROFILER_EVENT_1(assembly_unloaded, AssemblyLUnloaded, MonoAssembly *, assembly) + +MONO_PROFILER_EVENT_2(method_enter, MethodEnter, MonoMethod *, method, MonoProfilerCallContext *, context) +MONO_PROFILER_EVENT_2(method_leave, MethodLeave, MonoMethod *, method, MonoProfilerCallContext *, context) +MONO_PROFILER_EVENT_2(method_tail_call, MethodTailCall, MonoMethod *, method, MonoMethod *, target) +MONO_PROFILER_EVENT_2(method_exception_leave, MethodExceptionLeave, MonoMethod *, method, MonoObject *, exception) +MONO_PROFILER_EVENT_1(method_free, MethodFree, MonoMethod *, method) +MONO_PROFILER_EVENT_1(method_begin_invoke, MethodBeginInvoke, MonoMethod *, method) +MONO_PROFILER_EVENT_1(method_end_invoke, MethodEndInvoke, MonoMethod *, method) + +MONO_PROFILER_EVENT_1(exception_throw, ExceptionThrow, MonoObject *, exception) +MONO_PROFILER_EVENT_4(exception_clause, ExceptionClause, MonoMethod *, method, uint32_t, index, MonoExceptionEnum, type, MonoObject *, exception) + +MONO_PROFILER_EVENT_3(gc_event, GCEvent2, MonoProfilerGCEvent, event, uint32_t, generation, mono_bool, is_serial) +MONO_PROFILER_EVENT_1(gc_allocation, GCAllocation, MonoObject *, object) +MONO_PROFILER_EVENT_2(gc_moves, GCMoves, MonoObject *const *, objects, uint64_t, count) +MONO_PROFILER_EVENT_1(gc_resize, GCResize, uintptr_t, size) +MONO_PROFILER_EVENT_3(gc_handle_created, GCHandleCreated, uint32_t, handle, MonoGCHandleType, type, MonoObject *, object) +MONO_PROFILER_EVENT_2(gc_handle_deleted, GCHandleDeleted, uint32_t, handle, MonoGCHandleType, type) +MONO_PROFILER_EVENT_0(gc_finalizing, GCFinalizing) +MONO_PROFILER_EVENT_0(gc_finalized, GCFinalized) +MONO_PROFILER_EVENT_1(gc_finalizing_object, GCFinalizingObject, MonoObject *, object) +MONO_PROFILER_EVENT_1(gc_finalized_object, GCFinalizedObject, MonoObject *, object) +MONO_PROFILER_EVENT_5(gc_root_register, RootRegister, const mono_byte *, start, uintptr_t, size, MonoGCRootSource, source, const void *, key, const char *, name) +MONO_PROFILER_EVENT_1(gc_root_unregister, RootUnregister, const mono_byte *, start) +MONO_PROFILER_EVENT_3(gc_roots, GCRoots, uint64_t, count, const mono_byte *const *, addresses, MonoObject *const *, objects) + +MONO_PROFILER_EVENT_1(monitor_contention, MonitorContention, MonoObject *, object) +MONO_PROFILER_EVENT_1(monitor_failed, MonitorFailed, MonoObject *, object) +MONO_PROFILER_EVENT_1(monitor_acquired, MonitorAcquired, MonoObject *, object) + +MONO_PROFILER_EVENT_1(thread_started, ThreadStarted, uintptr_t, tid) +MONO_PROFILER_EVENT_1(thread_stopping, ThreadStopping, uintptr_t, tid) +MONO_PROFILER_EVENT_1(thread_stopped, ThreadStopped, uintptr_t, tid) +MONO_PROFILER_EVENT_1(thread_exited, ThreadExited, uintptr_t, tid) +MONO_PROFILER_EVENT_2(thread_name, ThreadName, uintptr_t, tid, const char *, name) + +MONO_PROFILER_EVENT_2(sample_hit, SampleHit, const mono_byte *, ip, const void *, context) diff --git a/src/mono/msvc/include/mono/metadata/profiler.h b/src/mono/msvc/include/mono/metadata/profiler.h new file mode 100644 index 0000000000000..2fd2d840f82a5 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/profiler.h @@ -0,0 +1,248 @@ +/* + * Licensed to the .NET Foundation under one or more agreements. + * The .NET Foundation licenses this file to you under the MIT license. + */ + +#ifndef __MONO_PROFILER_H__ +#define __MONO_PROFILER_H__ + +#include +#include +#include + +MONO_BEGIN_DECLS + +/** + * This value will be incremented whenever breaking changes to the profiler API + * are made. This macro is intended for use in profiler modules that wish to + * support older versions of the profiler API. + * + * Version 2: + * - Major overhaul of the profiler API. + * Version 3: + * - Added mono_profiler_enable_clauses (). This must now be called to enable + * raising exception_clause events. + * - The exception argument to exception_clause events can now be NULL for + * finally clauses invoked in the non-exceptional case. + * - The type argument to exception_clause events will now correctly indicate + * that the catch portion of the clause is being executed in the case of + * try-filter-catch clauses. + * - Removed the iomap_report event. + * - Removed the old gc_event event and renamed gc_event2 to gc_event. + */ +#define MONO_PROFILER_API_VERSION 3 + +typedef struct _MonoProfiler MonoProfiler; +typedef struct _MonoProfilerDesc *MonoProfilerHandle; + +typedef void (*MonoProfilerCleanupCallback) (MonoProfiler *prof); + +MONO_API void mono_profiler_load (const char *desc); +MONO_API MonoProfilerHandle mono_profiler_create (MonoProfiler *prof); +MONO_API void mono_profiler_set_cleanup_callback (MonoProfilerHandle handle, MonoProfilerCleanupCallback cb); + +typedef struct { + MonoMethod *method; + uint32_t il_offset; + uint32_t counter; + const char *file_name; + uint32_t line; + uint32_t column; +} MonoProfilerCoverageData; + +typedef mono_bool (*MonoProfilerCoverageFilterCallback) (MonoProfiler *prof, MonoMethod *method); +typedef void (*MonoProfilerCoverageCallback) (MonoProfiler *prof, const MonoProfilerCoverageData *data); + +MONO_API mono_bool mono_profiler_enable_coverage (void); +MONO_API void mono_profiler_set_coverage_filter_callback (MonoProfilerHandle handle, MonoProfilerCoverageFilterCallback cb); +MONO_API mono_bool mono_profiler_get_coverage_data (MonoProfilerHandle handle, MonoMethod *method, MonoProfilerCoverageCallback cb); + +typedef enum { + /** + * Do not perform sampling. Will make the sampling thread sleep until the + * sampling mode is changed to one of the below modes. + */ + MONO_PROFILER_SAMPLE_MODE_NONE = 0, + /** + * Try to base sampling frequency on process activity. Falls back to + * MONO_PROFILER_SAMPLE_MODE_REAL if such a clock is not available. + */ + MONO_PROFILER_SAMPLE_MODE_PROCESS = 1, + /** + * Base sampling frequency on wall clock time. Uses a monotonic clock when + * available (all major platforms). + */ + MONO_PROFILER_SAMPLE_MODE_REAL = 2, +} MonoProfilerSampleMode; + +MONO_API mono_bool mono_profiler_enable_sampling (MonoProfilerHandle handle); +MONO_API mono_bool mono_profiler_set_sample_mode (MonoProfilerHandle handle, MonoProfilerSampleMode mode, uint32_t freq); +MONO_API mono_bool mono_profiler_get_sample_mode (MonoProfilerHandle handle, MonoProfilerSampleMode *mode, uint32_t *freq); + +MONO_API mono_bool mono_profiler_enable_allocations (void); +MONO_API mono_bool mono_profiler_enable_clauses (void); + +typedef struct _MonoProfilerCallContext MonoProfilerCallContext; + +typedef enum { + /** + * Do not instrument calls. + */ + MONO_PROFILER_CALL_INSTRUMENTATION_NONE = 0, + /** + * Instrument method entries. + */ + MONO_PROFILER_CALL_INSTRUMENTATION_ENTER = 1 << 1, + /** + * Also capture a call context for method entries. + */ + MONO_PROFILER_CALL_INSTRUMENTATION_ENTER_CONTEXT = 1 << 2, + /** + * Instrument method exits. + */ + MONO_PROFILER_CALL_INSTRUMENTATION_LEAVE = 1 << 3, + /** + * Also capture a call context for method exits. + */ + MONO_PROFILER_CALL_INSTRUMENTATION_LEAVE_CONTEXT = 1 << 4, + /** + * Instrument method exits as a result of a tail call. + */ + MONO_PROFILER_CALL_INSTRUMENTATION_TAIL_CALL = 1 << 5, + /** + * Instrument exceptional method exits. + */ + MONO_PROFILER_CALL_INSTRUMENTATION_EXCEPTION_LEAVE = 1 << 6, +} MonoProfilerCallInstrumentationFlags; + +typedef MonoProfilerCallInstrumentationFlags (*MonoProfilerCallInstrumentationFilterCallback) (MonoProfiler *prof, MonoMethod *method); + +MONO_API void mono_profiler_set_call_instrumentation_filter_callback (MonoProfilerHandle handle, MonoProfilerCallInstrumentationFilterCallback cb); +MONO_API mono_bool mono_profiler_enable_call_context_introspection (void); +MONO_API void *mono_profiler_call_context_get_this (MonoProfilerCallContext *context); +MONO_API void *mono_profiler_call_context_get_argument (MonoProfilerCallContext *context, uint32_t position); +MONO_API void *mono_profiler_call_context_get_local (MonoProfilerCallContext *context, uint32_t position); +MONO_API void *mono_profiler_call_context_get_result (MonoProfilerCallContext *context); +MONO_API void mono_profiler_call_context_free_buffer (void *buffer); + +typedef enum { + /** + * The \c data parameter is a \c MonoMethod pointer. + */ + MONO_PROFILER_CODE_BUFFER_METHOD = 0, + /** + * \deprecated No longer used. + */ + MONO_PROFILER_CODE_BUFFER_METHOD_TRAMPOLINE = 1, + /** + * The \c data parameter is a \c MonoMethod pointer. + */ + MONO_PROFILER_CODE_BUFFER_UNBOX_TRAMPOLINE = 2, + MONO_PROFILER_CODE_BUFFER_IMT_TRAMPOLINE = 3, + MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE = 4, + /** + * The \c data parameter is a C string. + */ + MONO_PROFILER_CODE_BUFFER_SPECIFIC_TRAMPOLINE = 5, + MONO_PROFILER_CODE_BUFFER_HELPER = 6, + /** + * \deprecated No longer used. + */ + MONO_PROFILER_CODE_BUFFER_MONITOR = 7, + MONO_PROFILER_CODE_BUFFER_DELEGATE_INVOKE = 8, + MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING = 9, +} MonoProfilerCodeBufferType; + +typedef enum { + MONO_GC_EVENT_PRE_STOP_WORLD = 6, + /** + * When this event arrives, the GC and suspend locks are acquired. + */ + MONO_GC_EVENT_PRE_STOP_WORLD_LOCKED = 10, + MONO_GC_EVENT_POST_STOP_WORLD = 7, + MONO_GC_EVENT_START = 0, + MONO_GC_EVENT_END = 5, + MONO_GC_EVENT_PRE_START_WORLD = 8, + /** + * When this event arrives, the GC and suspend locks are released. + */ + MONO_GC_EVENT_POST_START_WORLD_UNLOCKED = 11, + MONO_GC_EVENT_POST_START_WORLD = 9, +} MonoProfilerGCEvent; + +/* + * The macros below will generate the majority of the callback API. Refer to + * mono/metadata/profiler-events.h for a list of callbacks. They are expanded + * like so: + * + * typedef void (*MonoProfilerRuntimeInitializedCallback (MonoProfiler *prof); + * MONO_API void mono_profiler_set_runtime_initialized_callback (MonoProfiler *prof, MonoProfilerRuntimeInitializedCallback cb); + * + * typedef void (*MonoProfilerRuntimeShutdownCallback (MonoProfiler *prof); + * MONO_API void mono_profiler_set_runtime_shutdown_callback (MonoProfiler *prof, MonoProfilerRuntimeShutdownCallback cb); + * + * typedef void (*MonoProfilerContextLoadedCallback (MonoProfiler *prof); + * MONO_API void mono_profiler_set_context_loaded_callback (MonoProfiler *prof, MonoProfilerContextLoadedCallback cb); + * + * typedef void (*MonoProfilerContextUnloadedCallback (MonoProfiler *prof); + * MONO_API void mono_profiler_set_context_unloaded_callback (MonoProfiler *prof, MonoProfilerContextUnloadedCallback cb); + * + * Etc. + * + * To remove a callback, pass NULL instead of a valid function pointer. + * Callbacks can be changed at any point, but note that doing so is inherently + * racy with respect to threads that aren't suspended, i.e. you may still see a + * call from another thread right after you change a callback. + * + * These functions are async safe. + */ + +#define _MONO_PROFILER_EVENT(type, ...) \ + typedef void (*MonoProfiler ## type ## Callback) (__VA_ARGS__); +#define MONO_PROFILER_EVENT_0(name, type) \ + _MONO_PROFILER_EVENT(type, MonoProfiler *prof) +#define MONO_PROFILER_EVENT_1(name, type, arg1_type, arg1_name) \ + _MONO_PROFILER_EVENT(type, MonoProfiler *prof, arg1_type arg1_name) +#define MONO_PROFILER_EVENT_2(name, type, arg1_type, arg1_name, arg2_type, arg2_name) \ + _MONO_PROFILER_EVENT(type, MonoProfiler *prof, arg1_type arg1_name, arg2_type arg2_name) +#define MONO_PROFILER_EVENT_3(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name) \ + _MONO_PROFILER_EVENT(type, MonoProfiler *prof, arg1_type arg1_name, arg2_type arg2_name, arg3_type arg3_name) +#define MONO_PROFILER_EVENT_4(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name, arg4_type, arg4_name) \ + _MONO_PROFILER_EVENT(type, MonoProfiler *prof, arg1_type arg1_name, arg2_type arg2_name, arg3_type arg3_name, arg4_type arg4_name) +#define MONO_PROFILER_EVENT_5(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name, arg4_type, arg4_name, arg5_type, arg5_name) \ + _MONO_PROFILER_EVENT(type, MonoProfiler *prof, arg1_type arg1_name, arg2_type arg2_name, arg3_type arg3_name, arg4_type arg4_name, arg5_type arg5_name) +#include +#undef MONO_PROFILER_EVENT_0 +#undef MONO_PROFILER_EVENT_1 +#undef MONO_PROFILER_EVENT_2 +#undef MONO_PROFILER_EVENT_3 +#undef MONO_PROFILER_EVENT_4 +#undef MONO_PROFILER_EVENT_5 +#undef _MONO_PROFILER_EVENT + +#define _MONO_PROFILER_EVENT(name, type) \ + MONO_API void mono_profiler_set_ ## name ## _callback (MonoProfilerHandle handle, MonoProfiler ## type ## Callback cb); +#define MONO_PROFILER_EVENT_0(name, type) \ + _MONO_PROFILER_EVENT(name, type) +#define MONO_PROFILER_EVENT_1(name, type, arg1_type, arg1_name) \ + _MONO_PROFILER_EVENT(name, type) +#define MONO_PROFILER_EVENT_2(name, type, arg1_type, arg1_name, arg2_type, arg2_name) \ + _MONO_PROFILER_EVENT(name, type) +#define MONO_PROFILER_EVENT_3(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name) \ + _MONO_PROFILER_EVENT(name, type) +#define MONO_PROFILER_EVENT_4(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name, arg4_type, arg4_name) \ + _MONO_PROFILER_EVENT(name, type) +#define MONO_PROFILER_EVENT_5(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name, arg4_type, arg4_name, arg5_type, arg5_name) \ + _MONO_PROFILER_EVENT(name, type) +#include +#undef MONO_PROFILER_EVENT_0 +#undef MONO_PROFILER_EVENT_1 +#undef MONO_PROFILER_EVENT_2 +#undef MONO_PROFILER_EVENT_3 +#undef MONO_PROFILER_EVENT_4 +#undef MONO_PROFILER_EVENT_5 +#undef _MONO_PROFILER_EVENT + +MONO_END_DECLS + +#endif // __MONO_PROFILER_H__ diff --git a/src/mono/msvc/include/mono/metadata/reflection.h b/src/mono/msvc/include/mono/metadata/reflection.h new file mode 100644 index 0000000000000..83bcfccd657bf --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/reflection.h @@ -0,0 +1,174 @@ +/** + * \file + */ + +#ifndef __METADATA_REFLECTION_H__ +#define __METADATA_REFLECTION_H__ + +#include +#include + +MONO_BEGIN_DECLS + +typedef struct MonoTypeNameParse MonoTypeNameParse; + +typedef struct { + MonoMethod *ctor; + uint32_t data_size; + const mono_byte* data; +} MonoCustomAttrEntry; + +typedef struct { + int num_attrs; + int cached; + MonoImage *image; + MonoCustomAttrEntry attrs [MONO_ZERO_LEN_ARRAY]; +} MonoCustomAttrInfo; + +#define MONO_SIZEOF_CUSTOM_ATTR_INFO (offsetof (MonoCustomAttrInfo, attrs)) + +/* + * Information which isn't in the MonoMethod structure is stored here for + * dynamic methods. + */ +typedef struct { + char **param_names; + MonoMarshalSpec **param_marshall; + MonoCustomAttrInfo **param_cattr; + uint8_t** param_defaults; + uint32_t *param_default_types; + char *dllentry, *dll; +} MonoReflectionMethodAux; + +typedef enum { + ResolveTokenError_OutOfRange, + ResolveTokenError_BadTable, + ResolveTokenError_Other +} MonoResolveTokenError; + +MONO_API MONO_RT_EXTERNAL_ONLY +int mono_reflection_parse_type (char *name, MonoTypeNameParse *info); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoType* mono_reflection_get_type (MonoImage* image, MonoTypeNameParse *info, mono_bool ignorecase, mono_bool *type_resolve); +MONO_API void mono_reflection_free_type_info (MonoTypeNameParse *info); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoType* mono_reflection_type_from_name (char *name, MonoImage *image); +MONO_API MONO_RT_EXTERNAL_ONLY +uint32_t mono_reflection_get_token (MonoObject *obj); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoReflectionAssembly* mono_assembly_get_object (MonoDomain *domain, MonoAssembly *assembly); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoReflectionModule* mono_module_get_object (MonoDomain *domain, MonoImage *image); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoReflectionModule* mono_module_file_get_object (MonoDomain *domain, MonoImage *image, int table_index); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoReflectionType* mono_type_get_object (MonoDomain *domain, MonoType *type); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoReflectionMethod* mono_method_get_object (MonoDomain *domain, MonoMethod *method, MonoClass *refclass); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoReflectionField* mono_field_get_object (MonoDomain *domain, MonoClass *klass, MonoClassField *field); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoReflectionProperty* mono_property_get_object (MonoDomain *domain, MonoClass *klass, MonoProperty *property); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoReflectionEvent* mono_event_get_object (MonoDomain *domain, MonoClass *klass, MonoEvent *event); +/* note: this one is slightly different: we keep the whole array of params in the cache */ +MONO_API MONO_RT_EXTERNAL_ONLY +MonoArray* mono_param_get_objects (MonoDomain *domain, MonoMethod *method); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoReflectionMethodBody* mono_method_body_get_object (MonoDomain *domain, MonoMethod *method); + +MONO_API MonoObject *mono_get_dbnull_object (MonoDomain *domain); + +MONO_API MonoArray* mono_reflection_get_custom_attrs_by_type (MonoObject *obj, MonoClass *attr_klass, MonoError *error); +MONO_API MonoArray* mono_reflection_get_custom_attrs (MonoObject *obj); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoArray* mono_reflection_get_custom_attrs_data (MonoObject *obj); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoArray* mono_reflection_get_custom_attrs_blob (MonoReflectionAssembly *assembly, MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *porpValues, MonoArray *fields, MonoArray* fieldValues); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoCustomAttrInfo* mono_reflection_get_custom_attrs_info (MonoObject *obj); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoArray* mono_custom_attrs_construct (MonoCustomAttrInfo *cinfo); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoCustomAttrInfo* mono_custom_attrs_from_index (MonoImage *image, uint32_t idx); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoCustomAttrInfo* mono_custom_attrs_from_method (MonoMethod *method); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoCustomAttrInfo* mono_custom_attrs_from_class (MonoClass *klass); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoCustomAttrInfo* mono_custom_attrs_from_assembly (MonoAssembly *assembly); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoCustomAttrInfo* mono_custom_attrs_from_property (MonoClass *klass, MonoProperty *property); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoCustomAttrInfo* mono_custom_attrs_from_event (MonoClass *klass, MonoEvent *event); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoCustomAttrInfo* mono_custom_attrs_from_field (MonoClass *klass, MonoClassField *field); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoCustomAttrInfo* mono_custom_attrs_from_param (MonoMethod *method, uint32_t param); +MONO_API mono_bool mono_custom_attrs_has_attr (MonoCustomAttrInfo *ainfo, MonoClass *attr_klass); +MONO_API MONO_RT_EXTERNAL_ONLY +MonoObject* mono_custom_attrs_get_attr (MonoCustomAttrInfo *ainfo, MonoClass *attr_klass); +MONO_API void mono_custom_attrs_free (MonoCustomAttrInfo *ainfo); + + +#define MONO_DECLSEC_ACTION_MIN 0x1 +#define MONO_DECLSEC_ACTION_MAX 0x12 + +enum { + MONO_DECLSEC_FLAG_REQUEST = 0x00000001, + MONO_DECLSEC_FLAG_DEMAND = 0x00000002, + MONO_DECLSEC_FLAG_ASSERT = 0x00000004, + MONO_DECLSEC_FLAG_DENY = 0x00000008, + MONO_DECLSEC_FLAG_PERMITONLY = 0x00000010, + MONO_DECLSEC_FLAG_LINKDEMAND = 0x00000020, + MONO_DECLSEC_FLAG_INHERITANCEDEMAND = 0x00000040, + MONO_DECLSEC_FLAG_REQUEST_MINIMUM = 0x00000080, + MONO_DECLSEC_FLAG_REQUEST_OPTIONAL = 0x00000100, + MONO_DECLSEC_FLAG_REQUEST_REFUSE = 0x00000200, + MONO_DECLSEC_FLAG_PREJIT_GRANT = 0x00000400, + MONO_DECLSEC_FLAG_PREJIT_DENY = 0x00000800, + MONO_DECLSEC_FLAG_NONCAS_DEMAND = 0x00001000, + MONO_DECLSEC_FLAG_NONCAS_LINKDEMAND = 0x00002000, + MONO_DECLSEC_FLAG_NONCAS_INHERITANCEDEMAND = 0x00004000, + MONO_DECLSEC_FLAG_LINKDEMAND_CHOICE = 0x00008000, + MONO_DECLSEC_FLAG_INHERITANCEDEMAND_CHOICE = 0x00010000, + MONO_DECLSEC_FLAG_DEMAND_CHOICE = 0x00020000 +}; + +MONO_API uint32_t mono_declsec_flags_from_method (MonoMethod *method); +MONO_API uint32_t mono_declsec_flags_from_class (MonoClass *klass); +MONO_API uint32_t mono_declsec_flags_from_assembly (MonoAssembly *assembly); + +/* this structure MUST be kept in synch with RuntimeDeclSecurityEntry + * located in /mcs/class/corlib/System.Security/SecurityFrame.cs */ +typedef struct { + char *blob; /* pointer to metadata blob */ + uint32_t size; /* size of the metadata blob */ + uint32_t index; +} MonoDeclSecurityEntry; + +typedef struct { + MonoDeclSecurityEntry demand; + MonoDeclSecurityEntry noncasdemand; + MonoDeclSecurityEntry demandchoice; +} MonoDeclSecurityActions; + +MONO_API MonoBoolean mono_declsec_get_demands (MonoMethod *callee, MonoDeclSecurityActions* demands); +MONO_API MonoBoolean mono_declsec_get_linkdemands (MonoMethod *callee, MonoDeclSecurityActions* klass, MonoDeclSecurityActions* cmethod); +MONO_API MonoBoolean mono_declsec_get_inheritdemands_class (MonoClass *klass, MonoDeclSecurityActions* demands); +MONO_API MonoBoolean mono_declsec_get_inheritdemands_method (MonoMethod *callee, MonoDeclSecurityActions* demands); + +MONO_API MonoBoolean mono_declsec_get_method_action (MonoMethod *method, uint32_t action, MonoDeclSecurityEntry *entry); +MONO_API MonoBoolean mono_declsec_get_class_action (MonoClass *klass, uint32_t action, MonoDeclSecurityEntry *entry); +MONO_API MonoBoolean mono_declsec_get_assembly_action (MonoAssembly *assembly, uint32_t action, MonoDeclSecurityEntry *entry); + +MONO_API MONO_RT_EXTERNAL_ONLY +MonoType* mono_reflection_type_get_type (MonoReflectionType *reftype); + +MONO_API MonoAssembly* mono_reflection_assembly_get_assembly (MonoReflectionAssembly *refassembly); + +MONO_END_DECLS + +#endif /* __METADATA_REFLECTION_H__ */ diff --git a/src/mono/msvc/include/mono/metadata/row-indexes.h b/src/mono/msvc/include/mono/metadata/row-indexes.h new file mode 100644 index 0000000000000..b0f5dc072d681 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/row-indexes.h @@ -0,0 +1,503 @@ +/** + * \file + */ + +#ifndef __MONO_METADATA_ROW_INDEXES_H__ +#define __MONO_METADATA_ROW_INDEXES_H__ + +/* + * The last entry in the enum is used to give the number + * of columns in the row. + */ + +enum { + MONO_ASSEMBLY_HASH_ALG, + MONO_ASSEMBLY_MAJOR_VERSION, + MONO_ASSEMBLY_MINOR_VERSION, + MONO_ASSEMBLY_BUILD_NUMBER, + MONO_ASSEMBLY_REV_NUMBER, + MONO_ASSEMBLY_FLAGS, + MONO_ASSEMBLY_PUBLIC_KEY, + MONO_ASSEMBLY_NAME, + MONO_ASSEMBLY_CULTURE, + MONO_ASSEMBLY_SIZE +}; + +enum { + MONO_ASSEMBLYOS_PLATFORM, + MONO_ASSEMBLYOS_MAJOR_VERSION, + MONO_ASSEMBLYOS_MINOR_VERSION, + MONO_ASSEMBLYOS_SIZE +}; + +enum { + MONO_ASSEMBLY_PROCESSOR, + MONO_ASSEMBLY_PROCESSOR_SIZE +}; + +enum { + MONO_ASSEMBLYREF_MAJOR_VERSION, + MONO_ASSEMBLYREF_MINOR_VERSION, + MONO_ASSEMBLYREF_BUILD_NUMBER, + MONO_ASSEMBLYREF_REV_NUMBER, + MONO_ASSEMBLYREF_FLAGS, + MONO_ASSEMBLYREF_PUBLIC_KEY, + MONO_ASSEMBLYREF_NAME, + MONO_ASSEMBLYREF_CULTURE, + MONO_ASSEMBLYREF_HASH_VALUE, + MONO_ASSEMBLYREF_SIZE +}; + +enum { + MONO_ASSEMBLYREFOS_PLATFORM, + MONO_ASSEMBLYREFOS_MAJOR_VERSION, + MONO_ASSEMBLYREFOS_MINOR_VERSION, + MONO_ASSEMBLYREFOS_ASSEMBLYREF, + MONO_ASSEMBLYREFOS_SIZE +}; + +enum { + MONO_ASSEMBLYREFPROC_PROCESSOR, + MONO_ASSEMBLYREFPROC_ASSEMBLYREF, + MONO_ASSEMBLYREFPROC_SIZE +}; + +enum { + MONO_CLASS_LAYOUT_PACKING_SIZE, + MONO_CLASS_LAYOUT_CLASS_SIZE, + MONO_CLASS_LAYOUT_PARENT, + MONO_CLASS_LAYOUT_SIZE +}; + +enum { + MONO_CONSTANT_TYPE, + MONO_CONSTANT_PADDING, + MONO_CONSTANT_PARENT, + MONO_CONSTANT_VALUE, + MONO_CONSTANT_SIZE +}; + +enum { + MONO_CUSTOM_ATTR_PARENT, + MONO_CUSTOM_ATTR_TYPE, + MONO_CUSTOM_ATTR_VALUE, + MONO_CUSTOM_ATTR_SIZE +}; + +enum { + MONO_DECL_SECURITY_ACTION, + MONO_DECL_SECURITY_PARENT, + MONO_DECL_SECURITY_PERMISSIONSET, + MONO_DECL_SECURITY_SIZE +}; + +enum { + MONO_EVENT_MAP_PARENT, + MONO_EVENT_MAP_EVENTLIST, + MONO_EVENT_MAP_SIZE +}; + +enum { + MONO_EVENT_FLAGS, + MONO_EVENT_NAME, + MONO_EVENT_TYPE, + MONO_EVENT_SIZE +}; + +enum { + MONO_EVENT_POINTER_EVENT, + MONO_EVENT_POINTER_SIZE +}; + +enum { + MONO_EXP_TYPE_FLAGS, + MONO_EXP_TYPE_TYPEDEF, + MONO_EXP_TYPE_NAME, + MONO_EXP_TYPE_NAMESPACE, + MONO_EXP_TYPE_IMPLEMENTATION, + MONO_EXP_TYPE_SIZE +}; + +enum { + MONO_FIELD_FLAGS, + MONO_FIELD_NAME, + MONO_FIELD_SIGNATURE, + MONO_FIELD_SIZE +}; + +enum { + MONO_FIELD_LAYOUT_OFFSET, + MONO_FIELD_LAYOUT_FIELD, + MONO_FIELD_LAYOUT_SIZE +}; + +enum { + MONO_FIELD_MARSHAL_PARENT, + MONO_FIELD_MARSHAL_NATIVE_TYPE, + MONO_FIELD_MARSHAL_SIZE +}; + +enum { + MONO_FIELD_POINTER_FIELD, + MONO_FIELD_POINTER_SIZE +}; + +enum { + MONO_FIELD_RVA_RVA, + MONO_FIELD_RVA_FIELD, + MONO_FIELD_RVA_SIZE +}; + +enum { + MONO_ENCLOG_TOKEN, + MONO_ENCLOG_FUNC_CODE, + MONO_ENCLOG_SIZE +}; + +enum { + MONO_ENCMAP_TOKEN, + MONO_ENCMAP_SIZE +}; + +enum { + MONO_FILE_FLAGS, + MONO_FILE_NAME, + MONO_FILE_HASH_VALUE, + MONO_FILE_SIZE +}; + +enum { + MONO_IMPLMAP_FLAGS, + MONO_IMPLMAP_MEMBER, + MONO_IMPLMAP_NAME, + MONO_IMPLMAP_SCOPE, + MONO_IMPLMAP_SIZE +}; + +enum { + MONO_INTERFACEIMPL_CLASS, + MONO_INTERFACEIMPL_INTERFACE, + MONO_INTERFACEIMPL_SIZE +}; + +enum { + MONO_MANIFEST_OFFSET, + MONO_MANIFEST_FLAGS, + MONO_MANIFEST_NAME, + MONO_MANIFEST_IMPLEMENTATION, + MONO_MANIFEST_SIZE +}; + +enum { + MONO_MEMBERREF_CLASS, + MONO_MEMBERREF_NAME, + MONO_MEMBERREF_SIGNATURE, + MONO_MEMBERREF_SIZE +}; + +enum { + MONO_METHOD_RVA, + MONO_METHOD_IMPLFLAGS, + MONO_METHOD_FLAGS, + MONO_METHOD_NAME, + MONO_METHOD_SIGNATURE, + MONO_METHOD_PARAMLIST, + MONO_METHOD_SIZE +}; + +enum { + MONO_METHODIMPL_CLASS, + MONO_METHODIMPL_BODY, + MONO_METHODIMPL_DECLARATION, + MONO_METHODIMPL_SIZE +}; + +enum { + MONO_METHOD_POINTER_METHOD, + MONO_METHOD_POINTER_SIZE +}; + +enum { + MONO_METHOD_SEMA_SEMANTICS, + MONO_METHOD_SEMA_METHOD, + MONO_METHOD_SEMA_ASSOCIATION, + MONO_METHOD_SEMA_SIZE +}; + +enum { + MONO_MODULE_GENERATION, + MONO_MODULE_NAME, + MONO_MODULE_MVID, + MONO_MODULE_ENC, + MONO_MODULE_ENCBASE, + MONO_MODULE_SIZE +}; + +enum { + MONO_MODULEREF_NAME, + MONO_MODULEREF_SIZE +}; + +enum { + MONO_NESTED_CLASS_NESTED, + MONO_NESTED_CLASS_ENCLOSING, + MONO_NESTED_CLASS_SIZE +}; + +enum { + MONO_PARAM_FLAGS, + MONO_PARAM_SEQUENCE, + MONO_PARAM_NAME, + MONO_PARAM_SIZE +}; + +enum { + MONO_PARAM_POINTER_PARAM, + MONO_PARAM_POINTER_SIZE +}; + +enum { + MONO_PROPERTY_FLAGS, + MONO_PROPERTY_NAME, + MONO_PROPERTY_TYPE, + MONO_PROPERTY_SIZE +}; + +enum { + MONO_PROPERTY_POINTER_PROPERTY, + MONO_PROPERTY_POINTER_SIZE +}; + +enum { + MONO_PROPERTY_MAP_PARENT, + MONO_PROPERTY_MAP_PROPERTY_LIST, + MONO_PROPERTY_MAP_SIZE +}; + +enum { + MONO_STAND_ALONE_SIGNATURE, + MONO_STAND_ALONE_SIGNATURE_SIZE +}; + +enum { + MONO_TYPEDEF_FLAGS, + MONO_TYPEDEF_NAME, + MONO_TYPEDEF_NAMESPACE, + MONO_TYPEDEF_EXTENDS, + MONO_TYPEDEF_FIELD_LIST, + MONO_TYPEDEF_METHOD_LIST, + MONO_TYPEDEF_SIZE +}; + +enum { + MONO_TYPEREF_SCOPE, + MONO_TYPEREF_NAME, + MONO_TYPEREF_NAMESPACE, + MONO_TYPEREF_SIZE +}; + +enum { + MONO_TYPESPEC_SIGNATURE, + MONO_TYPESPEC_SIZE +}; + +enum { + MONO_GENERICPARAM_NUMBER, + MONO_GENERICPARAM_FLAGS, + MONO_GENERICPARAM_OWNER, + MONO_GENERICPARAM_NAME, + + MONO_GENERICPARAM_SIZE +}; + +enum { + MONO_METHODSPEC_METHOD, + MONO_METHODSPEC_SIGNATURE, + MONO_METHODSPEC_SIZE +}; + +enum { + MONO_GENPARCONSTRAINT_GENERICPAR, + MONO_GENPARCONSTRAINT_CONSTRAINT, + MONO_GENPARCONSTRAINT_SIZE +}; + +enum { + MONO_DOCUMENT_NAME, + MONO_DOCUMENT_HASHALG, + MONO_DOCUMENT_HASH, + MONO_DOCUMENT_LANGUAGE, + MONO_DOCUMENT_SIZE +}; + +enum { + MONO_METHODBODY_DOCUMENT, + MONO_METHODBODY_SEQ_POINTS, + MONO_METHODBODY_SIZE +}; + +enum { + MONO_LOCALSCOPE_METHOD, + MONO_LOCALSCOPE_IMPORTSCOPE, + MONO_LOCALSCOPE_VARIABLELIST, + MONO_LOCALSCOPE_CONSTANTLIST, + MONO_LOCALSCOPE_STARTOFFSET, + MONO_LOCALSCOPE_LENGTH, + MONO_LOCALSCOPE_SIZE +}; + +enum { + MONO_LOCALVARIABLE_ATTRIBUTES, + MONO_LOCALVARIABLE_INDEX, + MONO_LOCALVARIABLE_NAME, + MONO_LOCALVARIABLE_SIZE +}; + +enum { + MONO_CUSTOMDEBUGINFORMATION_PARENT, + MONO_CUSTOMDEBUGINFORMATION_KIND, + MONO_CUSTOMDEBUGINFORMATION_VALUE, + MONO_CUSTOMDEBUGINFORMATION_SIZE +}; + +/* + * Coded Tokens + * The _BITS entry is for the bits used in the token. + * The _MASK entry is for mask the index out. + */ + +enum { + MONO_TYPEDEFORREF_TYPEDEF, + MONO_TYPEDEFORREF_TYPEREF, + MONO_TYPEDEFORREF_TYPESPEC, + MONO_TYPEDEFORREF_BITS = 2, + MONO_TYPEDEFORREF_MASK = 3 +}; + +enum { + MONO_HASCONSTANT_FIEDDEF, + MONO_HASCONSTANT_PARAM, + MONO_HASCONSTANT_PROPERTY, + MONO_HASCONSTANT_BITS = 2, + MONO_HASCONSTANT_MASK = 3 +}; + +enum { + MONO_CUSTOM_ATTR_METHODDEF, + MONO_CUSTOM_ATTR_FIELDDEF, + MONO_CUSTOM_ATTR_TYPEREF, + MONO_CUSTOM_ATTR_TYPEDEF, + MONO_CUSTOM_ATTR_PARAMDEF, + MONO_CUSTOM_ATTR_INTERFACE, + MONO_CUSTOM_ATTR_MEMBERREF, + MONO_CUSTOM_ATTR_MODULE, + MONO_CUSTOM_ATTR_PERMISSION, + MONO_CUSTOM_ATTR_PROPERTY, + MONO_CUSTOM_ATTR_EVENT, + MONO_CUSTOM_ATTR_SIGNATURE, + MONO_CUSTOM_ATTR_MODULEREF, + MONO_CUSTOM_ATTR_TYPESPEC, + MONO_CUSTOM_ATTR_ASSEMBLY, + MONO_CUSTOM_ATTR_ASSEMBLYREF, + MONO_CUSTOM_ATTR_FILE, + MONO_CUSTOM_ATTR_EXP_TYPE, + MONO_CUSTOM_ATTR_MANIFEST, + MONO_CUSTOM_ATTR_GENERICPAR, + MONO_CUSTOM_ATTR_GENERICPARAMCONSTRAINT, + MONO_CUSTOM_ATTR_BITS = 5, + MONO_CUSTOM_ATTR_MASK = 0x1F +}; + +enum { + MONO_HAS_FIELD_MARSHAL_FIELDSREF, + MONO_HAS_FIELD_MARSHAL_PARAMDEF, + MONO_HAS_FIELD_MARSHAL_BITS = 1, + MONO_HAS_FIELD_MARSHAL_MASK = 1 +}; + +enum { + MONO_HAS_DECL_SECURITY_TYPEDEF, + MONO_HAS_DECL_SECURITY_METHODDEF, + MONO_HAS_DECL_SECURITY_ASSEMBLY, + MONO_HAS_DECL_SECURITY_BITS = 2, + MONO_HAS_DECL_SECURITY_MASK = 3 +}; + +enum { + MONO_MEMBERREF_PARENT_TYPEDEF, /* not used */ + MONO_MEMBERREF_PARENT_TYPEREF, + MONO_MEMBERREF_PARENT_MODULEREF, + MONO_MEMBERREF_PARENT_METHODDEF, + MONO_MEMBERREF_PARENT_TYPESPEC, + MONO_MEMBERREF_PARENT_BITS = 3, + MONO_MEMBERREF_PARENT_MASK = 7 +}; + +enum { + MONO_HAS_SEMANTICS_EVENT, + MONO_HAS_SEMANTICS_PROPERTY, + MONO_HAS_SEMANTICS_BITS = 1, + MONO_HAS_SEMANTICS_MASK = 1 +}; + +enum { + MONO_METHODDEFORREF_METHODDEF, + MONO_METHODDEFORREF_METHODREF, + MONO_METHODDEFORREF_BITS = 1, + MONO_METHODDEFORREF_MASK = 1 +}; + +enum { + MONO_MEMBERFORWD_FIELDDEF, + MONO_MEMBERFORWD_METHODDEF, + MONO_MEMBERFORWD_BITS = 1, + MONO_MEMBERFORWD_MASK = 1 +}; + +enum { + MONO_IMPLEMENTATION_FILE, + MONO_IMPLEMENTATION_ASSEMBLYREF, + MONO_IMPLEMENTATION_EXP_TYPE, + MONO_IMPLEMENTATION_BITS = 2, + MONO_IMPLEMENTATION_MASK = 3 +}; + +enum { + MONO_CUSTOM_ATTR_TYPE_TYPEREF, /* not used */ + MONO_CUSTOM_ATTR_TYPE_TYPEDEF, /* not used */ + MONO_CUSTOM_ATTR_TYPE_METHODDEF, + MONO_CUSTOM_ATTR_TYPE_MEMBERREF, + MONO_CUSTOM_ATTR_TYPE_STRING, /* not used */ + MONO_CUSTOM_ATTR_TYPE_BITS = 3, + MONO_CUSTOM_ATTR_TYPE_MASK = 7 +}; + +enum { + MONO_RESOLUTION_SCOPE_MODULE, + MONO_RESOLUTION_SCOPE_MODULEREF, + MONO_RESOLUTION_SCOPE_ASSEMBLYREF, + MONO_RESOLUTION_SCOPE_TYPEREF, + MONO_RESOLUTION_SCOPE_BITS = 2, + MONO_RESOLUTION_SCOPE_MASK = 3 +}; + +/* Kept for compatibility since this is a public header file */ +enum { + MONO_RESOLTION_SCOPE_MODULE, + MONO_RESOLTION_SCOPE_MODULEREF, + MONO_RESOLTION_SCOPE_ASSEMBLYREF, + MONO_RESOLTION_SCOPE_TYPEREF, + MONO_RESOLTION_SCOPE_BITS = 2, + MONO_RESOLTION_SCOPE_MASK = 3 +}; + +enum { + MONO_TYPEORMETHOD_TYPE, + MONO_TYPEORMETHOD_METHOD, + MONO_TYPEORMETHOD_BITS = 1, + MONO_TYPEORMETHOD_MASK = 1 +}; + +#endif /* __MONO_METADATA_ROW_INDEXES_H__ */ + + diff --git a/src/mono/msvc/include/mono/metadata/sgen-bridge.h b/src/mono/msvc/include/mono/metadata/sgen-bridge.h new file mode 100644 index 0000000000000..c131f3066914e --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/sgen-bridge.h @@ -0,0 +1,110 @@ +/** + * \file + * Copyright 2011 Novell, Inc. + * + * Licensed under the MIT license. See LICENSE file in the project root for full license information. + */ + +/* + * The bridge is a mechanism for SGen to let clients override the death of some + * unreachable objects. We use it in monodroid to do garbage collection across + * the Mono and Java heaps. + * + * The client (Monodroid) can designate some objects as "bridged", which means + * that they participate in the bridge processing step once SGen considers them + * unreachable, i.e., dead. Bridged objects must be registered for + * finalization. + * + * When SGen is done marking, it puts together a list of all dead bridged + * objects. This is passed to the bridge processor, which does an analysis to + * simplify the graph: It replaces strongly-connected components with single + * nodes, and may remove nodes corresponding to components which do not contain + * bridged objects. + * + * The output of the SCC analysis is passed to the client's `cross_references()` + * callback. This consists of 2 arrays, an array of SCCs (MonoGCBridgeSCC), + * and an array of "xrefs" (edges between SCCs, MonoGCBridgeXRef). Edges are + * encoded as pairs of "API indices", ie indexes in the SCC array. The client + * is expected to set the `is_alive` flag on those strongly connected components + * that it wishes to be kept alive. + * + * In monodroid each bridged object has a corresponding Java mirror object. In + * the bridge callback it reifies the Mono object graph in the Java heap so that + * the full, combined object graph is now instantiated on the Java side. Then + * it triggers a Java GC, waits for it to finish, and checks which of the Java + * mirror objects are still alive. For those it sets the `is_alive` flag and + * returns from the callback. + * + * The SCC analysis is done while the world is stopped, but the callback is made + * with the world running again. Weak links to bridged objects and other + * objects reachable from them are kept until the callback returns, at which + * point all links to bridged objects that don't have `is_alive` set are nulled. + * Note that weak links to non-bridged objects reachable from bridged objects + * are not nulled. This might be considered a bug. + * + * There are three different implementations of the bridge processor, each of + * which implements 8 callbacks (see SgenBridgeProcessor). The implementations + * differ in the algorithm they use to compute the "simplified" SCC graph. + */ + +#ifndef _MONO_SGEN_BRIDGE_H_ +#define _MONO_SGEN_BRIDGE_H_ + +#include + +MONO_BEGIN_DECLS + +enum { + SGEN_BRIDGE_VERSION = 5 +}; + +typedef enum { + /* Instances of this class should be scanned when computing the transitive dependency among bridges. E.g. List*/ + GC_BRIDGE_TRANSPARENT_CLASS, + /* Instances of this class should not be scanned when computing the transitive dependency among bridges. E.g. String*/ + GC_BRIDGE_OPAQUE_CLASS, + /* Instances of this class should be bridged and have their dependency computed. */ + GC_BRIDGE_TRANSPARENT_BRIDGE_CLASS, + /* Instances of this class should be bridged but no dependencies should not be calculated. */ + GC_BRIDGE_OPAQUE_BRIDGE_CLASS, +} MonoGCBridgeObjectKind; + +typedef struct { + mono_bool is_alive; /* to be set by the cross reference callback */ + int num_objs; + MonoObject *objs [MONO_ZERO_LEN_ARRAY]; +} MonoGCBridgeSCC; + +typedef struct { + int src_scc_index; + int dst_scc_index; +} MonoGCBridgeXRef; + +typedef struct { + int bridge_version; + /* + * Tells the runtime which classes to even consider when looking for + * bridged objects. If subclasses are to be considered as well, the + * subclass check must be done in the callback. + */ + MonoGCBridgeObjectKind (*bridge_class_kind) (MonoClass *klass); + /* + * This is only called on objects for whose classes + * `bridge_class_kind()` returned `XXX_BRIDGE_CLASS`. + */ + mono_bool (*is_bridge_object) (MonoObject *object); + void (*cross_references) (int num_sccs, MonoGCBridgeSCC **sccs, int num_xrefs, MonoGCBridgeXRef *xrefs); +} MonoGCBridgeCallbacks; + +/* + * Note: This may be called at any time, but cannot be called concurrently + * with (during and on a separate thread from) sgen init. Callers are + * responsible for enforcing this. + */ +MONO_API void mono_gc_register_bridge_callbacks (MonoGCBridgeCallbacks *callbacks); + +MONO_API void mono_gc_wait_for_bridge_processing (void); + +MONO_END_DECLS + +#endif diff --git a/src/mono/msvc/include/mono/metadata/threads.h b/src/mono/msvc/include/mono/metadata/threads.h new file mode 100644 index 0000000000000..89be80f5a024b --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/threads.h @@ -0,0 +1,69 @@ +/** + * \file + * Threading API + * + * Author: + * Dick Porter (dick@ximian.com) + * Patrik Torstensson (patrik.torstensson@labs2.com) + * + * (C) 2001 Ximian, Inc + */ + +#ifndef _MONO_METADATA_THREADS_H_ +#define _MONO_METADATA_THREADS_H_ + +#include +#include +#include + +MONO_BEGIN_DECLS + +/* This callback should return TRUE if the runtime must wait for the thread, FALSE otherwise */ +typedef mono_bool (*MonoThreadManageCallback) (MonoThread* thread); + +MONO_API void mono_thread_init (MonoThreadStartCB start_cb, + MonoThreadAttachCB attach_cb); +MONO_API void mono_thread_cleanup (void); +MONO_API MONO_RT_EXTERNAL_ONLY +void mono_thread_manage(void); + +MONO_API MonoThread *mono_thread_current (void); + +MONO_API void mono_thread_set_main (MonoThread *thread); +MONO_API MonoThread *mono_thread_get_main (void); + +MONO_API MONO_RT_EXTERNAL_ONLY void mono_thread_stop (MonoThread *thread); + +MONO_API void mono_thread_new_init (intptr_t tid, void* stack_start, + void* func); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_thread_create (MonoDomain *domain, void* func, void* arg); + +MONO_API MONO_RT_EXTERNAL_ONLY MonoThread * +mono_thread_attach (MonoDomain *domain); +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_thread_detach (MonoThread *thread); +MONO_API void mono_thread_exit (void); + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_threads_attach_tools_thread (void); + +MONO_API char *mono_thread_get_name_utf8 (MonoThread *thread); +MONO_API int32_t mono_thread_get_managed_id (MonoThread *thread); + +MONO_API void mono_thread_set_manage_callback (MonoThread *thread, MonoThreadManageCallback func); + +MONO_API void mono_threads_set_default_stacksize (uint32_t stacksize); +MONO_API uint32_t mono_threads_get_default_stacksize (void); + +MONO_API void mono_threads_request_thread_dump (void); + +MONO_API mono_bool mono_thread_is_foreign (MonoThread *thread); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_thread_detach_if_exiting (void); + +MONO_END_DECLS + +#endif /* _MONO_METADATA_THREADS_H_ */ diff --git a/src/mono/msvc/include/mono/metadata/tokentype.h b/src/mono/msvc/include/mono/metadata/tokentype.h new file mode 100644 index 0000000000000..a1c58944d7404 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/tokentype.h @@ -0,0 +1,45 @@ +/** + * \file + */ + +#ifndef _MONO_METADATA_TOKENTYPE_H_ +#define _MONO_METADATA_TOKENTYPE_H_ + +/* + * These tokens match the table ID except for the last + * three (string, name and base type which are special) + */ + +typedef enum { + MONO_TOKEN_MODULE = 0x00000000, + MONO_TOKEN_TYPE_REF = 0x01000000, + MONO_TOKEN_TYPE_DEF = 0x02000000, + MONO_TOKEN_FIELD_DEF = 0x04000000, + MONO_TOKEN_METHOD_DEF = 0x06000000, + MONO_TOKEN_PARAM_DEF = 0x08000000, + MONO_TOKEN_INTERFACE_IMPL = 0x09000000, + MONO_TOKEN_MEMBER_REF = 0x0a000000, + MONO_TOKEN_CUSTOM_ATTRIBUTE = 0x0c000000, + MONO_TOKEN_PERMISSION = 0x0e000000, + MONO_TOKEN_SIGNATURE = 0x11000000, + MONO_TOKEN_EVENT = 0x14000000, + MONO_TOKEN_PROPERTY = 0x17000000, + MONO_TOKEN_MODULE_REF = 0x1a000000, + MONO_TOKEN_TYPE_SPEC = 0x1b000000, + MONO_TOKEN_ASSEMBLY = 0x20000000, + MONO_TOKEN_ASSEMBLY_REF = 0x23000000, + MONO_TOKEN_FILE = 0x26000000, + MONO_TOKEN_EXPORTED_TYPE = 0x27000000, + MONO_TOKEN_MANIFEST_RESOURCE = 0x28000000, + MONO_TOKEN_GENERIC_PARAM = 0x2a000000, + MONO_TOKEN_METHOD_SPEC = 0x2b000000, + + /* + * These do not match metadata tables directly + */ + MONO_TOKEN_STRING = 0x70000000, + MONO_TOKEN_NAME = 0x71000000, + MONO_TOKEN_BASE_TYPE = 0x72000000 +} MonoTokenType; + +#endif /* _MONO_METADATA_TOKENTYPE_H_ */ diff --git a/src/mono/msvc/include/mono/metadata/verify.h b/src/mono/msvc/include/mono/metadata/verify.h new file mode 100644 index 0000000000000..162ef4434e682 --- /dev/null +++ b/src/mono/msvc/include/mono/metadata/verify.h @@ -0,0 +1,66 @@ +/** + * \file + */ + +#ifndef __MONO_METADATA_VERIFY_H__ +#define __MONO_METADATA_VERIFY_H__ + +#include +#include +#include +#include /* GSList dep */ + +MONO_BEGIN_DECLS + +typedef enum { + MONO_VERIFY_OK, + MONO_VERIFY_ERROR, + MONO_VERIFY_WARNING, + MONO_VERIFY_CLS = 4, + MONO_VERIFY_ALL = 7, + + /* Status signaling code that is not verifiable.*/ + MONO_VERIFY_NOT_VERIFIABLE = 8, + + /*OR it with other flags*/ + + /* Abort the verification if the code is not verifiable. + * The standard behavior is to abort if the code is not valid. + * */ + MONO_VERIFY_FAIL_FAST = 16, + + + /* Perform less verification of the code. This flag should be used + * if one wants the verifier to be more compatible to the MS runtime. + * Mind that this is not to be more compatible with MS peverify, but + * with the runtime itself, that has a less strict verifier. + */ + MONO_VERIFY_NON_STRICT = 32, + + /*Skip all visibility related checks*/ + MONO_VERIFY_SKIP_VISIBILITY = 64, + + /*Skip all visibility related checks*/ + MONO_VERIFY_REPORT_ALL_ERRORS = 128 + +} MonoVerifyStatus; + +typedef struct { + char *message; + MonoVerifyStatus status; +} MonoVerifyInfo; + +typedef struct { + MonoVerifyInfo info; + int8_t exception_type; /*should be one of MONO_EXCEPTION_* */ +} MonoVerifyInfoExtended; + + +MONO_API GSList* mono_method_verify (MonoMethod *method, int level); +MONO_API void mono_free_verify_list (GSList *list); +MONO_API char* mono_verify_corlib (void); + +MONO_END_DECLS + +#endif /* __MONO_METADATA_VERIFY_H__ */ + diff --git a/src/mono/msvc/include/mono/utils/mono-counters.h b/src/mono/msvc/include/mono/utils/mono-counters.h new file mode 100644 index 0000000000000..77175b35f49a8 --- /dev/null +++ b/src/mono/msvc/include/mono/utils/mono-counters.h @@ -0,0 +1,105 @@ +/** + * \file + */ + +#ifndef __MONO_COUNTERS_H__ +#define __MONO_COUNTERS_H__ + +#include +#include + +enum { + /* Counter type, bits 0-7. */ + MONO_COUNTER_INT, /* 32 bit int */ + MONO_COUNTER_UINT, /* 32 bit uint */ + MONO_COUNTER_WORD, /* pointer-sized int */ + MONO_COUNTER_LONG, /* 64 bit int */ + MONO_COUNTER_ULONG, /* 64 bit uint */ + MONO_COUNTER_DOUBLE, + MONO_COUNTER_STRING, /* char* */ + MONO_COUNTER_TIME_INTERVAL, /* 64 bits signed int holding usecs. */ + MONO_COUNTER_TYPE_MASK = 0xf, + MONO_COUNTER_CALLBACK = 128, /* ORed with the other values */ + MONO_COUNTER_SECTION_MASK = 0x00ffff00, + /* Sections, bits 8-23 (16 bits) */ + MONO_COUNTER_JIT = 1 << 8, + MONO_COUNTER_GC = 1 << 9, + MONO_COUNTER_METADATA = 1 << 10, + MONO_COUNTER_GENERICS = 1 << 11, + MONO_COUNTER_SECURITY = 1 << 12, + MONO_COUNTER_RUNTIME = 1 << 13, + MONO_COUNTER_SYSTEM = 1 << 14, + MONO_COUNTER_PERFCOUNTERS = 1 << 15, + MONO_COUNTER_PROFILER = 1 << 16, + MONO_COUNTER_INTERP = 1 << 17, + MONO_COUNTER_TIERED = 1 << 18, + MONO_COUNTER_LAST_SECTION, + + /* Unit, bits 24-27 (4 bits) */ + MONO_COUNTER_UNIT_SHIFT = 24, + MONO_COUNTER_UNIT_MASK = 0xFu << MONO_COUNTER_UNIT_SHIFT, + MONO_COUNTER_RAW = 0 << 24, /* Raw value */ + MONO_COUNTER_BYTES = 1 << 24, /* Quantity of bytes. RSS, active heap, etc */ + MONO_COUNTER_TIME = 2 << 24, /* Time interval in 100ns units. Minor pause, JIT compilation*/ + MONO_COUNTER_COUNT = 3 << 24, /* Number of things (threads, queued jobs) or Number of events triggered (Major collections, Compiled methods).*/ + MONO_COUNTER_PERCENTAGE = 4 << 24, /* [0-1] Fraction Percentage of something. Load average. */ + + /* Monotonicity, bits 28-31 (4 bits) */ + MONO_COUNTER_VARIANCE_SHIFT = 28, + MONO_COUNTER_VARIANCE_MASK = 0xFu << MONO_COUNTER_VARIANCE_SHIFT, + MONO_COUNTER_MONOTONIC = 1 << 28, /* This counter value always increase/decreases over time. Reported by --stat. */ + MONO_COUNTER_CONSTANT = 1 << 29, /* Fixed value. Used by configuration data. */ + MONO_COUNTER_VARIABLE = 1 << 30, /* This counter value can be anything on each sampling. Only interesting when sampling. */ +}; + +typedef struct _MonoCounter MonoCounter; + +MONO_API void mono_counters_enable (int section_mask); +MONO_API void mono_counters_init (void); + +/* + * register addr as the address of a counter of type type. + * It may be a function pointer if MONO_COUNTER_CALLBACK is specified: + * the function should return the value and take no arguments. + */ +MONO_API void mono_counters_register (const char* descr, int type, void *addr); +MONO_API void mono_counters_register_with_size (const char *name, int type, void *addr, int size); + +typedef void (*MonoCounterRegisterCallback) (MonoCounter*); +MONO_API void mono_counters_on_register (MonoCounterRegisterCallback callback); + +/* + * Create a readable dump of the counters for section_mask sections (ORed section values) + */ +MONO_API void mono_counters_dump (int section_mask, FILE *outfile); + +MONO_API void mono_counters_cleanup (void); + +typedef mono_bool (*CountersEnumCallback) (MonoCounter *counter, void *user_data); + +MONO_API void mono_counters_foreach (CountersEnumCallback cb, void *user_data); + +MONO_API int mono_counters_sample (MonoCounter *counter, void *buffer, int buffer_size); + +MONO_API const char* mono_counter_get_name (MonoCounter *name); +MONO_API int mono_counter_get_type (MonoCounter *counter); +MONO_API int mono_counter_get_section (MonoCounter *counter); +MONO_API int mono_counter_get_unit (MonoCounter *counter); +MONO_API int mono_counter_get_variance (MonoCounter *counter); +MONO_API size_t mono_counter_get_size (MonoCounter *counter); + +typedef enum { + MONO_RESOURCE_JIT_CODE, /* bytes */ + MONO_RESOURCE_METADATA, /* bytes */ + MONO_RESOURCE_GC_HEAP, /* bytes */ + MONO_RESOURCE_COUNT /* non-ABI value */ +} MonoResourceType; + +typedef void (*MonoResourceCallback) (int resource_type, uintptr_t value, int is_soft); + +MONO_API int mono_runtime_resource_limit (int resource_type, uintptr_t soft_limit, uintptr_t hard_limit); +MONO_API void mono_runtime_resource_set_callback (MonoResourceCallback callback); +MONO_API void mono_runtime_resource_check_limit (int resource_type, uintptr_t value); + +#endif /* __MONO_COUNTERS_H__ */ + diff --git a/src/mono/msvc/include/mono/utils/mono-dl-fallback.h b/src/mono/msvc/include/mono/utils/mono-dl-fallback.h new file mode 100644 index 0000000000000..11ec4f30b8ac0 --- /dev/null +++ b/src/mono/msvc/include/mono/utils/mono-dl-fallback.h @@ -0,0 +1,43 @@ +/** + * \file + */ + +#ifndef __MONO_UTILS_DL_FALLBACK_H__ +#define __MONO_UTILS_DL_FALLBACK_H__ + +#include + +MONO_BEGIN_DECLS + +enum { + MONO_DL_EAGER = 0, + MONO_DL_LAZY = 1, + // If MONO_DL_LOCAL is set, it will trump MONO_DL_GLOBAL. + MONO_DL_LOCAL = 2, + // MONO_DL_MASK is unused internally and no longer a full mask on netcore, given the introduction of MONO_DL_GLOBAL. Avoid. + MONO_DL_MASK = 3, + // Only applicable when building Mono in netcore mode. + MONO_DL_GLOBAL = 4 +}; + +/* + * This is the dynamic loader fallback API + */ +typedef struct MonoDlFallbackHandler MonoDlFallbackHandler; + +/* + * The "err" variable contents must be allocated using g_malloc or g_strdup + */ +typedef void* (*MonoDlFallbackLoad) (const char *name, int flags, char **err, void *user_data); +typedef void* (*MonoDlFallbackSymbol) (void *handle, const char *name, char **err, void *user_data); +typedef void* (*MonoDlFallbackClose) (void *handle, void *user_data); + +MONO_API MonoDlFallbackHandler *mono_dl_fallback_register (MonoDlFallbackLoad load_func, MonoDlFallbackSymbol symbol_func, + MonoDlFallbackClose close_func, void *user_data); + +MONO_API void mono_dl_fallback_unregister (MonoDlFallbackHandler *handler); + +MONO_END_DECLS + +#endif /* __MONO_UTILS_DL_FALLBACK_H__ */ + diff --git a/src/mono/msvc/include/mono/utils/mono-error.h b/src/mono/msvc/include/mono/utils/mono-error.h new file mode 100644 index 0000000000000..69bfb8a47346f --- /dev/null +++ b/src/mono/msvc/include/mono/utils/mono-error.h @@ -0,0 +1,105 @@ +/** + * \file + */ + +#ifndef __MONO_ERROR_H__ +#define __MONO_ERROR_H__ + +#include + +enum { + /* + The supplied strings were dup'd by means of calling mono_error_dup_strings. + */ + MONO_ERROR_FREE_STRINGS = 0x0001, + + /* + Something happened while processing the error and the resulting message is incomplete. + */ + MONO_ERROR_INCOMPLETE = 0x0002, + /* + This MonoError is heap allocated in a mempool + */ + MONO_ERROR_MEMPOOL_BOXED = 0x0004 +}; + +enum { + MONO_ERROR_NONE = 0, + MONO_ERROR_MISSING_METHOD = 1, + MONO_ERROR_MISSING_FIELD = 2, + MONO_ERROR_TYPE_LOAD = 3, + MONO_ERROR_FILE_NOT_FOUND = 4, + MONO_ERROR_BAD_IMAGE = 5, + MONO_ERROR_OUT_OF_MEMORY = 6, + MONO_ERROR_ARGUMENT = 7, + MONO_ERROR_ARGUMENT_NULL = 11, + MONO_ERROR_ARGUMENT_OUT_OF_RANGE = 14, + MONO_ERROR_NOT_VERIFIABLE = 8, + MONO_ERROR_INVALID_PROGRAM = 12, + MONO_ERROR_MEMBER_ACCESS = 13, + + /* + * This is a generic error mechanism is you need to raise an arbitrary corlib exception. + * You must pass the exception name otherwise prepare_exception will fail with internal execution. + */ + MONO_ERROR_GENERIC = 9, + /* This one encapsulates a managed exception instance */ + MONO_ERROR_EXCEPTION_INSTANCE = 10, + + /* Not a valid error code - indicates that the error was cleaned up and reused */ + MONO_ERROR_CLEANUP_CALLED_SENTINEL = 0xffff +}; + +#ifdef _MSC_VER +__pragma(warning (push)) +__pragma(warning (disable:4201)) +#endif + +/*Keep in sync with MonoErrorInternal*/ +typedef union _MonoError { + // Merge two uint16 into one uint32 so it can be initialized + // with one instruction instead of two. + uint32_t init; + struct { + uint16_t error_code; + uint16_t private_flags; /*DON'T TOUCH */ + void *hidden_1 [12]; /*DON'T TOUCH */ + }; +} MonoErrorExternal; + +#ifdef _MSC_VER +__pragma(warning (pop)) +#endif + +#ifdef MONO_INSIDE_RUNTIME +typedef union _MonoErrorInternal MonoError; +#else +typedef MonoErrorExternal MonoError; +#endif + +/* Mempool-allocated MonoError.*/ +typedef struct _MonoErrorBoxed MonoErrorBoxed; + +MONO_BEGIN_DECLS + +MONO_API MONO_RT_EXTERNAL_ONLY void +mono_error_init (MonoError *error); + +MONO_API void +mono_error_init_flags (MonoError *error, unsigned short flags); + +MONO_API void +mono_error_cleanup (MonoError *error); + +MONO_API MONO_RT_EXTERNAL_ONLY mono_bool +mono_error_ok (MonoError *error); + +MONO_API unsigned short +mono_error_get_error_code (MonoError *error); + +MONO_API const char* +mono_error_get_message (MonoError *error); + +MONO_END_DECLS + +#endif diff --git a/src/mono/msvc/include/mono/utils/mono-forward.h b/src/mono/msvc/include/mono/utils/mono-forward.h new file mode 100644 index 0000000000000..784f6e080921a --- /dev/null +++ b/src/mono/msvc/include/mono/utils/mono-forward.h @@ -0,0 +1,15 @@ +/** + * \file + * + * (C) 2018 Microsoft, Inc. + * + */ +#ifndef _MONO_UTILS_FORWARD_ +#define _MONO_UTILS_FORWARD_ + +typedef struct _MonoDomain MonoDomain; +typedef struct _MonoJitInfo MonoJitInfo; + +typedef void * MonoGCHandle; + +#endif diff --git a/src/mono/msvc/include/mono/utils/mono-jemalloc.h b/src/mono/msvc/include/mono/utils/mono-jemalloc.h new file mode 100644 index 0000000000000..6721877f51428 --- /dev/null +++ b/src/mono/msvc/include/mono/utils/mono-jemalloc.h @@ -0,0 +1,36 @@ +/** + * \file + * + * Header for jemalloc registration code + */ + +#ifndef __MONO_JEMALLOC_H__ +#define __MONO_JEMALLOC_H__ + +#if defined(MONO_JEMALLOC_ENABLED) + +#include + +/* Jemalloc can be configured in three ways. + * 1. You can use it with library loading hacks at run-time + * 2. You can use it as a global malloc replacement + * 3. You can use it with a prefix. If you use it with a prefix, you have to explicitly name the malloc function. + * + * In order to make this feature able to be toggled at run-time, I chose to use a prefix of mono_je. + * This mapping is captured below in the header, in the spirit of "no magic constants". + * + * The place that configures jemalloc and sets this prefix is in the Makefile in + * mono/jemalloc/Makefile.am + * + */ +#define MONO_JEMALLOC_MALLOC mono_jemalloc +#define MONO_JEMALLOC_REALLOC mono_jerealloc +#define MONO_JEMALLOC_FREE mono_jefree +#define MONO_JEMALLOC_CALLOC mono_jecalloc + +void mono_init_jemalloc (void); + +#endif + +#endif + diff --git a/src/mono/msvc/include/mono/utils/mono-logger.h b/src/mono/msvc/include/mono/utils/mono-logger.h new file mode 100644 index 0000000000000..a90e6c54cf365 --- /dev/null +++ b/src/mono/msvc/include/mono/utils/mono-logger.h @@ -0,0 +1,31 @@ +/** + * \file + */ + +#ifndef __MONO_LOGGER_H__ +#define __MONO_LOGGER_H__ + +#include +MONO_BEGIN_DECLS + +MONO_API void +mono_trace_set_level_string (const char *value); + +MONO_API void +mono_trace_set_mask_string (const char *value); + +typedef void (*MonoPrintCallback) (const char *string, mono_bool is_stdout); +typedef void (*MonoLogCallback) (const char *log_domain, const char *log_level, const char *message, mono_bool fatal, void *user_data); + +MONO_API void +mono_trace_set_log_handler (MonoLogCallback callback, void *user_data); + +MONO_API void +mono_trace_set_print_handler (MonoPrintCallback callback); + +MONO_API void +mono_trace_set_printerr_handler (MonoPrintCallback callback); + +MONO_END_DECLS + +#endif /* __MONO_LOGGER_H__ */ diff --git a/src/mono/msvc/include/mono/utils/mono-private-unstable.h b/src/mono/msvc/include/mono/utils/mono-private-unstable.h new file mode 100644 index 0000000000000..241a723447957 --- /dev/null +++ b/src/mono/msvc/include/mono/utils/mono-private-unstable.h @@ -0,0 +1,19 @@ +/** + * \file + * + * Private unstable APIs. + * + * WARNING: The declarations and behavior of functions in this header are NOT STABLE and can be modified or removed at + * any time. + * + */ + + +#ifndef __MONO_UTILS_MONO_PRIVATE_UNSTABLE_H__ +#define __MONO_UTILS_MONO_PRIVATE_UNSTABLE_H__ + +#include + + + +#endif /*__MONO_UTILS_MONO_PRIVATE_UNSTABLE_H__*/ diff --git a/src/mono/msvc/include/mono/utils/mono-publib.h b/src/mono/msvc/include/mono/utils/mono-publib.h new file mode 100644 index 0000000000000..b01438e52cf1c --- /dev/null +++ b/src/mono/msvc/include/mono/utils/mono-publib.h @@ -0,0 +1,187 @@ +/** + * \file + */ + +#ifndef __MONO_PUBLIB_H__ +#define __MONO_PUBLIB_H__ + +/* + * Minimal general purpose header for use in public mono header files. + * We can't include config.h, so we use compiler-specific preprocessor + * directives where needed. + */ + +#ifdef __cplusplus +#define MONO_BEGIN_DECLS extern "C" { +#define MONO_END_DECLS } +#else +#define MONO_BEGIN_DECLS /* nothing */ +#define MONO_END_DECLS /* nothing */ +#endif + +MONO_BEGIN_DECLS + +/* VS 2010 and later have stdint.h */ +#if defined(_MSC_VER) + +#if _MSC_VER < 1600 + +typedef __int8 int8_t; +typedef unsigned __int8 uint8_t; +typedef __int16 int16_t; +typedef unsigned __int16 uint16_t; +typedef __int32 int32_t; +typedef unsigned __int32 uint32_t; +typedef __int64 int64_t; +typedef unsigned __int64 uint64_t; + +#else + +#include + +#endif + +#define MONO_API_EXPORT __declspec(dllexport) +#define MONO_API_IMPORT __declspec(dllimport) + +#else + +#include + +#if defined (__clang__) || defined (__GNUC__) +#define MONO_API_EXPORT __attribute__ ((__visibility__ ("default"))) +#else +#define MONO_API_EXPORT +#endif +#define MONO_API_IMPORT + +#endif /* end of compiler-specific stuff */ + +#include + +#ifdef __cplusplus +#define MONO_EXTERN_C extern "C" +#else +#define MONO_EXTERN_C /* nothing */ +#endif + +#if defined(MONO_DLL_EXPORT) + #define MONO_API_NO_EXTERN_C MONO_API_EXPORT +#elif defined(MONO_DLL_IMPORT) + #define MONO_API_NO_EXTERN_C MONO_API_IMPORT +#else + #define MONO_API_NO_EXTERN_C /* nothing */ +#endif + +#define MONO_API MONO_EXTERN_C MONO_API_NO_EXTERN_C + +// Should (but not must) wrap in extern "C" (MONO_BEGIN_DECLS, MONO_END_DECLS). +#define MONO_API_DATA MONO_API_NO_EXTERN_C extern + +typedef int32_t mono_bool; +typedef uint8_t mono_byte; +typedef mono_byte MonoBoolean; +#ifdef _WIN32 +MONO_END_DECLS +#include +typedef wchar_t mono_unichar2; +MONO_BEGIN_DECLS +#else +typedef uint16_t mono_unichar2; +#endif +typedef uint32_t mono_unichar4; + +typedef void (*MonoFunc) (void* data, void* user_data); +typedef void (*MonoHFunc) (void* key, void* value, void* user_data); + +MONO_API void mono_free (void *); + +#define MONO_ALLOCATOR_VTABLE_VERSION 1 + +typedef struct { + int version; + void *(*malloc) (size_t size); + void *(*realloc) (void *mem, size_t count); + void (*free) (void *mem); + void *(*calloc) (size_t count, size_t size); +} MonoAllocatorVTable; + +MONO_API mono_bool +mono_set_allocator_vtable (MonoAllocatorVTable* vtable); + + +#define MONO_CONST_RETURN const + +/* + * When embedding, you have to define MONO_ZERO_LEN_ARRAY before including any + * other Mono header file if you use a different compiler from the one used to + * build Mono. + */ +#ifndef MONO_ZERO_LEN_ARRAY +#ifdef __GNUC__ +#define MONO_ZERO_LEN_ARRAY 0 +#else +#define MONO_ZERO_LEN_ARRAY 1 +#endif +#endif + +#if defined (MONO_INSIDE_RUNTIME) + +#if defined (__CENTRINEL__) +/* Centrinel is an analyzer that warns about raw pointer to managed objects + * inside Mono. + */ +#define MONO_RT_MANAGED_ATTR __CENTRINEL_MANAGED_ATTR +#define MONO_RT_CENTRINEL_SUPPRESS __CENTRINEL_SUPPRESS_ATTR(1) +#else +#define MONO_RT_MANAGED_ATTR +#define MONO_RT_CENTRINEL_SUPPRESS +#endif + +#if defined (__clang__) || defined (__GNUC__) +// attribute(deprecated(message)) was introduced in gcc 4.5. +// attribute(deprecated)) was introduced in gcc 4.0. +// Compare: https://gcc.gnu.org/onlinedocs/gcc-3.4.6/gcc/Function-Attributes.html +// https://gcc.gnu.org/onlinedocs/gcc-4.4.0/gcc/Function-Attributes.html +// https://gcc.gnu.org/onlinedocs/gcc-4.5.0/gcc/Function-Attributes.html +#if defined (__clang__) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5) +#define MONO_RT_EXTERNAL_ONLY \ + __attribute__ ((__deprecated__ ("The mono runtime must not call this function."))) \ + MONO_RT_CENTRINEL_SUPPRESS +#elif __GNUC__ >= 4 +#define MONO_RT_EXTERNAL_ONLY __attribute__ ((__deprecated__)) MONO_RT_CENTRINEL_SUPPRESS +#else +#define MONO_RT_EXTERNAL_ONLY MONO_RT_CENTRINEL_SUPPRESS +#endif + +#if defined (__clang__) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2) +// Pragmas for controlling diagnostics appear to be from gcc 4.2. +// This is used in place of configure gcc -Werror=deprecated-declarations: +// 1. To be portable across build systems. +// 2. configure is very sensitive to compiler flags; they break autoconf's probes. +// Though #2 can be mitigated by being late in configure. +#pragma GCC diagnostic error "-Wdeprecated-declarations" +#endif + +#else +#define MONO_RT_EXTERNAL_ONLY MONO_RT_CENTRINEL_SUPPRESS +#endif // clang or gcc + +#else +#define MONO_RT_EXTERNAL_ONLY +#define MONO_RT_MANAGED_ATTR +#endif /* MONO_INSIDE_RUNTIME */ + +#if defined (__clang__) || defined (__GNUC__) +#define _MONO_DEPRECATED __attribute__ ((__deprecated__)) +#elif defined (_MSC_VER) +#define _MONO_DEPRECATED __declspec (deprecated) +#else +#define _MONO_DEPRECATED +#endif + +#define MONO_DEPRECATED MONO_API MONO_RT_EXTERNAL_ONLY _MONO_DEPRECATED + +MONO_END_DECLS + +#endif /* __MONO_PUBLIB_H__ */ From 989a2428af00ee03756af52c563d0b461c096f0b Mon Sep 17 00:00:00 2001 From: Peter Sollich Date: Tue, 1 Dec 2020 11:39:48 +0100 Subject: [PATCH 07/16] Undo unintended Mono changes that somehow crept in. --- src/mono/msvc/include/mono/cil/opcode.def | 349 ------------ src/mono/msvc/include/mono/jit/jit.h | 120 ---- .../include/mono/jit/mono-private-unstable.h | 39 -- .../msvc/include/mono/metadata/appdomain.h | 234 -------- .../msvc/include/mono/metadata/assembly.h | 136 ----- .../msvc/include/mono/metadata/attrdefs.h | 274 ---------- src/mono/msvc/include/mono/metadata/blob.h | 118 ---- src/mono/msvc/include/mono/metadata/class.h | 313 ----------- .../include/mono/metadata/debug-helpers.h | 54 -- .../mono/metadata/debug-mono-symfile.h | 114 ---- .../msvc/include/mono/metadata/environment.h | 23 - .../msvc/include/mono/metadata/exception.h | 177 ------ src/mono/msvc/include/mono/metadata/image.h | 99 ---- src/mono/msvc/include/mono/metadata/loader.h | 109 ---- .../msvc/include/mono/metadata/metadata.h | 517 ------------------ .../msvc/include/mono/metadata/mono-config.h | 38 -- .../msvc/include/mono/metadata/mono-debug.h | 231 -------- src/mono/msvc/include/mono/metadata/mono-gc.h | 138 ----- .../mono/metadata/mono-private-unstable.h | 41 -- .../include/mono/metadata/object-forward.h | 22 - src/mono/msvc/include/mono/metadata/object.h | 408 -------------- src/mono/msvc/include/mono/metadata/opcodes.h | 83 --- .../include/mono/metadata/profiler-events.h | 108 ---- .../msvc/include/mono/metadata/profiler.h | 248 --------- .../msvc/include/mono/metadata/reflection.h | 174 ------ .../msvc/include/mono/metadata/row-indexes.h | 503 ----------------- .../msvc/include/mono/metadata/sgen-bridge.h | 110 ---- src/mono/msvc/include/mono/metadata/threads.h | 69 --- .../msvc/include/mono/metadata/tokentype.h | 45 -- src/mono/msvc/include/mono/metadata/verify.h | 66 --- .../msvc/include/mono/utils/mono-counters.h | 105 ---- .../include/mono/utils/mono-dl-fallback.h | 43 -- src/mono/msvc/include/mono/utils/mono-error.h | 105 ---- .../msvc/include/mono/utils/mono-forward.h | 15 - .../msvc/include/mono/utils/mono-jemalloc.h | 36 -- .../msvc/include/mono/utils/mono-logger.h | 31 -- .../mono/utils/mono-private-unstable.h | 19 - .../msvc/include/mono/utils/mono-publib.h | 187 ------- 38 files changed, 5501 deletions(-) delete mode 100644 src/mono/msvc/include/mono/cil/opcode.def delete mode 100644 src/mono/msvc/include/mono/jit/jit.h delete mode 100644 src/mono/msvc/include/mono/jit/mono-private-unstable.h delete mode 100644 src/mono/msvc/include/mono/metadata/appdomain.h delete mode 100644 src/mono/msvc/include/mono/metadata/assembly.h delete mode 100644 src/mono/msvc/include/mono/metadata/attrdefs.h delete mode 100644 src/mono/msvc/include/mono/metadata/blob.h delete mode 100644 src/mono/msvc/include/mono/metadata/class.h delete mode 100644 src/mono/msvc/include/mono/metadata/debug-helpers.h delete mode 100644 src/mono/msvc/include/mono/metadata/debug-mono-symfile.h delete mode 100644 src/mono/msvc/include/mono/metadata/environment.h delete mode 100644 src/mono/msvc/include/mono/metadata/exception.h delete mode 100644 src/mono/msvc/include/mono/metadata/image.h delete mode 100644 src/mono/msvc/include/mono/metadata/loader.h delete mode 100644 src/mono/msvc/include/mono/metadata/metadata.h delete mode 100644 src/mono/msvc/include/mono/metadata/mono-config.h delete mode 100644 src/mono/msvc/include/mono/metadata/mono-debug.h delete mode 100644 src/mono/msvc/include/mono/metadata/mono-gc.h delete mode 100644 src/mono/msvc/include/mono/metadata/mono-private-unstable.h delete mode 100644 src/mono/msvc/include/mono/metadata/object-forward.h delete mode 100644 src/mono/msvc/include/mono/metadata/object.h delete mode 100644 src/mono/msvc/include/mono/metadata/opcodes.h delete mode 100644 src/mono/msvc/include/mono/metadata/profiler-events.h delete mode 100644 src/mono/msvc/include/mono/metadata/profiler.h delete mode 100644 src/mono/msvc/include/mono/metadata/reflection.h delete mode 100644 src/mono/msvc/include/mono/metadata/row-indexes.h delete mode 100644 src/mono/msvc/include/mono/metadata/sgen-bridge.h delete mode 100644 src/mono/msvc/include/mono/metadata/threads.h delete mode 100644 src/mono/msvc/include/mono/metadata/tokentype.h delete mode 100644 src/mono/msvc/include/mono/metadata/verify.h delete mode 100644 src/mono/msvc/include/mono/utils/mono-counters.h delete mode 100644 src/mono/msvc/include/mono/utils/mono-dl-fallback.h delete mode 100644 src/mono/msvc/include/mono/utils/mono-error.h delete mode 100644 src/mono/msvc/include/mono/utils/mono-forward.h delete mode 100644 src/mono/msvc/include/mono/utils/mono-jemalloc.h delete mode 100644 src/mono/msvc/include/mono/utils/mono-logger.h delete mode 100644 src/mono/msvc/include/mono/utils/mono-private-unstable.h delete mode 100644 src/mono/msvc/include/mono/utils/mono-publib.h diff --git a/src/mono/msvc/include/mono/cil/opcode.def b/src/mono/msvc/include/mono/cil/opcode.def deleted file mode 100644 index a39b315bac5e9..0000000000000 --- a/src/mono/msvc/include/mono/cil/opcode.def +++ /dev/null @@ -1,349 +0,0 @@ -/* GENERATED FILE, DO NOT EDIT. Edit cil-opcodes.xml instead and run "make opcode.def" to regenerate. */ -OPDEF(CEE_NOP, "nop", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0x00, NEXT) -OPDEF(CEE_BREAK, "break", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0x01, ERROR) -OPDEF(CEE_LDARG_0, "ldarg.0", Pop0, Push1, InlineNone, 0, 1, 0xFF, 0x02, NEXT) -OPDEF(CEE_LDARG_1, "ldarg.1", Pop0, Push1, InlineNone, 1, 1, 0xFF, 0x03, NEXT) -OPDEF(CEE_LDARG_2, "ldarg.2", Pop0, Push1, InlineNone, 2, 1, 0xFF, 0x04, NEXT) -OPDEF(CEE_LDARG_3, "ldarg.3", Pop0, Push1, InlineNone, 3, 1, 0xFF, 0x05, NEXT) -OPDEF(CEE_LDLOC_0, "ldloc.0", Pop0, Push1, InlineNone, 0, 1, 0xFF, 0x06, NEXT) -OPDEF(CEE_LDLOC_1, "ldloc.1", Pop0, Push1, InlineNone, 1, 1, 0xFF, 0x07, NEXT) -OPDEF(CEE_LDLOC_2, "ldloc.2", Pop0, Push1, InlineNone, 2, 1, 0xFF, 0x08, NEXT) -OPDEF(CEE_LDLOC_3, "ldloc.3", Pop0, Push1, InlineNone, 3, 1, 0xFF, 0x09, NEXT) -OPDEF(CEE_STLOC_0, "stloc.0", Pop1, Push0, InlineNone, 0, 1, 0xFF, 0x0A, NEXT) -OPDEF(CEE_STLOC_1, "stloc.1", Pop1, Push0, InlineNone, 1, 1, 0xFF, 0x0B, NEXT) -OPDEF(CEE_STLOC_2, "stloc.2", Pop1, Push0, InlineNone, 2, 1, 0xFF, 0x0C, NEXT) -OPDEF(CEE_STLOC_3, "stloc.3", Pop1, Push0, InlineNone, 3, 1, 0xFF, 0x0D, NEXT) -OPDEF(CEE_LDARG_S, "ldarg.s", Pop0, Push1, ShortInlineVar, 0, 1, 0xFF, 0x0E, NEXT) -OPDEF(CEE_LDARGA_S, "ldarga.s", Pop0, PushI, ShortInlineVar, 0, 1, 0xFF, 0x0F, NEXT) -OPDEF(CEE_STARG_S, "starg.s", Pop1, Push0, ShortInlineVar, 0, 1, 0xFF, 0x10, NEXT) -OPDEF(CEE_LDLOC_S, "ldloc.s", Pop0, Push1, ShortInlineVar, 0, 1, 0xFF, 0x11, NEXT) -OPDEF(CEE_LDLOCA_S, "ldloca.s", Pop0, PushI, ShortInlineVar, 0, 1, 0xFF, 0x12, NEXT) -OPDEF(CEE_STLOC_S, "stloc.s", Pop1, Push0, ShortInlineVar, 0, 1, 0xFF, 0x13, NEXT) -OPDEF(CEE_LDNULL, "ldnull", Pop0, PushRef, InlineNone, 0, 1, 0xFF, 0x14, NEXT) -OPDEF(CEE_LDC_I4_M1, "ldc.i4.m1", Pop0, PushI, InlineNone, -1, 1, 0xFF, 0x15, NEXT) -OPDEF(CEE_LDC_I4_0, "ldc.i4.0", Pop0, PushI, InlineNone, 0, 1, 0xFF, 0x16, NEXT) -OPDEF(CEE_LDC_I4_1, "ldc.i4.1", Pop0, PushI, InlineNone, 1, 1, 0xFF, 0x17, NEXT) -OPDEF(CEE_LDC_I4_2, "ldc.i4.2", Pop0, PushI, InlineNone, 2, 1, 0xFF, 0x18, NEXT) -OPDEF(CEE_LDC_I4_3, "ldc.i4.3", Pop0, PushI, InlineNone, 3, 1, 0xFF, 0x19, NEXT) -OPDEF(CEE_LDC_I4_4, "ldc.i4.4", Pop0, PushI, InlineNone, 4, 1, 0xFF, 0x1A, NEXT) -OPDEF(CEE_LDC_I4_5, "ldc.i4.5", Pop0, PushI, InlineNone, 5, 1, 0xFF, 0x1B, NEXT) -OPDEF(CEE_LDC_I4_6, "ldc.i4.6", Pop0, PushI, InlineNone, 6, 1, 0xFF, 0x1C, NEXT) -OPDEF(CEE_LDC_I4_7, "ldc.i4.7", Pop0, PushI, InlineNone, 7, 1, 0xFF, 0x1D, NEXT) -OPDEF(CEE_LDC_I4_8, "ldc.i4.8", Pop0, PushI, InlineNone, 8, 1, 0xFF, 0x1E, NEXT) -OPDEF(CEE_LDC_I4_S, "ldc.i4.s", Pop0, PushI, ShortInlineI, 0, 1, 0xFF, 0x1F, NEXT) -OPDEF(CEE_LDC_I4, "ldc.i4", Pop0, PushI, InlineI, 0, 1, 0xFF, 0x20, NEXT) -OPDEF(CEE_LDC_I8, "ldc.i8", Pop0, PushI8, InlineI8, 0, 1, 0xFF, 0x21, NEXT) -OPDEF(CEE_LDC_R4, "ldc.r4", Pop0, PushR4, ShortInlineR, 0, 1, 0xFF, 0x22, NEXT) -OPDEF(CEE_LDC_R8, "ldc.r8", Pop0, PushR8, InlineR, 0, 1, 0xFF, 0x23, NEXT) -OPDEF(CEE_UNUSED99, "unused99", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0x24, NEXT) -OPDEF(CEE_DUP, "dup", Pop1, Push1+Push1, InlineNone, 0, 1, 0xFF, 0x25, NEXT) -OPDEF(CEE_POP, "pop", Pop1, Push0, InlineNone, 0, 1, 0xFF, 0x26, NEXT) -OPDEF(CEE_JMP, "jmp", Pop0, Push0, InlineMethod, 0, 1, 0xFF, 0x27, CALL) -OPDEF(CEE_CALL, "call", VarPop, VarPush, InlineMethod, 0, 1, 0xFF, 0x28, CALL) -OPDEF(CEE_CALLI, "calli", VarPop, VarPush, InlineSig, 0, 1, 0xFF, 0x29, CALL) -OPDEF(CEE_RET, "ret", VarPop, Push0, InlineNone, 0, 1, 0xFF, 0x2A, RETURN) -OPDEF(CEE_BR_S, "br.s", Pop0, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x2B, BRANCH) -OPDEF(CEE_BRFALSE_S, "brfalse.s", PopI, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x2C, COND_BRANCH) -OPDEF(CEE_BRTRUE_S, "brtrue.s", PopI, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x2D, COND_BRANCH) -OPDEF(CEE_BEQ_S, "beq.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x2E, COND_BRANCH) -OPDEF(CEE_BGE_S, "bge.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x2F, COND_BRANCH) -OPDEF(CEE_BGT_S, "bgt.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x30, COND_BRANCH) -OPDEF(CEE_BLE_S, "ble.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x31, COND_BRANCH) -OPDEF(CEE_BLT_S, "blt.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x32, COND_BRANCH) -OPDEF(CEE_BNE_UN_S, "bne.un.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x33, COND_BRANCH) -OPDEF(CEE_BGE_UN_S, "bge.un.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x34, COND_BRANCH) -OPDEF(CEE_BGT_UN_S, "bgt.un.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x35, COND_BRANCH) -OPDEF(CEE_BLE_UN_S, "ble.un.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x36, COND_BRANCH) -OPDEF(CEE_BLT_UN_S, "blt.un.s", Pop1+Pop1, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0x37, COND_BRANCH) -OPDEF(CEE_BR, "br", Pop0, Push0, InlineBrTarget, 0, 1, 0xFF, 0x38, BRANCH) -OPDEF(CEE_BRFALSE, "brfalse", PopI, Push0, InlineBrTarget, 0, 1, 0xFF, 0x39, COND_BRANCH) -OPDEF(CEE_BRTRUE, "brtrue", PopI, Push0, InlineBrTarget, 0, 1, 0xFF, 0x3A, COND_BRANCH) -OPDEF(CEE_BEQ, "beq", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x3B, COND_BRANCH) -OPDEF(CEE_BGE, "bge", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x3C, COND_BRANCH) -OPDEF(CEE_BGT, "bgt", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x3D, COND_BRANCH) -OPDEF(CEE_BLE, "ble", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x3E, COND_BRANCH) -OPDEF(CEE_BLT, "blt", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x3F, COND_BRANCH) -OPDEF(CEE_BNE_UN, "bne.un", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x40, COND_BRANCH) -OPDEF(CEE_BGE_UN, "bge.un", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x41, COND_BRANCH) -OPDEF(CEE_BGT_UN, "bgt.un", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x42, COND_BRANCH) -OPDEF(CEE_BLE_UN, "ble.un", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x43, COND_BRANCH) -OPDEF(CEE_BLT_UN, "blt.un", Pop1+Pop1, Push0, InlineBrTarget, 0, 1, 0xFF, 0x44, COND_BRANCH) -OPDEF(CEE_SWITCH, "switch", PopI, Push0, InlineSwitch, 0, 1, 0xFF, 0x45, COND_BRANCH) -OPDEF(CEE_LDIND_I1, "ldind.i1", PopI, PushI, InlineNone, 0, 1, 0xFF, 0x46, NEXT) -OPDEF(CEE_LDIND_U1, "ldind.u1", PopI, PushI, InlineNone, 0, 1, 0xFF, 0x47, NEXT) -OPDEF(CEE_LDIND_I2, "ldind.i2", PopI, PushI, InlineNone, 0, 1, 0xFF, 0x48, NEXT) -OPDEF(CEE_LDIND_U2, "ldind.u2", PopI, PushI, InlineNone, 0, 1, 0xFF, 0x49, NEXT) -OPDEF(CEE_LDIND_I4, "ldind.i4", PopI, PushI, InlineNone, 0, 1, 0xFF, 0x4A, NEXT) -OPDEF(CEE_LDIND_U4, "ldind.u4", PopI, PushI, InlineNone, 0, 1, 0xFF, 0x4B, NEXT) -OPDEF(CEE_LDIND_I8, "ldind.i8", PopI, PushI8, InlineNone, 0, 1, 0xFF, 0x4C, NEXT) -OPDEF(CEE_LDIND_I, "ldind.i", PopI, PushI, InlineNone, 0, 1, 0xFF, 0x4D, NEXT) -OPDEF(CEE_LDIND_R4, "ldind.r4", PopI, PushR4, InlineNone, 0, 1, 0xFF, 0x4E, NEXT) -OPDEF(CEE_LDIND_R8, "ldind.r8", PopI, PushR8, InlineNone, 0, 1, 0xFF, 0x4F, NEXT) -OPDEF(CEE_LDIND_REF, "ldind.ref", PopI, PushRef, InlineNone, 0, 1, 0xFF, 0x50, NEXT) -OPDEF(CEE_STIND_REF, "stind.ref", PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x51, NEXT) -OPDEF(CEE_STIND_I1, "stind.i1", PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x52, NEXT) -OPDEF(CEE_STIND_I2, "stind.i2", PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x53, NEXT) -OPDEF(CEE_STIND_I4, "stind.i4", PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x54, NEXT) -OPDEF(CEE_STIND_I8, "stind.i8", PopI+PopI8, Push0, InlineNone, 0, 1, 0xFF, 0x55, NEXT) -OPDEF(CEE_STIND_R4, "stind.r4", PopI+PopR4, Push0, InlineNone, 0, 1, 0xFF, 0x56, NEXT) -OPDEF(CEE_STIND_R8, "stind.r8", PopI+PopR8, Push0, InlineNone, 0, 1, 0xFF, 0x57, NEXT) -OPDEF(CEE_ADD, "add", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x58, NEXT) -OPDEF(CEE_SUB, "sub", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x59, NEXT) -OPDEF(CEE_MUL, "mul", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x5A, NEXT) -OPDEF(CEE_DIV, "div", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x5B, NEXT) -OPDEF(CEE_DIV_UN, "div.un", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x5C, NEXT) -OPDEF(CEE_REM, "rem", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x5D, NEXT) -OPDEF(CEE_REM_UN, "rem.un", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x5E, NEXT) -OPDEF(CEE_AND, "and", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x5F, NEXT) -OPDEF(CEE_OR, "or", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x60, NEXT) -OPDEF(CEE_XOR, "xor", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x61, NEXT) -OPDEF(CEE_SHL, "shl", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x62, NEXT) -OPDEF(CEE_SHR, "shr", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x63, NEXT) -OPDEF(CEE_SHR_UN, "shr.un", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x64, NEXT) -OPDEF(CEE_NEG, "neg", Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x65, NEXT) -OPDEF(CEE_NOT, "not", Pop1, Push1, InlineNone, 0, 1, 0xFF, 0x66, NEXT) -OPDEF(CEE_CONV_I1, "conv.i1", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x67, NEXT) -OPDEF(CEE_CONV_I2, "conv.i2", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x68, NEXT) -OPDEF(CEE_CONV_I4, "conv.i4", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x69, NEXT) -OPDEF(CEE_CONV_I8, "conv.i8", Pop1, PushI8, InlineNone, 0, 1, 0xFF, 0x6A, NEXT) -OPDEF(CEE_CONV_R4, "conv.r4", Pop1, PushR4, InlineNone, 0, 1, 0xFF, 0x6B, NEXT) -OPDEF(CEE_CONV_R8, "conv.r8", Pop1, PushR8, InlineNone, 0, 1, 0xFF, 0x6C, NEXT) -OPDEF(CEE_CONV_U4, "conv.u4", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x6D, NEXT) -OPDEF(CEE_CONV_U8, "conv.u8", Pop1, PushI8, InlineNone, 0, 1, 0xFF, 0x6E, NEXT) -OPDEF(CEE_CALLVIRT, "callvirt", VarPop, VarPush, InlineMethod, 0, 1, 0xFF, 0x6F, CALL) -OPDEF(CEE_CPOBJ, "cpobj", PopI+PopI, Push0, InlineType, 0, 1, 0xFF, 0x70, NEXT) -OPDEF(CEE_LDOBJ, "ldobj", PopI, Push1, InlineType, 0, 1, 0xFF, 0x71, NEXT) -OPDEF(CEE_LDSTR, "ldstr", Pop0, PushRef, InlineString, 0, 1, 0xFF, 0x72, NEXT) -OPDEF(CEE_NEWOBJ, "newobj", VarPop, PushRef, InlineMethod, 0, 1, 0xFF, 0x73, CALL) -OPDEF(CEE_CASTCLASS, "castclass", PopRef, PushRef, InlineType, 0, 1, 0xFF, 0x74, NEXT) -OPDEF(CEE_ISINST, "isinst", PopRef, PushI, InlineType, 0, 1, 0xFF, 0x75, NEXT) -OPDEF(CEE_CONV_R_UN, "conv.r.un", Pop1, PushR8, InlineNone, 0, 1, 0xFF, 0x76, NEXT) -OPDEF(CEE_UNUSED58, "unused58", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0x77, NEXT) -OPDEF(CEE_UNUSED1, "unused1", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0x78, NEXT) -OPDEF(CEE_UNBOX, "unbox", PopRef, PushI, InlineType, 0, 1, 0xFF, 0x79, NEXT) -OPDEF(CEE_THROW, "throw", PopRef, Push0, InlineNone, 0, 1, 0xFF, 0x7A, ERROR) -OPDEF(CEE_LDFLD, "ldfld", PopRef, Push1, InlineField, 0, 1, 0xFF, 0x7B, NEXT) -OPDEF(CEE_LDFLDA, "ldflda", PopRef, PushI, InlineField, 0, 1, 0xFF, 0x7C, NEXT) -OPDEF(CEE_STFLD, "stfld", PopRef+Pop1, Push0, InlineField, 0, 1, 0xFF, 0x7D, NEXT) -OPDEF(CEE_LDSFLD, "ldsfld", Pop0, Push1, InlineField, 0, 1, 0xFF, 0x7E, NEXT) -OPDEF(CEE_LDSFLDA, "ldsflda", Pop0, PushI, InlineField, 0, 1, 0xFF, 0x7F, NEXT) -OPDEF(CEE_STSFLD, "stsfld", Pop1, Push0, InlineField, 0, 1, 0xFF, 0x80, NEXT) -OPDEF(CEE_STOBJ, "stobj", PopI+Pop1, Push0, InlineType, 0, 1, 0xFF, 0x81, NEXT) -OPDEF(CEE_CONV_OVF_I1_UN, "conv.ovf.i1.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x82, NEXT) -OPDEF(CEE_CONV_OVF_I2_UN, "conv.ovf.i2.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x83, NEXT) -OPDEF(CEE_CONV_OVF_I4_UN, "conv.ovf.i4.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x84, NEXT) -OPDEF(CEE_CONV_OVF_I8_UN, "conv.ovf.i8.un", Pop1, PushI8, InlineNone, 0, 1, 0xFF, 0x85, NEXT) -OPDEF(CEE_CONV_OVF_U1_UN, "conv.ovf.u1.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x86, NEXT) -OPDEF(CEE_CONV_OVF_U2_UN, "conv.ovf.u2.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x87, NEXT) -OPDEF(CEE_CONV_OVF_U4_UN, "conv.ovf.u4.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x88, NEXT) -OPDEF(CEE_CONV_OVF_U8_UN, "conv.ovf.u8.un", Pop1, PushI8, InlineNone, 0, 1, 0xFF, 0x89, NEXT) -OPDEF(CEE_CONV_OVF_I_UN, "conv.ovf.i.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x8A, NEXT) -OPDEF(CEE_CONV_OVF_U_UN, "conv.ovf.u.un", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0x8B, NEXT) -OPDEF(CEE_BOX, "box", Pop1, PushRef, InlineType, 0, 1, 0xFF, 0x8C, NEXT) -OPDEF(CEE_NEWARR, "newarr", PopI, PushRef, InlineType, 0, 1, 0xFF, 0x8D, NEXT) -OPDEF(CEE_LDLEN, "ldlen", PopRef, PushI, InlineNone, 0, 1, 0xFF, 0x8E, NEXT) -OPDEF(CEE_LDELEMA, "ldelema", PopRef+PopI, PushI, InlineType, 0, 1, 0xFF, 0x8F, NEXT) -OPDEF(CEE_LDELEM_I1, "ldelem.i1", PopRef+PopI, PushI, InlineNone, 0, 1, 0xFF, 0x90, NEXT) -OPDEF(CEE_LDELEM_U1, "ldelem.u1", PopRef+PopI, PushI, InlineNone, 0, 1, 0xFF, 0x91, NEXT) -OPDEF(CEE_LDELEM_I2, "ldelem.i2", PopRef+PopI, PushI, InlineNone, 0, 1, 0xFF, 0x92, NEXT) -OPDEF(CEE_LDELEM_U2, "ldelem.u2", PopRef+PopI, PushI, InlineNone, 0, 1, 0xFF, 0x93, NEXT) -OPDEF(CEE_LDELEM_I4, "ldelem.i4", PopRef+PopI, PushI, InlineNone, 0, 1, 0xFF, 0x94, NEXT) -OPDEF(CEE_LDELEM_U4, "ldelem.u4", PopRef+PopI, PushI, InlineNone, 0, 1, 0xFF, 0x95, NEXT) -OPDEF(CEE_LDELEM_I8, "ldelem.i8", PopRef+PopI, PushI8, InlineNone, 0, 1, 0xFF, 0x96, NEXT) -OPDEF(CEE_LDELEM_I, "ldelem.i", PopRef+PopI, PushI, InlineNone, 0, 1, 0xFF, 0x97, NEXT) -OPDEF(CEE_LDELEM_R4, "ldelem.r4", PopRef+PopI, PushR4, InlineNone, 0, 1, 0xFF, 0x98, NEXT) -OPDEF(CEE_LDELEM_R8, "ldelem.r8", PopRef+PopI, PushR8, InlineNone, 0, 1, 0xFF, 0x99, NEXT) -OPDEF(CEE_LDELEM_REF, "ldelem.ref", PopRef+PopI, PushRef, InlineNone, 0, 1, 0xFF, 0x9A, NEXT) -OPDEF(CEE_STELEM_I, "stelem.i", PopRef+PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x9B, NEXT) -OPDEF(CEE_STELEM_I1, "stelem.i1", PopRef+PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x9C, NEXT) -OPDEF(CEE_STELEM_I2, "stelem.i2", PopRef+PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x9D, NEXT) -OPDEF(CEE_STELEM_I4, "stelem.i4", PopRef+PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0x9E, NEXT) -OPDEF(CEE_STELEM_I8, "stelem.i8", PopRef+PopI+PopI8, Push0, InlineNone, 0, 1, 0xFF, 0x9F, NEXT) -OPDEF(CEE_STELEM_R4, "stelem.r4", PopRef+PopI+PopR4, Push0, InlineNone, 0, 1, 0xFF, 0xA0, NEXT) -OPDEF(CEE_STELEM_R8, "stelem.r8", PopRef+PopI+PopR8, Push0, InlineNone, 0, 1, 0xFF, 0xA1, NEXT) -OPDEF(CEE_STELEM_REF, "stelem.ref", PopRef+PopI+PopRef, Push0, InlineNone, 0, 1, 0xFF, 0xA2, NEXT) -OPDEF(CEE_LDELEM, "ldelem", PopRef+PopI, Push1, InlineType, 0, 1, 0xFF, 0xA3, NEXT) -OPDEF(CEE_STELEM, "stelem", PopRef+PopI+Pop1, Push0, InlineType, 0, 1, 0xFF, 0xA4, NEXT) -OPDEF(CEE_UNBOX_ANY, "unbox.any", PopRef, Push1, InlineType, 0, 1, 0xFF, 0xA5, NEXT) -OPDEF(CEE_UNUSED5, "unused5", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xA6, NEXT) -OPDEF(CEE_UNUSED6, "unused6", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xA7, NEXT) -OPDEF(CEE_UNUSED7, "unused7", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xA8, NEXT) -OPDEF(CEE_UNUSED8, "unused8", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xA9, NEXT) -OPDEF(CEE_UNUSED9, "unused9", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xAA, NEXT) -OPDEF(CEE_UNUSED10, "unused10", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xAB, NEXT) -OPDEF(CEE_UNUSED11, "unused11", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xAC, NEXT) -OPDEF(CEE_UNUSED12, "unused12", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xAD, NEXT) -OPDEF(CEE_UNUSED13, "unused13", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xAE, NEXT) -OPDEF(CEE_UNUSED14, "unused14", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xAF, NEXT) -OPDEF(CEE_UNUSED15, "unused15", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xB0, NEXT) -OPDEF(CEE_UNUSED16, "unused16", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xB1, NEXT) -OPDEF(CEE_UNUSED17, "unused17", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xB2, NEXT) -OPDEF(CEE_CONV_OVF_I1, "conv.ovf.i1", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xB3, NEXT) -OPDEF(CEE_CONV_OVF_U1, "conv.ovf.u1", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xB4, NEXT) -OPDEF(CEE_CONV_OVF_I2, "conv.ovf.i2", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xB5, NEXT) -OPDEF(CEE_CONV_OVF_U2, "conv.ovf.u2", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xB6, NEXT) -OPDEF(CEE_CONV_OVF_I4, "conv.ovf.i4", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xB7, NEXT) -OPDEF(CEE_CONV_OVF_U4, "conv.ovf.u4", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xB8, NEXT) -OPDEF(CEE_CONV_OVF_I8, "conv.ovf.i8", Pop1, PushI8, InlineNone, 0, 1, 0xFF, 0xB9, NEXT) -OPDEF(CEE_CONV_OVF_U8, "conv.ovf.u8", Pop1, PushI8, InlineNone, 0, 1, 0xFF, 0xBA, NEXT) -OPDEF(CEE_UNUSED50, "unused50", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xBB, NEXT) -OPDEF(CEE_UNUSED18, "unused18", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xBC, NEXT) -OPDEF(CEE_UNUSED19, "unused19", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xBD, NEXT) -OPDEF(CEE_UNUSED20, "unused20", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xBE, NEXT) -OPDEF(CEE_UNUSED21, "unused21", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xBF, NEXT) -OPDEF(CEE_UNUSED22, "unused22", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xC0, NEXT) -OPDEF(CEE_UNUSED23, "unused23", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xC1, NEXT) -OPDEF(CEE_REFANYVAL, "refanyval", Pop1, PushI, InlineType, 0, 1, 0xFF, 0xC2, NEXT) -OPDEF(CEE_CKFINITE, "ckfinite", Pop1, PushR8, InlineNone, 0, 1, 0xFF, 0xC3, NEXT) -OPDEF(CEE_UNUSED24, "unused24", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xC4, NEXT) -OPDEF(CEE_UNUSED25, "unused25", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xC5, NEXT) -OPDEF(CEE_MKREFANY, "mkrefany", PopI, Push1, InlineType, 0, 1, 0xFF, 0xC6, NEXT) -OPDEF(CEE_UNUSED59, "unused59", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xC7, NEXT) -OPDEF(CEE_UNUSED60, "unused60", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xC8, NEXT) -OPDEF(CEE_UNUSED61, "unused61", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xC9, NEXT) -OPDEF(CEE_UNUSED62, "unused62", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xCA, NEXT) -OPDEF(CEE_UNUSED63, "unused63", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xCB, NEXT) -OPDEF(CEE_UNUSED64, "unused64", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xCC, NEXT) -OPDEF(CEE_UNUSED65, "unused65", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xCD, NEXT) -OPDEF(CEE_UNUSED66, "unused66", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xCE, NEXT) -OPDEF(CEE_UNUSED67, "unused67", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xCF, NEXT) -OPDEF(CEE_LDTOKEN, "ldtoken", Pop0, PushI, InlineTok, 0, 1, 0xFF, 0xD0, NEXT) -OPDEF(CEE_CONV_U2, "conv.u2", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xD1, NEXT) -OPDEF(CEE_CONV_U1, "conv.u1", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xD2, NEXT) -OPDEF(CEE_CONV_I, "conv.i", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xD3, NEXT) -OPDEF(CEE_CONV_OVF_I, "conv.ovf.i", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xD4, NEXT) -OPDEF(CEE_CONV_OVF_U, "conv.ovf.u", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xD5, NEXT) -OPDEF(CEE_ADD_OVF, "add.ovf", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0xD6, NEXT) -OPDEF(CEE_ADD_OVF_UN, "add.ovf.un", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0xD7, NEXT) -OPDEF(CEE_MUL_OVF, "mul.ovf", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0xD8, NEXT) -OPDEF(CEE_MUL_OVF_UN, "mul.ovf.un", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0xD9, NEXT) -OPDEF(CEE_SUB_OVF, "sub.ovf", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0xDA, NEXT) -OPDEF(CEE_SUB_OVF_UN, "sub.ovf.un", Pop1+Pop1, Push1, InlineNone, 0, 1, 0xFF, 0xDB, NEXT) -OPDEF(CEE_ENDFINALLY, "endfinally", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xDC, RETURN) -OPDEF(CEE_LEAVE, "leave", Pop0, Push0, InlineBrTarget, 0, 1, 0xFF, 0xDD, BRANCH) -OPDEF(CEE_LEAVE_S, "leave.s", Pop0, Push0, ShortInlineBrTarget, 0, 1, 0xFF, 0xDE, BRANCH) -OPDEF(CEE_STIND_I, "stind.i", PopI+PopI, Push0, InlineNone, 0, 1, 0xFF, 0xDF, NEXT) -OPDEF(CEE_CONV_U, "conv.u", Pop1, PushI, InlineNone, 0, 1, 0xFF, 0xE0, NEXT) -OPDEF(CEE_UNUSED26, "unused26", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE1, NEXT) -OPDEF(CEE_UNUSED27, "unused27", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE2, NEXT) -OPDEF(CEE_UNUSED28, "unused28", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE3, NEXT) -OPDEF(CEE_UNUSED29, "unused29", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE4, NEXT) -OPDEF(CEE_UNUSED30, "unused30", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE5, NEXT) -OPDEF(CEE_UNUSED31, "unused31", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE6, NEXT) -OPDEF(CEE_UNUSED32, "unused32", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE7, NEXT) -OPDEF(CEE_UNUSED33, "unused33", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE8, NEXT) -OPDEF(CEE_UNUSED34, "unused34", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xE9, NEXT) -OPDEF(CEE_UNUSED35, "unused35", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xEA, NEXT) -OPDEF(CEE_UNUSED36, "unused36", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xEB, NEXT) -OPDEF(CEE_UNUSED37, "unused37", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xEC, NEXT) -OPDEF(CEE_UNUSED38, "unused38", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xED, NEXT) -OPDEF(CEE_UNUSED39, "unused39", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xEE, NEXT) -OPDEF(CEE_UNUSED40, "unused40", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xEF, NEXT) -OPDEF(CEE_UNUSED41, "unused41", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF0, NEXT) -OPDEF(CEE_UNUSED42, "unused42", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF1, NEXT) -OPDEF(CEE_UNUSED43, "unused43", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF2, NEXT) -OPDEF(CEE_UNUSED44, "unused44", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF3, NEXT) -OPDEF(CEE_UNUSED45, "unused45", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF4, NEXT) -OPDEF(CEE_UNUSED46, "unused46", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF5, NEXT) -OPDEF(CEE_UNUSED47, "unused47", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF6, NEXT) -OPDEF(CEE_UNUSED48, "unused48", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF7, NEXT) -OPDEF(CEE_PREFIX7, "prefix7", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF8, META) -OPDEF(CEE_PREFIX6, "prefix6", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xF9, META) -OPDEF(CEE_PREFIX5, "prefix5", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xFA, META) -OPDEF(CEE_PREFIX4, "prefix4", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xFB, META) -OPDEF(CEE_PREFIX3, "prefix3", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xFC, META) -OPDEF(CEE_PREFIX2, "prefix2", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xFD, META) -OPDEF(CEE_PREFIX1, "prefix1", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xFE, META) -OPDEF(CEE_PREFIXREF, "prefixref", Pop0, Push0, InlineNone, 0, 1, 0xFF, 0xFF, META) -OPDEF(CEE_ARGLIST, "arglist", Pop0, PushI, InlineNone, 0, 2, 0xFE, 0x00, NEXT) -OPDEF(CEE_CEQ, "ceq", Pop1+Pop1, PushI, InlineNone, 0, 2, 0xFE, 0x01, NEXT) -OPDEF(CEE_CGT, "cgt", Pop1+Pop1, PushI, InlineNone, 0, 2, 0xFE, 0x02, NEXT) -OPDEF(CEE_CGT_UN, "cgt.un", Pop1+Pop1, PushI, InlineNone, 0, 2, 0xFE, 0x03, NEXT) -OPDEF(CEE_CLT, "clt", Pop1+Pop1, PushI, InlineNone, 0, 2, 0xFE, 0x04, NEXT) -OPDEF(CEE_CLT_UN, "clt.un", Pop1+Pop1, PushI, InlineNone, 0, 2, 0xFE, 0x05, NEXT) -OPDEF(CEE_LDFTN, "ldftn", Pop0, PushI, InlineMethod, 0, 2, 0xFE, 0x06, NEXT) -OPDEF(CEE_LDVIRTFTN, "ldvirtftn", PopRef, PushI, InlineMethod, 0, 2, 0xFE, 0x07, NEXT) -OPDEF(CEE_UNUSED56, "unused56", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x08, NEXT) -OPDEF(CEE_LDARG, "ldarg", Pop0, Push1, InlineVar, 0, 2, 0xFE, 0x09, NEXT) -OPDEF(CEE_LDARGA, "ldarga", Pop0, PushI, InlineVar, 0, 2, 0xFE, 0x0A, NEXT) -OPDEF(CEE_STARG, "starg", Pop1, Push0, InlineVar, 0, 2, 0xFE, 0x0B, NEXT) -OPDEF(CEE_LDLOC, "ldloc", Pop0, Push1, InlineVar, 0, 2, 0xFE, 0x0C, NEXT) -OPDEF(CEE_LDLOCA, "ldloca", Pop0, PushI, InlineVar, 0, 2, 0xFE, 0x0D, NEXT) -OPDEF(CEE_STLOC, "stloc", Pop1, Push0, InlineVar, 0, 2, 0xFE, 0x0E, NEXT) -OPDEF(CEE_LOCALLOC, "localloc", PopI, PushI, InlineNone, 0, 2, 0xFE, 0x0F, NEXT) -OPDEF(CEE_UNUSED57, "unused57", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x10, NEXT) -OPDEF(CEE_ENDFILTER, "endfilter", PopI, Push0, InlineNone, 0, 2, 0xFE, 0x11, RETURN) -OPDEF(CEE_UNALIGNED_, "unaligned.", Pop0, Push0, ShortInlineI, 0, 2, 0xFE, 0x12, META) -OPDEF(CEE_VOLATILE_, "volatile.", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x13, META) -OPDEF(CEE_TAIL_, "tail.", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x14, META) -OPDEF(CEE_INITOBJ, "initobj", PopI, Push0, InlineType, 0, 2, 0xFE, 0x15, NEXT) -OPDEF(CEE_CONSTRAINED_, "constrained.", Pop0, Push0, InlineType, 0, 2, 0xFE, 0x16, META) -OPDEF(CEE_CPBLK, "cpblk", PopI+PopI+PopI, Push0, InlineNone, 0, 2, 0xFE, 0x17, NEXT) -OPDEF(CEE_INITBLK, "initblk", PopI+PopI+PopI, Push0, InlineNone, 0, 2, 0xFE, 0x18, NEXT) -OPDEF(CEE_NO_, "no.", Pop0, Push0, ShortInlineI, 0, 2, 0xFE, 0x19, NEXT) -OPDEF(CEE_RETHROW, "rethrow", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x1A, ERROR) -OPDEF(CEE_UNUSED, "unused", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x1B, NEXT) -OPDEF(CEE_SIZEOF, "sizeof", Pop0, PushI, InlineType, 0, 2, 0xFE, 0x1C, NEXT) -OPDEF(CEE_REFANYTYPE, "refanytype", Pop1, PushI, InlineNone, 0, 2, 0xFE, 0x1D, NEXT) -OPDEF(CEE_READONLY_, "readonly.", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x1E, META) -OPDEF(CEE_UNUSED53, "unused53", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x1F, NEXT) -OPDEF(CEE_UNUSED54, "unused54", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x20, NEXT) -OPDEF(CEE_UNUSED55, "unused55", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x21, NEXT) -OPDEF(CEE_UNUSED70, "unused70", Pop0, Push0, InlineNone, 0, 2, 0xFE, 0x22, NEXT) -OPDEF(CEE_ILLEGAL, "illegal", Pop0, Push0, InlineNone, 0, 2, 0x00, 0x00, META) -OPDEF(CEE_ENDMAC, "endmac", Pop0, Push0, InlineNone, 0, 2, 0x00, 0x00, META) -OPDEF(CEE_MONO_ICALL, "mono_icall", VarPop, VarPush, InlineI, 0, 2, 0xF0, 0x00, NEXT) -OPDEF(CEE_MONO_OBJADDR, "mono_objaddr", Pop1, PushI, InlineNone, 0, 2, 0xF0, 0x01, NEXT) -OPDEF(CEE_MONO_LDPTR, "mono_ldptr", Pop0, PushI, InlineI, 0, 2, 0xF0, 0x02, NEXT) -OPDEF(CEE_MONO_VTADDR, "mono_vtaddr", Pop1, PushI, InlineNone, 0, 2, 0xF0, 0x03, NEXT) -OPDEF(CEE_MONO_NEWOBJ, "mono_newobj", Pop0, PushRef, InlineType, 0, 2, 0xF0, 0x04, NEXT) -OPDEF(CEE_MONO_RETOBJ, "mono_retobj", PopI, Push0, InlineType, 0, 2, 0xF0, 0x05, RETURN) -OPDEF(CEE_MONO_LDNATIVEOBJ, "mono_ldnativeobj", PopI, Push1, InlineType, 0, 2, 0xF0, 0x06, RETURN) -OPDEF(CEE_MONO_CISINST, "mono_cisinst", PopRef, Push1, InlineType, 0, 2, 0xF0, 0x07, NEXT) -OPDEF(CEE_MONO_CCASTCLASS, "mono_ccastclass", PopRef, Push1, InlineType, 0, 2, 0xF0, 0x08, NEXT) -OPDEF(CEE_MONO_SAVE_LMF, "mono_save_lmf", Pop0, Push0, InlineNone, 0, 2, 0xF0, 0x09, NEXT) -OPDEF(CEE_MONO_RESTORE_LMF, "mono_restore_lmf", Pop0, Push0, InlineNone, 0, 2, 0xF0, 0x0A, NEXT) -OPDEF(CEE_MONO_CLASSCONST, "mono_classconst", Pop0, PushI, InlineI, 0, 2, 0xF0, 0x0B, NEXT) -OPDEF(CEE_MONO_NOT_TAKEN, "mono_not_taken", Pop0, Push0, InlineNone, 0, 2, 0xF0, 0x0C, NEXT) -OPDEF(CEE_MONO_TLS, "mono_tls", Pop0, PushI, InlineI, 0, 2, 0xF0, 0x0D, NEXT) -OPDEF(CEE_MONO_ICALL_ADDR, "mono_icall_addr", Pop0, PushI, InlineI, 0, 2, 0xF0, 0x0E, NEXT) -OPDEF(CEE_MONO_DYN_CALL, "mono_dyn_call", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x0F, NEXT) -OPDEF(CEE_MONO_MEMORY_BARRIER, "mono_memory_barrier", Pop0, Push0, InlineI, 0, 2, 0xF0, 0x10, NEXT) -OPDEF(CEE_UNUSED71, "unused71", Pop0, Push0, InlineNone, 0, 2, 0xF0, 0x11, NEXT) -OPDEF(CEE_UNUSED72, "unused72", Pop0, Push0, InlineNone, 0, 2, 0xF0, 0x12, NEXT) -OPDEF(CEE_MONO_JIT_ICALL_ADDR, "mono_jit_icall_addr", Pop0, PushI, InlineI, 0, 2, 0xF0, 0x13, NEXT) -OPDEF(CEE_MONO_LDPTR_INT_REQ_FLAG, "mono_ldptr_int_req_flag", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x14, NEXT) -OPDEF(CEE_MONO_LDPTR_CARD_TABLE, "mono_ldptr_card_table", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x15, NEXT) -OPDEF(CEE_MONO_LDPTR_NURSERY_START, "mono_ldptr_nursery_start", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x16, NEXT) -OPDEF(CEE_MONO_LDPTR_NURSERY_BITS, "mono_ldptr_nursery_bits", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x17, NEXT) -OPDEF(CEE_MONO_CALLI_EXTRA_ARG, "mono_calli_extra_arg", VarPop, VarPush, InlineSig, 0, 2, 0xF0, 0x18, CALL) -OPDEF(CEE_MONO_LDDOMAIN, "mono_lddomain", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x19, NEXT) -OPDEF(CEE_MONO_ATOMIC_STORE_I4, "mono_atomic_store_i4", PopI+PopI, Push0, InlineI, 0, 2, 0xF0, 0x1A, NEXT) -OPDEF(CEE_MONO_SAVE_LAST_ERROR, "mono_save_last_error", Pop0, Push0, InlineNone, 0, 2, 0xF0, 0x1B, NEXT) -OPDEF(CEE_MONO_GET_RGCTX_ARG, "mono_get_rgctx_arg", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x1C, NEXT) -OPDEF(CEE_MONO_LDPTR_PROFILER_ALLOCATION_COUNT, "mono_ldptr_profiler_allocation_count", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x1D, NEXT) -OPDEF(CEE_MONO_LD_DELEGATE_METHOD_PTR, "mono_ld_delegate_method_ptr", Pop1, PushI, InlineNone, 0, 2, 0xF0, 0x1E, NEXT) -OPDEF(CEE_MONO_RETHROW, "mono_rethrow", PopRef, Push0, InlineNone, 0, 2, 0xF0, 0x1F, ERROR) -OPDEF(CEE_MONO_GET_SP, "mono_get_sp", Pop0, PushI, InlineNone, 0, 2, 0xF0, 0x20, NEXT) -OPDEF(CEE_MONO_METHODCONST, "mono_methodconst", Pop0, PushI, InlineI, 0, 2, 0xF0, 0x21, NEXT) -OPDEF(CEE_MONO_PINVOKE_ADDR_CACHE, "mono_pinvoke_addr_cache", Pop0, PushI, InlineI, 0, 2, 0xF0, 0x22, NEXT) -#ifndef OPALIAS -#define _MONO_CIL_OPALIAS_DEFINED_ -#define OPALIAS(a,s,r) -#endif - -OPALIAS(CEE_BRNULL, "brnull", CEE_BRFALSE) -OPALIAS(CEE_BRNULL_S, "brnull.s", CEE_BRFALSE_S) -OPALIAS(CEE_BRZERO, "brzero", CEE_BRFALSE) -OPALIAS(CEE_BRZERO_S, "brzero.s", CEE_BRFALSE_S) -OPALIAS(CEE_BRINST, "brinst", CEE_BRTRUE) -OPALIAS(CEE_BRINST_S, "brinst.s", CEE_BRTRUE_S) -OPALIAS(CEE_LDIND_U8, "ldind.u8", CEE_LDIND_I8) -OPALIAS(CEE_LDELEM_U8, "ldelem.u8", CEE_LDELEM_I8) -OPALIAS(CEE_LDX_I4_MIX, "ldc.i4.M1", CEE_LDC_I4_M1) -OPALIAS(CEE_ENDFAULT, "endfault", CEE_ENDFINALLY) - -#ifdef _MONO_CIL_OPALIAS_DEFINED_ -#undef OPALIAS -#undef _MONO_CIL_OPALIAS_DEFINED_ -#endif diff --git a/src/mono/msvc/include/mono/jit/jit.h b/src/mono/msvc/include/mono/jit/jit.h deleted file mode 100644 index 02639c95122de..0000000000000 --- a/src/mono/msvc/include/mono/jit/jit.h +++ /dev/null @@ -1,120 +0,0 @@ -/** - * \file - * Author: - * Dietmar Maurer (dietmar@ximian.com) - * - * (C) 2001, 2002, 2003 Ximian, Inc. - */ - -#ifndef _MONO_JIT_JIT_H_ -#define _MONO_JIT_JIT_H_ - -#include - -MONO_BEGIN_DECLS - -MONO_API MONO_RT_EXTERNAL_ONLY MonoDomain * -mono_jit_init (const char *file); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoDomain * -mono_jit_init_version (const char *root_domain_name, const char *runtime_version); - -MONO_API MonoDomain * -mono_jit_init_version_for_test_only (const char *root_domain_name, const char *runtime_version); - -MONO_API int -mono_jit_exec (MonoDomain *domain, MonoAssembly *assembly, - int argc, char *argv[]); -MONO_API void -mono_jit_cleanup (MonoDomain *domain); - -MONO_API mono_bool -mono_jit_set_trace_options (const char* options); - -MONO_API void -mono_set_signal_chaining (mono_bool chain_signals); - -MONO_API void -mono_set_crash_chaining (mono_bool chain_signals); - -/** - * This function is deprecated, use mono_jit_set_aot_mode instead. - */ -MONO_API void -mono_jit_set_aot_only (mono_bool aot_only); - -/** - * Allows control over our AOT (Ahead-of-time) compilation mode. - */ -typedef enum { - /* Disables AOT mode */ - MONO_AOT_MODE_NONE, - /* Enables normal AOT mode, equivalent to mono_jit_set_aot_only (false) */ - MONO_AOT_MODE_NORMAL, - /* Enables hybrid AOT mode, JIT can still be used for wrappers */ - MONO_AOT_MODE_HYBRID, - /* Enables full AOT mode, JIT is disabled and not allowed, - * equivalent to mono_jit_set_aot_only (true) */ - MONO_AOT_MODE_FULL, - /* Same as full, but use only llvm compiled code */ - MONO_AOT_MODE_LLVMONLY, - /* Uses Interpreter, JIT is disabled and not allowed, - * equivalent to "--full-aot --interpreter" */ - MONO_AOT_MODE_INTERP, - /* Same as INTERP, but use only llvm compiled code */ - MONO_AOT_MODE_INTERP_LLVMONLY, - /* Use only llvm compiled code, fall back to the interpeter */ - MONO_AOT_MODE_LLVMONLY_INTERP, - /* Same as --interp */ - MONO_AOT_MODE_INTERP_ONLY, - /* Sentinel value used internally by the runtime. We use a large number to avoid clashing with some internal values. */ - MONO_AOT_MODE_LAST = 1000, -} MonoAotMode; - -MONO_API void -mono_jit_set_aot_mode (MonoAotMode mode); - -/* - * Returns whether the runtime was invoked for the purpose of AOT-compiling an - * assembly, i.e. no managed code will run. - */ -MONO_API mono_bool -mono_jit_aot_compiling (void); - -/* Allow embedders to decide wherther to actually obey breakpoint instructions - * in specific methods (works for both break IL instructions and Debugger.Break () - * method calls). - */ -typedef enum { - /* the default is to always obey the breakpoint */ - MONO_BREAK_POLICY_ALWAYS, - /* a nop is inserted instead of a breakpoint */ - MONO_BREAK_POLICY_NEVER, - /* the breakpoint is executed only if the program has ben started under - * the debugger (that is if a debugger was attached at the time the method - * was compiled). - */ - MONO_BREAK_POLICY_ON_DBG -} MonoBreakPolicy; - -typedef MonoBreakPolicy (*MonoBreakPolicyFunc) (MonoMethod *method); -MONO_API void mono_set_break_policy (MonoBreakPolicyFunc policy_callback); - -MONO_API void -mono_jit_parse_options (int argc, char * argv[]); - -MONO_API char* mono_get_runtime_build_info (void); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_set_use_llvm (mono_bool use_llvm); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_aot_register_module (void **aot_info); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoDomain* mono_jit_thread_attach (MonoDomain *domain); - -MONO_END_DECLS - -#endif - diff --git a/src/mono/msvc/include/mono/jit/mono-private-unstable.h b/src/mono/msvc/include/mono/jit/mono-private-unstable.h deleted file mode 100644 index 4d746dd00e258..0000000000000 --- a/src/mono/msvc/include/mono/jit/mono-private-unstable.h +++ /dev/null @@ -1,39 +0,0 @@ -/** - * \file - * - * Private unstable APIs. - * - * WARNING: The declarations and behavior of functions in this header are NOT STABLE and can be modified or removed at - * any time. - * - */ - - -#ifndef __MONO_JIT_MONO_PRIVATE_UNSTABLE_H__ -#define __MONO_JIT_MONO_PRIVATE_UNSTABLE_H__ - -#include -#include - -/* These are used to load the AOT data for aot images compiled with MONO_AOT_FILE_FLAG_SEPARATE_DATA */ -/* - * Return the AOT data for ASSEMBLY. SIZE is the size of the data. OUT_HANDLE should be set to a handle which is later - * passed to the free function. - */ -typedef unsigned char* (*MonoLoadAotDataFunc) (MonoAssembly *assembly, int size, void* user_data, void **out_handle); -/* Not yet used */ -typedef void (*MonoFreeAotDataFunc) (MonoAssembly *assembly, int size, void* user_data, void *handle); -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_install_load_aot_data_hook (MonoLoadAotDataFunc load_func, MonoFreeAotDataFunc free_func, void* user_data); - -MONO_API int -monovm_initialize (int propertyCount, const char **propertyKeys, const char **propertyValues); - -//#ifdef HOST_WASM -typedef void* (*MonoWasmGetNativeToInterpTramp) (MonoMethod *method, void *extra_arg); - -MONO_API void -mono_wasm_install_get_native_to_interp_tramp (MonoWasmGetNativeToInterpTramp cb); -//#endif - -#endif /*__MONO_JIT_MONO_PRIVATE_UNSTABLE_H__*/ diff --git a/src/mono/msvc/include/mono/metadata/appdomain.h b/src/mono/msvc/include/mono/metadata/appdomain.h deleted file mode 100644 index bc8a1f2de199c..0000000000000 --- a/src/mono/msvc/include/mono/metadata/appdomain.h +++ /dev/null @@ -1,234 +0,0 @@ -/** - * \file - * AppDomain functions - * - * Author: - * Dietmar Maurer (dietmar@ximian.com) - * - * (C) 2001 Ximian, Inc. - */ - -#ifndef _MONO_METADATA_APPDOMAIN_H_ -#define _MONO_METADATA_APPDOMAIN_H_ - -#include - -#include -#include -#include - -MONO_BEGIN_DECLS - -typedef void (*MonoThreadStartCB) (intptr_t tid, void* stack_start, - void* func); -typedef void (*MonoThreadAttachCB) (intptr_t tid, void* stack_start); - -typedef struct _MonoAppDomain MonoAppDomain; - -typedef void (*MonoDomainFunc) (MonoDomain *domain, void* user_data); - -MONO_API MonoDomain* -mono_init (const char *filename); - -MONO_API MonoDomain * -mono_init_from_assembly (const char *domain_name, const char *filename); - -MONO_API MonoDomain * -mono_init_version (const char *domain_name, const char *version); - -MONO_API MonoDomain* -mono_get_root_domain (void); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_runtime_init (MonoDomain *domain, MonoThreadStartCB start_cb, - MonoThreadAttachCB attach_cb); - -MONO_API void -mono_runtime_cleanup (MonoDomain *domain); - -MONO_API void -mono_install_runtime_cleanup (MonoDomainFunc func); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_runtime_quit (void); - -MONO_API void -mono_runtime_set_shutting_down (void); - -MONO_API mono_bool -mono_runtime_is_shutting_down (void); - -MONO_API const char* -mono_check_corlib_version (void); - -MONO_API MonoDomain * -mono_domain_create (void); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoDomain * -mono_domain_create_appdomain (char *friendly_name, char *configuration_file); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_domain_set_config (MonoDomain *domain, const char *base_dir, const char *config_file_name); - -MONO_API MonoDomain * -mono_domain_get (void); - -MONO_API MonoDomain * -mono_domain_get_by_id (int32_t domainid); - -MONO_API int32_t -mono_domain_get_id (MonoDomain *domain); - -MONO_API const char * -mono_domain_get_friendly_name (MonoDomain *domain); - -MONO_API MONO_RT_EXTERNAL_ONLY mono_bool -mono_domain_set (MonoDomain *domain, mono_bool force); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_domain_set_internal (MonoDomain *domain); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_domain_unload (MonoDomain *domain); - -MONO_API void -mono_domain_try_unload (MonoDomain *domain, MonoObject **exc); - -MONO_API mono_bool -mono_domain_is_unloading (MonoDomain *domain); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoDomain * -mono_domain_from_appdomain (MonoAppDomain *appdomain); - -MONO_API void -mono_domain_foreach (MonoDomainFunc func, void* user_data); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoAssembly * -mono_domain_assembly_open (MonoDomain *domain, const char *name); - -MONO_API void -mono_domain_ensure_entry_assembly (MonoDomain *domain, MonoAssembly *assembly); - -MONO_API mono_bool -mono_domain_finalize (MonoDomain *domain, uint32_t timeout); - -MONO_API void -mono_domain_free (MonoDomain *domain, mono_bool force); - -MONO_API mono_bool -mono_domain_has_type_resolve (MonoDomain *domain); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoReflectionAssembly * -mono_domain_try_type_resolve (MonoDomain *domain, char *name, MonoObject *tb); - -MONO_API mono_bool -mono_domain_owns_vtable_slot (MonoDomain *domain, void* vtable_slot); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_context_init (MonoDomain *domain); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_context_set (MonoAppContext *new_context); - -MONO_API MonoAppContext * -mono_context_get (void); - -MONO_API int32_t -mono_context_get_id (MonoAppContext *context); - -MONO_API int32_t -mono_context_get_domain_id (MonoAppContext *context); - -MONO_API MonoJitInfo * -mono_jit_info_table_find (MonoDomain *domain, void* addr); - -/* MonoJitInfo accessors */ - -MONO_API void* -mono_jit_info_get_code_start (MonoJitInfo* ji); - -MONO_API int -mono_jit_info_get_code_size (MonoJitInfo* ji); - -MONO_API MonoMethod* -mono_jit_info_get_method (MonoJitInfo* ji); - - -MONO_API MonoImage* -mono_get_corlib (void); - -MONO_API MonoClass* -mono_get_object_class (void); - -MONO_API MonoClass* -mono_get_byte_class (void); - -MONO_API MonoClass* -mono_get_void_class (void); - -MONO_API MonoClass* -mono_get_boolean_class (void); - -MONO_API MonoClass* -mono_get_sbyte_class (void); - -MONO_API MonoClass* -mono_get_int16_class (void); - -MONO_API MonoClass* -mono_get_uint16_class (void); - -MONO_API MonoClass* -mono_get_int32_class (void); - -MONO_API MonoClass* -mono_get_uint32_class (void); - -MONO_API MonoClass* -mono_get_intptr_class (void); - -MONO_API MonoClass* -mono_get_uintptr_class (void); - -MONO_API MonoClass* -mono_get_int64_class (void); - -MONO_API MonoClass* -mono_get_uint64_class (void); - -MONO_API MonoClass* -mono_get_single_class (void); - -MONO_API MonoClass* -mono_get_double_class (void); - -MONO_API MonoClass* -mono_get_char_class (void); - -MONO_API MonoClass* -mono_get_string_class (void); - -MONO_API MonoClass* -mono_get_enum_class (void); - -MONO_API MonoClass* -mono_get_array_class (void); - -MONO_API MonoClass* -mono_get_thread_class (void); - -MONO_API MonoClass* -mono_get_exception_class (void); - -MONO_API void -mono_security_enable_core_clr (void); - -typedef mono_bool (*MonoCoreClrPlatformCB) (const char *image_name); - -MONO_API void -mono_security_set_core_clr_platform_callback (MonoCoreClrPlatformCB callback); - -MONO_END_DECLS - -#endif /* _MONO_METADATA_APPDOMAIN_H_ */ - diff --git a/src/mono/msvc/include/mono/metadata/assembly.h b/src/mono/msvc/include/mono/metadata/assembly.h deleted file mode 100644 index e9c02ee26f5be..0000000000000 --- a/src/mono/msvc/include/mono/metadata/assembly.h +++ /dev/null @@ -1,136 +0,0 @@ -/** - * \file - */ - -#ifndef _MONONET_METADATA_ASSEMBLY_H_ -#define _MONONET_METADATA_ASSEMBLY_H_ - -#include -#include - -MONO_BEGIN_DECLS - -MONO_API void mono_assemblies_init (void); -MONO_API void mono_assemblies_cleanup (void); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoAssembly *mono_assembly_open (const char *filename, - MonoImageOpenStatus *status); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoAssembly *mono_assembly_open_full (const char *filename, - MonoImageOpenStatus *status, - mono_bool refonly); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoAssembly* mono_assembly_load (MonoAssemblyName *aname, - const char *basedir, - MonoImageOpenStatus *status); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoAssembly* mono_assembly_load_full (MonoAssemblyName *aname, - const char *basedir, - MonoImageOpenStatus *status, - mono_bool refonly); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoAssembly* mono_assembly_load_from (MonoImage *image, const char *fname, - MonoImageOpenStatus *status); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoAssembly* mono_assembly_load_from_full (MonoImage *image, const char *fname, - MonoImageOpenStatus *status, - mono_bool refonly); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoAssembly* mono_assembly_load_with_partial_name (const char *name, MonoImageOpenStatus *status); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoAssembly* mono_assembly_loaded (MonoAssemblyName *aname); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoAssembly* mono_assembly_loaded_full (MonoAssemblyName *aname, mono_bool refonly); -MONO_API void mono_assembly_get_assemblyref (MonoImage *image, int index, MonoAssemblyName *aname); -MONO_API void mono_assembly_load_reference (MonoImage *image, int index); -MONO_API void mono_assembly_load_references (MonoImage *image, MonoImageOpenStatus *status); -MONO_API MONO_RT_EXTERNAL_ONLY MonoImage* mono_assembly_load_module (MonoAssembly *assembly, uint32_t idx); -MONO_API void mono_assembly_close (MonoAssembly *assembly); -MONO_API void mono_assembly_setrootdir (const char *root_dir); -MONO_API MONO_CONST_RETURN char *mono_assembly_getrootdir (void); -MONO_API char *mono_native_getrootdir (void); -MONO_API void mono_assembly_foreach (MonoFunc func, void* user_data); -MONO_API void mono_assembly_set_main (MonoAssembly *assembly); -MONO_API MonoAssembly *mono_assembly_get_main (void); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoImage *mono_assembly_get_image (MonoAssembly *assembly); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoAssemblyName *mono_assembly_get_name (MonoAssembly *assembly); -MONO_API mono_bool mono_assembly_fill_assembly_name (MonoImage *image, MonoAssemblyName *aname); -MONO_API mono_bool mono_assembly_names_equal (MonoAssemblyName *l, MonoAssemblyName *r); -MONO_API char* mono_stringify_assembly_name (MonoAssemblyName *aname); - -/* Installs a function which is called each time a new assembly is loaded. */ -typedef void (*MonoAssemblyLoadFunc) (MonoAssembly *assembly, void* user_data); -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_install_assembly_load_hook (MonoAssemblyLoadFunc func, void* user_data); - -/* - * Installs a new function which is used to search the list of loaded - * assemblies for a given assembly name. - */ -typedef MonoAssembly *(*MonoAssemblySearchFunc) (MonoAssemblyName *aname, void* user_data); -MONO_API MONO_RT_EXTERNAL_ONLY -void mono_install_assembly_search_hook (MonoAssemblySearchFunc func, void* user_data); -MONO_API MONO_RT_EXTERNAL_ONLY -void mono_install_assembly_refonly_search_hook (MonoAssemblySearchFunc func, void* user_data); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoAssembly* mono_assembly_invoke_search_hook (MonoAssemblyName *aname); - -/* - * Installs a new search function which is used as a last resort when loading - * an assembly fails. This could invoke AssemblyResolve events. - */ -MONO_API MONO_RT_EXTERNAL_ONLY -void -mono_install_assembly_postload_search_hook (MonoAssemblySearchFunc func, void* user_data); - -MONO_API MONO_RT_EXTERNAL_ONLY -void -mono_install_assembly_postload_refonly_search_hook (MonoAssemblySearchFunc func, void* user_data); - - -/* Installs a function which is called before a new assembly is loaded - * The hook are invoked from last hooked to first. If any of them returns - * a non-null value, that will be the value returned in mono_assembly_load */ -typedef MonoAssembly * (*MonoAssemblyPreLoadFunc) (MonoAssemblyName *aname, - char **assemblies_path, - void* user_data); - -MONO_API MONO_RT_EXTERNAL_ONLY -void mono_install_assembly_preload_hook (MonoAssemblyPreLoadFunc func, void* user_data); -MONO_API MONO_RT_EXTERNAL_ONLY -void mono_install_assembly_refonly_preload_hook (MonoAssemblyPreLoadFunc func, void* user_data); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_assembly_invoke_load_hook (MonoAssembly *ass); - -MONO_API MonoAssemblyName* mono_assembly_name_new (const char *name); -MONO_API const char* mono_assembly_name_get_name (MonoAssemblyName *aname); -MONO_API const char* mono_assembly_name_get_culture (MonoAssemblyName *aname); -MONO_API uint16_t mono_assembly_name_get_version (MonoAssemblyName *aname, - uint16_t *minor, uint16_t *build, uint16_t *revision); -MONO_API mono_byte* mono_assembly_name_get_pubkeytoken (MonoAssemblyName *aname); -MONO_API MONO_RT_EXTERNAL_ONLY void mono_assembly_name_free (MonoAssemblyName *aname); - -typedef struct { - const char *name; - const unsigned char *data; - unsigned int size; -} MonoBundledAssembly; - -MONO_API void mono_register_bundled_assemblies (const MonoBundledAssembly **assemblies); -MONO_API void mono_register_config_for_assembly (const char* assembly_name, const char* config_xml); -MONO_API void mono_register_symfile_for_assembly (const char* assembly_name, const mono_byte *raw_contents, int size); -MONO_API void mono_register_machine_config (const char *config_xml); - -MONO_API void mono_set_rootdir (void); -MONO_API void mono_set_dirs (const char *assembly_dir, const char *config_dir); -MONO_API void mono_set_assemblies_path (const char* path); -MONO_END_DECLS - -#endif - diff --git a/src/mono/msvc/include/mono/metadata/attrdefs.h b/src/mono/msvc/include/mono/metadata/attrdefs.h deleted file mode 100644 index 504c6c65fc6d2..0000000000000 --- a/src/mono/msvc/include/mono/metadata/attrdefs.h +++ /dev/null @@ -1,274 +0,0 @@ -/** - * \file - * This file contains the various definitions for constants - * found on the metadata tables - * - * Author: - * Miguel de Icaza (miguel@ximian.com) - * Paolo Molaro (lupus@ximian.com) - * - * (C) 2001 Ximian, Inc. - * (C) 2006 Novell, Inc. - * - * From the ECMA documentation - */ - -#ifndef _MONO_METADATA_ATTRDEFS_H_ -#define _MONO_METADATA_ATTRDEFS_H_ - -/* - * 23.1.1 Values for AssemblyHashAlgorithm - */ -enum { - MONO_ASSEMBLY_HASH_NONE, - MONO_ASSEMBLY_HASH_MD5 = 0x8003, - MONO_ASSEMBLY_HASH_SHA1 = 0x8004 -}; - -/* - * 23.1.2 AssemblyRefs - */ -enum { - MONO_ASSEMBLYREF_FULL_PUBLIC_KEY = 0x0001, - MONO_ASSEMBLYREF_RETARGETABLE = 0x0100, - MONO_ASSEMBLYREF_JIT_TRACKING = 0x8000, - MONO_ASSEMBLYREF_NO_JIT_OPT = 0x4000 -}; - -/* - * 23.1.4 Flags for Event.EventAttributes - */ -enum { - MONO_EVENT_SPECIALNAME = 0x0200, - MONO_EVENT_RTSPECIALNAME = 0x0400 -}; - -/* - * Field Attributes (23.1.5). - */ -enum { - MONO_FIELD_ATTR_FIELD_ACCESS_MASK = 0x0007, - MONO_FIELD_ATTR_COMPILER_CONTROLLED = 0x0000, - MONO_FIELD_ATTR_PRIVATE = 0x0001, - MONO_FIELD_ATTR_FAM_AND_ASSEM = 0x0002, - MONO_FIELD_ATTR_ASSEMBLY = 0x0003, - MONO_FIELD_ATTR_FAMILY = 0x0004, - MONO_FIELD_ATTR_FAM_OR_ASSEM = 0x0005, - MONO_FIELD_ATTR_PUBLIC = 0x0006, - - MONO_FIELD_ATTR_STATIC = 0x0010, - MONO_FIELD_ATTR_INIT_ONLY = 0x0020, - MONO_FIELD_ATTR_LITERAL = 0x0040, - MONO_FIELD_ATTR_NOT_SERIALIZED = 0x0080, - MONO_FIELD_ATTR_SPECIAL_NAME = 0x0200, - MONO_FIELD_ATTR_PINVOKE_IMPL = 0x2000, - -/* For runtime use only */ - MONO_FIELD_ATTR_RESERVED_MASK = 0x9500, - MONO_FIELD_ATTR_RT_SPECIAL_NAME = 0x0400, - MONO_FIELD_ATTR_HAS_MARSHAL = 0x1000, - MONO_FIELD_ATTR_HAS_DEFAULT = 0x8000, - MONO_FIELD_ATTR_HAS_RVA = 0x0100 -}; - -/* - * 23.1.6 Flags for FileAttributes - */ -enum { - MONO_FILE_HAS_METADATA = 0, - MONO_FILE_HAS_NO_METADATA = 1 -}; - -/* - * 23.1.7 Flags for generic parameters - */ -enum { - MONO_GEN_PARAM_VARIANCE_MASK = 0x0003, - MONO_GEN_PARAM_NON_VARIANT = 0x0000, - MONO_GEN_PARAM_VARIANT = 0x0001, - MONO_GEN_PARAM_COVARIANT = 0x0002, - MONO_GEN_PARAM_CONSTRAINT_MASK = 0x001c, - MONO_GEN_PARAM_CONSTRAINT_CLASS = 0x0004, - MONO_GEN_PARAM_CONSTRAINT_VTYPE = 0x0008, - MONO_GEN_PARAM_CONSTRAINT_DCTOR = 0x0010 -}; - -/* - * 23.1.8 Flags for ImplMap [PInvokeAttributes] - */ -enum { - MONO_PINVOKE_NO_MANGLE = 0x0001, - MONO_PINVOKE_CHAR_SET_MASK = 0x0006, - MONO_PINVOKE_CHAR_SET_NOT_SPEC = 0x0000, - MONO_PINVOKE_CHAR_SET_ANSI = 0x0002, - MONO_PINVOKE_CHAR_SET_UNICODE = 0x0004, - MONO_PINVOKE_CHAR_SET_AUTO = 0x0006, - MONO_PINVOKE_BEST_FIT_ENABLED = 0x0010, - MONO_PINVOKE_BEST_FIT_DISABLED = 0x0020, - MONO_PINVOKE_BEST_FIT_MASK = 0x0030, - MONO_PINVOKE_SUPPORTS_LAST_ERROR = 0x0040, - MONO_PINVOKE_CALL_CONV_MASK = 0x0700, - MONO_PINVOKE_CALL_CONV_WINAPI = 0x0100, - MONO_PINVOKE_CALL_CONV_CDECL = 0x0200, - MONO_PINVOKE_CALL_CONV_STDCALL = 0x0300, - MONO_PINVOKE_CALL_CONV_THISCALL = 0x0400, - MONO_PINVOKE_CALL_CONV_FASTCALL = 0x0500, - MONO_PINVOKE_THROW_ON_UNMAPPABLE_ENABLED = 0x1000, - MONO_PINVOKE_THROW_ON_UNMAPPABLE_DISABLED = 0x2000, - MONO_PINVOKE_THROW_ON_UNMAPPABLE_MASK = 0x3000, - MONO_PINVOKE_CALL_CONV_GENERIC = 0x0010, - MONO_PINVOKE_CALL_CONV_GENERICINST = 0x000a -}; - -/* - * 23.1.9 Flags for ManifestResource - */ -enum { - MONO_MANIFEST_RESOURCE_VISIBILITY_MASK = 0x00000007, - MONO_MANIFEST_RESOURCE_PUBLIC = 0x00000001, - MONO_MANIFEST_RESOURCE_PRIVATE = 0x00000002 -}; - -/* - * Method Attributes (23.1.10) - */ -enum { - MONO_METHOD_ATTR_ACCESS_MASK = 0x0007, - MONO_METHOD_ATTR_COMPILER_CONTROLLED = 0x0000, - MONO_METHOD_ATTR_PRIVATE = 0x0001, - MONO_METHOD_ATTR_FAM_AND_ASSEM = 0x0002, - MONO_METHOD_ATTR_ASSEM = 0x0003, - MONO_METHOD_ATTR_FAMILY = 0x0004, - MONO_METHOD_ATTR_FAM_OR_ASSEM = 0x0005, - MONO_METHOD_ATTR_PUBLIC = 0x0006, - - MONO_METHOD_ATTR_STATIC = 0x0010, - MONO_METHOD_ATTR_FINAL = 0x0020, - MONO_METHOD_ATTR_VIRTUAL = 0x0040, - MONO_METHOD_ATTR_HIDE_BY_SIG = 0x0080, - - MONO_METHOD_ATTR_VTABLE_LAYOUT_MASK = 0x0100, - MONO_METHOD_ATTR_REUSE_SLOT = 0x0000, - MONO_METHOD_ATTR_NEW_SLOT = 0x0100, - MONO_METHOD_ATTR_STRICT = 0x0200, - MONO_METHOD_ATTR_ABSTRACT = 0x0400, - - MONO_METHOD_ATTR_SPECIAL_NAME = 0x0800, - - MONO_METHOD_ATTR_PINVOKE_IMPL = 0x2000, - MONO_METHOD_ATTR_UNMANAGED_EXPORT = 0x0008, - -/* - * For runtime use only - */ - MONO_METHOD_ATTR_RESERVED_MASK = 0xd000, - MONO_METHOD_ATTR_RT_SPECIAL_NAME = 0x1000, - MONO_METHOD_ATTR_HAS_SECURITY = 0x4000, - MONO_METHOD_ATTR_REQUIRE_SEC_OBJECT = 0x8000 -}; - -/* - * Method Impl Attributes (23.1.11) - */ -enum { - MONO_METHOD_IMPL_ATTR_CODE_TYPE_MASK = 0x0003, - MONO_METHOD_IMPL_ATTR_IL = 0x0000, - MONO_METHOD_IMPL_ATTR_NATIVE = 0x0001, - MONO_METHOD_IMPL_ATTR_OPTIL = 0x0002, - MONO_METHOD_IMPL_ATTR_RUNTIME = 0x0003, - - MONO_METHOD_IMPL_ATTR_MANAGED_MASK = 0x0004, - MONO_METHOD_IMPL_ATTR_UNMANAGED = 0x0004, - MONO_METHOD_IMPL_ATTR_MANAGED = 0x0000, - - MONO_METHOD_IMPL_ATTR_FORWARD_REF = 0x0010, - MONO_METHOD_IMPL_ATTR_PRESERVE_SIG = 0x0080, - MONO_METHOD_IMPL_ATTR_INTERNAL_CALL = 0x1000, - MONO_METHOD_IMPL_ATTR_SYNCHRONIZED = 0x0020, - MONO_METHOD_IMPL_ATTR_NOINLINING = 0x0008, - MONO_METHOD_IMPL_ATTR_NOOPTIMIZATION = 0x0040, - MONO_METHOD_IMPL_ATTR_MAX_METHOD_IMPL_VAL = 0xffff -}; - -/* - * Method Semantics ([MethodSemanticAttributes]) 23.1.12, - */ -enum { - MONO_METHOD_SEMANTIC_SETTER = 0x0001, - MONO_METHOD_SEMANTIC_GETTER = 0x0002, - MONO_METHOD_SEMANTIC_OTHER = 0x0004, - MONO_METHOD_SEMANTIC_ADD_ON = 0x0008, - MONO_METHOD_SEMANTIC_REMOVE_ON = 0x0010, - MONO_METHOD_SEMANTIC_FIRE = 0x0020 -}; - -/* - * Flags for Params (23.1.13) - */ -enum { - MONO_PARAM_ATTR_IN = 0x0001, - MONO_PARAM_ATTR_OUT = 0x0002, - MONO_PARAM_ATTR_OPTIONAL = 0x0010, - MONO_PARAM_ATTR_RESERVED_MASK = 0xf000, - MONO_PARAM_ATTR_HAS_DEFAULT = 0x1000, - MONO_PARAM_ATTR_HAS_MARSHAL = 0x2000, - MONO_PARAM_ATTR_UNUSED = 0xcfe0 -}; - -/* - * 23.1.14 PropertyAttributes - */ -enum { - MONO_PROPERTY_ATTR_SPECIAL_NAME = 0x0200, - MONO_PROPERTY_ATTR_RESERVED_MASK = 0xf400, - MONO_PROPERTY_ATTR_RT_SPECIAL_NAME = 0x0400, - MONO_PROPERTY_ATTR_HAS_DEFAULT = 0x1000, - MONO_PROPERTY_ATTR_UNUSED = 0xe9ff -}; - -/* - * Type Attributes (23.1.15). - */ -enum { - MONO_TYPE_ATTR_VISIBILITY_MASK = 0x00000007, - MONO_TYPE_ATTR_NOT_PUBLIC = 0x00000000, - MONO_TYPE_ATTR_PUBLIC = 0x00000001, - MONO_TYPE_ATTR_NESTED_PUBLIC = 0x00000002, - MONO_TYPE_ATTR_NESTED_PRIVATE = 0x00000003, - MONO_TYPE_ATTR_NESTED_FAMILY = 0x00000004, - MONO_TYPE_ATTR_NESTED_ASSEMBLY = 0x00000005, - MONO_TYPE_ATTR_NESTED_FAM_AND_ASSEM = 0x00000006, - MONO_TYPE_ATTR_NESTED_FAM_OR_ASSEM = 0x00000007, - - MONO_TYPE_ATTR_LAYOUT_MASK = 0x00000018, - MONO_TYPE_ATTR_AUTO_LAYOUT = 0x00000000, - MONO_TYPE_ATTR_SEQUENTIAL_LAYOUT = 0x00000008, - MONO_TYPE_ATTR_EXPLICIT_LAYOUT = 0x00000010, - - MONO_TYPE_ATTR_CLASS_SEMANTIC_MASK = 0x00000020, - MONO_TYPE_ATTR_CLASS = 0x00000000, - MONO_TYPE_ATTR_INTERFACE = 0x00000020, - - MONO_TYPE_ATTR_ABSTRACT = 0x00000080, - MONO_TYPE_ATTR_SEALED = 0x00000100, - MONO_TYPE_ATTR_SPECIAL_NAME = 0x00000400, - - MONO_TYPE_ATTR_IMPORT = 0x00001000, - MONO_TYPE_ATTR_SERIALIZABLE = 0x00002000, - - MONO_TYPE_ATTR_STRING_FORMAT_MASK = 0x00030000, - MONO_TYPE_ATTR_ANSI_CLASS = 0x00000000, - MONO_TYPE_ATTR_UNICODE_CLASS = 0x00010000, - MONO_TYPE_ATTR_AUTO_CLASS = 0x00020000, - MONO_TYPE_ATTR_CUSTOM_CLASS = 0x00030000, - MONO_TYPE_ATTR_CUSTOM_MASK = 0x00c00000, - - MONO_TYPE_ATTR_BEFORE_FIELD_INIT = 0x00100000, - MONO_TYPE_ATTR_FORWARDER = 0x00200000, - - MONO_TYPE_ATTR_RESERVED_MASK = 0x00040800, - MONO_TYPE_ATTR_RT_SPECIAL_NAME = 0x00000800, - MONO_TYPE_ATTR_HAS_SECURITY = 0x00040000 -}; - -#endif diff --git a/src/mono/msvc/include/mono/metadata/blob.h b/src/mono/msvc/include/mono/metadata/blob.h deleted file mode 100644 index 7405d54466499..0000000000000 --- a/src/mono/msvc/include/mono/metadata/blob.h +++ /dev/null @@ -1,118 +0,0 @@ -/** - * \file - * Definitions used to pull information out of the Blob - * - */ -#ifndef _MONO_METADATA_BLOB_H_ -#define _MONO_METADATA_BLOB_H_ - -/* - * Encoding for type signatures used in the Metadata - */ -typedef enum { - MONO_TYPE_END = 0x00, /* End of List */ - MONO_TYPE_VOID = 0x01, - MONO_TYPE_BOOLEAN = 0x02, - MONO_TYPE_CHAR = 0x03, - MONO_TYPE_I1 = 0x04, - MONO_TYPE_U1 = 0x05, - MONO_TYPE_I2 = 0x06, - MONO_TYPE_U2 = 0x07, - MONO_TYPE_I4 = 0x08, - MONO_TYPE_U4 = 0x09, - MONO_TYPE_I8 = 0x0a, - MONO_TYPE_U8 = 0x0b, - MONO_TYPE_R4 = 0x0c, - MONO_TYPE_R8 = 0x0d, - MONO_TYPE_STRING = 0x0e, - MONO_TYPE_PTR = 0x0f, /* arg: token */ - MONO_TYPE_BYREF = 0x10, /* arg: token */ - MONO_TYPE_VALUETYPE = 0x11, /* arg: token */ - MONO_TYPE_CLASS = 0x12, /* arg: token */ - MONO_TYPE_VAR = 0x13, /* number */ - MONO_TYPE_ARRAY = 0x14, /* type, rank, boundsCount, bound1, loCount, lo1 */ - MONO_TYPE_GENERICINST= 0x15, /* \x{2026} */ - MONO_TYPE_TYPEDBYREF = 0x16, - MONO_TYPE_I = 0x18, - MONO_TYPE_U = 0x19, - MONO_TYPE_FNPTR = 0x1b, /* arg: full method signature */ - MONO_TYPE_OBJECT = 0x1c, - MONO_TYPE_SZARRAY = 0x1d, /* 0-based one-dim-array */ - MONO_TYPE_MVAR = 0x1e, /* number */ - MONO_TYPE_CMOD_REQD = 0x1f, /* arg: typedef or typeref token */ - MONO_TYPE_CMOD_OPT = 0x20, /* optional arg: typedef or typref token */ - MONO_TYPE_INTERNAL = 0x21, /* CLR internal type */ - - MONO_TYPE_MODIFIER = 0x40, /* Or with the following types */ - MONO_TYPE_SENTINEL = 0x41, /* Sentinel for varargs method signature */ - MONO_TYPE_PINNED = 0x45, /* Local var that points to pinned object */ - - MONO_TYPE_ENUM = 0x55 /* an enumeration */ -} MonoTypeEnum; - -typedef enum { - MONO_TABLE_MODULE, - MONO_TABLE_TYPEREF, - MONO_TABLE_TYPEDEF, - MONO_TABLE_FIELD_POINTER, - MONO_TABLE_FIELD, - MONO_TABLE_METHOD_POINTER, - MONO_TABLE_METHOD, - MONO_TABLE_PARAM_POINTER, - MONO_TABLE_PARAM, - MONO_TABLE_INTERFACEIMPL, - MONO_TABLE_MEMBERREF, /* 0xa */ - MONO_TABLE_CONSTANT, - MONO_TABLE_CUSTOMATTRIBUTE, - MONO_TABLE_FIELDMARSHAL, - MONO_TABLE_DECLSECURITY, - MONO_TABLE_CLASSLAYOUT, - MONO_TABLE_FIELDLAYOUT, /* 0x10 */ - MONO_TABLE_STANDALONESIG, - MONO_TABLE_EVENTMAP, - MONO_TABLE_EVENT_POINTER, - MONO_TABLE_EVENT, - MONO_TABLE_PROPERTYMAP, - MONO_TABLE_PROPERTY_POINTER, - MONO_TABLE_PROPERTY, - MONO_TABLE_METHODSEMANTICS, - MONO_TABLE_METHODIMPL, - MONO_TABLE_MODULEREF, /* 0x1a */ - MONO_TABLE_TYPESPEC, - MONO_TABLE_IMPLMAP, - MONO_TABLE_FIELDRVA, - MONO_TABLE_ENCLOG, - MONO_TABLE_ENCMAP, - MONO_TABLE_ASSEMBLY, /* 0x20 */ - MONO_TABLE_ASSEMBLYPROCESSOR, - MONO_TABLE_ASSEMBLYOS, - MONO_TABLE_ASSEMBLYREF, - MONO_TABLE_ASSEMBLYREFPROCESSOR, - MONO_TABLE_ASSEMBLYREFOS, - MONO_TABLE_FILE, - MONO_TABLE_EXPORTEDTYPE, - MONO_TABLE_MANIFESTRESOURCE, - MONO_TABLE_NESTEDCLASS, - MONO_TABLE_GENERICPARAM, /* 0x2a */ - MONO_TABLE_METHODSPEC, - MONO_TABLE_GENERICPARAMCONSTRAINT, - MONO_TABLE_UNUSED8, - MONO_TABLE_UNUSED9, - MONO_TABLE_UNUSED10, - /* Portable PDB tables */ - MONO_TABLE_DOCUMENT, /* 0x30 */ - MONO_TABLE_METHODBODY, - MONO_TABLE_LOCALSCOPE, - MONO_TABLE_LOCALVARIABLE, - MONO_TABLE_LOCALCONSTANT, - MONO_TABLE_IMPORTSCOPE, - MONO_TABLE_STATEMACHINEMETHOD, - MONO_TABLE_CUSTOMDEBUGINFORMATION - -#define MONO_TABLE_LAST MONO_TABLE_CUSTOMDEBUGINFORMATION -#define MONO_TABLE_NUM (MONO_TABLE_LAST + 1) - -} MonoMetaTableEnum; - -#endif - diff --git a/src/mono/msvc/include/mono/metadata/class.h b/src/mono/msvc/include/mono/metadata/class.h deleted file mode 100644 index 8966e029b7c6c..0000000000000 --- a/src/mono/msvc/include/mono/metadata/class.h +++ /dev/null @@ -1,313 +0,0 @@ -/** - * \file - */ - -#ifndef _MONO_CLI_CLASS_H_ -#define _MONO_CLI_CLASS_H_ - -#include -#include -#include -#include - -MONO_BEGIN_DECLS - -typedef struct MonoVTable MonoVTable; - -typedef struct _MonoClassField MonoClassField; -typedef struct _MonoProperty MonoProperty; -typedef struct _MonoEvent MonoEvent; - -typedef enum { - MONO_TYPE_NAME_FORMAT_IL, - MONO_TYPE_NAME_FORMAT_REFLECTION, - MONO_TYPE_NAME_FORMAT_FULL_NAME, - MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED -} MonoTypeNameFormat; - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoClass * -mono_class_get (MonoImage *image, uint32_t type_token); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoClass * -mono_class_get_full (MonoImage *image, uint32_t type_token, MonoGenericContext *context); - -MONO_API MONO_RT_EXTERNAL_ONLY mono_bool -mono_class_init (MonoClass *klass); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoVTable * -mono_class_vtable (MonoDomain *domain, MonoClass *klass); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoClass * -mono_class_from_name (MonoImage *image, const char* name_space, const char *name); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoClass * -mono_class_from_name_case (MonoImage *image, const char* name_space, const char *name); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod * -mono_class_get_method_from_name_flags (MonoClass *klass, const char *name, int param_count, int flags); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoClass * -mono_class_from_typeref (MonoImage *image, uint32_t type_token); - -MONO_API MonoClass * -mono_class_from_typeref_checked (MonoImage *image, uint32_t type_token, MonoError *error); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoClass * -mono_class_from_generic_parameter (MonoGenericParam *param, MonoImage *image, mono_bool is_mvar); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoType* -mono_class_inflate_generic_type (MonoType *type, MonoGenericContext *context) /* MONO_DEPRECATED */; - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoMethod* -mono_class_inflate_generic_method (MonoMethod *method, MonoGenericContext *context); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoMethod * -mono_get_inflated_method (MonoMethod *method); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoClassField* -mono_field_from_token (MonoImage *image, uint32_t token, MonoClass **retklass, MonoGenericContext *context); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoClass * -mono_bounded_array_class_get (MonoClass *element_class, uint32_t rank, mono_bool bounded); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoClass * -mono_array_class_get (MonoClass *element_class, uint32_t rank); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoClass * -mono_ptr_class_get (MonoType *type); - -MONO_API MonoClassField * -mono_class_get_field (MonoClass *klass, uint32_t field_token); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoClassField * -mono_class_get_field_from_name (MonoClass *klass, const char *name); - -MONO_API uint32_t -mono_class_get_field_token (MonoClassField *field); - -MONO_API uint32_t -mono_class_get_event_token (MonoEvent *event); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoProperty * -mono_class_get_property_from_name (MonoClass *klass, const char *name); - -MONO_API uint32_t -mono_class_get_property_token (MonoProperty *prop); - -MONO_API int32_t -mono_array_element_size (MonoClass *ac); - -MONO_API int32_t -mono_class_instance_size (MonoClass *klass); - -MONO_API int32_t -mono_class_array_element_size (MonoClass *klass); - -MONO_API int32_t -mono_class_data_size (MonoClass *klass); - -MONO_API int32_t -mono_class_value_size (MonoClass *klass, uint32_t *align); - -MONO_API int32_t -mono_class_min_align (MonoClass *klass); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoClass * -mono_class_from_mono_type (MonoType *type); - -MONO_API MONO_RT_EXTERNAL_ONLY mono_bool -mono_class_is_subclass_of (MonoClass *klass, MonoClass *klassc, - mono_bool check_interfaces); - -MONO_API MONO_RT_EXTERNAL_ONLY mono_bool -mono_class_is_assignable_from (MonoClass *klass, MonoClass *oklass); - -MONO_API MONO_RT_EXTERNAL_ONLY -void* -mono_ldtoken (MonoImage *image, uint32_t token, MonoClass **retclass, MonoGenericContext *context); - -MONO_API char * -mono_type_get_name_full (MonoType *type, MonoTypeNameFormat format); - -MONO_API char* -mono_type_get_name (MonoType *type); - -MONO_API MonoType* -mono_type_get_underlying_type (MonoType *type); - -/* MonoClass accessors */ -MONO_API MonoImage* -mono_class_get_image (MonoClass *klass); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoClass* -mono_class_get_element_class (MonoClass *klass); - -MONO_API MONO_RT_EXTERNAL_ONLY -mono_bool -mono_class_is_valuetype (MonoClass *klass); - -MONO_API MONO_RT_EXTERNAL_ONLY -mono_bool -mono_class_is_enum (MonoClass *klass); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoType* -mono_class_enum_basetype (MonoClass *klass); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoClass* -mono_class_get_parent (MonoClass *klass); - -MONO_API MonoClass* -mono_class_get_nesting_type (MonoClass *klass); - -MONO_API int -mono_class_get_rank (MonoClass *klass); - -MONO_API uint32_t -mono_class_get_flags (MonoClass *klass); - -MONO_API MONO_RT_EXTERNAL_ONLY -const char* -mono_class_get_name (MonoClass *klass); - -MONO_API MONO_RT_EXTERNAL_ONLY -const char* -mono_class_get_namespace (MonoClass *klass); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoType* -mono_class_get_type (MonoClass *klass); - -MONO_API uint32_t -mono_class_get_type_token (MonoClass *klass); - -MONO_API MonoType* -mono_class_get_byref_type (MonoClass *klass); - -MONO_API int -mono_class_num_fields (MonoClass *klass); - -MONO_API int -mono_class_num_methods (MonoClass *klass); - -MONO_API int -mono_class_num_properties (MonoClass *klass); - -MONO_API int -mono_class_num_events (MonoClass *klass); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoClassField* -mono_class_get_fields (MonoClass* klass, void **iter); - -MONO_API MonoMethod* -mono_class_get_methods (MonoClass* klass, void **iter); - -MONO_API MonoProperty* -mono_class_get_properties (MonoClass* klass, void **iter); - -MONO_API MonoEvent* -mono_class_get_events (MonoClass* klass, void **iter); - -MONO_API MonoClass* -mono_class_get_interfaces (MonoClass* klass, void **iter); - -MONO_API MonoClass* -mono_class_get_nested_types (MonoClass* klass, void **iter); - -MONO_API MONO_RT_EXTERNAL_ONLY -mono_bool -mono_class_is_delegate (MonoClass* klass); - -MONO_API MONO_RT_EXTERNAL_ONLY mono_bool -mono_class_implements_interface (MonoClass* klass, MonoClass* iface); - -/* MonoClassField accessors */ -MONO_API const char* -mono_field_get_name (MonoClassField *field); - -MONO_API MonoType* -mono_field_get_type (MonoClassField *field); - -MONO_API MonoClass* -mono_field_get_parent (MonoClassField *field); - -MONO_API uint32_t -mono_field_get_flags (MonoClassField *field); - -MONO_API uint32_t -mono_field_get_offset (MonoClassField *field); - -MONO_API const char * -mono_field_get_data (MonoClassField *field); - -/* MonoProperty acessors */ -MONO_API const char* -mono_property_get_name (MonoProperty *prop); - -MONO_API MonoMethod* -mono_property_get_set_method (MonoProperty *prop); - -MONO_API MonoMethod* -mono_property_get_get_method (MonoProperty *prop); - -MONO_API MonoClass* -mono_property_get_parent (MonoProperty *prop); - -MONO_API uint32_t -mono_property_get_flags (MonoProperty *prop); - -/* MonoEvent accessors */ -MONO_API const char* -mono_event_get_name (MonoEvent *event); - -MONO_API MonoMethod* -mono_event_get_add_method (MonoEvent *event); - -MONO_API MonoMethod* -mono_event_get_remove_method (MonoEvent *event); - -MONO_API MonoMethod* -mono_event_get_remove_method (MonoEvent *event); - -MONO_API MonoMethod* -mono_event_get_raise_method (MonoEvent *event); - -MONO_API MonoClass* -mono_event_get_parent (MonoEvent *event); - -MONO_API uint32_t -mono_event_get_flags (MonoEvent *event); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod * -mono_class_get_method_from_name (MonoClass *klass, const char *name, int param_count); - -MONO_API char * -mono_class_name_from_token (MonoImage *image, uint32_t type_token); - -MONO_API mono_bool -mono_method_can_access_field (MonoMethod *method, MonoClassField *field); - -MONO_API mono_bool -mono_method_can_access_method (MonoMethod *method, MonoMethod *called); - -MONO_API mono_bool -mono_class_is_nullable (MonoClass *klass); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoClass* -mono_class_get_nullable_param (MonoClass *klass); - -MONO_END_DECLS - -#endif /* _MONO_CLI_CLASS_H_ */ diff --git a/src/mono/msvc/include/mono/metadata/debug-helpers.h b/src/mono/msvc/include/mono/metadata/debug-helpers.h deleted file mode 100644 index 8ecdf8edc589f..0000000000000 --- a/src/mono/msvc/include/mono/metadata/debug-helpers.h +++ /dev/null @@ -1,54 +0,0 @@ -/** - * \file - */ - -#ifndef __MONO_DEBUG_HELPERS_H__ -#define __MONO_DEBUG_HELPERS_H__ - -#include - -MONO_BEGIN_DECLS - -typedef struct MonoDisHelper MonoDisHelper; - -typedef char* (*MonoDisIndenter) (MonoDisHelper *dh, MonoMethod *method, uint32_t ip_offset); -typedef char* (*MonoDisTokener) (MonoDisHelper *dh, MonoMethod *method, uint32_t token); - -struct MonoDisHelper { - const char *newline; - const char *label_format; - const char *label_target; - MonoDisIndenter indenter; - MonoDisTokener tokener; - void* user_data; -}; - -MONO_API char* mono_disasm_code_one (MonoDisHelper *dh, MonoMethod *method, const mono_byte *ip, const mono_byte** endp); -MONO_API char* mono_disasm_code (MonoDisHelper *dh, MonoMethod *method, const mono_byte *ip, const mono_byte* end); - -typedef struct MonoMethodDesc MonoMethodDesc; - -MONO_API char* mono_type_full_name (MonoType *type); - -MONO_API char* mono_signature_get_desc (MonoMethodSignature *sig, mono_bool include_namespace); - -MONO_API char* mono_context_get_desc (MonoGenericContext *context); - -MONO_API MonoMethodDesc* mono_method_desc_new (const char *name, mono_bool include_namespace); -MONO_API MonoMethodDesc* mono_method_desc_from_method (MonoMethod *method); -MONO_API void mono_method_desc_free (MonoMethodDesc *desc); -MONO_API mono_bool mono_method_desc_match (MonoMethodDesc *desc, MonoMethod *method); -MONO_API mono_bool mono_method_desc_is_full (MonoMethodDesc *desc); -MONO_API mono_bool mono_method_desc_full_match (MonoMethodDesc *desc, MonoMethod *method); -MONO_API MonoMethod* mono_method_desc_search_in_class (MonoMethodDesc *desc, MonoClass *klass); -MONO_API MonoMethod* mono_method_desc_search_in_image (MonoMethodDesc *desc, MonoImage *image); - -MONO_API char* mono_method_full_name (MonoMethod *method, mono_bool signature); -MONO_API char* mono_method_get_reflection_name (MonoMethod *method); - -MONO_API char* mono_field_full_name (MonoClassField *field); - -MONO_END_DECLS - -#endif /* __MONO_DEBUG_HELPERS_H__ */ - diff --git a/src/mono/msvc/include/mono/metadata/debug-mono-symfile.h b/src/mono/msvc/include/mono/metadata/debug-mono-symfile.h deleted file mode 100644 index cebc943d8506c..0000000000000 --- a/src/mono/msvc/include/mono/metadata/debug-mono-symfile.h +++ /dev/null @@ -1,114 +0,0 @@ -/** - * \file - * This header is only installed for use by the debugger: - * the structures and the API declared here are not supported. - * Copyright 2012 Xamarin Inc (http://www.xamarin.com) - * Licensed under the MIT license. See LICENSE file in the project root for full license information. - */ - -#ifndef __MONO_DEBUG_MONO_SYMFILE_H__ -#define __MONO_DEBUG_MONO_SYMFILE_H__ - -#include -#include -#include -#include -#include - -typedef struct MonoSymbolFileOffsetTable MonoSymbolFileOffsetTable; -typedef struct MonoSymbolFileLineNumberEntry MonoSymbolFileLineNumberEntry; -typedef struct MonoSymbolFileMethodAddress MonoSymbolFileMethodAddress; -typedef struct MonoSymbolFileDynamicTable MonoSymbolFileDynamicTable; -typedef struct MonoSymbolFileSourceEntry MonoSymbolFileSourceEntry; -typedef struct MonoSymbolFileMethodEntry MonoSymbolFileMethodEntry; - -/* Keep in sync with OffsetTable in mcs/class/Mono.CSharp.Debugger/MonoSymbolTable.cs */ -struct MonoSymbolFileOffsetTable { - uint32_t _total_file_size; - uint32_t _data_section_offset; - uint32_t _data_section_size; - uint32_t _compile_unit_count; - uint32_t _compile_unit_table_offset; - uint32_t _compile_unit_table_size; - uint32_t _source_count; - uint32_t _source_table_offset; - uint32_t _source_table_size; - uint32_t _method_count; - uint32_t _method_table_offset; - uint32_t _method_table_size; - uint32_t _type_count; - uint32_t _anonymous_scope_count; - uint32_t _anonymous_scope_table_offset; - uint32_t _anonymous_scope_table_size; - uint32_t _line_number_table_line_base; - uint32_t _line_number_table_line_range; - uint32_t _line_number_table_opcode_base; - uint32_t _is_aspx_source; -}; - -struct MonoSymbolFileSourceEntry { - uint32_t _index; - uint32_t _data_offset; -}; - -struct MonoSymbolFileMethodEntry { - uint32_t _token; - uint32_t _data_offset; - uint32_t _line_number_table; -}; - -struct MonoSymbolFileMethodAddress { - uint32_t size; - const uint8_t *start_address; - const uint8_t *end_address; - const uint8_t *method_start_address; - const uint8_t *method_end_address; - const uint8_t *wrapper_address; - uint32_t has_this; - uint32_t num_params; - uint32_t variable_table_offset; - uint32_t type_table_offset; - uint32_t num_line_numbers; - uint32_t line_number_offset; - uint8_t data [MONO_ZERO_LEN_ARRAY]; -}; - -#define MONO_SYMBOL_FILE_MAJOR_VERSION 50 -#define MONO_SYMBOL_FILE_MINOR_VERSION 0 -#define MONO_SYMBOL_FILE_MAGIC 0x45e82623fd7fa614ULL - -MONO_BEGIN_DECLS - -MONO_API MonoSymbolFile * -mono_debug_open_mono_symbols (MonoDebugHandle *handle, - const uint8_t *raw_contents, - int size, - mono_bool in_the_debugger); - -MONO_API void -mono_debug_close_mono_symbol_file (MonoSymbolFile *symfile); - -MONO_API mono_bool -mono_debug_symfile_is_loaded (MonoSymbolFile *symfile); - -MONO_API MonoDebugSourceLocation * -mono_debug_symfile_lookup_location (MonoDebugMethodInfo *minfo, - uint32_t offset); - -MONO_API void -mono_debug_symfile_free_location (MonoDebugSourceLocation *location); - -MONO_API MonoDebugMethodInfo * -mono_debug_symfile_lookup_method (MonoDebugHandle *handle, - MonoMethod *method); - -MONO_API MonoDebugLocalsInfo* -mono_debug_symfile_lookup_locals (MonoDebugMethodInfo *minfo); - -void -mono_debug_symfile_get_seq_points (MonoDebugMethodInfo *minfo, char **source_file, GPtrArray **source_file_list, int **source_files, MonoSymSeqPoint **seq_points, int *n_seq_points); - -MONO_END_DECLS - -#endif /* __MONO_SYMFILE_H__ */ - diff --git a/src/mono/msvc/include/mono/metadata/environment.h b/src/mono/msvc/include/mono/metadata/environment.h deleted file mode 100644 index 1fb5a57b31ecb..0000000000000 --- a/src/mono/msvc/include/mono/metadata/environment.h +++ /dev/null @@ -1,23 +0,0 @@ -/** - * \file - * System.Environment support internal calls - * - * Author: - * Dick Porter (dick@ximian.com) - * - * (C) 2002 Ximian, Inc - */ - -#ifndef _MONO_METADATA_ENVIRONMENT_H_ -#define _MONO_METADATA_ENVIRONMENT_H_ - -#include - -MONO_BEGIN_DECLS - -MONO_API int32_t mono_environment_exitcode_get (void); -MONO_API void mono_environment_exitcode_set (int32_t value); - -MONO_END_DECLS - -#endif /* _MONO_METADATA_ENVIRONMENT_H_ */ diff --git a/src/mono/msvc/include/mono/metadata/exception.h b/src/mono/msvc/include/mono/metadata/exception.h deleted file mode 100644 index 155c23c7e7747..0000000000000 --- a/src/mono/msvc/include/mono/metadata/exception.h +++ /dev/null @@ -1,177 +0,0 @@ -/** - * \file - */ - -#ifndef _MONO_METADATA_EXCEPTION_H_ -#define _MONO_METADATA_EXCEPTION_H_ - -#include -#include -#include - -MONO_BEGIN_DECLS - -MONO_API MonoException * -mono_exception_from_name (MonoImage *image, - const char* name_space, - const char *name); - -MONO_API MonoException * -mono_exception_from_token (MonoImage *image, uint32_t token); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoException * -mono_exception_from_name_two_strings (MonoImage *image, const char *name_space, - const char *name, MonoString *a1, MonoString *a2); - -MONO_API MonoException * -mono_exception_from_name_msg (MonoImage *image, const char *name_space, - const char *name, const char *msg); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoException * -mono_exception_from_token_two_strings (MonoImage *image, uint32_t token, - MonoString *a1, MonoString *a2); - -MONO_API MonoException * -mono_exception_from_name_domain (MonoDomain *domain, MonoImage *image, - const char* name_space, - const char *name); - -MONO_API MonoException * -mono_get_exception_divide_by_zero (void); - -MONO_API MonoException * -mono_get_exception_security (void); - -MONO_API MonoException * -mono_get_exception_arithmetic (void); - -MONO_API MonoException * -mono_get_exception_overflow (void); - -MONO_API MonoException * -mono_get_exception_null_reference (void); - -MONO_API MonoException * -mono_get_exception_execution_engine (const char *msg); - -MONO_API MonoException * -mono_get_exception_thread_abort (void); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoException * -mono_get_exception_thread_state (const char *msg); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoException * -mono_get_exception_thread_interrupted (void); - -MONO_API MonoException * -mono_get_exception_serialization (const char *msg); - -MONO_API MonoException * -mono_get_exception_invalid_cast (void); - -MONO_API MonoException * -mono_get_exception_invalid_operation (const char *msg); - -MONO_API MonoException * -mono_get_exception_index_out_of_range (void); - -MONO_API MonoException * -mono_get_exception_array_type_mismatch (void); - -MONO_API MonoException * -mono_get_exception_type_load (MonoString *class_name, char *assembly_name); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoException * -mono_get_exception_missing_method (const char *class_name, const char *member_name); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoException * -mono_get_exception_missing_field (const char *class_name, const char *member_name); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoException * -mono_get_exception_not_implemented (const char *msg); - -MONO_API MonoException * -mono_get_exception_not_supported (const char *msg); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoException* -mono_get_exception_argument_null (const char *arg); - -MONO_API MonoException * -mono_get_exception_argument (const char *arg, const char *msg); - -MONO_API MonoException * -mono_get_exception_argument_out_of_range (const char *arg); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoException * -mono_get_exception_io (const char *msg); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoException * -mono_get_exception_file_not_found (MonoString *fname); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoException * -mono_get_exception_file_not_found2 (const char *msg, MonoString *fname); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoException * -mono_get_exception_type_initialization (const char *type_name, MonoException *inner); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoException * -mono_get_exception_synchronization_lock (const char *msg); - -MONO_API MonoException * -mono_get_exception_cannot_unload_appdomain (const char *msg); - -MONO_API MonoException * -mono_get_exception_appdomain_unloaded (void); - -MONO_API MonoException * -mono_get_exception_bad_image_format (const char *msg); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoException * -mono_get_exception_bad_image_format2 (const char *msg, MonoString *fname); - -MONO_API MonoException * -mono_get_exception_stack_overflow (void); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoException * -mono_get_exception_out_of_memory (void); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoException * -mono_get_exception_field_access (void); - -MONO_API MonoException * -mono_get_exception_method_access (void); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoException * -mono_get_exception_reflection_type_load (MonoArray *types, MonoArray *exceptions); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoException * -mono_get_exception_runtime_wrapped (MonoObject *wrapped_exception); - -/* Installs a function which is called when the runtime encounters an unhandled exception. - * This hook isn't expected to return. - * If no hook has been installed, the runtime will print a message before aborting. - */ -typedef void (*MonoUnhandledExceptionFunc) (MonoObject *exc, void *user_data); -MONO_API void mono_install_unhandled_exception_hook (MonoUnhandledExceptionFunc func, void *user_data); -void mono_invoke_unhandled_exception_hook (MonoObject *exc); - -MONO_END_DECLS - -#endif /* _MONO_METADATA_EXCEPTION_H_ */ diff --git a/src/mono/msvc/include/mono/metadata/image.h b/src/mono/msvc/include/mono/metadata/image.h deleted file mode 100644 index 4ef0f5a341bd0..0000000000000 --- a/src/mono/msvc/include/mono/metadata/image.h +++ /dev/null @@ -1,99 +0,0 @@ -/** - * \file - */ - -#ifndef _MONONET_METADATA_IMAGE_H_ -#define _MONONET_METADATA_IMAGE_H_ - -#include -#include -#include -#include - -MONO_BEGIN_DECLS - -typedef struct _MonoAssembly MonoAssembly; -typedef struct _MonoAssemblyName MonoAssemblyName; -typedef struct _MonoTableInfo MonoTableInfo; - -typedef enum { - MONO_IMAGE_OK, - MONO_IMAGE_ERROR_ERRNO, - MONO_IMAGE_MISSING_ASSEMBLYREF, - MONO_IMAGE_IMAGE_INVALID -} MonoImageOpenStatus; - -MONO_API void mono_images_init (void); -MONO_API void mono_images_cleanup (void); - -MONO_API MonoImage *mono_image_open (const char *fname, - MonoImageOpenStatus *status); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoImage *mono_image_open_full (const char *fname, - MonoImageOpenStatus *status, mono_bool refonly); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoImage *mono_pe_file_open (const char *fname, - MonoImageOpenStatus *status); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoImage *mono_image_open_from_data (char *data, uint32_t data_len, mono_bool need_copy, - MonoImageOpenStatus *status); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoImage *mono_image_open_from_data_full (char *data, uint32_t data_len, mono_bool need_copy, - MonoImageOpenStatus *status, mono_bool refonly); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoImage *mono_image_open_from_data_with_name (char *data, uint32_t data_len, mono_bool need_copy, - MonoImageOpenStatus *status, mono_bool refonly, const char *name); -MONO_API void mono_image_fixup_vtable (MonoImage *image); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoImage *mono_image_loaded (const char *name); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoImage *mono_image_loaded_full (const char *name, mono_bool refonly); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoImage *mono_image_loaded_by_guid (const char *guid); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoImage *mono_image_loaded_by_guid_full (const char *guid, mono_bool refonly); -MONO_API void mono_image_init (MonoImage *image); -MONO_API void mono_image_close (MonoImage *image); -MONO_API void mono_image_addref (MonoImage *image); -MONO_API const char *mono_image_strerror (MonoImageOpenStatus status); - -MONO_API int mono_image_ensure_section (MonoImage *image, - const char *section); -MONO_API int mono_image_ensure_section_idx (MonoImage *image, - int section); - -MONO_API uint32_t mono_image_get_entry_point (MonoImage *image); -MONO_API const char *mono_image_get_resource (MonoImage *image, uint32_t offset, uint32_t *size); -MONO_API MONO_RT_EXTERNAL_ONLY MonoImage* mono_image_load_file_for_image (MonoImage *image, int fileidx); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoImage* mono_image_load_module (MonoImage *image, int idx); - -MONO_API const char* mono_image_get_name (MonoImage *image); -MONO_API const char* mono_image_get_filename (MonoImage *image); -MONO_API const char * mono_image_get_guid (MonoImage *image); -MONO_API MonoAssembly* mono_image_get_assembly (MonoImage *image); -MONO_API mono_bool mono_image_is_dynamic (MonoImage *image); -MONO_API char* mono_image_rva_map (MonoImage *image, uint32_t rva); - -MONO_API const MonoTableInfo *mono_image_get_table_info (MonoImage *image, int table_id); -MONO_API int mono_image_get_table_rows (MonoImage *image, int table_id); -MONO_API int mono_table_info_get_rows (const MonoTableInfo *table); - -/* This actually returns a MonoPEResourceDataEntry *, but declaring it - * causes an include file loop. - */ -MONO_API void* mono_image_lookup_resource (MonoImage *image, uint32_t res_id, - uint32_t lang_id, mono_unichar2 *name); - -MONO_API const char* mono_image_get_public_key (MonoImage *image, uint32_t *size); -MONO_API const char* mono_image_get_strong_name (MonoImage *image, uint32_t *size); -MONO_API uint32_t mono_image_strong_name_position (MonoImage *image, uint32_t *size); -MONO_API void mono_image_add_to_name_cache (MonoImage *image, - const char *nspace, const char *name, uint32_t idx); -MONO_API mono_bool mono_image_has_authenticode_entry (MonoImage *image); - -mono_bool mono_has_pdb_checksum (char *raw_data, uint32_t raw_data_len); - -MONO_END_DECLS - -#endif diff --git a/src/mono/msvc/include/mono/metadata/loader.h b/src/mono/msvc/include/mono/metadata/loader.h deleted file mode 100644 index 42c89288fcc6e..0000000000000 --- a/src/mono/msvc/include/mono/metadata/loader.h +++ /dev/null @@ -1,109 +0,0 @@ -/** - * \file - */ - -#ifndef _MONO_METADATA_LOADER_H_ -#define _MONO_METADATA_LOADER_H_ 1 - -#include -#include -#include -#include - -MONO_BEGIN_DECLS - -typedef mono_bool (*MonoStackWalk) (MonoMethod *method, int32_t native_offset, int32_t il_offset, mono_bool managed, void* data); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod * -mono_get_method (MonoImage *image, uint32_t token, MonoClass *klass); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod * -mono_get_method_full (MonoImage *image, uint32_t token, MonoClass *klass, - MonoGenericContext *context); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod * -mono_get_method_constrained (MonoImage *image, uint32_t token, MonoClass *constrained_class, - MonoGenericContext *context, MonoMethod **cil_method); - -MONO_API void -mono_free_method (MonoMethod *method); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoMethodSignature* -mono_method_get_signature_full (MonoMethod *method, MonoImage *image, uint32_t token, - MonoGenericContext *context); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoMethodSignature* -mono_method_get_signature (MonoMethod *method, MonoImage *image, uint32_t token); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoMethodSignature* -mono_method_signature (MonoMethod *method); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoMethodHeader* -mono_method_get_header (MonoMethod *method); - -MONO_API const char* -mono_method_get_name (MonoMethod *method); - -MONO_API MonoClass* -mono_method_get_class (MonoMethod *method); - -MONO_API uint32_t -mono_method_get_token (MonoMethod *method); - -MONO_API uint32_t -mono_method_get_flags (MonoMethod *method, uint32_t *iflags); - -MONO_API uint32_t -mono_method_get_index (MonoMethod *method); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_add_internal_call (const char *name, const void* method); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_dangerous_add_raw_internal_call (const char *name, const void* method); - -MONO_API void* -mono_lookup_internal_call (MonoMethod *method); - -MONO_API const char* -mono_lookup_icall_symbol (MonoMethod *m); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_dllmap_insert (MonoImage *assembly, const char *dll, const char *func, const char *tdll, const char *tfunc); - -MONO_API MONO_RT_EXTERNAL_ONLY void* -mono_lookup_pinvoke_call (MonoMethod *method, const char **exc_class, const char **exc_arg); - -MONO_API void -mono_method_get_param_names (MonoMethod *method, const char **names); - -MONO_API uint32_t -mono_method_get_param_token (MonoMethod *method, int idx); - -MONO_API void -mono_method_get_marshal_info (MonoMethod *method, MonoMarshalSpec **mspecs); - -MONO_API mono_bool -mono_method_has_marshal_info (MonoMethod *method); - -MONO_API MonoMethod* -mono_method_get_last_managed (void); - -MONO_API void -mono_stack_walk (MonoStackWalk func, void* user_data); - -/* Use this if the IL offset is not needed: it's faster */ -MONO_API void -mono_stack_walk_no_il (MonoStackWalk func, void* user_data); - -typedef mono_bool (*MonoStackWalkAsyncSafe) (MonoMethod *method, MonoDomain *domain, void *base_address, int offset, void* data); -MONO_API void -mono_stack_walk_async_safe (MonoStackWalkAsyncSafe func, void *initial_sig_context, void* user_data); - -MONO_API MonoMethodHeader* -mono_method_get_header_checked (MonoMethod *method, MonoError *error); - -MONO_END_DECLS - -#endif - diff --git a/src/mono/msvc/include/mono/metadata/metadata.h b/src/mono/msvc/include/mono/metadata/metadata.h deleted file mode 100644 index 965b06a86c195..0000000000000 --- a/src/mono/msvc/include/mono/metadata/metadata.h +++ /dev/null @@ -1,517 +0,0 @@ -/** - * \file - */ - -#ifndef __MONO_METADATA_H__ -#define __MONO_METADATA_H__ - -#include - -#include -#include -#include -#include -#include - -MONO_BEGIN_DECLS - -#define MONO_TYPE_ISSTRUCT(t) mono_type_is_struct (t) -#define MONO_TYPE_IS_VOID(t) mono_type_is_void (t) -#define MONO_TYPE_IS_POINTER(t) mono_type_is_pointer (t) -#define MONO_TYPE_IS_REFERENCE(t) mono_type_is_reference (t) - -#define MONO_CLASS_IS_INTERFACE(c) ((mono_class_get_flags (c) & TYPE_ATTRIBUTE_INTERFACE) || mono_type_is_generic_parameter (mono_class_get_type (c))) - -#define MONO_CLASS_IS_IMPORT(c) ((mono_class_get_flags (c) & TYPE_ATTRIBUTE_IMPORT)) - -typedef enum { - MONO_EXCEPTION_CLAUSE_NONE, - MONO_EXCEPTION_CLAUSE_FILTER, - MONO_EXCEPTION_CLAUSE_FINALLY, - MONO_EXCEPTION_CLAUSE_FAULT = 4 -} MonoExceptionEnum; - -typedef enum { - MONO_CALL_DEFAULT, - MONO_CALL_C, - MONO_CALL_STDCALL, - MONO_CALL_THISCALL, - MONO_CALL_FASTCALL, - MONO_CALL_VARARG -} MonoCallConvention; - -/* ECMA lamespec: the old spec had more info... */ -typedef enum { - MONO_NATIVE_BOOLEAN = 0x02, /* 4 bytes, 0 is false, != 0 is true */ - MONO_NATIVE_I1 = 0x03, - MONO_NATIVE_U1 = 0x04, - MONO_NATIVE_I2 = 0x05, - MONO_NATIVE_U2 = 0x06, - MONO_NATIVE_I4 = 0x07, - MONO_NATIVE_U4 = 0x08, - MONO_NATIVE_I8 = 0x09, - MONO_NATIVE_U8 = 0x0a, - MONO_NATIVE_R4 = 0x0b, - MONO_NATIVE_R8 = 0x0c, - MONO_NATIVE_CURRENCY = 0x0f, - MONO_NATIVE_BSTR = 0x13, /* prefixed length, Unicode */ - MONO_NATIVE_LPSTR = 0x14, /* ANSI, null terminated */ - MONO_NATIVE_LPWSTR = 0x15, /* UNICODE, null terminated */ - MONO_NATIVE_LPTSTR = 0x16, /* plattform dep., null terminated */ - MONO_NATIVE_BYVALTSTR = 0x17, - MONO_NATIVE_IUNKNOWN = 0x19, - MONO_NATIVE_IDISPATCH = 0x1a, - MONO_NATIVE_STRUCT = 0x1b, - MONO_NATIVE_INTERFACE = 0x1c, - MONO_NATIVE_SAFEARRAY = 0x1d, - MONO_NATIVE_BYVALARRAY = 0x1e, - MONO_NATIVE_INT = 0x1f, - MONO_NATIVE_UINT = 0x20, - MONO_NATIVE_VBBYREFSTR = 0x22, - MONO_NATIVE_ANSIBSTR = 0x23, /* prefixed length, ANSI */ - MONO_NATIVE_TBSTR = 0x24, /* prefixed length, plattform dep. */ - MONO_NATIVE_VARIANTBOOL = 0x25, - MONO_NATIVE_FUNC = 0x26, - MONO_NATIVE_ASANY = 0x28, - MONO_NATIVE_LPARRAY = 0x2a, - MONO_NATIVE_LPSTRUCT = 0x2b, - MONO_NATIVE_CUSTOM = 0x2c, - MONO_NATIVE_ERROR = 0x2d, - // TODO: MONO_NATIVE_IINSPECTABLE = 0x2e - // TODO: MONO_NATIVE_HSTRING = 0x2f - MONO_NATIVE_UTF8STR = 0x30, - MONO_NATIVE_MAX = 0x50 /* no info */ -} MonoMarshalNative; - -/* Used only in context of SafeArray */ -typedef enum { - MONO_VARIANT_EMPTY = 0x00, - MONO_VARIANT_NULL = 0x01, - MONO_VARIANT_I2 = 0x02, - MONO_VARIANT_I4 = 0x03, - MONO_VARIANT_R4 = 0x04, - MONO_VARIANT_R8 = 0x05, - MONO_VARIANT_CY = 0x06, - MONO_VARIANT_DATE = 0x07, - MONO_VARIANT_BSTR = 0x08, - MONO_VARIANT_DISPATCH = 0x09, - MONO_VARIANT_ERROR = 0x0a, - MONO_VARIANT_BOOL = 0x0b, - MONO_VARIANT_VARIANT = 0x0c, - MONO_VARIANT_UNKNOWN = 0x0d, - MONO_VARIANT_DECIMAL = 0x0e, - MONO_VARIANT_I1 = 0x10, - MONO_VARIANT_UI1 = 0x11, - MONO_VARIANT_UI2 = 0x12, - MONO_VARIANT_UI4 = 0x13, - MONO_VARIANT_I8 = 0x14, - MONO_VARIANT_UI8 = 0x15, - MONO_VARIANT_INT = 0x16, - MONO_VARIANT_UINT = 0x17, - MONO_VARIANT_VOID = 0x18, - MONO_VARIANT_HRESULT = 0x19, - MONO_VARIANT_PTR = 0x1a, - MONO_VARIANT_SAFEARRAY = 0x1b, - MONO_VARIANT_CARRAY = 0x1c, - MONO_VARIANT_USERDEFINED = 0x1d, - MONO_VARIANT_LPSTR = 0x1e, - MONO_VARIANT_LPWSTR = 0x1f, - MONO_VARIANT_RECORD = 0x24, - MONO_VARIANT_FILETIME = 0x40, - MONO_VARIANT_BLOB = 0x41, - MONO_VARIANT_STREAM = 0x42, - MONO_VARIANT_STORAGE = 0x43, - MONO_VARIANT_STREAMED_OBJECT = 0x44, - MONO_VARIANT_STORED_OBJECT = 0x45, - MONO_VARIANT_BLOB_OBJECT = 0x46, - MONO_VARIANT_CF = 0x47, - MONO_VARIANT_CLSID = 0x48, - MONO_VARIANT_VECTOR = 0x1000, - MONO_VARIANT_ARRAY = 0x2000, - MONO_VARIANT_BYREF = 0x4000 -} MonoMarshalVariant; - -typedef enum { - MONO_MARSHAL_CONV_NONE, - MONO_MARSHAL_CONV_BOOL_VARIANTBOOL, - MONO_MARSHAL_CONV_BOOL_I4, - MONO_MARSHAL_CONV_STR_BSTR, - MONO_MARSHAL_CONV_STR_LPSTR, - MONO_MARSHAL_CONV_LPSTR_STR, - MONO_MARSHAL_CONV_LPTSTR_STR, - MONO_MARSHAL_CONV_STR_LPWSTR, - MONO_MARSHAL_CONV_LPWSTR_STR, - MONO_MARSHAL_CONV_STR_LPTSTR, - MONO_MARSHAL_CONV_STR_ANSIBSTR, - MONO_MARSHAL_CONV_STR_TBSTR, - MONO_MARSHAL_CONV_STR_BYVALSTR, - MONO_MARSHAL_CONV_STR_BYVALWSTR, - MONO_MARSHAL_CONV_SB_LPSTR, - MONO_MARSHAL_CONV_SB_LPTSTR, - MONO_MARSHAL_CONV_SB_LPWSTR, - MONO_MARSHAL_CONV_LPSTR_SB, - MONO_MARSHAL_CONV_LPTSTR_SB, - MONO_MARSHAL_CONV_LPWSTR_SB, - MONO_MARSHAL_CONV_ARRAY_BYVALARRAY, - MONO_MARSHAL_CONV_ARRAY_BYVALCHARARRAY, - MONO_MARSHAL_CONV_ARRAY_SAVEARRAY, - MONO_MARSHAL_CONV_ARRAY_LPARRAY, - MONO_MARSHAL_FREE_LPARRAY, - MONO_MARSHAL_CONV_OBJECT_INTERFACE, - MONO_MARSHAL_CONV_OBJECT_IDISPATCH, - MONO_MARSHAL_CONV_OBJECT_IUNKNOWN, - MONO_MARSHAL_CONV_OBJECT_STRUCT, - MONO_MARSHAL_CONV_DEL_FTN, - MONO_MARSHAL_CONV_FTN_DEL, - MONO_MARSHAL_FREE_ARRAY, - MONO_MARSHAL_CONV_BSTR_STR, - MONO_MARSHAL_CONV_SAFEHANDLE, - MONO_MARSHAL_CONV_HANDLEREF, - MONO_MARSHAL_CONV_STR_UTF8STR, - MONO_MARSHAL_CONV_SB_UTF8STR, - MONO_MARSHAL_CONV_UTF8STR_STR, - MONO_MARSHAL_CONV_UTF8STR_SB, - MONO_MARSHAL_CONV_FIXED_BUFFER, - MONO_MARSHAL_CONV_ANSIBSTR_STR, - MONO_MARSHAL_CONV_TBSTR_STR -} MonoMarshalConv; - -#define MONO_MARSHAL_CONV_INVALID ((MonoMarshalConv)-1) - -typedef struct { - MonoMarshalNative native; - union { - struct { - MonoMarshalNative elem_type; - int32_t num_elem; /* -1 if not set */ - int16_t param_num; /* -1 if not set */ - int16_t elem_mult; /* -1 if not set */ - } array_data; - struct { - char *custom_name; - char *cookie; - MonoImage *image; - } custom_data; - struct { - MonoMarshalVariant elem_type; - int32_t num_elem; - } safearray_data; - } data; -} MonoMarshalSpec; - -MONO_API void mono_metadata_init (void); - -MONO_API void mono_metadata_decode_row (const MonoTableInfo *t, - int idx, - uint32_t *res, - int res_size); - -MONO_API uint32_t mono_metadata_decode_row_col (const MonoTableInfo *t, - int idx, - unsigned int col); - -/* - * This macro is used to extract the size of the table encoded in - * the size_bitfield of MonoTableInfo. - */ -#define mono_metadata_table_size(bitfield,table) ((((bitfield) >> ((table)*2)) & 0x3) + 1) -#define mono_metadata_table_count(bitfield) ((bitfield) >> 24) - -MONO_API int mono_metadata_compute_size (MonoImage *meta, - int tableindex, - uint32_t *result_bitfield); - -/* - * - */ -MONO_API const char *mono_metadata_locate (MonoImage *meta, int table, int idx); -MONO_API const char *mono_metadata_locate_token (MonoImage *meta, uint32_t token); - -MONO_API const char *mono_metadata_string_heap (MonoImage *meta, uint32_t table_index); -MONO_API const char *mono_metadata_blob_heap (MonoImage *meta, uint32_t table_index); -MONO_API const char *mono_metadata_user_string (MonoImage *meta, uint32_t table_index); -MONO_API const char *mono_metadata_guid_heap (MonoImage *meta, uint32_t table_index); - -MONO_API uint32_t mono_metadata_typedef_from_field (MonoImage *meta, uint32_t table_index); -MONO_API uint32_t mono_metadata_typedef_from_method (MonoImage *meta, uint32_t table_index); -MONO_API uint32_t mono_metadata_nested_in_typedef (MonoImage *meta, uint32_t table_index); -MONO_API uint32_t mono_metadata_nesting_typedef (MonoImage *meta, uint32_t table_index, uint32_t start_index); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoClass** mono_metadata_interfaces_from_typedef (MonoImage *meta, uint32_t table_index, unsigned int *count); - -MONO_API uint32_t mono_metadata_events_from_typedef (MonoImage *meta, uint32_t table_index, unsigned int *end_idx); -MONO_API uint32_t mono_metadata_methods_from_event (MonoImage *meta, uint32_t table_index, unsigned int *end); -MONO_API uint32_t mono_metadata_properties_from_typedef (MonoImage *meta, uint32_t table_index, unsigned int *end); -MONO_API uint32_t mono_metadata_methods_from_property (MonoImage *meta, uint32_t table_index, unsigned int *end); -MONO_API uint32_t mono_metadata_packing_from_typedef (MonoImage *meta, uint32_t table_index, uint32_t *packing, uint32_t *size); -MONO_API const char* mono_metadata_get_marshal_info (MonoImage *meta, uint32_t idx, mono_bool is_field); -MONO_API uint32_t mono_metadata_custom_attrs_from_index (MonoImage *meta, uint32_t cattr_index); - -MONO_API MonoMarshalSpec *mono_metadata_parse_marshal_spec (MonoImage *image, const char *ptr); - -MONO_API void mono_metadata_free_marshal_spec (MonoMarshalSpec *spec); - -MONO_API uint32_t mono_metadata_implmap_from_method (MonoImage *meta, uint32_t method_idx); - -MONO_API void mono_metadata_field_info (MonoImage *meta, - uint32_t table_index, - uint32_t *offset, - uint32_t *rva, - MonoMarshalSpec **marshal_spec); - -MONO_API uint32_t mono_metadata_get_constant_index (MonoImage *meta, uint32_t token, uint32_t hint); - -/* - * Functions to extract information from the Blobs - */ -MONO_API uint32_t mono_metadata_decode_value (const char *ptr, - const char **rptr); -MONO_API int32_t mono_metadata_decode_signed_value (const char *ptr, const char **rptr); - -MONO_API uint32_t mono_metadata_decode_blob_size (const char *ptr, - const char **rptr); - -MONO_API void mono_metadata_encode_value (uint32_t value, char *bug, char **endbuf); - -#define MONO_OFFSET_IN_CLAUSE(clause,offset) \ - ((clause)->try_offset <= (offset) && (offset) < ((clause)->try_offset + (clause)->try_len)) -#define MONO_OFFSET_IN_HANDLER(clause,offset) \ - ((clause)->handler_offset <= (offset) && (offset) < ((clause)->handler_offset + (clause)->handler_len)) -#define MONO_OFFSET_IN_FILTER(clause,offset) \ - ((clause)->flags == MONO_EXCEPTION_CLAUSE_FILTER && (clause)->data.filter_offset <= (offset) && (offset) < ((clause)->handler_offset)) - -typedef struct { - uint32_t flags; - uint32_t try_offset; - uint32_t try_len; - uint32_t handler_offset; - uint32_t handler_len; - union { - uint32_t filter_offset; - MonoClass *catch_class; - } data; -} MonoExceptionClause; - -typedef struct _MonoType MonoType; -typedef struct _MonoGenericInst MonoGenericInst; -typedef struct _MonoGenericClass MonoGenericClass; -typedef struct _MonoGenericContext MonoGenericContext; -typedef struct _MonoGenericContainer MonoGenericContainer; -typedef struct _MonoGenericParam MonoGenericParam; -typedef struct _MonoArrayType MonoArrayType; -typedef struct _MonoMethodSignature MonoMethodSignature; - -/* FIXME: Keeping this name alive for now, since it is part of the exposed API, even though no entrypoint uses it. */ -typedef struct invalid_name MonoGenericMethod; - -typedef struct { - unsigned int required : 1; - unsigned int token : 31; -} MonoCustomMod; - -typedef struct _MonoCustomModContainer { - uint8_t count; /* max 64 modifiers follow at the end */ - MonoImage *image; /* Image containing types in modifiers array */ - MonoCustomMod modifiers [1]; /* Actual length is count */ -} MonoCustomModContainer; - -struct _MonoArrayType { - MonoClass *eklass; - // Number of dimensions of the array - uint8_t rank; - - // Arrays recording known upper and lower index bounds for each dimension - uint8_t numsizes; - uint8_t numlobounds; - int *sizes; - int *lobounds; -}; - -typedef struct _MonoMethodHeader MonoMethodHeader; - -typedef enum { - MONO_PARSE_TYPE, - MONO_PARSE_MOD_TYPE, - MONO_PARSE_LOCAL, - MONO_PARSE_PARAM, - MONO_PARSE_RET, - MONO_PARSE_FIELD -} MonoParseTypeMode; - -MONO_API MONO_RT_EXTERNAL_ONLY mono_bool -mono_type_is_byref (MonoType *type); - -MONO_API MONO_RT_EXTERNAL_ONLY int -mono_type_get_type (MonoType *type); - -/* For MONO_TYPE_FNPTR */ -MONO_API MONO_RT_EXTERNAL_ONLY MonoMethodSignature* -mono_type_get_signature (MonoType *type); - -/* For MONO_TYPE_CLASS, VALUETYPE */ -MONO_API MONO_RT_EXTERNAL_ONLY MonoClass* -mono_type_get_class (MonoType *type); - -MONO_API MonoArrayType* -mono_type_get_array_type (MonoType *type); - -/* For MONO_TYPE_PTR */ -MONO_API MonoType* -mono_type_get_ptr_type (MonoType *type); - -MONO_API MonoClass* -mono_type_get_modifiers (MonoType *type, mono_bool *is_required, void **iter); - -MONO_API mono_bool mono_type_is_struct (MonoType *type); -MONO_API mono_bool mono_type_is_void (MonoType *type); -MONO_API mono_bool mono_type_is_pointer (MonoType *type); -MONO_API mono_bool mono_type_is_reference (MonoType *type); -MONO_API mono_bool mono_type_is_generic_parameter (MonoType *type); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoType* -mono_signature_get_return_type (MonoMethodSignature *sig); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoType* -mono_signature_get_params (MonoMethodSignature *sig, void **iter); - -MONO_API uint32_t -mono_signature_get_param_count (MonoMethodSignature *sig); - -MONO_API uint32_t -mono_signature_get_call_conv (MonoMethodSignature *sig); - -MONO_API int -mono_signature_vararg_start (MonoMethodSignature *sig); - -MONO_API mono_bool -mono_signature_is_instance (MonoMethodSignature *sig); - -MONO_API mono_bool -mono_signature_explicit_this (MonoMethodSignature *sig); - -MONO_API mono_bool -mono_signature_param_is_out (MonoMethodSignature *sig, int param_num); - -MONO_API uint32_t mono_metadata_parse_typedef_or_ref (MonoImage *m, - const char *ptr, - const char **rptr); -MONO_API int mono_metadata_parse_custom_mod (MonoImage *m, - MonoCustomMod *dest, - const char *ptr, - const char **rptr); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoArrayType *mono_metadata_parse_array (MonoImage *m, - const char *ptr, - const char **rptr); -MONO_API void mono_metadata_free_array (MonoArrayType *array); -MONO_API MONO_RT_EXTERNAL_ONLY MonoType *mono_metadata_parse_type (MonoImage *m, - MonoParseTypeMode mode, - short opt_attrs, - const char *ptr, - const char **rptr); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoType *mono_metadata_parse_param (MonoImage *m, - const char *ptr, - const char **rptr); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoType *mono_metadata_parse_field_type (MonoImage *m, - short field_flags, - const char *ptr, - const char **rptr); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoType *mono_type_create_from_typespec (MonoImage *image, - uint32_t type_spec); -MONO_API void mono_metadata_free_type (MonoType *type); -MONO_API int mono_type_size (MonoType *type, - int *alignment); -MONO_API int mono_type_stack_size (MonoType *type, - int *alignment); - -MONO_API mono_bool mono_type_generic_inst_is_valuetype (MonoType *type); -MONO_API mono_bool mono_metadata_generic_class_is_valuetype (MonoGenericClass *gclass); - -MONO_API unsigned int mono_metadata_type_hash (MonoType *t1); -MONO_API mono_bool mono_metadata_type_equal (MonoType *t1, MonoType *t2); - -MONO_API MonoMethodSignature *mono_metadata_signature_alloc (MonoImage *image, uint32_t nparams); - -MONO_API MonoMethodSignature *mono_metadata_signature_dup (MonoMethodSignature *sig); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoMethodSignature *mono_metadata_parse_signature (MonoImage *image, - uint32_t token); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoMethodSignature *mono_metadata_parse_method_signature (MonoImage *m, - int def, - const char *ptr, - const char **rptr); -MONO_API void mono_metadata_free_method_signature (MonoMethodSignature *method); - -MONO_API mono_bool mono_metadata_signature_equal (MonoMethodSignature *sig1, - MonoMethodSignature *sig2); - -MONO_API unsigned int mono_signature_hash (MonoMethodSignature *sig); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoMethodHeader *mono_metadata_parse_mh (MonoImage *m, const char *ptr); -MONO_API void mono_metadata_free_mh (MonoMethodHeader *mh); - -/* MonoMethodHeader accessors */ -MONO_API const unsigned char* -mono_method_header_get_code (MonoMethodHeader *header, uint32_t* code_size, uint32_t* max_stack); - -MONO_API MonoType** -mono_method_header_get_locals (MonoMethodHeader *header, uint32_t* num_locals, mono_bool *init_locals); - -MONO_API int -mono_method_header_get_num_clauses (MonoMethodHeader *header); - -MONO_API int -mono_method_header_get_clauses (MonoMethodHeader *header, MonoMethod *method, void **iter, MonoExceptionClause *clause); - -MONO_API uint32_t -mono_type_to_unmanaged (MonoType *type, MonoMarshalSpec *mspec, - mono_bool as_field, mono_bool unicode, MonoMarshalConv *conv); - -/* - * Makes a token based on a table and an index - */ -#define mono_metadata_make_token(table,idx) (((table) << 24)| (idx)) - -/* - * Returns the table index that this token encodes. - */ -#define mono_metadata_token_table(token) ((token) >> 24) - - /* - * Returns the index that a token refers to - */ -#define mono_metadata_token_index(token) ((token) & 0xffffff) - - -#define mono_metadata_token_code(token) ((token) & 0xff000000) - -MONO_API uint32_t mono_metadata_token_from_dor (uint32_t dor_index); - -MONO_API char *mono_guid_to_string (const uint8_t *guid); - -MONO_API char *mono_guid_to_string_minimal (const uint8_t *guid); - -MONO_API uint32_t mono_metadata_declsec_from_index (MonoImage *meta, uint32_t idx); - -MONO_API uint32_t mono_metadata_translate_token_index (MonoImage *image, int table, uint32_t idx); - -MONO_API void mono_metadata_decode_table_row (MonoImage *image, int table, - int idx, - uint32_t *res, - int res_size); - -MONO_API uint32_t mono_metadata_decode_table_row_col (MonoImage *image, int table, - int idx, - unsigned int col); - -MONO_END_DECLS - -#endif /* __MONO_METADATA_H__ */ diff --git a/src/mono/msvc/include/mono/metadata/mono-config.h b/src/mono/msvc/include/mono/metadata/mono-config.h deleted file mode 100644 index 91cdccd38e39d..0000000000000 --- a/src/mono/msvc/include/mono/metadata/mono-config.h +++ /dev/null @@ -1,38 +0,0 @@ -/** - * \file - * - * Author: Paolo Molaro (lupus@ximian.com) - * - * (C) 2002 Ximian, Inc. - */ -#ifndef __MONO_METADATA_CONFIG_H__ -#define __MONO_METADATA_CONFIG_H__ - -#include -#include - -MONO_BEGIN_DECLS - -MONO_API const char *mono_config_get_os (void); -MONO_API const char *mono_config_get_cpu (void); -MONO_API const char *mono_config_get_wordsize (void); - -MONO_API const char* mono_get_config_dir (void); -MONO_API void mono_set_config_dir (const char *dir); - -MONO_API const char* mono_get_machine_config (void); - -MONO_API void mono_config_cleanup (void); -MONO_API void mono_config_parse (const char *filename); -MONO_API MONO_RT_EXTERNAL_ONLY void mono_config_for_assembly (MonoImage *assembly); -MONO_API void mono_config_parse_memory (const char *buffer); - -MONO_API const char* mono_config_string_for_assembly_file (const char *filename); - -MONO_API void mono_config_set_server_mode (mono_bool server_mode); -MONO_API mono_bool mono_config_is_server_mode (void); - -MONO_END_DECLS - -#endif /* __MONO_METADATA_CONFIG_H__ */ - diff --git a/src/mono/msvc/include/mono/metadata/mono-debug.h b/src/mono/msvc/include/mono/metadata/mono-debug.h deleted file mode 100644 index c165db731154e..0000000000000 --- a/src/mono/msvc/include/mono/metadata/mono-debug.h +++ /dev/null @@ -1,231 +0,0 @@ -/** - * \file - * This header is only installed for use by the debugger: - * the structures and the API declared here are not supported. - */ - -#ifndef __MONO_DEBUG_H__ -#define __MONO_DEBUG_H__ - -#include -#include -#include - -MONO_BEGIN_DECLS - -typedef struct _MonoSymbolTable MonoSymbolTable; -typedef struct _MonoDebugDataTable MonoDebugDataTable; - -typedef struct _MonoSymbolFile MonoSymbolFile; -typedef struct _MonoPPDBFile MonoPPDBFile; - -typedef struct _MonoDebugHandle MonoDebugHandle; - -typedef struct _MonoDebugLineNumberEntry MonoDebugLineNumberEntry; - -typedef struct _MonoDebugVarInfo MonoDebugVarInfo; -typedef struct _MonoDebugMethodJitInfo MonoDebugMethodJitInfo; -typedef struct _MonoDebugMethodAddress MonoDebugMethodAddress; -typedef struct _MonoDebugMethodAddressList MonoDebugMethodAddressList; -typedef struct _MonoDebugClassEntry MonoDebugClassEntry; - -typedef struct _MonoDebugMethodInfo MonoDebugMethodInfo; -typedef struct _MonoDebugLocalsInfo MonoDebugLocalsInfo; -typedef struct _MonoDebugMethodAsyncInfo MonoDebugMethodAsyncInfo; -typedef struct _MonoDebugSourceLocation MonoDebugSourceLocation; - -typedef struct _MonoDebugList MonoDebugList; - -typedef enum { - MONO_DEBUG_FORMAT_NONE, - MONO_DEBUG_FORMAT_MONO, - /* Deprecated, the mdb debugger is not longer supported. */ - MONO_DEBUG_FORMAT_DEBUGGER -} MonoDebugFormat; - -/* - * NOTE: - * We intentionally do not use GList here since the debugger needs to know about - * the layout of the fields. -*/ -struct _MonoDebugList { - MonoDebugList *next; - const void* data; -}; - -struct _MonoSymbolTable { - uint64_t magic; - uint32_t version; - uint32_t total_size; - - /* - * Corlib and metadata info. - */ - MonoDebugHandle *corlib; - MonoDebugDataTable *global_data_table; - MonoDebugList *data_tables; - - /* - * The symbol files. - */ - MonoDebugList *symbol_files; -}; - -struct _MonoDebugHandle { - uint32_t index; - char *image_file; - MonoImage *image; - MonoDebugDataTable *type_table; - MonoSymbolFile *symfile; - MonoPPDBFile *ppdb; -}; - -struct _MonoDebugMethodJitInfo { - const mono_byte *code_start; - uint32_t code_size; - uint32_t prologue_end; - uint32_t epilogue_begin; - const mono_byte *wrapper_addr; - uint32_t num_line_numbers; - MonoDebugLineNumberEntry *line_numbers; - uint32_t has_var_info; - uint32_t num_params; - MonoDebugVarInfo *this_var; - MonoDebugVarInfo *params; - uint32_t num_locals; - MonoDebugVarInfo *locals; - MonoDebugVarInfo *gsharedvt_info_var; - MonoDebugVarInfo *gsharedvt_locals_var; -}; - -struct _MonoDebugMethodAddressList { - uint32_t size; - uint32_t count; - mono_byte data [MONO_ZERO_LEN_ARRAY]; -}; - -struct _MonoDebugSourceLocation { - char *source_file; - uint32_t row, column; - uint32_t il_offset; -}; - -MONO_API mono_bool mono_debug_enabled (void); - -/* - * These bits of the MonoDebugLocalInfo's "index" field are flags specifying - * where the variable is actually stored. - * - * See relocate_variable() in debug-symfile.c for more info. - */ -#define MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS 0xf0000000 - -/* The variable is in register "index". */ -#define MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER 0 - -/* The variable is at offset "offset" from register "index". */ -#define MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET 0x10000000 - -/* The variable is in the two registers "offset" and "index". */ -#define MONO_DEBUG_VAR_ADDRESS_MODE_TWO_REGISTERS 0x20000000 - -/* The variable is dead. */ -#define MONO_DEBUG_VAR_ADDRESS_MODE_DEAD 0x30000000 - -/* Same as REGOFFSET, but do an indirection */ -#define MONO_DEBUG_VAR_ADDRESS_MODE_REGOFFSET_INDIR 0x40000000 - -/* gsharedvt local */ -#define MONO_DEBUG_VAR_ADDRESS_MODE_GSHAREDVT_LOCAL 0x50000000 - -/* variable is a vt address */ -#define MONO_DEBUG_VAR_ADDRESS_MODE_VTADDR 0x60000000 - -struct _MonoDebugVarInfo { - uint32_t index; - uint32_t offset; - uint32_t size; - uint32_t begin_scope; - uint32_t end_scope; - MonoType *type; -}; - -#define MONO_DEBUGGER_MAJOR_VERSION 81 -#define MONO_DEBUGGER_MINOR_VERSION 6 -#define MONO_DEBUGGER_MAGIC 0x7aff65af4253d427ULL - -MONO_API void mono_debug_init (MonoDebugFormat format); -MONO_API void mono_debug_open_image_from_memory (MonoImage *image, const mono_byte *raw_contents, int size); -MONO_API void mono_debug_cleanup (void); - -MONO_API void mono_debug_close_image (MonoImage *image); - -MONO_API void mono_debug_domain_unload (MonoDomain *domain); -MONO_API void mono_debug_domain_create (MonoDomain *domain); - -MONO_API MonoDebugMethodAddress * -mono_debug_add_method (MonoMethod *method, MonoDebugMethodJitInfo *jit, MonoDomain *domain); - -MONO_API void -mono_debug_remove_method (MonoMethod *method, MonoDomain *domain); - -MONO_API MonoDebugMethodInfo * -mono_debug_lookup_method (MonoMethod *method); - -MONO_API MonoDebugMethodAddressList * -mono_debug_lookup_method_addresses (MonoMethod *method); - -MONO_API MonoDebugMethodJitInfo* -mono_debug_find_method (MonoMethod *method, MonoDomain *domain); - -MONO_API MonoDebugHandle * -mono_debug_get_handle (MonoImage *image); - -MONO_API void -mono_debug_free_method_jit_info (MonoDebugMethodJitInfo *jit); - - -MONO_API void -mono_debug_add_delegate_trampoline (void* code, int size); - -MONO_API MonoDebugLocalsInfo* -mono_debug_lookup_locals (MonoMethod *method); - -MonoDebugMethodAsyncInfo* -mono_debug_lookup_method_async_debug_info (MonoMethod *method); - -MONO_API -MonoDebugSourceLocation * -mono_debug_method_lookup_location (MonoDebugMethodInfo *minfo, int il_offset); - -/* - * Line number support. - */ - -MONO_API MonoDebugSourceLocation * -mono_debug_lookup_source_location (MonoMethod *method, uint32_t address, MonoDomain *domain); - -MONO_API int32_t -mono_debug_il_offset_from_address (MonoMethod *method, MonoDomain *domain, uint32_t native_offset); - -MONO_API void -mono_debug_free_source_location (MonoDebugSourceLocation *location); - -MONO_API char * -mono_debug_print_stack_frame (MonoMethod *method, uint32_t native_offset, MonoDomain *domain); - -/* - * Mono Debugger support functions - * - * These methods are used by the JIT while running inside the Mono Debugger. - */ - -MONO_API int mono_debugger_method_has_breakpoint (MonoMethod *method); -MONO_API int mono_debugger_insert_breakpoint (const char *method_name, mono_bool include_namespace); - -MONO_API void mono_set_is_debugger_attached (mono_bool attached); -MONO_API mono_bool mono_is_debugger_attached (void); - -MONO_END_DECLS - -#endif /* __MONO_DEBUG_H__ */ diff --git a/src/mono/msvc/include/mono/metadata/mono-gc.h b/src/mono/msvc/include/mono/metadata/mono-gc.h deleted file mode 100644 index 7d072a8108e95..0000000000000 --- a/src/mono/msvc/include/mono/metadata/mono-gc.h +++ /dev/null @@ -1,138 +0,0 @@ -/** - * \file - * GC related public interface - * - */ -#ifndef __METADATA_MONO_GC_H__ -#define __METADATA_MONO_GC_H__ - -#include - -MONO_BEGIN_DECLS - -typedef int (*MonoGCReferences) (MonoObject *obj, MonoClass *klass, uintptr_t size, uintptr_t num, MonoObject **refs, uintptr_t *offsets, void *data); - -/** - * This enum is used by the profiler API when reporting root registration. - */ -typedef enum { - /** - * Roots external to Mono. Embedders may only use this value. - */ - MONO_ROOT_SOURCE_EXTERNAL = 0, - /** - * Thread call stack. - * - * The \c key parameter is a thread ID as a \c uintptr_t. - */ - MONO_ROOT_SOURCE_STACK = 1, - /** - * Roots in the finalizer queue. This is a pseudo-root. - */ - MONO_ROOT_SOURCE_FINALIZER_QUEUE = 2, - /** - * Managed \c static variables. - * - * The \c key parameter is a \c MonoVTable pointer. - */ - MONO_ROOT_SOURCE_STATIC = 3, - /** - * Managed \c static variables with \c ThreadStaticAttribute. - * - * The \c key parameter is a thread ID as a \c uintptr_t. - */ - MONO_ROOT_SOURCE_THREAD_STATIC = 4, - /** - * Managed \c static variables with \c ContextStaticAttribute. - * - * The \c key parameter is a \c MonoAppContext pointer. - */ - MONO_ROOT_SOURCE_CONTEXT_STATIC = 5, - /** - * \c GCHandle structures. - */ - MONO_ROOT_SOURCE_GC_HANDLE = 6, - /** - * Roots in the just-in-time compiler. - */ - MONO_ROOT_SOURCE_JIT = 7, - /** - * Roots in the threading subsystem. - * - * The \c key parameter, if not \c NULL, is a thread ID as a \c uintptr_t. - */ - MONO_ROOT_SOURCE_THREADING = 8, - /** - * Roots in application domains. - * - * The \c key parameter, if not \c NULL, is a \c MonoDomain pointer. - */ - MONO_ROOT_SOURCE_DOMAIN = 9, - /** - * Roots in reflection code. - * - * The \c key parameter, if not \c NULL, is a \c MonoVTable pointer. - */ - MONO_ROOT_SOURCE_REFLECTION = 10, - /** - * Roots from P/Invoke or other marshaling infrastructure. - */ - MONO_ROOT_SOURCE_MARSHAL = 11, - /** - * Roots in the thread pool data structures. - */ - MONO_ROOT_SOURCE_THREAD_POOL = 12, - /** - * Roots in the debugger agent. - */ - MONO_ROOT_SOURCE_DEBUGGER = 13, - /** - * Roots in the runtime handle stack. This is a pseudo-root. - * - * The \c key parameter is a thread ID as a \c uintptr_t. - */ - MONO_ROOT_SOURCE_HANDLE = 14, - /** - * Roots in the ephemeron arrays. This is a pseudo-root. - */ - MONO_ROOT_SOURCE_EPHEMERON = 15, - /** - * Roots in the toggleref arrays. This is a pseudo-root. - */ - MONO_ROOT_SOURCE_TOGGLEREF = 16, -} MonoGCRootSource; - -typedef enum { - MONO_GC_HANDLE_TYPE_MIN = 0, - MONO_GC_HANDLE_WEAK = MONO_GC_HANDLE_TYPE_MIN, - MONO_GC_HANDLE_WEAK_TRACK_RESURRECTION, - MONO_GC_HANDLE_NORMAL, - MONO_GC_HANDLE_PINNED, - MONO_GC_HANDLE_TYPE_MAX, -} MonoGCHandleType; - -MONO_API void mono_gc_collect (int generation); -MONO_API int mono_gc_max_generation (void); -MONO_API int mono_gc_get_generation (MonoObject *object); -MONO_API int mono_gc_collection_count (int generation); -MONO_API int64_t mono_gc_get_used_size (void); -MONO_API int64_t mono_gc_get_heap_size (void); -MONO_API MonoBoolean mono_gc_pending_finalizers (void); -MONO_API void mono_gc_finalize_notify (void); -MONO_API int mono_gc_invoke_finalizers (void); -/* heap walking is only valid in the pre-stop-world event callback */ -MONO_API int mono_gc_walk_heap (int flags, MonoGCReferences callback, void *data); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_gc_init_finalizer_thread (void); - -/* - * Only supported under SGen. These two with Sgen will take and release the LOCK_GC - */ -void mono_gc_stop_world (void); -void mono_gc_restart_world (void); - -MONO_END_DECLS - -#endif /* __METADATA_MONO_GC_H__ */ - diff --git a/src/mono/msvc/include/mono/metadata/mono-private-unstable.h b/src/mono/msvc/include/mono/metadata/mono-private-unstable.h deleted file mode 100644 index 7b214bf70adbf..0000000000000 --- a/src/mono/msvc/include/mono/metadata/mono-private-unstable.h +++ /dev/null @@ -1,41 +0,0 @@ -/** - * \file - * - * Private unstable APIs. - * - * WARNING: The declarations and behavior of functions in this header are NOT STABLE and can be modified or removed at - * any time. - * - */ - - -#ifndef __MONO_METADATA_MONO_PRIVATE_UNSTABLE_H__ -#define __MONO_METADATA_MONO_PRIVATE_UNSTABLE_H__ - -#include - -typedef MonoGCHandle MonoAssemblyLoadContextGCHandle; - -MONO_API MONO_RT_EXTERNAL_ONLY MonoAssembly * -mono_assembly_load_full_alc (MonoAssemblyLoadContextGCHandle alc_gchandle, MonoAssemblyName *aname, const char *basedir, MonoImageOpenStatus *status); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoImage * -mono_image_open_from_data_alc (MonoAssemblyLoadContextGCHandle alc_gchandle, char *data, uint32_t data_len, mono_bool need_copy, MonoImageOpenStatus *status, const char *name); - -typedef MonoAssembly * (*MonoAssemblyPreLoadFuncV3) (MonoAssemblyLoadContextGCHandle alc_gchandle, MonoAssemblyName *aname, char **assemblies_path, void *user_data, MonoError *error); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_install_assembly_preload_hook_v3 (MonoAssemblyPreLoadFuncV3 func, void *user_data, mono_bool append); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoAssemblyLoadContextGCHandle -mono_alc_get_default_gchandle (void); - -typedef struct _MonoBundledSatelliteAssembly MonoBundledSatelliteAssembly; - -MONO_API void -mono_register_bundled_satellite_assemblies (const MonoBundledSatelliteAssembly **assemblies); - -MONO_API MonoBundledSatelliteAssembly * -mono_create_new_bundled_satellite_assembly (const char *name, const char *culture, const unsigned char *data, unsigned int size); - -#endif /*__MONO_METADATA_MONO_PRIVATE_UNSTABLE_H__*/ diff --git a/src/mono/msvc/include/mono/metadata/object-forward.h b/src/mono/msvc/include/mono/metadata/object-forward.h deleted file mode 100644 index 010dc8b0f76e4..0000000000000 --- a/src/mono/msvc/include/mono/metadata/object-forward.h +++ /dev/null @@ -1,22 +0,0 @@ -/** - * \file - * - * Forward declarations of opaque types, and typedefs thereof. - * - */ - -#ifndef __MONO_OBJECT_FORWARD_H__ -#define __MONO_OBJECT_FORWARD_H__ - -#include - -typedef struct _MonoClass MonoClass; -typedef struct _MonoImage MonoImage; -typedef struct _MonoMethod MonoMethod; - -typedef struct _MonoObject MONO_RT_MANAGED_ATTR MonoObject; -typedef struct _MonoException MONO_RT_MANAGED_ATTR MonoException; -typedef struct _MonoReflectionAssembly MONO_RT_MANAGED_ATTR MonoReflectionAssembly; -typedef struct _MonoReflectionTypeBuilder MONO_RT_MANAGED_ATTR MonoReflectionTypeBuilder; - -#endif /* __MONO_OBJECT_FORWARD_H__ */ diff --git a/src/mono/msvc/include/mono/metadata/object.h b/src/mono/msvc/include/mono/metadata/object.h deleted file mode 100644 index f421c6c1a33be..0000000000000 --- a/src/mono/msvc/include/mono/metadata/object.h +++ /dev/null @@ -1,408 +0,0 @@ -/** - * \file - */ - -#ifndef _MONO_CLI_OBJECT_H_ -#define _MONO_CLI_OBJECT_H_ - -#include -#include -#include -#include - -MONO_BEGIN_DECLS - -typedef struct _MonoString MONO_RT_MANAGED_ATTR MonoString; -typedef struct _MonoArray MONO_RT_MANAGED_ATTR MonoArray; -typedef struct _MonoReflectionMethod MONO_RT_MANAGED_ATTR MonoReflectionMethod; -typedef struct _MonoReflectionModule MONO_RT_MANAGED_ATTR MonoReflectionModule; -typedef struct _MonoReflectionField MONO_RT_MANAGED_ATTR MonoReflectionField; -typedef struct _MonoReflectionProperty MONO_RT_MANAGED_ATTR MonoReflectionProperty; -typedef struct _MonoReflectionEvent MONO_RT_MANAGED_ATTR MonoReflectionEvent; -typedef struct _MonoReflectionType MONO_RT_MANAGED_ATTR MonoReflectionType; -typedef struct _MonoDelegate MONO_RT_MANAGED_ATTR MonoDelegate; -typedef struct _MonoThreadsSync MonoThreadsSync; -#ifdef ENABLE_NETCORE -typedef struct _MonoInternalThread MONO_RT_MANAGED_ATTR MonoThread; -#else -typedef struct _MonoThread MONO_RT_MANAGED_ATTR MonoThread; -#endif -typedef struct _MonoDynamicAssembly MonoDynamicAssembly; -typedef struct _MonoDynamicImage MonoDynamicImage; -typedef struct _MonoReflectionMethodBody MONO_RT_MANAGED_ATTR MonoReflectionMethodBody; -typedef struct _MonoAppContext MONO_RT_MANAGED_ATTR MonoAppContext; - -struct _MonoObject { - MonoVTable *vtable; - MonoThreadsSync *synchronisation; -}; - -typedef MonoObject* (*MonoInvokeFunc) (MonoMethod *method, void *obj, void **params, MonoObject **exc, MonoError *error); -typedef void* (*MonoCompileFunc) (MonoMethod *method); -typedef void (*MonoMainThreadFunc) (void* user_data); - -#define MONO_OBJECT_SETREF(obj,fieldname,value) do { \ - mono_gc_wbarrier_set_field ((MonoObject*)(obj), &((obj)->fieldname), (MonoObject*)value); \ - /*(obj)->fieldname = (value);*/ \ - } while (0) - -/* This should be used if 's' can reside on the heap */ -#define MONO_STRUCT_SETREF(s,field,value) do { \ - mono_gc_wbarrier_generic_store (&((s)->field), (MonoObject*)(value)); \ - } while (0) - -#define mono_array_addr(array,type,index) ((type*)mono_array_addr_with_size ((array), sizeof (type), (index))) -#define mono_array_get(array,type,index) ( *(type*)mono_array_addr ((array), type, (index)) ) -#define mono_array_set(array,type,index,value) \ - do { \ - type *__p = (type *) mono_array_addr ((array), type, (index)); \ - *__p = (value); \ - } while (0) -#define mono_array_setref(array,index,value) \ - do { \ - void **__p = (void **) mono_array_addr ((array), void*, (index)); \ - mono_gc_wbarrier_set_arrayref ((array), __p, (MonoObject*)(value)); \ - /* *__p = (value);*/ \ - } while (0) -#define mono_array_memcpy_refs(dest,destidx,src,srcidx,count) \ - do { \ - void **__p = (void **) mono_array_addr ((dest), void*, (destidx)); \ - void **__s = mono_array_addr ((src), void*, (srcidx)); \ - mono_gc_wbarrier_arrayref_copy (__p, __s, (count)); \ - } while (0) - -MONO_API MONO_RT_EXTERNAL_ONLY mono_unichar2 *mono_string_chars (MonoString *s); -MONO_API MONO_RT_EXTERNAL_ONLY int mono_string_length (MonoString *s); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * -mono_object_new (MonoDomain *domain, MonoClass *klass); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoObject * -mono_object_new_specific (MonoVTable *vtable); - -/* can be used for classes without finalizer in non-profiling mode */ -MONO_API MONO_RT_EXTERNAL_ONLY -MonoObject * -mono_object_new_fast (MonoVTable *vtable); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoObject * -mono_object_new_alloc_specific (MonoVTable *vtable); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoObject * -mono_object_new_from_token (MonoDomain *domain, MonoImage *image, uint32_t token); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoArray* -mono_array_new (MonoDomain *domain, MonoClass *eclass, uintptr_t n); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoArray* -mono_array_new_full (MonoDomain *domain, MonoClass *array_class, - uintptr_t *lengths, intptr_t *lower_bounds); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoArray * -mono_array_new_specific (MonoVTable *vtable, uintptr_t n); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoArray* -mono_array_clone (MonoArray *array); - -MONO_API MONO_RT_EXTERNAL_ONLY char* -mono_array_addr_with_size (MonoArray *array, int size, uintptr_t idx); - -MONO_API MONO_RT_EXTERNAL_ONLY uintptr_t -mono_array_length (MonoArray *array); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoString* -mono_string_empty (MonoDomain *domain); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoString* -mono_string_empty_wrapper (void); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoString* -mono_string_new_utf16 (MonoDomain *domain, const mono_unichar2 *text, int32_t len); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoString* -mono_string_new_size (MonoDomain *domain, int32_t len); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoString* -mono_ldstr (MonoDomain *domain, MonoImage *image, uint32_t str_index); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoString* -mono_string_is_interned (MonoString *str); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoString* -mono_string_intern (MonoString *str); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoString* -mono_string_new (MonoDomain *domain, const char *text); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoString* -mono_string_new_wrapper (const char *text); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoString* -mono_string_new_len (MonoDomain *domain, const char *text, unsigned int length); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoString* -mono_string_new_utf32 (MonoDomain *domain, const mono_unichar4 *text, int32_t len); - -MONO_API MONO_RT_EXTERNAL_ONLY -char * -mono_string_to_utf8 (MonoString *string_obj); - -MONO_API MONO_RT_EXTERNAL_ONLY char * -mono_string_to_utf8_checked (MonoString *string_obj, MonoError *error); - -MONO_API MONO_RT_EXTERNAL_ONLY mono_unichar2 * -mono_string_to_utf16 (MonoString *string_obj); - -MONO_API MONO_RT_EXTERNAL_ONLY mono_unichar4 * -mono_string_to_utf32 (MonoString *string_obj); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoString * -mono_string_from_utf16 (/*const*/ mono_unichar2 *data); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoString * -mono_string_from_utf32 (/*const*/ mono_unichar4 *data); - -MONO_API MONO_RT_EXTERNAL_ONLY mono_bool -mono_string_equal (MonoString *s1, MonoString *s2); - -MONO_API MONO_RT_EXTERNAL_ONLY unsigned int -mono_string_hash (MonoString *s); - -MONO_API MONO_RT_EXTERNAL_ONLY int -mono_object_hash (MonoObject* obj); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoString * -mono_object_to_string (MonoObject *obj, MonoObject **exc); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * -mono_value_box (MonoDomain *domain, MonoClass *klass, void* val); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_value_copy (void* dest, /*const*/ void* src, MonoClass *klass); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_value_copy_array (MonoArray *dest, int dest_idx, void* src, int count); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoVTable* -mono_object_get_vtable (MonoObject *obj); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoDomain* -mono_object_get_domain (MonoObject *obj); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoClass* -mono_object_get_class (MonoObject *obj); - -MONO_API MONO_RT_EXTERNAL_ONLY void* -mono_object_unbox (MonoObject *obj); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * -mono_object_clone (MonoObject *obj); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * -mono_object_isinst (MonoObject *obj, MonoClass *klass); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * -mono_object_isinst_mbyref (MonoObject *obj, MonoClass *klass); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * -mono_object_castclass_mbyref (MonoObject *obj, MonoClass *klass); - -MONO_API MONO_RT_EXTERNAL_ONLY mono_bool -mono_monitor_try_enter (MonoObject *obj, uint32_t ms); - -MONO_API MONO_RT_EXTERNAL_ONLY mono_bool -mono_monitor_enter (MonoObject *obj); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_monitor_enter_v4 (MonoObject *obj, char *lock_taken); - -MONO_API MONO_RT_EXTERNAL_ONLY unsigned int -mono_object_get_size (MonoObject *o); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_monitor_exit (MonoObject *obj); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_raise_exception (MonoException *ex); - -MONO_API MONO_RT_EXTERNAL_ONLY mono_bool -mono_runtime_set_pending_exception (MonoException *exc, mono_bool overwrite); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_reraise_exception (MonoException *ex); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_runtime_object_init (MonoObject *this_obj); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_runtime_class_init (MonoVTable *vtable); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoDomain* -mono_vtable_domain (MonoVTable *vtable); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoClass* -mono_vtable_class (MonoVTable *vtable); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod* -mono_object_get_virtual_method (MonoObject *obj, MonoMethod *method); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoObject* -mono_runtime_invoke (MonoMethod *method, void *obj, void **params, - MonoObject **exc); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod* -mono_get_delegate_invoke (MonoClass *klass); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod* -mono_get_delegate_begin_invoke (MonoClass *klass); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoMethod* -mono_get_delegate_end_invoke (MonoClass *klass); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoObject* -mono_runtime_delegate_invoke (MonoObject *delegate, void **params, - MonoObject **exc); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoObject* -mono_runtime_invoke_array (MonoMethod *method, void *obj, MonoArray *params, - MonoObject **exc); - -MONO_API MONO_RT_EXTERNAL_ONLY void* -mono_method_get_unmanaged_thunk (MonoMethod *method); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoArray* -mono_runtime_get_main_args (void); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_runtime_exec_managed_code (MonoDomain *domain, - MonoMainThreadFunc main_func, - void* main_args); - -MONO_API MONO_RT_EXTERNAL_ONLY int -mono_runtime_run_main (MonoMethod *method, int argc, char* argv[], - MonoObject **exc); - -MONO_API MONO_RT_EXTERNAL_ONLY int -mono_runtime_exec_main (MonoMethod *method, MonoArray *args, - MonoObject **exc); - -MONO_API MONO_RT_EXTERNAL_ONLY int -mono_runtime_set_main_args (int argc, char* argv[]); - -/* The following functions won't be available with mono was configured with remoting disabled. */ -/*#ifndef DISABLE_REMOTING */ -MONO_API MONO_RT_EXTERNAL_ONLY void* -mono_load_remote_field (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, void **res); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * -mono_load_remote_field_new (MonoObject *this_obj, MonoClass *klass, MonoClassField *field); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_store_remote_field (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, void* val); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_store_remote_field_new (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, MonoObject *arg); - -/* #endif */ - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_unhandled_exception (MonoObject *exc); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_print_unhandled_exception (MonoObject *exc); - -MONO_API MONO_RT_EXTERNAL_ONLY -void* -mono_compile_method (MonoMethod *method); - -/* accessors for fields and properties */ -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_field_set_value (MonoObject *obj, MonoClassField *field, void *value); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_field_static_set_value (MonoVTable *vt, MonoClassField *field, void *value); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_field_get_value (MonoObject *obj, MonoClassField *field, void *value); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_field_static_get_value (MonoVTable *vt, MonoClassField *field, void *value); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoObject * -mono_field_get_value_object (MonoDomain *domain, MonoClassField *field, MonoObject *obj); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_property_set_value (MonoProperty *prop, void *obj, void **params, MonoObject **exc); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoObject* -mono_property_get_value (MonoProperty *prop, void *obj, void **params, MonoObject **exc); - -/* GC handles support - * - * A handle can be created to refer to a managed object and either prevent it - * from being garbage collected or moved or to be able to know if it has been - * collected or not (weak references). - * mono_gchandle_new () is used to prevent an object from being garbage collected - * until mono_gchandle_free() is called. Use a TRUE value for the pinned argument to - * prevent the object from being moved (this should be avoided as much as possible - * and this should be used only for shorts periods of time or performance will suffer). - * To create a weakref use mono_gchandle_new_weakref (): track_resurrection should - * usually be false (see the GC docs for more details). - * mono_gchandle_get_target () can be used to get the object referenced by both kinds - * of handle: for a weakref handle, if an object has been collected, it will return NULL. - */ -MONO_API MONO_RT_EXTERNAL_ONLY uint32_t mono_gchandle_new (MonoObject *obj, mono_bool pinned); -MONO_API MONO_RT_EXTERNAL_ONLY uint32_t mono_gchandle_new_weakref (MonoObject *obj, mono_bool track_resurrection); -MONO_API MONO_RT_EXTERNAL_ONLY MonoObject* mono_gchandle_get_target (uint32_t gchandle); -MONO_API MONO_RT_EXTERNAL_ONLY void mono_gchandle_free (uint32_t gchandle); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoGCHandle mono_gchandle_new_v2 (MonoObject *obj, mono_bool pinned); -MONO_API MONO_RT_EXTERNAL_ONLY MonoGCHandle mono_gchandle_new_weakref_v2 (MonoObject *obj, mono_bool track_resurrection); -MONO_API MONO_RT_EXTERNAL_ONLY MonoObject* mono_gchandle_get_target_v2 (MonoGCHandle gchandle); -MONO_API MONO_RT_EXTERNAL_ONLY void mono_gchandle_free_v2 (MonoGCHandle gchandle); - -/* Reference queue support - * - * A reference queue is used to get notifications of when objects are collected. - * Call mono_gc_reference_queue_new to create a new queue and pass the callback that - * will be invoked when registered objects are collected. - * Call mono_gc_reference_queue_add to register a pair of objects and data within a queue. - * The callback will be triggered once an object is both unreachable and finalized. - */ - -typedef void (*mono_reference_queue_callback) (void *user_data); -typedef struct _MonoReferenceQueue MonoReferenceQueue; - -MONO_API MONO_RT_EXTERNAL_ONLY MonoReferenceQueue* mono_gc_reference_queue_new (mono_reference_queue_callback callback); -MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_reference_queue_free (MonoReferenceQueue *queue); -MONO_API MONO_RT_EXTERNAL_ONLY mono_bool mono_gc_reference_queue_add (MonoReferenceQueue *queue, MonoObject *obj, void *user_data); - -/* GC write barriers support */ -MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_set_field (MonoObject *obj, void* field_ptr, MonoObject* value); -MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_set_arrayref (MonoArray *arr, void* slot_ptr, MonoObject* value); -MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_arrayref_copy (void* dest_ptr, /*const*/ void* src_ptr, int count); -MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_generic_store (void* ptr, MonoObject* value); -MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_generic_store_atomic (void *ptr, MonoObject *value); -MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_generic_nostore (void* ptr); -MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_value_copy (void* dest, /*const*/ void* src, int count, MonoClass *klass); -MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wbarrier_object_copy (MonoObject* obj, MonoObject *src); - -MONO_END_DECLS - -#endif diff --git a/src/mono/msvc/include/mono/metadata/opcodes.h b/src/mono/msvc/include/mono/metadata/opcodes.h deleted file mode 100644 index bcaf099a44bc1..0000000000000 --- a/src/mono/msvc/include/mono/metadata/opcodes.h +++ /dev/null @@ -1,83 +0,0 @@ -/** - * \file - */ - -#ifndef __MONO_METADATA_OPCODES_H__ -#define __MONO_METADATA_OPCODES_H__ - -/* - * opcodes.h: CIL instruction information - * - * Author: - * Paolo Molaro (lupus@ximian.com) - * - * (C) 2002 Ximian, Inc. - */ - -#include - -MONO_BEGIN_DECLS - -#define MONO_CUSTOM_PREFIX 0xf0 - -#define OPDEF(a,b,c,d,e,f,g,h,i,j) \ - MONO_ ## a, - -typedef enum MonoOpcodeEnum { - MonoOpcodeEnum_Invalid = -1, -#include "mono/cil/opcode.def" - MONO_CEE_LAST -} MonoOpcodeEnum; - -#undef OPDEF - -enum { - MONO_FLOW_NEXT, - MONO_FLOW_BRANCH, - MONO_FLOW_COND_BRANCH, - MONO_FLOW_ERROR, - MONO_FLOW_CALL, - MONO_FLOW_RETURN, - MONO_FLOW_META -}; - -enum { - MonoInlineNone = 0, - MonoInlineType = 1, - MonoInlineField = 2, - MonoInlineMethod = 3, - MonoInlineTok = 4, - MonoInlineString = 5, - MonoInlineSig = 6, - MonoInlineVar = 7, - MonoShortInlineVar = 8, - MonoInlineBrTarget = 9, - MonoShortInlineBrTarget = 10, - MonoInlineSwitch = 11, - MonoInlineR = 12, - MonoShortInlineR = 13, - MonoInlineI = 14, - MonoShortInlineI = 15, - MonoInlineI8 = 16, -}; - -typedef struct { - unsigned char argument; - unsigned char flow_type; - unsigned short opval; -} MonoOpcode; - -MONO_BEGIN_DECLS -MONO_API_DATA const MonoOpcode mono_opcodes []; -MONO_END_DECLS - -MONO_API const char* -mono_opcode_name (int opcode); - -MONO_API MonoOpcodeEnum -mono_opcode_value (const mono_byte **ip, const mono_byte *end); - -MONO_END_DECLS - -#endif /* __MONO_METADATA_OPCODES_H__ */ - diff --git a/src/mono/msvc/include/mono/metadata/profiler-events.h b/src/mono/msvc/include/mono/metadata/profiler-events.h deleted file mode 100644 index c7ab3f66d516d..0000000000000 --- a/src/mono/msvc/include/mono/metadata/profiler-events.h +++ /dev/null @@ -1,108 +0,0 @@ -/* - * Licensed to the .NET Foundation under one or more agreements. - * The .NET Foundation licenses this file to you under the MIT license. - */ - -/* - * To #include this file, #define the following macros first: - * - * MONO_PROFILER_EVENT_0(name, type) - * MONO_PROFILER_EVENT_1(name, type, arg1_type, arg1_name) - * MONO_PROFILER_EVENT_2(name, type, arg1_type, arg1_name, arg2_type, arg2_name) - * MONO_PROFILER_EVENT_3(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name) - * MONO_PROFILER_EVENT_4(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name, arg4_type, arg4_name) - * MONO_PROFILER_EVENT_5(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name, arg4_type, arg4_name, arg5_type, arg5_name) - * - * To add new callbacks to the API, simply add a line in this file and use - * MONO_PROFILER_RAISE to raise the event wherever. - * - * If you need more arguments then the current macros provide, add another - * macro and update all areas where the macros are used. Remember that this is - * a public header and not all users will be defining the newly added macro. So - * to prevent errors in existing code, you must add something like this at the - * beginning of this file: - * - * #ifndef MONO_PROFILER_EVENT_6 - * #define MONO_PROFILER_EVENT_6(...) # Do nothing. - * #endif - */ - -#ifndef MONO_PROFILER_EVENT_5 -#define MONO_PROFILER_EVENT_5(...) -#endif - -MONO_PROFILER_EVENT_0(runtime_initialized, RuntimeInitialized) -MONO_PROFILER_EVENT_0(runtime_shutdown_begin, RuntimeShutdownBegin) -MONO_PROFILER_EVENT_0(runtime_shutdown_end, RuntimeShutdownEnd) - -MONO_PROFILER_EVENT_1(context_loaded, ContextLoaded, MonoAppContext *, context) -MONO_PROFILER_EVENT_1(context_unloaded, ContextUnloaded, MonoAppContext *, context) - -MONO_PROFILER_EVENT_1(domain_loading, DomainLoading, MonoDomain *, domain) -MONO_PROFILER_EVENT_1(domain_loaded, DomainLoaded, MonoDomain *, domain) -MONO_PROFILER_EVENT_1(domain_unloading, DomainUnloading, MonoDomain *, domain) -MONO_PROFILER_EVENT_1(domain_unloaded, DomainUnloaded, MonoDomain *, domain) -MONO_PROFILER_EVENT_2(domain_name, DomainName, MonoDomain *, domain, const char *, name) - -MONO_PROFILER_EVENT_1(jit_begin, JitBegin, MonoMethod *, method) -MONO_PROFILER_EVENT_1(jit_failed, JitFailed, MonoMethod *, method) -MONO_PROFILER_EVENT_2(jit_done, JitDone, MonoMethod *, method, MonoJitInfo *, jinfo) -MONO_PROFILER_EVENT_2(jit_chunk_created, JitChunkCreated, const mono_byte *, chunk, uintptr_t, size) -MONO_PROFILER_EVENT_1(jit_chunk_destroyed, JitChunkDestroyed, const mono_byte *, chunk) -MONO_PROFILER_EVENT_4(jit_code_buffer, JitCodeBuffer, const mono_byte *, buffer, uint64_t, size, MonoProfilerCodeBufferType, type, const void *, data) - -MONO_PROFILER_EVENT_1(class_loading, ClassLoading, MonoClass *, klass) -MONO_PROFILER_EVENT_1(class_failed, ClassFailed, MonoClass *, klass) -MONO_PROFILER_EVENT_1(class_loaded, ClassLoaded, MonoClass *, klass) - -MONO_PROFILER_EVENT_1(vtable_loading, VTableLoading, MonoVTable *, vtable) -MONO_PROFILER_EVENT_1(vtable_failed, VTableFailed, MonoVTable *, vtable) -MONO_PROFILER_EVENT_1(vtable_loaded, VTableLoaded, MonoVTable *, vtable) - -MONO_PROFILER_EVENT_1(image_loading, ModuleLoading, MonoImage *, image) -MONO_PROFILER_EVENT_1(image_failed, ModuleFailed, MonoImage *, image) -MONO_PROFILER_EVENT_1(image_loaded, ModuleLoaded, MonoImage *, image) -MONO_PROFILER_EVENT_1(image_unloading, ModuleUnloading, MonoImage *, image) -MONO_PROFILER_EVENT_1(image_unloaded, ModuleUnloaded, MonoImage *, image) - -MONO_PROFILER_EVENT_1(assembly_loading, AssemblyLoading, MonoAssembly *, assembly) -MONO_PROFILER_EVENT_1(assembly_loaded, AssemblyLLoaded, MonoAssembly *, assembly) -MONO_PROFILER_EVENT_1(assembly_unloading, AssemblyLUnloading, MonoAssembly *, assembly) -MONO_PROFILER_EVENT_1(assembly_unloaded, AssemblyLUnloaded, MonoAssembly *, assembly) - -MONO_PROFILER_EVENT_2(method_enter, MethodEnter, MonoMethod *, method, MonoProfilerCallContext *, context) -MONO_PROFILER_EVENT_2(method_leave, MethodLeave, MonoMethod *, method, MonoProfilerCallContext *, context) -MONO_PROFILER_EVENT_2(method_tail_call, MethodTailCall, MonoMethod *, method, MonoMethod *, target) -MONO_PROFILER_EVENT_2(method_exception_leave, MethodExceptionLeave, MonoMethod *, method, MonoObject *, exception) -MONO_PROFILER_EVENT_1(method_free, MethodFree, MonoMethod *, method) -MONO_PROFILER_EVENT_1(method_begin_invoke, MethodBeginInvoke, MonoMethod *, method) -MONO_PROFILER_EVENT_1(method_end_invoke, MethodEndInvoke, MonoMethod *, method) - -MONO_PROFILER_EVENT_1(exception_throw, ExceptionThrow, MonoObject *, exception) -MONO_PROFILER_EVENT_4(exception_clause, ExceptionClause, MonoMethod *, method, uint32_t, index, MonoExceptionEnum, type, MonoObject *, exception) - -MONO_PROFILER_EVENT_3(gc_event, GCEvent2, MonoProfilerGCEvent, event, uint32_t, generation, mono_bool, is_serial) -MONO_PROFILER_EVENT_1(gc_allocation, GCAllocation, MonoObject *, object) -MONO_PROFILER_EVENT_2(gc_moves, GCMoves, MonoObject *const *, objects, uint64_t, count) -MONO_PROFILER_EVENT_1(gc_resize, GCResize, uintptr_t, size) -MONO_PROFILER_EVENT_3(gc_handle_created, GCHandleCreated, uint32_t, handle, MonoGCHandleType, type, MonoObject *, object) -MONO_PROFILER_EVENT_2(gc_handle_deleted, GCHandleDeleted, uint32_t, handle, MonoGCHandleType, type) -MONO_PROFILER_EVENT_0(gc_finalizing, GCFinalizing) -MONO_PROFILER_EVENT_0(gc_finalized, GCFinalized) -MONO_PROFILER_EVENT_1(gc_finalizing_object, GCFinalizingObject, MonoObject *, object) -MONO_PROFILER_EVENT_1(gc_finalized_object, GCFinalizedObject, MonoObject *, object) -MONO_PROFILER_EVENT_5(gc_root_register, RootRegister, const mono_byte *, start, uintptr_t, size, MonoGCRootSource, source, const void *, key, const char *, name) -MONO_PROFILER_EVENT_1(gc_root_unregister, RootUnregister, const mono_byte *, start) -MONO_PROFILER_EVENT_3(gc_roots, GCRoots, uint64_t, count, const mono_byte *const *, addresses, MonoObject *const *, objects) - -MONO_PROFILER_EVENT_1(monitor_contention, MonitorContention, MonoObject *, object) -MONO_PROFILER_EVENT_1(monitor_failed, MonitorFailed, MonoObject *, object) -MONO_PROFILER_EVENT_1(monitor_acquired, MonitorAcquired, MonoObject *, object) - -MONO_PROFILER_EVENT_1(thread_started, ThreadStarted, uintptr_t, tid) -MONO_PROFILER_EVENT_1(thread_stopping, ThreadStopping, uintptr_t, tid) -MONO_PROFILER_EVENT_1(thread_stopped, ThreadStopped, uintptr_t, tid) -MONO_PROFILER_EVENT_1(thread_exited, ThreadExited, uintptr_t, tid) -MONO_PROFILER_EVENT_2(thread_name, ThreadName, uintptr_t, tid, const char *, name) - -MONO_PROFILER_EVENT_2(sample_hit, SampleHit, const mono_byte *, ip, const void *, context) diff --git a/src/mono/msvc/include/mono/metadata/profiler.h b/src/mono/msvc/include/mono/metadata/profiler.h deleted file mode 100644 index 2fd2d840f82a5..0000000000000 --- a/src/mono/msvc/include/mono/metadata/profiler.h +++ /dev/null @@ -1,248 +0,0 @@ -/* - * Licensed to the .NET Foundation under one or more agreements. - * The .NET Foundation licenses this file to you under the MIT license. - */ - -#ifndef __MONO_PROFILER_H__ -#define __MONO_PROFILER_H__ - -#include -#include -#include - -MONO_BEGIN_DECLS - -/** - * This value will be incremented whenever breaking changes to the profiler API - * are made. This macro is intended for use in profiler modules that wish to - * support older versions of the profiler API. - * - * Version 2: - * - Major overhaul of the profiler API. - * Version 3: - * - Added mono_profiler_enable_clauses (). This must now be called to enable - * raising exception_clause events. - * - The exception argument to exception_clause events can now be NULL for - * finally clauses invoked in the non-exceptional case. - * - The type argument to exception_clause events will now correctly indicate - * that the catch portion of the clause is being executed in the case of - * try-filter-catch clauses. - * - Removed the iomap_report event. - * - Removed the old gc_event event and renamed gc_event2 to gc_event. - */ -#define MONO_PROFILER_API_VERSION 3 - -typedef struct _MonoProfiler MonoProfiler; -typedef struct _MonoProfilerDesc *MonoProfilerHandle; - -typedef void (*MonoProfilerCleanupCallback) (MonoProfiler *prof); - -MONO_API void mono_profiler_load (const char *desc); -MONO_API MonoProfilerHandle mono_profiler_create (MonoProfiler *prof); -MONO_API void mono_profiler_set_cleanup_callback (MonoProfilerHandle handle, MonoProfilerCleanupCallback cb); - -typedef struct { - MonoMethod *method; - uint32_t il_offset; - uint32_t counter; - const char *file_name; - uint32_t line; - uint32_t column; -} MonoProfilerCoverageData; - -typedef mono_bool (*MonoProfilerCoverageFilterCallback) (MonoProfiler *prof, MonoMethod *method); -typedef void (*MonoProfilerCoverageCallback) (MonoProfiler *prof, const MonoProfilerCoverageData *data); - -MONO_API mono_bool mono_profiler_enable_coverage (void); -MONO_API void mono_profiler_set_coverage_filter_callback (MonoProfilerHandle handle, MonoProfilerCoverageFilterCallback cb); -MONO_API mono_bool mono_profiler_get_coverage_data (MonoProfilerHandle handle, MonoMethod *method, MonoProfilerCoverageCallback cb); - -typedef enum { - /** - * Do not perform sampling. Will make the sampling thread sleep until the - * sampling mode is changed to one of the below modes. - */ - MONO_PROFILER_SAMPLE_MODE_NONE = 0, - /** - * Try to base sampling frequency on process activity. Falls back to - * MONO_PROFILER_SAMPLE_MODE_REAL if such a clock is not available. - */ - MONO_PROFILER_SAMPLE_MODE_PROCESS = 1, - /** - * Base sampling frequency on wall clock time. Uses a monotonic clock when - * available (all major platforms). - */ - MONO_PROFILER_SAMPLE_MODE_REAL = 2, -} MonoProfilerSampleMode; - -MONO_API mono_bool mono_profiler_enable_sampling (MonoProfilerHandle handle); -MONO_API mono_bool mono_profiler_set_sample_mode (MonoProfilerHandle handle, MonoProfilerSampleMode mode, uint32_t freq); -MONO_API mono_bool mono_profiler_get_sample_mode (MonoProfilerHandle handle, MonoProfilerSampleMode *mode, uint32_t *freq); - -MONO_API mono_bool mono_profiler_enable_allocations (void); -MONO_API mono_bool mono_profiler_enable_clauses (void); - -typedef struct _MonoProfilerCallContext MonoProfilerCallContext; - -typedef enum { - /** - * Do not instrument calls. - */ - MONO_PROFILER_CALL_INSTRUMENTATION_NONE = 0, - /** - * Instrument method entries. - */ - MONO_PROFILER_CALL_INSTRUMENTATION_ENTER = 1 << 1, - /** - * Also capture a call context for method entries. - */ - MONO_PROFILER_CALL_INSTRUMENTATION_ENTER_CONTEXT = 1 << 2, - /** - * Instrument method exits. - */ - MONO_PROFILER_CALL_INSTRUMENTATION_LEAVE = 1 << 3, - /** - * Also capture a call context for method exits. - */ - MONO_PROFILER_CALL_INSTRUMENTATION_LEAVE_CONTEXT = 1 << 4, - /** - * Instrument method exits as a result of a tail call. - */ - MONO_PROFILER_CALL_INSTRUMENTATION_TAIL_CALL = 1 << 5, - /** - * Instrument exceptional method exits. - */ - MONO_PROFILER_CALL_INSTRUMENTATION_EXCEPTION_LEAVE = 1 << 6, -} MonoProfilerCallInstrumentationFlags; - -typedef MonoProfilerCallInstrumentationFlags (*MonoProfilerCallInstrumentationFilterCallback) (MonoProfiler *prof, MonoMethod *method); - -MONO_API void mono_profiler_set_call_instrumentation_filter_callback (MonoProfilerHandle handle, MonoProfilerCallInstrumentationFilterCallback cb); -MONO_API mono_bool mono_profiler_enable_call_context_introspection (void); -MONO_API void *mono_profiler_call_context_get_this (MonoProfilerCallContext *context); -MONO_API void *mono_profiler_call_context_get_argument (MonoProfilerCallContext *context, uint32_t position); -MONO_API void *mono_profiler_call_context_get_local (MonoProfilerCallContext *context, uint32_t position); -MONO_API void *mono_profiler_call_context_get_result (MonoProfilerCallContext *context); -MONO_API void mono_profiler_call_context_free_buffer (void *buffer); - -typedef enum { - /** - * The \c data parameter is a \c MonoMethod pointer. - */ - MONO_PROFILER_CODE_BUFFER_METHOD = 0, - /** - * \deprecated No longer used. - */ - MONO_PROFILER_CODE_BUFFER_METHOD_TRAMPOLINE = 1, - /** - * The \c data parameter is a \c MonoMethod pointer. - */ - MONO_PROFILER_CODE_BUFFER_UNBOX_TRAMPOLINE = 2, - MONO_PROFILER_CODE_BUFFER_IMT_TRAMPOLINE = 3, - MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE = 4, - /** - * The \c data parameter is a C string. - */ - MONO_PROFILER_CODE_BUFFER_SPECIFIC_TRAMPOLINE = 5, - MONO_PROFILER_CODE_BUFFER_HELPER = 6, - /** - * \deprecated No longer used. - */ - MONO_PROFILER_CODE_BUFFER_MONITOR = 7, - MONO_PROFILER_CODE_BUFFER_DELEGATE_INVOKE = 8, - MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING = 9, -} MonoProfilerCodeBufferType; - -typedef enum { - MONO_GC_EVENT_PRE_STOP_WORLD = 6, - /** - * When this event arrives, the GC and suspend locks are acquired. - */ - MONO_GC_EVENT_PRE_STOP_WORLD_LOCKED = 10, - MONO_GC_EVENT_POST_STOP_WORLD = 7, - MONO_GC_EVENT_START = 0, - MONO_GC_EVENT_END = 5, - MONO_GC_EVENT_PRE_START_WORLD = 8, - /** - * When this event arrives, the GC and suspend locks are released. - */ - MONO_GC_EVENT_POST_START_WORLD_UNLOCKED = 11, - MONO_GC_EVENT_POST_START_WORLD = 9, -} MonoProfilerGCEvent; - -/* - * The macros below will generate the majority of the callback API. Refer to - * mono/metadata/profiler-events.h for a list of callbacks. They are expanded - * like so: - * - * typedef void (*MonoProfilerRuntimeInitializedCallback (MonoProfiler *prof); - * MONO_API void mono_profiler_set_runtime_initialized_callback (MonoProfiler *prof, MonoProfilerRuntimeInitializedCallback cb); - * - * typedef void (*MonoProfilerRuntimeShutdownCallback (MonoProfiler *prof); - * MONO_API void mono_profiler_set_runtime_shutdown_callback (MonoProfiler *prof, MonoProfilerRuntimeShutdownCallback cb); - * - * typedef void (*MonoProfilerContextLoadedCallback (MonoProfiler *prof); - * MONO_API void mono_profiler_set_context_loaded_callback (MonoProfiler *prof, MonoProfilerContextLoadedCallback cb); - * - * typedef void (*MonoProfilerContextUnloadedCallback (MonoProfiler *prof); - * MONO_API void mono_profiler_set_context_unloaded_callback (MonoProfiler *prof, MonoProfilerContextUnloadedCallback cb); - * - * Etc. - * - * To remove a callback, pass NULL instead of a valid function pointer. - * Callbacks can be changed at any point, but note that doing so is inherently - * racy with respect to threads that aren't suspended, i.e. you may still see a - * call from another thread right after you change a callback. - * - * These functions are async safe. - */ - -#define _MONO_PROFILER_EVENT(type, ...) \ - typedef void (*MonoProfiler ## type ## Callback) (__VA_ARGS__); -#define MONO_PROFILER_EVENT_0(name, type) \ - _MONO_PROFILER_EVENT(type, MonoProfiler *prof) -#define MONO_PROFILER_EVENT_1(name, type, arg1_type, arg1_name) \ - _MONO_PROFILER_EVENT(type, MonoProfiler *prof, arg1_type arg1_name) -#define MONO_PROFILER_EVENT_2(name, type, arg1_type, arg1_name, arg2_type, arg2_name) \ - _MONO_PROFILER_EVENT(type, MonoProfiler *prof, arg1_type arg1_name, arg2_type arg2_name) -#define MONO_PROFILER_EVENT_3(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name) \ - _MONO_PROFILER_EVENT(type, MonoProfiler *prof, arg1_type arg1_name, arg2_type arg2_name, arg3_type arg3_name) -#define MONO_PROFILER_EVENT_4(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name, arg4_type, arg4_name) \ - _MONO_PROFILER_EVENT(type, MonoProfiler *prof, arg1_type arg1_name, arg2_type arg2_name, arg3_type arg3_name, arg4_type arg4_name) -#define MONO_PROFILER_EVENT_5(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name, arg4_type, arg4_name, arg5_type, arg5_name) \ - _MONO_PROFILER_EVENT(type, MonoProfiler *prof, arg1_type arg1_name, arg2_type arg2_name, arg3_type arg3_name, arg4_type arg4_name, arg5_type arg5_name) -#include -#undef MONO_PROFILER_EVENT_0 -#undef MONO_PROFILER_EVENT_1 -#undef MONO_PROFILER_EVENT_2 -#undef MONO_PROFILER_EVENT_3 -#undef MONO_PROFILER_EVENT_4 -#undef MONO_PROFILER_EVENT_5 -#undef _MONO_PROFILER_EVENT - -#define _MONO_PROFILER_EVENT(name, type) \ - MONO_API void mono_profiler_set_ ## name ## _callback (MonoProfilerHandle handle, MonoProfiler ## type ## Callback cb); -#define MONO_PROFILER_EVENT_0(name, type) \ - _MONO_PROFILER_EVENT(name, type) -#define MONO_PROFILER_EVENT_1(name, type, arg1_type, arg1_name) \ - _MONO_PROFILER_EVENT(name, type) -#define MONO_PROFILER_EVENT_2(name, type, arg1_type, arg1_name, arg2_type, arg2_name) \ - _MONO_PROFILER_EVENT(name, type) -#define MONO_PROFILER_EVENT_3(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name) \ - _MONO_PROFILER_EVENT(name, type) -#define MONO_PROFILER_EVENT_4(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name, arg4_type, arg4_name) \ - _MONO_PROFILER_EVENT(name, type) -#define MONO_PROFILER_EVENT_5(name, type, arg1_type, arg1_name, arg2_type, arg2_name, arg3_type, arg3_name, arg4_type, arg4_name, arg5_type, arg5_name) \ - _MONO_PROFILER_EVENT(name, type) -#include -#undef MONO_PROFILER_EVENT_0 -#undef MONO_PROFILER_EVENT_1 -#undef MONO_PROFILER_EVENT_2 -#undef MONO_PROFILER_EVENT_3 -#undef MONO_PROFILER_EVENT_4 -#undef MONO_PROFILER_EVENT_5 -#undef _MONO_PROFILER_EVENT - -MONO_END_DECLS - -#endif // __MONO_PROFILER_H__ diff --git a/src/mono/msvc/include/mono/metadata/reflection.h b/src/mono/msvc/include/mono/metadata/reflection.h deleted file mode 100644 index 83bcfccd657bf..0000000000000 --- a/src/mono/msvc/include/mono/metadata/reflection.h +++ /dev/null @@ -1,174 +0,0 @@ -/** - * \file - */ - -#ifndef __METADATA_REFLECTION_H__ -#define __METADATA_REFLECTION_H__ - -#include -#include - -MONO_BEGIN_DECLS - -typedef struct MonoTypeNameParse MonoTypeNameParse; - -typedef struct { - MonoMethod *ctor; - uint32_t data_size; - const mono_byte* data; -} MonoCustomAttrEntry; - -typedef struct { - int num_attrs; - int cached; - MonoImage *image; - MonoCustomAttrEntry attrs [MONO_ZERO_LEN_ARRAY]; -} MonoCustomAttrInfo; - -#define MONO_SIZEOF_CUSTOM_ATTR_INFO (offsetof (MonoCustomAttrInfo, attrs)) - -/* - * Information which isn't in the MonoMethod structure is stored here for - * dynamic methods. - */ -typedef struct { - char **param_names; - MonoMarshalSpec **param_marshall; - MonoCustomAttrInfo **param_cattr; - uint8_t** param_defaults; - uint32_t *param_default_types; - char *dllentry, *dll; -} MonoReflectionMethodAux; - -typedef enum { - ResolveTokenError_OutOfRange, - ResolveTokenError_BadTable, - ResolveTokenError_Other -} MonoResolveTokenError; - -MONO_API MONO_RT_EXTERNAL_ONLY -int mono_reflection_parse_type (char *name, MonoTypeNameParse *info); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoType* mono_reflection_get_type (MonoImage* image, MonoTypeNameParse *info, mono_bool ignorecase, mono_bool *type_resolve); -MONO_API void mono_reflection_free_type_info (MonoTypeNameParse *info); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoType* mono_reflection_type_from_name (char *name, MonoImage *image); -MONO_API MONO_RT_EXTERNAL_ONLY -uint32_t mono_reflection_get_token (MonoObject *obj); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoReflectionAssembly* mono_assembly_get_object (MonoDomain *domain, MonoAssembly *assembly); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoReflectionModule* mono_module_get_object (MonoDomain *domain, MonoImage *image); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoReflectionModule* mono_module_file_get_object (MonoDomain *domain, MonoImage *image, int table_index); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoReflectionType* mono_type_get_object (MonoDomain *domain, MonoType *type); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoReflectionMethod* mono_method_get_object (MonoDomain *domain, MonoMethod *method, MonoClass *refclass); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoReflectionField* mono_field_get_object (MonoDomain *domain, MonoClass *klass, MonoClassField *field); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoReflectionProperty* mono_property_get_object (MonoDomain *domain, MonoClass *klass, MonoProperty *property); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoReflectionEvent* mono_event_get_object (MonoDomain *domain, MonoClass *klass, MonoEvent *event); -/* note: this one is slightly different: we keep the whole array of params in the cache */ -MONO_API MONO_RT_EXTERNAL_ONLY -MonoArray* mono_param_get_objects (MonoDomain *domain, MonoMethod *method); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoReflectionMethodBody* mono_method_body_get_object (MonoDomain *domain, MonoMethod *method); - -MONO_API MonoObject *mono_get_dbnull_object (MonoDomain *domain); - -MONO_API MonoArray* mono_reflection_get_custom_attrs_by_type (MonoObject *obj, MonoClass *attr_klass, MonoError *error); -MONO_API MonoArray* mono_reflection_get_custom_attrs (MonoObject *obj); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoArray* mono_reflection_get_custom_attrs_data (MonoObject *obj); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoArray* mono_reflection_get_custom_attrs_blob (MonoReflectionAssembly *assembly, MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *porpValues, MonoArray *fields, MonoArray* fieldValues); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoCustomAttrInfo* mono_reflection_get_custom_attrs_info (MonoObject *obj); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoArray* mono_custom_attrs_construct (MonoCustomAttrInfo *cinfo); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoCustomAttrInfo* mono_custom_attrs_from_index (MonoImage *image, uint32_t idx); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoCustomAttrInfo* mono_custom_attrs_from_method (MonoMethod *method); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoCustomAttrInfo* mono_custom_attrs_from_class (MonoClass *klass); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoCustomAttrInfo* mono_custom_attrs_from_assembly (MonoAssembly *assembly); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoCustomAttrInfo* mono_custom_attrs_from_property (MonoClass *klass, MonoProperty *property); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoCustomAttrInfo* mono_custom_attrs_from_event (MonoClass *klass, MonoEvent *event); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoCustomAttrInfo* mono_custom_attrs_from_field (MonoClass *klass, MonoClassField *field); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoCustomAttrInfo* mono_custom_attrs_from_param (MonoMethod *method, uint32_t param); -MONO_API mono_bool mono_custom_attrs_has_attr (MonoCustomAttrInfo *ainfo, MonoClass *attr_klass); -MONO_API MONO_RT_EXTERNAL_ONLY -MonoObject* mono_custom_attrs_get_attr (MonoCustomAttrInfo *ainfo, MonoClass *attr_klass); -MONO_API void mono_custom_attrs_free (MonoCustomAttrInfo *ainfo); - - -#define MONO_DECLSEC_ACTION_MIN 0x1 -#define MONO_DECLSEC_ACTION_MAX 0x12 - -enum { - MONO_DECLSEC_FLAG_REQUEST = 0x00000001, - MONO_DECLSEC_FLAG_DEMAND = 0x00000002, - MONO_DECLSEC_FLAG_ASSERT = 0x00000004, - MONO_DECLSEC_FLAG_DENY = 0x00000008, - MONO_DECLSEC_FLAG_PERMITONLY = 0x00000010, - MONO_DECLSEC_FLAG_LINKDEMAND = 0x00000020, - MONO_DECLSEC_FLAG_INHERITANCEDEMAND = 0x00000040, - MONO_DECLSEC_FLAG_REQUEST_MINIMUM = 0x00000080, - MONO_DECLSEC_FLAG_REQUEST_OPTIONAL = 0x00000100, - MONO_DECLSEC_FLAG_REQUEST_REFUSE = 0x00000200, - MONO_DECLSEC_FLAG_PREJIT_GRANT = 0x00000400, - MONO_DECLSEC_FLAG_PREJIT_DENY = 0x00000800, - MONO_DECLSEC_FLAG_NONCAS_DEMAND = 0x00001000, - MONO_DECLSEC_FLAG_NONCAS_LINKDEMAND = 0x00002000, - MONO_DECLSEC_FLAG_NONCAS_INHERITANCEDEMAND = 0x00004000, - MONO_DECLSEC_FLAG_LINKDEMAND_CHOICE = 0x00008000, - MONO_DECLSEC_FLAG_INHERITANCEDEMAND_CHOICE = 0x00010000, - MONO_DECLSEC_FLAG_DEMAND_CHOICE = 0x00020000 -}; - -MONO_API uint32_t mono_declsec_flags_from_method (MonoMethod *method); -MONO_API uint32_t mono_declsec_flags_from_class (MonoClass *klass); -MONO_API uint32_t mono_declsec_flags_from_assembly (MonoAssembly *assembly); - -/* this structure MUST be kept in synch with RuntimeDeclSecurityEntry - * located in /mcs/class/corlib/System.Security/SecurityFrame.cs */ -typedef struct { - char *blob; /* pointer to metadata blob */ - uint32_t size; /* size of the metadata blob */ - uint32_t index; -} MonoDeclSecurityEntry; - -typedef struct { - MonoDeclSecurityEntry demand; - MonoDeclSecurityEntry noncasdemand; - MonoDeclSecurityEntry demandchoice; -} MonoDeclSecurityActions; - -MONO_API MonoBoolean mono_declsec_get_demands (MonoMethod *callee, MonoDeclSecurityActions* demands); -MONO_API MonoBoolean mono_declsec_get_linkdemands (MonoMethod *callee, MonoDeclSecurityActions* klass, MonoDeclSecurityActions* cmethod); -MONO_API MonoBoolean mono_declsec_get_inheritdemands_class (MonoClass *klass, MonoDeclSecurityActions* demands); -MONO_API MonoBoolean mono_declsec_get_inheritdemands_method (MonoMethod *callee, MonoDeclSecurityActions* demands); - -MONO_API MonoBoolean mono_declsec_get_method_action (MonoMethod *method, uint32_t action, MonoDeclSecurityEntry *entry); -MONO_API MonoBoolean mono_declsec_get_class_action (MonoClass *klass, uint32_t action, MonoDeclSecurityEntry *entry); -MONO_API MonoBoolean mono_declsec_get_assembly_action (MonoAssembly *assembly, uint32_t action, MonoDeclSecurityEntry *entry); - -MONO_API MONO_RT_EXTERNAL_ONLY -MonoType* mono_reflection_type_get_type (MonoReflectionType *reftype); - -MONO_API MonoAssembly* mono_reflection_assembly_get_assembly (MonoReflectionAssembly *refassembly); - -MONO_END_DECLS - -#endif /* __METADATA_REFLECTION_H__ */ diff --git a/src/mono/msvc/include/mono/metadata/row-indexes.h b/src/mono/msvc/include/mono/metadata/row-indexes.h deleted file mode 100644 index b0f5dc072d681..0000000000000 --- a/src/mono/msvc/include/mono/metadata/row-indexes.h +++ /dev/null @@ -1,503 +0,0 @@ -/** - * \file - */ - -#ifndef __MONO_METADATA_ROW_INDEXES_H__ -#define __MONO_METADATA_ROW_INDEXES_H__ - -/* - * The last entry in the enum is used to give the number - * of columns in the row. - */ - -enum { - MONO_ASSEMBLY_HASH_ALG, - MONO_ASSEMBLY_MAJOR_VERSION, - MONO_ASSEMBLY_MINOR_VERSION, - MONO_ASSEMBLY_BUILD_NUMBER, - MONO_ASSEMBLY_REV_NUMBER, - MONO_ASSEMBLY_FLAGS, - MONO_ASSEMBLY_PUBLIC_KEY, - MONO_ASSEMBLY_NAME, - MONO_ASSEMBLY_CULTURE, - MONO_ASSEMBLY_SIZE -}; - -enum { - MONO_ASSEMBLYOS_PLATFORM, - MONO_ASSEMBLYOS_MAJOR_VERSION, - MONO_ASSEMBLYOS_MINOR_VERSION, - MONO_ASSEMBLYOS_SIZE -}; - -enum { - MONO_ASSEMBLY_PROCESSOR, - MONO_ASSEMBLY_PROCESSOR_SIZE -}; - -enum { - MONO_ASSEMBLYREF_MAJOR_VERSION, - MONO_ASSEMBLYREF_MINOR_VERSION, - MONO_ASSEMBLYREF_BUILD_NUMBER, - MONO_ASSEMBLYREF_REV_NUMBER, - MONO_ASSEMBLYREF_FLAGS, - MONO_ASSEMBLYREF_PUBLIC_KEY, - MONO_ASSEMBLYREF_NAME, - MONO_ASSEMBLYREF_CULTURE, - MONO_ASSEMBLYREF_HASH_VALUE, - MONO_ASSEMBLYREF_SIZE -}; - -enum { - MONO_ASSEMBLYREFOS_PLATFORM, - MONO_ASSEMBLYREFOS_MAJOR_VERSION, - MONO_ASSEMBLYREFOS_MINOR_VERSION, - MONO_ASSEMBLYREFOS_ASSEMBLYREF, - MONO_ASSEMBLYREFOS_SIZE -}; - -enum { - MONO_ASSEMBLYREFPROC_PROCESSOR, - MONO_ASSEMBLYREFPROC_ASSEMBLYREF, - MONO_ASSEMBLYREFPROC_SIZE -}; - -enum { - MONO_CLASS_LAYOUT_PACKING_SIZE, - MONO_CLASS_LAYOUT_CLASS_SIZE, - MONO_CLASS_LAYOUT_PARENT, - MONO_CLASS_LAYOUT_SIZE -}; - -enum { - MONO_CONSTANT_TYPE, - MONO_CONSTANT_PADDING, - MONO_CONSTANT_PARENT, - MONO_CONSTANT_VALUE, - MONO_CONSTANT_SIZE -}; - -enum { - MONO_CUSTOM_ATTR_PARENT, - MONO_CUSTOM_ATTR_TYPE, - MONO_CUSTOM_ATTR_VALUE, - MONO_CUSTOM_ATTR_SIZE -}; - -enum { - MONO_DECL_SECURITY_ACTION, - MONO_DECL_SECURITY_PARENT, - MONO_DECL_SECURITY_PERMISSIONSET, - MONO_DECL_SECURITY_SIZE -}; - -enum { - MONO_EVENT_MAP_PARENT, - MONO_EVENT_MAP_EVENTLIST, - MONO_EVENT_MAP_SIZE -}; - -enum { - MONO_EVENT_FLAGS, - MONO_EVENT_NAME, - MONO_EVENT_TYPE, - MONO_EVENT_SIZE -}; - -enum { - MONO_EVENT_POINTER_EVENT, - MONO_EVENT_POINTER_SIZE -}; - -enum { - MONO_EXP_TYPE_FLAGS, - MONO_EXP_TYPE_TYPEDEF, - MONO_EXP_TYPE_NAME, - MONO_EXP_TYPE_NAMESPACE, - MONO_EXP_TYPE_IMPLEMENTATION, - MONO_EXP_TYPE_SIZE -}; - -enum { - MONO_FIELD_FLAGS, - MONO_FIELD_NAME, - MONO_FIELD_SIGNATURE, - MONO_FIELD_SIZE -}; - -enum { - MONO_FIELD_LAYOUT_OFFSET, - MONO_FIELD_LAYOUT_FIELD, - MONO_FIELD_LAYOUT_SIZE -}; - -enum { - MONO_FIELD_MARSHAL_PARENT, - MONO_FIELD_MARSHAL_NATIVE_TYPE, - MONO_FIELD_MARSHAL_SIZE -}; - -enum { - MONO_FIELD_POINTER_FIELD, - MONO_FIELD_POINTER_SIZE -}; - -enum { - MONO_FIELD_RVA_RVA, - MONO_FIELD_RVA_FIELD, - MONO_FIELD_RVA_SIZE -}; - -enum { - MONO_ENCLOG_TOKEN, - MONO_ENCLOG_FUNC_CODE, - MONO_ENCLOG_SIZE -}; - -enum { - MONO_ENCMAP_TOKEN, - MONO_ENCMAP_SIZE -}; - -enum { - MONO_FILE_FLAGS, - MONO_FILE_NAME, - MONO_FILE_HASH_VALUE, - MONO_FILE_SIZE -}; - -enum { - MONO_IMPLMAP_FLAGS, - MONO_IMPLMAP_MEMBER, - MONO_IMPLMAP_NAME, - MONO_IMPLMAP_SCOPE, - MONO_IMPLMAP_SIZE -}; - -enum { - MONO_INTERFACEIMPL_CLASS, - MONO_INTERFACEIMPL_INTERFACE, - MONO_INTERFACEIMPL_SIZE -}; - -enum { - MONO_MANIFEST_OFFSET, - MONO_MANIFEST_FLAGS, - MONO_MANIFEST_NAME, - MONO_MANIFEST_IMPLEMENTATION, - MONO_MANIFEST_SIZE -}; - -enum { - MONO_MEMBERREF_CLASS, - MONO_MEMBERREF_NAME, - MONO_MEMBERREF_SIGNATURE, - MONO_MEMBERREF_SIZE -}; - -enum { - MONO_METHOD_RVA, - MONO_METHOD_IMPLFLAGS, - MONO_METHOD_FLAGS, - MONO_METHOD_NAME, - MONO_METHOD_SIGNATURE, - MONO_METHOD_PARAMLIST, - MONO_METHOD_SIZE -}; - -enum { - MONO_METHODIMPL_CLASS, - MONO_METHODIMPL_BODY, - MONO_METHODIMPL_DECLARATION, - MONO_METHODIMPL_SIZE -}; - -enum { - MONO_METHOD_POINTER_METHOD, - MONO_METHOD_POINTER_SIZE -}; - -enum { - MONO_METHOD_SEMA_SEMANTICS, - MONO_METHOD_SEMA_METHOD, - MONO_METHOD_SEMA_ASSOCIATION, - MONO_METHOD_SEMA_SIZE -}; - -enum { - MONO_MODULE_GENERATION, - MONO_MODULE_NAME, - MONO_MODULE_MVID, - MONO_MODULE_ENC, - MONO_MODULE_ENCBASE, - MONO_MODULE_SIZE -}; - -enum { - MONO_MODULEREF_NAME, - MONO_MODULEREF_SIZE -}; - -enum { - MONO_NESTED_CLASS_NESTED, - MONO_NESTED_CLASS_ENCLOSING, - MONO_NESTED_CLASS_SIZE -}; - -enum { - MONO_PARAM_FLAGS, - MONO_PARAM_SEQUENCE, - MONO_PARAM_NAME, - MONO_PARAM_SIZE -}; - -enum { - MONO_PARAM_POINTER_PARAM, - MONO_PARAM_POINTER_SIZE -}; - -enum { - MONO_PROPERTY_FLAGS, - MONO_PROPERTY_NAME, - MONO_PROPERTY_TYPE, - MONO_PROPERTY_SIZE -}; - -enum { - MONO_PROPERTY_POINTER_PROPERTY, - MONO_PROPERTY_POINTER_SIZE -}; - -enum { - MONO_PROPERTY_MAP_PARENT, - MONO_PROPERTY_MAP_PROPERTY_LIST, - MONO_PROPERTY_MAP_SIZE -}; - -enum { - MONO_STAND_ALONE_SIGNATURE, - MONO_STAND_ALONE_SIGNATURE_SIZE -}; - -enum { - MONO_TYPEDEF_FLAGS, - MONO_TYPEDEF_NAME, - MONO_TYPEDEF_NAMESPACE, - MONO_TYPEDEF_EXTENDS, - MONO_TYPEDEF_FIELD_LIST, - MONO_TYPEDEF_METHOD_LIST, - MONO_TYPEDEF_SIZE -}; - -enum { - MONO_TYPEREF_SCOPE, - MONO_TYPEREF_NAME, - MONO_TYPEREF_NAMESPACE, - MONO_TYPEREF_SIZE -}; - -enum { - MONO_TYPESPEC_SIGNATURE, - MONO_TYPESPEC_SIZE -}; - -enum { - MONO_GENERICPARAM_NUMBER, - MONO_GENERICPARAM_FLAGS, - MONO_GENERICPARAM_OWNER, - MONO_GENERICPARAM_NAME, - - MONO_GENERICPARAM_SIZE -}; - -enum { - MONO_METHODSPEC_METHOD, - MONO_METHODSPEC_SIGNATURE, - MONO_METHODSPEC_SIZE -}; - -enum { - MONO_GENPARCONSTRAINT_GENERICPAR, - MONO_GENPARCONSTRAINT_CONSTRAINT, - MONO_GENPARCONSTRAINT_SIZE -}; - -enum { - MONO_DOCUMENT_NAME, - MONO_DOCUMENT_HASHALG, - MONO_DOCUMENT_HASH, - MONO_DOCUMENT_LANGUAGE, - MONO_DOCUMENT_SIZE -}; - -enum { - MONO_METHODBODY_DOCUMENT, - MONO_METHODBODY_SEQ_POINTS, - MONO_METHODBODY_SIZE -}; - -enum { - MONO_LOCALSCOPE_METHOD, - MONO_LOCALSCOPE_IMPORTSCOPE, - MONO_LOCALSCOPE_VARIABLELIST, - MONO_LOCALSCOPE_CONSTANTLIST, - MONO_LOCALSCOPE_STARTOFFSET, - MONO_LOCALSCOPE_LENGTH, - MONO_LOCALSCOPE_SIZE -}; - -enum { - MONO_LOCALVARIABLE_ATTRIBUTES, - MONO_LOCALVARIABLE_INDEX, - MONO_LOCALVARIABLE_NAME, - MONO_LOCALVARIABLE_SIZE -}; - -enum { - MONO_CUSTOMDEBUGINFORMATION_PARENT, - MONO_CUSTOMDEBUGINFORMATION_KIND, - MONO_CUSTOMDEBUGINFORMATION_VALUE, - MONO_CUSTOMDEBUGINFORMATION_SIZE -}; - -/* - * Coded Tokens - * The _BITS entry is for the bits used in the token. - * The _MASK entry is for mask the index out. - */ - -enum { - MONO_TYPEDEFORREF_TYPEDEF, - MONO_TYPEDEFORREF_TYPEREF, - MONO_TYPEDEFORREF_TYPESPEC, - MONO_TYPEDEFORREF_BITS = 2, - MONO_TYPEDEFORREF_MASK = 3 -}; - -enum { - MONO_HASCONSTANT_FIEDDEF, - MONO_HASCONSTANT_PARAM, - MONO_HASCONSTANT_PROPERTY, - MONO_HASCONSTANT_BITS = 2, - MONO_HASCONSTANT_MASK = 3 -}; - -enum { - MONO_CUSTOM_ATTR_METHODDEF, - MONO_CUSTOM_ATTR_FIELDDEF, - MONO_CUSTOM_ATTR_TYPEREF, - MONO_CUSTOM_ATTR_TYPEDEF, - MONO_CUSTOM_ATTR_PARAMDEF, - MONO_CUSTOM_ATTR_INTERFACE, - MONO_CUSTOM_ATTR_MEMBERREF, - MONO_CUSTOM_ATTR_MODULE, - MONO_CUSTOM_ATTR_PERMISSION, - MONO_CUSTOM_ATTR_PROPERTY, - MONO_CUSTOM_ATTR_EVENT, - MONO_CUSTOM_ATTR_SIGNATURE, - MONO_CUSTOM_ATTR_MODULEREF, - MONO_CUSTOM_ATTR_TYPESPEC, - MONO_CUSTOM_ATTR_ASSEMBLY, - MONO_CUSTOM_ATTR_ASSEMBLYREF, - MONO_CUSTOM_ATTR_FILE, - MONO_CUSTOM_ATTR_EXP_TYPE, - MONO_CUSTOM_ATTR_MANIFEST, - MONO_CUSTOM_ATTR_GENERICPAR, - MONO_CUSTOM_ATTR_GENERICPARAMCONSTRAINT, - MONO_CUSTOM_ATTR_BITS = 5, - MONO_CUSTOM_ATTR_MASK = 0x1F -}; - -enum { - MONO_HAS_FIELD_MARSHAL_FIELDSREF, - MONO_HAS_FIELD_MARSHAL_PARAMDEF, - MONO_HAS_FIELD_MARSHAL_BITS = 1, - MONO_HAS_FIELD_MARSHAL_MASK = 1 -}; - -enum { - MONO_HAS_DECL_SECURITY_TYPEDEF, - MONO_HAS_DECL_SECURITY_METHODDEF, - MONO_HAS_DECL_SECURITY_ASSEMBLY, - MONO_HAS_DECL_SECURITY_BITS = 2, - MONO_HAS_DECL_SECURITY_MASK = 3 -}; - -enum { - MONO_MEMBERREF_PARENT_TYPEDEF, /* not used */ - MONO_MEMBERREF_PARENT_TYPEREF, - MONO_MEMBERREF_PARENT_MODULEREF, - MONO_MEMBERREF_PARENT_METHODDEF, - MONO_MEMBERREF_PARENT_TYPESPEC, - MONO_MEMBERREF_PARENT_BITS = 3, - MONO_MEMBERREF_PARENT_MASK = 7 -}; - -enum { - MONO_HAS_SEMANTICS_EVENT, - MONO_HAS_SEMANTICS_PROPERTY, - MONO_HAS_SEMANTICS_BITS = 1, - MONO_HAS_SEMANTICS_MASK = 1 -}; - -enum { - MONO_METHODDEFORREF_METHODDEF, - MONO_METHODDEFORREF_METHODREF, - MONO_METHODDEFORREF_BITS = 1, - MONO_METHODDEFORREF_MASK = 1 -}; - -enum { - MONO_MEMBERFORWD_FIELDDEF, - MONO_MEMBERFORWD_METHODDEF, - MONO_MEMBERFORWD_BITS = 1, - MONO_MEMBERFORWD_MASK = 1 -}; - -enum { - MONO_IMPLEMENTATION_FILE, - MONO_IMPLEMENTATION_ASSEMBLYREF, - MONO_IMPLEMENTATION_EXP_TYPE, - MONO_IMPLEMENTATION_BITS = 2, - MONO_IMPLEMENTATION_MASK = 3 -}; - -enum { - MONO_CUSTOM_ATTR_TYPE_TYPEREF, /* not used */ - MONO_CUSTOM_ATTR_TYPE_TYPEDEF, /* not used */ - MONO_CUSTOM_ATTR_TYPE_METHODDEF, - MONO_CUSTOM_ATTR_TYPE_MEMBERREF, - MONO_CUSTOM_ATTR_TYPE_STRING, /* not used */ - MONO_CUSTOM_ATTR_TYPE_BITS = 3, - MONO_CUSTOM_ATTR_TYPE_MASK = 7 -}; - -enum { - MONO_RESOLUTION_SCOPE_MODULE, - MONO_RESOLUTION_SCOPE_MODULEREF, - MONO_RESOLUTION_SCOPE_ASSEMBLYREF, - MONO_RESOLUTION_SCOPE_TYPEREF, - MONO_RESOLUTION_SCOPE_BITS = 2, - MONO_RESOLUTION_SCOPE_MASK = 3 -}; - -/* Kept for compatibility since this is a public header file */ -enum { - MONO_RESOLTION_SCOPE_MODULE, - MONO_RESOLTION_SCOPE_MODULEREF, - MONO_RESOLTION_SCOPE_ASSEMBLYREF, - MONO_RESOLTION_SCOPE_TYPEREF, - MONO_RESOLTION_SCOPE_BITS = 2, - MONO_RESOLTION_SCOPE_MASK = 3 -}; - -enum { - MONO_TYPEORMETHOD_TYPE, - MONO_TYPEORMETHOD_METHOD, - MONO_TYPEORMETHOD_BITS = 1, - MONO_TYPEORMETHOD_MASK = 1 -}; - -#endif /* __MONO_METADATA_ROW_INDEXES_H__ */ - - diff --git a/src/mono/msvc/include/mono/metadata/sgen-bridge.h b/src/mono/msvc/include/mono/metadata/sgen-bridge.h deleted file mode 100644 index c131f3066914e..0000000000000 --- a/src/mono/msvc/include/mono/metadata/sgen-bridge.h +++ /dev/null @@ -1,110 +0,0 @@ -/** - * \file - * Copyright 2011 Novell, Inc. - * - * Licensed under the MIT license. See LICENSE file in the project root for full license information. - */ - -/* - * The bridge is a mechanism for SGen to let clients override the death of some - * unreachable objects. We use it in monodroid to do garbage collection across - * the Mono and Java heaps. - * - * The client (Monodroid) can designate some objects as "bridged", which means - * that they participate in the bridge processing step once SGen considers them - * unreachable, i.e., dead. Bridged objects must be registered for - * finalization. - * - * When SGen is done marking, it puts together a list of all dead bridged - * objects. This is passed to the bridge processor, which does an analysis to - * simplify the graph: It replaces strongly-connected components with single - * nodes, and may remove nodes corresponding to components which do not contain - * bridged objects. - * - * The output of the SCC analysis is passed to the client's `cross_references()` - * callback. This consists of 2 arrays, an array of SCCs (MonoGCBridgeSCC), - * and an array of "xrefs" (edges between SCCs, MonoGCBridgeXRef). Edges are - * encoded as pairs of "API indices", ie indexes in the SCC array. The client - * is expected to set the `is_alive` flag on those strongly connected components - * that it wishes to be kept alive. - * - * In monodroid each bridged object has a corresponding Java mirror object. In - * the bridge callback it reifies the Mono object graph in the Java heap so that - * the full, combined object graph is now instantiated on the Java side. Then - * it triggers a Java GC, waits for it to finish, and checks which of the Java - * mirror objects are still alive. For those it sets the `is_alive` flag and - * returns from the callback. - * - * The SCC analysis is done while the world is stopped, but the callback is made - * with the world running again. Weak links to bridged objects and other - * objects reachable from them are kept until the callback returns, at which - * point all links to bridged objects that don't have `is_alive` set are nulled. - * Note that weak links to non-bridged objects reachable from bridged objects - * are not nulled. This might be considered a bug. - * - * There are three different implementations of the bridge processor, each of - * which implements 8 callbacks (see SgenBridgeProcessor). The implementations - * differ in the algorithm they use to compute the "simplified" SCC graph. - */ - -#ifndef _MONO_SGEN_BRIDGE_H_ -#define _MONO_SGEN_BRIDGE_H_ - -#include - -MONO_BEGIN_DECLS - -enum { - SGEN_BRIDGE_VERSION = 5 -}; - -typedef enum { - /* Instances of this class should be scanned when computing the transitive dependency among bridges. E.g. List*/ - GC_BRIDGE_TRANSPARENT_CLASS, - /* Instances of this class should not be scanned when computing the transitive dependency among bridges. E.g. String*/ - GC_BRIDGE_OPAQUE_CLASS, - /* Instances of this class should be bridged and have their dependency computed. */ - GC_BRIDGE_TRANSPARENT_BRIDGE_CLASS, - /* Instances of this class should be bridged but no dependencies should not be calculated. */ - GC_BRIDGE_OPAQUE_BRIDGE_CLASS, -} MonoGCBridgeObjectKind; - -typedef struct { - mono_bool is_alive; /* to be set by the cross reference callback */ - int num_objs; - MonoObject *objs [MONO_ZERO_LEN_ARRAY]; -} MonoGCBridgeSCC; - -typedef struct { - int src_scc_index; - int dst_scc_index; -} MonoGCBridgeXRef; - -typedef struct { - int bridge_version; - /* - * Tells the runtime which classes to even consider when looking for - * bridged objects. If subclasses are to be considered as well, the - * subclass check must be done in the callback. - */ - MonoGCBridgeObjectKind (*bridge_class_kind) (MonoClass *klass); - /* - * This is only called on objects for whose classes - * `bridge_class_kind()` returned `XXX_BRIDGE_CLASS`. - */ - mono_bool (*is_bridge_object) (MonoObject *object); - void (*cross_references) (int num_sccs, MonoGCBridgeSCC **sccs, int num_xrefs, MonoGCBridgeXRef *xrefs); -} MonoGCBridgeCallbacks; - -/* - * Note: This may be called at any time, but cannot be called concurrently - * with (during and on a separate thread from) sgen init. Callers are - * responsible for enforcing this. - */ -MONO_API void mono_gc_register_bridge_callbacks (MonoGCBridgeCallbacks *callbacks); - -MONO_API void mono_gc_wait_for_bridge_processing (void); - -MONO_END_DECLS - -#endif diff --git a/src/mono/msvc/include/mono/metadata/threads.h b/src/mono/msvc/include/mono/metadata/threads.h deleted file mode 100644 index 89be80f5a024b..0000000000000 --- a/src/mono/msvc/include/mono/metadata/threads.h +++ /dev/null @@ -1,69 +0,0 @@ -/** - * \file - * Threading API - * - * Author: - * Dick Porter (dick@ximian.com) - * Patrik Torstensson (patrik.torstensson@labs2.com) - * - * (C) 2001 Ximian, Inc - */ - -#ifndef _MONO_METADATA_THREADS_H_ -#define _MONO_METADATA_THREADS_H_ - -#include -#include -#include - -MONO_BEGIN_DECLS - -/* This callback should return TRUE if the runtime must wait for the thread, FALSE otherwise */ -typedef mono_bool (*MonoThreadManageCallback) (MonoThread* thread); - -MONO_API void mono_thread_init (MonoThreadStartCB start_cb, - MonoThreadAttachCB attach_cb); -MONO_API void mono_thread_cleanup (void); -MONO_API MONO_RT_EXTERNAL_ONLY -void mono_thread_manage(void); - -MONO_API MonoThread *mono_thread_current (void); - -MONO_API void mono_thread_set_main (MonoThread *thread); -MONO_API MonoThread *mono_thread_get_main (void); - -MONO_API MONO_RT_EXTERNAL_ONLY void mono_thread_stop (MonoThread *thread); - -MONO_API void mono_thread_new_init (intptr_t tid, void* stack_start, - void* func); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_thread_create (MonoDomain *domain, void* func, void* arg); - -MONO_API MONO_RT_EXTERNAL_ONLY MonoThread * -mono_thread_attach (MonoDomain *domain); -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_thread_detach (MonoThread *thread); -MONO_API void mono_thread_exit (void); - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_threads_attach_tools_thread (void); - -MONO_API char *mono_thread_get_name_utf8 (MonoThread *thread); -MONO_API int32_t mono_thread_get_managed_id (MonoThread *thread); - -MONO_API void mono_thread_set_manage_callback (MonoThread *thread, MonoThreadManageCallback func); - -MONO_API void mono_threads_set_default_stacksize (uint32_t stacksize); -MONO_API uint32_t mono_threads_get_default_stacksize (void); - -MONO_API void mono_threads_request_thread_dump (void); - -MONO_API mono_bool mono_thread_is_foreign (MonoThread *thread); - -MONO_API MONO_RT_EXTERNAL_ONLY mono_bool -mono_thread_detach_if_exiting (void); - -MONO_END_DECLS - -#endif /* _MONO_METADATA_THREADS_H_ */ diff --git a/src/mono/msvc/include/mono/metadata/tokentype.h b/src/mono/msvc/include/mono/metadata/tokentype.h deleted file mode 100644 index a1c58944d7404..0000000000000 --- a/src/mono/msvc/include/mono/metadata/tokentype.h +++ /dev/null @@ -1,45 +0,0 @@ -/** - * \file - */ - -#ifndef _MONO_METADATA_TOKENTYPE_H_ -#define _MONO_METADATA_TOKENTYPE_H_ - -/* - * These tokens match the table ID except for the last - * three (string, name and base type which are special) - */ - -typedef enum { - MONO_TOKEN_MODULE = 0x00000000, - MONO_TOKEN_TYPE_REF = 0x01000000, - MONO_TOKEN_TYPE_DEF = 0x02000000, - MONO_TOKEN_FIELD_DEF = 0x04000000, - MONO_TOKEN_METHOD_DEF = 0x06000000, - MONO_TOKEN_PARAM_DEF = 0x08000000, - MONO_TOKEN_INTERFACE_IMPL = 0x09000000, - MONO_TOKEN_MEMBER_REF = 0x0a000000, - MONO_TOKEN_CUSTOM_ATTRIBUTE = 0x0c000000, - MONO_TOKEN_PERMISSION = 0x0e000000, - MONO_TOKEN_SIGNATURE = 0x11000000, - MONO_TOKEN_EVENT = 0x14000000, - MONO_TOKEN_PROPERTY = 0x17000000, - MONO_TOKEN_MODULE_REF = 0x1a000000, - MONO_TOKEN_TYPE_SPEC = 0x1b000000, - MONO_TOKEN_ASSEMBLY = 0x20000000, - MONO_TOKEN_ASSEMBLY_REF = 0x23000000, - MONO_TOKEN_FILE = 0x26000000, - MONO_TOKEN_EXPORTED_TYPE = 0x27000000, - MONO_TOKEN_MANIFEST_RESOURCE = 0x28000000, - MONO_TOKEN_GENERIC_PARAM = 0x2a000000, - MONO_TOKEN_METHOD_SPEC = 0x2b000000, - - /* - * These do not match metadata tables directly - */ - MONO_TOKEN_STRING = 0x70000000, - MONO_TOKEN_NAME = 0x71000000, - MONO_TOKEN_BASE_TYPE = 0x72000000 -} MonoTokenType; - -#endif /* _MONO_METADATA_TOKENTYPE_H_ */ diff --git a/src/mono/msvc/include/mono/metadata/verify.h b/src/mono/msvc/include/mono/metadata/verify.h deleted file mode 100644 index 162ef4434e682..0000000000000 --- a/src/mono/msvc/include/mono/metadata/verify.h +++ /dev/null @@ -1,66 +0,0 @@ -/** - * \file - */ - -#ifndef __MONO_METADATA_VERIFY_H__ -#define __MONO_METADATA_VERIFY_H__ - -#include -#include -#include -#include /* GSList dep */ - -MONO_BEGIN_DECLS - -typedef enum { - MONO_VERIFY_OK, - MONO_VERIFY_ERROR, - MONO_VERIFY_WARNING, - MONO_VERIFY_CLS = 4, - MONO_VERIFY_ALL = 7, - - /* Status signaling code that is not verifiable.*/ - MONO_VERIFY_NOT_VERIFIABLE = 8, - - /*OR it with other flags*/ - - /* Abort the verification if the code is not verifiable. - * The standard behavior is to abort if the code is not valid. - * */ - MONO_VERIFY_FAIL_FAST = 16, - - - /* Perform less verification of the code. This flag should be used - * if one wants the verifier to be more compatible to the MS runtime. - * Mind that this is not to be more compatible with MS peverify, but - * with the runtime itself, that has a less strict verifier. - */ - MONO_VERIFY_NON_STRICT = 32, - - /*Skip all visibility related checks*/ - MONO_VERIFY_SKIP_VISIBILITY = 64, - - /*Skip all visibility related checks*/ - MONO_VERIFY_REPORT_ALL_ERRORS = 128 - -} MonoVerifyStatus; - -typedef struct { - char *message; - MonoVerifyStatus status; -} MonoVerifyInfo; - -typedef struct { - MonoVerifyInfo info; - int8_t exception_type; /*should be one of MONO_EXCEPTION_* */ -} MonoVerifyInfoExtended; - - -MONO_API GSList* mono_method_verify (MonoMethod *method, int level); -MONO_API void mono_free_verify_list (GSList *list); -MONO_API char* mono_verify_corlib (void); - -MONO_END_DECLS - -#endif /* __MONO_METADATA_VERIFY_H__ */ - diff --git a/src/mono/msvc/include/mono/utils/mono-counters.h b/src/mono/msvc/include/mono/utils/mono-counters.h deleted file mode 100644 index 77175b35f49a8..0000000000000 --- a/src/mono/msvc/include/mono/utils/mono-counters.h +++ /dev/null @@ -1,105 +0,0 @@ -/** - * \file - */ - -#ifndef __MONO_COUNTERS_H__ -#define __MONO_COUNTERS_H__ - -#include -#include - -enum { - /* Counter type, bits 0-7. */ - MONO_COUNTER_INT, /* 32 bit int */ - MONO_COUNTER_UINT, /* 32 bit uint */ - MONO_COUNTER_WORD, /* pointer-sized int */ - MONO_COUNTER_LONG, /* 64 bit int */ - MONO_COUNTER_ULONG, /* 64 bit uint */ - MONO_COUNTER_DOUBLE, - MONO_COUNTER_STRING, /* char* */ - MONO_COUNTER_TIME_INTERVAL, /* 64 bits signed int holding usecs. */ - MONO_COUNTER_TYPE_MASK = 0xf, - MONO_COUNTER_CALLBACK = 128, /* ORed with the other values */ - MONO_COUNTER_SECTION_MASK = 0x00ffff00, - /* Sections, bits 8-23 (16 bits) */ - MONO_COUNTER_JIT = 1 << 8, - MONO_COUNTER_GC = 1 << 9, - MONO_COUNTER_METADATA = 1 << 10, - MONO_COUNTER_GENERICS = 1 << 11, - MONO_COUNTER_SECURITY = 1 << 12, - MONO_COUNTER_RUNTIME = 1 << 13, - MONO_COUNTER_SYSTEM = 1 << 14, - MONO_COUNTER_PERFCOUNTERS = 1 << 15, - MONO_COUNTER_PROFILER = 1 << 16, - MONO_COUNTER_INTERP = 1 << 17, - MONO_COUNTER_TIERED = 1 << 18, - MONO_COUNTER_LAST_SECTION, - - /* Unit, bits 24-27 (4 bits) */ - MONO_COUNTER_UNIT_SHIFT = 24, - MONO_COUNTER_UNIT_MASK = 0xFu << MONO_COUNTER_UNIT_SHIFT, - MONO_COUNTER_RAW = 0 << 24, /* Raw value */ - MONO_COUNTER_BYTES = 1 << 24, /* Quantity of bytes. RSS, active heap, etc */ - MONO_COUNTER_TIME = 2 << 24, /* Time interval in 100ns units. Minor pause, JIT compilation*/ - MONO_COUNTER_COUNT = 3 << 24, /* Number of things (threads, queued jobs) or Number of events triggered (Major collections, Compiled methods).*/ - MONO_COUNTER_PERCENTAGE = 4 << 24, /* [0-1] Fraction Percentage of something. Load average. */ - - /* Monotonicity, bits 28-31 (4 bits) */ - MONO_COUNTER_VARIANCE_SHIFT = 28, - MONO_COUNTER_VARIANCE_MASK = 0xFu << MONO_COUNTER_VARIANCE_SHIFT, - MONO_COUNTER_MONOTONIC = 1 << 28, /* This counter value always increase/decreases over time. Reported by --stat. */ - MONO_COUNTER_CONSTANT = 1 << 29, /* Fixed value. Used by configuration data. */ - MONO_COUNTER_VARIABLE = 1 << 30, /* This counter value can be anything on each sampling. Only interesting when sampling. */ -}; - -typedef struct _MonoCounter MonoCounter; - -MONO_API void mono_counters_enable (int section_mask); -MONO_API void mono_counters_init (void); - -/* - * register addr as the address of a counter of type type. - * It may be a function pointer if MONO_COUNTER_CALLBACK is specified: - * the function should return the value and take no arguments. - */ -MONO_API void mono_counters_register (const char* descr, int type, void *addr); -MONO_API void mono_counters_register_with_size (const char *name, int type, void *addr, int size); - -typedef void (*MonoCounterRegisterCallback) (MonoCounter*); -MONO_API void mono_counters_on_register (MonoCounterRegisterCallback callback); - -/* - * Create a readable dump of the counters for section_mask sections (ORed section values) - */ -MONO_API void mono_counters_dump (int section_mask, FILE *outfile); - -MONO_API void mono_counters_cleanup (void); - -typedef mono_bool (*CountersEnumCallback) (MonoCounter *counter, void *user_data); - -MONO_API void mono_counters_foreach (CountersEnumCallback cb, void *user_data); - -MONO_API int mono_counters_sample (MonoCounter *counter, void *buffer, int buffer_size); - -MONO_API const char* mono_counter_get_name (MonoCounter *name); -MONO_API int mono_counter_get_type (MonoCounter *counter); -MONO_API int mono_counter_get_section (MonoCounter *counter); -MONO_API int mono_counter_get_unit (MonoCounter *counter); -MONO_API int mono_counter_get_variance (MonoCounter *counter); -MONO_API size_t mono_counter_get_size (MonoCounter *counter); - -typedef enum { - MONO_RESOURCE_JIT_CODE, /* bytes */ - MONO_RESOURCE_METADATA, /* bytes */ - MONO_RESOURCE_GC_HEAP, /* bytes */ - MONO_RESOURCE_COUNT /* non-ABI value */ -} MonoResourceType; - -typedef void (*MonoResourceCallback) (int resource_type, uintptr_t value, int is_soft); - -MONO_API int mono_runtime_resource_limit (int resource_type, uintptr_t soft_limit, uintptr_t hard_limit); -MONO_API void mono_runtime_resource_set_callback (MonoResourceCallback callback); -MONO_API void mono_runtime_resource_check_limit (int resource_type, uintptr_t value); - -#endif /* __MONO_COUNTERS_H__ */ - diff --git a/src/mono/msvc/include/mono/utils/mono-dl-fallback.h b/src/mono/msvc/include/mono/utils/mono-dl-fallback.h deleted file mode 100644 index 11ec4f30b8ac0..0000000000000 --- a/src/mono/msvc/include/mono/utils/mono-dl-fallback.h +++ /dev/null @@ -1,43 +0,0 @@ -/** - * \file - */ - -#ifndef __MONO_UTILS_DL_FALLBACK_H__ -#define __MONO_UTILS_DL_FALLBACK_H__ - -#include - -MONO_BEGIN_DECLS - -enum { - MONO_DL_EAGER = 0, - MONO_DL_LAZY = 1, - // If MONO_DL_LOCAL is set, it will trump MONO_DL_GLOBAL. - MONO_DL_LOCAL = 2, - // MONO_DL_MASK is unused internally and no longer a full mask on netcore, given the introduction of MONO_DL_GLOBAL. Avoid. - MONO_DL_MASK = 3, - // Only applicable when building Mono in netcore mode. - MONO_DL_GLOBAL = 4 -}; - -/* - * This is the dynamic loader fallback API - */ -typedef struct MonoDlFallbackHandler MonoDlFallbackHandler; - -/* - * The "err" variable contents must be allocated using g_malloc or g_strdup - */ -typedef void* (*MonoDlFallbackLoad) (const char *name, int flags, char **err, void *user_data); -typedef void* (*MonoDlFallbackSymbol) (void *handle, const char *name, char **err, void *user_data); -typedef void* (*MonoDlFallbackClose) (void *handle, void *user_data); - -MONO_API MonoDlFallbackHandler *mono_dl_fallback_register (MonoDlFallbackLoad load_func, MonoDlFallbackSymbol symbol_func, - MonoDlFallbackClose close_func, void *user_data); - -MONO_API void mono_dl_fallback_unregister (MonoDlFallbackHandler *handler); - -MONO_END_DECLS - -#endif /* __MONO_UTILS_DL_FALLBACK_H__ */ - diff --git a/src/mono/msvc/include/mono/utils/mono-error.h b/src/mono/msvc/include/mono/utils/mono-error.h deleted file mode 100644 index 69bfb8a47346f..0000000000000 --- a/src/mono/msvc/include/mono/utils/mono-error.h +++ /dev/null @@ -1,105 +0,0 @@ -/** - * \file - */ - -#ifndef __MONO_ERROR_H__ -#define __MONO_ERROR_H__ - -#include - -enum { - /* - The supplied strings were dup'd by means of calling mono_error_dup_strings. - */ - MONO_ERROR_FREE_STRINGS = 0x0001, - - /* - Something happened while processing the error and the resulting message is incomplete. - */ - MONO_ERROR_INCOMPLETE = 0x0002, - /* - This MonoError is heap allocated in a mempool - */ - MONO_ERROR_MEMPOOL_BOXED = 0x0004 -}; - -enum { - MONO_ERROR_NONE = 0, - MONO_ERROR_MISSING_METHOD = 1, - MONO_ERROR_MISSING_FIELD = 2, - MONO_ERROR_TYPE_LOAD = 3, - MONO_ERROR_FILE_NOT_FOUND = 4, - MONO_ERROR_BAD_IMAGE = 5, - MONO_ERROR_OUT_OF_MEMORY = 6, - MONO_ERROR_ARGUMENT = 7, - MONO_ERROR_ARGUMENT_NULL = 11, - MONO_ERROR_ARGUMENT_OUT_OF_RANGE = 14, - MONO_ERROR_NOT_VERIFIABLE = 8, - MONO_ERROR_INVALID_PROGRAM = 12, - MONO_ERROR_MEMBER_ACCESS = 13, - - /* - * This is a generic error mechanism is you need to raise an arbitrary corlib exception. - * You must pass the exception name otherwise prepare_exception will fail with internal execution. - */ - MONO_ERROR_GENERIC = 9, - /* This one encapsulates a managed exception instance */ - MONO_ERROR_EXCEPTION_INSTANCE = 10, - - /* Not a valid error code - indicates that the error was cleaned up and reused */ - MONO_ERROR_CLEANUP_CALLED_SENTINEL = 0xffff -}; - -#ifdef _MSC_VER -__pragma(warning (push)) -__pragma(warning (disable:4201)) -#endif - -/*Keep in sync with MonoErrorInternal*/ -typedef union _MonoError { - // Merge two uint16 into one uint32 so it can be initialized - // with one instruction instead of two. - uint32_t init; - struct { - uint16_t error_code; - uint16_t private_flags; /*DON'T TOUCH */ - void *hidden_1 [12]; /*DON'T TOUCH */ - }; -} MonoErrorExternal; - -#ifdef _MSC_VER -__pragma(warning (pop)) -#endif - -#ifdef MONO_INSIDE_RUNTIME -typedef union _MonoErrorInternal MonoError; -#else -typedef MonoErrorExternal MonoError; -#endif - -/* Mempool-allocated MonoError.*/ -typedef struct _MonoErrorBoxed MonoErrorBoxed; - -MONO_BEGIN_DECLS - -MONO_API MONO_RT_EXTERNAL_ONLY void -mono_error_init (MonoError *error); - -MONO_API void -mono_error_init_flags (MonoError *error, unsigned short flags); - -MONO_API void -mono_error_cleanup (MonoError *error); - -MONO_API MONO_RT_EXTERNAL_ONLY mono_bool -mono_error_ok (MonoError *error); - -MONO_API unsigned short -mono_error_get_error_code (MonoError *error); - -MONO_API const char* -mono_error_get_message (MonoError *error); - -MONO_END_DECLS - -#endif diff --git a/src/mono/msvc/include/mono/utils/mono-forward.h b/src/mono/msvc/include/mono/utils/mono-forward.h deleted file mode 100644 index 784f6e080921a..0000000000000 --- a/src/mono/msvc/include/mono/utils/mono-forward.h +++ /dev/null @@ -1,15 +0,0 @@ -/** - * \file - * - * (C) 2018 Microsoft, Inc. - * - */ -#ifndef _MONO_UTILS_FORWARD_ -#define _MONO_UTILS_FORWARD_ - -typedef struct _MonoDomain MonoDomain; -typedef struct _MonoJitInfo MonoJitInfo; - -typedef void * MonoGCHandle; - -#endif diff --git a/src/mono/msvc/include/mono/utils/mono-jemalloc.h b/src/mono/msvc/include/mono/utils/mono-jemalloc.h deleted file mode 100644 index 6721877f51428..0000000000000 --- a/src/mono/msvc/include/mono/utils/mono-jemalloc.h +++ /dev/null @@ -1,36 +0,0 @@ -/** - * \file - * - * Header for jemalloc registration code - */ - -#ifndef __MONO_JEMALLOC_H__ -#define __MONO_JEMALLOC_H__ - -#if defined(MONO_JEMALLOC_ENABLED) - -#include - -/* Jemalloc can be configured in three ways. - * 1. You can use it with library loading hacks at run-time - * 2. You can use it as a global malloc replacement - * 3. You can use it with a prefix. If you use it with a prefix, you have to explicitly name the malloc function. - * - * In order to make this feature able to be toggled at run-time, I chose to use a prefix of mono_je. - * This mapping is captured below in the header, in the spirit of "no magic constants". - * - * The place that configures jemalloc and sets this prefix is in the Makefile in - * mono/jemalloc/Makefile.am - * - */ -#define MONO_JEMALLOC_MALLOC mono_jemalloc -#define MONO_JEMALLOC_REALLOC mono_jerealloc -#define MONO_JEMALLOC_FREE mono_jefree -#define MONO_JEMALLOC_CALLOC mono_jecalloc - -void mono_init_jemalloc (void); - -#endif - -#endif - diff --git a/src/mono/msvc/include/mono/utils/mono-logger.h b/src/mono/msvc/include/mono/utils/mono-logger.h deleted file mode 100644 index a90e6c54cf365..0000000000000 --- a/src/mono/msvc/include/mono/utils/mono-logger.h +++ /dev/null @@ -1,31 +0,0 @@ -/** - * \file - */ - -#ifndef __MONO_LOGGER_H__ -#define __MONO_LOGGER_H__ - -#include -MONO_BEGIN_DECLS - -MONO_API void -mono_trace_set_level_string (const char *value); - -MONO_API void -mono_trace_set_mask_string (const char *value); - -typedef void (*MonoPrintCallback) (const char *string, mono_bool is_stdout); -typedef void (*MonoLogCallback) (const char *log_domain, const char *log_level, const char *message, mono_bool fatal, void *user_data); - -MONO_API void -mono_trace_set_log_handler (MonoLogCallback callback, void *user_data); - -MONO_API void -mono_trace_set_print_handler (MonoPrintCallback callback); - -MONO_API void -mono_trace_set_printerr_handler (MonoPrintCallback callback); - -MONO_END_DECLS - -#endif /* __MONO_LOGGER_H__ */ diff --git a/src/mono/msvc/include/mono/utils/mono-private-unstable.h b/src/mono/msvc/include/mono/utils/mono-private-unstable.h deleted file mode 100644 index 241a723447957..0000000000000 --- a/src/mono/msvc/include/mono/utils/mono-private-unstable.h +++ /dev/null @@ -1,19 +0,0 @@ -/** - * \file - * - * Private unstable APIs. - * - * WARNING: The declarations and behavior of functions in this header are NOT STABLE and can be modified or removed at - * any time. - * - */ - - -#ifndef __MONO_UTILS_MONO_PRIVATE_UNSTABLE_H__ -#define __MONO_UTILS_MONO_PRIVATE_UNSTABLE_H__ - -#include - - - -#endif /*__MONO_UTILS_MONO_PRIVATE_UNSTABLE_H__*/ diff --git a/src/mono/msvc/include/mono/utils/mono-publib.h b/src/mono/msvc/include/mono/utils/mono-publib.h deleted file mode 100644 index b01438e52cf1c..0000000000000 --- a/src/mono/msvc/include/mono/utils/mono-publib.h +++ /dev/null @@ -1,187 +0,0 @@ -/** - * \file - */ - -#ifndef __MONO_PUBLIB_H__ -#define __MONO_PUBLIB_H__ - -/* - * Minimal general purpose header for use in public mono header files. - * We can't include config.h, so we use compiler-specific preprocessor - * directives where needed. - */ - -#ifdef __cplusplus -#define MONO_BEGIN_DECLS extern "C" { -#define MONO_END_DECLS } -#else -#define MONO_BEGIN_DECLS /* nothing */ -#define MONO_END_DECLS /* nothing */ -#endif - -MONO_BEGIN_DECLS - -/* VS 2010 and later have stdint.h */ -#if defined(_MSC_VER) - -#if _MSC_VER < 1600 - -typedef __int8 int8_t; -typedef unsigned __int8 uint8_t; -typedef __int16 int16_t; -typedef unsigned __int16 uint16_t; -typedef __int32 int32_t; -typedef unsigned __int32 uint32_t; -typedef __int64 int64_t; -typedef unsigned __int64 uint64_t; - -#else - -#include - -#endif - -#define MONO_API_EXPORT __declspec(dllexport) -#define MONO_API_IMPORT __declspec(dllimport) - -#else - -#include - -#if defined (__clang__) || defined (__GNUC__) -#define MONO_API_EXPORT __attribute__ ((__visibility__ ("default"))) -#else -#define MONO_API_EXPORT -#endif -#define MONO_API_IMPORT - -#endif /* end of compiler-specific stuff */ - -#include - -#ifdef __cplusplus -#define MONO_EXTERN_C extern "C" -#else -#define MONO_EXTERN_C /* nothing */ -#endif - -#if defined(MONO_DLL_EXPORT) - #define MONO_API_NO_EXTERN_C MONO_API_EXPORT -#elif defined(MONO_DLL_IMPORT) - #define MONO_API_NO_EXTERN_C MONO_API_IMPORT -#else - #define MONO_API_NO_EXTERN_C /* nothing */ -#endif - -#define MONO_API MONO_EXTERN_C MONO_API_NO_EXTERN_C - -// Should (but not must) wrap in extern "C" (MONO_BEGIN_DECLS, MONO_END_DECLS). -#define MONO_API_DATA MONO_API_NO_EXTERN_C extern - -typedef int32_t mono_bool; -typedef uint8_t mono_byte; -typedef mono_byte MonoBoolean; -#ifdef _WIN32 -MONO_END_DECLS -#include -typedef wchar_t mono_unichar2; -MONO_BEGIN_DECLS -#else -typedef uint16_t mono_unichar2; -#endif -typedef uint32_t mono_unichar4; - -typedef void (*MonoFunc) (void* data, void* user_data); -typedef void (*MonoHFunc) (void* key, void* value, void* user_data); - -MONO_API void mono_free (void *); - -#define MONO_ALLOCATOR_VTABLE_VERSION 1 - -typedef struct { - int version; - void *(*malloc) (size_t size); - void *(*realloc) (void *mem, size_t count); - void (*free) (void *mem); - void *(*calloc) (size_t count, size_t size); -} MonoAllocatorVTable; - -MONO_API mono_bool -mono_set_allocator_vtable (MonoAllocatorVTable* vtable); - - -#define MONO_CONST_RETURN const - -/* - * When embedding, you have to define MONO_ZERO_LEN_ARRAY before including any - * other Mono header file if you use a different compiler from the one used to - * build Mono. - */ -#ifndef MONO_ZERO_LEN_ARRAY -#ifdef __GNUC__ -#define MONO_ZERO_LEN_ARRAY 0 -#else -#define MONO_ZERO_LEN_ARRAY 1 -#endif -#endif - -#if defined (MONO_INSIDE_RUNTIME) - -#if defined (__CENTRINEL__) -/* Centrinel is an analyzer that warns about raw pointer to managed objects - * inside Mono. - */ -#define MONO_RT_MANAGED_ATTR __CENTRINEL_MANAGED_ATTR -#define MONO_RT_CENTRINEL_SUPPRESS __CENTRINEL_SUPPRESS_ATTR(1) -#else -#define MONO_RT_MANAGED_ATTR -#define MONO_RT_CENTRINEL_SUPPRESS -#endif - -#if defined (__clang__) || defined (__GNUC__) -// attribute(deprecated(message)) was introduced in gcc 4.5. -// attribute(deprecated)) was introduced in gcc 4.0. -// Compare: https://gcc.gnu.org/onlinedocs/gcc-3.4.6/gcc/Function-Attributes.html -// https://gcc.gnu.org/onlinedocs/gcc-4.4.0/gcc/Function-Attributes.html -// https://gcc.gnu.org/onlinedocs/gcc-4.5.0/gcc/Function-Attributes.html -#if defined (__clang__) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5) -#define MONO_RT_EXTERNAL_ONLY \ - __attribute__ ((__deprecated__ ("The mono runtime must not call this function."))) \ - MONO_RT_CENTRINEL_SUPPRESS -#elif __GNUC__ >= 4 -#define MONO_RT_EXTERNAL_ONLY __attribute__ ((__deprecated__)) MONO_RT_CENTRINEL_SUPPRESS -#else -#define MONO_RT_EXTERNAL_ONLY MONO_RT_CENTRINEL_SUPPRESS -#endif - -#if defined (__clang__) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2) -// Pragmas for controlling diagnostics appear to be from gcc 4.2. -// This is used in place of configure gcc -Werror=deprecated-declarations: -// 1. To be portable across build systems. -// 2. configure is very sensitive to compiler flags; they break autoconf's probes. -// Though #2 can be mitigated by being late in configure. -#pragma GCC diagnostic error "-Wdeprecated-declarations" -#endif - -#else -#define MONO_RT_EXTERNAL_ONLY MONO_RT_CENTRINEL_SUPPRESS -#endif // clang or gcc - -#else -#define MONO_RT_EXTERNAL_ONLY -#define MONO_RT_MANAGED_ATTR -#endif /* MONO_INSIDE_RUNTIME */ - -#if defined (__clang__) || defined (__GNUC__) -#define _MONO_DEPRECATED __attribute__ ((__deprecated__)) -#elif defined (_MSC_VER) -#define _MONO_DEPRECATED __declspec (deprecated) -#else -#define _MONO_DEPRECATED -#endif - -#define MONO_DEPRECATED MONO_API MONO_RT_EXTERNAL_ONLY _MONO_DEPRECATED - -MONO_END_DECLS - -#endif /* __MONO_PUBLIB_H__ */ From dcd191dde89108d1cca961e2151f3ba56bbdc348 Mon Sep 17 00:00:00 2001 From: Peter Sollich Date: Mon, 22 Feb 2021 17:09:59 +0100 Subject: [PATCH 08/16] Introduce a config setting that triggers a compacting gen 2 collection when gen 2 fragmentation becomes too high. Details: - New config setting GCConserveMemory with values between 0 and 9 - intuitively, the higher the value, the more GC tries to keep gen 2 compact. - Implementation: the config value is considered in dt_high_frag_p as the desired percentage*10 of useful data in gen 2. In other words, 100 - config value*10 is the fragmentation threshold above which a blocking gen 2 is performed. --- src/coreclr/gc/gc.cpp | 14 +++++++++++--- src/coreclr/gc/gcconfig.h | 1 + 2 files changed, 12 insertions(+), 3 deletions(-) diff --git a/src/coreclr/gc/gc.cpp b/src/coreclr/gc/gc.cpp index 6bbe250fd9f15..ee1d49089652a 100644 --- a/src/coreclr/gc/gc.cpp +++ b/src/coreclr/gc/gc.cpp @@ -2989,17 +2989,25 @@ gc_heap::dt_high_frag_p (gc_tuning_point tp, } else { -#ifndef MULTIPLE_HEAPS if (gen_number == max_generation) { float frag_ratio = (float)(dd_fragmentation (dynamic_data_of (max_generation))) / (float)generation_size (max_generation); - if (frag_ratio > 0.65) + int conserve_mem_setting = (int)GCConfig::GetGCConserveMem(); + if (conserve_mem_setting < 0) + conserve_mem_setting = 0; + if (conserve_mem_setting > 9) + conserve_mem_setting = 9; + float frag_limit = 1.0f - conserve_mem_setting / 10.0f; +#ifndef MULTIPLE_HEAPS + if (conserve_mem_setting == 0) + frag_limit = 0.65f; +#endif //!MULTIPLE_HEAPS + if (frag_ratio > frag_limit) { dprintf (GTC_LOG, ("g2 FR: %d%%", (int)(frag_ratio*100))); return TRUE; } } -#endif //!MULTIPLE_HEAPS size_t fr = generation_unusable_fragmentation (generation_of (gen_number)); ret = (fr > dd_fragmentation_limit(dd)); if (ret) diff --git a/src/coreclr/gc/gcconfig.h b/src/coreclr/gc/gcconfig.h index e7b5e1f21804d..7998cb8805dae 100644 --- a/src/coreclr/gc/gcconfig.h +++ b/src/coreclr/gc/gcconfig.h @@ -131,6 +131,7 @@ class GCConfigStringHolder INT_CONFIG (GCHeapHardLimitLOHPercent, "GCHeapHardLimitLOHPercent", "System.GC.HeapHardLimitLOHPercent", 0, "Specifies the GC heap LOH usage as a percentage of the total memory") \ INT_CONFIG (GCHeapHardLimitPOHPercent, "GCHeapHardLimitPOHPercent", "System.GC.HeapHardLimitPOHPercent", 0, "Specifies the GC heap POH usage as a percentage of the total memory") \ INT_CONFIG (GCEnabledInstructionSets, "GCEnabledInstructionSets", NULL, -1, "Specifies whether GC can use AVX2 or AVX512F - 0 for neither, 1 for AVX2, 3 for AVX512F")\ + INT_CONFIG (GCConserveMem, "GCConserveMemory", NULL, 0, "Specifies how hard GC should try to conserve memory - values 0-9") \ // This class is responsible for retreiving configuration information // for how the GC should operate. From d4cd80ba9c72697a019679b9924bb30d4a3e9684 Mon Sep 17 00:00:00 2001 From: Peter Sollich Date: Wed, 24 Feb 2021 17:20:02 +0100 Subject: [PATCH 09/16] Add more sophistication to the conserve memory logic: - store the config setting in a static field on gc_heap, fetch & validate config in init_semi_shared. - take LOH fragmentation into account as well - trim down budgets for gen 2 and above if conserve memory setting is aggressive enough --- src/coreclr/gc/gc.cpp | 57 ++++++++++++++++++++++++++++++++++++----- src/coreclr/gc/gcpriv.h | 3 +++ 2 files changed, 54 insertions(+), 6 deletions(-) diff --git a/src/coreclr/gc/gc.cpp b/src/coreclr/gc/gc.cpp index ee1d49089652a..c55fb5254fd2c 100644 --- a/src/coreclr/gc/gc.cpp +++ b/src/coreclr/gc/gc.cpp @@ -2190,6 +2190,7 @@ double gc_heap::short_plugs_pad_ratio = 0; #endif //SHORT_PLUGS int gc_heap::generation_skip_ratio_threshold = 0; +int gc_heap::conserve_mem_setting = 0; uint64_t gc_heap::suspended_start_time = 0; uint64_t gc_heap::end_gc_time = 0; @@ -2992,11 +2993,6 @@ gc_heap::dt_high_frag_p (gc_tuning_point tp, if (gen_number == max_generation) { float frag_ratio = (float)(dd_fragmentation (dynamic_data_of (max_generation))) / (float)generation_size (max_generation); - int conserve_mem_setting = (int)GCConfig::GetGCConserveMem(); - if (conserve_mem_setting < 0) - conserve_mem_setting = 0; - if (conserve_mem_setting > 9) - conserve_mem_setting = 9; float frag_limit = 1.0f - conserve_mem_setting / 10.0f; #ifndef MULTIPLE_HEAPS if (conserve_mem_setting == 0) @@ -12014,6 +12010,12 @@ gc_heap::init_semi_shared() generation_skip_ratio_threshold = (int)GCConfig::GetGCLowSkipRatio(); + conserve_mem_setting = (int)GCConfig::GetGCConserveMem(); + if (conserve_mem_setting < 0) + conserve_mem_setting = 0; + if (conserve_mem_setting > 9) + conserve_mem_setting = 9; + ret = 1; cleanup: @@ -17674,6 +17676,39 @@ int gc_heap::joined_generation_to_condemn (BOOL should_evaluate_elevation, } } + if (conserve_mem_setting != 0) + { + float frag_limit = 1.0f - conserve_mem_setting / 10.0f; + +#ifdef MULTIPLE_HEAPS + size_t loh_size = 0; + for (int hn = 0; hn < gc_heap::n_heaps; hn++) + { + gc_heap* hp = gc_heap::g_heaps[hn]; + loh_size += hp->generation_sizes (hp->generation_of (loh_generation)); + } +#else + size_t loh_size = generation_sizes (generation_of (loh_generation)); +#endif //MULTIPLE_HEAPS + float loh_frag_ratio = 0.0f; + if (loh_size != 0) + { + size_t loh_frag = get_total_gen_fragmentation(loh_generation); + loh_frag_ratio = ((float)loh_frag) / (float)loh_size; + } + if (loh_frag_ratio > frag_limit) + { + dprintf(GTC_LOG, ("loh frag: %f > limit %f", loh_frag_ratio, frag_limit)); + gc_data_global.gen_to_condemn_reasons.set_condition (gen_joined_limit_loh_frag); + + n = max_generation; + *blocking_collection_p = TRUE; + settings.loh_compaction = TRUE; + + dprintf(GTC_LOG, ("compacting LOH due to GCConserveMem setting")); + } + } + #ifdef BGC_SERVO_TUNING if (bgc_tuning::should_trigger_ngc2()) { @@ -24500,7 +24535,7 @@ BOOL gc_heap::plan_loh() void gc_heap::compact_loh() { - assert (loh_compaction_requested() || heap_hard_limit); + assert (loh_compaction_requested() || heap_hard_limit || conserve_mem_setting); generation* gen = large_object_generation; heap_segment* start_seg = heap_segment_rw (generation_start_segment (gen)); @@ -35468,6 +35503,16 @@ size_t gc_heap::desired_new_allocation (dynamic_data* dd, cst = min (1.0f, float (out) / float (dd_begin_data_size (dd))); f = surv_to_growth (cst, limit, max_limit); + if (conserve_mem_setting != 0) + { + // if this is set, compete a growth factor based on it. + // formula below means use 50% of the allowable fragmentation + float f_conserve = (10.0f / conserve_mem_setting - 1) * 0.5f + 1.0f; + + // use the smaller one + f = min (f, f_conserve); + } + size_t max_growth_size = (size_t)(max_size / f); if (current_size >= max_growth_size) { diff --git a/src/coreclr/gc/gcpriv.h b/src/coreclr/gc/gcpriv.h index d5d5fcde9a705..a011540780129 100644 --- a/src/coreclr/gc/gcpriv.h +++ b/src/coreclr/gc/gcpriv.h @@ -4345,6 +4345,9 @@ class gc_heap PER_HEAP_ISOLATED int generation_skip_ratio_threshold; + PER_HEAP_ISOLATED + int conserve_mem_setting; + PER_HEAP BOOL gen0_bricks_cleared; PER_HEAP From 33be16643f489a264c5327d7d0e29c101310c516 Mon Sep 17 00:00:00 2001 From: Peter Sollich Date: Thu, 25 Feb 2021 11:55:03 +0100 Subject: [PATCH 10/16] Added dprintf for the setting of GCConserveMemory. --- src/coreclr/gc/gc.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/coreclr/gc/gc.cpp b/src/coreclr/gc/gc.cpp index c55fb5254fd2c..2a40516df3672 100644 --- a/src/coreclr/gc/gc.cpp +++ b/src/coreclr/gc/gc.cpp @@ -12016,6 +12016,8 @@ gc_heap::init_semi_shared() if (conserve_mem_setting > 9) conserve_mem_setting = 9; + dprintf (1, ("conserve_mem_setting = %d", conserve_mem_setting)); + ret = 1; cleanup: From 9d22ff31421ac40d2617985071b000627e77171c Mon Sep 17 00:00:00 2001 From: Peter Sollich Date: Fri, 5 Mar 2021 15:39:15 +0100 Subject: [PATCH 11/16] Fixed bitrot with FREE_USAGE_STATS, additional debug output. --- src/coreclr/gc/gc.cpp | 25 ++++++++++++++----------- src/coreclr/gc/gcpriv.h | 5 ++++- 2 files changed, 18 insertions(+), 12 deletions(-) diff --git a/src/coreclr/gc/gc.cpp b/src/coreclr/gc/gc.cpp index 3ccc10e426bff..147daf243f6b5 100644 --- a/src/coreclr/gc/gc.cpp +++ b/src/coreclr/gc/gc.cpp @@ -11481,9 +11481,9 @@ void gc_heap::make_generation (int gen_num, heap_segment* seg, uint8_t* start) #endif //DOUBLY_LINKED_FL #ifdef FREE_USAGE_STATS - memset (gen->gen_free_spaces, 0, sizeof (gen.gen_free_spaces)); - memset (gen->gen_current_pinned_free_spaces, 0, sizeof (gen.gen_current_pinned_free_spaces)); - memset (gen->gen_plugs, 0, sizeof (gen.gen_plugs)); + memset (gen->gen_free_spaces, 0, sizeof (gen->gen_free_spaces)); + memset (gen->gen_current_pinned_free_spaces, 0, sizeof (gen->gen_current_pinned_free_spaces)); + memset (gen->gen_plugs, 0, sizeof (gen->gen_plugs)); #endif //FREE_USAGE_STATS } @@ -16413,7 +16413,6 @@ void gc_heap::init_free_and_plug() #else memset (gen->gen_free_spaces, 0, sizeof (gen->gen_free_spaces)); #endif //DOUBLY_LINKED_FL - memset (gen->gen_plugs_allocated_in_free, 0, sizeof (gen->gen_plugs_allocated_in_free)); memset (gen->gen_plugs, 0, sizeof (gen->gen_plugs)); memset (gen->gen_current_pinned_free_spaces, 0, sizeof (gen->gen_current_pinned_free_spaces)); } @@ -16431,7 +16430,7 @@ void gc_heap::init_free_and_plug() void gc_heap::print_free_and_plug (const char* msg) { -#if defined(FREE_USAGE_STATS) && defined(SIMPLE_DPRINTF) +#ifdef FREE_USAGE_STATS int older_gen = ((settings.condemned_generation == max_generation) ? max_generation : (settings.condemned_generation + 1)); for (int i = 0; i <= older_gen; i++) { @@ -16452,7 +16451,7 @@ void gc_heap::print_free_and_plug (const char* msg) } #else UNREFERENCED_PARAMETER(msg); -#endif //FREE_USAGE_STATS && SIMPLE_DPRINTF +#endif //FREE_USAGE_STATS } // replace with allocator::first_suitable_bucket @@ -16524,8 +16523,8 @@ void gc_heap::add_gen_free (int gen_number, size_t free_size) (gen->gen_free_spaces[i])++; if (gen_number == max_generation) { - dprintf (3, ("Mb b%d: f+ %Id (%Id->%Id)", - i, free_size, (gen->gen_free_spaces[i]).num_items, (gen->gen_free_spaces[i]).total_size)); +// dprintf (3, ("Mb b%d: f+ %Id (%Id->%Id)", +// i, free_size, (gen->gen_free_spaces[i]).num_items, (gen->gen_free_spaces[i]).total_size)); } #else UNREFERENCED_PARAMETER(gen_number); @@ -16547,8 +16546,8 @@ void gc_heap::remove_gen_free (int gen_number, size_t free_size) (gen->gen_free_spaces[i])--; if (gen_number == max_generation) { - dprintf (3, ("Mb b%d: f- %Id (%Id->%Id)", - i, free_size, (gen->gen_free_spaces[i]).num_items, (gen->gen_free_spaces[i]).total_size)); +// dprintf (3, ("Mb b%d: f- %Id (%Id->%Id)", +// i, free_size, (gen->gen_free_spaces[i]).num_items, (gen->gen_free_spaces[i]).total_size)); } #else UNREFERENCED_PARAMETER(gen_number); @@ -16658,6 +16657,8 @@ uint8_t* gc_heap::allocate_in_older_generation (generation* gen, size_t size, for (unsigned int a_l_idx = gen_allocator->first_suitable_bucket(real_size * 2); a_l_idx < gen_allocator->number_of_buckets(); a_l_idx++) { + dprintf (3, ("trying free list bucket %u for size %Id", a_l_idx, real_size)); + uint8_t* free_list = 0; uint8_t* prev_free_item = 0; @@ -35515,7 +35516,7 @@ size_t gc_heap::desired_new_allocation (dynamic_data* dd, f = surv_to_growth (cst, limit, max_limit); if (conserve_mem_setting != 0) { - // if this is set, compete a growth factor based on it. + // if this is set, compute a growth factor based on it. // formula below means use 50% of the allowable fragmentation float f_conserve = (10.0f / conserve_mem_setting - 1) * 0.5f + 1.0f; @@ -35644,6 +35645,8 @@ size_t gc_heap::desired_new_allocation (dynamic_data* dd, heap_number, gen_number, out, current_size, (dd_desired_allocation (dd) - dd_gc_new_allocation (dd)), (int)(cst*100), (int)(f*100), current_size + new_allocation, new_allocation)); + dprintf (2, ("heap%d gen%d size: %Id MB fragmentation: %Id MB", heap_number, gen_number, generation_size (gen_number)/(1924*1024), dd_fragmentation (dd)/(1924*1024))); + return new_allocation_ret; } } diff --git a/src/coreclr/gc/gcpriv.h b/src/coreclr/gc/gcpriv.h index 1a8200dead16c..1e24ca8c0da1e 100644 --- a/src/coreclr/gc/gcpriv.h +++ b/src/coreclr/gc/gcpriv.h @@ -144,7 +144,7 @@ inline void FATAL_GC_ERROR() #define MAX_LONGPATH 1024 #endif // MAX_LONGPATH -//#define TRACE_GC +#define TRACE_GC //#define SIMPLE_DPRINTF //#define JOIN_STATS //amount of time spent in the join @@ -152,6 +152,8 @@ inline void FATAL_GC_ERROR() //#define SYNCHRONIZATION_STATS //#define SEG_REUSE_STATS +#define FREE_USAGE_STATS + #ifdef SYNCHRONIZATION_STATS #define BEGIN_TIMING(x) \ int64_t x##_start; \ @@ -271,6 +273,7 @@ void GCLog (const char *fmt, ... ); // to do so. //#define dprintf(l, x) #define dprintf(l,x) STRESS_LOG_VA(l,x); +//#define dprintf(l,x) {if ((l <= 2) || (l == GTC_LOG)) { STRESS_LOG_VA(l,x);}} #endif //SIMPLE_DPRINTF From 6f0e5941ac83ec58eb89076ebe278e803392533f Mon Sep 17 00:00:00 2001 From: Peter Sollich Date: Thu, 11 Mar 2021 14:14:48 +0100 Subject: [PATCH 12/16] Disable mechanism to reduce budget for gen 2 if conserve_mem_setting is on. --- src/coreclr/gc/gc.cpp | 1 + .../x64-Debug/.cmake/api/v1/query/client-MicrosoftVS/query.json | 1 + .../Native/Unix/out/build/x64-Debug/VSInheritEnvironments.txt | 1 + .../x64-Debug/.cmake/api/v1/query/client-MicrosoftVS/query.json | 1 + .../Native/Windows/out/build/x64-Debug/VSInheritEnvironments.txt | 1 + 5 files changed, 5 insertions(+) create mode 100644 src/libraries/Native/Unix/out/build/x64-Debug/.cmake/api/v1/query/client-MicrosoftVS/query.json create mode 100644 src/libraries/Native/Unix/out/build/x64-Debug/VSInheritEnvironments.txt create mode 100644 src/libraries/Native/Windows/out/build/x64-Debug/.cmake/api/v1/query/client-MicrosoftVS/query.json create mode 100644 src/libraries/Native/Windows/out/build/x64-Debug/VSInheritEnvironments.txt diff --git a/src/coreclr/gc/gc.cpp b/src/coreclr/gc/gc.cpp index 147daf243f6b5..ae5a74669c242 100644 --- a/src/coreclr/gc/gc.cpp +++ b/src/coreclr/gc/gc.cpp @@ -35547,6 +35547,7 @@ size_t gc_heap::desired_new_allocation (dynamic_data* dd, #ifdef BGC_SERVO_TUNING !bgc_tuning::fl_tuning_triggered && #endif //BGC_SERVO_TUNING + (conserve_mem_setting == 0) && (dd_fragmentation (dd) > ((size_t)((f-1)*current_size)))) { //reducing allocation in case of fragmentation diff --git a/src/libraries/Native/Unix/out/build/x64-Debug/.cmake/api/v1/query/client-MicrosoftVS/query.json b/src/libraries/Native/Unix/out/build/x64-Debug/.cmake/api/v1/query/client-MicrosoftVS/query.json new file mode 100644 index 0000000000000..308f68dd8c5fa --- /dev/null +++ b/src/libraries/Native/Unix/out/build/x64-Debug/.cmake/api/v1/query/client-MicrosoftVS/query.json @@ -0,0 +1 @@ +{"requests":[{"kind":"cache","version":2},{"kind":"cmakeFiles","version":1},{"kind":"codemodel","version":2}]} \ No newline at end of file diff --git a/src/libraries/Native/Unix/out/build/x64-Debug/VSInheritEnvironments.txt b/src/libraries/Native/Unix/out/build/x64-Debug/VSInheritEnvironments.txt new file mode 100644 index 0000000000000..f8cc9d8acecec --- /dev/null +++ b/src/libraries/Native/Unix/out/build/x64-Debug/VSInheritEnvironments.txt @@ -0,0 +1 @@ +msvc_x64_x64 \ No newline at end of file diff --git a/src/libraries/Native/Windows/out/build/x64-Debug/.cmake/api/v1/query/client-MicrosoftVS/query.json b/src/libraries/Native/Windows/out/build/x64-Debug/.cmake/api/v1/query/client-MicrosoftVS/query.json new file mode 100644 index 0000000000000..308f68dd8c5fa --- /dev/null +++ b/src/libraries/Native/Windows/out/build/x64-Debug/.cmake/api/v1/query/client-MicrosoftVS/query.json @@ -0,0 +1 @@ +{"requests":[{"kind":"cache","version":2},{"kind":"cmakeFiles","version":1},{"kind":"codemodel","version":2}]} \ No newline at end of file diff --git a/src/libraries/Native/Windows/out/build/x64-Debug/VSInheritEnvironments.txt b/src/libraries/Native/Windows/out/build/x64-Debug/VSInheritEnvironments.txt new file mode 100644 index 0000000000000..f8cc9d8acecec --- /dev/null +++ b/src/libraries/Native/Windows/out/build/x64-Debug/VSInheritEnvironments.txt @@ -0,0 +1 @@ +msvc_x64_x64 \ No newline at end of file From 240e4199ca00f1134b0b153f78afcc274180831a Mon Sep 17 00:00:00 2001 From: Peter Sollich Date: Mon, 22 Mar 2021 10:57:15 +0100 Subject: [PATCH 13/16] Update logic to look at the combined fragmentation in gen 2 and LOH to make the compaction decision. Also, only do the computations only for gen 1 GCs to cut down on the back-to-back gen 2 GCs that we were observing. --- src/coreclr/gc/gc.cpp | 29 +++++++++++++++++++---------- 1 file changed, 19 insertions(+), 10 deletions(-) diff --git a/src/coreclr/gc/gc.cpp b/src/coreclr/gc/gc.cpp index f6038e64ecdb3..7b0d81bd88111 100644 --- a/src/coreclr/gc/gc.cpp +++ b/src/coreclr/gc/gc.cpp @@ -17649,36 +17649,45 @@ int gc_heap::joined_generation_to_condemn (BOOL should_evaluate_elevation, } } - if (conserve_mem_setting != 0) + if ((conserve_mem_setting != 0) && (n >= (max_generation-1))) { float frag_limit = 1.0f - conserve_mem_setting / 10.0f; #ifdef MULTIPLE_HEAPS size_t loh_size = 0; + size_t gen2_size = 0; for (int hn = 0; hn < gc_heap::n_heaps; hn++) { gc_heap* hp = gc_heap::g_heaps[hn]; - loh_size += hp->generation_sizes (hp->generation_of (loh_generation)); + loh_size += hp->generation_sizes (hp->generation_of (loh_generation)); + gen2_size += hp->generation_sizes (hp->generation_of (max_generation)); } #else - size_t loh_size = generation_sizes (generation_of (loh_generation)); + size_t loh_size = generation_sizes (generation_of (loh_generation)); + size_t gen2_size = generation_sizes (generation_of (max_generation)); #endif //MULTIPLE_HEAPS float loh_frag_ratio = 0.0f; + float combined_frag_ratio = 0.0f; if (loh_size != 0) { - size_t loh_frag = get_total_gen_fragmentation(loh_generation); - loh_frag_ratio = ((float)loh_frag) / (float)loh_size; + size_t loh_frag = get_total_gen_fragmentation (loh_generation); + size_t gen2_frag = get_total_gen_fragmentation (max_generation); + loh_frag_ratio = (float)loh_frag / (float)loh_size; + combined_frag_ratio = (float)(gen2_frag + loh_frag) / (float)(gen2_size + loh_size); } - if (loh_frag_ratio > frag_limit) + if (combined_frag_ratio > frag_limit) { - dprintf(GTC_LOG, ("loh frag: %f > limit %f", loh_frag_ratio, frag_limit)); - gc_data_global.gen_to_condemn_reasons.set_condition (gen_joined_limit_loh_frag); + dprintf (GTC_LOG, ("combined frag: %f > limit %f, loh frag: %f", combined_frag_ratio, frag_limit, loh_frag_ratio)); + gc_data_global.gen_to_condemn_reasons.set_condition (gen_max_high_frag_p); n = max_generation; *blocking_collection_p = TRUE; - settings.loh_compaction = TRUE; + if (loh_frag_ratio > frag_limit) + { + settings.loh_compaction = TRUE; - dprintf(GTC_LOG, ("compacting LOH due to GCConserveMem setting")); + dprintf (GTC_LOG, ("compacting LOH due to GCConserveMem setting")); + } } } From e9ce602bd8ae2e11811c889ea6bc28a5bf854c7c Mon Sep 17 00:00:00 2001 From: Peter Sollich Date: Tue, 1 Jun 2021 17:42:37 +0200 Subject: [PATCH 14/16] Base decision on fully compacting GC in the hard limit case on the combined fragmentation in gen 2 + loh, rather than just the fragmentation in loh. --- src/coreclr/gc/gc.cpp | 52 +++++++++++++++++++++++------------------ src/coreclr/gc/gcpriv.h | 2 ++ 2 files changed, 31 insertions(+), 23 deletions(-) diff --git a/src/coreclr/gc/gc.cpp b/src/coreclr/gc/gc.cpp index a11d327c59adb..b43a6cfe9a431 100644 --- a/src/coreclr/gc/gc.cpp +++ b/src/coreclr/gc/gc.cpp @@ -18061,26 +18061,28 @@ int gc_heap::joined_generation_to_condemn (BOOL should_evaluate_elevation, } else if ((current_total_committed * 10) >= (heap_hard_limit * 9)) { - size_t loh_frag = get_total_gen_fragmentation (loh_generation); + size_t combined_frag = get_total_gen_fragmentation(max_generation) + + get_total_gen_fragmentation(loh_generation); - // If the LOH frag is >= 1/8 it's worth compacting it - if ((loh_frag * 8) >= heap_hard_limit) + // If the combined frag is >= 1/8 it's worth compacting + if ((combined_frag * 8) >= heap_hard_limit) { - dprintf (GTC_LOG, ("loh frag: %Id > 1/8 of limit %Id", loh_frag, (heap_hard_limit / 8))); + dprintf (GTC_LOG, ("gen2+loh frag: %Id > 1/8 of limit %Id", combined_frag, (heap_hard_limit / 8))); gc_data_global.gen_to_condemn_reasons.set_condition(gen_joined_limit_loh_frag); full_compact_gc_p = true; } else { // If there's not much fragmentation but it looks like it'll be productive to - // collect LOH, do that. - size_t est_loh_reclaim = get_total_gen_estimated_reclaim (loh_generation); - if ((est_loh_reclaim * 8) >= heap_hard_limit) + // collect, do that. + size_t est_combined_reclaim = get_total_gen_estimated_reclaim (max_generation) + + get_total_gen_estimated_reclaim(loh_generation); + if ((est_combined_reclaim * 8) >= heap_hard_limit) { gc_data_global.gen_to_condemn_reasons.set_condition(gen_joined_limit_loh_reclaim); full_compact_gc_p = true; } - dprintf (GTC_LOG, ("loh est reclaim: %Id, 1/8 of limit %Id", est_loh_reclaim, (heap_hard_limit / 8))); + dprintf (GTC_LOG, ("gen2+loh est reclaim: %Id, 1/8 of limit %Id", est_combined_reclaim, (heap_hard_limit / 8))); } } @@ -18089,27 +18091,16 @@ int gc_heap::joined_generation_to_condemn (BOOL should_evaluate_elevation, n = max_generation; *blocking_collection_p = TRUE; settings.loh_compaction = TRUE; - dprintf (GTC_LOG, ("compacting LOH due to hard limit")); + dprintf (GTC_LOG, ("compacting gen2+loh due to hard limit")); } } - if ((conserve_mem_setting != 0) && (n >= (max_generation-1))) + if ((conserve_mem_setting != 0) && (n >= max_generation)) { float frag_limit = 1.0f - conserve_mem_setting / 10.0f; -#ifdef MULTIPLE_HEAPS - size_t loh_size = 0; - size_t gen2_size = 0; - for (int hn = 0; hn < gc_heap::n_heaps; hn++) - { - gc_heap* hp = gc_heap::g_heaps[hn]; - loh_size += hp->generation_sizes (hp->generation_of (loh_generation)); - gen2_size += hp->generation_sizes (hp->generation_of (max_generation)); - } -#else - size_t loh_size = generation_sizes (generation_of (loh_generation)); - size_t gen2_size = generation_sizes (generation_of (max_generation)); -#endif //MULTIPLE_HEAPS + size_t loh_size = get_total_gen_size (loh_generation); + size_t gen2_size = get_total_gen_size (max_generation); float loh_frag_ratio = 0.0f; float combined_frag_ratio = 0.0f; if (loh_size != 0) @@ -23203,6 +23194,21 @@ size_t gc_heap::get_total_gen_estimated_reclaim (int gen_number) return total_estimated_reclaim; } +size_t gc_heap::get_total_gen_size (int gen_number) +{ +#ifdef MULTIPLE_HEAPS + size_t size = 0; + for (int hn = 0; hn < gc_heap::n_heaps; hn++) + { + gc_heap* hp = gc_heap::g_heaps[hn]; + size += hp->generation_sizes (hp->generation_of (gen_number)); + } +#else + size_t size = generation_sizes (generation_of (gen_number)); +#endif //MULTIPLE_HEAPS + return size; +} + size_t gc_heap::committed_size() { size_t total_committed = 0; diff --git a/src/coreclr/gc/gcpriv.h b/src/coreclr/gc/gcpriv.h index 1b02070bd2364..c20ebe672e8a6 100644 --- a/src/coreclr/gc/gcpriv.h +++ b/src/coreclr/gc/gcpriv.h @@ -3112,6 +3112,8 @@ class gc_heap PER_HEAP_ISOLATED size_t get_total_gen_estimated_reclaim (int gen_number); PER_HEAP_ISOLATED + size_t get_total_gen_size (int gen_number); + PER_HEAP_ISOLATED void get_memory_info (uint32_t* memory_load, uint64_t* available_physical=NULL, uint64_t* available_page_file=NULL); From e38e6f036e0a4ecb025f7ff0d5d62a767b1e2418 Mon Sep 17 00:00:00 2001 From: Peter Sollich Date: Tue, 3 Aug 2021 12:27:35 +0200 Subject: [PATCH 15/16] Fix dprintfs that had bitrotted and were commented out, turned off TRACE_GC and removed debugging code. --- runtime-1.wsp | 13 +++++++++++++ src/coreclr/gc/gc.cpp | 8 ++++---- src/coreclr/gc/gcpriv.h | 5 ++--- .../api/v1/query/client-MicrosoftVS/query.json | 1 - .../out/build/x64-Debug/VSInheritEnvironments.txt | 1 - .../api/v1/query/client-MicrosoftVS/query.json | 1 - .../out/build/x64-Debug/VSInheritEnvironments.txt | 1 - 7 files changed, 19 insertions(+), 11 deletions(-) create mode 100644 runtime-1.wsp delete mode 100644 src/libraries/Native/Unix/out/build/x64-Debug/.cmake/api/v1/query/client-MicrosoftVS/query.json delete mode 100644 src/libraries/Native/Unix/out/build/x64-Debug/VSInheritEnvironments.txt delete mode 100644 src/libraries/Native/Windows/out/build/x64-Debug/.cmake/api/v1/query/client-MicrosoftVS/query.json delete mode 100644 src/libraries/Native/Windows/out/build/x64-Debug/VSInheritEnvironments.txt diff --git a/runtime-1.wsp b/runtime-1.wsp new file mode 100644 index 0000000000000..a26ac421e5ac9 --- /dev/null +++ b/runtime-1.wsp @@ -0,0 +1,13 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.31424.327 +MinimumVisualStudioVersion = 10.0.40219.1 +Global + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {678C61E1-6BE8-4BEF-8BD5-72C64BA9835C} + EndGlobalSection +EndGlobal diff --git a/src/coreclr/gc/gc.cpp b/src/coreclr/gc/gc.cpp index e7ca94e6824d4..033b5b8ec0e76 100644 --- a/src/coreclr/gc/gc.cpp +++ b/src/coreclr/gc/gc.cpp @@ -17083,8 +17083,8 @@ void gc_heap::add_gen_free (int gen_number, size_t free_size) (gen->gen_free_spaces[i])++; if (gen_number == max_generation) { -// dprintf (3, ("Mb b%d: f+ %Id (%Id->%Id)", -// i, free_size, (gen->gen_free_spaces[i]).num_items, (gen->gen_free_spaces[i]).total_size)); + dprintf (3, ("Mb b%d: f+ %Id (%Id)", + i, free_size, gen->gen_free_spaces[i])); } #else UNREFERENCED_PARAMETER(gen_number); @@ -17106,8 +17106,8 @@ void gc_heap::remove_gen_free (int gen_number, size_t free_size) (gen->gen_free_spaces[i])--; if (gen_number == max_generation) { -// dprintf (3, ("Mb b%d: f- %Id (%Id->%Id)", -// i, free_size, (gen->gen_free_spaces[i]).num_items, (gen->gen_free_spaces[i]).total_size)); + dprintf (3, ("Mb b%d: f- %Id (%Id)", + i, free_size, gen->gen_free_spaces[i])); } #else UNREFERENCED_PARAMETER(gen_number); diff --git a/src/coreclr/gc/gcpriv.h b/src/coreclr/gc/gcpriv.h index d560985e854c6..fa2026c6e3def 100644 --- a/src/coreclr/gc/gcpriv.h +++ b/src/coreclr/gc/gcpriv.h @@ -139,7 +139,7 @@ inline void FATAL_GC_ERROR() #define MAX_LONGPATH 1024 #endif // MAX_LONGPATH -#define TRACE_GC +//#define TRACE_GC //#define SIMPLE_DPRINTF //#define JOIN_STATS //amount of time spent in the join @@ -147,7 +147,7 @@ inline void FATAL_GC_ERROR() //#define SYNCHRONIZATION_STATS //#define SEG_REUSE_STATS -#define FREE_USAGE_STATS +//#define FREE_USAGE_STATS #ifdef SYNCHRONIZATION_STATS #define BEGIN_TIMING(x) \ @@ -268,7 +268,6 @@ void GCLog (const char *fmt, ... ); // to do so. //#define dprintf(l, x) #define dprintf(l,x) STRESS_LOG_VA(l,x); -//#define dprintf(l,x) {if ((l <= 2) || (l == GTC_LOG)) { STRESS_LOG_VA(l,x);}} #endif //SIMPLE_DPRINTF diff --git a/src/libraries/Native/Unix/out/build/x64-Debug/.cmake/api/v1/query/client-MicrosoftVS/query.json b/src/libraries/Native/Unix/out/build/x64-Debug/.cmake/api/v1/query/client-MicrosoftVS/query.json deleted file mode 100644 index 308f68dd8c5fa..0000000000000 --- a/src/libraries/Native/Unix/out/build/x64-Debug/.cmake/api/v1/query/client-MicrosoftVS/query.json +++ /dev/null @@ -1 +0,0 @@ -{"requests":[{"kind":"cache","version":2},{"kind":"cmakeFiles","version":1},{"kind":"codemodel","version":2}]} \ No newline at end of file diff --git a/src/libraries/Native/Unix/out/build/x64-Debug/VSInheritEnvironments.txt b/src/libraries/Native/Unix/out/build/x64-Debug/VSInheritEnvironments.txt deleted file mode 100644 index f8cc9d8acecec..0000000000000 --- a/src/libraries/Native/Unix/out/build/x64-Debug/VSInheritEnvironments.txt +++ /dev/null @@ -1 +0,0 @@ -msvc_x64_x64 \ No newline at end of file diff --git a/src/libraries/Native/Windows/out/build/x64-Debug/.cmake/api/v1/query/client-MicrosoftVS/query.json b/src/libraries/Native/Windows/out/build/x64-Debug/.cmake/api/v1/query/client-MicrosoftVS/query.json deleted file mode 100644 index 308f68dd8c5fa..0000000000000 --- a/src/libraries/Native/Windows/out/build/x64-Debug/.cmake/api/v1/query/client-MicrosoftVS/query.json +++ /dev/null @@ -1 +0,0 @@ -{"requests":[{"kind":"cache","version":2},{"kind":"cmakeFiles","version":1},{"kind":"codemodel","version":2}]} \ No newline at end of file diff --git a/src/libraries/Native/Windows/out/build/x64-Debug/VSInheritEnvironments.txt b/src/libraries/Native/Windows/out/build/x64-Debug/VSInheritEnvironments.txt deleted file mode 100644 index f8cc9d8acecec..0000000000000 --- a/src/libraries/Native/Windows/out/build/x64-Debug/VSInheritEnvironments.txt +++ /dev/null @@ -1 +0,0 @@ -msvc_x64_x64 \ No newline at end of file From 13a8e47edcbbd563349e35459abe45e98e17fe35 Mon Sep 17 00:00:00 2001 From: Peter Sollich Date: Tue, 3 Aug 2021 12:36:22 +0200 Subject: [PATCH 16/16] Remove extra file. --- runtime-1.wsp | 13 ------------- 1 file changed, 13 deletions(-) delete mode 100644 runtime-1.wsp diff --git a/runtime-1.wsp b/runtime-1.wsp deleted file mode 100644 index a26ac421e5ac9..0000000000000 --- a/runtime-1.wsp +++ /dev/null @@ -1,13 +0,0 @@ - -Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio Version 16 -VisualStudioVersion = 16.0.31424.327 -MinimumVisualStudioVersion = 10.0.40219.1 -Global - GlobalSection(SolutionProperties) = preSolution - HideSolutionNode = FALSE - EndGlobalSection - GlobalSection(ExtensibilityGlobals) = postSolution - SolutionGuid = {678C61E1-6BE8-4BEF-8BD5-72C64BA9835C} - EndGlobalSection -EndGlobal