Index: llvm/lib/CodeGen/MachineCopyPropagation.cpp
===================================================================
--- llvm/lib/CodeGen/MachineCopyPropagation.cpp
+++ llvm/lib/CodeGen/MachineCopyPropagation.cpp
@@ -68,6 +68,7 @@
 
 STATISTIC(NumDeletes, "Number of dead copies deleted");
 STATISTIC(NumCopyForwards, "Number of copy uses forwarded");
+STATISTIC(NumCopyBackwardPropagated, "Number of copy defs backward propagated");
 DEBUG_COUNTER(FwdCounter, "machine-cp-fwd",
               "Controls which register COPYs are forwarded");
 
@@ -211,11 +212,13 @@
   void ReadRegister(unsigned Reg, MachineInstr &Reader,
                     DebugType DT);
   void CopyPropagateBlock(MachineBasicBlock &MBB);
+  bool eraseIfRedundant(MachineInstr &Copy);
   bool eraseIfRedundant(MachineInstr &Copy, unsigned Src, unsigned Def);
   void forwardUses(MachineInstr &MI);
   bool isForwardableRegClassCopy(const MachineInstr &Copy,
                                  const MachineInstr &UseI, unsigned UseIdx);
   bool hasImplicitOverlap(const MachineInstr &MI, const MachineOperand &Use);
+  bool isSafeBackwardCopyPropagation(MachineInstr &Copy, MachineInstr &SrcMI);
 
   /// Candidates for deletion.
   SmallSetVector<MachineInstr *, 8> MaybeDeadCopies;
@@ -274,6 +277,61 @@
   return SubIdx == TRI->getSubRegIndex(PreviousDef, Def);
 }
 
+bool MachineCopyPropagation::isSafeBackwardCopyPropagation(
+    MachineInstr &Copy, MachineInstr &SrcMI) {
+  MachineOperand &SrcOp = SrcMI.getOperand(0);
+  if (!(SrcOp.isReg() && SrcOp.isDef() &&
+        SrcOp.getReg() == Copy.getOperand(1).getReg() && SrcOp.isRenamable() &&
+        !SrcOp.isTied() && !SrcOp.isImplicit() &&
+        !MRI->isReserved(SrcOp.getReg())))
+    return false;
+  if (const TargetRegisterClass *URC = SrcMI.getRegClassConstraint(0, TII, TRI))
+    return URC->contains(Copy.getOperand(0).getReg());
+  return false;
+}
+
+/// In a terminal BB, remove instruction \p Copy if \p Copy's src and dst are
+/// not used or defined between \p Copy and definition point of \p Copy's src.
+/// \p Copy's dst will be backward propagated to where \p Copy's src is defined.
+bool MachineCopyPropagation::eraseIfRedundant(MachineInstr &Copy) {
+  // Only take terminal BBs into account.
+  if (!Copy.getParent()->succ_empty())
+    return false;
+  if (!Copy.getOperand(1).isRenamable() || !Copy.getOperand(1).isKill())
+    return false;
+  unsigned Def = Copy.getOperand(0).getReg();
+  unsigned Src = Copy.getOperand(1).getReg();
+  if (MRI->isReserved(Src) || MRI->isReserved(Def))
+    return false;
+  MachineBasicBlock::reverse_iterator E = Copy.getParent()->rend(), It = Copy;
+  It++;
+  MachineInstr *SrcMI = nullptr;
+  for (; It != E; ++It) {
+    if (It->readsRegister(Src, TRI) || It->readsRegister(Def, TRI))
+      return false;
+    if (It->modifiesRegister(Def, TRI))
+      return false;
+    if (It->modifiesRegister(Src, TRI)) {
+      SrcMI = &*It;
+      break;
+    }
+  }
+  if (!SrcMI)
+    return false;
+  if (!isSafeBackwardCopyPropagation(Copy, *SrcMI))
+    return false;
+  SrcMI->getOperand(0).setReg(Def);
+  SrcMI->getOperand(0).setIsRenamable(Copy.getOperand(0).isRenamable());
+  // FIXME: Since SrcMI no longer clobbers Src reg, Tracker still considers Src
+  // reg is clobbered. Therefore we might miss opportunities to delete more
+  // copies.
+  Tracker.clobberRegister(Def, *TRI);
+  Copy.eraseFromParent();
+  ++NumCopyBackwardPropagated;
+  ++NumDeletes;
+  return true;
+}
+
 /// Remove instruction \p Copy if there exists a previous copy that copies the
 /// register \p Src to the register \p Def; This may happen indirectly by
 /// copying the super registers.
@@ -475,6 +533,17 @@
              !Register::isVirtualRegister(Src) &&
              "MachineCopyPropagation should be run after register allocation!");
 
