[ConstProp] Remove ConstantPropagation

[aeubanks]

Summary

As discussed in
http://lists.llvm.org/pipermail/llvm-dev/2020-July/143801.html.

Currently no users outside of unit tests.

Replace all instances in tests of -constprop with -instsimplify.
Notable changes in tests:

• vscale.ll - @llvm.sadd.sat.nxv16i8 is evaluated by instsimplify, use a fake intrinsic instead
• InsertElement.ll - insertelement undef is removed by instsimplify in @insertelement_undef

llvm/test/Transforms/ConstProp moved to llvm/test/Transforms/InstSimplify/ConstProp

[aeubanks]

Rebase

[fhahn]

llvm/test/Analysis/ConstantFolding/vscale.ll

210

why are those removed? Is that functionality missing from instsimplify?

llvm/test/Transforms/ConstProp/bitcast.ll

2

I think we should probably move the tests to the instsimplify dir?

[lattner]

nice, thanks for cleaning this up!

[aeubanks]

Move tests into InstSimplify/ConstProp

[aeubanks]

llvm/test/Analysis/ConstantFolding/vscale.ll

210

Looks like in ConstProp it always calls ConstantFoldInstruction(), which in this case just returns the same value, and replaces all uses, inlining into the ret. But InstSimplify calls SimplifyInstruction() which special cases vector instructions but doesn't know how to simplify these values any more, so it returns nullptr and InstSimplify doesn't do anything.

Maybe inlining these values into the ret isn't super useful?

[nikic]

llvm/test/Analysis/ConstantFolding/vscale.ll

210

Sounds like an InstSimplify bug. SimplifyInstruction is supposed to be a superset of ConstantFoldInstruction.

[aeubanks]

llvm/test/Analysis/ConstantFolding/vscale.ll

210

I took a look at this. It seems like insertelement constants aren't handled as well as insertelement instructions.

For example, at [1], an instruction is properly handled, causing

define i32 @foo() {
  %v = insertelement <vscale x 4 x i32> undef, i32 1, i64 4
  %r = extractelement <vscale x 4 x i32> %v, i64 4
  ret i32 %r
}

to become

define i32 @foo() {
  ret i32 1
}

But if we start inlining vector constants then it ends up at

define i32 @foo() {
  ret i32 extractelement (<vscale x 4 x i32> insertelement (<vscale x 4 x i32> undef, i32 1, i64 4), i64 4)
}

since llvm::findScalarElement doesn't properly handle insertelement constants.

