[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

581

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

581

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

[pscoro]

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

1038

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

1038

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

24

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

1206

Does this check include 32 and 64 modes?

[sunshaoce]

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

1206

Yes, this is reserved for RV32.

[sunshaoce]

Rebase

[sunshaoce]

Try to fix build fails

flang/include/flang/Evaluate/target.h

public:
   const std::string &compilerVersionString() const {
     return compilerVersionString_;
   };
   TargetCharacteristics &set_compilerVersionString(std::string x) {
     compilerVersionString_ = x;
     return *this;
   }
 
+  TargetCharacteristics &set_targetFeatures(std::string x) {
+    targetFeaturesString_ = x;
+    return *this;
+  }
+  bool hasFeature(std::string x);
+
   bool isPPC() const { return isPPC_; }
   void set_isPPC(bool isPPC = false);
 
+  bool isRISCV64() const { return isRISCV64_; }
+  void set_isRISCV64(bool isRISCV64 = false);
+
 private:
   static constexpr int maxKind{32};
   std::uint8_t byteSize_[common::TypeCategory_enumSize][maxKind]{};
   std::uint8_t align_[common::TypeCategory_enumSize][maxKind]{};
   bool isBigEndian_{false};
   bool isPPC_{false};
+  bool isRISCV64_{false};
   bool areSubnormalsFlushedToZero_{false};
   Rounding roundingMode_{defaultRounding};
   std::size_t procedurePointerByteSize_{8};
   std::size_t procedurePointerAlignment_{8};
   std::size_t descriptorAlignment_{8};
   std::size_t maxByteSize_{8 /*at least*/};
   std::size_t maxAlignment_{8 /*at least*/};
   std::string compilerOptionsString_;
   std::string compilerVersionString_;
+  std::string targetFeaturesString_;
 };
 
 } // namespace Fortran::evaluate
 #endif // FORTRAN_EVALUATE_TARGET_H_

flang/include/flang/Optimizer/Builder/RISCVIntrinsicCall.h

+//==-- Builder/RISCVIntrinsicCall.h - lowering of RISCV intrinsics -*-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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_LOWER_RISCVINTRINSICCALL_H
+#define FORTRAN_LOWER_RISCVINTRINSICCALL_H
+
+#include "flang/Common/static-multimap-view.h"
+#include "flang/Optimizer/Builder/IntrinsicCall.h"
+#include "mlir/Dialect/Math/IR/Math.h"
+
+namespace fir {
+
+struct RISCVIntrinsicLibrary : IntrinsicLibrary {
+
+  // Constructors.
+  explicit RISCVIntrinsicLibrary(fir::FirOpBuilder &builder, mlir::Location loc)
+      : IntrinsicLibrary(builder, loc) {}
+  RISCVIntrinsicLibrary() = delete;
+  RISCVIntrinsicLibrary(const RISCVIntrinsicLibrary &) = delete;
+};
+
+std::pair<const MathOperation *, const MathOperation *>
+checkRISCVMathOperationsRange(llvm::StringRef name);
+
+} // namespace fir
+
+#endif // FORTRAN_LOWER_RISCVINTRINSICCALL_H

flang/include/flang/Semantics/riscv-ext-with-intrinsics.def

+//===-- include/flang/Semantics/riscv-ext-with-intrinsics.def ---*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef RISCV_EXTENSION
+#error Define extensions with intrinsics in RISC-V
+#endif
+
+RISCV_EXTENSION(Zbb)
+RISCV_EXTENSION(Zbc)
+RISCV_EXTENSION(Zbkb)
+RISCV_EXTENSION(Zbkc)
+RISCV_EXTENSION(Zbkx)

flang/include/flang/Semantics/semantics.h

public:
   const Scope *GetBuiltinsScope() const { return builtinsScope_; }
 
   void UsePPCBuiltinTypesModule();
   const Scope &GetCUDABuiltinsScope();
   void UsePPCBuiltinsModule();
   Scope *GetPPCBuiltinTypesScope() { return ppcBuiltinTypesScope_; }
   const Scope *GetPPCBuiltinsScope() const { return ppcBuiltinsScope_; }
 
+#define RISCV_EXTENSION(F) \
+  void UseRISCV64##F##BuiltinsModule(); \
+  const Scope *GetRISCV64##F##BuiltinsScope() const { \
+    return riscv64##F##BuiltinsScope_; \
+  }
+#include "flang/Semantics/riscv-ext-with-intrinsics.def"
+#undef RISCV_EXTENSION
+
   // 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 __ppc_intrinsics
