[X86] Custom lowering of llvm.is_fpclass for x86_fp80

[sepavloff]

This patch was tested using runtime tests from https://reviews.llvm.org/D112933 and a patch for clang https://reviews.llvm.org/D112932.

[pengfei]

llvm/lib/Target/X86/X86ISelLowering.cpp

722

Add f32/f64 too?

22889

Why only f80?

22944

Can we define it with a new name? This give an impression the check conditions can be permuted. But the code seems don't support it.

22947

ditto.

22951

Define it in FPSWFlag ?

22990

It's equal to assert at line 22751 and better there with message.

23030

This only works for fp80. We should check the type first.
Can we check exception #IA for f32 and f64?

llvm/test/CodeGen/X86/x86-is_fpclass-fp80.ll

9 ↗

(On Diff #385523)

Where's fucomp generated from? I didn't see it in the code.

21 ↗

(On Diff #385523)

Why fucompi?

[sepavloff]

Address reviewer's notes.

[sepavloff]

llvm/lib/Target/X86/X86ISelLowering.cpp

722

There is concern that FXAM can be slow (https://reviews.llvm.org/D104853#2839746). So it is used only for f80, where x87 anyway is used. For other types a default lowering is used, which use usual float operations or integer arithmetic to make the tests. The resulted code for x86 is presented in D112025 in the test.

22889

You are right, this check is not needed. Removed.

22944

Actually the checks can be permuted. I reformatted the comments, hopefully they make this code clearer.

22951

I would like but I cannot invent a good name for it. Added comment to describe why this constant is used.

22990

The assert only checked that for each CCToCompare there is corresponding ExpectedCC. There are not many cases here, it seems that this check is safe to remove.

23030

Fixed.

llvm/test/CodeGen/X86/x86-is_fpclass-fp80.ll

9 ↗

(On Diff #385523)

It appears as a result of the call DAG.getSetCC(DL, ResultVT, Arg, Arg, ISD::CondCode::SETUNE), which is called at the beginning of lowerIS_FPCLASS if exceptions are ignored.

21 ↗

(On Diff #385523)

It is also the result of getSetCC. This code must be generated for unordered comparison.

[pengfei]

llvm/lib/Target/X86/X86ISelLowering.cpp

722

Given that and we still need to distinguish sNaN with qNaN. Why don't we use integer arithmetic for f80 too? We just need to check the high 32 bits for all classes expect fcZero and fcInf.

22886

This should also help for nan combined with other flags.

22894–22907

Can we assert the type only be f80?

22944

But the switch doesn't enumerate all possibilities, e.g., ISD::fcZero | ISD::fcInf. I don't think silently break for these cases are correct.

23030

I don't understand. If we only customize for f80. Why do we always add code for f32 and f64?

[sepavloff]

Remove support of f32 and f64

[sepavloff]

llvm/lib/Target/X86/X86ISelLowering.cpp

722

There is no i80, so doing integer arithmetic on f80 is complicated. Existing default lowering simply crashes on f80. Also for many classes, like fcZero, fcSubnormal, fcInf or fcSNan we need to analyze all three words of f80. One instruction FXAM does all the job, and seems faster even if its latency is high.

22886

It looks faster to execute FXAM and then analyze its result in integer pipeline than doing checks in x87 registers and move the results to integer registers for analysis.

22894–22907

Done just at the start of the function.

22944

This switch only processes some combinations that are simple to implement. For all other combinations the general case is applied.

This patch was tested using runtime tests from D112933. They contains all combinations of two basic tests and many other combinations.

23030

There was some hesitation whether using FXAM could be used for types other than f80 in some cases. Now support of these types is removed.

[pengfei]

llvm/lib/Target/X86/X86ISelLowering.cpp

722

I mean we still customize f80 here, but enrich the code for checking S/QNAN to more classes by loading bits [79:48] rather than [63:32]. We can easily check whether the remainding 48 bits are zero for fcZero and fcInf.
Not only for performance, but also we should lower it when f80 is used without x87 enabled. Although it's rare of such case, it's supported by compiler.

[sepavloff]

llvm/lib/Target/X86/X86ISelLowering.cpp

722

but also we should lower it when f80 is used without x87 enabled. Although it's rare of such case, it's supported by compiler.

How can this mode be activated? If I provide option -mno-x87, compiler fails in TargetLoweringBase::getRegClassFor in:

assert(RC && "This value type is not natively supported!");

[pengfei]

llvm/lib/Target/X86/X86ISelLowering.cpp

722

Yeah, Clang may still have some problem to handle such cases, but GCC does support it. https://godbolt.org/z/aza81fKx4
We shouldn't make it worse :)

[sepavloff]

llvm/lib/Target/X86/X86ISelLowering.cpp

722

As I understand, it is what -msoft-float should do but it doesn't in clang. Things are already bad :)

If FP operations in this case are implemented by library functions, it must be easier, more efficient and reliable to implement a special function for this intrinsic, rather than emulate the FP operations in the compiler.

[sepavloff]

Updated patch because its dependency changed.

[sepavloff]

llvm/lib/Target/X86/X86ISelLowering.cpp

722

Adding a new library function is not an option, because we cannot add it to libgcc. The base patch (D112025) changed to support fp80 as well. Functions with suffix "soft" in the test file is_fpclass-fp80.ll demonstrate lowering for this case when x87 unit is not available.

llvm/lib/Target/X86/MCTargetDesc/X86BaseInfo.h

 //===-- X86BaseInfo.h - Top level definitions for X86 -------- --*- C++ -*-===//
 //
 // 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 contains small standalone helper functions and enum definitions for
enum CondCode {
     // which can't be represented on x86 with a single condition. These
     // are never used in MachineInstrs and are inverses of one another.
     COND_NE_OR_P,
     COND_E_AND_NP,
 
     COND_INVALID
   };
 
+  /// Bits of x87 FPU Status Register.
+  enum FPSWFlag {
+    // Condition code.
+    C0   = 0x0100,
+    C1   = 0x0200,
+    C2   = 0x0400,
+    C3   = 0x4000,
+
+    // Bits set by FXAM.
+    AllCondCodeBits = C0 | C1 | C2 | C3,
+    AllClassBits    = C0 | C2 | C3,
+    ClassNaN        = C0,
+    ClassInf        = C0 | C2,
+    ClassNormal     = C2,
+    ClassZero       = C3,
+    ClassSubnormal  = C2 | C3,
+    Negative        = C1
+  };
+
   // The classification for the first instruction in macro fusion.
   enum class FirstMacroFusionInstKind {
     // TEST
     Test,
     // CMP
     Cmp,
     // AND
     And,

llvm/lib/Target/X86/X86ISelLowering.h

private:
     SDValue LowerWin64_FP_TO_INT128(SDValue Op, SelectionDAG &DAG,
                                     SDValue &Chain) const;
     SDValue LowerWin64_INT128_TO_FP(SDValue Op, SelectionDAG &DAG) const;
     SDValue LowerGC_TRANSITION(SDValue Op, SelectionDAG &DAG) const;
     SDValue LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG) const;
     SDValue lowerFaddFsub(SDValue Op, SelectionDAG &DAG) const;
     SDValue LowerFP_EXTEND(SDValue Op, SelectionDAG &DAG) const;
     SDValue LowerFP_ROUND(SDValue Op, SelectionDAG &DAG) const;
+    SDValue lowerIS_FPCLASS(SDValue Op, SelectionDAG &DAG) const;
 
     SDValue
     LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
                          const SmallVectorImpl<ISD::InputArg> &Ins,
                          const SDLoc &dl, SelectionDAG &DAG,
                          SmallVectorImpl<SDValue> &InVals) const override;
     SDValue LowerCall(CallLoweringInfo &CLI,
                       SmallVectorImpl<SDValue> &InVals) const override;

llvm/lib/Target/X86/X86ISelLowering.cpp

 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Analysis/BlockFrequencyInfo.h"
 #include "llvm/Analysis/EHPersonalities.h"
 #include "llvm/Analysis/ObjCARCUtil.h"
 #include "llvm/Analysis/ProfileSummaryInfo.h"
 #include "llvm/Analysis/VectorUtils.h"
+#include "llvm/CodeGen/CodeGenCommonISel.h"
 #include "llvm/CodeGen/IntrinsicLowering.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineJumpTableInfo.h"
 #include "llvm/CodeGen/MachineLoopInfo.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
if (UseX87) {
     setOperationAction(ISD::FTRUNC, MVT::f80, Expand);
     setOperationAction(ISD::FRINT,  MVT::f80, Expand);
     setOperationAction(ISD::FNEARBYINT, MVT::f80, Expand);
     setOperationAction(ISD::FMA, MVT::f80, Expand);
     setOperationAction(ISD::LROUND, MVT::f80, Expand);
     setOperationAction(ISD::LLROUND, MVT::f80, Expand);
     setOperationAction(ISD::LRINT, MVT::f80, Custom);
     setOperationAction(ISD::LLRINT, MVT::f80, Custom);
 
     // Handle constrained floating-point operations of scalar.
     setOperationAction(ISD::STRICT_FADD     , MVT::f80, Legal);
     setOperationAction(ISD::STRICT_FSUB     , MVT::f80, Legal);
     setOperationAction(ISD::STRICT_FMUL     , MVT::f80, Legal);
     setOperationAction(ISD::STRICT_FDIV     , MVT::f80, Legal);
     setOperationAction(ISD::STRICT_FSQRT    , MVT::f80, Legal);
     setOperationAction(ISD::STRICT_FP_EXTEND, MVT::f80, Legal);
     // FIXME: When the target is 64-bit, STRICT_FP_ROUND will be overwritten
     // as Custom.
     setOperationAction(ISD::STRICT_FP_ROUND, MVT::f80, Legal);
+
+    if (!Subtarget.useSoftFloat())
+      setOperationAction(ISD::IS_FPCLASS, MVT::f80, Custom);
   }
 
   // f128 uses xmm registers, but most operations require libcalls.
   if (!Subtarget.useSoftFloat() && Subtarget.is64Bit() && Subtarget.hasSSE1()) {
     addRegisterClass(MVT::f128, Subtarget.hasVLX() ? &X86::VR128XRegClass
                                                    : &X86::VR128RegClass);
 
     addLegalFPImmediate(APFloat::getZero(APFloat::IEEEquad())); // xorps
static SDValue LowerFGETSIGN(SDValue Op, SelectionDAG &DAG) {
   MVT VecVT = (OpVT == MVT::f32 ? MVT::v4f32 : MVT::v2f64);
   SDValue Res = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT, N0);
   Res = DAG.getNode(X86ISD::MOVMSK, dl, MVT::i32, Res);
   Res = DAG.getZExtOrTrunc(Res, dl, VT);
   Res = DAG.getNode(ISD::AND, dl, VT, Res, DAG.getConstant(1, dl, VT));
   return Res;
 }
 
+SDValue X86TargetLowering::lowerIS_FPCLASS(SDValue Op,
+                                           SelectionDAG &DAG) const {
+  SDLoc DL(Op);
+  MVT ResultVT = Op.getSimpleValueType();
+  SDValue Arg = Op.getOperand(0);
+  MVT ArgVT = Arg.getSimpleValueType();
+  assert(ArgVT == MVT::f80);
+  auto CNode = cast<ConstantSDNode>(Op.getOperand(1));
+  unsigned Check = CNode->getZExtValue();
+
+  // Degenerated cases.
+  if (Check == 0 || (Check & fcAllFlags) == fcAllFlags)
+    return DAG.getBoolConstant(true, DL, ResultVT, ArgVT);
+
+  // Some checks can be implemented using float comparisons, if floating point
+  // exceptions are ignored.
+  if (Op->getFlags().hasNoFPExcept()) {
+    if (Check == fcZero)
+      return DAG.getSetCC(DL, ResultVT, Arg, DAG.getConstantFP(0.0, DL, ArgVT),
+                          ISD::SETOEQ);
+    // Unordered comparison treats unsupported values as NaNs, which is
+    // compatible with glibc.
+    if (Check == fcNan)
+      return DAG.getSetCC(DL, ResultVT, Arg, Arg, ISD::SETUO);
+  }
+
+  // Determine classification of the argument using instruction FXAM.
+  SDValue Test(DAG.getMachineNode(X86::XAM_Fp80, DL, MVT::Glue, Arg), 0);
+
+  // Move FPSW to AX.
+  SDValue FPSW =
+      SDValue(DAG.getMachineNode(X86::FNSTSW16r, DL, MVT::i16, Test), 0);
+
+  // Mask irrelevant bits in FPSW.
+  SDValue ClassCCWithoutSign =
+      DAG.getNode(ISD::AND, DL, MVT::i16, FPSW,
+                  DAG.getConstant(X86::AllClassBits, DL, MVT::i16));
+  FPSW = DAG.getNode(ISD::AND, DL, MVT::i16, FPSW,
+                     DAG.getConstant(X86::AllCondCodeBits, DL, MVT::i16));
+
+  // Process the simple cases, when only one compare is required for
+  // classification.
+  SDValue CCToCompare;
+  switch (Check) {
+  default:
+    break;
+  case fcZero:
+  case fcSubnormal:
+  case fcNormal:
+  case fcInf:
+  case fcNan:
+    CCToCompare = ClassCCWithoutSign;
+    break;
+  // Some practically important tests can be implemented by checking part of
+  // condition code bits.
+  case fcInf | fcNan:        // isnan       == (C3==0, C2==0, C0==1)
+                             // isinf       == (C3==0, C2==1, C0==1)
+  case fcZero | fcSubnormal: // iszero      == (C3==1, C2==0, C0==0)
+                             // issubnormal == (C3==1, C2==1, C0==0)
+    // C2 can be ignored for these checks.
+    CCToCompare = DAG.getNode(ISD::AND, DL, MVT::i16, FPSW,
+                              DAG.getConstant(X86::C3 | X86::C0, DL, MVT::i16));
+    break;
+  }
+  unsigned ExpectedCC = 0;
+  switch (Check) {
+  default:
+    break;
+  case fcInf | fcNan:
+    // For this test the bit C2 is cleared, so check for NaN will check for Inf
+    // also.
+    ExpectedCC = X86::ClassNaN;
+    break;
+  case fcZero:
+  case fcZero | fcSubnormal:
+    ExpectedCC = X86::ClassZero;
+    break;
+  case fcSubnormal:
+    ExpectedCC = X86::ClassSubnormal;
+    break;
+  case fcNormal:
+    ExpectedCC = X86::ClassNormal;
+    break;
+  case fcInf:
+    ExpectedCC = X86::ClassInf;
+    break;
+  case fcNan:
+    // For compatibility with glibc treat unsupported formats as NaN.
+    return DAG.getSetCC(DL, ResultVT, ClassCCWithoutSign,
+                        DAG.getConstant(X86::ClassNaN, DL, MVT::i16),
+                        ISD::SETLE);
+  }
+  if (ExpectedCC)
+    return DAG.getSetCC(DL, ResultVT, CCToCompare,
+                        DAG.getConstant(ExpectedCC, DL, MVT::i16), ISD::SETEQ);
+
+  // The general case is implemented as series of checks.
+  SDValue Res;
+  unsigned PartialCheck;
+
+  PartialCheck = Check & fcNan;
+  if (PartialCheck) {
+    Res =
+        DAG.getSetCC(DL, ResultVT, ClassCCWithoutSign,
+                     DAG.getConstant(X86::ClassNaN, DL, MVT::i16), ISD::SETEQ);
+    if (PartialCheck == fcSNan || PartialCheck == fcQNan) {
+      // FXAM does not provide information whether a NaN value is signaling, so
+      // to distinguish between signaling and quiet NaNs we need to analyze
+      // mantissa.
+
+      // Store FP value to stack.
+      SDValue Chain = DAG.getEntryNode();
+      MachineFunction &MF = DAG.getMachineFunction();
+      Align StackAlign = Subtarget.getFrameLowering()->getStackAlign();
+      unsigned SSFISize = alignTo(ArgVT.getStoreSize(), StackAlign);
+      int SSFI =
+          MF.getFrameInfo().CreateStackObject(SSFISize, StackAlign, false);
+      auto PtrVT = getPointerTy(MF.getDataLayout());
+      SDValue StackSlot = DAG.getFrameIndex(SSFI, PtrVT);
+      MachineMemOperand *StoreMMO = MF.getMachineMemOperand(
+          MachinePointerInfo::getFixedStack(DAG.getMachineFunction(), SSFI),
+          MachineMemOperand::MOStore, SSFISize, StackAlign);
+
+      Chain = DAG.getStore(Chain, DL, Arg, StackSlot, StoreMMO);
+
+      // Load the high half of the mantissa.
+      SDValue OffsetSlot = StackSlot;
+      if (ArgVT != MVT::f32)
+        OffsetSlot =
+            DAG.getMemBasePlusOffset(StackSlot, TypeSize::Fixed(4), DL);
+      SDValue AsInt = DAG.getLoad(
+          MVT::i32, DL, Chain, OffsetSlot,
+          MachinePointerInfo::getFixedStack(MF, SSFI).getWithOffset(4));
+
+      // Check the quiet NaN bit.
+      APInt QNaNBitMask(32, 0x40000000);
+      SDValue QNaNBitMaskV = DAG.getConstant(QNaNBitMask, DL, MVT::i32);
+      SDValue QNaNBitV =
+          DAG.getNode(ISD::AND, DL, MVT::i32, AsInt, QNaNBitMaskV);
+      ISD::CondCode CC = (PartialCheck == fcSNan) ? ISD::CondCode::SETEQ
+                                                  : ISD::CondCode::SETNE;
+      SDValue QNaNBitTest = DAG.getSetCC(DL, ResultVT, QNaNBitV,
+                                         DAG.getConstant(0, DL, MVT::i32), CC);
+      Res = DAG.getNode(ISD::AND, DL, ResultVT, Res, QNaNBitTest);
+    }
+  }
+
+  PartialCheck = Check & fcInf;
+  if (PartialCheck) {
+    SDValue PartialRes;
+    if (PartialCheck == fcPosInf) {
+      PartialRes = DAG.getSetCC(DL, ResultVT, FPSW,
+                                DAG.getConstant(X86::ClassInf, DL, MVT::i16),
+                                ISD::SETEQ);
+    } else if (PartialCheck == fcNegInf) {
+      PartialRes = DAG.getSetCC(
+          DL, ResultVT, FPSW,
+          DAG.getConstant(X86::ClassInf | X86::Negative, DL, MVT::i16),
+          ISD::SETEQ);
+    } else {
+      PartialRes = DAG.getSetCC(DL, ResultVT, ClassCCWithoutSign,
+                                DAG.getConstant(X86::ClassInf, DL, MVT::i16),
+                                ISD::SETEQ);
+    }
+    if (Res)
+      Res = DAG.getNode(ISD::OR, DL, ResultVT, Res, PartialRes);
+    else
+      Res = PartialRes;
+  }
+
+  PartialCheck = Check & fcNormal;
+  if (PartialCheck) {
+    SDValue PartialRes;
+    if (PartialCheck == fcPosNormal) {
+      PartialRes = DAG.getSetCC(DL, ResultVT, FPSW,
+                                DAG.getConstant(X86::ClassNormal, DL, MVT::i16),
+                                ISD::SETEQ);
+    } else if (PartialCheck == fcNegNormal) {
+      PartialRes = DAG.getSetCC(
+          DL, ResultVT, FPSW,
+          DAG.getConstant(X86::ClassNormal | X86::Negative, DL, MVT::i16),
+          ISD::SETEQ);
+    } else {
+      PartialRes = DAG.getSetCC(DL, ResultVT, ClassCCWithoutSign,
+                                DAG.getConstant(X86::ClassNormal, DL, MVT::i16),
+                                ISD::SETEQ);
+    }
+    if (Res)
+      Res = DAG.getNode(ISD::OR, DL, ResultVT, Res, PartialRes);
+    else
+      Res = PartialRes;
+  }
+
+  PartialCheck = Check & fcSubnormal;
+  if (PartialCheck) {
+    SDValue PartialRes;
+    if (PartialCheck == fcPosSubnormal) {
+      PartialRes = DAG.getSetCC(
+          DL, ResultVT, FPSW,
+          DAG.getConstant(X86::ClassSubnormal, DL, MVT::i16), ISD::SETEQ);
+    } else if (PartialCheck == fcNegSubnormal) {
+      PartialRes = DAG.getSetCC(
+          DL, ResultVT, FPSW,
+          DAG.getConstant(X86::ClassSubnormal | X86::Negative, DL, MVT::i16),
+          ISD::SETEQ);
+    } else {
+      PartialRes = DAG.getSetCC(
+          DL, ResultVT, ClassCCWithoutSign,
+          DAG.getConstant(X86::ClassSubnormal, DL, MVT::i16), ISD::SETEQ);
+    }
+    if (Res)
+      Res = DAG.getNode(ISD::OR, DL, ResultVT, Res, PartialRes);
+    else
+      Res = PartialRes;
+  }
+
+  PartialCheck = Check & fcZero;
+  if (PartialCheck) {
+    SDValue PartialRes;
+    if (PartialCheck == fcPosZero) {
+      PartialRes = DAG.getSetCC(DL, ResultVT, FPSW,
+                                DAG.getConstant(X86::ClassZero, DL, MVT::i16),
+                                ISD::SETEQ);
+    } else if (PartialCheck == fcNegZero) {
+      PartialRes = DAG.getSetCC(
+          DL, ResultVT, FPSW,
+          DAG.getConstant(X86::ClassZero | X86::Negative, DL, MVT::i16),
+          ISD::SETEQ);
+    } else {
+      PartialRes = DAG.getSetCC(DL, ResultVT, ClassCCWithoutSign,
+                                DAG.getConstant(X86::ClassZero, DL, MVT::i16),
+                                ISD::SETEQ);
+    }
+    if (Res)
+      Res = DAG.getNode(ISD::OR, DL, ResultVT, Res, PartialRes);
+    else
+      Res = PartialRes;
+  }
+
+  return Res;
+}
+
 /// Helper for creating a X86ISD::SETCC node.
 static SDValue getSETCC(X86::CondCode Cond, SDValue EFLAGS, const SDLoc &dl,
                         SelectionDAG &DAG) {
   return DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
                      DAG.getTargetConstant(Cond, dl, MVT::i8), EFLAGS);
 }
 
 /// Helper for matching OR(EXTRACTELT(X,0),OR(EXTRACTELT(X,1),...))
SDValue X86TargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
   case ISD::STORE:              return LowerStore(Op, Subtarget, DAG);
   case ISD::FADD:
   case ISD::FSUB:               return lowerFaddFsub(Op, DAG);
   case ISD::FROUND:             return LowerFROUND(Op, DAG);
   case ISD::FABS:
   case ISD::FNEG:               return LowerFABSorFNEG(Op, DAG);
   case ISD::FCOPYSIGN:          return LowerFCOPYSIGN(Op, DAG);
   case ISD::FGETSIGN:           return LowerFGETSIGN(Op, DAG);
+  case ISD::IS_FPCLASS:         return lowerIS_FPCLASS(Op, DAG);
   case ISD::LRINT:
   case ISD::LLRINT:             return LowerLRINT_LLRINT(Op, DAG);
   case ISD::SETCC:
   case ISD::STRICT_FSETCC:
   case ISD::STRICT_FSETCCS:     return LowerSETCC(Op, DAG);
   case ISD::SETCCCARRY:         return LowerSETCCCARRY(Op, DAG);
   case ISD::SELECT:             return LowerSELECT(Op, DAG);
   case ISD::BRCOND:             return LowerBRCOND(Op, DAG);

llvm/test/CodeGen/X86/is_fpclass-fp80.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc < %s -mtriple=i686-linux | FileCheck %s -check-prefix=CHECK-32
 ; RUN: llc < %s -mtriple=x86_64-linux | FileCheck %s -check-prefix=CHECK-64
 
-define i1 @is_nan_f80(x86_fp80 %x) {
+define i1 @is_nan_f80(x86_fp80 %x) #0 {
 ; CHECK-32-LABEL: is_nan_f80:
 ; CHECK-32:       # %bb.0: # %entry
 ; CHECK-32-NEXT:    fldt {{[0-9]+}}(%esp)
 ; CHECK-32-NEXT:    fucomp %st(0)
 ; CHECK-32-NEXT:    fnstsw %ax
 ; CHECK-32-NEXT:    # kill: def $ah killed $ah killed $ax
 ; CHECK-32-NEXT:    sahf
 ; CHECK-32-NEXT:    setp %al
 ; CHECK-32-NEXT:    retl
 ;
 ; CHECK-64-LABEL: is_nan_f80:
 ; CHECK-64:       # %bb.0: # %entry
 ; CHECK-64-NEXT:    fldt {{[0-9]+}}(%rsp)
 ; CHECK-64-NEXT:    fucompi %st(0), %st
 ; CHECK-64-NEXT:    setp %al
 ; CHECK-64-NEXT:    retq
 entry:
   %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 3)  ; "nan"
   ret i1 %0
 }
 
-define i1 @is_nan_f80_strict(x86_fp80 %x) strictfp {
-; CHECK-32-LABEL: is_nan_f80_strict:
+define i1 @is_nan_f80_soft(x86_fp80 %x) #1 {
+; CHECK-32-LABEL: is_nan_f80_soft:
 ; CHECK-32:       # %bb.0: # %entry
 ; CHECK-32-NEXT:    pushl %esi
-; CHECK-32-NEXT:    .cfi_def_cfa_offset 8
-; CHECK-32-NEXT:    .cfi_offset %esi, -8
 ; CHECK-32-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; CHECK-32-NEXT:    movzwl {{[0-9]+}}(%esp), %ecx
 ; CHECK-32-NEXT:    andl $32767, %ecx # imm = 0x7FFF
 ; CHECK-32-NEXT:    xorl %edx, %edx
 ; CHECK-32-NEXT:    cmpl {{[0-9]+}}(%esp), %edx
 ; CHECK-32-NEXT:    movl $-2147483648, %esi # imm = 0x80000000
 ; CHECK-32-NEXT:    sbbl %eax, %esi
 ; CHECK-32-NEXT:    movl $32767, %esi # imm = 0x7FFF
 ; CHECK-32-NEXT:    sbbl %ecx, %esi
 ; CHECK-32-NEXT:    sbbl %edx, %edx
 ; CHECK-32-NEXT:    setl %dl
 ; CHECK-32-NEXT:    testl %ecx, %ecx
 ; CHECK-32-NEXT:    sete %cl
 ; CHECK-32-NEXT:    shrl $31, %eax
 ; CHECK-32-NEXT:    xorb %cl, %al
 ; CHECK-32-NEXT:    xorb $1, %al
 ; CHECK-32-NEXT:    orb %dl, %al
 ; CHECK-32-NEXT:    # kill: def $al killed $al killed $eax
 ; CHECK-32-NEXT:    popl %esi
-; CHECK-32-NEXT:    .cfi_def_cfa_offset 4
 ; CHECK-32-NEXT:    retl
 ;
-; CHECK-64-LABEL: is_nan_f80_strict:
+; CHECK-64-LABEL: is_nan_f80_soft:
 ; CHECK-64:       # %bb.0: # %entry
 ; CHECK-64-NEXT:    movzwl {{[0-9]+}}(%rsp), %eax
 ; CHECK-64-NEXT:    movq {{[0-9]+}}(%rsp), %rcx
 ; CHECK-64-NEXT:    andl $32767, %eax # imm = 0x7FFF
 ; CHECK-64-NEXT:    movabsq $-9223372036854775808, %rdx # imm = 0x8000000000000000
 ; CHECK-64-NEXT:    cmpq %rcx, %rdx
 ; CHECK-64-NEXT:    movl $32767, %edx # imm = 0x7FFF
 ; CHECK-64-NEXT:    sbbq %rax, %rdx
 ; CHECK-64-NEXT:    setl %dl
 ; CHECK-64-NEXT:    shrq $63, %rcx
 ; CHECK-64-NEXT:    testq %rax, %rax
 ; CHECK-64-NEXT:    sete %al
 ; CHECK-64-NEXT:    xorb %cl, %al
 ; CHECK-64-NEXT:    xorb $1, %al
 ; CHECK-64-NEXT:    orb %dl, %al
 ; CHECK-64-NEXT:    retq
 entry:
   %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 3)  ; "nan"
   ret i1 %0
 }
 
-define i1 @is_snan_f80(x86_fp80 %x) {
+define i1 @is_nan_f80_strict(x86_fp80 %x) #2 {
+; CHECK-32-LABEL: is_nan_f80_strict:
+; CHECK-32:       # %bb.0: # %entry
+; CHECK-32-NEXT:    fldt {{[0-9]+}}(%esp)
+; CHECK-32-NEXT:    fxam
+; CHECK-32-NEXT:    fnstsw %ax
+; CHECK-32-NEXT:    fstp %st(0)
+; CHECK-32-NEXT:    wait
+; CHECK-32-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-32-NEXT:    andl $17664, %eax # imm = 0x4500
+; CHECK-32-NEXT:    cmpl $256, %eax # imm = 0x100
+; CHECK-32-NEXT:    setle %al
+; CHECK-32-NEXT:    retl
+;
+; CHECK-64-LABEL: is_nan_f80_strict:
+; CHECK-64:       # %bb.0: # %entry
+; CHECK-64-NEXT:    fldt {{[0-9]+}}(%rsp)
+; CHECK-64-NEXT:    fxam
+; CHECK-64-NEXT:    fnstsw %ax
+; CHECK-64-NEXT:    fstp %st(0)
+; CHECK-64-NEXT:    wait
+; CHECK-64-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-64-NEXT:    andl $17664, %eax # imm = 0x4500
+; CHECK-64-NEXT:    cmpl $256, %eax # imm = 0x100
+; CHECK-64-NEXT:    setle %al
+; CHECK-64-NEXT:    retq
+entry:
+  %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 3)  ; "nan"
+  ret i1 %0
+}
+
+define i1 @is_snan_f80(x86_fp80 %x) #0 {
 ; CHECK-32-LABEL: is_snan_f80:
 ; CHECK-32:       # %bb.0: # %entry
