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"
13 #include "clang/Driver/Driver.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;
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.
119  ArgStringList &CmdArgs) const {
120 }
121 
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" +
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 
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 
190  ArgStringList &CmdArgs) const {
191 }
192 
193 static void
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 
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 =
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 
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 
483 
485  return new tools::hexagon::Assembler(*this);
486 }
487 
489  return new tools::hexagon::Linker(*this);
490 }
491 
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 
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 
553 HexagonToolChain::GetCXXStdlibType(const ArgList &Args) const {
554  Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
555  if (!A)
557 
558  StringRef Value = A->getValue();
559  if (Value != "libstdc++")
560  getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
561 
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 //
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 }
bool IsStatic
Definition: Format.cpp:1837
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
void handleTargetFeaturesGroup(const llvm::opt::ArgList &Args, std::vector< StringRef > &Features, llvm::opt::OptSpecifier Group)
prefix_list PrefixDirs
Definition: Driver.h:145
StringRef P
DiagnosticBuilder Diag(unsigned DiagID) const
Definition: Driver.h:109
std::string GetLinkerPath() const
Returns the linker path, respecting the -fuse-ld= argument to determine the linker suffix or name...
Definition: ToolChain.cpp:520
const char * getFilename() const
Definition: InputInfo.h:83
virtual void RenderExtraToolArgs(const JobAction &JA, llvm::opt::ArgStringList &CmdArgs) const
Definition: Hexagon.cpp:189
path_list & getProgramPaths()
Definition: ToolChain.h:240
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:22
std::string GetFilePath(const char *Name) const
Definition: ToolChain.cpp:512
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
path_list & getFilePaths()
Definition: ToolChain.h:237
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:59
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
void addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Definition: Hexagon.cpp:543
llvm::vfs::FileSystem & getVFS() const
Definition: Driver.h:319
void getHexagonLibraryPaths(const llvm::opt::ArgList &Args, ToolChain::path_list &LibPaths) const
Definition: Hexagon.cpp:418
void RenderExtraToolArgs(const JobAction &JA, llvm::opt::ArgStringList &CmdArgs) const
Definition: Hexagon.cpp:118
static const StringRef GetTargetCPUVersion(const llvm::opt::ArgList &Args)
Definition: Hexagon.cpp:580
void addCommand(std::unique_ptr< Command > C)
Definition: Compilation.h:205
std::string getHexagonTargetDir(const std::string &InstalledDir, const SmallVectorImpl< std::string > &PrefixDirs) const
Hexagon Toolchain.
Definition: Hexagon.cpp:384
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
const Driver & getDriver() const
Definition: ToolChain.h:199
std::string InstalledDir
The path to the installed clang directory, if any.
Definition: Driver.h:129
bool CCCIsCXX() const
Whether the driver should follow g++ like behavior.
Definition: Driver.h:173
static void handleHVXTargetFeatures(const Driver &D, const ArgList &Args, std::vector< StringRef > &Features, bool &HasHVX)
Definition: Hexagon.cpp:49
unsigned getOptimizationLevel(const llvm::opt::ArgList &DriverArgs) const
Definition: Hexagon.cpp:492
Tool * buildAssembler() const override
Definition: Hexagon.cpp:484
CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override
Definition: Hexagon.cpp:553
bool ShouldLinkCXXStdlib(const llvm::opt::ArgList &Args) const
Returns if the C++ standard library should be linked in.
Definition: ToolChain.cpp:883
Dataflow Directional Tag Classes.
void AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const JobAction &JA)
void getHexagonTargetFeatures(const Driver &D, const llvm::opt::ArgList &Args, std::vector< StringRef > &Features)
Tool - Information on a specific compilation tool.
Definition: Tool.h:33
void claimNoWarnArgs(const llvm::opt::ArgList &Args)
const char * getInstalledDir() const
Get the path to where the clang executable was installed.
Definition: Driver.h:338
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:45
static bool isAutoHVXEnabled(const llvm::opt::ArgList &Args)
Definition: Hexagon.cpp:565
static Optional< unsigned > getSmallDataThreshold(const llvm::opt::ArgList &Args)
Definition: Hexagon.cpp:401
static StringRef getDefaultHvxLength(StringRef Cpu)
Definition: Hexagon.cpp:29
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
bool isNothing() const
Definition: InputInfo.h:74
bool isFilename() const
Definition: InputInfo.h:75
static const StringRef GetDefaultCPU()
Definition: Hexagon.cpp:576
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
static void handleHVXWarnings(const Driver &D, const ArgList &Args)
Definition: Hexagon.cpp:38
std::vector< std::string > ExtraOpts
Definition: Linux.h:47
bool isLLVMIR(ID Id)
Is this LLVM IR.
Definition: Types.cpp:178
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
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