Revert "CI: update gitlab config for newer runners."

[VincentWu]

Summary

This reverts commit 5458a2b7c42f920376352ea199e4376131840188.

[VincentWu]

test

llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp

 //===-- RISCVAsmParser.cpp - Parse RISCV assembly to MCInst instructions --===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
bool isUImmLog2XLenHalf() const {
     if (!isImm())
       return false;
     if (!evaluateConstantImm(getImm(), Imm, VK) ||
         VK != RISCVMCExpr::VK_RISCV_None)
       return false;
     return (isRV64() && isUInt<5>(Imm)) || isUInt<4>(Imm);
   }
 
+  bool isUImm2() const {
+    int64_t Imm;
+    RISCVMCExpr::VariantKind VK = RISCVMCExpr::VK_RISCV_None;
+    if (!isImm())
+      return false;
+    bool IsConstantImm = evaluateConstantImm(getImm(), Imm, VK);
+    return IsConstantImm && isUInt<2>(Imm) && VK == RISCVMCExpr::VK_RISCV_None;
+  }
+
+  bool isUImm4() const {
+    int64_t Imm;
+    RISCVMCExpr::VariantKind VK = RISCVMCExpr::VK_RISCV_None;
+    if (!isImm())
+      return false;
+    bool IsConstantImm = evaluateConstantImm(getImm(), Imm, VK);
+    return IsConstantImm && isUInt<4>(Imm) && VK == RISCVMCExpr::VK_RISCV_None;
+  }
+
   bool isUImm5() const {
     int64_t Imm;
     RISCVMCExpr::VariantKind VK = RISCVMCExpr::VK_RISCV_None;
     if (!isImm())
       return false;
     bool IsConstantImm = evaluateConstantImm(getImm(), Imm, VK);
     return IsConstantImm && isUInt<5>(Imm) && VK == RISCVMCExpr::VK_RISCV_None;
   }
if (!isImm())
       return false;
     RISCVMCExpr::VariantKind VK = RISCVMCExpr::VK_RISCV_None;
     int64_t Imm;
     bool IsConstantImm = evaluateConstantImm(getImm(), Imm, VK);
     return IsConstantImm && isInt<5>(Imm - 1) &&
            VK == RISCVMCExpr::VK_RISCV_None;
   }
 
+  bool isRnumArg() const {
+    int64_t Imm;
+    RISCVMCExpr::VariantKind VK = RISCVMCExpr::VK_RISCV_None;
+    if (!isImm())
+      return false;
+    bool IsConstantImm = evaluateConstantImm(getImm(), Imm, VK);
+    return IsConstantImm && Imm>= INT64_C(0) && Imm <= INT64_C(10) &&
+           VK == RISCVMCExpr::VK_RISCV_None;
+  }
+
   /// getStartLoc - Gets location of the first token of this operand
   SMLoc getStartLoc() const override { return StartLoc; }
   /// getEndLoc - Gets location of the last token of this operand
   SMLoc getEndLoc() const override { return EndLoc; }
   /// True if this operand is for an RV64 instruction
   bool isRV64() const { return IsRV64; }
 
   unsigned getReg() const override {
bool RISCVAsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
   case Match_InvalidUImmLog2XLenNonZero:
     if (isRV64())
       return generateImmOutOfRangeError(Operands, ErrorInfo, 1, (1 << 6) - 1);
     return generateImmOutOfRangeError(Operands, ErrorInfo, 1, (1 << 5) - 1);
   case Match_InvalidUImmLog2XLenHalf:
     if (isRV64())
       return generateImmOutOfRangeError(Operands, ErrorInfo, 0, (1 << 5) - 1);
     return generateImmOutOfRangeError(Operands, ErrorInfo, 0, (1 << 4) - 1);
+  case Match_InvalidUImm2:
+    return generateImmOutOfRangeError(Operands, ErrorInfo, 0, (1 << 2) - 1);
   case Match_InvalidUImm5:
     return generateImmOutOfRangeError(Operands, ErrorInfo, 0, (1 << 5) - 1);
   case Match_InvalidSImm5:
     return generateImmOutOfRangeError(Operands, ErrorInfo, -(1 << 4),
                                       (1 << 4) - 1);
   case Match_InvalidSImm6:
     return generateImmOutOfRangeError(Operands, ErrorInfo, -(1 << 5),
                                       (1 << 5) - 1);
case Match_InvalidVMaskRegister: {
     SMLoc ErrorLoc = ((RISCVOperand &)*Operands[ErrorInfo]).getStartLoc();
     return Error(ErrorLoc, "operand must be v0.t");
   }
   case Match_InvalidSImm5Plus1: {
     return generateImmOutOfRangeError(Operands, ErrorInfo, -(1 << 4) + 1,
                                       (1 << 4),
                                       "immediate must be in the range");
   }
+  case Match_InvalidRnumArg: {
+    return generateImmOutOfRangeError(Operands, ErrorInfo, 0, (1 << 4) - 6);
+  }
   }
 
   llvm_unreachable("Unknown match type detected!");
 }
 
 // Attempts to match Name as a register (either using the default name or
 // alternative ABI names), setting RegNo to the matching register. Upon
 // failure, returns true and sets RegNo to 0. If IsRV32E then registers
