diff --git a/README.md b/README.md
index 0c563c9..1ba6551 100644
--- a/README.md
+++ b/README.md
@@ -218,7 +218,7 @@
   Type *ft = Type::getFloatTy(C);
   Type *dt = Type::getDoubleTy(C);
 
-  std::unique_ptr<Backend> be(go_get_backend(C, llvm::CallingConv::X86_64_SysV));
+  std::unique_ptr<Backend> be(go_get_backend(C, gollvm::driver::CallingConvId::X86_64_SysV));
   Btype *c32 = be->complex_type(64);
   ASSERT_TRUE(c32 != NULL);
   ASSERT_EQ(c32->type(), mkTwoFieldLLvmStruct(C, ft, ft));
diff --git a/bridge/CMakeLists.txt b/bridge/CMakeLists.txt
index 29b71c1..e4bc389 100644
--- a/bridge/CMakeLists.txt
+++ b/bridge/CMakeLists.txt
@@ -61,4 +61,4 @@
 
 include_directories(${EXTINSTALLDIR}/include)
 include_directories(${GOFRONTEND_SOURCE_DIR})
-
+include_directories(${DRIVER_UTILS_SOURCE_DIR})
diff --git a/bridge/go-llvm-backend.h b/bridge/go-llvm-backend.h
index 9c7f7e4..bb0bf0d 100644
--- a/bridge/go-llvm-backend.h
+++ b/bridge/go-llvm-backend.h
@@ -19,6 +19,6 @@
 
 class Backend;
 
-extern Backend *go_get_backend(llvm::LLVMContext &Context, llvm::CallingConv::ID cconv);
+extern Backend *go_get_backend(llvm::LLVMContext &Context, gollvm::driver::CallingConvId cconv);
 
 #endif // !defined(GO_LLVM_BACKEND_H)
diff --git a/bridge/go-llvm-cabi-oracle.cpp b/bridge/go-llvm-cabi-oracle.cpp
index 45c2406..7ba851f 100644
--- a/bridge/go-llvm-cabi-oracle.cpp
+++ b/bridge/go-llvm-cabi-oracle.cpp
@@ -16,6 +16,8 @@
 #include "llvm/IR/DataLayout.h"
 #include "llvm/Support/raw_ostream.h"
 
+#include "CallingConv.h"
+
 //......................................................................
 
 // Given an LLVM type, classify it according to whether it would
@@ -146,12 +148,12 @@
     : typeManager_(tmgr)
 {
   explode(bt);
-  llvm::CallingConv::ID cconv = tmgr->callingConv();
+  gollvm::driver::CallingConvId cconv = tmgr->callingConv();
   switch (cconv) {
-  case llvm::CallingConv::X86_64_SysV:
+  case gollvm::driver::CallingConvId::X86_64_SysV:
     determineABITypesForX86_64_SysV();
     break;
-  case llvm::CallingConv::ARM_AAPCS:
+  case gollvm::driver::CallingConvId::ARM_AAPCS:
     setHFA();
     if (getHFA().number == 0 && tmgr->typeSize(bt) <= 16) {
       // For HFA and indirect cases, we don't need do this.
@@ -159,7 +161,7 @@
     }
     break;
   default:
-    llvm::errs() << "unsupported llvm::CallingConv::ID " << cconv << "\n";
+    llvm::errs() << "unsupported gollvm::driver::CallingConvId " << static_cast<int>(cconv) << "\n";
     break;
   }
 }
@@ -544,18 +546,18 @@
 public:
   ABIState(TypeManager *typm) : argCount_(0) {
     assert(typm != nullptr);
-    llvm::CallingConv::ID cconv = typm->callingConv();
+    gollvm::driver::CallingConvId cconv = typm->callingConv();
     switch (cconv) {
-    case llvm::CallingConv::X86_64_SysV:
+    case gollvm::driver::CallingConvId::X86_64_SysV:
       availIntRegs_ = 6;
       availSSERegs_ = 8;
       break;
-    case llvm::CallingConv::ARM_AAPCS:
+    case gollvm::driver::CallingConvId::ARM_AAPCS:
       availIntRegs_ = 8;
       availSIMDFPRegs_ = 8;
       break;
     default:
-      llvm::errs() << "unsupported llvm::CallingConv::ID " << cconv << "\n";
+      llvm::errs() << "unsupported gollvm::driver::CallingConvId " << static_cast<int>(cconv) << "\n";
       break;
     }
   }
@@ -610,7 +612,7 @@
     , fcnTypeForABI_(nullptr)
     , typeManager_(typeManager)
     , followsCabi_(followsCabi)
