Changeset 10152


Ignore:
Timestamp:
Jul 19, 2008, 10:15:52 PM (11 years ago)
Author:
rme
Message:

32-bit %BIGNUM-RANDOM: account for endianness (so that random produces
the same results on ppc32 and x8632).

FIXNUM-SFLOAT-COMPARE, TRUNCATE, TRUNCATE-NO-REM: conditionalize on
32-bit-target rather than ppc32-target.

most-positive-fixnum => target::target-most-positive-fixnum
most-negative-fixnum => target::target-most-negative-fixnum

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/source/level-0/l0-numbers.lisp

    r9882 r10152  
    467467  (if (and (eq int 0)(= sfloat 0.0s0))
    468468    0
    469     (#+32-bit-target ppc32::with-stack-short-floats #+32-bit-target ((s1 int))
     469    (#+32-bit-target target::with-stack-short-floats #+32-bit-target ((s1 int))
    470470     #-32-bit-target let* #-32-bit-target ((s1 (%int-to-sfloat int)))
    471471                     (locally
     
    10681068                     (%double-float--2 fnum (%double-float*-2! (%double-float res f2) ,divisor f2))))))
    10691069       (truncate-rat-sfloat (number divisor)
    1070          #+ppc32-target
    1071          `(ppc32::with-stack-short-floats ((fnum ,number)
     1070         #+32-bit-target
     1071         `(target::with-stack-short-floats ((fnum ,number)
    10721072                                           (f2))
    10731073           (let ((res (%unary-truncate (%short-float/-2! fnum ,divisor f2))))
     
    10851085    (number-case number
    10861086      (fixnum
    1087        (if (eql number most-negative-fixnum)
     1087       (if (eql number target::target-most-negative-fixnum)
    10881088         (if (zerop divisor)
    10891089           (error 'division-by-zero :operation 'truncate :operands (list number divisor))
     
    11031103      (bignum (number-case divisor
    11041104                (fixnum (if (eq divisor 1) (values number 0)
    1105                           (if (eq divisor most-negative-fixnum);; << aargh
     1105                          (if (eq divisor target::target-most-negative-fixnum);; << aargh
    11061106                            (with-small-bignum-buffers ((bd divisor))
    11071107                              (bignum-truncate number bd))
     
    11181118                     (number-case divisor
    11191119                       (short-float
    1120                         #+ppc32-target
    1121                         (ppc32::with-stack-short-floats ((f2))
     1120                        #+32-bit-target
     1121                        (target::with-stack-short-floats ((f2))
    11221122                          (let ((res (%unary-truncate (%short-float/-2! number divisor f2))))
    11231123                            (values res
     
    11341134                                          (the short-float divisor))))))
    11351135                       ((fixnum bignum ratio)
    1136                         #+ppc32-target
    1137                         (ppc32::with-stack-short-floats ((fdiv divisor)
     1136                        #+32-bit-target
     1137                        (target::with-stack-short-floats ((fdiv divisor)
    11381138                                                         (f2))
    11391139                          (let ((res (%unary-truncate (%short-float/-2! number fdiv f2))))
     
    11931193         (%unary-truncate (%double-float/-2! fnum ,divisor f2))))
    11941194     (truncate-rat-sfloat (number divisor)
    1195        #+ppc32-target
    1196        `(ppc32::with-stack-short-floats ((fnum ,number)
     1195       #+32-bit-target
     1196       `(target::with-stack-short-floats ((fnum ,number)
    11971197                                      (f2))
    11981198         (%unary-truncate (%short-float/-2! fnum ,divisor f2)))
     
    12031203    (number-case number
    12041204    (fixnum
    1205      (if (eql number most-negative-fixnum)
     1205     (if (eql number target::target-most-negative-fixnum)
    12061206       (if (zerop divisor)
    12071207         (error 'division-by-zero :operation 'truncate :operands (list number divisor))
     
    12211221     (bignum (number-case divisor
    12221222               (fixnum (if (eq divisor 1) number
    1223                          (if (eq divisor most-negative-fixnum)
     1223                         (if (eq divisor target::target-most-negative-fixnum)
    12241224                           (with-small-bignum-buffers ((bd divisor))
    12251225                             (bignum-truncate number bd :no-rem))
     
    12521252                    (number-case divisor
    12531253                      ((fixnum bignum ratio)
    1254                        #+ppc32-target
    1255                        (ppc32::with-stack-short-floats ((fdiv divisor)
     1254                       #+32-bit-target
     1255                       (target::with-stack-short-floats ((fdiv divisor)
    12561256                                                 (f2))
    12571257                         (let ((res (%unary-truncate (%short-float/-2! number fdiv f2))))
     
    12611261                                           (the short-float (%short-float divisor)))))
    12621262                      (short-float
    1263                        #+ppc32-target
    1264                        (ppc32::with-stack-short-floats ((ddiv divisor)
     1263                       #+32-bit-target
     1264                       (target::with-stack-short-floats ((ddiv divisor)
    12651265                                                      (f2))
    12661266                         (%unary-truncate (%short-float/-2! number ddiv f2)))
     
    14741474     (number-case divisor
    14751475       (fixnum
    1476         (if (eq divisor most-negative-fixnum)
     1476        (if (eq divisor target::target-most-negative-fixnum)
    14771477          (nth-value 1 (truncate number divisor))
    14781478          (bignum-truncate-by-fixnum-no-quo number divisor)))
     
    17201720                                    (mixup-hash-code
    17211721                                     (logand (get-internal-real-time)
    1722                                              (1- most-positive-fixnum))))))
     1722                                             (1- target::target-most-positive-fixnum))))))
    17231723         (high (ldb (byte 16 16) (if (zerop ticks) #x10000 ticks)))
    17241724         (low (ldb (byte 16 0) ticks)))
     
    18371837    (declare (fixnum long-words index bits)
    18381838             (dynamic-extent dividend)
    1839              (type (simple-array (unsigned-byte 16) (*)) 16-bit-dividend)       ; lie
     1839             (type (simple-array (unsigned-byte 16) (*)) 16-bit-dividend) ;lie
    18401840             (optimize (speed 3) (safety 0)))
    18411841    (loop
    1842       ;; This had better inline due to the lie above, or it will error
    1843       (setf (aref 16-bit-dividend index) (%next-random-seed state))
    1844       (decf half-words)
    1845       (when (<= half-words 0) (return))
    1846       (setf (aref 16-bit-dividend (the fixnum (1- index)))
    1847             (%next-random-seed state))
    1848       (decf half-words)
    1849       (when (<= half-words 0) (return))
    1850       (incf index 2))
     1842       ;; This had better inline due to the lie above, or it will error
     1843       #+big-endian-target
     1844       (setf (aref 16-bit-dividend index) (%next-random-seed state))
     1845       #+little-endian-target
     1846       (setf (aref 16-bit-dividend (the fixnum (1- index)))
     1847             (%next-random-seed state))
     1848       (decf half-words)
     1849       (when (<= half-words 0) (return))
     1850       #+big-endian-target
     1851       (setf (aref 16-bit-dividend (the fixnum (1- index)))
     1852             (%next-random-seed state))
     1853       #+little-endian-target
     1854       (setf (aref 16-bit-dividend index) (%next-random-seed state))
     1855       (decf half-words)
     1856       (when (<= half-words 0) (return))
     1857       (incf index 2))
    18511858    ;; The bignum code expects normalized bignums
    18521859    (let* ((result (mod dividend number)))
     
    18561863
    18571864(defun %float-random (number state)
    1858   (let ((ratio (gvector :ratio (random most-positive-fixnum state) most-positive-fixnum)))
     1865  (let ((ratio (gvector :ratio (random target::target-most-positive-fixnum state) target::target-most-positive-fixnum)))
    18591866    (declare (dynamic-extent ratio))
    18601867    (* number ratio)))
     
    18701877      `(let ((,n ,nexp))
    18711878         (if (minusp (the fixnum ,n))
    1872            (if (eq ,n most-negative-fixnum)
     1879           (if (eq ,n target::target-most-negative-fixnum)
    18731880             (- ,n)
    18741881             (the fixnum (- (the fixnum ,n))))
     
    18941901         (number-case n2
    18951902          (fixnum
    1896            (if (eql n1 most-negative-fixnum)
    1897              (if (eql n2 most-negative-fixnum)
    1898                (- most-negative-fixnum)
    1899                (bignum-fixnum-gcd (- most-negative-fixnum) (abs n2)))
    1900              (if (eql n2 most-negative-fixnum)
    1901                (bignum-fixnum-gcd (- most-negative-fixnum) (abs n1))
     1903           (if (eql n1 target::target-most-negative-fixnum)
     1904             (if (eql n2 target::target-most-negative-fixnum)
     1905               (- target::target-most-negative-fixnum)
     1906               (bignum-fixnum-gcd (- target::target-most-negative-fixnum) (abs n2)))
     1907             (if (eql n2 target::target-most-negative-fixnum)
     1908               (bignum-fixnum-gcd (- target::target-most-negative-fixnum) (abs n1))
    19021909               (locally
    19031910                   (declare (optimize (speed 3) (safety 0))
     
    19061913                 (if (minusp n2)(setq n2 (the fixnum (- n2))))
    19071914               (%fixnum-gcd n1 n2)))))
    1908            (bignum (if (eql n1 most-negative-fixnum)
    1909                      (%bignum-bignum-gcd n2 (- most-negative-fixnum))
     1915           (bignum (if (eql n1 target::target-most-negative-fixnum)
     1916                     (%bignum-bignum-gcd n2 (- target::target-most-negative-fixnum))
    19101917                     (bignum-fixnum-gcd (bignum-abs n2)(fixnum-abs n1))))))
    19111918        (bignum
    19121919         (number-case n2
    19131920           (fixnum
    1914             (if (eql n2 most-negative-fixnum)
     1921            (if (eql n2 target::target-most-negative-fixnum)
    19151922              (%bignum-bignum-gcd (bignum-abs n1)(fixnum-abs n2))
    19161923              (bignum-fixnum-gcd (bignum-abs n1)(fixnum-abs n2))))
Note: See TracChangeset for help on using the changeset viewer.