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 "InputInfo.h"
12 #include "clang/Driver/Compilation.h"
13 #include "clang/Driver/Driver.h"
14 #include "clang/Driver/DriverDiagnostic.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_lower("64b") && !Val.equals_lower("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   if (Output.isFilename()) {
150     CmdArgs.push_back("-o");
151     CmdArgs.push_back(Output.getFilename());
152   } else {
153     assert(Output.isNothing() && "Unexpected output");
154     CmdArgs.push_back("-fsyntax-only");
155   }
156 
157   if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) {
158     CmdArgs.push_back(Args.MakeArgString("-gpsize=" + Twine(G.getValue())));
159   }
160 
161   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
162 
163   // Only pass -x if gcc will understand it; otherwise hope gcc
164   // understands the suffix correctly. The main use case this would go
165   // wrong in is for linker inputs if they happened to have an odd
166   // suffix; really the only way to get this to happen is a command
167   // like '-x foobar a.c' which will treat a.c like a linker input.
168   //
169   // FIXME: For the linker case specifically, can we safely convert
170   // inputs into '-Wl,' options?
171   for (const auto &II : Inputs) {
172     // Don't try to pass LLVM or AST inputs to a generic gcc.
173     if (types::isLLVMIR(II.getType()))
174       D.Diag(clang::diag::err_drv_no_linker_llvm_support)
175           << HTC.getTripleString();
176     else if (II.getType() == types::TY_AST)
177       D.Diag(clang::diag::err_drv_no_ast_support)
178           << HTC.getTripleString();
179     else if (II.getType() == types::TY_ModuleFile)
180       D.Diag(diag::err_drv_no_module_support)
181           << HTC.getTripleString();
182 
183     if (II.isFilename())
184       CmdArgs.push_back(II.getFilename());
185     else
186       // Don't render as input, we need gcc to do the translations.
187       // FIXME: What is this?
188       II.getInputArg().render(Args, CmdArgs);
189   }
190 
191   auto *Exec = Args.MakeArgString(HTC.GetProgramPath(AsName));
192   C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
193 }
194 
195 void hexagon::Linker::RenderExtraToolArgs(const JobAction &JA,
196                                           ArgStringList &CmdArgs) const {
197 }
198 
199 static void
200 constructHexagonLinkArgs(Compilation &C, const JobAction &JA,
201                          const toolchains::HexagonToolChain &HTC,
202                          const InputInfo &Output, const InputInfoList &Inputs,
203                          const ArgList &Args, ArgStringList &CmdArgs,
204                          const char *LinkingOutput) {
205 
206   const Driver &D = HTC.getDriver();
207 
208   //----------------------------------------------------------------------------
209   //
210   //----------------------------------------------------------------------------
211   bool IsStatic = Args.hasArg(options::OPT_static);
212   bool IsShared = Args.hasArg(options::OPT_shared);
213   bool IsPIE = Args.hasArg(options::OPT_pie);
214   bool IncStdLib = !Args.hasArg(options::OPT_nostdlib);
215   bool IncStartFiles = !Args.hasArg(options::OPT_nostartfiles);
216   bool IncDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
217   bool UseG0 = false;
218   const char *Exec = Args.MakeArgString(HTC.GetLinkerPath());
219   bool UseLLD = (llvm::sys::path::filename(Exec).equals_lower("ld.lld") ||
220                  llvm::sys::path::stem(Exec).equals_lower("ld.lld"));
221   bool UseShared = IsShared && !IsStatic;
222   StringRef CpuVer = toolchains::HexagonToolChain::GetTargetCPUVersion(Args);
223 
224   //----------------------------------------------------------------------------
225   // Silence warnings for various options
226   //----------------------------------------------------------------------------
227   Args.ClaimAllArgs(options::OPT_g_Group);
228   Args.ClaimAllArgs(options::OPT_emit_llvm);
229   Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
230                                      // handled somewhere else.
231   Args.ClaimAllArgs(options::OPT_static_libgcc);
232 
233   //----------------------------------------------------------------------------
234   //
235   //----------------------------------------------------------------------------
236   if (Args.hasArg(options::OPT_s))
237     CmdArgs.push_back("-s");
238 
239   if (Args.hasArg(options::OPT_r))
240     CmdArgs.push_back("-r");
241 
242   for (const auto &Opt : HTC.ExtraOpts)
243     CmdArgs.push_back(Opt.c_str());
244 
245   if (!UseLLD) {
246     CmdArgs.push_back("-march=hexagon");
247     CmdArgs.push_back(Args.MakeArgString("-mcpu=hexagon" + CpuVer));
248   }
249 
250   if (IsShared) {
251     CmdArgs.push_back("-shared");
252     // The following should be the default, but doing as hexagon-gcc does.
253     CmdArgs.push_back("-call_shared");
254   }
255 
256   if (IsStatic)
257     CmdArgs.push_back("-static");
258 
259   if (IsPIE && !IsShared)
260     CmdArgs.push_back("-pie");
261 
262   if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) {
263     CmdArgs.push_back(Args.MakeArgString("-G" + Twine(G.getValue())));
264     UseG0 = G.getValue() == 0;
265   }
266 
267   CmdArgs.push_back("-o");
268   CmdArgs.push_back(Output.getFilename());
269 
270   if (HTC.getTriple().isMusl()) {
271     if (!Args.hasArg(options::OPT_shared, options::OPT_static))
272       CmdArgs.push_back("-dynamic-linker=/lib/ld-musl-hexagon.so.1");
273 
274     if (!Args.hasArg(options::OPT_shared, options::OPT_nostartfiles,
275                      options::OPT_nostdlib))
276       CmdArgs.push_back(Args.MakeArgString(D.SysRoot + "/usr/lib/crt1.o"));
277     else if (Args.hasArg(options::OPT_shared) &&
278              !Args.hasArg(options::OPT_nostartfiles, options::OPT_nostdlib))
279       CmdArgs.push_back(Args.MakeArgString(D.SysRoot + "/usr/lib/crti.o"));
280 
281     CmdArgs.push_back(
282         Args.MakeArgString(StringRef("-L") + D.SysRoot + "/usr/lib"));
283     Args.AddAllArgs(CmdArgs,
284                     {options::OPT_T_Group, options::OPT_e, options::OPT_s,
285                      options::OPT_t, options::OPT_u_Group});
286     AddLinkerInputs(HTC, Inputs, Args, CmdArgs, JA);
287 
288     if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
289       CmdArgs.push_back("-lclang_rt.builtins-hexagon");
290       CmdArgs.push_back("-lc");
291     }
292     if (D.CCCIsCXX()) {
293       if (HTC.ShouldLinkCXXStdlib(Args))
294         HTC.AddCXXStdlibLibArgs(Args, CmdArgs);
295     }
296     return;
297   }
298 
299   //----------------------------------------------------------------------------
300   // moslib
301   //----------------------------------------------------------------------------
302   std::vector<std::string> OsLibs;
303   bool HasStandalone = false;
304   for (const Arg *A : Args.filtered(options::OPT_moslib_EQ)) {
305     A->claim();
306     OsLibs.emplace_back(A->getValue());
307     HasStandalone = HasStandalone || (OsLibs.back() == "standalone");
308   }
309   if (OsLibs.empty()) {
310     OsLibs.push_back("standalone");
311     HasStandalone = true;
312   }
313 
314   //----------------------------------------------------------------------------
315   // Start Files
316   //----------------------------------------------------------------------------
317   const std::string MCpuSuffix = "/" + CpuVer.str();
318   const std::string MCpuG0Suffix = MCpuSuffix + "/G0";
319   const std::string RootDir =
320       HTC.getHexagonTargetDir(D.InstalledDir, D.PrefixDirs) + "/";
321   const std::string StartSubDir =
322       "hexagon/lib" + (UseG0 ? MCpuG0Suffix : MCpuSuffix);
323 
324   auto Find = [&HTC] (const std::string &RootDir, const std::string &SubDir,
325                       const char *Name) -> std::string {
326     std::string RelName = SubDir + Name;
327     std::string P = HTC.GetFilePath(RelName.c_str());
328     if (llvm::sys::fs::exists(P))
329       return P;
330     return RootDir + RelName;
331   };
332 
333   if (IncStdLib && IncStartFiles) {
334     if (!IsShared) {
335       if (HasStandalone) {
336         std::string Crt0SA = Find(RootDir, StartSubDir, "/crt0_standalone.o");
337         CmdArgs.push_back(Args.MakeArgString(Crt0SA));
338       }
339       std::string Crt0 = Find(RootDir, StartSubDir, "/crt0.o");
340       CmdArgs.push_back(Args.MakeArgString(Crt0));
341     }
342     std::string Init = UseShared
343           ? Find(RootDir, StartSubDir + "/pic", "/initS.o")
344           : Find(RootDir, StartSubDir, "/init.o");
345     CmdArgs.push_back(Args.MakeArgString(Init));
346   }
347 
348   //----------------------------------------------------------------------------
349   // Library Search Paths
350   //----------------------------------------------------------------------------
351   const ToolChain::path_list &LibPaths = HTC.getFilePaths();
352   for (const auto &LibPath : LibPaths)
353     CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
354 
355   //----------------------------------------------------------------------------
356   //
357   //----------------------------------------------------------------------------
358   Args.AddAllArgs(CmdArgs,
359                   {options::OPT_T_Group, options::OPT_e, options::OPT_s,
360                    options::OPT_t, options::OPT_u_Group});
361 
362   AddLinkerInputs(HTC, Inputs, Args, CmdArgs, JA);
363 
364   //----------------------------------------------------------------------------
365   // Libraries
366   //----------------------------------------------------------------------------
367   if (IncStdLib && IncDefLibs) {
368     if (D.CCCIsCXX()) {
369       if (HTC.ShouldLinkCXXStdlib(Args))
370         HTC.AddCXXStdlibLibArgs(Args, CmdArgs);
371       CmdArgs.push_back("-lm");
372     }
373 
374     CmdArgs.push_back("--start-group");
375 
376     if (!IsShared) {
377       for (StringRef Lib : OsLibs)
378         CmdArgs.push_back(Args.MakeArgString("-l" + Lib));
379       CmdArgs.push_back("-lc");
380     }
381     CmdArgs.push_back("-lgcc");
382 
383     CmdArgs.push_back("--end-group");
384   }
385 
386   //----------------------------------------------------------------------------
387   // End files
388   //----------------------------------------------------------------------------
389   if (IncStdLib && IncStartFiles) {
390     std::string Fini = UseShared
391           ? Find(RootDir, StartSubDir + "/pic", "/finiS.o")
392           : Find(RootDir, StartSubDir, "/fini.o");
393     CmdArgs.push_back(Args.MakeArgString(Fini));
394   }
395 }
396 
397 void hexagon::Linker::ConstructJob(Compilation &C, const JobAction &JA,
398                                    const InputInfo &Output,
399                                    const InputInfoList &Inputs,
400                                    const ArgList &Args,
401                                    const char *LinkingOutput) const {
402   auto &HTC = static_cast<const toolchains::HexagonToolChain&>(getToolChain());
403 
404   ArgStringList CmdArgs;
405   constructHexagonLinkArgs(C, JA, HTC, Output, Inputs, Args, CmdArgs,
406                            LinkingOutput);
407 
408   const char *Exec = Args.MakeArgString(HTC.GetLinkerPath());
409   C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
410 }
411 // Hexagon tools end.
412 
413 /// Hexagon Toolchain
414 
415 std::string HexagonToolChain::getHexagonTargetDir(
416       const std::string &InstalledDir,
417       const SmallVectorImpl<std::string> &PrefixDirs) const {
418   std::string InstallRelDir;
419   const Driver &D = getDriver();
420 
421   // Locate the rest of the toolchain ...
422   for (auto &I : PrefixDirs)
423     if (D.getVFS().exists(I))
424       return I;
425 
426   if (getVFS().exists(InstallRelDir = InstalledDir + "/../target"))
427     return InstallRelDir;
428 
429   return InstalledDir;
430 }
431 
432 Optional<unsigned> HexagonToolChain::getSmallDataThreshold(
433       const ArgList &Args) {
434   StringRef Gn = "";
435   if (Arg *A = Args.getLastArg(options::OPT_G)) {
436     Gn = A->getValue();
437   } else if (Args.getLastArg(options::OPT_shared, options::OPT_fpic,
438                              options::OPT_fPIC)) {
439     Gn = "0";
440   }
441 
442   unsigned G;
443   if (!Gn.getAsInteger(10, G))
444     return G;
445 
446   return None;
447 }
448 
449 void HexagonToolChain::getHexagonLibraryPaths(const ArgList &Args,
450       ToolChain::path_list &LibPaths) const {
451   const Driver &D = getDriver();
452 
453   //----------------------------------------------------------------------------
454   // -L Args
455   //----------------------------------------------------------------------------
456   for (Arg *A : Args.filtered(options::OPT_L))
457     for (const char *Value : A->getValues())
458       LibPaths.push_back(Value);
459 
460   //----------------------------------------------------------------------------
461   // Other standard paths
462   //----------------------------------------------------------------------------
463   std::vector<std::string> RootDirs;
464   std::copy(D.PrefixDirs.begin(), D.PrefixDirs.end(),
465             std::back_inserter(RootDirs));
466 
467   std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
468                                               D.PrefixDirs);
469   if (llvm::find(RootDirs, TargetDir) == RootDirs.end())
470     RootDirs.push_back(TargetDir);
471 
472   bool HasPIC = Args.hasArg(options::OPT_fpic, options::OPT_fPIC);
473   // Assume G0 with -shared.
474   bool HasG0 = Args.hasArg(options::OPT_shared);
475   if (auto G = getSmallDataThreshold(Args))
476     HasG0 = G.getValue() == 0;
477 
478   const std::string CpuVer = GetTargetCPUVersion(Args).str();
479   for (auto &Dir : RootDirs) {
480     std::string LibDir = Dir + "/hexagon/lib";
481     std::string LibDirCpu = LibDir + '/' + CpuVer;
482     if (HasG0) {
483       if (HasPIC)
484         LibPaths.push_back(LibDirCpu + "/G0/pic");
485       LibPaths.push_back(LibDirCpu + "/G0");
486     }
487     LibPaths.push_back(LibDirCpu);
488     LibPaths.push_back(LibDir);
489   }
490 }
491 
492 HexagonToolChain::HexagonToolChain(const Driver &D, const llvm::Triple &Triple,
493                                    const llvm::opt::ArgList &Args)
494     : Linux(D, Triple, Args) {
495   const std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
496                                                     D.PrefixDirs);
497 
498   // Note: Generic_GCC::Generic_GCC adds InstalledDir and getDriver().Dir to
499   // program paths
500   const std::string BinDir(TargetDir + "/bin");
501   if (D.getVFS().exists(BinDir))
502     getProgramPaths().push_back(BinDir);
503 
504   ToolChain::path_list &LibPaths = getFilePaths();
505 
506   // Remove paths added by Linux toolchain. Currently Hexagon_TC really targets
507   // 'elf' OS type, so the Linux paths are not appropriate. When we actually
508   // support 'linux' we'll need to fix this up
509   LibPaths.clear();
510   getHexagonLibraryPaths(Args, LibPaths);
511 }
512 
513 HexagonToolChain::~HexagonToolChain() {}
514 
515 void HexagonToolChain::AddCXXStdlibLibArgs(const ArgList &Args,
516                                            ArgStringList &CmdArgs) const {
517   CXXStdlibType Type = GetCXXStdlibType(Args);
518   switch (Type) {
519   case ToolChain::CST_Libcxx:
520     CmdArgs.push_back("-lc++");
521     CmdArgs.push_back("-lc++abi");
522     CmdArgs.push_back("-lunwind");
523     break;
524 
525   case ToolChain::CST_Libstdcxx:
526     CmdArgs.push_back("-lstdc++");
527     break;
528   }
529 }
530 
531 Tool *HexagonToolChain::buildAssembler() const {
532   return new tools::hexagon::Assembler(*this);
533 }
534 
535 Tool *HexagonToolChain::buildLinker() const {
536   return new tools::hexagon::Linker(*this);
537 }
538 
539 unsigned HexagonToolChain::getOptimizationLevel(
540     const llvm::opt::ArgList &DriverArgs) const {
541   // Copied in large part from lib/Frontend/CompilerInvocation.cpp.
542   Arg *A = DriverArgs.getLastArg(options::OPT_O_Group);
543   if (!A)
544     return 0;
545 
546   if (A->getOption().matches(options::OPT_O0))
547     return 0;
548   if (A->getOption().matches(options::OPT_Ofast) ||
549       A->getOption().matches(options::OPT_O4))
550     return 3;
551   assert(A->getNumValues() != 0);
552   StringRef S(A->getValue());
553   if (S == "s" || S == "z" || S.empty())
554     return 2;
555   if (S == "g")
556     return 1;
557 
558   unsigned OptLevel;
559   if (S.getAsInteger(10, OptLevel))
560     return 0;
561   return OptLevel;
562 }
563 
564 void HexagonToolChain::addClangTargetOptions(const ArgList &DriverArgs,
565                                              ArgStringList &CC1Args,
566                                              Action::OffloadKind) const {
567 
568   bool UseInitArrayDefault = getTriple().isMusl();
569 
570   if (!DriverArgs.hasFlag(options::OPT_fuse_init_array,
571                           options::OPT_fno_use_init_array,
572                           UseInitArrayDefault))
573     CC1Args.push_back("-fno-use-init-array");
574 
575   if (DriverArgs.hasArg(options::OPT_ffixed_r19)) {
576     CC1Args.push_back("-target-feature");
577     CC1Args.push_back("+reserved-r19");
578   }
579   if (isAutoHVXEnabled(DriverArgs)) {
580     CC1Args.push_back("-mllvm");
581     CC1Args.push_back("-hexagon-autohvx");
582   }
583 }
584 
585 void HexagonToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
586                                                  ArgStringList &CC1Args) const {
587   if (DriverArgs.hasArg(options::OPT_nostdinc) ||
588       DriverArgs.hasArg(options::OPT_nostdlibinc))
589     return;
590 
591   const Driver &D = getDriver();
592   if (!D.SysRoot.empty()) {
593     SmallString<128> P(D.SysRoot);
594     if (getTriple().isMusl())
595       llvm::sys::path::append(P, "usr/include");
596     else
597       llvm::sys::path::append(P, "include");
598     addExternCSystemInclude(DriverArgs, CC1Args, P.str());
599     return;
600   }
601 
602   std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
603                                               D.PrefixDirs);
604   addExternCSystemInclude(DriverArgs, CC1Args, TargetDir + "/hexagon/include");
605 }
606 
607 void HexagonToolChain::addLibCxxIncludePaths(
608     const llvm::opt::ArgList &DriverArgs,
609     llvm::opt::ArgStringList &CC1Args) const {
610   const Driver &D = getDriver();
611   if (!D.SysRoot.empty() && getTriple().isMusl())
612     addLibStdCXXIncludePaths(D.SysRoot + "/usr/include/c++/v1", "", "", "", "",
613                              "", DriverArgs, CC1Args);
614   else if (getTriple().isMusl())
615     addLibStdCXXIncludePaths("/usr/include/c++/v1", "", "", "", "", "",
616                              DriverArgs, CC1Args);
617   else {
618     std::string TargetDir = getHexagonTargetDir(D.InstalledDir, D.PrefixDirs);
619     addLibStdCXXIncludePaths(TargetDir, "/hexagon/include/c++/v1", "", "", "",
620                              "", DriverArgs, CC1Args);
621   }
622 }
623 void HexagonToolChain::addLibStdCxxIncludePaths(
624     const llvm::opt::ArgList &DriverArgs,
625     llvm::opt::ArgStringList &CC1Args) const {
626   const Driver &D = getDriver();
627   std::string TargetDir = getHexagonTargetDir(D.InstalledDir, D.PrefixDirs);
628   addLibStdCXXIncludePaths(TargetDir, "/hexagon/include/c++", "", "", "", "",
629                            DriverArgs, CC1Args);
630 }
631 
632 ToolChain::CXXStdlibType
633 HexagonToolChain::GetCXXStdlibType(const ArgList &Args) const {
634   Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
635   if (!A) {
636     if (getTriple().isMusl())
637       return ToolChain::CST_Libcxx;
638     else
639       return ToolChain::CST_Libstdcxx;
640   }
641   StringRef Value = A->getValue();
642   if (Value != "libstdc++" && Value != "libc++")
643     getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
644 
645   if (Value == "libstdc++")
646     return ToolChain::CST_Libstdcxx;
647   else if (Value == "libc++")
648     return ToolChain::CST_Libcxx;
649   else
650     return ToolChain::CST_Libstdcxx;
651 }
652 
653 bool HexagonToolChain::isAutoHVXEnabled(const llvm::opt::ArgList &Args) {
654   if (Arg *A = Args.getLastArg(options::OPT_fvectorize,
655                                options::OPT_fno_vectorize))
656     return A->getOption().matches(options::OPT_fvectorize);
657   return false;
658 }
659 
660 //
661 // Returns the default CPU for Hexagon. This is the default compilation target
662 // if no Hexagon processor is selected at the command-line.
663 //
664 const StringRef HexagonToolChain::GetDefaultCPU() {
665   return "hexagonv60";
666 }
667 
668 const StringRef HexagonToolChain::GetTargetCPUVersion(const ArgList &Args) {
669   Arg *CpuArg = nullptr;
670   if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
671     CpuArg = A;
672 
673   StringRef CPU = CpuArg ? CpuArg->getValue() : GetDefaultCPU();
674   if (CPU.startswith("hexagon"))
675     return CPU.substr(sizeof("hexagon") - 1);
676   return CPU;
677 }
678