#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/Analysis/AliasAnalysis.h"
#include "llvm/Analysis/GlobalsModRef.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 <deque>
#include <functional> // For std::function
using namespace llvm;
static cl::opt<unsigned>
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; Float2Int() : FunctionPass(ID) {
initializeFloat2IntPass(*PassRegistry::getPassRegistry());
}
bool runOnFunction(Function &F) override;
void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.setPreservesCFG();
AU.addPreserved<GlobalsAAWrapperPass>();
}
void findRoots(Function &F, SmallPtrSet<Instruction*,8> &Roots);
ConstantRange seen(Instruction *I, ConstantRange R);
ConstantRange badRange();
ConstantRange unknownRange();
ConstantRange validateRange(ConstantRange R);
void walkBackwards(const SmallPtrSetImpl<Instruction*> &Roots);
void walkForwards();
bool validateAndTransform();
Value *convert(Instruction *I, Type *ToTy);
void cleanup();
MapVector<Instruction*, ConstantRange > SeenInsts;
SmallPtrSet<Instruction*,8> Roots;
EquivalenceClasses<Instruction*> ECs;
MapVector<Instruction*, Value*> ConvertedInsts;
LLVMContext *Ctx;
};
}
char Float2Int::ID = 0;
INITIALIZE_PASS_BEGIN(Float2Int, "float2int", "Float to int", false, false)
INITIALIZE_PASS_DEPENDENCY(GlobalsAAWrapperPass)
INITIALIZE_PASS_END(Float2Int, "float2int", "Float to int", false, false)
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;
}
}
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;
}
}
void Float2Int::findRoots(Function &F, SmallPtrSet<Instruction*,8> &Roots) {
for (auto &I : instructions(F)) {
switch (I.getOpcode()) {
default: break;
case Instruction::FPToUI:
case Instruction::FPToSI:
Roots.insert(&I);
break;
case Instruction::FCmp:
if (mapFCmpPred(cast<CmpInst>(&I)->getPredicate()) !=
CmpInst::BAD_ICMP_PREDICATE)
Roots.insert(&I);
break;
}
}
}
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;
}
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;
}
void Float2Int::walkBackwards(const SmallPtrSetImpl<Instruction*> &Roots) {
std::deque<Instruction*> Worklist(Roots.begin(), Roots.end());
while (!Worklist.empty()) {
Instruction *I = Worklist.back();
Worklist.pop_back();
if (SeenInsts.find(I) != SeenInsts.end())
continue;
switch (I->getOpcode()) {
default:
seen(I, badRange());
break;
case Instruction::UIToFP: {
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: {
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<Instruction>(O)) {
ECs.unionSets(I, OI);
if (SeenInsts.find(I)->second != badRange())
Worklist.push_back(OI);
} else if (!isa<ConstantFP>(O)) {
seen(I, badRange());
}
}
}
}
void Float2Int::walkForwards() {
for (auto &It : make_range(SeenInsts.rbegin(), SeenInsts.rend())) {
if (It.second != unknownRange())
continue;
Instruction *I = It.first;
std::function<ConstantRange(ArrayRef<ConstantRange>)> Op;
switch (I->getOpcode()) {
default:
case Instruction::UIToFP:
case Instruction::SIToFP:
llvm_unreachable("Should have been handled in walkForwards!");
case Instruction::FAdd:
Op = [](ArrayRef<ConstantRange> Ops) {
assert(Ops.size() == 2 && "FAdd is a binary operator!");
return Ops[0].add(Ops[1]);
};
break;
case Instruction::FSub:
Op = [](ArrayRef<ConstantRange> Ops) {
assert(Ops.size() == 2 && "FSub is a binary operator!");
return Ops[0].sub(Ops[1]);
};
break;
case Instruction::FMul:
Op = [](ArrayRef<ConstantRange> Ops) {
assert(Ops.size() == 2 && "FMul is a binary operator!");
return Ops[0].multiply(Ops[1]);
};
break;
case Instruction::FPToUI:
case Instruction::FPToSI:
Op = [](ArrayRef<ConstantRange> Ops) {
assert(Ops.size() == 1 && "FPTo[US]I is a unary operator!");
return Ops[0];
};
break;
case Instruction::FCmp:
Op = [](ArrayRef<ConstantRange> Ops) {
assert(Ops.size() == 2 && "FCmp is a binary operator!");
return Ops[0].unionWith(Ops[1]);
};
break;
}
bool Abort = false;
SmallVector<ConstantRange,4> OpRanges;
for (Value *O : I->operands()) {
if (Instruction *OI = dyn_cast<Instruction>(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<ConstantFP>(O)) {
APFloat F = CF->getValueAPF();
if (!F.isFinite() ||
(F.isZero() && F.isNegative() && isa<FPMathOperator>(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;
}
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!");
}
}
if (!Abort)
seen(I, Op(OpRanges));
}
}
bool Float2Int::validateAndTransform() {
bool MadeChange = false;
for (auto It = ECs.begin(), E = ECs.end(); It != E; ++It) {
ConstantRange R(MaxIntegerBW + 1, false);
bool Fail = false;
Type *ConvertedToTy = nullptr;
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);
if (Roots.count(I) == 0) {
if (!ConvertedToTy)
ConvertedToTy = I->getType();
for (User *U : I->users()) {
Instruction *UI = dyn_cast<Instruction>(U);
if (!UI || SeenInsts.find(UI) == SeenInsts.end()) {
DEBUG(dbgs() << "F2I: Failing because of " << *U << "\n");
Fail = true;
break;
}
}
}
if (Fail)
break;
}
if (ECs.member_begin(It) == ECs.member_end() || Fail ||
R.isFullSet() || R.isSignWrappedSet())
continue;
assert(ConvertedToTy && "Must have set the convertedtoty by this point!");
unsigned MinBW = std::max(R.getLower().getMinSignedBits(),
R.getUpper().getMinSignedBits()) + 1;
DEBUG(dbgs() << "F2I: MinBitwidth=" << MinBW << ", R: " << R << "\n");
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;
}
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())
return ConvertedInsts[I];
SmallVector<Value*,4> NewOperands;
for (Value *V : I->operands()) {
if (I->getOpcode() == Instruction::UIToFP ||
I->getOpcode() == Instruction::SIToFP) {
NewOperands.push_back(V);
} else if (Instruction *VI = dyn_cast<Instruction>(V)) {
NewOperands.push_back(convert(VI, ToTy));
} else if (ConstantFP *CF = dyn_cast<ConstantFP>(V)) {
APSInt Val(ToTy->getPrimitiveSizeInBits(), false);
bool Exact;
CF->getValueAPF().convertToInteger(Val,
APFloat::rmNearestTiesToEven,
&Exact);
NewOperands.push_back(ConstantInt::get(ToTy, Val));
} else {
llvm_unreachable("Unhandled operand type?");
}
}
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<CmpInst>(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 (Roots.count(I))
I->replaceAllUsesWith(NewV);
ConvertedInsts[I] = NewV;
return NewV;
}
void Float2Int::cleanup() {
for (auto &I : make_range(ConvertedInsts.rbegin(), ConvertedInsts.rend()))
I.first->eraseFromParent();
}
bool Float2Int::runOnFunction(Function &F) {
if (skipOptnoneFunction(F))
return false;
DEBUG(dbgs() << "F2I: Looking at function " << F.getName() << "\n");
ECs = EquivalenceClasses<Instruction*>();
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(); }