mono/metadata/reflection-cache.h

   1 /**
   2  * \file
   3  * Copyright 2016 Microsoft
   4  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
   5  */
   6 #ifndef __MONO_METADATA_REFLECTION_CACHE_H__
   7 #define __MONO_METADATA_REFLECTION_CACHE_H__
   8
   9 #include <glib.h>
  10 #include <mono/metadata/domain-internals.h>
  11 #include <mono/metadata/handle.h>
  12 #include <mono/metadata/mono-hash.h>
  13 #include <mono/metadata/mempool.h>
  14 #include <mono/utils/mono-error-internals.h>
  15
  16 /*
  17  * We need to return always the same object for MethodInfo, FieldInfo etc..
  18  * but we need to consider the reflected type.
  19  * type uses a different hash, since it uses custom hash/equal functions.
  20  */
  21
  22 typedef struct {
  23         gpointer item;
  24         MonoClass *refclass;
  25 } ReflectedEntry;
  26
  27 gboolean
  28 reflected_equal (gconstpointer a, gconstpointer b);
  29
  30 guint
  31 reflected_hash (gconstpointer a);
  32
  33 #ifdef HAVE_BOEHM_GC
  34 /* ReflectedEntry doesn't need to be GC tracked */
  35 #define ALLOC_REFENTRY g_new0 (ReflectedEntry, 1)
  36 #define FREE_REFENTRY(entry) g_free ((entry))
  37 #define REFENTRY_REQUIRES_CLEANUP
  38 #else
  39 #define ALLOC_REFENTRY (ReflectedEntry *)mono_mempool_alloc (domain->mp, sizeof (ReflectedEntry))
  40 /* FIXME: */
  41 #define FREE_REFENTRY(entry)
  42 #endif
  43
  44 static inline MonoObject*
  45 cache_object (MonoDomain *domain, MonoClass *klass, gpointer item, MonoObject* o)
  46 {
  47         MonoObject *obj;
  48         ReflectedEntry pe;
  49         pe.item = item;
  50         pe.refclass = klass;
  51
  52         mono_domain_lock (domain);
  53         if (!domain->refobject_hash)
  54                 domain->refobject_hash = mono_conc_g_hash_table_new_type (reflected_hash, reflected_equal, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, "domain reflection objects table");
  55
  56         obj = (MonoObject*) mono_conc_g_hash_table_lookup (domain->refobject_hash, &pe);
  57         if (obj == NULL) {
  58                 ReflectedEntry *e = ALLOC_REFENTRY;
  59                 e->item = item;
  60                 e->refclass = klass;
  61                 mono_conc_g_hash_table_insert (domain->refobject_hash, e, o);
  62                 obj = o;
  63         }
  64         mono_domain_unlock (domain);
  65         return obj;
  66 }
  67
  68
  69 static inline MonoObjectHandle
  70 cache_object_handle (MonoDomain *domain, MonoClass *klass, gpointer item, MonoObjectHandle o)
  71 {
  72         ReflectedEntry pe;
  73         pe.item = item;
  74         pe.refclass = klass;
  75
  76         mono_domain_lock (domain);
  77         if (!domain->refobject_hash)
  78                 domain->refobject_hash = mono_conc_g_hash_table_new_type (reflected_hash, reflected_equal, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, "domain reflection objects table");
  79
  80         MonoObjectHandle obj = MONO_HANDLE_NEW (MonoObject, mono_conc_g_hash_table_lookup (domain->refobject_hash, &pe));
  81         if (MONO_HANDLE_IS_NULL (obj)) {
  82                 ReflectedEntry *e = ALLOC_REFENTRY;
  83                 e->item = item;
  84                 e->refclass = klass;
  85                 mono_conc_g_hash_table_insert (domain->refobject_hash, e, MONO_HANDLE_RAW (o));
  86                 MONO_HANDLE_ASSIGN (obj, o);
  87         }
  88         mono_domain_unlock (domain);
  89         return obj;
  90 }
  91
  92 #define CACHE_OBJECT(t,p,o,k) ((t) (cache_object (domain, (k), (p), (o))))
  93 #define CACHE_OBJECT_HANDLE(t,p,o,k) ((t) (cache_object_handle (domain, (k), (p), (o))))
  94
  95 static inline MonoObjectHandle
  96 check_object_handle (MonoDomain* domain, MonoClass *klass, gpointer item)
  97 {
  98         ReflectedEntry e;
  99         e.item = item;
 100         e.refclass = klass;
 101         MonoConcGHashTable *hash = domain->refobject_hash;
 102         if (!hash)
 103                 return MONO_HANDLE_NEW (MonoObject, NULL);
 104
 105         MonoObjectHandle obj = MONO_HANDLE_NEW (MonoObject, mono_conc_g_hash_table_lookup (hash, &e));
 106         return obj;
 107 }
 108
 109
 110 typedef MonoObjectHandle (*ReflectionCacheConstructFunc_handle) (MonoDomain*, MonoClass*, gpointer, gpointer, MonoError *);
 111
 112 static inline MonoObjectHandle
 113 check_or_construct_handle (MonoDomain *domain, MonoClass *klass, gpointer item, gpointer user_data, MonoError *error, ReflectionCacheConstructFunc_handle construct)
 114 {
 115         error_init (error);
 116         MonoObjectHandle obj = check_object_handle (domain, klass, item);
 117         if (!MONO_HANDLE_IS_NULL (obj))
 118                 return obj;
 119         MONO_HANDLE_ASSIGN (obj, construct (domain, klass, item, user_data, error));
 120         return_val_if_nok (error, NULL);
 121         if (MONO_HANDLE_IS_NULL (obj))
 122                 return obj;
 123         /* note no caching if there was an error in construction */
 124         return cache_object_handle (domain, klass, item, obj);
 125 }
 126
 127
 128 #define CHECK_OR_CONSTRUCT_HANDLE(t,p,k,construct,ud) ((t) check_or_construct_handle (domain, (k), (p), (ud), error, (ReflectionCacheConstructFunc_handle) (construct)))
 129
 130
 131 #endif /*__MONO_METADATA_REFLECTION_CACHE_H__*/