clang 24.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"
12#include "clang/Driver/Driver.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 Opt.consume_back("=");
58 if (Opt.starts_with("mno-"))
59 Opt = Opt.drop_front(4);
60 else if (Opt.starts_with("m"))
61 Opt = Opt.drop_front(1);
62 return Args.MakeArgString(Twine(Enable ? "+" : "-") + Twine(Opt));
63 };
64
65 auto withMinus = [](StringRef S) -> std::string {
66 return "-" + S.str();
67 };
68
69 std::optional<std::string> HvxVer =
71 HasHVX = HvxVer.has_value();
72 if (HasHVX)
73 Features.push_back(makeFeature(Twine("hvx") + *HvxVer, true));
74 else {
75 if (Arg *A = Args.getLastArg(options::OPT_mno_hexagon_hvx)) {
76 // If there was an explicit -mno-hvx, add -hvx to target features.
77 Features.push_back(makeFeature(A->getOption().getName(), false));
78 }
79 }
80
81 StringRef HvxLen =
82 getDefaultHvxLength(HasHVX ? StringRef(*HvxVer) : StringRef(""));
83
84 // Handle -mhvx-length=.
85 if (Arg *A = Args.getLastArg(options::OPT_mhexagon_hvx_length_EQ)) {
86 // These flags are valid only if HVX in enabled.
87 if (!HasHVX)
88 D.Diag(diag::err_drv_needs_hvx) << withMinus(A->getOption().getName());
89 else if (A->getOption().matches(options::OPT_mhexagon_hvx_length_EQ))
90 HvxLen = A->getValue();
91 }
92
93 if (HasHVX) {
94 StringRef L = makeFeature(Twine("hvx-length") + HvxLen.lower(), true);
95 Features.push_back(L);
96 }
97
98 unsigned HvxVerNum = 0;
99 // getAsInteger returns 'true' on error.
100 if (HasHVX) {
101 StringRef HvxVerRef(*HvxVer);
102 if (HvxVerRef.size() <= 1 ||
103 HvxVerRef.drop_front(1).getAsInteger(10, HvxVerNum))
104 HvxVerNum = 0;
105 }
106
107 // Handle HVX floating point flags.
108 auto checkFlagHvxVersion =
109 [&](auto FlagOn, auto FlagOnWithModes, auto FlagOff, bool CheckMode,
110 unsigned MinVerNum) -> std::optional<StringRef> {
111 // Return an std::optional<StringRef>:
112 // - std::nullopt indicates a verification failure, or that the flag was not
113 // present in Args.
114 // - Otherwise the returned value is that name of the feature to add
115 // to Features.
116 Arg *A = Args.getLastArg(FlagOn, FlagOnWithModes, FlagOff);
117 if (!A)
118 return std::nullopt;
119
120 StringRef OptName = A->getOption().getName();
121 if (A->getOption().matches(FlagOff))
122 return makeFeature(OptName, false);
123
124 if (!HasHVX) {
125 D.Diag(diag::err_drv_needs_hvx) << withMinus(OptName);
126 return std::nullopt;
127 }
128 if (HvxVerNum < MinVerNum) {
129 D.Diag(diag::err_drv_needs_hvx_version)
130 << withMinus(OptName) << ("v" + std::to_string(HvxVerNum));
131 return std::nullopt;
132 }
133
134 if (CheckMode && A->getOption().matches(FlagOnWithModes)) {
135 bool ValidMode =
136 llvm::StringSwitch<bool>(StringRef(A->getValue()).lower())
137 .Cases({"strict-ieee", "ieee", "lossy", "legacy"}, true)
138 .Default(false);
139 if (!ValidMode)
140 D.Diag(diag::err_drv_invalid_value)
141 << A->getAsString(Args) << A->getValue();
142 }
143 return makeFeature(OptName, true);
144 };
145
146 if (auto F = checkFlagHvxVersion(
147 options::OPT_mhexagon_hvx_qfloat, options::OPT_mhexagon_hvx_qfloat_EQ,
148 options::OPT_mno_hexagon_hvx_qfloat, /*CheckMode=*/true, 68)) {
149 Features.push_back(*F);
150 }
151 if (auto F = checkFlagHvxVersion(
152 options::OPT_mhexagon_hvx_ieee_fp, options::OPT_mhexagon_hvx_ieee_fp,
153 options::OPT_mno_hexagon_hvx_ieee_fp, /*CheckMode=*/false, 68)) {
154 Features.push_back(*F);
155 }
156
157 // On v79 and above, there is no IEEE hardware. Treat -mhvx-ieee-fp
158 // as "qfloat mode ieee".
159 if (HvxVerNum >= 79 && Args.getLastArg(options::OPT_mhexagon_hvx_ieee_fp))
160 Features.push_back("+hvx-qfloat");
161}
162
163// Hexagon target features.
165 const llvm::Triple &Triple,
166 const ArgList &Args,
167 std::vector<StringRef> &Features) {
168 handleTargetFeaturesGroup(D, Triple, Args, Features,
169 options::OPT_m_hexagon_Features_Group);
170
171 bool UseLongCalls = false;
172 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
173 options::OPT_mno_long_calls)) {
174 if (A->getOption().matches(options::OPT_mlong_calls))
175 UseLongCalls = true;
176 }
177
178 Features.push_back(UseLongCalls ? "+long-calls" : "-long-calls");
179
180 bool HasHVX = false;
182 // 't' in Cpu denotes tiny-core micro-architecture. For now, the co-processors
183 // have no dependency on micro-architecture.
184 const bool TinyCore = Cpu.contains('t');
185
186 if (TinyCore)
187 Cpu = Cpu.take_front(Cpu.size() - 1);
188
189 handleHVXTargetFeatures(D, Args, Features, Cpu, HasHVX);
190
191 // HLX is available on v85 and later.
192 if (Arg *A = Args.getLastArg(options::OPT_mhexagon_hlx,
193 options::OPT_mno_hexagon_hlx)) {
194 unsigned CpuVer = 0;
195 // getAsInteger returns 'true' on error.
196 if (Cpu.substr(1).getAsInteger(10, CpuVer) || CpuVer < 85)
197 D.Diag(diag::err_drv_unsupported_opt_for_target)
198 << A->getSpelling() << Cpu;
199 }
200
201 if (HexagonToolChain::isAutoHVXEnabled(Args) && !HasHVX)
202 D.Diag(diag::warn_drv_needs_hvx) << "auto-vectorization";
203}
204
205// Hexagon tools start.
207 ArgStringList &CmdArgs) const {
208}
209
211 const InputInfo &Output,
212 const InputInfoList &Inputs,
213 const ArgList &Args,
214 const char *LinkingOutput) const {
215 claimNoWarnArgs(Args);
216
217 auto &HTC = static_cast<const toolchains::HexagonToolChain&>(getToolChain());
218 const Driver &D = HTC.getDriver();
219 ArgStringList CmdArgs;
220
221 CmdArgs.push_back("--arch=hexagon");
222
223 RenderExtraToolArgs(JA, CmdArgs);
224
225 const char *AsName = "llvm-mc";
226 CmdArgs.push_back("-filetype=obj");
227 CmdArgs.push_back(Args.MakeArgString(
228 "-mcpu=hexagon" +
230
231 if (std::get<0>(ParsePICArgs(HTC, Args)) == llvm::Reloc::PIC_)
232 CmdArgs.push_back("-position-independent");
233
234 addSanitizerRuntimes(HTC, Args, CmdArgs, C);
235
236 assert((Output.isFilename() || Output.isNothing()) && "Invalid output.");
237 if (Output.isFilename()) {
238 CmdArgs.push_back("-o");
239 CmdArgs.push_back(Output.getFilename());
240 } else {
241 CmdArgs.push_back("-fsyntax-only");
242 }
243
244 if (Arg *A = Args.getLastArg(options::OPT_mhexagon_hvx_ieee_fp,
245 options::OPT_mno_hexagon_hvx_ieee_fp)) {
246 if (A->getOption().matches(options::OPT_mhexagon_hvx_ieee_fp))
247 CmdArgs.push_back("-mhvx-ieee-fp");
248 }
249
250 if (Args.hasFlag(options::OPT_mhexagon_hmx, options::OPT_mno_hexagon_hmx,
251 false)) {
252 CmdArgs.push_back("-mhmx");
253 }
254
255 if (Args.hasFlag(options::OPT_mhexagon_hlx, options::OPT_mno_hexagon_hlx,
256 false))
257 CmdArgs.push_back("-mhlx");
258
260 CmdArgs.push_back(Args.MakeArgString("-gpsize=" + Twine(*G)));
261 }
262
263 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
264
265 // Only pass -x if gcc will understand it; otherwise hope gcc
266 // understands the suffix correctly. The main use case this would go
267 // wrong in is for linker inputs if they happened to have an odd
268 // suffix; really the only way to get this to happen is a command
269 // like '-x foobar a.c' which will treat a.c like a linker input.
270 //
271 // FIXME: For the linker case specifically, can we safely convert
272 // inputs into '-Wl,' options?
273 for (const auto &II : Inputs) {
274 // Don't try to pass LLVM or AST inputs to a generic gcc.
275 if (types::isLLVMIR(II.getType()))
276 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
277 << HTC.getTripleString();
278 else if (II.getType() == types::TY_AST)
279 D.Diag(clang::diag::err_drv_no_ast_support)
280 << HTC.getTripleString();
281 else if (II.getType() == types::TY_ModuleFile)
282 D.Diag(diag::err_drv_no_module_support)
283 << HTC.getTripleString();
284
285 if (II.isFilename())
286 CmdArgs.push_back(II.getFilename());
287 else
288 // Don't render as input, we need gcc to do the translations.
289 // FIXME: What is this?
290 II.getInputArg().render(Args, CmdArgs);
291 }
292
293 auto *Exec = Args.MakeArgString(HTC.GetProgramPath(AsName));
294 C.addCommand(std::make_unique<Command>(JA, *this,
296 Exec, CmdArgs, Inputs, Output));
297}
298
300 ArgStringList &CmdArgs) const {
301}
302
303static void
306 const InputInfo &Output, const InputInfoList &Inputs,
307 const ArgList &Args, ArgStringList &CmdArgs,
308 const char *LinkingOutput) {
309
310 const Driver &D = HTC.getDriver();
311
312 //----------------------------------------------------------------------------
313 //
314 //----------------------------------------------------------------------------
315 bool IsStatic = Args.hasArg(options::OPT_static);
316 bool IsShared = Args.hasArg(options::OPT_shared);
317 bool IsPIE = Args.hasFlag(options::OPT_pie, options::OPT_no_pie,
318 HTC.isPIEDefault(Args));
319 bool IncStdLib = !Args.hasArg(options::OPT_nostdlib);
320 bool IncStartFiles = !Args.hasArg(options::OPT_nostartfiles);
321 bool IncDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
322 bool UseLLD = false;
323 const char *Exec = Args.MakeArgString(HTC.GetLinkerPath(&UseLLD));
324 StringRef LinkerName = llvm::sys::path::filename(Exec);
325 UseLLD = UseLLD || LinkerName.starts_with("ld.lld") ||
326 LinkerName.ends_with("ld.lld") ||
327 llvm::sys::path::stem(Exec).ends_with("ld.lld");
328 bool UseShared = IsShared && !IsStatic;
330
331 bool NeedsSanitizerDeps = addSanitizerRuntimes(HTC, Args, CmdArgs, C);
332 bool NeedsXRayDeps = addXRayRuntime(HTC, Args, CmdArgs);
333
334 //----------------------------------------------------------------------------
335 // Silence warnings for various options
336 //----------------------------------------------------------------------------
337 Args.ClaimAllArgs(options::OPT_g_Group);
338 Args.ClaimAllArgs(options::OPT_emit_llvm);
339 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
340 // handled somewhere else.
341 Args.ClaimAllArgs(options::OPT_static_libgcc);
342
343 CmdArgs.push_back("--eh-frame-hdr");
344 //----------------------------------------------------------------------------
345 //
346 //----------------------------------------------------------------------------
347 if (Args.hasArg(options::OPT_s))
348 CmdArgs.push_back("-s");
349
350 if (Args.hasArg(options::OPT_r))
351 CmdArgs.push_back("-r");
352
353 for (const auto &Opt : HTC.ExtraOpts)
354 CmdArgs.push_back(Opt.c_str());
355
356 if (!UseLLD) {
357 CmdArgs.push_back("-march=hexagon");
358 CmdArgs.push_back(Args.MakeArgString("-mcpu=hexagon" + CpuVer));
359 }
360
361 if (IsShared) {
362 CmdArgs.push_back("-shared");
363 // The following should be the default, but doing as hexagon-gcc does.
364 CmdArgs.push_back("-call_shared");
365 }
366
367 if (IsStatic)
368 CmdArgs.push_back("-static");
369
370 if (IsPIE && !IsShared && !Args.hasArg(options::OPT_r))
371 CmdArgs.push_back("-pie");
372
374 CmdArgs.push_back(Args.MakeArgString("-G" + Twine(*G)));
375
376 CmdArgs.push_back("-o");
377 CmdArgs.push_back(Output.getFilename());
378
379 if (HTC.getTriple().isMusl()) {
380 if (!Args.hasArg(options::OPT_shared, options::OPT_static, options::OPT_r))
381 CmdArgs.push_back("-dynamic-linker=/lib/ld-musl-hexagon.so.1");
382
383 StringRef MLSuffix;
384 if (!HTC.getSelectedMultilibs().empty() &&
385 !HTC.getSelectedMultilibs().back().isDefault())
386 MLSuffix = HTC.getSelectedMultilibs().back().gccSuffix();
387 auto StartFile = [&](StringRef Name) -> std::string {
388 return D.SysRoot + "/usr/lib" + MLSuffix.str() + "/" + Name.str();
389 };
390
391 if (!Args.hasArg(options::OPT_shared, options::OPT_nostartfiles,
392 options::OPT_nostdlib, options::OPT_r)) {
393 if (IsStatic && IsPIE)
394 CmdArgs.push_back(Args.MakeArgString(StartFile("rcrt1.o")));
395 else
396 CmdArgs.push_back(Args.MakeArgString(StartFile("crt1.o")));
397 } else if (Args.hasArg(options::OPT_shared) &&
398 !Args.hasArg(options::OPT_nostartfiles, options::OPT_nostdlib,
399 options::OPT_r))
400 CmdArgs.push_back(Args.MakeArgString(StartFile("crti.o")));
401
402 if (!MLSuffix.empty()) {
403 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + D.SysRoot +
404 "/usr/lib" + MLSuffix));
405 }
406 CmdArgs.push_back(
407 Args.MakeArgString(StringRef("-L") + D.SysRoot + "/usr/lib"));
408 Args.addAllArgs(CmdArgs, {options::OPT_T_Group, options::OPT_s,
409 options::OPT_t, options::OPT_u_Group});
410 AddLinkerInputs(HTC, Inputs, Args, CmdArgs, JA);
411
412 if (auto LTO = HTC.getLTOMode(Args); LTO != LTOK_None)
413 addLTOOptions(HTC, Args, CmdArgs, Output, Inputs, LTO == LTOK_Thin);
414
416
417 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
418 if (NeedsSanitizerDeps) {
419 linkSanitizerRuntimeDeps(HTC, Args, CmdArgs);
420
421 if (UNW != ToolChain::UNW_None)
422 CmdArgs.push_back("-lunwind");
423 }
424 if (NeedsXRayDeps)
425 linkXRayRuntimeDeps(HTC, Args, CmdArgs);
426
427 if (!Args.hasArg(options::OPT_nolibc))
428 CmdArgs.push_back("-lc");
429 CmdArgs.push_back("-lclang_rt.builtins-hexagon");
430 }
431 if (D.CCCIsCXX()) {
432 if (HTC.ShouldLinkCXXStdlib(Args))
433 HTC.AddCXXStdlibLibArgs(Args, CmdArgs);
434 }
435 const ToolChain::path_list &LibPaths = HTC.getFilePaths();
436 for (const auto &LibPath : LibPaths)
437 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
438 Args.ClaimAllArgs(options::OPT_L);
439 return;
440 }
441
442 //----------------------------------------------------------------------------
443 // moslib
444 //----------------------------------------------------------------------------
445 std::vector<std::string> OsLibs;
446 bool HasStandalone = false;
447 for (const Arg *A : Args.filtered(options::OPT_moslib_EQ)) {
448 A->claim();
449 OsLibs.emplace_back(A->getValue());
450 HasStandalone = HasStandalone || (OsLibs.back() == "standalone");
451 }
452 if (OsLibs.empty()) {
453 OsLibs.push_back("standalone");
454 HasStandalone = true;
455 }
456
457 //----------------------------------------------------------------------------
458 // Start Files
459 //----------------------------------------------------------------------------
460 SmallString<128> LibraryDir;
461 HTC.getLibraryDir(Args, LibraryDir);
462
463 if (IncStdLib && IncStartFiles) {
464 if (HTC.GetCStdlibType(Args) == ToolChain::CST_Picolibc) {
465 SmallString<128> Crt0 = LibraryDir;
466 if (HTC.getTriple().isOSH2()) {
467 llvm::sys::path::append(Crt0, "crt0-noflash-hosted.o");
468 CmdArgs.push_back(Args.MakeArgString(Crt0));
469 } else if (HTC.getTriple().isOSUnknown()) {
470 llvm::sys::path::append(Crt0, "crt0-semihost.o");
471 CmdArgs.push_back(Args.MakeArgString(Crt0));
472 } else if (HTC.getTriple().isOSQurt()) {
473 // QURT provides its own crt0.
474 }
475 // Known OS other than H2/QURT: no semihost crt0; OS provides its own.
476 } else {
477 if (!IsShared) {
478 if (HasStandalone) {
479 SmallString<128> Crt0SA = LibraryDir;
480 llvm::sys::path::append(Crt0SA, "crt0_standalone.o");
481 CmdArgs.push_back(Args.MakeArgString(Crt0SA));
482 }
483 SmallString<128> Crt0 = LibraryDir;
484 llvm::sys::path::append(Crt0, "crt0.o");
485 CmdArgs.push_back(Args.MakeArgString(Crt0));
486 }
487 }
488 if (HTC.GetCStdlibType(Args) != ToolChain::CST_Picolibc) {
489 SmallString<128> Init = LibraryDir;
490 llvm::sys::path::append(Init, UseShared ? "initS.o" : "init.o");
491 CmdArgs.push_back(Args.MakeArgString(Init));
492 }
493 }
494
495 //----------------------------------------------------------------------------
496 // Library Search Paths
497 //----------------------------------------------------------------------------
498 const ToolChain::path_list &LibPaths = HTC.getFilePaths();
499 for (const auto &LibPath : LibPaths)
500 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
501 Args.ClaimAllArgs(options::OPT_L);
502
503 //----------------------------------------------------------------------------
504 //
505 //----------------------------------------------------------------------------
506 Args.addAllArgs(CmdArgs, {options::OPT_T_Group, options::OPT_s,
507 options::OPT_t, options::OPT_u_Group});
508
509 AddLinkerInputs(HTC, Inputs, Args, CmdArgs, JA);
510
511 if (auto LTO = HTC.getLTOMode(Args); LTO != LTOK_None)
512 addLTOOptions(HTC, Args, CmdArgs, Output, Inputs, LTO == LTOK_Thin);
513
514 //----------------------------------------------------------------------------
515 // Libraries
516 //----------------------------------------------------------------------------
517 if (IncStdLib && IncDefLibs) {
518 if (D.CCCIsCXX()) {
519 if (HTC.ShouldLinkCXXStdlib(Args))
520 HTC.AddCXXStdlibLibArgs(Args, CmdArgs);
521 CmdArgs.push_back("-lm");
522 }
523
524 CmdArgs.push_back("--start-group");
525
526 if (!IsShared) {
527 if (HTC.GetCStdlibType(Args) == ToolChain::CST_Picolibc) {
528 if (HTC.getTriple().isOSH2()) {
529 CmdArgs.push_back("-lh2");
530 CmdArgs.push_back("-lsyscall_wrapper");
531 } else if (HTC.getTriple().isOSUnknown()) {
532 CmdArgs.push_back("-lsemihost");
533 }
534 // Known OS other than H2: no semihost lib; OS provides its own.
535 } else {
536 for (StringRef Lib : OsLibs)
537 CmdArgs.push_back(Args.MakeArgString("-l" + Lib));
538 }
539 if (!Args.hasArg(options::OPT_nolibc))
540 CmdArgs.push_back("-lc");
541 }
542 if (HTC.GetCStdlibType(Args) == ToolChain::CST_Picolibc) {
544 CmdArgs.push_back("-lclang_rt.builtins");
545 else
546 CmdArgs.push_back("-lgcc");
547 } else {
548 CmdArgs.push_back("-lgcc");
549 }
550
551 CmdArgs.push_back("--end-group");
552 }
553
554 //----------------------------------------------------------------------------
555 // End files
556 //----------------------------------------------------------------------------
557 if (IncStdLib && IncStartFiles) {
558 if (HTC.GetCStdlibType(Args) != ToolChain::CST_Picolibc) {
559 SmallString<128> Fini = LibraryDir;
560 llvm::sys::path::append(Fini, UseShared ? "finiS.o" : "fini.o");
561 CmdArgs.push_back(Args.MakeArgString(Fini));
562 }
563 }
564}
565
567 const InputInfo &Output,
568 const InputInfoList &Inputs,
569 const ArgList &Args,
570 const char *LinkingOutput) const {
571 auto &HTC = static_cast<const toolchains::HexagonToolChain&>(getToolChain());
572
573 ArgStringList CmdArgs;
574 constructHexagonLinkArgs(C, JA, HTC, Output, Inputs, Args, CmdArgs,
575 LinkingOutput);
576
577 const char *Exec = Args.MakeArgString(HTC.GetLinkerPath());
578 C.addCommand(std::make_unique<Command>(JA, *this,
580 Exec, CmdArgs, Inputs, Output));
581}
582// Hexagon tools end.
583
584/// Hexagon Toolchain
585
587 const std::string &InstalledDir,
588 const SmallVectorImpl<std::string> &PrefixDirs) const {
589 const Driver &D = getDriver();
590
591 // Locate the rest of the toolchain ...
592 for (auto &I : PrefixDirs)
593 if (D.getVFS().exists(I))
594 return I;
595
596 SmallString<128> Dir(InstalledDir);
597 llvm::sys::path::append(Dir, "..", "target");
598 return std::string(Dir);
599}
600
602HexagonToolChain::getEffectiveSysRoot(const ArgList &Args) const {
603 const Driver &D = getDriver();
604 // The user-specified `--sysroot` always takes precedence.
605 if (!D.SysRoot.empty())
606 return SmallString<128>(D.SysRoot);
607 SmallString<128> Dir(getHexagonTargetDir(D.Dir, D.PrefixDirs));
608 // For Picolibc, use picolibc/<triple> with no fallback.
610 llvm::sys::path::append(Dir, "picolibc", getTripleString());
611 return Dir;
612 }
613 // Otherwise, try a triple subdirectory first, then fall back to "hexagon".
614 llvm::sys::path::append(Dir, getTripleString());
615 if (getVFS().exists(Dir))
616 return Dir;
617 Dir = getHexagonTargetDir(D.Dir, D.PrefixDirs);
618 llvm::sys::path::append(Dir, "hexagon");
619 return Dir;
620}
621
622void HexagonToolChain::getLibraryDir(const ArgList &Args,
623 llvm::SmallString<128> &Dir) const {
624 bool IsLinuxMusl = getTriple().isMusl() && getTriple().isOSLinux();
625 const llvm::SmallString<128> SysRoot = getEffectiveSysRoot(Args);
626 // Linux toolchain uses "usr/lib" but it also should accept "lib" in case an
627 // external sysroot is used. Similar logic is for include paths.
628 if (IsLinuxMusl) {
629 Dir = SysRoot;
630 llvm::sys::path::append(Dir, "usr", "lib");
631 }
632 if (!IsLinuxMusl || !getVFS().exists(Dir)) {
633 Dir = SysRoot;
634 llvm::sys::path::append(Dir, "lib");
635 }
636 std::string CpuVer = GetTargetCPUVersion(Args).str();
637 bool IsPicolibc = GetCStdlibType(Args) == ToolChain::CST_Picolibc;
638 bool IsG0 =
640 0;
641 bool IsStatic = Args.hasArg(options::OPT_static);
642 bool IsShared = Args.hasArg(options::OPT_shared);
643 bool IsPic = Args.hasArg(options::OPT_fpic, options::OPT_fPIC);
644 if (IsPicolibc) {
645 // Flat layout: lib/v68-G0-pic, lib/v68-G0, lib/v68
646 std::string Variant = CpuVer;
647 if (IsG0)
648 Variant += "-G0";
649 if (IsPic || IsShared)
650 Variant += "-pic";
651 llvm::sys::path::append(Dir, Variant);
652 } else {
653 // Nested layout (non-Picolibc): lib/v68/G0/pic
654 llvm::sys::path::append(Dir, CpuVer);
655 if (IsG0)
656 llvm::sys::path::append(Dir, "G0");
657 if (IsShared && !IsStatic)
658 llvm::sys::path::append(Dir, "pic");
659 }
660}
661
662void HexagonToolChain::getBaseIncludeDir(const ArgList &Args,
663 llvm::SmallString<128> &Dir) const {
664 bool IsLinuxMusl = getTriple().isMusl() && getTriple().isOSLinux();
665 const llvm::SmallString<128> SysRoot = getEffectiveSysRoot(Args);
666 if (IsLinuxMusl) {
667 Dir = SysRoot;
668 llvm::sys::path::append(Dir, "usr", "include");
669 }
670 if (!IsLinuxMusl || !getVFS().exists(Dir)) {
671 Dir = SysRoot;
672 llvm::sys::path::append(Dir, "include");
673 }
674}
675
676std::optional<unsigned>
678 StringRef Gn = "";
679 if (Arg *A = Args.getLastArg(options::OPT_G)) {
680 Gn = A->getValue();
681 } else if (Args.getLastArg(options::OPT_shared, options::OPT_fpic,
682 options::OPT_fPIC)) {
683 Gn = "0";
684 }
685
686 unsigned G;
687 if (!Gn.getAsInteger(10, G))
688 return G;
689
690 return std::nullopt;
691}
692
694 SmallString<128> Dir(getDriver().SysRoot);
695 llvm::sys::path::append(Dir, "usr", "lib");
696 if (!SelectedMultilibs.empty()) {
697 Dir += SelectedMultilibs.back().gccSuffix();
698 }
699 return std::string(Dir);
700}
701
703 ToolChain::path_list &LibPaths) const {
704 const Driver &D = getDriver();
705
706 //----------------------------------------------------------------------------
707 // -L Args
708 //----------------------------------------------------------------------------
709 for (Arg *A : Args.filtered(options::OPT_L))
710 llvm::append_range(LibPaths, A->getValues());
711
712 //----------------------------------------------------------------------------
713 // Other standard paths
714 //----------------------------------------------------------------------------
715 std::vector<std::string> RootDirs;
716 std::copy(D.PrefixDirs.begin(), D.PrefixDirs.end(),
717 std::back_inserter(RootDirs));
718
719 std::string SysRoot(getEffectiveSysRoot(Args));
720 if (!llvm::is_contained(RootDirs, SysRoot))
721 RootDirs.push_back(SysRoot);
722
723 bool HasPIC = Args.hasArg(options::OPT_fpic, options::OPT_fPIC);
724 // Assume G0 with -shared.
725 bool HasG0 = Args.hasArg(options::OPT_shared);
726 if (auto G = getSmallDataThreshold(Args))
727 HasG0 = *G == 0;
728
729 bool IsPicolibc = GetCStdlibType(Args) == ToolChain::CST_Picolibc;
730 const std::string CpuVer = GetTargetCPUVersion(Args).str();
731 for (auto &Dir : RootDirs) {
732 std::string LibDir = Dir + "/lib";
733 std::string LibDirCpu = LibDir + '/' + CpuVer;
734 if (IsPicolibc) {
735 // Flat layout: push only the single most-specific variant dir, then lib.
736 // Base case (no G0/pic): lib/v68, lib.
737 // -shared also implies -pic for Picolibc library search paths.
738 bool HasPICOrShared = HasPIC || Args.hasArg(options::OPT_shared);
739 if (HasG0) {
740 std::string Variant = CpuVer + "-G0";
741 if (HasPICOrShared)
742 Variant += "-pic";
743 LibPaths.push_back(LibDir + "/" + Variant);
744 } else {
745 LibPaths.push_back(LibDirCpu);
746 }
747 } else {
748 // Nested layout (non-Picolibc): lib/v68/G0/pic, lib/v68/G0
749 if (HasG0) {
750 if (HasPIC)
751 LibPaths.push_back(LibDirCpu + "/G0/pic");
752 LibPaths.push_back(LibDirCpu + "/G0");
753 }
754 LibPaths.push_back(LibDirCpu);
755 }
756 LibPaths.push_back(LibDir);
757 }
758}
759
760HexagonToolChain::HexagonToolChain(const Driver &D, const llvm::Triple &Triple,
761 const llvm::opt::ArgList &Args)
762 : Linux(D, Triple, Args) {
764
765 // Remove paths added by Linux toolchain. Currently Hexagon_TC really targets
766 // 'elf' OS type, so the Linux paths are not appropriate. When we actually
767 // support 'linux' we'll need to fix this up
768 LibPaths.clear();
769 getHexagonLibraryPaths(Args, LibPaths);
770
771 if (getTriple().isMusl()) {
772 Multilibs.push_back(Multilib());
773 Multilibs.push_back(MultilibBuilder("msan", {}, {})
774 .flag("-fsanitize=memory")
775 .makeMultilib());
776 Multilibs.push_back(MultilibBuilder("asan", {}, {})
777 .flag("-fsanitize=address")
778 .makeMultilib());
779 Multilibs.push_back(MultilibBuilder("scs", {}, {})
780 .flag("-fsanitize=shadow-call-stack")
781 .makeMultilib());
782
784 addMultilibFlag(getSanitizerArgs(Args).needsMsanRt(), "-fsanitize=memory",
785 Flags);
786 addMultilibFlag(getSanitizerArgs(Args).needsAsanRt(), "-fsanitize=address",
787 Flags);
788 addMultilibFlag(getSanitizerArgs(Args).hasShadowCallStack(),
789 "-fsanitize=shadow-call-stack", Flags);
790
791 if (Multilibs.select(D, Flags, SelectedMultilibs)) {
792 Multilib LastSelected = SelectedMultilibs.back();
793 SelectedMultilibs = {LastSelected};
794
795 if (!SelectedMultilibs.back().isDefault()) {
796 SmallString<128> SanLibPath(D.SysRoot);
797 llvm::sys::path::append(SanLibPath, "usr", "lib");
798 SanLibPath += SelectedMultilibs.back().gccSuffix();
799 LibPaths.insert(LibPaths.begin(), std::string(SanLibPath));
800 }
801 }
802 }
803}
804
806
808 ArgStringList &CmdArgs) const {
811 if (UNW != ToolChain::UNW_None && UNW != ToolChain::UNW_CompilerRT) {
812 const Arg *A = Args.getLastArg(options::OPT_unwindlib_EQ);
813 if (A) {
814 getDriver().Diag(diag::err_drv_unsupported_unwind_for_platform)
815 << A->getValue() << getTripleString();
816 return;
817 }
818 }
819
820 switch (Type) {
822 CmdArgs.push_back("-lc++");
823 if (Args.hasArg(options::OPT_fexperimental_library))
824 CmdArgs.push_back("-lc++experimental");
825 CmdArgs.push_back("-lc++abi");
826 if (UNW != ToolChain::UNW_None)
827 CmdArgs.push_back("-lunwind");
828 break;
829
831 CmdArgs.push_back("-lstdc++");
832 break;
833 }
834}
835
839
841 return new tools::hexagon::Linker(*this);
842}
843
845 const llvm::opt::ArgList &DriverArgs) const {
846 // Copied in large part from lib/Frontend/CompilerInvocation.cpp.
847 Arg *A = DriverArgs.getLastArg(options::OPT_O_Group);
848 if (!A)
849 return 0;
850
851 if (A->getOption().matches(options::OPT_O0))
852 return 0;
853 if (A->getOption().matches(options::OPT_Ofast) ||
854 A->getOption().matches(options::OPT_O4))
855 return 3;
856 assert(A->getNumValues() != 0);
857 StringRef S(A->getValue());
858 if (S == "s" || S == "z" || S.empty())
859 return 2;
860 if (S == "g")
861 return 1;
862
863 unsigned OptLevel;
864 if (S.getAsInteger(10, OptLevel))
865 return 0;
866 return OptLevel;
867}
868
869void HexagonToolChain::addClangTargetOptions(const ArgList &DriverArgs,
870 ArgStringList &CC1Args,
871 BoundArch BA,
872 Action::OffloadKind) const {
873
874 bool UseInitArrayDefault =
875 getTriple().isMusl() ||
877
878 if (!DriverArgs.hasFlag(options::OPT_fuse_init_array,
879 options::OPT_fno_use_init_array,
880 UseInitArrayDefault))
881 CC1Args.push_back("-fno-use-init-array");
882
883 // The bool marks caller-saved (scratch) registers in the Hexagon ABI.
884 // Reserving those only behaves correctly if every other translation unit and
885 // library reserves them too, so we warn when the user does so.
886 static const std::tuple<options::ID, const char *, bool> FixedRegs[] = {
887 {options::OPT_ffixed_r6, "+reserved-r6", true},
888 {options::OPT_ffixed_r7, "+reserved-r7", true},
889 {options::OPT_ffixed_r8, "+reserved-r8", true},
890 {options::OPT_ffixed_r9, "+reserved-r9", true},
891 {options::OPT_ffixed_r10, "+reserved-r10", true},
892 {options::OPT_ffixed_r11, "+reserved-r11", true},
893 {options::OPT_ffixed_r12, "+reserved-r12", true},
894 {options::OPT_ffixed_r13, "+reserved-r13", true},
895 {options::OPT_ffixed_r14, "+reserved-r14", true},
896 {options::OPT_ffixed_r15, "+reserved-r15", true},
897 {options::OPT_ffixed_r16, "+reserved-r16", false},
898 {options::OPT_ffixed_r17, "+reserved-r17", false},
899 {options::OPT_ffixed_r18, "+reserved-r18", false},
900 {options::OPT_ffixed_r19, "+reserved-r19", false},
901 {options::OPT_ffixed_r20, "+reserved-r20", false},
902 {options::OPT_ffixed_r21, "+reserved-r21", false},
903 {options::OPT_ffixed_r22, "+reserved-r22", false},
904 {options::OPT_ffixed_r23, "+reserved-r23", false},
905 {options::OPT_ffixed_r24, "+reserved-r24", false},
906 {options::OPT_ffixed_r25, "+reserved-r25", false},
907 {options::OPT_ffixed_r26, "+reserved-r26", false},
908 {options::OPT_ffixed_r27, "+reserved-r27", false},
909 {options::OPT_ffixed_r28, "+reserved-r28", false},
910 };
911 for (const auto &[Opt, Feature, IsCallerSaved] : FixedRegs) {
912 if (Arg *A = DriverArgs.getLastArg(Opt)) {
913 if (IsCallerSaved)
914 getDriver().Diag(diag::warn_drv_hexagon_reserved_caller_saved_reg)
915 << A->getOption().getName();
916 CC1Args.push_back("-target-feature");
917 CC1Args.push_back(Feature);
918 }
919 }
920
921 // Select the shadow call stack pointer register. It has to hold a value
922 // across arbitrary calls, so only the callee-saved registers r16-r27 are
923 // allowed (Hexagon ABI, "Register usage across calls").
924 if (Arg *A = DriverArgs.getLastArg(options::OPT_mhexagon_scs_reg)) {
925 StringRef Val(A->getValue());
926 unsigned RegNo = 0;
927 if (!Val.consume_front("r") || Val.getAsInteger(10, RegNo) || RegNo < 16 ||
928 RegNo > 27) {
929 getDriver().Diag(diag::err_drv_invalid_value)
930 << A->getSpelling() << A->getValue();
931 } else {
932 CC1Args.push_back("-target-feature");
933 CC1Args.push_back(DriverArgs.MakeArgString("+scs-reg-r" + Twine(RegNo)));
934 }
935 }
936
937 if (isAutoHVXEnabled(DriverArgs)) {
938 CC1Args.push_back("-mllvm");
939 CC1Args.push_back("-hexagon-autohvx");
940 }
941}
942
943void HexagonToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
944 ArgStringList &CC1Args) const {
945 if (DriverArgs.hasArg(options::OPT_nostdinc))
946 return;
947
948 const Driver &D = getDriver();
949 const bool UseBuiltins = !DriverArgs.hasArg(options::OPT_nobuiltininc);
950 if (UseBuiltins) {
951 SmallString<128> ResourceDirInclude(D.ResourceDir);
952 llvm::sys::path::append(ResourceDirInclude, "include");
953 addSystemInclude(DriverArgs, CC1Args, ResourceDirInclude);
954 }
955 if (!DriverArgs.hasArg(options::OPT_nostdlibinc)) {
956 SmallString<128> CIncludeDir;
957 getBaseIncludeDir(DriverArgs, CIncludeDir);
958 addExternCSystemInclude(DriverArgs, CC1Args, std::string(CIncludeDir));
959 bool IsLinuxMusl = getTriple().isMusl() && getTriple().isOSLinux();
960 if (IsLinuxMusl) {
961 SmallString<128> LocalIncludeDir = getEffectiveSysRoot(DriverArgs);
962 llvm::sys::path::append(LocalIncludeDir, "usr", "local", "include");
963 addSystemInclude(DriverArgs, CC1Args, LocalIncludeDir);
964 }
965 // TOOL_INCLUDE_DIR
966 AddMultilibIncludeArgs(DriverArgs, CC1Args);
967 }
968}
969
971 const llvm::opt::ArgList &DriverArgs,
972 llvm::opt::ArgStringList &CC1Args) const {
974 getBaseIncludeDir(DriverArgs, Dir);
975 llvm::sys::path::append(Dir, "c++", "v1");
976 addLibStdCXXIncludePaths(Dir, "", "", DriverArgs, CC1Args);
977}
978
980 const llvm::opt::ArgList &DriverArgs,
981 llvm::opt::ArgStringList &CC1Args) const {
983 getBaseIncludeDir(DriverArgs, Dir);
984 llvm::sys::path::append(Dir, "c++");
985 addLibStdCXXIncludePaths(Dir, "", "", DriverArgs, CC1Args);
986}
987
989HexagonToolChain::GetRuntimeLibType(const ArgList &Args) const {
991 if (Args.getLastArg(options::OPT_rtlib_EQ))
992 return ToolChain::GetRuntimeLibType(Args);
994 }
995 return ToolChain::GetRuntimeLibType(Args);
996}
997
999HexagonToolChain::GetUnwindLibType(const ArgList &Args) const {
1001 if (Args.getLastArg(options::OPT_unwindlib_EQ))
1002 return ToolChain::GetUnwindLibType(Args);
1004 }
1005 return ToolChain::GetUnwindLibType(Args);
1006}
1007
1009HexagonToolChain::GetCXXStdlibType(const ArgList &Args) const {
1010 Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
1011 if (!A) {
1012 if (getTriple().isMusl() || GetCStdlibType(Args) == ToolChain::CST_Picolibc)
1013 return ToolChain::CST_Libcxx;
1014 else
1016 }
1017 StringRef Value = A->getValue();
1018 if (Value != "libstdc++" && Value != "libc++")
1019 getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
1020
1021 if (Value == "libstdc++")
1023 else if (Value == "libc++")
1024 return ToolChain::CST_Libcxx;
1025 else
1027}
1028
1029bool HexagonToolChain::isAutoHVXEnabled(const llvm::opt::ArgList &Args) {
1030 if (Arg *A = Args.getLastArg(options::OPT_fvectorize,
1031 options::OPT_fno_vectorize))
1032 return A->getOption().matches(options::OPT_fvectorize);
1033 return false;
1034}
1035
1036//
1037// Returns the default CPU for Hexagon. This is the default compilation target
1038// if no Hexagon processor is selected at the command-line.
1039//
1040StringRef HexagonToolChain::GetDefaultCPU() { return "hexagonv68"; }
1041
1042StringRef HexagonToolChain::GetTargetCPUVersion(const ArgList &Args) {
1043 Arg *CpuArg = nullptr;
1044 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1045 CpuArg = A;
1046
1047 StringRef CPU = CpuArg ? CpuArg->getValue() : GetDefaultCPU();
1048 CPU.consume_front("hexagon");
1049 return CPU;
1050}
1051
1052std::optional<std::string>
1054 // Handle -mh[v]x= and -mno-hvx. If versioned and versionless flags
1055 // are both present, the last one wins.
1056 Arg *HvxEnablingArg =
1057 Args.getLastArg(options::OPT_mhexagon_hvx, options::OPT_mhexagon_hvx_EQ,
1058 options::OPT_mno_hexagon_hvx);
1059 if (!HvxEnablingArg ||
1060 HvxEnablingArg->getOption().matches(options::OPT_mno_hexagon_hvx))
1061 return std::nullopt;
1062
1064 std::string HvxVer;
1065 if (!Cpu.empty() && (Cpu.back() == 'T' || Cpu.back() == 't'))
1066 HvxVer = Cpu.drop_back(1).str();
1067 else
1068 HvxVer = Cpu.str();
1069
1070 if (HvxEnablingArg->getOption().matches(options::OPT_mhexagon_hvx_EQ))
1071 HvxVer = StringRef(HvxEnablingArg->getValue()).lower();
1072
1073 return HvxVer;
1074}
1075
1076// End Hexagon
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:304
static void handleHVXWarnings(const Driver &D, const ArgList &Args)
Definition Hexagon.cpp:37
static StringRef getDefaultHvxLength(StringRef HvxVer)
Definition Hexagon.cpp:29
static StringRef getTriple(const Command &Job)
The base class of the type hierarchy.
Definition TypeBase.h:1879
Compilation - A set of tasks to perform for a single driver invocation.
Definition Compilation.h:46
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition Driver.h:93
std::string SysRoot
sysroot, if present
Definition Driver.h:193
DiagnosticBuilder Diag(unsigned DiagID) const
Definition Driver.h:157
bool CCCIsCXX() const
Whether the driver should follow g++ like behavior.
Definition Driver.h:220
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
This corresponds to a single GCC multilib, or a segment of one controlled by a command line flag.
MultilibBuilder & flag(StringRef Flag, bool Disallow=false)
Add a flag to the flags list Flag must be a flag accepted by the driver.
This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag.
Definition Multilib.h:35
std::vector< std::string > flags_list
Definition Multilib.h:37
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.
virtual CStdlibType GetCStdlibType(const llvm::opt::ArgList &Args) const
virtual RuntimeLibType GetRuntimeLibType(const llvm::opt::ArgList &Args) const
bool ShouldLinkCXXStdlib(const llvm::opt::ArgList &Args) const
Returns if the C++ standard library should be linked in.
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.
path_list & getFilePaths()
Definition ToolChain.h:322
const Driver & getDriver() const
Definition ToolChain.h:282
llvm::vfs::FileSystem & getVFS() const
virtual LTOKind getLTOMode(const llvm::opt::ArgList &Args, Action::OffloadKind Kind=Action::OFK_None) const
Resolve the requested LTO mode for this toolchain.
const llvm::Triple & getTriple() const
Definition ToolChain.h:284
const llvm::SmallVector< Multilib > & getSelectedMultilibs() const
Definition ToolChain.h:330
virtual UnwindLibType GetUnwindLibType(const llvm::opt::ArgList &Args) const
StringRef getTripleString() const
Definition ToolChain.h:307
std::string GetLinkerPath(bool *LinkerIsLLD=nullptr) const
Returns the linker path, respecting the -fuse-ld= argument to determine the linker suffix or name.
llvm::SmallVector< Multilib > SelectedMultilibs
Definition ToolChain.h:213
SanitizerArgs getSanitizerArgs(const llvm::opt::ArgList &JobArgs, BoundArch BA={}, Action::OffloadKind DeviceOffloadKind=Action::OFK_None) const
SmallVector< std::string, 16 > path_list
Definition ToolChain.h:94
Tool - Information on a specific compilation tool.
Definition Tool.h:31
const ToolChain & getToolChain() const
Definition Tool.h:51
void AddMultilibIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const
Definition Gnu.cpp:3234
bool addLibStdCXXIncludePaths(Twine IncludeDir, StringRef Triple, Twine IncludeSuffix, const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, bool DetectDebian=false) const
Definition Gnu.cpp:3367
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:807
static bool isAutoHVXEnabled(const llvm::opt::ArgList &Args)
Definition Hexagon.cpp:1029
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:943
void getLibraryDir(const llvm::opt::ArgList &Args, llvm::SmallString< 128 > &) const
Definition Hexagon.cpp:622
std::string getHexagonTargetDir(const std::string &InstalledDir, const SmallVectorImpl< std::string > &PrefixDirs) const
Hexagon Toolchain.
Definition Hexagon.cpp:586
unsigned getOptimizationLevel(const llvm::opt::ArgList &DriverArgs) const
Definition Hexagon.cpp:844
UnwindLibType GetUnwindLibType(const llvm::opt::ArgList &Args) const override
Definition Hexagon.cpp:999
void getHexagonLibraryPaths(const llvm::opt::ArgList &Args, ToolChain::path_list &LibPaths) const
Definition Hexagon.cpp:702
void addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Definition Hexagon.cpp:979
RuntimeLibType GetRuntimeLibType(const llvm::opt::ArgList &Args) const override
Definition Hexagon.cpp:989
void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, BoundArch BA, Action::OffloadKind DeviceOffloadKind) const override
Add options that need to be passed to cc1 for this target.
Definition Hexagon.cpp:869
void getBaseIncludeDir(const llvm::opt::ArgList &Args, llvm::SmallString< 128 > &) const
Definition Hexagon.cpp:662
SmallString< 128 > getEffectiveSysRoot(const llvm::opt::ArgList &Args) const
Definition Hexagon.cpp:602
HexagonToolChain(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Definition Hexagon.cpp:760
std::string getCompilerRTPath() const override
Definition Hexagon.cpp:693
CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override
Definition Hexagon.cpp:1009
static std::optional< std::string > GetHVXVersion(const llvm::opt::ArgList &Args)
Definition Hexagon.cpp:1053
void addLibCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Definition Hexagon.cpp:970
static std::optional< unsigned > getSmallDataThreshold(const llvm::opt::ArgList &Args)
Definition Hexagon.cpp:677
bool isPIEDefault(const llvm::opt::ArgList &Args) const override
Test whether this toolchain defaults to PIE.
Definition Hexagon.h:121
static StringRef GetTargetCPUVersion(const llvm::opt::ArgList &Args)
Definition Hexagon.cpp:1042
std::vector< std::string > ExtraOpts
Definition Linux.h:72
Linux(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Definition Linux.cpp:225
void RenderExtraToolArgs(const JobAction &JA, llvm::opt::ArgStringList &CmdArgs) const
Definition Hexagon.cpp:206
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:210
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:566
void RenderExtraToolArgs(const JobAction &JA, llvm::opt::ArgStringList &CmdArgs) const
Definition Hexagon.cpp:299
void getHexagonTargetFeatures(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args, std::vector< StringRef > &Features)
void handleTargetFeaturesGroup(const Driver &D, const llvm::Triple &Triple, 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.
bool addSanitizerRuntimes(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, Compilation &C)
void addLTOOptions(const ToolChain &ToolChain, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const InputInfo &Output, const InputInfoList &Inputs, bool IsThinLTO)
void addMultilibFlag(bool Enabled, const StringRef Flag, Multilib::flags_list &Flags)
Flag must be a flag accepted by the driver.
void linkXRayRuntimeDeps(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs)
void linkSanitizerRuntimeDeps(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)
std::tuple< llvm::Reloc::Model, unsigned, bool > ParsePICArgs(const ToolChain &ToolChain, const llvm::opt::ArgList &Args)
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)
bool isLLVMIR(ID Id)
Is this LLVM IR.
Definition Types.cpp:292
SmallVector< InputInfo, 4 > InputInfoList
Definition Driver.h:49
Top level wrappers for InstallAPI frontend operations.
@ Default
Set to the current date and time.
const FunctionProtoType * T
Represents a bound architecture for offload / multiple architecture compilation.
static constexpr ResponseFileSupport AtFileCurCP()
Definition Job.h:93