| /external/llvm/test/CodeGen/X86/ |
| legalizedag_vec.ll | 7 ; legalizing the divide in LegalizeDAG, we scalarize the vector divide and make
8 ; two 64 bit divide library calls which introduces i64 nodes that needs to be
|
| /external/llvm/test/Transforms/ConstProp/ |
| 2002-05-03-DivideByZeroException.ll | 1 ; Make sure that the constant propogator doesn't divide by zero!
|
| /dalvik/vm/mterp/x86-atom/ |
| binopD.S | 19 * Code: 32-bit integer divide operation. If "div" is set, the code
21 * Also, a divide-by-zero check is done.
38 cmp $$0, %ecx # check for divide by zero
39 je common_errDivideByZero # handle divide by zero
40 cmpl $$-1, %ecx # handle -1 special case divide error
42 cmpl $$0x80000000,%eax # handle min int special case divide error
46 idiv %ecx # divide %edx:%eax by %ecx
|
| binopDLit16.S | 19 * Code: 32-bit "lit16" divide operation. If "div" is set, the code
21 * Also, a divide-by-zero check is done.
38 cmp $$0, %ecx # check for divide by zero
40 je common_errDivideByZero # handle divide by zero
42 cmpl $$-1, %ecx # handle -1 special case divide error
44 cmpl $$0x80000000,%eax # handle min int special case divide error
48 idiv %ecx # divide %edx:%eax by %ecx
|
| binopDLit8.S | 19 * Code: 32-bit "lit8" divide operation. If "div" is set, the code
21 * Also, a divide-by-zero check is done.
37 cmp $$0, %ecx # check for divide by zero
39 je common_errDivideByZero # handle divide by zero
41 cmpl $$-1, %ecx # handle -1 special case divide error
43 cmpl $$0x80000000,%eax # handle min int special case divide error
47 idiv %ecx # divide %edx:%eax by %ecx
|
| binopD2addr.S | 21 * the remainder. Also, a divide-by-zero check is done.
40 cmp $$0, %ecx # check for divide by zero
41 je common_errDivideByZero # handle divide by zero
42 cmpl $$-1, %ecx # handle -1 special case divide error
44 cmpl $$0x80000000,%eax # handle min int special case divide error
48 idiv %ecx # divide %edx:%eax by %ecx
|
| OP_DIV_DOUBLE.S | 23 * Description: Divide operation on two source registers, storing
34 fdivl (rFP, %edx, 4) # divide double; vBB/vCC
|
| OP_DIV_DOUBLE_2ADDR.S | 23 * Description: Divide operation on two source registers, storing
35 fdivl (rFP, rINST, 4) # divide double; vA/vB
|
| OP_DIV_FLOAT.S | 23 * Description: Divide operation on two source registers, storing
34 fdivs (rFP, %ecx, 4) # divide double; vBB/vCC
|
| OP_DIV_FLOAT_2ADDR.S | 23 * Description: Divide operation on two source registers, storing
35 fdivs (rFP, rINST, 4) # divide double; vA/vB
|
| binopDivRemLong.S | 19 * Code: 64-bit long divide operation. Variable
38 or %ecx, %eax # check for divide by zero
39 je common_errDivideByZero # handle divide by zero
|
| binopDivRemLong2Addr.S | 19 * Code: 64-bit "/2addr" long divide operation. Variable
40 or %ecx, %eax # check for divide by zero
41 je common_errDivideByZero # handle divide by zero
|
| /libcore/luni/src/test/java/libcore/java/math/ |
| OldBigDecimalArithmeticTest.java | 197 a.round(mc).divide(b.round(mc)).toString());
198 res = a.divide(b, BigDecimal.ROUND_FLOOR);
203 res = a.divide(b, BigDecimal.ROUND_UNNECESSARY);
209 res = a.divide(b, BigDecimal.ROUND_UNNECESSARY);
223 res = a.divide(b, -1220, BigDecimal.ROUND_FLOOR);
228 res = a.divide(b, 1, BigDecimal.ROUND_UNNECESSARY);
234 res = a.divide(b, 0, BigDecimal.ROUND_UNNECESSARY);
252 a.round(mc).divide(b.round(mc)).toString());
253 res = a.divide(b, mc);
259 res = a.divide(b, mc)
[all...] |
| /external/apache-harmony/math/src/test/java/org/apache/harmony/tests/java/math/ |
| BigIntegerDivideTest.java | 28 * Methods: divide, remainder, mod, and divideAndRemainder
32 * Divide by zero
42 aNumber.divide(bNumber);
49 * Divide by ZERO
57 aNumber.divide(bNumber);
64 * Divide two equal positive numbers
74 BigInteger result = aNumber.divide(bNumber);
84 * Divide two equal in absolute value numbers of different signs.
94 BigInteger result = aNumber.divide(bNumber);
104 * Divide two numbers of different length and different signs
[all...] |
| BigDecimalArithmeticTest.java | 29 * Methods: add, subtract, multiply, divide
478 * Divide by zero
486 aNumber.divide(bNumber);
494 * Divide with ROUND_UNNECESSARY
504 aNumber.divide(bNumber, BigDecimal.ROUND_UNNECESSARY);
512 * Divide with invalid rounding mode
522 aNumber.divide(bNumber, 100);
530 * Divide: local variable exponent is less than zero
541 BigDecimal result = aNumber.divide(bNumber, resScale, BigDecimal.ROUND_CEILING);
547 * Divide: local variable exponent is equal to zer
[all...] |
| /external/skia/src/gpu/ |
| GrPathUtils.h | 25 /// Since we divide by tol if we're computing exact worst-case bounds,
30 /// Since we divide by tol if we're computing exact worst-case bounds,
39 /// Since we divide by tol if we're computing exact worst-case bounds,
|
| /external/guava/guava-tests/test/com/google/common/primitives/ |
| UnsignedLongsTest.java | 59 assertEquals(2, UnsignedLongs.divide(14, 5));
60 assertEquals(0, UnsignedLongs.divide(0, 50));
61 assertEquals(1, UnsignedLongs.divide(0xfffffffffffffffeL, 0xfffffffffffffffdL));
62 assertEquals(0, UnsignedLongs.divide(0xfffffffffffffffdL, 0xfffffffffffffffeL));
63 assertEquals(281479271743488L, UnsignedLongs.divide(0xfffffffffffffffeL, 65535));
64 assertEquals(0x7fffffffffffffffL, UnsignedLongs.divide(0xfffffffffffffffeL, 2));
65 assertEquals(3689348814741910322L, UnsignedLongs.divide(0xfffffffffffffffeL, 5));
87 assertTrue(dividend - (divisor * UnsignedLongs.divide(dividend, divisor)
|
| /external/proguard/src/proguard/evaluation/value/ |
| SpecificDoubleValue.java | 80 public DoubleValue divide(DoubleValue other) method in class:SpecificDoubleValue
87 return other.divide(this);
134 public DoubleValue divide(SpecificDoubleValue other) method in class:SpecificDoubleValue
136 return new CompositeDoubleValue(this, CompositeDoubleValue.DIVIDE, other);
141 return new CompositeDoubleValue(other, CompositeDoubleValue.DIVIDE, this);
|
| SpecificFloatValue.java | 80 public FloatValue divide(FloatValue other) method in class:SpecificFloatValue
87 return other.divide(this);
134 public FloatValue divide(SpecificFloatValue other) method in class:SpecificFloatValue
136 return new CompositeFloatValue(this, CompositeFloatValue.DIVIDE, other);
141 return new CompositeFloatValue(other, CompositeFloatValue.DIVIDE, this);
|
| /external/srec/tools/thirdparty/OpenFst/fst/lib/ |
| weight.h | 40 // Divide: for all a,b,c s.t. Times(a, b) == c
41 // --> b = Divide(c, a, DIVIDE_LEFT) if a left semiring and b.Member()
42 // --> a = Divide(c, b, DIVIDE_RIGHT) if a right semiring and a.Member()
43 // --> b = Divide(c, a)
44 // = Divide(c, a, DIVIDE_ANY)
45 // = Divide(c, a, DIVIDE_LEFT)
46 // = Divide(c, a, DIVIDE_RIGHT) if a commutative semiring
|
| /external/dexmaker/src/main/java/com/google/dexmaker/ |
| BinaryOp.java | 27 * {@link #DIVIDE}, and {@link #REMAINDER}) support ints, longs, floats and
35 * For int and long operands, {@link #DIVIDE} and {@link #REMAINDER} throw
62 DIVIDE() {
|
| /external/dropbear/libtommath/ |
| bn_mp_gcd.c | 50 /* divide the power of two out */
60 /* divide any remaining factors of two out */
85 /* Divide out all factors of two */
|
| /external/compiler-rt/lib/arm/ |
| udivmodsi4.S | 1 /*===-- udivmodsi4.S - 32-bit unsigned integer divide and modulus ---------===//
10 * This file implements the __udivmodsi4 (32-bit unsigned integer divide and
35 // divide loop, we must calculate the left-shift amount necessary to align
42 tst b, b // detect divide-by-zero
|
| udivsi3.S | 1 /*===-- udivsi3.S - 32-bit unsigned integer divide ------------------------===//
10 * This file implements the __udivsi3 (32-bit unsigned integer divide)
37 // divide loop, we must calculate the left-shift amount necessary to align
44 tst b, b // detect divide-by-zero
|
| /external/openfst/src/include/fst/ |
| reweight.h | 85 arc.weight = Divide(Times(arc.weight, nextweight), weight,
88 arc.weight = Divide(Times(weight, arc.weight), nextweight,
93 fst->SetFinal(state, Divide(fst->Final(state), weight, DIVIDE_LEFT));
119 Divide(Weight::One(), startweight, DIVIDE_RIGHT),
126 fst->SetFinal(state, Times(Divide(Weight::One(), startweight,
132 Divide(Weight::One(), startweight, DIVIDE_RIGHT);
|
