Lines Matching +full:left +full:- +full:shifted
5 This C source fragment is part of the SoftFloat IEC/IEEE Floating-point
11 National Science Foundation under grant MIP-9311980. The original version
12 of this code was written as part of a project to build a fixed-point vector
16 http://www.jhauser.us/arithmetic/SoftFloat-2b/SoftFloat-source.txt
33 -------------------------------------------------------------------------------
35 bits are shifted off, they are ``jammed'' into the least significant bit of
40 -------------------------------------------------------------------------------
49 z = ( a>>count ) | ( ( a<<( ( - count ) & 31 ) ) != 0 );
58 -------------------------------------------------------------------------------
60 bits are shifted off, they are ``jammed'' into the least significant bit of
65 -------------------------------------------------------------------------------
71 __asm__("@shift64RightJamming -- start");
76 z = ( a>>count ) | ( ( a<<( ( - count ) & 63 ) ) != 0 );
81 __asm__("@shift64RightJamming -- end");
86 -------------------------------------------------------------------------------
87 Shifts the 128-bit value formed by concatenating `a0' and `a1' right by 64
88 _plus_ the number of bits given in `count'. The shifted result is at most
90 bits shifted off form a second 64-bit result as follows: The _last_ bit
91 shifted off is the most-significant bit of the extra result, and the other
93 bits shifted off were all zero. This extra result is stored in the location
96 fixed-point value with binary point between `a0' and `a1'. This fixed-point
97 value is shifted right by the number of bits given in `count', and the
101 -------------------------------------------------------------------------------
108 int8 negCount = ( - count ) & 63;
133 -------------------------------------------------------------------------------
134 Shifts the 128-bit value formed by concatenating `a0' and `a1' right by the
135 number of bits given in `count'. Any bits shifted off are lost. The value
137 than 128, the result will be 0. The result is broken into two 64-bit pieces
139 -------------------------------------------------------------------------------
146 int8 negCount = ( - count ) & 63;
166 -------------------------------------------------------------------------------
167 Shifts the 128-bit value formed by concatenating `a0' and `a1' right by the
168 number of bits given in `count'. If any nonzero bits are shifted off, they
173 nonzero. The result is broken into two 64-bit pieces which are stored at
175 -------------------------------------------------------------------------------
182 int8 negCount = ( - count ) & 63;
210 -------------------------------------------------------------------------------
211 Shifts the 192-bit value formed by concatenating `a0', `a1', and `a2' right
212 by 64 _plus_ the number of bits given in `count'. The shifted result is
213 at most 128 nonzero bits; these are broken into two 64-bit pieces which are
214 stored at the locations pointed to by `z0Ptr' and `z1Ptr'. The bits shifted
215 off form a third 64-bit result as follows: The _last_ bit shifted off is
216 the most-significant bit of the extra result, and the other 63 bits of the
217 extra result are all zero if and only if _all_but_the_last_ bits shifted off
221 to form a fixed-point value with binary point between `a1' and `a2'. This
222 fixed-point value is shifted right by the number of bits given in `count',
227 -------------------------------------------------------------------------------
241 int8 negCount = ( - count ) & 63;
281 -------------------------------------------------------------------------------
282 Shifts the 128-bit value formed by concatenating `a0' and `a1' left by the
283 number of bits given in `count'. Any bits shifted off are lost. The value
284 of `count' must be less than 64. The result is broken into two 64-bit
286 -------------------------------------------------------------------------------
295 ( count == 0 ) ? a0 : ( a0<<count ) | ( a1>>( ( - count ) & 63 ) );
300 -------------------------------------------------------------------------------
301 Shifts the 192-bit value formed by concatenating `a0', `a1', and `a2' left
302 by the number of bits given in `count'. Any bits shifted off are lost.
304 64-bit pieces which are stored at the locations pointed to by `z0Ptr',
306 -------------------------------------------------------------------------------
326 negCount = ( ( - count ) & 63 );
337 -------------------------------------------------------------------------------
338 Adds the 128-bit value formed by concatenating `a0' and `a1' to the 128-bit
340 any carry out is lost. The result is broken into two 64-bit pieces which
342 -------------------------------------------------------------------------------
357 -------------------------------------------------------------------------------
358 Adds the 192-bit value formed by concatenating `a0', `a1', and `a2' to the
359 192-bit value formed by concatenating `b0', `b1', and `b2'. Addition is
361 64-bit pieces which are stored at the locations pointed to by `z0Ptr',
363 -------------------------------------------------------------------------------
396 -------------------------------------------------------------------------------
397 Subtracts the 128-bit value formed by concatenating `b0' and `b1' from the
398 128-bit value formed by concatenating `a0' and `a1'. Subtraction is modulo
400 64-bit pieces which are stored at the locations pointed to by `z0Ptr' and
402 -------------------------------------------------------------------------------
409 *z1Ptr = a1 - b1;
410 *z0Ptr = a0 - b0 - ( a1 < b1 );
415 -------------------------------------------------------------------------------
416 Subtracts the 192-bit value formed by concatenating `b0', `b1', and `b2'
417 from the 192-bit value formed by concatenating `a0', `a1', and `a2'.
419 result is broken into three 64-bit pieces which are stored at the locations
421 -------------------------------------------------------------------------------
439 z2 = a2 - b2;
441 z1 = a1 - b1;
443 z0 = a0 - b0;
444 z0 -= ( z1 < borrow1 );
445 z1 -= borrow1;
446 z0 -= borrow0;
454 -------------------------------------------------------------------------------
455 Multiplies `a' by `b' to obtain a 128-bit product. The product is broken
456 into two 64-bit pieces which are stored at the locations pointed to by
458 -------------------------------------------------------------------------------
484 -------------------------------------------------------------------------------
485 Multiplies the 128-bit value formed by concatenating `a0' and `a1' by `b' to
486 obtain a 192-bit product. The product is broken into three 64-bit pieces
489 -------------------------------------------------------------------------------
513 -------------------------------------------------------------------------------
514 Multiplies the 128-bit value formed by concatenating `a0' and `a1' to the
515 128-bit value formed by concatenating `b0' and `b1' to obtain a 256-bit
516 product. The product is broken into four 64-bit pieces which are stored at
518 -------------------------------------------------------------------------------
551 -------------------------------------------------------------------------------
552 Returns an approximation to the 64-bit integer quotient obtained by dividing
553 `b' into the 128-bit value formed by concatenating `a0' and `a1'. The
556 If the exact quotient q is larger than 64 bits, the maximum positive 64-bit
558 -------------------------------------------------------------------------------
577 z -= LIT64( 0x100000000 );
593 -------------------------------------------------------------------------------
594 Returns an approximation to the square root of the 32-bit significand given
599 case, the approximation returned lies strictly within +/-2 of the exact
601 -------------------------------------------------------------------------------
619 z = 0x4000 + ( a>>17 ) - sqrtOddAdjustments[ index ];
624 z = 0x8000 + ( a>>17 ) - sqrtEvenAdjustments[ index ];
636 -------------------------------------------------------------------------------
637 Returns the number of leading 0 bits before the most-significant 1 bit
639 -------------------------------------------------------------------------------
678 -------------------------------------------------------------------------------
679 Returns the number of leading 0 bits before the most-significant 1 bit
681 -------------------------------------------------------------------------------
700 -------------------------------------------------------------------------------
701 Returns 1 if the 128-bit value formed by concatenating `a0' and `a1'
702 is equal to the 128-bit value formed by concatenating `b0' and `b1'.
704 -------------------------------------------------------------------------------
714 -------------------------------------------------------------------------------
715 Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is less
716 than or equal to the 128-bit value formed by concatenating `b0' and `b1'.
718 -------------------------------------------------------------------------------
728 -------------------------------------------------------------------------------
729 Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is less
730 than the 128-bit value formed by concatenating `b0' and `b1'. Otherwise,
732 -------------------------------------------------------------------------------
742 -------------------------------------------------------------------------------
743 Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is
744 not equal to the 128-bit value formed by concatenating `b0' and `b1'.
746 -------------------------------------------------------------------------------