diff --git a/llvm/bindings/ocaml/llvm/llvm.ml b/llvm/bindings/ocaml/llvm/llvm.ml
index 35bc16a60bcfc..63931bac940e6 100644
--- a/llvm/bindings/ocaml/llvm/llvm.ml
+++ b/llvm/bindings/ocaml/llvm/llvm.ml
@@ -655,9 +655,6 @@ external const_nuw_add : llvalue -> llvalue -> llvalue = "llvm_const_nuw_add"
 external const_sub : llvalue -> llvalue -> llvalue = "llvm_const_sub"
 external const_nsw_sub : llvalue -> llvalue -> llvalue = "llvm_const_nsw_sub"
 external const_nuw_sub : llvalue -> llvalue -> llvalue = "llvm_const_nuw_sub"
-external const_mul : llvalue -> llvalue -> llvalue = "llvm_const_mul"
-external const_nsw_mul : llvalue -> llvalue -> llvalue = "llvm_const_nsw_mul"
-external const_nuw_mul : llvalue -> llvalue -> llvalue = "llvm_const_nuw_mul"
 external const_xor : llvalue -> llvalue -> llvalue = "llvm_const_xor"
 external const_gep : lltype -> llvalue -> llvalue array -> llvalue
                    = "llvm_const_gep"
diff --git a/llvm/bindings/ocaml/llvm/llvm.mli b/llvm/bindings/ocaml/llvm/llvm.mli
index da52ae6033b90..8a85d672db774 100644
--- a/llvm/bindings/ocaml/llvm/llvm.mli
+++ b/llvm/bindings/ocaml/llvm/llvm.mli
@@ -1131,20 +1131,6 @@ val const_nsw_sub : llvalue -> llvalue -> llvalue
     See the method [llvm::ConstantExpr::getNSWSub]. *)
 val const_nuw_sub : llvalue -> llvalue -> llvalue
 
-(** [const_mul c1 c2] returns the constant product of two constants.
-    See the method [llvm::ConstantExpr::getMul]. *)
-val const_mul : llvalue -> llvalue -> llvalue
-
-(** [const_nsw_mul c1 c2] returns the constant product of two constants with
-    no signed wrapping. The result is undefined if the sum overflows.
-    See the method [llvm::ConstantExpr::getNSWMul]. *)
-val const_nsw_mul : llvalue -> llvalue -> llvalue
-
-(** [const_nuw_mul c1 c2] returns the constant product of two constants with
-    no unsigned wrapping. The result is undefined if the sum overflows.
-    See the method [llvm::ConstantExpr::getNSWMul]. *)
-val const_nuw_mul : llvalue -> llvalue -> llvalue
-
 (** [const_xor c1 c2] returns the constant bitwise [XOR] of two integer
     constants.
     See the method [llvm::ConstantExpr::getXor]. *)
diff --git a/llvm/bindings/ocaml/llvm/llvm_ocaml.c b/llvm/bindings/ocaml/llvm/llvm_ocaml.c
index 019e731172a98..904dc114d307d 100644
--- a/llvm/bindings/ocaml/llvm/llvm_ocaml.c
+++ b/llvm/bindings/ocaml/llvm/llvm_ocaml.c
@@ -1210,24 +1210,6 @@ value llvm_const_nuw_sub(value LHS, value RHS) {
   return to_val(Value);
 }
 