+; CHECK-32-NEXT:    subl $28, %esp
+; CHECK-32-NEXT:    fldt {{[0-9]+}}(%esp)
+; CHECK-32-NEXT:    fld %st(0)
+; CHECK-32-NEXT:    fstpt (%esp)
+; CHECK-32-NEXT:    fxam
+; CHECK-32-NEXT:    fnstsw %ax
+; CHECK-32-NEXT:    fstp %st(0)
+; CHECK-32-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-32-NEXT:    andl $17664, %eax # imm = 0x4500
+; CHECK-32-NEXT:    cmpl $256, %eax # imm = 0x100
+; CHECK-32-NEXT:    sete %cl
+; CHECK-32-NEXT:    testl $1073741824, {{[0-9]+}}(%esp) # imm = 0x40000000
+; CHECK-32-NEXT:    sete %al
+; CHECK-32-NEXT:    andb %cl, %al
+; CHECK-32-NEXT:    addl $28, %esp
+; CHECK-32-NEXT:    retl
+;
+; CHECK-64-LABEL: is_snan_f80:
+; CHECK-64:       # %bb.0: # %entry
+; CHECK-64-NEXT:    fldt {{[0-9]+}}(%rsp)
+; CHECK-64-NEXT:    fld %st(0)
+; CHECK-64-NEXT:    fstpt -{{[0-9]+}}(%rsp)
+; CHECK-64-NEXT:    fxam
+; CHECK-64-NEXT:    fnstsw %ax
+; CHECK-64-NEXT:    fstp %st(0)
+; CHECK-64-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-64-NEXT:    andl $17664, %eax # imm = 0x4500
+; CHECK-64-NEXT:    cmpl $256, %eax # imm = 0x100
+; CHECK-64-NEXT:    sete %cl
+; CHECK-64-NEXT:    testl $1073741824, -{{[0-9]+}}(%rsp) # imm = 0x40000000
+; CHECK-64-NEXT:    sete %al
+; CHECK-64-NEXT:    andb %cl, %al
+; CHECK-64-NEXT:    retq
+entry:
+  %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 1)  ; "snan"
+  ret i1 %0
+}
+
+define i1 @is_snan_f80_soft(x86_fp80 %x) #1 {
+; CHECK-32-LABEL: is_snan_f80_soft:
+; CHECK-32:       # %bb.0: # %entry
 ; CHECK-32-NEXT:    pushl %ebx
