LLVM  6.0.0svn
Float2Int.cpp
Go to the documentation of this file.
1 //===- Float2Int.cpp - Demote floating point ops to work on integers ------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the Float2Int pass, which aims to demote floating
11 // point operations to work on integers, where that is losslessly possible.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #define DEBUG_TYPE "float2int"
16 
18 #include "llvm/ADT/APInt.h"
19 #include "llvm/ADT/APSInt.h"
20 #include "llvm/ADT/SmallVector.h"
23 #include "llvm/IR/Constants.h"
24 #include "llvm/IR/IRBuilder.h"
25 #include "llvm/IR/InstIterator.h"
26 #include "llvm/IR/Instructions.h"
27 #include "llvm/IR/Module.h"
28 #include "llvm/Pass.h"
29 #include "llvm/Support/Debug.h"
31 #include "llvm/Transforms/Scalar.h"
32 #include <deque>
33 #include <functional> // For std::function
34 using namespace llvm;
35 
36 // The algorithm is simple. Start at instructions that convert from the
37 // float to the int domain: fptoui, fptosi and fcmp. Walk up the def-use
38 // graph, using an equivalence datastructure to unify graphs that interfere.
39 //
40 // Mappable instructions are those with an integer corrollary that, given
41 // integer domain inputs, produce an integer output; fadd, for example.
42 //
43 // If a non-mappable instruction is seen, this entire def-use graph is marked
44 // as non-transformable. If we see an instruction that converts from the
45 // integer domain to FP domain (uitofp,sitofp), we terminate our walk.
46 
47 /// The largest integer type worth dealing with.
48 static cl::opt<unsigned>
49 MaxIntegerBW("float2int-max-integer-bw", cl::init(64), cl::Hidden,
50  cl::desc("Max integer bitwidth to consider in float2int"
51  "(default=64)"));
52 
53 namespace {
54  struct Float2IntLegacyPass : public FunctionPass {
55  static char ID; // Pass identification, replacement for typeid
56  Float2IntLegacyPass() : FunctionPass(ID) {
58  }
59 
60  bool runOnFunction(Function &F) override {
61  if (skipFunction(F))
62  return false;
63 
64  return Impl.runImpl(F);
65  }
66 
67  void getAnalysisUsage(AnalysisUsage &AU) const override {
68  AU.setPreservesCFG();
70  }
71 
72  private:
73  Float2IntPass Impl;
74  };
75 }
76 
78 INITIALIZE_PASS(Float2IntLegacyPass, "float2int", "Float to int", false, false)
79 
80 // Given a FCmp predicate, return a matching ICmp predicate if one
81 // exists, otherwise return BAD_ICMP_PREDICATE.
83  switch (P) {
84  case CmpInst::FCMP_OEQ:
85  case CmpInst::FCMP_UEQ:
86  return CmpInst::ICMP_EQ;
87  case CmpInst::FCMP_OGT:
88  case CmpInst::FCMP_UGT:
89  return CmpInst::ICMP_SGT;
90  case CmpInst::FCMP_OGE:
91  case CmpInst::FCMP_UGE:
92  return CmpInst::ICMP_SGE;
93  case CmpInst::FCMP_OLT:
94  case CmpInst::FCMP_ULT:
95  return CmpInst::ICMP_SLT;
96  case CmpInst::FCMP_OLE:
97  case CmpInst::FCMP_ULE:
98  return CmpInst::ICMP_SLE;
99  case CmpInst::FCMP_ONE:
100  case CmpInst::FCMP_UNE:
101  return CmpInst::ICMP_NE;
102  default:
104  }
105 }
106 
107 // Given a floating point binary operator, return the matching
108 // integer version.
109 static Instruction::BinaryOps mapBinOpcode(unsigned Opcode) {
110  switch (Opcode) {
111  default: llvm_unreachable("Unhandled opcode!");
112  case Instruction::FAdd: return Instruction::Add;
113  case Instruction::FSub: return Instruction::Sub;
114  case Instruction::FMul: return Instruction::Mul;
115  }
116 }
117 
118 // Find the roots - instructions that convert from the FP domain to
119 // integer domain.
120 void Float2IntPass::findRoots(Function &F, SmallPtrSet<Instruction*,8> &Roots) {
121  for (auto &I : instructions(F)) {
122  if (isa<VectorType>(I.getType()))
123  continue;
124  switch (I.getOpcode()) {
125  default: break;
126  case Instruction::FPToUI:
127  case Instruction::FPToSI:
128  Roots.insert(&I);
129  break;
130  case Instruction::FCmp:
131  if (mapFCmpPred(cast<CmpInst>(&I)->getPredicate()) !=
133  Roots.insert(&I);
134  break;
135  }
136  }
137 }
138 
139 // Helper - mark I as having been traversed, having range R.
140 void Float2IntPass::seen(Instruction *I, ConstantRange R) {
141  DEBUG(dbgs() << "F2I: " << *I << ":" << R << "\n");
142  auto IT = SeenInsts.find(I);
143  if (IT != SeenInsts.end())
144  IT->second = std::move(R);
145  else
146  SeenInsts.insert(std::make_pair(I, std::move(R)));
147 }
148 
149 // Helper - get a range representing a poison value.
150 ConstantRange Float2IntPass::badRange() {
151  return ConstantRange(MaxIntegerBW + 1, true);
152 }
153 ConstantRange Float2IntPass::unknownRange() {
154  return ConstantRange(MaxIntegerBW + 1, false);
155 }
156 ConstantRange Float2IntPass::validateRange(ConstantRange R) {
157  if (R.getBitWidth() > MaxIntegerBW + 1)
158  return badRange();
159  return R;
160 }
161 
162 // The most obvious way to structure the search is a depth-first, eager
163 // search from each root. However, that require direct recursion and so
164 // can only handle small instruction sequences. Instead, we split the search
165 // up into two phases:
166 // - walkBackwards: A breadth-first walk of the use-def graph starting from
167 // the roots. Populate "SeenInsts" with interesting
168 // instructions and poison values if they're obvious and
169 // cheap to compute. Calculate the equivalance set structure
170 // while we're here too.
171 // - walkForwards: Iterate over SeenInsts in reverse order, so we visit
172 // defs before their uses. Calculate the real range info.
173 
174 // Breadth-first walk of the use-def graph; determine the set of nodes
175 // we care about and eagerly determine if some of them are poisonous.
176 void Float2IntPass::walkBackwards(const SmallPtrSetImpl<Instruction*> &Roots) {
177  std::deque<Instruction*> Worklist(Roots.begin(), Roots.end());
178  while (!Worklist.empty()) {
179  Instruction *I = Worklist.back();
180  Worklist.pop_back();
181 
182  if (SeenInsts.find(I) != SeenInsts.end())
183  // Seen already.
184  continue;
185 
186  switch (I->getOpcode()) {
187  // FIXME: Handle select and phi nodes.
188  default:
189  // Path terminated uncleanly.
190  seen(I, badRange());
191  break;
192 
193  case Instruction::UIToFP:
194  case Instruction::SIToFP: {
195  // Path terminated cleanly - use the type of the integer input to seed
196  // the analysis.
197  unsigned BW = I->getOperand(0)->getType()->getPrimitiveSizeInBits();
198  auto Input = ConstantRange(BW, true);
199  auto CastOp = (Instruction::CastOps)I->getOpcode();
200  seen(I, validateRange(Input.castOp(CastOp, MaxIntegerBW+1)));
201  continue;
202  }
203 
204  case Instruction::FAdd:
205  case Instruction::FSub:
206  case Instruction::FMul:
207  case Instruction::FPToUI:
208  case Instruction::FPToSI:
209  case Instruction::FCmp:
210  seen(I, unknownRange());
211  break;
212  }
213 
214  for (Value *O : I->operands()) {
215  if (Instruction *OI = dyn_cast<Instruction>(O)) {
216  // Unify def-use chains if they interfere.
217  ECs.unionSets(I, OI);
218  if (SeenInsts.find(I)->second != badRange())
219  Worklist.push_back(OI);
220  } else if (!isa<ConstantFP>(O)) {
221  // Not an instruction or ConstantFP? we can't do anything.
222  seen(I, badRange());
223  }
224  }
225  }
226 }
227 
228 // Walk forwards down the list of seen instructions, so we visit defs before
229 // uses.
230 void Float2IntPass::walkForwards() {
231  for (auto &It : reverse(SeenInsts)) {
232  if (It.second != unknownRange())
233  continue;
234 
235  Instruction *I = It.first;
236  std::function<ConstantRange(ArrayRef<ConstantRange>)> Op;
237  switch (I->getOpcode()) {
238  // FIXME: Handle select and phi nodes.
239  default:
240  case Instruction::UIToFP:
241  case Instruction::SIToFP:
242  llvm_unreachable("Should have been handled in walkForwards!");
243 
244  case Instruction::FAdd:
245  case Instruction::FSub:
246  case Instruction::FMul:
247  Op = [I](ArrayRef<ConstantRange> Ops) {
248  assert(Ops.size() == 2 && "its a binary operator!");
249  auto BinOp = (Instruction::BinaryOps) I->getOpcode();
250  return Ops[0].binaryOp(BinOp, Ops[1]);
251  };
252  break;
253 
254  //
255  // Root-only instructions - we'll only see these if they're the
256  // first node in a walk.
257  //
258  case Instruction::FPToUI:
259  case Instruction::FPToSI:
260  Op = [I](ArrayRef<ConstantRange> Ops) {
261  assert(Ops.size() == 1 && "FPTo[US]I is a unary operator!");
262  // Note: We're ignoring the casts output size here as that's what the
263  // caller expects.
264  auto CastOp = (Instruction::CastOps)I->getOpcode();
265  return Ops[0].castOp(CastOp, MaxIntegerBW+1);
266  };
267  break;
268 
269  case Instruction::FCmp:
270  Op = [](ArrayRef<ConstantRange> Ops) {
271  assert(Ops.size() == 2 && "FCmp is a binary operator!");
272  return Ops[0].unionWith(Ops[1]);
273  };
274  break;
275  }
276 
277  bool Abort = false;
279  for (Value *O : I->operands()) {
280  if (Instruction *OI = dyn_cast<Instruction>(O)) {
281  assert(SeenInsts.find(OI) != SeenInsts.end() &&
282  "def not seen before use!");
283  OpRanges.push_back(SeenInsts.find(OI)->second);
284  } else if (ConstantFP *CF = dyn_cast<ConstantFP>(O)) {
285  // Work out if the floating point number can be losslessly represented
286  // as an integer.
287  // APFloat::convertToInteger(&Exact) purports to do what we want, but
288  // the exactness can be too precise. For example, negative zero can
289  // never be exactly converted to an integer.
290  //
291  // Instead, we ask APFloat to round itself to an integral value - this
292  // preserves sign-of-zero - then compare the result with the original.
293  //
294  const APFloat &F = CF->getValueAPF();
295 
296  // First, weed out obviously incorrect values. Non-finite numbers
297  // can't be represented and neither can negative zero, unless
298  // we're in fast math mode.
299  if (!F.isFinite() ||
300  (F.isZero() && F.isNegative() && isa<FPMathOperator>(I) &&
301  !I->hasNoSignedZeros())) {
302  seen(I, badRange());
303  Abort = true;
304  break;
305  }
306 
307  APFloat NewF = F;
309  if (Res != APFloat::opOK || NewF.compare(F) != APFloat::cmpEqual) {
310  seen(I, badRange());
311  Abort = true;
312  break;
313  }
314  // OK, it's representable. Now get it.
315  APSInt Int(MaxIntegerBW+1, false);
316  bool Exact;
317  CF->getValueAPF().convertToInteger(Int,
319  &Exact);
320  OpRanges.push_back(ConstantRange(Int));
321  } else {
322  llvm_unreachable("Should have already marked this as badRange!");
323  }
324  }
325 
326  // Reduce the operands' ranges to a single range and return.
327  if (!Abort)
328  seen(I, Op(OpRanges));
329  }
330 }
331 
332 // If there is a valid transform to be done, do it.
333 bool Float2IntPass::validateAndTransform() {
334  bool MadeChange = false;
335 
336  // Iterate over every disjoint partition of the def-use graph.
337  for (auto It = ECs.begin(), E = ECs.end(); It != E; ++It) {
338  ConstantRange R(MaxIntegerBW + 1, false);
339  bool Fail = false;
340  Type *ConvertedToTy = nullptr;
341 
342  // For every member of the partition, union all the ranges together.
343  for (auto MI = ECs.member_begin(It), ME = ECs.member_end();
344  MI != ME; ++MI) {
345  Instruction *I = *MI;
346  auto SeenI = SeenInsts.find(I);
347  if (SeenI == SeenInsts.end())
348  continue;
349 
350  R = R.unionWith(SeenI->second);
351  // We need to ensure I has no users that have not been seen.
352  // If it does, transformation would be illegal.
353  //
354  // Don't count the roots, as they terminate the graphs.
355  if (Roots.count(I) == 0) {
356  // Set the type of the conversion while we're here.
357  if (!ConvertedToTy)
358  ConvertedToTy = I->getType();
359  for (User *U : I->users()) {
360  Instruction *UI = dyn_cast<Instruction>(U);
361  if (!UI || SeenInsts.find(UI) == SeenInsts.end()) {
362  DEBUG(dbgs() << "F2I: Failing because of " << *U << "\n");
363  Fail = true;
364  break;
365  }
366  }
367  }
368  if (Fail)
369  break;
370  }
371 
372  // If the set was empty, or we failed, or the range is poisonous,
373  // bail out.
374  if (ECs.member_begin(It) == ECs.member_end() || Fail ||
375  R.isFullSet() || R.isSignWrappedSet())
376  continue;
377  assert(ConvertedToTy && "Must have set the convertedtoty by this point!");
378 
379  // The number of bits required is the maximum of the upper and
380  // lower limits, plus one so it can be signed.
381  unsigned MinBW = std::max(R.getLower().getMinSignedBits(),
382  R.getUpper().getMinSignedBits()) + 1;
383  DEBUG(dbgs() << "F2I: MinBitwidth=" << MinBW << ", R: " << R << "\n");
384 
385  // If we've run off the realms of the exactly representable integers,
386  // the floating point result will differ from an integer approximation.
387 
388  // Do we need more bits than are in the mantissa of the type we converted
389  // to? semanticsPrecision returns the number of mantissa bits plus one
390  // for the sign bit.
391  unsigned MaxRepresentableBits
392  = APFloat::semanticsPrecision(ConvertedToTy->getFltSemantics()) - 1;
393  if (MinBW > MaxRepresentableBits) {
394  DEBUG(dbgs() << "F2I: Value not guaranteed to be representable!\n");
395  continue;
396  }
397  if (MinBW > 64) {
398  DEBUG(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  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:1008
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks &#39;this&#39; from the containing basic block and deletes it.
Definition: Instruction.cpp:69
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:1638
This class is the base class for the comparison instructions.
Definition: InstrTypes.h:843
bool isZero() const
Definition: APFloat.h:1143
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:1112
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:1395
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
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:859
1 1 1 0 True if unordered or not equal
Definition: InstrTypes.h:869
F(f)
static void cleanup(BlockFrequencyInfoImplBase &BFI)
Clear all memory not needed downstream.
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:177
bool runImpl(Function &F)
Definition: Float2Int.cpp:492
1 0 0 1 True if unordered or equal
Definition: InstrTypes.h:864
uint32_t getBitWidth() const
Get the bit width of this ConstantRange.
#define Fail
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:237
static bool runImpl(CallGraphSCC &SCC, AARGetterT AARGetter)
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:668
0 1 0 1 True if ordered and less than or equal
Definition: InstrTypes.h:860
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:186
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
Value * CreateSExtOrTrunc(Value *V, Type *DestTy, const Twine &Name="")
Create a SExt or Trunc from the integer value V to DestTy.
Definition: IRBuilder.h:1409
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
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:430
Value * getOperand(unsigned i) const
Definition: User.h:154
static CmpInst::Predicate mapFCmpPred(CmpInst::Predicate P)
Definition: Float2Int.cpp:82
static bool runOnFunction(Function &F, bool PostInlining)
#define P(N)
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:406
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:153
bool isNegative() const
Definition: APFloat.h:1147
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
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:264
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:371
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:853
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:285
op_range operands()
Definition: User.h:222
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:382
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:868
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
signed greater than
Definition: InstrTypes.h:880
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:34
0 0 1 0 True if ordered and greater than
Definition: InstrTypes.h:857
bool isFinite() const
Definition: APFloat.h:1152
Predicate getPredicate(unsigned Condition, unsigned Hint)
Return predicate consisting of specified condition and hint bits.
Definition: PPCPredicates.h:85
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:418
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:864
1 1 0 0 True if unordered or less than
Definition: InstrTypes.h:867
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:882
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:560
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:285
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:883
iterator_range< user_iterator > users()
Definition: Value.h:401
Represents analyses that only rely on functions&#39; control flow.
Definition: PassManager.h:114
static Instruction::BinaryOps mapBinOpcode(unsigned Opcode)
Definition: Float2Int.cpp:109
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:397
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:176
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:220
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:861
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:323
void preserve()
Mark an analysis as preserved.
Definition: PassManager.h:174
1 0 1 0 True if unordered or greater than
Definition: InstrTypes.h:865
iterator end() const
Definition: SmallPtrSet.h:402
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
unsigned getMinSignedBits() const
Get the minimum bit size for this signed APInt.
Definition: APInt.h:1531
unsigned getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
Definition: Type.cpp:115
0 0 0 1 True if ordered and equal
Definition: InstrTypes.h:856
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:556
LLVM Value Representation.
Definition: Value.h:73
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:866
#define DEBUG(X)
Definition: Debug.h:118
IRTranslator LLVM IR MI
inst_range instructions(Function *F)
Definition: InstIterator.h:134
A container for analyses that lazily runs them and caches their results.
0 0 1 1 True if ordered and greater than or equal
Definition: InstrTypes.h:858
signed greater or equal
Definition: InstrTypes.h:881
cmpResult compare(const APFloat &RHS) const
Definition: APFloat.h:1102
const fltSemantics & getFltSemantics() const
Definition: Type.h:169