[MSP430][Clang] Infer CPU type from -mcpu= or -mmcu=

[jozefl]

Summary

clang::driver::tools::getCPUName can now infer the CPU being used by
examining either the MCU specified with the -mmcu= option, or the CPU
directly specified with -mcpu=.

This means Clang will now pass the correct "-target-cpu" to downstream
tools, enabling CPU-specific features in LLVM.

The MSP430X CPU can now be selected, in addition to the "generic" MSP430
CPU.

[jozefl]

Rebased onto current upstream.

[jozefl]

Updated patch to use hasFeature() to check for msp430x support, instead of a
new function.

Fixed use of tools::getCPUName() after rebase.

[jozefl]

Fix the msp430-toolchain.c test by adding some more Windows path separators to
the match patterns.

[jozefl]

Rebase.

[jozefl]

Pinging for review.

Thanks,
Jozef

[jozefl]

Rebase to fix patch application failure for
clang/test/Misc/target-invalid-cpu-note.c.

[jozefl]

Rebase after updates to parent revision D108301.

[jozefl]

Rebase onto new base revision to fix pre-merge tests.

[jozefl]

Ping.

Thanks,
Jozef

[jozefl]

Ping.

Thanks,
Jozef

[jozefl]

Ping.

Thanks,
Jozef

clang/include/clang/Basic/DiagnosticDriverKinds.td

def err_drv_trivial_auto_var_init_stop_after_missing_dependency : Error<
   "'-ftrivial-auto-var-init-stop-after=*' is used without "
   "'-ftrivial-auto-var-init=zero' or '-ftrivial-auto-var-init=pattern'">;
 
 def err_drv_trivial_auto_var_init_stop_after_invalid_value : Error<
   "'-ftrivial-auto-var-init-stop-after=*' only accepts positive integers">;
 
 def warn_drv_msp430_hwmult_unsupported : Warning<
   "the given MCU does not support hardware multiply, but '-mhwmult' is set to "
-  "%0">, InGroup<InvalidCommandLineArgument>;
+  "'%0'">, InGroup<InvalidCommandLineArgument>;
 def warn_drv_msp430_hwmult_mismatch : Warning<
-  "the given MCU supports %0 hardware multiply, but '-mhwmult' is set to %1">,
+  "the given MCU supports '%0' hardware multiply, but '-mhwmult' is set to '%1'">,
    InGroup<InvalidCommandLineArgument>;
 def warn_drv_msp430_hwmult_no_device : Warning<
   "no MCU device specified, but '-mhwmult' is set to 'auto', assuming no "
   "hardware multiply; use '-mmcu' to specify an MSP430 device, or '-mhwmult' "
   "to set the hardware multiply type explicitly">,
   InGroup<InvalidCommandLineArgument>;
+def warn_drv_msp430_cpu_mismatch : Warning<
+  "the given MCU supports the '%0' CPU, but '-mcpu' is set to '%1'">,
+   InGroup<InvalidCommandLineArgument>;
 
 def warn_drv_libstdcxx_not_found : Warning<
   "include path for libstdc++ headers not found; pass '-stdlib=libc++' on the "
   "command line to use the libc++ standard library instead">,
   InGroup<DiagGroup<"stdlibcxx-not-found">>;
 
 def err_drv_cannot_mix_options : Error<"cannot specify '%1' along with '%0'">;
 

clang/lib/Basic/Targets/MSP430.h

 #include "llvm/ADT/Triple.h"
 #include "llvm/Support/Compiler.h"
 
 namespace clang {
 namespace targets {
 
 class LLVM_LIBRARY_VISIBILITY MSP430TargetInfo : public TargetInfo {
   static const char *const GCCRegNames[];
+  static const llvm::StringLiteral ValidCPUNames[4];
+  std::string CPU;
 
 public:
   MSP430TargetInfo(const llvm::Triple &Triple, const TargetOptions &)
       : TargetInfo(Triple) {
     TLSSupported = false;
     IntWidth = 16;
     IntAlign = 16;
     LongWidth = 32;
public:
 
   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
     // FIXME: Implement.
     return None;
   }
 
   bool allowsLargerPreferedTypeAlignment() const override { return false; }
 
+  /// Check for support of feature \p Feature.
+  ///
+  /// Currently only the driver needs to know about hwmult features, so checking
+  /// their availability here is not required.
   bool hasFeature(StringRef Feature) const override {
-    return Feature == "msp430";
+    assert(Feature != "hwmult16" && Feature != "hwmult32" &&
+           Feature != "hwmultf5" && "unexpected check of hwmult feature");
+    if (Feature == "msp430")
+      return true;
+    if (Feature == "msp430x")
+      return llvm::StringSwitch<bool>(CPU)
+          .Case("msp430x", true)
+          .Case("msp430xv2", true)
+          .Default(false);
+    return false;
   }
 
   ArrayRef<const char *> getGCCRegNames() const override;
 
   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
     // Make r0 - r3 be recognized by llc (f.e., in clobber list)
     static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
         {{"r0"}, "pc"},
const char *getClobbers() const override {
     // FIXME: Is this really right?
     return "";
   }
 
   BuiltinVaListKind getBuiltinVaListKind() const override {
     // FIXME: implement
     return TargetInfo::CharPtrBuiltinVaList;
   }
+
+  bool
+  initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
+                 StringRef CPU,
+                 const std::vector<std::string> &FeaturesVec) const override {
+    Features["msp430x"] = hasFeature("msp430x");
+    return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
+  }
+
+  bool setCPU(const std::string &Name) override {
+    if (!isValidCPUName(Name))
+      return false;
+    CPU = Name;
+    return true;
+  }
+
+  void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override {
+    Values.append(std::begin(ValidCPUNames), std::end(ValidCPUNames));
+  }
+
+  bool isValidCPUName(StringRef Name) const override {
+    return llvm::find(ValidCPUNames, Name) != std::end(ValidCPUNames);
+  }
 };
 
 } // namespace targets
 } // namespace clang
 #endif // LLVM_CLANG_LIB_BASIC_TARGETS_MSP430_H

