[RISCV] Define preprocessor definitions for 'P' extension

clang/lib/Basic/Targets/RISCV.h

 protected:
   std::string ABI, CPU;
   bool HasM = false;
   bool HasA = false;
   bool HasF = false;
   bool HasD = false;
   bool HasC = false;
   bool HasB = false;
+  bool HasP = false;
   bool HasV = false;
   bool HasZba = false;
   bool HasZbb = false;
   bool HasZbc = false;
   bool HasZbe = false;
   bool HasZbf = false;
   bool HasZbm = false;
   bool HasZbp = false;
   bool HasZbproposedc = false;
   bool HasZbr = false;
   bool HasZbs = false;
   bool HasZbt = false;
+  bool HasZpn = false;
+  bool HasZpsfoperand = false;
+  bool HasZprvsfextra = false;
   bool HasZfh = false;
   bool HasZvamo = false;
   bool HasZvlsseg = false;
 
   static const Builtin::Info BuiltinInfo[];
 
 public:
   RISCVTargetInfo(const llvm::Triple &Triple, const TargetOptions &)

clang/lib/Basic/Targets/RISCV.cpp

if (HasC) {
     Builder.defineMacro("__riscv_compressed");
   }
 
   if (HasB) {
     Builder.defineMacro("__riscv_b", "93000");
     Builder.defineMacro("__riscv_bitmanip");
   }
 
+  if (HasP)
+    Builder.defineMacro("__riscv_p", "93000");
+
   if (HasV) {
     Builder.defineMacro("__riscv_v", "10000");
     Builder.defineMacro("__riscv_vector");
   }
 
   if (HasZba)
     Builder.defineMacro("__riscv_zba", "93000");
 
if (HasZbr)
     Builder.defineMacro("__riscv_zbr", "93000");
 
   if (HasZbs)
     Builder.defineMacro("__riscv_zbs", "93000");
 
   if (HasZbt)
     Builder.defineMacro("__riscv_zbt", "93000");
 
+  if (HasZpn)
+    Builder.defineMacro("__riscv_zpn", "93000");
+
+  if (HasZpsfoperand)
+    Builder.defineMacro("__riscv_zpsfoperand", "93000");
+
+  if (HasZprvsfextra)
+    Builder.defineMacro("__riscv_zprvsfextra", "93000");
+
   if (HasZfh)
     Builder.defineMacro("__riscv_zfh", "1000");
 
   if (HasZvamo)
     Builder.defineMacro("__riscv_zvamo", "10000");
 
   if (HasZvlsseg)
     Builder.defineMacro("__riscv_zvlsseg", "10000");
return llvm::StringSwitch<bool>(Feature)
       .Case("riscv64", Is64Bit)
       .Case("64bit", Is64Bit)
       .Case("m", HasM)
       .Case("a", HasA)
       .Case("f", HasF)
       .Case("d", HasD)
       .Case("c", HasC)
       .Case("experimental-b", HasB)
+      .Case("experimental-p", HasP)
       .Case("experimental-v", HasV)
       .Case("experimental-zba", HasZba)
       .Case("experimental-zbb", HasZbb)
       .Case("experimental-zbc", HasZbc)
       .Case("experimental-zbe", HasZbe)
       .Case("experimental-zbf", HasZbf)
       .Case("experimental-zbm", HasZbm)
       .Case("experimental-zbp", HasZbp)
       .Case("experimental-zbproposedc", HasZbproposedc)
       .Case("experimental-zbr", HasZbr)
       .Case("experimental-zbs", HasZbs)
       .Case("experimental-zbt", HasZbt)
+      .Case("experimental-zpn", HasZpn)
+      .Case("experimental-zpsfoperand", HasZpsfoperand)
+      .Case("experimental-zprvsfextra", HasZprvsfextra)
       .Case("experimental-zfh", HasZfh)
       .Case("experimental-zvamo", HasZvamo)
       .Case("experimental-zvlsseg", HasZvlsseg)
       .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 == "+experimental-b")
       HasB = true;
+    else if (Feature == "+experimental-p")
+      HasP = true;
     else if (Feature == "+experimental-v")
       HasV = true;
     else if (Feature == "+experimental-zba")
       HasZba = true;
     else if (Feature == "+experimental-zbb")
       HasZbb = true;
     else if (Feature == "+experimental-zbc")
       HasZbc = true;
     else if (Feature == "+experimental-zbe")
       HasZbe = true;
     else if (Feature == "+experimental-zbf")
       HasZbf = true;
     else if (Feature == "+experimental-zbm")
       HasZbm = true;
     else if (Feature == "+experimental-zbp")
       HasZbp = true;
     else if (Feature == "+experimental-zbproposedc")
       HasZbproposedc = true;
     else if (Feature == "+experimental-zbr")
       HasZbr = true;
     else if (Feature == "+experimental-zbs")
       HasZbs = true;
     else if (Feature == "+experimental-zbt")
       HasZbt = true;