-/* llvalue -> llvalue -> llvalue */
-value llvm_const_mul(value LHS, value RHS) {
-  LLVMValueRef Value = LLVMConstMul(Value_val(LHS), Value_val(RHS));
-  return to_val(Value);
-}
-
-/* llvalue -> llvalue -> llvalue */
-value llvm_const_nsw_mul(value LHS, value RHS) {
-  LLVMValueRef Value = LLVMConstNSWMul(Value_val(LHS), Value_val(RHS));
-  return to_val(Value);
-}
-
-/* llvalue -> llvalue -> llvalue */
-value llvm_const_nuw_mul(value LHS, value RHS) {
-  LLVMValueRef Value = LLVMConstNUWMul(Value_val(LHS), Value_val(RHS));
-  return to_val(Value);
-}
-
 /* llvalue -> llvalue -> llvalue */
 value llvm_const_xor(value LHS, value RHS) {
   LLVMValueRef Value = LLVMConstXor(Value_val(LHS), Value_val(RHS));
diff --git a/llvm/docs/LangRef.rst b/llvm/docs/LangRef.rst
index 8ea5d35cb63e9..deb87365ae8d7 100644
--- a/llvm/docs/LangRef.rst
+++ b/llvm/docs/LangRef.rst
@@ -5113,10 +5113,6 @@ The following is the syntax for constant expressions:
     Perform an addition on constants.
 ``sub (LHS, RHS)``
     Perform a subtraction on constants.
-``mul (LHS, RHS)``
-    Perform a multiplication on constants.
-``shl (LHS, RHS)``
-    Perform a left shift on constants.
 ``xor (LHS, RHS)``
     Perform a bitwise xor on constants.
 
diff --git a/llvm/docs/ReleaseNotes.md b/llvm/docs/ReleaseNotes.md
index 204eeaeb31ee3..c9543ff09217a 100644
--- a/llvm/docs/ReleaseNotes.md
+++ b/llvm/docs/ReleaseNotes.md
@@ -57,6 +57,10 @@ Changes to the LLVM IR
 ----------------------
 
 * The `nocapture` attribute has been replaced by `captures(none)`.
+* The constant expression variants of the following instructions have been
+  removed:
+
+  * `mul`
 
 Changes to LLVM infrastructure
 ------------------------------
@@ -121,6 +125,15 @@ Changes to the Python bindings
 Changes to the C API
 --------------------
 
+* The following functions for creating constant expressions have been removed,
+  because the underlying constant expressions are no longer supported. Instead,
+  an instruction should be created using the `LLVMBuildXYZ` APIs, which will
+  constant fold the operands if possible and create an instruction otherwise:
+
+  * `LLVMConstMul`
+  * `LLVMConstNUWMul`
+  * `LLVMConstNSWMul`
+
 Changes to the CodeGen infrastructure
 -------------------------------------
 
diff --git a/llvm/include/llvm-c/Core.h b/llvm/include/llvm-c/Core.h
index 43bb775e5781a..a414e2061a595 100644
--- a/llvm/include/llvm-c/Core.h
+++ b/llvm/include/llvm-c/Core.h
@@ -2459,9 +2459,6 @@ LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
-LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
 LLVMValueRef LLVMConstGEP2(LLVMTypeRef Ty, LLVMValueRef ConstantVal,
                            LLVMValueRef *ConstantIndices, unsigned NumIndices);
diff --git a/llvm/include/llvm/IR/Constants.h b/llvm/include/llvm/IR/Constants.h
index 15b90589b7e2b..676d59e3fcb08 100644
--- a/llvm/include/llvm/IR/Constants.h
+++ b/llvm/include/llvm/IR/Constants.h
@@ -1143,8 +1143,6 @@ class ConstantExpr : public Constant {
                           bool HasNSW = false);
   static Constant *getSub(Constant *C1, Constant *C2, bool HasNUW = false,
                           bool HasNSW = false);
-  static Constant *getMul(Constant *C1, Constant *C2, bool HasNUW = false,
-                          bool HasNSW = false);
   static Constant *getXor(Constant *C1, Constant *C2);
   static Constant *getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced = false);
   static Constant *getPtrToInt(Constant *C, Type *Ty,
@@ -1174,14 +1172,6 @@ class ConstantExpr : public Constant {
     return getSub(C1, C2, true, false);
   }
 
-  static Constant *getNSWMul(Constant *C1, Constant *C2) {
-    return getMul(C1, C2, false, true);
-  }
-
-  static Constant *getNUWMul(Constant *C1, Constant *C2) {
-    return getMul(C1, C2, true, false);
-  }
-
   /// If C is a scalar/fixed width vector of known powers of 2, then this
   /// function returns a new scalar/fixed width vector obtained from logBase2
   /// of C. Undef vector elements are set to zero.
diff --git a/llvm/lib/AsmParser/LLParser.cpp b/llvm/lib/AsmParser/LLParser.cpp
index 0817851bd408a..37103937c92a7 100644
--- a/llvm/lib/AsmParser/LLParser.cpp
+++ b/llvm/lib/AsmParser/LLParser.cpp
@@ -4301,6 +4301,8 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS, Type *ExpectedTy) {
     return error(ID.Loc, "ashr constexprs are no longer supported");
   case lltok::kw_shl:
     return error(ID.Loc, "shl constexprs are no longer supported");
+  case lltok::kw_mul:
+    return error(ID.Loc, "mul constexprs are no longer supported");
   case lltok::kw_fneg:
     return error(ID.Loc, "fneg constexprs are no longer supported");
   case lltok::kw_select:
@@ -4329,7 +4331,6 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS, Type *ExpectedTy) {
   // Binary Operators.
   case lltok::kw_add:
   case lltok::kw_sub:
-  case lltok::kw_mul:
   case lltok::kw_xor: {
     bool NUW = false;
     bool NSW = false;
diff --git a/llvm/lib/IR/Constants.cpp b/llvm/lib/IR/Constants.cpp
index 9b69b1cb059da..9e3e739fae3dc 100644
--- a/llvm/lib/IR/Constants.cpp
+++ b/llvm/lib/IR/Constants.cpp
@@ -2422,10 +2422,10 @@ bool ConstantExpr::isSupportedBinOp(unsigned Opcode) {
   case Instruction::LShr:
   case Instruction::AShr:
   case Instruction::Shl:
+  case Instruction::Mul:
     return false;
   case Instruction::Add:
   case Instruction::Sub:
-  case Instruction::Mul:
   case Instruction::Xor:
     return true;
   default:
@@ -2649,13 +2649,6 @@ Constant *ConstantExpr::getSub(Constant *C1, Constant *C2,
   return get(Instruction::Sub, C1, C2, Flags);
 }
 
-Constant *ConstantExpr::getMul(Constant *C1, Constant *C2,
-                               bool HasNUW, bool HasNSW) {
-  unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
-                   (HasNSW ? OverflowingBinaryOperator::NoSignedWrap   : 0);
-  return get(Instruction::Mul, C1, C2, Flags);
-}
-
 Constant *ConstantExpr::getXor(Constant *C1, Constant *C2) {
   return get(Instruction::Xor, C1, C2);
 }
diff --git a/llvm/lib/IR/Core.cpp b/llvm/lib/IR/Core.cpp
index 15ab9674f496d..88b89c52c19a2 100644
--- a/llvm/lib/IR/Core.cpp
+++ b/llvm/lib/IR/Core.cpp
@@ -1803,23 +1803,6 @@ LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant,
                                       unwrap<Constant>(RHSConstant)));
 }
 
-LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
-  return wrap(ConstantExpr::getMul(unwrap<Constant>(LHSConstant),
-                                   unwrap<Constant>(RHSConstant)));
-}
-
-LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant,
-                             LLVMValueRef RHSConstant) {
-  return wrap(ConstantExpr::getNSWMul(unwrap<Constant>(LHSConstant),
-                                      unwrap<Constant>(RHSConstant)));
-}
-
-LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant,
-                             LLVMValueRef RHSConstant) {
-  return wrap(ConstantExpr::getNUWMul(unwrap<Constant>(LHSConstant),
-                                      unwrap<Constant>(RHSConstant)));
-}
-
 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
   return wrap(ConstantExpr::getXor(unwrap<Constant>(LHSConstant),
                                    unwrap<Constant>(RHSConstant)));