clang/lib/Basic/Targets/MSP430.cpp

 using namespace clang;
 using namespace clang::targets;
 
 const char *const MSP430TargetInfo::GCCRegNames[] = {
     "r0", "r1", "r2",  "r3",  "r4",  "r5",  "r6",  "r7",
     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
 };
 
+constexpr llvm::StringLiteral MSP430TargetInfo::ValidCPUNames[4] = {
+    {"generic"}, {"msp430"}, {"msp430x"}, {"msp430xv2"}};
+
 ArrayRef<const char *> MSP430TargetInfo::getGCCRegNames() const {
   return llvm::makeArrayRef(GCCRegNames);
 }
 
 void MSP430TargetInfo::getTargetDefines(const LangOptions &Opts,
                                         MacroBuilder &Builder) const {
   Builder.defineMacro("MSP430");
   Builder.defineMacro("__MSP430__");
   Builder.defineMacro("__ELF__");
   // FIXME: defines for different 'flavours' of MCU
+  if (hasFeature("msp430x"))
+    Builder.defineMacro("__MSP430X__");
 }

clang/lib/Driver/ToolChains/CommonArgs.cpp

 #include "Arch/M68k.h"
 #include "Arch/Mips.h"
 #include "Arch/PPC.h"
 #include "Arch/SystemZ.h"
 #include "Arch/VE.h"
 #include "Arch/X86.h"
 #include "HIP.h"
 #include "Hexagon.h"
+#include "MSP430.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/ObjCRuntime.h"
 #include "clang/Basic/Version.h"
 #include "clang/Config/config.h"
 #include "clang/Driver/Action.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Driver.h"
std::string tools::getCPUName(const Driver &D, const ArgList &Args,
   case llvm::Triple::mips64:
   case llvm::Triple::mips64el: {
     StringRef CPUName;
     StringRef ABIName;
     mips::getMipsCPUAndABI(Args, T, CPUName, ABIName);
     return std::string(CPUName);
   }
 
+  case llvm::Triple::msp430:
+    if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
+      return A->getValue();
+    if (const Arg *A = Args.getLastArg(options::OPT_mmcu_EQ))
+      return msp430::getMSP430CPUFromMCU(A->getValue());
+    return "msp430";
+
   case llvm::Triple::nvptx:
   case llvm::Triple::nvptx64:
     if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
       return A->getValue();
     return "";
 
   case llvm::Triple::ppc:
   case llvm::Triple::ppcle:

clang/lib/Driver/ToolChains/Gnu.cpp

if (AndroidArmMultilibs.select(Flags, Result.SelectedMultilib))
     Result.Multilibs = AndroidArmMultilibs;
 }
 
 static bool findMSP430Multilibs(const Driver &D,
                                 const llvm::Triple &TargetTriple,
                                 StringRef Path, const ArgList &Args,
                                 DetectedMultilibs &Result) {
   FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
-  Multilib WithoutExceptions = makeMultilib("/430").flag("-exceptions");
-  Multilib WithExceptions = makeMultilib("/430/exceptions").flag("+exceptions");
+  Multilib WithoutExceptions =
+      makeMultilib("/430").flag("-exceptions").flag("-msp430x");
+  Multilib WithExceptions =
+      makeMultilib("/430/exceptions").flag("+exceptions").flag("-msp430x");
+  Multilib WithoutExceptions430x =
+      makeMultilib("").flag("-exceptions").flag("+msp430x");
+  Multilib WithExceptions430x =
+      makeMultilib("/exceptions").flag("+exceptions").flag("+msp430x");
 
-  // FIXME: when clang starts to support msp430x ISA additional logic
-  // to select between multilib must be implemented
+  // FIXME: When LLVM starts to support the msp430x large memory model (20-bit
+  // pointers) additional logic to select between multilibs must be implemented.
   // Multilib MSP430xMultilib = makeMultilib("/large");
 
   Result.Multilibs.push_back(WithoutExceptions);
   Result.Multilibs.push_back(WithExceptions);
+  Result.Multilibs.push_back(WithoutExceptions430x);
+  Result.Multilibs.push_back(WithExceptions430x);
   Result.Multilibs.FilterOut(NonExistent);
 
   Multilib::flags_list Flags;
   addMultilibFlag(Args.hasFlag(options::OPT_fexceptions,
                                options::OPT_fno_exceptions, false),
                   "exceptions", Flags);
+
+  std::string CPUName = tools::getCPUName(D, Args, TargetTriple);
+  bool msp430x = (CPUName == "msp430x" || CPUName == "msp430xv2");
+  addMultilibFlag(msp430x, "msp430x", Flags);
   if (Result.Multilibs.select(Flags, Result.SelectedMultilib))
     return true;
 
   return false;
 }
 
 static void findRISCVBareMetalMultilibs(const Driver &D,
                                         const llvm::Triple &TargetTriple,

clang/lib/Driver/ToolChains/MSP430.h

private:
   void AddDefaultLibs(const llvm::opt::ArgList &Args,
                       llvm::opt::ArgStringList &CmdArgs) const;
   void AddEndFiles(bool UseExceptions, const llvm::opt::ArgList &Args,
                    llvm::opt::ArgStringList &CmdArgs) const;
 };
 
 void getMSP430TargetFeatures(const Driver &D, const llvm::opt::ArgList &Args,
                              std::vector<llvm::StringRef> &Features);
