@@ -536,29 +536,10 @@ void PruningFunctionCloner::CloneBlock(
536536 // Eagerly remap operands to the newly cloned instruction, except for PHI
537537 // nodes for which we defer processing until we update the CFG. Also defer
538538 // debug intrinsic processing because they may contain use-before-defs.
539- if (!isa<PHINode>(NewInst) && !isa<DbgVariableIntrinsic>(NewInst))
{ 539+ if (!isa<PHINode>(NewInst) && !isa<DbgVariableIntrinsic>(NewInst))
540540 RemapInstruction (NewInst, VMap,
541541 ModuleLevelChanges ? RF_None : RF_NoModuleLevelChanges);
542542
543- // If we can simplify this instruction to some other value, simply add
544- // a mapping to that value rather than inserting a new instruction into
545- // the basic block.
546- if (Value *V =
547- simplifyInstruction (NewInst, BB->getModule ()->getDataLayout ())) {
548- // On the off-chance that this simplifies to an instruction in the old
549- // function, map it back into the new function.
550- if (NewFunc != OldFunc)
551- if (Value *MappedV = VMap.lookup (V))
552- V = MappedV;
553-
554- if (!NewInst->mayHaveSideEffects ()) {
555- VMap[&*II] = V;
556- NewInst->eraseFromParent ();
557- continue ;
558- }
559- }
560- }
561-
562543 if (II->hasName ())
563544 NewInst->setName (II->getName () + NameSuffix);
564545 VMap[&*II] = NewInst; // Add instruction map to value.
@@ -823,52 +804,45 @@ void llvm::CloneAndPruneIntoFromInst(Function *NewFunc, const Function *OldFunc,
823804 }
824805 }
825806
826- // Make a second pass over the PHINodes now that all of them have been
827- // remapped into the new function, simplifying the PHINode and performing any
828- // recursive simplifications exposed. This will transparently update the
829- // WeakTrackingVH in the VMap. Notably, we rely on that so that if we coalesce
830- // two PHINodes, the iteration over the old PHIs remains valid, and the
831- // mapping will just map us to the new node (which may not even be a PHI
832- // node).
833- const DataLayout &DL = NewFunc->getParent ()->getDataLayout ();
834- SmallSetVector<const Value *, 8 > Worklist;
835- for (unsigned Idx = 0 , Size = PHIToResolve.size (); Idx != Size; ++Idx)
836- if (isa<PHINode>(VMap[PHIToResolve[Idx]]))
837- Worklist.insert (PHIToResolve[Idx]);
838-
839- // Note that we must test the size on each iteration, the worklist can grow.
840- for (unsigned Idx = 0 ; Idx != Worklist.size (); ++Idx) {
841- const Value *OrigV = Worklist[Idx];
842- auto *I = dyn_cast_or_null<Instruction>(VMap.lookup (OrigV));
843- if (!I)
844- continue ;
845-
846- // Skip over non-intrinsic callsites, we don't want to remove any nodes from
847- // the CGSCC.
848- CallBase *CB = dyn_cast<CallBase>(I);
849- if (CB && CB->getCalledFunction () &&
850- !CB->getCalledFunction ()->isIntrinsic ())
851- continue ;
852-
853- // See if this instruction simplifies.
854- Value *SimpleV = simplifyInstruction (I, DL);
855- if (!SimpleV)
856- continue ;
857-
858- // Stash away all the uses of the old instruction so we can check them for
859- // recursive simplifications after a RAUW. This is cheaper than checking all
860- // uses of To on the recursive step in most cases.
861- for (const User *U : OrigV->users ())
862- Worklist.insert (cast<Instruction>(U));
863-
864- // Replace the instruction with its simplified value.
865- I->replaceAllUsesWith (SimpleV);
807+ auto GetOriginalValueInVMap = [&](const auto &I) -> Value * {
808+ for (const auto &[OrigI, NewI] : VMap) {
809+ if (NewI == I)
810+ return const_cast <Value *>(OrigI);
811+ }
812+ return nullptr ;
813+ };
866814
867- // If the original instruction had no side effects, remove it.
868- if (isInstructionTriviallyDead (I))
869- I->eraseFromParent ();
870- else
871- VMap[OrigV] = I;
815+ // As phi-nodes have been now remapped, allow incremental simplification of
816+ // newly-cloned instructions.
817+ const DataLayout &DL = NewFunc->getParent ()->getDataLayout ();
818+ auto *NewEntryBlock = cast<BasicBlock>(VMap[StartingBB]);
819+ ReversePostOrderTraversal<BasicBlock *> RPOT (NewEntryBlock);
820+ for (auto &BB : RPOT) {
821+ for (BasicBlock::iterator II = BB->begin (), IE = BB->end (); II != IE;) {
822+ auto *NewI = &*II++;
823+ if (isa<DbgInfoIntrinsic>(NewI))
824+ continue ;
825+
826+ CallBase *CB = dyn_cast<CallBase>(NewI);
827+ if (CB && CB->getCalledFunction () &&
828+ !CB->getCalledFunction ()->isIntrinsic ())
829+ continue ;
830+
831+ if (Value *V = simplifyInstruction (NewI, DL)) {
832+ if (!NewI->use_empty ())
833+ NewI->replaceAllUsesWith (V);
834+
835+ if (isInstructionTriviallyDead (NewI)) {
836+ NewI->eraseFromParent ();
837+ } else {
838+ // Did not erase it? Restore the new instruction into VMap.
839+ auto *OriginalI = GetOriginalValueInVMap (NewI);
840+ assert (OriginalI != nullptr &&
841+ " Previously remapped value was not found?"
842+ VMap[OriginalI] = NewI;
843+ }
844+ }
845+ }
872846 }
873847
874848 // Remap debug intrinsic operands now that all values have been mapped.
0 commit comments