[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 ↗

(On Diff #288074)

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 ↗

(On Diff #288074)

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 ↗

(On Diff #288074)

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

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

2 ↗

(On Diff #288074)

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/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/Transforms/InstSimplify/ConstProp/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/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/AMDGPU/cos.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 declare half @llvm.amdgcn.cos.f16(half) #0
 declare float @llvm.amdgcn.cos.f32(float) #0
 declare double @llvm.amdgcn.cos.f64(double) #0
 
 define void @test_f16(half* %p) {
 ; CHECK-LABEL: @test_f16(
 ; CHECK-NEXT:    store volatile half 0xH3C00, half* [[P:%.*]], align 2
 ; CHECK-NEXT:    store volatile half 0xH3C00, half* [[P]], align 2
 ; CHECK-NEXT:    store volatile half 0xH39A8, half* [[P]], align 2
 ; CHECK-NEXT:    store volatile half 0xH39A8, half* [[P]], align 2
 ; CHECK-NEXT:    store volatile half 0xH0000, half* [[P]], align 2
 ; CHECK-NEXT:    store volatile half 0xH0000, half* [[P]], align 2
 ; CHECK-NEXT:    store volatile half 0xHBC00, half* [[P]], align 2
 ; CHECK-NEXT:    store volatile half 0xHBC00, half* [[P]], align 2
 ; CHECK-NEXT:    store volatile half 0xH3C00, half* [[P]], align 2
 ; CHECK-NEXT:    store volatile half 0xH3C00, half* [[P]], align 2
 ; CHECK-NEXT:    store volatile half 0xH3C00, half* [[P]], align 2
 ; CHECK-NEXT:    store volatile half 0xH3C00, half* [[P]], align 2
 ; CHECK-NEXT:    [[P1000:%.*]] = call half @llvm.amdgcn.cos.f16(half 0xH63D0)
 ; CHECK-NEXT:    store volatile half [[P1000]], half* [[P]], align 2
 ; CHECK-NEXT:    [[N1000:%.*]] = call half @llvm.amdgcn.cos.f16(half 0xHE3D0)
 ; CHECK-NEXT:    store volatile half [[N1000]], half* [[P]], align 2
 ; CHECK-NEXT:    [[PINF:%.*]] = call half @llvm.amdgcn.cos.f16(half 0xH7C00)
 ; CHECK-NEXT:    store volatile half [[PINF]], half* [[P]], align 2
 ; CHECK-NEXT:    [[NINF:%.*]] = call half @llvm.amdgcn.cos.f16(half 0xHFC00)
 ; CHECK-NEXT:    store volatile half [[NINF]], half* [[P]], align 2
 ; CHECK-NEXT:    [[NAN:%.*]] = call half @llvm.amdgcn.cos.f16(half 0xH7E00)
 ; CHECK-NEXT:    store volatile half [[NAN]], half* [[P]], align 2
 ; CHECK-NEXT:    ret void
 ;
   %p0 = call half @llvm.amdgcn.cos.f16(half +0.0)
   store volatile half %p0, half* %p
   %n0 = call half @llvm.amdgcn.cos.f16(half -0.0)
   store volatile half %n0, half* %p
   %p0125 = call half @llvm.amdgcn.cos.f16(half +0.125)
   store volatile half %p0125, half* %p
   %n0125 = call half @llvm.amdgcn.cos.f16(half -0.125)
   store volatile half %n0125, half* %p
   %p025 = call half @llvm.amdgcn.cos.f16(half +0.25)
   store volatile half %p025, half* %p
   %n025 = call half @llvm.amdgcn.cos.f16(half -0.25)
   store volatile half %n025, half* %p
   %p05 = call half @llvm.amdgcn.cos.f16(half +0.5)
   store volatile half %p05, half* %p
   %n05 = call half @llvm.amdgcn.cos.f16(half -0.5)
   store volatile half %n05, half* %p
   %p1 = call half @llvm.amdgcn.cos.f16(half +1.0)
   store volatile half %p1, half* %p
   %n1 = call half @llvm.amdgcn.cos.f16(half -1.0)
   store volatile half %n1, half* %p
   %p256 = call half @llvm.amdgcn.cos.f16(half +256.0)
   store volatile half %p256, half* %p
   %n256 = call half @llvm.amdgcn.cos.f16(half -256.0)
   store volatile half %n256, half* %p
   %p1000 = call half @llvm.amdgcn.cos.f16(half +1000.0)
   store volatile half %p1000, half* %p
   %n1000 = call half @llvm.amdgcn.cos.f16(half -1000.0)
   store volatile half %n1000, half* %p
   %pinf = call half @llvm.amdgcn.cos.f16(half 0xH7C00) ; +inf
   store volatile half %pinf, half* %p
   %ninf = call half @llvm.amdgcn.cos.f16(half 0xHFC00) ; -inf
   store volatile half %ninf, half* %p
   %nan = call half @llvm.amdgcn.cos.f16(half 0xH7E00) ; nan
   store volatile half %nan, half* %p
   ret void
 }
 
 define void @test_f32(float* %p) {
 ; CHECK-LABEL: @test_f32(
 ; CHECK-NEXT:    store volatile float 1.000000e+00, float* [[P:%.*]], align 4
 ; CHECK-NEXT:    store volatile float 1.000000e+00, float* [[P]], align 4
 ; CHECK-NEXT:    store volatile float 0x3FE6A09E60000000, float* [[P]], align 4
 ; CHECK-NEXT:    store volatile float 0x3FE6A09E60000000, float* [[P]], align 4
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]], align 4
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]], align 4
 ; CHECK-NEXT:    store volatile float -1.000000e+00, float* [[P]], align 4
 ; CHECK-NEXT:    store volatile float -1.000000e+00, float* [[P]], align 4
 ; CHECK-NEXT:    store volatile float 1.000000e+00, float* [[P]], align 4
 ; CHECK-NEXT:    store volatile float 1.000000e+00, float* [[P]], align 4
 ; CHECK-NEXT:    store volatile float 1.000000e+00, float* [[P]], align 4
 ; CHECK-NEXT:    store volatile float 1.000000e+00, float* [[P]], align 4
 ; CHECK-NEXT:    [[P1000:%.*]] = call float @llvm.amdgcn.cos.f32(float 1.000000e+03)
 ; CHECK-NEXT:    store volatile float [[P1000]], float* [[P]], align 4
 ; CHECK-NEXT:    [[N1000:%.*]] = call float @llvm.amdgcn.cos.f32(float -1.000000e+03)
 ; CHECK-NEXT:    store volatile float [[N1000]], float* [[P]], align 4
 ; CHECK-NEXT:    [[PINF:%.*]] = call float @llvm.amdgcn.cos.f32(float 0x7FF0000000000000)
 ; CHECK-NEXT:    store volatile float [[PINF]], float* [[P]], align 4
 ; CHECK-NEXT:    [[NINF:%.*]] = call float @llvm.amdgcn.cos.f32(float 0xFFF0000000000000)
 ; CHECK-NEXT:    store volatile float [[NINF]], float* [[P]], align 4
 ; CHECK-NEXT:    [[NAN:%.*]] = call float @llvm.amdgcn.cos.f32(float 0x7FF8000000000000)
 ; CHECK-NEXT:    store volatile float [[NAN]], float* [[P]], align 4
 ; CHECK-NEXT:    ret void
 ;
   %p0 = call float @llvm.amdgcn.cos.f32(float +0.0)
   store volatile float %p0, float* %p
   %n0 = call float @llvm.amdgcn.cos.f32(float -0.0)
   store volatile float %n0, float* %p
   %p0125 = call float @llvm.amdgcn.cos.f32(float +0.125)
   store volatile float %p0125, float* %p
   %n0125 = call float @llvm.amdgcn.cos.f32(float -0.125)
   store volatile float %n0125, float* %p
   %p025 = call float @llvm.amdgcn.cos.f32(float +0.25)
   store volatile float %p025, float* %p
   %n025 = call float @llvm.amdgcn.cos.f32(float -0.25)
   store volatile float %n025, float* %p
   %p05 = call float @llvm.amdgcn.cos.f32(float +0.5)
   store volatile float %p05, float* %p
   %n05 = call float @llvm.amdgcn.cos.f32(float -0.5)
   store volatile float %n05, float* %p
   %p1 = call float @llvm.amdgcn.cos.f32(float +1.0)
   store volatile float %p1, float* %p
   %n1 = call float @llvm.amdgcn.cos.f32(float -1.0)
   store volatile float %n1, float* %p
   %p256 = call float @llvm.amdgcn.cos.f32(float +256.0)
   store volatile float %p256, float* %p
   %n256 = call float @llvm.amdgcn.cos.f32(float -256.0)
   store volatile float %n256, float* %p
   %p1000 = call float @llvm.amdgcn.cos.f32(float +1000.0)
   store volatile float %p1000, float* %p
   %n1000 = call float @llvm.amdgcn.cos.f32(float -1000.0)
   store volatile float %n1000, float* %p
   %pinf = call float @llvm.amdgcn.cos.f32(float 0x7FF0000000000000) ; +inf
   store volatile float %pinf, float* %p
   %ninf = call float @llvm.amdgcn.cos.f32(float 0xFFF0000000000000) ; -inf
   store volatile float %ninf, float* %p
   %nan = call float @llvm.amdgcn.cos.f32(float 0x7FF8000000000000) ; nan
   store volatile float %nan, float* %p
   ret void
 }
 
 define void @test_f64(double* %p) {
 ; CHECK-LABEL: @test_f64(
 ; CHECK-NEXT:    store volatile double 1.000000e+00, double* [[P:%.*]], align 8
 ; CHECK-NEXT:    store volatile double 1.000000e+00, double* [[P]], align 8
 ; CHECK-NEXT:    store volatile double 0x3FE6A09E667F3B{{.*}}, double* [[P]], align 8
 ; CHECK-NEXT:    store volatile double 0x3FE6A09E667F3B{{.*}}, double* [[P]], align 8
 ; CHECK-NEXT:    store volatile double 0.000000e+00, double* [[P]], align 8
 ; CHECK-NEXT:    store volatile double 0.000000e+00, double* [[P]], align 8
 ; CHECK-NEXT:    store volatile double -1.000000e+00, double* [[P]], align 8
 ; CHECK-NEXT:    store volatile double -1.000000e+00, double* [[P]], align 8
 ; CHECK-NEXT:    store volatile double 1.000000e+00, double* [[P]], align 8
 ; CHECK-NEXT:    store volatile double 1.000000e+00, double* [[P]], align 8
 ; CHECK-NEXT:    store volatile double 1.000000e+00, double* [[P]], align 8
 ; CHECK-NEXT:    store volatile double 1.000000e+00, double* [[P]], align 8
 ; CHECK-NEXT:    [[P1000:%.*]] = call double @llvm.amdgcn.cos.f64(double 1.000000e+03)
 ; CHECK-NEXT:    store volatile double [[P1000]], double* [[P]], align 8
 ; CHECK-NEXT:    [[N1000:%.*]] = call double @llvm.amdgcn.cos.f64(double -1.000000e+03)
 ; CHECK-NEXT:    store volatile double [[N1000]], double* [[P]], align 8
 ; CHECK-NEXT:    [[PINF:%.*]] = call double @llvm.amdgcn.cos.f64(double 0x7FF0000000000000)
 ; CHECK-NEXT:    store volatile double [[PINF]], double* [[P]], align 8
 ; CHECK-NEXT:    [[NINF:%.*]] = call double @llvm.amdgcn.cos.f64(double 0xFFF0000000000000)
 ; CHECK-NEXT:    store volatile double [[NINF]], double* [[P]], align 8
 ; CHECK-NEXT:    [[NAN:%.*]] = call double @llvm.amdgcn.cos.f64(double 0x7FF8000000000000)
 ; CHECK-NEXT:    store volatile double [[NAN]], double* [[P]], align 8
 ; CHECK-NEXT:    ret void
 ;
   %p0 = call double @llvm.amdgcn.cos.f64(double +0.0)
   store volatile double %p0, double* %p
   %n0 = call double @llvm.amdgcn.cos.f64(double -0.0)
   store volatile double %n0, double* %p
   %p0125 = call double @llvm.amdgcn.cos.f64(double +0.125)
   store volatile double %p0125, double* %p
   %n0125 = call double @llvm.amdgcn.cos.f64(double -0.125)
   store volatile double %n0125, double* %p
   %p025 = call double @llvm.amdgcn.cos.f64(double +0.25)
   store volatile double %p025, double* %p
   %n025 = call double @llvm.amdgcn.cos.f64(double -0.25)
   store volatile double %n025, double* %p
   %p05 = call double @llvm.amdgcn.cos.f64(double +0.5)
   store volatile double %p05, double* %p
   %n05 = call double @llvm.amdgcn.cos.f64(double -0.5)
   store volatile double %n05, double* %p
   %p1 = call double @llvm.amdgcn.cos.f64(double +1.0)
   store volatile double %p1, double* %p
   %n1 = call double @llvm.amdgcn.cos.f64(double -1.0)
   store volatile double %n1, double* %p
   %p256 = call double @llvm.amdgcn.cos.f64(double +256.0)
   store volatile double %p256, double* %p
   %n256 = call double @llvm.amdgcn.cos.f64(double -256.0)
   store volatile double %n256, double* %p
   %p1000 = call double @llvm.amdgcn.cos.f64(double +1000.0)
   store volatile double %p1000, double* %p
   %n1000 = call double @llvm.amdgcn.cos.f64(double -1000.0)
   store volatile double %n1000, double* %p
   %pinf = call double @llvm.amdgcn.cos.f64(double 0x7FF0000000000000) ; +inf
   store volatile double %pinf, double* %p
   %ninf = call double @llvm.amdgcn.cos.f64(double 0xFFF0000000000000) ; -inf
   store volatile double %ninf, double* %p
   %nan = call double @llvm.amdgcn.cos.f64(double 0x7FF8000000000000) ; nan
   store volatile double %nan, double* %p
   ret void
 }
 
 define void @test_f16_strictfp (half* %p) #1 {
 ; CHECK-LABEL: @test_f16_strictfp(
 ; CHECK-NEXT:    [[P0:%.*]] = call half @llvm.amdgcn.cos.f16(half 0xH0000) #1
 ; CHECK-NEXT:    store volatile half [[P0]], half* [[P:%.*]], align 2
 ; CHECK-NEXT:    [[P025:%.*]] = call half @llvm.amdgcn.cos.f16(half 0xH3400) #1
 ; CHECK-NEXT:    store volatile half [[P025]], half* [[P]], align 2
 ; CHECK-NEXT:    ret void
 ;
   %p0 = call half @llvm.amdgcn.cos.f16(half +0.0) #1
   store volatile half %p0, half* %p
   %p025 = call half @llvm.amdgcn.cos.f16(half +0.25) #1
   store volatile half %p025, half* %p
   ret void
 }
 
 define void @test_f32_strictfp(float* %p) #1 {
 ; CHECK-LABEL: @test_f32_strictfp(
 ; CHECK-NEXT:    [[P0:%.*]] = call float @llvm.amdgcn.cos.f32(float 0.000000e+00) #1
 ; CHECK-NEXT:    store volatile float [[P0]], float* [[P:%.*]], align 4
 ; CHECK-NEXT:    [[P025:%.*]] = call float @llvm.amdgcn.cos.f32(float 2.500000e-01) #1
 ; CHECK-NEXT:    store volatile float [[P025]], float* [[P]], align 4
 ; CHECK-NEXT:    ret void
 ;
   %p0 = call float @llvm.amdgcn.cos.f32(float +0.0) #1
   store volatile float %p0, float* %p
   %p025 = call float @llvm.amdgcn.cos.f32(float +0.25) #1
   store volatile float %p025, float* %p
   ret void
 }
 
 define void @test_f64_strictfp(double* %p) #1 {
 ; CHECK-LABEL: @test_f64_strictfp(
 ; CHECK-NEXT:    [[P0:%.*]] = call double @llvm.amdgcn.cos.f64(double 0.000000e+00) #1
 ; CHECK-NEXT:    store volatile double [[P0]], double* [[P:%.*]], align 8
 ; CHECK-NEXT:    [[P025:%.*]] = call double @llvm.amdgcn.cos.f64(double 2.500000e-01) #1
 ; CHECK-NEXT:    store volatile double [[P025]], double* [[P]], align 8
 ; CHECK-NEXT:    ret void
 ;
   %p0 = call double @llvm.amdgcn.cos.f64(double +0.0) #1
   store volatile double %p0, double* %p
   %p025 = call double @llvm.amdgcn.cos.f64(double +0.25) #1
   store volatile double %p025, double* %p
   ret void
 }
 
 attributes #0 = { nounwind readnone speculatable }
 attributes #1 = { strictfp }

llvm/test/Transforms/InstSimplify/ConstProp/AMDGPU/cubeid.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 declare float @llvm.amdgcn.cubeid(float, float, float)
 
 define void @test(float* %p) {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P:%.*]]
 ; CHECK-NEXT:    store volatile float 2.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 2.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 5.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 2.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 5.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 2.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 5.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 5.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 2.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 2.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 5.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 2.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 5.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 2.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 5.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 5.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+00, float* [[P]]
 ; CHECK-NEXT:    ret void
 ;
   %p3p4p5 = call float @llvm.amdgcn.cubeid(float +3.0, float +4.0, float +5.0)
   store volatile float %p3p4p5, float* %p
   %p3p5p4 = call float @llvm.amdgcn.cubeid(float +3.0, float +5.0, float +4.0)
   store volatile float %p3p5p4, float* %p
   %p4p3p5 = call float @llvm.amdgcn.cubeid(float +4.0, float +3.0, float +5.0)
   store volatile float %p4p3p5, float* %p
   %p4p5p3 = call float @llvm.amdgcn.cubeid(float +4.0, float +5.0, float +3.0)
   store volatile float %p4p5p3, float* %p
   %p5p3p4 = call float @llvm.amdgcn.cubeid(float +5.0, float +3.0, float +4.0)
   store volatile float %p5p3p4, float* %p
   %p5p4p3 = call float @llvm.amdgcn.cubeid(float +5.0, float +4.0, float +3.0)
   store volatile float %p5p4p3, float* %p
   %p3p4n5 = call float @llvm.amdgcn.cubeid(float +3.0, float +4.0, float -5.0)
   store volatile float %p3p4n5, float* %p
   %p3p5n4 = call float @llvm.amdgcn.cubeid(float +3.0, float +5.0, float -4.0)
   store volatile float %p3p5n4, float* %p
   %p4p3n5 = call float @llvm.amdgcn.cubeid(float +4.0, float +3.0, float -5.0)
   store volatile float %p4p3n5, float* %p
   %p4p5n3 = call float @llvm.amdgcn.cubeid(float +4.0, float +5.0, float -3.0)
   store volatile float %p4p5n3, float* %p
   %p5p3n4 = call float @llvm.amdgcn.cubeid(float +5.0, float +3.0, float -4.0)
   store volatile float %p5p3n4, float* %p
   %p5p4n3 = call float @llvm.amdgcn.cubeid(float +5.0, float +4.0, float -3.0)
   store volatile float %p5p4n3, float* %p
   %p3n4p5 = call float @llvm.amdgcn.cubeid(float +3.0, float -4.0, float +5.0)
   store volatile float %p3n4p5, float* %p
   %p3n5p4 = call float @llvm.amdgcn.cubeid(float +3.0, float -5.0, float +4.0)
   store volatile float %p3n5p4, float* %p
   %p4n3p5 = call float @llvm.amdgcn.cubeid(float +4.0, float -3.0, float +5.0)
   store volatile float %p4n3p5, float* %p
   %p4n5p3 = call float @llvm.amdgcn.cubeid(float +4.0, float -5.0, float +3.0)
   store volatile float %p4n5p3, float* %p
   %p5n3p4 = call float @llvm.amdgcn.cubeid(float +5.0, float -3.0, float +4.0)
   store volatile float %p5n3p4, float* %p
   %p5n4p3 = call float @llvm.amdgcn.cubeid(float +5.0, float -4.0, float +3.0)
   store volatile float %p5n4p3, float* %p
   %p3n4n5 = call float @llvm.amdgcn.cubeid(float +3.0, float -4.0, float -5.0)
   store volatile float %p3n4n5, float* %p
   %p3n5n4 = call float @llvm.amdgcn.cubeid(float +3.0, float -5.0, float -4.0)
   store volatile float %p3n5n4, float* %p
   %p4n3n5 = call float @llvm.amdgcn.cubeid(float +4.0, float -3.0, float -5.0)
   store volatile float %p4n3n5, float* %p
   %p4n5n3 = call float @llvm.amdgcn.cubeid(float +4.0, float -5.0, float -3.0)
   store volatile float %p4n5n3, float* %p
   %p5n3n4 = call float @llvm.amdgcn.cubeid(float +5.0, float -3.0, float -4.0)
   store volatile float %p5n3n4, float* %p
   %p5n4n3 = call float @llvm.amdgcn.cubeid(float +5.0, float -4.0, float -3.0)
   store volatile float %p5n4n3, float* %p
   %n3p4p5 = call float @llvm.amdgcn.cubeid(float -3.0, float +4.0, float +5.0)
   store volatile float %n3p4p5, float* %p
   %n3p5p4 = call float @llvm.amdgcn.cubeid(float -3.0, float +5.0, float +4.0)
   store volatile float %n3p5p4, float* %p
   %n4p3p5 = call float @llvm.amdgcn.cubeid(float -4.0, float +3.0, float +5.0)
   store volatile float %n4p3p5, float* %p
   %n4p5p3 = call float @llvm.amdgcn.cubeid(float -4.0, float +5.0, float +3.0)
   store volatile float %n4p5p3, float* %p
   %n5p3p4 = call float @llvm.amdgcn.cubeid(float -5.0, float +3.0, float +4.0)
   store volatile float %n5p3p4, float* %p
   %n5p4p3 = call float @llvm.amdgcn.cubeid(float -5.0, float +4.0, float +3.0)
   store volatile float %n5p4p3, float* %p
   %n3p4n5 = call float @llvm.amdgcn.cubeid(float -3.0, float +4.0, float -5.0)
   store volatile float %n3p4n5, float* %p
   %n3p5n4 = call float @llvm.amdgcn.cubeid(float -3.0, float +5.0, float -4.0)
   store volatile float %n3p5n4, float* %p
   %n4p3n5 = call float @llvm.amdgcn.cubeid(float -4.0, float +3.0, float -5.0)
   store volatile float %n4p3n5, float* %p
   %n4p5n3 = call float @llvm.amdgcn.cubeid(float -4.0, float +5.0, float -3.0)
   store volatile float %n4p5n3, float* %p
   %n5p3n4 = call float @llvm.amdgcn.cubeid(float -5.0, float +3.0, float -4.0)
   store volatile float %n5p3n4, float* %p
   %n5p4n3 = call float @llvm.amdgcn.cubeid(float -5.0, float +4.0, float -3.0)
   store volatile float %n5p4n3, float* %p
   %n3n4p5 = call float @llvm.amdgcn.cubeid(float -3.0, float -4.0, float +5.0)
   store volatile float %n3n4p5, float* %p
   %n3n5p4 = call float @llvm.amdgcn.cubeid(float -3.0, float -5.0, float +4.0)
   store volatile float %n3n5p4, float* %p
   %n4n3p5 = call float @llvm.amdgcn.cubeid(float -4.0, float -3.0, float +5.0)
   store volatile float %n4n3p5, float* %p
   %n4n5p3 = call float @llvm.amdgcn.cubeid(float -4.0, float -5.0, float +3.0)
   store volatile float %n4n5p3, float* %p
   %n5n3p4 = call float @llvm.amdgcn.cubeid(float -5.0, float -3.0, float +4.0)
   store volatile float %n5n3p4, float* %p
   %n5n4p3 = call float @llvm.amdgcn.cubeid(float -5.0, float -4.0, float +3.0)
   store volatile float %n5n4p3, float* %p
   %n3n4n5 = call float @llvm.amdgcn.cubeid(float -3.0, float -4.0, float -5.0)
   store volatile float %n3n4n5, float* %p
   %n3n5n4 = call float @llvm.amdgcn.cubeid(float -3.0, float -5.0, float -4.0)
   store volatile float %n3n5n4, float* %p
   %n4n3n5 = call float @llvm.amdgcn.cubeid(float -4.0, float -3.0, float -5.0)
   store volatile float %n4n3n5, float* %p
   %n4n5n3 = call float @llvm.amdgcn.cubeid(float -4.0, float -5.0, float -3.0)
   store volatile float %n4n5n3, float* %p
   %n5n3n4 = call float @llvm.amdgcn.cubeid(float -5.0, float -3.0, float -4.0)
   store volatile float %n5n3n4, float* %p
   %n5n4n3 = call float @llvm.amdgcn.cubeid(float -5.0, float -4.0, float -3.0)
   store volatile float %n5n4n3, float* %p
   ret void
 }

llvm/test/Transforms/InstSimplify/ConstProp/AMDGPU/cubema.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 declare float @llvm.amdgcn.cubema(float, float, float)
 
 define void @test(float* %p) {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P:%.*]]
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    store volatile float -1.000000e+01, float* [[P]]
 ; CHECK-NEXT:    ret void
 ;
   %p3p4p5 = call float @llvm.amdgcn.cubema(float +3.0, float +4.0, float +5.0)
   store volatile float %p3p4p5, float* %p
   %p3p5p4 = call float @llvm.amdgcn.cubema(float +3.0, float +5.0, float +4.0)
   store volatile float %p3p5p4, float* %p
   %p4p3p5 = call float @llvm.amdgcn.cubema(float +4.0, float +3.0, float +5.0)
   store volatile float %p4p3p5, float* %p
   %p4p5p3 = call float @llvm.amdgcn.cubema(float +4.0, float +5.0, float +3.0)
   store volatile float %p4p5p3, float* %p
   %p5p3p4 = call float @llvm.amdgcn.cubema(float +5.0, float +3.0, float +4.0)
   store volatile float %p5p3p4, float* %p
   %p5p4p3 = call float @llvm.amdgcn.cubema(float +5.0, float +4.0, float +3.0)
   store volatile float %p5p4p3, float* %p
   %p3p4n5 = call float @llvm.amdgcn.cubema(float +3.0, float +4.0, float -5.0)
   store volatile float %p3p4n5, float* %p
   %p3p5n4 = call float @llvm.amdgcn.cubema(float +3.0, float +5.0, float -4.0)
   store volatile float %p3p5n4, float* %p
   %p4p3n5 = call float @llvm.amdgcn.cubema(float +4.0, float +3.0, float -5.0)
   store volatile float %p4p3n5, float* %p
   %p4p5n3 = call float @llvm.amdgcn.cubema(float +4.0, float +5.0, float -3.0)
   store volatile float %p4p5n3, float* %p
   %p5p3n4 = call float @llvm.amdgcn.cubema(float +5.0, float +3.0, float -4.0)
   store volatile float %p5p3n4, float* %p
   %p5p4n3 = call float @llvm.amdgcn.cubema(float +5.0, float +4.0, float -3.0)
   store volatile float %p5p4n3, float* %p
   %p3n4p5 = call float @llvm.amdgcn.cubema(float +3.0, float -4.0, float +5.0)
   store volatile float %p3n4p5, float* %p
   %p3n5p4 = call float @llvm.amdgcn.cubema(float +3.0, float -5.0, float +4.0)
   store volatile float %p3n5p4, float* %p
   %p4n3p5 = call float @llvm.amdgcn.cubema(float +4.0, float -3.0, float +5.0)
   store volatile float %p4n3p5, float* %p
   %p4n5p3 = call float @llvm.amdgcn.cubema(float +4.0, float -5.0, float +3.0)
   store volatile float %p4n5p3, float* %p
   %p5n3p4 = call float @llvm.amdgcn.cubema(float +5.0, float -3.0, float +4.0)
   store volatile float %p5n3p4, float* %p
   %p5n4p3 = call float @llvm.amdgcn.cubema(float +5.0, float -4.0, float +3.0)
   store volatile float %p5n4p3, float* %p
   %p3n4n5 = call float @llvm.amdgcn.cubema(float +3.0, float -4.0, float -5.0)
   store volatile float %p3n4n5, float* %p
   %p3n5n4 = call float @llvm.amdgcn.cubema(float +3.0, float -5.0, float -4.0)
   store volatile float %p3n5n4, float* %p
   %p4n3n5 = call float @llvm.amdgcn.cubema(float +4.0, float -3.0, float -5.0)
   store volatile float %p4n3n5, float* %p
   %p4n5n3 = call float @llvm.amdgcn.cubema(float +4.0, float -5.0, float -3.0)
   store volatile float %p4n5n3, float* %p
   %p5n3n4 = call float @llvm.amdgcn.cubema(float +5.0, float -3.0, float -4.0)
   store volatile float %p5n3n4, float* %p
   %p5n4n3 = call float @llvm.amdgcn.cubema(float +5.0, float -4.0, float -3.0)
   store volatile float %p5n4n3, float* %p
   %n3p4p5 = call float @llvm.amdgcn.cubema(float -3.0, float +4.0, float +5.0)
   store volatile float %n3p4p5, float* %p
   %n3p5p4 = call float @llvm.amdgcn.cubema(float -3.0, float +5.0, float +4.0)
   store volatile float %n3p5p4, float* %p
   %n4p3p5 = call float @llvm.amdgcn.cubema(float -4.0, float +3.0, float +5.0)
   store volatile float %n4p3p5, float* %p
   %n4p5p3 = call float @llvm.amdgcn.cubema(float -4.0, float +5.0, float +3.0)
   store volatile float %n4p5p3, float* %p
   %n5p3p4 = call float @llvm.amdgcn.cubema(float -5.0, float +3.0, float +4.0)
   store volatile float %n5p3p4, float* %p
   %n5p4p3 = call float @llvm.amdgcn.cubema(float -5.0, float +4.0, float +3.0)
   store volatile float %n5p4p3, float* %p
   %n3p4n5 = call float @llvm.amdgcn.cubema(float -3.0, float +4.0, float -5.0)
   store volatile float %n3p4n5, float* %p
   %n3p5n4 = call float @llvm.amdgcn.cubema(float -3.0, float +5.0, float -4.0)
   store volatile float %n3p5n4, float* %p
   %n4p3n5 = call float @llvm.amdgcn.cubema(float -4.0, float +3.0, float -5.0)
   store volatile float %n4p3n5, float* %p
   %n4p5n3 = call float @llvm.amdgcn.cubema(float -4.0, float +5.0, float -3.0)
   store volatile float %n4p5n3, float* %p
   %n5p3n4 = call float @llvm.amdgcn.cubema(float -5.0, float +3.0, float -4.0)
   store volatile float %n5p3n4, float* %p
   %n5p4n3 = call float @llvm.amdgcn.cubema(float -5.0, float +4.0, float -3.0)
   store volatile float %n5p4n3, float* %p
   %n3n4p5 = call float @llvm.amdgcn.cubema(float -3.0, float -4.0, float +5.0)
   store volatile float %n3n4p5, float* %p
   %n3n5p4 = call float @llvm.amdgcn.cubema(float -3.0, float -5.0, float +4.0)
   store volatile float %n3n5p4, float* %p
   %n4n3p5 = call float @llvm.amdgcn.cubema(float -4.0, float -3.0, float +5.0)
   store volatile float %n4n3p5, float* %p
   %n4n5p3 = call float @llvm.amdgcn.cubema(float -4.0, float -5.0, float +3.0)
   store volatile float %n4n5p3, float* %p
   %n5n3p4 = call float @llvm.amdgcn.cubema(float -5.0, float -3.0, float +4.0)
   store volatile float %n5n3p4, float* %p
   %n5n4p3 = call float @llvm.amdgcn.cubema(float -5.0, float -4.0, float +3.0)
   store volatile float %n5n4p3, float* %p
   %n3n4n5 = call float @llvm.amdgcn.cubema(float -3.0, float -4.0, float -5.0)
   store volatile float %n3n4n5, float* %p
   %n3n5n4 = call float @llvm.amdgcn.cubema(float -3.0, float -5.0, float -4.0)
   store volatile float %n3n5n4, float* %p
   %n4n3n5 = call float @llvm.amdgcn.cubema(float -4.0, float -3.0, float -5.0)
   store volatile float %n4n3n5, float* %p
   %n4n5n3 = call float @llvm.amdgcn.cubema(float -4.0, float -5.0, float -3.0)
   store volatile float %n4n5n3, float* %p
   %n5n3n4 = call float @llvm.amdgcn.cubema(float -5.0, float -3.0, float -4.0)
   store volatile float %n5n3n4, float* %p
   %n5n4n3 = call float @llvm.amdgcn.cubema(float -5.0, float -4.0, float -3.0)
   store volatile float %n5n4n3, float* %p
   ret void
 }

