Home | History | Annotate | Line # | Download | only in ToolChains
MSP430.cpp revision 1.1.1.2 
      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, "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 }
    319