+std::string getMSP430CPUFromMCU(StringRef MCU);
+
 } // end namespace msp430
 } // end namespace tools
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_MSP430_H

clang/lib/Driver/ToolChains/MSP430.cpp

static void addHWMultFeature(const Driver &D, const ArgList &Args,
   assert((HWMult == "16bit" || HWMult == "32bit" || HWMult == "f5series") &&
          "unexpected HWMult value");
   Features.push_back(llvm::StringSwitch<StringRef>(HWMult)
                          .Case("16bit", "+hwmult16")
                          .Case("32bit", "+hwmult32")
                          .Case("f5series", "+hwmultf5"));
 }
 
-/// Process the -mmcu= and -mhwmult= options to determine the target features.
+/// Emit a warning if the \p SelectedCPU value passed to -mcpu= does not match
+/// the \p SupportedCPU extracted from the MCU data for the MCU selected with
+/// -mmcu=.
 ///
-/// This is the only time Clang will warn about conflicts between these options,
-/// or issues with the values passed to them.
+/// Clang's generic option processing handles invalid values passed to -mcpu=.
+static void validateSelectedCPU(const Driver &D, StringRef SelectedCPU,
+                                StringRef SupportedCPU) {
+  if (SelectedCPU == "generic")
+    SelectedCPU = "msp430";
+  if (SelectedCPU != SupportedCPU)
+    D.Diag(clang::diag::warn_drv_msp430_cpu_mismatch)
+        << SupportedCPU << SelectedCPU;
+}
+
+/// Return the supported CPU for the given MCU.
+///
+/// If the MCU is not valid, Clang has already emitted a warning, so just return
+/// the default "msp430" CPU.
+std::string msp430::getMSP430CPUFromMCU(StringRef MCU) {
+  return std::string(getMCUData(MCU).CPU);
+}
+
+/// Process the -mmcu=, -mcpu= and -mhwmult= options to determine the target
+/// features.
+///
+/// Emit warnings if the selected MCU does not support the selected CPU or
+/// hardware multiply version.
 void msp430::getMSP430TargetFeatures(const Driver &D, const ArgList &Args,
                                      std::vector<StringRef> &Features) {
   const Arg *MCUArg = Args.getLastArg(options::OPT_mmcu_EQ);
   StringRef SupportedHWMult;
+
   if (MCUArg) {
     MCUData LoadedMCUData = getMCUData(MCUArg->getValue());
     if (!LoadedMCUData.isValid()) {
       D.Diag(diag::err_drv_clang_unsupported) << MCUArg->getValue();
       return;
     }
     SupportedHWMult = LoadedMCUData.HWMult;
+    if (const Arg *CPUArg = Args.getLastArg(options::OPT_mcpu_EQ))
+      validateSelectedCPU(D, CPUArg->getValue(), LoadedMCUData.CPU);
   }
 
   addHWMultFeature(D, Args, SupportedHWMult, Features);
 }
 
 /// MSP430 Toolchain
 MSP430ToolChain::MSP430ToolChain(const Driver &D, const llvm::Triple &Triple,
                                  const ArgList &Args)

clang/test/Driver/msp430-cpu.c

+// Check the correct translation of -mcpu= to -target-cpu.
+
+// RUN: %clang -target msp430 -mcpu=generic -### -c %s 2>&1 | FileCheck -check-prefix=GENERIC %s
+// GENERIC: "-cc1"{{.*}} "-target-cpu" "generic"
+
+// RUN: %clang -target msp430 -### -c %s 2>&1 | FileCheck -check-prefix=MSP430 %s
+// RUN: %clang -target msp430 -mcpu=msp430 -### -c %s 2>&1 | FileCheck -check-prefix=MSP430 %s
+// MSP430: "-cc1"{{.*}} "-target-cpu" "msp430"
+
+// RUN: %clang -target msp430 -mcpu=msp430x -### -c %s 2>&1 | FileCheck -check-prefix=MSP430X %s
+// MSP430X: "-cc1"{{.*}} "-target-cpu" "msp430x"
+
+// RUN: %clang -target msp430 -mcpu=msp430xv2 -### -c %s 2>&1 | FileCheck -check-prefix=MSP430XV2 %s
+// MSP430XV2: "-cc1"{{.*}} "-target-cpu" "msp430xv2"
+
+// Test that Clang emits an error on an invalid value passed to -mcpu=.
+// RUN: not %clang  -target msp430 -mcpu=msp430xv3 -v -c %s 2>&1 | FileCheck -check-prefix=MSP430XV3 %s
+// MSP430XV3: error: unknown target CPU 'msp430xv3'
+// MSP430XV3-NEXT: note: valid target CPU values are: generic, msp430, msp430x, msp430xv2

clang/test/Driver/msp430-mmcu.c

 
 // Test the symbol definitions, linker scripts and hardware multiply features
 // selected for different MCUs.
 
 // RUN: %clang %s -### -no-canonical-prefixes -target msp430 -mmcu=msp430c111 2>&1 \
 // RUN:   | FileCheck -check-prefix=MSP430-C111 %s
 
 // MSP430-C111: clang{{.*}} "-cc1" {{.*}} "-D__MSP430C111__"
