[Porting MergeSimilarFunctions 2/n] Changes to DataLayout

[hiraditya]

Summary

Depends on https://reviews.llvm.org/D52896

Maybe I can merge both the patches together?

[hiraditya]

rebase

[vish99]

Changes to sync D52898 with D52966

[vish99]

Reverting back to diff 222348, the previous diff was against a wrong branch

[vish99]

Changes to merge the 5 patches together

llvm/lib/Transforms/IPO/MergeSimilarFunctions.cpp

 /// Create a cast instruction if needed to cast V to type DstType. We treat
 /// pointer and integer types of the same bitwidth as equivalent, so this can be
 /// used to cast them to each other where needed. The function returns the Value
 /// itself if no cast is needed, or a new CastInst instance inserted before
 /// InsertBefore. The integer type equivalent to pointers must be passed as
 /// IntPtrType (get it from DataLayout). This is guaranteed to generate no-op
 /// casts, otherwise it will assert.
 static Value *createCastIfNeeded(Value *V, Type *DstType,
-                                 Value *InstrOrBB, Type *IntPtrType) {
+                                 Value *InstrOrBB, Type *IntPtrType, const DataLayout *DL) {
   if (V->getType() == DstType)
     return V;
 
   BasicBlock *InsertAtEnd = dyn_cast<BasicBlock>(InstrOrBB);
   Instruction *InsertBefore = dyn_cast<Instruction>(InstrOrBB);
   BasicBlock *InsertBB = InsertAtEnd ? InsertAtEnd : InsertBefore->getParent();
 
   CastInst *Result;
   Type *OrigType = V->getType();
 
   if (OrigType->isStructTy()) {
     assert(DstType->isStructTy());
     assert(OrigType->getStructNumElements() == DstType->getStructNumElements());
 
     IRBuilder<> Builder(InsertBB);
     if (InsertBefore)
       Builder.SetInsertPoint(InsertBefore);
     Value *Result = UndefValue::get(DstType);
     for (unsigned int I = 0, E = OrigType->getStructNumElements(); I < E; ++I) {
       Value *ExtractedValue
         = Builder.CreateExtractValue(V, ArrayRef<unsigned int>(I));
       Value *Element = createCastIfNeeded(ExtractedValue,
                                           DstType->getStructElementType(I),
-                                          InstrOrBB, IntPtrType);
+                                          InstrOrBB, IntPtrType, DL);
       Result =
           Builder.CreateInsertValue(Result, Element, ArrayRef<unsigned int>(I));
     }
     return Result;
   }
   assert(!DstType->isStructTy());
 
   if (OrigType->isPointerTy()
if (OrigType->isPointerTy()
     } else {
       Result = CastInst::Create(CastInst::IntToPtr, V, DstType, "",
                                 InsertAtEnd);
     }
   } else {
     llvm_unreachable("Can only cast int -> ptr or ptr -> (ptr or int)");
   }
 