This can of course be fixed (I'm struggling to figure out how to peek into an InsertElementConstantExpr though...), but I wonder about the extra work of handling both insertelement instructions and constants everywhere and how maintainable that is.

Thoughts?

[1]: https://github.com/llvm/llvm-project/blob/fb04d7b4a69831f6b999b1776da738557b108e0d/llvm/lib/Analysis/VectorUtils.cpp#L282

[aeubanks]

Rebase after instsimplify fixes

[nikic]

Can you please also move Analysis/ConstantFolding/* and Other/2002-03-11-ConstPropCrash.ll into Transforms/InstSimplify?

llvm/test/Transforms/Inline/externally_available.ll

1

I'd drop the -constprop from this test entirely and regenerate check lines. It doesn't really look relevant.

llvm/test/Transforms/Reassociate/2002-05-15-SubReassociate.ll

2

The -instsimplify here can probably just dropped (instcombine already does instsimplify internally). Same for the other llvm/test/Transforms/Reassociate tests.

[aeubanks]

Move more tests into Transforms/InstSimplify/ConstProp
Rebase past https://reviews.llvm.org/D86653

[aeubanks]

llvm/test/Analysis/ConstantFolding/vscale.ll

210

Actually now these are fixed, see the description for what test changes have been made, should be better now.

llvm/test/Transforms/Inline/externally_available.ll

1

Done in https://reviews.llvm.org/D86653

llvm/test/Transforms/Reassociate/2002-05-15-SubReassociate.ll

2

Done in https://reviews.llvm.org/D86653

[nikic]

LGTM

[gribozavr2]

@aeubanks This change seems to have broken an OCaml test. Could you please take a look and push a fix at your earliest convenience?

Before: http://lab.llvm.org:8011/builders/clang-x86_64-debian-fast/builds/35253

After: http://lab.llvm.org:8011/builders/clang-x86_64-debian-fast/builds/35254

[aeubanks]

Sorry, I thought I fixed that shortly after in 82875dcf, but apparently I
missed some more, hopefully fixed in dd04fa17. Let me know if there are
still issues.

[sroland]

mesa/llvmpipe was using this pass, so it doesn't build anymore. If the proposed replacement is the InstSimplifyLegacyPass that's fine, however the old one was nicely available via the c interface (LLVMAddConstantPropagationPass) whereas the InstSimplifyLegacyPass is not.
(I'd note that we only use very few passes, and they are perhaps not optimal, but the goal is to avoid any expensive passes while still getting some optimization. So, not really insisting on InstSimplifyLegacyPass neither if there are other suitable replacements doing roughly the same thing - it would be nice though if we'd not have to do our own c++ wrapper as we try to avoid that when possible.)

[aeubanks]

Yeah InstSimplify really should be used anywhere ConstProp is being used,
adding C bindings for it in https://reviews.llvm.org/D86764.

llvm/bindings/go/llvm/executionengine_test.go

if err != nil {
     t.Errorf("Error creating JIT: %s", err)
     return
   }
   defer engine.Dispose()
 
   pass := NewPassManager()
   defer pass.Dispose()
 
-  pass.AddConstantPropagationPass()
   pass.AddInstructionCombiningPass()
   pass.AddPromoteMemoryToRegisterPass()
   pass.AddGVNPass()
   pass.AddCFGSimplificationPass()
   pass.Run(mod)
 
   exec_args := []GenericValue{NewGenericValueFromInt(Int32Type(), 10, false)}
   exec_res := engine.RunFunction(fac, exec_args)
   var fac10 uint64 = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1
   if exec_res.Int(false) != fac10 {
     t.Errorf("Expected %d, got %d", fac10, exec_res.Int(false))
   }
 }

llvm/bindings/go/llvm/transforms_scalar.go

 func (pm PassManager) AddReassociatePass()             { C.LLVMAddReassociatePass(pm.C) }
 func (pm PassManager) AddSCCPPass()                    { C.LLVMAddSCCPPass(pm.C) }
 func (pm PassManager) AddScalarReplAggregatesPass()    { C.LLVMAddScalarReplAggregatesPass(pm.C) }
 func (pm PassManager) AddScalarReplAggregatesPassWithThreshold(threshold int) {
   C.LLVMAddScalarReplAggregatesPassWithThreshold(pm.C, C.int(threshold))
 }
 func (pm PassManager) AddSimplifyLibCallsPass()       { C.LLVMAddSimplifyLibCallsPass(pm.C) }
 func (pm PassManager) AddTailCallEliminationPass()    { C.LLVMAddTailCallEliminationPass(pm.C) }
-func (pm PassManager) AddConstantPropagationPass()    { C.LLVMAddConstantPropagationPass(pm.C) }
 func (pm PassManager) AddDemoteMemoryToRegisterPass() { C.LLVMAddDemoteMemoryToRegisterPass(pm.C) }
 func (pm PassManager) AddVerifierPass()               { C.LLVMAddVerifierPass(pm.C) }

llvm/bindings/ocaml/transforms/scalar_opts/llvm_scalar_opts.mli

external add_lib_call_simplification
   : [< Llvm.PassManager.any ] Llvm.PassManager.t -> unit
   = "llvm_add_simplify_lib_calls"
 
 (** See the [llvm::createTailCallEliminationPass] function. *)
 external add_tail_call_elimination
   : [< Llvm.PassManager.any ] Llvm.PassManager.t -> unit
   = "llvm_add_tail_call_elimination"
 
-(** See the [llvm::createConstantPropagationPass] function. *)
-external add_constant_propagation
-  : [< Llvm.PassManager.any ] Llvm.PassManager.t -> unit
-  = "llvm_add_constant_propagation"
-
 (** See the [llvm::createDemoteMemoryToRegisterPass] function. *)
 external add_memory_to_register_demotion
   : [< Llvm.PassManager.any ] Llvm.PassManager.t -> unit
   = "llvm_add_demote_memory_to_register"
 
 (** See the [llvm::createVerifierPass] function. *)
 external add_verifier
   : [< Llvm.PassManager.any ] Llvm.PassManager.t -> unit

llvm/bindings/ocaml/transforms/scalar_opts/scalar_opts_ocaml.c

 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 CAMLprim value llvm_add_tail_call_elimination(LLVMPassManagerRef PM) {
   LLVMAddTailCallEliminationPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
-CAMLprim value llvm_add_constant_propagation(LLVMPassManagerRef PM) {
-  LLVMAddConstantPropagationPass(PM);
-  return Val_unit;
-}
-
-/* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 CAMLprim value llvm_add_demote_memory_to_register(LLVMPassManagerRef PM) {
   LLVMAddDemoteMemoryToRegisterPass(PM);
   return Val_unit;
 }
 
 /* [<Llvm.PassManager.any] Llvm.PassManager.t -> unit */
 CAMLprim value llvm_add_verifier(LLVMPassManagerRef PM) {
   LLVMAddVerifierPass(PM);

llvm/docs/CommandLine.rst

 .. _lists:
 
 Parsing a list of options
 -------------------------
 
 Now that we have the standard run-of-the-mill argument types out of the way,
 lets get a little wild and crazy.  Lets say that we want our optimizer to accept
 a **list** of optimizations to perform, allowing duplicates.  For example, we
-might want to run: "``compiler -dce -constprop -inline -dce -strip``".  In this
+might want to run: "``compiler -dce -instsimplify -inline -dce -strip``".  In this
 case, the order of the arguments and the number of appearances is very
 important.  This is what the "``cl::list``" template is for.  First, start by
 defining an enum of the optimizations that you would like to perform:
 
 .. code-block:: c++
 
   enum Opts {
     // 'inline' is a C++ keyword, so name it 'inlining'
-    dce, constprop, inlining, strip
+    dce, instsimplify, inlining, strip
   };
 
 Then define your "``cl::list``" variable:
 
 .. code-block:: c++
 
   cl::list<Opts> OptimizationList(cl::desc("Available Optimizations:"),
     cl::values(
       clEnumVal(dce               , "Dead Code Elimination"),
-      clEnumVal(constprop         , "Constant Propagation"),
+      clEnumVal(instsimplify      , "Instruction Simplification"),
      clEnumValN(inlining, "inline", "Procedure Integration"),
       clEnumVal(strip             , "Strip Symbols")));
 
 This defines a variable that is conceptually of the type
 "``std::vector<enum Opts>``".  Thus, you can access it with standard vector
 methods:
 
 .. code-block:: c++

 
 Reworking the above list example, we could replace `cl::list`_ with `cl::bits`_:
 
 .. code-block:: c++
 
   cl::bits<Opts> OptimizationBits(cl::desc("Available Optimizations:"),
     cl::values(
       clEnumVal(dce               , "Dead Code Elimination"),
-      clEnumVal(constprop         , "Constant Propagation"),
+      clEnumVal(instsimplify      , "Instruction Simplification"),
      clEnumValN(inlining, "inline", "Procedure Integration"),
       clEnumVal(strip             , "Strip Symbols")));
 
-To test to see if ``constprop`` was specified, we can use the ``cl:bits::isSet``
+To test to see if ``instsimplify`` was specified, we can use the ``cl:bits::isSet``
 function:
 
 .. code-block:: c++
 
-  if (OptimizationBits.isSet(constprop)) {
+  if (OptimizationBits.isSet(instsimplify)) {
     ...
   }
 
 It's also possible to get the raw bit vector using the ``cl::bits::getBits``
 function:
 
 .. code-block:: c++
 

llvm/docs/Passes.rst

 ``-constmerge``: Merge Duplicate Global Constants
 -------------------------------------------------
 
 Merges duplicate global constants together into a single constant that is
 shared.  This is useful because some passes (i.e., TraceValues) insert a lot of
 string constants into the program, regardless of whether or not an existing
 string is available.
 
-``-constprop``: Simple constant propagation
--------------------------------------------
-
-This pass implements constant propagation and merging.  It looks for
-instructions involving only constant operands and replaces them with a constant
-value instead of an instruction.  For example:
-
-.. code-block:: llvm
-
-  add i32 1, 2
-
-becomes
-
-.. code-block:: llvm
-
-  i32 3
-
-NOTE: this pass has a habit of making definitions be dead.  It is a good idea
-to run a :ref:`Dead Instruction Elimination <passes-die>` pass sometime after
-running this pass.
-
 .. _passes-dce:
 
 ``-dce``: Dead Code Elimination
 -------------------------------
 
 Dead code elimination is similar to :ref:`dead instruction elimination
 <passes-die>`, but it rechecks instructions that were used by removed
 instructions to see if they are newly dead.

llvm/include/llvm-c/Transforms/Scalar.h

void LLVMAddScalarReplAggregatesPassWithThreshold(LLVMPassManagerRef PM,
                                                   int Threshold);
 
 /** See llvm::createSimplifyLibCallsPass function. */
 void LLVMAddSimplifyLibCallsPass(LLVMPassManagerRef PM);
 
 /** See llvm::createTailCallEliminationPass function. */
 void LLVMAddTailCallEliminationPass(LLVMPassManagerRef PM);
 
-/** See llvm::createConstantPropagationPass function. */
-void LLVMAddConstantPropagationPass(LLVMPassManagerRef PM);
-
 /** See llvm::demotePromoteMemoryToRegisterPass function. */
 void LLVMAddDemoteMemoryToRegisterPass(LLVMPassManagerRef PM);
 
 /** See llvm::createVerifierPass function. */
 void LLVMAddVerifierPass(LLVMPassManagerRef PM);
 
 /** See llvm::createCorrelatedValuePropagationPass function */
 void LLVMAddCorrelatedValuePropagationPass(LLVMPassManagerRef PM);

llvm/include/llvm/InitializePasses.h

 void initializeCallGraphPrinterLegacyPassPass(PassRegistry&);
 void initializeCallGraphViewerPass(PassRegistry&);
 void initializeCallGraphWrapperPassPass(PassRegistry&);
 void initializeCallSiteSplittingLegacyPassPass(PassRegistry&);
 void initializeCalledValuePropagationLegacyPassPass(PassRegistry &);
 void initializeCodeGenPreparePass(PassRegistry&);
 void initializeConstantHoistingLegacyPassPass(PassRegistry&);
 void initializeConstantMergeLegacyPassPass(PassRegistry&);
-void initializeConstantPropagationPass(PassRegistry&);
 void initializeControlHeightReductionLegacyPassPass(PassRegistry&);
 void initializeCorrelatedValuePropagationPass(PassRegistry&);
 void initializeCostModelAnalysisPass(PassRegistry&);
 void initializeCrossDSOCFIPass(PassRegistry&);
 void initializeDAEPass(PassRegistry&);
 void initializeDAHPass(PassRegistry&);
 void initializeDCELegacyPassPass(PassRegistry&);
 void initializeDSELegacyPassPass(PassRegistry&);

llvm/include/llvm/LinkAllPasses.h

ForcePassLinking() {
       (void) llvm::createCallGraphViewerPass();
       (void) llvm::createCFGSimplificationPass();
       (void) llvm::createCFLAndersAAWrapperPass();
       (void) llvm::createCFLSteensAAWrapperPass();
       (void) llvm::createStructurizeCFGPass();
       (void) llvm::createLibCallsShrinkWrapPass();
       (void) llvm::createCalledValuePropagationPass();
       (void) llvm::createConstantMergePass();
-      (void) llvm::createConstantPropagationPass();
       (void) llvm::createControlHeightReductionLegacyPass();
       (void) llvm::createCostModelAnalysisPass();
       (void) llvm::createDeadArgEliminationPass();
       (void) llvm::createDeadCodeEliminationPass();
       (void) llvm::createDeadInstEliminationPass();
       (void) llvm::createDeadStoreEliminationPass();
       (void) llvm::createDependenceAnalysisWrapperPass();
       (void) llvm::createDomOnlyPrinterPass();

llvm/include/llvm/Transforms/Scalar.h

 
 class Function;
 class FunctionPass;
 class ModulePass;
 class Pass;
 
 //===----------------------------------------------------------------------===//
 //
-// ConstantPropagation - A worklist driven constant propagation pass
-//
-FunctionPass *createConstantPropagationPass();
-
-//===----------------------------------------------------------------------===//
-//
 // AlignmentFromAssumptions - Use assume intrinsics to set load/store
 // alignments.
 //
 FunctionPass *createAlignmentFromAssumptionsPass();
 
 //===----------------------------------------------------------------------===//
 //
 // SCCP - Sparse conditional constant propagation.

llvm/lib/Transforms/Scalar/CMakeLists.txt

 add_llvm_component_library(LLVMScalarOpts
   ADCE.cpp
   AlignmentFromAssumptions.cpp
   BDCE.cpp
   CallSiteSplitting.cpp
   ConstantHoisting.cpp
-  ConstantProp.cpp
   CorrelatedValuePropagation.cpp
   DCE.cpp
   DeadStoreElimination.cpp
   DivRemPairs.cpp
   EarlyCSE.cpp
   FlattenCFGPass.cpp
   Float2Int.cpp
   GuardWidening.cpp

llvm/lib/Transforms/Scalar/ConstantProp.cpp

-//===- ConstantProp.cpp - Code to perform Simple Constant Propagation -----===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements constant propagation and merging:
-//
-// Specifically, this:
-//   * Converts instructions like "add int 1, 2" into 3
-//
-// Notice that:
-//   * This pass has a habit of making definitions be dead.  It is a good idea
-//     to run a DIE pass sometime after running this pass.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/ADT/SmallPtrSet.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/Statistic.h"
-#include "llvm/Analysis/ConstantFolding.h"
-#include "llvm/Analysis/TargetLibraryInfo.h"
-#include "llvm/IR/Constant.h"
-#include "llvm/IR/InstIterator.h"
-#include "llvm/IR/Instruction.h"
-#include "llvm/InitializePasses.h"
-#include "llvm/Pass.h"
-#include "llvm/Support/DebugCounter.h"
-#include "llvm/Transforms/Scalar.h"
-#include "llvm/Transforms/Utils/Local.h"
-using namespace llvm;
-
-#define DEBUG_TYPE "constprop"
-
-STATISTIC(NumInstKilled, "Number of instructions killed");
-DEBUG_COUNTER(CPCounter, "constprop-transform",
-              "Controls which instructions are killed");
-
-namespace {
-  struct ConstantPropagation : public FunctionPass {
-    static char ID; // Pass identification, replacement for typeid
-    ConstantPropagation() : FunctionPass(ID) {
-      initializeConstantPropagationPass(*PassRegistry::getPassRegistry());
-    }
-
-    bool runOnFunction(Function &F) override;
-
-    void getAnalysisUsage(AnalysisUsage &AU) const override {
-      AU.setPreservesCFG();
-      AU.addRequired<TargetLibraryInfoWrapperPass>();
-    }
-  };
-}
-
-char ConstantPropagation::ID = 0;
-INITIALIZE_PASS_BEGIN(ConstantPropagation, "constprop",
-                "Simple constant propagation", false, false)
-INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
-INITIALIZE_PASS_END(ConstantPropagation, "constprop",
-                "Simple constant propagation", false, false)
-
-FunctionPass *llvm::createConstantPropagationPass() {
-  return new ConstantPropagation();
-}
-
-bool ConstantPropagation::runOnFunction(Function &F) {
-  if (skipFunction(F))
-    return false;
-
-  // Initialize the worklist to all of the instructions ready to process...
-  SmallPtrSet<Instruction *, 16> WorkList;
-  // The SmallVector of WorkList ensures that we do iteration at stable order.
-  // We use two containers rather than one SetVector, since remove is
-  // linear-time, and we don't care enough to remove from Vec.
-  SmallVector<Instruction *, 16> WorkListVec;
-  for (Instruction &I : instructions(&F)) {
-    WorkList.insert(&I);
-    WorkListVec.push_back(&I);
-  }
-
-  bool Changed = false;
-  const DataLayout &DL = F.getParent()->getDataLayout();
-  TargetLibraryInfo *TLI =
-      &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
-
-  while (!WorkList.empty()) {
-    SmallVector<Instruction*, 16> NewWorkListVec;
-    for (auto *I : WorkListVec) {
-      WorkList.erase(I); // Remove element from the worklist...
-
-      if (!I->use_empty()) // Don't muck with dead instructions...
-        if (Constant *C = ConstantFoldInstruction(I, DL, TLI)) {
-          if (!DebugCounter::shouldExecute(CPCounter))
-            continue;
-
-          // Add all of the users of this instruction to the worklist, they might
-          // be constant propagatable now...
-          for (User *U : I->users()) {
-            // If user not in the set, then add it to the vector.
-            if (WorkList.insert(cast<Instruction>(U)).second)
-              NewWorkListVec.push_back(cast<Instruction>(U));
-          }
-
-          // Replace all of the uses of a variable with uses of the constant.
-          I->replaceAllUsesWith(C);
-
-          if (isInstructionTriviallyDead(I, TLI)) {
-            I->eraseFromParent();
-            ++NumInstKilled;
-          }
-
-          // We made a change to the function...
-          Changed = true;
-        }
-    }
-    WorkListVec = std::move(NewWorkListVec);
-  }
-  return Changed;
-}

llvm/lib/Transforms/Scalar/Scalar.cpp

 /// initializeScalarOptsPasses - Initialize all passes linked into the
 /// ScalarOpts library.
 void llvm::initializeScalarOpts(PassRegistry &Registry) {
   initializeADCELegacyPassPass(Registry);
   initializeBDCELegacyPassPass(Registry);
   initializeAlignmentFromAssumptionsPass(Registry);
   initializeCallSiteSplittingLegacyPassPass(Registry);
   initializeConstantHoistingLegacyPassPass(Registry);
-  initializeConstantPropagationPass(Registry);
   initializeCorrelatedValuePropagationPass(Registry);
   initializeDCELegacyPassPass(Registry);
   initializeDeadInstEliminationPass(Registry);
   initializeDivRemPairsLegacyPassPass(Registry);
   initializeScalarizerLegacyPassPass(Registry);
   initializeDSELegacyPassPass(Registry);
   initializeGuardWideningLegacyPassPass(Registry);
   initializeLoopGuardWideningLegacyPassPass(Registry);

 void LLVMAddSimplifyLibCallsPass(LLVMPassManagerRef PM) {
   // NOTE: The simplify-libcalls pass has been removed.
 }
 
 void LLVMAddTailCallEliminationPass(LLVMPassManagerRef PM) {
   unwrap(PM)->add(createTailCallEliminationPass());
 }
 
-void LLVMAddConstantPropagationPass(LLVMPassManagerRef PM) {
-  unwrap(PM)->add(createConstantPropagationPass());
-}
-
 void LLVMAddDemoteMemoryToRegisterPass(LLVMPassManagerRef PM) {
   unwrap(PM)->add(createDemoteRegisterToMemoryPass());
 }
 
 void LLVMAddVerifierPass(LLVMPassManagerRef PM) {
   unwrap(PM)->add(createVerifierPass());
 }
 

llvm/test/Analysis/ConstantFolding/abs.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -constprop -S | FileCheck %s
+; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 declare i8 @llvm.abs.i8(i8, i1)
 declare <8 x i8> @llvm.abs.v8i8(<8 x i8>, i1)
 
 define i8 @undef_val_min_poison() {
 ; CHECK-LABEL: @undef_val_min_poison(
 ; CHECK-NEXT:    ret i8 undef
 ;

llvm/test/Analysis/ConstantFolding/binop-identity-undef.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -constprop -S %s | FileCheck %s
+; RUN: opt -instsimplify -S %s | FileCheck %s
 
 define i32 @and1() {
 ; CHECK-LABEL: @and1(
 ; CHECK-NEXT:    ret i32 undef
 ;
   %r = and i32 undef, -1
   ret i32 %r
 }

llvm/test/Analysis/ConstantFolding/bitcount.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -constprop -S | FileCheck %s
+; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 declare i31 @llvm.ctpop.i31(i31 %val)
 declare i32 @llvm.cttz.i32(i32 %val, i1)
 declare i33 @llvm.ctlz.i33(i33 %val, i1)
 declare <2 x i31> @llvm.ctpop.v2i31(<2 x i31> %val)
 declare <2 x i32> @llvm.cttz.v2i32(<2 x i32> %val, i1)
 declare <2 x i33> @llvm.ctlz.v2i33(<2 x i33> %val, i1)
 

llvm/test/Analysis/ConstantFolding/copysign.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -constprop < %s | FileCheck %s
+; RUN: opt -S -instsimplify < %s | FileCheck %s
 
 declare float @llvm.copysign.f32(float, float)
 declare double @llvm.copysign.f64(double, double)
 
 define float @f32_01() {
 ; CHECK-LABEL: @f32_01(
 ; CHECK-NEXT:    ret float -1.000000e+00
 ;

llvm/test/Analysis/ConstantFolding/fneg.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -constprop -S | FileCheck %s
+; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 define float @fneg_constant() {
 ; CHECK-LABEL: @fneg_constant(
 ; CHECK-NEXT:    ret float 0.000000e+00
 ;
   %r = fneg float -0.0
   ret float %r
 }

llvm/test/Analysis/ConstantFolding/fp-undef.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -constprop -S | FileCheck %s
+; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 ; Constant folding - undef undef.
 
 define double @fadd_undef_undef(double %x) {
 ; CHECK-LABEL: @fadd_undef_undef(
 ; CHECK-NEXT:    ret double undef
 ;
   %r = fadd double undef, undef

llvm/test/Analysis/ConstantFolding/freeze.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -constprop -S | FileCheck %s
+; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 @g = external global i16, align 1
 @g2 = external global i16, align 1
 
 define i64 @ptrdiff1() {
 ; CHECK-LABEL: @ptrdiff1(
 ; CHECK-NEXT:    ret i64 sub (i64 ptrtoint (i16* @g to i64), i64 ptrtoint (i16* @g2 to i64))
 ;

llvm/test/Analysis/ConstantFolding/funnel-shift.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -constprop -S -o - | FileCheck %s
+; RUN: opt < %s -instsimplify -S -o - | FileCheck %s
 
 declare i32 @llvm.fshl.i32(i32, i32, i32)
 declare i32 @llvm.fshr.i32(i32, i32, i32)
 declare i7 @llvm.fshl.i7(i7, i7, i7)
 declare i7 @llvm.fshr.i7(i7, i7, i7)
 declare <4 x i8> @llvm.fshl.v4i8(<4 x i8>, <4 x i8>, <4 x i8>)
 declare <4 x i8> @llvm.fshr.v4i8(<4 x i8>, <4 x i8>, <4 x i8>)
 

llvm/test/Analysis/ConstantFolding/gep-zeroinit-vector.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -constprop -S -o - | FileCheck %s
+; RUN: opt < %s -instsimplify -S -o - | FileCheck %s
 
 ; Testcase that verify that we don't get a faulty bitcast that cast between
 ; different sizes.
 
 %rec8 = type { i16 }
 @a = global [1 x %rec8] zeroinitializer
 
 define <2 x i16*> @test_gep() {

llvm/test/Analysis/ConstantFolding/min-max.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -constprop -S < %s | FileCheck %s
+; RUN: opt -instsimplify -S < %s | FileCheck %s
 
 declare float @llvm.minnum.f32(float, float)
 declare <4 x float> @llvm.minnum.v4f32(<4 x float>, <4 x float>)
 
 declare float @llvm.maxnum.f32(float, float)
 declare <4 x float> @llvm.maxnum.v4f32(<4 x float>, <4 x float>)
 
 declare float @llvm.minimum.f32(float, float)

llvm/test/Analysis/ConstantFolding/saturating-add-sub.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -constprop -S | FileCheck %s
+; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 declare i8 @llvm.uadd.sat.i8(i8, i8)
 declare i8 @llvm.sadd.sat.i8(i8, i8)
 declare <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8>, <2 x i8>)
 declare <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8>, <2 x i8>)
 
 declare i8 @llvm.usub.sat.i8(i8, i8)
 declare i8 @llvm.ssub.sat.i8(i8, i8)

llvm/test/Analysis/ConstantFolding/smul-fix-sat.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -constprop -S | FileCheck %s
+; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 ;-----------------------------------------------------------------------------
 ; Simple test using scalar layout.
 ;-----------------------------------------------------------------------------
 
 declare i32 @llvm.smul.fix.sat.i32(i32, i32, i32)
 
 define i32 @test_smul_fix_sat_i32_0() {

llvm/test/Analysis/ConstantFolding/smul-fix.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -constprop -S | FileCheck %s
+; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 ;-----------------------------------------------------------------------------
 ; Simple test using scalar layout.
 ;-----------------------------------------------------------------------------
 
 declare i32 @llvm.smul.fix.i32(i32, i32, i32)
 
 define i32 @test_smul_fix_i32_0() {

llvm/test/Analysis/ConstantFolding/vecreduce.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -constprop -S | FileCheck %s
+; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 declare i32 @llvm.experimental.vector.reduce.add.v1i32(<1 x i32> %a)
 declare i32 @llvm.experimental.vector.reduce.add.v8i32(<8 x i32> %a)
 declare i32 @llvm.experimental.vector.reduce.mul.v1i32(<1 x i32> %a)
 declare i32 @llvm.experimental.vector.reduce.mul.v8i32(<8 x i32> %a)
 declare i32 @llvm.experimental.vector.reduce.and.v1i32(<1 x i32> %a)
 declare i32 @llvm.experimental.vector.reduce.and.v8i32(<8 x i32> %a)
 declare i32 @llvm.experimental.vector.reduce.or.v1i32(<1 x i32> %a)

llvm/test/Analysis/ConstantFolding/vector-undef-elts.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -constprop -S -o - | FileCheck %s
+; RUN: opt < %s -instsimplify -S -o - | FileCheck %s
 
 ; When both operands are undef in a lane, that lane should produce an undef result.
 
 define <3 x i8> @shl() {
 ; CHECK-LABEL: @shl(
 ; CHECK-NEXT:    ret <3 x i8> <i8 undef, i8 0, i8 0>
 ;
   %c = shl <3 x i8> undef, <i8 undef, i8 4, i8 1>

llvm/test/Analysis/ConstantFolding/vscale.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -constprop -S -verify | FileCheck %s
+; RUN: opt < %s -instsimplify -S -verify | FileCheck %s
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Unary Operations
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 define <vscale x 2 x double> @fneg(<vscale x 2 x double> %val) {
 ; CHECK-LABEL: @fneg(
 ; CHECK-NEXT:    ret <vscale x 2 x double> undef

 define <vscale x 4 x i32> @xor() {
 ; CHECK-LABEL: @xor(
 ; CHECK-NEXT:    ret <vscale x 4 x i32> zeroinitializer
 ;
   %r = xor <vscale x 4 x i32> undef, undef
   ret <vscale x 4 x i32> %r
 }
 
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Vector Operations
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-define <vscale x 4 x i32> @insertelement() {
-; CHECK-LABEL: @insertelement(
-; CHECK-NEXT:    ret <vscale x 4 x i32> insertelement (<vscale x 4 x i32> undef, i32 1, i32 0)
-;
-  %i = insertelement <vscale x 4 x i32> undef, i32 1, i32 0
-  ret <vscale x 4 x i32> %i
-}
-
-define <vscale x 4 x i32> @shufflevector() {
-; CHECK-LABEL: @shufflevector(
-; CHECK-NEXT:    ret <vscale x 4 x i32> shufflevector (<vscale x 4 x i32> insertelement (<vscale x 4 x i32> undef, i32 1, i32 0), <vscale x 4 x i32> undef, <vscale x 4 x i32> zeroinitializer)
-;
-  %i = insertelement <vscale x 4 x i32> undef, i32 1, i32 0
-  %i2 = shufflevector <vscale x 4 x i32> %i, <vscale x 4 x i32> undef, <vscale x 4 x i32> zeroinitializer
-  ret <vscale x 4 x i32> %i2
-}
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Memory Access and Addressing Operations
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 define <vscale x 2 x double> @load() {
 ; CHECK-LABEL: @load(
 ; CHECK-NEXT:    [[R:%.*]] = load <vscale x 2 x double>, <vscale x 2 x double>* getelementptr (<vscale x 2 x double>, <vscale x 2 x double>* null, i64 1)
 ; CHECK-NEXT:    ret <vscale x 2 x double> [[R]]
 ;
   %r = load <vscale x 2 x double>, <vscale x 2 x double>* getelementptr (<vscale x 2 x double>, <vscale x 2 x double>* null, i64 1)
   ret <vscale x 2 x double> %r
 }
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Conversion Operations
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-define <vscale x 4 x float> @bitcast() {
-; CHECK-LABEL: @bitcast(
-; CHECK-NEXT:    ret <vscale x 4 x float> bitcast (<vscale x 4 x i32> shufflevector (<vscale x 4 x i32> insertelement (<vscale x 4 x i32> undef, i32 1, i32 0), <vscale x 4 x i32> undef, <vscale x 4 x i32> zeroinitializer) to <vscale x 4 x float>)
-;
-  %i1 = insertelement <vscale x 4 x i32> undef, i32 1, i32 0
-  %i2 = shufflevector <vscale x 4 x i32> %i1, <vscale x 4 x i32> undef, <vscale x 4 x i32> zeroinitializer
-  %i3 = bitcast <vscale x 4 x i32> %i2 to <vscale x 4 x float>
-  ret <vscale x 4 x float> %i3
-}
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Other Operations
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 define <vscale x 4 x i32> @select() {
 ; CHECK-LABEL: @select(
 ; CHECK-NEXT:    ret <vscale x 4 x i32> undef
 ;
   %r = select <vscale x 4 x i1> undef, <vscale x 4 x i32> zeroinitializer, <vscale x 4 x i32> undef
   ret <vscale x 4 x i32> %r
 }
 
 declare <vscale x 16 x i8> @llvm.sadd.sat.nxv16i8(<vscale x 16 x i8>, <vscale x 16 x i8>)
 
-define <vscale x 16 x i8> @call() {
-; CHECK-LABEL: @call(
-; CHECK-NEXT:    [[R:%.*]] = call <vscale x 16 x i8> @llvm.sadd.sat.nxv16i8(<vscale x 16 x i8> undef, <vscale x 16 x i8> undef)
-; CHECK-NEXT:    ret <vscale x 16 x i8> [[R]]
-;
-  %r =  call <vscale x 16 x i8> @llvm.sadd.sat.nxv16i8(<vscale x 16 x i8> undef, <vscale x 16 x i8> undef)
-  ret <vscale x 16 x i8> %r
-}
-
 define <vscale x 4 x i1> @icmp_undef() {
 ; CHECK-LABEL: @icmp_undef(
 ; CHECK-NEXT:    ret <vscale x 4 x i1> undef
 ;
   %r = icmp eq <vscale x 4 x i32> undef, undef
   ret <vscale x 4 x i1> %r
 }
 

llvm/test/Assembler/2002-04-07-HexFloatConstants.ll

 ; This testcase checks to make sure that the assembler can handle floating 
 ; point constants in IEEE hex format. This also checks that the disassembler,
 ; when presented with a FP constant that cannot be represented exactly in 
 ; exponential form, outputs it correctly in hex format.  This is a distillation
 ; of the bug that was causing the Olden Health benchmark to output incorrect
 ; results!
 ;
-; RUN: opt -constprop -S > %t.1 < %s
-; RUN: llvm-as < %s | llvm-dis | llvm-as | opt -constprop | \
+; RUN: opt -instsimplify -S > %t.1 < %s
+; RUN: llvm-as < %s | llvm-dis | llvm-as | opt -instsimplify | \
 ; RUN: llvm-dis > %t.2
 ; RUN: diff %t.1 %t.2
 ; RUN: verify-uselistorder %s
 
 define double @test() {
         %tmp = fmul double 7.200000e+101, 0x427F4000             ; <double> [#uses=1]
         ret double %tmp
 }

llvm/test/Bitcode/extractelement.ll

-; RUN: opt < %s -constprop | llvm-dis -disable-output
+; RUN: opt < %s -instsimplify | llvm-dis -disable-output
 ; RUN: verify-uselistorder < %s
 ; PR3465
 
 define double @test() {
   %tmp24 = extractelement <2 x double> bitcast (<1 x i128> < i128 85070591730234615870450834276742070272 > to <2 x double>), i32 0
   ret double %tmp24
 }
 

llvm/test/Other/2002-03-11-ConstPropCrash.ll

 ; When constant propogating terminator instructions, the basic block iterator
 ; was not updated to refer to the final position of the new terminator.  This
 ; can be bad, f.e. because constproping a terminator can lead to the 
 ; destruction of PHI nodes, which invalidates the iterator!
 ;
 ; Fixed by adding new arguments to ConstantFoldTerminator
 ;
-; RUN: opt < %s -constprop
+; RUN: opt < %s -instsimplify
 
 define void @build_tree(i32 %ml) {
 ; <label>:0
         br label %bb2
 
 bb2:            ; preds = %bb2, %0
         %reg137 = phi i32 [ %reg140, %bb2 ], [ 12, %0 ]         ; <i32> [#uses=1]
         %reg138 = phi i32 [ %reg139, %bb2 ], [ 0, %0 ]          ; <i32> [#uses=1]
         %reg139 = add i32 %reg138, 1            ; <i32> [#uses=1]
         %reg140 = add i32 %reg137, -1           ; <i32> [#uses=1]
         br i1 false, label %bb2, label %bb3
 
 bb3:            ; preds = %bb2
         ret void
 }
 

llvm/test/Transforms/Inline/externally_available.ll

-; RUN: opt < %s -inline -constprop -S | FileCheck %s
+; RUN: opt < %s -inline -instsimplify -S | FileCheck %s
 
 define available_externally i32 @test_function() {
 ; CHECK-NOT: @test_function
 entry:
   ret i32 4
 }
 
 

llvm/test/Transforms/InstSimplify/ConstProp/2002-05-03-DivideByZeroException.ll

 ; Make sure that the constant propogator doesn't divide by zero!
 ;
-; RUN: opt < %s -constprop
+; RUN: opt < %s -instsimplify
 ;
 
 define i32 @test() {
         %R = sdiv i32 12, 0             ; <i32> [#uses=1]
         ret i32 %R
 }
 
 define i32 @test2() {
         %R = srem i32 12, 0             ; <i32> [#uses=1]
         ret i32 %R
 }
 

llvm/test/Transforms/InstSimplify/ConstProp/2002-05-03-NotOperator.ll

 ; This bug has to do with the fact that constant propagation was implemented in
 ; terms of _logical_ not (! in C) instead of _bitwise_ not (~ in C).  This was
 ; due to a spec change.
 
 ; Fix #2: The unary not instruction now no longer exists. Change to xor.
 
-; RUN: opt < %s -constprop -S | \
+; RUN: opt < %s -instsimplify -S | \
 ; RUN:   not grep "i32 0"
 
 define i32 @test1() {
         %R = xor i32 123, -1            ; <i32> [#uses=1]
         ret i32 %R
 }
 
 define i32 @test2() {
         %R = xor i32 -123, -1           ; <i32> [#uses=1]
         ret i32 %R
 }
 

llvm/test/Transforms/InstSimplify/ConstProp/2002-09-03-SetCC-Bools.ll

 ; SetCC on boolean values was not implemented!
 
-; RUN: opt < %s -constprop -die -S | \
+; RUN: opt < %s -instsimplify -die -S | \
 ; RUN:   not grep set
 
 define i1 @test1() {
         %A = icmp ule i1 true, false            ; <i1> [#uses=1]
         %B = icmp uge i1 true, false            ; <i1> [#uses=1]
         %C = icmp ult i1 false, true            ; <i1> [#uses=1]
         %D = icmp ugt i1 true, false            ; <i1> [#uses=1]
         %E = icmp eq i1 false, false            ; <i1> [#uses=1]

llvm/test/Transforms/InstSimplify/ConstProp/2003-05-12-DivideError.ll

 ; Make sure that the constant propagator doesn't cause a sigfpe
 ;
-; RUN: opt < %s -constprop
+; RUN: opt < %s -instsimplify
 ;
 
 define i32 @test() {
         %R = sdiv i32 -2147483648, -1           ; <i32> [#uses=1]
         ret i32 %R
 }
 
 define i32 @test2() {
         %R = srem i32 -2147483648, -1           ; <i32> [#uses=1]
         ret i32 %R
 }
 

llvm/test/Transforms/InstSimplify/ConstProp/2005-01-28-SetCCGEP.ll

-; RUN: opt < %s -constprop -S | \
+; RUN: opt < %s -instsimplify -S | \
 ; RUN:    not grep "ret i1 false"
 
 @b = external global [2 x {  }]         ; <[2 x {  }]*> [#uses=2]
 
 define i1 @f() {
         %tmp.2 = icmp eq {  }* getelementptr ([2 x {  }], [2 x {  }]* @b, i32 0, i32 0), getelementptr ([2 x {  }], [2 x {  }]* @b, i32 0, i32 1)                ; <i1> [#uses=1]
         ret i1 %tmp.2
 }
 

llvm/test/Transforms/InstSimplify/ConstProp/2006-11-30-vector-cast.ll

-; RUN: opt < %s -constprop -S | \
+; RUN: opt < %s -instsimplify -S | \
 ; RUN:   grep "i32 -1"
-; RUN: opt < %s -constprop -S | \
+; RUN: opt < %s -instsimplify -S | \
 ; RUN:   not grep zeroinitializer
 
 define <4 x i32> @test() {
         %tmp40 = bitcast <2 x i64> bitcast (<4 x i32> < i32 0, i32 0, i32 -1, i32 0 > to <2 x i64>) to <4 x i32>; <<4 x i32>> [#uses=1]
         ret <4 x i32> %tmp40
 }
 

llvm/test/Transforms/InstSimplify/ConstProp/2006-12-01-TruncBoolBug.ll

 ; RUN: opt < %s -instcombine -S | \
 ; RUN:   grep "ret i1 false"
 define i1 @test() {
         %X = trunc i32 320 to i1                ; <i1> [#uses=1]
         ret i1 %X
 }
 

llvm/test/Transforms/InstSimplify/ConstProp/2006-12-01-bool-casts.ll

-; RUN: opt < %s -constprop -S | \
+; RUN: opt < %s -instsimplify -S | \
 ; RUN:    grep "ret i32 -1"
-; RUN: opt < %s -constprop -S | \
+; RUN: opt < %s -instsimplify -S | \
 ; RUN:    grep "ret i32 1"
 
 define i32 @test1() {
         %A = sext i1 true to i32                ; <i32> [#uses=1]
         ret i32 %A
 }
 
 define i32 @test2() {
         %A = zext i1 true to i32                ; <i32> [#uses=1]
         ret i32 %A
 }
 

llvm/test/Transforms/InstSimplify/ConstProp/2007-02-05-BitCast.ll

-; RUN: opt < %s -constprop -S | grep 1065353216
+; RUN: opt < %s -instsimplify -S | grep 1065353216
 
 define i32 @test() {
         %A = bitcast float 1.000000e+00 to i32          ; <i32> [#uses=1]
         ret i32 %A
 }
 

llvm/test/Transforms/InstSimplify/ConstProp/2007-02-23-sdiv.ll

 ; RUN: llvm-as < %s | llvm-dis | grep "global i32 0"
 ; PR1215
 
 @G = global i32 sdiv (i32 0, i32 -1)
 

llvm/test/Transforms/InstSimplify/ConstProp/2008-07-07-VectorCompare.ll

-; RUN: opt < %s -constprop -disable-output
+; RUN: opt < %s -instsimplify -disable-output
 ; PR2529
 define <4 x i1> @test1(i32 %argc, i8** %argv) {
 entry:  
         %foo = icmp slt <4 x i32> undef, <i32 14, i32 undef, i32 undef, i32 undef>
         ret <4 x i1> %foo
 }
 
 define <4 x i1> @test2(i32 %argc, i8** %argv) {

llvm/test/Transforms/InstSimplify/ConstProp/2009-06-20-constexpr-zero-lhs.ll

 ; RUN: llvm-as < %s | llvm-dis | not grep ptrtoint
 ; PR4424
 @G = external global i32
 @test1 = constant i32 sdiv (i32 0, i32 ptrtoint (i32* @G to i32))
 @test2 = constant i32 udiv (i32 0, i32 ptrtoint (i32* @G to i32))
 @test3 = constant i32 srem (i32 0, i32 ptrtoint (i32* @G to i32))
 @test4 = constant i32 urem (i32 0, i32 ptrtoint (i32* @G to i32))
 @test5 = constant i32 lshr (i32 0, i32 ptrtoint (i32* @G to i32))
 @test6 = constant i32 ashr (i32 0, i32 ptrtoint (i32* @G to i32))
 @test7 = constant i32 shl (i32 0, i32 ptrtoint (i32* @G to i32))
 

llvm/test/Transforms/InstSimplify/ConstProp/2009-09-01-GEP-Crash.ll

-; RUN: opt < %s -constprop | llvm-dis
+; RUN: opt < %s -instsimplify | llvm-dis
 ; PR4848
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
 target triple = "x86_64-unknown-linux-gnu"
 
 %0 = type { %struct.anon }
 %1 = type { %0, %2, [24 x i8] }
 %2 = type <{ %3, %3 }>
 %3 = type { %struct.hrtimer_cpu_base*, i32, %struct.rb_root, %struct.rb_node*, %struct.pgprot, i64 ()*, [16 x i8] }

llvm/test/Transforms/InstSimplify/ConstProp/InsertElement.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -constprop -S | FileCheck %s
+; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 define i32 @test1() {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:    ret i32 2139171423
 ;
   %A = bitcast i32 2139171423 to float
   %B = insertelement <1 x float> undef, float %A, i32 0
   %C = extractelement <1 x float> %B, i32 0
;
   %vec2 = insertelement <4 x i64> %vec1, i64 -2, i32 1
   %vec3 = insertelement <4 x i64> %vec2, i64 -3, i32 2
   %vec4 = insertelement <4 x i64> %vec3, i64 -4, i32 3
   ret <4 x i64> %vec4
 }
 
 define <4 x i64> @insertelement_undef() {
 ; CHECK-LABEL: @insertelement_undef(
-; CHECK-NEXT:    [[VEC4:%.*]] = insertelement <4 x i64> <i64 -1, i64 -2, i64 -3, i64 undef>, i64 -4, i32 3
 ; CHECK-NEXT:    ret <4 x i64> undef
 ;
   %vec1 = insertelement <4 x i64> undef, i64 -1, i32 0
   %vec2 = insertelement <4 x i64> %vec1, i64 -2, i32 1
   %vec3 = insertelement <4 x i64> %vec2, i64 -3, i32 2
   %vec4 = insertelement <4 x i64> %vec3, i64 -4, i32 3
   %vec5 = insertelement <4 x i64> %vec3, i64 -5, i32 4
   ret <4 x i64> %vec5

llvm/test/Transforms/InstSimplify/ConstProp/avx512.ll

-; RUN: opt < %s -constprop -S | FileCheck %s
+; RUN: opt < %s -instsimplify -S | FileCheck %s
 ; REQUIRES: x86-registered-target
 
 define i1 @test_avx512_cvts_exact() nounwind readnone {
 ; CHECK-LABEL: @test_avx512_cvts_exact(
 ; CHECK-NOT: call
 ; CHECK: ret i1 true
 entry:
   %i0 = tail call i32 @llvm.x86.avx512.vcvtss2si32(<4 x float> <float 3.0, float undef, float undef, float undef>, i32 4) nounwind

llvm/test/Transforms/InstSimplify/ConstProp/basictest.ll

-; RUN: opt < %s -constprop -die -S | FileCheck %s
+; RUN: opt < %s -instsimplify -die -S | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.7.2"
 
 ; This is a basic sanity check for constant propagation.  The add instruction
 ; should be eliminated.
 define i32 @test1(i1 %B) {
         br i1 %B, label %BB1, label %BB2

llvm/test/Transforms/InstSimplify/ConstProp/bitcast.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -constprop -S | FileCheck %s
+; RUN: opt < %s -instsimplify -S | FileCheck %s
 ; PR2165
 
 define <1 x i64> @test1() {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:    ret <1 x i64> <i64 63>
 ;
   %A = bitcast i64 63 to <1 x i64>
   ret <1 x i64> %A

llvm/test/Transforms/InstSimplify/ConstProp/bswap.ll

 ; bswap should be constant folded when it is passed a constant argument
 
-; RUN: opt < %s -constprop -S | FileCheck %s
+; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 declare i16 @llvm.bswap.i16(i16)
 
 declare i32 @llvm.bswap.i32(i32)
 
 declare i64 @llvm.bswap.i64(i64)
 
 declare i80 @llvm.bswap.i80(i80)

llvm/test/Transforms/InstSimplify/ConstProp/calls-math-finite.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -constprop -S | FileCheck %s
-; RUN: opt < %s -constprop -S -mtriple=unknown-unknown-linux-musl | FileCheck -check-prefix=MUSL %s
+; RUN: opt < %s -instsimplify -S | FileCheck %s
+; RUN: opt < %s -instsimplify -S -mtriple=unknown-unknown-linux-musl | FileCheck -check-prefix=MUSL %s
 
 ; Test to verify constant folding can occur when math routines are mapped
 ; to the __<func>_finite versions of functions due to __FINITE_MATH_ONLY__
 ; being enabled on headers on Linux. All calls should constant fold away
 ; in this test.
 
 target triple = "unknown-unknown-linux-gnu"
 

llvm/test/Transforms/InstSimplify/ConstProp/calls.ll

-; RUN: opt < %s -constprop -S | FileCheck %s
-; RUN: opt < %s -constprop -disable-simplify-libcalls -S | FileCheck %s --check-prefix=FNOBUILTIN
+; RUN: opt < %s -instsimplify -S | FileCheck %s
+; RUN: opt < %s -instsimplify -disable-simplify-libcalls -S | FileCheck %s --check-prefix=FNOBUILTIN
 
 declare double @acos(double) readnone nounwind
 declare double @asin(double) readnone nounwind
 declare double @atan(double) readnone nounwind
 declare double @atan2(double, double) readnone nounwind
 declare double @ceil(double) readnone nounwind
 declare double @cos(double) readnone nounwind
 declare double @cosh(double) readnone nounwind

llvm/test/Transforms/InstSimplify/ConstProp/cast.ll

-; RUN: opt < %s -constprop -S | FileCheck %s
+; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 ; Overflow on a float to int or int to float conversion is undefined (PR21130).
 
 define i8 @overflow_fptosi() {
 ; CHECK-LABEL: @overflow_fptosi(
 ; CHECK-NEXT:    ret i8 undef
 ;
   %i = fptosi double 1.56e+02 to i8

llvm/test/Transforms/InstSimplify/ConstProp/constant-expr.ll

 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
 
 @X = external global i8
 @Y = external global i8
 @Z = external global i8
 
 @A = global i1 add (i1 icmp ult (i8* @X, i8* @Y), i1 icmp ult (i8* @X, i8* @Z))
 ; CHECK: @A = global i1 xor (i1 icmp ult (i8* @X, i8* @Y), i1 icmp ult (i8* @X, i8* @Z))
 @B = global i1 sub (i1 icmp ult (i8* @X, i8* @Y), i1 icmp ult (i8* @X, i8* @Z)), align 2
 ; CHECK: @B = global i1 xor (i1 icmp ult (i8* @X, i8* @Y), i1 icmp ult (i8* @X, i8* @Z))
 @C = global i1 mul (i1 icmp ult (i8* @X, i8* @Y), i1 icmp ult (i8* @X, i8* @Z))
 ; CHECK: @C = global i1 and (i1 icmp ult (i8* @X, i8* @Y), i1 icmp ult (i8* @X, i8* @Z))
 
 @D = global i1 sdiv (i1 icmp ult (i8* @X, i8* @Y), i1 icmp ult (i8* @X, i8* @Z))
 ; CHECK: @D = global i1 icmp ult (i8* @X, i8* @Y)
 @E = global i1 udiv (i1 icmp ult (i8* @X, i8* @Y), i1 icmp ult (i8* @X, i8* @Z))
 ; CHECK: @E = global i1 icmp ult (i8* @X, i8* @Y)
 @F = global i1 srem (i1 icmp ult (i8* @X, i8* @Y), i1 icmp ult (i8* @X, i8* @Z))
 ; CHECK: @F = global i1 false 
 @G = global i1 urem (i1 icmp ult (i8* @X, i8* @Y), i1 icmp ult (i8* @X, i8* @Z))
 ; CHECK: @G = global i1 false 
 
 @H = global i1 icmp ule (i32* bitcast (i8* @X to i32*), i32* bitcast (i8* @Y to i32*))
 ; CHECK: @H = global i1 icmp ule (i8* @X, i8* @Y)
 
 @I = global i1 xor (i1 icmp ult (i8* @X, i8* @Y), i1 false)
 ; CHECK: @I = global i1 icmp ult (i8* @X, i8* @Y)
 @J = global i1 xor (i1 icmp ult (i8* @X, i8* @Y), i1 true)
 ; CHECK: @J = global i1 icmp uge (i8* @X, i8* @Y)
 
 @K = global i1 icmp eq (i1 icmp ult (i8* @X, i8* @Y), i1 false)
 ; CHECK: @K = global i1 icmp uge (i8* @X, i8* @Y)
 @L = global i1 icmp eq (i1 icmp ult (i8* @X, i8* @Y), i1 true)
 ; CHECK: @L = global i1 icmp ult (i8* @X, i8* @Y)
 @M = global i1 icmp ne (i1 icmp ult (i8* @X, i8* @Y), i1 true)
 ; CHECK: @M = global i1 icmp uge (i8* @X, i8* @Y)
 @N = global i1 icmp ne (i1 icmp ult (i8* @X, i8* @Y), i1 false)
 ; CHECK: @N = global i1 icmp ult (i8* @X, i8* @Y)
 
 @O = global i1 icmp eq (i32 zext (i1 icmp ult (i8* @X, i8* @Y) to i32), i32 0)
 ; CHECK: @O = global i1 icmp uge (i8* @X, i8* @Y)
 
 
 
 ; PR5176
 
 ; CHECK: @T1 = global i1 true
 @T1 = global i1 icmp eq (i64 and (i64 trunc (i256 lshr (i256 or (i256 and (i256 and (i256 shl (i256 zext (i64 ptrtoint (i1* @B to i64) to i256), i256 64), i256 -6277101735386680763495507056286727952638980837032266301441), i256 6277101735386680763835789423207666416102355444464034512895), i256 shl (i256 zext (i64 ptrtoint (i1* @A to i64) to i256), i256 192)), i256 64) to i64), i64 1), i64 0)
 
 ; CHECK: @T2 = global i1* @B
 @T2 = global i1* inttoptr (i64 add (i64 trunc (i256 lshr (i256 or (i256 and (i256 and (i256 shl (i256 zext (i64 ptrtoint (i1* @A to i64) to i256), i256 64), i256 -6277101735386680763495507056286727952638980837032266301441), i256 6277101735386680763835789423207666416102355444464034512895), i256 shl (i256 zext (i64 ptrtoint (i1* @B to i64) to i256), i256 192)), i256 192) to i64), i64 trunc (i256 lshr (i256 or (i256 and (i256 and (i256 shl (i256 zext (i64 ptrtoint (i1* @A to i64) to i256), i256 64), i256 -6277101735386680763495507056286727952638980837032266301441), i256 6277101735386680763835789423207666416102355444464034512895), i256 shl (i256 zext (i64 ptrtoint (i1* @B to i64) to i256), i256 192)), i256 128) to i64)) to i1*)
 
 ; CHECK: @T3 = global i64 add (i64 ptrtoint (i1* @B to i64), i64 -1)
 @T3 = global i64 add (i64 trunc (i256 lshr (i256 or (i256 and (i256 and (i256 shl (i256 zext (i64 ptrtoint (i1* @B to i64) to i256), i256 64), i256 -6277101735386680763495507056286727952638980837032266301441), i256 6277101735386680763835789423207666416102355444464034512895), i256 shl (i256 zext (i64 ptrtoint (i1* @A to i64) to i256), i256 192)), i256 64) to i64), i64 -1)
 
 ; CHECK: @T4 = global i1* @B
 @T4 = global i1* inttoptr (i64 trunc (i256 lshr (i256 or (i256 and (i256 and (i256 shl (i256 zext (i64 ptrtoint (i1* @B to i64) to i256), i256 64), i256 -6277101735386680763495507056286727952638980837032266301441), i256 6277101735386680763835789423207666416102355444464034512895), i256 shl (i256 zext (i64 ptrtoint (i1* @A to i64) to i256), i256 192)), i256 64) to i64) to i1*)
 
 ; CHECK: @T5 = global i1* @A
 @T5 = global i1* inttoptr (i64 add (i64 trunc (i256 lshr (i256 or (i256 and (i256 and (i256 shl (i256 zext (i64 ptrtoint (i1* @B to i64) to i256), i256 64), i256 -6277101735386680763495507056286727952638980837032266301441), i256 6277101735386680763835789423207666416102355444464034512895), i256 shl (i256 zext (i64 ptrtoint (i1* @A to i64) to i256), i256 192)), i256 192) to i64), i64 trunc (i256 lshr (i256 or (i256 and (i256 and (i256 shl (i256 zext (i64 ptrtoint (i1* @B to i64) to i256), i256 64), i256 -6277101735386680763495507056286727952638980837032266301441), i256 6277101735386680763835789423207666416102355444464034512895), i256 shl (i256 zext (i64 ptrtoint (i1* @A to i64) to i256), i256 192)), i256 128) to i64)) to i1*)
 
 
 
 ; PR6096
 
 ; No check line. This used to crash llvm-as.
 @T6 = global <2 x i1> fcmp ole (<2 x float> fdiv (<2 x float> undef, <2 x float> <float 1.000000e+00, float 1.000000e+00>), <2 x float> zeroinitializer)
 
 
 ; PR9011
 
 @pr9011_1 = constant <4 x i32> zext (<4 x i8> zeroinitializer to <4 x i32>)
 ; CHECK: pr9011_1 = constant <4 x i32> zeroinitializer
 @pr9011_2 = constant <4 x i32> sext (<4 x i8> zeroinitializer to <4 x i32>)
 ; CHECK: pr9011_2 = constant <4 x i32> zeroinitializer
 @pr9011_3 = constant <4 x i32> bitcast (<16 x i8> zeroinitializer to <4 x i32>)
 ; CHECK: pr9011_3 = constant <4 x i32> zeroinitializer
 @pr9011_4 = constant <4 x float> uitofp (<4 x i8> zeroinitializer to <4 x float>)
 ; CHECK: pr9011_4 = constant <4 x float> zeroinitializer
 @pr9011_5 = constant <4 x float> sitofp (<4 x i8> zeroinitializer to <4 x float>)
 ; CHECK: pr9011_5 = constant <4 x float> zeroinitializer
 @pr9011_6 = constant <4 x i32> fptosi (<4 x float> zeroinitializer to <4 x i32>)
 ; CHECK: pr9011_6 = constant <4 x i32> zeroinitializer
 @pr9011_7 = constant <4 x i32> fptoui (<4 x float> zeroinitializer to <4 x i32>)
 ; CHECK: pr9011_7 = constant <4 x i32> zeroinitializer
 @pr9011_8 = constant <4 x float> fptrunc (<4 x double> zeroinitializer to <4 x float>)
 ; CHECK: pr9011_8 = constant <4 x float> zeroinitializer
 @pr9011_9 = constant <4 x double> fpext (<4 x float> zeroinitializer to <4 x double>)
 ; CHECK: pr9011_9 = constant <4 x double> zeroinitializer
 
 @pr9011_10 = constant <4 x double> bitcast (i256 0 to <4 x double>)
 ; CHECK: pr9011_10 = constant <4 x double> zeroinitializer
 @pr9011_11 = constant <4 x float> bitcast (i128 0 to <4 x float>)
 ; CHECK: pr9011_11 = constant <4 x float> zeroinitializer
 @pr9011_12 = constant <4 x i32> bitcast (i128 0 to <4 x i32>)
 ; CHECK: pr9011_12 = constant <4 x i32> zeroinitializer
 @pr9011_13 = constant i256 bitcast (<4 x double> zeroinitializer to i256)
 ; CHECK: pr9011_13 = constant i256 0
 @pr9011_14 = constant i128 bitcast (<4 x float> zeroinitializer to i128)
 ; CHECK: pr9011_14 = constant i128 0
 @pr9011_15 = constant i128 bitcast (<4 x i32> zeroinitializer to i128)
 ; CHECK: pr9011_15 = constant i128 0
 
 @select = internal constant
           i32 select (i1 icmp ult (i32 ptrtoint (i8* @X to i32),
                                    i32 ptrtoint (i8* @Y to i32)),
             i32 select (i1 icmp ult (i32 ptrtoint (i8* @X to i32),
                                      i32 ptrtoint (i8* @Y to i32)),
                i32 10, i32 20),
             i32 30)
 ; CHECK: select = internal constant i32 select {{.*}} i32 10, i32 30

llvm/test/Transforms/InstSimplify/ConstProp/convert-from-fp16.ll

-; RUN: opt -constprop -S < %s | FileCheck %s
+; RUN: opt -instsimplify -S < %s | FileCheck %s
 
 ; Verify that we don't crash with an assertion failure when constant folding
 ; a call to intrinsic 'convert.from.fp16' if the return type is not 'float'.
 
 define float @fold_from_fp16_to_fp32() {
 ; CHECK-LABEL: @fold_from_fp16_to_fp32
 ; CHECK: ret float 0.000000e+00
 entry:

llvm/test/Transforms/InstSimplify/ConstProp/div-zero.ll

 ; RUN: opt < %s -instcombine -S | grep "ret i32 0"
 ; PR4424
 declare void @ext()
 
 define i32 @foo(i32 %ptr) {
 entry:
         %zero = sub i32 %ptr, %ptr              ; <i32> [#uses=1]
         %div_zero = sdiv i32 %zero, ptrtoint (i32* getelementptr (i32, i32* null,
 i32 1) to i32)             ; <i32> [#uses=1]
         ret i32 %div_zero
 }
 

llvm/test/Transforms/InstSimplify/ConstProp/extractvalue.ll

-; RUN: opt < %s -constprop -S | FileCheck %s
+; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 %struct = type { i32, [4 x i8] }
 
 define i32 @test1() {
   %A = extractvalue %struct { i32 2, [4 x i8] c"foo\00" }, 0
   ret i32 %A
 ; CHECK-LABEL: @test1(
 ; CHECK: ret i32 2

llvm/test/Transforms/InstSimplify/ConstProp/float-to-ptr-cast.ll

-; RUN: opt < %s -constprop -S | FileCheck %s
+; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 define i32* @test1() {
         %X = inttoptr i64 0 to i32*             ; <i32*> [#uses=1]
         ret i32* %X
 }
 
 ; CHECK:  ret i32* null
 
 define i32* @test2() {
         ret i32* null
 }
 
 ; CHECK:  ret i32* null
 

llvm/test/Transforms/InstSimplify/ConstProp/fma.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -constprop -S < %s | FileCheck %s
+; RUN: opt -instsimplify -S < %s | FileCheck %s
 
 ; Fixes PR20832
 ; Make sure that we correctly fold a fused multiply-add where operands
 ; are all finite constants and addend is zero.
 
 declare double @llvm.fma.f64(double, double, double)
 
 

llvm/test/Transforms/InstSimplify/ConstProp/insertvalue.ll

-; RUN: opt < %s -constprop -S | FileCheck %s
+; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 %struct = type { i32, [4 x i8] }
 
 define %struct @test1() {
   %A = insertvalue %struct { i32 2, [4 x i8] c"foo\00" }, i32 1, 0
   ret %struct %A
 ; CHECK-LABEL: @test1(
 ; CHECK: ret %struct { i32 1, [4 x i8] c"foo\00" }

llvm/test/Transforms/InstSimplify/ConstProp/loads.ll

 ; RUN: opt < %s -data-layout="e-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64" -instcombine -S | FileCheck %s --check-prefix=LE
 ; RUN: opt < %s -data-layout="E-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64" -instcombine -S | FileCheck %s --check-prefix=BE
 
 ; {{ 0xDEADBEEF, 0xBA }, 0xCAFEBABE}
 @g1 = constant {{i32,i8},i32} {{i32,i8} { i32 -559038737, i8 186 }, i32 -889275714 }
 @g2 = constant double 1.0
 ; { 0x7B, 0x06B1BFF8 }
 @g3 = constant {i64, i64} { i64 123, i64 112312312 }
 
 ; Simple load
 define i32 @test1() {
   %r = load i32, i32* getelementptr ({{i32,i8},i32}, {{i32,i8},i32}* @g1, i32 0, i32 0, i32 0)
   ret i32 %r
 
 ; 0xDEADBEEF
 ; LE-LABEL: @test1(
 ; LE: ret i32 -559038737
 
 ; 0xDEADBEEF
 ; BE-LABEL: @test1(
 ; BE: ret i32 -559038737
 }
 
 ; PR3152
 ; Load of first 16 bits of 32-bit value.
 define i16 @test2() {
   %r = load i16, i16* bitcast(i32* getelementptr ({{i32,i8},i32}, {{i32,i8},i32}* @g1, i32 0, i32 0, i32 0) to i16*)
   ret i16 %r
 
 ; 0xBEEF
 ; LE-LABEL: @test2(
 ; LE: ret i16 -16657
 
 ; 0xDEAD
 ; BE-LABEL: @test2(
 ; BE: ret i16 -8531
 }
 
 define i16 @test2_addrspacecast() {
   %r = load i16, i16 addrspace(1)* addrspacecast(i32* getelementptr ({{i32,i8},i32}, {{i32,i8},i32}* @g1, i32 0, i32 0, i32 0) to i16 addrspace(1)*)
   ret i16 %r
 
 ; FIXME: Should be able to load through a constant addrspacecast.
 ; 0xBEEF
 ; LE-LABEL: @test2_addrspacecast(
 ; XLE: ret i16 -16657
 ; LE: load i16, i16 addrspace(1)* addrspacecast
 
 ; 0xDEAD
 ; BE-LABEL: @test2_addrspacecast(
 ; XBE: ret i16 -8531
 ; BE: load i16, i16 addrspace(1)* addrspacecast
 }
 
 ; Load of second 16 bits of 32-bit value.
 define i16 @test3() {
   %r = load i16, i16* getelementptr(i16, i16* bitcast(i32* getelementptr ({{i32,i8},i32}, {{i32,i8},i32}* @g1, i32 0, i32 0, i32 0) to i16*), i32 1)
   ret i16 %r
 
 ; 0xDEAD
 ; LE-LABEL: @test3(
 ; LE: ret i16 -8531
 
 ; 0xBEEF
 ; BE-LABEL: @test3(
 ; BE: ret i16 -16657
 }
 
 ; Load of 8 bit field + tail padding.
 define i16 @test4() {
   %r = load i16, i16* getelementptr(i16, i16* bitcast(i32* getelementptr ({{i32,i8},i32}, {{i32,i8},i32}* @g1, i32 0, i32 0, i32 0) to i16*), i32 2)
   ret i16 %r
 
 ; 0x00BA
 ; LE-LABEL: @test4(
 ; LE: ret i16 186
 
 ; 0xBA00
 ; BE-LABEL: @test4(
 ; BE: ret i16 -17920
 }
 
 ; Load of double bits.
 define i64 @test6() {
   %r = load i64, i64* bitcast(double* @g2 to i64*)
   ret i64 %r
 
 ; 0x3FF_0000000000000
 ; LE-LABEL: @test6(
 ; LE: ret i64 4607182418800017408
 
 ; 0x3FF_0000000000000
 ; BE-LABEL: @test6(
 ; BE: ret i64 4607182418800017408
 }
 
 ; Load of double bits.
 define i16 @test7() {
   %r = load i16, i16* bitcast(double* @g2 to i16*)
   ret i16 %r
 
 ; 0x0000
 ; LE-LABEL: @test7(
 ; LE: ret i16 0
 
 ; 0x3FF0
 ; BE-LABEL: @test7(
 ; BE: ret i16 16368
 }
 
 ; Double load.
 define double @test8() {
   %r = load double, double* bitcast({{i32,i8},i32}* @g1 to double*)
   ret double %r
 
 ; LE-LABEL: @test8(
 ; LE: ret double 0xBADEADBEEF
 
 ; BE-LABEL: @test8(
 ; BE: ret double 0xDEADBEEFBA000000
 }
 
 
 ; i128 load.
 define i128 @test9() {
   %r = load i128, i128* bitcast({i64, i64}* @g3 to i128*)
   ret i128 %r
 
 ; 0x00000000_06B1BFF8_00000000_0000007B
 ; LE-LABEL: @test9(
 ; LE: ret i128 2071796475790618158476296315
 
 ; 0x00000000_0000007B_00000000_06B1BFF8
 ; BE-LABEL: @test9(
 ; BE: ret i128 2268949521066387161080
 }
 
 ; vector load.
 define <2 x i64> @test10() {
   %r = load <2 x i64>, <2 x i64>* bitcast({i64, i64}* @g3 to <2 x i64>*)
   ret <2 x i64> %r
 
 ; LE-LABEL: @test10(
 ; LE: ret <2 x i64> <i64 123, i64 112312312>
 
 ; BE-LABEL: @test10(
 ; BE: ret <2 x i64> <i64 123, i64 112312312>
 }
 
 
 ; PR5287
 ; { 0xA1, 0x08 }
 @g4 = internal constant { i8, i8 } { i8 -95, i8 8 }
 
 define i16 @test11() nounwind {
 entry:
   %a = load i16, i16* bitcast ({ i8, i8 }* @g4 to i16*)
   ret i16 %a
 
 ; 0x08A1
 ; LE-LABEL: @test11(
 ; LE: ret i16 2209
 
 ; 0xA108
 ; BE-LABEL: @test11(
 ; BE: ret i16 -24312
 }
 
 
 ; PR5551
 @test12g = private constant [6 x i8] c"a\00b\00\00\00"
 
 define i16 @test12() {
   %a = load i16, i16* getelementptr inbounds ([3 x i16], [3 x i16]* bitcast ([6 x i8]* @test12g to [3 x i16]*), i32 0, i64 1)
   ret i16 %a
 
 ; 0x0062
 ; LE-LABEL: @test12(
 ; LE: ret i16 98
 
 ; 0x6200
 ; BE-LABEL: @test12(
 ; BE: ret i16 25088
 }
 
 
 ; PR5978
 @g5 = constant i8 4
 define i1 @test13() {
   %A = load i1, i1* bitcast (i8* @g5 to i1*)
   ret i1 %A
 
 ; LE-LABEL: @test13(
 ; LE: ret i1 false
 
 ; BE-LABEL: @test13(
 ; BE: ret i1 false
 }
 
 @g6 = constant [2 x i8*] [i8* inttoptr (i64 1 to i8*), i8* inttoptr (i64 2 to i8*)]
 define i64 @test14() nounwind {
 entry:
   %tmp = load i64, i64* bitcast ([2 x i8*]* @g6 to i64*)
   ret i64 %tmp
 
 ; LE-LABEL: @test14(
 ; LE: ret i64 1
 
 ; BE-LABEL: @test14(
 ; BE: ret i64 1
 }
 
 ; Check with address space pointers
 @g6_as1 = constant [2 x i8 addrspace(1)*] [i8 addrspace(1)* inttoptr (i16 1 to i8 addrspace(1)*), i8 addrspace(1)* inttoptr (i16 2 to i8 addrspace(1)*)]
 define i16 @test14_as1() nounwind {
 entry:
   %tmp = load i16, i16* bitcast ([2 x i8 addrspace(1)*]* @g6_as1 to i16*)
   ret i16 %tmp
 
 ; LE: @test14_as1
 ; LE: ret i16 1
 
 ; BE: @test14_as1
 ; BE: ret i16 1
 }
 
 define i64 @test15() nounwind {
 entry:
   %tmp = load i64, i64* bitcast (i8** getelementptr inbounds ([2 x i8*], [2 x i8*]* @g6, i32 0, i64 1) to i64*)
   ret i64 %tmp
 
 ; LE-LABEL: @test15(
 ; LE: ret i64 2
 
 ; BE-LABEL: @test15(
 ; BE: ret i64 2
 }
 
 @gv7 = constant [4 x i8*] [i8* null, i8* inttoptr (i64 -14 to i8*), i8* null, i8* null]
 define i64 @test16.1() {
   %v = load i64, i64* bitcast ([4 x i8*]* @gv7 to i64*), align 8
   ret i64 %v
 
 ; LE-LABEL: @test16.1(
 ; LE: ret i64 0
 
 ; BE-LABEL: @test16.1(
 ; BE: ret i64 0
 }
 
 define i64 @test16.2() {
   %v = load i64, i64* bitcast (i8** getelementptr inbounds ([4 x i8*], [4 x i8*]* @gv7, i64 0, i64 1) to i64*), align 8
   ret i64 %v
 
 ; LE-LABEL: @test16.2(
 ; LE: ret i64 -14
 
 ; BE-LABEL: @test16.2(
 ; BE: ret i64 -14
 }
 
 define i64 @test16.3() {
   %v = load i64, i64* bitcast (i8** getelementptr inbounds ([4 x i8*], [4 x i8*]* @gv7, i64 0, i64 2) to i64*), align 8
   ret i64 %v
 
 ; LE-LABEL: @test16.3(
 ; LE: ret i64 0
 
 ; BE-LABEL: @test16.3(
 ; BE: ret i64 0
 }
 
 @g7 = constant {[0 x i32], [0 x i8], {}*} { [0 x i32] undef, [0 x i8] undef, {}* null }
 
 define i64* @test_leading_zero_size_elems() {
   %v = load i64*, i64** bitcast ({[0 x i32], [0 x i8], {}*}* @g7 to i64**)
   ret i64* %v
 
 ; LE-LABEL: @test_leading_zero_size_elems(
 ; LE: ret i64* null
 
 ; BE-LABEL: @test_leading_zero_size_elems(
 ; BE: ret i64* null
 }
 
 @g8 = constant {[4294967295 x [0 x i32]], i64} { [4294967295 x [0 x i32]] undef, i64 123 }
 
 define i64 @test_leading_zero_size_elems_big() {
   %v = load i64, i64* bitcast ({[4294967295 x [0 x i32]], i64}* @g8 to i64*)
   ret i64 %v
 
 ; LE-LABEL: @test_leading_zero_size_elems_big(
 ; LE: ret i64 123
 
 ; BE-LABEL: @test_leading_zero_size_elems_big(
 ; BE: ret i64 123
 }
 
 @g9 = constant [4294967295 x [0 x i32]] zeroinitializer
 
 define i64 @test_array_of_zero_size_array() {
   %v = load i64, i64* bitcast ([4294967295 x [0 x i32]]* @g9 to i64*)
   ret i64 %v
 
 ; LE-LABEL: @test_array_of_zero_size_array(
 ; LE: ret i64 0
 
 ; BE-LABEL: @test_array_of_zero_size_array(
 ; BE: ret i64 0
 }

llvm/test/Transforms/InstSimplify/ConstProp/logicaltest.ll

 ; Ensure constant propagation of logical instructions is working correctly.
 
-; RUN: opt < %s -constprop -die -S | FileCheck %s
+; RUN: opt < %s -instsimplify -die -S | FileCheck %s
 ; CHECK-NOT:     {{and|or|xor}}
 
 define i32 @test1() {
         %R = and i32 4, 1234            ; <i32> [#uses=1]
         ret i32 %R
 }
 
 define i1 @test1.upgrd.1() {

llvm/test/Transforms/InstSimplify/ConstProp/overflow-ops.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -constprop -S | FileCheck %s --check-prefixes=CHECK,CONSTPROP
+; RUN: opt < %s -instsimplify -S | FileCheck %s --check-prefixes=CHECK,CONSTPROP
 ; RUN: opt < %s -instsimplify -S | FileCheck %s --check-prefixes=CHECK,INSTSIMPLIFY
 ; We must *NOT* have any check-lines with prefixes other than CHECK here.
 ; If we do, that means the rules are different between the passes.
 
 declare {i8, i1} @llvm.uadd.with.overflow.i8(i8, i8)
 declare {i8, i1} @llvm.usub.with.overflow.i8(i8, i8)
 declare {i8, i1} @llvm.umul.with.overflow.i8(i8, i8)
 

llvm/test/Transforms/InstSimplify/ConstProp/phi.ll

 ; This is a basic sanity check for constant propagation.  The add instruction
 ; should be eliminated.
 
-; RUN: opt < %s -constprop -die -S | not grep phi
+; RUN: opt < %s -instsimplify -die -S | not grep phi
 
 define i32 @test(i1 %B) {
 BB0:
         br i1 %B, label %BB1, label %BB3
 
 BB1:            ; preds = %BB0
         br label %BB3
 
 BB3:            ; preds = %BB1, %BB0
         %Ret = phi i32 [ 1, %BB0 ], [ 1, %BB1 ]         ; <i32> [#uses=1]
         ret i32 %Ret
 }
 

llvm/test/Transforms/InstSimplify/ConstProp/remtest.ll

 ; Ensure constant propagation of remainder instructions is working correctly.
 
-; RUN: opt < %s -constprop -die -S | not grep rem
+; RUN: opt < %s -instsimplify -die -S | not grep rem
 
 define i32 @test1() {
         %R = srem i32 4, 3              ; <i32> [#uses=1]
         ret i32 %R
 }
 
 define i32 @test2() {
         %R = srem i32 123, -23          ; <i32> [#uses=1]

llvm/test/Transforms/InstSimplify/ConstProp/shift.ll

-; RUN: opt < %s -constprop -S | FileCheck %s
+; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 ; CHECK-LABEL: shift_undef_64
 define void @shift_undef_64(i64* %p) {
   %r1 = lshr i64 -1, 4294967296 ; 2^32
   ; CHECK: store i64 undef
   store i64 %r1, i64* %p
 
   %r2 = ashr i64 -1, 4294967297 ; 2^32 + 1

llvm/test/Transforms/InstSimplify/ConstProp/sse.ll

-; RUN: opt < %s -constprop -S | FileCheck %s
+; RUN: opt < %s -instsimplify -S | FileCheck %s
 ; REQUIRES: x86-registered-target
 
 define i1 @test_sse_cvts_exact() nounwind readnone {
 ; CHECK-LABEL: @test_sse_cvts_exact(
 ; CHECK-NOT: call
 ; CHECK: ret i1 true
 entry:
   %i0 = tail call i32 @llvm.x86.sse.cvtss2si(<4 x float> <float 3.0, float undef, float undef, float undef>) nounwind

llvm/test/Transforms/InstSimplify/ConstProp/trunc_vec.ll

-; RUN: opt -constprop < %s
+; RUN: opt -instsimplify < %s
 
 ; Make sure we don't crash on this one
 
 define <8 x i8> @test_truc_vec() {
   %x = bitcast <2 x i64> <i64 1, i64 2> to <8 x i16>
   %y = trunc <8 x i16> %x to <8 x i8>
   ret <8 x i8> %y
 }

llvm/test/Transforms/Reassociate/2002-05-15-SubReassociate.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -reassociate -constprop -instcombine -dce -S | FileCheck %s
+; RUN: opt < %s -reassociate -instsimplify -instcombine -dce -S | FileCheck %s
 
 ; With sub reassociation, constant folding can eliminate all of the constants.
 define i32 @test1(i32 %A, i32 %B) {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:    [[Z:%.*]] = sub i32 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    ret i32 [[Z]]
 ;
   %W = add i32 5, %B

llvm/test/Transforms/Reassociate/fast-SubReassociate.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -reassociate -constprop -instcombine -S | FileCheck %s
+; RUN: opt < %s -reassociate -instsimplify -instcombine -S | FileCheck %s
 
 define float @test1(float %A, float %B) {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:    [[W:%.*]] = fadd float [[B:%.*]], 5.000000e+00
 ; CHECK-NEXT:    [[X:%.*]] = fadd float [[A:%.*]], -7.000000e+00
 ; CHECK-NEXT:    [[Y:%.*]] = fsub float [[X]], [[W]]
 ; CHECK-NEXT:    [[Z:%.*]] = fadd float [[Y]], 1.200000e+01
 ; CHECK-NEXT:    ret float [[Z]]

llvm/test/Transforms/Reassociate/otherops.ll

 ; Reassociation should apply to Add, Mul, And, Or, & Xor
 ;
-; RUN: opt < %s -reassociate -constprop -instcombine -die -S | FileCheck %s
+; RUN: opt < %s -reassociate -instsimplify -instcombine -die -S | FileCheck %s
 
 define i32 @test_mul(i32 %arg) {
 ; CHECK-LABEL: test_mul
 ; CHECK-NEXT: %tmp2 = mul i32 %arg, 144
 ; CHECK-NEXT: ret i32 %tmp2
 
   %tmp1 = mul i32 12, %arg
   %tmp2 = mul i32 %tmp1, 12

llvm/test/Transforms/SimplifyCFG/2005-12-03-IncorrectPHIFold.ll

 ; Make sure this doesn't turn into an infinite loop
 
-; RUN: opt < %s -simplifycfg -constprop -simplifycfg | llvm-dis | FileCheck %s
+; RUN: opt < %s -simplifycfg -instsimplify -simplifycfg | llvm-dis | FileCheck %s
 
 %struct.anon = type { i32, i32, i32, i32, [1024 x i8] }
 @_zero_ = external global %struct.anon*   ; <%struct.anon**> [#uses=2]
 @_one_ = external global %struct.anon*    ; <%struct.anon**> [#uses=4]
 @str = internal constant [4 x i8] c"%d\0A\00"    ; <[4 x i8]*> [#uses=0]
 
 declare i32 @bc_compare(%struct.anon*, %struct.anon*)
 

llvm/unittests/ExecutionEngine/MCJIT/MCJITCAPITest.cpp

protected:
   void buildMCJITEngine() {
     ASSERT_EQ(
       0, LLVMCreateMCJITCompilerForModule(&Engine, Module, &Options,
                                           sizeof(Options), &Error));
   }
   
   void buildAndRunPasses() {
     LLVMPassManagerRef pass = LLVMCreatePassManager();
-    LLVMAddConstantPropagationPass(pass);
     LLVMAddInstructionCombiningPass(pass);
     LLVMRunPassManager(pass, Module);
     LLVMDisposePassManager(pass);
   }
   
   void buildAndRunOptPasses() {
     LLVMPassManagerBuilderRef passBuilder;
     

llvm/utils/gn/secondary/llvm/lib/Transforms/Scalar/BUILD.gn

deps = [
     "//llvm/lib/Transforms/Utils",
   ]
   sources = [
     "ADCE.cpp",
     "AlignmentFromAssumptions.cpp",
     "BDCE.cpp",
     "CallSiteSplitting.cpp",
     "ConstantHoisting.cpp",
-    "ConstantProp.cpp",
     "CorrelatedValuePropagation.cpp",
     "DCE.cpp",
     "DeadStoreElimination.cpp",
     "DivRemPairs.cpp",
     "EarlyCSE.cpp",
     "FlattenCFGPass.cpp",
     "Float2Int.cpp",
     "GVN.cpp",