diff --git a/llvm/test/Analysis/ValueTracking/known-non-equal.ll b/llvm/test/Analysis/ValueTracking/known-non-equal.ll
index cbc61b339dca7..654e1c6cdf9e1 100644
--- a/llvm/test/Analysis/ValueTracking/known-non-equal.ll
+++ b/llvm/test/Analysis/ValueTracking/known-non-equal.ll
@@ -206,11 +206,13 @@ define i1 @mul5(i8 %B, i8 %C) {
 define i1 @mul_constantexpr(i16 %a) {
 ; CHECK-LABEL: @mul_constantexpr(
 ; CHECK-NEXT:    [[MUL:%.*]] = mul nsw i16 [[A:%.*]], 3
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i16 mul nsw (i16 ptrtoint (ptr @g to i16), i16 -1), [[MUL]]
+; CHECK-NEXT:    [[MUL2:%.*]] = mul nsw i16 ptrtoint (ptr @g to i16), -1
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i16 [[MUL2]], [[MUL]]
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %mul = mul nsw i16 %a, 3
-  %cmp = icmp eq i16 mul nsw (i16 ptrtoint (ptr @g to i16), i16 -1), %mul
+  %mul2 = mul nsw i16 ptrtoint (ptr @g to i16), -1
+  %cmp = icmp eq i16 %mul2, %mul
   ret i1 %cmp
 }
 
diff --git a/llvm/test/Assembler/ConstantExprFold.ll b/llvm/test/Assembler/ConstantExprFold.ll
index 944e6f0236ecb..840ed06d42228 100644
--- a/llvm/test/Assembler/ConstantExprFold.ll
+++ b/llvm/test/Assembler/ConstantExprFold.ll
@@ -10,7 +10,6 @@
 
 @add = global ptr inttoptr (i64 add (i64 ptrtoint (ptr @A to i64), i64 0) to ptr) ; X + 0 == X
 @sub = global ptr inttoptr (i64 sub (i64 ptrtoint (ptr @A to i64), i64 0) to ptr) ; X - 0 == X
-@mul = global ptr inttoptr (i64 mul (i64 ptrtoint (ptr @A to i64), i64 0) to ptr) ; X * 0 == 0
 @xor = global ptr inttoptr (i64 xor (i64 ptrtoint (ptr @A to i64), i64 0) to ptr) ; X ^ 0 == X
 
 %Ty = type { i32, i32 }
@@ -33,7 +32,6 @@
 ; CHECK: @A = global i64 0
 ; CHECK: @add = global ptr @A
 ; CHECK: @sub = global ptr @A
-; CHECK: @mul = global ptr null
 ; CHECK: @xor = global ptr @A
 ; CHECK: @B = external global %Ty
 ; CHECK: @cons = weak global i32 0, align 8
diff --git a/llvm/test/Assembler/flags.ll b/llvm/test/Assembler/flags.ll
index acc8874aef443..b685277f4ee04 100644
--- a/llvm/test/Assembler/flags.ll
+++ b/llvm/test/Assembler/flags.ll
@@ -170,11 +170,6 @@ define i64 @sub_both_ce() {
 	ret i64 sub nsw nuw (i64 ptrtoint (ptr @addr to i64), i64 91)
 }
 
-define i64 @mul_both_ce() {
-; CHECK: ret i64 mul nuw nsw (i64 ptrtoint (ptr @addr to i64), i64 91)
-	ret i64 mul nuw nsw (i64 ptrtoint (ptr @addr to i64), i64 91)
-}
-
 define ptr @gep_nw_ce() {
 ; CHECK: ret ptr getelementptr inbounds (i64, ptr @addr, i64 171)
         ret ptr getelementptr inbounds (i64, ptr @addr, i64 171)
@@ -190,11 +185,6 @@ define i64 @sub_plain_ce() {
 	ret i64 sub (i64 ptrtoint (ptr @addr to i64), i64 91)
 }
 
-define i64 @mul_plain_ce() {
-; CHECK: ret i64 mul (i64 ptrtoint (ptr @addr to i64), i64 91)
-	ret i64 mul (i64 ptrtoint (ptr @addr to i64), i64 91)
-}
-
 define ptr @gep_plain_ce() {
 ; CHECK: ret ptr getelementptr (i64, ptr @addr, i64 171)
         ret ptr getelementptr (i64, ptr @addr, i64 171)
@@ -210,11 +200,6 @@ define i64 @sub_both_reversed_ce() {
 	ret i64 sub nsw nuw (i64 ptrtoint (ptr @addr to i64), i64 91)
 }
 
-define i64 @mul_both_reversed_ce() {
-; CHECK: ret i64 mul nuw nsw (i64 ptrtoint (ptr @addr to i64), i64 91)
-	ret i64 mul nsw nuw (i64 ptrtoint (ptr @addr to i64), i64 91)
-}
-
 define i64 @add_signed_ce() {
 ; CHECK: ret i64 add nsw (i64 ptrtoint (ptr @addr to i64), i64 91)
 	ret i64 add nsw (i64 ptrtoint (ptr @addr to i64), i64 91)
@@ -225,11 +210,6 @@ define i64 @sub_signed_ce() {
 	ret i64 sub nsw (i64 ptrtoint (ptr @addr to i64), i64 91)
 }
 
-define i64 @mul_signed_ce() {
-; CHECK: ret i64 mul nsw (i64 ptrtoint (ptr @addr to i64), i64 91)
-	ret i64 mul nsw (i64 ptrtoint (ptr @addr to i64), i64 91)
-}
-
 define i64 @add_unsigned_ce() {
 ; CHECK: ret i64 add nuw (i64 ptrtoint (ptr @addr to i64), i64 91)
 	ret i64 add nuw (i64 ptrtoint (ptr @addr to i64), i64 91)
@@ -240,11 +220,6 @@ define i64 @sub_unsigned_ce() {
 	ret i64 sub nuw (i64 ptrtoint (ptr @addr to i64), i64 91)
 }
 
-define i64 @mul_unsigned_ce() {
-; CHECK: ret i64 mul nuw (i64 ptrtoint (ptr @addr to i64), i64 91)
-	ret i64 mul nuw (i64 ptrtoint (ptr @addr to i64), i64 91)
-}
-
 define i64 @test_zext(i32 %a) {
 ; CHECK: %res = zext nneg i32 %a to i64
   %res = zext nneg i32 %a to i64
diff --git a/llvm/test/Bindings/OCaml/core.ml b/llvm/test/Bindings/OCaml/core.ml
index 9d42107aff2ab..aeefd28c54bc0 100644
--- a/llvm/test/Bindings/OCaml/core.ml
+++ b/llvm/test/Bindings/OCaml/core.ml
@@ -271,9 +271,6 @@ let test_constants () =
    * CHECK: @const_sub = global i64 sub
    * CHECK: @const_nsw_sub = global i64 sub nsw
    * CHECK: @const_nuw_sub = global i64 sub nuw
-   * CHECK: @const_mul = global i64 mul
-   * CHECK: @const_nsw_mul = global i64 mul nsw
-   * CHECK: @const_nuw_mul = global i64 mul nuw
    * CHECK: @const_xor = global i64 xor
    *)
   let void_ptr = pointer_type context in
@@ -290,9 +287,6 @@ let test_constants () =
   ignore (define_global "const_sub" (const_sub foldbomb five) m);
   ignore (define_global "const_nsw_sub" (const_nsw_sub foldbomb five) m);
   ignore (define_global "const_nuw_sub" (const_nuw_sub foldbomb five) m);
-  ignore (define_global "const_mul" (const_mul foldbomb five) m);
-  ignore (define_global "const_nsw_mul" (const_nsw_mul foldbomb five) m);
-  ignore (define_global "const_nuw_mul" (const_nuw_mul foldbomb five) m);
   ignore (define_global "const_xor" (const_xor foldbomb five) m);
 
   group "constant casts";
diff --git a/llvm/test/CodeGen/ARM/2008-04-04-ScavengerAssert.ll b/llvm/test/CodeGen/ARM/2008-04-04-ScavengerAssert.ll
index 02e1cee13448e..d152998cf700a 100644
--- a/llvm/test/CodeGen/ARM/2008-04-04-ScavengerAssert.ll
+++ b/llvm/test/CodeGen/ARM/2008-04-04-ScavengerAssert.ll
@@ -46,7 +46,9 @@ bb17.i:		; preds = %cond_next119.i
 cond_true53.i:		; preds = %bb17.i
 	ret ptr null
 cond_false99.i:		; preds = %bb17.i
-        %malloccall = tail call ptr @malloc(i32 trunc (i64 mul nuw (i64 ptrtoint (ptr getelementptr (ptr, ptr null, i32 1) to i64), i64 2) to i32))
+  %mul = mul nuw i64 ptrtoint (ptr getelementptr (ptr, ptr null, i32 1) to i64), 2
+  %trunc = trunc i64 %mul to i32
+  %malloccall = tail call ptr @malloc(i32 %trunc)
 	br i1 false, label %bb126.i, label %cond_next119.i
 cond_next119.i:		; preds = %cond_false99.i, %bb42
 	%curr_ptr.0.reg2mem.0.i = phi ptr [ %malloccall, %cond_false99.i ], [ null, %bb42 ]		; <ptr> [#uses=2]
diff --git a/llvm/test/CodeGen/X86/ptrtoint-constexpr.ll b/llvm/test/CodeGen/X86/ptrtoint-constexpr.ll
index 58d1895f0b158..230c16b0e0bf9 100644
--- a/llvm/test/CodeGen/X86/ptrtoint-constexpr.ll
+++ b/llvm/test/CodeGen/X86/ptrtoint-constexpr.ll
@@ -9,6 +9,6 @@
 
 ; CHECK:	.globl x
 ; CHECK: x:
-; CHECK: .quad	3
+; CHECK: .quad	1+3
 
-@x = global i64 mul (i64 3, i64 ptrtoint (ptr getelementptr (i2, ptr null, i64 1) to i64))
+@x = global i64 add (i64 3, i64 ptrtoint (ptr getelementptr (i2, ptr null, i64 1) to i64))
diff --git a/llvm/test/Other/constant-fold-gep-address-spaces.ll b/llvm/test/Other/constant-fold-gep-address-spaces.ll
index e2589ce77ebd2..b6d0a72dbdfce 100644
--- a/llvm/test/Other/constant-fold-gep-address-spaces.ll
+++ b/llvm/test/Other/constant-fold-gep-address-spaces.ll
@@ -24,18 +24,10 @@ target datalayout = "e-p:128:128:128-p1:32:32:32-p2:8:8:8-p3:16:16:16-p4:64:64:6
 ; The target-independent folder should be able to do some clever
 ; simplifications on sizeof, alignof, and offsetof expressions. The
 ; target-dependent folder should fold these down to constants.
-; PLAIN-X: @a = constant i64 mul (i64 ptrtoint (ptr addrspace(4) getelementptr (double, ptr addrspace(4) null, i32 1) to i64), i64 2310)
-@a = constant i64 mul (i64 3, i64 mul (i64 ptrtoint (ptr addrspace(4) getelementptr ({[7 x double], [7 x double]}, ptr addrspace(4) null, i64 11) to i64), i64 5))
 
 ; PLAIN-X: @b = constant i64 ptrtoint (ptr addrspace(4) getelementptr ({ i1, double }, ptr null, i64 0, i32 1) to i64)
 @b = constant i64 ptrtoint (ptr addrspace(4) getelementptr ({i1, [13 x double]}, ptr addrspace(4) null, i64 0, i32 1) to i64)
 
-; PLAIN-X: @c = constant i64 mul nuw (i64 ptrtoint (ptr addrspace(4) getelementptr (double, ptr addrspace(4) null, i32 1) to i64), i64 2)
-@c = constant i64 ptrtoint (ptr addrspace(4) getelementptr ({double, double, double, double}, ptr addrspace(4) null, i64 0, i32 2) to i64)
-
-; PLAIN-X: @d = constant i64 mul nuw (i64 ptrtoint (ptr addrspace(4) getelementptr (double, ptr addrspace(4) null, i32 1) to i64), i64 11)
-@d = constant i64 ptrtoint (ptr addrspace(4) getelementptr ([13 x double], ptr addrspace(4) null, i64 0, i32 11) to i64)
-
 ; PLAIN-X: @e = constant i64 ptrtoint (ptr addrspace(4) getelementptr ({ double, float, double, double }, ptr null, i64 0, i32 2) to i64)
 @e = constant i64 ptrtoint (ptr addrspace(4) getelementptr ({double, float, double, double}, ptr addrspace(4) null, i64 0, i32 2) to i64)
 
@@ -123,10 +115,6 @@ define ptr addrspace(2) @hoo1() #0 {
   ret ptr addrspace(2) %t
 }
 
-; PLAIN-X: define i64 @fa() #0 {
-; PLAIN-X:   %t = bitcast i64 mul (i64 ptrtoint (ptr addrspace(4) getelementptr (double, ptr addrspace(4) null, i32 1) to i64), i64 2310) to i64
-; PLAIN-X:   ret i64 %t
-; PLAIN-X: }
 ; PLAIN-X: define i64 @fb() #0 {
 ; PLAIN-X:   %t = bitcast i64 ptrtoint (ptr addrspace(4) getelementptr ({ i1, double }, ptr null, i64 0, i32 1) to i64) to i64
 ; PLAIN-X:   ret i64 %t
@@ -159,10 +147,6 @@ define ptr addrspace(2) @hoo1() #0 {
 ; PLAIN-X:   %t = bitcast i64 ptrtoint (ptr addrspace(2) getelementptr ({ i1, ptr addrspace(2) }, ptr null, i64 0, i32 1) to i64) to i64
 ; PLAIN-X:   ret i64 %t
 ; PLAIN-X: }
-define i64 @fa() #0 {
-  %t = bitcast i64 mul (i64 3, i64 mul (i64 ptrtoint (ptr getelementptr ({[7 x double], [7 x double]}, ptr null, i64 11) to i64), i64 5)) to i64
-  ret i64 %t
-}
 define i64 @fb() #0 {
   %t = bitcast i64 ptrtoint (ptr addrspace(4) getelementptr ({i1, [13 x double]}, ptr addrspace(4) null, i64 0, i32 1) to i64) to i64
   ret i64 %t
diff --git a/llvm/test/Other/constant-fold-gep.ll b/llvm/test/Other/constant-fold-gep.ll
index a4c55c62840a6..46bf49d8d5a4a 100644
--- a/llvm/test/Other/constant-fold-gep.ll
+++ b/llvm/test/Other/constant-fold-gep.ll
@@ -48,7 +48,6 @@
 ; simplifications on sizeof, alignof, and offsetof expressions. The
 ; target-dependent folder should fold these down to constants.
 
-; PLAIN: @a = constant i64 mul (i64 ptrtoint (ptr getelementptr ({ [7 x double], [7 x double] }, ptr null, i64 11) to i64), i64 15)
 ; PLAIN: @b = constant i64 ptrtoint (ptr getelementptr ({ i1, [13 x double] }, ptr null, i64 0, i32 1) to i64)
 ; PLAIN: @c = constant i64 ptrtoint (ptr getelementptr ({ double, double, double, double }, ptr null, i64 0, i32 2) to i64)
 ; PLAIN: @d = constant i64 ptrtoint (ptr getelementptr ([13 x double], ptr null, i64 0, i32 11) to i64)
@@ -57,7 +56,6 @@
 ; PLAIN: @g = constant i64 ptrtoint (ptr getelementptr ({ i1, { double, double } }, ptr null, i64 0, i32 1) to i64)
 ; PLAIN: @h = constant i64 ptrtoint (ptr getelementptr (ptr, ptr null, i64 1) to i64)
 ; PLAIN: @i = constant i64 ptrtoint (ptr getelementptr ({ i1, ptr }, ptr null, i64 0, i32 1) to i64)
-; OPT: @a = local_unnamed_addr constant i64 18480
 ; OPT: @b = local_unnamed_addr constant i64 8
 ; OPT: @c = local_unnamed_addr constant i64 16
 ; OPT: @d = local_unnamed_addr constant i64 88
@@ -66,7 +64,6 @@
 ; OPT: @g = local_unnamed_addr constant i64 8
 ; OPT: @h = local_unnamed_addr constant i64 8
 ; OPT: @i = local_unnamed_addr constant i64 8
-; TO: @a = local_unnamed_addr constant i64 18480
 ; TO: @b = local_unnamed_addr constant i64 8
 ; TO: @c = local_unnamed_addr constant i64 16
 ; TO: @d = local_unnamed_addr constant i64 88
@@ -76,7 +73,6 @@
 ; TO: @h = local_unnamed_addr constant i64 8
 ; TO: @i = local_unnamed_addr constant i64 8
 
-@a = constant i64 mul (i64 3, i64 mul (i64 ptrtoint (ptr getelementptr ({[7 x double], [7 x double]}, ptr null, i64 11) to i64), i64 5))
 @b = constant i64 ptrtoint (ptr getelementptr ({i1, [13 x double]}, ptr null, i64 0, i32 1) to i64)
 @c = constant i64 ptrtoint (ptr getelementptr ({double, double, double, double}, ptr null, i64 0, i32 2) to i64)
 @d = constant i64 ptrtoint (ptr getelementptr ([13 x double], ptr null, i64 0, i32 11) to i64)
@@ -220,10 +216,6 @@ define ptr @hoo1() nounwind {
   ret ptr %t
 }
 
-; PLAIN: define i64 @fa() #0 {
-; PLAIN:   %t = bitcast i64 mul (i64 ptrtoint (ptr getelementptr ({ [7 x double], [7 x double] }, ptr null, i64 11) to i64), i64 15) to i64
-; PLAIN:   ret i64 %t
-; PLAIN: }
 ; PLAIN: define i64 @fb() #0 {
 ; PLAIN:   %t = bitcast i64 ptrtoint (ptr getelementptr ({ i1, [13 x double] }, ptr null, i64 0, i32 1) to i64) to i64
 ; PLAIN:   ret i64 %t
@@ -256,9 +248,6 @@ define ptr @hoo1() nounwind {
 ; PLAIN:   %t = bitcast i64 ptrtoint (ptr getelementptr ({ i1, ptr }, ptr null, i64 0, i32 1) to i64) to i64
 ; PLAIN:   ret i64 %t
 ; PLAIN: }
-; OPT: define i64 @fa() local_unnamed_addr #0 {
-; OPT:   ret i64 18480
-; OPT: }
 ; OPT: define i64 @fb() local_unnamed_addr #0 {
 ; OPT:   ret i64 8
 ; OPT: }
