← Back to branch summary

~ubuntu-branches/ubuntu/feisty/clamav/feisty

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/lib/System/Win32/DynamicLibrary.inc

  • Committer: Bazaar Package Importer
  • Author(s): Kees Cook
  • Date: 2007-02-20 10:33:44 UTC
  • mto: This revision was merged to the branch mainline in revision 16.
  • Revision ID: james.westby@ubuntu.com-20070220103344-zgcu2psnx9d98fpa
Tags: upstream-0.90
Import upstream version 0.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/lib/System/Win32/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 "Win32.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 std::vector<HMODULE> OpenedHandles;
43
 
 
44
 
#ifdef _WIN64
45
 
  typedef DWORD64 ModuleBaseType;
46
 
#else
47
 
  typedef ULONG ModuleBaseType;
48
 
#endif
49
 
 
50
 
extern "C" {
51
 
// Use old callback if:
52
 
//  - Not using Visual Studio
53
 
//  - Visual Studio 2005 or earlier but only if we are not using the Windows SDK 
54
 
//    or Windows SDK version is older than 6.0
55
 
// Use new callback if:
56
 
//  - Newer Visual Studio (comes with newer SDK).
57
 
//  - Visual Studio 2005 with Windows SDK 6.0+
58
 
#if !defined(_MSC_VER) || _MSC_VER < 1500 && (!defined(VER_PRODUCTBUILD) || VER_PRODUCTBUILD < 6000)
59
 
  static BOOL CALLBACK ELM_Callback(PSTR  ModuleName,
60
 
                                    ModuleBaseType ModuleBase,
61
 
                                    ULONG ModuleSize,
62
 
                                    PVOID UserContext)
63
 
#else
64
 
  static BOOL CALLBACK ELM_Callback(PCSTR  ModuleName,
65
 
                                    ModuleBaseType ModuleBase,
66
 
                                    ULONG ModuleSize,
67
 
                                    PVOID UserContext)
68
 
#endif
69
 
  {
70
 
    // Ignore VC++ runtimes prior to 7.1.  Somehow some of them get loaded
71
 
    // into the process.
72
 
    if (stricmp(ModuleName, "msvci70") != 0 &&
73
 
        stricmp(ModuleName, "msvcirt") != 0 &&
74
 
        stricmp(ModuleName, "msvcp50") != 0 &&
75
 
        stricmp(ModuleName, "msvcp60") != 0 &&
76
 
        stricmp(ModuleName, "msvcp70") != 0 &&
77
 
        stricmp(ModuleName, "msvcr70") != 0 &&
78
 
#ifndef __MINGW32__
79
 
        // Mingw32 uses msvcrt.dll by default. Don't ignore it.
80
 
        // Otherwise, user should be aware, what he's doing :)
81
 
        stricmp(ModuleName, "msvcrt") != 0 &&
82
 
#endif
83
 
        stricmp(ModuleName, "msvcrt20") != 0 &&
84
 
        stricmp(ModuleName, "msvcrt40") != 0) {
85
 
      OpenedHandles.push_back((HMODULE)ModuleBase);
86
 
    }
87
 
    return TRUE;
88
 
  }
89
 
}
90
 
 
91
 
bool DynamicLibrary::LoadLibraryPermanently(const char *filename,
92
 
                                            std::string *ErrMsg) {                                            
93
 
  if (filename) {
94
 
    HMODULE a_handle = LoadLibrary(filename);
95
 
 
96
 
    if (a_handle == 0)
97
 
      return MakeErrMsg(ErrMsg, std::string(filename) + ": Can't open : ");
98
 
 
99
 
    OpenedHandles.push_back(a_handle);
100
 
  } else {
101
 
    // When no file is specified, enumerate all DLLs and EXEs in the
102
 
    // process.
103
 
    EnumerateLoadedModules(GetCurrentProcess(), ELM_Callback, 0);
104
 
  }
105
 
 
106
 
  // Because we don't remember the handle, we will never free it; hence,
107
 
  // it is loaded permanently.
108
 
  return false;
109
 
}
110
 
 
111
 
// Stack probing routines are in the support library (e.g. libgcc), but we don't
112
 
// have dynamic linking on windows. Provide a hook.
113
 
#if defined(__MINGW32__) || defined (_MSC_VER)
114
 
  #define EXPLICIT_SYMBOL(SYM)                    \
