config/s390/s390.c

1211    value except for the literal pool base label.  */
1213 s390_label_align (rtx_insn *label)
1215   rtx_insn *prev_insn = prev_active_insn (label);
2816   /* GOT offset is not OK, the GOT can be large.  */
2897   HOST_WIDE_INT offset = 0;
2963 	  offset = INTVAL (disp);
2970 	  offset = INTVAL (XEXP (XEXP (disp, 0), 1));
3035 	if (!DISP_IN_RANGE (offset))
3053       /* Accept pool label offsets.  */
3066 	     relative offset to the _GLOBAL_OFFSET_TABLE_ label which
3073 	  if (offset)
3075 	      /* If we have an offset, make sure it does not
3080 	      if (offset >= GET_MODE_SIZE (get_pool_mode (sym)))
3083 	      orig_disp = plus_constant (Pmode, orig_disp, offset);
3107    components, and return the base register in BASE and the offset in
3115 					HOST_WIDE_INT *offset)
3137   if (offset)
3140 	*offset = 0;
3142 	*offset = INTVAL (off);
3144 	/* The offset will anyway be cut down to 12 bits so take just
3146 	*offset = CONST_WIDE_INT_ELT (off, 0);
4501       HOST_WIDE_INT offset;
4507 	  && s390_loadrelative_operand_p (x, &symref, &offset)
4510 	  && (offset & 1) == 1)
4876       compute the address as an offset from the GOT, whose base is in
4944 	      /* If the offset is even, we can just use LARL.  This
5002 	  /* Assume GOT offset is a valid displacement operand (< 4k
5019 	  /* If the GOT offset might be >= 4k, we determine the position
5119    The returned offset is written to RESULT_REG and an USE rtx is
5213 	    /* Assume GOT offset < 4k.  This is handled the same way
5228 	    /* If the GOT offset might be >= 4k, we determine the position
5897 s390_emit_ccraw_jump (HOST_WIDE_INT mask, enum rtx_code comparison, rtx label)
5907 			       gen_rtx_LABEL_REF (VOIDmode, label), pc_rtx);
6033   rtx offset = gen_reg_rtx (Pmode);
6066   /* Calculate `offset' so that src + offset points to the last byte
6073   /* offset = 0xf - temp */
6074   emit_move_insn (offset, GEN_INT (15));
6075   force_expand_binop (Pmode, sub_optab, offset, temp, offset,
6078   /* Store `offset' bytes in the dstination string.  The quick check
6079      has loaded at least `offset' bytes into vsrc.  */
6081   emit_insn (gen_vstlv16qi (vsrc, gen_lowpart (SImode, offset), dst));
6084   force_expand_binop (Pmode, add_optab, offset, const1_rtx, offset,
6099 			       gen_rtx_PLUS (Pmode, src_addr_reg, offset)));
6108 			       gen_rtx_PLUS (Pmode, dst_addr_reg, offset)),
6110   /* offset += 16 */
6111   force_expand_binop (Pmode, add_optab, offset, GEN_INT (16),
6112 		      offset,  1, OPTAB_DIRECT);
6119   /* We are done.  Add the offset of the zero character to the dst_addr
6125   force_expand_binop (Pmode, add_optab, dst_addr_reg, offset, dst_addr_reg,
6929   rtx shift;	  /* Bit offset with regard to lsb.  */
6971       /* As we already have some offset, evaluate the remaining distance.  */
7434       HOST_WIDE_INT offset = 0;
7442 	  offset = INTVAL (XEXP (y, 1));
7449 	return plus_constant (Pmode, XVECEXP (y, 0, 0), offset);
7497    OP is an address (register + offset) which is not used to address data;
7503   HOST_WIDE_INT offset;
7506   /* Extract base register and offset.  */
7507   if (!s390_decompose_addrstyle_without_index (op, &base, &offset))
7519   fprintf (file, HOST_WIDE_INT_PRINT_DEC, offset & ((1 << 12) - 1));
7546    function label to *HW_BEFORE and *HW_AFTER.  Both pointers must not be NULL.
7651       /* Add a trampoline code area before the function label and initialize it
7655 		   "\t# pre-label NOPs for hotpatch (%d halfwords)\n",
7660       /* Note:  The function label must be aligned so that (a) the bytes of the
7663 	 stored directly before the label without crossing a cacheline
7667 	 if there are NOPs before the function label, the alignment is placed
7704 		 "\t# post-label NOPs for hotpatch (%d halfwords)\n",
8509 replace_constant_pool_ref_1 (rtx *x, rtx ref, rtx offset)
8520       *x = gen_rtx_PLUS (Pmode, XVECEXP (*x, 0, 1), offset);
8530       rtx addr = gen_rtx_PLUS (Pmode, XVECEXP (XEXP (*x, 0), 0, 1), offset);
8540 	  replace_constant_pool_ref_1 (&XEXP (*x, i), ref, offset);
8545 	    replace_constant_pool_ref_1 (&XVECEXP (*x, i, j), ref, offset);
8556 replace_constant_pool_ref (rtx_insn *insn, rtx ref, rtx offset)
8560   replace_constant_pool_ref_1 (&PATTERN (insn), ref, offset);
8586   rtx_code_label *label;
8599   rtx_code_label *label;
8617   pool->label = gen_label_rtx ();
8703       c->label = gen_label_rtx ();
8710 /* Return an rtx that represents the offset of X from the start of
8716   rtx label;
8718   label = gen_rtx_LABEL_REF (GET_MODE (x), pool->label);
8719   x = gen_rtx_UNSPEC (GET_MODE (x), gen_rtvec (2, x, label),
8746   return s390_pool_offset (pool, gen_rtx_LABEL_REF (Pmode, c->label));
8769 	     - The execute target label is wrapped into an
8793   return s390_pool_offset (pool, gen_rtx_LABEL_REF (Pmode, c->label));
8823    execute insns that carry a unique label.  */
8828   rtx label = s390_execute_label (insn);
8829   return label && label != const0_rtx;
8833    do not emit the pool base label.  */
8850   /* Emit pool base label.  */
8853       insn = emit_label_after (pool->label, insn);
8870 	insn = emit_label_after (c->label, insn);
8887       insn = emit_label_after (c->label, insn);
9032   set = gen_main_base_64 (base_reg, pool->label);
9144 	 Don't do that, however, if it is the label before
9162 	      rtx label = XEXP (XVECEXP (vec_pat, diff_p, i), 0);
9164 	      if (s390_find_pool (pool_list, label)
9166 		bitmap_set_bit (far_labels, CODE_LABEL_NUMBER (label));
9180 	      rtx label = JUMP_LABEL (insn);
9181 	      if (label && !ANY_RETURN_P (label))
9183 		  if (s390_find_pool (pool_list, label)
9185 		    bitmap_set_bit (far_labels, CODE_LABEL_NUMBER (label));
9196 					 curr_pool->label);
9201   /* Insert base register reload insns at every far label.  */
9211 					       pool->label);
9331   int offset;
9346     offset = -2 * UNITS_PER_LONG;
9348     offset = RETURN_REGNUM * UNITS_PER_LONG;
9350   addr = plus_constant (Pmode, frame, offset);
10474 /* Return offset between register FROM and TO initially after prolog.  */
10479   HOST_WIDE_INT offset;
10488       offset = (get_frame_size()
10495       offset = cfun_frame_layout.frame_size + STACK_POINTER_OFFSET;
10517       offset = (cfun_frame_layout.frame_size + cfun_frame_layout.gprs_offset +
10523       offset = 0;
10530   return offset;
10533 /* Emit insn to save fpr REGNUM at offset OFFSET relative
10537 save_fpr (rtx base, int offset, int regnum)
10540   addr = gen_rtx_MEM (DFmode, plus_constant (Pmode, base, offset));
10550 /* Emit insn to restore fpr REGNUM from offset OFFSET relative
10554 restore_fpr (rtx base, int offset, int regnum)
10557   addr = gen_rtx_MEM (DFmode, plus_constant (Pmode, base, offset));
10564    the register save area located at offset OFFSET
10568 save_gprs (rtx base, int offset, int first, int last)
10573   addr = plus_constant (Pmode, base, offset);
10641 			    offset + (start - first) * UNITS_PER_LONG);
10679    the register save area located at offset OFFSET
10683 restore_gprs (rtx base, int offset, int first, int last)
10687   addr = plus_constant (Pmode, base, offset);
10885 s390_prologue_plus_offset (rtx target, rtx reg, rtx offset, bool frame_related_p)
10888   rtx orig_offset = offset;
10892   gcc_assert (CONST_INT_P (offset));
10894   if (offset == const0_rtx)                               /* lr/lgr */
10898   else if (DISP_IN_RANGE (INTVAL (offset)))               /* la */
10901 						   offset));
10905       if (!satisfies_constraint_K (offset)                /* ahi/aghi */
10907 	      || (!satisfies_constraint_Op (offset)       /* alfi/algfi */
10908 		  && !satisfies_constraint_On (offset)))) /* slfi/slgfi */
10909 	offset = force_const_mem (Pmode, offset);
10917       insn = emit_insn (gen_add2_insn (target, offset));
10919       if (!CONST_INT_P (offset))
10958    if necessary.  LAST_PROBE_OFFSET contains the offset of the closest
10980 	  rtx offset = GEN_INT (probe_interval - UNITS_PER_LONG);
10996 						       offset));
11016 						   offset));
11065   int offset;
11086      we know *sp (offset 0) was written.  */
11121   offset = cfun_frame_layout.f0_offset;
11128 	  save_fpr (stack_pointer_rtx, offset, i);
11129 	  if (offset < last_probe_offset)
11130 	    last_probe_offset = offset;
11131 	  offset += 8;
11134 	offset += 8;
11138   offset = cfun_frame_layout.f4_offset;
11143 	  insn = save_fpr (stack_pointer_rtx, offset, i);
11144 	  if (offset < last_probe_offset)
11145 	    last_probe_offset = offset;
11146 	  offset += 8;
11154 	offset += 8;
11161       offset = (cfun_frame_layout.f8_offset
11164       for (i = FPR15_REGNUM; i >= FPR8_REGNUM && offset >= 0; i--)
11167 	    insn = save_fpr (stack_pointer_rtx, offset, i);
11168 	    if (offset < last_probe_offset)
11169 	      last_probe_offset = offset;
11172 	    offset -= 8;
11174       if (offset >= cfun_frame_layout.f8_offset)
11327       offset = 0;
11335 				      + offset);
11337 	    insn = save_fpr (temp_reg, offset, i);
11338 	    offset += 8;
11389   int area_bottom, area_top, offset = 0;
11428       offset = cfun_frame_layout.frame_size;
11435       offset = area_bottom < 0 ? -area_bottom : 0;
11436       frame_off = GEN_INT (cfun_frame_layout.frame_size - offset);
11472 			       offset + next_offset, i);
11491 			   offset + next_offset, i);
11520 				    offset + cfun_frame_layout.gprs_offset
11559 				offset + cfun_frame_layout.gprs_offset
11575 			   offset + cfun_frame_layout.gprs_offset
11632    - offset between parm block and __morestack return label  */
12441        holds the offset of the first anonymous stack argument
12930 /* Output assembler code to FILE to increment profiler label # LABELNO
12938   char label[128];
12939   ASM_GENERATE_INTERNAL_LABEL (label, "LP", labelno);
12949   op[3] = gen_rtx_SYMBOL_REF (Pmode, label);
13055    stored at VCALL_OFFSET in the vtable whose address is located at offset 0
13352       char label[32];
13354       ASM_GENERATE_INTERNAL_LABEL (label,
13357       ASM_OUTPUT_LABEL (asm_out_file, label);
13400    either be an address register or a label pointing to the location
13408       char label[32];
13410       ASM_GENERATE_INTERNAL_LABEL (label,
13413       ASM_OUTPUT_LABEL (asm_out_file, label);
13757       rtx set, base, offset;
13818 	  offset = const0_rtx;
13819 	  base = eliminate_constant_term (XEXP (SET_DEST (set), 0), &offset);
13820 	  off = INTVAL (offset);
13856 	  offset = const0_rtx;
13857 	  base = eliminate_constant_term (XEXP (SET_DEST (set), 0), &offset);
13858 	  off = INTVAL (offset);
13876 	  offset = const0_rtx;
13877 	  base = eliminate_constant_term (XEXP (SET_SRC (set), 0), &offset);
13878 	  off = INTVAL (offset);
13927 	  offset = const0_rtx;
13928 	  base = eliminate_constant_term (XEXP (SET_SRC (set), 0), &offset);
13929 	  off = INTVAL (offset);
14366       rtx label;
14369       label = s390_execute_label (insn);
14370       if (!label)
14373       gcc_assert (label != const0_rtx);
14375       target = emit_label (XEXP (label, 0));
14382 	     pointing at the jump table label.  Only this makes it