LLVM  9.0.0svn
Float2Int.cpp
Go to the documentation of this file.
1 //===- Float2Int.cpp - Demote floating point ops to work on integers ------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the Float2Int pass, which aims to demote floating
10 // point operations to work on integers, where that is losslessly possible.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #define DEBUG_TYPE "float2int"
15 
17 #include "llvm/ADT/APInt.h"
18 #include "llvm/ADT/APSInt.h"
19 #include "llvm/ADT/SmallVector.h"
22 #include "llvm/IR/Constants.h"
23 #include "llvm/IR/IRBuilder.h"
24 #include "llvm/IR/InstIterator.h"
25 #include "llvm/IR/Instructions.h"
26 #include "llvm/IR/Module.h"
27 #include "llvm/Pass.h"
28 #include "llvm/Support/Debug.h"
30 #include "llvm/Transforms/Scalar.h"
31 #include <deque>
32 #include <functional> // For std::function
33 using namespace llvm;
34 
35 // The algorithm is simple. Start at instructions that convert from the
36 // float to the int domain: fptoui, fptosi and fcmp. Walk up the def-use
37 // graph, using an equivalence datastructure to unify graphs that interfere.
38 //
39 // Mappable instructions are those with an integer corrollary that, given
40 // integer domain inputs, produce an integer output; fadd, for example.
41 //
42 // If a non-mappable instruction is seen, this entire def-use graph is marked
43 // as non-transformable. If we see an instruction that converts from the
44 // integer domain to FP domain (uitofp,sitofp), we terminate our walk.
45 
46 /// The largest integer type worth dealing with.
47 static cl::opt<unsigned>
48 MaxIntegerBW("float2int-max-integer-bw", cl::init(64), cl::Hidden,
49  cl::desc("Max integer bitwidth to consider in float2int"
50  "(default=64)"));
51 
52 namespace {
53  struct Float2IntLegacyPass : public FunctionPass {
54  static char ID; // Pass identification, replacement for typeid
55  Float2IntLegacyPass() : FunctionPass(ID) {
57  }
58 
59  bool runOnFunction(Function &F) override {
60  if (skipFunction(F))
61  return false;
62 
63  return Impl.runImpl(F);
64  }
65 
66  void getAnalysisUsage(AnalysisUsage &AU) const override {
67  AU.setPreservesCFG();
69  }
70 
71  private:
72  Float2IntPass Impl;
73  };
74 }
75 
77 INITIALIZE_PASS(Float2IntLegacyPass, "float2int", "Float to int", false, false)
78 
79 // Given a FCmp predicate, return a matching ICmp predicate if one
80 // exists, otherwise return BAD_ICMP_PREDICATE.
82  switch (P) {
83  case CmpInst::FCMP_OEQ:
84  case CmpInst::FCMP_UEQ:
85  return CmpInst::ICMP_EQ;
86  case CmpInst::FCMP_OGT:
87  case CmpInst::FCMP_UGT:
88  return CmpInst::ICMP_SGT;
89  case CmpInst::FCMP_OGE:
90  case CmpInst::FCMP_UGE:
91  return CmpInst::ICMP_SGE;
92  case CmpInst::FCMP_OLT:
93  case CmpInst::FCMP_ULT:
94  return CmpInst::ICMP_SLT;
95  case CmpInst::FCMP_OLE:
96  case CmpInst::FCMP_ULE:
97  return CmpInst::ICMP_SLE;
98  case CmpInst::FCMP_ONE:
99  case CmpInst::FCMP_UNE:
100  return CmpInst::ICMP_NE;
101  default:
103  }
104 }
105 
106 // Given a floating point binary operator, return the matching
107 // integer version.
108 static Instruction::BinaryOps mapBinOpcode(unsigned Opcode) {
109  switch (Opcode) {
110  default: llvm_unreachable("Unhandled opcode!");
111  case Instruction::FAdd: return Instruction::Add;
112  case Instruction::FSub: return Instruction::Sub;
113  case Instruction::FMul: return Instruction::Mul;
114  }
115 }
116 
117 // Find the roots - instructions that convert from the FP domain to
118 // integer domain.
119 void Float2IntPass::findRoots(Function &F, SmallPtrSet<Instruction*,8> &Roots) {
120  for (auto &I : instructions(F)) {
121  if (isa<VectorType>(I.getType()))
122  continue;
123  switch (I.getOpcode()) {
124  default: break;
125  case Instruction::FPToUI:
126  case Instruction::FPToSI:
127  Roots.insert(&I);
128  break;
129  case Instruction::FCmp:
130  if (mapFCmpPred(cast<CmpInst>(&I)->getPredicate()) !=
132  Roots.insert(&I);
133  break;
134  }
135  }
136 }
137 
138 // Helper - mark I as having been traversed, having range R.
139 void Float2IntPass::seen(Instruction *I, ConstantRange R) {
140  LLVM_DEBUG(dbgs() << "F2I: " << *I << ":" << R << "\n");
141  auto IT = SeenInsts.find(I);
142  if (IT != SeenInsts.end())
143  IT->second = std::move(R);
144  else
145  SeenInsts.insert(std::make_pair(I, std::move(R)));
146 }
147 
148 // Helper - get a range representing a poison value.
149 ConstantRange Float2IntPass::badRange() {
150  return ConstantRange::getFull(MaxIntegerBW + 1);
151 }
152 ConstantRange Float2IntPass::unknownRange() {
153  return ConstantRange::getEmpty(MaxIntegerBW + 1);
154 }
155 ConstantRange Float2IntPass::validateRange(ConstantRange R) {
156  if (R.getBitWidth() > MaxIntegerBW + 1)
157  return badRange();
158  return R;
159 }
160 
161 // The most obvious way to structure the search is a depth-first, eager
162 // search from each root. However, that require direct recursion and so
163 // can only handle small instruction sequences. Instead, we split the search
164 // up into two phases:
165 // - walkBackwards: A breadth-first walk of the use-def graph starting from
166 // the roots. Populate "SeenInsts" with interesting
167 // instructions and poison values if they're obvious and
168 // cheap to compute. Calculate the equivalance set structure
169 // while we're here too.
170 // - walkForwards: Iterate over SeenInsts in reverse order, so we visit
171 // defs before their uses. Calculate the real range info.
172 
173 // Breadth-first walk of the use-def graph; determine the set of nodes
174 // we care about and eagerly determine if some of them are poisonous.
175 void Float2IntPass::walkBackwards(const SmallPtrSetImpl<Instruction*> &Roots) {
176  std::deque<Instruction*> Worklist(Roots.begin(), Roots.end());
177  while (!Worklist.empty()) {
178  Instruction *I = Worklist.back();
179  Worklist.pop_back();
180 
181  if (SeenInsts.find(I) != SeenInsts.end())
182  // Seen already.
183  continue;
184 
185  switch (I->getOpcode()) {
186  // FIXME: Handle select and phi nodes.
187  default:
188  // Path terminated uncleanly.
189  seen(I, badRange());
190  break;
191 
192  case Instruction::UIToFP:
193  case Instruction::SIToFP: {
194  // Path terminated cleanly - use the type of the integer input to seed
195  // the analysis.
196  unsigned BW = I->getOperand(0)->getType()->getPrimitiveSizeInBits();
197  auto Input = ConstantRange::getFull(BW);
198  auto CastOp = (Instruction::CastOps)I->getOpcode();
199  seen(I, validateRange(Input.castOp(CastOp, MaxIntegerBW+1)));
200  continue;
201  }
202 
203  case Instruction::FAdd:
204  case Instruction::FSub:
205  case Instruction::FMul:
206  case Instruction::FPToUI:
207  case Instruction::FPToSI:
208  case Instruction::FCmp:
209  seen(I, unknownRange());
210  break;
211  }
212 
213  for (Value *O : I->operands()) {
214  if (Instruction *OI = dyn_cast<Instruction>(O)) {
215  // Unify def-use chains if they interfere.
216  ECs.unionSets(I, OI);
217  if (SeenInsts.find(I)->second != badRange())
218  Worklist.push_back(OI);
219  } else if (!isa<ConstantFP>(O)) {
220  // Not an instruction or ConstantFP? we can't do anything.
221  seen(I, badRange());
222  }
223  }
224  }
225 }
226 
227 // Walk forwards down the list of seen instructions, so we visit defs before
228 // uses.
229 void Float2IntPass::walkForwards() {
230  for (auto &It : reverse(SeenInsts)) {
231  if (It.second != unknownRange())
232  continue;
233 
234  Instruction *I = It.first;
235  std::function<ConstantRange(ArrayRef<ConstantRange>)> Op;
236  switch (I->getOpcode()) {
237  // FIXME: Handle select and phi nodes.
238  default:
239  case Instruction::UIToFP:
240  case Instruction::SIToFP:
241  llvm_unreachable("Should have been handled in walkForwards!");
242 
243  case Instruction::FAdd:
244  case Instruction::FSub:
245  case Instruction::FMul:
246  Op = [I](ArrayRef<ConstantRange> Ops) {
247  assert(Ops.size() == 2 && "its a binary operator!");
248  auto BinOp = (Instruction::BinaryOps) I->getOpcode();
249  return Ops[0].binaryOp(BinOp, Ops[1]);
250  };
251  break;
252 
253  //
254  // Root-only instructions - we'll only see these if they're the
255  // first node in a walk.
256  //
257  case Instruction::FPToUI:
258  case Instruction::FPToSI:
259  Op = [I](ArrayRef<ConstantRange> Ops) {
260  assert(Ops.size() == 1 && "FPTo[US]I is a unary operator!");
261  // Note: We're ignoring the casts output size here as that's what the
262  // caller expects.
263  auto CastOp = (Instruction::CastOps)I->getOpcode();
264  return Ops[0].castOp(CastOp, MaxIntegerBW+1);
265  };
266  break;
267 
268  case Instruction::FCmp:
269  Op = [](ArrayRef<ConstantRange> Ops) {
270  assert(Ops.size() == 2 && "FCmp is a binary operator!");
271  return Ops[0].unionWith(Ops[1]);
272  };
273  break;
274  }
275 
276  bool Abort = false;
278  for (Value *O : I->operands()) {
279  if (Instruction *OI = dyn_cast<Instruction>(O)) {
280  assert(SeenInsts.find(OI) != SeenInsts.end() &&
281  "def not seen before use!");
282  OpRanges.push_back(SeenInsts.find(OI)->second);
283  } else if (ConstantFP *CF = dyn_cast<ConstantFP>(O)) {
284  // Work out if the floating point number can be losslessly represented
285  // as an integer.
286  // APFloat::convertToInteger(&Exact) purports to do what we want, but
287  // the exactness can be too precise. For example, negative zero can
288  // never be exactly converted to an integer.
289  //
290  // Instead, we ask APFloat to round itself to an integral value - this
291  // preserves sign-of-zero - then compare the result with the original.
292  //
293  const APFloat &F = CF->getValueAPF();
294 
295  // First, weed out obviously incorrect values. Non-finite numbers
296  // can't be represented and neither can negative zero, unless
297  // we're in fast math mode.
298  if (!F.isFinite() ||
299  (F.isZero() && F.isNegative() && isa<FPMathOperator>(I) &&
300  !I->hasNoSignedZeros())) {
301  seen(I, badRange());
302  Abort = true;
303  break;
304  }
305 
306  APFloat NewF = F;
308  if (Res != APFloat::opOK || NewF.compare(F) != APFloat::cmpEqual) {
309  seen(I, badRange());
310  Abort = true;
311  break;
312  }
313  // OK, it's representable. Now get it.
314  APSInt Int(MaxIntegerBW+1, false);
315  bool Exact;
316  CF->getValueAPF().convertToInteger(Int,
318  &Exact);
319  OpRanges.push_back(ConstantRange(Int));
320  } else {
321  llvm_unreachable("Should have already marked this as badRange!");
322  }
323  }
324 
325  // Reduce the operands' ranges to a single range and return.
326  if (!Abort)
327  seen(I, Op(OpRanges));
328  }
329 }
330 
331 // If there is a valid transform to be done, do it.
332 bool Float2IntPass::validateAndTransform() {
333  bool MadeChange = false;
334 
335  // Iterate over every disjoint partition of the def-use graph.
336  for (auto It = ECs.begin(), E = ECs.end(); It != E; ++It) {
337  ConstantRange R(MaxIntegerBW + 1, false);
338  bool Fail = false;
339  Type *ConvertedToTy = nullptr;
340 
341  // For every member of the partition, union all the ranges together.
342  for (auto MI = ECs.member_begin(It), ME = ECs.member_end();
343  MI != ME; ++MI) {
344  Instruction *I = *MI;
345  auto SeenI = SeenInsts.find(I);
346  if (SeenI == SeenInsts.end())
347  continue;
348 
349  R = R.unionWith(SeenI->second);
350  // We need to ensure I has no users that have not been seen.
351  // If it does, transformation would be illegal.
352  //
353  // Don't count the roots, as they terminate the graphs.
354  if (Roots.count(I) == 0) {
355  // Set the type of the conversion while we're here.
356  if (!ConvertedToTy)
357  ConvertedToTy = I->getType();
358  for (User *U : I->users()) {
359  Instruction *UI = dyn_cast<Instruction>(U);
360  if (!UI || SeenInsts.find(UI) == SeenInsts.end()) {
361  LLVM_DEBUG(dbgs() << "F2I: Failing because of " << *U << "\n");
362  Fail = true;
363  break;
364  }
365  }
366  }
367  if (Fail)
368  break;
369  }
370 
371  // If the set was empty, or we failed, or the range is poisonous,
372  // bail out.
373  if (ECs.member_begin(It) == ECs.member_end() || Fail ||
374  R.isFullSet() || R.isSignWrappedSet())
375  continue;
376  assert(ConvertedToTy && "Must have set the convertedtoty by this point!");
377 
378  // The number of bits required is the maximum of the upper and
379  // lower limits, plus one so it can be signed.
380  unsigned MinBW = std::max(R.getLower().getMinSignedBits(),
381  R.getUpper().getMinSignedBits()) + 1;
382  LLVM_DEBUG(dbgs() << "F2I: MinBitwidth=" << MinBW << ", R: " << R << "\n");
383 
384  // If we've run off the realms of the exactly representable integers,
385  // the floating point result will differ from an integer approximation.
386 
387  // Do we need more bits than are in the mantissa of the type we converted
388  // to? semanticsPrecision returns the number of mantissa bits plus one
389  // for the sign bit.
390  unsigned MaxRepresentableBits
391  = APFloat::semanticsPrecision(ConvertedToTy->getFltSemantics()) - 1;
392  if (MinBW > MaxRepresentableBits) {
393  LLVM_DEBUG(dbgs() << "F2I: Value not guaranteed to be representable!\n");
394  continue;
395  }
396  if (MinBW > 64) {
397  LLVM_DEBUG(
398  dbgs() << "F2I: Value requires more than 64 bits to represent!\n");
399  continue;
400  }
401 
402  // OK, R is known to be representable. Now pick a type for it.
403  // FIXME: Pick the smallest legal type that will fit.
404  Type *Ty = (MinBW > 32) ? Type::getInt64Ty(*Ctx) : Type::getInt32Ty(*Ctx);
405 
406  for (auto MI = ECs.member_begin(It), ME = ECs.member_end();
407  MI != ME; ++MI)
408  convert(*MI, Ty);
409  MadeChange = true;
410  }
411 
412  return MadeChange;
413 }
414 
415 Value *Float2IntPass::convert(Instruction *I, Type *ToTy) {
416  if (ConvertedInsts.find(I) != ConvertedInsts.end())
417  // Already converted this instruction.
418  return ConvertedInsts[I];
419 
420  SmallVector<Value*,4> NewOperands;
421  for (Value *V : I->operands()) {
422  // Don't recurse if we're an instruction that terminates the path.
423  if (I->getOpcode() == Instruction::UIToFP ||
424  I->getOpcode() == Instruction::SIToFP) {
425  NewOperands.push_back(V);
426  } else if (Instruction *VI = dyn_cast<Instruction>(V)) {
427  NewOperands.push_back(convert(VI, ToTy));
428  } else if (ConstantFP *CF = dyn_cast<ConstantFP>(V)) {
429  APSInt Val(ToTy->getPrimitiveSizeInBits(), /*IsUnsigned=*/false);
430  bool Exact;
431  CF->getValueAPF().convertToInteger(Val,
433  &Exact);
434  NewOperands.push_back(ConstantInt::get(ToTy, Val));
435  } else {
436  llvm_unreachable("Unhandled operand type?");
437  }
438  }
439 
440  // Now create a new instruction.
441  IRBuilder<> IRB(I);
442  Value *NewV = nullptr;
443  switch (I->getOpcode()) {
444  default: llvm_unreachable("Unhandled instruction!");
445 
446  case Instruction::FPToUI:
447  NewV = IRB.CreateZExtOrTrunc(NewOperands[0], I->getType());
448  break;
449 
450  case Instruction::FPToSI:
451  NewV = IRB.CreateSExtOrTrunc(NewOperands[0], I->getType());
452  break;
453 
454  case Instruction::FCmp: {
455  CmpInst::Predicate P = mapFCmpPred(cast<CmpInst>(I)->getPredicate());
456  assert(P != CmpInst::BAD_ICMP_PREDICATE && "Unhandled predicate!");
457  NewV = IRB.CreateICmp(P, NewOperands[0], NewOperands[1], I->getName());
458  break;
459  }
460 
461  case Instruction::UIToFP:
462  NewV = IRB.CreateZExtOrTrunc(NewOperands[0], ToTy);
463  break;
464 
465  case Instruction::SIToFP:
466  NewV = IRB.CreateSExtOrTrunc(NewOperands[0], ToTy);
467  break;
468 
469  case Instruction::FAdd:
470  case Instruction::FSub:
471  case Instruction::FMul:
472  NewV = IRB.CreateBinOp(mapBinOpcode(I->getOpcode()),
473  NewOperands[0], NewOperands[1],
474  I->getName());
475  break;
476  }
477 
478  // If we're a root instruction, RAUW.
479  if (Roots.count(I))
480  I->replaceAllUsesWith(NewV);
481 
482  ConvertedInsts[I] = NewV;
483  return NewV;
484 }
485 
486 // Perform dead code elimination on the instructions we just modified.
487 void Float2IntPass::cleanup() {
488  for (auto &I : reverse(ConvertedInsts))
489  I.first->eraseFromParent();
490 }
491 
493  LLVM_DEBUG(dbgs() << "F2I: Looking at function " << F.getName() << "\n");
494  // Clear out all state.
496  SeenInsts.clear();
497  ConvertedInsts.clear();
498  Roots.clear();
499 
500  Ctx = &F.getParent()->getContext();
501 
502  findRoots(F, Roots);
503 
504  walkBackwards(Roots);
505  walkForwards();
506 
507  bool Modified = validateAndTransform();
508  if (Modified)
509  cleanup();
510  return Modified;
511 }
512 
513 namespace llvm {
514 FunctionPass *createFloat2IntPass() { return new Float2IntLegacyPass(); }
515 
517  if (!runImpl(F))
518  return PreservedAnalyses::all();
519 
521  PA.preserveSet<CFGAnalyses>();
522  PA.preserve<GlobalsAA>();
523  return PA;
524 }
525 } // End namespace llvm
Legacy wrapper pass to provide the GlobalsAAResult object.
opStatus roundToIntegral(roundingMode RM)
Definition: APFloat.h:1007
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks &#39;this&#39; from the containing basic block and deletes it.
Definition: Instruction.cpp:67
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)"))
The largest integer type worth dealing with.
Value * CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1984
This class is the base class for the comparison instructions.
Definition: InstrTypes.h:699
static bool runImpl(Function &F, TargetLibraryInfo &TLI, DominatorTree &DT)
This is the entry point for all transforms.
bool isZero() const
Definition: APFloat.h:1142
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
bool hasNoSignedZeros() const
Determine whether the no-signed-zeros flag is set.
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
Value * CreateBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:1333
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
Value * CreateZExtOrTrunc(Value *V, Type *DestTy, const Twine &Name="")
Create a ZExt or Trunc from the integer value V to DestTy.
Definition: IRBuilder.h:1704
This class represents lattice values for constants.
Definition: AllocatorList.h:23
const APInt & getUpper() const
Return the upper value for this range.
This is the interface for a simple mod/ref and alias analysis over globals.
FunctionPass * createFloat2IntPass()
Definition: Float2Int.cpp:514
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:715
1 1 1 0 True if unordered or not equal
Definition: InstrTypes.h:725
F(f)
static void cleanup(BlockFrequencyInfoImplBase &BFI)
Clear all memory not needed downstream.
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:176
bool runImpl(Function &F)
Definition: Float2Int.cpp:492
1 0 0 1 True if unordered or equal
Definition: InstrTypes.h:720
uint32_t getBitWidth() const
Get the bit width of this ConstantRange.
#define Fail
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:244
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:742
0 1 0 1 True if ordered and less than or equal
Definition: InstrTypes.h:716
This file implements a class to represent arbitrary precision integral constant values and operations...
auto reverse(ContainerTy &&C, typename std::enable_if< has_rbegin< ContainerTy >::value >::type *=nullptr) -> decltype(make_range(C.rbegin(), C.rend()))
Definition: STLExtras.h:266
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:244
Value * CreateSExtOrTrunc(Value *V, Type *DestTy, const Twine &Name="")
Create a SExt or Trunc from the integer value V to DestTy.
Definition: IRBuilder.h:1719
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:125
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:429
Value * getOperand(unsigned i) const
Definition: User.h:169
static CmpInst::Predicate mapFCmpPred(CmpInst::Predicate P)
Definition: Float2Int.cpp:81
static bool runOnFunction(Function &F, bool PostInlining)
#define P(N)
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:432
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:153
bool isNegative() const
Definition: APFloat.h:1146
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
bool isSignWrappedSet() const
Return true if this set wraps around the signed domain.
This file contains the declarations for the subclasses of Constant, which represent the different fla...
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:263
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:370
EquivalenceClasses - This represents a collection of equivalence classes and supports three efficient...
Represent the analysis usage information of a pass.
Analysis pass providing a never-invalidated alias analysis result.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:709
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:284
op_range operands()
Definition: User.h:237
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:381
bool isFullSet() const
Return true if this set contains all of the elements possible for this data-type. ...
void initializeFloat2IntLegacyPassPass(PassRegistry &)
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:159
1 1 0 1 True if unordered, less than, or equal
Definition: InstrTypes.h:724
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
signed greater than
Definition: InstrTypes.h:736
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:33
0 0 1 0 True if ordered and greater than
Definition: InstrTypes.h:713
bool isFinite() const
Definition: APFloat.h:1151
Predicate getPredicate(unsigned Condition, unsigned Hint)
Return predicate consisting of specified condition and hint bits.
Definition: PPCPredicates.h:87
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:417
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:841
1 1 0 0 True if unordered or less than
Definition: InstrTypes.h:723
Module.h This file contains the declarations for the Module class.
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
Definition: Float2Int.cpp:516
This class represents a range of values.
Definition: ConstantRange.h:47
signed less than
Definition: InstrTypes.h:738
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:631
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:301
static unsigned int semanticsPrecision(const fltSemantics &)
Definition: APFloat.cpp:154
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
signed less or equal
Definition: InstrTypes.h:739
iterator_range< user_iterator > users()
Definition: Value.h:399
Represents analyses that only rely on functions&#39; control flow.
Definition: PassManager.h:114
static Instruction::BinaryOps mapBinOpcode(unsigned Opcode)
Definition: Float2Int.cpp:108
static cl::opt< ITMode > IT(cl::desc("IT block support"), cl::Hidden, cl::init(DefaultIT), cl::ZeroOrMore, cl::values(clEnumValN(DefaultIT, "arm-default-it", "Generate IT block based on arch"), clEnumValN(RestrictedIT, "arm-restrict-it", "Disallow deprecated IT based on ARMv8"), clEnumValN(NoRestrictedIT, "arm-no-restrict-it", "Allow IT blocks based on ARMv7")))
iterator begin() const
Definition: SmallPtrSet.h:396
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:175
void preserveSet()
Mark an analysis set as preserved.
Definition: PassManager.h:189
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:214
const APInt & getLower() const
Return the lower value for this range.
#define I(x, y, z)
Definition: MD5.cpp:58
0 1 1 0 True if ordered and operands are unequal
Definition: InstrTypes.h:717
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:332
void preserve()
Mark an analysis as preserved.
Definition: PassManager.h:174
1 0 1 0 True if unordered or greater than
Definition: InstrTypes.h:721
iterator end() const
Definition: SmallPtrSet.h:401
ConstantRange unionWith(const ConstantRange &CR, PreferredRangeType Type=Smallest) const
Return the range that results from the union of this range with another range.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
unsigned getMinSignedBits() const
Get the minimum bit size for this signed APInt.
Definition: APInt.h:1551
unsigned getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
Definition: Type.cpp:114
0 0 0 1 True if ordered and equal
Definition: InstrTypes.h:712
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:565
LLVM Value Representation.
Definition: Value.h:72
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:722
IRTranslator LLVM IR MI
inst_range instructions(Function *F)
Definition: InstIterator.h:133
A container for analyses that lazily runs them and caches their results.
#define LLVM_DEBUG(X)
Definition: Debug.h:122
0 0 1 1 True if ordered and greater than or equal
Definition: InstrTypes.h:714
signed greater or equal
Definition: InstrTypes.h:737
cmpResult compare(const APFloat &RHS) const
Definition: APFloat.h:1101
const fltSemantics & getFltSemantics() const
Definition: Type.h:168