92    in the entire compilation a unique label number.  */
362 	  && (!p->offset_known_p || known_eq (p->offset, q->offset))
401   h.add_poly_hwi (p->offset);
414   return (p->decl == q->decl && known_eq (p->offset, q->offset));
421 get_reg_attrs (tree decl, poly_int64 offset)
426   if (decl == 0 && known_eq (offset, 0))
430   attrs.offset = offset;
907 		 const_rtx reg, poly_uint64 offset)
918   if (!multiple_p (offset, osize))
921   /* The subreg offset cannot be outside the inner object.  */
922   if (maybe_ge (offset, isize))
965   /* Paradoxical subregs must have offset zero.  */
967     return known_eq (offset, 0U);
969   /* This is a normal subreg.  Verify that the offset is representable.  */
983       return subreg_offset_representable_p (regno, imode, offset, omode);
997      register.  If BYTES_BIG_ENDIAN, the lowpart is at the highest offset,
998      otherwise it is at the lowest offset.
1000      Given that we've already checked the mode and offset alignment,
1010       if (!can_div_trunc_p (offset, block_size, &start_reg, &offset_within_reg)
1020 gen_rtx_SUBREG (machine_mode mode, rtx reg, poly_uint64 offset)
1022   gcc_assert (validate_subreg (mode, GET_MODE (reg), reg, offset));
1023   return gen_rtx_raw_SUBREG (mode, reg, offset);
1120    paradoxical lowpart, in which case the offset will be negative
1133 /* Return the offset of (subreg:OUTER_MODE (mem:INNER_MODE X) OFFSET)
1139 		      poly_uint64 offset)
1143       gcc_assert (known_eq (offset, 0U));
1146   return offset;
1149 /* As above, but return the offset that existing subreg X would have
1254 update_reg_offset (rtx new_rtx, rtx reg, poly_int64 offset)
1257 				       REG_OFFSET (reg) + offset);
1265 		    poly_int64 offset)
1269   update_reg_offset (new_rtx, reg, offset);
1277 gen_reg_rtx_offset (rtx reg, machine_mode mode, int offset)
1281   update_reg_offset (new_rtx, reg, offset);
1301   poly_int64 offset;
1330   offset = byte_lowpart_offset (GET_MODE (reg), GET_MODE (x));
1335 					 MEM_OFFSET (x) + offset);
1342 	update_reg_offset (reg, x, offset);
1495 /* Return 1 + the largest label number used so far in the current function.  */
1503 /* Return first label number used in this function (if any were used).  */
1511 /* If the rtx for label was created during the expansion of a nested
1512    function, then first_label_num won't include this label number.
1524    Ensure that label_num is greater than the label num of X, to avoid
1744 operand_subword (rtx op, poly_uint64 offset, int validate_address,
1759       && maybe_gt ((offset + 1) * UNITS_PER_WORD, GET_MODE_SIZE (mode)))
1765       rtx new_rtx = adjust_address_nv (op, word_mode, offset * UNITS_PER_WORD);
1782   return simplify_gen_subreg (word_mode, op, mode, (offset * UNITS_PER_WORD));
1793 operand_subword_force (rtx op, poly_uint64 offset, machine_mode mode)
1795   rtx result = operand_subword (op, offset, 1, mode);
1810   result = operand_subword (op, offset, 1, mode);
1819     offset (0),
1854   poly_uint64 offset;
1876   offset = MEM_OFFSET (mem);
1902 	  offset += suboffset;
1903 	  offset += tree_to_uhwi (bit_offset) / BITS_PER_UNIT;
1927   if (!known_misalignment (offset, align / BITS_PER_UNIT, &misalign))
1935    there is an offset outstanding on T that will be applied later.  */
1977       attrs.offset = refattrs->offset;
2071 	  attrs.offset = 0;
2087 	  attrs.offset = 0;
2101 	  attrs.offset = 0;
2144      bit position offset.  Similarly, increase the size of the accessed
2145      object to contain the negative offset.  */
2150       attrs.offset -= bytepos;
2208 /* Set the offset of MEM to OFFSET.  */
2211 set_mem_offset (rtx mem, poly_int64 offset)
2215   attrs.offset = offset;
2219 /* Clear the offset of MEM.  */
2334    to MODE and its address offset by OFFSET bytes.  If VALIDATE is
2346 adjust_address_1 (rtx memref, machine_mode mode, poly_int64 offset,
2371       && known_eq (offset, 0)
2379      This may happen even if offset is nonzero -- consider
2383   /* Convert a possibly large offset to a signed value within the
2386   offset = trunc_int_for_mode (offset, address_mode);
2390       /* If MEMREF is a LO_SUM and the offset is within the alignment of the
2394 	  && known_in_range_p (offset,
2399 					      XEXP (addr, 1), offset));
2401       /* If MEMREF is a ZERO_EXTEND from pointer_mode and the offset is valid
2407 	       && known_eq (trunc_int_for_mode (offset, pointer_mode), offset))
2410 						   XEXP (addr, 0), offset));
2413 	addr = plus_constant (address_mode, addr, offset);
2420   if (new_rtx == memref && maybe_ne (offset, 0))
2434       attrs.offset += offset;
2437       if (adjust_object && maybe_lt (attrs.offset, 0))
2447   if (maybe_ne (offset, 0))
2449       max_align = known_alignment (offset) * BITS_PER_UNIT;
2456       if (adjust_object && maybe_gt (offset + size, attrs.size))
2467       attrs.size -= offset;
2479    MEMREF offset by OFFSET bytes.  If VALIDATE is
2484 			     poly_int64 offset, int validate)
2487   return adjust_address_1 (memref, mode, offset, validate, 0, 0, 0);
2495 offset_address (rtx memref, rtx offset, unsigned HOST_WIDE_INT pow2)
2503   new_rtx = simplify_gen_binary (PLUS, address_mode, addr, offset);
2518       new_rtx = simplify_gen_binary (PLUS, address_mode, addr, offset);
2528   /* Update the alignment to reflect the offset.  Reset the offset, which
2564    MODE and offset by OFFSET.  This would be used by targets that e.g.
2569 widen_memory_access (rtx memref, machine_mode mode, poly_int64 offset)
2571   rtx new_rtx = adjust_address_1 (memref, mode, offset, 1, 1, 0, 0);
2580   /* If we don't know what offset we were at within the expression, then
2590 	  tree offset = component_ref_field_offset (attrs.expr);
2602 	      && known_ge (attrs.offset, 0))
2606 	  if (!poly_int_tree_p (offset, &suboffset))
2613 	  attrs.offset += suboffset;
2614 	  attrs.offset += (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field))
2623 	       && known_ge (attrs.offset, 0))
2694 	(mem:MODE (plus (reg sfp) (const_int offset)))
2695      with perhaps the plus missing for offset = 0.  */
2698   strip_offset (addr, &attrs.offset);
2705 /* Return a newly created CODE_LABEL rtx with a unique label number.  */
3795 /* Increment the label uses for all labels present in rtx.  */
3982      usage count so we don't delete the label.  */
4621 /* Emit the label LABEL before the insn BEFORE.  */
4624 emit_label_before (rtx_code_label *label, rtx_insn *before)
4626   gcc_checking_assert (INSN_UID (label) == 0);
4627   INSN_UID (label) = cur_insn_uid++;
4628   add_insn_before (label, before, NULL);
4629   return label;
4769 /* Emit the label LABEL after the insn AFTER.  */
4772 emit_label_after (rtx_insn *label, rtx_insn *after)
4774   gcc_checking_assert (INSN_UID (label) == 0);
4775   INSN_UID (label) = cur_insn_uid++;
4776   add_insn_after (label, after, NULL);
4777   return label;
5252 /* Add the label LABEL to the end of the doubly-linked list.  */
5257   rtx_code_label *label = as_a <rtx_code_label *> (uncast_label);
5259   gcc_checking_assert (INSN_UID (label) == 0);
5260   INSN_UID (label) = cur_insn_uid++;
5261   add_insn (label);
5262   return label;
5482    If X is a label, it is simply added into the insn chain.  */

Indexes created Sun Aug 25 13:10:05 MDT 2024