mono/metadata/image.h

   1 #ifndef _MONONET_METADATA_IMAGE_H_
   2 #define _MONONET_METADATA_IMAGE_H_
   3
   4 #include <stdio.h>
   5 #include <glib.h>
   6 #include <gmodule.h>
   7
   8 typedef struct _MonoImage MonoImage;
   9
  10 typedef struct {
  11         const char *name;
  12         const char *culture;
  13         const char *hash_value;
  14         guint32 hash_len;
  15         guint32 flags;
  16         guint16 major, minor, build, revision;
  17 } MonoAssemblyName;
  18
  19 typedef struct {
  20         int   ref_count;
  21         char *basedir;
  22         MonoAssemblyName aname;
  23         GModule *aot_module;
  24         MonoImage *image;
  25         /* Load files here */
  26         void *dynamic;
  27 } MonoAssembly;
  28
  29 typedef struct {
  30         const char* data;
  31         guint32  size;
  32 } MonoStreamHeader;
  33
  34 typedef struct {
  35         guint32   rows, row_size;
  36         const char *base;
  37
  38         /*
  39          * Tables contain up to 9 columns and the possible sizes of the
  40          * fields in the documentation are 1, 2 and 4 bytes.  So we
  41          * can encode in 2 bits the size.
  42          *
  43          * A 32 bit value can encode the resulting size
  44          *
  45          * The top eight bits encode the number of columns in the table.
  46          * we only need 4, but 8 is aligned no shift required.
  47          */
  48         guint32   size_bitfield;
  49 } MonoTableInfo;
  50
  51 struct _MonoImage {
  52         int   ref_count;
  53         FILE *f;
  54         /* if f is NULL the image was loaded rom raw data */
  55         char *raw_data;
  56         guint32 raw_data_len;
  57         gboolean raw_data_allocated;
  58         char *name;
  59         const char *assembly_name;
  60         const char *module_name;
  61         char *guid;
  62         void *image_info;
  63
  64         char                *raw_metadata;
  65
  66         gboolean             idx_string_wide, idx_guid_wide, idx_blob_wide;
  67
  68         MonoStreamHeader     heap_strings;
  69         MonoStreamHeader     heap_us;
  70         MonoStreamHeader     heap_blob;
  71         MonoStreamHeader     heap_guid;
  72         MonoStreamHeader     heap_tables;
  73
  74         const char          *tables_base;
  75
  76         MonoTableInfo        tables [64];
  77
  78         /*
  79          * references is initialized only by using the mono_assembly_open
  80          * function, and not by using the lowlevel mono_image_open.
  81          *
  82          * It is NULL terminated.
  83          */
  84         MonoAssembly **references;
  85
  86         MonoImage **modules;
  87
  88         /*
  89          * The Assembly this image was loaded from.
  90          */
  91         MonoAssembly *assembly;
  92
  93         /*
  94          * Indexed by method tokens and typedef tokens.
  95          */
  96         GHashTable *method_cache;
  97         GHashTable *class_cache;
  98         /*
  99          * Indexes namespaces to hash tables that map class name to typedef token.
 100          */
 101         GHashTable *name_cache;
 102
 103         /*
 104          * Indexed by ((rank << 24) | (typedef & 0xffffff)), which limits us to a
 105          * maximal rank of 255
 106          */
 107         GHashTable *array_cache;
 108
 109         /*
 110          * indexed by MonoMethodSignature
 111          */
 112         GHashTable *delegate_begin_invoke_cache;
 113         GHashTable *delegate_end_invoke_cache;
 114         GHashTable *delegate_invoke_cache;
 115
 116         /*
 117          * indexed by MonoMethod pointers
 118          */
 119         GHashTable *runtime_invoke_cache;
 120         GHashTable *managed_wrapper_cache;
 121         GHashTable *native_wrapper_cache;
 122         GHashTable *remoting_invoke_cache;
 123         GHashTable *synchronized_cache;
 124
 125         void *reflection_info;
 126
 127         /*
 128          * user_info is a public field and is not touched by the
 129          * metadata engine
 130          */
 131         void *user_info;
 132 };
 133
 134 typedef enum {
 135         MONO_IMAGE_OK,
 136         MONO_IMAGE_ERROR_ERRNO,
 137         MONO_IMAGE_MISSING_ASSEMBLYREF,
 138         MONO_IMAGE_IMAGE_INVALID
 139 } MonoImageOpenStatus;
 140
 141 MonoImage    *mono_image_open     (const char *fname,
 142                                    MonoImageOpenStatus *status);
 143 MonoImage    *mono_image_open_from_data (char *data, guint32 data_len, gboolean need_copy,
 144                                          MonoImageOpenStatus *status);
 145 MonoImage    *mono_image_loaded   (const char *name);
 146 MonoImage    *mono_image_loaded_by_guid (const char *guid);
 147 void          mono_image_init     (MonoImage *image);
 148 void          mono_image_close    (MonoImage *image);
 149 const char   *mono_image_strerror (MonoImageOpenStatus status);
 150
 151 int           mono_image_ensure_section     (MonoImage *image,
 152                                              const char *section);
 153 int           mono_image_ensure_section_idx (MonoImage *image,
 154                                              int section);
 155
 156 guint32       mono_image_get_entry_point    (MonoImage *image);
 157 const char   *mono_image_get_resource       (MonoImage *image, guint32 offset, guint32 *size);
 158
 159 void          mono_image_load_references    (MonoImage *image, MonoImageOpenStatus *status);
 160
 161 /* This actually returns a MonoPEResourceDataEntry *, but declaring it
 162  * causes an include file loop.
 163  */
 164 gpointer      mono_image_lookup_resource (MonoImage *image, guint32 res_id,
 165                                           guint32 lang_id, gunichar2 *name);
 166
 167 const char*   mono_image_get_public_key  (MonoImage *image, guint32 *size);
 168 const char*   mono_image_get_strong_name (MonoImage *image, guint32 *size);
 169 guint32       mono_image_strong_name_position (MonoImage *image, guint32 *size);
 170 void          mono_image_add_to_name_cache (MonoImage *image,
 171                                                                                         const char *nspace,
 172                                                                                         const char *name, guint32 idx);
 173
 174 #endif