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