contrib/llvm/tools/clang/lib/Driver/ToolChains/Hexagon.cpp

   1 //===--- Hexagon.cpp - Hexagon ToolChain Implementations --------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "Hexagon.h"
  11 #include "InputInfo.h"
  12 #include "CommonArgs.h"
  13 #include "clang/Basic/VirtualFileSystem.h"
  14 #include "clang/Config/config.h"
  15 #include "clang/Driver/Compilation.h"
  16 #include "clang/Driver/Driver.h"
  17 #include "clang/Driver/DriverDiagnostic.h"
  18 #include "clang/Driver/Options.h"
  19 #include "llvm/ADT/StringExtras.h"
  20 #include "llvm/Option/ArgList.h"
  21 #include "llvm/Support/FileSystem.h"
  22 #include "llvm/Support/Path.h"
  23
  24 using namespace clang::driver;
  25 using namespace clang::driver::tools;
  26 using namespace clang::driver::toolchains;
  27 using namespace clang;
  28 using namespace llvm::opt;
  29
  30 // Default hvx-length for various versions.
  31 static StringRef getDefaultHvxLength(StringRef Cpu) {
  32   return llvm::StringSwitch<StringRef>(Cpu)
  33       .Case("v60", "64b")
  34       .Case("v62", "64b")
  35       .Case("v65", "64b")
  36       .Default("128b");
  37 }
  38
  39 static void handleHVXWarnings(const Driver &D, const ArgList &Args) {
  40   // Handle deprecated HVX double warnings.
  41   if (Arg *A = Args.getLastArg(options::OPT_mhexagon_hvx_double))
  42     D.Diag(diag::warn_drv_deprecated_arg)
  43         << A->getAsString(Args) << "-mhvx-length=128B";
  44   if (Arg *A = Args.getLastArg(options::OPT_mno_hexagon_hvx_double))
  45     D.Diag(diag::warn_drv_deprecated_arg) << A->getAsString(Args) << "-mno-hvx";
  46   // Handle the unsupported values passed to mhvx-length.
  47   if (Arg *A = Args.getLastArg(options::OPT_mhexagon_hvx_length_EQ)) {
  48     StringRef Val = A->getValue();
  49     if (!Val.equals_lower("64b") && !Val.equals_lower("128b"))
  50       D.Diag(diag::err_drv_unsupported_option_argument)
  51           << A->getOption().getName() << Val;
  52   }
  53 }
  54
  55 // Handle hvx target features explicitly.
  56 static void handleHVXTargetFeatures(const Driver &D, const ArgList &Args,
  57                                     std::vector<StringRef> &Features,
  58                                     bool &HasHVX) {
  59   // Handle HVX warnings.
  60   handleHVXWarnings(D, Args);
  61
  62   // Add the +hvx* features based on commandline flags.
  63   StringRef HVXFeature, HVXLength;
  64   StringRef Cpu(toolchains::HexagonToolChain::GetTargetCPUVersion(Args));
  65
  66   // Handle -mhvx, -mhvx=, -mno-hvx, -mno-hvx-double.
  67   if (Arg *A = Args.getLastArg(
  68           options::OPT_mno_hexagon_hvx, options::OPT_mno_hexagon_hvx_double,
  69           options::OPT_mhexagon_hvx, options::OPT_mhexagon_hvx_EQ)) {
  70     if (A->getOption().matches(options::OPT_mno_hexagon_hvx) ||
  71         A->getOption().matches(options::OPT_mno_hexagon_hvx_double)) {
  72       return;
  73     } else if (A->getOption().matches(options::OPT_mhexagon_hvx_EQ)) {
  74       HasHVX = true;
  75       HVXFeature = Cpu = A->getValue();
  76       HVXFeature = Args.MakeArgString(llvm::Twine("+hvx") + HVXFeature.lower());
  77     } else if (A->getOption().matches(options::OPT_mhexagon_hvx)) {
  78       HasHVX = true;
  79       HVXFeature = Args.MakeArgString(llvm::Twine("+hvx") + Cpu);
  80     }
  81     Features.push_back(HVXFeature);
  82   }
  83
  84   // Handle -mhvx-length=, -mhvx-double.
  85   if (Arg *A = Args.getLastArg(options::OPT_mhexagon_hvx_length_EQ,
  86                                options::OPT_mhexagon_hvx_double)) {
  87     // These falgs are valid only if HVX in enabled.
  88     if (!HasHVX)
  89       D.Diag(diag::err_drv_invalid_hvx_length);
  90     else if (A->getOption().matches(options::OPT_mhexagon_hvx_length_EQ))
  91       HVXLength = A->getValue();
  92     else if (A->getOption().matches(options::OPT_mhexagon_hvx_double))
  93       HVXLength = "128b";
  94   }
  95   // Default hvx-length based on Cpu.
  96   else if (HasHVX)
  97     HVXLength = getDefaultHvxLength(Cpu);
  98
  99   if (!HVXLength.empty()) {
 100     HVXFeature =
 101         Args.MakeArgString(llvm::Twine("+hvx-length") + HVXLength.lower());
 102     Features.push_back(HVXFeature);
 103   }
 104 }
 105
 106 // Hexagon target features.
 107 void hexagon::getHexagonTargetFeatures(const Driver &D, const ArgList &Args,
 108                                        std::vector<StringRef> &Features) {
 109   handleTargetFeaturesGroup(Args, Features,
 110                             options::OPT_m_hexagon_Features_Group);
 111
 112   bool UseLongCalls = false;
 113   if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
 114                                options::OPT_mno_long_calls)) {
 115     if (A->getOption().matches(options::OPT_mlong_calls))
 116       UseLongCalls = true;
 117   }
 118
 119   Features.push_back(UseLongCalls ? "+long-calls" : "-long-calls");
 120
 121   bool HasHVX(false);
 122   handleHVXTargetFeatures(D, Args, Features, HasHVX);
 123 }
 124
 125 // Hexagon tools start.
 126 void hexagon::Assembler::RenderExtraToolArgs(const JobAction &JA,
 127                                              ArgStringList &CmdArgs) const {
 128 }
 129
 130 void hexagon::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
 131                                       const InputInfo &Output,
 132                                       const InputInfoList &Inputs,
 133                                       const ArgList &Args,
 134                                       const char *LinkingOutput) const {
 135   claimNoWarnArgs(Args);
 136
 137   auto &HTC = static_cast<const toolchains::HexagonToolChain&>(getToolChain());
 138   const Driver &D = HTC.getDriver();
 139   ArgStringList CmdArgs;
 140
 141   CmdArgs.push_back("-march=hexagon");
 142
 143   RenderExtraToolArgs(JA, CmdArgs);
 144
 145   const char *AsName = "hexagon-llvm-mc";
 146   CmdArgs.push_back("-filetype=obj");
 147   CmdArgs.push_back(Args.MakeArgString(
 148       "-mcpu=hexagon" +
 149       toolchains::HexagonToolChain::GetTargetCPUVersion(Args)));
 150
 151   if (Output.isFilename()) {
 152     CmdArgs.push_back("-o");
 153     CmdArgs.push_back(Output.getFilename());
 154   } else {
 155     assert(Output.isNothing() && "Unexpected output");
 156     CmdArgs.push_back("-fsyntax-only");
 157   }
 158
 159   if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) {
 160     CmdArgs.push_back(Args.MakeArgString("-gpsize=" + Twine(G.getValue())));
 161   }
 162
 163   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
 164
 165   // Only pass -x if gcc will understand it; otherwise hope gcc
 166   // understands the suffix correctly. The main use case this would go
 167   // wrong in is for linker inputs if they happened to have an odd
 168   // suffix; really the only way to get this to happen is a command
 169   // like '-x foobar a.c' which will treat a.c like a linker input.
 170   //
 171   // FIXME: For the linker case specifically, can we safely convert
 172   // inputs into '-Wl,' options?
 173   for (const auto &II : Inputs) {
 174     // Don't try to pass LLVM or AST inputs to a generic gcc.
 175     if (types::isLLVMIR(II.getType()))
 176       D.Diag(clang::diag::err_drv_no_linker_llvm_support)
 177           << HTC.getTripleString();
 178     else if (II.getType() == types::TY_AST)
 179       D.Diag(clang::diag::err_drv_no_ast_support)
 180           << HTC.getTripleString();
 181     else if (II.getType() == types::TY_ModuleFile)
 182       D.Diag(diag::err_drv_no_module_support)
 183           << HTC.getTripleString();
 184
 185     if (II.isFilename())
 186       CmdArgs.push_back(II.getFilename());
 187     else
 188       // Don't render as input, we need gcc to do the translations.
 189       // FIXME: What is this?
 190       II.getInputArg().render(Args, CmdArgs);
 191   }
 192
 193   auto *Exec = Args.MakeArgString(HTC.GetProgramPath(AsName));
 194   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 195 }
 196
 197 void hexagon::Linker::RenderExtraToolArgs(const JobAction &JA,
 198                                           ArgStringList &CmdArgs) const {
 199 }
 200
 201 static void
 202 constructHexagonLinkArgs(Compilation &C, const JobAction &JA,
 203                          const toolchains::HexagonToolChain &HTC,
 204                          const InputInfo &Output, const InputInfoList &Inputs,
 205                          const ArgList &Args, ArgStringList &CmdArgs,
 206                          const char *LinkingOutput) {
 207
 208   const Driver &D = HTC.getDriver();
 209
 210   //----------------------------------------------------------------------------
 211   //
 212   //----------------------------------------------------------------------------
 213   bool IsStatic = Args.hasArg(options::OPT_static);
 214   bool IsShared = Args.hasArg(options::OPT_shared);
 215   bool IsPIE = Args.hasArg(options::OPT_pie);
 216   bool IncStdLib = !Args.hasArg(options::OPT_nostdlib);
 217   bool IncStartFiles = !Args.hasArg(options::OPT_nostartfiles);
 218   bool IncDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
 219   bool UseG0 = false;
 220   bool UseShared = IsShared && !IsStatic;
 221
 222   //----------------------------------------------------------------------------
 223   // Silence warnings for various options
 224   //----------------------------------------------------------------------------
 225   Args.ClaimAllArgs(options::OPT_g_Group);
 226   Args.ClaimAllArgs(options::OPT_emit_llvm);
 227   Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
 228                                      // handled somewhere else.
 229   Args.ClaimAllArgs(options::OPT_static_libgcc);
 230
 231   //----------------------------------------------------------------------------
 232   //
 233   //----------------------------------------------------------------------------
 234   if (Args.hasArg(options::OPT_s))
 235     CmdArgs.push_back("-s");
 236
 237   if (Args.hasArg(options::OPT_r))
 238     CmdArgs.push_back("-r");
 239
 240   for (const auto &Opt : HTC.ExtraOpts)
 241     CmdArgs.push_back(Opt.c_str());
 242
 243   CmdArgs.push_back("-march=hexagon");
 244   StringRef CpuVer = toolchains::HexagonToolChain::GetTargetCPUVersion(Args);
 245   CmdArgs.push_back(Args.MakeArgString("-mcpu=hexagon" + CpuVer));
 246
 247   if (IsShared) {
 248     CmdArgs.push_back("-shared");
 249     // The following should be the default, but doing as hexagon-gcc does.
 250     CmdArgs.push_back("-call_shared");
 251   }
 252
 253   if (IsStatic)
 254     CmdArgs.push_back("-static");
 255
 256   if (IsPIE && !IsShared)
 257     CmdArgs.push_back("-pie");
 258
 259   if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) {
 260     CmdArgs.push_back(Args.MakeArgString("-G" + Twine(G.getValue())));
 261     UseG0 = G.getValue() == 0;
 262   }
 263
 264   //----------------------------------------------------------------------------
 265   //
 266   //----------------------------------------------------------------------------
 267   CmdArgs.push_back("-o");
 268   CmdArgs.push_back(Output.getFilename());
 269
 270   //----------------------------------------------------------------------------
 271   // moslib
 272   //----------------------------------------------------------------------------
 273   std::vector<std::string> OsLibs;
 274   bool HasStandalone = false;
 275
 276   for (const Arg *A : Args.filtered(options::OPT_moslib_EQ)) {
 277     A->claim();
 278     OsLibs.emplace_back(A->getValue());
 279     HasStandalone = HasStandalone || (OsLibs.back() == "standalone");
 280   }
 281   if (OsLibs.empty()) {
 282     OsLibs.push_back("standalone");
 283     HasStandalone = true;
 284   }
 285
 286   //----------------------------------------------------------------------------
 287   // Start Files
 288   //----------------------------------------------------------------------------
 289   const std::string MCpuSuffix = "/" + CpuVer.str();
 290   const std::string MCpuG0Suffix = MCpuSuffix + "/G0";
 291   const std::string RootDir =
 292       HTC.getHexagonTargetDir(D.InstalledDir, D.PrefixDirs) + "/";
 293   const std::string StartSubDir =
 294       "hexagon/lib" + (UseG0 ? MCpuG0Suffix : MCpuSuffix);
 295
 296   auto Find = [&HTC] (const std::string &RootDir, const std::string &SubDir,
 297                       const char *Name) -> std::string {
 298     std::string RelName = SubDir + Name;
 299     std::string P = HTC.GetFilePath(RelName.c_str());
 300     if (llvm::sys::fs::exists(P))
 301       return P;
 302     return RootDir + RelName;
 303   };
 304
 305   if (IncStdLib && IncStartFiles) {
 306     if (!IsShared) {
 307       if (HasStandalone) {
 308         std::string Crt0SA = Find(RootDir, StartSubDir, "/crt0_standalone.o");
 309         CmdArgs.push_back(Args.MakeArgString(Crt0SA));
 310       }
 311       std::string Crt0 = Find(RootDir, StartSubDir, "/crt0.o");
 312       CmdArgs.push_back(Args.MakeArgString(Crt0));
 313     }
 314     std::string Init = UseShared
 315           ? Find(RootDir, StartSubDir + "/pic", "/initS.o")
 316           : Find(RootDir, StartSubDir, "/init.o");
 317     CmdArgs.push_back(Args.MakeArgString(Init));
 318   }
 319
 320   //----------------------------------------------------------------------------
 321   // Library Search Paths
 322   //----------------------------------------------------------------------------
 323   const ToolChain::path_list &LibPaths = HTC.getFilePaths();
 324   for (const auto &LibPath : LibPaths)
 325     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
 326
 327   //----------------------------------------------------------------------------
 328   //
 329   //----------------------------------------------------------------------------
 330   Args.AddAllArgs(CmdArgs,
 331                   {options::OPT_T_Group, options::OPT_e, options::OPT_s,
 332                    options::OPT_t, options::OPT_u_Group});
 333
 334   AddLinkerInputs(HTC, Inputs, Args, CmdArgs, JA);
 335
 336   //----------------------------------------------------------------------------
 337   // Libraries
 338   //----------------------------------------------------------------------------
 339   if (IncStdLib && IncDefLibs) {
 340     if (D.CCCIsCXX()) {
 341       if (HTC.ShouldLinkCXXStdlib(Args))
 342         HTC.AddCXXStdlibLibArgs(Args, CmdArgs);
 343       CmdArgs.push_back("-lm");
 344     }
 345
 346     CmdArgs.push_back("--start-group");
 347
 348     if (!IsShared) {
 349       for (StringRef Lib : OsLibs)
 350         CmdArgs.push_back(Args.MakeArgString("-l" + Lib));
 351       CmdArgs.push_back("-lc");
 352     }
 353     CmdArgs.push_back("-lgcc");
 354
 355     CmdArgs.push_back("--end-group");
 356   }
 357
 358   //----------------------------------------------------------------------------
 359   // End files
 360   //----------------------------------------------------------------------------
 361   if (IncStdLib && IncStartFiles) {
 362     std::string Fini = UseShared
 363           ? Find(RootDir, StartSubDir + "/pic", "/finiS.o")
 364           : Find(RootDir, StartSubDir, "/fini.o");
 365     CmdArgs.push_back(Args.MakeArgString(Fini));
 366   }
 367 }
 368
 369 void hexagon::Linker::ConstructJob(Compilation &C, const JobAction &JA,
 370                                    const InputInfo &Output,
 371                                    const InputInfoList &Inputs,
 372                                    const ArgList &Args,
 373                                    const char *LinkingOutput) const {
 374   auto &HTC = static_cast<const toolchains::HexagonToolChain&>(getToolChain());
 375
 376   ArgStringList CmdArgs;
 377   constructHexagonLinkArgs(C, JA, HTC, Output, Inputs, Args, CmdArgs,
 378                            LinkingOutput);
 379
 380   std::string Linker = HTC.GetProgramPath("hexagon-link");
 381   C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
 382                                           CmdArgs, Inputs));
 383 }
 384 // Hexagon tools end.
 385
 386 /// Hexagon Toolchain
 387
 388 std::string HexagonToolChain::getHexagonTargetDir(
 389       const std::string &InstalledDir,
 390       const SmallVectorImpl<std::string> &PrefixDirs) const {
 391   std::string InstallRelDir;
 392   const Driver &D = getDriver();
 393
 394   // Locate the rest of the toolchain ...
 395   for (auto &I : PrefixDirs)
 396     if (D.getVFS().exists(I))
 397       return I;
 398
 399   if (getVFS().exists(InstallRelDir = InstalledDir + "/../target"))
 400     return InstallRelDir;
 401
 402   return InstalledDir;
 403 }
 404
 405 Optional<unsigned> HexagonToolChain::getSmallDataThreshold(
 406       const ArgList &Args) {
 407   StringRef Gn = "";
 408   if (Arg *A = Args.getLastArg(options::OPT_G)) {
 409     Gn = A->getValue();
 410   } else if (Args.getLastArg(options::OPT_shared, options::OPT_fpic,
 411                              options::OPT_fPIC)) {
 412     Gn = "0";
 413   }
 414
 415   unsigned G;
 416   if (!Gn.getAsInteger(10, G))
 417     return G;
 418
 419   return None;
 420 }
 421
 422 void HexagonToolChain::getHexagonLibraryPaths(const ArgList &Args,
 423       ToolChain::path_list &LibPaths) const {
 424   const Driver &D = getDriver();
 425
 426   //----------------------------------------------------------------------------
 427   // -L Args
 428   //----------------------------------------------------------------------------
 429   for (Arg *A : Args.filtered(options::OPT_L))
 430     for (const char *Value : A->getValues())
 431       LibPaths.push_back(Value);
 432
 433   //----------------------------------------------------------------------------
 434   // Other standard paths
 435   //----------------------------------------------------------------------------
 436   std::vector<std::string> RootDirs;
 437   std::copy(D.PrefixDirs.begin(), D.PrefixDirs.end(),
 438             std::back_inserter(RootDirs));
 439
 440   std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
 441                                               D.PrefixDirs);
 442   if (std::find(RootDirs.begin(), RootDirs.end(), TargetDir) == RootDirs.end())
 443     RootDirs.push_back(TargetDir);
 444
 445   bool HasPIC = Args.hasArg(options::OPT_fpic, options::OPT_fPIC);
 446   // Assume G0 with -shared.
 447   bool HasG0 = Args.hasArg(options::OPT_shared);
 448   if (auto G = getSmallDataThreshold(Args))
 449     HasG0 = G.getValue() == 0;
 450
 451   const std::string CpuVer = GetTargetCPUVersion(Args).str();
 452   for (auto &Dir : RootDirs) {
 453     std::string LibDir = Dir + "/hexagon/lib";
 454     std::string LibDirCpu = LibDir + '/' + CpuVer;
 455     if (HasG0) {
 456       if (HasPIC)
 457         LibPaths.push_back(LibDirCpu + "/G0/pic");
 458       LibPaths.push_back(LibDirCpu + "/G0");
 459     }
 460     LibPaths.push_back(LibDirCpu);
 461     LibPaths.push_back(LibDir);
 462   }
 463 }
 464
 465 HexagonToolChain::HexagonToolChain(const Driver &D, const llvm::Triple &Triple,
 466                                    const llvm::opt::ArgList &Args)
 467     : Linux(D, Triple, Args) {
 468   const std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
 469                                                     D.PrefixDirs);
 470
 471   // Note: Generic_GCC::Generic_GCC adds InstalledDir and getDriver().Dir to
 472   // program paths
 473   const std::string BinDir(TargetDir + "/bin");
 474   if (D.getVFS().exists(BinDir))
 475     getProgramPaths().push_back(BinDir);
 476
 477   ToolChain::path_list &LibPaths = getFilePaths();
 478
 479   // Remove paths added by Linux toolchain. Currently Hexagon_TC really targets
 480   // 'elf' OS type, so the Linux paths are not appropriate. When we actually
 481   // support 'linux' we'll need to fix this up
 482   LibPaths.clear();
 483   getHexagonLibraryPaths(Args, LibPaths);
 484 }
 485
 486 HexagonToolChain::~HexagonToolChain() {}
 487
 488 Tool *HexagonToolChain::buildAssembler() const {
 489   return new tools::hexagon::Assembler(*this);
 490 }
 491
 492 Tool *HexagonToolChain::buildLinker() const {
 493   return new tools::hexagon::Linker(*this);
 494 }
 495
 496 unsigned HexagonToolChain::getOptimizationLevel(
 497     const llvm::opt::ArgList &DriverArgs) const {
 498   // Copied in large part from lib/Frontend/CompilerInvocation.cpp.
 499   Arg *A = DriverArgs.getLastArg(options::OPT_O_Group);
 500   if (!A)
 501     return 0;
 502
 503   if (A->getOption().matches(options::OPT_O0))
 504     return 0;
 505   if (A->getOption().matches(options::OPT_Ofast) ||
 506       A->getOption().matches(options::OPT_O4))
 507     return 3;
 508   assert(A->getNumValues() != 0);
 509   StringRef S(A->getValue());
 510   if (S == "s" || S == "z" || S.empty())
 511     return 2;
 512   if (S == "g")
 513     return 1;
 514
 515   unsigned OptLevel;
 516   if (S.getAsInteger(10, OptLevel))
 517     return 0;
 518   return OptLevel;
 519 }
 520
 521 void HexagonToolChain::addClangTargetOptions(const ArgList &DriverArgs,
 522                                              ArgStringList &CC1Args,
 523                                              Action::OffloadKind) const {
 524   if (DriverArgs.hasArg(options::OPT_ffp_contract))
 525     return;
 526   unsigned OptLevel = getOptimizationLevel(DriverArgs);
 527   if (OptLevel >= 3)
 528     CC1Args.push_back("-ffp-contract=fast");
 529 }
 530
 531 void HexagonToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
 532                                                  ArgStringList &CC1Args) const {
 533   if (DriverArgs.hasArg(options::OPT_nostdinc) ||
 534       DriverArgs.hasArg(options::OPT_nostdlibinc))
 535     return;
 536
 537   const Driver &D = getDriver();
 538   std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
 539                                               D.PrefixDirs);
 540   addExternCSystemInclude(DriverArgs, CC1Args, TargetDir + "/hexagon/include");
 541 }
 542
 543
 544 void HexagonToolChain::addLibStdCxxIncludePaths(
 545     const llvm::opt::ArgList &DriverArgs,
 546     llvm::opt::ArgStringList &CC1Args) const {
 547   const Driver &D = getDriver();
 548   std::string TargetDir = getHexagonTargetDir(D.InstalledDir, D.PrefixDirs);
 549   addLibStdCXXIncludePaths(TargetDir, "/hexagon/include/c++", "", "", "", "",
 550                            DriverArgs, CC1Args);
 551 }
 552
 553 ToolChain::CXXStdlibType
 554 HexagonToolChain::GetCXXStdlibType(const ArgList &Args) const {
 555   Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
 556   if (!A)
 557     return ToolChain::CST_Libstdcxx;
 558
 559   StringRef Value = A->getValue();
 560   if (Value != "libstdc++")
 561     getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
 562
 563   return ToolChain::CST_Libstdcxx;
 564 }
 565
 566 //
 567 // Returns the default CPU for Hexagon. This is the default compilation target
 568 // if no Hexagon processor is selected at the command-line.
 569 //
 570 const StringRef HexagonToolChain::GetDefaultCPU() {
 571   return "hexagonv60";
 572 }
 573
 574 const StringRef HexagonToolChain::GetTargetCPUVersion(const ArgList &Args) {
 575   Arg *CpuArg = nullptr;
 576   if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ, options::OPT_march_EQ))
 577     CpuArg = A;
 578
 579   StringRef CPU = CpuArg ? CpuArg->getValue() : GetDefaultCPU();
 580   if (CPU.startswith("hexagon"))
 581     return CPU.substr(sizeof("hexagon") - 1);
 582   return CPU;
 583 }