config/nios2/nios2.c

482 save_reg (int regno, unsigned offset)
485   rtx addr = plus_constant (Pmode, stack_pointer_rtx, offset, false);
491 restore_reg (int regno, unsigned offset)
494   rtx addr = plus_constant (Pmode, stack_pointer_rtx, offset, false);
504 base_reg_adjustment_p (rtx set, rtx *base_reg, rtx *offset)
514       *offset = XEXP (SET_SRC (set), 1);
525   rtx base_reg, offset, elt, pat = PATTERN (insn);
532       if (base_reg_adjustment_p (elt, &base_reg, &offset))
647   int sp_offset;      /* offset from base_reg to final stack value.  */
648   int save_regs_base; /* offset from base_reg to register save area.  */
997       unsigned offset = cfun->machine->save_reg_size - 4;
1005 	  offset += cfun->machine->save_regs_offset;
1007 	  if (!SMALL_INT (offset))
1009 	      emit_move_insn (scratch, gen_int_mode (offset, Pmode));
1012 	      offset = 0;
1015       if (offset)
1016 	base = plus_constant (Pmode, base, offset);
1113   int offset;
1117   /* Set OFFSET to the offset from the stack pointer.  */
1123       offset = cfun->machine->args_size + cfun->machine->var_size;
1127       offset = cfun->machine->total_size;
1128       offset -= crtl->args.pretend_args_size;
1135     /* If we are asked for the frame pointer offset, then adjust OFFSET
1136        by the offset from the frame pointer to the stack pointer.  */
1138     offset -= (cfun->machine->save_regs_offset
1141   return offset;
1672       /* FIXME: TLS GOT offset relocations will eventually also get this
1710 /* Generate GOT pointer based address with large offset.  */
1712 nios2_large_got_address (rtx offset, rtx tmp)
1716   emit_move_insn (tmp, offset);
1724   rtx offset = nios2_unspec_offset (loc, unspec);
1728     return force_reg (Pmode, nios2_large_got_address (offset, NULL_RTX));
1730   return gen_rtx_PLUS (Pmode, pic_offset_table_rtx, offset);
1811    ??? The __divsi3_table label should ideally be moved out
2052   rtx base, offset;
2060       split_const (x, &base, &offset);
2065 		&& SMALL_INT (INTVAL (offset)));
2084   rtx base, offset;
2085   split_const (x, &base, &offset);
2123    the IO forms of these instructions we must restrict the offset to fit
2127 nios2_valid_addr_offset_p (rtx offset)
2129   return (CONST_INT_P (offset)
2132 	      ? SMALL_INT12 (INTVAL (offset))
2133 	      : SMALL_INT (INTVAL (offset))));
2139 nios2_valid_addr_expr_p (rtx base, rtx offset, bool strict_p)
2145 	  && (offset == NULL_RTX
2146 	      || nios2_valid_addr_offset_p (offset)
2148 		  && nios2_symbolic_constant_p (offset))
2149 	      || nios2_unspec_reloc_p (offset)));
2233    - We should discourage splitting (symbol + offset) into hi/lo pairs
2234      to allow CSE'ing the symbol when it's used with more than one offset,
2478 	 fits within the 64K range of the GP offset.  */
2560       rtx offset = nios2_unspec_offset (sym, UNSPEC_PIC_GOTOFF_SYM);
2562       return nios2_large_got_address (offset, tmp);
2593   rtx base, offset;
2594   split_const (addr, &base, &offset);
2616   if (offset != const0_rtx)
2620 			   (CONST_INT_P (offset)
2621 			    ? (SMALL_INT (INTVAL (offset))
2622 			       ? offset : force_reg (Pmode, offset))
2623 			    : offset));
2686       rtx unspec, offset;
2687       split_const (op1, &unspec, &offset);
2690 	  && offset != const0_rtx)
2695 	    = plus_constant (Pmode, XVECEXP (unspec, 0, 0), INTVAL (offset));
2758 	/* Handled directly by movsi_internal as gp + offset
2759 	   or r0 + offset.  */
2763 	   representing a 32-bit offset.  We split the former
3127 /* Return the name string for a supported unspec reloc offset.  */
4538    base register + constant offset.  Return false if something
4541 split_mem_address (rtx addr, rtx *base_reg, rtx *offset)
4546       *offset = const0_rtx;
4552       *offset = XEXP (addr, 1);
4778 	HOST_WIDE_INT offset, rem = 0;
4805 	offset = INTVAL (rhs2);
4808 	    rem = offset & 3;
4809 	    offset >>= 2;
4812 		&& rem == 0 && (offset & ~0x1f) == 0)
4817 	    rem = offset & 1;
4818 	    offset >>= 1;
4822 		&& rem == 0 && (offset & ~0xf) == 0);
4831 	  HOST_WIDE_INT offset, rem = 0;
4848 	  offset = INTVAL (rhs2);
4851 	      rem = offset & 3;
4852 	      offset >>= 2;
4855 		  && rem == 0 && (offset & ~0x1f) == 0)
4859 		       && rem == 0 && (offset & ~0x3f) == 0)
4864 	      rem = offset & 1;
4865 	      offset >>= 1;
4872 		  && (offset & ~0x3f) == 0)
4878 		  && rem == 0 && (offset & ~0xf) == 0);
4941   rtx base_reg, offset;
4945       || !base_reg_adjustment_p (XVECEXP (op, 0, 1), &base_reg, &offset)
4947       || !CONST_INT_P (offset)
4948       || (INTVAL (offset) & 3) != 0)
4975   if (last_offset < 0 || last_offset + 4 != INTVAL (offset))
5012   rtx base_reg, offset;
5015   bool wb_p = base_reg_adjustment_p (first_elt, &base_reg, &offset);
5033       /* If no writeback to determine direction, use offset of first MEM.  */
5035 	inc_p = INTVAL (offset) > 0;
5066 gen_ldst (bool load_p, int regno, rtx base_mem, int offset)
5069   rtx mem = adjust_address_nv (base_mem, SImode, offset);
5079    OFFSET_INC_P: Same as REG_INC_P, but for the memory offset order.
5103 	int offset = (offset_inc_p ? 4 : -4) * n++;
5104 	RTVEC_ELT (p, i++) = gen_ldst (load_p, regno, base_mem, offset);
5110       rtx reg, offset;
5111       if (!split_mem_address (XEXP (base_mem, 0), &reg, &offset))
5124   int offset;	/* Offset from base register.  */
5125   rtx reg;	/* Register to store at this offset.  */
5141     return op1->offset - op2->offset;
5145    BASEREG and offset OFFSET meets the constraints for a 2-byte CDX ldw.n,
5148 can_use_cdx_ldstw (int regno, int basereg, int offset)
5151       && (offset & 0x3) == 0 && offset >= 0 && offset < 0x40)
5154 	   && offset >= 0 && offset < 0x80 && (offset & 0x3) == 0)
5193       rtx base, offset;
5209       if (!split_mem_address (XEXP (mem, 0), &base, &offset))
5212       o = INTVAL (offset);
5222       sort[i].offset = o;
5232   /* Sort the array by increasing mem offset order, then check that
5238   baseoffset = sort[0].offset;
5248       if (sort[m].offset != lastoffset
5293     if (can_use_cdx_ldstw (REGNO (sort[i].reg), basereg, sort[i].offset))
5305       if (!can_use_cdx_ldstw (REGNO (sort[i].reg), basereg, sort[i].offset)
5307 				sort[i].offset - baseoffset))
5327 	  int offset = sort[i].offset;
5331 	    offset -= baseoffset;
5332 	  mem = gen_rtx_MEM (SImode, plus_constant (Pmode, base_reg, offset));
5349 	  int offset = sort[i].offset - baseoffset;
5350 	  mem = gen_rtx_MEM (SImode, plus_constant (Pmode, scratch, offset));
5397 	    rtx label = JUMP_LABEL (insn);
5403 	    if (label && LABEL_P (label) && get_attr_length (insn) > 4)
5405 		int index = CODE_LABEL_NUMBER (label) - min_labelno;
5418 nios2_label_align (rtx label)
5420   int n = CODE_LABEL_NUMBER (label);