Index: lib/Driver/Driver.cpp =================================================================== --- lib/Driver/Driver.cpp +++ lib/Driver/Driver.cpp @@ -2032,12 +2032,12 @@ break; case llvm::Triple::Linux: if (Target.getArch() == llvm::Triple::hexagon) - TC = new toolchains::Hexagon_TC(*this, Target, Args); + TC = new toolchains::HexagonToolChain(*this, Target, Args); else TC = new toolchains::Linux(*this, Target, Args); break; case llvm::Triple::NaCl: - TC = new toolchains::NaCl_TC(*this, Target, Args); + TC = new toolchains::NaClToolChain(*this, Target, Args); break; case llvm::Triple::Solaris: TC = new toolchains::Solaris(*this, Target, Args); @@ -2075,9 +2075,9 @@ if (Target.getArchName() == "tce") TC = new toolchains::TCEToolChain(*this, Target, Args); else if (Target.getArch() == llvm::Triple::hexagon) - TC = new toolchains::Hexagon_TC(*this, Target, Args); + TC = new toolchains::HexagonToolChain(*this, Target, Args); else if (Target.getArch() == llvm::Triple::xcore) - TC = new toolchains::XCore(*this, Target, Args); + TC = new toolchains::XCoreToolChain(*this, Target, Args); else if (Target.getArch() == llvm::Triple::shave) TC = new toolchains::SHAVEToolChain(*this, Target, Args); else if (Target.isOSBinFormatELF()) Index: lib/Driver/ToolChains.h =================================================================== --- lib/Driver/ToolChains.h +++ lib/Driver/ToolChains.h @@ -666,16 +666,16 @@ std::string computeSysRoot() const; }; -class LLVM_LIBRARY_VISIBILITY Hexagon_TC : public Linux { +class LLVM_LIBRARY_VISIBILITY HexagonToolChain : public Linux { protected: GCCVersion GCCLibAndIncVersion; Tool *buildAssembler() const override; Tool *buildLinker() const override; public: - Hexagon_TC(const Driver &D, const llvm::Triple &Triple, - const llvm::opt::ArgList &Args); - ~Hexagon_TC() override; + HexagonToolChain(const Driver &D, const llvm::Triple &Triple, + const llvm::opt::ArgList &Args); + ~HexagonToolChain() override; void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, @@ -697,10 +697,10 @@ static bool UsesG0(const char *smallDataThreshold); }; -class LLVM_LIBRARY_VISIBILITY NaCl_TC : public Generic_ELF { +class LLVM_LIBRARY_VISIBILITY NaClToolChain : public Generic_ELF { public: - NaCl_TC(const Driver &D, const llvm::Triple &Triple, - const llvm::opt::ArgList &Args); + NaClToolChain(const Driver &D, const llvm::Triple &Triple, + const llvm::opt::ArgList &Args); void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, @@ -716,8 +716,9 @@ bool IsIntegratedAssemblerDefault() const override { return false; } - // Get the path to the file containing NaCl's ARM macros. It lives in NaCl_TC - // because the AssembleARM tool needs a const char * that it can pass around + // Get the path to the file containing NaCl's ARM macros. + // It lives in NaClToolChain because the ARMAssembler tool needs a + // const char * that it can pass around, // and the toolchain outlives all the jobs. const char *GetNaClArmMacrosPath() const { return NaClArmMacrosPath.c_str(); } @@ -814,10 +815,10 @@ Tool *buildAssembler() const override; }; -class LLVM_LIBRARY_VISIBILITY XCore : public ToolChain { +class LLVM_LIBRARY_VISIBILITY XCoreToolChain : public ToolChain { public: - XCore(const Driver &D, const llvm::Triple &Triple, - const llvm::opt::ArgList &Args); + XCoreToolChain(const Driver &D, const llvm::Triple &Triple, + const llvm::opt::ArgList &Args); protected: Tool *buildAssembler() const override; @@ -841,7 +842,7 @@ llvm::opt::ArgStringList &CmdArgs) const override; }; -/// SHAVEToolChain - A tool chain using the compiler installed by the the +// SHAVEToolChain - A tool chain using the compiler installed by the the // Movidius SDK into MV_TOOLS_DIR (which we assume will be copied to llvm's // installation dir) to perform all subcommands. class LLVM_LIBRARY_VISIBILITY SHAVEToolChain : public Generic_GCC { Index: lib/Driver/ToolChains.cpp =================================================================== --- lib/Driver/ToolChains.cpp +++ lib/Driver/ToolChains.cpp @@ -2070,9 +2070,8 @@ /// Hexagon Toolchain -std::string Hexagon_TC::GetGnuDir(const std::string &InstalledDir, - const ArgList &Args) { - +std::string HexagonToolChain::GetGnuDir(const std::string &InstalledDir, + const ArgList &Args) { // Locate the rest of the toolchain ... std::string GccToolchain = getGCCToolchainDir(Args); @@ -2090,7 +2089,7 @@ return InstallRelDir; } -const char *Hexagon_TC::GetSmallDataThreshold(const ArgList &Args) { +const char *HexagonToolChain::GetSmallDataThreshold(const ArgList &Args) { Arg *A; A = Args.getLastArg(options::OPT_G, options::OPT_G_EQ, @@ -2106,7 +2105,7 @@ return 0; } -bool Hexagon_TC::UsesG0(const char *smallDataThreshold) { +bool HexagonToolChain::UsesG0(const char *smallDataThreshold) { return smallDataThreshold && smallDataThreshold[0] == '0'; } @@ -2129,7 +2128,8 @@ const std::string MarchSuffix = "/" + MarchString; const std::string G0Suffix = "/G0"; const std::string MarchG0Suffix = MarchSuffix + G0Suffix; - const std::string RootDir = Hexagon_TC::GetGnuDir(InstalledDir, Args) + "/"; + const std::string RootDir = + HexagonToolChain::GetGnuDir(InstalledDir, Args) + "/"; // lib/gcc/hexagon/... std::string LibGCCHexagonDir = RootDir + "lib/gcc/hexagon/"; @@ -2153,11 +2153,11 @@ LibPaths->push_back(HexagonLibDir); } -Hexagon_TC::Hexagon_TC(const Driver &D, const llvm::Triple &Triple, - const ArgList &Args) +HexagonToolChain::HexagonToolChain(const Driver &D, const llvm::Triple &Triple, + const ArgList &Args) : Linux(D, Triple, Args) { const std::string InstalledDir(getDriver().getInstalledDir()); - const std::string GnuDir = Hexagon_TC::GetGnuDir(InstalledDir, Args); + const std::string GnuDir = HexagonToolChain::GetGnuDir(InstalledDir, Args); // Note: Generic_GCC::Generic_GCC adds InstalledDir and getDriver().Dir to // program paths @@ -2188,18 +2188,18 @@ InstalledDir, LibPaths); } -Hexagon_TC::~Hexagon_TC() {} +HexagonToolChain::~HexagonToolChain() {} -Tool *Hexagon_TC::buildAssembler() const { +Tool *HexagonToolChain::buildAssembler() const { return new tools::hexagon::Assembler(*this); } -Tool *Hexagon_TC::buildLinker() const { +Tool *HexagonToolChain::buildLinker() const { return new tools::hexagon::Linker(*this); } -void Hexagon_TC::AddClangSystemIncludeArgs(const ArgList &DriverArgs, - ArgStringList &CC1Args) const { +void HexagonToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs, + ArgStringList &CC1Args) const { const Driver &D = getDriver(); if (DriverArgs.hasArg(options::OPT_nostdinc) || @@ -2207,16 +2207,15 @@ return; std::string Ver(GetGCCLibAndIncVersion()); - std::string GnuDir = Hexagon_TC::GetGnuDir(D.InstalledDir, DriverArgs); + std::string GnuDir = HexagonToolChain::GetGnuDir(D.InstalledDir, DriverArgs); std::string HexagonDir(GnuDir + "/lib/gcc/hexagon/" + Ver); addExternCSystemInclude(DriverArgs, CC1Args, HexagonDir + "/include"); addExternCSystemInclude(DriverArgs, CC1Args, HexagonDir + "/include-fixed"); addExternCSystemInclude(DriverArgs, CC1Args, GnuDir + "/hexagon/include"); } -void Hexagon_TC::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, - ArgStringList &CC1Args) const { - +void HexagonToolChain::AddClangCXXStdlibIncludeArgs( + const ArgList &DriverArgs, ArgStringList &CC1Args) const { if (DriverArgs.hasArg(options::OPT_nostdlibinc) || DriverArgs.hasArg(options::OPT_nostdincxx)) return; @@ -2224,7 +2223,7 @@ const Driver &D = getDriver(); std::string Ver(GetGCCLibAndIncVersion()); SmallString<128> IncludeDir( - Hexagon_TC::GetGnuDir(D.InstalledDir, DriverArgs)); + HexagonToolChain::GetGnuDir(D.InstalledDir, DriverArgs)); llvm::sys::path::append(IncludeDir, "hexagon/include/c++/"); llvm::sys::path::append(IncludeDir, Ver); @@ -2232,7 +2231,7 @@ } ToolChain::CXXStdlibType -Hexagon_TC::GetCXXStdlibType(const ArgList &Args) const { +HexagonToolChain::GetCXXStdlibType(const ArgList &Args) const { Arg *A = Args.getLastArg(options::OPT_stdlib_EQ); if (!A) return ToolChain::CST_Libstdcxx; @@ -2268,7 +2267,7 @@ return 4; } -StringRef Hexagon_TC::GetTargetCPU(const ArgList &Args) { +StringRef HexagonToolChain::GetTargetCPU(const ArgList &Args) { int V = getHexagonVersion(Args); // FIXME: We don't support versions < 4. We should error on them. switch (V) { @@ -2289,10 +2288,9 @@ // End Hexagon /// NaCl Toolchain -NaCl_TC::NaCl_TC(const Driver &D, const llvm::Triple &Triple, - const ArgList &Args) +NaClToolChain::NaClToolChain(const Driver &D, const llvm::Triple &Triple, + const ArgList &Args) : Generic_ELF(D, Triple, Args) { - // Remove paths added by Generic_GCC. NaCl Toolchain cannot use the // default paths, and must instead only use the paths provided // with this toolchain based on architecture. @@ -2342,8 +2340,8 @@ NaClArmMacrosPath = GetFilePath("nacl-arm-macros.s"); } -void NaCl_TC::AddClangSystemIncludeArgs(const ArgList &DriverArgs, - ArgStringList &CC1Args) const { +void NaClToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs, + ArgStringList &CC1Args) const { const Driver &D = getDriver(); if (DriverArgs.hasArg(options::OPT_nostdinc)) return; @@ -2379,16 +2377,16 @@ addSystemInclude(DriverArgs, CC1Args, P.str()); } -void NaCl_TC::AddCXXStdlibLibArgs(const ArgList &Args, - ArgStringList &CmdArgs) const { +void NaClToolChain::AddCXXStdlibLibArgs(const ArgList &Args, + ArgStringList &CmdArgs) const { // Check for -stdlib= flags. We only support libc++ but this consumes the arg // if the value is libc++, and emits an error for other values. GetCXXStdlibType(Args); CmdArgs.push_back("-lc++"); } -void NaCl_TC::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, - ArgStringList &CC1Args) const { +void NaClToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, + ArgStringList &CC1Args) const { const Driver &D = getDriver(); if (DriverArgs.hasArg(options::OPT_nostdlibinc) || DriverArgs.hasArg(options::OPT_nostdincxx)) @@ -2417,7 +2415,8 @@ } } -ToolChain::CXXStdlibType NaCl_TC::GetCXXStdlibType(const ArgList &Args) const { +ToolChain::CXXStdlibType +NaClToolChain::GetCXXStdlibType(const ArgList &Args) const { if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) { StringRef Value = A->getValue(); if (Value == "libc++") @@ -2428,8 +2427,9 @@ return ToolChain::CST_Libcxx; } -std::string NaCl_TC::ComputeEffectiveClangTriple(const ArgList &Args, - types::ID InputType) const { +std::string +NaClToolChain::ComputeEffectiveClangTriple(const ArgList &Args, + types::ID InputType) const { llvm::Triple TheTriple(ComputeLLVMTriple(Args, InputType)); if (TheTriple.getArch() == llvm::Triple::arm && TheTriple.getEnvironment() == llvm::Triple::UnknownEnvironment) @@ -2437,13 +2437,13 @@ return TheTriple.getTriple(); } -Tool *NaCl_TC::buildLinker() const { +Tool *NaClToolChain::buildLinker() const { return new tools::nacltools::Linker(*this); } -Tool *NaCl_TC::buildAssembler() const { +Tool *NaClToolChain::buildAssembler() const { if (getTriple().getArch() == llvm::Triple::arm) - return new tools::nacltools::AssemblerARM(*this); + return new tools::nacltools::ARMAssembler(*this); return new tools::gnutools::Assembler(*this); } // End NaCl @@ -3632,29 +3632,32 @@ } /// XCore tool chain -XCore::XCore(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) +XCoreToolChain::XCoreToolChain(const Driver &D, const llvm::Triple &Triple, + const ArgList &Args) : ToolChain(D, Triple, Args) { // ProgramPaths are found via 'PATH' environment variable. } -Tool *XCore::buildAssembler() const { +Tool *XCoreToolChain::buildAssembler() const { return new tools::XCore::Assembler(*this); } -Tool *XCore::buildLinker() const { return new tools::XCore::Linker(*this); } +Tool *XCoreToolChain::buildLinker() const { + return new tools::XCore::Linker(*this); +} -bool XCore::isPICDefault() const { return false; } +bool XCoreToolChain::isPICDefault() const { return false; } -bool XCore::isPIEDefault() const { return false; } +bool XCoreToolChain::isPIEDefault() const { return false; } -bool XCore::isPICDefaultForced() const { return false; } +bool XCoreToolChain::isPICDefaultForced() const { return false; } -bool XCore::SupportsProfiling() const { return false; } +bool XCoreToolChain::SupportsProfiling() const { return false; } -bool XCore::hasBlocksRuntime() const { return false; } +bool XCoreToolChain::hasBlocksRuntime() const { return false; } -void XCore::AddClangSystemIncludeArgs(const ArgList &DriverArgs, - ArgStringList &CC1Args) const { +void XCoreToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs, + ArgStringList &CC1Args) const { if (DriverArgs.hasArg(options::OPT_nostdinc) || DriverArgs.hasArg(options::OPT_nostdlibinc)) return; @@ -3667,13 +3670,13 @@ } } -void XCore::addClangTargetOptions(const ArgList &DriverArgs, - ArgStringList &CC1Args) const { +void XCoreToolChain::addClangTargetOptions(const ArgList &DriverArgs, + ArgStringList &CC1Args) const { CC1Args.push_back("-nostdsysteminc"); } -void XCore::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, - ArgStringList &CC1Args) const { +void XCoreToolChain::AddClangCXXStdlibIncludeArgs( + const ArgList &DriverArgs, ArgStringList &CC1Args) const { if (DriverArgs.hasArg(options::OPT_nostdinc) || DriverArgs.hasArg(options::OPT_nostdlibinc) || DriverArgs.hasArg(options::OPT_nostdincxx)) @@ -3687,8 +3690,8 @@ } } -void XCore::AddCXXStdlibLibArgs(const ArgList &Args, - ArgStringList &CmdArgs) const { +void XCoreToolChain::AddCXXStdlibLibArgs(const ArgList &Args, + ArgStringList &CmdArgs) const { // We don't output any lib args. This is handled by xcc. } Index: lib/Driver/Tools.h =================================================================== --- lib/Driver/Tools.h +++ lib/Driver/Tools.h @@ -519,9 +519,9 @@ } namespace nacltools { - class LLVM_LIBRARY_VISIBILITY AssemblerARM : public gnutools::Assembler { + class LLVM_LIBRARY_VISIBILITY ARMAssembler : public gnutools::Assembler { public: - AssemblerARM(const ToolChain &TC) : gnutools::Assembler(TC) {} + ARMAssembler(const ToolChain &TC) : gnutools::Assembler(TC) {} void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, Index: lib/Driver/Tools.cpp =================================================================== --- lib/Driver/Tools.cpp +++ lib/Driver/Tools.cpp @@ -1483,7 +1483,7 @@ return getX86TargetCPU(Args, T); case llvm::Triple::hexagon: - return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str(); + return "hexagon" + toolchains::HexagonToolChain::GetTargetCPU(Args).str(); case llvm::Triple::systemz: return getSystemZTargetCPU(Args); @@ -1759,7 +1759,8 @@ CmdArgs.push_back("-mqdsp6-compat"); CmdArgs.push_back("-Wreturn-type"); - if (const char *v = toolchains::Hexagon_TC::GetSmallDataThreshold(Args)) { + if (const char *v = + toolchains::HexagonToolChain::GetSmallDataThreshold(Args)) { std::string SmallDataThreshold = "-hexagon-small-data-threshold="; SmallDataThreshold += v; CmdArgs.push_back("-mllvm"); @@ -5461,7 +5462,7 @@ ArgStringList CmdArgs; std::string MarchString = "-march="; - MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args); + MarchString += toolchains::HexagonToolChain::GetTargetCPU(Args); CmdArgs.push_back(Args.MakeArgString(MarchString)); RenderExtraToolArgs(JA, CmdArgs); @@ -5474,7 +5475,7 @@ CmdArgs.push_back("-fsyntax-only"); } - if (const char *v = toolchains::Hexagon_TC::GetSmallDataThreshold(Args)) + if (const char *v = toolchains::HexagonToolChain::GetSmallDataThreshold(Args)) CmdArgs.push_back(Args.MakeArgString(std::string("-G") + v)); Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); @@ -5518,13 +5519,12 @@ // The types are (hopefully) good enough. } -static void constructHexagonLinkArgs(Compilation &C, const JobAction &JA, - const toolchains::Hexagon_TC &ToolChain, - const InputInfo &Output, - const InputInfoList &Inputs, - const ArgList &Args, - ArgStringList &CmdArgs, - const char *LinkingOutput) { +static void +constructHexagonLinkArgs(Compilation &C, const JobAction &JA, + const toolchains::HexagonToolChain &ToolChain, + const InputInfo &Output, const InputInfoList &Inputs, + const ArgList &Args, ArgStringList &CmdArgs, + const char *LinkingOutput) { const Driver &D = ToolChain.getDriver(); @@ -5556,7 +5556,7 @@ for (const auto &Opt : ToolChain.ExtraOpts) CmdArgs.push_back(Opt.c_str()); - std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args); + std::string MarchString = toolchains::HexagonToolChain::GetTargetCPU(Args); CmdArgs.push_back(Args.MakeArgString("-m" + MarchString)); if (buildingLib) { @@ -5571,9 +5571,10 @@ if (buildPIE && !buildingLib) CmdArgs.push_back("-pie"); - if (const char *v = toolchains::Hexagon_TC::GetSmallDataThreshold(Args)) { + if (const char *v = + toolchains::HexagonToolChain::GetSmallDataThreshold(Args)) { CmdArgs.push_back(Args.MakeArgString(std::string("-G") + v)); - useG0 = toolchains::Hexagon_TC::UsesG0(v); + useG0 = toolchains::HexagonToolChain::UsesG0(v); } //---------------------------------------------------------------------------- @@ -5586,7 +5587,7 @@ const std::string G0Suffix = "/G0"; const std::string MarchG0Suffix = MarchSuffix + G0Suffix; const std::string RootDir = - toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir, Args) + "/"; + toolchains::HexagonToolChain::GetGnuDir(D.InstalledDir, Args) + "/"; const std::string StartFilesDir = RootDir + "hexagon/lib" + (useG0 ? MarchG0Suffix : MarchSuffix); @@ -5678,8 +5679,8 @@ const ArgList &Args, const char *LinkingOutput) const { - const toolchains::Hexagon_TC &ToolChain = - static_cast(getToolChain()); + const toolchains::HexagonToolChain &ToolChain = + static_cast(getToolChain()); ArgStringList CmdArgs; constructHexagonLinkArgs(C, JA, ToolChain, Output, Inputs, Args, CmdArgs, @@ -8113,13 +8114,13 @@ // for the various SFI requirements like register masking. The assembly tool // inserts the file containing the macros as an input into all the assembly // jobs. -void nacltools::AssemblerARM::ConstructJob(Compilation &C, const JobAction &JA, +void nacltools::ARMAssembler::ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const ArgList &Args, const char *LinkingOutput) const { - const toolchains::NaCl_TC &ToolChain = - static_cast(getToolChain()); + const toolchains::NaClToolChain &ToolChain = + static_cast(getToolChain()); InputInfo NaClMacros(ToolChain.GetNaClArmMacrosPath(), types::TY_PP_Asm, "nacl-arm-macros.s"); InputInfoList NewInputs; @@ -8139,8 +8140,8 @@ const ArgList &Args, const char *LinkingOutput) const { - const toolchains::NaCl_TC &ToolChain = - static_cast(getToolChain()); + const toolchains::NaClToolChain &ToolChain = + static_cast(getToolChain()); const Driver &D = ToolChain.getDriver(); const llvm::Triple::ArchType Arch = ToolChain.getArch(); const bool IsStatic = @@ -8165,8 +8166,8 @@ if (Args.hasArg(options::OPT_s)) CmdArgs.push_back("-s"); - // NaCl_TC doesn't have ExtraOpts like Linux; the only relevant flag from - // there is --build-id, which we do want. + // NaClToolChain doesn't have ExtraOpts like Linux; the only relevant flag + // from there is --build-id, which we do want. CmdArgs.push_back("--build-id"); if (!IsStatic)