+      // In a terminal BB,
+      //  $reg0 = OP ...
+      //  ... <<< No uses of $reg0 and $reg1, no defs of $reg0 and $reg1
+      //  $reg1 = COPY $reg0 <<< $reg0 is killed
+      // =>
+      //  $reg1 = OP ...
+      //  ...
+      //  <RET>
+      if (eraseIfRedundant(*MI))
+        continue;
+
       // The two copies cancel out and the source of the first copy
       // hasn't been overridden, eliminate the second one. e.g.
       //  %ecx = COPY %eax
Index: llvm/test/CodeGen/PowerPC/machine-backward-cp.mir
===================================================================
--- llvm/test/CodeGen/PowerPC/machine-backward-cp.mir
+++ llvm/test/CodeGen/PowerPC/machine-backward-cp.mir
@@ -10,8 +10,7 @@
 body: |
   bb.0.entry:
     ; CHECK-LABEL: name: test0
-    ; CHECK: renamable $x4 = LI8 1024
-    ; CHECK: $x3 = COPY killed renamable $x4
+    ; CHECK: $x3 = LI8 1024
     ; CHECK: BLR8 implicit $lr8, implicit undef $rm, implicit $x3
     renamable $x4 = LI8 1024
     $x3 = COPY renamable killed $x4
@@ -138,8 +137,7 @@
 
     ; CHECK-LABEL: name: iterative_deletion
     ; CHECK: liveins: $x5
-    ; CHECK: renamable $x6 = ADDI8 killed renamable $x5, 1
-    ; CHECK: $x3 = COPY $x6
+    ; CHECK: $x3 = ADDI8 killed renamable $x5, 1
     ; CHECK: BLR8 implicit $lr8, implicit undef $rm, implicit $x3
     renamable $x6 = ADDI8 renamable killed $x5, 1
     renamable $x4 = COPY renamable killed $x6
@@ -159,8 +157,8 @@
     ; CHECK-LABEL: name: Enter
     ; CHECK: liveins: $x4, $x7
     ; CHECK: renamable $x5 = COPY killed renamable $x7
-    ; CHECK: renamable $x6 = ADDI8 killed renamable $x4, 1
-    ; CHECK: $x3 = ADD8 killed renamable $x5, $x6
+    ; CHECK: renamable $x7 = ADDI8 killed renamable $x4, 1
+    ; CHECK: $x3 = ADD8 killed renamable $x5, killed renamable $x7
     ; CHECK: BLR8 implicit $lr8, implicit undef $rm, implicit $x3
     renamable $x5 = COPY killed renamable $x7
     renamable $x6 = ADDI8 killed renamable $x4, 1
@@ -180,10 +178,9 @@
     ; CHECK-LABEL: name: foo
     ; CHECK: liveins: $x4, $x7
     ; CHECK: renamable $x5 = COPY killed renamable $x7
-    ; CHECK: renamable $x6 = ADDI8 renamable $x4, 1
-    ; CHECK: renamable $x7 = COPY killed renamable $x6
-    ; CHECK: renamable $x8 = ADDI8 killed $x4, 2
-    ; CHECK: $x3 = ADD8 killed renamable $x5, $x8
+    ; CHECK: renamable $x7 = ADDI8 renamable $x4, 1
+    ; CHECK: renamable $x6 = ADDI8 killed $x4, 2
+    ; CHECK: $x3 = ADD8 killed renamable $x5, killed renamable $x6
     ; CHECK: $x3 = ADD8 $x3, killed renamable $x7
     ; CHECK: BLR8 implicit $lr8, implicit undef $rm, implicit $x3
     renamable $x5 = COPY killed renamable $x7
@@ -207,10 +204,9 @@
     ; CHECK-LABEL: name: bar
     ; CHECK: liveins: $x4, $x7
     ; CHECK: renamable $x5 = COPY killed renamable $x7
-    ; CHECK: renamable $x6 = ADDI8 renamable $x4, 1
-    ; CHECK: renamable $x8 = COPY $x6
-    ; CHECK: renamable $x6 = ADDI8 renamable $x5, 2
-    ; CHECK: $x3 = ADD8 killed renamable $x5, $x6
+    ; CHECK: renamable $x8 = ADDI8 renamable $x4, 1
+    ; CHECK: renamable $x7 = ADDI8 renamable $x5, 2
+    ; CHECK: $x3 = ADD8 killed renamable $x5, killed renamable $x7
     ; CHECK: $x3 = ADD8 $x3, killed renamable $x8
     ; CHECK: BLR8 implicit $lr8, implicit undef $rm, implicit $x3
     renamable $x5 = COPY killed renamable $x7