-; CHECK-32-NEXT:    .cfi_def_cfa_offset 8
 ; CHECK-32-NEXT:    pushl %esi
-; CHECK-32-NEXT:    .cfi_def_cfa_offset 12
-; CHECK-32-NEXT:    .cfi_offset %esi, -12
-; CHECK-32-NEXT:    .cfi_offset %ebx, -8
 ; CHECK-32-NEXT:    movl {{[0-9]+}}(%esp), %edx
 ; CHECK-32-NEXT:    movzwl {{[0-9]+}}(%esp), %eax
 ; CHECK-32-NEXT:    andl $32767, %eax # imm = 0x7FFF
 ; CHECK-32-NEXT:    xorl %ecx, %ecx
 ; CHECK-32-NEXT:    cmpl {{[0-9]+}}(%esp), %ecx
 ; CHECK-32-NEXT:    movl $-2147483648, %esi # imm = 0x80000000
 ; CHECK-32-NEXT:    sbbl %edx, %esi
 ; CHECK-32-NEXT:    movl $32767, %esi # imm = 0x7FFF
 ; CHECK-32-NEXT:    sbbl %eax, %esi
 ; CHECK-32-NEXT:    movl $0, %esi
 ; CHECK-32-NEXT:    sbbl %esi, %esi
 ; CHECK-32-NEXT:    setl %bl
 ; CHECK-32-NEXT:    cmpl $-1073741824, %edx # imm = 0xC0000000
 ; CHECK-32-NEXT:    sbbl $32767, %eax # imm = 0x7FFF
 ; CHECK-32-NEXT:    sbbl %ecx, %ecx
 ; CHECK-32-NEXT:    setl %al
 ; CHECK-32-NEXT:    andb %bl, %al
 ; CHECK-32-NEXT:    popl %esi
