1 //===--- Hexagon.cpp - Hexagon ToolChain Implementations --------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "Hexagon.h" 10 #include "CommonArgs.h" 11 #include "clang/Driver/Compilation.h" 12 #include "clang/Driver/Driver.h" 13 #include "clang/Driver/DriverDiagnostic.h" 14 #include "clang/Driver/InputInfo.h" 15 #include "clang/Driver/Options.h" 16 #include "llvm/ADT/StringExtras.h" 17 #include "llvm/Option/ArgList.h" 18 #include "llvm/Support/FileSystem.h" 19 #include "llvm/Support/Path.h" 20 #include "llvm/Support/VirtualFileSystem.h" 21 22 using namespace clang::driver; 23 using namespace clang::driver::tools; 24 using namespace clang::driver::toolchains; 25 using namespace clang; 26 using namespace llvm::opt; 27 28 // Default hvx-length for various versions. 29 static StringRef getDefaultHvxLength(StringRef HvxVer) { 30 return llvm::StringSwitch<StringRef>(HvxVer) 31 .Case("v60", "64b") 32 .Case("v62", "64b") 33 .Case("v65", "64b") 34 .Default("128b"); 35 } 36 37 static void handleHVXWarnings(const Driver &D, const ArgList &Args) { 38 // Handle the unsupported values passed to mhvx-length. 39 if (Arg *A = Args.getLastArg(options::OPT_mhexagon_hvx_length_EQ)) { 40 StringRef Val = A->getValue(); 41 if (!Val.equals_insensitive("64b") && !Val.equals_insensitive("128b")) 42 D.Diag(diag::err_drv_unsupported_option_argument) 43 << A->getSpelling() << Val; 44 } 45 } 46 47 // Handle hvx target features explicitly. 48 static void handleHVXTargetFeatures(const Driver &D, const ArgList &Args, 49 std::vector<StringRef> &Features, 50 StringRef Cpu, bool &HasHVX) { 51 // Handle HVX warnings. 52 handleHVXWarnings(D, Args); 53 54 auto makeFeature = [&Args](Twine T, bool Enable) -> StringRef { 55 const std::string &S = T.str(); 56 StringRef Opt(S); 57 if (Opt.endswith("=")) 58 Opt = Opt.drop_back(1); 59 if (Opt.startswith("mno-")) 60 Opt = Opt.drop_front(4); 61 else if (Opt.startswith("m")) 62 Opt = Opt.drop_front(1); 63 return Args.MakeArgString(Twine(Enable ? "+" : "-") + Twine(Opt)); 64 }; 65 66 auto withMinus = [](StringRef S) -> std::string { 67 return "-" + S.str(); 68 }; 69 70 // Drop tiny core suffix for HVX version. 71 std::string HvxVer = 72 (Cpu.back() == 'T' || Cpu.back() == 't' ? Cpu.drop_back(1) : Cpu).str(); 73 HasHVX = false; 74 75 // Handle -mhvx, -mhvx=, -mno-hvx. If versioned and versionless flags 76 // are both present, the last one wins. 77 Arg *HvxEnablingArg = 78 Args.getLastArg(options::OPT_mhexagon_hvx, options::OPT_mhexagon_hvx_EQ, 79 options::OPT_mno_hexagon_hvx); 80 if (HvxEnablingArg) { 81 if (HvxEnablingArg->getOption().matches(options::OPT_mno_hexagon_hvx)) 82 HvxEnablingArg = nullptr; 83 } 84 85 if (HvxEnablingArg) { 86 // If -mhvx[=] was given, it takes precedence. 87 if (Arg *A = Args.getLastArg(options::OPT_mhexagon_hvx, 88 options::OPT_mhexagon_hvx_EQ)) { 89 // If the version was given, set HvxVer. Otherwise HvxVer 90 // will remain equal to the CPU version. 91 if (A->getOption().matches(options::OPT_mhexagon_hvx_EQ)) 92 HvxVer = StringRef(A->getValue()).lower(); 93 } 94 HasHVX = true; 95 Features.push_back(makeFeature(Twine("hvx") + HvxVer, true)); 96 } else if (Arg *A = Args.getLastArg(options::OPT_mno_hexagon_hvx)) { 97 // If there was an explicit -mno-hvx, add -hvx to target features. 98 Features.push_back(makeFeature(A->getOption().getName(), false)); 99 } 100 101 StringRef HvxLen = getDefaultHvxLength(HvxVer); 102 103 // Handle -mhvx-length=. 104 if (Arg *A = Args.getLastArg(options::OPT_mhexagon_hvx_length_EQ)) { 105 // These flags are valid only if HVX in enabled. 106 if (!HasHVX) 107 D.Diag(diag::err_drv_needs_hvx) << withMinus(A->getOption().getName()); 108 else if (A->getOption().matches(options::OPT_mhexagon_hvx_length_EQ)) 109 HvxLen = A->getValue(); 110 } 111 112 if (HasHVX) { 113 StringRef L = makeFeature(Twine("hvx-length") + HvxLen.lower(), true); 114 Features.push_back(L); 115 } 116 117 unsigned HvxVerNum; 118 // getAsInteger returns 'true' on error. 119 if (StringRef(HvxVer).drop_front(1).getAsInteger(10, HvxVerNum)) 120 HvxVerNum = 0; 121 122 // Handle HVX floating point flags. 123 auto checkFlagHvxVersion = 124 [&](auto FlagOn, auto FlagOff, 125 unsigned MinVerNum) -> std::optional<StringRef> { 126 // Return an std::optional<StringRef>: 127 // - std::nullopt indicates a verification failure, or that the flag was not 128 // present in Args. 129 // - Otherwise the returned value is that name of the feature to add 130 // to Features. 131 Arg *A = Args.getLastArg(FlagOn, FlagOff); 132 if (!A) 133 return std::nullopt; 134 135 StringRef OptName = A->getOption().getName(); 136 if (A->getOption().matches(FlagOff)) 137 return makeFeature(OptName, false); 138 139 if (!HasHVX) { 140 D.Diag(diag::err_drv_needs_hvx) << withMinus(OptName); 141 return std::nullopt; 142 } 143 if (HvxVerNum < MinVerNum) { 144 D.Diag(diag::err_drv_needs_hvx_version) 145 << withMinus(OptName) << ("v" + std::to_string(HvxVerNum)); 146 return std::nullopt; 147 } 148 return makeFeature(OptName, true); 149 }; 150 151 if (auto F = checkFlagHvxVersion(options::OPT_mhexagon_hvx_qfloat, 152 options::OPT_mno_hexagon_hvx_qfloat, 68)) { 153 Features.push_back(*F); 154 } 155 if (auto F = checkFlagHvxVersion(options::OPT_mhexagon_hvx_ieee_fp, 156 options::OPT_mno_hexagon_hvx_ieee_fp, 68)) { 157 Features.push_back(*F); 158 } 159 } 160 161 // Hexagon target features. 162 void hexagon::getHexagonTargetFeatures(const Driver &D, const ArgList &Args, 163 std::vector<StringRef> &Features) { 164 handleTargetFeaturesGroup(Args, Features, 165 options::OPT_m_hexagon_Features_Group); 166 167 bool UseLongCalls = false; 168 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls, 169 options::OPT_mno_long_calls)) { 170 if (A->getOption().matches(options::OPT_mlong_calls)) 171 UseLongCalls = true; 172 } 173 174 Features.push_back(UseLongCalls ? "+long-calls" : "-long-calls"); 175 176 bool HasHVX = false; 177 StringRef Cpu(toolchains::HexagonToolChain::GetTargetCPUVersion(Args)); 178 // 't' in Cpu denotes tiny-core micro-architecture. For now, the co-processors 179 // have no dependency on micro-architecture. 180 const bool TinyCore = Cpu.contains('t'); 181 182 if (TinyCore) 183 Cpu = Cpu.take_front(Cpu.size() - 1); 184 185 handleHVXTargetFeatures(D, Args, Features, Cpu, HasHVX); 186 187 if (HexagonToolChain::isAutoHVXEnabled(Args) && !HasHVX) 188 D.Diag(diag::warn_drv_needs_hvx) << "auto-vectorization"; 189 } 190 191 // Hexagon tools start. 192 void hexagon::Assembler::RenderExtraToolArgs(const JobAction &JA, 193 ArgStringList &CmdArgs) const { 194 } 195 196 void hexagon::Assembler::ConstructJob(Compilation &C, const JobAction &JA, 197 const InputInfo &Output, 198 const InputInfoList &Inputs, 199 const ArgList &Args, 200 const char *LinkingOutput) const { 201 claimNoWarnArgs(Args); 202 203 auto &HTC = static_cast<const toolchains::HexagonToolChain&>(getToolChain()); 204 const Driver &D = HTC.getDriver(); 205 ArgStringList CmdArgs; 206 207 CmdArgs.push_back("--arch=hexagon"); 208 209 RenderExtraToolArgs(JA, CmdArgs); 210 211 const char *AsName = "llvm-mc"; 212 CmdArgs.push_back("-filetype=obj"); 213 CmdArgs.push_back(Args.MakeArgString( 214 "-mcpu=hexagon" + 215 toolchains::HexagonToolChain::GetTargetCPUVersion(Args))); 216 217 addSanitizerRuntimes(HTC, Args, CmdArgs); 218 219 if (Output.isFilename()) { 220 CmdArgs.push_back("-o"); 221 CmdArgs.push_back(Output.getFilename()); 222 } else { 223 assert(Output.isNothing() && "Unexpected output"); 224 CmdArgs.push_back("-fsyntax-only"); 225 } 226 227 if (Arg *A = Args.getLastArg(options::OPT_mhexagon_hvx_ieee_fp, 228 options::OPT_mno_hexagon_hvx_ieee_fp)) { 229 if (A->getOption().matches(options::OPT_mhexagon_hvx_ieee_fp)) 230 CmdArgs.push_back("-mhvx-ieee-fp"); 231 } 232 233 if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) { 234 CmdArgs.push_back(Args.MakeArgString("-gpsize=" + Twine(*G))); 235 } 236 237 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler); 238 239 // Only pass -x if gcc will understand it; otherwise hope gcc 240 // understands the suffix correctly. The main use case this would go 241 // wrong in is for linker inputs if they happened to have an odd 242 // suffix; really the only way to get this to happen is a command 243 // like '-x foobar a.c' which will treat a.c like a linker input. 244 // 245 // FIXME: For the linker case specifically, can we safely convert 246 // inputs into '-Wl,' options? 247 for (const auto &II : Inputs) { 248 // Don't try to pass LLVM or AST inputs to a generic gcc. 249 if (types::isLLVMIR(II.getType())) 250 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 251 << HTC.getTripleString(); 252 else if (II.getType() == types::TY_AST) 253 D.Diag(clang::diag::err_drv_no_ast_support) 254 << HTC.getTripleString(); 255 else if (II.getType() == types::TY_ModuleFile) 256 D.Diag(diag::err_drv_no_module_support) 257 << HTC.getTripleString(); 258 259 if (II.isFilename()) 260 CmdArgs.push_back(II.getFilename()); 261 else 262 // Don't render as input, we need gcc to do the translations. 263 // FIXME: What is this? 264 II.getInputArg().render(Args, CmdArgs); 265 } 266 267 auto *Exec = Args.MakeArgString(HTC.GetProgramPath(AsName)); 268 C.addCommand(std::make_unique<Command>(JA, *this, 269 ResponseFileSupport::AtFileCurCP(), 270 Exec, CmdArgs, Inputs, Output)); 271 } 272 273 void hexagon::Linker::RenderExtraToolArgs(const JobAction &JA, 274 ArgStringList &CmdArgs) const { 275 } 276 277 static void 278 constructHexagonLinkArgs(Compilation &C, const JobAction &JA, 279 const toolchains::HexagonToolChain &HTC, 280 const InputInfo &Output, const InputInfoList &Inputs, 281 const ArgList &Args, ArgStringList &CmdArgs, 282 const char *LinkingOutput) { 283 284 const Driver &D = HTC.getDriver(); 285 286 //---------------------------------------------------------------------------- 287 // 288 //---------------------------------------------------------------------------- 289 bool IsStatic = Args.hasArg(options::OPT_static); 290 bool IsShared = Args.hasArg(options::OPT_shared); 291 bool IsPIE = Args.hasArg(options::OPT_pie); 292 bool IncStdLib = !Args.hasArg(options::OPT_nostdlib); 293 bool IncStartFiles = !Args.hasArg(options::OPT_nostartfiles); 294 bool IncDefLibs = !Args.hasArg(options::OPT_nodefaultlibs); 295 bool UseG0 = false; 296 const char *Exec = Args.MakeArgString(HTC.GetLinkerPath()); 297 bool UseLLD = (llvm::sys::path::filename(Exec).equals_insensitive("ld.lld") || 298 llvm::sys::path::stem(Exec).equals_insensitive("ld.lld")); 299 bool UseShared = IsShared && !IsStatic; 300 StringRef CpuVer = toolchains::HexagonToolChain::GetTargetCPUVersion(Args); 301 302 bool NeedsSanitizerDeps = addSanitizerRuntimes(HTC, Args, CmdArgs); 303 bool NeedsXRayDeps = addXRayRuntime(HTC, Args, CmdArgs); 304 305 //---------------------------------------------------------------------------- 306 // Silence warnings for various options 307 //---------------------------------------------------------------------------- 308 Args.ClaimAllArgs(options::OPT_g_Group); 309 Args.ClaimAllArgs(options::OPT_emit_llvm); 310 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already 311 // handled somewhere else. 312 Args.ClaimAllArgs(options::OPT_static_libgcc); 313 314 //---------------------------------------------------------------------------- 315 // 316 //---------------------------------------------------------------------------- 317 if (Args.hasArg(options::OPT_s)) 318 CmdArgs.push_back("-s"); 319 320 if (Args.hasArg(options::OPT_r)) 321 CmdArgs.push_back("-r"); 322 323 for (const auto &Opt : HTC.ExtraOpts) 324 CmdArgs.push_back(Opt.c_str()); 325 326 if (!UseLLD) { 327 CmdArgs.push_back("-march=hexagon"); 328 CmdArgs.push_back(Args.MakeArgString("-mcpu=hexagon" + CpuVer)); 329 } 330 331 if (IsShared) { 332 CmdArgs.push_back("-shared"); 333 // The following should be the default, but doing as hexagon-gcc does. 334 CmdArgs.push_back("-call_shared"); 335 } 336 337 if (IsStatic) 338 CmdArgs.push_back("-static"); 339 340 if (IsPIE && !IsShared) 341 CmdArgs.push_back("-pie"); 342 343 if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) { 344 CmdArgs.push_back(Args.MakeArgString("-G" + Twine(*G))); 345 UseG0 = *G == 0; 346 } 347 348 CmdArgs.push_back("-o"); 349 CmdArgs.push_back(Output.getFilename()); 350 351 if (HTC.getTriple().isMusl()) { 352 if (!Args.hasArg(options::OPT_shared, options::OPT_static)) 353 CmdArgs.push_back("-dynamic-linker=/lib/ld-musl-hexagon.so.1"); 354 355 if (!Args.hasArg(options::OPT_shared, options::OPT_nostartfiles, 356 options::OPT_nostdlib)) 357 CmdArgs.push_back(Args.MakeArgString(D.SysRoot + "/usr/lib/crt1.o")); 358 else if (Args.hasArg(options::OPT_shared) && 359 !Args.hasArg(options::OPT_nostartfiles, options::OPT_nostdlib)) 360 CmdArgs.push_back(Args.MakeArgString(D.SysRoot + "/usr/lib/crti.o")); 361 362 CmdArgs.push_back( 363 Args.MakeArgString(StringRef("-L") + D.SysRoot + "/usr/lib")); 364 Args.AddAllArgs(CmdArgs, 365 {options::OPT_T_Group, options::OPT_e, options::OPT_s, 366 options::OPT_t, options::OPT_u_Group}); 367 AddLinkerInputs(HTC, Inputs, Args, CmdArgs, JA); 368 369 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) { 370 if (NeedsSanitizerDeps) { 371 linkSanitizerRuntimeDeps(HTC, CmdArgs); 372 373 CmdArgs.push_back("-lunwind"); 374 } 375 if (NeedsXRayDeps) 376 linkXRayRuntimeDeps(HTC, CmdArgs); 377 378 CmdArgs.push_back("-lclang_rt.builtins-hexagon"); 379 CmdArgs.push_back("-lc"); 380 } 381 if (D.CCCIsCXX()) { 382 if (HTC.ShouldLinkCXXStdlib(Args)) 383 HTC.AddCXXStdlibLibArgs(Args, CmdArgs); 384 } 385 return; 386 } 387 388 //---------------------------------------------------------------------------- 389 // moslib 390 //---------------------------------------------------------------------------- 391 std::vector<std::string> OsLibs; 392 bool HasStandalone = false; 393 for (const Arg *A : Args.filtered(options::OPT_moslib_EQ)) { 394 A->claim(); 395 OsLibs.emplace_back(A->getValue()); 396 HasStandalone = HasStandalone || (OsLibs.back() == "standalone"); 397 } 398 if (OsLibs.empty()) { 399 OsLibs.push_back("standalone"); 400 HasStandalone = true; 401 } 402 403 //---------------------------------------------------------------------------- 404 // Start Files 405 //---------------------------------------------------------------------------- 406 const std::string MCpuSuffix = "/" + CpuVer.str(); 407 const std::string MCpuG0Suffix = MCpuSuffix + "/G0"; 408 const std::string RootDir = 409 HTC.getHexagonTargetDir(D.InstalledDir, D.PrefixDirs) + "/"; 410 const std::string StartSubDir = 411 "hexagon/lib" + (UseG0 ? MCpuG0Suffix : MCpuSuffix); 412 413 auto Find = [&HTC] (const std::string &RootDir, const std::string &SubDir, 414 const char *Name) -> std::string { 415 std::string RelName = SubDir + Name; 416 std::string P = HTC.GetFilePath(RelName.c_str()); 417 if (llvm::sys::fs::exists(P)) 418 return P; 419 return RootDir + RelName; 420 }; 421 422 if (IncStdLib && IncStartFiles) { 423 if (!IsShared) { 424 if (HasStandalone) { 425 std::string Crt0SA = Find(RootDir, StartSubDir, "/crt0_standalone.o"); 426 CmdArgs.push_back(Args.MakeArgString(Crt0SA)); 427 } 428 std::string Crt0 = Find(RootDir, StartSubDir, "/crt0.o"); 429 CmdArgs.push_back(Args.MakeArgString(Crt0)); 430 } 431 std::string Init = UseShared 432 ? Find(RootDir, StartSubDir + "/pic", "/initS.o") 433 : Find(RootDir, StartSubDir, "/init.o"); 434 CmdArgs.push_back(Args.MakeArgString(Init)); 435 } 436 437 //---------------------------------------------------------------------------- 438 // Library Search Paths 439 //---------------------------------------------------------------------------- 440 const ToolChain::path_list &LibPaths = HTC.getFilePaths(); 441 for (const auto &LibPath : LibPaths) 442 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath)); 443 444 //---------------------------------------------------------------------------- 445 // 446 //---------------------------------------------------------------------------- 447 Args.AddAllArgs(CmdArgs, 448 {options::OPT_T_Group, options::OPT_e, options::OPT_s, 449 options::OPT_t, options::OPT_u_Group}); 450 451 AddLinkerInputs(HTC, Inputs, Args, CmdArgs, JA); 452 453 //---------------------------------------------------------------------------- 454 // Libraries 455 //---------------------------------------------------------------------------- 456 if (IncStdLib && IncDefLibs) { 457 if (D.CCCIsCXX()) { 458 if (HTC.ShouldLinkCXXStdlib(Args)) 459 HTC.AddCXXStdlibLibArgs(Args, CmdArgs); 460 CmdArgs.push_back("-lm"); 461 } 462 463 CmdArgs.push_back("--start-group"); 464 465 if (!IsShared) { 466 for (StringRef Lib : OsLibs) 467 CmdArgs.push_back(Args.MakeArgString("-l" + Lib)); 468 CmdArgs.push_back("-lc"); 469 } 470 CmdArgs.push_back("-lgcc"); 471 472 CmdArgs.push_back("--end-group"); 473 } 474 475 //---------------------------------------------------------------------------- 476 // End files 477 //---------------------------------------------------------------------------- 478 if (IncStdLib && IncStartFiles) { 479 std::string Fini = UseShared 480 ? Find(RootDir, StartSubDir + "/pic", "/finiS.o") 481 : Find(RootDir, StartSubDir, "/fini.o"); 482 CmdArgs.push_back(Args.MakeArgString(Fini)); 483 } 484 } 485 486 void hexagon::Linker::ConstructJob(Compilation &C, const JobAction &JA, 487 const InputInfo &Output, 488 const InputInfoList &Inputs, 489 const ArgList &Args, 490 const char *LinkingOutput) const { 491 auto &HTC = static_cast<const toolchains::HexagonToolChain&>(getToolChain()); 492 493 ArgStringList CmdArgs; 494 constructHexagonLinkArgs(C, JA, HTC, Output, Inputs, Args, CmdArgs, 495 LinkingOutput); 496 497 const char *Exec = Args.MakeArgString(HTC.GetLinkerPath()); 498 C.addCommand(std::make_unique<Command>(JA, *this, 499 ResponseFileSupport::AtFileCurCP(), 500 Exec, CmdArgs, Inputs, Output)); 501 } 502 // Hexagon tools end. 503 504 /// Hexagon Toolchain 505 506 std::string HexagonToolChain::getHexagonTargetDir( 507 const std::string &InstalledDir, 508 const SmallVectorImpl<std::string> &PrefixDirs) const { 509 std::string InstallRelDir; 510 const Driver &D = getDriver(); 511 512 // Locate the rest of the toolchain ... 513 for (auto &I : PrefixDirs) 514 if (D.getVFS().exists(I)) 515 return I; 516 517 if (getVFS().exists(InstallRelDir = InstalledDir + "/../target")) 518 return InstallRelDir; 519 520 return InstalledDir; 521 } 522 523 std::optional<unsigned> 524 HexagonToolChain::getSmallDataThreshold(const ArgList &Args) { 525 StringRef Gn = ""; 526 if (Arg *A = Args.getLastArg(options::OPT_G)) { 527 Gn = A->getValue(); 528 } else if (Args.getLastArg(options::OPT_shared, options::OPT_fpic, 529 options::OPT_fPIC)) { 530 Gn = "0"; 531 } 532 533 unsigned G; 534 if (!Gn.getAsInteger(10, G)) 535 return G; 536 537 return std::nullopt; 538 } 539 540 std::string HexagonToolChain::getCompilerRTPath() const { 541 SmallString<128> Dir(getDriver().SysRoot); 542 llvm::sys::path::append(Dir, "usr", "lib"); 543 Dir += SelectedMultilib.gccSuffix(); 544 return std::string(Dir.str()); 545 } 546 547 void HexagonToolChain::getHexagonLibraryPaths(const ArgList &Args, 548 ToolChain::path_list &LibPaths) const { 549 const Driver &D = getDriver(); 550 551 //---------------------------------------------------------------------------- 552 // -L Args 553 //---------------------------------------------------------------------------- 554 for (Arg *A : Args.filtered(options::OPT_L)) 555 llvm::append_range(LibPaths, A->getValues()); 556 557 //---------------------------------------------------------------------------- 558 // Other standard paths 559 //---------------------------------------------------------------------------- 560 std::vector<std::string> RootDirs; 561 std::copy(D.PrefixDirs.begin(), D.PrefixDirs.end(), 562 std::back_inserter(RootDirs)); 563 564 std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(), 565 D.PrefixDirs); 566 if (!llvm::is_contained(RootDirs, TargetDir)) 567 RootDirs.push_back(TargetDir); 568 569 bool HasPIC = Args.hasArg(options::OPT_fpic, options::OPT_fPIC); 570 // Assume G0 with -shared. 571 bool HasG0 = Args.hasArg(options::OPT_shared); 572 if (auto G = getSmallDataThreshold(Args)) 573 HasG0 = *G == 0; 574 575 const std::string CpuVer = GetTargetCPUVersion(Args).str(); 576 for (auto &Dir : RootDirs) { 577 std::string LibDir = Dir + "/hexagon/lib"; 578 std::string LibDirCpu = LibDir + '/' + CpuVer; 579 if (HasG0) { 580 if (HasPIC) 581 LibPaths.push_back(LibDirCpu + "/G0/pic"); 582 LibPaths.push_back(LibDirCpu + "/G0"); 583 } 584 LibPaths.push_back(LibDirCpu); 585 LibPaths.push_back(LibDir); 586 } 587 } 588 589 HexagonToolChain::HexagonToolChain(const Driver &D, const llvm::Triple &Triple, 590 const llvm::opt::ArgList &Args) 591 : Linux(D, Triple, Args) { 592 const std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(), 593 D.PrefixDirs); 594 595 // Note: Generic_GCC::Generic_GCC adds InstalledDir and getDriver().Dir to 596 // program paths 597 const std::string BinDir(TargetDir + "/bin"); 598 if (D.getVFS().exists(BinDir)) 599 getProgramPaths().push_back(BinDir); 600 601 ToolChain::path_list &LibPaths = getFilePaths(); 602 603 // Remove paths added by Linux toolchain. Currently Hexagon_TC really targets 604 // 'elf' OS type, so the Linux paths are not appropriate. When we actually 605 // support 'linux' we'll need to fix this up 606 LibPaths.clear(); 607 getHexagonLibraryPaths(Args, LibPaths); 608 } 609 610 HexagonToolChain::~HexagonToolChain() {} 611 612 void HexagonToolChain::AddCXXStdlibLibArgs(const ArgList &Args, 613 ArgStringList &CmdArgs) const { 614 CXXStdlibType Type = GetCXXStdlibType(Args); 615 switch (Type) { 616 case ToolChain::CST_Libcxx: 617 CmdArgs.push_back("-lc++"); 618 if (Args.hasArg(options::OPT_fexperimental_library)) 619 CmdArgs.push_back("-lc++experimental"); 620 CmdArgs.push_back("-lc++abi"); 621 CmdArgs.push_back("-lunwind"); 622 break; 623 624 case ToolChain::CST_Libstdcxx: 625 CmdArgs.push_back("-lstdc++"); 626 break; 627 } 628 } 629 630 Tool *HexagonToolChain::buildAssembler() const { 631 return new tools::hexagon::Assembler(*this); 632 } 633 634 Tool *HexagonToolChain::buildLinker() const { 635 return new tools::hexagon::Linker(*this); 636 } 637 638 unsigned HexagonToolChain::getOptimizationLevel( 639 const llvm::opt::ArgList &DriverArgs) const { 640 // Copied in large part from lib/Frontend/CompilerInvocation.cpp. 641 Arg *A = DriverArgs.getLastArg(options::OPT_O_Group); 642 if (!A) 643 return 0; 644 645 if (A->getOption().matches(options::OPT_O0)) 646 return 0; 647 if (A->getOption().matches(options::OPT_Ofast) || 648 A->getOption().matches(options::OPT_O4)) 649 return 3; 650 assert(A->getNumValues() != 0); 651 StringRef S(A->getValue()); 652 if (S == "s" || S == "z" || S.empty()) 653 return 2; 654 if (S == "g") 655 return 1; 656 657 unsigned OptLevel; 658 if (S.getAsInteger(10, OptLevel)) 659 return 0; 660 return OptLevel; 661 } 662 663 void HexagonToolChain::addClangTargetOptions(const ArgList &DriverArgs, 664 ArgStringList &CC1Args, 665 Action::OffloadKind) const { 666 667 bool UseInitArrayDefault = getTriple().isMusl(); 668 669 if (!DriverArgs.hasFlag(options::OPT_fuse_init_array, 670 options::OPT_fno_use_init_array, 671 UseInitArrayDefault)) 672 CC1Args.push_back("-fno-use-init-array"); 673 674 if (DriverArgs.hasArg(options::OPT_ffixed_r19)) { 675 CC1Args.push_back("-target-feature"); 676 CC1Args.push_back("+reserved-r19"); 677 } 678 if (isAutoHVXEnabled(DriverArgs)) { 679 CC1Args.push_back("-mllvm"); 680 CC1Args.push_back("-hexagon-autohvx"); 681 } 682 } 683 684 void HexagonToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs, 685 ArgStringList &CC1Args) const { 686 if (DriverArgs.hasArg(options::OPT_nostdinc)) 687 return; 688 689 const bool IsELF = !getTriple().isMusl() && !getTriple().isOSLinux(); 690 const bool IsLinuxMusl = getTriple().isMusl() && getTriple().isOSLinux(); 691 692 const Driver &D = getDriver(); 693 SmallString<128> ResourceDirInclude(D.ResourceDir); 694 if (!IsELF) { 695 llvm::sys::path::append(ResourceDirInclude, "include"); 696 if (!DriverArgs.hasArg(options::OPT_nobuiltininc) && 697 (!IsLinuxMusl || DriverArgs.hasArg(options::OPT_nostdlibinc))) 698 addSystemInclude(DriverArgs, CC1Args, ResourceDirInclude); 699 } 700 if (DriverArgs.hasArg(options::OPT_nostdlibinc)) 701 return; 702 703 const bool HasSysRoot = !D.SysRoot.empty(); 704 if (HasSysRoot) { 705 SmallString<128> P(D.SysRoot); 706 if (IsLinuxMusl) 707 llvm::sys::path::append(P, "usr/include"); 708 else 709 llvm::sys::path::append(P, "include"); 710 711 addExternCSystemInclude(DriverArgs, CC1Args, P.str()); 712 // LOCAL_INCLUDE_DIR 713 addSystemInclude(DriverArgs, CC1Args, P + "/usr/local/include"); 714 // TOOL_INCLUDE_DIR 715 AddMultilibIncludeArgs(DriverArgs, CC1Args); 716 } 717 718 if (!DriverArgs.hasArg(options::OPT_nobuiltininc) && IsLinuxMusl) 719 addSystemInclude(DriverArgs, CC1Args, ResourceDirInclude); 720 721 if (HasSysRoot) 722 return; 723 std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(), 724 D.PrefixDirs); 725 addExternCSystemInclude(DriverArgs, CC1Args, TargetDir + "/hexagon/include"); 726 } 727 728 void HexagonToolChain::addLibCxxIncludePaths( 729 const llvm::opt::ArgList &DriverArgs, 730 llvm::opt::ArgStringList &CC1Args) const { 731 const Driver &D = getDriver(); 732 if (!D.SysRoot.empty() && getTriple().isMusl()) 733 addLibStdCXXIncludePaths(D.SysRoot + "/usr/include/c++/v1", "", "", 734 DriverArgs, CC1Args); 735 else if (getTriple().isMusl()) 736 addLibStdCXXIncludePaths("/usr/include/c++/v1", "", "", DriverArgs, 737 CC1Args); 738 else { 739 std::string TargetDir = getHexagonTargetDir(D.InstalledDir, D.PrefixDirs); 740 addLibStdCXXIncludePaths(TargetDir + "/hexagon/include/c++/v1", "", "", 741 DriverArgs, CC1Args); 742 } 743 } 744 void HexagonToolChain::addLibStdCxxIncludePaths( 745 const llvm::opt::ArgList &DriverArgs, 746 llvm::opt::ArgStringList &CC1Args) const { 747 const Driver &D = getDriver(); 748 std::string TargetDir = getHexagonTargetDir(D.InstalledDir, D.PrefixDirs); 749 addLibStdCXXIncludePaths(TargetDir + "/hexagon/include/c++", "", "", 750 DriverArgs, CC1Args); 751 } 752 753 ToolChain::CXXStdlibType 754 HexagonToolChain::GetCXXStdlibType(const ArgList &Args) const { 755 Arg *A = Args.getLastArg(options::OPT_stdlib_EQ); 756 if (!A) { 757 if (getTriple().isMusl()) 758 return ToolChain::CST_Libcxx; 759 else 760 return ToolChain::CST_Libstdcxx; 761 } 762 StringRef Value = A->getValue(); 763 if (Value != "libstdc++" && Value != "libc++") 764 getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args); 765 766 if (Value == "libstdc++") 767 return ToolChain::CST_Libstdcxx; 768 else if (Value == "libc++") 769 return ToolChain::CST_Libcxx; 770 else 771 return ToolChain::CST_Libstdcxx; 772 } 773 774 bool HexagonToolChain::isAutoHVXEnabled(const llvm::opt::ArgList &Args) { 775 if (Arg *A = Args.getLastArg(options::OPT_fvectorize, 776 options::OPT_fno_vectorize)) 777 return A->getOption().matches(options::OPT_fvectorize); 778 return false; 779 } 780 781 // 782 // Returns the default CPU for Hexagon. This is the default compilation target 783 // if no Hexagon processor is selected at the command-line. 784 // 785 StringRef HexagonToolChain::GetDefaultCPU() { 786 return "hexagonv60"; 787 } 788 789 StringRef HexagonToolChain::GetTargetCPUVersion(const ArgList &Args) { 790 Arg *CpuArg = nullptr; 791 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) 792 CpuArg = A; 793 794 StringRef CPU = CpuArg ? CpuArg->getValue() : GetDefaultCPU(); 795 if (CPU.startswith("hexagon")) 796 return CPU.substr(sizeof("hexagon") - 1); 797 return CPU; 798 } 799