1 //===-- llvm/Support/DynamicLibrary.h - Portable Dynamic Library -*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file declares the sys::DynamicLibrary class. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_SUPPORT_DYNAMICLIBRARY_H 15 #define LLVM_SUPPORT_DYNAMICLIBRARY_H 16 17 #include <string> 18 19 namespace llvm { 20 21 class StringRef; 22 23 namespace sys { 24 25 /// This class provides a portable interface to dynamic libraries which also 26 /// might be known as shared libraries, shared objects, dynamic shared 27 /// objects, or dynamic link libraries. Regardless of the terminology or the 28 /// operating system interface, this class provides a portable interface that 29 /// allows dynamic libraries to be loaded and searched for externally 30 /// defined symbols. This is typically used to provide "plug-in" support. 31 /// It also allows for symbols to be defined which don't live in any library, 32 /// but rather the main program itself, useful on Windows where the main 33 /// executable cannot be searched. 34 /// 35 /// Note: there is currently no interface for temporarily loading a library, 36 /// or for unloading libraries when the LLVM library is unloaded. 37 class DynamicLibrary { 38 // Placeholder whose address represents an invalid library. 39 // We use this instead of NULL or a pointer-int pair because the OS library 40 // might define 0 or 1 to be "special" handles, such as "search all". 41 static char Invalid; 42 43 // Opaque data used to interface with OS-specific dynamic library handling. 44 void *Data; 45 46 public: 47 explicit DynamicLibrary(void *data = &Invalid) : Data(data) {} 48 49 /// Returns true if the object refers to a valid library. 50 bool isValid() const { return Data != &Invalid; } 51 52 /// Searches through the library for the symbol \p symbolName. If it is 53 /// found, the address of that symbol is returned. If not, NULL is returned. 54 /// Note that NULL will also be returned if the library failed to load. 55 /// Use isValid() to distinguish these cases if it is important. 56 /// Note that this will \e not search symbols explicitly registered by 57 /// AddSymbol(). 58 void *getAddressOfSymbol(const char *symbolName); 59 60 /// This function permanently loads the dynamic library at the given path. 61 /// The library will only be unloaded when llvm_shutdown() is called. 62 /// This returns a valid DynamicLibrary instance on success and an invalid 63 /// instance on failure (see isValid()). \p *errMsg will only be modified 64 /// if the library fails to load. 65 /// 66 /// It is safe to call this function multiple times for the same library. 67 /// @brief Open a dynamic library permanently. 68 static DynamicLibrary getPermanentLibrary(const char *filename, 69 std::string *errMsg = nullptr); 70 71 /// Registers an externally loaded library. The library will be unloaded 72 /// when the program terminates. 73 /// 74 /// It is safe to call this function multiple times for the same library, 75 /// though ownership is only taken if there was no error. 76 /// 77 /// \returns An empty \p DynamicLibrary if the library was already loaded. 78 static DynamicLibrary addPermanentLibrary(void *handle, 79 std::string *errMsg = nullptr); 80 81 /// This function permanently loads the dynamic library at the given path. 82 /// Use this instead of getPermanentLibrary() when you won't need to get 83 /// symbols from the library itself. 84 /// 85 /// It is safe to call this function multiple times for the same library. 86 static bool LoadLibraryPermanently(const char *Filename, 87 std::string *ErrMsg = nullptr) { 88 return !getPermanentLibrary(Filename, ErrMsg).isValid(); 89 } 90 91 enum SearchOrdering { 92 /// SO_Linker - Search as a call to dlsym(dlopen(NULL)) would when 93 /// DynamicLibrary::getPermanentLibrary(NULL) has been called or 94 /// search the list of explcitly loaded symbols if not. 95 SO_Linker, 96 /// SO_LoadedFirst - Search all loaded libraries, then as SO_Linker would. 97 SO_LoadedFirst, 98 /// SO_LoadedLast - Search as SO_Linker would, then loaded libraries. 99 /// Only useful to search if libraries with RTLD_LOCAL have been added. 100 SO_LoadedLast, 101 /// SO_LoadOrder - Or this in to search libraries in the ordered loaded. 102 /// The default bahaviour is to search loaded libraries in reverse. 103 SO_LoadOrder = 4 104 }; 105 static SearchOrdering SearchOrder; // = SO_Linker 106 107 /// This function will search through all previously loaded dynamic 108 /// libraries for the symbol \p symbolName. If it is found, the address of 109 /// that symbol is returned. If not, null is returned. Note that this will 110 /// search permanently loaded libraries (getPermanentLibrary()) as well 111 /// as explicitly registered symbols (AddSymbol()). 112 /// @throws std::string on error. 113 /// @brief Search through libraries for address of a symbol 114 static void *SearchForAddressOfSymbol(const char *symbolName); 115 116 /// @brief Convenience function for C++ophiles. 117 static void *SearchForAddressOfSymbol(const std::string &symbolName) { 118 return SearchForAddressOfSymbol(symbolName.c_str()); 119 } 120 121 /// This functions permanently adds the symbol \p symbolName with the 122 /// value \p symbolValue. These symbols are searched before any 123 /// libraries. 124 /// @brief Add searchable symbol/value pair. 125 static void AddSymbol(StringRef symbolName, void *symbolValue); 126 127 class HandleSet; 128 }; 129 130 } // End sys namespace 131 } // End llvm namespace 132 133 #endif 134