-; CHECK-32-NEXT:    .cfi_def_cfa_offset 8
 ; CHECK-32-NEXT:    popl %ebx
-; CHECK-32-NEXT:    .cfi_def_cfa_offset 4
 ; CHECK-32-NEXT:    retl
 ;
-; CHECK-64-LABEL: is_snan_f80:
+; CHECK-64-LABEL: is_snan_f80_soft:
 ; CHECK-64:       # %bb.0: # %entry
 ; CHECK-64-NEXT:    movzwl {{[0-9]+}}(%rsp), %eax
 ; CHECK-64-NEXT:    movq {{[0-9]+}}(%rsp), %rcx
 ; CHECK-64-NEXT:    andl $32767, %eax # imm = 0x7FFF
 ; CHECK-64-NEXT:    movabsq $-4611686018427387904, %rdx # imm = 0xC000000000000000
 ; CHECK-64-NEXT:    cmpq %rdx, %rcx
 ; CHECK-64-NEXT:    movq %rax, %rdx
 ; CHECK-64-NEXT:    sbbq $32767, %rdx # imm = 0x7FFF
 ; CHECK-64-NEXT:    setl %dl
 ; CHECK-64-NEXT:    movabsq $-9223372036854775808, %rsi # imm = 0x8000000000000000
 ; CHECK-64-NEXT:    cmpq %rcx, %rsi
 ; CHECK-64-NEXT:    movl $32767, %ecx # imm = 0x7FFF
 ; CHECK-64-NEXT:    sbbq %rax, %rcx
 ; CHECK-64-NEXT:    setl %al
 ; CHECK-64-NEXT:    andb %dl, %al
 ; CHECK-64-NEXT:    retq
 entry:
   %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 1)  ; "snan"
   ret i1 %0
 }
 
-define i1 @is_qnan_f80(x86_fp80 %x) {
+define i1 @is_qnan_f80(x86_fp80 %x) #0 {
 ; CHECK-32-LABEL: is_qnan_f80:
 ; CHECK-32:       # %bb.0: # %entry
-; CHECK-32-NEXT:    movzwl {{[0-9]+}}(%esp), %eax
-; CHECK-32-NEXT:    andl $32767, %eax # imm = 0x7FFF
-; CHECK-32-NEXT:    xorl %ecx, %ecx
-; CHECK-32-NEXT:    movl $-1073741825, %edx # imm = 0xBFFFFFFF
-; CHECK-32-NEXT:    cmpl {{[0-9]+}}(%esp), %edx
-; CHECK-32-NEXT:    movl $32767, %edx # imm = 0x7FFF
-; CHECK-32-NEXT:    sbbl %eax, %edx
-; CHECK-32-NEXT:    sbbl %ecx, %ecx
-; CHECK-32-NEXT:    setl %al
+; CHECK-32-NEXT:    subl $28, %esp
+; CHECK-32-NEXT:    fldt {{[0-9]+}}(%esp)
+; CHECK-32-NEXT:    fld %st(0)
+; CHECK-32-NEXT:    fstpt (%esp)
+; CHECK-32-NEXT:    fxam
+; CHECK-32-NEXT:    fnstsw %ax
+; CHECK-32-NEXT:    fstp %st(0)
+; CHECK-32-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-32-NEXT:    andl $17664, %eax # imm = 0x4500
+; CHECK-32-NEXT:    cmpl $256, %eax # imm = 0x100
+; CHECK-32-NEXT:    sete %cl
+; CHECK-32-NEXT:    testl $1073741824, {{[0-9]+}}(%esp) # imm = 0x40000000
+; CHECK-32-NEXT:    setne %al
+; CHECK-32-NEXT:    andb %cl, %al
+; CHECK-32-NEXT:    addl $28, %esp
 ; CHECK-32-NEXT:    retl
 ;
 ; CHECK-64-LABEL: is_qnan_f80:
 ; CHECK-64:       # %bb.0: # %entry
-; CHECK-64-NEXT:    movzwl {{[0-9]+}}(%rsp), %eax
-; CHECK-64-NEXT:    andl $32767, %eax # imm = 0x7FFF
-; CHECK-64-NEXT:    movabsq $-4611686018427387905, %rcx # imm = 0xBFFFFFFFFFFFFFFF
-; CHECK-64-NEXT:    cmpq {{[0-9]+}}(%rsp), %rcx
-; CHECK-64-NEXT:    movl $32767, %ecx # imm = 0x7FFF
-; CHECK-64-NEXT:    sbbq %rax, %rcx
-; CHECK-64-NEXT:    setl %al
+; CHECK-64-NEXT:    fldt {{[0-9]+}}(%rsp)
+; CHECK-64-NEXT:    fld %st(0)
+; CHECK-64-NEXT:    fstpt -{{[0-9]+}}(%rsp)
+; CHECK-64-NEXT:    fxam
+; CHECK-64-NEXT:    fnstsw %ax
+; CHECK-64-NEXT:    fstp %st(0)
+; CHECK-64-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-64-NEXT:    andl $17664, %eax # imm = 0x4500
+; CHECK-64-NEXT:    cmpl $256, %eax # imm = 0x100
+; CHECK-64-NEXT:    sete %cl
+; CHECK-64-NEXT:    testl $1073741824, -{{[0-9]+}}(%rsp) # imm = 0x40000000
+; CHECK-64-NEXT:    setne %al
+; CHECK-64-NEXT:    andb %cl, %al
+; CHECK-64-NEXT:    retq
+entry:
+  %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 2)  ; "qnan"
+  ret i1 %0
+}
+
+define i1 @is_qnan_f80_soft(x86_fp80 %x) #2 {
+; CHECK-32-LABEL: is_qnan_f80_soft:
+; CHECK-32:       # %bb.0: # %entry
+; CHECK-32-NEXT:    subl $28, %esp
+; CHECK-32-NEXT:    fldt {{[0-9]+}}(%esp)
+; CHECK-32-NEXT:    fld %st(0)
+; CHECK-32-NEXT:    fstpt (%esp)
+; CHECK-32-NEXT:    fxam
+; CHECK-32-NEXT:    fnstsw %ax
+; CHECK-32-NEXT:    fstp %st(0)
+; CHECK-32-NEXT:    wait
+; CHECK-32-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-32-NEXT:    andl $17664, %eax # imm = 0x4500
+; CHECK-32-NEXT:    cmpl $256, %eax # imm = 0x100
+; CHECK-32-NEXT:    sete %cl
+; CHECK-32-NEXT:    testl $1073741824, {{[0-9]+}}(%esp) # imm = 0x40000000
+; CHECK-32-NEXT:    setne %al
+; CHECK-32-NEXT:    andb %cl, %al
+; CHECK-32-NEXT:    addl $28, %esp
+; CHECK-32-NEXT:    retl
+;
+; CHECK-64-LABEL: is_qnan_f80_soft:
+; CHECK-64:       # %bb.0: # %entry
+; CHECK-64-NEXT:    fldt {{[0-9]+}}(%rsp)
+; CHECK-64-NEXT:    fld %st(0)
+; CHECK-64-NEXT:    fstpt -{{[0-9]+}}(%rsp)
+; CHECK-64-NEXT:    fxam
+; CHECK-64-NEXT:    fnstsw %ax
+; CHECK-64-NEXT:    fstp %st(0)
+; CHECK-64-NEXT:    wait
+; CHECK-64-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-64-NEXT:    andl $17664, %eax # imm = 0x4500
+; CHECK-64-NEXT:    cmpl $256, %eax # imm = 0x100
+; CHECK-64-NEXT:    sete %cl
+; CHECK-64-NEXT:    testl $1073741824, -{{[0-9]+}}(%rsp) # imm = 0x40000000
+; CHECK-64-NEXT:    setne %al
+; CHECK-64-NEXT:    andb %cl, %al
 ; CHECK-64-NEXT:    retq
 entry:
   %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 2)  ; "qnan"
   ret i1 %0
 }
 
-define i1 @is_zero_f80(x86_fp80 %x) {
+define i1 @is_zero_f80(x86_fp80 %x) #0 {
 ; CHECK-32-LABEL: is_zero_f80:
 ; CHECK-32:       # %bb.0: # %entry
 ; CHECK-32-NEXT:    fldt {{[0-9]+}}(%esp)
 ; CHECK-32-NEXT:    fldz
 ; CHECK-32-NEXT:    fucompp
 ; CHECK-32-NEXT:    fnstsw %ax
 ; CHECK-32-NEXT:    # kill: def $ah killed $ah killed $ax
 ; CHECK-32-NEXT:    sahf

 ; CHECK-64-NEXT:    sete %al
 ; CHECK-64-NEXT:    andb %cl, %al
 ; CHECK-64-NEXT:    retq
 entry:
   %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 96)  ; 0x60 = "zero"
   ret i1 %0
 }
 
-define i1 @is_zero_f80_strict(x86_fp80 %x) strictfp {
-; CHECK-32-LABEL: is_zero_f80_strict:
+define i1 @is_zero_f80_soft(x86_fp80 %x) #1 {
+; CHECK-32-LABEL: is_zero_f80_soft:
 ; CHECK-32:       # %bb.0: # %entry
 ; CHECK-32-NEXT:    movzwl {{[0-9]+}}(%esp), %eax
 ; CHECK-32-NEXT:    andl $32767, %eax # imm = 0x7FFF
 ; CHECK-32-NEXT:    orl {{[0-9]+}}(%esp), %eax
 ; CHECK-32-NEXT:    orl {{[0-9]+}}(%esp), %eax
 ; CHECK-32-NEXT:    sete %al
 ; CHECK-32-NEXT:    retl
 ;
-; CHECK-64-LABEL: is_zero_f80_strict:
+; CHECK-64-LABEL: is_zero_f80_soft:
 ; CHECK-64:       # %bb.0: # %entry
 ; CHECK-64-NEXT:    movzwl {{[0-9]+}}(%rsp), %eax
 ; CHECK-64-NEXT:    andl $32767, %eax # imm = 0x7FFF
 ; CHECK-64-NEXT:    orq {{[0-9]+}}(%rsp), %rax
 ; CHECK-64-NEXT:    sete %al
 ; CHECK-64-NEXT:    retq
 entry:
   %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 96)  ; 0x60 = "zero"
   ret i1 %0
 }
 