if (Tag == RISCVAttrs::ARCH) {
     clearFeatureBits(RISCV::FeatureExtZbm, "experimental-zbm");
     clearFeatureBits(RISCV::FeatureExtZbp, "experimental-zbp");
     clearFeatureBits(RISCV::FeatureExtZbproposedc, "experimental-zbproposedc");
     clearFeatureBits(RISCV::FeatureExtZbr, "experimental-zbr");
     clearFeatureBits(RISCV::FeatureExtZbs, "experimental-zbs");
     clearFeatureBits(RISCV::FeatureExtZbt, "experimental-zbt");
     clearFeatureBits(RISCV::FeatureExtZvamo, "experimental-zvamo");
     clearFeatureBits(RISCV::FeatureStdExtZvlsseg, "experimental-zvlsseg");
+    clearFeatureBits(RISCV::FeatureStdExtK, "experimental-k");
+    clearFeatureBits(RISCV::FeatureExtZkb, "experimental-zkb");
+    clearFeatureBits(RISCV::FeatureExtZkg, "experimental-zkg");
+    clearFeatureBits(RISCV::FeatureExtZkn, "experimental-zkn");
+    clearFeatureBits(RISCV::FeatureExtZknd, "experimental-zknd");
+    clearFeatureBits(RISCV::FeatureExtZkne, "experimental-zkne");
+    clearFeatureBits(RISCV::FeatureExtZknh, "experimental-zknh");
+    clearFeatureBits(RISCV::FeatureExtZkr, "experimental-zkr");
+    clearFeatureBits(RISCV::FeatureExtZks, "experimental-zks");
+    clearFeatureBits(RISCV::FeatureExtZksh, "experimental-zsh");
+    clearFeatureBits(RISCV::FeatureExtZksed, "experimental-zksed");
 
     while (!Arch.empty()) {
       bool DropFirst = true;
       if (Arch[0] == 'i')
         clearFeatureBits(RISCV::FeatureRV32E, "e");
       else if (Arch[0] == 'e')
         setFeatureBits(RISCV::FeatureRV32E, "e");
       else if (Arch[0] == 'g') {
while (!Arch.empty()) {
         setFeatureBits(RISCV::FeatureStdExtF, "f");
         setFeatureBits(RISCV::FeatureStdExtD, "d");
       } else if (Arch[0] == 'c') {
         setFeatureBits(RISCV::FeatureStdExtC, "c");
       } else if (Arch[0] == 'b') {
         setFeatureBits(RISCV::FeatureStdExtB, "experimental-b");
       } else if (Arch[0] == 'v') {
         setFeatureBits(RISCV::FeatureStdExtV, "experimental-v");
+      } else if (Arch[0] == 'k') {
+          setFeatureBits(RISCV::FeatureStdExtK, "experimental-k");
       } else if (Arch[0] == 's' || Arch[0] == 'x' || Arch[0] == 'z') {
         StringRef Ext =
             Arch.take_until([](char c) { return ::isdigit(c) || c == '_'; });
         if (Ext == "zba")
           setFeatureBits(RISCV::FeatureExtZba, "experimental-zba");
         else if (Ext == "zbb")
           setFeatureBits(RISCV::FeatureExtZbb, "experimental-zbb");
         else if (Ext == "zbc")
while (!Arch.empty()) {
         else if (Ext == "zbt")
           setFeatureBits(RISCV::FeatureExtZbt, "experimental-zbt");
         else if (Ext == "zfh")
           setFeatureBits(RISCV::FeatureExtZfh, "experimental-zfh");
         else if (Ext == "zvamo")
           setFeatureBits(RISCV::FeatureExtZvamo, "experimental-zvamo");
         else if (Ext == "zvlsseg")
           setFeatureBits(RISCV::FeatureStdExtZvlsseg, "experimental-zvlsseg");
+        else if (Ext == "zkb")
+          setFeatureBits(RISCV::FeatureExtZkb, "experimental-zkb");
+        else if (Ext == "zkg")
+          setFeatureBits(RISCV::FeatureExtZkg, "experimental-zkg");
+        else if (Ext == "zkn")
+          setFeatureBits(RISCV::FeatureExtZkn, "experimental-zkn");
+        else if (Ext == "zknd")
+          setFeatureBits(RISCV::FeatureExtZknd, "experimental-zknd");
+        else if (Ext == "zkne")
+          setFeatureBits(RISCV::FeatureExtZkne, "experimental-zkne");
+        else if (Ext == "zknh")
+          setFeatureBits(RISCV::FeatureExtZknh, "experimental-zknh");
+        else if (Ext == "zkr")
+          setFeatureBits(RISCV::FeatureExtZkr, "experimental-zkr");
+        else if (Ext == "zkns")
+          setFeatureBits(RISCV::FeatureExtZks, "experimental-zks");
+        else if (Ext == "zknsh")
+          setFeatureBits(RISCV::FeatureExtZksh, "experimental-zksh");
+        else if (Ext == "zknsed")
+          setFeatureBits(RISCV::FeatureExtZksed, "experimental-zksed");
         else
           return Error(ValueExprLoc, "bad arch string " + Ext);
         Arch = Arch.drop_until([](char c) { return ::isdigit(c) || c == '_'; });
         DropFirst = false;
       } else
         return Error(ValueExprLoc, "bad arch string " + Arch);
 
       if (DropFirst)
if (Tag != RISCVAttrs::ARCH) {
       if (getFeatureBits(RISCV::FeatureStdExtD))
         formalArchStr = (Twine(formalArchStr) + "_d2p0").str();
       if (getFeatureBits(RISCV::FeatureStdExtC))
         formalArchStr = (Twine(formalArchStr) + "_c2p0").str();
       if (getFeatureBits(RISCV::FeatureStdExtB))
         formalArchStr = (Twine(formalArchStr) + "_b0p93").str();
       if (getFeatureBits(RISCV::FeatureStdExtV))
         formalArchStr = (Twine(formalArchStr) + "_v0p10").str();
+      if (getFeatureBits(RISCV::FeatureStdExtK))
+        formalArchStr = (Twine(formalArchStr) + "_k0p9").str();
       if (getFeatureBits(RISCV::FeatureExtZfh))
         formalArchStr = (Twine(formalArchStr) + "_zfh0p1").str();
       if (getFeatureBits(RISCV::FeatureExtZba))
         formalArchStr = (Twine(formalArchStr) + "_zba0p93").str();
       if (getFeatureBits(RISCV::FeatureExtZbb))
         formalArchStr = (Twine(formalArchStr) + "_zbb0p93").str();
       if (getFeatureBits(RISCV::FeatureExtZbc))
         formalArchStr = (Twine(formalArchStr) + "_zbc0p93").str();
if (Tag != RISCVAttrs::ARCH) {
       if (getFeatureBits(RISCV::FeatureExtZbs))
         formalArchStr = (Twine(formalArchStr) + "_zbs0p93").str();
       if (getFeatureBits(RISCV::FeatureExtZbt))
         formalArchStr = (Twine(formalArchStr) + "_zbt0p93").str();
       if (getFeatureBits(RISCV::FeatureExtZvamo))
         formalArchStr = (Twine(formalArchStr) + "_zvamo0p10").str();
       if (getFeatureBits(RISCV::FeatureStdExtZvlsseg))
         formalArchStr = (Twine(formalArchStr) + "_zvlsseg0p10").str();
-
+      if (getFeatureBits(RISCV::FeatureExtZkb))
+        formalArchStr = (Twine(formalArchStr) + "_zkb0p9").str();
+      if (getFeatureBits(RISCV::FeatureExtZkg))
+        formalArchStr = (Twine(formalArchStr) + "_zkg0p9").str();
+      if (getFeatureBits(RISCV::FeatureExtZkn))
+        formalArchStr = (Twine(formalArchStr) + "_zkn0p9").str();
+      if (getFeatureBits(RISCV::FeatureExtZknd))
+        formalArchStr = (Twine(formalArchStr) + "_zknd0p9").str();
+      if (getFeatureBits(RISCV::FeatureExtZkne))
+        formalArchStr = (Twine(formalArchStr) + "_zkne0p9").str();
+      if (getFeatureBits(RISCV::FeatureExtZknh))
+        formalArchStr = (Twine(formalArchStr) + "_zknh0p9").str();
+      if (getFeatureBits(RISCV::FeatureExtZkr))
+        formalArchStr = (Twine(formalArchStr) + "_zkr0p9").str();
+      if (getFeatureBits(RISCV::FeatureExtZks))
+        formalArchStr = (Twine(formalArchStr) + "_zks0p9").str();
+      if (getFeatureBits(RISCV::FeatureExtZksh))
+        formalArchStr = (Twine(formalArchStr) + "_zksh0p9").str();
+      if (getFeatureBits(RISCV::FeatureExtZksed))
+        formalArchStr = (Twine(formalArchStr) + "_zksed0p9").str();
       getTargetStreamer().emitTextAttribute(Tag, formalArchStr);
     }
   }
 
   return false;
 }
 
 void RISCVAsmParser::emitToStreamer(MCStreamer &S, const MCInst &Inst) {

llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.h

 //===-- RISCVBaseInfo.h - Top level definitions for RISCV MC ----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
enum {
   // multiple "bitmask" flags.
   MO_DIRECT_FLAG_MASK = 15
 };
 } // namespace RISCVII
 
 namespace RISCVOp {
 enum OperandType : unsigned {
   OPERAND_FIRST_RISCV_IMM = MCOI::OPERAND_FIRST_TARGET,
-  OPERAND_UIMM4 = OPERAND_FIRST_RISCV_IMM,
+  OPERAND_UIMM2 = OPERAND_FIRST_RISCV_IMM,
+  OPERAND_UIMM4,
   OPERAND_UIMM5,
   OPERAND_UIMM12,
   OPERAND_SIMM12,
   OPERAND_UIMM20,
   OPERAND_UIMMLOG2XLEN,
   OPERAND_LAST_RISCV_IMM = OPERAND_UIMMLOG2XLEN,
   // Operand is either a register or uimm5, this is used by V extension pseudo
   // instructions to represent a value that be passed as AVL to either vsetvli

llvm/lib/Target/RISCV/MCTargetDesc/RISCVTargetStreamer.cpp

 //===-- RISCVTargetStreamer.cpp - RISCV Target Streamer Methods -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
void RISCVTargetStreamer::emitTargetAttributes(const MCSubtargetInfo &STI) {
   if (STI.hasFeature(RISCV::FeatureExtZbs))
     Arch += "_zbs0p93";
   if (STI.hasFeature(RISCV::FeatureExtZbt))
     Arch += "_zbt0p93";
   if (STI.hasFeature(RISCV::FeatureExtZvamo))
     Arch += "_zvamo0p10";
   if (STI.hasFeature(RISCV::FeatureStdExtZvlsseg))
     Arch += "_zvlsseg0p10";
+  if (STI.hasFeature(RISCV::FeatureStdExtK))
+    Arch += "_k0p9";
+  if (STI.hasFeature(RISCV::FeatureExtZkb))
+    Arch += "_zkb0p9";
+  if (STI.hasFeature(RISCV::FeatureExtZkg))
+    Arch += "_zkg0p9";
+  if (STI.hasFeature(RISCV::FeatureExtZkn))
+    Arch += "_zkn0p9";
+  if (STI.hasFeature(RISCV::FeatureExtZknd))
+    Arch += "_zknd0p9";
+  if (STI.hasFeature(RISCV::FeatureExtZkne))
+    Arch += "_zkne0p9";
+  if (STI.hasFeature(RISCV::FeatureExtZknh))
+    Arch += "_zknh0p9";
+  if (STI.hasFeature(RISCV::FeatureExtZkr))
+    Arch += "_zkr0p9";
+  if (STI.hasFeature(RISCV::FeatureExtZks))
+    Arch += "_zks0p9";
+  if (STI.hasFeature(RISCV::FeatureExtZksh))
+    Arch += "_zksh0p9";
+  if (STI.hasFeature(RISCV::FeatureExtZksed))
+    Arch += "_zksed0p9";
 
   emitTextAttribute(RISCVAttrs::ARCH, Arch);
 }
 
 // This part is for ascii assembly output
 RISCVTargetAsmStreamer::RISCVTargetAsmStreamer(MCStreamer &S,
                                                formatted_raw_ostream &OS)
     : RISCVTargetStreamer(S), OS(OS) {}

llvm/lib/Target/RISCV/RISCV.td

def HasStdExtZvlsseg : Predicate<"Subtarget->hasStdExtZvlsseg()">,
                                  AssemblerPredicate<(all_of FeatureStdExtZvlsseg),
                                  "'Zvlsseg' (Vector segment load/store instructions)">;
 
 def FeatureExtZvamo
     : SubtargetFeature<"experimental-zvamo", "HasStdExtZvamo", "true",
                        "'Zvamo' (Vector AMO Operations)",
                        [FeatureStdExtV]>;
 def HasStdExtZvamo : Predicate<"Subtarget->hasStdExtZvamo()">,
-                               AssemblerPredicate<(all_of FeatureExtZvamo),
-                               "'Zvamo' (Vector AMO Operations)">;
 
+def FeatureExtZkb
+    : SubtargetFeature<"experimental-zkb", "HasStdExtZkb", "true",
+                       "'Zkb' (Bitmanip subset included in the scalar cryptography extension)",
+                       [FeatureExtZbp]>;
+def HasStdExtZkb : Predicate<"Subtarget->hasStdExtZkb()">,
+                              AssemblerPredicate<(all_of FeatureExtZkb),
+                              "'Zkb' (Bitmanip subset included in the scalar cryptography extension)">;
+def FeatureExtZkg
+    : SubtargetFeature<"experimental-zkg", "HasStdExtZkg", "true",
+                       "'Zkg' (Constant time carry-less multiply for Galois/Counter Mode)",
+                       [FeatureExtZbc]>;
+def HasStdExtZkg : Predicate<"Subtarget->hasStdExtZkg()">,
+                              AssemblerPredicate<(all_of FeatureExtZkg),
+                              "'Zkg' (Constant time carry-less multiply for Galois/Counter Mode)">;
+def FeatureExtZksh
+    : SubtargetFeature<"experimental-zksh", "HasStdExtZksh", "true",
+                       "'Zksh' (SM3 Hash function instructions)">;
+def HasStdExtZksh : Predicate<"Subtarget->hasStdExtZksh()">,
+                              AssemblerPredicate<(all_of FeatureExtZksh),
+                              "'Zksh' (SM3 Hash function instructions)">;
+def FeatureExtZksed
+    : SubtargetFeature<"experimental-zksed", "HasStdExtZksed", "true",
+                       "'Zksed' (SM4 Instructions)">;
+def HasStdExtZksed : Predicate<"Subtarget->hasStdExtZksed()">,
+                              AssemblerPredicate<(all_of FeatureExtZksed),
+                              "'Zksed' (SM4 Instructions)">;
+def FeatureExtZks
+    : SubtargetFeature<"experimental-zks", "HasStdExtZks", "true",
+                       "'Zks' (ShangMi (SM) algorithm suite)",
+                       [FeatureExtZksed,
+                        FeatureExtZksh,
+                        FeatureExtZkg,
+                        FeatureExtZkb]>;
+def HasStdExtZks : Predicate<"Subtarget->hasStdExtZks()">,
+                              AssemblerPredicate<(all_of FeatureExtZks),
+                              "'Zks' (ShangMi (SM) algorithm suite)">;
+def FeatureExtZknh
+    : SubtargetFeature<"experimental-zknh", "HasStdExtZknh", "true",
+                       "'Zknh' (NIST SHA2 Hash function instructions)">;
+def HasStdExtZknh : Predicate<"Subtarget->hasStdExtZknh()">,
+                              AssemblerPredicate<(all_of FeatureExtZknh),
+                              "'Zknh' (NIST SHA2 Hash function instructions)">;
+def FeatureExtZkne
+    : SubtargetFeature<"experimental-zkne", "HasStdExtZkne", "true",
+                       "'Zkne' (NIST AES Encryption Instructions)">;
+def HasStdExtZkne : Predicate<"Subtarget->hasStdExtZkne()">,
+                              AssemblerPredicate<(all_of FeatureExtZkne),
+                              "'Zkne' (NIST AES Encryption Instructions)">;
+def FeatureExtZknd
+    : SubtargetFeature<"experimental-zknd", "HasStdExtZknd", "true",
+                       "'Zknd' (NIST AES Decryption Instructions)">;
+def HasStdExtZknd : Predicate<"Subtarget->hasStdExtZknd()">,
+                              AssemblerPredicate<(all_of FeatureExtZknd),
+                              "'Zknd' (NIST AES Decryption Instructions)">;
+def FeatureExtZkn
+    : SubtargetFeature<"experimental-zkn", "HasStdExtZkn", "true",
+                       "'Zkn' (NIST algorithm suite)",
+                       [FeatureExtZknd,
+                        FeatureExtZkne,
+                        FeatureExtZknh,
+                        FeatureExtZkg,
+                        FeatureExtZkb]>;
+def HasStdExtZkn : Predicate<"Subtarget->hasStdExtZkn()">,
+                              AssemblerPredicate<(all_of FeatureExtZkn),
+                              "'Zkn' (NIST algorithm suite)">;
+def FeatureExtZkr
+    : SubtargetFeature<"experimental-zkr", "HasStdExtZkr", "true",
+                       "'Zkr' (Entropy source for seeding random number generators)">;
+def HasStdExtZkr : Predicate<"Subtarget->hasStdExtZkr()">,
+                              AssemblerPredicate<(all_of FeatureExtZkr),
+                              "'Zkr' (Entropy source for seeding random number generators)">;
+def FeatureStdExtK
+    : SubtargetFeature<"experimental-k", "HasStdExtK", "true",
+                       "'K' (Scalar Cryptography Instructions)",
+                       [FeatureExtZkr,
+                        FeatureExtZkn]>;
+def HasStdExtK : Predicate<"Subtarget->hasStdExtK()">,
+                           AssemblerPredicate<(all_of FeatureStdExtK),
+                           "'K' (Scalar Cryptography Instructions)">;
+
 def Feature64Bit
     : SubtargetFeature<"64bit", "HasRV64", "true", "Implements RV64">;
 def IsRV64 : Predicate<"Subtarget->is64Bit()">,
                        AssemblerPredicate<(all_of Feature64Bit),
                        "RV64I Base Instruction Set">;
 def IsRV32 : Predicate<"!Subtarget->is64Bit()">,
                        AssemblerPredicate<(all_of (not Feature64Bit)),
                        "RV32I Base Instruction Set">;

llvm/lib/Target/RISCV/RISCVInstrInfo.td

let MCOperandPredicate = [{
     if (STI.getTargetTriple().isArch64Bit())
       return isUInt<6>(Imm);
     return isUInt<5>(Imm);
   }];
   let OperandType = "OPERAND_UIMMLOG2XLEN";
   let OperandNamespace = "RISCVOp";
 }
 
+def uimm2 : Operand<XLenVT>, ImmLeaf<XLenVT, [{return isUInt<2>(Imm);}]> {
+  let ParserMatchClass = UImmAsmOperand<2>;
+  let DecoderMethod = "decodeUImmOperand<2>";
+  let OperandType = "OPERAND_UIMM2";
+  let OperandNamespace = "RISCVOp";
+}
+
 def uimm5 : Operand<XLenVT>, ImmLeaf<XLenVT, [{return isUInt<5>(Imm);}]> {
   let ParserMatchClass = UImmAsmOperand<5>;
   let DecoderMethod = "decodeUImmOperand<5>";
   let OperandType = "OPERAND_UIMM5";
   let OperandNamespace = "RISCVOp";
 }
 
 def simm12 : Operand<XLenVT>, ImmLeaf<XLenVT, [{return isInt<12>(Imm);}]> {

 
 include "RISCVInstrInfoM.td"
 include "RISCVInstrInfoA.td"
 include "RISCVInstrInfoF.td"
 include "RISCVInstrInfoD.td"
 include "RISCVInstrInfoC.td"
 include "RISCVInstrInfoB.td"
 include "RISCVInstrInfoV.td"
+include "RISCVInstrInfoK.td"
 include "RISCVInstrInfoZfh.td"

llvm/lib/Target/RISCV/RISCVInstrInfoK.td

+//===-- RISCVInstrInfoK.td - RISC-V 'K' instructions -------*- tablegen -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// This file describes the RISC-V instructions from the standard 'K' 
+/// scalar cryptography extension, version 0.9.2.
+/// 
+/// This version is still experimental as the 'K' extension hasn't been
+/// ratified yet.
+///
+//===----------------------------------------------------------------------===//
+
+def RnumArg : AsmOperandClass {
+  let Name = "RnumArg";
+  let RenderMethod = "addImmOperands";
+  let DiagnosticType = "InvalidRnumArg";
+}
+
+def rnum : Operand<XLenVT>, ImmLeaf<XLenVT, [{return isInt<4>(Imm);}]> {
+  let ParserMatchClass = RnumArg;
+  let EncoderMethod = "getImmOpValue";
+  let DecoderMethod = "decodeUImmOperand<4>";
+  let OperandType = "OPERAND_UIMM4";
+  let OperandNamespace = "RISCVOp";
+}
+
+//===----------------------------------------------------------------------===//
+// Instruction class templates
+//===----------------------------------------------------------------------===//
+
+let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in
+class RVKUnary<bits<7> funct7, bits<5> funct5, bits<3> funct3, string opcodestr>
+    : RVInstR<funct7, funct3, OPC_OP_IMM, (outs GPR:$rd), (ins GPR:$rs1), opcodestr, "$rd, $rs1"> {
+        let Inst{24-20} = funct5;
+    }
+
+let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in
+class RVKBinary<bits<7> funct7, bits<3> funct3, string opcodestr>
+    : RVInstR<funct7, funct3, OPC_OP, (outs GPR:$rd), (ins GPR:$rs1, GPR:$rs2),
+            opcodestr, "$rd, $rs1, $rs2">;
+
+let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in
+class RVKByteSelect<bits<5> funct5, string opcodestr>
+    : RVInstR<{0b00, funct5}, 0b000, OPC_OP, (outs GPR:$rd), (ins GPR:$rs1, GPR:$rs2, uimm2:$bs),
+            opcodestr, "$rd, $rs1, $rs2, $bs"> {
+        bits<2> bs;
+        let Inst{31-30}=bs;
+    }
+
+let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in
+class RVKUnary_rnum<bits<7> funct7, bits<3> funct3, string opcodestr>
+    : RVInstI<funct3, OPC_OP_IMM, (outs GPR:$rd), (ins GPR:$rs1, rnum:$rnum),
+            opcodestr, "$rd, $rs1, $rnum"> {
+    bits<4> rnum;
+    
+    let Inst{31-25} = funct7;
+    let Inst{24} = 1;
+    let Inst{23-20} = rnum;
+}
+
+//===----------------------------------------------------------------------===//
+// Instructions
+//===----------------------------------------------------------------------===//
+
+let Predicates = [HasStdExtZkr] in {
+// Assembler Pseudo Instructions
+def : InstAlias<"getnoise $rd", (CSRRS GPR:$rd, MNOISE.Encoding, X0)>;
+def : InstAlias<"pollentropy $rd", (CSRRS GPR:$rd, MENTROPY.Encoding, X0)>;
+}// Predicates = [HasStdExtZkr]
+
+let Predicates = [HasStdExtZkne, IsRV32] in {
+def AES32ESI : RVKByteSelect<0b10001, "aes32esi">;
+def AES32ESMI : RVKByteSelect<0b10011, "aes32esmi">;
+} // Predicates = [HasStdExtZkne, IsRV32]
+
+let Predicates = [HasStdExtZkne, IsRV64] in {
+def AES64ES : RVKBinary<0b0011001, 0b000, "aes64es">;
+def AES64ESM : RVKBinary<0b0011011, 0b000, "aes64esm">;
+def AES64KS2 : RVKBinary<0b0111111, 0b000, "aes64ks2">;
+def AES64KS1I : RVKUnary_rnum<0b0011000, 0b001, "aes64ks1i">;
+} // Predicates = [HasStdExtZkne, IsRV64]
+
+let Predicates = [HasStdExtZknd, IsRV32] in {
+def AES32DSI : RVKByteSelect<0b10101, "aes32dsi">;
+def AES32DSMI : RVKByteSelect<0b10111, "aes32dsmi">;
+} // Predicates = [HasStdExtZknd, IsRV32]
+
+let Predicates = [HasStdExtZknd, IsRV64] in {
+def AES64DS : RVKBinary<0b0011101, 0b000, "aes64ds">;
+def AES64IM : RVKUnary<0b0011000, 0b00000, 0b001, "aes64im">;
+
+def AES64DSM : RVKBinary<0b0011111, 0b000, "aes64dsm">;
+} // Predicates = [HasStdExtZknd, IsRV64]
+
+let Predicates = [HasStdExtZknh] in {
+def SHA256SUM0 : RVKUnary<0b0001000, 0b00000, 0b001, "sha256sum0">;
+def SHA256SUM1 : RVKUnary<0b0001000, 0b00001, 0b001, "sha256sum1">;
+def SHA256SIG0 : RVKUnary<0b0001000, 0b00010, 0b001, "sha256sig0">;
+def SHA256SIG1 : RVKUnary<0b0001000, 0b00011, 0b001, "sha256sig1">;
+} // Predicates = [HasStdExtZknh]
+
+let Predicates = [HasStdExtZknh, IsRV32] in {
+def SHA512SUM0R : RVKBinary<0b0101000, 0b000, "sha512sum0r">;
+def SHA512SUM1R : RVKBinary<0b0101001, 0b000, "sha512sum1r">;
+def SHA512SIG0L : RVKBinary<0b0101010, 0b000, "sha512sig0l">;
+def SHA512SIG0H : RVKBinary<0b0101110, 0b000, "sha512sig0h">;
+def SHA512SIG1L : RVKBinary<0b0101011, 0b000, "sha512sig1l">;
+def SHA512SIG1H : RVKBinary<0b0101111, 0b000, "sha512sig1h">;
+} // Predicates = [HasStdExtZknh, IsRV32]
+
+let Predicates = [HasStdExtZknh, IsRV64] in {
+def SHA512SUM0 : RVKUnary<0b0001000, 0b00100, 0b001, "sha512sum0">;
+def SHA512SUM1 : RVKUnary<0b0001000, 0b00101, 0b001, "sha512sum1">;
+def SHA512SIG0 : RVKUnary<0b0001000, 0b00110, 0b001, "sha512sig0">;
+def SHA512SIG1 : RVKUnary<0b0001000, 0b00111, 0b001, "sha512sig1">;
+} // Predicates = [HasStdExtZknh, IsRV64]
+
+let Predicates = [HasStdExtZksed] in {
+def SM4ED : RVKByteSelect<0b11000, "sm4ed">;
+def SM4KS : RVKByteSelect<0b11010, "sm4ks">;
+} // Predicates = [HasStdExtZksed]
+
+let Predicates = [HasStdExtZksh] in {
+def SM3P0 : RVKUnary<0b0001000, 0b01000, 0b001, "sm3p0">;
+def SM3P1 : RVKUnary<0b0001000, 0b01001, 0b001, "sm3p1">;
+} // Predicates = [HasStdExtZksh]

llvm/lib/Target/RISCV/RISCVSchedRocket.td

 // This works with MachineScheduler. See MCSchedule.h for details.
 
 // Rocket machine model for scheduling and other instruction cost heuristics.
 def RocketModel : SchedMachineModel {
   let MicroOpBufferSize = 0; // Rocket is in-order.
   let IssueWidth = 1;        // 1 micro-op is dispatched per cycle.
   let LoadLatency = 3;
   let MispredictPenalty = 3;
-  let UnsupportedFeatures = [HasStdExtV, HasStdExtZvamo, HasStdExtZvlsseg];
+  let UnsupportedFeatures = [HasStdExtV, HasStdExtZvamo, HasStdExtZvlsseg, HasStdExtZkr, HasStdExtZknd, HasStdExtZkne, HasStdExtZknh, HasStdExtZksed, HasStdExtZksh];
 }
 
 //===----------------------------------------------------------------------===//
 // Define each kind of processor resource and number available.
 
 // Modeling each pipeline as a ProcResource using the BufferSize = 0 since
 // Rocket is in-order.
 

llvm/lib/Target/RISCV/RISCVSchedSiFive7.td

 
 // SiFive7 machine model for scheduling and other instruction cost heuristics.
 def SiFive7Model : SchedMachineModel {
   let MicroOpBufferSize = 0; // Explicitly set to zero since SiFive7 is in-order.
   let IssueWidth = 2;        // 2 micro-ops are dispatched per cycle.
   let LoadLatency = 3;
   let MispredictPenalty = 3;
   let CompleteModel = 0;
-  let UnsupportedFeatures = [HasStdExtV, HasStdExtZvamo, HasStdExtZvlsseg];
+  let UnsupportedFeatures = [HasStdExtV, HasStdExtZvamo, HasStdExtZvlsseg, HasStdExtZkr, HasStdExtZknd, HasStdExtZkne, HasStdExtZknh, HasStdExtZksed, HasStdExtZksh];
 }
 
 // The SiFive7 microarchitecture has two pipelines: A and B.
 // Pipe A can handle memory, integer alu and vector operations.
 // Pipe B can handle integer alu, control flow, integer multiply and divide,
 // and floating point computation.
 let SchedModel = SiFive7Model in {
 let BufferSize = 0 in {

llvm/lib/Target/RISCV/RISCVSubtarget.h

 //===-- RISCVSubtarget.h - Define Subtarget for the RISCV -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
class RISCVSubtarget : public RISCVGenSubtargetInfo {
   bool HasStdExtZbr = false;
   bool HasStdExtZbs = false;
   bool HasStdExtZbt = false;
   bool HasStdExtZbproposedc = false;
   bool HasStdExtV = false;
   bool HasStdExtZvlsseg = false;
   bool HasStdExtZvamo = false;
   bool HasStdExtZfh = false;
+  bool HasStdExtK = false;
+  bool HasStdExtZkb = false;
+  bool HasStdExtZkg = false;
+  bool HasStdExtZkn = false;
+  bool HasStdExtZknd = false;
+  bool HasStdExtZkne = false;
+  bool HasStdExtZknh = false;
+  bool HasStdExtZkr = false;
+  bool HasStdExtZks = false;
+  bool HasStdExtZksh = false;
+  bool HasStdExtZksed = false;
   bool HasRV64 = false;
   bool IsRV32E = false;
   bool EnableLinkerRelax = false;
   bool EnableRVCHintInstrs = true;
   bool EnableSaveRestore = false;
   unsigned XLen = 32;
   MVT XLenVT = MVT::i32;
   uint8_t MaxInterleaveFactor = 2;
public:
   bool hasStdExtZbr() const { return HasStdExtZbr; }
   bool hasStdExtZbs() const { return HasStdExtZbs; }
   bool hasStdExtZbt() const { return HasStdExtZbt; }
   bool hasStdExtZbproposedc() const { return HasStdExtZbproposedc; }
   bool hasStdExtV() const { return HasStdExtV; }
   bool hasStdExtZvlsseg() const { return HasStdExtZvlsseg; }
   bool hasStdExtZvamo() const { return HasStdExtZvamo; }
   bool hasStdExtZfh() const { return HasStdExtZfh; }
+  bool hasStdExtK() const { return HasStdExtK; }
+  bool hasStdExtZkb() const { return HasStdExtZkb; }
+  bool hasStdExtZkg() const { return HasStdExtZkg; }
+  bool hasStdExtZkn() const { return HasStdExtZkn; }
+  bool hasStdExtZknd() const { return HasStdExtZknd; }
+  bool hasStdExtZkne() const { return HasStdExtZkne; }
+  bool hasStdExtZknh() const { return HasStdExtZknh; }
+  bool hasStdExtZkr() const { return HasStdExtZkr; }
+  bool hasStdExtZks() const { return HasStdExtZks; }
+  bool hasStdExtZksh() const { return HasStdExtZksh; }
+  bool hasStdExtZksed() const { return HasStdExtZksed; }
   bool is64Bit() const { return HasRV64; }
   bool isRV32E() const { return IsRV32E; }
   bool enableLinkerRelax() const { return EnableLinkerRelax; }
   bool enableRVCHintInstrs() const { return EnableRVCHintInstrs; }
   bool enableSaveRestore() const { return EnableSaveRestore; }
   MVT getXLenVT() const { return XLenVT; }
   unsigned getXLen() const { return XLen; }
   RISCVABI::ABI getTargetABI() const { return TargetABI; }

llvm/lib/Target/RISCV/RISCVSystemOperands.td

 // User Vector CSRs
 //===-----------------------------------------------
 def : SysReg<"vstart", 0x008>;
 def : SysReg<"vxsat", 0x009>;
 def : SysReg<"vxrm", 0x00A>;
 def : SysReg<"vl", 0xC20>;
 def : SysReg<"vtype", 0xC21>;
 def : SysReg<"vlenb", 0xC22>;
+
+//===-----------------------------------------------
+// Machine Scalar Cryptography CSRs
+//===-----------------------------------------------
+def MENTROPY : SysReg<"mentropy", 0xF15>;
+def MNOISE   : SysReg<"mnoise", 0x7A9>;

llvm/test/CodeGen/RISCV/attributes.ll

 ; RUN: llc -mtriple=riscv32 -mattr=+experimental-zbe %s -o - | FileCheck --check-prefix=RV32ZBE %s
 ; RUN: llc -mtriple=riscv32 -mattr=+experimental-zbf %s -o - | FileCheck --check-prefix=RV32ZBF %s
 ; RUN: llc -mtriple=riscv32 -mattr=+experimental-zbm %s -o - | FileCheck --check-prefix=RV32ZBM %s
 ; RUN: llc -mtriple=riscv32 -mattr=+experimental-zbp %s -o - | FileCheck --check-prefix=RV32ZBP %s
 ; RUN: llc -mtriple=riscv32 -mattr=+experimental-zbproposedc %s -o - | FileCheck --check-prefix=RV32ZBPROPOSEDC %s
 ; RUN: llc -mtriple=riscv32 -mattr=+experimental-zbr %s -o - | FileCheck --check-prefix=RV32ZBR %s
 ; RUN: llc -mtriple=riscv32 -mattr=+experimental-zbs %s -o - | FileCheck --check-prefix=RV32ZBS %s
 ; RUN: llc -mtriple=riscv32 -mattr=+experimental-zbt %s -o - | FileCheck --check-prefix=RV32ZBT %s
+; RUN: llc -mtriple=riscv32 -mattr=+experimental-k %s -o - | FileCheck --check-prefix=RV32K %s
+; RUN: llc -mtriple=riscv32 -mattr=+experimental-zkb %s -o - | FileCheck --check-prefix=RV32ZKB %s
+; RUN: llc -mtriple=riscv32 -mattr=+experimental-zkg %s -o - | FileCheck --check-prefix=RV32ZKG %s
+; RUN: llc -mtriple=riscv32 -mattr=+experimental-zkN %s -o - | FileCheck --check-prefix=RV32ZKN %s
+; RUN: llc -mtriple=riscv32 -mattr=+experimental-zknd %s -o - | FileCheck --check-prefix=RV32ZKND %s
+; RUN: llc -mtriple=riscv32 -mattr=+experimental-zkne %s -o - | FileCheck --check-prefix=RV32ZKNE %s
+; RUN: llc -mtriple=riscv32 -mattr=+experimental-zknh %s -o - | FileCheck --check-prefix=RV32ZKNH %s
+; RUN: llc -mtriple=riscv32 -mattr=+experimental-zkr %s -o - | FileCheck --check-prefix=RV32ZKR %s
+; RUN: llc -mtriple=riscv32 -mattr=+experimental-zks %s -o - | FileCheck --check-prefix=RV32ZKS %s
+; RUN: llc -mtriple=riscv32 -mattr=+experimental-zksh %s -o - | FileCheck --check-prefix=RV32ZKSH %s
+; RUN: llc -mtriple=riscv32 -mattr=+experimental-zksed %s -o - | FileCheck --check-prefix=RV32ZKSED %s
 ; RUN: llc -mtriple=riscv32 -mattr=+experimental-zbb,+experimental-zfh,+experimental-zvamo,+experimental-v,+f,+experimental-zvlsseg %s -o - | FileCheck --check-prefix=RV32COMBINED %s
 ; RUN: llc -mtriple=riscv64 -mattr=+m %s -o - | FileCheck --check-prefix=RV64M %s
 ; RUN: llc -mtriple=riscv64 -mattr=+a %s -o - | FileCheck --check-prefix=RV64A %s
 ; RUN: llc -mtriple=riscv64 -mattr=+f %s -o - | FileCheck --check-prefix=RV64F %s
 ; RUN: llc -mtriple=riscv64 -mattr=+d %s -o - | FileCheck --check-prefix=RV64D %s
 ; RUN: llc -mtriple=riscv64 -mattr=+c %s -o - | FileCheck --check-prefix=RV64C %s
 ; RUN: llc -mtriple=riscv64 -mattr=+experimental-b %s -o - | FileCheck --check-prefix=RV64B %s
 ; RUN: llc -mtriple=riscv64 -mattr=+experimental-v,+experimental-zvamo,+experimental-zvlsseg %s -o - | FileCheck --check-prefix=RV64V %s
 ; RUN: llc -mtriple=riscv64 -mattr=+experimental-zfh %s -o - | FileCheck --check-prefix=RV64ZFH %s
 ; RUN: llc -mtriple=riscv64 -mattr=+experimental-zba %s -o - | FileCheck --check-prefix=RV64ZBA %s
 ; RUN: llc -mtriple=riscv64 -mattr=+experimental-zbb %s -o - | FileCheck --check-prefix=RV64ZBB %s
 ; RUN: llc -mtriple=riscv64 -mattr=+experimental-zbc %s -o - | FileCheck --check-prefix=RV64ZBC %s
 ; RUN: llc -mtriple=riscv64 -mattr=+experimental-zbe %s -o - | FileCheck --check-prefix=RV64ZBE %s
 ; RUN: llc -mtriple=riscv64 -mattr=+experimental-zbf %s -o - | FileCheck --check-prefix=RV64ZBF %s
 ; RUN: llc -mtriple=riscv64 -mattr=+experimental-zbm %s -o - | FileCheck --check-prefix=RV64ZBM %s
 ; RUN: llc -mtriple=riscv64 -mattr=+experimental-zbp %s -o - | FileCheck --check-prefix=RV64ZBP %s
 ; RUN: llc -mtriple=riscv64 -mattr=+experimental-zbproposedc %s -o - | FileCheck --check-prefix=RV64ZBPROPOSEDC %s
 ; RUN: llc -mtriple=riscv64 -mattr=+experimental-zbr %s -o - | FileCheck --check-prefix=RV64ZBR %s
 ; RUN: llc -mtriple=riscv64 -mattr=+experimental-zbs %s -o - | FileCheck --check-prefix=RV64ZBS %s
 ; RUN: llc -mtriple=riscv64 -mattr=+experimental-zbt %s -o - | FileCheck --check-prefix=RV64ZBT %s
+; RUN: llc -mtriple=riscv64 -mattr=+experimental-k %s -o - | FileCheck --check-prefix=RV64K %s
+; RUN: llc -mtriple=riscv64 -mattr=+experimental-zkb %s -o - | FileCheck --check-prefix=RV64ZKB %s
+; RUN: llc -mtriple=riscv64 -mattr=+experimental-zkg %s -o - | FileCheck --check-prefix=RV64ZKG %s
+; RUN: llc -mtriple=riscv64 -mattr=+experimental-zkN %s -o - | FileCheck --check-prefix=RV64ZKN %s
+; RUN: llc -mtriple=riscv64 -mattr=+experimental-zknd %s -o - | FileCheck --check-prefix=RV64ZKND %s
+; RUN: llc -mtriple=riscv64 -mattr=+experimental-zkne %s -o - | FileCheck --check-prefix=RV64ZKNE %s
+; RUN: llc -mtriple=riscv64 -mattr=+experimental-zknh %s -o - | FileCheck --check-prefix=RV64ZKNH %s
+; RUN: llc -mtriple=riscv64 -mattr=+experimental-zkr %s -o - | FileCheck --check-prefix=RV64ZKR %s
+; RUN: llc -mtriple=riscv64 -mattr=+experimental-zks %s -o - | FileCheck --check-prefix=RV64ZKS %s
+; RUN: llc -mtriple=riscv64 -mattr=+experimental-zksh %s -o - | FileCheck --check-prefix=RV64ZKSH %s
+; RUN: llc -mtriple=riscv64 -mattr=+experimental-zksed %s -o - | FileCheck --check-prefix=RV64ZKSED %s
 ; RUN: llc -mtriple=riscv64 -mattr=+experimental-zbb,+experimental-zfh,+experimental-zvamo,+experimental-v,+f,+experimental-zvlsseg %s -o - | FileCheck --check-prefix=RV64COMBINED %s
 
 ; RV32M: .attribute 5, "rv32i2p0_m2p0"
 ; RV32A: .attribute 5, "rv32i2p0_a2p0"
 ; RV32F: .attribute 5, "rv32i2p0_f2p0"
 ; RV32D: .attribute 5, "rv32i2p0_f2p0_d2p0"
 ; RV32C: .attribute 5, "rv32i2p0_c2p0"
 ; RV32B: .attribute 5, "rv32i2p0_b0p93_zba0p93_zbb0p93_zbc0p93_zbe0p93_zbf0p93_zbm0p93_zbp0p93_zbr0p93_zbs0p93_zbt0p93"
 ; RV32V: .attribute 5, "rv32i2p0_v0p10_zvamo0p10_zvlsseg0p10"
 ; RV32ZFH: .attribute 5, "rv32i2p0_f2p0_zfh0p1"
 ; RV32ZBA: .attribute 5, "rv32i2p0_zba0p93"
 ; RV32ZBB: .attribute 5, "rv32i2p0_zbb0p93"
 ; RV32ZBC: .attribute 5, "rv32i2p0_zbc0p93"
 ; RV32ZBE: .attribute 5, "rv32i2p0_zbe0p93"
 ; RV32ZBF: .attribute 5, "rv32i2p0_zbf0p93"
 ; RV32ZBM: .attribute 5, "rv32i2p0_zbm0p93"
 ; RV32ZBP: .attribute 5, "rv32i2p0_zbp0p93"
 ; RV32ZBPROPOSEDC: .attribute 5, "rv32i2p0_zbproposedc0p93"
 ; RV32ZBR: .attribute 5, "rv32i2p0_zbr0p93"
 ; RV32ZBS: .attribute 5, "rv32i2p0_zbs0p93"
 ; RV32ZBT: .attribute 5, "rv32i2p0_zbt0p93"
+; RV32K: .attribute 5, "rv32i2p0_zbc0p93_zbp0p93_k0p9_zkb0p9_zkg0p9_zkn0p9_zknd0p9_zkne0p9_zknh0p9_zkr0p9"
+; RV32ZKB: .attribute 5, "rv32i2p0_zbp0p93_zkb0p9"
+; RV32ZKG: .attribute 5, "rv32i2p0_zbc0p93_zkg0p9"
+; RV32ZKN: .attribute 5, "rv32i2p0_zbc0p93_zbp0p93_zkb0p9_zkg0p9_zkn0p9_zknd0p9_zkne0p9_zknh0p9"
+; RV32ZKND: .attribute 5, "rv32i2p0_zknd0p9"
+; RV32ZKNE: .attribute 5, "rv32i2p0_zkne0p9"
+; RV32ZKNH: .attribute 5, "rv32i2p0_zknh0p9"
+; RV32ZKR: .attribute 5, "rv32i2p0_zkr0p9"
+; RV32ZKS: .attribute 5, "rv32i2p0_zbc0p93_zbp0p93_zkb0p9_zkg0p9_zks0p9_zksh0p9_zksed0p9"
+; RV32ZKSH: .attribute 5, "rv32i2p0_zksh0p9"
+; RV32ZKSED: .attribute 5, "rv32i2p0_zksed0p9"
 ; RV32COMBINED: .attribute 5, "rv32i2p0_f2p0_v0p10_zfh0p1_zbb0p93_zvamo0p10_zvlsseg0p10"
 
 ; RV64M: .attribute 5, "rv64i2p0_m2p0"
 ; RV64A: .attribute 5, "rv64i2p0_a2p0"
 ; RV64F: .attribute 5, "rv64i2p0_f2p0"
 ; RV64D: .attribute 5, "rv64i2p0_f2p0_d2p0"
 ; RV64C: .attribute 5, "rv64i2p0_c2p0"
 ; RV64B: .attribute 5, "rv64i2p0_b0p93_zba0p93_zbb0p93_zbc0p93_zbe0p93_zbf0p93_zbm0p93_zbp0p93_zbr0p93_zbs0p93_zbt0p93"
 ; RV64ZFH: .attribute 5, "rv64i2p0_f2p0_zfh0p1"
 ; RV64ZBA: .attribute 5, "rv64i2p0_zba0p93"
 ; RV64ZBB: .attribute 5, "rv64i2p0_zbb0p93"
 ; RV64ZBC: .attribute 5, "rv64i2p0_zbc0p93"
 ; RV64ZBE: .attribute 5, "rv64i2p0_zbe0p93"
 ; RV64ZBF: .attribute 5, "rv64i2p0_zbf0p93"
 ; RV64ZBM: .attribute 5, "rv64i2p0_zbm0p93"
 ; RV64ZBP: .attribute 5, "rv64i2p0_zbp0p93"
 ; RV64ZBPROPOSEDC: .attribute 5, "rv64i2p0_zbproposedc0p93"
 ; RV64ZBR: .attribute 5, "rv64i2p0_zbr0p93"
 ; RV64ZBS: .attribute 5, "rv64i2p0_zbs0p93"
 ; RV64ZBT: .attribute 5, "rv64i2p0_zbt0p93"
 ; RV64V: .attribute 5, "rv64i2p0_v0p10_zvamo0p10_zvlsseg0p10"
+; RV64K: .attribute 5, "rv64i2p0_zbc0p93_zbp0p93_k0p9_zkb0p9_zkg0p9_zkn0p9_zknd0p9_zkne0p9_zknh0p9_zkr0p9"
+; RV64ZKB: .attribute 5, "rv64i2p0_zbp0p93_zkb0p9"
+; RV64ZKG: .attribute 5, "rv64i2p0_zbc0p93_zkg0p9"
+; RV64ZKN: .attribute 5, "rv64i2p0_zbc0p93_zbp0p93_zkb0p9_zkg0p9_zkn0p9_zknd0p9_zkne0p9_zknh0p9"
+; RV64ZKND: .attribute 5, "rv64i2p0_zknd0p9"
+; RV64ZKNE: .attribute 5, "rv64i2p0_zkne0p9"
+; RV64ZKNH: .attribute 5, "rv64i2p0_zknh0p9"
+; RV64ZKR: .attribute 5, "rv64i2p0_zkr0p9"
+; RV64ZKS: .attribute 5, "rv64i2p0_zbc0p93_zbp0p93_zkb0p9_zkg0p9_zks0p9_zksh0p9_zksed0p9"
+; RV64ZKSH: .attribute 5, "rv64i2p0_zksh0p9"
+; RV64ZKSED: .attribute 5, "rv64i2p0_zksed0p9"
 ; RV64COMBINED: .attribute 5, "rv64i2p0_f2p0_v0p10_zfh0p1_zbb0p93_zvamo0p10_zvlsseg0p10"
 
 
 define i32 @addi(i32 %a) {
   %1 = add i32 %a, 1
   ret i32 %1
 }

llvm/test/MC/RISCV/attribute-arch.s

 .attribute arch, "rv32ifzfh"
 # CHECK: attribute      5, "rv32i2p0_f2p0_zfh0p1"
 
 .attribute arch, "rv32ivzvamo_zvlsseg"
 # CHECK: attribute      5, "rv32i2p0_v0p10_zvamo0p10_zvlsseg0p10"
 
 .attribute arch, "rv32iv_zvamo0p10_zvlsseg"
 # CHECK: attribute      5, "rv32i2p0_v0p10_zvamo0p10_zvlsseg0p10"
+
+.attribute arch, "rv32ik"
+# CHECK: attribute      5, "rv32i2p0_k0p9_zbc0p93_zbp0p93_zkb0p9_zkg0p9_zkn0p9_zknd0p9_zkne0p9_zknh0p9_zkr0p9"

llvm/test/MC/RISCV/rv32zkb-aliases-valid.s

+# With K extension:
+# RUN: llvm-mc %s -triple=riscv32 -mattr=+experimental-k -riscv-no-aliases \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc %s -triple=riscv32 -mattr=+experimental-k \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+# RUN: llvm-mc -filetype=obj -triple riscv32 -mattr=+experimental-k < %s \
+# RUN:     | llvm-objdump -d -r -M no-aliases --mattr=+experimental-k - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc -filetype=obj -triple riscv32 -mattr=+experimental-k < %s \
+# RUN:     | llvm-objdump -d -r --mattr=+experimental-k - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+
+# With Zkn extension:
+# RUN: llvm-mc %s -triple=riscv32 -mattr=+experimental-zkn -riscv-no-aliases \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc %s -triple=riscv32 -mattr=+experimental-zkn \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+# RUN: llvm-mc -filetype=obj -triple riscv32 -mattr=+experimental-zkn < %s \
+# RUN:     | llvm-objdump -d -r -M no-aliases --mattr=+experimental-zkn - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc -filetype=obj -triple riscv32 -mattr=+experimental-zkn < %s \
+# RUN:     | llvm-objdump -d -r --mattr=+experimental-zkn - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+
+# With Zks extension:
+# RUN: llvm-mc %s -triple=riscv32 -mattr=+experimental-zks -riscv-no-aliases \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc %s -triple=riscv32 -mattr=+experimental-zks \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+# RUN: llvm-mc -filetype=obj -triple riscv32 -mattr=+experimental-zks < %s \
+# RUN:     | llvm-objdump -d -r -M no-aliases --mattr=+experimental-zks - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc -filetype=obj -triple riscv32 -mattr=+experimental-zks < %s \
+# RUN:     | llvm-objdump -d -r --mattr=+experimental-zks - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+
+# With Zkb extension:
+# RUN: llvm-mc %s -triple=riscv32 -mattr=+experimental-zkb -riscv-no-aliases \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc %s -triple=riscv32 -mattr=+experimental-zkb \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+# RUN: llvm-mc -filetype=obj -triple riscv32 -mattr=+experimental-zkb < %s \
+# RUN:     | llvm-objdump -d -r -M no-aliases --mattr=+experimental-zkb - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc -filetype=obj -triple riscv32 -mattr=+experimental-zkb < %s \
+# RUN:     | llvm-objdump -d -r --mattr=+experimental-zkb - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+
+
+# CHECK-S-OBJ-NOALIAS: grevi t0, t1, 7
+# CHECK-S-OBJ: rev.b t0, t1
+rev.b x5, x6
+
+# CHECK-S-OBJ-NOALIAS: shfli t0, t1, 15
+# CHECK-S-OBJ: zip t0, t1
+zip x5, x6
+
+# CHECK-S-OBJ-NOALIAS: unshfli t0, t1, 15
+# CHECK-S-OBJ: unzip t0, t1
+unzip x5, x6

llvm/test/MC/RISCV/rv32zkb-valid.s

+# With K extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-k %s \
+# RUN:      | FileCheck -check-prefixes=CHECK-ASM,CHECK-ASM-AND-OBJ %s
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-k - \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ASM-AND-OBJ
+
+# With Zkn extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-zkn %s \
+# RUN:      | FileCheck -check-prefixes=CHECK-ASM,CHECK-ASM-AND-OBJ %s
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zkn %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zkn - \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ASM-AND-OBJ
+
+# With Zks extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-zks %s \
+# RUN:      | FileCheck -check-prefixes=CHECK-ASM,CHECK-ASM-AND-OBJ %s
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zks %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zks - \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ASM-AND-OBJ
+
+# With Zkb extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-zkb %s \
+# RUN:      | FileCheck -check-prefixes=CHECK-ASM,CHECK-ASM-AND-OBJ %s
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zkb %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zkb - \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ASM-AND-OBJ
+
+
+# CHECK-ASM-AND-OBJ: xperm.n t0, t1, t2
+# CHECK-ASM: encoding: [0xb3,0x22,0x73,0x28]
+xperm.n t0, t1, t2
+
+# CHECK-ASM-AND-OBJ: xperm.b t0, t1, t2
+# CHECK-ASM: encoding: [0xb3,0x42,0x73,0x28]
+xperm.b t0, t1, t2
+
+# CHECK-ASM-AND-OBJ: ror t0, t1, t2
+# CHECK-ASM: encoding: [0xb3,0x52,0x73,0x60]
+ror t0, t1, t2
+
+# CHECK-ASM-AND-OBJ: rol t0, t1, t2
+# CHECK-ASM: encoding: [0xb3,0x12,0x73,0x60]
+rol t0, t1, t2
+
+# CHECK-ASM-AND-OBJ: rori t0, t1, 31
+# CHECK-ASM: encoding: [0x93,0x52,0xf3,0x61]
+rori t0, t1, 31
+
+# CHECK-ASM-AND-OBJ: rori t0, t1, 0
+# CHECK-ASM: encoding: [0x93,0x52,0x03,0x60]
+rori t0, t1, 0
+
+# CHECK-ASM-AND-OBJ: andn t0, t1, t2
+# CHECK-ASM: encoding: [0xb3,0x72,0x73,0x40]
+andn t0, t1, t2
+
+# CHECK-ASM-AND-OBJ: orn t0, t1, t2
+# CHECK-ASM: encoding: [0xb3,0x62,0x73,0x40]
+orn t0, t1, t2
+
+# CHECK-ASM-AND-OBJ: xnor t0, t1, t2
+# CHECK-ASM: encoding: [0xb3,0x42,0x73,0x40]
+xnor t0, t1, t2
+
+# CHECK-ASM-AND-OBJ: pack t0, t1, t2
+# CHECK-ASM: encoding: [0xb3,0x42,0x73,0x08]
+pack t0, t1, t2
+
+# CHECK-ASM-AND-OBJ: packu t0, t1, t2
+# CHECK-ASM: encoding: [0xb3,0x42,0x73,0x48]
+packu t0, t1, t2
+
+# CHECK-ASM-AND-OBJ: packh t0, t1, t2
+# CHECK-ASM: encoding: [0xb3,0x72,0x73,0x08]
+packh t0, t1, t2
+
+# CHECK-ASM-AND-OBJ: rev8 t0, t1
+# CHECK-ASM: encoding: [0x93,0x52,0x83,0x69]
+rev8 t0, t1
+
+# CHECK-ASM-AND-OBJ: grevi t0, t1, 0
+# CHECK-ASM: encoding: [0x93,0x52,0x03,0x68]
+grevi t0, t1, 0
+
+# CHECK-ASM-AND-OBJ: shfli t0, t1, 0
+# CHECK-ASM: encoding: [0x93,0x12,0x03,0x08]
+shfli t0, t1, 0
+
+# CHECK-ASM-AND-OBJ: unshfli t0, t1, 0
+# CHECK-ASM: encoding: [0x93,0x52,0x03,0x08]
+unshfli t0, t1, 0

llvm/test/MC/RISCV/rv32zkg-valid.s

+# With K extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-k %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-k - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+
+# With Zkn extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-zkn %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zkn %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zkn - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+
+# With Zks extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-zks %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zks %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zks - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+
+# With Zkg extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-zkg %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zkg %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zkg - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+
+# CHECK-INST: clmul t0, t1, t2
+# CHECK-ENCODING: [0xb3,0x12,0x73,0x0a]
+clmul t0, t1, t2
+
+# CHECK-INST: clmulh t0, t1, t2
+# CHECK-ENCODING: [0xb3,0x32,0x73,0x0a]
+clmulh t0, t1, t2

llvm/test/MC/RISCV/rv32zknd-only-invalid.s

+# With K extension:
+# RUN: not llvm-mc -triple=riscv32 -mattr=+experimental-k < %s 2>&1 \
+# RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
+
+# With Zkn extension:
+# RUN: not llvm-mc -triple=riscv32 -mattr=+experimental-zkn < %s 2>&1 \
+# RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
+
+# With Zknd extension:
+# RUN: not llvm-mc -triple=riscv32 -mattr=+experimental-zknd < %s 2>&1 \
+# RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
+
+aes32dsmi a0, a1, a2, 8
+# CHECK-ERROR: immediate must be an integer in the range [0, 3]
+
+aes32dsi a0, a1, a2, 8
+# CHECK-ERROR: immediate must be an integer in the range [0, 3]

llvm/test/MC/RISCV/rv32zknd-only-valid.s

+# With K extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-k %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv32 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-k - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# With Zkn extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-zkn %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv32 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zkn %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zkn - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zkn %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# With Zknd extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-zknd %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv32 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zknd %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zknd - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zknd %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# CHECK-INST: aes32dsi a0, a1, a2, 3
+# CHECK-ENCODING: [0x33,0x85,0xc5,0xea]
+# CHECK-ERROR: instruction requires the following: 'Zknd' (NIST AES Decryption Instructions)
+# CHECK-UNKNOWN: 33 85 c5 ea <unknown>
+aes32dsi a0, a1, a2, 3
+
+# CHECK-INST: aes32dsmi a0, a1, a2, 3
+# CHECK-ENCODING: [0x33,0x85,0xc5,0xee]
+# CHECK-ERROR: instruction requires the following: 'Zknd' (NIST AES Decryption Instructions)
+# CHECK-UNKNOWN: 33 85 c5 ee <unknown>
+aes32dsmi a0, a1, a2, 3

llvm/test/MC/RISCV/rv32zkne-only-invalid.s

+# With K extension:
+# RUN: not llvm-mc -triple=riscv32 -mattr=+experimental-k < %s 2>&1 \
+# RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
+
+# With Zkn extension:
+# RUN: not llvm-mc -triple=riscv32 -mattr=+experimental-zkn < %s 2>&1 \
+# RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
+
+# With Zkne extension:
+# RUN: not llvm-mc -triple=riscv32 -mattr=+experimental-zkne < %s 2>&1 \
+# RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
+
+aes32esmi a0, a1, a2, 8
+# CHECK-ERROR: immediate must be an integer in the range [0, 3]
+
+aes32esi a0, a1, a2, 8
+# CHECK-ERROR: immediate must be an integer in the range [0, 3]

llvm/test/MC/RISCV/rv32zkne-only-valid.s

+# With K extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-k %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv32 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-k - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# With Zkn extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-zkn %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv32 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zkn %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zkn - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zkn %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# With Zkne extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-zkne %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv32 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zkne %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zkne - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zkne %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# CHECK-INST: aes32esi a0, a1, a2, 3
+# CHECK-ENCODING: [0x33,0x85,0xc5,0xe2]
+# CHECK-ERROR: instruction requires the following: 'Zkne' (NIST AES Encryption Instructions)
+# CHECK-UNKNOWN: 33 85 c5 e2 <unknown>
+aes32esi a0, a1, a2, 3
+
+# CHECK-INST: aes32esmi a0, a1, a2, 3
+# CHECK-ENCODING: [0x33,0x85,0xc5,0xe6]
+# CHECK-ERROR: instruction requires the following: 'Zkne' (NIST AES Encryption Instructions)
+# CHECK-UNKNOWN: 33 85 c5 e6 <unknown>
+aes32esmi a0, a1, a2, 3

llvm/test/MC/RISCV/rv32zknh-only-valid.s

+# With K extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-k %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv32 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-k - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# With Zkn extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-zkn %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv32 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zkn %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zkn - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zkn %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# With Zknh extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-zknh %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv32 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zknh %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zknh - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zknh %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# CHECK-INST: sha512sig0h a0, a1, a2
+# CHECK-ENCODING: [0x33,0x85,0xc5,0x5c]
+# CHECK-ERROR: instruction requires the following: 'Zknh' (NIST SHA2 Hash function instructions)
+# CHECK-UNKNOWN: 33 85 c5 5c <unknown>
+sha512sig0h a0, a1, a2
+
+# CHECK-INST: sha512sig1h a0, a1, a2
+# CHECK-ENCODING: [0x33,0x85,0xc5,0x5e]
+# CHECK-ERROR: instruction requires the following: 'Zknh' (NIST SHA2 Hash function instructions)
+# CHECK-UNKNOWN: 33 85 c5 5e <unknown>
+sha512sig1h a0, a1, a2
+
+# CHECK-INST: sha512sig0l a0, a1, a2
+# CHECK-ENCODING: [0x33,0x85,0xc5,0x54]
+# CHECK-ERROR: instruction requires the following: 'Zknh' (NIST SHA2 Hash function instructions)
+# CHECK-UNKNOWN: 33 85 c5 54 <unknown>
+sha512sig0l a0, a1, a2
+
+# CHECK-INST: sha512sig1l a0, a1, a2
+# CHECK-ENCODING: [0x33,0x85,0xc5,0x56]
+# CHECK-ERROR: instruction requires the following: 'Zknh' (NIST SHA2 Hash function instructions)
+# CHECK-UNKNOWN: 33 85 c5 56 <unknown>
+sha512sig1l a0, a1, a2
+
+# CHECK-INST: sha512sum0r a0, a1, a2
+# CHECK-ENCODING: [0x33,0x85,0xc5,0x50]
+# CHECK-ERROR: instruction requires the following: 'Zknh' (NIST SHA2 Hash function instructions)
+# CHECK-UNKNOWN: 33 85 c5 50 <unknown>
+sha512sum0r a0, a1, a2
+
+# CHECK-INST: sha512sum1r a0, a1, a2
+# CHECK-ENCODING: [0x33,0x85,0xc5,0x52]
+# CHECK-ERROR: instruction requires the following: 'Zknh' (NIST SHA2 Hash function instructions)
+# CHECK-UNKNOWN: 33 85 c5 52 <unknown>
+sha512sum1r a0, a1, a2

llvm/test/MC/RISCV/rv32zknh-valid.s

+# With K extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-k %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv32 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-k - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# With Zkn extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-zkn %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv32 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zkn %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zkn - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zkn %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# With Zknh extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-zknh %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv32 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zknh %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zknh - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zknh %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# CHECK-INST: sha256sig0 a0, a1
+# CHECK-ENCODING: [0x13,0x95,0x25,0x10]
+# CHECK-ERROR: instruction requires the following: 'Zknh' (NIST SHA2 Hash function instructions)
+# CHECK-UNKNOWN: 13 95 25 10 <unknown>
+sha256sig0 a0, a1
+
+# CHECK-INST: sha256sig1 a0, a1
+# CHECK-ENCODING: [0x13,0x95,0x35,0x10]
+# CHECK-ERROR: instruction requires the following: 'Zknh' (NIST SHA2 Hash function instructions)
+# CHECK-UNKNOWN: 13 95 35 10 <unknown>
+sha256sig1 a0, a1
+
+# CHECK-INST: sha256sum0 a0, a1
+# CHECK-ENCODING: [0x13,0x95,0x05,0x10]
+# CHECK-ERROR: instruction requires the following: 'Zknh' (NIST SHA2 Hash function instructions)
+# CHECK-UNKNOWN: 13 95 05 10 <unknown>
+sha256sum0 a0, a1
+
+# CHECK-INST: sha256sum1 a0, a1
+# CHECK-ENCODING: [0x13,0x95,0x15,0x10]
+# CHECK-ERROR: instruction requires the following: 'Zknh' (NIST SHA2 Hash function instructions)
+# CHECK-UNKNOWN: 13 95 15 10 <unknown>
+sha256sum1 a0, a1

llvm/test/MC/RISCV/rv32zkr-valid.s

+# With K extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-k %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv32 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-k - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# With Zkr extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-zkr %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv32 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zkr %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zkr - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zkr %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# CHECK-INST: csrr a0, mnoise 
+# CHECK-ENCODING: [0x73,0x25,0x90,0x7a]
+# CHECK-ERROR: instruction requires the following: 'Zkr' (Entropy source for seeding random number generators)
+# CHECK-UNKNOWN: 73 25 90 7a
+getnoise a0
+
+# CHECK-INST: csrr a0, mentropy
+# CHECK-ENCODING: [0x73,0x25,0x50,0xf1]
+# CHECK-ERROR: instruction requires the following: 'Zkr' (Entropy source for seeding random number generators)
+# CHECK-UNKNOWN: 73 25 50 f1
+pollentropy a0

llvm/test/MC/RISCV/rv32zksed-invalid.s

+# With Zks extension:
+# RUN: not llvm-mc -triple=riscv32 -mattr=+experimental-zks < %s 2>&1 \
+# RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
+
+# With Zksed extension:
+# RUN: not llvm-mc -triple=riscv32 -mattr=+experimental-zksed < %s 2>&1 \
+# RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
+
+sm4ed a0, a1, a2, 8
+# CHECK-ERROR: immediate must be an integer in the range [0, 3]
+
+sm4ks a0, a1, a2, 8
+# CHECK-ERROR: immediate must be an integer in the range [0, 3]

llvm/test/MC/RISCV/rv32zksed-valid.s

+# With Zks extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-zks %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv32 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zks %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zks - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zks %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# With Zksed extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-zksed %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv32 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zksed %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zksed - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zksed %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# CHECK-INST: sm4ed a0, a1, a2, 3
+# CHECK-ENCODING: [0x33,0x85,0xc5,0xf0]
+# CHECK-ERROR: instruction requires the following: 'Zksed' (SM4 Instructions)
+# CHECK-UNKNOWN: 33 85 c5 f0 <unknown>
+sm4ed a0, a1, a2, 3
+
+# CHECK-INST: sm4ks a0, a1, a2, 3
+# CHECK-ENCODING: [0x33,0x85,0xc5,0xf4]
+# CHECK-ERROR: instruction requires the following: 'Zksed' (SM4 Instructions)
+# CHECK-UNKNOWN: 33 85 c5 f4 <unknown>
+sm4ks a0, a1, a2, 3

llvm/test/MC/RISCV/rv32zksh-valid.s

+# With Zks extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-zks %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv32 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zks %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zks - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zks %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# With Zksh extension:
+# RUN: llvm-mc -triple=riscv32 -show-encoding --mattr=+experimental-zksh %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv32 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zksh %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zksh - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv32 -filetype=obj --mattr=+experimental-zksh %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+
+# CHECK-INST: sm3p0 a0, a1
+# CHECK-ENCODING: [0x13,0x95,0x85,0x10]
+# CHECK-ERROR: instruction requires the following: 'Zksh' (SM3 Hash function instructions)
+# CHECK-UNKNOWN: 13 95 85 10 <unknown>
+sm3p0 a0, a1
+
+# CHECK-INST: sm3p1 a0, a1
+# CHECK-ENCODING: [0x13,0x95,0x95,0x10]
+# CHECK-ERROR: instruction requires the following: 'Zksh' (SM3 Hash function instructions)
+# CHECK-UNKNOWN: 13 95 95 10 <unknown>
+sm3p1 a0, a1

llvm/test/MC/RISCV/rv64zkb-aliases-valid.s

+# With K extension:
+# RUN: llvm-mc %s -triple=riscv64 -mattr=+experimental-k -riscv-no-aliases \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc %s -triple=riscv64 -mattr=+experimental-k \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+# RUN: llvm-mc -filetype=obj -triple riscv64 -mattr=+experimental-k < %s \
+# RUN:     | llvm-objdump -d -r -M no-aliases --mattr=+experimental-k - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc -filetype=obj -triple riscv64 -mattr=+experimental-k < %s \
+# RUN:     | llvm-objdump -d -r --mattr=+experimental-k - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+
+# With Zkn extension:
+# RUN: llvm-mc %s -triple=riscv64 -mattr=+experimental-zkn -riscv-no-aliases \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc %s -triple=riscv64 -mattr=+experimental-zkn \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+# RUN: llvm-mc -filetype=obj -triple riscv64 -mattr=+experimental-zkn < %s \
+# RUN:     | llvm-objdump -d -r -M no-aliases --mattr=+experimental-zkn - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc -filetype=obj -triple riscv64 -mattr=+experimental-zkn < %s \
+# RUN:     | llvm-objdump -d -r --mattr=+experimental-zkn - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+
+# With Zks extension:
+# RUN: llvm-mc %s -triple=riscv64 -mattr=+experimental-zks -riscv-no-aliases \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc %s -triple=riscv64 -mattr=+experimental-zks \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+# RUN: llvm-mc -filetype=obj -triple riscv64 -mattr=+experimental-zks < %s \
+# RUN:     | llvm-objdump -d -r -M no-aliases --mattr=+experimental-zks - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc -filetype=obj -triple riscv64 -mattr=+experimental-zks < %s \
+# RUN:     | llvm-objdump -d -r --mattr=+experimental-zks - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+
+# With Zkb extension:
+# RUN: llvm-mc %s -triple=riscv64 -mattr=+experimental-zkb -riscv-no-aliases \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc %s -triple=riscv64 -mattr=+experimental-zkb \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+# RUN: llvm-mc -filetype=obj -triple riscv64 -mattr=+experimental-zkb < %s \
+# RUN:     | llvm-objdump -d -r -M no-aliases --mattr=+experimental-zkb - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc -filetype=obj -triple riscv64 -mattr=+experimental-zkb < %s \
+# RUN:     | llvm-objdump -d -r --mattr=+experimental-zkb - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+
+
+# CHECK-S-OBJ-NOALIAS: grevi t0, t1, 7
+# CHECK-S-OBJ: rev.b t0, t1
+rev.b x5, x6
+
+# CHECK-S-OBJ-NOALIAS: shfli t0, t1, 31
+# CHECK-S-OBJ: zip t0, t1
+zip x5, x6
+
+# CHECK-S-OBJ-NOALIAS: unshfli t0, t1, 31
+# CHECK-S-OBJ: unzip t0, t1
+unzip x5, x6

llvm/test/MC/RISCV/rv64zkb-only-aliases-valid.s

+# With K extension:
+# RUN: llvm-mc %s -triple=riscv64 -mattr=+experimental-k -riscv-no-aliases \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc %s -triple=riscv64 -mattr=+experimental-k \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+# RUN: llvm-mc -filetype=obj -triple riscv64 -mattr=+experimental-k < %s \
+# RUN:     | llvm-objdump -d -r -M no-aliases --mattr=+experimental-k - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc -filetype=obj -triple riscv64 -mattr=+experimental-k < %s \
+# RUN:     | llvm-objdump -d -r --mattr=+experimental-k - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+
+# With Zkn extension:
+# RUN: llvm-mc %s -triple=riscv64 -mattr=+experimental-zkn -riscv-no-aliases \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc %s -triple=riscv64 -mattr=+experimental-zkn \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+# RUN: llvm-mc -filetype=obj -triple riscv64 -mattr=+experimental-zkn < %s \
+# RUN:     | llvm-objdump -d -r -M no-aliases --mattr=+experimental-zkn - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc -filetype=obj -triple riscv64 -mattr=+experimental-zkn < %s \
+# RUN:     | llvm-objdump -d -r --mattr=+experimental-zkn - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+
+# With Zks extension:
+# RUN: llvm-mc %s -triple=riscv64 -mattr=+experimental-zks -riscv-no-aliases \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc %s -triple=riscv64 -mattr=+experimental-zks \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+# RUN: llvm-mc -filetype=obj -triple riscv64 -mattr=+experimental-zks < %s \
+# RUN:     | llvm-objdump -d -r -M no-aliases --mattr=+experimental-zks - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc -filetype=obj -triple riscv64 -mattr=+experimental-zks < %s \
+# RUN:     | llvm-objdump -d -r --mattr=+experimental-zks - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+
+# With Zkb extension:
+# RUN: llvm-mc %s -triple=riscv64 -mattr=+experimental-zkb -riscv-no-aliases \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc %s -triple=riscv64 -mattr=+experimental-zkb \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+# RUN: llvm-mc -filetype=obj -triple riscv64 -mattr=+experimental-zkb < %s \
+# RUN:     | llvm-objdump -d -r -M no-aliases --mattr=+experimental-zkb - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ-NOALIAS %s
+# RUN: llvm-mc -filetype=obj -triple riscv64 -mattr=+experimental-zkb < %s \
+# RUN:     | llvm-objdump -d -r --mattr=+experimental-zkb - \
+# RUN:     | FileCheck -check-prefixes=CHECK-S-OBJ %s
+
+
+# CHECK-S-OBJ-NOALIAS: grevi t0, t1, 24
+# CHECK-S-OBJ: rev8.w t0, t1
+rev8.w x5, x6

llvm/test/MC/RISCV/rv64zkb-only-valid.s

+# With K extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-k %s \
+# RUN:      | FileCheck -check-prefixes=CHECK-ASM,CHECK-ASM-AND-OBJ %s
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-k - \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ASM-AND-OBJ
+
+# With Zkn extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-zkn %s \
+# RUN:      | FileCheck -check-prefixes=CHECK-ASM,CHECK-ASM-AND-OBJ %s
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zkn %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zkn - \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ASM-AND-OBJ
+
+# With Zks extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-zks %s \
+# RUN:      | FileCheck -check-prefixes=CHECK-ASM,CHECK-ASM-AND-OBJ %s
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zks %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zks - \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ASM-AND-OBJ
+
+# With Zkb extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-zkb %s \
+# RUN:      | FileCheck -check-prefixes=CHECK-ASM,CHECK-ASM-AND-OBJ %s
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zkb %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zkb - \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ASM-AND-OBJ
+
+
+# CHECK-ASM-AND-OBJ: roriw t0, t1, 31
+# CHECK-ASM: encoding: [0x9b,0x52,0xf3,0x61]
+roriw t0, t1, 31
+
+# CHECK-ASM-AND-OBJ: roriw t0, t1, 0
+# CHECK-ASM: encoding: [0x9b,0x52,0x03,0x60]
+roriw t0, t1, 0
+
+# CHECK-ASM-AND-OBJ: packw t0, t1, t2
+# CHECK-ASM: encoding: [0xbb,0x42,0x73,0x08]
+packw t0, t1, t2
+
+# CHECK-ASM-AND-OBJ: packuw t0, t1, t2
+# CHECK-ASM: encoding: [0xbb,0x42,0x73,0x48]
+packuw t0, t1, t2

llvm/test/MC/RISCV/rv64zkb-valid.s

+# With K extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-k %s \
+# RUN:      | FileCheck -check-prefixes=CHECK-ASM,CHECK-ASM-AND-OBJ %s
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-k - \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ASM-AND-OBJ
+
+# With Zkn extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-zkn %s \
+# RUN:      | FileCheck -check-prefixes=CHECK-ASM,CHECK-ASM-AND-OBJ %s
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zkn %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zkn - \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ASM-AND-OBJ
+
+# With Zks extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-zks %s \
+# RUN:      | FileCheck -check-prefixes=CHECK-ASM,CHECK-ASM-AND-OBJ %s
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zks %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zks - \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ASM-AND-OBJ
+
+# With Zkb extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-zkb %s \
+# RUN:      | FileCheck -check-prefixes=CHECK-ASM,CHECK-ASM-AND-OBJ %s
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zkb %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zkb - \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ASM-AND-OBJ
+
+
+# CHECK-ASM-AND-OBJ: xperm.n t0, t1, t2
+# CHECK-ASM: encoding: [0xb3,0x22,0x73,0x28]
+xperm.n t0, t1, t2
+
+# CHECK-ASM-AND-OBJ: xperm.b t0, t1, t2
+# CHECK-ASM: encoding: [0xb3,0x42,0x73,0x28]
+xperm.b t0, t1, t2
+
+# CHECK-ASM-AND-OBJ: ror t0, t1, t2
+# CHECK-ASM: encoding: [0xb3,0x52,0x73,0x60]
+ror t0, t1, t2
+
+# CHECK-ASM-AND-OBJ: rol t0, t1, t2
+# CHECK-ASM: encoding: [0xb3,0x12,0x73,0x60]
+rol t0, t1, t2
+
+# CHECK-ASM-AND-OBJ: rori t0, t1, 31
+# CHECK-ASM: encoding: [0x93,0x52,0xf3,0x61]
+rori t0, t1, 31
+
+# CHECK-ASM-AND-OBJ: rori t0, t1, 0
+# CHECK-ASM: encoding: [0x93,0x52,0x03,0x60]
+rori t0, t1, 0
+
+# CHECK-ASM-AND-OBJ: andn t0, t1, t2
+# CHECK-ASM: encoding: [0xb3,0x72,0x73,0x40]
+andn t0, t1, t2
+
+# CHECK-ASM-AND-OBJ: orn t0, t1, t2
+# CHECK-ASM: encoding: [0xb3,0x62,0x73,0x40]
+orn t0, t1, t2
+
+# CHECK-ASM-AND-OBJ: xnor t0, t1, t2
+# CHECK-ASM: encoding: [0xb3,0x42,0x73,0x40]
+xnor t0, t1, t2
+
+# CHECK-ASM-AND-OBJ: pack t0, t1, t2
+# CHECK-ASM: encoding: [0xb3,0x42,0x73,0x08]
+pack t0, t1, t2
+
+# CHECK-ASM-AND-OBJ: packu t0, t1, t2
+# CHECK-ASM: encoding: [0xb3,0x42,0x73,0x48]
+packu t0, t1, t2
+
+# CHECK-ASM-AND-OBJ: packh t0, t1, t2
+# CHECK-ASM: encoding: [0xb3,0x72,0x73,0x08]
+packh t0, t1, t2
+
+# CHECK-ASM-AND-OBJ: rev8 t0, t1
+# CHECK-ASM: encoding: [0x93,0x52,0x83,0x6b]
+rev8 t0, t1
+
+# CHECK-ASM-AND-OBJ: grevi t0, t1, 0
+# CHECK-ASM: encoding: [0x93,0x52,0x03,0x68]
+grevi t0, t1, 0
+
+# CHECK-ASM-AND-OBJ: shfli t0, t1, 0
+# CHECK-ASM: encoding: [0x93,0x12,0x03,0x08]
+shfli t0, t1, 0
+
+# CHECK-ASM-AND-OBJ: unshfli t0, t1, 0
+# CHECK-ASM: encoding: [0x93,0x52,0x03,0x08]
+unshfli t0, t1, 0

llvm/test/MC/RISCV/rv64zkg-valid.s

+# With K extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-k %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-k - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+
+# With Zkn extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-zkn %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zkn %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zkn - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+
+# With Zks extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-zks %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zks %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zks - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+
+# With Zkg extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-zkg %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zkg %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zkg - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+
+# CHECK-INST: clmul t0, t1, t2
+# CHECK-ENCODING: [0xb3,0x12,0x73,0x0a]
+clmul t0, t1, t2
+
+# CHECK-INST: clmulh t0, t1, t2
+# CHECK-ENCODING: [0xb3,0x32,0x73,0x0a]
+clmulh t0, t1, t2

llvm/test/MC/RISCV/rv64zknd-only-valid.s

+# With K extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-k %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-k - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# With Zkn extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-zkn %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zkn %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zkn - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zkn %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# With Zknd extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-zknd %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zknd %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zknd - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zknd %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# CHECK-INST: aes64ds a0, a1, a2
+# CHECK-ENCODING: [0x33,0x85,0xc5,0x3a]
+# CHECK-ERROR: instruction requires the following: 'Zknd' (NIST AES Decryption Instructions)
+# CHECK-UNKNOWN: 33 85 c5 3a <unknown>
+aes64ds a0, a1, a2
+
+# CHECK-INST: aes64dsm a0, a1, a2
+# CHECK-ENCODING: [0x33,0x85,0xc5,0x3e]
+# CHECK-ERROR: instruction requires the following: 'Zknd' (NIST AES Decryption Instructions)
+# CHECK-UNKNOWN: 33 85 c5 3e <unknown>
+aes64dsm a0, a1, a2
+
+# CHECK-INST: aes64im a0, a1
+# CHECK-ENCODING: [0x13,0x95,0x05,0x30]
+# CHECK-ERROR: instruction requires the following: 'Zknd' (NIST AES Decryption Instructions)
+# CHECK-UNKNOWN: 13 95 05 30 <unknown>
+aes64im a0, a1

llvm/test/MC/RISCV/rv64zkne-only-invalid.s

+# With K extension:
+# RUN: not llvm-mc -triple=riscv64 -mattr=+experimental-k < %s 2>&1 \
+# RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
+
+# With Zkn extension:
+# RUN: not llvm-mc -triple=riscv64 -mattr=+experimental-zkn < %s 2>&1 \
+# RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
+
+# With Zkne extension:
+# RUN: not llvm-mc -triple=riscv64 -mattr=+experimental-zkne < %s 2>&1 \
+# RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
+
+aes64ks1i a0, a1, 11
+# CHECK-ERROR: immediate must be an integer in the range [0, 10]
+
+aes64ks1i a0, a1, -1
+# CHECK-ERROR: immediate must be an integer in the range [0, 10]

llvm/test/MC/RISCV/rv64zkne-only-valid.s

+# With K extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-k %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-k - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# With Zkn extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-zkn %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zkn %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zkn - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zkn %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# With Zkne extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-zkne %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zkne %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zkne - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zkne %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# CHECK-INST: aes64esm a0, a1, a2
+# CHECK-ENCODING: [0x33,0x85,0xc5,0x36]
+# CHECK-ERROR: instruction requires the following: 'Zkne' (NIST AES Encryption Instructions)
+# CHECK-UNKNOWN: 33 85 c5 36 <unknown>
+aes64esm a0, a1, a2
+
+# CHECK-INST: aes64es a0, a1, a2
+# CHECK-ENCODING: [0x33,0x85,0xc5,0x32]
+# CHECK-ERROR: instruction requires the following: 'Zkne' (NIST AES Encryption Instructions)
+# CHECK-UNKNOWN: 33 85 c5 32 <unknown>
+aes64es a0, a1, a2
+
+# CHECK-INST: aes64ks1i a0, a1, 5
+# CHECK-ENCODING: [0x13,0x95,0x55,0x31]
+# CHECK-ERROR: instruction requires the following: 'Zkne' (NIST AES Encryption Instructions)
+# CHECK-UNKNOWN: 13 95 55 31 <unknown>
+aes64ks1i a0, a1, 5
+
+# CHECK-INST: aes64ks2 a0, a1, a2
+# CHECK-ENCODING: [0x33,0x85,0xc5,0x7e]
+# CHECK-ERROR: instruction requires the following: 'Zkne' (NIST AES Encryption Instructions)
+# CHECK-UNKNOWN: 33 85 c5 7e <unknown>
+aes64ks2 a0, a1, a2

llvm/test/MC/RISCV/rv64zknh-only-valid.s

+# With K extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-k %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-k - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# With Zkn extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-zkn %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zkn %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zkn - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zkn %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# With Zknh extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-zknh %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zknh %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zknh - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zknh %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# CHECK-INST: sha512sig0 a0, a1
+# CHECK-ENCODING: [0x13,0x95,0x65,0x10]
+# CHECK-ERROR: instruction requires the following: 'Zknh' (NIST SHA2 Hash function instructions)
+# CHECK-UNKNOWN: 13 95 65 10 <unknown>
+sha512sig0 a0, a1
+
+# CHECK-INST: sha512sig1 a0, a1
+# CHECK-ENCODING: [0x13,0x95,0x75,0x10]
+# CHECK-ERROR: instruction requires the following: 'Zknh' (NIST SHA2 Hash function instructions)
+# CHECK-UNKNOWN: 13 95 75 10 <unknown>
+sha512sig1 a0, a1
+
+# CHECK-INST: sha512sum0 a0, a1
+# CHECK-ENCODING: [0x13,0x95,0x45,0x10]
+# CHECK-ERROR: instruction requires the following: 'Zknh' (NIST SHA2 Hash function instructions)
+# CHECK-UNKNOWN: 13 95 45 10 <unknown>
+sha512sum0 a0, a1
+
+# CHECK-INST: sha512sum1 a0, a1
+# CHECK-ENCODING: [0x13,0x95,0x55,0x10]
+# CHECK-ERROR: instruction requires the following: 'Zknh' (NIST SHA2 Hash function instructions)
+# CHECK-UNKNOWN: 13 95 55 10 <unknown>
+sha512sum1 a0, a1

llvm/test/MC/RISCV/rv64zknh-valid.s

+# With K extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-k %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-k - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# With Zkn extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-zkn %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zkn %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zkn - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zkn %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# With Zknh extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-zknh %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zknh %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zknh - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zknh %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# CHECK-INST: sha256sig0 a0, a1
+# CHECK-ENCODING: [0x13,0x95,0x25,0x10]
+# CHECK-ERROR: instruction requires the following: 'Zknh' (NIST SHA2 Hash function instructions)
+# CHECK-UNKNOWN: 13 95 25 10 <unknown>
+sha256sig0 a0, a1
+
+# CHECK-INST: sha256sig1 a0, a1
+# CHECK-ENCODING: [0x13,0x95,0x35,0x10]
+# CHECK-ERROR: instruction requires the following: 'Zknh' (NIST SHA2 Hash function instructions)
+# CHECK-UNKNOWN: 13 95 35 10 <unknown>
+sha256sig1 a0, a1
+
+# CHECK-INST: sha256sum0 a0, a1
+# CHECK-ENCODING: [0x13,0x95,0x05,0x10]
+# CHECK-ERROR: instruction requires the following: 'Zknh' (NIST SHA2 Hash function instructions)
+# CHECK-UNKNOWN: 13 95 05 10 <unknown>
+sha256sum0 a0, a1
+
+# CHECK-INST: sha256sum1 a0, a1
+# CHECK-ENCODING: [0x13,0x95,0x15,0x10]
+# CHECK-ERROR: instruction requires the following: 'Zknh' (NIST SHA2 Hash function instructions)
+# CHECK-UNKNOWN: 13 95 15 10 <unknown>
+sha256sum1 a0, a1

llvm/test/MC/RISCV/rv64zkr-valid.s

+# With K extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-k %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-k - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-k %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# With Zkr extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-zkr %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zkr %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zkr - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zkr %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# CHECK-INST: csrr a0, mnoise 
+# CHECK-ENCODING: [0x73,0x25,0x90,0x7a]
+# CHECK-ERROR: instruction requires the following: 'Zkr' (Entropy source for seeding random number generators)
+# CHECK-UNKNOWN: 73 25 90 7a
+getnoise a0
+
+# CHECK-INST: csrr a0, mentropy
+# CHECK-ENCODING: [0x73,0x25,0x50,0xf1]
+# CHECK-ERROR: instruction requires the following: 'Zkr' (Entropy source for seeding random number generators)
+# CHECK-UNKNOWN: 73 25 50 f1
+pollentropy a0

llvm/test/MC/RISCV/rv64zksed-invalid.s

+# With Zks extension:
+# RUN: not llvm-mc -triple=riscv64 -mattr=+experimental-zks < %s 2>&1 \
+# RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
+
+# With Zksed extension:
+# RUN: not llvm-mc -triple=riscv64 -mattr=+experimental-zksed < %s 2>&1 \
+# RUN:        | FileCheck %s --check-prefix=CHECK-ERROR
+
+sm4ed a0, a1, a2, 8
+# CHECK-ERROR: immediate must be an integer in the range [0, 3]
+
+sm4ks a0, a1, a2, 8
+# CHECK-ERROR: immediate must be an integer in the range [0, 3]

llvm/test/MC/RISCV/rv64zksed-valid.s

+# With Zks extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-zks %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zks %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zks - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zks %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# With Zksed extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-zksed %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zksed %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zksed - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zksed %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+
+# CHECK-INST: sm4ed a0, a1, a2, 3
+# CHECK-ENCODING: [0x33,0x85,0xc5,0xf0]
+# CHECK-ERROR: instruction requires the following: 'Zksed' (SM4 Instructions)
+# CHECK-UNKNOWN: 33 85 c5 f0 <unknown>
+sm4ed a0, a1, a2, 3
+
+# CHECK-INST: sm4ks a0, a1, a2, 3
+# CHECK-ENCODING: [0x33,0x85,0xc5,0xf4]
+# CHECK-ERROR: instruction requires the following: 'Zksed' (SM4 Instructions)
+# CHECK-UNKNOWN: 33 85 c5 f4 <unknown>
+sm4ks a0, a1, a2, 3

llvm/test/MC/RISCV/rv64zksh-valid.s

+# With Zks extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-zks %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zks %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zks - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zks %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# With Zksh extension:
+# RUN: llvm-mc -triple=riscv64 -show-encoding --mattr=+experimental-zksh %s \
+# RUN:      | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST
+# RUN: not llvm-mc -triple=riscv64 -show-encoding %s 2>&1 \
+# RUN:      | FileCheck %s --check-prefix=CHECK-ERROR
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zksh %s \
+# RUN:      | llvm-objdump -d --mattr=+experimental-zksh - \
+# RUN:      | FileCheck %s --check-prefix=CHECK-INST
+# RUN: llvm-mc -triple=riscv64 -filetype=obj --mattr=+experimental-zksh %s \
+# RUN:      | llvm-objdump -d - | FileCheck %s --check-prefix=CHECK-UNKNOWN
+
+# CHECK-INST: sm3p0 a0, a1
+# CHECK-ENCODING: [0x13,0x95,0x85,0x10]
+# CHECK-ERROR: instruction requires the following: 'Zksh' (SM3 Hash function instructions)
+# CHECK-UNKNOWN: 13 95 85 10 <unknown>
+sm3p0 a0, a1
+
+# CHECK-INST: sm3p1 a0, a1
+# CHECK-ENCODING: [0x13,0x95,0x95,0x10]
+# CHECK-ERROR: instruction requires the following: 'Zksh' (SM3 Hash function instructions)
+# CHECK-UNKNOWN: 13 95 95 10 <unknown>
+sm3p1 a0, a1