diff --git a/llvm/include/llvm/CodeGen/GlobalISel/CombinerHelper.h b/llvm/include/llvm/CodeGen/GlobalISel/CombinerHelper.h
--- a/llvm/include/llvm/CodeGen/GlobalISel/CombinerHelper.h
+++ b/llvm/include/llvm/CodeGen/GlobalISel/CombinerHelper.h
@@ -251,6 +251,12 @@
   applyCombineUnmergeMergeToPlainValues(MachineInstr &MI,
                                         SmallVectorImpl<Register> &Operands);
 
+  /// Transform G_UNMERGE Constant -> Constant1, Constant2, ...
+  bool matchCombineUnmergeConstant(MachineInstr &MI,
+                                   SmallVectorImpl<APInt> &Csts);
+  bool applyCombineUnmergeConstant(MachineInstr &MI,
+                                   SmallVectorImpl<APInt> &Csts);
+
   /// Transform IntToPtr(PtrToInt(x)) to x if cast is in the same address space.
   bool matchCombineI2PToP2I(MachineInstr &MI, Register &Reg);
   bool applyCombineI2PToP2I(MachineInstr &MI, Register &Reg);
diff --git a/llvm/include/llvm/Target/GlobalISel/Combine.td b/llvm/include/llvm/Target/GlobalISel/Combine.td
--- a/llvm/include/llvm/Target/GlobalISel/Combine.td
+++ b/llvm/include/llvm/Target/GlobalISel/Combine.td
@@ -390,6 +390,15 @@
   (apply [{ return Helper.applyCombineUnmergeMergeToPlainValues(*${d}, ${info}); }])
 >;
 
+// Fold (unmerge cst) -> cst1, cst2, ...
+def unmerge_cst_matchinfo : GIDefMatchData<"SmallVector<APInt, 8>">;
+def unmerge_cst : GICombineRule<
+  (defs root:$d, unmerge_cst_matchinfo:$info),
+  (match (wip_match_opcode G_UNMERGE_VALUES): $d,
+  [{ return Helper.matchCombineUnmergeConstant(*${d}, ${info}); }]),
+  (apply [{ return Helper.applyCombineUnmergeConstant(*${d}, ${info}); }])
+>;
+
 // FIXME: These should use the custom predicate feature once it lands.
 def undef_combines : GICombineGroup<[undef_to_fp_zero, undef_to_int_zero,
                                      undef_to_negative_one,
@@ -418,4 +427,4 @@
     shl_ashr_to_sext_inreg, sext_inreg_of_load,
     width_reduction_combines, select_combines,
     known_bits_simplifications, ext_ext_fold,
-    not_cmp_fold, unmerge_merge]>;
+    not_cmp_fold, unmerge_merge, unmerge_cst]>;
diff --git a/llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp b/llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp
--- a/llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp
+++ b/llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp
@@ -1615,6 +1615,47 @@
   return true;
 }
 
