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