for (i = 0; i < t->rows; i++){
guint32 cols [MONO_PROPERTY_SIZE];
char *type;
- int bsize;
int prop_flags;
mono_metadata_decode_row (t, i, cols, MONO_PROPERTY_SIZE);
strcat (flags, "hasdefault ");
ptr = mono_metadata_blob_heap (m, cols [MONO_PROPERTY_TYPE]);
- bsize = mono_metadata_decode_blob_size (ptr, &ptr);
+ /* bsize = */ mono_metadata_decode_blob_size (ptr, &ptr);
/* ECMA claims 0x08 ... */
if (*ptr != 0x28 && *ptr != 0x08)
g_warning("incorrect signature in propert blob: 0x%x", *ptr);
const char *ptr;
char *s, *result;
GString *res = g_string_new ("");
- int len;
MonoMethodSignature *sig;
mono_metadata_decode_row (&m->tables [MONO_TABLE_TYPESPEC], idx-1, cols, MONO_TYPESPEC_SIZE);
ptr = mono_metadata_blob_heap (m, cols [MONO_TYPESPEC_SIGNATURE]);
- len = mono_metadata_decode_value (ptr, &ptr);
+ /* len = */ mono_metadata_decode_value (ptr, &ptr);
switch (*ptr++){
case MONO_TYPE_PTR:
{
char *allocated_modifier_string, *allocated_type_string;
const char *ptr = mono_metadata_blob_heap (m, blob_signature);
- const char *base;
char *res;
int len;
len = mono_metadata_decode_value (ptr, &ptr);
- base = ptr;
/* FIELD is 0x06 */
g_assert (*ptr == 0x06);
/* hex_dump (ptr, 0, len); */
char *allocated_ret_type, *s;
const char *cconv_str;
gboolean seen_vararg = 0;
- int param_count, signature_len;
+ int param_count;
int i, gen_count = 0;
int cconv;
- signature_len = mono_metadata_decode_value (ptr, &ptr);
+ /* signature_len = */ mono_metadata_decode_value (ptr, &ptr);
if (*ptr & 0x20){
if (*ptr & 0x40)
char*
get_marshal_info (MonoImage *m, const char *blob) {
- int len, size = 0;
+ int size = 0;
- len = mono_metadata_decode_blob_size (blob, &blob);
+ /* len = */ mono_metadata_decode_blob_size (blob, &blob);
switch (*blob) {
case MONO_NATIVE_BOOLEAN:
unsigned char flags = *(const unsigned char *) ptr;
unsigned char format = flags & METHOD_HEADER_FORMAT_MASK;
guint16 fat_flags;
- guint32 local_var_sig_tok, max_stack, code_size, init_locals;
- int hsize;
+ guint32 local_var_sig_tok, init_locals;
g_assert (format == METHOD_HEADER_FAT_FORMAT);
fat_flags = read16 (ptr);
ptr += 2;
- hsize = (fat_flags >> 12) & 0xf;
- max_stack = read16 (ptr);
+ /* max_stack = read16 (ptr); */
ptr += 2;
- code_size = read32 (ptr);
+ /* code_size = read32 (ptr); */
ptr += 4;
local_var_sig_tok = read32 (ptr);
ptr += 4;
{
MonoImageOpenStatus status;
MonoImage *img;
- MonoAssembly *assembly;
-
img = mono_image_open (file, &status);
if (!img) {
fprintf (stderr, "Error while trying to process %s\n", file);
return;
} else {
- assembly = mono_assembly_load_from_full (img, file, &status, FALSE);
+ /* FIXME: is this call necessary? */
+ mono_assembly_load_from_full (img, file, &status, FALSE);
}
setup_filter (img);
struct _WapiHandle_file *file_handle;
gboolean ok;
struct stat statbuf;
- off_t size, pos;
+ off_t pos;
int ret, fd;
ok=_wapi_lookup_handle (handle, WAPI_HANDLE_FILE,
_wapi_set_last_error_from_errno ();
return(FALSE);
}
- size=statbuf.st_size;
pos=lseek(fd, (off_t)0, SEEK_CUR);
if(pos==-1) {
}
#ifdef FTRUNCATE_DOESNT_EXTEND
+ off_t size = statbuf.st_size;
/* I haven't bothered to write the configure.ac stuff for this
* because I don't know if any platform needs it. I'm leaving
* this code just in case though
static void process_close (gpointer handle, gpointer data);
static gboolean is_pid_valid (pid_t pid);
-#if !defined(__OpenBSD__)
+#if !(defined(PLATFORM_MACOSX) || defined(__OpenBSD__) || defined(__HAIKU__))
static FILE *
open_process_map (int pid, const char *mode);
#endif
return result;
}
-#if !defined(__OpenBSD__)
+#if !(defined(PLATFORM_MACOSX) || defined(__OpenBSD__) || defined(__HAIKU__))
static FILE *
open_process_map (int pid, const char *mode)
{
process_wait (gpointer handle, guint32 timeout, gboolean alertable)
{
WapiHandle_process *process_handle;
- pid_t pid, ret;
+ pid_t pid G_GNUC_UNUSED, ret;
int status;
guint32 start;
guint32 now;
}
#ifndef PLATFORM_PORT_PROVIDES_IOCTLSOCKET
-int ioctlsocket(guint32 fd, gint32 command, gpointer arg)
+int ioctlsocket(guint32 fd, unsigned long command, gpointer arg)
{
gpointer handle = GUINT_TO_POINTER (fd);
int ret;
extern int WSAGetLastError(void);
extern int closesocket(guint32 handle);
-extern int ioctlsocket(guint32 handle, gint32 command, gpointer arg);
+extern int ioctlsocket(guint32 handle, unsigned long command, gpointer arg);
extern int WSAIoctl (guint32 handle, gint32 command,
gchar *input, gint i_len,
gchar *output, gint o_len, glong *written,
get_fixedfileinfo_block (gconstpointer data, version_data *block)
{
gconstpointer data_ptr;
- gint32 data_len; /* signed to guard against underflow */
WapiFixedFileInfo *ffi;
data_ptr = get_versioninfo_block (data, block);
- data_len = block->data_len;
if (block->value_len != sizeof(WapiFixedFileInfo)) {
DEBUG ("%s: FIXEDFILEINFO size mismatch", __func__);
guint32
SleepEx (guint32 ms, gboolean alertable)
{
- struct timespec req;
int ms_quot, ms_rem;
int ret;
gpointer current_thread = NULL;
ms_quot = ms / 1000;
ms_rem = ms % 1000;
- req.tv_sec=ms_quot;
- req.tv_nsec=ms_rem*1000000;
-
#if defined (__linux__) && !defined(PLATFORM_ANDROID)
/* Use clock_nanosleep () to prevent time drifting problems when nanosleep () is interrupted by signals */
ret = clock_gettime (CLOCK_MONOTONIC, &start);
}
#else
+ struct timespec req;
+
+ req.tv_sec=ms_quot;
+ req.tv_nsec=ms_rem*1000000;
again:
memset (&rem, 0, sizeof (rem));
MonoCustomAttrEntry *attr = &attrs->attrs [i];
MonoAssemblyName *aname;
const gchar *data;
- guint slen;
/* Do some sanity checking */
if (!attr->ctor || attr->ctor->klass != mono_defaults.internals_visible_class)
continue;
/* 0xFF means null string, see custom attr format */
if (data [0] != 1 || data [1] != 0 || (data [2] & 0xFF) == 0xFF)
continue;
- slen = mono_metadata_decode_value (data + 2, &data);
+ mono_metadata_decode_value (data + 2, &data);
aname = g_new0 (MonoAssemblyName, 1);
/*g_print ("friend ass: %s\n", data);*/
if (mono_assembly_name_parse_full (data, aname, TRUE, NULL, NULL)) {
return (((int)buf [0]) << 0) | (((int)buf [1]) << 8) | (((int)buf [2]) << 16) | (((int)buf [3]) << 24);
}
-static inline int
-decode_short (guint8 *buf, guint8 **endbuf, guint8 *limit)
-{
- *endbuf = buf + 2;
- g_assert (*endbuf <= limit);
-
- return (((int)buf [0]) << 0) | (((int)buf [1]) << 8);
-}
-
static char*
decode_string_value (guint8 *buf, guint8 **endbuf, guint8 *limit)
{
gc_stats.major_gc_time += mono_100ns_ticks () - gc_start_time;
mono_trace_message (MONO_TRACE_GC, "gc took %d usecs", (mono_100ns_ticks () - gc_start_time) / 10);
break;
+ default:
+ break;
}
mono_profiler_gc_event (e, 0);
case MONO_TYPE_VOID:
//case MONO_TYPE_TYPEDBYREF:
return FALSE;
+ default:
+ return TRUE;
}
- return TRUE;
}
static MonoType*
return type->data.array->eklass->exception_type;
case MONO_TYPE_GENERICINST:
return mono_generic_class_get_class (type->data.generic_class)->exception_type;
+ default:
+ return FALSE;
}
- return FALSE;
}
/*
GHashTable *override_map = NULL;
gboolean security_enabled = mono_security_enabled ();
MonoMethod *cm;
- gpointer class_iter;
#if (DEBUG_INTERFACE_VTABLE_CODE|TRACE_INTERFACE_VTABLE_CODE)
int first_non_interface_slot;
#endif
// otherwise look for a matching method
if (override_im == NULL) {
int cm_index;
- gpointer iter;
MonoMethod *cm;
// First look for a suitable method among the class methods
- iter = NULL;
for (l = virt_methods; l; l = l->next) {
cm = l->data;
TRACE_INTERFACE_VTABLE (printf (" For slot %d ('%s'.'%s':'%s'), trying method '%s'.'%s':'%s'... [EXPLICIT IMPLEMENTATION = %d][SLOT IS NULL = %d]", im_slot, ic->name_space, ic->name, im->name, cm->klass->name_space, cm->klass->name, cm->name, interface_is_explicitly_implemented_by_class, (vtable [im_slot] == NULL)));
}
TRACE_INTERFACE_VTABLE (print_vtable_full (class, vtable, cur_slot, first_non_interface_slot, "AFTER SETTING UP INTERFACE METHODS", FALSE));
- class_iter = NULL;
for (l = virt_methods; l; l = l->next) {
cm = l->data;
/*
#endif
class->cast_class = mono_defaults.int64_class;
break;
+ default:
+ break;
}
class->element_class = eclass;
case MONO_TYPE_GENERICINST:
if (!can_access_type (access_klass, mono_class_from_mono_type (type)))
return FALSE;
+ default:
+ break;
}
}
return TRUE;
case MONO_TYPE_I:
case MONO_TYPE_U:
return TRUE;
+ default:
+ return FALSE;
}
- return FALSE;
}
/**
static MonoClass* com_interop_proxy_class = NULL;
static MonoMethod* com_interop_proxy_get_proxy = NULL;
static MonoMethod* get_transparent_proxy = NULL;
- int real_proxy;
guint32 pos_null = 0, pos_ccw = 0, pos_end = 0;
MonoClass *klass = NULL;
get_transparent_proxy = mono_class_get_method_from_name (mono_defaults.real_proxy_class, "GetTransparentProxy", 0);
#endif
- real_proxy = mono_mb_add_local (mb, &com_interop_proxy_class->byval_arg);
+ mono_mb_add_local (mb, &com_interop_proxy_class->byval_arg);
mono_mb_emit_ldloc (mb, 0);
mono_mb_emit_byte (mb, CEE_LDIND_I);
MonoMethodSignature *sig;
MonoMethodBuilder *mb;
MonoMethod *res;
- int i, temp_obj;
+ int i;
GHashTable* cache = mono_marshal_get_cache (&method->klass->image->cominterop_invoke_cache, mono_aligned_addr_hash, NULL);
g_assert (method);
mb = mono_mb_new (method->klass, method->name, MONO_WRAPPER_COMINTEROP_INVOKE);
/* get real proxy object, which is a ComInteropProxy in this case*/
- temp_obj = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
+ mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
mono_mb_emit_ldarg (mb, 0);
mono_mb_emit_ldflda (mb, MONO_STRUCT_OFFSET (MonoTransparentProxy, rp));
mono_mb_emit_byte (mb, CEE_LDIND_REF);
static void
tty_teardown (void)
{
- int unused;
+ int unused G_GNUC_UNUSED;
if (!setup_finished)
return;
MONO_SIG_HANDLER_FUNC (static, sigcont_handler)
{
- int unused;
+ int unused G_GNUC_UNUSED;
// Ignore error, there is not much we can do in the sigcont handler.
tcsetattr (STDIN_FILENO, TCSANOW, &mono_attr);
mono_method_desc_search_in_image (MonoMethodDesc *desc, MonoImage *image)
{
MonoClass *klass;
- const MonoTableInfo *tdef;
const MonoTableInfo *methods;
MonoMethod *method;
int i;
return mono_method_desc_search_in_class (desc, klass);
}
- tdef = mono_image_get_table_info (image, MONO_TABLE_TYPEDEF);
+ /* FIXME: Is this call necessary? We don't use its result. */
+ mono_image_get_table_info (image, MONO_TABLE_TYPEDEF);
methods = mono_image_get_table_info (image, MONO_TABLE_METHOD);
for (i = 0; i < mono_table_info_get_rows (methods); ++i) {
guint32 token = mono_metadata_decode_row_col (methods, i, MONO_METHOD_NAME);
{
MonoSymbolFile *symfile = minfo->handle->symfile;
const uint8_t *p;
- int i, len, compile_unit_index, locals_offset, num_locals, block_index;
- int namespace_id, code_block_table_offset;
+ int i, len, locals_offset, num_locals, block_index;
+ int code_block_table_offset;
MonoDebugLocalsInfo *res;
if (!symfile)
p = symfile->raw_contents + minfo->data_offset;
- compile_unit_index = read_leb128 (p, &p);
+ /* compile_unit_index = */ read_leb128 (p, &p);
locals_offset = read_leb128 (p, &p);
- namespace_id = read_leb128 (p, &p);
+ /* namespace_id = */ read_leb128 (p, &p);
code_block_table_offset = read_leb128 (p, &p);
res = g_new0 (MonoDebugLocalsInfo, 1);
}
// Decimal addition
-static MonoDecimalStatus
+static MonoDecimalStatus G_GNUC_UNUSED
mono_decimal_add(MonoDecimal *left, MonoDecimal *right, MonoDecimal *result)
{
return DecAddSub (left, right, result, 0);
}
// Decimal subtraction
-static MonoDecimalStatus
+static MonoDecimalStatus G_GNUC_UNUSED
mono_decimal_sub(MonoDecimal *left, MonoDecimal *right, MonoDecimal *result)
{
return DecAddSub (left, right, result, DECIMAL_NEG);
}
// mono_decimal_divide - Decimal divide
-static MonoDecimalStatus
+static MonoDecimalStatus G_GNUC_UNUSED
mono_decimal_divide_result(MonoDecimal *left, MonoDecimal *right, MonoDecimal *result)
{
uint32_t quo[3];
}
// mono_decimal_absolute - Decimal Absolute Value
-static void
+static void G_GNUC_UNUSED
mono_decimal_absolute (MonoDecimal *pdecOprd, MonoDecimal *result)
{
COPYDEC(*result, *pdecOprd);
}
// mono_decimal_negate - Decimal Negate
-static void
+static void G_GNUC_UNUSED
mono_decimal_negate (MonoDecimal *pdecOprd, MonoDecimal *result)
{
COPYDEC(*result, *pdecOprd);
MonoDl *fam_module;
int lib_used = 4; /* gamin */
int inotify_instance;
- void *iter;
char *err;
inotify_instance = ves_icall_System_IO_InotifyWatcher_GetInotifyInstance ();
return 5; /* inotify */
}
- iter = NULL;
fam_module = mono_dl_open ("libgamin-1.so", MONO_DL_LAZY, NULL);
if (fam_module == NULL) {
lib_used = 2; /* FAM */
- iter = NULL;
fam_module = mono_dl_open ("libfam.so", MONO_DL_LAZY, NULL);
}
guint slot = gchandle >> 3;
guint type = (gchandle & 7) - 1;
HandleData *handles = &gc_handles [type];
- MonoObject *old_obj = NULL;
if (type > 3)
return;
lock_handles (handles);
if (slot < handles->size && (handles->bitmap [slot / 32] & (1 << (slot % 32)))) {
if (handles->type <= HANDLE_WEAK_TRACK) {
- old_obj = handles->entries [slot];
if (handles->entries [slot])
mono_gc_weak_link_remove (&handles->entries [slot], handles->type == HANDLE_WEAK_TRACK);
if (obj)
INVALID_CAST;
}
break;
+ default:
+ break;
}
if (!ec->valuetype) {
ICALL_EXPORT guint32
ves_icall_type_is_subtype_of (MonoReflectionType *type, MonoReflectionType *c, MonoBoolean check_interfaces)
{
- MonoDomain *domain;
MonoClass *klass;
MonoClass *klassc;
g_assert (type != NULL);
- domain = ((MonoObject *)type)->vtable->domain;
-
if (!c) /* FIXME: dont know what do do here */
return 0;
ICALL_EXPORT guint32
ves_icall_type_is_assignable_from (MonoReflectionType *type, MonoReflectionType *c)
{
- MonoDomain *domain;
MonoClass *klass;
MonoClass *klassc;
g_assert (type != NULL);
- domain = ((MonoObject *)type)->vtable->domain;
-
klass = mono_class_from_mono_type (type->type);
klassc = mono_class_from_mono_type (c->type);
COMPARE_ENUM_VALUES (guint64);
case MONO_TYPE_I8:
COMPARE_ENUM_VALUES (gint64);
+ default:
+ break;
}
#undef COMPARE_ENUM_VALUES
/* indicates that the enum was of an unsupported unerlying type */
{
MonoDomain *domain = mono_object_domain (type);
MonoClass *enumc = mono_class_from_mono_type (type->type);
- guint j = 0, nvalues, crow;
+ guint j = 0, nvalues;
gpointer iter;
MonoClassField *field;
int base_type;
*names = mono_array_new (domain, mono_defaults.string_class, nvalues);
*values = mono_array_new (domain, mono_defaults.uint64_class, nvalues);
- crow = -1;
iter = NULL;
while ((field = mono_class_get_fields (enumc, &iter))) {
const char *p;
- int len;
MonoTypeEnum def_type;
if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC))
mono_array_setref (*names, j, mono_string_new (domain, mono_field_get_name (field)));
p = mono_class_get_field_default_value (field, &def_type);
- len = mono_metadata_decode_blob_size (p, &p);
+ /* len = */ mono_metadata_decode_blob_size (p, &p);
field_value = read_enum_value (p, base_type);
mono_array_set (*values, guint64, j, field_value);
MonoClass *startklass;
MonoMethod *method;
gpointer iter;
- int len, match, nslots;
+ int match, nslots;
/*FIXME, use MonoBitSet*/
guint32 method_slots_default [8];
guint32 *method_slots = NULL;
startklass = klass;
*ex = NULL;
- len = 0;
if (name != NULL)
compare_func = (ignore_case) ? mono_utf8_strcasecmp : strcmp;
}
transitioned++;
} else {
- time_t te;
- te = mktime (&tt);
-
mono_array_setref ((*names), 0, mono_string_new (domain, tzone));
mono_array_set ((*data), gint64, 1, ((gint64)t1 + EPOCH_ADJUST) * 10000000L);
if (gmtoff_ds == 0) {
{
MonoCLIImageInfo *iinfo = image->image_info;
MonoSectionTable *sect;
- gboolean writable;
g_return_val_if_fail (section < iinfo->cli_section_count, FALSE);
sect = &iinfo->cli_section_tables [section];
- writable = sect->st_flags & SECT_FLAGS_MEM_WRITE;
-
if (sect->st_raw_data_ptr + sect->st_raw_data_size > image->raw_data_len)
return FALSE;
#ifdef HOST_WIN32
{
const char *heap_tables = image->heap_tables.data;
const guint32 *rows;
- guint64 valid_mask, sorted_mask;
+ guint64 valid_mask;
int valid = 0, table;
int heap_sizes;
image->idx_blob_wide = ((heap_sizes & 0x04) == 4);
valid_mask = read64 (heap_tables + 8);
- sorted_mask = read64 (heap_tables + 16);
rows = (const guint32 *) (heap_tables + 24);
for (table = 0; table < 64; table++){
} else {
image->tables [table].rows = read32 (rows);
}
- /*if ((sorted_mask & ((guint64) 1 << table)) == 0){
- g_print ("table %s (0x%02x) is sorted\n", mono_meta_table_name (table), table);
- }*/
rows++;
valid++;
}
mono_image_load_cli_data (MonoImage *image)
{
MonoCLIImageInfo *iinfo;
- MonoDotNetHeader *header;
iinfo = image->image_info;
- header = &iinfo->cli_header;
/* Load the CLI header */
if (!load_cli_header (image, iinfo))
do_mono_image_load (MonoImage *image, MonoImageOpenStatus *status,
gboolean care_about_cli, gboolean care_about_pecoff)
{
- MonoCLIImageInfo *iinfo;
- MonoDotNetHeader *header;
GSList *errors = NULL;
mono_profiler_module_event (image, MONO_PROFILE_START_LOAD);
mono_image_init (image);
- iinfo = image->image_info;
- header = &iinfo->cli_header;
-
if (status)
*status = MONO_IMAGE_IMAGE_INVALID;
MonoTableInfo *tables = image->tables;
MonoType *sig_type;
guint32 cols[6];
- guint32 nindex, class, class_table;
+ guint32 nindex, class;
const char *fname;
const char *ptr;
guint32 idx = mono_metadata_token_index (token);
switch (class) {
case MONO_MEMBERREF_PARENT_TYPEDEF:
- class_table = MONO_TOKEN_TYPE_DEF;
klass = mono_class_get_checked (image, MONO_TOKEN_TYPE_DEF | nindex, error);
break;
case MONO_MEMBERREF_PARENT_TYPEREF:
- class_table = MONO_TOKEN_TYPE_REF;
klass = mono_class_from_typeref_checked (image, MONO_TOKEN_TYPE_REF | nindex, error);
break;
case MONO_MEMBERREF_PARENT_TYPESPEC:
- class_table = MONO_TOKEN_TYPE_SPEC;
klass = mono_class_get_and_inflate_typespec_checked (image, MONO_TOKEN_TYPE_SPEC | nindex, context, error);
break;
default:
MonoTableInfo *tables = image->tables;
MonoGenericContainer *generic_container = NULL, *container = NULL;
const char *sig = NULL;
- int size;
guint32 cols [MONO_TYPEDEF_SIZE];
mono_error_init (error);
if (!sig) /* already taken from the methodref */
sig = mono_metadata_blob_heap (image, cols [4]);
- size = mono_metadata_decode_blob_size (sig, &sig);
+ /* size = */ mono_metadata_decode_blob_size (sig, &sig);
container = klass->generic_container;
mono_method_signature_checked (MonoMethod *m, MonoError *error)
{
int idx;
- int size;
MonoImage* img;
const char *sig;
gboolean can_cache_signature;
if (!mono_verifier_verify_method_signature (img, sig_offset, error))
return NULL;
- size = mono_metadata_decode_blob_size (sig, &sig_body);
+ /* size = */ mono_metadata_decode_blob_size (sig, &sig_body);
signature = mono_metadata_parse_method_signature_full (img, container, idx, sig_body, NULL, error);
if (!signature)
return;
klass = array->obj.vtable->klass;
- switch (klass->element_class->byval_arg.type) {
- case MONO_TYPE_CLASS:
- for(i = 0; i < array->max_length; ++i)
- mono_marshal_free_ccw (mono_array_get (array, MonoObject*, i));
- free(nativeArray);
- break;
- }
+ if (klass->element_class->byval_arg.type == MONO_TYPE_CLASS) {
+ for(i = 0; i < array->max_length; ++i)
+ mono_marshal_free_ccw (mono_array_get (array, MonoObject*, i));
+ free(nativeArray);
+ }
#endif
}
#endif /* DISABLE_COM */
case MONO_MARSHAL_CONV_SAFEHANDLE: {
- int dar_release_slot, pos;
+ int pos;
- dar_release_slot = mono_mb_add_local (mb, &mono_defaults.boolean_class->byval_arg);
-
- /*
- * The following is ifdefed-out, because I have no way of doing the
- * DangerousRelease when destroying the structure
- */
-#if 0
- /* set release = false */
- mono_mb_emit_icon (mb, 0);
- mono_mb_emit_stloc (mb, dar_release_slot);
- if (!sh_dangerous_add_ref)
- init_safe_handle ();
-
- /* safehandle.DangerousAddRef (ref release) */
- mono_mb_emit_ldloc (mb, 0); /* the source */
- mono_mb_emit_byte (mb, CEE_LDIND_I);
- mono_mb_emit_ldloc_addr (mb, dar_release_slot);
- mono_mb_emit_managed_call (mb, sh_dangerous_add_ref, NULL);
-#endif
mono_mb_emit_ldloc (mb, 0);
mono_mb_emit_byte (mb, CEE_LDIND_I);
pos = mono_mb_emit_branch (mb, CEE_BRTRUE);
mono_marshal_need_free (MonoType *t, MonoMethodPInvoke *piinfo, MonoMarshalSpec *spec)
{
MonoMarshalNative encoding;
- MonoMarshalConv conv;
switch (t->type) {
case MONO_TYPE_VALUETYPE:
case MONO_TYPE_CLASS:
if (t->data.klass == mono_defaults.stringbuilder_class) {
gboolean need_free;
- conv = mono_marshal_get_ptr_to_stringbuilder_conv (piinfo, spec, &need_free);
+ mono_marshal_get_ptr_to_stringbuilder_conv (piinfo, spec, &need_free);
return need_free;
}
return FALSE;
MonoMethod *res;
MonoMethod *inst, *def;
MonoGenericContext *ctx;
- MonoMethod *def_method;
g_assert (orig_method->is_inflated);
- def_method = ((MonoMethodInflated*)orig_method)->declaring;
ctx = mono_method_get_context (orig_method);
/*
case MARSHAL_ACTION_MANAGED_CONV_IN: {
MonoClass *eklass;
guint32 label1, label2, label3;
- int index_var, src_ptr, loc, esize, param_num, num_elem;
+ int index_var, src_ptr, esize, param_num, num_elem;
MonoMarshalConv conv;
gboolean is_string = FALSE;
else
esize = mono_class_native_size (eklass, NULL);
src_ptr = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
- loc = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
mono_mb_emit_byte (mb, CEE_LDNULL);
mono_mb_emit_stloc (mb, conv_arg);
case MARSHAL_ACTION_MANAGED_CONV_OUT: {
MonoClass *eklass;
guint32 label1, label2, label3;
- int index_var, dest_ptr, loc, esize, param_num, num_elem;
+ int index_var, dest_ptr, esize, param_num, num_elem;
MonoMarshalConv conv;
gboolean is_string = FALSE;
esize = mono_class_native_size (eklass, NULL);
dest_ptr = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
- loc = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
/* Check null */
mono_mb_emit_ldloc (mb, conv_arg);
return emit_marshal_vtype (m, argnum, t, spec, conv_arg, conv_arg_type, action);
else
return emit_marshal_object (m, argnum, t, spec, conv_arg, conv_arg_type, action);
+ default:
+ return conv_arg;
}
- return conv_arg;
}
#ifndef DISABLE_JIT
case MONO_TYPE_BOOLEAN:
emit_marshal (&m, argnum, t, spec, tmp_locals [i], NULL, MARSHAL_ACTION_CONV_OUT);
break;
+ default:
+ break;
}
}
case MONO_TYPE_BOOLEAN:
emit_marshal (m, i, t, mspecs [i + 1], tmp_locals [i], NULL, MARSHAL_ACTION_MANAGED_CONV_OUT);
break;
+ default:
+ break;
}
}
else if (invoke_sig->params [i]->attrs & PARAM_ATTRIBUTE_OUT) {
gint32 call_conv;
gint32 charset = 0;
MonoBoolean set_last_error = 0;
- MonoBoolean best_fit_mapping = 0;
- MonoBoolean throw_on_unmappable = 0;
MonoError error;
mono_reflection_create_custom_attr_data_args (mono_defaults.corlib, attr->ctor, attr->data, attr->data_size, &typed_args, &named_args, &arginfo, &error);
} else if (!strcmp (narg->field->name, "SetLastError")) {
set_last_error = *(MonoBoolean*)mono_object_unbox (o);
} else if (!strcmp (narg->field->name, "BestFitMapping")) {
- best_fit_mapping = *(MonoBoolean*)mono_object_unbox (o);
+ // best_fit_mapping = *(MonoBoolean*)mono_object_unbox (o);
} else if (!strcmp (narg->field->name, "ThrowOnUnmappableChar")) {
- throw_on_unmappable = *(MonoBoolean*)mono_object_unbox (o);
+ // throw_on_unmappable = *(MonoBoolean*)mono_object_unbox (o);
} else {
g_assert_not_reached ();
}
MonoMethodSignature *sig;
MonoMethod *res;
MonoGenericContext *ctx = NULL;
- MonoMethod *orig_method = NULL;
MonoGenericContainer *container = NULL;
if (method->is_inflated && !mono_method_get_context (method)->method_inst) {
- orig_method = method;
ctx = &((MonoMethodInflated*)method)->context;
method = ((MonoMethodInflated*)method)->declaring;
container = mono_method_get_generic_container (method);
info = mono_marshal_load_type_info (klass);
for (i = 0; i < info->num_fields; i++) {
- MonoMarshalNative ntype;
MonoMarshalConv conv;
MonoType *ftype = info->fields [i].field->type;
char *cpos;
if (ftype->attrs & FIELD_ATTRIBUTE_STATIC)
continue;
- ntype = mono_type_to_unmanaged (ftype, info->fields [i].mspec, TRUE,
- klass->unicode, &conv);
+ mono_type_to_unmanaged (ftype, info->fields [i].mspec, TRUE,
+ klass->unicode, &conv);
cpos = ptr + info->fields [i].offset;
return res;
}
+ default:
+ break;
}
-
mono_raise_exception (mono_get_exception_argument ("", "No PInvoke conversion exists for value passed to Object-typed parameter."));
-
return NULL;
}
DataDirectory it = ctx->data_directories [RESOURCE_TABLE_IDX];
guint32 offset;
guint16 named_entries, id_entries;
- const char *ptr, *root, *end;
+ const char *ptr;
if (it.rva == 0)
return;
ADD_ERROR (ctx, g_strdup_printf ("Resource section is too small, must be at least 16 bytes long but it's %d long", it.size));
offset = it.translated_offset;
- root = ptr = ctx->data + offset;
- end = root + it.size;
+ ptr = ctx->data + offset;
g_assert (offset != INVALID_OFFSET);
if (type == &type->data.klass->this_arg)
return type;
break;
+ default:
+ break;
}
return NULL;
case MONO_TYPE_ARRAY:
mono_metadata_free_array (type->data.array);
break;
+ default:
+ break;
}
g_free (type);
parse_section_data (MonoImage *m, int *num_clauses, const unsigned char *ptr)
{
unsigned char sect_data_flags;
- const unsigned char *sptr;
int is_fat;
guint32 sect_data_len;
MonoExceptionClause* clauses = NULL;
while (1) {
/* align on 32-bit boundary */
- sptr = ptr = dword_align (ptr);
+ ptr = dword_align (ptr);
sect_data_flags = *ptr;
ptr++;
sect_data_len = ptr [0];
++ptr;
}
- /*
- g_print ("flags: %02x, len: %d\n", sect_data_flags, sect_data_len);
- hex_dump (sptr, 0, sect_data_len+8);
- g_print ("\nheader: ");
- hex_dump (sptr-4, 0, 4);
- g_print ("\n");
- */
-
+
if (sect_data_flags & METHOD_HEADER_SECTION_EHTABLE) {
const unsigned char *p = dword_align (ptr);
int i;
guint32 local_var_sig_tok, max_stack, code_size, init_locals;
const unsigned char *code;
MonoExceptionClause* clauses = NULL;
- int hsize, num_clauses = 0;
+ int num_clauses = 0;
MonoTableInfo *t = &m->tables [MONO_TABLE_STANDALONESIG];
guint32 cols [MONO_STAND_ALONE_SIGNATURE_SIZE];
case METHOD_HEADER_FAT_FORMAT:
fat_flags = read16 (ptr);
ptr += 2;
- hsize = (fat_flags >> 12) & 0xf;
max_stack = read16 (ptr);
ptr += 2;
code_size = read32 (ptr);
clauses = parse_section_data (m, &num_clauses, (const unsigned char*)ptr);
if (local_var_sig_tok) {
const char *locals_ptr;
- int len=0, i, bsize;
+ int len=0, i;
locals_ptr = mono_metadata_blob_heap (m, cols [MONO_STAND_ALONE_SIGNATURE]);
- bsize = mono_metadata_decode_blob_size (locals_ptr, &locals_ptr);
+ mono_metadata_decode_blob_size (locals_ptr, &locals_ptr);
if (*locals_ptr != 0x07)
g_warning ("wrong signature for locals blob");
locals_ptr++;
case MONO_TYPE_VAR:
case MONO_TYPE_MVAR:
return ((hash << 5) - hash) ^ mono_metadata_generic_param_hash (t1->data.generic_param);
+ default:
+ return hash;
}
- return hash;
}
static guint
MonoTableInfo *t;
guint32 cols [MONO_TYPESPEC_SIZE];
const char *ptr;
- guint32 len;
MonoType *type, *type2;
mono_error_init (error);
return NULL;
}
- len = mono_metadata_decode_value (ptr, &ptr);
+ mono_metadata_decode_value (ptr, &ptr);
type = mono_metadata_parse_type_internal (image, NULL, MONO_PARSE_TYPE, 0, TRUE, ptr, &ptr);
if (!type) {
int got_it = 0, i;
char *aname, *cfg, *cfg_name;
const char *bundled_config;
- const char *home;
state.assembly = assembly;
cfg_name = g_strdup_printf ("%s.config", mono_image_get_name (assembly));
- home = g_get_home_dir ();
-
for (i = 0; (aname = get_assembly_filename (assembly, i)) != NULL; ++i) {
cfg = g_build_filename (mono_get_config_dir (), "mono", "assemblies", aname, cfg_name, NULL);
got_it += mono_config_parse_file_with_context (&state, cfg);
g_free (cfg);
#ifdef TARGET_WIN32
+ const char *home = g_get_home_dir ();
cfg = g_build_filename (home, ".mono", "assemblies", aname, cfg_name, NULL);
got_it += mono_config_parse_file_with_context (&state, cfg);
g_free (cfg);
void
mono_debug_domain_create (MonoDomain *domain)
{
- MonoDebugDataTable *table;
-
if (!mono_debug_initialized)
return;
mono_debugger_lock ();
- table = create_data_table (domain);
+ create_data_table (domain);
mono_debugger_unlock ();
}
{
MonoDebugDataTable *table;
MonoDebugMethodAddress *address;
- MonoDebugMethodInfo *minfo;
- MonoDebugHandle *handle;
guint8 buffer [BUFSIZ];
guint8 *ptr, *oldptr;
guint32 i, size, total_size, max_size;
table = lookup_data_table (domain);
- handle = mono_debug_get_image (method->klass->image);
- minfo = mono_debug_lookup_method_internal (method);
-
max_size = (5 * 5) + 1 + (10 * jit->num_line_numbers) +
(25 + sizeof (gpointer)) * (1 + jit->num_params + jit->num_locals);
{
int diff = ABS (hash->last_rehash - hash->in_use);
RehashData data;
- void *old_table;
+ void *old_table G_GNUC_UNUSED; /* unused on Boehm */
/* These are the factors to play with to change the rehashing strategy */
/* I played with them with a large range, and could not really get */
{
SharedInstance* inst;
char *p;
- int size, data_offset;
+ int size;
inst = find_custom_instance (cat, name);
if (inst)
return inst;
size = sizeof (SharedInstance) + strlen (name);
size += 7;
size &= ~7;
- data_offset = size;
size += (sizeof (guint64) * cat->num_counters);
perfctr_lock ();
inst = (SharedInstance*) shared_data_reserve_room (size, FTYPE_INSTANCE);
mono_perfcounter_foreach_shared_item (SharedHeader *header, gpointer data)
{
int i;
- char *p, *name, *help;
+ char *p, *name;
unsigned char type;
- int seq_num;
void *addr;
SharedCategory *cat;
SharedCounter *counter;
for (i = 0; i < cat->num_counters; ++i) {
counter = (SharedCounter*) p;
type = (unsigned char)*p++;
- seq_num = (int)*p++;
+ /* seq_num = (int)* */ p++;
name = p;
p += strlen (p) + 1;
- help = p;
+ /* help = p; */
p += strlen (p) + 1;
inst = custom_get_instance (cat, counter, name);
size_t imt_table_bytes;
int gc_bits;
guint32 vtable_size, class_size;
- guint32 cindex;
gpointer iter;
gpointer *interface_offsets;
mono_stats.class_static_data_size += class_size;
}
- cindex = -1;
iter = NULL;
while ((field = mono_class_get_fields (class, &iter))) {
if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC))
return o;
}
+#ifndef HAVE_SGEN_GC
/**
* mono_object_allocate_ptrfree:
* @size: number of bytes to allocate
ALLOC_PTRFREE (o, vtable, size);
return o;
}
+#endif
static inline void *
mono_object_allocate_spec (size_t size, MonoVTable *vtable)
mono_delegate_ctor_with_method (MonoObject *this, MonoObject *target, gpointer addr, MonoMethod *method)
{
MonoDelegate *delegate = (MonoDelegate *)this;
- MonoClass *class;
g_assert (this);
g_assert (addr);
if (method)
delegate->method = method;
- class = this->vtable->klass;
mono_stats.delegate_creations++;
#ifndef DISABLE_REMOTING
MonoDomain *domain = mono_domain_get ();
MonoMethodSignature *sig = mono_method_signature (method);
MonoMethodMessage *msg;
- int i, count, type;
+ int i, count;
msg = (MonoMethodMessage *)mono_object_new (domain, mono_defaults.mono_method_message_class);
else
vpos = params [i];
- type = sig->params [i]->type;
class = mono_class_from_mono_type (sig->params [i]);
if (class->valuetype)
encode_constant (MonoDynamicImage *assembly, MonoObject *val, guint32 *ret_type) {
char blob_size [64];
char *b = blob_size;
- char *p, *box_val;
+ char *box_val;
char* buf;
guint32 idx = 0, len = 0, dummy = 0;
- p = buf = g_malloc (64);
+ buf = g_malloc (64);
if (!val) {
*ret_type = MONO_TYPE_CLASS;
len = 4;
guint32 token;
MonoClass *klass;
MonoGenericClass *gclass;
- MonoDynamicGenericClass *dgclass;
MonoType *type;
char *name;
klass = mono_class_from_mono_type (type);
gclass = type->data.generic_class;
g_assert (gclass->is_dynamic);
- dgclass = (MonoDynamicGenericClass *) gclass;
name = mono_string_to_utf8 (fb->name);
token = mono_image_get_memberref_token (assembly, &klass->byval_arg, name,
if (is_sre_ctor_builder (mono_object_class (c->cb))) {
MonoReflectionCtorBuilder *cb = (MonoReflectionCtorBuilder *)c->cb;
- MonoDynamicGenericClass *dgclass;
ReflectionMethodBuilder rmb;
char *name;
gclass = type->data.generic_class;
g_assert (gclass->is_dynamic);
- dgclass = (MonoDynamicGenericClass *) gclass;
reflection_methodbuilder_from_ctor_builder (&rmb, cb);
mono_image_get_generic_field_token (MonoDynamicImage *assembly, MonoReflectionFieldBuilder *fb)
{
MonoDynamicTable *table;
- MonoClass *klass;
MonoType *custom = NULL, *type;
guint32 *values;
guint32 token, pclass, parent, sig;
if (token)
return token;
- klass = mono_class_from_mono_type (mono_reflection_type_get_handle (fb->typeb));
+ /* FIXME: is this call necessary? */
+ mono_class_from_mono_type (mono_reflection_type_get_handle (fb->typeb));
name = mono_string_to_utf8 (fb->name);
/*FIXME this is one more layer of ugliness due how types are created.*/
{
SigBuffer buf;
guint32 nargs;
- guint32 size;
guint32 i, idx;
if (!assembly->save)
else
nargs = 0;
- size = 10 + (nargs * 10);
-
sigbuffer_init (&buf, 32);
/* Encode calling convention */
for (i = 0; i < inst->type_argc; ++i)
if (!verify_safe_for_managed_space (inst->type_argv [i]))
return FALSE;
- break;
+ return TRUE;
}
#endif
case MONO_TYPE_VAR:
case MONO_TYPE_MVAR:
return TRUE;
+ default:
+ return TRUE;
}
- return TRUE;
}
static MonoType*
MonoClass *klass;
MonoReflectionTypeBuilder *tb = NULL;
gboolean is_dynamic = FALSE;
- MonoDomain *domain;
MonoClass *geninst;
mono_loader_lock ();
- domain = mono_object_domain (type);
-
if (is_sre_type_builder (mono_object_class (type))) {
tb = (MonoReflectionTypeBuilder *) type;
}
return;
}
+ default:
+ break;
}
if (mono_object_class (src) == mono_defaults.stringbuilder_class) {
return MONO_MARSHAL_COPY;
break;
}
+ default:
+ break;
}
-
return MONO_MARSHAL_SERIALIZE;
}
}
return (MonoObject *) acopy;
}
+ default:
+ break;
}
if (mono_object_class (val) == mono_defaults.stringbuilder_class) {
void
sgen_bridge_processing_finish (int generation)
{
- unsigned long step_8;
- SGEN_TV_DECLARE (atv);
- SGEN_TV_DECLARE (btv);
-
bridge_processor.processing_build_callback_data (generation);
if (compare_bridge_processors ())
compare_to_bridge_processor.processing_build_callback_data (generation);
if (compare_bridge_processors ())
sgen_compare_bridge_processor_results (&bridge_processor, &compare_to_bridge_processor);
- SGEN_TV_GETTIME (btv);
-
null_weak_links_to_dead_objects (&bridge_processor, generation);
free_callback_data (&bridge_processor);
if (compare_bridge_processors ())
free_callback_data (&compare_to_bridge_processor);
- SGEN_TV_GETTIME (atv);
- step_8 = SGEN_TV_ELAPSED (btv, atv);
-
after_callback:
bridge_processor.processing_after_callback (generation);
if (compare_bridge_processors ())
GrayQueue *queue = ctx.queue;
SgenHashTable *hash_table = get_finalize_entry_hash_table (generation);
MonoObject *object;
- gpointer dummy;
+ gpointer dummy G_GNUC_UNUSED;
char *copy;
SgenPointerQueue moved_fin_objects;
GrayQueue *queue = ctx.queue;
SgenHashTable *hash_table = get_finalize_entry_hash_table (generation);
MonoObject *object;
- gpointer dummy;
+ gpointer dummy G_GNUC_UNUSED;
SgenPointerQueue moved_fin_objects;
sgen_pointer_queue_init (&moved_fin_objects, INTERNAL_MEM_TEMPORARY);
SgenHashTable *hash_table)
{
MonoObject *object;
- gpointer dummy;
+ gpointer dummy G_GNUC_UNUSED;
int count;
if (no_finalize || !out_size || !out_array)
CopyOrMarkObjectFunc copy_func = ctx.copy_func;
GrayQueue *queue = ctx.queue;
void **link;
- gpointer dummy;
+ gpointer dummy G_GNUC_UNUSED;
SgenHashTable *hash = get_dislink_hash_table (generation);
SGEN_HASH_TABLE_FOREACH (hash, link, dummy) {
sgen_null_links_for_domain (MonoDomain *domain, int generation)
{
void **link;
- gpointer dummy;
+ gpointer dummy G_GNUC_UNUSED;
SgenHashTable *hash = get_dislink_hash_table (generation);
SGEN_HASH_TABLE_FOREACH (hash, link, dummy) {
char *object = DISLINK_OBJECT (link);
sgen_null_links_with_predicate (int generation, WeakLinkAlivePredicateFunc predicate, void *data)
{
void **link;
- gpointer dummy;
+ gpointer dummy G_GNUC_UNUSED;
SgenHashTable *hash = get_dislink_hash_table (generation);
SGEN_HASH_TABLE_FOREACH (hash, link, dummy) {
char *object = DISLINK_OBJECT (link);
{
SgenHashTable *hash_table = get_finalize_entry_hash_table (generation);
MonoObject *object;
- gpointer dummy;
+ gpointer dummy G_GNUC_UNUSED;
SGEN_HASH_TABLE_FOREACH (hash_table, object, dummy) {
object = tagged_object_get_object (object);
* ######################################################################
*/
-inline static void*
-align_pointer (void *ptr)
-{
- mword p = (mword)ptr;
- p += sizeof (gpointer) - 1;
- p &= ~ (sizeof (gpointer) - 1);
- return (void*)p;
-}
-
typedef SgenGrayQueue GrayQueue;
/* forward declarations */
char *end = section->data + section->size;
char *occ_start = NULL;
GCVTable *vt;
- char *old_start = NULL; /* just for debugging */
+ char *old_start G_GNUC_UNUSED = NULL; /* just for debugging */
fprintf (heap_dump_file, "<section type=\"%s\" size=\"%lu\">\n", type, (unsigned long)section->size);
while (start < end) {
guint size;
- MonoClass *class;
+ MonoClass *class G_GNUC_UNUSED;
if (!*(void**)start) {
if (occ_start) {
static void
check_nursery_is_clean (void)
{
- char *start, *end, *cur;
+ char *end, *cur;
- start = cur = sgen_get_nursery_start ();
+ cur = sgen_get_nursery_start ();
end = sgen_get_nursery_end ();
while (cur < end) {
- size_t ss, size;
+ size_t size;
if (!*(void**)cur) {
cur += sizeof (void*);
g_assert (!object_is_forwarded (cur));
g_assert (!object_is_pinned (cur));
- ss = safe_object_get_size ((MonoObject*)cur);
size = ALIGN_UP (safe_object_get_size ((MonoObject*)cur));
verify_scan_starts (cur, cur + size);
int dummy;
gboolean debug_print_allowance = FALSE;
double allowance_ratio = 0, save_target = 0;
- gboolean have_split_nursery = FALSE;
gboolean cement_enabled = TRUE;
mono_counters_init ();
sgen_simple_nursery_init (&sgen_minor_collector);
} else if (!strcmp (minor_collector_opt, "split")) {
sgen_split_nursery_init (&sgen_minor_collector);
- have_split_nursery = TRUE;
} else {
sgen_env_var_error (MONO_GC_PARAMS_NAME, "Using `simple` instead.", "Unknown minor collector `%s'.", minor_collector_opt);
goto use_simple_nursery;
case GC_BRIDGE_OPAQUE_CLASS:
res = SGEN_GC_BIT_BRIDGE_OPAQUE_OBJECT;
break;
+ case GC_BRIDGE_TRANSPARENT_CLASS:
+ break;
}
}
if (fin_callbacks.is_class_finalization_aware) {
LOSObject *obj;
for (obj = los_object_list; obj; obj = obj->next) {
- MonoVTable *vtable;
const char *los_kind;
mword size;
gboolean pinned;
else
los_kind = "los-ptr";
- vtable = (MonoVTable*)SGEN_LOAD_VTABLE (obj->data);
-
if (obj->data == ptr) {
SGEN_LOG (0, "%s (size %d pin %d)\n", los_kind, (int)size, pinned ? 1 : 0);
} else {
static void
free_data (void)
{
- MonoObject *obj;
+ MonoObject *obj G_GNUC_UNUSED;
HashEntry *entry;
int total_srcs = 0;
int max_srcs = 0;
{
int i;
int bridge_count;
- MonoObject *obj;
+ MonoObject *obj G_GNUC_UNUSED;
HashEntry *entry;
SGEN_TV_DECLARE (atv);
SGEN_TV_DECLARE (btv);
int i, j;
int num_sccs, num_xrefs;
int max_entries, max_xrefs;
- int sccs_size;
- MonoObject *obj;
+ MonoObject *obj G_GNUC_UNUSED;
HashEntry *entry;
HashEntry **all_entries;
MonoGCBridgeSCC **api_sccs;
}
}
- sccs_size = dyn_array_scc_size (&sccs);
-
for (i = 0; i < hash_table.num_entries; ++i) {
HashEntry *entry = all_entries [i];
second_pass_links += dyn_array_ptr_size (&entry->srcs);
while (pin_entry < pin_end || frags_ranges) {
char *addr0, *addr1;
size_t size;
- SgenFragment *last_frag = NULL;
addr0 = addr1 = sgen_nursery_end;
if (pin_entry < pin_end)
} else {
frag_end = addr1;
size = frags_ranges->fragment_next - addr1;
- last_frag = frags_ranges;
frags_ranges = frags_ranges->next_in_order;
}
static void
free_data (void)
{
- MonoObject *obj;
+ MonoObject *obj G_GNUC_UNUSED;
HashEntry *entry;
int total_srcs = 0;
int max_srcs = 0;
int i, j;
int num_sccs, num_xrefs;
int max_entries, max_xrefs;
- int sccs_size;
- MonoObject *obj;
+ MonoObject *obj G_GNUC_UNUSED;
HashEntry *entry;
HashEntry **all_entries;
MonoGCBridgeSCC **api_sccs;
}
}
- sccs_size = dyn_array_scc_size (&sccs);
-
for (i = 0; i < hash_table.num_entries; ++i) {
HashEntry *entry = all_entries [i];
second_pass_links += dyn_array_ptr_size (&entry->srcs);
return region_age [idx];
}
-static inline void
-set_object_age (char *object, int age)
-{
- size_t idx = (object - sgen_nursery_start) >> SGEN_TO_SPACE_GRANULE_BITS;
- region_age [idx] = age;
-}
-
static void
set_age_in_range (char *start, char *end, int age)
{
monitor_heuristic (gint16 *current, gint16 *history_size, SamplesHistory *history, ThreadPool *tp)
{
int i;
- gint8 decision;
+ gint8 decision G_GNUC_UNUSED;
gint16 cur, max = 0;
gboolean all_waitsleepjoin;
MonoInternalThread *thread;
SocketIOData *socket_io_data;
tp_poll_data *data;
char msg [1];
- int unused;
+ int unused G_GNUC_UNUSED;
socket_io_data = p;
data = socket_io_data->event_data;
return FALSE;
break;
}
+ default:
+ break;
}
return TRUE;
}
* is it a "class Foo<T>" or a "struct Foo<T>"?
*/
return !arg->type->data.generic_class->container_class->valuetype;
+ default:
+ return FALSE;
}
default:
return FALSE;
case MONO_TYPE_PTR:
case MONO_TYPE_TYPEDBYREF:
CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Invalid value for %s at 0x%04x", opcode, ctx->ip_offset));
+ default:
+ break;
}
do_box = is_boxed || mono_type_is_generic_argument(type) || mono_class_from_mono_type (type)->valuetype;
static void
do_localloc (VerifyContext *ctx)
{
- ILStackDesc *top;
-
if (ctx->eval.size != 1) {
ADD_VERIFY_ERROR (ctx, g_strdup_printf ("Stack must have only size item in localloc at 0x%04x", ctx->ip_offset));
return;
}
/*TODO verify top type*/
- top = stack_pop (ctx);
+ /* top = */ stack_pop (ctx);
set_stack_value (ctx, stack_push (ctx), &mono_defaults.int_class->byval_arg, FALSE);
CODE_NOT_VERIFIABLE (ctx, g_strdup_printf ("Instruction localloc in never verifiable at 0x%04x", ctx->ip_offset));
MonoSimpleBasicBlock *bb = NULL, *original_bb = NULL;
int i, n, need_merge = 0, start = 0;
- guint token, ip_offset = 0, prefix = 0;
+ guint ip_offset = 0, prefix = 0;
MonoGenericContext *generic_context = NULL;
MonoImage *image;
VerifyContext ctx;
code_bounds_check (5);
if (ctx.eval.size)
ADD_VERIFY_ERROR (&ctx, g_strdup_printf ("Eval stack must be empty in jmp at 0x%04x", ip_offset));
- token = read32 (ip + 1);
+ /* token = read32 (ip + 1); */
if (in_any_block (ctx.header, ip_offset))
ADD_VERIFY_ERROR (&ctx, g_strdup_printf ("jmp cannot escape exception blocks at 0x%04x", ip_offset));
case CEE_CALLI:
code_bounds_check (5);
- token = read32 (ip + 1);
+ /* token = read32 (ip + 1); */
/*
* FIXME: check signature, retval, arguments etc.
* FIXME: check requirements for tail call
img_writer_emit_section_change (acfg->w, section_name, subsection_index);
}
-static inline void
-emit_push_section (MonoAotCompile *acfg, const char *section_name, int subsection)
-{
- img_writer_emit_push_section (acfg->w, section_name, subsection);
-}
-
-static inline void
-emit_pop_section (MonoAotCompile *acfg)
-{
- img_writer_emit_pop_section (acfg->w);
-}
-
static inline void
emit_local_symbol (MonoAotCompile *acfg, const char *name, const char *end_label, gboolean func)
{
}
}
-static inline void
-emit_pointer_unaligned (MonoAotCompile *acfg, const char *target)
-{
- img_writer_emit_pointer_unaligned (acfg->w, target);
-}
-
static inline void
emit_pointer (MonoAotCompile *acfg, const char *target)
{
MonoMethodSignature *sig = mono_method_signature (e->ctor);
const char *p = (const char*)e->data;
const char *named;
- int slen, num_named, named_type, data_type;
+ int slen, num_named, named_type;
char *n;
MonoType *t;
MonoClass *klass;
if (num_named == 1) {
int name_len;
char *name;
- MonoType *prop_type;
/* parse ExportSymbol attribute */
named = p;
named_type = *named;
named += 1;
- data_type = *named;
+ /* data_type = *named; */
named += 1;
name_len = mono_metadata_decode_blob_size (named, &named);
g_assert (named_type == 0x54);
g_assert (!strcmp (name, "ExportSymbol"));
- prop_type = &mono_defaults.string_class->byval_arg;
-
/* load_cattr_value (), string case */
g_assert (*named != (char)0xff);
slen = mono_metadata_decode_value (named, &named);
static void
emit_and_reloc_code (MonoAotCompile *acfg, MonoMethod *method, guint8 *code, guint32 code_len, MonoJumpInfo *relocs, gboolean got_only, MonoDebugMethodJitInfo *debug_info)
{
- int i, pindex, start_index, method_index;
+ int i, pindex, start_index;
GPtrArray *patches;
MonoJumpInfo *patch_info;
- MonoMethodHeader *header;
MonoDebugSourceLocation **locs = NULL;
gboolean skip;
#ifdef MONO_ARCH_AOT_SUPPORTED
const char *direct_pinvoke;
#endif
- if (method) {
- header = mono_method_get_header (method);
-
- method_index = get_method_index (acfg, method);
- }
-
if (acfg->gas_line_numbers && method && debug_info) {
locs = compute_line_numbers (method, code_len, debug_info);
if (!locs) {
char *debug_sym = NULL;
char *symbol = NULL;
int func_alignment = AOT_FUNC_ALIGNMENT;
- MonoMethodHeader *header;
char *export_name;
method = cfg->orig_method;
code = cfg->native_code;
- header = cfg->header;
method_index = get_method_index (acfg, method);
symbol = g_strdup_printf ("%sme_%x", acfg->temp_prefix, method_index);
int pindex, buf_size, n_patches;
GPtrArray *patches;
MonoJumpInfo *patch_info;
- MonoMethodHeader *header;
guint32 method_index;
guint8 *p, *buf;
guint32 first_got_offset;
method = cfg->orig_method;
- header = mono_method_get_header (method);
method_index = get_method_index (acfg, method);
static void
emit_exception_debug_info (MonoAotCompile *acfg, MonoCompile *cfg, gboolean store_seq_points)
{
- MonoMethod *method;
- int i, k, buf_size, method_index;
+ int i, k, buf_size;
guint32 debug_info_size, seq_points_size;
guint8 *code;
MonoMethodHeader *header;
gboolean use_unwind_ops = FALSE;
MonoSeqPointInfo *seq_points;
- method = cfg->orig_method;
code = cfg->native_code;
header = cfg->header;
- method_index = get_method_index (acfg, method);
-
if (!acfg->aot_opts.nodebug) {
mono_debug_serialize_debug_info (cfg, &debug_info, &debug_info_size);
} else {
if (jinfo->has_generic_jit_info) {
MonoGenericJitInfo *gi = mono_jit_info_get_generic_jit_info (jinfo);
MonoGenericSharingContext* gsctx = gi->generic_sharing_context;
- guint8 *p1;
guint8 *buf2, *p2;
int len;
- p1 = p;
encode_value (gi->nlocs, p, &p);
if (gi->nlocs) {
for (i = 0; i < gi->nlocs; ++i) {
for (i = 0; i < acfg->plt_offset; ++i) {
char *debug_sym = NULL;
MonoPltEntry *plt_entry = NULL;
- MonoJumpInfo *ji;
if (i == 0)
/*
continue;
plt_entry = g_hash_table_lookup (acfg->plt_offset_to_entry, GUINT_TO_POINTER (i));
- ji = plt_entry->ji;
debug_sym = plt_entry->debug_sym;
for (i = 0; i < acfg->plt_offset; ++i) {
char *debug_sym = NULL;
MonoPltEntry *plt_entry = NULL;
- MonoJumpInfo *ji;
if (i == 0)
continue;
plt_entry = g_hash_table_lookup (acfg->plt_offset_to_entry, GUINT_TO_POINTER (i));
- ji = plt_entry->ji;
/* Skip plt entries not actually called by LLVM code */
if (!plt_entry->llvm_used)
mono_aot_get_offset (guint32 *table, int index)
{
int i, group, ngroups, index_entry_size;
- int start_offset, offset, noffsets, group_size;
+ int start_offset, offset, group_size;
guint8 *data_start, *p;
guint32 *index32 = NULL;
guint16 *index16 = NULL;
- noffsets = table [0];
+ /* noffsets = table [0]; */
group_size = table [1];
ngroups = table [2];
index_entry_size = table [3];
{
MonoMethodSignature *sig;
guint32 flags;
- int i, param_count, call_conv, gen_param_count = 0;
+ int i, param_count, call_conv;
guint8 *p = buf;
gboolean hasthis, explicit_this, has_gen_params;
call_conv = flags & 0x0F;
if (has_gen_params)
- gen_param_count = decode_value (p, &p);
+ /* gen_param_count = */ decode_value (p, &p);
param_count = decode_value (p, &p);
if (target && param_count != target->param_count)
return NULL;
guint8 *fde, *cie, *code_start, *code_end;
int version, fde_count;
gint32 *table;
- int i, j, pos, left, right, offset, offset1, offset2, code_len, func_encoding;
+ int i, j, pos, left, right, offset, offset1, offset2, code_len;
MonoJitExceptionInfo *ei;
guint32 fde_len, ei_len, nested_len, nindex;
gpointer *type_info;
version = *p;
g_assert (version == 3);
p ++;
- func_encoding = *p;
+ /* func_encoding = *p; */
p ++;
p = ALIGN_PTR_TO (p, 4);
gboolean has_generic_jit_info, has_dwarf_unwind_info, has_clauses, has_seq_points, has_try_block_holes, has_arch_eh_jit_info;
gboolean from_llvm, has_gc_map;
guint8 *p;
- int generic_info_size, try_holes_info_size, num_holes, arch_eh_jit_info_size;
+ int try_holes_info_size, num_holes;
int this_reg = 0, this_offset = 0;
gboolean async;
} else {
unwind_info = decode_value (p, &p);
}
- if (has_generic_jit_info) {
+ if (has_generic_jit_info)
flags |= JIT_INFO_HAS_GENERIC_JIT_INFO;
- generic_info_size = sizeof (MonoGenericJitInfo);
- } else {
- generic_info_size = 0;
- }
if (has_try_block_holes) {
num_holes = decode_value (p, &p);
if (has_arch_eh_jit_info) {
flags |= JIT_INFO_HAS_ARCH_EH_INFO;
- arch_eh_jit_info_size = sizeof (MonoArchEHJitInfo);
/* Overwrite the original code_len which includes alignment padding */
code_len = decode_value (p, &p);
- } else {
- arch_eh_jit_info_size = 0;
}
/* Exception table */
MonoAotModule *amodule = image->aot_module;
MonoMethod *method = NULL;
MonoJitInfo *jinfo;
- guint8 *code, *code_end, *ex_info, *p;
+ guint8 *code, *ex_info, *p;
guint32 *table;
int nmethods;
gint32 *code_offsets;
code_offsets = amodule->sorted_code_offsets;
offsets_len = amodule->sorted_code_offsets_len;
- code_end = amodule->jit_code_end > amodule->llvm_code_end ? amodule->jit_code_end : amodule->llvm_code_end;
-
/* Binary search in the sorted_code_offsets table */
left = 0;
right = offsets_len;
* optimize_branches () since the IR is already optimized.
*/
for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
- MonoBasicBlock *bb1, *bb2, *true_bb, *false_bb, *next_bb;
+ MonoBasicBlock *bb1, *bb2, *next_bb;
MonoInst *branch1, *branch2, *compare1, *ins, *next;
/* Look for the IR code generated from if (<var> < 0 || v > <limit>)
if (!(branch1 && ((branch1->opcode == OP_IBLT) || (branch1->opcode == OP_LBLT)) && (branch1->inst_false_bb == next_bb)))
continue;
- true_bb = branch1->inst_true_bb;
-
/* Check second branch */
branch2 = mono_bb_last_inst (next_bb, filter);
if (!branch2)
/* mcs sometimes generates inverted branches */
if (((branch2->opcode == OP_IBGT) || (branch2->opcode == OP_LBGT)) && branch2->inst_true_bb == branch1->inst_true_bb)
- false_bb = branch2->inst_false_bb;
+ ;
else if (((branch2->opcode == OP_IBLE) || (branch2->opcode == OP_LBLE)) && branch2->inst_false_bb == branch1->inst_true_bb)
- false_bb = branch2->inst_true_bb;
+ ;
else
continue;
MonoDebugMethodJitInfo *jit;
MonoMethodHeader *header;
MonoMethodSignature *sig;
- MonoDebugMethodAddress *debug_info;
MonoMethod *method;
int i;
for (i = 0; i < jit->num_line_numbers; i++)
jit->line_numbers [i] = g_array_index (info->line_numbers, MonoDebugLineNumberEntry, i);
- debug_info = mono_debug_add_method (cfg->method_to_register, jit, cfg->domain);
+ mono_debug_add_method (cfg->method_to_register, jit, cfg->domain);
mono_debug_add_vg_method (method, jit);
DebuggerTlsData *tls;
StackFrame *frame;
MonoDebugMethodJitInfo *jit;
- MonoDebugVarInfo *var;
MonoMethodSignature *sig;
gssize id;
MonoMethodHeader *header;
g_assert (pos >= 0 && pos < jit->num_params);
- var = &jit->params [pos];
-
add_var (buf, jit, sig->params [pos], &jit->params [pos], &frame->ctx, frame->domain, FALSE);
} else {
g_assert (pos >= 0 && pos < jit->num_locals);
- var = &jit->locals [pos];
-
add_var (buf, jit, header->locals [pos], &jit->locals [pos], &frame->ctx, frame->domain, FALSE);
}
}
img_writer_emit_pop_section (w->w);
}
-static inline void
-emit_local_symbol (MonoDwarfWriter *w, const char *name, const char *end_label, gboolean func)
-{
- img_writer_emit_local_symbol (w->w, name, end_label, func);
-}
-
static inline void
emit_label (MonoDwarfWriter *w, const char *name)
{
img_writer_emit_symbol_diff (w->w, end, start, offset);
}
-static inline void
-emit_zero_bytes (MonoDwarfWriter *w, int num)
-{
- img_writer_emit_zero_bytes (w->w, num);
-}
-
static inline void
emit_byte (MonoDwarfWriter *w, guint8 val)
{
iter = NULL;
while ((field = mono_class_get_fields (klass, &iter))) {
const char *p;
- int len;
MonoTypeEnum def_type;
if (strcmp ("value__", mono_field_get_name (field)) == 0)
emit_string (w, mono_field_get_name (field));
p = mono_class_get_field_default_value (field, &def_type);
- len = mono_metadata_decode_blob_size (p, &p);
+ /* len = */ mono_metadata_decode_blob_size (p, &p);
switch (mono_class_enum_basetype (klass)->type) {
case MONO_TYPE_U1:
case MONO_TYPE_I1:
char *as_file;
char *o_file;
char *cmd;
- int unused;
+ int unused G_GNUC_UNUSED;
#ifdef HOST_WIN32
as_file = g_strdup_printf ("%s/test.s", tmp);
static int
bin_writer_emit_writeout (MonoImageWriter *acfg)
{
- FILE *file;
ElfHeader header;
ElfProgHeader progh [4];
ElfSectHeader secth [SECT_NUM];
ElfSymbol *symtab;
ElfDynamic dynamic [14];
int *hash;
- int i, num_sections, file_offset, virt_offset, size, num_symtab;
+ int i, num_sections, file_offset, virt_offset, size;
int num_local_syms;
- file = acfg->fp;
-
/* Section headers */
memset (§h, 0, sizeof (secth));
memset (&dynamic, 0, sizeof (dynamic));
num_sections = collect_sections (acfg, secth, all_sections, 16);
hash = build_hash (acfg, num_sections, &dyn_str_table);
- num_symtab = hash [1]; /* FIXME */
#if 0
g_print ("num_sections: %d\n", num_sections);
g_print ("dynsym: %d, dynstr size: %d\n", hash [1], (int)dyn_str_table.data->len);
num_sregs = mono_inst_get_src_registers (ins, sregs);
for (srcindex = 0; srcindex < num_sregs; ++srcindex) {
MonoInst *def;
- int nregs;
- nregs = mono_inst_get_src_registers (ins, sregs);
+ mono_inst_get_src_registers (ins, sregs);
regtype = spec [MONO_INST_SRC1 + srcindex];
sreg = sregs [srcindex];
mini_emit_stobj (MonoCompile *cfg, MonoInst *dest, MonoInst *src, MonoClass *klass, gboolean native)
{
MonoInst *iargs [4];
- int context_used, n;
+ int n;
guint32 align = 0;
MonoMethod *memcpy_method;
MonoInst *size_ins = NULL;
if (mini_is_gsharedvt_klass (cfg, klass)) {
g_assert (!native);
- context_used = mini_class_check_context_used (cfg, klass);
size_ins = emit_get_gsharedvt_info_klass (cfg, klass, MONO_RGCTX_INFO_VALUE_SIZE);
memcpy_ins = emit_get_gsharedvt_info_klass (cfg, klass, MONO_RGCTX_INFO_MEMCPY);
}
mini_emit_initobj (MonoCompile *cfg, MonoInst *dest, const guchar *ip, MonoClass *klass)
{
MonoInst *iargs [3];
- int n, context_used;
+ int n;
guint32 align;
MonoMethod *memset_method;
MonoInst *size_ins = NULL;
/* FIXME: Optimize this for the case when dest is an LDADDR */
mono_class_init (klass);
if (mini_is_gsharedvt_klass (cfg, klass)) {
- context_used = mini_class_check_context_used (cfg, klass);
size_ins = emit_get_gsharedvt_info_klass (cfg, klass, MONO_RGCTX_INFO_VALUE_SIZE);
bzero_ins = emit_get_gsharedvt_info_klass (cfg, klass, MONO_RGCTX_INFO_BZERO);
if (!bzero_method)
MonoInst *addr = emit_get_gsharedvt_info_klass (cfg, klass, MONO_RGCTX_INFO_NULLABLE_CLASS_UNBOX);
MonoInst *unbox_call;
MonoMethodSignature *unbox_sig;
- MonoInst *var;
-
- var = mono_compile_create_var (cfg, &klass->byval_arg, OP_LOCAL);
unbox_sig = mono_mempool_alloc0 (cfg->mempool, MONO_SIZEOF_METHOD_SIGNATURE + (1 * sizeof (MonoType *)));
unbox_sig->ret = &klass->byval_arg;
if (mini_is_gsharedvt_klass (cfg, klass)) {
MonoBasicBlock *is_ref_bb, *is_nullable_bb, *end_bb;
MonoInst *res, *is_ref, *src_var, *addr;
- int addr_reg, dreg;
+ int dreg;
dreg = alloc_ireg (cfg);
/* Ref case */
MONO_START_BB (cfg, is_ref_bb);
- addr_reg = alloc_ireg (cfg);
/* val is a vtype, so has to load the value manually */
src_var = get_vreg_to_inst (cfg, val->dreg);
{
MonoType *enum_type = mono_type_get_underlying_type (&klass->byval_arg);
guint32 load_opc = mono_type_to_load_membase (cfg, enum_type);
- gboolean is_i4 = TRUE;
+ gboolean is_i4;
switch (enum_type->type) {
case MONO_TYPE_I8:
#endif
is_i4 = FALSE;
break;
+ default:
+ is_i4 = TRUE;
+ break;
}
{
if (strcmp (cmethod->name, "get_Chars") == 0 && fsig->param_count == 2) {
int dreg = alloc_ireg (cfg);
int index_reg = alloc_preg (cfg);
- int mult_reg = alloc_preg (cfg);
int add_reg = alloc_preg (cfg);
#if SIZEOF_REGISTER == 8
#if defined(TARGET_X86) || defined(TARGET_AMD64)
EMIT_NEW_X86_LEA (cfg, ins, args [0]->dreg, index_reg, 1, MONO_STRUCT_OFFSET (MonoString, chars));
add_reg = ins->dreg;
- /* Avoid a warning */
- mult_reg = 0;
EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOADU2_MEMBASE, dreg,
add_reg, 0);
#else
+ int mult_reg = alloc_preg (cfg);
MONO_EMIT_NEW_BIALU_IMM (cfg, OP_SHL_IMM, mult_reg, index_reg, 1);
MONO_EMIT_NEW_BIALU (cfg, OP_PADD, add_reg, mult_reg, args [0]->dreg);
EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOADU2_MEMBASE, dreg,
for (i = 0; i < attrs->num_attrs; ++i) {
MonoCustomAttrEntry *attr = &attrs->attrs [i];
const gchar *p;
- int len;
MonoMethodSignature *sig;
if (!attr->ctor || attr->ctor->klass != klass)
continue;
/* Decode the attribute. See reflection.c */
- len = attr->data_size;
p = (const char*)attr->data;
g_assert (read16 (p) == 0x0001);
p += 2;
break;
case CEE_ENDFILTER: {
MonoExceptionClause *clause, *nearest;
- int cc, nearest_num;
+ int cc;
CHECK_STACK (1);
--sp;
ip += 2;
nearest = NULL;
- nearest_num = 0;
for (cc = 0; cc < header->num_clauses; ++cc) {
clause = &header->clauses [cc];
if ((clause->flags & MONO_EXCEPTION_CLAUSE_FILTER) &&
((ip - header->code) > clause->data.filter_offset && (ip - header->code) <= clause->handler_offset) &&
- (!nearest || (clause->data.filter_offset < nearest->data.filter_offset))) {
+ (!nearest || (clause->data.filter_offset < nearest->data.filter_offset)))
nearest = clause;
- nearest_num = cc;
- }
}
g_assert (nearest);
if ((ip - header->code) != nearest->handler_offset)
{
MonoType *sig_ret;
MonoMethodSignature *sig;
- MonoMethodHeader *header;
MonoInst *ins;
int i;
CallInfo *cinfo;
- header = cfg->header;
-
sig = mono_method_signature (cfg->method);
cinfo = cfg->arch.cinfo;
for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
ArgInfo *ainfo = &cinfo->args [i];
- MonoType *arg_type;
ins = cfg->args [i];
- if (sig->hasthis && (i == 0))
- arg_type = &mono_defaults.object_class->byval_arg;
- else
- arg_type = sig->params [i - sig->hasthis];
-
switch (ainfo->storage) {
case ArgInIReg:
case ArgInFloatSSEReg:
{
MonoType *sig_ret;
MonoMethodSignature *sig;
- MonoMethodHeader *header;
MonoInst *ins;
int i, offset;
guint32 locals_stack_size, locals_stack_align;
gint32 *offsets;
CallInfo *cinfo;
- header = cfg->header;
-
sig = mono_method_signature (cfg->method);
cinfo = cfg->arch.cinfo;
if (ins->opcode != OP_REGVAR) {
ArgInfo *ainfo = &cinfo->args [i];
gboolean inreg = TRUE;
- MonoType *arg_type;
-
- if (sig->hasthis && (i == 0))
- arg_type = &mono_defaults.object_class->byval_arg;
- else
- arg_type = sig->params [i - sig->hasthis];
if (cfg->globalra) {
/* The new allocator needs info about the original locations of the arguments */
MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, AMD64_RSP, cinfo->sig_cookie.offset, sig_reg);
}
+#ifdef ENABLE_LLVM
static inline LLVMArgStorage
arg_storage_to_llvm_arg_storage (MonoCompile *cfg, ArgStorage storage)
{
}
}
-#ifdef ENABLE_LLVM
LLVMCallInfo*
mono_arch_get_llvm_call_info (MonoCompile *cfg, MonoMethodSignature *sig)
{
MonoInst *arg, *in;
MonoMethodSignature *sig;
MonoType *sig_ret;
- int i, n, stack_size;
+ int i, n;
CallInfo *cinfo;
ArgInfo *ainfo;
- stack_size = 0;
-
sig = call->signature;
n = sig->param_count + sig->hasthis;
MonoCallInst *call;
guint offset;
guint8 *code = cfg->native_code + cfg->code_len;
- MonoInst *last_ins = NULL;
- guint last_offset = 0;
int max_len;
/* Fix max_offset estimate for each successor bb */
g_assert_not_reached ();
#endif
}
-
- last_ins = ins;
- last_offset = offset;
}
cfg->code_len = code - cfg->native_code;
/* Keep this in sync with emit_load_volatile_arguments */
for (i = 0; i < sig->param_count + sig->hasthis; ++i) {
ArgInfo *ainfo = cinfo->args + i;
- gint32 stack_offset;
- MonoType *arg_type;
ins = cfg->args [i];
/* Unused arguments */
continue;
- if (sig->hasthis && (i == 0))
- arg_type = &mono_defaults.object_class->byval_arg;
- else
- arg_type = sig->params [i - sig->hasthis];
-
- stack_offset = ainfo->offset + ARGS_OFFSET;
-
if (cfg->globalra) {
/* All the other moves are done by the register allocator */
switch (ainfo->storage) {
mono_arch_emit_epilog (MonoCompile *cfg)
{
MonoMethod *method = cfg->method;
- int quad, pos, i;
+ int quad, i;
guint8 *code;
int max_epilog_size;
CallInfo *cinfo;
code = mono_arch_instrument_epilog (cfg, mono_trace_leave_method, code, TRUE);
/* the code restoring the registers must be kept in sync with OP_TAILCALL */
- pos = 0;
if (method->save_lmf) {
/* check if we need to restore protection of the stack after a stack overflow */
mono_arch_instrument_prolog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments)
{
guchar *code = p;
- CallInfo *cinfo = NULL;
MonoMethodSignature *sig;
MonoInst *inst;
int i, n, stack_area = 0;
/* Allocate a new area on the stack and save arguments there */
sig = mono_method_signature (cfg->method);
- cinfo = get_call_info (cfg->generic_sharing_context, cfg->mempool, sig);
-
n = sig->param_count + sig->hasthis;
stack_area = ALIGN_TO (n * 8, 16);
{
MonoInst *load;
int i, sel, spill;
- int *symbolic;
MonoRegState *rs = cfg->rs;
- symbolic = rs->symbolic [bank];
sel = rs->vassign [reg];
/* the vreg we need to spill lives in another logical reg bank */
MonoInst *load;
int i, sel, spill, num_sregs;
int sregs [MONO_MAX_SRC_REGS];
- int *symbolic;
MonoRegState *rs = cfg->rs;
- symbolic = rs->symbolic [bank];
-
g_assert (bank < MONO_NUM_REGBANKS);
DEBUG (printf ("\tstart regmask to assign R%d: 0x%08llu (R%d <- R%d R%d R%d)\n", reg, (unsigned long long)regmask, ins->dreg, ins->sreg1, ins->sreg2, ins->sreg3));
ins->dreg = -1;
}
- if (spec [MONO_INST_CLOB] == 'c' && MONO_IS_CALL (ins)) {
- /* A call instruction implicitly uses all registers in call->out_ireg_args */
-
- MonoCallInst *call = (MonoCallInst*)ins;
- GSList *list;
-
- list = call->out_ireg_args;
- if (list) {
- while (list) {
- guint32 regpair;
- int reg, hreg;
-
- regpair = (guint32)(gssize)(list->data);
- hreg = regpair >> 24;
- reg = regpair & 0xffffff;
-
- //reginfo [reg].prev_use = reginfo [reg].last_use;
- //reginfo [reg].last_use = i;
-
- list = g_slist_next (list);
- }
- }
-
- list = call->out_freg_args;
- if (list) {
- while (list) {
- guint32 regpair;
- int reg, hreg;
-
- regpair = (guint32)(gssize)(list->data);
- hreg = regpair >> 24;
- reg = regpair & 0xffffff;
-
- list = g_slist_next (list);
- }
- }
- }
-
++i;
}
DEBUG (print_regtrack (reginfo, rs->next_vreg));
MONO_BB_FOR_EACH_INS_REVERSE_SAFE (bb, prev, ins) {
- int prev_dreg, clob_dreg;
+ int prev_dreg;
int dest_dreg, clob_reg;
int dest_sregs [MONO_MAX_SRC_REGS], prev_sregs [MONO_MAX_SRC_REGS];
int dreg_high, sreg1_high;
spec_src1 = spec [MONO_INST_SRC1];
spec_dest = spec [MONO_INST_DEST];
prev_dreg = -1;
- clob_dreg = -1;
clob_reg = -1;
dest_dreg = -1;
dreg_high = -1;
prev_dreg = ins->dreg;
assign_reg (cfg, rs, ins->dreg, new_dest, 0);
- clob_dreg = ins->dreg;
create_copy_ins (cfg, bb, tmp, dest_sreg, new_dest, ins, ip, 0);
mono_regstate_free_int (rs, dest_sreg);
need_spill = FALSE;
for (i = 0; i < attrs->num_attrs; ++i) {
MonoCustomAttrEntry *attr = &attrs->attrs [i];
const gchar *p;
- int len, num_named, named_type, data_type, name_len;
+ int num_named, named_type, name_len;
char *name;
if (!attr->ctor || attr->ctor->klass != klass)
continue;
/* Decode the RuntimeCompatibilityAttribute. See reflection.c */
- len = attr->data_size;
p = (const char*)attr->data;
g_assert (read16 (p) == 0x0001);
p += 2;
p += 2;
named_type = *p;
p ++;
- data_type = *p;
+ /* data_type = *p; */
p ++;
/* Property */
if (named_type != 0x54)
/* Do less expensive checks first */
sig = mono_method_signature (method);
if (attr_class && sig && ((sig->ret->type == MONO_TYPE_VOID) ||
- (sig->ret->type == MONO_TYPE_CLASS && (sig->ret->data.generic_class->container_class->name, "Task")) ||
+ (sig->ret->type == MONO_TYPE_CLASS && !strcmp (sig->ret->data.generic_class->container_class->name, "Task")) ||
(sig->ret->type == MONO_TYPE_GENERICINST && !strcmp (sig->ret->data.generic_class->container_class->name, "Task`1")))) {
//printf ("X: %s\n", mono_method_full_name (method, TRUE));
cattr = mono_custom_attrs_from_method (method);
return mono_icall_get_wrapper_full (callinfo, FALSE);
}
-static void
-mono_dynamic_code_hash_insert (MonoDomain *domain, MonoMethod *method, MonoJitDynamicMethodInfo *ji)
-{
- if (!domain_jit_info (domain)->dynamic_code_hash)
- domain_jit_info (domain)->dynamic_code_hash = g_hash_table_new (NULL, NULL);
- g_hash_table_insert (domain_jit_info (domain)->dynamic_code_hash, method, ji);
-}
-
static MonoJitDynamicMethodInfo*
mono_dynamic_code_hash_lookup (MonoDomain *domain, MonoMethod *method)
{
mono_register_jit_icall_full (func, name, sig, save, FALSE, save ? name : NULL);
}
-/* Register a jit icall which doesn't throw exceptions through mono_raise_exception () */
-static void
-register_icall_noraise (gpointer func, const char *name, const char *sigstr)
-{
- MonoMethodSignature *sig;
-
- if (sigstr)
- sig = mono_create_icall_signature (sigstr);
- else
- sig = NULL;
-
- mono_register_jit_icall_full (func, name, sig, TRUE, TRUE, name);
-}
-
static void
register_dyn_icall (gpointer func, const char *name, const char *sigstr, gboolean save)
{
return (t->type == MONO_TYPE_VAR || t->type == MONO_TYPE_MVAR) && t->data.generic_param->gshared_constraint == MONO_TYPE_VALUETYPE;
}
-static gboolean
-is_open_method (MonoMethod *method)
-{
- MonoGenericContext *context;
-
- if (!method->is_inflated)
- return FALSE;
- context = mono_method_get_context (method);
- if (context->class_inst && context->class_inst->is_open)
- return TRUE;
- if (context->method_inst && context->method_inst->is_open)
- return TRUE;
- return FALSE;
-}
-
void
mini_init_gsctx (MonoDomain *domain, MonoMemPool *mp, MonoGenericContext *context, MonoGenericSharingContext *gsctx)
{
emul_opcode_hit_cache [opcode >> (EMUL_HIT_SHIFT + 3)] |= (1 << (opcode & EMUL_HIT_MASK));
}
-/*
- * For JIT icalls implemented in C.
- * NAME should be the same as the name of the C function whose address is FUNC.
- * If SAVE is TRUE, no wrapper is generated. This is for perf critical icalls which
- * can't throw exceptions.
- */
-static void
-register_icall (gpointer func, const char *name, const char *sigstr, gboolean save)
-{
- MonoMethodSignature *sig;
-
- if (sigstr)
- sig = mono_create_icall_signature (sigstr);
- else
- sig = NULL;
-
- mono_register_jit_icall_full (func, name, sig, save, FALSE, save ? name : NULL);
-}
-
-/* Register a jit icall which doesn't throw exceptions through mono_raise_exception () */
-static void
-register_icall_noraise (gpointer func, const char *name, const char *sigstr)
-{
- MonoMethodSignature *sig;
-
- if (sigstr)
- sig = mono_create_icall_signature (sigstr);
- else
- sig = NULL;
-
- mono_register_jit_icall_full (func, name, sig, TRUE, TRUE, name);
-}
-
-static void
-register_dyn_icall (gpointer func, const char *name, const char *sigstr, gboolean save)
-{
- MonoMethodSignature *sig;
-
- if (sigstr)
- sig = mono_create_icall_signature (sigstr);
- else
- sig = NULL;
-
- mono_register_jit_icall (func, name, sig, save);
-}
-
static void
print_dfn (MonoCompile *cfg) {
int i, j;
#endif /* !DISABLE_JIT */
-static gboolean
-mini_tls_key_supported (MonoTlsKey key)
-{
- if (!MONO_ARCH_HAVE_TLS_GET)
- return FALSE;
-
- return mini_get_tls_offset (key) != -1;
-}
-
void
mono_add_patch_info (MonoCompile *cfg, int ip, MonoJumpInfoType type, gconstpointer target)
{
MonoMethodHeader *header;
MonoMethodSignature *sig;
MonoError err;
- guint8 *ip;
MonoCompile *cfg;
int dfn, i, code_size_ratio;
-#ifndef DISABLE_SSA
- gboolean deadce_has_run = FALSE;
-#endif
gboolean try_generic_shared, try_llvm = FALSE;
MonoMethod *method_to_compile, *method_to_register;
gboolean method_is_gshared = FALSE;
}
}
- ip = (guint8 *)header->code;
-
cfg->intvars = mono_mempool_alloc0 (cfg->mempool, sizeof (guint16) * STACK_MAX * header->max_stack);
if (cfg->verbose_level > 0) {
//mono_local_cprop (cfg);
}
- if (cfg->opt & MONO_OPT_DEADCE) {
+ if (cfg->opt & MONO_OPT_DEADCE)
mono_ssa_deadce (cfg);
- deadce_has_run = TRUE;
- }
if ((cfg->flags & (MONO_CFG_HAS_LDELEMA|MONO_CFG_HAS_CHECK_THIS)) && (cfg->opt & MONO_OPT_ABCREM))
mono_perform_abc_removal (cfg);
{
guint8 *tramp;
guint8 *code, *buf;
- guint8 *jump_obj_null, *jump_have_waiters, *jump_sync_null, *jump_not_owned, *jump_cmpxchg_failed, *jump_sync_thin_hash = NULL;
+ guint8 *jump_obj_null, *jump_have_waiters, *jump_sync_null, *jump_not_owned, *jump_cmpxchg_failed;
guint8 *jump_next;
int tramp_size;
int status_offset, nest_offset;
/*if bit zero is set it's a thin hash*/
/*FIXME use testb encoding*/
amd64_test_reg_imm (code, sync_reg, 0x01);
- jump_sync_thin_hash = code;
amd64_branch8 (code, X86_CC_NE, -1, 1);
/*clear bits used by the gc*/
i = cached_info_next;
if (cached_info_next >= cached_info_size) {
- MonoUnwindInfo **old_table, **new_table;
+ MonoUnwindInfo **new_table;
/*
* Avoid freeing the old table so mono_get_cached_unwind_info ()
* doesn't need locks/hazard pointers.
*/
- old_table = cached_info;
new_table = g_new0 (MonoUnwindInfo*, cached_info_size * 2);
memcpy (new_table, cached_info, cached_info_size * sizeof (MonoUnwindInfo*));
mono_unwind_decode_fde (guint8 *fde, guint32 *out_len, guint32 *code_len, MonoJitExceptionInfo **ex_info, guint32 *ex_info_len, gpointer **type_info, int *this_reg, int *this_offset)
{
guint8 *p, *cie, *fde_current, *fde_aug = NULL, *code, *fde_cfi, *cie_cfi;
- gint32 fde_len, cie_offset, pc_begin, pc_range, aug_len, fde_data_len;
+ gint32 fde_len, cie_offset, pc_begin, pc_range, aug_len;
gint32 cie_len, cie_id, cie_version, code_align, data_align, return_reg;
gint32 i, cie_aug_len, buf_len;
char *cie_aug_str;
aug_len = 0;
}
fde_cfi = p;
- fde_data_len = fde + 4 + fde_len - p;
if (code_len)
*code_len = pc_range;
emit_time (LogBuffer *logbuffer, uint64_t value)
{
uint64_t tdiff = value - logbuffer->last_time;
- unsigned char *p;
if (value < logbuffer->last_time)
printf ("time went backwards\n");
//if (tdiff > 1000000)
// printf ("large time offset: %llu\n", tdiff);
- p = logbuffer->data;
encode_uleb128 (tdiff, logbuffer->data, &logbuffer->data);
/*if (tdiff != decode_uleb128 (p, &p))
printf ("incorrect encoding: %llu\n", tdiff);*/
int fd = strtol (nf + 1, NULL, 10);
prof->file = fdopen (fd, "a");
} else {
- FILE *f;
if (force_delete)
unlink (nf);
prof->file = fopen (nf, "wb");
LIBTEST_API int STDCALL
mono_test_marshal_delegate6 (SimpleDelegate5 delegate)
{
- int res;
-
- res = delegate (NULL);
-
+ delegate (NULL);
return 0;
}
return res;
}
-static void
+static void G_GNUC_UNUSED
benchmark_conc (void)
{
mono_mutex_t mutex;
}
-static void
+static void G_GNUC_UNUSED
benchmark_glib (void)
{
GHashTable *h;
res += parallel_writer_parallel_reader ();
return res;
-}
\ No newline at end of file
+}
int npages = (size + pagesize - 1) / pagesize;
char *faulted = g_malloc0 (sizeof (char*) * npages);
- if (mincore (addr, size, faulted) != 0) {
+ /*
+ * We cast `faulted` to void* because Linux wants an unsigned
+ * char* while BSD wants a char*.
+ */
+ if (mincore (addr, size, (void*)faulted) != 0) {
count = -1;
} else {
count = 0;
projects / mono.git / commitdiff