Home | History | Annotate | Download | only in Support
      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_SYSTEM_DYNAMICLIBRARY_H
     15 #define LLVM_SYSTEM_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     explicit DynamicLibrary(void *data = &Invalid) : Data(data) {}
     47   public:
     48     /// Returns true if the object refers to a valid library.
     49     bool isValid() { return Data != &Invalid; }
     50 
     51     /// Searches through the library for the symbol \p symbolName. If it is
     52     /// found, the address of that symbol is returned. If not, NULL is returned.
     53     /// Note that NULL will also be returned if the library failed to load.
     54     /// Use isValid() to distinguish these cases if it is important.
     55     /// Note that this will \e not search symbols explicitly registered by
     56     /// AddSymbol().
     57     void *getAddressOfSymbol(const char *symbolName);
     58 
     59     /// This function permanently loads the dynamic library at the given path.
     60     /// The library will only be unloaded when the program terminates.
     61     /// This returns a valid DynamicLibrary instance on success and an invalid
     62     /// instance on failure (see isValid()). \p *errMsg will only be modified
     63     /// if the library fails to load.
     64     ///
     65     /// It is safe to call this function multiple times for the same library.
     66     /// @brief Open a dynamic library permanently.
     67     static DynamicLibrary getPermanentLibrary(const char *filename,
     68                                               std::string *errMsg = 0);
     69 
     70     /// This function permanently loads the dynamic library at the given path.
     71     /// Use this instead of getPermanentLibrary() when you won't need to get
     72     /// symbols from the library itself.
     73     ///
     74     /// It is safe to call this function multiple times for the same library.
     75     static bool LoadLibraryPermanently(const char *Filename,
     76                                        std::string *ErrMsg = 0) {
     77       return !getPermanentLibrary(Filename, ErrMsg).isValid();
     78     }
     79 
     80     /// This function will search through all previously loaded dynamic
     81     /// libraries for the symbol \p symbolName. If it is found, the address of
     82     /// that symbol is returned. If not, null is returned. Note that this will
     83     /// search permanently loaded libraries (getPermanentLibrary()) as well
     84     /// as explicitly registered symbols (AddSymbol()).
     85     /// @throws std::string on error.
     86     /// @brief Search through libraries for address of a symbol
     87     static void *SearchForAddressOfSymbol(const char *symbolName);
     88 
     89     /// @brief Convenience function for C++ophiles.
     90     static void *SearchForAddressOfSymbol(const std::string &symbolName) {
     91       return SearchForAddressOfSymbol(symbolName.c_str());
     92     }
     93 
     94     /// This functions permanently adds the symbol \p symbolName with the
     95     /// value \p symbolValue.  These symbols are searched before any
     96     /// libraries.
     97     /// @brief Add searchable symbol/value pair.
     98     static void AddSymbol(StringRef symbolName, void *symbolValue);
     99   };
    100 
    101 } // End sys namespace
    102 } // End llvm namespace
    103 
    104 #endif // LLVM_SYSTEM_DYNAMIC_LIBRARY_H
    105