diff options
Diffstat (limited to 'contrib/llvm-project/llvm/lib/Transforms/Utils/CloneFunction.cpp')
-rw-r--r-- | contrib/llvm-project/llvm/lib/Transforms/Utils/CloneFunction.cpp | 66 |
1 files changed, 60 insertions, 6 deletions
diff --git a/contrib/llvm-project/llvm/lib/Transforms/Utils/CloneFunction.cpp b/contrib/llvm-project/llvm/lib/Transforms/Utils/CloneFunction.cpp index d55208602b71..c0f333364fa5 100644 --- a/contrib/llvm-project/llvm/lib/Transforms/Utils/CloneFunction.cpp +++ b/contrib/llvm-project/llvm/lib/Transforms/Utils/CloneFunction.cpp @@ -44,6 +44,7 @@ BasicBlock *llvm::CloneBasicBlock(const BasicBlock *BB, ValueToValueMapTy &VMap, ClonedCodeInfo *CodeInfo, DebugInfoFinder *DIFinder) { BasicBlock *NewBB = BasicBlock::Create(BB->getContext(), "", F); + NewBB->IsNewDbgInfoFormat = BB->IsNewDbgInfoFormat; if (BB->hasName()) NewBB->setName(BB->getName() + NameSuffix); @@ -58,7 +59,10 @@ BasicBlock *llvm::CloneBasicBlock(const BasicBlock *BB, ValueToValueMapTy &VMap, Instruction *NewInst = I.clone(); if (I.hasName()) NewInst->setName(I.getName() + NameSuffix); - NewInst->insertInto(NewBB, NewBB->end()); + + NewInst->insertBefore(*NewBB, NewBB->end()); + NewInst->cloneDebugInfoFrom(&I); + VMap[&I] = NewInst; // Add instruction map to value. if (isa<CallInst>(I) && !I.isDebugOrPseudoInst()) { @@ -90,6 +94,7 @@ void llvm::CloneFunctionInto(Function *NewFunc, const Function *OldFunc, const char *NameSuffix, ClonedCodeInfo *CodeInfo, ValueMapTypeRemapper *TypeMapper, ValueMaterializer *Materializer) { + NewFunc->setIsNewDbgInfoFormat(OldFunc->IsNewDbgInfoFormat); assert(NameSuffix && "NameSuffix cannot be null!"); #ifndef NDEBUG @@ -267,9 +272,13 @@ void llvm::CloneFunctionInto(Function *NewFunc, const Function *OldFunc, BB = cast<BasicBlock>(VMap[&OldFunc->front()])->getIterator(), BE = NewFunc->end(); BB != BE; ++BB) - // Loop over all instructions, fixing each one as we find it... - for (Instruction &II : *BB) + // Loop over all instructions, fixing each one as we find it, and any + // attached debug-info records. + for (Instruction &II : *BB) { RemapInstruction(&II, VMap, RemapFlag, TypeMapper, Materializer); + RemapDPValueRange(II.getModule(), II.getDbgValueRange(), VMap, RemapFlag, + TypeMapper, Materializer); + } // Only update !llvm.dbg.cu for DifferentModule (not CloneModule). In the // same module, the compile unit will already be listed (or not). When @@ -327,6 +336,7 @@ Function *llvm::CloneFunction(Function *F, ValueToValueMapTy &VMap, // Create the new function... Function *NewF = Function::Create(FTy, F->getLinkage(), F->getAddressSpace(), F->getName(), F->getParent()); + NewF->setIsNewDbgInfoFormat(F->IsNewDbgInfoFormat); // Loop over the arguments, copying the names of the mapped arguments over... Function::arg_iterator DestI = NewF->arg_begin(); @@ -472,6 +482,7 @@ void PruningFunctionCloner::CloneBlock( BasicBlock *NewBB; Twine NewName(BB->hasName() ? Twine(BB->getName()) + NameSuffix : ""); BBEntry = NewBB = BasicBlock::Create(BB->getContext(), NewName, NewFunc); + NewBB->IsNewDbgInfoFormat = BB->IsNewDbgInfoFormat; // 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 @@ -491,6 +502,22 @@ void PruningFunctionCloner::CloneBlock( bool hasCalls = false, hasDynamicAllocas = false, hasStaticAllocas = false; bool hasMemProfMetadata = false; + // Keep a cursor pointing at the last place we cloned debug-info records from. + BasicBlock::const_iterator DbgCursor = StartingInst; + auto CloneDbgRecordsToHere = + [NewBB, &DbgCursor](Instruction *NewInst, BasicBlock::const_iterator II) { + if (!NewBB->IsNewDbgInfoFormat) + return; + + // Clone debug-info records onto this instruction. Iterate through any + // source-instructions we've cloned and then subsequently optimised + // away, so that their debug-info doesn't go missing. + for (; DbgCursor != II; ++DbgCursor) + NewInst->cloneDebugInfoFrom(&*DbgCursor, std::nullopt, false); + NewInst->cloneDebugInfoFrom(&*II); + DbgCursor = std::next(II); + }; + // Loop over all instructions, and copy them over, DCE'ing as we go. This // loop doesn't include the terminator. for (BasicBlock::const_iterator II = StartingInst, IE = --BB->end(); II != IE; @@ -540,6 +567,8 @@ void PruningFunctionCloner::CloneBlock( hasMemProfMetadata |= II->hasMetadata(LLVMContext::MD_memprof); } + CloneDbgRecordsToHere(NewInst, II); + if (CodeInfo) { CodeInfo->OrigVMap[&*II] = NewInst; if (auto *CB = dyn_cast<CallBase>(&*II)) @@ -597,6 +626,9 @@ void PruningFunctionCloner::CloneBlock( if (OldTI->hasName()) NewInst->setName(OldTI->getName() + NameSuffix); NewInst->insertInto(NewBB, NewBB->end()); + + CloneDbgRecordsToHere(NewInst, OldTI->getIterator()); + VMap[OldTI] = NewInst; // Add instruction map to value. if (CodeInfo) { @@ -608,6 +640,13 @@ void PruningFunctionCloner::CloneBlock( // Recursively clone any reachable successor blocks. append_range(ToClone, successors(BB->getTerminator())); + } else { + // If we didn't create a new terminator, clone DPValues from the old + // terminator onto the new terminator. + Instruction *NewInst = NewBB->getTerminator(); + assert(NewInst); + + CloneDbgRecordsToHere(NewInst, OldTI->getIterator()); } if (CodeInfo) { @@ -845,12 +884,22 @@ void llvm::CloneAndPruneIntoFromInst(Function *NewFunc, const Function *OldFunc, TypeMapper, Materializer); } + // Do the same for DPValues, touching all the instructions in the cloned + // range of blocks. + Function::iterator Begin = cast<BasicBlock>(VMap[StartingBB])->getIterator(); + for (BasicBlock &BB : make_range(Begin, NewFunc->end())) { + for (Instruction &I : BB) { + RemapDPValueRange(I.getModule(), I.getDbgValueRange(), VMap, + ModuleLevelChanges ? RF_None : RF_NoModuleLevelChanges, + TypeMapper, Materializer); + } + } + // Simplify conditional branches and switches with a constant operand. We try // to prune these out when cloning, but if the simplification required // looking through PHI nodes, those are only available after forming the full // basic block. That may leave some here, and we still want to prune the dead // code as early as possible. - Function::iterator Begin = cast<BasicBlock>(VMap[StartingBB])->getIterator(); for (BasicBlock &BB : make_range(Begin, NewFunc->end())) ConstantFoldTerminator(&BB); @@ -939,10 +988,14 @@ void llvm::CloneAndPruneFunctionInto( void llvm::remapInstructionsInBlocks(ArrayRef<BasicBlock *> Blocks, ValueToValueMapTy &VMap) { // Rewrite the code to refer to itself. - for (auto *BB : Blocks) - for (auto &Inst : *BB) + for (auto *BB : Blocks) { + for (auto &Inst : *BB) { + RemapDPValueRange(Inst.getModule(), Inst.getDbgValueRange(), VMap, + RF_NoModuleLevelChanges | RF_IgnoreMissingLocals); RemapInstruction(&Inst, VMap, RF_NoModuleLevelChanges | RF_IgnoreMissingLocals); + } + } } /// Clones a loop \p OrigLoop. Returns the loop and the blocks in \p @@ -1066,6 +1119,7 @@ BasicBlock *llvm::DuplicateInstructionsInSplitBetween( Instruction *New = BI->clone(); New->setName(BI->getName()); New->insertBefore(NewTerm); + New->cloneDebugInfoFrom(&*BI); ValueMapping[&*BI] = New; // Remap operands to patch up intra-block references. |