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