X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSystem%2FDynamicLibrary.cpp;h=3da50a28b656b97e12fe768c2d6ce3d20ee2a2f3;hb=87e0697a46ad214be0d8fce0955494f4085de95a;hp=ca7bee661a661471ed393f9cf1f0b7b206fc696c;hpb=0de02a6ba9d9da6aac3c787ec4047068d8250aa9;p=oota-llvm.git

diff --git a/lib/System/DynamicLibrary.cpp b/lib/System/DynamicLibrary.cpp
index ca7bee661a6..3da50a28b65 100644
--- a/lib/System/DynamicLibrary.cpp
+++ b/lib/System/DynamicLibrary.cpp
@@ -1,78 +1,165 @@
 //===-- DynamicLibrary.cpp - Runtime link/load libraries --------*- C++ -*-===//
-// 
+//
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by Reid Spencer and is distributed under the 
-// University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
 //===----------------------------------------------------------------------===//
 //
 //  This header file implements the operating system DynamicLibrary concept.
 //
+// FIXME: This file leaks the ExplicitSymbols and OpenedHandles vector, and is
+// not thread safe!
+//
 //===----------------------------------------------------------------------===//
 
 #include "llvm/System/DynamicLibrary.h"
-#include "llvm/Config/dlfcn.h"
-#include <cassert>
+#include "llvm/System/Mutex.h"
+#include "llvm/Config/config.h"
+#include <cstdio>
+#include <cstring>
+#include <map>
+#include <vector>
 
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only TRULY operating system
-//===          independent code. 
-//===----------------------------------------------------------------------===//
+// Collection of symbol name/value pairs to be searched prior to any libraries.
+static std::map<std::string, void*> *ExplicitSymbols = 0;
 
