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 "clang/Driver/CommonArgs.h"
11#include "clang/Driver/Compilation.h"
12#include "clang/Driver/Driver.h"
13#include "clang/Driver/InputInfo.h"
14#include "clang/Driver/MultilibBuilder.h"
15#include "clang/Driver/SanitizerArgs.h"
16#include "clang/Options/Options.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(S: "v60", Value: "64b")
32 .Case(S: "v62", Value: "64b")
33 .Case(S: "v65", Value: "64b")
34 .Default(Value: "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(Ids: options::OPT_mhexagon_hvx_length_EQ)) {
40 StringRef Val = A->getValue();
41 if (!Val.equals_insensitive(RHS: "64b") && !Val.equals_insensitive(RHS: "128b"))
42 D.Diag(DiagID: 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(Suffix: "=");
58 if (Opt.starts_with(Prefix: "mno-"))
59 Opt = Opt.drop_front(N: 4);
60 else if (Opt.starts_with(Prefix: "m"))
61 Opt = Opt.drop_front(N: 1);
62 return Args.MakeArgString(Str: 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 =
70 toolchains::HexagonToolChain::GetHVXVersion(Args);
71 HasHVX = HvxVer.has_value();
72 if (HasHVX)
73 Features.push_back(x: makeFeature(Twine("hvx") + *HvxVer, true));
74 else {
75 if (Arg *A = Args.getLastArg(Ids: options::OPT_mno_hexagon_hvx)) {
76 // If there was an explicit -mno-hvx, add -hvx to target features.
77 Features.push_back(x: makeFeature(A->getOption().getName(), false));
78 }
79 }
80
81 StringRef HvxLen =
82 getDefaultHvxLength(HvxVer: HasHVX ? StringRef(*HvxVer) : StringRef(""));
83
84 // Handle -mhvx-length=.
85 if (Arg *A = Args.getLastArg(Ids: options::OPT_mhexagon_hvx_length_EQ)) {
86 // These flags are valid only if HVX in enabled.
87 if (!HasHVX)
88 D.Diag(DiagID: diag::err_drv_needs_hvx) << withMinus(A->getOption().getName());
89 else if (A->getOption().matches(ID: 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(x: 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(N: 1).getAsInteger(Radix: 10, Result&: 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(ID: FlagOff))
122 return makeFeature(OptName, false);
123
124 if (!HasHVX) {
125 D.Diag(DiagID: diag::err_drv_needs_hvx) << withMinus(OptName);
126 return std::nullopt;
127 }
128 if (HvxVerNum < MinVerNum) {
129 D.Diag(DiagID: diag::err_drv_needs_hvx_version)
130 << withMinus(OptName) << ("v" + std::to_string(val: HvxVerNum));
131 return std::nullopt;
132 }
133
134 if (CheckMode && A->getOption().matches(ID: FlagOnWithModes)) {
135 bool ValidMode =
136 llvm::StringSwitch<bool>(StringRef(A->getValue()).lower())
137 .Cases(CaseStrings: {"strict-ieee", "ieee", "lossy", "legacy"}, Value: true)
138 .Default(Value: false);
139 if (!ValidMode)
140 D.Diag(DiagID: 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(x: *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(x: *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(Ids: options::OPT_mhexagon_hvx_ieee_fp))
160 Features.push_back(x: "+hvx-qfloat");
161}
162
163// Hexagon target features.
164void hexagon::getHexagonTargetFeatures(const Driver &D,
165 const llvm::Triple &Triple,
166 const ArgList &Args,
167 std::vector<StringRef> &Features) {
168 handleTargetFeaturesGroup(D, Triple, Args, Features,
169 Group: options::OPT_m_hexagon_Features_Group);
170
171 bool UseLongCalls = false;
172 if (Arg *A = Args.getLastArg(Ids: options::OPT_mlong_calls,
173 Ids: options::OPT_mno_long_calls)) {
174 if (A->getOption().matches(ID: options::OPT_mlong_calls))
175 UseLongCalls = true;
176 }
177
178 Features.push_back(x: UseLongCalls ? "+long-calls" : "-long-calls");
179
180 bool HasHVX = false;
181 StringRef Cpu(toolchains::HexagonToolChain::GetTargetCPUVersion(Args));
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(C: 't');
185
186 if (TinyCore)
187 Cpu = Cpu.take_front(N: 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(Ids: options::OPT_mhexagon_hlx,
193 Ids: options::OPT_mno_hexagon_hlx)) {
194 unsigned CpuVer = 0;
195 // getAsInteger returns 'true' on error.
196 if (Cpu.substr(Start: 1).getAsInteger(Radix: 10, Result&: CpuVer) || CpuVer < 85)
197 D.Diag(DiagID: diag::err_drv_unsupported_opt_for_target)
198 << A->getSpelling() << Cpu;
199 }
200
201 if (HexagonToolChain::isAutoHVXEnabled(Args) && !HasHVX)
202 D.Diag(DiagID: diag::warn_drv_needs_hvx) << "auto-vectorization";
203}
204
205// Hexagon tools start.
206void hexagon::Assembler::RenderExtraToolArgs(const JobAction &JA,
207 ArgStringList &CmdArgs) const {
208}
209
210void hexagon::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
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(Elt: "--arch=hexagon");
222
223 RenderExtraToolArgs(JA, CmdArgs);
224
225 const char *AsName = "llvm-mc";
226 CmdArgs.push_back(Elt: "-filetype=obj");
227 CmdArgs.push_back(Elt: Args.MakeArgString(
228 Str: "-mcpu=hexagon" +
229 toolchains::HexagonToolChain::GetTargetCPUVersion(Args)));
230
231 if (std::get<0>(t: ParsePICArgs(ToolChain: HTC, Args)) == llvm::Reloc::PIC_)
232 CmdArgs.push_back(Elt: "-position-independent");
233
234 addSanitizerRuntimes(TC: HTC, Args, CmdArgs, C);
235
236 assert((Output.isFilename() || Output.isNothing()) && "Invalid output.");
237 if (Output.isFilename()) {
238 CmdArgs.push_back(Elt: "-o");
239 CmdArgs.push_back(Elt: Output.getFilename());
240 } else {
241 CmdArgs.push_back(Elt: "-fsyntax-only");
242 }
243
244 if (Arg *A = Args.getLastArg(Ids: options::OPT_mhexagon_hvx_ieee_fp,
245 Ids: options::OPT_mno_hexagon_hvx_ieee_fp)) {
246 if (A->getOption().matches(ID: options::OPT_mhexagon_hvx_ieee_fp))
247 CmdArgs.push_back(Elt: "-mhvx-ieee-fp");
248 }
249
250 if (Args.hasFlag(Pos: options::OPT_mhexagon_hmx, Neg: options::OPT_mno_hexagon_hmx,
251 Default: false)) {
252 CmdArgs.push_back(Elt: "-mhmx");
253 }
254
255 if (Args.hasFlag(Pos: options::OPT_mhexagon_hlx, Neg: options::OPT_mno_hexagon_hlx,
256 Default: false))
257 CmdArgs.push_back(Elt: "-mhlx");
258
259 if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) {
260 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-gpsize=" + Twine(*G)));
261 }
262
263 Args.AddAllArgValues(Output&: CmdArgs, Id0: options::OPT_Wa_COMMA, Id1: 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(Id: II.getType()))
276 D.Diag(DiagID: clang::diag::err_drv_no_linker_llvm_support)
277 << HTC.getTripleString();
278 else if (II.getType() == types::TY_AST)
279 D.Diag(DiagID: clang::diag::err_drv_no_ast_support)
280 << HTC.getTripleString();
281 else if (II.getType() == types::TY_ModuleFile)
282 D.Diag(DiagID: diag::err_drv_no_module_support)
283 << HTC.getTripleString();
284
285 if (II.isFilename())
286 CmdArgs.push_back(Elt: 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, Output&: CmdArgs);
291 }
292
293 auto *Exec = Args.MakeArgString(Str: HTC.GetProgramPath(Name: AsName));
294 C.addCommand(Cmd: std::make_unique<Command>(args: JA, args: *this,
295 args: ResponseFileSupport::AtFileCurCP(),
296 args&: Exec, args&: CmdArgs, args: Inputs, args: Output));
297}
298
299void hexagon::Linker::RenderExtraToolArgs(const JobAction &JA,
300 ArgStringList &CmdArgs) const {
301}
302
303static void
304constructHexagonLinkArgs(Compilation &C, const JobAction &JA,
305 const toolchains::HexagonToolChain &HTC,
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(Ids: options::OPT_static);
316 bool IsShared = Args.hasArg(Ids: options::OPT_shared);
317 bool IsPIE = Args.hasFlag(Pos: options::OPT_pie, Neg: options::OPT_no_pie,
318 Default: HTC.isPIEDefault(Args));
319 bool IncStdLib = !Args.hasArg(Ids: options::OPT_nostdlib);
320 bool IncStartFiles = !Args.hasArg(Ids: options::OPT_nostartfiles);
321 bool IncDefLibs = !Args.hasArg(Ids: options::OPT_nodefaultlibs);
322 bool UseLLD = false;
323 const char *Exec = Args.MakeArgString(Str: HTC.GetLinkerPath(LinkerIsLLD: &UseLLD));
324 StringRef LinkerName = llvm::sys::path::filename(path: Exec);
325 UseLLD = UseLLD || LinkerName.starts_with(Prefix: "ld.lld") ||
326 LinkerName.ends_with(Suffix: "ld.lld") ||
327 llvm::sys::path::stem(path: Exec).ends_with(Suffix: "ld.lld");
328 bool UseShared = IsShared && !IsStatic;
329 StringRef CpuVer = toolchains::HexagonToolChain::GetTargetCPUVersion(Args);
330
331 bool NeedsSanitizerDeps = addSanitizerRuntimes(TC: HTC, Args, CmdArgs, C);
332 bool NeedsXRayDeps = addXRayRuntime(TC: HTC, Args, CmdArgs);
333
334 //----------------------------------------------------------------------------
335 // Silence warnings for various options
336 //----------------------------------------------------------------------------
337 Args.ClaimAllArgs(Id0: options::OPT_g_Group);
338 Args.ClaimAllArgs(Id0: options::OPT_emit_llvm);
339 Args.ClaimAllArgs(Id0: options::OPT_w); // Other warning options are already
340 // handled somewhere else.
341 Args.ClaimAllArgs(Id0: options::OPT_static_libgcc);
342
343 CmdArgs.push_back(Elt: "--eh-frame-hdr");
344 //----------------------------------------------------------------------------
345 //
346 //----------------------------------------------------------------------------
347 if (Args.hasArg(Ids: options::OPT_s))
348 CmdArgs.push_back(Elt: "-s");
349
350 if (Args.hasArg(Ids: options::OPT_r))
351 CmdArgs.push_back(Elt: "-r");
352
353 for (const auto &Opt : HTC.ExtraOpts)
354 CmdArgs.push_back(Elt: Opt.c_str());
355
356 if (!UseLLD) {
357 CmdArgs.push_back(Elt: "-march=hexagon");
358 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-mcpu=hexagon" + CpuVer));
359 }
360
361 if (IsShared) {
362 CmdArgs.push_back(Elt: "-shared");
363 // The following should be the default, but doing as hexagon-gcc does.
364 CmdArgs.push_back(Elt: "-call_shared");
365 }
366
367 if (IsStatic)
368 CmdArgs.push_back(Elt: "-static");
369
370 if (IsPIE && !IsShared && !Args.hasArg(Ids: options::OPT_r))
371 CmdArgs.push_back(Elt: "-pie");
372
373 if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args))
374 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-G" + Twine(*G)));
375
376 CmdArgs.push_back(Elt: "-o");
377 CmdArgs.push_back(Elt: Output.getFilename());
378
379 if (HTC.getTriple().isMusl()) {
380 if (!Args.hasArg(Ids: options::OPT_shared, Ids: options::OPT_static, Ids: options::OPT_r))
381 CmdArgs.push_back(Elt: "-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(Ids: options::OPT_shared, Ids: options::OPT_nostartfiles,
392 Ids: options::OPT_nostdlib, Ids: options::OPT_r)) {
393 if (IsStatic && IsPIE)
394 CmdArgs.push_back(Elt: Args.MakeArgString(Str: StartFile("rcrt1.o")));
395 else
396 CmdArgs.push_back(Elt: Args.MakeArgString(Str: StartFile("crt1.o")));
397 } else if (Args.hasArg(Ids: options::OPT_shared) &&
398 !Args.hasArg(Ids: options::OPT_nostartfiles, Ids: options::OPT_nostdlib,
399 Ids: options::OPT_r))
400 CmdArgs.push_back(Elt: Args.MakeArgString(Str: StartFile("crti.o")));
401
402 if (!MLSuffix.empty()) {
403 CmdArgs.push_back(Elt: Args.MakeArgString(Str: StringRef("-L") + D.SysRoot +
404 "/usr/lib" + MLSuffix));
405 }
406 CmdArgs.push_back(
407 Elt: Args.MakeArgString(Str: StringRef("-L") + D.SysRoot + "/usr/lib"));
408 Args.addAllArgs(Output&: CmdArgs, Ids: {options::OPT_T_Group, options::OPT_s,
409 options::OPT_t, options::OPT_u_Group});
410 AddLinkerInputs(TC: HTC, Inputs, Args, CmdArgs, JA);
411
412 if (auto LTO = HTC.getLTOMode(Args); LTO != LTOK_None)
413 addLTOOptions(ToolChain: HTC, Args, CmdArgs, Output, Inputs, IsThinLTO: LTO == LTOK_Thin);
414
415 ToolChain::UnwindLibType UNW = HTC.GetUnwindLibType(Args);
416
417 if (!Args.hasArg(Ids: options::OPT_nostdlib, Ids: options::OPT_nodefaultlibs)) {
418 if (NeedsSanitizerDeps) {
419 linkSanitizerRuntimeDeps(TC: HTC, Args, CmdArgs);
420
421 if (UNW != ToolChain::UNW_None)
422 CmdArgs.push_back(Elt: "-lunwind");
423 }
424 if (NeedsXRayDeps)
425 linkXRayRuntimeDeps(TC: HTC, Args, CmdArgs);
426
427 if (!Args.hasArg(Ids: options::OPT_nolibc))
428 CmdArgs.push_back(Elt: "-lc");
429 CmdArgs.push_back(Elt: "-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(Elt: Args.MakeArgString(Str: StringRef("-L") + LibPath));
438 Args.ClaimAllArgs(Id0: 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(Ids: options::OPT_moslib_EQ)) {
448 A->claim();
449 OsLibs.emplace_back(args: A->getValue());
450 HasStandalone = HasStandalone || (OsLibs.back() == "standalone");
451 }
452 if (OsLibs.empty()) {
453 OsLibs.push_back(x: "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(path&: Crt0, a: "crt0-noflash-hosted.o");
468 CmdArgs.push_back(Elt: Args.MakeArgString(Str: Crt0));
469 } else if (HTC.getTriple().isOSUnknown()) {
470 llvm::sys::path::append(path&: Crt0, a: "crt0-semihost.o");
471 CmdArgs.push_back(Elt: Args.MakeArgString(Str: 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(path&: Crt0SA, a: "crt0_standalone.o");
481 CmdArgs.push_back(Elt: Args.MakeArgString(Str: Crt0SA));
482 }
483 SmallString<128> Crt0 = LibraryDir;
484 llvm::sys::path::append(path&: Crt0, a: "crt0.o");
485 CmdArgs.push_back(Elt: Args.MakeArgString(Str: Crt0));
486 }
487 }
488 if (HTC.GetCStdlibType(Args) != ToolChain::CST_Picolibc) {
489 SmallString<128> Init = LibraryDir;
490 llvm::sys::path::append(path&: Init, a: UseShared ? "initS.o" : "init.o");
491 CmdArgs.push_back(Elt: Args.MakeArgString(Str: 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(Elt: Args.MakeArgString(Str: StringRef("-L") + LibPath));
501 Args.ClaimAllArgs(Id0: options::OPT_L);
502
503 //----------------------------------------------------------------------------
504 //
505 //----------------------------------------------------------------------------
506 Args.addAllArgs(Output&: CmdArgs, Ids: {options::OPT_T_Group, options::OPT_s,
507 options::OPT_t, options::OPT_u_Group});
508
509 AddLinkerInputs(TC: HTC, Inputs, Args, CmdArgs, JA);
510
511 if (auto LTO = HTC.getLTOMode(Args); LTO != LTOK_None)
512 addLTOOptions(ToolChain: HTC, Args, CmdArgs, Output, Inputs, IsThinLTO: 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(Elt: "-lm");
522 }
523
524 CmdArgs.push_back(Elt: "--start-group");
525
526 if (!IsShared) {
527 if (HTC.GetCStdlibType(Args) == ToolChain::CST_Picolibc) {
528 if (HTC.getTriple().isOSH2()) {
529 CmdArgs.push_back(Elt: "-lh2");
530 CmdArgs.push_back(Elt: "-lsyscall_wrapper");
531 } else if (HTC.getTriple().isOSUnknown()) {
532 CmdArgs.push_back(Elt: "-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(Elt: Args.MakeArgString(Str: "-l" + Lib));
538 }
539 if (!Args.hasArg(Ids: options::OPT_nolibc))
540 CmdArgs.push_back(Elt: "-lc");
541 }
542 if (HTC.GetCStdlibType(Args) == ToolChain::CST_Picolibc) {
543 if (HTC.GetRuntimeLibType(Args) == ToolChain::RLT_CompilerRT)
544 CmdArgs.push_back(Elt: "-lclang_rt.builtins");
545 else
546 CmdArgs.push_back(Elt: "-lgcc");
547 } else {
548 CmdArgs.push_back(Elt: "-lgcc");
549 }
550
551 CmdArgs.push_back(Elt: "--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(path&: Fini, a: UseShared ? "finiS.o" : "fini.o");
561 CmdArgs.push_back(Elt: Args.MakeArgString(Str: Fini));
562 }
563 }
564}
565
566void hexagon::Linker::ConstructJob(Compilation &C, const JobAction &JA,
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(Str: HTC.GetLinkerPath());
578 C.addCommand(Cmd: std::make_unique<Command>(args: JA, args: *this,
579 args: ResponseFileSupport::AtFileCurCP(),
580 args&: Exec, args&: CmdArgs, args: Inputs, args: Output));
581}
582// Hexagon tools end.
583
584/// Hexagon Toolchain
585
586std::string HexagonToolChain::getHexagonTargetDir(
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(Path: I))
594 return I;
595
596 SmallString<128> Dir(InstalledDir);
597 llvm::sys::path::append(path&: Dir, a: "..", b: "target");
598 return std::string(Dir);
599}
600
601SmallString<128>
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(InstalledDir: D.Dir, PrefixDirs: D.PrefixDirs));
608 // For Picolibc, use picolibc/<triple> with no fallback.
609 if (GetCStdlibType(Args) == ToolChain::CST_Picolibc) {
610 llvm::sys::path::append(path&: Dir, a: "picolibc", b: getTripleString());
611 return Dir;
612 }
613 // Otherwise, try a triple subdirectory first, then fall back to "hexagon".
614 llvm::sys::path::append(path&: Dir, a: getTripleString());
615 if (getVFS().exists(Path: Dir))
616 return Dir;
617 Dir = getHexagonTargetDir(InstalledDir: D.Dir, PrefixDirs: D.PrefixDirs);
618 llvm::sys::path::append(path&: Dir, a: "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(path&: Dir, a: "usr", b: "lib");
631 }
632 if (!IsLinuxMusl || !getVFS().exists(Path: Dir)) {
633 Dir = SysRoot;
634 llvm::sys::path::append(path&: Dir, a: "lib");
635 }
636 std::string CpuVer = GetTargetCPUVersion(Args).str();
637 bool IsPicolibc = GetCStdlibType(Args) == ToolChain::CST_Picolibc;
638 bool IsG0 =
639 toolchains::HexagonToolChain::getSmallDataThreshold(Args).value_or(u: 1) ==
640 0;
641 bool IsStatic = Args.hasArg(Ids: options::OPT_static);
642 bool IsShared = Args.hasArg(Ids: options::OPT_shared);
643 bool IsPic = Args.hasArg(Ids: options::OPT_fpic, Ids: 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(path&: Dir, a: Variant);
652 } else {
653 // Nested layout (non-Picolibc): lib/v68/G0/pic
654 llvm::sys::path::append(path&: Dir, a: CpuVer);
655 if (IsG0)
656 llvm::sys::path::append(path&: Dir, a: "G0");
657 if (IsShared && !IsStatic)
658 llvm::sys::path::append(path&: Dir, a: "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(path&: Dir, a: "usr", b: "include");
669 }
670 if (!IsLinuxMusl || !getVFS().exists(Path: Dir)) {
671 Dir = SysRoot;
672 llvm::sys::path::append(path&: Dir, a: "include");
673 }
674}
675
676std::optional<unsigned>
677HexagonToolChain::getSmallDataThreshold(const ArgList &Args) {
678 StringRef Gn = "";
679 if (Arg *A = Args.getLastArg(Ids: options::OPT_G)) {
680 Gn = A->getValue();
681 } else if (Args.getLastArg(Ids: options::OPT_shared, Ids: options::OPT_fpic,
682 Ids: options::OPT_fPIC)) {
683 Gn = "0";
684 }
685
686 unsigned G;
687 if (!Gn.getAsInteger(Radix: 10, Result&: G))
688 return G;
689
690 return std::nullopt;
691}
692
693std::string HexagonToolChain::getCompilerRTPath() const {
694 SmallString<128> Dir(getDriver().SysRoot);
695 llvm::sys::path::append(path&: Dir, a: "usr", b: "lib");
696 if (!SelectedMultilibs.empty()) {
697 Dir += SelectedMultilibs.back().gccSuffix();
698 }
699 return std::string(Dir);
700}
701
702void HexagonToolChain::getHexagonLibraryPaths(const ArgList &Args,
703 ToolChain::path_list &LibPaths) const {
704 const Driver &D = getDriver();
705
706 //----------------------------------------------------------------------------
707 // -L Args
708 //----------------------------------------------------------------------------
709 for (Arg *A : Args.filtered(Ids: options::OPT_L))
710 llvm::append_range(C&: LibPaths, R&: A->getValues());
711
712 //----------------------------------------------------------------------------
713 // Other standard paths
714 //----------------------------------------------------------------------------
715 std::vector<std::string> RootDirs;
716 std::copy(first: D.PrefixDirs.begin(), last: D.PrefixDirs.end(),
717 result: std::back_inserter(x&: RootDirs));
718
719 std::string SysRoot(getEffectiveSysRoot(Args));
720 if (!llvm::is_contained(Range&: RootDirs, Element: SysRoot))
721 RootDirs.push_back(x: SysRoot);
722
723 bool HasPIC = Args.hasArg(Ids: options::OPT_fpic, Ids: options::OPT_fPIC);
724 // Assume G0 with -shared.
725 bool HasG0 = Args.hasArg(Ids: 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(Ids: options::OPT_shared);
739 if (HasG0) {
740 std::string Variant = CpuVer + "-G0";
741 if (HasPICOrShared)
742 Variant += "-pic";
743 LibPaths.push_back(Elt: LibDir + "/" + Variant);
744 } else {
745 LibPaths.push_back(Elt: 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(Elt: LibDirCpu + "/G0/pic");
752 LibPaths.push_back(Elt: LibDirCpu + "/G0");
753 }
754 LibPaths.push_back(Elt: LibDirCpu);
755 }
756 LibPaths.push_back(Elt: LibDir);
757 }
758}
759
760HexagonToolChain::HexagonToolChain(const Driver &D, const llvm::Triple &Triple,
761 const llvm::opt::ArgList &Args)
762 : Linux(D, Triple, Args) {
763 ToolChain::path_list &LibPaths = getFilePaths();
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(M: Multilib());
773 Multilibs.push_back(M: MultilibBuilder("msan", {}, {})
774 .flag(Flag: "-fsanitize=memory")
775 .makeMultilib());
776 Multilibs.push_back(M: MultilibBuilder("asan", {}, {})
777 .flag(Flag: "-fsanitize=address")
778 .makeMultilib());
779 Multilibs.push_back(M: MultilibBuilder("scs", {}, {})
780 .flag(Flag: "-fsanitize=shadow-call-stack")
781 .makeMultilib());
782
783 Multilib::flags_list Flags;
784 addMultilibFlag(Enabled: getSanitizerArgs(JobArgs: Args).needsMsanRt(), Flag: "-fsanitize=memory",
785 Flags);
786 addMultilibFlag(Enabled: getSanitizerArgs(JobArgs: Args).needsAsanRt(), Flag: "-fsanitize=address",
787 Flags);
788 addMultilibFlag(Enabled: getSanitizerArgs(JobArgs: Args).hasShadowCallStack(),
789 Flag: "-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(path&: SanLibPath, a: "usr", b: "lib");
798 SanLibPath += SelectedMultilibs.back().gccSuffix();
799 LibPaths.insert(I: LibPaths.begin(), Elt: std::string(SanLibPath));
800 }
801 }
802 }
803}
804
805HexagonToolChain::~HexagonToolChain() {}
806
807void HexagonToolChain::AddCXXStdlibLibArgs(const ArgList &Args,
808 ArgStringList &CmdArgs) const {
809 CXXStdlibType Type = GetCXXStdlibType(Args);
810 ToolChain::UnwindLibType UNW = GetUnwindLibType(Args);
811 if (UNW != ToolChain::UNW_None && UNW != ToolChain::UNW_CompilerRT) {
812 const Arg *A = Args.getLastArg(Ids: options::OPT_unwindlib_EQ);
813 if (A) {
814 getDriver().Diag(DiagID: diag::err_drv_unsupported_unwind_for_platform)
815 << A->getValue() << getTripleString();
816 return;
817 }
818 }
819
820 switch (Type) {
821 case ToolChain::CST_Libcxx:
822 CmdArgs.push_back(Elt: "-lc++");
823 if (Args.hasArg(Ids: options::OPT_fexperimental_library))
824 CmdArgs.push_back(Elt: "-lc++experimental");
825 CmdArgs.push_back(Elt: "-lc++abi");
826 if (UNW != ToolChain::UNW_None)
827 CmdArgs.push_back(Elt: "-lunwind");
828 break;
829
830 case ToolChain::CST_Libstdcxx:
831 CmdArgs.push_back(Elt: "-lstdc++");
832 break;
833 }
834}
835
836Tool *HexagonToolChain::buildAssembler() const {
837 return new tools::hexagon::Assembler(*this);
838}
839
840Tool *HexagonToolChain::buildLinker() const {
841 return new tools::hexagon::Linker(*this);
842}
843
844unsigned HexagonToolChain::getOptimizationLevel(
845 const llvm::opt::ArgList &DriverArgs) const {
846 // Copied in large part from lib/Frontend/CompilerInvocation.cpp.
847 Arg *A = DriverArgs.getLastArg(Ids: options::OPT_O_Group);
848 if (!A)
849 return 0;
850
851 if (A->getOption().matches(ID: options::OPT_O0))
852 return 0;
853 if (A->getOption().matches(ID: options::OPT_Ofast) ||
854 A->getOption().matches(ID: 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(Radix: 10, Result&: 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() ||
876 GetCStdlibType(Args: DriverArgs) == ToolChain::CST_Picolibc;
877
878 if (!DriverArgs.hasFlag(Pos: options::OPT_fuse_init_array,
879 Neg: options::OPT_fno_use_init_array,
880 Default: UseInitArrayDefault))
881 CC1Args.push_back(Elt: "-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(Ids: Opt)) {
913 if (IsCallerSaved)
914 getDriver().Diag(DiagID: diag::warn_drv_hexagon_reserved_caller_saved_reg)
915 << A->getOption().getName();
916 CC1Args.push_back(Elt: "-target-feature");
917 CC1Args.push_back(Elt: 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(Ids: options::OPT_mhexagon_scs_reg)) {
925 StringRef Val(A->getValue());
926 unsigned RegNo = 0;
927 if (!Val.consume_front(Prefix: "r") || Val.getAsInteger(Radix: 10, Result&: RegNo) || RegNo < 16 ||
928 RegNo > 27) {
929 getDriver().Diag(DiagID: diag::err_drv_invalid_value)
930 << A->getSpelling() << A->getValue();
931 } else {
932 CC1Args.push_back(Elt: "-target-feature");
933 CC1Args.push_back(Elt: DriverArgs.MakeArgString(Str: "+scs-reg-r" + Twine(RegNo)));
934 }
935 }
936
937 if (isAutoHVXEnabled(Args: DriverArgs)) {
938 CC1Args.push_back(Elt: "-mllvm");
939 CC1Args.push_back(Elt: "-hexagon-autohvx");
940 }
941
942 if (Arg *A = DriverArgs.getLastArg(Ids: options::OPT_fhlx_vector_stack_limit_EQ)) {
943 unsigned Limit;
944 if (!DriverArgs.hasFlag(Pos: options::OPT_mhexagon_hlx,
945 Neg: options::OPT_mno_hexagon_hlx, Default: false)) {
946 getDriver().Diag(DiagID: diag::err_drv_needs_hlx) << A->getSpelling();
947 } else if (StringRef(A->getValue()).getAsInteger(Radix: 10, Result&: Limit)) {
948 getDriver().Diag(DiagID: diag::err_drv_invalid_value)
949 << A->getAsString(Args: DriverArgs) << A->getValue();
950 } else {
951 CC1Args.push_back(
952 Elt: DriverArgs.MakeArgString(Str: "-fhlx-vector-stack-limit=" + Twine(Limit)));
953 }
954 }
955}
956
957void HexagonToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
958 ArgStringList &CC1Args) const {
959 if (DriverArgs.hasArg(Ids: options::OPT_nostdinc))
960 return;
961
962 const Driver &D = getDriver();
963 const bool UseBuiltins = !DriverArgs.hasArg(Ids: options::OPT_nobuiltininc);
964 if (UseBuiltins) {
965 SmallString<128> ResourceDirInclude(D.ResourceDir);
966 llvm::sys::path::append(path&: ResourceDirInclude, a: "include");
967 addSystemInclude(DriverArgs, CC1Args, Path: ResourceDirInclude);
968 }
969 if (!DriverArgs.hasArg(Ids: options::OPT_nostdlibinc)) {
970 SmallString<128> CIncludeDir;
971 getBaseIncludeDir(Args: DriverArgs, Dir&: CIncludeDir);
972 addExternCSystemInclude(DriverArgs, CC1Args, Path: std::string(CIncludeDir));
973 bool IsLinuxMusl = getTriple().isMusl() && getTriple().isOSLinux();
974 if (IsLinuxMusl) {
975 SmallString<128> LocalIncludeDir = getEffectiveSysRoot(Args: DriverArgs);
976 llvm::sys::path::append(path&: LocalIncludeDir, a: "usr", b: "local", c: "include");
977 addSystemInclude(DriverArgs, CC1Args, Path: LocalIncludeDir);
978 }
979 // TOOL_INCLUDE_DIR
980 AddMultilibIncludeArgs(DriverArgs, CC1Args);
981 }
982}
983
984void HexagonToolChain::addLibCxxIncludePaths(
985 const llvm::opt::ArgList &DriverArgs,
986 llvm::opt::ArgStringList &CC1Args) const {
987 SmallString<128> Dir;
988 getBaseIncludeDir(Args: DriverArgs, Dir);
989 llvm::sys::path::append(path&: Dir, a: "c++", b: "v1");
990 addLibStdCXXIncludePaths(IncludeDir: Dir, Triple: "", IncludeSuffix: "", DriverArgs, CC1Args);
991}
992
993void HexagonToolChain::addLibStdCxxIncludePaths(
994 const llvm::opt::ArgList &DriverArgs,
995 llvm::opt::ArgStringList &CC1Args) const {
996 SmallString<128> Dir;
997 getBaseIncludeDir(Args: DriverArgs, Dir);
998 llvm::sys::path::append(path&: Dir, a: "c++");
999 addLibStdCXXIncludePaths(IncludeDir: Dir, Triple: "", IncludeSuffix: "", DriverArgs, CC1Args);
1000}
1001
1002ToolChain::RuntimeLibType
1003HexagonToolChain::GetRuntimeLibType(const ArgList &Args) const {
1004 if (GetCStdlibType(Args) == ToolChain::CST_Picolibc) {
1005 if (Args.getLastArg(Ids: options::OPT_rtlib_EQ))
1006 return ToolChain::GetRuntimeLibType(Args);
1007 return ToolChain::RLT_CompilerRT;
1008 }
1009 return ToolChain::GetRuntimeLibType(Args);
1010}
1011
1012ToolChain::UnwindLibType
1013HexagonToolChain::GetUnwindLibType(const ArgList &Args) const {
1014 if (GetCStdlibType(Args) == ToolChain::CST_Picolibc) {
1015 if (Args.getLastArg(Ids: options::OPT_unwindlib_EQ))
1016 return ToolChain::GetUnwindLibType(Args);
1017 return ToolChain::UNW_CompilerRT;
1018 }
1019 return ToolChain::GetUnwindLibType(Args);
1020}
1021
1022ToolChain::CXXStdlibType
1023HexagonToolChain::GetCXXStdlibType(const ArgList &Args) const {
1024 Arg *A = Args.getLastArg(Ids: options::OPT_stdlib_EQ);
1025 if (!A) {
1026 if (getTriple().isMusl() || GetCStdlibType(Args) == ToolChain::CST_Picolibc)
1027 return ToolChain::CST_Libcxx;
1028 else
1029 return ToolChain::CST_Libstdcxx;
1030 }
1031 StringRef Value = A->getValue();
1032 if (Value != "libstdc++" && Value != "libc++")
1033 getDriver().Diag(DiagID: diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
1034
1035 if (Value == "libstdc++")
1036 return ToolChain::CST_Libstdcxx;
1037 else if (Value == "libc++")
1038 return ToolChain::CST_Libcxx;
1039 else
1040 return ToolChain::CST_Libstdcxx;
1041}
1042
1043bool HexagonToolChain::isAutoHVXEnabled(const llvm::opt::ArgList &Args) {
1044 if (Arg *A = Args.getLastArg(Ids: options::OPT_fvectorize,
1045 Ids: options::OPT_fno_vectorize))
1046 return A->getOption().matches(ID: options::OPT_fvectorize);
1047 return false;
1048}
1049
1050//
1051// Returns the default CPU for Hexagon. This is the default compilation target
1052// if no Hexagon processor is selected at the command-line.
1053//
1054StringRef HexagonToolChain::GetDefaultCPU() { return "hexagonv68"; }
1055
1056StringRef HexagonToolChain::GetTargetCPUVersion(const ArgList &Args) {
1057 Arg *CpuArg = nullptr;
1058 if (Arg *A = Args.getLastArg(Ids: options::OPT_mcpu_EQ))
1059 CpuArg = A;
1060
1061 StringRef CPU = CpuArg ? CpuArg->getValue() : GetDefaultCPU();
1062 CPU.consume_front(Prefix: "hexagon");
1063 return CPU;
1064}
1065
1066std::optional<std::string>
1067HexagonToolChain::GetHVXVersion(const ArgList &Args) {
1068 // Handle -mh[v]x= and -mno-hvx. If versioned and versionless flags
1069 // are both present, the last one wins.
1070 Arg *HvxEnablingArg =
1071 Args.getLastArg(Ids: options::OPT_mhexagon_hvx, Ids: options::OPT_mhexagon_hvx_EQ,
1072 Ids: options::OPT_mno_hexagon_hvx);
1073 if (!HvxEnablingArg ||
1074 HvxEnablingArg->getOption().matches(ID: options::OPT_mno_hexagon_hvx))
1075 return std::nullopt;
1076
1077 StringRef Cpu(toolchains::HexagonToolChain::GetTargetCPUVersion(Args));
1078 std::string HvxVer;
1079 if (!Cpu.empty() && (Cpu.back() == 'T' || Cpu.back() == 't'))
1080 HvxVer = Cpu.drop_back(N: 1).str();
1081 else
1082 HvxVer = Cpu.str();
1083
1084 if (HvxEnablingArg->getOption().matches(ID: options::OPT_mhexagon_hvx_EQ))
1085 HvxVer = StringRef(HvxEnablingArg->getValue()).lower();
1086
1087 return HvxVer;
1088}
1089
1090// End Hexagon
1091