-  assert(cast<CastInst>(Result)->isNoopCast(IntPtrType) &&
+  assert(cast<CastInst>(Result)->isNoopCast(*DL) &&
       "Cast is not a no-op cast. Potential loss of precision");
 
   return Result;
 }
 
 namespace {
 
 /// ComparableFunction - A struct that pairs together functions with a
static void writeThunkBody(Function *Thunk, Function *F,
   BasicBlock *BB = &Thunk->getEntryBlock();
   IRBuilder<> Builder(BB);
 
   SmallVector<Value *, 16> Args;
   unsigned i = 0;
   FunctionType *FFTy = F->getFunctionType();
   Type *IntPtrTy = DL->getIntPtrType(FFTy->getContext());
   for (auto &AI : Thunk->args()) {
-    Value *Cast = createCastIfNeeded(&AI, FFTy->getParamType(i), BB, IntPtrTy);
+    Value *Cast = createCastIfNeeded(&AI, FFTy->getParamType(i), BB, IntPtrTy, DL);
     Args.push_back(Cast);
     ++i;
   }
   if (Choice)
     Args.push_back(Choice);
 
   CallInst *CI = Builder.CreateCall(F, Args);
   CI->setTailCall();
   CI->setCallingConv(F->getCallingConv());
   CI->setAttributes(F->getAttributes());
   CI->setIsNoInline();
   if (Thunk->getReturnType()->isVoidTy()) {
     Builder.CreateRetVoid();
   } else {
     Type *RetTy = Thunk->getReturnType();
     if (CI->getType()->isIntegerTy() && RetTy->isPointerTy())
       Builder.CreateRet(Builder.CreateIntToPtr(CI, RetTy));
     else if (CI->getType()->isPointerTy() && RetTy->isIntegerTy())
       Builder.CreateRet(Builder.CreatePtrToInt(CI, RetTy));
     else {
-      Value *Cast = createCastIfNeeded(CI, RetTy, BB, IntPtrTy);
+      Value *Cast = createCastIfNeeded(CI, RetTy, BB, IntPtrTy, DL);
       Builder.CreateRet(Cast);
     }
   }
 }
 
 // Replace G with a simple tail call to bitcast(F). Also replace direct uses
 // of G with bitcast(F). Deletes G.
 void MergeSimilarFunctions::writeThunk(Function *F, Function *G) {
static Value *getLastArg(Function *F) {
   std::advance(it, F->arg_size()-1);
   return it;
 }
 
 static void insertCondAndRemapInstructions(
     Instruction *F1InstInNewF, const std::vector<const Instruction *> &F2Insts,
     Function *NewF, ValueToValueMapTy &F1toNewF,
     const SmallVectorImpl<FunctionComparator *> &Comps,
-    Type *IntPtrTy) {
+    Type *IntPtrTy, const DataLayout *DL) {
   assert(F2Insts.size() == Comps.size() &&
       "Mis-match between F2Insts & Comps!");
 
   SmallVector<Instruction *, 8> F2InstsInNewF;
   for (unsigned FnI = 0, FnE = F2Insts.size(); FnI != FnE; ++FnI) {
     const Instruction *F2Inst = F2Insts[FnI];
     if (!F2Inst) {
       F2InstsInNewF.push_back(NULL);
for (unsigned FnI = 0, FnE = F2InstsInNewF.size(); FnI != FnE; ++FnI) {
     for (unsigned OpId=0; OpId < F2InstInNewF->getNumOperands(); ++OpId) {
       Value *F2NewFOperand = F2InstInNewF->getOperand(OpId);
       Value *F2OrigOperand = F2Inst->getOperand(OpId);
 
       if (F2NewFOperand->getType() != F2OrigOperand->getType()) {
         Value *Cast = createCastIfNeeded(F2NewFOperand,
             F2OrigOperand->getType(),
             F2InstInNewF,
-            IntPtrTy);
+            IntPtrTy, DL);
         F2InstInNewF->setOperand(OpId, Cast);
       }
     }
   }
 
   if (ReturnInst *F1Ret = dyn_cast<ReturnInst>(F1InstInNewF)) {
     // If we're handling differing return instructions, we need to ensure that
     // they all return the same type. Since we treat pointer types as equal, we
     // may need to insert a bitcast.
     for (Instruction *F2Inst : F2InstsInNewF) {
       if (!F2Inst)
         continue;
 
       // F2Inst must also be a return instruction due to control flow
       // isomorphism.
       ReturnInst *F2Ret = cast<ReturnInst>(F2Inst);
 
       if (F2Ret->getReturnValue()->getType() !=
           F1Ret->getReturnValue()->getType())
         F2Ret->setOperand(0,
                           createCastIfNeeded(F2Ret->getReturnValue(),
                                              F1Ret->getReturnValue()->getType(),
-                                             F2Ret, IntPtrTy));
+                                             F2Ret, IntPtrTy, DL));
     }
   } else if (!F1InstInNewF->use_empty()) {
     // If the instructions have uses, we need to insert a PHI node.
     //
     // We treat all pointer types as equal, so we may need to insert
     // a bitcast to ensure that all incoming values of the PHI node have the
     // same type
     Type *F1IType = F1InstInNewF->getType();
for (unsigned FnI = 0, FnE = F2InstsInNewF.size(); FnI != FnE; ++FnI) {
       if (F2InstInNewF->getType() != F1IType) {
         assert(!F2InstInNewF->isTerminator() &&
             "Cannot cast result of terminator instruction");
 
         F2InstInNewF = cast<Instruction>(
             createCastIfNeeded(F2InstInNewF,
               F1IType,
               Terminators[FnI+1],
-              IntPtrTy));
+              IntPtrTy, DL));
       }
 
       Phi->addIncoming(F2InstInNewF, F2InstInNewF->getParent());
     }
   }
 }
 
 static void mergePHINode(const SmallVectorImpl<FunctionComparator *> &Fns,
for (unsigned FnI = 0, FnE = F2PhiInsts.size(); FnI != FnE; ++FnI) {
         assert(V && F2InValNewF && "Cannot map F2InVal to NewF");
       }
 
       // Cast F2InValNewF to the correct type if needed
       LLVMContext &Ctx = F1InValNewF->getType()->getContext();
       const DataLayout *FTD = Fns[FnI]->getDataLayout();
       Type *IntPtrTy = FTD ? FTD->getIntPtrType(Ctx) : NULL;
       F2InValNewF = createCastIfNeeded(F2InValNewF, F1InValNewF->getType(),
-                                       InsertPt, IntPtrTy);
+                                       InsertPt, IntPtrTy, FTD);
 
       // Create compare & select
       Value *ChoiceArg = getLastArg(NewF);
       Value *SelectBit = new ICmpInst(InsertPt,
                                       ICmpInst::ICMP_EQ,
                                       getLastArg(NewF),
                                       ConstantInt::get(ChoiceArg->getType(),
                                                        FnI+1));
