* Structs are not being labeled as `valuetype' classes
*
* How are fields with literals mapped to constants?
+ * Licensed under the MIT license. See LICENSE file in the project root for full license information.
*/
#include <config.h>
#include <stdio.h>
static void
dis_nt_header (MonoImage *m)
{
- MonoCLIImageInfo *image_info = m->image_info;
+ MonoCLIImageInfo *image_info = (MonoCLIImageInfo *)m->image_info;
if (image_info && image_info->cli_header.nt.pe_stack_reserve != 0x100000)
fprintf (output, ".stackreserve 0x%x\n", image_info->cli_header.nt.pe_stack_reserve);
}
if ((crow = mono_metadata_get_constant_index (m, MONO_TOKEN_FIELD_DEF | (i+1), 0))) {
mono_metadata_decode_row (&m->tables [MONO_TABLE_CONSTANT], crow-1, const_cols, MONO_CONSTANT_SIZE);
- lit = get_constant (m, const_cols [MONO_CONSTANT_TYPE], const_cols [MONO_CONSTANT_VALUE]);
+ lit = get_constant (m, (MonoTypeEnum)const_cols [MONO_CONSTANT_TYPE], const_cols [MONO_CONSTANT_VALUE]);
} else {
lit = g_strdup ("not found");
}
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;
static void
dis_code (MonoImage *m, guint32 token, guint32 rva, MonoGenericContainer *container)
{
+ MonoError error;
MonoMethodHeader *mh;
const char *ptr = mono_image_rva_map (m, rva);
const char *loc;
g_free (override);
}
- mh = mono_metadata_parse_mh_full (m, container, ptr);
+ mh = mono_metadata_parse_mh_full (m, container, ptr, &error);
entry_point = mono_image_get_entry_point (m);
if (entry_point && mono_metadata_token_index (entry_point) && mono_metadata_token_table (entry_point) == MONO_TABLE_METHOD) {
loc = mono_metadata_locate_token (m, entry_point);
hex_dump (mh->code + mh->code_size, 0, 64);
*/
mono_metadata_free_mh (mh);
+ } else {
+ mono_error_cleanup (&error);
}
}
if ((crow = mono_metadata_get_constant_index(m, MONO_TOKEN_PARAM_DEF | i, 0))) {
guint32 const_cols [MONO_CONSTANT_SIZE];
mono_metadata_decode_row( &m->tables[MONO_TABLE_CONSTANT], crow-1, const_cols, MONO_CONSTANT_SIZE);
- lit = get_constant(m, const_cols [MONO_CONSTANT_TYPE], const_cols [MONO_CONSTANT_VALUE]);
+ lit = get_constant (m, (MonoTypeEnum)const_cols [MONO_CONSTANT_TYPE], const_cols [MONO_CONSTANT_VALUE]);
}
else {
lit = g_strdup ("not found");
}
for (i = start; i < end; i++){
+ MonoError error;
MonoMethodSignature *ms;
MonoGenericContainer *container;
char *flags, *impl_flags;
container = type_container;
}
- ms = mono_metadata_parse_method_signature_full (m, container, i + 1, sig, &sig);
+ ms = mono_metadata_parse_method_signature_full (m, container, i + 1, sig, &sig, &error);
if (ms != NULL){
sig_str = dis_stringify_method_signature (m, ms, i + 1, container, FALSE);
method_name = mono_metadata_string_heap (m, cols [MONO_METHOD_NAME]);
} else {
sig_str = NULL;
method_name = g_strdup ("<NULL METHOD SIGNATURE>");
+ mono_error_cleanup (&error);
}
fprintf (output, " // method line %d\n", i + 1);
static char*
dis_property_signature (MonoImage *m, guint32 prop_idx, MonoGenericContainer *container)
{
+ MonoError error;
MonoTableInfo *propt = &m->tables [MONO_TABLE_PROPERTY];
const char *ptr;
guint32 pcount, i;
g_string_append (res, "instance ");
ptr++;
pcount = mono_metadata_decode_value (ptr, &ptr);
- type = mono_metadata_parse_type_full (m, container, MONO_PARSE_TYPE, 0, ptr, &ptr);
- blurb = dis_stringify_type (m, type, TRUE);
+ type = mono_metadata_parse_type_checked (m, container, 0, FALSE, ptr, &ptr, &error);
+ if (type) {
+ blurb = dis_stringify_type (m, type, TRUE);
+ } else {
+ blurb = g_strdup_printf ("Invalid type due to %s", mono_error_get_message (&error));
+ mono_error_cleanup (&error);
+ }
if (prop_flags & 0x0200)
g_string_append (res, "specialname ");
if (prop_flags & 0x0400)
for (i = 0; i < pcount; i++) {
if (i)
g_string_append (res, ", ");
- param = mono_metadata_parse_type_full (m, container, MONO_PARSE_PARAM, 0, ptr, &ptr);
- blurb = dis_stringify_param (m, param);
+ param = mono_metadata_parse_type_checked (m, container, 0, FALSE, ptr, &ptr, &error);
+ if (type) {
+ blurb = dis_stringify_param (m, param);
+ } else {
+ blurb = g_strdup_printf ("Invalid type due to %s", mono_error_get_message (&error));
+ mono_error_cleanup (&error);
+ }
+
g_string_append (res, blurb);
g_free (blurb);
}
MonoType *type;
for (i = 0; i < t->rows; i++) {
+ MonoError error;
mono_metadata_decode_row (t, i, cols, MONO_FIELD_RVA_SIZE);
rva = mono_image_rva_map (m, cols [MONO_FIELD_RVA_RVA]);
sig = mono_metadata_blob_heap (m, mono_metadata_decode_row_col (ft, cols [MONO_FIELD_RVA_FIELD] -1, MONO_FIELD_SIGNATURE));
mono_metadata_decode_value (sig, &sig);
/* FIELD signature == 0x06 */
g_assert (*sig == 0x06);
- type = mono_metadata_parse_field_type (m, 0, sig + 1, &sig);
+ type = mono_metadata_parse_type_checked (m, NULL, 0, FALSE, sig + 1, &sig, &error);
+ if (!type) {
+ fprintf (output, "// invalid field %d due to %s\n", i, mono_error_get_message (&error));
+ mono_error_cleanup (&error);
+ continue;
+ }
mono_class_init (mono_class_from_mono_type (type));
size = mono_type_size (type, &align);
{
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);
const char *name = mono_image_get_name (image);
for (item = filter_list; item; item = item->next) {
- ifilter = item->data;
+ ifilter = (ImageFilter *)item->data;
if (strcmp (ifilter->name, name) == 0) {
cur_filter = ifilter;
return;
static int
int_cmp (const void *e1, const void *e2)
{
- const int *i1 = e1;
- const int *i2 = e2;
+ const int *i1 = (const int *)e1;
+ const int *i2 = (const int *)e2;
return *i1 - *i2;
}
GList *item;
for (item = filter_list; item; item = item->next) {
- ifilter = item->data;
+ ifilter = (ImageFilter *)item->data;
if (strcmp (ifilter->name, name) == 0)
return ifilter;
}
if (tf->count >= tf->size) {
if (!tf->size) {
tf->size = 8;
- tf->elems = g_malloc (sizeof (int) * tf->size);
+ tf->elems = (int *)g_malloc (sizeof (int) * tf->size);
} else {
tf->size *= 2;
- tf->elems = g_realloc (tf->elems, sizeof (int) * tf->size);
+ tf->elems = (int *)g_realloc (tf->elems, sizeof (int) * tf->size);
}
}
tf->elems [tf->count++] = val;
GList *item;
for (item = filter_list; item; item = item->next) {
- ifilter = item->data;
+ ifilter = (ImageFilter *)item->data;
qsort (ifilter->types.elems, ifilter->types.count, sizeof (int), int_cmp);
qsort (ifilter->fields.elems, ifilter->fields.count, sizeof (int), int_cmp);
qsort (ifilter->methods.elems, ifilter->methods.count, sizeof (int), int_cmp);
GList *tmp;
for (tmp = loaded_assemblies; tmp; tmp = tmp->next) {
- MonoAssembly *ass = tmp->data;
+ MonoAssembly *ass = (MonoAssembly *)tmp->data;
if (mono_assembly_names_equal (aname, &ass->aname))
return ass;
}
* If we just have one file, use the corlib version it requires.
*/
if (!input_files->next) {
- char *filename = input_files->data;
+ char *filename = (char *)input_files->data;
mono_init_from_assembly (argv [0], filename);
mono_init (argv [0]);
for (l = input_files; l; l = l->next)
- disassemble_file (l->data);
+ disassemble_file ((const char *)l->data);
}
return 0;
projects / mono.git / blobdiff