llvm/test/Transforms/InstSimplify/ConstProp/AMDGPU/cubesc.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 declare float @llvm.amdgcn.cubesc(float, float, float)
 
 define void @test(float* %p) {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P:%.*]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    ret void
 ;
   %p3p4p5 = call float @llvm.amdgcn.cubesc(float +3.0, float +4.0, float +5.0)
   store volatile float %p3p4p5, float* %p
   %p3p5p4 = call float @llvm.amdgcn.cubesc(float +3.0, float +5.0, float +4.0)
   store volatile float %p3p5p4, float* %p
   %p4p3p5 = call float @llvm.amdgcn.cubesc(float +4.0, float +3.0, float +5.0)
   store volatile float %p4p3p5, float* %p
   %p4p5p3 = call float @llvm.amdgcn.cubesc(float +4.0, float +5.0, float +3.0)
   store volatile float %p4p5p3, float* %p
   %p5p3p4 = call float @llvm.amdgcn.cubesc(float +5.0, float +3.0, float +4.0)
   store volatile float %p5p3p4, float* %p
   %p5p4p3 = call float @llvm.amdgcn.cubesc(float +5.0, float +4.0, float +3.0)
   store volatile float %p5p4p3, float* %p
   %p3p4n5 = call float @llvm.amdgcn.cubesc(float +3.0, float +4.0, float -5.0)
   store volatile float %p3p4n5, float* %p
   %p3p5n4 = call float @llvm.amdgcn.cubesc(float +3.0, float +5.0, float -4.0)
   store volatile float %p3p5n4, float* %p
   %p4p3n5 = call float @llvm.amdgcn.cubesc(float +4.0, float +3.0, float -5.0)
   store volatile float %p4p3n5, float* %p
   %p4p5n3 = call float @llvm.amdgcn.cubesc(float +4.0, float +5.0, float -3.0)
   store volatile float %p4p5n3, float* %p
   %p5p3n4 = call float @llvm.amdgcn.cubesc(float +5.0, float +3.0, float -4.0)
   store volatile float %p5p3n4, float* %p
   %p5p4n3 = call float @llvm.amdgcn.cubesc(float +5.0, float +4.0, float -3.0)
   store volatile float %p5p4n3, float* %p
   %p3n4p5 = call float @llvm.amdgcn.cubesc(float +3.0, float -4.0, float +5.0)
   store volatile float %p3n4p5, float* %p
   %p3n5p4 = call float @llvm.amdgcn.cubesc(float +3.0, float -5.0, float +4.0)
   store volatile float %p3n5p4, float* %p
   %p4n3p5 = call float @llvm.amdgcn.cubesc(float +4.0, float -3.0, float +5.0)
   store volatile float %p4n3p5, float* %p
   %p4n5p3 = call float @llvm.amdgcn.cubesc(float +4.0, float -5.0, float +3.0)
   store volatile float %p4n5p3, float* %p
   %p5n3p4 = call float @llvm.amdgcn.cubesc(float +5.0, float -3.0, float +4.0)
   store volatile float %p5n3p4, float* %p
   %p5n4p3 = call float @llvm.amdgcn.cubesc(float +5.0, float -4.0, float +3.0)
   store volatile float %p5n4p3, float* %p
   %p3n4n5 = call float @llvm.amdgcn.cubesc(float +3.0, float -4.0, float -5.0)
   store volatile float %p3n4n5, float* %p
   %p3n5n4 = call float @llvm.amdgcn.cubesc(float +3.0, float -5.0, float -4.0)
   store volatile float %p3n5n4, float* %p
   %p4n3n5 = call float @llvm.amdgcn.cubesc(float +4.0, float -3.0, float -5.0)
   store volatile float %p4n3n5, float* %p
   %p4n5n3 = call float @llvm.amdgcn.cubesc(float +4.0, float -5.0, float -3.0)
   store volatile float %p4n5n3, float* %p
   %p5n3n4 = call float @llvm.amdgcn.cubesc(float +5.0, float -3.0, float -4.0)
   store volatile float %p5n3n4, float* %p
   %p5n4n3 = call float @llvm.amdgcn.cubesc(float +5.0, float -4.0, float -3.0)
   store volatile float %p5n4n3, float* %p
   %n3p4p5 = call float @llvm.amdgcn.cubesc(float -3.0, float +4.0, float +5.0)
   store volatile float %n3p4p5, float* %p
   %n3p5p4 = call float @llvm.amdgcn.cubesc(float -3.0, float +5.0, float +4.0)
   store volatile float %n3p5p4, float* %p
   %n4p3p5 = call float @llvm.amdgcn.cubesc(float -4.0, float +3.0, float +5.0)
   store volatile float %n4p3p5, float* %p
   %n4p5p3 = call float @llvm.amdgcn.cubesc(float -4.0, float +5.0, float +3.0)
   store volatile float %n4p5p3, float* %p
   %n5p3p4 = call float @llvm.amdgcn.cubesc(float -5.0, float +3.0, float +4.0)
   store volatile float %n5p3p4, float* %p
   %n5p4p3 = call float @llvm.amdgcn.cubesc(float -5.0, float +4.0, float +3.0)
   store volatile float %n5p4p3, float* %p
   %n3p4n5 = call float @llvm.amdgcn.cubesc(float -3.0, float +4.0, float -5.0)
   store volatile float %n3p4n5, float* %p
   %n3p5n4 = call float @llvm.amdgcn.cubesc(float -3.0, float +5.0, float -4.0)
   store volatile float %n3p5n4, float* %p
   %n4p3n5 = call float @llvm.amdgcn.cubesc(float -4.0, float +3.0, float -5.0)
   store volatile float %n4p3n5, float* %p
   %n4p5n3 = call float @llvm.amdgcn.cubesc(float -4.0, float +5.0, float -3.0)
   store volatile float %n4p5n3, float* %p
   %n5p3n4 = call float @llvm.amdgcn.cubesc(float -5.0, float +3.0, float -4.0)
   store volatile float %n5p3n4, float* %p
   %n5p4n3 = call float @llvm.amdgcn.cubesc(float -5.0, float +4.0, float -3.0)
   store volatile float %n5p4n3, float* %p
   %n3n4p5 = call float @llvm.amdgcn.cubesc(float -3.0, float -4.0, float +5.0)
   store volatile float %n3n4p5, float* %p
   %n3n5p4 = call float @llvm.amdgcn.cubesc(float -3.0, float -5.0, float +4.0)
   store volatile float %n3n5p4, float* %p
   %n4n3p5 = call float @llvm.amdgcn.cubesc(float -4.0, float -3.0, float +5.0)
   store volatile float %n4n3p5, float* %p
   %n4n5p3 = call float @llvm.amdgcn.cubesc(float -4.0, float -5.0, float +3.0)
   store volatile float %n4n5p3, float* %p
   %n5n3p4 = call float @llvm.amdgcn.cubesc(float -5.0, float -3.0, float +4.0)
   store volatile float %n5n3p4, float* %p
   %n5n4p3 = call float @llvm.amdgcn.cubesc(float -5.0, float -4.0, float +3.0)
   store volatile float %n5n4p3, float* %p
   %n3n4n5 = call float @llvm.amdgcn.cubesc(float -3.0, float -4.0, float -5.0)
   store volatile float %n3n4n5, float* %p
   %n3n5n4 = call float @llvm.amdgcn.cubesc(float -3.0, float -5.0, float -4.0)
   store volatile float %n3n5n4, float* %p
   %n4n3n5 = call float @llvm.amdgcn.cubesc(float -4.0, float -3.0, float -5.0)
   store volatile float %n4n3n5, float* %p
   %n4n5n3 = call float @llvm.amdgcn.cubesc(float -4.0, float -5.0, float -3.0)
   store volatile float %n4n5n3, float* %p
   %n5n3n4 = call float @llvm.amdgcn.cubesc(float -5.0, float -3.0, float -4.0)
   store volatile float %n5n3n4, float* %p
   %n5n4n3 = call float @llvm.amdgcn.cubesc(float -5.0, float -4.0, float -3.0)
   store volatile float %n5n4n3, float* %p
   ret void
 }

llvm/test/Transforms/InstSimplify/ConstProp/AMDGPU/cubetc.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 declare float @llvm.amdgcn.cubetc(float, float, float)
 
 define void @test(float* %p) {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P:%.*]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float -3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 3.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 4.000000e+00, float* [[P]]
 ; CHECK-NEXT:    ret void
 ;
   %p3p4p5 = call float @llvm.amdgcn.cubetc(float +3.0, float +4.0, float +5.0)
   store volatile float %p3p4p5, float* %p
   %p3p5p4 = call float @llvm.amdgcn.cubetc(float +3.0, float +5.0, float +4.0)
   store volatile float %p3p5p4, float* %p
   %p4p3p5 = call float @llvm.amdgcn.cubetc(float +4.0, float +3.0, float +5.0)
   store volatile float %p4p3p5, float* %p
   %p4p5p3 = call float @llvm.amdgcn.cubetc(float +4.0, float +5.0, float +3.0)
   store volatile float %p4p5p3, float* %p
   %p5p3p4 = call float @llvm.amdgcn.cubetc(float +5.0, float +3.0, float +4.0)
   store volatile float %p5p3p4, float* %p
   %p5p4p3 = call float @llvm.amdgcn.cubetc(float +5.0, float +4.0, float +3.0)
   store volatile float %p5p4p3, float* %p
   %p3p4n5 = call float @llvm.amdgcn.cubetc(float +3.0, float +4.0, float -5.0)
   store volatile float %p3p4n5, float* %p
   %p3p5n4 = call float @llvm.amdgcn.cubetc(float +3.0, float +5.0, float -4.0)
   store volatile float %p3p5n4, float* %p
   %p4p3n5 = call float @llvm.amdgcn.cubetc(float +4.0, float +3.0, float -5.0)
   store volatile float %p4p3n5, float* %p
   %p4p5n3 = call float @llvm.amdgcn.cubetc(float +4.0, float +5.0, float -3.0)
   store volatile float %p4p5n3, float* %p
   %p5p3n4 = call float @llvm.amdgcn.cubetc(float +5.0, float +3.0, float -4.0)
   store volatile float %p5p3n4, float* %p
   %p5p4n3 = call float @llvm.amdgcn.cubetc(float +5.0, float +4.0, float -3.0)
   store volatile float %p5p4n3, float* %p
   %p3n4p5 = call float @llvm.amdgcn.cubetc(float +3.0, float -4.0, float +5.0)
   store volatile float %p3n4p5, float* %p
   %p3n5p4 = call float @llvm.amdgcn.cubetc(float +3.0, float -5.0, float +4.0)
   store volatile float %p3n5p4, float* %p
   %p4n3p5 = call float @llvm.amdgcn.cubetc(float +4.0, float -3.0, float +5.0)
   store volatile float %p4n3p5, float* %p
   %p4n5p3 = call float @llvm.amdgcn.cubetc(float +4.0, float -5.0, float +3.0)
   store volatile float %p4n5p3, float* %p
   %p5n3p4 = call float @llvm.amdgcn.cubetc(float +5.0, float -3.0, float +4.0)
   store volatile float %p5n3p4, float* %p
   %p5n4p3 = call float @llvm.amdgcn.cubetc(float +5.0, float -4.0, float +3.0)
   store volatile float %p5n4p3, float* %p
   %p3n4n5 = call float @llvm.amdgcn.cubetc(float +3.0, float -4.0, float -5.0)
   store volatile float %p3n4n5, float* %p
   %p3n5n4 = call float @llvm.amdgcn.cubetc(float +3.0, float -5.0, float -4.0)
   store volatile float %p3n5n4, float* %p
   %p4n3n5 = call float @llvm.amdgcn.cubetc(float +4.0, float -3.0, float -5.0)
   store volatile float %p4n3n5, float* %p
   %p4n5n3 = call float @llvm.amdgcn.cubetc(float +4.0, float -5.0, float -3.0)
   store volatile float %p4n5n3, float* %p
   %p5n3n4 = call float @llvm.amdgcn.cubetc(float +5.0, float -3.0, float -4.0)
   store volatile float %p5n3n4, float* %p
   %p5n4n3 = call float @llvm.amdgcn.cubetc(float +5.0, float -4.0, float -3.0)
   store volatile float %p5n4n3, float* %p
   %n3p4p5 = call float @llvm.amdgcn.cubetc(float -3.0, float +4.0, float +5.0)
   store volatile float %n3p4p5, float* %p
   %n3p5p4 = call float @llvm.amdgcn.cubetc(float -3.0, float +5.0, float +4.0)
   store volatile float %n3p5p4, float* %p
   %n4p3p5 = call float @llvm.amdgcn.cubetc(float -4.0, float +3.0, float +5.0)
   store volatile float %n4p3p5, float* %p
   %n4p5p3 = call float @llvm.amdgcn.cubetc(float -4.0, float +5.0, float +3.0)
   store volatile float %n4p5p3, float* %p
   %n5p3p4 = call float @llvm.amdgcn.cubetc(float -5.0, float +3.0, float +4.0)
   store volatile float %n5p3p4, float* %p
   %n5p4p3 = call float @llvm.amdgcn.cubetc(float -5.0, float +4.0, float +3.0)
   store volatile float %n5p4p3, float* %p
   %n3p4n5 = call float @llvm.amdgcn.cubetc(float -3.0, float +4.0, float -5.0)
   store volatile float %n3p4n5, float* %p
   %n3p5n4 = call float @llvm.amdgcn.cubetc(float -3.0, float +5.0, float -4.0)
   store volatile float %n3p5n4, float* %p
   %n4p3n5 = call float @llvm.amdgcn.cubetc(float -4.0, float +3.0, float -5.0)
   store volatile float %n4p3n5, float* %p
   %n4p5n3 = call float @llvm.amdgcn.cubetc(float -4.0, float +5.0, float -3.0)
   store volatile float %n4p5n3, float* %p
   %n5p3n4 = call float @llvm.amdgcn.cubetc(float -5.0, float +3.0, float -4.0)
   store volatile float %n5p3n4, float* %p
   %n5p4n3 = call float @llvm.amdgcn.cubetc(float -5.0, float +4.0, float -3.0)
   store volatile float %n5p4n3, float* %p
   %n3n4p5 = call float @llvm.amdgcn.cubetc(float -3.0, float -4.0, float +5.0)
   store volatile float %n3n4p5, float* %p
   %n3n5p4 = call float @llvm.amdgcn.cubetc(float -3.0, float -5.0, float +4.0)
   store volatile float %n3n5p4, float* %p
   %n4n3p5 = call float @llvm.amdgcn.cubetc(float -4.0, float -3.0, float +5.0)
   store volatile float %n4n3p5, float* %p
   %n4n5p3 = call float @llvm.amdgcn.cubetc(float -4.0, float -5.0, float +3.0)
   store volatile float %n4n5p3, float* %p
   %n5n3p4 = call float @llvm.amdgcn.cubetc(float -5.0, float -3.0, float +4.0)
   store volatile float %n5n3p4, float* %p
   %n5n4p3 = call float @llvm.amdgcn.cubetc(float -5.0, float -4.0, float +3.0)
   store volatile float %n5n4p3, float* %p
   %n3n4n5 = call float @llvm.amdgcn.cubetc(float -3.0, float -4.0, float -5.0)
   store volatile float %n3n4n5, float* %p
   %n3n5n4 = call float @llvm.amdgcn.cubetc(float -3.0, float -5.0, float -4.0)
   store volatile float %n3n5n4, float* %p
   %n4n3n5 = call float @llvm.amdgcn.cubetc(float -4.0, float -3.0, float -5.0)
   store volatile float %n4n3n5, float* %p
   %n4n5n3 = call float @llvm.amdgcn.cubetc(float -4.0, float -5.0, float -3.0)
   store volatile float %n4n5n3, float* %p
   %n5n3n4 = call float @llvm.amdgcn.cubetc(float -5.0, float -3.0, float -4.0)
   store volatile float %n5n3n4, float* %p
   %n5n4n3 = call float @llvm.amdgcn.cubetc(float -5.0, float -4.0, float -3.0)
   store volatile float %n5n4n3, float* %p
   ret void
 }

llvm/test/Transforms/InstSimplify/ConstProp/AMDGPU/fmul_legacy.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 declare float @llvm.amdgcn.fmul.legacy(float, float)
 
 define void @test(float* %p) {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:    store volatile float 6.000000e+00, float* [[P:%.*]]
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]]
 ; CHECK-NEXT:    ret void
 ;
   %a = call float @llvm.amdgcn.fmul.legacy(float +2.0, float +3.0)
   store volatile float %a, float* %p
   %b = call float @llvm.amdgcn.fmul.legacy(float +2.0, float +0.0)
   store volatile float %b, float* %p
   %c = call float @llvm.amdgcn.fmul.legacy(float +2.0, float -0.0)
   store volatile float %c, float* %p
   %d = call float @llvm.amdgcn.fmul.legacy(float +0.0, float +0.0)
   store volatile float %d, float* %p
   %e = call float @llvm.amdgcn.fmul.legacy(float +0.0, float -0.0)
   store volatile float %e, float* %p
   %f = call float @llvm.amdgcn.fmul.legacy(float -0.0, float +0.0)
   store volatile float %f, float* %p
   %g = call float @llvm.amdgcn.fmul.legacy(float -0.0, float -0.0)
   store volatile float %g, float* %p
   %h = call float @llvm.amdgcn.fmul.legacy(float +0.0, float 0x7ff0000000000000) ; +inf
   store volatile float %h, float* %p
   %i = call float @llvm.amdgcn.fmul.legacy(float 0xfff0000000000000, float +0.0) ; -inf
   store volatile float %i, float* %p
   %j = call float @llvm.amdgcn.fmul.legacy(float 0x7ff0001000000000, float -0.0) ; +nan
   store volatile float %j, float* %p
   %k = call float @llvm.amdgcn.fmul.legacy(float -0.0, float 0xfff0000100000000) ; -nan
   store volatile float %k, float* %p
   ret void
 }

