clang 10.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"
13 #include "clang/Driver/Compilation.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, "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 GCCInstallation.getTriple().str());
143 else
144 llvm::sys::path::append(Dir, getDriver().Dir, "..", getTriple().str());
145
146 return Dir.str();
147 }
148
149 void MSP430ToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
150 ArgStringList &CC1Args) const {
151 if (DriverArgs.hasArg(options::OPT_nostdinc) ||
152 DriverArgs.hasArg(options::OPT_nostdlibinc))
153 return;
154
155 SmallString<128> Dir(computeSysRoot());
156 llvm::sys::path::append(Dir, "include");
157 addSystemInclude(DriverArgs, CC1Args, Dir.str());
158 }
159
160 void MSP430ToolChain::addClangTargetOptions(const ArgList &DriverArgs,
161 ArgStringList &CC1Args,
162 Action::OffloadKind) const {
163 CC1Args.push_back("-nostdsysteminc");
164
165 const auto *MCUArg = DriverArgs.getLastArg(options::OPT_mmcu_EQ);
166 if (!MCUArg)
167 return;
168
169 const StringRef MCU = MCUArg->getValue();
170 if (MCU.startswith("msp430i")) {
171 // 'i' should be in lower case as it's defined in TI MSP430-GCC headers
172 CC1Args.push_back(DriverArgs.MakeArgString(
173 "-D__MSP430i" + MCU.drop_front(7).upper() + "__"));
174 } else {
175 CC1Args.push_back(DriverArgs.MakeArgString("-D__" + MCU.upper() + "__"));
176 }
177 }
178
179 Tool *MSP430ToolChain::buildLinker() const {
180 return new tools::msp430::Linker(*this);
181 }
182
183 void msp430::Linker::ConstructJob(Compilation &C, const JobAction &JA,
184 const InputInfo &Output,
185 const InputInfoList &Inputs,
186 const ArgList &Args,
187 const char *LinkingOutput) const {
188 const ToolChain &ToolChain = getToolChain();
189 const Driver &D = ToolChain.getDriver();
190 std::string Linker = ToolChain.GetProgramPath(getShortName());
191 ArgStringList CmdArgs;
192
193 if (!D.SysRoot.empty())
194 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
195
196 Args.AddAllArgs(CmdArgs, options::OPT_L);
197 ToolChain.AddFilePathLibArgs(Args, CmdArgs);
198
199 if (!Args.hasArg(options::OPT_T)) {
200 if (const Arg *MCUArg = Args.getLastArg(options::OPT_mmcu_EQ))
201 CmdArgs.push_back(
202 Args.MakeArgString("-T" + StringRef(MCUArg->getValue()) + ".ld"));
203 } else {
204 Args.AddAllArgs(CmdArgs, options::OPT_T);
205 }
206
207 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
208 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt0.o")));
209 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtbegin.o")));
210 }
211
212 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA);
213
214 CmdArgs.push_back("--start-group");
215 CmdArgs.push_back(Args.MakeArgString(getHWMultLib(Args)));
216 CmdArgs.push_back("-lgcc");
217 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
218 CmdArgs.push_back("-lc");
219 CmdArgs.push_back("-lcrt");
220 CmdArgs.push_back("-lnosys");
221 }
222 CmdArgs.push_back("--end-group");
223
224 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
225 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
226 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
227 }
228 CmdArgs.push_back("-o");
229 CmdArgs.push_back(Output.getFilename());
230 C.addCommand(std::make_unique<Command>(JA, *this, Args.MakeArgString(Linker),
231 CmdArgs, Inputs));
232 }
clang::driver::toolchains::MSP430ToolChain::buildLinker
Tool * buildLinker() const override
Definition: MSP430.cpp:179
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::getTriple
const llvm::Triple & getTriple() const
Get the GCC triple for the detected install.
Definition: Gnu.h:219
clang::driver::Driver::Diag
DiagnosticBuilder Diag(unsigned DiagID) const
Definition: Driver.h:109
isSupportedMCU
static bool isSupportedMCU(const StringRef MCU)
Definition: MSP430.cpp:26
clang::driver::InputInfo::getFilename
const char * getFilename() const
Definition: InputInfo.h:83
clang::driver::toolchains::Generic_GCC::GCCInstallation
GCCInstallationDetector GCCInstallation
Definition: Gnu.h:279
MSP430_MCU
#define MSP430_MCU(NAME)
clang::driver::ToolChain::getProgramPaths
path_list & getProgramPaths()
Definition: ToolChain.h:240
CommonArgs.h
clang::driver::JobAction
Definition: Action.h:375
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::tools
Definition: AIX.h:17
clang::driver::InputInfo
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:22
clang::driver::ToolChain::GetFilePath
std::string GetFilePath(const char *Name) const
Definition: ToolChain.cpp:512
clang::driver::ToolChain::getFilePaths
path_list & getFilePaths()
Definition: ToolChain.h:237
clang::driver::Driver
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:59
llvm::SmallString< 128 >
Compilation.h
clang::driver::toolchains::Generic_ELF
Definition: Gnu.h:348
llvm::opt
Definition: Action.h:23
clang::driver::Compilation::addCommand
void addCommand(std::unique_ptr< Command > C)
Definition: Compilation.h:205
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:160
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:906
MSP430_MCU_FEAT
#define MSP430_MCU_FEAT(NAME, HWMULT)
clang::driver::ToolChain::getDriver
const Driver & getDriver() const
Definition: ToolChain.h:199
Multilib.h
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:35
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:820
Options.h
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::getParentLibPath
StringRef getParentLibPath() const
Get the detected GCC parent lib path.
Definition: Gnu.h:225
Gnu.h
clang::driver::Action::OffloadKind
OffloadKind
Definition: Action.h:84
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:21
clang::driver::tools::AddLinkerInputs
void AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const JobAction &JA)
clang::driver::Driver::SysRoot
std::string SysRoot
sysroot, if present
Definition: Driver.h:148
getHWMultLib
static StringRef getHWMultLib(const ArgList &Args)
Definition: MSP430.cpp:43
clang::driver::Tool
Tool - Information on a specific compilation tool.
Definition: Tool.h:33
InputInfo.h
clang::driver::tools::msp430::getMSP430TargetFeatures
void getMSP430TargetFeatures(const Driver &D, const llvm::opt::ArgList &Args, std::vector< llvm::StringRef > &Features)
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:149
clang::driver::Compilation
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:45
clang::driver::ToolChain::getTriple
const llvm::Triple & getTriple() const
Definition: ToolChain.h:201
clang::driver
Definition: Action.h:31
clang::driver::toolchains
Definition: AIX.h:55
clang::driver::ToolChain::GetProgramPath
std::string GetProgramPath(const char *Name) const
Definition: ToolChain.cpp:516
clang::driver::tools::msp430::Linker
Definition: MSP430.h:55
clang::driver::tools::addPathIfExists
void addPathIfExists(const Driver &D, const Twine &Path, ToolChain::path_list &Paths)
Definition: CommonArgs.cpp:61
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:1827
getSupportedHWMult
static StringRef getSupportedHWMult(const Arg *MCU)
Definition: MSP430.cpp:33
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::getInstallPath
StringRef getInstallPath() const
Get the detected GCC installation path.
Definition: Gnu.h:222
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::getMultilib
const Multilib & getMultilib() const
Get the detected Multilib.
Definition: Gnu.h:228
clang::driver::ToolChain
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:88
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::isValid
bool isValid() const
Check whether we detected a valid GCC install.
Definition: Gnu.h:216