+// MSP430-C111: "-target-cpu" "msp430"
 // MSP430-C111-NOT: "-target-feature" "+hwmult16"
 // MSP430-C111-NOT: "-target-feature" "+hwmult32"
 // MSP430-C111-NOT: "-target-feature" "+hwmultf5"
 // MSP430-C111: msp430-elf-ld{{.*}} "-Tmsp430c111.ld"
 
 // RUN: %clang %s -### -no-canonical-prefixes -target msp430 -mmcu=msp430i2020 2>&1 \
 // RUN:   | FileCheck -check-prefix=MSP430-I2020 %s
 
 // MSP430-I2020: clang{{.*}} "-cc1" {{.*}} "-D__MSP430i2020__"
+// MSP430-I2020: "-target-cpu" "msp430"
 // MSP430-I2020: "-target-feature" "+hwmult16"
 // MSP430-I2020: msp430-elf-ld{{.*}} "-Tmsp430i2020.ld"
 
 // RUN: %clang %s -### -no-canonical-prefixes -target msp430 -mmcu=msp430f47126 2>&1 \
 // RUN:   | FileCheck -check-prefix=MSP430-F47126 %s
 
 // MSP430-F47126: clang{{.*}} "-cc1" {{.*}} "-D__MSP430F47126__"
+// MSP430-F47126: "-target-cpu" "msp430x"
 // MSP430-F47126: "-target-feature" "+hwmult32"
 // MSP430-F47126: msp430-elf-ld{{.*}} "-Tmsp430f47126.ld"
 
 // RAN: %clang %s -### -no-canonical-prefixes -target msp430 -mmcu=msp430fr5969 2>&1 \
 // RAN:   | FileCheck -check-prefix=MSP430-FR5969 %s
 
 // MSP430-FR5969: clang{{.*}} "-cc1" {{.*}} "-D__MSP430FR5969__"
+// MSP430-FR5969: "-target-cpu" "msp430xv2"
 // MSP430-FR5969: "-target-feature" "+hwmultf5"
 // MSP430-FR5969: msp430-elf-ld{{.*}} "-Tmsp430fr5969.ld"
 
 // Test for the error message emitted when an invalid MCU is selected.
 //
 // Note that if this test is ever modified because the expected error message is
 // changed, the check prefixes at the top of this file, used to validate the
 // ordering of the hard-coded MCU data, also need to be updated.
 //
 // RUN: %clang %s -### -no-canonical-prefixes -target msp430 -mmcu=not-a-mcu 2>&1 \
 // RUN:   | FileCheck -check-prefix=MSP430-UNSUP %s
 
 // MSP430-UNSUP: error: the clang compiler does not support 'not-a-mcu'
 
 // The generic MCU name "msp430" is not supported.
 // RUN: %clang %s -### -no-canonical-prefixes -target msp430 -mmcu=msp430 2>&1 \
 // RUN:   | FileCheck -check-prefix=MSP430 %s
 
 // MSP430: error: the clang compiler does not support 'msp430'
+
+// Test that the CPU derived from -mmcu= can be overriden with -mcpu=, but that a
+// warning will be emitted.
+
+// RUN: %clang %s -### -no-canonical-prefixes -target msp430 -mmcu=msp430fr5969 \
+// RUN:    -mcpu=msp430x 2>&1 | FileCheck -check-prefix=MSP430-FR5969-430X %s
+
+// MSP430-FR5969-430X: warning: the given MCU supports the 'msp430xv2' CPU, but '-mcpu' is set to 'msp430x'
+// MSP430-FR5969-430X: clang{{.*}} "-cc1" {{.*}} "-D__MSP430FR5969__"
+// MSP430-FR5969-430X: "-target-cpu" "msp430x"
+// MSP430-FR5969-430X: "-target-feature" "+hwmultf5"
+// MSP430-FR5969-430X: msp430-elf-ld{{.*}} "-Tmsp430fr5969.ld"
+
+// RUN: %clang %s -### -no-canonical-prefixes -target msp430 -mmcu=msp430fr5969 \
+// RUN:    -mcpu=msp430 2>&1 | FileCheck -check-prefix=MSP430-FR5969-430 %s
+
+// MSP430-FR5969-430: warning: the given MCU supports the 'msp430xv2' CPU, but '-mcpu' is set to 'msp430'
+// MSP430-FR5969-430: clang{{.*}} "-cc1" {{.*}} "-D__MSP430FR5969__"
+// MSP430-FR5969-430: "-target-cpu" "msp430"
+// MSP430-FR5969-430: "-target-feature" "+hwmultf5"
+// MSP430-FR5969-430: msp430-elf-ld{{.*}} "-Tmsp430fr5969.ld"
+
+// RUN: %clang %s -### -no-canonical-prefixes -target msp430 -mmcu=msp430c111 \
+// RUN:    -mcpu=msp430x 2>&1 | FileCheck -check-prefix=MSP430-C111-430X %s
+
+// MSP430-C111-430X: warning: the given MCU supports the 'msp430' CPU, but '-mcpu' is set to 'msp430x'
+// MSP430-C111-430X: clang{{.*}} "-cc1" {{.*}} "-D__MSP430C111__"
+// MSP430-C111-430X: "-target-cpu" "msp430x"
+// MSP430-C111-430X: msp430-elf-ld{{.*}} "-Tmsp430c111.ld"
+
+// Test that the CPU name "generic" implies the "msp430" CPU when checking for
+// CPU compatibility.
+//
+// RUN: %clang %s -### -no-canonical-prefixes -target msp430 -mmcu=msp430c111 \
+// RUN:    -mcpu=generic 2>&1 | FileCheck -check-prefix=MSP430-C111-GENERIC %s
+
+// MSP430-C111-GENERIC-NOT: warning:
+// MSP430-C111-GENERIC: clang{{.*}} "-cc1" {{.*}} "-D__MSP430C111__"
+// MSP430-C111-GENERIC: "-target-cpu" "generic"
+// MSP430-C111-GENERIC: msp430-elf-ld{{.*}} "-Tmsp430c111.ld"