llvm/test/Transforms/InstSimplify/ConstProp/AMDGPU/fract.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 declare half @llvm.amdgcn.fract.f16(half)
 declare float @llvm.amdgcn.fract.f32(float)
 declare double @llvm.amdgcn.fract.f64(double)
 
 define void @test_f16(half* %p) {
 ; CHECK-LABEL: @test_f16(
 ; CHECK-NEXT:    store volatile half 0xH0000, half* [[P:%.*]]
 ; CHECK-NEXT:    store volatile half 0xH0000, half* [[P]]
 ; CHECK-NEXT:    store volatile half 0xH0000, half* [[P]]
 ; CHECK-NEXT:    store volatile half 0xH0000, half* [[P]]
 ; CHECK-NEXT:    store volatile half 0xH3400, half* [[P]]
 ; CHECK-NEXT:    store volatile half 0xH3B00, half* [[P]]
 ; CHECK-NEXT:    store volatile half 0xH0400, half* [[P]]
 ; CHECK-NEXT:    store volatile half 0xH3BFF, half* [[P]]
 ; CHECK-NEXT:    store volatile half 0xH7E00, half* [[P]]
 ; CHECK-NEXT:    store volatile half 0xH7E00, half* [[P]]
 ; CHECK-NEXT:    store volatile half 0xH7E00, half* [[P]]
 ; CHECK-NEXT:    ret void
 ;
   %p0 = call half @llvm.amdgcn.fract.f16(half +0.0)
   store volatile half %p0, half* %p
   %n0 = call half @llvm.amdgcn.fract.f16(half -0.0)
   store volatile half %n0, half* %p
   %p1 = call half @llvm.amdgcn.fract.f16(half +1.0)
   store volatile half %p1, half* %p
   %n1 = call half @llvm.amdgcn.fract.f16(half -1.0)
   store volatile half %n1, half* %p
   %p225 = call half @llvm.amdgcn.fract.f16(half +2.25)
   store volatile half %p225, half* %p
   %n6125 = call half @llvm.amdgcn.fract.f16(half -6.125)
   store volatile half %n6125, half* %p
   %ptiny = call half @llvm.amdgcn.fract.f16(half 0xH0400) ; +min normal
   store volatile half %ptiny, half* %p
   %ntiny = call half @llvm.amdgcn.fract.f16(half 0xH8400) ; -min normal
   store volatile half %ntiny, half* %p
   %pinf = call half @llvm.amdgcn.fract.f16(half 0xH7C00) ; +inf
   store volatile half %pinf, half* %p
   %ninf = call half @llvm.amdgcn.fract.f16(half 0xHFC00) ; -inf
   store volatile half %ninf, half* %p
   %nan = call half @llvm.amdgcn.fract.f16(half 0xH7E00) ; nan
   store volatile half %nan, half* %p
   ret void
 }
 
 define void @test_f32(float* %p) {
 ; CHECK-LABEL: @test_f32(
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P:%.*]]
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]]
 ; CHECK-NEXT:    store volatile float 2.500000e-01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 8.750000e-01, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0x3810000000000000, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0x3FEFFFFFE0000000, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0x7FF8000000000000, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0x7FF8000000000000, float* [[P]]
 ; CHECK-NEXT:    store volatile float 0x7FF8000000000000, float* [[P]]
 ; CHECK-NEXT:    ret void
 ;
   %p0 = call float @llvm.amdgcn.fract.f32(float +0.0)
   store volatile float %p0, float* %p
   %n0 = call float @llvm.amdgcn.fract.f32(float -0.0)
   store volatile float %n0, float* %p
   %p1 = call float @llvm.amdgcn.fract.f32(float +1.0)
   store volatile float %p1, float* %p
   %n1 = call float @llvm.amdgcn.fract.f32(float -1.0)
   store volatile float %n1, float* %p
   %p225 = call float @llvm.amdgcn.fract.f32(float +2.25)
   store volatile float %p225, float* %p
   %n6125 = call float @llvm.amdgcn.fract.f32(float -6.125)
   store volatile float %n6125, float* %p
   %ptiny = call float @llvm.amdgcn.fract.f32(float 0x3810000000000000) ; +min normal
   store volatile float %ptiny, float* %p
   %ntiny = call float @llvm.amdgcn.fract.f32(float 0xB810000000000000) ; -min normal
   store volatile float %ntiny, float* %p
   %pinf = call float @llvm.amdgcn.fract.f32(float 0x7FF0000000000000) ; +inf
   store volatile float %pinf, float* %p
   %ninf = call float @llvm.amdgcn.fract.f32(float 0xFFF0000000000000) ; -inf
   store volatile float %ninf, float* %p
   %nan = call float @llvm.amdgcn.fract.f32(float 0x7FF8000000000000) ; nan
   store volatile float %nan, float* %p
   ret void
 }
 
 define void @test_f64(double* %p) {
 ; CHECK-LABEL: @test_f64(
 ; CHECK-NEXT:    store volatile double 0.000000e+00, double* [[P:%.*]]
 ; CHECK-NEXT:    store volatile double 0.000000e+00, double* [[P]]
 ; CHECK-NEXT:    store volatile double 0.000000e+00, double* [[P]]
 ; CHECK-NEXT:    store volatile double 0.000000e+00, double* [[P]]
 ; CHECK-NEXT:    store volatile double 2.500000e-01, double* [[P]]
 ; CHECK-NEXT:    store volatile double 8.750000e-01, double* [[P]]
 ; CHECK-NEXT:    store volatile double 2.000000e-308, double* [[P]]
 ; CHECK-NEXT:    store volatile double 0x3FEFFFFFFFFFFFFF, double* [[P]]
 ; CHECK-NEXT:    store volatile double 0x7FF8000000000000, double* [[P]]
 ; CHECK-NEXT:    store volatile double 0x7FF8000000000000, double* [[P]]
 ; CHECK-NEXT:    store volatile double 0x7FF8000000000000, double* [[P]]
 ; CHECK-NEXT:    ret void
 ;
   %p0 = call double @llvm.amdgcn.fract.f64(double +0.0)
   store volatile double %p0, double* %p
   %n0 = call double @llvm.amdgcn.fract.f64(double -0.0)
   store volatile double %n0, double* %p
   %p1 = call double @llvm.amdgcn.fract.f64(double +1.0)
   store volatile double %p1, double* %p
   %n1 = call double @llvm.amdgcn.fract.f64(double -1.0)
   store volatile double %n1, double* %p
   %p225 = call double @llvm.amdgcn.fract.f64(double +2.25)
   store volatile double %p225, double* %p
   %n6125 = call double @llvm.amdgcn.fract.f64(double -6.125)
   store volatile double %n6125, double* %p
   %ptiny = call double @llvm.amdgcn.fract.f64(double +2.0e-308) ; +min normal
   store volatile double %ptiny, double* %p
   %ntiny = call double @llvm.amdgcn.fract.f64(double -2.0e-308) ; -min normal
   store volatile double %ntiny, double* %p
   %pinf = call double @llvm.amdgcn.fract.f64(double 0x7FF0000000000000) ; +inf
   store volatile double %pinf, double* %p
   %ninf = call double @llvm.amdgcn.fract.f64(double 0xFFF0000000000000) ; -inf
   store volatile double %ninf, double* %p
   %nan = call double @llvm.amdgcn.fract.f64(double 0x7FF8000000000000) ; nan
   store volatile double %nan, double* %p
   ret void
 }

llvm/test/Transforms/InstSimplify/ConstProp/AMDGPU/lit.local.cfg

 if not 'AMDGPU' in config.root.targets:
     config.unsupported = True

llvm/test/Transforms/InstSimplify/ConstProp/AMDGPU/sin.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 declare half @llvm.amdgcn.sin.f16(half) #0
 declare float @llvm.amdgcn.sin.f32(float) #0
 declare double @llvm.amdgcn.sin.f64(double) #0
 
 define void @test_f16(half* %p) {
 ; CHECK-LABEL: @test_f16(
 ; CHECK-NEXT:    store volatile half 0xH0000, half* [[P:%.*]], align 2
 ; CHECK-NEXT:    store volatile half 0xH0000, half* [[P]], align 2
 ; CHECK-NEXT:    store volatile half 0xH39A8, half* [[P]], align 2
 ; CHECK-NEXT:    store volatile half 0xHB9A8, half* [[P]], align 2
 ; CHECK-NEXT:    store volatile half 0xH3C00, half* [[P]], align 2
 ; CHECK-NEXT:    store volatile half 0xHBC00, half* [[P]], align 2
 ; CHECK-NEXT:    store volatile half 0xH0000, half* [[P]], align 2
 ; CHECK-NEXT:    store volatile half 0xH0000, half* [[P]], align 2
 ; CHECK-NEXT:    store volatile half 0xH0000, half* [[P]], align 2
 ; CHECK-NEXT:    store volatile half 0xH0000, half* [[P]], align 2
 ; CHECK-NEXT:    store volatile half 0xH0000, half* [[P]], align 2
 ; CHECK-NEXT:    store volatile half 0xH0000, half* [[P]], align 2
 ; CHECK-NEXT:    [[P1000:%.*]] = call half @llvm.amdgcn.sin.f16(half 0xH63D0)
 ; CHECK-NEXT:    store volatile half [[P1000]], half* [[P]], align 2
 ; CHECK-NEXT:    [[N1000:%.*]] = call half @llvm.amdgcn.sin.f16(half 0xHE3D0)
 ; CHECK-NEXT:    store volatile half [[N1000]], half* [[P]], align 2
 ; CHECK-NEXT:    [[PINF:%.*]] = call half @llvm.amdgcn.sin.f16(half 0xH7C00)
 ; CHECK-NEXT:    store volatile half [[PINF]], half* [[P]], align 2
 ; CHECK-NEXT:    [[NINF:%.*]] = call half @llvm.amdgcn.sin.f16(half 0xHFC00)
 ; CHECK-NEXT:    store volatile half [[NINF]], half* [[P]], align 2
 ; CHECK-NEXT:    [[NAN:%.*]] = call half @llvm.amdgcn.sin.f16(half 0xH7E00)
 ; CHECK-NEXT:    store volatile half [[NAN]], half* [[P]], align 2
 ; CHECK-NEXT:    ret void
 ;
   %p0 = call half @llvm.amdgcn.sin.f16(half +0.0)
   store volatile half %p0, half* %p
   %n0 = call half @llvm.amdgcn.sin.f16(half -0.0)
   store volatile half %n0, half* %p
   %p0125 = call half @llvm.amdgcn.sin.f16(half +0.125)
   store volatile half %p0125, half* %p
   %n0125 = call half @llvm.amdgcn.sin.f16(half -0.125)
   store volatile half %n0125, half* %p
   %p025 = call half @llvm.amdgcn.sin.f16(half +0.25)
   store volatile half %p025, half* %p
   %n025 = call half @llvm.amdgcn.sin.f16(half -0.25)
   store volatile half %n025, half* %p
   %p05 = call half @llvm.amdgcn.sin.f16(half +0.5)
   store volatile half %p05, half* %p
   %n05 = call half @llvm.amdgcn.sin.f16(half -0.5)
   store volatile half %n05, half* %p
   %p1 = call half @llvm.amdgcn.sin.f16(half +1.0)
   store volatile half %p1, half* %p
   %n1 = call half @llvm.amdgcn.sin.f16(half -1.0)
   store volatile half %n1, half* %p
   %p256 = call half @llvm.amdgcn.sin.f16(half +256.0)
   store volatile half %p256, half* %p
   %n256 = call half @llvm.amdgcn.sin.f16(half -256.0)
   store volatile half %n256, half* %p
   %p1000 = call half @llvm.amdgcn.sin.f16(half +1000.0)
   store volatile half %p1000, half* %p
   %n1000 = call half @llvm.amdgcn.sin.f16(half -1000.0)
   store volatile half %n1000, half* %p
   %pinf = call half @llvm.amdgcn.sin.f16(half 0xH7C00) ; +inf
   store volatile half %pinf, half* %p
   %ninf = call half @llvm.amdgcn.sin.f16(half 0xHFC00) ; -inf
   store volatile half %ninf, half* %p
   %nan = call half @llvm.amdgcn.sin.f16(half 0xH7E00) ; nan
   store volatile half %nan, half* %p
   ret void
 }
 
 define void @test_f32(float* %p) {
 ; CHECK-LABEL: @test_f32(
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P:%.*]], align 4
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]], align 4
 ; CHECK-NEXT:    store volatile float 0x3FE6A09E60000000, float* [[P]], align 4
 ; CHECK-NEXT:    store volatile float 0xBFE6A09E60000000, float* [[P]], align 4
 ; CHECK-NEXT:    store volatile float 1.000000e+00, float* [[P]], align 4
 ; CHECK-NEXT:    store volatile float -1.000000e+00, float* [[P]], align 4
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]], align 4
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]], align 4
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]], align 4
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]], align 4
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]], align 4
 ; CHECK-NEXT:    store volatile float 0.000000e+00, float* [[P]], align 4
 ; CHECK-NEXT:    [[P1000:%.*]] = call float @llvm.amdgcn.sin.f32(float 1.000000e+03)
 ; CHECK-NEXT:    store volatile float [[P1000]], float* [[P]], align 4
 ; CHECK-NEXT:    [[N1000:%.*]] = call float @llvm.amdgcn.sin.f32(float -1.000000e+03)
 ; CHECK-NEXT:    store volatile float [[N1000]], float* [[P]], align 4
 ; CHECK-NEXT:    [[PINF:%.*]] = call float @llvm.amdgcn.sin.f32(float 0x7FF0000000000000)
 ; CHECK-NEXT:    store volatile float [[PINF]], float* [[P]], align 4
 ; CHECK-NEXT:    [[NINF:%.*]] = call float @llvm.amdgcn.sin.f32(float 0xFFF0000000000000)
 ; CHECK-NEXT:    store volatile float [[NINF]], float* [[P]], align 4
 ; CHECK-NEXT:    [[NAN:%.*]] = call float @llvm.amdgcn.sin.f32(float 0x7FF8000000000000)
 ; CHECK-NEXT:    store volatile float [[NAN]], float* [[P]], align 4
 ; CHECK-NEXT:    ret void
 ;
   %p0 = call float @llvm.amdgcn.sin.f32(float +0.0)
   store volatile float %p0, float* %p
   %n0 = call float @llvm.amdgcn.sin.f32(float -0.0)
   store volatile float %n0, float* %p
   %p0125 = call float @llvm.amdgcn.sin.f32(float +0.125)
   store volatile float %p0125, float* %p
   %n0125 = call float @llvm.amdgcn.sin.f32(float -0.125)
   store volatile float %n0125, float* %p
   %p025 = call float @llvm.amdgcn.sin.f32(float +0.25)
   store volatile float %p025, float* %p
   %n025 = call float @llvm.amdgcn.sin.f32(float -0.25)
   store volatile float %n025, float* %p
   %p05 = call float @llvm.amdgcn.sin.f32(float +0.5)
   store volatile float %p05, float* %p
   %n05 = call float @llvm.amdgcn.sin.f32(float -0.5)
   store volatile float %n05, float* %p
   %p1 = call float @llvm.amdgcn.sin.f32(float +1.0)
   store volatile float %p1, float* %p
   %n1 = call float @llvm.amdgcn.sin.f32(float -1.0)
   store volatile float %n1, float* %p
   %p256 = call float @llvm.amdgcn.sin.f32(float +256.0)
   store volatile float %p256, float* %p
   %n256 = call float @llvm.amdgcn.sin.f32(float -256.0)
   store volatile float %n256, float* %p
   %p1000 = call float @llvm.amdgcn.sin.f32(float +1000.0)
   store volatile float %p1000, float* %p
   %n1000 = call float @llvm.amdgcn.sin.f32(float -1000.0)
   store volatile float %n1000, float* %p
   %pinf = call float @llvm.amdgcn.sin.f32(float 0x7FF0000000000000) ; +inf
   store volatile float %pinf, float* %p
   %ninf = call float @llvm.amdgcn.sin.f32(float 0xFFF0000000000000) ; -inf
   store volatile float %ninf, float* %p
   %nan = call float @llvm.amdgcn.sin.f32(float 0x7FF8000000000000) ; nan
   store volatile float %nan, float* %p
   ret void
 }
 
 define void @test_f64(double* %p) {
 ; CHECK-LABEL: @test_f64(
 ; CHECK-NEXT:    store volatile double 0.000000e+00, double* [[P:%.*]], align 8
 ; CHECK-NEXT:    store volatile double 0.000000e+00, double* [[P]], align 8
 ; CHECK-NEXT:    store volatile double 0x3FE6A09E667F3B{{.*}}, double* [[P]], align 8
 ; CHECK-NEXT:    store volatile double 0xBFE6A09E667F3B{{.*}}, double* [[P]], align 8
 ; CHECK-NEXT:    store volatile double 1.000000e+00, double* [[P]], align 8
 ; CHECK-NEXT:    store volatile double -1.000000e+00, double* [[P]], align 8
 ; CHECK-NEXT:    store volatile double 0.000000e+00, double* [[P]], align 8
 ; CHECK-NEXT:    store volatile double 0.000000e+00, double* [[P]], align 8
 ; CHECK-NEXT:    store volatile double 0.000000e+00, double* [[P]], align 8
 ; CHECK-NEXT:    store volatile double 0.000000e+00, double* [[P]], align 8
 ; CHECK-NEXT:    store volatile double 0.000000e+00, double* [[P]], align 8
 ; CHECK-NEXT:    store volatile double 0.000000e+00, double* [[P]], align 8
 ; CHECK-NEXT:    [[P1000:%.*]] = call double @llvm.amdgcn.sin.f64(double 1.000000e+03)
 ; CHECK-NEXT:    store volatile double [[P1000]], double* [[P]], align 8
 ; CHECK-NEXT:    [[N1000:%.*]] = call double @llvm.amdgcn.sin.f64(double -1.000000e+03)
 ; CHECK-NEXT:    store volatile double [[N1000]], double* [[P]], align 8
 ; CHECK-NEXT:    [[PINF:%.*]] = call double @llvm.amdgcn.sin.f64(double 0x7FF0000000000000)
 ; CHECK-NEXT:    store volatile double [[PINF]], double* [[P]], align 8
 ; CHECK-NEXT:    [[NINF:%.*]] = call double @llvm.amdgcn.sin.f64(double 0xFFF0000000000000)
 ; CHECK-NEXT:    store volatile double [[NINF]], double* [[P]], align 8
 ; CHECK-NEXT:    [[NAN:%.*]] = call double @llvm.amdgcn.sin.f64(double 0x7FF8000000000000)
 ; CHECK-NEXT:    store volatile double [[NAN]], double* [[P]], align 8
 ; CHECK-NEXT:    ret void
 ;
   %p0 = call double @llvm.amdgcn.sin.f64(double +0.0)
   store volatile double %p0, double* %p
   %n0 = call double @llvm.amdgcn.sin.f64(double -0.0)
   store volatile double %n0, double* %p
   %p0125 = call double @llvm.amdgcn.sin.f64(double +0.125)
   store volatile double %p0125, double* %p
   %n0125 = call double @llvm.amdgcn.sin.f64(double -0.125)
   store volatile double %n0125, double* %p
   %p025 = call double @llvm.amdgcn.sin.f64(double +0.25)
   store volatile double %p025, double* %p
   %n025 = call double @llvm.amdgcn.sin.f64(double -0.25)
   store volatile double %n025, double* %p
   %p05 = call double @llvm.amdgcn.sin.f64(double +0.5)
   store volatile double %p05, double* %p
   %n05 = call double @llvm.amdgcn.sin.f64(double -0.5)
   store volatile double %n05, double* %p
   %p1 = call double @llvm.amdgcn.sin.f64(double +1.0)
   store volatile double %p1, double* %p
   %n1 = call double @llvm.amdgcn.sin.f64(double -1.0)
   store volatile double %n1, double* %p
   %p256 = call double @llvm.amdgcn.sin.f64(double +256.0)
   store volatile double %p256, double* %p
   %n256 = call double @llvm.amdgcn.sin.f64(double -256.0)
   store volatile double %n256, double* %p
   %p1000 = call double @llvm.amdgcn.sin.f64(double +1000.0)
   store volatile double %p1000, double* %p
   %n1000 = call double @llvm.amdgcn.sin.f64(double -1000.0)
   store volatile double %n1000, double* %p
   %pinf = call double @llvm.amdgcn.sin.f64(double 0x7FF0000000000000) ; +inf
   store volatile double %pinf, double* %p
   %ninf = call double @llvm.amdgcn.sin.f64(double 0xFFF0000000000000) ; -inf
   store volatile double %ninf, double* %p
   %nan = call double @llvm.amdgcn.sin.f64(double 0x7FF8000000000000) ; nan
   store volatile double %nan, double* %p
   ret void
 }
 
 define void @test_f16_strictfp (half* %p) #1 {
 ; CHECK-LABEL: @test_f16_strictfp(
 ; CHECK-NEXT:    [[P0:%.*]] = call half @llvm.amdgcn.sin.f16(half 0xH0000) #1
 ; CHECK-NEXT:    store volatile half [[P0]], half* [[P:%.*]], align 2
 ; CHECK-NEXT:    [[P025:%.*]] = call half @llvm.amdgcn.sin.f16(half 0xH3400) #1
 ; CHECK-NEXT:    store volatile half [[P025]], half* [[P]], align 2
 ; CHECK-NEXT:    ret void
 ;
   %p0 = call half @llvm.amdgcn.sin.f16(half +0.0) #1
   store volatile half %p0, half* %p
   %p025 = call half @llvm.amdgcn.sin.f16(half +0.25) #1
   store volatile half %p025, half* %p
   ret void
 }
 
 define void @test_f32_strictfp(float* %p) #1 {
 ; CHECK-LABEL: @test_f32_strictfp(
 ; CHECK-NEXT:    [[P0:%.*]] = call float @llvm.amdgcn.sin.f32(float 0.000000e+00) #1
 ; CHECK-NEXT:    store volatile float [[P0]], float* [[P:%.*]], align 4
 ; CHECK-NEXT:    [[P025:%.*]] = call float @llvm.amdgcn.sin.f32(float 2.500000e-01) #1
 ; CHECK-NEXT:    store volatile float [[P025]], float* [[P]], align 4
 ; CHECK-NEXT:    ret void
 ;
   %p0 = call float @llvm.amdgcn.sin.f32(float +0.0) #1
   store volatile float %p0, float* %p
   %p025 = call float @llvm.amdgcn.sin.f32(float +0.25) #1
   store volatile float %p025, float* %p
   ret void
 }
 
 define void @test_f64_strictfp(double* %p) #1 {
 ; CHECK-LABEL: @test_f64_strictfp(
 ; CHECK-NEXT:    [[P0:%.*]] = call double @llvm.amdgcn.sin.f64(double 0.000000e+00) #1
 ; CHECK-NEXT:    store volatile double [[P0]], double* [[P:%.*]], align 8
 ; CHECK-NEXT:    [[P025:%.*]] = call double @llvm.amdgcn.sin.f64(double 2.500000e-01) #1
 ; CHECK-NEXT:    store volatile double [[P025]], double* [[P]], align 8
 ; CHECK-NEXT:    ret void
 ;
   %p0 = call double @llvm.amdgcn.sin.f64(double +0.0) #1
   store volatile double %p0, double* %p
   %p025 = call double @llvm.amdgcn.sin.f64(double +0.25) #1
   store volatile double %p025, double* %p
   ret void
 }
 
 attributes #0 = { nounwind readnone speculatable }
 attributes #1 = { strictfp }

llvm/test/Transforms/InstSimplify/ConstProp/ARM/lit.local.cfg

 if not 'ARM' in config.root.targets:
     config.unsupported = True

llvm/test/Transforms/InstSimplify/ConstProp/ARM/mve-vctp.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -instsimplify -S -o - %s | FileCheck %s
 
 target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
 
 define <16 x i1> @vctp8_0() {
 ; CHECK-LABEL: @vctp8_0(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <16 x i1> zeroinitializer
 ;
 entry:
   %int = call <16 x i1> @llvm.arm.mve.vctp8(i32 0)
   ret <16 x i1> %int
 }
 
 define <16 x i1> @vctp8_1() {
 ; CHECK-LABEL: @vctp8_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <16 x i1> <i1 true, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false>
 ;
 entry:
   %int = call <16 x i1> @llvm.arm.mve.vctp8(i32 1)
   ret <16 x i1> %int
 }
 
 define <16 x i1> @vctp8_8() {
 ; CHECK-LABEL: @vctp8_8(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <16 x i1> <i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false>
 ;
 entry:
   %int = call <16 x i1> @llvm.arm.mve.vctp8(i32 8)
   ret <16 x i1> %int
 }
 
 define <16 x i1> @vctp8_15() {
 ; CHECK-LABEL: @vctp8_15(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <16 x i1> <i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 false>
 ;
 entry:
   %int = call <16 x i1> @llvm.arm.mve.vctp8(i32 15)
   ret <16 x i1> %int
 }
 
 define <16 x i1> @vctp8_16() {
 ; CHECK-LABEL: @vctp8_16(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <16 x i1> <i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true>
 ;
 entry:
   %int = call <16 x i1> @llvm.arm.mve.vctp8(i32 16)
   ret <16 x i1> %int
 }
 
 define <16 x i1> @vctp8_100() {
 ; CHECK-LABEL: @vctp8_100(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <16 x i1> <i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true>
 ;
 entry:
   %int = call <16 x i1> @llvm.arm.mve.vctp8(i32 100)
   ret <16 x i1> %int
 }
 
 define <16 x i1> @vctp8_m1() {
 ; CHECK-LABEL: @vctp8_m1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <16 x i1> <i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true>
 ;
 entry:
   %int = call <16 x i1> @llvm.arm.mve.vctp8(i32 -1)
   ret <16 x i1> %int
 }
 
 
 
 define <8 x i1> @vctp16_0() {
 ; CHECK-LABEL: @vctp16_0(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <8 x i1> zeroinitializer
 ;
 entry:
   %int = call <8 x i1> @llvm.arm.mve.vctp16(i32 0)
   ret <8 x i1> %int
 }
 
 define <8 x i1> @vctp16_1() {
 ; CHECK-LABEL: @vctp16_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <8 x i1> <i1 true, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false>
 ;
 entry:
   %int = call <8 x i1> @llvm.arm.mve.vctp16(i32 1)
   ret <8 x i1> %int
 }
 
 define <8 x i1> @vctp16_4() {
 ; CHECK-LABEL: @vctp16_4(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <8 x i1> <i1 true, i1 true, i1 true, i1 true, i1 false, i1 false, i1 false, i1 false>
 ;
 entry:
   %int = call <8 x i1> @llvm.arm.mve.vctp16(i32 4)
   ret <8 x i1> %int
 }
 
 define <8 x i1> @vctp16_7() {
 ; CHECK-LABEL: @vctp16_7(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <8 x i1> <i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 false>
 ;
 entry:
   %int = call <8 x i1> @llvm.arm.mve.vctp16(i32 7)
   ret <8 x i1> %int
 }
 
 define <8 x i1> @vctp16_8() {
 ; CHECK-LABEL: @vctp16_8(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <8 x i1> <i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true>
 ;
 entry:
   %int = call <8 x i1> @llvm.arm.mve.vctp16(i32 8)
   ret <8 x i1> %int
 }
 
 define <8 x i1> @vctp16_100() {
 ; CHECK-LABEL: @vctp16_100(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <8 x i1> <i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true>
 ;
 entry:
   %int = call <8 x i1> @llvm.arm.mve.vctp16(i32 100)
   ret <8 x i1> %int
 }
 
 define <8 x i1> @vctp16_m1() {
 ; CHECK-LABEL: @vctp16_m1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <8 x i1> <i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true>
 ;
 entry:
   %int = call <8 x i1> @llvm.arm.mve.vctp16(i32 -1)
   ret <8 x i1> %int
 }
 
 
 
 define <4 x i1> @vctp32_0() {
 ; CHECK-LABEL: @vctp32_0(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <4 x i1> zeroinitializer
 ;
 entry:
   %int = call <4 x i1> @llvm.arm.mve.vctp32(i32 0)
   ret <4 x i1> %int
 }
 
 define <4 x i1> @vctp32_1() {
 ; CHECK-LABEL: @vctp32_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <4 x i1> <i1 true, i1 false, i1 false, i1 false>
 ;
 entry:
   %int = call <4 x i1> @llvm.arm.mve.vctp32(i32 1)
   ret <4 x i1> %int
 }
 
 define <4 x i1> @vctp32_3() {
 ; CHECK-LABEL: @vctp32_3(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <4 x i1> <i1 true, i1 true, i1 true, i1 false>
 ;
 entry:
   %int = call <4 x i1> @llvm.arm.mve.vctp32(i32 3)
   ret <4 x i1> %int
 }
 
 define <4 x i1> @vctp32_4() {
 ; CHECK-LABEL: @vctp32_4(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <4 x i1> <i1 true, i1 true, i1 true, i1 true>
 ;
 entry:
   %int = call <4 x i1> @llvm.arm.mve.vctp32(i32 4)
   ret <4 x i1> %int
 }
 
 define <4 x i1> @vctp32_100() {
 ; CHECK-LABEL: @vctp32_100(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <4 x i1> <i1 true, i1 true, i1 true, i1 true>
 ;
 entry:
   %int = call <4 x i1> @llvm.arm.mve.vctp32(i32 100)
   ret <4 x i1> %int
 }
 
 define <4 x i1> @vctp32_m1() {
 ; CHECK-LABEL: @vctp32_m1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <4 x i1> <i1 true, i1 true, i1 true, i1 true>
 ;
 entry:
   %int = call <4 x i1> @llvm.arm.mve.vctp32(i32 -1)
   ret <4 x i1> %int
 }
 
 
 
 define <4 x i1> @vctp64_0() {
 ; CHECK-LABEL: @vctp64_0(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <4 x i1> zeroinitializer
 ;
 entry:
   %int = call <4 x i1> @llvm.arm.mve.vctp64(i32 0)
   ret <4 x i1> %int
 }
 
 define <4 x i1> @vctp64_1() {
 ; CHECK-LABEL: @vctp64_1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <4 x i1> <i1 true, i1 true, i1 false, i1 false>
 ;
 entry:
   %int = call <4 x i1> @llvm.arm.mve.vctp64(i32 1)
   ret <4 x i1> %int
 }
 
 define <4 x i1> @vctp64_2() {
 ; CHECK-LABEL: @vctp64_2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <4 x i1> <i1 true, i1 true, i1 true, i1 true>
 ;
 entry:
   %int = call <4 x i1> @llvm.arm.mve.vctp64(i32 2)
   ret <4 x i1> %int
 }
 
 define <4 x i1> @vctp64_100() {
 ; CHECK-LABEL: @vctp64_100(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <4 x i1> <i1 true, i1 true, i1 true, i1 true>
 ;
 entry:
   %int = call <4 x i1> @llvm.arm.mve.vctp64(i32 100)
   ret <4 x i1> %int
 }
 
 define <4 x i1> @vctp64_m1() {
 ; CHECK-LABEL: @vctp64_m1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <4 x i1> <i1 true, i1 true, i1 true, i1 true>
 ;
 entry:
   %int = call <4 x i1> @llvm.arm.mve.vctp64(i32 -1)
   ret <4 x i1> %int
 }
 
 
 
 declare <4 x i1> @llvm.arm.mve.vctp64(i32)
 declare <4 x i1> @llvm.arm.mve.vctp32(i32)
 declare <8 x i1> @llvm.arm.mve.vctp16(i32)
 declare <16 x i1> @llvm.arm.mve.vctp8(i32)

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/WebAssembly/trunc.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 declare i32 @llvm.wasm.trunc.signed.i32.f32(float)
 declare i32 @llvm.wasm.trunc.unsigned.i32.f32(float)
 declare i32 @llvm.wasm.trunc.signed.i32.f64(double)
 declare i32 @llvm.wasm.trunc.unsigned.i32.f64(double)
 declare i64 @llvm.wasm.trunc.signed.i64.f32(float)
 declare i64 @llvm.wasm.trunc.unsigned.i64.f32(float)
 declare i64 @llvm.wasm.trunc.signed.i64.f64(double)
 declare i64 @llvm.wasm.trunc.unsigned.i64.f64(double)
 
 define void @test_i32_trunc_f32_s(i32* %p) {
 ; CHECK-LABEL: @test_i32_trunc_f32_s(
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -2, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 2147483520, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -2147483648, i32* [[P]], align 4
 ; CHECK-NEXT:    [[T14:%.*]] = call i32 @llvm.wasm.trunc.signed.i32.f32(float 0x41E0000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T14]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T15:%.*]] = call i32 @llvm.wasm.trunc.signed.i32.f32(float 0xC1E0000020000000)
 ; CHECK-NEXT:    store volatile i32 [[T15]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T16:%.*]] = call i32 @llvm.wasm.trunc.signed.i32.f32(float 0x7FF0000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T16]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T17:%.*]] = call i32 @llvm.wasm.trunc.signed.i32.f32(float 0xFFF0000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T17]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T18:%.*]] = call i32 @llvm.wasm.trunc.signed.i32.f32(float 0x7FF8000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T18]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T19:%.*]] = call i32 @llvm.wasm.trunc.signed.i32.f32(float 0x7FFA000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T19]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T20:%.*]] = call i32 @llvm.wasm.trunc.signed.i32.f32(float 0xFFF8000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T20]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T21:%.*]] = call i32 @llvm.wasm.trunc.signed.i32.f32(float 0xFFFA000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T21]], i32* [[P]], align 4
 ; CHECK-NEXT:    ret void
 ;
   %t0 = call i32 @llvm.wasm.trunc.signed.i32.f32(float +0.0)
   store volatile i32 %t0, i32* %p
   %t1 = call i32 @llvm.wasm.trunc.signed.i32.f32(float -0.0)
   store volatile i32 %t1, i32* %p
   %t2 = call i32 @llvm.wasm.trunc.signed.i32.f32(float 0x36a0000000000000); 0x1p-149
   store volatile i32 %t2, i32* %p
   %t3 = call i32 @llvm.wasm.trunc.signed.i32.f32(float 0xb6a0000000000000); -0x1p-149
   store volatile i32 %t3, i32* %p
   %t4 = call i32 @llvm.wasm.trunc.signed.i32.f32(float 1.0)
   store volatile i32 %t4, i32* %p
   %t5 = call i32 @llvm.wasm.trunc.signed.i32.f32(float 0x3ff19999a0000000); 0x1.19999ap+0
   store volatile i32 %t5, i32* %p
   %t6 = call i32 @llvm.wasm.trunc.signed.i32.f32(float 1.5)
   store volatile i32 %t6, i32* %p
   %t7 = call i32 @llvm.wasm.trunc.signed.i32.f32(float -1.0)
   store volatile i32 %t7, i32* %p
   %t8 = call i32 @llvm.wasm.trunc.signed.i32.f32(float 0xbff19999a0000000); -0x1.19999ap+0
   store volatile i32 %t8, i32* %p
   %t9 = call i32 @llvm.wasm.trunc.signed.i32.f32(float -1.5)
   store volatile i32 %t9, i32* %p
   %t10 = call i32 @llvm.wasm.trunc.signed.i32.f32(float 0xbffe666660000000); -1.9
   store volatile i32 %t10, i32* %p
   %t11 = call i32 @llvm.wasm.trunc.signed.i32.f32(float -2.0)
   store volatile i32 %t11, i32* %p
   %t12 = call i32 @llvm.wasm.trunc.signed.i32.f32(float 2147483520.0)
   store volatile i32 %t12, i32* %p
   %t13 = call i32 @llvm.wasm.trunc.signed.i32.f32(float -2147483648.0)
   store volatile i32 %t13, i32* %p
   %t14 = call i32 @llvm.wasm.trunc.signed.i32.f32(float 2147483648.0)
   store volatile i32 %t14, i32* %p
   %t15 = call i32 @llvm.wasm.trunc.signed.i32.f32(float -2147483904.0)
   store volatile i32 %t15, i32* %p
   %t16 = call i32 @llvm.wasm.trunc.signed.i32.f32(float 0x7ff0000000000000); inf
   store volatile i32 %t16, i32* %p
   %t17 = call i32 @llvm.wasm.trunc.signed.i32.f32(float 0xfff0000000000000); -inf
   store volatile i32 %t17, i32* %p
   %t18 = call i32 @llvm.wasm.trunc.signed.i32.f32(float 0x7ff8000000000000); nan
   store volatile i32 %t18, i32* %p
   %t19 = call i32 @llvm.wasm.trunc.signed.i32.f32(float 0x7ffa000000000000); nan:0x200000
   store volatile i32 %t19, i32* %p
   %t20 = call i32 @llvm.wasm.trunc.signed.i32.f32(float 0xfff8000000000000); -nan
   store volatile i32 %t20, i32* %p
   %t21 = call i32 @llvm.wasm.trunc.signed.i32.f32(float 0xfffa000000000000); -nan:0x200000
   store volatile i32 %t21, i32* %p
   ret void
 }
 
 define void @test_i32_trunc_f32_u(i32* %p) {
 ; CHECK-LABEL: @test_i32_trunc_f32_u(
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 2, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -2147483648, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -256, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    [[T13:%.*]] = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 0x41F0000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T13]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T14:%.*]] = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float -1.000000e+00)
 ; CHECK-NEXT:    store volatile i32 [[T14]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T15:%.*]] = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 0x7FF0000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T15]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T16:%.*]] = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 0xFFF0000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T16]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T17:%.*]] = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 0x7FF8000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T17]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T18:%.*]] = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 0x7FFA000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T18]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T19:%.*]] = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 0xFFF8000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T19]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T20:%.*]] = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 0xFFFA000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T20]], i32* [[P]], align 4
 ; CHECK-NEXT:    ret void
 ;
   %t0 = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float +0.0)
   store volatile i32 %t0, i32* %p
   %t1 = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float -0.0)
   store volatile i32 %t1, i32* %p
   %t2 = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 0x36a0000000000000); 0x1p-149
   store volatile i32 %t2, i32* %p
   %t3 = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 0xb6a0000000000000); -0x1p-149
   store volatile i32 %t3, i32* %p
   %t4 = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 1.0)
   store volatile i32 %t4, i32* %p
   %t5 = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 0x3ff19999a0000000); 0x1.19999ap+0
   store volatile i32 %t5, i32* %p
   %t6 = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 1.5)
   store volatile i32 %t6, i32* %p
   %t7 = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 0x3ffe666660000000); 1.9
   store volatile i32 %t7, i32* %p
   %t8 = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 2.0)
   store volatile i32 %t8, i32* %p
   %t9 = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 2147483648.0)
   store volatile i32 %t9, i32* %p
   %t10 = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 4294967040.0)
   store volatile i32 %t10, i32* %p
   %t11 = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 0xbfecccccc0000000); -0x1.ccccccp-1
   store volatile i32 %t11, i32* %p
   %t12 = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 0xbfefffffe0000000); -0x1.fffffep-1
   store volatile i32 %t12, i32* %p
   %t13 = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 4294967296.0)
   store volatile i32 %t13, i32* %p
   %t14 = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float -1.0)
   store volatile i32 %t14, i32* %p
   %t15 = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 0x7ff0000000000000); inf
   store volatile i32 %t15, i32* %p
   %t16 = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 0xfff0000000000000); -inf
   store volatile i32 %t16, i32* %p
   %t17 = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 0x7ff8000000000000); nan
   store volatile i32 %t17, i32* %p
   %t18 = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 0x7ffa000000000000); nan:0x200000
   store volatile i32 %t18, i32* %p
   %t19 = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 0xfff8000000000000); -nan
   store volatile i32 %t19, i32* %p
   %t20 = call i32 @llvm.wasm.trunc.unsigned.i32.f32(float 0xfffa000000000000); -nan:0x200000
   store volatile i32 %t20, i32* %p
   ret void
 }
 
 define void @test_i32_trunc_f64_s(i32* %p) {
 ; CHECK-LABEL: @test_i32_trunc_f64_s(
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -2, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 2147483647, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -2147483648, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -2147483648, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 2147483647, i32* [[P]], align 4
 ; CHECK-NEXT:    [[T16:%.*]] = call i32 @llvm.wasm.trunc.signed.i32.f64(double 0x41E0000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T16]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T17:%.*]] = call i32 @llvm.wasm.trunc.signed.i32.f64(double 0xC1E0000000200000)
 ; CHECK-NEXT:    store volatile i32 [[T17]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T18:%.*]] = call i32 @llvm.wasm.trunc.signed.i32.f64(double 0x7FF0000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T18]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T19:%.*]] = call i32 @llvm.wasm.trunc.signed.i32.f64(double 0xFFF0000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T19]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T20:%.*]] = call i32 @llvm.wasm.trunc.signed.i32.f64(double 0x7FF8000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T20]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T21:%.*]] = call i32 @llvm.wasm.trunc.signed.i32.f64(double 0x7FF4000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T21]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T22:%.*]] = call i32 @llvm.wasm.trunc.signed.i32.f64(double 0xFFF8000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T22]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T23:%.*]] = call i32 @llvm.wasm.trunc.signed.i32.f64(double 0x7FF4000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T23]], i32* [[P]], align 4
 ; CHECK-NEXT:    ret void
 ;
   %t0 = call i32 @llvm.wasm.trunc.signed.i32.f64(double +0.0)
   store volatile i32 %t0, i32* %p
   %t1 = call i32 @llvm.wasm.trunc.signed.i32.f64(double -0.0)
   store volatile i32 %t1, i32* %p
   %t2 = call i32 @llvm.wasm.trunc.signed.i32.f64(double 0x0010000000000001); 0x0.0000000000001p-1022
   store volatile i32 %t2, i32* %p
   %t3 = call i32 @llvm.wasm.trunc.signed.i32.f64(double 0x8010000000000001); -0x1.0000000000001p-1022
   store volatile i32 %t3, i32* %p
   %t4 = call i32 @llvm.wasm.trunc.signed.i32.f64(double 1.0)
   store volatile i32 %t4, i32* %p
   %t5 = call i32 @llvm.wasm.trunc.signed.i32.f64(double 0x3ff199999999999a); 0x1.199999999999ap+0
   store volatile i32 %t5, i32* %p
   %t6 = call i32 @llvm.wasm.trunc.signed.i32.f64(double 1.5)
   store volatile i32 %t6, i32* %p
   %t7 = call i32 @llvm.wasm.trunc.signed.i32.f64(double -1.0)
   store volatile i32 %t7, i32* %p
   %t8 = call i32 @llvm.wasm.trunc.signed.i32.f64(double 0xbff199999999999a); -0x1.199999999999ap+0
   store volatile i32 %t8, i32* %p
   %t9 = call i32 @llvm.wasm.trunc.signed.i32.f64(double -1.5)
   store volatile i32 %t9, i32* %p
   %t10 = call i32 @llvm.wasm.trunc.signed.i32.f64(double 0xbffe666666666666); -1.9
   store volatile i32 %t10, i32* %p
   %t11 = call i32 @llvm.wasm.trunc.signed.i32.f64(double -2.0)
   store volatile i32 %t11, i32* %p
   %t12 = call i32 @llvm.wasm.trunc.signed.i32.f64(double 2147483647.0)
   store volatile i32 %t12, i32* %p
   %t13 = call i32 @llvm.wasm.trunc.signed.i32.f64(double -2147483648.0)
   store volatile i32 %t13, i32* %p
   %t14 = call i32 @llvm.wasm.trunc.signed.i32.f64(double -2147483648.9)
   store volatile i32 %t14, i32* %p
   %t15 = call i32 @llvm.wasm.trunc.signed.i32.f64(double 2147483647.9)
   store volatile i32 %t15, i32* %p
   %t16 = call i32 @llvm.wasm.trunc.signed.i32.f64(double 2147483648.0)
   store volatile i32 %t16, i32* %p
   %t17 = call i32 @llvm.wasm.trunc.signed.i32.f64(double -2147483649.0)
   store volatile i32 %t17, i32* %p
   %t18 = call i32 @llvm.wasm.trunc.signed.i32.f64(double 0x7ff0000000000000); inf
   store volatile i32 %t18, i32* %p
   %t19 = call i32 @llvm.wasm.trunc.signed.i32.f64(double 0xfff0000000000000); -inf
   store volatile i32 %t19, i32* %p
   %t20 = call i32 @llvm.wasm.trunc.signed.i32.f64(double 0x7ff8000000000000); nan
   store volatile i32 %t20, i32* %p
   %t21 = call i32 @llvm.wasm.trunc.signed.i32.f64(double 0x7ff4000000000000); nan:0x4000000000000
   store volatile i32 %t21, i32* %p
   %t22 = call i32 @llvm.wasm.trunc.signed.i32.f64(double 0xfff8000000000000); -nan
   store volatile i32 %t22, i32* %p
   %t23 = call i32 @llvm.wasm.trunc.signed.i32.f64(double 0x7ff4000000000000); -nan:0x4000000000000
   store volatile i32 %t23, i32* %p
   ret void
 }
 
 define void @test_i32_trunc_f64_u(i32* %p) {
 ; CHECK-LABEL: @test_i32_trunc_f64_u(
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 2, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -2147483648, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 100000000, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    [[T15:%.*]] = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 0x41F0000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T15]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T16:%.*]] = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double -1.000000e+00)
 ; CHECK-NEXT:    store volatile i32 [[T16]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T17:%.*]] = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 1.000000e+16)
 ; CHECK-NEXT:    store volatile i32 [[T17]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T18:%.*]] = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 1.000000e+30)
 ; CHECK-NEXT:    store volatile i32 [[T18]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T19:%.*]] = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 0x43E0000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T19]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T20:%.*]] = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 0x7FF0000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T20]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T21:%.*]] = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 0xFFF0000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T21]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T22:%.*]] = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 0x7FF8000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T22]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T23:%.*]] = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 0x7FF4000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T23]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T24:%.*]] = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 0xFFF8000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T24]], i32* [[P]], align 4
 ; CHECK-NEXT:    [[T25:%.*]] = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 0xFFF4000000000000)
 ; CHECK-NEXT:    store volatile i32 [[T25]], i32* [[P]], align 4
 ; CHECK-NEXT:    ret void
 ;
   %t0 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double +0.0)
   store volatile i32 %t0, i32* %p
   %t1 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double -0.0)
   store volatile i32 %t1, i32* %p
   %t2 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 0x0010000000000001); 0x0.0000000000001p-1022
   store volatile i32 %t2, i32* %p
   %t3 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 0x8010000000000001); -0x0.0000000000001p-1022
   store volatile i32 %t3, i32* %p
   %t4 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 1.0)
   store volatile i32 %t4, i32* %p
   %t5 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 0x3ff199999999999a); 0x1.199999999999ap+0
   store volatile i32 %t5, i32* %p
   %t6 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 1.5)
   store volatile i32 %t6, i32* %p
   %t7 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 0x3ffe666666666666); 1.9
   store volatile i32 %t7, i32* %p
   %t8 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 2.0)
   store volatile i32 %t8, i32* %p
   %t9 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 2147483648.0)
   store volatile i32 %t9, i32* %p
   %t10 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 4294967295.0)
   store volatile i32 %t10, i32* %p
   %t11 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 0xbfeccccccccccccd); -0x1.ccccccccccccdp-1
   store volatile i32 %t11, i32* %p
   %t12 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 0xbfefffffffffffff); -0x1.fffffffffffffp-1
   store volatile i32 %t12, i32* %p
   %t13 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 100000000.0)
   store volatile i32 %t13, i32* %p
   %t14 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 4294967295.9)
   store volatile i32 %t14, i32* %p
   %t15 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 4294967296.0)
   store volatile i32 %t15, i32* %p
   %t16 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double -1.0)
   store volatile i32 %t16, i32* %p
   %t17 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 10000000000000000.0); 1e16
   store volatile i32 %t17, i32* %p
   %t18 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 1000000000000000000000000000000.0); 1e30
   store volatile i32 %t18, i32* %p
   %t19 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 9223372036854775808.0)
   store volatile i32 %t19, i32* %p
   %t20 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 0x7ff0000000000000); inf
   store volatile i32 %t20, i32* %p
   %t21 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 0xfff0000000000000); -inf
   store volatile i32 %t21, i32* %p
   %t22 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 0x7ff8000000000000); nan
   store volatile i32 %t22, i32* %p
   %t23 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 0x7ff4000000000000); nan:0x4000000000000
   store volatile i32 %t23, i32* %p
   %t24 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 0xfff8000000000000); -nan
   store volatile i32 %t24, i32* %p
   %t25 = call i32 @llvm.wasm.trunc.unsigned.i32.f64(double 0xfff4000000000000); -nan:0x4000000000000
   store volatile i32 %t25, i32* %p
   ret void
 }
 
 define void @test_i64_trunc_f32_s(i64* %p) {
 ; CHECK-LABEL: @test_i64_trunc_f32_s(
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P:%.*]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -2, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 4294967296, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -4294967296, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 9223371487098961920, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -9223372036854775808, i64* [[P]], align 8
 ; CHECK-NEXT:    [[T16:%.*]] = call i64 @llvm.wasm.trunc.signed.i64.f32(float 0x43E0000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T16]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T17:%.*]] = call i64 @llvm.wasm.trunc.signed.i64.f32(float 0xC3E0000020000000)
 ; CHECK-NEXT:    store volatile i64 [[T17]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T18:%.*]] = call i64 @llvm.wasm.trunc.signed.i64.f32(float 0x7FF0000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T18]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T19:%.*]] = call i64 @llvm.wasm.trunc.signed.i64.f32(float 0xFFF0000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T19]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T20:%.*]] = call i64 @llvm.wasm.trunc.signed.i64.f32(float 0x7FF8000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T20]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T21:%.*]] = call i64 @llvm.wasm.trunc.signed.i64.f32(float 0x7FFA000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T21]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T22:%.*]] = call i64 @llvm.wasm.trunc.signed.i64.f32(float 0xFFF8000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T22]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T23:%.*]] = call i64 @llvm.wasm.trunc.signed.i64.f32(float 0xFFFA000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T23]], i64* [[P]], align 8
 ; CHECK-NEXT:    ret void
 ;
   %t0 = call i64 @llvm.wasm.trunc.signed.i64.f32(float +0.0)
   store volatile i64 %t0, i64* %p
   %t1 = call i64 @llvm.wasm.trunc.signed.i64.f32(float -0.0)
   store volatile i64 %t1, i64* %p
   %t2 = call i64 @llvm.wasm.trunc.signed.i64.f32(float 0x36a0000000000000); 0x1p-149
   store volatile i64 %t2, i64* %p
   %t3 = call i64 @llvm.wasm.trunc.signed.i64.f32(float 0xb6a0000000000000); -0x1p-149
   store volatile i64 %t3, i64* %p
   %t4 = call i64 @llvm.wasm.trunc.signed.i64.f32(float 1.0)
   store volatile i64 %t4, i64* %p
   %t5 = call i64 @llvm.wasm.trunc.signed.i64.f32(float 0x3ff19999a0000000); 0x1.19999ap+0
   store volatile i64 %t5, i64* %p
   %t6 = call i64 @llvm.wasm.trunc.signed.i64.f32(float 1.5)
   store volatile i64 %t6, i64* %p
   %t7 = call i64 @llvm.wasm.trunc.signed.i64.f32(float -1.0)
   store volatile i64 %t7, i64* %p
   %t8 = call i64 @llvm.wasm.trunc.signed.i64.f32(float 0xbff19999a0000000); -0x1.19999ap+0
   store volatile i64 %t8, i64* %p
   %t9 = call i64 @llvm.wasm.trunc.signed.i64.f32(float -1.5)
   store volatile i64 %t9, i64* %p
   %t10 = call i64 @llvm.wasm.trunc.signed.i64.f32(float 0xbffe666660000000); -1.9
   store volatile i64 %t10, i64* %p
   %t11 = call i64 @llvm.wasm.trunc.signed.i64.f32(float -2.0)
   store volatile i64 %t11, i64* %p
   %t12 = call i64 @llvm.wasm.trunc.signed.i64.f32(float 4294967296.0)
   store volatile i64 %t12, i64* %p
   %t13 = call i64 @llvm.wasm.trunc.signed.i64.f32(float -4294967296.0)
   store volatile i64 %t13, i64* %p
   %t14 = call i64 @llvm.wasm.trunc.signed.i64.f32(float 9223371487098961920.0)
   store volatile i64 %t14, i64* %p
   %t15 = call i64 @llvm.wasm.trunc.signed.i64.f32(float -9223372036854775808.0)
   store volatile i64 %t15, i64* %p
   %t16 = call i64 @llvm.wasm.trunc.signed.i64.f32(float 9223372036854775808.0)
   store volatile i64 %t16, i64* %p
   %t17 = call i64 @llvm.wasm.trunc.signed.i64.f32(float -9223373136366403584.0)
   store volatile i64 %t17, i64* %p
   %t18 = call i64 @llvm.wasm.trunc.signed.i64.f32(float 0x7ff0000000000000); inf
   store volatile i64 %t18, i64* %p
   %t19 = call i64 @llvm.wasm.trunc.signed.i64.f32(float 0xfff0000000000000); -inf
   store volatile i64 %t19, i64* %p
   %t20 = call i64 @llvm.wasm.trunc.signed.i64.f32(float 0x7ff8000000000000); nan
   store volatile i64 %t20, i64* %p
   %t21 = call i64 @llvm.wasm.trunc.signed.i64.f32(float 0x7ffa000000000000); nan:0x200000
   store volatile i64 %t21, i64* %p
   %t22 = call i64 @llvm.wasm.trunc.signed.i64.f32(float 0xfff8000000000000); -nan
   store volatile i64 %t22, i64* %p
   %t23 = call i64 @llvm.wasm.trunc.signed.i64.f32(float 0xfffa000000000000); -nan:0x200000
   store volatile i64 %t23, i64* %p
   ret void
 }
 
 define void @test_i64_trunc_f32_u(i64* %p) {
 ; CHECK-LABEL: @test_i64_trunc_f32_u(
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P:%.*]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 4294967296, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -1099511627776, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    [[T11:%.*]] = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float 0x43F0000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T11]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T12:%.*]] = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float -1.000000e+00)
 ; CHECK-NEXT:    store volatile i64 [[T12]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T13:%.*]] = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float 0x7FF0000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T13]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T14:%.*]] = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float 0xFFF0000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T14]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T15:%.*]] = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float 0x7FF8000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T15]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T16:%.*]] = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float 0x7FFA000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T16]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T17:%.*]] = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float 0xFFF8000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T17]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T18:%.*]] = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float 0xFFFA000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T18]], i64* [[P]], align 8
 ; CHECK-NEXT:    ret void
 ;
   %t0 = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float +0.0)
   store volatile i64 %t0, i64* %p
   %t1 = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float -0.0)
   store volatile i64 %t1, i64* %p
   %t2 = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float 0x36a0000000000000); 0x1p-149
   store volatile i64 %t2, i64* %p
   %t3 = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float 0xb6a0000000000000); -0x1p-149
   store volatile i64 %t3, i64* %p
   %t4 = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float 1.0)
   store volatile i64 %t4, i64* %p
   %t5 = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float 0x3ff19999a0000000); 0x1.19999ap+0
   store volatile i64 %t5, i64* %p
   %t6 = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float 1.5)
   store volatile i64 %t6, i64* %p
   %t7 = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float 4294967296.0)
   store volatile i64 %t7, i64* %p
   %t8 = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float 18446742974197923840.0)
   store volatile i64 %t8, i64* %p
   %t9 = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float 0xbfecccccc0000000); -0x1.ccccccp-1
   store volatile i64 %t9, i64* %p
   %t10 = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float 0xbfefffffe0000000); -0x1.fffffep-1
   store volatile i64 %t10, i64* %p
   %t11 = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float 18446744073709551616.0)
   store volatile i64 %t11, i64* %p
   %t12 = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float -1.0)
   store volatile i64 %t12, i64* %p
   %t13 = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float 0x7ff0000000000000); inf
   store volatile i64 %t13, i64* %p
   %t14 = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float 0xfff0000000000000); -inf
   store volatile i64 %t14, i64* %p
   %t15 = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float 0x7ff8000000000000); nan
   store volatile i64 %t15, i64* %p
   %t16 = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float 0x7ffa000000000000); nan:0x200000
   store volatile i64 %t16, i64* %p
   %t17 = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float 0xfff8000000000000); -nan
   store volatile i64 %t17, i64* %p
   %t18 = call i64 @llvm.wasm.trunc.unsigned.i64.f32(float 0xfffa000000000000); -nan:0x200000
   store volatile i64 %t18, i64* %p
   ret void
 }
 
 define void @test_i64_trunc_f64_s(i64* %p) {
 ; CHECK-LABEL: @test_i64_trunc_f64_s(
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P:%.*]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -2, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 4294967296, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -4294967296, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 9223372036854774784, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -9223372036854775808, i64* [[P]], align 8
 ; CHECK-NEXT:    [[T16:%.*]] = call i64 @llvm.wasm.trunc.signed.i64.f64(double 0x43E0000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T16]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T17:%.*]] = call i64 @llvm.wasm.trunc.signed.i64.f64(double 0xC3E0000000000001)
 ; CHECK-NEXT:    store volatile i64 [[T17]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T18:%.*]] = call i64 @llvm.wasm.trunc.signed.i64.f64(double 0x7FF0000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T18]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T19:%.*]] = call i64 @llvm.wasm.trunc.signed.i64.f64(double 0xFFF0000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T19]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T20:%.*]] = call i64 @llvm.wasm.trunc.signed.i64.f64(double 0x7FF8000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T20]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T21:%.*]] = call i64 @llvm.wasm.trunc.signed.i64.f64(double 0x7FF4000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T21]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T22:%.*]] = call i64 @llvm.wasm.trunc.signed.i64.f64(double 0xFFF8000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T22]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T23:%.*]] = call i64 @llvm.wasm.trunc.signed.i64.f64(double 0x7FF4000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T23]], i64* [[P]], align 8
 ; CHECK-NEXT:    ret void
 ;
   %t0 = call i64 @llvm.wasm.trunc.signed.i64.f64(double +0.0)
   store volatile i64 %t0, i64* %p
   %t1 = call i64 @llvm.wasm.trunc.signed.i64.f64(double -0.0)
   store volatile i64 %t1, i64* %p
   %t2 = call i64 @llvm.wasm.trunc.signed.i64.f64(double 0x0010000000000001); 0x0.0000000000001p-1022
   store volatile i64 %t2, i64* %p
   %t3 = call i64 @llvm.wasm.trunc.signed.i64.f64(double 0x8010000000000001); -0x1.0000000000001p-1022
   store volatile i64 %t3, i64* %p
   %t4 = call i64 @llvm.wasm.trunc.signed.i64.f64(double 1.0)
   store volatile i64 %t4, i64* %p
   %t5 = call i64 @llvm.wasm.trunc.signed.i64.f64(double 0x3ff199999999999a); 0x1.199999999999ap+0
   store volatile i64 %t5, i64* %p
   %t6 = call i64 @llvm.wasm.trunc.signed.i64.f64(double 1.5)
   store volatile i64 %t6, i64* %p
   %t7 = call i64 @llvm.wasm.trunc.signed.i64.f64(double -1.0)
   store volatile i64 %t7, i64* %p
   %t8 = call i64 @llvm.wasm.trunc.signed.i64.f64(double 0xbff199999999999a); -0x1.199999999999ap+0
   store volatile i64 %t8, i64* %p
   %t9 = call i64 @llvm.wasm.trunc.signed.i64.f64(double -1.5)
   store volatile i64 %t9, i64* %p
   %t10 = call i64 @llvm.wasm.trunc.signed.i64.f64(double 0xbffe666666666666); -1.9
   store volatile i64 %t10, i64* %p
   %t11 = call i64 @llvm.wasm.trunc.signed.i64.f64(double -2.0)
   store volatile i64 %t11, i64* %p
   %t12 = call i64 @llvm.wasm.trunc.signed.i64.f64(double 4294967296.0)
   store volatile i64 %t12, i64* %p
   %t13 = call i64 @llvm.wasm.trunc.signed.i64.f64(double -4294967296.0)
   store volatile i64 %t13, i64* %p
   %t14 = call i64 @llvm.wasm.trunc.signed.i64.f64(double 9223372036854774784.0)
   store volatile i64 %t14, i64* %p
   %t15 = call i64 @llvm.wasm.trunc.signed.i64.f64(double -9223372036854775808.0)
   store volatile i64 %t15, i64* %p
   %t16 = call i64 @llvm.wasm.trunc.signed.i64.f64(double 9223372036854775808.0)
   store volatile i64 %t16, i64* %p
   %t17 = call i64 @llvm.wasm.trunc.signed.i64.f64(double -9223372036854777856.0)
   store volatile i64 %t17, i64* %p
   %t18 = call i64 @llvm.wasm.trunc.signed.i64.f64(double 0x7ff0000000000000); inf
   store volatile i64 %t18, i64* %p
   %t19 = call i64 @llvm.wasm.trunc.signed.i64.f64(double 0xfff0000000000000); -inf
   store volatile i64 %t19, i64* %p
   %t20 = call i64 @llvm.wasm.trunc.signed.i64.f64(double 0x7ff8000000000000); nan
   store volatile i64 %t20, i64* %p
   %t21 = call i64 @llvm.wasm.trunc.signed.i64.f64(double 0x7ff4000000000000); nan:0x4000000000000
   store volatile i64 %t21, i64* %p
   %t22 = call i64 @llvm.wasm.trunc.signed.i64.f64(double 0xfff8000000000000); -nan
   store volatile i64 %t22, i64* %p
   %t23 = call i64 @llvm.wasm.trunc.signed.i64.f64(double 0x7ff4000000000000); -nan:0x4000000000000
   store volatile i64 %t23, i64* %p
   ret void
 }
 
 define void @test_i64_trunc_f64_u(i64* %p) {
 ; CHECK-LABEL: @test_i64_trunc_f64_u(
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P:%.*]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 4294967295, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 4294967296, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -2048, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 100000000, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 10000000000000000, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -9223372036854775808, i64* [[P]], align 8
 ; CHECK-NEXT:    [[T15:%.*]] = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 0x43F0000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T15]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T16:%.*]] = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double -1.000000e+00)
 ; CHECK-NEXT:    store volatile i64 [[T16]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T17:%.*]] = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 0x7FF0000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T17]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T18:%.*]] = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 0xFFF0000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T18]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T19:%.*]] = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 0x7FF8000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T19]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T20:%.*]] = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 0x7FF4000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T20]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T21:%.*]] = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 0xFFF8000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T21]], i64* [[P]], align 8
 ; CHECK-NEXT:    [[T22:%.*]] = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 0xFFF4000000000000)
 ; CHECK-NEXT:    store volatile i64 [[T22]], i64* [[P]], align 8
 ; CHECK-NEXT:    ret void
 ;
   %t0 = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double +0.0)
   store volatile i64 %t0, i64* %p
   %t1 = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double -0.0)
   store volatile i64 %t1, i64* %p
   %t2 = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 0x0010000000000001); 0x0.0000000000001p-1022
   store volatile i64 %t2, i64* %p
   %t3 = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 0x8010000000000001); -0x0.0000000000001p-1022
   store volatile i64 %t3, i64* %p
   %t4 = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 1.0)
   store volatile i64 %t4, i64* %p
   %t5 = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 0x3ff199999999999a); 0x1.199999999999ap+0
   store volatile i64 %t5, i64* %p
   %t6 = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 1.5)
   store volatile i64 %t6, i64* %p
   %t7 = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 4294967295.0)
   store volatile i64 %t7, i64* %p
   %t8 = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 4294967296.0)
   store volatile i64 %t8, i64* %p
   %t9 = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 18446744073709549568.0)
   store volatile i64 %t9, i64* %p
   %t10 = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 0xbfeccccccccccccd); -0x1.ccccccccccccdp-1
   store volatile i64 %t10, i64* %p
   %t11 = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 0xbfefffffffffffff); -0x1.fffffffffffffp-1
   store volatile i64 %t11, i64* %p
   %t12 = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 100000000.0); 1e8
   store volatile i64 %t12, i64* %p
   %t13 = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 10000000000000000.0); 1e16
   store volatile i64 %t13, i64* %p
   %t14 = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 9223372036854775808.0);
   store volatile i64 %t14, i64* %p
   %t15 = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 18446744073709551616.0)
   store volatile i64 %t15, i64* %p
   %t16 = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double -1.0)
   store volatile i64 %t16, i64* %p
   %t17 = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 0x7ff0000000000000); inf
   store volatile i64 %t17, i64* %p
   %t18 = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 0xfff0000000000000); -inf
   store volatile i64 %t18, i64* %p
   %t19 = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 0x7ff8000000000000); nan
   store volatile i64 %t19, i64* %p
   %t20 = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 0x7ff4000000000000); nan:0x4000000000000
   store volatile i64 %t20, i64* %p
   %t21 = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 0xfff8000000000000); -nan
   store volatile i64 %t21, i64* %p
   %t22 = call i64 @llvm.wasm.trunc.unsigned.i64.f64(double 0xfff4000000000000); -nan:0x4000000000000
   store volatile i64 %t22, i64* %p
   ret void
 }

