| ... | ... | @@ -12,6 +12,9 @@ |
| 12 | 12 | #include "os.hpp" |
| 13 | 13 | #include "softfloat.hpp" |
| 14 | 14 | |
| 15 | #include <limits> |
| 16 | #include <algorithm> |
| 17 | |
| 15 | 18 | static void bigint_normalize(BigInt *dest) { |
| 16 | 19 | const uint64_t *digits = bigint_ptr(dest); |
| 17 | 20 | |
| ... | ... | @@ -539,7 +542,7 @@ void bigint_add(BigInt *dest, const BigInt *op1, const BigInt *op2) { |
| 539 | 542 | dest->data.digits[i] = x; |
| 540 | 543 | i += 1; |
| 541 | 544 | |
| 542 | | if (!found_digit) |
| 545 | if (!found_digit || i >= bigger_op->digit_count) |
| 543 | 546 | break; |
| 544 | 547 | } |
| 545 | 548 | assert(overflow == 0); |
| ... | ... | @@ -670,19 +673,409 @@ void bigint_mul_wrap(BigInt *dest, const BigInt *op1, const BigInt *op2, size_t |
| 670 | 673 | bigint_truncate(dest, &unwrapped, bit_count, is_signed); |
| 671 | 674 | } |
| 672 | 675 | |
| 676 | enum ZeroBehavior { |
| 677 | /// \brief The returned value is undefined. |
| 678 | ZB_Undefined, |
| 679 | /// \brief The returned value is numeric_limits<T>::max() |
| 680 | ZB_Max, |
| 681 | /// \brief The returned value is numeric_limits<T>::digits |
| 682 | ZB_Width |
| 683 | }; |
| 684 | |
| 685 | template <typename T, std::size_t SizeOfT> struct LeadingZerosCounter { |
| 686 | static std::size_t count(T Val, ZeroBehavior) { |
| 687 | if (!Val) |
| 688 | return std::numeric_limits<T>::digits; |
| 689 | |
| 690 | // Bisection method. |
| 691 | std::size_t ZeroBits = 0; |
| 692 | for (T Shift = std::numeric_limits<T>::digits >> 1; Shift; Shift >>= 1) { |
| 693 | T Tmp = Val >> Shift; |
| 694 | if (Tmp) |
| 695 | Val = Tmp; |
| 696 | else |
| 697 | ZeroBits |= Shift; |
| 698 | } |
| 699 | return ZeroBits; |
| 700 | } |
| 701 | }; |
| 702 | |
| 703 | #if __GNUC__ >= 4 || defined(_MSC_VER) |
| 704 | template <typename T> struct LeadingZerosCounter<T, 4> { |
| 705 | static std::size_t count(T Val, ZeroBehavior ZB) { |
| 706 | if (ZB != ZB_Undefined && Val == 0) |
| 707 | return 32; |
| 708 | |
| 709 | #if defined(_MSC_VER) |
| 710 | unsigned long Index; |
| 711 | _BitScanReverse(&Index, Val); |
| 712 | return Index ^ 31; |
| 713 | #else |
| 714 | return __builtin_clz(Val); |
| 715 | #endif |
| 716 | } |
| 717 | }; |
| 718 | |
| 719 | #if !defined(_MSC_VER) || defined(_M_X64) |
| 720 | template <typename T> struct LeadingZerosCounter<T, 8> { |
| 721 | static std::size_t count(T Val, ZeroBehavior ZB) { |
| 722 | if (ZB != ZB_Undefined && Val == 0) |
| 723 | return 64; |
| 724 | |
| 725 | #if defined(_MSC_VER) |
| 726 | unsigned long Index; |
| 727 | _BitScanReverse64(&Index, Val); |
| 728 | return Index ^ 63; |
| 729 | #else |
| 730 | return __builtin_clzll(Val); |
| 731 | #endif |
| 732 | } |
| 733 | }; |
| 734 | #endif |
| 735 | #endif |
| 736 | |
| 737 | /// \brief Count number of 0's from the most significant bit to the least |
| 738 | /// stopping at the first 1. |
| 739 | /// |
| 740 | /// Only unsigned integral types are allowed. |
| 741 | /// |
| 742 | /// \param ZB the behavior on an input of 0. Only ZB_Width and ZB_Undefined are |
| 743 | /// valid arguments. |
| 744 | template <typename T> |
| 745 | std::size_t countLeadingZeros(T Val, ZeroBehavior ZB = ZB_Width) { |
| 746 | static_assert(std::numeric_limits<T>::is_integer && |
| 747 | !std::numeric_limits<T>::is_signed, |
| 748 | "Only unsigned integral types are allowed."); |
| 749 | return LeadingZerosCounter<T, sizeof(T)>::count(Val, ZB); |
| 750 | } |
| 751 | |
| 752 | /// Make a 64-bit integer from a high / low pair of 32-bit integers. |
| 753 | constexpr inline uint64_t Make_64(uint32_t High, uint32_t Low) { |
| 754 | return ((uint64_t)High << 32) | (uint64_t)Low; |
| 755 | } |
| 756 | |
| 757 | /// Return the high 32 bits of a 64 bit value. |
| 758 | constexpr inline uint32_t Hi_32(uint64_t Value) { |
| 759 | return static_cast<uint32_t>(Value >> 32); |
| 760 | } |
| 761 | |
| 762 | /// Return the low 32 bits of a 64 bit value. |
| 763 | constexpr inline uint32_t Lo_32(uint64_t Value) { |
| 764 | return static_cast<uint32_t>(Value); |
| 765 | } |
| 766 | |
| 767 | /// Implementation of Knuth's Algorithm D (Division of nonnegative integers) |
| 768 | /// from "Art of Computer Programming, Volume 2", section 4.3.1, p. 272. The |
| 769 | /// variables here have the same names as in the algorithm. Comments explain |
| 770 | /// the algorithm and any deviation from it. |
| 771 | static void KnuthDiv(uint32_t *u, uint32_t *v, uint32_t *q, uint32_t* r, |
| 772 | unsigned m, unsigned n) |
| 773 | { |
| 774 | assert(u && "Must provide dividend"); |
| 775 | assert(v && "Must provide divisor"); |
| 776 | assert(q && "Must provide quotient"); |
| 777 | assert(u != v && u != q && v != q && "Must use different memory"); |
| 778 | assert(n>1 && "n must be > 1"); |
| 779 | |
| 780 | // b denotes the base of the number system. In our case b is 2^32. |
| 781 | const uint64_t b = uint64_t(1) << 32; |
| 782 | |
| 783 | // D1. [Normalize.] Set d = b / (v[n-1] + 1) and multiply all the digits of |
| 784 | // u and v by d. Note that we have taken Knuth's advice here to use a power |
| 785 | // of 2 value for d such that d * v[n-1] >= b/2 (b is the base). A power of |
| 786 | // 2 allows us to shift instead of multiply and it is easy to determine the |
| 787 | // shift amount from the leading zeros. We are basically normalizing the u |
| 788 | // and v so that its high bits are shifted to the top of v's range without |
| 789 | // overflow. Note that this can require an extra word in u so that u must |
| 790 | // be of length m+n+1. |
| 791 | unsigned shift = countLeadingZeros(v[n-1]); |
| 792 | uint32_t v_carry = 0; |
| 793 | uint32_t u_carry = 0; |
| 794 | if (shift) { |
| 795 | for (unsigned i = 0; i < m+n; ++i) { |
| 796 | uint32_t u_tmp = u[i] >> (32 - shift); |
| 797 | u[i] = (u[i] << shift) | u_carry; |
| 798 | u_carry = u_tmp; |
| 799 | } |
| 800 | for (unsigned i = 0; i < n; ++i) { |
| 801 | uint32_t v_tmp = v[i] >> (32 - shift); |
| 802 | v[i] = (v[i] << shift) | v_carry; |
| 803 | v_carry = v_tmp; |
| 804 | } |
| 805 | } |
| 806 | u[m+n] = u_carry; |
| 807 | |
| 808 | // D2. [Initialize j.] Set j to m. This is the loop counter over the places. |
| 809 | int j = m; |
| 810 | do { |
| 811 | // D3. [Calculate q'.]. |
| 812 | // Set qp = (u[j+n]*b + u[j+n-1]) / v[n-1]. (qp=qprime=q') |
| 813 | // Set rp = (u[j+n]*b + u[j+n-1]) % v[n-1]. (rp=rprime=r') |
| 814 | // Now test if qp == b or qp*v[n-2] > b*rp + u[j+n-2]; if so, decrease |
| 815 | // qp by 1, increase rp by v[n-1], and repeat this test if rp < b. The test |
| 816 | // on v[n-2] determines at high speed most of the cases in which the trial |
| 817 | // value qp is one too large, and it eliminates all cases where qp is two |
| 818 | // too large. |
| 819 | uint64_t dividend = Make_64(u[j+n], u[j+n-1]); |
| 820 | uint64_t qp = dividend / v[n-1]; |
| 821 | uint64_t rp = dividend % v[n-1]; |
| 822 | if (qp == b || qp*v[n-2] > b*rp + u[j+n-2]) { |
| 823 | qp--; |
| 824 | rp += v[n-1]; |
| 825 | if (rp < b && (qp == b || qp*v[n-2] > b*rp + u[j+n-2])) |
| 826 | qp--; |
| 827 | } |
| 828 | |
| 829 | // D4. [Multiply and subtract.] Replace (u[j+n]u[j+n-1]...u[j]) with |
| 830 | // (u[j+n]u[j+n-1]..u[j]) - qp * (v[n-1]...v[1]v[0]). This computation |
| 831 | // consists of a simple multiplication by a one-place number, combined with |
| 832 | // a subtraction. |
| 833 | // The digits (u[j+n]...u[j]) should be kept positive; if the result of |
| 834 | // this step is actually negative, (u[j+n]...u[j]) should be left as the |
| 835 | // true value plus b**(n+1), namely as the b's complement of |
| 836 | // the true value, and a "borrow" to the left should be remembered. |
| 837 | int64_t borrow = 0; |
| 838 | for (unsigned i = 0; i < n; ++i) { |
| 839 | uint64_t p = uint64_t(qp) * uint64_t(v[i]); |
| 840 | int64_t subres = int64_t(u[j+i]) - borrow - Lo_32(p); |
| 841 | u[j+i] = Lo_32(subres); |
| 842 | borrow = Hi_32(p) - Hi_32(subres); |
| 843 | } |
| 844 | bool isNeg = u[j+n] < borrow; |
| 845 | u[j+n] -= Lo_32(borrow); |
| 846 | |
| 847 | // D5. [Test remainder.] Set q[j] = qp. If the result of step D4 was |
| 848 | // negative, go to step D6; otherwise go on to step D7. |
| 849 | q[j] = Lo_32(qp); |
| 850 | if (isNeg) { |
| 851 | // D6. [Add back]. The probability that this step is necessary is very |
| 852 | // small, on the order of only 2/b. Make sure that test data accounts for |
| 853 | // this possibility. Decrease q[j] by 1 |
| 854 | q[j]--; |
| 855 | // and add (0v[n-1]...v[1]v[0]) to (u[j+n]u[j+n-1]...u[j+1]u[j]). |
| 856 | // A carry will occur to the left of u[j+n], and it should be ignored |
| 857 | // since it cancels with the borrow that occurred in D4. |
| 858 | bool carry = false; |
| 859 | for (unsigned i = 0; i < n; i++) { |
| 860 | uint32_t limit = std::min(u[j+i],v[i]); |
| 861 | u[j+i] += v[i] + carry; |
| 862 | carry = u[j+i] < limit || (carry && u[j+i] == limit); |
| 863 | } |
| 864 | u[j+n] += carry; |
| 865 | } |
| 866 | |
| 867 | // D7. [Loop on j.] Decrease j by one. Now if j >= 0, go back to D3. |
| 868 | } while (--j >= 0); |
| 869 | |
| 870 | // D8. [Unnormalize]. Now q[...] is the desired quotient, and the desired |
| 871 | // remainder may be obtained by dividing u[...] by d. If r is non-null we |
| 872 | // compute the remainder (urem uses this). |
| 873 | if (r) { |
| 874 | // The value d is expressed by the "shift" value above since we avoided |
| 875 | // multiplication by d by using a shift left. So, all we have to do is |
| 876 | // shift right here. |
| 877 | if (shift) { |
| 878 | uint32_t carry = 0; |
| 879 | for (int i = n-1; i >= 0; i--) { |
| 880 | r[i] = (u[i] >> shift) | carry; |
| 881 | carry = u[i] << (32 - shift); |
| 882 | } |
| 883 | } else { |
| 884 | for (int i = n-1; i >= 0; i--) { |
| 885 | r[i] = u[i]; |
| 886 | } |
| 887 | } |
| 888 | } |
| 889 | } |
| 890 | |
| 891 | // Implementation ported from LLVM/lib/Support/APInt.cpp |
| 892 | static void bigint_unsigned_division(const BigInt *op1, const BigInt *op2, BigInt *Quotient, BigInt *Remainder) { |
| 893 | Cmp cmp = bigint_cmp(op1, op2); |
| 894 | if (cmp == CmpLT) { |
| 895 | if (Quotient != nullptr) { |
| 896 | bigint_init_unsigned(Quotient, 0); |
| 897 | } |
| 898 | if (Remainder != nullptr) { |
| 899 | bigint_init_bigint(Remainder, op1); |
| 900 | } |
| 901 | return; |
| 902 | } |
| 903 | if (cmp == CmpEQ) { |
| 904 | if (Quotient != nullptr) { |
| 905 | bigint_init_unsigned(Quotient, 1); |
| 906 | } |
| 907 | if (Remainder != nullptr) { |
| 908 | bigint_init_unsigned(Remainder, 0); |
| 909 | } |
| 910 | return; |
| 911 | } |
| 912 | |
| 913 | const uint64_t *LHS = bigint_ptr(op1); |
| 914 | const uint64_t *RHS = bigint_ptr(op2); |
| 915 | unsigned lhsWords = op1->digit_count; |
| 916 | unsigned rhsWords = op2->digit_count; |
| 917 | |
| 918 | // First, compose the values into an array of 32-bit words instead of |
| 919 | // 64-bit words. This is a necessity of both the "short division" algorithm |
| 920 | // and the Knuth "classical algorithm" which requires there to be native |
| 921 | // operations for +, -, and * on an m bit value with an m*2 bit result. We |
| 922 | // can't use 64-bit operands here because we don't have native results of |
| 923 | // 128-bits. Furthermore, casting the 64-bit values to 32-bit values won't |
| 924 | // work on large-endian machines. |
| 925 | unsigned n = rhsWords * 2; |
| 926 | unsigned m = (lhsWords * 2) - n; |
| 927 | |
| 928 | // Allocate space for the temporary values we need either on the stack, if |
| 929 | // it will fit, or on the heap if it won't. |
| 930 | uint32_t SPACE[128]; |
| 931 | uint32_t *U = nullptr; |
| 932 | uint32_t *V = nullptr; |
| 933 | uint32_t *Q = nullptr; |
| 934 | uint32_t *R = nullptr; |
| 935 | if ((Remainder?4:3)*n+2*m+1 <= 128) { |
| 936 | U = &SPACE[0]; |
| 937 | V = &SPACE[m+n+1]; |
| 938 | Q = &SPACE[(m+n+1) + n]; |
| 939 | if (Remainder) |
| 940 | R = &SPACE[(m+n+1) + n + (m+n)]; |
| 941 | } else { |
| 942 | U = new uint32_t[m + n + 1]; |
| 943 | V = new uint32_t[n]; |
| 944 | Q = new uint32_t[m+n]; |
| 945 | if (Remainder) |
| 946 | R = new uint32_t[n]; |
| 947 | } |
| 948 | |
| 949 | // Initialize the dividend |
| 950 | memset(U, 0, (m+n+1)*sizeof(uint32_t)); |
| 951 | for (unsigned i = 0; i < lhsWords; ++i) { |
| 952 | uint64_t tmp = LHS[i]; |
| 953 | U[i * 2] = Lo_32(tmp); |
| 954 | U[i * 2 + 1] = Hi_32(tmp); |
| 955 | } |
| 956 | U[m+n] = 0; // this extra word is for "spill" in the Knuth algorithm. |
| 957 | |
| 958 | // Initialize the divisor |
| 959 | memset(V, 0, (n)*sizeof(uint32_t)); |
| 960 | for (unsigned i = 0; i < rhsWords; ++i) { |
| 961 | uint64_t tmp = RHS[i]; |
| 962 | V[i * 2] = Lo_32(tmp); |
| 963 | V[i * 2 + 1] = Hi_32(tmp); |
| 964 | } |
| 965 | |
| 966 | // initialize the quotient and remainder |
| 967 | memset(Q, 0, (m+n) * sizeof(uint32_t)); |
| 968 | if (Remainder) |
| 969 | memset(R, 0, n * sizeof(uint32_t)); |
| 970 | |
| 971 | // Now, adjust m and n for the Knuth division. n is the number of words in |
| 972 | // the divisor. m is the number of words by which the dividend exceeds the |
| 973 | // divisor (i.e. m+n is the length of the dividend). These sizes must not |
| 974 | // contain any zero words or the Knuth algorithm fails. |
| 975 | for (unsigned i = n; i > 0 && V[i-1] == 0; i--) { |
| 976 | n--; |
| 977 | m++; |
| 978 | } |
| 979 | for (unsigned i = m+n; i > 0 && U[i-1] == 0; i--) |
| 980 | m--; |
| 981 | |
| 982 | // If we're left with only a single word for the divisor, Knuth doesn't work |
| 983 | // so we implement the short division algorithm here. This is much simpler |
| 984 | // and faster because we are certain that we can divide a 64-bit quantity |
| 985 | // by a 32-bit quantity at hardware speed and short division is simply a |
| 986 | // series of such operations. This is just like doing short division but we |
| 987 | // are using base 2^32 instead of base 10. |
| 988 | assert(n != 0 && "Divide by zero?"); |
| 989 | if (n == 1) { |
| 990 | uint32_t divisor = V[0]; |
| 991 | uint32_t remainder = 0; |
| 992 | for (int i = m; i >= 0; i--) { |
| 993 | uint64_t partial_dividend = Make_64(remainder, U[i]); |
| 994 | if (partial_dividend == 0) { |
| 995 | Q[i] = 0; |
| 996 | remainder = 0; |
| 997 | } else if (partial_dividend < divisor) { |
| 998 | Q[i] = 0; |
| 999 | remainder = Lo_32(partial_dividend); |
| 1000 | } else if (partial_dividend == divisor) { |
| 1001 | Q[i] = 1; |
| 1002 | remainder = 0; |
| 1003 | } else { |
| 1004 | Q[i] = Lo_32(partial_dividend / divisor); |
| 1005 | remainder = Lo_32(partial_dividend - (Q[i] * divisor)); |
| 1006 | } |
| 1007 | } |
| 1008 | if (R) |
| 1009 | R[0] = remainder; |
| 1010 | } else { |
| 1011 | // Now we're ready to invoke the Knuth classical divide algorithm. In this |
| 1012 | // case n > 1. |
| 1013 | KnuthDiv(U, V, Q, R, m, n); |
| 1014 | } |
| 1015 | |
| 1016 | // If the caller wants the quotient |
| 1017 | if (Quotient) { |
| 1018 | Quotient->digit_count = lhsWords; |
| 1019 | Quotient->data.digits = allocate<uint64_t>(lhsWords); |
| 1020 | Quotient->is_negative = false; |
| 1021 | for (size_t i = 0; i < lhsWords; i += 1) { |
| 1022 | Quotient->data.digits[i] = Make_64(Q[i*2+1], Q[i*2]); |
| 1023 | } |
| 1024 | } |
| 1025 | |
| 1026 | // If the caller wants the remainder |
| 1027 | if (Remainder) { |
| 1028 | Remainder->digit_count = rhsWords; |
| 1029 | Remainder->data.digits = allocate<uint64_t>(rhsWords); |
| 1030 | Remainder->is_negative = false; |
| 1031 | for (size_t i = 0; i < rhsWords; i += 1) { |
| 1032 | Remainder->data.digits[i] = Make_64(R[i*2+1], R[i*2]); |
| 1033 | } |
| 1034 | } |
| 1035 | } |
| 1036 | |
| 673 | 1037 | void bigint_div_trunc(BigInt *dest, const BigInt *op1, const BigInt *op2) { |
| 674 | 1038 | assert(op2->digit_count != 0); // division by zero |
| 675 | 1039 | if (op1->digit_count == 0) { |
| 676 | 1040 | bigint_init_unsigned(dest, 0); |
| 677 | 1041 | return; |
| 678 | 1042 | } |
| 679 | | if (op1->digit_count != 1 || op2->digit_count != 1) { |
| 680 | | zig_panic("TODO bigint div_trunc with >1 digits"); |
| 681 | | } |
| 682 | 1043 | const uint64_t *op1_digits = bigint_ptr(op1); |
| 683 | 1044 | const uint64_t *op2_digits = bigint_ptr(op2); |
| 684 | | dest->data.digit = op1_digits[0] / op2_digits[0]; |
| 685 | | dest->digit_count = 1; |
| 1045 | if (op1->digit_count == 1 && op2->digit_count == 1) { |
| 1046 | dest->data.digit = op1_digits[0] / op2_digits[0]; |
| 1047 | dest->digit_count = 1; |
| 1048 | dest->is_negative = op1->is_negative != op2->is_negative; |
| 1049 | bigint_normalize(dest); |
| 1050 | return; |
| 1051 | } |
| 1052 | if (op2->digit_count == 1 && op2_digits[0] == 1) { |
| 1053 | // X / 1 == X |
| 1054 | bigint_init_bigint(dest, op1); |
| 1055 | dest->is_negative = op1->is_negative != op2->is_negative; |
| 1056 | bigint_normalize(dest); |
| 1057 | return; |
| 1058 | } |
| 1059 | |
| 1060 | const BigInt *op1_positive; |
| 1061 | BigInt op1_positive_data; |
| 1062 | if (op1->is_negative) { |
| 1063 | bigint_negate(&op1_positive_data, op1); |
| 1064 | op1_positive = &op1_positive_data; |
| 1065 | } else { |
| 1066 | op1_positive = op1; |
| 1067 | } |
| 1068 | |
| 1069 | const BigInt *op2_positive; |
| 1070 | BigInt op2_positive_data; |
| 1071 | if (op2->is_negative) { |
| 1072 | bigint_negate(&op2_positive_data, op2); |
| 1073 | op2_positive = &op2_positive_data; |
| 1074 | } else { |
| 1075 | op2_positive = op2; |
| 1076 | } |
| 1077 | |
| 1078 | bigint_unsigned_division(op1_positive, op2_positive, dest, nullptr); |
| 686 | 1079 | dest->is_negative = op1->is_negative != op2->is_negative; |
| 687 | 1080 | bigint_normalize(dest); |
| 688 | 1081 | } |
| ... | ... | @@ -714,6 +1107,14 @@ void bigint_rem(BigInt *dest, const BigInt *op1, const BigInt *op2) { |
| 714 | 1107 | } |
| 715 | 1108 | const uint64_t *op1_digits = bigint_ptr(op1); |
| 716 | 1109 | const uint64_t *op2_digits = bigint_ptr(op2); |
| 1110 | |
| 1111 | if (op1->digit_count == 1 && op2->digit_count == 1) { |
| 1112 | dest->data.digit = op1_digits[0] % op2_digits[0]; |
| 1113 | dest->digit_count = 1; |
| 1114 | dest->is_negative = op1->is_negative; |
| 1115 | bigint_normalize(dest); |
| 1116 | return; |
| 1117 | } |
| 717 | 1118 | if (op2->digit_count == 2 && op2_digits[0] == 0 && op2_digits[1] == 1) { |
| 718 | 1119 | // special case this divisor |
| 719 | 1120 | bigint_init_unsigned(dest, op1_digits[0]); |
| ... | ... | @@ -721,11 +1122,32 @@ void bigint_rem(BigInt *dest, const BigInt *op1, const BigInt *op2) { |
| 721 | 1122 | bigint_normalize(dest); |
| 722 | 1123 | return; |
| 723 | 1124 | } |
| 724 | | if (op1->digit_count != 1 || op2->digit_count != 1) { |
| 725 | | zig_panic("TODO bigint rem with >1 digits"); |
| 1125 | |
| 1126 | if (op2->digit_count == 1 && op2_digits[0] == 1) { |
| 1127 | // X % 1 == 0 |
| 1128 | bigint_init_unsigned(dest, 0); |
| 1129 | return; |
| 726 | 1130 | } |
| 727 | | dest->data.digit = op1_digits[0] % op2_digits[0]; |
| 728 | | dest->digit_count = 1; |
| 1131 | |
| 1132 | const BigInt *op1_positive; |
| 1133 | BigInt op1_positive_data; |
| 1134 | if (op1->is_negative) { |
| 1135 | bigint_negate(&op1_positive_data, op1); |
| 1136 | op1_positive = &op1_positive_data; |
| 1137 | } else { |
| 1138 | op1_positive = op1; |
| 1139 | } |
| 1140 | |
| 1141 | const BigInt *op2_positive; |
| 1142 | BigInt op2_positive_data; |
| 1143 | if (op2->is_negative) { |
| 1144 | bigint_negate(&op2_positive_data, op2); |
| 1145 | op2_positive = &op2_positive_data; |
| 1146 | } else { |
| 1147 | op2_positive = op2; |
| 1148 | } |
| 1149 | |
| 1150 | bigint_unsigned_division(op1_positive, op2_positive, nullptr, dest); |
| 729 | 1151 | dest->is_negative = op1->is_negative; |
| 730 | 1152 | bigint_normalize(dest); |
| 731 | 1153 | } |
Andrew Kelley <andrew@ziglang.org> 2018-01-15 22:17:22-05:00
src