X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSystem%2FDynamicLibrary.cpp;h=572ba496e191451d201a7c9cd3195911f8909fab;hb=629c1a3f78494d0dd769fe82bd2bd17df0555843;hp=d4bf0f797fc4472b543a012747b8bc8a8dbb5751;hpb=81e3954dc9dc3416c24cb82a0fd6b72576baede8;p=oota-llvm.git diff --git a/lib/System/DynamicLibrary.cpp b/lib/System/DynamicLibrary.cpp index d4bf0f797fc..572ba496e19 100644 --- a/lib/System/DynamicLibrary.cpp +++ b/lib/System/DynamicLibrary.cpp @@ -2,8 +2,8 @@ // // 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. // //===----------------------------------------------------------------------===// // @@ -13,6 +13,7 @@ #include "llvm/System/DynamicLibrary.h" #include "llvm/Config/config.h" +#include #include // Collection of symbol name/value pairs to be searched prior to any libraries. @@ -35,7 +36,8 @@ void llvm::sys::DynamicLibrary::AddSymbol(const char* symbolName, #else -#include "ltdl.h" +//#include "ltdl.h" +#include #include using namespace llvm; using namespace llvm::sys; @@ -45,84 +47,32 @@ using namespace llvm::sys; //=== independent code. //===----------------------------------------------------------------------===// -static inline void check_ltdl_initialization() { - static bool did_initialize_ltdl = false; - if (!did_initialize_ltdl) { - int Err = lt_dlinit(); - assert(0 == Err && "Can't init the ltdl library"); - did_initialize_ltdl = true; - } -} - -static std::vector OpenedHandles; - -DynamicLibrary::DynamicLibrary() : handle(0) { - check_ltdl_initialization(); - - lt_dlhandle a_handle = lt_dlopen(0); - - assert(a_handle == 0 || "Can't open program as dynamic library"); - - handle = a_handle; - OpenedHandles.push_back(a_handle); -} - -/* -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); +//static std::vector OpenedHandles; +static std::vector OpenedHandles; - if (a_handle == 0) - throw std::string("Can't open :") + filename + ": " + lt_dlerror(); - - handle = a_handle; - OpenedHandles.push_back(a_handle); -} -*/ +DynamicLibrary::DynamicLibrary() {} DynamicLibrary::~DynamicLibrary() { - lt_dlhandle a_handle = (lt_dlhandle) handle; - if (a_handle) { - lt_dlclose(a_handle); - - 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); - return; - } - } + while(!OpenedHandles.empty()) { + void *H = OpenedHandles.back(); OpenedHandles.pop_back(); + dlclose(H); } } bool DynamicLibrary::LoadLibraryPermanently(const char *Filename, std::string *ErrMsg) { - check_ltdl_initialization(); - lt_dlhandle a_handle = lt_dlopen(Filename); - - if (a_handle == 0) - a_handle = lt_dlopenext(Filename); - - if (a_handle == 0) { + void *H = dlopen(Filename, RTLD_LAZY); + if (H == 0) { if (ErrMsg) - *ErrMsg = std::string("Can't open :") + - (Filename ? Filename : "") + ": " + lt_dlerror(); + *ErrMsg = dlerror(); return true; } - - lt_dlmakeresident(a_handle); - - OpenedHandles.push_back(a_handle); + OpenedHandles.push_back(H); return false; } void* DynamicLibrary::SearchForAddressOfSymbol(const char* symbolName) { - check_ltdl_initialization(); + // check_ltdl_initialization(); // First check symbols added via AddSymbol(). std::map::iterator I = g_symbols.find(symbolName); @@ -130,21 +80,23 @@ void* DynamicLibrary::SearchForAddressOfSymbol(const char* symbolName) { return I->second; // Now search the libraries. - for (std::vector::iterator I = OpenedHandles.begin(), + for (std::vector::iterator I = OpenedHandles.begin(), E = OpenedHandles.end(); I != E; ++I) { - lt_ptr ptr = lt_dlsym(*I, symbolName); + //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__ -#define EXPLICIT_SYMBOL(SYM) \ - extern void *SYM; if (!strcmp(symbolName, #SYM)) return &SYM { EXPLICIT_SYMBOL(__ashldi3); EXPLICIT_SYMBOL(__ashrdi3); @@ -162,13 +114,33 @@ void* DynamicLibrary::SearchForAddressOfSymbol(const char* symbolName) { EXPLICIT_SYMBOL(__udivdi3); EXPLICIT_SYMBOL(__umoddi3); } -#undef EXPLICIT_SYMBOL #endif + +#ifdef __CYGWIN__ + { + EXPLICIT_SYMBOL(_alloca); + EXPLICIT_SYMBOL(__main); + } +#endif + +#undef EXPLICIT_SYMBOL + +// This macro returns the address of a well-known, explicit symbol #define EXPLICIT_SYMBOL(SYM) \ if (!strcmp(symbolName, #SYM)) return &SYM - // Try a few well known symbols just to give lli a shot at working. - // Note that on some systems stdin, etc. are macros so we have to - // avoid attempting to take the address of a macro :) + +// 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); @@ -180,16 +152,10 @@ void* DynamicLibrary::SearchForAddressOfSymbol(const char* symbolName) { 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 - -DEFINING_FILE_FOR(SystemDynamicLibrary)