[M68k] Add basic Clang supports for M68881/2

[myhsu]

Summary

• Add the -m68881 flag
• Add floating point feature detection
• Macro definitions

To be honest this patch is not really urgent until we need inline assembly support and/or have decent amount of floating point instructions, but since it's a low-hanging fruit I just did it anyway.

[RKSimon]

clang/test/Driver/m68k-macros.cpp

2–9

Add a CHECK-NOMX881 prefix and check that HAVE_68881 isn't defined?

27

Add soft-float checks without CHECK-MX881 so we can check for 020-060 targets without FPU (68LC040 etc.)

[myhsu]

• Explicit add isa-68882 even for newer (>=68040) CPUs. Such that's it's a lot easier to conditionally add related macro definitions with TargetOptions::FeatureMap
• Add cases to test the absent of HAVE_68881 macro definitions

[myhsu]

ping

[0x59616e]

LGTM. Thanks !

[glaubitz]

@myhsu Can you fix the typo in the commit message?

s/supports/support/

clang/include/clang/Driver/Options.td

 // M68k features flags
 def m68000 : Flag<["-"], "m68000">, Group<m_m68k_Features_Group>;
 def m68010 : Flag<["-"], "m68010">, Group<m_m68k_Features_Group>;
 def m68020 : Flag<["-"], "m68020">, Group<m_m68k_Features_Group>;
 def m68030 : Flag<["-"], "m68030">, Group<m_m68k_Features_Group>;
 def m68040 : Flag<["-"], "m68040">, Group<m_m68k_Features_Group>;
 def m68060 : Flag<["-"], "m68060">, Group<m_m68k_Features_Group>;
 
+def m68881 : Flag<["-"], "m68881">, Group<m_m68k_Features_Group>;
+
 foreach i = {0-6} in
   def ffixed_a#i : Flag<["-"], "ffixed-a"#i>, Group<m_m68k_Features_Group>,
     HelpText<"Reserve the a"#i#" register (M68k only)">;
 foreach i = {0-7} in
   def ffixed_d#i : Flag<["-"], "ffixed-d"#i>, Group<m_m68k_Features_Group>,
     HelpText<"Reserve the d"#i#" register (M68k only)">;
 
 // X86 feature flags

clang/lib/Basic/Targets/M68k.h

enum CPUKind {
     CK_68000,
     CK_68010,
     CK_68020,
     CK_68030,
     CK_68040,
     CK_68060
   } CPU = CK_Unknown;
 
+  const TargetOptions &TargetOpts;
+
 public:
   M68kTargetInfo(const llvm::Triple &Triple, const TargetOptions &);
 
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override;
   ArrayRef<Builtin::Info> getTargetBuiltins() const override;
   bool hasFeature(StringRef Feature) const override;
   ArrayRef<const char *> getGCCRegNames() const override;

clang/lib/Basic/Targets/M68k.cpp

 #include <cstring>
 #include <limits>
 #include <optional>
 
 namespace clang {
 namespace targets {
 
 M68kTargetInfo::M68kTargetInfo(const llvm::Triple &Triple,
-                               const TargetOptions &)
-    : TargetInfo(Triple) {
+                               const TargetOptions &Opts)
+    : TargetInfo(Triple), TargetOpts(Opts) {
 
   std::string Layout;
 
   // M68k is Big Endian
   Layout += "E";
 
   // FIXME how to wire it with the used object format?
   Layout += "-m:e";
default:
     break;
   }
 
   if (CPU >= CK_68020) {
     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
   }
+
+  // Floating point
+  if (TargetOpts.FeatureMap.lookup("isa-68881") ||
+      TargetOpts.FeatureMap.lookup("isa-68882"))
+    Builder.defineMacro("__HAVE_68881__");
 }
 
 ArrayRef<Builtin::Info> M68kTargetInfo::getTargetBuiltins() const {
   // FIXME: Implement.
   return std::nullopt;
 }
 
 bool M68kTargetInfo::hasFeature(StringRef Feature) const {

clang/lib/Driver/ToolChains/Arch/M68k.h

 #include <string>
 #include <vector>
 
 namespace clang {
 namespace driver {
 namespace tools {
 namespace m68k {
 
-enum class FloatABI {
-  Invalid,
-  Soft,
-  Hard,
-};
-
-FloatABI getM68kFloatABI(const Driver &D, const llvm::opt::ArgList &Args);
-
 std::string getM68kTargetCPU(const llvm::opt::ArgList &Args);
 
 void getM68kTargetFeatures(const Driver &D, const llvm::Triple &Triple,
                            const llvm::opt::ArgList &Args,
                            std::vector<llvm::StringRef> &Features);
 
 } // end namespace m68k
 } // end namespace tools
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_ARCH_M680X0_H

clang/lib/Driver/ToolChains/Arch/M68k.cpp

std::string m68k::getM68kTargetCPU(const ArgList &Args) {
   if (Args.hasArg(clang::driver::options::OPT_m68040))
     return "M68040";
   if (Args.hasArg(clang::driver::options::OPT_m68060))
     return "M68060";
 
   return "";
 }
 
+static void addFloatABIFeatures(const llvm::opt::ArgList &Args,
+                                std::vector<llvm::StringRef> &Features) {
+  Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
+                           options::OPT_m68881);
+  // Opt out FPU even for newer CPUs.
+  if (A && A->getOption().matches(options::OPT_msoft_float)) {
+    Features.push_back("-isa-68881");
+    Features.push_back("-isa-68882");
+    return;
+  }
+
+  std::string CPU = m68k::getM68kTargetCPU(Args);
+  // Only enable M68881 for CPU < 68020 if the related flags are present.
+  if ((A && (CPU == "M68000" || CPU == "M68010")) ||
+      // Otherwise, by default we assume newer CPUs have M68881/2.
+      CPU == "M68020")
+    Features.push_back("+isa-68881");
+  else if (CPU == "M68030" || CPU == "M68040" || CPU == "M68060")
+    // Note that although CPU >= M68040 imply M68882, we still add `isa-68882`
+    // anyway so that it's easier to add or not add the corresponding macro
+    // definitions later, in case we want to disable 68881/2 in newer CPUs
+    // (with -msoft-float, for instance).
+    Features.push_back("+isa-68882");
+}
+
 void m68k::getM68kTargetFeatures(const Driver &D, const llvm::Triple &Triple,
                                  const ArgList &Args,
                                  std::vector<StringRef> &Features) {
-
-  m68k::FloatABI FloatABI = m68k::getM68kFloatABI(D, Args);
-  if (FloatABI == m68k::FloatABI::Soft)
-    Features.push_back("-hard-float");
+  addFloatABIFeatures(Args, Features);
 
   // Handle '-ffixed-<register>' flags
   if (Args.hasArg(options::OPT_ffixed_a0))
     Features.push_back("+reserve-a0");
   if (Args.hasArg(options::OPT_ffixed_a1))
     Features.push_back("+reserve-a1");
   if (Args.hasArg(options::OPT_ffixed_a2))
     Features.push_back("+reserve-a2");
if (Args.hasArg(options::OPT_ffixed_d4))
     Features.push_back("+reserve-d4");
   if (Args.hasArg(options::OPT_ffixed_d5))
     Features.push_back("+reserve-d5");
   if (Args.hasArg(options::OPT_ffixed_d6))
     Features.push_back("+reserve-d6");
   if (Args.hasArg(options::OPT_ffixed_d7))
     Features.push_back("+reserve-d7");
 }
-
-m68k::FloatABI m68k::getM68kFloatABI(const Driver &D, const ArgList &Args) {
-  m68k::FloatABI ABI = m68k::FloatABI::Invalid;
-  if (Arg *A =
-          Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) {
-
-    if (A->getOption().matches(options::OPT_msoft_float))
-      ABI = m68k::FloatABI::Soft;
-    else if (A->getOption().matches(options::OPT_mhard_float))
-      ABI = m68k::FloatABI::Hard;
-  }
-
-  // If unspecified, choose the default based on the platform.
-  if (ABI == m68k::FloatABI::Invalid)
-    ABI = m68k::FloatABI::Hard;
-
-  return ABI;
-}

clang/test/Driver/m68k-features.cpp

 // RUN: %clang -target m68k -ffixed-d6 -### %s 2> %t
 // RUN: FileCheck --check-prefix=CHECK-FIXED-D6 < %t %s
 // CHECK-FIXED-D6: "-target-feature" "+reserve-d6"
 
 // RUN: %clang -target m68k -ffixed-d7 -### %s 2> %t
 // RUN: FileCheck --check-prefix=CHECK-FIXED-D7 < %t %s
 // CHECK-FIXED-D7: "-target-feature" "+reserve-d7"
 
+// ==== Floating point ====
+// RUN: %clang -target m68k -m68000 -mhard-float -### %s 2> %t
+// RUN: FileCheck --check-prefix=CHECK-MX881 < %t %s
+// RUN: %clang -target m68k -m68000 -m68881 -### %s 2> %t
+// RUN: FileCheck --check-prefix=CHECK-MX881 < %t %s
+
+// RUN: %clang -target m68k -m68010 -mhard-float -### %s 2> %t
+// RUN: FileCheck --check-prefix=CHECK-MX881 < %t %s
+// RUN: %clang -target m68k -m68010 -m68881 -### %s 2> %t
+// RUN: FileCheck --check-prefix=CHECK-MX881 < %t %s
+
+// RUN: %clang -target m68k -m68020 -### %s 2> %t
+// RUN: FileCheck --check-prefix=CHECK-MX881 < %t %s
+
+// RUN: %clang -target m68k -m68030 -### %s 2> %t
+// RUN: FileCheck --check-prefix=CHECK-MX882 < %t %s
+
+// CHECK-MX881: "-target-feature" "+isa-68881"
+// CHECK-MX882: "-target-feature" "+isa-68882"
+

clang/test/Driver/m68k-macros.cpp

 // Check macro definitions
-// RUN: %clang -target m68k-unknown-linux -m68000 -dM -E %s | FileCheck --check-prefix=CHECK-MX %s
+
+// Since '__HAVE_68881__' sorted before most of the 'mc680x0' macros, we need to put it here.
+// CHECK-MX881: #define __HAVE_68881__ 1
+// CHECK-NOMX881-NOT: #define __HAVE_68881__ 1
+
+// RUN: %clang -target m68k-unknown-linux -m68000 -dM -E %s | FileCheck --check-prefixes=CHECK-MX,CHECK-NOMX881 %s
+// RUN: %clang -target m68k-unknown-linux -m68000 -mhard-float -dM -E %s | FileCheck --check-prefix=CHECK-MX881 %s
+// RUN: %clang -target m68k-unknown-linux -m68000 -m68881 -dM -E %s | FileCheck --check-prefix=CHECK-MX881 %s
 // CHECK-MX: #define __mc68000 1
 // CHECK-MX: #define __mc68000__ 1
 // CHECK-MX: #define mc68000 1
 
-// RUN: %clang -target m68k-unknown-linux -m68010 -dM -E %s | FileCheck --check-prefix=CHECK-MX10 %s
+// RUN: %clang -target m68k-unknown-linux -m68010 -dM -E %s | FileCheck --check-prefixes=CHECK-MX10,CHECK-NOMX881 %s
+// RUN: %clang -target m68k-unknown-linux -m68010 -mhard-float -dM -E %s | FileCheck --check-prefix=CHECK-MX881 %s
+// RUN: %clang -target m68k-unknown-linux -m68010 -m68881 -dM -E %s | FileCheck --check-prefix=CHECK-MX881 %s
 // CHECK-MX10: #define __mc68000 1
 // CHECK-MX10: #define __mc68000__ 1
 // CHECK-MX10: #define __mc68010 1
 // CHECK-MX10: #define __mc68010__ 1
 // CHECK-MX10: #define mc68000 1
 // CHECK-MX10: #define mc68010 1
 
-// RUN: %clang -target m68k-unknown-linux -m68020 -dM -E %s | FileCheck --check-prefix=CHECK-MX20 %s
+// RUN: %clang -target m68k-unknown-linux -m68020 -dM -E %s | FileCheck --check-prefixes=CHECK-MX20,CHECK-MX881 %s
+// RUN: %clang -target m68k-unknown-linux -m68020 -msoft-float -dM -E %s | FileCheck --check-prefix=CHECK-NOMX881 %s
 // CHECK-MX20: #define __mc68000 1
 // CHECK-MX20: #define __mc68000__ 1
 // CHECK-MX20: #define __mc68020 1
 // CHECK-MX20: #define __mc68020__ 1
 // CHECK-MX20: #define mc68000 1
 // CHECK-MX20: #define mc68020 1
 
-// RUN: %clang -target m68k-unknown-linux -m68030 -dM -E %s | FileCheck --check-prefix=CHECK-MX30 %s
+// RUN: %clang -target m68k-unknown-linux -m68030 -dM -E %s | FileCheck --check-prefixes=CHECK-MX30,CHECK-MX881 %s
+// RUN: %clang -target m68k-unknown-linux -m68030 -msoft-float -dM -E %s | FileCheck --check-prefix=CHECK-NOMX881 %s
 // CHECK-MX30: #define __mc68000 1
 // CHECK-MX30: #define __mc68000__ 1
 // CHECK-MX30: #define __mc68030 1
 // CHECK-MX30: #define __mc68030__ 1
 // CHECK-MX30: #define mc68000 1
 // CHECK-MX30: #define mc68030 1
 
-// RUN: %clang -target m68k-unknown-linux -m68040 -dM -E %s | FileCheck --check-prefix=CHECK-MX40 %s
+// RUN: %clang -target m68k-unknown-linux -m68040 -dM -E %s | FileCheck --check-prefixes=CHECK-MX40,CHECK-MX881 %s
+// RUN: %clang -target m68k-unknown-linux -m68040 -msoft-float -dM -E %s | FileCheck --check-prefix=CHECK-NOMX881 %s
 // CHECK-MX40: #define __mc68000 1
 // CHECK-MX40: #define __mc68000__ 1
 // CHECK-MX40: #define __mc68040 1
 // CHECK-MX40: #define __mc68040__ 1
 // CHECK-MX40: #define mc68000 1
 // CHECK-MX40: #define mc68040 1
 
-// RUN: %clang -target m68k-unknown-linux -m68060 -dM -E %s | FileCheck --check-prefix=CHECK-MX60 %s
+// RUN: %clang -target m68k-unknown-linux -m68060 -dM -E %s | FileCheck --check-prefixes=CHECK-MX60,CHECK-MX881 %s
+// RUN: %clang -target m68k-unknown-linux -m68060 -msoft-float -dM -E %s | FileCheck --check-prefix=CHECK-NOMX881 %s
 // CHECK-MX60: #define __mc68000 1
 // CHECK-MX60: #define __mc68000__ 1
 // CHECK-MX60: #define __mc68060 1
 // CHECK-MX60: #define __mc68060__ 1
 // CHECK-MX60: #define mc68000 1
 // CHECK-MX60: #define mc68060 1