115
 
    if (!strcmp(symbolName, #SYM)) return (void*)&SYM
116
 
  #define EXPLICIT_SYMBOL2(SYMFROM, SYMTO)        \
117
 
    if (!strcmp(symbolName, #SYMFROM)) return (void*)&SYMTO
118
 
  #define EXPLICIT_SYMBOL_DEF(SYM)                \
119
 
    extern "C" { extern void *SYM; }
120
 
 
121
 
  #if defined(__MINGW32__)
122
 
    EXPLICIT_SYMBOL_DEF(_alloca)
123
 
    EXPLICIT_SYMBOL_DEF(__main)
124
 
    EXPLICIT_SYMBOL_DEF(__ashldi3)
125
 
    EXPLICIT_SYMBOL_DEF(__ashrdi3)
126
 
    EXPLICIT_SYMBOL_DEF(__cmpdi2)
127
 
    EXPLICIT_SYMBOL_DEF(__divdi3)
128
 
    EXPLICIT_SYMBOL_DEF(__fixdfdi)
129
 
    EXPLICIT_SYMBOL_DEF(__fixsfdi)
130
 
    EXPLICIT_SYMBOL_DEF(__fixunsdfdi)
131
 
    EXPLICIT_SYMBOL_DEF(__fixunssfdi)
132
 
    EXPLICIT_SYMBOL_DEF(__floatdidf)
133
 
    EXPLICIT_SYMBOL_DEF(__floatdisf)
134
 
    EXPLICIT_SYMBOL_DEF(__lshrdi3)
135
 
    EXPLICIT_SYMBOL_DEF(__moddi3)
136
 
    EXPLICIT_SYMBOL_DEF(__udivdi3)
137
 
    EXPLICIT_SYMBOL_DEF(__umoddi3)
138
 
  #elif defined(_MSC_VER)
139
 
    EXPLICIT_SYMBOL_DEF(_alloca_probe)
140
 
  #endif
141
 
#endif
142
 
 
143
 
void* DynamicLibrary::SearchForAddressOfSymbol(const char* symbolName) {
144
 
  // First check symbols added via AddSymbol().
145
 
  if (ExplicitSymbols) {
146
 
    std::map<std::string, void *>::iterator I = 
147
 
      ExplicitSymbols->find(symbolName);
148
 
    std::map<std::string, void *>::iterator E = ExplicitSymbols->end();
149
 
    if (I != E)
150
 
      return I->second;
151
 
  }
152
 
 
153
 
  // Now search the libraries.
154
 
  for (std::vector<HMODULE>::iterator I = OpenedHandles.begin(),
155
 
       E = OpenedHandles.end(); I != E; ++I) {
156
 
    FARPROC ptr = GetProcAddress((HMODULE)*I, symbolName);
157
 
    if (ptr) {
158
 
      return (void *) ptr;
159
 
    }
160
 
  }
161
 
 
162
 
#if defined(__MINGW32__)
163
 
  {
164
 
    EXPLICIT_SYMBOL(_alloca);
165
 
    EXPLICIT_SYMBOL(__main);
166
 
    EXPLICIT_SYMBOL(__ashldi3);
167
 
    EXPLICIT_SYMBOL(__ashrdi3);
168
 
    EXPLICIT_SYMBOL(__cmpdi2);
169
 
    EXPLICIT_SYMBOL(__divdi3);
170
 
    EXPLICIT_SYMBOL(__fixdfdi);
171
 
    EXPLICIT_SYMBOL(__fixsfdi);
172
 
    EXPLICIT_SYMBOL(__fixunsdfdi);
173
 
    EXPLICIT_SYMBOL(__fixunssfdi);
174
 
    EXPLICIT_SYMBOL(__floatdidf);
175
 
    EXPLICIT_SYMBOL(__floatdisf);
176
 
    EXPLICIT_SYMBOL(__lshrdi3);
177
 
    EXPLICIT_SYMBOL(__moddi3);
178
 
    EXPLICIT_SYMBOL(__udivdi3);
179
 
    EXPLICIT_SYMBOL(__umoddi3);
180
 
 
181
 
    EXPLICIT_SYMBOL2(alloca, _alloca);
182
 
#undef EXPLICIT_SYMBOL
183
 
#undef EXPLICIT_SYMBOL2
184
 
#undef EXPLICIT_SYMBOL_DEF
185
 
  }
186
 
#elif defined(_MSC_VER)
187
 
  {
188
 
    EXPLICIT_SYMBOL2(alloca, _alloca_probe);
189
 
    EXPLICIT_SYMBOL2(_alloca, _alloca_probe);
190
 
#undef EXPLICIT_SYMBOL
191
 
#undef EXPLICIT_SYMBOL2
192
 
#undef EXPLICIT_SYMBOL_DEF
193
 
  }
194
 
#endif
195
 
 
196
 
  return 0;
197
 
}
198
 
 
199
 
}
200