OSDN Git Service

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