-define i1 @is_poszero_f80(x86_fp80 %x) {
+define i1 @is_zero_f80_strict(x86_fp80 %x) #2 {
+; CHECK-32-LABEL: is_zero_f80_strict:
+; CHECK-32:       # %bb.0: # %entry
+; CHECK-32-NEXT:    fldt {{[0-9]+}}(%esp)
+; CHECK-32-NEXT:    fxam
+; CHECK-32-NEXT:    fnstsw %ax
+; CHECK-32-NEXT:    fstp %st(0)
+; CHECK-32-NEXT:    wait
+; CHECK-32-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-32-NEXT:    andl $17664, %eax # imm = 0x4500
+; CHECK-32-NEXT:    cmpl $16384, %eax # imm = 0x4000
+; CHECK-32-NEXT:    sete %al
+; CHECK-32-NEXT:    retl
+;
+; CHECK-64-LABEL: is_zero_f80_strict:
+; CHECK-64:       # %bb.0: # %entry
+; CHECK-64-NEXT:    fldt {{[0-9]+}}(%rsp)
+; CHECK-64-NEXT:    fxam
+; CHECK-64-NEXT:    fnstsw %ax
+; CHECK-64-NEXT:    fstp %st(0)
+; CHECK-64-NEXT:    wait
+; CHECK-64-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-64-NEXT:    andl $17664, %eax # imm = 0x4500
+; CHECK-64-NEXT:    cmpl $16384, %eax # imm = 0x4000
+; CHECK-64-NEXT:    sete %al
+; CHECK-64-NEXT:    retq
+entry:
+  %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 96)  ; 0x60 = "zero"
+  ret i1 %0
+}
+
+define i1 @is_poszero_f80(x86_fp80 %x) #0 {
 ; CHECK-32-LABEL: is_poszero_f80:
 ; CHECK-32:       # %bb.0: # %entry
+; CHECK-32-NEXT:    fldt {{[0-9]+}}(%esp)
+; CHECK-32-NEXT:    fxam
+; CHECK-32-NEXT:    fnstsw %ax
+; CHECK-32-NEXT:    fstp %st(0)
+; CHECK-32-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-32-NEXT:    andl $18176, %eax # imm = 0x4700
+; CHECK-32-NEXT:    cmpl $16384, %eax # imm = 0x4000
+; CHECK-32-NEXT:    sete %al
+; CHECK-32-NEXT:    retl
+;
+; CHECK-64-LABEL: is_poszero_f80:
+; CHECK-64:       # %bb.0: # %entry
+; CHECK-64-NEXT:    fldt {{[0-9]+}}(%rsp)
+; CHECK-64-NEXT:    fxam
+; CHECK-64-NEXT:    fnstsw %ax
+; CHECK-64-NEXT:    fstp %st(0)
+; CHECK-64-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-64-NEXT:    andl $18176, %eax # imm = 0x4700
+; CHECK-64-NEXT:    cmpl $16384, %eax # imm = 0x4000
+; CHECK-64-NEXT:    sete %al
+; CHECK-64-NEXT:    retq
+entry:
+  %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 64)  ; 0x40 = "+zero"
+  ret i1 %0
+}
+
+define i1 @is_poszero_f80_soft(x86_fp80 %x) #1 {
+; CHECK-32-LABEL: is_poszero_f80_soft:
+; CHECK-32:       # %bb.0: # %entry
 ; CHECK-32-NEXT:    movzwl {{[0-9]+}}(%esp), %eax
 ; CHECK-32-NEXT:    orl {{[0-9]+}}(%esp), %eax
 ; CHECK-32-NEXT:    orl {{[0-9]+}}(%esp), %eax
 ; CHECK-32-NEXT:    sete %al
 ; CHECK-32-NEXT:    retl
 ;
-; CHECK-64-LABEL: is_poszero_f80:
+; CHECK-64-LABEL: is_poszero_f80_soft:
 ; CHECK-64:       # %bb.0: # %entry
 ; CHECK-64-NEXT:    movzwl {{[0-9]+}}(%rsp), %eax
 ; CHECK-64-NEXT:    orq {{[0-9]+}}(%rsp), %rax
 ; CHECK-64-NEXT:    sete %al
 ; CHECK-64-NEXT:    retq
 entry:
   %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 64)  ; 0x40 = "+zero"
   ret i1 %0
 }
 
-define i1 @is_negzero_f80(x86_fp80 %x) {
+define i1 @is_negzero_f80(x86_fp80 %x) #0 {
 ; CHECK-32-LABEL: is_negzero_f80:
 ; CHECK-32:       # %bb.0: # %entry
+; CHECK-32-NEXT:    fldt {{[0-9]+}}(%esp)
+; CHECK-32-NEXT:    fxam
+; CHECK-32-NEXT:    fnstsw %ax
+; CHECK-32-NEXT:    fstp %st(0)
+; CHECK-32-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-32-NEXT:    andl $18176, %eax # imm = 0x4700
+; CHECK-32-NEXT:    cmpl $16896, %eax # imm = 0x4200
+; CHECK-32-NEXT:    sete %al
+; CHECK-32-NEXT:    retl
+;
+; CHECK-64-LABEL: is_negzero_f80:
+; CHECK-64:       # %bb.0: # %entry
+; CHECK-64-NEXT:    fldt {{[0-9]+}}(%rsp)
+; CHECK-64-NEXT:    fxam
+; CHECK-64-NEXT:    fnstsw %ax
+; CHECK-64-NEXT:    fstp %st(0)
+; CHECK-64-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-64-NEXT:    andl $18176, %eax # imm = 0x4700
+; CHECK-64-NEXT:    cmpl $16896, %eax # imm = 0x4200
+; CHECK-64-NEXT:    sete %al
+; CHECK-64-NEXT:    retq
+entry:
+  %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 32)  ; 0x20 = "-zero"
+  ret i1 %0
+}
+
+define i1 @is_negzero_f80_soft(x86_fp80 %x) #1 {
+; CHECK-32-LABEL: is_negzero_f80_soft:
+; CHECK-32:       # %bb.0: # %entry
 ; CHECK-32-NEXT:    movzwl {{[0-9]+}}(%esp), %eax
 ; CHECK-32-NEXT:    xorl $32768, %eax # imm = 0x8000
 ; CHECK-32-NEXT:    orl {{[0-9]+}}(%esp), %eax
 ; CHECK-32-NEXT:    orl {{[0-9]+}}(%esp), %eax
 ; CHECK-32-NEXT:    sete %al
 ; CHECK-32-NEXT:    retl
 ;
-; CHECK-64-LABEL: is_negzero_f80:
+; CHECK-64-LABEL: is_negzero_f80_soft:
 ; CHECK-64:       # %bb.0: # %entry
 ; CHECK-64-NEXT:    movzwl {{[0-9]+}}(%rsp), %eax
 ; CHECK-64-NEXT:    xorq $32768, %rax # imm = 0x8000
 ; CHECK-64-NEXT:    orq {{[0-9]+}}(%rsp), %rax
 ; CHECK-64-NEXT:    sete %al
 ; CHECK-64-NEXT:    retq
 entry:
   %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 32)  ; 0x20 = "-zero"
   ret i1 %0
 }
 
-define i1 @is_inf_f80(x86_fp80 %x) {
+define i1 @is_inf_f80(x86_fp80 %x) #0 {
 ; CHECK-32-LABEL: is_inf_f80:
 ; CHECK-32:       # %bb.0: # %entry
+; CHECK-32-NEXT:    fldt {{[0-9]+}}(%esp)
+; CHECK-32-NEXT:    fxam
+; CHECK-32-NEXT:    fnstsw %ax
+; CHECK-32-NEXT:    fstp %st(0)
+; CHECK-32-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-32-NEXT:    andl $17664, %eax # imm = 0x4500
+; CHECK-32-NEXT:    cmpl $1280, %eax # imm = 0x500
+; CHECK-32-NEXT:    sete %al
+; CHECK-32-NEXT:    retl
+;
+; CHECK-64-LABEL: is_inf_f80:
+; CHECK-64:       # %bb.0: # %entry
+; CHECK-64-NEXT:    fldt {{[0-9]+}}(%rsp)
+; CHECK-64-NEXT:    fxam
+; CHECK-64-NEXT:    fnstsw %ax
+; CHECK-64-NEXT:    fstp %st(0)
+; CHECK-64-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-64-NEXT:    andl $17664, %eax # imm = 0x4500
+; CHECK-64-NEXT:    cmpl $1280, %eax # imm = 0x500
+; CHECK-64-NEXT:    sete %al
+; CHECK-64-NEXT:    retq
+entry:
+  %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 516)  ; 0x204 = "inf"
+  ret i1 %0
+}
+
+define i1 @is_inf_f80_soft(x86_fp80 %x) #1 {
+; CHECK-32-LABEL: is_inf_f80_soft:
+; CHECK-32:       # %bb.0: # %entry
 ; CHECK-32-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; CHECK-32-NEXT:    notl %eax
 ; CHECK-32-NEXT:    movl $-2147483648, %ecx # imm = 0x80000000
 ; CHECK-32-NEXT:    xorl {{[0-9]+}}(%esp), %ecx
 ; CHECK-32-NEXT:    andl $32767, %eax # imm = 0x7FFF
 ; CHECK-32-NEXT:    orl {{[0-9]+}}(%esp), %eax
 ; CHECK-32-NEXT:    orl %ecx, %eax
 ; CHECK-32-NEXT:    sete %al
 ; CHECK-32-NEXT:    retl
 ;
-; CHECK-64-LABEL: is_inf_f80:
+; CHECK-64-LABEL: is_inf_f80_soft:
 ; CHECK-64:       # %bb.0: # %entry
 ; CHECK-64-NEXT:    movl {{[0-9]+}}(%rsp), %eax
 ; CHECK-64-NEXT:    notl %eax
 ; CHECK-64-NEXT:    andl $32767, %eax # imm = 0x7FFF
 ; CHECK-64-NEXT:    movabsq $-9223372036854775808, %rcx # imm = 0x8000000000000000
 ; CHECK-64-NEXT:    xorq {{[0-9]+}}(%rsp), %rcx
 ; CHECK-64-NEXT:    orq %rax, %rcx
 ; CHECK-64-NEXT:    sete %al
 ; CHECK-64-NEXT:    retq
 entry:
   %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 516)  ; 0x204 = "inf"
   ret i1 %0
 }
 
