1 //===--- ToolChains.cpp - ToolChain Implementations -----------------------===//
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 #include "ToolChains.h"
11 #include "clang/Basic/CharInfo.h"
12 #include "clang/Basic/Version.h"
13 #include "clang/Driver/Compilation.h"
14 #include "clang/Driver/Driver.h"
15 #include "clang/Driver/DriverDiagnostic.h"
16 #include "clang/Driver/Options.h"
17 #include "llvm/Option/Arg.h"
18 #include "llvm/Option/ArgList.h"
19 #include "llvm/Support/ErrorHandling.h"
20 #include "llvm/Support/Path.h"
21
22 // Include the necessary headers to interface with the Windows registry and
23 // environment.
24 #ifdef _MSC_VER
25 #define WIN32_LEAN_AND_MEAN
26 #define NOGDI
27 #define NOMINMAX
28 #include <Windows.h>
29 #endif
30
31 using namespace clang::driver;
32 using namespace clang::driver::toolchains;
33 using namespace clang;
34 using namespace llvm::opt;
35
Windows(const Driver & D,const llvm::Triple & Triple,const ArgList & Args)36 Windows::Windows(const Driver &D, const llvm::Triple& Triple,
37 const ArgList &Args)
38 : ToolChain(D, Triple, Args) {
39 }
40
buildLinker() const41 Tool *Windows::buildLinker() const {
42 return new tools::visualstudio::Link(*this);
43 }
44
buildAssembler() const45 Tool *Windows::buildAssembler() const {
46 if (getTriple().getEnvironment() == llvm::Triple::MachO)
47 return new tools::darwin::Assemble(*this);
48 getDriver().Diag(clang::diag::err_no_external_assembler);
49 return NULL;
50 }
51
IsIntegratedAssemblerDefault() const52 bool Windows::IsIntegratedAssemblerDefault() const {
53 return true;
54 }
55
IsUnwindTablesDefault() const56 bool Windows::IsUnwindTablesDefault() const {
57 return getArch() == llvm::Triple::x86_64;
58 }
59
isPICDefault() const60 bool Windows::isPICDefault() const {
61 return getArch() == llvm::Triple::x86_64;
62 }
63
isPIEDefault() const64 bool Windows::isPIEDefault() const {
65 return false;
66 }
67
isPICDefaultForced() const68 bool Windows::isPICDefaultForced() const {
69 return getArch() == llvm::Triple::x86_64;
70 }
71
72 // FIXME: This probably should goto to some platform utils place.
73 #ifdef _MSC_VER
74
75 /// \brief Read registry string.
76 /// This also supports a means to look for high-versioned keys by use
77 /// of a $VERSION placeholder in the key path.
78 /// $VERSION in the key path is a placeholder for the version number,
79 /// causing the highest value path to be searched for and used.
80 /// I.e. "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\$VERSION".
81 /// There can be additional characters in the component. Only the numberic
82 /// characters are compared.
getSystemRegistryString(const char * keyPath,const char * valueName,char * value,size_t maxLength)83 static bool getSystemRegistryString(const char *keyPath, const char *valueName,
84 char *value, size_t maxLength) {
85 HKEY hRootKey = NULL;
86 HKEY hKey = NULL;
87 const char* subKey = NULL;
88 DWORD valueType;
89 DWORD valueSize = maxLength - 1;
90 long lResult;
91 bool returnValue = false;
92
93 if (strncmp(keyPath, "HKEY_CLASSES_ROOT\\", 18) == 0) {
94 hRootKey = HKEY_CLASSES_ROOT;
95 subKey = keyPath + 18;
96 } else if (strncmp(keyPath, "HKEY_USERS\\", 11) == 0) {
97 hRootKey = HKEY_USERS;
98 subKey = keyPath + 11;
99 } else if (strncmp(keyPath, "HKEY_LOCAL_MACHINE\\", 19) == 0) {
100 hRootKey = HKEY_LOCAL_MACHINE;
101 subKey = keyPath + 19;
102 } else if (strncmp(keyPath, "HKEY_CURRENT_USER\\", 18) == 0) {
103 hRootKey = HKEY_CURRENT_USER;
104 subKey = keyPath + 18;
105 } else {
106 return false;
107 }
108
109 const char *placeHolder = strstr(subKey, "$VERSION");
110 char bestName[256];
111 bestName[0] = '\0';
112 // If we have a $VERSION placeholder, do the highest-version search.
113 if (placeHolder) {
114 const char *keyEnd = placeHolder - 1;
115 const char *nextKey = placeHolder;
116 // Find end of previous key.
117 while ((keyEnd > subKey) && (*keyEnd != '\\'))
118 keyEnd--;
119 // Find end of key containing $VERSION.
120 while (*nextKey && (*nextKey != '\\'))
121 nextKey++;
122 size_t partialKeyLength = keyEnd - subKey;
123 char partialKey[256];
124 if (partialKeyLength > sizeof(partialKey))
125 partialKeyLength = sizeof(partialKey);
126 strncpy(partialKey, subKey, partialKeyLength);
127 partialKey[partialKeyLength] = '\0';
128 HKEY hTopKey = NULL;
129 lResult = RegOpenKeyEx(hRootKey, partialKey, 0, KEY_READ | KEY_WOW64_32KEY,
130 &hTopKey);
131 if (lResult == ERROR_SUCCESS) {
132 char keyName[256];
133 int bestIndex = -1;
134 double bestValue = 0.0;
135 DWORD index, size = sizeof(keyName) - 1;
136 for (index = 0; RegEnumKeyEx(hTopKey, index, keyName, &size, NULL,
137 NULL, NULL, NULL) == ERROR_SUCCESS; index++) {
138 const char *sp = keyName;
139 while (*sp && !isDigit(*sp))
140 sp++;
141 if (!*sp)
142 continue;
143 const char *ep = sp + 1;
144 while (*ep && (isDigit(*ep) || (*ep == '.')))
145 ep++;
146 char numBuf[32];
147 strncpy(numBuf, sp, sizeof(numBuf) - 1);
148 numBuf[sizeof(numBuf) - 1] = '\0';
149 double dvalue = strtod(numBuf, NULL);
150 if (dvalue > bestValue) {
151 // Test that InstallDir is indeed there before keeping this index.
152 // Open the chosen key path remainder.
153 strcpy(bestName, keyName);
154 // Append rest of key.
155 strncat(bestName, nextKey, sizeof(bestName) - 1);
156 bestName[sizeof(bestName) - 1] = '\0';
157 lResult = RegOpenKeyEx(hTopKey, bestName, 0,
158 KEY_READ | KEY_WOW64_32KEY, &hKey);
159 if (lResult == ERROR_SUCCESS) {
160 lResult = RegQueryValueEx(hKey, valueName, NULL, &valueType,
161 (LPBYTE)value, &valueSize);
162 if (lResult == ERROR_SUCCESS) {
163 bestIndex = (int)index;
164 bestValue = dvalue;
165 returnValue = true;
166 }
167 RegCloseKey(hKey);
168 }
169 }
170 size = sizeof(keyName) - 1;
171 }
172 RegCloseKey(hTopKey);
173 }
174 } else {
175 lResult = RegOpenKeyEx(hRootKey, subKey, 0, KEY_READ | KEY_WOW64_32KEY,
176 &hKey);
177 if (lResult == ERROR_SUCCESS) {
178 lResult = RegQueryValueEx(hKey, valueName, NULL, &valueType,
179 (LPBYTE)value, &valueSize);
180 if (lResult == ERROR_SUCCESS)
181 returnValue = true;
182 RegCloseKey(hKey);
183 }
184 }
185 return returnValue;
186 }
187
188 /// \brief Get Windows SDK installation directory.
getWindowsSDKDir(std::string & path)189 static bool getWindowsSDKDir(std::string &path) {
190 char windowsSDKInstallDir[256];
191 // Try the Windows registry.
192 bool hasSDKDir = getSystemRegistryString(
193 "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\$VERSION",
194 "InstallationFolder",
195 windowsSDKInstallDir,
196 sizeof(windowsSDKInstallDir) - 1);
197 // If we have both vc80 and vc90, pick version we were compiled with.
198 if (hasSDKDir && windowsSDKInstallDir[0]) {
199 path = windowsSDKInstallDir;
200 return true;
201 }
202 return false;
203 }
204
205 // Get Visual Studio installation directory.
getVisualStudioDir(std::string & path)206 static bool getVisualStudioDir(std::string &path) {
207 // First check the environment variables that vsvars32.bat sets.
208 const char* vcinstalldir = getenv("VCINSTALLDIR");
209 if (vcinstalldir) {
210 char *p = const_cast<char *>(strstr(vcinstalldir, "\\VC"));
211 if (p)
212 *p = '\0';
213 path = vcinstalldir;
214 return true;
215 }
216
217 char vsIDEInstallDir[256];
218 char vsExpressIDEInstallDir[256];
219 // Then try the windows registry.
220 bool hasVCDir = getSystemRegistryString(
221 "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\$VERSION",
222 "InstallDir", vsIDEInstallDir, sizeof(vsIDEInstallDir) - 1);
223 bool hasVCExpressDir = getSystemRegistryString(
224 "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\$VERSION",
225 "InstallDir", vsExpressIDEInstallDir, sizeof(vsExpressIDEInstallDir) - 1);
226 // If we have both vc80 and vc90, pick version we were compiled with.
227 if (hasVCDir && vsIDEInstallDir[0]) {
228 char *p = (char*)strstr(vsIDEInstallDir, "\\Common7\\IDE");
229 if (p)
230 *p = '\0';
231 path = vsIDEInstallDir;
232 return true;
233 }
234
235 if (hasVCExpressDir && vsExpressIDEInstallDir[0]) {
236 char *p = (char*)strstr(vsExpressIDEInstallDir, "\\Common7\\IDE");
237 if (p)
238 *p = '\0';
239 path = vsExpressIDEInstallDir;
240 return true;
241 }
242
243 // Try the environment.
244 const char *vs100comntools = getenv("VS100COMNTOOLS");
245 const char *vs90comntools = getenv("VS90COMNTOOLS");
246 const char *vs80comntools = getenv("VS80COMNTOOLS");
247 const char *vscomntools = NULL;
248
249 // Try to find the version that we were compiled with
250 if(false) {}
251 #if (_MSC_VER >= 1600) // VC100
252 else if(vs100comntools) {
253 vscomntools = vs100comntools;
254 }
255 #elif (_MSC_VER == 1500) // VC80
256 else if(vs90comntools) {
257 vscomntools = vs90comntools;
258 }
259 #elif (_MSC_VER == 1400) // VC80
260 else if(vs80comntools) {
261 vscomntools = vs80comntools;
262 }
263 #endif
264 // Otherwise find any version we can
265 else if (vs100comntools)
266 vscomntools = vs100comntools;
267 else if (vs90comntools)
268 vscomntools = vs90comntools;
269 else if (vs80comntools)
270 vscomntools = vs80comntools;
271
272 if (vscomntools && *vscomntools) {
273 const char *p = strstr(vscomntools, "\\Common7\\Tools");
274 path = p ? std::string(vscomntools, p) : vscomntools;
275 return true;
276 }
277 return false;
278 }
279
280 #endif // _MSC_VER
281
AddClangSystemIncludeArgs(const ArgList & DriverArgs,ArgStringList & CC1Args) const282 void Windows::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
283 ArgStringList &CC1Args) const {
284 if (DriverArgs.hasArg(options::OPT_nostdinc))
285 return;
286
287 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
288 SmallString<128> P(getDriver().ResourceDir);
289 llvm::sys::path::append(P, "include");
290 addSystemInclude(DriverArgs, CC1Args, P.str());
291 }
292
293 if (DriverArgs.hasArg(options::OPT_nostdlibinc))
294 return;
295
296 #ifdef _MSC_VER
297 // Honor %INCLUDE%. It should know essential search paths with vcvarsall.bat.
298 if (const char *cl_include_dir = getenv("INCLUDE")) {
299 SmallVector<StringRef, 8> Dirs;
300 StringRef(cl_include_dir).split(Dirs, ";");
301 int n = 0;
302 for (SmallVectorImpl<StringRef>::iterator I = Dirs.begin(), E = Dirs.end();
303 I != E; ++I) {
304 StringRef d = *I;
305 if (d.size() == 0)
306 continue;
307 ++n;
308 addSystemInclude(DriverArgs, CC1Args, d);
309 }
310 if (n) return;
311 }
312
313 std::string VSDir;
314 std::string WindowsSDKDir;
315
316 // When built with access to the proper Windows APIs, try to actually find
317 // the correct include paths first.
318 if (getVisualStudioDir(VSDir)) {
319 addSystemInclude(DriverArgs, CC1Args, VSDir + "\\VC\\include");
320 if (getWindowsSDKDir(WindowsSDKDir))
321 addSystemInclude(DriverArgs, CC1Args, WindowsSDKDir + "\\include");
322 else
323 addSystemInclude(DriverArgs, CC1Args,
324 VSDir + "\\VC\\PlatformSDK\\Include");
325 return;
326 }
327 #endif // _MSC_VER
328
329 // As a fallback, select default install paths.
330 const StringRef Paths[] = {
331 "C:/Program Files/Microsoft Visual Studio 10.0/VC/include",
332 "C:/Program Files/Microsoft Visual Studio 9.0/VC/include",
333 "C:/Program Files/Microsoft Visual Studio 9.0/VC/PlatformSDK/Include",
334 "C:/Program Files/Microsoft Visual Studio 8/VC/include",
335 "C:/Program Files/Microsoft Visual Studio 8/VC/PlatformSDK/Include"
336 };
337 addSystemIncludes(DriverArgs, CC1Args, Paths);
338 }
339
AddClangCXXStdlibIncludeArgs(const ArgList & DriverArgs,ArgStringList & CC1Args) const340 void Windows::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
341 ArgStringList &CC1Args) const {
342 // FIXME: There should probably be logic here to find libc++ on Windows.
343 }
344