OSDN Git Service

72a7685f5b4d031e981f23f7749d7b0ef1df1caf
[pf3gnuchains/gcc-fork.git] / gcc / config / s390 / s390.c
1 /* Subroutines used for code generation on IBM S/390 and zSeries
2    Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
3    2007, 2008, 2009, 2010 Free Software Foundation, Inc.
4    Contributed by Hartmut Penner (hpenner@de.ibm.com) and
5                   Ulrich Weigand (uweigand@de.ibm.com) and
6                   Andreas Krebbel (Andreas.Krebbel@de.ibm.com).
7
8 This file is part of GCC.
9
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
13 version.
14
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
18 for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3.  If not see
22 <http://www.gnu.org/licenses/>.  */
23
24 #include "config.h"
25 #include "system.h"
26 #include "coretypes.h"
27 #include "tm.h"
28 #include "rtl.h"
29 #include "tree.h"
30 #include "tm_p.h"
31 #include "regs.h"
32 #include "hard-reg-set.h"
33 #include "insn-config.h"
34 #include "conditions.h"
35 #include "output.h"
36 #include "insn-attr.h"
37 #include "flags.h"
38 #include "except.h"
39 #include "function.h"
40 #include "recog.h"
41 #include "expr.h"
42 #include "reload.h"
43 #include "toplev.h"
44 #include "basic-block.h"
45 #include "integrate.h"
46 #include "ggc.h"
47 #include "target.h"
48 #include "target-def.h"
49 #include "debug.h"
50 #include "langhooks.h"
51 #include "optabs.h"
52 #include "gimple.h"
53 #include "df.h"
54 #include "params.h"
55 #include "cfgloop.h"
56
57
58 /* Define the specific costs for a given cpu.  */
59
60 struct processor_costs
61 {
62   /* multiplication */
63   const int m;        /* cost of an M instruction.  */
64   const int mghi;     /* cost of an MGHI instruction.  */
65   const int mh;       /* cost of an MH instruction.  */
66   const int mhi;      /* cost of an MHI instruction.  */
67   const int ml;       /* cost of an ML instruction.  */
68   const int mr;       /* cost of an MR instruction.  */
69   const int ms;       /* cost of an MS instruction.  */
70   const int msg;      /* cost of an MSG instruction.  */
71   const int msgf;     /* cost of an MSGF instruction.  */
72   const int msgfr;    /* cost of an MSGFR instruction.  */
73   const int msgr;     /* cost of an MSGR instruction.  */
74   const int msr;      /* cost of an MSR instruction.  */
75   const int mult_df;  /* cost of multiplication in DFmode.  */
76   const int mxbr;
77   /* square root */
78   const int sqxbr;    /* cost of square root in TFmode.  */
79   const int sqdbr;    /* cost of square root in DFmode.  */
80   const int sqebr;    /* cost of square root in SFmode.  */
81   /* multiply and add */
82   const int madbr;    /* cost of multiply and add in DFmode.  */
83   const int maebr;    /* cost of multiply and add in SFmode.  */
84   /* division */
85   const int dxbr;
86   const int ddbr;
87   const int debr;
88   const int dlgr;
89   const int dlr;
90   const int dr;
91   const int dsgfr;
92   const int dsgr;
93 };
94
95 const struct processor_costs *s390_cost;
96
97 static const
98 struct processor_costs z900_cost =
99 {
100   COSTS_N_INSNS (5),     /* M     */
101   COSTS_N_INSNS (10),    /* MGHI  */
102   COSTS_N_INSNS (5),     /* MH    */
103   COSTS_N_INSNS (4),     /* MHI   */
104   COSTS_N_INSNS (5),     /* ML    */
105   COSTS_N_INSNS (5),     /* MR    */
106   COSTS_N_INSNS (4),     /* MS    */
107   COSTS_N_INSNS (15),    /* MSG   */
108   COSTS_N_INSNS (7),     /* MSGF  */
109   COSTS_N_INSNS (7),     /* MSGFR */
110   COSTS_N_INSNS (10),    /* MSGR  */
111   COSTS_N_INSNS (4),     /* MSR   */
112   COSTS_N_INSNS (7),     /* multiplication in DFmode */
113   COSTS_N_INSNS (13),    /* MXBR */
114   COSTS_N_INSNS (136),   /* SQXBR */
115   COSTS_N_INSNS (44),    /* SQDBR */
116   COSTS_N_INSNS (35),    /* SQEBR */
117   COSTS_N_INSNS (18),    /* MADBR */
118   COSTS_N_INSNS (13),    /* MAEBR */
119   COSTS_N_INSNS (134),   /* DXBR */
120   COSTS_N_INSNS (30),    /* DDBR */
121   COSTS_N_INSNS (27),    /* DEBR */
122   COSTS_N_INSNS (220),   /* DLGR */
123   COSTS_N_INSNS (34),    /* DLR */
124   COSTS_N_INSNS (34),    /* DR */
125   COSTS_N_INSNS (32),    /* DSGFR */
126   COSTS_N_INSNS (32),    /* DSGR */
127 };
128
129 static const
130 struct processor_costs z990_cost =
131 {
132   COSTS_N_INSNS (4),     /* M     */
133   COSTS_N_INSNS (2),     /* MGHI  */
134   COSTS_N_INSNS (2),     /* MH    */
135   COSTS_N_INSNS (2),     /* MHI   */
136   COSTS_N_INSNS (4),     /* ML    */
137   COSTS_N_INSNS (4),     /* MR    */
138   COSTS_N_INSNS (5),     /* MS    */
139   COSTS_N_INSNS (6),     /* MSG   */
140   COSTS_N_INSNS (4),     /* MSGF  */
141   COSTS_N_INSNS (4),     /* MSGFR */
142   COSTS_N_INSNS (4),     /* MSGR  */
143   COSTS_N_INSNS (4),     /* MSR   */
144   COSTS_N_INSNS (1),     /* multiplication in DFmode */
145   COSTS_N_INSNS (28),    /* MXBR */
146   COSTS_N_INSNS (130),   /* SQXBR */
147   COSTS_N_INSNS (66),    /* SQDBR */
148   COSTS_N_INSNS (38),    /* SQEBR */
149   COSTS_N_INSNS (1),     /* MADBR */
150   COSTS_N_INSNS (1),     /* MAEBR */
151   COSTS_N_INSNS (60),    /* DXBR */
152   COSTS_N_INSNS (40),    /* DDBR */
153   COSTS_N_INSNS (26),    /* DEBR */
154   COSTS_N_INSNS (176),   /* DLGR */
155   COSTS_N_INSNS (31),    /* DLR */
156   COSTS_N_INSNS (31),    /* DR */
157   COSTS_N_INSNS (31),    /* DSGFR */
158   COSTS_N_INSNS (31),    /* DSGR */
159 };
160
161 static const
162 struct processor_costs z9_109_cost =
163 {
164   COSTS_N_INSNS (4),     /* M     */
165   COSTS_N_INSNS (2),     /* MGHI  */
166   COSTS_N_INSNS (2),     /* MH    */
167   COSTS_N_INSNS (2),     /* MHI   */
168   COSTS_N_INSNS (4),     /* ML    */
169   COSTS_N_INSNS (4),     /* MR    */
170   COSTS_N_INSNS (5),     /* MS    */
171   COSTS_N_INSNS (6),     /* MSG   */
172   COSTS_N_INSNS (4),     /* MSGF  */
173   COSTS_N_INSNS (4),     /* MSGFR */
174   COSTS_N_INSNS (4),     /* MSGR  */
175   COSTS_N_INSNS (4),     /* MSR   */
176   COSTS_N_INSNS (1),     /* multiplication in DFmode */
177   COSTS_N_INSNS (28),    /* MXBR */
178   COSTS_N_INSNS (130),   /* SQXBR */
179   COSTS_N_INSNS (66),    /* SQDBR */
180   COSTS_N_INSNS (38),    /* SQEBR */
181   COSTS_N_INSNS (1),     /* MADBR */
182   COSTS_N_INSNS (1),     /* MAEBR */
183   COSTS_N_INSNS (60),    /* DXBR */
184   COSTS_N_INSNS (40),    /* DDBR */
185   COSTS_N_INSNS (26),    /* DEBR */
186   COSTS_N_INSNS (30),    /* DLGR */
187   COSTS_N_INSNS (23),    /* DLR */
188   COSTS_N_INSNS (23),    /* DR */
189   COSTS_N_INSNS (24),    /* DSGFR */
190   COSTS_N_INSNS (24),    /* DSGR */
191 };
192
193 static const
194 struct processor_costs z10_cost =
195 {
196   COSTS_N_INSNS (10),    /* M     */
197   COSTS_N_INSNS (10),    /* MGHI  */
198   COSTS_N_INSNS (10),    /* MH    */
199   COSTS_N_INSNS (10),    /* MHI   */
200   COSTS_N_INSNS (10),    /* ML    */
201   COSTS_N_INSNS (10),    /* MR    */
202   COSTS_N_INSNS (10),    /* MS    */
203   COSTS_N_INSNS (10),    /* MSG   */
204   COSTS_N_INSNS (10),    /* MSGF  */
205   COSTS_N_INSNS (10),    /* MSGFR */
206   COSTS_N_INSNS (10),    /* MSGR  */
207   COSTS_N_INSNS (10),    /* MSR   */
208   COSTS_N_INSNS (1) ,    /* multiplication in DFmode */
209   COSTS_N_INSNS (50),    /* MXBR */
210   COSTS_N_INSNS (120),   /* SQXBR */
211   COSTS_N_INSNS (52),    /* SQDBR */
212   COSTS_N_INSNS (38),    /* SQEBR */
213   COSTS_N_INSNS (1),     /* MADBR */
214   COSTS_N_INSNS (1),     /* MAEBR */
215   COSTS_N_INSNS (111),   /* DXBR */
216   COSTS_N_INSNS (39),    /* DDBR */
217   COSTS_N_INSNS (32),    /* DEBR */
218   COSTS_N_INSNS (160),   /* DLGR */
219   COSTS_N_INSNS (71),    /* DLR */
220   COSTS_N_INSNS (71),    /* DR */
221   COSTS_N_INSNS (71),    /* DSGFR */
222   COSTS_N_INSNS (71),    /* DSGR */
223 };
224
225 extern int reload_completed;
226
227 /* Kept up to date using the SCHED_VARIABLE_ISSUE hook.  */
228 static rtx last_scheduled_insn;
229
230 /* Structure used to hold the components of a S/390 memory
231    address.  A legitimate address on S/390 is of the general
232    form
233           base + index + displacement
234    where any of the components is optional.
235
236    base and index are registers of the class ADDR_REGS,
237    displacement is an unsigned 12-bit immediate constant.  */
238
239 struct s390_address
240 {
241   rtx base;
242   rtx indx;
243   rtx disp;
244   bool pointer;
245   bool literal_pool;
246 };
247
248 /* Which cpu are we tuning for.  */
249 enum processor_type s390_tune = PROCESSOR_max;
250 int s390_tune_flags;
251 /* Which instruction set architecture to use.  */
252 enum processor_type s390_arch;
253 int s390_arch_flags;
254
255 HOST_WIDE_INT s390_warn_framesize = 0;
256 HOST_WIDE_INT s390_stack_size = 0;
257 HOST_WIDE_INT s390_stack_guard = 0;
258
259 /* The following structure is embedded in the machine
260    specific part of struct function.  */
261
262 struct GTY (()) s390_frame_layout
263 {
264   /* Offset within stack frame.  */
265   HOST_WIDE_INT gprs_offset;
266   HOST_WIDE_INT f0_offset;
267   HOST_WIDE_INT f4_offset;
268   HOST_WIDE_INT f8_offset;
269   HOST_WIDE_INT backchain_offset;
270
271   /* Number of first and last gpr where slots in the register
272      save area are reserved for.  */
273   int first_save_gpr_slot;
274   int last_save_gpr_slot;
275
276   /* Number of first and last gpr to be saved, restored.  */
277   int first_save_gpr;
278   int first_restore_gpr;
279   int last_save_gpr;
280   int last_restore_gpr;
281
282   /* Bits standing for floating point registers. Set, if the
283      respective register has to be saved. Starting with reg 16 (f0)
284      at the rightmost bit.
285      Bit 15 -  8  7  6  5  4  3  2  1  0
286      fpr 15 -  8  7  5  3  1  6  4  2  0
287      reg 31 - 24 23 22 21 20 19 18 17 16  */
288   unsigned int fpr_bitmap;
289
290   /* Number of floating point registers f8-f15 which must be saved.  */
291   int high_fprs;
292
293   /* Set if return address needs to be saved.
294      This flag is set by s390_return_addr_rtx if it could not use
295      the initial value of r14 and therefore depends on r14 saved
296      to the stack.  */
297   bool save_return_addr_p;
298
299   /* Size of stack frame.  */
300   HOST_WIDE_INT frame_size;
301 };
302
303 /* Define the structure for the machine field in struct function.  */
304
305 struct GTY(()) machine_function
306 {
307   struct s390_frame_layout frame_layout;
308
309   /* Literal pool base register.  */
310   rtx base_reg;
311
312   /* True if we may need to perform branch splitting.  */
313   bool split_branches_pending_p;
314
315   /* Some local-dynamic TLS symbol name.  */
316   const char *some_ld_name;
317
318   bool has_landing_pad_p;
319 };
320
321 /* Few accessor macros for struct cfun->machine->s390_frame_layout.  */
322
323 #define cfun_frame_layout (cfun->machine->frame_layout)
324 #define cfun_save_high_fprs_p (!!cfun_frame_layout.high_fprs)
325 #define cfun_gprs_save_area_size ((cfun_frame_layout.last_save_gpr_slot -           \
326   cfun_frame_layout.first_save_gpr_slot + 1) * UNITS_PER_LONG)
327 #define cfun_set_fpr_bit(BITNUM) (cfun->machine->frame_layout.fpr_bitmap |=    \
328   (1 << (BITNUM)))
329 #define cfun_fpr_bit_p(BITNUM) (!!(cfun->machine->frame_layout.fpr_bitmap &    \
330   (1 << (BITNUM))))
331
332 /* Number of GPRs and FPRs used for argument passing.  */
333 #define GP_ARG_NUM_REG 5
334 #define FP_ARG_NUM_REG (TARGET_64BIT? 4 : 2)
335
336 /* A couple of shortcuts.  */
337 #define CONST_OK_FOR_J(x) \
338         CONST_OK_FOR_CONSTRAINT_P((x), 'J', "J")
339 #define CONST_OK_FOR_K(x) \
340         CONST_OK_FOR_CONSTRAINT_P((x), 'K', "K")
341 #define CONST_OK_FOR_Os(x) \
342         CONST_OK_FOR_CONSTRAINT_P((x), 'O', "Os")
343 #define CONST_OK_FOR_Op(x) \
344         CONST_OK_FOR_CONSTRAINT_P((x), 'O', "Op")
345 #define CONST_OK_FOR_On(x) \
346         CONST_OK_FOR_CONSTRAINT_P((x), 'O', "On")
347
348 #define REGNO_PAIR_OK(REGNO, MODE)                               \
349   (HARD_REGNO_NREGS ((REGNO), (MODE)) == 1 || !((REGNO) & 1))
350
351 /* That's the read ahead of the dynamic branch prediction unit in
352    bytes on a z10 CPU.  */
353 #define Z10_PREDICT_DISTANCE 384
354
355 static enum machine_mode
356 s390_libgcc_cmp_return_mode (void)
357 {
358   return TARGET_64BIT ? DImode : SImode;
359 }
360
361 static enum machine_mode
362 s390_libgcc_shift_count_mode (void)
363 {
364   return TARGET_64BIT ? DImode : SImode;
365 }
366
367 static enum machine_mode
368 s390_unwind_word_mode (void)
369 {
370   return TARGET_64BIT ? DImode : SImode;
371 }
372
373 /* Return true if the back end supports mode MODE.  */
374 static bool
375 s390_scalar_mode_supported_p (enum machine_mode mode)
376 {
377   /* In contrast to the default implementation reject TImode constants on 31bit
378      TARGET_ZARCH for ABI compliance.  */
379   if (!TARGET_64BIT && TARGET_ZARCH && mode == TImode)
380     return false;
381
382   if (DECIMAL_FLOAT_MODE_P (mode))
383     return default_decimal_float_supported_p ();
384
385   return default_scalar_mode_supported_p (mode);
386 }
387
388 /* Set the has_landing_pad_p flag in struct machine_function to VALUE.  */
389
390 void
391 s390_set_has_landing_pad_p (bool value)
392 {
393   cfun->machine->has_landing_pad_p = value;
394 }
395
396 /* If two condition code modes are compatible, return a condition code
397    mode which is compatible with both.  Otherwise, return
398    VOIDmode.  */
399
400 static enum machine_mode
401 s390_cc_modes_compatible (enum machine_mode m1, enum machine_mode m2)
402 {
403   if (m1 == m2)
404     return m1;
405
406   switch (m1)
407     {
408     case CCZmode:
409       if (m2 == CCUmode || m2 == CCTmode || m2 == CCZ1mode
410           || m2 == CCSmode || m2 == CCSRmode || m2 == CCURmode)
411         return m2;
412       return VOIDmode;
413
414     case CCSmode:
415     case CCUmode:
416     case CCTmode:
417     case CCSRmode:
418     case CCURmode:
419     case CCZ1mode:
420       if (m2 == CCZmode)
421         return m1;
422
423       return VOIDmode;
424
425     default:
426       return VOIDmode;
427     }
428   return VOIDmode;
429 }
430
431 /* Return true if SET either doesn't set the CC register, or else
432    the source and destination have matching CC modes and that
433    CC mode is at least as constrained as REQ_MODE.  */
434
435 static bool
436 s390_match_ccmode_set (rtx set, enum machine_mode req_mode)
437 {
438   enum machine_mode set_mode;
439
440   gcc_assert (GET_CODE (set) == SET);
441
442   if (GET_CODE (SET_DEST (set)) != REG || !CC_REGNO_P (REGNO (SET_DEST (set))))
443     return 1;
444
445   set_mode = GET_MODE (SET_DEST (set));
446   switch (set_mode)
447     {
448     case CCSmode:
449     case CCSRmode:
450     case CCUmode:
451     case CCURmode:
452     case CCLmode:
453     case CCL1mode:
454     case CCL2mode:
455     case CCL3mode:
456     case CCT1mode:
457     case CCT2mode:
458     case CCT3mode:
459       if (req_mode != set_mode)
460         return 0;
461       break;
462
463     case CCZmode:
464       if (req_mode != CCSmode && req_mode != CCUmode && req_mode != CCTmode
465           && req_mode != CCSRmode && req_mode != CCURmode)
466         return 0;
467       break;
468
469     case CCAPmode:
470     case CCANmode:
471       if (req_mode != CCAmode)
472         return 0;
473       break;
474
475     default:
476       gcc_unreachable ();
477     }
478
479   return (GET_MODE (SET_SRC (set)) == set_mode);
480 }
481
482 /* Return true if every SET in INSN that sets the CC register
483    has source and destination with matching CC modes and that
484    CC mode is at least as constrained as REQ_MODE.
485    If REQ_MODE is VOIDmode, always return false.  */
486
487 bool
488 s390_match_ccmode (rtx insn, enum machine_mode req_mode)
489 {
490   int i;
491
492   /* s390_tm_ccmode returns VOIDmode to indicate failure.  */
493   if (req_mode == VOIDmode)
494     return false;
495
496   if (GET_CODE (PATTERN (insn)) == SET)
497     return s390_match_ccmode_set (PATTERN (insn), req_mode);
498
499   if (GET_CODE (PATTERN (insn)) == PARALLEL)
500       for (i = 0; i < XVECLEN (PATTERN (insn), 0); i++)
501         {
502           rtx set = XVECEXP (PATTERN (insn), 0, i);
503           if (GET_CODE (set) == SET)
504             if (!s390_match_ccmode_set (set, req_mode))
505               return false;
506         }
507
508   return true;
509 }
510
511 /* If a test-under-mask instruction can be used to implement
512    (compare (and ... OP1) OP2), return the CC mode required
513    to do that.  Otherwise, return VOIDmode.
514    MIXED is true if the instruction can distinguish between
515    CC1 and CC2 for mixed selected bits (TMxx), it is false
516    if the instruction cannot (TM).  */
517
518 enum machine_mode
519 s390_tm_ccmode (rtx op1, rtx op2, bool mixed)
520 {
521   int bit0, bit1;
522
523   /* ??? Fixme: should work on CONST_DOUBLE as well.  */
524   if (GET_CODE (op1) != CONST_INT || GET_CODE (op2) != CONST_INT)
525     return VOIDmode;
526
527   /* Selected bits all zero: CC0.
528      e.g.: int a; if ((a & (16 + 128)) == 0) */
529   if (INTVAL (op2) == 0)
530     return CCTmode;
531
532   /* Selected bits all one: CC3.
533      e.g.: int a; if ((a & (16 + 128)) == 16 + 128) */
534   if (INTVAL (op2) == INTVAL (op1))
535     return CCT3mode;
536
537   /* Exactly two bits selected, mixed zeroes and ones: CC1 or CC2. e.g.:
538      int a;
539      if ((a & (16 + 128)) == 16)         -> CCT1
540      if ((a & (16 + 128)) == 128)        -> CCT2  */
541   if (mixed)
542     {
543       bit1 = exact_log2 (INTVAL (op2));
544       bit0 = exact_log2 (INTVAL (op1) ^ INTVAL (op2));
545       if (bit0 != -1 && bit1 != -1)
546         return bit0 > bit1 ? CCT1mode : CCT2mode;
547     }
548
549   return VOIDmode;
550 }
551
552 /* Given a comparison code OP (EQ, NE, etc.) and the operands
553    OP0 and OP1 of a COMPARE, return the mode to be used for the
554    comparison.  */
555
556 enum machine_mode
557 s390_select_ccmode (enum rtx_code code, rtx op0, rtx op1)
558 {
559   switch (code)
560     {
561       case EQ:
562       case NE:
563         if ((GET_CODE (op0) == NEG || GET_CODE (op0) == ABS)
564             && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT)
565           return CCAPmode;
566         if (GET_CODE (op0) == PLUS && GET_CODE (XEXP (op0, 1)) == CONST_INT
567             && CONST_OK_FOR_K (INTVAL (XEXP (op0, 1))))
568           return CCAPmode;
569         if ((GET_CODE (op0) == PLUS || GET_CODE (op0) == MINUS
570              || GET_CODE (op1) == NEG)
571             && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT)
572           return CCLmode;
573
574         if (GET_CODE (op0) == AND)
575           {
576             /* Check whether we can potentially do it via TM.  */
577             enum machine_mode ccmode;
578             ccmode = s390_tm_ccmode (XEXP (op0, 1), op1, 1);
579             if (ccmode != VOIDmode)
580               {
581                 /* Relax CCTmode to CCZmode to allow fall-back to AND
582                    if that turns out to be beneficial.  */
583                 return ccmode == CCTmode ? CCZmode : ccmode;
584               }
585           }
586
587         if (register_operand (op0, HImode)
588             && GET_CODE (op1) == CONST_INT
589             && (INTVAL (op1) == -1 || INTVAL (op1) == 65535))
590           return CCT3mode;
591         if (register_operand (op0, QImode)
592             && GET_CODE (op1) == CONST_INT
593             && (INTVAL (op1) == -1 || INTVAL (op1) == 255))
594           return CCT3mode;
595
596         return CCZmode;
597
598       case LE:
599       case LT:
600       case GE:
601       case GT:
602         /* The only overflow condition of NEG and ABS happens when
603            -INT_MAX is used as parameter, which stays negative. So
604            we have an overflow from a positive value to a negative.
605            Using CCAP mode the resulting cc can be used for comparisons.  */
606         if ((GET_CODE (op0) == NEG || GET_CODE (op0) == ABS)
607             && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT)
608           return CCAPmode;
609
610         /* If constants are involved in an add instruction it is possible to use
611            the resulting cc for comparisons with zero. Knowing the sign of the
612            constant the overflow behavior gets predictable. e.g.:
613              int a, b; if ((b = a + c) > 0)
614            with c as a constant value: c < 0 -> CCAN and c >= 0 -> CCAP  */
615         if (GET_CODE (op0) == PLUS && GET_CODE (XEXP (op0, 1)) == CONST_INT
616             && CONST_OK_FOR_K (INTVAL (XEXP (op0, 1))))
617           {
618             if (INTVAL (XEXP((op0), 1)) < 0)
619               return CCANmode;
620             else
621               return CCAPmode;
622           }
623         /* Fall through.  */
624       case UNORDERED:
625       case ORDERED:
626       case UNEQ:
627       case UNLE:
628       case UNLT:
629       case UNGE:
630       case UNGT:
631       case LTGT:
632         if ((GET_CODE (op0) == SIGN_EXTEND || GET_CODE (op0) == ZERO_EXTEND)
633             && GET_CODE (op1) != CONST_INT)
634           return CCSRmode;
635         return CCSmode;
636
637       case LTU:
638       case GEU:
639         if (GET_CODE (op0) == PLUS
640             && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT)
641           return CCL1mode;
642
643         if ((GET_CODE (op0) == SIGN_EXTEND || GET_CODE (op0) == ZERO_EXTEND)
644             && GET_CODE (op1) != CONST_INT)
645           return CCURmode;
646         return CCUmode;
647
648       case LEU:
649       case GTU:
650         if (GET_CODE (op0) == MINUS
651             && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT)
652           return CCL2mode;
653
654         if ((GET_CODE (op0) == SIGN_EXTEND || GET_CODE (op0) == ZERO_EXTEND)
655             && GET_CODE (op1) != CONST_INT)
656           return CCURmode;
657         return CCUmode;
658
659       default:
660         gcc_unreachable ();
661     }
662 }
663
664 /* Replace the comparison OP0 CODE OP1 by a semantically equivalent one
665    that we can implement more efficiently.  */
666
667 void
668 s390_canonicalize_comparison (enum rtx_code *code, rtx *op0, rtx *op1)
669 {
670   /* Convert ZERO_EXTRACT back to AND to enable TM patterns.  */
671   if ((*code == EQ || *code == NE)
672       && *op1 == const0_rtx
673       && GET_CODE (*op0) == ZERO_EXTRACT
674       && GET_CODE (XEXP (*op0, 1)) == CONST_INT
675       && GET_CODE (XEXP (*op0, 2)) == CONST_INT
676       && SCALAR_INT_MODE_P (GET_MODE (XEXP (*op0, 0))))
677     {
678       rtx inner = XEXP (*op0, 0);
679       HOST_WIDE_INT modesize = GET_MODE_BITSIZE (GET_MODE (inner));
680       HOST_WIDE_INT len = INTVAL (XEXP (*op0, 1));
681       HOST_WIDE_INT pos = INTVAL (XEXP (*op0, 2));
682
683       if (len > 0 && len < modesize
684           && pos >= 0 && pos + len <= modesize
685           && modesize <= HOST_BITS_PER_WIDE_INT)
686         {
687           unsigned HOST_WIDE_INT block;
688           block = ((unsigned HOST_WIDE_INT) 1 << len) - 1;
689           block <<= modesize - pos - len;
690
691           *op0 = gen_rtx_AND (GET_MODE (inner), inner,
692                               gen_int_mode (block, GET_MODE (inner)));
693         }
694     }
695
696   /* Narrow AND of memory against immediate to enable TM.  */
697   if ((*code == EQ || *code == NE)
698       && *op1 == const0_rtx
699       && GET_CODE (*op0) == AND
700       && GET_CODE (XEXP (*op0, 1)) == CONST_INT
701       && SCALAR_INT_MODE_P (GET_MODE (XEXP (*op0, 0))))
702     {
703       rtx inner = XEXP (*op0, 0);
704       rtx mask = XEXP (*op0, 1);
705
706       /* Ignore paradoxical SUBREGs if all extra bits are masked out.  */
707       if (GET_CODE (inner) == SUBREG
708           && SCALAR_INT_MODE_P (GET_MODE (SUBREG_REG (inner)))
709           && (GET_MODE_SIZE (GET_MODE (inner))
710               >= GET_MODE_SIZE (GET_MODE (SUBREG_REG (inner))))
711           && ((INTVAL (mask)
712                & GET_MODE_MASK (GET_MODE (inner))
713                & ~GET_MODE_MASK (GET_MODE (SUBREG_REG (inner))))
714               == 0))
715         inner = SUBREG_REG (inner);
716
717       /* Do not change volatile MEMs.  */
718       if (MEM_P (inner) && !MEM_VOLATILE_P (inner))
719         {
720           int part = s390_single_part (XEXP (*op0, 1),
721                                        GET_MODE (inner), QImode, 0);
722           if (part >= 0)
723             {
724               mask = gen_int_mode (s390_extract_part (mask, QImode, 0), QImode);
725               inner = adjust_address_nv (inner, QImode, part);
726               *op0 = gen_rtx_AND (QImode, inner, mask);
727             }
728         }
729     }
730
731   /* Narrow comparisons against 0xffff to HImode if possible.  */
732   if ((*code == EQ || *code == NE)
733       && GET_CODE (*op1) == CONST_INT
734       && INTVAL (*op1) == 0xffff
735       && SCALAR_INT_MODE_P (GET_MODE (*op0))
736       && (nonzero_bits (*op0, GET_MODE (*op0))
737           & ~(unsigned HOST_WIDE_INT) 0xffff) == 0)
738     {
739       *op0 = gen_lowpart (HImode, *op0);
740       *op1 = constm1_rtx;
741     }
742
743   /* Remove redundant UNSPEC_CCU_TO_INT conversions if possible.  */
744   if (GET_CODE (*op0) == UNSPEC
745       && XINT (*op0, 1) == UNSPEC_CCU_TO_INT
746       && XVECLEN (*op0, 0) == 1
747       && GET_MODE (XVECEXP (*op0, 0, 0)) == CCUmode
748       && GET_CODE (XVECEXP (*op0, 0, 0)) == REG
749       && REGNO (XVECEXP (*op0, 0, 0)) == CC_REGNUM
750       && *op1 == const0_rtx)
751     {
752       enum rtx_code new_code = UNKNOWN;
753       switch (*code)
754         {
755           case EQ: new_code = EQ;  break;
756           case NE: new_code = NE;  break;
757           case LT: new_code = GTU; break;
758           case GT: new_code = LTU; break;
759           case LE: new_code = GEU; break;
760           case GE: new_code = LEU; break;
761           default: break;
762         }
763
764       if (new_code != UNKNOWN)
765         {
766           *op0 = XVECEXP (*op0, 0, 0);
767           *code = new_code;
768         }
769     }
770
771   /* Remove redundant UNSPEC_CCZ_TO_INT conversions if possible.  */
772   if (GET_CODE (*op0) == UNSPEC
773       && XINT (*op0, 1) == UNSPEC_CCZ_TO_INT
774       && XVECLEN (*op0, 0) == 1
775       && GET_MODE (XVECEXP (*op0, 0, 0)) == CCZmode
776       && GET_CODE (XVECEXP (*op0, 0, 0)) == REG
777       && REGNO (XVECEXP (*op0, 0, 0)) == CC_REGNUM
778       && *op1 == const0_rtx)
779     {
780       enum rtx_code new_code = UNKNOWN;
781       switch (*code)
782         {
783           case EQ: new_code = EQ;  break;
784           case NE: new_code = NE;  break;
785           default: break;
786         }
787
788       if (new_code != UNKNOWN)
789         {
790           *op0 = XVECEXP (*op0, 0, 0);
791           *code = new_code;
792         }
793     }
794
795   /* Simplify cascaded EQ, NE with const0_rtx.  */
796   if ((*code == NE || *code == EQ)
797       && (GET_CODE (*op0) == EQ || GET_CODE (*op0) == NE)
798       && GET_MODE (*op0) == SImode
799       && GET_MODE (XEXP (*op0, 0)) == CCZ1mode
800       && REG_P (XEXP (*op0, 0))
801       && XEXP (*op0, 1) == const0_rtx
802       && *op1 == const0_rtx)
803     {
804       if ((*code == EQ && GET_CODE (*op0) == NE)
805           || (*code == NE && GET_CODE (*op0) == EQ))
806         *code = EQ;
807       else
808         *code = NE;
809       *op0 = XEXP (*op0, 0);
810     }
811
812   /* Prefer register over memory as first operand.  */
813   if (MEM_P (*op0) && REG_P (*op1))
814     {
815       rtx tem = *op0; *op0 = *op1; *op1 = tem;
816       *code = swap_condition (*code);
817     }
818 }
819
820 /* Emit a compare instruction suitable to implement the comparison
821    OP0 CODE OP1.  Return the correct condition RTL to be placed in
822    the IF_THEN_ELSE of the conditional branch testing the result.  */
823
824 rtx
825 s390_emit_compare (enum rtx_code code, rtx op0, rtx op1)
826 {
827   enum machine_mode mode = s390_select_ccmode (code, op0, op1);
828   rtx cc;
829
830   /* Do not output a redundant compare instruction if a compare_and_swap
831      pattern already computed the result and the machine modes are compatible.  */
832   if (GET_MODE_CLASS (GET_MODE (op0)) == MODE_CC)
833     {
834       gcc_assert (s390_cc_modes_compatible (GET_MODE (op0), mode)
835                   == GET_MODE (op0));
836       cc = op0;
837     }
838   else
839     {
840       cc = gen_rtx_REG (mode, CC_REGNUM);
841       emit_insn (gen_rtx_SET (VOIDmode, cc, gen_rtx_COMPARE (mode, op0, op1)));
842     }
843
844   return gen_rtx_fmt_ee (code, VOIDmode, cc, const0_rtx);
845 }
846
847 /* Emit a SImode compare and swap instruction setting MEM to NEW_RTX if OLD
848    matches CMP.
849    Return the correct condition RTL to be placed in the IF_THEN_ELSE of the
850    conditional branch testing the result.  */
851
852 static rtx
853 s390_emit_compare_and_swap (enum rtx_code code, rtx old, rtx mem, rtx cmp, rtx new_rtx)
854 {
855   emit_insn (gen_sync_compare_and_swapsi (old, mem, cmp, new_rtx));
856   return s390_emit_compare (code, gen_rtx_REG (CCZ1mode, CC_REGNUM), const0_rtx);
857 }
858
859 /* Emit a jump instruction to TARGET.  If COND is NULL_RTX, emit an
860    unconditional jump, else a conditional jump under condition COND.  */
861
862 void
863 s390_emit_jump (rtx target, rtx cond)
864 {
865   rtx insn;
866
867   target = gen_rtx_LABEL_REF (VOIDmode, target);
868   if (cond)
869     target = gen_rtx_IF_THEN_ELSE (VOIDmode, cond, target, pc_rtx);
870
871   insn = gen_rtx_SET (VOIDmode, pc_rtx, target);
872   emit_jump_insn (insn);
873 }
874
875 /* Return branch condition mask to implement a branch
876    specified by CODE.  Return -1 for invalid comparisons.  */
877
878 int
879 s390_branch_condition_mask (rtx code)
880 {
881   const int CC0 = 1 << 3;
882   const int CC1 = 1 << 2;
883   const int CC2 = 1 << 1;
884   const int CC3 = 1 << 0;
885
886   gcc_assert (GET_CODE (XEXP (code, 0)) == REG);
887   gcc_assert (REGNO (XEXP (code, 0)) == CC_REGNUM);
888   gcc_assert (XEXP (code, 1) == const0_rtx);
889
890   switch (GET_MODE (XEXP (code, 0)))
891     {
892     case CCZmode:
893     case CCZ1mode:
894       switch (GET_CODE (code))
895         {
896         case EQ:        return CC0;
897         case NE:        return CC1 | CC2 | CC3;
898         default:        return -1;
899         }
900       break;
901
902     case CCT1mode:
903       switch (GET_CODE (code))
904         {
905         case EQ:        return CC1;
906         case NE:        return CC0 | CC2 | CC3;
907         default:        return -1;
908         }
909       break;
910
911     case CCT2mode:
912       switch (GET_CODE (code))
913         {
914         case EQ:        return CC2;
915         case NE:        return CC0 | CC1 | CC3;
916         default:        return -1;
917         }
918       break;
919
920     case CCT3mode:
921       switch (GET_CODE (code))
922         {
923         case EQ:        return CC3;
924         case NE:        return CC0 | CC1 | CC2;
925         default:        return -1;
926         }
927       break;
928
929     case CCLmode:
930       switch (GET_CODE (code))
931         {
932         case EQ:        return CC0 | CC2;
933         case NE:        return CC1 | CC3;
934         default:        return -1;
935         }
936       break;
937
938     case CCL1mode:
939       switch (GET_CODE (code))
940         {
941         case LTU:       return CC2 | CC3;  /* carry */
942         case GEU:       return CC0 | CC1;  /* no carry */
943         default:        return -1;
944         }
945       break;
946
947     case CCL2mode:
948       switch (GET_CODE (code))
949         {
950         case GTU:       return CC0 | CC1;  /* borrow */
951         case LEU:       return CC2 | CC3;  /* no borrow */
952         default:        return -1;
953         }
954       break;
955
956     case CCL3mode:
957       switch (GET_CODE (code))
958         {
959         case EQ:        return CC0 | CC2;
960         case NE:        return CC1 | CC3;
961         case LTU:       return CC1;
962         case GTU:       return CC3;
963         case LEU:       return CC1 | CC2;
964         case GEU:       return CC2 | CC3;
965         default:        return -1;
966         }
967
968     case CCUmode:
969       switch (GET_CODE (code))
970         {
971         case EQ:        return CC0;
972         case NE:        return CC1 | CC2 | CC3;
973         case LTU:       return CC1;
974         case GTU:       return CC2;
975         case LEU:       return CC0 | CC1;
976         case GEU:       return CC0 | CC2;
977         default:        return -1;
978         }
979       break;
980
981     case CCURmode:
982       switch (GET_CODE (code))
983         {
984         case EQ:        return CC0;
985         case NE:        return CC2 | CC1 | CC3;
986         case LTU:       return CC2;
987         case GTU:       return CC1;
988         case LEU:       return CC0 | CC2;
989         case GEU:       return CC0 | CC1;
990         default:        return -1;
991         }
992       break;
993
994     case CCAPmode:
995       switch (GET_CODE (code))
996         {
997         case EQ:        return CC0;
998         case NE:        return CC1 | CC2 | CC3;
999         case LT:        return CC1 | CC3;
1000         case GT:        return CC2;
1001         case LE:        return CC0 | CC1 | CC3;
1002         case GE:        return CC0 | CC2;
1003         default:        return -1;
1004         }
1005       break;
1006
1007     case CCANmode:
1008       switch (GET_CODE (code))
1009         {
1010         case EQ:        return CC0;
1011         case NE:        return CC1 | CC2 | CC3;
1012         case LT:        return CC1;
1013         case GT:        return CC2 | CC3;
1014         case LE:        return CC0 | CC1;
1015         case GE:        return CC0 | CC2 | CC3;
1016         default:        return -1;
1017         }
1018       break;
1019
1020     case CCSmode:
1021       switch (GET_CODE (code))
1022         {
1023         case EQ:        return CC0;
1024         case NE:        return CC1 | CC2 | CC3;
1025         case LT:        return CC1;
1026         case GT:        return CC2;
1027         case LE:        return CC0 | CC1;
1028         case GE:        return CC0 | CC2;
1029         case UNORDERED: return CC3;
1030         case ORDERED:   return CC0 | CC1 | CC2;
1031         case UNEQ:      return CC0 | CC3;
1032         case UNLT:      return CC1 | CC3;
1033         case UNGT:      return CC2 | CC3;
1034         case UNLE:      return CC0 | CC1 | CC3;
1035         case UNGE:      return CC0 | CC2 | CC3;
1036         case LTGT:      return CC1 | CC2;
1037         default:        return -1;
1038         }
1039       break;
1040
1041     case CCSRmode:
1042       switch (GET_CODE (code))
1043         {
1044         case EQ:        return CC0;
1045         case NE:        return CC2 | CC1 | CC3;
1046         case LT:        return CC2;
1047         case GT:        return CC1;
1048         case LE:        return CC0 | CC2;
1049         case GE:        return CC0 | CC1;
1050         case UNORDERED: return CC3;
1051         case ORDERED:   return CC0 | CC2 | CC1;
1052         case UNEQ:      return CC0 | CC3;
1053         case UNLT:      return CC2 | CC3;
1054         case UNGT:      return CC1 | CC3;
1055         case UNLE:      return CC0 | CC2 | CC3;
1056         case UNGE:      return CC0 | CC1 | CC3;
1057         case LTGT:      return CC2 | CC1;
1058         default:        return -1;
1059         }
1060       break;
1061
1062     default:
1063       return -1;
1064     }
1065 }
1066
1067
1068 /* Return branch condition mask to implement a compare and branch
1069    specified by CODE.  Return -1 for invalid comparisons.  */
1070
1071 int
1072 s390_compare_and_branch_condition_mask (rtx code)
1073 {
1074   const int CC0 = 1 << 3;
1075   const int CC1 = 1 << 2;
1076   const int CC2 = 1 << 1;
1077
1078   switch (GET_CODE (code))
1079     {
1080     case EQ:
1081       return CC0;
1082     case NE:
1083       return CC1 | CC2;
1084     case LT:
1085     case LTU:
1086       return CC1;
1087     case GT:
1088     case GTU:
1089       return CC2;
1090     case LE:
1091     case LEU:
1092       return CC0 | CC1;
1093     case GE:
1094     case GEU:
1095       return CC0 | CC2;
1096     default:
1097       gcc_unreachable ();
1098     }
1099   return -1;
1100 }
1101
1102 /* If INV is false, return assembler mnemonic string to implement
1103    a branch specified by CODE.  If INV is true, return mnemonic
1104    for the corresponding inverted branch.  */
1105
1106 static const char *
1107 s390_branch_condition_mnemonic (rtx code, int inv)
1108 {
1109   int mask;
1110
1111   static const char *const mnemonic[16] =
1112     {
1113       NULL, "o", "h", "nle",
1114       "l", "nhe", "lh", "ne",
1115       "e", "nlh", "he", "nl",
1116       "le", "nh", "no", NULL
1117     };
1118
1119   if (GET_CODE (XEXP (code, 0)) == REG
1120       && REGNO (XEXP (code, 0)) == CC_REGNUM
1121       && XEXP (code, 1) == const0_rtx)
1122     mask = s390_branch_condition_mask (code);
1123   else
1124     mask = s390_compare_and_branch_condition_mask (code);
1125
1126   gcc_assert (mask >= 0);
1127
1128   if (inv)
1129     mask ^= 15;
1130
1131   gcc_assert (mask >= 1 && mask <= 14);
1132
1133   return mnemonic[mask];
1134 }
1135
1136 /* Return the part of op which has a value different from def.
1137    The size of the part is determined by mode.
1138    Use this function only if you already know that op really
1139    contains such a part.  */
1140
1141 unsigned HOST_WIDE_INT
1142 s390_extract_part (rtx op, enum machine_mode mode, int def)
1143 {
1144   unsigned HOST_WIDE_INT value = 0;
1145   int max_parts = HOST_BITS_PER_WIDE_INT / GET_MODE_BITSIZE (mode);
1146   int part_bits = GET_MODE_BITSIZE (mode);
1147   unsigned HOST_WIDE_INT part_mask
1148     = ((unsigned HOST_WIDE_INT)1 << part_bits) - 1;
1149   int i;
1150
1151   for (i = 0; i < max_parts; i++)
1152     {
1153       if (i == 0)
1154         value = (unsigned HOST_WIDE_INT) INTVAL (op);
1155       else
1156         value >>= part_bits;
1157
1158       if ((value & part_mask) != (def & part_mask))
1159         return value & part_mask;
1160     }
1161
1162   gcc_unreachable ();
1163 }
1164
1165 /* If OP is an integer constant of mode MODE with exactly one
1166    part of mode PART_MODE unequal to DEF, return the number of that
1167    part. Otherwise, return -1.  */
1168
1169 int
1170 s390_single_part (rtx op,
1171                   enum machine_mode mode,
1172                   enum machine_mode part_mode,
1173                   int def)
1174 {
1175   unsigned HOST_WIDE_INT value = 0;
1176   int n_parts = GET_MODE_SIZE (mode) / GET_MODE_SIZE (part_mode);
1177   unsigned HOST_WIDE_INT part_mask
1178     = ((unsigned HOST_WIDE_INT)1 << GET_MODE_BITSIZE (part_mode)) - 1;
1179   int i, part = -1;
1180
1181   if (GET_CODE (op) != CONST_INT)
1182     return -1;
1183
1184   for (i = 0; i < n_parts; i++)
1185     {
1186       if (i == 0)
1187         value = (unsigned HOST_WIDE_INT) INTVAL (op);
1188       else
1189         value >>= GET_MODE_BITSIZE (part_mode);
1190
1191       if ((value & part_mask) != (def & part_mask))
1192         {
1193           if (part != -1)
1194             return -1;
1195           else
1196             part = i;
1197         }
1198     }
1199   return part == -1 ? -1 : n_parts - 1 - part;
1200 }
1201
1202 /* Return true if IN contains a contiguous bitfield in the lower SIZE
1203    bits and no other bits are set in IN.  POS and LENGTH can be used
1204    to obtain the start position and the length of the bitfield.
1205
1206    POS gives the position of the first bit of the bitfield counting
1207    from the lowest order bit starting with zero.  In order to use this
1208    value for S/390 instructions this has to be converted to "bits big
1209    endian" style.  */
1210
1211 bool
1212 s390_contiguous_bitmask_p (unsigned HOST_WIDE_INT in, int size,
1213                            int *pos, int *length)
1214 {
1215   int tmp_pos = 0;
1216   int tmp_length = 0;
1217   int i;
1218   unsigned HOST_WIDE_INT mask = 1ULL;
1219   bool contiguous = false;
1220
1221   for (i = 0; i < size; mask <<= 1, i++)
1222     {
1223       if (contiguous)
1224         {
1225           if (mask & in)
1226             tmp_length++;
1227           else
1228             break;
1229         }
1230       else
1231         {
1232           if (mask & in)
1233             {
1234               contiguous = true;
1235               tmp_length++;
1236             }
1237           else
1238             tmp_pos++;
1239         }
1240     }
1241
1242   if (!tmp_length)
1243     return false;
1244
1245   /* Calculate a mask for all bits beyond the contiguous bits.  */
1246   mask = (-1LL & ~(((1ULL << (tmp_length + tmp_pos - 1)) << 1) - 1));
1247
1248   if (mask & in)
1249     return false;
1250
1251   if (tmp_length + tmp_pos - 1 > size)
1252     return false;
1253
1254   if (length)
1255     *length = tmp_length;
1256
1257   if (pos)
1258     *pos = tmp_pos;
1259
1260   return true;
1261 }
1262
1263 /* Check whether we can (and want to) split a double-word
1264    move in mode MODE from SRC to DST into two single-word
1265    moves, moving the subword FIRST_SUBWORD first.  */
1266
1267 bool
1268 s390_split_ok_p (rtx dst, rtx src, enum machine_mode mode, int first_subword)
1269 {
1270   /* Floating point registers cannot be split.  */
1271   if (FP_REG_P (src) || FP_REG_P (dst))
1272     return false;
1273
1274   /* We don't need to split if operands are directly accessible.  */
1275   if (s_operand (src, mode) || s_operand (dst, mode))
1276     return false;
1277
1278   /* Non-offsettable memory references cannot be split.  */
1279   if ((GET_CODE (src) == MEM && !offsettable_memref_p (src))
1280       || (GET_CODE (dst) == MEM && !offsettable_memref_p (dst)))
1281     return false;
1282
1283   /* Moving the first subword must not clobber a register
1284      needed to move the second subword.  */
1285   if (register_operand (dst, mode))
1286     {
1287       rtx subreg = operand_subword (dst, first_subword, 0, mode);
1288       if (reg_overlap_mentioned_p (subreg, src))
1289         return false;
1290     }
1291
1292   return true;
1293 }
1294
1295 /* Return true if it can be proven that [MEM1, MEM1 + SIZE]
1296    and [MEM2, MEM2 + SIZE] do overlap and false
1297    otherwise.  */
1298
1299 bool
1300 s390_overlap_p (rtx mem1, rtx mem2, HOST_WIDE_INT size)
1301 {
1302   rtx addr1, addr2, addr_delta;
1303   HOST_WIDE_INT delta;
1304
1305   if (GET_CODE (mem1) != MEM || GET_CODE (mem2) != MEM)
1306     return true;
1307
1308   if (size == 0)
1309     return false;
1310
1311   addr1 = XEXP (mem1, 0);
1312   addr2 = XEXP (mem2, 0);
1313
1314   addr_delta = simplify_binary_operation (MINUS, Pmode, addr2, addr1);
1315
1316   /* This overlapping check is used by peepholes merging memory block operations.
1317      Overlapping operations would otherwise be recognized by the S/390 hardware
1318      and would fall back to a slower implementation. Allowing overlapping
1319      operations would lead to slow code but not to wrong code. Therefore we are
1320      somewhat optimistic if we cannot prove that the memory blocks are
1321      overlapping.
1322      That's why we return false here although this may accept operations on
1323      overlapping memory areas.  */
1324   if (!addr_delta || GET_CODE (addr_delta) != CONST_INT)
1325     return false;
1326
1327   delta = INTVAL (addr_delta);
1328
1329   if (delta == 0
1330       || (delta > 0 && delta < size)
1331       || (delta < 0 && -delta < size))
1332     return true;
1333
1334   return false;
1335 }
1336
1337 /* Check whether the address of memory reference MEM2 equals exactly
1338    the address of memory reference MEM1 plus DELTA.  Return true if
1339    we can prove this to be the case, false otherwise.  */
1340
1341 bool
1342 s390_offset_p (rtx mem1, rtx mem2, rtx delta)
1343 {
1344   rtx addr1, addr2, addr_delta;
1345
1346   if (GET_CODE (mem1) != MEM || GET_CODE (mem2) != MEM)
1347     return false;
1348
1349   addr1 = XEXP (mem1, 0);
1350   addr2 = XEXP (mem2, 0);
1351
1352   addr_delta = simplify_binary_operation (MINUS, Pmode, addr2, addr1);
1353   if (!addr_delta || !rtx_equal_p (addr_delta, delta))
1354     return false;
1355
1356   return true;
1357 }
1358
1359 /* Expand logical operator CODE in mode MODE with operands OPERANDS.  */
1360
1361 void
1362 s390_expand_logical_operator (enum rtx_code code, enum machine_mode mode,
1363                               rtx *operands)
1364 {
1365   enum machine_mode wmode = mode;
1366   rtx dst = operands[0];
1367   rtx src1 = operands[1];
1368   rtx src2 = operands[2];
1369   rtx op, clob, tem;
1370
1371   /* If we cannot handle the operation directly, use a temp register.  */
1372   if (!s390_logical_operator_ok_p (operands))
1373     dst = gen_reg_rtx (mode);
1374
1375   /* QImode and HImode patterns make sense only if we have a destination
1376      in memory.  Otherwise perform the operation in SImode.  */
1377   if ((mode == QImode || mode == HImode) && GET_CODE (dst) != MEM)
1378     wmode = SImode;
1379
1380   /* Widen operands if required.  */
1381   if (mode != wmode)
1382     {
1383       if (GET_CODE (dst) == SUBREG
1384           && (tem = simplify_subreg (wmode, dst, mode, 0)) != 0)
1385         dst = tem;
1386       else if (REG_P (dst))
1387         dst = gen_rtx_SUBREG (wmode, dst, 0);
1388       else
1389         dst = gen_reg_rtx (wmode);
1390
1391       if (GET_CODE (src1) == SUBREG
1392           && (tem = simplify_subreg (wmode, src1, mode, 0)) != 0)
1393         src1 = tem;
1394       else if (GET_MODE (src1) != VOIDmode)
1395         src1 = gen_rtx_SUBREG (wmode, force_reg (mode, src1), 0);
1396
1397       if (GET_CODE (src2) == SUBREG
1398           && (tem = simplify_subreg (wmode, src2, mode, 0)) != 0)
1399         src2 = tem;
1400       else if (GET_MODE (src2) != VOIDmode)
1401         src2 = gen_rtx_SUBREG (wmode, force_reg (mode, src2), 0);
1402     }
1403
1404   /* Emit the instruction.  */
1405   op = gen_rtx_SET (VOIDmode, dst, gen_rtx_fmt_ee (code, wmode, src1, src2));
1406   clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, CC_REGNUM));
1407   emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, op, clob)));
1408
1409   /* Fix up the destination if needed.  */
1410   if (dst != operands[0])
1411     emit_move_insn (operands[0], gen_lowpart (mode, dst));
1412 }
1413
1414 /* Check whether OPERANDS are OK for a logical operation (AND, IOR, XOR).  */
1415
1416 bool
1417 s390_logical_operator_ok_p (rtx *operands)
1418 {
1419   /* If the destination operand is in memory, it needs to coincide
1420      with one of the source operands.  After reload, it has to be
1421      the first source operand.  */
1422   if (GET_CODE (operands[0]) == MEM)
1423     return rtx_equal_p (operands[0], operands[1])
1424            || (!reload_completed && rtx_equal_p (operands[0], operands[2]));
1425
1426   return true;
1427 }
1428
1429 /* Narrow logical operation CODE of memory operand MEMOP with immediate
1430    operand IMMOP to switch from SS to SI type instructions.  */
1431
1432 void
1433 s390_narrow_logical_operator (enum rtx_code code, rtx *memop, rtx *immop)
1434 {
1435   int def = code == AND ? -1 : 0;
1436   HOST_WIDE_INT mask;
1437   int part;
1438
1439   gcc_assert (GET_CODE (*memop) == MEM);
1440   gcc_assert (!MEM_VOLATILE_P (*memop));
1441
1442   mask = s390_extract_part (*immop, QImode, def);
1443   part = s390_single_part (*immop, GET_MODE (*memop), QImode, def);
1444   gcc_assert (part >= 0);
1445
1446   *memop = adjust_address (*memop, QImode, part);
1447   *immop = gen_int_mode (mask, QImode);
1448 }
1449
1450
1451 /* How to allocate a 'struct machine_function'.  */
1452
1453 static struct machine_function *
1454 s390_init_machine_status (void)
1455 {
1456   return GGC_CNEW (struct machine_function);
1457 }
1458
1459 /* Change optimizations to be performed, depending on the
1460    optimization level.
1461
1462    LEVEL is the optimization level specified; 2 if `-O2' is
1463    specified, 1 if `-O' is specified, and 0 if neither is specified.
1464
1465    SIZE is nonzero if `-Os' is specified and zero otherwise.  */
1466
1467 void
1468 optimization_options (int level ATTRIBUTE_UNUSED, int size ATTRIBUTE_UNUSED)
1469 {
1470   /* ??? There are apparently still problems with -fcaller-saves.  */
1471   flag_caller_saves = 0;
1472
1473   /* By default, always emit DWARF-2 unwind info.  This allows debugging
1474      without maintaining a stack frame back-chain.  */
1475   flag_asynchronous_unwind_tables = 1;
1476
1477   if (HAVE_prefetch || optimize >= 3)
1478       flag_prefetch_loop_arrays = 1;
1479
1480   /* Use MVCLE instructions to decrease code size if requested.  */
1481   if (size != 0)
1482     target_flags |= MASK_MVCLE;
1483 }
1484
1485 /* Return true if ARG is the name of a processor.  Set *TYPE and *FLAGS
1486    to the associated processor_type and processor_flags if so.  */
1487
1488 static bool
1489 s390_handle_arch_option (const char *arg,
1490                          enum processor_type *type,
1491                          int *flags)
1492 {
1493   static struct pta
1494     {
1495       const char *const name;           /* processor name or nickname.  */
1496       const enum processor_type processor;
1497       const int flags;                  /* From enum processor_flags. */
1498     }
1499   const processor_alias_table[] =
1500     {
1501       {"g5", PROCESSOR_9672_G5, PF_IEEE_FLOAT},
1502       {"g6", PROCESSOR_9672_G6, PF_IEEE_FLOAT},
1503       {"z900", PROCESSOR_2064_Z900, PF_IEEE_FLOAT | PF_ZARCH},
1504       {"z990", PROCESSOR_2084_Z990, PF_IEEE_FLOAT | PF_ZARCH
1505                                     | PF_LONG_DISPLACEMENT},
1506       {"z9-109", PROCESSOR_2094_Z9_109, PF_IEEE_FLOAT | PF_ZARCH
1507                                        | PF_LONG_DISPLACEMENT | PF_EXTIMM},
1508       {"z9-ec", PROCESSOR_2094_Z9_109, PF_IEEE_FLOAT | PF_ZARCH
1509                              | PF_LONG_DISPLACEMENT | PF_EXTIMM | PF_DFP },
1510       {"z10", PROCESSOR_2097_Z10, PF_IEEE_FLOAT | PF_ZARCH
1511                              | PF_LONG_DISPLACEMENT | PF_EXTIMM | PF_DFP | PF_Z10},
1512     };
1513   size_t i;
1514
1515   for (i = 0; i < ARRAY_SIZE (processor_alias_table); i++)
1516     if (strcmp (arg, processor_alias_table[i].name) == 0)
1517       {
1518         *type = processor_alias_table[i].processor;
1519         *flags = processor_alias_table[i].flags;
1520         return true;
1521       }
1522   return false;
1523 }
1524
1525 /* Implement TARGET_HANDLE_OPTION.  */
1526
1527 static bool
1528 s390_handle_option (size_t code, const char *arg, int value ATTRIBUTE_UNUSED)
1529 {
1530   switch (code)
1531     {
1532     case OPT_march_:
1533       return s390_handle_arch_option (arg, &s390_arch, &s390_arch_flags);
1534
1535     case OPT_mstack_guard_:
1536       if (sscanf (arg, HOST_WIDE_INT_PRINT_DEC, &s390_stack_guard) != 1)
1537         return false;
1538       if (exact_log2 (s390_stack_guard) == -1)
1539         error ("stack guard value must be an exact power of 2");
1540       return true;
1541
1542     case OPT_mstack_size_:
1543       if (sscanf (arg, HOST_WIDE_INT_PRINT_DEC, &s390_stack_size) != 1)
1544         return false;
1545       if (exact_log2 (s390_stack_size) == -1)
1546         error ("stack size must be an exact power of 2");
1547       return true;
1548
1549     case OPT_mtune_:
1550       return s390_handle_arch_option (arg, &s390_tune, &s390_tune_flags);
1551
1552     case OPT_mwarn_framesize_:
1553       return sscanf (arg, HOST_WIDE_INT_PRINT_DEC, &s390_warn_framesize) == 1;
1554
1555     default:
1556       return true;
1557     }
1558 }
1559
1560 void
1561 override_options (void)
1562 {
1563   /* Set up function hooks.  */
1564   init_machine_status = s390_init_machine_status;
1565
1566   /* Architecture mode defaults according to ABI.  */
1567   if (!(target_flags_explicit & MASK_ZARCH))
1568     {
1569       if (TARGET_64BIT)
1570         target_flags |= MASK_ZARCH;
1571       else
1572         target_flags &= ~MASK_ZARCH;
1573     }
1574
1575   /* Determine processor architectural level.  */
1576   if (!s390_arch_string)
1577     {
1578       s390_arch_string = TARGET_ZARCH? "z900" : "g5";
1579       s390_handle_arch_option (s390_arch_string, &s390_arch, &s390_arch_flags);
1580     }
1581
1582   /* Determine processor to tune for.  */
1583   if (s390_tune == PROCESSOR_max)
1584     {
1585       s390_tune = s390_arch;
1586       s390_tune_flags = s390_arch_flags;
1587     }
1588
1589   /* Sanity checks.  */
1590   if (TARGET_ZARCH && !TARGET_CPU_ZARCH)
1591     error ("z/Architecture mode not supported on %s", s390_arch_string);
1592   if (TARGET_64BIT && !TARGET_ZARCH)
1593     error ("64-bit ABI not supported in ESA/390 mode");
1594
1595   if (TARGET_HARD_DFP && !TARGET_DFP)
1596     {
1597       if (target_flags_explicit & MASK_HARD_DFP)
1598         {
1599           if (!TARGET_CPU_DFP)
1600             error ("Hardware decimal floating point instructions"
1601                    " not available on %s", s390_arch_string);
1602           if (!TARGET_ZARCH)
1603             error ("Hardware decimal floating point instructions"
1604                    " not available in ESA/390 mode");
1605         }
1606       else
1607         target_flags &= ~MASK_HARD_DFP;
1608     }
1609
1610   if ((target_flags_explicit & MASK_SOFT_FLOAT) && TARGET_SOFT_FLOAT)
1611     {
1612       if ((target_flags_explicit & MASK_HARD_DFP) && TARGET_HARD_DFP)
1613         error ("-mhard-dfp can't be used in conjunction with -msoft-float");
1614
1615       target_flags &= ~MASK_HARD_DFP;
1616     }
1617
1618   /* Set processor cost function.  */
1619   switch (s390_tune)
1620     {
1621     case PROCESSOR_2084_Z990:
1622       s390_cost = &z990_cost;
1623       break;
1624     case PROCESSOR_2094_Z9_109:
1625       s390_cost = &z9_109_cost;
1626       break;
1627     case PROCESSOR_2097_Z10:
1628       s390_cost = &z10_cost;
1629       break;
1630     default:
1631       s390_cost = &z900_cost;
1632     }
1633
1634   if (TARGET_BACKCHAIN && TARGET_PACKED_STACK && TARGET_HARD_FLOAT)
1635     error ("-mbackchain -mpacked-stack -mhard-float are not supported "
1636            "in combination");
1637
1638   if (s390_stack_size)
1639     {
1640       if (s390_stack_guard >= s390_stack_size)
1641         error ("stack size must be greater than the stack guard value");
1642       else if (s390_stack_size > 1 << 16)
1643         error ("stack size must not be greater than 64k");
1644     }
1645   else if (s390_stack_guard)
1646     error ("-mstack-guard implies use of -mstack-size");
1647
1648 #ifdef TARGET_DEFAULT_LONG_DOUBLE_128
1649   if (!(target_flags_explicit & MASK_LONG_DOUBLE_128))
1650     target_flags |= MASK_LONG_DOUBLE_128;
1651 #endif
1652
1653   if (s390_tune == PROCESSOR_2097_Z10)
1654     {
1655       if (!PARAM_SET_P (PARAM_MAX_UNROLLED_INSNS))
1656         set_param_value ("max-unrolled-insns", 100);
1657       if (!PARAM_SET_P (PARAM_MAX_UNROLL_TIMES))
1658         set_param_value ("max-unroll-times", 32);
1659       if (!PARAM_SET_P (PARAM_MAX_COMPLETELY_PEELED_INSNS))
1660         set_param_value ("max-completely-peeled-insns", 2000);
1661       if (!PARAM_SET_P (PARAM_MAX_COMPLETELY_PEEL_TIMES))
1662         set_param_value ("max-completely-peel-times", 64);
1663     }
1664
1665   set_param_value ("max-pending-list-length", 256);
1666   /* values for loop prefetching */
1667   set_param_value ("l1-cache-line-size", 256);
1668   if (!PARAM_SET_P (PARAM_L1_CACHE_SIZE))
1669     set_param_value ("l1-cache-size", 128);
1670   /* s390 has more than 2 levels and the size is much larger.  Since
1671      we are always running virtualized assume that we only get a small
1672      part of the caches above l1.  */
1673   if (!PARAM_SET_P (PARAM_L2_CACHE_SIZE))
1674     set_param_value ("l2-cache-size", 1500);
1675   if (!PARAM_SET_P (PARAM_PREFETCH_MIN_INSN_TO_MEM_RATIO))
1676     set_param_value ("prefetch-min-insn-to-mem-ratio", 2);
1677   if (!PARAM_SET_P (PARAM_SIMULTANEOUS_PREFETCHES))
1678     set_param_value ("simultaneous-prefetches", 6);
1679 }
1680
1681 /* Map for smallest class containing reg regno.  */
1682
1683 const enum reg_class regclass_map[FIRST_PSEUDO_REGISTER] =
1684 { GENERAL_REGS, ADDR_REGS, ADDR_REGS, ADDR_REGS,
1685   ADDR_REGS,    ADDR_REGS, ADDR_REGS, ADDR_REGS,
1686   ADDR_REGS,    ADDR_REGS, ADDR_REGS, ADDR_REGS,
1687   ADDR_REGS,    ADDR_REGS, ADDR_REGS, ADDR_REGS,
1688   FP_REGS,      FP_REGS,   FP_REGS,   FP_REGS,
1689   FP_REGS,      FP_REGS,   FP_REGS,   FP_REGS,
1690   FP_REGS,      FP_REGS,   FP_REGS,   FP_REGS,
1691   FP_REGS,      FP_REGS,   FP_REGS,   FP_REGS,
1692   ADDR_REGS,    CC_REGS,   ADDR_REGS, ADDR_REGS,
1693   ACCESS_REGS,  ACCESS_REGS
1694 };
1695
1696 /* Return attribute type of insn.  */
1697
1698 static enum attr_type
1699 s390_safe_attr_type (rtx insn)
1700 {
1701   if (recog_memoized (insn) >= 0)
1702     return get_attr_type (insn);
1703   else
1704     return TYPE_NONE;
1705 }
1706
1707 /* Return true if DISP is a valid short displacement.  */
1708
1709 static bool
1710 s390_short_displacement (rtx disp)
1711 {
1712   /* No displacement is OK.  */
1713   if (!disp)
1714     return true;
1715
1716   /* Without the long displacement facility we don't need to
1717      distingiush between long and short displacement.  */
1718   if (!TARGET_LONG_DISPLACEMENT)
1719     return true;
1720
1721   /* Integer displacement in range.  */
1722   if (GET_CODE (disp) == CONST_INT)
1723     return INTVAL (disp) >= 0 && INTVAL (disp) < 4096;
1724
1725   /* GOT offset is not OK, the GOT can be large.  */
1726   if (GET_CODE (disp) == CONST
1727       && GET_CODE (XEXP (disp, 0)) == UNSPEC
1728       && (XINT (XEXP (disp, 0), 1) == UNSPEC_GOT
1729           || XINT (XEXP (disp, 0), 1) == UNSPEC_GOTNTPOFF))
1730     return false;
1731
1732   /* All other symbolic constants are literal pool references,
1733      which are OK as the literal pool must be small.  */
1734   if (GET_CODE (disp) == CONST)
1735     return true;
1736
1737   return false;
1738 }
1739
1740 /* Decompose a RTL expression ADDR for a memory address into
1741    its components, returned in OUT.
1742
1743    Returns false if ADDR is not a valid memory address, true
1744    otherwise.  If OUT is NULL, don't return the components,
1745    but check for validity only.
1746
1747    Note: Only addresses in canonical form are recognized.
1748    LEGITIMIZE_ADDRESS should convert non-canonical forms to the
1749    canonical form so that they will be recognized.  */
1750
1751 static int
1752 s390_decompose_address (rtx addr, struct s390_address *out)
1753 {
1754   HOST_WIDE_INT offset = 0;
1755   rtx base = NULL_RTX;
1756   rtx indx = NULL_RTX;
1757   rtx disp = NULL_RTX;
1758   rtx orig_disp;
1759   bool pointer = false;
1760   bool base_ptr = false;
1761   bool indx_ptr = false;
1762   bool literal_pool = false;
1763
1764   /* We may need to substitute the literal pool base register into the address
1765      below.  However, at this point we do not know which register is going to
1766      be used as base, so we substitute the arg pointer register.  This is going
1767      to be treated as holding a pointer below -- it shouldn't be used for any
1768      other purpose.  */
1769   rtx fake_pool_base = gen_rtx_REG (Pmode, ARG_POINTER_REGNUM);
1770
1771   /* Decompose address into base + index + displacement.  */
1772
1773   if (GET_CODE (addr) == REG || GET_CODE (addr) == UNSPEC)
1774     base = addr;
1775
1776   else if (GET_CODE (addr) == PLUS)
1777     {
1778       rtx op0 = XEXP (addr, 0);
1779       rtx op1 = XEXP (addr, 1);
1780       enum rtx_code code0 = GET_CODE (op0);
1781       enum rtx_code code1 = GET_CODE (op1);
1782
1783       if (code0 == REG || code0 == UNSPEC)
1784         {
1785           if (code1 == REG || code1 == UNSPEC)
1786             {
1787               indx = op0;       /* index + base */
1788               base = op1;
1789             }
1790
1791           else
1792             {
1793               base = op0;       /* base + displacement */
1794               disp = op1;
1795             }
1796         }
1797
1798       else if (code0 == PLUS)
1799         {
1800           indx = XEXP (op0, 0); /* index + base + disp */
1801           base = XEXP (op0, 1);
1802           disp = op1;
1803         }
1804
1805       else
1806         {
1807           return false;
1808         }
1809     }
1810
1811   else
1812     disp = addr;                /* displacement */
1813
1814   /* Extract integer part of displacement.  */
1815   orig_disp = disp;
1816   if (disp)
1817     {
1818       if (GET_CODE (disp) == CONST_INT)
1819         {
1820           offset = INTVAL (disp);
1821           disp = NULL_RTX;
1822         }
1823       else if (GET_CODE (disp) == CONST
1824                && GET_CODE (XEXP (disp, 0)) == PLUS
1825                && GET_CODE (XEXP (XEXP (disp, 0), 1)) == CONST_INT)
1826         {
1827           offset = INTVAL (XEXP (XEXP (disp, 0), 1));
1828           disp = XEXP (XEXP (disp, 0), 0);
1829         }
1830     }
1831
1832   /* Strip off CONST here to avoid special case tests later.  */
1833   if (disp && GET_CODE (disp) == CONST)
1834     disp = XEXP (disp, 0);
1835
1836   /* We can convert literal pool addresses to
1837      displacements by basing them off the base register.  */
1838   if (disp && GET_CODE (disp) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (disp))
1839     {
1840       /* Either base or index must be free to hold the base register.  */
1841       if (!base)
1842         base = fake_pool_base, literal_pool = true;
1843       else if (!indx)
1844         indx = fake_pool_base, literal_pool = true;
1845       else
1846         return false;
1847
1848       /* Mark up the displacement.  */
1849       disp = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, disp),
1850                              UNSPEC_LTREL_OFFSET);
1851     }
1852
1853   /* Validate base register.  */
1854   if (base)
1855     {
1856       if (GET_CODE (base) == UNSPEC)
1857         switch (XINT (base, 1))
1858           {
1859           case UNSPEC_LTREF:
1860             if (!disp)
1861               disp = gen_rtx_UNSPEC (Pmode,
1862                                      gen_rtvec (1, XVECEXP (base, 0, 0)),
1863                                      UNSPEC_LTREL_OFFSET);
1864             else
1865               return false;
1866
1867             base = XVECEXP (base, 0, 1);
1868             break;
1869
1870           case UNSPEC_LTREL_BASE:
1871             if (XVECLEN (base, 0) == 1)
1872               base = fake_pool_base, literal_pool = true;
1873             else
1874               base = XVECEXP (base, 0, 1);
1875             break;
1876
1877           default:
1878             return false;
1879           }
1880
1881       if (!REG_P (base)
1882           || (GET_MODE (base) != SImode
1883               && GET_MODE (base) != Pmode))
1884         return false;
1885
1886       if (REGNO (base) == STACK_POINTER_REGNUM
1887           || REGNO (base) == FRAME_POINTER_REGNUM
1888           || ((reload_completed || reload_in_progress)
1889               && frame_pointer_needed
1890               && REGNO (base) == HARD_FRAME_POINTER_REGNUM)
1891           || REGNO (base) == ARG_POINTER_REGNUM
1892           || (flag_pic
1893               && REGNO (base) == PIC_OFFSET_TABLE_REGNUM))
1894         pointer = base_ptr = true;
1895
1896       if ((reload_completed || reload_in_progress)
1897           && base == cfun->machine->base_reg)
1898         pointer = base_ptr = literal_pool = true;
1899     }
1900
1901   /* Validate index register.  */
1902   if (indx)
1903     {
1904       if (GET_CODE (indx) == UNSPEC)
1905         switch (XINT (indx, 1))
1906           {
1907           case UNSPEC_LTREF:
1908             if (!disp)
1909               disp = gen_rtx_UNSPEC (Pmode,
1910                                      gen_rtvec (1, XVECEXP (indx, 0, 0)),
1911                                      UNSPEC_LTREL_OFFSET);
1912             else
1913               return false;
1914
1915             indx = XVECEXP (indx, 0, 1);
1916             break;
1917
1918           case UNSPEC_LTREL_BASE:
1919             if (XVECLEN (indx, 0) == 1)
1920               indx = fake_pool_base, literal_pool = true;
1921             else
1922               indx = XVECEXP (indx, 0, 1);
1923             break;
1924
1925           default:
1926             return false;
1927           }
1928
1929       if (!REG_P (indx)
1930           || (GET_MODE (indx) != SImode
1931               && GET_MODE (indx) != Pmode))
1932         return false;
1933
1934       if (REGNO (indx) == STACK_POINTER_REGNUM
1935           || REGNO (indx) == FRAME_POINTER_REGNUM
1936           || ((reload_completed || reload_in_progress)
1937               && frame_pointer_needed
1938               && REGNO (indx) == HARD_FRAME_POINTER_REGNUM)
1939           || REGNO (indx) == ARG_POINTER_REGNUM
1940           || (flag_pic
1941               && REGNO (indx) == PIC_OFFSET_TABLE_REGNUM))
1942         pointer = indx_ptr = true;
1943
1944       if ((reload_completed || reload_in_progress)
1945           && indx == cfun->machine->base_reg)
1946         pointer = indx_ptr = literal_pool = true;
1947     }
1948
1949   /* Prefer to use pointer as base, not index.  */
1950   if (base && indx && !base_ptr
1951       && (indx_ptr || (!REG_POINTER (base) && REG_POINTER (indx))))
1952     {
1953       rtx tmp = base;
1954       base = indx;
1955       indx = tmp;
1956     }
1957
1958   /* Validate displacement.  */
1959   if (!disp)
1960     {
1961       /* If virtual registers are involved, the displacement will change later
1962          anyway as the virtual registers get eliminated.  This could make a
1963          valid displacement invalid, but it is more likely to make an invalid
1964          displacement valid, because we sometimes access the register save area
1965          via negative offsets to one of those registers.
1966          Thus we don't check the displacement for validity here.  If after
1967          elimination the displacement turns out to be invalid after all,
1968          this is fixed up by reload in any case.  */
1969       if (base != arg_pointer_rtx
1970           && indx != arg_pointer_rtx
1971           && base != return_address_pointer_rtx
1972           && indx != return_address_pointer_rtx
1973           && base != frame_pointer_rtx
1974           && indx != frame_pointer_rtx
1975           && base != virtual_stack_vars_rtx
1976           && indx != virtual_stack_vars_rtx)
1977         if (!DISP_IN_RANGE (offset))
1978           return false;
1979     }
1980   else
1981     {
1982       /* All the special cases are pointers.  */
1983       pointer = true;
1984
1985       /* In the small-PIC case, the linker converts @GOT
1986          and @GOTNTPOFF offsets to possible displacements.  */
1987       if (GET_CODE (disp) == UNSPEC
1988           && (XINT (disp, 1) == UNSPEC_GOT
1989               || XINT (disp, 1) == UNSPEC_GOTNTPOFF)
1990           && flag_pic == 1)
1991         {
1992           ;
1993         }
1994
1995       /* Accept pool label offsets.  */
1996       else if (GET_CODE (disp) == UNSPEC
1997                && XINT (disp, 1) == UNSPEC_POOL_OFFSET)
1998         ;
1999
2000       /* Accept literal pool references.  */
2001       else if (GET_CODE (disp) == UNSPEC
2002                && XINT (disp, 1) == UNSPEC_LTREL_OFFSET)
2003         {
2004           orig_disp = gen_rtx_CONST (Pmode, disp);
2005           if (offset)
2006             {
2007               /* If we have an offset, make sure it does not
2008                  exceed the size of the constant pool entry.  */
2009               rtx sym = XVECEXP (disp, 0, 0);
2010               if (offset >= GET_MODE_SIZE (get_pool_mode (sym)))
2011                 return false;
2012
2013               orig_disp = plus_constant (orig_disp, offset);
2014             }
2015         }
2016
2017       else
2018         return false;
2019     }
2020
2021   if (!base && !indx)
2022     pointer = true;
2023
2024   if (out)
2025     {
2026       out->base = base;
2027       out->indx = indx;
2028       out->disp = orig_disp;
2029       out->pointer = pointer;
2030       out->literal_pool = literal_pool;
2031     }
2032
2033   return true;
2034 }
2035
2036 /* Decompose a RTL expression OP for a shift count into its components,
2037    and return the base register in BASE and the offset in OFFSET.
2038
2039    Return true if OP is a valid shift count, false if not.  */
2040
2041 bool
2042 s390_decompose_shift_count (rtx op, rtx *base, HOST_WIDE_INT *offset)
2043 {
2044   HOST_WIDE_INT off = 0;
2045
2046   /* We can have an integer constant, an address register,
2047      or a sum of the two.  */
2048   if (GET_CODE (op) == CONST_INT)
2049     {
2050       off = INTVAL (op);
2051       op = NULL_RTX;
2052     }
2053   if (op && GET_CODE (op) == PLUS && GET_CODE (XEXP (op, 1)) == CONST_INT)
2054     {
2055       off = INTVAL (XEXP (op, 1));
2056       op = XEXP (op, 0);
2057     }
2058   while (op && GET_CODE (op) == SUBREG)
2059     op = SUBREG_REG (op);
2060
2061   if (op && GET_CODE (op) != REG)
2062     return false;
2063
2064   if (offset)
2065     *offset = off;
2066   if (base)
2067     *base = op;
2068
2069    return true;
2070 }
2071
2072
2073 /* Return true if CODE is a valid address without index.  */
2074
2075 bool
2076 s390_legitimate_address_without_index_p (rtx op)
2077 {
2078   struct s390_address addr;
2079
2080   if (!s390_decompose_address (XEXP (op, 0), &addr))
2081     return false;
2082   if (addr.indx)
2083     return false;
2084
2085   return true;
2086 }
2087
2088
2089 /* Return true if ADDR is of kind symbol_ref or symbol_ref + const_int
2090    and return these parts in SYMREF and ADDEND.  You can pass NULL in
2091    SYMREF and/or ADDEND if you are not interested in these values.  */
2092
2093 static bool
2094 s390_symref_operand_p (rtx addr, rtx *symref, HOST_WIDE_INT *addend)
2095 {
2096   HOST_WIDE_INT tmpaddend = 0;
2097
2098   if (GET_CODE (addr) == CONST)
2099     addr = XEXP (addr, 0);
2100
2101   if (GET_CODE (addr) == PLUS)
2102     {
2103       if (GET_CODE (XEXP (addr, 0)) == SYMBOL_REF
2104           && CONST_INT_P (XEXP (addr, 1)))
2105         {
2106           tmpaddend = INTVAL (XEXP (addr, 1));
2107           addr = XEXP (addr, 0);
2108         }
2109       else
2110         return false;
2111     }
2112   else
2113     if (GET_CODE (addr) != SYMBOL_REF)
2114         return false;
2115
2116   if (symref)
2117     *symref = addr;
2118   if (addend)
2119     *addend = tmpaddend;
2120
2121   return true;
2122 }
2123
2124
2125 /* Return true if the address in OP is valid for constraint letter C
2126    if wrapped in a MEM rtx.  Set LIT_POOL_OK to true if it literal
2127    pool MEMs should be accepted.  Only the Q, R, S, T constraint
2128    letters are allowed for C.  */
2129
2130 static int
2131 s390_check_qrst_address (char c, rtx op, bool lit_pool_ok)
2132 {
2133   struct s390_address addr;
2134   bool decomposed = false;
2135
2136   /* This check makes sure that no symbolic address (except literal
2137      pool references) are accepted by the R or T constraints.  */
2138   if (s390_symref_operand_p (op, NULL, NULL))
2139     {
2140       if (!lit_pool_ok)
2141         return 0;
2142       if (!s390_decompose_address (op, &addr))
2143         return 0;
2144       if (!addr.literal_pool)
2145         return 0;
2146       decomposed = true;
2147     }
2148
2149   switch (c)
2150     {
2151     case 'Q': /* no index short displacement */
2152       if (!decomposed && !s390_decompose_address (op, &addr))
2153         return 0;
2154       if (addr.indx)
2155         return 0;
2156       if (!s390_short_displacement (addr.disp))
2157         return 0;
2158       break;
2159
2160     case 'R': /* with index short displacement */
2161       if (TARGET_LONG_DISPLACEMENT)
2162         {
2163           if (!decomposed && !s390_decompose_address (op, &addr))
2164             return 0;
2165           if (!s390_short_displacement (addr.disp))
2166             return 0;
2167         }
2168       /* Any invalid address here will be fixed up by reload,
2169          so accept it for the most generic constraint.  */
2170       break;
2171
2172     case 'S': /* no index long displacement */
2173       if (!TARGET_LONG_DISPLACEMENT)
2174         return 0;
2175       if (!decomposed && !s390_decompose_address (op, &addr))
2176         return 0;
2177       if (addr.indx)
2178         return 0;
2179       if (s390_short_displacement (addr.disp))
2180         return 0;
2181       break;
2182
2183     case 'T': /* with index long displacement */
2184       if (!TARGET_LONG_DISPLACEMENT)
2185         return 0;
2186       /* Any invalid address here will be fixed up by reload,
2187          so accept it for the most generic constraint.  */
2188       if ((decomposed || s390_decompose_address (op, &addr))
2189           && s390_short_displacement (addr.disp))
2190         return 0;
2191       break;
2192     default:
2193       return 0;
2194     }
2195   return 1;
2196 }
2197
2198
2199 /* Evaluates constraint strings described by the regular expression
2200    ([A|B|Z](Q|R|S|T))|U|W|Y and returns 1 if OP is a valid operand for
2201    the constraint given in STR, or 0 else.  */
2202
2203 int
2204 s390_mem_constraint (const char *str, rtx op)
2205 {
2206   char c = str[0];
2207
2208   switch (c)
2209     {
2210     case 'A':
2211       /* Check for offsettable variants of memory constraints.  */
2212       if (!MEM_P (op) || MEM_VOLATILE_P (op))
2213         return 0;
2214       if ((reload_completed || reload_in_progress)
2215           ? !offsettable_memref_p (op) : !offsettable_nonstrict_memref_p (op))
2216         return 0;
2217       return s390_check_qrst_address (str[1], XEXP (op, 0), true);
2218     case 'B':
2219       /* Check for non-literal-pool variants of memory constraints.  */
2220       if (!MEM_P (op))
2221         return 0;
2222       return s390_check_qrst_address (str[1], XEXP (op, 0), false);
2223     case 'Q':
2224     case 'R':
2225     case 'S':
2226     case 'T':
2227       if (GET_CODE (op) != MEM)
2228         return 0;
2229       return s390_check_qrst_address (c, XEXP (op, 0), true);
2230     case 'U':
2231       return (s390_check_qrst_address ('Q', op, true)
2232               || s390_check_qrst_address ('R', op, true));
2233     case 'W':
2234       return (s390_check_qrst_address ('S', op, true)
2235               || s390_check_qrst_address ('T', op, true));
2236     case 'Y':
2237       /* Simply check for the basic form of a shift count.  Reload will
2238          take care of making sure we have a proper base register.  */
2239       if (!s390_decompose_shift_count (op, NULL, NULL))
2240         return 0;
2241       break;
2242     case 'Z':
2243       return s390_check_qrst_address (str[1], op, true);
2244     default:
2245       return 0;
2246     }
2247   return 1;
2248 }
2249
2250
2251 /* Evaluates constraint strings starting with letter O.  Input
2252    parameter C is the second letter following the "O" in the constraint
2253    string. Returns 1 if VALUE meets the respective constraint and 0
2254    otherwise.  */
2255
2256 int
2257 s390_O_constraint_str (const char c, HOST_WIDE_INT value)
2258 {
2259   if (!TARGET_EXTIMM)
2260     return 0;
2261
2262   switch (c)
2263     {
2264     case 's':
2265       return trunc_int_for_mode (value, SImode) == value;
2266
2267     case 'p':
2268       return value == 0
2269         || s390_single_part (GEN_INT (value), DImode, SImode, 0) == 1;
2270
2271     case 'n':
2272       return s390_single_part (GEN_INT (value - 1), DImode, SImode, -1) == 1;
2273
2274     default:
2275       gcc_unreachable ();
2276     }
2277 }
2278
2279
2280 /* Evaluates constraint strings starting with letter N.  Parameter STR
2281    contains the letters following letter "N" in the constraint string.
2282    Returns true if VALUE matches the constraint.  */
2283
2284 int
2285 s390_N_constraint_str (const char *str, HOST_WIDE_INT value)
2286 {
2287   enum machine_mode mode, part_mode;
2288   int def;
2289   int part, part_goal;
2290
2291
2292   if (str[0] == 'x')
2293     part_goal = -1;
2294   else
2295     part_goal = str[0] - '0';
2296
2297   switch (str[1])
2298     {
2299     case 'Q':
2300       part_mode = QImode;
2301       break;
2302     case 'H':
2303       part_mode = HImode;
2304       break;
2305     case 'S':
2306       part_mode = SImode;
2307       break;
2308     default:
2309       return 0;
2310     }
2311
2312   switch (str[2])
2313     {
2314     case 'H':
2315       mode = HImode;
2316       break;
2317     case 'S':
2318       mode = SImode;
2319       break;
2320     case 'D':
2321       mode = DImode;
2322       break;
2323     default:
2324       return 0;
2325     }
2326
2327   switch (str[3])
2328     {
2329     case '0':
2330       def = 0;
2331       break;
2332     case 'F':
2333       def = -1;
2334       break;
2335     default:
2336       return 0;
2337     }
2338
2339   if (GET_MODE_SIZE (mode) <= GET_MODE_SIZE (part_mode))
2340     return 0;
2341
2342   part = s390_single_part (GEN_INT (value), mode, part_mode, def);
2343   if (part < 0)
2344     return 0;
2345   if (part_goal != -1 && part_goal != part)
2346     return 0;
2347
2348   return 1;
2349 }
2350
2351
2352 /* Returns true if the input parameter VALUE is a float zero.  */
2353
2354 int
2355 s390_float_const_zero_p (rtx value)
2356 {
2357   return (GET_MODE_CLASS (GET_MODE (value)) == MODE_FLOAT
2358           && value == CONST0_RTX (GET_MODE (value)));
2359 }
2360
2361
2362 /* Compute a (partial) cost for rtx X.  Return true if the complete
2363    cost has been computed, and false if subexpressions should be
2364    scanned.  In either case, *TOTAL contains the cost result.
2365    CODE contains GET_CODE (x), OUTER_CODE contains the code
2366    of the superexpression of x.  */
2367
2368 static bool
2369 s390_rtx_costs (rtx x, int code, int outer_code, int *total,
2370                 bool speed ATTRIBUTE_UNUSED)
2371 {
2372   switch (code)
2373     {
2374     case CONST:
2375     case CONST_INT:
2376     case LABEL_REF:
2377     case SYMBOL_REF:
2378     case CONST_DOUBLE:
2379     case MEM:
2380       *total = 0;
2381       return true;
2382
2383     case ASHIFT:
2384     case ASHIFTRT:
2385     case LSHIFTRT:
2386     case ROTATE:
2387     case ROTATERT:
2388     case AND:
2389     case IOR:
2390     case XOR:
2391     case NEG:
2392     case NOT:
2393       *total = COSTS_N_INSNS (1);
2394       return false;
2395
2396     case PLUS:
2397     case MINUS:
2398       /* Check for multiply and add.  */
2399       if ((GET_MODE (x) == DFmode || GET_MODE (x) == SFmode)
2400           && GET_CODE (XEXP (x, 0)) == MULT
2401           && TARGET_HARD_FLOAT && TARGET_FUSED_MADD)
2402         {
2403           /* This is the multiply and add case.  */
2404           if (GET_MODE (x) == DFmode)
2405             *total = s390_cost->madbr;
2406           else
2407             *total = s390_cost->maebr;
2408           *total += (rtx_cost (XEXP (XEXP (x, 0), 0), MULT, speed)
2409                      + rtx_cost (XEXP (XEXP (x, 0), 1), MULT, speed)
2410                      + rtx_cost (XEXP (x, 1), (enum rtx_code) code, speed));
2411           return true;  /* Do not do an additional recursive descent.  */
2412         }
2413       *total = COSTS_N_INSNS (1);
2414       return false;
2415
2416     case MULT:
2417       switch (GET_MODE (x))
2418         {
2419         case SImode:
2420           {
2421             rtx left = XEXP (x, 0);
2422             rtx right = XEXP (x, 1);
2423             if (GET_CODE (right) == CONST_INT
2424                 && CONST_OK_FOR_K (INTVAL (right)))
2425               *total = s390_cost->mhi;
2426             else if (GET_CODE (left) == SIGN_EXTEND)
2427               *total = s390_cost->mh;
2428             else
2429               *total = s390_cost->ms;  /* msr, ms, msy */
2430             break;
2431           }
2432         case DImode:
2433           {
2434             rtx left = XEXP (x, 0);
2435             rtx right = XEXP (x, 1);
2436             if (TARGET_ZARCH)
2437               {
2438                 if (GET_CODE (right) == CONST_INT
2439                     && CONST_OK_FOR_K (INTVAL (right)))
2440                   *total = s390_cost->mghi;
2441                 else if (GET_CODE (left) == SIGN_EXTEND)
2442                   *total = s390_cost->msgf;
2443                 else
2444                   *total = s390_cost->msg;  /* msgr, msg */
2445               }
2446             else /* TARGET_31BIT */
2447               {
2448                 if (GET_CODE (left) == SIGN_EXTEND
2449                     && GET_CODE (right) == SIGN_EXTEND)
2450                   /* mulsidi case: mr, m */
2451                   *total = s390_cost->m;
2452                 else if (GET_CODE (left) == ZERO_EXTEND
2453                          && GET_CODE (right) == ZERO_EXTEND
2454                          && TARGET_CPU_ZARCH)
2455                   /* umulsidi case: ml, mlr */
2456                   *total = s390_cost->ml;
2457                 else
2458                   /* Complex calculation is required.  */
2459                   *total = COSTS_N_INSNS (40);
2460               }
2461             break;
2462           }
2463         case SFmode:
2464         case DFmode:
2465           *total = s390_cost->mult_df;
2466           break;
2467         case TFmode:
2468           *total = s390_cost->mxbr;
2469           break;
2470         default:
2471           return false;
2472         }
2473       return false;
2474
2475     case UDIV:
2476     case UMOD:
2477       if (GET_MODE (x) == TImode)              /* 128 bit division */
2478         *total = s390_cost->dlgr;
2479       else if (GET_MODE (x) == DImode)
2480         {
2481           rtx right = XEXP (x, 1);
2482           if (GET_CODE (right) == ZERO_EXTEND) /* 64 by 32 bit division */
2483             *total = s390_cost->dlr;
2484           else                                 /* 64 by 64 bit division */
2485             *total = s390_cost->dlgr;
2486         }
2487       else if (GET_MODE (x) == SImode)         /* 32 bit division */
2488         *total = s390_cost->dlr;
2489       return false;
2490
2491     case DIV:
2492     case MOD:
2493       if (GET_MODE (x) == DImode)
2494         {
2495           rtx right = XEXP (x, 1);
2496           if (GET_CODE (right) == ZERO_EXTEND) /* 64 by 32 bit division */
2497             if (TARGET_ZARCH)
2498               *total = s390_cost->dsgfr;
2499             else
2500               *total = s390_cost->dr;
2501           else                                 /* 64 by 64 bit division */
2502             *total = s390_cost->dsgr;
2503         }
2504       else if (GET_MODE (x) == SImode)         /* 32 bit division */
2505         *total = s390_cost->dlr;
2506       else if (GET_MODE (x) == SFmode)
2507         {
2508           *total = s390_cost->debr;
2509         }
2510       else if (GET_MODE (x) == DFmode)
2511         {
2512           *total = s390_cost->ddbr;
2513         }
2514       else if (GET_MODE (x) == TFmode)
2515         {
2516           *total = s390_cost->dxbr;
2517         }
2518       return false;
2519
2520     case SQRT:
2521       if (GET_MODE (x) == SFmode)
2522         *total = s390_cost->sqebr;
2523       else if (GET_MODE (x) == DFmode)
2524         *total = s390_cost->sqdbr;
2525       else /* TFmode */
2526         *total = s390_cost->sqxbr;
2527       return false;
2528
2529     case SIGN_EXTEND:
2530     case ZERO_EXTEND:
2531       if (outer_code == MULT || outer_code == DIV || outer_code == MOD
2532           || outer_code == PLUS || outer_code == MINUS
2533           || outer_code == COMPARE)
2534         *total = 0;
2535       return false;
2536
2537     case COMPARE:
2538       *total = COSTS_N_INSNS (1);
2539       if (GET_CODE (XEXP (x, 0)) == AND
2540           && GET_CODE (XEXP (x, 1)) == CONST_INT
2541           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
2542         {
2543           rtx op0 = XEXP (XEXP (x, 0), 0);
2544           rtx op1 = XEXP (XEXP (x, 0), 1);
2545           rtx op2 = XEXP (x, 1);
2546
2547           if (memory_operand (op0, GET_MODE (op0))
2548               && s390_tm_ccmode (op1, op2, 0) != VOIDmode)
2549             return true;
2550           if (register_operand (op0, GET_MODE (op0))
2551               && s390_tm_ccmode (op1, op2, 1) != VOIDmode)
2552             return true;
2553         }
2554       return false;
2555
2556     default:
2557       return false;
2558     }
2559 }
2560
2561 /* Return the cost of an address rtx ADDR.  */
2562
2563 static int
2564 s390_address_cost (rtx addr, bool speed ATTRIBUTE_UNUSED)
2565 {
2566   struct s390_address ad;
2567   if (!s390_decompose_address (addr, &ad))
2568     return 1000;
2569
2570   return ad.indx? COSTS_N_INSNS (1) + 1 : COSTS_N_INSNS (1);
2571 }
2572
2573 /* If OP is a SYMBOL_REF of a thread-local symbol, return its TLS mode,
2574    otherwise return 0.  */
2575
2576 int
2577 tls_symbolic_operand (rtx op)
2578 {
2579   if (GET_CODE (op) != SYMBOL_REF)
2580     return 0;
2581   return SYMBOL_REF_TLS_MODEL (op);
2582 }
2583 \f
2584 /* Split DImode access register reference REG (on 64-bit) into its constituent
2585    low and high parts, and store them into LO and HI.  Note that gen_lowpart/
2586    gen_highpart cannot be used as they assume all registers are word-sized,
2587    while our access registers have only half that size.  */
2588
2589 void
2590 s390_split_access_reg (rtx reg, rtx *lo, rtx *hi)
2591 {
2592   gcc_assert (TARGET_64BIT);
2593   gcc_assert (ACCESS_REG_P (reg));
2594   gcc_assert (GET_MODE (reg) == DImode);
2595   gcc_assert (!(REGNO (reg) & 1));
2596
2597   *lo = gen_rtx_REG (SImode, REGNO (reg) + 1);
2598   *hi = gen_rtx_REG (SImode, REGNO (reg));
2599 }
2600
2601 /* Return true if OP contains a symbol reference */
2602
2603 bool
2604 symbolic_reference_mentioned_p (rtx op)
2605 {
2606   const char *fmt;
2607   int i;
2608
2609   if (GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == LABEL_REF)
2610     return 1;
2611
2612   fmt = GET_RTX_FORMAT (GET_CODE (op));
2613   for (i = GET_RTX_LENGTH (GET_CODE (op)) - 1; i >= 0; i--)
2614     {
2615       if (fmt[i] == 'E')
2616         {
2617           int j;
2618
2619           for (j = XVECLEN (op, i) - 1; j >= 0; j--)
2620             if (symbolic_reference_mentioned_p (XVECEXP (op, i, j)))
2621               return 1;
2622         }
2623
2624       else if (fmt[i] == 'e' && symbolic_reference_mentioned_p (XEXP (op, i)))
2625         return 1;
2626     }
2627
2628   return 0;
2629 }
2630
2631 /* Return true if OP contains a reference to a thread-local symbol.  */
2632
2633 bool
2634 tls_symbolic_reference_mentioned_p (rtx op)
2635 {
2636   const char *fmt;
2637   int i;
2638
2639   if (GET_CODE (op) == SYMBOL_REF)
2640     return tls_symbolic_operand (op);
2641
2642   fmt = GET_RTX_FORMAT (GET_CODE (op));
2643   for (i = GET_RTX_LENGTH (GET_CODE (op)) - 1; i >= 0; i--)
2644     {
2645       if (fmt[i] == 'E')
2646         {
2647           int j;
2648
2649           for (j = XVECLEN (op, i) - 1; j >= 0; j--)
2650             if (tls_symbolic_reference_mentioned_p (XVECEXP (op, i, j)))
2651               return true;
2652         }
2653
2654       else if (fmt[i] == 'e' && tls_symbolic_reference_mentioned_p (XEXP (op, i)))
2655         return true;
2656     }
2657
2658   return false;
2659 }
2660
2661
2662 /* Return true if OP is a legitimate general operand when
2663    generating PIC code.  It is given that flag_pic is on
2664    and that OP satisfies CONSTANT_P or is a CONST_DOUBLE.  */
2665
2666 int
2667 legitimate_pic_operand_p (rtx op)
2668 {
2669   /* Accept all non-symbolic constants.  */
2670   if (!SYMBOLIC_CONST (op))
2671     return 1;
2672
2673   /* Reject everything else; must be handled
2674      via emit_symbolic_move.  */
2675   return 0;
2676 }
2677
2678 /* Returns true if the constant value OP is a legitimate general operand.
2679    It is given that OP satisfies CONSTANT_P or is a CONST_DOUBLE.  */
2680
2681 int
2682 legitimate_constant_p (rtx op)
2683 {
2684   /* Accept all non-symbolic constants.  */
2685   if (!SYMBOLIC_CONST (op))
2686     return 1;
2687
2688   /* Accept immediate LARL operands.  */
2689   if (TARGET_CPU_ZARCH && larl_operand (op, VOIDmode))
2690     return 1;
2691
2692   /* Thread-local symbols are never legal constants.  This is
2693      so that emit_call knows that computing such addresses
2694      might require a function call.  */
2695   if (TLS_SYMBOLIC_CONST (op))
2696     return 0;
2697
2698   /* In the PIC case, symbolic constants must *not* be
2699      forced into the literal pool.  We accept them here,
2700      so that they will be handled by emit_symbolic_move.  */
2701   if (flag_pic)
2702     return 1;
2703
2704   /* All remaining non-PIC symbolic constants are
2705      forced into the literal pool.  */
2706   return 0;
2707 }
2708
2709 /* Determine if it's legal to put X into the constant pool.  This
2710    is not possible if X contains the address of a symbol that is
2711    not constant (TLS) or not known at final link time (PIC).  */
2712
2713 static bool
2714 s390_cannot_force_const_mem (rtx x)
2715 {
2716   switch (GET_CODE (x))
2717     {
2718     case CONST_INT:
2719     case CONST_DOUBLE:
2720       /* Accept all non-symbolic constants.  */
2721       return false;
2722
2723     case LABEL_REF:
2724       /* Labels are OK iff we are non-PIC.  */
2725       return flag_pic != 0;
2726
2727     case SYMBOL_REF:
2728       /* 'Naked' TLS symbol references are never OK,
2729          non-TLS symbols are OK iff we are non-PIC.  */
2730       if (tls_symbolic_operand (x))
2731         return true;
2732       else
2733         return flag_pic != 0;
2734
2735     case CONST:
2736       return s390_cannot_force_const_mem (XEXP (x, 0));
2737     case PLUS:
2738     case MINUS:
2739       return s390_cannot_force_const_mem (XEXP (x, 0))
2740              || s390_cannot_force_const_mem (XEXP (x, 1));
2741
2742     case UNSPEC:
2743       switch (XINT (x, 1))
2744         {
2745         /* Only lt-relative or GOT-relative UNSPECs are OK.  */
2746         case UNSPEC_LTREL_OFFSET:
2747         case UNSPEC_GOT:
2748         case UNSPEC_GOTOFF:
2749         case UNSPEC_PLTOFF:
2750         case UNSPEC_TLSGD:
2751         case UNSPEC_TLSLDM:
2752         case UNSPEC_NTPOFF:
2753         case UNSPEC_DTPOFF:
2754         case UNSPEC_GOTNTPOFF:
2755         case UNSPEC_INDNTPOFF:
2756           return false;
2757
2758         /* If the literal pool shares the code section, be put
2759            execute template placeholders into the pool as well.  */
2760         case UNSPEC_INSN:
2761           return TARGET_CPU_ZARCH;
2762
2763         default:
2764           return true;
2765         }
2766       break;
2767
2768     default:
2769       gcc_unreachable ();
2770     }
2771 }
2772
2773 /* Returns true if the constant value OP is a legitimate general
2774    operand during and after reload.  The difference to
2775    legitimate_constant_p is that this function will not accept
2776    a constant that would need to be forced to the literal pool
2777    before it can be used as operand.  */
2778
2779 bool
2780 legitimate_reload_constant_p (rtx op)
2781 {
2782   /* Accept la(y) operands.  */
2783   if (GET_CODE (op) == CONST_INT
2784       && DISP_IN_RANGE (INTVAL (op)))
2785     return true;
2786
2787   /* Accept l(g)hi/l(g)fi operands.  */
2788   if (GET_CODE (op) == CONST_INT
2789       && (CONST_OK_FOR_K (INTVAL (op)) || CONST_OK_FOR_Os (INTVAL (op))))
2790     return true;
2791
2792   /* Accept lliXX operands.  */
2793   if (TARGET_ZARCH
2794       && GET_CODE (op) == CONST_INT
2795       && trunc_int_for_mode (INTVAL (op), word_mode) == INTVAL (op)
2796       && s390_single_part (op, word_mode, HImode, 0) >= 0)
2797   return true;
2798
2799   if (TARGET_EXTIMM
2800       && GET_CODE (op) == CONST_INT
2801       && trunc_int_for_mode (INTVAL (op), word_mode) == INTVAL (op)
2802       && s390_single_part (op, word_mode, SImode, 0) >= 0)
2803     return true;
2804
2805   /* Accept larl operands.  */
2806   if (TARGET_CPU_ZARCH
2807       && larl_operand (op, VOIDmode))
2808     return true;
2809
2810   /* Accept lzXX operands.  */
2811   if (GET_CODE (op) == CONST_DOUBLE
2812       && CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, 'G', "G"))
2813     return true;
2814
2815   /* Accept double-word operands that can be split.  */
2816   if (GET_CODE (op) == CONST_INT
2817       && trunc_int_for_mode (INTVAL (op), word_mode) != INTVAL (op))
2818     {
2819       enum machine_mode dword_mode = word_mode == SImode ? DImode : TImode;
2820       rtx hi = operand_subword (op, 0, 0, dword_mode);
2821       rtx lo = operand_subword (op, 1, 0, dword_mode);
2822       return legitimate_reload_constant_p (hi)
2823              && legitimate_reload_constant_p (lo);
2824     }
2825
2826   /* Everything else cannot be handled without reload.  */
2827   return false;
2828 }
2829
2830 /* Given an rtx OP being reloaded into a reg required to be in class RCLASS,
2831    return the class of reg to actually use.  */
2832
2833 enum reg_class
2834 s390_preferred_reload_class (rtx op, enum reg_class rclass)
2835 {
2836   switch (GET_CODE (op))
2837     {
2838       /* Constants we cannot reload must be forced into the
2839          literal pool.  */
2840
2841       case CONST_DOUBLE:
2842       case CONST_INT:
2843         if (legitimate_reload_constant_p (op))
2844           return rclass;
2845         else
2846           return NO_REGS;
2847
2848       /* If a symbolic constant or a PLUS is reloaded,
2849          it is most likely being used as an address, so
2850          prefer ADDR_REGS.  If 'class' is not a superset
2851          of ADDR_REGS, e.g. FP_REGS, reject this reload.  */
2852       case PLUS:
2853       case LABEL_REF:
2854       case SYMBOL_REF:
2855       case CONST:
2856         if (reg_class_subset_p (ADDR_REGS, rclass))
2857           return ADDR_REGS;
2858         else
2859           return NO_REGS;
2860
2861       default:
2862         break;
2863     }
2864
2865   return rclass;
2866 }
2867
2868 /* Return true if ADDR is SYMBOL_REF + addend with addend being a
2869    multiple of ALIGNMENT and the SYMBOL_REF being naturally
2870    aligned.  */
2871
2872 bool
2873 s390_check_symref_alignment (rtx addr, HOST_WIDE_INT alignment)
2874 {
2875   HOST_WIDE_INT addend;
2876   rtx symref;
2877
2878   if (!s390_symref_operand_p (addr, &symref, &addend))
2879     return false;
2880
2881   return (!SYMBOL_REF_NOT_NATURALLY_ALIGNED_P (symref)
2882           && !(addend & (alignment - 1)));
2883 }
2884
2885 /* ADDR is moved into REG using larl.  If ADDR isn't a valid larl
2886    operand SCRATCH is used to reload the even part of the address and
2887    adding one.  */
2888
2889 void
2890 s390_reload_larl_operand (rtx reg, rtx addr, rtx scratch)
2891 {
2892   HOST_WIDE_INT addend;
2893   rtx symref;
2894
2895   if (!s390_symref_operand_p (addr, &symref, &addend))
2896     gcc_unreachable ();
2897
2898   if (!(addend & 1))
2899     /* Easy case.  The addend is even so larl will do fine.  */
2900     emit_move_insn (reg, addr);
2901   else
2902     {
2903       /* We can leave the scratch register untouched if the target
2904          register is a valid base register.  */
2905       if (REGNO (reg) < FIRST_PSEUDO_REGISTER
2906           && REGNO_REG_CLASS (REGNO (reg)) == ADDR_REGS)
2907         scratch = reg;
2908
2909       gcc_assert (REGNO (scratch) < FIRST_PSEUDO_REGISTER);
2910       gcc_assert (REGNO_REG_CLASS (REGNO (scratch)) == ADDR_REGS);
2911
2912       if (addend != 1)
2913         emit_move_insn (scratch,
2914                         gen_rtx_CONST (Pmode,
2915                                        gen_rtx_PLUS (Pmode, symref,
2916                                                      GEN_INT (addend - 1))));
2917       else
2918         emit_move_insn (scratch, symref);
2919
2920       /* Increment the address using la in order to avoid clobbering cc.  */
2921       emit_move_insn (reg, gen_rtx_PLUS (Pmode, scratch, const1_rtx));
2922     }
2923 }
2924
2925 /* Generate what is necessary to move between REG and MEM using
2926    SCRATCH.  The direction is given by TOMEM.  */
2927
2928 void
2929 s390_reload_symref_address (rtx reg, rtx mem, rtx scratch, bool tomem)
2930 {
2931   /* Reload might have pulled a constant out of the literal pool.
2932      Force it back in.  */
2933   if (CONST_INT_P (mem) || GET_CODE (mem) == CONST_DOUBLE
2934       || GET_CODE (mem) == CONST)
2935     mem = force_const_mem (GET_MODE (reg), mem);
2936
2937   gcc_assert (MEM_P (mem));
2938
2939   /* For a load from memory we can leave the scratch register
2940      untouched if the target register is a valid base register.  */
2941   if (!tomem
2942       && REGNO (reg) < FIRST_PSEUDO_REGISTER
2943       && REGNO_REG_CLASS (REGNO (reg)) == ADDR_REGS
2944       && GET_MODE (reg) == GET_MODE (scratch))
2945     scratch = reg;
2946
2947   /* Load address into scratch register.  Since we can't have a
2948      secondary reload for a secondary reload we have to cover the case
2949      where larl would need a secondary reload here as well.  */
2950   s390_reload_larl_operand (scratch, XEXP (mem, 0), scratch);
2951
2952   /* Now we can use a standard load/store to do the move.  */
2953   if (tomem)
2954     emit_move_insn (replace_equiv_address (mem, scratch), reg);
2955   else
2956     emit_move_insn (reg, replace_equiv_address (mem, scratch));
2957 }
2958
2959 /* Inform reload about cases where moving X with a mode MODE to a register in
2960    RCLASS requires an extra scratch or immediate register.  Return the class
2961    needed for the immediate register.  */
2962
2963 static enum reg_class
2964 s390_secondary_reload (bool in_p, rtx x, enum reg_class rclass,
2965                        enum machine_mode mode, secondary_reload_info *sri)
2966 {
2967   /* Intermediate register needed.  */
2968   if (reg_classes_intersect_p (CC_REGS, rclass))
2969     return GENERAL_REGS;
2970
2971   if (TARGET_Z10)
2972     {
2973       /* On z10 several optimizer steps may generate larl operands with
2974          an odd addend.  */
2975       if (in_p
2976           && s390_symref_operand_p (x, NULL, NULL)
2977           && mode == Pmode
2978           && !s390_check_symref_alignment (x, 2))
2979         sri->icode = ((mode == DImode) ? CODE_FOR_reloaddi_larl_odd_addend_z10
2980                       : CODE_FOR_reloadsi_larl_odd_addend_z10);
2981
2982       /* On z10 we need a scratch register when moving QI, TI or floating
2983          point mode values from or to a memory location with a SYMBOL_REF
2984          or if the symref addend of a SI or DI move is not aligned to the
2985          width of the access.  */
2986       if (MEM_P (x)
2987           && s390_symref_operand_p (XEXP (x, 0), NULL, NULL)
2988           && (mode == QImode || mode == TImode || FLOAT_MODE_P (mode)
2989               || (!TARGET_ZARCH && mode == DImode)
2990               || ((mode == HImode || mode == SImode || mode == DImode)
2991                   && (!s390_check_symref_alignment (XEXP (x, 0),
2992                                                     GET_MODE_SIZE (mode))))))
2993         {
2994 #define __SECONDARY_RELOAD_CASE(M,m)                                    \
2995           case M##mode:                                                 \
2996             if (TARGET_64BIT)                                           \
2997               sri->icode = in_p ? CODE_FOR_reload##m##di_toreg_z10 :    \
2998                                   CODE_FOR_reload##m##di_tomem_z10;     \
2999             else                                                        \
3000               sri->icode = in_p ? CODE_FOR_reload##m##si_toreg_z10 :    \
3001                                   CODE_FOR_reload##m##si_tomem_z10;     \
3002           break;
3003
3004           switch (GET_MODE (x))
3005             {
3006               __SECONDARY_RELOAD_CASE (QI, qi);
3007               __SECONDARY_RELOAD_CASE (HI, hi);
3008               __SECONDARY_RELOAD_CASE (SI, si);
3009               __SECONDARY_RELOAD_CASE (DI, di);
3010               __SECONDARY_RELOAD_CASE (TI, ti);
3011               __SECONDARY_RELOAD_CASE (SF, sf);
3012               __SECONDARY_RELOAD_CASE (DF, df);
3013               __SECONDARY_RELOAD_CASE (TF, tf);
3014               __SECONDARY_RELOAD_CASE (SD, sd);
3015               __SECONDARY_RELOAD_CASE (DD, dd);
3016               __SECONDARY_RELOAD_CASE (TD, td);
3017
3018             default:
3019               gcc_unreachable ();
3020             }
3021 #undef __SECONDARY_RELOAD_CASE
3022         }
3023     }
3024
3025   /* We need a scratch register when loading a PLUS expression which
3026      is not a legitimate operand of the LOAD ADDRESS instruction.  */
3027   if (in_p && s390_plus_operand (x, mode))
3028     sri->icode = (TARGET_64BIT ?
3029                   CODE_FOR_reloaddi_plus : CODE_FOR_reloadsi_plus);
3030
3031   /* Performing a multiword move from or to memory we have to make sure the
3032      second chunk in memory is addressable without causing a displacement
3033      overflow.  If that would be the case we calculate the address in
3034      a scratch register.  */
3035   if (MEM_P (x)
3036       && GET_CODE (XEXP (x, 0)) == PLUS
3037       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
3038       && !DISP_IN_RANGE (INTVAL (XEXP (XEXP (x, 0), 1))
3039                          + GET_MODE_SIZE (mode) - 1))
3040     {
3041       /* For GENERAL_REGS a displacement overflow is no problem if occurring
3042          in a s_operand address since we may fallback to lm/stm.  So we only
3043          have to care about overflows in the b+i+d case.  */
3044       if ((reg_classes_intersect_p (GENERAL_REGS, rclass)
3045            && s390_class_max_nregs (GENERAL_REGS, mode) > 1
3046            && GET_CODE (XEXP (XEXP (x, 0), 0)) == PLUS)
3047           /* For FP_REGS no lm/stm is available so this check is triggered
3048              for displacement overflows in b+i+d and b+d like addresses.  */
3049           || (reg_classes_intersect_p (FP_REGS, rclass)
3050               && s390_class_max_nregs (FP_REGS, mode) > 1))
3051         {
3052           if (in_p)
3053             sri->icode = (TARGET_64BIT ?
3054                           CODE_FOR_reloaddi_nonoffmem_in :
3055                           CODE_FOR_reloadsi_nonoffmem_in);
3056           else
3057             sri->icode = (TARGET_64BIT ?
3058                           CODE_FOR_reloaddi_nonoffmem_out :
3059                           CODE_FOR_reloadsi_nonoffmem_out);
3060         }
3061     }
3062
3063   /* A scratch address register is needed when a symbolic constant is
3064      copied to r0 compiling with -fPIC.  In other cases the target
3065      register might be used as temporary (see legitimize_pic_address).  */
3066   if (in_p && SYMBOLIC_CONST (x) && flag_pic == 2 && rclass != ADDR_REGS)
3067     sri->icode = (TARGET_64BIT ?
3068                   CODE_FOR_reloaddi_PIC_addr :
3069                   CODE_FOR_reloadsi_PIC_addr);
3070
3071   /* Either scratch or no register needed.  */
3072   return NO_REGS;
3073 }
3074
3075 /* Generate code to load SRC, which is PLUS that is not a
3076    legitimate operand for the LA instruction, into TARGET.
3077    SCRATCH may be used as scratch register.  */
3078
3079 void
3080 s390_expand_plus_operand (rtx target, rtx src,
3081                           rtx scratch)
3082 {
3083   rtx sum1, sum2;
3084   struct s390_address ad;
3085
3086   /* src must be a PLUS; get its two operands.  */
3087   gcc_assert (GET_CODE (src) == PLUS);
3088   gcc_assert (GET_MODE (src) == Pmode);
3089
3090   /* Check if any of the two operands is already scheduled
3091      for replacement by reload.  This can happen e.g. when
3092      float registers occur in an address.  */
3093   sum1 = find_replacement (&XEXP (src, 0));
3094   sum2 = find_replacement (&XEXP (src, 1));
3095   src = gen_rtx_PLUS (Pmode, sum1, sum2);
3096
3097   /* If the address is already strictly valid, there's nothing to do.  */
3098   if (!s390_decompose_address (src, &ad)
3099       || (ad.base && !REGNO_OK_FOR_BASE_P (REGNO (ad.base)))
3100       || (ad.indx && !REGNO_OK_FOR_INDEX_P (REGNO (ad.indx))))
3101     {
3102       /* Otherwise, one of the operands cannot be an address register;
3103          we reload its value into the scratch register.  */
3104       if (true_regnum (sum1) < 1 || true_regnum (sum1) > 15)
3105         {
3106           emit_move_insn (scratch, sum1);
3107           sum1 = scratch;
3108         }
3109       if (true_regnum (sum2) < 1 || true_regnum (sum2) > 15)
3110         {
3111           emit_move_insn (scratch, sum2);
3112           sum2 = scratch;
3113         }
3114
3115       /* According to the way these invalid addresses are generated
3116          in reload.c, it should never happen (at least on s390) that
3117          *neither* of the PLUS components, after find_replacements
3118          was applied, is an address register.  */
3119       if (sum1 == scratch && sum2 == scratch)
3120         {
3121           debug_rtx (src);
3122           gcc_unreachable ();
3123         }
3124
3125       src = gen_rtx_PLUS (Pmode, sum1, sum2);
3126     }
3127
3128   /* Emit the LOAD ADDRESS pattern.  Note that reload of PLUS
3129      is only ever performed on addresses, so we can mark the
3130      sum as legitimate for LA in any case.  */
3131   s390_load_address (target, src);
3132 }
3133
3134
3135 /* Return true if ADDR is a valid memory address.
3136    STRICT specifies whether strict register checking applies.  */
3137
3138 static bool
3139 s390_legitimate_address_p (enum machine_mode mode, rtx addr, bool strict)
3140 {
3141   struct s390_address ad;
3142
3143   if (TARGET_Z10
3144       && larl_operand (addr, VOIDmode)
3145       && (mode == VOIDmode
3146           || s390_check_symref_alignment (addr, GET_MODE_SIZE (mode))))
3147     return true;
3148
3149   if (!s390_decompose_address (addr, &ad))
3150     return false;
3151
3152   if (strict)
3153     {
3154       if (ad.base && !REGNO_OK_FOR_BASE_P (REGNO (ad.base)))
3155         return false;
3156
3157       if (ad.indx && !REGNO_OK_FOR_INDEX_P (REGNO (ad.indx)))
3158         return false;
3159     }
3160   else
3161     {
3162       if (ad.base
3163           && !(REGNO (ad.base) >= FIRST_PSEUDO_REGISTER
3164                || REGNO_REG_CLASS (REGNO (ad.base)) == ADDR_REGS))
3165         return false;
3166
3167       if (ad.indx
3168           && !(REGNO (ad.indx) >= FIRST_PSEUDO_REGISTER
3169                || REGNO_REG_CLASS (REGNO (ad.indx)) == ADDR_REGS))
3170           return false;
3171     }
3172   return true;
3173 }
3174
3175 /* Return true if OP is a valid operand for the LA instruction.
3176    In 31-bit, we need to prove that the result is used as an
3177    address, as LA performs only a 31-bit addition.  */
3178
3179 bool
3180 legitimate_la_operand_p (rtx op)
3181 {
3182   struct s390_address addr;
3183   if (!s390_decompose_address (op, &addr))
3184     return false;
3185
3186   return (TARGET_64BIT || addr.pointer);
3187 }
3188
3189 /* Return true if it is valid *and* preferable to use LA to
3190    compute the sum of OP1 and OP2.  */
3191
3192 bool
3193 preferred_la_operand_p (rtx op1, rtx op2)
3194 {
3195   struct s390_address addr;
3196
3197   if (op2 != const0_rtx)
3198     op1 = gen_rtx_PLUS (Pmode, op1, op2);
3199
3200   if (!s390_decompose_address (op1, &addr))
3201     return false;
3202   if (addr.base && !REGNO_OK_FOR_BASE_P (REGNO (addr.base)))
3203     return false;
3204   if (addr.indx && !REGNO_OK_FOR_INDEX_P (REGNO (addr.indx)))
3205     return false;
3206
3207   if (!TARGET_64BIT && !addr.pointer)
3208     return false;
3209
3210   if (addr.pointer)
3211     return true;
3212
3213   if ((addr.base && REG_P (addr.base) && REG_POINTER (addr.base))
3214       || (addr.indx && REG_P (addr.indx) && REG_POINTER (addr.indx)))
3215     return true;
3216
3217   return false;
3218 }
3219
3220 /* Emit a forced load-address operation to load SRC into DST.
3221    This will use the LOAD ADDRESS instruction even in situations
3222    where legitimate_la_operand_p (SRC) returns false.  */
3223
3224 void
3225 s390_load_address (rtx dst, rtx src)
3226 {
3227   if (TARGET_64BIT)
3228     emit_move_insn (dst, src);
3229   else
3230     emit_insn (gen_force_la_31 (dst, src));
3231 }
3232
3233 /* Return a legitimate reference for ORIG (an address) using the
3234    register REG.  If REG is 0, a new pseudo is generated.
3235
3236    There are two types of references that must be handled:
3237
3238    1. Global data references must load the address from the GOT, via
3239       the PIC reg.  An insn is emitted to do this load, and the reg is
3240       returned.
3241
3242    2. Static data references, constant pool addresses, and code labels
3243       compute the address as an offset from the GOT, whose base is in
3244       the PIC reg.  Static data objects have SYMBOL_FLAG_LOCAL set to
3245       differentiate them from global data objects.  The returned
3246       address is the PIC reg + an unspec constant.
3247
3248    TARGET_LEGITIMIZE_ADDRESS_P rejects symbolic references unless the PIC
3249    reg also appears in the address.  */
3250
3251 rtx
3252 legitimize_pic_address (rtx orig, rtx reg)
3253 {
3254   rtx addr = orig;
3255   rtx new_rtx = orig;
3256   rtx base;
3257
3258   gcc_assert (!TLS_SYMBOLIC_CONST (addr));
3259
3260   if (GET_CODE (addr) == LABEL_REF
3261       || (GET_CODE (addr) == SYMBOL_REF && SYMBOL_REF_LOCAL_P (addr)))
3262     {
3263       /* This is a local symbol.  */
3264       if (TARGET_CPU_ZARCH && larl_operand (addr, VOIDmode))
3265         {
3266           /* Access local symbols PC-relative via LARL.
3267              This is the same as in the non-PIC case, so it is
3268              handled automatically ...  */
3269         }
3270       else
3271         {
3272           /* Access local symbols relative to the GOT.  */
3273
3274           rtx temp = reg? reg : gen_reg_rtx (Pmode);
3275
3276           if (reload_in_progress || reload_completed)
3277             df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
3278
3279           addr = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTOFF);
3280           addr = gen_rtx_CONST (Pmode, addr);
3281           addr = force_const_mem (Pmode, addr);
3282           emit_move_insn (temp, addr);
3283
3284           new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp);
3285           if (reg != 0)
3286             {
3287               s390_load_address (reg, new_rtx);
3288               new_rtx = reg;
3289             }
3290         }
3291     }
3292   else if (GET_CODE (addr) == SYMBOL_REF)
3293     {
3294       if (reg == 0)
3295         reg = gen_reg_rtx (Pmode);
3296
3297       if (flag_pic == 1)
3298         {
3299           /* Assume GOT offset < 4k.  This is handled the same way
3300              in both 31- and 64-bit code (@GOT).  */
3301
3302           if (reload_in_progress || reload_completed)
3303             df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
3304
3305           new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOT);
3306           new_rtx = gen_rtx_CONST (Pmode, new_rtx);
3307           new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, new_rtx);
3308           new_rtx = gen_const_mem (Pmode, new_rtx);
3309           emit_move_insn (reg, new_rtx);
3310           new_rtx = reg;
3311         }
3312       else if (TARGET_CPU_ZARCH)
3313         {
3314           /* If the GOT offset might be >= 4k, we determine the position
3315              of the GOT entry via a PC-relative LARL (@GOTENT).  */
3316
3317           rtx temp = reg ? reg : gen_reg_rtx (Pmode);
3318
3319           gcc_assert (REGNO (temp) >= FIRST_PSEUDO_REGISTER
3320                       || REGNO_REG_CLASS (REGNO (temp)) == ADDR_REGS);
3321
3322           new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTENT);
3323           new_rtx = gen_rtx_CONST (Pmode, new_rtx);
3324           emit_move_insn (temp, new_rtx);
3325
3326           new_rtx = gen_const_mem (Pmode, temp);
3327           emit_move_insn (reg, new_rtx);
3328           new_rtx = reg;
3329         }
3330       else
3331         {
3332           /* If the GOT offset might be >= 4k, we have to load it
3333              from the literal pool (@GOT).  */
3334
3335           rtx temp = reg ? reg : gen_reg_rtx (Pmode);
3336
3337           gcc_assert (REGNO (temp) >= FIRST_PSEUDO_REGISTER
3338                       || REGNO_REG_CLASS (REGNO (temp)) == ADDR_REGS);
3339
3340           if (reload_in_progress || reload_completed)
3341             df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
3342
3343           addr = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOT);
3344           addr = gen_rtx_CONST (Pmode, addr);
3345           addr = force_const_mem (Pmode, addr);
3346           emit_move_insn (temp, addr);
3347
3348           new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp);
3349           new_rtx = gen_const_mem (Pmode, new_rtx);
3350           emit_move_insn (reg, new_rtx);
3351           new_rtx = reg;
3352         }
3353     }
3354   else
3355     {
3356       if (GET_CODE (addr) == CONST)
3357         {
3358           addr = XEXP (addr, 0);
3359           if (GET_CODE (addr) == UNSPEC)
3360             {
3361               gcc_assert (XVECLEN (addr, 0) == 1);
3362               switch (XINT (addr, 1))
3363                 {
3364                   /* If someone moved a GOT-relative UNSPEC
3365                      out of the literal pool, force them back in.  */
3366                   case UNSPEC_GOTOFF:
3367                   case UNSPEC_PLTOFF:
3368                     new_rtx = force_const_mem (Pmode, orig);
3369                     break;
3370
3371                   /* @GOT is OK as is if small.  */
3372                   case UNSPEC_GOT:
3373                     if (flag_pic == 2)
3374                       new_rtx = force_const_mem (Pmode, orig);
3375                     break;
3376
3377                   /* @GOTENT is OK as is.  */
3378                   case UNSPEC_GOTENT:
3379                     break;
3380
3381                   /* @PLT is OK as is on 64-bit, must be converted to
3382                      GOT-relative @PLTOFF on 31-bit.  */
3383                   case UNSPEC_PLT:
3384                     if (!TARGET_CPU_ZARCH)
3385                       {
3386                         rtx temp = reg? reg : gen_reg_rtx (Pmode);
3387
3388                         if (reload_in_progress || reload_completed)
3389                           df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
3390
3391                         addr = XVECEXP (addr, 0, 0);
3392                         addr = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr),
3393                                                UNSPEC_PLTOFF);
3394                         addr = gen_rtx_CONST (Pmode, addr);
3395                         addr = force_const_mem (Pmode, addr);
3396                         emit_move_insn (temp, addr);
3397
3398                         new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp);
3399                         if (reg != 0)
3400                           {
3401                             s390_load_address (reg, new_rtx);
3402                             new_rtx = reg;
3403                           }
3404                       }
3405                     break;
3406
3407                   /* Everything else cannot happen.  */
3408                   default:
3409                     gcc_unreachable ();
3410                 }
3411             }
3412           else
3413             gcc_assert (GET_CODE (addr) == PLUS);
3414         }
3415       if (GET_CODE (addr) == PLUS)
3416         {
3417           rtx op0 = XEXP (addr, 0), op1 = XEXP (addr, 1);
3418
3419           gcc_assert (!TLS_SYMBOLIC_CONST (op0));
3420           gcc_assert (!TLS_SYMBOLIC_CONST (op1));
3421
3422           /* Check first to see if this is a constant offset
3423              from a local symbol reference.  */
3424           if ((GET_CODE (op0) == LABEL_REF
3425                 || (GET_CODE (op0) == SYMBOL_REF && SYMBOL_REF_LOCAL_P (op0)))
3426               && GET_CODE (op1) == CONST_INT)
3427             {
3428               if (TARGET_CPU_ZARCH
3429                   && larl_operand (op0, VOIDmode)
3430                   && INTVAL (op1) < (HOST_WIDE_INT)1 << 31
3431                   && INTVAL (op1) >= -((HOST_WIDE_INT)1 << 31))
3432                 {
3433                   if (INTVAL (op1) & 1)
3434                     {
3435                       /* LARL can't handle odd offsets, so emit a
3436                          pair of LARL and LA.  */
3437                       rtx temp = reg? reg : gen_reg_rtx (Pmode);
3438
3439                       if (!DISP_IN_RANGE (INTVAL (op1)))
3440                         {
3441                           HOST_WIDE_INT even = INTVAL (op1) - 1;
3442                           op0 = gen_rtx_PLUS (Pmode, op0, GEN_INT (even));
3443                           op0 = gen_rtx_CONST (Pmode, op0);
3444                           op1 = const1_rtx;
3445                         }
3446
3447                       emit_move_insn (temp, op0);
3448                       new_rtx = gen_rtx_PLUS (Pmode, temp, op1);
3449
3450                       if (reg != 0)
3451                         {
3452                           s390_load_address (reg, new_rtx);
3453                           new_rtx = reg;
3454                         }
3455                     }
3456                   else
3457                     {
3458                       /* If the offset is even, we can just use LARL.
3459                          This will happen automatically.  */
3460                     }
3461                 }
3462               else
3463                 {
3464                   /* Access local symbols relative to the GOT.  */
3465
3466                   rtx temp = reg? reg : gen_reg_rtx (Pmode);
3467
3468                   if (reload_in_progress || reload_completed)
3469                     df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
3470
3471                   addr = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, op0),
3472                                          UNSPEC_GOTOFF);
3473                   addr = gen_rtx_PLUS (Pmode, addr, op1);
3474                   addr = gen_rtx_CONST (Pmode, addr);
3475                   addr = force_const_mem (Pmode, addr);
3476                   emit_move_insn (temp, addr);
3477
3478                   new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp);
3479                   if (reg != 0)
3480                     {
3481                       s390_load_address (reg, new_rtx);
3482                       new_rtx = reg;
3483                     }
3484                 }
3485             }
3486
3487           /* Now, check whether it is a GOT relative symbol plus offset
3488              that was pulled out of the literal pool.  Force it back in.  */
3489
3490           else if (GET_CODE (op0) == UNSPEC
3491                    && GET_CODE (op1) == CONST_INT
3492                    && XINT (op0, 1) == UNSPEC_GOTOFF)
3493             {
3494               gcc_assert (XVECLEN (op0, 0) == 1);
3495
3496               new_rtx = force_const_mem (Pmode, orig);
3497             }
3498
3499           /* Otherwise, compute the sum.  */
3500           else
3501             {
3502               base = legitimize_pic_address (XEXP (addr, 0), reg);
3503               new_rtx  = legitimize_pic_address (XEXP (addr, 1),
3504                                              base == reg ? NULL_RTX : reg);
3505               if (GET_CODE (new_rtx) == CONST_INT)
3506                 new_rtx = plus_constant (base, INTVAL (new_rtx));
3507               else
3508                 {
3509                   if (GET_CODE (new_rtx) == PLUS && CONSTANT_P (XEXP (new_rtx, 1)))
3510                     {
3511                       base = gen_rtx_PLUS (Pmode, base, XEXP (new_rtx, 0));
3512                       new_rtx = XEXP (new_rtx, 1);
3513                     }
3514                   new_rtx = gen_rtx_PLUS (Pmode, base, new_rtx);
3515                 }
3516
3517               if (GET_CODE (new_rtx) == CONST)
3518                 new_rtx = XEXP (new_rtx, 0);
3519               new_rtx = force_operand (new_rtx, 0);
3520             }
3521         }
3522     }
3523   return new_rtx;
3524 }
3525
3526 /* Load the thread pointer into a register.  */
3527
3528 rtx
3529 s390_get_thread_pointer (void)
3530 {
3531   rtx tp = gen_reg_rtx (Pmode);
3532
3533   emit_move_insn (tp, gen_rtx_REG (Pmode, TP_REGNUM));
3534   mark_reg_pointer (tp, BITS_PER_WORD);
3535
3536   return tp;
3537 }
3538
3539 /* Emit a tls call insn. The call target is the SYMBOL_REF stored
3540    in s390_tls_symbol which always refers to __tls_get_offset.
3541    The returned offset is written to RESULT_REG and an USE rtx is
3542    generated for TLS_CALL.  */
3543
3544 static GTY(()) rtx s390_tls_symbol;
3545
3546 static void
3547 s390_emit_tls_call_insn (rtx result_reg, rtx tls_call)
3548 {
3549   rtx insn;
3550
3551   gcc_assert (flag_pic);
3552
3553   if (!s390_tls_symbol)
3554     s390_tls_symbol = gen_rtx_SYMBOL_REF (Pmode, "__tls_get_offset");
3555
3556   insn = s390_emit_call (s390_tls_symbol, tls_call, result_reg,
3557                          gen_rtx_REG (Pmode, RETURN_REGNUM));
3558
3559   use_reg (&CALL_INSN_FUNCTION_USAGE (insn), result_reg);
3560   RTL_CONST_CALL_P (insn) = 1;
3561 }
3562
3563 /* ADDR contains a thread-local SYMBOL_REF.  Generate code to compute
3564    this (thread-local) address.  REG may be used as temporary.  */
3565
3566 static rtx
3567 legitimize_tls_address (rtx addr, rtx reg)
3568 {
3569   rtx new_rtx, tls_call, temp, base, r2, insn;
3570
3571   if (GET_CODE (addr) == SYMBOL_REF)
3572     switch (tls_symbolic_operand (addr))
3573       {
3574       case TLS_MODEL_GLOBAL_DYNAMIC:
3575         start_sequence ();
3576         r2 = gen_rtx_REG (Pmode, 2);
3577         tls_call = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_TLSGD);
3578         new_rtx = gen_rtx_CONST (Pmode, tls_call);
3579         new_rtx = force_const_mem (Pmode, new_rtx);
3580         emit_move_insn (r2, new_rtx);
3581         s390_emit_tls_call_insn (r2, tls_call);
3582         insn = get_insns ();
3583         end_sequence ();
3584
3585         new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_NTPOFF);
3586         temp = gen_reg_rtx (Pmode);
3587         emit_libcall_block (insn, temp, r2, new_rtx);
3588
3589         new_rtx = gen_rtx_PLUS (Pmode, s390_get_thread_pointer (), temp);
3590         if (reg != 0)
3591           {
3592             s390_load_address (reg, new_rtx);
3593             new_rtx = reg;
3594           }
3595         break;
3596
3597       case TLS_MODEL_LOCAL_DYNAMIC:
3598         start_sequence ();
3599         r2 = gen_rtx_REG (Pmode, 2);
3600         tls_call = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx), UNSPEC_TLSLDM);
3601         new_rtx = gen_rtx_CONST (Pmode, tls_call);
3602         new_rtx = force_const_mem (Pmode, new_rtx);
3603         emit_move_insn (r2, new_rtx);
3604         s390_emit_tls_call_insn (r2, tls_call);
3605         insn = get_insns ();
3606         end_sequence ();
3607
3608         new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx), UNSPEC_TLSLDM_NTPOFF);
3609         temp = gen_reg_rtx (Pmode);
3610         emit_libcall_block (insn, temp, r2, new_rtx);
3611
3612         new_rtx = gen_rtx_PLUS (Pmode, s390_get_thread_pointer (), temp);
3613         base = gen_reg_rtx (Pmode);
3614         s390_load_address (base, new_rtx);
3615
3616         new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_DTPOFF);
3617         new_rtx = gen_rtx_CONST (Pmode, new_rtx);
3618         new_rtx = force_const_mem (Pmode, new_rtx);
3619         temp = gen_reg_rtx (Pmode);
3620         emit_move_insn (temp, new_rtx);
3621
3622         new_rtx = gen_rtx_PLUS (Pmode, base, temp);
3623         if (reg != 0)
3624           {
3625             s390_load_address (reg, new_rtx);
3626             new_rtx = reg;
3627           }
3628         break;
3629
3630       case TLS_MODEL_INITIAL_EXEC:
3631         if (flag_pic == 1)
3632           {
3633             /* Assume GOT offset < 4k.  This is handled the same way
3634                in both 31- and 64-bit code.  */
3635
3636             if (reload_in_progress || reload_completed)
3637               df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
3638
3639             new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTNTPOFF);
3640             new_rtx = gen_rtx_CONST (Pmode, new_rtx);
3641             new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, new_rtx);
3642             new_rtx = gen_const_mem (Pmode, new_rtx);
3643             temp = gen_reg_rtx (Pmode);
3644             emit_move_insn (temp, new_rtx);
3645           }
3646         else if (TARGET_CPU_ZARCH)
3647           {
3648             /* If the GOT offset might be >= 4k, we determine the position
3649                of the GOT entry via a PC-relative LARL.  */
3650
3651             new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_INDNTPOFF);
3652             new_rtx = gen_rtx_CONST (Pmode, new_rtx);
3653             temp = gen_reg_rtx (Pmode);
3654             emit_move_insn (temp, new_rtx);
3655
3656             new_rtx = gen_const_mem (Pmode, temp);
3657             temp = gen_reg_rtx (Pmode);
3658             emit_move_insn (temp, new_rtx);
3659           }
3660         else if (flag_pic)
3661           {
3662             /* If the GOT offset might be >= 4k, we have to load it
3663                from the literal pool.  */
3664
3665             if (reload_in_progress || reload_completed)
3666               df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
3667
3668             new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTNTPOFF);
3669             new_rtx = gen_rtx_CONST (Pmode, new_rtx);
3670             new_rtx = force_const_mem (Pmode, new_rtx);
3671             temp = gen_reg_rtx (Pmode);
3672             emit_move_insn (temp, new_rtx);
3673
3674             new_rtx = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp);
3675             new_rtx = gen_const_mem (Pmode, new_rtx);
3676
3677             new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (2, new_rtx, addr), UNSPEC_TLS_LOAD);
3678             temp = gen_reg_rtx (Pmode);
3679             emit_insn (gen_rtx_SET (Pmode, temp, new_rtx));
3680           }
3681         else
3682           {
3683             /* In position-dependent code, load the absolute address of
3684                the GOT entry from the literal pool.  */
3685
3686             new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_INDNTPOFF);
3687             new_rtx = gen_rtx_CONST (Pmode, new_rtx);
3688             new_rtx = force_const_mem (Pmode, new_rtx);
3689             temp = gen_reg_rtx (Pmode);
3690             emit_move_insn (temp, new_rtx);
3691
3692             new_rtx = temp;
3693             new_rtx = gen_const_mem (Pmode, new_rtx);
3694             new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (2, new_rtx, addr), UNSPEC_TLS_LOAD);
3695             temp = gen_reg_rtx (Pmode);
3696             emit_insn (gen_rtx_SET (Pmode, temp, new_rtx));
3697           }
3698
3699         new_rtx = gen_rtx_PLUS (Pmode, s390_get_thread_pointer (), temp);
3700         if (reg != 0)
3701           {
3702             s390_load_address (reg, new_rtx);
3703             new_rtx = reg;
3704           }
3705         break;
3706
3707       case TLS_MODEL_LOCAL_EXEC:
3708         new_rtx = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_NTPOFF);
3709         new_rtx = gen_rtx_CONST (Pmode, new_rtx);
3710         new_rtx = force_const_mem (Pmode, new_rtx);
3711         temp = gen_reg_rtx (Pmode);
3712         emit_move_insn (temp, new_rtx);
3713
3714         new_rtx = gen_rtx_PLUS (Pmode, s390_get_thread_pointer (), temp);
3715         if (reg != 0)
3716           {
3717             s390_load_address (reg, new_rtx);
3718             new_rtx = reg;
3719           }
3720         break;
3721
3722       default:
3723         gcc_unreachable ();
3724       }
3725
3726   else if (GET_CODE (addr) == CONST && GET_CODE (XEXP (addr, 0)) == UNSPEC)
3727     {
3728       switch (XINT (XEXP (addr, 0), 1))
3729         {
3730         case UNSPEC_INDNTPOFF:
3731           gcc_assert (TARGET_CPU_ZARCH);
3732           new_rtx = addr;
3733           break;
3734
3735         default:
3736           gcc_unreachable ();
3737         }
3738     }
3739
3740   else if (GET_CODE (addr) == CONST && GET_CODE (XEXP (addr, 0)) == PLUS
3741            && GET_CODE (XEXP (XEXP (addr, 0), 1)) == CONST_INT)
3742     {
3743       new_rtx = XEXP (XEXP (addr, 0), 0);
3744       if (GET_CODE (new_rtx) != SYMBOL_REF)
3745         new_rtx = gen_rtx_CONST (Pmode, new_rtx);
3746
3747       new_rtx = legitimize_tls_address (new_rtx, reg);
3748       new_rtx = plus_constant (new_rtx, INTVAL (XEXP (XEXP (addr, 0), 1)));
3749       new_rtx = force_operand (new_rtx, 0);
3750     }
3751
3752   else
3753     gcc_unreachable ();  /* for now ... */
3754
3755   return new_rtx;
3756 }
3757
3758 /* Emit insns making the address in operands[1] valid for a standard
3759    move to operands[0].  operands[1] is replaced by an address which
3760    should be used instead of the former RTX to emit the move
3761    pattern.  */
3762
3763 void
3764 emit_symbolic_move (rtx *operands)
3765 {
3766   rtx temp = !can_create_pseudo_p () ? operands[0] : gen_reg_rtx (Pmode);
3767
3768   if (GET_CODE (operands[0]) == MEM)
3769     operands[1] = force_reg (Pmode, operands[1]);
3770   else if (TLS_SYMBOLIC_CONST (operands[1]))
3771     operands[1] = legitimize_tls_address (operands[1], temp);
3772   else if (flag_pic)
3773     operands[1] = legitimize_pic_address (operands[1], temp);
3774 }
3775
3776 /* Try machine-dependent ways of modifying an illegitimate address X
3777    to be legitimate.  If we find one, return the new, valid address.
3778
3779    OLDX is the address as it was before break_out_memory_refs was called.
3780    In some cases it is useful to look at this to decide what needs to be done.
3781
3782    MODE is the mode of the operand pointed to by X.
3783
3784    When -fpic is used, special handling is needed for symbolic references.
3785    See comments by legitimize_pic_address for details.  */
3786
3787 static rtx
3788 s390_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
3789                          enum machine_mode mode ATTRIBUTE_UNUSED)
3790 {
3791   rtx constant_term = const0_rtx;
3792
3793   if (TLS_SYMBOLIC_CONST (x))
3794     {
3795       x = legitimize_tls_address (x, 0);
3796
3797       if (s390_legitimate_address_p (mode, x, FALSE))
3798         return x;
3799     }
3800   else if (GET_CODE (x) == PLUS
3801            && (TLS_SYMBOLIC_CONST (XEXP (x, 0))
3802                || TLS_SYMBOLIC_CONST (XEXP (x, 1))))
3803     {
3804       return x;
3805     }
3806   else if (flag_pic)
3807     {
3808       if (SYMBOLIC_CONST (x)
3809           || (GET_CODE (x) == PLUS
3810               && (SYMBOLIC_CONST (XEXP (x, 0))
3811                   || SYMBOLIC_CONST (XEXP (x, 1)))))
3812           x = legitimize_pic_address (x, 0);
3813
3814       if (s390_legitimate_address_p (mode, x, FALSE))
3815         return x;
3816     }
3817
3818   x = eliminate_constant_term (x, &constant_term);
3819
3820   /* Optimize loading of large displacements by splitting them
3821      into the multiple of 4K and the rest; this allows the
3822      former to be CSE'd if possible.
3823
3824      Don't do this if the displacement is added to a register
3825      pointing into the stack frame, as the offsets will
3826      change later anyway.  */
3827
3828   if (GET_CODE (constant_term) == CONST_INT
3829       && !TARGET_LONG_DISPLACEMENT
3830       && !DISP_IN_RANGE (INTVAL (constant_term))
3831       && !(REG_P (x) && REGNO_PTR_FRAME_P (REGNO (x))))
3832     {
3833       HOST_WIDE_INT lower = INTVAL (constant_term) & 0xfff;
3834       HOST_WIDE_INT upper = INTVAL (constant_term) ^ lower;
3835
3836       rtx temp = gen_reg_rtx (Pmode);
3837       rtx val  = force_operand (GEN_INT (upper), temp);
3838       if (val != temp)
3839         emit_move_insn (temp, val);
3840
3841       x = gen_rtx_PLUS (Pmode, x, temp);
3842       constant_term = GEN_INT (lower);
3843     }
3844
3845   if (GET_CODE (x) == PLUS)
3846     {
3847       if (GET_CODE (XEXP (x, 0)) == REG)
3848         {
3849           rtx temp = gen_reg_rtx (Pmode);
3850           rtx val  = force_operand (XEXP (x, 1), temp);
3851           if (val != temp)
3852             emit_move_insn (temp, val);
3853
3854           x = gen_rtx_PLUS (Pmode, XEXP (x, 0), temp);
3855         }
3856
3857       else if (GET_CODE (XEXP (x, 1)) == REG)
3858         {
3859           rtx temp = gen_reg_rtx (Pmode);
3860           rtx val  = force_operand (XEXP (x, 0), temp);
3861           if (val != temp)
3862             emit_move_insn (temp, val);
3863
3864           x = gen_rtx_PLUS (Pmode, temp, XEXP (x, 1));
3865         }
3866     }
3867
3868   if (constant_term != const0_rtx)
3869     x = gen_rtx_PLUS (Pmode, x, constant_term);
3870
3871   return x;
3872 }
3873
3874 /* Try a machine-dependent way of reloading an illegitimate address AD
3875    operand.  If we find one, push the reload and and return the new address.
3876
3877    MODE is the mode of the enclosing MEM.  OPNUM is the operand number
3878    and TYPE is the reload type of the current reload.  */
3879
3880 rtx
3881 legitimize_reload_address (rtx ad, enum machine_mode mode ATTRIBUTE_UNUSED,
3882                            int opnum, int type)
3883 {
3884   if (!optimize || TARGET_LONG_DISPLACEMENT)
3885     return NULL_RTX;
3886
3887   if (GET_CODE (ad) == PLUS)
3888     {
3889       rtx tem = simplify_binary_operation (PLUS, Pmode,
3890                                            XEXP (ad, 0), XEXP (ad, 1));
3891       if (tem)
3892         ad = tem;
3893     }
3894
3895   if (GET_CODE (ad) == PLUS
3896       && GET_CODE (XEXP (ad, 0)) == REG
3897       && GET_CODE (XEXP (ad, 1)) == CONST_INT
3898       && !DISP_IN_RANGE (INTVAL (XEXP (ad, 1))))
3899     {
3900       HOST_WIDE_INT lower = INTVAL (XEXP (ad, 1)) & 0xfff;
3901       HOST_WIDE_INT upper = INTVAL (XEXP (ad, 1)) ^ lower;
3902       rtx cst, tem, new_rtx;
3903
3904       cst = GEN_INT (upper);
3905       if (!legitimate_reload_constant_p (cst))
3906         cst = force_const_mem (Pmode, cst);
3907
3908       tem = gen_rtx_PLUS (Pmode, XEXP (ad, 0), cst);
3909       new_rtx = gen_rtx_PLUS (Pmode, tem, GEN_INT (lower));
3910
3911       push_reload (XEXP (tem, 1), 0, &XEXP (tem, 1), 0,
3912                    BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,
3913                    opnum, (enum reload_type) type);
3914       return new_rtx;
3915     }
3916
3917   return NULL_RTX;
3918 }
3919
3920 /* Emit code to move LEN bytes from DST to SRC.  */
3921
3922 void
3923 s390_expand_movmem (rtx dst, rtx src, rtx len)
3924 {
3925   if (GET_CODE (len) == CONST_INT && INTVAL (len) >= 0 && INTVAL (len) <= 256)
3926     {
3927       if (INTVAL (len) > 0)
3928         emit_insn (gen_movmem_short (dst, src, GEN_INT (INTVAL (len) - 1)));
3929     }
3930
3931   else if (TARGET_MVCLE)
3932     {
3933       emit_insn (gen_movmem_long (dst, src, convert_to_mode (Pmode, len, 1)));
3934     }
3935
3936   else
3937     {
3938       rtx dst_addr, src_addr, count, blocks, temp;
3939       rtx loop_start_label = gen_label_rtx ();
3940       rtx loop_end_label = gen_label_rtx ();
3941       rtx end_label = gen_label_rtx ();
3942       enum machine_mode mode;
3943
3944       mode = GET_MODE (len);
3945       if (mode == VOIDmode)
3946         mode = Pmode;
3947
3948       dst_addr = gen_reg_rtx (Pmode);
3949       src_addr = gen_reg_rtx (Pmode);
3950       count = gen_reg_rtx (mode);
3951       blocks = gen_reg_rtx (mode);
3952
3953       convert_move (count, len, 1);
3954       emit_cmp_and_jump_insns (count, const0_rtx,
3955                                EQ, NULL_RTX, mode, 1, end_label);
3956
3957       emit_move_insn (dst_addr, force_operand (XEXP (dst, 0), NULL_RTX));
3958       emit_move_insn (src_addr, force_operand (XEXP (src, 0), NULL_RTX));
3959       dst = change_address (dst, VOIDmode, dst_addr);
3960       src = change_address (src, VOIDmode, src_addr);
3961
3962       temp = expand_binop (mode, add_optab, count, constm1_rtx, count, 1,
3963                            OPTAB_DIRECT);
3964       if (temp != count)
3965         emit_move_insn (count, temp);
3966
3967       temp = expand_binop (mode, lshr_optab, count, GEN_INT (8), blocks, 1,
3968                            OPTAB_DIRECT);
3969       if (temp != blocks)
3970         emit_move_insn (blocks, temp);
3971
3972       emit_cmp_and_jump_insns (blocks, const0_rtx,
3973                                EQ, NULL_RTX, mode, 1, loop_end_label);
3974
3975       emit_label (loop_start_label);
3976
3977       if (TARGET_Z10
3978           && (GET_CODE (len) != CONST_INT || INTVAL (len) > 768))
3979         {
3980           rtx prefetch;
3981
3982           /* Issue a read prefetch for the +3 cache line.  */
3983           prefetch = gen_prefetch (gen_rtx_PLUS (Pmode, src_addr, GEN_INT (768)),
3984                                    const0_rtx, const0_rtx);
3985           PREFETCH_SCHEDULE_BARRIER_P (prefetch) = true;
3986           emit_insn (prefetch);
3987
3988           /* Issue a write prefetch for the +3 cache line.  */
3989           prefetch = gen_prefetch (gen_rtx_PLUS (Pmode, dst_addr, GEN_INT (768)),
3990                                    const1_rtx, const0_rtx);
3991           PREFETCH_SCHEDULE_BARRIER_P (prefetch) = true;
3992           emit_insn (prefetch);
3993         }
3994
3995       emit_insn (gen_movmem_short (dst, src, GEN_INT (255)));
3996       s390_load_address (dst_addr,
3997                          gen_rtx_PLUS (Pmode, dst_addr, GEN_INT (256)));
3998       s390_load_address (src_addr,
3999                          gen_rtx_PLUS (Pmode, src_addr, GEN_INT (256)));
4000
4001       temp = expand_binop (mode, add_optab, blocks, constm1_rtx, blocks, 1,
4002                            OPTAB_DIRECT);
4003       if (temp != blocks)
4004         emit_move_insn (blocks, temp);
4005
4006       emit_cmp_and_jump_insns (blocks, const0_rtx,
4007                                EQ, NULL_RTX, mode, 1, loop_end_label);
4008
4009       emit_jump (loop_start_label);
4010       emit_label (loop_end_label);
4011
4012       emit_insn (gen_movmem_short (dst, src,
4013                                    convert_to_mode (Pmode, count, 1)));
4014       emit_label (end_label);
4015     }
4016 }
4017
4018 /* Emit code to set LEN bytes at DST to VAL.
4019    Make use of clrmem if VAL is zero.  */
4020
4021 void
4022 s390_expand_setmem (rtx dst, rtx len, rtx val)
4023 {
4024   if (GET_CODE (len) == CONST_INT && INTVAL (len) == 0)
4025     return;
4026
4027   gcc_assert (GET_CODE (val) == CONST_INT || GET_MODE (val) == QImode);
4028
4029   if (GET_CODE (len) == CONST_INT && INTVAL (len) > 0 && INTVAL (len) <= 257)
4030     {
4031       if (val == const0_rtx && INTVAL (len) <= 256)
4032         emit_insn (gen_clrmem_short (dst, GEN_INT (INTVAL (len) - 1)));
4033       else
4034         {
4035           /* Initialize memory by storing the first byte.  */
4036           emit_move_insn (adjust_address (dst, QImode, 0), val);
4037
4038           if (INTVAL (len) > 1)
4039             {
4040               /* Initiate 1 byte overlap move.
4041                  The first byte of DST is propagated through DSTP1.
4042                  Prepare a movmem for:  DST+1 = DST (length = LEN - 1).
4043                  DST is set to size 1 so the rest of the memory location
4044                  does not count as source operand.  */
4045               rtx dstp1 = adjust_address (dst, VOIDmode, 1);
4046               set_mem_size (dst, const1_rtx);
4047
4048               emit_insn (gen_movmem_short (dstp1, dst,
4049                                            GEN_INT (INTVAL (len) - 2)));
4050             }
4051         }
4052     }
4053
4054   else if (TARGET_MVCLE)
4055     {
4056       val = force_not_mem (convert_modes (Pmode, QImode, val, 1));
4057       emit_insn (gen_setmem_long (dst, convert_to_mode (Pmode, len, 1), val));
4058     }
4059
4060   else
4061     {
4062       rtx dst_addr, count, blocks, temp, dstp1 = NULL_RTX;
4063       rtx loop_start_label = gen_label_rtx ();
4064       rtx loop_end_label = gen_label_rtx ();
4065       rtx end_label = gen_label_rtx ();
4066       enum machine_mode mode;
4067