-define i1 @is_posinf_f80(x86_fp80 %x) {
+define i1 @is_posinf_f80(x86_fp80 %x) #0 {
 ; CHECK-32-LABEL: is_posinf_f80:
 ; CHECK-32:       # %bb.0: # %entry
+; CHECK-32-NEXT:    fldt {{[0-9]+}}(%esp)
+; CHECK-32-NEXT:    fxam
+; CHECK-32-NEXT:    fnstsw %ax
+; CHECK-32-NEXT:    fstp %st(0)
+; CHECK-32-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-32-NEXT:    andl $18176, %eax # imm = 0x4700
+; CHECK-32-NEXT:    cmpl $1280, %eax # imm = 0x500
+; CHECK-32-NEXT:    sete %al
+; CHECK-32-NEXT:    retl
+;
+; CHECK-64-LABEL: is_posinf_f80:
+; CHECK-64:       # %bb.0: # %entry
+; CHECK-64-NEXT:    fldt {{[0-9]+}}(%rsp)
+; CHECK-64-NEXT:    fxam
+; CHECK-64-NEXT:    fnstsw %ax
+; CHECK-64-NEXT:    fstp %st(0)
+; CHECK-64-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-64-NEXT:    andl $18176, %eax # imm = 0x4700
+; CHECK-64-NEXT:    cmpl $1280, %eax # imm = 0x500
+; CHECK-64-NEXT:    sete %al
+; CHECK-64-NEXT:    retq
+entry:
+  %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 512)  ; 0x200 = "+inf"
+  ret i1 %0
+}
+
+define i1 @is_posinf_f80_soft(x86_fp80 %x) #1 {
+; CHECK-32-LABEL: is_posinf_f80_soft:
+; CHECK-32:       # %bb.0: # %entry
 ; CHECK-32-NEXT:    movzwl {{[0-9]+}}(%esp), %eax
 ; CHECK-32-NEXT:    movl $-2147483648, %ecx # imm = 0x80000000
 ; CHECK-32-NEXT:    xorl {{[0-9]+}}(%esp), %ecx
 ; CHECK-32-NEXT:    xorl $32767, %eax # imm = 0x7FFF
 ; CHECK-32-NEXT:    orl {{[0-9]+}}(%esp), %eax
 ; CHECK-32-NEXT:    orl %ecx, %eax
 ; CHECK-32-NEXT:    sete %al
 ; CHECK-32-NEXT:    retl
 ;
-; CHECK-64-LABEL: is_posinf_f80:
+; CHECK-64-LABEL: is_posinf_f80_soft:
 ; CHECK-64:       # %bb.0: # %entry
 ; CHECK-64-NEXT:    movzwl {{[0-9]+}}(%rsp), %eax
 ; CHECK-64-NEXT:    movabsq $-9223372036854775808, %rcx # imm = 0x8000000000000000
 ; CHECK-64-NEXT:    xorq {{[0-9]+}}(%rsp), %rcx
 ; CHECK-64-NEXT:    xorq $32767, %rax # imm = 0x7FFF
 ; CHECK-64-NEXT:    orq %rcx, %rax
 ; CHECK-64-NEXT:    sete %al
 ; CHECK-64-NEXT:    retq
 entry:
   %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 512)  ; 0x200 = "+inf"
   ret i1 %0
 }
 
-define i1 @is_neginf_f80(x86_fp80 %x) {
+define i1 @is_neginf_f80(x86_fp80 %x) #0 {
 ; CHECK-32-LABEL: is_neginf_f80:
 ; CHECK-32:       # %bb.0: # %entry
+; CHECK-32-NEXT:    fldt {{[0-9]+}}(%esp)
+; CHECK-32-NEXT:    fxam
+; CHECK-32-NEXT:    fnstsw %ax
+; CHECK-32-NEXT:    fstp %st(0)
+; CHECK-32-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-32-NEXT:    andl $18176, %eax # imm = 0x4700
+; CHECK-32-NEXT:    cmpl $1792, %eax # imm = 0x700
+; CHECK-32-NEXT:    sete %al
+; CHECK-32-NEXT:    retl
+;
+; CHECK-64-LABEL: is_neginf_f80:
+; CHECK-64:       # %bb.0: # %entry
+; CHECK-64-NEXT:    fldt {{[0-9]+}}(%rsp)
+; CHECK-64-NEXT:    fxam
+; CHECK-64-NEXT:    fnstsw %ax
+; CHECK-64-NEXT:    fstp %st(0)
+; CHECK-64-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-64-NEXT:    andl $18176, %eax # imm = 0x4700
+; CHECK-64-NEXT:    cmpl $1792, %eax # imm = 0x700
+; CHECK-64-NEXT:    sete %al
+; CHECK-64-NEXT:    retq
+entry:
+  %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 4)  ; "-inf"
+  ret i1 %0
+}
+
+define i1 @is_neginf_f80_soft(x86_fp80 %x) #1 {
+; CHECK-32-LABEL: is_neginf_f80_soft:
+; CHECK-32:       # %bb.0: # %entry
 ; CHECK-32-NEXT:    movzwl {{[0-9]+}}(%esp), %eax
 ; CHECK-32-NEXT:    xorl $65535, %eax # imm = 0xFFFF
 ; CHECK-32-NEXT:    movl $-2147483648, %ecx # imm = 0x80000000
 ; CHECK-32-NEXT:    xorl {{[0-9]+}}(%esp), %ecx
 ; CHECK-32-NEXT:    orl {{[0-9]+}}(%esp), %eax
 ; CHECK-32-NEXT:    orl %ecx, %eax
 ; CHECK-32-NEXT:    sete %al
 ; CHECK-32-NEXT:    retl
 ;
-; CHECK-64-LABEL: is_neginf_f80:
+; CHECK-64-LABEL: is_neginf_f80_soft:
 ; CHECK-64:       # %bb.0: # %entry
 ; CHECK-64-NEXT:    movl {{[0-9]+}}(%rsp), %eax
 ; CHECK-64-NEXT:    notl %eax
 ; CHECK-64-NEXT:    movzwl %ax, %eax
 ; CHECK-64-NEXT:    movabsq $-9223372036854775808, %rcx # imm = 0x8000000000000000
 ; CHECK-64-NEXT:    xorq {{[0-9]+}}(%rsp), %rcx
 ; CHECK-64-NEXT:    orq %rax, %rcx
 ; CHECK-64-NEXT:    sete %al
 ; CHECK-64-NEXT:    retq
 entry:
   %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 4)  ; "-inf"
   ret i1 %0
 }
 
-define i1 @is_normal_f80(x86_fp80 %x) {
+define i1 @is_normal_f80(x86_fp80 %x) #0 {
 ; CHECK-32-LABEL: is_normal_f80:
 ; CHECK-32:       # %bb.0: # %entry
+; CHECK-32-NEXT:    fldt {{[0-9]+}}(%esp)
+; CHECK-32-NEXT:    fxam
+; CHECK-32-NEXT:    fnstsw %ax
+; CHECK-32-NEXT:    fstp %st(0)
+; CHECK-32-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-32-NEXT:    andl $17664, %eax # imm = 0x4500
+; CHECK-32-NEXT:    cmpl $1024, %eax # imm = 0x400
+; CHECK-32-NEXT:    sete %al
+; CHECK-32-NEXT:    retl
+;
+; CHECK-64-LABEL: is_normal_f80:
+; CHECK-64:       # %bb.0: # %entry
+; CHECK-64-NEXT:    fldt {{[0-9]+}}(%rsp)
+; CHECK-64-NEXT:    fxam
+; CHECK-64-NEXT:    fnstsw %ax
+; CHECK-64-NEXT:    fstp %st(0)
+; CHECK-64-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-64-NEXT:    andl $17664, %eax # imm = 0x4500
+; CHECK-64-NEXT:    cmpl $1024, %eax # imm = 0x400
+; CHECK-64-NEXT:    sete %al
+; CHECK-64-NEXT:    retq
+entry:
+  %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 264)  ; 0x108 = "normal"
+  ret i1 %0
+}
+
+define i1 @is_normal_f80_soft(x86_fp80 %x) #1 {
+; CHECK-32-LABEL: is_normal_f80_soft:
+; CHECK-32:       # %bb.0: # %entry
 ; CHECK-32-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; CHECK-32-NEXT:    movzwl {{[0-9]+}}(%esp), %ecx
 ; CHECK-32-NEXT:    andl $32767, %ecx # imm = 0x7FFF
 ; CHECK-32-NEXT:    decl %ecx
 ; CHECK-32-NEXT:    movzwl %cx, %ecx
 ; CHECK-32-NEXT:    xorl %edx, %edx
 ; CHECK-32-NEXT:    cmpl $32766, %ecx # imm = 0x7FFE
 ; CHECK-32-NEXT:    sbbl %edx, %edx
 ; CHECK-32-NEXT:    setb %cl
 ; CHECK-32-NEXT:    shrl $31, %eax
 ; CHECK-32-NEXT:    andb %cl, %al
 ; CHECK-32-NEXT:    # kill: def $al killed $al killed $eax
 ; CHECK-32-NEXT:    retl
 ;
-; CHECK-64-LABEL: is_normal_f80:
+; CHECK-64-LABEL: is_normal_f80_soft:
 ; CHECK-64:       # %bb.0: # %entry
 ; CHECK-64-NEXT:    movzwl {{[0-9]+}}(%rsp), %eax
 ; CHECK-64-NEXT:    movq {{[0-9]+}}(%rsp), %rcx
 ; CHECK-64-NEXT:    shrq $63, %rcx
 ; CHECK-64-NEXT:    andl $32767, %eax # imm = 0x7FFF
 ; CHECK-64-NEXT:    decl %eax
 ; CHECK-64-NEXT:    movzwl %ax, %eax
 ; CHECK-64-NEXT:    cmpl $32766, %eax # imm = 0x7FFE
 ; CHECK-64-NEXT:    setb %al
 ; CHECK-64-NEXT:    andb %cl, %al
 ; CHECK-64-NEXT:    retq
 entry:
   %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 264)  ; 0x108 = "normal"
   ret i1 %0
 }
 
-define i1 @is_posnormal_f80(x86_fp80 %x) {
+define i1 @is_posnormal_f80(x86_fp80 %x) #0 {
 ; CHECK-32-LABEL: is_posnormal_f80:
 ; CHECK-32:       # %bb.0: # %entry
+; CHECK-32-NEXT:    fldt {{[0-9]+}}(%esp)
+; CHECK-32-NEXT:    fxam
+; CHECK-32-NEXT:    fnstsw %ax
+; CHECK-32-NEXT:    fstp %st(0)
+; CHECK-32-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-32-NEXT:    andl $18176, %eax # imm = 0x4700
+; CHECK-32-NEXT:    cmpl $1024, %eax # imm = 0x400
+; CHECK-32-NEXT:    sete %al
+; CHECK-32-NEXT:    retl
+;
+; CHECK-64-LABEL: is_posnormal_f80:
+; CHECK-64:       # %bb.0: # %entry
+; CHECK-64-NEXT:    fldt {{[0-9]+}}(%rsp)
+; CHECK-64-NEXT:    fxam
+; CHECK-64-NEXT:    fnstsw %ax
+; CHECK-64-NEXT:    fstp %st(0)
+; CHECK-64-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-64-NEXT:    andl $18176, %eax # imm = 0x4700
+; CHECK-64-NEXT:    cmpl $1024, %eax # imm = 0x400
+; CHECK-64-NEXT:    sete %al
+; CHECK-64-NEXT:    retq
+entry:
+  %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 256)  ; 0x100 = "+normal"
+  ret i1 %0
+}
+
+define i1 @is_posnormal_f80_soft(x86_fp80 %x) #1 {
+; CHECK-32-LABEL: is_posnormal_f80_soft:
+; CHECK-32:       # %bb.0: # %entry
 ; CHECK-32-NEXT:    pushl %esi
