Work in progres, please take a look and give early feedback if this is the way we want to structure…

src/vm/ffi.cc

 // Copyright (c) 2015, the Fletch project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE.md file.
 
 #include "src/vm/ffi.h"
 
 #include <dlfcn.h>
 #include <errno.h>
+#include <sys/param.h>
 
 #include "src/shared/asan_helper.h"
+#include "src/shared/platform.h"
 #include "src/vm/natives.h"
 #include "src/vm/object.h"
 #include "src/vm/port.h"
 #include "src/vm/process.h"
 
 namespace fletch {
 
 class DefaultLibraryEntry {
  public:
   DefaultLibraryEntry(char* library, DefaultLibraryEntry* next)
@@ skipping 46 matching lines @@
   ScopedLock lock(mutex_);
   for (DefaultLibraryEntry* current = libraries_;
        current != NULL;
        current = current->next()) {
     void* result = PerformForeignLookup(current->library(), symbol);
     if (result != NULL) return result;
   }
   return NULL;
 }
 
+NATIVE(ForeignLibraryLookup) {
+  char* library = AsForeignString(String::cast(arguments[0]));
+  void* result = dlopen(library, RTLD_LOCAL | RTLD_LAZY);
+  if (result == NULL) {
+    fprintf(stderr, "Failed libary lookup(%s): %s\n", library, dlerror());
+  }
+  free(library);
+  return result != NULL
+      ? process->ToInteger(reinterpret_cast<intptr_t>(result))
+      : Failure::index_out_of_bounds();
+}
+
+NATIVE(ForeignLibraryGetFunction) {
+  word address = AsForeignWord(arguments[0]);
+  void* handle = reinterpret_cast<void*>(address);
+  char* name = AsForeignString(String::cast(arguments[1]));
+  if (handle == NULL) handle = dlopen(NULL, RTLD_LOCAL | RTLD_LAZY);
+  void* result = dlsym(handle, name);
+  free(name);
+  return result != NULL
+      ? process->ToInteger(reinterpret_cast<intptr_t>(result))
+      : Failure::index_out_of_bounds();
+}
+
+NATIVE(ForeignLibraryBundlePath) {
+  char* library = AsForeignString(String::cast(arguments[0]));
+  char executable[MAXPATHLEN + 1];
+  GetPathOfExecutable(executable, sizeof(executable));
+  char* directory = FFIUtils::DirName(executable);
+  // dirname on linux may mess with the content of the buffer, so we use a fresh
+  // buffer for the result. If anybody cares this can be optimized by manually
+  // writing the strings other than dirname to the executable buffer.
+  char result[MAXPATHLEN + 1];
+  int wrote = snprintf(result, MAXPATHLEN + 1, "%s%s%s%s", directory,
+                       FFIUtils::kLibBundlePrefix, library,
+                       FFIUtils::kLibBundlePostfix);
+  if (wrote > MAXPATHLEN) {
+    return Failure::index_out_of_bounds();
+  }
+  free(library);
+  return process->NewStringFromAscii(List<const char>(result, strlen(result)));
+}
+
+NATIVE(ForeignLibraryClose) {
+  word address = AsForeignWord(arguments[0]);
+  void* handle = reinterpret_cast<void*>(address);
+  if (dlclose(handle) != 0)  {
+    fprintf(stderr, "Failed to close handle: %s\n", dlerror());
+    return Failure::index_out_of_bounds();
+  }
+  return NULL;
+}
+
 NATIVE(ForeignLookup) {
   char* library = arguments[1]->IsString()
       ? AsForeignString(String::cast(arguments[1]))
       : NULL;
 
   char* name = AsForeignString(String::cast(arguments[0]));
   void* result = PerformForeignLookup(library, name);
 
   if (result == NULL) {
     result = ForeignFunctionInterface::LookupInDefaultLibraries(name);
@@ skipping 343 matching lines @@
   *address = Double::cast(value)->value();                               \
   return value;                                                          \
 }
 
 DEFINE_FOREIGN_ACCESSORS_DOUBLE(Float32, float)
 DEFINE_FOREIGN_ACCESSORS_DOUBLE(Float64, double)
 
 #undef DEFINE_FOREIGN_ACCESSORS
 
 }  // namespace fletch