| 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 "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/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->getSpelling() << 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 |
|
| 178 |
Tool *MSP430ToolChain::buildLinker() const { |
| 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 |
} |