OSDN Git Service

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