Driver.cpp revision 4f6a4b47675a30e621251fcda1d192a2c17c6eea
1c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath//===--- Driver.cpp - Clang GCC Compatible Driver -------------------------===// 2c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath// 3c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath// The LLVM Compiler Infrastructure 4c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath// 5c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath// This file is distributed under the University of Illinois Open Source 6c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath// License. See LICENSE.TXT for details. 7c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath// 8c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath//===----------------------------------------------------------------------===// 9c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath 10c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include "clang/Driver/Driver.h" 11c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath 12c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include "clang/Driver/Action.h" 13c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include "clang/Driver/Arg.h" 14c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include "clang/Driver/ArgList.h" 15c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include "clang/Driver/Compilation.h" 16c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include "clang/Driver/DriverDiagnostic.h" 17c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include "clang/Driver/Job.h" 18c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include "clang/Driver/OptTable.h" 19c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include "clang/Driver/Option.h" 20c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include "clang/Driver/Options.h" 21c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include "clang/Driver/Tool.h" 22c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include "clang/Driver/ToolChain.h" 23c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath 24c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include "clang/Basic/Version.h" 25c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath 26c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include "llvm/ADT/ArrayRef.h" 27c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include "llvm/ADT/StringSet.h" 28c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include "llvm/ADT/OwningPtr.h" 29c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include "llvm/Support/ErrorHandling.h" 30c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include "llvm/Support/PrettyStackTrace.h" 31c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include "llvm/Support/raw_ostream.h" 327faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez#include "llvm/Support/FileSystem.h" 33c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include "llvm/Support/Path.h" 347faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez#include "llvm/Support/Program.h" 35c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath 36c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include "InputInfo.h" 37c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include "ToolChains.h" 38c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath 39c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include <map> 40c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath 41c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath#include "clang/Config/config.h" 42c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath 43c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamathusing namespace clang::driver; 44c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamathusing namespace clang; 45c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath 46c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan KamathDriver::Driver(StringRef ClangExecutable, 47c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath StringRef DefaultTargetTriple, 48c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath StringRef DefaultImageName, 49c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath bool IsProduction, 50c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath DiagnosticsEngine &Diags) 51c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath : Opts(createDriverOptTable()), Diags(Diags), 52c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath ClangExecutable(ClangExecutable), SysRoot(DEFAULT_SYSROOT), 53c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath UseStdLib(true), DefaultTargetTriple(DefaultTargetTriple), 54c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath DefaultImageName(DefaultImageName), 55c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath DriverTitle("clang \"gcc-compatible\" driver"), 56c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath CCPrintOptionsFilename(0), CCPrintHeadersFilename(0), 57c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath CCLogDiagnosticsFilename(0), CCCIsCXX(false), 587faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez CCCIsCPP(false),CCCEcho(false), CCCPrintBindings(false), 59c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath CCPrintOptions(false), CCPrintHeaders(false), CCLogDiagnostics(false), 607faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez CCGenDiagnostics(false), CCCGenericGCCName(""), CheckInputsExist(true), 61c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath CCCUseClang(true), CCCUseClangCXX(true), CCCUseClangCPP(true), 62c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath ForcedClangUse(false), CCCUsePCH(true), SuppressMissingInputWarning(false) { 63c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath if (IsProduction) { 64c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath // In a "production" build, only use clang on architectures we expect to 65c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath // work. 66c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath // 67c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath // During development its more convenient to always have the driver use 68c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath // clang, but we don't want users to be confused when things don't work, or 69c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath // to file bugs for things we don't support. 70c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath CCCClangArchs.insert(llvm::Triple::x86); 71c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath CCCClangArchs.insert(llvm::Triple::x86_64); 72c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath CCCClangArchs.insert(llvm::Triple::arm); 73c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath } 74c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath 75c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath Name = llvm::sys::path::stem(ClangExecutable); 76c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath Dir = llvm::sys::path::parent_path(ClangExecutable); 77c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath 78c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath // Compute the path to the resource directory. 79c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath StringRef ClangResourceDir(CLANG_RESOURCE_DIR); 80c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath SmallString<128> P(Dir); 81c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath if (ClangResourceDir != "") 82c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath llvm::sys::path::append(P, ClangResourceDir); 83c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath else 84c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath llvm::sys::path::append(P, "..", "lib", "clang", CLANG_VERSION_STRING); 85c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath ResourceDir = P.str(); 86c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath} 87c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath 887faaa9f3f0df9d23790277834d426c3d992ac3baCarlos HernandezDriver::~Driver() { 89c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath delete Opts; 90c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath 91c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath for (llvm::StringMap<ToolChain *>::iterator I = ToolChains.begin(), 92c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath E = ToolChains.end(); 93c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath I != E; ++I) 94c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath delete I->second; 95c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath} 96c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath 97c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan KamathInputArgList *Driver::ParseArgStrings(ArrayRef<const char *> ArgList) { 98c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath llvm::PrettyStackTraceString CrashInfo("Command line argument parsing"); 99c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath unsigned MissingArgIndex, MissingArgCount; 100c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath InputArgList *Args = getOpts().ParseArgs(ArgList.begin(), ArgList.end(), 101c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath MissingArgIndex, MissingArgCount); 102c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath 103c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath // Check for missing argument error. 104c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath if (MissingArgCount) 105c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath Diag(clang::diag::err_drv_missing_argument) 106c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath << Args->getArgString(MissingArgIndex) << MissingArgCount; 107c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath 108c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath // Check for unsupported options. 109c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath for (ArgList::const_iterator it = Args->begin(), ie = Args->end(); 110c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath it != ie; ++it) { 111c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath Arg *A = *it; 1127faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez if (A->getOption().isUnsupported()) { 113c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath Diag(clang::diag::err_drv_unsupported_opt) << A->getAsString(*Args); 114c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath continue; 115c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath } 116c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath 117c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath // Warn about -mcpu= without an argument. 118c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath if (A->getOption().matches(options::OPT_mcpu_EQ) && 119c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath A->containsValue("")) { 120c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath Diag(clang::diag::warn_drv_empty_joined_argument) << A->getAsString(*Args); 121c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath } 122c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath } 123c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath 124c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath return Args; 125c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath} 126c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath 127c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath// Determine which compilation mode we are in. We look for options which 128c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath// affect the phase, starting with the earliest phases, and record which 129c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath// option we used to determine the final phase. 130c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamathphases::ID Driver::getFinalPhase(const DerivedArgList &DAL, Arg **FinalPhaseArg) 131c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamathconst { 1327faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez Arg *PhaseArg = 0; 1337faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez phases::ID FinalPhase; 1347faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez 1357faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez // -{E,M,MM} only run the preprocessor. 1367faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez if (CCCIsCPP || 1377faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez (PhaseArg = DAL.getLastArg(options::OPT_E)) || 1387faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez (PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM))) { 1397faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez FinalPhase = phases::Preprocess; 1407faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez 1417faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez // -{fsyntax-only,-analyze,emit-ast,S} only run up to the compiler. 1427faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez } else if ((PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) || 1437faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez (PhaseArg = DAL.getLastArg(options::OPT_rewrite_objc)) || 1447faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez (PhaseArg = DAL.getLastArg(options::OPT_rewrite_legacy_objc)) || 1457faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez (PhaseArg = DAL.getLastArg(options::OPT__migrate)) || 1467faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez (PhaseArg = DAL.getLastArg(options::OPT__analyze, 1477faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez options::OPT__analyze_auto)) || 1487faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez (PhaseArg = DAL.getLastArg(options::OPT_emit_ast)) || 1497faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez (PhaseArg = DAL.getLastArg(options::OPT_S))) { 1507faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez FinalPhase = phases::Compile; 1517faaa9f3f0df9d23790277834d426c3d992ac3baCarlos Hernandez 152c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath // -c only runs up to the assembler. 153c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath } else if ((PhaseArg = DAL.getLastArg(options::OPT_c))) { 154c981c48f5bc9aefeffc0bcb0cc3934c2fae179ddNarayan Kamath FinalPhase = phases::Assemble; 155 156 // Otherwise do everything. 157 } else 158 FinalPhase = phases::Link; 159 160 if (FinalPhaseArg) 161 *FinalPhaseArg = PhaseArg; 162 163 return FinalPhase; 164} 165 166DerivedArgList *Driver::TranslateInputArgs(const InputArgList &Args) const { 167 DerivedArgList *DAL = new DerivedArgList(Args); 168 169 bool HasNostdlib = Args.hasArg(options::OPT_nostdlib); 170 for (ArgList::const_iterator it = Args.begin(), 171 ie = Args.end(); it != ie; ++it) { 172 const Arg *A = *it; 173 174 // Unfortunately, we have to parse some forwarding options (-Xassembler, 175 // -Xlinker, -Xpreprocessor) because we either integrate their functionality 176 // (assembler and preprocessor), or bypass a previous driver ('collect2'). 177 178 // Rewrite linker options, to replace --no-demangle with a custom internal 179 // option. 180 if ((A->getOption().matches(options::OPT_Wl_COMMA) || 181 A->getOption().matches(options::OPT_Xlinker)) && 182 A->containsValue("--no-demangle")) { 183 // Add the rewritten no-demangle argument. 184 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_Xlinker__no_demangle)); 185 186 // Add the remaining values as Xlinker arguments. 187 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) 188 if (StringRef(A->getValue(Args, i)) != "--no-demangle") 189 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_Xlinker), 190 A->getValue(Args, i)); 191 192 continue; 193 } 194 195 // Rewrite preprocessor options, to replace -Wp,-MD,FOO which is used by 196 // some build systems. We don't try to be complete here because we don't 197 // care to encourage this usage model. 198 if (A->getOption().matches(options::OPT_Wp_COMMA) && 199 A->getNumValues() == 2 && 200 (A->getValue(Args, 0) == StringRef("-MD") || 201 A->getValue(Args, 0) == StringRef("-MMD"))) { 202 // Rewrite to -MD/-MMD along with -MF. 203 if (A->getValue(Args, 0) == StringRef("-MD")) 204 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MD)); 205 else 206 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MMD)); 207 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_MF), 208 A->getValue(Args, 1)); 209 continue; 210 } 211 212 // Rewrite reserved library names. 213 if (A->getOption().matches(options::OPT_l)) { 214 StringRef Value = A->getValue(Args); 215 216 // Rewrite unless -nostdlib is present. 217 if (!HasNostdlib && Value == "stdc++") { 218 DAL->AddFlagArg(A, Opts->getOption( 219 options::OPT_Z_reserved_lib_stdcxx)); 220 continue; 221 } 222 223 // Rewrite unconditionally. 224 if (Value == "cc_kext") { 225 DAL->AddFlagArg(A, Opts->getOption( 226 options::OPT_Z_reserved_lib_cckext)); 227 continue; 228 } 229 } 230 231 DAL->append(*it); 232 } 233 234 // Add a default value of -mlinker-version=, if one was given and the user 235 // didn't specify one. 236#if defined(HOST_LINK_VERSION) 237 if (!Args.hasArg(options::OPT_mlinker_version_EQ)) { 238 DAL->AddJoinedArg(0, Opts->getOption(options::OPT_mlinker_version_EQ), 239 HOST_LINK_VERSION); 240 DAL->getLastArg(options::OPT_mlinker_version_EQ)->claim(); 241 } 242#endif 243 244 return DAL; 245} 246 247Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) { 248 llvm::PrettyStackTraceString CrashInfo("Compilation construction"); 249 250 // FIXME: Handle environment options which affect driver behavior, somewhere 251 // (client?). GCC_EXEC_PREFIX, LPATH, CC_PRINT_OPTIONS. 252 253 if (char *env = ::getenv("COMPILER_PATH")) { 254 StringRef CompilerPath = env; 255 while (!CompilerPath.empty()) { 256 std::pair<StringRef, StringRef> Split = CompilerPath.split(':'); 257 PrefixDirs.push_back(Split.first); 258 CompilerPath = Split.second; 259 } 260 } 261 262 // FIXME: What are we going to do with -V and -b? 263 264 // FIXME: This stuff needs to go into the Compilation, not the driver. 265 bool CCCPrintOptions = false, CCCPrintActions = false; 266 267 InputArgList *Args = ParseArgStrings(ArgList.slice(1)); 268 269 // -no-canonical-prefixes is used very early in main. 270 Args->ClaimAllArgs(options::OPT_no_canonical_prefixes); 271 272 // Ignore -pipe. 273 Args->ClaimAllArgs(options::OPT_pipe); 274 275 // Extract -ccc args. 276 // 277 // FIXME: We need to figure out where this behavior should live. Most of it 278 // should be outside in the client; the parts that aren't should have proper 279 // options, either by introducing new ones or by overloading gcc ones like -V 280 // or -b. 281 CCCPrintOptions = Args->hasArg(options::OPT_ccc_print_options); 282 CCCPrintActions = Args->hasArg(options::OPT_ccc_print_phases); 283 CCCPrintBindings = Args->hasArg(options::OPT_ccc_print_bindings); 284 CCCIsCXX = Args->hasArg(options::OPT_ccc_cxx) || CCCIsCXX; 285 CCCEcho = Args->hasArg(options::OPT_ccc_echo); 286 if (const Arg *A = Args->getLastArg(options::OPT_ccc_gcc_name)) 287 CCCGenericGCCName = A->getValue(*Args); 288 CCCUseClangCXX = Args->hasFlag(options::OPT_ccc_clang_cxx, 289 options::OPT_ccc_no_clang_cxx, 290 CCCUseClangCXX); 291 CCCUsePCH = Args->hasFlag(options::OPT_ccc_pch_is_pch, 292 options::OPT_ccc_pch_is_pth); 293 CCCUseClang = !Args->hasArg(options::OPT_ccc_no_clang); 294 CCCUseClangCPP = !Args->hasArg(options::OPT_ccc_no_clang_cpp); 295 if (const Arg *A = Args->getLastArg(options::OPT_ccc_clang_archs)) { 296 StringRef Cur = A->getValue(*Args); 297 298 CCCClangArchs.clear(); 299 while (!Cur.empty()) { 300 std::pair<StringRef, StringRef> Split = Cur.split(','); 301 302 if (!Split.first.empty()) { 303 llvm::Triple::ArchType Arch = 304 llvm::Triple(Split.first, "", "").getArch(); 305 306 if (Arch == llvm::Triple::UnknownArch) 307 Diag(clang::diag::err_drv_invalid_arch_name) << Split.first; 308 309 CCCClangArchs.insert(Arch); 310 } 311 312 Cur = Split.second; 313 } 314 } 315 // FIXME: DefaultTargetTriple is used by the target-prefixed calls to as/ld 316 // and getToolChain is const. 317 if (const Arg *A = Args->getLastArg(options::OPT_target)) 318 DefaultTargetTriple = A->getValue(*Args); 319 if (const Arg *A = Args->getLastArg(options::OPT_ccc_install_dir)) 320 Dir = InstalledDir = A->getValue(*Args); 321 for (arg_iterator it = Args->filtered_begin(options::OPT_B), 322 ie = Args->filtered_end(); it != ie; ++it) { 323 const Arg *A = *it; 324 A->claim(); 325 PrefixDirs.push_back(A->getValue(*Args, 0)); 326 } 327 if (const Arg *A = Args->getLastArg(options::OPT__sysroot_EQ)) 328 SysRoot = A->getValue(*Args); 329 if (Args->hasArg(options::OPT_nostdlib)) 330 UseStdLib = false; 331 332 // Perform the default argument translations. 333 DerivedArgList *TranslatedArgs = TranslateInputArgs(*Args); 334 335 // Owned by the host. 336 const ToolChain &TC = getToolChain(*Args); 337 338 // The compilation takes ownership of Args. 339 Compilation *C = new Compilation(*this, TC, Args, TranslatedArgs); 340 341 // FIXME: This behavior shouldn't be here. 342 if (CCCPrintOptions) { 343 PrintOptions(C->getInputArgs()); 344 return C; 345 } 346 347 if (!HandleImmediateArgs(*C)) 348 return C; 349 350 // Construct the list of inputs. 351 InputList Inputs; 352 BuildInputs(C->getDefaultToolChain(), C->getArgs(), Inputs); 353 354 // Construct the list of abstract actions to perform for this compilation. On 355 // Darwin target OSes this uses the driver-driver and universal actions. 356 if (TC.getTriple().isOSDarwin()) 357 BuildUniversalActions(C->getDefaultToolChain(), C->getArgs(), 358 Inputs, C->getActions()); 359 else 360 BuildActions(C->getDefaultToolChain(), C->getArgs(), Inputs, 361 C->getActions()); 362 363 if (CCCPrintActions) { 364 PrintActions(*C); 365 return C; 366 } 367 368 BuildJobs(*C); 369 370 return C; 371} 372 373// When clang crashes, produce diagnostic information including the fully 374// preprocessed source file(s). Request that the developer attach the 375// diagnostic information to a bug report. 376void Driver::generateCompilationDiagnostics(Compilation &C, 377 const Command *FailingCommand) { 378 if (C.getArgs().hasArg(options::OPT_fno_crash_diagnostics)) 379 return; 380 381 // Don't try to generate diagnostics for link jobs. 382 if (FailingCommand && FailingCommand->getCreator().isLinkJob()) 383 return; 384 385 // Print the version of the compiler. 386 PrintVersion(C, llvm::errs()); 387 388 Diag(clang::diag::note_drv_command_failed_diag_msg) 389 << "\n********************\n********************\n\n" 390 "PLEASE submit a BUG REPORT to " BUG_REPORT_URL " and _INCLUDE_ the " 391 "crash backtrace, all command line arguments, PREPROCESSED SOURCE, " 392 "and associated RUN SCRIPT.\n" 393 "\n********************\n********************"; 394 395 // Suppress driver output and emit preprocessor output to temp file. 396 CCCIsCPP = true; 397 CCGenDiagnostics = true; 398 399 // Save the original job command(s). 400 std::string Cmd; 401 llvm::raw_string_ostream OS(Cmd); 402 if (FailingCommand) 403 C.PrintJob(OS, *FailingCommand, "\n", false); 404 else 405 // Crash triggered by FORCE_CLANG_DIAGNOSTICS_CRASH, which doesn't have an 406 // associated FailingCommand, so just pass all jobs. 407 C.PrintJob(OS, C.getJobs(), "\n", false); 408 OS.flush(); 409 410 // Clear stale state and suppress tool output. 411 C.initCompilationForDiagnostics(); 412 Diags.Reset(); 413 414 // Construct the list of inputs. 415 InputList Inputs; 416 BuildInputs(C.getDefaultToolChain(), C.getArgs(), Inputs); 417 418 for (InputList::iterator it = Inputs.begin(), ie = Inputs.end(); it != ie;) { 419 bool IgnoreInput = false; 420 421 // Ignore input from stdin or any inputs that cannot be preprocessed. 422 if (!strcmp(it->second->getValue(C.getArgs()), "-")) { 423 Diag(clang::diag::note_drv_command_failed_diag_msg) 424 << "Error generating preprocessed source(s) - ignoring input from stdin" 425 "."; 426 IgnoreInput = true; 427 } else if (types::getPreprocessedType(it->first) == types::TY_INVALID) { 428 IgnoreInput = true; 429 } 430 431 if (IgnoreInput) { 432 it = Inputs.erase(it); 433 ie = Inputs.end(); 434 } else { 435 ++it; 436 } 437 } 438 439 // Don't attempt to generate preprocessed files if multiple -arch options are 440 // used, unless they're all duplicates. 441 llvm::StringSet<> ArchNames; 442 for (ArgList::const_iterator it = C.getArgs().begin(), ie = C.getArgs().end(); 443 it != ie; ++it) { 444 Arg *A = *it; 445 if (A->getOption().matches(options::OPT_arch)) { 446 StringRef ArchName = A->getValue(C.getArgs()); 447 ArchNames.insert(ArchName); 448 } 449 } 450 if (ArchNames.size() > 1) { 451 Diag(clang::diag::note_drv_command_failed_diag_msg) 452 << "Error generating preprocessed source(s) - cannot generate " 453 "preprocessed source with multiple -arch options."; 454 return; 455 } 456 457 if (Inputs.empty()) { 458 Diag(clang::diag::note_drv_command_failed_diag_msg) 459 << "Error generating preprocessed source(s) - no preprocessable inputs."; 460 return; 461 } 462 463 // Construct the list of abstract actions to perform for this compilation. On 464 // Darwin OSes this uses the driver-driver and builds universal actions. 465 const ToolChain &TC = C.getDefaultToolChain(); 466 if (TC.getTriple().isOSDarwin()) 467 BuildUniversalActions(TC, C.getArgs(), Inputs, C.getActions()); 468 else 469 BuildActions(TC, C.getArgs(), Inputs, C.getActions()); 470 471 BuildJobs(C); 472 473 // If there were errors building the compilation, quit now. 474 if (Diags.hasErrorOccurred()) { 475 Diag(clang::diag::note_drv_command_failed_diag_msg) 476 << "Error generating preprocessed source(s)."; 477 return; 478 } 479 480 // Generate preprocessed output. 481 FailingCommand = 0; 482 int Res = C.ExecuteJob(C.getJobs(), FailingCommand); 483 484 // If the command succeeded, we are done. 485 if (Res == 0) { 486 Diag(clang::diag::note_drv_command_failed_diag_msg) 487 << "Preprocessed source(s) and associated run script(s) are located at:"; 488 ArgStringList Files = C.getTempFiles(); 489 for (ArgStringList::const_iterator it = Files.begin(), ie = Files.end(); 490 it != ie; ++it) { 491 Diag(clang::diag::note_drv_command_failed_diag_msg) << *it; 492 493 std::string Err; 494 std::string Script = StringRef(*it).rsplit('.').first; 495 Script += ".sh"; 496 llvm::raw_fd_ostream ScriptOS(Script.c_str(), Err, 497 llvm::raw_fd_ostream::F_Excl | 498 llvm::raw_fd_ostream::F_Binary); 499 if (!Err.empty()) { 500 Diag(clang::diag::note_drv_command_failed_diag_msg) 501 << "Error generating run script: " + Script + " " + Err; 502 } else { 503 // Strip away options not necessary to reproduce the crash. 504 // FIXME: This doesn't work with quotes (e.g., -D "foo bar"). 505 SmallVector<std::string, 16> Flag; 506 Flag.push_back("-D "); 507 Flag.push_back("-F"); 508 Flag.push_back("-I "); 509 Flag.push_back("-o "); 510 Flag.push_back("-coverage-file "); 511 Flag.push_back("-dependency-file "); 512 Flag.push_back("-fdebug-compilation-dir "); 513 Flag.push_back("-fmodule-cache-path "); 514 Flag.push_back("-include "); 515 Flag.push_back("-include-pch "); 516 Flag.push_back("-isysroot "); 517 Flag.push_back("-resource-dir "); 518 Flag.push_back("-serialize-diagnostic-file "); 519 for (unsigned i = 0, e = Flag.size(); i < e; ++i) { 520 size_t I = 0, E = 0; 521 do { 522 I = Cmd.find(Flag[i], I); 523 if (I == std::string::npos) break; 524 525 E = Cmd.find(" ", I + Flag[i].length()); 526 if (E == std::string::npos) break; 527 Cmd.erase(I, E - I + 1); 528 } while(1); 529 } 530 // Append the new filename with correct preprocessed suffix. 531 size_t I, E; 532 I = Cmd.find("-main-file-name "); 533 assert (I != std::string::npos && "Expected to find -main-file-name"); 534 I += 16; 535 E = Cmd.find(" ", I); 536 assert (E != std::string::npos && "-main-file-name missing argument?"); 537 StringRef OldFilename = StringRef(Cmd).slice(I, E); 538 StringRef NewFilename = llvm::sys::path::filename(*it); 539 I = StringRef(Cmd).rfind(OldFilename); 540 E = I + OldFilename.size(); 541 I = Cmd.rfind(" ", I) + 1; 542 Cmd.replace(I, E - I, NewFilename.data(), NewFilename.size()); 543 ScriptOS << Cmd; 544 Diag(clang::diag::note_drv_command_failed_diag_msg) << Script; 545 } 546 } 547 } else { 548 // Failure, remove preprocessed files. 549 if (!C.getArgs().hasArg(options::OPT_save_temps)) 550 C.CleanupFileList(C.getTempFiles(), true); 551 552 Diag(clang::diag::note_drv_command_failed_diag_msg) 553 << "Error generating preprocessed source(s)."; 554 } 555} 556 557int Driver::ExecuteCompilation(const Compilation &C, 558 const Command *&FailingCommand) const { 559 // Just print if -### was present. 560 if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) { 561 C.PrintJob(llvm::errs(), C.getJobs(), "\n", true); 562 return 0; 563 } 564 565 // If there were errors building the compilation, quit now. 566 if (Diags.hasErrorOccurred()) 567 return 1; 568 569 int Res = C.ExecuteJob(C.getJobs(), FailingCommand); 570 571 // Remove temp files. 572 C.CleanupFileList(C.getTempFiles()); 573 574 // If the command succeeded, we are done. 575 if (Res == 0) 576 return Res; 577 578 // Otherwise, remove result files as well. 579 if (!C.getArgs().hasArg(options::OPT_save_temps)) { 580 C.CleanupFileList(C.getResultFiles(), true); 581 582 // Failure result files are valid unless we crashed. 583 if (Res < 0) { 584 C.CleanupFileList(C.getFailureResultFiles(), true); 585#ifdef _WIN32 586 // Exit status should not be negative on Win32, 587 // unless abnormal termination. 588 Res = 1; 589#endif 590 } 591 } 592 593 // Print extra information about abnormal failures, if possible. 594 // 595 // This is ad-hoc, but we don't want to be excessively noisy. If the result 596 // status was 1, assume the command failed normally. In particular, if it was 597 // the compiler then assume it gave a reasonable error code. Failures in other 598 // tools are less common, and they generally have worse diagnostics, so always 599 // print the diagnostic there. 600 const Tool &FailingTool = FailingCommand->getCreator(); 601 602 if (!FailingCommand->getCreator().hasGoodDiagnostics() || Res != 1) { 603 // FIXME: See FIXME above regarding result code interpretation. 604 if (Res < 0) 605 Diag(clang::diag::err_drv_command_signalled) 606 << FailingTool.getShortName(); 607 else 608 Diag(clang::diag::err_drv_command_failed) 609 << FailingTool.getShortName() << Res; 610 } 611 612 return Res; 613} 614 615void Driver::PrintOptions(const ArgList &Args) const { 616 unsigned i = 0; 617 for (ArgList::const_iterator it = Args.begin(), ie = Args.end(); 618 it != ie; ++it, ++i) { 619 Arg *A = *it; 620 llvm::errs() << "Option " << i << " - " 621 << "Name: \"" << A->getOption().getName() << "\", " 622 << "Values: {"; 623 for (unsigned j = 0; j < A->getNumValues(); ++j) { 624 if (j) 625 llvm::errs() << ", "; 626 llvm::errs() << '"' << A->getValue(Args, j) << '"'; 627 } 628 llvm::errs() << "}\n"; 629 } 630} 631 632void Driver::PrintHelp(bool ShowHidden) const { 633 getOpts().PrintHelp(llvm::outs(), Name.c_str(), DriverTitle.c_str(), 634 ShowHidden); 635} 636 637void Driver::PrintVersion(const Compilation &C, raw_ostream &OS) const { 638 // FIXME: The following handlers should use a callback mechanism, we don't 639 // know what the client would like to do. 640 OS << getClangFullVersion() << '\n'; 641 const ToolChain &TC = C.getDefaultToolChain(); 642 OS << "Target: " << TC.getTripleString() << '\n'; 643 644 // Print the threading model. 645 // 646 // FIXME: Implement correctly. 647 OS << "Thread model: " << "posix" << '\n'; 648} 649 650/// PrintDiagnosticCategories - Implement the --print-diagnostic-categories 651/// option. 652static void PrintDiagnosticCategories(raw_ostream &OS) { 653 // Skip the empty category. 654 for (unsigned i = 1, max = DiagnosticIDs::getNumberOfCategories(); 655 i != max; ++i) 656 OS << i << ',' << DiagnosticIDs::getCategoryNameFromID(i) << '\n'; 657} 658 659bool Driver::HandleImmediateArgs(const Compilation &C) { 660 // The order these options are handled in gcc is all over the place, but we 661 // don't expect inconsistencies w.r.t. that to matter in practice. 662 663 if (C.getArgs().hasArg(options::OPT_dumpmachine)) { 664 llvm::outs() << C.getDefaultToolChain().getTripleString() << '\n'; 665 return false; 666 } 667 668 if (C.getArgs().hasArg(options::OPT_dumpversion)) { 669 // Since -dumpversion is only implemented for pedantic GCC compatibility, we 670 // return an answer which matches our definition of __VERSION__. 671 // 672 // If we want to return a more correct answer some day, then we should 673 // introduce a non-pedantically GCC compatible mode to Clang in which we 674 // provide sensible definitions for -dumpversion, __VERSION__, etc. 675 llvm::outs() << "4.2.1\n"; 676 return false; 677 } 678 679 if (C.getArgs().hasArg(options::OPT__print_diagnostic_categories)) { 680 PrintDiagnosticCategories(llvm::outs()); 681 return false; 682 } 683 684 if (C.getArgs().hasArg(options::OPT_help) || 685 C.getArgs().hasArg(options::OPT__help_hidden)) { 686 PrintHelp(C.getArgs().hasArg(options::OPT__help_hidden)); 687 return false; 688 } 689 690 if (C.getArgs().hasArg(options::OPT__version)) { 691 // Follow gcc behavior and use stdout for --version and stderr for -v. 692 PrintVersion(C, llvm::outs()); 693 return false; 694 } 695 696 if (C.getArgs().hasArg(options::OPT_v) || 697 C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) { 698 PrintVersion(C, llvm::errs()); 699 SuppressMissingInputWarning = true; 700 } 701 702 const ToolChain &TC = C.getDefaultToolChain(); 703 if (C.getArgs().hasArg(options::OPT_print_search_dirs)) { 704 llvm::outs() << "programs: ="; 705 for (ToolChain::path_list::const_iterator it = TC.getProgramPaths().begin(), 706 ie = TC.getProgramPaths().end(); it != ie; ++it) { 707 if (it != TC.getProgramPaths().begin()) 708 llvm::outs() << ':'; 709 llvm::outs() << *it; 710 } 711 llvm::outs() << "\n"; 712 llvm::outs() << "libraries: =" << ResourceDir; 713 714 StringRef sysroot = C.getSysRoot(); 715 716 for (ToolChain::path_list::const_iterator it = TC.getFilePaths().begin(), 717 ie = TC.getFilePaths().end(); it != ie; ++it) { 718 llvm::outs() << ':'; 719 const char *path = it->c_str(); 720 if (path[0] == '=') 721 llvm::outs() << sysroot << path + 1; 722 else 723 llvm::outs() << path; 724 } 725 llvm::outs() << "\n"; 726 return false; 727 } 728 729 // FIXME: The following handlers should use a callback mechanism, we don't 730 // know what the client would like to do. 731 if (Arg *A = C.getArgs().getLastArg(options::OPT_print_file_name_EQ)) { 732 llvm::outs() << GetFilePath(A->getValue(C.getArgs()), TC) << "\n"; 733 return false; 734 } 735 736 if (Arg *A = C.getArgs().getLastArg(options::OPT_print_prog_name_EQ)) { 737 llvm::outs() << GetProgramPath(A->getValue(C.getArgs()), TC) << "\n"; 738 return false; 739 } 740 741 if (C.getArgs().hasArg(options::OPT_print_libgcc_file_name)) { 742 llvm::outs() << GetFilePath("libgcc.a", TC) << "\n"; 743 return false; 744 } 745 746 if (C.getArgs().hasArg(options::OPT_print_multi_lib)) { 747 // FIXME: We need tool chain support for this. 748 llvm::outs() << ".;\n"; 749 750 switch (C.getDefaultToolChain().getTriple().getArch()) { 751 default: 752 break; 753 754 case llvm::Triple::x86_64: 755 llvm::outs() << "x86_64;@m64" << "\n"; 756 break; 757 758 case llvm::Triple::ppc64: 759 llvm::outs() << "ppc64;@m64" << "\n"; 760 break; 761 } 762 return false; 763 } 764 765 // FIXME: What is the difference between print-multi-directory and 766 // print-multi-os-directory? 767 if (C.getArgs().hasArg(options::OPT_print_multi_directory) || 768 C.getArgs().hasArg(options::OPT_print_multi_os_directory)) { 769 switch (C.getDefaultToolChain().getTriple().getArch()) { 770 default: 771 case llvm::Triple::x86: 772 case llvm::Triple::ppc: 773 llvm::outs() << "." << "\n"; 774 break; 775 776 case llvm::Triple::x86_64: 777 llvm::outs() << "x86_64" << "\n"; 778 break; 779 780 case llvm::Triple::ppc64: 781 llvm::outs() << "ppc64" << "\n"; 782 break; 783 } 784 return false; 785 } 786 787 return true; 788} 789 790static unsigned PrintActions1(const Compilation &C, Action *A, 791 std::map<Action*, unsigned> &Ids) { 792 if (Ids.count(A)) 793 return Ids[A]; 794 795 std::string str; 796 llvm::raw_string_ostream os(str); 797 798 os << Action::getClassName(A->getKind()) << ", "; 799 if (InputAction *IA = dyn_cast<InputAction>(A)) { 800 os << "\"" << IA->getInputArg().getValue(C.getArgs()) << "\""; 801 } else if (BindArchAction *BIA = dyn_cast<BindArchAction>(A)) { 802 os << '"' << BIA->getArchName() << '"' 803 << ", {" << PrintActions1(C, *BIA->begin(), Ids) << "}"; 804 } else { 805 os << "{"; 806 for (Action::iterator it = A->begin(), ie = A->end(); it != ie;) { 807 os << PrintActions1(C, *it, Ids); 808 ++it; 809 if (it != ie) 810 os << ", "; 811 } 812 os << "}"; 813 } 814 815 unsigned Id = Ids.size(); 816 Ids[A] = Id; 817 llvm::errs() << Id << ": " << os.str() << ", " 818 << types::getTypeName(A->getType()) << "\n"; 819 820 return Id; 821} 822 823void Driver::PrintActions(const Compilation &C) const { 824 std::map<Action*, unsigned> Ids; 825 for (ActionList::const_iterator it = C.getActions().begin(), 826 ie = C.getActions().end(); it != ie; ++it) 827 PrintActions1(C, *it, Ids); 828} 829 830/// \brief Check whether the given input tree contains any compilation or 831/// assembly actions. 832static bool ContainsCompileOrAssembleAction(const Action *A) { 833 if (isa<CompileJobAction>(A) || isa<AssembleJobAction>(A)) 834 return true; 835 836 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it) 837 if (ContainsCompileOrAssembleAction(*it)) 838 return true; 839 840 return false; 841} 842 843void Driver::BuildUniversalActions(const ToolChain &TC, 844 const DerivedArgList &Args, 845 const InputList &BAInputs, 846 ActionList &Actions) const { 847 llvm::PrettyStackTraceString CrashInfo("Building universal build actions"); 848 // Collect the list of architectures. Duplicates are allowed, but should only 849 // be handled once (in the order seen). 850 llvm::StringSet<> ArchNames; 851 SmallVector<const char *, 4> Archs; 852 for (ArgList::const_iterator it = Args.begin(), ie = Args.end(); 853 it != ie; ++it) { 854 Arg *A = *it; 855 856 if (A->getOption().matches(options::OPT_arch)) { 857 // Validate the option here; we don't save the type here because its 858 // particular spelling may participate in other driver choices. 859 llvm::Triple::ArchType Arch = 860 llvm::Triple::getArchTypeForDarwinArchName(A->getValue(Args)); 861 if (Arch == llvm::Triple::UnknownArch) { 862 Diag(clang::diag::err_drv_invalid_arch_name) 863 << A->getAsString(Args); 864 continue; 865 } 866 867 A->claim(); 868 if (ArchNames.insert(A->getValue(Args))) 869 Archs.push_back(A->getValue(Args)); 870 } 871 } 872 873 // When there is no explicit arch for this platform, make sure we still bind 874 // the architecture (to the default) so that -Xarch_ is handled correctly. 875 if (!Archs.size()) 876 Archs.push_back(Args.MakeArgString(TC.getArchName())); 877 878 // FIXME: We killed off some others but these aren't yet detected in a 879 // functional manner. If we added information to jobs about which "auxiliary" 880 // files they wrote then we could detect the conflict these cause downstream. 881 if (Archs.size() > 1) { 882 // No recovery needed, the point of this is just to prevent 883 // overwriting the same files. 884 if (const Arg *A = Args.getLastArg(options::OPT_save_temps)) 885 Diag(clang::diag::err_drv_invalid_opt_with_multiple_archs) 886 << A->getAsString(Args); 887 } 888 889 ActionList SingleActions; 890 BuildActions(TC, Args, BAInputs, SingleActions); 891 892 // Add in arch bindings for every top level action, as well as lipo and 893 // dsymutil steps if needed. 894 for (unsigned i = 0, e = SingleActions.size(); i != e; ++i) { 895 Action *Act = SingleActions[i]; 896 897 // Make sure we can lipo this kind of output. If not (and it is an actual 898 // output) then we disallow, since we can't create an output file with the 899 // right name without overwriting it. We could remove this oddity by just 900 // changing the output names to include the arch, which would also fix 901 // -save-temps. Compatibility wins for now. 902 903 if (Archs.size() > 1 && !types::canLipoType(Act->getType())) 904 Diag(clang::diag::err_drv_invalid_output_with_multiple_archs) 905 << types::getTypeName(Act->getType()); 906 907 ActionList Inputs; 908 for (unsigned i = 0, e = Archs.size(); i != e; ++i) { 909 Inputs.push_back(new BindArchAction(Act, Archs[i])); 910 if (i != 0) 911 Inputs.back()->setOwnsInputs(false); 912 } 913 914 // Lipo if necessary, we do it this way because we need to set the arch flag 915 // so that -Xarch_ gets overwritten. 916 if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing) 917 Actions.append(Inputs.begin(), Inputs.end()); 918 else 919 Actions.push_back(new LipoJobAction(Inputs, Act->getType())); 920 921 // Handle debug info queries. 922 Arg *A = Args.getLastArg(options::OPT_g_Group); 923 if (A && !A->getOption().matches(options::OPT_g0) && 924 !A->getOption().matches(options::OPT_gstabs) && 925 ContainsCompileOrAssembleAction(Actions.back())) { 926 927 // Add a 'dsymutil' step if necessary, when debug info is enabled and we 928 // have a compile input. We need to run 'dsymutil' ourselves in such cases 929 // because the debug info will refer to a temporary object file which is 930 // will be removed at the end of the compilation process. 931 if (Act->getType() == types::TY_Image) { 932 ActionList Inputs; 933 Inputs.push_back(Actions.back()); 934 Actions.pop_back(); 935 Actions.push_back(new DsymutilJobAction(Inputs, types::TY_dSYM)); 936 } 937 938 // Verify the output (debug information only) if we passed '-verify'. 939 if (Args.hasArg(options::OPT_verify)) { 940 ActionList VerifyInputs; 941 VerifyInputs.push_back(Actions.back()); 942 Actions.pop_back(); 943 Actions.push_back(new VerifyJobAction(VerifyInputs, 944 types::TY_Nothing)); 945 } 946 } 947 } 948} 949 950// Construct a the list of inputs and their types. 951void Driver::BuildInputs(const ToolChain &TC, const DerivedArgList &Args, 952 InputList &Inputs) const { 953 // Track the current user specified (-x) input. We also explicitly track the 954 // argument used to set the type; we only want to claim the type when we 955 // actually use it, so we warn about unused -x arguments. 956 types::ID InputType = types::TY_Nothing; 957 Arg *InputTypeArg = 0; 958 959 for (ArgList::const_iterator it = Args.begin(), ie = Args.end(); 960 it != ie; ++it) { 961 Arg *A = *it; 962 963 if (isa<InputOption>(A->getOption())) { 964 const char *Value = A->getValue(Args); 965 types::ID Ty = types::TY_INVALID; 966 967 // Infer the input type if necessary. 968 if (InputType == types::TY_Nothing) { 969 // If there was an explicit arg for this, claim it. 970 if (InputTypeArg) 971 InputTypeArg->claim(); 972 973 // stdin must be handled specially. 974 if (memcmp(Value, "-", 2) == 0) { 975 // If running with -E, treat as a C input (this changes the builtin 976 // macros, for example). This may be overridden by -ObjC below. 977 // 978 // Otherwise emit an error but still use a valid type to avoid 979 // spurious errors (e.g., no inputs). 980 if (!Args.hasArgNoClaim(options::OPT_E) && !CCCIsCPP) 981 Diag(clang::diag::err_drv_unknown_stdin_type); 982 Ty = types::TY_C; 983 } else { 984 // Otherwise lookup by extension. 985 // Fallback is C if invoked as C preprocessor or Object otherwise. 986 // We use a host hook here because Darwin at least has its own 987 // idea of what .s is. 988 if (const char *Ext = strrchr(Value, '.')) 989 Ty = TC.LookupTypeForExtension(Ext + 1); 990 991 if (Ty == types::TY_INVALID) { 992 if (CCCIsCPP) 993 Ty = types::TY_C; 994 else 995 Ty = types::TY_Object; 996 } 997 998 // If the driver is invoked as C++ compiler (like clang++ or c++) it 999 // should autodetect some input files as C++ for g++ compatibility. 1000 if (CCCIsCXX) { 1001 types::ID OldTy = Ty; 1002 Ty = types::lookupCXXTypeForCType(Ty); 1003 1004 if (Ty != OldTy) 1005 Diag(clang::diag::warn_drv_treating_input_as_cxx) 1006 << getTypeName(OldTy) << getTypeName(Ty); 1007 } 1008 } 1009 1010 // -ObjC and -ObjC++ override the default language, but only for "source 1011 // files". We just treat everything that isn't a linker input as a 1012 // source file. 1013 // 1014 // FIXME: Clean this up if we move the phase sequence into the type. 1015 if (Ty != types::TY_Object) { 1016 if (Args.hasArg(options::OPT_ObjC)) 1017 Ty = types::TY_ObjC; 1018 else if (Args.hasArg(options::OPT_ObjCXX)) 1019 Ty = types::TY_ObjCXX; 1020 } 1021 } else { 1022 assert(InputTypeArg && "InputType set w/o InputTypeArg"); 1023 InputTypeArg->claim(); 1024 Ty = InputType; 1025 } 1026 1027 // Check that the file exists, if enabled. 1028 if (CheckInputsExist && memcmp(Value, "-", 2) != 0) { 1029 SmallString<64> Path(Value); 1030 if (Arg *WorkDir = Args.getLastArg(options::OPT_working_directory)) { 1031 SmallString<64> Directory(WorkDir->getValue(Args)); 1032 if (llvm::sys::path::is_absolute(Directory.str())) { 1033 llvm::sys::path::append(Directory, Value); 1034 Path.assign(Directory); 1035 } 1036 } 1037 1038 bool exists = false; 1039 if (llvm::sys::fs::exists(Path.c_str(), exists) || !exists) 1040 Diag(clang::diag::err_drv_no_such_file) << Path.str(); 1041 else 1042 Inputs.push_back(std::make_pair(Ty, A)); 1043 } else 1044 Inputs.push_back(std::make_pair(Ty, A)); 1045 1046 } else if (A->getOption().isLinkerInput()) { 1047 // Just treat as object type, we could make a special type for this if 1048 // necessary. 1049 Inputs.push_back(std::make_pair(types::TY_Object, A)); 1050 1051 } else if (A->getOption().matches(options::OPT_x)) { 1052 InputTypeArg = A; 1053 InputType = types::lookupTypeForTypeSpecifier(A->getValue(Args)); 1054 A->claim(); 1055 1056 // Follow gcc behavior and treat as linker input for invalid -x 1057 // options. Its not clear why we shouldn't just revert to unknown; but 1058 // this isn't very important, we might as well be bug compatible. 1059 if (!InputType) { 1060 Diag(clang::diag::err_drv_unknown_language) << A->getValue(Args); 1061 InputType = types::TY_Object; 1062 } 1063 } 1064 } 1065 if (CCCIsCPP && Inputs.empty()) { 1066 // If called as standalone preprocessor, stdin is processed 1067 // if no other input is present. 1068 unsigned Index = Args.getBaseArgs().MakeIndex("-"); 1069 Arg *A = Opts->ParseOneArg(Args, Index); 1070 A->claim(); 1071 Inputs.push_back(std::make_pair(types::TY_C, A)); 1072 } 1073} 1074 1075void Driver::BuildActions(const ToolChain &TC, const DerivedArgList &Args, 1076 const InputList &Inputs, ActionList &Actions) const { 1077 llvm::PrettyStackTraceString CrashInfo("Building compilation actions"); 1078 1079 if (!SuppressMissingInputWarning && Inputs.empty()) { 1080 Diag(clang::diag::err_drv_no_input_files); 1081 return; 1082 } 1083 1084 Arg *FinalPhaseArg; 1085 phases::ID FinalPhase = getFinalPhase(Args, &FinalPhaseArg); 1086 1087 // Reject -Z* at the top level, these options should never have been exposed 1088 // by gcc. 1089 if (Arg *A = Args.getLastArg(options::OPT_Z_Joined)) 1090 Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args); 1091 1092 // Construct the actions to perform. 1093 ActionList LinkerInputs; 1094 unsigned NumSteps = 0; 1095 for (unsigned i = 0, e = Inputs.size(); i != e; ++i) { 1096 types::ID InputType = Inputs[i].first; 1097 const Arg *InputArg = Inputs[i].second; 1098 1099 NumSteps = types::getNumCompilationPhases(InputType); 1100 assert(NumSteps && "Invalid number of steps!"); 1101 1102 // If the first step comes after the final phase we are doing as part of 1103 // this compilation, warn the user about it. 1104 phases::ID InitialPhase = types::getCompilationPhase(InputType, 0); 1105 if (InitialPhase > FinalPhase) { 1106 // Claim here to avoid the more general unused warning. 1107 InputArg->claim(); 1108 1109 // Suppress all unused style warnings with -Qunused-arguments 1110 if (Args.hasArg(options::OPT_Qunused_arguments)) 1111 continue; 1112 1113 // Special case '-E' warning on a previously preprocessed file to make 1114 // more sense. 1115 if (InitialPhase == phases::Compile && FinalPhase == phases::Preprocess && 1116 getPreprocessedType(InputType) == types::TY_INVALID) 1117 Diag(clang::diag::warn_drv_preprocessed_input_file_unused) 1118 << InputArg->getAsString(Args) 1119 << FinalPhaseArg->getOption().getName(); 1120 else 1121 Diag(clang::diag::warn_drv_input_file_unused) 1122 << InputArg->getAsString(Args) 1123 << getPhaseName(InitialPhase) 1124 << FinalPhaseArg->getOption().getName(); 1125 continue; 1126 } 1127 1128 // Build the pipeline for this file. 1129 OwningPtr<Action> Current(new InputAction(*InputArg, InputType)); 1130 for (unsigned i = 0; i != NumSteps; ++i) { 1131 phases::ID Phase = types::getCompilationPhase(InputType, i); 1132 1133 // We are done if this step is past what the user requested. 1134 if (Phase > FinalPhase) 1135 break; 1136 1137 // Queue linker inputs. 1138 if (Phase == phases::Link) { 1139 assert(i + 1 == NumSteps && "linking must be final compilation step."); 1140 LinkerInputs.push_back(Current.take()); 1141 break; 1142 } 1143 1144 // Some types skip the assembler phase (e.g., llvm-bc), but we can't 1145 // encode this in the steps because the intermediate type depends on 1146 // arguments. Just special case here. 1147 if (Phase == phases::Assemble && Current->getType() != types::TY_PP_Asm) 1148 continue; 1149 1150 // Otherwise construct the appropriate action. 1151 Current.reset(ConstructPhaseAction(Args, Phase, Current.take())); 1152 if (Current->getType() == types::TY_Nothing) 1153 break; 1154 } 1155 1156 // If we ended with something, add to the output list. 1157 if (Current) 1158 Actions.push_back(Current.take()); 1159 } 1160 1161 // Add a link action if necessary. 1162 if (!LinkerInputs.empty()) 1163 Actions.push_back(new LinkJobAction(LinkerInputs, types::TY_Image)); 1164 1165 // If we are linking, claim any options which are obviously only used for 1166 // compilation. 1167 if (FinalPhase == phases::Link && (NumSteps == 1)) 1168 Args.ClaimAllArgs(options::OPT_CompileOnly_Group); 1169} 1170 1171Action *Driver::ConstructPhaseAction(const ArgList &Args, phases::ID Phase, 1172 Action *Input) const { 1173 llvm::PrettyStackTraceString CrashInfo("Constructing phase actions"); 1174 // Build the appropriate action. 1175 switch (Phase) { 1176 case phases::Link: llvm_unreachable("link action invalid here."); 1177 case phases::Preprocess: { 1178 types::ID OutputTy; 1179 // -{M, MM} alter the output type. 1180 if (Args.hasArg(options::OPT_M, options::OPT_MM)) { 1181 OutputTy = types::TY_Dependencies; 1182 } else { 1183 OutputTy = types::getPreprocessedType(Input->getType()); 1184 assert(OutputTy != types::TY_INVALID && 1185 "Cannot preprocess this input type!"); 1186 } 1187 return new PreprocessJobAction(Input, OutputTy); 1188 } 1189 case phases::Precompile: 1190 return new PrecompileJobAction(Input, types::TY_PCH); 1191 case phases::Compile: { 1192 if (Args.hasArg(options::OPT_fsyntax_only)) { 1193 return new CompileJobAction(Input, types::TY_Nothing); 1194 } else if (Args.hasArg(options::OPT_rewrite_objc)) { 1195 return new CompileJobAction(Input, types::TY_RewrittenObjC); 1196 } else if (Args.hasArg(options::OPT_rewrite_legacy_objc)) { 1197 return new CompileJobAction(Input, types::TY_RewrittenLegacyObjC); 1198 } else if (Args.hasArg(options::OPT__analyze, options::OPT__analyze_auto)) { 1199 return new AnalyzeJobAction(Input, types::TY_Plist); 1200 } else if (Args.hasArg(options::OPT__migrate)) { 1201 return new MigrateJobAction(Input, types::TY_Remap); 1202 } else if (Args.hasArg(options::OPT_emit_ast)) { 1203 return new CompileJobAction(Input, types::TY_AST); 1204 } else if (IsUsingLTO(Args)) { 1205 types::ID Output = 1206 Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC; 1207 return new CompileJobAction(Input, Output); 1208 } else { 1209 return new CompileJobAction(Input, types::TY_PP_Asm); 1210 } 1211 } 1212 case phases::Assemble: 1213 return new AssembleJobAction(Input, types::TY_Object); 1214 } 1215 1216 llvm_unreachable("invalid phase in ConstructPhaseAction"); 1217} 1218 1219bool Driver::IsUsingLTO(const ArgList &Args) const { 1220 // Check for -emit-llvm or -flto. 1221 if (Args.hasArg(options::OPT_emit_llvm) || 1222 Args.hasFlag(options::OPT_flto, options::OPT_fno_lto, false)) 1223 return true; 1224 1225 // Check for -O4. 1226 if (const Arg *A = Args.getLastArg(options::OPT_O_Group)) 1227 return A->getOption().matches(options::OPT_O4); 1228 1229 return false; 1230} 1231 1232void Driver::BuildJobs(Compilation &C) const { 1233 llvm::PrettyStackTraceString CrashInfo("Building compilation jobs"); 1234 1235 Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o); 1236 1237 // It is an error to provide a -o option if we are making multiple output 1238 // files. 1239 if (FinalOutput) { 1240 unsigned NumOutputs = 0; 1241 for (ActionList::const_iterator it = C.getActions().begin(), 1242 ie = C.getActions().end(); it != ie; ++it) 1243 if ((*it)->getType() != types::TY_Nothing) 1244 ++NumOutputs; 1245 1246 if (NumOutputs > 1) { 1247 Diag(clang::diag::err_drv_output_argument_with_multiple_files); 1248 FinalOutput = 0; 1249 } 1250 } 1251 1252 for (ActionList::const_iterator it = C.getActions().begin(), 1253 ie = C.getActions().end(); it != ie; ++it) { 1254 Action *A = *it; 1255 1256 // If we are linking an image for multiple archs then the linker wants 1257 // -arch_multiple and -final_output <final image name>. Unfortunately, this 1258 // doesn't fit in cleanly because we have to pass this information down. 1259 // 1260 // FIXME: This is a hack; find a cleaner way to integrate this into the 1261 // process. 1262 const char *LinkingOutput = 0; 1263 if (isa<LipoJobAction>(A)) { 1264 if (FinalOutput) 1265 LinkingOutput = FinalOutput->getValue(C.getArgs()); 1266 else 1267 LinkingOutput = DefaultImageName.c_str(); 1268 } 1269 1270 InputInfo II; 1271 BuildJobsForAction(C, A, &C.getDefaultToolChain(), 1272 /*BoundArch*/0, 1273 /*AtTopLevel*/ true, 1274 /*LinkingOutput*/ LinkingOutput, 1275 II); 1276 } 1277 1278 // If the user passed -Qunused-arguments or there were errors, don't warn 1279 // about any unused arguments. 1280 if (Diags.hasErrorOccurred() || 1281 C.getArgs().hasArg(options::OPT_Qunused_arguments)) 1282 return; 1283 1284 // Claim -### here. 1285 (void) C.getArgs().hasArg(options::OPT__HASH_HASH_HASH); 1286 1287 for (ArgList::const_iterator it = C.getArgs().begin(), ie = C.getArgs().end(); 1288 it != ie; ++it) { 1289 Arg *A = *it; 1290 1291 // FIXME: It would be nice to be able to send the argument to the 1292 // DiagnosticsEngine, so that extra values, position, and so on could be 1293 // printed. 1294 if (!A->isClaimed()) { 1295 if (A->getOption().hasNoArgumentUnused()) 1296 continue; 1297 1298 // Suppress the warning automatically if this is just a flag, and it is an 1299 // instance of an argument we already claimed. 1300 const Option &Opt = A->getOption(); 1301 if (isa<FlagOption>(Opt)) { 1302 bool DuplicateClaimed = false; 1303 1304 for (arg_iterator it = C.getArgs().filtered_begin(&Opt), 1305 ie = C.getArgs().filtered_end(); it != ie; ++it) { 1306 if ((*it)->isClaimed()) { 1307 DuplicateClaimed = true; 1308 break; 1309 } 1310 } 1311 1312 if (DuplicateClaimed) 1313 continue; 1314 } 1315 1316 Diag(clang::diag::warn_drv_unused_argument) 1317 << A->getAsString(C.getArgs()); 1318 } 1319 } 1320} 1321 1322static const Tool &SelectToolForJob(Compilation &C, const ToolChain *TC, 1323 const JobAction *JA, 1324 const ActionList *&Inputs) { 1325 const Tool *ToolForJob = 0; 1326 1327 // See if we should look for a compiler with an integrated assembler. We match 1328 // bottom up, so what we are actually looking for is an assembler job with a 1329 // compiler input. 1330 1331 if (C.getArgs().hasFlag(options::OPT_integrated_as, 1332 options::OPT_no_integrated_as, 1333 TC->IsIntegratedAssemblerDefault()) && 1334 !C.getArgs().hasArg(options::OPT_save_temps) && 1335 isa<AssembleJobAction>(JA) && 1336 Inputs->size() == 1 && isa<CompileJobAction>(*Inputs->begin())) { 1337 const Tool &Compiler = TC->SelectTool( 1338 C, cast<JobAction>(**Inputs->begin()), (*Inputs)[0]->getInputs()); 1339 if (Compiler.hasIntegratedAssembler()) { 1340 Inputs = &(*Inputs)[0]->getInputs(); 1341 ToolForJob = &Compiler; 1342 } 1343 } 1344 1345 // Otherwise use the tool for the current job. 1346 if (!ToolForJob) 1347 ToolForJob = &TC->SelectTool(C, *JA, *Inputs); 1348 1349 // See if we should use an integrated preprocessor. We do so when we have 1350 // exactly one input, since this is the only use case we care about 1351 // (irrelevant since we don't support combine yet). 1352 if (Inputs->size() == 1 && isa<PreprocessJobAction>(*Inputs->begin()) && 1353 !C.getArgs().hasArg(options::OPT_no_integrated_cpp) && 1354 !C.getArgs().hasArg(options::OPT_traditional_cpp) && 1355 !C.getArgs().hasArg(options::OPT_save_temps) && 1356 ToolForJob->hasIntegratedCPP()) 1357 Inputs = &(*Inputs)[0]->getInputs(); 1358 1359 return *ToolForJob; 1360} 1361 1362void Driver::BuildJobsForAction(Compilation &C, 1363 const Action *A, 1364 const ToolChain *TC, 1365 const char *BoundArch, 1366 bool AtTopLevel, 1367 const char *LinkingOutput, 1368 InputInfo &Result) const { 1369 llvm::PrettyStackTraceString CrashInfo("Building compilation jobs"); 1370 1371 if (const InputAction *IA = dyn_cast<InputAction>(A)) { 1372 // FIXME: It would be nice to not claim this here; maybe the old scheme of 1373 // just using Args was better? 1374 const Arg &Input = IA->getInputArg(); 1375 Input.claim(); 1376 if (Input.getOption().matches(options::OPT_INPUT)) { 1377 const char *Name = Input.getValue(C.getArgs()); 1378 Result = InputInfo(Name, A->getType(), Name); 1379 } else 1380 Result = InputInfo(&Input, A->getType(), ""); 1381 return; 1382 } 1383 1384 if (const BindArchAction *BAA = dyn_cast<BindArchAction>(A)) { 1385 const ToolChain *TC; 1386 const char *ArchName = BAA->getArchName(); 1387 1388 if (ArchName) 1389 TC = &getToolChain(C.getArgs(), ArchName); 1390 else 1391 TC = &C.getDefaultToolChain(); 1392 1393 BuildJobsForAction(C, *BAA->begin(), TC, BAA->getArchName(), 1394 AtTopLevel, LinkingOutput, Result); 1395 return; 1396 } 1397 1398 const ActionList *Inputs = &A->getInputs(); 1399 1400 const JobAction *JA = cast<JobAction>(A); 1401 const Tool &T = SelectToolForJob(C, TC, JA, Inputs); 1402 1403 // Only use pipes when there is exactly one input. 1404 InputInfoList InputInfos; 1405 for (ActionList::const_iterator it = Inputs->begin(), ie = Inputs->end(); 1406 it != ie; ++it) { 1407 // Treat dsymutil sub-jobs as being at the top-level too, they shouldn't get 1408 // temporary output names. 1409 // 1410 // FIXME: Clean this up. 1411 bool SubJobAtTopLevel = false; 1412 if (AtTopLevel && isa<DsymutilJobAction>(A)) 1413 SubJobAtTopLevel = true; 1414 1415 // Also treat verify sub-jobs as being at the top-level. They don't 1416 // produce any output and so don't need temporary output names. 1417 if (AtTopLevel && isa<VerifyJobAction>(A)) 1418 SubJobAtTopLevel = true; 1419 1420 InputInfo II; 1421 BuildJobsForAction(C, *it, TC, BoundArch, 1422 SubJobAtTopLevel, LinkingOutput, II); 1423 InputInfos.push_back(II); 1424 } 1425 1426 // Always use the first input as the base input. 1427 const char *BaseInput = InputInfos[0].getBaseInput(); 1428 1429 // ... except dsymutil actions, which use their actual input as the base 1430 // input. 1431 if (JA->getType() == types::TY_dSYM) 1432 BaseInput = InputInfos[0].getFilename(); 1433 1434 // Determine the place to write output to, if any. 1435 if (JA->getType() == types::TY_Nothing) { 1436 Result = InputInfo(A->getType(), BaseInput); 1437 } else { 1438 Result = InputInfo(GetNamedOutputPath(C, *JA, BaseInput, AtTopLevel), 1439 A->getType(), BaseInput); 1440 } 1441 1442 if (CCCPrintBindings && !CCGenDiagnostics) { 1443 llvm::errs() << "# \"" << T.getToolChain().getTripleString() << '"' 1444 << " - \"" << T.getName() << "\", inputs: ["; 1445 for (unsigned i = 0, e = InputInfos.size(); i != e; ++i) { 1446 llvm::errs() << InputInfos[i].getAsString(); 1447 if (i + 1 != e) 1448 llvm::errs() << ", "; 1449 } 1450 llvm::errs() << "], output: " << Result.getAsString() << "\n"; 1451 } else { 1452 T.ConstructJob(C, *JA, Result, InputInfos, 1453 C.getArgsForToolChain(TC, BoundArch), LinkingOutput); 1454 } 1455} 1456 1457const char *Driver::GetNamedOutputPath(Compilation &C, 1458 const JobAction &JA, 1459 const char *BaseInput, 1460 bool AtTopLevel) const { 1461 llvm::PrettyStackTraceString CrashInfo("Computing output path"); 1462 // Output to a user requested destination? 1463 if (AtTopLevel && !isa<DsymutilJobAction>(JA) && 1464 !isa<VerifyJobAction>(JA)) { 1465 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) 1466 return C.addResultFile(FinalOutput->getValue(C.getArgs())); 1467 } 1468 1469 // Default to writing to stdout? 1470 if (AtTopLevel && isa<PreprocessJobAction>(JA) && !CCGenDiagnostics) 1471 return "-"; 1472 1473 // Output to a temporary file? 1474 if ((!AtTopLevel && !C.getArgs().hasArg(options::OPT_save_temps)) || 1475 CCGenDiagnostics) { 1476 StringRef Name = llvm::sys::path::filename(BaseInput); 1477 std::pair<StringRef, StringRef> Split = Name.split('.'); 1478 std::string TmpName = 1479 GetTemporaryPath(Split.first, types::getTypeTempSuffix(JA.getType())); 1480 return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str())); 1481 } 1482 1483 SmallString<128> BasePath(BaseInput); 1484 StringRef BaseName; 1485 1486 // Dsymutil actions should use the full path. 1487 if (isa<DsymutilJobAction>(JA) || isa<VerifyJobAction>(JA)) 1488 BaseName = BasePath; 1489 else 1490 BaseName = llvm::sys::path::filename(BasePath); 1491 1492 // Determine what the derived output name should be. 1493 const char *NamedOutput; 1494 if (JA.getType() == types::TY_Image) { 1495 NamedOutput = DefaultImageName.c_str(); 1496 } else { 1497 const char *Suffix = types::getTypeTempSuffix(JA.getType()); 1498 assert(Suffix && "All types used for output should have a suffix."); 1499 1500 std::string::size_type End = std::string::npos; 1501 if (!types::appendSuffixForType(JA.getType())) 1502 End = BaseName.rfind('.'); 1503 std::string Suffixed(BaseName.substr(0, End)); 1504 Suffixed += '.'; 1505 Suffixed += Suffix; 1506 NamedOutput = C.getArgs().MakeArgString(Suffixed.c_str()); 1507 } 1508 1509 // If we're saving temps and the temp file conflicts with the input file, 1510 // then avoid overwriting input file. 1511 if (!AtTopLevel && C.getArgs().hasArg(options::OPT_save_temps) && 1512 NamedOutput == BaseName) { 1513 1514 bool SameFile = false; 1515 SmallString<256> Result; 1516 llvm::sys::fs::current_path(Result); 1517 llvm::sys::path::append(Result, BaseName); 1518 llvm::sys::fs::equivalent(BaseInput, Result.c_str(), SameFile); 1519 // Must share the same path to conflict. 1520 if (SameFile) { 1521 StringRef Name = llvm::sys::path::filename(BaseInput); 1522 std::pair<StringRef, StringRef> Split = Name.split('.'); 1523 std::string TmpName = 1524 GetTemporaryPath(Split.first, types::getTypeTempSuffix(JA.getType())); 1525 return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str())); 1526 } 1527 } 1528 1529 // As an annoying special case, PCH generation doesn't strip the pathname. 1530 if (JA.getType() == types::TY_PCH) { 1531 llvm::sys::path::remove_filename(BasePath); 1532 if (BasePath.empty()) 1533 BasePath = NamedOutput; 1534 else 1535 llvm::sys::path::append(BasePath, NamedOutput); 1536 return C.addResultFile(C.getArgs().MakeArgString(BasePath.c_str())); 1537 } else { 1538 return C.addResultFile(NamedOutput); 1539 } 1540} 1541 1542std::string Driver::GetFilePath(const char *Name, const ToolChain &TC) const { 1543 // Respect a limited subset of the '-Bprefix' functionality in GCC by 1544 // attempting to use this prefix when lokup up program paths. 1545 for (Driver::prefix_list::const_iterator it = PrefixDirs.begin(), 1546 ie = PrefixDirs.end(); it != ie; ++it) { 1547 std::string Dir(*it); 1548 if (Dir.empty()) 1549 continue; 1550 if (Dir[0] == '=') 1551 Dir = SysRoot + Dir.substr(1); 1552 llvm::sys::Path P(Dir); 1553 P.appendComponent(Name); 1554 bool Exists; 1555 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) 1556 return P.str(); 1557 } 1558 1559 llvm::sys::Path P(ResourceDir); 1560 P.appendComponent(Name); 1561 bool Exists; 1562 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) 1563 return P.str(); 1564 1565 const ToolChain::path_list &List = TC.getFilePaths(); 1566 for (ToolChain::path_list::const_iterator 1567 it = List.begin(), ie = List.end(); it != ie; ++it) { 1568 std::string Dir(*it); 1569 if (Dir.empty()) 1570 continue; 1571 if (Dir[0] == '=') 1572 Dir = SysRoot + Dir.substr(1); 1573 llvm::sys::Path P(Dir); 1574 P.appendComponent(Name); 1575 bool Exists; 1576 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) 1577 return P.str(); 1578 } 1579 1580 return Name; 1581} 1582 1583static bool isPathExecutable(llvm::sys::Path &P, bool WantFile) { 1584 bool Exists; 1585 return (WantFile ? !llvm::sys::fs::exists(P.str(), Exists) && Exists 1586 : P.canExecute()); 1587} 1588 1589std::string Driver::GetProgramPath(const char *Name, const ToolChain &TC, 1590 bool WantFile) const { 1591 // FIXME: Needs a better variable than DefaultTargetTriple 1592 std::string TargetSpecificExecutable(DefaultTargetTriple + "-" + Name); 1593 // Respect a limited subset of the '-Bprefix' functionality in GCC by 1594 // attempting to use this prefix when lokup up program paths. 1595 for (Driver::prefix_list::const_iterator it = PrefixDirs.begin(), 1596 ie = PrefixDirs.end(); it != ie; ++it) { 1597 llvm::sys::Path P(*it); 1598 P.appendComponent(TargetSpecificExecutable); 1599 if (isPathExecutable(P, WantFile)) return P.str(); 1600 P.eraseComponent(); 1601 P.appendComponent(Name); 1602 if (isPathExecutable(P, WantFile)) return P.str(); 1603 } 1604 1605 const ToolChain::path_list &List = TC.getProgramPaths(); 1606 for (ToolChain::path_list::const_iterator 1607 it = List.begin(), ie = List.end(); it != ie; ++it) { 1608 llvm::sys::Path P(*it); 1609 P.appendComponent(TargetSpecificExecutable); 1610 if (isPathExecutable(P, WantFile)) return P.str(); 1611 P.eraseComponent(); 1612 P.appendComponent(Name); 1613 if (isPathExecutable(P, WantFile)) return P.str(); 1614 } 1615 1616 // If all else failed, search the path. 1617 llvm::sys::Path 1618 P(llvm::sys::Program::FindProgramByName(TargetSpecificExecutable)); 1619 if (!P.empty()) 1620 return P.str(); 1621 1622 P = llvm::sys::Path(llvm::sys::Program::FindProgramByName(Name)); 1623 if (!P.empty()) 1624 return P.str(); 1625 1626 return Name; 1627} 1628 1629std::string Driver::GetTemporaryPath(StringRef Prefix, const char *Suffix) 1630 const { 1631 // FIXME: This is lame; sys::Path should provide this function (in particular, 1632 // it should know how to find the temporary files dir). 1633 std::string Error; 1634 const char *TmpDir = ::getenv("TMPDIR"); 1635 if (!TmpDir) 1636 TmpDir = ::getenv("TEMP"); 1637 if (!TmpDir) 1638 TmpDir = ::getenv("TMP"); 1639 if (!TmpDir) 1640 TmpDir = "/tmp"; 1641 llvm::sys::Path P(TmpDir); 1642 P.appendComponent(Prefix); 1643 if (P.makeUnique(false, &Error)) { 1644 Diag(clang::diag::err_unable_to_make_temp) << Error; 1645 return ""; 1646 } 1647 1648 // FIXME: Grumble, makeUnique sometimes leaves the file around!? PR3837. 1649 P.eraseFromDisk(false, 0); 1650 1651 P.appendSuffix(Suffix); 1652 return P.str(); 1653} 1654 1655/// \brief Compute target triple from args. 1656/// 1657/// This routine provides the logic to compute a target triple from various 1658/// args passed to the driver and the default triple string. 1659static llvm::Triple computeTargetTriple(StringRef DefaultTargetTriple, 1660 const ArgList &Args, 1661 StringRef DarwinArchName) { 1662 // FIXME: Already done in Compilation *Driver::BuildCompilation 1663 if (const Arg *A = Args.getLastArg(options::OPT_target)) 1664 DefaultTargetTriple = A->getValue(Args); 1665 1666 llvm::Triple Target(llvm::Triple::normalize(DefaultTargetTriple)); 1667 1668 // Handle Darwin-specific options available here. 1669 if (Target.isOSDarwin()) { 1670 // If an explict Darwin arch name is given, that trumps all. 1671 if (!DarwinArchName.empty()) { 1672 Target.setArch( 1673 llvm::Triple::getArchTypeForDarwinArchName(DarwinArchName)); 1674 return Target; 1675 } 1676 1677 // Handle the Darwin '-arch' flag. 1678 if (Arg *A = Args.getLastArg(options::OPT_arch)) { 1679 llvm::Triple::ArchType DarwinArch 1680 = llvm::Triple::getArchTypeForDarwinArchName(A->getValue(Args)); 1681 if (DarwinArch != llvm::Triple::UnknownArch) 1682 Target.setArch(DarwinArch); 1683 } 1684 } 1685 1686 // Skip further flag support on OSes which don't support '-m32' or '-m64'. 1687 if (Target.getArchName() == "tce" || 1688 Target.getOS() == llvm::Triple::AuroraUX || 1689 Target.getOS() == llvm::Triple::Minix) 1690 return Target; 1691 1692 // Handle pseudo-target flags '-m32' and '-m64'. 1693 // FIXME: Should this information be in llvm::Triple? 1694 if (Arg *A = Args.getLastArg(options::OPT_m32, options::OPT_m64)) { 1695 if (A->getOption().matches(options::OPT_m32)) { 1696 if (Target.getArch() == llvm::Triple::x86_64) 1697 Target.setArch(llvm::Triple::x86); 1698 if (Target.getArch() == llvm::Triple::ppc64) 1699 Target.setArch(llvm::Triple::ppc); 1700 } else { 1701 if (Target.getArch() == llvm::Triple::x86) 1702 Target.setArch(llvm::Triple::x86_64); 1703 if (Target.getArch() == llvm::Triple::ppc) 1704 Target.setArch(llvm::Triple::ppc64); 1705 } 1706 } 1707 1708 return Target; 1709} 1710 1711const ToolChain &Driver::getToolChain(const ArgList &Args, 1712 StringRef DarwinArchName) const { 1713 llvm::Triple Target = computeTargetTriple(DefaultTargetTriple, Args, 1714 DarwinArchName); 1715 1716 ToolChain *&TC = ToolChains[Target.str()]; 1717 if (!TC) { 1718 switch (Target.getOS()) { 1719 case llvm::Triple::AuroraUX: 1720 TC = new toolchains::AuroraUX(*this, Target, Args); 1721 break; 1722 case llvm::Triple::Darwin: 1723 case llvm::Triple::MacOSX: 1724 case llvm::Triple::IOS: 1725 if (Target.getArch() == llvm::Triple::x86 || 1726 Target.getArch() == llvm::Triple::x86_64 || 1727 Target.getArch() == llvm::Triple::arm || 1728 Target.getArch() == llvm::Triple::thumb) 1729 TC = new toolchains::DarwinClang(*this, Target); 1730 else 1731 TC = new toolchains::Darwin_Generic_GCC(*this, Target, Args); 1732 break; 1733 case llvm::Triple::DragonFly: 1734 TC = new toolchains::DragonFly(*this, Target, Args); 1735 break; 1736 case llvm::Triple::OpenBSD: 1737 TC = new toolchains::OpenBSD(*this, Target, Args); 1738 break; 1739 case llvm::Triple::NetBSD: 1740 TC = new toolchains::NetBSD(*this, Target, Args); 1741 break; 1742 case llvm::Triple::FreeBSD: 1743 TC = new toolchains::FreeBSD(*this, Target, Args); 1744 break; 1745 case llvm::Triple::Minix: 1746 TC = new toolchains::Minix(*this, Target, Args); 1747 break; 1748 case llvm::Triple::Linux: 1749 if (Target.getArch() == llvm::Triple::hexagon) 1750 TC = new toolchains::Hexagon_TC(*this, Target); 1751 else 1752 TC = new toolchains::Linux(*this, Target, Args); 1753 break; 1754 case llvm::Triple::Solaris: 1755 TC = new toolchains::Solaris(*this, Target, Args); 1756 break; 1757 case llvm::Triple::Win32: 1758 TC = new toolchains::Windows(*this, Target); 1759 break; 1760 case llvm::Triple::MinGW32: 1761 // FIXME: We need a MinGW toolchain. Fallthrough for now. 1762 default: 1763 // TCE is an OSless target 1764 if (Target.getArchName() == "tce") { 1765 TC = new toolchains::TCEToolChain(*this, Target); 1766 break; 1767 } 1768 1769 TC = new toolchains::Generic_GCC(*this, Target, Args); 1770 break; 1771 } 1772 } 1773 return *TC; 1774} 1775 1776bool Driver::ShouldUseClangCompiler(const Compilation &C, const JobAction &JA, 1777 const llvm::Triple &Triple) const { 1778 // Check if user requested no clang, or clang doesn't understand this type (we 1779 // only handle single inputs for now). 1780 if (!CCCUseClang || JA.size() != 1 || 1781 !types::isAcceptedByClang((*JA.begin())->getType())) 1782 return false; 1783 1784 // Otherwise make sure this is an action clang understands. 1785 if (isa<PreprocessJobAction>(JA)) { 1786 if (!CCCUseClangCPP) { 1787 Diag(clang::diag::warn_drv_not_using_clang_cpp); 1788 return false; 1789 } 1790 } else if (!isa<PrecompileJobAction>(JA) && !isa<CompileJobAction>(JA)) 1791 return false; 1792 1793 // Use clang for C++? 1794 if (!CCCUseClangCXX && types::isCXX((*JA.begin())->getType())) { 1795 Diag(clang::diag::warn_drv_not_using_clang_cxx); 1796 return false; 1797 } 1798 1799 // Always use clang for precompiling, AST generation, and rewriting, 1800 // regardless of archs. 1801 if (isa<PrecompileJobAction>(JA) || 1802 types::isOnlyAcceptedByClang(JA.getType())) 1803 return true; 1804 1805 // Finally, don't use clang if this isn't one of the user specified archs to 1806 // build. 1807 if (!CCCClangArchs.empty() && !CCCClangArchs.count(Triple.getArch())) { 1808 Diag(clang::diag::warn_drv_not_using_clang_arch) << Triple.getArchName(); 1809 return false; 1810 } 1811 1812 return true; 1813} 1814 1815/// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and return the 1816/// grouped values as integers. Numbers which are not provided are set to 0. 1817/// 1818/// \return True if the entire string was parsed (9.2), or all groups were 1819/// parsed (10.3.5extrastuff). 1820bool Driver::GetReleaseVersion(const char *Str, unsigned &Major, 1821 unsigned &Minor, unsigned &Micro, 1822 bool &HadExtra) { 1823 HadExtra = false; 1824 1825 Major = Minor = Micro = 0; 1826 if (*Str == '\0') 1827 return true; 1828 1829 char *End; 1830 Major = (unsigned) strtol(Str, &End, 10); 1831 if (*Str != '\0' && *End == '\0') 1832 return true; 1833 if (*End != '.') 1834 return false; 1835 1836 Str = End+1; 1837 Minor = (unsigned) strtol(Str, &End, 10); 1838 if (*Str != '\0' && *End == '\0') 1839 return true; 1840 if (*End != '.') 1841 return false; 1842 1843 Str = End+1; 1844 Micro = (unsigned) strtol(Str, &End, 10); 1845 if (*Str != '\0' && *End == '\0') 1846 return true; 1847 if (Str == End) 1848 return false; 1849 HadExtra = true; 1850 return true; 1851} 1852