From 181093864f34faa597e994bbd4de7525035fb243 Mon Sep 17 00:00:00 2001 From: Zoltan Varga Date: Thu, 5 Mar 2015 17:06:29 -0500 Subject: [PATCH] [runtime] Remove the usage of MONO_INTERNAL, use MONO_API to mark exported functions and -fvisibility=hidden to exclude everything else. --- mono/metadata/attach.h | 10 +- mono/metadata/class-internals.h | 258 +++++++++--------- mono/metadata/cominterop.h | 18 +- mono/metadata/console-io.h | 16 +- mono/metadata/coree.h | 16 +- mono/metadata/decimal-ms.h | 24 +- mono/metadata/domain-internals.h | 142 +++++----- mono/metadata/environment.c | 2 +- mono/metadata/file-io.h | 76 +++--- mono/metadata/file-mmap.h | 14 +- mono/metadata/filewatcher.h | 10 +- mono/metadata/gc-internal.h | 194 +++++++------- mono/metadata/icall.c | 2 +- mono/metadata/locales.h | 46 ++-- mono/metadata/lock-tracer.h | 6 +- mono/metadata/marshal.h | 250 ++++++++--------- mono/metadata/mempool-internals.h | 2 +- mono/metadata/metadata-internals.h | 154 +++++------ mono/metadata/method-builder.h | 74 ++--- mono/metadata/monitor.h | 22 +- mono/metadata/mono-basic-block.h | 8 +- mono/metadata/mono-cq.h | 10 +- mono/metadata/mono-debug-debugger.h | 8 +- mono/metadata/mono-perfcounters.h | 24 +- mono/metadata/mono-route.h | 4 +- mono/metadata/mono-wsq.h | 18 +- mono/metadata/object-internals.h | 218 +++++++-------- mono/metadata/process.h | 42 +-- mono/metadata/profiler-private.h | 112 ++++---- mono/metadata/rand.h | 8 +- mono/metadata/reflection-internals.h | 2 +- mono/metadata/remoting.h | 22 +- mono/metadata/runtime.h | 6 +- mono/metadata/security-core-clr.h | 26 +- mono/metadata/security-manager.h | 28 +- mono/metadata/security.h | 40 +-- mono/metadata/sgen-cardtable.h | 20 +- mono/metadata/sgen-descriptor.h | 12 +- mono/metadata/sgen-gc.h | 302 ++++++++++----------- mono/metadata/sgen-gray.h | 38 +-- mono/metadata/sgen-hash-table.h | 14 +- mono/metadata/sgen-layout-stats.h | 10 +- mono/metadata/sgen-memory-governor.h | 32 +-- mono/metadata/sgen-nursery-allocator.c | 4 +- mono/metadata/sgen-pinning.h | 50 ++-- mono/metadata/sgen-pointer-queue.h | 20 +- mono/metadata/sgen-protocol.h | 20 +- mono/metadata/sgen-workers.h | 30 +-- mono/metadata/socket-io.h | 64 ++--- mono/metadata/string-icalls.h | 12 +- mono/metadata/sysmath.h | 36 +-- mono/metadata/threadpool-internals.h | 18 +- mono/metadata/threadpool.h | 30 +-- mono/metadata/threads-types.h | 356 ++++++++++++------------- mono/metadata/verify-internals.h | 76 +++--- mono/utils/hazard-pointer.h | 22 +- mono/utils/lock-free-alloc.h | 10 +- mono/utils/lock-free-array-queue.h | 12 +- mono/utils/lock-free-queue.h | 10 +- mono/utils/mach-support.h | 26 +- mono/utils/mono-compiler.h | 4 +- mono/utils/mono-conc-hashtable.h | 12 +- mono/utils/mono-context.h | 4 +- mono/utils/mono-dl.h | 20 +- mono/utils/mono-error-internals.h | 38 +-- mono/utils/mono-hwcap.h | 6 +- mono/utils/mono-internal-hash.h | 10 +- mono/utils/mono-io-portability.h | 6 +- mono/utils/mono-linked-list-set.h | 8 +- mono/utils/mono-logger-internal.h | 16 +- mono/utils/mono-mmap-internal.h | 2 +- mono/utils/mono-networkinterfaces.h | 4 +- mono/utils/mono-proclib.h | 16 +- mono/utils/mono-threads-mach-helper.c | 6 +- mono/utils/mono-threads.h | 110 ++++---- mono/utils/mono-time.h | 6 +- mono/utils/mono-value-hash.h | 8 +- mono/utils/networking.h | 26 +- mono/utils/strtod.h | 2 +- 79 files changed, 1719 insertions(+), 1721 deletions(-) mode change 100755 => 100644 mono/utils/mono-context.h diff --git a/mono/metadata/attach.h b/mono/metadata/attach.h index b396ed12ed2..7a5fb7e7347 100644 --- a/mono/metadata/attach.h +++ b/mono/metadata/attach.h @@ -7,19 +7,19 @@ G_BEGIN_DECLS void -mono_attach_parse_options (char *options) MONO_INTERNAL; +mono_attach_parse_options (char *options); void -mono_attach_init (void) MONO_INTERNAL; +mono_attach_init (void); gboolean -mono_attach_start (void) MONO_INTERNAL; +mono_attach_start (void); void -mono_attach_maybe_start (void) MONO_INTERNAL; +mono_attach_maybe_start (void); void -mono_attach_cleanup (void) MONO_INTERNAL; +mono_attach_cleanup (void); G_END_DECLS diff --git a/mono/metadata/class-internals.h b/mono/metadata/class-internals.h index 8f9cfb37460..fcd8a85963d 100644 --- a/mono/metadata/class-internals.h +++ b/mono/metadata/class-internals.h @@ -410,8 +410,8 @@ struct _MonoClass { }; #ifdef COMPRESSED_INTERFACE_BITMAP -int mono_compress_bitmap (uint8_t *dest, const uint8_t *bitmap, int size) MONO_INTERNAL; -int mono_class_interface_match (const uint8_t *bitmap, int id) MONO_INTERNAL; +int mono_compress_bitmap (uint8_t *dest, const uint8_t *bitmap, int size); +int mono_class_interface_match (const uint8_t *bitmap, int id); #else #define mono_class_interface_match(bmap,uiid) ((bmap) [(uiid) >> 3] & (1 << ((uiid)&7))) #endif @@ -442,7 +442,7 @@ int mono_class_interface_match (const uint8_t *bitmap, int id) MONO_INTERNAL; MONO_API int mono_class_interface_offset (MonoClass *klass, MonoClass *itf); -int mono_class_interface_offset_with_variance (MonoClass *klass, MonoClass *itf, gboolean *non_exact_match) MONO_INTERNAL; +int mono_class_interface_offset_with_variance (MonoClass *klass, MonoClass *itf, gboolean *non_exact_match); typedef gpointer MonoRuntimeGenericContext; @@ -678,10 +678,10 @@ typedef struct { } MonoLoaderError; void -mono_class_setup_supertypes (MonoClass *klass) MONO_INTERNAL; +mono_class_setup_supertypes (MonoClass *klass); void -mono_class_setup_fields_locking (MonoClass *klass) MONO_INTERNAL; +mono_class_setup_fields_locking (MonoClass *klass); /* WARNING * Only call this function if you can ensure both @klass and @parent @@ -837,7 +837,7 @@ typedef struct { guint threadpool_iothreads; } MonoPerfCounters; -extern MonoPerfCounters *mono_perfcounters MONO_INTERNAL; +extern MonoPerfCounters *mono_perfcounters; MONO_API void mono_perfcounters_init (void); @@ -876,7 +876,7 @@ enum { #define MONO_GENERIC_CONTEXT_USED_BOTH (MONO_GENERIC_CONTEXT_USED_CLASS | MONO_GENERIC_CONTEXT_USED_METHOD) -extern MonoStats mono_stats MONO_INTERNAL; +extern MonoStats mono_stats; typedef gpointer (*MonoTrampoline) (MonoMethod *method); typedef gpointer (*MonoJumpTrampoline) (MonoDomain *domain, MonoMethod *method, gboolean add_sync_wrapper); @@ -900,162 +900,162 @@ method_is_dynamic (MonoMethod *method) } void -mono_classes_init (void) MONO_INTERNAL; +mono_classes_init (void); void -mono_classes_cleanup (void) MONO_INTERNAL; +mono_classes_cleanup (void); void -mono_class_layout_fields (MonoClass *klass) MONO_INTERNAL; +mono_class_layout_fields (MonoClass *klass); void -mono_class_setup_interface_offsets (MonoClass *klass) MONO_INTERNAL; +mono_class_setup_interface_offsets (MonoClass *klass); void -mono_class_setup_vtable_general (MonoClass *klass, MonoMethod **overrides, int onum, GList *in_setup) MONO_INTERNAL; +mono_class_setup_vtable_general (MonoClass *klass, MonoMethod **overrides, int onum, GList *in_setup); void -mono_class_setup_vtable (MonoClass *klass) MONO_INTERNAL; +mono_class_setup_vtable (MonoClass *klass); void -mono_class_setup_methods (MonoClass *klass) MONO_INTERNAL; +mono_class_setup_methods (MonoClass *klass); void -mono_class_setup_mono_type (MonoClass *klass) MONO_INTERNAL; +mono_class_setup_mono_type (MonoClass *klass); void -mono_class_setup_parent (MonoClass *klass, MonoClass *parent) MONO_INTERNAL; +mono_class_setup_parent (MonoClass *klass, MonoClass *parent); MonoMethod* -mono_class_get_method_by_index (MonoClass *klass, int index) MONO_INTERNAL; +mono_class_get_method_by_index (MonoClass *klass, int index); MonoMethod* -mono_class_get_inflated_method (MonoClass *klass, MonoMethod *method) MONO_INTERNAL; +mono_class_get_inflated_method (MonoClass *klass, MonoMethod *method); MonoMethod* -mono_class_get_vtable_entry (MonoClass *klass, int offset) MONO_INTERNAL; +mono_class_get_vtable_entry (MonoClass *klass, int offset); GPtrArray* -mono_class_get_implemented_interfaces (MonoClass *klass, MonoError *error) MONO_INTERNAL; +mono_class_get_implemented_interfaces (MonoClass *klass, MonoError *error); int -mono_class_get_vtable_size (MonoClass *klass) MONO_INTERNAL; +mono_class_get_vtable_size (MonoClass *klass); gboolean -mono_class_is_open_constructed_type (MonoType *t) MONO_INTERNAL; +mono_class_is_open_constructed_type (MonoType *t); gboolean mono_class_get_overrides_full (MonoImage *image, guint32 type_token, MonoMethod ***overrides, gint32 *num_overrides, - MonoGenericContext *generic_context) MONO_INTERNAL; + MonoGenericContext *generic_context); MonoMethod* -mono_class_get_cctor (MonoClass *klass) MONO_INTERNAL; +mono_class_get_cctor (MonoClass *klass); MonoMethod* -mono_class_get_finalizer (MonoClass *klass) MONO_INTERNAL; +mono_class_get_finalizer (MonoClass *klass); gboolean -mono_class_needs_cctor_run (MonoClass *klass, MonoMethod *caller) MONO_INTERNAL; +mono_class_needs_cctor_run (MonoClass *klass, MonoMethod *caller); gboolean -mono_class_field_is_special_static (MonoClassField *field) MONO_INTERNAL; +mono_class_field_is_special_static (MonoClassField *field); guint32 -mono_class_field_get_special_static_type (MonoClassField *field) MONO_INTERNAL; +mono_class_field_get_special_static_type (MonoClassField *field); gboolean -mono_class_has_special_static_fields (MonoClass *klass) MONO_INTERNAL; +mono_class_has_special_static_fields (MonoClass *klass); const char* -mono_class_get_field_default_value (MonoClassField *field, MonoTypeEnum *def_type) MONO_INTERNAL; +mono_class_get_field_default_value (MonoClassField *field, MonoTypeEnum *def_type); const char* -mono_class_get_property_default_value (MonoProperty *property, MonoTypeEnum *def_type) MONO_INTERNAL; +mono_class_get_property_default_value (MonoProperty *property, MonoTypeEnum *def_type); void -mono_install_trampoline (MonoTrampoline func) MONO_INTERNAL; +mono_install_trampoline (MonoTrampoline func); void -mono_install_jump_trampoline (MonoJumpTrampoline func) MONO_INTERNAL; +mono_install_jump_trampoline (MonoJumpTrampoline func); void -mono_install_delegate_trampoline (MonoDelegateTrampoline func) MONO_INTERNAL; +mono_install_delegate_trampoline (MonoDelegateTrampoline func); gpointer -mono_lookup_dynamic_token (MonoImage *image, guint32 token, MonoGenericContext *context) MONO_INTERNAL; +mono_lookup_dynamic_token (MonoImage *image, guint32 token, MonoGenericContext *context); gpointer -mono_lookup_dynamic_token_class (MonoImage *image, guint32 token, gboolean check_token, MonoClass **handle_class, MonoGenericContext *context) MONO_INTERNAL; +mono_lookup_dynamic_token_class (MonoImage *image, guint32 token, gboolean check_token, MonoClass **handle_class, MonoGenericContext *context); void -mono_install_lookup_dynamic_token (MonoLookupDynamicToken func) MONO_INTERNAL; +mono_install_lookup_dynamic_token (MonoLookupDynamicToken func); gpointer -mono_runtime_create_jump_trampoline (MonoDomain *domain, MonoMethod *method, gboolean add_sync_wrapper) MONO_INTERNAL; +mono_runtime_create_jump_trampoline (MonoDomain *domain, MonoMethod *method, gboolean add_sync_wrapper); gpointer -mono_runtime_create_delegate_trampoline (MonoClass *klass) MONO_INTERNAL; +mono_runtime_create_delegate_trampoline (MonoClass *klass); void -mono_install_get_cached_class_info (MonoGetCachedClassInfo func) MONO_INTERNAL; +mono_install_get_cached_class_info (MonoGetCachedClassInfo func); void -mono_install_get_class_from_name (MonoGetClassFromName func) MONO_INTERNAL; +mono_install_get_class_from_name (MonoGetClassFromName func); MonoGenericContext* -mono_class_get_context (MonoClass *klass) MONO_INTERNAL; +mono_class_get_context (MonoClass *klass); MonoMethodSignature* -mono_method_signature_checked (MonoMethod *m, MonoError *err) MONO_INTERNAL; +mono_method_signature_checked (MonoMethod *m, MonoError *err); MonoGenericContext* -mono_method_get_context_general (MonoMethod *method, gboolean uninflated) MONO_INTERNAL; +mono_method_get_context_general (MonoMethod *method, gboolean uninflated); MonoGenericContext* -mono_method_get_context (MonoMethod *method) MONO_INTERNAL; +mono_method_get_context (MonoMethod *method); /* Used by monodis, thus cannot be MONO_INTERNAL */ MONO_API MonoGenericContainer* mono_method_get_generic_container (MonoMethod *method); MonoGenericContext* -mono_generic_class_get_context (MonoGenericClass *gclass) MONO_INTERNAL; +mono_generic_class_get_context (MonoGenericClass *gclass); MonoClass* -mono_generic_class_get_class (MonoGenericClass *gclass) MONO_INTERNAL; +mono_generic_class_get_class (MonoGenericClass *gclass); void -mono_method_set_generic_container (MonoMethod *method, MonoGenericContainer* container) MONO_INTERNAL; +mono_method_set_generic_container (MonoMethod *method, MonoGenericContainer* container); MonoMethod* -mono_class_inflate_generic_method_full (MonoMethod *method, MonoClass *klass_hint, MonoGenericContext *context) MONO_INTERNAL; +mono_class_inflate_generic_method_full (MonoMethod *method, MonoClass *klass_hint, MonoGenericContext *context); MonoMethod* -mono_class_inflate_generic_method_full_checked (MonoMethod *method, MonoClass *klass_hint, MonoGenericContext *context, MonoError *error) MONO_INTERNAL; +mono_class_inflate_generic_method_full_checked (MonoMethod *method, MonoClass *klass_hint, MonoGenericContext *context, MonoError *error); MonoMethod * -mono_class_inflate_generic_method_checked (MonoMethod *method, MonoGenericContext *context, MonoError *error) MONO_INTERNAL; +mono_class_inflate_generic_method_checked (MonoMethod *method, MonoGenericContext *context, MonoError *error); MonoMethodInflated* -mono_method_inflated_lookup (MonoMethodInflated* method, gboolean cache) MONO_INTERNAL; +mono_method_inflated_lookup (MonoMethodInflated* method, gboolean cache); MONO_API MonoMethodSignature * mono_metadata_get_inflated_signature (MonoMethodSignature *sig, MonoGenericContext *context); MonoType* -mono_class_inflate_generic_type_with_mempool (MonoImage *image, MonoType *type, MonoGenericContext *context, MonoError *error) MONO_INTERNAL; +mono_class_inflate_generic_type_with_mempool (MonoImage *image, MonoType *type, MonoGenericContext *context, MonoError *error); MonoClass* -mono_class_inflate_generic_class (MonoClass *gklass, MonoGenericContext *context) MONO_INTERNAL; +mono_class_inflate_generic_class (MonoClass *gklass, MonoGenericContext *context); MonoType* -mono_class_inflate_generic_type_checked (MonoType *type, MonoGenericContext *context, MonoError *error) MONO_INTERNAL; +mono_class_inflate_generic_type_checked (MonoType *type, MonoGenericContext *context, MonoError *error); MONO_API void mono_metadata_free_inflated_signature (MonoMethodSignature *sig); MonoMethodSignature* -mono_inflate_generic_signature (MonoMethodSignature *sig, MonoGenericContext *context, MonoError *error) MONO_INTERNAL; +mono_inflate_generic_signature (MonoMethodSignature *sig, MonoGenericContext *context, MonoError *error); typedef struct { MonoImage *corlib; @@ -1128,10 +1128,10 @@ typedef struct { #define mono_object_is_transparent_proxy(object) (FALSE) #else MonoRemoteClass* -mono_remote_class (MonoDomain *domain, MonoString *class_name, MonoClass *proxy_class) MONO_INTERNAL; +mono_remote_class (MonoDomain *domain, MonoString *class_name, MonoClass *proxy_class); void -mono_install_remoting_trampoline (MonoRemotingTrampoline func) MONO_INTERNAL; +mono_install_remoting_trampoline (MonoRemotingTrampoline func); #define mono_class_is_transparent_proxy(klass) ((klass) == mono_defaults.transparent_proxy_class) #define mono_class_is_real_proxy(klass) ((klass) == mono_defaults.real_proxy_class) @@ -1171,13 +1171,13 @@ GENERATE_GET_CLASS_WITH_CACHE_DECL (variant) #endif -extern MonoDefaults mono_defaults MONO_INTERNAL; +extern MonoDefaults mono_defaults; void -mono_loader_init (void) MONO_INTERNAL; +mono_loader_init (void); void -mono_loader_cleanup (void) MONO_INTERNAL; +mono_loader_cleanup (void); void mono_loader_lock (void) MONO_LLVM_INTERNAL; @@ -1186,54 +1186,54 @@ void mono_loader_unlock (void) MONO_LLVM_INTERNAL; void -mono_loader_lock_track_ownership (gboolean track) MONO_INTERNAL; +mono_loader_lock_track_ownership (gboolean track); gboolean -mono_loader_lock_is_owned_by_self (void) MONO_INTERNAL; +mono_loader_lock_is_owned_by_self (void); void -mono_loader_lock_if_inited (void) MONO_INTERNAL; +mono_loader_lock_if_inited (void); void -mono_loader_unlock_if_inited (void) MONO_INTERNAL; +mono_loader_unlock_if_inited (void); void -mono_loader_set_error_assembly_load (const char *assembly_name, gboolean ref_only) MONO_INTERNAL; +mono_loader_set_error_assembly_load (const char *assembly_name, gboolean ref_only); void -mono_loader_set_error_type_load (const char *class_name, const char *assembly_name) MONO_INTERNAL; +mono_loader_set_error_type_load (const char *class_name, const char *assembly_name); void -mono_loader_set_error_method_load (const char *class_name, const char *member_name) MONO_INTERNAL; +mono_loader_set_error_method_load (const char *class_name, const char *member_name); void -mono_loader_set_error_field_load (MonoClass *klass, const char *member_name) MONO_INTERNAL; +mono_loader_set_error_field_load (MonoClass *klass, const char *member_name); void -mono_loader_set_error_bad_image (char *msg) MONO_INTERNAL; +mono_loader_set_error_bad_image (char *msg); MonoException * -mono_loader_error_prepare_exception (MonoLoaderError *error) MONO_INTERNAL; +mono_loader_error_prepare_exception (MonoLoaderError *error); MonoLoaderError * -mono_loader_get_last_error (void) MONO_INTERNAL; +mono_loader_get_last_error (void); void -mono_loader_clear_error (void) MONO_INTERNAL; +mono_loader_clear_error (void); void -mono_reflection_init (void) MONO_INTERNAL; +mono_reflection_init (void); void -mono_icall_init (void) MONO_INTERNAL; +mono_icall_init (void); void -mono_icall_cleanup (void) MONO_INTERNAL; +mono_icall_cleanup (void); gpointer -mono_method_get_wrapper_data (MonoMethod *method, guint32 id) MONO_INTERNAL; +mono_method_get_wrapper_data (MonoMethod *method, guint32 id); gboolean -mono_metadata_has_generic_params (MonoImage *image, guint32 token) MONO_INTERNAL; +mono_metadata_has_generic_params (MonoImage *image, guint32 token); MONO_API MonoGenericContainer * mono_metadata_load_generic_params (MonoImage *image, guint32 token, @@ -1244,16 +1244,16 @@ mono_metadata_load_generic_param_constraints_checked (MonoImage *image, guint32 MonoGenericContainer *container, MonoError *error); MonoMethodSignature* -mono_create_icall_signature (const char *sigstr) MONO_INTERNAL; +mono_create_icall_signature (const char *sigstr); MonoJitICallInfo * -mono_register_jit_icall (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save) MONO_INTERNAL; +mono_register_jit_icall (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save); MonoJitICallInfo * -mono_register_jit_icall_full (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save, gboolean no_raise, const char *c_symbol) MONO_INTERNAL; +mono_register_jit_icall_full (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save, gboolean no_raise, const char *c_symbol); void -mono_register_jit_icall_wrapper (MonoJitICallInfo *info, gconstpointer wrapper) MONO_INTERNAL; +mono_register_jit_icall_wrapper (MonoJitICallInfo *info, gconstpointer wrapper); MonoJitICallInfo * mono_find_jit_icall_by_name (const char *name) MONO_LLVM_INTERNAL; @@ -1262,34 +1262,34 @@ MonoJitICallInfo * mono_find_jit_icall_by_addr (gconstpointer addr) MONO_LLVM_INTERNAL; GHashTable* -mono_get_jit_icall_info (void) MONO_INTERNAL; +mono_get_jit_icall_info (void); const char* -mono_lookup_jit_icall_symbol (const char *name) MONO_INTERNAL; +mono_lookup_jit_icall_symbol (const char *name); gboolean -mono_class_set_failure (MonoClass *klass, guint32 ex_type, void *ex_data) MONO_INTERNAL; +mono_class_set_failure (MonoClass *klass, guint32 ex_type, void *ex_data); gpointer -mono_class_get_exception_data (MonoClass *klass) MONO_INTERNAL; +mono_class_get_exception_data (MonoClass *klass); MonoException* -mono_class_get_exception_for_failure (MonoClass *klass) MONO_INTERNAL; +mono_class_get_exception_for_failure (MonoClass *klass); char* -mono_type_get_name_full (MonoType *type, MonoTypeNameFormat format) MONO_INTERNAL; +mono_type_get_name_full (MonoType *type, MonoTypeNameFormat format); char* -mono_type_get_full_name (MonoClass *klass) MONO_INTERNAL; +mono_type_get_full_name (MonoClass *klass); -MonoArrayType *mono_dup_array_type (MonoImage *image, MonoArrayType *a) MONO_INTERNAL; -MonoMethodSignature *mono_metadata_signature_deep_dup (MonoImage *image, MonoMethodSignature *sig) MONO_INTERNAL; +MonoArrayType *mono_dup_array_type (MonoImage *image, MonoArrayType *a); +MonoMethodSignature *mono_metadata_signature_deep_dup (MonoImage *image, MonoMethodSignature *sig); MONO_API void mono_image_init_name_cache (MonoImage *image); -gboolean mono_class_is_nullable (MonoClass *klass) MONO_INTERNAL; -MonoClass *mono_class_get_nullable_param (MonoClass *klass) MONO_INTERNAL; +gboolean mono_class_is_nullable (MonoClass *klass); +MonoClass *mono_class_get_nullable_param (MonoClass *klass); /* object debugging functions, for use inside gdb */ MONO_API void mono_object_describe (MonoObject *obj); @@ -1305,110 +1305,110 @@ MONO_API gboolean mono_class_is_valid_enum (MonoClass *klass); MonoType * -mono_type_get_checked (MonoImage *image, guint32 type_token, MonoGenericContext *context, MonoError *error) MONO_INTERNAL; +mono_type_get_checked (MonoImage *image, guint32 type_token, MonoGenericContext *context, MonoError *error); gboolean -mono_generic_class_is_generic_type_definition (MonoGenericClass *gklass) MONO_INTERNAL; +mono_generic_class_is_generic_type_definition (MonoGenericClass *gklass); MonoMethod* -mono_class_get_method_generic (MonoClass *klass, MonoMethod *method) MONO_INTERNAL; +mono_class_get_method_generic (MonoClass *klass, MonoMethod *method); MonoType* -mono_type_get_basic_type_from_generic (MonoType *type) MONO_INTERNAL; +mono_type_get_basic_type_from_generic (MonoType *type); gboolean -mono_method_can_access_method_full (MonoMethod *method, MonoMethod *called, MonoClass *context_klass) MONO_INTERNAL; +mono_method_can_access_method_full (MonoMethod *method, MonoMethod *called, MonoClass *context_klass); gboolean -mono_method_can_access_field_full (MonoMethod *method, MonoClassField *field, MonoClass *context_klass) MONO_INTERNAL; +mono_method_can_access_field_full (MonoMethod *method, MonoClassField *field, MonoClass *context_klass); gboolean -mono_class_can_access_class (MonoClass *access_class, MonoClass *target_class) MONO_INTERNAL; +mono_class_can_access_class (MonoClass *access_class, MonoClass *target_class); MonoClass * -mono_class_get_generic_type_definition (MonoClass *klass) MONO_INTERNAL; +mono_class_get_generic_type_definition (MonoClass *klass); gboolean -mono_class_has_parent_and_ignore_generics (MonoClass *klass, MonoClass *parent) MONO_INTERNAL; +mono_class_has_parent_and_ignore_generics (MonoClass *klass, MonoClass *parent); int -mono_method_get_vtable_slot (MonoMethod *method) MONO_INTERNAL; +mono_method_get_vtable_slot (MonoMethod *method); int -mono_method_get_vtable_index (MonoMethod *method) MONO_INTERNAL; +mono_method_get_vtable_index (MonoMethod *method); MonoMethod* -mono_method_search_in_array_class (MonoClass *klass, const char *name, MonoMethodSignature *sig) MONO_INTERNAL; +mono_method_search_in_array_class (MonoClass *klass, const char *name, MonoMethodSignature *sig); void -mono_class_setup_interface_id (MonoClass *klass) MONO_INTERNAL; +mono_class_setup_interface_id (MonoClass *klass); MonoGenericContainer* -mono_class_get_generic_container (MonoClass *klass) MONO_INTERNAL; +mono_class_get_generic_container (MonoClass *klass); MonoGenericClass* -mono_class_get_generic_class (MonoClass *klass) MONO_INTERNAL; +mono_class_get_generic_class (MonoClass *klass); void -mono_class_alloc_ext (MonoClass *klass) MONO_INTERNAL; +mono_class_alloc_ext (MonoClass *klass); void -mono_class_setup_interfaces (MonoClass *klass, MonoError *error) MONO_INTERNAL; +mono_class_setup_interfaces (MonoClass *klass, MonoError *error); MonoClassField* -mono_class_get_field_from_name_full (MonoClass *klass, const char *name, MonoType *type) MONO_INTERNAL; +mono_class_get_field_from_name_full (MonoClass *klass, const char *name, MonoType *type); MonoVTable* -mono_class_vtable_full (MonoDomain *domain, MonoClass *klass, gboolean raise_on_error) MONO_INTERNAL; +mono_class_vtable_full (MonoDomain *domain, MonoClass *klass, gboolean raise_on_error); gboolean -mono_class_is_assignable_from_slow (MonoClass *target, MonoClass *candidate) MONO_INTERNAL; +mono_class_is_assignable_from_slow (MonoClass *target, MonoClass *candidate); gboolean -mono_class_has_variant_generic_params (MonoClass *klass) MONO_INTERNAL; +mono_class_has_variant_generic_params (MonoClass *klass); gboolean -mono_class_is_variant_compatible (MonoClass *klass, MonoClass *oklass, gboolean check_for_reference_conv) MONO_INTERNAL; +mono_class_is_variant_compatible (MonoClass *klass, MonoClass *oklass, gboolean check_for_reference_conv); -gboolean mono_is_corlib_image (MonoImage *image) MONO_INTERNAL; +gboolean mono_is_corlib_image (MonoImage *image); MonoType* -mono_field_get_type_checked (MonoClassField *field, MonoError *error) MONO_INTERNAL; +mono_field_get_type_checked (MonoClassField *field, MonoError *error); MonoClassField* -mono_class_get_fields_lazy (MonoClass* klass, gpointer *iter) MONO_INTERNAL; +mono_class_get_fields_lazy (MonoClass* klass, gpointer *iter); gboolean -mono_class_check_vtable_constraints (MonoClass *klass, GList *in_setup) MONO_INTERNAL; +mono_class_check_vtable_constraints (MonoClass *klass, GList *in_setup); gboolean -mono_class_has_finalizer (MonoClass *klass) MONO_INTERNAL; +mono_class_has_finalizer (MonoClass *klass); void -mono_unload_interface_id (MonoClass *klass) MONO_INTERNAL; +mono_unload_interface_id (MonoClass *klass); GPtrArray* -mono_class_get_methods_by_name (MonoClass *klass, const char *name, guint32 bflags, gboolean ignore_case, gboolean allow_ctors, MonoException **ex) MONO_INTERNAL; +mono_class_get_methods_by_name (MonoClass *klass, const char *name, guint32 bflags, gboolean ignore_case, gboolean allow_ctors, MonoException **ex); char* -mono_class_full_name (MonoClass *klass) MONO_INTERNAL; +mono_class_full_name (MonoClass *klass); MonoClass* -mono_class_inflate_generic_class_checked (MonoClass *gklass, MonoGenericContext *context, MonoError *error) MONO_INTERNAL; +mono_class_inflate_generic_class_checked (MonoClass *gklass, MonoGenericContext *context, MonoError *error); MonoClass * -mono_class_get_checked (MonoImage *image, guint32 type_token, MonoError *error) MONO_INTERNAL; +mono_class_get_checked (MonoImage *image, guint32 type_token, MonoError *error); MonoClass * -mono_class_get_and_inflate_typespec_checked (MonoImage *image, guint32 type_token, MonoGenericContext *context, MonoError *error) MONO_INTERNAL; +mono_class_get_and_inflate_typespec_checked (MonoImage *image, guint32 type_token, MonoGenericContext *context, MonoError *error); MonoClass * -mono_class_from_name_case_checked (MonoImage *image, const char* name_space, const char *name, MonoError *error) MONO_INTERNAL; +mono_class_from_name_case_checked (MonoImage *image, const char* name_space, const char *name, MonoError *error); MonoClassField* -mono_field_from_token_checked (MonoImage *image, uint32_t token, MonoClass **retklass, MonoGenericContext *context, MonoError *error) MONO_INTERNAL; +mono_field_from_token_checked (MonoImage *image, uint32_t token, MonoClass **retklass, MonoGenericContext *context, MonoError *error); gpointer -mono_ldtoken_checked (MonoImage *image, guint32 token, MonoClass **handle_class, MonoGenericContext *context, MonoError *error) MONO_INTERNAL; +mono_ldtoken_checked (MonoImage *image, guint32 token, MonoClass **handle_class, MonoGenericContext *context, MonoError *error); #endif /* __MONO_METADATA_CLASS_INTERBALS_H__ */ diff --git a/mono/metadata/cominterop.h b/mono/metadata/cominterop.h index f65aae2fb03..6a15374f16c 100644 --- a/mono/metadata/cominterop.h +++ b/mono/metadata/cominterop.h @@ -13,39 +13,39 @@ #include void -mono_cominterop_init (void) MONO_INTERNAL; +mono_cominterop_init (void); void -mono_cominterop_cleanup (void) MONO_INTERNAL; +mono_cominterop_cleanup (void); void -mono_mb_emit_cominterop_call (MonoMethodBuilder *mb, MonoMethodSignature *sig, MonoMethod* method) MONO_INTERNAL; +mono_mb_emit_cominterop_call (MonoMethodBuilder *mb, MonoMethodSignature *sig, MonoMethod* method); void -mono_cominterop_emit_ptr_to_object_conv (MonoMethodBuilder *mb, MonoType *type, MonoMarshalConv conv, MonoMarshalSpec *mspec) MONO_INTERNAL; +mono_cominterop_emit_ptr_to_object_conv (MonoMethodBuilder *mb, MonoType *type, MonoMarshalConv conv, MonoMarshalSpec *mspec); void -mono_cominterop_emit_object_to_ptr_conv (MonoMethodBuilder *mb, MonoType *type, MonoMarshalConv conv, MonoMarshalSpec *mspec) MONO_INTERNAL; +mono_cominterop_emit_object_to_ptr_conv (MonoMethodBuilder *mb, MonoType *type, MonoMarshalConv conv, MonoMarshalSpec *mspec); MonoMethod * -mono_cominterop_get_native_wrapper (MonoMethod *method) MONO_INTERNAL; +mono_cominterop_get_native_wrapper (MonoMethod *method); MonoMethod * -mono_cominterop_get_invoke (MonoMethod *method) MONO_INTERNAL; +mono_cominterop_get_invoke (MonoMethod *method); int mono_cominterop_emit_marshal_com_interface (EmitMarshalContext *m, int argnum, MonoType *t, MonoMarshalSpec *spec, int conv_arg, MonoType **conv_arg_type, - MarshalAction action) MONO_INTERNAL; + MarshalAction action); int mono_cominterop_emit_marshal_safearray (EmitMarshalContext *m, int argnum, MonoType *t, MonoMarshalSpec *spec, int conv_arg, MonoType **conv_arg_type, - MarshalAction action) MONO_INTERNAL; + MarshalAction action); MONO_API MonoString * mono_string_from_bstr (gpointer bstr); diff --git a/mono/metadata/console-io.h b/mono/metadata/console-io.h index 66930511150..fdca4871eeb 100644 --- a/mono/metadata/console-io.h +++ b/mono/metadata/console-io.h @@ -19,14 +19,14 @@ G_BEGIN_DECLS -void mono_console_init (void) MONO_INTERNAL; -void mono_console_handle_async_ops (void) MONO_INTERNAL; -MonoBoolean ves_icall_System_ConsoleDriver_Isatty (HANDLE handle) MONO_INTERNAL; -gint32 ves_icall_System_ConsoleDriver_InternalKeyAvailable (gint32 timeout) MONO_INTERNAL; -MonoBoolean ves_icall_System_ConsoleDriver_SetEcho (MonoBoolean echo) MONO_INTERNAL; -MonoBoolean ves_icall_System_ConsoleDriver_SetBreak (MonoBoolean want_break) MONO_INTERNAL; -MonoBoolean ves_icall_System_ConsoleDriver_TtySetup (MonoString *keypad, MonoString *teardown, MonoArray **control_characters, int **size) MONO_INTERNAL; -void ves_icall_System_ConsoleDriver_Suspend (void) MONO_INTERNAL; +void mono_console_init (void); +void mono_console_handle_async_ops (void); +MonoBoolean ves_icall_System_ConsoleDriver_Isatty (HANDLE handle); +gint32 ves_icall_System_ConsoleDriver_InternalKeyAvailable (gint32 timeout); +MonoBoolean ves_icall_System_ConsoleDriver_SetEcho (MonoBoolean echo); +MonoBoolean ves_icall_System_ConsoleDriver_SetBreak (MonoBoolean want_break); +MonoBoolean ves_icall_System_ConsoleDriver_TtySetup (MonoString *keypad, MonoString *teardown, MonoArray **control_characters, int **size); +void ves_icall_System_ConsoleDriver_Suspend (void); G_END_DECLS diff --git a/mono/metadata/coree.h b/mono/metadata/coree.h index e5f842f2528..a9c6a7cb76a 100644 --- a/mono/metadata/coree.h +++ b/mono/metadata/coree.h @@ -32,19 +32,19 @@ STDAPI MonoFixupCorEE(HMODULE ModuleHandle); #define __ImageBase _image_base__ #endif #endif -extern IMAGE_DOS_HEADER __ImageBase MONO_INTERNAL; +extern IMAGE_DOS_HEADER __ImageBase; -extern HMODULE coree_module_handle MONO_INTERNAL; +extern HMODULE coree_module_handle; -HMODULE WINAPI MonoLoadImage(LPCWSTR FileName) MONO_INTERNAL; -STDAPI MonoFixupExe(HMODULE ModuleHandle) MONO_INTERNAL; +HMODULE WINAPI MonoLoadImage(LPCWSTR FileName); +STDAPI MonoFixupExe(HMODULE ModuleHandle); -gchar* mono_get_module_file_name (HMODULE module_handle) MONO_INTERNAL; -void mono_load_coree (const char* file_name) MONO_INTERNAL; -void mono_fixup_exe_image (MonoImage* image) MONO_INTERNAL; +gchar* mono_get_module_file_name (HMODULE module_handle); +void mono_load_coree (const char* file_name); +void mono_fixup_exe_image (MonoImage* image); /* Declared in image.c. */ -MonoImage* mono_image_open_from_module_handle (HMODULE module_handle, char* fname, gboolean has_entry_point, MonoImageOpenStatus* status) MONO_INTERNAL; +MonoImage* mono_image_open_from_module_handle (HMODULE module_handle, char* fname, gboolean has_entry_point, MonoImageOpenStatus* status); #endif /* HOST_WIN32 */ diff --git a/mono/metadata/decimal-ms.h b/mono/metadata/decimal-ms.h index d60dd1561e4..1f2ad7a39c4 100644 --- a/mono/metadata/decimal-ms.h +++ b/mono/metadata/decimal-ms.h @@ -41,19 +41,19 @@ typedef enum { } MonoDecimalCompareResult; MonoDecimalCompareResult - mono_decimal_compare (MonoDecimal *left, MonoDecimal *right) MONO_INTERNAL; + mono_decimal_compare (MonoDecimal *left, MonoDecimal *right); -void mono_decimal_init_single (MonoDecimal *_this, float value) MONO_INTERNAL; -void mono_decimal_init_double (MonoDecimal *_this, double value) MONO_INTERNAL; -void mono_decimal_floor (MonoDecimal *d) MONO_INTERNAL; -int32_t mono_decimal_get_hash_code (MonoDecimal *d) MONO_INTERNAL; -void mono_decimal_multiply (MonoDecimal *d1, MonoDecimal *d2) MONO_INTERNAL; -void mono_decimal_round (MonoDecimal *d, int32_t decimals) MONO_INTERNAL; -void mono_decimal_tocurrency (MonoDecimal *decimal) MONO_INTERNAL; -double mono_decimal_to_double (MonoDecimal d) MONO_INTERNAL; -int32_t mono_decimal_to_int32 (MonoDecimal d) MONO_INTERNAL; -float mono_decimal_to_float (MonoDecimal d) MONO_INTERNAL; -void mono_decimal_truncate (MonoDecimal *d) MONO_INTERNAL; +void mono_decimal_init_single (MonoDecimal *_this, float value); +void mono_decimal_init_double (MonoDecimal *_this, double value); +void mono_decimal_floor (MonoDecimal *d); +int32_t mono_decimal_get_hash_code (MonoDecimal *d); +void mono_decimal_multiply (MonoDecimal *d1, MonoDecimal *d2); +void mono_decimal_round (MonoDecimal *d, int32_t decimals); +void mono_decimal_tocurrency (MonoDecimal *decimal); +double mono_decimal_to_double (MonoDecimal d); +int32_t mono_decimal_to_int32 (MonoDecimal d); +float mono_decimal_to_float (MonoDecimal d); +void mono_decimal_truncate (MonoDecimal *d); void mono_decimal_addsub (MonoDecimal *left, MonoDecimal *right, uint8_t sign); void mono_decimal_divide (MonoDecimal *left, MonoDecimal *right); int mono_decimal_from_number (void *from, MonoDecimal *target); diff --git a/mono/metadata/domain-internals.h b/mono/metadata/domain-internals.h index ca3d6cdba3d..b2de1885aa8 100644 --- a/mono/metadata/domain-internals.h +++ b/mono/metadata/domain-internals.h @@ -441,245 +441,245 @@ typedef struct { typedef MonoDomain* (*MonoLoadFunc) (const char *filename, const char *runtime_version); void -mono_install_runtime_load (MonoLoadFunc func) MONO_INTERNAL; +mono_install_runtime_load (MonoLoadFunc func); MonoDomain* -mono_runtime_load (const char *filename, const char *runtime_version) MONO_INTERNAL; +mono_runtime_load (const char *filename, const char *runtime_version); typedef void (*MonoCreateDomainFunc) (MonoDomain *domain); void -mono_install_create_domain_hook (MonoCreateDomainFunc func) MONO_INTERNAL; +mono_install_create_domain_hook (MonoCreateDomainFunc func); typedef void (*MonoFreeDomainFunc) (MonoDomain *domain); void -mono_install_free_domain_hook (MonoFreeDomainFunc func) MONO_INTERNAL; +mono_install_free_domain_hook (MonoFreeDomainFunc func); void -mono_cleanup (void) MONO_INTERNAL; +mono_cleanup (void); void -mono_close_exe_image (void) MONO_INTERNAL; +mono_close_exe_image (void); int -mono_jit_info_size (MonoJitInfoFlags flags, int num_clauses, int num_holes) MONO_INTERNAL; +mono_jit_info_size (MonoJitInfoFlags flags, int num_clauses, int num_holes); void mono_jit_info_init (MonoJitInfo *ji, MonoMethod *method, guint8 *code, int code_size, - MonoJitInfoFlags flags, int num_clauses, int num_holes) MONO_INTERNAL; + MonoJitInfoFlags flags, int num_clauses, int num_holes); MonoJitInfoTable * -mono_jit_info_table_new (MonoDomain *domain) MONO_INTERNAL; +mono_jit_info_table_new (MonoDomain *domain); void -mono_jit_info_table_free (MonoJitInfoTable *table) MONO_INTERNAL; +mono_jit_info_table_free (MonoJitInfoTable *table); void -mono_jit_info_table_add (MonoDomain *domain, MonoJitInfo *ji) MONO_INTERNAL; +mono_jit_info_table_add (MonoDomain *domain, MonoJitInfo *ji); void -mono_jit_info_table_remove (MonoDomain *domain, MonoJitInfo *ji) MONO_INTERNAL; +mono_jit_info_table_remove (MonoDomain *domain, MonoJitInfo *ji); void -mono_jit_info_add_aot_module (MonoImage *image, gpointer start, gpointer end) MONO_INTERNAL; +mono_jit_info_add_aot_module (MonoImage *image, gpointer start, gpointer end); MonoGenericJitInfo* -mono_jit_info_get_generic_jit_info (MonoJitInfo *ji) MONO_INTERNAL; +mono_jit_info_get_generic_jit_info (MonoJitInfo *ji); MonoGenericSharingContext* -mono_jit_info_get_generic_sharing_context (MonoJitInfo *ji) MONO_INTERNAL; +mono_jit_info_get_generic_sharing_context (MonoJitInfo *ji); void -mono_jit_info_set_generic_sharing_context (MonoJitInfo *ji, MonoGenericSharingContext *gsctx) MONO_INTERNAL; +mono_jit_info_set_generic_sharing_context (MonoJitInfo *ji, MonoGenericSharingContext *gsctx); char * -mono_make_shadow_copy (const char *filename) MONO_INTERNAL; +mono_make_shadow_copy (const char *filename); gboolean -mono_is_shadow_copy_enabled (MonoDomain *domain, const gchar *dir_name) MONO_INTERNAL; +mono_is_shadow_copy_enabled (MonoDomain *domain, const gchar *dir_name); gpointer -mono_domain_alloc (MonoDomain *domain, guint size) MONO_INTERNAL; +mono_domain_alloc (MonoDomain *domain, guint size); gpointer -mono_domain_alloc0 (MonoDomain *domain, guint size) MONO_INTERNAL; +mono_domain_alloc0 (MonoDomain *domain, guint size); gpointer -mono_domain_alloc0_lock_free (MonoDomain *domain, guint size) MONO_INTERNAL; +mono_domain_alloc0_lock_free (MonoDomain *domain, guint size); void* mono_domain_code_reserve (MonoDomain *domain, int size) MONO_LLVM_INTERNAL; void* -mono_domain_code_reserve_align (MonoDomain *domain, int size, int alignment) MONO_INTERNAL; +mono_domain_code_reserve_align (MonoDomain *domain, int size, int alignment); void -mono_domain_code_commit (MonoDomain *domain, void *data, int size, int newsize) MONO_INTERNAL; +mono_domain_code_commit (MonoDomain *domain, void *data, int size, int newsize); void * -nacl_domain_get_code_dest (MonoDomain *domain, void *data) MONO_INTERNAL; +nacl_domain_get_code_dest (MonoDomain *domain, void *data); void -nacl_domain_code_validate (MonoDomain *domain, guint8 **buf_base, int buf_size, guint8 **code_end) MONO_INTERNAL; +nacl_domain_code_validate (MonoDomain *domain, guint8 **buf_base, int buf_size, guint8 **code_end); void -mono_domain_code_foreach (MonoDomain *domain, MonoCodeManagerFunc func, void *user_data) MONO_INTERNAL; +mono_domain_code_foreach (MonoDomain *domain, MonoCodeManagerFunc func, void *user_data); void -mono_domain_unset (void) MONO_INTERNAL; +mono_domain_unset (void); void -mono_domain_set_internal_with_options (MonoDomain *domain, gboolean migrate_exception) MONO_INTERNAL; +mono_domain_set_internal_with_options (MonoDomain *domain, gboolean migrate_exception); MonoTryBlockHoleTableJitInfo* -mono_jit_info_get_try_block_hole_table_info (MonoJitInfo *ji) MONO_INTERNAL; +mono_jit_info_get_try_block_hole_table_info (MonoJitInfo *ji); MonoArchEHJitInfo* -mono_jit_info_get_arch_eh_info (MonoJitInfo *ji) MONO_INTERNAL; +mono_jit_info_get_arch_eh_info (MonoJitInfo *ji); MonoMethodCasInfo* -mono_jit_info_get_cas_info (MonoJitInfo *ji) MONO_INTERNAL; +mono_jit_info_get_cas_info (MonoJitInfo *ji); /* * Installs a new function which is used to return a MonoJitInfo for a method inside * an AOT module. */ typedef MonoJitInfo *(*MonoJitInfoFindInAot) (MonoDomain *domain, MonoImage *image, gpointer addr); -void mono_install_jit_info_find_in_aot (MonoJitInfoFindInAot func) MONO_INTERNAL; +void mono_install_jit_info_find_in_aot (MonoJitInfoFindInAot func); void -mono_jit_code_hash_init (MonoInternalHashTable *jit_code_hash) MONO_INTERNAL; +mono_jit_code_hash_init (MonoInternalHashTable *jit_code_hash); MonoAppDomain * -ves_icall_System_AppDomain_getCurDomain (void) MONO_INTERNAL; +ves_icall_System_AppDomain_getCurDomain (void); MonoAppDomain * -ves_icall_System_AppDomain_getRootDomain (void) MONO_INTERNAL; +ves_icall_System_AppDomain_getRootDomain (void); MonoAppDomain * ves_icall_System_AppDomain_createDomain (MonoString *friendly_name, - MonoAppDomainSetup *setup) MONO_INTERNAL; + MonoAppDomainSetup *setup); MonoObject * ves_icall_System_AppDomain_GetData (MonoAppDomain *ad, - MonoString *name) MONO_INTERNAL; + MonoString *name); MonoReflectionAssembly * ves_icall_System_AppDomain_LoadAssemblyRaw (MonoAppDomain *ad, MonoArray *raw_assembly, MonoArray *raw_symbol_store, MonoObject *evidence, - MonoBoolean refonly) MONO_INTERNAL; + MonoBoolean refonly); void ves_icall_System_AppDomain_SetData (MonoAppDomain *ad, MonoString *name, - MonoObject *data) MONO_INTERNAL; + MonoObject *data); MonoAppDomainSetup * -ves_icall_System_AppDomain_getSetup (MonoAppDomain *ad) MONO_INTERNAL; +ves_icall_System_AppDomain_getSetup (MonoAppDomain *ad); MonoString * -ves_icall_System_AppDomain_getFriendlyName (MonoAppDomain *ad) MONO_INTERNAL; +ves_icall_System_AppDomain_getFriendlyName (MonoAppDomain *ad); MonoArray * ves_icall_System_AppDomain_GetAssemblies (MonoAppDomain *ad, - MonoBoolean refonly) MONO_INTERNAL; + MonoBoolean refonly); MonoReflectionAssembly * ves_icall_System_Reflection_Assembly_LoadFrom (MonoString *fname, - MonoBoolean refonly) MONO_INTERNAL; + MonoBoolean refonly); MonoReflectionAssembly * ves_icall_System_AppDomain_LoadAssembly (MonoAppDomain *ad, MonoString *assRef, MonoObject *evidence, - MonoBoolean refonly) MONO_INTERNAL; + MonoBoolean refonly); gboolean -ves_icall_System_AppDomain_InternalIsFinalizingForUnload (gint32 domain_id) MONO_INTERNAL; +ves_icall_System_AppDomain_InternalIsFinalizingForUnload (gint32 domain_id); void -ves_icall_System_AppDomain_InternalUnload (gint32 domain_id) MONO_INTERNAL; +ves_icall_System_AppDomain_InternalUnload (gint32 domain_id); gint32 ves_icall_System_AppDomain_ExecuteAssembly (MonoAppDomain *ad, MonoReflectionAssembly *refass, - MonoArray *args) MONO_INTERNAL; + MonoArray *args); MonoAppDomain * -ves_icall_System_AppDomain_InternalSetDomain (MonoAppDomain *ad) MONO_INTERNAL; +ves_icall_System_AppDomain_InternalSetDomain (MonoAppDomain *ad); MonoAppDomain * -ves_icall_System_AppDomain_InternalSetDomainByID (gint32 domainid) MONO_INTERNAL; +ves_icall_System_AppDomain_InternalSetDomainByID (gint32 domainid); void -ves_icall_System_AppDomain_InternalPushDomainRef (MonoAppDomain *ad) MONO_INTERNAL; +ves_icall_System_AppDomain_InternalPushDomainRef (MonoAppDomain *ad); void -ves_icall_System_AppDomain_InternalPushDomainRefByID (gint32 domain_id) MONO_INTERNAL; +ves_icall_System_AppDomain_InternalPushDomainRefByID (gint32 domain_id); void -ves_icall_System_AppDomain_InternalPopDomainRef (void) MONO_INTERNAL; +ves_icall_System_AppDomain_InternalPopDomainRef (void); MonoAppContext * -ves_icall_System_AppDomain_InternalGetContext (void) MONO_INTERNAL; +ves_icall_System_AppDomain_InternalGetContext (void); MonoAppContext * -ves_icall_System_AppDomain_InternalGetDefaultContext (void) MONO_INTERNAL; +ves_icall_System_AppDomain_InternalGetDefaultContext (void); MonoAppContext * -ves_icall_System_AppDomain_InternalSetContext (MonoAppContext *mc) MONO_INTERNAL; +ves_icall_System_AppDomain_InternalSetContext (MonoAppContext *mc); gint32 -ves_icall_System_AppDomain_GetIDFromDomain (MonoAppDomain * ad) MONO_INTERNAL; +ves_icall_System_AppDomain_GetIDFromDomain (MonoAppDomain * ad); MonoString * -ves_icall_System_AppDomain_InternalGetProcessGuid (MonoString* newguid) MONO_INTERNAL; +ves_icall_System_AppDomain_InternalGetProcessGuid (MonoString* newguid); MonoAssembly * -mono_assembly_load_corlib (const MonoRuntimeInfo *runtime, MonoImageOpenStatus *status) MONO_INTERNAL; +mono_assembly_load_corlib (const MonoRuntimeInfo *runtime, MonoImageOpenStatus *status); const MonoRuntimeInfo* -mono_get_runtime_info (void) MONO_INTERNAL; +mono_get_runtime_info (void); void -mono_runtime_set_no_exec (gboolean val) MONO_INTERNAL; +mono_runtime_set_no_exec (gboolean val); gboolean -mono_runtime_get_no_exec (void) MONO_INTERNAL; +mono_runtime_get_no_exec (void); gboolean -mono_assembly_name_parse (const char *name, MonoAssemblyName *aname) MONO_INTERNAL; +mono_assembly_name_parse (const char *name, MonoAssemblyName *aname); MonoImage *mono_assembly_open_from_bundle (const char *filename, MonoImageOpenStatus *status, - gboolean refonly) MONO_INTERNAL; + gboolean refonly); MONO_API void mono_domain_add_class_static_data (MonoDomain *domain, MonoClass *klass, gpointer data, guint32 *bitmap); MonoReflectionAssembly * -mono_try_assembly_resolve (MonoDomain *domain, MonoString *fname, MonoAssembly *requesting, gboolean refonly) MONO_INTERNAL; +mono_try_assembly_resolve (MonoDomain *domain, MonoString *fname, MonoAssembly *requesting, gboolean refonly); MonoAssembly * -mono_domain_assembly_postload_search (MonoAssemblyName *aname, MonoAssembly *requesting, gboolean refonly) MONO_INTERNAL; +mono_domain_assembly_postload_search (MonoAssemblyName *aname, MonoAssembly *requesting, gboolean refonly); MonoAssembly* mono_assembly_load_full_nosearch (MonoAssemblyName *aname, const char *basedir, MonoImageOpenStatus *status, - gboolean refonly) MONO_INTERNAL; + gboolean refonly); -void mono_set_private_bin_path_from_config (MonoDomain *domain) MONO_INTERNAL; +void mono_set_private_bin_path_from_config (MonoDomain *domain); -int mono_framework_version (void) MONO_INTERNAL; +int mono_framework_version (void); -void mono_reflection_cleanup_domain (MonoDomain *domain) MONO_INTERNAL; +void mono_reflection_cleanup_domain (MonoDomain *domain); -void mono_assembly_cleanup_domain_bindings (guint32 domain_id) MONO_INTERNAL; +void mono_assembly_cleanup_domain_bindings (guint32 domain_id); -MonoJitInfo* mono_jit_info_table_find_internal (MonoDomain *domain, char *addr, gboolean try_aot) MONO_INTERNAL; +MonoJitInfo* mono_jit_info_table_find_internal (MonoDomain *domain, char *addr, gboolean try_aot); void mono_enable_debug_domain_unload (gboolean enable); diff --git a/mono/metadata/environment.c b/mono/metadata/environment.c index 03c60f33dc3..e0d1970f612 100644 --- a/mono/metadata/environment.c +++ b/mono/metadata/environment.c @@ -18,7 +18,7 @@ #include #include -extern MonoString* ves_icall_System_Environment_GetOSVersionString (void) MONO_INTERNAL; +extern MonoString* ves_icall_System_Environment_GetOSVersionString (void); #if !defined(HOST_WIN32) && defined(HAVE_SYS_UTSNAME_H) #include diff --git a/mono/metadata/file-io.h b/mono/metadata/file-io.h index fa98eaa9105..fc7f9e1231b 100644 --- a/mono/metadata/file-io.h +++ b/mono/metadata/file-io.h @@ -114,142 +114,142 @@ typedef struct _MonoFSAsyncResult { /* System.IO.MonoIO */ extern MonoBoolean -ves_icall_System_IO_MonoIO_CreateDirectory (MonoString *path, gint32 *error) MONO_INTERNAL; +ves_icall_System_IO_MonoIO_CreateDirectory (MonoString *path, gint32 *error); extern MonoBoolean -ves_icall_System_IO_MonoIO_RemoveDirectory (MonoString *path, gint32 *error) MONO_INTERNAL; +ves_icall_System_IO_MonoIO_RemoveDirectory (MonoString *path, gint32 *error); MonoArray * ves_icall_System_IO_MonoIO_GetFileSystemEntries (MonoString *path, MonoString *path_with_pattern, gint mask, gint attrs, - gint32 *error) MONO_INTERNAL; + gint32 *error); extern MonoString * ves_icall_System_IO_MonoIO_FindFirst (MonoString *path, MonoString *path_with_pattern, gint32 *result_mask, gint32 *error, - gpointer *handle) MONO_INTERNAL; + gpointer *handle); extern MonoString * -ves_icall_System_IO_MonoIO_FindNext (gpointer handle, gint32 *result_mask, gint32 *error) MONO_INTERNAL; +ves_icall_System_IO_MonoIO_FindNext (gpointer handle, gint32 *result_mask, gint32 *error); extern int -ves_icall_System_IO_MonoIO_FindClose (gpointer handle) MONO_INTERNAL; +ves_icall_System_IO_MonoIO_FindClose (gpointer handle); extern MonoString * -ves_icall_System_IO_MonoIO_GetCurrentDirectory (gint32 *error) MONO_INTERNAL; +ves_icall_System_IO_MonoIO_GetCurrentDirectory (gint32 *error); extern MonoBoolean ves_icall_System_IO_MonoIO_SetCurrentDirectory (MonoString *path, - gint32 *error) MONO_INTERNAL; + gint32 *error); extern MonoBoolean ves_icall_System_IO_MonoIO_MoveFile (MonoString *path, MonoString *dest, - gint32 *error) MONO_INTERNAL; + gint32 *error); extern MonoBoolean ves_icall_System_IO_MonoIO_CopyFile (MonoString *path, MonoString *dest, - MonoBoolean overwrite, gint32 *error) MONO_INTERNAL; + MonoBoolean overwrite, gint32 *error); extern MonoBoolean -ves_icall_System_IO_MonoIO_DeleteFile (MonoString *path, gint32 *error) MONO_INTERNAL; +ves_icall_System_IO_MonoIO_DeleteFile (MonoString *path, gint32 *error); extern gint32 -ves_icall_System_IO_MonoIO_GetFileAttributes (MonoString *path, gint32 *error) MONO_INTERNAL; +ves_icall_System_IO_MonoIO_GetFileAttributes (MonoString *path, gint32 *error); extern MonoBoolean ves_icall_System_IO_MonoIO_SetFileAttributes (MonoString *path, gint32 attrs, - gint32 *error) MONO_INTERNAL; + gint32 *error); extern gint32 -ves_icall_System_IO_MonoIO_GetFileType (HANDLE handle, gint32 *error) MONO_INTERNAL; +ves_icall_System_IO_MonoIO_GetFileType (HANDLE handle, gint32 *error); extern MonoBoolean ves_icall_System_IO_MonoIO_GetFileStat (MonoString *path, MonoIOStat *stat, - gint32 *error) MONO_INTERNAL; + gint32 *error); extern HANDLE ves_icall_System_IO_MonoIO_Open (MonoString *filename, gint32 mode, gint32 access_mode, gint32 share, gint32 options, - gint32 *error) MONO_INTERNAL; + gint32 *error); extern MonoBoolean -ves_icall_System_IO_MonoIO_Close (HANDLE handle, gint32 *error) MONO_INTERNAL; +ves_icall_System_IO_MonoIO_Close (HANDLE handle, gint32 *error); extern gint32 ves_icall_System_IO_MonoIO_Read (HANDLE handle, MonoArray *dest, gint32 dest_offset, gint32 count, - gint32 *error) MONO_INTERNAL; + gint32 *error); extern gint32 ves_icall_System_IO_MonoIO_Write (HANDLE handle, MonoArray *src, gint32 src_offset, gint32 count, - gint32 *error) MONO_INTERNAL; + gint32 *error); extern gint64 ves_icall_System_IO_MonoIO_Seek (HANDLE handle, gint64 offset, gint32 origin, - gint32 *error) MONO_INTERNAL; + gint32 *error); extern MonoBoolean -ves_icall_System_IO_MonoIO_Flush (HANDLE handle, gint32 *error) MONO_INTERNAL; +ves_icall_System_IO_MonoIO_Flush (HANDLE handle, gint32 *error); extern gint64 -ves_icall_System_IO_MonoIO_GetLength (HANDLE handle, gint32 *error) MONO_INTERNAL; +ves_icall_System_IO_MonoIO_GetLength (HANDLE handle, gint32 *error); extern MonoBoolean ves_icall_System_IO_MonoIO_SetLength (HANDLE handle, gint64 length, - gint32 *error) MONO_INTERNAL; + gint32 *error); extern MonoBoolean ves_icall_System_IO_MonoIO_SetFileTime (HANDLE handle, gint64 creation_time, gint64 last_access_time, - gint64 last_write_time, gint32 *error) MONO_INTERNAL; + gint64 last_write_time, gint32 *error); extern HANDLE -ves_icall_System_IO_MonoIO_get_ConsoleOutput (void) MONO_INTERNAL; +ves_icall_System_IO_MonoIO_get_ConsoleOutput (void); extern HANDLE -ves_icall_System_IO_MonoIO_get_ConsoleInput (void) MONO_INTERNAL; +ves_icall_System_IO_MonoIO_get_ConsoleInput (void); extern HANDLE -ves_icall_System_IO_MonoIO_get_ConsoleError (void) MONO_INTERNAL; +ves_icall_System_IO_MonoIO_get_ConsoleError (void); extern MonoBoolean ves_icall_System_IO_MonoIO_CreatePipe (HANDLE *read_handle, - HANDLE *write_handle) MONO_INTERNAL; + HANDLE *write_handle); extern MonoBoolean ves_icall_System_IO_MonoIO_DuplicateHandle (HANDLE source_process_handle, HANDLE source_handle, HANDLE target_process_handle, HANDLE *target_handle, - gint32 access, gint32 inherit, gint32 options) MONO_INTERNAL; + gint32 access, gint32 inherit, gint32 options); extern gunichar2 -ves_icall_System_IO_MonoIO_get_VolumeSeparatorChar (void) MONO_INTERNAL; +ves_icall_System_IO_MonoIO_get_VolumeSeparatorChar (void); extern gunichar2 -ves_icall_System_IO_MonoIO_get_DirectorySeparatorChar (void) MONO_INTERNAL; +ves_icall_System_IO_MonoIO_get_DirectorySeparatorChar (void); extern gunichar2 -ves_icall_System_IO_MonoIO_get_AltDirectorySeparatorChar (void) MONO_INTERNAL; +ves_icall_System_IO_MonoIO_get_AltDirectorySeparatorChar (void); extern gunichar2 -ves_icall_System_IO_MonoIO_get_PathSeparator (void) MONO_INTERNAL; +ves_icall_System_IO_MonoIO_get_PathSeparator (void); extern MonoArray * -ves_icall_System_IO_MonoIO_get_InvalidPathChars (void) MONO_INTERNAL; +ves_icall_System_IO_MonoIO_get_InvalidPathChars (void); extern gint32 -ves_icall_System_IO_MonoIO_GetTempPath (MonoString **mono_name) MONO_INTERNAL; +ves_icall_System_IO_MonoIO_GetTempPath (MonoString **mono_name); extern void ves_icall_System_IO_MonoIO_Lock (HANDLE handle, gint64 position, - gint64 length, gint32 *error) MONO_INTERNAL; + gint64 length, gint32 *error); extern void ves_icall_System_IO_MonoIO_Unlock (HANDLE handle, gint64 position, - gint64 length, gint32 *error) MONO_INTERNAL; + gint64 length, gint32 *error); extern MonoBoolean ves_icall_System_IO_MonoIO_ReplaceFile (MonoString *sourceFileName, MonoString *destinationFileName, MonoString *destinationBackupFileName, MonoBoolean ignoreMetadataErrors, - gint32 *error) MONO_INTERNAL; + gint32 *error); extern gint64 mono_filesize_from_path (MonoString *path); diff --git a/mono/metadata/file-mmap.h b/mono/metadata/file-mmap.h index 1d750167254..0e391ff1d40 100644 --- a/mono/metadata/file-mmap.h +++ b/mono/metadata/file-mmap.h @@ -17,18 +17,18 @@ #include #include -extern void mono_mmap_close (void *mmap_handle) MONO_INTERNAL; +extern void mono_mmap_close (void *mmap_handle); -extern void mono_mmap_configure_inheritability (void *mmap_handle, gboolean inheritability) MONO_INTERNAL; +extern void mono_mmap_configure_inheritability (void *mmap_handle, gboolean inheritability); -extern void mono_mmap_flush (void *mmap_handle) MONO_INTERNAL; +extern void mono_mmap_flush (void *mmap_handle); -extern void *mono_mmap_open_file (MonoString *string, int mode, MonoString *mapName, gint64 *capacity, int access, int options, int *error) MONO_INTERNAL; +extern void *mono_mmap_open_file (MonoString *string, int mode, MonoString *mapName, gint64 *capacity, int access, int options, int *error); -extern void *mono_mmap_open_handle (void *handle, MonoString *mapName, gint64 *capacity, int access, int options, int *error) MONO_INTERNAL; +extern void *mono_mmap_open_handle (void *handle, MonoString *mapName, gint64 *capacity, int access, int options, int *error); -extern int mono_mmap_map (void *handle, gint64 offset, gint64 *size, int access, void **mmap_handle, void **base_address) MONO_INTERNAL; +extern int mono_mmap_map (void *handle, gint64 offset, gint64 *size, int access, void **mmap_handle, void **base_address); -extern gboolean mono_mmap_unmap (void *base_address) MONO_INTERNAL; +extern gboolean mono_mmap_unmap (void *base_address); #endif /* _MONO_METADATA_FILE_MMAP_H_ */ diff --git a/mono/metadata/filewatcher.h b/mono/metadata/filewatcher.h index c0a1ca2fcdc..c57be128325 100644 --- a/mono/metadata/filewatcher.h +++ b/mono/metadata/filewatcher.h @@ -21,16 +21,16 @@ G_BEGIN_DECLS -gint ves_icall_System_IO_FSW_SupportsFSW (void) MONO_INTERNAL; +gint ves_icall_System_IO_FSW_SupportsFSW (void); gboolean ves_icall_System_IO_FAMW_InternalFAMNextEvent (gpointer conn, MonoString **filename, gint *code, - gint *reqnum) MONO_INTERNAL; + gint *reqnum); -int ves_icall_System_IO_InotifyWatcher_GetInotifyInstance (void) MONO_INTERNAL; -int ves_icall_System_IO_InotifyWatcher_AddWatch (int fd, MonoString *directory, gint32 mask) MONO_INTERNAL; -int ves_icall_System_IO_InotifyWatcher_RemoveWatch (int fd, gint32 watch_descriptor) MONO_INTERNAL; +int ves_icall_System_IO_InotifyWatcher_GetInotifyInstance (void); +int ves_icall_System_IO_InotifyWatcher_AddWatch (int fd, MonoString *directory, gint32 mask); +int ves_icall_System_IO_InotifyWatcher_RemoveWatch (int fd, gint32 watch_descriptor); G_END_DECLS diff --git a/mono/metadata/gc-internal.h b/mono/metadata/gc-internal.h index 0bd1d21ffc7..de78a309391 100644 --- a/mono/metadata/gc-internal.h +++ b/mono/metadata/gc-internal.h @@ -71,44 +71,44 @@ typedef struct { /* useful until we keep track of gc-references in corlib etc. */ #define IS_GC_REFERENCE(t) (mono_gc_is_moving () ? FALSE : ((t)->type == MONO_TYPE_U && class->image == mono_defaults.corlib)) -extern GCStats gc_stats MONO_INTERNAL; +extern GCStats gc_stats; -void mono_object_register_finalizer (MonoObject *obj) MONO_INTERNAL; -void ves_icall_System_GC_InternalCollect (int generation) MONO_INTERNAL; -gint64 ves_icall_System_GC_GetTotalMemory (MonoBoolean forceCollection) MONO_INTERNAL; -void ves_icall_System_GC_KeepAlive (MonoObject *obj) MONO_INTERNAL; -void ves_icall_System_GC_ReRegisterForFinalize (MonoObject *obj) MONO_INTERNAL; -void ves_icall_System_GC_SuppressFinalize (MonoObject *obj) MONO_INTERNAL; -void ves_icall_System_GC_WaitForPendingFinalizers (void) MONO_INTERNAL; +void mono_object_register_finalizer (MonoObject *obj); +void ves_icall_System_GC_InternalCollect (int generation); +gint64 ves_icall_System_GC_GetTotalMemory (MonoBoolean forceCollection); +void ves_icall_System_GC_KeepAlive (MonoObject *obj); +void ves_icall_System_GC_ReRegisterForFinalize (MonoObject *obj); +void ves_icall_System_GC_SuppressFinalize (MonoObject *obj); +void ves_icall_System_GC_WaitForPendingFinalizers (void); -MonoObject *ves_icall_System_GCHandle_GetTarget (guint32 handle) MONO_INTERNAL; -guint32 ves_icall_System_GCHandle_GetTargetHandle (MonoObject *obj, guint32 handle, gint32 type) MONO_INTERNAL; -void ves_icall_System_GCHandle_FreeHandle (guint32 handle) MONO_INTERNAL; -gpointer ves_icall_System_GCHandle_GetAddrOfPinnedObject (guint32 handle) MONO_INTERNAL; -void ves_icall_System_GC_register_ephemeron_array (MonoObject *array) MONO_INTERNAL; -MonoObject *ves_icall_System_GC_get_ephemeron_tombstone (void) MONO_INTERNAL; +MonoObject *ves_icall_System_GCHandle_GetTarget (guint32 handle); +guint32 ves_icall_System_GCHandle_GetTargetHandle (MonoObject *obj, guint32 handle, gint32 type); +void ves_icall_System_GCHandle_FreeHandle (guint32 handle); +gpointer ves_icall_System_GCHandle_GetAddrOfPinnedObject (guint32 handle); +void ves_icall_System_GC_register_ephemeron_array (MonoObject *array); +MonoObject *ves_icall_System_GC_get_ephemeron_tombstone (void); -MonoBoolean ves_icall_Mono_Runtime_SetGCAllowSynchronousMajor (MonoBoolean flag) MONO_INTERNAL; +MonoBoolean ves_icall_Mono_Runtime_SetGCAllowSynchronousMajor (MonoBoolean flag); -extern void mono_gc_init (void) MONO_INTERNAL; -extern void mono_gc_base_init (void) MONO_INTERNAL; -extern void mono_gc_cleanup (void) MONO_INTERNAL; +extern void mono_gc_init (void); +extern void mono_gc_base_init (void); +extern void mono_gc_cleanup (void); /* * Return whenever the current thread is registered with the GC (i.e. started * by the GC pthread wrappers on unix. */ -extern gboolean mono_gc_is_gc_thread (void) MONO_INTERNAL; +extern gboolean mono_gc_is_gc_thread (void); /* * Try to register a foreign thread with the GC, if we fail or the backend * can't cope with this concept - we return FALSE. */ -extern gboolean mono_gc_register_thread (void *baseptr) MONO_INTERNAL; +extern gboolean mono_gc_register_thread (void *baseptr); -extern gboolean mono_gc_is_finalizer_internal_thread (MonoInternalThread *thread) MONO_INTERNAL; +extern gboolean mono_gc_is_finalizer_internal_thread (MonoInternalThread *thread); -extern void mono_gc_set_stack_end (void *stack_end) MONO_INTERNAL; +extern void mono_gc_set_stack_end (void *stack_end); /* only valid after the RECLAIM_START GC event and before RECLAIM_END * Not exported in public headers, but can be linked to (unsupported). @@ -119,24 +119,24 @@ extern MONO_API gpointer mono_gc_out_of_memory (size_t size); extern MONO_API void mono_gc_enable_events (void); /* disappearing link functionality */ -void mono_gc_weak_link_add (void **link_addr, MonoObject *obj, gboolean track) MONO_INTERNAL; -void mono_gc_weak_link_remove (void **link_addr, gboolean track) MONO_INTERNAL; -MonoObject *mono_gc_weak_link_get (void **link_addr) MONO_INTERNAL; +void mono_gc_weak_link_add (void **link_addr, MonoObject *obj, gboolean track); +void mono_gc_weak_link_remove (void **link_addr, gboolean track); +MonoObject *mono_gc_weak_link_get (void **link_addr); /*Ephemeron functionality. Sgen only*/ -gboolean mono_gc_ephemeron_array_add (MonoObject *obj) MONO_INTERNAL; +gboolean mono_gc_ephemeron_array_add (MonoObject *obj); /* To disable synchronous, evacuating collections - concurrent SGen only */ -gboolean mono_gc_set_allow_synchronous_major (gboolean flag) MONO_INTERNAL; +gboolean mono_gc_set_allow_synchronous_major (gboolean flag); MonoBoolean -GCHandle_CheckCurrentDomain (guint32 gchandle) MONO_INTERNAL; +GCHandle_CheckCurrentDomain (guint32 gchandle); /* simple interface for data structures needed in the runtime */ -void* mono_gc_make_descr_from_bitmap (gsize *bitmap, int numbits) MONO_INTERNAL; +void* mono_gc_make_descr_from_bitmap (gsize *bitmap, int numbits); /* Return a root descriptor for a root with all refs */ -void* mono_gc_make_root_descr_all_refs (int numbits) MONO_INTERNAL; +void* mono_gc_make_root_descr_all_refs (int numbits); /* User defined marking function */ /* It should work like this: @@ -150,7 +150,7 @@ typedef void (*MonoGCRootMarkFunc) (void *addr, MonoGCMarkFunc mark_func, void * MONO_API void *mono_gc_make_root_descr_user (MonoGCRootMarkFunc marker); /* Return whenever user defined marking functions are supported */ -gboolean mono_gc_user_markers_supported (void) MONO_INTERNAL; +gboolean mono_gc_user_markers_supported (void); /* desc is the result from mono_gc_make_descr*. A NULL value means * all the words might contain GC pointers. @@ -160,36 +160,36 @@ gboolean mono_gc_user_markers_supported (void) MONO_INTERNAL; * NOTE: Under Boehm, this returns memory allocated using GC_malloc, so the result should * be stored into a location registered using MONO_GC_REGISTER_ROOT_FIXED (). */ -void* mono_gc_alloc_fixed (size_t size, void *descr) MONO_INTERNAL; -void mono_gc_free_fixed (void* addr) MONO_INTERNAL; +void* mono_gc_alloc_fixed (size_t size, void *descr); +void mono_gc_free_fixed (void* addr); /* make sure the gchandle was allocated for an object in domain */ -gboolean mono_gchandle_is_in_domain (guint32 gchandle, MonoDomain *domain) MONO_INTERNAL; -void mono_gchandle_free_domain (MonoDomain *domain) MONO_INTERNAL; +gboolean mono_gchandle_is_in_domain (guint32 gchandle, MonoDomain *domain); +void mono_gchandle_free_domain (MonoDomain *domain); typedef void (*FinalizerThreadCallback) (gpointer user_data); /* if there are finalizers to run, run them. Returns the number of finalizers run */ -gboolean mono_gc_pending_finalizers (void) MONO_INTERNAL; -void mono_gc_finalize_notify (void) MONO_INTERNAL; - -void* mono_gc_alloc_pinned_obj (MonoVTable *vtable, size_t size) MONO_INTERNAL; -void* mono_gc_alloc_obj (MonoVTable *vtable, size_t size) MONO_INTERNAL; -void* mono_gc_alloc_vector (MonoVTable *vtable, size_t size, uintptr_t max_length) MONO_INTERNAL; -void* mono_gc_alloc_array (MonoVTable *vtable, size_t size, uintptr_t max_length, uintptr_t bounds_size) MONO_INTERNAL; -void* mono_gc_alloc_string (MonoVTable *vtable, size_t size, gint32 len) MONO_INTERNAL; -void* mono_gc_make_descr_for_string (gsize *bitmap, int numbits) MONO_INTERNAL; -void* mono_gc_make_descr_for_object (gsize *bitmap, int numbits, size_t obj_size) MONO_INTERNAL; -void* mono_gc_make_descr_for_array (int vector, gsize *elem_bitmap, int numbits, size_t elem_size) MONO_INTERNAL; - -void mono_gc_register_for_finalization (MonoObject *obj, void *user_data) MONO_INTERNAL; -void mono_gc_add_memory_pressure (gint64 value) MONO_INTERNAL; +gboolean mono_gc_pending_finalizers (void); +void mono_gc_finalize_notify (void); + +void* mono_gc_alloc_pinned_obj (MonoVTable *vtable, size_t size); +void* mono_gc_alloc_obj (MonoVTable *vtable, size_t size); +void* mono_gc_alloc_vector (MonoVTable *vtable, size_t size, uintptr_t max_length); +void* mono_gc_alloc_array (MonoVTable *vtable, size_t size, uintptr_t max_length, uintptr_t bounds_size); +void* mono_gc_alloc_string (MonoVTable *vtable, size_t size, gint32 len); +void* mono_gc_make_descr_for_string (gsize *bitmap, int numbits); +void* mono_gc_make_descr_for_object (gsize *bitmap, int numbits, size_t obj_size); +void* mono_gc_make_descr_for_array (int vector, gsize *elem_bitmap, int numbits, size_t elem_size); + +void mono_gc_register_for_finalization (MonoObject *obj, void *user_data); +void mono_gc_add_memory_pressure (gint64 value); MONO_API int mono_gc_register_root (char *start, size_t size, void *descr); -void mono_gc_deregister_root (char* addr) MONO_INTERNAL; -int mono_gc_finalizers_for_domain (MonoDomain *domain, MonoObject **out_array, int out_size) MONO_INTERNAL; -void mono_gc_run_finalize (void *obj, void *data) MONO_INTERNAL; -void mono_gc_clear_domain (MonoDomain * domain) MONO_INTERNAL; -void* mono_gc_alloc_mature (MonoVTable *vtable) MONO_INTERNAL; +void mono_gc_deregister_root (char* addr); +int mono_gc_finalizers_for_domain (MonoDomain *domain, MonoObject **out_array, int out_size); +void mono_gc_run_finalize (void *obj, void *data); +void mono_gc_clear_domain (MonoDomain * domain); +void* mono_gc_alloc_mature (MonoVTable *vtable); /* * Register a root which can only be written using a write barrier. @@ -201,16 +201,16 @@ void* mono_gc_alloc_mature (MonoVTable *vtable) MONO_INTERNAL; * FIXME: Add an API for clearing remset entries if a root with a user defined * mark routine is deleted. */ -int mono_gc_register_root_wbarrier (char *start, size_t size, void *descr) MONO_INTERNAL; +int mono_gc_register_root_wbarrier (char *start, size_t size, void *descr); -void mono_gc_wbarrier_set_root (gpointer ptr, MonoObject *value) MONO_INTERNAL; +void mono_gc_wbarrier_set_root (gpointer ptr, MonoObject *value); /* Set a field of a root registered using mono_gc_register_root_wbarrier () */ #define MONO_ROOT_SETREF(s,fieldname,value) do { \ mono_gc_wbarrier_set_root (&((s)->fieldname), (MonoObject*)value); \ } while (0) -void mono_gc_finalize_threadpool_threads (void) MONO_INTERNAL; +void mono_gc_finalize_threadpool_threads (void); /* fast allocation support */ @@ -220,24 +220,24 @@ typedef struct { int alloc_type; } AllocatorWrapperInfo; -int mono_gc_get_aligned_size_for_allocator (int size) MONO_INTERNAL; -MonoMethod* mono_gc_get_managed_allocator (MonoClass *klass, gboolean for_box, gboolean known_instance_size) MONO_INTERNAL; -MonoMethod* mono_gc_get_managed_array_allocator (MonoClass *klass) MONO_INTERNAL; -MonoMethod *mono_gc_get_managed_allocator_by_type (int atype) MONO_INTERNAL; +int mono_gc_get_aligned_size_for_allocator (int size); +MonoMethod* mono_gc_get_managed_allocator (MonoClass *klass, gboolean for_box, gboolean known_instance_size); +MonoMethod* mono_gc_get_managed_array_allocator (MonoClass *klass); +MonoMethod *mono_gc_get_managed_allocator_by_type (int atype); -guint32 mono_gc_get_managed_allocator_types (void) MONO_INTERNAL; +guint32 mono_gc_get_managed_allocator_types (void); /* Return a short string identifying the GC, indented to be saved in AOT images */ -const char *mono_gc_get_gc_name (void) MONO_INTERNAL; +const char *mono_gc_get_gc_name (void); /* Fast write barriers */ -MonoMethod* mono_gc_get_write_barrier (void) MONO_INTERNAL; +MonoMethod* mono_gc_get_write_barrier (void); /* Fast valuetype copy */ -void mono_gc_wbarrier_value_copy_bitmap (gpointer dest, gpointer src, int size, unsigned bitmap) MONO_INTERNAL; +void mono_gc_wbarrier_value_copy_bitmap (gpointer dest, gpointer src, int size, unsigned bitmap); /* helper for the managed alloc support */ -MonoString *mono_string_alloc (int length) MONO_INTERNAL; +MonoString *mono_string_alloc (int length); /* * Functions supplied by the runtime and called by the GC. Currently only used @@ -273,75 +273,75 @@ typedef struct { } MonoGCCallbacks; /* Set the callback functions callable by the GC */ -void mono_gc_set_gc_callbacks (MonoGCCallbacks *callbacks) MONO_INTERNAL; -MonoGCCallbacks *mono_gc_get_gc_callbacks (void) MONO_INTERNAL; +void mono_gc_set_gc_callbacks (MonoGCCallbacks *callbacks); +MonoGCCallbacks *mono_gc_get_gc_callbacks (void); /* Functions callable from the thread mark func */ /* Scan the memory area between START and END conservatively */ -void mono_gc_conservatively_scan_area (void *start, void *end) MONO_INTERNAL; +void mono_gc_conservatively_scan_area (void *start, void *end); /* Scan OBJ, returning its new address */ -void *mono_gc_scan_object (void *obj, void *gc_data) MONO_INTERNAL; +void *mono_gc_scan_object (void *obj, void *gc_data); /* Return the bitmap encoded by a descriptor */ -gsize* mono_gc_get_bitmap_for_descr (void *descr, int *numbits) MONO_INTERNAL; +gsize* mono_gc_get_bitmap_for_descr (void *descr, int *numbits); /* Return the suspend signal number used by the GC to suspend threads, or -1 if not applicable. */ -int mono_gc_get_suspend_signal (void) MONO_INTERNAL; +int mono_gc_get_suspend_signal (void); /* Return the suspend signal number used by the GC to suspend threads, or -1 if not applicable. */ -int mono_gc_get_restart_signal (void) MONO_INTERNAL; +int mono_gc_get_restart_signal (void); /* * Return a human readable description of the GC in malloc-ed memory. */ -char* mono_gc_get_description (void) MONO_INTERNAL; +char* mono_gc_get_description (void); /* * Configure the GC to desktop mode */ -void mono_gc_set_desktop_mode (void) MONO_INTERNAL; +void mono_gc_set_desktop_mode (void); /* * Return whenever this GC can move objects */ -gboolean mono_gc_is_moving (void) MONO_INTERNAL; +gboolean mono_gc_is_moving (void); typedef void* (*MonoGCLockedCallbackFunc) (void *data); -void* mono_gc_invoke_with_gc_lock (MonoGCLockedCallbackFunc func, void *data) MONO_INTERNAL; +void* mono_gc_invoke_with_gc_lock (MonoGCLockedCallbackFunc func, void *data); -int mono_gc_get_los_limit (void) MONO_INTERNAL; +int mono_gc_get_los_limit (void); -guint8* mono_gc_get_card_table (int *shift_bits, gpointer *card_mask) MONO_INTERNAL; -gboolean mono_gc_card_table_nursery_check (void) MONO_INTERNAL; +guint8* mono_gc_get_card_table (int *shift_bits, gpointer *card_mask); +gboolean mono_gc_card_table_nursery_check (void); -void* mono_gc_get_nursery (int *shift_bits, size_t *size) MONO_INTERNAL; +void* mono_gc_get_nursery (int *shift_bits, size_t *size); -void mono_gc_set_current_thread_appdomain (MonoDomain *domain) MONO_INTERNAL; +void mono_gc_set_current_thread_appdomain (MonoDomain *domain); -void mono_gc_set_skip_thread (gboolean skip) MONO_INTERNAL; +void mono_gc_set_skip_thread (gboolean skip); /* * Return whenever GC is disabled */ -gboolean mono_gc_is_disabled (void) MONO_INTERNAL; +gboolean mono_gc_is_disabled (void); -void mono_gc_set_string_length (MonoString *str, gint32 new_length) MONO_INTERNAL; +void mono_gc_set_string_length (MonoString *str, gint32 new_length); #if defined(__MACH__) -void mono_gc_register_mach_exception_thread (pthread_t thread) MONO_INTERNAL; -pthread_t mono_gc_get_mach_exception_thread (void) MONO_INTERNAL; +void mono_gc_register_mach_exception_thread (pthread_t thread); +pthread_t mono_gc_get_mach_exception_thread (void); #endif -gboolean mono_gc_parse_environment_string_extract_number (const char *str, size_t *out) MONO_INTERNAL; +gboolean mono_gc_parse_environment_string_extract_number (const char *str, size_t *out); -gboolean mono_gc_precise_stack_mark_enabled (void) MONO_INTERNAL; +gboolean mono_gc_precise_stack_mark_enabled (void); -FILE *mono_gc_get_logfile (void) MONO_INTERNAL; +FILE *mono_gc_get_logfile (void); typedef struct _RefQueueEntry RefQueueEntry; @@ -374,21 +374,21 @@ MONO_API void mono_gc_register_finalizer_callbacks (MonoGCFinalizerCallbacks *ca #ifdef HOST_WIN32 -BOOL APIENTRY mono_gc_dllmain (HMODULE module_handle, DWORD reason, LPVOID reserved) MONO_INTERNAL; +BOOL APIENTRY mono_gc_dllmain (HMODULE module_handle, DWORD reason, LPVOID reserved); #endif /* Those functions must be used when it's possible that either destination is not word aligned or size is not a multiple of word size. */ -void mono_gc_bzero_atomic (void *dest, size_t size) MONO_INTERNAL; -void mono_gc_bzero_aligned (void *dest, size_t size) MONO_INTERNAL; -void mono_gc_memmove_atomic (void *dest, const void *src, size_t size) MONO_INTERNAL; -void mono_gc_memmove_aligned (void *dest, const void *src, size_t size) MONO_INTERNAL; +void mono_gc_bzero_atomic (void *dest, size_t size); +void mono_gc_bzero_aligned (void *dest, size_t size); +void mono_gc_memmove_atomic (void *dest, const void *src, size_t size); +void mono_gc_memmove_aligned (void *dest, const void *src, size_t size); -guint mono_gc_get_vtable_bits (MonoClass *klass) MONO_INTERNAL; +guint mono_gc_get_vtable_bits (MonoClass *klass); -void mono_gc_register_altstack (gpointer stack, gint32 stack_size, gpointer altstack, gint32 altstack_size) MONO_INTERNAL; +void mono_gc_register_altstack (gpointer stack, gint32 stack_size, gpointer altstack, gint32 altstack_size); #endif /* __MONO_METADATA_GC_INTERNAL_H__ */ diff --git a/mono/metadata/icall.c b/mono/metadata/icall.c index c9680c87329..4c63ad16359 100644 --- a/mono/metadata/icall.c +++ b/mono/metadata/icall.c @@ -97,7 +97,7 @@ #endif #include "decimal-ms.h" -extern MonoString* ves_icall_System_Environment_GetOSVersionString (void) MONO_INTERNAL; +extern MonoString* ves_icall_System_Environment_GetOSVersionString (void); ICALL_EXPORT MonoReflectionAssembly* ves_icall_System_Reflection_Assembly_GetCallingAssembly (void); diff --git a/mono/metadata/locales.h b/mono/metadata/locales.h index f87439d5bed..36890c3bbe2 100644 --- a/mono/metadata/locales.h +++ b/mono/metadata/locales.h @@ -26,31 +26,31 @@ typedef enum { CompareOptions_Ordinal=0x40000000 } MonoCompareOptions; -extern MonoBoolean ves_icall_System_Globalization_CalendarData_fill_calendar_data (MonoCalendarData *this_obj, MonoString *name, gint32 calendar_index) MONO_INTERNAL; -extern void ves_icall_System_Globalization_CultureData_fill_culture_data (MonoCultureData *this_obj, gint32 datetime_index) MONO_INTERNAL; -extern void ves_icall_System_Globalization_CultureInfo_construct_internal_locale (MonoCultureInfo *this_obj, MonoString *locale) MONO_INTERNAL; -extern MonoString* ves_icall_System_Globalization_CultureInfo_get_current_locale_name (void) MONO_INTERNAL; -extern MonoBoolean ves_icall_System_Globalization_CultureInfo_construct_internal_locale_from_lcid (MonoCultureInfo *this_obj, gint lcid) MONO_INTERNAL; -extern MonoBoolean ves_icall_System_Globalization_CultureInfo_construct_internal_locale_from_name (MonoCultureInfo *this_obj, MonoString *name) MONO_INTERNAL; -extern MonoArray *ves_icall_System_Globalization_CultureInfo_internal_get_cultures (MonoBoolean neutral, MonoBoolean specific, MonoBoolean installed) MONO_INTERNAL; -extern void ves_icall_System_Globalization_CultureInfo_construct_number_format (MonoCultureInfo *this_obj) MONO_INTERNAL; -extern void ves_icall_System_Globalization_CompareInfo_construct_compareinfo (MonoCompareInfo *comp, MonoString *locale) MONO_INTERNAL; -extern int ves_icall_System_Globalization_CompareInfo_internal_compare (MonoCompareInfo *this_obj, MonoString *str1, gint32 off1, gint32 len1, MonoString *str2, gint32 off2, gint32 len2, gint32 options) MONO_INTERNAL; -extern void ves_icall_System_Globalization_CompareInfo_free_internal_collator (MonoCompareInfo *this_obj) MONO_INTERNAL; +extern MonoBoolean ves_icall_System_Globalization_CalendarData_fill_calendar_data (MonoCalendarData *this_obj, MonoString *name, gint32 calendar_index); +extern void ves_icall_System_Globalization_CultureData_fill_culture_data (MonoCultureData *this_obj, gint32 datetime_index); +extern void ves_icall_System_Globalization_CultureInfo_construct_internal_locale (MonoCultureInfo *this_obj, MonoString *locale); +extern MonoString* ves_icall_System_Globalization_CultureInfo_get_current_locale_name (void); +extern MonoBoolean ves_icall_System_Globalization_CultureInfo_construct_internal_locale_from_lcid (MonoCultureInfo *this_obj, gint lcid); +extern MonoBoolean ves_icall_System_Globalization_CultureInfo_construct_internal_locale_from_name (MonoCultureInfo *this_obj, MonoString *name); +extern MonoArray *ves_icall_System_Globalization_CultureInfo_internal_get_cultures (MonoBoolean neutral, MonoBoolean specific, MonoBoolean installed); +extern void ves_icall_System_Globalization_CultureInfo_construct_number_format (MonoCultureInfo *this_obj); +extern void ves_icall_System_Globalization_CompareInfo_construct_compareinfo (MonoCompareInfo *comp, MonoString *locale); +extern int ves_icall_System_Globalization_CompareInfo_internal_compare (MonoCompareInfo *this_obj, MonoString *str1, gint32 off1, gint32 len1, MonoString *str2, gint32 off2, gint32 len2, gint32 options); +extern void ves_icall_System_Globalization_CompareInfo_free_internal_collator (MonoCompareInfo *this_obj); extern MonoBoolean -ves_icall_System_Globalization_RegionInfo_construct_internal_region_from_lcid (MonoRegionInfo *this_obj, gint lcid) MONO_INTERNAL; +ves_icall_System_Globalization_RegionInfo_construct_internal_region_from_lcid (MonoRegionInfo *this_obj, gint lcid); extern MonoBoolean ves_icall_System_Globalization_RegionInfo_construct_internal_region_from_name (MonoRegionInfo *this_obj, - MonoString *name) MONO_INTERNAL; -extern void ves_icall_System_Globalization_CompareInfo_assign_sortkey (MonoCompareInfo *this_obj, MonoSortKey *key, MonoString *source, gint32 options) MONO_INTERNAL; -extern int ves_icall_System_Globalization_CompareInfo_internal_index (MonoCompareInfo *this_obj, MonoString *source, gint32 sindex, gint32 count, MonoString *value, gint32 options, MonoBoolean first) MONO_INTERNAL; -extern int ves_icall_System_Globalization_CompareInfo_internal_index_char (MonoCompareInfo *this_obj, MonoString *source, gint32 sindex, gint32 count, gunichar2 value, gint32 options, MonoBoolean first) MONO_INTERNAL; -extern int ves_icall_System_Threading_Thread_current_lcid (void) MONO_INTERNAL; -extern MonoString *ves_icall_System_String_InternalReplace_Str_Comp (MonoString *this_obj, MonoString *old, MonoString *new_str, MonoCompareInfo *comp) MONO_INTERNAL; -extern MonoString *ves_icall_System_String_InternalToLower_Comp (MonoString *this_obj, MonoCultureInfo *cult) MONO_INTERNAL; -extern MonoString *ves_icall_System_String_InternalToUpper_Comp (MonoString *this_obj, MonoCultureInfo *cult) MONO_INTERNAL; -extern gunichar2 ves_icall_System_Char_InternalToUpper_Comp (gunichar2 c, MonoCultureInfo *cult) MONO_INTERNAL; -extern gunichar2 ves_icall_System_Char_InternalToLower_Comp (gunichar2 c, MonoCultureInfo *cult) MONO_INTERNAL; -extern void load_normalization_resource (guint8 **argProps, guint8** argMappedChars, guint8** argCharMapIndex, guint8** argHelperIndex, guint8** argMapIdxToComposite, guint8** argCombiningClass) MONO_INTERNAL; + MonoString *name); +extern void ves_icall_System_Globalization_CompareInfo_assign_sortkey (MonoCompareInfo *this_obj, MonoSortKey *key, MonoString *source, gint32 options); +extern int ves_icall_System_Globalization_CompareInfo_internal_index (MonoCompareInfo *this_obj, MonoString *source, gint32 sindex, gint32 count, MonoString *value, gint32 options, MonoBoolean first); +extern int ves_icall_System_Globalization_CompareInfo_internal_index_char (MonoCompareInfo *this_obj, MonoString *source, gint32 sindex, gint32 count, gunichar2 value, gint32 options, MonoBoolean first); +extern int ves_icall_System_Threading_Thread_current_lcid (void); +extern MonoString *ves_icall_System_String_InternalReplace_Str_Comp (MonoString *this_obj, MonoString *old, MonoString *new_str, MonoCompareInfo *comp); +extern MonoString *ves_icall_System_String_InternalToLower_Comp (MonoString *this_obj, MonoCultureInfo *cult); +extern MonoString *ves_icall_System_String_InternalToUpper_Comp (MonoString *this_obj, MonoCultureInfo *cult); +extern gunichar2 ves_icall_System_Char_InternalToUpper_Comp (gunichar2 c, MonoCultureInfo *cult); +extern gunichar2 ves_icall_System_Char_InternalToLower_Comp (gunichar2 c, MonoCultureInfo *cult); +extern void load_normalization_resource (guint8 **argProps, guint8** argMappedChars, guint8** argCharMapIndex, guint8** argHelperIndex, guint8** argMapIdxToComposite, guint8** argCombiningClass); #endif /* _MONO_METADATA_FILEIO_H_ */ diff --git a/mono/metadata/lock-tracer.h b/mono/metadata/lock-tracer.h index 4844edbb803..82e29ad5ffa 100644 --- a/mono/metadata/lock-tracer.h +++ b/mono/metadata/lock-tracer.h @@ -24,10 +24,10 @@ typedef enum { #ifdef LOCK_TRACER -void mono_locks_tracer_init (void) MONO_INTERNAL; +void mono_locks_tracer_init (void); -void mono_locks_lock_acquired (RuntimeLocks kind, gpointer lock) MONO_INTERNAL; -void mono_locks_lock_released (RuntimeLocks kind, gpointer lock) MONO_INTERNAL; +void mono_locks_lock_acquired (RuntimeLocks kind, gpointer lock); +void mono_locks_lock_released (RuntimeLocks kind, gpointer lock); #else diff --git a/mono/metadata/marshal.h b/mono/metadata/marshal.h index eb10aebac1f..03fc446a2f0 100644 --- a/mono/metadata/marshal.h +++ b/mono/metadata/marshal.h @@ -208,341 +208,341 @@ typedef void (*RuntimeInvokeDynamicFunction) (void *args, MonoObject **exc, void /* marshaling helper functions */ void -mono_marshal_init (void) MONO_INTERNAL; +mono_marshal_init (void); void -mono_marshal_init_tls (void) MONO_INTERNAL; +mono_marshal_init_tls (void); void -mono_marshal_cleanup (void) MONO_INTERNAL; +mono_marshal_cleanup (void); gint32 -mono_class_native_size (MonoClass *klass, guint32 *align) MONO_INTERNAL; +mono_class_native_size (MonoClass *klass, guint32 *align); MonoMarshalType * -mono_marshal_load_type_info (MonoClass* klass) MONO_INTERNAL; +mono_marshal_load_type_info (MonoClass* klass); gint32 mono_marshal_type_size (MonoType *type, MonoMarshalSpec *mspec, guint32 *align, - gboolean as_field, gboolean unicode) MONO_INTERNAL; + gboolean as_field, gboolean unicode); int -mono_type_native_stack_size (MonoType *type, guint32 *alignment) MONO_INTERNAL; +mono_type_native_stack_size (MonoType *type, guint32 *alignment); gpointer -mono_array_to_savearray (MonoArray *array) MONO_INTERNAL; +mono_array_to_savearray (MonoArray *array); gpointer -mono_array_to_lparray (MonoArray *array) MONO_INTERNAL; +mono_array_to_lparray (MonoArray *array); void -mono_free_lparray (MonoArray *array, gpointer* nativeArray) MONO_INTERNAL; +mono_free_lparray (MonoArray *array, gpointer* nativeArray); void -mono_string_utf8_to_builder (MonoStringBuilder *sb, char *text) MONO_INTERNAL; +mono_string_utf8_to_builder (MonoStringBuilder *sb, char *text); void -mono_string_utf16_to_builder (MonoStringBuilder *sb, gunichar2 *text) MONO_INTERNAL; +mono_string_utf16_to_builder (MonoStringBuilder *sb, gunichar2 *text); gpointer -mono_string_builder_to_utf8 (MonoStringBuilder *sb) MONO_INTERNAL; +mono_string_builder_to_utf8 (MonoStringBuilder *sb); gpointer -mono_string_builder_to_utf16 (MonoStringBuilder *sb) MONO_INTERNAL; +mono_string_builder_to_utf16 (MonoStringBuilder *sb); gpointer -mono_string_to_ansibstr (MonoString *string_obj) MONO_INTERNAL; +mono_string_to_ansibstr (MonoString *string_obj); gpointer -mono_string_to_bstr (MonoString *string_obj) MONO_INTERNAL; +mono_string_to_bstr (MonoString *string_obj); void -mono_string_to_byvalstr (gpointer dst, MonoString *src, int size) MONO_INTERNAL; +mono_string_to_byvalstr (gpointer dst, MonoString *src, int size); void -mono_string_to_byvalwstr (gpointer dst, MonoString *src, int size) MONO_INTERNAL; +mono_string_to_byvalwstr (gpointer dst, MonoString *src, int size); gpointer -mono_delegate_to_ftnptr (MonoDelegate *delegate) MONO_INTERNAL; +mono_delegate_to_ftnptr (MonoDelegate *delegate); MonoDelegate* -mono_ftnptr_to_delegate (MonoClass *klass, gpointer ftn) MONO_INTERNAL; +mono_ftnptr_to_delegate (MonoClass *klass, gpointer ftn); -void mono_delegate_free_ftnptr (MonoDelegate *delegate) MONO_INTERNAL; +void mono_delegate_free_ftnptr (MonoDelegate *delegate); void -mono_marshal_set_last_error (void) MONO_INTERNAL; +mono_marshal_set_last_error (void); gpointer -mono_marshal_asany (MonoObject *obj, MonoMarshalNative string_encoding, int param_attrs) MONO_INTERNAL; +mono_marshal_asany (MonoObject *obj, MonoMarshalNative string_encoding, int param_attrs); void -mono_marshal_free_asany (MonoObject *o, gpointer ptr, MonoMarshalNative string_encoding, int param_attrs) MONO_INTERNAL; +mono_marshal_free_asany (MonoObject *o, gpointer ptr, MonoMarshalNative string_encoding, int param_attrs); guint -mono_type_to_ldind (MonoType *type) MONO_INTERNAL; +mono_type_to_ldind (MonoType *type); guint -mono_type_to_stind (MonoType *type) MONO_INTERNAL; +mono_type_to_stind (MonoType *type); /* functions to create various architecture independent helper functions */ MonoMethod * -mono_marshal_method_from_wrapper (MonoMethod *wrapper) MONO_INTERNAL; +mono_marshal_method_from_wrapper (MonoMethod *wrapper); WrapperInfo* -mono_wrapper_info_create (MonoMethodBuilder *mb, WrapperSubtype subtype) MONO_INTERNAL; +mono_wrapper_info_create (MonoMethodBuilder *mb, WrapperSubtype subtype); void -mono_marshal_set_wrapper_info (MonoMethod *method, gpointer data) MONO_INTERNAL; +mono_marshal_set_wrapper_info (MonoMethod *method, gpointer data); gpointer -mono_marshal_get_wrapper_info (MonoMethod *wrapper) MONO_INTERNAL; +mono_marshal_get_wrapper_info (MonoMethod *wrapper); MonoMethod * -mono_marshal_get_delegate_begin_invoke (MonoMethod *method) MONO_INTERNAL; +mono_marshal_get_delegate_begin_invoke (MonoMethod *method); MonoMethod * -mono_marshal_get_delegate_end_invoke (MonoMethod *method) MONO_INTERNAL; +mono_marshal_get_delegate_end_invoke (MonoMethod *method); MonoMethod * -mono_marshal_get_delegate_invoke (MonoMethod *method, MonoDelegate *del) MONO_INTERNAL; +mono_marshal_get_delegate_invoke (MonoMethod *method, MonoDelegate *del); MonoMethod * -mono_marshal_get_runtime_invoke (MonoMethod *method, gboolean is_virtual) MONO_INTERNAL; +mono_marshal_get_runtime_invoke (MonoMethod *method, gboolean is_virtual); MonoMethod* -mono_marshal_get_runtime_invoke_dynamic (void) MONO_INTERNAL; +mono_marshal_get_runtime_invoke_dynamic (void); MonoMethodSignature* -mono_marshal_get_string_ctor_signature (MonoMethod *method) MONO_INTERNAL; +mono_marshal_get_string_ctor_signature (MonoMethod *method); MonoMethod * -mono_marshal_get_managed_wrapper (MonoMethod *method, MonoClass *delegate_klass, uint32_t this_loc) MONO_INTERNAL; +mono_marshal_get_managed_wrapper (MonoMethod *method, MonoClass *delegate_klass, uint32_t this_loc); gpointer -mono_marshal_get_vtfixup_ftnptr (MonoImage *image, guint32 token, guint16 type) MONO_INTERNAL; +mono_marshal_get_vtfixup_ftnptr (MonoImage *image, guint32 token, guint16 type); MonoMethod * -mono_marshal_get_icall_wrapper (MonoMethodSignature *sig, const char *name, gconstpointer func, gboolean check_exceptions) MONO_INTERNAL; +mono_marshal_get_icall_wrapper (MonoMethodSignature *sig, const char *name, gconstpointer func, gboolean check_exceptions); MonoMethod * -mono_marshal_get_native_wrapper (MonoMethod *method, gboolean check_exceptions, gboolean aot) MONO_INTERNAL; +mono_marshal_get_native_wrapper (MonoMethod *method, gboolean check_exceptions, gboolean aot); MonoMethod * -mono_marshal_get_native_func_wrapper (MonoImage *image, MonoMethodSignature *sig, MonoMethodPInvoke *piinfo, MonoMarshalSpec **mspecs, gpointer func) MONO_INTERNAL; +mono_marshal_get_native_func_wrapper (MonoImage *image, MonoMethodSignature *sig, MonoMethodPInvoke *piinfo, MonoMarshalSpec **mspecs, gpointer func); MonoMethod* -mono_marshal_get_native_func_wrapper_aot (MonoClass *klass) MONO_INTERNAL; +mono_marshal_get_native_func_wrapper_aot (MonoClass *klass); MonoMethod * -mono_marshal_get_struct_to_ptr (MonoClass *klass) MONO_INTERNAL; +mono_marshal_get_struct_to_ptr (MonoClass *klass); MonoMethod * -mono_marshal_get_ptr_to_struct (MonoClass *klass) MONO_INTERNAL; +mono_marshal_get_ptr_to_struct (MonoClass *klass); MonoMethod * -mono_marshal_get_synchronized_wrapper (MonoMethod *method) MONO_INTERNAL; +mono_marshal_get_synchronized_wrapper (MonoMethod *method); MonoMethod * -mono_marshal_get_synchronized_inner_wrapper (MonoMethod *method) MONO_INTERNAL; +mono_marshal_get_synchronized_inner_wrapper (MonoMethod *method); MonoMethod * -mono_marshal_get_unbox_wrapper (MonoMethod *method) MONO_INTERNAL; +mono_marshal_get_unbox_wrapper (MonoMethod *method); MonoMethod * -mono_marshal_get_castclass_with_cache (void) MONO_INTERNAL; +mono_marshal_get_castclass_with_cache (void); MonoMethod * -mono_marshal_get_isinst_with_cache (void) MONO_INTERNAL; +mono_marshal_get_isinst_with_cache (void); MonoMethod * -mono_marshal_get_isinst (MonoClass *klass) MONO_INTERNAL; +mono_marshal_get_isinst (MonoClass *klass); MonoMethod * -mono_marshal_get_castclass (MonoClass *klass) MONO_INTERNAL; +mono_marshal_get_castclass (MonoClass *klass); MonoMethod * -mono_marshal_get_stelemref (void) MONO_INTERNAL; +mono_marshal_get_stelemref (void); MonoMethod* -mono_marshal_get_virtual_stelemref (MonoClass *array_class) MONO_INTERNAL; +mono_marshal_get_virtual_stelemref (MonoClass *array_class); MonoMethod** -mono_marshal_get_virtual_stelemref_wrappers (int *nwrappers) MONO_INTERNAL; +mono_marshal_get_virtual_stelemref_wrappers (int *nwrappers); MonoMethod* -mono_marshal_get_array_address (int rank, int elem_size) MONO_INTERNAL; +mono_marshal_get_array_address (int rank, int elem_size); MonoMethod * -mono_marshal_get_array_accessor_wrapper (MonoMethod *method) MONO_INTERNAL; +mono_marshal_get_array_accessor_wrapper (MonoMethod *method); MonoMethod * mono_marshal_get_generic_array_helper (MonoClass *klass, MonoClass *iface, - gchar *name, MonoMethod *method) MONO_INTERNAL; + gchar *name, MonoMethod *method); MonoMethod * -mono_marshal_get_thunk_invoke_wrapper (MonoMethod *method) MONO_INTERNAL; +mono_marshal_get_thunk_invoke_wrapper (MonoMethod *method); MonoMethod* -mono_marshal_get_gsharedvt_in_wrapper (void) MONO_INTERNAL; +mono_marshal_get_gsharedvt_in_wrapper (void); MonoMethod* -mono_marshal_get_gsharedvt_out_wrapper (void) MONO_INTERNAL; +mono_marshal_get_gsharedvt_out_wrapper (void); void -mono_marshal_free_dynamic_wrappers (MonoMethod *method) MONO_INTERNAL; +mono_marshal_free_dynamic_wrappers (MonoMethod *method); void -mono_marshal_free_inflated_wrappers (MonoMethod *method) MONO_INTERNAL; +mono_marshal_free_inflated_wrappers (MonoMethod *method); void -mono_marshal_lock_internal (void) MONO_INTERNAL; +mono_marshal_lock_internal (void); void -mono_marshal_unlock_internal (void) MONO_INTERNAL; +mono_marshal_unlock_internal (void); /* marshaling internal calls */ void * -mono_marshal_alloc (gulong size) MONO_INTERNAL; +mono_marshal_alloc (gulong size); void -mono_marshal_free (gpointer ptr) MONO_INTERNAL; +mono_marshal_free (gpointer ptr); void -mono_marshal_free_array (gpointer *ptr, int size) MONO_INTERNAL; +mono_marshal_free_array (gpointer *ptr, int size); gboolean -mono_marshal_free_ccw (MonoObject* obj) MONO_INTERNAL; +mono_marshal_free_ccw (MonoObject* obj); void -cominterop_release_all_rcws (void) MONO_INTERNAL; +cominterop_release_all_rcws (void); void ves_icall_System_Runtime_InteropServices_Marshal_copy_to_unmanaged (MonoArray *src, gint32 start_index, - gpointer dest, gint32 length) MONO_INTERNAL; + gpointer dest, gint32 length); void ves_icall_System_Runtime_InteropServices_Marshal_copy_from_unmanaged (gpointer src, gint32 start_index, - MonoArray *dest, gint32 length) MONO_INTERNAL; + MonoArray *dest, gint32 length); MonoString * -ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi (char *ptr) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi (char *ptr); MonoString * -ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi_len (char *ptr, gint32 len) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi_len (char *ptr, gint32 len); MonoString * -ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringUni (guint16 *ptr) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringUni (guint16 *ptr); MonoString * -ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringUni_len (guint16 *ptr, gint32 len) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringUni_len (guint16 *ptr, gint32 len); MonoString * -ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringBSTR (gpointer ptr) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringBSTR (gpointer ptr); guint32 -ves_icall_System_Runtime_InteropServices_Marshal_GetComSlotForMethodInfoInternal (MonoReflectionMethod *m) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_GetComSlotForMethodInfoInternal (MonoReflectionMethod *m); guint32 -ves_icall_System_Runtime_InteropServices_Marshal_GetLastWin32Error (void) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_GetLastWin32Error (void); guint32 -ves_icall_System_Runtime_InteropServices_Marshal_SizeOf (MonoReflectionType *rtype) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_SizeOf (MonoReflectionType *rtype); void -ves_icall_System_Runtime_InteropServices_Marshal_StructureToPtr (MonoObject *obj, gpointer dst, MonoBoolean delete_old) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_StructureToPtr (MonoObject *obj, gpointer dst, MonoBoolean delete_old); void -ves_icall_System_Runtime_InteropServices_Marshal_PtrToStructure (gpointer src, MonoObject *dst) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_PtrToStructure (gpointer src, MonoObject *dst); MonoObject * -ves_icall_System_Runtime_InteropServices_Marshal_PtrToStructure_type (gpointer src, MonoReflectionType *type) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_PtrToStructure_type (gpointer src, MonoReflectionType *type); int -ves_icall_System_Runtime_InteropServices_Marshal_OffsetOf (MonoReflectionType *type, MonoString *field_name) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_OffsetOf (MonoReflectionType *type, MonoString *field_name); gpointer -ves_icall_System_Runtime_InteropServices_Marshal_StringToBSTR (MonoString *string) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_StringToBSTR (MonoString *string); gpointer -ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalAnsi (MonoString *string) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalAnsi (MonoString *string); gpointer -ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalUni (MonoString *string) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalUni (MonoString *string); void -ves_icall_System_Runtime_InteropServices_Marshal_DestroyStructure (gpointer src, MonoReflectionType *type) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_DestroyStructure (gpointer src, MonoReflectionType *type); void* -ves_icall_System_Runtime_InteropServices_Marshal_AllocCoTaskMem (int size) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_AllocCoTaskMem (int size); void -ves_icall_System_Runtime_InteropServices_Marshal_FreeCoTaskMem (void *ptr) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_FreeCoTaskMem (void *ptr); gpointer -ves_icall_System_Runtime_InteropServices_Marshal_ReAllocCoTaskMem (gpointer ptr, int size) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_ReAllocCoTaskMem (gpointer ptr, int size); void* -ves_icall_System_Runtime_InteropServices_Marshal_AllocHGlobal (int size) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_AllocHGlobal (int size); gpointer -ves_icall_System_Runtime_InteropServices_Marshal_ReAllocHGlobal (gpointer ptr, int size) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_ReAllocHGlobal (gpointer ptr, int size); void -ves_icall_System_Runtime_InteropServices_Marshal_FreeHGlobal (void *ptr) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_FreeHGlobal (void *ptr); void -ves_icall_System_Runtime_InteropServices_Marshal_FreeBSTR (void *ptr) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_FreeBSTR (void *ptr); void* -ves_icall_System_Runtime_InteropServices_Marshal_UnsafeAddrOfPinnedArrayElement (MonoArray *arrayobj, int index) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_UnsafeAddrOfPinnedArrayElement (MonoArray *arrayobj, int index); MonoDelegate* -ves_icall_System_Runtime_InteropServices_Marshal_GetDelegateForFunctionPointerInternal (void *ftn, MonoReflectionType *type) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_GetDelegateForFunctionPointerInternal (void *ftn, MonoReflectionType *type); int -ves_icall_System_Runtime_InteropServices_Marshal_AddRefInternal (gpointer pUnk) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_AddRefInternal (gpointer pUnk); int -ves_icall_System_Runtime_InteropServices_Marshal_QueryInterfaceInternal (gpointer pUnk, gpointer riid, gpointer* ppv) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_QueryInterfaceInternal (gpointer pUnk, gpointer riid, gpointer* ppv); int -ves_icall_System_Runtime_InteropServices_Marshal_ReleaseInternal (gpointer pUnk) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_ReleaseInternal (gpointer pUnk); void* -ves_icall_System_Runtime_InteropServices_Marshal_GetIUnknownForObjectInternal (MonoObject* object) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_GetIUnknownForObjectInternal (MonoObject* object); MonoObject* -ves_icall_System_Runtime_InteropServices_Marshal_GetObjectForCCW (void* pUnk) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_GetObjectForCCW (void* pUnk); void* -ves_icall_System_Runtime_InteropServices_Marshal_GetIDispatchForObjectInternal (MonoObject* object) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_GetIDispatchForObjectInternal (MonoObject* object); void* -ves_icall_System_Runtime_InteropServices_Marshal_GetCCW (MonoObject* object, MonoReflectionType* type) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_GetCCW (MonoObject* object, MonoReflectionType* type); MonoBoolean -ves_icall_System_Runtime_InteropServices_Marshal_IsComObject (MonoObject* object) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_IsComObject (MonoObject* object); gint32 -ves_icall_System_Runtime_InteropServices_Marshal_ReleaseComObjectInternal (MonoObject* object) MONO_INTERNAL; +ves_icall_System_Runtime_InteropServices_Marshal_ReleaseComObjectInternal (MonoObject* object); MonoObject * -ves_icall_System_ComObject_CreateRCW (MonoReflectionType *type) MONO_INTERNAL; +ves_icall_System_ComObject_CreateRCW (MonoReflectionType *type); void -ves_icall_System_ComObject_ReleaseInterfaces(MonoComObject* obj) MONO_INTERNAL; +ves_icall_System_ComObject_ReleaseInterfaces(MonoComObject* obj); gpointer -ves_icall_System_ComObject_GetInterfaceInternal (MonoComObject* obj, MonoReflectionType* type, MonoBoolean throw_exception) MONO_INTERNAL; +ves_icall_System_ComObject_GetInterfaceInternal (MonoComObject* obj, MonoReflectionType* type, MonoBoolean throw_exception); void -ves_icall_Mono_Interop_ComInteropProxy_AddProxy (gpointer pUnk, MonoComInteropProxy* proxy) MONO_INTERNAL; +ves_icall_Mono_Interop_ComInteropProxy_AddProxy (gpointer pUnk, MonoComInteropProxy* proxy); MonoComInteropProxy* -ves_icall_Mono_Interop_ComInteropProxy_FindProxy (gpointer pUnk) MONO_INTERNAL; +ves_icall_Mono_Interop_ComInteropProxy_FindProxy (gpointer pUnk); MONO_API void mono_win32_compat_CopyMemory (gpointer dest, gconstpointer source, gsize length); @@ -557,55 +557,55 @@ MONO_API void mono_win32_compat_ZeroMemory (gpointer dest, gsize length); void -mono_marshal_find_nonzero_bit_offset (guint8 *buf, int len, int *byte_offset, guint8 *bitmask) MONO_INTERNAL; +mono_marshal_find_nonzero_bit_offset (guint8 *buf, int len, int *byte_offset, guint8 *bitmask); MonoMethodSignature* -mono_signature_no_pinvoke (MonoMethod *method) MONO_INTERNAL; +mono_signature_no_pinvoke (MonoMethod *method); /* Called from cominterop.c/remoting.c */ void -mono_marshal_emit_native_wrapper (MonoImage *image, MonoMethodBuilder *mb, MonoMethodSignature *sig, MonoMethodPInvoke *piinfo, MonoMarshalSpec **mspecs, gpointer func, gboolean aot, gboolean check_exceptions, gboolean func_param) MONO_INTERNAL; +mono_marshal_emit_native_wrapper (MonoImage *image, MonoMethodBuilder *mb, MonoMethodSignature *sig, MonoMethodPInvoke *piinfo, MonoMarshalSpec **mspecs, gpointer func, gboolean aot, gboolean check_exceptions, gboolean func_param); void -mono_marshal_emit_managed_wrapper (MonoMethodBuilder *mb, MonoMethodSignature *invoke_sig, MonoMarshalSpec **mspecs, EmitMarshalContext* m, MonoMethod *method, uint32_t target_handle) MONO_INTERNAL; +mono_marshal_emit_managed_wrapper (MonoMethodBuilder *mb, MonoMethodSignature *invoke_sig, MonoMarshalSpec **mspecs, EmitMarshalContext* m, MonoMethod *method, uint32_t target_handle); GHashTable* -mono_marshal_get_cache (GHashTable **var, GHashFunc hash_func, GCompareFunc equal_func) MONO_INTERNAL; +mono_marshal_get_cache (GHashTable **var, GHashFunc hash_func, GCompareFunc equal_func); MonoMethod* -mono_marshal_find_in_cache (GHashTable *cache, gpointer key) MONO_INTERNAL; +mono_marshal_find_in_cache (GHashTable *cache, gpointer key); MonoMethod* mono_mb_create_and_cache (GHashTable *cache, gpointer key, MonoMethodBuilder *mb, MonoMethodSignature *sig, - int max_stack) MONO_INTERNAL; + int max_stack); void -mono_marshal_emit_thread_interrupt_checkpoint (MonoMethodBuilder *mb) MONO_INTERNAL; +mono_marshal_emit_thread_interrupt_checkpoint (MonoMethodBuilder *mb); void -mono_marshal_emit_thread_force_interrupt_checkpoint (MonoMethodBuilder *mb) MONO_INTERNAL; +mono_marshal_emit_thread_force_interrupt_checkpoint (MonoMethodBuilder *mb); void -mono_marshal_use_aot_wrappers (gboolean use) MONO_INTERNAL; +mono_marshal_use_aot_wrappers (gboolean use); MonoObject * -mono_marshal_xdomain_copy_value (MonoObject *val) MONO_INTERNAL; +mono_marshal_xdomain_copy_value (MonoObject *val); int -mono_mb_emit_save_args (MonoMethodBuilder *mb, MonoMethodSignature *sig, gboolean save_this) MONO_INTERNAL; +mono_mb_emit_save_args (MonoMethodBuilder *mb, MonoMethodSignature *sig, gboolean save_this); void -mono_mb_emit_restore_result (MonoMethodBuilder *mb, MonoType *return_type) MONO_INTERNAL; +mono_mb_emit_restore_result (MonoMethodBuilder *mb, MonoType *return_type); MonoMethod* mono_mb_create (MonoMethodBuilder *mb, MonoMethodSignature *sig, - int max_stack, WrapperInfo *info) MONO_INTERNAL; + int max_stack, WrapperInfo *info); MonoMethod* mono_mb_create_and_cache_full (GHashTable *cache, gpointer key, MonoMethodBuilder *mb, MonoMethodSignature *sig, - int max_stack, WrapperInfo *info, gboolean *out_found) MONO_INTERNAL; + int max_stack, WrapperInfo *info, gboolean *out_found); G_END_DECLS diff --git a/mono/metadata/mempool-internals.h b/mono/metadata/mempool-internals.h index a317a669b9c..afaf812d778 100644 --- a/mono/metadata/mempool-internals.h +++ b/mono/metadata/mempool-internals.h @@ -58,6 +58,6 @@ g_slist_append_mempool (MonoMemPool *mp, GSList *list, gpointer data) } long -mono_mempool_get_bytes_allocated (void) MONO_INTERNAL; +mono_mempool_get_bytes_allocated (void); #endif diff --git a/mono/metadata/metadata-internals.h b/mono/metadata/metadata-internals.h index 14eb80cd793..219276d2d7b 100644 --- a/mono/metadata/metadata-internals.h +++ b/mono/metadata/metadata-internals.h @@ -559,85 +559,85 @@ assembly_is_dynamic (MonoAssembly *assembly) } /* for use with allocated memory blocks (assumes alignment is to 8 bytes) */ -guint mono_aligned_addr_hash (gconstpointer ptr) MONO_INTERNAL; +guint mono_aligned_addr_hash (gconstpointer ptr); void -mono_image_check_for_module_cctor (MonoImage *image) MONO_INTERNAL; +mono_image_check_for_module_cctor (MonoImage *image); gpointer -mono_image_alloc (MonoImage *image, guint size) MONO_INTERNAL; +mono_image_alloc (MonoImage *image, guint size); gpointer -mono_image_alloc0 (MonoImage *image, guint size) MONO_INTERNAL; +mono_image_alloc0 (MonoImage *image, guint size); #define mono_image_new0(image,type,size) ((type *) mono_image_alloc0 (image, sizeof (type)* (size))) char* -mono_image_strdup (MonoImage *image, const char *s) MONO_INTERNAL; +mono_image_strdup (MonoImage *image, const char *s); GList* -g_list_prepend_image (MonoImage *image, GList *list, gpointer data) MONO_INTERNAL; +g_list_prepend_image (MonoImage *image, GList *list, gpointer data); GSList* -g_slist_append_image (MonoImage *image, GSList *list, gpointer data) MONO_INTERNAL; +g_slist_append_image (MonoImage *image, GSList *list, gpointer data); void -mono_image_lock (MonoImage *image) MONO_INTERNAL; +mono_image_lock (MonoImage *image); void -mono_image_unlock (MonoImage *image) MONO_INTERNAL; +mono_image_unlock (MonoImage *image); gpointer -mono_image_property_lookup (MonoImage *image, gpointer subject, guint32 property) MONO_INTERNAL; +mono_image_property_lookup (MonoImage *image, gpointer subject, guint32 property); void -mono_image_property_insert (MonoImage *image, gpointer subject, guint32 property, gpointer value) MONO_INTERNAL; +mono_image_property_insert (MonoImage *image, gpointer subject, guint32 property, gpointer value); void -mono_image_property_remove (MonoImage *image, gpointer subject) MONO_INTERNAL; +mono_image_property_remove (MonoImage *image, gpointer subject); gboolean -mono_image_close_except_pools (MonoImage *image) MONO_INTERNAL; +mono_image_close_except_pools (MonoImage *image); void -mono_image_close_finish (MonoImage *image) MONO_INTERNAL; +mono_image_close_finish (MonoImage *image); typedef void (*MonoImageUnloadFunc) (MonoImage *image, gpointer user_data); void -mono_install_image_unload_hook (MonoImageUnloadFunc func, gpointer user_data) MONO_INTERNAL; +mono_install_image_unload_hook (MonoImageUnloadFunc func, gpointer user_data); void -mono_remove_image_unload_hook (MonoImageUnloadFunc func, gpointer user_data) MONO_INTERNAL; +mono_remove_image_unload_hook (MonoImageUnloadFunc func, gpointer user_data); void -mono_image_append_class_to_reflection_info_set (MonoClass *klass) MONO_INTERNAL; +mono_image_append_class_to_reflection_info_set (MonoClass *klass); gpointer -mono_image_set_alloc (MonoImageSet *set, guint size) MONO_INTERNAL; +mono_image_set_alloc (MonoImageSet *set, guint size); gpointer -mono_image_set_alloc0 (MonoImageSet *set, guint size) MONO_INTERNAL; +mono_image_set_alloc0 (MonoImageSet *set, guint size); char* -mono_image_set_strdup (MonoImageSet *set, const char *s) MONO_INTERNAL; +mono_image_set_strdup (MonoImageSet *set, const char *s); #define mono_image_set_new0(image,type,size) ((type *) mono_image_set_alloc0 (image, sizeof (type)* (size))) MonoType* -mono_metadata_get_shared_type (MonoType *type) MONO_INTERNAL; +mono_metadata_get_shared_type (MonoType *type); void -mono_metadata_clean_for_image (MonoImage *image) MONO_INTERNAL; +mono_metadata_clean_for_image (MonoImage *image); void -mono_metadata_clean_generic_classes_for_image (MonoImage *image) MONO_INTERNAL; +mono_metadata_clean_generic_classes_for_image (MonoImage *image); MONO_API void mono_metadata_cleanup (void); -const char * mono_meta_table_name (int table) MONO_INTERNAL; -void mono_metadata_compute_table_bases (MonoImage *meta) MONO_INTERNAL; +const char * mono_meta_table_name (int table); +void mono_metadata_compute_table_bases (MonoImage *meta); gboolean mono_metadata_interfaces_from_typedef_full (MonoImage *image, @@ -646,13 +646,13 @@ mono_metadata_interfaces_from_typedef_full (MonoImage *image, guint *count, gboolean heap_alloc_result, MonoGenericContext *context, - MonoError *error) MONO_INTERNAL; + MonoError *error); MonoArrayType * mono_metadata_parse_array_full (MonoImage *image, MonoGenericContainer *container, const char *ptr, - const char **rptr) MONO_INTERNAL; + const char **rptr); MONO_API MonoType * mono_metadata_parse_type_full (MonoImage *image, @@ -665,7 +665,7 @@ mono_metadata_parse_type_full (MonoImage *image, MonoMethodSignature * mono_metadata_parse_signature_full (MonoImage *image, MonoGenericContainer *generic_container, - guint32 token) MONO_INTERNAL; + guint32 token); MONO_API MonoMethodSignature * mono_metadata_parse_method_signature_full (MonoImage *image, @@ -681,84 +681,84 @@ mono_metadata_parse_mh_full (MonoImage *image, const char *ptr); gboolean -mono_method_get_header_summary (MonoMethod *method, MonoMethodHeaderSummary *summary) MONO_INTERNAL; +mono_method_get_header_summary (MonoMethod *method, MonoMethodHeaderSummary *summary); -int* mono_metadata_get_param_attrs (MonoImage *m, int def, int param_count) MONO_INTERNAL; -gboolean mono_metadata_method_has_param_attrs (MonoImage *m, int def) MONO_INTERNAL; +int* mono_metadata_get_param_attrs (MonoImage *m, int def, int param_count); +gboolean mono_metadata_method_has_param_attrs (MonoImage *m, int def); guint -mono_metadata_generic_context_hash (const MonoGenericContext *context) MONO_INTERNAL; +mono_metadata_generic_context_hash (const MonoGenericContext *context); gboolean mono_metadata_generic_context_equal (const MonoGenericContext *g1, - const MonoGenericContext *g2) MONO_INTERNAL; + const MonoGenericContext *g2); MonoGenericInst * mono_metadata_parse_generic_inst (MonoImage *image, MonoGenericContainer *container, int count, const char *ptr, - const char **rptr) MONO_INTERNAL; + const char **rptr); MonoGenericInst * mono_metadata_get_generic_inst (int type_argc, - MonoType **type_argv) MONO_INTERNAL; + MonoType **type_argv); MonoGenericClass * mono_metadata_lookup_generic_class (MonoClass *gclass, MonoGenericInst *inst, - gboolean is_dynamic) MONO_INTERNAL; + gboolean is_dynamic); -MonoGenericInst * mono_metadata_inflate_generic_inst (MonoGenericInst *ginst, MonoGenericContext *context, MonoError *error) MONO_INTERNAL; +MonoGenericInst * mono_metadata_inflate_generic_inst (MonoGenericInst *ginst, MonoGenericContext *context, MonoError *error); -void mono_dynamic_stream_reset (MonoDynamicStream* stream) MONO_INTERNAL; -void mono_assembly_addref (MonoAssembly *assembly) MONO_INTERNAL; -void mono_assembly_load_friends (MonoAssembly* ass) MONO_INTERNAL; -gboolean mono_assembly_has_skip_verification (MonoAssembly* ass) MONO_INTERNAL; +void mono_dynamic_stream_reset (MonoDynamicStream* stream); +void mono_assembly_addref (MonoAssembly *assembly); +void mono_assembly_load_friends (MonoAssembly* ass); +gboolean mono_assembly_has_skip_verification (MonoAssembly* ass); -void mono_assembly_release_gc_roots (MonoAssembly *assembly) MONO_INTERNAL; -gboolean mono_assembly_close_except_image_pools (MonoAssembly *assembly) MONO_INTERNAL; -void mono_assembly_close_finish (MonoAssembly *assembly) MONO_INTERNAL; +void mono_assembly_release_gc_roots (MonoAssembly *assembly); +gboolean mono_assembly_close_except_image_pools (MonoAssembly *assembly); +void mono_assembly_close_finish (MonoAssembly *assembly); -gboolean mono_public_tokens_are_equal (const unsigned char *pubt1, const unsigned char *pubt2) MONO_INTERNAL; +gboolean mono_public_tokens_are_equal (const unsigned char *pubt1, const unsigned char *pubt2); -void mono_config_parse_publisher_policy (const char *filename, MonoAssemblyBindingInfo *binding_info) MONO_INTERNAL; +void mono_config_parse_publisher_policy (const char *filename, MonoAssemblyBindingInfo *binding_info); void mono_config_parse_assembly_bindings (const char *filename, int major, int minor, void *user_data, - void (*infocb)(MonoAssemblyBindingInfo *info, void *user_data)) MONO_INTERNAL; + void (*infocb)(MonoAssemblyBindingInfo *info, void *user_data)); gboolean mono_assembly_name_parse_full (const char *name, MonoAssemblyName *aname, gboolean save_public_key, gboolean *is_version_defined, - gboolean *is_token_defined) MONO_INTERNAL; + gboolean *is_token_defined); MONO_API guint32 mono_metadata_get_generic_param_row (MonoImage *image, guint32 token, guint32 *owner); -void mono_unload_interface_ids (MonoBitSet *bitset) MONO_INTERNAL; +void mono_unload_interface_ids (MonoBitSet *bitset); -MonoType *mono_metadata_type_dup (MonoImage *image, const MonoType *original) MONO_INTERNAL; -MonoMethodSignature *mono_metadata_signature_dup_full (MonoImage *image,MonoMethodSignature *sig) MONO_INTERNAL; -MonoMethodSignature *mono_metadata_signature_dup_mempool (MonoMemPool *mp, MonoMethodSignature *sig) MONO_INTERNAL; +MonoType *mono_metadata_type_dup (MonoImage *image, const MonoType *original); +MonoMethodSignature *mono_metadata_signature_dup_full (MonoImage *image,MonoMethodSignature *sig); +MonoMethodSignature *mono_metadata_signature_dup_mempool (MonoMemPool *mp, MonoMethodSignature *sig); MonoGenericInst * -mono_get_shared_generic_inst (MonoGenericContainer *container) MONO_INTERNAL; +mono_get_shared_generic_inst (MonoGenericContainer *container); int -mono_type_stack_size_internal (MonoType *t, int *align, gboolean allow_open) MONO_INTERNAL; +mono_type_stack_size_internal (MonoType *t, int *align, gboolean allow_open); MONO_API void mono_type_get_desc (GString *res, MonoType *type, mono_bool include_namespace); gboolean -mono_metadata_type_equal_full (MonoType *t1, MonoType *t2, gboolean signature_only) MONO_INTERNAL; +mono_metadata_type_equal_full (MonoType *t1, MonoType *t2, gboolean signature_only); MonoMarshalSpec * -mono_metadata_parse_marshal_spec_full (MonoImage *image, MonoImage *parent_image, const char *ptr) MONO_INTERNAL; +mono_metadata_parse_marshal_spec_full (MonoImage *image, MonoImage *parent_image, const char *ptr); -guint mono_metadata_generic_inst_hash (gconstpointer data) MONO_INTERNAL; -gboolean mono_metadata_generic_inst_equal (gconstpointer ka, gconstpointer kb) MONO_INTERNAL; +guint mono_metadata_generic_inst_hash (gconstpointer data); +gboolean mono_metadata_generic_inst_equal (gconstpointer ka, gconstpointer kb); MONO_API void mono_metadata_field_info_with_mempool ( @@ -769,47 +769,47 @@ mono_metadata_field_info_with_mempool ( MonoMarshalSpec **marshal_spec); MonoClassField* -mono_metadata_get_corresponding_field_from_generic_type_definition (MonoClassField *field) MONO_INTERNAL; +mono_metadata_get_corresponding_field_from_generic_type_definition (MonoClassField *field); MonoEvent* -mono_metadata_get_corresponding_event_from_generic_type_definition (MonoEvent *event) MONO_INTERNAL; +mono_metadata_get_corresponding_event_from_generic_type_definition (MonoEvent *event); MonoProperty* -mono_metadata_get_corresponding_property_from_generic_type_definition (MonoProperty *property) MONO_INTERNAL; +mono_metadata_get_corresponding_property_from_generic_type_definition (MonoProperty *property); guint32 -mono_metadata_signature_size (MonoMethodSignature *sig) MONO_INTERNAL; +mono_metadata_signature_size (MonoMethodSignature *sig); -guint mono_metadata_str_hash (gconstpointer v1) MONO_INTERNAL; +guint mono_metadata_str_hash (gconstpointer v1); -gboolean mono_image_load_pe_data (MonoImage *image) MONO_INTERNAL; +gboolean mono_image_load_pe_data (MonoImage *image); -gboolean mono_image_load_cli_data (MonoImage *image) MONO_INTERNAL; +gboolean mono_image_load_cli_data (MonoImage *image); -void mono_image_load_names (MonoImage *image) MONO_INTERNAL; +void mono_image_load_names (MonoImage *image); -MonoImage *mono_image_open_raw (const char *fname, MonoImageOpenStatus *status) MONO_INTERNAL; +MonoImage *mono_image_open_raw (const char *fname, MonoImageOpenStatus *status); -MonoException *mono_get_exception_field_access_msg (const char *msg) MONO_INTERNAL; +MonoException *mono_get_exception_field_access_msg (const char *msg); -MonoException *mono_get_exception_method_access_msg (const char *msg) MONO_INTERNAL; +MonoException *mono_get_exception_method_access_msg (const char *msg); -MonoMethod* method_from_method_def_or_ref (MonoImage *m, guint32 tok, MonoGenericContext *context, MonoError *error) MONO_INTERNAL; +MonoMethod* method_from_method_def_or_ref (MonoImage *m, guint32 tok, MonoGenericContext *context, MonoError *error); -MonoMethod *mono_get_method_constrained_with_method (MonoImage *image, MonoMethod *method, MonoClass *constrained_class, MonoGenericContext *context, MonoError *error) MONO_INTERNAL; -MonoMethod *mono_get_method_constrained_checked (MonoImage *image, guint32 token, MonoClass *constrained_class, MonoGenericContext *context, MonoMethod **cil_method, MonoError *error) MONO_INTERNAL; +MonoMethod *mono_get_method_constrained_with_method (MonoImage *image, MonoMethod *method, MonoClass *constrained_class, MonoGenericContext *context, MonoError *error); +MonoMethod *mono_get_method_constrained_checked (MonoImage *image, guint32 token, MonoClass *constrained_class, MonoGenericContext *context, MonoMethod **cil_method, MonoError *error); -void mono_type_set_alignment (MonoTypeEnum type, int align) MONO_INTERNAL; +void mono_type_set_alignment (MonoTypeEnum type, int align); -MonoAotCacheConfig *mono_get_aot_cache_config (void) MONO_INTERNAL; +MonoAotCacheConfig *mono_get_aot_cache_config (void); MonoType * -mono_type_create_from_typespec_checked (MonoImage *image, guint32 type_spec, MonoError *error) MONO_INTERNAL; +mono_type_create_from_typespec_checked (MonoImage *image, guint32 type_spec, MonoError *error); MonoMethodSignature* -mono_method_get_signature_checked (MonoMethod *method, MonoImage *image, guint32 token, MonoGenericContext *context, MonoError *error) MONO_INTERNAL; +mono_method_get_signature_checked (MonoMethod *method, MonoImage *image, guint32 token, MonoGenericContext *context, MonoError *error); MonoMethod * -mono_get_method_checked (MonoImage *image, guint32 token, MonoClass *klass, MonoGenericContext *context, MonoError *error) MONO_INTERNAL; +mono_get_method_checked (MonoImage *image, guint32 token, MonoClass *klass, MonoGenericContext *context, MonoError *error); #endif /* __MONO_METADATA_INTERNALS_H__ */ diff --git a/mono/metadata/method-builder.h b/mono/metadata/method-builder.h index be448c59192..444745cb0b3 100644 --- a/mono/metadata/method-builder.h +++ b/mono/metadata/method-builder.h @@ -38,116 +38,116 @@ typedef struct _MonoMethodBuilder { } MonoMethodBuilder; MonoMethodBuilder * -mono_mb_new (MonoClass *klass, const char *name, MonoWrapperType type) MONO_INTERNAL; +mono_mb_new (MonoClass *klass, const char *name, MonoWrapperType type); MonoMethodBuilder * -mono_mb_new_no_dup_name (MonoClass *klass, const char *name, MonoWrapperType type) MONO_INTERNAL; +mono_mb_new_no_dup_name (MonoClass *klass, const char *name, MonoWrapperType type); void -mono_mb_free (MonoMethodBuilder *mb) MONO_INTERNAL; +mono_mb_free (MonoMethodBuilder *mb); MonoMethod * -mono_mb_create_method (MonoMethodBuilder *mb, MonoMethodSignature *signature, int max_stack) MONO_INTERNAL; +mono_mb_create_method (MonoMethodBuilder *mb, MonoMethodSignature *signature, int max_stack); guint32 -mono_mb_add_data (MonoMethodBuilder *mb, gpointer data) MONO_INTERNAL; +mono_mb_add_data (MonoMethodBuilder *mb, gpointer data); #ifndef DISABLE_JIT void -mono_mb_patch_addr (MonoMethodBuilder *mb, int pos, int value) MONO_INTERNAL; +mono_mb_patch_addr (MonoMethodBuilder *mb, int pos, int value); void -mono_mb_patch_addr_s (MonoMethodBuilder *mb, int pos, gint8 value) MONO_INTERNAL; +mono_mb_patch_addr_s (MonoMethodBuilder *mb, int pos, gint8 value); void -mono_mb_patch_branch (MonoMethodBuilder *mb, guint32 pos) MONO_INTERNAL; +mono_mb_patch_branch (MonoMethodBuilder *mb, guint32 pos); void -mono_mb_patch_short_branch (MonoMethodBuilder *mb, guint32 pos) MONO_INTERNAL; +mono_mb_patch_short_branch (MonoMethodBuilder *mb, guint32 pos); int -mono_mb_get_label (MonoMethodBuilder *mb) MONO_INTERNAL; +mono_mb_get_label (MonoMethodBuilder *mb); int -mono_mb_get_pos (MonoMethodBuilder *mb) MONO_INTERNAL; +mono_mb_get_pos (MonoMethodBuilder *mb); void -mono_mb_emit_ptr (MonoMethodBuilder *mb, gpointer ptr) MONO_INTERNAL; +mono_mb_emit_ptr (MonoMethodBuilder *mb, gpointer ptr); void -mono_mb_emit_calli (MonoMethodBuilder *mb, MonoMethodSignature *sig) MONO_INTERNAL; +mono_mb_emit_calli (MonoMethodBuilder *mb, MonoMethodSignature *sig); void -mono_mb_emit_native_call (MonoMethodBuilder *mb, MonoMethodSignature *sig, gpointer func) MONO_INTERNAL; +mono_mb_emit_native_call (MonoMethodBuilder *mb, MonoMethodSignature *sig, gpointer func); void -mono_mb_emit_managed_call (MonoMethodBuilder *mb, MonoMethod *method, MonoMethodSignature *opt_sig) MONO_INTERNAL; +mono_mb_emit_managed_call (MonoMethodBuilder *mb, MonoMethod *method, MonoMethodSignature *opt_sig); void -mono_mb_emit_icall (MonoMethodBuilder *mb, gpointer func) MONO_INTERNAL; +mono_mb_emit_icall (MonoMethodBuilder *mb, gpointer func); int -mono_mb_add_local (MonoMethodBuilder *mb, MonoType *type) MONO_INTERNAL; +mono_mb_add_local (MonoMethodBuilder *mb, MonoType *type); void -mono_mb_emit_ldarg (MonoMethodBuilder *mb, guint argnum) MONO_INTERNAL; +mono_mb_emit_ldarg (MonoMethodBuilder *mb, guint argnum); void -mono_mb_emit_ldarg_addr (MonoMethodBuilder *mb, guint argnum) MONO_INTERNAL; +mono_mb_emit_ldarg_addr (MonoMethodBuilder *mb, guint argnum); void -mono_mb_emit_ldloc (MonoMethodBuilder *mb, guint num) MONO_INTERNAL; +mono_mb_emit_ldloc (MonoMethodBuilder *mb, guint num); void -mono_mb_emit_ldloc_addr (MonoMethodBuilder *mb, guint locnum) MONO_INTERNAL; +mono_mb_emit_ldloc_addr (MonoMethodBuilder *mb, guint locnum); void -mono_mb_emit_stloc (MonoMethodBuilder *mb, guint num) MONO_INTERNAL; +mono_mb_emit_stloc (MonoMethodBuilder *mb, guint num); void -mono_mb_emit_exception (MonoMethodBuilder *mb, const char *exc_name, const char *msg) MONO_INTERNAL; +mono_mb_emit_exception (MonoMethodBuilder *mb, const char *exc_name, const char *msg); void -mono_mb_emit_exception_full (MonoMethodBuilder *mb, const char *exc_nspace, const char *exc_name, const char *msg) MONO_INTERNAL; +mono_mb_emit_exception_full (MonoMethodBuilder *mb, const char *exc_nspace, const char *exc_name, const char *msg); void -mono_mb_emit_icon (MonoMethodBuilder *mb, gint32 value) MONO_INTERNAL; +mono_mb_emit_icon (MonoMethodBuilder *mb, gint32 value); guint32 -mono_mb_emit_branch (MonoMethodBuilder *mb, guint8 op) MONO_INTERNAL; +mono_mb_emit_branch (MonoMethodBuilder *mb, guint8 op); guint32 -mono_mb_emit_short_branch (MonoMethodBuilder *mb, guint8 op) MONO_INTERNAL; +mono_mb_emit_short_branch (MonoMethodBuilder *mb, guint8 op); void -mono_mb_emit_branch_label (MonoMethodBuilder *mb, guint8 op, guint32 label) MONO_INTERNAL; +mono_mb_emit_branch_label (MonoMethodBuilder *mb, guint8 op, guint32 label); void -mono_mb_emit_add_to_local (MonoMethodBuilder *mb, guint16 local, gint32 incr) MONO_INTERNAL; +mono_mb_emit_add_to_local (MonoMethodBuilder *mb, guint16 local, gint32 incr); void -mono_mb_emit_ldflda (MonoMethodBuilder *mb, gint32 offset) MONO_INTERNAL; +mono_mb_emit_ldflda (MonoMethodBuilder *mb, gint32 offset); void -mono_mb_emit_byte (MonoMethodBuilder *mb, guint8 op) MONO_INTERNAL; +mono_mb_emit_byte (MonoMethodBuilder *mb, guint8 op); void -mono_mb_emit_i2 (MonoMethodBuilder *mb, gint16 data) MONO_INTERNAL; +mono_mb_emit_i2 (MonoMethodBuilder *mb, gint16 data); void -mono_mb_emit_i4 (MonoMethodBuilder *mb, gint32 data) MONO_INTERNAL; +mono_mb_emit_i4 (MonoMethodBuilder *mb, gint32 data); void -mono_mb_emit_op (MonoMethodBuilder *mb, guint8 op, gpointer data) MONO_INTERNAL; +mono_mb_emit_op (MonoMethodBuilder *mb, guint8 op, gpointer data); void -mono_mb_emit_ldstr (MonoMethodBuilder *mb, char *str) MONO_INTERNAL; +mono_mb_emit_ldstr (MonoMethodBuilder *mb, char *str); void -mono_mb_set_clauses (MonoMethodBuilder *mb, int num_clauses, MonoExceptionClause *clauses) MONO_INTERNAL; +mono_mb_set_clauses (MonoMethodBuilder *mb, int num_clauses, MonoExceptionClause *clauses); void -mono_mb_set_param_names (MonoMethodBuilder *mb, const char **param_names) MONO_INTERNAL; +mono_mb_set_param_names (MonoMethodBuilder *mb, const char **param_names); #endif diff --git a/mono/metadata/monitor.h b/mono/metadata/monitor.h index 4d2bcdc9392..0a7fe777eaa 100644 --- a/mono/metadata/monitor.h +++ b/mono/metadata/monitor.h @@ -47,22 +47,22 @@ struct _MonoThreadsSync MONO_API void mono_locks_dump (gboolean include_untaken); -void mono_monitor_init (void) MONO_INTERNAL; -void mono_monitor_cleanup (void) MONO_INTERNAL; +void mono_monitor_init (void); +void mono_monitor_cleanup (void); -void** mono_monitor_get_object_monitor_weak_link (MonoObject *object) MONO_INTERNAL; +void** mono_monitor_get_object_monitor_weak_link (MonoObject *object); -void mono_monitor_threads_sync_members_offset (int *status_offset, int *nest_offset) MONO_INTERNAL; +void mono_monitor_threads_sync_members_offset (int *status_offset, int *nest_offset); #define MONO_THREADS_SYNC_MEMBER_OFFSET(o) ((o)>>8) #define MONO_THREADS_SYNC_MEMBER_SIZE(o) ((o)&0xff) -extern gboolean ves_icall_System_Threading_Monitor_Monitor_try_enter(MonoObject *obj, guint32 ms) MONO_INTERNAL; -extern gboolean ves_icall_System_Threading_Monitor_Monitor_test_owner(MonoObject *obj) MONO_INTERNAL; -extern gboolean ves_icall_System_Threading_Monitor_Monitor_test_synchronised(MonoObject *obj) MONO_INTERNAL; -extern void ves_icall_System_Threading_Monitor_Monitor_pulse(MonoObject *obj) MONO_INTERNAL; -extern void ves_icall_System_Threading_Monitor_Monitor_pulse_all(MonoObject *obj) MONO_INTERNAL; -extern gboolean ves_icall_System_Threading_Monitor_Monitor_wait(MonoObject *obj, guint32 ms) MONO_INTERNAL; -extern void ves_icall_System_Threading_Monitor_Monitor_try_enter_with_atomic_var (MonoObject *obj, guint32 ms, char *lockTaken) MONO_INTERNAL; +extern gboolean ves_icall_System_Threading_Monitor_Monitor_try_enter(MonoObject *obj, guint32 ms); +extern gboolean ves_icall_System_Threading_Monitor_Monitor_test_owner(MonoObject *obj); +extern gboolean ves_icall_System_Threading_Monitor_Monitor_test_synchronised(MonoObject *obj); +extern void ves_icall_System_Threading_Monitor_Monitor_pulse(MonoObject *obj); +extern void ves_icall_System_Threading_Monitor_Monitor_pulse_all(MonoObject *obj); +extern gboolean ves_icall_System_Threading_Monitor_Monitor_wait(MonoObject *obj, guint32 ms); +extern void ves_icall_System_Threading_Monitor_Monitor_try_enter_with_atomic_var (MonoObject *obj, guint32 ms, char *lockTaken); G_END_DECLS diff --git a/mono/metadata/mono-basic-block.h b/mono/metadata/mono-basic-block.h index 18457249d12..a971b36176e 100644 --- a/mono/metadata/mono-basic-block.h +++ b/mono/metadata/mono-basic-block.h @@ -19,18 +19,18 @@ struct _MonoSimpleBasicBlock { }; MonoSimpleBasicBlock* -mono_basic_block_split (MonoMethod *method, MonoError *error) MONO_INTERNAL; +mono_basic_block_split (MonoMethod *method, MonoError *error); void -mono_basic_block_free (MonoSimpleBasicBlock *bb) MONO_INTERNAL; +mono_basic_block_free (MonoSimpleBasicBlock *bb); /*This function is here because opcodes.h is a public header*/ int -mono_opcode_value_and_size (const unsigned char **ip, const unsigned char *end, int *value) MONO_INTERNAL; +mono_opcode_value_and_size (const unsigned char **ip, const unsigned char *end, int *value); int -mono_opcode_size (const unsigned char *ip, const unsigned char *end) MONO_INTERNAL; +mono_opcode_size (const unsigned char *ip, const unsigned char *end); G_END_DECLS diff --git a/mono/metadata/mono-cq.h b/mono/metadata/mono-cq.h index 26e1642305b..db776c565f5 100644 --- a/mono/metadata/mono-cq.h +++ b/mono/metadata/mono-cq.h @@ -10,11 +10,11 @@ G_BEGIN_DECLS typedef struct _MonoCQ MonoCQ; -MonoCQ *mono_cq_create (void) MONO_INTERNAL; -void mono_cq_destroy (MonoCQ *cq) MONO_INTERNAL; -gint mono_cq_count (MonoCQ *cq) MONO_INTERNAL; -void mono_cq_enqueue (MonoCQ *cq, MonoObject *obj) MONO_INTERNAL; -gboolean mono_cq_dequeue (MonoCQ *cq, MonoObject **result) MONO_INTERNAL; +MonoCQ *mono_cq_create (void); +void mono_cq_destroy (MonoCQ *cq); +gint mono_cq_count (MonoCQ *cq); +void mono_cq_enqueue (MonoCQ *cq, MonoObject *obj); +gboolean mono_cq_dequeue (MonoCQ *cq, MonoObject **result); G_END_DECLS diff --git a/mono/metadata/mono-debug-debugger.h b/mono/metadata/mono-debug-debugger.h index c61a504be15..166c9ab6385 100644 --- a/mono/metadata/mono-debug-debugger.h +++ b/mono/metadata/mono-debug-debugger.h @@ -12,12 +12,12 @@ #include -void mono_debugger_initialize (void) MONO_INTERNAL; +void mono_debugger_initialize (void); -void mono_debugger_lock (void) MONO_INTERNAL; -void mono_debugger_unlock (void) MONO_INTERNAL; +void mono_debugger_lock (void); +void mono_debugger_unlock (void); gchar * -mono_debugger_check_runtime_version (const char *filename) MONO_INTERNAL; +mono_debugger_check_runtime_version (const char *filename); #endif /* __MONO_DEBUG_DEBUGGER_H__ */ diff --git a/mono/metadata/mono-perfcounters.h b/mono/metadata/mono-perfcounters.h index c9f3fc2be09..906d2c69b8b 100644 --- a/mono/metadata/mono-perfcounters.h +++ b/mono/metadata/mono-perfcounters.h @@ -8,22 +8,22 @@ typedef struct _MonoCounterSample MonoCounterSample; void* mono_perfcounter_get_impl (MonoString* category, MonoString* counter, MonoString* instance, - MonoString* machine, int *type, MonoBoolean *custom) MONO_INTERNAL; + MonoString* machine, int *type, MonoBoolean *custom); -MonoBoolean mono_perfcounter_get_sample (void *impl, MonoBoolean only_value, MonoCounterSample *sample) MONO_INTERNAL; +MonoBoolean mono_perfcounter_get_sample (void *impl, MonoBoolean only_value, MonoCounterSample *sample); -gint64 mono_perfcounter_update_value (void *impl, MonoBoolean do_incr, gint64 value) MONO_INTERNAL; -void mono_perfcounter_free_data (void *impl) MONO_INTERNAL; +gint64 mono_perfcounter_update_value (void *impl, MonoBoolean do_incr, gint64 value); +void mono_perfcounter_free_data (void *impl); /* Category icalls */ -MonoBoolean mono_perfcounter_category_del (MonoString *name) MONO_INTERNAL; -MonoString* mono_perfcounter_category_help (MonoString *category, MonoString *machine) MONO_INTERNAL; -MonoBoolean mono_perfcounter_category_exists (MonoString *counter, MonoString *category, MonoString *machine) MONO_INTERNAL; -MonoBoolean mono_perfcounter_create (MonoString *category, MonoString *help, int type, MonoArray *items) MONO_INTERNAL; -int mono_perfcounter_instance_exists (MonoString *instance, MonoString *category, MonoString *machine) MONO_INTERNAL; -MonoArray* mono_perfcounter_category_names (MonoString *machine) MONO_INTERNAL; -MonoArray* mono_perfcounter_counter_names (MonoString *category, MonoString *machine) MONO_INTERNAL; -MonoArray* mono_perfcounter_instance_names (MonoString *category, MonoString *machine) MONO_INTERNAL; +MonoBoolean mono_perfcounter_category_del (MonoString *name); +MonoString* mono_perfcounter_category_help (MonoString *category, MonoString *machine); +MonoBoolean mono_perfcounter_category_exists (MonoString *counter, MonoString *category, MonoString *machine); +MonoBoolean mono_perfcounter_create (MonoString *category, MonoString *help, int type, MonoArray *items); +int mono_perfcounter_instance_exists (MonoString *instance, MonoString *category, MonoString *machine); +MonoArray* mono_perfcounter_category_names (MonoString *machine); +MonoArray* mono_perfcounter_counter_names (MonoString *category, MonoString *machine); +MonoArray* mono_perfcounter_instance_names (MonoString *category, MonoString *machine); typedef gboolean (*PerfCounterEnumCallback) (char *category_name, char *name, unsigned char type, gint64 value, gpointer user_data); MONO_API void mono_perfcounter_foreach (PerfCounterEnumCallback cb, gpointer user_data); diff --git a/mono/metadata/mono-route.h b/mono/metadata/mono-route.h index 8f7cf73c6c1..333a24367ad 100644 --- a/mono/metadata/mono-route.h +++ b/mono/metadata/mono-route.h @@ -14,10 +14,10 @@ #include -in_addr_t gateway_from_rtm (struct rt_msghdr *rtm) MONO_INTERNAL; +in_addr_t gateway_from_rtm (struct rt_msghdr *rtm); /* Category icalls */ -extern MonoBoolean ves_icall_System_Net_NetworkInformation_MacOsIPInterfaceProperties_ParseRouteInfo_internal (MonoString *iface, MonoArray **gw_addr_list) MONO_INTERNAL; +extern MonoBoolean ves_icall_System_Net_NetworkInformation_MacOsIPInterfaceProperties_ParseRouteInfo_internal (MonoString *iface, MonoArray **gw_addr_list); #endif /* #if defined(PLATFORM_MACOSX) || defined(PLATFORM_BSD) */ #endif /* __MONO_ROUTE_H__ */ diff --git a/mono/metadata/mono-wsq.h b/mono/metadata/mono-wsq.h index ccb064d4f18..3550013359d 100644 --- a/mono/metadata/mono-wsq.h +++ b/mono/metadata/mono-wsq.h @@ -11,16 +11,16 @@ G_BEGIN_DECLS typedef struct _MonoWSQ MonoWSQ; -void mono_wsq_init (void) MONO_INTERNAL; -void mono_wsq_cleanup (void) MONO_INTERNAL; +void mono_wsq_init (void); +void mono_wsq_cleanup (void); -MonoWSQ *mono_wsq_create (void) MONO_INTERNAL; -void mono_wsq_destroy (MonoWSQ *wsq) MONO_INTERNAL; -gboolean mono_wsq_local_push (void *obj) MONO_INTERNAL; -gboolean mono_wsq_local_pop (void **ptr) MONO_INTERNAL; -void mono_wsq_try_steal (MonoWSQ *wsq, void **ptr, guint32 ms_timeout) MONO_INTERNAL; -gint mono_wsq_count (MonoWSQ *wsq) MONO_INTERNAL; -gboolean mono_wsq_suspend (MonoWSQ *wsq) MONO_INTERNAL; +MonoWSQ *mono_wsq_create (void); +void mono_wsq_destroy (MonoWSQ *wsq); +gboolean mono_wsq_local_push (void *obj); +gboolean mono_wsq_local_pop (void **ptr); +void mono_wsq_try_steal (MonoWSQ *wsq, void **ptr, guint32 ms_timeout); +gint mono_wsq_count (MonoWSQ *wsq); +gboolean mono_wsq_suspend (MonoWSQ *wsq); G_END_DECLS diff --git a/mono/metadata/object-internals.h b/mono/metadata/object-internals.h index a1844325dbb..9b4899c127a 100644 --- a/mono/metadata/object-internals.h +++ b/mono/metadata/object-internals.h @@ -629,91 +629,91 @@ typedef void (*MonoFreeMethodFunc) (MonoDomain *domain, MonoMethod *meth /* Used to initialize the method pointers inside vtables */ typedef gboolean (*MonoInitVTableFunc) (MonoVTable *vtable); -MONO_COLD void mono_set_pending_exception (MonoException *exc) MONO_INTERNAL; +MONO_COLD void mono_set_pending_exception (MonoException *exc); /* remoting and async support */ MonoAsyncResult * mono_async_result_new (MonoDomain *domain, HANDLE handle, - MonoObject *state, gpointer data, MonoObject *object_data) MONO_INTERNAL; + MonoObject *state, gpointer data, MonoObject *object_data); MonoWaitHandle * -mono_wait_handle_new (MonoDomain *domain, HANDLE handle) MONO_INTERNAL; +mono_wait_handle_new (MonoDomain *domain, HANDLE handle); HANDLE -mono_wait_handle_get_handle (MonoWaitHandle *handle) MONO_INTERNAL; +mono_wait_handle_get_handle (MonoWaitHandle *handle); void mono_message_init (MonoDomain *domain, MonoMethodMessage *this_obj, - MonoReflectionMethod *method, MonoArray *out_args) MONO_INTERNAL; + MonoReflectionMethod *method, MonoArray *out_args); MonoObject * mono_message_invoke (MonoObject *target, MonoMethodMessage *msg, - MonoObject **exc, MonoArray **out_args) MONO_INTERNAL; + MonoObject **exc, MonoArray **out_args); MonoMethodMessage * mono_method_call_message_new (MonoMethod *method, gpointer *params, MonoMethod *invoke, - MonoDelegate **cb, MonoObject **state) MONO_INTERNAL; + MonoDelegate **cb, MonoObject **state); void -mono_method_return_message_restore (MonoMethod *method, gpointer *params, MonoArray *out_args) MONO_INTERNAL; +mono_method_return_message_restore (MonoMethod *method, gpointer *params, MonoArray *out_args); void -mono_delegate_ctor_with_method (MonoObject *this_obj, MonoObject *target, gpointer addr, MonoMethod *method) MONO_INTERNAL; +mono_delegate_ctor_with_method (MonoObject *this_obj, MonoObject *target, gpointer addr, MonoMethod *method); void -mono_delegate_ctor (MonoObject *this_obj, MonoObject *target, gpointer addr) MONO_INTERNAL; +mono_delegate_ctor (MonoObject *this_obj, MonoObject *target, gpointer addr); void* -mono_class_get_allocation_ftn (MonoVTable *vtable, gboolean for_box, gboolean *pass_size_in_words) MONO_INTERNAL; +mono_class_get_allocation_ftn (MonoVTable *vtable, gboolean for_box, gboolean *pass_size_in_words); void -mono_runtime_free_method (MonoDomain *domain, MonoMethod *method) MONO_INTERNAL; +mono_runtime_free_method (MonoDomain *domain, MonoMethod *method); void -mono_install_runtime_invoke (MonoInvokeFunc func) MONO_INTERNAL; +mono_install_runtime_invoke (MonoInvokeFunc func); void -mono_install_compile_method (MonoCompileFunc func) MONO_INTERNAL; +mono_install_compile_method (MonoCompileFunc func); void -mono_install_free_method (MonoFreeMethodFunc func) MONO_INTERNAL; +mono_install_free_method (MonoFreeMethodFunc func); void -mono_install_callbacks (MonoRuntimeCallbacks *cbs) MONO_INTERNAL; +mono_install_callbacks (MonoRuntimeCallbacks *cbs); MonoRuntimeCallbacks* -mono_get_runtime_callbacks (void) MONO_INTERNAL; +mono_get_runtime_callbacks (void); void -mono_install_eh_callbacks (MonoRuntimeExceptionHandlingCallbacks *cbs) MONO_INTERNAL; +mono_install_eh_callbacks (MonoRuntimeExceptionHandlingCallbacks *cbs); MonoRuntimeExceptionHandlingCallbacks * -mono_get_eh_callbacks (void) MONO_INTERNAL; +mono_get_eh_callbacks (void); void -mono_raise_exception_with_context (MonoException *ex, MonoContext *ctx) MONO_INTERNAL; +mono_raise_exception_with_context (MonoException *ex, MonoContext *ctx); void -mono_type_initialization_init (void) MONO_INTERNAL; +mono_type_initialization_init (void); void -mono_type_initialization_cleanup (void) MONO_INTERNAL; +mono_type_initialization_cleanup (void); int -mono_thread_kill (MonoInternalThread *thread, int signal) MONO_INTERNAL; +mono_thread_kill (MonoInternalThread *thread, int signal); MonoNativeTlsKey -mono_thread_get_tls_key (void) MONO_INTERNAL; +mono_thread_get_tls_key (void); gint32 -mono_thread_get_tls_offset (void) MONO_INTERNAL; +mono_thread_get_tls_offset (void); MonoNativeTlsKey -mono_domain_get_tls_key (void) MONO_INTERNAL; +mono_domain_get_tls_key (void); gint32 -mono_domain_get_tls_offset (void) MONO_INTERNAL; +mono_domain_get_tls_offset (void); /* Reflection and Reflection.Emit support */ @@ -1393,126 +1393,126 @@ typedef struct { MonoProperty *prop; } CattrNamedArg; -void mono_image_create_pefile (MonoReflectionModuleBuilder *module, HANDLE file) MONO_INTERNAL; -void mono_image_basic_init (MonoReflectionAssemblyBuilder *assembly) MONO_INTERNAL; -MonoReflectionModule * mono_image_load_module_dynamic (MonoReflectionAssemblyBuilder *assembly, MonoString *file_name) MONO_INTERNAL; -guint32 mono_image_insert_string (MonoReflectionModuleBuilder *module, MonoString *str) MONO_INTERNAL; -guint32 mono_image_create_token (MonoDynamicImage *assembly, MonoObject *obj, gboolean create_methodspec, gboolean register_token) MONO_INTERNAL; -guint32 mono_image_create_method_token (MonoDynamicImage *assembly, MonoObject *obj, MonoArray *opt_param_types) MONO_INTERNAL; -void mono_image_module_basic_init (MonoReflectionModuleBuilder *module) MONO_INTERNAL; -void mono_image_register_token (MonoDynamicImage *assembly, guint32 token, MonoObject *obj) MONO_INTERNAL; -void mono_dynamic_image_free (MonoDynamicImage *image) MONO_INTERNAL; -void mono_dynamic_image_free_image (MonoDynamicImage *image) MONO_INTERNAL; -void mono_image_set_wrappers_type (MonoReflectionModuleBuilder *mb, MonoReflectionType *type) MONO_INTERNAL; -void mono_dynamic_image_release_gc_roots (MonoDynamicImage *image) MONO_INTERNAL; +void mono_image_create_pefile (MonoReflectionModuleBuilder *module, HANDLE file); +void mono_image_basic_init (MonoReflectionAssemblyBuilder *assembly); +MonoReflectionModule * mono_image_load_module_dynamic (MonoReflectionAssemblyBuilder *assembly, MonoString *file_name); +guint32 mono_image_insert_string (MonoReflectionModuleBuilder *module, MonoString *str); +guint32 mono_image_create_token (MonoDynamicImage *assembly, MonoObject *obj, gboolean create_methodspec, gboolean register_token); +guint32 mono_image_create_method_token (MonoDynamicImage *assembly, MonoObject *obj, MonoArray *opt_param_types); +void mono_image_module_basic_init (MonoReflectionModuleBuilder *module); +void mono_image_register_token (MonoDynamicImage *assembly, guint32 token, MonoObject *obj); +void mono_dynamic_image_free (MonoDynamicImage *image); +void mono_dynamic_image_free_image (MonoDynamicImage *image); +void mono_image_set_wrappers_type (MonoReflectionModuleBuilder *mb, MonoReflectionType *type); +void mono_dynamic_image_release_gc_roots (MonoDynamicImage *image); -void mono_reflection_setup_internal_class (MonoReflectionTypeBuilder *tb) MONO_INTERNAL; +void mono_reflection_setup_internal_class (MonoReflectionTypeBuilder *tb); -void mono_reflection_create_internal_class (MonoReflectionTypeBuilder *tb) MONO_INTERNAL; +void mono_reflection_create_internal_class (MonoReflectionTypeBuilder *tb); -void mono_reflection_setup_generic_class (MonoReflectionTypeBuilder *tb) MONO_INTERNAL; +void mono_reflection_setup_generic_class (MonoReflectionTypeBuilder *tb); -void mono_reflection_create_generic_class (MonoReflectionTypeBuilder *tb) MONO_INTERNAL; +void mono_reflection_create_generic_class (MonoReflectionTypeBuilder *tb); -MonoReflectionType* mono_reflection_create_runtime_class (MonoReflectionTypeBuilder *tb) MONO_INTERNAL; +MonoReflectionType* mono_reflection_create_runtime_class (MonoReflectionTypeBuilder *tb); -void mono_reflection_get_dynamic_overrides (MonoClass *klass, MonoMethod ***overrides, int *num_overrides) MONO_INTERNAL; +void mono_reflection_get_dynamic_overrides (MonoClass *klass, MonoMethod ***overrides, int *num_overrides); -void mono_reflection_create_dynamic_method (MonoReflectionDynamicMethod *m) MONO_INTERNAL; -void mono_reflection_destroy_dynamic_method (MonoReflectionDynamicMethod *mb) MONO_INTERNAL; +void mono_reflection_create_dynamic_method (MonoReflectionDynamicMethod *m); +void mono_reflection_destroy_dynamic_method (MonoReflectionDynamicMethod *mb); -void mono_reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam) MONO_INTERNAL; -void mono_reflection_create_unmanaged_type (MonoReflectionType *type) MONO_INTERNAL; -void mono_reflection_register_with_runtime (MonoReflectionType *type) MONO_INTERNAL; +void mono_reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam); +void mono_reflection_create_unmanaged_type (MonoReflectionType *type); +void mono_reflection_register_with_runtime (MonoReflectionType *type); -void mono_reflection_create_custom_attr_data_args (MonoImage *image, MonoMethod *method, const guchar *data, guint32 len, MonoArray **typed_args, MonoArray **named_args, CattrNamedArg **named_arg_info, MonoError *error) MONO_INTERNAL; -MonoMethodSignature * mono_reflection_lookup_signature (MonoImage *image, MonoMethod *method, guint32 token, MonoError *error) MONO_INTERNAL; +void mono_reflection_create_custom_attr_data_args (MonoImage *image, MonoMethod *method, const guchar *data, guint32 len, MonoArray **typed_args, MonoArray **named_args, CattrNamedArg **named_arg_info, MonoError *error); +MonoMethodSignature * mono_reflection_lookup_signature (MonoImage *image, MonoMethod *method, guint32 token, MonoError *error); -MonoArray* mono_param_get_objects_internal (MonoDomain *domain, MonoMethod *method, MonoClass *refclass) MONO_INTERNAL; +MonoArray* mono_param_get_objects_internal (MonoDomain *domain, MonoMethod *method, MonoClass *refclass); MonoClass* -mono_class_bind_generic_parameters (MonoClass *klass, int type_argc, MonoType **types, gboolean is_dynamic) MONO_INTERNAL; +mono_class_bind_generic_parameters (MonoClass *klass, int type_argc, MonoType **types, gboolean is_dynamic); MonoType* -mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_argc, MonoType **types) MONO_INTERNAL; +mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_argc, MonoType **types); MonoReflectionMethod* -mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *method, MonoArray *types) MONO_INTERNAL; +mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *method, MonoArray *types); void -mono_reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoArray *fields) MONO_INTERNAL; +mono_reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoArray *fields); MonoReflectionEvent * -mono_reflection_event_builder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb) MONO_INTERNAL; +mono_reflection_event_builder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb); -MonoArray *mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig) MONO_INTERNAL; +MonoArray *mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig); -MonoArray *mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig) MONO_INTERNAL; +MonoArray *mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig); -MonoReflectionMarshalAsAttribute* mono_reflection_marshal_as_attribute_from_marshal_spec (MonoDomain *domain, MonoClass *klass, MonoMarshalSpec *spec) MONO_INTERNAL; +MonoReflectionMarshalAsAttribute* mono_reflection_marshal_as_attribute_from_marshal_spec (MonoDomain *domain, MonoClass *klass, MonoMarshalSpec *spec); gpointer -mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token, gboolean valid_token, MonoClass **handle_class, MonoGenericContext *context) MONO_INTERNAL; +mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token, gboolean valid_token, MonoClass **handle_class, MonoGenericContext *context); gboolean -mono_reflection_call_is_assignable_to (MonoClass *klass, MonoClass *oklass) MONO_INTERNAL; +mono_reflection_call_is_assignable_to (MonoClass *klass, MonoClass *oklass); gboolean -mono_reflection_is_valid_dynamic_token (MonoDynamicImage *image, guint32 token) MONO_INTERNAL; +mono_reflection_is_valid_dynamic_token (MonoDynamicImage *image, guint32 token); void -mono_reflection_resolve_custom_attribute_data (MonoReflectionMethod *method, MonoReflectionAssembly *assembly, gpointer data, guint32 data_length, MonoArray **ctor_args, MonoArray ** named_args) MONO_INTERNAL; +mono_reflection_resolve_custom_attribute_data (MonoReflectionMethod *method, MonoReflectionAssembly *assembly, gpointer data, guint32 data_length, MonoArray **ctor_args, MonoArray ** named_args); MonoType* -mono_reflection_type_get_handle (MonoReflectionType *ref) MONO_INTERNAL; +mono_reflection_type_get_handle (MonoReflectionType *ref); void -mono_reflection_free_dynamic_generic_class (MonoGenericClass *gclass) MONO_INTERNAL; +mono_reflection_free_dynamic_generic_class (MonoGenericClass *gclass); void -mono_image_build_metadata (MonoReflectionModuleBuilder *module) MONO_INTERNAL; +mono_image_build_metadata (MonoReflectionModuleBuilder *module); int -mono_get_constant_value_from_blob (MonoDomain* domain, MonoTypeEnum type, const char *blob, void *value) MONO_INTERNAL; +mono_get_constant_value_from_blob (MonoDomain* domain, MonoTypeEnum type, const char *blob, void *value); void -mono_release_type_locks (MonoInternalThread *thread) MONO_INTERNAL; +mono_release_type_locks (MonoInternalThread *thread); char * -mono_string_to_utf8_mp (MonoMemPool *mp, MonoString *s, MonoError *error) MONO_INTERNAL; +mono_string_to_utf8_mp (MonoMemPool *mp, MonoString *s, MonoError *error); char * -mono_string_to_utf8_image (MonoImage *image, MonoString *s, MonoError *error) MONO_INTERNAL; +mono_string_to_utf8_image (MonoImage *image, MonoString *s, MonoError *error); MonoArray* -mono_array_clone_in_domain (MonoDomain *domain, MonoArray *array) MONO_INTERNAL; +mono_array_clone_in_domain (MonoDomain *domain, MonoArray *array); void -mono_array_full_copy (MonoArray *src, MonoArray *dest) MONO_INTERNAL; +mono_array_full_copy (MonoArray *src, MonoArray *dest); gboolean -mono_array_calc_byte_len (MonoClass *klass, uintptr_t len, uintptr_t *res) MONO_INTERNAL; +mono_array_calc_byte_len (MonoClass *klass, uintptr_t len, uintptr_t *res); #ifndef DISABLE_REMOTING MonoObject * mono_remoting_invoke (MonoObject *real_proxy, MonoMethodMessage *msg, - MonoObject **exc, MonoArray **out_args) MONO_INTERNAL; + MonoObject **exc, MonoArray **out_args); gpointer -mono_remote_class_vtable (MonoDomain *domain, MonoRemoteClass *remote_class, MonoRealProxy *real_proxy) MONO_INTERNAL; +mono_remote_class_vtable (MonoDomain *domain, MonoRemoteClass *remote_class, MonoRealProxy *real_proxy); void -mono_upgrade_remote_class (MonoDomain *domain, MonoObject *tproxy, MonoClass *klass) MONO_INTERNAL; +mono_upgrade_remote_class (MonoDomain *domain, MonoObject *tproxy, MonoClass *klass); #endif gpointer -mono_create_ftnptr (MonoDomain *domain, gpointer addr) MONO_INTERNAL; +mono_create_ftnptr (MonoDomain *domain, gpointer addr); gpointer -mono_get_addr_from_ftnptr (gpointer descr) MONO_INTERNAL; +mono_get_addr_from_ftnptr (gpointer descr); void -mono_nullable_init (guint8 *buf, MonoObject *value, MonoClass *klass) MONO_INTERNAL; +mono_nullable_init (guint8 *buf, MonoObject *value, MonoClass *klass); MonoObject* -mono_nullable_box (guint8 *buf, MonoClass *klass) MONO_INTERNAL; +mono_nullable_box (guint8 *buf, MonoClass *klass); #ifdef MONO_SMALL_CONFIG #define MONO_IMT_SIZE 9 @@ -1552,21 +1552,21 @@ typedef gpointer (*MonoImtThunkBuilder) (MonoVTable *vtable, MonoDomain *domain, MonoIMTCheckItem **imt_entries, int count, gpointer fail_trunk); void -mono_install_imt_thunk_builder (MonoImtThunkBuilder func) MONO_INTERNAL; +mono_install_imt_thunk_builder (MonoImtThunkBuilder func); void -mono_vtable_build_imt_slot (MonoVTable* vtable, int imt_slot) MONO_INTERNAL; +mono_vtable_build_imt_slot (MonoVTable* vtable, int imt_slot); guint32 -mono_method_get_imt_slot (MonoMethod *method) MONO_INTERNAL; +mono_method_get_imt_slot (MonoMethod *method); void mono_method_add_generic_virtual_invocation (MonoDomain *domain, MonoVTable *vtable, gpointer *vtable_slot, - MonoMethod *method, gpointer code) MONO_INTERNAL; + MonoMethod *method, gpointer code); gpointer -mono_method_alloc_generic_virtual_thunk (MonoDomain *domain, int size) MONO_INTERNAL; +mono_method_alloc_generic_virtual_thunk (MonoDomain *domain, int size); typedef enum { MONO_UNHANDLED_POLICY_LEGACY, @@ -1574,73 +1574,73 @@ typedef enum { } MonoRuntimeUnhandledExceptionPolicy; MonoRuntimeUnhandledExceptionPolicy -mono_runtime_unhandled_exception_policy_get (void) MONO_INTERNAL; +mono_runtime_unhandled_exception_policy_get (void); void -mono_runtime_unhandled_exception_policy_set (MonoRuntimeUnhandledExceptionPolicy policy) MONO_INTERNAL; +mono_runtime_unhandled_exception_policy_set (MonoRuntimeUnhandledExceptionPolicy policy); MonoVTable * -mono_class_try_get_vtable (MonoDomain *domain, MonoClass *klass) MONO_INTERNAL; +mono_class_try_get_vtable (MonoDomain *domain, MonoClass *klass); MonoException * -mono_runtime_class_init_full (MonoVTable *vtable, gboolean raise_exception) MONO_INTERNAL; +mono_runtime_class_init_full (MonoVTable *vtable, gboolean raise_exception); void -mono_method_clear_object (MonoDomain *domain, MonoMethod *method) MONO_INTERNAL; +mono_method_clear_object (MonoDomain *domain, MonoMethod *method); void -mono_class_compute_gc_descriptor (MonoClass *klass) MONO_INTERNAL; +mono_class_compute_gc_descriptor (MonoClass *klass); gsize* -mono_class_compute_bitmap (MonoClass *klass, gsize *bitmap, int size, int offset, int *max_set, gboolean static_fields) MONO_INTERNAL; +mono_class_compute_bitmap (MonoClass *klass, gsize *bitmap, int size, int offset, int *max_set, gboolean static_fields); MonoObject* -mono_object_xdomain_representation (MonoObject *obj, MonoDomain *target_domain, MonoObject **exc) MONO_INTERNAL; +mono_object_xdomain_representation (MonoObject *obj, MonoDomain *target_domain, MonoObject **exc); gboolean -mono_class_is_reflection_method_or_constructor (MonoClass *klass) MONO_INTERNAL; +mono_class_is_reflection_method_or_constructor (MonoClass *klass); MonoObject * -mono_get_object_from_blob (MonoDomain *domain, MonoType *type, const char *blob) MONO_INTERNAL; +mono_get_object_from_blob (MonoDomain *domain, MonoType *type, const char *blob); gpointer -mono_class_get_ref_info (MonoClass *klass) MONO_INTERNAL; +mono_class_get_ref_info (MonoClass *klass); void -mono_class_set_ref_info (MonoClass *klass, gpointer obj) MONO_INTERNAL; +mono_class_set_ref_info (MonoClass *klass, gpointer obj); void -mono_class_free_ref_info (MonoClass *klass) MONO_INTERNAL; +mono_class_free_ref_info (MonoClass *klass); MonoObject * -mono_object_new_pinned (MonoDomain *domain, MonoClass *klass) MONO_INTERNAL; +mono_object_new_pinned (MonoDomain *domain, MonoClass *klass); void -mono_field_static_get_value_for_thread (MonoInternalThread *thread, MonoVTable *vt, MonoClassField *field, void *value) MONO_INTERNAL; +mono_field_static_get_value_for_thread (MonoInternalThread *thread, MonoVTable *vt, MonoClassField *field, void *value); /* exported, used by the debugger */ MONO_API void * mono_vtable_get_static_field_data (MonoVTable *vt); char * -mono_string_to_utf8_ignore (MonoString *s) MONO_INTERNAL; +mono_string_to_utf8_ignore (MonoString *s); char * -mono_string_to_utf8_image_ignore (MonoImage *image, MonoString *s) MONO_INTERNAL; +mono_string_to_utf8_image_ignore (MonoImage *image, MonoString *s); char * -mono_string_to_utf8_mp_ignore (MonoMemPool *mp, MonoString *s) MONO_INTERNAL; +mono_string_to_utf8_mp_ignore (MonoMemPool *mp, MonoString *s); gboolean -mono_monitor_is_il_fastpath_wrapper (MonoMethod *method) MONO_INTERNAL; +mono_monitor_is_il_fastpath_wrapper (MonoMethod *method); char * -mono_exception_get_native_backtrace (MonoException *exc) MONO_INTERNAL; +mono_exception_get_native_backtrace (MonoException *exc); MonoString * -ves_icall_Mono_Runtime_GetNativeStackTrace (MonoException *exc) MONO_INTERNAL; +ves_icall_Mono_Runtime_GetNativeStackTrace (MonoException *exc); char * -mono_exception_get_managed_backtrace (MonoException *exc) MONO_INTERNAL; +mono_exception_get_managed_backtrace (MonoException *exc); #endif /* __MONO_OBJECT_INTERNALS_H__ */ diff --git a/mono/metadata/process.h b/mono/metadata/process.h index 96ea93b888d..39247874b0f 100644 --- a/mono/metadata/process.h +++ b/mono/metadata/process.h @@ -57,27 +57,27 @@ typedef struct G_BEGIN_DECLS -HANDLE ves_icall_System_Diagnostics_Process_GetProcess_internal (guint32 pid) MONO_INTERNAL; -MonoArray *ves_icall_System_Diagnostics_Process_GetProcesses_internal (void) MONO_INTERNAL; -guint32 ves_icall_System_Diagnostics_Process_GetPid_internal (void) MONO_INTERNAL; -void ves_icall_System_Diagnostics_Process_Process_free_internal (MonoObject *this_obj, HANDLE process) MONO_INTERNAL; -MonoArray *ves_icall_System_Diagnostics_Process_GetModules_internal (MonoObject *this_obj, HANDLE process) MONO_INTERNAL; -void ves_icall_System_Diagnostics_FileVersionInfo_GetVersionInfo_internal (MonoObject *this_obj, MonoString *filename) MONO_INTERNAL; -MonoBoolean ves_icall_System_Diagnostics_Process_ShellExecuteEx_internal (MonoProcessStartInfo *proc_start_info, MonoProcInfo *process_handle) MONO_INTERNAL; -MonoBoolean ves_icall_System_Diagnostics_Process_CreateProcess_internal (MonoProcessStartInfo *proc_start_info, HANDLE stdin_handle, HANDLE stdout_handle, HANDLE stderr_handle, MonoProcInfo *process_handle) MONO_INTERNAL; -MonoBoolean ves_icall_System_Diagnostics_Process_WaitForExit_internal (MonoObject *this_obj, HANDLE process, gint32 ms) MONO_INTERNAL; -MonoBoolean ves_icall_System_Diagnostics_Process_WaitForInputIdle_internal (MonoObject *this_obj, HANDLE process, gint32 ms) MONO_INTERNAL; -gint64 ves_icall_System_Diagnostics_Process_ExitTime_internal (HANDLE process) MONO_INTERNAL; -gint64 ves_icall_System_Diagnostics_Process_StartTime_internal (HANDLE process) MONO_INTERNAL; -gint32 ves_icall_System_Diagnostics_Process_ExitCode_internal (HANDLE process) MONO_INTERNAL; -MonoString *ves_icall_System_Diagnostics_Process_ProcessName_internal (HANDLE process) MONO_INTERNAL; -MonoBoolean ves_icall_System_Diagnostics_Process_GetWorkingSet_internal (HANDLE process, guint32 *min, guint32 *max) MONO_INTERNAL; -MonoBoolean ves_icall_System_Diagnostics_Process_SetWorkingSet_internal (HANDLE process, guint32 min, guint32 max, MonoBoolean use_min) MONO_INTERNAL; -MonoBoolean ves_icall_System_Diagnostics_Process_Kill_internal (HANDLE process, gint32 sig) MONO_INTERNAL; -gint64 ves_icall_System_Diagnostics_Process_Times (HANDLE process, gint32 type) MONO_INTERNAL; -gint32 ves_icall_System_Diagnostics_Process_GetPriorityClass (HANDLE process, gint32 *error) MONO_INTERNAL; -MonoBoolean ves_icall_System_Diagnostics_Process_SetPriorityClass (HANDLE process, gint32 priority_class, gint32 *error) MONO_INTERNAL; -gint64 ves_icall_System_Diagnostics_Process_GetProcessData (int pid, gint32 data_type, gint32 *error) MONO_INTERNAL; +HANDLE ves_icall_System_Diagnostics_Process_GetProcess_internal (guint32 pid); +MonoArray *ves_icall_System_Diagnostics_Process_GetProcesses_internal (void); +guint32 ves_icall_System_Diagnostics_Process_GetPid_internal (void); +void ves_icall_System_Diagnostics_Process_Process_free_internal (MonoObject *this_obj, HANDLE process); +MonoArray *ves_icall_System_Diagnostics_Process_GetModules_internal (MonoObject *this_obj, HANDLE process); +void ves_icall_System_Diagnostics_FileVersionInfo_GetVersionInfo_internal (MonoObject *this_obj, MonoString *filename); +MonoBoolean ves_icall_System_Diagnostics_Process_ShellExecuteEx_internal (MonoProcessStartInfo *proc_start_info, MonoProcInfo *process_handle); +MonoBoolean ves_icall_System_Diagnostics_Process_CreateProcess_internal (MonoProcessStartInfo *proc_start_info, HANDLE stdin_handle, HANDLE stdout_handle, HANDLE stderr_handle, MonoProcInfo *process_handle); +MonoBoolean ves_icall_System_Diagnostics_Process_WaitForExit_internal (MonoObject *this_obj, HANDLE process, gint32 ms); +MonoBoolean ves_icall_System_Diagnostics_Process_WaitForInputIdle_internal (MonoObject *this_obj, HANDLE process, gint32 ms); +gint64 ves_icall_System_Diagnostics_Process_ExitTime_internal (HANDLE process); +gint64 ves_icall_System_Diagnostics_Process_StartTime_internal (HANDLE process); +gint32 ves_icall_System_Diagnostics_Process_ExitCode_internal (HANDLE process); +MonoString *ves_icall_System_Diagnostics_Process_ProcessName_internal (HANDLE process); +MonoBoolean ves_icall_System_Diagnostics_Process_GetWorkingSet_internal (HANDLE process, guint32 *min, guint32 *max); +MonoBoolean ves_icall_System_Diagnostics_Process_SetWorkingSet_internal (HANDLE process, guint32 min, guint32 max, MonoBoolean use_min); +MonoBoolean ves_icall_System_Diagnostics_Process_Kill_internal (HANDLE process, gint32 sig); +gint64 ves_icall_System_Diagnostics_Process_Times (HANDLE process, gint32 type); +gint32 ves_icall_System_Diagnostics_Process_GetPriorityClass (HANDLE process, gint32 *error); +MonoBoolean ves_icall_System_Diagnostics_Process_SetPriorityClass (HANDLE process, gint32 priority_class, gint32 *error); +gint64 ves_icall_System_Diagnostics_Process_GetProcessData (int pid, gint32 data_type, gint32 *error); HANDLE ves_icall_System_Diagnostics_Process_ProcessHandle_duplicate (HANDLE process); void ves_icall_System_Diagnostics_Process_ProcessHandle_close (HANDLE process); diff --git a/mono/metadata/profiler-private.h b/mono/metadata/profiler-private.h index fe26be49359..9bf9c7bb831 100644 --- a/mono/metadata/profiler-private.h +++ b/mono/metadata/profiler-private.h @@ -23,62 +23,62 @@ typedef struct { } data [1]; } MonoProfileCoverageInfo; -void mono_profiler_shutdown (void) MONO_INTERNAL; - -void mono_profiler_method_enter (MonoMethod *method) MONO_INTERNAL; -void mono_profiler_method_leave (MonoMethod *method) MONO_INTERNAL; -void mono_profiler_method_jit (MonoMethod *method) MONO_INTERNAL; -void mono_profiler_method_end_jit (MonoMethod *method, MonoJitInfo* jinfo, int result) MONO_INTERNAL; -void mono_profiler_method_free (MonoMethod *method) MONO_INTERNAL; -void mono_profiler_method_start_invoke (MonoMethod *method) MONO_INTERNAL; -void mono_profiler_method_end_invoke (MonoMethod *method) MONO_INTERNAL; - -void mono_profiler_code_transition (MonoMethod *method, int result) MONO_INTERNAL; -void mono_profiler_allocation (MonoObject *obj, MonoClass *klass) MONO_INTERNAL; -void mono_profiler_monitor_event (MonoObject *obj, MonoProfilerMonitorEvent event) MONO_INTERNAL; -void mono_profiler_stat_hit (guchar *ip, void *context) MONO_INTERNAL; -void mono_profiler_stat_call_chain (int call_chain_depth, guchar **ips, void *context) MONO_INTERNAL; -int mono_profiler_stat_get_call_chain_depth (void) MONO_INTERNAL; -MonoProfilerCallChainStrategy mono_profiler_stat_get_call_chain_strategy (void) MONO_INTERNAL; -void mono_profiler_thread_start (gsize tid) MONO_INTERNAL; -void mono_profiler_thread_end (gsize tid) MONO_INTERNAL; -void mono_profiler_thread_name (gsize tid, const char *name) MONO_INTERNAL; - -void mono_profiler_exception_thrown (MonoObject *exception) MONO_INTERNAL; -void mono_profiler_exception_method_leave (MonoMethod *method) MONO_INTERNAL; -void mono_profiler_exception_clause_handler (MonoMethod *method, int clause_type, int clause_num) MONO_INTERNAL; - -void mono_profiler_assembly_event (MonoAssembly *assembly, int code) MONO_INTERNAL; -void mono_profiler_assembly_loaded (MonoAssembly *assembly, int result) MONO_INTERNAL; - -void mono_profiler_module_event (MonoImage *image, int code) MONO_INTERNAL; -void mono_profiler_module_loaded (MonoImage *image, int result) MONO_INTERNAL; - -void mono_profiler_class_event (MonoClass *klass, int code) MONO_INTERNAL; -void mono_profiler_class_loaded (MonoClass *klass, int result) MONO_INTERNAL; - -void mono_profiler_appdomain_event (MonoDomain *domain, int code) MONO_INTERNAL; -void mono_profiler_appdomain_loaded (MonoDomain *domain, int result) MONO_INTERNAL; - -void mono_profiler_iomap (char *report, const char *pathname, const char *new_pathname) MONO_INTERNAL; - -MonoProfileCoverageInfo* mono_profiler_coverage_alloc (MonoMethod *method, int entries) MONO_INTERNAL; -void mono_profiler_coverage_free (MonoMethod *method) MONO_INTERNAL; - -void mono_profiler_gc_event (MonoGCEvent e, int generation) MONO_INTERNAL; -void mono_profiler_gc_heap_resize (gint64 new_size) MONO_INTERNAL; -void mono_profiler_gc_moves (void **objects, int num) MONO_INTERNAL; -void mono_profiler_gc_handle (int op, int type, uintptr_t handle, MonoObject *obj) MONO_INTERNAL; -void mono_profiler_gc_roots (int num, void **objects, int *root_types, uintptr_t *extra_info) MONO_INTERNAL; - -void mono_profiler_code_chunk_new (gpointer chunk, int size) MONO_INTERNAL; -void mono_profiler_code_chunk_destroy (gpointer chunk) MONO_INTERNAL; -void mono_profiler_code_buffer_new (gpointer buffer, int size, MonoProfilerCodeBufferType type, gconstpointer data) MONO_INTERNAL; - -void mono_profiler_runtime_initialized (void) MONO_INTERNAL; - -int64_t mono_profiler_get_sampling_rate (void) MONO_INTERNAL; -MonoProfileSamplingMode mono_profiler_get_sampling_mode (void) MONO_INTERNAL; +void mono_profiler_shutdown (void); + +void mono_profiler_method_enter (MonoMethod *method); +void mono_profiler_method_leave (MonoMethod *method); +void mono_profiler_method_jit (MonoMethod *method); +void mono_profiler_method_end_jit (MonoMethod *method, MonoJitInfo* jinfo, int result); +void mono_profiler_method_free (MonoMethod *method); +void mono_profiler_method_start_invoke (MonoMethod *method); +void mono_profiler_method_end_invoke (MonoMethod *method); + +void mono_profiler_code_transition (MonoMethod *method, int result); +void mono_profiler_allocation (MonoObject *obj, MonoClass *klass); +void mono_profiler_monitor_event (MonoObject *obj, MonoProfilerMonitorEvent event); +void mono_profiler_stat_hit (guchar *ip, void *context); +void mono_profiler_stat_call_chain (int call_chain_depth, guchar **ips, void *context); +int mono_profiler_stat_get_call_chain_depth (void); +MonoProfilerCallChainStrategy mono_profiler_stat_get_call_chain_strategy (void); +void mono_profiler_thread_start (gsize tid); +void mono_profiler_thread_end (gsize tid); +void mono_profiler_thread_name (gsize tid, const char *name); + +void mono_profiler_exception_thrown (MonoObject *exception); +void mono_profiler_exception_method_leave (MonoMethod *method); +void mono_profiler_exception_clause_handler (MonoMethod *method, int clause_type, int clause_num); + +void mono_profiler_assembly_event (MonoAssembly *assembly, int code); +void mono_profiler_assembly_loaded (MonoAssembly *assembly, int result); + +void mono_profiler_module_event (MonoImage *image, int code); +void mono_profiler_module_loaded (MonoImage *image, int result); + +void mono_profiler_class_event (MonoClass *klass, int code); +void mono_profiler_class_loaded (MonoClass *klass, int result); + +void mono_profiler_appdomain_event (MonoDomain *domain, int code); +void mono_profiler_appdomain_loaded (MonoDomain *domain, int result); + +void mono_profiler_iomap (char *report, const char *pathname, const char *new_pathname); + +MonoProfileCoverageInfo* mono_profiler_coverage_alloc (MonoMethod *method, int entries); +void mono_profiler_coverage_free (MonoMethod *method); + +void mono_profiler_gc_event (MonoGCEvent e, int generation); +void mono_profiler_gc_heap_resize (gint64 new_size); +void mono_profiler_gc_moves (void **objects, int num); +void mono_profiler_gc_handle (int op, int type, uintptr_t handle, MonoObject *obj); +void mono_profiler_gc_roots (int num, void **objects, int *root_types, uintptr_t *extra_info); + +void mono_profiler_code_chunk_new (gpointer chunk, int size); +void mono_profiler_code_chunk_destroy (gpointer chunk); +void mono_profiler_code_buffer_new (gpointer buffer, int size, MonoProfilerCodeBufferType type, gconstpointer data); + +void mono_profiler_runtime_initialized (void); + +int64_t mono_profiler_get_sampling_rate (void); +MonoProfileSamplingMode mono_profiler_get_sampling_mode (void); #endif /* __MONO_PROFILER_PRIVATE_H__ */ diff --git a/mono/metadata/rand.h b/mono/metadata/rand.h index 76864ca31cb..15af782fdc6 100644 --- a/mono/metadata/rand.h +++ b/mono/metadata/rand.h @@ -16,9 +16,9 @@ #include #include "mono/utils/mono-compiler.h" -MonoBoolean ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngOpen (void) MONO_INTERNAL; -gpointer ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngInitialize (MonoArray *seed) MONO_INTERNAL; -gpointer ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngGetBytes (gpointer handle, MonoArray *arry) MONO_INTERNAL; -void ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngClose (gpointer handle) MONO_INTERNAL; +MonoBoolean ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngOpen (void); +gpointer ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngInitialize (MonoArray *seed); +gpointer ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngGetBytes (gpointer handle, MonoArray *arry); +void ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngClose (gpointer handle); #endif diff --git a/mono/metadata/reflection-internals.h b/mono/metadata/reflection-internals.h index be3b1fd0d51..207241f49bc 100644 --- a/mono/metadata/reflection-internals.h +++ b/mono/metadata/reflection-internals.h @@ -9,6 +9,6 @@ #include MonoObject* -mono_custom_attrs_get_attr_checked (MonoCustomAttrInfo *ainfo, MonoClass *attr_klass, MonoError *error) MONO_INTERNAL; +mono_custom_attrs_get_attr_checked (MonoCustomAttrInfo *ainfo, MonoClass *attr_klass, MonoError *error); #endif diff --git a/mono/metadata/remoting.h b/mono/metadata/remoting.h index 24f4c802fc4..9b495b2fb59 100644 --- a/mono/metadata/remoting.h +++ b/mono/metadata/remoting.h @@ -13,39 +13,39 @@ #include #include -void mono_remoting_init (void) MONO_INTERNAL; +void mono_remoting_init (void); #ifndef DISABLE_REMOTING MonoMethod * -mono_marshal_get_remoting_invoke (MonoMethod *method) MONO_INTERNAL; +mono_marshal_get_remoting_invoke (MonoMethod *method); MonoMethod * -mono_marshal_get_xappdomain_invoke (MonoMethod *method) MONO_INTERNAL; +mono_marshal_get_xappdomain_invoke (MonoMethod *method); MonoMethod * -mono_marshal_get_remoting_invoke_for_target (MonoMethod *method, MonoRemotingTarget target_type) MONO_INTERNAL; +mono_marshal_get_remoting_invoke_for_target (MonoMethod *method, MonoRemotingTarget target_type); MonoMethod * -mono_marshal_get_remoting_invoke_with_check (MonoMethod *method) MONO_INTERNAL; +mono_marshal_get_remoting_invoke_with_check (MonoMethod *method); MonoMethod * -mono_marshal_get_stfld_wrapper (MonoType *type) MONO_INTERNAL; +mono_marshal_get_stfld_wrapper (MonoType *type); MonoMethod * -mono_marshal_get_ldfld_wrapper (MonoType *type) MONO_INTERNAL; +mono_marshal_get_ldfld_wrapper (MonoType *type); MonoMethod * -mono_marshal_get_ldflda_wrapper (MonoType *type) MONO_INTERNAL; +mono_marshal_get_ldflda_wrapper (MonoType *type); MonoMethod * -mono_marshal_get_ldfld_remote_wrapper (MonoClass *klass) MONO_INTERNAL; +mono_marshal_get_ldfld_remote_wrapper (MonoClass *klass); MonoMethod * -mono_marshal_get_stfld_remote_wrapper (MonoClass *klass) MONO_INTERNAL; +mono_marshal_get_stfld_remote_wrapper (MonoClass *klass); MonoMethod * -mono_marshal_get_proxy_cancast (MonoClass *klass) MONO_INTERNAL; +mono_marshal_get_proxy_cancast (MonoClass *klass); #endif diff --git a/mono/metadata/runtime.h b/mono/metadata/runtime.h index 42b8d7d3d77..ef14453ceb2 100644 --- a/mono/metadata/runtime.h +++ b/mono/metadata/runtime.h @@ -17,10 +17,10 @@ MONO_BEGIN_DECLS -gboolean mono_runtime_is_critical_method (MonoMethod *method) MONO_INTERNAL; -gboolean mono_runtime_try_shutdown (void) MONO_INTERNAL; +gboolean mono_runtime_is_critical_method (MonoMethod *method); +gboolean mono_runtime_try_shutdown (void); -void mono_runtime_init_tls (void) MONO_INTERNAL; +void mono_runtime_init_tls (void); MONO_END_DECLS #endif /* _MONO_METADATA_RUNTIME_H_ */ diff --git a/mono/metadata/security-core-clr.h b/mono/metadata/security-core-clr.h index 987f7459686..ca2039656e1 100644 --- a/mono/metadata/security-core-clr.h +++ b/mono/metadata/security-core-clr.h @@ -39,24 +39,24 @@ typedef enum { extern gboolean mono_security_core_clr_test; -extern void mono_security_core_clr_check_inheritance (MonoClass *klass) MONO_INTERNAL; -extern void mono_security_core_clr_check_override (MonoClass *klass, MonoMethod *override, MonoMethod *base) MONO_INTERNAL; +extern void mono_security_core_clr_check_inheritance (MonoClass *klass); +extern void mono_security_core_clr_check_override (MonoClass *klass, MonoMethod *override, MonoMethod *base); -extern void mono_security_core_clr_ensure_reflection_access_field (MonoClassField *field) MONO_INTERNAL; -extern void mono_security_core_clr_ensure_reflection_access_method (MonoMethod *method) MONO_INTERNAL; -extern gboolean mono_security_core_clr_ensure_delegate_creation (MonoMethod *method, gboolean throwOnBindFailure) MONO_INTERNAL; -extern MonoException* mono_security_core_clr_ensure_dynamic_method_resolved_object (gpointer ref, MonoClass *handle_class) MONO_INTERNAL; +extern void mono_security_core_clr_ensure_reflection_access_field (MonoClassField *field); +extern void mono_security_core_clr_ensure_reflection_access_method (MonoMethod *method); +extern gboolean mono_security_core_clr_ensure_delegate_creation (MonoMethod *method, gboolean throwOnBindFailure); +extern MonoException* mono_security_core_clr_ensure_dynamic_method_resolved_object (gpointer ref, MonoClass *handle_class); -extern gboolean mono_security_core_clr_can_access_internals (MonoImage *accessing, MonoImage* accessed) MONO_INTERNAL; +extern gboolean mono_security_core_clr_can_access_internals (MonoImage *accessing, MonoImage* accessed); -extern MonoException* mono_security_core_clr_is_field_access_allowed (MonoMethod *caller, MonoClassField *field) MONO_INTERNAL; -extern MonoException* mono_security_core_clr_is_call_allowed (MonoMethod *caller, MonoMethod *callee) MONO_INTERNAL; +extern MonoException* mono_security_core_clr_is_field_access_allowed (MonoMethod *caller, MonoClassField *field); +extern MonoException* mono_security_core_clr_is_call_allowed (MonoMethod *caller, MonoMethod *callee); -extern MonoSecurityCoreCLRLevel mono_security_core_clr_class_level (MonoClass *klass) MONO_INTERNAL; -extern MonoSecurityCoreCLRLevel mono_security_core_clr_method_level (MonoMethod *method, gboolean with_class_level) MONO_INTERNAL; +extern MonoSecurityCoreCLRLevel mono_security_core_clr_class_level (MonoClass *klass); +extern MonoSecurityCoreCLRLevel mono_security_core_clr_method_level (MonoMethod *method, gboolean with_class_level); -extern gboolean mono_security_core_clr_is_platform_image (MonoImage *image) MONO_INTERNAL; -extern gboolean mono_security_core_clr_determine_platform_image (MonoImage *image) MONO_INTERNAL; +extern gboolean mono_security_core_clr_is_platform_image (MonoImage *image); +extern gboolean mono_security_core_clr_determine_platform_image (MonoImage *image); extern MONO_API gboolean mono_security_core_clr_require_elevated_permissions (void); diff --git a/mono/metadata/security-manager.h b/mono/metadata/security-manager.h index 747f61723b3..dd2f17d5b27 100644 --- a/mono/metadata/security-manager.h +++ b/mono/metadata/security-manager.h @@ -63,27 +63,27 @@ typedef struct { MonoClass *suppressunmanagedcodesecurity; /* System.Security.SuppressUnmanagedCodeSecurityAttribute */ } MonoSecurityManager; -gboolean mono_is_ecma_key (const char *publickey, int size) MONO_INTERNAL; -MonoMethod* mono_get_context_capture_method (void) MONO_INTERNAL; +gboolean mono_is_ecma_key (const char *publickey, int size); +MonoMethod* mono_get_context_capture_method (void); -void mono_secman_inheritancedemand_class (MonoClass *klass, MonoClass *parent) MONO_INTERNAL; -void mono_secman_inheritancedemand_method (MonoMethod *override, MonoMethod *base) MONO_INTERNAL; +void mono_secman_inheritancedemand_class (MonoClass *klass, MonoClass *parent); +void mono_secman_inheritancedemand_method (MonoMethod *override, MonoMethod *base); /* Initialization/utility functions */ -void mono_activate_security_manager (void) MONO_INTERNAL; -MonoSecurityManager* mono_security_manager_get_methods (void) MONO_INTERNAL; +void mono_activate_security_manager (void); +MonoSecurityManager* mono_security_manager_get_methods (void); /* Security mode */ -gboolean mono_is_security_manager_active (void) MONO_INTERNAL; -void mono_security_set_mode (MonoSecurityMode mode) MONO_INTERNAL; -MonoSecurityMode mono_security_get_mode (void) MONO_INTERNAL; +gboolean mono_is_security_manager_active (void); +void mono_security_set_mode (MonoSecurityMode mode); +MonoSecurityMode mono_security_get_mode (void); /* internal calls */ -MonoBoolean ves_icall_System_Security_SecurityManager_get_SecurityEnabled (void) MONO_INTERNAL; -void ves_icall_System_Security_SecurityManager_set_SecurityEnabled (MonoBoolean value) MONO_INTERNAL; -MonoBoolean ves_icall_System_Security_SecurityManager_get_CheckExecutionRights (void) MONO_INTERNAL; -void ves_icall_System_Security_SecurityManager_set_CheckExecutionRights (MonoBoolean value) MONO_INTERNAL; -MonoBoolean ves_icall_System_Security_SecurityManager_GetLinkDemandSecurity (MonoReflectionMethod *m, MonoDeclSecurityActions *kactions, MonoDeclSecurityActions *mactions) MONO_INTERNAL; +MonoBoolean ves_icall_System_Security_SecurityManager_get_SecurityEnabled (void); +void ves_icall_System_Security_SecurityManager_set_SecurityEnabled (MonoBoolean value); +MonoBoolean ves_icall_System_Security_SecurityManager_get_CheckExecutionRights (void); +void ves_icall_System_Security_SecurityManager_set_CheckExecutionRights (MonoBoolean value); +MonoBoolean ves_icall_System_Security_SecurityManager_GetLinkDemandSecurity (MonoReflectionMethod *m, MonoDeclSecurityActions *kactions, MonoDeclSecurityActions *mactions); #ifndef DISABLE_SECURITY #define mono_security_enabled() (mono_is_security_manager_active ()) diff --git a/mono/metadata/security.h b/mono/metadata/security.h index f30f5e82e1c..d72d048661a 100644 --- a/mono/metadata/security.h +++ b/mono/metadata/security.h @@ -19,43 +19,43 @@ G_BEGIN_DECLS /* System.Environment */ -extern MonoString* ves_icall_System_Environment_get_UserName (void) MONO_INTERNAL; +extern MonoString* ves_icall_System_Environment_get_UserName (void); /* System.Security.Principal.WindowsIdentity */ -extern MonoArray* ves_icall_System_Security_Principal_WindowsIdentity_GetRoles (gpointer token) MONO_INTERNAL; -extern gpointer ves_icall_System_Security_Principal_WindowsIdentity_GetCurrentToken (void) MONO_INTERNAL; -extern MonoString* ves_icall_System_Security_Principal_WindowsIdentity_GetTokenName (gpointer token) MONO_INTERNAL; -extern gpointer ves_icall_System_Security_Principal_WindowsIdentity_GetUserToken (MonoString *username) MONO_INTERNAL; +extern MonoArray* ves_icall_System_Security_Principal_WindowsIdentity_GetRoles (gpointer token); +extern gpointer ves_icall_System_Security_Principal_WindowsIdentity_GetCurrentToken (void); +extern MonoString* ves_icall_System_Security_Principal_WindowsIdentity_GetTokenName (gpointer token); +extern gpointer ves_icall_System_Security_Principal_WindowsIdentity_GetUserToken (MonoString *username); /* System.Security.Principal.WindowsImpersonationContext */ -extern gboolean ves_icall_System_Security_Principal_WindowsImpersonationContext_CloseToken (gpointer token) MONO_INTERNAL; -extern gpointer ves_icall_System_Security_Principal_WindowsImpersonationContext_DuplicateToken (gpointer token) MONO_INTERNAL; -extern gboolean ves_icall_System_Security_Principal_WindowsImpersonationContext_SetCurrentToken (gpointer token) MONO_INTERNAL; -extern gboolean ves_icall_System_Security_Principal_WindowsImpersonationContext_RevertToSelf (void) MONO_INTERNAL; +extern gboolean ves_icall_System_Security_Principal_WindowsImpersonationContext_CloseToken (gpointer token); +extern gpointer ves_icall_System_Security_Principal_WindowsImpersonationContext_DuplicateToken (gpointer token); +extern gboolean ves_icall_System_Security_Principal_WindowsImpersonationContext_SetCurrentToken (gpointer token); +extern gboolean ves_icall_System_Security_Principal_WindowsImpersonationContext_RevertToSelf (void); /* System.Security.Principal.WindowsPrincipal */ -extern gboolean ves_icall_System_Security_Principal_WindowsPrincipal_IsMemberOfGroupId (gpointer user, gpointer group) MONO_INTERNAL; -extern gboolean ves_icall_System_Security_Principal_WindowsPrincipal_IsMemberOfGroupName (gpointer user, MonoString *group) MONO_INTERNAL; +extern gboolean ves_icall_System_Security_Principal_WindowsPrincipal_IsMemberOfGroupId (gpointer user, gpointer group); +extern gboolean ves_icall_System_Security_Principal_WindowsPrincipal_IsMemberOfGroupName (gpointer user, MonoString *group); /* Mono.Security.Cryptography.KeyPairPersistance */ -extern MonoBoolean ves_icall_Mono_Security_Cryptography_KeyPairPersistence_CanSecure (MonoString *root) MONO_INTERNAL; -extern MonoBoolean ves_icall_Mono_Security_Cryptography_KeyPairPersistence_IsMachineProtected (MonoString *path) MONO_INTERNAL; -extern MonoBoolean ves_icall_Mono_Security_Cryptography_KeyPairPersistence_IsUserProtected (MonoString *path) MONO_INTERNAL; -extern MonoBoolean ves_icall_Mono_Security_Cryptography_KeyPairPersistence_ProtectMachine (MonoString *path) MONO_INTERNAL; -extern MonoBoolean ves_icall_Mono_Security_Cryptography_KeyPairPersistence_ProtectUser (MonoString *path) MONO_INTERNAL; +extern MonoBoolean ves_icall_Mono_Security_Cryptography_KeyPairPersistence_CanSecure (MonoString *root); +extern MonoBoolean ves_icall_Mono_Security_Cryptography_KeyPairPersistence_IsMachineProtected (MonoString *path); +extern MonoBoolean ves_icall_Mono_Security_Cryptography_KeyPairPersistence_IsUserProtected (MonoString *path); +extern MonoBoolean ves_icall_Mono_Security_Cryptography_KeyPairPersistence_ProtectMachine (MonoString *path); +extern MonoBoolean ves_icall_Mono_Security_Cryptography_KeyPairPersistence_ProtectUser (MonoString *path); /* System.Security.Policy.Evidence */ -MonoBoolean ves_icall_System_Security_Policy_Evidence_IsAuthenticodePresent (MonoReflectionAssembly *refass) MONO_INTERNAL; +MonoBoolean ves_icall_System_Security_Policy_Evidence_IsAuthenticodePresent (MonoReflectionAssembly *refass); /* System.Security.SecureString */ -extern void ves_icall_System_Security_SecureString_DecryptInternal (MonoArray *data, MonoObject *scope) MONO_INTERNAL; -extern void ves_icall_System_Security_SecureString_EncryptInternal (MonoArray *data, MonoObject *scope) MONO_INTERNAL; -void invoke_protected_memory_method (MonoArray *data, MonoObject *scope, gboolean encrypt) MONO_INTERNAL; +extern void ves_icall_System_Security_SecureString_DecryptInternal (MonoArray *data, MonoObject *scope); +extern void ves_icall_System_Security_SecureString_EncryptInternal (MonoArray *data, MonoObject *scope); +void invoke_protected_memory_method (MonoArray *data, MonoObject *scope, gboolean encrypt); G_END_DECLS diff --git a/mono/metadata/sgen-cardtable.h b/mono/metadata/sgen-cardtable.h index bc9ea77a5e3..bf74990610a 100644 --- a/mono/metadata/sgen-cardtable.h +++ b/mono/metadata/sgen-cardtable.h @@ -24,18 +24,18 @@ #ifndef __MONO_SGEN_CARD_TABLE_INLINES_H__ #define __MONO_SGEN_CARD_TABLE_INLINES_H__ -void sgen_card_table_reset_region (mword start, mword end) MONO_INTERNAL; -void* sgen_card_table_align_pointer (void *ptr) MONO_INTERNAL; -void sgen_card_table_mark_range (mword address, mword size) MONO_INTERNAL; +void sgen_card_table_reset_region (mword start, mword end); +void* sgen_card_table_align_pointer (void *ptr); +void sgen_card_table_mark_range (mword address, mword size); void sgen_cardtable_scan_object (char *obj, mword obj_size, guint8 *cards, - gboolean mod_union, SgenGrayQueue *queue) MONO_INTERNAL; + gboolean mod_union, SgenGrayQueue *queue); -gboolean sgen_card_table_get_card_data (guint8 *dest, mword address, mword cards) MONO_INTERNAL; +gboolean sgen_card_table_get_card_data (guint8 *dest, mword address, mword cards); -guint8* sgen_card_table_update_mod_union_from_cards (guint8 *dest, guint8 *start_card, size_t num_cards) MONO_INTERNAL; -guint8* sgen_card_table_update_mod_union (guint8 *dest, char *obj, mword obj_size, size_t *out_num_cards) MONO_INTERNAL; +guint8* sgen_card_table_update_mod_union_from_cards (guint8 *dest, guint8 *start_card, size_t num_cards); +guint8* sgen_card_table_update_mod_union (guint8 *dest, char *obj, mword obj_size, size_t *out_num_cards); -void sgen_card_table_init (SgenRemeberedSet *remset) MONO_INTERNAL; +void sgen_card_table_init (SgenRemeberedSet *remset); /*How many bytes a single card covers*/ #define CARD_BITS 9 @@ -54,7 +54,7 @@ void sgen_card_table_init (SgenRemeberedSet *remset) MONO_INTERNAL; #define SGEN_HAVE_OVERLAPPING_CARDS 1 #endif -extern guint8 *sgen_cardtable MONO_INTERNAL; +extern guint8 *sgen_cardtable; #ifdef SGEN_HAVE_OVERLAPPING_CARDS @@ -65,7 +65,7 @@ sgen_card_table_get_card_address (mword address) return sgen_cardtable + ((address >> CARD_BITS) & CARD_MASK); } -extern guint8 *sgen_shadow_cardtable MONO_INTERNAL; +extern guint8 *sgen_shadow_cardtable; static inline guint8* sgen_card_table_get_shadow_card_address (mword address) diff --git a/mono/metadata/sgen-descriptor.h b/mono/metadata/sgen-descriptor.h index 610865d2485..cf516e54dd9 100644 --- a/mono/metadata/sgen-descriptor.h +++ b/mono/metadata/sgen-descriptor.h @@ -132,15 +132,15 @@ enum { ROOT_DESC_TYPE_SHIFT = 3, }; -gsize* sgen_get_complex_descriptor (mword desc) MONO_INTERNAL; -void* sgen_get_complex_descriptor_bitmap (mword desc) MONO_INTERNAL; -MonoGCRootMarkFunc sgen_get_user_descriptor_func (mword desc) MONO_INTERNAL; +gsize* sgen_get_complex_descriptor (mword desc); +void* sgen_get_complex_descriptor_bitmap (mword desc); +MonoGCRootMarkFunc sgen_get_user_descriptor_func (mword desc); -void sgen_init_descriptors (void) MONO_INTERNAL; +void sgen_init_descriptors (void); #ifdef HEAVY_STATISTICS -void sgen_descriptor_count_scanned_object (mword desc) MONO_INTERNAL; -void sgen_descriptor_count_copied_object (mword desc) MONO_INTERNAL; +void sgen_descriptor_count_scanned_object (mword desc); +void sgen_descriptor_count_copied_object (mword desc); #endif static inline gboolean diff --git a/mono/metadata/sgen-gc.h b/mono/metadata/sgen-gc.h index 27bcf096536..1e89e83198f 100644 --- a/mono/metadata/sgen-gc.h +++ b/mono/metadata/sgen-gc.h @@ -61,7 +61,7 @@ typedef enum { CLEAR_AT_TLAB_CREATION_DEBUG } NurseryClearPolicy; -NurseryClearPolicy sgen_get_nursery_clear_policy (void) MONO_INTERNAL; +NurseryClearPolicy sgen_get_nursery_clear_policy (void); #define SGEN_TV_DECLARE(name) gint64 name #define SGEN_TV_GETTIME(tv) tv = mono_100ns_ticks () @@ -253,11 +253,11 @@ extern int num_ready_finalizers; /* good sizes are 512KB-1MB: larger ones increase a lot memzeroing time */ #define DEFAULT_NURSERY_SIZE (sgen_nursery_size) -extern size_t sgen_nursery_size MONO_INTERNAL; +extern size_t sgen_nursery_size; #ifdef SGEN_ALIGN_NURSERY /* The number of trailing 0 bits in DEFAULT_NURSERY_SIZE */ #define DEFAULT_NURSERY_BITS (sgen_nursery_bits) -extern int sgen_nursery_bits MONO_INTERNAL; +extern int sgen_nursery_bits; #endif #else @@ -273,8 +273,8 @@ extern int sgen_nursery_bits MONO_INTERNAL; #define DEFAULT_NURSERY_BITS -1 #endif -extern char *sgen_nursery_start MONO_INTERNAL; -extern char *sgen_nursery_end MONO_INTERNAL; +extern char *sgen_nursery_start; +extern char *sgen_nursery_end; static inline MONO_ALWAYS_INLINE gboolean sgen_ptr_in_nursery (void *p) @@ -394,18 +394,18 @@ extern SgenHashTable roots_hash [ROOT_TYPE_NUM]; typedef void (*IterateObjectCallbackFunc) (char*, size_t, void*); -int sgen_thread_handshake (BOOL suspend) MONO_INTERNAL; -gboolean sgen_suspend_thread (SgenThreadInfo *info) MONO_INTERNAL; -gboolean sgen_resume_thread (SgenThreadInfo *info) MONO_INTERNAL; -void sgen_wait_for_suspend_ack (int count) MONO_INTERNAL; -void sgen_os_init (void) MONO_INTERNAL; +int sgen_thread_handshake (BOOL suspend); +gboolean sgen_suspend_thread (SgenThreadInfo *info); +gboolean sgen_resume_thread (SgenThreadInfo *info); +void sgen_wait_for_suspend_ack (int count); +void sgen_os_init (void); -gboolean sgen_is_worker_thread (MonoNativeThreadId thread) MONO_INTERNAL; +gboolean sgen_is_worker_thread (MonoNativeThreadId thread); -void sgen_update_heap_boundaries (mword low, mword high) MONO_INTERNAL; +void sgen_update_heap_boundaries (mword low, mword high); -void sgen_scan_area_with_callback (char *start, char *end, IterateObjectCallbackFunc callback, void *data, gboolean allow_flags) MONO_INTERNAL; -void sgen_check_section_scan_starts (GCMemSection *section) MONO_INTERNAL; +void sgen_scan_area_with_callback (char *start, char *end, IterateObjectCallbackFunc callback, void *data, gboolean allow_flags); +void sgen_check_section_scan_starts (GCMemSection *section); /* Keep in sync with description_for_type() in sgen-internal.c! */ enum { @@ -461,7 +461,7 @@ enum { #define BINARY_PROTOCOL_ARG(x) #endif -void sgen_init_internal_allocator (void) MONO_INTERNAL; +void sgen_init_internal_allocator (void); typedef struct _ObjectList ObjectList; struct _ObjectList { @@ -480,31 +480,31 @@ typedef struct SgenGrayQueue *queue; } ScanCopyContext; -void sgen_report_internal_mem_usage (void) MONO_INTERNAL; -void sgen_dump_internal_mem_usage (FILE *heap_dump_file) MONO_INTERNAL; -void sgen_dump_section (GCMemSection *section, const char *type) MONO_INTERNAL; -void sgen_dump_occupied (char *start, char *end, char *section_start) MONO_INTERNAL; +void sgen_report_internal_mem_usage (void); +void sgen_dump_internal_mem_usage (FILE *heap_dump_file); +void sgen_dump_section (GCMemSection *section, const char *type); +void sgen_dump_occupied (char *start, char *end, char *section_start); -void sgen_register_moved_object (void *obj, void *destination) MONO_INTERNAL; +void sgen_register_moved_object (void *obj, void *destination); -void sgen_register_fixed_internal_mem_type (int type, size_t size) MONO_INTERNAL; +void sgen_register_fixed_internal_mem_type (int type, size_t size); -void* sgen_alloc_internal (int type) MONO_INTERNAL; -void sgen_free_internal (void *addr, int type) MONO_INTERNAL; +void* sgen_alloc_internal (int type); +void sgen_free_internal (void *addr, int type); -void* sgen_alloc_internal_dynamic (size_t size, int type, gboolean assert_on_failure) MONO_INTERNAL; -void sgen_free_internal_dynamic (void *addr, size_t size, int type) MONO_INTERNAL; +void* sgen_alloc_internal_dynamic (size_t size, int type, gboolean assert_on_failure); +void sgen_free_internal_dynamic (void *addr, size_t size, int type); void sgen_pin_stats_register_object (char *obj, size_t size); void sgen_pin_stats_register_global_remset (char *obj); void sgen_pin_stats_print_class_stats (void); -void sgen_sort_addresses (void **array, size_t size) MONO_INTERNAL; -void sgen_add_to_global_remset (gpointer ptr, gpointer obj) MONO_INTERNAL; +void sgen_sort_addresses (void **array, size_t size); +void sgen_add_to_global_remset (gpointer ptr, gpointer obj); -int sgen_get_current_collection_generation (void) MONO_INTERNAL; -gboolean sgen_collection_is_concurrent (void) MONO_INTERNAL; -gboolean sgen_concurrent_collection_in_progress (void) MONO_INTERNAL; +int sgen_get_current_collection_generation (void); +gboolean sgen_collection_is_concurrent (void); +gboolean sgen_concurrent_collection_in_progress (void); typedef struct { CopyOrMarkObjectFunc copy_or_mark_object; @@ -513,7 +513,7 @@ typedef struct { /*FIXME add allocation function? */ } SgenObjectOperations; -SgenObjectOperations *sgen_get_current_object_ops (void) MONO_INTERNAL; +SgenObjectOperations *sgen_get_current_object_ops (void); typedef struct _SgenFragment SgenFragment; @@ -530,15 +530,15 @@ typedef struct { SgenFragment *region_head; /* List head of the region used by this allocator. Walk with next_in_order. */ } SgenFragmentAllocator; -void sgen_fragment_allocator_add (SgenFragmentAllocator *allocator, char *start, char *end) MONO_INTERNAL; -void sgen_fragment_allocator_release (SgenFragmentAllocator *allocator) MONO_INTERNAL; -void* sgen_fragment_allocator_serial_alloc (SgenFragmentAllocator *allocator, size_t size) MONO_INTERNAL; -void* sgen_fragment_allocator_par_alloc (SgenFragmentAllocator *allocator, size_t size) MONO_INTERNAL; -void* sgen_fragment_allocator_serial_range_alloc (SgenFragmentAllocator *allocator, size_t desired_size, size_t minimum_size, size_t *out_alloc_size) MONO_INTERNAL; -void* sgen_fragment_allocator_par_range_alloc (SgenFragmentAllocator *allocator, size_t desired_size, size_t minimum_size, size_t *out_alloc_size) MONO_INTERNAL; -SgenFragment* sgen_fragment_allocator_alloc (void) MONO_INTERNAL; -void sgen_clear_allocator_fragments (SgenFragmentAllocator *allocator) MONO_INTERNAL; -void sgen_clear_range (char *start, char *end) MONO_INTERNAL; +void sgen_fragment_allocator_add (SgenFragmentAllocator *allocator, char *start, char *end); +void sgen_fragment_allocator_release (SgenFragmentAllocator *allocator); +void* sgen_fragment_allocator_serial_alloc (SgenFragmentAllocator *allocator, size_t size); +void* sgen_fragment_allocator_par_alloc (SgenFragmentAllocator *allocator, size_t size); +void* sgen_fragment_allocator_serial_range_alloc (SgenFragmentAllocator *allocator, size_t desired_size, size_t minimum_size, size_t *out_alloc_size); +void* sgen_fragment_allocator_par_range_alloc (SgenFragmentAllocator *allocator, size_t desired_size, size_t minimum_size, size_t *out_alloc_size); +SgenFragment* sgen_fragment_allocator_alloc (void); +void sgen_clear_allocator_fragments (SgenFragmentAllocator *allocator); +void sgen_clear_range (char *start, char *end); /* @@ -558,8 +558,8 @@ Test 1 (compiling corlib): #define SGEN_TO_SPACE_GRANULE_BITS 9 #define SGEN_TO_SPACE_GRANULE_IN_BYTES (1 << SGEN_TO_SPACE_GRANULE_BITS) -extern char *sgen_space_bitmap MONO_INTERNAL; -extern size_t sgen_space_bitmap_size MONO_INTERNAL; +extern char *sgen_space_bitmap; +extern size_t sgen_space_bitmap_size; static inline gboolean sgen_nursery_is_to_space (char *object) @@ -615,8 +615,8 @@ typedef struct { extern SgenMinorCollector sgen_minor_collector; -void sgen_simple_nursery_init (SgenMinorCollector *collector) MONO_INTERNAL; -void sgen_split_nursery_init (SgenMinorCollector *collector) MONO_INTERNAL; +void sgen_simple_nursery_init (SgenMinorCollector *collector); +void sgen_split_nursery_init (SgenMinorCollector *collector); /* Updating references */ @@ -640,7 +640,7 @@ sgen_update_reference (void **p, void *o, gboolean allow_null) /* Major collector */ typedef void (*sgen_cardtable_block_callback) (mword start, mword size); -void sgen_major_collector_iterate_live_block_ranges (sgen_cardtable_block_callback callback) MONO_INTERNAL; +void sgen_major_collector_iterate_live_block_ranges (sgen_cardtable_block_callback callback); typedef enum { ITERATE_OBJECTS_SWEEP = 1, @@ -726,12 +726,12 @@ struct _SgenMajorCollector { extern SgenMajorCollector major_collector; -void sgen_marksweep_init (SgenMajorCollector *collector) MONO_INTERNAL; -void sgen_marksweep_fixed_init (SgenMajorCollector *collector) MONO_INTERNAL; -void sgen_marksweep_par_init (SgenMajorCollector *collector) MONO_INTERNAL; -void sgen_marksweep_fixed_par_init (SgenMajorCollector *collector) MONO_INTERNAL; -void sgen_marksweep_conc_init (SgenMajorCollector *collector) MONO_INTERNAL; -SgenMajorCollector* sgen_get_major_collector (void) MONO_INTERNAL; +void sgen_marksweep_init (SgenMajorCollector *collector); +void sgen_marksweep_fixed_init (SgenMajorCollector *collector); +void sgen_marksweep_par_init (SgenMajorCollector *collector); +void sgen_marksweep_fixed_par_init (SgenMajorCollector *collector); +void sgen_marksweep_conc_init (SgenMajorCollector *collector); +SgenMajorCollector* sgen_get_major_collector (void); typedef struct _SgenRemeberedSet { @@ -752,7 +752,7 @@ typedef struct _SgenRemeberedSet { gboolean (*find_address_with_cards) (char *cards_start, guint8 *cards, char *addr); } SgenRemeberedSet; -SgenRemeberedSet *sgen_get_remset (void) MONO_INTERNAL; +SgenRemeberedSet *sgen_get_remset (void); static mword /*__attribute__((noinline)) not sure if this hint is a good idea*/ slow_object_get_size (MonoVTable *vtable, MonoObject* o) @@ -865,34 +865,34 @@ sgen_safe_object_get_size_unaligned (MonoObject *obj) return slow_object_get_size ((MonoVTable*)SGEN_LOAD_VTABLE (obj), obj); } -const char* sgen_safe_name (void* obj) MONO_INTERNAL; +const char* sgen_safe_name (void* obj); -gboolean sgen_object_is_live (void *obj) MONO_INTERNAL; +gboolean sgen_object_is_live (void *obj); -void sgen_init_fin_weak_hash (void) MONO_INTERNAL; +void sgen_init_fin_weak_hash (void); -gboolean sgen_need_bridge_processing (void) MONO_INTERNAL; -void sgen_bridge_reset_data (void) MONO_INTERNAL; -void sgen_bridge_processing_stw_step (void) MONO_INTERNAL; -void sgen_bridge_processing_finish (int generation) MONO_INTERNAL; -void sgen_register_test_bridge_callbacks (const char *bridge_class_name) MONO_INTERNAL; -gboolean sgen_is_bridge_object (MonoObject *obj) MONO_INTERNAL; -MonoGCBridgeObjectKind sgen_bridge_class_kind (MonoClass *klass) MONO_INTERNAL; -void sgen_mark_bridge_object (MonoObject *obj) MONO_INTERNAL; -void sgen_bridge_register_finalized_object (MonoObject *object) MONO_INTERNAL; -void sgen_bridge_describe_pointer (MonoObject *object) MONO_INTERNAL; +gboolean sgen_need_bridge_processing (void); +void sgen_bridge_reset_data (void); +void sgen_bridge_processing_stw_step (void); +void sgen_bridge_processing_finish (int generation); +void sgen_register_test_bridge_callbacks (const char *bridge_class_name); +gboolean sgen_is_bridge_object (MonoObject *obj); +MonoGCBridgeObjectKind sgen_bridge_class_kind (MonoClass *klass); +void sgen_mark_bridge_object (MonoObject *obj); +void sgen_bridge_register_finalized_object (MonoObject *object); +void sgen_bridge_describe_pointer (MonoObject *object); -void sgen_mark_togglerefs (char *start, char *end, ScanCopyContext ctx) MONO_INTERNAL; -void sgen_clear_togglerefs (char *start, char *end, ScanCopyContext ctx) MONO_INTERNAL; +void sgen_mark_togglerefs (char *start, char *end, ScanCopyContext ctx); +void sgen_clear_togglerefs (char *start, char *end, ScanCopyContext ctx); -void sgen_process_togglerefs (void) MONO_INTERNAL; -void sgen_register_test_toggleref_callback (void) MONO_INTERNAL; +void sgen_process_togglerefs (void); +void sgen_register_test_toggleref_callback (void); -gboolean sgen_is_bridge_object (MonoObject *obj) MONO_INTERNAL; -void sgen_mark_bridge_object (MonoObject *obj) MONO_INTERNAL; +gboolean sgen_is_bridge_object (MonoObject *obj); +void sgen_mark_bridge_object (MonoObject *obj); -gboolean sgen_bridge_handle_gc_debug (const char *opt) MONO_INTERNAL; -void sgen_bridge_print_gc_debug_usage (void) MONO_INTERNAL; +gboolean sgen_bridge_handle_gc_debug (const char *opt); +void sgen_bridge_print_gc_debug_usage (void); typedef struct { void (*reset_data) (void); @@ -915,36 +915,36 @@ typedef struct { MonoGCBridgeXRef *api_xrefs; } SgenBridgeProcessor; -void sgen_old_bridge_init (SgenBridgeProcessor *collector) MONO_INTERNAL; -void sgen_new_bridge_init (SgenBridgeProcessor *collector) MONO_INTERNAL; -void sgen_tarjan_bridge_init (SgenBridgeProcessor *collector) MONO_INTERNAL; -void sgen_set_bridge_implementation (const char *name) MONO_INTERNAL; -void sgen_bridge_set_dump_prefix (const char *prefix) MONO_INTERNAL; +void sgen_old_bridge_init (SgenBridgeProcessor *collector); +void sgen_new_bridge_init (SgenBridgeProcessor *collector); +void sgen_tarjan_bridge_init (SgenBridgeProcessor *collector); +void sgen_set_bridge_implementation (const char *name); +void sgen_bridge_set_dump_prefix (const char *prefix); -gboolean sgen_compare_bridge_processor_results (SgenBridgeProcessor *a, SgenBridgeProcessor *b) MONO_INTERNAL; +gboolean sgen_compare_bridge_processor_results (SgenBridgeProcessor *a, SgenBridgeProcessor *b); typedef mono_bool (*WeakLinkAlivePredicateFunc) (MonoObject*, void*); -void sgen_null_links_with_predicate (int generation, WeakLinkAlivePredicateFunc predicate, void *data) MONO_INTERNAL; +void sgen_null_links_with_predicate (int generation, WeakLinkAlivePredicateFunc predicate, void *data); -gboolean sgen_gc_is_object_ready_for_finalization (void *object) MONO_INTERNAL; -void sgen_gc_lock (void) MONO_INTERNAL; -void sgen_gc_unlock (void) MONO_INTERNAL; -void sgen_gc_event_moves (void) MONO_INTERNAL; +gboolean sgen_gc_is_object_ready_for_finalization (void *object); +void sgen_gc_lock (void); +void sgen_gc_unlock (void); +void sgen_gc_event_moves (void); -void sgen_queue_finalization_entry (MonoObject *obj) MONO_INTERNAL; -const char* sgen_generation_name (int generation) MONO_INTERNAL; +void sgen_queue_finalization_entry (MonoObject *obj); +const char* sgen_generation_name (int generation); -void sgen_collect_bridge_objects (int generation, ScanCopyContext ctx) MONO_INTERNAL; -void sgen_finalize_in_range (int generation, ScanCopyContext ctx) MONO_INTERNAL; -void sgen_null_link_in_range (int generation, gboolean before_finalization, ScanCopyContext ctx) MONO_INTERNAL; -void sgen_null_links_for_domain (MonoDomain *domain, int generation) MONO_INTERNAL; -void sgen_remove_finalizers_for_domain (MonoDomain *domain, int generation) MONO_INTERNAL; -void sgen_process_fin_stage_entries (void) MONO_INTERNAL; -void sgen_process_dislink_stage_entries (void) MONO_INTERNAL; -void sgen_register_disappearing_link (MonoObject *obj, void **link, gboolean track, gboolean in_gc) MONO_INTERNAL; +void sgen_collect_bridge_objects (int generation, ScanCopyContext ctx); +void sgen_finalize_in_range (int generation, ScanCopyContext ctx); +void sgen_null_link_in_range (int generation, gboolean before_finalization, ScanCopyContext ctx); +void sgen_null_links_for_domain (MonoDomain *domain, int generation); +void sgen_remove_finalizers_for_domain (MonoDomain *domain, int generation); +void sgen_process_fin_stage_entries (void); +void sgen_process_dislink_stage_entries (void); +void sgen_register_disappearing_link (MonoObject *obj, void **link, gboolean track, gboolean in_gc); -gboolean sgen_drain_gray_stack (int max_objs, ScanCopyContext ctx) MONO_INTERNAL; +gboolean sgen_drain_gray_stack (int max_objs, ScanCopyContext ctx); enum { SPACE_NURSERY, @@ -952,14 +952,14 @@ enum { SPACE_LOS }; -void sgen_pin_object (void *object, SgenGrayQueue *queue) MONO_INTERNAL; -void sgen_parallel_pin_or_update (void **ptr, void *obj, MonoVTable *vt, SgenGrayQueue *queue) MONO_INTERNAL; -void sgen_set_pinned_from_failed_allocation (mword objsize) MONO_INTERNAL; +void sgen_pin_object (void *object, SgenGrayQueue *queue); +void sgen_parallel_pin_or_update (void **ptr, void *obj, MonoVTable *vt, SgenGrayQueue *queue); +void sgen_set_pinned_from_failed_allocation (mword objsize); -void sgen_ensure_free_space (size_t size) MONO_INTERNAL; -void sgen_perform_collection (size_t requested_size, int generation_to_collect, const char *reason, gboolean wait_to_finish) MONO_INTERNAL; -gboolean sgen_has_critical_method (void) MONO_INTERNAL; -gboolean sgen_is_critical_method (MonoMethod *method) MONO_INTERNAL; +void sgen_ensure_free_space (size_t size); +void sgen_perform_collection (size_t requested_size, int generation_to_collect, const char *reason, gboolean wait_to_finish); +gboolean sgen_has_critical_method (void); +gboolean sgen_is_critical_method (MonoMethod *method); /* STW */ @@ -972,9 +972,9 @@ typedef struct { SGEN_TV_DECLARE (bridge_time); } GGTimingInfo; -int sgen_stop_world (int generation) MONO_INTERNAL; -int sgen_restart_world (int generation, GGTimingInfo *timing) MONO_INTERNAL; -void sgen_init_stw (void) MONO_INTERNAL; +int sgen_stop_world (int generation); +int sgen_restart_world (int generation, GGTimingInfo *timing); +void sgen_init_stw (void); /* LOS */ @@ -992,45 +992,45 @@ struct _LOSObject { extern LOSObject *los_object_list; extern mword los_memory_usage; -void sgen_los_free_object (LOSObject *obj) MONO_INTERNAL; -void* sgen_los_alloc_large_inner (MonoVTable *vtable, size_t size) MONO_INTERNAL; -void sgen_los_sweep (void) MONO_INTERNAL; -gboolean sgen_ptr_is_in_los (char *ptr, char **start) MONO_INTERNAL; -void sgen_los_iterate_objects (IterateObjectCallbackFunc cb, void *user_data) MONO_INTERNAL; -void sgen_los_iterate_live_block_ranges (sgen_cardtable_block_callback callback) MONO_INTERNAL; -void sgen_los_scan_card_table (gboolean mod_union, SgenGrayQueue *queue) MONO_INTERNAL; -void sgen_los_update_cardtable_mod_union (void) MONO_INTERNAL; -void sgen_los_count_cards (long long *num_total_cards, long long *num_marked_cards) MONO_INTERNAL; -void sgen_major_collector_scan_card_table (SgenGrayQueue *queue) MONO_INTERNAL; -gboolean sgen_los_is_valid_object (char *object) MONO_INTERNAL; -gboolean mono_sgen_los_describe_pointer (char *ptr) MONO_INTERNAL; -LOSObject* sgen_los_header_for_object (char *data) MONO_INTERNAL; -mword sgen_los_object_size (LOSObject *obj) MONO_INTERNAL; -void sgen_los_pin_object (char *obj) MONO_INTERNAL; -void sgen_los_unpin_object (char *obj) MONO_INTERNAL; -gboolean sgen_los_object_is_pinned (char *obj) MONO_INTERNAL; +void sgen_los_free_object (LOSObject *obj); +void* sgen_los_alloc_large_inner (MonoVTable *vtable, size_t size); +void sgen_los_sweep (void); +gboolean sgen_ptr_is_in_los (char *ptr, char **start); +void sgen_los_iterate_objects (IterateObjectCallbackFunc cb, void *user_data); +void sgen_los_iterate_live_block_ranges (sgen_cardtable_block_callback callback); +void sgen_los_scan_card_table (gboolean mod_union, SgenGrayQueue *queue); +void sgen_los_update_cardtable_mod_union (void); +void sgen_los_count_cards (long long *num_total_cards, long long *num_marked_cards); +void sgen_major_collector_scan_card_table (SgenGrayQueue *queue); +gboolean sgen_los_is_valid_object (char *object); +gboolean mono_sgen_los_describe_pointer (char *ptr); +LOSObject* sgen_los_header_for_object (char *data); +mword sgen_los_object_size (LOSObject *obj); +void sgen_los_pin_object (char *obj); +void sgen_los_unpin_object (char *obj); +gboolean sgen_los_object_is_pinned (char *obj); /* nursery allocator */ -void sgen_clear_nursery_fragments (void) MONO_INTERNAL; -void sgen_nursery_allocator_prepare_for_pinning (void) MONO_INTERNAL; -void sgen_nursery_allocator_set_nursery_bounds (char *nursery_start, char *nursery_end) MONO_INTERNAL; -mword sgen_build_nursery_fragments (GCMemSection *nursery_section, SgenGrayQueue *unpin_queue) MONO_INTERNAL; -void sgen_init_nursery_allocator (void) MONO_INTERNAL; -void sgen_nursery_allocator_init_heavy_stats (void) MONO_INTERNAL; -void sgen_alloc_init_heavy_stats (void) MONO_INTERNAL; -char* sgen_nursery_alloc_get_upper_alloc_bound (void) MONO_INTERNAL; -void* sgen_nursery_alloc (size_t size) MONO_INTERNAL; -void* sgen_nursery_alloc_range (size_t size, size_t min_size, size_t *out_alloc_size) MONO_INTERNAL; -MonoVTable* sgen_get_array_fill_vtable (void) MONO_INTERNAL; -gboolean sgen_can_alloc_size (size_t size) MONO_INTERNAL; -void sgen_nursery_retire_region (void *address, ptrdiff_t size) MONO_INTERNAL; - -void sgen_nursery_alloc_prepare_for_minor (void) MONO_INTERNAL; -void sgen_nursery_alloc_prepare_for_major (void) MONO_INTERNAL; - -char* sgen_alloc_for_promotion (char *obj, size_t objsize, gboolean has_references) MONO_INTERNAL; +void sgen_clear_nursery_fragments (void); +void sgen_nursery_allocator_prepare_for_pinning (void); +void sgen_nursery_allocator_set_nursery_bounds (char *nursery_start, char *nursery_end); +mword sgen_build_nursery_fragments (GCMemSection *nursery_section, SgenGrayQueue *unpin_queue); +void sgen_init_nursery_allocator (void); +void sgen_nursery_allocator_init_heavy_stats (void); +void sgen_alloc_init_heavy_stats (void); +char* sgen_nursery_alloc_get_upper_alloc_bound (void); +void* sgen_nursery_alloc (size_t size); +void* sgen_nursery_alloc_range (size_t size, size_t min_size, size_t *out_alloc_size); +MonoVTable* sgen_get_array_fill_vtable (void); +gboolean sgen_can_alloc_size (size_t size); +void sgen_nursery_retire_region (void *address, ptrdiff_t size); + +void sgen_nursery_alloc_prepare_for_minor (void); +void sgen_nursery_alloc_prepare_for_major (void); + +char* sgen_alloc_for_promotion (char *obj, size_t objsize, gboolean has_references); /* TLS Data */ @@ -1159,14 +1159,14 @@ void sgen_check_consistency (void); void sgen_check_mod_union_consistency (void); void sgen_check_major_refs (void); void sgen_check_whole_heap (gboolean allow_missing_pinning); -void sgen_check_whole_heap_stw (void) MONO_INTERNAL; +void sgen_check_whole_heap_stw (void); void sgen_check_objref (char *obj); -void sgen_check_heap_marked (gboolean nursery_must_be_pinned) MONO_INTERNAL; -void sgen_check_nursery_objects_pinned (gboolean pinned) MONO_INTERNAL; -void sgen_scan_for_registered_roots_in_domain (MonoDomain *domain, int root_type) MONO_INTERNAL; -void sgen_check_for_xdomain_refs (void) MONO_INTERNAL; +void sgen_check_heap_marked (gboolean nursery_must_be_pinned); +void sgen_check_nursery_objects_pinned (gboolean pinned); +void sgen_scan_for_registered_roots_in_domain (MonoDomain *domain, int root_type); +void sgen_check_for_xdomain_refs (void); -void mono_gc_scan_for_specific_ref (MonoObject *key, gboolean precise) MONO_INTERNAL; +void mono_gc_scan_for_specific_ref (MonoObject *key, gboolean precise); /* Write barrier support */ @@ -1190,13 +1190,13 @@ sgen_dummy_use (gpointer v) { #define MONO_GC_PARAMS_NAME "MONO_GC_PARAMS" #define MONO_GC_DEBUG_NAME "MONO_GC_DEBUG" -gboolean sgen_parse_environment_string_extract_number (const char *str, size_t *out) MONO_INTERNAL; -void sgen_env_var_error (const char *env_var, const char *fallback, const char *description_format, ...) MONO_INTERNAL; +gboolean sgen_parse_environment_string_extract_number (const char *str, size_t *out); +void sgen_env_var_error (const char *env_var, const char *fallback, const char *description_format, ...); /* Utilities */ -void sgen_qsort (void *base, size_t nel, size_t width, int (*compar) (const void*, const void*)) MONO_INTERNAL; -gint64 sgen_timestamp (void) MONO_INTERNAL; +void sgen_qsort (void *base, size_t nel, size_t width, int (*compar) (const void*, const void*)); +gint64 sgen_timestamp (void); /* * Canary (guard word) support @@ -1205,7 +1205,7 @@ gint64 sgen_timestamp (void) MONO_INTERNAL; * - Canary space is not included on checks against SGEN_MAX_SMALL_OBJ_SIZE */ -gboolean nursery_canaries_enabled (void) MONO_INTERNAL; +gboolean nursery_canaries_enabled (void); #define CANARY_SIZE 8 #define CANARY_STRING "koupepia" diff --git a/mono/metadata/sgen-gray.h b/mono/metadata/sgen-gray.h index c51822c908d..f222c55b907 100644 --- a/mono/metadata/sgen-gray.h +++ b/mono/metadata/sgen-gray.h @@ -134,28 +134,28 @@ extern guint64 stat_gray_queue_enqueue_slow_path; extern guint64 stat_gray_queue_dequeue_slow_path; #endif -void sgen_init_gray_queues (void) MONO_INTERNAL; - -void sgen_gray_object_enqueue (SgenGrayQueue *queue, char *obj, mword desc) MONO_INTERNAL; -GrayQueueEntry sgen_gray_object_dequeue (SgenGrayQueue *queue) MONO_INTERNAL; -GrayQueueSection* sgen_gray_object_dequeue_section (SgenGrayQueue *queue) MONO_INTERNAL; -void sgen_gray_object_enqueue_section (SgenGrayQueue *queue, GrayQueueSection *section) MONO_INTERNAL; -void sgen_gray_object_queue_trim_free_list (SgenGrayQueue *queue) MONO_INTERNAL; -void sgen_gray_object_queue_init (SgenGrayQueue *queue, GrayQueueEnqueueCheckFunc enqueue_check_func) MONO_INTERNAL; -void sgen_gray_object_queue_init_invalid (SgenGrayQueue *queue) MONO_INTERNAL; -void sgen_gray_queue_set_alloc_prepare (SgenGrayQueue *queue, GrayQueueAllocPrepareFunc alloc_prepare_func, void *data) MONO_INTERNAL; +void sgen_init_gray_queues (void); + +void sgen_gray_object_enqueue (SgenGrayQueue *queue, char *obj, mword desc); +GrayQueueEntry sgen_gray_object_dequeue (SgenGrayQueue *queue); +GrayQueueSection* sgen_gray_object_dequeue_section (SgenGrayQueue *queue); +void sgen_gray_object_enqueue_section (SgenGrayQueue *queue, GrayQueueSection *section); +void sgen_gray_object_queue_trim_free_list (SgenGrayQueue *queue); +void sgen_gray_object_queue_init (SgenGrayQueue *queue, GrayQueueEnqueueCheckFunc enqueue_check_func); +void sgen_gray_object_queue_init_invalid (SgenGrayQueue *queue); +void sgen_gray_queue_set_alloc_prepare (SgenGrayQueue *queue, GrayQueueAllocPrepareFunc alloc_prepare_func, void *data); void sgen_gray_object_queue_init_with_alloc_prepare (SgenGrayQueue *queue, GrayQueueEnqueueCheckFunc enqueue_check_func, - GrayQueueAllocPrepareFunc func, void *data) MONO_INTERNAL; -void sgen_gray_object_queue_deinit (SgenGrayQueue *queue) MONO_INTERNAL; -void sgen_gray_object_queue_disable_alloc_prepare (SgenGrayQueue *queue) MONO_INTERNAL; -void sgen_gray_object_alloc_queue_section (SgenGrayQueue *queue) MONO_INTERNAL; -void sgen_gray_object_free_queue_section (GrayQueueSection *section) MONO_INTERNAL; + GrayQueueAllocPrepareFunc func, void *data); +void sgen_gray_object_queue_deinit (SgenGrayQueue *queue); +void sgen_gray_object_queue_disable_alloc_prepare (SgenGrayQueue *queue); +void sgen_gray_object_alloc_queue_section (SgenGrayQueue *queue); +void sgen_gray_object_free_queue_section (GrayQueueSection *section); void sgen_section_gray_queue_init (SgenSectionGrayQueue *queue, gboolean locked, - GrayQueueEnqueueCheckFunc enqueue_check_func) MONO_INTERNAL; -gboolean sgen_section_gray_queue_is_empty (SgenSectionGrayQueue *queue) MONO_INTERNAL; -GrayQueueSection* sgen_section_gray_queue_dequeue (SgenSectionGrayQueue *queue) MONO_INTERNAL; -void sgen_section_gray_queue_enqueue (SgenSectionGrayQueue *queue, GrayQueueSection *section) MONO_INTERNAL; + GrayQueueEnqueueCheckFunc enqueue_check_func); +gboolean sgen_section_gray_queue_is_empty (SgenSectionGrayQueue *queue); +GrayQueueSection* sgen_section_gray_queue_dequeue (SgenSectionGrayQueue *queue); +void sgen_section_gray_queue_enqueue (SgenSectionGrayQueue *queue, GrayQueueSection *section); gboolean sgen_gray_object_fill_prefetch (SgenGrayQueue *queue); diff --git a/mono/metadata/sgen-hash-table.h b/mono/metadata/sgen-hash-table.h index dfb47dcca42..e6cfe43a5a0 100644 --- a/mono/metadata/sgen-hash-table.h +++ b/mono/metadata/sgen-hash-table.h @@ -30,15 +30,15 @@ typedef struct { #define SGEN_HASH_TABLE_INIT(table_type,entry_type,data_size,hash_func,equal_func) { (table_type), (entry_type), (data_size), (hash_func), (equal_func), NULL, 0, 0 } #define SGEN_HASH_TABLE_ENTRY_SIZE(data_size) ((data_size) + sizeof (SgenHashTableEntry*) + sizeof (gpointer)) -gpointer sgen_hash_table_lookup (SgenHashTable *table, gpointer key) MONO_INTERNAL; -gboolean sgen_hash_table_replace (SgenHashTable *table, gpointer key, gpointer new_value, gpointer old_value) MONO_INTERNAL; -gboolean sgen_hash_table_set_value (SgenHashTable *table, gpointer key, gpointer new_value, gpointer old_value) MONO_INTERNAL; -gboolean sgen_hash_table_set_key (SgenHashTable *hash_table, gpointer old_key, gpointer new_key) MONO_INTERNAL; -gboolean sgen_hash_table_remove (SgenHashTable *table, gpointer key, gpointer data_return) MONO_INTERNAL; +gpointer sgen_hash_table_lookup (SgenHashTable *table, gpointer key); +gboolean sgen_hash_table_replace (SgenHashTable *table, gpointer key, gpointer new_value, gpointer old_value); +gboolean sgen_hash_table_set_value (SgenHashTable *table, gpointer key, gpointer new_value, gpointer old_value); +gboolean sgen_hash_table_set_key (SgenHashTable *hash_table, gpointer old_key, gpointer new_key); +gboolean sgen_hash_table_remove (SgenHashTable *table, gpointer key, gpointer data_return); -void sgen_hash_table_clean (SgenHashTable *table) MONO_INTERNAL; +void sgen_hash_table_clean (SgenHashTable *table); -void sgen_init_hash_table (void) MONO_INTERNAL; +void sgen_init_hash_table (void); #define sgen_hash_table_num_entries(h) ((h)->num_entries) diff --git a/mono/metadata/sgen-layout-stats.h b/mono/metadata/sgen-layout-stats.h index e8116a0cfb6..7692a99e945 100644 --- a/mono/metadata/sgen-layout-stats.h +++ b/mono/metadata/sgen-layout-stats.h @@ -27,12 +27,12 @@ #define SGEN_OBJECT_LAYOUT_BITMAP_BITS 16 -void sgen_object_layout_scanned_bitmap (unsigned int bitmap) MONO_INTERNAL; -void sgen_object_layout_scanned_bitmap_overflow (void) MONO_INTERNAL; -void sgen_object_layout_scanned_ref_array (void) MONO_INTERNAL; -void sgen_object_layout_scanned_vtype_array (void) MONO_INTERNAL; +void sgen_object_layout_scanned_bitmap (unsigned int bitmap); +void sgen_object_layout_scanned_bitmap_overflow (void); +void sgen_object_layout_scanned_ref_array (void); +void sgen_object_layout_scanned_vtype_array (void); -void sgen_object_layout_dump (FILE *out) MONO_INTERNAL; +void sgen_object_layout_dump (FILE *out); #define SGEN_OBJECT_LAYOUT_STATISTICS_DECLARE_BITMAP unsigned int __object_layout_bitmap = 0 #define SGEN_OBJECT_LAYOUT_STATISTICS_MARK_BITMAP(o,p) do { \ diff --git a/mono/metadata/sgen-memory-governor.h b/mono/metadata/sgen-memory-governor.h index fffe906f5bf..16b9ac358a9 100644 --- a/mono/metadata/sgen-memory-governor.h +++ b/mono/metadata/sgen-memory-governor.h @@ -25,23 +25,23 @@ #define __MONO_SGEN_MEMORY_GOVERNOR_H__ /* Heap limits */ -void sgen_memgov_init (size_t max_heap, size_t soft_limit, gboolean debug_allowance, double min_allowance_ratio, double save_target) MONO_INTERNAL; -void sgen_memgov_release_space (mword size, int space) MONO_INTERNAL; -gboolean sgen_memgov_try_alloc_space (mword size, int space) MONO_INTERNAL; +void sgen_memgov_init (size_t max_heap, size_t soft_limit, gboolean debug_allowance, double min_allowance_ratio, double save_target); +void sgen_memgov_release_space (mword size, int space); +gboolean sgen_memgov_try_alloc_space (mword size, int space); /* GC trigger heuristics */ -void sgen_memgov_minor_collection_start (void) MONO_INTERNAL; -void sgen_memgov_minor_collection_end (void) MONO_INTERNAL; +void sgen_memgov_minor_collection_start (void); +void sgen_memgov_minor_collection_end (void); -void sgen_memgov_major_collection_start (void) MONO_INTERNAL; -void sgen_memgov_major_collection_end (void) MONO_INTERNAL; +void sgen_memgov_major_collection_start (void); +void sgen_memgov_major_collection_end (void); -void sgen_memgov_collection_start (int generation) MONO_INTERNAL; -void sgen_memgov_collection_end (int generation, GGTimingInfo* info, int info_count) MONO_INTERNAL; +void sgen_memgov_collection_start (int generation); +void sgen_memgov_collection_end (int generation, GGTimingInfo* info, int info_count); -void sgen_register_major_sections_alloced (size_t num_sections) MONO_INTERNAL; -mword sgen_get_minor_collection_allowance (void) MONO_INTERNAL; -gboolean sgen_need_major_collection (mword space_needed) MONO_INTERNAL; +void sgen_register_major_sections_alloced (size_t num_sections); +mword sgen_get_minor_collection_allowance (void); +gboolean sgen_need_major_collection (mword space_needed); typedef enum { @@ -51,12 +51,12 @@ typedef enum { } SgenAllocFlags; /* OS memory allocation */ -void* sgen_alloc_os_memory (size_t size, SgenAllocFlags flags, const char *assert_description) MONO_INTERNAL; -void* sgen_alloc_os_memory_aligned (size_t size, mword alignment, SgenAllocFlags flags, const char *assert_description) MONO_INTERNAL; -void sgen_free_os_memory (void *addr, size_t size, SgenAllocFlags flags) MONO_INTERNAL; +void* sgen_alloc_os_memory (size_t size, SgenAllocFlags flags, const char *assert_description); +void* sgen_alloc_os_memory_aligned (size_t size, mword alignment, SgenAllocFlags flags, const char *assert_description); +void sgen_free_os_memory (void *addr, size_t size, SgenAllocFlags flags); /* Error handling */ -void sgen_assert_memory_alloc (void *ptr, size_t requested_size, const char *assert_description) MONO_INTERNAL; +void sgen_assert_memory_alloc (void *ptr, size_t requested_size, const char *assert_description); #endif diff --git a/mono/metadata/sgen-nursery-allocator.c b/mono/metadata/sgen-nursery-allocator.c index dc79eb1babd..d2ef221e1dd 100644 --- a/mono/metadata/sgen-nursery-allocator.c +++ b/mono/metadata/sgen-nursery-allocator.c @@ -107,8 +107,8 @@ int sgen_nursery_bits = 22; #endif #endif -char *sgen_space_bitmap MONO_INTERNAL; -size_t sgen_space_bitmap_size MONO_INTERNAL; +char *sgen_space_bitmap; +size_t sgen_space_bitmap_size; #ifdef HEAVY_STATISTICS diff --git a/mono/metadata/sgen-pinning.h b/mono/metadata/sgen-pinning.h index 9a2dcbb2c57..462fa0fd149 100644 --- a/mono/metadata/sgen-pinning.h +++ b/mono/metadata/sgen-pinning.h @@ -27,38 +27,38 @@ enum { PIN_TYPE_MAX }; -void sgen_pin_stage_ptr (void *ptr) MONO_INTERNAL; -void sgen_optimize_pin_queue (void) MONO_INTERNAL; -void sgen_init_pinning (void) MONO_INTERNAL; -void sgen_finish_pinning (void) MONO_INTERNAL; -void sgen_pin_queue_clear_discarded_entries (GCMemSection *section, size_t max_pin_slot) MONO_INTERNAL; -size_t sgen_get_pinned_count (void) MONO_INTERNAL; -void sgen_pinning_setup_section (GCMemSection *section) MONO_INTERNAL; -void sgen_pinning_trim_queue_to_section (GCMemSection *section) MONO_INTERNAL; +void sgen_pin_stage_ptr (void *ptr); +void sgen_optimize_pin_queue (void); +void sgen_init_pinning (void); +void sgen_finish_pinning (void); +void sgen_pin_queue_clear_discarded_entries (GCMemSection *section, size_t max_pin_slot); +size_t sgen_get_pinned_count (void); +void sgen_pinning_setup_section (GCMemSection *section); +void sgen_pinning_trim_queue_to_section (GCMemSection *section); -void sgen_dump_pin_queue (void) MONO_INTERNAL; +void sgen_dump_pin_queue (void); -gboolean sgen_find_optimized_pin_queue_area (void *start, void *end, size_t *first_out, size_t *last_out) MONO_INTERNAL; -void sgen_find_section_pin_queue_start_end (GCMemSection *section) MONO_INTERNAL; -void** sgen_pinning_get_entry (size_t index) MONO_INTERNAL; -void sgen_pin_objects_in_section (GCMemSection *section, ScanCopyContext ctx) MONO_INTERNAL; +gboolean sgen_find_optimized_pin_queue_area (void *start, void *end, size_t *first_out, size_t *last_out); +void sgen_find_section_pin_queue_start_end (GCMemSection *section); +void** sgen_pinning_get_entry (size_t index); +void sgen_pin_objects_in_section (GCMemSection *section, ScanCopyContext ctx); /* Pinning stats */ -void sgen_pin_stats_register_address (char *addr, int pin_type) MONO_INTERNAL; -size_t sgen_pin_stats_get_pinned_byte_count (int pin_type) MONO_INTERNAL; -ObjectList *sgen_pin_stats_get_object_list (void) MONO_INTERNAL; -void sgen_pin_stats_reset (void) MONO_INTERNAL; +void sgen_pin_stats_register_address (char *addr, int pin_type); +size_t sgen_pin_stats_get_pinned_byte_count (int pin_type); +ObjectList *sgen_pin_stats_get_object_list (void); +void sgen_pin_stats_reset (void); /* Perpetual pinning, aka cementing */ -void sgen_cement_init (gboolean enabled) MONO_INTERNAL; -void sgen_cement_reset (void) MONO_INTERNAL; -void sgen_cement_concurrent_start (void) MONO_INTERNAL; -void sgen_cement_concurrent_finish (void) MONO_INTERNAL; -gboolean sgen_cement_lookup (char *obj) MONO_INTERNAL; -gboolean sgen_cement_lookup_or_register (char *obj) MONO_INTERNAL; -void sgen_pin_cemented_objects (void) MONO_INTERNAL; -void sgen_cement_clear_below_threshold (void) MONO_INTERNAL; +void sgen_cement_init (gboolean enabled); +void sgen_cement_reset (void); +void sgen_cement_concurrent_start (void); +void sgen_cement_concurrent_finish (void); +gboolean sgen_cement_lookup (char *obj); +gboolean sgen_cement_lookup_or_register (char *obj); +void sgen_pin_cemented_objects (void); +void sgen_cement_clear_below_threshold (void); #endif diff --git a/mono/metadata/sgen-pointer-queue.h b/mono/metadata/sgen-pointer-queue.h index 0bbeedfdd67..303562e974c 100644 --- a/mono/metadata/sgen-pointer-queue.h +++ b/mono/metadata/sgen-pointer-queue.h @@ -29,15 +29,15 @@ typedef struct { int mem_type; } SgenPointerQueue; -void sgen_pointer_queue_add (SgenPointerQueue *queue, void *ptr) MONO_INTERNAL; -void sgen_pointer_queue_clear (SgenPointerQueue *queue) MONO_INTERNAL; -void sgen_pointer_queue_remove_nulls (SgenPointerQueue *queue) MONO_INTERNAL; -void sgen_pointer_queue_sort_uniq (SgenPointerQueue *queue) MONO_INTERNAL; -size_t sgen_pointer_queue_search (SgenPointerQueue *queue, void *addr) MONO_INTERNAL; -size_t sgen_pointer_queue_find (SgenPointerQueue *queue, void *ptr) MONO_INTERNAL; -void sgen_pointer_queue_init (SgenPointerQueue *queue, int mem_type) MONO_INTERNAL; -void* sgen_pointer_queue_pop (SgenPointerQueue *queue) MONO_INTERNAL; -gboolean sgen_pointer_queue_is_empty (SgenPointerQueue *queue) MONO_INTERNAL; -void sgen_pointer_queue_free (SgenPointerQueue *queue) MONO_INTERNAL; +void sgen_pointer_queue_add (SgenPointerQueue *queue, void *ptr); +void sgen_pointer_queue_clear (SgenPointerQueue *queue); +void sgen_pointer_queue_remove_nulls (SgenPointerQueue *queue); +void sgen_pointer_queue_sort_uniq (SgenPointerQueue *queue); +size_t sgen_pointer_queue_search (SgenPointerQueue *queue, void *addr); +size_t sgen_pointer_queue_find (SgenPointerQueue *queue, void *ptr); +void sgen_pointer_queue_init (SgenPointerQueue *queue, int mem_type); +void* sgen_pointer_queue_pop (SgenPointerQueue *queue); +gboolean sgen_pointer_queue_is_empty (SgenPointerQueue *queue); +void sgen_pointer_queue_free (SgenPointerQueue *queue); #endif diff --git a/mono/metadata/sgen-protocol.h b/mono/metadata/sgen-protocol.h index 6abd32cdba6..31e10389f1f 100644 --- a/mono/metadata/sgen-protocol.h +++ b/mono/metadata/sgen-protocol.h @@ -140,25 +140,25 @@ enum { /* missing: finalizers, roots, non-store wbarriers */ -void binary_protocol_init (const char *filename, long long limit) MONO_INTERNAL; -gboolean binary_protocol_is_enabled (void) MONO_INTERNAL; +void binary_protocol_init (const char *filename, long long limit); +gboolean binary_protocol_is_enabled (void); -void binary_protocol_flush_buffers (gboolean force) MONO_INTERNAL; +void binary_protocol_flush_buffers (gboolean force); #define BEGIN_PROTOCOL_ENTRY0(method) \ - void method (void) MONO_INTERNAL; + void method (void); #define BEGIN_PROTOCOL_ENTRY1(method,t1,f1) \ - void method (t1 f1) MONO_INTERNAL; + void method (t1 f1); #define BEGIN_PROTOCOL_ENTRY2(method,t1,f1,t2,f2) \ - void method (t1 f1, t2 f2) MONO_INTERNAL; + void method (t1 f1, t2 f2); #define BEGIN_PROTOCOL_ENTRY3(method,t1,f1,t2,f2,t3,f3) \ - void method (t1 f1, t2 f2, t3 f3) MONO_INTERNAL; + void method (t1 f1, t2 f2, t3 f3); #define BEGIN_PROTOCOL_ENTRY4(method,t1,f1,t2,f2,t3,f3,t4,f4) \ - void method (t1 f1, t2 f2, t3 f3, t4 f4) MONO_INTERNAL; + void method (t1 f1, t2 f2, t3 f3, t4 f4); #define BEGIN_PROTOCOL_ENTRY5(method,t1,f1,t2,f2,t3,f3,t4,f4,t5,f5) \ - void method (t1 f1, t2 f2, t3 f3, t4 f4, t5 f5) MONO_INTERNAL; + void method (t1 f1, t2 f2, t3 f3, t4 f4, t5 f5); #define BEGIN_PROTOCOL_ENTRY6(method,t1,f1,t2,f2,t3,f3,t4,f4,t5,f5,t6,f6) \ - void method (t1 f1, t2 f2, t3 f3, t4 f4, t5 f5, t6 f6) MONO_INTERNAL; + void method (t1 f1, t2 f2, t3 f3, t4 f4, t5 f5, t6 f6); #ifdef SGEN_HEAVY_BINARY_PROTOCOL #define binary_protocol_is_heavy_enabled() binary_protocol_is_enabled () diff --git a/mono/metadata/sgen-workers.h b/mono/metadata/sgen-workers.h index 298071bec14..2b3ee35083a 100644 --- a/mono/metadata/sgen-workers.h +++ b/mono/metadata/sgen-workers.h @@ -47,21 +47,21 @@ struct _JobQueueEntry { volatile JobQueueEntry *next; }; -void sgen_workers_init (int num_workers) MONO_INTERNAL; -void sgen_workers_start_all_workers (void) MONO_INTERNAL; -gboolean sgen_workers_have_started (void) MONO_INTERNAL; -void sgen_workers_ensure_awake (void) MONO_INTERNAL; -void sgen_workers_init_distribute_gray_queue (void) MONO_INTERNAL; -void sgen_workers_enqueue_job (JobFunc func, void *data) MONO_INTERNAL; -void sgen_workers_wait_for_jobs_finished (void) MONO_INTERNAL; -void sgen_workers_distribute_gray_queue_sections (void) MONO_INTERNAL; -void sgen_workers_reset_data (void) MONO_INTERNAL; -void sgen_workers_join (void) MONO_INTERNAL; -gboolean sgen_workers_all_done (void) MONO_INTERNAL; -gboolean sgen_workers_are_working (void) MONO_INTERNAL; -SgenSectionGrayQueue* sgen_workers_get_distribute_section_gray_queue (void) MONO_INTERNAL; +void sgen_workers_init (int num_workers); +void sgen_workers_start_all_workers (void); +gboolean sgen_workers_have_started (void); +void sgen_workers_ensure_awake (void); +void sgen_workers_init_distribute_gray_queue (void); +void sgen_workers_enqueue_job (JobFunc func, void *data); +void sgen_workers_wait_for_jobs_finished (void); +void sgen_workers_distribute_gray_queue_sections (void); +void sgen_workers_reset_data (void); +void sgen_workers_join (void); +gboolean sgen_workers_all_done (void); +gboolean sgen_workers_are_working (void); +SgenSectionGrayQueue* sgen_workers_get_distribute_section_gray_queue (void); -void sgen_workers_signal_start_nursery_collection_and_wait (void) MONO_INTERNAL; -void sgen_workers_signal_finish_nursery_collection (void) MONO_INTERNAL; +void sgen_workers_signal_start_nursery_collection_and_wait (void); +void sgen_workers_signal_finish_nursery_collection (void); #endif diff --git a/mono/metadata/socket-io.h b/mono/metadata/socket-io.h index 26944839442..3f2dd85a5ad 100644 --- a/mono/metadata/socket-io.h +++ b/mono/metadata/socket-io.h @@ -191,38 +191,38 @@ typedef struct gint gid; } MonoPeerCredData; -extern gpointer ves_icall_System_Net_Sockets_Socket_Socket_internal(MonoObject *this_obj, gint32 family, gint32 type, gint32 proto, gint32 *error) MONO_INTERNAL; -extern void ves_icall_System_Net_Sockets_Socket_Close_internal(SOCKET sock, gint32 *error) MONO_INTERNAL; -extern gint32 ves_icall_System_Net_Sockets_SocketException_WSAGetLastError_internal(void) MONO_INTERNAL; -extern gint32 ves_icall_System_Net_Sockets_Socket_Available_internal(SOCKET sock, gint32 *error) MONO_INTERNAL; -extern void ves_icall_System_Net_Sockets_Socket_Blocking_internal(SOCKET sock, gboolean block, gint32 *error) MONO_INTERNAL; -extern gpointer ves_icall_System_Net_Sockets_Socket_Accept_internal(SOCKET sock, gint32 *error, gboolean blocking) MONO_INTERNAL; -extern void ves_icall_System_Net_Sockets_Socket_Listen_internal(SOCKET sock, guint32 backlog, gint32 *error) MONO_INTERNAL; -extern MonoObject *ves_icall_System_Net_Sockets_Socket_LocalEndPoint_internal(SOCKET sock, gint32 af, gint32 *error) MONO_INTERNAL; -extern MonoObject *ves_icall_System_Net_Sockets_Socket_RemoteEndPoint_internal(SOCKET sock, gint32 af, gint32 *error) MONO_INTERNAL; -extern void ves_icall_System_Net_Sockets_Socket_Bind_internal(SOCKET sock, MonoObject *sockaddr, gint32 *error) MONO_INTERNAL; -extern void ves_icall_System_Net_Sockets_Socket_Connect_internal(SOCKET sock, MonoObject *sockaddr, gint32 *error) MONO_INTERNAL; -extern gint32 ves_icall_System_Net_Sockets_Socket_Receive_internal(SOCKET sock, MonoArray *buffer, gint32 offset, gint32 count, gint32 flags, gint32 *error) MONO_INTERNAL; -extern gint32 ves_icall_System_Net_Sockets_Socket_Receive_array_internal(SOCKET sock, MonoArray *buffers, gint32 flags, gint32 *error) MONO_INTERNAL; -extern gint32 ves_icall_System_Net_Sockets_Socket_RecvFrom_internal(SOCKET sock, MonoArray *buffer, gint32 offset, gint32 count, gint32 flags, MonoObject **sockaddr, gint32 *error) MONO_INTERNAL; -extern gint32 ves_icall_System_Net_Sockets_Socket_Send_internal(SOCKET sock, MonoArray *buffer, gint32 offset, gint32 count, gint32 flags, gint32 *error) MONO_INTERNAL; -extern gint32 ves_icall_System_Net_Sockets_Socket_Send_array_internal(SOCKET sock, MonoArray *buffers, gint32 flags, gint32 *error) MONO_INTERNAL; -extern gint32 ves_icall_System_Net_Sockets_Socket_SendTo_internal(SOCKET sock, MonoArray *buffer, gint32 offset, gint32 count, gint32 flags, MonoObject *sockaddr, gint32 *error) MONO_INTERNAL; -extern void ves_icall_System_Net_Sockets_Socket_Select_internal(MonoArray **sockets, gint32 timeout, gint32 *error) MONO_INTERNAL; -extern void ves_icall_System_Net_Sockets_Socket_Shutdown_internal(SOCKET sock, gint32 how, gint32 *error) MONO_INTERNAL; -extern void ves_icall_System_Net_Sockets_Socket_GetSocketOption_obj_internal(SOCKET sock, gint32 level, gint32 name, MonoObject **obj_val, gint32 *error) MONO_INTERNAL; -extern void ves_icall_System_Net_Sockets_Socket_GetSocketOption_arr_internal(SOCKET sock, gint32 level, gint32 name, MonoArray **byte_val, gint32 *error) MONO_INTERNAL; -extern void ves_icall_System_Net_Sockets_Socket_SetSocketOption_internal(SOCKET sock, gint32 level, gint32 name, MonoObject *obj_val, MonoArray *byte_val, gint32 int_val, gint32 *error) MONO_INTERNAL; -extern int ves_icall_System_Net_Sockets_Socket_WSAIoctl (SOCKET sock, gint32 code, MonoArray *input, MonoArray *output, gint32 *error) MONO_INTERNAL; -extern MonoBoolean ves_icall_System_Net_Dns_GetHostByName_internal(MonoString *host, MonoString **h_name, MonoArray **h_aliases, MonoArray **h_addr_list) MONO_INTERNAL; -extern MonoBoolean ves_icall_System_Net_Dns_GetHostByAddr_internal(MonoString *addr, MonoString **h_name, MonoArray **h_aliases, MonoArray **h_addr_list) MONO_INTERNAL; -extern MonoBoolean ves_icall_System_Net_Dns_GetHostName_internal(MonoString **h_name) MONO_INTERNAL; -extern MonoBoolean ves_icall_System_Net_Sockets_Socket_Poll_internal (SOCKET sock, gint mode, gint timeout, gint32 *error) MONO_INTERNAL; -extern void ves_icall_System_Net_Sockets_Socket_Disconnect_internal(SOCKET sock, MonoBoolean reuse, gint32 *error) MONO_INTERNAL; -extern gboolean ves_icall_System_Net_Sockets_Socket_SendFile (SOCKET sock, MonoString *filename, MonoArray *pre_buffer, MonoArray *post_buffer, gint flags) MONO_INTERNAL; -void icall_cancel_blocking_socket_operation (MonoThread *thread) MONO_INTERNAL; +extern gpointer ves_icall_System_Net_Sockets_Socket_Socket_internal(MonoObject *this_obj, gint32 family, gint32 type, gint32 proto, gint32 *error); +extern void ves_icall_System_Net_Sockets_Socket_Close_internal(SOCKET sock, gint32 *error); +extern gint32 ves_icall_System_Net_Sockets_SocketException_WSAGetLastError_internal(void); +extern gint32 ves_icall_System_Net_Sockets_Socket_Available_internal(SOCKET sock, gint32 *error); +extern void ves_icall_System_Net_Sockets_Socket_Blocking_internal(SOCKET sock, gboolean block, gint32 *error); +extern gpointer ves_icall_System_Net_Sockets_Socket_Accept_internal(SOCKET sock, gint32 *error, gboolean blocking); +extern void ves_icall_System_Net_Sockets_Socket_Listen_internal(SOCKET sock, guint32 backlog, gint32 *error); +extern MonoObject *ves_icall_System_Net_Sockets_Socket_LocalEndPoint_internal(SOCKET sock, gint32 af, gint32 *error); +extern MonoObject *ves_icall_System_Net_Sockets_Socket_RemoteEndPoint_internal(SOCKET sock, gint32 af, gint32 *error); +extern void ves_icall_System_Net_Sockets_Socket_Bind_internal(SOCKET sock, MonoObject *sockaddr, gint32 *error); +extern void ves_icall_System_Net_Sockets_Socket_Connect_internal(SOCKET sock, MonoObject *sockaddr, gint32 *error); +extern gint32 ves_icall_System_Net_Sockets_Socket_Receive_internal(SOCKET sock, MonoArray *buffer, gint32 offset, gint32 count, gint32 flags, gint32 *error); +extern gint32 ves_icall_System_Net_Sockets_Socket_Receive_array_internal(SOCKET sock, MonoArray *buffers, gint32 flags, gint32 *error); +extern gint32 ves_icall_System_Net_Sockets_Socket_RecvFrom_internal(SOCKET sock, MonoArray *buffer, gint32 offset, gint32 count, gint32 flags, MonoObject **sockaddr, gint32 *error); +extern gint32 ves_icall_System_Net_Sockets_Socket_Send_internal(SOCKET sock, MonoArray *buffer, gint32 offset, gint32 count, gint32 flags, gint32 *error); +extern gint32 ves_icall_System_Net_Sockets_Socket_Send_array_internal(SOCKET sock, MonoArray *buffers, gint32 flags, gint32 *error); +extern gint32 ves_icall_System_Net_Sockets_Socket_SendTo_internal(SOCKET sock, MonoArray *buffer, gint32 offset, gint32 count, gint32 flags, MonoObject *sockaddr, gint32 *error); +extern void ves_icall_System_Net_Sockets_Socket_Select_internal(MonoArray **sockets, gint32 timeout, gint32 *error); +extern void ves_icall_System_Net_Sockets_Socket_Shutdown_internal(SOCKET sock, gint32 how, gint32 *error); +extern void ves_icall_System_Net_Sockets_Socket_GetSocketOption_obj_internal(SOCKET sock, gint32 level, gint32 name, MonoObject **obj_val, gint32 *error); +extern void ves_icall_System_Net_Sockets_Socket_GetSocketOption_arr_internal(SOCKET sock, gint32 level, gint32 name, MonoArray **byte_val, gint32 *error); +extern void ves_icall_System_Net_Sockets_Socket_SetSocketOption_internal(SOCKET sock, gint32 level, gint32 name, MonoObject *obj_val, MonoArray *byte_val, gint32 int_val, gint32 *error); +extern int ves_icall_System_Net_Sockets_Socket_WSAIoctl (SOCKET sock, gint32 code, MonoArray *input, MonoArray *output, gint32 *error); +extern MonoBoolean ves_icall_System_Net_Dns_GetHostByName_internal(MonoString *host, MonoString **h_name, MonoArray **h_aliases, MonoArray **h_addr_list); +extern MonoBoolean ves_icall_System_Net_Dns_GetHostByAddr_internal(MonoString *addr, MonoString **h_name, MonoArray **h_aliases, MonoArray **h_addr_list); +extern MonoBoolean ves_icall_System_Net_Dns_GetHostName_internal(MonoString **h_name); +extern MonoBoolean ves_icall_System_Net_Sockets_Socket_Poll_internal (SOCKET sock, gint mode, gint timeout, gint32 *error); +extern void ves_icall_System_Net_Sockets_Socket_Disconnect_internal(SOCKET sock, MonoBoolean reuse, gint32 *error); +extern gboolean ves_icall_System_Net_Sockets_Socket_SendFile (SOCKET sock, MonoString *filename, MonoArray *pre_buffer, MonoArray *post_buffer, gint flags); +void icall_cancel_blocking_socket_operation (MonoThread *thread); -extern void mono_network_init(void) MONO_INTERNAL; -extern void mono_network_cleanup(void) MONO_INTERNAL; +extern void mono_network_init(void); +extern void mono_network_cleanup(void); #endif /* _MONO_METADATA_SOCKET_H_ */ diff --git a/mono/metadata/string-icalls.h b/mono/metadata/string-icalls.h index 33bcf80378b..2ffc8e38ccf 100644 --- a/mono/metadata/string-icalls.h +++ b/mono/metadata/string-icalls.h @@ -16,21 +16,21 @@ #include "mono/utils/mono-compiler.h" void -ves_icall_System_String_ctor_RedirectToCreateString (void) MONO_INTERNAL; +ves_icall_System_String_ctor_RedirectToCreateString (void); MonoString * -ves_icall_System_String_InternalAllocateStr (gint32 length) MONO_INTERNAL; +ves_icall_System_String_InternalAllocateStr (gint32 length); MonoString * -ves_icall_System_String_InternalIntern (MonoString *str) MONO_INTERNAL; +ves_icall_System_String_InternalIntern (MonoString *str); MonoString * -ves_icall_System_String_InternalIsInterned (MonoString *str) MONO_INTERNAL; +ves_icall_System_String_InternalIsInterned (MonoString *str); int -ves_icall_System_String_GetLOSLimit (void) MONO_INTERNAL; +ves_icall_System_String_GetLOSLimit (void); void -ves_icall_System_String_InternalSetLength (MonoString *str, gint32 new_length) MONO_INTERNAL; +ves_icall_System_String_InternalSetLength (MonoString *str, gint32 new_length); #endif /* _MONO_CLI_STRING_ICALLS_H_ */ diff --git a/mono/metadata/sysmath.h b/mono/metadata/sysmath.h index c4159020e9e..f8f5778ab41 100644 --- a/mono/metadata/sysmath.h +++ b/mono/metadata/sysmath.h @@ -14,53 +14,53 @@ #include #include "mono/utils/mono-compiler.h" -extern gdouble ves_icall_System_Math_Floor (gdouble x) MONO_INTERNAL; -extern gdouble ves_icall_System_Math_Round (gdouble x) MONO_INTERNAL; -extern gdouble ves_icall_System_Math_Round2 (gdouble value, gint32 digits, gboolean away_from_zero) MONO_INTERNAL; +extern gdouble ves_icall_System_Math_Floor (gdouble x); +extern gdouble ves_icall_System_Math_Round (gdouble x); +extern gdouble ves_icall_System_Math_Round2 (gdouble value, gint32 digits, gboolean away_from_zero); extern gdouble -ves_icall_System_Math_Sin (gdouble x) MONO_INTERNAL; +ves_icall_System_Math_Sin (gdouble x); extern gdouble -ves_icall_System_Math_Cos (gdouble x) MONO_INTERNAL; +ves_icall_System_Math_Cos (gdouble x); extern gdouble -ves_icall_System_Math_Tan (gdouble x) MONO_INTERNAL; +ves_icall_System_Math_Tan (gdouble x); extern gdouble -ves_icall_System_Math_Sinh (gdouble x) MONO_INTERNAL; +ves_icall_System_Math_Sinh (gdouble x); extern gdouble -ves_icall_System_Math_Cosh (gdouble x) MONO_INTERNAL; +ves_icall_System_Math_Cosh (gdouble x); extern gdouble -ves_icall_System_Math_Tanh (gdouble x) MONO_INTERNAL; +ves_icall_System_Math_Tanh (gdouble x); extern gdouble -ves_icall_System_Math_Acos (gdouble x) MONO_INTERNAL; +ves_icall_System_Math_Acos (gdouble x); extern gdouble -ves_icall_System_Math_Asin (gdouble x) MONO_INTERNAL; +ves_icall_System_Math_Asin (gdouble x); extern gdouble -ves_icall_System_Math_Atan (gdouble x) MONO_INTERNAL; +ves_icall_System_Math_Atan (gdouble x); extern gdouble -ves_icall_System_Math_Atan2 (gdouble y, gdouble x) MONO_INTERNAL; +ves_icall_System_Math_Atan2 (gdouble y, gdouble x); extern gdouble -ves_icall_System_Math_Exp (gdouble x) MONO_INTERNAL; +ves_icall_System_Math_Exp (gdouble x); extern gdouble -ves_icall_System_Math_Log (gdouble x) MONO_INTERNAL; +ves_icall_System_Math_Log (gdouble x); extern gdouble -ves_icall_System_Math_Log10 (gdouble x) MONO_INTERNAL; +ves_icall_System_Math_Log10 (gdouble x); extern gdouble -ves_icall_System_Math_Pow (gdouble x, gdouble y) MONO_INTERNAL; +ves_icall_System_Math_Pow (gdouble x, gdouble y); extern gdouble -ves_icall_System_Math_Sqrt (gdouble x) MONO_INTERNAL; +ves_icall_System_Math_Sqrt (gdouble x); #endif diff --git a/mono/metadata/threadpool-internals.h b/mono/metadata/threadpool-internals.h index 847a070d6a2..0d30705bfbc 100644 --- a/mono/metadata/threadpool-internals.h +++ b/mono/metadata/threadpool-internals.h @@ -20,18 +20,18 @@ typedef struct { void (*shutdown) (gpointer event_data); } SocketIOData; -void mono_thread_pool_remove_socket (int sock) MONO_INTERNAL; -gboolean mono_thread_pool_is_queue_array (MonoArray *o) MONO_INTERNAL; -void mono_internal_thread_unhandled_exception (MonoObject* exc) MONO_INTERNAL; +void mono_thread_pool_remove_socket (int sock); +gboolean mono_thread_pool_is_queue_array (MonoArray *o); +void mono_internal_thread_unhandled_exception (MonoObject* exc); //TP implementations -gpointer tp_poll_init (SocketIOData *data) MONO_INTERNAL; +gpointer tp_poll_init (SocketIOData *data); //TP internals the impls use -void check_for_interruption_critical (void) MONO_INTERNAL; -void socket_io_cleanup (SocketIOData *data) MONO_INTERNAL; -MonoObject *get_io_event (MonoMList **list, gint event) MONO_INTERNAL; -int get_events_from_list (MonoMList *list) MONO_INTERNAL; -void threadpool_append_async_io_jobs (MonoObject **jobs, gint njobs) MONO_INTERNAL; +void check_for_interruption_critical (void); +void socket_io_cleanup (SocketIOData *data); +MonoObject *get_io_event (MonoMList **list, gint event); +int get_events_from_list (MonoMList *list); +void threadpool_append_async_io_jobs (MonoObject **jobs, gint njobs); #endif diff --git a/mono/metadata/threadpool.h b/mono/metadata/threadpool.h index 81cea4ce1d4..2c9249e87ca 100644 --- a/mono/metadata/threadpool.h +++ b/mono/metadata/threadpool.h @@ -6,45 +6,45 @@ #include /* No managed code here */ -void mono_thread_pool_init (void) MONO_INTERNAL; -void mono_thread_pool_init_tls (void) MONO_INTERNAL; +void mono_thread_pool_init (void); +void mono_thread_pool_init_tls (void); -void icall_append_job (MonoObject *ar) MONO_INTERNAL; -void icall_append_io_job (MonoObject *target, MonoSocketAsyncResult *state) MONO_INTERNAL; +void icall_append_job (MonoObject *ar); +void icall_append_io_job (MonoObject *target, MonoSocketAsyncResult *state); MonoAsyncResult * mono_thread_pool_add (MonoObject *target, MonoMethodMessage *msg, - MonoDelegate *async_callback, MonoObject *state) MONO_INTERNAL; + MonoDelegate *async_callback, MonoObject *state); MonoObject * mono_thread_pool_finish (MonoAsyncResult *ares, MonoArray **out_args, - MonoObject **exc) MONO_INTERNAL; + MonoObject **exc); -void mono_thread_pool_cleanup (void) MONO_INTERNAL; +void mono_thread_pool_cleanup (void); -gboolean mono_thread_pool_remove_domain_jobs (MonoDomain *domain, int timeout) MONO_INTERNAL; +gboolean mono_thread_pool_remove_domain_jobs (MonoDomain *domain, int timeout); -void mono_thread_pool_suspend (void) MONO_INTERNAL; -void mono_thread_pool_resume (void) MONO_INTERNAL; +void mono_thread_pool_suspend (void); +void mono_thread_pool_resume (void); void ves_icall_System_Threading_ThreadPool_GetAvailableThreads (int *workerThreads, - int *completionPortThreads) MONO_INTERNAL; + int *completionPortThreads); void ves_icall_System_Threading_ThreadPool_GetMaxThreads (int *workerThreads, - int *completionPortThreads) MONO_INTERNAL; + int *completionPortThreads); void ves_icall_System_Threading_ThreadPool_GetMinThreads (gint *workerThreads, - gint *completionPortThreads) MONO_INTERNAL; + gint *completionPortThreads); MonoBoolean ves_icall_System_Threading_ThreadPool_SetMinThreads (gint workerThreads, - gint completionPortThreads) MONO_INTERNAL; + gint completionPortThreads); MonoBoolean ves_icall_System_Threading_ThreadPool_SetMaxThreads (gint workerThreads, - gint completionPortThreads) MONO_INTERNAL; + gint completionPortThreads); typedef void (*MonoThreadPoolFunc) (gpointer user_data); MONO_API void mono_install_threadpool_thread_hooks (MonoThreadPoolFunc start_func, MonoThreadPoolFunc finish_func, gpointer user_data); diff --git a/mono/metadata/threads-types.h b/mono/metadata/threads-types.h index 0e96e804e2a..7ed5a1f063f 100644 --- a/mono/metadata/threads-types.h +++ b/mono/metadata/threads-types.h @@ -63,201 +63,201 @@ typedef void (*MonoThreadCleanupFunc) (MonoInternalThread* thread); /* INFO has type MonoThreadInfo* */ typedef void (*MonoThreadNotifyPendingExcFunc) (gpointer info); -MonoInternalThread* mono_thread_create_internal (MonoDomain *domain, gpointer func, gpointer arg, gboolean threadpool_thread, guint32 stack_size) MONO_INTERNAL; - -void mono_threads_install_cleanup (MonoThreadCleanupFunc func) MONO_INTERNAL; - -void ves_icall_System_Threading_Thread_ConstructInternalThread (MonoThread *this_obj) MONO_INTERNAL; -HANDLE ves_icall_System_Threading_Thread_Thread_internal(MonoThread *this_obj, MonoObject *start) MONO_INTERNAL; -void ves_icall_System_Threading_InternalThread_Thread_free_internal(MonoInternalThread *this_obj, HANDLE thread) MONO_INTERNAL; -void ves_icall_System_Threading_Thread_Sleep_internal(gint32 ms) MONO_INTERNAL; -gboolean ves_icall_System_Threading_Thread_Join_internal(MonoInternalThread *this_obj, int ms, HANDLE thread) MONO_INTERNAL; -gint32 ves_icall_System_Threading_Thread_GetDomainID (void) MONO_INTERNAL; -gboolean ves_icall_System_Threading_Thread_Yield (void) MONO_INTERNAL; -MonoString* ves_icall_System_Threading_Thread_GetName_internal (MonoInternalThread *this_obj) MONO_INTERNAL; -void ves_icall_System_Threading_Thread_SetName_internal (MonoInternalThread *this_obj, MonoString *name) MONO_INTERNAL; -int ves_icall_System_Threading_Thread_GetPriority (MonoInternalThread *thread) MONO_INTERNAL; -void ves_icall_System_Threading_Thread_SetPriority (MonoInternalThread *thread, int priority) MONO_INTERNAL; -MonoObject* ves_icall_System_Threading_Thread_GetCachedCurrentCulture (MonoInternalThread *this_obj) MONO_INTERNAL; -void ves_icall_System_Threading_Thread_SetCachedCurrentCulture (MonoThread *this_obj, MonoObject *culture) MONO_INTERNAL; -MonoObject* ves_icall_System_Threading_Thread_GetCachedCurrentUICulture (MonoInternalThread *this_obj) MONO_INTERNAL; -void ves_icall_System_Threading_Thread_SetCachedCurrentUICulture (MonoThread *this_obj, MonoObject *culture) MONO_INTERNAL; -HANDLE ves_icall_System_Threading_Mutex_CreateMutex_internal(MonoBoolean owned, MonoString *name, MonoBoolean *created) MONO_INTERNAL; -MonoBoolean ves_icall_System_Threading_Mutex_ReleaseMutex_internal (HANDLE handle ) MONO_INTERNAL; -HANDLE ves_icall_System_Threading_Mutex_OpenMutex_internal (MonoString *name, gint32 rights, gint32 *error) MONO_INTERNAL; -HANDLE ves_icall_System_Threading_Semaphore_CreateSemaphore_internal (gint32 initialCount, gint32 maximumCount, MonoString *name, MonoBoolean *created) MONO_INTERNAL; -gint32 ves_icall_System_Threading_Semaphore_ReleaseSemaphore_internal (HANDLE handle, gint32 releaseCount, MonoBoolean *fail) MONO_INTERNAL; -HANDLE ves_icall_System_Threading_Semaphore_OpenSemaphore_internal (MonoString *name, gint32 rights, gint32 *error) MONO_INTERNAL; -HANDLE ves_icall_System_Threading_Events_CreateEvent_internal (MonoBoolean manual, MonoBoolean initial, MonoString *name, MonoBoolean *created) MONO_INTERNAL; -gboolean ves_icall_System_Threading_Events_SetEvent_internal (HANDLE handle) MONO_INTERNAL; -gboolean ves_icall_System_Threading_Events_ResetEvent_internal (HANDLE handle) MONO_INTERNAL; -void ves_icall_System_Threading_Events_CloseEvent_internal (HANDLE handle) MONO_INTERNAL; -HANDLE ves_icall_System_Threading_Events_OpenEvent_internal (MonoString *name, gint32 rights, gint32 *error) MONO_INTERNAL; - -gboolean ves_icall_System_Threading_WaitHandle_WaitAll_internal(MonoArray *mono_handles, gint32 ms, gboolean exitContext) MONO_INTERNAL; -gint32 ves_icall_System_Threading_WaitHandle_WaitAny_internal(MonoArray *mono_handles, gint32 ms, gboolean exitContext) MONO_INTERNAL; -gboolean ves_icall_System_Threading_WaitHandle_WaitOne_internal(MonoObject *this_obj, HANDLE handle, gint32 ms, gboolean exitContext) MONO_INTERNAL; -gboolean ves_icall_System_Threading_WaitHandle_SignalAndWait_Internal (HANDLE toSignal, HANDLE toWait, gint32 ms, gboolean exitContext) MONO_INTERNAL; - -MonoArray* ves_icall_System_Threading_Thread_ByteArrayToRootDomain (MonoArray *arr) MONO_INTERNAL; -MonoArray* ves_icall_System_Threading_Thread_ByteArrayToCurrentDomain (MonoArray *arr) MONO_INTERNAL; - -gint32 ves_icall_System_Threading_Interlocked_Increment_Int(gint32 *location) MONO_INTERNAL; -gint64 ves_icall_System_Threading_Interlocked_Increment_Long(gint64 *location) MONO_INTERNAL; -gint32 ves_icall_System_Threading_Interlocked_Decrement_Int(gint32 *location) MONO_INTERNAL; -gint64 ves_icall_System_Threading_Interlocked_Decrement_Long(gint64 * location) MONO_INTERNAL; - -gint32 ves_icall_System_Threading_Interlocked_Exchange_Int(gint32 *location, gint32 value) MONO_INTERNAL; -gint64 ves_icall_System_Threading_Interlocked_Exchange_Long(gint64 *location, gint64 value) MONO_INTERNAL; -MonoObject *ves_icall_System_Threading_Interlocked_Exchange_Object(MonoObject **location, MonoObject *value) MONO_INTERNAL; -gpointer ves_icall_System_Threading_Interlocked_Exchange_IntPtr(gpointer *location, gpointer value) MONO_INTERNAL; -gfloat ves_icall_System_Threading_Interlocked_Exchange_Single(gfloat *location, gfloat value) MONO_INTERNAL; -gdouble ves_icall_System_Threading_Interlocked_Exchange_Double(gdouble *location, gdouble value) MONO_INTERNAL; - -gint32 ves_icall_System_Threading_Interlocked_CompareExchange_Int(gint32 *location, gint32 value, gint32 comparand) MONO_INTERNAL; -gint32 ves_icall_System_Threading_Interlocked_CompareExchange_Int_Success(gint32 *location, gint32 value, gint32 comparand, MonoBoolean *success) MONO_INTERNAL; -gint64 ves_icall_System_Threading_Interlocked_CompareExchange_Long(gint64 *location, gint64 value, gint64 comparand) MONO_INTERNAL; -MonoObject *ves_icall_System_Threading_Interlocked_CompareExchange_Object(MonoObject **location, MonoObject *value, MonoObject *comparand) MONO_INTERNAL; -gpointer ves_icall_System_Threading_Interlocked_CompareExchange_IntPtr(gpointer *location, gpointer value, gpointer comparand) MONO_INTERNAL; -gfloat ves_icall_System_Threading_Interlocked_CompareExchange_Single(gfloat *location, gfloat value, gfloat comparand) MONO_INTERNAL; -gdouble ves_icall_System_Threading_Interlocked_CompareExchange_Double(gdouble *location, gdouble value, gdouble comparand) MONO_INTERNAL; -MonoObject* ves_icall_System_Threading_Interlocked_CompareExchange_T(MonoObject **location, MonoObject *value, MonoObject *comparand) MONO_INTERNAL; -MonoObject* ves_icall_System_Threading_Interlocked_Exchange_T(MonoObject **location, MonoObject *value) MONO_INTERNAL; - -gint32 ves_icall_System_Threading_Interlocked_Add_Int(gint32 *location, gint32 value) MONO_INTERNAL; -gint64 ves_icall_System_Threading_Interlocked_Add_Long(gint64 *location, gint64 value) MONO_INTERNAL; -gint64 ves_icall_System_Threading_Interlocked_Read_Long(gint64 *location) MONO_INTERNAL; - -gint32 ves_icall_System_Threading_Interlocked_Increment_Int(gint32 *location) MONO_INTERNAL; -gint64 ves_icall_System_Threading_Interlocked_Increment_Long(gint64 *location) MONO_INTERNAL; - -gint32 ves_icall_System_Threading_Interlocked_Decrement_Int(gint32 *location) MONO_INTERNAL; -gint64 ves_icall_System_Threading_Interlocked_Decrement_Long(gint64 * location) MONO_INTERNAL; - -void ves_icall_System_Threading_Thread_Abort (MonoInternalThread *thread, MonoObject *state) MONO_INTERNAL; -void ves_icall_System_Threading_Thread_ResetAbort (void) MONO_INTERNAL; -MonoObject* ves_icall_System_Threading_Thread_GetAbortExceptionState (MonoThread *thread) MONO_INTERNAL; -void ves_icall_System_Threading_Thread_Suspend (MonoInternalThread *thread) MONO_INTERNAL; -void ves_icall_System_Threading_Thread_Resume (MonoThread *thread) MONO_INTERNAL; -void ves_icall_System_Threading_Thread_ClrState (MonoInternalThread *thread, guint32 state) MONO_INTERNAL; -void ves_icall_System_Threading_Thread_SetState (MonoInternalThread *thread, guint32 state) MONO_INTERNAL; -guint32 ves_icall_System_Threading_Thread_GetState (MonoInternalThread *thread) MONO_INTERNAL; - -gint8 ves_icall_System_Threading_Thread_VolatileRead1 (void *ptr) MONO_INTERNAL; -gint16 ves_icall_System_Threading_Thread_VolatileRead2 (void *ptr) MONO_INTERNAL; -gint32 ves_icall_System_Threading_Thread_VolatileRead4 (void *ptr) MONO_INTERNAL; -gint64 ves_icall_System_Threading_Thread_VolatileRead8 (void *ptr) MONO_INTERNAL; -void * ves_icall_System_Threading_Thread_VolatileReadIntPtr (void *ptr) MONO_INTERNAL; -void * ves_icall_System_Threading_Thread_VolatileReadObject (void *ptr) MONO_INTERNAL; -double ves_icall_System_Threading_Thread_VolatileReadDouble (void *ptr) MONO_INTERNAL; -float ves_icall_System_Threading_Thread_VolatileReadFloat (void *ptr) MONO_INTERNAL; - -void ves_icall_System_Threading_Thread_VolatileWrite1 (void *ptr, gint8) MONO_INTERNAL; -void ves_icall_System_Threading_Thread_VolatileWrite2 (void *ptr, gint16) MONO_INTERNAL; -void ves_icall_System_Threading_Thread_VolatileWrite4 (void *ptr, gint32) MONO_INTERNAL; -void ves_icall_System_Threading_Thread_VolatileWrite8 (void *ptr, gint64) MONO_INTERNAL; -void ves_icall_System_Threading_Thread_VolatileWriteIntPtr (void *ptr, void *) MONO_INTERNAL; -void ves_icall_System_Threading_Thread_VolatileWriteObject (void *ptr, MonoObject *) MONO_INTERNAL; -void ves_icall_System_Threading_Thread_VolatileWriteFloat (void *ptr, float) MONO_INTERNAL; -void ves_icall_System_Threading_Thread_VolatileWriteDouble (void *ptr, double) MONO_INTERNAL; - -gint8 ves_icall_System_Threading_Volatile_Read1 (void *ptr) MONO_INTERNAL; -gint16 ves_icall_System_Threading_Volatile_Read2 (void *ptr) MONO_INTERNAL; -gint32 ves_icall_System_Threading_Volatile_Read4 (void *ptr) MONO_INTERNAL; -gint64 ves_icall_System_Threading_Volatile_Read8 (void *ptr) MONO_INTERNAL; -void * ves_icall_System_Threading_Volatile_ReadIntPtr (void *ptr) MONO_INTERNAL; -double ves_icall_System_Threading_Volatile_ReadDouble (void *ptr) MONO_INTERNAL; -float ves_icall_System_Threading_Volatile_ReadFloat (void *ptr) MONO_INTERNAL; -MonoObject* ves_icall_System_Threading_Volatile_Read_T (void *ptr) MONO_INTERNAL; - -void ves_icall_System_Threading_Volatile_Write1 (void *ptr, gint8) MONO_INTERNAL; -void ves_icall_System_Threading_Volatile_Write2 (void *ptr, gint16) MONO_INTERNAL; -void ves_icall_System_Threading_Volatile_Write4 (void *ptr, gint32) MONO_INTERNAL; -void ves_icall_System_Threading_Volatile_Write8 (void *ptr, gint64) MONO_INTERNAL; -void ves_icall_System_Threading_Volatile_WriteIntPtr (void *ptr, void *) MONO_INTERNAL; -void ves_icall_System_Threading_Volatile_WriteFloat (void *ptr, float) MONO_INTERNAL; -void ves_icall_System_Threading_Volatile_WriteDouble (void *ptr, double) MONO_INTERNAL; -void ves_icall_System_Threading_Volatile_Write_T (void *ptr, MonoObject *value) MONO_INTERNAL; - -void ves_icall_System_Threading_Thread_MemoryBarrier (void) MONO_INTERNAL; -void ves_icall_System_Threading_Thread_Interrupt_internal (MonoInternalThread *this_obj) MONO_INTERNAL; -void ves_icall_System_Threading_Thread_SpinWait_nop (void) MONO_INTERNAL; - -MonoInternalThread *mono_thread_internal_current (void) MONO_INTERNAL; - -void mono_thread_internal_stop (MonoInternalThread *thread) MONO_INTERNAL; - -gboolean mono_thread_internal_has_appdomain_ref (MonoInternalThread *thread, MonoDomain *domain) MONO_INTERNAL; - -void mono_thread_internal_reset_abort (MonoInternalThread *thread) MONO_INTERNAL; - -void mono_alloc_special_static_data_free (GHashTable *special_static_fields) MONO_INTERNAL; -void mono_special_static_data_free_slot (guint32 offset, guint32 size) MONO_INTERNAL; -uint32_t mono_thread_alloc_tls (MonoReflectionType *type) MONO_INTERNAL; -void mono_thread_destroy_tls (uint32_t tls_offset) MONO_INTERNAL; -void mono_thread_destroy_domain_tls (MonoDomain *domain) MONO_INTERNAL; -void mono_thread_free_local_slot_values (int slot, MonoBoolean is_thread_local) MONO_INTERNAL; -void mono_thread_current_check_pending_interrupt (void) MONO_INTERNAL; - -void mono_thread_set_state (MonoInternalThread *thread, MonoThreadState state) MONO_INTERNAL; -void mono_thread_clr_state (MonoInternalThread *thread, MonoThreadState state) MONO_INTERNAL; -gboolean mono_thread_test_state (MonoInternalThread *thread, MonoThreadState test) MONO_INTERNAL; - -void mono_thread_init_apartment_state (void) MONO_INTERNAL; -void mono_thread_cleanup_apartment_state (void) MONO_INTERNAL; - -void mono_threads_set_shutting_down (void) MONO_INTERNAL; - -gunichar2* mono_thread_get_name (MonoInternalThread *this_obj, guint32 *name_len) MONO_INTERNAL; +MonoInternalThread* mono_thread_create_internal (MonoDomain *domain, gpointer func, gpointer arg, gboolean threadpool_thread, guint32 stack_size); + +void mono_threads_install_cleanup (MonoThreadCleanupFunc func); + +void ves_icall_System_Threading_Thread_ConstructInternalThread (MonoThread *this_obj); +HANDLE ves_icall_System_Threading_Thread_Thread_internal(MonoThread *this_obj, MonoObject *start); +void ves_icall_System_Threading_InternalThread_Thread_free_internal(MonoInternalThread *this_obj, HANDLE thread); +void ves_icall_System_Threading_Thread_Sleep_internal(gint32 ms); +gboolean ves_icall_System_Threading_Thread_Join_internal(MonoInternalThread *this_obj, int ms, HANDLE thread); +gint32 ves_icall_System_Threading_Thread_GetDomainID (void); +gboolean ves_icall_System_Threading_Thread_Yield (void); +MonoString* ves_icall_System_Threading_Thread_GetName_internal (MonoInternalThread *this_obj); +void ves_icall_System_Threading_Thread_SetName_internal (MonoInternalThread *this_obj, MonoString *name); +int ves_icall_System_Threading_Thread_GetPriority (MonoInternalThread *thread); +void ves_icall_System_Threading_Thread_SetPriority (MonoInternalThread *thread, int priority); +MonoObject* ves_icall_System_Threading_Thread_GetCachedCurrentCulture (MonoInternalThread *this_obj); +void ves_icall_System_Threading_Thread_SetCachedCurrentCulture (MonoThread *this_obj, MonoObject *culture); +MonoObject* ves_icall_System_Threading_Thread_GetCachedCurrentUICulture (MonoInternalThread *this_obj); +void ves_icall_System_Threading_Thread_SetCachedCurrentUICulture (MonoThread *this_obj, MonoObject *culture); +HANDLE ves_icall_System_Threading_Mutex_CreateMutex_internal(MonoBoolean owned, MonoString *name, MonoBoolean *created); +MonoBoolean ves_icall_System_Threading_Mutex_ReleaseMutex_internal (HANDLE handle ); +HANDLE ves_icall_System_Threading_Mutex_OpenMutex_internal (MonoString *name, gint32 rights, gint32 *error); +HANDLE ves_icall_System_Threading_Semaphore_CreateSemaphore_internal (gint32 initialCount, gint32 maximumCount, MonoString *name, MonoBoolean *created); +gint32 ves_icall_System_Threading_Semaphore_ReleaseSemaphore_internal (HANDLE handle, gint32 releaseCount, MonoBoolean *fail); +HANDLE ves_icall_System_Threading_Semaphore_OpenSemaphore_internal (MonoString *name, gint32 rights, gint32 *error); +HANDLE ves_icall_System_Threading_Events_CreateEvent_internal (MonoBoolean manual, MonoBoolean initial, MonoString *name, MonoBoolean *created); +gboolean ves_icall_System_Threading_Events_SetEvent_internal (HANDLE handle); +gboolean ves_icall_System_Threading_Events_ResetEvent_internal (HANDLE handle); +void ves_icall_System_Threading_Events_CloseEvent_internal (HANDLE handle); +HANDLE ves_icall_System_Threading_Events_OpenEvent_internal (MonoString *name, gint32 rights, gint32 *error); + +gboolean ves_icall_System_Threading_WaitHandle_WaitAll_internal(MonoArray *mono_handles, gint32 ms, gboolean exitContext); +gint32 ves_icall_System_Threading_WaitHandle_WaitAny_internal(MonoArray *mono_handles, gint32 ms, gboolean exitContext); +gboolean ves_icall_System_Threading_WaitHandle_WaitOne_internal(MonoObject *this_obj, HANDLE handle, gint32 ms, gboolean exitContext); +gboolean ves_icall_System_Threading_WaitHandle_SignalAndWait_Internal (HANDLE toSignal, HANDLE toWait, gint32 ms, gboolean exitContext); + +MonoArray* ves_icall_System_Threading_Thread_ByteArrayToRootDomain (MonoArray *arr); +MonoArray* ves_icall_System_Threading_Thread_ByteArrayToCurrentDomain (MonoArray *arr); + +gint32 ves_icall_System_Threading_Interlocked_Increment_Int(gint32 *location); +gint64 ves_icall_System_Threading_Interlocked_Increment_Long(gint64 *location); +gint32 ves_icall_System_Threading_Interlocked_Decrement_Int(gint32 *location); +gint64 ves_icall_System_Threading_Interlocked_Decrement_Long(gint64 * location); + +gint32 ves_icall_System_Threading_Interlocked_Exchange_Int(gint32 *location, gint32 value); +gint64 ves_icall_System_Threading_Interlocked_Exchange_Long(gint64 *location, gint64 value); +MonoObject *ves_icall_System_Threading_Interlocked_Exchange_Object(MonoObject **location, MonoObject *value); +gpointer ves_icall_System_Threading_Interlocked_Exchange_IntPtr(gpointer *location, gpointer value); +gfloat ves_icall_System_Threading_Interlocked_Exchange_Single(gfloat *location, gfloat value); +gdouble ves_icall_System_Threading_Interlocked_Exchange_Double(gdouble *location, gdouble value); + +gint32 ves_icall_System_Threading_Interlocked_CompareExchange_Int(gint32 *location, gint32 value, gint32 comparand); +gint32 ves_icall_System_Threading_Interlocked_CompareExchange_Int_Success(gint32 *location, gint32 value, gint32 comparand, MonoBoolean *success); +gint64 ves_icall_System_Threading_Interlocked_CompareExchange_Long(gint64 *location, gint64 value, gint64 comparand); +MonoObject *ves_icall_System_Threading_Interlocked_CompareExchange_Object(MonoObject **location, MonoObject *value, MonoObject *comparand); +gpointer ves_icall_System_Threading_Interlocked_CompareExchange_IntPtr(gpointer *location, gpointer value, gpointer comparand); +gfloat ves_icall_System_Threading_Interlocked_CompareExchange_Single(gfloat *location, gfloat value, gfloat comparand); +gdouble ves_icall_System_Threading_Interlocked_CompareExchange_Double(gdouble *location, gdouble value, gdouble comparand); +MonoObject* ves_icall_System_Threading_Interlocked_CompareExchange_T(MonoObject **location, MonoObject *value, MonoObject *comparand); +MonoObject* ves_icall_System_Threading_Interlocked_Exchange_T(MonoObject **location, MonoObject *value); + +gint32 ves_icall_System_Threading_Interlocked_Add_Int(gint32 *location, gint32 value); +gint64 ves_icall_System_Threading_Interlocked_Add_Long(gint64 *location, gint64 value); +gint64 ves_icall_System_Threading_Interlocked_Read_Long(gint64 *location); + +gint32 ves_icall_System_Threading_Interlocked_Increment_Int(gint32 *location); +gint64 ves_icall_System_Threading_Interlocked_Increment_Long(gint64 *location); + +gint32 ves_icall_System_Threading_Interlocked_Decrement_Int(gint32 *location); +gint64 ves_icall_System_Threading_Interlocked_Decrement_Long(gint64 * location); + +void ves_icall_System_Threading_Thread_Abort (MonoInternalThread *thread, MonoObject *state); +void ves_icall_System_Threading_Thread_ResetAbort (void); +MonoObject* ves_icall_System_Threading_Thread_GetAbortExceptionState (MonoThread *thread); +void ves_icall_System_Threading_Thread_Suspend (MonoInternalThread *thread); +void ves_icall_System_Threading_Thread_Resume (MonoThread *thread); +void ves_icall_System_Threading_Thread_ClrState (MonoInternalThread *thread, guint32 state); +void ves_icall_System_Threading_Thread_SetState (MonoInternalThread *thread, guint32 state); +guint32 ves_icall_System_Threading_Thread_GetState (MonoInternalThread *thread); + +gint8 ves_icall_System_Threading_Thread_VolatileRead1 (void *ptr); +gint16 ves_icall_System_Threading_Thread_VolatileRead2 (void *ptr); +gint32 ves_icall_System_Threading_Thread_VolatileRead4 (void *ptr); +gint64 ves_icall_System_Threading_Thread_VolatileRead8 (void *ptr); +void * ves_icall_System_Threading_Thread_VolatileReadIntPtr (void *ptr); +void * ves_icall_System_Threading_Thread_VolatileReadObject (void *ptr); +double ves_icall_System_Threading_Thread_VolatileReadDouble (void *ptr); +float ves_icall_System_Threading_Thread_VolatileReadFloat (void *ptr); + +void ves_icall_System_Threading_Thread_VolatileWrite1 (void *ptr, gint8); +void ves_icall_System_Threading_Thread_VolatileWrite2 (void *ptr, gint16); +void ves_icall_System_Threading_Thread_VolatileWrite4 (void *ptr, gint32); +void ves_icall_System_Threading_Thread_VolatileWrite8 (void *ptr, gint64); +void ves_icall_System_Threading_Thread_VolatileWriteIntPtr (void *ptr, void *); +void ves_icall_System_Threading_Thread_VolatileWriteObject (void *ptr, MonoObject *); +void ves_icall_System_Threading_Thread_VolatileWriteFloat (void *ptr, float); +void ves_icall_System_Threading_Thread_VolatileWriteDouble (void *ptr, double); + +gint8 ves_icall_System_Threading_Volatile_Read1 (void *ptr); +gint16 ves_icall_System_Threading_Volatile_Read2 (void *ptr); +gint32 ves_icall_System_Threading_Volatile_Read4 (void *ptr); +gint64 ves_icall_System_Threading_Volatile_Read8 (void *ptr); +void * ves_icall_System_Threading_Volatile_ReadIntPtr (void *ptr); +double ves_icall_System_Threading_Volatile_ReadDouble (void *ptr); +float ves_icall_System_Threading_Volatile_ReadFloat (void *ptr); +MonoObject* ves_icall_System_Threading_Volatile_Read_T (void *ptr); + +void ves_icall_System_Threading_Volatile_Write1 (void *ptr, gint8); +void ves_icall_System_Threading_Volatile_Write2 (void *ptr, gint16); +void ves_icall_System_Threading_Volatile_Write4 (void *ptr, gint32); +void ves_icall_System_Threading_Volatile_Write8 (void *ptr, gint64); +void ves_icall_System_Threading_Volatile_WriteIntPtr (void *ptr, void *); +void ves_icall_System_Threading_Volatile_WriteFloat (void *ptr, float); +void ves_icall_System_Threading_Volatile_WriteDouble (void *ptr, double); +void ves_icall_System_Threading_Volatile_Write_T (void *ptr, MonoObject *value); + +void ves_icall_System_Threading_Thread_MemoryBarrier (void); +void ves_icall_System_Threading_Thread_Interrupt_internal (MonoInternalThread *this_obj); +void ves_icall_System_Threading_Thread_SpinWait_nop (void); + +MonoInternalThread *mono_thread_internal_current (void); + +void mono_thread_internal_stop (MonoInternalThread *thread); + +gboolean mono_thread_internal_has_appdomain_ref (MonoInternalThread *thread, MonoDomain *domain); + +void mono_thread_internal_reset_abort (MonoInternalThread *thread); + +void mono_alloc_special_static_data_free (GHashTable *special_static_fields); +void mono_special_static_data_free_slot (guint32 offset, guint32 size); +uint32_t mono_thread_alloc_tls (MonoReflectionType *type); +void mono_thread_destroy_tls (uint32_t tls_offset); +void mono_thread_destroy_domain_tls (MonoDomain *domain); +void mono_thread_free_local_slot_values (int slot, MonoBoolean is_thread_local); +void mono_thread_current_check_pending_interrupt (void); + +void mono_thread_set_state (MonoInternalThread *thread, MonoThreadState state); +void mono_thread_clr_state (MonoInternalThread *thread, MonoThreadState state); +gboolean mono_thread_test_state (MonoInternalThread *thread, MonoThreadState test); + +void mono_thread_init_apartment_state (void); +void mono_thread_cleanup_apartment_state (void); + +void mono_threads_set_shutting_down (void); + +gunichar2* mono_thread_get_name (MonoInternalThread *this_obj, guint32 *name_len); MONO_API MonoException* mono_thread_get_undeniable_exception (void); -MonoException* mono_thread_get_and_clear_pending_exception (void) MONO_INTERNAL; +MonoException* mono_thread_get_and_clear_pending_exception (void); -void mono_thread_set_name_internal (MonoInternalThread *this_obj, MonoString *name, gboolean managed) MONO_INTERNAL; +void mono_thread_set_name_internal (MonoInternalThread *this_obj, MonoString *name, gboolean managed); -void mono_threads_install_notify_pending_exc (MonoThreadNotifyPendingExcFunc func) MONO_INTERNAL; +void mono_threads_install_notify_pending_exc (MonoThreadNotifyPendingExcFunc func); -MonoObject* mono_thread_get_execution_context (void) MONO_INTERNAL; -void mono_thread_set_execution_context (MonoObject *ec) MONO_INTERNAL; +MonoObject* mono_thread_get_execution_context (void); +void mono_thread_set_execution_context (MonoObject *ec); -void mono_runtime_set_has_tls_get (gboolean val) MONO_INTERNAL; -gboolean mono_runtime_has_tls_get (void) MONO_INTERNAL; +void mono_runtime_set_has_tls_get (gboolean val); +gboolean mono_runtime_has_tls_get (void); -int mono_thread_get_abort_signal (void) MONO_INTERNAL; +int mono_thread_get_abort_signal (void); -void mono_thread_abort_all_other_threads (void) MONO_INTERNAL; -void mono_thread_suspend_all_other_threads (void) MONO_INTERNAL; -gboolean mono_threads_abort_appdomain_threads (MonoDomain *domain, int timeout) MONO_INTERNAL; +void mono_thread_abort_all_other_threads (void); +void mono_thread_suspend_all_other_threads (void); +gboolean mono_threads_abort_appdomain_threads (MonoDomain *domain, int timeout); -void mono_thread_push_appdomain_ref (MonoDomain *domain) MONO_INTERNAL; -void mono_thread_pop_appdomain_ref (void) MONO_INTERNAL; -gboolean mono_thread_has_appdomain_ref (MonoThread *thread, MonoDomain *domain) MONO_INTERNAL; +void mono_thread_push_appdomain_ref (MonoDomain *domain); +void mono_thread_pop_appdomain_ref (void); +gboolean mono_thread_has_appdomain_ref (MonoThread *thread, MonoDomain *domain); -void mono_threads_clear_cached_culture (MonoDomain *domain) MONO_INTERNAL; +void mono_threads_clear_cached_culture (MonoDomain *domain); -MonoException* mono_thread_request_interruption (mono_bool running_managed) MONO_INTERNAL; -gboolean mono_thread_interruption_requested (void) MONO_INTERNAL; -MonoException* mono_thread_interruption_checkpoint (void) MONO_INTERNAL; -MonoException* mono_thread_force_interruption_checkpoint_noraise (void) MONO_INTERNAL; -void mono_thread_force_interruption_checkpoint (void) MONO_INTERNAL; -gint32* mono_thread_interruption_request_flag (void) MONO_INTERNAL; +MonoException* mono_thread_request_interruption (mono_bool running_managed); +gboolean mono_thread_interruption_requested (void); +MonoException* mono_thread_interruption_checkpoint (void); +MonoException* mono_thread_force_interruption_checkpoint_noraise (void); +void mono_thread_force_interruption_checkpoint (void); +gint32* mono_thread_interruption_request_flag (void); -uint32_t mono_alloc_special_static_data (uint32_t static_type, uint32_t size, uint32_t align, uintptr_t *bitmap, int numbits) MONO_INTERNAL; -void* mono_get_special_static_data (uint32_t offset) MONO_INTERNAL; -gpointer mono_get_special_static_data_for_thread (MonoInternalThread *thread, guint32 offset) MONO_INTERNAL; +uint32_t mono_alloc_special_static_data (uint32_t static_type, uint32_t size, uint32_t align, uintptr_t *bitmap, int numbits); +void* mono_get_special_static_data (uint32_t offset); +gpointer mono_get_special_static_data_for_thread (MonoInternalThread *thread, guint32 offset); -MonoException* mono_thread_resume_interruption (void) MONO_INTERNAL; -void mono_threads_perform_thread_dump (void) MONO_INTERNAL; -MonoThread *mono_thread_attach_full (MonoDomain *domain, gboolean force_attach) MONO_INTERNAL; +MonoException* mono_thread_resume_interruption (void); +void mono_threads_perform_thread_dump (void); +MonoThread *mono_thread_attach_full (MonoDomain *domain, gboolean force_attach); -void mono_thread_init_tls (void) MONO_INTERNAL; +void mono_thread_init_tls (void); /* Can't include utils/mono-threads.h because of the THREAD_INFO_TYPE wizardry */ -void mono_threads_add_joinable_thread (gpointer tid) MONO_INTERNAL; -void mono_threads_join_threads (void) MONO_INTERNAL; -void mono_thread_join (gpointer tid) MONO_INTERNAL; +void mono_threads_add_joinable_thread (gpointer tid); +void mono_threads_join_threads (void); +void mono_thread_join (gpointer tid); -void mono_thread_detach_internal (MonoInternalThread *thread) MONO_INTERNAL; +void mono_thread_detach_internal (MonoInternalThread *thread); #endif /* _MONO_METADATA_THREADS_TYPES_H_ */ diff --git a/mono/metadata/verify-internals.h b/mono/metadata/verify-internals.h index d02816f656a..341b7292557 100644 --- a/mono/metadata/verify-internals.h +++ b/mono/metadata/verify-internals.h @@ -15,44 +15,44 @@ typedef enum { MONO_VERIFIER_MODE_STRICT } MiniVerifierMode; -void mono_verifier_set_mode (MiniVerifierMode mode) MONO_INTERNAL; -void mono_verifier_enable_verify_all (void) MONO_INTERNAL; - -gboolean mono_verifier_is_enabled_for_image (MonoImage *image) MONO_INTERNAL; -gboolean mono_verifier_is_enabled_for_method (MonoMethod *method) MONO_INTERNAL; -gboolean mono_verifier_is_enabled_for_class (MonoClass *klass) MONO_INTERNAL; - -gboolean mono_verifier_is_method_full_trust (MonoMethod *method) MONO_INTERNAL; -gboolean mono_verifier_is_class_full_trust (MonoClass *klass) MONO_INTERNAL; -gboolean mono_verifier_class_is_valid_generic_instantiation (MonoClass *klass) MONO_INTERNAL; -gboolean mono_verifier_is_method_valid_generic_instantiation (MonoMethod *method) MONO_INTERNAL; - -gboolean mono_verifier_verify_class (MonoClass *klass) MONO_INTERNAL; - -GSList* mono_method_verify_with_current_settings (MonoMethod *method, gboolean skip_visibility, gboolean is_fulltrust) MONO_INTERNAL; - -gboolean mono_verifier_verify_pe_data (MonoImage *image, GSList **error_list) MONO_INTERNAL; -gboolean mono_verifier_verify_cli_data (MonoImage *image, GSList **error_list) MONO_INTERNAL; -gboolean mono_verifier_verify_table_data (MonoImage *image, GSList **error_list) MONO_INTERNAL; - -gboolean mono_verifier_verify_full_table_data (MonoImage *image, GSList **error_list) MONO_INTERNAL; - -gboolean mono_verifier_verify_field_signature (MonoImage *image, guint32 offset, GSList **error_list) MONO_INTERNAL; -gboolean mono_verifier_verify_method_header (MonoImage *image, guint32 offset, GSList **error_list) MONO_INTERNAL; -gboolean mono_verifier_verify_method_signature (MonoImage *image, guint32 offset, MonoError *error) MONO_INTERNAL; -gboolean mono_verifier_verify_standalone_signature (MonoImage *image, guint32 offset, GSList **error_list) MONO_INTERNAL; -gboolean mono_verifier_verify_typespec_signature (MonoImage *image, guint32 offset, guint32 token, GSList **error_list) MONO_INTERNAL; -gboolean mono_verifier_verify_methodspec_signature (MonoImage *image, guint32 offset, GSList **error_list) MONO_INTERNAL; -gboolean mono_verifier_verify_string_signature (MonoImage *image, guint32 offset, GSList **error_list) MONO_INTERNAL; -gboolean mono_verifier_verify_cattr_blob (MonoImage *image, guint32 offset, GSList **error_list) MONO_INTERNAL; -gboolean mono_verifier_verify_cattr_content (MonoImage *image, MonoMethod *ctor, const guchar *data, guint32 size, GSList **error_list) MONO_INTERNAL; -gboolean mono_verifier_is_sig_compatible (MonoImage *image, MonoMethod *method, MonoMethodSignature *signature) MONO_INTERNAL; -gboolean mono_verifier_verify_memberref_method_signature (MonoImage *image, guint32 offset, GSList **error_list) MONO_INTERNAL; -gboolean mono_verifier_verify_memberref_field_signature (MonoImage *image, guint32 offset, GSList **error_list) MONO_INTERNAL; - -gboolean mono_verifier_verify_typeref_row (MonoImage *image, guint32 row, MonoError *error) MONO_INTERNAL; -gboolean mono_verifier_verify_methodimpl_row (MonoImage *image, guint32 row, MonoError *error) MONO_INTERNAL; -gboolean mono_verifier_is_signature_compatible (MonoMethodSignature *target, MonoMethodSignature *candidate) MONO_INTERNAL; +void mono_verifier_set_mode (MiniVerifierMode mode); +void mono_verifier_enable_verify_all (void); + +gboolean mono_verifier_is_enabled_for_image (MonoImage *image); +gboolean mono_verifier_is_enabled_for_method (MonoMethod *method); +gboolean mono_verifier_is_enabled_for_class (MonoClass *klass); + +gboolean mono_verifier_is_method_full_trust (MonoMethod *method); +gboolean mono_verifier_is_class_full_trust (MonoClass *klass); +gboolean mono_verifier_class_is_valid_generic_instantiation (MonoClass *klass); +gboolean mono_verifier_is_method_valid_generic_instantiation (MonoMethod *method); + +gboolean mono_verifier_verify_class (MonoClass *klass); + +GSList* mono_method_verify_with_current_settings (MonoMethod *method, gboolean skip_visibility, gboolean is_fulltrust); + +gboolean mono_verifier_verify_pe_data (MonoImage *image, GSList **error_list); +gboolean mono_verifier_verify_cli_data (MonoImage *image, GSList **error_list); +gboolean mono_verifier_verify_table_data (MonoImage *image, GSList **error_list); + +gboolean mono_verifier_verify_full_table_data (MonoImage *image, GSList **error_list); + +gboolean mono_verifier_verify_field_signature (MonoImage *image, guint32 offset, GSList **error_list); +gboolean mono_verifier_verify_method_header (MonoImage *image, guint32 offset, GSList **error_list); +gboolean mono_verifier_verify_method_signature (MonoImage *image, guint32 offset, MonoError *error); +gboolean mono_verifier_verify_standalone_signature (MonoImage *image, guint32 offset, GSList **error_list); +gboolean mono_verifier_verify_typespec_signature (MonoImage *image, guint32 offset, guint32 token, GSList **error_list); +gboolean mono_verifier_verify_methodspec_signature (MonoImage *image, guint32 offset, GSList **error_list); +gboolean mono_verifier_verify_string_signature (MonoImage *image, guint32 offset, GSList **error_list); +gboolean mono_verifier_verify_cattr_blob (MonoImage *image, guint32 offset, GSList **error_list); +gboolean mono_verifier_verify_cattr_content (MonoImage *image, MonoMethod *ctor, const guchar *data, guint32 size, GSList **error_list); +gboolean mono_verifier_is_sig_compatible (MonoImage *image, MonoMethod *method, MonoMethodSignature *signature); +gboolean mono_verifier_verify_memberref_method_signature (MonoImage *image, guint32 offset, GSList **error_list); +gboolean mono_verifier_verify_memberref_field_signature (MonoImage *image, guint32 offset, GSList **error_list); + +gboolean mono_verifier_verify_typeref_row (MonoImage *image, guint32 row, MonoError *error); +gboolean mono_verifier_verify_methodimpl_row (MonoImage *image, guint32 row, MonoError *error); +gboolean mono_verifier_is_signature_compatible (MonoMethodSignature *target, MonoMethodSignature *candidate); G_END_DECLS #endif /* __MONO_METADATA_VERIFY_INTERNAL_H__ */ diff --git a/mono/utils/hazard-pointer.h b/mono/utils/hazard-pointer.h index ff50b166780..1e49bc1770a 100644 --- a/mono/utils/hazard-pointer.h +++ b/mono/utils/hazard-pointer.h @@ -19,11 +19,11 @@ typedef struct { typedef void (*MonoHazardousFreeFunc) (gpointer p); void mono_thread_hazardous_free_or_queue (gpointer p, MonoHazardousFreeFunc free_func, - gboolean free_func_might_lock, gboolean lock_free_context) MONO_INTERNAL; -void mono_thread_hazardous_try_free_all (void) MONO_INTERNAL; -void mono_thread_hazardous_try_free_some (void) MONO_INTERNAL; -MonoThreadHazardPointers* mono_hazard_pointer_get (void) MONO_INTERNAL; -gpointer get_hazardous_pointer (gpointer volatile *pp, MonoThreadHazardPointers *hp, int hazard_index) MONO_INTERNAL; + gboolean free_func_might_lock, gboolean lock_free_context); +void mono_thread_hazardous_try_free_all (void); +void mono_thread_hazardous_try_free_some (void); +MonoThreadHazardPointers* mono_hazard_pointer_get (void); +gpointer get_hazardous_pointer (gpointer volatile *pp, MonoThreadHazardPointers *hp, int hazard_index); #define mono_hazard_pointer_set(hp,i,v) \ do { g_assert ((i) >= 0 && (i) < HAZARD_POINTER_COUNT); \ @@ -40,12 +40,12 @@ gpointer get_hazardous_pointer (gpointer volatile *pp, MonoThreadHazardPointers } while (0) -void mono_thread_small_id_free (int id) MONO_INTERNAL; -int mono_thread_small_id_alloc (void) MONO_INTERNAL; +void mono_thread_small_id_free (int id); +int mono_thread_small_id_alloc (void); -int mono_hazard_pointer_save_for_signal_handler (void) MONO_INTERNAL; -void mono_hazard_pointer_restore_for_signal_handler (int small_id) MONO_INTERNAL; +int mono_hazard_pointer_save_for_signal_handler (void); +void mono_hazard_pointer_restore_for_signal_handler (int small_id); -void mono_thread_smr_init (void) MONO_INTERNAL; -void mono_thread_smr_cleanup (void) MONO_INTERNAL; +void mono_thread_smr_init (void); +void mono_thread_smr_cleanup (void); #endif /*__MONO_HAZARD_POINTER_H__*/ diff --git a/mono/utils/lock-free-alloc.h b/mono/utils/lock-free-alloc.h index 84935646d37..9cbfdec5e99 100644 --- a/mono/utils/lock-free-alloc.h +++ b/mono/utils/lock-free-alloc.h @@ -47,12 +47,12 @@ typedef struct { #define LOCK_FREE_ALLOC_SB_HEADER_SIZE (sizeof (MonoLockFreeAllocator)) #define LOCK_FREE_ALLOC_SB_USABLE_SIZE(block_size) ((block_size) - LOCK_FREE_ALLOC_SB_HEADER_SIZE) -void mono_lock_free_allocator_init_size_class (MonoLockFreeAllocSizeClass *sc, unsigned int slot_size, unsigned int block_size) MONO_INTERNAL; -void mono_lock_free_allocator_init_allocator (MonoLockFreeAllocator *heap, MonoLockFreeAllocSizeClass *sc) MONO_INTERNAL; +void mono_lock_free_allocator_init_size_class (MonoLockFreeAllocSizeClass *sc, unsigned int slot_size, unsigned int block_size); +void mono_lock_free_allocator_init_allocator (MonoLockFreeAllocator *heap, MonoLockFreeAllocSizeClass *sc); -gpointer mono_lock_free_alloc (MonoLockFreeAllocator *heap) MONO_INTERNAL; -void mono_lock_free_free (gpointer ptr, size_t block_size) MONO_INTERNAL; +gpointer mono_lock_free_alloc (MonoLockFreeAllocator *heap); +void mono_lock_free_free (gpointer ptr, size_t block_size); -gboolean mono_lock_free_allocator_check_consistency (MonoLockFreeAllocator *heap) MONO_INTERNAL; +gboolean mono_lock_free_allocator_check_consistency (MonoLockFreeAllocator *heap); #endif diff --git a/mono/utils/lock-free-array-queue.h b/mono/utils/lock-free-array-queue.h index 3dd8b100eb8..620025153de 100644 --- a/mono/utils/lock-free-array-queue.h +++ b/mono/utils/lock-free-array-queue.h @@ -25,16 +25,16 @@ typedef struct { #define MONO_LOCK_FREE_ARRAY_INIT(entry_size) { (entry_size), NULL } #define MONO_LOCK_FREE_ARRAY_QUEUE_INIT(entry_size) { MONO_LOCK_FREE_ARRAY_INIT ((entry_size) + sizeof (gpointer)), 0 } -gpointer mono_lock_free_array_nth (MonoLockFreeArray *arr, int index) MONO_INTERNAL; +gpointer mono_lock_free_array_nth (MonoLockFreeArray *arr, int index); typedef gpointer (*MonoLockFreeArrayIterateFunc) (int index, gpointer entry_ptr, gpointer user_data); -gpointer mono_lock_free_array_iterate (MonoLockFreeArray *arr, MonoLockFreeArrayIterateFunc func, gpointer user_data) MONO_INTERNAL; +gpointer mono_lock_free_array_iterate (MonoLockFreeArray *arr, MonoLockFreeArrayIterateFunc func, gpointer user_data); -void mono_lock_free_array_cleanup (MonoLockFreeArray *arr) MONO_INTERNAL; +void mono_lock_free_array_cleanup (MonoLockFreeArray *arr); -void mono_lock_free_array_queue_push (MonoLockFreeArrayQueue *q, gpointer entry_data_ptr) MONO_INTERNAL; -gboolean mono_lock_free_array_queue_pop (MonoLockFreeArrayQueue *q, gpointer entry_data_ptr) MONO_INTERNAL; +void mono_lock_free_array_queue_push (MonoLockFreeArrayQueue *q, gpointer entry_data_ptr); +gboolean mono_lock_free_array_queue_pop (MonoLockFreeArrayQueue *q, gpointer entry_data_ptr); -void mono_lock_free_array_queue_cleanup (MonoLockFreeArrayQueue *q) MONO_INTERNAL; +void mono_lock_free_array_queue_cleanup (MonoLockFreeArrayQueue *q); #endif diff --git a/mono/utils/lock-free-queue.h b/mono/utils/lock-free-queue.h index 32fec4cad3d..2dd4948b78e 100644 --- a/mono/utils/lock-free-queue.h +++ b/mono/utils/lock-free-queue.h @@ -55,13 +55,13 @@ typedef struct { volatile gint32 has_dummy; } MonoLockFreeQueue; -void mono_lock_free_queue_init (MonoLockFreeQueue *q) MONO_INTERNAL; +void mono_lock_free_queue_init (MonoLockFreeQueue *q); -void mono_lock_free_queue_node_init (MonoLockFreeQueueNode *node, gboolean to_be_freed) MONO_INTERNAL; -void mono_lock_free_queue_node_free (MonoLockFreeQueueNode *node) MONO_INTERNAL; +void mono_lock_free_queue_node_init (MonoLockFreeQueueNode *node, gboolean to_be_freed); +void mono_lock_free_queue_node_free (MonoLockFreeQueueNode *node); -void mono_lock_free_queue_enqueue (MonoLockFreeQueue *q, MonoLockFreeQueueNode *node) MONO_INTERNAL; +void mono_lock_free_queue_enqueue (MonoLockFreeQueue *q, MonoLockFreeQueueNode *node); -MonoLockFreeQueueNode* mono_lock_free_queue_dequeue (MonoLockFreeQueue *q) MONO_INTERNAL; +MonoLockFreeQueueNode* mono_lock_free_queue_dequeue (MonoLockFreeQueue *q); #endif diff --git a/mono/utils/mach-support.h b/mono/utils/mach-support.h index 8d8bb1e9037..940cf0356a0 100644 --- a/mono/utils/mach-support.h +++ b/mono/utils/mach-support.h @@ -23,21 +23,21 @@ typedef _STRUCT_MCONTEXT64 *mcontext_t; // and the pthread header guards against this extern pthread_t pthread_from_mach_thread_np(mach_port_t); -void *mono_mach_arch_get_ip (thread_state_t state) MONO_INTERNAL; -void *mono_mach_arch_get_sp (thread_state_t state) MONO_INTERNAL; -void mono_mach_init (pthread_key_t key) MONO_INTERNAL; +void *mono_mach_arch_get_ip (thread_state_t state); +void *mono_mach_arch_get_sp (thread_state_t state); +void mono_mach_init (pthread_key_t key); -int mono_mach_arch_get_mcontext_size (void) MONO_INTERNAL; -void mono_mach_arch_thread_state_to_mcontext (thread_state_t state, void *context) MONO_INTERNAL; -void mono_mach_arch_mcontext_to_thread_state (void *context, thread_state_t state) MONO_INTERNAL; +int mono_mach_arch_get_mcontext_size (void); +void mono_mach_arch_thread_state_to_mcontext (thread_state_t state, void *context); +void mono_mach_arch_mcontext_to_thread_state (void *context, thread_state_t state); -int mono_mach_arch_get_thread_state_size (void) MONO_INTERNAL; -kern_return_t mono_mach_get_threads (thread_act_array_t *threads, guint32 *count) MONO_INTERNAL; -kern_return_t mono_mach_free_threads (thread_act_array_t threads, guint32 count) MONO_INTERNAL; -kern_return_t mono_mach_arch_get_thread_state (thread_port_t thread, thread_state_t state, mach_msg_type_number_t *count) MONO_INTERNAL; -kern_return_t mono_mach_arch_set_thread_state (thread_port_t thread, thread_state_t state, mach_msg_type_number_t count) MONO_INTERNAL; -void *mono_mach_arch_get_tls_value_from_thread (pthread_t thread, guint32 key) MONO_INTERNAL; -void *mono_mach_get_tls_address_from_thread (pthread_t thread, pthread_key_t key) MONO_INTERNAL; +int mono_mach_arch_get_thread_state_size (void); +kern_return_t mono_mach_get_threads (thread_act_array_t *threads, guint32 *count); +kern_return_t mono_mach_free_threads (thread_act_array_t threads, guint32 count); +kern_return_t mono_mach_arch_get_thread_state (thread_port_t thread, thread_state_t state, mach_msg_type_number_t *count); +kern_return_t mono_mach_arch_set_thread_state (thread_port_t thread, thread_state_t state, mach_msg_type_number_t count); +void *mono_mach_arch_get_tls_value_from_thread (pthread_t thread, guint32 key); +void *mono_mach_get_tls_address_from_thread (pthread_t thread, pthread_key_t key); #endif #endif /* __MONO_MACH_SUPPORT_H__ */ diff --git a/mono/utils/mono-compiler.h b/mono/utils/mono-compiler.h index 97dd7ef9842..322b9124be9 100644 --- a/mono/utils/mono-compiler.h +++ b/mono/utils/mono-compiler.h @@ -242,14 +242,12 @@ typedef SSIZE_T ssize_t; #endif /* _MSC_VER */ #if !defined(_MSC_VER) && !defined(PLATFORM_SOLARIS) && !defined(_WIN32) && !defined(__CYGWIN__) && !defined(MONOTOUCH) && HAVE_VISIBILITY_HIDDEN -#define MONO_INTERNAL __attribute__ ((visibility ("hidden"))) #if MONO_LLVM_LOADED #define MONO_LLVM_INTERNAL MONO_API #else -#define MONO_LLVM_INTERNAL MONO_INTERNAL +#define MONO_LLVM_INTERNAL #endif #else -#define MONO_INTERNAL #define MONO_LLVM_INTERNAL #endif diff --git a/mono/utils/mono-conc-hashtable.h b/mono/utils/mono-conc-hashtable.h index 65792bc54c8..6a90ff0fbd6 100644 --- a/mono/utils/mono-conc-hashtable.h +++ b/mono/utils/mono-conc-hashtable.h @@ -16,12 +16,12 @@ typedef struct _MonoConcurrentHashTable MonoConcurrentHashTable; -MonoConcurrentHashTable* mono_conc_hashtable_new (mono_mutex_t *mutex, GHashFunc hash_func, GEqualFunc key_equal_func) MONO_INTERNAL; -MonoConcurrentHashTable* mono_conc_hashtable_new_full (mono_mutex_t *mutex, GHashFunc hash_func, GEqualFunc key_equal_func, GDestroyNotify key_destroy_func, GDestroyNotify value_destroy_func) MONO_INTERNAL; -void mono_conc_hashtable_destroy (MonoConcurrentHashTable *hash_table) MONO_INTERNAL; -gpointer mono_conc_hashtable_lookup (MonoConcurrentHashTable *hash_table, gpointer key) MONO_INTERNAL; -gpointer mono_conc_hashtable_insert (MonoConcurrentHashTable *hash_table, gpointer key, gpointer value) MONO_INTERNAL; -gpointer mono_conc_hashtable_remove (MonoConcurrentHashTable *hash_table, gpointer key) MONO_INTERNAL; +MonoConcurrentHashTable* mono_conc_hashtable_new (mono_mutex_t *mutex, GHashFunc hash_func, GEqualFunc key_equal_func); +MonoConcurrentHashTable* mono_conc_hashtable_new_full (mono_mutex_t *mutex, GHashFunc hash_func, GEqualFunc key_equal_func, GDestroyNotify key_destroy_func, GDestroyNotify value_destroy_func); +void mono_conc_hashtable_destroy (MonoConcurrentHashTable *hash_table); +gpointer mono_conc_hashtable_lookup (MonoConcurrentHashTable *hash_table, gpointer key); +gpointer mono_conc_hashtable_insert (MonoConcurrentHashTable *hash_table, gpointer key, gpointer value); +gpointer mono_conc_hashtable_remove (MonoConcurrentHashTable *hash_table, gpointer key); #endif diff --git a/mono/utils/mono-context.h b/mono/utils/mono-context.h old mode 100755 new mode 100644 index ad56e2c50c2..2b65b2b715b --- a/mono/utils/mono-context.h +++ b/mono/utils/mono-context.h @@ -558,7 +558,7 @@ typedef struct ucontext MonoContext; * The naming is misleading, the SIGCTX argument should be the platform's context * structure (ucontext_c on posix, CONTEXT on windows). */ -void mono_sigctx_to_monoctx (void *sigctx, MonoContext *mctx) MONO_INTERNAL; +void mono_sigctx_to_monoctx (void *sigctx, MonoContext *mctx); /* * This will not completely initialize SIGCTX since MonoContext contains less @@ -566,6 +566,6 @@ void mono_sigctx_to_monoctx (void *sigctx, MonoContext *mctx) MONO_INTERNAL; * the system, and use this function to override the parts of it which are * also in MonoContext. */ -void mono_monoctx_to_sigctx (MonoContext *mctx, void *sigctx) MONO_INTERNAL; +void mono_monoctx_to_sigctx (MonoContext *mctx, void *sigctx); #endif /* __MONO_MONO_CONTEXT_H__ */ diff --git a/mono/utils/mono-dl.h b/mono/utils/mono-dl.h index 4b972ef62f0..c3c59c16078 100644 --- a/mono/utils/mono-dl.h +++ b/mono/utils/mono-dl.h @@ -29,20 +29,20 @@ MonoDl* mono_dl_open (const char *name, int flags, char **error_msg) M char* mono_dl_symbol (MonoDl *module, const char *name, void **symbol) MONO_LLVM_INTERNAL; void mono_dl_close (MonoDl *module) MONO_LLVM_INTERNAL; -char* mono_dl_build_path (const char *directory, const char *name, void **iter) MONO_INTERNAL; +char* mono_dl_build_path (const char *directory, const char *name, void **iter); -MonoDl* mono_dl_open_runtime_lib (const char *lib_name, int flags, char **error_msg) MONO_INTERNAL; +MonoDl* mono_dl_open_runtime_lib (const char *lib_name, int flags, char **error_msg); //Platform API for mono_dl -const char* mono_dl_get_so_prefix (void) MONO_INTERNAL; -const char** mono_dl_get_so_suffixes (void) MONO_INTERNAL; -void* mono_dl_open_file (const char *file, int flags) MONO_INTERNAL; -void mono_dl_close_handle (MonoDl *module) MONO_INTERNAL; -void* mono_dl_lookup_symbol (MonoDl *module, const char *name) MONO_INTERNAL; -int mono_dl_convert_flags (int flags) MONO_INTERNAL; -char* mono_dl_current_error_string (void) MONO_INTERNAL; -int mono_dl_get_executable_path (char *buf, int buflen) MONO_INTERNAL; +const char* mono_dl_get_so_prefix (void); +const char** mono_dl_get_so_suffixes (void); +void* mono_dl_open_file (const char *file, int flags); +void mono_dl_close_handle (MonoDl *module); +void* mono_dl_lookup_symbol (MonoDl *module, const char *name); +int mono_dl_convert_flags (int flags); +char* mono_dl_current_error_string (void); +int mono_dl_get_executable_path (char *buf, int buflen); #endif /* __MONO_UTILS_DL_H__ */ diff --git a/mono/utils/mono-error-internals.h b/mono/utils/mono-error-internals.h index ac2394fa41c..29fb6319af7 100644 --- a/mono/utils/mono-error-internals.h +++ b/mono/utils/mono-error-internals.h @@ -23,61 +23,61 @@ typedef struct { } MonoErrorInternal; void -mono_error_dup_strings (MonoError *error, gboolean dup_strings) MONO_INTERNAL; +mono_error_dup_strings (MonoError *error, gboolean dup_strings); /* This function is not very useful as you can't provide any details beyond the message.*/ void -mono_error_set_error (MonoError *error, int error_code, const char *msg_format, ...) MONO_INTERNAL; +mono_error_set_error (MonoError *error, int error_code, const char *msg_format, ...); void -mono_error_set_assembly_load (MonoError *error, const char *assembly_name, const char *msg_format, ...) MONO_INTERNAL; +mono_error_set_assembly_load (MonoError *error, const char *assembly_name, const char *msg_format, ...); void -mono_error_set_assembly_load_simple (MonoError *error, const char *assembly_name, gboolean refection_only) MONO_INTERNAL; +mono_error_set_assembly_load_simple (MonoError *error, const char *assembly_name, gboolean refection_only); void -mono_error_set_type_load_class (MonoError *error, MonoClass *klass, const char *msg_format, ...) MONO_INTERNAL; +mono_error_set_type_load_class (MonoError *error, MonoClass *klass, const char *msg_format, ...); void -mono_error_set_type_load_name (MonoError *error, const char *type_name, const char *assembly_name, const char *msg_format, ...) MONO_INTERNAL; +mono_error_set_type_load_name (MonoError *error, const char *type_name, const char *assembly_name, const char *msg_format, ...); void -mono_error_set_method_load (MonoError *error, MonoClass *klass, const char *method_name, const char *msg_format, ...) MONO_INTERNAL; +mono_error_set_method_load (MonoError *error, MonoClass *klass, const char *method_name, const char *msg_format, ...); void -mono_error_set_field_load (MonoError *error, MonoClass *klass, const char *field_name, const char *msg_format, ...) MONO_INTERNAL; +mono_error_set_field_load (MonoError *error, MonoClass *klass, const char *field_name, const char *msg_format, ...); void -mono_error_set_bad_image (MonoError *error, MonoImage *image, const char *msg_format, ...) MONO_INTERNAL; +mono_error_set_bad_image (MonoError *error, MonoImage *image, const char *msg_format, ...); void -mono_error_set_bad_image_name (MonoError *error, const char *file_name, const char *msg_format, ...) MONO_INTERNAL; +mono_error_set_bad_image_name (MonoError *error, const char *file_name, const char *msg_format, ...); void -mono_error_set_out_of_memory (MonoError *error, const char *msg_format, ...) MONO_INTERNAL; +mono_error_set_out_of_memory (MonoError *error, const char *msg_format, ...); void -mono_error_set_argument (MonoError *error, const char *argument, const char *msg_format, ...) MONO_INTERNAL; +mono_error_set_argument (MonoError *error, const char *argument, const char *msg_format, ...); void -mono_error_set_not_verifiable (MonoError *oerror, MonoMethod *method, const char *msg_format, ...) MONO_INTERNAL; +mono_error_set_not_verifiable (MonoError *oerror, MonoMethod *method, const char *msg_format, ...); void -mono_error_set_generic_error (MonoError *error, const char * name_space, const char *name, const char *msg_format, ...) MONO_INTERNAL; +mono_error_set_generic_error (MonoError *error, const char * name_space, const char *name, const char *msg_format, ...); void -mono_error_set_from_loader_error (MonoError *error) MONO_INTERNAL; +mono_error_set_from_loader_error (MonoError *error); MonoException* -mono_error_prepare_exception (MonoError *error, MonoError *error_out) MONO_INTERNAL; +mono_error_prepare_exception (MonoError *error, MonoError *error_out); MonoException* -mono_error_convert_to_exception (MonoError *error) MONO_INTERNAL; +mono_error_convert_to_exception (MonoError *error); void -mono_error_raise_exception (MonoError *error) MONO_INTERNAL; +mono_error_raise_exception (MonoError *error); void -mono_loader_set_error_from_mono_error (MonoError *oerror) MONO_INTERNAL; +mono_loader_set_error_from_mono_error (MonoError *oerror); #endif diff --git a/mono/utils/mono-hwcap.h b/mono/utils/mono-hwcap.h index 159701b4498..af5d6654269 100644 --- a/mono/utils/mono-hwcap.h +++ b/mono/utils/mono-hwcap.h @@ -21,13 +21,13 @@ * To get at feature variables, include the appropriate header, * e.g. mono-hwcap-x86.h for x86(-64). */ -void mono_hwcap_init (void) MONO_INTERNAL; +void mono_hwcap_init (void); /* Implemented in mono-hwcap-$TARGET.c. Do not call. */ -void mono_hwcap_arch_init (void) MONO_INTERNAL; +void mono_hwcap_arch_init (void); /* Print detected features to the given file. */ -void mono_hwcap_print (FILE *f) MONO_INTERNAL; +void mono_hwcap_print (FILE *f); /* Please note: If you're going to use the Linux auxiliary vector * to detect CPU features, don't use any of the constant names in diff --git a/mono/utils/mono-internal-hash.h b/mono/utils/mono-internal-hash.h index d8d7a323e11..aa8d1497247 100644 --- a/mono/utils/mono-internal-hash.h +++ b/mono/utils/mono-internal-hash.h @@ -51,13 +51,13 @@ void mono_internal_hash_table_init (MonoInternalHashTable *table, GHashFunc hash_func, MonoInternalHashKeyExtractFunc key_extract, - MonoInternalHashNextValueFunc next_value) MONO_INTERNAL; + MonoInternalHashNextValueFunc next_value); void -mono_internal_hash_table_destroy (MonoInternalHashTable *table) MONO_INTERNAL; +mono_internal_hash_table_destroy (MonoInternalHashTable *table); gpointer -mono_internal_hash_table_lookup (MonoInternalHashTable *table, gpointer key) MONO_INTERNAL; +mono_internal_hash_table_lookup (MonoInternalHashTable *table, gpointer key); /* mono_internal_hash_table_insert requires that there is no entry for key in the hash table. If you want to change the value for a key @@ -68,9 +68,9 @@ mono_internal_hash_table_lookup (MonoInternalHashTable *table, gpointer key) MON assertion and to make the API look more familiar. */ void mono_internal_hash_table_insert (MonoInternalHashTable *table, - gpointer key, gpointer value) MONO_INTERNAL; + gpointer key, gpointer value); void -mono_internal_hash_table_remove (MonoInternalHashTable *table, gpointer key) MONO_INTERNAL; +mono_internal_hash_table_remove (MonoInternalHashTable *table, gpointer key); #endif diff --git a/mono/utils/mono-io-portability.h b/mono/utils/mono-io-portability.h index 62cf5208649..b2cee59bfe2 100644 --- a/mono/utils/mono-io-portability.h +++ b/mono/utils/mono-io-portability.h @@ -25,10 +25,10 @@ enum { #else -void mono_portability_helpers_init (void) MONO_INTERNAL; -gchar *mono_portability_find_file (const gchar *pathname, gboolean last_exists) MONO_INTERNAL; +void mono_portability_helpers_init (void); +gchar *mono_portability_find_file (const gchar *pathname, gboolean last_exists); -extern int __mono_io_portability_helpers MONO_INTERNAL; +extern int __mono_io_portability_helpers; #define IS_PORTABILITY_NONE (__mono_io_portability_helpers & PORTABILITY_NONE) #define IS_PORTABILITY_UNKNOWN (__mono_io_portability_helpers & PORTABILITY_UNKNOWN) diff --git a/mono/utils/mono-linked-list-set.h b/mono/utils/mono-linked-list-set.h index 89c7f1181c7..c1d6d7a014a 100644 --- a/mono/utils/mono-linked-list-set.h +++ b/mono/utils/mono-linked-list-set.h @@ -48,16 +48,16 @@ void mono_lls_init (MonoLinkedListSet *list, void (*free_node_func)(void *)); gboolean -mono_lls_find (MonoLinkedListSet *list, MonoThreadHazardPointers *hp, uintptr_t key) MONO_INTERNAL; +mono_lls_find (MonoLinkedListSet *list, MonoThreadHazardPointers *hp, uintptr_t key); gboolean -mono_lls_insert (MonoLinkedListSet *list, MonoThreadHazardPointers *hp, MonoLinkedListSetNode *value) MONO_INTERNAL; +mono_lls_insert (MonoLinkedListSet *list, MonoThreadHazardPointers *hp, MonoLinkedListSetNode *value); gboolean -mono_lls_remove (MonoLinkedListSet *list, MonoThreadHazardPointers *hp, MonoLinkedListSetNode *value) MONO_INTERNAL; +mono_lls_remove (MonoLinkedListSet *list, MonoThreadHazardPointers *hp, MonoLinkedListSetNode *value); gpointer -get_hazardous_pointer_with_mask (gpointer volatile *pp, MonoThreadHazardPointers *hp, int hazard_index) MONO_INTERNAL; +get_hazardous_pointer_with_mask (gpointer volatile *pp, MonoThreadHazardPointers *hp, int hazard_index); /* Requires the world to be stoped diff --git a/mono/utils/mono-logger-internal.h b/mono/utils/mono-logger-internal.h index 6f711622993..5d567ae5a77 100644 --- a/mono/utils/mono-logger-internal.h +++ b/mono/utils/mono-logger-internal.h @@ -24,28 +24,28 @@ typedef enum { } MonoTraceMask; void -mono_trace_cleanup (void) MONO_INTERNAL; +mono_trace_cleanup (void); void -mono_trace (GLogLevelFlags level, MonoTraceMask mask, const char *format, ...) MONO_INTERNAL; +mono_trace (GLogLevelFlags level, MonoTraceMask mask, const char *format, ...); void -mono_tracev (GLogLevelFlags level, MonoTraceMask mask, const char *format, va_list args) MONO_INTERNAL; +mono_tracev (GLogLevelFlags level, MonoTraceMask mask, const char *format, va_list args); void -mono_trace_set_level (GLogLevelFlags level) MONO_INTERNAL; +mono_trace_set_level (GLogLevelFlags level); void -mono_trace_set_mask (MonoTraceMask mask) MONO_INTERNAL; +mono_trace_set_mask (MonoTraceMask mask); void -mono_trace_push (GLogLevelFlags level, MonoTraceMask mask) MONO_INTERNAL; +mono_trace_push (GLogLevelFlags level, MonoTraceMask mask); void -mono_trace_pop (void) MONO_INTERNAL; +mono_trace_pop (void); gboolean -mono_trace_is_traced (GLogLevelFlags level, MonoTraceMask mask) MONO_INTERNAL; +mono_trace_is_traced (GLogLevelFlags level, MonoTraceMask mask); #ifdef G_HAVE_ISO_VARARGS #define mono_trace_error(...) mono_trace(G_LOG_LEVEL_ERROR, \ diff --git a/mono/utils/mono-mmap-internal.h b/mono/utils/mono-mmap-internal.h index 1818e5c303d..b23ba168999 100644 --- a/mono/utils/mono-mmap-internal.h +++ b/mono/utils/mono-mmap-internal.h @@ -22,7 +22,7 @@ #include "mono-compiler.h" -int mono_pages_not_faulted (void *addr, size_t length) MONO_INTERNAL; +int mono_pages_not_faulted (void *addr, size_t length); #endif /* __MONO_UTILS_MMAP_INTERNAL_H__ */ diff --git a/mono/utils/mono-networkinterfaces.h b/mono/utils/mono-networkinterfaces.h index fe27fc5c4e5..766a4befad2 100644 --- a/mono/utils/mono-networkinterfaces.h +++ b/mono/utils/mono-networkinterfaces.h @@ -21,8 +21,8 @@ typedef enum { MONO_NETWORK_ERROR_OTHER } MonoNetworkError; -gpointer *mono_networkinterface_list (int *size) MONO_INTERNAL; -gint64 mono_network_get_data (char* name, MonoNetworkData data, MonoNetworkError *error) MONO_INTERNAL; +gpointer *mono_networkinterface_list (int *size); +gint64 mono_network_get_data (char* name, MonoNetworkData data, MonoNetworkError *error); #endif /* __MONO_NETWORK_INTERFACES_H__ */ diff --git a/mono/utils/mono-proclib.h b/mono/utils/mono-proclib.h index 6a8f6bf81f7..139bb6e070e 100644 --- a/mono/utils/mono-proclib.h +++ b/mono/utils/mono-proclib.h @@ -41,19 +41,19 @@ typedef enum { MONO_PROCESS_ERROR_OTHER } MonoProcessError; -gpointer* mono_process_list (int *size) MONO_INTERNAL; +gpointer* mono_process_list (int *size); -char* mono_process_get_name (gpointer pid, char *buf, int len) MONO_INTERNAL; +char* mono_process_get_name (gpointer pid, char *buf, int len); -gint64 mono_process_get_data (gpointer pid, MonoProcessData data) MONO_INTERNAL; -gint64 mono_process_get_data_with_error (gpointer pid, MonoProcessData data, MonoProcessError *error) MONO_INTERNAL; +gint64 mono_process_get_data (gpointer pid, MonoProcessData data); +gint64 mono_process_get_data_with_error (gpointer pid, MonoProcessData data, MonoProcessError *error); -int mono_process_current_pid (void) MONO_INTERNAL; +int mono_process_current_pid (void); -int mono_cpu_count (void) MONO_INTERNAL; -gint64 mono_cpu_get_data (int cpu_id, MonoCpuData data, MonoProcessError *error) MONO_INTERNAL; +int mono_cpu_count (void); +gint64 mono_cpu_get_data (int cpu_id, MonoCpuData data, MonoProcessError *error); -int mono_atexit (void (*func)(void)) MONO_INTERNAL; +int mono_atexit (void (*func)(void)); #endif /* __MONO_PROC_LIB_H__ */ diff --git a/mono/utils/mono-threads-mach-helper.c b/mono/utils/mono-threads-mach-helper.c index fd95b92fad1..649cdad0d9a 100644 --- a/mono/utils/mono-threads-mach-helper.c +++ b/mono/utils/mono-threads-mach-helper.c @@ -21,9 +21,9 @@ * which conflicts with objc. * Hence the hack here. */ -void mono_threads_init_dead_letter (void) MONO_INTERNAL; -void mono_threads_install_dead_letter (void) MONO_INTERNAL; -void mono_thread_info_detach (void) MONO_INTERNAL; +void mono_threads_init_dead_letter (void); +void mono_threads_install_dead_letter (void); +void mono_thread_info_detach (void); static Class nsobject, nsthread, mono_dead_letter_class; static SEL dealloc, release, currentThread, threadDictionary, init, alloc, objectForKey, setObjectForKey; diff --git a/mono/utils/mono-threads.h b/mono/utils/mono-threads.h index f4d468f76ad..55461f2e2c1 100644 --- a/mono/utils/mono-threads.h +++ b/mono/utils/mono-threads.h @@ -230,88 +230,88 @@ Snapshot iteration. * a single block with info from both camps. */ void -mono_threads_init (MonoThreadInfoCallbacks *callbacks, size_t thread_info_size) MONO_INTERNAL; +mono_threads_init (MonoThreadInfoCallbacks *callbacks, size_t thread_info_size); void -mono_threads_runtime_init (MonoThreadInfoRuntimeCallbacks *callbacks) MONO_INTERNAL; +mono_threads_runtime_init (MonoThreadInfoRuntimeCallbacks *callbacks); MonoThreadInfoCallbacks * -mono_threads_get_callbacks (void) MONO_INTERNAL; +mono_threads_get_callbacks (void); MonoThreadInfoRuntimeCallbacks * -mono_threads_get_runtime_callbacks (void) MONO_INTERNAL; +mono_threads_get_runtime_callbacks (void); int -mono_thread_info_register_small_id (void) MONO_INTERNAL; +mono_thread_info_register_small_id (void); THREAD_INFO_TYPE * -mono_thread_info_attach (void *baseptr) MONO_INTERNAL; +mono_thread_info_attach (void *baseptr); void -mono_thread_info_detach (void) MONO_INTERNAL; +mono_thread_info_detach (void); gboolean -mono_thread_info_is_exiting (void) MONO_INTERNAL; +mono_thread_info_is_exiting (void); THREAD_INFO_TYPE * -mono_thread_info_current (void) MONO_INTERNAL; +mono_thread_info_current (void); int -mono_thread_info_get_small_id (void) MONO_INTERNAL; +mono_thread_info_get_small_id (void); MonoLinkedListSet* -mono_thread_info_list_head (void) MONO_INTERNAL; +mono_thread_info_list_head (void); THREAD_INFO_TYPE* -mono_thread_info_lookup (MonoNativeThreadId id) MONO_INTERNAL; +mono_thread_info_lookup (MonoNativeThreadId id); THREAD_INFO_TYPE* -mono_thread_info_safe_suspend_sync (MonoNativeThreadId tid, gboolean interrupt_kernel) MONO_INTERNAL; +mono_thread_info_safe_suspend_sync (MonoNativeThreadId tid, gboolean interrupt_kernel); gboolean -mono_thread_info_resume (MonoNativeThreadId tid) MONO_INTERNAL; +mono_thread_info_resume (MonoNativeThreadId tid); void -mono_thread_info_set_name (MonoNativeThreadId tid, const char *name) MONO_INTERNAL; +mono_thread_info_set_name (MonoNativeThreadId tid, const char *name); void -mono_thread_info_finish_suspend (MonoThreadInfo *info) MONO_INTERNAL; +mono_thread_info_finish_suspend (MonoThreadInfo *info); void -mono_thread_info_finish_suspend_and_resume (MonoThreadInfo *info) MONO_INTERNAL; +mono_thread_info_finish_suspend_and_resume (MonoThreadInfo *info); void -mono_thread_info_self_suspend (void) MONO_INTERNAL; +mono_thread_info_self_suspend (void); gboolean -mono_thread_info_new_interrupt_enabled (void) MONO_INTERNAL; +mono_thread_info_new_interrupt_enabled (void); void -mono_thread_info_setup_async_call (THREAD_INFO_TYPE *info, void (*target_func)(void*), void *user_data) MONO_INTERNAL; +mono_thread_info_setup_async_call (THREAD_INFO_TYPE *info, void (*target_func)(void*), void *user_data); void -mono_thread_info_suspend_lock (void) MONO_INTERNAL; +mono_thread_info_suspend_lock (void); void -mono_thread_info_suspend_unlock (void) MONO_INTERNAL; +mono_thread_info_suspend_unlock (void); void -mono_thread_info_disable_new_interrupt (gboolean disable) MONO_INTERNAL; +mono_thread_info_disable_new_interrupt (gboolean disable); void -mono_thread_info_abort_socket_syscall_for_close (MonoNativeThreadId tid) MONO_INTERNAL; +mono_thread_info_abort_socket_syscall_for_close (MonoNativeThreadId tid); void -mono_thread_info_set_is_async_context (gboolean async_context) MONO_INTERNAL; +mono_thread_info_set_is_async_context (gboolean async_context); gboolean -mono_thread_info_is_async_context (void) MONO_INTERNAL; +mono_thread_info_is_async_context (void); void mono_thread_info_get_stack_bounds (guint8 **staddr, size_t *stsize); gboolean -mono_thread_info_yield (void) MONO_INTERNAL; +mono_thread_info_yield (void); gpointer mono_thread_info_tls_get (THREAD_INFO_TYPE *info, MonoTlsKey key); @@ -341,16 +341,16 @@ void mono_thread_info_clear_interruption (void); gboolean -mono_thread_info_is_live (THREAD_INFO_TYPE *info) MONO_INTERNAL; +mono_thread_info_is_live (THREAD_INFO_TYPE *info); HANDLE mono_threads_create_thread (LPTHREAD_START_ROUTINE start, gpointer arg, guint32 stack_size, guint32 creation_flags, MonoNativeThreadId *out_tid); int -mono_threads_get_max_stack_size (void) MONO_INTERNAL; +mono_threads_get_max_stack_size (void); HANDLE -mono_threads_open_thread_handle (HANDLE handle, MonoNativeThreadId tid) MONO_INTERNAL; +mono_threads_open_thread_handle (HANDLE handle, MonoNativeThreadId tid); /* This is the async job submission/consumption API. @@ -358,10 +358,10 @@ XXX: This is a PROVISIONAL API only meant to be used by the statistical profiler If you want to use/extend it anywhere else, understand that you'll have to do some API design work to better fit this puppy. */ gboolean -mono_threads_add_async_job (THREAD_INFO_TYPE *info, MonoAsyncJob job) MONO_INTERNAL; +mono_threads_add_async_job (THREAD_INFO_TYPE *info, MonoAsyncJob job); MonoAsyncJob -mono_threads_consume_async_jobs (void) MONO_INTERNAL; +mono_threads_consume_async_jobs (void); MONO_API void mono_threads_attach_tools_thread (void); @@ -371,42 +371,42 @@ mono_threads_attach_tools_thread (void); /*Use this instead of pthread_kill */ int -mono_threads_pthread_kill (THREAD_INFO_TYPE *info, int signum) MONO_INTERNAL; +mono_threads_pthread_kill (THREAD_INFO_TYPE *info, int signum); #endif /* !defined(HOST_WIN32) */ /* Plartform specific functions DON'T use them */ -void mono_threads_init_platform (void) MONO_INTERNAL; //ok -gboolean mono_threads_core_suspend (THREAD_INFO_TYPE *info, gboolean interrupt_kernel) MONO_INTERNAL; -gboolean mono_threads_core_resume (THREAD_INFO_TYPE *info) MONO_INTERNAL; -void mono_threads_platform_register (THREAD_INFO_TYPE *info) MONO_INTERNAL; //ok -void mono_threads_platform_free (THREAD_INFO_TYPE *info) MONO_INTERNAL; -void mono_threads_core_interrupt (THREAD_INFO_TYPE *info) MONO_INTERNAL; -void mono_threads_core_abort_syscall (THREAD_INFO_TYPE *info) MONO_INTERNAL; -gboolean mono_threads_core_needs_abort_syscall (void) MONO_INTERNAL; -HANDLE mono_threads_core_create_thread (LPTHREAD_START_ROUTINE start, gpointer arg, guint32 stack_size, guint32 creation_flags, MonoNativeThreadId *out_tid) MONO_INTERNAL; -void mono_threads_core_resume_created (THREAD_INFO_TYPE *info, MonoNativeThreadId tid) MONO_INTERNAL; -void mono_threads_core_get_stack_bounds (guint8 **staddr, size_t *stsize) MONO_INTERNAL; -gboolean mono_threads_core_yield (void) MONO_INTERNAL; -void mono_threads_core_exit (int exit_code) MONO_INTERNAL; -void mono_threads_core_unregister (THREAD_INFO_TYPE *info) MONO_INTERNAL; -HANDLE mono_threads_core_open_handle (void) MONO_INTERNAL; -HANDLE mono_threads_core_open_thread_handle (HANDLE handle, MonoNativeThreadId tid) MONO_INTERNAL; -void mono_threads_core_set_name (MonoNativeThreadId tid, const char *name) MONO_INTERNAL; +void mono_threads_init_platform (void); //ok +gboolean mono_threads_core_suspend (THREAD_INFO_TYPE *info, gboolean interrupt_kernel); +gboolean mono_threads_core_resume (THREAD_INFO_TYPE *info); +void mono_threads_platform_register (THREAD_INFO_TYPE *info); //ok +void mono_threads_platform_free (THREAD_INFO_TYPE *info); +void mono_threads_core_interrupt (THREAD_INFO_TYPE *info); +void mono_threads_core_abort_syscall (THREAD_INFO_TYPE *info); +gboolean mono_threads_core_needs_abort_syscall (void); +HANDLE mono_threads_core_create_thread (LPTHREAD_START_ROUTINE start, gpointer arg, guint32 stack_size, guint32 creation_flags, MonoNativeThreadId *out_tid); +void mono_threads_core_resume_created (THREAD_INFO_TYPE *info, MonoNativeThreadId tid); +void mono_threads_core_get_stack_bounds (guint8 **staddr, size_t *stsize); +gboolean mono_threads_core_yield (void); +void mono_threads_core_exit (int exit_code); +void mono_threads_core_unregister (THREAD_INFO_TYPE *info); +HANDLE mono_threads_core_open_handle (void); +HANDLE mono_threads_core_open_thread_handle (HANDLE handle, MonoNativeThreadId tid); +void mono_threads_core_set_name (MonoNativeThreadId tid, const char *name); gpointer mono_threads_core_prepare_interrupt (HANDLE thread_handle); void mono_threads_core_finish_interrupt (gpointer wait_handle); void mono_threads_core_self_interrupt (void); void mono_threads_core_clear_interruption (void); -MonoNativeThreadId mono_native_thread_id_get (void) MONO_INTERNAL; +MonoNativeThreadId mono_native_thread_id_get (void); -gboolean mono_native_thread_id_equals (MonoNativeThreadId id1, MonoNativeThreadId id2) MONO_INTERNAL; +gboolean mono_native_thread_id_equals (MonoNativeThreadId id1, MonoNativeThreadId id2); gboolean -mono_native_thread_create (MonoNativeThreadId *tid, gpointer func, gpointer arg) MONO_INTERNAL; +mono_native_thread_create (MonoNativeThreadId *tid, gpointer func, gpointer arg); /*Mach specific internals */ -void mono_threads_init_dead_letter (void) MONO_INTERNAL; -void mono_threads_install_dead_letter (void) MONO_INTERNAL; +void mono_threads_init_dead_letter (void); +void mono_threads_install_dead_letter (void); #endif /* __MONO_THREADS_H__ */ diff --git a/mono/utils/mono-time.h b/mono/utils/mono-time.h index 294ca1b530a..6961306c290 100644 --- a/mono/utils/mono-time.h +++ b/mono/utils/mono-time.h @@ -5,13 +5,13 @@ #include /* Returns the number of milliseconds from boot time: this should be monotonic */ -guint32 mono_msec_ticks (void) MONO_INTERNAL; +guint32 mono_msec_ticks (void); /* Returns the number of 100ns ticks from unspecified time: this should be monotonic */ -gint64 mono_100ns_ticks (void) MONO_INTERNAL; +gint64 mono_100ns_ticks (void); /* Returns the number of 100ns ticks since 1/1/1, UTC timezone */ -gint64 mono_100ns_datetime (void) MONO_INTERNAL; +gint64 mono_100ns_datetime (void); /* Stopwatch class for internal runtime use */ typedef struct { diff --git a/mono/utils/mono-value-hash.h b/mono/utils/mono-value-hash.h index 0d373d0c134..7b2e00c321d 100644 --- a/mono/utils/mono-value-hash.h +++ b/mono/utils/mono-value-hash.h @@ -38,19 +38,19 @@ typedef gpointer (*MonoValueHashKeyExtractFunc) (gpointer value); MonoValueHashTable* mono_value_hash_table_new (GHashFunc hash_func, GEqualFunc key_equal_func, - MonoValueHashKeyExtractFunc key_extract) MONO_INTERNAL; + MonoValueHashKeyExtractFunc key_extract); void -mono_value_hash_table_destroy (MonoValueHashTable *table) MONO_INTERNAL; +mono_value_hash_table_destroy (MonoValueHashTable *table); gpointer -mono_value_hash_table_lookup (MonoValueHashTable *table, gconstpointer key) MONO_INTERNAL; +mono_value_hash_table_lookup (MonoValueHashTable *table, gconstpointer key); /* The key pointer is actually only passed here to check a debugging assertion and to make the API look more familiar. */ void mono_value_hash_table_insert (MonoValueHashTable *table, - gpointer key, gpointer value) MONO_INTERNAL; + gpointer key, gpointer value); G_END_DECLS diff --git a/mono/utils/networking.h b/mono/utils/networking.h index 55c829152fa..370a3d0ffaf 100644 --- a/mono/utils/networking.h +++ b/mono/utils/networking.h @@ -79,28 +79,28 @@ typedef struct { } MonoAddress; /* This only supports IPV4 / IPV6 and tcp */ -int mono_get_address_info (const char *hostname, int port, int flags, MonoAddressInfo **res) MONO_INTERNAL; +int mono_get_address_info (const char *hostname, int port, int flags, MonoAddressInfo **res); -void mono_free_address_info (MonoAddressInfo *ai) MONO_INTERNAL; +void mono_free_address_info (MonoAddressInfo *ai); -void mono_socket_address_init (MonoSocketAddress *sa, socklen_t *len, int family, const void *address, int port) MONO_INTERNAL; +void mono_socket_address_init (MonoSocketAddress *sa, socklen_t *len, int family, const void *address, int port); -void *mono_get_local_interfaces (int family, int *interface_count) MONO_INTERNAL; +void *mono_get_local_interfaces (int family, int *interface_count); #ifndef HAVE_INET_PTON -int inet_pton (int family, const char *address, void *inaddrp) MONO_INTERNAL; +int inet_pton (int family, const char *address, void *inaddrp); #endif -void mono_address_init (MonoAddress *out_addr, int family, void *in_addr) MONO_INTERNAL; -int mono_address_size_for_family (int family) MONO_INTERNAL; -gboolean mono_networking_addr_to_str (MonoAddress *address, char *buffer, socklen_t buflen) MONO_INTERNAL; +void mono_address_init (MonoAddress *out_addr, int family, void *in_addr); +int mono_address_size_for_family (int family); +gboolean mono_networking_addr_to_str (MonoAddress *address, char *buffer, socklen_t buflen); -int mono_networking_get_tcp_protocol (void) MONO_INTERNAL; -int mono_networking_get_ip_protocol (void) MONO_INTERNAL; -int mono_networking_get_ipv6_protocol (void) MONO_INTERNAL; +int mono_networking_get_tcp_protocol (void); +int mono_networking_get_ip_protocol (void); +int mono_networking_get_ipv6_protocol (void); -void mono_networking_init (void) MONO_INTERNAL; -void mono_networking_shutdown (void) MONO_INTERNAL; +void mono_networking_init (void); +void mono_networking_shutdown (void); #endif diff --git a/mono/utils/strtod.h b/mono/utils/strtod.h index 512e9f293fc..8f53741c5d7 100644 --- a/mono/utils/strtod.h +++ b/mono/utils/strtod.h @@ -3,6 +3,6 @@ #include "mono-compiler.h" -double mono_strtod (const char *s00, char **se) MONO_INTERNAL; +double mono_strtod (const char *s00, char **se); #endif -- 2.25.1