X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSystem%2FDynamicLibrary.cpp;h=3da50a28b656b97e12fe768c2d6ce3d20ee2a2f3;hb=87e0697a46ad214be0d8fce0955494f4085de95a;hp=157f1735f137878f9067fbb53ebe1b2a266fdbcd;hpb=28dabf743b4079d1a2fc9a937e23f70966ea7621;p=oota-llvm.git diff --git a/lib/System/DynamicLibrary.cpp b/lib/System/DynamicLibrary.cpp index 157f1735f13..3da50a28b65 100644 --- a/lib/System/DynamicLibrary.cpp +++ b/lib/System/DynamicLibrary.cpp @@ -1,134 +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 "ltdl.h" -#include +#include "llvm/System/Mutex.h" +#include "llvm/Config/config.h" +#include +#include +#include +#include + +// Collection of symbol name/value pairs to be searched prior to any libraries. +static std::map *ExplicitSymbols = 0; + +namespace { + +struct ExplicitSymbolsDeleter { + ~ExplicitSymbolsDeleter() { + if (ExplicitSymbols) + delete ExplicitSymbols; + } +}; + +} + +static ExplicitSymbolsDeleter Dummy; + +void llvm::sys::DynamicLibrary::AddSymbol(const char* symbolName, + void *symbolValue) { + if (ExplicitSymbols == 0) + ExplicitSymbols = new std::map(); + (*ExplicitSymbols)[symbolName] = symbolValue; +} + +#ifdef LLVM_ON_WIN32 + +#include "Win32/DynamicLibrary.inc" + +#else + +#if HAVE_DLFCN_H +#include using namespace llvm; using namespace llvm::sys; //===----------------------------------------------------------------------===// //=== WARNING: Implementation here must contain only TRULY operating system -//=== independent code. +//=== independent code. //===----------------------------------------------------------------------===// -static bool did_initialize_ltdl = false; +static SmartMutex HandlesMutex; +static std::vector *OpenedHandles = 0; + -static inline void check_ltdl_initialization() { - if (!did_initialize_ltdl) { - if (0 != lt_dlinit()) - throw std::string(lt_dlerror()); - did_initialize_ltdl = true; +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 Lock(HandlesMutex); + if (OpenedHandles == 0) + OpenedHandles = new std::vector(); + OpenedHandles->push_back(H); + return false; } +#else -static std::vector OpenedHandles; - -DynamicLibrary::DynamicLibrary() : handle(0) { - check_ltdl_initialization(); - - lt_dlhandle a_handle = lt_dlopen(0); +using namespace llvm; +using namespace llvm::sys; - if (a_handle == 0) - throw std::string("Can't open program as dynamic library"); - - handle = a_handle; - OpenedHandles.push_back(a_handle); +bool DynamicLibrary::LoadLibraryPermanently(const char *Filename, + std::string *ErrMsg) { + if (ErrMsg) *ErrMsg = "dlopen() not supported on this platform"; + return true; } +#endif -DynamicLibrary::DynamicLibrary(const char*filename) : handle(0) { - check_ltdl_initialization(); - - lt_dlhandle a_handle = lt_dlopen(filename); - - if (a_handle == 0) - a_handle = lt_dlopenext(filename); - - if (a_handle == 0) - throw std::string("Can't open :") + filename + ": " + lt_dlerror(); - - handle = a_handle; - OpenedHandles.push_back(a_handle); +namespace llvm { +void *SearchForAddressOfSpecialSymbol(const char* symbolName); } -DynamicLibrary::~DynamicLibrary() { - lt_dlhandle a_handle = (lt_dlhandle) handle; - if (a_handle) { - lt_dlclose(a_handle); +void* DynamicLibrary::SearchForAddressOfSymbol(const char* symbolName) { + // First check symbols added via AddSymbol(). + if (ExplicitSymbols) { + std::map::iterator I = + ExplicitSymbols->find(symbolName); + std::map::iterator E = ExplicitSymbols->end(); + + if (I != E) + return I->second; + } - for (std::vector::iterator I = OpenedHandles.begin(), - E = OpenedHandles.end(); I != E; ++I) { - if (*I == a_handle) { - // Note: don't use the swap/pop_back trick here. Order is important. - OpenedHandles.erase(I); +#if HAVE_DLFCN_H + // Now search the libraries. + SmartScopedLock Lock(HandlesMutex); + if (OpenedHandles) { + 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; } } } -} - -void DynamicLibrary::LoadLibraryPermanently(const char* filename) { - check_ltdl_initialization(); - lt_dlhandle a_handle = lt_dlopen(filename); - - if (a_handle == 0) - a_handle = lt_dlopenext(filename); - - if (a_handle == 0) - throw std::string("Can't open :") + filename + ": " + lt_dlerror(); +#endif - lt_dlmakeresident(a_handle); + if (void *Result = llvm::SearchForAddressOfSpecialSymbol(symbolName)) + return Result; - OpenedHandles.push_back(a_handle); -} +// This macro returns the address of a well-known, explicit symbol +#define EXPLICIT_SYMBOL(SYM) \ + if (!strcmp(symbolName, #SYM)) return &SYM -void* DynamicLibrary::SearchForAddressOfSymbol(const char* symbolName) { - check_ltdl_initialization(); - for (std::vector::iterator I = OpenedHandles.begin(), - E = OpenedHandles.end(); I != E; ++I) { - lt_ptr ptr = lt_dlsym(*I, symbolName); - if (ptr) - return ptr; +// 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); } - - // 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__ +#else + // For everything else, we want to check to make sure the symbol isn't defined + // as a macro before using EXPLICIT_SYMBOL. { - extern void *__ashldi3; if (Name == "__ashldi3") return &__ashldi3; - extern void *__ashrdi3; if (Name == "__ashrdi3") return &__ashrdi3; - extern void *__cmpdi2; if (Name == "__cmpdi2") return &__cmpdi2; - extern void *__divdi3; if (Name == "__divdi3") return &__divdi3; - extern void *__eprintf; if (Name == "__eprintf") return &__eprintf; - extern void *__fixdfdi; if (Name == "__fixdfdi") return &__fixdfdi; - extern void *__fixsfdi; if (Name == "__fixsfdi") return &__fixsfdi; - extern void *__fixunsdfdi; if (Name == "__fixunsdfdi") return &__fixunsdfdi; - extern void *__fixunssfdi; if (Name == "__fixunssfdi") return &__fixunssfdi; - extern void *__floatdidf; if (Name == "__floatdidf") return &__floatdidf; - extern void *__floatdisf; if (Name == "__floatdisf") return &__floatdisf; - extern void *__lshrdi3; if (Name == "__lshrdi3") return &__lshrdi3; - extern void *__moddi3; if (Name == "__moddi3") return &__moddi3; - extern void *__udivdi3; if (Name == "__udivdi3") return &__udivdi3; - extern void *__umoddi3; if (Name == "__umoddi3") return &__umoddi3; +#ifndef stdin + EXPLICIT_SYMBOL(stdin); +#endif +#ifndef stdout + EXPLICIT_SYMBOL(stdout); +#endif +#ifndef stderr + EXPLICIT_SYMBOL(stderr); +#endif } #endif +#undef EXPLICIT_SYMBOL return 0; } -void *DynamicLibrary::GetAddressOfSymbol(const char *symbolName) { - assert(handle != 0 && "Invalid DynamicLibrary handle"); - return lt_dlsym((lt_dlhandle) handle, symbolName); -} - +#endif // LLVM_ON_WIN32