Lines Matching defs:bits
33 #include "src/base/bits.h"
133 int index = base::bits::CountTrailingZeros(list_);
434 DCHECK(m >= kInstrSize && base::bits::IsPowerOfTwo(m));
3571 // bits: aBbb.bbbb.bbcd.efgh.0000.0000.0000.0000
3573 uint64_t bits = bit_cast<uint64_t>(imm);
3575 uint64_t bit7 = ((bits >> 63) & 0x1) << 7;
3577 uint64_t bit6 = ((bits >> 61) & 0x1) << 6;
3579 uint64_t bit5_to_0 = (bits >> 48) & 0x3F;
3592 // Ignore the top 32 bits of an immediate if we're moving to a W register.
3594 // Check that the top 32 bits are zero (a positive 32-bit number) or top
3595 // 33 bits are one (a negative 32-bit number, sign extended to 64 bits).
3894 // Number of bits left in the result that are not introduced by the shift.
3920 // No need to extend as the extended bits would be shifted away.
4054 // (s bits must not be all set)
4056 // A pattern is constructed of size bits, where the least significant S+1 bits
4061 // contiguous stretch of 1 bits, repeated across the whole word at intervals
4063 // lowest stretch of 1 bits, then the next 1 bit above that; that combination
4068 // (The rotation parameter does give the possibility of the stretch of 1 bits
4087 // The most-significant 32 bits may not be zero (ie. negate is true) so
4101 // bottommost stretch of set bits and replaces it with a 1 carried into the
4104 // but with the lowest stretch of set bits completely gone. Now we find the
4108 // to this number is the one in which a stretch of bits running from a to just
4109 // below b is replicated every d bits.
4120 // The general case, in which there is more than one stretch of set bits.
4122 // unit of repetition (i.e. a word with the bottom d bits set). Also, in all
4137 // The input was zero (or all 1 bits, which will come to here too after we
4143 // of set bits in our word, meaning that we have the trivial case of
4154 if (!base::bits::IsPowerOfTwo(d)) {
4164 // The only possible option is b - a repeated every d bits. Now we're going to
4168 // To repeat a value every d bits, we multiply it by a number of the form
4188 // construct the bits and pieces of the instruction encoding that generates
4191 // Count the set bits in our basic stretch. The special case of clz(0) == -1
4197 // Decide how many bits to rotate right by, to put the low bit of that basic
4202 // where we compensate: the number of set bits becomes the number of clear
4203 // bits, and the rotation count is based on position b rather than position
4212 // it gives both the number of set bits and the length of the repeated
4238 uint32_t bits = bit_cast<uint32_t>(imm);
4239 // bits[19..0] are cleared.
4240 if ((bits & 0x7FFFF) != 0) {
4244 // bits[29..25] are all set or all cleared.
4245 uint32_t b_pattern = (bits >> 16) & 0x3E00;
4251 if (((bits ^ (bits << 1)) & 0x40000000) == 0) {
4262 uint64_t bits = bit_cast<uint64_t>(imm);
4263 // bits[47..0] are cleared.
4264 if ((bits & 0xFFFFFFFFFFFFL) != 0) {
4268 // bits[61..54] are all set or all cleared.
4269 uint32_t b_pattern = (bits >> 48) & 0x3FC0;
4275 if (((bits ^ (bits << 1)) & 0x4000000000000000L) == 0) {
4406 // Recorded constant pool size is expressed in number of 32-bits words,
4666 // Addresses are only 48 bits.