[RISCV] Add Clang frontend support for Bitmanip extension

[simoncook]

Summary

This adds the __riscv_bitmanip macro and the 'b' target feature to enable it.

[lewis-revill]

Thanks Scott, it should be relatively easy to add tests for this in 'clang/test/Preprocessor/riscv-target-features.c' if you could.

[s.egerton]

Add test that march 'b' flag enables __riscv_bitmanip.

[lenary]

LGTM!

[lenary]

@s.egerton Please can you revert rG57cf6ee9c84434161088c39a6f8dd2aae14eb12d - this patch has open dependencies, including on the LLVM support for RISC-V B extension. It would be confusing to users if clang 10.0 contained frontend support for the B extension, but LLVM 10.0 did not contain backend support for it.

Sorry for the confusion around marking this as approved.

[s.egerton]

Good point. It's reverted now.

[lenary]

@s.egerton Thank you. Sorry again for the confusion.

Reverted in rGcbe681bd8339d3a018d25441a5f4ef9da2bd017d

[simoncook]

Rebase changes on top of experimental feature support (D73891)

[simoncook]

Rebase on new dependencies

[MaskRay]

clang/lib/Basic/Targets/RISCV.cpp

129

delete {}

[simoncook]

Address feedback

[s.egerton]

Looks good to me

clang/lib/Basic/Targets/RISCV.h

 class RISCVTargetInfo : public TargetInfo {
 protected:
   std::string ABI;
   bool HasM;
   bool HasA;
   bool HasF;
   bool HasD;
   bool HasC;
+  bool HasB;
 
 public:
   RISCVTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
       : TargetInfo(Triple), HasM(false), HasA(false), HasF(false),
-        HasD(false), HasC(false) {
+        HasD(false), HasC(false), HasB(false) {
     LongDoubleWidth = 128;
     LongDoubleAlign = 128;
     LongDoubleFormat = &llvm::APFloat::IEEEquad();
     SuitableAlign = 128;
     WCharType = SignedInt;
     WIntType = UnsignedInt;
   }
 

clang/lib/Basic/Targets/RISCV.cpp

void RISCVTargetInfo::getTargetDefines(const LangOptions &Opts,
   if (HasF || HasD) {
     Builder.defineMacro("__riscv_flen", HasD ? "64" : "32");
     Builder.defineMacro("__riscv_fdiv");
     Builder.defineMacro("__riscv_fsqrt");
   }
 
   if (HasC)
     Builder.defineMacro("__riscv_compressed");
+
+  if (HasB) {
+    Builder.defineMacro("__riscv_bitmanip");
+  }
 }
 
 /// Return true if has this feature, need to sync with handleTargetFeatures.
 bool RISCVTargetInfo::hasFeature(StringRef Feature) const {
   bool Is64Bit = getTriple().getArch() == llvm::Triple::riscv64;
   return llvm::StringSwitch<bool>(Feature)
       .Case("riscv", true)
       .Case("riscv32", !Is64Bit)
       .Case("riscv64", Is64Bit)
       .Case("m", HasM)
       .Case("a", HasA)
       .Case("f", HasF)
       .Case("d", HasD)
       .Case("c", HasC)
+      .Case("b", HasB)
       .Default(false);
 }
 
 /// Perform initialization based on the user configured set of features.
 bool RISCVTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
                                            DiagnosticsEngine &Diags) {
   for (const auto &Feature : Features) {
     if (Feature == "+m")
       HasM = true;
     else if (Feature == "+a")
       HasA = true;
     else if (Feature == "+f")
       HasF = true;
     else if (Feature == "+d")
       HasD = true;
     else if (Feature == "+c")
       HasC = true;
+    else if (Feature == "+b")
+      HasB = true;
   }
 
   return true;
 }

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

case 'f':
       break;
     case 'd':
       Features.push_back("+d");
       HasD = true;
       break;
     case 'c':
       Features.push_back("+c");
       break;
+    case 'b':
+      Features.push_back("+b");
+      break;
     }
   }
 
   // Dependency check.
   // It's illegal to specify the 'd' (double-precision floating point)
   // extension without also specifying the 'f' (single precision
   // floating-point) extension.
   if (HasD && !HasF) {