xref: /freebsd/contrib/llvm-project/clang/lib/Driver/ToolChains/Hexagon.cpp (revision 5b56413d04e608379c9a306373554a8e4d321bc0)
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.ends_with("="))
58       Opt = Opt.drop_back(1);
59     if (Opt.starts_with("mno-"))
60       Opt = Opt.drop_front(4);
61     else if (Opt.starts_with("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,
163                                        const llvm::Triple &Triple,
164                                        const ArgList &Args,
165                                        std::vector<StringRef> &Features) {
166   handleTargetFeaturesGroup(D, Triple, Args, Features,
167                             options::OPT_m_hexagon_Features_Group);
168 
169   bool UseLongCalls = false;
170   if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
171                                options::OPT_mno_long_calls)) {
172     if (A->getOption().matches(options::OPT_mlong_calls))
173       UseLongCalls = true;
174   }
175 
176   Features.push_back(UseLongCalls ? "+long-calls" : "-long-calls");
177 
178   bool HasHVX = false;
179   StringRef Cpu(toolchains::HexagonToolChain::GetTargetCPUVersion(Args));
180   // 't' in Cpu denotes tiny-core micro-architecture. For now, the co-processors
181   // have no dependency on micro-architecture.
182   const bool TinyCore = Cpu.contains('t');
183 
184   if (TinyCore)
185     Cpu = Cpu.take_front(Cpu.size() - 1);
186 
187   handleHVXTargetFeatures(D, Args, Features, Cpu, HasHVX);
188 
189   if (HexagonToolChain::isAutoHVXEnabled(Args) && !HasHVX)
190     D.Diag(diag::warn_drv_needs_hvx) << "auto-vectorization";
191 }
192 
193 // Hexagon tools start.
194 void hexagon::Assembler::RenderExtraToolArgs(const JobAction &JA,
195                                              ArgStringList &CmdArgs) const {
196 }
197 
198 void hexagon::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
199                                       const InputInfo &Output,
200                                       const InputInfoList &Inputs,
201                                       const ArgList &Args,
202                                       const char *LinkingOutput) const {
203   claimNoWarnArgs(Args);
204 
205   auto &HTC = static_cast<const toolchains::HexagonToolChain&>(getToolChain());
206   const Driver &D = HTC.getDriver();
207   ArgStringList CmdArgs;
208 
209   CmdArgs.push_back("--arch=hexagon");
210 
211   RenderExtraToolArgs(JA, CmdArgs);
212 
213   const char *AsName = "llvm-mc";
214   CmdArgs.push_back("-filetype=obj");
215   CmdArgs.push_back(Args.MakeArgString(
216       "-mcpu=hexagon" +
217       toolchains::HexagonToolChain::GetTargetCPUVersion(Args)));
218 
219   addSanitizerRuntimes(HTC, Args, CmdArgs);
220 
221   assert((Output.isFilename() || Output.isNothing()) && "Invalid output.");
222   if (Output.isFilename()) {
223     CmdArgs.push_back("-o");
224     CmdArgs.push_back(Output.getFilename());
225   } else {
226     CmdArgs.push_back("-fsyntax-only");
227   }
228 
229   if (Arg *A = Args.getLastArg(options::OPT_mhexagon_hvx_ieee_fp,
230                                options::OPT_mno_hexagon_hvx_ieee_fp)) {
231     if (A->getOption().matches(options::OPT_mhexagon_hvx_ieee_fp))
232       CmdArgs.push_back("-mhvx-ieee-fp");
233   }
234 
235   if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) {
236     CmdArgs.push_back(Args.MakeArgString("-gpsize=" + Twine(*G)));
237   }
238 
239   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
240 
241   // Only pass -x if gcc will understand it; otherwise hope gcc
242   // understands the suffix correctly. The main use case this would go
243   // wrong in is for linker inputs if they happened to have an odd
244   // suffix; really the only way to get this to happen is a command
245   // like '-x foobar a.c' which will treat a.c like a linker input.
246   //
247   // FIXME: For the linker case specifically, can we safely convert
248   // inputs into '-Wl,' options?
249   for (const auto &II : Inputs) {
250     // Don't try to pass LLVM or AST inputs to a generic gcc.
251     if (types::isLLVMIR(II.getType()))
252       D.Diag(clang::diag::err_drv_no_linker_llvm_support)
253           << HTC.getTripleString();
254     else if (II.getType() == types::TY_AST)
255       D.Diag(clang::diag::err_drv_no_ast_support)
256           << HTC.getTripleString();
257     else if (II.getType() == types::TY_ModuleFile)
258       D.Diag(diag::err_drv_no_module_support)
259           << HTC.getTripleString();
260 
261     if (II.isFilename())
262       CmdArgs.push_back(II.getFilename());
263     else
264       // Don't render as input, we need gcc to do the translations.
265       // FIXME: What is this?
266       II.getInputArg().render(Args, CmdArgs);
267   }
268 
269   auto *Exec = Args.MakeArgString(HTC.GetProgramPath(AsName));
270   C.addCommand(std::make_unique<Command>(JA, *this,
271                                          ResponseFileSupport::AtFileCurCP(),
272                                          Exec, CmdArgs, Inputs, Output));
273 }
274 
275 void hexagon::Linker::RenderExtraToolArgs(const JobAction &JA,
276                                           ArgStringList &CmdArgs) const {
277 }
278 
279 static void
280 constructHexagonLinkArgs(Compilation &C, const JobAction &JA,
281                          const toolchains::HexagonToolChain &HTC,
282                          const InputInfo &Output, const InputInfoList &Inputs,
283                          const ArgList &Args, ArgStringList &CmdArgs,
284                          const char *LinkingOutput) {
285 
286   const Driver &D = HTC.getDriver();
287 
288   //----------------------------------------------------------------------------
289   //
290   //----------------------------------------------------------------------------
291   bool IsStatic = Args.hasArg(options::OPT_static);
292   bool IsShared = Args.hasArg(options::OPT_shared);
293   bool IsPIE = Args.hasArg(options::OPT_pie);
294   bool IncStdLib = !Args.hasArg(options::OPT_nostdlib);
295   bool IncStartFiles = !Args.hasArg(options::OPT_nostartfiles);
296   bool IncDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
297   bool UseG0 = false;
298   const char *Exec = Args.MakeArgString(HTC.GetLinkerPath());
299   bool UseLLD = (llvm::sys::path::filename(Exec).equals_insensitive("ld.lld") ||
300                  llvm::sys::path::stem(Exec).equals_insensitive("ld.lld"));
301   bool UseShared = IsShared && !IsStatic;
302   StringRef CpuVer = toolchains::HexagonToolChain::GetTargetCPUVersion(Args);
303 
304   bool NeedsSanitizerDeps = addSanitizerRuntimes(HTC, Args, CmdArgs);
305   bool NeedsXRayDeps = addXRayRuntime(HTC, Args, CmdArgs);
306 
307   //----------------------------------------------------------------------------
308   // Silence warnings for various options
309   //----------------------------------------------------------------------------
310   Args.ClaimAllArgs(options::OPT_g_Group);
311   Args.ClaimAllArgs(options::OPT_emit_llvm);
312   Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
313                                      // handled somewhere else.
314   Args.ClaimAllArgs(options::OPT_static_libgcc);
315 
316   //----------------------------------------------------------------------------
317   //
318   //----------------------------------------------------------------------------
319   if (Args.hasArg(options::OPT_s))
320     CmdArgs.push_back("-s");
321 
322   if (Args.hasArg(options::OPT_r))
323     CmdArgs.push_back("-r");
324 
325   for (const auto &Opt : HTC.ExtraOpts)
326     CmdArgs.push_back(Opt.c_str());
327 
328   if (!UseLLD) {
329     CmdArgs.push_back("-march=hexagon");
330     CmdArgs.push_back(Args.MakeArgString("-mcpu=hexagon" + CpuVer));
331   }
332 
333   if (IsShared) {
334     CmdArgs.push_back("-shared");
335     // The following should be the default, but doing as hexagon-gcc does.
336     CmdArgs.push_back("-call_shared");
337   }
338 
339   if (IsStatic)
340     CmdArgs.push_back("-static");
341 
342   if (IsPIE && !IsShared)
343     CmdArgs.push_back("-pie");
344 
345   if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) {
346     CmdArgs.push_back(Args.MakeArgString("-G" + Twine(*G)));
347     UseG0 = *G == 0;
348   }
349 
350   CmdArgs.push_back("-o");
351   CmdArgs.push_back(Output.getFilename());
352 
353   if (HTC.getTriple().isMusl()) {
354     if (!Args.hasArg(options::OPT_shared, options::OPT_static))
355       CmdArgs.push_back("-dynamic-linker=/lib/ld-musl-hexagon.so.1");
356 
357     if (!Args.hasArg(options::OPT_shared, options::OPT_nostartfiles,
358                      options::OPT_nostdlib))
359       CmdArgs.push_back(Args.MakeArgString(D.SysRoot + "/usr/lib/crt1.o"));
360     else if (Args.hasArg(options::OPT_shared) &&
361              !Args.hasArg(options::OPT_nostartfiles, options::OPT_nostdlib))
362       CmdArgs.push_back(Args.MakeArgString(D.SysRoot + "/usr/lib/crti.o"));
363 
364     CmdArgs.push_back(
365         Args.MakeArgString(StringRef("-L") + D.SysRoot + "/usr/lib"));
366     Args.addAllArgs(CmdArgs, {options::OPT_T_Group, options::OPT_s,
367                               options::OPT_t, options::OPT_u_Group});
368     AddLinkerInputs(HTC, Inputs, Args, CmdArgs, JA);
369 
370     if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
371       if (NeedsSanitizerDeps) {
372         linkSanitizerRuntimeDeps(HTC, Args, CmdArgs);
373 
374         CmdArgs.push_back("-lunwind");
375       }
376       if (NeedsXRayDeps)
377         linkXRayRuntimeDeps(HTC, Args, CmdArgs);
378 
379       CmdArgs.push_back("-lclang_rt.builtins-hexagon");
380       if (!Args.hasArg(options::OPT_nolibc))
381         CmdArgs.push_back("-lc");
382     }
383     if (D.CCCIsCXX()) {
384       if (HTC.ShouldLinkCXXStdlib(Args))
385         HTC.AddCXXStdlibLibArgs(Args, CmdArgs);
386     }
387     const ToolChain::path_list &LibPaths = HTC.getFilePaths();
388     for (const auto &LibPath : LibPaths)
389       CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
390     Args.ClaimAllArgs(options::OPT_L);
391     return;
392   }
393 
394   //----------------------------------------------------------------------------
395   // moslib
396   //----------------------------------------------------------------------------
397   std::vector<std::string> OsLibs;
398   bool HasStandalone = false;
399   for (const Arg *A : Args.filtered(options::OPT_moslib_EQ)) {
400     A->claim();
401     OsLibs.emplace_back(A->getValue());
402     HasStandalone = HasStandalone || (OsLibs.back() == "standalone");
403   }
404   if (OsLibs.empty()) {
405     OsLibs.push_back("standalone");
406     HasStandalone = true;
407   }
408 
409   //----------------------------------------------------------------------------
410   // Start Files
411   //----------------------------------------------------------------------------
412   const std::string MCpuSuffix = "/" + CpuVer.str();
413   const std::string MCpuG0Suffix = MCpuSuffix + "/G0";
414   const std::string RootDir =
415       HTC.getHexagonTargetDir(D.InstalledDir, D.PrefixDirs) + "/";
416   const std::string StartSubDir =
417       "hexagon/lib" + (UseG0 ? MCpuG0Suffix : MCpuSuffix);
418 
419   auto Find = [&HTC] (const std::string &RootDir, const std::string &SubDir,
420                       const char *Name) -> std::string {
421     std::string RelName = SubDir + Name;
422     std::string P = HTC.GetFilePath(RelName.c_str());
423     if (llvm::sys::fs::exists(P))
424       return P;
425     return RootDir + RelName;
426   };
427 
428   if (IncStdLib && IncStartFiles) {
429     if (!IsShared) {
430       if (HasStandalone) {
431         std::string Crt0SA = Find(RootDir, StartSubDir, "/crt0_standalone.o");
432         CmdArgs.push_back(Args.MakeArgString(Crt0SA));
433       }
434       std::string Crt0 = Find(RootDir, StartSubDir, "/crt0.o");
435       CmdArgs.push_back(Args.MakeArgString(Crt0));
436     }
437     std::string Init = UseShared
438           ? Find(RootDir, StartSubDir + "/pic", "/initS.o")
439           : Find(RootDir, StartSubDir, "/init.o");
440     CmdArgs.push_back(Args.MakeArgString(Init));
441   }
442 
443   //----------------------------------------------------------------------------
444   // Library Search Paths
445   //----------------------------------------------------------------------------
446   const ToolChain::path_list &LibPaths = HTC.getFilePaths();
447   for (const auto &LibPath : LibPaths)
448     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
449   Args.ClaimAllArgs(options::OPT_L);
450 
451   //----------------------------------------------------------------------------
452   //
453   //----------------------------------------------------------------------------
454   Args.addAllArgs(CmdArgs, {options::OPT_T_Group, options::OPT_s,
455                             options::OPT_t, options::OPT_u_Group});
456 
457   AddLinkerInputs(HTC, Inputs, Args, CmdArgs, JA);
458 
459   //----------------------------------------------------------------------------
460   // Libraries
461   //----------------------------------------------------------------------------
462   if (IncStdLib && IncDefLibs) {
463     if (D.CCCIsCXX()) {
464       if (HTC.ShouldLinkCXXStdlib(Args))
465         HTC.AddCXXStdlibLibArgs(Args, CmdArgs);
466       CmdArgs.push_back("-lm");
467     }
468 
469     CmdArgs.push_back("--start-group");
470 
471     if (!IsShared) {
472       for (StringRef Lib : OsLibs)
473         CmdArgs.push_back(Args.MakeArgString("-l" + Lib));
474       if (!Args.hasArg(options::OPT_nolibc))
475         CmdArgs.push_back("-lc");
476     }
477     CmdArgs.push_back("-lgcc");
478 
479     CmdArgs.push_back("--end-group");
480   }
481 
482   //----------------------------------------------------------------------------
483   // End files
484   //----------------------------------------------------------------------------
485   if (IncStdLib && IncStartFiles) {
486     std::string Fini = UseShared
487           ? Find(RootDir, StartSubDir + "/pic", "/finiS.o")
488           : Find(RootDir, StartSubDir, "/fini.o");
489     CmdArgs.push_back(Args.MakeArgString(Fini));
490   }
491 }
492 
493 void hexagon::Linker::ConstructJob(Compilation &C, const JobAction &JA,
494                                    const InputInfo &Output,
495                                    const InputInfoList &Inputs,
496                                    const ArgList &Args,
497                                    const char *LinkingOutput) const {
498   auto &HTC = static_cast<const toolchains::HexagonToolChain&>(getToolChain());
499 
500   ArgStringList CmdArgs;
501   constructHexagonLinkArgs(C, JA, HTC, Output, Inputs, Args, CmdArgs,
502                            LinkingOutput);
503 
504   const char *Exec = Args.MakeArgString(HTC.GetLinkerPath());
505   C.addCommand(std::make_unique<Command>(JA, *this,
506                                          ResponseFileSupport::AtFileCurCP(),
507                                          Exec, CmdArgs, Inputs, Output));
508 }
509 // Hexagon tools end.
510 
511 /// Hexagon Toolchain
512 
513 std::string HexagonToolChain::getHexagonTargetDir(
514       const std::string &InstalledDir,
515       const SmallVectorImpl<std::string> &PrefixDirs) const {
516   std::string InstallRelDir;
517   const Driver &D = getDriver();
518 
519   // Locate the rest of the toolchain ...
520   for (auto &I : PrefixDirs)
521     if (D.getVFS().exists(I))
522       return I;
523 
524   if (getVFS().exists(InstallRelDir = InstalledDir + "/../target"))
525     return InstallRelDir;
526 
527   return InstalledDir;
528 }
529 
530 std::optional<unsigned>
531 HexagonToolChain::getSmallDataThreshold(const ArgList &Args) {
532   StringRef Gn = "";
533   if (Arg *A = Args.getLastArg(options::OPT_G)) {
534     Gn = A->getValue();
535   } else if (Args.getLastArg(options::OPT_shared, options::OPT_fpic,
536                              options::OPT_fPIC)) {
537     Gn = "0";
538   }
539 
540   unsigned G;
541   if (!Gn.getAsInteger(10, G))
542     return G;
543 
544   return std::nullopt;
545 }
546 
547 std::string HexagonToolChain::getCompilerRTPath() const {
548   SmallString<128> Dir(getDriver().SysRoot);
549   llvm::sys::path::append(Dir, "usr", "lib");
550   if (!SelectedMultilibs.empty()) {
551     Dir += SelectedMultilibs.back().gccSuffix();
552   }
553   return std::string(Dir);
554 }
555 
556 void HexagonToolChain::getHexagonLibraryPaths(const ArgList &Args,
557       ToolChain::path_list &LibPaths) const {
558   const Driver &D = getDriver();
559 
560   //----------------------------------------------------------------------------
561   // -L Args
562   //----------------------------------------------------------------------------
563   for (Arg *A : Args.filtered(options::OPT_L))
564     llvm::append_range(LibPaths, A->getValues());
565 
566   //----------------------------------------------------------------------------
567   // Other standard paths
568   //----------------------------------------------------------------------------
569   std::vector<std::string> RootDirs;
570   std::copy(D.PrefixDirs.begin(), D.PrefixDirs.end(),
571             std::back_inserter(RootDirs));
572 
573   std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
574                                               D.PrefixDirs);
575   if (!llvm::is_contained(RootDirs, TargetDir))
576     RootDirs.push_back(TargetDir);
577 
578   bool HasPIC = Args.hasArg(options::OPT_fpic, options::OPT_fPIC);
579   // Assume G0 with -shared.
580   bool HasG0 = Args.hasArg(options::OPT_shared);
581   if (auto G = getSmallDataThreshold(Args))
582     HasG0 = *G == 0;
583 
584   const std::string CpuVer = GetTargetCPUVersion(Args).str();
585   for (auto &Dir : RootDirs) {
586     std::string LibDir = Dir + "/hexagon/lib";
587     std::string LibDirCpu = LibDir + '/' + CpuVer;
588     if (HasG0) {
589       if (HasPIC)
590         LibPaths.push_back(LibDirCpu + "/G0/pic");
591       LibPaths.push_back(LibDirCpu + "/G0");
592     }
593     LibPaths.push_back(LibDirCpu);
594     LibPaths.push_back(LibDir);
595   }
596 }
597 
598 HexagonToolChain::HexagonToolChain(const Driver &D, const llvm::Triple &Triple,
599                                    const llvm::opt::ArgList &Args)
600     : Linux(D, Triple, Args) {
601   const std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
602                                                     D.PrefixDirs);
603 
604   // Note: Generic_GCC::Generic_GCC adds InstalledDir and getDriver().Dir to
605   // program paths
606   const std::string BinDir(TargetDir + "/bin");
607   if (D.getVFS().exists(BinDir))
608     getProgramPaths().push_back(BinDir);
609 
610   ToolChain::path_list &LibPaths = getFilePaths();
611 
612   // Remove paths added by Linux toolchain. Currently Hexagon_TC really targets
613   // 'elf' OS type, so the Linux paths are not appropriate. When we actually
614   // support 'linux' we'll need to fix this up
615   LibPaths.clear();
616   getHexagonLibraryPaths(Args, LibPaths);
617 }
618 
619 HexagonToolChain::~HexagonToolChain() {}
620 
621 void HexagonToolChain::AddCXXStdlibLibArgs(const ArgList &Args,
622                                            ArgStringList &CmdArgs) const {
623   CXXStdlibType Type = GetCXXStdlibType(Args);
624   switch (Type) {
625   case ToolChain::CST_Libcxx:
626     CmdArgs.push_back("-lc++");
627     if (Args.hasArg(options::OPT_fexperimental_library))
628       CmdArgs.push_back("-lc++experimental");
629     CmdArgs.push_back("-lc++abi");
630     CmdArgs.push_back("-lunwind");
631     break;
632 
633   case ToolChain::CST_Libstdcxx:
634     CmdArgs.push_back("-lstdc++");
635     break;
636   }
637 }
638 
639 Tool *HexagonToolChain::buildAssembler() const {
640   return new tools::hexagon::Assembler(*this);
641 }
642 
643 Tool *HexagonToolChain::buildLinker() const {
644   return new tools::hexagon::Linker(*this);
645 }
646 
647 unsigned HexagonToolChain::getOptimizationLevel(
648     const llvm::opt::ArgList &DriverArgs) const {
649   // Copied in large part from lib/Frontend/CompilerInvocation.cpp.
650   Arg *A = DriverArgs.getLastArg(options::OPT_O_Group);
651   if (!A)
652     return 0;
653 
654   if (A->getOption().matches(options::OPT_O0))
655     return 0;
656   if (A->getOption().matches(options::OPT_Ofast) ||
657       A->getOption().matches(options::OPT_O4))
658     return 3;
659   assert(A->getNumValues() != 0);
660   StringRef S(A->getValue());
661   if (S == "s" || S == "z" || S.empty())
662     return 2;
663   if (S == "g")
664     return 1;
665 
666   unsigned OptLevel;
667   if (S.getAsInteger(10, OptLevel))
668     return 0;
669   return OptLevel;
670 }
671 
672 void HexagonToolChain::addClangTargetOptions(const ArgList &DriverArgs,
673                                              ArgStringList &CC1Args,
674                                              Action::OffloadKind) const {
675 
676   bool UseInitArrayDefault = getTriple().isMusl();
677 
678   if (!DriverArgs.hasFlag(options::OPT_fuse_init_array,
679                           options::OPT_fno_use_init_array,
680                           UseInitArrayDefault))
681     CC1Args.push_back("-fno-use-init-array");
682 
683   if (DriverArgs.hasArg(options::OPT_ffixed_r19)) {
684     CC1Args.push_back("-target-feature");
685     CC1Args.push_back("+reserved-r19");
686   }
687   if (isAutoHVXEnabled(DriverArgs)) {
688     CC1Args.push_back("-mllvm");
689     CC1Args.push_back("-hexagon-autohvx");
690   }
691 }
692 
693 void HexagonToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
694                                                  ArgStringList &CC1Args) const {
695   if (DriverArgs.hasArg(options::OPT_nostdinc))
696     return;
697 
698   const bool IsELF = !getTriple().isMusl() && !getTriple().isOSLinux();
699   const bool IsLinuxMusl = getTriple().isMusl() && getTriple().isOSLinux();
700 
701   const Driver &D = getDriver();
702   SmallString<128> ResourceDirInclude(D.ResourceDir);
703   if (!IsELF) {
704     llvm::sys::path::append(ResourceDirInclude, "include");
705     if (!DriverArgs.hasArg(options::OPT_nobuiltininc) &&
706         (!IsLinuxMusl || DriverArgs.hasArg(options::OPT_nostdlibinc)))
707       addSystemInclude(DriverArgs, CC1Args, ResourceDirInclude);
708   }
709   if (DriverArgs.hasArg(options::OPT_nostdlibinc))
710     return;
711 
712   const bool HasSysRoot = !D.SysRoot.empty();
713   if (HasSysRoot) {
714     SmallString<128> P(D.SysRoot);
715     if (IsLinuxMusl)
716       llvm::sys::path::append(P, "usr/include");
717     else
718       llvm::sys::path::append(P, "include");
719 
720     addExternCSystemInclude(DriverArgs, CC1Args, P.str());
721     // LOCAL_INCLUDE_DIR
722     addSystemInclude(DriverArgs, CC1Args, P + "/usr/local/include");
723     // TOOL_INCLUDE_DIR
724     AddMultilibIncludeArgs(DriverArgs, CC1Args);
725   }
726 
727   if (!DriverArgs.hasArg(options::OPT_nobuiltininc) && IsLinuxMusl)
728     addSystemInclude(DriverArgs, CC1Args, ResourceDirInclude);
729 
730   if (HasSysRoot)
731     return;
732   std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
733                                               D.PrefixDirs);
734   addExternCSystemInclude(DriverArgs, CC1Args, TargetDir + "/hexagon/include");
735 }
736 
737 void HexagonToolChain::addLibCxxIncludePaths(
738     const llvm::opt::ArgList &DriverArgs,
739     llvm::opt::ArgStringList &CC1Args) const {
740   const Driver &D = getDriver();
741   if (!D.SysRoot.empty() && getTriple().isMusl())
742     addLibStdCXXIncludePaths(D.SysRoot + "/usr/include/c++/v1", "", "",
743                              DriverArgs, CC1Args);
744   else if (getTriple().isMusl())
745     addLibStdCXXIncludePaths("/usr/include/c++/v1", "", "", DriverArgs,
746                              CC1Args);
747   else {
748     std::string TargetDir = getHexagonTargetDir(D.InstalledDir, D.PrefixDirs);
749     addLibStdCXXIncludePaths(TargetDir + "/hexagon/include/c++/v1", "", "",
750                              DriverArgs, CC1Args);
751   }
752 }
753 void HexagonToolChain::addLibStdCxxIncludePaths(
754     const llvm::opt::ArgList &DriverArgs,
755     llvm::opt::ArgStringList &CC1Args) const {
756   const Driver &D = getDriver();
757   std::string TargetDir = getHexagonTargetDir(D.InstalledDir, D.PrefixDirs);
758   addLibStdCXXIncludePaths(TargetDir + "/hexagon/include/c++", "", "",
759                            DriverArgs, CC1Args);
760 }
761 
762 ToolChain::CXXStdlibType
763 HexagonToolChain::GetCXXStdlibType(const ArgList &Args) const {
764   Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
765   if (!A) {
766     if (getTriple().isMusl())
767       return ToolChain::CST_Libcxx;
768     else
769       return ToolChain::CST_Libstdcxx;
770   }
771   StringRef Value = A->getValue();
772   if (Value != "libstdc++" && Value != "libc++")
773     getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
774 
775   if (Value == "libstdc++")
776     return ToolChain::CST_Libstdcxx;
777   else if (Value == "libc++")
778     return ToolChain::CST_Libcxx;
779   else
780     return ToolChain::CST_Libstdcxx;
781 }
782 
783 bool HexagonToolChain::isAutoHVXEnabled(const llvm::opt::ArgList &Args) {
784   if (Arg *A = Args.getLastArg(options::OPT_fvectorize,
785                                options::OPT_fno_vectorize))
786     return A->getOption().matches(options::OPT_fvectorize);
787   return false;
788 }
789 
790 //
791 // Returns the default CPU for Hexagon. This is the default compilation target
792 // if no Hexagon processor is selected at the command-line.
793 //
794 StringRef HexagonToolChain::GetDefaultCPU() {
795   return "hexagonv60";
796 }
797 
798 StringRef HexagonToolChain::GetTargetCPUVersion(const ArgList &Args) {
799   Arg *CpuArg = nullptr;
800   if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
801     CpuArg = A;
802 
803   StringRef CPU = CpuArg ? CpuArg->getValue() : GetDefaultCPU();
804   if (CPU.starts_with("hexagon"))
805     return CPU.substr(sizeof("hexagon") - 1);
806   return CPU;
807 }
808