-; CHECK-32-NEXT:    .cfi_def_cfa_offset 8
-; CHECK-32-NEXT:    .cfi_offset %esi, -8
 ; CHECK-32-NEXT:    movzwl {{[0-9]+}}(%esp), %edx
 ; CHECK-32-NEXT:    movswl %dx, %ecx
 ; CHECK-32-NEXT:    sarl $15, %ecx
 ; CHECK-32-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; CHECK-32-NEXT:    andl $32767, %edx # imm = 0x7FFF
 ; CHECK-32-NEXT:    decl %edx
 ; CHECK-32-NEXT:    movzwl %dx, %edx
 ; CHECK-32-NEXT:    xorl %esi, %esi
 ; CHECK-32-NEXT:    cmpl $32766, %edx # imm = 0x7FFE
 ; CHECK-32-NEXT:    sbbl %esi, %esi
 ; CHECK-32-NEXT:    setb %dl
 ; CHECK-32-NEXT:    testl %ecx, %ecx
 ; CHECK-32-NEXT:    setns %cl
 ; CHECK-32-NEXT:    shrl $31, %eax
 ; CHECK-32-NEXT:    andb %cl, %al
 ; CHECK-32-NEXT:    andb %dl, %al
 ; CHECK-32-NEXT:    # kill: def $al killed $al killed $eax
 ; CHECK-32-NEXT:    popl %esi
-; CHECK-32-NEXT:    .cfi_def_cfa_offset 4
 ; CHECK-32-NEXT:    retl
 ;
-; CHECK-64-LABEL: is_posnormal_f80:
+; CHECK-64-LABEL: is_posnormal_f80_soft:
 ; CHECK-64:       # %bb.0: # %entry
 ; CHECK-64-NEXT:    movq {{[0-9]+}}(%rsp), %rax
 ; CHECK-64-NEXT:    movswq {{[0-9]+}}(%rsp), %rcx
 ; CHECK-64-NEXT:    testq %rcx, %rcx
 ; CHECK-64-NEXT:    setns %dl
 ; CHECK-64-NEXT:    andl $32767, %ecx # imm = 0x7FFF
 ; CHECK-64-NEXT:    decl %ecx
 ; CHECK-64-NEXT:    movzwl %cx, %ecx
 ; CHECK-64-NEXT:    cmpl $32766, %ecx # imm = 0x7FFE
 ; CHECK-64-NEXT:    setb %cl
 ; CHECK-64-NEXT:    shrq $63, %rax
 ; CHECK-64-NEXT:    andb %dl, %al
 ; CHECK-64-NEXT:    andb %cl, %al
 ; CHECK-64-NEXT:    # kill: def $al killed $al killed $rax
 ; CHECK-64-NEXT:    retq
 entry:
   %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 256)  ; 0x100 = "+normal"
   ret i1 %0
 }
 
-define i1 @is_negnormal_f80(x86_fp80 %x) {
+define i1 @is_negnormal_f80(x86_fp80 %x) #0 {
 ; CHECK-32-LABEL: is_negnormal_f80:
 ; CHECK-32:       # %bb.0: # %entry
+; CHECK-32-NEXT:    fldt {{[0-9]+}}(%esp)
+; CHECK-32-NEXT:    fxam
+; CHECK-32-NEXT:    fnstsw %ax
+; CHECK-32-NEXT:    fstp %st(0)
+; CHECK-32-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-32-NEXT:    andl $18176, %eax # imm = 0x4700
+; CHECK-32-NEXT:    cmpl $1536, %eax # imm = 0x600
+; CHECK-32-NEXT:    sete %al
+; CHECK-32-NEXT:    retl
+;
+; CHECK-64-LABEL: is_negnormal_f80:
+; CHECK-64:       # %bb.0: # %entry
+; CHECK-64-NEXT:    fldt {{[0-9]+}}(%rsp)
+; CHECK-64-NEXT:    fxam
+; CHECK-64-NEXT:    fnstsw %ax
+; CHECK-64-NEXT:    fstp %st(0)
+; CHECK-64-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-64-NEXT:    andl $18176, %eax # imm = 0x4700
+; CHECK-64-NEXT:    cmpl $1536, %eax # imm = 0x600
+; CHECK-64-NEXT:    sete %al
+; CHECK-64-NEXT:    retq
+entry:
+  %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 8)  ; "-normal"
+  ret i1 %0
+}
+
+define i1 @is_negnormal_f80_soft(x86_fp80 %x) #1 {
+; CHECK-32-LABEL: is_negnormal_f80_soft:
+; CHECK-32:       # %bb.0: # %entry
 ; CHECK-32-NEXT:    pushl %esi
-; CHECK-32-NEXT:    .cfi_def_cfa_offset 8
-; CHECK-32-NEXT:    .cfi_offset %esi, -8
 ; CHECK-32-NEXT:    movzwl {{[0-9]+}}(%esp), %edx
 ; CHECK-32-NEXT:    movswl %dx, %ecx
 ; CHECK-32-NEXT:    sarl $15, %ecx
 ; CHECK-32-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; CHECK-32-NEXT:    andl $32767, %edx # imm = 0x7FFF
 ; CHECK-32-NEXT:    decl %edx
 ; CHECK-32-NEXT:    movzwl %dx, %edx
 ; CHECK-32-NEXT:    xorl %esi, %esi
 ; CHECK-32-NEXT:    cmpl $32766, %edx # imm = 0x7FFE
 ; CHECK-32-NEXT:    sbbl %esi, %esi
 ; CHECK-32-NEXT:    setb %dl
 ; CHECK-32-NEXT:    testl %ecx, %ecx
 ; CHECK-32-NEXT:    sets %cl
 ; CHECK-32-NEXT:    shrl $31, %eax
 ; CHECK-32-NEXT:    andb %cl, %al
 ; CHECK-32-NEXT:    andb %dl, %al
 ; CHECK-32-NEXT:    # kill: def $al killed $al killed $eax
 ; CHECK-32-NEXT:    popl %esi
-; CHECK-32-NEXT:    .cfi_def_cfa_offset 4
 ; CHECK-32-NEXT:    retl
 ;
-; CHECK-64-LABEL: is_negnormal_f80:
+; CHECK-64-LABEL: is_negnormal_f80_soft:
 ; CHECK-64:       # %bb.0: # %entry
 ; CHECK-64-NEXT:    movq {{[0-9]+}}(%rsp), %rax
 ; CHECK-64-NEXT:    movswq {{[0-9]+}}(%rsp), %rcx
 ; CHECK-64-NEXT:    testq %rcx, %rcx
 ; CHECK-64-NEXT:    sets %dl
 ; CHECK-64-NEXT:    andl $32767, %ecx # imm = 0x7FFF
 ; CHECK-64-NEXT:    decl %ecx
 ; CHECK-64-NEXT:    movzwl %cx, %ecx
 ; CHECK-64-NEXT:    cmpl $32766, %ecx # imm = 0x7FFE
 ; CHECK-64-NEXT:    setb %cl
 ; CHECK-64-NEXT:    shrq $63, %rax
 ; CHECK-64-NEXT:    andb %dl, %al
 ; CHECK-64-NEXT:    andb %cl, %al
 ; CHECK-64-NEXT:    # kill: def $al killed $al killed $rax
 ; CHECK-64-NEXT:    retq
 entry:
   %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 8)  ; "-normal"
   ret i1 %0
 }
 
-define i1 @is_subnormal_f80(x86_fp80 %x) {
+define i1 @is_subnormal_f80(x86_fp80 %x) #0 {
 ; CHECK-32-LABEL: is_subnormal_f80:
 ; CHECK-32:       # %bb.0: # %entry
+; CHECK-32-NEXT:    fldt {{[0-9]+}}(%esp)
+; CHECK-32-NEXT:    fxam
+; CHECK-32-NEXT:    fnstsw %ax
+; CHECK-32-NEXT:    fstp %st(0)
+; CHECK-32-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-32-NEXT:    andl $17664, %eax # imm = 0x4500
+; CHECK-32-NEXT:    cmpl $17408, %eax # imm = 0x4400
+; CHECK-32-NEXT:    sete %al
+; CHECK-32-NEXT:    retl
+;
+; CHECK-64-LABEL: is_subnormal_f80:
+; CHECK-64:       # %bb.0: # %entry
+; CHECK-64-NEXT:    fldt {{[0-9]+}}(%rsp)
+; CHECK-64-NEXT:    fxam
+; CHECK-64-NEXT:    fnstsw %ax
+; CHECK-64-NEXT:    fstp %st(0)
+; CHECK-64-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-64-NEXT:    andl $17664, %eax # imm = 0x4500
+; CHECK-64-NEXT:    cmpl $17408, %eax # imm = 0x4400
+; CHECK-64-NEXT:    sete %al
+; CHECK-64-NEXT:    retq
+entry:
+  %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 144)  ; 0x90 = "subnormal"
+  ret i1 %0
+}
+
+define i1 @is_subnormal_f80_soft(x86_fp80 %x) #1 {
+; CHECK-32-LABEL: is_subnormal_f80_soft:
+; CHECK-32:       # %bb.0: # %entry
 ; CHECK-32-NEXT:    pushl %esi
-; CHECK-32-NEXT:    .cfi_def_cfa_offset 8
-; CHECK-32-NEXT:    .cfi_offset %esi, -8
 ; CHECK-32-NEXT:    movl {{[0-9]+}}(%esp), %esi
 ; CHECK-32-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; CHECK-32-NEXT:    movzwl {{[0-9]+}}(%esp), %eax
 ; CHECK-32-NEXT:    andl $32767, %eax # imm = 0x7FFF
 ; CHECK-32-NEXT:    xorl %edx, %edx
 ; CHECK-32-NEXT:    addl $-1, %esi
 ; CHECK-32-NEXT:    adcl $-1, %ecx
 ; CHECK-32-NEXT:    adcl $-1, %eax
 ; CHECK-32-NEXT:    adcl $-1, %edx
 ; CHECK-32-NEXT:    cmpl $-1, %esi
 ; CHECK-32-NEXT:    sbbl $2147483647, %ecx # imm = 0x7FFFFFFF
 ; CHECK-32-NEXT:    sbbl $0, %eax
 ; CHECK-32-NEXT:    sbbl $0, %edx
 ; CHECK-32-NEXT:    setb %al
 ; CHECK-32-NEXT:    popl %esi