clang/test/Driver/msp430-toolchain.c

 // MISC-FLAGS-2-POS: "{{.*}}msp430-elf-ld"
 // MISC-FLAGS-2-POS: "-e" "EntryPoint" "-s" "-u" "__undef"
 // MISC-FLAGS-2-NEG: "{{.*}}msp430-elf-ld"
 // MISC-FLAGS-2-NEG-NOT: "-r"
 // MISC-FLAGS-2-NEG-NOT: "-t"
 // MISC-FLAGS-2-NEG-NOT: "-z"
 // MISC-FLAGS-2-NEG-NOT: "--relax"
 
-// Tests for -nostdlib, -nostartfiles, -nodefaultfiles and -f(no-)exceptions
-
 // RUN: %clang %s -### -no-canonical-prefixes -target msp430 -rtlib=libgcc \
 // RUN:   --sysroot="%S/Inputs/basic_msp430_tree" > %t 2>&1
 // RUN: FileCheck -check-prefix=LIBS-DEFAULT-POS %s < %t
 // RUN: FileCheck -check-prefix=LIBS-DEFAULT-NEG %s < %t
 // RUN: %clang %s -### -no-canonical-prefixes -target msp430 -rtlib=libgcc \
 // RUN:   --gcc-toolchain="%S/Inputs/basic_msp430_tree" --sysroot="" 2>&1 \
 // RUN:   | FileCheck -check-prefix=LIBS-DEFAULT-GCC-TOOLCHAIN %s
 // LIBS-DEFAULT-POS: "{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/../../..{{/|\\\\}}..{{/|\\\\}}bin{{/|\\\\}}msp430-elf-ld"

 // LIBS-COMPILER-RT-POS: "{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/430{{/|\\\\}}crtend_no_eh.o" "{{[^"]*}}libclang_rt.builtins-msp430.a"
 // LIBS-COMPILER-RT-NEG-NOT: crtbegin.o
 // LIBS-COMPILER-RT-NEG-NOT: -lssp_nonshared
 // LIBS-COMPILER-RT-NEG-NOT: -lssp
 // LIBS-COMPILER-RT-NEG-NOT: -lgcc
 // LIBS-COMPILER-RT-NEG-NOT: crtend.o
 // LIBS-COMPILER-RT-NEG-NOT: /exceptions
 
+// Tests for -mcpu=msp430x(v2) and -f(no-)exceptions.
 // RUN: %clang %s -### -no-canonical-prefixes -target msp430 -rtlib=libgcc -fexceptions \
 // RUN:   --sysroot="%S/Inputs/basic_msp430_tree" > %t 2>&1
 // RUN: FileCheck -check-prefix=LIBS-EXC-POS %s < %t
 // RUN: FileCheck -check-prefix=LIBS-EXC-NEG %s < %t
 // LIBS-EXC-POS: "{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/../../..{{/|\\\\}}..{{/|\\\\}}bin{{/|\\\\}}msp430-elf-ld"
 // LIBS-EXC-POS: "{{.*}}/Inputs/basic_msp430_tree{{/|\\\\}}msp430-elf{{/|\\\\}}lib/430/exceptions{{/|\\\\}}crt0.o"
 // LIBS-EXC-POS: "{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/430/exceptions{{/|\\\\}}crtbegin.o"
 // LIBS-EXC-POS: "-L{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/430/exceptions"
 // LIBS-EXC-POS: "-L{{.*}}/Inputs/basic_msp430_tree{{/|\\\\}}msp430-elf{{/|\\\\}}lib/430/exceptions"
 // LIBS-EXC-POS: "-lgcc" "--start-group" "-lmul_none" "-lc" "-lgcc" "-lcrt" "-lnosys" "--end-group"
 // LIBS-EXC-POS: "{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/430/exceptions{{/|\\\\}}crtend.o" "-lgcc"
 // LIBS-EXC-NEG-NOT: "{{.*}}/430"
 // LIBS-EXC-NEG-NOT: "{{.*}}430/crt{{.*}}"
 
