Lines Matching refs:bitpos
2908 unsigned HOST_WIDE_INT bitpos, xbitpos, padding_correction = 0;
2982 for (bitpos = 0, xbitpos = padding_correction;
2983 bitpos < bytes * BITS_PER_UNIT;
2984 bitpos += bitsize, xbitpos += bitsize)
2992 /* We need a new destination operand each time bitpos is on
2996 else if (bitpos % BITS_PER_WORD == 0)
2997 dst = operand_subword (target, bitpos / BITS_PER_WORD, 1, tmode);
3000 bitpos for the destination store (left justified). */
3001 store_bit_field (dst, bitsize, bitpos % BITS_PER_WORD, 0, 0, copy_mode,
3019 unsigned HOST_WIDE_INT bitpos, xbitpos, padding_correction = 0, bytes;
3058 for (bitpos = 0, xbitpos = padding_correction;
3059 bitpos < bytes * BITS_PER_UNIT;
3060 bitpos += bitsize, xbitpos += bitsize)
3087 if (msize <= ((bytes * BITS_PER_UNIT) - bitpos)
3095 /* We need a new source operand each time bitpos is on a word
3097 if (bitpos % BITS_PER_WORD == 0)
3098 src_word = operand_subword_force (x, bitpos / BITS_PER_WORD, BLKmode);
3100 /* Use bitpos for the source extraction (left justified) and
3105 bitpos % BITS_PER_WORD, 1,
5049 unsigned HOST_WIDE_INT bitsize, bitpos, bitregion_start, bitregion_end;
5052 || !pbitpos.is_constant (&bitpos)
5106 if (!get_best_mode (bitsize, bitpos, bitregion_start, bitregion_end,
5112 offset1 = bitpos;
5113 bitpos %= str_bitsize;
5114 offset1 = (offset1 - bitpos) / BITS_PER_UNIT;
5126 if (bitpos + bitsize > str_bitsize)
5130 bitpos = str_bitsize - bitpos - bitsize;
5142 if ((reverse || bitpos + bitsize != str_bitsize)
5160 if (bitsize == 1 && (reverse || bitpos + bitsize != str_bitsize))
5168 value = expand_shift (LSHIFT_EXPR, str_mode, value, bitpos, NULL_RTX, 1);
5196 if (bitpos + bitsize != str_bitsize)
5202 value = expand_shift (LSHIFT_EXPR, str_mode, value, bitpos, NULL_RTX, 1);
5221 Given a COMPONENT_REF EXP at position (BITPOS, OFFSET), this function
5223 belongs. The values are returned in *BITSTART and *BITEND. *BITPOS
5231 poly_int64_pod *bitpos, tree *offset)
5267 /* Compute the adjustment to bitpos from the offset of the field
5280 /* If the adjustment is larger than bitpos, we would have a negative bit
5282 offset and bitpos to make the lower bound non-negative in that case. */
5283 if (maybe_gt (bitoffset, *bitpos))
5285 poly_int64 adjust_bits = upper_bound (bitoffset, *bitpos) - *bitpos;
5288 *bitpos += adjust_bits;
5296 *bitstart = *bitpos - bitoffset;
5417 poly_int64 bitsize, bitpos;
5425 tem = get_inner_reference (to, &bitsize, &bitpos, &offset, &mode1,
5428 /* Make sure bitpos is not negative, it can wreak havoc later. */
5429 if (maybe_lt (bitpos, 0))
5432 offset = size_int (bits_to_bytes_round_down (bitpos));
5433 bitpos = num_trailing_bits (bitpos);
5438 get_bit_range (&bitregion_start, &bitregion_end, to, &bitpos, &offset);
5440 However, if we do not have a DECL_BIT_FIELD_TYPE but BITPOS or
5445 && multiple_p (bitpos, BITS_PER_UNIT))
5447 bitregion_start = bitpos;
5448 bitregion_end = bitpos + bitsize - 1;
5491 byte offset in BITPOS, adding the byte offset before the
5509 && maybe_ne (bitpos, 0)
5511 && multiple_p (bitpos, BITS_PER_UNIT, &bytepos)
5512 && multiple_p (bitpos, bitsize)
5518 if (known_ge (bitregion_end, poly_uint64 (bitpos)))
5519 bitregion_end -= bitpos;
5520 bitpos = 0;
5533 && known_ge (bitpos, GET_MODE_PRECISION (GET_MODE (to_rtx))))
5546 && known_eq (bitpos, 0)
5551 && (known_eq (bitpos, 0)
5552 || known_eq (bitpos, inner_bitsize)))
5553 result = store_expr (from, XEXP (to_rtx, maybe_ne (bitpos, 0)),
5555 else if (known_le (bitpos + bitsize, inner_bitsize))
5556 result = store_field (XEXP (to_rtx, 0), bitsize, bitpos,
5560 else if (known_ge (bitpos, inner_bitsize))
5562 bitpos - inner_bitsize,
5566 else if (known_eq (bitpos, 0) && known_eq (bitsize, mode_bitsize))
5625 result = store_field (temp, bitsize, bitpos,
5643 result = store_field (temp, bitsize, bitpos, bitregion_start,
5655 set_mem_attributes_minus_bitpos (to_rtx, to, 0, bitpos);
5660 gcc_checking_assert (known_ge (bitpos, 0));
5661 if (optimize_bitfield_assignment_op (bitsize, bitpos,
5674 && known_eq (bitpos, 0)
5683 result = store_field (to_rtx1, bitsize, bitpos,
5692 result = store_field (to_rtx, bitsize, bitpos,
6661 TARGET, BITSIZE, BITPOS, MODE, EXP are as for store_field.
6672 store_constructor_field (rtx target, poly_uint64 bitsize, poly_int64 bitpos,
6684 && multiple_p (bitpos, BITS_PER_UNIT, &bytepos)
6687 /* If we have a nonzero bitpos for a register target, then we just
6690 && (known_eq (bitpos, 0) || MEM_P (target)))
6696 && !multiple_p (bitpos, GET_MODE_ALIGNMENT (target_mode)))
6713 store_field (target, bitsize, bitpos, bitregion_start, bitregion_end, mode,
6813 HOST_WIDE_INT bitpos = 0;
6838 bitpos = int_bit_position (field);
6852 && bitpos % BITS_PER_WORD == 0
6856 && bitpos + BITS_PER_WORD <= exp_size * BITS_PER_UNIT)
6890 store_constructor_field (to_rtx, bitsize, bitpos,
7001 HOST_WIDE_INT bitpos;
7037 bitpos = lo * tree_to_shwi (TYPE_SIZE (elttype));
7049 (target, bitsize, bitpos, 0, bitregion_end,
7143 bitpos = ((tree_to_shwi (index) - minelt)
7146 bitpos = (i * tree_to_uhwi (TYPE_SIZE (elttype)));
7155 store_constructor_field (target, bitsize, bitpos, 0,
7176 HOST_WIDE_INT bitpos;
7329 bitpos = eltpos * elt_size;
7330 store_constructor_field (target, bitsize, bitpos, 0,
7349 BITSIZE bits, starting BITPOS bits from the start of TARGET.
7352 BITREGION_START is bitpos of the first bitfield in this region.
7353 BITREGION_END is the bitpos of the ending bitfield in this region.
7369 store_field (rtx target, poly_int64 bitsize, poly_int64 bitpos,
7389 gcc_assert (known_eq (bitpos, 0));
7408 || !multiple_p (bitpos, GET_MODE_ALIGNMENT (mode)))
7410 || !multiple_p (bitpos, BITS_PER_UNIT)))
7436 || !multiple_p (bitpos, BITS_PER_UNIT)
7543 and BITPOS must be aligned on a byte boundary. If so, we simply do
7549 && multiple_p (bitpos, BITS_PER_UNIT)
7553 poly_int64 bytepos = exact_div (bitpos, BITS_PER_UNIT);
7574 gcc_checking_assert (known_ge (bitpos, 0));
7575 store_bit_field (target, bitsize, bitpos,
7585 exact_div (bitpos, BITS_PER_UNIT));
7809 /* Avoid returning a negative bitpos as this may wreak havoc later. */
8366 poly_int64 bitsize, bitpos;
8414 bitpos = 0;
8423 bitpos = GET_MODE_BITSIZE (SCALAR_TYPE_MODE (TREE_TYPE (exp)));
8477 inner = get_inner_reference (exp, &bitsize, &bitpos, &offset, &mode1,
8485 subtarget = offset || maybe_ne (bitpos, 0) ? NULL_RTX : target;
8520 subtarget = maybe_ne (bitpos, 0) ? NULL_RTX : target;
8526 if (maybe_ne (bitpos, 0))
8530 poly_int64 bytepos = exact_div (bitpos, BITS_PER_UNIT);
10298 unsigned bitpos = tree_to_uhwi (treeop2);
10308 store_bit_field (dst, bitsize, bitpos, 0, 0,
11114 poly_int64 bitsize, bitpos, bytepos;
11118 = get_inner_reference (exp, &bitsize, &bitpos, &offset, &mode1,
11158 /* Make sure bitpos is not negative, it can wreak havoc later. */
11159 if (maybe_lt (bitpos, 0))
11162 offset = size_int (bits_to_bytes_round_down (bitpos));
11163 bitpos = num_trailing_bits (bitpos);
11177 || maybe_gt (bitpos + bitsize,
11183 if (known_eq (bitpos, 0)
11215 if (known_eq (bitpos, 0)
11223 else if (known_eq (bitpos,
11227 && maybe_ne (bitpos, 0)
11231 bitpos = 0;
11283 && maybe_ne (bitpos, 0)
11285 && multiple_p (bitpos, BITS_PER_UNIT, &bytepos)
11286 && multiple_p (bitpos, bitsize)
11291 bitpos = 0;
11301 && known_eq (bitpos, 0)
11349 || !multiple_p (bitpos, GET_MODE_ALIGNMENT (mode1))
11351 || !multiple_p (bitpos, GET_MODE_ALIGNMENT (mode)))
11358 || !multiple_p (bitpos, BITS_PER_UNIT)))
11373 && multiple_p (bitpos, BITS_PER_UNIT)))
11386 /* In this case, BITPOS must start at a byte boundary and
11391 bytepos = exact_div (bitpos, BITS_PER_UNIT);
11423 gcc_checking_assert (known_ge (bitpos, 0));
11424 op0 = extract_bit_field (op0, bitsize, bitpos, unsignedp,
11473 bytepos = bits_to_bytes_round_down (bitpos);
11576 poly_int64 bitsize, bitpos, bytepos;
11580 = get_inner_reference (treeop0, &bitsize, &bitpos, &offset, &mode1,
11585 && multiple_p (bitpos, BITS_PER_UNIT, &bytepos)
Indexes created Sat Apr 25 00:22:52 UTC 2026