for (CombinedDiffMap::const_iterator I = AllDifferingInstructions.begin(),
     assert(VMap.find(F1Inst) != VMap.end() &&
       "Cannot find differing inst!");
     Instruction *F1InstInNewF = cast<Instruction>(VMap[F1Inst]);
 
     if (isa<PHINode>(F1InstInNewF))
       continue; // we already handled these above
 
     insertCondAndRemapInstructions(F1InstInNewF, F2Insts,
-      NewF, VMap, Fns, IntPtrType);
+      NewF, VMap, Fns, IntPtrType, DL);
   }
 
   // Replace functions with thunks
   PrintMerges("FNSM", F1, NewF);
   writeThunkWithChoice(NewF, F1, 0);
   for (unsigned FnI = 0, FnE = Fns.size(); FnI != FnE; ++FnI) {
     Function *F2 = Fns[FnI]->getF2();
     PrintMerges("FNSM", F2, NewF);

llvm/lib/Transforms/Utils/CloneFunction.cpp

#endif
   // appropriate.  Note that we save BE this way in order to handle cloning of
   // recursive functions into themselves.
   //
   for (Function::const_iterator BI = OldFunc->begin(), BE = OldFunc->end();
        BI != BE; ++BI) {
     const BasicBlock &BB = *BI;
 
     // Create a new basic block and copy instructions into it!
     BasicBlock *CBB = CloneBasicBlock(&BB, VMap, NameSuffix, NewFunc, CodeInfo,
-                                      ModuleLevelChanges ? &DIFinder : nullptr);
+                                      CT == CloneType::ModuleLevelChanges ? &DIFinder : nullptr);
 
     // Add basic block mapping.
     VMap[&BB] = CBB;
 
     // It is only legal to clone a function if a block address within that
     // function is never referenced outside of the function.  Given that, we
     // want to map block addresses from the old function to block addresses in
     // the clone. (This is different from the generic ValueMapper