clang 17.0.0git
Hexagon.cpp
Go to the documentation of this file.
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"
12#include "clang/Driver/Driver.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
22using namespace clang::driver;
23using namespace clang::driver::tools;
24using namespace clang::driver::toolchains;
25using namespace clang;
26using namespace llvm::opt;
27
28// Default hvx-length for various versions.
29static 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
37static 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.
48static 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.
162void 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;
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.
193 ArgStringList &CmdArgs) const {
194}
195
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" +
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
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,
270 Exec, CmdArgs, Inputs, Output));
271}
272
274 ArgStringList &CmdArgs) const {
275}
276
277static void
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;
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
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 =
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
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,
500 Exec, CmdArgs, Inputs, Output));
501}
502// Hexagon tools end.
503
504/// Hexagon Toolchain
505
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
523std::optional<unsigned>
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
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
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
589HexagonToolChain::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
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
611
613 ArgStringList &CmdArgs) const {
615 switch (Type) {
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
625 CmdArgs.push_back("-lstdc++");
626 break;
627 }
628}
629
631 return new tools::hexagon::Assembler(*this);
632}
633
635 return new tools::hexagon::Linker(*this);
636}
637
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
663void 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
684void 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) {
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
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}
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
754HexagonToolChain::GetCXXStdlibType(const ArgList &Args) const {
755 Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
756 if (!A) {
757 if (getTriple().isMusl())
759 else
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++")
768 else if (Value == "libc++")
770 else
772}
773
774bool 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//
786 return "hexagonv60";
787}
788
789StringRef 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}
StringRef P
static void handleHVXTargetFeatures(const Driver &D, const ArgList &Args, std::vector< StringRef > &Features, StringRef Cpu, bool &HasHVX)
Definition: Hexagon.cpp:48
static void constructHexagonLinkArgs(Compilation &C, const JobAction &JA, const toolchains::HexagonToolChain &HTC, const InputInfo &Output, const InputInfoList &Inputs, const ArgList &Args, ArgStringList &CmdArgs, const char *LinkingOutput)
Definition: Hexagon.cpp:278
static void handleHVXWarnings(const Driver &D, const ArgList &Args)
Definition: Hexagon.cpp:37
static StringRef getDefaultHvxLength(StringRef HvxVer)
Definition: Hexagon.cpp:29
bool IsStatic
Definition: Format.cpp:2786
The base class of the type hierarchy.
Definition: Type.h:1566
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:45
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:77
std::string SysRoot
sysroot, if present
Definition: Driver.h:183
DiagnosticBuilder Diag(unsigned DiagID) const
Definition: Driver.h:144
std::string InstalledDir
The path to the installed clang directory, if any.
Definition: Driver.h:164
std::string ResourceDir
The path to the compiler resource directory.
Definition: Driver.h:167
const char * getInstalledDir() const
Get the path to where the clang executable was installed.
Definition: Driver.h:417
llvm::vfs::FileSystem & getVFS() const
Definition: Driver.h:392
prefix_list PrefixDirs
Definition: Driver.h:180
bool CCCIsCXX() const
Whether the driver should follow g++ like behavior.
Definition: Driver.h:216
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:22
const char * getFilename() const
Definition: InputInfo.h:83
bool isNothing() const
Definition: InputInfo.h:74
bool isFilename() const
Definition: InputInfo.h:75
static void addSystemInclude(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, const Twine &Path)
Utility function to add a system include directory to CC1 arguments.
Definition: ToolChain.cpp:969
bool ShouldLinkCXXStdlib(const llvm::opt::ArgList &Args) const
Returns if the C++ standard library should be linked in.
Definition: ToolChain.cpp:1071
static void addExternCSystemInclude(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, const Twine &Path)
Utility function to add a system include directory with extern "C" semantics to CC1 arguments.
Definition: ToolChain.cpp:984
std::string GetFilePath(const char *Name) const
Definition: ToolChain.cpp:660
path_list & getFilePaths()
Definition: ToolChain.h:278
const Driver & getDriver() const
Definition: ToolChain.h:236
path_list & getProgramPaths()
Definition: ToolChain.h:281
const llvm::Triple & getTriple() const
Definition: ToolChain.h:238
std::string GetLinkerPath(bool *LinkerIsLLD=nullptr) const
Returns the linker path, respecting the -fuse-ld= argument to determine the linker suffix or name.
Definition: ToolChain.cpp:668
Tool - Information on a specific compilation tool.
Definition: Tool.h:32
void AddMultilibIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const
Definition: Gnu.cpp:3054
bool addLibStdCXXIncludePaths(Twine IncludeDir, StringRef Triple, Twine IncludeSuffix, const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, bool DetectDebian=false) const
Definition: Gnu.cpp:3126
void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
AddCXXStdlibLibArgs - Add the system specific linker arguments to use for the given C++ standard libr...
Definition: Hexagon.cpp:612
static bool isAutoHVXEnabled(const llvm::opt::ArgList &Args)
Definition: Hexagon.cpp:774
void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, Action::OffloadKind DeviceOffloadKind) const override
Add options that need to be passed to cc1 for this target.
Definition: Hexagon.cpp:663
void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add the clang cc1 arguments for system include paths.
Definition: Hexagon.cpp:684
std::string getHexagonTargetDir(const std::string &InstalledDir, const SmallVectorImpl< std::string > &PrefixDirs) const
Hexagon Toolchain.
Definition: Hexagon.cpp:506
unsigned getOptimizationLevel(const llvm::opt::ArgList &DriverArgs) const
Definition: Hexagon.cpp:638
void getHexagonLibraryPaths(const llvm::opt::ArgList &Args, ToolChain::path_list &LibPaths) const
Definition: Hexagon.cpp:547
Tool * buildAssembler() const override
Definition: Hexagon.cpp:630
void addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Definition: Hexagon.cpp:744
HexagonToolChain(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Definition: Hexagon.cpp:589
std::string getCompilerRTPath() const override
Definition: Hexagon.cpp:540
CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override
Definition: Hexagon.cpp:754
void addLibCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Definition: Hexagon.cpp:728
static std::optional< unsigned > getSmallDataThreshold(const llvm::opt::ArgList &Args)
Definition: Hexagon.cpp:524
static StringRef GetTargetCPUVersion(const llvm::opt::ArgList &Args)
Definition: Hexagon.cpp:789
std::vector< std::string > ExtraOpts
Definition: Linux.h:60
void RenderExtraToolArgs(const JobAction &JA, llvm::opt::ArgStringList &CmdArgs) const
Definition: Hexagon.cpp:192
void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
ConstructJob - Construct jobs to perform the action JA, writing to Output and with Inputs,...
Definition: Hexagon.cpp:196
void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
ConstructJob - Construct jobs to perform the action JA, writing to Output and with Inputs,...
Definition: Hexagon.cpp:486
virtual void RenderExtraToolArgs(const JobAction &JA, llvm::opt::ArgStringList &CmdArgs) const
Definition: Hexagon.cpp:273
void getHexagonTargetFeatures(const Driver &D, const llvm::opt::ArgList &Args, std::vector< StringRef > &Features)
void linkXRayRuntimeDeps(const ToolChain &TC, llvm::opt::ArgStringList &CmdArgs)
bool addSanitizerRuntimes(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs)
bool addXRayRuntime(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs)
void handleTargetFeaturesGroup(const llvm::opt::ArgList &Args, std::vector< StringRef > &Features, llvm::opt::OptSpecifier Group)
Iterate Args and convert -mxxx to +xxx and -mno-xxx to -xxx and append it to Features.
void claimNoWarnArgs(const llvm::opt::ArgList &Args)
void AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const JobAction &JA)
void linkSanitizerRuntimeDeps(const ToolChain &TC, llvm::opt::ArgStringList &CmdArgs)
bool isLLVMIR(ID Id)
Is this LLVM IR.
Definition: Types.cpp:252
@ C
Languages that the frontend can parse and compile.
static constexpr ResponseFileSupport AtFileCurCP()
Definition: Job.h:92