lib/Analysis/InstructionSimplify.cpp

46   const TargetLibraryInfo *TLI;
50         const DominatorTree *dt) : TD(td), TLI(tli), DT(dt) {}
598                                       Q.TD, Q.TLI);
654                              const DataLayout *TD, const TargetLibraryInfo *TLI,
656   return ::SimplifyAddInst(Op0, Op1, isNSW, isNUW, Query (TD, TLI, DT),
740                                       Ops, Q.TD, Q.TLI);
860                              const DataLayout *TD, const TargetLibraryInfo *TLI,
862   return ::SimplifySubInst(Op0, Op1, isNSW, isNUW, Query (TD, TLI, DT),
874                                       Ops, Q.TD, Q.TLI);
916                                       Ops, Q.TD, Q.TLI);
954                                       Ops, Q.TD, Q.TLI);
980                                       Ops, Q.TD, Q.TLI);
1038                              const DataLayout *TD, const TargetLibraryInfo *TLI,
1040   return ::SimplifyFAddInst(Op0, Op1, FMF, Query (TD, TLI, DT), RecursionLimit);
1044                              const DataLayout *TD, const TargetLibraryInfo *TLI,
1046   return ::SimplifyFSubInst(Op0, Op1, FMF, Query (TD, TLI, DT), RecursionLimit);
1052                               const TargetLibraryInfo *TLI,
1054   return ::SimplifyFMulInst(Op0, Op1, FMF, Query (TD, TLI, DT), RecursionLimit);
1058                              const TargetLibraryInfo *TLI,
1060   return ::SimplifyMulInst(Op0, Op1, Query (TD, TLI, DT), RecursionLimit);
1070       return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, Q.TD, Q.TLI);
1146                               const TargetLibraryInfo *TLI,
1148   return ::SimplifySDivInst(Op0, Op1, Query (TD, TLI, DT), RecursionLimit);
1162                               const TargetLibraryInfo *TLI,
1164   return ::SimplifyUDivInst(Op0, Op1, Query (TD, TLI, DT), RecursionLimit);
1181                               const TargetLibraryInfo *TLI,
1183   return ::SimplifyFDivInst(Op0, Op1, Query (TD, TLI, DT), RecursionLimit);
1193       return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, Q.TD, Q.TLI);
1251                               const TargetLibraryInfo *TLI,
1253   return ::SimplifySRemInst(Op0, Op1, Query (TD, TLI, DT), RecursionLimit);
1267                               const TargetLibraryInfo *TLI,
1269   return ::SimplifyURemInst(Op0, Op1, Query (TD, TLI, DT), RecursionLimit);
1286                               const TargetLibraryInfo *TLI,
1288   return ::SimplifyFRemInst(Op0, Op1, Query (TD, TLI, DT), RecursionLimit);
1298       return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, Q.TD, Q.TLI);
1354                              const DataLayout *TD, const TargetLibraryInfo *TLI,
1356   return ::SimplifyShlInst(Op0, Op1, isNSW, isNUW, Query (TD, TLI, DT),
1386                               const TargetLibraryInfo *TLI,
1388   return ::SimplifyLShrInst(Op0, Op1, isExact, Query (TD, TLI, DT),
1422                               const TargetLibraryInfo *TLI,
1424   return ::SimplifyAShrInst(Op0, Op1, isExact, Query (TD, TLI, DT),
1436                                       Ops, Q.TD, Q.TLI);
1522                              const TargetLibraryInfo *TLI,
1524   return ::SimplifyAndInst(Op0, Op1, Query (TD, TLI, DT), RecursionLimit);
1535                                       Ops, Q.TD, Q.TLI);
1616                             const TargetLibraryInfo *TLI,
1618   return ::SimplifyOrInst(Op0, Op1, Query (TD, TLI, DT), RecursionLimit);
1629                                       Ops, Q.TD, Q.TLI);
1676                              const TargetLibraryInfo *TLI,
1678   return ::SimplifyXorInst(Op0, Op1, Query (TD, TLI, DT), RecursionLimit);
1734                                     const TargetLibraryInfo *TLI,
1742   if (llvm::isKnownNonNull(LHS, TLI) && isa<ConstantPointerNull>(RHS) &&
1820           getObjectSize(LHS, LHSSize, TD, TLI) &&
1821           getObjectSize(RHS, RHSSize, TD, TLI)) {
1868       return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, Q.TD, Q.TLI);
2551     if (Constant *C = computePointerICmp(Q.TD, Q.TLI, Pred, LHS, RHS))
2592                               const TargetLibraryInfo *TLI,
2594   return ::SimplifyICmpInst(Predicate, LHS, RHS, Query (TD, TLI, DT),
2607       return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, Q.TD, Q.TLI);
2689                               const TargetLibraryInfo *TLI,
2691   return ::SimplifyFCmpInst(Predicate, LHS, RHS, Query (TD, TLI, DT),
2724                                 const TargetLibraryInfo *TLI,
2726   return ::SimplifySelectInst(Cond, TrueVal, FalseVal, Query (TD, TLI, DT),
2772                              const TargetLibraryInfo *TLI,
2774   return ::SimplifyGEPInst(Ops, Query (TD, TLI, DT), RecursionLimit);
2809                                      const TargetLibraryInfo *TLI,
2811   return ::SimplifyInsertValueInst(Agg, Val, Idxs, Query (TD, TLI, DT),
2851     return ConstantFoldInstOperands(Instruction::Trunc, Ty, C, Q.TD, Q.TLI);
2857                                const TargetLibraryInfo *TLI,
2859   return ::SimplifyTruncInst(Op, Ty, Query (TD, TLI, DT), RecursionLimit);
2905                                         Q.TLI);
2930                            const DataLayout *TD, const TargetLibraryInfo *TLI,
2932   return ::SimplifyBinOp(Opcode, LHS, RHS, Query (TD, TLI, DT), RecursionLimit);
2945                              const DataLayout *TD, const TargetLibraryInfo *TLI,
2947   return ::SimplifyCmpInst(Predicate, LHS, RHS, Query (TD, TLI, DT),
3016   return ConstantFoldCall(F, ConstantArgs, Q.TLI);
3021                           const TargetLibraryInfo *TLI,
3023   return ::SimplifyCall(V, ArgBegin, ArgEnd, Query(TD, TLI, DT),
3028                           const DataLayout *TD, const TargetLibraryInfo *TLI,
3030   return ::SimplifyCall(V, Args.begin(), Args.end(), Query(TD, TLI, DT),
3037                                  const TargetLibraryInfo *TLI,
3043     Result = ConstantFoldInstruction(I, TD, TLI);
3047                               I->getFastMathFlags(), TD, TLI, DT);
3053                              TD, TLI, DT);
3057                               I->getFastMathFlags(), TD, TLI, DT);
3063                              TD, TLI, DT);
3067                               I->getFastMathFlags(), TD, TLI, DT);
3070     Result = SimplifyMulInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT);
3073     Result = SimplifySDivInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT);
3076     Result = SimplifyUDivInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT);
3079     Result = SimplifyFDivInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT);
3082     Result = SimplifySRemInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT);
3085     Result = SimplifyURemInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT);
3088     Result = SimplifyFRemInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT);
3094                              TD, TLI, DT);
3099                               TD, TLI, DT);
3104                               TD, TLI, DT);
3107     Result = SimplifyAndInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT);
3110     Result = SimplifyOrInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT);
3113     Result = SimplifyXorInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT);
3117                               I->getOperand(0), I->getOperand(1), TD, TLI, DT);
3121                               I->getOperand(0), I->getOperand(1), TD, TLI, DT);
3125                                 I->getOperand(2), TD, TLI, DT);
3129     Result = SimplifyGEPInst(Ops, TD, TLI, DT);
3136                                      IV->getIndices(), TD, TLI, DT);
3140     Result = SimplifyPHINode(cast<PHINode>(I), Query (TD, TLI, DT));
3145                           TD, TLI, DT);
3149     Result = SimplifyTruncInst(I->getOperand(0), I->getType(), TD, TLI, DT);
3172                                               const TargetLibraryInfo *TLI,
3201     SimpleV = SimplifyInstruction(I, TD, TLI, DT);
3227                                           const TargetLibraryInfo *TLI,
3229   return replaceAndRecursivelySimplifyImpl(I, 0, TD, TLI, DT);
3234                                          const TargetLibraryInfo *TLI,
3238   return replaceAndRecursivelySimplifyImpl(I, SimpleV, TD, TLI, DT);