+
+  // module __RISCV64_##F##_intrinsics
+#define RISCV_EXTENSION(F) const Scope *riscv64##F##BuiltinsScope_{nullptr};
+#include "flang/Semantics/riscv-ext-with-intrinsics.def"
+#undef RISCV_EXTENSION
+
   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/Evaluate/target.cpp

 //===-- lib/Semantics/target.cpp ------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Evaluate/target.h"
 #include "flang/Common/template.h"
 #include "flang/Evaluate/common.h"
 #include "flang/Evaluate/type.h"
+#include "flang/Parser/characters.h"
 
 namespace Fortran::evaluate {
 
 Rounding TargetCharacteristics::defaultRounding;
 
 TargetCharacteristics::TargetCharacteristics() {
   auto enableCategoryKinds{[this](TypeCategory category) {
     for (int kind{0}; kind < maxKind; ++kind) {
bool TargetCharacteristics::IsTypeEnabled(
     common::TypeCategory category, std::int64_t kind) const {
   return GetAlignment(category, kind) > 0;
 }
 
 void TargetCharacteristics::set_isBigEndian(bool isBig) {
   isBigEndian_ = isBig;
 }
 
+bool TargetCharacteristics::hasFeature(std::string x) {
+  for (auto &c : x) {
+    c = parser::ToLowerCaseLetter(c);
+  }
+  std::string features = targetFeaturesString_ + ",";
+  if (features.find("+" + x + ",") != std::string::npos) {
+    return true;
+  }
+  return false;
+}
+
 void TargetCharacteristics::set_isPPC(bool isPowerPC) { isPPC_ = isPowerPC; }
+void TargetCharacteristics::set_isRISCV64(bool isRISCV64) {
+  isRISCV64_ = isRISCV64;
+}
 
 void TargetCharacteristics::set_areSubnormalsFlushedToZero(bool yes) {
   areSubnormalsFlushedToZero_ = yes;
 }
 
 void TargetCharacteristics::set_roundingMode(Rounding rounding) {
   roundingMode_ = rounding;
 }

flang/lib/Frontend/CompilerInvocation.cpp

 #include "flang/Semantics/semantics.h"
 #include "flang/Version.inc"
 #include "clang/Basic/AllDiagnostics.h"
 #include "clang/Basic/DiagnosticDriver.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/OptionUtils.h"
 #include "clang/Driver/Options.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Frontend/Debug/Options.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FileUtilities.h"
void CompilerInvocation::setSemanticsOpts(
 
   std::string version = Fortran::common::getFlangFullVersion();
   semanticsContext->targetCharacteristics()
       .set_compilerOptionsString(allCompilerInvocOpts)
       .set_compilerVersionString(version);
 
   if (targetTriple.isPPC())
     semanticsContext->targetCharacteristics().set_isPPC(true);
+  if (targetTriple.isRISCV64())
+    semanticsContext->targetCharacteristics().set_isRISCV64(true);
+
+  std::vector<std::string> targetFeatures{this->targetOpts.featuresAsWritten};
+  std::string featuresString =
+      llvm::join(targetFeatures.begin(), targetFeatures.end(), ",");
+  semanticsContext->targetCharacteristics().set_targetFeatures(featuresString);
 }
 
 /// Set \p loweringOptions controlling lowering behavior based
 /// on the \p optimizationLevel.
 void CompilerInvocation::setLoweringOptions() {
   const CodeGenOptions &codegenOpts = getCodeGenOpts();
 
   // Lower TRANSPOSE as a runtime call under -O0.

flang/lib/Optimizer/Builder/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 get_property(extension_libs GLOBAL PROPERTY MLIR_EXTENSION_LIBS)
 
 add_flang_library(FIRBuilder
   BoxValue.cpp
   Character.cpp
   Complex.cpp
   DoLoopHelper.cpp
   FIRBuilder.cpp
   HLFIRTools.cpp
   IntrinsicCall.cpp
   LowLevelIntrinsics.cpp
   MutableBox.cpp
   PPCIntrinsicCall.cpp
+  RISCVIntrinsicCall.cpp
   Runtime/Allocatable.cpp
   Runtime/ArrayConstructor.cpp
   Runtime/Assign.cpp
   Runtime/Character.cpp
   Runtime/Command.cpp
   Runtime/Derived.cpp
   Runtime/EnvironmentDefaults.cpp
   Runtime/Inquiry.cpp

flang/lib/Optimizer/Builder/IntrinsicCall.cpp

 #include "flang/Optimizer/Builder/IntrinsicCall.h"
 #include "flang/Common/static-multimap-view.h"
 #include "flang/Optimizer/Builder/BoxValue.h"
 #include "flang/Optimizer/Builder/Character.h"
 #include "flang/Optimizer/Builder/Complex.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/MutableBox.h"
 #include "flang/Optimizer/Builder/PPCIntrinsicCall.h"
+#include "flang/Optimizer/Builder/RISCVIntrinsicCall.h"
 #include "flang/Optimizer/Builder/Runtime/Allocatable.h"
 #include "flang/Optimizer/Builder/Runtime/Character.h"
 #include "flang/Optimizer/Builder/Runtime/Command.h"
 #include "flang/Optimizer/Builder/Runtime/Derived.h"
 #include "flang/Optimizer/Builder/Runtime/Inquiry.h"
 #include "flang/Optimizer/Builder/Runtime/Intrinsics.h"
 #include "flang/Optimizer/Builder/Runtime/Numeric.h"
 #include "flang/Optimizer/Builder/Runtime/RTBuilder.h"

 
 static llvm::cl::opt<bool>
     disableMlirComplex("disable-mlir-complex",
                        llvm::cl::desc("Use libm instead of the MLIR complex "
                                       "dialect to lower complex operations"),
                        llvm::cl::init(false));
 
 mlir::Value genLibCall(fir::FirOpBuilder &builder, mlir::Location loc,
                        llvm::StringRef libFuncName,
                        mlir::FunctionType libFuncType,
                        llvm::ArrayRef<mlir::Value> args) {
   LLVM_DEBUG(llvm::dbgs() << "Generating '" << libFuncName
                           << "' call with type ";
              libFuncType.dump(); llvm::dbgs() << "\n");
   mlir::func::FuncOp funcOp = builder.getNamedFunction(libFuncName);
 
   if (!funcOp) {
static constexpr MathOperation mathOperations[] = {
     {"tanh", "tanh", genFuncType<Ty::Real<8>, Ty::Real<8>>,
      genMathOp<mlir::math::TanhOp>},
     {"tanh", "ctanhf", genFuncType<Ty::Complex<4>, Ty::Complex<4>>,
      genComplexMathOp<mlir::complex::TanhOp>},
     {"tanh", "ctanh", genFuncType<Ty::Complex<8>, Ty::Complex<8>>,
      genComplexMathOp<mlir::complex::TanhOp>},
 };
 
 // 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"
 // arguments matters, d(foo, bar) may not be the same as d(bar, foo) because it
searchMathOperation(fir::FirOpBuilder &builder, llvm::StringRef name,
                     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 = checkPPCMathOperationsRange(name);
   }
+  // Search riscvMathOps only if targetting RISCV arch
+  if (fir::getTargetTriple(mod).isRISCV() && range.first == range.second) {
+    range = checkRISCVMathOperationsRange(name);
+  }
   for (auto iter = range.first; iter != range.second && iter; ++iter) {
     const auto &impl = *iter;
     auto implType = impl.typeGenerator(builder.getContext(), builder);
     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/Optimizer/Builder/RISCVIntrinsicCall.cpp

+//===-- RISCVIntrinsicCall.cpp --------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Helper routines for constructing the FIR dialect of MLIR for RISC-V
+// intrinsics. Extensive use of MLIR interfaces and MLIR's coding style
+// (https://mlir.llvm.org/getting_started/DeveloperGuide/) is used in this
+// module.
+//
+//===----------------------------------------------------------------------===//
+
+#include "flang/Optimizer/Builder/RISCVIntrinsicCall.h"
+#include "flang/Optimizer/Builder/FIRBuilder.h"
+#include "flang/Optimizer/Builder/IntrinsicCall.h"
+#include "flang/Optimizer/Builder/MutableBox.h"
+
+namespace fir {
+
+// RISC-V specific intrinsic handlers.
+static constexpr MathOperation riscvMathOperations[] = {
+    {"__riscv_brev8", "llvm.riscv.brev8.i32",
+     genFuncType<Ty::Integer<4>, Ty::Integer<4>>, genLibCall},
+    {"__riscv_brev8", "llvm.riscv.brev8.i64",
+     genFuncType<Ty::Integer<8>, Ty::Integer<8>>, genLibCall},
+    {"__riscv_clmul", "llvm.riscv.clmul.i32",
+     genFuncType<Ty::Integer<4>, Ty::Integer<4>, Ty::Integer<4>>, genLibCall},
+    {"__riscv_clmul", "llvm.riscv.clmul.i64",
+     genFuncType<Ty::Integer<8>, Ty::Integer<8>, Ty::Integer<8>>, genLibCall},
+    {"__riscv_clmulh", "llvm.riscv.clmulh.i32",
+     genFuncType<Ty::Integer<4>, Ty::Integer<4>, Ty::Integer<4>>, genLibCall},
+    {"__riscv_clmulh", "llvm.riscv.clmulh.i64",
+     genFuncType<Ty::Integer<8>, Ty::Integer<8>, Ty::Integer<8>>, genLibCall},
+    {"__riscv_clmulr", "llvm.riscv.clmulr.i32",
+     genFuncType<Ty::Integer<4>, Ty::Integer<4>, Ty::Integer<4>>, genLibCall},
+    {"__riscv_clmulr", "llvm.riscv.clmulr.i64",
+     genFuncType<Ty::Integer<8>, Ty::Integer<8>, Ty::Integer<8>>, genLibCall},
+    {"__riscv_orc_b", "llvm.riscv.orc.b.i32",
+     genFuncType<Ty::Integer<4>, Ty::Integer<4>>, genLibCall},
+    {"__riscv_orc_b", "llvm.riscv.orc.b.i64",
+     genFuncType<Ty::Integer<8>, Ty::Integer<8>>, genLibCall},
+    {"__riscv_unzip", "llvm.riscv.unzip.i32",
+     genFuncType<Ty::Integer<4>, Ty::Integer<4>>, genLibCall},
+    {"__riscv_xperm4", "llvm.riscv.xperm4.i32",
+     genFuncType<Ty::Integer<4>, Ty::Integer<4>, Ty::Integer<4>>, genLibCall},
+    {"__riscv_xperm4", "llvm.riscv.xperm4.i64",
+     genFuncType<Ty::Integer<8>, Ty::Integer<8>, Ty::Integer<8>>, genLibCall},
+    {"__riscv_xperm8", "llvm.riscv.xperm8.i32",
+     genFuncType<Ty::Integer<4>, Ty::Integer<4>, Ty::Integer<4>>, genLibCall},
+    {"__riscv_xperm8", "llvm.riscv.xperm8.i64",
+     genFuncType<Ty::Integer<8>, Ty::Integer<8>, Ty::Integer<8>>, genLibCall},
+    {"__riscv_zip", "llvm.riscv.zip.i32",
+     genFuncType<Ty::Integer<4>, Ty::Integer<4>>, genLibCall},
+};
+
+using RtMap = Fortran::common::StaticMultimapView<MathOperation>;
+static constexpr RtMap riscvMathOps(riscvMathOperations);
+static_assert(riscvMathOps.Verify() && "map must be sorted");
+
+std::pair<const MathOperation *, const MathOperation *>
+checkRISCVMathOperationsRange(llvm::StringRef name) {
+  return riscvMathOps.equal_range(name);
+}
+
+} // namespace fir

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 {
+    }
+    // clang-format off
+    // Check if it is a RISC-V builtin from the predefined module
+#define RISCV_EXTENSION(F) \
+    else if (const auto *riscv64##F##BuiltinScope = \
+                currScope().context().GetRISCV64##F##BuiltinsScope()) { \
+      symbol = FindSymbol(*riscv64##F##BuiltinScope, name); \
+      if (!symbol) { \
+        symbol = &MakeSymbol(context().globalScope(), name.source, Attrs{}); \
+      } \
+    }
+#include "flang/Semantics/riscv-ext-with-intrinsics.def"
+#undef RISCV_EXTENSION
+    // clang-format on
+    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

 #include "check-select-type.h"
 #include "check-stop.h"
 #include "compute-offsets.h"
 #include "mod-file.h"
 #include "resolve-labels.h"
 #include "resolve-names.h"
 #include "rewrite-parse-tree.h"
 #include "flang/Common/default-kinds.h"
+#include "flang/Parser/characters.h"
 #include "flang/Parser/parse-tree-visitor.h"
 #include "flang/Parser/tools.h"
 #include "flang/Semantics/expression.h"
 #include "flang/Semantics/scope.h"
 #include "flang/Semantics/symbol.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TargetParser/Host.h"
 #include "llvm/TargetParser/Triple.h"

 }
 
 void SemanticsContext::UsePPCBuiltinsModule() {
   if (ppcBuiltinsScope_ == nullptr) {
     ppcBuiltinsScope_ = GetBuiltinModule("__ppc_intrinsics");
   }
 }
 
+std::string GetRISCVIntrinsicName(const char *bit, const char *name) {
+  std::string lowerName = name;
+  for (auto &c : lowerName) {
+    c = parser::ToLowerCaseLetter(c);
+  }
+  return lowerName = "__riscv"s + bit + "_" + lowerName + "_intrinsics";
+}
+
+// clang-format off
+#define RISCV_EXTENSION(F) \
+void SemanticsContext::UseRISCV64##F##BuiltinsModule() { \
+  if (riscv64##F##BuiltinsScope_ == nullptr) { \
+    riscv64##F##BuiltinsScope_ = \
+        GetBuiltinModule(GetRISCVIntrinsicName("64", #F).c_str()); \
+  } \
+}
+#include "flang/Semantics/riscv-ext-with-intrinsics.def"
+#undef RISCV_EXTENSION
+// clang-format on
+
 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 == "__ppc_types")) {
       // Don't try to read the builtins module when we're actually building it.
     } else if (frontModule &&
         std::get<parser::Statement<parser::ModuleStmt>>(frontModule->value().t)
                 .statement.v.source == "__ppc_intrinsics") {
       // The derived type definition for the vectors is needed.
       context_.UsePPCBuiltinTypesModule();
-    } else {
+    }
+    // clang-format off
+#define RISCV_EXTENSION(F) \
+    else if (frontModule && \
+        std::get<parser::Statement<parser::ModuleStmt>>(frontModule->value().t) \
+                .statement.v.source == GetRISCVIntrinsicName("64", #F)) { \
+      context_.UseRISCV64##F##BuiltinsModule(); \
+    }
+#include "flang/Semantics/riscv-ext-with-intrinsics.def"
+#undef RISCV_EXTENSION
+    // clang-format on
+    else {
       context_.UseFortranBuiltinsModule();
       llvm::Triple targetTriple{llvm::Triple(
           llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple()))};
       // Only use __ppc_intrinsics module when targetting PowerPC arch
       if (context_.targetCharacteristics().isPPC()) {
         context_.UsePPCBuiltinTypesModule();
         context_.UsePPCBuiltinsModule();
       }
+      if (context_.targetCharacteristics().isRISCV64()) {
+        // clang-format off
+#define RISCV_EXTENSION(F) \
+        if (context_.targetCharacteristics().hasFeature(#F)) { \
+          context_.UseRISCV64##F##BuiltinsModule(); \
+        }
+#include "flang/Semantics/riscv-ext-with-intrinsics.def"
+#undef RISCV_EXTENSION
+        // clang-format on
+      }
     }
   }
   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/__riscv64_zbb_intrinsics.f90

+!===-- module/__riscv64_zbb_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 __RISCV64_Zbb_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
+  end interface
+
+  ! 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
+
+end module __RISCV64_Zbb_intrinsics

flang/module/__riscv64_zbc_intrinsics.f90

+!===-- module/__riscv64_zbc_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 __RISCV64_Zbc_intrinsics
+
+  private
+
+  abstract interface
+    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
+
+  ! 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
+
+end module __RISCV64_Zbc_intrinsics

flang/module/__riscv64_zbkb_intrinsics.f90

+!===-- module/__riscv64_zbkb_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 __RISCV64_Zbkb_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
+  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
+
+end module __RISCV64_Zbkb_intrinsics

flang/module/__riscv64_zbkc_intrinsics.f90

+!===-- module/__riscv64_zbkc_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 __RISCV64_Zbkc_intrinsics
+
+  private
+
+  abstract interface
+    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
+
+  ! 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
+
+end module __RISCV64_Zbkc_intrinsics

flang/module/__riscv64_zbkx_intrinsics.f90

+!===-- module/__riscv64_zbkx_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 __RISCV64_Zbkx_intrinsics
+
+  private
+
+  abstract interface
+    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
+
+  ! 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
+
+  ! xperm8
+  procedure(func_i4i4i4) :: __riscv_xperm8_i4
+  procedure(func_i8i8i8) :: __riscv_xperm8_i8
+  interface xperm8
+    procedure :: __riscv_xperm8_i4
+    procedure :: __riscv_xperm8_i8
+  end interface xperm8
+  public :: xperm8
+
+end module __RISCV64_Zbkx_intrinsics

flang/test/Lower/RISCV/riscv64-zbb-intrinsics.f90

+! RUN: %flang_fc1 -triple riscv64-unknown-linux-gnu -target-feature +zbb \
+! RUN:   -emit-llvm %s -o - | FileCheck --check-prefix="CHECK-LLVMIR" %s
+
+! CHECK-LABEL: orc_b_i32_test
+! 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-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

flang/test/Lower/RISCV/riscv64-zbc-intrinsics.f90

+! RUN: %flang_fc1 -triple riscv64-unknown-linux-gnu -target-feature +zbc \
+! RUN:   -emit-llvm %s -o - | FileCheck --check-prefix="CHECK-LLVMIR" %s
+
+! CHECK-LABEL: clmul_i32_test
+! 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-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-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-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-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-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

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

+! RUN: %flang_fc1 -triple riscv64-unknown-linux-gnu -target-feature +zbkb \
+! RUN:   -emit-llvm %s -o - | FileCheck --check-prefix="CHECK-LLVMIR" %s
+
+! CHECK-LABEL: brev8_i32_test
+! 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-LLVMIR: call i64 @llvm.riscv.brev8.i64(i64 %{{[0-9]}})
+subroutine brev8_i64_test(x)
+  integer(8) :: x, r
+  r = brev8(x)
+end

flang/test/Lower/RISCV/riscv64-zbkc-intrinsics.f90

+! RUN: %flang_fc1 -triple riscv64-unknown-linux-gnu -target-feature +zbkc \
+! RUN:   -emit-llvm %s -o - | FileCheck --check-prefix="CHECK-LLVMIR" %s
+
+! CHECK-LABEL: clmul_i32_test
+! 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-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-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-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

flang/test/Lower/RISCV/riscv64-zbkx-intrinsics.f90

+! RUN: %flang_fc1 -triple riscv64-unknown-linux-gnu -target-feature +zbkx \
+! RUN:   -emit-llvm %s -o - | FileCheck --check-prefix="CHECK-LLVMIR" %s
+
+! CHECK-LABEL: xperm4_i32_test
+! 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-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: xperm8_i32_test
+! CHECK-LLVMIR: call i32 @llvm.riscv.xperm8.i32(i32 %{{[0-9]}}, i32 %{{[0-9]}})
+subroutine xperm8_i32_test(x, y)
+  integer :: x, y, r
+  r = xperm8(x, y)
+end
+
+! CHECK-LABEL: xperm8_i64_test
+! CHECK-LLVMIR: call i64 @llvm.riscv.xperm8.i64(i64 %{{[0-9]}}, i64 %{{[0-9]}})
+subroutine xperm8_i64_test(x, y)
+  integer(8) :: x, y, r
+  r = xperm8(x, y)
+end

flang/tools/bbc/bbc.cpp

int main(int argc, char **argv) {
   // FIXME: Handle real(3) ?
   if (targetTriple.getArch() != llvm::Triple::ArchType::x86 &&
       targetTriple.getArch() != llvm::Triple::ArchType::x86_64) {
     semanticsContext.targetCharacteristics().DisableType(
         Fortran::common::TypeCategory::Real, /*kind=*/10);
   }
   if (targetTriple.isPPC())
     semanticsContext.targetCharacteristics().set_isPPC(true);
+  if (targetTriple.isRISCV64())
+    semanticsContext.targetCharacteristics().set_isRISCV64(true);
 
   return mlir::failed(convertFortranSourceToMLIR(
       inputFilename, options, programPrefix, semanticsContext, passPipe));
 }

flang/tools/f18/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   FrontendOpenACC
   FrontendOpenMP
   Support
   )
 
 set(MODULES
   "__fortran_builtins"
   "__fortran_ieee_exceptions"
   "__fortran_type_info"
   "__ppc_types"
   "__ppc_intrinsics"
+  "__riscv64_zbb_intrinsics"
+  "__riscv64_zbc_intrinsics"
+  "__riscv64_zbkb_intrinsics"
+  "__riscv64_zbkc_intrinsics"
+  "__riscv64_zbkx_intrinsics"
   "__cuda_builtins"
   "ieee_arithmetic"
   "ieee_exceptions"
   "ieee_features"
   "iso_c_binding"
   "iso_fortran_env"
   "omp_lib"
   "__fortran_builtins"