LLVM  6.0.0svn
DynamicLibrary.h
Go to the documentation of this file.
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.
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 
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.
96  /// SO_LoadedFirst - Search all loaded libraries, then as SO_Linker would.
98  /// SO_LoadedLast - Search as SO_Linker would, then loaded libraries.
99  /// Only useful to search if libraries with RTLD_LOCAL have been added.
101  /// SO_LoadOrder - Or this in to search libraries in the ordered loaded.
102  /// The default bahaviour is to search loaded libraries in reverse.
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
static void * SearchForAddressOfSymbol(const char *symbolName)
This function will search through all previously loaded dynamic libraries for the symbol symbolName...
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
DynamicLibrary(void *data=&Invalid)
static void * SearchForAddressOfSymbol(const std::string &symbolName)
Convenience function for C++ophiles.
void * getAddressOfSymbol(const char *symbolName)
Searches through the library for the symbol symbolName.
static bool LoadLibraryPermanently(const char *Filename, std::string *ErrMsg=nullptr)
This function permanently loads the dynamic library at the given path.
This class provides a portable interface to dynamic libraries which also might be known as shared lib...
static DynamicLibrary addPermanentLibrary(void *handle, std::string *errMsg=nullptr)
Registers an externally loaded library.
bool isValid() const
Returns true if the object refers to a valid library.
static DynamicLibrary getPermanentLibrary(const char *filename, std::string *errMsg=nullptr)
This function permanently loads the dynamic library at the given path.
SO_LoadedFirst - Search all loaded libraries, then as SO_Linker would.
SO_LoadedLast - Search as SO_Linker would, then loaded libraries.
StringRef filename(StringRef path, Style style=Style::native)
Get filename.
Definition: Path.cpp:575
SO_Linker - Search as a call to dlsym(dlopen(NULL)) would when DynamicLibrary::getPermanentLibrary(NU...
static void AddSymbol(StringRef symbolName, void *symbolValue)
This functions permanently adds the symbol symbolName with the value symbolValue. ...
static SearchOrdering SearchOrder
SO_LoadOrder - Or this in to search libraries in the ordered loaded.
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49