clang  13.0.0git
MSP430.cpp
Go to the documentation of this file.
1 //===--- MSP430.cpp - MSP430 Helpers for Tools ------------------*- 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 "MSP430.h"
10 #include "CommonArgs.h"
11 #include "Gnu.h"
12 #include "InputInfo.h"
14 #include "clang/Driver/Multilib.h"
15 #include "clang/Driver/Options.h"
16 #include "llvm/Option/ArgList.h"
17 #include "llvm/Support/FileSystem.h"
18 #include "llvm/Support/Path.h"
19 
20 using namespace clang::driver;
21 using namespace clang::driver::toolchains;
22 using namespace clang::driver::tools;
23 using namespace clang;
24 using namespace llvm::opt;
25 
26 static bool isSupportedMCU(const StringRef MCU) {
27  return llvm::StringSwitch<bool>(MCU)
28 #define MSP430_MCU(NAME) .Case(NAME, true)
29 #include "clang/Basic/MSP430Target.def"
30  .Default(false);
31 }
32 
33 static StringRef getSupportedHWMult(const Arg *MCU) {
34  if (!MCU)
35  return "none";
36 
37  return llvm::StringSwitch<StringRef>(MCU->getValue())
38 #define MSP430_MCU_FEAT(NAME, HWMULT) .Case(NAME, HWMULT)
39 #include "clang/Basic/MSP430Target.def"
40  .Default("none");
41 }
42 
43 static StringRef getHWMultLib(const ArgList &Args) {
44  StringRef HWMult = Args.getLastArgValue(options::OPT_mhwmult_EQ, "auto");
45  if (HWMult == "auto") {
46  HWMult = getSupportedHWMult(Args.getLastArg(options::OPT_mmcu_EQ));
47  }
48 
49  return llvm::StringSwitch<StringRef>(HWMult)
50  .Case("16bit", "-lmul_16")
51  .Case("32bit", "-lmul_32")
52  .Case("f5series", "-lmul_f5")
53  .Default("-lmul_none");
54 }
55 
56 void msp430::getMSP430TargetFeatures(const Driver &D, const ArgList &Args,
57  std::vector<StringRef> &Features) {
58  const Arg *MCU = Args.getLastArg(options::OPT_mmcu_EQ);
59  if (MCU && !isSupportedMCU(MCU->getValue())) {
60  D.Diag(diag::err_drv_clang_unsupported) << MCU->getValue();
61  return;
62  }
63 
64  const Arg *HWMultArg = Args.getLastArg(options::OPT_mhwmult_EQ);
65  if (!MCU && !HWMultArg)
66  return;
67 
68  StringRef HWMult = HWMultArg ? HWMultArg->getValue() : "auto";
69  StringRef SupportedHWMult = getSupportedHWMult(MCU);
70 
71  if (HWMult == "auto") {
72  // 'auto' - deduce hw multiplier support based on mcu name provided.
73  // If no mcu name is provided, assume no hw multiplier is supported.
74  if (!MCU)
75  D.Diag(clang::diag::warn_drv_msp430_hwmult_no_device);
76  HWMult = SupportedHWMult;
77  }
78 
79  if (HWMult == "none") {
80  // 'none' - disable hw multiplier.
81  Features.push_back("-hwmult16");
82  Features.push_back("-hwmult32");
83  Features.push_back("-hwmultf5");
84  return;
85  }
86 
87  if (MCU && SupportedHWMult == "none")
88  D.Diag(clang::diag::warn_drv_msp430_hwmult_unsupported) << HWMult;
89  if (MCU && HWMult != SupportedHWMult)
90  D.Diag(clang::diag::warn_drv_msp430_hwmult_mismatch)
91  << SupportedHWMult << HWMult;
92 
93  if (HWMult == "16bit") {
94  // '16bit' - for 16-bit only hw multiplier.
95  Features.push_back("+hwmult16");
96  } else if (HWMult == "32bit") {
97  // '32bit' - for 16/32-bit hw multiplier.
98  Features.push_back("+hwmult32");
99  } else if (HWMult == "f5series") {
100  // 'f5series' - for 16/32-bit hw multiplier supported by F5 series mcus.
101  Features.push_back("+hwmultf5");
102  } else {
103  D.Diag(clang::diag::err_drv_unsupported_option_argument)
104  << HWMultArg->getAsString(Args) << HWMult;
105  }
106 }
107 
108 /// MSP430 Toolchain
109 MSP430ToolChain::MSP430ToolChain(const Driver &D, const llvm::Triple &Triple,
110  const ArgList &Args)
111  : Generic_ELF(D, Triple, Args) {
112 
113  StringRef MultilibSuf = "";
114 
115  GCCInstallation.init(Triple, Args);
116  if (GCCInstallation.isValid()) {
117  MultilibSuf = GCCInstallation.getMultilib().gccSuffix();
118 
119  SmallString<128> GCCBinPath;
120  llvm::sys::path::append(GCCBinPath,
121  GCCInstallation.getParentLibPath(), "..", "bin");
122  addPathIfExists(D, GCCBinPath, getProgramPaths());
123 
124  SmallString<128> GCCRtPath;
125  llvm::sys::path::append(GCCRtPath,
126  GCCInstallation.getInstallPath(), MultilibSuf);
127  addPathIfExists(D, GCCRtPath, getFilePaths());
128  }
129 
130  SmallString<128> SysRootDir(computeSysRoot());
131  llvm::sys::path::append(SysRootDir, "msp430-elf", "lib", MultilibSuf);
132  addPathIfExists(D, SysRootDir, getFilePaths());
133 }
134 
135 std::string MSP430ToolChain::computeSysRoot() const {
136  if (!getDriver().SysRoot.empty())
137  return getDriver().SysRoot;
138 
139  SmallString<128> Dir;
140  if (GCCInstallation.isValid())
141  llvm::sys::path::append(Dir, GCCInstallation.getParentLibPath(), "..");
142  else
143  llvm::sys::path::append(Dir, getDriver().Dir, "..");
144 
145  return std::string(Dir.str());
146 }
147 
148 void MSP430ToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
149  ArgStringList &CC1Args) const {
150  if (DriverArgs.hasArg(options::OPT_nostdinc) ||
151  DriverArgs.hasArg(options::OPT_nostdlibinc))
152  return;
153 
154  SmallString<128> Dir(computeSysRoot());
155  llvm::sys::path::append(Dir, "msp430-elf", "include");
156  addSystemInclude(DriverArgs, CC1Args, Dir.str());
157 }
158 
159 void MSP430ToolChain::addClangTargetOptions(const ArgList &DriverArgs,
160  ArgStringList &CC1Args,
161  Action::OffloadKind) const {
162  CC1Args.push_back("-nostdsysteminc");
163 
164  const auto *MCUArg = DriverArgs.getLastArg(options::OPT_mmcu_EQ);
165  if (!MCUArg)
166  return;
167 
168  const StringRef MCU = MCUArg->getValue();
169  if (MCU.startswith("msp430i")) {
170  // 'i' should be in lower case as it's defined in TI MSP430-GCC headers
171  CC1Args.push_back(DriverArgs.MakeArgString(
172  "-D__MSP430i" + MCU.drop_front(7).upper() + "__"));
173  } else {
174  CC1Args.push_back(DriverArgs.MakeArgString("-D__" + MCU.upper() + "__"));
175  }
176 }
177 
179  return new tools::msp430::Linker(*this);
180 }
181 
182 void msp430::Linker::AddStartFiles(bool UseExceptions, const ArgList &Args,
183  ArgStringList &CmdArgs) const {
184  const ToolChain &ToolChain = getToolChain();
185 
186  CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt0.o")));
187  const char *crtbegin = UseExceptions ? "crtbegin.o" : "crtbegin_no_eh.o";
188  CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
189 }
190 
191 void msp430::Linker::AddDefaultLibs(const llvm::opt::ArgList &Args,
192  llvm::opt::ArgStringList &CmdArgs) const {
193  const ToolChain &ToolChain = getToolChain();
194  const Driver &D = ToolChain.getDriver();
195 
196  CmdArgs.push_back("--start-group");
197  CmdArgs.push_back(Args.MakeArgString(getHWMultLib(Args)));
198  CmdArgs.push_back("-lc");
199  AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
200  CmdArgs.push_back("-lcrt");
201 
202  if (Args.hasArg(options::OPT_msim)) {
203  CmdArgs.push_back("-lsim");
204 
205  // msp430-sim.ld relies on __crt0_call_exit being implicitly .refsym-ed
206  // in main() by msp430-gcc.
207  // This workaround should work seamlessly unless the compilation unit that
208  // contains main() is compiled by clang and then passed to
209  // gcc compiler driver for linkage.
210  CmdArgs.push_back("--undefined=__crt0_call_exit");
211  } else
212  CmdArgs.push_back("-lnosys");
213 
214  CmdArgs.push_back("--end-group");
215  AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
216 }
217 
218 void msp430::Linker::AddEndFiles(bool UseExceptions, const ArgList &Args,
219  ArgStringList &CmdArgs) const {
220  const ToolChain &ToolChain = getToolChain();
221  const Driver &D = ToolChain.getDriver();
222 
223  const char *crtend = UseExceptions ? "crtend.o" : "crtend_no_eh.o";
224  CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
225  AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
226 }
227 
228 static void AddSspArgs(const ArgList &Args, ArgStringList &CmdArgs) {
229  Arg *SspFlag = Args.getLastArg(
230  options::OPT_fno_stack_protector, options::OPT_fstack_protector,
231  options::OPT_fstack_protector_all, options::OPT_fstack_protector_strong);
232 
233  if (SspFlag &&
234  !SspFlag->getOption().matches(options::OPT_fno_stack_protector)) {
235  CmdArgs.push_back("-lssp_nonshared");
236  CmdArgs.push_back("-lssp");
237  }
238 }
239 
240 static void AddImplicitLinkerScript(const std::string SysRoot,
241  const ArgList &Args,
242  ArgStringList &CmdArgs) {
243  if (Args.hasArg(options::OPT_T))
244  return;
245 
246  if (Args.hasArg(options::OPT_msim)) {
247  CmdArgs.push_back("-Tmsp430-sim.ld");
248  return;
249  }
250 
251  const Arg *MCUArg = Args.getLastArg(options::OPT_mmcu_EQ);
252  if (!MCUArg)
253  return;
254 
255  SmallString<128> MCULinkerScriptPath(SysRoot);
256  llvm::sys::path::append(MCULinkerScriptPath, "include");
257  // -L because <mcu>.ld INCLUDEs <mcu>_symbols.ld
258  CmdArgs.push_back(Args.MakeArgString("-L" + MCULinkerScriptPath));
259  CmdArgs.push_back(
260  Args.MakeArgString("-T" + StringRef(MCUArg->getValue()) + ".ld"));
261 }
262 
263 void msp430::Linker::ConstructJob(Compilation &C, const JobAction &JA,
264  const InputInfo &Output,
265  const InputInfoList &Inputs,
266  const ArgList &Args,
267  const char *LinkingOutput) const {
268  const ToolChain &ToolChain = getToolChain();
269  const Driver &D = ToolChain.getDriver();
270  std::string Linker = ToolChain.GetProgramPath(getShortName());
271  ArgStringList CmdArgs;
272  bool UseExceptions = Args.hasFlag(options::OPT_fexceptions,
273  options::OPT_fno_exceptions, false);
274  bool UseStartAndEndFiles = !Args.hasArg(options::OPT_nostdlib, options::OPT_r,
275  options::OPT_nostartfiles);
276 
277  if (Args.hasArg(options::OPT_mrelax))
278  CmdArgs.push_back("--relax");
279  if (!Args.hasArg(options::OPT_r, options::OPT_g_Group))
280  CmdArgs.push_back("--gc-sections");
281 
282  Args.AddAllArgs(CmdArgs, {
283  options::OPT_e,
284  options::OPT_n,
285  options::OPT_s,
286  options::OPT_t,
287  options::OPT_u,
288  });
289 
290  if (UseStartAndEndFiles)
291  AddStartFiles(UseExceptions, Args, CmdArgs);
292 
293  Args.AddAllArgs(CmdArgs, options::OPT_L);
294  ToolChain.AddFilePathLibArgs(Args, CmdArgs);
295  AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA);
296 
297  if (!Args.hasArg(options::OPT_nostdlib, options::OPT_r,
298  options::OPT_nodefaultlibs)) {
299  AddSspArgs(Args, CmdArgs);
300  AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
301  if (!Args.hasArg(options::OPT_nolibc)) {
302  AddDefaultLibs(Args, CmdArgs);
303  AddImplicitLinkerScript(D.SysRoot, Args, CmdArgs);
304  }
305  }
306 
307  if (UseStartAndEndFiles)
308  AddEndFiles(UseExceptions, Args, CmdArgs);
309 
310  CmdArgs.push_back("-o");
311  CmdArgs.push_back(Output.getFilename());
312 
313  Args.AddAllArgs(CmdArgs, options::OPT_T);
314 
315  C.addCommand(std::make_unique<Command>(
316  JA, *this, ResponseFileSupport::AtFileCurCP(), Args.MakeArgString(Linker),
317  CmdArgs, Inputs, Output));
318 }
clang::driver::toolchains
Definition: AIX.h:55
clang::driver::ToolChain::getProgramPaths
path_list & getProgramPaths()
Definition: ToolChain.h:255
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::driver::toolchains::MSP430ToolChain::MSP430ToolChain
MSP430ToolChain(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
MSP430 Toolchain.
Definition: MSP430.cpp:109
llvm::SmallVector
Definition: LLVM.h:38
clang::driver::toolchains::Generic_GCC::GCCInstallation
GCCInstallationDetector GCCInstallation
Definition: Gnu.h:288
clang::driver::ToolChain::GetProgramPath
std::string GetProgramPath(const char *Name) const
Definition: ToolChain.cpp:561
clang::driver::tools::msp430::Linker
Definition: MSP430.h:60
clang::driver::tools
Definition: AIX.h:17
clang::driver::ToolChain::getDriver
const Driver & getDriver() const
Definition: ToolChain.h:214
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::isValid
bool isValid() const
Check whether we detected a valid GCC install.
Definition: Gnu.h:224
clang::driver::ToolChain::GetFilePath
std::string GetFilePath(const char *Name) const
Definition: ToolChain.cpp:557
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::init
void init(const llvm::Triple &TargetTriple, const llvm::opt::ArgList &Args, ArrayRef< std::string > ExtraTripleAliases=None)
Initialize a GCCInstallationDetector from the driver.
Definition: Gnu.cpp:1896
clang::driver::InputInfo
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:22
InputInfo.h
getSupportedHWMult
static StringRef getSupportedHWMult(const Arg *MCU)
Definition: MSP430.cpp:33
clang::driver::tools::AddLinkerInputs
void AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const JobAction &JA)
AddSspArgs
static void AddSspArgs(const ArgList &Args, ArgStringList &CmdArgs)
Definition: MSP430.cpp:228
clang::driver::ToolChain::getFilePaths
path_list & getFilePaths()
Definition: ToolChain.h:252
clang::driver::Driver::Diag
DiagnosticBuilder Diag(unsigned DiagID) const
Definition: Driver.h:109
clang::driver::Multilib::gccSuffix
const std::string & gccSuffix() const
Get the detected GCC installation path suffix for the multi-arch target variant.
Definition: Multilib.h:45
clang::driver::Tool
Tool - Information on a specific compilation tool.
Definition: Tool.h:32
clang::driver::toolchains::Generic_ELF
Definition: Gnu.h:367
Options.h
llvm::opt
Definition: DiagnosticOptions.h:19
clang::driver::ResponseFileSupport::AtFileCurCP
static constexpr ResponseFileSupport AtFileCurCP()
Definition: Job.h:91
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::getParentLibPath
StringRef getParentLibPath() const
Get the detected GCC parent lib path.
Definition: Gnu.h:233
clang::driver::tools::addPathIfExists
void addPathIfExists(const Driver &D, const Twine &Path, ToolChain::path_list &Paths)
Definition: CommonArgs.cpp:121
llvm::SmallString< 128 >
clang::driver::Driver::SysRoot
std::string SysRoot
sysroot, if present
Definition: Driver.h:148
isSupportedMCU
static bool isSupportedMCU(const StringRef MCU)
Definition: MSP430.cpp:26
MSP430.h
clang::driver::ToolChain::AddFilePathLibArgs
void AddFilePathLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
AddFilePathLibArgs - Add each thing in getFilePaths() as a "-L" option.
Definition: ToolChain.cpp:972
Compilation.h
Gnu.h
clang::driver::ToolChain
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:91
clang::driver::tools::AddRunTimeLibs
void AddRunTimeLibs(const ToolChain &TC, const Driver &D, llvm::opt::ArgStringList &CmdArgs, const llvm::opt::ArgList &Args)
AddImplicitLinkerScript
static void AddImplicitLinkerScript(const std::string SysRoot, const ArgList &Args, ArgStringList &CmdArgs)
Definition: MSP430.cpp:240
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::getInstallPath
StringRef getInstallPath() const
Get the detected GCC installation path.
Definition: Gnu.h:230
clang::driver::toolchains::MSP430ToolChain::AddClangSystemIncludeArgs
void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add the clang cc1 arguments for system include paths.
Definition: MSP430.cpp:148
clang::driver::Compilation
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:45
clang::driver::toolchains::MSP430ToolChain::buildLinker
Tool * buildLinker() const override
Definition: MSP430.cpp:178
clang::driver::InputInfo::getFilename
const char * getFilename() const
Definition: InputInfo.h:83
getHWMultLib
static StringRef getHWMultLib(const ArgList &Args)
Definition: MSP430.cpp:43
CommonArgs.h
clang
Dataflow Directional Tag Classes.
Definition: CalledOnceCheck.h:17
clang::driver::Driver
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:59
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::getMultilib
const Multilib & getMultilib() const
Get the detected Multilib.
Definition: Gnu.h:236
clang::driver::tools::msp430::getMSP430TargetFeatures
void getMSP430TargetFeatures(const Driver &D, const llvm::opt::ArgList &Args, std::vector< llvm::StringRef > &Features)
clang::driver::toolchains::MSP430ToolChain::addClangTargetOptions
void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, Action::OffloadKind) const override
Add options that need to be passed to cc1 for this target.
Definition: MSP430.cpp:159
Multilib.h
clang::driver::Action::OffloadKind
OffloadKind
Definition: Action.h:85
clang::driver
Definition: Action.h:31
clang::driver::ToolChain::addSystemInclude
static void addSystemInclude(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, const Twine &Path)
Utility function to add a system include directory to CC1 arguments.
Definition: ToolChain.cpp:862
clang::driver::JobAction
Definition: Action.h:380