xref: /freebsd/contrib/llvm-project/clang/lib/Driver/ToolChains/Hexagon.cpp (revision 5e801ac66d24704442eba426ed13c3effb8a34e7) 
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 Cpu) {
30   return llvm::StringSwitch<StringRef>(Cpu)
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->getOption().getName() << 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   // Add the +hvx* features based on commandline flags.
55   StringRef HVXFeature, HVXLength;
56 
57   // Handle -mhvx, -mhvx=, -mno-hvx.
58   if (Arg *A = Args.getLastArg(options::OPT_mno_hexagon_hvx,
59                                options::OPT_mhexagon_hvx,
60                                options::OPT_mhexagon_hvx_EQ)) {
61     if (A->getOption().matches(options::OPT_mno_hexagon_hvx))
62       return;
63     if (A->getOption().matches(options::OPT_mhexagon_hvx_EQ)) {
64       HasHVX = true;
65       HVXFeature = Cpu = A->getValue();
66       HVXFeature = Args.MakeArgString(llvm::Twine("+hvx") + HVXFeature.lower());
67     } else if (A->getOption().matches(options::OPT_mhexagon_hvx)) {
68       HasHVX = true;
69       HVXFeature = Args.MakeArgString(llvm::Twine("+hvx") + Cpu);
70     }
71     Features.push_back(HVXFeature);
72   }
73 
74   // Handle -mhvx-length=.
75   if (Arg *A = Args.getLastArg(options::OPT_mhexagon_hvx_length_EQ)) {
76     // These flags are valid only if HVX in enabled.
77     if (!HasHVX)
78       D.Diag(diag::err_drv_invalid_hvx_length);
79     else if (A->getOption().matches(options::OPT_mhexagon_hvx_length_EQ))
80       HVXLength = A->getValue();
81   }
82   // Default hvx-length based on Cpu.
83   else if (HasHVX)
84     HVXLength = getDefaultHvxLength(Cpu);
85 
86   if (!HVXLength.empty()) {
87     HVXFeature =
88         Args.MakeArgString(llvm::Twine("+hvx-length") + HVXLength.lower());
89     Features.push_back(HVXFeature);
90   }
91 }
92 
93 // Hexagon target features.
94 void hexagon::getHexagonTargetFeatures(const Driver &D, const ArgList &Args,
95                                        std::vector<StringRef> &Features) {
96   handleTargetFeaturesGroup(Args, Features,
97                             options::OPT_m_hexagon_Features_Group);
98 
99   bool UseLongCalls = false;
100   if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
101                                options::OPT_mno_long_calls)) {
102     if (A->getOption().matches(options::OPT_mlong_calls))
103       UseLongCalls = true;
104   }
105 
106   Features.push_back(UseLongCalls ? "+long-calls" : "-long-calls");
107 
108   bool HasHVX = false;
109   StringRef Cpu(toolchains::HexagonToolChain::GetTargetCPUVersion(Args));
110   // 't' in Cpu denotes tiny-core micro-architecture. For now, the co-processors
111   // have no dependency on micro-architecture.
112   const bool TinyCore = Cpu.contains('t');
113 
114   if (TinyCore)
115     Cpu = Cpu.take_front(Cpu.size() - 1);
116 
117   handleHVXTargetFeatures(D, Args, Features, Cpu, HasHVX);
118 
119   if (HexagonToolChain::isAutoHVXEnabled(Args) && !HasHVX)
120     D.Diag(diag::warn_drv_vectorize_needs_hvx);
121 }
122 
123 // Hexagon tools start.
124 void hexagon::Assembler::RenderExtraToolArgs(const JobAction &JA,
125                                              ArgStringList &CmdArgs) const {
126 }
127 
128 void hexagon::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
129                                       const InputInfo &Output,
130                                       const InputInfoList &Inputs,
131                                       const ArgList &Args,
132                                       const char *LinkingOutput) const {
133   claimNoWarnArgs(Args);
134 
135   auto &HTC = static_cast<const toolchains::HexagonToolChain&>(getToolChain());
136   const Driver &D = HTC.getDriver();
137   ArgStringList CmdArgs;
138 
139   CmdArgs.push_back("--arch=hexagon");
140 
141   RenderExtraToolArgs(JA, CmdArgs);
142 
143   const char *AsName = "llvm-mc";
144   CmdArgs.push_back("-filetype=obj");
145   CmdArgs.push_back(Args.MakeArgString(
146       "-mcpu=hexagon" +
147       toolchains::HexagonToolChain::GetTargetCPUVersion(Args)));
148 
149   addSanitizerRuntimes(HTC, Args, CmdArgs);
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(std::make_unique<Command>(JA, *this,
195                                          ResponseFileSupport::AtFileCurCP(),
196                                          Exec, CmdArgs, Inputs, Output));
197 }
198 
199 void hexagon::Linker::RenderExtraToolArgs(const JobAction &JA,
200                                           ArgStringList &CmdArgs) const {
201 }
202 
203 static void
204 constructHexagonLinkArgs(Compilation &C, const JobAction &JA,
205                          const toolchains::HexagonToolChain &HTC,
206                          const InputInfo &Output, const InputInfoList &Inputs,
207                          const ArgList &Args, ArgStringList &CmdArgs,
208                          const char *LinkingOutput) {
209 
210   const Driver &D = HTC.getDriver();
211 
212   //----------------------------------------------------------------------------
213   //
214   //----------------------------------------------------------------------------
215   bool IsStatic = Args.hasArg(options::OPT_static);
216   bool IsShared = Args.hasArg(options::OPT_shared);
217   bool IsPIE = Args.hasArg(options::OPT_pie);
218   bool IncStdLib = !Args.hasArg(options::OPT_nostdlib);
219   bool IncStartFiles = !Args.hasArg(options::OPT_nostartfiles);
220   bool IncDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
221   bool UseG0 = false;
222   const char *Exec = Args.MakeArgString(HTC.GetLinkerPath());
223   bool UseLLD = (llvm::sys::path::filename(Exec).equals_insensitive("ld.lld") ||
224                  llvm::sys::path::stem(Exec).equals_insensitive("ld.lld"));
225   bool UseShared = IsShared && !IsStatic;
226   StringRef CpuVer = toolchains::HexagonToolChain::GetTargetCPUVersion(Args);
227 
228   bool NeedsSanitizerDeps = addSanitizerRuntimes(HTC, Args, CmdArgs);
229 
230   //----------------------------------------------------------------------------
231   // Silence warnings for various options
232   //----------------------------------------------------------------------------
233   Args.ClaimAllArgs(options::OPT_g_Group);
234   Args.ClaimAllArgs(options::OPT_emit_llvm);
235   Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
236                                      // handled somewhere else.
237   Args.ClaimAllArgs(options::OPT_static_libgcc);
238 
239   //----------------------------------------------------------------------------
240   //
241   //----------------------------------------------------------------------------
242   if (Args.hasArg(options::OPT_s))
243     CmdArgs.push_back("-s");
244 
245   if (Args.hasArg(options::OPT_r))
246     CmdArgs.push_back("-r");
247 
248   for (const auto &Opt : HTC.ExtraOpts)
249     CmdArgs.push_back(Opt.c_str());
250 
251   if (!UseLLD) {
252     CmdArgs.push_back("-march=hexagon");
253     CmdArgs.push_back(Args.MakeArgString("-mcpu=hexagon" + CpuVer));
254   }
255 
256   if (IsShared) {
257     CmdArgs.push_back("-shared");
258     // The following should be the default, but doing as hexagon-gcc does.
259     CmdArgs.push_back("-call_shared");
260   }
261 
262   if (IsStatic)
263     CmdArgs.push_back("-static");
264 
265   if (IsPIE && !IsShared)
266     CmdArgs.push_back("-pie");
267 
268   if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) {
269     CmdArgs.push_back(Args.MakeArgString("-G" + Twine(G.getValue())));
270     UseG0 = G.getValue() == 0;
271   }
272 
273   CmdArgs.push_back("-o");
274   CmdArgs.push_back(Output.getFilename());
275 
276   if (HTC.getTriple().isMusl()) {
277     if (!Args.hasArg(options::OPT_shared, options::OPT_static))
278       CmdArgs.push_back("-dynamic-linker=/lib/ld-musl-hexagon.so.1");
279 
280     if (!Args.hasArg(options::OPT_shared, options::OPT_nostartfiles,
281                      options::OPT_nostdlib))
282       CmdArgs.push_back(Args.MakeArgString(D.SysRoot + "/usr/lib/crt1.o"));
283     else if (Args.hasArg(options::OPT_shared) &&
284              !Args.hasArg(options::OPT_nostartfiles, options::OPT_nostdlib))
285       CmdArgs.push_back(Args.MakeArgString(D.SysRoot + "/usr/lib/crti.o"));
286 
287     CmdArgs.push_back(
288         Args.MakeArgString(StringRef("-L") + D.SysRoot + "/usr/lib"));
289     Args.AddAllArgs(CmdArgs,
290                     {options::OPT_T_Group, options::OPT_e, options::OPT_s,
291                      options::OPT_t, options::OPT_u_Group});
292     AddLinkerInputs(HTC, Inputs, Args, CmdArgs, JA);
293 
294     if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
295       if (NeedsSanitizerDeps) {
296         linkSanitizerRuntimeDeps(HTC, CmdArgs);
297 
298         CmdArgs.push_back("-lunwind");
299       }
300 
301       CmdArgs.push_back("-lclang_rt.builtins-hexagon");
302       CmdArgs.push_back("-lc");
303     }
304     if (D.CCCIsCXX()) {
305       if (HTC.ShouldLinkCXXStdlib(Args))
306         HTC.AddCXXStdlibLibArgs(Args, CmdArgs);
307     }
308     return;
309   }
310 
311   //----------------------------------------------------------------------------
312   // moslib
313   //----------------------------------------------------------------------------
314   std::vector<std::string> OsLibs;
315   bool HasStandalone = false;
316   for (const Arg *A : Args.filtered(options::OPT_moslib_EQ)) {
317     A->claim();
318     OsLibs.emplace_back(A->getValue());
319     HasStandalone = HasStandalone || (OsLibs.back() == "standalone");
320   }
321   if (OsLibs.empty()) {
322     OsLibs.push_back("standalone");
323     HasStandalone = true;
324   }
325 
326   //----------------------------------------------------------------------------
327   // Start Files
328   //----------------------------------------------------------------------------
329   const std::string MCpuSuffix = "/" + CpuVer.str();
330   const std::string MCpuG0Suffix = MCpuSuffix + "/G0";
331   const std::string RootDir =
332       HTC.getHexagonTargetDir(D.InstalledDir, D.PrefixDirs) + "/";
333   const std::string StartSubDir =
334       "hexagon/lib" + (UseG0 ? MCpuG0Suffix : MCpuSuffix);
335 
336   auto Find = [&HTC] (const std::string &RootDir, const std::string &SubDir,
337                       const char *Name) -> std::string {
338     std::string RelName = SubDir + Name;
339     std::string P = HTC.GetFilePath(RelName.c_str());
340     if (llvm::sys::fs::exists(P))
341       return P;
342     return RootDir + RelName;
343   };
344 
345   if (IncStdLib && IncStartFiles) {
346     if (!IsShared) {
347       if (HasStandalone) {
348         std::string Crt0SA = Find(RootDir, StartSubDir, "/crt0_standalone.o");
349         CmdArgs.push_back(Args.MakeArgString(Crt0SA));
350       }
351       std::string Crt0 = Find(RootDir, StartSubDir, "/crt0.o");
352       CmdArgs.push_back(Args.MakeArgString(Crt0));
353     }
354     std::string Init = UseShared
355           ? Find(RootDir, StartSubDir + "/pic", "/initS.o")
356           : Find(RootDir, StartSubDir, "/init.o");
357     CmdArgs.push_back(Args.MakeArgString(Init));
358   }
359 
360   //----------------------------------------------------------------------------
361   // Library Search Paths
362   //----------------------------------------------------------------------------
363   const ToolChain::path_list &LibPaths = HTC.getFilePaths();
364   for (const auto &LibPath : LibPaths)
365     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
366 
367   //----------------------------------------------------------------------------
368   //
369   //----------------------------------------------------------------------------
370   Args.AddAllArgs(CmdArgs,
371                   {options::OPT_T_Group, options::OPT_e, options::OPT_s,
372                    options::OPT_t, options::OPT_u_Group});
373 
374   AddLinkerInputs(HTC, Inputs, Args, CmdArgs, JA);
375 
376   //----------------------------------------------------------------------------
377   // Libraries
378   //----------------------------------------------------------------------------
379   if (IncStdLib && IncDefLibs) {
380     if (D.CCCIsCXX()) {
381       if (HTC.ShouldLinkCXXStdlib(Args))
382         HTC.AddCXXStdlibLibArgs(Args, CmdArgs);
383       CmdArgs.push_back("-lm");
384     }
385 
386     CmdArgs.push_back("--start-group");
387 
388     if (!IsShared) {
389       for (StringRef Lib : OsLibs)
390         CmdArgs.push_back(Args.MakeArgString("-l" + Lib));
391       CmdArgs.push_back("-lc");
392     }
393     CmdArgs.push_back("-lgcc");
394 
395     CmdArgs.push_back("--end-group");
396   }
397 
398   //----------------------------------------------------------------------------
399   // End files
400   //----------------------------------------------------------------------------
401   if (IncStdLib && IncStartFiles) {
402     std::string Fini = UseShared
403           ? Find(RootDir, StartSubDir + "/pic", "/finiS.o")
404           : Find(RootDir, StartSubDir, "/fini.o");
405     CmdArgs.push_back(Args.MakeArgString(Fini));
406   }
407 }
408 
409 void hexagon::Linker::ConstructJob(Compilation &C, const JobAction &JA,
410                                    const InputInfo &Output,
411                                    const InputInfoList &Inputs,
412                                    const ArgList &Args,
413                                    const char *LinkingOutput) const {
414   auto &HTC = static_cast<const toolchains::HexagonToolChain&>(getToolChain());
415 
416   ArgStringList CmdArgs;
417   constructHexagonLinkArgs(C, JA, HTC, Output, Inputs, Args, CmdArgs,
418                            LinkingOutput);
419 
420   const char *Exec = Args.MakeArgString(HTC.GetLinkerPath());
421   C.addCommand(std::make_unique<Command>(JA, *this,
422                                          ResponseFileSupport::AtFileCurCP(),
423                                          Exec, CmdArgs, Inputs, Output));
424 }
425 // Hexagon tools end.
426 
427 /// Hexagon Toolchain
428 
429 std::string HexagonToolChain::getHexagonTargetDir(
430       const std::string &InstalledDir,
431       const SmallVectorImpl<std::string> &PrefixDirs) const {
432   std::string InstallRelDir;
433   const Driver &D = getDriver();
434 
435   // Locate the rest of the toolchain ...
436   for (auto &I : PrefixDirs)
437     if (D.getVFS().exists(I))
438       return I;
439 
440   if (getVFS().exists(InstallRelDir = InstalledDir + "/../target"))
441     return InstallRelDir;
442 
443   return InstalledDir;
444 }
445 
446 Optional<unsigned> HexagonToolChain::getSmallDataThreshold(
447       const ArgList &Args) {
448   StringRef Gn = "";
449   if (Arg *A = Args.getLastArg(options::OPT_G)) {
450     Gn = A->getValue();
451   } else if (Args.getLastArg(options::OPT_shared, options::OPT_fpic,
452                              options::OPT_fPIC)) {
453     Gn = "0";
454   }
455 
456   unsigned G;
457   if (!Gn.getAsInteger(10, G))
458     return G;
459 
460   return None;
461 }
462 
463 std::string HexagonToolChain::getCompilerRTPath() const {
464   SmallString<128> Dir(getDriver().SysRoot);
465   llvm::sys::path::append(Dir, "usr", "lib");
466   Dir += SelectedMultilib.gccSuffix();
467   return std::string(Dir.str());
468 }
469 
470 void HexagonToolChain::getHexagonLibraryPaths(const ArgList &Args,
471       ToolChain::path_list &LibPaths) const {
472   const Driver &D = getDriver();
473 
474   //----------------------------------------------------------------------------
475   // -L Args
476   //----------------------------------------------------------------------------
477   for (Arg *A : Args.filtered(options::OPT_L))
478     for (const char *Value : A->getValues())
479       LibPaths.push_back(Value);
480 
481   //----------------------------------------------------------------------------
482   // Other standard paths
483   //----------------------------------------------------------------------------
484   std::vector<std::string> RootDirs;
485   std::copy(D.PrefixDirs.begin(), D.PrefixDirs.end(),
486             std::back_inserter(RootDirs));
487 
488   std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
489                                               D.PrefixDirs);
490   if (!llvm::is_contained(RootDirs, TargetDir))
491     RootDirs.push_back(TargetDir);
492 
493   bool HasPIC = Args.hasArg(options::OPT_fpic, options::OPT_fPIC);
494   // Assume G0 with -shared.
495   bool HasG0 = Args.hasArg(options::OPT_shared);
496   if (auto G = getSmallDataThreshold(Args))
497     HasG0 = G.getValue() == 0;
498 
499   const std::string CpuVer = GetTargetCPUVersion(Args).str();
500   for (auto &Dir : RootDirs) {
501     std::string LibDir = Dir + "/hexagon/lib";
502     std::string LibDirCpu = LibDir + '/' + CpuVer;
503     if (HasG0) {
504       if (HasPIC)
505         LibPaths.push_back(LibDirCpu + "/G0/pic");
506       LibPaths.push_back(LibDirCpu + "/G0");
507     }
508     LibPaths.push_back(LibDirCpu);
509     LibPaths.push_back(LibDir);
510   }
511 }
512 
513 HexagonToolChain::HexagonToolChain(const Driver &D, const llvm::Triple &Triple,
514                                    const llvm::opt::ArgList &Args)
515     : Linux(D, Triple, Args) {
516   const std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
517                                                     D.PrefixDirs);
518 
519   // Note: Generic_GCC::Generic_GCC adds InstalledDir and getDriver().Dir to
520   // program paths
521   const std::string BinDir(TargetDir + "/bin");
522   if (D.getVFS().exists(BinDir))
523     getProgramPaths().push_back(BinDir);
524 
525   ToolChain::path_list &LibPaths = getFilePaths();
526 
527   // Remove paths added by Linux toolchain. Currently Hexagon_TC really targets
528   // 'elf' OS type, so the Linux paths are not appropriate. When we actually
529   // support 'linux' we'll need to fix this up
530   LibPaths.clear();
531   getHexagonLibraryPaths(Args, LibPaths);
532 }
533 
534 HexagonToolChain::~HexagonToolChain() {}
535 
536 void HexagonToolChain::AddCXXStdlibLibArgs(const ArgList &Args,
537                                            ArgStringList &CmdArgs) const {
538   CXXStdlibType Type = GetCXXStdlibType(Args);
539   switch (Type) {
540   case ToolChain::CST_Libcxx:
541     CmdArgs.push_back("-lc++");
542     CmdArgs.push_back("-lc++abi");
543     CmdArgs.push_back("-lunwind");
544     break;
545 
546   case ToolChain::CST_Libstdcxx:
547     CmdArgs.push_back("-lstdc++");
548     break;
549   }
550 }
551 
552 Tool *HexagonToolChain::buildAssembler() const {
553   return new tools::hexagon::Assembler(*this);
554 }
555 
556 Tool *HexagonToolChain::buildLinker() const {
557   return new tools::hexagon::Linker(*this);
558 }
559 
560 unsigned HexagonToolChain::getOptimizationLevel(
561     const llvm::opt::ArgList &DriverArgs) const {
562   // Copied in large part from lib/Frontend/CompilerInvocation.cpp.
563   Arg *A = DriverArgs.getLastArg(options::OPT_O_Group);
564   if (!A)
565     return 0;
566 
567   if (A->getOption().matches(options::OPT_O0))
568     return 0;
569   if (A->getOption().matches(options::OPT_Ofast) ||
570       A->getOption().matches(options::OPT_O4))
571     return 3;
572   assert(A->getNumValues() != 0);
573   StringRef S(A->getValue());
574   if (S == "s" || S == "z" || S.empty())
575     return 2;
576   if (S == "g")
577     return 1;
578 
579   unsigned OptLevel;
580   if (S.getAsInteger(10, OptLevel))
581     return 0;
582   return OptLevel;
583 }
584 
585 void HexagonToolChain::addClangTargetOptions(const ArgList &DriverArgs,
586                                              ArgStringList &CC1Args,
587                                              Action::OffloadKind) const {
588 
589   bool UseInitArrayDefault = getTriple().isMusl();
590 
591   if (!DriverArgs.hasFlag(options::OPT_fuse_init_array,
592                           options::OPT_fno_use_init_array,
593                           UseInitArrayDefault))
594     CC1Args.push_back("-fno-use-init-array");
595 
596   if (DriverArgs.hasArg(options::OPT_ffixed_r19)) {
597     CC1Args.push_back("-target-feature");
598     CC1Args.push_back("+reserved-r19");
599   }
600   if (isAutoHVXEnabled(DriverArgs)) {
601     CC1Args.push_back("-mllvm");
602     CC1Args.push_back("-hexagon-autohvx");
603   }
604 }
605 
606 void HexagonToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
607                                                  ArgStringList &CC1Args) const {
608   if (DriverArgs.hasArg(options::OPT_nostdinc))
609     return;
610 
611   const bool IsELF = !getTriple().isMusl() && !getTriple().isOSLinux();
612   const bool IsLinuxMusl = getTriple().isMusl() && getTriple().isOSLinux();
613 
614   const Driver &D = getDriver();
615   SmallString<128> ResourceDirInclude(D.ResourceDir);
616   if (!IsELF) {
617     llvm::sys::path::append(ResourceDirInclude, "include");
618     if (!DriverArgs.hasArg(options::OPT_nobuiltininc) &&
619         (!IsLinuxMusl || DriverArgs.hasArg(options::OPT_nostdlibinc)))
620       addSystemInclude(DriverArgs, CC1Args, ResourceDirInclude);
621   }
622   if (DriverArgs.hasArg(options::OPT_nostdlibinc))
623     return;
624 
625   const bool HasSysRoot = !D.SysRoot.empty();
626   if (HasSysRoot) {
627     SmallString<128> P(D.SysRoot);
628     if (IsLinuxMusl)
629       llvm::sys::path::append(P, "usr/include");
630     else
631       llvm::sys::path::append(P, "include");
632 
633     addExternCSystemInclude(DriverArgs, CC1Args, P.str());
634     // LOCAL_INCLUDE_DIR
635     addSystemInclude(DriverArgs, CC1Args, P + "/usr/local/include");
636     // TOOL_INCLUDE_DIR
637     AddMultilibIncludeArgs(DriverArgs, CC1Args);
638   }
639 
640   if (!DriverArgs.hasArg(options::OPT_nobuiltininc) && IsLinuxMusl)
641     addSystemInclude(DriverArgs, CC1Args, ResourceDirInclude);
642 
643   if (HasSysRoot)
644     return;
645   std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
646                                               D.PrefixDirs);
647   addExternCSystemInclude(DriverArgs, CC1Args, TargetDir + "/hexagon/include");
648 }
649 
650 void HexagonToolChain::addLibCxxIncludePaths(
651     const llvm::opt::ArgList &DriverArgs,
652     llvm::opt::ArgStringList &CC1Args) const {
653   const Driver &D = getDriver();
654   if (!D.SysRoot.empty() && getTriple().isMusl())
655     addLibStdCXXIncludePaths(D.SysRoot + "/usr/include/c++/v1", "", "",
656                              DriverArgs, CC1Args);
657   else if (getTriple().isMusl())
658     addLibStdCXXIncludePaths("/usr/include/c++/v1", "", "", DriverArgs,
659                              CC1Args);
660   else {
661     std::string TargetDir = getHexagonTargetDir(D.InstalledDir, D.PrefixDirs);
662     addLibStdCXXIncludePaths(TargetDir + "/hexagon/include/c++/v1", "", "",
663                              DriverArgs, CC1Args);
664   }
665 }
666 void HexagonToolChain::addLibStdCxxIncludePaths(
667     const llvm::opt::ArgList &DriverArgs,
668     llvm::opt::ArgStringList &CC1Args) const {
669   const Driver &D = getDriver();
670   std::string TargetDir = getHexagonTargetDir(D.InstalledDir, D.PrefixDirs);
671   addLibStdCXXIncludePaths(TargetDir + "/hexagon/include/c++", "", "",
672                            DriverArgs, CC1Args);
673 }
674 
675 ToolChain::CXXStdlibType
676 HexagonToolChain::GetCXXStdlibType(const ArgList &Args) const {
677   Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
678   if (!A) {
679     if (getTriple().isMusl())
680       return ToolChain::CST_Libcxx;
681     else
682       return ToolChain::CST_Libstdcxx;
683   }
684   StringRef Value = A->getValue();
685   if (Value != "libstdc++" && Value != "libc++")
686     getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
687 
688   if (Value == "libstdc++")
689     return ToolChain::CST_Libstdcxx;
690   else if (Value == "libc++")
691     return ToolChain::CST_Libcxx;
692   else
693     return ToolChain::CST_Libstdcxx;
694 }
695 
696 bool HexagonToolChain::isAutoHVXEnabled(const llvm::opt::ArgList &Args) {
697   if (Arg *A = Args.getLastArg(options::OPT_fvectorize,
698                                options::OPT_fno_vectorize))
699     return A->getOption().matches(options::OPT_fvectorize);
700   return false;
701 }
702 
703 //
704 // Returns the default CPU for Hexagon. This is the default compilation target
705 // if no Hexagon processor is selected at the command-line.
706 //
707 StringRef HexagonToolChain::GetDefaultCPU() {
708   return "hexagonv60";
709 }
710 
711 StringRef HexagonToolChain::GetTargetCPUVersion(const ArgList &Args) {
712   Arg *CpuArg = nullptr;
713   if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
714     CpuArg = A;
715 
716   StringRef CPU = CpuArg ? CpuArg->getValue() : GetDefaultCPU();
717   if (CPU.startswith("hexagon"))
718     return CPU.substr(sizeof("hexagon") - 1);
719   return CPU;
720 }
721