* Makefile.am: removed monosn from compilation.
* appdomain.c, assembly.c, assembly.h, blob.h, class.c,
debug-helpers.c, debug-mono-symfile.c, domain.c, icall.c,
image.c, image.h, loader.c, marshal.c, metadata-internals.h,
metadata.c, metadata.h, mono-config.c, mono-debug-debugger.c,
mono-debug.c, object.c, opcodes.c, opcodes.h, pedump.c, process.c,
reflection.c, reflection.h, verify.c: more API cleanups and fixes.
svn path=/trunk/mono/; revision=29680
#include <mono/metadata/mono-endian.h>
#include <mono/metadata/tabledefs.h>
#include <mono/metadata/tokentype.h>
+#include <mono/metadata/metadata-internals.h>
#include <mono/metadata/blob.h>
+
+Wed Jun 16 14:33:22 CEST 2004 Paolo Molaro <lupus@ximian.com>
+
+ * Makefile.am: removed monosn from compilation.
+ * appdomain.c, assembly.c, assembly.h, blob.h, class.c,
+ debug-helpers.c, debug-mono-symfile.c, domain.c, icall.c,
+ image.c, image.h, loader.c, marshal.c, metadata-internals.h,
+ metadata.c, metadata.h, mono-config.c, mono-debug-debugger.c,
+ mono-debug.c, object.c, opcodes.c, opcodes.h, pedump.c, process.c,
+ reflection.c, reflection.h, verify.c: more API cleanups and fixes.
+
2004-06-15 Jackson Harper <jackson@ximian.com>
* assembly.c: Make locales lower case when searching the GAC for
endif
bin_PROGRAMS = pedump
-# monosn is deprecated in favor of sn
-noinst_PROGRAMS = monosn
noinst_LTLIBRARIES = libmetadata.la libmonoruntime.la
domain-internals.h \
opcodes.c \
image.c \
+ cil-coff.h \
+ tabledefs.h \
metadata.c \
+ metadata-internals.h \
verify.c \
mono-endian.c \
+ mono-endian.h \
mono-config.c \
mono-config.h \
private.h \
rawbuffer.c \
+ rawbuffer.h \
loader.c \
class.c \
mempool.c \
mono-debug-debugger.h \
debug-mono-symfile.h \
threads.h \
- environment.h \
- locales.h
+ environment.h
libmetadatainclude_HEADERS = \
assembly.h \
opcodes.h \
blob.h \
- cil-coff.h \
- mono-endian.h \
image.h \
metadata.h \
verify.h \
- rawbuffer.h \
reflection.h \
row-indexes.h \
- tabledefs.h \
tokentype.h \
loader.h \
class.h \
profiler.h \
appdomain.h \
debug-helpers.h \
- mempool.h \
- rand.h
+ mempool.h
pedump_SOURCES = \
pedump.c
pedump_LDADD = libmetadata.la ../io-layer/libwapi.la ../utils/libmonoutils.la \
$(LIBGC_LIBS) $(GLIB_LIBS) $(GMODULE_LIBS) -lm
-
-monosn_LDADD = \
- libmetadata.la \
- ../io-layer/libwapi.la \
- ../utils/libmonoutils.la \
- $(LIBGC_LIBS) \
- $(GLIB_LIBS) \
- $(GMODULE_LIBS) \
- -lm
-
BUILT_SOURCES = $(bundle_srcs) libmetadata.la
EXTRA_DIST = make-bundle.pl sample-bundle
#include <mono/metadata/object.h>
#include <mono/metadata/domain-internals.h>
+#include "mono/metadata/metadata-internals.h"
#include <mono/metadata/assembly.h>
#include <mono/metadata/exception.h>
#include <mono/metadata/threads.h>
*
* (C) 2001 Ximian, Inc. http://www.ximian.com
*
- * TODO:
- * Implement big-endian versions of the reading routines.
*/
#include <config.h>
#include <stdio.h>
#endif
#include <mono/metadata/loader.h>
#include <mono/metadata/tabledefs.h>
+#include <mono/metadata/metadata-internals.h>
#include <mono/io-layer/io-layer.h>
#include <mono/utils/mono-uri.h>
#include <mono/metadata/mono-config.h>
return(main_assembly);
}
+MonoImage*
+mono_assembly_get_image (MonoAssembly *assembly)
+{
+ return assembly->image;
+}
void mono_assembly_foreach (GFunc func, gpointer user_data);
void mono_assembly_set_main (MonoAssembly *assembly);
MonoAssembly *mono_assembly_get_main (void);
+MonoImage *mono_assembly_get_image (MonoAssembly *assembly);
gboolean mono_assembly_fill_assembly_name (MonoImage *image, MonoAssemblyName *aname);
/* Installs a function which is called each time a new assembly is loaded. */
#ifndef _MONO_METADATA_BLOB_H_
#define _MONO_METADATA_BLOB_H_
-#define SIGNATURE_HAS_THIS 0x20
-#define SIGNATURE_EXPLICIT_THIS 0x40
-#define SIGNATURE_VARARG 0x05
-
/*
* Encoding for type signatures used in the Metadata
*/
#include <mono/metadata/assembly.h>
#include <mono/metadata/cil-coff.h>
#include <mono/metadata/metadata.h>
+#include <mono/metadata/metadata-internals.h>
#include <mono/metadata/tabledefs.h>
#include <mono/metadata/tokentype.h>
#include <mono/metadata/class.h>
return mono_method_desc_search_in_class (desc, klass);
}
- tdef = &image->tables [MONO_TABLE_TYPEDEF];
- methods = &image->tables [MONO_TABLE_METHOD];
- for (i = 0; i < methods->rows; ++i) {
+ tdef = 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);
const char *n = mono_metadata_string_heap (image, token);
}
static const unsigned char*
-dis_one (GString *str, MonoDisHelper *dh, MonoMethod *method, const unsigned char *ip)
+dis_one (GString *str, MonoDisHelper *dh, MonoMethod *method, const unsigned char *ip, const unsigned char *end)
{
MonoMethodHeader *header = ((MonoMethodNormal*)method)->header;
const MonoOpcode *opcode;
if (dh->label_format)
g_string_sprintfa (str, dh->label_format, label);
- i = mono_opcode_value (&ip);
+ i = mono_opcode_value (&ip, end);
ip++;
opcode = &mono_opcodes [i];
g_string_sprintfa (str, "%-10s", mono_opcode_names [i]);
if (!dh)
dh = &default_dh;
- ip = dis_one (res, dh, method, ip);
+ /* set ip + 2 as the end: this is just a debugging method */
+ ip = dis_one (res, dh, method, ip, ip + 2);
if (endp)
*endp = ip;
if (!dh)
dh = &default_dh;
while (ip < end) {
- ip = dis_one (res, dh, method, ip);
+ ip = dis_one (res, dh, method, ip, end);
}
result = res->str;
static gconstpointer
open_symfile (MonoImage *image, guint32 *size)
{
- MonoTableInfo *table = &image->tables [MONO_TABLE_MANIFESTRESOURCE];
- guint32 i;
+ MonoTableInfo *table = mono_image_get_table_info (image, MONO_TABLE_MANIFESTRESOURCE);
+ guint32 i, num_rows;
guint32 cols [MONO_MANIFEST_SIZE];
const char *val;
- for (i = 0; i < table->rows; ++i) {
+ num_rows = mono_table_info_get_rows (table);
+ for (i = 0; i < num_rows; ++i) {
mono_metadata_decode_row (table, i, cols, MONO_MANIFEST_SIZE);
val = mono_metadata_string_heap (image, cols [MONO_MANIFEST_NAME]);
if (!strcmp (val, "MonoSymbolFile"))
break;
}
- if (i == table->rows)
+ if (i == num_rows)
return NULL;
g_assert (!cols [MONO_MANIFEST_IMPLEMENTATION]);
exit (1);
}
- mono_defaults.corlib = ass->image;
+ mono_defaults.corlib = mono_assembly_get_image (ass);
mono_defaults.object_class = mono_class_from_name (
mono_defaults.corlib, "System", "Object");
#include <mono/metadata/tokentype.h>
#include <mono/metadata/unicode.h>
#include <mono/metadata/domain-internals.h>
+#include <mono/metadata/metadata-internals.h>
#include <mono/metadata/marshal.h>
#include <mono/metadata/gc-internal.h>
#include <mono/metadata/rand.h>
#include "private.h"
#include "tabledefs.h"
#include "tokentype.h"
+#include "metadata-internals.h"
#include <mono/io-layer/io-layer.h>
#define INVALID_ADDRESS 0xffffffff
return pubkey;
}
+const char*
+mono_image_get_name (MonoImage *image)
+{
+ return image->name;
+}
+
+const char*
+mono_image_get_filename (MonoImage *image)
+{
+ return image->assembly_name;
+}
+
+const MonoTableInfo*
+mono_image_get_table_info (MonoImage *image, int table_id)
+{
+ if (table_id < 0 || table_id >= 64)
+ return NULL;
+ return &image->tables [table_id];
+}
+
+int
+mono_image_get_table_rows (MonoImage *image, int table_id)
+{
+ if (table_id < 0 || table_id >= 64)
+ return 0;
+ return image->tables [table_id].rows;
+}
+
+int
+mono_table_info_get_rows (MonoTableInfo *table)
+{
+ return table->rows;
+}
+
+MonoAssembly*
+mono_image_get_assembly (MonoImage *image)
+{
+ return image->assembly;
+}
+
+gboolean
+mono_image_is_dynamic (MonoImage *image)
+{
+ return image->dynamic;
+}
+
+char*
+mono_image_rva_map (MonoImage *image, guint32 rva)
+{
+ return mono_cli_rva_map (image->image_info, rva);
+}
+
#include <gmodule.h>
typedef struct _MonoImage MonoImage;
+typedef struct _MonoAssembly MonoAssembly;
+typedef struct _MonoTableInfo MonoTableInfo;
typedef struct {
const char *name;
guint16 major, minor, build, revision;
} MonoAssemblyName;
-typedef struct {
- int ref_count;
- char *basedir;
- gboolean in_gac;
- MonoAssemblyName aname;
- GModule *aot_module;
- MonoImage *image;
- /* Load files here */
- gboolean dynamic;
-} MonoAssembly;
-
-typedef struct {
- const char* data;
- guint32 size;
-} MonoStreamHeader;
-
-typedef struct {
- guint32 rows, row_size;
- const char *base;
-
- /*
- * Tables contain up to 9 columns and the possible sizes of the
- * fields in the documentation are 1, 2 and 4 bytes. So we
- * can encode in 2 bits the size.
- *
- * A 32 bit value can encode the resulting size
- *
- * The top eight bits encode the number of columns in the table.
- * we only need 4, but 8 is aligned no shift required.
- */
- guint32 size_bitfield;
-} MonoTableInfo;
-
-struct _MonoImage {
- int ref_count;
- FILE *f;
- /* if f is NULL the image was loaded from raw data */
- char *raw_data;
- guint32 raw_data_len;
- gboolean raw_data_allocated;
- char *name;
- const char *assembly_name;
- const char *module_name;
- const char *version;
- char *guid;
- void *image_info;
-
- char *raw_metadata;
-
- gboolean idx_string_wide, idx_guid_wide, idx_blob_wide;
-
- MonoStreamHeader heap_strings;
- MonoStreamHeader heap_us;
- MonoStreamHeader heap_blob;
- MonoStreamHeader heap_guid;
- MonoStreamHeader heap_tables;
-
- const char *tables_base;
-
- MonoTableInfo tables [64];
-
- /*
- * references is initialized only by using the mono_assembly_open
- * function, and not by using the lowlevel mono_image_open.
- *
- * It is NULL terminated.
- */
- MonoAssembly **references;
-
- MonoImage **modules;
-
- MonoImage **files;
-
- /*
- * The Assembly this image was loaded from.
- */
- MonoAssembly *assembly;
-
- /*
- * Indexed by method tokens and typedef tokens.
- */
- GHashTable *method_cache;
- GHashTable *class_cache;
- /*
- * Indexed by fielddef and memberref tokens
- */
- GHashTable *field_cache;
-
- /* indexed by typespec tokens. */
- GHashTable *typespec_cache;
- /* indexed by token */
- GHashTable *memberref_signatures;
-
- /*
- * Indexed by MonoGenericInst.
- */
- GHashTable *generic_inst_cache;
-
- /*
- * Indexes namespaces to hash tables that map class name to typedef token.
- */
- GHashTable *name_cache;
-
- /*
- * Indexed by ((rank << 24) | (typedef & 0xffffff)), which limits us to a
- * maximal rank of 255
- */
- GHashTable *array_cache;
-
- /*
- * indexed by MonoMethodSignature
- */
- GHashTable *delegate_begin_invoke_cache;
- GHashTable *delegate_end_invoke_cache;
- GHashTable *delegate_invoke_cache;
-
- /*
- * indexed by MonoMethod pointers
- */
- GHashTable *runtime_invoke_cache;
- GHashTable *managed_wrapper_cache;
- GHashTable *native_wrapper_cache;
- GHashTable *remoting_invoke_cache;
- GHashTable *synchronized_cache;
-
- void *reflection_info;
-
- /*
- * user_info is a public field and is not touched by the
- * metadata engine
- */
- void *user_info;
-
- /* dll map entries */
- GHashTable *dll_map;
-
- /* Whenever this is a dynamically emitted module */
- gboolean dynamic;
-};
-
typedef enum {
MONO_IMAGE_OK,
MONO_IMAGE_ERROR_ERRNO,
const char *mono_image_get_resource (MonoImage *image, guint32 offset, guint32 *size);
MonoImage* mono_image_load_file_for_image (MonoImage *image, int fileidx);
+const char* mono_image_get_name (MonoImage *image);
+const char* mono_image_get_filename (MonoImage *image);
+MonoAssembly* mono_image_get_assembly (MonoImage *image);
+gboolean mono_image_is_dynamic (MonoImage *image);
+char* mono_image_rva_map (MonoImage *image, guint32 rva);
+
+const MonoTableInfo *mono_image_get_table_info (MonoImage *image, int table_id);
+int mono_image_get_table_rows (MonoImage *image, int table_id);
+int mono_table_info_get_rows (MonoTableInfo *table);
+
/* This actually returns a MonoPEResourceDataEntry *, but declaring it
* causes an include file loop.
*/
#include <mono/metadata/tokentype.h>
#include <mono/metadata/cil-coff.h>
#include <mono/metadata/tabledefs.h>
+#include <mono/metadata/metadata-internals.h>
#include <mono/metadata/loader.h>
#include <mono/metadata/class.h>
#include <mono/metadata/debug-helpers.h>
#include "mono/metadata/threadpool.h"
#include "mono/metadata/threads.h"
#include "mono/metadata/monitor.h"
+#include "mono/metadata/metadata-internals.h"
#include <string.h>
#include <errno.h>
--- /dev/null
+
+#ifndef __MONO_METADATA_INTERNALS_H__
+#define __MONO_METADATA_INTERNALS_H__
+
+#include "mono/metadata/image.h"
+#include "mono/utils/mono-hash.h"
+
+struct _MonoAssembly {
+ int ref_count;
+ char *basedir;
+ gboolean in_gac;
+ MonoAssemblyName aname;
+ GModule *aot_module;
+ MonoImage *image;
+ /* Load files here */
+ gboolean dynamic;
+};
+
+typedef struct {
+ const char* data;
+ guint32 size;
+} MonoStreamHeader;
+
+struct _MonoTableInfo {
+ guint32 rows, row_size;
+ const char *base;
+
+ /*
+ * Tables contain up to 9 columns and the possible sizes of the
+ * fields in the documentation are 1, 2 and 4 bytes. So we
+ * can encode in 2 bits the size.
+ *
+ * A 32 bit value can encode the resulting size
+ *
+ * The top eight bits encode the number of columns in the table.
+ * we only need 4, but 8 is aligned no shift required.
+ */
+ guint32 size_bitfield;
+};
+
+struct _MonoImage {
+ int ref_count;
+ FILE *f;
+ /* if f is NULL the image was loaded from raw data */
+ char *raw_data;
+ guint32 raw_data_len;
+ gboolean raw_data_allocated;
+ char *name;
+ const char *assembly_name;
+ const char *module_name;
+ const char *version;
+ char *guid;
+ void *image_info;
+
+ char *raw_metadata;
+
+ gboolean idx_string_wide, idx_guid_wide, idx_blob_wide;
+
+ MonoStreamHeader heap_strings;
+ MonoStreamHeader heap_us;
+ MonoStreamHeader heap_blob;
+ MonoStreamHeader heap_guid;
+ MonoStreamHeader heap_tables;
+
+ const char *tables_base;
+
+ MonoTableInfo tables [64];
+
+ /*
+ * references is initialized only by using the mono_assembly_open
+ * function, and not by using the lowlevel mono_image_open.
+ *
+ * It is NULL terminated.
+ */
+ MonoAssembly **references;
+
+ MonoImage **modules;
+
+ MonoImage **files;
+
+ /*
+ * The Assembly this image was loaded from.
+ */
+ MonoAssembly *assembly;
+
+ /*
+ * Indexed by method tokens and typedef tokens.
+ */
+ GHashTable *method_cache;
+ GHashTable *class_cache;
+ /*
+ * Indexed by fielddef and memberref tokens
+ */
+ GHashTable *field_cache;
+
+ /* indexed by typespec tokens. */
+ GHashTable *typespec_cache;
+ /* indexed by token */
+ GHashTable *memberref_signatures;
+
+ /*
+ * Indexed by MonoGenericInst.
+ */
+ GHashTable *generic_inst_cache;
+
+ /*
+ * Indexes namespaces to hash tables that map class name to typedef token.
+ */
+ GHashTable *name_cache;
+
+ /*
+ * Indexed by ((rank << 24) | (typedef & 0xffffff)), which limits us to a
+ * maximal rank of 255
+ */
+ GHashTable *array_cache;
+
+ /*
+ * indexed by MonoMethodSignature
+ */
+ GHashTable *delegate_begin_invoke_cache;
+ GHashTable *delegate_end_invoke_cache;
+ GHashTable *delegate_invoke_cache;
+
+ /*
+ * indexed by MonoMethod pointers
+ */
+ GHashTable *runtime_invoke_cache;
+ GHashTable *managed_wrapper_cache;
+ GHashTable *native_wrapper_cache;
+ GHashTable *remoting_invoke_cache;
+ GHashTable *synchronized_cache;
+
+ void *reflection_info;
+
+ /*
+ * user_info is a public field and is not touched by the
+ * metadata engine
+ */
+ void *user_info;
+
+ /* dll map entries */
+ GHashTable *dll_map;
+
+ /* Whenever this is a dynamically emitted module */
+ gboolean dynamic;
+};
+
+enum {
+ MONO_SECTION_TEXT,
+ MONO_SECTION_RSRC,
+ MONO_SECTION_RELOC,
+ MONO_SECTION_MAX
+};
+
+typedef struct {
+ GHashTable *hash;
+ char *data;
+ guint32 alloc_size; /* malloced bytes */
+ guint32 index;
+ guint32 offset; /* from start of metadata */
+} MonoDynamicStream;
+
+typedef struct {
+ guint32 alloc_rows;
+ guint32 rows;
+ guint32 row_size; /* calculated later with column_sizes */
+ guint32 columns;
+ guint32 column_sizes [9];
+ guint32 *values; /* rows * columns */
+ guint32 next_idx;
+} MonoDynamicTable;
+
+struct _MonoDynamicAssembly {
+ MonoAssembly assembly;
+ gboolean run;
+ gboolean save;
+ char *strong_name;
+ guint32 strong_name_size;
+};
+
+struct _MonoDynamicImage {
+ MonoImage image;
+ guint32 meta_size;
+ guint32 text_rva;
+ guint32 metadata_rva;
+ guint32 image_base;
+ guint32 cli_header_offset;
+ guint32 iat_offset;
+ guint32 idt_offset;
+ guint32 ilt_offset;
+ guint32 imp_names_offset;
+ struct {
+ guint32 rva;
+ guint32 size;
+ guint32 offset;
+ guint32 attrs;
+ } sections [MONO_SECTION_MAX];
+ GHashTable *typespec;
+ GHashTable *typeref;
+ GHashTable *handleref;
+ MonoGHashTable *tokens;
+ MonoGHashTable *blob_cache;
+ GList *array_methods;
+ MonoGHashTable *token_fixups;
+ MonoGHashTable *method_to_table_idx;
+ MonoGHashTable *field_to_table_idx;
+ MonoGHashTable *method_aux_hash;
+ gboolean run;
+ gboolean save;
+ char *strong_name;
+ guint32 strong_name_size;
+ char *win32_res;
+ guint32 win32_res_size;
+ MonoDynamicStream pefile;
+ MonoDynamicStream sheap;
+ MonoDynamicStream code; /* used to store method headers and bytecode */
+ MonoDynamicStream resources; /* managed embedded resources */
+ MonoDynamicStream us;
+ MonoDynamicStream blob;
+ MonoDynamicStream tstream;
+ MonoDynamicStream guid;
+ MonoDynamicTable tables [64];
+};
+
+
+#endif /* __MONO_METADATA_INTERNALS_H__ */
+
#include "mono-endian.h"
#include "cil-coff.h"
#include "tokentype.h"
+#include "metadata-internals.h"
#include "private.h"
#include "class.h"
guint32 mono_metadata_methods_from_property (MonoImage *meta, guint32 table_index, guint *end);
guint32 mono_metadata_packing_from_typedef (MonoImage *meta, guint32 table_index, guint32 *packing, guint32 *size);
const char* mono_metadata_get_marshal_info (MonoImage *meta, guint32 idx, gboolean is_field);
-guint32 mono_metadata_custom_attrs_from_index (MonoImage *meta, guint32 index);
+guint32 mono_metadata_custom_attrs_from_index (MonoImage *meta, guint32 cattr_index);
MonoMarshalSpec *mono_metadata_parse_marshal_spec (MonoImage *image, const char *ptr);
{
switch (state) {
case 0:
- return g_strdup (image->assembly_name);
+ return g_strdup (mono_image_get_name (image));
default:
return NULL;
}
const char *home;
state.assembly = assembly;
- cfg_name = g_strdup_printf ("%s.config", assembly->name);
+ cfg_name = g_strdup_printf ("%s.config", mono_image_get_filename (assembly));
mono_config_parse_file_with_context (&state, cfg_name);
g_free (cfg_name);
- cfg_name = g_strdup_printf ("%s.config", assembly->assembly_name);
+ cfg_name = g_strdup_printf ("%s.config", mono_image_get_name (assembly));
home = g_get_home_dir ();
{
MonoMethod *method;
- method = mono_get_method (assembly->assembly->image, token, NULL);
+ method = mono_get_method (mono_assembly_get_image (assembly->assembly), token, NULL);
return mono_method_get_object (mono_domain_get (), method, NULL);
}
{
MonoClass *klass;
- klass = mono_class_get (assembly->assembly->image, token);
+ klass = mono_class_get (mono_assembly_get_image (assembly->assembly), token);
if (!klass) {
g_warning (G_STRLOC ": %x", token);
return NULL;
MONO_CHECK_ARG_NULL (signature);
domain = mono_domain_get();
- image = assembly->assembly->image;
+ image = mono_assembly_get_image (assembly->assembly);
ptr = mono_array_addr (signature, char, 0);
g_assert (*ptr++ == 0x07);
mono_install_assembly_load_hook (mono_debug_add_assembly, NULL);
mono_debug_open_image (mono_defaults.corlib);
+ /*
+ * FIXME: Ugh: what is this code supposed to do? corlib has no references.
for (ass = mono_defaults.corlib->references; ass && *ass; ass++)
mono_debug_open_image ((*ass)->image);
+ */
}
/*
{
MonoDebugHandle *handle;
- mono_debug_open_image (assembly->image);
+ mono_debug_open_image (mono_assembly_get_image (assembly));
handle = _mono_debug_get_image (mono_defaults.corlib);
g_assert (handle);
handle = g_new0 (MonoDebugHandle, 1);
handle->image = image;
- handle->image->ref_count++;
- handle->image_file = g_strdup (image->name);
+ mono_image_addref (image);
+ handle->image_file = g_strdup (mono_image_get_filename (image));
handle->_priv = g_new0 (MonoDebugHandlePriv, 1);
g_hash_table_insert (mono_debug_handles, image, handle);
- if (image->assembly->dynamic)
+ if (mono_image_is_dynamic (image))
return handle;
handle->symfile = mono_debug_open_mono_symbol_file (handle, in_the_mono_debugger);
{
if (handle->symfile)
mono_debug_close_mono_symbol_file (handle->symfile);
- handle->image->ref_count--;
+ /* decrease the refcount added with mono_image_addref () */
+ mono_image_close (handle->image);
+ /* FIXME: should also free handle->image_file? */
g_free (handle->_priv);
g_free (handle);
}
mono_debug_add_assembly (MonoAssembly *assembly, gpointer user_data)
{
mono_debugger_lock ();
- mono_debug_open_image (assembly->image);
+ mono_debug_open_image (mono_assembly_get_image (assembly));
mono_debugger_unlock ();
}
#include <mono/metadata/gc-internal.h>
#include <mono/metadata/exception.h>
#include <mono/metadata/domain-internals.h>
+#include "mono/metadata/metadata-internals.h"
#include <mono/metadata/assembly.h>
#include <mono/metadata/threadpool.h>
#include <mono/metadata/marshal.h>
};
MonoOpcodeEnum
-mono_opcode_value (const guint8 **ip)
+mono_opcode_value (const guint8 **ip, const guint8 *end)
{
MonoOpcodeEnum res;
-
- if (**ip == 0xfe) {
- ++*ip;
- res = **ip + MONO_PREFIX1_OFFSET;
- } else if (**ip == MONO_CUSTOM_PREFIX) {
- ++*ip;
- res = **ip + MONO_CUSTOM_PREFIX_OFFSET;
+ const guint8 *p = *ip;
+
+ if (p >= end)
+ return -1;
+ if (*p == 0xfe) {
+ ++p;
+ if (p >= end)
+ return -1;
+ res = *p + MONO_PREFIX1_OFFSET;
+ } else if (*p == MONO_CUSTOM_PREFIX) {
+ ++p;
+ if (p >= end)
+ return -1;
+ res = *p + MONO_CUSTOM_PREFIX_OFFSET;
} else {
- res = **ip;
+ res = *p;
}
-
+ *ip = p;
return res;
}
extern const char* const mono_opcode_names [];
MonoOpcodeEnum
-mono_opcode_value (const guint8 **ip);
+mono_opcode_value (const guint8 **ip, const guint8 *end);
#endif /* __MONO_METADATA_OPCODES_H__ */
#include <mono/metadata/tokentype.h>
#include <mono/metadata/appdomain.h>
#include <mono/metadata/assembly.h>
+#include <mono/metadata/metadata-internals.h>
#include <mono/metadata/rawbuffer.h>
#include "mono/utils/mono-digest.h"
return;
}
- data=mono_cli_rva_map (image->image_info,
+ data=mono_image_rva_map (image,
version_info->rde_data_offset);
if(data==NULL) {
return;
MonoObject *item, *filever;
MonoDomain *domain=mono_domain_get ();
gchar *modulename;
+ const char* filename;
/* Build a System.Diagnostics.ProcessModule with the data.
* Leave BaseAddress and EntryPointAddress set to NULL,
g_message (G_GNUC_PRETTY_FUNCTION ": recording assembly: FileName [%s] FileVersionInfo [%d.%d.%d.%d], ModuleName [%s]", ass->image->name, ass->aname.major, ass->aname.minor, ass->aname.build, ass->aname.revision, ass->image->name);
#endif
- process_get_fileversion (filever, ass->image);
+ process_get_fileversion (filever, mono_assembly_get_image (ass));
- process_set_field_string_utf8 (filever, "filename", ass->image->name);
- process_set_field_string_utf8 (item, "filename", ass->image->name);
+ filename = mono_image_get_filename (mono_assembly_get_image (ass));
+ process_set_field_string_utf8 (filever, "filename", filename);
+ process_set_field_string_utf8 (item, "filename", filename);
process_set_field_object (item, "version_info", filever);
- modulename=g_path_get_basename (ass->image->name);
+ modulename=g_path_get_basename (filename);
process_set_field_string_utf8 (item, "modulename", modulename);
g_free (modulename);
}
process_get_fileversion (this, image);
- process_set_field_string_utf8 (this, "filename", image->name);
+ process_set_field_string_utf8 (this, "filename", mono_image_get_filename (image));
mono_image_close (image);
}
#include "mono/utils/mono-digest.h"
#include "mono/metadata/reflection.h"
#include "mono/metadata/tabledefs.h"
+#include "mono/metadata/metadata-internals.h"
#include "mono/metadata/tokentype.h"
#include "mono/metadata/domain-internals.h"
#include "mono/metadata/opcodes.h"
#include <mono/metadata/object.h>
#include <mono/utils/mono-hash.h>
-typedef struct {
- GHashTable *hash;
- char *data;
- guint32 alloc_size; /* malloced bytes */
- guint32 index;
- guint32 offset; /* from start of metadata */
-} MonoDynamicStream;
-
-typedef struct {
- guint32 alloc_rows;
- guint32 rows;
- guint32 row_size; /* calculated later with column_sizes */
- guint32 columns;
- guint32 column_sizes [9];
- guint32 *values; /* rows * columns */
- guint32 next_idx;
-} MonoDynamicTable;
-
/*
* The followinbg structure must match the C# implementation in our corlib.
*/
guint32 call_conv;
} MonoReflectionArrayMethod;
-enum {
- MONO_SECTION_TEXT,
- MONO_SECTION_RSRC,
- MONO_SECTION_RELOC,
- MONO_SECTION_MAX
-};
-
-typedef struct {
- MonoAssembly assembly;
- gboolean run;
- gboolean save;
- char *strong_name;
- guint32 strong_name_size;
-} MonoDynamicAssembly;
-
-typedef struct {
- MonoImage image;
- guint32 meta_size;
- guint32 text_rva;
- guint32 metadata_rva;
- guint32 image_base;
- guint32 cli_header_offset;
- guint32 iat_offset;
- guint32 idt_offset;
- guint32 ilt_offset;
- guint32 imp_names_offset;
- struct {
- guint32 rva;
- guint32 size;
- guint32 offset;
- guint32 attrs;
- } sections [MONO_SECTION_MAX];
- GHashTable *typespec;
- GHashTable *typeref;
- GHashTable *handleref;
- MonoGHashTable *tokens;
- MonoGHashTable *blob_cache;
- GList *array_methods;
- MonoGHashTable *token_fixups;
- MonoGHashTable *method_to_table_idx;
- MonoGHashTable *field_to_table_idx;
- MonoGHashTable *method_aux_hash;
- gboolean run;
- gboolean save;
- char *strong_name;
- guint32 strong_name_size;
- char *win32_res;
- guint32 win32_res_size;
- MonoDynamicStream pefile;
- MonoDynamicStream sheap;
- MonoDynamicStream code; /* used to store method headers and bytecode */
- MonoDynamicStream resources; /* managed embedded resources */
- MonoDynamicStream us;
- MonoDynamicStream blob;
- MonoDynamicStream tstream;
- MonoDynamicStream guid;
- MonoDynamicTable tables [64];
-} MonoDynamicImage;
+typedef struct _MonoDynamicAssembly MonoDynamicAssembly;
+typedef struct _MonoDynamicImage MonoDynamicImage;
typedef struct {
MonoArray *data;
#include <mono/metadata/debug-helpers.h>
#include <mono/metadata/mono-endian.h>
#include <mono/metadata/metadata.h>
+#include <mono/metadata/metadata-internals.h>
#include <mono/metadata/tokentype.h>
#include <string.h>
#include <signal.h>
#include <mono/metadata/appdomain.h>
#include <mono/metadata/debug-helpers.h>
#include <mono/metadata/assembly.h>
+#include <mono/metadata/metadata-internals.h>
#include <mono/metadata/marshal.h>
#include <mono/os/gc_wrapper.h>
}
/* load the metadata */
- for (i = 0; i < image->tables [MONO_TABLE_METHOD].rows; ++i) {
+ for (i = 0; i < mono_image_get_table_rows (image, MONO_TABLE_METHOD); ++i) {
method = mono_get_method (image, MONO_TOKEN_METHOD_DEF | (i + 1), NULL);
mono_class_init (method->klass);
opt_flags = opt_sets [opt];
mono_set_defaults (verbose, opt_flags);
n = opt_descr (opt_flags);
- g_print ("Test run: image=%s, opts=%s\n", image->name, n);
+ g_print ("Test run: image=%s, opts=%s\n", mono_image_get_filename (image), n);
g_free (n);
cfailed = failed = run = code_size = 0;
comp_time = elapsed = 0.0;
/* fixme: ugly hack - delete all previously compiled methods */
- for (i = 0; i < image->tables [MONO_TABLE_METHOD].rows; ++i) {
+ for (i = 0; i < mono_image_get_table_rows (image, MONO_TABLE_METHOD); ++i) {
method = mono_get_method (image, MONO_TOKEN_METHOD_DEF | (i + 1), NULL);
method->info = NULL;
}
g_timer_start (timer);
if (mini_stats_fd)
fprintf (mini_stats_fd, "[");
- for (i = 0; i < image->tables [MONO_TABLE_METHOD].rows; ++i) {
+ for (i = 0; i < mono_image_get_table_rows (image, MONO_TABLE_METHOD); ++i) {
method = mono_get_method (image, MONO_TOKEN_METHOD_DEF | (i + 1), NULL);
if (strncmp (method->name, "test_", 5) == 0) {
expected = atoi (method->name + 5);
g_warning ("failed to load assembly: %s", images [i]);
continue;
}
- total += mini_regression (ass->image, verbose, &run);
+ total += mini_regression (mono_assembly_get_image (ass), verbose, &run);
total_run += run;
mono_assembly_close (ass);
}
{
MonoAssembly *ass = args->ass;
int verbose = args->verbose;
- MonoImage *image = ass->image;
+ MonoImage *image = mono_assembly_get_image (ass);
MonoMethod *method;
int i, count = 0;
- for (i = 0; i < image->tables [MONO_TABLE_METHOD].rows; ++i) {
+ for (i = 0; i < mono_image_get_table_rows (image, MONO_TABLE_METHOD); ++i) {
method = mono_get_method (image, MONO_TOKEN_METHOD_DEF | (i + 1), NULL);
if (method->flags & METHOD_ATTRIBUTE_ABSTRACT)
continue;
int
mono_jit_exec (MonoDomain *domain, MonoAssembly *assembly, int argc, char *argv[])
{
- MonoImage *image = assembly->image;
+ MonoImage *image = mono_assembly_get_image (assembly);
MonoMethod *method;
guint32 entry = mono_image_get_entry_point (image);
if (!entry) {
- g_print ("Assembly '%s' doesn't have an entry point.\n", image->name);
+ g_print ("Assembly '%s' doesn't have an entry point.\n", mono_image_get_filename (image));
/* FIXME: remove this silly requirement. */
mono_environment_exitcode_set (1);
return 1;
const guchar *clibpath;
mono_init ("mono");
cerror = mono_check_corlib_version ();
- clibpath = mono_defaults.corlib? mono_defaults.corlib->name: "unknown";
+ clibpath = mono_defaults.corlib? mono_image_get_filename (mono_defaults.corlib): "unknown";
if (cerror) {
g_print ("The currently installed mscorlib doesn't match this runtime version.\n");
g_print ("The error is: %s\n", cerror);
mini_cleanup (domain);
return 3;
}
- method = mono_method_desc_search_in_image (desc, assembly->image);
+ method = mono_method_desc_search_in_image (desc, mono_assembly_get_image (assembly));
if (!method) {
g_print ("Cannot find method %s\n", mname);
mini_cleanup (domain);
while (ip < end) {
cli_addr = ip - start;
- i = mono_opcode_value ((const guint8 **)&ip);
+ i = mono_opcode_value ((const guint8 **)&ip, end);
+ if (i < 0)
+ goto unverified;
opcode = &mono_opcodes [i];
switch (opcode->argument) {
case MonoInlineNone:
static void
mono_precompile_assembly (MonoAssembly *ass, void *user_data)
{
- MonoImage *image = ass->image;
+ MonoImage *image = mono_assembly_get_image (ass);
MonoMethod *method, *invoke;
int i, count = 0;
if (mini_verbose > 0)
- printf ("PRECOMPILE: %s.\n", ass->image->name);
+ printf ("PRECOMPILE: %s.\n", mono_image_get_filename (image));
- for (i = 0; i < image->tables [MONO_TABLE_METHOD].rows; ++i) {
+ for (i = 0; i < mono_image_get_table_rows (image, MONO_TABLE_METHOD); ++i) {
method = mono_get_method (image, MONO_TOKEN_METHOD_DEF | (i + 1), NULL);
if (method->flags & METHOD_ATTRIBUTE_ABSTRACT)
continue;
#include <string.h>
#include "mini.h"
#include <mono/metadata/debug-helpers.h>
+#include <mono/metadata/assembly.h>
#include "trace.h"
static MonoTraceSpec trace_spec;
case MONO_TRACEOP_ALL:
inc = 1; break;
case MONO_TRACEOP_PROGRAM:
- if (method->klass->image == trace_spec.assembly->image)
+ if (method->klass->image == mono_assembly_get_image (trace_spec.assembly))
inc = 1; break;
case MONO_TRACEOP_METHOD:
if (mono_method_desc_match ((MonoMethodDesc *) op->data, method))
inc = 1;
break;
case MONO_TRACEOP_ASSEMBLY:
- if (strcmp (method->klass->image->assembly_name, op->data) == 0)
+ if (strcmp (mono_image_get_name (method->klass->image), op->data) == 0)
inc = 1; break;
case MONO_TRACEOP_NAMESPACE:
if (strcmp (method->klass->name_space, op->data) == 0)
if (depth++ > max_depth)
return;
- t = &image->tables [MONO_TABLE_TYPEDEF];
+ t = mono_image_get_table_info (image, MONO_TABLE_TYPEDEF);
token = mono_metadata_token_index (class->type_token);
token <<= TYPEDEFORREF_BITS;
token |= TYPEDEFORREF_TYPEDEF;
/* use a subgraph? */
- for (i = 0; i < t->rows; ++i) {
+ for (i = 0; i < mono_table_info_get_rows (t); ++i) {
if (token == mono_metadata_decode_row_col (t, i, MONO_TYPEDEF_EXTENDS)) {
child = mono_class_get (image, MONO_TOKEN_TYPE_DEF | (i + 1));
output_type_edge (class, child);
char *p;
guint32 cols [MONO_INTERFACEIMPL_SIZE];
guint32 token, i, count = 0;
- MonoTableInfo *intf = &image->tables [MONO_TABLE_INTERFACEIMPL];
+ MonoTableInfo *intf = mono_image_get_table_info (image, MONO_TABLE_INTERFACEIMPL);
cname = g_strdup (cname);
p = strrchr (cname, '.');
token = mono_metadata_token_index (class->type_token);
token <<= TYPEDEFORREF_BITS;
token |= TYPEDEFORREF_TYPEDEF;
- for (i = 0; i < intf->rows; ++i) {
+ for (i = 0; i < mono_table_info_get_rows (intf); ++i) {
mono_metadata_decode_row (intf, i, cols, MONO_INTERFACEIMPL_SIZE);
/*g_print ("index: %d [%d implements %d]\n", index, cols [MONO_INTERFACEIMPL_CLASS], cols [MONO_INTERFACEIMPL_INTERFACE]);*/
if (token == cols [MONO_INTERFACEIMPL_INTERFACE]) {
MonoMethod *method;
MonoClass *klass;
- for (i = 0; i < image->tables [MONO_TABLE_METHOD].rows; ++i) {
+ num_methods = mono_image_get_table_rows (image, MONO_TABLE_METHOD);
+ for (i = 0; i < num_methods; ++i) {
method = mono_get_method (image, MONO_TOKEN_METHOD_DEF | (i + 1), NULL);
method_stats (method);
}
- num_methods = image->tables [MONO_TABLE_METHOD].rows;
- for (i = 0; i < image->tables [MONO_TABLE_TYPEDEF].rows; ++i) {
+ num_types = mono_image_get_table_rows (image, MONO_TABLE_TYPEDEF);
+ for (i = 0; i < num_types; ++i) {
klass = mono_class_get (image, MONO_TOKEN_TYPE_DEF | (i + 1));
type_stats (klass);
}
- num_types = image->tables [MONO_TABLE_TYPEDEF].rows;
g_print ("Methods and code stats:\n");
g_print ("back branch waste: %d\n", back_branch_waste);
if (!name) {
guint32 token = mono_image_get_entry_point (image);
if (!token || !(method = mono_get_method (image, token, NULL))) {
- g_print ("Cannot find entry point in %s: specify an explict method name.\n", image->name);
+ g_print ("Cannot find entry point in %s: specify an explict method name.\n", mono_image_get_filename (image));
exit (1);
}
} else {
if (!name) {
guint32 token = mono_image_get_entry_point (image);
if (!token || !(method = mono_get_method (image, token, NULL))) {
- g_print ("Cannot find entry point in %s: specify an explict method name.\n", image->name);
+ g_print ("Cannot find entry point in %s: specify an explict method name.\n", mono_image_get_filename (image));
exit (1);
}
} else {
int
main (int argc, char *argv[]) {
MonoAssembly *assembly;
+ MonoImage *image;
const char *cname = NULL;
const char *aname = NULL;
char *outputfile = NULL;
if (cname && strchr (cname, ':') && graphtype == GRAPH_TYPES)
graphtype = GRAPH_CALL;
+ image = mono_assembly_get_image (assembly);
switch (graphtype) {
case GRAPH_TYPES:
- type_graph (assembly->image, cname);
+ type_graph (image, cname);
break;
case GRAPH_CALL:
- method_graph (assembly->image, cname);
+ method_graph (image, cname);
break;
case GRAPH_INTERFACE:
- interface_graph (assembly->image, cname);
+ interface_graph (image, cname);
break;
case GRAPH_CONTROL_FLOW:
- method_cfg (assembly->image, cname);
+ method_cfg (image, cname);
break;
case GRAPH_STATS:
- stats (assembly->image, cname);
+ stats (image, cname);
break;
default:
g_error ("wrong graph type");
projects / mono.git / commitdiff