+bool CombinerHelper::matchCombineUnmergeConstant(MachineInstr &MI,
+                                                 SmallVectorImpl<APInt> &Csts) {
+  unsigned SrcIdx = MI.getNumOperands() - 1;
+  Register SrcReg = MI.getOperand(SrcIdx).getReg();
+  MachineInstr *SrcInstr = MRI.getVRegDef(SrcReg);
+  if (SrcInstr->getOpcode() != TargetOpcode::G_CONSTANT)
+    return false;
+  // Break down the big constant in smaller ones.
+  const MachineOperand &CstVal = SrcInstr->getOperand(1);
+  unsigned BitWidth = MRI.getType(SrcReg).getSizeInBits();
+  APInt Val = CstVal.isImm() ? APInt(BitWidth, CstVal.getImm())
+                             : CstVal.getCImm()->getValue();
+
+  LLT Dst0Ty = MRI.getType(MI.getOperand(0).getReg());
+  unsigned ShiftAmt = Dst0Ty.getSizeInBits();
+  // Unmerge a constant.
+  for (unsigned Idx = 0; Idx != SrcIdx; ++Idx) {
+    Csts.emplace_back(Val.trunc(ShiftAmt));
+    Val = Val.lshr(ShiftAmt);
+  }
+
+  return true;
+}
+
+bool CombinerHelper::applyCombineUnmergeConstant(MachineInstr &MI,
+                                                 SmallVectorImpl<APInt> &Csts) {
+  assert(MI.getOpcode() == TargetOpcode::G_UNMERGE_VALUES &&
+         "Expected an unmerge");
+  assert((MI.getNumOperands() - 1 == Csts.size()) &&
+         "Not enough operands to replace all defs");
+  unsigned NumElems = MI.getNumOperands() - 1;
+  Builder.setInstrAndDebugLoc(MI);
+  for (unsigned Idx = 0; Idx < NumElems; ++Idx) {
+    Register DstReg = MI.getOperand(Idx).getReg();
+    Builder.buildConstant(DstReg, Csts[Idx]);
+  }
+
+  MI.eraseFromParent();
+  return true;
+}
+
 bool CombinerHelper::matchCombineShiftToUnmerge(MachineInstr &MI,
                                                 unsigned TargetShiftSize,
                                                 unsigned &ShiftVal) {
diff --git a/llvm/test/CodeGen/AArch64/GlobalISel/combine-unmerge.mir b/llvm/test/CodeGen/AArch64/GlobalISel/combine-unmerge.mir
--- a/llvm/test/CodeGen/AArch64/GlobalISel/combine-unmerge.mir
+++ b/llvm/test/CodeGen/AArch64/GlobalISel/combine-unmerge.mir
@@ -181,3 +181,92 @@
     $w1 = COPY %4(s32)
 ...
 
+# Unmerge a constant into a bunch of smaller constant.
+# Constant is 0x0102030405060708090a0b0c0d0e0f10 and we break it down into
+# bytes:
+# cst1 0x10
+# cst2 0x0f
+# cst3 0x0e
+# ...
+---
+name:            test_combine_unmerge_cst
+body:             |
+  bb.1:
+    ; CHECK-LABEL: name: test_combine_unmerge_cst
+    ; CHECK: [[C:%[0-9]+]]:_(s8) = G_CONSTANT i8 16
+    ; CHECK: [[C1:%[0-9]+]]:_(s8) = G_CONSTANT i8 15
+    ; CHECK: [[C2:%[0-9]+]]:_(s8) = G_CONSTANT i8 14
+    ; CHECK: [[C3:%[0-9]+]]:_(s8) = G_CONSTANT i8 13
+    ; CHECK: [[C4:%[0-9]+]]:_(s8) = G_CONSTANT i8 12
+    ; CHECK: [[C5:%[0-9]+]]:_(s8) = G_CONSTANT i8 11
+    ; CHECK: [[C6:%[0-9]+]]:_(s8) = G_CONSTANT i8 10
+    ; CHECK: [[C7:%[0-9]+]]:_(s8) = G_CONSTANT i8 9
+    ; CHECK: [[C8:%[0-9]+]]:_(s8) = G_CONSTANT i8 8
+    ; CHECK: [[C9:%[0-9]+]]:_(s8) = G_CONSTANT i8 7
+    ; CHECK: [[C10:%[0-9]+]]:_(s8) = G_CONSTANT i8 6
+    ; CHECK: [[C11:%[0-9]+]]:_(s8) = G_CONSTANT i8 5
+    ; CHECK: [[C12:%[0-9]+]]:_(s8) = G_CONSTANT i8 4
+    ; CHECK: [[C13:%[0-9]+]]:_(s8) = G_CONSTANT i8 3
+    ; CHECK: [[C14:%[0-9]+]]:_(s8) = G_CONSTANT i8 2
+    ; CHECK: [[C15:%[0-9]+]]:_(s8) = G_CONSTANT i8 1
+    ; CHECK: $b0 = COPY [[C]](s8)
+    ; CHECK: $b1 = COPY [[C1]](s8)
+    ; CHECK: $b2 = COPY [[C2]](s8)
+    ; CHECK: $b3 = COPY [[C3]](s8)
+    ; CHECK: $b4 = COPY [[C4]](s8)
+    ; CHECK: $b5 = COPY [[C5]](s8)
+    ; CHECK: $b6 = COPY [[C6]](s8)
+    ; CHECK: $b7 = COPY [[C7]](s8)
+    ; CHECK: $b8 = COPY [[C8]](s8)
+    ; CHECK: $b9 = COPY [[C9]](s8)
+    ; CHECK: $b10 = COPY [[C10]](s8)
+    ; CHECK: $b11 = COPY [[C11]](s8)
+    ; CHECK: $b12 = COPY [[C12]](s8)
+    ; CHECK: $b13 = COPY [[C13]](s8)
+    ; CHECK: $b14 = COPY [[C14]](s8)
+    ; CHECK: $b15 = COPY [[C15]](s8)
+    %0:_(s128) = G_CONSTANT i128 1339673755198158349044581307228491536
+    %1:_(s8),%2:_(s8),%3:_(s8),%4:_(s8),%5:_(s8),%6:_(s8),%7:_(s8),%8:_(s8),%9:_(s8),%10:_(s8),%11:_(s8),%12:_(s8),%13:_(s8),%14:_(s8),%15:_(s8),%16:_(s8) = G_UNMERGE_VALUES %0(s128)
+    $b0 = COPY %1(s8)
+    $b1 = COPY %2(s8)
+    $b2 = COPY %3(s8)
+    $b3 = COPY %4(s8)
+    $b4 = COPY %5(s8)
+    $b5 = COPY %6(s8)
+    $b6 = COPY %7(s8)
+    $b7 = COPY %8(s8)
+    $b8 = COPY %9(s8)
+    $b9 = COPY %10(s8)
+    $b10 = COPY %11(s8)
+    $b11 = COPY %12(s8)
+    $b12 = COPY %13(s8)
+    $b13 = COPY %14(s8)
+    $b14 = COPY %15(s8)
+    $b15 = COPY %16(s8)
+...
+
+# Unmerge a constant on a non-power of 2 type into a bunch of smaller constant.
+# Constant is a 3 | 2 | 1 in chunks of 13-bit.
+---
+name:            test_combine_unmerge_cst_36bit
+body:             |
+  bb.1:
+    ; CHECK-LABEL: name: test_combine_unmerge_cst_36bit
+    ; CHECK: [[C:%[0-9]+]]:_(s13) = G_CONSTANT i13 1
+    ; CHECK: [[C1:%[0-9]+]]:_(s13) = G_CONSTANT i13 2
+    ; CHECK: [[C2:%[0-9]+]]:_(s13) = G_CONSTANT i13 3
+    ; CHECK: [[ZEXT:%[0-9]+]]:_(s16) = G_ZEXT [[C]](s13)
+    ; CHECK: [[ZEXT1:%[0-9]+]]:_(s16) = G_ZEXT [[C1]](s13)
+    ; CHECK: [[ZEXT2:%[0-9]+]]:_(s16) = G_ZEXT [[C2]](s13)
+    ; CHECK: $h0 = COPY [[ZEXT]](s16)
+    ; CHECK: $h1 = COPY [[ZEXT1]](s16)
+    ; CHECK: $h2 = COPY [[ZEXT2]](s16)
+    %0:_(s39) = G_CONSTANT i39 201342977
+    %1:_(s13),%2:_(s13),%3:_(s13) = G_UNMERGE_VALUES %0(s39)
+    %4:_(s16) = G_ZEXT %1(s13)
+    %5:_(s16) = G_ZEXT %2(s13)
+    %6:_(s16) = G_ZEXT %3(s13)
+    $h0 = COPY %4(s16)
+    $h1 = COPY %5(s16)
+    $h2 = COPY %6(s16)
+...