+// RUN: %clang %s -### -no-canonical-prefixes -target msp430 -rtlib=libgcc -mcpu=msp430x \
+// RUN:   --sysroot="%S/Inputs/basic_msp430_tree" > %t 2>&1
+// RUN: FileCheck -check-prefix=LIBS-430X-POS %s < %t
+// RUN: FileCheck -check-prefix=LIBS-430X-NEG %s < %t
+// RUN: %clang %s -### -no-canonical-prefixes -target msp430 -rtlib=libgcc -mcpu=msp430xv2 \
+// RUN:   --sysroot="%S/Inputs/basic_msp430_tree" > %t 2>&1
+// RUN: FileCheck -check-prefix=LIBS-430X-POS %s < %t
+// RUN: FileCheck -check-prefix=LIBS-430X-NEG %s < %t
+// LIBS-430X-POS: "{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/../../..{{/|\\\\}}..{{/|\\\\}}bin{{/|\\\\}}msp430-elf-ld"
+// LIBS-430X-POS: "{{.*}}/Inputs/basic_msp430_tree{{/|\\\\}}msp430-elf{{/|\\\\}}lib{{/|\\\\}}crt0.o"
+// LIBS-430X-POS: "{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1{{/|\\\\}}crtbegin_no_eh.o"
+// LIBS-430X-POS: "-L{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1{{/|\\\\}}"
+// LIBS-430X-POS: "-L{{.*}}/Inputs/basic_msp430_tree{{/|\\\\}}msp430-elf{{/|\\\\}}lib{{/|\\\\}}"
+// LIBS-430X-POS: "-lgcc" "--start-group" "-lmul_none" "-lc" "-lgcc" "-lcrt" "-lnosys" "--end-group"
+// LIBS-430X-POS: "{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1{{/|\\\\}}crtend_no_eh.o" "-lgcc"
+// LIBS-430X-NEG-NOT: "{{.*}}/430"
+// LIBS-430X-NEG-NOT: "{{.*}}430/crt{{.*}}"
+// LIBS-430X-NEG-NOT: /exceptions
+
+// RUN: %clang %s -### -no-canonical-prefixes -target msp430 -rtlib=libgcc -mcpu=msp430x -fexceptions \
+// RUN:   --sysroot="%S/Inputs/basic_msp430_tree" > %t 2>&1
+// RUN: FileCheck -check-prefix=LIBS-430X-EXC-POS %s < %t
+// RUN: FileCheck -check-prefix=LIBS-430X-EXC-NEG %s < %t
+// RUN: %clang %s -### -no-canonical-prefixes -target msp430 -rtlib=libgcc -mcpu=msp430xv2 -fexceptions \
+// RUN:   --sysroot="%S/Inputs/basic_msp430_tree" > %t 2>&1
+// RUN: FileCheck -check-prefix=LIBS-430X-EXC-POS %s < %t
+// RUN: FileCheck -check-prefix=LIBS-430X-EXC-NEG %s < %t
+// LIBS-430X-EXC-POS: "{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/../../..{{/|\\\\}}..{{/|\\\\}}bin{{/|\\\\}}msp430-elf-ld"
+// LIBS-430X-EXC-POS: "{{.*}}/Inputs/basic_msp430_tree{{/|\\\\}}msp430-elf{{/|\\\\}}lib/exceptions{{/|\\\\}}crt0.o"
+// LIBS-430X-EXC-POS: "{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/exceptions{{/|\\\\}}crtbegin.o"
+// LIBS-430X-EXC-POS: "-L{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/exceptions"
+// LIBS-430X-EXC-POS: "-L{{.*}}/Inputs/basic_msp430_tree{{/|\\\\}}msp430-elf{{/|\\\\}}lib/exceptions"
+// LIBS-430X-EXC-POS: "-lgcc" "--start-group" "-lmul_none" "-lc" "-lgcc" "-lcrt" "-lnosys" "--end-group"
+// LIBS-430X-EXC-POS: "{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/exceptions{{/|\\\\}}crtend.o" "-lgcc"
+// LIBS-430X-EXC-NEG-NOT: "{{.*}}/430"
+// LIBS-430X-EXC-NEG-NOT: "{{.*}}430/crt{{.*}}"
+
+// Tests for -fstack-protector, -nostdlib, -nostartfiles and -nodefaultlibs.
 // RUN: %clang %s -### -no-canonical-prefixes -target msp430 -rtlib=libgcc \
 // RUN:   -fstack-protector  --sysroot="%S/Inputs/basic_msp430_tree" 2>&1 \
 // RUN:   | FileCheck -check-prefix=LIBS-SSP %s
 // LIBS-SSP: "{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/../../..{{/|\\\\}}..{{/|\\\\}}bin{{/|\\\\}}msp430-elf-ld"
 // LIBS-SSP: "{{.*}}/Inputs/basic_msp430_tree{{/|\\\\}}msp430-elf{{/|\\\\}}lib/430{{/|\\\\}}crt0.o"
 // LIBS-SSP: "{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/430{{/|\\\\}}crtbegin_no_eh.o"
 // LIBS-SSP: "-L{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/430"
 // LIBS-SSP: "-L{{.*}}/Inputs/basic_msp430_tree{{/|\\\\}}msp430-elf{{/|\\\\}}lib/430"

 // RUN:   | FileCheck -check-prefix=HWMult-F5 %s
 // HWMult-F5: "--start-group" "-lmul_f5"
 
 // RUN: %clang %s -### -no-canonical-prefixes -target msp430 -mhwmult=none --sysroot="" 2>&1 \
 // RUN:   | FileCheck -check-prefix=HWMult-NONE %s
 // RUN: %clang %s -### -no-canonical-prefixes -target msp430 -mhwmult=none -mmcu=msp430f4783 --sysroot="" 2>&1 \
 // RUN:   | FileCheck -check-prefix=HWMult-NONE %s
 // HWMult-NONE: "--start-group" "-lmul_none"
