X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSystem%2FDynamicLibrary.cpp;h=3bf172c22b3f376302cc30365fcc088f5a8376fb;hb=0001e56f15215ae4bc5fffb82eec5c4828b888f0;hp=477e3051c032c713a70c41453b1ab9c39226b4eb;hpb=441cc2ab01685fa9f03fbadbc83716dcdbfdc492;p=oota-llvm.git diff --git a/lib/System/DynamicLibrary.cpp b/lib/System/DynamicLibrary.cpp index 477e3051c03..3bf172c22b3 100644 --- a/lib/System/DynamicLibrary.cpp +++ b/lib/System/DynamicLibrary.cpp @@ -1,10 +1,10 @@ //===-- 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. @@ -12,77 +12,154 @@ //===----------------------------------------------------------------------===// #include "llvm/System/DynamicLibrary.h" -#include "llvm/Config/dlfcn.h" -#include - -//===----------------------------------------------------------------------===// -//=== WARNING: Implementation here must contain only TRULY operating system -//=== independent code. -//===----------------------------------------------------------------------===// - -#ifdef HAVE_LTDL_H - -namespace llvm { - -using namespace sys; - -#ifdef HAVE_LT_DLOPEN - -DynamicLibrary::DynamicLibrary() : handle(0) { - if (0 != lt_dlinit()) - throw std::string(lt_dlerror()); - - handle = lt_dlopen(0); +#include "llvm/Config/config.h" +#include +#include +#include + +// Collection of symbol name/value pairs to be searched prior to any libraries. +std::map &g_symbols() { + static std::map symbols; + return symbols; +} - if (handle == 0) - throw std::string("Can't open program as dynamic library"); +void llvm::sys::DynamicLibrary::AddSymbol(const char* symbolName, + void *symbolValue) { + g_symbols()[symbolName] = symbolValue; } -DynamicLibrary::DynamicLibrary(const char*filename) : handle(0) { - if (0 != lt_dlinit()) - throw std::string(lt_dlerror()); +// It is not possible to use ltdl.c on VC++ builds as the terms of its LGPL +// license and special exception would cause all of LLVM to be placed under +// the LGPL. This is because the exception applies only when libtool is +// used, and obviously libtool is not used with Visual Studio. An entirely +// separate implementation is provided in win32/DynamicLibrary.cpp. - 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); +//#include "ltdl.h" +#include +#include +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 std::vector OpenedHandles; +static std::vector OpenedHandles; -#else -DynamicLibrary::DynamicLibrary(const char*filename) : handle(0) { - assert(!"Have ltdl.h but not libltdl.a!"); -} +DynamicLibrary::DynamicLibrary() {} DynamicLibrary::~DynamicLibrary() { - assert(!"Have ltdl.h but not libltdl.a!"); + while(!OpenedHandles.empty()) { + void *H = OpenedHandles.back(); OpenedHandles.pop_back(); + dlclose(H); + } } -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) { + void *H = dlopen(Filename, RTLD_LAZY|RTLD_GLOBAL); + if (H == 0) { + if (ErrMsg) + *ErrMsg = dlerror(); + return true; + } + OpenedHandles.push_back(H); + return false; } -#endif // HAVE_DLOPEN +void* DynamicLibrary::SearchForAddressOfSymbol(const char* symbolName) { + // check_ltdl_initialization(); + + // First check symbols added via AddSymbol(). + std::map::iterator I = g_symbols().find(symbolName); + if (I != g_symbols().end()) + return I->second; + + // Now search the libraries. + for (std::vector::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; + } + +#define EXPLICIT_SYMBOL(SYM) \ + extern void *SYM; if (!strcmp(symbolName, #SYM)) return &SYM + + // If this is darwin, it has some funky issues, try to solve them here. Some + // important symbols are marked 'private external' which doesn't allow + // SearchForAddressOfSymbol to find them. As such, we special case them here, + // there is only a small handful of them. + +#ifdef __APPLE__ + { + EXPLICIT_SYMBOL(__ashldi3); + EXPLICIT_SYMBOL(__ashrdi3); + EXPLICIT_SYMBOL(__cmpdi2); + EXPLICIT_SYMBOL(__divdi3); + EXPLICIT_SYMBOL(__eprintf); + EXPLICIT_SYMBOL(__fixdfdi); + EXPLICIT_SYMBOL(__fixsfdi); + EXPLICIT_SYMBOL(__fixunsdfdi); + EXPLICIT_SYMBOL(__fixunssfdi); + EXPLICIT_SYMBOL(__floatdidf); + EXPLICIT_SYMBOL(__floatdisf); + EXPLICIT_SYMBOL(__lshrdi3); + EXPLICIT_SYMBOL(__moddi3); + EXPLICIT_SYMBOL(__udivdi3); + EXPLICIT_SYMBOL(__umoddi3); + } +#endif -} // namespace llvm +#ifdef __CYGWIN__ + { + EXPLICIT_SYMBOL(_alloca); + EXPLICIT_SYMBOL(__main); + } +#endif -#else // HAVE_LTDL_H +#undef EXPLICIT_SYMBOL + +// 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