reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

include/llvm/IR/Instruction.h

  430   FastMathFlags getFastMathFlags() const;

References

include/llvm/IR/IRBuilder.h

 1369                                 FMFSource->getFastMathFlags());
 1394                                 FMFSource->getFastMathFlags());
 1419                                 FMFSource->getFastMathFlags());
 1444                                 FMFSource->getFastMathFlags());
 1469                                 FMFSource->getFastMathFlags());
 1493       UseFMF = FMFSource->getFastMathFlags();
 1535                             FMFSource->getFastMathFlags()),
 2087       UseFMF = FMFSource->getFastMathFlags();

lib/Analysis/IVDescriptors.cpp

  305         FMF &= ReduxDesc.getPatternInst()->getFastMathFlags();

lib/Analysis/InstructionSimplify.cpp

 5248     Result = SimplifyFNegInst(I->getOperand(0), I->getFastMathFlags(), Q);
 5252                               I->getFastMathFlags(), Q);
 5262                               I->getFastMathFlags(), Q);
 5272                               I->getFastMathFlags(), Q);
 5285                               I->getFastMathFlags(), Q);
 5295                               I->getFastMathFlags(), Q);
 5327                          I->getOperand(1), I->getFastMathFlags(), Q);

lib/Analysis/ValueTracking.cpp

 5078     FMF = CmpI->getFastMathFlags();

lib/CodeGen/ExpandReductions.cpp

   90         isa<FPMathOperator>(II) ? II->getFastMathFlags() : FastMathFlags{};

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 8911     FMF = I.getFastMathFlags();

lib/IR/Instruction.cpp

  240   copyFastMathFlags(I->getFastMathFlags());
  281       FastMathFlags FM = getFastMathFlags();

lib/Transforms/InstCombine/InstCombineAddSub.cpp

  695   NewInstr->setFastMathFlags(Instr->getFastMathFlags());
 1477                                   I.getFastMathFlags(),
 2070   if (Value *V = SimplifyFNegInst(Op, I.getFastMathFlags(),
 2092                                   I.getFastMathFlags(),

lib/Transforms/InstCombine/InstCombineCalls.cpp

 2229       Builder.setFastMathFlags(II->getFastMathFlags());
 2239                                     II->getFastMathFlags(),
 2273                                    II->getFastMathFlags(),
 2614          cast<Instruction>(Arg0)->getFastMathFlags().noInfs())) {

lib/Transforms/InstCombine/InstCombineCompares.cpp

 5966   if (Value *V = SimplifyFCmpInst(Pred, Op0, Op1, I.getFastMathFlags(),

lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

  154     Builder.setFastMathFlags(I.getFastMathFlags());
  164     Builder.setFastMathFlags(I.getFastMathFlags());
  395                                   I.getFastMathFlags(),
 1204                                   I.getFastMathFlags(),
 1258       B.setFastMathFlags(I.getFastMathFlags());
 1474                                   I.getFastMathFlags(),

lib/Transforms/InstCombine/InstCombineSelect.cpp

 1705           FastMathFlags Flags = AddOp->getFastMathFlags();
 1706           Flags &= SubOp->getFastMathFlags();
 1724         FastMathFlags Flags = AddOp->getFastMathFlags();
 1725         Flags &= SubOp->getFastMathFlags();
 2315         Builder.setFastMathFlags(FCI->getFastMathFlags());
 2333         Builder.setFastMathFlags(FCI->getFastMathFlags());

lib/Transforms/InstCombine/InstructionCombining.cpp

  246   FastMathFlags FMF = I.getFastMathFlags();
  446           FastMathFlags Flags = I.getFastMathFlags();
  447           Flags &= Op0->getFastMathFlags();
  448           Flags &= Op1->getFastMathFlags();
  774       FMF = I.getFastMathFlags();

lib/Transforms/Scalar/GVN.cpp

 1457          CmpI->getFastMathFlags().noNaNs())) {

lib/Transforms/Scalar/LICM.cpp

  872         ReciprocalDivisor->setFastMathFlags(I.getFastMathFlags());
  878         Product->setFastMathFlags(I.getFastMathFlags());

lib/Transforms/Scalar/Reassociate.cpp

  763         NewOp->setFastMathFlags(I->getFastMathFlags());
  785         FastMathFlags Flags = I->getFastMathFlags();

lib/Transforms/Utils/SimplifyLibCalls.cpp

 1219   B.setFastMathFlags(CI->getFastMathFlags());
 1292   B.setFastMathFlags(CI->getFastMathFlags());
 1328   B.setFastMathFlags(CI->getFastMathFlags());
 1356   B.setFastMathFlags(Call->getFastMathFlags());
 1652   B.setFastMathFlags(Pow->getFastMathFlags());
 1801   FastMathFlags FMF = CI->getFastMathFlags();
 2012   B.setFastMathFlags(I->getFastMathFlags());

lib/Transforms/Vectorize/LoopVectorize.cpp

 4217         Builder.setFastMathFlags(Cmp->getFastMathFlags());

tools/clang/lib/CodeGen/CGExprScalar.cpp

  222     llvm::FastMathFlags FMF = I->getFastMathFlags();

unittests/IR/IRBuilderTest.cpp

  574   EXPECT_FALSE(FDiv->getFastMathFlags().any());