Line data Source code
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 4 : 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 : /// 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 454 : 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 : /// Search through libraries for address of a symbol
114 : static void *SearchForAddressOfSymbol(const char *symbolName);
115 :
116 : /// Convenience function for C++ophiles.
117 : static void *SearchForAddressOfSymbol(const std::string &symbolName) {
118 28 : 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 : /// 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
|