+    else if (Feature == "+experimental-zpn")
+      HasZpn = true;
+    else if (Feature == "+experimental-zpsfoperand")
+      HasZpsfoperand = true;
+    else if (Feature == "+experimental-zprvsfextra")
+      HasZprvsfextra = true;
     else if (Feature == "+experimental-zfh")
       HasZfh = true;
     else if (Feature == "+experimental-zvamo")
       HasZvamo = true;
     else if (Feature == "+experimental-zvlsseg")
       HasZvlsseg = true;
   }
 

clang/test/Preprocessor/riscv-target-features.c

 // RUN: -o - | FileCheck --check-prefix=CHECK-ZBT-EXT %s
 // RUN: %clang -target riscv64-unknown-linux-gnu -menable-experimental-extensions \
 // RUN: -march=rv64izbt0p93 -x c -E -dM %s \
 // RUN: -o - | FileCheck --check-prefix=CHECK-ZBT-EXT %s
 // CHECK-ZBT-NOT: __riscv_b
 // CHECK-ZBT-EXT: __riscv_zbt 93000
 
 // RUN: %clang -target riscv32-unknown-linux-gnu -menable-experimental-extensions \
+// RUN: -march=rv32ip0p93 -x c -E -dM %s \
+// RUN: -o - | FileCheck --check-prefix=CHECK-32P-EXT %s
+// CHECK-32P-EXT: __riscv_p 93000
+// CHECK-32P-EXT: __riscv_zpn 93000
+// CHECK-32P-EXT: __riscv_zpsfoperand 93000
+// CHECK-32P-NOT: __riscv_zprvsfextra
+
+// RUN: %clang -target riscv64-unknown-linux-gnu -menable-experimental-extensions \
+// RUN: -march=rv64ip0p93 -x c -E -dM %s \
+// RUN: -o - | FileCheck --check-prefix=CHECK-64P-EXT %s
+// CHECK-64P-EXT: __riscv_p 93000
+// CHECK-64P-EXT: __riscv_zpn 93000
+// CHECK-64P-EXT: __riscv_zprvsfextra 93000
+// CHECK-64P-EXT: __riscv_zpsfoperand 93000
+
+// RUN: %clang -target riscv32-unknown-linux-gnu -menable-experimental-extensions \
+// RUN: -march=rv32izpn0p93 -x c -E -dM %s \
+// RUN: -o - | FileCheck --check-prefix=CHECK-ZPN-EXT %s
+// RUN: %clang -target riscv64-unknown-linux-gnu -menable-experimental-extensions \
+// RUN: -march=rv64izpn0p93 -x c -E -dM %s \
+// RUN: -o - | FileCheck --check-prefix=CHECK-ZPN-EXT %s
+// CHECK-ZPN-NOT: __riscv_p
+// CHECK-ZPN-EXT: __riscv_zpn 93000
+
+// RUN: %clang -target riscv32-unknown-linux-gnu -menable-experimental-extensions \
+// RUN: -march=rv32izpsfoperand0p93 -x c -E -dM %s \
+// RUN: -o - | FileCheck --check-prefix=CHECK-ZPSFOPERAND-EXT %s
+// RUN: %clang -target riscv64-unknown-linux-gnu -menable-experimental-extensions \
+// RUN: -march=rv64izpsfoperand0p93 -x c -E -dM %s \
+// RUN: -o - | FileCheck --check-prefix=CHECK-ZPSFOPERAND-EXT %s
+// CHECK-ZPSFOPERAND-NOT: __riscv_p
+// CHECK-ZPSFOPERAND-EXT: __riscv_zpsfoperand 93000
+
+// RUN: %clang -target riscv64-unknown-linux-gnu -menable-experimental-extensions \
+// RUN: -march=rv64izprvsfextra0p93 -x c -E -dM %s \
+// RUN: -o - | FileCheck --check-prefix=CHECK-ZPRVSFEXTRA-EXT %s
+// CHECK-ZPRVSFEXTRA-NOT: __riscv_p
+// CHECK-ZPRVSFEXTRA-EXT: __riscv_zprvsfextra 93000
+
+// RUN: %clang -target riscv32-unknown-linux-gnu -menable-experimental-extensions \
 // RUN: -march=rv32iv0p10 -x c -E -dM %s \
 // RUN: -o - | FileCheck --check-prefix=CHECK-V-EXT %s
 // RUN: %clang -target riscv64-unknown-linux-gnu -menable-experimental-extensions \
 // RUN: -march=rv64iv0p10 -x c -E -dM %s \
 // RUN: -o - | FileCheck --check-prefix=CHECK-V-EXT %s
 // RUN: %clang -target riscv32-unknown-linux-gnu -menable-experimental-extensions \
 // RUN: -march=rv32izvlsseg0p10 -x c -E -dM %s \
 // RUN: -o - | FileCheck --check-prefix=CHECK-V-EXT %s