lib/Support/Windows/DynamicLibrary.inc

   1 //===- Win32/DynamicLibrary.cpp - Win32 DL Implementation -------*- 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 provides the Win32 specific implementation of DynamicLibrary.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "WindowsSupport.h"
  15
  16 #ifdef __MINGW32__
  17  #include <imagehlp.h>
  18 #else
  19  #include <dbghelp.h>
  20 #endif
  21
  22 #ifdef _MSC_VER
  23  #include <ntverp.h>
  24 #endif
  25
  26 namespace llvm {
  27 using namespace sys;
  28
  29 //===----------------------------------------------------------------------===//
  30 //=== WARNING: Implementation here must contain only Win32 specific code
  31 //===          and must not be UNIX code.
  32 //===----------------------------------------------------------------------===//
  33
  34 typedef BOOL (WINAPI *fpEnumerateLoadedModules)(HANDLE,PENUMLOADED_MODULES_CALLBACK64,PVOID);
  35 static fpEnumerateLoadedModules fEnumerateLoadedModules;
  36 static DenseSet<HMODULE> *OpenedHandles;
  37
  38 static bool loadDebugHelp(void) {
  39   HMODULE hLib = ::LoadLibraryW(L"Dbghelp.dll");
  40   if (hLib) {
  41     fEnumerateLoadedModules = (fpEnumerateLoadedModules)
  42       ::GetProcAddress(hLib, "EnumerateLoadedModules64");
  43   }
  44   return fEnumerateLoadedModules != 0;
  45 }
  46
  47 static BOOL CALLBACK
  48 ELM_Callback(WIN32_ELMCB_PCSTR ModuleName, DWORD64 ModuleBase,
  49              ULONG ModuleSize, PVOID UserContext) {
  50   OpenedHandles->insert((HMODULE)ModuleBase);
  51   return TRUE;
  52 }
  53
  54 DynamicLibrary DynamicLibrary::getPermanentLibrary(const char *filename,
  55                                                    std::string *errMsg) {
  56   SmartScopedLock<true> lock(*SymbolsMutex);
  57
  58   if (!filename) {
  59     // When no file is specified, enumerate all DLLs and EXEs in the process.
  60     if (OpenedHandles == 0)
  61       OpenedHandles = new DenseSet<HMODULE>();
  62
  63     if (!fEnumerateLoadedModules) {
  64       if (!loadDebugHelp()) {
  65         assert(false && "These APIs should always be available");
  66         return DynamicLibrary();
  67       }
  68     }
  69
  70     fEnumerateLoadedModules(GetCurrentProcess(), ELM_Callback, 0);
  71     // Dummy library that represents "search all handles".
  72     // This is mostly to ensure that the return value still shows up as "valid".
  73     return DynamicLibrary(&OpenedHandles);
  74   }
  75
  76   SmallVector<wchar_t, MAX_PATH> filenameUnicode;
  77   if (std::error_code ec = windows::UTF8ToUTF16(filename, filenameUnicode)) {
  78     SetLastError(ec.value());
  79     MakeErrMsg(errMsg, std::string(filename) + ": Can't convert to UTF-16");
  80     return DynamicLibrary();
  81   }
  82
  83   HMODULE a_handle = LoadLibraryW(filenameUnicode.data());
  84
  85   if (a_handle == 0) {
  86     MakeErrMsg(errMsg, std::string(filename) + ": Can't open");
  87     return DynamicLibrary();
  88   }
  89
  90   if (OpenedHandles == 0)
  91     OpenedHandles = new DenseSet<HMODULE>();
  92
  93   // If we've already loaded this library, FreeLibrary() the handle in order to
  94   // keep the internal refcount at +1.
  95   if (!OpenedHandles->insert(a_handle).second)
  96     FreeLibrary(a_handle);
  97
  98   return DynamicLibrary(a_handle);
  99 }
 100
 101 // Stack probing routines are in the support library (e.g. libgcc), but we don't
 102 // have dynamic linking on windows. Provide a hook.
 103 #define EXPLICIT_SYMBOL(SYM)                    \
 104   extern "C" { extern void *SYM; }
 105 #define EXPLICIT_SYMBOL2(SYMFROM, SYMTO) EXPLICIT_SYMBOL(SYMTO)
 106
 107 #ifdef _M_IX86
 108 // Win32 on x86 implements certain single-precision math functions as macros.
 109 // These functions are not exported by the DLL, but will still be needed
 110 // for symbol-resolution by the JIT loader. Therefore, this Support libray
 111 // provides helper functions with the same implementation.
 112
 113 #define INLINE_DEF_SYMBOL1(TYP, SYM)                                           \
 114   extern "C" TYP inline_##SYM(TYP _X) { return SYM(_X); }
 115 #define INLINE_DEF_SYMBOL2(TYP, SYM)                                           \
 116   extern "C" TYP inline_##SYM(TYP _X, TYP _Y) { return SYM(_X, _Y); }
 117 #endif
 118
 119 #include "explicit_symbols.inc"
 120
 121 #undef EXPLICIT_SYMBOL
 122 #undef EXPLICIT_SYMBOL2
 123 #undef INLINE_DEF_SYMBOL1
 124 #undef INLINE_DEF_SYMBOL2
 125
 126 void* DynamicLibrary::SearchForAddressOfSymbol(const char* symbolName) {
 127   SmartScopedLock<true> Lock(*SymbolsMutex);
 128
 129   // First check symbols added via AddSymbol().
 130   if (ExplicitSymbols.isConstructed()) {
 131     StringMap<void *>::iterator i = ExplicitSymbols->find(symbolName);
 132
 133     if (i != ExplicitSymbols->end())
 134       return i->second;
 135   }
 136
 137   // Now search the libraries.
 138   if (OpenedHandles) {
 139     for (DenseSet<HMODULE>::iterator I = OpenedHandles->begin(),
 140          E = OpenedHandles->end(); I != E; ++I) {
 141       FARPROC ptr = GetProcAddress((HMODULE)*I, symbolName);
 142       if (ptr) {
 143         return (void *)(intptr_t)ptr;
 144       }
 145     }
 146   }
 147
 148 #define EXPLICIT_SYMBOL(SYM)                                                   \
 149   if (!strcmp(symbolName, #SYM))                                               \
 150     return (void *)&SYM;
 151 #define EXPLICIT_SYMBOL2(SYMFROM, SYMTO)                                       \
 152   if (!strcmp(symbolName, #SYMFROM))                                           \
 153     return (void *)&SYMTO;
 154
 155 #ifdef _M_IX86
 156 #define INLINE_DEF_SYMBOL1(TYP, SYM)                                           \
 157   if (!strcmp(symbolName, #SYM))                                               \
 158     return (void *)&inline_##SYM;
 159 #define INLINE_DEF_SYMBOL2(TYP, SYM) INLINE_DEF_SYMBOL1(TYP, SYM)
 160 #endif
 161
 162   {
 163 #include "explicit_symbols.inc"
 164   }
 165
 166 #undef EXPLICIT_SYMBOL
 167 #undef EXPLICIT_SYMBOL2
 168 #undef INLINE_DEF_SYMBOL1
 169 #undef INLINE_DEF_SYMBOL2
 170
 171   return 0;
 172 }
 173
 174 void *DynamicLibrary::getAddressOfSymbol(const char *symbolName) {
 175   if (!isValid())
 176     return NULL;
 177   if (Data == &OpenedHandles)
 178     return SearchForAddressOfSymbol(symbolName);
 179   return (void *)(intptr_t)GetProcAddress((HMODULE)Data, symbolName);
 180 }
 181
 182 }