-; CHECK-32-NEXT:    .cfi_def_cfa_offset 4
 ; CHECK-32-NEXT:    retl
 ;
-; CHECK-64-LABEL: is_subnormal_f80:
+; CHECK-64-LABEL: is_subnormal_f80_soft:
 ; CHECK-64:       # %bb.0: # %entry
 ; CHECK-64-NEXT:    movzwl {{[0-9]+}}(%rsp), %eax
 ; CHECK-64-NEXT:    movq {{[0-9]+}}(%rsp), %rcx
 ; CHECK-64-NEXT:    andl $32767, %eax # imm = 0x7FFF
 ; CHECK-64-NEXT:    addq $-1, %rcx
 ; CHECK-64-NEXT:    adcq $-1, %rax
 ; CHECK-64-NEXT:    movabsq $9223372036854775807, %rdx # imm = 0x7FFFFFFFFFFFFFFF
 ; CHECK-64-NEXT:    cmpq %rdx, %rcx
 ; CHECK-64-NEXT:    sbbq $0, %rax
 ; CHECK-64-NEXT:    setb %al
 ; CHECK-64-NEXT:    retq
 entry:
   %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 144)  ; 0x90 = "subnormal"
   ret i1 %0
 }
 
-define i1 @is_possubnormal_f80(x86_fp80 %x) {
+define i1 @is_possubnormal_f80(x86_fp80 %x) #0 {
 ; CHECK-32-LABEL: is_possubnormal_f80:
 ; CHECK-32:       # %bb.0: # %entry
+; CHECK-32-NEXT:    fldt {{[0-9]+}}(%esp)
+; CHECK-32-NEXT:    fxam
+; CHECK-32-NEXT:    fnstsw %ax
+; CHECK-32-NEXT:    fstp %st(0)
+; CHECK-32-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-32-NEXT:    andl $18176, %eax # imm = 0x4700
+; CHECK-32-NEXT:    cmpl $17408, %eax # imm = 0x4400
+; CHECK-32-NEXT:    sete %al
+; CHECK-32-NEXT:    retl
+;
+; CHECK-64-LABEL: is_possubnormal_f80:
+; CHECK-64:       # %bb.0: # %entry
+; CHECK-64-NEXT:    fldt {{[0-9]+}}(%rsp)
+; CHECK-64-NEXT:    fxam
+; CHECK-64-NEXT:    fnstsw %ax
+; CHECK-64-NEXT:    fstp %st(0)
+; CHECK-64-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-64-NEXT:    andl $18176, %eax # imm = 0x4700
+; CHECK-64-NEXT:    cmpl $17408, %eax # imm = 0x4400
+; CHECK-64-NEXT:    sete %al
+; CHECK-64-NEXT:    retq
+entry:
+  %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 128)  ; 0x80 = "+subnormal"
+  ret i1 %0
+}
+
+define i1 @is_possubnormal_f80_soft(x86_fp80 %x) #1 {
+; CHECK-32-LABEL: is_possubnormal_f80_soft:
+; CHECK-32:       # %bb.0: # %entry
 ; CHECK-32-NEXT:    pushl %esi
-; CHECK-32-NEXT:    .cfi_def_cfa_offset 8
-; CHECK-32-NEXT:    .cfi_offset %esi, -8
 ; CHECK-32-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; CHECK-32-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; CHECK-32-NEXT:    movl {{[0-9]+}}(%esp), %edx
 ; CHECK-32-NEXT:    addl $-1, %ecx
 ; CHECK-32-NEXT:    adcl $-1, %edx
 ; CHECK-32-NEXT:    adcl $-1, %eax
 ; CHECK-32-NEXT:    movzwl %ax, %eax
 ; CHECK-32-NEXT:    xorl %esi, %esi
 ; CHECK-32-NEXT:    cmpl $-1, %ecx
 ; CHECK-32-NEXT:    sbbl $2147483647, %edx # imm = 0x7FFFFFFF
 ; CHECK-32-NEXT:    sbbl $0, %eax
 ; CHECK-32-NEXT:    sbbl %esi, %esi
 ; CHECK-32-NEXT:    setb %al
 ; CHECK-32-NEXT:    popl %esi
-; CHECK-32-NEXT:    .cfi_def_cfa_offset 4
 ; CHECK-32-NEXT:    retl
 ;
-; CHECK-64-LABEL: is_possubnormal_f80:
+; CHECK-64-LABEL: is_possubnormal_f80_soft:
 ; CHECK-64:       # %bb.0: # %entry
 ; CHECK-64-NEXT:    movl {{[0-9]+}}(%rsp), %eax
 ; CHECK-64-NEXT:    movq {{[0-9]+}}(%rsp), %rcx
 ; CHECK-64-NEXT:    addq $-1, %rcx
 ; CHECK-64-NEXT:    adcq $-1, %rax
 ; CHECK-64-NEXT:    movzwl %ax, %eax
 ; CHECK-64-NEXT:    movabsq $9223372036854775807, %rdx # imm = 0x7FFFFFFFFFFFFFFF
 ; CHECK-64-NEXT:    cmpq %rdx, %rcx
 ; CHECK-64-NEXT:    sbbq $0, %rax
 ; CHECK-64-NEXT:    setb %al
 ; CHECK-64-NEXT:    retq
 entry:
   %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 128)  ; 0x80 = "+subnormal"
   ret i1 %0
 }
 
-define i1 @is_negsubnormal_f80(x86_fp80 %x) {
+define i1 @is_negsubnormal_f80(x86_fp80 %x) #0 {
 ; CHECK-32-LABEL: is_negsubnormal_f80:
 ; CHECK-32:       # %bb.0: # %entry
+; CHECK-32-NEXT:    fldt {{[0-9]+}}(%esp)
+; CHECK-32-NEXT:    fxam
+; CHECK-32-NEXT:    fnstsw %ax
+; CHECK-32-NEXT:    fstp %st(0)
+; CHECK-32-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-32-NEXT:    andl $18176, %eax # imm = 0x4700
+; CHECK-32-NEXT:    cmpl $17920, %eax # imm = 0x4600
+; CHECK-32-NEXT:    sete %al
+; CHECK-32-NEXT:    retl
+;
+; CHECK-64-LABEL: is_negsubnormal_f80:
+; CHECK-64:       # %bb.0: # %entry
+; CHECK-64-NEXT:    fldt {{[0-9]+}}(%rsp)
+; CHECK-64-NEXT:    fxam
+; CHECK-64-NEXT:    fnstsw %ax
+; CHECK-64-NEXT:    fstp %st(0)
+; CHECK-64-NEXT:    # kill: def $ax killed $ax def $eax
+; CHECK-64-NEXT:    andl $18176, %eax # imm = 0x4700
+; CHECK-64-NEXT:    cmpl $17920, %eax # imm = 0x4600
+; CHECK-64-NEXT:    sete %al
+; CHECK-64-NEXT:    retq
+entry:
+  %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 16)  ; 0x10 = "-subnormal"
+  ret i1 %0
+}
+
+define i1 @is_negsubnormal_f80_soft(x86_fp80 %x) #1 {
+; CHECK-32-LABEL: is_negsubnormal_f80_soft:
+; CHECK-32:       # %bb.0: # %entry
 ; CHECK-32-NEXT:    pushl %edi
-; CHECK-32-NEXT:    .cfi_def_cfa_offset 8
 ; CHECK-32-NEXT:    pushl %esi
-; CHECK-32-NEXT:    .cfi_def_cfa_offset 12
-; CHECK-32-NEXT:    .cfi_offset %esi, -12
-; CHECK-32-NEXT:    .cfi_offset %edi, -8
 ; CHECK-32-NEXT:    movzwl {{[0-9]+}}(%esp), %ecx
 ; CHECK-32-NEXT:    movswl %cx, %eax
 ; CHECK-32-NEXT:    sarl $15, %eax
 ; CHECK-32-NEXT:    movl {{[0-9]+}}(%esp), %esi
 ; CHECK-32-NEXT:    movl {{[0-9]+}}(%esp), %edi
 ; CHECK-32-NEXT:    andl $32767, %ecx # imm = 0x7FFF
 ; CHECK-32-NEXT:    xorl %edx, %edx
 ; CHECK-32-NEXT:    addl $-1, %esi
 ; CHECK-32-NEXT:    adcl $-1, %edi
 ; CHECK-32-NEXT:    adcl $-1, %ecx
 ; CHECK-32-NEXT:    adcl $-1, %edx
 ; CHECK-32-NEXT:    cmpl $-1, %esi
 ; CHECK-32-NEXT:    sbbl $2147483647, %edi # imm = 0x7FFFFFFF
 ; CHECK-32-NEXT:    sbbl $0, %ecx
 ; CHECK-32-NEXT:    sbbl $0, %edx
 ; CHECK-32-NEXT:    setb %cl
 ; CHECK-32-NEXT:    testl %eax, %eax
 ; CHECK-32-NEXT:    sets %al
 ; CHECK-32-NEXT:    andb %cl, %al
 ; CHECK-32-NEXT:    popl %esi
-; CHECK-32-NEXT:    .cfi_def_cfa_offset 8
 ; CHECK-32-NEXT:    popl %edi
-; CHECK-32-NEXT:    .cfi_def_cfa_offset 4
 ; CHECK-32-NEXT:    retl
 ;
-; CHECK-64-LABEL: is_negsubnormal_f80:
+; CHECK-64-LABEL: is_negsubnormal_f80_soft:
 ; CHECK-64:       # %bb.0: # %entry
 ; CHECK-64-NEXT:    movzwl {{[0-9]+}}(%rsp), %eax
 ; CHECK-64-NEXT:    movswq %ax, %rcx
 ; CHECK-64-NEXT:    movq {{[0-9]+}}(%rsp), %rdx
 ; CHECK-64-NEXT:    andl $32767, %eax # imm = 0x7FFF
 ; CHECK-64-NEXT:    addq $-1, %rdx
 ; CHECK-64-NEXT:    adcq $-1, %rax
 ; CHECK-64-NEXT:    movabsq $9223372036854775807, %rsi # imm = 0x7FFFFFFFFFFFFFFF
 ; CHECK-64-NEXT:    cmpq %rsi, %rdx
 ; CHECK-64-NEXT:    sbbq $0, %rax
 ; CHECK-64-NEXT:    setb %dl
 ; CHECK-64-NEXT:    testq %rcx, %rcx
 ; CHECK-64-NEXT:    sets %al
 ; CHECK-64-NEXT:    andb %dl, %al
 ; CHECK-64-NEXT:    retq
 entry:
   %0 = tail call i1 @llvm.is.fpclass.f80(x86_fp80 %x, i32 16)  ; 0x10 = "-subnormal"
   ret i1 %0
 }
 
+attributes #0 = { nounwind }
+attributes #1 = { nounwind "use-soft-float"="true" }
+attributes #2 = { nounwind strictfp }
+
 declare i1 @llvm.is.fpclass.f80(x86_fp80, i32)