@@ -283,9 +272,6 @@ define ptr @hoo1() nounwind {
 ; OPT: define i64 @fi() local_unnamed_addr #0 {
 ; OPT:   ret i64 8
 ; OPT: }
-; TO: define i64 @fa() local_unnamed_addr #0 {
-; TO:   ret i64 18480
-; TO: }
 ; TO: define i64 @fb() local_unnamed_addr #0 {
 ; TO:   ret i64 8
 ; TO: }
@@ -310,9 +296,6 @@ define ptr @hoo1() nounwind {
 ; TO: define i64 @fi() local_unnamed_addr #0 {
 ; TO:   ret i64 8
 ; TO: }
-; SCEV-LABEL: Classifying expressions for: @fa
-; SCEV:   %t = bitcast i64 mul (i64 ptrtoint (ptr getelementptr ({ [7 x double], [7 x double] }, ptr null, i64 11) to i64), i64 15) to i64
-; SCEV:   -->  18480
 ; SCEV-LABEL: Classifying expressions for: @fb
 ; SCEV:  %t = bitcast i64 ptrtoint (ptr getelementptr ({ i1, [13 x double] }, ptr null, i64 0, i32 1) to i64) to i64
 ; SCEV:   -->  8
@@ -338,10 +321,6 @@ define ptr @hoo1() nounwind {
 ; SCEV:   %t = bitcast i64 ptrtoint (ptr getelementptr ({ i1, ptr }, ptr null, i64 0, i32 1) to i64) to i64
 ; SCEV:   --> 8
 
-define i64 @fa() nounwind {
-  %t = bitcast i64 mul (i64 3, i64 mul (i64 ptrtoint (ptr getelementptr ({[7 x double], [7 x double]}, ptr null, i64 11) to i64), i64 5)) to i64
-  ret i64 %t
-}
 define i64 @fb() nounwind {
   %t = bitcast i64 ptrtoint (ptr getelementptr ({i1, [13 x double]}, ptr null, i64 0, i32 1) to i64) to i64
   ret i64 %t
diff --git a/llvm/test/Transforms/GVN/2009-11-12-MemDepMallocBitCast.ll b/llvm/test/Transforms/GVN/2009-11-12-MemDepMallocBitCast.ll
index f2d4fa9d37844..e8f570b256c75 100644
--- a/llvm/test/Transforms/GVN/2009-11-12-MemDepMallocBitCast.ll
+++ b/llvm/test/Transforms/GVN/2009-11-12-MemDepMallocBitCast.ll
@@ -3,7 +3,8 @@
 ; RUN: opt < %s -passes=gvn -S | FileCheck %s
 
 define i64 @test() {
-  %1 = tail call ptr @malloc(i64 mul (i64 4, i64 ptrtoint (ptr getelementptr (i64, ptr null, i64 1) to i64))) ; <ptr> [#uses=2]
+  %mul = mul i64 4, ptrtoint (ptr getelementptr (i64, ptr null, i64 1) to i64)
+  %1 = tail call ptr @malloc(i64 %mul)
   store i8 42, ptr %1
   %Y = load i64, ptr %1                               ; <i64> [#uses=1]
   ret i64 %Y
diff --git a/llvm/test/Transforms/GlobalOpt/2008-12-16-HeapSRACrash-2.ll b/llvm/test/Transforms/GlobalOpt/2008-12-16-HeapSRACrash-2.ll
index 0204922a6f894..84f9f81aa585f 100644
--- a/llvm/test/Transforms/GlobalOpt/2008-12-16-HeapSRACrash-2.ll
+++ b/llvm/test/Transforms/GlobalOpt/2008-12-16-HeapSRACrash-2.ll
@@ -6,7 +6,9 @@ target triple = "i386-apple-darwin7"
 
 define void @bar(i32 %Size) nounwind noinline {
 entry:
-        %malloccall = tail call ptr @malloc(i32 trunc (i64 mul (i64 ptrtoint (ptr getelementptr (i32, ptr null, i32 1) to i64), i64 2000000) to i32))
+  %mul = mul i64 ptrtoint (ptr getelementptr (i32, ptr null, i32 1) to i64), 200000
+  %trunc = trunc i64 %mul to i32
+  %malloccall = tail call ptr @malloc(i32 %trunc)
 	%.sub = getelementptr [1000000 x %struct.foo], ptr %malloccall, i32 0, i32 0		; <ptr> [#uses=1]
 	store ptr %.sub, ptr @X, align 4
 	ret void
diff --git a/llvm/test/Transforms/GlobalOpt/2008-12-16-HeapSRACrash.ll b/llvm/test/Transforms/GlobalOpt/2008-12-16-HeapSRACrash.ll
index 9163026613728..e2a6fcc940f45 100644
--- a/llvm/test/Transforms/GlobalOpt/2008-12-16-HeapSRACrash.ll
+++ b/llvm/test/Transforms/GlobalOpt/2008-12-16-HeapSRACrash.ll
@@ -6,7 +6,9 @@ target triple = "i386-apple-darwin7"
 
 define void @bar(i32 %Size) nounwind noinline {
 entry:
-        %malloccall = tail call ptr @malloc(i32 trunc (i64 mul (i64 ptrtoint (ptr getelementptr (i32, ptr null, i32 1) to i64), i64 2000000) to i32))
+  %mul = mul i64 ptrtoint (ptr getelementptr (i32, ptr null, i32 1) to i64), 2000000
+  %trunc = trunc i64 %mul to i32
+  %malloccall = tail call ptr @malloc(i32 %trunc)
 	%.sub = getelementptr [1000000 x %struct.foo], ptr %malloccall, i32 0, i32 0		; <ptr> [#uses=1]
 	store ptr %.sub, ptr @X, align 4
 	ret void
diff --git a/llvm/test/Transforms/GlobalOpt/malloc-promote-2-no-null-opt.ll b/llvm/test/Transforms/GlobalOpt/malloc-promote-2-no-null-opt.ll
index ebfdd82cbedf5..f99afe4a878d4 100644
--- a/llvm/test/Transforms/GlobalOpt/malloc-promote-2-no-null-opt.ll
+++ b/llvm/test/Transforms/GlobalOpt/malloc-promote-2-no-null-opt.ll
@@ -5,7 +5,7 @@ target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:1
 @G = internal global ptr null
 
 ;.
-; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = internal unnamed_addr global ptr null
+; CHECK: @G = internal unnamed_addr global ptr null
 ;.
 define void @t() #0 {
 ; CHECK-LABEL: @t(
@@ -16,7 +16,7 @@ define void @t() #0 {
 ; CHECK-NEXT:    store i32 20, ptr [[GVE]], align 4
 ; CHECK-NEXT:    ret void
 ;
-  %malloccall = tail call ptr @malloc(i64 mul (i64 100, i64 4))
+  %malloccall = tail call ptr @malloc(i64 400)
   store ptr %malloccall, ptr @G
   %GV = load ptr, ptr @G
   %GVe = getelementptr i32, ptr %GV, i32 40
diff --git a/llvm/test/Transforms/GlobalOpt/malloc-promote-2.ll b/llvm/test/Transforms/GlobalOpt/malloc-promote-2.ll
index 766a3595607f9..378050ba934f6 100644
--- a/llvm/test/Transforms/GlobalOpt/malloc-promote-2.ll
+++ b/llvm/test/Transforms/GlobalOpt/malloc-promote-2.ll
@@ -8,7 +8,7 @@ define void @t() {
 ; CHECK-LABEL: @t(
 ; CHECK-NEXT:    ret void
 ;
-  %malloccall = tail call ptr @malloc(i64 mul (i64 100, i64 4))
+  %malloccall = tail call ptr @malloc(i64 400)
   store ptr %malloccall, ptr @G
   %GV = load ptr, ptr @G
   %GVe = getelementptr i32, ptr %GV, i32 40
diff --git a/llvm/test/Transforms/GlobalOpt/malloc-promote-3.ll b/llvm/test/Transforms/GlobalOpt/malloc-promote-3.ll
index ee98e7e2dd86f..082a5095692d4 100644
--- a/llvm/test/Transforms/GlobalOpt/malloc-promote-3.ll
+++ b/llvm/test/Transforms/GlobalOpt/malloc-promote-3.ll
@@ -16,7 +16,7 @@ define void @t() {
 ; CHECK-NEXT:    store i32 20, ptr [[GVE]], align 4
 ; CHECK-NEXT:    ret void
 ;
-  %malloccall = tail call ptr @malloc(i64 mul (i64 100, i64 4)) nobuiltin
+  %malloccall = tail call ptr @malloc(i64 400) nobuiltin
   store ptr %malloccall, ptr @G
   %GV = load ptr, ptr @G
   %GVe = getelementptr i32, ptr %GV, i32 40
diff --git a/llvm/test/Transforms/Inline/last-callsite.ll b/llvm/test/Transforms/Inline/last-callsite.ll
index 87c1ea8adbc1e..ce800b68a825a 100644
--- a/llvm/test/Transforms/Inline/last-callsite.ll
+++ b/llvm/test/Transforms/Inline/last-callsite.ll
@@ -261,9 +261,11 @@ entry:
   ; a second use. If this part starts failing we need to use more complex
   ; constant expressions to reference a particular function with them.
   %sink = alloca i64
-  store volatile i64 mul (i64 ptrtoint (ptr @test4_g to i64), i64 ptrtoint(ptr @test4_g to i64)), ptr %sink
+  %mul = mul i64 ptrtoint (ptr @test4_g to i64), ptrtoint(ptr @test4_g to i64)
+  store volatile i64 %mul, ptr %sink
   call void @test4_g(i1 true)
-; CHECK: store volatile i64 mul (i64 ptrtoint (ptr @test4_g to i64), i64 ptrtoint (ptr @test4_g to i64)), ptr %sink
+; CHECK: %mul = mul i64 ptrtoint (ptr @test4_g to i64), ptrtoint (ptr @test4_g to i64)
+; CHECK: store volatile i64 %mul, ptr %sink
 ; CHECK: call void @test4_g(i1 true)
 
   ret void
diff --git a/llvm/test/Transforms/InstCombine/force-opaque-ptr.ll b/llvm/test/Transforms/InstCombine/force-opaque-ptr.ll
index 6181aafa4f422..7fbf8bb49abbb 100644
--- a/llvm/test/Transforms/InstCombine/force-opaque-ptr.ll
+++ b/llvm/test/Transforms/InstCombine/force-opaque-ptr.ll
@@ -20,7 +20,13 @@ define ptr @gep_constexpr_gv_2() {
 ; Silly expression to get an inttoptr that does not combine with the GEP.
 define ptr @gep_constexpr_inttoptr() {
 ; CHECK-LABEL: @gep_constexpr_inttoptr(
-; CHECK-NEXT:    ret ptr getelementptr (i8, ptr inttoptr (i64 mul (i64 ptrtoint (ptr @g to i64), i64 2) to ptr), i64 20)
+; CHECK-NEXT:    [[MUL:%.*]] = shl i64 ptrtoint (ptr @g to i64), 1
+; CHECK-NEXT:    [[INTTOPTR:%.*]] = inttoptr i64 [[MUL]] to ptr
+; CHECK-NEXT:    [[GEP:%.*]] = getelementptr i8, ptr [[INTTOPTR]], i64 20
+; CHECK-NEXT:    ret ptr [[GEP]]
 ;
-  ret ptr getelementptr([16 x i16], ptr inttoptr (i64 mul (i64 ptrtoint (ptr @g to i64), i64 2) to ptr), i64 0, i64 10)
+  %mul = mul i64 ptrtoint (ptr @g to i64), 2
+  %inttoptr = inttoptr i64 %mul to ptr
+  %gep = getelementptr [16 x i16], ptr %inttoptr, i64 0, i64 10
+  ret ptr %gep
 }
diff --git a/llvm/test/Transforms/InstCombine/malloc-free.ll b/llvm/test/Transforms/InstCombine/malloc-free.ll
index 10725950a1c73..1f556821270a2 100644
--- a/llvm/test/Transforms/InstCombine/malloc-free.ll
+++ b/llvm/test/Transforms/InstCombine/malloc-free.ll
@@ -9,7 +9,8 @@ define i32 @main(i32 %argc, ptr %argv) {
 ; CHECK-NEXT:    ret i32 0
 ;
   %c_19 = alloca ptr
-  %malloc_206 = tail call ptr @malloc(i32 mul (i32 ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i32), i32 10))
+  %mul = mul i32 ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i32), 10
+  %malloc_206 = tail call ptr @malloc(i32 %mul)
   store ptr %malloc_206, ptr %c_19
   %tmp_207 = load ptr, ptr %c_19
   tail call void @free(ptr %tmp_207)
diff --git a/llvm/test/Transforms/MemCpyOpt/memmove.ll b/llvm/test/Transforms/MemCpyOpt/memmove.ll
index 69114ab5dc612..b906a39e9645d 100644
--- a/llvm/test/Transforms/MemCpyOpt/memmove.ll
+++ b/llvm/test/Transforms/MemCpyOpt/memmove.ll
@@ -12,13 +12,16 @@ declare void @llvm.memmove.p0.p0.i64(ptr nocapture, ptr nocapture, i64, i1) noun
 define ptr @test1(ptr nocapture %src) nounwind {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[MALLOCCALL:%.*]] = tail call ptr @malloc(i32 trunc (i64 mul nuw (i64 ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64), i64 13) to i32))
+; CHECK-NEXT:    [[MUL:%.*]] = mul nuw i64 ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64), 13
+; CHECK-NEXT:    [[TRUNC:%.*]] = trunc i64 [[MUL]] to i32
+; CHECK-NEXT:    [[MALLOCCALL:%.*]] = tail call ptr @malloc(i32 [[TRUNC]])
 ; CHECK-NEXT:    tail call void @llvm.memcpy.p0.p0.i64(ptr [[MALLOCCALL]], ptr [[SRC:%.*]], i64 13, i1 false)
 ; CHECK-NEXT:    ret ptr [[MALLOCCALL]]
 ;
 entry:
-
-  %malloccall = tail call ptr @malloc(i32 trunc (i64 mul nuw (i64 ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64), i64 13) to i32))
+  %mul = mul nuw i64 ptrtoint (ptr getelementptr (i8, ptr null, i32 1) to i64), 13
+  %trunc = trunc i64 %mul to i32
+  %malloccall = tail call ptr @malloc(i32 %trunc)
   tail call void @llvm.memmove.p0.p0.i64(ptr %malloccall, ptr %src, i64 13, i1 false)
   ret ptr %malloccall
 }
diff --git a/llvm/test/Transforms/NewGVN/2009-11-12-MemDepMallocBitCast.ll b/llvm/test/Transforms/NewGVN/2009-11-12-MemDepMallocBitCast.ll
index 10a76a9d6d01f..5fc2125db0990 100644
--- a/llvm/test/Transforms/NewGVN/2009-11-12-MemDepMallocBitCast.ll
+++ b/llvm/test/Transforms/NewGVN/2009-11-12-MemDepMallocBitCast.ll
@@ -5,12 +5,14 @@
 
 define i64 @test() {
 ; CHECK-LABEL: define i64 @test() {
-; CHECK-NEXT:    [[TMP1:%.*]] = tail call ptr @malloc(i64 mul (i64 4, i64 ptrtoint (ptr getelementptr (i64, ptr null, i64 1) to i64)))
+; CHECK-NEXT:    [[MUL:%.*]] = mul i64 4, ptrtoint (ptr getelementptr (i64, ptr null, i64 1) to i64)
+; CHECK-NEXT:    [[TMP1:%.*]] = tail call ptr @malloc(i64 [[MUL]])
 ; CHECK-NEXT:    store i8 42, ptr [[TMP1]], align 1
 ; CHECK-NEXT:    [[Y:%.*]] = load i64, ptr [[TMP1]], align 4
 ; CHECK-NEXT:    ret i64 [[Y]]
 ;
-  %1 = tail call ptr @malloc(i64 mul (i64 4, i64 ptrtoint (ptr getelementptr (i64, ptr null, i64 1) to i64))) ; <ptr> [#uses=2]
+  %mul = mul i64 4, ptrtoint (ptr getelementptr (i64, ptr null, i64 1) to i64)
+  %1 = tail call ptr @malloc(i64 %mul)
   store i8 42, ptr %1
   %Y = load i64, ptr %1                               ; <i64> [#uses=1]
   ret i64 %Y
diff --git a/llvm/test/Transforms/SimplifyCFG/ARM/switch-to-lookup-table-constant-expr.ll b/llvm/test/Transforms/SimplifyCFG/ARM/switch-to-lookup-table-constant-expr.ll
index a453e9a9b35f1..279a779455bd6 100644
--- a/llvm/test/Transforms/SimplifyCFG/ARM/switch-to-lookup-table-constant-expr.ll
+++ b/llvm/test/Transforms/SimplifyCFG/ARM/switch-to-lookup-table-constant-expr.ll
@@ -28,7 +28,7 @@ define ptr @test3(i32 %n) {
 ; CHECK:       sw.default:
 ; CHECK-NEXT:    br label [[RETURN]]
 ; CHECK:       return:
-; CHECK-NEXT:    [[RETVAL_0:%.*]] = phi ptr [ @g4, [[SW_DEFAULT]] ], [ getelementptr inbounds (i32, ptr inttoptr (i32 mul (i32 ptrtoint (ptr @g3 to i32), i32 2) to ptr), i32 1), [[SW_BB2]] ], [ @g2, [[SW_BB1]] ], [ @g1, [[ENTRY:%.*]] ]
+; CHECK-NEXT:    [[RETVAL_0:%.*]] = phi ptr [ @g4, [[SW_DEFAULT]] ], [ getelementptr inbounds (i32, ptr inttoptr (i32 add (i32 ptrtoint (ptr @g3 to i32), i32 2) to ptr), i32 1), [[SW_BB2]] ], [ @g2, [[SW_BB1]] ], [ @g1, [[ENTRY:%.*]] ]
 ; CHECK-NEXT:    ret ptr [[RETVAL_0]]
 ;
 entry:
@@ -51,6 +51,6 @@ sw.default:
   br label %return
 
 return:
-  %retval.0 = phi ptr [ @g4, %sw.default ], [ getelementptr inbounds (i32, ptr inttoptr (i32 mul (i32 ptrtoint (ptr @g3 to i32), i32 2) to ptr), i32 1), %sw.bb2 ], [ @g2, %sw.bb1 ], [ @g1, %sw.bb ]
+  %retval.0 = phi ptr [ @g4, %sw.default ], [ getelementptr inbounds (i32, ptr inttoptr (i32 add (i32 ptrtoint (ptr @g3 to i32), i32 2) to ptr), i32 1), %sw.bb2 ], [ @g2, %sw.bb1 ], [ @g1, %sw.bb ]
   ret ptr %retval.0
 }
diff --git a/llvm/unittests/IR/ConstantsTest.cpp b/llvm/unittests/IR/ConstantsTest.cpp
index 53ebe52b4f21b..a46178abd9066 100644
--- a/llvm/unittests/IR/ConstantsTest.cpp
+++ b/llvm/unittests/IR/ConstantsTest.cpp
@@ -64,7 +64,7 @@ TEST(ConstantsTest, Integer_i1) {
 
   // @n = constant i1 mul(i1 -1, i1 1)
   // @n = constant i1 true
-  EXPECT_EQ(One, ConstantExpr::getMul(NegOne, One));
+  EXPECT_EQ(One, ConstantFoldBinaryInstruction(Instruction::Mul, NegOne, One));
 
   // @o = constant i1 sdiv(i1 -1, i1 1) ; overflow
   // @o = constant i1 true
@@ -213,7 +213,6 @@ TEST(ConstantsTest, AsInstructionsTest) {
   CHECK(ConstantExpr::getAdd(P0, P0, true, true),
         "add nuw nsw i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getSub(P0, P0), "sub i32 " P0STR ", " P0STR);
-  CHECK(ConstantExpr::getMul(P0, P0), "mul i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getXor(P0, P0), "xor i32 " P0STR ", " P0STR);
 
   std::vector<Constant *> V;