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 if (HexagonToolChain::isAutoHVXEnabled(Args) && !HasHVX)
192 D.Diag(DiagID: diag::warn_drv_needs_hvx) << "auto-vectorization";
193}
194
195// Hexagon tools start.
196void hexagon::Assembler::RenderExtraToolArgs(const JobAction &JA,
197 ArgStringList &CmdArgs) const {
198}
199
200void hexagon::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
201 const InputInfo &Output,
202 const InputInfoList &Inputs,
203 const ArgList &Args,
204 const char *LinkingOutput) const {
205 claimNoWarnArgs(Args);
206
207 auto &HTC = static_cast<const toolchains::HexagonToolChain&>(getToolChain());
208 const Driver &D = HTC.getDriver();
209 ArgStringList CmdArgs;
210
211 CmdArgs.push_back(Elt: "--arch=hexagon");
212
213 RenderExtraToolArgs(JA, CmdArgs);
214
215 const char *AsName = "llvm-mc";
216 CmdArgs.push_back(Elt: "-filetype=obj");
217 CmdArgs.push_back(Elt: Args.MakeArgString(
218 Str: "-mcpu=hexagon" +
219 toolchains::HexagonToolChain::GetTargetCPUVersion(Args)));
220
221 if (std::get<0>(t: ParsePICArgs(ToolChain: HTC, Args)) == llvm::Reloc::PIC_)
222 CmdArgs.push_back(Elt: "-position-independent");
223
224 addSanitizerRuntimes(TC: HTC, Args, CmdArgs, C);
225
226 assert((Output.isFilename() || Output.isNothing()) && "Invalid output.");
227 if (Output.isFilename()) {
228 CmdArgs.push_back(Elt: "-o");
229 CmdArgs.push_back(Elt: Output.getFilename());
230 } else {
231 CmdArgs.push_back(Elt: "-fsyntax-only");
232 }
233
234 if (Arg *A = Args.getLastArg(Ids: options::OPT_mhexagon_hvx_ieee_fp,
235 Ids: options::OPT_mno_hexagon_hvx_ieee_fp)) {
236 if (A->getOption().matches(ID: options::OPT_mhexagon_hvx_ieee_fp))
237 CmdArgs.push_back(Elt: "-mhvx-ieee-fp");
238 }
239
240 if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) {
241 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-gpsize=" + Twine(*G)));
242 }
243
244 Args.AddAllArgValues(Output&: CmdArgs, Id0: options::OPT_Wa_COMMA, Id1: options::OPT_Xassembler);
245
246 // Only pass -x if gcc will understand it; otherwise hope gcc
247 // understands the suffix correctly. The main use case this would go
248 // wrong in is for linker inputs if they happened to have an odd
249 // suffix; really the only way to get this to happen is a command
250 // like '-x foobar a.c' which will treat a.c like a linker input.
251 //
252 // FIXME: For the linker case specifically, can we safely convert
253 // inputs into '-Wl,' options?
254 for (const auto &II : Inputs) {
255 // Don't try to pass LLVM or AST inputs to a generic gcc.
256 if (types::isLLVMIR(Id: II.getType()))
257 D.Diag(DiagID: clang::diag::err_drv_no_linker_llvm_support)
258 << HTC.getTripleString();
259 else if (II.getType() == types::TY_AST)
260 D.Diag(DiagID: clang::diag::err_drv_no_ast_support)
261 << HTC.getTripleString();
262 else if (II.getType() == types::TY_ModuleFile)
263 D.Diag(DiagID: diag::err_drv_no_module_support)
264 << HTC.getTripleString();
265
266 if (II.isFilename())
267 CmdArgs.push_back(Elt: II.getFilename());
268 else
269 // Don't render as input, we need gcc to do the translations.
270 // FIXME: What is this?
271 II.getInputArg().render(Args, Output&: CmdArgs);
272 }
273
274 auto *Exec = Args.MakeArgString(Str: HTC.GetProgramPath(Name: AsName));
275 C.addCommand(Cmd: std::make_unique<Command>(args: JA, args: *this,
276 args: ResponseFileSupport::AtFileCurCP(),
277 args&: Exec, args&: CmdArgs, args: Inputs, args: Output));
278}
279
280void hexagon::Linker::RenderExtraToolArgs(const JobAction &JA,
281 ArgStringList &CmdArgs) const {
282}
283
284static void
285constructHexagonLinkArgs(Compilation &C, const JobAction &JA,
286 const toolchains::HexagonToolChain &HTC,
287 const InputInfo &Output, const InputInfoList &Inputs,
288 const ArgList &Args, ArgStringList &CmdArgs,
289 const char *LinkingOutput) {
290
291 const Driver &D = HTC.getDriver();
292
293 //----------------------------------------------------------------------------
294 //
295 //----------------------------------------------------------------------------
296 bool IsStatic = Args.hasArg(Ids: options::OPT_static);
297 bool IsShared = Args.hasArg(Ids: options::OPT_shared);
298 bool IsPIE = Args.hasFlag(Pos: options::OPT_pie, Neg: options::OPT_no_pie,
299 Default: HTC.isPIEDefault(Args));
300 bool IncStdLib = !Args.hasArg(Ids: options::OPT_nostdlib);
301 bool IncStartFiles = !Args.hasArg(Ids: options::OPT_nostartfiles);
302 bool IncDefLibs = !Args.hasArg(Ids: options::OPT_nodefaultlibs);
303 bool UseLLD = false;
304 const char *Exec = Args.MakeArgString(Str: HTC.GetLinkerPath(LinkerIsLLD: &UseLLD));
305 UseLLD = UseLLD || llvm::sys::path::filename(path: Exec).ends_with(Suffix: "ld.lld") ||
306 llvm::sys::path::stem(path: Exec).ends_with(Suffix: "ld.lld");
307 bool UseShared = IsShared && !IsStatic;
308 StringRef CpuVer = toolchains::HexagonToolChain::GetTargetCPUVersion(Args);
309
310 bool NeedsSanitizerDeps = addSanitizerRuntimes(TC: HTC, Args, CmdArgs, C);
311 bool NeedsXRayDeps = addXRayRuntime(TC: HTC, Args, CmdArgs);
312
313 //----------------------------------------------------------------------------
314 // Silence warnings for various options
315 //----------------------------------------------------------------------------
316 Args.ClaimAllArgs(Id0: options::OPT_g_Group);
317 Args.ClaimAllArgs(Id0: options::OPT_emit_llvm);
318 Args.ClaimAllArgs(Id0: options::OPT_w); // Other warning options are already
319 // handled somewhere else.
320 Args.ClaimAllArgs(Id0: options::OPT_static_libgcc);
321
322 CmdArgs.push_back(Elt: "--eh-frame-hdr");
323 //----------------------------------------------------------------------------
324 //
325 //----------------------------------------------------------------------------
326 if (Args.hasArg(Ids: options::OPT_s))
327 CmdArgs.push_back(Elt: "-s");
328
329 if (Args.hasArg(Ids: options::OPT_r))
330 CmdArgs.push_back(Elt: "-r");
331
332 for (const auto &Opt : HTC.ExtraOpts)
333 CmdArgs.push_back(Elt: Opt.c_str());
334
335 if (!UseLLD) {
336 CmdArgs.push_back(Elt: "-march=hexagon");
337 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-mcpu=hexagon" + CpuVer));
338 }
339
340 if (IsShared) {
341 CmdArgs.push_back(Elt: "-shared");
342 // The following should be the default, but doing as hexagon-gcc does.
343 CmdArgs.push_back(Elt: "-call_shared");
344 }
345
346 if (IsStatic)
347 CmdArgs.push_back(Elt: "-static");
348
349 if (IsPIE && !IsShared && !Args.hasArg(Ids: options::OPT_r))
350 CmdArgs.push_back(Elt: "-pie");
351
352 if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args))
353 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-G" + Twine(*G)));
354
355 CmdArgs.push_back(Elt: "-o");
356 CmdArgs.push_back(Elt: Output.getFilename());
357
358 if (HTC.getTriple().isMusl()) {
359 if (!Args.hasArg(Ids: options::OPT_shared, Ids: options::OPT_static, Ids: options::OPT_r))
360 CmdArgs.push_back(Elt: "-dynamic-linker=/lib/ld-musl-hexagon.so.1");
361
362 StringRef MLSuffix;
363 if (!HTC.getSelectedMultilibs().empty() &&
364 !HTC.getSelectedMultilibs().back().isDefault())
365 MLSuffix = HTC.getSelectedMultilibs().back().gccSuffix();
366 auto StartFile = [&](StringRef Name) -> std::string {
367 return D.SysRoot + "/usr/lib" + MLSuffix.str() + "/" + Name.str();
368 };
369
370 if (!Args.hasArg(Ids: options::OPT_shared, Ids: options::OPT_nostartfiles,
371 Ids: options::OPT_nostdlib, Ids: options::OPT_r)) {
372 if (IsStatic && IsPIE)
373 CmdArgs.push_back(Elt: Args.MakeArgString(Str: StartFile("rcrt1.o")));
374 else
375 CmdArgs.push_back(Elt: Args.MakeArgString(Str: StartFile("crt1.o")));
376 } else if (Args.hasArg(Ids: options::OPT_shared) &&
377 !Args.hasArg(Ids: options::OPT_nostartfiles, Ids: options::OPT_nostdlib,
378 Ids: options::OPT_r))
379 CmdArgs.push_back(Elt: Args.MakeArgString(Str: StartFile("crti.o")));
380
381 if (!MLSuffix.empty()) {
382 CmdArgs.push_back(Elt: Args.MakeArgString(Str: StringRef("-L") + D.SysRoot +
383 "/usr/lib" + MLSuffix));
384 }
385 CmdArgs.push_back(
386 Elt: Args.MakeArgString(Str: StringRef("-L") + D.SysRoot + "/usr/lib"));
387 Args.addAllArgs(Output&: CmdArgs, Ids: {options::OPT_T_Group, options::OPT_s,
388 options::OPT_t, options::OPT_u_Group});
389 AddLinkerInputs(TC: HTC, Inputs, Args, CmdArgs, JA);
390
391 if (auto LTO = HTC.getLTOMode(Args); LTO != LTOK_None)
392 addLTOOptions(ToolChain: HTC, Args, CmdArgs, Output, Inputs, IsThinLTO: LTO == LTOK_Thin);
393
394 ToolChain::UnwindLibType UNW = HTC.GetUnwindLibType(Args);
395
396 if (!Args.hasArg(Ids: options::OPT_nostdlib, Ids: options::OPT_nodefaultlibs)) {
397 if (NeedsSanitizerDeps) {
398 linkSanitizerRuntimeDeps(TC: HTC, Args, CmdArgs);
399
400 if (UNW != ToolChain::UNW_None)
401 CmdArgs.push_back(Elt: "-lunwind");
402 }
403 if (NeedsXRayDeps)
404 linkXRayRuntimeDeps(TC: HTC, Args, CmdArgs);
405
406 if (!Args.hasArg(Ids: options::OPT_nolibc))
407 CmdArgs.push_back(Elt: "-lc");
408 CmdArgs.push_back(Elt: "-lclang_rt.builtins-hexagon");
409 }
410 if (D.CCCIsCXX()) {
411 if (HTC.ShouldLinkCXXStdlib(Args))
412 HTC.AddCXXStdlibLibArgs(Args, CmdArgs);
413 }
414 const ToolChain::path_list &LibPaths = HTC.getFilePaths();
415 for (const auto &LibPath : LibPaths)
416 CmdArgs.push_back(Elt: Args.MakeArgString(Str: StringRef("-L") + LibPath));
417 Args.ClaimAllArgs(Id0: options::OPT_L);
418 return;
419 }
420
421 //----------------------------------------------------------------------------
422 // moslib
423 //----------------------------------------------------------------------------
424 std::vector<std::string> OsLibs;
425 bool HasStandalone = false;
426 for (const Arg *A : Args.filtered(Ids: options::OPT_moslib_EQ)) {
427 A->claim();
428 OsLibs.emplace_back(args: A->getValue());
429 HasStandalone = HasStandalone || (OsLibs.back() == "standalone");
430 }
431 if (OsLibs.empty()) {
432 OsLibs.push_back(x: "standalone");
433 HasStandalone = true;
434 }
435
436 //----------------------------------------------------------------------------
437 // Start Files
438 //----------------------------------------------------------------------------
439 SmallString<128> LibraryDir;
440 HTC.getLibraryDir(Args, LibraryDir);
441
442 if (IncStdLib && IncStartFiles) {
443 if (HTC.GetCStdlibType(Args) == ToolChain::CST_Picolibc) {
444 SmallString<128> Crt0 = LibraryDir;
445 if (HTC.getTriple().isOSH2()) {
446 llvm::sys::path::append(path&: Crt0, a: "crt0-noflash-hosted.o");
447 CmdArgs.push_back(Elt: Args.MakeArgString(Str: Crt0));
448 } else if (HTC.getTriple().isOSUnknown()) {
449 llvm::sys::path::append(path&: Crt0, a: "crt0-semihost.o");
450 CmdArgs.push_back(Elt: Args.MakeArgString(Str: Crt0));
451 } else if (HTC.getTriple().isOSQurt()) {
452 // QURT provides its own crt0.
453 }
454 // Known OS other than H2/QURT: no semihost crt0; OS provides its own.
455 } else {
456 if (!IsShared) {
457 if (HasStandalone) {
458 SmallString<128> Crt0SA = LibraryDir;
459 llvm::sys::path::append(path&: Crt0SA, a: "crt0_standalone.o");
460 CmdArgs.push_back(Elt: Args.MakeArgString(Str: Crt0SA));
461 }
462 SmallString<128> Crt0 = LibraryDir;
463 llvm::sys::path::append(path&: Crt0, a: "crt0.o");
464 CmdArgs.push_back(Elt: Args.MakeArgString(Str: Crt0));
465 }
466 }
467 if (HTC.GetCStdlibType(Args) != ToolChain::CST_Picolibc) {
468 SmallString<128> Init = LibraryDir;
469 llvm::sys::path::append(path&: Init, a: UseShared ? "initS.o" : "init.o");
470 CmdArgs.push_back(Elt: Args.MakeArgString(Str: Init));
471 }
472 }
473
474 //----------------------------------------------------------------------------
475 // Library Search Paths
476 //----------------------------------------------------------------------------
477 const ToolChain::path_list &LibPaths = HTC.getFilePaths();
478 for (const auto &LibPath : LibPaths)
479 CmdArgs.push_back(Elt: Args.MakeArgString(Str: StringRef("-L") + LibPath));
480 Args.ClaimAllArgs(Id0: options::OPT_L);
481
482 //----------------------------------------------------------------------------
483 //
484 //----------------------------------------------------------------------------
485 Args.addAllArgs(Output&: CmdArgs, Ids: {options::OPT_T_Group, options::OPT_s,
486 options::OPT_t, options::OPT_u_Group});
487
488 AddLinkerInputs(TC: HTC, Inputs, Args, CmdArgs, JA);
489
490 if (auto LTO = HTC.getLTOMode(Args); LTO != LTOK_None)
491 addLTOOptions(ToolChain: HTC, Args, CmdArgs, Output, Inputs, IsThinLTO: LTO == LTOK_Thin);
492
493 //----------------------------------------------------------------------------
494 // Libraries
495 //----------------------------------------------------------------------------
496 if (IncStdLib && IncDefLibs) {
497 if (D.CCCIsCXX()) {
498 if (HTC.ShouldLinkCXXStdlib(Args))
499 HTC.AddCXXStdlibLibArgs(Args, CmdArgs);
500 CmdArgs.push_back(Elt: "-lm");
501 }
502
503 CmdArgs.push_back(Elt: "--start-group");
504
505 if (!IsShared) {
506 if (HTC.GetCStdlibType(Args) == ToolChain::CST_Picolibc) {
507 if (HTC.getTriple().isOSH2()) {
508 CmdArgs.push_back(Elt: "-lh2");
509 CmdArgs.push_back(Elt: "-lsyscall_wrapper");
510 } else if (HTC.getTriple().isOSUnknown()) {
511 CmdArgs.push_back(Elt: "-lsemihost");
512 }
513 // Known OS other than H2: no semihost lib; OS provides its own.
514 } else {
515 for (StringRef Lib : OsLibs)
516 CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-l" + Lib));
517 }
518 if (!Args.hasArg(Ids: options::OPT_nolibc))
519 CmdArgs.push_back(Elt: "-lc");
520 }
521 if (HTC.GetCStdlibType(Args) == ToolChain::CST_Picolibc) {
522 if (HTC.GetRuntimeLibType(Args) == ToolChain::RLT_CompilerRT)
523 CmdArgs.push_back(Elt: "-lclang_rt.builtins");
524 else
525 CmdArgs.push_back(Elt: "-lgcc");
526 } else {
527 CmdArgs.push_back(Elt: "-lgcc");
528 }
529
530 CmdArgs.push_back(Elt: "--end-group");
531 }
532
533 //----------------------------------------------------------------------------
534 // End files
535 //----------------------------------------------------------------------------
536 if (IncStdLib && IncStartFiles) {
537 if (HTC.GetCStdlibType(Args) != ToolChain::CST_Picolibc) {
538 SmallString<128> Fini = LibraryDir;
539 llvm::sys::path::append(path&: Fini, a: UseShared ? "finiS.o" : "fini.o");
540 CmdArgs.push_back(Elt: Args.MakeArgString(Str: Fini));
541 }
542 }
543}
544
545void hexagon::Linker::ConstructJob(Compilation &C, const JobAction &JA,
546 const InputInfo &Output,
547 const InputInfoList &Inputs,
548 const ArgList &Args,
549 const char *LinkingOutput) const {
550 auto &HTC = static_cast<const toolchains::HexagonToolChain&>(getToolChain());
551
552 ArgStringList CmdArgs;
553 constructHexagonLinkArgs(C, JA, HTC, Output, Inputs, Args, CmdArgs,
554 LinkingOutput);
555
556 const char *Exec = Args.MakeArgString(Str: HTC.GetLinkerPath());
557 C.addCommand(Cmd: std::make_unique<Command>(args: JA, args: *this,
558 args: ResponseFileSupport::AtFileCurCP(),
559 args&: Exec, args&: CmdArgs, args: Inputs, args: Output));
560}
561// Hexagon tools end.
562
563/// Hexagon Toolchain
564
565std::string HexagonToolChain::getHexagonTargetDir(
566 const std::string &InstalledDir,
567 const SmallVectorImpl<std::string> &PrefixDirs) const {
568 const Driver &D = getDriver();
569
570 // Locate the rest of the toolchain ...
571 for (auto &I : PrefixDirs)
572 if (D.getVFS().exists(Path: I))
573 return I;
574
575 SmallString<128> Dir(InstalledDir);
576 llvm::sys::path::append(path&: Dir, a: "..", b: "target");
577 return std::string(Dir);
578}
579
580SmallString<128>
581HexagonToolChain::getEffectiveSysRoot(const ArgList &Args) const {
582 const Driver &D = getDriver();
583 // The user-specified `--sysroot` always takes precedence.
584 if (!D.SysRoot.empty())
585 return SmallString<128>(D.SysRoot);
586 SmallString<128> Dir(getHexagonTargetDir(InstalledDir: D.Dir, PrefixDirs: D.PrefixDirs));
587 // For Picolibc, use picolibc/<triple> with no fallback.
588 if (GetCStdlibType(Args) == ToolChain::CST_Picolibc) {
589 llvm::sys::path::append(path&: Dir, a: "picolibc", b: getTripleString());
590 return Dir;
591 }
592 // Otherwise, try a triple subdirectory first, then fall back to "hexagon".
593 llvm::sys::path::append(path&: Dir, a: getTripleString());
594 if (getVFS().exists(Path: Dir))
595 return Dir;
596 Dir = getHexagonTargetDir(InstalledDir: D.Dir, PrefixDirs: D.PrefixDirs);
597 llvm::sys::path::append(path&: Dir, a: "hexagon");
598 return Dir;
599}
600
601void HexagonToolChain::getLibraryDir(const ArgList &Args,
602 llvm::SmallString<128> &Dir) const {
603 bool IsLinuxMusl = getTriple().isMusl() && getTriple().isOSLinux();
604 const llvm::SmallString<128> SysRoot = getEffectiveSysRoot(Args);
605 // Linux toolchain uses "usr/lib" but it also should accept "lib" in case an
606 // external sysroot is used. Similar logic is for include paths.
607 if (IsLinuxMusl) {
608 Dir = SysRoot;
609 llvm::sys::path::append(path&: Dir, a: "usr", b: "lib");
610 }
611 if (!IsLinuxMusl || !getVFS().exists(Path: Dir)) {
612 Dir = SysRoot;
613 llvm::sys::path::append(path&: Dir, a: "lib");
614 }
615 std::string CpuVer = GetTargetCPUVersion(Args).str();
616 bool IsPicolibc = GetCStdlibType(Args) == ToolChain::CST_Picolibc;
617 bool IsG0 =
618 toolchains::HexagonToolChain::getSmallDataThreshold(Args).value_or(u: 1) ==
619 0;
620 bool IsStatic = Args.hasArg(Ids: options::OPT_static);
621 bool IsShared = Args.hasArg(Ids: options::OPT_shared);
622 bool IsPic = Args.hasArg(Ids: options::OPT_fpic, Ids: options::OPT_fPIC);
623 if (IsPicolibc) {
624 // Flat layout: lib/v68-G0-pic, lib/v68-G0, lib/v68
625 std::string Variant = CpuVer;
626 if (IsG0)
627 Variant += "-G0";
628 if (IsPic || IsShared)
629 Variant += "-pic";
630 llvm::sys::path::append(path&: Dir, a: Variant);
631 } else {
632 // Nested layout (non-Picolibc): lib/v68/G0/pic
633 llvm::sys::path::append(path&: Dir, a: CpuVer);
634 if (IsG0)
635 llvm::sys::path::append(path&: Dir, a: "G0");
636 if (IsShared && !IsStatic)
637 llvm::sys::path::append(path&: Dir, a: "pic");
638 }
639}
640
641void HexagonToolChain::getBaseIncludeDir(const ArgList &Args,
642 llvm::SmallString<128> &Dir) const {
643 bool IsLinuxMusl = getTriple().isMusl() && getTriple().isOSLinux();
644 const llvm::SmallString<128> SysRoot = getEffectiveSysRoot(Args);
645 if (IsLinuxMusl) {
646 Dir = SysRoot;
647 llvm::sys::path::append(path&: Dir, a: "usr", b: "include");
648 }
649 if (!IsLinuxMusl || !getVFS().exists(Path: Dir)) {
650 Dir = SysRoot;
651 llvm::sys::path::append(path&: Dir, a: "include");
652 }
653}
654
655std::optional<unsigned>
656HexagonToolChain::getSmallDataThreshold(const ArgList &Args) {
657 StringRef Gn = "";
658 if (Arg *A = Args.getLastArg(Ids: options::OPT_G)) {
659 Gn = A->getValue();
660 } else if (Args.getLastArg(Ids: options::OPT_shared, Ids: options::OPT_fpic,
661 Ids: options::OPT_fPIC)) {
662 Gn = "0";
663 }
664
665 unsigned G;
666 if (!Gn.getAsInteger(Radix: 10, Result&: G))
667 return G;
668
669 return std::nullopt;
670}
671
672std::string HexagonToolChain::getCompilerRTPath() const {
673 SmallString<128> Dir(getDriver().SysRoot);
674 llvm::sys::path::append(path&: Dir, a: "usr", b: "lib");
675 if (!SelectedMultilibs.empty()) {
676 Dir += SelectedMultilibs.back().gccSuffix();
677 }
678 return std::string(Dir);
679}
680
681void HexagonToolChain::getHexagonLibraryPaths(const ArgList &Args,
682 ToolChain::path_list &LibPaths) const {
683 const Driver &D = getDriver();
684
685 //----------------------------------------------------------------------------
686 // -L Args
687 //----------------------------------------------------------------------------
688 for (Arg *A : Args.filtered(Ids: options::OPT_L))
689 llvm::append_range(C&: LibPaths, R&: A->getValues());
690
691 //----------------------------------------------------------------------------
692 // Other standard paths
693 //----------------------------------------------------------------------------
694 std::vector<std::string> RootDirs;
695 std::copy(first: D.PrefixDirs.begin(), last: D.PrefixDirs.end(),
696 result: std::back_inserter(x&: RootDirs));
697
698 std::string SysRoot(getEffectiveSysRoot(Args));
699 if (!llvm::is_contained(Range&: RootDirs, Element: SysRoot))
700 RootDirs.push_back(x: SysRoot);
701
702 bool HasPIC = Args.hasArg(Ids: options::OPT_fpic, Ids: options::OPT_fPIC);
703 // Assume G0 with -shared.
704 bool HasG0 = Args.hasArg(Ids: options::OPT_shared);
705 if (auto G = getSmallDataThreshold(Args))
706 HasG0 = *G == 0;
707
708 bool IsPicolibc = GetCStdlibType(Args) == ToolChain::CST_Picolibc;
709 const std::string CpuVer = GetTargetCPUVersion(Args).str();
710 for (auto &Dir : RootDirs) {
711 std::string LibDir = Dir + "/lib";
712 std::string LibDirCpu = LibDir + '/' + CpuVer;
713 if (IsPicolibc) {
714 // Flat layout: push only the single most-specific variant dir, then lib.
715 // Base case (no G0/pic): lib/v68, lib.
716 // -shared also implies -pic for Picolibc library search paths.
717 bool HasPICOrShared = HasPIC || Args.hasArg(Ids: options::OPT_shared);
718 if (HasG0) {
719 std::string Variant = CpuVer + "-G0";
720 if (HasPICOrShared)
721 Variant += "-pic";
722 LibPaths.push_back(Elt: LibDir + "/" + Variant);
723 } else {
724 LibPaths.push_back(Elt: LibDirCpu);
725 }
726 } else {
727 // Nested layout (non-Picolibc): lib/v68/G0/pic, lib/v68/G0
728 if (HasG0) {
729 if (HasPIC)
730 LibPaths.push_back(Elt: LibDirCpu + "/G0/pic");
731 LibPaths.push_back(Elt: LibDirCpu + "/G0");
732 }
733 LibPaths.push_back(Elt: LibDirCpu);
734 }
735 LibPaths.push_back(Elt: LibDir);
736 }
737}
738
739HexagonToolChain::HexagonToolChain(const Driver &D, const llvm::Triple &Triple,
740 const llvm::opt::ArgList &Args)
741 : Linux(D, Triple, Args) {
742 ToolChain::path_list &LibPaths = getFilePaths();
743
744 // Remove paths added by Linux toolchain. Currently Hexagon_TC really targets
745 // 'elf' OS type, so the Linux paths are not appropriate. When we actually
746 // support 'linux' we'll need to fix this up
747 LibPaths.clear();
748 getHexagonLibraryPaths(Args, LibPaths);
749
750 if (getTriple().isMusl()) {
751 Multilibs.push_back(M: Multilib());
752 Multilibs.push_back(M: MultilibBuilder("msan", {}, {})
753 .flag(Flag: "-fsanitize=memory")
754 .makeMultilib());
755 Multilibs.push_back(M: MultilibBuilder("asan", {}, {})
756 .flag(Flag: "-fsanitize=address")
757 .makeMultilib());
758 Multilibs.push_back(M: MultilibBuilder("scs", {}, {})
759 .flag(Flag: "-fsanitize=shadow-call-stack")
760 .makeMultilib());
761
762 Multilib::flags_list Flags;
763 addMultilibFlag(Enabled: getSanitizerArgs(JobArgs: Args).needsMsanRt(), Flag: "-fsanitize=memory",
764 Flags);
765 addMultilibFlag(Enabled: getSanitizerArgs(JobArgs: Args).needsAsanRt(), Flag: "-fsanitize=address",
766 Flags);
767 addMultilibFlag(Enabled: getSanitizerArgs(JobArgs: Args).hasShadowCallStack(),
768 Flag: "-fsanitize=shadow-call-stack", Flags);
769
770 if (Multilibs.select(D, Flags, SelectedMultilibs)) {
771 Multilib LastSelected = SelectedMultilibs.back();
772 SelectedMultilibs = {LastSelected};
773
774 if (!SelectedMultilibs.back().isDefault()) {
775 SmallString<128> SanLibPath(D.SysRoot);
776 llvm::sys::path::append(path&: SanLibPath, a: "usr", b: "lib");
777 SanLibPath += SelectedMultilibs.back().gccSuffix();
778 LibPaths.insert(I: LibPaths.begin(), Elt: std::string(SanLibPath));
779 }
780 }
781 }
782}
783
784HexagonToolChain::~HexagonToolChain() {}
785
786void HexagonToolChain::AddCXXStdlibLibArgs(const ArgList &Args,
787 ArgStringList &CmdArgs) const {
788 CXXStdlibType Type = GetCXXStdlibType(Args);
789 ToolChain::UnwindLibType UNW = GetUnwindLibType(Args);
790 if (UNW != ToolChain::UNW_None && UNW != ToolChain::UNW_CompilerRT) {
791 const Arg *A = Args.getLastArg(Ids: options::OPT_unwindlib_EQ);
792 if (A) {
793 getDriver().Diag(DiagID: diag::err_drv_unsupported_unwind_for_platform)
794 << A->getValue() << getTripleString();
795 return;
796 }
797 }
798
799 switch (Type) {
800 case ToolChain::CST_Libcxx:
801 CmdArgs.push_back(Elt: "-lc++");
802 if (Args.hasArg(Ids: options::OPT_fexperimental_library))
803 CmdArgs.push_back(Elt: "-lc++experimental");
804 CmdArgs.push_back(Elt: "-lc++abi");
805 if (UNW != ToolChain::UNW_None)
806 CmdArgs.push_back(Elt: "-lunwind");
807 break;
808
809 case ToolChain::CST_Libstdcxx:
810 CmdArgs.push_back(Elt: "-lstdc++");
811 break;
812 }
813}
814
815Tool *HexagonToolChain::buildAssembler() const {
816 return new tools::hexagon::Assembler(*this);
817}
818
819Tool *HexagonToolChain::buildLinker() const {
820 return new tools::hexagon::Linker(*this);
821}
822
823unsigned HexagonToolChain::getOptimizationLevel(
824 const llvm::opt::ArgList &DriverArgs) const {
825 // Copied in large part from lib/Frontend/CompilerInvocation.cpp.
826 Arg *A = DriverArgs.getLastArg(Ids: options::OPT_O_Group);
827 if (!A)
828 return 0;
829
830 if (A->getOption().matches(ID: options::OPT_O0))
831 return 0;
832 if (A->getOption().matches(ID: options::OPT_Ofast) ||
833 A->getOption().matches(ID: options::OPT_O4))
834 return 3;
835 assert(A->getNumValues() != 0);
836 StringRef S(A->getValue());
837 if (S == "s" || S == "z" || S.empty())
838 return 2;
839 if (S == "g")
840 return 1;
841
842 unsigned OptLevel;
843 if (S.getAsInteger(Radix: 10, Result&: OptLevel))
844 return 0;
845 return OptLevel;
846}
847
848void HexagonToolChain::addClangTargetOptions(const ArgList &DriverArgs,
849 ArgStringList &CC1Args,
850 BoundArch BA,
851 Action::OffloadKind) const {
852
853 bool UseInitArrayDefault =
854 getTriple().isMusl() ||
855 GetCStdlibType(Args: DriverArgs) == ToolChain::CST_Picolibc;
856
857 if (!DriverArgs.hasFlag(Pos: options::OPT_fuse_init_array,
858 Neg: options::OPT_fno_use_init_array,
859 Default: UseInitArrayDefault))
860 CC1Args.push_back(Elt: "-fno-use-init-array");
861
862 // The bool marks caller-saved (scratch) registers in the Hexagon ABI.
863 // Reserving those only behaves correctly if every other translation unit and
864 // library reserves them too, so we warn when the user does so.
865 static const std::tuple<options::ID, const char *, bool> FixedRegs[] = {
866 {options::OPT_ffixed_r6, "+reserved-r6", true},
867 {options::OPT_ffixed_r7, "+reserved-r7", true},
868 {options::OPT_ffixed_r8, "+reserved-r8", true},
869 {options::OPT_ffixed_r9, "+reserved-r9", true},
870 {options::OPT_ffixed_r10, "+reserved-r10", true},
871 {options::OPT_ffixed_r11, "+reserved-r11", true},
872 {options::OPT_ffixed_r12, "+reserved-r12", true},
873 {options::OPT_ffixed_r13, "+reserved-r13", true},
874 {options::OPT_ffixed_r14, "+reserved-r14", true},
875 {options::OPT_ffixed_r15, "+reserved-r15", true},
876 {options::OPT_ffixed_r16, "+reserved-r16", false},
877 {options::OPT_ffixed_r17, "+reserved-r17", false},
878 {options::OPT_ffixed_r18, "+reserved-r18", false},
879 {options::OPT_ffixed_r19, "+reserved-r19", false},
880 {options::OPT_ffixed_r20, "+reserved-r20", false},
881 {options::OPT_ffixed_r21, "+reserved-r21", false},
882 {options::OPT_ffixed_r22, "+reserved-r22", false},
883 {options::OPT_ffixed_r23, "+reserved-r23", false},
884 {options::OPT_ffixed_r24, "+reserved-r24", false},
885 {options::OPT_ffixed_r25, "+reserved-r25", false},
886 {options::OPT_ffixed_r26, "+reserved-r26", false},
887 {options::OPT_ffixed_r27, "+reserved-r27", false},
888 {options::OPT_ffixed_r28, "+reserved-r28", false},
889 };
890 for (const auto &[Opt, Feature, IsCallerSaved] : FixedRegs) {
891 if (Arg *A = DriverArgs.getLastArg(Ids: Opt)) {
892 if (IsCallerSaved)
893 getDriver().Diag(DiagID: diag::warn_drv_hexagon_reserved_caller_saved_reg)
894 << A->getOption().getName();
895 CC1Args.push_back(Elt: "-target-feature");
896 CC1Args.push_back(Elt: Feature);
897 }
898 }
899
900 // Select the shadow call stack pointer register. It has to hold a value
901 // across arbitrary calls, so only the callee-saved registers r16-r27 are
902 // allowed (Hexagon ABI, "Register usage across calls").
903 if (Arg *A = DriverArgs.getLastArg(Ids: options::OPT_mhexagon_scs_reg)) {
904 StringRef Val(A->getValue());
905 unsigned RegNo = 0;
906 if (!Val.consume_front(Prefix: "r") || Val.getAsInteger(Radix: 10, Result&: RegNo) || RegNo < 16 ||
907 RegNo > 27) {
908 getDriver().Diag(DiagID: diag::err_drv_invalid_value)
909 << A->getSpelling() << A->getValue();
910 } else {
911 CC1Args.push_back(Elt: "-target-feature");
912 CC1Args.push_back(Elt: DriverArgs.MakeArgString(Str: "+scs-reg-r" + Twine(RegNo)));
913 }
914 }
915
916 if (isAutoHVXEnabled(Args: DriverArgs)) {
917 CC1Args.push_back(Elt: "-mllvm");
918 CC1Args.push_back(Elt: "-hexagon-autohvx");
919 }
920}
921
922void HexagonToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
923 ArgStringList &CC1Args) const {
924 if (DriverArgs.hasArg(Ids: options::OPT_nostdinc))
925 return;
926
927 const Driver &D = getDriver();
928 const bool UseBuiltins = !DriverArgs.hasArg(Ids: options::OPT_nobuiltininc);
929 if (UseBuiltins) {
930 SmallString<128> ResourceDirInclude(D.ResourceDir);
931 llvm::sys::path::append(path&: ResourceDirInclude, a: "include");
932 addSystemInclude(DriverArgs, CC1Args, Path: ResourceDirInclude);
933 }
934 if (!DriverArgs.hasArg(Ids: options::OPT_nostdlibinc)) {
935 SmallString<128> CIncludeDir;
936 getBaseIncludeDir(Args: DriverArgs, Dir&: CIncludeDir);
937 addExternCSystemInclude(DriverArgs, CC1Args, Path: std::string(CIncludeDir));
938 bool IsLinuxMusl = getTriple().isMusl() && getTriple().isOSLinux();
939 if (IsLinuxMusl) {
940 SmallString<128> LocalIncludeDir = getEffectiveSysRoot(Args: DriverArgs);
941 llvm::sys::path::append(path&: LocalIncludeDir, a: "usr", b: "local", c: "include");
942 addSystemInclude(DriverArgs, CC1Args, Path: LocalIncludeDir);
943 }
944 // TOOL_INCLUDE_DIR
945 AddMultilibIncludeArgs(DriverArgs, CC1Args);
946 }
947}
948
949void HexagonToolChain::addLibCxxIncludePaths(
950 const llvm::opt::ArgList &DriverArgs,
951 llvm::opt::ArgStringList &CC1Args) const {
952 SmallString<128> Dir;
953 getBaseIncludeDir(Args: DriverArgs, Dir);
954 llvm::sys::path::append(path&: Dir, a: "c++", b: "v1");
955 addLibStdCXXIncludePaths(IncludeDir: Dir, Triple: "", IncludeSuffix: "", DriverArgs, CC1Args);
956}
957
958void HexagonToolChain::addLibStdCxxIncludePaths(
959 const llvm::opt::ArgList &DriverArgs,
960 llvm::opt::ArgStringList &CC1Args) const {
961 SmallString<128> Dir;
962 getBaseIncludeDir(Args: DriverArgs, Dir);
963 llvm::sys::path::append(path&: Dir, a: "c++");
964 addLibStdCXXIncludePaths(IncludeDir: Dir, Triple: "", IncludeSuffix: "", DriverArgs, CC1Args);
965}
966
967ToolChain::RuntimeLibType
968HexagonToolChain::GetRuntimeLibType(const ArgList &Args) const {
969 if (GetCStdlibType(Args) == ToolChain::CST_Picolibc) {
970 if (Args.getLastArg(Ids: options::OPT_rtlib_EQ))
971 return ToolChain::GetRuntimeLibType(Args);
972 return ToolChain::RLT_CompilerRT;
973 }
974 return ToolChain::GetRuntimeLibType(Args);
975}
976
977ToolChain::UnwindLibType
978HexagonToolChain::GetUnwindLibType(const ArgList &Args) const {
979 if (GetCStdlibType(Args) == ToolChain::CST_Picolibc) {
980 if (Args.getLastArg(Ids: options::OPT_unwindlib_EQ))
981 return ToolChain::GetUnwindLibType(Args);
982 return ToolChain::UNW_CompilerRT;
983 }
984 return ToolChain::GetUnwindLibType(Args);
985}
986
987ToolChain::CXXStdlibType
988HexagonToolChain::GetCXXStdlibType(const ArgList &Args) const {
989 Arg *A = Args.getLastArg(Ids: options::OPT_stdlib_EQ);
990 if (!A) {
991 if (getTriple().isMusl() || GetCStdlibType(Args) == ToolChain::CST_Picolibc)
992 return ToolChain::CST_Libcxx;
993 else
994 return ToolChain::CST_Libstdcxx;
995 }
996 StringRef Value = A->getValue();
997 if (Value != "libstdc++" && Value != "libc++")
998 getDriver().Diag(DiagID: diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
999
1000 if (Value == "libstdc++")
1001 return ToolChain::CST_Libstdcxx;
1002 else if (Value == "libc++")
1003 return ToolChain::CST_Libcxx;
1004 else
1005 return ToolChain::CST_Libstdcxx;
1006}
1007
1008bool HexagonToolChain::isAutoHVXEnabled(const llvm::opt::ArgList &Args) {
1009 if (Arg *A = Args.getLastArg(Ids: options::OPT_fvectorize,
1010 Ids: options::OPT_fno_vectorize))
1011 return A->getOption().matches(ID: options::OPT_fvectorize);
1012 return false;
1013}
1014
1015//
1016// Returns the default CPU for Hexagon. This is the default compilation target
1017// if no Hexagon processor is selected at the command-line.
1018//
1019StringRef HexagonToolChain::GetDefaultCPU() { return "hexagonv68"; }
1020
1021StringRef HexagonToolChain::GetTargetCPUVersion(const ArgList &Args) {
1022 Arg *CpuArg = nullptr;
1023 if (Arg *A = Args.getLastArg(Ids: options::OPT_mcpu_EQ))
1024 CpuArg = A;
1025
1026 StringRef CPU = CpuArg ? CpuArg->getValue() : GetDefaultCPU();
1027 CPU.consume_front(Prefix: "hexagon");
1028 return CPU;
1029}
1030
1031std::optional<std::string>
1032HexagonToolChain::GetHVXVersion(const ArgList &Args) {
1033 // Handle -mh[v]x= and -mno-hvx. If versioned and versionless flags
1034 // are both present, the last one wins.
1035 Arg *HvxEnablingArg =
1036 Args.getLastArg(Ids: options::OPT_mhexagon_hvx, Ids: options::OPT_mhexagon_hvx_EQ,
1037 Ids: options::OPT_mno_hexagon_hvx);
1038 if (!HvxEnablingArg ||
1039 HvxEnablingArg->getOption().matches(ID: options::OPT_mno_hexagon_hvx))
1040 return std::nullopt;
1041
1042 StringRef Cpu(toolchains::HexagonToolChain::GetTargetCPUVersion(Args));
1043 std::string HvxVer;
1044 if (!Cpu.empty() && (Cpu.back() == 'T' || Cpu.back() == 't'))
1045 HvxVer = Cpu.drop_back(N: 1).str();
1046 else
1047 HvxVer = Cpu.str();
1048
1049 if (HvxEnablingArg->getOption().matches(ID: options::OPT_mhexagon_hvx_EQ))
1050 HvxVer = StringRef(HvxEnablingArg->getValue()).lower();
1051
1052 return HvxVer;
1053}
1054
1055// End Hexagon
1056