+
+// Test for the correct multilib selection when overriding the CPU of an MCU.
+// RUN: %clang %s -### -no-canonical-prefixes -target msp430 -mmcu=msp430f5529 -mcpu=msp430 \
+// RUN:   -rtlib=libgcc --sysroot="%S/Inputs/basic_msp430_tree" > %t 2>&1
+// RUN: FileCheck -check-prefix=LIBS-OVERRIDE-430-POS %s < %t
+// RUN: FileCheck -check-prefix=LIBS-OVERRIDE-430-NEG %s < %t
+// RUN: %clang %s -### -no-canonical-prefixes -target msp430 -mmcu=msp430f5529 -mcpu=msp430 \
+// RUN:    -rtlib=libgcc --gcc-toolchain="%S/Inputs/basic_msp430_tree" --sysroot="" 2>&1 \
+// RUN:   | FileCheck -check-prefix=LIBS-OVERRIDE-430-GCC-TOOLCHAIN %s
+// LIBS-OVERRIDE-430-POS: "{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/../../..{{/|\\\\}}..{{/|\\\\}}bin{{/|\\\\}}msp430-elf-ld"
+// LIBS-OVERRIDE-430-POS: "{{.*}}/Inputs/basic_msp430_tree{{/|\\\\}}msp430-elf{{/|\\\\}}lib/430{{/|\\\\}}crt0.o"
+// LIBS-OVERRIDE-430-POS: "{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/430{{/|\\\\}}crtbegin_no_eh.o"
+// LIBS-OVERRIDE-430-POS: "-L{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/430"
+// LIBS-OVERRIDE-430-POS: "-L{{.*}}/Inputs/basic_msp430_tree{{/|\\\\}}msp430-elf{{/|\\\\}}lib/430"
+// LIBS-OVERRIDE-430-POS: "{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/430{{/|\\\\}}crtend_no_eh.o" "-lgcc"
+// LIBS-OVERRIDE-430-GCC-TOOLCHAIN: "{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/../../..{{/|\\\\}}..{{/|\\\\}}bin{{/|\\\\}}msp430-elf-ld"
+// LIBS-OVERRIDE-430-GCC-TOOLCHAIN: "{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/../../..{{/|\\\\}}..{{/|\\\\}}msp430-elf{{/|\\\\}}lib/430{{/|\\\\}}crt0.o"
+// LIBS-OVERRIDE-430-GCC-TOOLCHAIN: "{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/430{{/|\\\\}}crtbegin_no_eh.o"
+// LIBS-OVERRIDE-430-GCC-TOOLCHAIN: "-L{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/430"
+// LIBS-OVERRIDE-430-GCC-TOOLCHAIN: "-L{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/../../..{{/|\\\\}}..{{/|\\\\}}msp430-elf{{/|\\\\}}lib/430"
+// LIBS-OVERRIDE-430-GCC-TOOLCHAIN: "{{.*}}/Inputs/basic_msp430_tree/lib/gcc/msp430-elf/8.3.1/430{{/|\\\\}}crtend_no_eh.o" "-lgcc"
+// LIBS-OVERRIDE-430-NEG-NOT: crtbegin.o
+// LIBS-OVERRIDE-430-NEG-NOT: -lssp_nonshared
+// LIBS-OVERRIDE-430-NEG-NOT: -lssp
+// LIBS-OVERRIDE-430-NEG-NOT: clang_rt
+// LIBS-OVERRIDE-430-NEG-NOT: crtend.o
+// LIBS-OVERRIDE-430-NEG-NOT: /exceptions

clang/test/Misc/target-invalid-cpu-note.c

 
 // RUN: not %clang_cc1 -triple riscv32 -tune-cpu not-a-cpu -fsyntax-only %s 2>&1 | FileCheck %s --check-prefix TUNE-RISCV32
 // TUNE-RISCV32: error: unknown target CPU 'not-a-cpu'
 // TUNE-RISCV32-NEXT: note: valid target CPU values are: generic-rv32, rocket-rv32, sifive-7-rv32, sifive-e20, sifive-e21, sifive-e24, sifive-e31, sifive-e34, sifive-e76, generic, rocket, sifive-7-series{{$}}
 
 // RUN: not %clang_cc1 -triple riscv64 -tune-cpu not-a-cpu -fsyntax-only %s 2>&1 | FileCheck %s --check-prefix TUNE-RISCV64
 // TUNE-RISCV64: error: unknown target CPU 'not-a-cpu'
 // TUNE-RISCV64-NEXT: note: valid target CPU values are: generic-rv64, rocket-rv64, sifive-7-rv64, sifive-s21, sifive-s51, sifive-s54, sifive-s76, sifive-u54, sifive-u74, generic, rocket, sifive-7-series{{$}}
+
+// RUN: not %clang_cc1 -triple msp430 -target-cpu not-a-cpu -fsyntax-only %s 2>&1 | FileCheck %s --check-prefix MSP430
+// MSP430: error: unknown target CPU 'not-a-cpu'
+// MSP430-NEXT: note: valid target CPU values are: generic, msp430, msp430x, msp430xv2{{$}}

clang/test/Preprocessor/msp430-defs.c

+// Check the correct macros are defined for each CPU.
+
+// RUN: %clang -target msp430 -x c -E -dM %s -o - | FileCheck  %s
+// RUN: %clang -target msp430 -mcpu=generic -x c -E -dM %s -o - | FileCheck %s
+// RUN: %clang -target msp430 -mcpu=msp430 -x c -E -dM %s -o - | FileCheck %s
+
+// CHECK: MSP430
+// CHECK: __ELF__
+// CHECK-NOT: __MSP430X__
+// CHECK: __MSP430__
+
+// RUN: %clang -target msp430 -mcpu=msp430x -x c -E -dM %s -o - \
+// RUN:   | FileCheck --check-prefix=MSP430X %s
+// RUN: %clang -target msp430 -mcpu=msp430xv2 -x c -E -dM %s -o - \
+// RUN:   | FileCheck --check-prefix=MSP430X %s
+
+// MSP430X: MSP430
+// MSP430X: __ELF__
+// MSP430X: __MSP430X__
+// MSP430X: __MSP430__

llvm/lib/Target/MSP430/MSP430.td

 //===----------------------------------------------------------------------===//
 
 include "llvm/Target/Target.td"
 
 //===----------------------------------------------------------------------===//
 // Subtarget Features. 
 //===----------------------------------------------------------------------===//
 def FeatureX
