clang  5.0.0
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"
14 #include "clang/Config/config.h"
16 #include "clang/Driver/Driver.h"
18 #include "clang/Driver/Options.h"
19 #include "llvm/ADT/StringExtras.h"
20 #include "llvm/Option/ArgList.h"
21 #include "llvm/Support/FileSystem.h"
22 #include "llvm/Support/Path.h"
23 
24 using namespace clang::driver;
25 using namespace clang::driver::tools;
26 using namespace clang::driver::toolchains;
27 using namespace clang;
28 using namespace llvm::opt;
29 
30 // Hexagon tools start.
32  ArgStringList &CmdArgs) const {
33 }
34 
36  const InputInfo &Output,
37  const InputInfoList &Inputs,
38  const ArgList &Args,
39  const char *LinkingOutput) const {
40  claimNoWarnArgs(Args);
41 
42  auto &HTC = static_cast<const toolchains::HexagonToolChain&>(getToolChain());
43  const Driver &D = HTC.getDriver();
44  ArgStringList CmdArgs;
45 
46  std::string MArchString = "-march=hexagon";
47  CmdArgs.push_back(Args.MakeArgString(MArchString));
48 
49  RenderExtraToolArgs(JA, CmdArgs);
50 
51  std::string AsName = "hexagon-llvm-mc";
52  std::string MCpuString = "-mcpu=hexagon" +
54  CmdArgs.push_back("-filetype=obj");
55  CmdArgs.push_back(Args.MakeArgString(MCpuString));
56 
57  if (Output.isFilename()) {
58  CmdArgs.push_back("-o");
59  CmdArgs.push_back(Output.getFilename());
60  } else {
61  assert(Output.isNothing() && "Unexpected output");
62  CmdArgs.push_back("-fsyntax-only");
63  }
64 
66  std::string N = llvm::utostr(G.getValue());
67  CmdArgs.push_back(Args.MakeArgString(std::string("-gpsize=") + N));
68  }
69 
70  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
71 
72  // Only pass -x if gcc will understand it; otherwise hope gcc
73  // understands the suffix correctly. The main use case this would go
74  // wrong in is for linker inputs if they happened to have an odd
75  // suffix; really the only way to get this to happen is a command
76  // like '-x foobar a.c' which will treat a.c like a linker input.
77  //
78  // FIXME: For the linker case specifically, can we safely convert
79  // inputs into '-Wl,' options?
80  for (const auto &II : Inputs) {
81  // Don't try to pass LLVM or AST inputs to a generic gcc.
82  if (types::isLLVMIR(II.getType()))
83  D.Diag(clang::diag::err_drv_no_linker_llvm_support)
84  << HTC.getTripleString();
85  else if (II.getType() == types::TY_AST)
86  D.Diag(clang::diag::err_drv_no_ast_support)
87  << HTC.getTripleString();
88  else if (II.getType() == types::TY_ModuleFile)
89  D.Diag(diag::err_drv_no_module_support)
90  << HTC.getTripleString();
91 
92  if (II.isFilename())
93  CmdArgs.push_back(II.getFilename());
94  else
95  // Don't render as input, we need gcc to do the translations.
96  // FIXME: What is this?
97  II.getInputArg().render(Args, CmdArgs);
98  }
99 
100  auto *Exec = Args.MakeArgString(HTC.GetProgramPath(AsName.c_str()));
101  C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
102 }
103 
105  ArgStringList &CmdArgs) const {
106 }
107 
108 static void
110  const toolchains::HexagonToolChain &HTC,
111  const InputInfo &Output, const InputInfoList &Inputs,
112  const ArgList &Args, ArgStringList &CmdArgs,
113  const char *LinkingOutput) {
114 
115  const Driver &D = HTC.getDriver();
116 
117  //----------------------------------------------------------------------------
118  //
119  //----------------------------------------------------------------------------
120  bool IsStatic = Args.hasArg(options::OPT_static);
121  bool IsShared = Args.hasArg(options::OPT_shared);
122  bool IsPIE = Args.hasArg(options::OPT_pie);
123  bool IncStdLib = !Args.hasArg(options::OPT_nostdlib);
124  bool IncStartFiles = !Args.hasArg(options::OPT_nostartfiles);
125  bool IncDefLibs = !Args.hasArg(options::OPT_nodefaultlibs);
126  bool UseG0 = false;
127  bool UseShared = IsShared && !IsStatic;
128 
129  //----------------------------------------------------------------------------
130  // Silence warnings for various options
131  //----------------------------------------------------------------------------
132  Args.ClaimAllArgs(options::OPT_g_Group);
133  Args.ClaimAllArgs(options::OPT_emit_llvm);
134  Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
135  // handled somewhere else.
136  Args.ClaimAllArgs(options::OPT_static_libgcc);
137 
138  //----------------------------------------------------------------------------
139  //
140  //----------------------------------------------------------------------------
141  if (Args.hasArg(options::OPT_s))
142  CmdArgs.push_back("-s");
143 
144  if (Args.hasArg(options::OPT_r))
145  CmdArgs.push_back("-r");
146 
147  for (const auto &Opt : HTC.ExtraOpts)
148  CmdArgs.push_back(Opt.c_str());
149 
150  CmdArgs.push_back("-march=hexagon");
151  std::string CpuVer =
153  std::string MCpuString = "-mcpu=hexagon" + CpuVer;
154  CmdArgs.push_back(Args.MakeArgString(MCpuString));
155 
156  if (IsShared) {
157  CmdArgs.push_back("-shared");
158  // The following should be the default, but doing as hexagon-gcc does.
159  CmdArgs.push_back("-call_shared");
160  }
161 
162  if (IsStatic)
163  CmdArgs.push_back("-static");
164 
165  if (IsPIE && !IsShared)
166  CmdArgs.push_back("-pie");
167 
169  std::string N = llvm::utostr(G.getValue());
170  CmdArgs.push_back(Args.MakeArgString(std::string("-G") + N));
171  UseG0 = G.getValue() == 0;
172  }
173 
174  //----------------------------------------------------------------------------
175  //
176  //----------------------------------------------------------------------------
177  CmdArgs.push_back("-o");
178  CmdArgs.push_back(Output.getFilename());
179 
180  //----------------------------------------------------------------------------
181  // moslib
182  //----------------------------------------------------------------------------
183  std::vector<std::string> OsLibs;
184  bool HasStandalone = false;
185 
186  for (const Arg *A : Args.filtered(options::OPT_moslib_EQ)) {
187  A->claim();
188  OsLibs.emplace_back(A->getValue());
189  HasStandalone = HasStandalone || (OsLibs.back() == "standalone");
190  }
191  if (OsLibs.empty()) {
192  OsLibs.push_back("standalone");
193  HasStandalone = true;
194  }
195 
196  //----------------------------------------------------------------------------
197  // Start Files
198  //----------------------------------------------------------------------------
199  const std::string MCpuSuffix = "/" + CpuVer;
200  const std::string MCpuG0Suffix = MCpuSuffix + "/G0";
201  const std::string RootDir =
203  const std::string StartSubDir =
204  "hexagon/lib" + (UseG0 ? MCpuG0Suffix : MCpuSuffix);
205 
206  auto Find = [&HTC] (const std::string &RootDir, const std::string &SubDir,
207  const char *Name) -> std::string {
208  std::string RelName = SubDir + Name;
209  std::string P = HTC.GetFilePath(RelName.c_str());
210  if (llvm::sys::fs::exists(P))
211  return P;
212  return RootDir + RelName;
213  };
214 
215  if (IncStdLib && IncStartFiles) {
216  if (!IsShared) {
217  if (HasStandalone) {
218  std::string Crt0SA = Find(RootDir, StartSubDir, "/crt0_standalone.o");
219  CmdArgs.push_back(Args.MakeArgString(Crt0SA));
220  }
221  std::string Crt0 = Find(RootDir, StartSubDir, "/crt0.o");
222  CmdArgs.push_back(Args.MakeArgString(Crt0));
223  }
224  std::string Init = UseShared
225  ? Find(RootDir, StartSubDir + "/pic", "/initS.o")
226  : Find(RootDir, StartSubDir, "/init.o");
227  CmdArgs.push_back(Args.MakeArgString(Init));
228  }
229 
230  //----------------------------------------------------------------------------
231  // Library Search Paths
232  //----------------------------------------------------------------------------
233  const ToolChain::path_list &LibPaths = HTC.getFilePaths();
234  for (const auto &LibPath : LibPaths)
235  CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
236 
237  //----------------------------------------------------------------------------
238  //
239  //----------------------------------------------------------------------------
240  Args.AddAllArgs(CmdArgs,
241  {options::OPT_T_Group, options::OPT_e, options::OPT_s,
242  options::OPT_t, options::OPT_u_Group});
243 
244  AddLinkerInputs(HTC, Inputs, Args, CmdArgs, JA);
245 
246  //----------------------------------------------------------------------------
247  // Libraries
248  //----------------------------------------------------------------------------
249  if (IncStdLib && IncDefLibs) {
250  if (D.CCCIsCXX()) {
251  HTC.AddCXXStdlibLibArgs(Args, CmdArgs);
252  CmdArgs.push_back("-lm");
253  }
254 
255  CmdArgs.push_back("--start-group");
256 
257  if (!IsShared) {
258  for (const std::string &Lib : OsLibs)
259  CmdArgs.push_back(Args.MakeArgString("-l" + Lib));
260  CmdArgs.push_back("-lc");
261  }
262  CmdArgs.push_back("-lgcc");
263 
264  CmdArgs.push_back("--end-group");
265  }
266 
267  //----------------------------------------------------------------------------
268  // End files
269  //----------------------------------------------------------------------------
270  if (IncStdLib && IncStartFiles) {
271  std::string Fini = UseShared
272  ? Find(RootDir, StartSubDir + "/pic", "/finiS.o")
273  : Find(RootDir, StartSubDir, "/fini.o");
274  CmdArgs.push_back(Args.MakeArgString(Fini));
275  }
276 }
277 
279  const InputInfo &Output,
280  const InputInfoList &Inputs,
281  const ArgList &Args,
282  const char *LinkingOutput) const {
283  auto &HTC = static_cast<const toolchains::HexagonToolChain&>(getToolChain());
284 
285  ArgStringList CmdArgs;
286  constructHexagonLinkArgs(C, JA, HTC, Output, Inputs, Args, CmdArgs,
287  LinkingOutput);
288 
289  std::string Linker = HTC.GetProgramPath("hexagon-link");
290  C.addCommand(llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
291  CmdArgs, Inputs));
292 }
293 // Hexagon tools end.
294 
295 /// Hexagon Toolchain
296 
297 std::string HexagonToolChain::getHexagonTargetDir(
298  const std::string &InstalledDir,
299  const SmallVectorImpl<std::string> &PrefixDirs) const {
300  std::string InstallRelDir;
301  const Driver &D = getDriver();
302 
303  // Locate the rest of the toolchain ...
304  for (auto &I : PrefixDirs)
305  if (D.getVFS().exists(I))
306  return I;
307 
308  if (getVFS().exists(InstallRelDir = InstalledDir + "/../target"))
309  return InstallRelDir;
310 
311  return InstalledDir;
312 }
313 
314 Optional<unsigned> HexagonToolChain::getSmallDataThreshold(
315  const ArgList &Args) {
316  StringRef Gn = "";
317  if (Arg *A = Args.getLastArg(options::OPT_G)) {
318  Gn = A->getValue();
319  } else if (Args.getLastArg(options::OPT_shared, options::OPT_fpic,
320  options::OPT_fPIC)) {
321  Gn = "0";
322  }
323 
324  unsigned G;
325  if (!Gn.getAsInteger(10, G))
326  return G;
327 
328  return None;
329 }
330 
331 void HexagonToolChain::getHexagonLibraryPaths(const ArgList &Args,
332  ToolChain::path_list &LibPaths) const {
333  const Driver &D = getDriver();
334 
335  //----------------------------------------------------------------------------
336  // -L Args
337  //----------------------------------------------------------------------------
338  for (Arg *A : Args.filtered(options::OPT_L))
339  for (const char *Value : A->getValues())
340  LibPaths.push_back(Value);
341 
342  //----------------------------------------------------------------------------
343  // Other standard paths
344  //----------------------------------------------------------------------------
345  std::vector<std::string> RootDirs;
346  std::copy(D.PrefixDirs.begin(), D.PrefixDirs.end(),
347  std::back_inserter(RootDirs));
348 
349  std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
350  D.PrefixDirs);
351  if (std::find(RootDirs.begin(), RootDirs.end(), TargetDir) == RootDirs.end())
352  RootDirs.push_back(TargetDir);
353 
354  bool HasPIC = Args.hasArg(options::OPT_fpic, options::OPT_fPIC);
355  // Assume G0 with -shared.
356  bool HasG0 = Args.hasArg(options::OPT_shared);
357  if (auto G = getSmallDataThreshold(Args))
358  HasG0 = G.getValue() == 0;
359 
360  const std::string CpuVer = GetTargetCPUVersion(Args).str();
361  for (auto &Dir : RootDirs) {
362  std::string LibDir = Dir + "/hexagon/lib";
363  std::string LibDirCpu = LibDir + '/' + CpuVer;
364  if (HasG0) {
365  if (HasPIC)
366  LibPaths.push_back(LibDirCpu + "/G0/pic");
367  LibPaths.push_back(LibDirCpu + "/G0");
368  }
369  LibPaths.push_back(LibDirCpu);
370  LibPaths.push_back(LibDir);
371  }
372 }
373 
374 HexagonToolChain::HexagonToolChain(const Driver &D, const llvm::Triple &Triple,
375  const llvm::opt::ArgList &Args)
376  : Linux(D, Triple, Args) {
377  const std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
378  D.PrefixDirs);
379 
380  // Note: Generic_GCC::Generic_GCC adds InstalledDir and getDriver().Dir to
381  // program paths
382  const std::string BinDir(TargetDir + "/bin");
383  if (D.getVFS().exists(BinDir))
384  getProgramPaths().push_back(BinDir);
385 
386  ToolChain::path_list &LibPaths = getFilePaths();
387 
388  // Remove paths added by Linux toolchain. Currently Hexagon_TC really targets
389  // 'elf' OS type, so the Linux paths are not appropriate. When we actually
390  // support 'linux' we'll need to fix this up
391  LibPaths.clear();
392  getHexagonLibraryPaths(Args, LibPaths);
393 }
394 
396 
398  return new tools::hexagon::Assembler(*this);
399 }
400 
402  return new tools::hexagon::Linker(*this);
403 }
404 
406  const llvm::opt::ArgList &DriverArgs) const {
407  // Copied in large part from lib/Frontend/CompilerInvocation.cpp.
408  Arg *A = DriverArgs.getLastArg(options::OPT_O_Group);
409  if (!A)
410  return 0;
411 
412  if (A->getOption().matches(options::OPT_O0))
413  return 0;
414  if (A->getOption().matches(options::OPT_Ofast) ||
415  A->getOption().matches(options::OPT_O4))
416  return 3;
417  assert(A->getNumValues() != 0);
418  StringRef S(A->getValue());
419  if (S == "s" || S == "z" || S.empty())
420  return 2;
421  if (S == "g")
422  return 1;
423 
424  unsigned OptLevel;
425  if (S.getAsInteger(10, OptLevel))
426  return 0;
427  return OptLevel;
428 }
429 
430 void HexagonToolChain::addClangTargetOptions(const ArgList &DriverArgs,
431  ArgStringList &CC1Args,
432  Action::OffloadKind) const {
433  if (DriverArgs.hasArg(options::OPT_ffp_contract))
434  return;
435  unsigned OptLevel = getOptimizationLevel(DriverArgs);
436  if (OptLevel >= 3)
437  CC1Args.push_back("-ffp-contract=fast");
438 }
439 
440 void HexagonToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
441  ArgStringList &CC1Args) const {
442  if (DriverArgs.hasArg(options::OPT_nostdinc) ||
443  DriverArgs.hasArg(options::OPT_nostdlibinc))
444  return;
445 
446  const Driver &D = getDriver();
447  std::string TargetDir = getHexagonTargetDir(D.getInstalledDir(),
448  D.PrefixDirs);
449  addExternCSystemInclude(DriverArgs, CC1Args, TargetDir + "/hexagon/include");
450 }
451 
452 
454  const llvm::opt::ArgList &DriverArgs,
455  llvm::opt::ArgStringList &CC1Args) const {
456  const Driver &D = getDriver();
457  std::string TargetDir = getHexagonTargetDir(D.InstalledDir, D.PrefixDirs);
458  addLibStdCXXIncludePaths(TargetDir, "/hexagon/include/c++", "", "", "", "",
459  DriverArgs, CC1Args);
460 }
461 
463 HexagonToolChain::GetCXXStdlibType(const ArgList &Args) const {
464  Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
465  if (!A)
467 
468  StringRef Value = A->getValue();
469  if (Value != "libstdc++")
470  getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
471 
473 }
474 
475 //
476 // Returns the default CPU for Hexagon. This is the default compilation target
477 // if no Hexagon processor is selected at the command-line.
478 //
480  return "hexagonv60";
481 }
482 
483 const StringRef HexagonToolChain::GetTargetCPUVersion(const ArgList &Args) {
484  Arg *CpuArg = nullptr;
485  if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ, options::OPT_march_EQ))
486  CpuArg = A;
487 
488  StringRef CPU = CpuArg ? CpuArg->getValue() : GetDefaultCPU();
489  if (CPU.startswith("hexagon"))
490  return CPU.substr(sizeof("hexagon") - 1);
491  return CPU;
492 }
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:613
prefix_list PrefixDirs
Definition: Driver.h:143
void getHexagonLibraryPaths(const llvm::opt::ArgList &Args, ToolChain::path_list &LibPaths) const
Definition: Hexagon.cpp:331
StringRef P
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:109
bool isFilename() const
Definition: InputInfo.h:76
DiagnosticBuilder Diag(unsigned DiagID) const
Definition: Driver.h:116
virtual void RenderExtraToolArgs(const JobAction &JA, llvm::opt::ArgStringList &CmdArgs) const
Definition: Hexagon.cpp:104
std::string getHexagonTargetDir(const std::string &InstalledDir, const SmallVectorImpl< std::string > &PrefixDirs) const
Hexagon Toolchain.
Definition: Hexagon.cpp:297
bool CCCIsCXX() const
Whether the driver should follow g++ like behavior.
Definition: Driver.h:174
path_list & getProgramPaths()
Definition: ToolChain.h:175
const char * getInstalledDir() const
Get the path to where the clang executable was installed.
Definition: Driver.h:299
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:23
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:651
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:430
path_list & getFilePaths()
Definition: ToolChain.h:172
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:65
const Driver & getDriver() const
Definition: ToolChain.h:142
detail::InMemoryDirectory::const_iterator I
void addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Definition: Hexagon.cpp:453
static const StringRef GetTargetCPUVersion(const llvm::opt::ArgList &Args)
Definition: Hexagon.cpp:483
void addCommand(std::unique_ptr< Command > C)
Definition: Compilation.h:189
vfs::FileSystem & getVFS() const
Definition: Driver.h:284
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:440
const char * getFilename() const
Definition: InputInfo.h:84
unsigned getOptimizationLevel(const llvm::opt::ArgList &DriverArgs) const
Definition: Hexagon.cpp:405
std::string InstalledDir
The path to the installed clang directory, if any.
Definition: Driver.h:133
void RenderExtraToolArgs(const JobAction &JA, llvm::opt::ArgStringList &CmdArgs) const
Definition: Hexagon.cpp:31
Tool * buildAssembler() const override
Definition: Hexagon.cpp:397
CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override
Definition: Hexagon.cpp:463
StringRef Name
Definition: USRFinder.cpp:123
void AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const JobAction &JA)
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)
bool exists(const Twine &Path)
Check whether a file exists. Provided for convenience.
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:2386
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:34
static Optional< unsigned > getSmallDataThreshold(const llvm::opt::ArgList &Args)
Definition: Hexagon.cpp:314
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:35
bool isNothing() const
Definition: InputInfo.h:75
static const StringRef GetDefaultCPU()
Definition: Hexagon.cpp:479
std::vector< std::string > ExtraOpts
Definition: Linux.h:46
bool isLLVMIR(ID Id)
Is this LLVM IR.
Definition: Types.cpp:148
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:278
std::string GetFilePath(const char *Name) const
Definition: ToolChain.cpp:367