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(MaxIntegerBW + 1, true);
151 }
152 ConstantRange Float2IntPass::unknownRange() {
153  return ConstantRange(MaxIntegerBW + 1, false);
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(BW, true);
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:636
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)
ConstantRange unionWith(const ConstantRange &CR) const
Return the range that results from the union of this range with another range.
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:652
1 1 1 0 True if unordered or not equal
Definition: InstrTypes.h:662
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:657
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:653
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:423
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 INT_MIN of its bitwidth.
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:646
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:661
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
signed greater than
Definition: InstrTypes.h:673
#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:650
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:660
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:675
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:676
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:654
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:322
void preserve()
Mark an analysis as preserved.
Definition: PassManager.h:174
1 0 1 0 True if unordered or greater than
Definition: InstrTypes.h:658
iterator end() const
Definition: SmallPtrSet.h:401
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:649
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:659
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:651
signed greater or equal
Definition: InstrTypes.h:674
cmpResult compare(const APFloat &RHS) const
Definition: APFloat.h:1101
const fltSemantics & getFltSemantics() const
Definition: Type.h:168