- : SubtargetFeature<"ext", "ExtendedInsts", "true",
-                    "Enable MSP430-X extensions">;
+ : SubtargetFeature<"msp430x", "MSP430X", "true",
+                    "Enable MSP430X extensions">;
 
 def FeatureHWMult16
  : SubtargetFeature<"hwmult16", "HWMultMode", "HWMult16",
                     "Enable 16-bit hardware multiplier">;
 
 def FeatureHWMult32
  : SubtargetFeature<"hwmult32", "HWMultMode", "HWMult32",
                     "Enable 32-bit hardware multiplier">;
 
 def FeatureHWMultF5
  : SubtargetFeature<"hwmultf5", "HWMultMode", "HWMultF5",
                     "Enable F5 series hardware multiplier">;
 
 //===----------------------------------------------------------------------===//
 // MSP430 supported processors.
 //===----------------------------------------------------------------------===//
 class Proc<string Name, list<SubtargetFeature> Features>
  : Processor<Name, NoItineraries, Features>;
 
 def : Proc<"generic",         []>;
 def : Proc<"msp430",          []>;
 def : Proc<"msp430x",         [FeatureX]>;
+def : Proc<"msp430xv2",       [FeatureX]>;
 
 //===----------------------------------------------------------------------===//
 // Register File Description
 //===----------------------------------------------------------------------===//
 
 include "MSP430RegisterInfo.td"
 
 //===----------------------------------------------------------------------===//

llvm/lib/Target/MSP430/MSP430Subtarget.h

 class MSP430Subtarget : public MSP430GenSubtargetInfo {
 public:
   enum HWMultEnum {
     NoHWMult, HWMult16, HWMult32, HWMultF5
   };
 
 private:
   virtual void anchor();
-  bool ExtendedInsts = false;
+  bool MSP430X = false;
   HWMultEnum HWMultMode = NoHWMult;
   MSP430FrameLowering FrameLowering;
   MSP430InstrInfo InstrInfo;
   MSP430TargetLowering TLInfo;
   SelectionDAGTargetInfo TSInfo;
 
 public:
   /// This constructor initializes the data members to match that
   /// of the specified triple.
   ///
   MSP430Subtarget(const Triple &TT, const std::string &CPU,
                   const std::string &FS, const TargetMachine &TM);
 
   MSP430Subtarget &initializeSubtargetDependencies(StringRef CPU, StringRef FS);
 
   /// ParseSubtargetFeatures - Parses features string setting specified
   /// subtarget options.  Definition of function is auto generated by tblgen.
   void ParseSubtargetFeatures(StringRef CPU, StringRef TuneCPU, StringRef FS);
 
   bool hasHWMult16() const { return HWMultMode == HWMult16; }
   bool hasHWMult32() const { return HWMultMode == HWMult32; }
   bool hasHWMultF5() const { return HWMultMode == HWMultF5; }
 
+  bool hasMSP430X() const { return MSP430X; }
+
   const TargetFrameLowering *getFrameLowering() const override {
     return &FrameLowering;
   }
   const MSP430InstrInfo *getInstrInfo() const override { return &InstrInfo; }
   const TargetRegisterInfo *getRegisterInfo() const override {
     return &InstrInfo.getRegisterInfo();
   }
   const MSP430TargetLowering *getTargetLowering() const override {

llvm/lib/Target/MSP430/MSP430Subtarget.cpp

 #define GET_SUBTARGETINFO_TARGET_DESC
 #define GET_SUBTARGETINFO_CTOR
 #include "MSP430GenSubtargetInfo.inc"
 
 void MSP430Subtarget::anchor() { }
 
 MSP430Subtarget &
 MSP430Subtarget::initializeSubtargetDependencies(StringRef CPU, StringRef FS) {
-  ExtendedInsts = false;
-  HWMultMode = NoHWMult;
-
   StringRef CPUName = CPU;
   if (CPUName.empty())
     CPUName = "msp430";
 
   ParseSubtargetFeatures(CPUName, /*TuneCPU*/ CPUName, FS);
 
   if (HWMultModeOption != NoHWMult)
     HWMultMode = HWMultModeOption;
 
   return *this;
 }
 
 MSP430Subtarget::MSP430Subtarget(const Triple &TT, const std::string &CPU,
                                  const std::string &FS, const TargetMachine &TM)
     : MSP430GenSubtargetInfo(TT, CPU, /*TuneCPU*/ CPU, FS), FrameLowering(),
       InstrInfo(initializeSubtargetDependencies(CPU, FS)), TLInfo(TM, *this) {}

llvm/test/CodeGen/MSP430/build-attrs.ll

 ; Test that the -mcpu= option sets the correct ELF build attributes.
 
 ; RUN: llc -mtriple=msp430 -filetype=obj < %s \
 ; RUN:   | llvm-readelf -A - | FileCheck %s --check-prefixes COMMON,MSP430,SMALL
 ; RUN: llc -mtriple=msp430 -mcpu=generic -filetype=obj < %s \
 ; RUN:   | llvm-readelf -A - | FileCheck %s --check-prefixes COMMON,MSP430,SMALL
 ; RUN: llc -mtriple=msp430 -mcpu=msp430 -filetype=obj < %s \
 ; RUN:   | llvm-readelf -A - | FileCheck %s --check-prefixes COMMON,MSP430,SMALL
 ; RUN: llc -mtriple=msp430 -mcpu=msp430x -filetype=obj < %s \
 ; RUN:   | llvm-readelf -A - | FileCheck %s --check-prefixes COMMON,MSP430X,SMALL
+; RUN: llc -mtriple=msp430 -mcpu=msp430xv2 -filetype=obj < %s \
+; RUN:   | llvm-readelf -A - | FileCheck %s --check-prefixes COMMON,MSP430X,SMALL
 
 ; COMMON: BuildAttributes {
 ; COMMON: FormatVersion: 0x41
 ; COMMON:   SectionLength: 22
 ; COMMON:   Vendor: mspabi
 ; COMMON:   Tag: Tag_File (0x1)
 ; COMMON:   Size: 11