Fix building with getCalledValue for LLVM11.

lwesiers · sys_zuul · commit 1095fd508a54 · 2020-08-28T09:38:56.000-07:00
Change-Id: I36d6ee34344e74a2ceb8a596f6d966eac4e9e962
diff --git a/IGC/AdaptorCommon/AddImplicitArgs.cpp b/IGC/AdaptorCommon/AddImplicitArgs.cpp
@@ -35,6 +35,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include <llvm/IR/Module.h>
 #include <llvmWrapper/IR/Function.h>
 #include <llvmWrapper/ADT/STLExtras.h>
+#include <llvmWrapper/IR/Instructions.h>
 #include <llvm/IR/Instructions.h>
 #include <llvm/IR/DerivedTypes.h>
 #include "llvm/IR/DIBuilder.h"
@@ -362,7 +363,7 @@ void AddImplicitArgs::replaceAllUsesWithNewOCLBuiltinFunction(CodeGenContext* ct
 
         if (IGC_IS_FLAG_ENABLED(EnableFunctionPointer))
         {
-            if (!cInst || cInst->getCalledValue() != old_func)
+            if (!cInst || IGCLLVM::getCalledValue(cInst) != old_func)
             {
                 // Support indirect function pointer usages
                 if (Instruction* userInst = dyn_cast<Instruction>(U))
diff --git a/IGC/AdaptorCommon/LegalizeFunctionSignatures.cpp b/IGC/AdaptorCommon/LegalizeFunctionSignatures.cpp
@@ -31,6 +31,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "Compiler/CodeGenPublic.h"
 #include "common/LLVMWarningsPush.hpp"
 #include "llvmWrapper/IR/DerivedTypes.h"
+#include <llvmWrapper/IR/Instructions.h>
 #include <llvm/IR/Module.h>
 #include <llvm/IR/Function.h>
 #include "llvm/IR/InstIterator.h"
@@ -410,7 +411,7 @@ void LegalizeFunctionSignatures::FixCallInstruction(CallInst* callInst)
             }
             Type* retType = returnPtr ? Type::getVoidTy(callInst->getContext()) : callInst->getType();
             FunctionType* newFnTy = FunctionType::get(retType, argTypes, false);
-            Value* calledValue = callInst->getCalledValue();
+            Value* calledValue = IGCLLVM::getCalledValue(callInst);
             newCalledValue = m_pBuilder->CreatePointerCast(calledValue, PointerType::get(newFnTy, 0));
         }
         else
diff --git a/IGC/AdaptorCommon/ProcessFuncAttributes.cpp b/IGC/AdaptorCommon/ProcessFuncAttributes.cpp
@@ -36,6 +36,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "common/LLVMWarningsPush.hpp"
 
 #include "llvmWrapper/IR/Attributes.h"
+#include "llvmWrapper/IR/Instructions.h"
 
 #include <llvm/Pass.h>
 #include <llvm/IR/Module.h>
@@ -351,7 +352,7 @@ bool ProcessFuncAttributes::runOnModule(Module& M)
             {
                 CallInst* call = dyn_cast<CallInst>(*u);
 
-                if (!call || call->getCalledValue() != F)
+                if (!call || IGCLLVM::getCalledValue(call) != F)
                 {
                     isIndirect = true;
                 }
diff --git a/IGC/Compiler/CISACodeGen/EmitVISAPass.cpp b/IGC/Compiler/CISACodeGen/EmitVISAPass.cpp
@@ -51,6 +51,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "GenISAIntrinsics/GenIntrinsicInst.h"
 #include "Compiler/IGCPassSupport.h"
 #include "common/LLVMWarningsPush.hpp"
+#include "llvmWrapper/IR/Instructions.h"
 #include "llvm/Support/Path.h"
 #include "llvmWrapper/IR/Intrinsics.h"
 #include "common/LLVMWarningsPop.hpp"
@@ -239,7 +240,7 @@ uint EmitPass::DecideInstanceAndSlice(llvm::BasicBlock& blk, SDAG& sdag, bool& s
     if (CallInst * callInst = dyn_cast<CallInst>(sdag.m_root))
     {
         // Disable slicing for function calls
-        Function* F = dyn_cast<Function>(callInst->getCalledValue());
+        Function* F = dyn_cast<Function>(IGCLLVM::getCalledValue(callInst));
         if (!F || F->hasFnAttribute("visaStackCall"))
         {
             numInstance = 1;
@@ -8204,7 +8205,7 @@ void EmitPass::EmitIntrinsicMessage(llvm::IntrinsicInst* inst)
 bool EmitPass::validateInlineAsmConstraints(llvm::CallInst* inst, SmallVector<StringRef, 8> & constraints)
 {
     IGC_ASSERT(inst->isInlineAsm());
-    InlineAsm* IA = cast<InlineAsm>(inst->getCalledValue());
+    InlineAsm* IA = cast<InlineAsm>(IGCLLVM::getCalledValue(inst));
     StringRef constraintStr(IA->getConstraintString());
     if (constraintStr.empty()) return true;
 
@@ -8277,7 +8278,7 @@ bool EmitPass::validateInlineAsmConstraints(llvm::CallInst* inst, SmallVector<St
 void EmitPass::EmitInlineAsm(llvm::CallInst* inst)
 {
     std::stringstream& str = m_encoder->GetVISABuilder()->GetAsmTextStream();
-    InlineAsm* IA = cast<InlineAsm>(inst->getCalledValue());
+    InlineAsm* IA = cast<InlineAsm>(IGCLLVM::getCalledValue(inst));
     string asmStr = IA->getAsmString();
     smallvector<CVariable*, 8> opnds;
     SmallVector<StringRef, 8> constraints;
@@ -9874,7 +9875,7 @@ void EmitPass::emitStackCall(llvm::CallInst* inst)
         }
     };
 
-    CVariable* funcAddr = GetSymbol(inst->getCalledValue());
+    CVariable* funcAddr = GetSymbol(IGCLLVM::getCalledValue(inst));
     if (!isIndirectFCall)
     {
         CopyArgBlkVariables();
diff --git a/IGC/Compiler/CISACodeGen/PatternMatchPass.cpp b/IGC/Compiler/CISACodeGen/PatternMatchPass.cpp
@@ -35,6 +35,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include <llvm/IR/Constants.h>
 #include <llvm/IR/Instruction.h>
 #include <llvm/IR/PatternMatch.h>
+#include <llvmWrapper/IR/Instructions.h>
 #include "common/LLVMWarningsPop.hpp"
 #include "GenISAIntrinsics/GenIntrinsicInst.h"
 #include "Compiler/IGCPassSupport.h"
@@ -2993,7 +2994,7 @@ namespace IGC
             // Mark the function pointer in indirect calls as a source
             if (!callinst->getCalledFunction())
             {
-                MarkAsSource(callinst->getCalledValue());
+                MarkAsSource(IGCLLVM::getCalledValue(callinst));
             }
         }
         AddPattern(pattern);
diff --git a/IGC/Compiler/Optimizer/BuiltInFuncImport.cpp b/IGC/Compiler/Optimizer/BuiltInFuncImport.cpp
@@ -31,6 +31,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "common/LLVMWarningsPush.hpp"
 #include "llvmWrapper/IR/Attributes.h"
 #include <llvmWrapper/IR/Function.h>
+#include <llvmWrapper/IR/Instructions.h>
 #include <llvm/IR/CallSite.h>
 #include <llvm/IR/Module.h>
 #include <llvm/IR/Instruction.h>
@@ -691,7 +692,7 @@ void BIImport::removeFunctionBitcasts(Module& M)
             {
                 CallInst* pInstCall = dyn_cast<CallInst>(I);
                 if (!pInstCall || pInstCall->getCalledFunction()) continue;
-                if (auto constExpr = dyn_cast<llvm::ConstantExpr>(pInstCall->getCalledValue()))
+                if (auto constExpr = dyn_cast<llvm::ConstantExpr>(IGCLLVM::getCalledValue(pInstCall)))
                 {
                     if (auto funcTobeChanged = dyn_cast<llvm::Function>(constExpr->stripPointerCasts()))
                     {
diff --git a/IGC/Compiler/Optimizer/IndirectCallOptimization.cpp b/IGC/Compiler/Optimizer/IndirectCallOptimization.cpp
@@ -29,6 +29,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "Compiler/CodeGenPublic.h"
 #include "common/IGCIRBuilder.h"
 #include "common/LLVMWarningsPush.hpp"
+#include <llvmWrapper/IR/Instructions.h>
 #include <llvm/IR/Function.h>
 #include <llvm/IR/InstIterator.h>
 #include <llvm/Transforms/Utils/BasicBlockUtils.h>
@@ -173,7 +174,7 @@ namespace IGC
         IGCIRBuilder<> IRB(pModule->getContext());
         IRB.SetInsertPoint(&CI);
 
-        Value* calledAddr = IRB.CreatePtrToInt(CI.getCalledValue(), IRB.getInt64Ty());
+        Value* calledAddr = IRB.CreatePtrToInt(IGCLLVM::getCalledValue(CI), IRB.getInt64Ty());
 
         BasicBlock* beginBlock = CI.getParent();
         BasicBlock* endBlock = beginBlock->splitBasicBlock(&CI, "endIndirectCallBB");
diff --git a/IGC/ElfPackager/main.cpp b/IGC/ElfPackager/main.cpp
@@ -48,6 +48,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/CommandLine.h"
 
+#include "llvmWrapper/IR/Instructions.h"
 #include "llvmWrapper/IR/Module.h"
 #include "llvmWrapper/ADT/STLExtras.h"
 
@@ -161,7 +162,7 @@ std::unique_ptr<IGCLLVM::Module> LocalCloneModule(
                 auto inst = &*UI_BB;
                 if (auto CI = dyn_cast<CallInst>(inst))
                 {
-                    auto val = CI->getCalledValue();
+                    auto val = IGCLLVM::getCalledValue(CI);
                     auto *I2 = dyn_cast<llvm::Function>(val->stripPointerCasts());
 
                     Function *NF2 = cast<Function>(New.get()->getOrInsertFunction(
diff --git a/IGC/VectorCompiler/lib/GenXCodeGen/GenXCategory.cpp b/IGC/VectorCompiler/lib/GenXCodeGen/GenXCategory.cpp
@@ -144,6 +144,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "GenXTargetMachine.h"
 #include "GenXUtil.h"
 #include "llvmWrapper/IR/InstrTypes.h"
+#include "llvmWrapper/IR/Instructions.h"
 #include "vc/GenXOpts/Utils/KernelInfo.h"
 #include "vc/GenXOpts/Utils/RegCategory.h"
 #include "llvm/ADT/PostOrderIterator.h"
@@ -878,7 +879,7 @@ unsigned GenXCategory::getCategoryForInlasmConstraintedOp(CallInst *CI,
                                                           unsigned ArgNo,
                                                           bool IsOutput) const {
   IGC_ASSERT(CI->isInlineAsm() && "Inline asm expected");
-  InlineAsm *IA = dyn_cast<InlineAsm>(CI->getCalledValue());
+  InlineAsm *IA = dyn_cast<InlineAsm>(IGCLLVM::getCalledValue(CI));
   IGC_ASSERT(!IA->getConstraintString().empty() && "Here should be constraints");
 
   auto ConstraintsInfo = genx::getGenXInlineAsmInfo(CI);
diff --git a/IGC/VectorCompiler/lib/GenXCodeGen/GenXCisaBuilder.cpp b/IGC/VectorCompiler/lib/GenXCodeGen/GenXCisaBuilder.cpp
@@ -77,6 +77,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/StringSaver.h"
 
+#include "llvmWrapper/IR/Instructions.h"
 #include "llvmWrapper/IR/InstrTypes.h"
 
 #include <map>
@@ -4556,7 +4557,7 @@ unsigned GenXKernelBuilder::getOrCreateLabel(Value *V, int Kind) {
 
 void GenXKernelBuilder::buildInlineAsm(CallInst *CI) {
   IGC_ASSERT(CI->isInlineAsm() && "Inline asm expected");
-  InlineAsm *IA = dyn_cast<InlineAsm>(CI->getCalledValue());
+  InlineAsm *IA = dyn_cast<InlineAsm>(IGCLLVM::getCalledValue(CI));
   std::string AsmStr(IA->getAsmString());
   std::stringstream &AsmTextStream = CisaBuilder->GetAsmTextStream();
 
@@ -5555,7 +5556,7 @@ void GenXKernelBuilder::buildStackCall(IGCLLVM::CallInst *CI,
         Pred, (NoMask ? vISA_EMASK_M1_NM : vISA_EMASK_M1), EXEC_SIZE_16,
         Callee->getName(), NoStackSize, RetSize));
   } else {
-    auto *FuncAddr = createSource(CI->getCalledValue(), DONTCARESIGNED);
+    auto *FuncAddr = createSource(IGCLLVM::getCalledValue(CI), DONTCARESIGNED);
     IGC_ASSERT(FuncAddr);
     CISA_CALL(Kernel->AppendVISACFIndirectFuncCallInst(
         Pred, (NoMask ? vISA_EMASK_M1_NM : vISA_EMASK_M1), EXEC_SIZE_16,
diff --git a/IGC/VectorCompiler/lib/GenXCodeGen/GenXCoalescing.cpp b/IGC/VectorCompiler/lib/GenXCodeGen/GenXCoalescing.cpp
@@ -191,6 +191,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "GenXSubtarget.h"
 #include "GenXTargetMachine.h"
 #include "GenXUtil.h"
+#include "llvmWrapper/IR/Instructions.h"
 #include "llvmWrapper/IR/InstrTypes.h"
 #include "vc/GenXOpts/Utils/KernelInfo.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
@@ -495,7 +496,7 @@ void GenXCoalescing::recordCandidates(FunctionGroup *FG)
         } else if (IGCLLVM::CallInst *CI = dyn_cast<IGCLLVM::CallInst>(Inst)) {
           if (!GenXIntrinsic::isAnyNonTrivialIntrinsic(CI)) {
             if (CI->isInlineAsm()) {
-              InlineAsm *IA = cast<InlineAsm>(CI->getCalledValue());
+              InlineAsm *IA = cast<InlineAsm>(IGCLLVM::getCalledValue(CI));
               // Do not process if no constraints provided or it's baled
               // (the coalescing actually needs to be done at the wrregion).
               if (IA->getConstraintString().empty() || Baling->isBaled(CI))
diff --git a/IGC/VectorCompiler/lib/GenXCodeGen/GenXImportBiF.cpp b/IGC/VectorCompiler/lib/GenXCodeGen/GenXImportBiF.cpp
@@ -52,6 +52,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include <llvm/Support/Error.h>
 #include <llvm/Transforms/Utils/Cloning.h>
 #include <llvm/Transforms/Utils/ValueMapper.h>
+#include <llvmWrapper/IR/Instructions.h>
 
 #include <algorithm>
 #include <sstream>
@@ -386,7 +387,7 @@ static void removeFunctionBitcasts(llvm::Module &M) {
         if (!pInstCall || pInstCall->getCalledFunction())
           continue;
         if (auto constExpr =
-                dyn_cast<llvm::ConstantExpr>(pInstCall->getCalledValue())) {
+                dyn_cast<llvm::ConstantExpr>(IGCLLVM::getCalledValue(pInstCall))) {
           if (auto funcTobeChanged =
                   dyn_cast<llvm::Function>(constExpr->stripPointerCasts())) {
             if (funcTobeChanged->isDeclaration())
diff --git a/IGC/VectorCompiler/lib/GenXCodeGen/GenXInlineAsmLowering.cpp b/IGC/VectorCompiler/lib/GenXCodeGen/GenXInlineAsmLowering.cpp
@@ -59,6 +59,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
+#include "llvmWrapper/IR/Instructions.h"
 #include "Probe/Assertion.h"
 
 using namespace llvm;
@@ -134,7 +135,7 @@ bool GenXInlineAsmLowering::runOnFunction(Function &F) {
         auto *CI = dyn_cast<CallInst>(&I);
         // No need to process inline asm with empty constraint string
         return CI && CI->isInlineAsm() &&
-               !cast<InlineAsm>(CI->getCalledValue())
+               !cast<InlineAsm>(IGCLLVM::getCalledValue(CI))
                     ->getConstraintString()
                     .empty();
       });
@@ -148,7 +149,7 @@ bool GenXInlineAsmLowering::runOnFunction(Function &F) {
 
   Context = &InlineAsms[0]->getContext();
   for (auto *CI : InlineAsms) {
-    auto *IA = cast<InlineAsm>(CI->getCalledValue());
+    auto *IA = cast<InlineAsm>(IGCLLVM::getCalledValue(CI));
     InlineAsm::ConstraintInfoVector ConstraintsInfo = IA->ParseConstraints();
     MDNode *ConstraintsMD = createInlineAsmMetadata(CI, ConstraintsInfo);
     GenXConstraintInfoVector GenXConstraintsInfo =
@@ -331,7 +332,7 @@ CallInst *GenXInlineAsmLowering::recreateInlineAsmWithCR(
                  });
 
   // Create exactly the same inline assembly but with new function type
-  auto *IA = cast<InlineAsm>(CI->getCalledValue());
+  auto *IA = cast<InlineAsm>(IGCLLVM::getCalledValue(CI));
   InlineAsm *NewIA = InlineAsm::get(
       NewFTy, IA->getAsmString(), IA->getConstraintString(),
       IA->hasSideEffects(), IA->isAlignStack(), IA->getDialect());
diff --git a/IGC/VectorCompiler/lib/GenXCodeGen/GenXUtil.cpp b/IGC/VectorCompiler/lib/GenXCodeGen/GenXUtil.cpp
@@ -45,6 +45,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
+#include "llvmWrapper/IR/Instructions.h"
 
 #include <iterator>
 #include "Probe/Assertion.h"
@@ -1481,7 +1482,7 @@ std::vector<GenXInlineAsmInfo> genx::getGenXInlineAsmInfo(CallInst *CI) {
   MDNode *MD = CI->getMetadata(genx::MD_genx_inline_asm_info);
   // empty constraint info
   if (!MD) {
-    auto *IA = cast<InlineAsm>(CI->getCalledValue());
+    auto *IA = cast<InlineAsm>(IGCLLVM::getCalledValue(CI));
     IGC_ASSERT(IA->getConstraintString().empty() &&
            "No info only for empty constraint string");
     (void)IA;
diff --git a/IGC/WrapperLLVM/include/llvmWrapper/IR/Instructions.h b/IGC/WrapperLLVM/include/llvmWrapper/IR/Instructions.h
@@ -74,6 +74,33 @@ namespace IGCLLVM
         return I->getAlignment();
 #elif LLVM_VERSION_MAJOR >= 7
         return I->getDestAlignment();
+#endif
+    }
+
+    inline llvm::Value* getCalledValue(llvm::CallInst& CI)
+    {
+#if LLVM_VERSION_MAJOR <= 10
+        return CI.getCalledValue();
+#else
+        return CI.getCalledOperand();
+#endif
+    }
+	
+	inline llvm::Value* getCalledValue(llvm::CallInst* CI)
+	{ 
+#if LLVM_VERSION_MAJOR <= 10
+		return CI->getCalledValue();
+#else
+		return CI->getCalledOperand();
+#endif
+	}
+
+    inline const llvm::Value* getCalledValue(const llvm::CallInst* CI)
+    {
+#if LLVM_VERSION_MAJOR <= 10
+        return CI->getCalledValue();
+#else
+        return CI->getCalledOperand();
 #endif
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -36,6 +36,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.`
`36`	`36`	`#include "common/LLVMWarningsPush.hpp"`
`37`	`37`
`38`	`38`	`#include "llvmWrapper/IR/Attributes.h"`
	`39`	`+#include "llvmWrapper/IR/Instructions.h"`
`39`	`40`
`40`	`41`	`#include <llvm/Pass.h>`
`41`	`42`	`#include <llvm/IR/Module.h>`
`@@ -351,7 +352,7 @@ bool ProcessFuncAttributes::runOnModule(Module& M)`
`351`	`352`	`{`
`352`	`353`	`CallInst* call = dyn_cast<CallInst>(*u);`
`353`	`354`
`354`		`- if (!call \|\| call->getCalledValue() != F)`
	`355`	`+ if (!call \|\| IGCLLVM::getCalledValue(call) != F)`
`355`	`356`	`{`
`356`	`357`	`isIndirect = true;`
`357`	`358`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,6 +35,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.`
`35`	`35`	`#include <llvm/IR/Constants.h>`
`36`	`36`	`#include <llvm/IR/Instruction.h>`
`37`	`37`	`#include <llvm/IR/PatternMatch.h>`
	`38`	`+#include <llvmWrapper/IR/Instructions.h>`
`38`	`39`	`#include "common/LLVMWarningsPop.hpp"`
`39`	`40`	`#include "GenISAIntrinsics/GenIntrinsicInst.h"`
`40`	`41`	`#include "Compiler/IGCPassSupport.h"`
`@@ -2993,7 +2994,7 @@ namespace IGC`
`2993`	`2994`	`// Mark the function pointer in indirect calls as a source`
`2994`	`2995`	`if (!callinst->getCalledFunction())`
`2995`	`2996`	`{`
`2996`		`- MarkAsSource(callinst->getCalledValue());`
	`2997`	`+ MarkAsSource(IGCLLVM::getCalledValue(callinst));`
`2997`	`2998`	`}`
`2998`	`2999`	`}`
`2999`	`3000`	`AddPattern(pattern);`
Original file line number	Diff line number	Diff line change
`@@ -31,6 +31,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.`
`31`	`31`	`#include "common/LLVMWarningsPush.hpp"`
`32`	`32`	`#include "llvmWrapper/IR/Attributes.h"`
`33`	`33`	`#include <llvmWrapper/IR/Function.h>`
	`34`	`+#include <llvmWrapper/IR/Instructions.h>`
`34`	`35`	`#include <llvm/IR/CallSite.h>`
`35`	`36`	`#include <llvm/IR/Module.h>`
`36`	`37`	`#include <llvm/IR/Instruction.h>`
`@@ -691,7 +692,7 @@ void BIImport::removeFunctionBitcasts(Module& M)`
`691`	`692`	`{`
`692`	`693`	`CallInst* pInstCall = dyn_cast<CallInst>(I);`
`693`	`694`	`if (!pInstCall \|\| pInstCall->getCalledFunction()) continue;`
`694`		`- if (auto constExpr = dyn_cast<llvm::ConstantExpr>(pInstCall->getCalledValue()))`
	`695`	`+ if (auto constExpr = dyn_cast<llvm::ConstantExpr>(IGCLLVM::getCalledValue(pInstCall)))`
`695`	`696`	`{`
`696`	`697`	`if (auto funcTobeChanged = dyn_cast<llvm::Function>(constExpr->stripPointerCasts()))`
`697`	`698`	`{`