-    , ccID_(llvm::CallingConv::MaxID)
+    , ccID_(gollvm::driver::CallingConvId::MaxID)
     , cc_(nullptr)
 {
   setCC();
@@ -624,7 +626,7 @@
     , fcnTypeForABI_(nullptr)
     , typeManager_(typeManager)
     , followsCabi_(ft->followsCabi())
-    , ccID_(llvm::CallingConv::MaxID)
+    , ccID_(gollvm::driver::CallingConvId::MaxID)
     , cc_(nullptr)
 {
   setCC();
@@ -636,21 +638,22 @@
   assert(typeManager_ != nullptr);
   ccID_ = typeManager_->callingConv();
   // Supported architectures at present.
-  assert(ccID_ == llvm::CallingConv::X86_64_SysV ||
-         ccID_ == llvm::CallingConv::ARM_AAPCS);
+  assert(ccID_ == gollvm::driver::CallingConvId::X86_64_SysV ||
+         ccID_ == gollvm::driver::CallingConvId::ARM_AAPCS ||
+         ccID_ == gollvm::driver::CallingConvId::RISCV64_C);
 
   if (cc_ != nullptr) {
     return;
   }
   switch (ccID_) {
-  case llvm::CallingConv::X86_64_SysV:
+  case gollvm::driver::CallingConvId::X86_64_SysV:
     cc_ = std::unique_ptr<CABIOracleArgumentAnalyzer>(new CABIOracleX86_64_SysV(typeManager_));
     break;
-  case llvm::CallingConv::ARM_AAPCS:
+  case gollvm::driver::CallingConvId::ARM_AAPCS:
     cc_ = std::unique_ptr<CABIOracleArgumentAnalyzer>(new CABIOracleARM_AAPCS(typeManager_));
     break;
   default:
-    llvm::errs() << "unsupported llvm::CallingConv::ID " << ccID_ << "\n";
+    llvm::errs() << "unsupported gollvm::driver::CallingConvId " << static_cast<int>(ccID_) << "\n";
     break;
   }
 }
diff --git a/bridge/go-llvm-cabi-oracle.h b/bridge/go-llvm-cabi-oracle.h
index c186c38..86b79f5 100644
--- a/bridge/go-llvm-cabi-oracle.h
+++ b/bridge/go-llvm-cabi-oracle.h
@@ -20,8 +20,8 @@
 #ifndef LLVMGOFRONTEND_GO_LLVM_CABI_ORACLE_H
 #define LLVMGOFRONTEND_GO_LLVM_CABI_ORACLE_H
 
+#include "CallingConv.h"
 #include "go-llvm-btype.h"
-#include "llvm/IR/CallingConv.h"
 
 class TypeManager;
 class EightByteInfo;
@@ -198,7 +198,7 @@
   TypeManager *typeManager_;
   std::vector<CABIParamInfo> infov_;
   bool followsCabi_;
-  llvm::CallingConv::ID ccID_;
+  gollvm::driver::CallingConvId ccID_;
   std::unique_ptr<CABIOracleArgumentAnalyzer> cc_;
 
   // The main entry for cabi analysis.
diff --git a/bridge/go-llvm-typemanager.cpp b/bridge/go-llvm-typemanager.cpp
index ba57edc..4301233 100644
--- a/bridge/go-llvm-typemanager.cpp
+++ b/bridge/go-llvm-typemanager.cpp
@@ -23,7 +23,7 @@
 #include "llvm/IR/Type.h"
 
 TypeManager::TypeManager(llvm::LLVMContext &context,
-                         llvm::CallingConv::ID conv,
+                         gollvm::driver::CallingConvId conv,
                          unsigned addrspace)
     : context_(context)
     , datalayout_(nullptr)
diff --git a/bridge/go-llvm-typemanager.h b/bridge/go-llvm-typemanager.h
index 789b5d5..d77a3ab 100644
--- a/bridge/go-llvm-typemanager.h
+++ b/bridge/go-llvm-typemanager.h
@@ -20,7 +20,7 @@
 #include "namegen.h"
 #include "backend.h"
 
-#include "llvm/IR/CallingConv.h"
+#include "CallingConv.h"
 
 namespace llvm {
 class DataLayout;
@@ -43,7 +43,7 @@
 class TypeManager {
  public:
   TypeManager(llvm::LLVMContext &context,
-              llvm::CallingConv::ID cconv,
+              gollvm::driver::CallingConvId cconv,
               unsigned addrspace);
   ~TypeManager();
 
@@ -246,7 +246,7 @@
   const llvm::DataLayout *datalayout() const { return datalayout_; }
 
   // Calling convention
-  llvm::CallingConv::ID callingConv() const { return cconv_; }
+  gollvm::driver::CallingConvId callingConv() const { return cconv_; }
 
   // For named types, this returns the declared type name. If a type
   // is unnamed, then it returns a stringified representation of the
@@ -287,7 +287,7 @@
   // Context information needed for the LLVM backend.
   llvm::LLVMContext &context_;
   const llvm::DataLayout *datalayout_;
-  llvm::CallingConv::ID cconv_;
+  gollvm::driver::CallingConvId cconv_;
   unsigned addressSpace_;
   unsigned traceLevel_;
 
diff --git a/bridge/go-llvm.cpp b/bridge/go-llvm.cpp
index 312b38b..8ee5a24 100644
--- a/bridge/go-llvm.cpp
+++ b/bridge/go-llvm.cpp
@@ -45,7 +45,7 @@
                            Llvm_linemap *linemap,
                            unsigned addrspace,
                            llvm::Triple triple,
-                           llvm::CallingConv::ID cconv)
+                           gollvm::driver::CallingConvId cconv)
     : TypeManager(context, cconv, addrspace)
     , context_(context)
     , module_(module)
@@ -83,16 +83,21 @@
   if (!module_) {
     ownModule_.reset(new llvm::Module("gomodule", context));
     switch (cconv) {
-      case llvm::CallingConv::X86_64_SysV:
+      case gollvm::driver::CallingConvId::X86_64_SysV:
         ownModule_->setTargetTriple("x86_64-unknown-linux-gnu");
         ownModule_->setDataLayout("e-m:e-i64:64-f80:128-n8:16:32:64-S128");
         triple_ = llvm::Triple("x86_64-unknown-linux-gnu");
         break;
-      case llvm::CallingConv::ARM_AAPCS:
+      case gollvm::driver::CallingConvId::ARM_AAPCS:
         ownModule_->setTargetTriple("aarch64-unknown-linux-gnu");
         ownModule_->setDataLayout("e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128");
         triple_ = llvm::Triple("aarch64-unknown-linux-gnu");
         break;
+      case gollvm::driver::CallingConvId::RISCV64_C:
+        ownModule_->setTargetTriple("riscv64-unknown-linux-gnu");
+        ownModule_->setDataLayout("e-m:e-p:64:64-i64:64-i128:128-n64-S128");
+        triple_ = llvm::Triple("riscv64-unknown-linux-gnu");
+        break;
       default:
         std::cerr <<"Unsupported calling convention\n";
     }
@@ -4158,6 +4163,6 @@
 
 // Return a new backend generator.
 
-Backend *go_get_backend(llvm::LLVMContext &context, llvm::CallingConv::ID cconv) {
+Backend *go_get_backend(llvm::LLVMContext &context, gollvm::driver::CallingConvId cconv) {
   return new Llvm_backend(context, nullptr, nullptr, 0, llvm::Triple(), cconv);
 }
diff --git a/bridge/go-llvm.h b/bridge/go-llvm.h
index 880ae39..cd4d855 100644
--- a/bridge/go-llvm.h
+++ b/bridge/go-llvm.h
@@ -82,7 +82,7 @@
                unsigned addrspace,
                llvm::Triple triple,
                /* Temporarily set the parameter as optional to workaround the unit tests. */
-               llvm::CallingConv::ID cconv=llvm::CallingConv::X86_64_SysV);
+               gollvm::driver::CallingConvId cconv=gollvm::driver::CallingConvId::X86_64_SysV);
   ~Llvm_backend();
 
   // Types.
diff --git a/driver/CallingConv.h b/driver/CallingConv.h
new file mode 100644
index 0000000..cfd791f
--- /dev/null
+++ b/driver/CallingConv.h
@@ -0,0 +1,25 @@
+//===-- CallingConv.h -----------------------------------------------------===//
+//
+// Copyright 2022 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines the CallingConvId type.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef GOLLVM_DRIVER_CALLINGCONV_H
+#define GOLLVM_DRIVER_CALLINGCONV_H
+
+namespace gollvm {
+namespace driver {
+
+// Used inplace of llvm::CallingConv::Id which does not record arch and cpu
+enum class CallingConvId { X86_64_SysV, ARM_AAPCS, RISCV64_C, MaxID };
+
+} // end namespace driver
+} // end namespace gollvm
+
+#endif // GOLLVM_DRIVER_CALLINGCONV_H
diff --git a/driver/CompileGo.cpp b/driver/CompileGo.cpp
index b317c9b..3312a7a 100644
--- a/driver/CompileGo.cpp
+++ b/driver/CompileGo.cpp
@@ -24,6 +24,7 @@
 #include "Action.h"
 #include "ArchCpuSetup.h"
 #include "Artifact.h"
+#include "CallingConv.h"
 #include "Driver.h"
 #include "ToolChain.h"
 
@@ -105,7 +106,7 @@
   Triple triple_;
   const ToolChain &toolchain_;
   Driver &driver_;
-  CallingConv::ID cconv_;
+  CallingConvId cconv_;
   LLVMContext context_;
   const char *progname_;
   std::string executablePath_;
@@ -154,7 +155,7 @@
       triple_(tc.driver().triple()),
       toolchain_(tc),
       driver_(tc.driver()),
-      cconv_(CallingConv::MaxID),
+      cconv_(CallingConvId::MaxID),
       progname_(tc.driver().progname()),
       executablePath_(executablePath),
       args_(tc.driver().args()),
@@ -723,10 +724,13 @@
   assert(triple_.getArch() != Triple::UnknownArch);
   switch (triple_.getArch()) {
     case Triple::x86_64:
-      cconv_ = CallingConv::X86_64_SysV;
+      cconv_ = CallingConvId::X86_64_SysV;
       break;
     case Triple::aarch64:
-      cconv_ = CallingConv::ARM_AAPCS;
+      cconv_ = CallingConvId::ARM_AAPCS;
+      break;
+    case Triple::riscv64:
+      cconv_ = CallingConvId::RISCV64_C;
       break;
     default:
       errs() << "currently Gollvm is not supported on architecture "
diff --git a/passes/CMakeLists.txt b/passes/CMakeLists.txt
index b70279c..af9c25a 100644
--- a/passes/CMakeLists.txt
+++ b/passes/CMakeLists.txt
@@ -18,3 +18,5 @@
 
   DEPENDS intrinsics_gen
 )
+
+include_directories(${DRIVER_UTILS_SOURCE_DIR})
diff --git a/passes/GoStatepoints.cpp b/passes/GoStatepoints.cpp
index 3542a4f..6453db4 100644
--- a/passes/GoStatepoints.cpp
+++ b/passes/GoStatepoints.cpp
@@ -12,6 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "CallingConv.h"
 #include "GoStatepoints.h"
 #include "GoStackMap.h"
 #include "GollvmPasses.h"
@@ -35,7 +36,6 @@
 #include "llvm/IR/Argument.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
-#include "llvm/IR/CallingConv.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
diff --git a/unittests/BackendCore/BackendArrayStruct.cpp b/unittests/BackendCore/BackendArrayStruct.cpp
index 4f40d9c..a488338 100644
--- a/unittests/BackendCore/BackendArrayStruct.cpp
+++ b/unittests/BackendCore/BackendArrayStruct.cpp
@@ -18,11 +18,11 @@
 namespace {
 
 class BackendArrayStructTests
-    : public testing::TestWithParam<llvm::CallingConv::ID> {};
+    : public testing::TestWithParam<gollvm::driver::CallingConvId> {};
 
 INSTANTIATE_TEST_SUITE_P(
     UnitTest, BackendArrayStructTests,
-    goBackendUnitTests::CConvs,
+    goBackendUnitTests::cconvs(),
     [](const testing::TestParamInfo<BackendArrayStructTests::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
diff --git a/unittests/BackendCore/BackendCABIOracleTests.cpp b/unittests/BackendCore/BackendCABIOracleTests.cpp
index c1535ba..3f3c902 100644
--- a/unittests/BackendCore/BackendCABIOracleTests.cpp
+++ b/unittests/BackendCore/BackendCABIOracleTests.cpp
@@ -19,11 +19,11 @@
 namespace {
 
 class BackendCABIOracleTests
-    : public testing::TestWithParam<llvm::CallingConv::ID> {};
+    : public testing::TestWithParam<gollvm::driver::CallingConvId> {};
 
 INSTANTIATE_TEST_SUITE_P(
     UnitTest, BackendCABIOracleTests,
-    goBackendUnitTests::CConvs,
+    goBackendUnitTests::cconvs(),
     [](const testing::TestParamInfo<BackendCABIOracleTests::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
@@ -72,7 +72,7 @@
 TEST(BackendCABIOracleTests, ExtendedAmd64) {
   LLVMContext C;
   std::unique_ptr<Llvm_backend> bep(
-      new Llvm_backend(C, nullptr, nullptr, 0, llvm::Triple(), llvm::CallingConv::X86_64_SysV));
+      new Llvm_backend(C, nullptr, nullptr, 0, llvm::Triple(), gollvm::driver::CallingConvId::X86_64_SysV));
   Llvm_backend *be = bep.get();
 
   Btype *bi8t = be->integer_type(false, 8);
@@ -256,7 +256,7 @@
 TEST(BackendCABIOracleTests, ExtendedArm64) {
   LLVMContext C;
   std::unique_ptr<Llvm_backend> bep(
-      new Llvm_backend(C, nullptr, nullptr, 0, llvm::Triple(), llvm::CallingConv::ARM_AAPCS));
+      new Llvm_backend(C, nullptr, nullptr, 0, llvm::Triple(), gollvm::driver::CallingConvId::ARM_AAPCS));
   Llvm_backend *be = bep.get();
 
   Btype *bi8t = be->integer_type(false, 8);
@@ -439,7 +439,7 @@
 }
 
 TEST(BackendCABIOracleTests, RecursiveCall1Amd64) {
-  FcnTestHarness h(llvm::CallingConv::X86_64_SysV);
+  FcnTestHarness h(gollvm::driver::CallingConvId::X86_64_SysV);
   Llvm_backend *be = h.be();
 
   // type s1 struct {
@@ -564,7 +564,7 @@
 }
 
 TEST(BackendCABIOracleTests, RecursiveCall1Arm64) {
-  FcnTestHarness h(llvm::CallingConv::ARM_AAPCS);
+  FcnTestHarness h(gollvm::driver::CallingConvId::ARM_AAPCS);
   Llvm_backend *be = h.be();
 
   // type s1 struct {
@@ -686,7 +686,7 @@
 }
 
 TEST(BackendCABIOracleTests, PassAndReturnArraysAmd64) {
-  FcnTestHarness h(llvm::CallingConv::X86_64_SysV);
+  FcnTestHarness h(gollvm::driver::CallingConvId::X86_64_SysV);
   Llvm_backend *be = h.be();
 
   Btype *bf32t = be->float_type(32);
@@ -733,7 +733,7 @@
 }
 
 TEST(BackendCABIOracleTests, PassAndReturnArraysArm64) {
-  FcnTestHarness h(llvm::CallingConv::ARM_AAPCS);
+  FcnTestHarness h(gollvm::driver::CallingConvId::ARM_AAPCS);
   Llvm_backend *be = h.be();
 
   Btype *bf32t = be->float_type(32);
@@ -850,7 +850,7 @@
 }
 
 TEST(BackendCABIOracleTests, PassAndReturnComplexAmd64) {
-  FcnTestHarness h(llvm::CallingConv::X86_64_SysV);
+  FcnTestHarness h(gollvm::driver::CallingConvId::X86_64_SysV);
   Llvm_backend *be = h.be();
 
   Btype *bc64t = be->complex_type(64);
@@ -926,7 +926,7 @@
 }
 
 TEST(BackendCABIOracleTests, PassAndReturnComplexArm64) {
-  FcnTestHarness h(llvm::CallingConv::ARM_AAPCS);
+  FcnTestHarness h(gollvm::driver::CallingConvId::ARM_AAPCS);
   Llvm_backend *be = h.be();
 
   Btype *bc64t = be->complex_type(64);
diff --git a/unittests/BackendCore/BackendCallTests.cpp b/unittests/BackendCore/BackendCallTests.cpp
index e835bde..b8d7eaf 100644
--- a/unittests/BackendCore/BackendCallTests.cpp
+++ b/unittests/BackendCore/BackendCallTests.cpp
@@ -17,12 +17,12 @@
 
 namespace {
 
-class BackendCallTests : public testing::TestWithParam<llvm::CallingConv::ID> {
+class BackendCallTests : public testing::TestWithParam<gollvm::driver::CallingConvId> {
 };
 
 INSTANTIATE_TEST_SUITE_P(
     UnitTest, BackendCallTests,
-    goBackendUnitTests::CConvs,
+    goBackendUnitTests::cconvs(),
     [](const testing::TestParamInfo<BackendCallTests::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
@@ -235,7 +235,7 @@
 // expected result. However, the processing method of static link and dynamic
 // link is the same, but the instruction is slightly different.
 TEST(BackendCallTests, TestMakeGetgDynamicArm64) {
-  FcnTestHarness h(llvm::CallingConv::ARM_AAPCS, "foo");
+  FcnTestHarness h(gollvm::driver::CallingConvId::ARM_AAPCS, "foo");
   Llvm_backend *be = h.be();
   be->module().setPICLevel(llvm::PICLevel::BigPIC);
   Bfunction *func = h.func();
diff --git a/unittests/BackendCore/BackendCoreTests.cpp b/unittests/BackendCore/BackendCoreTests.cpp
index dbed58b..30923a0 100644
--- a/unittests/BackendCore/BackendCoreTests.cpp
+++ b/unittests/BackendCore/BackendCoreTests.cpp
@@ -15,12 +15,12 @@
 
 namespace {
 
-class BackendCoreTests : public testing::TestWithParam<llvm::CallingConv::ID> {
+class BackendCoreTests : public testing::TestWithParam<gollvm::driver::CallingConvId> {
 };
 
 INSTANTIATE_TEST_SUITE_P(
     UnitTest, BackendCoreTests,
-    goBackendUnitTests::CConvs,
+    goBackendUnitTests::cconvs(),
     [](const testing::TestParamInfo<BackendCoreTests::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
diff --git a/unittests/BackendCore/BackendDebugEmit.cpp b/unittests/BackendCore/BackendDebugEmit.cpp
index 2875ba4..7859104 100644
--- a/unittests/BackendCore/BackendDebugEmit.cpp
+++ b/unittests/BackendCore/BackendDebugEmit.cpp
@@ -20,12 +20,12 @@
 // changed). Perhaps there is some other way to verify this
 // functionality.
 
-class BackendDebugEmit : public testing::TestWithParam<llvm::CallingConv::ID> {
+class BackendDebugEmit : public testing::TestWithParam<gollvm::driver::CallingConvId> {
 };
 
 INSTANTIATE_TEST_SUITE_P(
     UnitTest, BackendDebugEmit,
-    goBackendUnitTests::CConvs,
+    goBackendUnitTests::cconvs(),
     [](const testing::TestParamInfo<BackendDebugEmit::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
@@ -60,7 +60,7 @@
 
 TEST(BackendDebugEmit, TestSimpleDecl2Amd64) {
   // Test that parameters of empty function are handled correctly.
-  FcnTestHarness h(llvm::CallingConv::X86_64_SysV);
+  FcnTestHarness h(gollvm::driver::CallingConvId::X86_64_SysV);
   Llvm_backend *be = h.be();
   Btype *bi64t = be->integer_type(false, 64);
   Btype *bst = mkBackendStruct(be, bi64t, "f1",
@@ -89,7 +89,7 @@
 
 TEST(BackendDebugEmit, TestSimpleDecl2Arm64) {
   // Test that parameters of empty function are handled correctly.
-  FcnTestHarness h(llvm::CallingConv::ARM_AAPCS);
+  FcnTestHarness h(gollvm::driver::CallingConvId::ARM_AAPCS);
   Llvm_backend *be = h.be();
   Btype *bi64t = be->integer_type(false, 64);
   Btype *bst = mkBackendStruct(be, bi64t, "f1", bi64t, "f2", bi64t, "f3",
diff --git a/unittests/BackendCore/BackendExprTests.cpp b/unittests/BackendCore/BackendExprTests.cpp
index eab503f..a476f06 100644
--- a/unittests/BackendCore/BackendExprTests.cpp
+++ b/unittests/BackendCore/BackendExprTests.cpp
@@ -17,12 +17,12 @@
 
 namespace {
 
-class BackendExprTests : public testing::TestWithParam<llvm::CallingConv::ID> {
+class BackendExprTests : public testing::TestWithParam<gollvm::driver::CallingConvId> {
 };
 
 INSTANTIATE_TEST_SUITE_P(
     UnitTest, BackendExprTests,
-    goBackendUnitTests::CConvs,
+    goBackendUnitTests::cconvs(),
     [](const testing::TestParamInfo<BackendExprTests::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
@@ -1429,7 +1429,7 @@
 }
 
 TEST(BackendExprTests, TestConditionalExpression3Amd64) {
-  FcnTestHarness h(llvm::CallingConv::X86_64_SysV);
+  FcnTestHarness h(gollvm::driver::CallingConvId::X86_64_SysV);
   Llvm_backend *be = h.be();
   Btype *bi32t = be->integer_type(false, 32);
   Btype *abt = be->array_type(bi32t, mkInt64Const(be, int64_t(16)));
@@ -1494,7 +1494,7 @@
 }
 
 TEST(BackendExprTests, TestConditionalExpression3Arm64) {
-  FcnTestHarness h(llvm::CallingConv::ARM_AAPCS);
+  FcnTestHarness h(gollvm::driver::CallingConvId::ARM_AAPCS);
   Llvm_backend *be = h.be();
   Btype *bi32t = be->integer_type(false, 32);
   Btype *abt = be->array_type(bi32t, mkInt64Const(be, int64_t(16)));
diff --git a/unittests/BackendCore/BackendFcnTests.cpp b/unittests/BackendCore/BackendFcnTests.cpp
index 0cf95db..2af5163 100644
--- a/unittests/BackendCore/BackendFcnTests.cpp
+++ b/unittests/BackendCore/BackendFcnTests.cpp
@@ -16,11 +16,11 @@
 
 namespace {
 
-class BackendFcnTests : public testing::TestWithParam<llvm::CallingConv::ID> {};
+class BackendFcnTests : public testing::TestWithParam<gollvm::driver::CallingConvId> {};
 
 INSTANTIATE_TEST_SUITE_P(
     UnitTest, BackendFcnTests,
-    goBackendUnitTests::CConvs,
+    goBackendUnitTests::cconvs(),
     [](const testing::TestParamInfo<BackendFcnTests::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
diff --git a/unittests/BackendCore/BackendNodeTests.cpp b/unittests/BackendCore/BackendNodeTests.cpp
index 34255bf..13a3a5a 100644
--- a/unittests/BackendCore/BackendNodeTests.cpp
+++ b/unittests/BackendCore/BackendNodeTests.cpp
@@ -18,12 +18,12 @@
 
 namespace {
 
-class BackendNodeTests : public testing::TestWithParam<llvm::CallingConv::ID> {
+class BackendNodeTests : public testing::TestWithParam<gollvm::driver::CallingConvId> {
 };
 
 INSTANTIATE_TEST_SUITE_P(
     UnitTest, BackendNodeTests,
-    goBackendUnitTests::CConvs,
+    goBackendUnitTests::cconvs(),
     [](const testing::TestParamInfo<BackendNodeTests::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
diff --git a/unittests/BackendCore/BackendPointerExprTests.cpp b/unittests/BackendCore/BackendPointerExprTests.cpp
index 58978ec..f5882ca 100644
--- a/unittests/BackendCore/BackendPointerExprTests.cpp
+++ b/unittests/BackendCore/BackendPointerExprTests.cpp
@@ -18,11 +18,11 @@
 namespace {
 
 class BackendPointerExprTests
-    : public testing::TestWithParam<llvm::CallingConv::ID> {};
+    : public testing::TestWithParam<gollvm::driver::CallingConvId> {};
 
 INSTANTIATE_TEST_SUITE_P(
     UnitTest, BackendPointerExprTests,
-    goBackendUnitTests::CConvs,
+    goBackendUnitTests::cconvs(),
     [](const testing::TestParamInfo<BackendPointerExprTests::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
diff --git a/unittests/BackendCore/BackendStmtTests.cpp b/unittests/BackendCore/BackendStmtTests.cpp
index 866f3ed..7e47928 100644
--- a/unittests/BackendCore/BackendStmtTests.cpp
+++ b/unittests/BackendCore/BackendStmtTests.cpp
@@ -15,12 +15,12 @@
 
 namespace {
 
-class BackendStmtTests : public testing::TestWithParam<llvm::CallingConv::ID> {
+class BackendStmtTests : public testing::TestWithParam<gollvm::driver::CallingConvId> {
 };
 
 INSTANTIATE_TEST_SUITE_P(
     UnitTest, BackendStmtTests,
-    goBackendUnitTests::CConvs,
+    goBackendUnitTests::cconvs(),
     [](const testing::TestParamInfo<BackendStmtTests::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
diff --git a/unittests/BackendCore/BackendTreeIntegrity.cpp b/unittests/BackendCore/BackendTreeIntegrity.cpp
index df6b32b..0c52b9c 100644
--- a/unittests/BackendCore/BackendTreeIntegrity.cpp
+++ b/unittests/BackendCore/BackendTreeIntegrity.cpp
@@ -16,11 +16,11 @@
 namespace {
 
 class BackendTreeIntegrity
-    : public testing::TestWithParam<llvm::CallingConv::ID> {};
+    : public testing::TestWithParam<gollvm::driver::CallingConvId> {};
 
 INSTANTIATE_TEST_SUITE_P(
     UnitTest, BackendTreeIntegrity,
-    goBackendUnitTests::CConvs,
+    goBackendUnitTests::cconvs(),
     [](const testing::TestParamInfo<BackendTreeIntegrity::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
diff --git a/unittests/BackendCore/BackendVarTests.cpp b/unittests/BackendCore/BackendVarTests.cpp
index 763602e..526cd9d 100644
--- a/unittests/BackendCore/BackendVarTests.cpp
+++ b/unittests/BackendCore/BackendVarTests.cpp
@@ -20,11 +20,11 @@
 
 namespace {
 
-class BackendVarTests : public testing::TestWithParam<llvm::CallingConv::ID> {};
+class BackendVarTests : public testing::TestWithParam<gollvm::driver::CallingConvId> {};
 
 INSTANTIATE_TEST_SUITE_P(
     UnitTest, BackendVarTests,
-    goBackendUnitTests::CConvs,
+    goBackendUnitTests::cconvs(),
     [](const testing::TestParamInfo<BackendVarTests::ParamType> &info) {
       std::string name = goBackendUnitTests::ccName(info.param);
       return name;
diff --git a/unittests/BackendCore/TestUtils.cpp b/unittests/BackendCore/TestUtils.cpp
index bfca6c1..73475e1 100644
--- a/unittests/BackendCore/TestUtils.cpp
+++ b/unittests/BackendCore/TestUtils.cpp
@@ -12,14 +12,17 @@
 
 namespace goBackendUnitTests {
 
-std::string ccName(llvm::CallingConv::ID cc) {
-  assert(cc == llvm::CallingConv::X86_64_SysV ||
-         cc == llvm::CallingConv::ARM_AAPCS);
+std::string ccName(gollvm::driver::CallingConvId cc) {
+  assert(cc == gollvm::driver::CallingConvId::X86_64_SysV ||
+         cc == gollvm::driver::CallingConvId::ARM_AAPCS ||
+         cc == gollvm::driver::CallingConvId::RISCV64_C);
   switch (cc) {
-  case llvm::CallingConv::X86_64_SysV:
+  case gollvm::driver::CallingConvId::X86_64_SysV:
     return "X8664SysV";
-  case llvm::CallingConv::ARM_AAPCS:
+  case gollvm::driver::CallingConvId::ARM_AAPCS:
     return "ARMAAPCS";
+  case gollvm::driver::CallingConvId::RISCV64_C:
+    return "RISCV64C";
   default:
     return "";
   }
@@ -384,7 +387,7 @@
   return trimsp(vis.result());
 }
 
-FcnTestHarness::FcnTestHarness(llvm::CallingConv::ID cconv, const char *fcnName)
+FcnTestHarness::FcnTestHarness(gollvm::driver::CallingConvId cconv, const char *fcnName)
     : context_()
     , be_(new Llvm_backend(context_, nullptr, nullptr, 0, llvm::Triple(), cconv))
     , func_(nullptr)
diff --git a/unittests/BackendCore/TestUtils.h b/unittests/BackendCore/TestUtils.h
index 366fbf7..fa6774e 100644
--- a/unittests/BackendCore/TestUtils.h
+++ b/unittests/BackendCore/TestUtils.h
@@ -32,11 +32,13 @@
 namespace goBackendUnitTests {
 
 // All supported calling conventions
-auto CConvs = testing::Values(llvm::CallingConv::X86_64_SysV,
-                              llvm::CallingConv::ARM_AAPCS);
+inline auto cconvs() {
+  return testing::Values(gollvm::driver::CallingConvId::X86_64_SysV,
+                         gollvm::driver::CallingConvId::ARM_AAPCS);
+}
 
-// Convert llvm::CallingConv::ID to its coresponding string name.
-std::string ccName(llvm::CallingConv::ID);
+// Convert gollvm::driver::CallingConvId to its coresponding string name.
+std::string ccName(gollvm::driver::CallingConvId);
 
 // Return string representation of LLVM value (handling null ptr)
 std::string repr(llvm::Value *val);
@@ -158,7 +160,7 @@
  public:
   // Create test harness. If name specified, then create a
   // default function "fcnName(i1, i2 int32) int64".
-  FcnTestHarness(llvm::CallingConv::ID cconv, const char *fcnName = nullptr);
+  FcnTestHarness(gollvm::driver::CallingConvId cconv, const char *fcnName = nullptr);
   ~FcnTestHarness();
 
   // Create function to work on
diff --git a/unittests/CMakeLists.txt b/unittests/CMakeLists.txt
index cac798a..b20037a 100644
--- a/unittests/CMakeLists.txt
+++ b/unittests/CMakeLists.txt
@@ -24,6 +24,7 @@
 include_directories(${EXTINSTALLDIR}/include)
 include_directories(${BRIDGE_SOURCE_DIR})
 include_directories(${GOFRONTEND_SOURCE_DIR})
+include_directories(${DRIVER_UTILS_SOURCE_DIR})
 
 add_subdirectory(DriverUtils)
 add_subdirectory(Driver)