Lines Matching defs:bits
36 #include "src/base/bits.h"
423 // TODO(all): currently each relocated constant is 64 bits, consider adding
455 // A constant pool size is expressed in number of 32-bits words.
605 DCHECK(m >= 4 && base::bits::IsPowerOfTwo32(m));
2074 // bits: aBbb.bbbc.defg.h000.0000.0000.0000.0000
2075 uint32_t bits = float_to_rawbits(imm);
2077 uint32_t bit7 = ((bits >> 31) & 0x1) << 7;
2079 uint32_t bit6 = ((bits >> 29) & 0x1) << 6;
2081 uint32_t bit5_to_0 = (bits >> 19) & 0x3f;
2089 // bits: aBbb.bbbb.bbcd.efgh.0000.0000.0000.0000
2091 uint64_t bits = double_to_rawbits(imm);
2093 uint32_t bit7 = ((bits >> 63) & 0x1) << 7;
2095 uint32_t bit6 = ((bits >> 61) & 0x1) << 6;
2097 uint32_t bit5_to_0 = (bits >> 48) & 0x3f;
2108 // Ignore the top 32 bits of an immediate if we're moving to a W register.
2110 // Check that the top 32 bits are zero (a positive 32-bit number) or top
2111 // 33 bits are one (a negative 32-bit number, sign extended to 64 bits).
2393 // Bits extracted are high_bit:0.
2395 // Number of bits left in the result that are not introduced by the shift.
2416 // No need to extend as the extended bits would be shifted away.
2551 // (s bits must not be all set)
2553 // A pattern is constructed of size bits, where the least significant S+1 bits
2558 // contiguous stretch of 1 bits, repeated across the whole word at intervals
2560 // lowest stretch of 1 bits, then the next 1 bit above that; that combination
2565 // (The rotation parameter does give the possibility of the stretch of 1 bits
2584 // The most-significant 32 bits may not be zero (ie. negate is true) so
2598 // bottommost stretch of set bits and replaces it with a 1 carried into the
2601 // but with the lowest stretch of set bits completely gone. Now we find the
2605 // to this number is the one in which a stretch of bits running from a to just
2606 // below b is replicated every d bits.
2617 // The general case, in which there is more than one stretch of set bits.
2619 // unit of repetition (i.e. a word with the bottom d bits set). Also, in all
2634 // The input was zero (or all 1 bits, which will come to here too after we
2640 // of set bits in our word, meaning that we have the trivial case of
2661 // The only possible option is b - a repeated every d bits. Now we're going to
2665 // To repeat a value every d bits, we multiply it by a number of the form
2689 // construct the bits and pieces of the instruction encoding that generates
2692 // Count the set bits in our basic stretch. The special case of clz(0) == -1
2698 // Decide how many bits to rotate right by, to put the low bit of that basic
2703 // where we compensate: the number of set bits becomes the number of clear
2704 // bits, and the rotation count is based on position b rather than position
2713 // it gives both the number of set bits and the length of the repeated
2741 uint32_t bits = float_to_rawbits(imm);
2742 // bits[19..0] are cleared.
2743 if ((bits & 0x7ffff) != 0) {
2747 // bits[29..25] are all set or all cleared.
2748 uint32_t b_pattern = (bits >> 16) & 0x3e00;
2754 if (((bits ^ (bits << 1)) & 0x40000000) == 0) {
2766 uint64_t bits = double_to_rawbits(imm);
2767 // bits[47..0] are cleared.
2768 if ((bits & 0xffffffffffffL) != 0) {
2772 // bits[61..54] are all set or all cleared.
2773 uint32_t b_pattern = (bits >> 48) & 0x3fc0;
2779 if (((bits ^ (bits << 1)) & 0x4000000000000000L) == 0) {
3130 // Addresses are only 48 bits.
