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
};
#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
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;
} 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
guint threadpool_iothreads;
} MonoPerfCounters;
-extern MonoPerfCounters *mono_perfcounters MONO_INTERNAL;
+extern MonoPerfCounters *mono_perfcounters;
MONO_API void mono_perfcounters_init (void);
#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);
}
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;
#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)
#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;
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,
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;
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);
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__ */
#include <mono/metadata/marshal.h>
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);
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
#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 */
} 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);
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);
#include <mono/utils/mono-compiler.h>
#include <mono/io-layer/io-layer.h>
-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 <sys/utsname.h>
/* 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);
#include <mono/io-layer/io-layer.h>
#include <mono/utils/mono-compiler.h>
-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_ */
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
/* 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).
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:
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.
* 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.
* 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 */
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
} 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;
#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__ */
#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);
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_ */
#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
/* 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);
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
}
long
-mono_mempool_get_bytes_allocated (void) MONO_INTERNAL;
+mono_mempool_get_bytes_allocated (void);
#endif
}
/* 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,
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,
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,
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 (
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__ */
} 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
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
};
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
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
#include <mono/utils/mono-compiler.h>
-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__ */
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);
#include <mono/metadata/object-internals.h>
-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__ */
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
/* 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 */
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
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,
} 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__ */
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);
} 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__ */
#include <mono/metadata/object.h>
#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
#include <mono/utils/mono-error.h>
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
#include <mono/metadata/object-internals.h>
#include <mono/metadata/class-internals.h>
-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
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_ */
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);
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 ())
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
#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
#define SGEN_HAVE_OVERLAPPING_CARDS 1
#endif
-extern guint8 *sgen_cardtable MONO_INTERNAL;
+extern guint8 *sgen_cardtable;
#ifdef SGEN_HAVE_OVERLAPPING_CARDS
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)
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
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 ()
/* 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
#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)
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 {
#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 {
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;
/*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;
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);
/*
#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)
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 */
/* 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,
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 {
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)
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);
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,
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 */
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 */
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 */
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 */
#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
* - 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"
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);
#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)
#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 { \
#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 {
} 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
#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
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
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
/* 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 ()
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
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_ */
#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_ */
#include <glib.h>
#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
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
#include <mono/metadata/socket-io.h>
/* 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);
/* 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_ */
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__ */
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); \
} 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__*/
#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
#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
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
// 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__ */
#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
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
* 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
* 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__ */
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__ */
} 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
* 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
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
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
#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)
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
} 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, \
#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__ */
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__ */
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__ */
* 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;
* 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);
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.
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);
/*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__ */
#include <glib.h>
/* 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 {
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
} 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
#include "mono-compiler.h"
-double mono_strtod (const char *s00, char **se) MONO_INTERNAL;
+double mono_strtod (const char *s00, char **se);
#endif
projects / mono.git / commitdiff