Lines Matching defs:bit
158 ALOGI("Register Map bit difference stats:");
366 * Given a line of registers, output a bit vector that indicates whether
371 * in the low bit of the first byte.
382 val |= 0x80; /* set hi bit */
537 ALOGE("GLITCH: addr %d reg %d: bit=%d reg=%d(%d)",
560 * Advance "ptr" to ensure 32-bit alignment.
766 /* a bit late */
1100 Each entry consists of an address and a bit vector. Adjacent entries are
1105 bit vectors. However, the register values at a given address do not
1116 change the bit vector from its previous state.
1118 Each entry advances the address value by at least 1 (measured in 16-bit
1128 Using a 3-bit delta, with one value reserved as an escape code, should
1139 By observation, many entries simply repeat the previous bit vector, or
1146 1 bit changed: 32.2%
1148 changed is usually less than 1/10th of the number of entries with 1 bit
1149 changed. A solution that allows us to encode 0- or 1- bit changes
1153 probably want a way to drop in a full copy of the bit vector when it's
1154 smaller than the representation of multiple bit changes.
1157 The bit-change information can be encoded as an index that tells the
1171 state, but we know we'll never have to output a bit change for the last
1184 Looking at all bit changes in all methods, 94% are to registers 0-15. The
1194 In some cases there are repeating patterns in the bit vector that aren't
1214 +05+ 1B initial address (0-127), high bit set if max addr >= 256
1215 +06+ nB initial value for bit vector
1226 CCCC: if B is 0, this is the number of the bit to toggle (0-15).
1230 the entire bit vector.
1234 +01+: (optional) one or more ULEB128-encoded bit numbers, OR the entire
1235 bit vector.
1238 code units, has no changes or just a single bit change, and the changed
1301 * Compare bit vectors in adjacent entries. We want to count
1313 int prev, cur, bit;
1318 for (bit = 0; bit < 8; bit++) {
1319 if (((prev >> bit) & 1) != ((cur >> bit) & 1)) {
1322 int bitNum = regByte * 8 + bit;
1334 ALOGE("WEIRD: bit=%d (%d/%d), prev=%02x cur=%02x",
1335 bit, regByte, method->registersSize,
1369 * Compute the difference between two bit vectors.
1371 * If "lebOutBuf" is non-NULL, we output the bit indices in ULEB128 format
1374 * The bit vectors are compared byte-by-byte, so any unused bits at the
1380 * receive the index of the first changed bit and the number of changed
1499 * The initial address offset and bit vector will take up less than
1523 * Start by writing the initial address and bit vector data. The high
1524 * bit of the initial address is used to indicate the required address
1583 /* set B to 0 and CCCC to the index of the changed bit */
1585 if (debug) ALOGI(" : 1 low bit changed");
1598 * diff (if it didn't fit in 3 bits), then the changed bit info.
1613 /* write bit indices in LEB128 format */
1619 /* single-bit changed, value encoded in key byte */
1680 * Toggle the value of the "idx"th bit in "ptr".
1715 /* get the initial address and the 16-bit address flag */
1789 /* full copy of bit vector is present; ignore prevBits */
1804 /* one bit, from 0-15 inclusive, was changed */