llvm/test/Transforms/InstSimplify/ConstProp/WebAssembly/trunc_saturate.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 declare i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float)
 declare i32 @llvm.wasm.trunc.saturate.unsigned.i32.f32(float)
 declare i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double)
 declare i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double)
 declare i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float)
 declare i64 @llvm.wasm.trunc.saturate.unsigned.i64.f32(float)
 declare i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double)
 declare i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double)
 
 define void @test_i32_trunc_sat_f32_s(i32* %p) {
 ; CHECK-LABEL: @test_i32_trunc_sat_f32_s(
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -2, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 2147483520, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -2147483648, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 2147483647, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -2147483648, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 2147483647, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -2147483648, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    ret void
 ;
   %t0 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float +0.0)
   store volatile i32 %t0, i32* %p
   %t1 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float -0.0)
   store volatile i32 %t1, i32* %p
   %t2 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float 0x36a0000000000000); 0x1p-149
   store volatile i32 %t2, i32* %p
   %t3 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float 0xb6a0000000000000); -0x1p-149
   store volatile i32 %t3, i32* %p
   %t4 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float 1.0)
   store volatile i32 %t4, i32* %p
   %t5 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float 0x3ff19999a0000000); 0x1.19999ap+0
   store volatile i32 %t5, i32* %p
   %t6 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float 1.5)
   store volatile i32 %t6, i32* %p
   %t7 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float -1.0)
   store volatile i32 %t7, i32* %p
   %t8 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float 0xbff19999a0000000); -0x1.19999ap+0
   store volatile i32 %t8, i32* %p
   %t9 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float -1.5)
   store volatile i32 %t9, i32* %p
   %t10 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float 0xbffe666660000000); -1.9
   store volatile i32 %t10, i32* %p
   %t11 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float -2.0)
   store volatile i32 %t11, i32* %p
   %t12 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float 2147483520.0)
   store volatile i32 %t12, i32* %p
   %t13 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float -2147483648.0)
   store volatile i32 %t13, i32* %p
   %t14 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float 2147483648.0)
   store volatile i32 %t14, i32* %p
   %t15 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float -2147483904.0)
   store volatile i32 %t15, i32* %p
   %t16 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float 0x7ff0000000000000); inf
   store volatile i32 %t16, i32* %p
   %t17 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float 0xfff0000000000000); -inf
   store volatile i32 %t17, i32* %p
   %t18 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float 0x7ff8000000000000); nan
   store volatile i32 %t18, i32* %p
   %t19 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float 0x7ffa000000000000); nan:0x200000
   store volatile i32 %t19, i32* %p
   %t20 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float 0xfff8000000000000); -nan
   store volatile i32 %t20, i32* %p
   %t21 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f32(float 0xfffa000000000000); -nan:0x200000
   store volatile i32 %t21, i32* %p
   ret void
 }
 
 define void @test_i32_trunc_sat_f32_u(i32* %p) {
 ; CHECK-LABEL: @test_i32_trunc_sat_f32_u(
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 2, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -2147483648, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -256, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    ret void
 ;
   %t0 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f32(float +0.0)
   store volatile i32 %t0, i32* %p
   %t1 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f32(float -0.0)
   store volatile i32 %t1, i32* %p
   %t2 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f32(float 0x36a0000000000000); 0x1p-149
   store volatile i32 %t2, i32* %p
   %t3 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f32(float 0xb6a0000000000000); -0x1p-149
   store volatile i32 %t3, i32* %p
   %t4 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f32(float 1.0)
   store volatile i32 %t4, i32* %p
   %t5 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f32(float 0x3ff19999a0000000); 0x1.19999ap+0
   store volatile i32 %t5, i32* %p
   %t6 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f32(float 1.5)
   store volatile i32 %t6, i32* %p
   %t7 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f32(float 0x3ffe666660000000); 1.9
   store volatile i32 %t7, i32* %p
   %t8 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f32(float 2.0)
   store volatile i32 %t8, i32* %p
   %t9 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f32(float 2147483648.0)
   store volatile i32 %t9, i32* %p
   %t10 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f32(float 4294967040.0)
   store volatile i32 %t10, i32* %p
   %t11 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f32(float 0xbfecccccc0000000); -0x1.ccccccp-1
   store volatile i32 %t11, i32* %p
   %t12 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f32(float 0xbfefffffe0000000); -0x1.fffffep-1
   store volatile i32 %t12, i32* %p
   %t13 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f32(float 4294967296.0)
   store volatile i32 %t13, i32* %p
   %t14 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f32(float -1.0)
   store volatile i32 %t14, i32* %p
   %t15 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f32(float 0x7ff0000000000000); inf
   store volatile i32 %t15, i32* %p
   %t16 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f32(float 0xfff0000000000000); -inf
   store volatile i32 %t16, i32* %p
   %t17 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f32(float 0x7ff8000000000000); nan
   store volatile i32 %t17, i32* %p
   %t18 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f32(float 0x7ffa000000000000); nan:0x200000
   store volatile i32 %t18, i32* %p
   %t19 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f32(float 0xfff8000000000000); -nan
   store volatile i32 %t19, i32* %p
   %t20 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f32(float 0xfffa000000000000); -nan:0x200000
   store volatile i32 %t20, i32* %p
   ret void
 }
 
 define void @test_i32_trunc_sat_f64_s(i32* %p) {
 ; CHECK-LABEL: @test_i32_trunc_sat_f64_s(
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -2, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 2147483647, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -2147483648, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 2147483647, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -2147483648, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 2147483647, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -2147483648, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    ret void
 ;
   %t0 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double +0.0)
   store volatile i32 %t0, i32* %p
   %t1 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double -0.0)
   store volatile i32 %t1, i32* %p
   %t2 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double 0x0010000000000001); 0x0.0000000000001p-1022
   store volatile i32 %t2, i32* %p
   %t3 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double 0x8010000000000001); -0x1.0000000000001p-1022
   store volatile i32 %t3, i32* %p
   %t4 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double 1.0)
   store volatile i32 %t4, i32* %p
   %t5 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double 0x3ff199999999999a); 0x1.199999999999ap+0
   store volatile i32 %t5, i32* %p
   %t6 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double 1.5)
   store volatile i32 %t6, i32* %p
   %t7 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double -1.0)
   store volatile i32 %t7, i32* %p
   %t8 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double 0xbff199999999999a); -0x1.199999999999ap+0
   store volatile i32 %t8, i32* %p
   %t9 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double -1.5)
   store volatile i32 %t9, i32* %p
   %t10 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double 0xbffe666666666666); -1.9
   store volatile i32 %t10, i32* %p
   %t11 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double -2.0)
   store volatile i32 %t11, i32* %p
   %t12 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double 2147483647.0)
   store volatile i32 %t12, i32* %p
   %t13 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double -2147483648.0)
   store volatile i32 %t13, i32* %p
   %t14 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double 2147483648.0)
   store volatile i32 %t14, i32* %p
   %t15 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double -2147483649.0)
   store volatile i32 %t15, i32* %p
   %t16 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double 0x7ff0000000000000); inf
   store volatile i32 %t16, i32* %p
   %t17 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double 0xfff0000000000000); -inf
   store volatile i32 %t17, i32* %p
   %t18 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double 0x7ff8000000000000); nan
   store volatile i32 %t18, i32* %p
   %t19 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double 0x7ff4000000000000); nan:0x4000000000000
   store volatile i32 %t19, i32* %p
   %t20 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double 0xfff8000000000000); -nan
   store volatile i32 %t20, i32* %p
   %t21 = call i32 @llvm.wasm.trunc.saturate.signed.i32.f64(double 0x7ff4000000000000); -nan:0x4000000000000
   store volatile i32 %t21, i32* %p
   ret void
 }
 
 define void @test_i32_trunc_sat_f64_u(i32* %p) {
 ; CHECK-LABEL: @test_i32_trunc_sat_f64_u(
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 2, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -2147483648, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 100000000, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 -1, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    store volatile i32 0, i32* [[P]], align 4
 ; CHECK-NEXT:    ret void
 ;
   %t0 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double +0.0)
   store volatile i32 %t0, i32* %p
   %t1 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double -0.0)
   store volatile i32 %t1, i32* %p
   %t2 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double 0x0010000000000001); 0x0.0000000000001p-1022
   store volatile i32 %t2, i32* %p
   %t3 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double 0x8010000000000001); -0x0.0000000000001p-1022
   store volatile i32 %t3, i32* %p
   %t4 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double 1.0)
   store volatile i32 %t4, i32* %p
   %t5 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double 0x3ff199999999999a); 0x1.199999999999ap+0
   store volatile i32 %t5, i32* %p
   %t6 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double 1.5)
   store volatile i32 %t6, i32* %p
   %t7 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double 0x3ffe666666666666); 1.9
   store volatile i32 %t7, i32* %p
   %t8 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double 2.0)
   store volatile i32 %t8, i32* %p
   %t9 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double 2147483648.0)
   store volatile i32 %t9, i32* %p
   %t10 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double 4294967295.0)
   store volatile i32 %t10, i32* %p
   %t11 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double 0xbfeccccccccccccd); -0x1.ccccccccccccdp-1
   store volatile i32 %t11, i32* %p
   %t12 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double 0xbfefffffffffffff); -0x1.fffffffffffffp-1
   store volatile i32 %t12, i32* %p
   %t13 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double 100000000.0); 1e8
   store volatile i32 %t13, i32* %p
   %t14 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double 4294967296.0)
   store volatile i32 %t14, i32* %p
   %t15 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double -1.0)
   store volatile i32 %t15, i32* %p
   %t16 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double 10000000000000000.0); 1e16
   store volatile i32 %t16, i32* %p
   %t17 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double 1000000000000000000000000000000.0); 1e30
   store volatile i32 %t17, i32* %p
   %t18 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double 9223372036854775808.0)
   store volatile i32 %t18, i32* %p
   %t19 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double 0x7ff0000000000000); inf
   store volatile i32 %t19, i32* %p
   %t20 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double 0xfff0000000000000); -inf
   store volatile i32 %t20, i32* %p
   %t21 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double 0x7ff8000000000000); nan
   store volatile i32 %t21, i32* %p
   %t22 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double 0x7ff4000000000000); nan:0x4000000000000
   store volatile i32 %t22, i32* %p
   %t23 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double 0xfff8000000000000); -nan
   store volatile i32 %t23, i32* %p
   %t24 = call i32 @llvm.wasm.trunc.saturate.unsigned.i32.f64(double 0xfff4000000000000); -nan:0x4000000000000
   store volatile i32 %t24, i32* %p
   ret void
 }
 
 define void @test_i64_trunc_sat_f32_s(i64* %p) {
 ; CHECK-LABEL: @test_i64_trunc_sat_f32_s(
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P:%.*]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -2, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 4294967296, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -4294967296, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 9223371487098961920, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -9223372036854775808, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 9223372036854775807, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -9223372036854775808, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 9223372036854775807, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -9223372036854775808, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    ret void
 ;
   %t0 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float +0.0)
   store volatile i64 %t0, i64* %p
   %t1 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float -0.0)
   store volatile i64 %t1, i64* %p
   %t2 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float 0x36a0000000000000); 0x1p-149
   store volatile i64 %t2, i64* %p
   %t3 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float 0xb6a0000000000000); -0x1p-149
   store volatile i64 %t3, i64* %p
   %t4 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float 1.0)
   store volatile i64 %t4, i64* %p
   %t5 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float 0x3ff19999a0000000); 0x1.19999ap+0
   store volatile i64 %t5, i64* %p
   %t6 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float 1.5)
   store volatile i64 %t6, i64* %p
   %t7 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float -1.0)
   store volatile i64 %t7, i64* %p
   %t8 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float 0xbff19999a0000000); -0x1.19999ap+0
   store volatile i64 %t8, i64* %p
   %t9 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float -1.5)
   store volatile i64 %t9, i64* %p
   %t10 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float 0xbffe666660000000); -1.9
   store volatile i64 %t10, i64* %p
   %t11 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float -2.0)
   store volatile i64 %t11, i64* %p
   %t12 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float 4294967296.0)
   store volatile i64 %t12, i64* %p
   %t13 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float -4294967296.0)
   store volatile i64 %t13, i64* %p
   %t14 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float 9223371487098961920.0)
   store volatile i64 %t14, i64* %p
   %t15 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float -9223372036854775808.0)
   store volatile i64 %t15, i64* %p
   %t16 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float 9223372036854775808.0)
   store volatile i64 %t16, i64* %p
   %t17 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float -9223373136366403584.0)
   store volatile i64 %t17, i64* %p
   %t18 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float 0x7ff0000000000000); inf
   store volatile i64 %t18, i64* %p
   %t19 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float 0xfff0000000000000); -inf
   store volatile i64 %t19, i64* %p
   %t20 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float 0x7ff8000000000000); nan
   store volatile i64 %t20, i64* %p
   %t21 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float 0x7ffa000000000000); nan:0x200000
   store volatile i64 %t21, i64* %p
   %t22 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float 0xfff8000000000000); -nan
   store volatile i64 %t22, i64* %p
   %t23 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f32(float 0xfffa000000000000); -nan:0x200000
   store volatile i64 %t23, i64* %p
   ret void
 }
 
 define void @test_i64_trunc_sat_f32_u(i64* %p) {
 ; CHECK-LABEL: @test_i64_trunc_sat_f32_u(
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P:%.*]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 4294967296, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -1099511627776, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    ret void
 ;
   %t0 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f32(float +0.0)
   store volatile i64 %t0, i64* %p
   %t1 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f32(float -0.0)
   store volatile i64 %t1, i64* %p
   %t2 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f32(float 0x36a0000000000000); 0x1p-149
   store volatile i64 %t2, i64* %p
   %t3 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f32(float 0xb6a0000000000000); -0x1p-149
   store volatile i64 %t3, i64* %p
   %t4 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f32(float 1.0)
   store volatile i64 %t4, i64* %p
   %t5 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f32(float 0x3ff19999a0000000); 0x1.19999ap+0
   store volatile i64 %t5, i64* %p
   %t6 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f32(float 1.5)
   store volatile i64 %t6, i64* %p
   %t7 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f32(float 4294967296.0)
   store volatile i64 %t7, i64* %p
   %t8 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f32(float 18446742974197923840.0)
   store volatile i64 %t8, i64* %p
   %t9 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f32(float 0xbfecccccc0000000); -0x1.ccccccp-1
   store volatile i64 %t9, i64* %p
   %t10 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f32(float 0xbfefffffe0000000); -0x1.fffffep-1
   store volatile i64 %t10, i64* %p
   %t11 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f32(float 18446744073709551616.0)
   store volatile i64 %t11, i64* %p
   %t12 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f32(float -1.0)
   store volatile i64 %t12, i64* %p
   %t13 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f32(float 0x7ff0000000000000); inf
   store volatile i64 %t13, i64* %p
   %t14 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f32(float 0xfff0000000000000); -inf
   store volatile i64 %t14, i64* %p
   %t15 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f32(float 0x7ff8000000000000); nan
   store volatile i64 %t15, i64* %p
   %t16 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f32(float 0x7ffa000000000000); nan:0x200000
   store volatile i64 %t16, i64* %p
   %t17 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f32(float 0xfff8000000000000); -nan
   store volatile i64 %t17, i64* %p
   %t18 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f32(float 0xfffa000000000000); -nan:0x200000
   store volatile i64 %t18, i64* %p
   ret void
 }
 
 define void @test_i64_trunc_sat_f64_s(i64* %p) {
 ; CHECK-LABEL: @test_i64_trunc_sat_f64_s(
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P:%.*]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -2, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 4294967296, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -4294967296, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 9223372036854774784, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -9223372036854775808, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 9223372036854775807, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -9223372036854775808, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 9223372036854775807, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -9223372036854775808, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    ret void
 ;
   %t0 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double +0.0)
   store volatile i64 %t0, i64* %p
   %t1 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double -0.0)
   store volatile i64 %t1, i64* %p
   %t2 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double 0x0010000000000001); 0x0.0000000000001p-1022
   store volatile i64 %t2, i64* %p
   %t3 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double 0x8010000000000001); -0x1.0000000000001p-1022
   store volatile i64 %t3, i64* %p
   %t4 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double 1.0)
   store volatile i64 %t4, i64* %p
   %t5 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double 0x3ff199999999999a); 0x1.199999999999ap+0
   store volatile i64 %t5, i64* %p
   %t6 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double 1.5)
   store volatile i64 %t6, i64* %p
   %t7 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double -1.0)
   store volatile i64 %t7, i64* %p
   %t8 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double 0xbff199999999999a); -0x1.199999999999ap+0
   store volatile i64 %t8, i64* %p
   %t9 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double -1.5)
   store volatile i64 %t9, i64* %p
   %t10 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double 0xbffe666666666666); -1.9
   store volatile i64 %t10, i64* %p
   %t11 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double -2.0)
   store volatile i64 %t11, i64* %p
   %t12 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double 4294967296.0)
   store volatile i64 %t12, i64* %p
   %t13 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double -4294967296.0)
   store volatile i64 %t13, i64* %p
   %t14 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double 9223372036854774784.0)
   store volatile i64 %t14, i64* %p
   %t15 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double -9223372036854775808.0)
   store volatile i64 %t15, i64* %p
   %t16 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double 9223372036854775808.0)
   store volatile i64 %t16, i64* %p
   %t17 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double -9223372036854777856.0)
   store volatile i64 %t17, i64* %p
   %t18 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double 0x7ff0000000000000); inf
   store volatile i64 %t18, i64* %p
   %t19 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double 0xfff0000000000000); -inf
   store volatile i64 %t19, i64* %p
   %t20 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double 0x7ff8000000000000); nan
   store volatile i64 %t20, i64* %p
   %t21 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double 0x7ff4000000000000); nan:0x4000000000000
   store volatile i64 %t21, i64* %p
   %t22 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double 0xfff8000000000000); -nan
   store volatile i64 %t22, i64* %p
   %t23 = call i64 @llvm.wasm.trunc.saturate.signed.i64.f64(double 0x7ff4000000000000); -nan:0x4000000000000
   store volatile i64 %t23, i64* %p
   ret void
 }
 
 define void @test_i64_trunc_sat_f64_u(i64* %p) {
 ; CHECK-LABEL: @test_i64_trunc_sat_f64_u(
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P:%.*]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 4294967295, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 4294967296, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -2048, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 100000000, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 10000000000000000, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -9223372036854775808, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 -1, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    store volatile i64 0, i64* [[P]], align 8
 ; CHECK-NEXT:    ret void
 ;
   %t0 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double +0.0)
   store volatile i64 %t0, i64* %p
   %t1 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double -0.0)
   store volatile i64 %t1, i64* %p
   %t2 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double 0x0010000000000001); 0x0.0000000000001p-1022
   store volatile i64 %t2, i64* %p
   %t3 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double 0x8010000000000001); -0x0.0000000000001p-1022
   store volatile i64 %t3, i64* %p
   %t4 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double 1.0)
   store volatile i64 %t4, i64* %p
   %t5 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double 0x3ff199999999999a); 0x1.199999999999ap+0
   store volatile i64 %t5, i64* %p
   %t6 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double 1.5)
   store volatile i64 %t6, i64* %p
   %t7 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double 4294967295.0)
   store volatile i64 %t7, i64* %p
   %t8 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double 4294967296.0)
   store volatile i64 %t8, i64* %p
   %t9 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double 18446744073709549568.0)
   store volatile i64 %t9, i64* %p
   %t10 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double 0xbfeccccccccccccd); -0x1.ccccccccccccdp-1
   store volatile i64 %t10, i64* %p
   %t11 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double 0xbfefffffffffffff); -0x1.fffffffffffffp-1
   store volatile i64 %t11, i64* %p
   %t12 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double 100000000.0); 1e8
   store volatile i64 %t12, i64* %p
   %t13 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double 10000000000000000.0); 1e16
   store volatile i64 %t13, i64* %p
   %t14 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double 9223372036854775808.0);
   store volatile i64 %t14, i64* %p
   %t15 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double 18446744073709551616.0)
   store volatile i64 %t15, i64* %p
   %t16 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double -1.0)
   store volatile i64 %t16, i64* %p
   %t17 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double 0x7ff0000000000000); inf
   store volatile i64 %t17, i64* %p
   %t18 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double 0xfff0000000000000); -inf
   store volatile i64 %t18, i64* %p
   %t19 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double 0x7ff8000000000000); nan
   store volatile i64 %t19, i64* %p
   %t20 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double 0x7ff4000000000000); nan:0x4000000000000
   store volatile i64 %t20, i64* %p
   %t21 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double 0xfff8000000000000); -nan
   store volatile i64 %t21, i64* %p
   %t22 = call i64 @llvm.wasm.trunc.saturate.unsigned.i64.f64(double 0xfff4000000000000); -nan:0x4000000000000
   store volatile i64 %t22, i64* %p
   ret void
 }

