OSDN Git Service

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