[Flang][RISCV] Adding intrinsics of RV64 Zb* extentions

[sunshaoce]

Summary

Similiar to D143951. These intrinsics have been added in clang/Basic/BuiltinsRISCV.def.

[sunshaoce]

Rebased

[pscoro]

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

690

FYI there is a patch open: https://reviews.llvm.org/D151812 that replaces all of these static mlir::FunctionType generators with a single generic function..

If this patch lands first I will rebase the other patch to replace genIntIntFuncType. Are you ok with rebasing this patch if the other patch lands first?

[sunshaoce]

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

690

Thank you for the reminder! I will rebase this patch according to the situation.

[pscoro]

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

1146

As another FYI, we plan on moving all our PowerPC-specific code out of IntrinsicCall.cpp/.h after the function type generator patch lands (https://reviews.llvm.org/D151812). There is no review yet for this planned patch since we are waiting for the function type generator patch to land first as a dependency. I expect that RISCV may be interested in a similar approach (in a future patch) to help with keeping standard intrinsics separate from intrinsic extensions.

The basic structure of this future patch is new PPCIntrinsicCall.cpp/.h files that define a struct PPCIntrinsicLibrary : public IntrinsicLibrary that contains the generator functions for PPC-specific intrinsics and we moved the definitions of ppcHandlers, ppcMathOperations to PPCIntrinsicCall.h

I will try to remember to link the patch here when its created if this patch is still open

[sunshaoce]

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

1146

Based on your information, I will wait for the PPC-related intrinsics land before modifying the RISCV-related intrinsics. Thank you very much for your contribution in this regard, especially in relation to vector-related aspects, which has been of great help to RISC-V.

[sunshaoce]

Rebased

[sunshaoce]

As the PPC-related D151812 and D152460 have already landed, I think it's time to start reviewing this patch. Thanks!

[tschuett]

Did you check somewhere that the zb* extension is available?

[sunshaoce]

Added a check for whether Zb* extensions are enabled

[sunshaoce]

Fix the occasional error: No explicit type declared for '__builtin_c_ptr'

[sunshaoce]

Fix CI failure

[craig.topper]

Does anything prevent the use of i64 intrinsics on RV32? The RISC-V backend does not have support for that.

flang/lib/Optimizer/Builder/RISCVIntrinsicCall.cpp

23 ↗

(On Diff #534307)

RISCV -> RISC-V

[craig.topper]

flang/test/Lower/RISCV/riscv-zbkb-intrinsics.f90

20 ↗

(On Diff #534307)

Zip and unzip are RV32-only instructions. This is an RV64 test.

[sunshaoce]

Because flang does not support RISC-V 32 currently, I have temporarily removed the zip and unzip instructions.

[tschuett]

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

1352

Does this check include 32 and 64 modes?

[sunshaoce]

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

1352

Yes, this is reserved for RV32.

[sunshaoce]

Rebase

[sunshaoce]

Try to fix build fails

flang/include/flang/Semantics/semantics.h

public:
   const Scope *GetBuiltinsScope() const { return builtinsScope_; }
 
   void UsePPCFortranBuiltinTypesModule();
   const Scope &GetCUDABuiltinsScope();
   void UsePPCFortranBuiltinsModule();
   Scope *GetPPCBuiltinTypesScope() { return ppcBuiltinTypesScope_; }
   const Scope *GetPPCBuiltinsScope() const { return ppcBuiltinsScope_; }
 
+  void UseRISCVFortranBuiltinsModule();
+  const Scope *GetRISCVBuiltinsScope() const { return riscvBuiltinsScope_; }
+
   // Saves a module file's parse tree so that it remains available
   // during semantics.
   parser::Program &SaveParseTree(parser::Program &&);
 
   // Ensures a common block definition does not conflict with previous
   // appearances in the program and consolidate information about
   // common blocks at the program level for later checks and lowering.
   // This can obviously not check any conflicts between different compilation
private:
   std::map<SymbolRef, const IndexVarInfo, SymbolAddressCompare>
       activeIndexVars_;
   UnorderedSymbolSet errorSymbols_;
   std::set<std::string> tempNames_;
   const Scope *builtinsScope_{nullptr}; // module __Fortran_builtins
   Scope *ppcBuiltinTypesScope_{nullptr}; // module __Fortran_PPC_types
   std::optional<const Scope *> cudaBuiltinsScope_; // module __CUDA_builtins
   const Scope *ppcBuiltinsScope_{nullptr}; // module __Fortran_PPC_intrinsics
+  // module __Fortran_RISCV_intrinsics
+  const Scope *riscvBuiltinsScope_{nullptr};
   std::list<parser::Program> modFileParseTrees_;
   std::unique_ptr<CommonBlockMap> commonBlockMap_;
   bool anyDefinedIntrinsicOperator_{false};
 };
 
 class Semantics {
 public:
   explicit Semantics(SemanticsContext &context, parser::Program &program,

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

 template <int Bits>
 static mlir::FunctionType genF32IntF32FuncType(mlir::MLIRContext *context) {
   auto ftype = mlir::FloatType::getF32(context);
   auto itype = mlir::IntegerType::get(context, Bits);
   return mlir::FunctionType::get(context, {itype, ftype}, {ftype});
 }
 
 template <int Bits>
+static mlir::FunctionType genIntIntFuncType(mlir::MLIRContext *context) {
+  auto itype = mlir::IntegerType::get(context, Bits);
+  return mlir::FunctionType::get(context, {itype}, {itype});
+}
+
+template <int Bits>
 static mlir::FunctionType genIntIntIntFuncType(mlir::MLIRContext *context) {
   auto itype = mlir::IntegerType::get(context, Bits);
   return mlir::FunctionType::get(context, {itype, itype}, {itype});
 }
 
 template <int Kind>
 static mlir::FunctionType
 genComplexComplexFuncType(mlir::MLIRContext *context) {
static constexpr MathOperation ppcMathOperations[] = {
     {"__ppc_fnmsub", "llvm.ppc.fnmsub.f64", genF64F64F64F64FuncType,
      genLibCall},
     {"__ppc_fre", "llvm.ppc.fre", genF64F64FuncType, genLibCall},
     {"__ppc_fres", "llvm.ppc.fres", genF32F32FuncType, genLibCall},
     {"__ppc_frsqrte", "llvm.ppc.frsqrte", genF64F64FuncType, genLibCall},
     {"__ppc_frsqrtes", "llvm.ppc.frsqrtes", genF32F32FuncType, genLibCall},
 };
 
+static constexpr MathOperation riscvMathOperations[] = {
+    {"__riscv_brev8", "llvm.riscv.brev8.i32", genIntIntFuncType<32>,
+     genLibCall},
+    {"__riscv_brev8", "llvm.riscv.brev8.i64", genIntIntFuncType<64>,
+     genLibCall},
+    {"__riscv_clmul", "llvm.riscv.clmul.i32", genIntIntIntFuncType<32>,
+     genLibCall},
+    {"__riscv_clmul", "llvm.riscv.clmul.i64", genIntIntIntFuncType<64>,
+     genLibCall},
+    {"__riscv_clmulh", "llvm.riscv.clmulh.i32", genIntIntIntFuncType<32>,
+     genLibCall},
+    {"__riscv_clmulh", "llvm.riscv.clmulh.i64", genIntIntIntFuncType<64>,
+     genLibCall},
+    {"__riscv_clmulr", "llvm.riscv.clmulr.i32", genIntIntIntFuncType<32>,
+     genLibCall},
+    {"__riscv_clmulr", "llvm.riscv.clmulr.i64", genIntIntIntFuncType<64>,
+     genLibCall},
+    {"__riscv_orc_b", "llvm.riscv.orc.b.i32", genIntIntFuncType<32>,
+     genLibCall},
+    {"__riscv_orc_b", "llvm.riscv.orc.b.i64", genIntIntFuncType<64>,
+     genLibCall},
+    {"__riscv_unzip", "llvm.riscv.unzip.i32", genIntIntFuncType<32>,
+     genLibCall},
+    {"__riscv_xperm4", "llvm.riscv.xperm4.i32", genIntIntIntFuncType<32>,
+     genLibCall},
+    {"__riscv_xperm4", "llvm.riscv.xperm4.i64", genIntIntIntFuncType<64>,
+     genLibCall},
+    {"__riscv_zip", "llvm.riscv.zip.i32", genIntIntFuncType<32>, genLibCall},
+};
+
 // This helper class computes a "distance" between two function types.
 // The distance measures how many narrowing conversions of actual arguments
 // and result of "from" must be made in order to use "to" instead of "from".
 // For instance, the distance between ACOS(REAL(10)) and ACOS(REAL(8)) is
 // greater than the one between ACOS(REAL(10)) and ACOS(REAL(16)). This means
 // if no implementation of ACOS(REAL(10)) is available, it is better to use
 // ACOS(REAL(16)) with casts rather than ACOS(REAL(8)).
 // Note that this is not a symmetric distance and the order of "from" and "to"

 using RtMap = Fortran::common::StaticMultimapView<MathOperation>;
 static constexpr RtMap mathOps(mathOperations);
 static_assert(mathOps.Verify() && "map must be sorted");
 
 // PPC
 static constexpr RtMap ppcMathOps(ppcMathOperations);
 static_assert(ppcMathOps.Verify() && "map must be sorted");
 
+// RISCV
+static constexpr RtMap riscvMathOps(riscvMathOperations);
+static_assert(riscvMathOps.Verify() && "map must be sorted");
+
 /// Look for a MathOperation entry specifying how to lower a mathematical
 /// operation defined by \p name with its result' and operands' types
 /// specified in the form of a FunctionType \p funcType.
 /// If exact match for the given types is found, then the function
 /// returns a pointer to the corresponding MathOperation.
 /// Otherwise, the function returns nullptr.
 /// If there is a MathOperation that can be used with additional
 /// type casts for the operands or/and result (non-exact match),
 /// then it is returned via \p bestNearMatch argument, and
 /// \p bestMatchDistance specifies the FunctionDistance between
 /// the requested operation and the non-exact match.
 static const MathOperation *
 searchMathOperation(fir::FirOpBuilder &builder, llvm::StringRef name,
                     mlir::FunctionType funcType,
                     const MathOperation **bestNearMatch,
                     FunctionDistance &bestMatchDistance) {
   auto range = mathOps.equal_range(name);
   auto mod = builder.getModule();
 
   // Search ppcMathOps only if targetting PowerPC arch
   if (fir::getTargetTriple(mod).isPPC() && range.first == range.second) {
     range = ppcMathOps.equal_range(name);
   }
+  // Search riscvMathOps only if targetting RISCV arch
+  if (fir::getTargetTriple(mod).isRISCV() && range.first == range.second) {
+    range = riscvMathOps.equal_range(name);
+  }
   for (auto iter = range.first; iter != range.second && iter; ++iter) {
     const auto &impl = *iter;
     auto implType = impl.typeGenerator(builder.getContext());
     if (funcType == implType)
       return &impl; // exact match
 
     FunctionDistance distance(funcType, implType);
     if (distance.isSmallerThan(bestMatchDistance)) {

 }
 
 //===----------------------------------------------------------------------===//
 // IntrinsicLibrary
 //===----------------------------------------------------------------------===//
 
 static bool isIntrinsicModuleProcedure(llvm::StringRef name) {
   return name.startswith("c_") || name.startswith("compiler_") ||
-         name.startswith("ieee_") || name.startswith("__ppc_");
+         name.startswith("ieee_") || name.startswith("__ppc_") ||
+         name.startswith("__riscv_");
 }
 
 /// Return the generic name of an intrinsic module procedure specific name.
 /// Remove any "__builtin_" prefix, and any specific suffix of the form
 /// {_[ail]?[0-9]+}*, such as _1 or _a4.
 llvm::StringRef genericName(llvm::StringRef specificName) {
   const std::string builtin = "__builtin_";
   llvm::StringRef name = specificName.startswith(builtin)
                              ? specificName.drop_front(builtin.size())
                              : specificName;
+  if (name.startswith("__riscv_")) {
+    if (name.ends_with("_i4") || name.ends_with("_i8"))
+      return name.drop_back(3);
+    return name;
+  }
   size_t size = name.size();
   if (isIntrinsicModuleProcedure(name))
     while (isdigit(name[size - 1]))
       while (name[--size] != '_')
         ;
   return name.drop_back(name.size() - size);
 }
 

flang/lib/Semantics/resolve-names.cpp

if (IsIntrinsic(name.source, flag)) {
       symbol =
           &MakeSymbol(InclusiveScope(), name.source, Attrs{Attr::INTRINSIC});
     } else if (const auto ppcBuiltinScope =
                    currScope().context().GetPPCBuiltinsScope()) {
       // Check if it is a builtin from the predefined module
       symbol = FindSymbol(*ppcBuiltinScope, name);
       if (!symbol)
         symbol = &MakeSymbol(context().globalScope(), name.source, Attrs{});
+    } else if (const auto riscvBuiltinScope =
+                   currScope().context().GetRISCVBuiltinsScope()) {
+      // Check if it is a builtin from the predefined module
+      symbol = FindSymbol(*riscvBuiltinScope, name);
+      if (!symbol)
+        symbol = &MakeSymbol(context().globalScope(), name.source, Attrs{});
     } else {
       symbol = &MakeSymbol(context().globalScope(), name.source, Attrs{});
     }
     Resolve(name, *symbol);
     ConvertToProcEntity(*symbol);
     if (!symbol->attrs().test(Attr::INTRINSIC)) {
       if (CheckImplicitNoneExternal(name.source, *symbol)) {
         MakeExternal(*symbol);

flang/lib/Semantics/semantics.cpp

 }
 
 void SemanticsContext::UsePPCFortranBuiltinsModule() {
   if (ppcBuiltinsScope_ == nullptr) {
     ppcBuiltinsScope_ = GetBuiltinModule("__fortran_ppc_intrinsics");
   }
 }
 
+void SemanticsContext::UseRISCVFortranBuiltinsModule() {
+  if (riscvBuiltinsScope_ == nullptr) {
+    riscvBuiltinsScope_ = GetBuiltinModule("__fortran_riscv_intrinsics");
+  }
+}
+
 parser::Program &SemanticsContext::SaveParseTree(parser::Program &&tree) {
   return modFileParseTrees_.emplace_back(std::move(tree));
 }
 
 bool Semantics::Perform() {
   // Implicitly USE the __Fortran_builtins module so that special types
   // (e.g., __builtin_team_type) are available to semantics, esp. for
   // intrinsic checking.
   if (!program_.v.empty()) {
     const auto *frontModule{std::get_if<common::Indirection<parser::Module>>(
         &program_.v.front().u)};
     if (frontModule &&
         (std::get<parser::Statement<parser::ModuleStmt>>(frontModule->value().t)
                     .statement.v.source == "__fortran_builtins" ||
             std::get<parser::Statement<parser::ModuleStmt>>(
                 frontModule->value().t)
                     .statement.v.source == "__fortran_ppc_intrinsics" ||
             std::get<parser::Statement<parser::ModuleStmt>>(
                 frontModule->value().t)
-                    .statement.v.source == "__fortran_ppc_types")) {
+                    .statement.v.source == "__fortran_ppc_types" ||
+            std::get<parser::Statement<parser::ModuleStmt>>(
+                frontModule->value().t)
+                    .statement.v.source == "__fortran_riscv_intrinsics")) {
       // Don't try to read the builtins module when we're actually building it.
     } else {
       context_.UseFortranBuiltinsModule();
       llvm::Triple targetTriple{llvm::Triple(
           llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple()))};
       // Only use __Fortran_PPC_intrinsics module when targetting PowerPC arch
       if (targetTriple.isPPC()) {
         context_.UsePPCFortranBuiltinTypesModule();
         context_.UsePPCFortranBuiltinsModule();
       }
+      if (targetTriple.isRISCV()) {
+        context_.UseRISCVFortranBuiltinsModule();
+      }
     }
   }
   return ValidateLabels(context_, program_) &&
       parser::CanonicalizeDo(program_) && // force line break
       CanonicalizeAcc(context_.messages(), program_) &&
       CanonicalizeOmp(context_.messages(), program_) &&
       CanonicalizeCUDA(program_) &&
       PerformStatementSemantics(context_, program_) &&

flang/module/__fortran_riscv_intrinsics.f90

+!===-- module/__fortran_riscv_intrinsics.f90 -------------------------------===!
+!
+! 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
+!
+!===------------------------------------------------------------------------===!
+
+module __Fortran_RISCV_intrinsics
+
+  private
+
+  abstract interface
+    elemental integer(4) function func_i4i4(x)
+      integer, intent(in) :: x
+    end function func_i4i4
+    elemental integer(8) function func_i8i8(x)
+      integer(8), intent(in) :: x
+    end function func_i8i8
+    elemental integer(4) function func_i4i4i4(x, y)
+      integer, intent(in) :: x, y
+    end function func_i4i4i4
+    elemental integer(8) function func_i8i8i8(x, y)
+      integer(8), intent(in) :: x, y
+    end function func_i8i8i8
+  end interface
+
+  ! brev8
+  procedure(func_i4i4) :: __riscv_brev8_i4
+  procedure(func_i8i8) :: __riscv_brev8_i8
+  interface brev8
+    procedure :: __riscv_brev8_i4
+    procedure :: __riscv_brev8_i8
+  end interface brev8
+  public :: brev8
+
+  ! clmul
+  procedure(func_i4i4i4) :: __riscv_clmul_i4
+  procedure(func_i8i8i8) :: __riscv_clmul_i8
+  interface clmul
+    procedure :: __riscv_clmul_i4
+    procedure :: __riscv_clmul_i8
+  end interface clmul
+  public :: clmul
+
+  ! clmulh
+  procedure(func_i4i4i4) :: __riscv_clmulh_i4
+  procedure(func_i8i8i8) :: __riscv_clmulh_i8
+  interface clmulh
+    procedure :: __riscv_clmulh_i4
+    procedure :: __riscv_clmulh_i8
+  end interface clmulh
+  public :: clmulh
+
+  ! clmulr
+  procedure(func_i4i4i4) :: __riscv_clmulr_i4
+  procedure(func_i8i8i8) :: __riscv_clmulr_i8
+  interface clmulr
+    procedure :: __riscv_clmulr_i4
+    procedure :: __riscv_clmulr_i8
+  end interface clmulr
+  public :: clmulr
+
+  ! orc.b
+  procedure(func_i4i4) :: __riscv_orc_b_i4
+  procedure(func_i8i8) :: __riscv_orc_b_i8
+  interface orc_b
+    procedure :: __riscv_orc_b_i4
+    procedure :: __riscv_orc_b_i8
+  end interface orc_b
+  public :: orc_b
+
+  ! unzip
+  procedure(func_i4i4) :: __riscv_unzip_i4
+  interface unzip
+    procedure :: __riscv_unzip_i4
+  end interface unzip
+  public :: unzip
+
+  ! xperm4
+  procedure(func_i4i4i4) :: __riscv_xperm4_i4
+  procedure(func_i8i8i8) :: __riscv_xperm4_i8
+  interface xperm4
+    procedure :: __riscv_xperm4_i4
+    procedure :: __riscv_xperm4_i8
+  end interface xperm4
+  public :: xperm4
+
+  ! zip
+  procedure(func_i4i4) :: __riscv_zip_i4
+  interface zip
+    procedure :: __riscv_zip_i4
+  end interface zip
+  public :: zip
+
+end module __Fortran_RISCV_intrinsics

flang/test/Lower/riscv-intrinsics.f90

+! RUN: bbc -emit-fir %s -outline-intrinsics -o - | FileCheck --check-prefix="CHECK-FIR" %s
+! RUN: %flang_fc1 -emit-llvm %s -o - | FileCheck --check-prefix="CHECK-LLVMIR" %s
+! REQUIRES: target=riscv{{.*}}
+
+! CHECK-LABEL: brev8_i32_test
+! CHECK-FIR: fir.call @fir.__riscv_brev8.i32.i32
+! CHECK-LLVMIR: call i32 @llvm.riscv.brev8.i32(i32 %{{[0-9]}})
+subroutine brev8_i32_test(x)
+  integer :: x, r
+  r = brev8(x)
+end
+
+! CHECK-LABEL: brev8_i64_test
+! CHECK-FIR: fir.call @fir.__riscv_brev8.i64.i64
+! CHECK-LLVMIR: call i64 @llvm.riscv.brev8.i64(i64 %{{[0-9]}})
+subroutine brev8_i64_test(x)
+  integer(8) :: x, r
+  r = brev8(x)
+end
+
+! CHECK-LABEL: clmul_i32_test
+! CHECK-FIR: fir.call @fir.__riscv_clmul.i32.i32.i32
+! CHECK-LLVMIR: call i32 @llvm.riscv.clmul.i32(i32 %{{[0-9]}}, i32 %{{[0-9]}})
+subroutine clmul_i32_test(x, y)
+  integer :: x, y, r
+  r = clmul(x, y)
+end
+
+! CHECK-LABEL: clmul_i64_test
+! CHECK-FIR: fir.call @fir.__riscv_clmul.i64.i64.i64
+! CHECK-LLVMIR: call i64 @llvm.riscv.clmul.i64(i64 %{{[0-9]}}, i64 %{{[0-9]}})
+subroutine clmul_i64_test(x, y)
+  integer(8) :: x, y, r
+  r = clmul(x, y)
+end
+
+! CHECK-LABEL: clmulh_i32_test
+! CHECK-FIR: fir.call @fir.__riscv_clmulh.i32.i32
+! CHECK-LLVMIR: call i32 @llvm.riscv.clmulh.i32(i32 %{{[0-9]}}, i32 %{{[0-9]}})
+subroutine clmulh_i32_test(x, y)
+  integer :: x, y, r
+  r = clmulh(x, y)
+end
+
+! CHECK-LABEL: clmulh_i64_test
+! CHECK-FIR: fir.call @fir.__riscv_clmulh.i64.i64
+! CHECK-LLVMIR: call i64 @llvm.riscv.clmulh.i64(i64 %{{[0-9]}}, i64 %{{[0-9]}})
+subroutine clmulh_i64_test(x, y)
+  integer(8) :: x, y, r
+  r = clmulh(x, y)
+end
+
+! CHECK-LABEL: clmulr_i32_test
+! CHECK-FIR: fir.call @fir.__riscv_clmulr.i32.i32.i32
+! CHECK-LLVMIR: call i32 @llvm.riscv.clmulr.i32(i32 %{{[0-9]}}, i32 %{{[0-9]}})
+subroutine clmulr_i32_test(x, y)
+  integer :: x, y, r
+  r = clmulr(x, y)
+end
+
+! CHECK-LABEL: clmulr_i64_test
+! CHECK-FIR: fir.call @fir.__riscv_clmulr.i64.i64.i64
+! CHECK-LLVMIR: call i64 @llvm.riscv.clmulr.i64(i64 %{{[0-9]}}, i64 %{{[0-9]}})
+subroutine clmulr_i64_test(x, y)
+  integer(8) :: x, y, r
+  r = clmulr(x, y)
+end
+
+! CHECK-LABEL: orc_b_i32_test
+! CHECK-FIR: fir.call @fir.__riscv_orc_b.i32.i32
+! CHECK-LLVMIR: call i32 @llvm.riscv.orc.b.i32(i32 %{{[0-9]}})
+subroutine orc_b_i32_test(x)
+  integer :: x, r
+  r = orc_b(x)
+end
+
+! CHECK-LABEL: orc_b_i64_test
+! CHECK-FIR: fir.call @fir.__riscv_orc_b.i64.i64
+! CHECK-LLVMIR: call i64 @llvm.riscv.orc.b.i64(i64 %{{[0-9]}})
+subroutine orc_b_i64_test(x)
+  integer(8) :: x, r
+  r = orc_b(x)
+end
+
+! CHECK-LABEL: unzip_i32_test
+! CHECK-FIR: fir.call @fir.__riscv_unzip.i32.i32
+! CHECK-LLVMIR: call i32 @llvm.riscv.unzip.i32(i32 %{{[0-9]}})
+subroutine unzip_i32_test(x)
+  integer :: x, r
+  r = unzip(x)
+end
+
+! CHECK-LABEL: xperm4_i32_test
+! CHECK-FIR: fir.call @fir.__riscv_xperm4.i32.i32.i32
+! CHECK-LLVMIR: call i32 @llvm.riscv.xperm4.i32(i32 %{{[0-9]}}, i32 %{{[0-9]}})
+subroutine xperm4_i32_test(x, y)
+  integer :: x, y, r
+  r = xperm4(x, y)
+end
+
+! CHECK-LABEL: xperm4_i64_test
+! CHECK-FIR: fir.call @fir.__riscv_xperm4.i64.i64.i64
+! CHECK-LLVMIR: call i64 @llvm.riscv.xperm4.i64(i64 %{{[0-9]}}, i64 %{{[0-9]}})
+subroutine xperm4_i64_test(x, y)
+  integer(8) :: x, y, r
+  r = xperm4(x, y)
+end
+
+! CHECK-LABEL: zip_i32_test
+! CHECK-FIR: fir.call @fir.__riscv_zip.i32.i32
+! CHECK-LLVMIR: call i32 @llvm.riscv.zip.i32(i32 %{{[0-9]}})
+subroutine zip_i32_test(x)
+  integer :: x, r
+  r = zip(x)
+end

flang/tools/f18/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   FrontendOpenACC
   FrontendOpenMP
   Support
   )
 
 set(MODULES
   "__fortran_builtins"
   "__fortran_ieee_exceptions"
   "__fortran_type_info"
   "__fortran_ppc_types"
   "__fortran_ppc_intrinsics"
+  "__fortran_riscv_intrinsics"
   "__cuda_builtins"
   "ieee_arithmetic"
   "ieee_exceptions"
   "ieee_features"
   "iso_c_binding"
   "iso_fortran_env"
   "omp_lib"
   "__fortran_builtins"
   "__fortran_type_info"
 )
 
 # Create module files directly from the top-level module source directory.
 # If CMAKE_CROSSCOMPILING, then the newly built flang-new executable was
 # cross compiled, and thus can't be executed on the build system and thus
 # can't be used for generating module files.
 if (NOT CMAKE_CROSSCOMPILING)
   foreach(filename ${MODULES})
     set(base ${FLANG_INTRINSIC_MODULES_DIR}/${filename})
     if(${filename} STREQUAL "__fortran_builtins")
       set(depends "")
     elseif(${filename} STREQUAL "__fortran_ppc_types")
       set(depends "")
     elseif(${filename} STREQUAL "__fortran_ppc_intrinsics")
       set(depends ${FLANG_INTRINSIC_MODULES_DIR}/__fortran_ppc_types.mod)
+    elseif(${filename} STREQUAL "__fortran_riscv_intrinsics")
+      set(depends "")
     else()
       set(depends ${FLANG_INTRINSIC_MODULES_DIR}/__fortran_builtins.mod)
       if(NOT ${filename} STREQUAL "__fortran_type_info")
         set(depends ${FLANG_INTRINSIC_MODULES_DIR}/__fortran_type_info.mod)
       endif()
       if(${filename} STREQUAL "ieee_arithmetic" OR
          ${filename} STREQUAL "ieee_exceptions")
         set(depends ${FLANG_INTRINSIC_MODULES_DIR}/__fortran_ieee_exceptions.mod)