mono/metadata/null-gc.c

   1 /*
   2  * null-gc.c: GC implementation using malloc: will leak everything, just for testing.
   3  *
   4  */
   5
   6 #include "config.h"
   7 #include <glib.h>
   8 #include <mono/metadata/mono-gc.h>
   9 #include <mono/metadata/gc-internal.h>
  10
  11 #ifdef HAVE_NULL_GC
  12
  13 void
  14 mono_gc_base_init (void)
  15 {
  16 }
  17
  18 void
  19 mono_gc_collect (int generation)
  20 {
  21 }
  22
  23 int
  24 mono_gc_max_generation (void)
  25 {
  26         return 0;
  27 }
  28
  29 int
  30 mono_gc_get_generation  (MonoObject *object)
  31 {
  32         return 0;
  33 }
  34
  35 int
  36 mono_gc_collection_count (int generation)
  37 {
  38         return 0;
  39 }
  40
  41 void
  42 mono_gc_add_memory_pressure (gint64 value)
  43 {
  44 }
  45
  46 /* maybe track the size, not important, though */
  47 gint64
  48 mono_gc_get_used_size (void)
  49 {
  50         return 1024*1024;
  51 }
  52
  53 gint64
  54 mono_gc_get_heap_size (void)
  55 {
  56         return 2*1024*1024;
  57 }
  58
  59 void
  60 mono_gc_disable (void)
  61 {
  62 }
  63
  64 void
  65 mono_gc_enable (void)
  66 {
  67 }
  68
  69 gboolean
  70 mono_gc_is_gc_thread (void)
  71 {
  72         return TRUE;
  73 }
  74
  75 gboolean
  76 mono_gc_register_thread (void *baseptr)
  77 {
  78         return TRUE;
  79 }
  80
  81 gboolean
  82 mono_object_is_alive (MonoObject* o)
  83 {
  84         return TRUE;
  85 }
  86
  87 void
  88 mono_gc_enable_events (void)
  89 {
  90 }
  91
  92 int
  93 mono_gc_register_root (char *start, size_t size, void *descr)
  94 {
  95         return TRUE;
  96 }
  97
  98 void
  99 mono_gc_deregister_root (char* addr)
 100 {
 101 }
 102
 103 void
 104 mono_gc_weak_link_add (void **link_addr, MonoObject *obj)
 105 {
 106         *link_addr = obj;
 107 }
 108
 109 void
 110 mono_gc_weak_link_remove (void **link_addr)
 111 {
 112         *link_addr = NULL;
 113 }
 114
 115 MonoObject*
 116 mono_gc_weak_link_get (void **link_addr)
 117 {
 118         return *link_addr;
 119 }
 120
 121 void*
 122 mono_gc_make_descr_for_string (gsize *bitmap, int numbits)
 123 {
 124         return NULL;
 125 }
 126
 127 void*
 128 mono_gc_make_descr_for_object (gsize *bitmap, int numbits, size_t obj_size)
 129 {
 130         return NULL;
 131 }
 132
 133 void*
 134 mono_gc_make_descr_for_array (int vector, gsize *elem_bitmap, int numbits, size_t elem_size)
 135 {
 136         return NULL;
 137 }
 138
 139 void*
 140 mono_gc_make_descr_from_bitmap (gsize *bitmap, int numbits)
 141 {
 142         return NULL;
 143 }
 144
 145 void*
 146 mono_gc_alloc_fixed (size_t size, void *descr)
 147 {
 148         return g_malloc0 (size);
 149 }
 150
 151 void
 152 mono_gc_free_fixed (void* addr)
 153 {
 154         g_free (addr);
 155 }
 156
 157 void
 158 mono_gc_wbarrier_set_field (MonoObject *obj, gpointer field_ptr, MonoObject* value)
 159 {
 160         *(void**)field_ptr = value;
 161 }
 162
 163 void
 164 mono_gc_wbarrier_set_arrayref (MonoArray *arr, gpointer slot_ptr, MonoObject* value)
 165 {
 166         *(void**)slot_ptr = value;
 167 }
 168
 169 void
 170 mono_gc_wbarrier_arrayref_copy (MonoArray *arr, gpointer slot_ptr, int count)
 171 {
 172         /* no need to do anything */
 173 }
 174
 175 void
 176 mono_gc_wbarrier_generic_store (gpointer ptr, MonoObject* value)
 177 {
 178         *(void**)ptr = value;
 179 }
 180
 181 void
 182 mono_gc_wbarrier_value_copy (gpointer dest, gpointer src, int count, MonoClass *klass)
 183 {
 184 }
 185
 186 void
 187 mono_gc_wbarrier_object (MonoObject* obj)
 188 {
 189 }
 190
 191 MonoMethod*
 192 mono_gc_get_managed_allocator (MonoVTable *vtable, gboolean for_box)
 193 {
 194         return NULL;
 195 }
 196
 197 int
 198 mono_gc_get_managed_allocator_type (MonoMethod *managed_alloc)
 199 {
 200         return -1;
 201 }
 202
 203 MonoMethod*
 204 mono_gc_get_managed_allocator_by_type (int atype)
 205 {
 206         return NULL;
 207 }
 208
 209 #endif
 210