llvm/test/Transforms/InstSimplify/ConstProp/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/Transforms/InstSimplify/ConstProp/allones.ll

 ; RUN: opt -early-cse -S -o - %s | FileCheck %s
 target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64-ni:2"
 target triple = "armv7-unknown-linux-gnueabi"
 
 %struct.anon = type { i32 }
 
 @onesstruct = private constant %struct.anon { i32 -1 }, align 4
 
 define i32 @allones_struct() {
 ; CHECK-LABEL: @allones_struct()
 ; CHECK-NEXT:    %1 = load [1 x i32], [1 x i32]* bitcast (%struct.anon* @onesstruct to [1 x i32]*), align 4
 ; CHECK-NEXT:    %2 = extractvalue [1 x i32] %1, 0
 ; CHECK-NEXT:    ret i32 %2
   %1 = load [1 x i32], [1 x i32]* bitcast (%struct.anon* @onesstruct to [1 x i32]*), align 4
   %2 = extractvalue [1 x i32] %1, 0
   ret i32 %2
 }
 
 define i32 @allones_int() {
 ; CHECK-LABEL: @allones_int()
 ; CHECK-NEXT:    ret i32 -1
   %1 = load i32, i32* bitcast (%struct.anon* @onesstruct to i32*), align 4
   ret i32 %1
 }
 
 define i32* @allones_ptr() {
 ; CHECK-LABEL: @allones_ptr()
 ; CHECK-NEXT:    ret i32* inttoptr (i32 -1 to i32*)
   %1 = load i32*, i32** bitcast (%struct.anon* @onesstruct to i32**), align 4
   ret i32* %1
 }
 
 define i32 addrspace(1)* @allones_ptr1() {
 ; CHECK-LABEL: @allones_ptr1()
 ; CHECK-NEXT:    ret i32 addrspace(1)* inttoptr (i32 -1 to i32 addrspace(1)*)
   %1 = load i32 addrspace(1)*, i32 addrspace(1)** bitcast (%struct.anon* @onesstruct to i32 addrspace(1)**), align 4
   ret i32 addrspace(1)* %1
 }
 
 define i32 addrspace(2)* @allones_ptr2() {
 ; CHECK-LABEL: @allones_ptr2()
 ; CHECK-NEXT:    %1 = load i32 addrspace(2)*, i32 addrspace(2)** bitcast (%struct.anon* @onesstruct to i32 addrspace(2)**), align 4
 ; CHECK-NEXT:    ret i32 addrspace(2)* %1
   %1 = load i32 addrspace(2)*, i32 addrspace(2)** bitcast (%struct.anon* @onesstruct to i32 addrspace(2)**), align 4
   ret i32 addrspace(2)* %1
 }

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/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/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/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/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-vector.ll

-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -instsimplify -S | FileCheck %s
-
-; Test constant fold of constant expression GEP used by ptrtoint (the
-; "offsetof-like expression" case).
-; This used to hit an assert due to not supporting vectors in
-; llvm::ConstantFoldCastInstruction when handling ptrtoint.
-define <2 x i16> @test1() {
-; CHECK-LABEL: @test1(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    ret <2 x i16> ptrtoint (<2 x i32*> getelementptr ([10 x i32], [10 x i32]* null, <2 x i64> zeroinitializer, <2 x i64> <i64 5, i64 7>) to <2 x i16>)
-;
-entry:
-  %gep = getelementptr inbounds [10 x i32], [10 x i32]* null, i16 0, <2 x i16> <i16 5, i16 7>
-  %vec = ptrtoint <2 x i32*> %gep to <2 x i16>
-  ret <2 x i16> %vec
-}
-
-; Test constant fold of constant expression GEP used by ptrtoint (the
-; "sizeof-like expression" case).
-; This used to hit an assert due to not supporting vectors in
-; llvm::ConstantFoldCastInstruction when handling ptrtoint.
-define <2 x i16> @test2() {
-; CHECK-LABEL: @test2(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    ret <2 x i16> ptrtoint (<2 x i32*> getelementptr (i32, i32* null, <2 x i64> <i64 5, i64 7>) to <2 x i16>)
-;
-entry:
-  %gep = getelementptr i32, i32* null, <2 x i16> <i16 5, i16 7>
-  %vec = ptrtoint <2 x i32*> %gep to <2 x i16>
-  ret <2 x i16> %vec
-}
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -instsimplify -S | FileCheck %s
+
+; Test constant fold of constant expression GEP used by ptrtoint (the
+; "offsetof-like expression" case).
+; This used to hit an assert due to not supporting vectors in
+; llvm::ConstantFoldCastInstruction when handling ptrtoint.
+define <2 x i16> @test1() {
+; CHECK-LABEL: @test1(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret <2 x i16> ptrtoint (<2 x i32*> getelementptr ([10 x i32], [10 x i32]* null, <2 x i64> zeroinitializer, <2 x i64> <i64 5, i64 7>) to <2 x i16>)
+;
+entry:
+  %gep = getelementptr inbounds [10 x i32], [10 x i32]* null, i16 0, <2 x i16> <i16 5, i16 7>
+  %vec = ptrtoint <2 x i32*> %gep to <2 x i16>
+  ret <2 x i16> %vec
+}
+
+; Test constant fold of constant expression GEP used by ptrtoint (the
+; "sizeof-like expression" case).
+; This used to hit an assert due to not supporting vectors in
+; llvm::ConstantFoldCastInstruction when handling ptrtoint.
+define <2 x i16> @test2() {
+; CHECK-LABEL: @test2(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret <2 x i16> ptrtoint (<2 x i32*> getelementptr (i32, i32* null, <2 x i64> <i64 5, i64 7>) to <2 x i16>)
+;
+entry:
+  %gep = getelementptr i32, i32* null, <2 x i16> <i16 5, i16 7>
+  %vec = ptrtoint <2 x i32*> %gep to <2 x i16>
+  ret <2 x i16> %vec
+}

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/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/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/extractelement-vscale.ll

 ; RUN: opt -instcombine -S < %s | FileCheck %s
 
 ; CHECK-LABEL: definitely_in_bounds
 ; CHECK: ret i8 0
 define i8 @definitely_in_bounds() {
   ret i8 extractelement (<vscale x 16 x i8> zeroinitializer, i64 15)
 }
 
 ; CHECK-LABEL: maybe_in_bounds
 ; CHECK: ret i8 extractelement (<vscale x 16 x i8> zeroinitializer, i64 16)
 define i8 @maybe_in_bounds() {
   ret i8 extractelement (<vscale x 16 x i8> zeroinitializer, i64 16)
 }

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/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/Transforms/InstSimplify/ConstProp/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/Transforms/InstSimplify/ConstProp/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/Transforms/InstSimplify/ConstProp/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/Transforms/InstSimplify/ConstProp/gep-alias.ll

-; RUN: opt -instcombine -S -o - %s | FileCheck %s
-; Test that we don't replace an alias with its aliasee when simplifying GEPs.
-; In this test case the transformation is invalid because it replaces the
-; reference to the symbol "b" (which refers to whichever instance of "b"
-; was chosen by the linker) with a reference to "a" (which refers to the
-; specific instance of "b" in this module).
-
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
-
-@a = internal global [3 x i8*] zeroinitializer
-@b = linkonce_odr alias [3 x i8*], [3 x i8*]* @a
-
-define i8** @f() {
-  ; CHECK: ret i8** getelementptr ([3 x i8*], [3 x i8*]* @b, i64 0, i64 1)
-  ret i8** getelementptr ([3 x i8*], [3 x i8*]* @b, i64 0, i64 1)
-}
+; RUN: opt -instcombine -S -o - %s | FileCheck %s
+; Test that we don't replace an alias with its aliasee when simplifying GEPs.
+; In this test case the transformation is invalid because it replaces the
+; reference to the symbol "b" (which refers to whichever instance of "b"
+; was chosen by the linker) with a reference to "a" (which refers to the
+; specific instance of "b" in this module).
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@a = internal global [3 x i8*] zeroinitializer
+@b = linkonce_odr alias [3 x i8*], [3 x i8*]* @a
+
+define i8** @f() {
+  ; CHECK: ret i8** getelementptr ([3 x i8*], [3 x i8*]* @b, i64 0, i64 1)
+  ret i8** getelementptr ([3 x i8*], [3 x i8*]* @b, i64 0, i64 1)
+}

llvm/test/Transforms/InstSimplify/ConstProp/gep-constanfolding-error.ll

-; RUN: opt -gvn -S -o - %s | FileCheck %s
-; RUN: opt -newgvn -S -o - %s | FileCheck %s
-; Test that the constantfolding getelementptr computation results in
-; j[5][4][1] (j+239)
-; and not [1][4][4][1] (#449) which is an incorrect out-of-range error
-target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
-target triple = "armv7-none-eabi"
-
-@f = local_unnamed_addr global i32 2, align 4
-@t6 = local_unnamed_addr global i32 1, align 4
-@j = local_unnamed_addr global [6 x [6 x [7 x i8]]] [[6 x [7 x i8]] [[7 x i8] c"\06\00\00\00\00\00\00", [7 x i8] zeroinitializer, [7 x i8] zeroinitializer, [7 x i8] zeroinitializer, [7 x i8] zeroinitializer, [7 x i8] zeroinitializer], [6 x [7 x i8]] zeroinitializer, [6 x [7 x i8]] zeroinitializer, [6 x [7 x i8]] zeroinitializer, [6 x [7 x i8]] zeroinitializer, [6 x [7 x i8]] zeroinitializer], align 1
-@p = internal global i64 0, align 8
-@y = local_unnamed_addr global i64* @p, align 4
-@b = internal unnamed_addr global i32 0, align 4
-@h = common local_unnamed_addr global i16 0, align 2
-@a = common local_unnamed_addr global i32 0, align 4
-@k = common local_unnamed_addr global i32 0, align 4
-@t11 = common local_unnamed_addr global i32 0, align 4
-
-; Function Attrs: nounwind
-define i32 @main() local_unnamed_addr {
-entry:
-  %0 = load i32, i32* @t6, align 4
-  %inc = add nsw i32 %0, 1
-  store i32 %inc, i32* @t6, align 4
-  store i16 4, i16* @h, align 2
-  %1 = load i32, i32* @a, align 4
-  %conv = trunc i32 %1 to i8
-  store i32 1, i32* @f, align 4
-  %2 = load i64, i64* @p, align 8
-  %cmp4 = icmp slt i64 %2, 2
-  %conv6 = zext i1 %cmp4 to i8
-  %3 = load i16, i16* @h, align 2
-  %conv7 = sext i16 %3 to i32
-  %add = add nsw i32 %conv7, 1
-  %f.promoted = load i32, i32* @f, align 4
-  %4 = mul i32 %conv7, 7
-  %5 = add i32 %4, 5
-  %6 = sub i32 -1, %f.promoted
-  %7 = icmp sgt i32 %6, -2
-  %smax = select i1 %7, i32 %6, i32 -2
-  %8 = sub i32 6, %smax
-  %scevgep = getelementptr [6 x [6 x [7 x i8]]], [6 x [6 x [7 x i8]]]* @j, i32 0, i32 0, i32 %5, i32 %8
-  %9 = add i32 %f.promoted, %smax
-  %10 = add i32 %9, 2
-  call void @llvm.memset.p0i8.i32(i8* %scevgep, i8 %conv6, i32 %10, i1 false)
-; CHECK:  call void @llvm.memset.p0i8.i32(i8* getelementptr inbounds ([6 x [6 x [7 x i8]]], [6 x [6 x [7 x i8]]]* @j, i32 0, i{{32|64}} 5, i{{32|64}} 4, i32 1), i8 %conv6, i32 1, i1 false)
-; CHECK-NOT: call void @llvm.memset.p0i8.i32(i8* getelementptr ([6 x [6 x [7 x i8]]], [6 x [6 x [7 x i8]]]* @j, i64 1, i64 4, i64 4, i32 1)
-  ret i32 0
-}
-; Function Attrs: argmemonly nounwind
-declare void @llvm.memset.p0i8.i32(i8* nocapture writeonly, i8, i32, i1)
+; RUN: opt -gvn -S -o - %s | FileCheck %s
+; RUN: opt -newgvn -S -o - %s | FileCheck %s
+; Test that the constantfolding getelementptr computation results in
+; j[5][4][1] (j+239)
+; and not [1][4][4][1] (#449) which is an incorrect out-of-range error
+target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
+target triple = "armv7-none-eabi"
+
+@f = local_unnamed_addr global i32 2, align 4
+@t6 = local_unnamed_addr global i32 1, align 4
+@j = local_unnamed_addr global [6 x [6 x [7 x i8]]] [[6 x [7 x i8]] [[7 x i8] c"\06\00\00\00\00\00\00", [7 x i8] zeroinitializer, [7 x i8] zeroinitializer, [7 x i8] zeroinitializer, [7 x i8] zeroinitializer, [7 x i8] zeroinitializer], [6 x [7 x i8]] zeroinitializer, [6 x [7 x i8]] zeroinitializer, [6 x [7 x i8]] zeroinitializer, [6 x [7 x i8]] zeroinitializer, [6 x [7 x i8]] zeroinitializer], align 1
+@p = internal global i64 0, align 8
+@y = local_unnamed_addr global i64* @p, align 4
+@b = internal unnamed_addr global i32 0, align 4
+@h = common local_unnamed_addr global i16 0, align 2
+@a = common local_unnamed_addr global i32 0, align 4
+@k = common local_unnamed_addr global i32 0, align 4
+@t11 = common local_unnamed_addr global i32 0, align 4
+
+; Function Attrs: nounwind
+define i32 @main() local_unnamed_addr {
+entry:
+  %0 = load i32, i32* @t6, align 4
+  %inc = add nsw i32 %0, 1
+  store i32 %inc, i32* @t6, align 4
+  store i16 4, i16* @h, align 2
+  %1 = load i32, i32* @a, align 4
+  %conv = trunc i32 %1 to i8
+  store i32 1, i32* @f, align 4
+  %2 = load i64, i64* @p, align 8
+  %cmp4 = icmp slt i64 %2, 2
+  %conv6 = zext i1 %cmp4 to i8
+  %3 = load i16, i16* @h, align 2
+  %conv7 = sext i16 %3 to i32
+  %add = add nsw i32 %conv7, 1
+  %f.promoted = load i32, i32* @f, align 4
+  %4 = mul i32 %conv7, 7
+  %5 = add i32 %4, 5
+  %6 = sub i32 -1, %f.promoted
+  %7 = icmp sgt i32 %6, -2
+  %smax = select i1 %7, i32 %6, i32 -2
+  %8 = sub i32 6, %smax
+  %scevgep = getelementptr [6 x [6 x [7 x i8]]], [6 x [6 x [7 x i8]]]* @j, i32 0, i32 0, i32 %5, i32 %8
+  %9 = add i32 %f.promoted, %smax
+  %10 = add i32 %9, 2
+  call void @llvm.memset.p0i8.i32(i8* %scevgep, i8 %conv6, i32 %10, i1 false)
+; CHECK:  call void @llvm.memset.p0i8.i32(i8* getelementptr inbounds ([6 x [6 x [7 x i8]]], [6 x [6 x [7 x i8]]]* @j, i32 0, i{{32|64}} 5, i{{32|64}} 4, i32 1), i8 %conv6, i32 1, i1 false)
+; CHECK-NOT: call void @llvm.memset.p0i8.i32(i8* getelementptr ([6 x [6 x [7 x i8]]], [6 x [6 x [7 x i8]]]* @j, i64 1, i64 4, i64 4, i32 1)
+  ret i32 0
+}
+; Function Attrs: argmemonly nounwind
+declare void @llvm.memset.p0i8.i32(i8* nocapture writeonly, i8, i32, i1)

llvm/test/Transforms/InstSimplify/ConstProp/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/Transforms/InstSimplify/ConstProp/gep.ll

-; RUN: opt -instcombine -S -o - %s | FileCheck %s
-; Tests that we preserve the inrange attribute on indices where possible.
-
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
-
-%struct.A = type { i32 (...)** }
-
-@vt = external global [3 x i8*]
-
-; CHECK: define i32 (...)** @f0()
-define i32 (...)** @f0() {
-  ; CHECK-NEXT: ret i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*], [3 x i8*]* @vt, inrange i64 0, i64 2) to i32 (...)**
-  ret i32 (...)** getelementptr (i32 (...)*, i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*], [3 x i8*]* @vt, inrange i64 0, i64 1) to i32 (...)**), i64 1)
-}
-
-; CHECK: define i32 (...)** @f1()
-define i32 (...)** @f1() {
-  ; CHECK-NEXT: ret i32 (...)** getelementptr (i32 (...)*, i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*], [3 x i8*]* @vt, i64 0, inrange i64 1) to i32 (...)**), i64 1)
-  ret i32 (...)** getelementptr (i32 (...)*, i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*], [3 x i8*]* @vt, i64 0, inrange i64 1) to i32 (...)**), i64 1)
-}
-
-; CHECK: define i32 (...)** @f2()
-define i32 (...)** @f2() {
-  ; CHECK-NEXT: ret i32 (...)** getelementptr (i32 (...)*, i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*], [3 x i8*]* @vt, i64 0, inrange i64 1) to i32 (...)**), i64 3)
-  ret i32 (...)** getelementptr (i32 (...)*, i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*], [3 x i8*]* @vt, i64 0, inrange i64 1) to i32 (...)**), i64 3)
-}
+; RUN: opt -instcombine -S -o - %s | FileCheck %s
+; Tests that we preserve the inrange attribute on indices where possible.
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+%struct.A = type { i32 (...)** }
+
+@vt = external global [3 x i8*]
+
+; CHECK: define i32 (...)** @f0()
+define i32 (...)** @f0() {
+  ; CHECK-NEXT: ret i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*], [3 x i8*]* @vt, inrange i64 0, i64 2) to i32 (...)**
+  ret i32 (...)** getelementptr (i32 (...)*, i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*], [3 x i8*]* @vt, inrange i64 0, i64 1) to i32 (...)**), i64 1)
+}
+
+; CHECK: define i32 (...)** @f1()
+define i32 (...)** @f1() {
+  ; CHECK-NEXT: ret i32 (...)** getelementptr (i32 (...)*, i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*], [3 x i8*]* @vt, i64 0, inrange i64 1) to i32 (...)**), i64 1)
+  ret i32 (...)** getelementptr (i32 (...)*, i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*], [3 x i8*]* @vt, i64 0, inrange i64 1) to i32 (...)**), i64 1)
+}
+
+; CHECK: define i32 (...)** @f2()
+define i32 (...)** @f2() {
+  ; CHECK-NEXT: ret i32 (...)** getelementptr (i32 (...)*, i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*], [3 x i8*]* @vt, i64 0, inrange i64 1) to i32 (...)**), i64 3)
+  ret i32 (...)** getelementptr (i32 (...)*, i32 (...)** bitcast (i8** getelementptr inbounds ([3 x i8*], [3 x i8*]* @vt, i64 0, inrange i64 1) to i32 (...)**), i64 3)
+}

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/math-1.ll

-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -early-cse -S -o - %s | FileCheck %s
-
-declare double @acos(double)
-define double @f_acos() {
-; CHECK-LABEL: @f_acos(
-; CHECK-NEXT:    ret double 0.000000e+00
-;
-  %res = tail call fast double @acos(double 1.0)
-  ret double %res
-}
-
-declare float @asinf(float)
-define float @f_asinf() {
-; CHECK-LABEL: @f_asinf(
-; CHECK-NEXT:    ret float 0x3FF921FB{{.+}}
-;
-  %res = tail call fast float @asinf(float 1.0)
-  ret float %res
-}
-
-declare double @atan(double)
-define double @f_atan() {
-; CHECK-LABEL: @f_atan(
-; CHECK-NEXT:    [[RES:%.*]] = tail call fast double @atan(double 1.000000e+00)
-; CHECK-NEXT:    ret double 0x3FE921FB
-;
-  %res = tail call fast double @atan(double 1.0)
-  ret double %res
-}
-
-declare float @cosf(float)
-define float @f_cosf() {
-; CHECK-LABEL: @f_cosf(
-; CHECK-NEXT:    ret float 0x3FE14A2{{.+}}
-;
-  %res = tail call fast float @cosf(float 1.0)
-  ret float %res
-}
-
-declare float @llvm.cos.f32(float)
-define float @i_cosf() {
-; CHECK-LABEL: @i_cosf(
-; CHECK-NEXT:    ret float 0x3FE14A2
-;
-  %res = tail call fast float @llvm.cos.f32(float 1.0)
-  ret float %res
-}
-
-declare double @cosh(double)
-define double @f_cosh() {
-; CHECK-LABEL: @f_cosh(
-; CHECK-NEXT:    ret double 0x3FF8B075{{.+}}
-;
-  %res = tail call fast double @cosh(double 1.0)
-  ret double %res
-}
-
-declare float @expf(float)
-define float @f_expf() {
-; CHECK-LABEL: @f_expf(
-; CHECK-NEXT:    ret float 0x4005BF0A{{.+}}
-;
-  %res = tail call fast float @expf(float 1.0)
-  ret float %res
-}
-
-declare float @llvm.exp.f32(float)
-define float @i_expf() {
-; CHECK-LABEL: @i_expf(
-; CHECK-NEXT:    ret float 0x4005BF0A{{.+}}
-;
-  %res = tail call fast float @llvm.exp.f32(float 1.0)
-  ret float %res
-}
-
-declare double @exp2(double)
-define double @f_exp2() {
-; CHECK-LABEL: @f_exp2(
-; CHECK-NEXT:    ret double 2.000000e+00
-;
-  %res = tail call fast double @exp2(double 1.0)
-  ret double %res
-}
-
-declare double @llvm.exp2.f64(double)
-define double @i_exp2() {
-; CHECK-LABEL: @i_exp2(
-; CHECK-NEXT:    ret double 2.000000e+00
-;
-  %res = tail call fast double @llvm.exp2.f64(double 1.0)
-  ret double %res
-}
-
-; FIXME: exp10() is not widely supported.
-declare float @exp10f(float)
-define float @f_exp10f() {
-; CHECK-LABEL: @f_exp10f(
-; CHECK-NEXT:    [[RES:%.*]] = tail call float @exp10f(float 1.000000e+00)
-; CHECK-NEXT:    ret float [[RES]]
-;
-  %res = tail call float @exp10f(float 1.0)
-  ret float %res
-}
-
-declare double @log(double)
-define double @f_log() {
-; CHECK-LABEL: @f_log(
-; CHECK-NEXT:    ret double 0.000000e+00
-;
-  %res = tail call fast double @log(double 1.0)
-  ret double %res
-}
-
-declare double @llvm.log.f64(double)
-define double @i_log() {
-; CHECK-LABEL: @i_log(
-; CHECK-NEXT:    ret double 0.000000e+00
-;
-  %res = tail call fast double @llvm.log.f64(double 1.0)
-  ret double %res
-}
-
-declare float @log2f(float)
-define float @f_log2f() {
-; CHECK-LABEL: @f_log2f(
-; CHECK-NEXT:    ret float 0.000000e+00
-;
-  %res = tail call fast float @log2f(float 1.0)
-  ret float %res
-}
-
-declare float @llvm.log2.f32(float)
-define float @i_log2f() {
-; CHECK-LABEL: @i_log2f(
-; CHECK-NEXT:    ret float 0.000000e+00
-;
-  %res = tail call fast float @llvm.log2.f32(float 1.0)
-  ret float %res
-}
-
-declare double @log10(double)
-define double @f_log10() {
-; CHECK-LABEL: @f_log10(
-; CHECK-NEXT:    ret double 0.000000e+00
-;
-  %res = tail call fast double @log10(double 1.0)
-  ret double %res
-}
-
-declare float @sinf(float)
-define float @f_sinf() {
-; CHECK-LABEL: @f_sinf(
-; CHECK-NEXT:    ret float 0x3FEAED54{{.+}}
-;
-  %res = tail call fast float @sinf(float 1.0)
-  ret float %res
-}
-
-declare double @sinh(double)
-define double @f_sinh() {
-; CHECK-LABEL: @f_sinh(
-; CHECK-NEXT:    ret double 0x3FF2CD9F{{.+}}
-;
-  %res = tail call fast double @sinh(double 1.0)
-  ret double %res
-}
-
-declare float @sqrtf(float)
-define float @f_sqrtf() {
-; CHECK-LABEL: @f_sqrtf(
-; CHECK-NEXT:    ret float 1.000000e+00
-;
-  %res = tail call fast float @sqrtf(float 1.0)
-  ret float %res
-}
-
-declare double @tan(double)
-define double @f_tan() {
-; CHECK-LABEL: @f_tan(
-; CHECK-NEXT:    ret double 0x3FF8EB24{{.+}}
-;
-  %res = tail call fast double @tan(double 1.0)
-  ret double %res
-}
-
-declare float @tanhf(float)
-define float @f_tanhf() {
-; CHECK-LABEL: @f_tanhf(
-; CHECK-NEXT:    [[RES:%.*]] = tail call fast float @tanhf(float 1.000000e+00)
-; CHECK-NEXT:    ret float 0x3FE85EFA{{.+}}
-;
-  %res = tail call fast float @tanhf(float 1.0)
-  ret float %res
-}
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt -early-cse -S -o - %s | FileCheck %s
+
+declare double @acos(double)
+define double @f_acos() {
+; CHECK-LABEL: @f_acos(
+; CHECK-NEXT:    ret double 0.000000e+00
+;
+  %res = tail call fast double @acos(double 1.0)
+  ret double %res
+}
+
+declare float @asinf(float)
+define float @f_asinf() {
+; CHECK-LABEL: @f_asinf(
+; CHECK-NEXT:    ret float 0x3FF921FB{{.+}}
+;
+  %res = tail call fast float @asinf(float 1.0)
+  ret float %res
+}
+
+declare double @atan(double)
+define double @f_atan() {
+; CHECK-LABEL: @f_atan(
+; CHECK-NEXT:    [[RES:%.*]] = tail call fast double @atan(double 1.000000e+00)
+; CHECK-NEXT:    ret double 0x3FE921FB
+;
+  %res = tail call fast double @atan(double 1.0)
+  ret double %res
+}
+
+declare float @cosf(float)
+define float @f_cosf() {
+; CHECK-LABEL: @f_cosf(
+; CHECK-NEXT:    ret float 0x3FE14A2{{.+}}
+;
+  %res = tail call fast float @cosf(float 1.0)
+  ret float %res
+}
+
+declare float @llvm.cos.f32(float)
+define float @i_cosf() {
+; CHECK-LABEL: @i_cosf(
+; CHECK-NEXT:    ret float 0x3FE14A2
+;
+  %res = tail call fast float @llvm.cos.f32(float 1.0)
+  ret float %res
+}
+
+declare double @cosh(double)
+define double @f_cosh() {
+; CHECK-LABEL: @f_cosh(
+; CHECK-NEXT:    ret double 0x3FF8B075{{.+}}
+;
+  %res = tail call fast double @cosh(double 1.0)
+  ret double %res
+}
+
+declare float @expf(float)
+define float @f_expf() {
+; CHECK-LABEL: @f_expf(
+; CHECK-NEXT:    ret float 0x4005BF0A{{.+}}
+;
+  %res = tail call fast float @expf(float 1.0)
+  ret float %res
+}
+
+declare float @llvm.exp.f32(float)
+define float @i_expf() {
+; CHECK-LABEL: @i_expf(
+; CHECK-NEXT:    ret float 0x4005BF0A{{.+}}
+;
+  %res = tail call fast float @llvm.exp.f32(float 1.0)
+  ret float %res
+}
+
+declare double @exp2(double)
+define double @f_exp2() {
+; CHECK-LABEL: @f_exp2(
+; CHECK-NEXT:    ret double 2.000000e+00
+;
+  %res = tail call fast double @exp2(double 1.0)
+  ret double %res
+}
+
+declare double @llvm.exp2.f64(double)
+define double @i_exp2() {
+; CHECK-LABEL: @i_exp2(
+; CHECK-NEXT:    ret double 2.000000e+00
+;
+  %res = tail call fast double @llvm.exp2.f64(double 1.0)
+  ret double %res
+}
+
+; FIXME: exp10() is not widely supported.
+declare float @exp10f(float)
+define float @f_exp10f() {
+; CHECK-LABEL: @f_exp10f(
+; CHECK-NEXT:    [[RES:%.*]] = tail call float @exp10f(float 1.000000e+00)
+; CHECK-NEXT:    ret float [[RES]]
+;
+  %res = tail call float @exp10f(float 1.0)
+  ret float %res
+}
+
+declare double @log(double)
+define double @f_log() {
+; CHECK-LABEL: @f_log(
+; CHECK-NEXT:    ret double 0.000000e+00
+;
+  %res = tail call fast double @log(double 1.0)
+  ret double %res
+}
+
+declare double @llvm.log.f64(double)
+define double @i_log() {
+; CHECK-LABEL: @i_log(
+; CHECK-NEXT:    ret double 0.000000e+00
+;
+  %res = tail call fast double @llvm.log.f64(double 1.0)
+  ret double %res
+}
+
+declare float @log2f(float)
+define float @f_log2f() {
+; CHECK-LABEL: @f_log2f(
+; CHECK-NEXT:    ret float 0.000000e+00
+;
+  %res = tail call fast float @log2f(float 1.0)
+  ret float %res
+}
+
+declare float @llvm.log2.f32(float)
+define float @i_log2f() {
+; CHECK-LABEL: @i_log2f(
+; CHECK-NEXT:    ret float 0.000000e+00
+;
+  %res = tail call fast float @llvm.log2.f32(float 1.0)
+  ret float %res
+}
+
+declare double @log10(double)
+define double @f_log10() {
+; CHECK-LABEL: @f_log10(
+; CHECK-NEXT:    ret double 0.000000e+00
+;
+  %res = tail call fast double @log10(double 1.0)
+  ret double %res
+}
+
+declare float @sinf(float)
+define float @f_sinf() {
+; CHECK-LABEL: @f_sinf(
+; CHECK-NEXT:    ret float 0x3FEAED54{{.+}}
+;
+  %res = tail call fast float @sinf(float 1.0)
+  ret float %res
+}
+
+declare double @sinh(double)
+define double @f_sinh() {
+; CHECK-LABEL: @f_sinh(
+; CHECK-NEXT:    ret double 0x3FF2CD9F{{.+}}
+;
+  %res = tail call fast double @sinh(double 1.0)
+  ret double %res
+}
+
+declare float @sqrtf(float)
+define float @f_sqrtf() {
+; CHECK-LABEL: @f_sqrtf(
+; CHECK-NEXT:    ret float 1.000000e+00
+;
+  %res = tail call fast float @sqrtf(float 1.0)
+  ret float %res
+}
+
+declare double @tan(double)
+define double @f_tan() {
+; CHECK-LABEL: @f_tan(
+; CHECK-NEXT:    ret double 0x3FF8EB24{{.+}}
+;
+  %res = tail call fast double @tan(double 1.0)
+  ret double %res
+}
+
+declare float @tanhf(float)
+define float @f_tanhf() {
+; CHECK-LABEL: @f_tanhf(
+; CHECK-NEXT:    [[RES:%.*]] = tail call fast float @tanhf(float 1.000000e+00)
+; CHECK-NEXT:    ret float 0x3FE85EFA{{.+}}
+;
+  %res = tail call fast float @tanhf(float 1.0)
+  ret float %res
+}

llvm/test/Transforms/InstSimplify/ConstProp/math-2.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -early-cse -S -o - %s | FileCheck %s
 
 declare double @atan2(double, double)
 define double @f_atan2() {
 ; CHECK-LABEL: @f_atan2(
 ; CHECK-NEXT:    [[RES:%.*]] = tail call fast double @atan2(double 1.000000e+00, double 2.000000e+00)
 ; CHECK-NEXT:    ret double 0x3FDDAC6{{.+}}
 ;
   %res = tail call fast double @atan2(double 1.0, double 2.0)
   ret double %res
 }
 
 declare float @fmodf(float, float)
 define float @f_fmodf() {
 ; CHECK-LABEL: @f_fmodf(
 ; CHECK-NEXT:    ret float 1.000000e+00
 ;
   %res = tail call fast float @fmodf(float 1.0, float 2.0)
   ret float %res
 }
 
 declare float @remainderf(float, float)
 define float @f_remainderf_fold1() {
 ; CHECK-LABEL: @f_remainderf_fold1(
 ; CHECK-NEXT:    ret float 1.000000e+00
 ;
   %res = tail call fast float @remainderf(float 1.0, float 2.0)
   ret float %res
 }
 
 define float @f_remainderf_fold2() {
 ; CHECK-LABEL: @f_remainderf_fold2(
 ; CHECK-NEXT:    ret float -5.000000e-01
 ;
   %res = tail call fast float @remainderf(float 1.5, float 1.0)
   ret float %res
 }
 
 define float @f_remainderf_nofold() {
 ; CHECK-LABEL: @f_remainderf_nofold(
 ; CHECK-NEXT:    [[RES:%.*]] = tail call fast float @remainderf(float 1.000000e+00, float 0.000000e+00)
 ; CHECK-NEXT:    ret float [[RES]]
 ;
   %res = tail call fast float @remainderf(float 1.0, float 0.0)
   ret float %res
 }
 
 declare double @remainder(double, double)
 define double @f_remainder_fold1() {
 ; CHECK-LABEL: @f_remainder_fold1(
 ; CHECK-NEXT:    ret double 1.000000e+00
 ;
   %res = tail call fast double @remainder(double 1.0, double 2.0)
   ret double %res
 }
 
 define double @f_remainder_fold2() {
 ; CHECK-LABEL: @f_remainder_fold2(
 ; CHECK-NEXT:    ret double -5.000000e-01
 ;
   %res = tail call fast double @remainder(double 1.5, double 1.0)
   ret double %res
 }
 
 define double @f_remainder_nofold() {
 ; CHECK-LABEL: @f_remainder_nofold(
 ; CHECK-NEXT:    [[RES:%.*]] = tail call fast double @remainder(double 1.000000e+00, double 0.000000e+00)
 ; CHECK-NEXT:    ret double [[RES]]
 ;
   %res = tail call fast double @remainder(double 1.0, double 0.0)
   ret double %res
 }
 
 declare double @pow(double, double)
 define double @f_pow() {
 ; CHECK-LABEL: @f_pow(
 ; CHECK-NEXT:    ret double 1.000000e+00
 ;
   %res = tail call fast double @pow(double 1.0, double 2.0)
   ret double %res
 }
 
 declare float @llvm.pow.f32(float, float)
 define float @i_powf() {
 ; CHECK-LABEL: @i_powf(
 ; CHECK-NEXT:    ret float 1.000000e+00
 ;
   %res = tail call fast float @llvm.pow.f32(float 1.0, float 2.0)
   ret float %res
 }
 
 declare double @llvm.powi.f64(double, i32)
 define double @i_powi() {
 ; CHECK-LABEL: @i_powi(
 ; CHECK-NEXT:    ret double 1.000000e+00
 ;
   %res = tail call fast double @llvm.powi.f64(double 1.0, i32 2)
   ret double %res
 }

llvm/test/Transforms/InstSimplify/ConstProp/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/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/rint.ll

-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -early-cse < %s | FileCheck %s
-
-declare float @nearbyintf(float) #0
-declare float @llvm.nearbyint.f32(float) #0
-declare double @nearbyint(double) #0
-declare double @llvm.nearbyint.f64(double) #0
-declare float @rintf(float) #0
-declare float @llvm.rint.f32(float) #0
-declare double @rint(double) #0
-declare double @llvm.rint.f64(double) #0
-
-define float @constant_fold_rint_f32_01() #0 {
-; CHECK-LABEL: @constant_fold_rint_f32_01(
-; CHECK-NEXT:    ret float 1.000000e+00
-;
-  %x = call float @nearbyintf(float 1.25) #0
-  ret float %x
-}
-
-define float @constant_fold_rint_f32_02() #0 {
-; CHECK-LABEL: @constant_fold_rint_f32_02(
-; CHECK-NEXT:    ret float -1.000000e+00
-;
-  %x = call float @llvm.nearbyint.f32(float -1.25) #0
-  ret float %x
-}
-
-define float @constant_fold_rint_f32_03() #0 {
-; CHECK-LABEL: @constant_fold_rint_f32_03(
-; CHECK-NEXT:    ret float 2.000000e+00
-;
-  %x = call float @rintf(float 1.5) #0
-  ret float %x
-}
-
-define float @constant_fold_rint_f32_04() #0 {
-; CHECK-LABEL: @constant_fold_rint_f32_04(
-; CHECK-NEXT:    ret float -2.000000e+00
-;
-  %x = call float @llvm.rint.f32(float -1.5) #0
-  ret float %x
-}
-
-define float @constant_fold_rint_f32_05() #0 {
-; CHECK-LABEL: @constant_fold_rint_f32_05(
-; CHECK-NEXT:    ret float 3.000000e+00
-;
-  %x = call float @nearbyintf(float 2.75) #0
-  ret float %x
-}
-
-define float @constant_fold_rint_f32_06() #0 {
-; CHECK-LABEL: @constant_fold_rint_f32_06(
-; CHECK-NEXT:    ret float -3.000000e+00
-;
-  %x = call float @llvm.nearbyint.f32(float -2.75) #0
-  ret float %x
-}
-
-define double @constant_fold_rint_f64_01() #0 {
-; CHECK-LABEL: @constant_fold_rint_f64_01(
-; CHECK-NEXT:    ret double 1.000000e+00
-;
-  %x = call double @rint(double 1.3) #0
-  ret double %x
-}
-
-define double @constant_fold_rint_f64_02() #0 {
-; CHECK-LABEL: @constant_fold_rint_f64_02(
-; CHECK-NEXT:    ret double -1.000000e+00
-;
-  %x = call double @llvm.rint.f64(double -1.3) #0
-  ret double %x
-}
-
-define double @constant_fold_rint_f64_03() #0 {
-; CHECK-LABEL: @constant_fold_rint_f64_03(
-; CHECK-NEXT:    ret double 2.000000e+00
-;
-  %x = call double @nearbyint(double 1.5) #0
-  ret double %x
-}
-
-define double @constant_fold_rint_f64_04() #0 {
-; CHECK-LABEL: @constant_fold_rint_f64_04(
-; CHECK-NEXT:    ret double -2.000000e+00
-;
-  %x = call double @llvm.nearbyint.f64(double -1.5) #0
-  ret double %x
-}
-
-define double @constant_fold_rint_f64_05() #0 {
-; CHECK-LABEL: @constant_fold_rint_f64_05(
-; CHECK-NEXT:    ret double 3.000000e+00
-;
-  %x = call double @rint(double 2.7) #0
-  ret double %x
-}
-
-define double @constant_fold_rint_f64_06() #0 {
-; CHECK-LABEL: @constant_fold_rint_f64_06(
-; CHECK-NEXT:    ret double -3.000000e+00
-;
-  %x = call double @llvm.rint.f64(double -2.7) #0
-  ret double %x
-}
-
-attributes #0 = { nounwind readnone }
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt -S -early-cse < %s | FileCheck %s
+
+declare float @nearbyintf(float) #0
+declare float @llvm.nearbyint.f32(float) #0
+declare double @nearbyint(double) #0
+declare double @llvm.nearbyint.f64(double) #0
+declare float @rintf(float) #0
+declare float @llvm.rint.f32(float) #0
+declare double @rint(double) #0
+declare double @llvm.rint.f64(double) #0
+
+define float @constant_fold_rint_f32_01() #0 {
+; CHECK-LABEL: @constant_fold_rint_f32_01(
+; CHECK-NEXT:    ret float 1.000000e+00
+;
+  %x = call float @nearbyintf(float 1.25) #0
+  ret float %x
+}
+
+define float @constant_fold_rint_f32_02() #0 {
+; CHECK-LABEL: @constant_fold_rint_f32_02(
+; CHECK-NEXT:    ret float -1.000000e+00
+;
+  %x = call float @llvm.nearbyint.f32(float -1.25) #0
+  ret float %x
+}
+
+define float @constant_fold_rint_f32_03() #0 {
+; CHECK-LABEL: @constant_fold_rint_f32_03(
+; CHECK-NEXT:    ret float 2.000000e+00
+;
+  %x = call float @rintf(float 1.5) #0
+  ret float %x
+}
+
+define float @constant_fold_rint_f32_04() #0 {
+; CHECK-LABEL: @constant_fold_rint_f32_04(
+; CHECK-NEXT:    ret float -2.000000e+00
+;
+  %x = call float @llvm.rint.f32(float -1.5) #0
+  ret float %x
+}
+
+define float @constant_fold_rint_f32_05() #0 {
+; CHECK-LABEL: @constant_fold_rint_f32_05(
+; CHECK-NEXT:    ret float 3.000000e+00
+;
+  %x = call float @nearbyintf(float 2.75) #0
+  ret float %x
+}
+
+define float @constant_fold_rint_f32_06() #0 {
+; CHECK-LABEL: @constant_fold_rint_f32_06(
+; CHECK-NEXT:    ret float -3.000000e+00
+;
+  %x = call float @llvm.nearbyint.f32(float -2.75) #0
+  ret float %x
+}
+
+define double @constant_fold_rint_f64_01() #0 {
+; CHECK-LABEL: @constant_fold_rint_f64_01(
+; CHECK-NEXT:    ret double 1.000000e+00
+;
+  %x = call double @rint(double 1.3) #0
+  ret double %x
+}
+
+define double @constant_fold_rint_f64_02() #0 {
+; CHECK-LABEL: @constant_fold_rint_f64_02(
+; CHECK-NEXT:    ret double -1.000000e+00
+;
+  %x = call double @llvm.rint.f64(double -1.3) #0
+  ret double %x
+}
+
+define double @constant_fold_rint_f64_03() #0 {
+; CHECK-LABEL: @constant_fold_rint_f64_03(
+; CHECK-NEXT:    ret double 2.000000e+00
+;
+  %x = call double @nearbyint(double 1.5) #0
+  ret double %x
+}
+
+define double @constant_fold_rint_f64_04() #0 {
+; CHECK-LABEL: @constant_fold_rint_f64_04(
+; CHECK-NEXT:    ret double -2.000000e+00
+;
+  %x = call double @llvm.nearbyint.f64(double -1.5) #0
+  ret double %x
+}
+
+define double @constant_fold_rint_f64_05() #0 {
+; CHECK-LABEL: @constant_fold_rint_f64_05(
+; CHECK-NEXT:    ret double 3.000000e+00
+;
+  %x = call double @rint(double 2.7) #0
+  ret double %x
+}
+
+define double @constant_fold_rint_f64_06() #0 {
+; CHECK-LABEL: @constant_fold_rint_f64_06(
+; CHECK-NEXT:    ret double -3.000000e+00
+;
+  %x = call double @llvm.rint.f64(double -2.7) #0
+  ret double %x
+}
+
+attributes #0 = { nounwind readnone }

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

-; RUN: opt -S -early-cse < %s | FileCheck %s
-
-declare float @roundf(float) #0
-declare float @llvm.round.f32(float) #0
-declare double @round(double) #0
-declare double @llvm.round.f64(double) #0
-
-; CHECK-LABEL: @constant_fold_round_f32_01
-; CHECK-NEXT: ret float 1.000000e+00
-define float @constant_fold_round_f32_01() #0 {
-  %x = call float @roundf(float 1.25) #0
-  ret float %x
-}
-
-; CHECK-LABEL: @constant_fold_round_f32_02
-; CHECK-NEXT: ret float -1.000000e+00
-define float @constant_fold_round_f32_02() #0 {
-  %x = call float @llvm.round.f32(float -1.25) #0
-  ret float %x
-}
-
-; CHECK-LABEL: @constant_fold_round_f32_03
-; CHECK-NEXT: ret float 2.000000e+00
-define float @constant_fold_round_f32_03() #0 {
-  %x = call float @roundf(float 1.5) #0
-  ret float %x
-}
-
-; CHECK-LABEL: @constant_fold_round_f32_04
-; CHECK-NEXT: ret float -2.000000e+00
-define float @constant_fold_round_f32_04() #0 {
-  %x = call float @llvm.round.f32(float -1.5) #0
-  ret float %x
-}
-
-; CHECK-LABEL: @constant_fold_round_f32_05
-; CHECK-NEXT: ret float 3.000000e+00
-define float @constant_fold_round_f32_05() #0 {
-  %x = call float @roundf(float 2.75) #0
-  ret float %x
-}
-
-; CHECK-LABEL: @constant_fold_round_f32_06
-; CHECK-NEXT: ret float -3.000000e+00
-define float @constant_fold_round_f32_06() #0 {
-  %x = call float @llvm.round.f32(float -2.75) #0
-  ret float %x
-}
-
-; CHECK-LABEL: @constant_fold_round_f64_01
-; CHECK-NEXT: ret double 1.000000e+00
-define double @constant_fold_round_f64_01() #0 {
-  %x = call double @round(double 1.3) #0
-  ret double %x
-}
-
-; CHECK-LABEL: @constant_fold_round_f64_02
-; CHECK-NEXT: ret double -1.000000e+00
-define double @constant_fold_round_f64_02() #0 {
-  %x = call double @llvm.round.f64(double -1.3) #0
-  ret double %x
-}
-
-; CHECK-LABEL: @constant_fold_round_f64_03
-; CHECK-NEXT: ret double 2.000000e+00
-define double @constant_fold_round_f64_03() #0 {
-  %x = call double @round(double 1.5) #0
-  ret double %x
-}
-
-; CHECK-LABEL: @constant_fold_round_f64_04
-; CHECK-NEXT: ret double -2.000000e+00
-define double @constant_fold_round_f64_04() #0 {
-  %x = call double @llvm.round.f64(double -1.5) #0
-  ret double %x
-}
-
-; CHECK-LABEL: @constant_fold_round_f64_05
-; CHECK-NEXT: ret double 3.000000e+00
-define double @constant_fold_round_f64_05() #0 {
-  %x = call double @round(double 2.7) #0
-  ret double %x
-}
-
-; CHECK-LABEL: @constant_fold_round_f64_06
-; CHECK-NEXT: ret double -3.000000e+00
-define double @constant_fold_round_f64_06() #0 {
-  %x = call double @llvm.round.f64(double -2.7) #0
-  ret double %x
-}
-
-attributes #0 = { nounwind readnone }
+; RUN: opt -S -early-cse < %s | FileCheck %s
+
+declare float @roundf(float) #0
+declare float @llvm.round.f32(float) #0
+declare double @round(double) #0
+declare double @llvm.round.f64(double) #0
+
+; CHECK-LABEL: @constant_fold_round_f32_01
+; CHECK-NEXT: ret float 1.000000e+00
+define float @constant_fold_round_f32_01() #0 {
+  %x = call float @roundf(float 1.25) #0
+  ret float %x
+}
+
+; CHECK-LABEL: @constant_fold_round_f32_02
+; CHECK-NEXT: ret float -1.000000e+00
+define float @constant_fold_round_f32_02() #0 {
+  %x = call float @llvm.round.f32(float -1.25) #0
+  ret float %x
+}
+
+; CHECK-LABEL: @constant_fold_round_f32_03
+; CHECK-NEXT: ret float 2.000000e+00
+define float @constant_fold_round_f32_03() #0 {
+  %x = call float @roundf(float 1.5) #0
+  ret float %x
+}
+
+; CHECK-LABEL: @constant_fold_round_f32_04
+; CHECK-NEXT: ret float -2.000000e+00
+define float @constant_fold_round_f32_04() #0 {
+  %x = call float @llvm.round.f32(float -1.5) #0
+  ret float %x
+}
+
+; CHECK-LABEL: @constant_fold_round_f32_05
+; CHECK-NEXT: ret float 3.000000e+00
+define float @constant_fold_round_f32_05() #0 {
+  %x = call float @roundf(float 2.75) #0
+  ret float %x
+}
+
+; CHECK-LABEL: @constant_fold_round_f32_06
+; CHECK-NEXT: ret float -3.000000e+00
+define float @constant_fold_round_f32_06() #0 {
+  %x = call float @llvm.round.f32(float -2.75) #0
+  ret float %x
+}
+
+; CHECK-LABEL: @constant_fold_round_f64_01
+; CHECK-NEXT: ret double 1.000000e+00
+define double @constant_fold_round_f64_01() #0 {
+  %x = call double @round(double 1.3) #0
+  ret double %x
+}
+
+; CHECK-LABEL: @constant_fold_round_f64_02
+; CHECK-NEXT: ret double -1.000000e+00
+define double @constant_fold_round_f64_02() #0 {
+  %x = call double @llvm.round.f64(double -1.3) #0
+  ret double %x
+}
+
+; CHECK-LABEL: @constant_fold_round_f64_03
+; CHECK-NEXT: ret double 2.000000e+00
+define double @constant_fold_round_f64_03() #0 {
+  %x = call double @round(double 1.5) #0
+  ret double %x
+}
+
+; CHECK-LABEL: @constant_fold_round_f64_04
+; CHECK-NEXT: ret double -2.000000e+00
+define double @constant_fold_round_f64_04() #0 {
+  %x = call double @llvm.round.f64(double -1.5) #0
+  ret double %x
+}
+
+; CHECK-LABEL: @constant_fold_round_f64_05
+; CHECK-NEXT: ret double 3.000000e+00
+define double @constant_fold_round_f64_05() #0 {
+  %x = call double @round(double 2.7) #0
+  ret double %x
+}
+
+; CHECK-LABEL: @constant_fold_round_f64_06
+; CHECK-NEXT: ret double -3.000000e+00
+define double @constant_fold_round_f64_06() #0 {
+  %x = call double @llvm.round.f64(double -2.7) #0
+  ret double %x
+}
+
+attributes #0 = { nounwind readnone }

llvm/test/Transforms/InstSimplify/ConstProp/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/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/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/Transforms/InstSimplify/ConstProp/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/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/timeout.ll

-; NOTE: This is a timeout test for some O(something silly) constant folding behaviour. It may not be the best test. Providing it finishes, it passes.
-; RUN: opt < %s -O3 -S | FileCheck %s
-target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
-target triple = "armv8-none-eabi"
-
-%struct.ST = type { %struct.ST* }
-
-@global = internal global [121 x i8] zeroinitializer, align 1
-
-define void @func() #0 {
-;CHECK-LABEL: func
-entry:
-  %s = alloca %struct.ST*, align 4
-  %j = alloca i32, align 4
-  store %struct.ST* bitcast ([121 x i8]* @global to %struct.ST*), %struct.ST** %s, align 4
-  store i32 0, i32* %j, align 4
-  br label %for.cond
-
-for.cond:                                         ; preds = %for.inc, %entry
-  %0 = load i32, i32* %j, align 4
-  %cmp = icmp slt i32 %0, 30
-  br i1 %cmp, label %for.body, label %for.end
-
-for.body:                                         ; preds = %for.cond
-  %1 = load %struct.ST*, %struct.ST** %s, align 4
-  %2 = bitcast %struct.ST* %1 to i8*
-  %add.ptr = getelementptr inbounds i8, i8* %2, i32 4
-  %3 = ptrtoint i8* %add.ptr to i32
-  %4 = load %struct.ST*, %struct.ST** %s, align 4
-  %5 = bitcast %struct.ST* %4 to i8*
-  %add.ptr1 = getelementptr inbounds i8, i8* %5, i32 4
-  %6 = ptrtoint i8* %add.ptr1 to i32
-  %rem = urem i32 %6, 2
-  %cmp2 = icmp eq i32 %rem, 0
-  br i1 %cmp2, label %cond.true, label %cond.false
-
-cond.true:                                        ; preds = %for.body
-  br label %cond.end
-
-cond.false:                                       ; preds = %for.body
-  %7 = load %struct.ST*, %struct.ST** %s, align 4
-  %8 = bitcast %struct.ST* %7 to i8*
-  %add.ptr3 = getelementptr inbounds i8, i8* %8, i32 4
-  %9 = ptrtoint i8* %add.ptr3 to i32
-  %rem4 = urem i32 %9, 2
-  br label %cond.end
-
-cond.end:                                         ; preds = %cond.false, %cond.true
-  %cond = phi i32 [ 0, %cond.true ], [ %rem4, %cond.false ]
-  %add = add i32 %3, %cond
-  %10 = inttoptr i32 %add to %struct.ST*
-  %11 = load %struct.ST*, %struct.ST** %s, align 4
-  %next = getelementptr inbounds %struct.ST, %struct.ST* %11, i32 0, i32 0
-  store %struct.ST* %10, %struct.ST** %next, align 4
-  %12 = load %struct.ST*, %struct.ST** %s, align 4
-  %next5 = getelementptr inbounds %struct.ST, %struct.ST* %12, i32 0, i32 0
-  %13 = load %struct.ST*, %struct.ST** %next5, align 4
-  store %struct.ST* %13, %struct.ST** %s, align 4
-  br label %for.inc
-
-for.inc:                                          ; preds = %cond.end
-  %14 = load i32, i32* %j, align 4
-  %inc = add nsw i32 %14, 1
-  store i32 %inc, i32* %j, align 4
-  br label %for.cond
-
-for.end:                                          ; preds = %for.cond
-  %15 = load %struct.ST*, %struct.ST** %s, align 4
-  %next6 = getelementptr inbounds %struct.ST, %struct.ST* %15, i32 0, i32 0
-  store %struct.ST* null, %struct.ST** %next6, align 4
-  ret void
-}
-
+; NOTE: This is a timeout test for some O(something silly) constant folding behaviour. It may not be the best test. Providing it finishes, it passes.
+; RUN: opt < %s -O3 -S | FileCheck %s
+target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
+target triple = "armv8-none-eabi"
+
+%struct.ST = type { %struct.ST* }
+
+@global = internal global [121 x i8] zeroinitializer, align 1
+
+define void @func() #0 {
+;CHECK-LABEL: func
+entry:
+  %s = alloca %struct.ST*, align 4
+  %j = alloca i32, align 4
+  store %struct.ST* bitcast ([121 x i8]* @global to %struct.ST*), %struct.ST** %s, align 4
+  store i32 0, i32* %j, align 4
+  br label %for.cond
+
+for.cond:                                         ; preds = %for.inc, %entry
+  %0 = load i32, i32* %j, align 4
+  %cmp = icmp slt i32 %0, 30
+  br i1 %cmp, label %for.body, label %for.end
+
+for.body:                                         ; preds = %for.cond
+  %1 = load %struct.ST*, %struct.ST** %s, align 4
+  %2 = bitcast %struct.ST* %1 to i8*
+  %add.ptr = getelementptr inbounds i8, i8* %2, i32 4
+  %3 = ptrtoint i8* %add.ptr to i32
+  %4 = load %struct.ST*, %struct.ST** %s, align 4
+  %5 = bitcast %struct.ST* %4 to i8*
+  %add.ptr1 = getelementptr inbounds i8, i8* %5, i32 4
+  %6 = ptrtoint i8* %add.ptr1 to i32
+  %rem = urem i32 %6, 2
+  %cmp2 = icmp eq i32 %rem, 0
+  br i1 %cmp2, label %cond.true, label %cond.false
+
+cond.true:                                        ; preds = %for.body
+  br label %cond.end
+
+cond.false:                                       ; preds = %for.body
+  %7 = load %struct.ST*, %struct.ST** %s, align 4
+  %8 = bitcast %struct.ST* %7 to i8*
+  %add.ptr3 = getelementptr inbounds i8, i8* %8, i32 4
+  %9 = ptrtoint i8* %add.ptr3 to i32
+  %rem4 = urem i32 %9, 2
+  br label %cond.end
+
+cond.end:                                         ; preds = %cond.false, %cond.true
+  %cond = phi i32 [ 0, %cond.true ], [ %rem4, %cond.false ]
+  %add = add i32 %3, %cond
+  %10 = inttoptr i32 %add to %struct.ST*
+  %11 = load %struct.ST*, %struct.ST** %s, align 4
+  %next = getelementptr inbounds %struct.ST, %struct.ST* %11, i32 0, i32 0
+  store %struct.ST* %10, %struct.ST** %next, align 4
+  %12 = load %struct.ST*, %struct.ST** %s, align 4
+  %next5 = getelementptr inbounds %struct.ST, %struct.ST* %12, i32 0, i32 0
+  %13 = load %struct.ST*, %struct.ST** %next5, align 4
+  store %struct.ST* %13, %struct.ST** %s, align 4
+  br label %for.inc
+
+for.inc:                                          ; preds = %cond.end
+  %14 = load i32, i32* %j, align 4
+  %inc = add nsw i32 %14, 1
+  store i32 %inc, i32* %j, align 4
+  br label %for.cond
+
+for.end:                                          ; preds = %for.cond
+  %15 = load %struct.ST*, %struct.ST** %s, align 4
+  %next6 = getelementptr inbounds %struct.ST, %struct.ST* %15, i32 0, i32 0
+  store %struct.ST* null, %struct.ST** %next6, align 4
+  ret void
+}
+

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

-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -early-cse < %s | FileCheck %s
-
-declare float @truncf(float) #0
-declare float @llvm.trunc.f32(float) #0
-declare double @trunc(double) #0
-declare double @llvm.trunc.f64(double) #0
-
-define float @constant_fold_trunc_f32_01() #0 {
-; CHECK-LABEL: @constant_fold_trunc_f32_01(
-; CHECK-NEXT:    ret float 1.000000e+00
-;
-  %x = call float @truncf(float 1.25) #0
-  ret float %x
-}
-
-define float @constant_fold_trunc_f32_02() #0 {
-; CHECK-LABEL: @constant_fold_trunc_f32_02(
-; CHECK-NEXT:    ret float -1.000000e+00
-;
-  %x = call float @llvm.trunc.f32(float -1.25) #0
-  ret float %x
-}
-
-define float @constant_fold_trunc_f32_03() #0 {
-; CHECK-LABEL: @constant_fold_trunc_f32_03(
-; CHECK-NEXT:    ret float 1.000000e+00
-;
-  %x = call float @truncf(float 1.5) #0
-  ret float %x
-}
-
-define float @constant_fold_trunc_f32_04() #0 {
-; CHECK-LABEL: @constant_fold_trunc_f32_04(
-; CHECK-NEXT:    ret float -1.000000e+00
-;
-  %x = call float @llvm.trunc.f32(float -1.5) #0
-  ret float %x
-}
-
-define float @constant_fold_trunc_f32_05() #0 {
-; CHECK-LABEL: @constant_fold_trunc_f32_05(
-; CHECK-NEXT:    ret float 2.000000e+00
-;
-  %x = call float @truncf(float 2.75) #0
-  ret float %x
-}
-
-define float @constant_fold_trunc_f32_06() #0 {
-; CHECK-LABEL: @constant_fold_trunc_f32_06(
-; CHECK-NEXT:    ret float -2.000000e+00
-;
-  %x = call float @llvm.trunc.f32(float -2.75) #0
-  ret float %x
-}
-
-define double @constant_fold_trunc_f64_01() #0 {
-; CHECK-LABEL: @constant_fold_trunc_f64_01(
-; CHECK-NEXT:    ret double 1.000000e+00
-;
-  %x = call double @trunc(double 1.3) #0
-  ret double %x
-}
-
-define double @constant_fold_trunc_f64_02() #0 {
-; CHECK-LABEL: @constant_fold_trunc_f64_02(
-; CHECK-NEXT:    ret double -1.000000e+00
-;
-  %x = call double @llvm.trunc.f64(double -1.3) #0
-  ret double %x
-}
-
-define double @constant_fold_trunc_f64_03() #0 {
-; CHECK-LABEL: @constant_fold_trunc_f64_03(
-; CHECK-NEXT:    ret double 1.000000e+00
-;
-  %x = call double @trunc(double 1.5) #0
-  ret double %x
-}
-
-define double @constant_fold_trunc_f64_04() #0 {
-; CHECK-LABEL: @constant_fold_trunc_f64_04(
-; CHECK-NEXT:    ret double -1.000000e+00
-;
-  %x = call double @llvm.trunc.f64(double -1.5) #0
-  ret double %x
-}
-
-define double @constant_fold_trunc_f64_05() #0 {
-; CHECK-LABEL: @constant_fold_trunc_f64_05(
-; CHECK-NEXT:    ret double 2.000000e+00
-;
-  %x = call double @trunc(double 2.7) #0
-  ret double %x
-}
-
-define double @constant_fold_trunc_f64_06() #0 {
-; CHECK-LABEL: @constant_fold_trunc_f64_06(
-; CHECK-NEXT:    ret double -2.000000e+00
-;
-  %x = call double @llvm.trunc.f64(double -2.7) #0
-  ret double %x
-}
-
-attributes #0 = { nounwind readnone }
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt -S -early-cse < %s | FileCheck %s
+
+declare float @truncf(float) #0
+declare float @llvm.trunc.f32(float) #0
+declare double @trunc(double) #0
+declare double @llvm.trunc.f64(double) #0
+
+define float @constant_fold_trunc_f32_01() #0 {
+; CHECK-LABEL: @constant_fold_trunc_f32_01(
+; CHECK-NEXT:    ret float 1.000000e+00
+;
+  %x = call float @truncf(float 1.25) #0
+  ret float %x
+}
+
+define float @constant_fold_trunc_f32_02() #0 {
+; CHECK-LABEL: @constant_fold_trunc_f32_02(
+; CHECK-NEXT:    ret float -1.000000e+00
+;
+  %x = call float @llvm.trunc.f32(float -1.25) #0
+  ret float %x
+}
+
+define float @constant_fold_trunc_f32_03() #0 {
+; CHECK-LABEL: @constant_fold_trunc_f32_03(
+; CHECK-NEXT:    ret float 1.000000e+00
+;
+  %x = call float @truncf(float 1.5) #0
+  ret float %x
+}
+
+define float @constant_fold_trunc_f32_04() #0 {
+; CHECK-LABEL: @constant_fold_trunc_f32_04(
+; CHECK-NEXT:    ret float -1.000000e+00
+;
+  %x = call float @llvm.trunc.f32(float -1.5) #0
+  ret float %x
+}
+
+define float @constant_fold_trunc_f32_05() #0 {
+; CHECK-LABEL: @constant_fold_trunc_f32_05(
+; CHECK-NEXT:    ret float 2.000000e+00
+;
+  %x = call float @truncf(float 2.75) #0
+  ret float %x
+}
+
+define float @constant_fold_trunc_f32_06() #0 {
+; CHECK-LABEL: @constant_fold_trunc_f32_06(
+; CHECK-NEXT:    ret float -2.000000e+00
+;
+  %x = call float @llvm.trunc.f32(float -2.75) #0
+  ret float %x
+}
+
+define double @constant_fold_trunc_f64_01() #0 {
+; CHECK-LABEL: @constant_fold_trunc_f64_01(
+; CHECK-NEXT:    ret double 1.000000e+00
+;
+  %x = call double @trunc(double 1.3) #0
+  ret double %x
+}
+
+define double @constant_fold_trunc_f64_02() #0 {
+; CHECK-LABEL: @constant_fold_trunc_f64_02(
+; CHECK-NEXT:    ret double -1.000000e+00
+;
+  %x = call double @llvm.trunc.f64(double -1.3) #0
+  ret double %x
+}
+
+define double @constant_fold_trunc_f64_03() #0 {
+; CHECK-LABEL: @constant_fold_trunc_f64_03(
+; CHECK-NEXT:    ret double 1.000000e+00
+;
+  %x = call double @trunc(double 1.5) #0
+  ret double %x
+}
+
+define double @constant_fold_trunc_f64_04() #0 {
+; CHECK-LABEL: @constant_fold_trunc_f64_04(
+; CHECK-NEXT:    ret double -1.000000e+00
+;
+  %x = call double @llvm.trunc.f64(double -1.5) #0
+  ret double %x
+}
+
+define double @constant_fold_trunc_f64_05() #0 {
+; CHECK-LABEL: @constant_fold_trunc_f64_05(
+; CHECK-NEXT:    ret double 2.000000e+00
+;
+  %x = call double @trunc(double 2.7) #0
+  ret double %x
+}
+
+define double @constant_fold_trunc_f64_06() #0 {
+; CHECK-LABEL: @constant_fold_trunc_f64_06(
+; CHECK-NEXT:    ret double -2.000000e+00
+;
+  %x = call double @llvm.trunc.f64(double -2.7) #0
+  ret double %x
+}
+
+attributes #0 = { nounwind readnone }

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/InstSimplify/ConstProp/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/Transforms/InstSimplify/ConstProp/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/Transforms/InstSimplify/ConstProp/vectorgep-crash.ll

 ; RUN: opt -instcombine -S -o - %s | FileCheck %s
 ; Tests that we don't crash upon encountering a vector GEP
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 %Dual = type { %Dual.72, %Partials.73 }
 %Dual.72 = type { double, %Partials }
 %Partials = type { [2 x double] }
 %Partials.73 = type { [2 x %Dual.72] }
 
 ; Function Attrs: sspreq
 define <8 x i64*> @"julia_axpy!_65480"(%Dual* %arg1, <8 x i64> %arg2) {
 top:
 ; CHECK: %VectorGep14 = getelementptr inbounds %Dual, %Dual* %arg1, <8 x i64> %arg2, i32 1, i32 0, i64 0, i32 1, i32 0, i64 0
   %VectorGep14 = getelementptr inbounds %Dual, %Dual* %arg1, <8 x i64> %arg2, i32 1, i32 0, i64 0, i32 1, i32 0, i64 0
   %0 = bitcast <8 x double*> %VectorGep14 to <8 x i64*>
   ret <8 x i64*> %0
 }
 
 %struct.A = type { i32, %struct.B* }
 %struct.B = type { i64, %struct.C* }
 %struct.C = type { i64 }
 
 @G = internal global [65 x %struct.A] zeroinitializer, align 16
 ; CHECK-LABEL: @test
 ; CHECK: ret <16 x i32*> getelementptr ([65 x %struct.A], [65 x %struct.A]* @G, <16 x i64> zeroinitializer, <16 x i64> <i64 1, i64 2, i64 3, i64 4, i64 5, i64 6, i64 7, i64 8, i64 9, i64 10, i64 11, i64 12, i64 13, i64 14, i64 15, i64 16>, i32 0)
 define <16 x i32*> @test() {
 vector.body:
   %VectorGep = getelementptr [65 x %struct.A], [65 x %struct.A]* @G, <16 x i64> zeroinitializer, <16 x i64> <i64 1, i64 2, i64 3, i64 4, i64 5, i64 6, i64 7, i64 8, i64 9, i64 10, i64 11, i64 12, i64 13, i64 14, i64 15, i64 16>, <16 x i32> zeroinitializer
   ret <16 x i32*> %VectorGep
 }
 
 ; CHECK-LABEL: @test2
 ; CHECK: ret <16 x i32*> getelementptr ([65 x %struct.A], [65 x %struct.A]* @G, <16 x i64> zeroinitializer, <16 x i64> <i64 1, i64 2, i64 3, i64 4, i64 5, i64 6, i64 7, i64 8, i64 9, 
 define <16 x i32*> @test2() {
 vector.body:
   %VectorGep = getelementptr [65 x %struct.A], [65 x %struct.A]* @G, <16 x i32> zeroinitializer, <16 x i64> <i64 1, i64 2, i64 3, i64 4, i64 5, i64 6, i64 7, i64 8, i64 9, i64 10, i64 11, i64 12, i64 13, i64 14, i64 15, i64 16>, <16 x i32> zeroinitializer
   ret <16 x i32*> %VectorGep
 }
 
 @g = external global i8, align 1
 
 define <2 x i8*> @constant_zero_index() {
 ; CHECK-LABEL: @constant_zero_index(
 ; CHECK-NEXT:    ret <2 x i8*> <i8* @g, i8* @g>
 ;
   %gep = getelementptr i8, i8* @g, <2 x i64> zeroinitializer
   ret <2 x i8*> %gep
 }
 
 define <2 x i8*> @constant_undef_index() {
 ; CHECK-LABEL: @constant_undef_index(
 ; CHECK-NEXT:    ret <2 x i8*> <i8* @g, i8* @g>
 ;
   %gep = getelementptr i8, i8* @g, <2 x i64> undef
   ret <2 x i8*> %gep
 }
 
 define <2 x i8*> @constant_inbounds() {
 ; CHECK-LABEL: @constant_inbounds(
 ; CHECK-NEXT:    ret <2 x i8*> getelementptr inbounds (i8, i8* @g, <2 x i64> <i64 1, i64 1>)
 ;
   %gep = getelementptr i8, i8* @g, <2 x i64> <i64 1, i64 1>
   ret <2 x i8*> %gep
 }

llvm/test/Transforms/InstSimplify/ConstProp/vscale-getelementptr.ll

-; RUN: opt -early-cse -S < %s | FileCheck %s
-
-target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
-target triple = "aarch64"
-
-; CHECK-LABEL: define <4 x i32*> @fixed_length_version_first() {
-; CHECK-NEXT:  ret <4 x i32*> undef
-define <4 x i32*> @fixed_length_version_first() {
-  %ptr = getelementptr i32, <4 x i32*> undef, <4 x i64> undef
-  ret <4 x i32*> %ptr
-}
-
-; CHECK-LABEL: define <4 x <4 x i32>*> @fixed_length_version_second() {
-; CHECK-NEXT:  ret <4 x <4 x i32>*> undef
-define <4 x <4 x i32>*> @fixed_length_version_second() {
-  %ptr = getelementptr <4 x i32>, <4 x i32>* undef, <4 x i64> undef
-  ret <4 x <4 x i32>*> %ptr
-}
-
-; CHECK-LABEL: define <vscale x 4 x i32*> @vscale_version_first() {
-; CHECK-NEXT:  ret <vscale x 4 x i32*> undef
-define <vscale x 4 x i32*> @vscale_version_first() {
-  %ptr = getelementptr i32, <vscale x 4 x i32*> undef, <vscale x 4 x i64> undef
-  ret <vscale x 4 x i32*> %ptr
-}
-
-; CHECK-LABEL: define <vscale x 4 x <vscale x 4 x i32>*> @vscale_version_second() {
-; CHECK-NEXT:  ret <vscale x 4 x <vscale x 4 x i32>*> undef
-define <vscale x 4 x <vscale x 4 x i32>*> @vscale_version_second() {
-  %ptr = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* undef, <vscale x 4 x i64> undef
-  ret <vscale x 4 x <vscale x 4 x i32>*> %ptr
-}
+; RUN: opt -early-cse -S < %s | FileCheck %s
+
+target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
+target triple = "aarch64"
+
+; CHECK-LABEL: define <4 x i32*> @fixed_length_version_first() {
+; CHECK-NEXT:  ret <4 x i32*> undef
+define <4 x i32*> @fixed_length_version_first() {
+  %ptr = getelementptr i32, <4 x i32*> undef, <4 x i64> undef
+  ret <4 x i32*> %ptr
+}
+
+; CHECK-LABEL: define <4 x <4 x i32>*> @fixed_length_version_second() {
+; CHECK-NEXT:  ret <4 x <4 x i32>*> undef
+define <4 x <4 x i32>*> @fixed_length_version_second() {
+  %ptr = getelementptr <4 x i32>, <4 x i32>* undef, <4 x i64> undef
+  ret <4 x <4 x i32>*> %ptr
+}
+
+; CHECK-LABEL: define <vscale x 4 x i32*> @vscale_version_first() {
+; CHECK-NEXT:  ret <vscale x 4 x i32*> undef
+define <vscale x 4 x i32*> @vscale_version_first() {
+  %ptr = getelementptr i32, <vscale x 4 x i32*> undef, <vscale x 4 x i64> undef
+  ret <vscale x 4 x i32*> %ptr
+}
+
+; CHECK-LABEL: define <vscale x 4 x <vscale x 4 x i32>*> @vscale_version_second() {
+; CHECK-NEXT:  ret <vscale x 4 x <vscale x 4 x i32>*> undef
+define <vscale x 4 x <vscale x 4 x i32>*> @vscale_version_second() {
+  %ptr = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* undef, <vscale x 4 x i64> undef
+  ret <vscale x 4 x <vscale x 4 x i32>*> %ptr
+}

llvm/test/Transforms/InstSimplify/ConstProp/vscale-shufflevector.ll

 ; RUN: opt -early-cse -S < %s | FileCheck %s
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 target triple = "aarch64"
 
 ; This test checks that SimplifyInstruction does not blow up in the face of
 ; a scalable shufflevector. vscale is a constant value known only at runtime.
 ; Therefore, it is not possible to know the concrete value of, or the length
 ; of the mask at compile time. Simplifications that depend on the value
 ; of the mask cannot be performed.
 
 ; Given the fact that the value of the mask is unknown at compile time for
 ; scalable vectors, very few simplifications will be done. Here, we want to
 ; see that the instruction can be passed to SimplifyInstruction and not crash
 ; the compiler. It happens to be the case that this will be the result.
 
 ; CHECK-LABEL: define <vscale x 8 x i1> @vscale_version()
 ; CHECK-NEXT: ret <vscale x 8 x i1> shufflevector (<vscale x 8 x i1> insertelement (<vscale x 8 x i1> undef, i1 true, i32 0), <vscale x 8 x i1> undef, <vscale x 8 x i32> zeroinitializer)
 
 define <vscale x 8 x i1> @vscale_version() {
   %splatter = insertelement <vscale x 8 x i1> undef, i1 true, i32 0
   %foo = shufflevector <vscale x 8 x i1> %splatter,
                        <vscale x 8 x i1> undef,
                        <vscale x 8 x i32> zeroinitializer
   ret <vscale x 8 x i1> %foo
 }
 
 ; The non-scalable version should be optimized as normal.
 
 ; CHECK-LABEL: define <8 x i1> @fixed_length_version() {
 ; CHECK-NEXT:  ret <8 x i1> <i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true>
 define <8 x i1> @fixed_length_version() {
   %splatter = insertelement <8 x i1> undef, i1 true, i32 0
   %foo = shufflevector <8 x i1> %splatter,
                        <8 x i1> undef,
                        <8 x i32> zeroinitializer
   ret <8 x i1> %foo
 }
 

llvm/test/Transforms/InstSimplify/ConstProp/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

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; 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>)
+declare <vscale x 16 x i8> @llvm.something(<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:    [[R:%.*]] = call <vscale x 16 x i8> @llvm.something(<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)
+  %r =  call <vscale x 16 x i8> @llvm.something(<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

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",