clang 10.0.0git

Hexagon.cpp
Go to the documentation of this file.
1 //===--- Hexagon.cpp - Hexagon ToolChain Implementations --------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "Hexagon.h"
10 #include "CommonArgs.h"
11 #include "InputInfo.h"
12 #include "clang/Driver/Compilation.h"
13 #include "clang/Driver/Driver.h"
14 #include "clang/Driver/DriverDiagnostic.h"
15 #include "clang/Driver/Options.h"
16 #include "llvm/ADT/StringExtras.h"
17 #include "llvm/Option/ArgList.h"
18 #include "llvm/Support/FileSystem.h"
19 #include "llvm/Support/Path.h"
20 #include "llvm/Support/VirtualFileSystem.h"
21
22 using namespace clang::driver;
23 using namespace clang::driver::tools;
24 using namespace clang::driver::toolchains;
25 using namespace clang;
26 using namespace llvm::opt;
27
28 // Default hvx-length for various versions.
29 static StringRef getDefaultHvxLength(StringRef Cpu) {
30 return llvm::StringSwitch<StringRef>(Cpu)
31 .Case("v60", "64b")
32 .Case("v62", "64b")
33 .Case("v65", "64b")
34 .Case("v66", "128b")
35 .Default("128b");
36 }
37
38 static void handleHVXWarnings(const Driver &D, const ArgList &Args) {
39 // Handle the unsupported values passed to mhvx-length.
40 if (Arg *A = Args.getLastArg(options::OPT_mhexagon_hvx_length_EQ)) {
41 StringRef Val = A->getValue();
42 if (!Val.equals_lower("64b") && !Val.equals_lower("128b"))
43 D.Diag(diag::err_drv_unsupported_option_argument)
44 << A->getOption().getName() << Val;
45 }
46 }
47
48 // Handle hvx target features explicitly.
49 static void handleHVXTargetFeatures(const Driver &D, const ArgList &Args,
50 std::vector<StringRef> &Features,
51 bool &HasHVX) {
52 // Handle HVX warnings.
53 handleHVXWarnings(D, Args);
54
55 // Add the +hvx* features based on commandline flags.
56 StringRef HVXFeature, HVXLength;
57 StringRef Cpu(toolchains::HexagonToolChain::GetTargetCPUVersion(Args));
58
59 // Handle -mhvx, -mhvx=, -mno-hvx.
60 if (Arg *A = Args.getLastArg(options::OPT_mno_hexagon_hvx,
61 options::OPT_mhexagon_hvx,
62 options::OPT_mhexagon_hvx_EQ)) {
63 if (A->getOption().matches(options::OPT_mno_hexagon_hvx))
64 return;
65 if (A->getOption().matches(options::OPT_mhexagon_hvx_EQ)) {
66 HasHVX = true;
67 HVXFeature = Cpu = A->getValue();
68 HVXFeature = Args.MakeArgString(llvm::Twine("+hvx") + HVXFeature.lower());
69 } else if (A->getOption().matches(options::OPT_mhexagon_hvx)) {
70 HasHVX = true;
71 HVXFeature = Args.MakeArgString(llvm::Twine("+hvx") + Cpu);
72 }
73 Features.push_back(HVXFeature);
74 }
75
76 // Handle -mhvx-length=.
77 if (Arg *A = Args.getLastArg(options::OPT_mhexagon_hvx_length_EQ)) {
78 // These flags are valid only if HVX in enabled.
79 if (!HasHVX)
80 D.Diag(diag::err_drv_invalid_hvx_length);
81 else if (A->getOption().matches(options::OPT_mhexagon_hvx_length_EQ))
82 HVXLength = A->getValue();
83 }
84 // Default hvx-length based on Cpu.
85 else if (HasHVX)
86 HVXLength = getDefaultHvxLength(Cpu);
87
88 if (!HVXLength.empty()) {
89 HVXFeature =
90 Args.MakeArgString(llvm::Twine("+hvx-length") + HVXLength.lower());
91 Features.push_back(HVXFeature);
92 }
93 }
94
95 // Hexagon target features.
96 void hexagon::getHexagonTargetFeatures(const Driver &D, const ArgList &Args,
97 std::vector<StringRef> &Features) {
98 handleTargetFeaturesGroup(Args, Features,
99 options::OPT_m_hexagon_Features_Group);
100
101 bool UseLongCalls = false;
102 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
103 options::OPT_mno_long_calls)) {
104 if (A->getOption().matches(options::OPT_mlong_calls))
105 UseLongCalls = true;
106 }
107
108 Features.push_back(UseLongCalls ? "+long-calls" : "-long-calls");
109
110 bool HasHVX = false;
111 handleHVXTargetFeatures(D, Args, Features, HasHVX);
112
113 if (HexagonToolChain::isAutoHVXEnabled(Args) && !HasHVX)
114 D.Diag(diag::warn_drv_vectorize_needs_hvx);
115 }
116
117 // Hexagon tools start.
118 void hexagon::Assembler::RenderExtraToolArgs(const JobAction &JA,
119 ArgStringList &CmdArgs) const {
120 }
121
122 void hexagon::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
123 const InputInfo &Output,
124 const InputInfoList &Inputs,
125 const ArgList &Args,
126 const char *LinkingOutput) const {
127 claimNoWarnArgs(Args);
128
129 auto &HTC = static_cast<const toolchains::HexagonToolChain&>(getToolChain());
130 const Driver &D = HTC.getDriver();
131 ArgStringList CmdArgs;
132
133 CmdArgs.push_back("--arch=hexagon");
134
135 RenderExtraToolArgs(JA, CmdArgs);
136
137 const char *AsName = "llvm-mc";
138 CmdArgs.push_back("-filetype=obj");
139 CmdArgs.push_back(Args.MakeArgString(
140 "-mcpu=hexagon" +
141 toolchains::HexagonToolChain::GetTargetCPUVersion(Args)));
142
143 if (Output.isFilename()) {
144 CmdArgs.push_back("-o");
145 CmdArgs.push_back(Output.getFilename());
146 } else {
147 assert(Output.isNothing() && "Unexpected output");
148 CmdArgs.push_back("-fsyntax-only");
149 }
150
151 if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) {
152 CmdArgs.push_back(Args.MakeArgString("-gpsize=" + Twine(G.getValue())));
153 }
154
155 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
156
157 // Only pass -x if gcc will understand it; otherwise hope gcc
158 // understands the suffix correctly. The main use case this would go
159 // wrong in is for linker inputs if they happened to have an odd
160 // suffix; really the only way to get this to happen is a command
161 // like '-x foobar a.c' which will treat a.c like a linker input.
162 //
163 // FIXME: For the linker case specifically, can we safely convert
164 // inputs into '-Wl,' options?
165 for (const auto &II : Inputs) {
166 // Don't try to pass LLVM or AST inputs to a generic gcc.
167 if (types::isLLVMIR(II.getType()))
168 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
169 << HTC.getTripleString();
170 else if (II.getType() == types::TY_AST)
171 D.Diag(clang::diag::err_drv_no_ast_support)
172 << HTC.getTripleString();
173 else if (II.getType() == types::TY_ModuleFile)
174 D.Diag(diag::err_drv_no_module_support)
175 << HTC.getTripleString();
176
177 if (II.isFilename())
178 CmdArgs.push_back(II.getFilename());
179 else
180 // Don't render as input, we need gcc to do the translations.
181 // FIXME: What is this?
182 II.getInputArg().render(Args, CmdArgs);
183 }
184
185 auto *Exec = Args.MakeArgString(HTC.GetProgramPath(AsName));
186 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
187 }
188
189 void hexagon::Linker::RenderExtraToolArgs(const JobAction &JA,
190 ArgStringList &CmdArgs) const {
191 }
192
193 static void
194 constructHexagonLinkArgs(Compilation &C, const JobAction &JA,
195 const toolchains::HexagonToolChain &HTC,
196 const InputInfo &Output, const InputInfoList &Inputs,
197 const ArgList &Args, ArgStringList &CmdArgs,
198 const char *LinkingOutput) {
199
200 const Driver &D = HTC.getDriver();
201
202 //----------------------------------------------------------------------------
203 //
204 //----------------------------------------------------------------------------
205 bool IsStatic = Args.hasArg(options::OPT_static);
206 bool IsShared = Args.hasArg(options::OPT_shared);
207 bool IsPIE = Args.hasArg(options::OPT_pie);
208 bool IncStdLib = !Args.hasArg(options::OPT_nostdlib);
209 bool IncStartFiles = !Args.hasArg(options::OPT_nostartfiles);
210 bool IncDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
211 bool UseG0 = false;
212 const char *Exec = Args.MakeArgString(HTC.GetLinkerPath());
213 bool UseLLD = (llvm::sys::path::filename(Exec).equals_lower("ld.lld") ||
214 llvm::sys::path::stem(Exec).equals_lower("ld.lld"));
215 bool UseShared = IsShared && !IsStatic;
216 StringRef CpuVer = toolchains::HexagonToolChain::GetTargetCPUVersion(Args);
217
218 //----------------------------------------------------------------------------
219 // Silence warnings for various options
220 //----------------------------------------------------------------------------
221 Args.ClaimAllArgs(options::OPT_g_Group);
222 Args.ClaimAllArgs(options::OPT_emit_llvm);
223 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
224 // handled somewhere else.
225 Args.ClaimAllArgs(options::OPT_static_libgcc);
226
227 //----------------------------------------------------------------------------
228 //
229 //----------------------------------------------------------------------------
230 if (Args.hasArg(options::OPT_s))
231 CmdArgs.push_back("-s");
232
233 if (Args.hasArg(options::OPT_r))
234 CmdArgs.push_back("-r");
235
236 for (const auto &Opt : HTC.ExtraOpts)
237 CmdArgs.push_back(Opt.c_str());
238
239 if (!UseLLD) {
240 CmdArgs.push_back("-march=hexagon");
241 CmdArgs.push_back(Args.MakeArgString("-mcpu=hexagon" + CpuVer));
242 }
243
244 if (IsShared) {
245 CmdArgs.push_back("-shared");
246 // The following should be the default, but doing as hexagon-gcc does.
247 CmdArgs.push_back("-call_shared");
248 }
249
250 if (IsStatic)
251 CmdArgs.push_back("-static");
252
253 if (IsPIE && !IsShared)
254 CmdArgs.push_back("-pie");
255
256 if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) {
257 CmdArgs.push_back(Args.MakeArgString("-G" + Twine(G.getValue())));
258 UseG0 = G.getValue() == 0;
259 }
260
261 //----------------------------------------------------------------------------
262 //
263 //----------------------------------------------------------------------------
264 CmdArgs.push_back("-o");
265 CmdArgs.push_back(Output.getFilename());
266
267 //----------------------------------------------------------------------------
268 // moslib
269 //----------------------------------------------------------------------------
270 std::vector<std::string> OsLibs;
271 bool HasStandalone = false;
272
273 for (const Arg *A : Args.filtered(options::OPT_moslib_EQ)) {
274 A->claim();
275 OsLibs.emplace_back(A->getValue());
276 HasStandalone = HasStandalone || (OsLibs.back() == "standalone");
277 }
278 if (OsLibs.empty()) {
279 OsLibs.push_back("standalone");
280 HasStandalone = true;
281 }
282
283 //----------------------------------------------------------------------------
284 // Start Files
285 //----------------------------------------------------------------------------
286 const std::string MCpuSuffix = "/" + CpuVer.str();
287 const std::string MCpuG0Suffix = MCpuSuffix + "/G0";
288 const std::string RootDir =
289 HTC.getHexagonTargetDir(D.InstalledDir, D.PrefixDirs) + "/";
290 const std::string StartSubDir =
291 "hexagon/lib" + (UseG0 ? MCpuG0Suffix : MCpuSuffix);
292
293 auto Find = [&HTC] (const std::string &RootDir, const std::string &SubDir,
294 const char *Name) -> std::string {
295 std::string RelName = SubDir + Name;
296 std::string P = HTC.GetFilePath(RelName.c_str());
297 if (llvm::sys::fs::exists(P))
298 return P;
299 return RootDir + RelName;
300 };
301
302 if (IncStdLib && IncStartFiles) {
303 if (!IsShared) {
304 if (HasStandalone) {
305 std::string Crt0SA = Find(RootDir, StartSubDir, "/crt0_standalone.o");
306 CmdArgs.push_back(Args.MakeArgString(Crt0SA));
307 }
308 std::string Crt0 = Find(RootDir, StartSubDir, "/crt0.o");
309 CmdArgs.push_back(Args.MakeArgString(Crt0));
310 }
311 std::string Init = UseShared
312 ? Find(RootDir, StartSubDir + "/pic", "/initS.o")
313 : Find(RootDir, StartSubDir, "/init.o");
314 CmdArgs.push_back(Args.MakeArgString(Init));
315 }
316
317 //----------------------------------------------------------------------------
318 // Library Search Paths
319 //----------------------------------------------------------------------------
320 const ToolChain::path_list &LibPaths = HTC.getFilePaths();
321 for (const auto &LibPath : LibPaths)
322 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
323
324 //----------------------------------------------------------------------------
325 //
326 //----------------------------------------------------------------------------
327 Args.AddAllArgs(CmdArgs,
328 {options::OPT_T_Group, options::OPT_e, options::OPT_s,
329 options::OPT_t, options::OPT_u_Group});
330
331 AddLinkerInputs(HTC, Inputs, Args, CmdArgs, JA);
332
333 //----------------------------------------------------------------------------
334 // Libraries
335 //----------------------------------------------------------------------------
336 if (IncStdLib && IncDefLibs) {
337 if (D.CCCIsCXX()) {
338 if (HTC.ShouldLinkCXXStdlib(Args))
339 HTC.AddCXXStdlibLibArgs(Args, CmdArgs);
340 CmdArgs.push_back("-lm");
341 }
342
343 CmdArgs.push_back("--start-group");
344
345 if (!IsShared) {
346 for (StringRef Lib : OsLibs)
347 CmdArgs.push_back(Args.MakeArgString("-l" + Lib));
348 CmdArgs.push_back("-lc");
349 }
350 CmdArgs.push_back("-lgcc");
351
352 CmdArgs.push_back("--end-group");
353 }
354
355 //----------------------------------------------------------------------------
356 // End files
357 //----------------------------------------------------------------------------
358 if (IncStdLib && IncStartFiles) {
359 std::string Fini = UseShared
360 ? Find(RootDir, StartSubDir + "/pic", "/finiS.o")
361 : Find(RootDir, StartSubDir, "/fini.o");
362 CmdArgs.push_back(Args.MakeArgString(Fini));
363 }
364 }
365
366 void hexagon::Linker::ConstructJob(Compilation &C, const JobAction &JA,
367 const InputInfo &Output,
368 const InputInfoList &Inputs,
369 const ArgList &Args,
370 const char *LinkingOutput) const {
371 auto &HTC = static_cast<const toolchains::HexagonToolChain&>(getToolChain());
372
373 ArgStringList CmdArgs;
374 constructHexagonLinkArgs(C, JA, HTC, Output, Inputs, Args, CmdArgs,
375 LinkingOutput);
376
377 const char *Exec = Args.MakeArgString(HTC.GetLinkerPath());
378 C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
379 }
380 // Hexagon tools end.
381
382 /// Hexagon Toolchain
383
384 std::string HexagonToolChain::getHexagonTargetDir(
385 const std::string &InstalledDir,
386 const SmallVectorImpl<std::string> &PrefixDirs) const {
387 std::string InstallRelDir;
388 const Driver &D = getDriver();
389
390 // Locate the rest of the toolchain ...
391 for (auto &I : PrefixDirs)
392 if (D.getVFS().exists(I))
393 return I;
394
395 if (getVFS().exists(InstallRelDir = InstalledDir + "/../target"))
396 return InstallRelDir;
397
398 return InstalledDir;
399 }
400
401 Optional<unsigned> HexagonToolChain::getSmallDataThreshold(
402 const ArgList &Args) {
403 StringRef Gn = "";
404 if (Arg *A = Args.getLastArg(options::OPT_G)) {
405 Gn = A->getValue();
406 } else if (Args.getLastArg(options::OPT_shared, options::OPT_fpic,
407 options::OPT_fPIC)) {
408 Gn = "0";
409 }
410
411 unsigned G;
412 if (!Gn.getAsInteger(10, G))
413 return G;
414
415 return None;
416 }
417
418 void HexagonToolChain::getHexagonLibraryPaths(const ArgList &Args,
419 ToolChain::path_list &LibPaths) const {
420 const Driver &D = getDriver();
421
422 //----------------------------------------------------------------------------
423 // -L Args
424 //----------------------------------------------------------------------------
425 for (Arg *A : Args.filtered(options::OPT_L))
426 for (const char *Value : A->getValues())
427 LibPaths.push_back(Value);
428
429 //----------------------------------------------------------------------------
430 // Other standard paths
431 //----------------------------------------------------------------------------
432 std::vector<std::string> RootDirs;
433 std::copy(D.PrefixDirs.begin(), D.PrefixDirs.end(),
434 std::back_inserter(RootDirs));
435
436 std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
437 D.PrefixDirs);
438 if (llvm::find(RootDirs, TargetDir) == RootDirs.end())
439 RootDirs.push_back(TargetDir);
440
441 bool HasPIC = Args.hasArg(options::OPT_fpic, options::OPT_fPIC);
442 // Assume G0 with -shared.
443 bool HasG0 = Args.hasArg(options::OPT_shared);
444 if (auto G = getSmallDataThreshold(Args))
445 HasG0 = G.getValue() == 0;
446
447 const std::string CpuVer = GetTargetCPUVersion(Args).str();
448 for (auto &Dir : RootDirs) {
449 std::string LibDir = Dir + "/hexagon/lib";
450 std::string LibDirCpu = LibDir + '/' + CpuVer;
451 if (HasG0) {
452 if (HasPIC)
453 LibPaths.push_back(LibDirCpu + "/G0/pic");
454 LibPaths.push_back(LibDirCpu + "/G0");
455 }
456 LibPaths.push_back(LibDirCpu);
457 LibPaths.push_back(LibDir);
458 }
459 }
460
461 HexagonToolChain::HexagonToolChain(const Driver &D, const llvm::Triple &Triple,
462 const llvm::opt::ArgList &Args)
463 : Linux(D, Triple, Args) {
464 const std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
465 D.PrefixDirs);
466
467 // Note: Generic_GCC::Generic_GCC adds InstalledDir and getDriver().Dir to
468 // program paths
469 const std::string BinDir(TargetDir + "/bin");
470 if (D.getVFS().exists(BinDir))
471 getProgramPaths().push_back(BinDir);
472
473 ToolChain::path_list &LibPaths = getFilePaths();
474
475 // Remove paths added by Linux toolchain. Currently Hexagon_TC really targets
476 // 'elf' OS type, so the Linux paths are not appropriate. When we actually
477 // support 'linux' we'll need to fix this up
478 LibPaths.clear();
479 getHexagonLibraryPaths(Args, LibPaths);
480 }
481
482 HexagonToolChain::~HexagonToolChain() {}
483
484 Tool *HexagonToolChain::buildAssembler() const {
485 return new tools::hexagon::Assembler(*this);
486 }
487
488 Tool *HexagonToolChain::buildLinker() const {
489 return new tools::hexagon::Linker(*this);
490 }
491
492 unsigned HexagonToolChain::getOptimizationLevel(
493 const llvm::opt::ArgList &DriverArgs) const {
494 // Copied in large part from lib/Frontend/CompilerInvocation.cpp.
495 Arg *A = DriverArgs.getLastArg(options::OPT_O_Group);
496 if (!A)
497 return 0;
498
499 if (A->getOption().matches(options::OPT_O0))
500 return 0;
501 if (A->getOption().matches(options::OPT_Ofast) ||
502 A->getOption().matches(options::OPT_O4))
503 return 3;
504 assert(A->getNumValues() != 0);
505 StringRef S(A->getValue());
506 if (S == "s" || S == "z" || S.empty())
507 return 2;
508 if (S == "g")
509 return 1;
510
511 unsigned OptLevel;
512 if (S.getAsInteger(10, OptLevel))
513 return 0;
514 return OptLevel;
515 }
516
517 void HexagonToolChain::addClangTargetOptions(const ArgList &DriverArgs,
518 ArgStringList &CC1Args,
519 Action::OffloadKind) const {
520 if (DriverArgs.hasArg(options::OPT_ffixed_r19)) {
521 CC1Args.push_back("-target-feature");
522 CC1Args.push_back("+reserved-r19");
523 }
524 if (isAutoHVXEnabled(DriverArgs)) {
525 CC1Args.push_back("-mllvm");
526 CC1Args.push_back("-hexagon-autohvx");
527 }
528 }
529
530 void HexagonToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
531 ArgStringList &CC1Args) const {
532 if (DriverArgs.hasArg(options::OPT_nostdinc) ||
533 DriverArgs.hasArg(options::OPT_nostdlibinc))
534 return;
535
536 const Driver &D = getDriver();
537 std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
538 D.PrefixDirs);
539 addExternCSystemInclude(DriverArgs, CC1Args, TargetDir + "/hexagon/include");
540 }
541
542
543 void HexagonToolChain::addLibStdCxxIncludePaths(
544 const llvm::opt::ArgList &DriverArgs,
545 llvm::opt::ArgStringList &CC1Args) const {
546 const Driver &D = getDriver();
547 std::string TargetDir = getHexagonTargetDir(D.InstalledDir, D.PrefixDirs);
548 addLibStdCXXIncludePaths(TargetDir, "/hexagon/include/c++", "", "", "", "",
549 DriverArgs, CC1Args);
550 }
551
552 ToolChain::CXXStdlibType
553 HexagonToolChain::GetCXXStdlibType(const ArgList &Args) const {
554 Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
555 if (!A)
556 return ToolChain::CST_Libstdcxx;
557
558 StringRef Value = A->getValue();
559 if (Value != "libstdc++")
560 getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
561
562 return ToolChain::CST_Libstdcxx;
563 }
564
565 bool HexagonToolChain::isAutoHVXEnabled(const llvm::opt::ArgList &Args) {
566 if (Arg *A = Args.getLastArg(options::OPT_fvectorize,
567 options::OPT_fno_vectorize))
568 return A->getOption().matches(options::OPT_fvectorize);
569 return false;
570 }
571
572 //
573 // Returns the default CPU for Hexagon. This is the default compilation target
574 // if no Hexagon processor is selected at the command-line.
575 //
576 const StringRef HexagonToolChain::GetDefaultCPU() {
577 return "hexagonv60";
578 }
579
580 const StringRef HexagonToolChain::GetTargetCPUVersion(const ArgList &Args) {
581 Arg *CpuArg = nullptr;
582 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
583 CpuArg = A;
584
585 StringRef CPU = CpuArg ? CpuArg->getValue() : GetDefaultCPU();
586 if (CPU.startswith("hexagon"))
587 return CPU.substr(sizeof("hexagon") - 1);
588 return CPU;
589 }
IsStatic
bool IsStatic
Definition: Format.cpp:1837
clang::driver::ToolChain::addExternCSystemInclude
static void addExternCSystemInclude(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, const Twine &Path)
Utility function to add a system include directory with extern "C" semantics to CC1 arguments...
Definition: ToolChain.cpp:835
clang::driver::tools::handleTargetFeaturesGroup
void handleTargetFeaturesGroup(const llvm::opt::ArgList &Args, std::vector< StringRef > &Features, llvm::opt::OptSpecifier Group)
clang::driver::Driver::PrefixDirs
prefix_list PrefixDirs
Definition: Driver.h:145
P
StringRef P
Definition: ASTMatchersInternal.cpp:485
clang::driver::Driver::Diag
DiagnosticBuilder Diag(unsigned DiagID) const
Definition: Driver.h:109
Value
Value
Definition: UninitializedValues.cpp:101
clang::driver::ToolChain::GetLinkerPath
std::string GetLinkerPath() const
Returns the linker path, respecting the -fuse-ld= argument to determine the linker suffix or name...
Definition: ToolChain.cpp:520
clang::driver::toolchains::HexagonToolChain::~HexagonToolChain
~HexagonToolChain() override
Definition: Hexagon.cpp:482
Hexagon.h
clang::driver::ToolChain::CXXStdlibType
CXXStdlibType
Definition: ToolChain.h:92
clang::driver::InputInfo::getFilename
const char * getFilename() const
Definition: InputInfo.h:83
clang::driver::tools::hexagon::Linker::RenderExtraToolArgs
virtual void RenderExtraToolArgs(const JobAction &JA, llvm::opt::ArgStringList &CmdArgs) const
Definition: Hexagon.cpp:189
llvm::Optional< unsigned >
clang::driver::ToolChain::getProgramPaths
path_list & getProgramPaths()
Definition: ToolChain.h:240
CommonArgs.h
clang::driver::JobAction
Definition: Action.h:375
llvm::SmallVectorImpl
Definition: LLVM.h:36
clang::driver::toolchains::HexagonToolChain::buildLinker
Tool * buildLinker() const override
Definition: Hexagon.cpp:488
clang::driver::tools
Definition: AIX.h:17
clang::driver::InputInfo
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:22
clang::driver::ToolChain::GetFilePath
std::string GetFilePath(const char *Name) const
Definition: ToolChain.cpp:512
clang::driver::toolchains::HexagonToolChain::addClangTargetOptions
void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, Action::OffloadKind DeviceOffloadKind) const override
Add options that need to be passed to cc1 for this target.
Definition: Hexagon.cpp:517
clang::driver::ToolChain::getFilePaths
path_list & getFilePaths()
Definition: ToolChain.h:237
clang::driver::Driver
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:59
constructHexagonLinkArgs
static void constructHexagonLinkArgs(Compilation &C, const JobAction &JA, const toolchains::HexagonToolChain &HTC, const InputInfo &Output, const InputInfoList &Inputs, const ArgList &Args, ArgStringList &CmdArgs, const char *LinkingOutput)
Definition: Hexagon.cpp:194
Driver.h
clang::driver::toolchains::HexagonToolChain::addLibStdCxxIncludePaths
void addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Definition: Hexagon.cpp:543
Compilation.h
clang::driver::Driver::getVFS
llvm::vfs::FileSystem & getVFS() const
Definition: Driver.h:319
clang::driver::toolchains::HexagonToolChain::getHexagonLibraryPaths
void getHexagonLibraryPaths(const llvm::opt::ArgList &Args, ToolChain::path_list &LibPaths) const
Definition: Hexagon.cpp:418
clang::driver::toolchains::HexagonToolChain
Definition: Hexagon.h:61
llvm::opt
Definition: Action.h:23
clang::driver::tools::hexagon::Assembler::RenderExtraToolArgs
void RenderExtraToolArgs(const JobAction &JA, llvm::opt::ArgStringList &CmdArgs) const
Definition: Hexagon.cpp:118
clang::driver::toolchains::Linux
Definition: Linux.h:19
clang::driver::toolchains::HexagonToolChain::GetTargetCPUVersion
static const StringRef GetTargetCPUVersion(const llvm::opt::ArgList &Args)
Definition: Hexagon.cpp:580
clang::driver::Compilation::addCommand
void addCommand(std::unique_ptr< Command > C)
Definition: Compilation.h:205
clang::driver::toolchains::HexagonToolChain::getHexagonTargetDir
std::string getHexagonTargetDir(const std::string &InstalledDir, const SmallVectorImpl< std::string > &PrefixDirs) const
Hexagon Toolchain.
Definition: Hexagon.cpp:384
clang::driver::toolchains::HexagonToolChain::AddClangSystemIncludeArgs
void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add the clang cc1 arguments for system include paths.
Definition: Hexagon.cpp:530
clang::driver::ToolChain::getDriver
const Driver & getDriver() const
Definition: ToolChain.h:199
clang::driver::Driver::InstalledDir
std::string InstalledDir
The path to the installed clang directory, if any.
Definition: Driver.h:129
clang::driver::Driver::CCCIsCXX
bool CCCIsCXX() const
Whether the driver should follow g++ like behavior.
Definition: Driver.h:173
clang::driver::tools::hexagon::Linker
Definition: Hexagon.h:38
llvm::SmallVector
Definition: LLVM.h:35
Options.h
handleHVXTargetFeatures
static void handleHVXTargetFeatures(const Driver &D, const ArgList &Args, std::vector< StringRef > &Features, bool &HasHVX)
Definition: Hexagon.cpp:49
clang::driver::toolchains::HexagonToolChain::getOptimizationLevel
unsigned getOptimizationLevel(const llvm::opt::ArgList &DriverArgs) const
Definition: Hexagon.cpp:492
clang::driver::toolchains::HexagonToolChain::buildAssembler
Tool * buildAssembler() const override
Definition: Hexagon.cpp:484
clang::driver::Action::OffloadKind
OffloadKind
Definition: Action.h:84
clang::driver::toolchains::HexagonToolChain::GetCXXStdlibType
CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override
Definition: Hexagon.cpp:553
clang::driver::ToolChain::ShouldLinkCXXStdlib
bool ShouldLinkCXXStdlib(const llvm::opt::ArgList &Args) const
Returns if the C++ standard library should be linked in.
Definition: ToolChain.cpp:883
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:21
clang::driver::tools::AddLinkerInputs
void AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const JobAction &JA)
clang::driver::tools::hexagon::getHexagonTargetFeatures
void getHexagonTargetFeatures(const Driver &D, const llvm::opt::ArgList &Args, std::vector< StringRef > &Features)
clang::driver::Tool
Tool - Information on a specific compilation tool.
Definition: Tool.h:33
InputInfo.h
clang::driver::tools::claimNoWarnArgs
void claimNoWarnArgs(const llvm::opt::ArgList &Args)
clang::driver::Driver::getInstalledDir
const char * getInstalledDir() const
Get the path to where the clang executable was installed.
Definition: Driver.h:338
clang::driver::Compilation
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:45
clang::driver::toolchains::HexagonToolChain::isAutoHVXEnabled
static bool isAutoHVXEnabled(const llvm::opt::ArgList &Args)
Definition: Hexagon.cpp:565
clang::driver::toolchains::HexagonToolChain::getSmallDataThreshold
static Optional< unsigned > getSmallDataThreshold(const llvm::opt::ArgList &Args)
Definition: Hexagon.cpp:401
clang::driver
Definition: Action.h:31
DriverDiagnostic.h
getDefaultHvxLength
static StringRef getDefaultHvxLength(StringRef Cpu)
Definition: Hexagon.cpp:29
clang::driver::tools::hexagon::Assembler
Definition: Hexagon.h:23
clang::driver::tools::hexagon::Assembler::ConstructJob
void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
ConstructJob - Construct jobs to perform the action JA, writing to Output and with Inputs...
Definition: Hexagon.cpp:122
clang::driver::toolchains
Definition: AIX.h:55
clang::driver::InputInfo::isNothing
bool isNothing() const
Definition: InputInfo.h:74
clang::driver::InputInfo::isFilename
bool isFilename() const
Definition: InputInfo.h:75
clang::driver::toolchains::HexagonToolChain::GetDefaultCPU
static const StringRef GetDefaultCPU()
Definition: Hexagon.cpp:576
clang::driver::toolchains::Generic_GCC::addLibStdCXXIncludePaths
bool addLibStdCXXIncludePaths(Twine Base, Twine Suffix, StringRef GCCTriple, StringRef GCCMultiarchTriple, StringRef TargetMultiarchTriple, Twine IncludeSuffix, const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const
Helper to add the variant paths of a libstdc++ installation.
Definition: Gnu.cpp:2732
handleHVXWarnings
static void handleHVXWarnings(const Driver &D, const ArgList &Args)
Definition: Hexagon.cpp:38
clang::driver::toolchains::Linux::ExtraOpts
std::vector< std::string > ExtraOpts
Definition: Linux.h:47
clang::driver::types::isLLVMIR
bool isLLVMIR(ID Id)
Is this LLVM IR.
Definition: Types.cpp:178
clang::driver::ToolChain::CST_Libstdcxx
Definition: ToolChain.h:94
clang::driver::ToolChain::AddCXXStdlibLibArgs
virtual void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
AddCXXStdlibLibArgs - Add the system specific linker arguments to use for the given C++ standard libr...
Definition: ToolChain.cpp:889
clang::driver::tools::hexagon::Linker::ConstructJob
void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
ConstructJob - Construct jobs to perform the action JA, writing to Output and with Inputs...
Definition: Hexagon.cpp:366