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 = arguments[0]->IsString()
+      ? AsForeignString(String::cast(arguments[0]))
+      : NULL;
+  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 = ForeignUtils::DirectoryName(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,
+                       ForeignUtils::kLibBundlePrefix, library,
+                       ForeignUtils::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 308 matching lines @@
   type* address = reinterpret_cast<type*>(AsForeignWord(arguments[0]));  \
   return process->ToInteger(*address);                                   \
 }                                                                        \
                                                                          \
 NATIVE(ForeignSet##suffix) {                                             \
   Object* value = arguments[1];                                          \
   if (!value->IsSmi() && !value->IsLargeInteger()) {                     \
     return Failure::wrong_argument_type();                               \
   }                                                                      \
   type* address = reinterpret_cast<type*>(AsForeignWord(arguments[0]));  \
-  *address = AsForeignWord(value);                                       \
+  if (value->IsSmi()) {                                                  \

[ricow1, 2015/07/02 16:01:57]

This already landed in another cl, I redid this here to pass my tests, but I did
not want to rebase before getting the review done (since the diff would include
a lot of stuff)

+    *address = Smi::cast(value)->value();                                \
+  } else {                                                               \
+    *address = LargeInteger::cast(value)->value();                       \
+  }                                                                      \
   return value;                                                          \
 }
 
 DEFINE_FOREIGN_ACCESSORS_INTEGER(Int8, int8)
 DEFINE_FOREIGN_ACCESSORS_INTEGER(Int16, int16)
 DEFINE_FOREIGN_ACCESSORS_INTEGER(Int32, int32)
 DEFINE_FOREIGN_ACCESSORS_INTEGER(Int64, int64)
 
 DEFINE_FOREIGN_ACCESSORS_INTEGER(Uint8, uint8)
 DEFINE_FOREIGN_ACCESSORS_INTEGER(Uint16, uint16)
@@ skipping 14 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