Index: include/clang/Driver/ToolChain.h =================================================================== --- include/clang/Driver/ToolChain.h +++ include/clang/Driver/ToolChain.h @@ -89,6 +89,7 @@ protected: MultilibSet Multilibs; + Multilib SelectedMultilib; ToolChain(const Driver &D, const llvm::Triple &T, const llvm::opt::ArgList &Args); @@ -143,6 +144,8 @@ const MultilibSet &getMultilibs() const { return Multilibs; } + const Multilib &getSelectedMultilib() const { return SelectedMultilib; } + const SanitizerArgs& getSanitizerArgs() const; // Returns the Arg * that explicitly turned on/off rtti, or nullptr. Index: lib/Driver/Driver.cpp =================================================================== --- lib/Driver/Driver.cpp +++ lib/Driver/Driver.cpp @@ -2122,6 +2122,11 @@ // FIXME: Needs a better variable than DefaultTargetTriple Names.emplace_back(DefaultTargetTriple + "-" + Tool); Names.emplace_back(Tool); + + // Allow the discovery of tools prefixed with LLVM's default target triple. + std::string LLVMDefaultTargetTriple = llvm::sys::getDefaultTargetTriple(); + if (LLVMDefaultTargetTriple != DefaultTargetTriple) + Names.emplace_back(LLVMDefaultTargetTriple + "-" + Tool); } static bool ScanDirForExecutable(SmallString<128> &Dir, @@ -2217,6 +2222,8 @@ case llvm::Triple::Linux: if (Target.getArch() == llvm::Triple::hexagon) TC = new toolchains::HexagonToolChain(*this, Target, Args); + else if (Target.getVendor() == llvm::Triple::MipsTechnologies) + TC = new toolchains::MipsToolChain(*this, Target, Args); else TC = new toolchains::Linux(*this, Target, Args); break; Index: lib/Driver/ToolChain.cpp =================================================================== --- lib/Driver/ToolChain.cpp +++ lib/Driver/ToolChain.cpp @@ -316,7 +316,6 @@ std::string ToolChain::GetFilePath(const char *Name) const { return D.GetFilePath(Name, *this); - } std::string ToolChain::GetProgramPath(const char *Name) const { Index: lib/Driver/ToolChains.h =================================================================== --- lib/Driver/ToolChains.h +++ lib/Driver/ToolChains.h @@ -724,6 +724,7 @@ llvm::opt::ArgStringList &CC1Args) const override; bool isPIEDefault() const override; SanitizerMask getSupportedSanitizers() const override; + virtual std::string computeSysRoot() const; std::string Linker; std::vector ExtraOpts; @@ -741,7 +742,6 @@ const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args); - std::string computeSysRoot() const; }; class LLVM_LIBRARY_VISIBILITY CudaToolChain : public Linux { @@ -756,6 +756,42 @@ llvm::opt::ArgStringList &CC1Args) const override; }; +class LLVM_LIBRARY_VISIBILITY MipsToolChain : public Linux { +protected: + Tool *buildLinker() const override; + +public: + MipsToolChain(const Driver &D, const llvm::Triple &Triple, + const llvm::opt::ArgList &Args); + + void + AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args) const override; + + CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override; + + void AddClangCXXStdlibIncludeArgs( + const llvm::opt::ArgList &DriverArgs, + llvm::opt::ArgStringList &CC1Args) const override; + + void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, + llvm::opt::ArgStringList &CmdArgs) const override; + + SmallString<128> getCompilerRT(const llvm::opt::ArgList &Args, + StringRef Component, + bool Shared = false) const override; + + std::string computeSysRoot() const override; + + RuntimeLibType GetDefaultRuntimeLibType() const override { + return GCCInstallation.isValid() ? RuntimeLibType::RLT_Libgcc + : RuntimeLibType::RLT_CompilerRT; + } + +private: + std::string LibSuffix; +}; + class LLVM_LIBRARY_VISIBILITY HexagonToolChain : public Linux { protected: GCCVersion GCCLibAndIncVersion; Index: lib/Driver/ToolChains.cpp =================================================================== --- lib/Driver/ToolChains.cpp +++ lib/Driver/ToolChains.cpp @@ -1301,8 +1301,9 @@ "i586-linux-gnu"}; static const char *const MIPSLibDirs[] = {"/lib"}; - static const char *const MIPSTriples[] = { - "mips-linux-gnu", "mips-mti-linux-gnu", "mips-img-linux-gnu"}; + static const char *const MIPSTriples[] = {"mips-linux-gnu", "mips-mti-linux", + "mips-mti-linux-gnu", + "mips-img-linux-gnu"}; static const char *const MIPSELLibDirs[] = {"/lib"}; static const char *const MIPSELTriples[] = { "mipsel-linux-gnu", "mipsel-linux-android", "mips-img-linux-gnu"}; @@ -1691,6 +1692,32 @@ }); } + // Check for Musl toolchain multilibs + MultilibSet MuslMipsMultilibs; + { + auto MArchMipsR2 = makeMultilib("") + .osSuffix("/mips-r2-hard-musl") + .flag("+EB") + .flag("-EL") + .flag("+march=mips32r2"); + + auto MArchMipselR2 = makeMultilib("/mipsel-r2-hard-musl") + .flag("-EB") + .flag("+EL") + .flag("+march=mips32r2"); + + MuslMipsMultilibs = MultilibSet().Either(MArchMipsR2, MArchMipselR2); + + // Specify the callback that computes the include directories. + MuslMipsMultilibs.setIncludeDirsCallback([]( + StringRef InstallDir, StringRef TripleStr, const Multilib &M) { + std::vector Dirs; + Dirs.push_back( + (InstallDir + "/../sysroot" + M.osSuffix() + "/usr/include").str()); + return Dirs; + }); + } + // Check for Code Sourcery toolchain multilibs MultilibSet CSMipsMultilibs; { @@ -1836,6 +1863,16 @@ return false; } + if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies && + TargetTriple.getOS() == llvm::Triple::Linux && + TargetTriple.getEnvironment() == llvm::Triple::UnknownEnvironment) { + if (MuslMipsMultilibs.select(Flags, Result.SelectedMultilib)) { + Result.Multilibs = MuslMipsMultilibs; + return true; + } + return false; + } + if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies && TargetTriple.getOS() == llvm::Triple::Linux && TargetTriple.getEnvironment() == llvm::Triple::GNU) { @@ -2170,19 +2207,173 @@ void Generic_ELF::addClangTargetOptions(const ArgList &DriverArgs, ArgStringList &CC1Args) const { const Generic_GCC::GCCVersion &V = GCCInstallation.getVersion(); + const llvm::Triple &TT = getTriple(); bool UseInitArrayDefault = - getTriple().getArch() == llvm::Triple::aarch64 || - getTriple().getArch() == llvm::Triple::aarch64_be || - (getTriple().getOS() == llvm::Triple::Linux && + TT.getArch() == llvm::Triple::aarch64 || + TT.getArch() == llvm::Triple::aarch64_be || + (TT.getOS() == llvm::Triple::Linux && (!V.isOlderThan(4, 7, 0) || - getTriple().getEnvironment() == llvm::Triple::Android)) || - getTriple().getOS() == llvm::Triple::NaCl; + TT.getEnvironment() == llvm::Triple::Android)) || + TT.getOS() == llvm::Triple::NaCl || + (TT.getVendor() == llvm::Triple::MipsTechnologies && + !TT.hasEnvironment()); if (DriverArgs.hasFlag(options::OPT_fuse_init_array, options::OPT_fno_use_init_array, UseInitArrayDefault)) CC1Args.push_back("-fuse-init-array"); } +/// Mips Toolchain +MipsToolChain::MipsToolChain(const Driver &D, const llvm::Triple &Triple, + const ArgList &Args) + : Linux(D, Triple, Args) { + // If we did find a valid GCC installation, we don't have anything else to do. + if (GCCInstallation.isValid()) + return; + + // Select the correct multilib according to the given arguments. + DetectedMultilibs Result; + findMIPSMultilibs(Triple, "", Args, Result); + Multilibs = Result.Multilibs; + SelectedMultilib = Result.SelectedMultilib; + + // Find out the library suffix based on the ABI. + StringRef CPUName, ABIName; + tools::mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName); + LibSuffix = llvm::StringSwitch(ABIName) + .Case("o32", "") + .Case("n32", "32") + .Case("n64", "64"); + getFilePaths().clear(); + getFilePaths().push_back(computeSysRoot() + "/usr/lib" + LibSuffix); + + // Use LLD by default. + if (!Args.getLastArg(options::OPT_fuse_ld_EQ)) + Linker = GetProgramPath("lld"); +} + +void MipsToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs, + ArgStringList &CC1Args) const { + if (GCCInstallation.isValid()) + return Linux::AddClangSystemIncludeArgs(DriverArgs, CC1Args); + + if (DriverArgs.hasArg(options::OPT_nostdinc)) + return; + + const Driver &D = getDriver(); + + if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) { + SmallString<128> P(D.ResourceDir); + llvm::sys::path::append(P, "include"); + addSystemInclude(DriverArgs, CC1Args, P); + } + + if (DriverArgs.hasArg(options::OPT_nostdlibinc)) + return; + + const auto &Callback = Multilibs.includeDirsCallback(); + if (Callback) { + const auto IncludePaths = + Callback(D.getInstalledDir(), getTripleString(), getSelectedMultilib()); + for (const auto &Path : IncludePaths) + addExternCSystemIncludeIfExists(DriverArgs, CC1Args, Path); + } +} + +Tool *MipsToolChain::buildLinker() const { + return new tools::gnutools::Linker(*this); +} + +std::string MipsToolChain::computeSysRoot() const { + if (GCCInstallation.isValid()) + return Linux::computeSysRoot(); + + if (!getDriver().SysRoot.empty()) + return getDriver().SysRoot + getSelectedMultilib().osSuffix(); + + const std::string InstalledDir(getDriver().getInstalledDir()); + std::string SysRootPath = + InstalledDir + "/../sysroot" + getSelectedMultilib().osSuffix(); + if (llvm::sys::fs::exists(SysRootPath)) + return SysRootPath; + + return std::string(); +} + +ToolChain::CXXStdlibType +MipsToolChain::GetCXXStdlibType(const ArgList &Args) const { + if (GCCInstallation.isValid()) + return Linux::GetCXXStdlibType(Args); + + Arg *A = Args.getLastArg(options::OPT_stdlib_EQ); + if (A) { + StringRef Value = A->getValue(); + if (Value != "libc++") + getDriver().Diag(diag::err_drv_invalid_stdlib_name) + << A->getAsString(Args); + } + + return ToolChain::CST_Libcxx; +} + +void MipsToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, + ArgStringList &CC1Args) const { + if (GCCInstallation.isValid()) { + Linux::AddClangCXXStdlibIncludeArgs(DriverArgs, CC1Args); + return; + } + + if (DriverArgs.hasArg(options::OPT_nostdlibinc) || + DriverArgs.hasArg(options::OPT_nostdincxx)) + return; + + assert((GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) && + "Only -lc++ (aka libcxx) is suported in this toolchain."); + + const auto &Callback = Multilibs.includeDirsCallback(); + if (Callback) { + const auto IncludePaths = + Callback(getDriver().getInstalledDir(), getTripleString(), + getSelectedMultilib()); + for (const auto &Path : IncludePaths) { + if (llvm::sys::fs::exists(Path + "/c++/v1")) { + addSystemInclude(DriverArgs, CC1Args, Path + "/c++/v1"); + break; + } + } + } +} + +void MipsToolChain::AddCXXStdlibLibArgs(const ArgList &Args, + ArgStringList &CmdArgs) const { + if (GCCInstallation.isValid()) { + Linux::AddCXXStdlibLibArgs(Args, CmdArgs); + return; + } + + assert((GetCXXStdlibType(Args) == ToolChain::CST_Libcxx) && + "Only -lc++ (aka libxx) is suported in this toolchain."); + + CmdArgs.push_back("-lc++"); + CmdArgs.push_back("-lc++abi"); + CmdArgs.push_back("-lunwind"); +} + +SmallString<128> MipsToolChain::getCompilerRT(const ArgList &Args, + StringRef Component, + bool Shared) const { + if (GCCInstallation.isValid()) + return Linux::getCompilerRT(Args, Component, Shared); + + SmallString<128> Path(getDriver().ResourceDir); + llvm::sys::path::append(Path, SelectedMultilib.osSuffix(), "lib" + LibSuffix, + getOS()); + llvm::sys::path::append(Path, Twine("libclang_rt." + Component + "-" + + getTriple().getArchName() + + (Shared ? ".so" : ".a"))); + return Path; +} + /// Hexagon Toolchain std::string HexagonToolChain::GetGnuDir(const std::string &InstalledDir, Index: lib/Driver/Tools.cpp =================================================================== --- lib/Driver/Tools.cpp +++ lib/Driver/Tools.cpp @@ -4559,12 +4559,16 @@ } // -fuse-cxa-atexit is default. - if (!Args.hasFlag(options::OPT_fuse_cxa_atexit, - options::OPT_fno_use_cxa_atexit, - !IsWindowsCygnus && !IsWindowsGNU && - getToolChain().getTriple().getOS() != llvm::Triple::Solaris && - getToolChain().getArch() != llvm::Triple::hexagon && - getToolChain().getArch() != llvm::Triple::xcore) || + if (!Args.hasFlag( + options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit, + !IsWindowsCygnus && !IsWindowsGNU && + getToolChain().getTriple().getOS() != llvm::Triple::Solaris && + getToolChain().getArch() != llvm::Triple::hexagon && + getToolChain().getArch() != llvm::Triple::xcore && + getToolChain().getArch() != llvm::Triple::xcore && + ((getToolChain().getTriple().getVendor() != + llvm::Triple::MipsTechnologies) || + getToolChain().getTriple().hasEnvironment())) || KernelOrKext) CmdArgs.push_back("-fno-use-cxa-atexit"); @@ -8108,9 +8112,10 @@ static std::string getLinuxDynamicLinker(const ArgList &Args, const toolchains::Linux &ToolChain) { const llvm::Triple::ArchType Arch = ToolChain.getArch(); + const llvm::Triple &TT = ToolChain.getTriple(); - if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) { - if (ToolChain.getTriple().isArch64Bit()) + if (TT.getEnvironment() == llvm::Triple::Android) { + if (TT.isArch64Bit()) return "/system/bin/linker64"; else return "/system/bin/linker"; @@ -8122,24 +8127,25 @@ else if (Arch == llvm::Triple::aarch64_be) return "/lib/ld-linux-aarch64_be.so.1"; else if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb) { - if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF || + if (TT.getEnvironment() == llvm::Triple::GNUEABIHF || arm::getARMFloatABI(ToolChain, Args) == arm::FloatABI::Hard) return "/lib/ld-linux-armhf.so.3"; else return "/lib/ld-linux.so.3"; } else if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb) { // TODO: check which dynamic linker name. - if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF || + if (TT.getEnvironment() == llvm::Triple::GNUEABIHF || arm::getARMFloatABI(ToolChain, Args) == arm::FloatABI::Hard) return "/lib/ld-linux-armhf.so.3"; else return "/lib/ld-linux.so.3"; } else if (Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el) { + StringRef CPUName; StringRef ABIName; - mips::getMipsCPUAndABI(Args, ToolChain.getTriple(), CPUName, ABIName); - bool IsNaN2008 = mips::isNaN2008(Args, ToolChain.getTriple()); + mips::getMipsCPUAndABI(Args, TT, CPUName, ABIName); + bool IsNaN2008 = mips::isNaN2008(Args, TT); StringRef LibDir = llvm::StringSwitch(ABIName) .Case("o32", "/lib") @@ -8149,7 +8155,11 @@ StringRef LibName; if (mips::isUCLibc(Args)) LibName = IsNaN2008 ? "ld-uClibc-mipsn8.so.0" : "ld-uClibc.so.0"; - else + else if (!TT.hasEnvironment()) { + bool LE = (TT.getArch() == llvm::Triple::mipsel) || + (TT.getArch() == llvm::Triple::mips64el); + LibName = LE ? "ld-musl-mipsel.so.1" : "ld-musl-mips.so.1"; + } else LibName = IsNaN2008 ? "ld-linux-mipsn8.so.1" : "ld.so.1"; return (LibDir + "/" + LibName).str(); @@ -8168,7 +8178,7 @@ else if (Arch == llvm::Triple::sparcv9) return "/lib64/ld-linux.so.2"; else if (Arch == llvm::Triple::x86_64 && - ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUX32) + TT.getEnvironment() == llvm::Triple::GNUX32) return "/libx32/ld-linux-x32.so.2"; else return "/lib64/ld-linux-x86-64.so.2"; @@ -8262,6 +8272,9 @@ const bool IsPIE = !Args.hasArg(options::OPT_shared) && !Args.hasArg(options::OPT_static) && (Args.hasArg(options::OPT_pie) || ToolChain.isPIEDefault()); + const bool HasCRTBeginEndFiles = + ToolChain.getTriple().hasEnvironment() || + (ToolChain.getTriple().getVendor() != llvm::Triple::MipsTechnologies); ArgStringList CmdArgs; @@ -8273,6 +8286,13 @@ // handled somewhere else. Args.ClaimAllArgs(options::OPT_w); + if (llvm::sys::path::filename(ToolChain.Linker) == "lld") { + CmdArgs.push_back("-flavor"); + CmdArgs.push_back("gnu"); + CmdArgs.push_back("-target"); + CmdArgs.push_back(Args.MakeArgString(getToolChain().getTripleString())); + } + if (!D.SysRoot.empty()) CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); @@ -8347,7 +8367,9 @@ crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o"; else crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o"; - CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin))); + + if (HasCRTBeginEndFiles) + CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin))); // Add crtfastmath.o if available and fast math is enabled. ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs); @@ -8446,11 +8468,13 @@ else crtend = isAndroid ? "crtend_android.o" : "crtend.o"; - CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend))); + if (HasCRTBeginEndFiles) + CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend))); if (!isAndroid) CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o"))); } - } + } else if (Args.hasArg(options::OPT_rtlib_EQ)) + AddRunTimeLibs(ToolChain, D, CmdArgs, Args); C.addCommand(llvm::make_unique(JA, *this, ToolChain.Linker.c_str(), CmdArgs, Inputs)); Index: test/Driver/mips-mti-linux.c =================================================================== --- /dev/null +++ test/Driver/mips-mti-linux.c @@ -0,0 +1,42 @@ +// Check frontend and linker invocations on GPL-free MIPS toolchain. +// +// FIXME: Using --sysroot with this toolchain/triple isn't supported. We use +// it here to test that we are producing the correct paths/flags. +// Ideally, we'd like to have an --llvm-toolchain option similar to +// the --gcc-toolchain one. + +// = Big-endian, mips32r2, hard float +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: --target=mips-mti-linux -mips32r2 -mhard-float \ +// RUN: --sysroot=%S/Inputs/mips_mti_linux/sysroot \ +// RUN: | FileCheck --check-prefix=CHECK-BE-HF-32R2 %s +// +// CHECK-BE-HF-32R2: "{{.*}}clang" {{.*}} "-triple" "mips-mti-linux" +// CHECK-BE-HF-32R2-SAME: "-fuse-init-array" "-target-cpu" "mips32r2" +// CHECK-BE-HF-32R2-SAME: "-isysroot" "{{.*}}mips_mti_linux/sysroot" +// CHECK-BE-HF-32R2: "lld" "-flavor" "gnu" "-target" "mips-mti-linux" +// CHECK-BE-HF-32R2-SAME: "--sysroot=[[SYSROOT:[^"]+]]" {{.*}} "-dynamic-linker" "/lib/ld-musl-mips.so.1" +// CHECK-BE-HF-32R2-SAME: "[[SYSROOT]]/mips-r2-hard-musl/usr/lib/crt1.o" +// CHECK-BE-HF-32R2-SAME: "[[SYSROOT]]/mips-r2-hard-musl/usr/lib/crti.o" +// CHECK-BE-HF-32R2-SAME: "-L[[SYSROOT]]/mips-r2-hard-musl/usr/lib" +// CHECK-BE-HF-32R2-SAME: "{{[^"]+}}/mips-r2-hard-musl/lib/linux/libclang_rt.builtins-mips.a" +// CHECK-BE-HF-32R2-SAME: "-lc" +// CHECK-BE-HF-32R2-SAME: "[[SYSROOT]]/mips-r2-hard-musl/usr/lib/crtn.o" + +// = Little-endian, mips32r2, hard float +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: --target=mips-mti-linux -mips32r2 -EL -mhard-float \ +// RUN: --sysroot=%S/Inputs/mips_mti_linux/sysroot \ +// RUN: | FileCheck --check-prefix=CHECK-LE-HF-32R2 %s +// +// CHECK-LE-HF-32R2: "{{.*}}clang" {{.*}} "-triple" "mipsel-mti-linux" +// CHECK-LE-HF-32R2-SAME: "-fuse-init-array" "-target-cpu" "mips32r2" +// CHECK-LE-HF-32R2-SAME: "-isysroot" "{{.*}}mips_mti_linux/sysroot" +// CHECK-LE-HF-32R2: "lld" "-flavor" "gnu" "-target" "mipsel-mti-linux" +// CHECK-LE-HF-32R2-SAME: "--sysroot=[[SYSROOT:[^"]+]]" {{.*}} "-dynamic-linker" "/lib/ld-musl-mipsel.so.1" +// CHECK-LE-HF-32R2-SAME: "[[SYSROOT]]/mipsel-r2-hard-musl/usr/lib/crt1.o" +// CHECK-LE-HF-32R2-SAME: "[[SYSROOT]]/mipsel-r2-hard-musl/usr/lib/crti.o" +// CHECK-LE-HF-32R2-SAME: "-L[[SYSROOT]]/mipsel-r2-hard-musl/usr/lib" +// CHECK-LE-HF-32R2-SAME: "{{[^"]+}}/mipsel-r2-hard-musl/lib/linux/libclang_rt.builtins-mipsel.a" +// CHECK-LE-HF-32R2-SAME: "-lc" +// CHECK-LE-HF-32R2-SAME: "[[SYSROOT]]/mipsel-r2-hard-musl/usr/lib/crtn.o"