@@ -235,10 +231,9 @@
     ; CHECK-LABEL: name: bogus
     ; CHECK: liveins: $x7
     ; CHECK: renamable $x5 = COPY renamable $x7
-    ; CHECK: renamable $x6 = ADDI8 $x7, 1
-    ; CHECK: renamable $x7 = COPY $x6
+    ; CHECK: renamable $x4 = ADDI8 $x7, 1
     ; CHECK: renamable $x6 = ADDI8 renamable $x5, 2
-    ; CHECK: $x3 = ADD8 $x7, killed renamable $x5
+    ; CHECK: $x3 = ADD8 killed renamable $x4, killed renamable $x5
     ; CHECK: $x3 = ADD8 $x3, killed renamable $x6
     ; CHECK: BLR8 implicit $lr8, implicit undef $rm, implicit $x3
     renamable $x5 = COPY killed renamable $x7
@@ -262,10 +257,9 @@
     liveins: $x7
     ; CHECK-LABEL: name: foobar
     ; CHECK: liveins: $x7
-    ; CHECK: renamable $x6 = ADDI8 $x7, 1
-    ; CHECK: renamable $x8 = COPY $x6
-    ; CHECK: renamable $x6 = ADDI8 $x7, 2
-    ; CHECK: $x3 = ADD8 $x6, $x7
+    ; CHECK: renamable $x8 = ADDI8 $x7, 1
+    ; CHECK: renamable $x4 = ADDI8 $x7, 2
+    ; CHECK: $x3 = ADD8 killed renamable $x4, $x7
     ; CHECK: $x3 = ADD8 $x3, killed renamable $x8
     ; CHECK: BLR8 implicit $lr8, implicit undef $rm, implicit $x3
     renamable $x5 = COPY killed renamable $x7
Index: llvm/test/CodeGen/PowerPC/redundant-copy-after-tail-dup.ll
===================================================================
--- llvm/test/CodeGen/PowerPC/redundant-copy-after-tail-dup.ll
+++ llvm/test/CodeGen/PowerPC/redundant-copy-after-tail-dup.ll
@@ -26,8 +26,7 @@
 ; CHECK-P9-NEXT:    cmplwi r3, 2
 ; CHECK-P9-NEXT:    bge- cr0, .LBB0_6
 ; CHECK-P9-NEXT:  # %bb.3: # %land.lhs.true.1
-; CHECK-P9-NEXT:    li r5, 0
-; CHECK-P9-NEXT:    mr r3, r5
+; CHECK-P9-NEXT:    li r3, 0
 ; CHECK-P9-NEXT:    blr
 ; CHECK-P9-NEXT:  .LBB0_4: # %lor.lhs.false
 ; CHECK-P9-NEXT:    cmplwi cr0, r4, 0
Index: llvm/test/CodeGen/X86/mul-i512.ll
===================================================================
--- llvm/test/CodeGen/X86/mul-i512.ll
+++ llvm/test/CodeGen/X86/mul-i512.ll
@@ -153,9 +153,8 @@
 ; X32-NEXT:    movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
 ; X32-NEXT:    adcl $0, %edx
 ; X32-NEXT:    movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
-; X32-NEXT:    movl {{[0-9]+}}(%esp), %esi
-; X32-NEXT:    movl %esi, %ecx
-; X32-NEXT:    movl 8(%esi), %ebx
+; X32-NEXT:    movl {{[0-9]+}}(%esp), %ecx
+; X32-NEXT:    movl 8(%ecx), %ebx
 ; X32-NEXT:    movl %ebx, %eax
 ; X32-NEXT:    movl %ebx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
 ; X32-NEXT:    movl {{[-0-9]+}}(%e{{[sb]}}p), %esi # 4-byte Reload
Index: llvm/test/CodeGen/X86/umulo-128-legalisation-lowering.ll
===================================================================
--- llvm/test/CodeGen/X86/umulo-128-legalisation-lowering.ll
+++ llvm/test/CodeGen/X86/umulo-128-legalisation-lowering.ll
@@ -98,8 +98,8 @@
 ; X86-NEXT:    addl %esi, %ecx
 ; X86-NEXT:    adcl $0, %ebp
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
-; X86-NEXT:    movl {{[0-9]+}}(%esp), %esi
-; X86-NEXT:    mull %esi
+; X86-NEXT:    movl {{[0-9]+}}(%esp), %edx
+; X86-NEXT:    mull %edx
 ; X86-NEXT:    movl %edx, %esi
 ; X86-NEXT:    addl %ecx, %eax
 ; X86-NEXT:    movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill