InstSimplify: Simplifications for ldexp

[arsenm]

Summary

Ported from old amdgcn intrinsic which will soon be deleted.

[foad]

llvm/lib/Analysis/ConstantFolding.cpp

1578

Should keep support for the old intrinsic while it still exists.

2682

Should keep support for the old intrinsic while it still exists.

[foad]

llvm/lib/Analysis/InstructionSimplify.cpp

6128

Why is this not strictfp-safe?

[foad]

I think you can simplify ldexp(x, C) -> x * ldexp(1.0, C). Even for strictfp this should work if you use a constrained fmul and the if the new ldexp itself does not overflow or underflow.

[kpn]

llvm/lib/Analysis/InstructionSimplify.cpp

6128

It would pass through an SNaN instead of quieting it I expect.

[arsenm]

llvm/lib/Analysis/ConstantFolding.cpp

2682

There's no reason to aim for performance compatibility with something trivially replaceable. It's already dropped in D149589

llvm/lib/Analysis/InstructionSimplify.cpp

6128

Yes, needs to quiet/canonicalize which isn't guaranteed for non-constrained ops

[arsenm]

ping

[arsenm]

ping

[arsenm]

ping

[arsenm]

Rebase

[foad]

llvm/lib/Analysis/ConstantFolding.cpp

2682

This is dead code with the extra case you added above.

llvm/lib/Analysis/InstructionSimplify.cpp

6104

Why is this not strictfp-safe?

6126

Why is this not strictfp-safe?

Maybe I just need a good description of what strictfp implies. The description in the langref mentions rounding mode, status flags and trapping, but says nothing about quieting NaNs.

[arsenm]

llvm/lib/Analysis/InstructionSimplify.cpp

6104

If undef resolved to a signaling nan it wouldn't raise an exception

6126

A signaling nan is supposed to raise an exception which quieting it would hide.

The LangRef states signaling nans may not be quieted by non-constrained operations and constrained should handle them properly

[foad]

llvm/lib/Analysis/InstructionSimplify.cpp

6104

But here you are choosing what you want the undef value to be, so choose a quiet NaN.

[arsenm]

llvm/lib/Analysis/InstructionSimplify.cpp

6104

https://github.com/llvm/llvm-project/blob/67a212af4c24426de6e436e9b82590d41faa665c/llvm/lib/Analysis/InstructionSimplify.cpp#L5513

This is checking this which is a more refined check of strictfp

[arsenm]

llvm/lib/Analysis/InstructionSimplify.cpp

6104

although really I should probably just call simplifyFPOp in the first place

[foad]

llvm/lib/Analysis/InstructionSimplify.cpp

6104

https://github.com/llvm/llvm-project/blob/67a212af4c24426de6e436e9b82590d41faa665c/llvm/lib/Analysis/InstructionSimplify.cpp#L5513

Well I don't understand why that code doesn't propagate quiet NaNs unconditionally. I agree with @sepavloff's comment: https://reviews.llvm.org/D103169#inline-979968

Also, that code handles all fp ops but here we only care specifically about ldexp. Where is the spec for what fp exceptions ldexp can raise? man ldexp mentions exceptions on overflow and underflow, but does not mention raising invalid operation even on a signalling NaN input.

In any case a comment explaining why each case is supposedly not fpstrict-safe would really help, since this stuff is massively non-obvious.

[arsenm]

llvm/lib/Analysis/InstructionSimplify.cpp

6104

man ldexp says:

Range error, overflow
       errno is set to ERANGE.  An overflow floating-point exception (FE_OVERFLOW) is raised.

Range error, underflow
       errno is set to ERANGE.  An underflow floating-point exception (FE_UNDERFLOW) is raised.

6104

but does not mention raising invalid operation even on a signalling NaN input.

This is implied for every FP operation. There are just the exceptions for fabs/fneg/copysign/is.fpclass

[kpn]

llvm/lib/Analysis/InstructionSimplify.cpp

6126

With "maytrap' we are allowed to remove exceptions. That should make quieting an sNaN safe, no? Also, are callers checking for the default fp environment? That should behave the same as non-constrained operations.

[arsenm]

llvm/lib/Analysis/InstructionSimplify.cpp

6126

I just remembered this also has the problem that the constrained operations aren't fully expressive enough. "Default FP environment" doesn't cover denormal flushing or other target dependent modes.

[arsenm]

Drop dead code, add strictfp and FMF todo. I looked into merging with simplifyFPOp, but it would multiply the complexity of the patch. I also don't necessarily agree we have adequate information to fold these given denormal input exceptions exist and the denormal mode is dynamically changeable

[foad]

llvm/lib/Analysis/InstructionSimplify.cpp

6120

Also handle qNaN here?

[arsenm]

llvm/lib/Analysis/InstructionSimplify.cpp

6120

Technically would add more brokenness to old mips signaling nans although I don’t think we have a ruling on how much we should care

[kpn]

llvm/lib/Analysis/InstructionSimplify.cpp

6120

Isn't this a problem that should be solved in APFloat? Anyway, it seems like we shouldn't let old mips keep us from optimizing in the present.

[arsenm]

llvm/lib/Analysis/InstructionSimplify.cpp

6120

APFloat would need to know what to do and maybe treat it as a separate type. Maybe it should be part of DataLayout, I don’t know

[arsenm]

The point of the patch is to optimize the regular version. I handled the strictfp parts that do not require any thought. I don't want to further complicate this step for strictfp

[arsenm]

ping, this should be in the release that introduced the intrinsic

[jcranmer-intel]

llvm/lib/Analysis/InstructionSimplify.cpp

6104

I think for this block of code, just deferring to simplifyFPOp is better; the only thing that differs here is that ldexp(x, undef) needs to fold to x.

6132

Rounding mode doesn't come into play, since ldexp is always an exact operation.

[arsenm]

llvm/lib/Analysis/InstructionSimplify.cpp

6104

simplifyFPOp complicates things because that's expecting only float inputs and here there's an integer op

[arsenm]

Fix comment

llvm/lib/Analysis/InstructionSimplify.cpp

6104

I keep trying to make it use simplifyFPOp and I'm unhappy with it. It's ignoring the denorm flushing potential, uses FastMathFlags and i'm about 80% sure the precedent here for getting to the FMF is broken. I see various places using the CxtI in the SimplifyQuery, which is likely not the instruction the flags are actually attached to. It's not really less code to just handle the nan case directly while I have the APFloat

[foad]

llvm/lib/Analysis/InstructionSimplify.cpp

6104

I've read all the comments here and I still don't understand why this case is not strictfp-safe.

[arsenm]

llvm/lib/Analysis/InstructionSimplify.cpp

6104

Folding to the input operand drops a canonicalize. It would be more correct to introduce llvm.experimental.constrained.canonicalize which does not exist

[foad]

llvm/lib/Analysis/InstructionSimplify.cpp

6104

You have a free choice of what input operand value to assume, so choose one for which llvm.experimental.constrained.canonicalize would be a no-op? Isn't that already true for the value returned by getNaN? (Or is this some MIPS weirdness again where we don't know whether that NaN is quiet or not?)

[arsenm]

llvm/lib/Analysis/InstructionSimplify.cpp

6104

Maybe for the ldexp(undef, x) -> nan case (where we evidently don't have concrete rules for payload bits)

I'm talking about the ldexp(x, undef) -> x case

[arsenm]

ping, I'll drop strictfp support completely and never come back to it if it moves this along

[foad]

I still think removing support for amdgcn_ldexp should be in the patch that removes amdgcn_ldexp.

I still think every simplification guarded by !IsStrict should have a comment saying why, even if it's just "to be conservative because we're not *sure* that it's fpstrict-safe".

[foad]

llvm/lib/Analysis/InstructionSimplify.cpp

6103

I still don't understand why this one isn't strictfp-safe, if you simplify -> qnan.

[arsenm]

llvm/lib/Analysis/InstructionSimplify.cpp

6103

if undef could be anything, it could have been a signaling nan that would demand quieting

[arsenm]

llvm/lib/Analysis/InstructionSimplify.cpp

6103

Plus we evidently don't have agreement on how nan payload bits are supposed to work

[foad]

llvm/lib/Analysis/InstructionSimplify.cpp

6103

it could have been a signaling nan

That's like saying "it could have been 99.9". The point is we are *choosing* a particular value to refine it to, so why not choose a quiet nan?

Plus we evidently don't have agreement on how nan payload bits are supposed to work

OK, if we are unable to make a quiet nan because we don't know what bits to put in the payload, that seems like a good reason - but please add a comment to that effect since it is massively non-obvious. (Also if that is true then how does C->makeQuiet() below work??)

[arsenm]

llvm/lib/Analysis/InstructionSimplify.cpp

6103

Make quiet just flips the bit of an existing nan which is obviously ok (ignoring old mips). This is synthesizing a new choice

[arsenm]

Just fold the undef for strict, this is near universally broken anyway if it's decided it's broken

[arsenm]

ping

[arsenm]

ping

[arsenm]

ping

[arsenm]

ping

[arsenm]

ping

[arsenm]

ping

[arsenm]

00061843bd93b7dd9f83e1448e569e193c22ccf8

llvm/lib/Analysis/ConstantFolding.cpp

bool llvm::canConstantFoldCallTo(const CallBase *Call, const Function *F) {
   case Intrinsic::log10:
   case Intrinsic::exp:
   case Intrinsic::exp2:
   case Intrinsic::sqrt:
   case Intrinsic::sin:
   case Intrinsic::cos:
   case Intrinsic::pow:
   case Intrinsic::powi:
+  case Intrinsic::ldexp:
   case Intrinsic::fma:
   case Intrinsic::fmuladd:
   case Intrinsic::frexp:
   case Intrinsic::fptoui_sat:
   case Intrinsic::fptosi_sat:
   case Intrinsic::convert_from_fp16:
   case Intrinsic::convert_to_fp16:
   case Intrinsic::amdgcn_cos:
   case Intrinsic::amdgcn_cubeid:
   case Intrinsic::amdgcn_cubema:
   case Intrinsic::amdgcn_cubesc:
   case Intrinsic::amdgcn_cubetc:
   case Intrinsic::amdgcn_fmul_legacy:
   case Intrinsic::amdgcn_fma_legacy:
   case Intrinsic::amdgcn_fract:
   case Intrinsic::amdgcn_ldexp:
   case Intrinsic::amdgcn_sin:
   // The intrinsics below depend on rounding mode in MXCSR.
   case Intrinsic::x86_sse_cvtss2si:
   case Intrinsic::x86_sse_cvtss2si64:
   case Intrinsic::x86_sse_cvttss2si:
   case Intrinsic::x86_sse_cvttss2si64:
   case Intrinsic::x86_sse2_cvtsd2si:
   case Intrinsic::x86_sse2_cvtsd2si64:
if (const auto *Op2 = dyn_cast<ConstantFP>(Operands[1])) {
       case LibFunc_atan2_finite:
       case LibFunc_atan2f_finite:
         if (TLI->has(Func))
           return ConstantFoldBinaryFP(atan2, Op1V, Op2V, Ty);
         break;
       }
     } else if (auto *Op2C = dyn_cast<ConstantInt>(Operands[1])) {
       switch (IntrinsicID) {
+      case Intrinsic::ldexp: {
+        return ConstantFP::get(
+            Ty->getContext(),
+            scalbn(Op1V, Op2C->getSExtValue(), APFloat::rmNearestTiesToEven));
+      }
       case Intrinsic::is_fpclass: {
         FPClassTest Mask = static_cast<FPClassTest>(Op2C->getZExtValue());
         bool Result =
           ((Mask & fcSNan) && Op1V.isNaN() && Op1V.isSignaling()) ||
           ((Mask & fcQNan) && Op1V.isNaN() && !Op1V.isSignaling()) ||
           ((Mask & fcNegInf) && Op1V.isNegInfinity()) ||
           ((Mask & fcNegNormal) && Op1V.isNormal() && Op1V.isNegative()) ||
           ((Mask & fcNegSubnormal) && Op1V.isDenormal() && Op1V.isNegative()) ||
if (const auto *Op2 = dyn_cast<ConstantFP>(Operands[1])) {
             APFloat((float)std::pow((float)Op1V.convertToDouble(),
                                     (int)Op2C->getZExtValue())));
       if (IntrinsicID == Intrinsic::powi && Ty->isDoubleTy())
         return ConstantFP::get(
             Ty->getContext(),
             APFloat((double)std::pow(Op1V.convertToDouble(),
                                      (int)Op2C->getZExtValue())));
 
       if (IntrinsicID == Intrinsic::amdgcn_ldexp) {
         // FIXME: Should flush denorms depending on FP mode, but that's ignored
         // everywhere else.
 
         // scalbn is equivalent to ldexp with float radix 2
         APFloat Result = scalbn(Op1->getValueAPF(), Op2C->getSExtValue(),
                                 APFloat::rmNearestTiesToEven);
         return ConstantFP::get(Ty->getContext(), Result);
       }

llvm/lib/Analysis/InstructionSimplify.cpp

static Value *simplifyRelativeLoad(Constant *Ptr, Constant *Offset,
   if (!IsConstantOffsetFromGlobal(LoadedRHS, LoadedRHSSym, LoadedRHSOffset,
                                   DL) ||
       PtrSym != LoadedRHSSym || PtrOffset != LoadedRHSOffset)
     return nullptr;
 
   return LoadedLHSPtr;
 }
 
+// TODO: Need to pass in FastMathFlags
+static Value *simplifyLdexp(Value *Op0, Value *Op1, const SimplifyQuery &Q,
+                            bool IsStrict) {
+  // ldexp(poison, x) -> poison
+  // ldexp(x, poison) -> poison
+  if (isa<PoisonValue>(Op0) || isa<PoisonValue>(Op1))
+    return Op0;
+
+  // ldexp(undef, x) -> nan
+  if (Q.isUndefValue(Op0))
+    return ConstantFP::getNaN(Op0->getType());
+
+  if (!IsStrict) {
+    // TODO: Could insert a canonicalize for strict
+
+    // ldexp(x, undef) -> x
+    if (Q.isUndefValue(Op1))
+      return Op0;
+  }
+
+  const APFloat *C = nullptr;
+  match(Op0, PatternMatch::m_APFloat(C));
+
+  // These cases should be safe, even with strictfp.
+  // ldexp(0.0, x) -> 0.0
+  // ldexp(-0.0, x) -> -0.0
+  // ldexp(inf, x) -> inf
+  // ldexp(-inf, x) -> -inf
+  if (C && (C->isZero() || C->isInfinity()))
+    return Op0;
+
+  // These are canonicalization dropping, could do it if we knew how we could
+  // ignore denormal flushes and target handling of nan payload bits.
+  if (IsStrict)
+    return nullptr;
+
+  // TODO: Could quiet this with strictfp if the exception mode isn't strict.
+  if (C && C->isNaN())
+    return ConstantFP::get(Op0->getType(), C->makeQuiet());
+
+  // ldexp(x, 0) -> x
+
+  // TODO: Could fold this if we know the exception mode isn't
+  // strict, we know the denormal mode and other target modes.
+  if (match(Op1, PatternMatch::m_ZeroInt()))
+    return Op0;
+
+  return nullptr;
+}
+
 static Value *simplifyUnaryIntrinsic(Function *F, Value *Op0,
                                      const SimplifyQuery &Q) {
   // Idempotent functions return the same result when called repeatedly.
   Intrinsic::ID IID = F->getIntrinsicID();
   if (isIdempotent(IID))
     if (auto *II = dyn_cast<IntrinsicInst>(Op0))
       if (II->getIntrinsicID() == IID)
         return II;
if (auto *Power = dyn_cast<ConstantInt>(Op1)) {
       // powi(x, 0) -> 1.0
       if (Power->isZero())
         return ConstantFP::get(Op0->getType(), 1.0);
       // powi(x, 1) -> x
       if (Power->isOne())
         return Op0;
     }
     break;
+  case Intrinsic::ldexp:
+    return simplifyLdexp(Op0, Op1, Q, false);
   case Intrinsic::copysign:
     // copysign X, X --> X
     if (Op0 == Op1)
       return Op0;
     // copysign -X, X --> X
     // copysign X, -X --> -X
     if (match(Op0, m_FNeg(m_Specific(Op1))) ||
         match(Op1, m_FNeg(m_Specific(Op0))))
return simplifyFDivInst(Args[0], Args[1], FPI->getFastMathFlags(), Q,
                             *FPI->getRoundingMode());
   }
   case Intrinsic::experimental_constrained_frem: {
     auto *FPI = cast<ConstrainedFPIntrinsic>(Call);
     return simplifyFRemInst(Args[0], Args[1], FPI->getFastMathFlags(), Q,
                             *FPI->getExceptionBehavior(),
                             *FPI->getRoundingMode());
   }
+  case Intrinsic::experimental_constrained_ldexp:
+    return simplifyLdexp(Args[0], Args[1], Q, true);
   default:
     return nullptr;
   }
 }
 
 static Value *tryConstantFoldCall(CallBase *Call, Value *Callee,
                                   ArrayRef<Value *> Args,
                                   const SimplifyQuery &Q) {

llvm/test/Transforms/InstCombine/ldexp.ll

;
   %ldexp0 = call reassoc float @llvm.ldexp.f32.i32(float %x, i32 8)
   %ldexp1 = call reassoc float @llvm.ldexp.f32.i32(float %ldexp0, i32 24)
   ret float %ldexp1
 }
 
 define float @ldexp_ldexp_opposite_constants(float %x) {
 ; CHECK-LABEL: define float @ldexp_ldexp_opposite_constants
 ; CHECK-SAME: (float [[X:%.*]]) {
-; CHECK-NEXT:    [[LDEXP1:%.*]] = call reassoc float @llvm.ldexp.f32.i32(float [[X]], i32 0)
-; CHECK-NEXT:    ret float [[LDEXP1]]
+; CHECK-NEXT:    ret float [[X]]
 ;
   %ldexp0 = call reassoc float @llvm.ldexp.f32.i32(float %x, i32 8)
   %ldexp1 = call reassoc float @llvm.ldexp.f32.i32(float %ldexp0, i32 -8)
   ret float %ldexp1
 }
 
 define float @ldexp_ldexp_negated_variable_reassoc(float %x, i32 %a) {
 ; CHECK-LABEL: define float @ldexp_ldexp_negated_variable_reassoc
 ; CHECK-SAME: (float [[X:%.*]], i32 [[A:%.*]]) {
-; CHECK-NEXT:    [[LDEXP1:%.*]] = call reassoc float @llvm.ldexp.f32.i32(float [[X]], i32 0)
-; CHECK-NEXT:    ret float [[LDEXP1]]
+; CHECK-NEXT:    ret float [[X]]
 ;
   %ldexp0 = call reassoc float @llvm.ldexp.f32.i32(float %x, i32 %a)
   %neg.a = sub i32 0, %a
   %ldexp1 = call reassoc float @llvm.ldexp.f32.i32(float %ldexp0, i32 %neg.a)
   ret float %ldexp1
 }
 
 define float @ldexp_ldexp_negated_variable(float %x, i32 %a) {
;
   %ldexp0 = call reassoc float @llvm.ldexp.f32.i32(float %x, i32 0)
   %ldexp1 = call reassoc float @llvm.ldexp.f32.i32(float %ldexp0, i32 %y)
   ret float %ldexp1
 }
 
 define float @ldexp_ldexp_0(float %x, i32 %y) {
 ; CHECK-LABEL: define float @ldexp_ldexp_0
 ; CHECK-SAME: (float [[X:%.*]], i32 [[Y:%.*]]) {
-; CHECK-NEXT:    [[LDEXP0:%.*]] = call float @llvm.ldexp.f32.i32(float [[X]], i32 0)
-; CHECK-NEXT:    [[LDEXP1:%.*]] = call float @llvm.ldexp.f32.i32(float [[LDEXP0]], i32 [[Y]])
+; CHECK-NEXT:    [[LDEXP1:%.*]] = call float @llvm.ldexp.f32.i32(float [[X]], i32 [[Y]])
 ; CHECK-NEXT:    ret float [[LDEXP1]]
 ;
   %ldexp0 = call float @llvm.ldexp.f32.i32(float %x, i32 0)
   %ldexp1 = call float @llvm.ldexp.f32.i32(float %ldexp0, i32 %y)
   ret float %ldexp1
 }
 
 !0 = !{i32 -127, i32 0}
 !1 = !{i32 0, i32 127}

llvm/test/Transforms/InstSimplify/ldexp.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt -S -passes=instsimplify < %s | FileCheck %s
+
+define float @ldexp_f32_undef_undef() {
+; CHECK-LABEL: @ldexp_f32_undef_undef(
+; CHECK-NEXT:    ret float 0x7FF8000000000000
+;
+  %call = call float @llvm.ldexp.f32.i32(float undef, i32 undef)
+  ret float %call
+}
+
+define float @ldexp_f32_poison_undef() {
+; CHECK-LABEL: @ldexp_f32_poison_undef(
+; CHECK-NEXT:    ret float poison
+;
+  %call = call float @llvm.ldexp.f32.i32(float poison, i32 undef)
+  ret float %call
+}
+
+define float @ldexp_f32_undef_poison() {
+; CHECK-LABEL: @ldexp_f32_undef_poison(
+; CHECK-NEXT:    ret float undef
+;
+  %call = call float @llvm.ldexp.f32.i32(float undef, i32 poison)
+  ret float %call
+}
+
+define float @ldexp_f32_poison_poison() {
+; CHECK-LABEL: @ldexp_f32_poison_poison(
+; CHECK-NEXT:    ret float poison
+;
+  %call = call float @llvm.ldexp.f32.i32(float poison, i32 poison)
+  ret float %call
+}
+
+; If the exponent is 0, it doesn't matter if the first argument is
+; constant or not.
+define void @ldexp_f32_exp0(float %x) {
+; CHECK-LABEL: @ldexp_f32_exp0(
+; CHECK-NEXT:    store volatile float [[X:%.*]], ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float [[X]], ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    [[ONE:%.*]] = call float @llvm.ldexp.f32.i32(float [[X]], i32 1)
+; CHECK-NEXT:    store volatile float [[ONE]], ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    ret void
+;
+  %zero = call float @llvm.ldexp.f32.i32(float %x, i32 0)
+  store volatile float %zero, ptr addrspace(1) undef
+
+  %undef = call float @llvm.ldexp.f32.i32(float %x, i32 undef)
+  store volatile float %undef, ptr addrspace(1) undef
+
+  %one = call float @llvm.ldexp.f32.i32(float %x, i32 1)
+  store volatile float %one, ptr addrspace(1) undef
+  ret void
+}
+
+define void @ldexp_v2f32_exp0(<2 x float> %x) {
+; CHECK-LABEL: @ldexp_v2f32_exp0(
+; CHECK-NEXT:    store volatile <2 x float> [[X:%.*]], ptr addrspace(1) undef, align 8
+; CHECK-NEXT:    store volatile <2 x float> [[X]], ptr addrspace(1) undef, align 8
+; CHECK-NEXT:    store volatile <2 x float> [[X]], ptr addrspace(1) undef, align 8
+; CHECK-NEXT:    ret void
+;
+  %part.undef0 = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> %x, <2 x i32> <i32 0, i32 undef>)
+  store volatile <2 x float> %part.undef0, ptr addrspace(1) undef
+
+  %part.undef1 = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> %x, <2 x i32> <i32 undef, i32 0>)
+  store volatile <2 x float> %part.undef1, ptr addrspace(1) undef
+
+  %zero = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> %x, <2 x i32> zeroinitializer)
+  store volatile <2 x float> %zero, ptr addrspace(1) undef
+  ret void
+}
+
+; Test variable exponent but zero or undef value.
+define void @ldexp_f32_val0(i32 %y) {
+; CHECK-LABEL: @ldexp_f32_val0(
+; CHECK-NEXT:    store volatile float 0.000000e+00, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float -0.000000e+00, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0x7FF8000000000000, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    ret void
+;
+  %zero = call float @llvm.ldexp.f32.i32(float 0.0, i32 %y)
+  store volatile float %zero, ptr addrspace(1) undef
+
+  %neg.zero = call float @llvm.ldexp.f32.i32(float -0.0, i32 %y)
+  store volatile float %neg.zero, ptr addrspace(1) undef
+
+  %undef = call float @llvm.ldexp.f32.i32(float undef, i32 %y)
+  store volatile float %undef, ptr addrspace(1) undef
+  ret void
+}
+
+define void @ldexp_f32_val_infinity(i32 %y) {
+; CHECK-LABEL: @ldexp_f32_val_infinity(
+; CHECK-NEXT:    store volatile float 0x7FF0000000000000, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0xFFF0000000000000, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0x7FF0000000000000, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0xFFF0000000000000, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    ret void
+;
+  %inf = call float @llvm.ldexp.f32.i32(float 0x7ff0000000000000, i32 %y)
+  store volatile float %inf, ptr addrspace(1) undef
+
+  %neg.inf = call float @llvm.ldexp.f32.i32(float 0xfff0000000000000, i32 %y)
+  store volatile float %neg.inf, ptr addrspace(1) undef
+
+  %inf.zero = call float @llvm.ldexp.f32.i32(float 0x7ff0000000000000, i32 0)
+  store volatile float %inf.zero, ptr addrspace(1) undef
+
+  %neg.inf.zero = call float @llvm.ldexp.f32.i32(float 0xfff0000000000000, i32 0)
+  store volatile float %neg.inf.zero, ptr addrspace(1) undef
+
+  ret void
+}
+
+; Signaling nan should be quieted.
+; Technically this depends on the ieee_mode in the mode register.
+define void @ldexp_f32_val_nan(i32 %y) {
+; CHECK-LABEL: @ldexp_f32_val_nan(
+; CHECK-NEXT:    store volatile float 0x7FF8001000000000, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0xFFF8000100000000, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0x7FF8000020000000, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0xFFFFFFFFE0000000, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    ret void
+;
+  %plus.qnan = call float @llvm.ldexp.f32.i32(float 0x7ff0001000000000, i32 %y)
+  store volatile float %plus.qnan, ptr addrspace(1) undef
+
+  %neg.qnan = call float @llvm.ldexp.f32.i32(float 0xfff0000100000000, i32 %y)
+  store volatile float %neg.qnan, ptr addrspace(1) undef
+
+  %plus.snan = call float @llvm.ldexp.f32.i32(float 0x7FF0000020000000, i32 %y)
+  store volatile float %plus.snan, ptr addrspace(1) undef
+
+  %neg.snan = call float @llvm.ldexp.f32.i32(float 0xFFF7FFFFE0000000, i32 %y)
+  store volatile float %neg.snan, ptr addrspace(1) undef
+
+  ret void
+}
+
+define void @ldexp_f32_val_nan_strictfp_maytrap(i32 %y) #0 {
+; CHECK-LABEL: @ldexp_f32_val_nan_strictfp_maytrap(
+; CHECK-NEXT:    [[PLUS_QNAN:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7FF0001000000000, i32 [[Y:%.*]], metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0:[0-9]+]]
+; CHECK-NEXT:    store volatile float [[PLUS_QNAN]], ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    [[NEG_QNAN:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0xFFF0000100000000, i32 [[Y]], metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    store volatile float [[NEG_QNAN]], ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    [[PLUS_SNAN:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7FF0000020000000, i32 [[Y]], metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    store volatile float [[PLUS_SNAN]], ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    [[NEG_SNAN:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0xFFF7FFFFE0000000, i32 [[Y]], metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    store volatile float [[NEG_SNAN]], ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0x7FF8000000000000, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    ret void
+;
+  %plus.qnan = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7ff0001000000000, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  store volatile float %plus.qnan, ptr addrspace(1) undef
+
+  %neg.qnan = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0xfff0000100000000, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  store volatile float %neg.qnan, ptr addrspace(1) undef
+
+  %plus.snan = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7FF0000020000000, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  store volatile float %plus.snan, ptr addrspace(1) undef
+
+  %neg.snan = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0xFFF7FFFFE0000000, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  store volatile float %neg.snan, ptr addrspace(1) undef
+
+  %undef = call float @llvm.experimental.constrained.ldexp.f32.i32(float undef, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  store volatile float %undef, ptr addrspace(1) undef
+
+  ret void
+}
+
+
+define void @ldexp_f32_val_nan_strictfp_strict(i32 %y) #0 {
+; CHECK-LABEL: @ldexp_f32_val_nan_strictfp_strict(
+; CHECK-NEXT:    [[PLUS_QNAN:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7FF0001000000000, i32 [[Y:%.*]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    store volatile float [[PLUS_QNAN]], ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    [[NEG_QNAN:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0xFFF0000100000000, i32 [[Y]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    store volatile float [[NEG_QNAN]], ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    [[PLUS_SNAN:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7FF0000020000000, i32 [[Y]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    store volatile float [[PLUS_SNAN]], ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    [[NEG_SNAN:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0xFFF7FFFFE0000000, i32 [[Y]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    store volatile float [[NEG_SNAN]], ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    [[UNDEF:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float undef, i32 [[Y]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR0]]
+; CHECK-NEXT:    store volatile float 0x7FF8000000000000, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    ret void
+;
+  %plus.qnan = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7ff0001000000000, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  store volatile float %plus.qnan, ptr addrspace(1) undef
+
+  %neg.qnan = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0xfff0000100000000, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  store volatile float %neg.qnan, ptr addrspace(1) undef
+
+  %plus.snan = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7FF0000020000000, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  store volatile float %plus.snan, ptr addrspace(1) undef
+
+  %neg.snan = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0xFFF7FFFFE0000000, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  store volatile float %neg.snan, ptr addrspace(1) undef
+
+  %undef = call float @llvm.experimental.constrained.ldexp.f32.i32(float undef, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.strict") #0
+  store volatile float %undef, ptr addrspace(1) undef
+
+  ret void
+}
+
+define void @ldexp_f32_0() {
+; CHECK-LABEL: @ldexp_f32_0(
+; CHECK-NEXT:    store volatile float 0.000000e+00, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float -0.000000e+00, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0.000000e+00, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0.000000e+00, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0.000000e+00, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0.000000e+00, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0.000000e+00, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    ret void
+;
+  %zero = call float @llvm.ldexp.f32.i32(float 0.0, i32 0)
+  store volatile float %zero, ptr addrspace(1) undef
+
+  %neg.zero = call float @llvm.ldexp.f32.i32(float -0.0, i32 0)
+  store volatile float %neg.zero, ptr addrspace(1) undef
+
+  %one = call float @llvm.ldexp.f32.i32(float 0.0, i32 1)
+  store volatile float %one, ptr addrspace(1) undef
+
+  %min.exp = call float @llvm.ldexp.f32.i32(float 0.0, i32 -126)
+  store volatile float %min.exp, ptr addrspace(1) undef
+
+  %min.exp.sub1 = call float @llvm.ldexp.f32.i32(float 0.0, i32 -127)
+  store volatile float %min.exp.sub1, ptr addrspace(1) undef
+
+  %max.exp = call float @llvm.ldexp.f32.i32(float 0.0, i32 127)
+  store volatile float %max.exp, ptr addrspace(1) undef
+
+  %max.exp.plus1 = call float @llvm.ldexp.f32.i32(float 0.0, i32 128)
+  store volatile float %max.exp.plus1, ptr addrspace(1) undef
+
+  ret void
+}
+
+define void @ldexp_f32_undef_strictfp(float %x, i32 %y) #0 {
+; CHECK-LABEL: @ldexp_f32_undef_strictfp(
+; CHECK-NEXT:    [[UNDEF_EXP:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float [[X:%.*]], i32 undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    store volatile float [[UNDEF_EXP]], ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float [[X]], ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0x7FF8000000000000, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float poison, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float poison, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float undef, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    ret void
+;
+  %undef.exp = call float @llvm.experimental.constrained.ldexp.f32.i32(float %x, i32 undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  store volatile float %undef.exp, ptr addrspace(1) undef
+  %poison.exp = call float @llvm.experimental.constrained.ldexp.f32.i32(float %x, i32 poison, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  store volatile float %poison.exp, ptr addrspace(1) undef
+  %undef.val = call float @llvm.experimental.constrained.ldexp.f32.i32(float undef, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  store volatile float %undef.val, ptr addrspace(1) undef
+  %poison.val = call float @llvm.experimental.constrained.ldexp.f32.i32(float poison, i32 %y, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  store volatile float %poison.val, ptr addrspace(1) undef
+  %poison.undef = call float @llvm.experimental.constrained.ldexp.f32.i32(float poison, i32 undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  store volatile float %poison.undef, ptr addrspace(1) undef
+  %undef.poison = call float @llvm.experimental.constrained.ldexp.f32.i32(float undef, i32 poison, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  store volatile float %undef.poison, ptr addrspace(1) undef
+  ret void
+}
+
+; Should be able to ignore strictfp in this case
+define void @ldexp_f32_0_strictfp(float %x) #0 {
+; CHECK-LABEL: @ldexp_f32_0_strictfp(
+; CHECK-NEXT:    store volatile float 0.000000e+00, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float -0.000000e+00, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0.000000e+00, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    [[UNKNOWN_ZERO:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float [[X:%.*]], i32 0, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    store volatile float [[UNKNOWN_ZERO]], ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    [[UNKNOWN_UNDEF:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float [[X]], i32 undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    store volatile float [[UNKNOWN_UNDEF]], ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    [[DENORMAL_0:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x380FFFFFC0000000, i32 0, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    store volatile float [[DENORMAL_0]], ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    [[DENORMAL_1:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x380FFFFFC0000000, i32 1, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    store volatile float [[DENORMAL_1]], ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    ret void
+;
+  %zero = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0.0, i32 0, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  store volatile float %zero, ptr addrspace(1) undef
+
+  %neg.zero = call float @llvm.experimental.constrained.ldexp.f32.i32(float -0.0, i32 0, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  store volatile float %neg.zero, ptr addrspace(1) undef
+
+  %one = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0.0, i32 1, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  store volatile float %one, ptr addrspace(1) undef
+
+  %unknown.zero = call float @llvm.experimental.constrained.ldexp.f32.i32(float %x, i32 0, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  store volatile float %unknown.zero, ptr addrspace(1) undef
+
+  %unknown.undef = call float @llvm.experimental.constrained.ldexp.f32.i32(float %x, i32 undef, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  store volatile float %unknown.undef, ptr addrspace(1) undef
+
+  %denormal.0 = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x380FFFFFC0000000, i32 0, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  store volatile float %denormal.0, ptr addrspace(1) undef
+
+  %denormal.1 = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x380FFFFFC0000000, i32 1, metadata !"round.dynamic", metadata !"fpexcept.maytrap") #0
+  store volatile float %denormal.1, ptr addrspace(1) undef
+
+  ret void
+}
+
+define void @ldexp_f32() {
+; CHECK-LABEL: @ldexp_f32(
+; CHECK-NEXT:    store volatile float 2.000000e+00, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 4.000000e+00, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 8.000000e+00, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 5.000000e-01, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0x3810000000000000, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0x3800000000000000, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0x47E0000000000000, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0x7FF0000000000000, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float -2.000000e+00, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float -4.000000e+00, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float -8.000000e+00, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float -5.000000e-01, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0xB810000000000000, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0xB800000000000000, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0xC7E0000000000000, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0xFFF0000000000000, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0x44D5000000000000, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    ret void
+;
+  %one.one = call float @llvm.ldexp.f32.i32(float 1.0, i32 1)
+  store volatile float %one.one, ptr addrspace(1) undef
+
+  %one.two = call float @llvm.ldexp.f32.i32(float 1.0, i32 2)
+  store volatile float %one.two, ptr addrspace(1) undef
+
+  %one.three = call float @llvm.ldexp.f32.i32(float 1.0, i32 3)
+  store volatile float %one.three, ptr addrspace(1) undef
+
+  %one.negone = call float @llvm.ldexp.f32.i32(float 1.0, i32 -1)
+  store volatile float %one.negone, ptr addrspace(1) undef
+
+  %one.min.exp = call float @llvm.ldexp.f32.i32(float 1.0, i32 -126)
+  store volatile float %one.min.exp, ptr addrspace(1) undef
+
+  %one.min.exp.sub1 = call float @llvm.ldexp.f32.i32(float 1.0, i32 -127)
+  store volatile float %one.min.exp.sub1, ptr addrspace(1) undef
+
+  %one.max.exp = call float @llvm.ldexp.f32.i32(float 1.0, i32 127)
+  store volatile float %one.max.exp, ptr addrspace(1) undef
+
+  %one.max.exp.plus1 = call float @llvm.ldexp.f32.i32(float 1.0, i32 128)
+  store volatile float %one.max.exp.plus1, ptr addrspace(1) undef
+
+  %neg.one.one = call float @llvm.ldexp.f32.i32(float -1.0, i32 1)
+  store volatile float %neg.one.one, ptr addrspace(1) undef
+
+  %neg.one.two = call float @llvm.ldexp.f32.i32(float -1.0, i32 2)
+  store volatile float %neg.one.two, ptr addrspace(1) undef
+
+  %neg.one.three = call float @llvm.ldexp.f32.i32(float -1.0, i32 3)
+  store volatile float %neg.one.three, ptr addrspace(1) undef
+
+  %neg.one.negone = call float @llvm.ldexp.f32.i32(float -1.0, i32 -1)
+  store volatile float %neg.one.negone, ptr addrspace(1) undef
+
+  %neg.one.min.exp = call float @llvm.ldexp.f32.i32(float -1.0, i32 -126)
+  store volatile float %neg.one.min.exp, ptr addrspace(1) undef
+
+  %neg.one.min.exp.sub1 = call float @llvm.ldexp.f32.i32(float -1.0, i32 -127)
+  store volatile float %neg.one.min.exp.sub1, ptr addrspace(1) undef
+
+  %neg.one.max.exp = call float @llvm.ldexp.f32.i32(float -1.0, i32 127)
+  store volatile float %neg.one.max.exp, ptr addrspace(1) undef
+
+  %neg.one.max.exp.plus1 = call float @llvm.ldexp.f32.i32(float -1.0, i32 128)
+  store volatile float %neg.one.max.exp.plus1, ptr addrspace(1) undef
+
+  %fortytwo.seven = call float @llvm.ldexp.f32.i32(float 42.0, i32 73)
+  store volatile float %fortytwo.seven, ptr addrspace(1) undef
+
+  ret void
+}
+
+; Technically we should probably flush these depending on the expected
+; denormal mode of the function, but no other IR constant folding
+; considers this.
+define void @ldexp_f32_denormal() {
+; CHECK-LABEL: @ldexp_f32_denormal(
+; CHECK-NEXT:    store volatile float 0x380FFFFFC0000000, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    store volatile float 0x381FFFFFC0000000, ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    ret void
+;
+  %denormal.0 = call float @llvm.ldexp.f32.i32(float 0x380FFFFFC0000000, i32 0)
+  store volatile float %denormal.0, ptr addrspace(1) undef
+
+  %denormal.1 = call float @llvm.ldexp.f32.i32(float 0x380FFFFFC0000000, i32 1)
+  store volatile float %denormal.1, ptr addrspace(1) undef
+
+  ret void
+}
+
+define void @ldexp_f64() {
+; CHECK-LABEL: @ldexp_f64(
+; CHECK-NEXT:    store volatile double 2.000000e+00, ptr addrspace(1) undef, align 8
+; CHECK-NEXT:    store volatile double 4.000000e+00, ptr addrspace(1) undef, align 8
+; CHECK-NEXT:    store volatile double 0x44D5000000000000, ptr addrspace(1) undef, align 8
+; CHECK-NEXT:    ret void
+;
+  %one.one = call double @llvm.ldexp.f64.i32(double 1.0, i32 1)
+  store volatile double %one.one, ptr addrspace(1) undef
+
+  %one.two = call double @llvm.ldexp.f64.i32(double 1.0, i32 2)
+  store volatile double %one.two, ptr addrspace(1) undef
+
+  %fortytwo.seven = call double @llvm.ldexp.f64.i32(double 42.0, i32 73)
+  store volatile double %fortytwo.seven, ptr addrspace(1) undef
+
+  ret void
+}
+
+define void @ldexp_f16() {
+; CHECK-LABEL: @ldexp_f16(
+; CHECK-NEXT:    store volatile half 0xH4000, ptr addrspace(1) undef, align 2
+; CHECK-NEXT:    store volatile half 0xH4400, ptr addrspace(1) undef, align 2
+; CHECK-NEXT:    store volatile half 0xH7C00, ptr addrspace(1) undef, align 2
+; CHECK-NEXT:    ret void
+;
+  %one.one = call half @llvm.ldexp.f16.i32(half 1.0, i32 1)
+  store volatile half %one.one, ptr addrspace(1) undef
+
+  %one.two = call half @llvm.ldexp.f16.i32(half 1.0, i32 2)
+  store volatile half %one.two, ptr addrspace(1) undef
+
+  %fortytwo.seven = call half @llvm.ldexp.f16.i32(half 42.0, i32 73)
+  store volatile half %fortytwo.seven, ptr addrspace(1) undef
+
+  ret void
+}
+
+define void @ldexp_ppcf128() {
+; CHECK-LABEL: @ldexp_ppcf128(
+; CHECK-NEXT:    store volatile ppc_fp128 0xMFFF00000000000000000000000000000, ptr addrspace(1) undef, align 16
+; CHECK-NEXT:    store volatile ppc_fp128 0xMFFFC0000000000000000000000000000, ptr addrspace(1) undef, align 16
+; CHECK-NEXT:    store volatile ppc_fp128 0xM3FD00000000000000000000000000000, ptr addrspace(1) undef, align 16
+; CHECK-NEXT:    store volatile ppc_fp128 0xM41700000000000000000000000000000, ptr addrspace(1) undef, align 16
+; CHECK-NEXT:    store volatile ppc_fp128 0xMC0700000000000000000000000000000, ptr addrspace(1) undef, align 16
+; CHECK-NEXT:    ret void
+;
+  %neginf = call ppc_fp128 @llvm.ldexp.ppcf128.i32(ppc_fp128 0xMFFF00000000000000000000000000000, i32 0)
+  store volatile ppc_fp128 %neginf, ptr addrspace(1) undef
+
+  %snan = call ppc_fp128 @llvm.ldexp.ppcf128.i32(ppc_fp128 0xMFFFC0000000000000000000000000000, i32 0)
+  store volatile ppc_fp128 %snan, ptr addrspace(1) undef
+
+  %one.neg2 = call ppc_fp128 @llvm.ldexp.ppcf128.i32(ppc_fp128 0xM3FF00000000000000000000000000000, i32 -2)
+  store volatile ppc_fp128 %one.neg2, ptr addrspace(1) undef
+
+  %one.24 = call ppc_fp128 @llvm.ldexp.ppcf128.i32(ppc_fp128 0xM3FF00000000000000000000000000000, i32 24)
+  store volatile ppc_fp128 %one.24, ptr addrspace(1) undef
+
+  %negone.8 = call ppc_fp128 @llvm.ldexp.ppcf128.i32(ppc_fp128 0xMBFF00000000000000000000000000000, i32 8)
+  store volatile ppc_fp128 %negone.8, ptr addrspace(1) undef
+
+  ret void
+}
+
+define void @constant_fold_ldexp_f32_val_strictfp(i32 %y) #0 {
+; CHECK-LABEL: @constant_fold_ldexp_f32_val_strictfp(
+; CHECK-NEXT:    [[SNAN_MAY_TRAP:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7FF0000020000000, i32 3, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #[[ATTR0]]
+; CHECK-NEXT:    store volatile float [[SNAN_MAY_TRAP]], ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    [[SNAN_MAY_NOT_TRAP:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7FF0000020000000, i32 3, metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    store volatile float [[SNAN_MAY_NOT_TRAP]], ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    [[UNKNOWN_ROUNDING:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 2.500000e+00, i32 42, metadata !"round.dynamic", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    store volatile float [[UNKNOWN_ROUNDING]], ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    [[NORMAL:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 2.500000e+00, i32 42, metadata !"round.tonearest", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    store volatile float [[NORMAL]], ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    [[NORMAL_DOWN:%.*]] = call float @llvm.experimental.constrained.ldexp.f32.i32(float 2.500000e+00, i32 42, metadata !"round.downward", metadata !"fpexcept.ignore") #[[ATTR0]]
+; CHECK-NEXT:    store volatile float [[NORMAL_DOWN]], ptr addrspace(1) undef, align 4
+; CHECK-NEXT:    ret void
+;
+  %snan.may.trap = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7FF0000020000000, i32 3, metadata !"round.tonearest", metadata !"fpexcept.maytrap") #0
+  store volatile float %snan.may.trap, ptr addrspace(1) undef
+
+  %snan.may.not.trap = call float @llvm.experimental.constrained.ldexp.f32.i32(float 0x7FF0000020000000, i32 3, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  store volatile float %snan.may.not.trap, ptr addrspace(1) undef
+
+  %unknown.rounding = call float @llvm.experimental.constrained.ldexp.f32.i32(float 2.5, i32 42, metadata !"round.dynamic", metadata !"fpexcept.ignore") #0
+  store volatile float %unknown.rounding, ptr addrspace(1) undef
+
+  %normal = call float @llvm.experimental.constrained.ldexp.f32.i32(float 2.5, i32 42, metadata !"round.tonearest", metadata !"fpexcept.ignore") #0
+  store volatile float %normal, ptr addrspace(1) undef
+
+  %normal.down = call float @llvm.experimental.constrained.ldexp.f32.i32(float 2.5, i32 42, metadata !"round.downward", metadata !"fpexcept.ignore") #0
+  store volatile float %normal.down, ptr addrspace(1) undef
+
+  ret void
+}
+
+declare half @llvm.ldexp.f16.i32(half, i32) #1
+declare float @llvm.ldexp.f32.i32(float, i32) #1
+declare double @llvm.ldexp.f64.i32(double, i32) #1
+declare <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float>, <2 x i32>) #1
+declare float @llvm.experimental.constrained.ldexp.f32.i32(float, i32, metadata, metadata) #1
+declare ppc_fp128 @llvm.ldexp.ppcf128.i32(ppc_fp128, i32) #1
+
+attributes #0 = { strictfp }
+attributes #1 = { nounwind readnone speculatable }