-#ifdef HAVE_LTDL_H
+namespace {
 
-namespace llvm {
+struct ExplicitSymbolsDeleter {
+  ~ExplicitSymbolsDeleter() {
+    if (ExplicitSymbols)
+      delete ExplicitSymbols;
+  }
+};
 
-using namespace sys;
+}
 
-#ifdef HAVE_LT_DLOPEN
+static ExplicitSymbolsDeleter Dummy;
 
-DynamicLibrary::DynamicLibrary(const char*filename) : handle(0) {
-  if (0 != lt_dlinit())
-    throw std::string(lt_dlerror());
+void llvm::sys::DynamicLibrary::AddSymbol(const char* symbolName,
+                                          void *symbolValue) {
+  if (ExplicitSymbols == 0)
+    ExplicitSymbols = new std::map<std::string, void*>();
+  (*ExplicitSymbols)[symbolName] = symbolValue;
+}
 
-  handle = lt_dlopen(filename);
+#ifdef LLVM_ON_WIN32
 
-  if (handle == 0)
-    handle = lt_dlopenext(filename);
+#include "Win32/DynamicLibrary.inc"
 
-  if (handle == 0)
-    throw std::string("Can't open dynamic library:") + filename;
-}
+#else
 
-DynamicLibrary::~DynamicLibrary() {
-  if (handle)
-    lt_dlclose((lt_dlhandle)handle);
+#if HAVE_DLFCN_H
+#include <dlfcn.h>
+using namespace llvm;
+using namespace llvm::sys;
 
-  lt_dlexit();
-}
+//===----------------------------------------------------------------------===//
+//=== WARNING: Implementation here must contain only TRULY operating system
+//===          independent code.
+//===----------------------------------------------------------------------===//
 
-void *DynamicLibrary::GetAddressOfSymbol(const char *symbolName) {
-  assert(handle != 0 && "Invalid DynamicLibrary handle");
-  return lt_dlsym((lt_dlhandle) handle,symbolName);
+static SmartMutex<true> HandlesMutex;
+static std::vector<void *> *OpenedHandles = 0;
+
+
+bool DynamicLibrary::LoadLibraryPermanently(const char *Filename,
+                                            std::string *ErrMsg) {
+  void *H = dlopen(Filename, RTLD_LAZY|RTLD_GLOBAL);
+  if (H == 0) {
+    if (ErrMsg) *ErrMsg = dlerror();
+    return true;
+  }
+#ifdef __CYGWIN__
+  // Cygwin searches symbols only in the main
+  // with the handle of dlopen(NULL, RTLD_GLOBAL).
+  if (Filename == NULL)
+    H = RTLD_DEFAULT;
+#endif
+  SmartScopedLock<true> Lock(HandlesMutex);
+  if (OpenedHandles == 0)
+    OpenedHandles = new std::vector<void *>();
+  OpenedHandles->push_back(H);
+  return false;
 }
-
 #else
-DynamicLibrary::DynamicLibrary(const char*filename) : handle(0) {
-  assert(!"Have ltdl.h but not libltdl.a!");
-}
 
-DynamicLibrary::~DynamicLibrary() {
-  assert(!"Have ltdl.h but not libltdl.a!");
-}
+using namespace llvm;
+using namespace llvm::sys;
 
-void *DynamicLibrary::GetAddressOfSymbol(const char *symbolName) {
-  assert(!"Have ltdl.h but not libltdl.a!");
-  return 0;
+bool DynamicLibrary::LoadLibraryPermanently(const char *Filename,
+                                            std::string *ErrMsg) {
+  if (ErrMsg) *ErrMsg = "dlopen() not supported on this platform";
+  return true;
 }
+#endif
 
-#endif // HAVE_DLOPEN
+namespace llvm {
+void *SearchForAddressOfSpecialSymbol(const char* symbolName);
+}
 
-} // namespace llvm
+void* DynamicLibrary::SearchForAddressOfSymbol(const char* symbolName) {
+  // First check symbols added via AddSymbol().
+  if (ExplicitSymbols) {
+    std::map<std::string, void *>::iterator I =
+      ExplicitSymbols->find(symbolName);
+    std::map<std::string, void *>::iterator E = ExplicitSymbols->end();
+  
+    if (I != E)
+      return I->second;
+  }
+
+#if HAVE_DLFCN_H
+  // Now search the libraries.
+  SmartScopedLock<true> Lock(HandlesMutex);
+  if (OpenedHandles) {
+    for (std::vector<void *>::iterator I = OpenedHandles->begin(),
+         E = OpenedHandles->end(); I != E; ++I) {
+      //lt_ptr ptr = lt_dlsym(*I, symbolName);
+      void *ptr = dlsym(*I, symbolName);
+      if (ptr) {
+        return ptr;
+      }
+    }
+  }
+#endif
 
-#else // HAVE_LTDL_H
+  if (void *Result = llvm::SearchForAddressOfSpecialSymbol(symbolName))
+    return Result;
+
+// This macro returns the address of a well-known, explicit symbol
+#define EXPLICIT_SYMBOL(SYM) \
+   if (!strcmp(symbolName, #SYM)) return &SYM
+
+// On linux we have a weird situation. The stderr/out/in symbols are both
+// macros and global variables because of standards requirements. So, we 
+// boldly use the EXPLICIT_SYMBOL macro without checking for a #define first.
+#if defined(__linux__)
+  {
+    EXPLICIT_SYMBOL(stderr);
+    EXPLICIT_SYMBOL(stdout);
+    EXPLICIT_SYMBOL(stdin);
+  }
+#else
+  // For everything else, we want to check to make sure the symbol isn't defined
+  // as a macro before using EXPLICIT_SYMBOL.
+  {
+#ifndef stdin
+    EXPLICIT_SYMBOL(stdin);
+#endif
+#ifndef stdout
+    EXPLICIT_SYMBOL(stdout);
+#endif
+#ifndef stderr
+    EXPLICIT_SYMBOL(stderr);
+#endif
+  }
+#endif
+#undef EXPLICIT_SYMBOL
 
-#include "platform/DynamicLibrary.cpp"
+  return 0;
+}
 
-#endif
+#endif // LLVM_ON_WIN32