/src/mono/dlls @thaystg @lambdageek
+/src/native/public/mono @marek-safar @lambdageek
+
# Obsoletions / Custom Diagnostics
/docs/project/list-of-diagnostics.md @jeffhandley
#include <eventpipe/ep.h>
#include <eglib/test/test.h>
-#include <mono/mini/jit.h>
+#include <mono/jit/jit.h>
#include <mono/metadata/assembly.h>
MonoDomain *eventpipe_test_domain;
#include <eventpipe/ep.h>
#include <eglib/test/test.h>
-#include <mono/mini/jit.h>
+#include <mono/jit/jit.h>
#define TEST_FILE "./ep_test_create_file.txt"
#define TEST_FILE_2 "./ep_test_create_file_2.txt"
#include <mono/metadata/loader-internals.h>
#include <mono/metadata/mempool-internals.h>
#include <mono/metadata/handle-decl.h>
-#include <mono/mini/mono-private-unstable.h>
+#include <mono/jit/mono-private-unstable.h>
G_BEGIN_DECLS
#include <mono/metadata/loader-internals.h>
#include <mono/metadata/mempool-internals.h>
#include <mono/metadata/handle-decl.h>
-#include <mono/mini/mono-private-unstable.h>
+#include <mono/jit/mono-private-unstable.h>
G_BEGIN_DECLS
#include <sys/types.h>
#include "mini.h"
-#include <mono/mini/mono-private-unstable.h>
+#include <mono/jit/mono-private-unstable.h>
#include "interp/interp.h"
#ifdef TARGET_WASM
#include "aot-runtime.h"
#include "jit-icalls.h"
#include "mini-runtime.h"
-#include <mono/mini/mono-private-unstable.h>
+#include <mono/jit/mono-private-unstable.h>
#include "llvmonly-runtime.h"
#include <mono/metadata/components.h>
#include "mini.h"
#include "mini-runtime.h"
-#include <mono/mini/jit.h>
+#include <mono/jit/jit.h>
#include "config.h"
#include <mono/metadata/verify.h>
#include <mono/metadata/mono-config.h>
#include <mono/mini/debugger-agent-external.h>
#include "mini.h"
-#include <mono/mini/jit.h>
+#include <mono/jit/jit.h>
#include "aot-compiler.h"
#include "aot-runtime.h"
#include "mini-runtime.h"
#include "ir-emit.h"
#include "jit-icalls.h"
-#include <mono/mini/jit.h>
+#include <mono/jit/jit.h>
#include "seq-points.h"
#include "aot-compiler.h"
#include "mini-llvm.h"
#include "mini-arch.h"
#include "regalloc.h"
#include "mini-unwind.h"
-#include <mono/mini/jit.h>
+#include <mono/jit/jit.h>
#include "cfgdump.h"
#include "tiered.h"
#define _MONO_MINI_MONOVM_H_
#include <mono/utils/mono-publib.h>
-#include <mono/mini/mono-private-unstable.h>
+#include <mono/jit/mono-private-unstable.h>
// MonoVM equivalents of the CoreCLR hosting API and helpers
// Only functional on netcore builds
#include <mono/metadata/class-internals.h>
#include <mono/metadata/debug-helpers.h>
#include <mono/utils/mono-publib.h>
-#include <mono/mini/jit.h>
+#include <mono/jit/jit.h>
#include <mono/utils/mono-logger-internals.h>
#include <mono/utils/mono-os-mutex.h>
#include <mono/utils/mono-threads.h>
#include <mono/metadata/class-internals.h>
#include <mono/metadata/object-internals.h>
-#include <mono/mini/jit.h>
+#include <mono/jit/jit.h>
#include <mono/utils/atomic.h>
#include <mono/utils/hazard-pointer.h>
#include <mono/metadata/tabledefs.h>
#include <mono/metadata/threads.h>
#include <mono/metadata/threads-types.h>
-#include <mono/mini/jit.h>
+#include <mono/jit/jit.h>
#include <mono/utils/atomic.h>
#include <mono/utils/hazard-pointer.h>
#include <mono/utils/lock-free-alloc.h>
*/
#define _TESTCASE_
-#include <mono/mini/jit.h>
+#include <mono/jit/jit.h>
#include <embed/test-invoke.c>
#include <mono/metadata/class-internals.h>
#include <mono/metadata/appdomain.h>
#include <mono/metadata/debug-helpers.h>
-#include <mono/mini/jit.h>
+#include <mono/jit/jit.h>
#include <mono/utils/mono-error-internals.h>
#define TESTPROG "callspec.exe"
*/
#define _TESTCASE_
-#include <mono/mini/jit.h>
+#include <mono/jit/jit.h>
#include <embed/teste.c>
#include "config.h"
#include <stdio.h>
#include "metadata/object-internals.h"
-#include "mini/jit.h"
+#include <mono/jit/jit.h>
static int
new_string_ok (void)
#include <mono/utils/mono-logger.h>
#include <mono/utils/mono-dl-fallback.h>
-#include <mono/mini/jit.h>
-#include <mono/mini/mono-private-unstable.h>
+#include <mono/jit/jit.h>
+#include <mono/jit/mono-private-unstable.h>
#include "wasm/runtime/pinvoke.h"
#include <stdint.h>
#include <assert.h>
+#include <mono/metadata/appdomain.h>
+#include <mono/metadata/class.h>
+#include <mono/metadata/loader.h>
+#include <mono/metadata/object.h>
#include <mono/jit/jit.h>
//JS funcs
#include <dlfcn.h>
#include <sys/stat.h>
+#include <mono/metadata/appdomain.h>
#include <mono/metadata/assembly.h>
+#include <mono/metadata/class.h>
#include <mono/metadata/tokentype.h>
#include <mono/metadata/threads.h>
#include <mono/metadata/image.h>
+#include <mono/metadata/loader.h>
#include <mono/metadata/mono-gc.h>
+#include <mono/metadata/object.h>
// FIXME: unavailable in emscripten
// #include <mono/metadata/gc-internals.h>
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoDomain *, mono_jit_init, (const char *file))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoDomain *, mono_jit_init_version, (const char *root_domain_name, const char *runtime_version))
+
+MONO_API_FUNCTION(MonoDomain *, mono_jit_init_version_for_test_only, (const char *root_domain_name, const char *runtime_version))
+
+MONO_API_FUNCTION(int, mono_jit_exec, (MonoDomain *domain, MonoAssembly *assembly, int argc, char *argv[]))
+MONO_API_FUNCTION(void, mono_jit_cleanup, (MonoDomain *domain))
+
+MONO_API_FUNCTION(mono_bool, mono_jit_set_trace_options, (const char* options))
+
+MONO_API_FUNCTION(void, mono_set_signal_chaining, (mono_bool chain_signals))
+
+MONO_API_FUNCTION(void, mono_set_crash_chaining, (mono_bool chain_signals))
+
+/**
+ * This function is deprecated, use mono_jit_set_aot_mode instead.
+ */
+MONO_API_FUNCTION(void, mono_jit_set_aot_only, (mono_bool aot_only))
+
+MONO_API_FUNCTION(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_FUNCTION(mono_bool, mono_jit_aot_compiling, (void))
+
+MONO_API_FUNCTION(void, mono_set_break_policy, (MonoBreakPolicyFunc policy_callback))
+
+MONO_API_FUNCTION(void, mono_jit_parse_options, (int argc, char * argv[]))
+
+MONO_API_FUNCTION(char*, mono_get_runtime_build_info, (void))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_set_use_llvm, (mono_bool use_llvm))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_aot_register_module, (void **aot_info))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoDomain*, mono_jit_thread_attach, (MonoDomain *domain))
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+#ifndef _MONO_JIT_TYPES_H
+#define _MONO_JIT_TYPES_H
+
+#include <mono/metadata/details/appdomain-types.h>
+
+MONO_BEGIN_DECLS
+
+/**
+ * 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,
+ /*
+ * Use interpreter only, no native code is generated
+ * at runtime. Trampolines are loaded from corlib aot image.
+ */
+ 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;
+
+/* 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_END_DECLS
+
+#endif /* _MONO_JIT_TYPES_H */
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+/**
+ *
+ * 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.
+ *
+ */
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_install_load_aot_data_hook, (MonoLoadAotDataFunc load_func, MonoFreeAotDataFunc free_func, void* user_data))
+
+MONO_API_FUNCTION(int, monovm_initialize, (int propertyCount, const char **propertyKeys, const char **propertyValues))
+
+MONO_API_FUNCTION(int, monovm_runtimeconfig_initialize, (MonovmRuntimeConfigArguments *arg, MonovmRuntimeConfigArgumentsCleanup cleanup_fn, void *user_data))
+
+// The wrapper MonoCoreRuntimeProperties struct can be stack-allocated or freed, but the structs inside it _must_ be heap-allocated and never freed, as they are not copied to avoid extra allocations
+MONO_API_FUNCTION(int, monovm_initialize_preparsed, (MonoCoreRuntimeProperties *parsed_properties, int propertyCount, const char **propertyKeys, const char **propertyValues))
+
+//#ifdef HOST_WASM
+MONO_API_FUNCTION(void, mono_wasm_install_get_native_to_interp_tramp, (MonoWasmGetNativeToInterpTramp cb))
+//#endif
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
/**
- * \file
*
* Private unstable APIs.
*
* any time.
*
*/
+#ifndef _MONO_JIT_PRIVATE_UNSTABLE_TYPES_H
+#define _MONO_JIT_PRIVATE_UNSTABLE_TYPES_H
+#include <mono/utils/details/mono-publib-types.h>
+#include <mono/metadata/details/image-types.h>
+#include <mono/metadata/details/mono-private-unstable-types.h>
-#ifndef __MONO_JIT_MONO_PRIVATE_UNSTABLE_H__
-#define __MONO_JIT_MONO_PRIVATE_UNSTABLE_H__
-
-#include <mono/utils/mono-publib.h>
-#include <mono/metadata/image.h>
-#include <mono/metadata/mono-private-unstable.h>
+MONO_BEGIN_DECLS
typedef struct {
uint32_t kind; // 0 = Path of runtimeconfig.blob, 1 = pointer to image data, >= 2 undefined
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);
-
-MONO_API int
-monovm_runtimeconfig_initialize (MonovmRuntimeConfigArguments *arg, MonovmRuntimeConfigArgumentsCleanup cleanup_fn, void *user_data);
-
-// The wrapper MonoCoreRuntimeProperties struct can be stack-allocated or freed, but the structs inside it _must_ be heap-allocated and never freed, as they are not copied to avoid extra allocations
-MONO_API int
-monovm_initialize_preparsed (MonoCoreRuntimeProperties *parsed_properties, 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__*/
+MONO_END_DECLS
+
+#endif /* _MONO_JIT_PRIVATE_UNSTABLE_TYPES_H */
--- /dev/null
+/**
+ * \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/jit/details/jit-types.h>
+
+MONO_BEGIN_DECLS
+
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/jit/details/jit-functions.h>
+#undef MONO_API_FUNCTION
+
+MONO_END_DECLS
+
+#endif
--- /dev/null
+/**
+ * \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 <mono/jit/details/mono-private-unstable-types.h>
+
+MONO_BEGIN_DECLS
+
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/jit/details/mono-private-unstable-functions.h>
+#undef MONO_API_FUNCTION
+
+MONO_END_DECLS
+
+#endif /*__MONO_JIT_MONO_PRIVATE_UNSTABLE_H__*/
#ifndef _MONO_METADATA_APPDOMAIN_H_
#define _MONO_METADATA_APPDOMAIN_H_
-#include <mono/utils/mono-publib.h>
-
-#include <mono/utils/mono-forward.h>
-#include <mono/metadata/object.h>
-#include <mono/metadata/reflection.h>
+#include <mono/metadata/details/appdomain-types.h>
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 MONO_RT_EXTERNAL_ONLY 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 MONO_RT_EXTERNAL_ONLY MonoDomain *
-mono_domain_get_by_id (int32_t domainid);
-
-MONO_API MONO_RT_EXTERNAL_ONLY int32_t
-mono_domain_get_id (MonoDomain *domain);
-
-MONO_API MONO_RT_EXTERNAL_ONLY 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 MONO_RT_EXTERNAL_ONLY void
-mono_domain_try_unload (MonoDomain *domain, MonoObject **exc);
-
-MONO_API MONO_RT_EXTERNAL_ONLY mono_bool
-mono_domain_is_unloading (MonoDomain *domain);
-
-MONO_API MONO_RT_EXTERNAL_ONLY MonoDomain *
-mono_domain_from_appdomain (MonoAppDomain *appdomain);
-
-MONO_API MONO_RT_EXTERNAL_ONLY 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 MONO_RT_EXTERNAL_ONLY void
-mono_domain_ensure_entry_assembly (MonoDomain *domain, MonoAssembly *assembly);
-
-MONO_API MONO_RT_EXTERNAL_ONLY mono_bool
-mono_domain_finalize (MonoDomain *domain, uint32_t timeout);
-
-MONO_API MONO_RT_EXTERNAL_ONLY 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_RT_EXTERNAL_ONLY 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 MONO_RT_EXTERNAL_ONLY MonoAppContext *
-mono_context_get (void);
-
-MONO_API MONO_RT_EXTERNAL_ONLY int32_t
-mono_context_get_id (MonoAppContext *context);
-
-MONO_API MONO_RT_EXTERNAL_ONLY int32_t
-mono_context_get_domain_id (MonoAppContext *context);
-
-MONO_API MONO_RT_EXTERNAL_ONLY 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);
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/metadata/details/appdomain-functions.h>
+#undef MONO_API_FUNCTION
MONO_END_DECLS
#ifndef _MONONET_METADATA_ASSEMBLY_H_
#define _MONONET_METADATA_ASSEMBLY_H_
-#include <mono/utils/mono-error.h>
-#include <mono/metadata/image.h>
+#include <mono/metadata/details/assembly-types.h>
MONO_BEGIN_DECLS
-MONO_API void mono_assemblies_init (void);
-MONO_API MONO_RT_EXTERNAL_ONLY 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);
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/metadata/details/assembly-functions.h>
+#undef MONO_API_FUNCTION
-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 MONO_RT_EXTERNAL_ONLY 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
#include <mono/metadata/loader.h>
#include <mono/utils/mono-error.h>
-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);
+#include <mono/metadata/details/class-types.h>
-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_BEGIN_DECLS
-MONO_API MONO_RT_EXTERNAL_ONLY MonoClass*
-mono_class_get_nullable_param (MonoClass *klass);
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/metadata/details/class-functions.h>
+#undef MONO_API_FUNCTION
MONO_END_DECLS
#ifndef __MONO_DEBUG_HELPERS_H__
#define __MONO_DEBUG_HELPERS_H__
-#include <mono/metadata/class.h>
+#include <mono/metadata/details/debug-helpers-types.h>
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_API MONO_RT_EXTERNAL_ONLY void
-mono_debugger_agent_unhandled_exception (MonoException *e);
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/metadata/details/debug-helpers-functions.h>
+#undef MONO_API_FUNCTION
MONO_END_DECLS
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(MonoDomain*, mono_init, (const char *filename))
+
+MONO_API_FUNCTION(MonoDomain *, mono_init_from_assembly, (const char *domain_name, const char *filename))
+
+MONO_API_FUNCTION(MonoDomain *, mono_init_version, (const char *domain_name, const char *version))
+
+MONO_API_FUNCTION(MonoDomain*, mono_get_root_domain, (void))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_runtime_init, (MonoDomain *domain, MonoThreadStartCB start_cb, MonoThreadAttachCB attach_cb))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_runtime_cleanup, (MonoDomain *domain))
+
+MONO_API_FUNCTION(void, mono_install_runtime_cleanup, (MonoDomainFunc func))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_runtime_quit, (void))
+
+MONO_API_FUNCTION(void, mono_runtime_set_shutting_down, (void))
+
+MONO_API_FUNCTION(mono_bool, mono_runtime_is_shutting_down, (void))
+
+MONO_API_FUNCTION(const char*, mono_check_corlib_version, (void))
+
+MONO_API_FUNCTION(MonoDomain *, mono_domain_create, (void))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoDomain *, mono_domain_create_appdomain, (char *friendly_name, char *configuration_file))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_domain_set_config, (MonoDomain *domain, const char *base_dir, const char *config_file_name))
+
+MONO_API_FUNCTION(MonoDomain *, mono_domain_get, (void))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoDomain *, mono_domain_get_by_id, (int32_t domainid))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY int32_t, mono_domain_get_id, (MonoDomain *domain))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY const char *, mono_domain_get_friendly_name, (MonoDomain *domain))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY mono_bool, mono_domain_set, (MonoDomain *domain, mono_bool force))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_domain_set_internal, (MonoDomain *domain))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_domain_unload, (MonoDomain *domain))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_domain_try_unload, (MonoDomain *domain, MonoObject **exc))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY mono_bool, mono_domain_is_unloading, (MonoDomain *domain))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoDomain *, mono_domain_from_appdomain, (MonoAppDomain *appdomain))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_domain_foreach, (MonoDomainFunc func, void* user_data))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoAssembly *, mono_domain_assembly_open, (MonoDomain *domain, const char *name))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_domain_ensure_entry_assembly, (MonoDomain *domain, MonoAssembly *assembly))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY mono_bool, mono_domain_finalize, (MonoDomain *domain, uint32_t timeout))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_domain_free, (MonoDomain *domain, mono_bool force))
+
+MONO_API_FUNCTION(mono_bool, mono_domain_has_type_resolve, (MonoDomain *domain))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoReflectionAssembly *, mono_domain_try_type_resolve, (MonoDomain *domain, char *name, MonoObject *tb))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY mono_bool, mono_domain_owns_vtable_slot, (MonoDomain *domain, void* vtable_slot))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_context_init, (MonoDomain *domain))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_context_set, (MonoAppContext *new_context))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoAppContext *, mono_context_get, (void))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY int32_t, mono_context_get_id, (MonoAppContext *context))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY int32_t, mono_context_get_domain_id, (MonoAppContext *context))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoJitInfo *, mono_jit_info_table_find, (MonoDomain *domain, void* addr))
+
+/* MonoJitInfo accessors */
+
+MONO_API_FUNCTION(void*, mono_jit_info_get_code_start, (MonoJitInfo* ji))
+
+MONO_API_FUNCTION(int, mono_jit_info_get_code_size, (MonoJitInfo* ji))
+
+MONO_API_FUNCTION(MonoMethod*, mono_jit_info_get_method, (MonoJitInfo* ji))
+
+
+MONO_API_FUNCTION(MonoImage*, mono_get_corlib, (void))
+
+MONO_API_FUNCTION(MonoClass*, mono_get_object_class, (void))
+
+MONO_API_FUNCTION(MonoClass*, mono_get_byte_class, (void))
+
+MONO_API_FUNCTION(MonoClass*, mono_get_void_class, (void))
+
+MONO_API_FUNCTION(MonoClass*, mono_get_boolean_class, (void))
+
+MONO_API_FUNCTION(MonoClass*, mono_get_sbyte_class, (void))
+
+MONO_API_FUNCTION(MonoClass*, mono_get_int16_class, (void))
+
+MONO_API_FUNCTION(MonoClass*, mono_get_uint16_class, (void))
+
+MONO_API_FUNCTION(MonoClass*, mono_get_int32_class, (void))
+
+MONO_API_FUNCTION(MonoClass*, mono_get_uint32_class, (void))
+
+MONO_API_FUNCTION(MonoClass*, mono_get_intptr_class, (void))
+
+MONO_API_FUNCTION(MonoClass*, mono_get_uintptr_class, (void))
+
+MONO_API_FUNCTION(MonoClass*, mono_get_int64_class, (void))
+
+MONO_API_FUNCTION(MonoClass*, mono_get_uint64_class, (void))
+
+MONO_API_FUNCTION(MonoClass*, mono_get_single_class, (void))
+
+MONO_API_FUNCTION(MonoClass*, mono_get_double_class, (void))
+
+MONO_API_FUNCTION(MonoClass*, mono_get_char_class, (void))
+
+MONO_API_FUNCTION(MonoClass*, mono_get_string_class, (void))
+
+MONO_API_FUNCTION(MonoClass*, mono_get_enum_class, (void))
+
+MONO_API_FUNCTION(MonoClass*, mono_get_array_class, (void))
+
+MONO_API_FUNCTION(MonoClass*, mono_get_thread_class, (void))
+
+MONO_API_FUNCTION(MonoClass*, mono_get_exception_class, (void))
+
+MONO_API_FUNCTION(void, mono_security_enable_core_clr, (void))
+
+MONO_API_FUNCTION(void, mono_security_set_core_clr_platform_callback, (MonoCoreClrPlatformCB callback))
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+#ifndef _MONO_APPDOMAIN_TYPES_H
+#define _MONO_APPDOMAIN_TYPES_H
+
+#include <mono/utils/details/mono-publib-types.h>
+#include <mono/utils/mono-forward.h>
+#include <mono/metadata/details/object-types.h>
+#include <mono/metadata/details/reflection-types.h>
+
+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);
+
+typedef mono_bool (*MonoCoreClrPlatformCB) (const char *image_name);
+
+MONO_END_DECLS
+
+#endif /* _MONO_APPDOMAIN_TYPES_H */
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(void, mono_assemblies_init, (void))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_assemblies_cleanup, (void))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoAssembly *, mono_assembly_open, (const char *filename, MonoImageOpenStatus *status))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoAssembly *, mono_assembly_open_full, (const char *filename, MonoImageOpenStatus *status, mono_bool refonly))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoAssembly*, mono_assembly_load, (MonoAssemblyName *aname, const char *basedir, MonoImageOpenStatus *status))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoAssembly*, mono_assembly_load_full, (MonoAssemblyName *aname, const char *basedir, MonoImageOpenStatus *status, mono_bool refonly))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoAssembly*, mono_assembly_load_from, (MonoImage *image, const char *fname, MonoImageOpenStatus *status))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoAssembly*, mono_assembly_load_from_full, (MonoImage *image, const char *fname, MonoImageOpenStatus *status, mono_bool refonly))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoAssembly*, mono_assembly_load_with_partial_name, (const char *name, MonoImageOpenStatus *status))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoAssembly*, mono_assembly_loaded, (MonoAssemblyName *aname))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoAssembly*, mono_assembly_loaded_full, (MonoAssemblyName *aname, mono_bool refonly))
+MONO_API_FUNCTION(void, mono_assembly_get_assemblyref, (MonoImage *image, int index, MonoAssemblyName *aname))
+MONO_API_FUNCTION(void, mono_assembly_load_reference, (MonoImage *image, int index))
+MONO_API_FUNCTION(void, mono_assembly_load_references, (MonoImage *image, MonoImageOpenStatus *status))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoImage*, mono_assembly_load_module, (MonoAssembly *assembly, uint32_t idx))
+MONO_API_FUNCTION(void, mono_assembly_close, (MonoAssembly *assembly))
+MONO_API_FUNCTION(void, mono_assembly_setrootdir, (const char *root_dir))
+MONO_API_FUNCTION(MONO_CONST_RETURN char *, mono_assembly_getrootdir, (void))
+MONO_API_FUNCTION(char *, mono_native_getrootdir, (void))
+MONO_API_FUNCTION(void, mono_assembly_foreach, (MonoFunc func, void* user_data))
+MONO_API_FUNCTION(void, mono_assembly_set_main, (MonoAssembly *assembly))
+MONO_API_FUNCTION(MonoAssembly *, mono_assembly_get_main, (void))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoImage *, mono_assembly_get_image, (MonoAssembly *assembly))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoAssemblyName *, mono_assembly_get_name, (MonoAssembly *assembly))
+MONO_API_FUNCTION(mono_bool, mono_assembly_fill_assembly_name, (MonoImage *image, MonoAssemblyName *aname))
+MONO_API_FUNCTION(mono_bool, mono_assembly_names_equal, (MonoAssemblyName *l, MonoAssemblyName *r))
+MONO_API_FUNCTION(char*, mono_stringify_assembly_name, (MonoAssemblyName *aname))
+
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_install_assembly_load_hook, (MonoAssemblyLoadFunc func, void* user_data))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_install_assembly_search_hook, (MonoAssemblySearchFunc func, void* user_data))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_install_assembly_refonly_search_hook, (MonoAssemblySearchFunc func, void* user_data))
+
+MONO_API_FUNCTION(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_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_install_assembly_postload_search_hook, (MonoAssemblySearchFunc func, void* user_data))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_install_assembly_postload_refonly_search_hook, (MonoAssemblySearchFunc func, void* user_data))
+
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_install_assembly_preload_hook, (MonoAssemblyPreLoadFunc func, void* user_data))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_install_assembly_refonly_preload_hook, (MonoAssemblyPreLoadFunc func, void* user_data))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_assembly_invoke_load_hook, (MonoAssembly *ass))
+
+MONO_API_FUNCTION(MonoAssemblyName*, mono_assembly_name_new, (const char *name))
+MONO_API_FUNCTION(const char*, mono_assembly_name_get_name, (MonoAssemblyName *aname))
+MONO_API_FUNCTION(const char*, mono_assembly_name_get_culture, (MonoAssemblyName *aname))
+MONO_API_FUNCTION(uint16_t, mono_assembly_name_get_version, (MonoAssemblyName *aname, uint16_t *minor, uint16_t *build, uint16_t *revision))
+MONO_API_FUNCTION(mono_byte*, mono_assembly_name_get_pubkeytoken, (MonoAssemblyName *aname))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_assembly_name_free, (MonoAssemblyName *aname))
+
+MONO_API_FUNCTION(void, mono_register_bundled_assemblies, (const MonoBundledAssembly **assemblies))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_register_config_for_assembly, (const char* assembly_name, const char* config_xml))
+MONO_API_FUNCTION(void, mono_register_symfile_for_assembly, (const char* assembly_name, const mono_byte *raw_contents, int size))
+MONO_API_FUNCTION(void, mono_register_machine_config, (const char *config_xml))
+
+MONO_API_FUNCTION(void, mono_set_rootdir, (void))
+MONO_API_FUNCTION(void, mono_set_dirs, (const char *assembly_dir, const char *config_dir))
+MONO_API_FUNCTION(void, mono_set_assemblies_path, (const char* path))
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+#ifndef _MONO_ASSEMBLY_TYPES_H
+#define _MONO_ASSEMBLY_TYPES_H
+
+#include <mono/utils/details/mono-error-types.h>
+#include <mono/metadata/details/image-types.h>
+
+MONO_BEGIN_DECLS
+
+/* Installs a function which is called each time a new assembly is loaded. */
+typedef void (*MonoAssemblyLoadFunc) (MonoAssembly *assembly, 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);
+
+/* 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);
+
+typedef struct {
+ const char *name;
+ const unsigned char *data;
+ unsigned int size;
+} MonoBundledAssembly;
+
+
+
+MONO_END_DECLS
+
+#endif /* _MONO_ASSEMBLY_TYPES_H */
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoClass *, mono_class_get, (MonoImage *image, uint32_t type_token))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoClass *, mono_class_get_full, (MonoImage *image, uint32_t type_token, MonoGenericContext *context))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY mono_bool, mono_class_init, (MonoClass *klass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoVTable *, mono_class_vtable, (MonoDomain *domain, MonoClass *klass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoClass *, mono_class_from_name, (MonoImage *image, const char* name_space, const char *name))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoClass *, mono_class_from_name_case, (MonoImage *image, const char* name_space, const char *name))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoMethod *, mono_class_get_method_from_name_flags, (MonoClass *klass, const char *name, int param_count, int flags))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoClass *, mono_class_from_typeref, (MonoImage *image, uint32_t type_token))
+
+MONO_API_FUNCTION(MonoClass *, mono_class_from_typeref_checked, (MonoImage *image, uint32_t type_token, MonoError *error))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoClass *, mono_class_from_generic_parameter, (MonoGenericParam *param, MonoImage *image, mono_bool is_mvar))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoType*, mono_class_inflate_generic_type, (MonoType *type, MonoGenericContext *context) /* MONO_DEPRECATED */)
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoMethod*, mono_class_inflate_generic_method, (MonoMethod *method, MonoGenericContext *context))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoMethod *, mono_get_inflated_method, (MonoMethod *method))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoClassField*, mono_field_from_token, (MonoImage *image, uint32_t token, MonoClass **retklass, MonoGenericContext *context))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoClass *, mono_bounded_array_class_get, (MonoClass *element_class, uint32_t rank, mono_bool bounded))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoClass *, mono_array_class_get, (MonoClass *element_class, uint32_t rank))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoClass *, mono_ptr_class_get, (MonoType *type))
+
+MONO_API_FUNCTION(MonoClassField *, mono_class_get_field, (MonoClass *klass, uint32_t field_token))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoClassField *, mono_class_get_field_from_name, (MonoClass *klass, const char *name))
+
+MONO_API_FUNCTION(uint32_t, mono_class_get_field_token, (MonoClassField *field))
+
+MONO_API_FUNCTION(uint32_t, mono_class_get_event_token, (MonoEvent *event))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoProperty *, mono_class_get_property_from_name, (MonoClass *klass, const char *name))
+
+MONO_API_FUNCTION(uint32_t, mono_class_get_property_token, (MonoProperty *prop))
+
+MONO_API_FUNCTION(int32_t, mono_array_element_size, (MonoClass *ac))
+
+MONO_API_FUNCTION(int32_t, mono_class_instance_size, (MonoClass *klass))
+
+MONO_API_FUNCTION(int32_t, mono_class_array_element_size, (MonoClass *klass))
+
+MONO_API_FUNCTION(int32_t, mono_class_data_size, (MonoClass *klass))
+
+MONO_API_FUNCTION(int32_t, mono_class_value_size, (MonoClass *klass, uint32_t *align))
+
+MONO_API_FUNCTION(int32_t, mono_class_min_align, (MonoClass *klass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoClass *, mono_class_from_mono_type, (MonoType *type))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY mono_bool, mono_class_is_subclass_of, (MonoClass *klass, MonoClass *klassc, mono_bool check_interfaces))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY mono_bool, mono_class_is_assignable_from, (MonoClass *klass, MonoClass *oklass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void*, mono_ldtoken, (MonoImage *image, uint32_t token, MonoClass **retclass, MonoGenericContext *context))
+
+MONO_API_FUNCTION(char *, mono_type_get_name_full, (MonoType *type, MonoTypeNameFormat format))
+
+MONO_API_FUNCTION(char*, mono_type_get_name, (MonoType *type))
+
+MONO_API_FUNCTION(MonoType*, mono_type_get_underlying_type, (MonoType *type))
+
+/* MonoClass accessors */
+MONO_API_FUNCTION(MonoImage*, mono_class_get_image, (MonoClass *klass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoClass*, mono_class_get_element_class, (MonoClass *klass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY mono_bool, mono_class_is_valuetype, (MonoClass *klass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY mono_bool, mono_class_is_enum, (MonoClass *klass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoType*, mono_class_enum_basetype, (MonoClass *klass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoClass*, mono_class_get_parent, (MonoClass *klass))
+
+MONO_API_FUNCTION(MonoClass*, mono_class_get_nesting_type, (MonoClass *klass))
+
+MONO_API_FUNCTION(int, mono_class_get_rank, (MonoClass *klass))
+
+MONO_API_FUNCTION(uint32_t, mono_class_get_flags, (MonoClass *klass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY const char*, mono_class_get_name, (MonoClass *klass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY const char*, mono_class_get_namespace, (MonoClass *klass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoType*, mono_class_get_type, (MonoClass *klass))
+
+MONO_API_FUNCTION(uint32_t, mono_class_get_type_token, (MonoClass *klass))
+
+MONO_API_FUNCTION(MonoType*, mono_class_get_byref_type, (MonoClass *klass))
+
+MONO_API_FUNCTION(int, mono_class_num_fields, (MonoClass *klass))
+
+MONO_API_FUNCTION(int, mono_class_num_methods, (MonoClass *klass))
+
+MONO_API_FUNCTION(int, mono_class_num_properties, (MonoClass *klass))
+
+MONO_API_FUNCTION(int, mono_class_num_events, (MonoClass *klass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoClassField*, mono_class_get_fields, (MonoClass* klass, void **iter))
+
+MONO_API_FUNCTION(MonoMethod*, mono_class_get_methods, (MonoClass* klass, void **iter))
+
+MONO_API_FUNCTION(MonoProperty*, mono_class_get_properties, (MonoClass* klass, void **iter))
+
+MONO_API_FUNCTION(MonoEvent*, mono_class_get_events, (MonoClass* klass, void **iter))
+
+MONO_API_FUNCTION(MonoClass*, mono_class_get_interfaces, (MonoClass* klass, void **iter))
+
+MONO_API_FUNCTION(MonoClass*, mono_class_get_nested_types, (MonoClass* klass, void **iter))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY mono_bool, mono_class_is_delegate, (MonoClass* klass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY mono_bool, mono_class_implements_interface, (MonoClass* klass, MonoClass* iface))
+
+/* MonoClassField accessors */
+MONO_API_FUNCTION(const char*, mono_field_get_name, (MonoClassField *field))
+
+MONO_API_FUNCTION(MonoType*, mono_field_get_type, (MonoClassField *field))
+
+MONO_API_FUNCTION(MonoClass*, mono_field_get_parent, (MonoClassField *field))
+
+MONO_API_FUNCTION(uint32_t, mono_field_get_flags, (MonoClassField *field))
+
+MONO_API_FUNCTION(uint32_t, mono_field_get_offset, (MonoClassField *field))
+
+MONO_API_FUNCTION(const char *, mono_field_get_data, (MonoClassField *field))
+
+/* MonoProperty acessors */
+MONO_API_FUNCTION(const char*, mono_property_get_name, (MonoProperty *prop))
+
+MONO_API_FUNCTION(MonoMethod*, mono_property_get_set_method, (MonoProperty *prop))
+
+MONO_API_FUNCTION(MonoMethod*, mono_property_get_get_method, (MonoProperty *prop))
+
+MONO_API_FUNCTION(MonoClass*, mono_property_get_parent, (MonoProperty *prop))
+
+MONO_API_FUNCTION(uint32_t, mono_property_get_flags, (MonoProperty *prop))
+
+/* MonoEvent accessors */
+MONO_API_FUNCTION(const char*, mono_event_get_name, (MonoEvent *event))
+
+MONO_API_FUNCTION(MonoMethod*, mono_event_get_add_method, (MonoEvent *event))
+
+MONO_API_FUNCTION(MonoMethod*, mono_event_get_remove_method, (MonoEvent *event))
+
+MONO_API_FUNCTION(MonoMethod*, mono_event_get_raise_method, (MonoEvent *event))
+
+MONO_API_FUNCTION(MonoClass*, mono_event_get_parent, (MonoEvent *event))
+
+MONO_API_FUNCTION(uint32_t, mono_event_get_flags, (MonoEvent *event))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoMethod *, mono_class_get_method_from_name, (MonoClass *klass, const char *name, int param_count))
+
+MONO_API_FUNCTION(char *, mono_class_name_from_token, (MonoImage *image, uint32_t type_token))
+
+MONO_API_FUNCTION(mono_bool, mono_method_can_access_field, (MonoMethod *method, MonoClassField *field))
+
+MONO_API_FUNCTION(mono_bool, mono_method_can_access_method, (MonoMethod *method, MonoMethod *called))
+
+MONO_API_FUNCTION(mono_bool, mono_class_is_nullable, (MonoClass *klass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoClass*, mono_class_get_nullable_param, (MonoClass *klass))
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+#ifndef _MONO_CLASS_TYPES_H
+#define _MONO_CLASS_TYPES_H
+
+#include <mono/metadata/details/metadata-types.h>
+#include <mono/metadata/details/image-types.h>
+#include <mono/metadata/details/loader-types.h>
+#include <mono/utils/details/mono-error-types.h>
+
+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_END_DECLS
+
+#endif /* _MONO_CLASS_TYPES_H */
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(char*, mono_disasm_code_one, (MonoDisHelper *dh, MonoMethod *method, const mono_byte *ip, const mono_byte** endp))
+MONO_API_FUNCTION(char*, mono_disasm_code, (MonoDisHelper *dh, MonoMethod *method, const mono_byte *ip, const mono_byte* end))
+
+MONO_API_FUNCTION(char*, mono_type_full_name, (MonoType *type))
+
+MONO_API_FUNCTION(char*, mono_signature_get_desc, (MonoMethodSignature *sig, mono_bool include_namespace))
+
+MONO_API_FUNCTION(char*, mono_context_get_desc, (MonoGenericContext *context))
+
+MONO_API_FUNCTION(MonoMethodDesc*, mono_method_desc_new, (const char *name, mono_bool include_namespace))
+MONO_API_FUNCTION(MonoMethodDesc*, mono_method_desc_from_method, (MonoMethod *method))
+MONO_API_FUNCTION(void, mono_method_desc_free, (MonoMethodDesc *desc))
+MONO_API_FUNCTION(mono_bool, mono_method_desc_match, (MonoMethodDesc *desc, MonoMethod *method))
+MONO_API_FUNCTION(mono_bool, mono_method_desc_is_full, (MonoMethodDesc *desc))
+MONO_API_FUNCTION(mono_bool, mono_method_desc_full_match, (MonoMethodDesc *desc, MonoMethod *method))
+MONO_API_FUNCTION(MonoMethod*, mono_method_desc_search_in_class, (MonoMethodDesc *desc, MonoClass *klass))
+MONO_API_FUNCTION(MonoMethod*, mono_method_desc_search_in_image, (MonoMethodDesc *desc, MonoImage *image))
+
+MONO_API_FUNCTION(char*, mono_method_full_name, (MonoMethod *method, mono_bool signature))
+MONO_API_FUNCTION(char*, mono_method_get_reflection_name, (MonoMethod *method))
+
+MONO_API_FUNCTION(char*, mono_field_full_name, (MonoClassField *field))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_debugger_agent_unhandled_exception, (MonoException *e))
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+#ifndef _MONO_DEBUG_HELPERS_TYPES_H
+#define _MONO_DEBUG_HELPERS_TYPES_H
+
+#include <mono/metadata/details/class-types.h>
+
+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;
+};
+
+typedef struct MonoMethodDesc MonoMethodDesc;
+
+MONO_END_DECLS
+
+#endif /* _MONO_DEBUG_HELPERS_TYPES_H */
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(int32_t, mono_environment_exitcode_get, (void))
+MONO_API_FUNCTION(void, mono_environment_exitcode_set, (int32_t value))
+
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(MonoException *, mono_exception_from_name, (MonoImage *image, const char* name_space, const char *name))
+
+MONO_API_FUNCTION(MonoException *, mono_exception_from_token, (MonoImage *image, uint32_t token))
+
+MONO_API_FUNCTION(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_FUNCTION(MonoException *, mono_exception_from_name_msg, (MonoImage *image, const char *name_space, const char *name, const char *msg))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoException *, mono_exception_from_token_two_strings, (MonoImage *image, uint32_t token, MonoString *a1, MonoString *a2))
+
+MONO_API_FUNCTION(MonoException *, mono_exception_from_name_domain, (MonoDomain *domain, MonoImage *image, const char* name_space, const char *name))
+
+MONO_API_FUNCTION(MonoException *, mono_get_exception_divide_by_zero, (void))
+
+MONO_API_FUNCTION(MonoException *, mono_get_exception_security, (void))
+
+MONO_API_FUNCTION(MonoException *, mono_get_exception_arithmetic, (void))
+
+MONO_API_FUNCTION(MonoException *, mono_get_exception_overflow, (void))
+
+MONO_API_FUNCTION(MonoException *, mono_get_exception_null_reference, (void))
+
+MONO_API_FUNCTION(MonoException *, mono_get_exception_execution_engine, (const char *msg))
+
+MONO_API_FUNCTION(MonoException *, mono_get_exception_thread_abort, (void))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoException *, mono_get_exception_thread_state, (const char *msg))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoException *, mono_get_exception_thread_interrupted, (void))
+
+MONO_API_FUNCTION(MonoException *, mono_get_exception_serialization, (const char *msg))
+
+MONO_API_FUNCTION(MonoException *, mono_get_exception_invalid_cast, (void))
+
+MONO_API_FUNCTION(MonoException *, mono_get_exception_invalid_operation, (const char *msg))
+
+MONO_API_FUNCTION(MonoException *, mono_get_exception_index_out_of_range, (void))
+
+MONO_API_FUNCTION(MonoException *, mono_get_exception_array_type_mismatch, (void))
+
+MONO_API_FUNCTION(MonoException *, mono_get_exception_type_load, (MonoString *class_name, char *assembly_name))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoException *, mono_get_exception_missing_method, (const char *class_name, const char *member_name))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoException *, mono_get_exception_missing_field, (const char *class_name, const char *member_name))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoException *, mono_get_exception_not_implemented, (const char *msg))
+
+MONO_API_FUNCTION(MonoException *, mono_get_exception_not_supported, (const char *msg))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoException*, mono_get_exception_argument_null, (const char *arg))
+
+MONO_API_FUNCTION(MonoException *, mono_get_exception_argument, (const char *arg, const char *msg))
+
+MONO_API_FUNCTION(MonoException *, mono_get_exception_argument_out_of_range, (const char *arg))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoException *, mono_get_exception_io, (const char *msg))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoException *, mono_get_exception_file_not_found, (MonoString *fname))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoException *, mono_get_exception_file_not_found2, (const char *msg, MonoString *fname))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoException *, mono_get_exception_type_initialization, (const char *type_name, MonoException *inner))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoException *, mono_get_exception_synchronization_lock, (const char *msg))
+
+MONO_API_FUNCTION(MonoException *, mono_get_exception_cannot_unload_appdomain, (const char *msg))
+
+MONO_API_FUNCTION(MonoException *, mono_get_exception_appdomain_unloaded, (void))
+
+MONO_API_FUNCTION(MonoException *, mono_get_exception_bad_image_format, (const char *msg))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoException *, mono_get_exception_bad_image_format2, (const char *msg, MonoString *fname))
+
+MONO_API_FUNCTION(MonoException *, mono_get_exception_stack_overflow, (void))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoException *, mono_get_exception_out_of_memory, (void))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoException *, mono_get_exception_field_access, (void))
+
+MONO_API_FUNCTION(MonoException *, mono_get_exception_method_access, (void))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoException *, mono_get_exception_reflection_type_load, (MonoArray *types, MonoArray *exceptions))
+
+MONO_API_FUNCTION(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.
+ */
+MONO_API_FUNCTION(void, mono_install_unhandled_exception_hook, (MonoUnhandledExceptionFunc func, void *user_data))
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+#ifndef _MONO_EXCEPTION_TYPES_H
+#define _MONO_EXCEPTION_TYPES_H
+
+#include <mono/metadata/object-forward.h>
+#include <mono/metadata/details/object-types.h>
+#include <mono/metadata/details/image-types.h>
+
+
+MONO_BEGIN_DECLS
+
+typedef void (*MonoUnhandledExceptionFunc) (MonoObject *exc, void *user_data);
+
+MONO_END_DECLS
+
+#endif /* _MONO_EXCEPTION_TYPES_H */
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(void, mono_images_init, (void))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_images_cleanup, (void))
+
+MONO_API_FUNCTION(MonoImage *, mono_image_open, (const char *fname, MonoImageOpenStatus *status))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoImage *, mono_image_open_full, (const char *fname, MonoImageOpenStatus *status, mono_bool refonly))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoImage *, mono_pe_file_open, (const char *fname, MonoImageOpenStatus *status))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoImage *, mono_image_open_from_data, (char *data, uint32_t data_len, mono_bool need_copy, MonoImageOpenStatus *status))
+MONO_API_FUNCTION(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_FUNCTION(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_FUNCTION(void, mono_image_fixup_vtable, (MonoImage *image))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoImage *, mono_image_loaded, (const char *name))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoImage *, mono_image_loaded_full, (const char *name, mono_bool refonly))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoImage *, mono_image_loaded_by_guid, (const char *guid))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoImage *, mono_image_loaded_by_guid_full, (const char *guid, mono_bool refonly))
+MONO_API_FUNCTION(void, mono_image_init, (MonoImage *image))
+MONO_API_FUNCTION(void, mono_image_close, (MonoImage *image))
+MONO_API_FUNCTION(void, mono_image_addref, (MonoImage *image))
+MONO_API_FUNCTION(const char *, mono_image_strerror, (MonoImageOpenStatus status))
+
+MONO_API_FUNCTION(int, mono_image_ensure_section, (MonoImage *image, const char *section))
+MONO_API_FUNCTION(int, mono_image_ensure_section_idx, (MonoImage *image, int section))
+
+MONO_API_FUNCTION(uint32_t, mono_image_get_entry_point, (MonoImage *image))
+MONO_API_FUNCTION(const char *, mono_image_get_resource, (MonoImage *image, uint32_t offset, uint32_t *size))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoImage*, mono_image_load_file_for_image, (MonoImage *image, int fileidx))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoImage*, mono_image_load_module, (MonoImage *image, int idx))
+
+MONO_API_FUNCTION(const char*, mono_image_get_name, (MonoImage *image))
+MONO_API_FUNCTION(const char*, mono_image_get_filename, (MonoImage *image))
+MONO_API_FUNCTION(const char*, mono_image_get_guid, (MonoImage *image))
+MONO_API_FUNCTION(MonoAssembly*, mono_image_get_assembly, (MonoImage *image))
+MONO_API_FUNCTION(mono_bool, mono_image_is_dynamic, (MonoImage *image))
+MONO_API_FUNCTION(char*, mono_image_rva_map, (MonoImage *image, uint32_t rva))
+
+MONO_API_FUNCTION(const MonoTableInfo *, mono_image_get_table_info, (MonoImage *image, int table_id))
+MONO_API_FUNCTION(int, mono_image_get_table_rows, (MonoImage *image, int table_id))
+MONO_API_FUNCTION(int, mono_table_info_get_rows, (const MonoTableInfo *table))
+
+/* This actually returns a MonoPEResourceDataEntry *, but declaring it
+ * causes an include file loop.
+ */
+MONO_API_FUNCTION(void*, mono_image_lookup_resource, (MonoImage *image, uint32_t res_id, uint32_t lang_id, mono_unichar2 *name))
+
+MONO_API_FUNCTION(const char*, mono_image_get_public_key, (MonoImage *image, uint32_t *size))
+MONO_API_FUNCTION(const char*, mono_image_get_strong_name, (MonoImage *image, uint32_t *size))
+MONO_API_FUNCTION(uint32_t, mono_image_strong_name_position, (MonoImage *image, uint32_t *size))
+MONO_API_FUNCTION(void, mono_image_add_to_name_cache, (MonoImage *image, const char *nspace, const char *name, uint32_t idx))
+MONO_API_FUNCTION(mono_bool, mono_image_has_authenticode_entry, (MonoImage *image))
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+#ifndef _MONO_IMAGE_TYPES_H
+#define _MONO_IMAGE_TYPES_H
+
+#include <stdio.h>
+#include <mono/utils/details/mono-publib-types.h>
+#include <mono/utils/details/mono-error-types.h>
+#include <mono/metadata/object-forward.h>
+
+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_END_DECLS
+
+#endif /* _MONO_IMAGE_TYPES_H */
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoMethod *, mono_get_method, (MonoImage *image, uint32_t token, MonoClass *klass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoMethod *, mono_get_method_full, (MonoImage *image, uint32_t token, MonoClass *klass, MonoGenericContext *context))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoMethod *, mono_get_method_constrained, (MonoImage *image, uint32_t token, MonoClass *constrained_class, MonoGenericContext *context, MonoMethod **cil_method))
+
+MONO_API_FUNCTION(void, mono_free_method, (MonoMethod *method))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoMethodSignature*, mono_method_get_signature_full, (MonoMethod *method, MonoImage *image, uint32_t token, MonoGenericContext *context))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoMethodSignature*, mono_method_get_signature, (MonoMethod *method, MonoImage *image, uint32_t token))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoMethodSignature*, mono_method_signature, (MonoMethod *method))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoMethodHeader*, mono_method_get_header, (MonoMethod *method))
+
+MONO_API_FUNCTION(const char*, mono_method_get_name, (MonoMethod *method))
+
+MONO_API_FUNCTION(MonoClass*, mono_method_get_class, (MonoMethod *method))
+
+MONO_API_FUNCTION(uint32_t, mono_method_get_token, (MonoMethod *method))
+
+MONO_API_FUNCTION(uint32_t, mono_method_get_flags, (MonoMethod *method, uint32_t *iflags))
+
+MONO_API_FUNCTION(uint32_t, mono_method_get_index, (MonoMethod *method))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_add_internal_call, (const char *name, const void* method))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_dangerous_add_raw_internal_call, (const char *name, const void* method))
+
+MONO_API_FUNCTION(void*, mono_lookup_internal_call, (MonoMethod *method))
+
+MONO_API_FUNCTION(const char*, mono_lookup_icall_symbol, (MonoMethod *m))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_dllmap_insert, (MonoImage *assembly, const char *dll, const char *func, const char *tdll, const char *tfunc))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void*, mono_lookup_pinvoke_call, (MonoMethod *method, const char **exc_class, const char **exc_arg))
+
+MONO_API_FUNCTION(void, mono_method_get_param_names, (MonoMethod *method, const char **names))
+
+MONO_API_FUNCTION(uint32_t, mono_method_get_param_token, (MonoMethod *method, int idx))
+
+MONO_API_FUNCTION(void, mono_method_get_marshal_info, (MonoMethod *method, MonoMarshalSpec **mspecs))
+
+MONO_API_FUNCTION(mono_bool, mono_method_has_marshal_info, (MonoMethod *method))
+
+MONO_API_FUNCTION(MonoMethod*, mono_method_get_last_managed, (void))
+
+MONO_API_FUNCTION(void, mono_stack_walk, (MonoStackWalk func, void* user_data))
+
+/* Use this if the IL offset is not needed: it's faster */
+MONO_API_FUNCTION(void, mono_stack_walk_no_il, (MonoStackWalk func, void* user_data))
+
+MONO_API_FUNCTION(void, mono_stack_walk_async_safe, (MonoStackWalkAsyncSafe func, void *initial_sig_context, void* user_data))
+
+MONO_API_FUNCTION(MonoMethodHeader*, mono_method_get_header_checked, (MonoMethod *method, MonoError *error))
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+#ifndef _MONO_LOADER_TYPES_H
+#define _MONO_LOADER_TYPES_H
+
+#include <mono/utils/mono-forward.h>
+#include <mono/metadata/details/metadata-types.h>
+#include <mono/metadata/details/image-types.h>
+#include <mono/utils/details/mono-error-types.h>
+
+MONO_BEGIN_DECLS
+
+typedef mono_bool (*MonoStackWalk) (MonoMethod *method, int32_t native_offset, int32_t il_offset, mono_bool managed, void* data);
+
+typedef mono_bool (*MonoStackWalkAsyncSafe) (MonoMethod *method, MonoDomain *domain, void *base_address, int offset, void* data);
+
+MONO_END_DECLS
+
+#endif /* _MONO_LOADER_TYPES_H */
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+
+MONO_API_FUNCTION(void, mono_metadata_init, (void))
+
+MONO_API_FUNCTION(void, mono_metadata_decode_row, (const MonoTableInfo *t, int idx, uint32_t *res, int res_size))
+
+MONO_API_FUNCTION(uint32_t, mono_metadata_decode_row_col, (const MonoTableInfo *t, int idx, unsigned int col))
+
+MONO_API_FUNCTION(int, mono_metadata_compute_size, (MonoImage *meta, int tableindex, uint32_t *result_bitfield))
+
+/*
+ *
+ */
+MONO_API_FUNCTION(const char *, mono_metadata_locate, (MonoImage *meta, int table, int idx))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY const char *, mono_metadata_locate_token, (MonoImage *meta, uint32_t token))
+
+MONO_API_FUNCTION(const char *, mono_metadata_string_heap, (MonoImage *meta, uint32_t table_index))
+MONO_API_FUNCTION(const char *, mono_metadata_blob_heap, (MonoImage *meta, uint32_t table_index))
+MONO_API_FUNCTION(const char *, mono_metadata_user_string, (MonoImage *meta, uint32_t table_index))
+MONO_API_FUNCTION(const char *, mono_metadata_guid_heap, (MonoImage *meta, uint32_t table_index))
+
+MONO_API_FUNCTION(uint32_t, mono_metadata_typedef_from_field, (MonoImage *meta, uint32_t table_index))
+MONO_API_FUNCTION(uint32_t, mono_metadata_typedef_from_method, (MonoImage *meta, uint32_t table_index))
+MONO_API_FUNCTION(uint32_t, mono_metadata_nested_in_typedef, (MonoImage *meta, uint32_t table_index))
+MONO_API_FUNCTION(uint32_t, mono_metadata_nesting_typedef, (MonoImage *meta, uint32_t table_index, uint32_t start_index))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoClass**, mono_metadata_interfaces_from_typedef, (MonoImage *meta, uint32_t table_index, unsigned int *count))
+
+MONO_API_FUNCTION(uint32_t, mono_metadata_events_from_typedef, (MonoImage *meta, uint32_t table_index, unsigned int *end_idx))
+MONO_API_FUNCTION(uint32_t, mono_metadata_methods_from_event, (MonoImage *meta, uint32_t table_index, unsigned int *end))
+MONO_API_FUNCTION(uint32_t, mono_metadata_properties_from_typedef, (MonoImage *meta, uint32_t table_index, unsigned int *end))
+MONO_API_FUNCTION(uint32_t, mono_metadata_methods_from_property, (MonoImage *meta, uint32_t table_index, unsigned int *end))
+MONO_API_FUNCTION(uint32_t, mono_metadata_packing_from_typedef, (MonoImage *meta, uint32_t table_index, uint32_t *packing, uint32_t *size))
+MONO_API_FUNCTION(const char*, mono_metadata_get_marshal_info, (MonoImage *meta, uint32_t idx, mono_bool is_field))
+MONO_API_FUNCTION(uint32_t, mono_metadata_custom_attrs_from_index, (MonoImage *meta, uint32_t cattr_index))
+
+MONO_API_FUNCTION(MonoMarshalSpec *, mono_metadata_parse_marshal_spec, (MonoImage *image, const char *ptr))
+
+MONO_API_FUNCTION(void, mono_metadata_free_marshal_spec, (MonoMarshalSpec *spec))
+
+MONO_API_FUNCTION(uint32_t, mono_metadata_implmap_from_method, (MonoImage *meta, uint32_t method_idx))
+
+MONO_API_FUNCTION(void, mono_metadata_field_info, (MonoImage *meta, uint32_t table_index, uint32_t *offset, uint32_t *rva, MonoMarshalSpec **marshal_spec))
+MONO_API_FUNCTION(uint32_t, mono_metadata_get_constant_index, (MonoImage *meta, uint32_t token, uint32_t hint))
+
+/*
+ * Functions to extract information from the Blobs
+ */
+MONO_API_FUNCTION(uint32_t, mono_metadata_decode_value, (const char *ptr, const char **rptr))
+MONO_API_FUNCTION(int32_t, mono_metadata_decode_signed_value, (const char *ptr, const char **rptr))
+
+MONO_API_FUNCTION(uint32_t, mono_metadata_decode_blob_size, (const char *ptr, const char **rptr))
+
+MONO_API_FUNCTION(void, mono_metadata_encode_value, (uint32_t value, char *bug, char **endbuf))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY mono_bool, mono_type_is_byref, (MonoType *type))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY int, mono_type_get_type, (MonoType *type))
+
+/* For MONO_TYPE_FNPTR */
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoMethodSignature*, mono_type_get_signature, (MonoType *type))
+
+/* For MONO_TYPE_CLASS, VALUETYPE */
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoClass*, mono_type_get_class, (MonoType *type))
+
+MONO_API_FUNCTION(MonoArrayType*, mono_type_get_array_type, (MonoType *type))
+
+/* For MONO_TYPE_PTR */
+MONO_API_FUNCTION(MonoType*, mono_type_get_ptr_type, (MonoType *type))
+
+MONO_API_FUNCTION(MonoClass*, mono_type_get_modifiers, (MonoType *type, mono_bool *is_required, void **iter))
+
+MONO_API_FUNCTION(mono_bool, mono_type_is_struct, (MonoType *type))
+MONO_API_FUNCTION(mono_bool, mono_type_is_void, (MonoType *type))
+MONO_API_FUNCTION(mono_bool, mono_type_is_pointer, (MonoType *type))
+MONO_API_FUNCTION(mono_bool, mono_type_is_reference, (MonoType *type))
+MONO_API_FUNCTION(mono_bool, mono_type_is_generic_parameter, (MonoType *type))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoType*, mono_signature_get_return_type, (MonoMethodSignature *sig))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoType*, mono_signature_get_params, (MonoMethodSignature *sig, void **iter))
+
+MONO_API_FUNCTION(uint32_t, mono_signature_get_param_count, (MonoMethodSignature *sig))
+
+MONO_API_FUNCTION(uint32_t, mono_signature_get_call_conv, (MonoMethodSignature *sig))
+
+MONO_API_FUNCTION(int, mono_signature_vararg_start, (MonoMethodSignature *sig))
+
+MONO_API_FUNCTION(mono_bool, mono_signature_is_instance, (MonoMethodSignature *sig))
+
+MONO_API_FUNCTION(mono_bool, mono_signature_explicit_this, (MonoMethodSignature *sig))
+
+MONO_API_FUNCTION(mono_bool, mono_signature_param_is_out, (MonoMethodSignature *sig, int param_num))
+
+MONO_API_FUNCTION(uint32_t, mono_metadata_parse_typedef_or_ref, (MonoImage *m, const char *ptr, const char **rptr))
+MONO_API_FUNCTION(int, mono_metadata_parse_custom_mod, (MonoImage *m, MonoCustomMod *dest, const char *ptr, const char **rptr))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoArrayType *, mono_metadata_parse_array, (MonoImage *m, const char *ptr, const char **rptr))
+MONO_API_FUNCTION(void, mono_metadata_free_array, (MonoArrayType *array))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoType *, mono_metadata_parse_type, (MonoImage *m, MonoParseTypeMode mode, short opt_attrs, const char *ptr, const char **rptr))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoType *, mono_metadata_parse_param, (MonoImage *m, const char *ptr, const char **rptr))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoType *, mono_metadata_parse_field_type, (MonoImage *m, short field_flags, const char *ptr, const char **rptr))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoType *, mono_type_create_from_typespec, (MonoImage *image, uint32_t type_spec))
+MONO_API_FUNCTION(void, mono_metadata_free_type, (MonoType *type))
+MONO_API_FUNCTION(int, mono_type_size, (MonoType *type, int *alignment))
+MONO_API_FUNCTION(int, mono_type_stack_size, (MonoType *type, int *alignment))
+
+MONO_API_FUNCTION(mono_bool, mono_type_generic_inst_is_valuetype, (MonoType *type))
+MONO_API_FUNCTION(mono_bool, mono_metadata_generic_class_is_valuetype, (MonoGenericClass *gclass))
+
+MONO_API_FUNCTION(unsigned int, mono_metadata_type_hash, (MonoType *t1))
+MONO_API_FUNCTION(mono_bool, mono_metadata_type_equal, (MonoType *t1, MonoType *t2))
+
+MONO_API_FUNCTION(MonoMethodSignature *, mono_metadata_signature_alloc, (MonoImage *image, uint32_t nparams))
+
+MONO_API_FUNCTION(MonoMethodSignature *, mono_metadata_signature_dup, (MonoMethodSignature *sig))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoMethodSignature *, mono_metadata_parse_signature, (MonoImage *image, uint32_t token))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoMethodSignature *, mono_metadata_parse_method_signature, (MonoImage *m, int def, const char *ptr, const char **rptr))
+MONO_API_FUNCTION(void, mono_metadata_free_method_signature, (MonoMethodSignature *method))
+
+MONO_API_FUNCTION(mono_bool, mono_metadata_signature_equal, (MonoMethodSignature *sig1, MonoMethodSignature *sig2))
+
+MONO_API_FUNCTION(unsigned int, mono_signature_hash, (MonoMethodSignature *sig))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoMethodHeader *, mono_metadata_parse_mh, (MonoImage *m, const char *ptr))
+MONO_API_FUNCTION(void, mono_metadata_free_mh, (MonoMethodHeader *mh))
+
+/* MonoMethodHeader accessors */
+MONO_API_FUNCTION(const unsigned char*, mono_method_header_get_code, (MonoMethodHeader *header, uint32_t* code_size, uint32_t* max_stack))
+
+MONO_API_FUNCTION(MonoType**, mono_method_header_get_locals, (MonoMethodHeader *header, uint32_t* num_locals, mono_bool *init_locals))
+
+MONO_API_FUNCTION(int, mono_method_header_get_num_clauses, (MonoMethodHeader *header))
+
+MONO_API_FUNCTION(int, mono_method_header_get_clauses, (MonoMethodHeader *header, MonoMethod *method, void **iter, MonoExceptionClause *clause))
+
+MONO_API_FUNCTION(uint32_t, mono_type_to_unmanaged, (MonoType *type, MonoMarshalSpec *mspec, mono_bool as_field, mono_bool unicode, MonoMarshalConv *conv))
+
+MONO_API_FUNCTION(uint32_t, mono_metadata_token_from_dor, (uint32_t dor_index))
+
+MONO_API_FUNCTION(char *, mono_guid_to_string, (const uint8_t *guid))
+
+MONO_API_FUNCTION(char *, mono_guid_to_string_minimal, (const uint8_t *guid))
+
+MONO_API_FUNCTION(uint32_t, mono_metadata_declsec_from_index, (MonoImage *meta, uint32_t idx))
+
+MONO_API_FUNCTION(uint32_t, mono_metadata_translate_token_index, (MonoImage *image, int table, uint32_t idx))
+
+MONO_API_FUNCTION(void, mono_metadata_decode_table_row, (MonoImage *image, int table, int idx, uint32_t *res, int res_size))
+
+MONO_API_FUNCTION(uint32_t, mono_metadata_decode_table_row_col, (MonoImage *image, int table, int idx, unsigned int col))
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+#ifndef _MONO_METADATA_TYPES_H
+#define _MONO_METADATA_TYPES_H
+
+
+#include <mono/utils/details/mono-publib-types.h>
+
+#include <mono/utils/mono-forward.h>
+#include <mono/metadata/blob.h>
+#include <mono/metadata/row-indexes.h>
+#include <mono/metadata/details/image-types.h>
+#include <mono/metadata/object-forward.h>
+
+MONO_BEGIN_DECLS
+
+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 = 0x05,
+ /* unused, */
+ /* unused, */
+ /* unused, */
+ MONO_CALL_UNMANAGED_MD = 0x09, /* default unmanaged calling convention, with additional attributed encoded in modopts */
+} 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;
+
+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_END_DECLS
+
+#endif /* _MONO_METADATA_TYPES_H */
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(const char *, mono_config_get_os, (void))
+MONO_API_FUNCTION(const char *, mono_config_get_cpu, (void))
+MONO_API_FUNCTION(const char *, mono_config_get_wordsize, (void))
+
+MONO_API_FUNCTION(const char*, mono_get_config_dir, (void))
+MONO_API_FUNCTION(void, mono_set_config_dir, (const char *dir))
+
+MONO_API_FUNCTION(const char *, mono_get_machine_config, (void))
+
+MONO_API_FUNCTION(void, mono_config_cleanup, (void))
+MONO_API_FUNCTION(void, mono_config_parse, (const char *filename))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_config_for_assembly, (MonoImage *assembly))
+MONO_API_FUNCTION(void, mono_config_parse_memory, (const char *buffer))
+
+MONO_API_FUNCTION(const char*, mono_config_string_for_assembly_file, (const char *filename))
+
+MONO_API_FUNCTION(void, mono_config_set_server_mode, (mono_bool server_mode))
+MONO_API_FUNCTION(mono_bool, mono_config_is_server_mode, (void))
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+#ifndef _MONO_METADATA_CONFIG_TYPES_H
+#define _MONO_METADATA_CONFIG_TYPES_H
+
+#include <mono/utils/details/mono-publib-types.h>
+#include <mono/metadata/details/image-types.h>
+
+MONO_BEGIN_DECLS
+
+MONO_END_DECLS
+
+#endif /* _MONO_METADATA_CONFIG_TYPES_H */
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(mono_bool, mono_debug_enabled, (void))
+
+MONO_API_FUNCTION(void, mono_debug_init, (MonoDebugFormat format))
+MONO_API_FUNCTION(void, mono_debug_open_image_from_memory, (MonoImage *image, const mono_byte *raw_contents, int size))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_debug_cleanup, (void))
+
+MONO_API_FUNCTION(void, mono_debug_close_image, (MonoImage *image))
+
+MONO_API_FUNCTION(void, mono_debug_domain_unload, (MonoDomain *domain))
+MONO_API_FUNCTION(void, mono_debug_domain_create, (MonoDomain *domain))
+
+MONO_API_FUNCTION(MonoDebugMethodAddress *, mono_debug_add_method, (MonoMethod *method, MonoDebugMethodJitInfo *jit, MonoDomain *domain))
+
+MONO_API_FUNCTION(void, mono_debug_remove_method, (MonoMethod *method, MonoDomain *domain))
+
+MONO_API_FUNCTION(MonoDebugMethodInfo *, mono_debug_lookup_method, (MonoMethod *method))
+
+MONO_API_FUNCTION(MonoDebugMethodAddressList *, mono_debug_lookup_method_addresses, (MonoMethod *method))
+
+MONO_API_FUNCTION(MonoDebugMethodJitInfo*, mono_debug_find_method, (MonoMethod *method, MonoDomain *domain))
+
+MONO_API_FUNCTION(MonoDebugHandle *, mono_debug_get_handle, (MonoImage *image))
+
+MONO_API_FUNCTION(void, mono_debug_free_method_jit_info, (MonoDebugMethodJitInfo *jit))
+
+
+MONO_API_FUNCTION(void, mono_debug_add_delegate_trampoline, (void* code, int size))
+
+MONO_API_FUNCTION(MonoDebugLocalsInfo*, mono_debug_lookup_locals, (MonoMethod *method))
+
+MONO_API_FUNCTION(MonoDebugMethodAsyncInfo*, mono_debug_lookup_method_async_debug_info, (MonoMethod *method))
+
+MONO_API_FUNCTION(MonoDebugSourceLocation *, mono_debug_method_lookup_location, (MonoDebugMethodInfo *minfo, int il_offset))
+
+/*
+ * Line number support.
+ */
+
+MONO_API_FUNCTION(MonoDebugSourceLocation *, mono_debug_lookup_source_location, (MonoMethod *method, uint32_t address, MonoDomain *domain))
+
+MONO_API_FUNCTION(int32_t, mono_debug_il_offset_from_address, (MonoMethod *method, MonoDomain *domain, uint32_t native_offset))
+
+MONO_API_FUNCTION(void, mono_debug_free_source_location, (MonoDebugSourceLocation *location))
+
+MONO_API_FUNCTION(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_FUNCTION(int, mono_debugger_method_has_breakpoint, (MonoMethod *method))
+MONO_API_FUNCTION(int, mono_debugger_insert_breakpoint, (const char *method_name, mono_bool include_namespace))
+
+MONO_API_FUNCTION(void, mono_set_is_debugger_attached, (mono_bool attached))
+MONO_API_FUNCTION(mono_bool, mono_is_debugger_attached, (void))
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+#ifndef _MONO_MONO_DEBUG_TYPES_H
+#define _MONO_MONO_DEBUG_TYPES_H
+
+#include <mono/utils/details/mono-publib-types.h>
+#include <mono/metadata/details/image-types.h>
+#include <mono/metadata/details/appdomain-types.h>
+
+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;
+};
+
+/*
+ * 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_END_DECLS
+
+#endif /* _MONO_MONO_DEBUG_TYPES_H */
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(void, mono_gc_collect, (int generation))
+MONO_API_FUNCTION(int, mono_gc_max_generation, (void))
+MONO_API_FUNCTION(int, mono_gc_get_generation, (MonoObject *object))
+MONO_API_FUNCTION(int, mono_gc_collection_count, (int generation))
+MONO_API_FUNCTION(int64_t, mono_gc_get_generation_size, (int generation))
+MONO_API_FUNCTION(int64_t, mono_gc_get_used_size, (void))
+MONO_API_FUNCTION(int64_t, mono_gc_get_heap_size, (void))
+MONO_API_FUNCTION(MonoBoolean, mono_gc_pending_finalizers, (void))
+MONO_API_FUNCTION(void, mono_gc_finalize_notify, (void))
+MONO_API_FUNCTION(int, mono_gc_invoke_finalizers, (void))
+/* heap walking is only valid in the pre-stop-world event callback */
+MONO_API_FUNCTION(int, mono_gc_walk_heap, (int flags, MonoGCReferences callback, void *data))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_gc_init_finalizer_thread, (void))
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+#ifndef _MONO_METADATA_MONO_GC_TYPES_H
+#define _MONO_METADATA_MONO_GC_TYPES_H
+
+#include <mono/metadata/details/object-types.h>
+
+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_END_DECLS
+
+#endif /* _MONO_METADATA_MONO_GC_TYPES_H */
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+/**
+ *
+ * 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.
+ *
+ */
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoAssembly *, mono_assembly_load_full_alc, (MonoAssemblyLoadContextGCHandle alc_gchandle, MonoAssemblyName *aname, const char *basedir, MonoImageOpenStatus *status))
+
+MONO_API_FUNCTION(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))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_install_assembly_preload_hook_v3, (MonoAssemblyPreLoadFuncV3 func, void *user_data, mono_bool append))
+
+// This can point at NULL before the default ALC is initialized
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoAssemblyLoadContextGCHandle, mono_alc_get_default_gchandle, (void))
+
+MONO_API_FUNCTION(void, mono_register_bundled_satellite_assemblies, (const MonoBundledSatelliteAssembly **assemblies))
+
+MONO_API_FUNCTION(MonoBundledSatelliteAssembly *, mono_create_new_bundled_satellite_assembly, (const char *name, const char *culture, const unsigned char *data, unsigned int size))
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+/**
+ *
+ * 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_PRIVATE_UNSTABLE_TYPES_H
+#define _MONO_METADATA_PRIVATE_UNSTABLE_TYPES_H
+
+#include <mono/utils/details/mono-publib-types.h>
+#include <mono/utils/mono-forward.h>
+
+MONO_BEGIN_DECLS
+
+typedef MonoGCHandle MonoAssemblyLoadContextGCHandle;
+
+typedef MonoAssembly * (*MonoAssemblyPreLoadFuncV3) (MonoAssemblyLoadContextGCHandle alc_gchandle, MonoAssemblyName *aname, char **assemblies_path, void *user_data, MonoError *error);
+
+typedef struct _MonoBundledSatelliteAssembly MonoBundledSatelliteAssembly;
+
+typedef void * (*PInvokeOverrideFn) (const char *libraryName, const char *entrypointName);
+
+MONO_END_DECLS
+
+#endif /* _MONO_METADATA_PRIVATE_UNSTABLE_TYPES_H */
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY mono_unichar2 *, mono_string_chars, (MonoString *s))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY int, mono_string_length, (MonoString *s))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoObject *, mono_object_new, (MonoDomain *domain, MonoClass *klass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoObject *, mono_object_new_specific, (MonoVTable *vtable))
+
+/* can be used for classes without finalizer in non-profiling mode */
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoObject *, mono_object_new_fast, (MonoVTable *vtable))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoObject *, mono_object_new_alloc_specific, (MonoVTable *vtable))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoObject *, mono_object_new_from_token, (MonoDomain *domain, MonoImage *image, uint32_t token))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoArray*, mono_array_new, (MonoDomain *domain, MonoClass *eclass, uintptr_t n))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoArray*, mono_array_new_full, (MonoDomain *domain, MonoClass *array_class, uintptr_t *lengths, intptr_t *lower_bounds))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoArray *, mono_array_new_specific, (MonoVTable *vtable, uintptr_t n))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoArray*, mono_array_clone, (MonoArray *array))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY char*, mono_array_addr_with_size, (MonoArray *array, int size, uintptr_t idx))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY uintptr_t, mono_array_length, (MonoArray *array))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoString*, mono_string_empty, (MonoDomain *domain))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoString*, mono_string_empty_wrapper, (void))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoString*, mono_string_new_utf16, (MonoDomain *domain, const mono_unichar2 *text, int32_t len))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoString*, mono_string_new_size, (MonoDomain *domain, int32_t len))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoString*, mono_ldstr, (MonoDomain *domain, MonoImage *image, uint32_t str_index))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoString*, mono_string_is_interned, (MonoString *str))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoString*, mono_string_intern, (MonoString *str))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoString*, mono_string_new, (MonoDomain *domain, const char *text))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoString*, mono_string_new_wrapper, (const char *text))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoString*, mono_string_new_len, (MonoDomain *domain, const char *text, unsigned int length))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoString*, mono_string_new_utf32, (MonoDomain *domain, const mono_unichar4 *text, int32_t len))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY char *, mono_string_to_utf8, (MonoString *string_obj))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY char *, mono_string_to_utf8_checked, (MonoString *string_obj, MonoError *error))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY mono_unichar2 *, mono_string_to_utf16, (MonoString *string_obj))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY mono_unichar4 *, mono_string_to_utf32, (MonoString *string_obj))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoString *, mono_string_from_utf16, (/*const*/ mono_unichar2 *data))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoString *, mono_string_from_utf32, (/*const*/ mono_unichar4 *data))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY mono_bool, mono_string_equal, (MonoString *s1, MonoString *s2))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY unsigned int, mono_string_hash, (MonoString *s))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY int, mono_object_hash, (MonoObject* obj))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoString *, mono_object_to_string, (MonoObject *obj, MonoObject **exc))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoObject *, mono_value_box, (MonoDomain *domain, MonoClass *klass, void* val))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_value_copy, (void* dest, /*const*/ void* src, MonoClass *klass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_value_copy_array, (MonoArray *dest, int dest_idx, void* src, int count))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoVTable*, mono_object_get_vtable, (MonoObject *obj))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoDomain*, mono_object_get_domain, (MonoObject *obj))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoClass*, mono_object_get_class, (MonoObject *obj))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void*, mono_object_unbox, (MonoObject *obj))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoObject *, mono_object_clone, (MonoObject *obj))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoObject *, mono_object_isinst, (MonoObject *obj, MonoClass *klass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoObject *, mono_object_isinst_mbyref, (MonoObject *obj, MonoClass *klass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoObject *, mono_object_castclass_mbyref, (MonoObject *obj, MonoClass *klass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY mono_bool, mono_monitor_try_enter, (MonoObject *obj, uint32_t ms))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY mono_bool, mono_monitor_enter, (MonoObject *obj))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_monitor_enter_v4, (MonoObject *obj, char *lock_taken))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY unsigned int, mono_object_get_size, (MonoObject *o))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_monitor_exit, (MonoObject *obj))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_raise_exception, (MonoException *ex))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY mono_bool, mono_runtime_set_pending_exception, (MonoException *exc, mono_bool overwrite))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_reraise_exception, (MonoException *ex))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_runtime_object_init, (MonoObject *this_obj))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_runtime_class_init, (MonoVTable *vtable))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoDomain*, mono_vtable_domain, (MonoVTable *vtable))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoClass*, mono_vtable_class, (MonoVTable *vtable))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoMethod*, mono_object_get_virtual_method, (MonoObject *obj, MonoMethod *method))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoObject*, mono_runtime_invoke, (MonoMethod *method, void *obj, void **params, MonoObject **exc))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoMethod*, mono_get_delegate_invoke, (MonoClass *klass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoMethod*, mono_get_delegate_begin_invoke, (MonoClass *klass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoMethod*, mono_get_delegate_end_invoke, (MonoClass *klass))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoObject*, mono_runtime_delegate_invoke, (MonoObject *delegate, void **params, MonoObject **exc))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoObject*, mono_runtime_invoke_array, (MonoMethod *method, void *obj, MonoArray *params, MonoObject **exc))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void*, mono_method_get_unmanaged_thunk, (MonoMethod *method))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoArray*, mono_runtime_get_main_args, (void))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_runtime_exec_managed_code, (MonoDomain *domain, MonoMainThreadFunc main_func, void* main_args))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY int, mono_runtime_run_main, (MonoMethod *method, int argc, char* argv[],MonoObject **exc))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY int, mono_runtime_exec_main, (MonoMethod *method, MonoArray *args, MonoObject **exc))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY int, mono_runtime_set_main_args, (int argc, char* argv[]))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void*, mono_load_remote_field, (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, void **res))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoObject *, mono_load_remote_field_new, (MonoObject *this_obj, MonoClass *klass, MonoClassField *field))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_store_remote_field, (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, void* val))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_store_remote_field_new, (MonoObject *this_obj, MonoClass *klass, MonoClassField *field, MonoObject *arg))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_unhandled_exception, (MonoObject *exc))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_print_unhandled_exception, (MonoObject *exc))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void*, mono_compile_method, (MonoMethod *method))
+
+/* accessors for fields and properties */
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_field_set_value, (MonoObject *obj, MonoClassField *field, void *value))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_field_static_set_value, (MonoVTable *vt, MonoClassField *field, void *value))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_field_get_value, (MonoObject *obj, MonoClassField *field, void *value))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_field_static_get_value, (MonoVTable *vt, MonoClassField *field, void *value))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoObject *, mono_field_get_value_object, (MonoDomain *domain, MonoClassField *field, MonoObject *obj))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_property_set_value, (MonoProperty *prop, void *obj, void **params, MonoObject **exc))
+
+MONO_API_FUNCTION(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_FUNCTION(MONO_RT_EXTERNAL_ONLY uint32_t, mono_gchandle_new, (MonoObject *obj, mono_bool pinned))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY uint32_t, mono_gchandle_new_weakref, (MonoObject *obj, mono_bool track_resurrection))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoObject*, mono_gchandle_get_target, (uint32_t gchandle))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_gchandle_free, (uint32_t gchandle))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoGCHandle, mono_gchandle_new_v2, (MonoObject *obj, mono_bool pinned))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoGCHandle, mono_gchandle_new_weakref_v2, (MonoObject *obj, mono_bool track_resurrection))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoObject*, mono_gchandle_get_target_v2, (MonoGCHandle gchandle))
+MONO_API_FUNCTION(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.
+ */
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoReferenceQueue*, mono_gc_reference_queue_new, (mono_reference_queue_callback callback))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_gc_reference_queue_free, (MonoReferenceQueue *queue))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY mono_bool, mono_gc_reference_queue_add, (MonoReferenceQueue *queue, MonoObject *obj, void *user_data))
+
+/* GC write barriers support */
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_gc_wbarrier_set_field, (MonoObject *obj, void* field_ptr, MonoObject* value))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_gc_wbarrier_set_arrayref, (MonoArray *arr, void* slot_ptr, MonoObject* value))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_gc_wbarrier_arrayref_copy, (void* dest_ptr, /*const*/ void* src_ptr, int count))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_gc_wbarrier_generic_store, (void* ptr, MonoObject* value))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_gc_wbarrier_generic_store_atomic, (void *ptr, MonoObject *value))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_gc_wbarrier_generic_nostore, (void* ptr))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_gc_wbarrier_value_copy, (void* dest, /*const*/ void* src, int count, MonoClass *klass))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_gc_wbarrier_object_copy, (MonoObject* obj, MonoObject *src))
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+#ifndef _MONO_OBJECT_TYPES_H
+#define _MONO_OBJECT_TYPES_H
+
+#include <mono/utils/mono-forward.h>
+#include <mono/metadata/object-forward.h>
+#include <mono/metadata/details/class-types.h>
+#include <mono/utils/details/mono-error-types.h>
+
+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;
+typedef struct _MonoInternalThread MONO_RT_MANAGED_ATTR MonoThread;
+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);
+
+typedef void (*mono_reference_queue_callback) (void *user_data);
+typedef struct _MonoReferenceQueue MonoReferenceQueue;
+
+MONO_END_DECLS
+
+#endif /* _MONO_OBJECT_TYPES_H */
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(const char*, mono_opcode_name, (int opcode))
+
+MONO_API_FUNCTION(MonoOpcodeEnum, mono_opcode_value, (const mono_byte **ip, const mono_byte *end))
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+#ifndef _MONO_OPCODES_TYPES_H
+#define _MONO_OPCODES_TYPES_H
+
+#include <mono/utils/details/mono-publib-types.h>
+
+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_END_DECLS
+
+#endif /* _MONO_OPCODES_TYPES_H */
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(void, mono_profiler_load, (const char *desc))
+MONO_API_FUNCTION(MonoProfilerHandle, mono_profiler_create, (MonoProfiler *prof))
+MONO_API_FUNCTION(void, mono_profiler_set_cleanup_callback, (MonoProfilerHandle handle, MonoProfilerCleanupCallback cb))
+
+MONO_API_FUNCTION(mono_bool, mono_profiler_enable_coverage, (void))
+MONO_API_FUNCTION(void, mono_profiler_set_coverage_filter_callback, (MonoProfilerHandle handle, MonoProfilerCoverageFilterCallback cb))
+MONO_API_FUNCTION(mono_bool, mono_profiler_get_coverage_data, (MonoProfilerHandle handle, MonoMethod *method, MonoProfilerCoverageCallback cb))
+
+MONO_API_FUNCTION(mono_bool, mono_profiler_enable_sampling, (MonoProfilerHandle handle))
+MONO_API_FUNCTION(mono_bool, mono_profiler_set_sample_mode, (MonoProfilerHandle handle, MonoProfilerSampleMode mode, uint32_t freq))
+MONO_API_FUNCTION(mono_bool, mono_profiler_get_sample_mode, (MonoProfilerHandle handle, MonoProfilerSampleMode *mode, uint32_t *freq))
+
+MONO_API_FUNCTION(mono_bool, mono_profiler_enable_allocations, (void))
+MONO_API_FUNCTION(mono_bool, mono_profiler_enable_clauses, (void))
+
+MONO_API_FUNCTION(void, mono_profiler_set_call_instrumentation_filter_callback, (MonoProfilerHandle handle, MonoProfilerCallInstrumentationFilterCallback cb))
+MONO_API_FUNCTION(mono_bool, mono_profiler_enable_call_context_introspection, (void))
+MONO_API_FUNCTION(void *, mono_profiler_call_context_get_this, (MonoProfilerCallContext *context))
+MONO_API_FUNCTION(void *, mono_profiler_call_context_get_argument, (MonoProfilerCallContext *context, uint32_t position))
+MONO_API_FUNCTION(void *, mono_profiler_call_context_get_local, (MonoProfilerCallContext *context, uint32_t position))
+MONO_API_FUNCTION(void *, mono_profiler_call_context_get_result, (MonoProfilerCallContext *context))
+MONO_API_FUNCTION(void, mono_profiler_call_context_free_buffer, (void *buffer))
--- /dev/null
+// 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_TYPES_H
+#define _MONO_PROFILER_TYPES_H
+
+#include <mono/utils/details/mono-publib-types.h>
+#include <mono/metadata/details/appdomain-types.h>
+#include <mono/metadata/details/mono-gc-types.h>
+#include <mono/metadata/details/object-types.h>
+
+MONO_BEGIN_DECLS
+
+typedef struct _MonoProfiler MonoProfiler;
+typedef struct _MonoProfilerDesc *MonoProfilerHandle;
+
+typedef void (*MonoProfilerCleanupCallback) (MonoProfiler *prof);
+
+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);
+
+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;
+
+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);
+
+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;
+
+MONO_END_DECLS
+
+#endif /* _MONO_PROFILER_TYPES_H */
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY int, mono_reflection_parse_type, (char *name, MonoTypeNameParse *info))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoType*, mono_reflection_get_type, (MonoImage* image, MonoTypeNameParse *info, mono_bool ignorecase, mono_bool *type_resolve))
+MONO_API_FUNCTION(void, mono_reflection_free_type_info, (MonoTypeNameParse *info))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoType*, mono_reflection_type_from_name, (char *name, MonoImage *image))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY uint32_t, mono_reflection_get_token, (MonoObject *obj))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoReflectionAssembly*, mono_assembly_get_object, (MonoDomain *domain, MonoAssembly *assembly))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoReflectionModule*, mono_module_get_object, (MonoDomain *domain, MonoImage *image))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoReflectionModule*, mono_module_file_get_object, (MonoDomain *domain, MonoImage *image, int table_index))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoReflectionType*, mono_type_get_object, (MonoDomain *domain, MonoType *type))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoReflectionMethod*, mono_method_get_object, (MonoDomain *domain, MonoMethod *method, MonoClass *refclass))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoReflectionField*, mono_field_get_object, (MonoDomain *domain, MonoClass *klass, MonoClassField *field))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoReflectionProperty*, mono_property_get_object, (MonoDomain *domain, MonoClass *klass, MonoProperty *property))
+MONO_API_FUNCTION(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_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoArray*, mono_param_get_objects, (MonoDomain *domain, MonoMethod *method))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoReflectionMethodBody*, mono_method_body_get_object, (MonoDomain *domain, MonoMethod *method))
+
+MONO_API_FUNCTION(MonoObject *, mono_get_dbnull_object, (MonoDomain *domain))
+
+MONO_API_FUNCTION(MonoArray*, mono_reflection_get_custom_attrs_by_type, (MonoObject *obj, MonoClass *attr_klass, MonoError *error))
+MONO_API_FUNCTION(MonoArray*, mono_reflection_get_custom_attrs, (MonoObject *obj))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoArray*, mono_reflection_get_custom_attrs_data, (MonoObject *obj))
+MONO_API_FUNCTION(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_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoCustomAttrInfo*, mono_reflection_get_custom_attrs_info, (MonoObject *obj))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoArray*, mono_custom_attrs_construct, (MonoCustomAttrInfo *cinfo))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoCustomAttrInfo*, mono_custom_attrs_from_index, (MonoImage *image, uint32_t idx))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoCustomAttrInfo*, mono_custom_attrs_from_method, (MonoMethod *method))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoCustomAttrInfo*, mono_custom_attrs_from_class, (MonoClass *klass))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoCustomAttrInfo*, mono_custom_attrs_from_assembly, (MonoAssembly *assembly))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoCustomAttrInfo*, mono_custom_attrs_from_property, (MonoClass *klass, MonoProperty *property))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoCustomAttrInfo*, mono_custom_attrs_from_event, (MonoClass *klass, MonoEvent *event))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoCustomAttrInfo*, mono_custom_attrs_from_field, (MonoClass *klass, MonoClassField *field))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoCustomAttrInfo*, mono_custom_attrs_from_param, (MonoMethod *method, uint32_t param))
+MONO_API_FUNCTION(mono_bool, mono_custom_attrs_has_attr, (MonoCustomAttrInfo *ainfo, MonoClass *attr_klass))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoObject*, mono_custom_attrs_get_attr, (MonoCustomAttrInfo *ainfo, MonoClass *attr_klass))
+MONO_API_FUNCTION(void, mono_custom_attrs_free, (MonoCustomAttrInfo *ainfo))
+
+
+MONO_API_FUNCTION(uint32_t, mono_declsec_flags_from_method, (MonoMethod *method))
+MONO_API_FUNCTION(uint32_t, mono_declsec_flags_from_class, (MonoClass *klass))
+MONO_API_FUNCTION(uint32_t, mono_declsec_flags_from_assembly, (MonoAssembly *assembly))
+
+MONO_API_FUNCTION(MonoBoolean, mono_declsec_get_demands, (MonoMethod *callee, MonoDeclSecurityActions* demands))
+MONO_API_FUNCTION(MonoBoolean, mono_declsec_get_linkdemands, (MonoMethod *callee, MonoDeclSecurityActions* klass, MonoDeclSecurityActions* cmethod))
+MONO_API_FUNCTION(MonoBoolean, mono_declsec_get_inheritdemands_class, (MonoClass *klass, MonoDeclSecurityActions* demands))
+MONO_API_FUNCTION(MonoBoolean, mono_declsec_get_inheritdemands_method, (MonoMethod *callee, MonoDeclSecurityActions* demands))
+
+MONO_API_FUNCTION(MonoBoolean, mono_declsec_get_method_action, (MonoMethod *method, uint32_t action, MonoDeclSecurityEntry *entry))
+MONO_API_FUNCTION(MonoBoolean, mono_declsec_get_class_action, (MonoClass *klass, uint32_t action, MonoDeclSecurityEntry *entry))
+MONO_API_FUNCTION(MonoBoolean, mono_declsec_get_assembly_action, (MonoAssembly *assembly, uint32_t action, MonoDeclSecurityEntry *entry))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoType*, mono_reflection_type_get_type, (MonoReflectionType *reftype))
+
+MONO_API_FUNCTION(MonoAssembly*, mono_reflection_assembly_get_assembly, (MonoReflectionAssembly *refassembly))
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+#ifndef _MONO_REFLECTION_TYPES_H
+#define _MONO_REFLECTION_TYPES_H
+
+#include <mono/utils/details/mono-publib-types.h>
+#include <mono/metadata/details/object-types.h>
+
+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;
+
+#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
+};
+
+/* 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_END_DECLS
+
+#endif /* _MONO_REFLECTION_TYPES_H */
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+/*
+ * 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_FUNCTION(void, mono_gc_register_bridge_callbacks, (MonoGCBridgeCallbacks *callbacks))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_gc_wait_for_bridge_processing, (void))
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+#ifndef _MONO_SGEN_BRIDGE_TYPES_H
+#define _MONO_SGEN_BRIDGE_TYPES_H
+
+#include <mono/utils/details/mono-publib-types.h>
+
+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<object>*/
+ 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;
+
+MONO_END_DECLS
+
+#endif /* _MONO_SGEN_BRIDGE_TYPES_H */
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(void, mono_thread_init, (MonoThreadStartCB start_cb, MonoThreadAttachCB attach_cb))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_thread_cleanup, (void))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_thread_manage, (void))
+
+MONO_API_FUNCTION(MonoThread *, mono_thread_current, (void))
+
+MONO_API_FUNCTION(void, mono_thread_set_main, (MonoThread *thread))
+MONO_API_FUNCTION(MonoThread *, mono_thread_get_main, (void))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_thread_stop, (MonoThread *thread))
+
+MONO_API_FUNCTION(void, mono_thread_new_init, (intptr_t tid, void* stack_start, void* func))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_thread_create, (MonoDomain *domain, void* func, void* arg))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY MonoThread *, mono_thread_attach, (MonoDomain *domain))
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_thread_detach, (MonoThread *thread))
+MONO_API_FUNCTION(void, mono_thread_exit, (void))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_threads_attach_tools_thread, (void))
+
+MONO_API_FUNCTION(char *, mono_thread_get_name_utf8, (MonoThread *thread))
+MONO_API_FUNCTION(int32_t, mono_thread_get_managed_id, (MonoThread *thread))
+
+MONO_API_FUNCTION(void, mono_thread_set_manage_callback, (MonoThread *thread, MonoThreadManageCallback func))
+
+MONO_API_FUNCTION(void, mono_threads_set_default_stacksize, (uint32_t stacksize))
+MONO_API_FUNCTION(uint32_t, mono_threads_get_default_stacksize, (void))
+
+MONO_API_FUNCTION(void, mono_threads_request_thread_dump, (void))
+
+MONO_API_FUNCTION(mono_bool, mono_thread_is_foreign, (MonoThread *thread))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY mono_bool, mono_thread_detach_if_exiting, (void))
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+#ifndef _MONO_METADATA_DETAILS_THREADS_TYPES_H
+#define _MONO_METADATA_DETAILS_THREADS_TYPES_H
+
+#include <mono/utils/details/mono-publib-types.h>
+#include <mono/metadata/details/object-types.h>
+#include <mono/metadata/details/appdomain-types.h>
+
+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_END_DECLS
+
+#endif /* _MONO_METADATA_DETAILS_THREADS_TYPES_H */
MONO_BEGIN_DECLS
-MONO_API int32_t mono_environment_exitcode_get (void);
-MONO_API void mono_environment_exitcode_set (int32_t value);
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/metadata/details/environment-functions.h>
+#undef MONO_API_FUNCTION
MONO_END_DECLS
#ifndef _MONO_METADATA_EXCEPTION_H_
#define _MONO_METADATA_EXCEPTION_H_
-#include <mono/metadata/object-forward.h>
-#include <mono/metadata/object.h>
-#include <mono/metadata/image.h>
+#include <mono/metadata/details/exception-types.h>
MONO_BEGIN_DECLS
-MONO_API MonoException *
-mono_exception_from_name (MonoImage *image,
- const char* name_space,
- const char *name);
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/metadata/details/exception-functions.h>
+#undef MONO_API_FUNCTION
-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
#ifndef _MONONET_METADATA_IMAGE_H_
#define _MONONET_METADATA_IMAGE_H_
-#include <stdio.h>
-#include <mono/utils/mono-publib.h>
-#include <mono/utils/mono-error.h>
-#include <mono/metadata/object-forward.h>
+#include <mono/metadata/details/image-types.h>
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 MONO_RT_EXTERNAL_ONLY 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);
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/metadata/details/image-functions.h>
+#undef MONO_API_FUNCTION
mono_bool mono_has_pdb_checksum (char *raw_data, uint32_t raw_data_len);
#ifndef _MONO_METADATA_LOADER_H_
#define _MONO_METADATA_LOADER_H_ 1
-#include <mono/utils/mono-forward.h>
-#include <mono/metadata/metadata.h>
-#include <mono/metadata/image.h>
-#include <mono/utils/mono-error.h>
+#include <mono/metadata/details/loader-types.h>
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);
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/metadata/details/loader-functions.h>
+#undef MONO_API_FUNCTION
MONO_END_DECLS
#ifndef __MONO_METADATA_H__
#define __MONO_METADATA_H__
-#include <mono/utils/mono-publib.h>
-
-#include <mono/utils/mono-forward.h>
-#include <mono/metadata/blob.h>
-#include <mono/metadata/row-indexes.h>
-#include <mono/metadata/image.h>
-#include <mono/metadata/object-forward.h>
+#include <mono/metadata/details/metadata-types.h>
MONO_BEGIN_DECLS
#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 = 0x05,
- /* unused, */
- /* unused, */
- /* unused, */
- MONO_CALL_UNMANAGED_MD = 0x09, /* default unmanaged calling convention, with additional attributed encoded in modopts */
-} 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 MONO_RT_EXTERNAL_ONLY
-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) \
#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_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);
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/metadata/details/metadata-functions.h>
+#undef MONO_API_FUNCTION
MONO_END_DECLS
#ifndef __MONO_METADATA_CONFIG_H__
#define __MONO_METADATA_CONFIG_H__
-#include <mono/utils/mono-publib.h>
-#include <mono/metadata/image.h>
+#include <mono/metadata/details/mono-config-types.h>
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);
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/metadata/details/mono-config-functions.h>
+#undef MONO_API_FUNCTION
MONO_END_DECLS
#ifndef __MONO_DEBUG_H__
#define __MONO_DEBUG_H__
-#include <mono/utils/mono-publib.h>
-#include <mono/metadata/image.h>
-#include <mono/metadata/appdomain.h>
+#include <mono/metadata/details/mono-debug-types.h>
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 MONO_RT_EXTERNAL_ONLY 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);
-
-MONO_API 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);
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/metadata/details/mono-debug-functions.h>
+#undef MONO_API_FUNCTION
MONO_END_DECLS
#ifndef __METADATA_MONO_GC_H__
#define __METADATA_MONO_GC_H__
-#include <mono/metadata/object.h>
+#include <mono/metadata/details/mono-gc-types.h>
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_generation_size (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);
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/metadata/details/mono-gc-functions.h>
+#undef MONO_API_FUNCTION
MONO_END_DECLS
#include <mono/utils/mono-forward.h>
#include <mono/utils/mono-publib.h>
-typedef MonoGCHandle MonoAssemblyLoadContextGCHandle;
+#include <mono/metadata/details/mono-private-unstable-types.h>
-MONO_API MONO_RT_EXTERNAL_ONLY MonoAssembly *
-mono_assembly_load_full_alc (MonoAssemblyLoadContextGCHandle alc_gchandle, MonoAssemblyName *aname, const char *basedir, MonoImageOpenStatus *status);
+MONO_BEGIN_DECLS
-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);
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/metadata/details/mono-private-unstable-functions.h>
+#undef MONO_API_FUNCTION
-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);
-
-// This can point at NULL before the default ALC is initialized
-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);
-
-typedef void * (*PInvokeOverrideFn) (const char *libraryName, const char *entrypointName);
+MONO_END_DECLS
#endif /*__MONO_METADATA_MONO_PRIVATE_UNSTABLE_H__*/
#ifndef __MONO_OBJECT_FORWARD_H__
#define __MONO_OBJECT_FORWARD_H__
-#include <mono/utils/mono-publib.h>
+#include <mono/utils/details/mono-publib-types.h>
typedef struct _MonoClass MonoClass;
typedef struct _MonoImage MonoImage;
#ifndef _MONO_CLI_OBJECT_H_
#define _MONO_CLI_OBJECT_H_
-#include <mono/utils/mono-forward.h>
-#include <mono/metadata/object-forward.h>
-#include <mono/metadata/class.h>
-#include <mono/utils/mono-error.h>
+#include <mono/metadata/details/object-types.h>
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;
-typedef struct _MonoInternalThread MONO_RT_MANAGED_ATTR MonoThread;
-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_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/metadata/details/object-functions.h>
+#undef MONO_API_FUNCTION
#define MONO_OBJECT_SETREF(obj,fieldname,value) do { \
mono_gc_wbarrier_set_field ((MonoObject*)(obj), &((obj)->fieldname), (MonoObject*)value); \
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[]);
-
-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);
-
-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
* (C) 2002 Ximian, Inc.
*/
-#include <mono/utils/mono-publib.h>
-
-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;
+#include <mono/metadata/details/opcodes-types.h>
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);
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/metadata/details/opcodes-functions.h>
+#undef MONO_API_FUNCTION
MONO_END_DECLS
#endif /* __MONO_METADATA_OPCODES_H__ */
#ifndef __MONO_PROFILER_H__
#define __MONO_PROFILER_H__
-#include <mono/metadata/appdomain.h>
-#include <mono/metadata/mono-gc.h>
-#include <mono/metadata/object.h>
+#include <mono/metadata/details/profiler-types.h>
MONO_BEGIN_DECLS
*/
#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;
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/metadata/details/profiler-functions.h>
+#undef MONO_API_FUNCTION
/*
* The macros below will generate the majority of the callback API. Refer to
#ifndef __METADATA_REFLECTION_H__
#define __METADATA_REFLECTION_H__
-#include <mono/utils/mono-publib.h>
-#include <mono/metadata/object.h>
+#include <mono/metadata/details/reflection-types.h>
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);
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/metadata/details/reflection-functions.h>
+#undef MONO_API_FUNCTION
MONO_END_DECLS
#include <mono/utils/mono-publib.h>
-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<object>*/
- 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;
+#include <mono/metadata/details/sgen-bridge-types.h>
-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_BEGIN_DECLS
-MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_wait_for_bridge_processing (void);
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/metadata/details/sgen-bridge-functions.h>
+#undef MONO_API_FUNCTION
MONO_END_DECLS
#ifndef _MONO_METADATA_THREADS_H_
#define _MONO_METADATA_THREADS_H_
-#include <mono/utils/mono-publib.h>
-#include <mono/metadata/object.h>
-#include <mono/metadata/appdomain.h>
+#include <mono/metadata/details/threads-types.h>
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 MONO_RT_EXTERNAL_ONLY 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);
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/metadata/details/threads-functions.h>
+#undef MONO_API_FUNCTION
MONO_END_DECLS
+++ /dev/null
-/**
- * \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/metadata/appdomain.h>
-
-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,
- /*
- * Use interpreter only, no native code is generated
- * at runtime. Trampolines are loaded from corlib aot image.
- */
- 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
-
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(void, mono_counters_enable, (int section_mask))
+MONO_API_FUNCTION(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_FUNCTION(void, mono_counters_register, (const char* descr, int type, void *addr))
+MONO_API_FUNCTION(void, mono_counters_register_with_size, (const char *name, int type, void *addr, int size))
+
+MONO_API_FUNCTION(void, mono_counters_on_register, (MonoCounterRegisterCallback callback))
+
+/*
+ * Create a readable dump of the counters for section_mask sections (ORed section values)
+ */
+MONO_API_FUNCTION(void, mono_counters_dump, (int section_mask, FILE *outfile))
+
+MONO_API_FUNCTION(void, mono_counters_cleanup, (void))
+
+MONO_API_FUNCTION(void, mono_counters_foreach, (CountersEnumCallback cb, void *user_data))
+
+MONO_API_FUNCTION(int, mono_counters_sample, (MonoCounter *counter, void *buffer, int buffer_size))
+
+MONO_API_FUNCTION(const char*, mono_counter_get_name, (MonoCounter *name))
+MONO_API_FUNCTION(int, mono_counter_get_type, (MonoCounter *counter))
+MONO_API_FUNCTION(int, mono_counter_get_section, (MonoCounter *counter))
+MONO_API_FUNCTION(int, mono_counter_get_unit, (MonoCounter *counter))
+MONO_API_FUNCTION(int, mono_counter_get_variance, (MonoCounter *counter))
+MONO_API_FUNCTION(size_t, mono_counter_get_size, (MonoCounter *counter))
+
+MONO_API_FUNCTION(int, mono_runtime_resource_limit, (int resource_type, uintptr_t soft_limit, uintptr_t hard_limit))
+MONO_API_FUNCTION(void, mono_runtime_resource_set_callback, (MonoResourceCallback callback))
+MONO_API_FUNCTION(void, mono_runtime_resource_check_limit, (int resource_type, uintptr_t value))
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+#ifndef _MONO_COUNTERS_TYPES_H
+#define _MONO_COUNTERS_TYPES_H
+
+#include <stdio.h>
+#include <mono/utils/details/mono-publib-types.h>
+
+MONO_BEGIN_DECLS
+
+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;
+
+typedef void (*MonoCounterRegisterCallback) (MonoCounter*);
+
+typedef mono_bool (*CountersEnumCallback) (MonoCounter *counter, void *user_data);
+
+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_END_DECLS
+
+#endif /* _MONO_COUNTERS_TYPES_H */
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(MonoDlFallbackHandler *, mono_dl_fallback_register, (MonoDlFallbackLoad load_func, MonoDlFallbackSymbol symbol_func, \
+ MonoDlFallbackClose close_func, void *user_data))
+MONO_API_FUNCTION(void, mono_dl_fallback_unregister, (MonoDlFallbackHandler *handler))
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+#ifndef _MONO_DL_FALLBACK_TYPES_H
+#define _MONO_DL_FALLBACK_TYPES_H
+
+#include <mono/utils/details/mono-publib-types.h>
+
+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_END_DECLS
+
+#endif
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY void, mono_error_init, (MonoError *error))
+MONO_API_FUNCTION(void, mono_error_init_flags, (MonoError *error, unsigned short flags))
+
+MONO_API_FUNCTION(void, mono_error_cleanup, (MonoError *error))
+
+MONO_API_FUNCTION(MONO_RT_EXTERNAL_ONLY mono_bool, mono_error_ok, (MonoError *error))
+
+MONO_API_FUNCTION(unsigned short, mono_error_get_error_code, (MonoError *error))
+
+MONO_API_FUNCTION(const char*, mono_error_get_message, (MonoError *error))
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+#ifndef _MONO_ERROR_TYPES_H
+#define _MONO_ERROR_TYPES_H
+
+#include <mono/utils/details/mono-publib-types.h>
+
+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;
+
+#endif
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(void, mono_trace_set_level_string, (const char *value))
+
+MONO_API_FUNCTION(void, mono_trace_set_mask_string, (const char *value))
+
+MONO_API_FUNCTION(void, mono_trace_set_log_handler, (MonoLogCallback callback, void *user_data))
+
+MONO_API_FUNCTION(void, mono_trace_set_print_handler, (MonoPrintCallback callback))
+
+MONO_API_FUNCTION(void, mono_trace_set_printerr_handler, (MonoPrintCallback callback))
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+#ifndef _MONO_LOGGER_TYPES_H
+#define _MONO_LOGGER_TYPES_H
+
+#include <mono/utils/details/mono-publib-types.h>
+
+MONO_BEGIN_DECLS
+
+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_END_DECLS
+
+#endif /* _MONO_LOGGER_TYPES_H */
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// This file does not have ifdef guards, it is meant to be included multiple times with different definitions of MONO_API_FUNCTION
+#ifndef MONO_API_FUNCTION
+#error "MONO_API_FUNCTION(ret,name,args) macro not defined before including function declaration header"
+#endif
+
+MONO_API_FUNCTION(void, mono_free, (void*))
+MONO_API_FUNCTION(mono_bool, mono_set_allocator_vtable, (MonoAllocatorVTable* vtable))
+
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+#ifndef _MONO_PUBLIB_TYPES_H
+#define _MONO_PUBLIB_TYPES_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 <stdint.h>
+
+#endif
+
+#define MONO_API_EXPORT __declspec(dllexport)
+#define MONO_API_IMPORT __declspec(dllimport)
+
+#else
+
+#include <stdint.h>
+
+#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 <stdlib.h>
+
+#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 <wchar.h>
+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);
+
+#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;
+
+#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_TYPES_H */
#ifndef __MONO_COUNTERS_H__
#define __MONO_COUNTERS_H__
-#include <stdio.h>
-#include <mono/utils/mono-publib.h>
+#include <mono/utils/details/mono-counters-types.h>
-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,
+MONO_BEGIN_DECLS
- /* 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. */
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/utils/details/mono-counters-functions.h>
+#undef MONO_API_FUNCTION
- /* 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);
+MONO_END_DECLS
#endif /* __MONO_COUNTERS_H__ */
#ifndef __MONO_UTILS_DL_FALLBACK_H__
#define __MONO_UTILS_DL_FALLBACK_H__
-#include <mono/utils/mono-publib.h>
+#include <mono/utils/details/mono-dl-fallback-types.h>
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);
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/utils/details/mono-dl-fallback-functions.h>
+#undef MONO_API_FUNCTION
MONO_END_DECLS
#ifndef __MONO_ERROR_H__
#define __MONO_ERROR_H__
-#include <mono/utils/mono-publib.h>
-
-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;
+#include <mono/utils/details/mono-error-types.h>
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);
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/utils/details/mono-error-functions.h>
+#undef MONO_API_FUNCTION
MONO_END_DECLS
#include <mono/utils/mono-publib.h>
MONO_BEGIN_DECLS
-MONO_API void
-mono_trace_set_level_string (const char *value);
+#include <mono/utils/details/mono-logger-types.h>
-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);
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/utils/details/mono-logger-functions.h>
+#undef MONO_API_FUNCTION
MONO_END_DECLS
#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 <stdint.h>
-
-#endif
-
-#define MONO_API_EXPORT __declspec(dllexport)
-#define MONO_API_IMPORT __declspec(dllimport)
-
-#else
-
-#include <stdint.h>
-
-#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 <stdlib.h>
-
-#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
+#include <mono/utils/details/mono-publib-types.h>
-// 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 <wchar.h>
-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
+#define MONO_API_FUNCTION(ret,name,args) MONO_API ret name args;
+#include <mono/utils/details/mono-publib-functions.h>
+#undef MONO_API_FUNCTION
MONO_END_DECLS
mono-jemalloc.h
mono-dl-fallback.h
mono-private-unstable.h
- mono-counters.h)
-addprefix(utils_public_headers ./mono/utils "${utils_public_headers_base}")
+ mono-counters.h
+ )
+set(utils_public_headers_details_base
+ details/mono-publib-types.h
+ details/mono-publib-functions.h
+ details/mono-logger-types.h
+ details/mono-logger-functions.h
+ details/mono-error-types.h
+ details/mono-error-functions.h
+ details/mono-dl-fallback-types.h
+ details/mono-dl-fallback-functions.h
+ details/mono-counters-types.h
+ details/mono-counters-functions.h
+ )
+addprefix(utils_public_headers mono/utils "${utils_public_headers_base}")
+addprefix(utils_public_headers_details mono/utils "${utils_public_headers_details_base}")
-target_sources(monoapi_utils INTERFACE ${utils_public_headers})
+target_sources(monoapi_utils INTERFACE ${utils_public_headers} ${utils_public_headers_details})
target_include_directories(monoapi_utils INTERFACE .)
-set_target_properties(monoapi_utils PROPERTIES PUBLIC_HEADER "${utils_public_headers}")
-
add_library(monoapi_metadata INTERFACE)
set(metadata_public_headers_base
sgen-bridge.h
threads.h
tokentype.h
- verify.h)
-addprefix(metadata_public_headers ./mono/metadata/ "${metadata_public_headers_base}")
+ verify.h
+ )
+set(metadata_public_headers_details_base
+ details/environment-functions.h
+ details/opcodes-types.h
+ details/opcodes-functions.h
+ details/sgen-bridge-types.h
+ details/sgen-bridge-functions.h
+ details/image-types.h
+ details/image-functions.h
+ details/metadata-types.h
+ details/metadata-functions.h
+ details/assembly-types.h
+ details/assembly-functions.h
+ details/loader-types.h
+ details/loader-functions.h
+ details/class-types.h
+ details/class-functions.h
+ details/object-types.h
+ details/object-functions.h
+ details/exception-types.h
+ details/exception-functions.h
+ details/reflection-types.h
+ details/reflection-functions.h
+ details/appdomain-types.h
+ details/appdomain-functions.h
+ details/threads-types.h
+ details/threads-functions.h
+ details/debug-helpers-types.h
+ details/debug-helpers-functions.h
+ details/mono-debug-types.h
+ details/mono-debug-functions.h
+ details/mono-gc-types.h
+ details/mono-gc-functions.h
+ details/mono-config-types.h
+ details/mono-config-functions.h
+ details/profiler-types.h
+ details/profiler-functions.h
+ details/mono-private-unstable-types.h
+ details/mono-private-unstable-functions.h
+ )
+addprefix(metadata_public_headers mono/metadata "${metadata_public_headers_base}")
+addprefix(metadata_public_headers_details mono/metadata "${metadata_public_headers_details_base}")
+
+target_sources(monoapi_metadata INTERFACE ${metadata_public_headers} ${metadata_public_headers_details})
-set_target_properties(monoapi_metadata PROPERTIES PUBLIC_HEADER "${metadata_public_headers}")
+target_include_directories(monoapi_metadata INTERFACE .)
-add_library(monoapi_mini INTERFACE)
+add_library(monoapi_jit INTERFACE)
-set(mini_public_headers_base
+set(jit_public_headers_base
jit.h
- mono-private-unstable.h)
-addprefix(mini_public_headers ./mono/mini "${mini_public_headers_base}")
+ mono-private-unstable.h
+ )
+set(jit_public_headers_details_base
+ details/jit-types.h
+ details/jit-functions.h
+ details/mono-private-unstable-types.h
+ details/mono-private-unstable-functions.h
+ )
+addprefix(jit_public_headers mono/jit "${jit_public_headers_base}")
+addprefix(jit_public_headers_details mono/jit "${jit_public_headers_details_base}")
+
+target_sources(monoapi_jit INTERFACE ${jit_public_headers} ${jit_public_headers_details})
+
+target_include_directories(monoapi_jit INTERFACE .)
-set_target_properties(monoapi_mini PROPERTIES PUBLIC_HEADER "${mini_public_headers}")
add_library(monoapi INTERFACE)
-target_link_libraries(monoapi INTERFACE monoapi_utils monoapi_metadata monoapi_mini)
+target_link_libraries(monoapi INTERFACE monoapi_utils monoapi_metadata monoapi_jit)
if(INSTALL_MONO_API)
- install(TARGETS monoapi_utils PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/mono-2.0/mono/utils)
- install(TARGETS monoapi_metadata PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/mono-2.0/mono/metadata)
- install(TARGETS monoapi_mini PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/mono-2.0/mono/jit)
+ install(FILES ${utils_public_headers} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/mono-2.0/mono/utils)
+ install(FILES ${utils_public_headers_details} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/mono-2.0/mono/utils/details)
+ install(FILES ${metadata_public_headers} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/mono-2.0/mono/metadata)
+ install(FILES ${metadata_public_headers_details} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/mono-2.0/mono/metadata/details)
+ install(FILES ${jit_public_headers} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/mono-2.0/mono/jit)
+ install(FILES ${jit_public_headers_details} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/mono-2.0/mono/jit/details)
endif()
#include <mono/utils/mono-publib.h>
#include <mono/utils/mono-logger.h>
#include <mono/metadata/assembly.h>
+#include <mono/metadata/appdomain.h>
+#include <mono/metadata/class.h>
#include <mono/metadata/mono-debug.h>
#include <mono/metadata/mono-gc.h>
#include <mono/metadata/exception.h>
+#include <mono/metadata/object.h>
#include <mono/jit/jit.h>
#include <mono/jit/mono-private-unstable.h>
#include <TargetConditionals.h>
projects / platform / upstream / dotnet / runtime.git / commitdiff