mono/mini/mini-llvm.h

   1 /*
   2  * Handle the differences between the llvm backend beeing embedded
   3  * or loaded at runtime.
   4  */
   5 #ifdef MONO_LLVM_LOADED
   6
   7 int mono_llvm_load (const char* bpath) MONO_INTERNAL;
   8
   9 #ifdef MONO_LLVM_IN_MINI
  10
  11 #ifdef __MACH__
  12 #include <mach-o/dyld.h>
  13 #endif
  14
  15 typedef void (*MonoLLVMVoidFunc)(void);
  16 typedef void (*MonoLLVMCFGFunc)(MonoCompile *cfg);
  17 typedef void (*MonoLLVMEmitCallFunc)(MonoCompile *cfg, MonoCallInst *call);
  18 typedef void (*MonoLLVMCreateAotFunc)(const char *got_symbol);
  19 typedef void (*MonoLLVMEmitAotFunc)(const char *filename, int got_size);
  20
  21 static MonoLLVMVoidFunc mono_llvm_init_fptr;
  22 static MonoLLVMVoidFunc mono_llvm_cleanup_fptr;
  23 static MonoLLVMCFGFunc mono_llvm_emit_method_fptr;
  24 static MonoLLVMEmitCallFunc mono_llvm_emit_call_fptr;
  25 static MonoLLVMCreateAotFunc mono_llvm_create_aot_module_fptr;
  26 static MonoLLVMEmitAotFunc mono_llvm_emit_aot_module_fptr;
  27 static MonoLLVMCFGFunc mono_llvm_check_method_supported_fptr;
  28
  29 void
  30 mono_llvm_init (void)
  31 {
  32         mono_llvm_init_fptr ();
  33 }
  34
  35 void
  36 mono_llvm_cleanup (void)
  37 {
  38         mono_llvm_cleanup_fptr ();
  39 }
  40
  41 void
  42 mono_llvm_emit_method (MonoCompile *cfg)
  43 {
  44         mono_llvm_emit_method_fptr (cfg);
  45 }
  46
  47 void
  48 mono_llvm_emit_call (MonoCompile *cfg, MonoCallInst *call)
  49 {
  50         mono_llvm_emit_call_fptr (cfg, call);
  51 }
  52
  53 void
  54 mono_llvm_create_aot_module (const char *got_symbol)
  55 {
  56         g_assert (mono_llvm_create_aot_module_fptr);
  57         mono_llvm_create_aot_module_fptr (got_symbol);
  58 }
  59
  60 void
  61 mono_llvm_emit_aot_module (const char *filename, int got_size)
  62 {
  63         g_assert (mono_llvm_emit_aot_module_fptr);
  64         mono_llvm_emit_aot_module_fptr (filename, got_size);
  65 }
  66
  67 void
  68 mono_llvm_check_method_supported (MonoCompile *cfg)
  69 {
  70         mono_llvm_check_method_supported_fptr (cfg);
  71 }
  72
  73 static MonoDl*
  74 try_llvm_load (char *dir, char **err)
  75 {
  76         gpointer iter;
  77         MonoDl *llvm_lib;
  78         char *path;
  79         iter = NULL;
  80         *err = NULL;
  81         while ((path = mono_dl_build_path (dir, "mono-llvm", &iter))) {
  82                 g_free (*err);
  83                 llvm_lib = mono_dl_open (path, MONO_DL_LAZY, err);
  84                 g_free (path);
  85                 if (llvm_lib)
  86                         return llvm_lib;
  87         }
  88         return NULL;
  89 }
  90
  91 int
  92 mono_llvm_load (const char* bpath)
  93 {
  94         MonoDl *llvm_lib = NULL;
  95         char *err;
  96         char buf [4096];
  97         int binl;
  98         binl = readlink ("/proc/self/exe", buf, sizeof (buf)-1);
  99 #ifdef __MACH__
 100         if (binl == -1) {
 101                 uint32_t bsize = sizeof (buf);
 102                 if (_NSGetExecutablePath (buf, &bsize) == 0) {
 103                         binl = strlen (buf);
 104                 }
 105         }
 106 #endif
 107         if (binl != -1) {
 108                 char *base;
 109                 char *name;
 110                 buf [binl] = 0;
 111                 base = g_path_get_dirname (buf);
 112                 name = g_strdup_printf ("%s/.libs", base);
 113                 err = NULL;
 114                 llvm_lib = try_llvm_load (name, &err);
 115                 g_free (name);
 116                 if (!llvm_lib) {
 117                         char *newbase = g_path_get_dirname (base);
 118                         name = g_strdup_printf ("%s/lib", newbase);
 119                         err = NULL;
 120                         llvm_lib = try_llvm_load (name, &err);
 121                         g_free (name);
 122                 }
 123                 g_free (base);
 124         }
 125         if (!llvm_lib) {
 126                 llvm_lib = try_llvm_load (NULL, &err);
 127                 if (!llvm_lib) {
 128                         g_warning ("llvm load failed: %s\n", err);
 129                         g_free (err);
 130                         return FALSE;
 131                 }
 132         }
 133         err = mono_dl_symbol (llvm_lib, "mono_llvm_init", (void**)&mono_llvm_init_fptr);
 134         if (err) goto symbol_error;
 135         err = mono_dl_symbol (llvm_lib, "mono_llvm_cleanup", (void**)&mono_llvm_cleanup_fptr);
 136         if (err) goto symbol_error;
 137         err = mono_dl_symbol (llvm_lib, "mono_llvm_emit_method", (void**)&mono_llvm_emit_method_fptr);
 138         if (err) goto symbol_error;
 139         err = mono_dl_symbol (llvm_lib, "mono_llvm_emit_call", (void**)&mono_llvm_emit_call_fptr);
 140         if (err) goto symbol_error;
 141         err = mono_dl_symbol (llvm_lib, "mono_llvm_create_aot_module", (void**)&mono_llvm_create_aot_module_fptr);
 142         if (err) goto symbol_error;
 143         err = mono_dl_symbol (llvm_lib, "mono_llvm_emit_aot_module", (void**)&mono_llvm_emit_aot_module_fptr);
 144         if (err) goto symbol_error;
 145         err = mono_dl_symbol (llvm_lib, "mono_llvm_check_method_supported", (void**)&mono_llvm_check_method_supported_fptr);
 146         if (err) goto symbol_error;
 147         return TRUE;
 148 symbol_error:
 149         g_warning ("llvm symbol load failed: %s\n", err);
 150         g_free (err);
 151         return FALSE;
 152 }
 153
 154 #endif
 155
 156 #else
 157 #define mono_llvm_load(bpath) TRUE
 158 #endif /* MONO_LLVM_LOADED */
 159