diff --git a/lib/SPIRV/OCLToSPIRV.cpp b/lib/SPIRV/OCLToSPIRV.cpp
index c9f0f2da3d..312530b4fb 100644
--- a/lib/SPIRV/OCLToSPIRV.cpp
+++ b/lib/SPIRV/OCLToSPIRV.cpp
@@ -174,7 +174,7 @@ bool OCLToSPIRVBase::runOCLToSPIRV(Module &Module) {
       std::get<0>(Src) != spv::SourceLanguageOpenCL_CPP &&
       std::get<0>(Src) != spv::SourceLanguageCPP_for_OpenCL)
     return false;
-
+  SrcLang = std::get<0>(Src);
   CLVer = std::get<1>(Src);
 
   LLVM_DEBUG(dbgs() << "Enter OCLToSPIRV:\n");
@@ -203,7 +203,8 @@ void OCLToSPIRVBase::visitCallInst(CallInst &CI) {
 
   auto MangledName = F->getName();
   StringRef DemangledName;
-  if (!oclIsBuiltin(MangledName, DemangledName))
+
+  if (!oclIsBuiltin(MangledName, DemangledName, isCpp(SrcLang)))
     return;
 
   LLVM_DEBUG(dbgs() << "DemangledName: " << DemangledName << '\n');
@@ -710,7 +711,7 @@ void OCLToSPIRVBase::transAtomicBuiltin(CallInst *CI,
 }
 
 void OCLToSPIRVBase::visitCallBarrier(CallInst *CI) {
-  auto Lit = getBarrierLiterals(CI);
+  auto Lit = getBarrierLiterals(CI, isCpp(SrcLang));
   // Use sequential consistent memory order by default.
   // But if the flags argument is set to 0, we use
   // None(Relaxed) memory order.
@@ -955,7 +956,8 @@ void OCLToSPIRVBase::transBuiltin(CallInst *CI, OCLBuiltinTransInfo &Info) {
     } else {
       Info.UniqName = getSPIRVFuncName(OC);
     }
-  } else if ((ExtOp = getExtOp(Info.MangledName, Info.UniqName)) != ~0U)
+  } else if ((ExtOp = getExtOp(Info.MangledName, Info.UniqName,
+                               isCpp(SrcLang))) != ~0U)
     Info.UniqName = getSPIRVExtFuncName(SPIRVEIS_OpenCL, ExtOp);
   else if (SPIRSPIRVBuiltinVariableMap::find(Info.UniqName, &BVKind)) {
     // Map OCL work item builtins to SPV-IR work item builtins.
@@ -1397,8 +1399,9 @@ void OCLToSPIRVBase::visitCallScalToVec(CallInst *CI, StringRef MangledName,
   Type *VecTy = CI->getOperand(VecPos[0])->getType();
   auto VecElemCount = cast<VectorType>(VecTy)->getElementCount();
   auto Mutator = mutateCallInst(
-      CI, getSPIRVExtFuncName(SPIRVEIS_OpenCL,
-                              getExtOp(MangledName, DemangledName)));
+      CI,
+      getSPIRVExtFuncName(SPIRVEIS_OpenCL, getExtOp(MangledName, DemangledName,
+                                                    isCpp(SrcLang))));
   for (auto I : ScalarPos)
     Mutator.mapArg(I, [&](Value *V) {
       Instruction *Inst = InsertElementInst::Create(UndefValue::get(VecTy), V,
@@ -1795,7 +1798,7 @@ void OCLToSPIRVBase::visitSubgroupAVCBuiltinCallWithSampler(
 
 void OCLToSPIRVBase::visitCallSplitBarrierINTEL(CallInst *CI,
                                                 StringRef DemangledName) {
-  auto Lit = getBarrierLiterals(CI);
+  auto Lit = getBarrierLiterals(CI, isCpp(SrcLang));
   Op OpCode =
       StringSwitch<Op>(DemangledName)
           .Case("intel_work_group_barrier_arrive", OpControlBarrierArriveINTEL)
diff --git a/lib/SPIRV/OCLToSPIRV.h b/lib/SPIRV/OCLToSPIRV.h
index d57cd7fdaf..196f4a23c0 100644
--- a/lib/SPIRV/OCLToSPIRV.h
+++ b/lib/SPIRV/OCLToSPIRV.h
@@ -54,8 +54,8 @@ class OCLTypeToSPIRVBase;
 class OCLToSPIRVBase : public InstVisitor<OCLToSPIRVBase>, BuiltinCallHelper {
 public:
   OCLToSPIRVBase()
-      : BuiltinCallHelper(ManglingRules::SPIRV), Ctx(nullptr), CLVer(0),
-        OCLTypeToSPIRVPtr(nullptr) {}
+      : BuiltinCallHelper(ManglingRules::SPIRV), Ctx(nullptr), SrcLang(0),
+        CLVer(0), OCLTypeToSPIRVPtr(nullptr) {}
   virtual ~OCLToSPIRVBase() {}
   bool runOCLToSPIRV(Module &M);
 
@@ -267,6 +267,7 @@ class OCLToSPIRVBase : public InstVisitor<OCLToSPIRVBase>, BuiltinCallHelper {
 
 private:
   LLVMContext *Ctx;
+  unsigned SrcLang;
   unsigned CLVer; /// OpenCL version as major*10+minor
   std::set<Instruction *> ValuesToDelete;
   OCLTypeToSPIRVBase *OCLTypeToSPIRVPtr;
diff --git a/lib/SPIRV/OCLTypeToSPIRV.cpp b/lib/SPIRV/OCLTypeToSPIRV.cpp
index 0c9f6f9a96..00d4c0d425 100644
--- a/lib/SPIRV/OCLTypeToSPIRV.cpp
+++ b/lib/SPIRV/OCLTypeToSPIRV.cpp
@@ -77,7 +77,8 @@ OCLTypeToSPIRVBase &OCLTypeToSPIRVPass::run(llvm::Module &M,
 }
 
 OCLTypeToSPIRVBase::OCLTypeToSPIRVBase()
-    : BuiltinCallHelper(ManglingRules::None), M(nullptr), Ctx(nullptr) {}
+    : BuiltinCallHelper(ManglingRules::None), M(nullptr), Ctx(nullptr),
+      SrcLang(0) {}
 
 bool OCLTypeToSPIRVBase::runOCLTypeToSPIRV(Module &Module) {
   LLVM_DEBUG(dbgs() << "Enter OCLTypeToSPIRV:\n");
@@ -95,7 +96,7 @@ bool OCLTypeToSPIRVBase::runOCLTypeToSPIRV(Module &Module) {
       std::get<0>(Src) != spv::SourceLanguageOpenCL_CPP &&
       std::get<0>(Src) != spv::SourceLanguageCPP_for_OpenCL)
     return false;
-
+  SrcLang = std::get<0>(Src);
   for (auto &F : Module.functions())
     adaptArgumentsByMetadata(&F);
 
@@ -199,7 +200,7 @@ void OCLTypeToSPIRVBase::adaptArgumentsBySamplerUse(Module &M) {
       continue;
     auto MangledName = F.getName();
     StringRef DemangledName;
-    if (!oclIsBuiltin(MangledName, DemangledName, false))
+    if (!oclIsBuiltin(MangledName, DemangledName, isCpp(SrcLang)))
       continue;
     if (DemangledName.find(kSPIRVName::SampledImage) == std::string::npos)
       continue;
diff --git a/lib/SPIRV/OCLTypeToSPIRV.h b/lib/SPIRV/OCLTypeToSPIRV.h
index 2ee77a954d..d76c9ffc12 100644
--- a/lib/SPIRV/OCLTypeToSPIRV.h
+++ b/lib/SPIRV/OCLTypeToSPIRV.h
@@ -67,6 +67,7 @@ class OCLTypeToSPIRVBase : protected BuiltinCallHelper {
 private:
   llvm::Module *M;
   llvm::LLVMContext *Ctx;
+  unsigned SrcLang;
   // Map of argument/Function -> adapted type (probably TypedPointerType)
   std::unordered_map<llvm::Value *, llvm::Type *> AdaptedTy;
   std::set<llvm::Function *> WorkSet; // Functions to be adapted
diff --git a/lib/SPIRV/OCLUtil.cpp b/lib/SPIRV/OCLUtil.cpp
index 2e21568710..fd7e018296 100644
--- a/lib/SPIRV/OCLUtil.cpp
+++ b/lib/SPIRV/OCLUtil.cpp
@@ -716,13 +716,13 @@ bool isComputeAtomicOCLBuiltin(StringRef DemangledName) {
       .Default(false);
 }
 
-BarrierLiterals getBarrierLiterals(CallInst *CI) {
+BarrierLiterals getBarrierLiterals(CallInst *CI, bool IsCpp) {
   auto N = CI->arg_size();
   assert(N == 1 || N == 2);
 
   StringRef DemangledName;
   assert(CI->getCalledFunction() && "Unexpected indirect call");
-  if (!oclIsBuiltin(CI->getCalledFunction()->getName(), DemangledName)) {
+  if (!oclIsBuiltin(CI->getCalledFunction()->getName(), DemangledName, IsCpp)) {
     assert(0 &&
            "call must a builtin (work_group_barrier or sub_group_barrier)");
   }
@@ -738,9 +738,11 @@ BarrierLiterals getBarrierLiterals(CallInst *CI) {
                          Scope);
 }
 
-unsigned getExtOp(StringRef OrigName, StringRef GivenDemangledName) {
+unsigned getExtOp(StringRef OrigName, StringRef GivenDemangledName,
+                  bool IsCpp) {
   std::string DemangledName{GivenDemangledName};
-  if (DemangledName.empty() || !oclIsBuiltin(OrigName, GivenDemangledName))
+  if (DemangledName.empty() ||
+      !oclIsBuiltin(OrigName, GivenDemangledName, IsCpp))
     return ~0U;
   LLVM_DEBUG(dbgs() << "getExtOp: demangled name: " << DemangledName << '\n');
   OCLExtOpKind EOC;
diff --git a/lib/SPIRV/OCLUtil.h b/lib/SPIRV/OCLUtil.h
index 53cdfbd4b7..f29fbe14c0 100644
--- a/lib/SPIRV/OCLUtil.h
+++ b/lib/SPIRV/OCLUtil.h
@@ -411,13 +411,14 @@ const static char TypePrefix[] = "opencl.intel_sub_group_avc_";
 ///   not empty.
 /// \return instruction index of extended instruction if the OpenCL builtin
 ///   function is translated to an extended instruction, otherwise ~0U.
-unsigned getExtOp(StringRef MangledName, StringRef DemangledName = "");
+unsigned getExtOp(StringRef MangledName, StringRef DemangledName = "",
+                  bool IsCpp = false);
 
 /// Get literal arguments of call of atomic_work_item_fence.
 AtomicWorkItemFenceLiterals getAtomicWorkItemFenceLiterals(CallInst *CI);
 
 /// Get literal arguments of call of work_group_barrier or sub_group_barrier.
-BarrierLiterals getBarrierLiterals(CallInst *CI);
+BarrierLiterals getBarrierLiterals(CallInst *CI, bool IsCpp = false);
 
 /// Get number of memory order arguments for atomic builtin function.
 size_t getAtomicBuiltinNumMemoryOrderArgs(StringRef Name);
diff --git a/lib/SPIRV/SPIRVInternal.h b/lib/SPIRV/SPIRVInternal.h
index b2d8bb75ca..1834a12a34 100644
--- a/lib/SPIRV/SPIRVInternal.h
+++ b/lib/SPIRV/SPIRVInternal.h
@@ -632,7 +632,8 @@ std::string getSPIRVExtFuncName(SPIRVExtInstSetKind Set, unsigned ExtOp,
 ///   otherwise return OpNop.
 /// \param Dec contains decorations decoded from function name if it is
 ///   not nullptr.
-Op getSPIRVFuncOC(StringRef Name, SmallVectorImpl<std::string> *Dec = nullptr);
+Op getSPIRVFuncOC(StringRef Name, SmallVectorImpl<std::string> *Dec = nullptr,
+                  bool IsCpp = false);
 
 /// Get SPIR-V builtin variable enum given the canonical builtin name
 /// Assume \param Name is in format __spirv_BuiltIn{Name}
@@ -951,7 +952,8 @@ bool hasLoopMetadata(const Module *M);
 
 // Check if CI is a call to instruction from OpenCL Extended Instruction Set.
 // If so, return it's extended opcode in ExtOp.
-bool isSPIRVOCLExtInst(const CallInst *CI, OCLExtOpKind *ExtOp);
+bool isSPIRVOCLExtInst(const CallInst *CI, OCLExtOpKind *ExtOp,
+                       bool IsCpp = false);
 
 /// Returns true if a function name corresponds to an OpenCL builtin that is not
 /// expected to have name mangling.
@@ -980,11 +982,11 @@ bool lowerBuiltinVariableToCall(GlobalVariable *GV,
 bool lowerBuiltinVariablesToCalls(Module *M);
 
 // Transform all builtin calls into variables
-bool lowerBuiltinCallsToVariables(Module *M);
+bool lowerBuiltinCallsToVariables(Module *M, bool IsCpp = false);
 
 //  Transform all builtins into variables or calls
 //  depending on user specification
-bool lowerBuiltins(SPIRVModule *BM, Module *M);
+bool lowerBuiltins(SPIRVModule *BM, Module *M, bool IsCpp = false);
 
 /// \brief Post-process OpenCL or SPIRV builtin function returning struct type.
 ///
@@ -1003,6 +1005,8 @@ bool postProcessBuiltinsReturningStruct(Module *M, bool IsCpp = false);
 
 bool postProcessBuiltinsWithArrayArguments(Module *M, bool IsCpp = false);
 
+bool isCpp(unsigned SrcLang);
+
 } // namespace SPIRV
 
 #endif // SPIRV_SPIRVINTERNAL_H
diff --git a/lib/SPIRV/SPIRVReader.cpp b/lib/SPIRV/SPIRVReader.cpp
index d028203542..0dbb1248e8 100644
--- a/lib/SPIRV/SPIRVReader.cpp
+++ b/lib/SPIRV/SPIRVReader.cpp
@@ -3432,7 +3432,9 @@ bool SPIRVToLLVM::translate() {
   if (!transSourceExtension())
     return false;
   transGeneratorMD();
-  if (!lowerBuiltins(BM, M))
+  SPIRVWord Ver = 0;
+  SourceLanguage SrcLang = BM->getSourceLanguage(&Ver);
+  if (!lowerBuiltins(BM, M, isCpp(SrcLang)))
     return false;
   if (BM->getDesiredBIsRepresentation() == BIsRepresentation::SPIRVFriendlyIR) {
     SPIRVWord SrcLangVer = 0;
diff --git a/lib/SPIRV/SPIRVToOCL.cpp b/lib/SPIRV/SPIRVToOCL.cpp
index c00c9f1891..3982699d9a 100644
--- a/lib/SPIRV/SPIRVToOCL.cpp
+++ b/lib/SPIRV/SPIRVToOCL.cpp
@@ -55,7 +55,7 @@ void SPIRVToOCLBase::visitCallInst(CallInst &CI) {
     return;
 
   OCLExtOpKind ExtOp;
-  if (isSPIRVOCLExtInst(&CI, &ExtOp)) {
+  if (isSPIRVOCLExtInst(&CI, &ExtOp, isCpp(SrcLang))) {
     switch (ExtOp) {
     case OpenCLLIB::Vloadn:
     case OpenCLLIB::Vloada_halfn:
@@ -89,8 +89,8 @@ void SPIRVToOCLBase::visitCallInst(CallInst &CI) {
   StringRef DemangledName;
   Op OC = OpNop;
   SPIRVBuiltinVariableKind BuiltinKind = SPIRVBuiltinVariableKind::BuiltInMax;
-  if (!oclIsBuiltin(MangledName, DemangledName) ||
-      ((OC = getSPIRVFuncOC(DemangledName)) == OpNop &&
+  if (!oclIsBuiltin(MangledName, DemangledName, isCpp(SrcLang)) ||
+      ((OC = getSPIRVFuncOC(DemangledName, nullptr, isCpp(SrcLang))) == OpNop &&
        !getSPIRVBuiltin(DemangledName.str(), BuiltinKind)))
     return;
   LLVM_DEBUG(dbgs() << "DemangledName = " << DemangledName.str() << '\n'
diff --git a/lib/SPIRV/SPIRVToOCL.h b/lib/SPIRV/SPIRVToOCL.h
index d18e9980bc..0074d079f5 100644
--- a/lib/SPIRV/SPIRVToOCL.h
+++ b/lib/SPIRV/SPIRVToOCL.h
@@ -57,7 +57,7 @@ class SPIRVToOCLBase : public InstVisitor<SPIRVToOCLBase>,
 public:
   SPIRVToOCLBase()
       : BuiltinCallHelper(ManglingRules::OpenCL, translateOpaqueType),
-        M(nullptr), Ctx(nullptr) {}
+        M(nullptr), Ctx(nullptr), SrcLang(0) {}
   virtual ~SPIRVToOCLBase() {}
 
   virtual bool runSPIRVToOCL(Module &M) = 0;
@@ -292,6 +292,7 @@ class SPIRVToOCLBase : public InstVisitor<SPIRVToOCLBase>,
 protected:
   Module *M;
   LLVMContext *Ctx;
+  unsigned SrcLang;
 };
 
 class SPIRVToOCLLegacy : public ModulePass {
diff --git a/lib/SPIRV/SPIRVToOCL12.cpp b/lib/SPIRV/SPIRVToOCL12.cpp
index 5aa265a9d6..d6fdca5565 100644
--- a/lib/SPIRV/SPIRVToOCL12.cpp
+++ b/lib/SPIRV/SPIRVToOCL12.cpp
@@ -52,6 +52,8 @@ bool SPIRVToOCL12Legacy::runOnModule(Module &Module) {
 bool SPIRVToOCL12Base::runSPIRVToOCL(Module &Module) {
   M = &Module;
   Ctx = &M->getContext();
+  auto Src = getSPIRVSource(&Module);
+  SrcLang = std::get<0>(Src);
 
   // Lower builtin variables to builtin calls first.
   lowerBuiltinVariablesToCalls(M);
diff --git a/lib/SPIRV/SPIRVToOCL20.cpp b/lib/SPIRV/SPIRVToOCL20.cpp
index 95b04aa697..c658fd9cd1 100644
--- a/lib/SPIRV/SPIRVToOCL20.cpp
+++ b/lib/SPIRV/SPIRVToOCL20.cpp
@@ -51,6 +51,8 @@ bool SPIRVToOCL20Legacy::runOnModule(Module &Module) {
 bool SPIRVToOCL20Base::runSPIRVToOCL(Module &Module) {
   M = &Module;
   Ctx = &M->getContext();
+  auto Src = getSPIRVSource(&Module);
+  SrcLang = std::get<0>(Src);
 
   // Lower builtin variables to builtin calls first.
   lowerBuiltinVariablesToCalls(M);
diff --git a/lib/SPIRV/SPIRVTypeScavenger.cpp b/lib/SPIRV/SPIRVTypeScavenger.cpp
index 6116658036..1fb30c1eea 100644
--- a/lib/SPIRV/SPIRVTypeScavenger.cpp
+++ b/lib/SPIRV/SPIRVTypeScavenger.cpp
@@ -446,9 +446,9 @@ bool SPIRVTypeScavenger::typeIntrinsicCall(
   };
 
   StringRef DemangledName;
-  if (oclIsBuiltin(TargetFn->getName(), DemangledName) ||
+  if (oclIsBuiltin(TargetFn->getName(), DemangledName, isCpp(SrcLang)) ||
       isDecoratedSPIRVFunc(TargetFn, DemangledName)) {
-    Op OC = getSPIRVFuncOC(DemangledName);
+    Op OC = getSPIRVFuncOC(DemangledName, nullptr, isCpp(SrcLang));
     switch (OC) {
     case OpAtomicLoad:
     case OpAtomicExchange:
diff --git a/lib/SPIRV/SPIRVTypeScavenger.h b/lib/SPIRV/SPIRVTypeScavenger.h
index be791a3ffa..75a8e35854 100644
--- a/lib/SPIRV/SPIRVTypeScavenger.h
+++ b/lib/SPIRV/SPIRVTypeScavenger.h
@@ -47,6 +47,8 @@
 #include "llvm/IR/Module.h"
 #include "llvm/IR/ValueMap.h"
 
+#include "SPIRVInternal.h"
+
 using namespace llvm;
 
 /// This class allows for the recovery of typed pointer types from LLVM opaque
@@ -208,8 +210,13 @@ class SPIRVTypeScavenger {
   /// currently being investigated, to avoid the possibility of infinite cycles.
   std::vector<Value *> VisitStack;
 
+  /// Source language
+  unsigned SrcLang;
+
 public:
   explicit SPIRVTypeScavenger(Module &M) : UnifiedTypeVars(1024) {
+    auto Src = getSPIRVSource(&M);
+    SrcLang = std::get<0>(Src);
     typeModule(M);
   }
 
diff --git a/lib/SPIRV/SPIRVUtil.cpp b/lib/SPIRV/SPIRVUtil.cpp
index b0ff6289a1..8d9aa66885 100644
--- a/lib/SPIRV/SPIRVUtil.cpp
+++ b/lib/SPIRV/SPIRVUtil.cpp
@@ -411,11 +411,11 @@ bool isNonMangledOCLBuiltin(StringRef Name) {
          isPipeOrAddressSpaceCastBI(Name.drop_front(2));
 }
 
-Op getSPIRVFuncOC(StringRef S, SmallVectorImpl<std::string> *Dec) {
+Op getSPIRVFuncOC(StringRef S, SmallVectorImpl<std::string> *Dec, bool IsCpp) {
   Op OC;
   SmallVector<StringRef, 2> Postfix;
   StringRef Name;
-  if (!oclIsBuiltin(S, Name))
+  if (!oclIsBuiltin(S, Name, IsCpp))
     Name = S;
   StringRef R(Name);
   if ((!Name.starts_with(kSPIRVName::Prefix) && !isNonMangledOCLBuiltin(S)) ||
@@ -454,23 +454,24 @@ bool oclIsBuiltin(StringRef Name, StringRef &DemangledName, bool IsCpp) {
   // TODO: consider using 'St' abbriviation for cl namespace mangling.
   // Similar to ::std:: in C++.
   if (IsCpp) {
-    if (!Name.starts_with("_ZN"))
-      return false;
-    // Skip CV and ref qualifiers.
-    size_t NameSpaceStart = Name.find_first_not_of("rVKRO", 3);
-    // All built-ins are in the ::cl:: namespace.
-    if (Name.substr(NameSpaceStart, 11) != "2cl7__spirv")
+    if (Name.starts_with("_ZN")) {
+      // Skip CV and ref qualifiers.
+      size_t NameSpaceStart = Name.find_first_not_of("rVKRO", 3);
+      // All built-ins are in the ::cl:: namespace.
+      if (Name.substr(NameSpaceStart, 11) != "2cl7__spirv")
+        return false;
+      size_t DemangledNameLenStart = NameSpaceStart + 11;
+      size_t Start =
+          Name.find_first_not_of("0123456789", DemangledNameLenStart);
+      size_t Len = 0;
+      if (!Name.substr(DemangledNameLenStart, Start - DemangledNameLenStart)
+               .getAsInteger(10, Len)) {
+        DemangledName = Name.substr(Start, Len);
+        return true;
+      }
+      SPIRVDBG(errs() << "Error in extracting integer value");
       return false;
-    size_t DemangledNameLenStart = NameSpaceStart + 11;
-    size_t Start = Name.find_first_not_of("0123456789", DemangledNameLenStart);
-    size_t Len = 0;
-    if (!Name.substr(DemangledNameLenStart, Start - DemangledNameLenStart)
-             .getAsInteger(10, Len)) {
-      DemangledName = Name.substr(Start, Len);
-      return true;
     }
-    SPIRVDBG(errs() << "Error in extracting integer value");
-    return false;
   }
   size_t Start = Name.find_first_not_of("0123456789", 2);
   size_t Len = 0;
@@ -1788,9 +1789,9 @@ bool hasLoopMetadata(const Module *M) {
   return false;
 }
 
-bool isSPIRVOCLExtInst(const CallInst *CI, OCLExtOpKind *ExtOp) {
+bool isSPIRVOCLExtInst(const CallInst *CI, OCLExtOpKind *ExtOp, bool IsCpp) {
   StringRef DemangledName;
-  if (!oclIsBuiltin(CI->getCalledFunction()->getName(), DemangledName))
+  if (!oclIsBuiltin(CI->getCalledFunction()->getName(), DemangledName, IsCpp))
     return false;
   StringRef S = DemangledName;
   if (!S.starts_with(kSPIRVName::Prefix))
@@ -2117,7 +2118,7 @@ bool lowerBuiltinVariablesToCalls(Module *M) {
 ///  SPV-IR: @_Z22__spirv_BuiltInWorkDim()
 ///    is transformed as:
 ///  load WorkDim
-bool lowerBuiltinCallsToVariables(Module *M) {
+bool lowerBuiltinCallsToVariables(Module *M, bool IsCpp) {
   LLVM_DEBUG(dbgs() << "Enter lowerBuiltinCallsToVariables\n");
   // Store instructions and functions that need to be removed.
   SmallVector<Value *, 16> ToRemove;
@@ -2126,7 +2127,7 @@ bool lowerBuiltinCallsToVariables(Module *M) {
     if (!F.isDeclaration())
       continue;
     StringRef DemangledName;
-    if (!oclIsBuiltin(F.getName(), DemangledName))
+    if (!oclIsBuiltin(F.getName(), DemangledName, IsCpp))
       continue;
     LLVM_DEBUG(dbgs() << "Function demangled name: " << DemangledName << '\n');
     SmallVector<StringRef, 2> Postfix;
@@ -2175,11 +2176,12 @@ bool lowerBuiltinCallsToVariables(Module *M) {
   return true;
 }
 
-bool lowerBuiltins(SPIRVModule *BM, Module *M) {
+bool lowerBuiltins(SPIRVModule *BM, Module *M, bool IsCpp) {
   auto Format = BM->getBuiltinFormat();
   if (Format == BuiltinFormat::Function && !lowerBuiltinVariablesToCalls(M))
     return false;
-  if (Format == BuiltinFormat::Global && !lowerBuiltinCallsToVariables(M))
+  if (Format == BuiltinFormat::Global &&
+      !lowerBuiltinCallsToVariables(M, IsCpp))
     return false;
   return true;
 }
@@ -2555,4 +2557,9 @@ std::string getSPIRVFriendlyIRFunctionName(const std::string &UniqName,
   return mangleBuiltin(UniqName, ArgTys, &MangleInfo);
 }
 
+bool isCpp(unsigned SrcLang) {
+  return SrcLang == spv::SourceLanguageOpenCL_CPP ||
+         SrcLang == spv::SourceLanguageCPP_for_OpenCL;
+}
+
 } // namespace SPIRV
diff --git a/lib/SPIRV/SPIRVWriter.cpp b/lib/SPIRV/SPIRVWriter.cpp
index 3132f2c73a..844c580132 100644
--- a/lib/SPIRV/SPIRVWriter.cpp
+++ b/lib/SPIRV/SPIRVWriter.cpp
@@ -256,19 +256,19 @@ bool LLVMToSPIRVBase::isKernel(Function *F) {
 
 bool LLVMToSPIRVBase::isBuiltinTransToInst(Function *F) {
   StringRef DemangledName;
-  if (!oclIsBuiltin(F->getName(), DemangledName) &&
+  if (!oclIsBuiltin(F->getName(), DemangledName, isCpp(SrcLang)) &&
       !isDecoratedSPIRVFunc(F, DemangledName))
     return false;
   SPIRVDBG(spvdbgs() << "CallInst: demangled name: " << DemangledName.str()
                      << '\n');
-  return getSPIRVFuncOC(DemangledName) != OpNop;
+  return getSPIRVFuncOC(DemangledName, nullptr, isCpp(SrcLang)) != OpNop;
 }
 
 bool LLVMToSPIRVBase::isBuiltinTransToExtInst(
     Function *F, SPIRVExtInstSetKind *ExtSet, SPIRVWord *ExtOp,
     SmallVectorImpl<std::string> *Dec) {
   StringRef DemangledName;
-  if (!oclIsBuiltin(F->getName(), DemangledName))
+  if (!oclIsBuiltin(F->getName(), DemangledName, isCpp(SrcLang)))
     return false;
   LLVM_DEBUG(dbgs() << "[oclIsBuiltinTransToExtInst] CallInst: demangled name: "
                     << DemangledName << '\n');
@@ -5093,7 +5093,7 @@ SPIRVValue *LLVMToSPIRVBase::transDirectCallInst(CallInst *CI,
   if (MangledName.starts_with(SPCV_CAST) || MangledName == SAMPLER_INIT)
     return oclTransSpvcCastSampler(CI, BB);
 
-  if (oclIsBuiltin(MangledName, DemangledName) ||
+  if (oclIsBuiltin(MangledName, DemangledName, isCpp(SrcLang)) ||
       isDecoratedSPIRVFunc(F, DemangledName)) {
     if (auto *BV = transBuiltinToConstant(DemangledName, CI))
       return BV;
@@ -5623,7 +5623,7 @@ bool LLVMToSPIRVBase::translate() {
   if (isEmptyLLVMModule(M))
     BM->addCapability(CapabilityLinkage);
 
-  if (!lowerBuiltinCallsToVariables(M))
+  if (!lowerBuiltinCallsToVariables(M, isCpp(SrcLang)))
     return false;
 
   // Use the type scavenger to recover pointer element types.
@@ -5685,7 +5685,7 @@ void LLVMToSPIRVBase::oclGetMutatedArgumentTypesByBuiltin(
     llvm::FunctionType *FT, std::unordered_map<unsigned, Type *> &ChangedType,
     Function *F) {
   StringRef Demangled;
-  if (!oclIsBuiltin(F->getName(), Demangled))
+  if (!oclIsBuiltin(F->getName(), Demangled, isCpp(SrcLang)))
     return;
   if (Demangled.find(kSPIRVName::SampledImage) == std::string::npos)
     return;
@@ -5695,7 +5695,7 @@ void LLVMToSPIRVBase::oclGetMutatedArgumentTypesByBuiltin(
 
 SPIRVValue *LLVMToSPIRVBase::transBuiltinToConstant(StringRef DemangledName,
                                                     CallInst *CI) {
-  Op OC = getSPIRVFuncOC(DemangledName);
+  Op OC = getSPIRVFuncOC(DemangledName, nullptr, isCpp(SrcLang));
   if (!isSpecConstantOpCode(OC))
     return nullptr;
   if (OC == spv::OpSpecConstantComposite) {
@@ -5727,7 +5727,7 @@ SPIRVInstruction *LLVMToSPIRVBase::transBuiltinToInst(StringRef DemangledName,
                                                       CallInst *CI,
                                                       SPIRVBasicBlock *BB) {
   SmallVector<std::string, 2> Dec;
-  auto OC = getSPIRVFuncOC(DemangledName, &Dec);
+  auto OC = getSPIRVFuncOC(DemangledName, &Dec, isCpp(SrcLang));
 
   if (OC == OpNop)
     return nullptr;