clang  7.0.0svn
Hexagon.cpp
Go to the documentation of this file.
1 //===--- Hexagon.cpp - Hexagon ToolChain Implementations --------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "Hexagon.h"
11 #include "InputInfo.h"
12 #include "CommonArgs.h"
15 #include "clang/Driver/Driver.h"
17 #include "clang/Driver/Options.h"
18 #include "llvm/ADT/StringExtras.h"
19 #include "llvm/Option/ArgList.h"
20 #include "llvm/Support/FileSystem.h"
21 #include "llvm/Support/Path.h"
22 
23 using namespace clang::driver;
24 using namespace clang::driver::tools;
25 using namespace clang::driver::toolchains;
26 using namespace clang;
27 using namespace llvm::opt;
28 
29 // Default hvx-length for various versions.
30 static StringRef getDefaultHvxLength(StringRef Cpu) {
31  return llvm::StringSwitch<StringRef>(Cpu)
32  .Case("v60", "64b")
33  .Case("v62", "64b")
34  .Case("v65", "64b")
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 falgs 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("-march=hexagon");
134 
135  RenderExtraToolArgs(JA, CmdArgs);
136 
137  const char *AsName = "hexagon-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(llvm::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  bool UseShared = IsShared && !IsStatic;
213 
214  //----------------------------------------------------------------------------
215  // Silence warnings for various options
216  //----------------------------------------------------------------------------
217  Args.ClaimAllArgs(options::OPT_g_Group);
218  Args.ClaimAllArgs(options::OPT_emit_llvm);
219  Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
220  // handled somewhere else.
221  Args.ClaimAllArgs(options::OPT_static_libgcc);
222 
223  //----------------------------------------------------------------------------
224  //
225  //----------------------------------------------------------------------------
226  if (Args.hasArg(options::OPT_s))
227  CmdArgs.push_back("-s");
228 
229  if (Args.hasArg(options::OPT_r))
230  CmdArgs.push_back("-r");
231 
232  for (const auto &Opt : HTC.ExtraOpts)
233  CmdArgs.push_back(Opt.c_str());
234 
235  CmdArgs.push_back("-march=hexagon");
236  StringRef CpuVer = toolchains::HexagonToolChain::GetTargetCPUVersion(Args);
237  CmdArgs.push_back(Args.MakeArgString("-mcpu=hexagon" + CpuVer));
238 
239  if (IsShared) {
240  CmdArgs.push_back("-shared");
241  // The following should be the default, but doing as hexagon-gcc does.
242  CmdArgs.push_back("-call_shared");
243  }
244 
245  if (IsStatic)
246  CmdArgs.push_back("-static");
247 
248  if (IsPIE && !IsShared)
249  CmdArgs.push_back("-pie");
250 
252  CmdArgs.push_back(Args.MakeArgString("-G" + Twine(G.getValue())));
253  UseG0 = G.getValue() == 0;
254  }
255 
256  //----------------------------------------------------------------------------
257  //
258  //----------------------------------------------------------------------------
259  CmdArgs.push_back("-o");
260  CmdArgs.push_back(Output.getFilename());
261 
262  //----------------------------------------------------------------------------
263  // moslib
264  //----------------------------------------------------------------------------
265  std::vector<std::string> OsLibs;
266  bool HasStandalone = false;
267 
268  for (const Arg *A : Args.filtered(options::OPT_moslib_EQ)) {
269  A->claim();
270  OsLibs.emplace_back(A->getValue());
271  HasStandalone = HasStandalone || (OsLibs.back() == "standalone");
272  }
273  if (OsLibs.empty()) {
274  OsLibs.push_back("standalone");
275  HasStandalone = true;
276  }
277 
278  //----------------------------------------------------------------------------
279  // Start Files
280  //----------------------------------------------------------------------------
281  const std::string MCpuSuffix = "/" + CpuVer.str();
282  const std::string MCpuG0Suffix = MCpuSuffix + "/G0";
283  const std::string RootDir =
285  const std::string StartSubDir =
286  "hexagon/lib" + (UseG0 ? MCpuG0Suffix : MCpuSuffix);
287 
288  auto Find = [&HTC] (const std::string &RootDir, const std::string &SubDir,
289  const char *Name) -> std::string {
290  std::string RelName = SubDir + Name;
291  std::string P = HTC.GetFilePath(RelName.c_str());
292  if (llvm::sys::fs::exists(P))
293  return P;
294  return RootDir + RelName;
295  };
296 
297  if (IncStdLib && IncStartFiles) {
298  if (!IsShared) {
299  if (HasStandalone) {
300  std::string Crt0SA = Find(RootDir, StartSubDir, "/crt0_standalone.o");
301  CmdArgs.push_back(Args.MakeArgString(Crt0SA));
302  }
303  std::string Crt0 = Find(RootDir, StartSubDir, "/crt0.o");
304  CmdArgs.push_back(Args.MakeArgString(Crt0));
305  }
306  std::string Init = UseShared
307  ? Find(RootDir, StartSubDir + "/pic", "/initS.o")
308  : Find(RootDir, StartSubDir, "/init.o");
309  CmdArgs.push_back(Args.MakeArgString(Init));
310  }
311 
312  //----------------------------------------------------------------------------
313  // Library Search Paths
314  //----------------------------------------------------------------------------
315  const ToolChain::path_list &LibPaths = HTC.getFilePaths();
316  for (const auto &LibPath : LibPaths)
317  CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
318 
319  //----------------------------------------------------------------------------
320  //
321  //----------------------------------------------------------------------------
322  Args.AddAllArgs(CmdArgs,
323  {options::OPT_T_Group, options::OPT_e, options::OPT_s,
324  options::OPT_t, options::OPT_u_Group});
325 
326  AddLinkerInputs(HTC, Inputs, Args, CmdArgs, JA);
327 
328  //----------------------------------------------------------------------------
329  // Libraries
330  //----------------------------------------------------------------------------
331  if (IncStdLib && IncDefLibs) {
332  if (D.CCCIsCXX()) {
333  if (HTC.ShouldLinkCXXStdlib(Args))
334  HTC.AddCXXStdlibLibArgs(Args, CmdArgs);
335  CmdArgs.push_back("-lm");
336  }
337 
338  CmdArgs.push_back("--start-group");
339 
340  if (!IsShared) {
341  for (StringRef Lib : OsLibs)
342  CmdArgs.push_back(Args.MakeArgString("-l" + Lib));
343  CmdArgs.push_back("-lc");
344  }
345  CmdArgs.push_back("-lgcc");
346 
347  CmdArgs.push_back("--end-group");
348  }
349 
350  //----------------------------------------------------------------------------
351  // End files
352  //----------------------------------------------------------------------------
353  if (IncStdLib && IncStartFiles) {
354  std::string Fini = UseShared
355  ? Find(RootDir, StartSubDir + "/pic", "/finiS.o")
356  : Find(RootDir, StartSubDir, "/fini.o");
357  CmdArgs.push_back(Args.MakeArgString(Fini));
358  }
359 }
360 
362  const InputInfo &Output,
363  const InputInfoList &Inputs,
364  const ArgList &Args,
365  const char *LinkingOutput) const {
366  auto &HTC = static_cast<const toolchains::HexagonToolChain&>(getToolChain());
367 
368  ArgStringList CmdArgs;
369  constructHexagonLinkArgs(C, JA, HTC, Output, Inputs, Args, CmdArgs,
370  LinkingOutput);
371 
372  std::string Linker = HTC.GetProgramPath("hexagon-link");
373  C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
374  CmdArgs, Inputs));
375 }
376 // Hexagon tools end.
377 
378 /// Hexagon Toolchain
379 
380 std::string HexagonToolChain::getHexagonTargetDir(
381  const std::string &InstalledDir,
382  const SmallVectorImpl<std::string> &PrefixDirs) const {
383  std::string InstallRelDir;
384  const Driver &D = getDriver();
385 
386  // Locate the rest of the toolchain ...
387  for (auto &I : PrefixDirs)
388  if (D.getVFS().exists(I))
389  return I;
390 
391  if (getVFS().exists(InstallRelDir = InstalledDir + "/../target"))
392  return InstallRelDir;
393 
394  return InstalledDir;
395 }
396 
397 Optional<unsigned> HexagonToolChain::getSmallDataThreshold(
398  const ArgList &Args) {
399  StringRef Gn = "";
400  if (Arg *A = Args.getLastArg(options::OPT_G)) {
401  Gn = A->getValue();
402  } else if (Args.getLastArg(options::OPT_shared, options::OPT_fpic,
403  options::OPT_fPIC)) {
404  Gn = "0";
405  }
406 
407  unsigned G;
408  if (!Gn.getAsInteger(10, G))
409  return G;
410 
411  return None;
412 }
413 
414 void HexagonToolChain::getHexagonLibraryPaths(const ArgList &Args,
415  ToolChain::path_list &LibPaths) const {
416  const Driver &D = getDriver();
417 
418  //----------------------------------------------------------------------------
419  // -L Args
420  //----------------------------------------------------------------------------
421  for (Arg *A : Args.filtered(options::OPT_L))
422  for (const char *Value : A->getValues())
423  LibPaths.push_back(Value);
424 
425  //----------------------------------------------------------------------------
426  // Other standard paths
427  //----------------------------------------------------------------------------
428  std::vector<std::string> RootDirs;
429  std::copy(D.PrefixDirs.begin(), D.PrefixDirs.end(),
430  std::back_inserter(RootDirs));
431 
432  std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
433  D.PrefixDirs);
434  if (std::find(RootDirs.begin(), RootDirs.end(), TargetDir) == RootDirs.end())
435  RootDirs.push_back(TargetDir);
436 
437  bool HasPIC = Args.hasArg(options::OPT_fpic, options::OPT_fPIC);
438  // Assume G0 with -shared.
439  bool HasG0 = Args.hasArg(options::OPT_shared);
440  if (auto G = getSmallDataThreshold(Args))
441  HasG0 = G.getValue() == 0;
442 
443  const std::string CpuVer = GetTargetCPUVersion(Args).str();
444  for (auto &Dir : RootDirs) {
445  std::string LibDir = Dir + "/hexagon/lib";
446  std::string LibDirCpu = LibDir + '/' + CpuVer;
447  if (HasG0) {
448  if (HasPIC)
449  LibPaths.push_back(LibDirCpu + "/G0/pic");
450  LibPaths.push_back(LibDirCpu + "/G0");
451  }
452  LibPaths.push_back(LibDirCpu);
453  LibPaths.push_back(LibDir);
454  }
455 }
456 
457 HexagonToolChain::HexagonToolChain(const Driver &D, const llvm::Triple &Triple,
458  const llvm::opt::ArgList &Args)
459  : Linux(D, Triple, Args) {
460  const std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
461  D.PrefixDirs);
462 
463  // Note: Generic_GCC::Generic_GCC adds InstalledDir and getDriver().Dir to
464  // program paths
465  const std::string BinDir(TargetDir + "/bin");
466  if (D.getVFS().exists(BinDir))
467  getProgramPaths().push_back(BinDir);
468 
469  ToolChain::path_list &LibPaths = getFilePaths();
470 
471  // Remove paths added by Linux toolchain. Currently Hexagon_TC really targets
472  // 'elf' OS type, so the Linux paths are not appropriate. When we actually
473  // support 'linux' we'll need to fix this up
474  LibPaths.clear();
475  getHexagonLibraryPaths(Args, LibPaths);
476 }
477 
479 
481  return new tools::hexagon::Assembler(*this);
482 }
483 
485  return new tools::hexagon::Linker(*this);
486 }
487 
489  const llvm::opt::ArgList &DriverArgs) const {
490  // Copied in large part from lib/Frontend/CompilerInvocation.cpp.
491  Arg *A = DriverArgs.getLastArg(options::OPT_O_Group);
492  if (!A)
493  return 0;
494 
495  if (A->getOption().matches(options::OPT_O0))
496  return 0;
497  if (A->getOption().matches(options::OPT_Ofast) ||
498  A->getOption().matches(options::OPT_O4))
499  return 3;
500  assert(A->getNumValues() != 0);
501  StringRef S(A->getValue());
502  if (S == "s" || S == "z" || S.empty())
503  return 2;
504  if (S == "g")
505  return 1;
506 
507  unsigned OptLevel;
508  if (S.getAsInteger(10, OptLevel))
509  return 0;
510  return OptLevel;
511 }
512 
513 void HexagonToolChain::addClangTargetOptions(const ArgList &DriverArgs,
514  ArgStringList &CC1Args,
515  Action::OffloadKind) const {
516  if (!DriverArgs.hasArg(options::OPT_ffp_contract)) {
517  unsigned OptLevel = getOptimizationLevel(DriverArgs);
518  if (OptLevel >= 3)
519  CC1Args.push_back("-ffp-contract=fast");
520  }
521  if (DriverArgs.hasArg(options::OPT_ffixed_r19)) {
522  CC1Args.push_back("-target-feature");
523  CC1Args.push_back("+reserved-r19");
524  }
525  if (isAutoHVXEnabled(DriverArgs)) {
526  CC1Args.push_back("-mllvm");
527  CC1Args.push_back("-hexagon-autohvx");
528  }
529 }
530 
531 void HexagonToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
532  ArgStringList &CC1Args) const {
533  if (DriverArgs.hasArg(options::OPT_nostdinc) ||
534  DriverArgs.hasArg(options::OPT_nostdlibinc))
535  return;
536 
537  const Driver &D = getDriver();
538  std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
539  D.PrefixDirs);
540  addExternCSystemInclude(DriverArgs, CC1Args, TargetDir + "/hexagon/include");
541 }
542 
543 
545  const llvm::opt::ArgList &DriverArgs,
546  llvm::opt::ArgStringList &CC1Args) const {
547  const Driver &D = getDriver();
548  std::string TargetDir = getHexagonTargetDir(D.InstalledDir, D.PrefixDirs);
549  addLibStdCXXIncludePaths(TargetDir, "/hexagon/include/c++", "", "", "", "",
550  DriverArgs, CC1Args);
551 }
552 
554 HexagonToolChain::GetCXXStdlibType(const ArgList &Args) const {
555  Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
556  if (!A)
558 
559  StringRef Value = A->getValue();
560  if (Value != "libstdc++")
561  getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
562 
564 }
565 
566 bool HexagonToolChain::isAutoHVXEnabled(const llvm::opt::ArgList &Args) {
567  if (Arg *A = Args.getLastArg(options::OPT_fvectorize,
568  options::OPT_fno_vectorize))
569  return A->getOption().matches(options::OPT_fvectorize);
570  return false;
571 }
572 
573 //
574 // Returns the default CPU for Hexagon. This is the default compilation target
575 // if no Hexagon processor is selected at the command-line.
576 //
578  return "hexagonv60";
579 }
580 
581 const StringRef HexagonToolChain::GetTargetCPUVersion(const ArgList &Args) {
582  Arg *CpuArg = nullptr;
583  if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ, options::OPT_march_EQ))
584  CpuArg = A;
585 
586  StringRef CPU = CpuArg ? CpuArg->getValue() : GetDefaultCPU();
587  if (CPU.startswith("hexagon"))
588  return CPU.substr(sizeof("hexagon") - 1);
589  return CPU;
590 }
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:702
void handleTargetFeaturesGroup(const llvm::opt::ArgList &Args, std::vector< StringRef > &Features, llvm::opt::OptSpecifier Group)
SmallVector< std::string, 16 > path_list
Definition: ToolChain.h:90
prefix_list PrefixDirs
Definition: Driver.h:146
StringRef P
DiagnosticBuilder Diag(unsigned DiagID) const
Definition: Driver.h:110
const char * getFilename() const
Definition: InputInfo.h:84
virtual void RenderExtraToolArgs(const JobAction &JA, llvm::opt::ArgStringList &CmdArgs) const
Definition: Hexagon.cpp:189
path_list & getProgramPaths()
Definition: ToolChain.h:219
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:23
std::string GetFilePath(const char *Name) const
Definition: ToolChain.cpp:416
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:513
path_list & getFilePaths()
Definition: ToolChain.h:216
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:544
void getHexagonLibraryPaths(const llvm::opt::ArgList &Args, ToolChain::path_list &LibPaths) const
Definition: Hexagon.cpp:414
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:581
void addCommand(std::unique_ptr< Command > C)
Definition: Compilation.h:206
std::string getHexagonTargetDir(const std::string &InstalledDir, const SmallVectorImpl< std::string > &PrefixDirs) const
Hexagon Toolchain.
Definition: Hexagon.cpp:380
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:531
vfs::FileSystem & getVFS() const
Definition: Driver.h:301
const Driver & getDriver() const
Definition: ToolChain.h:181
std::string InstalledDir
The path to the installed clang directory, if any.
Definition: Driver.h:130
bool CCCIsCXX() const
Whether the driver should follow g++ like behavior.
Definition: Driver.h:174
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:488
Tool * buildAssembler() const override
Definition: Hexagon.cpp:480
CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override
Definition: Hexagon.cpp:554
bool ShouldLinkCXXStdlib(const llvm::opt::ArgList &Args) const
Returns if the C++ standard library should be linked in.
Definition: ToolChain.cpp:740
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:34
Defines the virtual file system interface vfs::FileSystem.
void claimNoWarnArgs(const llvm::opt::ArgList &Args)
const char * getInstalledDir() const
Get the path to where the clang executable was installed.
Definition: Driver.h:320
bool exists(const Twine &Path)
Check whether a file exists. Provided for convenience.
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:46
static bool isAutoHVXEnabled(const llvm::opt::ArgList &Args)
Definition: Hexagon.cpp:566
static Optional< unsigned > getSmallDataThreshold(const llvm::opt::ArgList &Args)
Definition: Hexagon.cpp:397
static StringRef getDefaultHvxLength(StringRef Cpu)
Definition: Hexagon.cpp:30
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:75
bool isFilename() const
Definition: InputInfo.h:76
static const StringRef GetDefaultCPU()
Definition: Hexagon.cpp:577
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:2466
static void handleHVXWarnings(const Driver &D, const ArgList &Args)
Definition: Hexagon.cpp:38
std::vector< std::string > ExtraOpts
Definition: Linux.h:48
bool isLLVMIR(ID Id)
Is this LLVM IR.
Definition: Types.cpp:154
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:746
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:361