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