From 09f1b672cbffc40bc3cda5f75fb07fbc505f7268 Mon Sep 17 00:00:00 2001 From: James Molloy Date: Wed, 25 Mar 2015 10:03:42 +0000 Subject: [PATCH] Reapply r233062: "float2int": Add a new pass to demote from float to int where possible. Now with a fix for PR23008 and extra regression test. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@233175 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/InitializePasses.h | 1 + include/llvm/LinkAllPasses.h | 1 + include/llvm/Transforms/Scalar.h | 7 +- lib/Transforms/IPO/PassManagerBuilder.cpp | 7 + lib/Transforms/Scalar/CMakeLists.txt | 1 + lib/Transforms/Scalar/Float2Int.cpp | 537 ++++++++++++++++++++++ lib/Transforms/Scalar/Scalar.cpp | 1 + test/Transforms/Float2Int/basic.ll | 242 ++++++++++ test/Transforms/Float2Int/toolarge.ll | 16 + 9 files changed, 812 insertions(+), 1 deletion(-) create mode 100644 lib/Transforms/Scalar/Float2Int.cpp create mode 100644 test/Transforms/Float2Int/basic.ll create mode 100644 test/Transforms/Float2Int/toolarge.ll diff --git a/include/llvm/InitializePasses.h b/include/llvm/InitializePasses.h index 1d428b0a73a..2714ff26c23 100644 --- a/include/llvm/InitializePasses.h +++ b/include/llvm/InitializePasses.h @@ -294,6 +294,7 @@ void initializeWinEHPreparePass(PassRegistry&); void initializePlaceBackedgeSafepointsImplPass(PassRegistry&); void initializePlaceSafepointsPass(PassRegistry&); void initializeDwarfEHPreparePass(PassRegistry&); +void initializeFloat2IntPass(PassRegistry&); } #endif diff --git a/include/llvm/LinkAllPasses.h b/include/llvm/LinkAllPasses.h index 391267c060e..6d37cd96e5c 100644 --- a/include/llvm/LinkAllPasses.h +++ b/include/llvm/LinkAllPasses.h @@ -169,6 +169,7 @@ namespace { (void) llvm::createRewriteSymbolsPass(); (void) llvm::createStraightLineStrengthReducePass(); (void) llvm::createMemDerefPrinter(); + (void) llvm::createFloat2IntPass(); (void)new llvm::IntervalPartition(); (void)new llvm::ScalarEvolution(); diff --git a/include/llvm/Transforms/Scalar.h b/include/llvm/Transforms/Scalar.h index 672325f3f88..f59b0623950 100644 --- a/include/llvm/Transforms/Scalar.h +++ b/include/llvm/Transforms/Scalar.h @@ -429,7 +429,6 @@ BasicBlockPass *createLoadCombinePass(); FunctionPass *createStraightLineStrengthReducePass(); - //===----------------------------------------------------------------------===// // // PlaceSafepoints - Rewrite any IR calls to gc.statepoints and insert any @@ -447,6 +446,12 @@ ModulePass *createPlaceSafepointsPass(); // FunctionPass *createRewriteStatepointsForGCPass(); +//===----------------------------------------------------------------------===// +// +// Float2Int - Demote floats to ints where possible. +// +FunctionPass *createFloat2IntPass(); + } // End llvm namespace #endif diff --git a/lib/Transforms/IPO/PassManagerBuilder.cpp b/lib/Transforms/IPO/PassManagerBuilder.cpp index d28d5630fbd..502451bf432 100644 --- a/lib/Transforms/IPO/PassManagerBuilder.cpp +++ b/lib/Transforms/IPO/PassManagerBuilder.cpp @@ -59,6 +59,10 @@ static cl::opt RunLoopRerolling("reroll-loops", cl::Hidden, cl::desc("Run the loop rerolling pass")); +static cl::opt +RunFloat2Int("float-to-int", cl::Hidden, cl::init(true), + cl::desc("Run the float2int (float demotion) pass")); + static cl::opt RunLoadCombine("combine-loads", cl::init(false), cl::Hidden, cl::desc("Run the load combining pass")); @@ -307,6 +311,9 @@ void PassManagerBuilder::populateModulePassManager( // we must insert a no-op module pass to reset the pass manager. MPM.add(createBarrierNoopPass()); + if (RunFloat2Int) + MPM.add(createFloat2IntPass()); + // Re-rotate loops in all our loop nests. These may have fallout out of // rotated form due to GVN or other transformations, and the vectorizer relies // on the rotated form. diff --git a/lib/Transforms/Scalar/CMakeLists.txt b/lib/Transforms/Scalar/CMakeLists.txt index d12fdb7dd4e..4e4716f6bce 100644 --- a/lib/Transforms/Scalar/CMakeLists.txt +++ b/lib/Transforms/Scalar/CMakeLists.txt @@ -9,6 +9,7 @@ add_llvm_library(LLVMScalarOpts DeadStoreElimination.cpp EarlyCSE.cpp FlattenCFGPass.cpp + Float2Int.cpp GVN.cpp InductiveRangeCheckElimination.cpp IndVarSimplify.cpp diff --git a/lib/Transforms/Scalar/Float2Int.cpp b/lib/Transforms/Scalar/Float2Int.cpp new file mode 100644 index 00000000000..3d7457ea5dc --- /dev/null +++ b/lib/Transforms/Scalar/Float2Int.cpp @@ -0,0 +1,537 @@ +//===- Float2Int.cpp - Demote floating point ops to work on integers ------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file implements the Float2Int pass, which aims to demote floating +// point operations to work on integers, where that is losslessly possible. +// +//===----------------------------------------------------------------------===// + +#define DEBUG_TYPE "float2int" +#include "llvm/ADT/APInt.h" +#include "llvm/ADT/APSInt.h" +#include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/EquivalenceClasses.h" +#include "llvm/ADT/MapVector.h" +#include "llvm/ADT/SmallVector.h" +#include "llvm/IR/ConstantRange.h" +#include "llvm/IR/Constants.h" +#include "llvm/IR/IRBuilder.h" +#include "llvm/IR/InstIterator.h" +#include "llvm/IR/Instructions.h" +#include "llvm/IR/Module.h" +#include "llvm/Pass.h" +#include "llvm/Support/Debug.h" +#include "llvm/Support/raw_ostream.h" +#include "llvm/Transforms/Scalar.h" +#include +#include // For std::function +using namespace llvm; + +// The algorithm is simple. Start at instructions that convert from the +// float to the int domain: fptoui, fptosi and fcmp. Walk up the def-use +// graph, using an equivalence datastructure to unify graphs that interfere. +// +// Mappable instructions are those with an integer corrollary that, given +// integer domain inputs, produce an integer output; fadd, for example. +// +// If a non-mappable instruction is seen, this entire def-use graph is marked +// as non-transformable. If we see an instruction that converts from the +// integer domain to FP domain (uitofp,sitofp), we terminate our walk. + +/// The largest integer type worth dealing with. +static cl::opt +MaxIntegerBW("float2int-max-integer-bw", cl::init(64), cl::Hidden, + cl::desc("Max integer bitwidth to consider in float2int" + "(default=64)")); + +namespace { + struct Float2Int : public FunctionPass { + static char ID; // Pass identification, replacement for typeid + Float2Int() : FunctionPass(ID) { + initializeFloat2IntPass(*PassRegistry::getPassRegistry()); + } + + bool runOnFunction(Function &F) override; + void getAnalysisUsage(AnalysisUsage &AU) const override { + AU.setPreservesCFG(); + } + + void findRoots(Function &F, SmallPtrSet &Roots); + ConstantRange seen(Instruction *I, ConstantRange R); + ConstantRange badRange(); + ConstantRange unknownRange(); + ConstantRange validateRange(ConstantRange R); + void walkBackwards(const SmallPtrSetImpl &Roots); + void walkForwards(); + bool validateAndTransform(); + Value *convert(Instruction *I, Type *ToTy); + void cleanup(); + + MapVector SeenInsts; + SmallPtrSet Roots; + EquivalenceClasses ECs; + MapVector ConvertedInsts; + LLVMContext *Ctx; + }; +} + +char Float2Int::ID = 0; +INITIALIZE_PASS(Float2Int, "float2int", "Float to int", false, false) + +// Given a FCmp predicate, return a matching ICmp predicate if one +// exists, otherwise return BAD_ICMP_PREDICATE. +static CmpInst::Predicate mapFCmpPred(CmpInst::Predicate P) { + switch (P) { + case CmpInst::FCMP_OEQ: + case CmpInst::FCMP_UEQ: + return CmpInst::ICMP_EQ; + case CmpInst::FCMP_OGT: + case CmpInst::FCMP_UGT: + return CmpInst::ICMP_SGT; + case CmpInst::FCMP_OGE: + case CmpInst::FCMP_UGE: + return CmpInst::ICMP_SGE; + case CmpInst::FCMP_OLT: + case CmpInst::FCMP_ULT: + return CmpInst::ICMP_SLT; + case CmpInst::FCMP_OLE: + case CmpInst::FCMP_ULE: + return CmpInst::ICMP_SLE; + case CmpInst::FCMP_ONE: + case CmpInst::FCMP_UNE: + return CmpInst::ICMP_NE; + default: + return CmpInst::BAD_ICMP_PREDICATE; + } +} + +// Given a floating point binary operator, return the matching +// integer version. +static Instruction::BinaryOps mapBinOpcode(unsigned Opcode) { + switch (Opcode) { + default: llvm_unreachable("Unhandled opcode!"); + case Instruction::FAdd: return Instruction::Add; + case Instruction::FSub: return Instruction::Sub; + case Instruction::FMul: return Instruction::Mul; + } +} + +// Find the roots - instructions that convert from the FP domain to +// integer domain. +void Float2Int::findRoots(Function &F, SmallPtrSet &Roots) { + for (auto &I : inst_range(F)) { + switch (I.getOpcode()) { + default: break; + case Instruction::FPToUI: + case Instruction::FPToSI: + Roots.insert(&I); + break; + case Instruction::FCmp: + if (mapFCmpPred(cast(&I)->getPredicate()) != + CmpInst::BAD_ICMP_PREDICATE) + Roots.insert(&I); + break; + } + } +} + +// Helper - mark I as having been traversed, having range R. +ConstantRange Float2Int::seen(Instruction *I, ConstantRange R) { + DEBUG(dbgs() << "F2I: " << *I << ":" << R << "\n"); + if (SeenInsts.find(I) != SeenInsts.end()) + SeenInsts.find(I)->second = R; + else + SeenInsts.insert(std::make_pair(I, R)); + return R; +} + +// Helper - get a range representing a poison value. +ConstantRange Float2Int::badRange() { + return ConstantRange(MaxIntegerBW + 1, true); +} +ConstantRange Float2Int::unknownRange() { + return ConstantRange(MaxIntegerBW + 1, false); +} +ConstantRange Float2Int::validateRange(ConstantRange R) { + if (R.getBitWidth() > MaxIntegerBW + 1) + return badRange(); + return R; +} + +// The most obvious way to structure the search is a depth-first, eager +// search from each root. However, that require direct recursion and so +// can only handle small instruction sequences. Instead, we split the search +// up into two phases: +// - walkBackwards: A breadth-first walk of the use-def graph starting from +// the roots. Populate "SeenInsts" with interesting +// instructions and poison values if they're obvious and +// cheap to compute. Calculate the equivalance set structure +// while we're here too. +// - walkForwards: Iterate over SeenInsts in reverse order, so we visit +// defs before their uses. Calculate the real range info. + +// Breadth-first walk of the use-def graph; determine the set of nodes +// we care about and eagerly determine if some of them are poisonous. +void Float2Int::walkBackwards(const SmallPtrSetImpl &Roots) { + std::deque Worklist(Roots.begin(), Roots.end()); + while (!Worklist.empty()) { + Instruction *I = Worklist.back(); + Worklist.pop_back(); + + if (SeenInsts.find(I) != SeenInsts.end()) + // Seen already. + continue; + + switch (I->getOpcode()) { + // FIXME: Handle select and phi nodes. + default: + // Path terminated uncleanly. + seen(I, badRange()); + break; + + case Instruction::UIToFP: { + // Path terminated cleanly. + unsigned BW = I->getOperand(0)->getType()->getPrimitiveSizeInBits(); + APInt Min = APInt::getMinValue(BW).zextOrSelf(MaxIntegerBW+1); + APInt Max = APInt::getMaxValue(BW).zextOrSelf(MaxIntegerBW+1); + seen(I, validateRange(ConstantRange(Min, Max))); + continue; + } + + case Instruction::SIToFP: { + // Path terminated cleanly. + unsigned BW = I->getOperand(0)->getType()->getPrimitiveSizeInBits(); + APInt SMin = APInt::getSignedMinValue(BW).sextOrSelf(MaxIntegerBW+1); + APInt SMax = APInt::getSignedMaxValue(BW).sextOrSelf(MaxIntegerBW+1); + seen(I, validateRange(ConstantRange(SMin, SMax))); + continue; + } + + case Instruction::FAdd: + case Instruction::FSub: + case Instruction::FMul: + case Instruction::FPToUI: + case Instruction::FPToSI: + case Instruction::FCmp: + seen(I, unknownRange()); + break; + } + + for (Value *O : I->operands()) { + if (Instruction *OI = dyn_cast(O)) { + // Unify def-use chains if they interfere. + ECs.unionSets(I, OI); + if (SeenInsts.find(I)->second != badRange()) + Worklist.push_back(OI); + } else if (!isa(O)) { + // Not an instruction or ConstantFP? we can't do anything. + seen(I, badRange()); + } + } + } +} + +// Walk forwards down the list of seen instructions, so we visit defs before +// uses. +void Float2Int::walkForwards() { + for (auto It = SeenInsts.rbegin(), E = SeenInsts.rend(); It != E; ++It) { + if (It->second != unknownRange()) + continue; + + Instruction *I = It->first; + std::function)> Op; + switch (I->getOpcode()) { + // FIXME: Handle select and phi nodes. + default: + case Instruction::UIToFP: + case Instruction::SIToFP: + llvm_unreachable("Should have been handled in walkForwards!"); + + case Instruction::FAdd: + Op = [](ArrayRef Ops) { + assert(Ops.size() == 2 && "FAdd is a binary operator!"); + return Ops[0].add(Ops[1]); + }; + break; + + case Instruction::FSub: + Op = [](ArrayRef Ops) { + assert(Ops.size() == 2 && "FSub is a binary operator!"); + return Ops[0].sub(Ops[1]); + }; + break; + + case Instruction::FMul: + Op = [](ArrayRef Ops) { + assert(Ops.size() == 2 && "FMul is a binary operator!"); + return Ops[0].multiply(Ops[1]); + }; + break; + + // + // Root-only instructions - we'll only see these if they're the + // first node in a walk. + // + case Instruction::FPToUI: + case Instruction::FPToSI: + Op = [](ArrayRef Ops) { + assert(Ops.size() == 1 && "FPTo[US]I is a unary operator!"); + return Ops[0]; + }; + break; + + case Instruction::FCmp: + Op = [](ArrayRef Ops) { + assert(Ops.size() == 2 && "FCmp is a binary operator!"); + return Ops[0].unionWith(Ops[1]); + }; + break; + } + + bool Abort = false; + SmallVector OpRanges; + for (Value *O : I->operands()) { + if (Instruction *OI = dyn_cast(O)) { + assert(SeenInsts.find(OI) != SeenInsts.end() && + "def not seen before use!"); + OpRanges.push_back(SeenInsts.find(OI)->second); + } else if (ConstantFP *CF = dyn_cast(O)) { + // Work out if the floating point number can be losslessly represented + // as an integer. + // APFloat::convertToInteger(&Exact) purports to do what we want, but + // the exactness can be too precise. For example, negative zero can + // never be exactly converted to an integer. + // + // Instead, we ask APFloat to round itself to an integral value - this + // preserves sign-of-zero - then compare the result with the original. + // + APFloat F = CF->getValueAPF(); + + // First, weed out obviously incorrect values. Non-finite numbers + // can't be represented and neither can negative zero, unless + // we're in fast math mode. + if (!F.isFinite() || + (F.isZero() && F.isNegative() && isa(I) && + !I->hasNoSignedZeros())) { + seen(I, badRange()); + Abort = true; + break; + } + + APFloat NewF = F; + auto Res = NewF.roundToIntegral(APFloat::rmNearestTiesToEven); + if (Res != APFloat::opOK || NewF.compare(F) != APFloat::cmpEqual) { + seen(I, badRange()); + Abort = true; + break; + } + // OK, it's representable. Now get it. + APSInt Int(MaxIntegerBW+1, false); + bool Exact; + CF->getValueAPF().convertToInteger(Int, + APFloat::rmNearestTiesToEven, + &Exact); + OpRanges.push_back(ConstantRange(Int)); + } else { + llvm_unreachable("Should have already marked this as badRange!"); + } + } + + // Reduce the operands' ranges to a single range and return. + if (!Abort) + seen(I, Op(OpRanges)); + } +} + +// If there is a valid transform to be done, do it. +bool Float2Int::validateAndTransform() { + bool MadeChange = false; + + // Iterate over every disjoint partition of the def-use graph. + for (auto It = ECs.begin(), E = ECs.end(); It != E; ++It) { + ConstantRange R(MaxIntegerBW + 1, false); + bool Fail = false; + Type *ConvertedToTy = nullptr; + + // For every member of the partition, union all the ranges together. + for (auto MI = ECs.member_begin(It), ME = ECs.member_end(); + MI != ME; ++MI) { + Instruction *I = *MI; + auto SeenI = SeenInsts.find(I); + if (SeenI == SeenInsts.end()) + continue; + + R = R.unionWith(SeenI->second); + // We need to ensure I has no users that have not been seen. + // If it does, transformation would be illegal. + // + // Don't count the roots, as they terminate the graphs. + if (Roots.count(I) == 0) { + // Set the type of the conversion while we're here. + if (!ConvertedToTy) + ConvertedToTy = I->getType(); + for (User *U : I->users()) { + Instruction *UI = dyn_cast(U); + if (!UI || SeenInsts.find(UI) == SeenInsts.end()) { + DEBUG(dbgs() << "F2I: Failing because of " << *U << "\n"); + Fail = true; + break; + } + } + } + if (Fail) + break; + } + + // If the set was empty, or we failed, or the range is poisonous, + // bail out. + if (ECs.member_begin(It) == ECs.member_end() || Fail || + R.isFullSet() || R.isSignWrappedSet()) + continue; + assert(ConvertedToTy && "Must have set the convertedtoty by this point!"); + + // The number of bits required is the maximum of the upper and + // lower limits, plus one so it can be signed. + unsigned MinBW = std::max(R.getLower().getMinSignedBits(), + R.getUpper().getMinSignedBits()) + 1; + DEBUG(dbgs() << "F2I: MinBitwidth=" << MinBW << ", R: " << R << "\n"); + + // If we've run off the realms of the exactly representable integers, + // the floating point result will differ from an integer approximation. + + // Do we need more bits than are in the mantissa of the type we converted + // to? semanticsPrecision returns the number of mantissa bits plus one + // for the sign bit. + unsigned MaxRepresentableBits + = APFloat::semanticsPrecision(ConvertedToTy->getFltSemantics()) - 1; + if (MinBW > MaxRepresentableBits) { + DEBUG(dbgs() << "F2I: Value not guaranteed to be representable!\n"); + continue; + } + if (MinBW > 64) { + DEBUG(dbgs() << "F2I: Value requires more than 64 bits to represent!\n"); + continue; + } + + // OK, R is known to be representable. Now pick a type for it. + // FIXME: Pick the smallest legal type that will fit. + Type *Ty = (MinBW > 32) ? Type::getInt64Ty(*Ctx) : Type::getInt32Ty(*Ctx); + + for (auto MI = ECs.member_begin(It), ME = ECs.member_end(); + MI != ME; ++MI) + convert(*MI, Ty); + MadeChange = true; + } + + return MadeChange; +} + +Value *Float2Int::convert(Instruction *I, Type *ToTy) { + if (ConvertedInsts.find(I) != ConvertedInsts.end()) + // Already converted this instruction. + return ConvertedInsts[I]; + + SmallVector NewOperands; + for (Value *V : I->operands()) { + // Don't recurse if we're an instruction that terminates the path. + if (I->getOpcode() == Instruction::UIToFP || + I->getOpcode() == Instruction::SIToFP) { + NewOperands.push_back(V); + } else if (Instruction *VI = dyn_cast(V)) { + NewOperands.push_back(convert(VI, ToTy)); + } else if (ConstantFP *CF = dyn_cast(V)) { + APSInt Val(ToTy->getPrimitiveSizeInBits(), true); + bool Exact; + CF->getValueAPF().convertToInteger(Val, + APFloat::rmNearestTiesToEven, + &Exact); + NewOperands.push_back(ConstantInt::get(ToTy, Val)); + } else { + llvm_unreachable("Unhandled operand type?"); + } + } + + // Now create a new instruction. + IRBuilder<> IRB(I); + Value *NewV = nullptr; + switch (I->getOpcode()) { + default: llvm_unreachable("Unhandled instruction!"); + + case Instruction::FPToUI: + NewV = IRB.CreateZExtOrTrunc(NewOperands[0], I->getType()); + break; + + case Instruction::FPToSI: + NewV = IRB.CreateSExtOrTrunc(NewOperands[0], I->getType()); + break; + + case Instruction::FCmp: { + CmpInst::Predicate P = mapFCmpPred(cast(I)->getPredicate()); + assert(P != CmpInst::BAD_ICMP_PREDICATE && "Unhandled predicate!"); + NewV = IRB.CreateICmp(P, NewOperands[0], NewOperands[1], I->getName()); + break; + } + + case Instruction::UIToFP: + NewV = IRB.CreateZExtOrTrunc(NewOperands[0], ToTy); + break; + + case Instruction::SIToFP: + NewV = IRB.CreateSExtOrTrunc(NewOperands[0], ToTy); + break; + + case Instruction::FAdd: + case Instruction::FSub: + case Instruction::FMul: + NewV = IRB.CreateBinOp(mapBinOpcode(I->getOpcode()), + NewOperands[0], NewOperands[1], + I->getName()); + break; + } + + // If we're a root instruction, RAUW. + if (Roots.count(I)) + I->replaceAllUsesWith(NewV); + + ConvertedInsts[I] = NewV; + return NewV; +} + +// Perform dead code elimination on the instructions we just modified. +void Float2Int::cleanup() { + for (auto I = ConvertedInsts.rbegin(), E = ConvertedInsts.rend(); + I != E; ++I) + I->first->eraseFromParent(); +} + +bool Float2Int::runOnFunction(Function &F) { + DEBUG(dbgs() << "F2I: Looking at function " << F.getName() << "\n"); + // Clear out all state. + ECs = EquivalenceClasses(); + SeenInsts.clear(); + ConvertedInsts.clear(); + Roots.clear(); + + Ctx = &F.getParent()->getContext(); + + findRoots(F, Roots); + + walkBackwards(Roots); + walkForwards(); + + bool Modified = validateAndTransform(); + if (Modified) + cleanup(); + return Modified; +} + +FunctionPass *llvm::createFloat2IntPass() { + return new Float2Int(); +} + diff --git a/lib/Transforms/Scalar/Scalar.cpp b/lib/Transforms/Scalar/Scalar.cpp index 6cc8411bb5b..b2ab40fef7e 100644 --- a/lib/Transforms/Scalar/Scalar.cpp +++ b/lib/Transforms/Scalar/Scalar.cpp @@ -77,6 +77,7 @@ void llvm::initializeScalarOpts(PassRegistry &Registry) { initializeLoadCombinePass(Registry); initializePlaceBackedgeSafepointsImplPass(Registry); initializePlaceSafepointsPass(Registry); + initializeFloat2IntPass(Registry); } void LLVMInitializeScalarOpts(LLVMPassRegistryRef R) { diff --git a/test/Transforms/Float2Int/basic.ll b/test/Transforms/Float2Int/basic.ll new file mode 100644 index 00000000000..7851474173b --- /dev/null +++ b/test/Transforms/Float2Int/basic.ll @@ -0,0 +1,242 @@ +; RUN: opt < %s -float2int -S | FileCheck %s + +; +; Positive tests +; + +; CHECK-LABEL: @simple1 +; CHECK: %1 = zext i8 %a to i32 +; CHECK: %2 = add i32 %1, 1 +; CHECK: %3 = trunc i32 %2 to i16 +; CHECK: ret i16 %3 +define i16 @simple1(i8 %a) { + %1 = uitofp i8 %a to float + %2 = fadd float %1, 1.0 + %3 = fptoui float %2 to i16 + ret i16 %3 +} + +; CHECK-LABEL: @simple2 +; CHECK: %1 = zext i8 %a to i32 +; CHECK: %2 = sub i32 %1, 1 +; CHECK: %3 = trunc i32 %2 to i8 +; CHECK: ret i8 %3 +define i8 @simple2(i8 %a) { + %1 = uitofp i8 %a to float + %2 = fsub float %1, 1.0 + %3 = fptoui float %2 to i8 + ret i8 %3 +} + +; CHECK-LABEL: @simple3 +; CHECK: %1 = zext i8 %a to i32 +; CHECK: %2 = sub i32 %1, 1 +; CHECK: ret i32 %2 +define i32 @simple3(i8 %a) { + %1 = uitofp i8 %a to float + %2 = fsub float %1, 1.0 + %3 = fptoui float %2 to i32 + ret i32 %3 +} + +; CHECK-LABEL: @cmp +; CHECK: %1 = zext i8 %a to i32 +; CHECK: %2 = zext i8 %b to i32 +; CHECK: %3 = icmp slt i32 %1, %2 +; CHECK: ret i1 %3 +define i1 @cmp(i8 %a, i8 %b) { + %1 = uitofp i8 %a to float + %2 = uitofp i8 %b to float + %3 = fcmp ult float %1, %2 + ret i1 %3 +} + +; CHECK-LABEL: @simple4 +; CHECK: %1 = zext i32 %a to i64 +; CHECK: %2 = add i64 %1, 1 +; CHECK: %3 = trunc i64 %2 to i32 +; CHECK: ret i32 %3 +define i32 @simple4(i32 %a) { + %1 = uitofp i32 %a to double + %2 = fadd double %1, 1.0 + %3 = fptoui double %2 to i32 + ret i32 %3 +} + +; CHECK-LABEL: @simple5 +; CHECK: %1 = zext i8 %a to i32 +; CHECK: %2 = zext i8 %b to i32 +; CHECK: %3 = add i32 %1, 1 +; CHECK: %4 = mul i32 %3, %2 +; CHECK: ret i32 %4 +define i32 @simple5(i8 %a, i8 %b) { + %1 = uitofp i8 %a to float + %2 = uitofp i8 %b to float + %3 = fadd float %1, 1.0 + %4 = fmul float %3, %2 + %5 = fptoui float %4 to i32 + ret i32 %5 +} + +; The two chains don't interact - failure of one shouldn't +; cause failure of the other. + +; CHECK-LABEL: @multi1 +; CHECK: %1 = zext i8 %a to i32 +; CHECK: %2 = zext i8 %b to i32 +; CHECK: %fc = uitofp i8 %c to float +; CHECK: %x1 = add i32 %1, %2 +; CHECK: %z = fadd float %fc, %d +; CHECK: %w = fptoui float %z to i32 +; CHECK: %r = add i32 %x1, %w +; CHECK: ret i32 %r +define i32 @multi1(i8 %a, i8 %b, i8 %c, float %d) { + %fa = uitofp i8 %a to float + %fb = uitofp i8 %b to float + %fc = uitofp i8 %c to float + %x = fadd float %fa, %fb + %y = fptoui float %x to i32 + %z = fadd float %fc, %d + %w = fptoui float %z to i32 + %r = add i32 %y, %w + ret i32 %r +} + +; CHECK-LABEL: @simple_negzero +; CHECK: %1 = zext i8 %a to i32 +; CHECK: %2 = add i32 %1, 0 +; CHECK: %3 = trunc i32 %2 to i16 +; CHECK: ret i16 %3 +define i16 @simple_negzero(i8 %a) { + %1 = uitofp i8 %a to float + %2 = fadd fast float %1, -0.0 + %3 = fptoui float %2 to i16 + ret i16 %3 +} + +; +; Negative tests +; + +; CHECK-LABEL: @neg_multi1 +; CHECK: %fa = uitofp i8 %a to float +; CHECK: %fc = uitofp i8 %c to float +; CHECK: %x = fadd float %fa, %fc +; CHECK: %y = fptoui float %x to i32 +; CHECK: %z = fadd float %fc, %d +; CHECK: %w = fptoui float %z to i32 +; CHECK: %r = add i32 %y, %w +; CHECK: ret i32 %r +; The two chains intersect, which means because one fails, no +; transform can occur. +define i32 @neg_multi1(i8 %a, i8 %b, i8 %c, float %d) { + %fa = uitofp i8 %a to float + %fc = uitofp i8 %c to float + %x = fadd float %fa, %fc + %y = fptoui float %x to i32 + %z = fadd float %fc, %d + %w = fptoui float %z to i32 + %r = add i32 %y, %w + ret i32 %r +} + +; CHECK-LABEL: @neg_muld +; CHECK: %fa = uitofp i32 %a to double +; CHECK: %fb = uitofp i32 %b to double +; CHECK: %mul = fmul double %fa, %fb +; CHECK: %r = fptoui double %mul to i64 +; CHECK: ret i64 %r +; The i32 * i32 = i64, which has 64 bits, which is greater than the 52 bits +; that can be exactly represented in a double. +define i64 @neg_muld(i32 %a, i32 %b) { + %fa = uitofp i32 %a to double + %fb = uitofp i32 %b to double + %mul = fmul double %fa, %fb + %r = fptoui double %mul to i64 + ret i64 %r +} + +; CHECK-LABEL: @neg_mulf +; CHECK: %fa = uitofp i16 %a to float +; CHECK: %fb = uitofp i16 %b to float +; CHECK: %mul = fmul float %fa, %fb +; CHECK: %r = fptoui float %mul to i32 +; CHECK: ret i32 %r +; The i16 * i16 = i32, which can't be represented in a float, but can in a +; double. This should fail, as the written code uses floats, not doubles so +; the original result may be inaccurate. +define i32 @neg_mulf(i16 %a, i16 %b) { + %fa = uitofp i16 %a to float + %fb = uitofp i16 %b to float + %mul = fmul float %fa, %fb + %r = fptoui float %mul to i32 + ret i32 %r +} + +; CHECK-LABEL: @neg_cmp +; CHECK: %1 = uitofp i8 %a to float +; CHECK: %2 = uitofp i8 %b to float +; CHECK: %3 = fcmp false float %1, %2 +; CHECK: ret i1 %3 +; "false" doesn't have an icmp equivalent. +define i1 @neg_cmp(i8 %a, i8 %b) { + %1 = uitofp i8 %a to float + %2 = uitofp i8 %b to float + %3 = fcmp false float %1, %2 + ret i1 %3 +} + +; CHECK-LABEL: @neg_div +; CHECK: %1 = uitofp i8 %a to float +; CHECK: %2 = fdiv float %1, 1.0 +; CHECK: %3 = fptoui float %2 to i16 +; CHECK: ret i16 %3 +; Division isn't a supported operator. +define i16 @neg_div(i8 %a) { + %1 = uitofp i8 %a to float + %2 = fdiv float %1, 1.0 + %3 = fptoui float %2 to i16 + ret i16 %3 +} + +; CHECK-LABEL: @neg_remainder +; CHECK: %1 = uitofp i8 %a to float +; CHECK: %2 = fadd float %1, 1.2 +; CHECK: %3 = fptoui float %2 to i16 +; CHECK: ret i16 %3 +; 1.2 is not an integer. +define i16 @neg_remainder(i8 %a) { + %1 = uitofp i8 %a to float + %2 = fadd float %1, 1.25 + %3 = fptoui float %2 to i16 + ret i16 %3 +} + +; CHECK-LABEL: @neg_toolarge +; CHECK: %1 = uitofp i80 %a to fp128 +; CHECK: %2 = fadd fp128 %1, %1 +; CHECK: %3 = fptoui fp128 %2 to i80 +; CHECK: ret i80 %3 +; i80 > i64, which is the largest bitwidth handleable by default. +define i80 @neg_toolarge(i80 %a) { + %1 = uitofp i80 %a to fp128 + %2 = fadd fp128 %1, %1 + %3 = fptoui fp128 %2 to i80 + ret i80 %3 +} + +; CHECK-LABEL: @neg_calluser +; CHECK: sitofp +; CHECK: fcmp +; The sequence %1..%3 cannot be converted because %4 uses %2. +define i32 @neg_calluser(i32 %value) { + %1 = sitofp i32 %value to double + %2 = fadd double %1, 1.0 + %3 = fcmp olt double %2, 0.000000e+00 + %4 = tail call double @g(double %2) + %5 = fptosi double %4 to i32 + %6 = zext i1 %3 to i32 + %7 = add i32 %6, %5 + ret i32 %7 +} +declare double @g(double) \ No newline at end of file diff --git a/test/Transforms/Float2Int/toolarge.ll b/test/Transforms/Float2Int/toolarge.ll new file mode 100644 index 00000000000..b5d77815768 --- /dev/null +++ b/test/Transforms/Float2Int/toolarge.ll @@ -0,0 +1,16 @@ +; RUN: opt < %s -float2int -float2int-max-integer-bw=256 -S | FileCheck %s + +; CHECK-LABEL: @neg_toolarge +; CHECK: %1 = uitofp i80 %a to fp128 +; CHECK: %2 = fadd fp128 %1, %1 +; CHECK: %3 = fptoui fp128 %2 to i80 +; CHECK: ret i80 %3 +; fp128 has a 112-bit mantissa, which can hold an i80. But we only support +; up to i64, so it should fail (even though the max integer bitwidth is 256). +define i80 @neg_toolarge(i80 %a) { + %1 = uitofp i80 %a to fp128 + %2 = fadd fp128 %1, %1 + %3 = fptoui fp128 %2 to i80 + ret i80 %3 +} +