| /external/llvm/include/llvm/Transforms/Utils/ |
| IntegerDivision.h | 21 class BinaryOperator;
33 bool expandRemainder(BinaryOperator *Rem);
42 bool expandDivision(BinaryOperator* Div);
50 bool expandRemainderUpTo32Bits(BinaryOperator *Rem);
56 bool expandRemainderUpTo64Bits(BinaryOperator *Rem);
63 bool expandDivisionUpTo32Bits(BinaryOperator *Div);
69 bool expandDivisionUpTo64Bits(BinaryOperator *Div);
|
| /libcore/luni/src/test/java/libcore/java/util/function/ |
| BinaryOperatorTest.java | 22 import java.util.function.BinaryOperator;
28 assertEquals("a", BinaryOperator.minBy(stringComparator).apply("a", "b"));
33 BinaryOperator.minBy(null);
40 assertEquals("b", BinaryOperator.maxBy(stringComparator).apply("a", "b"));
45 BinaryOperator.maxBy(null);
|
| /libcore/ojluni/src/main/java/java/util/stream/ |
| package-info.java | 375 * {@link java.util.stream.Stream#reduce(java.util.function.BinaryOperator) reduce()}
439 * BinaryOperator<U> combiner);
[all...] |
| Collector.java | 32 import java.util.function.BinaryOperator;
140 * static factory methods {@link #of(Supplier, BiConsumer, BinaryOperator, Characteristics...)}
220 BinaryOperator<A> combiner();
262 BinaryOperator<R> combiner,
293 BinaryOperator<A> combiner,
|
| /external/clang/include/clang/AST/ |
| StmtVisitor.h | 45 if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) {
47 case BO_PtrMemD: DISPATCH(BinPtrMemD, BinaryOperator);
48 case BO_PtrMemI: DISPATCH(BinPtrMemI, BinaryOperator);
49 case BO_Mul: DISPATCH(BinMul, BinaryOperator);
50 case BO_Div: DISPATCH(BinDiv, BinaryOperator);
51 case BO_Rem: DISPATCH(BinRem, BinaryOperator);
52 case BO_Add: DISPATCH(BinAdd, BinaryOperator);
53 case BO_Sub: DISPATCH(BinSub, BinaryOperator);
54 case BO_Shl: DISPATCH(BinShl, BinaryOperator);
[all...] |
| /libcore/ojluni/src/main/java/java/util/function/ |
| BinaryOperator.java | 46 public interface BinaryOperator<T> extends BiFunction<T,T,T> {
48 * Returns a {@link BinaryOperator} which returns the lesser of two elements
53 * @return a {@code BinaryOperator} which returns the lesser of its operands,
57 public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
63 * Returns a {@link BinaryOperator} which returns the greater of two elements
68 * @return a {@code BinaryOperator} which returns the greater of its operands,
72 public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
|
| /external/llvm/include/llvm/IR/ |
| NoFolder.h | 42 BinaryOperator *BO = BinaryOperator::CreateAdd(LHS, RHS);
48 return BinaryOperator::CreateNSWAdd(LHS, RHS);
51 return BinaryOperator::CreateNUWAdd(LHS, RHS);
54 return BinaryOperator::CreateFAdd(LHS, RHS);
58 BinaryOperator *BO = BinaryOperator::CreateSub(LHS, RHS);
64 return BinaryOperator::CreateNSWSub(LHS, RHS);
67 return BinaryOperator::CreateNUWSub(LHS, RHS);
70 return BinaryOperator::CreateFSub(LHS, RHS)
[all...] |
| InstrTypes.h | 325 // BinaryOperator Class
328 class BinaryOperator : public Instruction {
333 BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
335 BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
340 BinaryOperator *cloneImpl() const;
356 static BinaryOperator *Create(BinaryOps Op, Value *S1, Value *S2,
364 static BinaryOperator *Create(BinaryOps Op, Value *S1, Value *S2,
371 static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
377 static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
383 static BinaryOperator *Create##OPC(Value *V1, Value *V2,
[all...] |
| /external/clang/lib/StaticAnalyzer/Checkers/ |
| FixedAddressChecker.cpp | 27 : public Checker< check::PreStmt<BinaryOperator> > {
31 void checkPreStmt(const BinaryOperator *B, CheckerContext &C) const;
35 void FixedAddressChecker::checkPreStmt(const BinaryOperator *B,
|
| UndefResultChecker.cpp | 29 : public Checker< check::PostStmt<BinaryOperator> > {
34 void checkPostStmt(const BinaryOperator *B, CheckerContext &C) const;
38 void UndefResultChecker::checkPostStmt(const BinaryOperator *B,
78 << BinaryOperator::getOpcodeStr(B->getOpcode())
84 << BinaryOperator::getOpcodeStr(B->getOpcode())
|
| DivZeroChecker.cpp | 25 class DivZeroChecker : public Checker< check::PreStmt<BinaryOperator> > {
31 void checkPreStmt(const BinaryOperator *B, CheckerContext &C) const;
48 void DivZeroChecker::checkPreStmt(const BinaryOperator *B,
50 BinaryOperator::Opcode Op = B->getOpcode();
|
| PointerArithChecker.cpp | 26 : public Checker< check::PreStmt<BinaryOperator> > {
30 void checkPreStmt(const BinaryOperator *B, CheckerContext &C) const;
34 void PointerArithChecker::checkPreStmt(const BinaryOperator *B,
|
| PointerSubChecker.cpp | 27 : public Checker< check::PreStmt<BinaryOperator> > {
31 void checkPreStmt(const BinaryOperator *B, CheckerContext &C) const;
35 void PointerSubChecker::checkPreStmt(const BinaryOperator *B,
|
| IdenticalExprChecker.cpp | 49 bool VisitBinaryOperator(const BinaryOperator *B);
54 void reportIdenticalExpr(const BinaryOperator *B, bool CheckBitwise,
56 void checkBitwiseOrLogicalOp(const BinaryOperator *B, bool CheckBitwise);
57 void checkComparisonOp(const BinaryOperator *B);
61 void FindIdenticalExprVisitor::reportIdenticalExpr(const BinaryOperator *B,
78 void FindIdenticalExprVisitor::checkBitwiseOrLogicalOp(const BinaryOperator *B,
89 while (const BinaryOperator *B2 = dyn_cast<BinaryOperator>(LHS)) {
182 bool FindIdenticalExprVisitor::VisitBinaryOperator(const BinaryOperator *B) {
183 BinaryOperator::Opcode Op = B->getOpcode()
[all...] |
| UndefinedAssignmentChecker.cpp | 63 if (const BinaryOperator *B = dyn_cast<BinaryOperator>(StoreE)) {
|
| MallocOverflowSecurityChecker.cpp | 36 const BinaryOperator *mulop;
40 MallocOverflowCheck(const BinaryOperator *m, const Expr *v, APSInt val)
76 const BinaryOperator * mulop = nullptr;
82 if (const BinaryOperator *binop = dyn_cast<BinaryOperator>(e)) {
176 void CheckAssignmentExpr(BinaryOperator *AssignEx) {
191 if (const BinaryOperator *BOp = dyn_cast<BinaryOperator>(rhse)) {
225 void VisitBinaryOperator(BinaryOperator *E) {
|
| TestAfterDivZeroChecker.cpp | 80 : public Checker<check::PreStmt<BinaryOperator>, check::BranchCondition,
86 void checkPreStmt(const BinaryOperator *B, CheckerContext &C) const;
107 if (const BinaryOperator *BO = P->getStmtAs<BinaryOperator>()) {
108 BinaryOperator::Opcode Op = BO->getOpcode();
203 void TestAfterDivZeroChecker::checkPreStmt(const BinaryOperator *B,
205 BinaryOperator::Opcode Op = B->getOpcode();
217 if (const BinaryOperator *B = dyn_cast<BinaryOperator>(Condition)) {
|
| /external/llvm/lib/Transforms/InstCombine/ |
| InstCombineInternal.h | 54 if (BinaryOperator::isNeg(V) || BinaryOperator::isFNeg(V) ||
55 BinaryOperator::isNot(V))
80 if (BinaryOperator::isNot(V))
94 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(V))
226 Instruction *visitAdd(BinaryOperator &I);
227 Instruction *visitFAdd(BinaryOperator &I);
229 Instruction *visitSub(BinaryOperator &I);
230 Instruction *visitFSub(BinaryOperator &I)
[all...] |
| InstCombineMulDivRem.cpp | 48 if (BinaryOperator *I = dyn_cast<BinaryOperator>(V))
175 Instruction *InstCombiner::visitMul(BinaryOperator &I) {
190 BinaryOperator *BO = BinaryOperator::CreateNeg(Op0, I.getName());
206 BinaryOperator *Mul = cast<BinaryOperator>(I.getOperand(0));
207 BinaryOperator *BO = BinaryOperator::CreateMul(NewOp, Shl);
228 BinaryOperator *Shl = BinaryOperator::CreateShl(NewOp, NewCst)
[all...] |
| InstCombineShifts.cpp | 24 Instruction *InstCombiner::commonShiftTransforms(BinaryOperator &I) {
219 BinaryOperator *BO = cast<BinaryOperator>(I);
261 BinaryOperator *BO = cast<BinaryOperator>(I);
322 BinaryOperator &I) {
355 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(Op0))
358 return BinaryOperator::CreateMul(BO->getOperand(0),
414 if (BinaryOperator *Op0BO = dyn_cast<BinaryOperator>(Op0))
[all...] |
| /external/clang/unittests/AST/ |
| ASTTypeTraitsTest.cpp | 58 EXPECT_TRUE(DNT<Expr>().isBaseOf(DNT<BinaryOperator>()));
59 EXPECT_FALSE(DNT<CallExpr>().isBaseOf(DNT<BinaryOperator>()));
60 EXPECT_FALSE(DNT<BinaryOperator>().isBaseOf(DNT<CallExpr>()));
70 EXPECT_TRUE(DNT<BinaryOperator>().isSame(
71 ASTNodeKind::getMostDerivedType(DNT<Expr>(), DNT<BinaryOperator>())));
72 EXPECT_TRUE(DNT<BinaryOperator>().isSame(
73 ASTNodeKind::getMostDerivedType(DNT<BinaryOperator>(), DNT<Expr>())));
81 DNT<BinaryOperator>()).isNone());
86 DNT<Expr>(), DNT<BinaryOperator>())));
88 DNT<BinaryOperator>(), DNT<Expr>())))
[all...] |
| /external/llvm/lib/Transforms/Scalar/ |
| Reassociate.cpp | 169 void ReassociateExpression(BinaryOperator *I);
170 void RewriteExprTree(BinaryOperator *I, SmallVectorImpl<ValueEntry> &Ops);
171 Value *OptimizeExpression(BinaryOperator *I,
183 Value *OptimizeMul(BinaryOperator *I, SmallVectorImpl<ValueEntry> &Ops);
227 static BinaryOperator *isReassociableOp(Value *V, unsigned Opcode) {
232 return cast<BinaryOperator>(V);
236 static BinaryOperator *isReassociableOp(Value *V, unsigned Opcode1,
243 return cast<BinaryOperator>(V);
292 if (!BinaryOperator::isNot(I) && !BinaryOperator::isNeg(I) &
[all...] |
| NaryReassociate.cpp | 149 Instruction *tryReassociateBinaryOp(BinaryOperator *I);
154 BinaryOperator *I);
157 BinaryOperator *I);
160 bool matchTernaryOp(BinaryOperator *I, Value *V, Value *&Op1, Value *&Op2);
163 const SCEV *getBinarySCEV(BinaryOperator *I, const SCEV *LHS,
294 return tryReassociateBinaryOp(cast<BinaryOperator>(I));
471 Instruction *NaryReassociate::tryReassociateBinaryOp(BinaryOperator *I) {
481 BinaryOperator *I) {
506 BinaryOperator *I) {
516 NewI = BinaryOperator::CreateAdd(LHS, RHS, "", I)
[all...] |
| /external/clang/lib/StaticAnalyzer/Core/ |
| SimpleConstraintManager.cpp | 53 if (BinaryOperator::isComparisonOp(SSE->getOpcode())) {
143 BinaryOperator::Opcode op = SE->getOpcode();
144 if (BinaryOperator::isComparisonOp(op)) {
146 op = BinaryOperator::negateComparisonOp(op);
159 BinaryOperator::Opcode Op = SSE->getOpcode();
160 assert(BinaryOperator::isComparisonOp(Op));
170 Op = BinaryOperator::reverseComparisonOp(Op);
172 Op = BinaryOperator::negateComparisonOp(Op);
232 BinaryOperator::Opcode Op = SE->getOpcode();
248 BinaryOperator::Opcode op
[all...] |
| /external/llvm/examples/Fibonacci/ |
| fibonacci.cpp | 71 Value *Sub = BinaryOperator::CreateSub(ArgX, One, "arg", RecurseBB);
76 Sub = BinaryOperator::CreateSub(ArgX, Two, "arg", RecurseBB);
82 Value *Sum = BinaryOperator::CreateAdd(CallFibX1, CallFibX2,
|
