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 bool s390_return_in_memory (tree, tree);
  64 static void s390_init_builtins (void);
  65 static rtx s390_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
  66 static void s390_output_mi_thunk (FILE *, tree, HOST_WIDE_INT,
  67                                   HOST_WIDE_INT, tree);
  68 static enum attr_type s390_safe_attr_type (rtx);
  69
  70 static int s390_adjust_cost (rtx, rtx, rtx, int);
  71 static int s390_adjust_priority (rtx, int);
  72 static int s390_issue_rate (void);
  73 static int s390_use_dfa_pipeline_interface (void);
  74 static int s390_first_cycle_multipass_dfa_lookahead (void);
  75 static int s390_sched_reorder2 (FILE *, int, rtx *, int *, int);
  76 static bool s390_rtx_costs (rtx, int, int, int *);
  77 static int s390_address_cost (rtx);
  78 static void s390_reorg (void);
  79 static bool s390_valid_pointer_mode (enum machine_mode);
  80 static tree s390_build_builtin_va_list (void);
  81
  82 #undef  TARGET_ASM_ALIGNED_HI_OP
  83 #define TARGET_ASM_ALIGNED_HI_OP "\t.word\t"
  84 #undef  TARGET_ASM_ALIGNED_DI_OP
  85 #define TARGET_ASM_ALIGNED_DI_OP "\t.quad\t"
  86 #undef  TARGET_ASM_INTEGER
  87 #define TARGET_ASM_INTEGER s390_assemble_integer
  88
  89 #undef  TARGET_ASM_OPEN_PAREN
  90 #define TARGET_ASM_OPEN_PAREN ""
  91
  92 #undef  TARGET_ASM_CLOSE_PAREN
  93 #define TARGET_ASM_CLOSE_PAREN ""
  94
  95 #undef  TARGET_ASM_SELECT_RTX_SECTION
  96 #define TARGET_ASM_SELECT_RTX_SECTION  s390_select_rtx_section
  97
  98 #undef  TARGET_ENCODE_SECTION_INFO
  99 #define TARGET_ENCODE_SECTION_INFO s390_encode_section_info
 100
 101 #ifdef HAVE_AS_TLS
 102 #undef TARGET_HAVE_TLS
 103 #define TARGET_HAVE_TLS true
 104 #endif
 105 #undef TARGET_CANNOT_FORCE_CONST_MEM
 106 #define TARGET_CANNOT_FORCE_CONST_MEM s390_cannot_force_const_mem
 107
 108 #undef TARGET_DELEGITIMIZE_ADDRESS
 109 #define TARGET_DELEGITIMIZE_ADDRESS s390_delegitimize_address
 110
 111 #undef TARGET_RETURN_IN_MEMORY
 112 #define TARGET_RETURN_IN_MEMORY s390_return_in_memory
 113
 114 #undef  TARGET_INIT_BUILTINS
 115 #define TARGET_INIT_BUILTINS s390_init_builtins
 116 #undef  TARGET_EXPAND_BUILTIN
 117 #define TARGET_EXPAND_BUILTIN s390_expand_builtin
 118
 119 #undef TARGET_ASM_OUTPUT_MI_THUNK
 120 #define TARGET_ASM_OUTPUT_MI_THUNK s390_output_mi_thunk
 121 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
 122 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK hook_bool_tree_hwi_hwi_tree_true
 123
 124 #undef  TARGET_SCHED_ADJUST_COST
 125 #define TARGET_SCHED_ADJUST_COST s390_adjust_cost
 126 #undef  TARGET_SCHED_ADJUST_PRIORITY
 127 #define TARGET_SCHED_ADJUST_PRIORITY s390_adjust_priority
 128 #undef TARGET_SCHED_ISSUE_RATE
 129 #define TARGET_SCHED_ISSUE_RATE s390_issue_rate
 130 #undef TARGET_SCHED_USE_DFA_PIPELINE_INTERFACE
 131 #define TARGET_SCHED_USE_DFA_PIPELINE_INTERFACE s390_use_dfa_pipeline_interface
 132 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
 133 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD s390_first_cycle_multipass_dfa_lookahead
 134 #undef TARGET_SCHED_REORDER2
 135 #define TARGET_SCHED_REORDER2 s390_sched_reorder2
 136
 137 #undef TARGET_RTX_COSTS
 138 #define TARGET_RTX_COSTS s390_rtx_costs
 139 #undef TARGET_ADDRESS_COST
 140 #define TARGET_ADDRESS_COST s390_address_cost
 141 #undef TARGET_DIRECT_POOL_LOAD_P
 142 #define TARGET_DIRECT_POOL_LOAD_P hook_bool_machine_mode_true
 143
 144 #undef TARGET_MACHINE_DEPENDENT_REORG
 145 #define TARGET_MACHINE_DEPENDENT_REORG s390_reorg
 146
 147 #undef TARGET_VALID_POINTER_MODE
 148 #define TARGET_VALID_POINTER_MODE s390_valid_pointer_mode
 149
 150 #undef TARGET_BUILD_BUILTIN_VA_LIST
 151 #define TARGET_BUILD_BUILTIN_VA_LIST s390_build_builtin_va_list
 152
 153 struct gcc_target targetm = TARGET_INITIALIZER;
 154
 155 extern int reload_completed;
 156
 157 /* The alias set for prologue/epilogue register save/restore.  */
 158 static int s390_sr_alias_set = 0;
 159
 160 /* Save information from a "cmpxx" operation until the branch or scc is
 161    emitted.  */
 162 rtx s390_compare_op0, s390_compare_op1;
 163
 164 /* Structure used to hold the components of a S/390 memory
 165    address.  A legitimate address on S/390 is of the general
 166    form
 167           base + index + displacement
 168    where any of the components is optional.
 169
 170    base and index are registers of the class ADDR_REGS,
 171    displacement is an unsigned 12-bit immediate constant.  */
 172
 173 struct s390_address
 174 {
 175   rtx base;
 176   rtx indx;
 177   rtx disp;
 178   int pointer;
 179 };
 180
 181 /* Which cpu are we tuning for.  */
 182 enum processor_type s390_tune;
 183 enum processor_flags s390_tune_flags;
 184 /* Which instruction set architecture to use.  */
 185 enum processor_type s390_arch;
 186 enum processor_flags s390_arch_flags;
 187
 188 /* Strings to hold which cpu and instruction set architecture  to use.  */
 189 const char *s390_tune_string;           /* for -mtune=<xxx> */
 190 const char *s390_arch_string;           /* for -march=<xxx> */
 191
 192 /* Define the structure for the machine field in struct function.  */
 193
 194 struct machine_function GTY(())
 195 {
 196   /* Set, if some of the fprs 8-15 need to be saved (64 bit abi).  */
 197   int save_fprs_p;
 198
 199   /* Set if return address needs to be saved.  */
 200   bool save_return_addr_p;
 201
 202   /* Number of first and last gpr to be saved, restored.  */
 203   int first_save_gpr;
 204   int first_restore_gpr;
 205   int last_save_gpr;
 206
 207   /* Size of stack frame.  */
 208   HOST_WIDE_INT frame_size;
 209
 210   /* Some local-dynamic TLS symbol name.  */
 211   const char *some_ld_name;
 212 };
 213
 214 static int s390_match_ccmode_set (rtx, enum machine_mode);
 215 static int s390_branch_condition_mask (rtx);
 216 static const char *s390_branch_condition_mnemonic (rtx, int);
 217 static int check_mode (rtx, enum machine_mode *);
 218 static int general_s_operand (rtx, enum machine_mode, int);
 219 static int s390_short_displacement (rtx);
 220 static int s390_decompose_address (rtx, struct s390_address *);
 221 static rtx get_thread_pointer (void);
 222 static rtx legitimize_tls_address (rtx, rtx);
 223 static void print_shift_count_operand (FILE *, rtx);
 224 static const char *get_some_local_dynamic_name (void);
 225 static int get_some_local_dynamic_name_1 (rtx *, void *);
 226 static int reg_used_in_mem_p (int, rtx);
 227 static int addr_generation_dependency_p (rtx, rtx);
 228 static int s390_split_branches (void);
 229 static void find_constant_pool_ref (rtx, rtx *);
 230 static void replace_constant_pool_ref (rtx *, rtx, rtx);
 231 static rtx find_ltrel_base (rtx);
 232 static void replace_ltrel_base (rtx *, rtx);
 233 static void s390_optimize_prolog (bool);
 234 static int find_unused_clobbered_reg (void);
 235 static void s390_frame_info (void);
 236 static rtx save_fpr (rtx, int, int);
 237 static rtx restore_fpr (rtx, int, int);
 238 static rtx save_gprs (rtx, int, int, int);
 239 static rtx restore_gprs (rtx, int, int, int);
 240 static int s390_function_arg_size (enum machine_mode, tree);
 241 static bool s390_function_arg_float (enum machine_mode, tree);
 242 static struct machine_function * s390_init_machine_status (void);
 243
 244 /* Check whether integer displacement is in range.  */
 245 #define DISP_IN_RANGE(d) \
 246   (TARGET_LONG_DISPLACEMENT? ((d) >= -524288 && (d) <= 524287) \
 247                            : ((d) >= 0 && (d) <= 4095))
 248
 249 /* Return true if SET either doesn't set the CC register, or else
 250    the source and destination have matching CC modes and that
 251    CC mode is at least as constrained as REQ_MODE.  */
 252
 253 static int
 254 s390_match_ccmode_set (rtx set, enum machine_mode req_mode)
 255 {
 256   enum machine_mode set_mode;
 257
 258   if (GET_CODE (set) != SET)
 259     abort ();
 260
 261   if (GET_CODE (SET_DEST (set)) != REG || !CC_REGNO_P (REGNO (SET_DEST (set))))
 262     return 1;
 263
 264   set_mode = GET_MODE (SET_DEST (set));
 265   switch (set_mode)
 266     {
 267     case CCSmode:
 268     case CCSRmode:
 269     case CCUmode:
 270     case CCURmode:
 271     case CCLmode:
 272     case CCL1mode:
 273     case CCL2mode:
 274     case CCT1mode:
 275     case CCT2mode:
 276     case CCT3mode:
 277       if (req_mode != set_mode)
 278         return 0;
 279       break;
 280
 281     case CCZmode:
 282       if (req_mode != CCSmode && req_mode != CCUmode && req_mode != CCTmode
 283           && req_mode != CCSRmode && req_mode != CCURmode)
 284         return 0;
 285       break;
 286
 287     case CCAPmode:
 288     case CCANmode:
 289       if (req_mode != CCAmode)
 290         return 0;
 291       break;
 292
 293     default:
 294       abort ();
 295     }
 296
 297   return (GET_MODE (SET_SRC (set)) == set_mode);
 298 }
 299
 300 /* Return true if every SET in INSN that sets the CC register
 301    has source and destination with matching CC modes and that
 302    CC mode is at least as constrained as REQ_MODE.
 303    If REQ_MODE is VOIDmode, always return false.  */
 304
 305 int
 306 s390_match_ccmode (rtx insn, enum machine_mode req_mode)
 307 {
 308   int i;
 309
 310   /* s390_tm_ccmode returns VOIDmode to indicate failure.  */
 311   if (req_mode == VOIDmode)
 312     return 0;
 313
 314   if (GET_CODE (PATTERN (insn)) == SET)
 315     return s390_match_ccmode_set (PATTERN (insn), req_mode);
 316
 317   if (GET_CODE (PATTERN (insn)) == PARALLEL)
 318       for (i = 0; i < XVECLEN (PATTERN (insn), 0); i++)
 319         {
 320           rtx set = XVECEXP (PATTERN (insn), 0, i);
 321           if (GET_CODE (set) == SET)
 322             if (!s390_match_ccmode_set (set, req_mode))
 323               return 0;
 324         }
 325
 326   return 1;
 327 }
 328
 329 /* If a test-under-mask instruction can be used to implement
 330    (compare (and ... OP1) OP2), return the CC mode required
 331    to do that.  Otherwise, return VOIDmode.
 332    MIXED is true if the instruction can distinguish between
 333    CC1 and CC2 for mixed selected bits (TMxx), it is false
 334    if the instruction cannot (TM).  */
 335
 336 enum machine_mode
 337 s390_tm_ccmode (rtx op1, rtx op2, int mixed)
 338 {
 339   int bit0, bit1;
 340
 341   /* ??? Fixme: should work on CONST_DOUBLE as well.  */
 342   if (GET_CODE (op1) != CONST_INT || GET_CODE (op2) != CONST_INT)
 343     return VOIDmode;
 344
 345   /* Selected bits all zero: CC0.  */
 346   if (INTVAL (op2) == 0)
 347     return CCTmode;
 348
 349   /* Selected bits all one: CC3.  */
 350   if (INTVAL (op2) == INTVAL (op1))
 351     return CCT3mode;
 352
 353   /* Exactly two bits selected, mixed zeroes and ones: CC1 or CC2.  */
 354   if (mixed)
 355     {
 356       bit1 = exact_log2 (INTVAL (op2));
 357       bit0 = exact_log2 (INTVAL (op1) ^ INTVAL (op2));
 358       if (bit0 != -1 && bit1 != -1)
 359         return bit0 > bit1 ? CCT1mode : CCT2mode;
 360     }
 361
 362   return VOIDmode;
 363 }
 364
 365 /* Given a comparison code OP (EQ, NE, etc.) and the operands
 366    OP0 and OP1 of a COMPARE, return the mode to be used for the
 367    comparison.  */
 368
 369 enum machine_mode
 370 s390_select_ccmode (enum rtx_code code, rtx op0, rtx op1)
 371 {
 372   switch (code)
 373     {
 374       case EQ:
 375       case NE:
 376         if (GET_CODE (op0) == PLUS && GET_CODE (XEXP (op0, 1)) == CONST_INT
 377             && CONST_OK_FOR_CONSTRAINT_P (INTVAL (XEXP (op0, 1)), 'K', "K"))
 378           return CCAPmode;
 379         if ((GET_CODE (op0) == PLUS || GET_CODE (op0) == MINUS
 380              || GET_CODE (op1) == NEG)
 381             && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT)
 382           return CCLmode;
 383
 384         if (GET_CODE (op0) == AND)
 385           {
 386             /* Check whether we can potentially do it via TM.  */
 387             enum machine_mode ccmode;
 388             ccmode = s390_tm_ccmode (XEXP (op0, 1), op1, 1);
 389             if (ccmode != VOIDmode)
 390               {
 391                 /* Relax CCTmode to CCZmode to allow fall-back to AND
 392                    if that turns out to be beneficial.  */
 393                 return ccmode == CCTmode ? CCZmode : ccmode;
 394               }
 395           }
 396
 397         if (register_operand (op0, HImode)
 398             && GET_CODE (op1) == CONST_INT
 399             && (INTVAL (op1) == -1 || INTVAL (op1) == 65535))
 400           return CCT3mode;
 401         if (register_operand (op0, QImode)
 402             && GET_CODE (op1) == CONST_INT
 403             && (INTVAL (op1) == -1 || INTVAL (op1) == 255))
 404           return CCT3mode;
 405
 406         return CCZmode;
 407
 408       case LE:
 409       case LT:
 410       case GE:
 411       case GT:
 412           if (GET_CODE (op0) == PLUS && GET_CODE (XEXP (op0, 1)) == CONST_INT
 413               && CONST_OK_FOR_CONSTRAINT_P (INTVAL (XEXP (op0, 1)), 'K', "K"))
 414             {
 415               if (INTVAL (XEXP((op0), 1)) < 0)
 416                 return CCANmode;
 417               else
 418                 return CCAPmode;
 419             }
 420       case UNORDERED:
 421       case ORDERED:
 422       case UNEQ:
 423       case UNLE:
 424       case UNLT:
 425       case UNGE:
 426       case UNGT:
 427       case LTGT:
 428         if ((GET_CODE (op0) == SIGN_EXTEND || GET_CODE (op0) == ZERO_EXTEND)
 429             && GET_CODE (op1) != CONST_INT)
 430           return CCSRmode;
 431         return CCSmode;
 432
 433       case LTU:
 434       case GEU:
 435         if (GET_CODE (op0) == PLUS
 436             && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT)
 437           return CCL1mode;
 438
 439         if ((GET_CODE (op0) == SIGN_EXTEND || GET_CODE (op0) == ZERO_EXTEND)
 440             && GET_CODE (op1) != CONST_INT)
 441           return CCURmode;
 442         return CCUmode;
 443
 444       case LEU:
 445       case GTU:
 446         if (GET_CODE (op0) == MINUS
 447             && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT)
 448           return CCL2mode;
 449
 450         if ((GET_CODE (op0) == SIGN_EXTEND || GET_CODE (op0) == ZERO_EXTEND)
 451             && GET_CODE (op1) != CONST_INT)
 452           return CCURmode;
 453         return CCUmode;
 454
 455       default:
 456         abort ();
 457     }
 458 }
 459
 460 /* Return nonzero if OP is a valid comparison operator
 461    for an ALC condition in mode MODE.  */
 462
 463 int
 464 s390_alc_comparison (rtx op, enum machine_mode mode)
 465 {
 466   if (mode != VOIDmode && mode != GET_MODE (op))
 467     return 0;
 468
 469   if (GET_RTX_CLASS (GET_CODE (op)) != '<')
 470     return 0;
 471
 472   if (GET_CODE (XEXP (op, 0)) != REG
 473       || REGNO (XEXP (op, 0)) != CC_REGNUM
 474       || XEXP (op, 1) != const0_rtx)
 475     return 0;
 476
 477   switch (GET_MODE (XEXP (op, 0)))
 478     {
 479     case CCL1mode:
 480       return GET_CODE (op) == LTU;
 481
 482     case CCL2mode:
 483       return GET_CODE (op) == LEU;
 484
 485     case CCUmode:
 486       return GET_CODE (op) == GTU;
 487
 488     case CCURmode:
 489       return GET_CODE (op) == LTU;
 490
 491     case CCSmode:
 492       return GET_CODE (op) == UNGT;
 493
 494     case CCSRmode:
 495       return GET_CODE (op) == UNLT;
 496
 497     default:
 498       return 0;
 499     }
 500 }
 501
 502 /* Return nonzero if OP is a valid comparison operator
 503    for an SLB condition in mode MODE.  */
 504
 505 int
 506 s390_slb_comparison (rtx op, enum machine_mode mode)
 507 {
 508   if (mode != VOIDmode && mode != GET_MODE (op))
 509     return 0;
 510
 511   if (GET_RTX_CLASS (GET_CODE (op)) != '<')
 512     return 0;
 513
 514   if (GET_CODE (XEXP (op, 0)) != REG
 515       || REGNO (XEXP (op, 0)) != CC_REGNUM
 516       || XEXP (op, 1) != const0_rtx)
 517     return 0;
 518
 519   switch (GET_MODE (XEXP (op, 0)))
 520     {
 521     case CCL1mode:
 522       return GET_CODE (op) == GEU;
 523
 524     case CCL2mode:
 525       return GET_CODE (op) == GTU;
 526
 527     case CCUmode:
 528       return GET_CODE (op) == LEU;
 529
 530     case CCURmode:
 531       return GET_CODE (op) == GEU;
 532
 533     case CCSmode:
 534       return GET_CODE (op) == LE;
 535
 536     case CCSRmode:
 537       return GET_CODE (op) == GE;
 538
 539     default:
 540       return 0;
 541     }
 542 }
 543
 544 /* Return branch condition mask to implement a branch
 545    specified by CODE.  */
 546
 547 static int
 548 s390_branch_condition_mask (rtx code)
 549 {
 550   const int CC0 = 1 << 3;
 551   const int CC1 = 1 << 2;
 552   const int CC2 = 1 << 1;
 553   const int CC3 = 1 << 0;
 554
 555   if (GET_CODE (XEXP (code, 0)) != REG
 556       || REGNO (XEXP (code, 0)) != CC_REGNUM
 557       || XEXP (code, 1) != const0_rtx)
 558     abort ();
 559
 560   switch (GET_MODE (XEXP (code, 0)))
 561     {
 562     case CCZmode:
 563       switch (GET_CODE (code))
 564         {
 565         case EQ:        return CC0;
 566         case NE:        return CC1 | CC2 | CC3;
 567         default:
 568           abort ();
 569         }
 570       break;
 571
 572     case CCT1mode:
 573       switch (GET_CODE (code))
 574         {
 575         case EQ:        return CC1;
 576         case NE:        return CC0 | CC2 | CC3;
 577         default:
 578           abort ();
 579         }
 580       break;
 581
 582     case CCT2mode:
 583       switch (GET_CODE (code))
 584         {
 585         case EQ:        return CC2;
 586         case NE:        return CC0 | CC1 | CC3;
 587         default:
 588           abort ();
 589         }
 590       break;
 591
 592     case CCT3mode:
 593       switch (GET_CODE (code))
 594         {
 595         case EQ:        return CC3;
 596         case NE:        return CC0 | CC1 | CC2;
 597         default:
 598           abort ();
 599         }
 600       break;
 601
 602     case CCLmode:
 603       switch (GET_CODE (code))
 604         {
 605         case EQ:        return CC0 | CC2;
 606         case NE:        return CC1 | CC3;
 607         default:
 608           abort ();
 609         }
 610       break;
 611
 612     case CCL1mode:
 613       switch (GET_CODE (code))
 614         {
 615         case LTU:       return CC2 | CC3;  /* carry */
 616         case GEU:       return CC0 | CC1;  /* no carry */
 617         default:
 618           abort ();
 619         }
 620       break;
 621
 622     case CCL2mode:
 623       switch (GET_CODE (code))
 624         {
 625         case GTU:       return CC0 | CC1;  /* borrow */
 626         case LEU:       return CC2 | CC3;  /* no borrow */
 627         default:
 628           abort ();
 629         }
 630       break;
 631
 632     case CCUmode:
 633       switch (GET_CODE (code))
 634         {
 635         case EQ:        return CC0;
 636         case NE:        return CC1 | CC2 | CC3;
 637         case LTU:       return CC1;
 638         case GTU:       return CC2;
 639         case LEU:       return CC0 | CC1;
 640         case GEU:       return CC0 | CC2;
 641         default:
 642           abort ();
 643         }
 644       break;
 645
 646     case CCURmode:
 647       switch (GET_CODE (code))
 648         {
 649         case EQ:        return CC0;
 650         case NE:        return CC2 | CC1 | CC3;
 651         case LTU:       return CC2;
 652         case GTU:       return CC1;
 653         case LEU:       return CC0 | CC2;
 654         case GEU:       return CC0 | CC1;
 655         default:
 656           abort ();
 657         }
 658       break;
 659
 660     case CCAPmode:
 661       switch (GET_CODE (code))
 662         {
 663         case EQ:        return CC0;
 664         case NE:        return CC1 | CC2 | CC3;
 665         case LT:        return CC1 | CC3;
 666         case GT:        return CC2;
 667         case LE:        return CC0 | CC1 | CC3;
 668         case GE:        return CC0 | CC2;
 669         default:
 670           abort ();
 671         }
 672       break;
 673
 674     case CCANmode:
 675       switch (GET_CODE (code))
 676         {
 677         case EQ:        return CC0;
 678         case NE:        return CC1 | CC2 | CC3;
 679         case LT:        return CC1;
 680         case GT:        return CC2 | CC3;
 681         case LE:        return CC0 | CC1;
 682         case GE:        return CC0 | CC2 | CC3;
 683         default:
 684           abort ();
 685         }
 686       break;
 687
 688     case CCSmode:
 689       switch (GET_CODE (code))
 690         {
 691         case EQ:        return CC0;
 692         case NE:        return CC1 | CC2 | CC3;
 693         case LT:        return CC1;
 694         case GT:        return CC2;
 695         case LE:        return CC0 | CC1;
 696         case GE:        return CC0 | CC2;
 697         case UNORDERED: return CC3;
 698         case ORDERED:   return CC0 | CC1 | CC2;
 699         case UNEQ:      return CC0 | CC3;
 700         case UNLT:      return CC1 | CC3;
 701         case UNGT:      return CC2 | CC3;
 702         case UNLE:      return CC0 | CC1 | CC3;
 703         case UNGE:      return CC0 | CC2 | CC3;
 704         case LTGT:      return CC1 | CC2;
 705         default:
 706           abort ();
 707         }
 708       break;
 709
 710     case CCSRmode:
 711       switch (GET_CODE (code))
 712         {
 713         case EQ:        return CC0;
 714         case NE:        return CC2 | CC1 | CC3;
 715         case LT:        return CC2;
 716         case GT:        return CC1;
 717         case LE:        return CC0 | CC2;
 718         case GE:        return CC0 | CC1;
 719         case UNORDERED: return CC3;
 720         case ORDERED:   return CC0 | CC2 | CC1;
 721         case UNEQ:      return CC0 | CC3;
 722         case UNLT:      return CC2 | CC3;
 723         case UNGT:      return CC1 | CC3;
 724         case UNLE:      return CC0 | CC2 | CC3;
 725         case UNGE:      return CC0 | CC1 | CC3;
 726         case LTGT:      return CC2 | CC1;
 727         default:
 728           abort ();
 729         }
 730       break;
 731
 732     default:
 733       abort ();
 734     }
 735 }
 736
 737 /* If INV is false, return assembler mnemonic string to implement
 738    a branch specified by CODE.  If INV is true, return mnemonic
 739    for the corresponding inverted branch.  */
 740
 741 static const char *
 742 s390_branch_condition_mnemonic (rtx code, int inv)
 743 {
 744   static const char *const mnemonic[16] =
 745     {
 746       NULL, "o", "h", "nle",
 747       "l", "nhe", "lh", "ne",
 748       "e", "nlh", "he", "nl",
 749       "le", "nh", "no", NULL
 750     };
 751
 752   int mask = s390_branch_condition_mask (code);
 753
 754   if (inv)
 755     mask ^= 15;
 756
 757   if (mask < 1 || mask > 14)
 758     abort ();
 759
 760   return mnemonic[mask];
 761 }
 762
 763 /* Return the part of op which has a value different from def.
 764    The size of the part is determined by mode.
 765    Use this function only if you already know that op really
 766    contains such a part.  */
 767
 768 unsigned HOST_WIDE_INT
 769 s390_extract_part (rtx op, enum machine_mode mode, int def)
 770 {
 771   unsigned HOST_WIDE_INT value = 0;
 772   int max_parts = HOST_BITS_PER_WIDE_INT / GET_MODE_BITSIZE (mode);
 773   int part_bits = GET_MODE_BITSIZE (mode);
 774   unsigned HOST_WIDE_INT part_mask = (1 << part_bits) - 1;
 775   int i;
 776
 777   for (i = 0; i < max_parts; i++)
 778     {
 779       if (i == 0)
 780         value = (unsigned HOST_WIDE_INT) INTVAL (op);
 781       else
 782         value >>= part_bits;
 783
 784       if ((value & part_mask) != (def & part_mask))
 785         return value & part_mask;
 786     }
 787
 788   abort ();
 789 }
 790
 791 /* If OP is an integer constant of mode MODE with exactly one
 792    part of mode PART_MODE unequal to DEF, return the number of that
 793    part. Otherwise, return -1.  */
 794
 795 int
 796 s390_single_part (rtx op,
 797                   enum machine_mode mode,
 798                   enum machine_mode part_mode,
 799                   int def)
 800 {
 801   unsigned HOST_WIDE_INT value = 0;
 802   int n_parts = GET_MODE_SIZE (mode) / GET_MODE_SIZE (part_mode);
 803   unsigned HOST_WIDE_INT part_mask = (1 << GET_MODE_BITSIZE (part_mode)) - 1;
 804   int i, part = -1;
 805
 806   if (GET_CODE (op) != CONST_INT)
 807     return -1;
 808
 809   for (i = 0; i < n_parts; i++)
 810     {
 811       if (i == 0)
 812         value = (unsigned HOST_WIDE_INT) INTVAL (op);
 813       else
 814         value >>= GET_MODE_BITSIZE (part_mode);
 815
 816       if ((value & part_mask) != (def & part_mask))
 817         {
 818           if (part != -1)
 819             return -1;
 820           else
 821             part = i;
 822         }
 823     }
 824   return part == -1 ? -1 : n_parts - 1 - part;
 825 }
 826
 827 /* Check whether we can (and want to) split a double-word
 828    move in mode MODE from SRC to DST into two single-word
 829    moves, moving the subword FIRST_SUBWORD first.  */
 830
 831 bool
 832 s390_split_ok_p (rtx dst, rtx src, enum machine_mode mode, int first_subword)
 833 {
 834   /* Floating point registers cannot be split.  */
 835   if (FP_REG_P (src) || FP_REG_P (dst))
 836     return false;
 837
 838   /* We don't need to split if operands are directly accessible.  */
 839   if (s_operand (src, mode) || s_operand (dst, mode))
 840     return false;
 841
 842   /* Non-offsettable memory references cannot be split.  */
 843   if ((GET_CODE (src) == MEM && !offsettable_memref_p (src))
 844       || (GET_CODE (dst) == MEM && !offsettable_memref_p (dst)))
 845     return false;
 846
 847   /* Moving the first subword must not clobber a register
 848      needed to move the second subword.  */
 849   if (register_operand (dst, mode))
 850     {
 851       rtx subreg = operand_subword (dst, first_subword, 0, mode);
 852       if (reg_overlap_mentioned_p (subreg, src))
 853         return false;
 854     }
 855
 856   return true;
 857 }
 858
 859
 860 /* Change optimizations to be performed, depending on the
 861    optimization level.
 862
 863    LEVEL is the optimization level specified; 2 if `-O2' is
 864    specified, 1 if `-O' is specified, and 0 if neither is specified.
 865
 866    SIZE is nonzero if `-Os' is specified and zero otherwise.  */
 867
 868 void
 869 optimization_options (int level ATTRIBUTE_UNUSED, int size ATTRIBUTE_UNUSED)
 870 {
 871   /* ??? There are apparently still problems with -fcaller-saves.  */
 872   flag_caller_saves = 0;
 873
 874   /* By default, always emit DWARF-2 unwind info.  This allows debugging
 875      without maintaining a stack frame back-chain.  */
 876   flag_asynchronous_unwind_tables = 1;
 877 }
 878
 879 void
 880 override_options (void)
 881 {
 882   int i;
 883   static struct pta
 884     {
 885       const char *const name;           /* processor name or nickname.  */
 886       const enum processor_type processor;
 887       const enum processor_flags flags;
 888     }
 889   const processor_alias_table[] =
 890     {
 891       {"g5", PROCESSOR_9672_G5, PF_IEEE_FLOAT},
 892       {"g6", PROCESSOR_9672_G6, PF_IEEE_FLOAT},
 893       {"z900", PROCESSOR_2064_Z900, PF_IEEE_FLOAT | PF_ZARCH},
 894       {"z990", PROCESSOR_2084_Z990, PF_IEEE_FLOAT | PF_ZARCH
 895                                     | PF_LONG_DISPLACEMENT},
 896     };
 897
 898   int const pta_size = ARRAY_SIZE (processor_alias_table);
 899
 900   /* Acquire a unique set number for our register saves and restores.  */
 901   s390_sr_alias_set = new_alias_set ();
 902
 903   /* Set up function hooks.  */
 904   init_machine_status = s390_init_machine_status;
 905
 906   /* Architecture mode defaults according to ABI.  */
 907   if (!(target_flags_explicit & MASK_ZARCH))
 908     {
 909       if (TARGET_64BIT)
 910         target_flags |= MASK_ZARCH;
 911       else
 912         target_flags &= ~MASK_ZARCH;
 913     }
 914
 915   /* Determine processor architectural level.  */
 916   if (!s390_arch_string)
 917     s390_arch_string = TARGET_ZARCH? "z900" : "g5";
 918
 919   for (i = 0; i < pta_size; i++)
 920     if (! strcmp (s390_arch_string, processor_alias_table[i].name))
 921       {
 922         s390_arch = processor_alias_table[i].processor;
 923         s390_arch_flags = processor_alias_table[i].flags;
 924         break;
 925       }
 926   if (i == pta_size)
 927     error ("Unknown cpu used in -march=%s.", s390_arch_string);
 928
 929   /* Determine processor to tune for.  */
 930   if (!s390_tune_string)
 931     {
 932       s390_tune = s390_arch;
 933       s390_tune_flags = s390_arch_flags;
 934       s390_tune_string = s390_arch_string;
 935     }
 936   else
 937     {
 938       for (i = 0; i < pta_size; i++)
 939         if (! strcmp (s390_tune_string, processor_alias_table[i].name))
 940           {
 941             s390_tune = processor_alias_table[i].processor;
 942             s390_tune_flags = processor_alias_table[i].flags;
 943             break;
 944           }
 945       if (i == pta_size)
 946         error ("Unknown cpu used in -mtune=%s.", s390_tune_string);
 947     }
 948
 949   /* Sanity checks.  */
 950   if (TARGET_ZARCH && !(s390_arch_flags & PF_ZARCH))
 951     error ("z/Architecture mode not supported on %s.", s390_arch_string);
 952   if (TARGET_64BIT && !TARGET_ZARCH)
 953     error ("64-bit ABI not supported in ESA/390 mode.");
 954 }
 955
 956 /* Map for smallest class containing reg regno.  */
 957
 958 const enum reg_class regclass_map[FIRST_PSEUDO_REGISTER] =
 959 { GENERAL_REGS, ADDR_REGS, ADDR_REGS, ADDR_REGS,
 960   ADDR_REGS,    ADDR_REGS, ADDR_REGS, ADDR_REGS,
 961   ADDR_REGS,    ADDR_REGS, ADDR_REGS, ADDR_REGS,
 962   ADDR_REGS,    ADDR_REGS, ADDR_REGS, ADDR_REGS,
 963   FP_REGS,      FP_REGS,   FP_REGS,   FP_REGS,
 964   FP_REGS,      FP_REGS,   FP_REGS,   FP_REGS,
 965   FP_REGS,      FP_REGS,   FP_REGS,   FP_REGS,
 966   FP_REGS,      FP_REGS,   FP_REGS,   FP_REGS,
 967   ADDR_REGS,    NO_REGS,   ADDR_REGS
 968 };
 969
 970 /* Return attribute type of insn.  */
 971
 972 static enum attr_type
 973 s390_safe_attr_type (rtx insn)
 974 {
 975   if (recog_memoized (insn) >= 0)
 976     return get_attr_type (insn);
 977   else
 978     return TYPE_NONE;
 979 }
 980
 981 /* Return true if OP a (const_int 0) operand.
 982    OP is the current operation.
 983    MODE is the current operation mode.  */
 984
 985 int
 986 const0_operand (register rtx op, enum machine_mode mode)
 987 {
 988   return op == CONST0_RTX (mode);
 989 }
 990
 991 /* Return true if OP is constant.
 992    OP is the current operation.
 993    MODE is the current operation mode.  */
 994
 995 int
 996 consttable_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
 997 {
 998   return CONSTANT_P (op);
 999 }
1000
1001 /* Return true if the mode of operand OP matches MODE.
1002    If MODE is set to VOIDmode, set it to the mode of OP.  */
1003
1004 static int
1005 check_mode (register rtx op, enum machine_mode *mode)
1006 {
1007   if (*mode == VOIDmode)
1008       *mode = GET_MODE (op);
1009   else
1010   {
1011     if (GET_MODE (op) != VOIDmode && GET_MODE (op) != *mode)
1012        return 0;
1013   }
1014   return 1;
1015 }
1016
1017 /* Return true if OP a valid operand for the LARL instruction.
1018    OP is the current operation.
1019    MODE is the current operation mode.  */
1020
1021 int
1022 larl_operand (register rtx op, enum machine_mode mode)
1023 {
1024   if (! check_mode (op, &mode))
1025     return 0;
1026
1027   /* Allow labels and local symbols.  */
1028   if (GET_CODE (op) == LABEL_REF)
1029     return 1;
1030   if (GET_CODE (op) == SYMBOL_REF)
1031     return ((SYMBOL_REF_FLAGS (op) & SYMBOL_FLAG_ALIGN1) == 0
1032             && SYMBOL_REF_TLS_MODEL (op) == 0
1033             && (!flag_pic || SYMBOL_REF_LOCAL_P (op)));
1034
1035   /* Everything else must have a CONST, so strip it.  */
1036   if (GET_CODE (op) != CONST)
1037     return 0;
1038   op = XEXP (op, 0);
1039
1040   /* Allow adding *even* in-range constants.  */
1041   if (GET_CODE (op) == PLUS)
1042     {
1043       if (GET_CODE (XEXP (op, 1)) != CONST_INT
1044           || (INTVAL (XEXP (op, 1)) & 1) != 0)
1045         return 0;
1046 #if HOST_BITS_PER_WIDE_INT > 32
1047       if (INTVAL (XEXP (op, 1)) >= (HOST_WIDE_INT)1 << 32
1048           || INTVAL (XEXP (op, 1)) < -((HOST_WIDE_INT)1 << 32))
1049         return 0;
1050 #endif
1051       op = XEXP (op, 0);
1052     }
1053
1054   /* Labels and local symbols allowed here as well.  */
1055   if (GET_CODE (op) == LABEL_REF)
1056     return 1;
1057   if (GET_CODE (op) == SYMBOL_REF)
1058     return ((SYMBOL_REF_FLAGS (op) & SYMBOL_FLAG_ALIGN1) == 0
1059             && SYMBOL_REF_TLS_MODEL (op) == 0
1060             && (!flag_pic || SYMBOL_REF_LOCAL_P (op)));
1061
1062   /* Now we must have a @GOTENT offset or @PLT stub
1063      or an @INDNTPOFF TLS offset.  */
1064   if (GET_CODE (op) == UNSPEC
1065       && XINT (op, 1) == UNSPEC_GOTENT)
1066     return 1;
1067   if (GET_CODE (op) == UNSPEC
1068       && XINT (op, 1) == UNSPEC_PLT)
1069     return 1;
1070   if (GET_CODE (op) == UNSPEC
1071       && XINT (op, 1) == UNSPEC_INDNTPOFF)
1072     return 1;
1073
1074   return 0;
1075 }
1076
1077 /* Helper routine to implement s_operand and s_imm_operand.
1078    OP is the current operation.
1079    MODE is the current operation mode.
1080    ALLOW_IMMEDIATE specifies whether immediate operands should
1081    be accepted or not.  */
1082
1083 static int
1084 general_s_operand (register rtx op, enum machine_mode mode,
1085                    int allow_immediate)
1086 {
1087   struct s390_address addr;
1088
1089   /* Call general_operand first, so that we don't have to
1090      check for many special cases.  */
1091   if (!general_operand (op, mode))
1092     return 0;
1093
1094   /* Just like memory_operand, allow (subreg (mem ...))
1095      after reload.  */
1096   if (reload_completed
1097       && GET_CODE (op) == SUBREG
1098       && GET_CODE (SUBREG_REG (op)) == MEM)
1099     op = SUBREG_REG (op);
1100
1101   switch (GET_CODE (op))
1102     {
1103       /* Constants are OK as s-operand if ALLOW_IMMEDIATE
1104          is true and we are still before reload.  */
1105       case CONST_INT:
1106       case CONST_DOUBLE:
1107         if (!allow_immediate || reload_completed)
1108           return 0;
1109         return 1;
1110
1111       /* Memory operands are OK unless they already use an
1112          index register.  */
1113       case MEM:
1114         if (GET_CODE (XEXP (op, 0)) == ADDRESSOF)
1115           return 1;
1116         if (!s390_decompose_address (XEXP (op, 0), &addr))
1117           return 0;
1118         if (addr.indx)
1119           return 0;
1120         /* Do not allow literal pool references unless ALLOW_IMMEDIATE
1121            is true.  This prevents compares between two literal pool
1122            entries from being accepted.  */
1123         if (!allow_immediate
1124             && addr.base && REGNO (addr.base) == BASE_REGISTER)
1125           return 0;
1126         return 1;
1127
1128       default:
1129         break;
1130     }
1131
1132   return 0;
1133 }
1134
1135 /* Return true if OP is a valid S-type operand.
1136    OP is the current operation.
1137    MODE is the current operation mode.  */
1138
1139 int
1140 s_operand (register rtx op, enum machine_mode mode)
1141 {
1142   return general_s_operand (op, mode, 0);
1143 }
1144
1145 /* Return true if OP is a valid S-type operand or an immediate
1146    operand that can be addressed as S-type operand by forcing
1147    it into the literal pool.
1148    OP is the current operation.
1149    MODE is the current operation mode.  */
1150
1151 int
1152 s_imm_operand (register rtx op, enum machine_mode mode)
1153 {
1154   return general_s_operand (op, mode, 1);
1155 }
1156
1157 /* Return true if OP a valid shift count operand.
1158    OP is the current operation.
1159    MODE is the current operation mode.  */
1160
1161 int
1162 shift_count_operand (rtx op, enum machine_mode mode)
1163 {
1164   HOST_WIDE_INT offset = 0;
1165
1166   if (! check_mode (op, &mode))
1167     return 0;
1168
1169   /* We can have an integer constant, an address register,
1170      or a sum of the two.  Note that reload already checks
1171      that any register present is an address register, so
1172      we just check for any register here.  */
1173   if (GET_CODE (op) == CONST_INT)
1174     {
1175       offset = INTVAL (op);
1176       op = NULL_RTX;
1177     }
1178   if (op && GET_CODE (op) == PLUS && GET_CODE (XEXP (op, 1)) == CONST_INT)
1179     {
1180       offset = INTVAL (XEXP (op, 1));
1181       op = XEXP (op, 0);
1182     }
1183   while (op && GET_CODE (op) == SUBREG)
1184     op = SUBREG_REG (op);
1185   if (op && GET_CODE (op) != REG)
1186     return 0;
1187
1188   /* Unfortunately we have to reject constants that are invalid
1189      for an address, or else reload will get confused.  */
1190   if (!DISP_IN_RANGE (offset))
1191     return 0;
1192
1193   return 1;
1194 }
1195
1196 /* Return true if DISP is a valid short displacement.  */
1197
1198 static int
1199 s390_short_displacement (rtx disp)
1200 {
1201   /* No displacement is OK.  */
1202   if (!disp)
1203     return 1;
1204
1205   /* Integer displacement in range.  */
1206   if (GET_CODE (disp) == CONST_INT)
1207     return INTVAL (disp) >= 0 && INTVAL (disp) < 4096;
1208
1209   /* GOT offset is not OK, the GOT can be large.  */
1210   if (GET_CODE (disp) == CONST
1211       && GET_CODE (XEXP (disp, 0)) == UNSPEC
1212       && XINT (XEXP (disp, 0), 1) == UNSPEC_GOT)
1213     return 0;
1214
1215   /* All other symbolic constants are literal pool references,
1216      which are OK as the literal pool must be small.  */
1217   if (GET_CODE (disp) == CONST)
1218     return 1;
1219
1220   return 0;
1221 }
1222
1223 /* Return true if OP is a valid operand for a C constraint.  */
1224
1225 int
1226 s390_extra_constraint_str (rtx op, int c, const char * str)
1227 {
1228   struct s390_address addr;
1229
1230   if (c != str[0])
1231     abort ();
1232
1233   switch (c)
1234     {
1235     case 'Q':
1236       if (GET_CODE (op) != MEM)
1237         return 0;
1238       if (!s390_decompose_address (XEXP (op, 0), &addr))
1239         return 0;
1240       if (addr.indx)
1241         return 0;
1242
1243       if (TARGET_LONG_DISPLACEMENT)
1244         {
1245           if (!s390_short_displacement (addr.disp))
1246             return 0;
1247         }
1248       break;
1249
1250     case 'R':
1251       if (GET_CODE (op) != MEM)
1252         return 0;
1253
1254       if (TARGET_LONG_DISPLACEMENT)
1255         {
1256           if (!s390_decompose_address (XEXP (op, 0), &addr))
1257             return 0;
1258           if (!s390_short_displacement (addr.disp))
1259             return 0;
1260         }
1261       break;
1262
1263     case 'S':
1264       if (!TARGET_LONG_DISPLACEMENT)
1265         return 0;
1266       if (GET_CODE (op) != MEM)
1267         return 0;
1268       if (!s390_decompose_address (XEXP (op, 0), &addr))
1269         return 0;
1270       if (addr.indx)
1271         return 0;
1272       if (s390_short_displacement (addr.disp))
1273         return 0;
1274       break;
1275
1276     case 'T':
1277       if (!TARGET_LONG_DISPLACEMENT)
1278         return 0;
1279       if (GET_CODE (op) != MEM)
1280         return 0;
1281       /* Any invalid address here will be fixed up by reload,
1282          so accept it for the most generic constraint.  */
1283       if (s390_decompose_address (XEXP (op, 0), &addr)
1284           && s390_short_displacement (addr.disp))
1285         return 0;
1286       break;
1287
1288     case 'U':
1289       if (TARGET_LONG_DISPLACEMENT)
1290         {
1291           if (!s390_decompose_address (op, &addr))
1292             return 0;
1293           if (!s390_short_displacement (addr.disp))
1294             return 0;
1295         }
1296       break;
1297
1298     case 'W':
1299       if (!TARGET_LONG_DISPLACEMENT)
1300         return 0;
1301       /* Any invalid address here will be fixed up by reload,
1302          so accept it for the most generic constraint.  */
1303       if (s390_decompose_address (op, &addr)
1304           && s390_short_displacement (addr.disp))
1305         return 0;
1306       break;
1307
1308     case 'Y':
1309       return shift_count_operand (op, VOIDmode);
1310
1311     default:
1312       return 0;
1313     }
1314
1315   return 1;
1316 }
1317
1318 /* Return true if VALUE matches the constraint STR.  */
1319
1320 int
1321 s390_const_ok_for_constraint_p (HOST_WIDE_INT value,
1322                                 int c,
1323                                 const char * str)
1324 {
1325   enum machine_mode mode, part_mode;
1326   int def;
1327   unsigned char part;
1328
1329   if (c != str[0])
1330     abort ();
1331
1332   switch (str[0])
1333     {
1334     case 'I':
1335       return (unsigned int)value < 256;
1336
1337     case 'J':
1338       return (unsigned int)value < 4096;
1339
1340     case 'K':
1341       return value >= -32768 && value < 32768;
1342
1343     case 'L':
1344       return (TARGET_LONG_DISPLACEMENT ?
1345               (value >= -524288 && value <= 524287)
1346               : (value >= 0 && value <= 4095));
1347     case 'M':
1348       return value == 2147483647;
1349
1350     case 'N':
1351       part = str[1] - '0';
1352
1353       switch (str[2])
1354         {
1355         case 'H': part_mode = HImode; break;
1356         case 'Q': part_mode = QImode; break;
1357         default:  return 0;
1358         }
1359
1360       switch (str[3])
1361         {
1362         case 'H': mode = HImode; break;
1363         case 'S': mode = SImode; break;
1364         case 'D': mode = DImode; break;
1365         default: return 0;
1366         }
1367
1368       switch (str[4])
1369         {
1370         case '0': def = 0;  break;
1371         case 'F': def = -1; break;
1372         default: return 0;
1373         }
1374
1375       if (GET_MODE_SIZE (mode) <= GET_MODE_SIZE (part_mode))
1376         return 0;
1377
1378       if (s390_single_part (GEN_INT (value), mode, part_mode, def) != part)
1379         return 0;
1380
1381       break;
1382
1383     default:
1384       return 0;
1385     }
1386
1387   return 1;
1388 }
1389
1390 /* Compute a (partial) cost for rtx X.  Return true if the complete
1391    cost has been computed, and false if subexpressions should be
1392    scanned.  In either case, *TOTAL contains the cost result.  */
1393
1394 static bool
1395 s390_rtx_costs (rtx x, int code, int outer_code, int *total)
1396 {
1397   switch (code)
1398     {
1399     case CONST:
1400       if (GET_CODE (XEXP (x, 0)) == MINUS
1401           && GET_CODE (XEXP (XEXP (x, 0), 1)) != CONST_INT)
1402         *total = 1000;
1403       else
1404         *total = 0;
1405       return true;
1406
1407     case CONST_INT:
1408       /* Force_const_mem does not work out of reload, because the
1409          saveable_obstack is set to reload_obstack, which does not
1410          live long enough.  Because of this we cannot use force_const_mem
1411          in addsi3.  This leads to problems with gen_add2_insn with a
1412          constant greater than a short. Because of that we give an
1413          addition of greater constants a cost of 3 (reload1.c 10096).  */
1414       /* ??? saveable_obstack no longer exists.  */
1415       if (outer_code == PLUS
1416           && (INTVAL (x) > 32767 || INTVAL (x) < -32768))
1417         *total = COSTS_N_INSNS (3);
1418       else
1419         *total = 0;
1420       return true;
1421
1422     case LABEL_REF:
1423     case SYMBOL_REF:
1424     case CONST_DOUBLE:
1425       *total = 0;
1426       return true;
1427
1428     case ASHIFT:
1429     case ASHIFTRT:
1430     case LSHIFTRT:
1431     case PLUS:
1432     case AND:
1433     case IOR:
1434     case XOR:
1435     case MINUS:
1436     case NEG:
1437     case NOT:
1438       *total = COSTS_N_INSNS (1);
1439       return true;
1440
1441     case MULT:
1442       if (GET_MODE (XEXP (x, 0)) == DImode)
1443         *total = COSTS_N_INSNS (40);
1444       else
1445         *total = COSTS_N_INSNS (7);
1446       return true;
1447
1448     case DIV:
1449     case UDIV:
1450     case MOD:
1451     case UMOD:
1452       *total = COSTS_N_INSNS (33);
1453       return true;
1454
1455     default:
1456       return false;
1457     }
1458 }
1459
1460 /* Return the cost of an address rtx ADDR.  */
1461
1462 static int
1463 s390_address_cost (rtx addr)
1464 {
1465   struct s390_address ad;
1466   if (!s390_decompose_address (addr, &ad))
1467     return 1000;
1468
1469   return ad.indx? COSTS_N_INSNS (1) + 1 : COSTS_N_INSNS (1);
1470 }
1471
1472 /* Return true if OP is a valid operand for the BRAS instruction.
1473    OP is the current operation.
1474    MODE is the current operation mode.  */
1475
1476 int
1477 bras_sym_operand (register rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1478 {
1479   register enum rtx_code code = GET_CODE (op);
1480
1481   /* Allow SYMBOL_REFs.  */
1482   if (code == SYMBOL_REF)
1483     return 1;
1484
1485   /* Allow @PLT stubs.  */
1486   if (code == CONST
1487       && GET_CODE (XEXP (op, 0)) == UNSPEC
1488       && XINT (XEXP (op, 0), 1) == UNSPEC_PLT)
1489     return 1;
1490   return 0;
1491 }
1492
1493 /* If OP is a SYMBOL_REF of a thread-local symbol, return its TLS mode,
1494    otherwise return 0.  */
1495
1496 int
1497 tls_symbolic_operand (register rtx op)
1498 {
1499   if (GET_CODE (op) != SYMBOL_REF)
1500     return 0;
1501   return SYMBOL_REF_TLS_MODEL (op);
1502 }
1503 \f
1504 /* Return true if OP is a load multiple operation.  It is known to be a
1505    PARALLEL and the first section will be tested.
1506    OP is the current operation.
1507    MODE is the current operation mode.  */
1508
1509 int
1510 load_multiple_operation (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1511 {
1512   enum machine_mode elt_mode;
1513   int count = XVECLEN (op, 0);
1514   unsigned int dest_regno;
1515   rtx src_addr;
1516   int i, off;
1517
1518
1519   /* Perform a quick check so we don't blow up below.  */
1520   if (count <= 1
1521       || GET_CODE (XVECEXP (op, 0, 0)) != SET
1522       || GET_CODE (SET_DEST (XVECEXP (op, 0, 0))) != REG
1523       || GET_CODE (SET_SRC (XVECEXP (op, 0, 0))) != MEM)
1524     return 0;
1525
1526   dest_regno = REGNO (SET_DEST (XVECEXP (op, 0, 0)));
1527   src_addr = XEXP (SET_SRC (XVECEXP (op, 0, 0)), 0);
1528   elt_mode = GET_MODE (SET_DEST (XVECEXP (op, 0, 0)));
1529
1530   /* Check, is base, or base + displacement.  */
1531
1532   if (GET_CODE (src_addr) == REG)
1533     off = 0;
1534   else if (GET_CODE (src_addr) == PLUS
1535            && GET_CODE (XEXP (src_addr, 0)) == REG
1536            && GET_CODE (XEXP (src_addr, 1)) == CONST_INT)
1537     {
1538       off = INTVAL (XEXP (src_addr, 1));
1539       src_addr = XEXP (src_addr, 0);
1540     }
1541   else
1542     return 0;
1543
1544   if (src_addr == frame_pointer_rtx || src_addr == arg_pointer_rtx)
1545     return 0;
1546
1547   for (i = 1; i < count; i++)
1548     {
1549       rtx elt = XVECEXP (op, 0, i);
1550
1551       if (GET_CODE (elt) != SET
1552           || GET_CODE (SET_DEST (elt)) != REG
1553           || GET_MODE (SET_DEST (elt)) != elt_mode
1554           || REGNO (SET_DEST (elt)) != dest_regno + i
1555           || GET_CODE (SET_SRC (elt)) != MEM
1556           || GET_MODE (SET_SRC (elt)) != elt_mode
1557           || GET_CODE (XEXP (SET_SRC (elt), 0)) != PLUS
1558           || ! rtx_equal_p (XEXP (XEXP (SET_SRC (elt), 0), 0), src_addr)
1559           || GET_CODE (XEXP (XEXP (SET_SRC (elt), 0), 1)) != CONST_INT
1560           || INTVAL (XEXP (XEXP (SET_SRC (elt), 0), 1))
1561              != off + i * GET_MODE_SIZE (elt_mode))
1562         return 0;
1563     }
1564
1565   return 1;
1566 }
1567
1568 /* Return true if OP is a store multiple operation.  It is known to be a
1569    PARALLEL and the first section will be tested.
1570    OP is the current operation.
1571    MODE is the current operation mode.  */
1572
1573 int
1574 store_multiple_operation (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1575 {
1576   enum machine_mode elt_mode;
1577   int count = XVECLEN (op, 0);
1578   unsigned int src_regno;
1579   rtx dest_addr;
1580   int i, off;
1581
1582   /* Perform a quick check so we don't blow up below.  */
1583   if (count <= 1
1584       || GET_CODE (XVECEXP (op, 0, 0)) != SET
1585       || GET_CODE (SET_DEST (XVECEXP (op, 0, 0))) != MEM
1586       || GET_CODE (SET_SRC (XVECEXP (op, 0, 0))) != REG)
1587     return 0;
1588
1589   src_regno = REGNO (SET_SRC (XVECEXP (op, 0, 0)));
1590   dest_addr = XEXP (SET_DEST (XVECEXP (op, 0, 0)), 0);
1591   elt_mode = GET_MODE (SET_SRC (XVECEXP (op, 0, 0)));
1592
1593   /* Check, is base, or base + displacement.  */
1594
1595   if (GET_CODE (dest_addr) == REG)
1596     off = 0;
1597   else if (GET_CODE (dest_addr) == PLUS
1598            && GET_CODE (XEXP (dest_addr, 0)) == REG
1599            && GET_CODE (XEXP (dest_addr, 1)) == CONST_INT)
1600     {
1601       off = INTVAL (XEXP (dest_addr, 1));
1602       dest_addr = XEXP (dest_addr, 0);
1603     }
1604   else
1605     return 0;
1606
1607   if (dest_addr == frame_pointer_rtx || dest_addr == arg_pointer_rtx)
1608     return 0;
1609
1610   for (i = 1; i < count; i++)
1611     {
1612       rtx elt = XVECEXP (op, 0, i);
1613
1614       if (GET_CODE (elt) != SET
1615           || GET_CODE (SET_SRC (elt)) != REG
1616           || GET_MODE (SET_SRC (elt)) != elt_mode
1617           || REGNO (SET_SRC (elt)) != src_regno + i
1618           || GET_CODE (SET_DEST (elt)) != MEM
1619           || GET_MODE (SET_DEST (elt)) != elt_mode
1620           || GET_CODE (XEXP (SET_DEST (elt), 0)) != PLUS
1621           || ! rtx_equal_p (XEXP (XEXP (SET_DEST (elt), 0), 0), dest_addr)
1622           || GET_CODE (XEXP (XEXP (SET_DEST (elt), 0), 1)) != CONST_INT
1623           || INTVAL (XEXP (XEXP (SET_DEST (elt), 0), 1))
1624              != off + i * GET_MODE_SIZE (elt_mode))
1625         return 0;
1626     }
1627   return 1;
1628 }
1629
1630
1631 /* Return true if OP contains a symbol reference */
1632
1633 int
1634 symbolic_reference_mentioned_p (rtx op)
1635 {
1636   register const char *fmt;
1637   register int i;
1638
1639   if (GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == LABEL_REF)
1640     return 1;
1641
1642   fmt = GET_RTX_FORMAT (GET_CODE (op));
1643   for (i = GET_RTX_LENGTH (GET_CODE (op)) - 1; i >= 0; i--)
1644     {
1645       if (fmt[i] == 'E')
1646         {
1647           register int j;
1648
1649           for (j = XVECLEN (op, i) - 1; j >= 0; j--)
1650             if (symbolic_reference_mentioned_p (XVECEXP (op, i, j)))
1651               return 1;
1652         }
1653
1654       else if (fmt[i] == 'e' && symbolic_reference_mentioned_p (XEXP (op, i)))
1655         return 1;
1656     }
1657
1658   return 0;
1659 }
1660
1661 /* Return true if OP contains a reference to a thread-local symbol.  */
1662
1663 int
1664 tls_symbolic_reference_mentioned_p (rtx op)
1665 {
1666   register const char *fmt;
1667   register int i;
1668
1669   if (GET_CODE (op) == SYMBOL_REF)
1670     return tls_symbolic_operand (op);
1671
1672   fmt = GET_RTX_FORMAT (GET_CODE (op));
1673   for (i = GET_RTX_LENGTH (GET_CODE (op)) - 1; i >= 0; i--)
1674     {
1675       if (fmt[i] == 'E')
1676         {
1677           register int j;
1678
1679           for (j = XVECLEN (op, i) - 1; j >= 0; j--)
1680             if (tls_symbolic_reference_mentioned_p (XVECEXP (op, i, j)))
1681               return 1;
1682         }
1683
1684       else if (fmt[i] == 'e' && tls_symbolic_reference_mentioned_p (XEXP (op, i)))
1685         return 1;
1686     }
1687
1688   return 0;
1689 }
1690
1691
1692 /* Return true if OP is a legitimate general operand when
1693    generating PIC code.  It is given that flag_pic is on
1694    and that OP satisfies CONSTANT_P or is a CONST_DOUBLE.  */
1695
1696 int
1697 legitimate_pic_operand_p (register rtx op)
1698 {
1699   /* Accept all non-symbolic constants.  */
1700   if (!SYMBOLIC_CONST (op))
1701     return 1;
1702
1703   /* Reject everything else; must be handled
1704      via emit_symbolic_move.  */
1705   return 0;
1706 }
1707
1708 /* Returns true if the constant value OP is a legitimate general operand.
1709    It is given that OP satisfies CONSTANT_P or is a CONST_DOUBLE.  */
1710
1711 int
1712 legitimate_constant_p (register rtx op)
1713 {
1714   /* Accept all non-symbolic constants.  */
1715   if (!SYMBOLIC_CONST (op))
1716     return 1;
1717
1718   /* Accept immediate LARL operands.  */
1719   if (TARGET_CPU_ZARCH && larl_operand (op, VOIDmode))
1720     return 1;
1721
1722   /* Thread-local symbols are never legal constants.  This is
1723      so that emit_call knows that computing such addresses
1724      might require a function call.  */
1725   if (TLS_SYMBOLIC_CONST (op))
1726     return 0;
1727
1728   /* In the PIC case, symbolic constants must *not* be
1729      forced into the literal pool.  We accept them here,
1730      so that they will be handled by emit_symbolic_move.  */
1731   if (flag_pic)
1732     return 1;
1733
1734   /* All remaining non-PIC symbolic constants are
1735      forced into the literal pool.  */
1736   return 0;
1737 }
1738
1739 /* Determine if it's legal to put X into the constant pool.  This
1740    is not possible if X contains the address of a symbol that is
1741    not constant (TLS) or not known at final link time (PIC).  */
1742
1743 static bool
1744 s390_cannot_force_const_mem (rtx x)
1745 {
1746   switch (GET_CODE (x))
1747     {
1748     case CONST_INT:
1749     case CONST_DOUBLE:
1750       /* Accept all non-symbolic constants.  */
1751       return false;
1752
1753     case LABEL_REF:
1754       /* Labels are OK iff we are non-PIC.  */
1755       return flag_pic != 0;
1756
1757     case SYMBOL_REF:
1758       /* 'Naked' TLS symbol references are never OK,
1759          non-TLS symbols are OK iff we are non-PIC.  */
1760       if (tls_symbolic_operand (x))
1761         return true;
1762       else
1763         return flag_pic != 0;
1764
1765     case CONST:
1766       return s390_cannot_force_const_mem (XEXP (x, 0));
1767     case PLUS:
1768     case MINUS:
1769       return s390_cannot_force_const_mem (XEXP (x, 0))
1770              || s390_cannot_force_const_mem (XEXP (x, 1));
1771
1772     case UNSPEC:
1773       switch (XINT (x, 1))
1774         {
1775         /* Only lt-relative or GOT-relative UNSPECs are OK.  */
1776         case UNSPEC_LTREL_OFFSET:
1777         case UNSPEC_GOT:
1778         case UNSPEC_GOTOFF:
1779         case UNSPEC_PLTOFF:
1780         case UNSPEC_TLSGD:
1781         case UNSPEC_TLSLDM:
1782         case UNSPEC_NTPOFF:
1783         case UNSPEC_DTPOFF:
1784         case UNSPEC_GOTNTPOFF:
1785         case UNSPEC_INDNTPOFF:
1786           return false;
1787
1788         default:
1789           return true;
1790         }
1791       break;
1792
1793     default:
1794       abort ();
1795     }
1796 }
1797
1798 /* Returns true if the constant value OP is a legitimate general
1799    operand during and after reload.  The difference to
1800    legitimate_constant_p is that this function will not accept
1801    a constant that would need to be forced to the literal pool
1802    before it can be used as operand.  */
1803
1804 int
1805 legitimate_reload_constant_p (register rtx op)
1806 {
1807   /* Accept la(y) operands.  */
1808   if (GET_CODE (op) == CONST_INT
1809       && DISP_IN_RANGE (INTVAL (op)))
1810     return 1;
1811
1812   /* Accept l(g)hi operands.  */
1813   if (GET_CODE (op) == CONST_INT
1814       && CONST_OK_FOR_CONSTRAINT_P (INTVAL (op), 'K', "K"))
1815     return 1;
1816
1817   /* Accept lliXX operands.  */
1818   if (TARGET_ZARCH
1819       && s390_single_part (op, DImode, HImode, 0) >= 0)
1820   return 1;
1821
1822   /* Accept larl operands.  */
1823   if (TARGET_CPU_ZARCH
1824       && larl_operand (op, VOIDmode))
1825     return 1;
1826
1827   /* Everything else cannot be handled without reload.  */
1828   return 0;
1829 }
1830
1831 /* Given an rtx OP being reloaded into a reg required to be in class CLASS,
1832    return the class of reg to actually use.  */
1833
1834 enum reg_class
1835 s390_preferred_reload_class (rtx op, enum reg_class class)
1836 {
1837   /* This can happen if a floating point constant is being
1838      reloaded into an integer register.  Leave well alone.  */
1839   if (GET_MODE_CLASS (GET_MODE (op)) == MODE_FLOAT
1840       && class != FP_REGS)
1841     return class;
1842
1843   switch (GET_CODE (op))
1844     {
1845       /* Constants we cannot reload must be forced into the
1846          literal pool.  */
1847
1848       case CONST_DOUBLE:
1849       case CONST_INT:
1850         if (legitimate_reload_constant_p (op))
1851           return class;
1852         else
1853           return NO_REGS;
1854
1855       /* If a symbolic constant or a PLUS is reloaded,
1856          it is most likely being used as an address, so
1857          prefer ADDR_REGS.  If 'class' is not a superset
1858          of ADDR_REGS, e.g. FP_REGS, reject this reload.  */
1859       case PLUS:
1860       case LABEL_REF:
1861       case SYMBOL_REF:
1862       case CONST:
1863         if (reg_class_subset_p (ADDR_REGS, class))
1864           return ADDR_REGS;
1865         else
1866           return NO_REGS;
1867
1868       default:
1869         break;
1870     }
1871
1872   return class;
1873 }
1874
1875 /* Return the register class of a scratch register needed to
1876    load IN into a register of class CLASS in MODE.
1877
1878    We need a temporary when loading a PLUS expression which
1879    is not a legitimate operand of the LOAD ADDRESS instruction.  */
1880
1881 enum reg_class
1882 s390_secondary_input_reload_class (enum reg_class class ATTRIBUTE_UNUSED,
1883                                    enum machine_mode mode, rtx in)
1884 {
1885   if (s390_plus_operand (in, mode))
1886     return ADDR_REGS;
1887
1888   return NO_REGS;
1889 }
1890
1891 /* Return the register class of a scratch register needed to
1892    store a register of class CLASS in MODE into OUT:
1893
1894    We need a temporary when storing a double-word to a
1895    non-offsettable memory address.  */
1896
1897 enum reg_class
1898 s390_secondary_output_reload_class (enum reg_class class,
1899                                     enum machine_mode mode, rtx out)
1900 {
1901   if ((TARGET_64BIT ? mode == TImode
1902                     : (mode == DImode || mode == DFmode))
1903       && reg_classes_intersect_p (GENERAL_REGS, class)
1904       && GET_CODE (out) == MEM
1905       && !offsettable_memref_p (out)
1906       && !s_operand (out, VOIDmode))
1907     return ADDR_REGS;
1908
1909   return NO_REGS;
1910 }
1911
1912 /* Return true if OP is a PLUS that is not a legitimate
1913    operand for the LA instruction.
1914    OP is the current operation.
1915    MODE is the current operation mode.  */
1916
1917 int
1918 s390_plus_operand (register rtx op, enum machine_mode mode)
1919 {
1920   if (!check_mode (op, &mode) || mode != Pmode)
1921     return FALSE;
1922
1923   if (GET_CODE (op) != PLUS)
1924     return FALSE;
1925
1926   if (legitimate_la_operand_p (op))
1927     return FALSE;
1928
1929   return TRUE;
1930 }
1931
1932 /* Generate code to load SRC, which is PLUS that is not a
1933    legitimate operand for the LA instruction, into TARGET.
1934    SCRATCH may be used as scratch register.  */
1935
1936 void
1937 s390_expand_plus_operand (register rtx target, register rtx src,
1938                           register rtx scratch)
1939 {
1940   rtx sum1, sum2;
1941   struct s390_address ad;
1942
1943   /* src must be a PLUS; get its two operands.  */
1944   if (GET_CODE (src) != PLUS || GET_MODE (src) != Pmode)
1945     abort ();
1946
1947   /* Check if any of the two operands is already scheduled
1948      for replacement by reload.  This can happen e.g. when
1949      float registers occur in an address.  */
1950   sum1 = find_replacement (&XEXP (src, 0));
1951   sum2 = find_replacement (&XEXP (src, 1));
1952   src = gen_rtx_PLUS (Pmode, sum1, sum2);
1953
1954   /* If the address is already strictly valid, there's nothing to do.  */
1955   if (!s390_decompose_address (src, &ad)
1956       || (ad.base && !REG_OK_FOR_BASE_STRICT_P (ad.base))
1957       || (ad.indx && !REG_OK_FOR_INDEX_STRICT_P (ad.indx)))
1958     {
1959       /* Otherwise, one of the operands cannot be an address register;
1960          we reload its value into the scratch register.  */
1961       if (true_regnum (sum1) < 1 || true_regnum (sum1) > 15)
1962         {
1963           emit_move_insn (scratch, sum1);
1964           sum1 = scratch;
1965         }
1966       if (true_regnum (sum2) < 1 || true_regnum (sum2) > 15)
1967         {
1968           emit_move_insn (scratch, sum2);
1969           sum2 = scratch;
1970         }
1971
1972       /* According to the way these invalid addresses are generated
1973          in reload.c, it should never happen (at least on s390) that
1974          *neither* of the PLUS components, after find_replacements
1975          was applied, is an address register.  */
1976       if (sum1 == scratch && sum2 == scratch)
1977         {
1978           debug_rtx (src);
1979           abort ();
1980         }
1981
1982       src = gen_rtx_PLUS (Pmode, sum1, sum2);
1983     }
1984
1985   /* Emit the LOAD ADDRESS pattern.  Note that reload of PLUS
1986      is only ever performed on addresses, so we can mark the
1987      sum as legitimate for LA in any case.  */
1988   s390_load_address (target, src);
1989 }
1990
1991
1992 /* Decompose a RTL expression ADDR for a memory address into
1993    its components, returned in OUT.
1994
1995    Returns 0 if ADDR is not a valid memory address, nonzero
1996    otherwise.  If OUT is NULL, don't return the components,
1997    but check for validity only.
1998
1999    Note: Only addresses in canonical form are recognized.
2000    LEGITIMIZE_ADDRESS should convert non-canonical forms to the
2001    canonical form so that they will be recognized.  */
2002
2003 static int
2004 s390_decompose_address (register rtx addr, struct s390_address *out)
2005 {
2006   rtx base = NULL_RTX;
2007   rtx indx = NULL_RTX;
2008   rtx disp = NULL_RTX;
2009   int pointer = FALSE;
2010   int base_ptr = FALSE;
2011   int indx_ptr = FALSE;
2012
2013   /* Decompose address into base + index + displacement.  */
2014
2015   if (GET_CODE (addr) == REG || GET_CODE (addr) == UNSPEC)
2016     base = addr;
2017
2018   else if (GET_CODE (addr) == PLUS)
2019     {
2020       rtx op0 = XEXP (addr, 0);
2021       rtx op1 = XEXP (addr, 1);
2022       enum rtx_code code0 = GET_CODE (op0);
2023       enum rtx_code code1 = GET_CODE (op1);
2024
2025       if (code0 == REG || code0 == UNSPEC)
2026         {
2027           if (code1 == REG || code1 == UNSPEC)
2028             {
2029               indx = op0;       /* index + base */
2030               base = op1;
2031             }
2032
2033           else
2034             {
2035               base = op0;       /* base + displacement */
2036               disp = op1;
2037             }
2038         }
2039
2040       else if (code0 == PLUS)
2041         {
2042           indx = XEXP (op0, 0); /* index + base + disp */
2043           base = XEXP (op0, 1);
2044           disp = op1;
2045         }
2046
2047       else
2048         {
2049           return FALSE;
2050         }
2051     }
2052
2053   else
2054     disp = addr;                /* displacement */
2055
2056
2057   /* Validate base register.  */
2058   if (base)
2059     {
2060       if (GET_CODE (base) == UNSPEC)
2061         {
2062           if (XVECLEN (base, 0) != 1 || XINT (base, 1) != UNSPEC_LTREL_BASE)
2063             return FALSE;
2064           base = gen_rtx_REG (Pmode, BASE_REGISTER);
2065         }
2066
2067       if (GET_CODE (base) != REG || GET_MODE (base) != Pmode)
2068         return FALSE;
2069
2070       if (REGNO (base) == BASE_REGISTER
2071           || REGNO (base) == STACK_POINTER_REGNUM
2072           || REGNO (base) == FRAME_POINTER_REGNUM
2073           || ((reload_completed || reload_in_progress)
2074               && frame_pointer_needed
2075               && REGNO (base) == HARD_FRAME_POINTER_REGNUM)
2076           || REGNO (base) == ARG_POINTER_REGNUM
2077           || (REGNO (base) >= FIRST_VIRTUAL_REGISTER
2078               && REGNO (base) <= LAST_VIRTUAL_REGISTER)
2079           || (flag_pic
2080               && REGNO (base) == PIC_OFFSET_TABLE_REGNUM))
2081         pointer = base_ptr = TRUE;
2082     }
2083
2084   /* Validate index register.  */
2085   if (indx)
2086     {
2087       if (GET_CODE (indx) == UNSPEC)
2088         {
2089           if (XVECLEN (indx, 0) != 1 || XINT (indx, 1) != UNSPEC_LTREL_BASE)
2090             return FALSE;
2091           indx = gen_rtx_REG (Pmode, BASE_REGISTER);
2092         }
2093
2094       if (GET_CODE (indx) != REG || GET_MODE (indx) != Pmode)
2095         return FALSE;
2096
2097       if (REGNO (indx) == BASE_REGISTER
2098           || REGNO (indx) == STACK_POINTER_REGNUM
2099           || REGNO (indx) == FRAME_POINTER_REGNUM
2100           || ((reload_completed || reload_in_progress)
2101               && frame_pointer_needed
2102               && REGNO (indx) == HARD_FRAME_POINTER_REGNUM)
2103           || REGNO (indx) == ARG_POINTER_REGNUM
2104           || (REGNO (indx) >= FIRST_VIRTUAL_REGISTER
2105               && REGNO (indx) <= LAST_VIRTUAL_REGISTER)
2106           || (flag_pic
2107               && REGNO (indx) == PIC_OFFSET_TABLE_REGNUM))
2108         pointer = indx_ptr = TRUE;
2109     }
2110
2111   /* Prefer to use pointer as base, not index.  */
2112   if (base && indx && !base_ptr
2113       && (indx_ptr || (!REG_POINTER (base) && REG_POINTER (indx))))
2114     {
2115       rtx tmp = base;
2116       base = indx;
2117       indx = tmp;
2118     }
2119
2120   /* Validate displacement.  */
2121   if (disp)
2122     {
2123       /* Allow integer constant in range.  */
2124       if (GET_CODE (disp) == CONST_INT)
2125         {
2126           /* If the argument pointer is involved, the displacement will change
2127              later anyway as the argument pointer gets eliminated.  This could
2128              make a valid displacement invalid, but it is more likely to make
2129              an invalid displacement valid, because we sometimes access the
2130              register save area via negative offsets to the arg pointer.
2131              Thus we don't check the displacement for validity here.  If after
2132              elimination the displacement turns out to be invalid after all,
2133              this is fixed up by reload in any case.  */
2134           if (base != arg_pointer_rtx && indx != arg_pointer_rtx)
2135             {
2136               if (!DISP_IN_RANGE (INTVAL (disp)))
2137                 return FALSE;
2138             }
2139         }
2140
2141       /* In the small-PIC case, the linker converts @GOT
2142          and @GOTNTPOFF offsets to possible displacements.  */
2143       else if (GET_CODE (disp) == CONST
2144                && GET_CODE (XEXP (disp, 0)) == UNSPEC
2145                && (XINT (XEXP (disp, 0), 1) == UNSPEC_GOT
2146                    || XINT (XEXP (disp, 0), 1) == UNSPEC_GOTNTPOFF))
2147         {
2148           if (flag_pic != 1)
2149             return FALSE;
2150
2151           pointer = TRUE;
2152         }
2153
2154       /* Accept chunkfied literal pool symbol references.  */
2155       else if (GET_CODE (disp) == CONST
2156                && GET_CODE (XEXP (disp, 0)) == MINUS
2157                && GET_CODE (XEXP (XEXP (disp, 0), 0)) == LABEL_REF
2158                && GET_CODE (XEXP (XEXP (disp, 0), 1)) == LABEL_REF)
2159         {
2160           pointer = TRUE;
2161         }
2162
2163       /* Likewise if a constant offset is present.  */
2164       else if (GET_CODE (disp) == CONST
2165                && GET_CODE (XEXP (disp, 0)) == PLUS
2166                && GET_CODE (XEXP (XEXP (disp, 0), 1)) == CONST_INT
2167                && GET_CODE (XEXP (XEXP (disp, 0), 0)) == MINUS
2168                && GET_CODE (XEXP (XEXP (XEXP (disp, 0), 0), 0)) == LABEL_REF
2169                && GET_CODE (XEXP (XEXP (XEXP (disp, 0), 0), 1)) == LABEL_REF)
2170         {
2171           pointer = TRUE;
2172         }
2173
2174       /* We can convert literal pool addresses to
2175          displacements by basing them off the base register.  */
2176       else
2177         {
2178           /* In some cases, we can accept an additional
2179              small constant offset.  Split these off here.  */
2180
2181           unsigned int offset = 0;
2182
2183           if (GET_CODE (disp) == CONST
2184               && GET_CODE (XEXP (disp, 0)) == PLUS
2185               && GET_CODE (XEXP (XEXP (disp, 0), 1)) == CONST_INT)
2186             {
2187               offset = INTVAL (XEXP (XEXP (disp, 0), 1));
2188               disp = XEXP (XEXP (disp, 0), 0);
2189             }
2190
2191           /* Now we must have a literal pool address.  */
2192           if (GET_CODE (disp) != SYMBOL_REF
2193               || !CONSTANT_POOL_ADDRESS_P (disp))
2194             return FALSE;
2195
2196           /* If we have an offset, make sure it does not
2197              exceed the size of the constant pool entry.  */
2198           if (offset && offset >= GET_MODE_SIZE (get_pool_mode (disp)))
2199             return FALSE;
2200
2201           /* Either base or index must be free to
2202              hold the base register.  */
2203           if (base && indx)
2204             return FALSE;
2205
2206           /* Convert the address.  */
2207           if (base)
2208             indx = gen_rtx_REG (Pmode, BASE_REGISTER);
2209           else
2210             base = gen_rtx_REG (Pmode, BASE_REGISTER);
2211
2212           disp = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, disp),
2213                                  UNSPEC_LTREL_OFFSET);
2214           disp = gen_rtx_CONST (Pmode, disp);
2215
2216           if (offset)
2217             disp = plus_constant (disp, offset);
2218
2219           pointer = TRUE;
2220         }
2221     }
2222
2223   if (!base && !indx)
2224     pointer = TRUE;
2225
2226   if (out)
2227     {
2228       out->base = base;
2229       out->indx = indx;
2230       out->disp = disp;
2231       out->pointer = pointer;
2232     }
2233
2234   return TRUE;
2235 }
2236
2237 /* Return nonzero if ADDR is a valid memory address.
2238    STRICT specifies whether strict register checking applies.  */
2239
2240 int
2241 legitimate_address_p (enum machine_mode mode ATTRIBUTE_UNUSED,
2242                       register rtx addr, int strict)
2243 {
2244   struct s390_address ad;
2245   if (!s390_decompose_address (addr, &ad))
2246     return FALSE;
2247
2248   if (strict)
2249     {
2250       if (ad.base && !REG_OK_FOR_BASE_STRICT_P (ad.base))
2251         return FALSE;
2252       if (ad.indx && !REG_OK_FOR_INDEX_STRICT_P (ad.indx))
2253         return FALSE;
2254     }
2255   else
2256     {
2257       if (ad.base && !REG_OK_FOR_BASE_NONSTRICT_P (ad.base))
2258         return FALSE;
2259       if (ad.indx && !REG_OK_FOR_INDEX_NONSTRICT_P (ad.indx))
2260         return FALSE;
2261     }
2262
2263   return TRUE;
2264 }
2265
2266 /* Return 1 if OP is a valid operand for the LA instruction.
2267    In 31-bit, we need to prove that the result is used as an
2268    address, as LA performs only a 31-bit addition.  */
2269
2270 int
2271 legitimate_la_operand_p (register rtx op)
2272 {
2273   struct s390_address addr;
2274   if (!s390_decompose_address (op, &addr))
2275     return FALSE;
2276
2277   if (TARGET_64BIT || addr.pointer)
2278     return TRUE;
2279
2280   return FALSE;
2281 }
2282
2283 /* Return 1 if OP is a valid operand for the LA instruction,
2284    and we prefer to use LA over addition to compute it.  */
2285
2286 int
2287 preferred_la_operand_p (register rtx op)
2288 {
2289   struct s390_address addr;
2290   if (!s390_decompose_address (op, &addr))
2291     return FALSE;
2292
2293   if (!TARGET_64BIT && !addr.pointer)
2294     return FALSE;
2295
2296   if (addr.pointer)
2297     return TRUE;
2298
2299   if ((addr.base && REG_P (addr.base) && REG_POINTER (addr.base))
2300       || (addr.indx && REG_P (addr.indx) && REG_POINTER (addr.indx)))
2301     return TRUE;
2302
2303   return FALSE;
2304 }
2305
2306 /* Emit a forced load-address operation to load SRC into DST.
2307    This will use the LOAD ADDRESS instruction even in situations
2308    where legitimate_la_operand_p (SRC) returns false.  */
2309
2310 void
2311 s390_load_address (rtx dst, rtx src)
2312 {
2313   if (TARGET_64BIT)
2314     emit_move_insn (dst, src);
2315   else
2316     emit_insn (gen_force_la_31 (dst, src));
2317 }
2318
2319 /* Return a legitimate reference for ORIG (an address) using the
2320    register REG.  If REG is 0, a new pseudo is generated.
2321
2322    There are two types of references that must be handled:
2323
2324    1. Global data references must load the address from the GOT, via
2325       the PIC reg.  An insn is emitted to do this load, and the reg is
2326       returned.
2327
2328    2. Static data references, constant pool addresses, and code labels
2329       compute the address as an offset from the GOT, whose base is in
2330       the PIC reg.  Static data objects have SYMBOL_FLAG_LOCAL set to
2331       differentiate them from global data objects.  The returned
2332       address is the PIC reg + an unspec constant.
2333
2334    GO_IF_LEGITIMATE_ADDRESS rejects symbolic references unless the PIC
2335    reg also appears in the address.  */
2336
2337 rtx
2338 legitimize_pic_address (rtx orig, rtx reg)
2339 {
2340   rtx addr = orig;
2341   rtx new = orig;
2342   rtx base;
2343
2344   if (GET_CODE (addr) == LABEL_REF
2345       || (GET_CODE (addr) == SYMBOL_REF && SYMBOL_REF_LOCAL_P (addr)))
2346     {
2347       /* This is a local symbol.  */
2348       if (TARGET_CPU_ZARCH && larl_operand (addr, VOIDmode))
2349         {
2350           /* Access local symbols PC-relative via LARL.
2351              This is the same as in the non-PIC case, so it is
2352              handled automatically ...  */
2353         }
2354       else
2355         {
2356           /* Access local symbols relative to the GOT.  */
2357
2358           rtx temp = reg? reg : gen_reg_rtx (Pmode);
2359
2360           if (reload_in_progress || reload_completed)
2361             regs_ever_live[PIC_OFFSET_TABLE_REGNUM] = 1;
2362
2363           addr = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTOFF);
2364           addr = gen_rtx_CONST (Pmode, addr);
2365           addr = force_const_mem (Pmode, addr);
2366           emit_move_insn (temp, addr);
2367
2368           new = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp);
2369           if (reg != 0)
2370             {
2371               emit_move_insn (reg, new);
2372               new = reg;
2373             }
2374         }
2375     }
2376   else if (GET_CODE (addr) == SYMBOL_REF)
2377     {
2378       if (reg == 0)
2379         reg = gen_reg_rtx (Pmode);
2380
2381       if (flag_pic == 1)
2382         {
2383           /* Assume GOT offset < 4k.  This is handled the same way
2384              in both 31- and 64-bit code (@GOT).  */
2385
2386           if (reload_in_progress || reload_completed)
2387             regs_ever_live[PIC_OFFSET_TABLE_REGNUM] = 1;
2388
2389           new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOT);
2390           new = gen_rtx_CONST (Pmode, new);
2391           new = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, new);
2392           new = gen_rtx_MEM (Pmode, new);
2393           RTX_UNCHANGING_P (new) = 1;
2394           emit_move_insn (reg, new);
2395           new = reg;
2396         }
2397       else if (TARGET_CPU_ZARCH)
2398         {
2399           /* If the GOT offset might be >= 4k, we determine the position
2400              of the GOT entry via a PC-relative LARL (@GOTENT).  */
2401
2402           rtx temp = gen_reg_rtx (Pmode);
2403
2404           new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTENT);
2405           new = gen_rtx_CONST (Pmode, new);
2406           emit_move_insn (temp, new);
2407
2408           new = gen_rtx_MEM (Pmode, temp);
2409           RTX_UNCHANGING_P (new) = 1;
2410           emit_move_insn (reg, new);
2411           new = reg;
2412         }
2413       else
2414         {
2415           /* If the GOT offset might be >= 4k, we have to load it
2416              from the literal pool (@GOT).  */
2417
2418           rtx temp = gen_reg_rtx (Pmode);
2419
2420           if (reload_in_progress || reload_completed)
2421             regs_ever_live[PIC_OFFSET_TABLE_REGNUM] = 1;
2422
2423           addr = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOT);
2424           addr = gen_rtx_CONST (Pmode, addr);
2425           addr = force_const_mem (Pmode, addr);
2426           emit_move_insn (temp, addr);
2427
2428           new = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp);
2429           new = gen_rtx_MEM (Pmode, new);
2430           RTX_UNCHANGING_P (new) = 1;
2431           emit_move_insn (reg, new);
2432           new = reg;
2433         }
2434     }
2435   else
2436     {
2437       if (GET_CODE (addr) == CONST)
2438         {
2439           addr = XEXP (addr, 0);
2440           if (GET_CODE (addr) == UNSPEC)
2441             {
2442               if (XVECLEN (addr, 0) != 1)
2443                 abort ();
2444               switch (XINT (addr, 1))
2445                 {
2446                   /* If someone moved a GOT-relative UNSPEC
2447                      out of the literal pool, force them back in.  */
2448                   case UNSPEC_GOTOFF:
2449                   case UNSPEC_PLTOFF:
2450                     new = force_const_mem (Pmode, orig);
2451                     break;
2452
2453                   /* @GOT is OK as is if small.  */
2454                   case UNSPEC_GOT:
2455                     if (flag_pic == 2)
2456                       new = force_const_mem (Pmode, orig);
2457                     break;
2458
2459                   /* @GOTENT is OK as is.  */
2460                   case UNSPEC_GOTENT:
2461                     break;
2462
2463                   /* @PLT is OK as is on 64-bit, must be converted to
2464                      GOT-relative @PLTOFF on 31-bit.  */
2465                   case UNSPEC_PLT:
2466                     if (!TARGET_CPU_ZARCH)
2467                       {
2468                         rtx temp = reg? reg : gen_reg_rtx (Pmode);
2469
2470                         if (reload_in_progress || reload_completed)
2471                           regs_ever_live[PIC_OFFSET_TABLE_REGNUM] = 1;
2472
2473                         addr = XVECEXP (addr, 0, 0);
2474                         addr = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr),
2475                                                UNSPEC_PLTOFF);
2476                         addr = gen_rtx_CONST (Pmode, addr);
2477                         addr = force_const_mem (Pmode, addr);
2478                         emit_move_insn (temp, addr);
2479
2480                         new = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp);
2481                         if (reg != 0)
2482                           {
2483                             emit_move_insn (reg, new);
2484                             new = reg;
2485                           }
2486                       }
2487                     break;
2488
2489                   /* Everything else cannot happen.  */
2490                   default:
2491                     abort ();
2492                 }
2493             }
2494           else if (GET_CODE (addr) != PLUS)
2495             abort ();
2496         }
2497       if (GET_CODE (addr) == PLUS)
2498         {
2499           rtx op0 = XEXP (addr, 0), op1 = XEXP (addr, 1);
2500           /* Check first to see if this is a constant offset
2501              from a local symbol reference.  */
2502           if ((GET_CODE (op0) == LABEL_REF
2503                 || (GET_CODE (op0) == SYMBOL_REF && SYMBOL_REF_LOCAL_P (op0)))
2504               && GET_CODE (op1) == CONST_INT)
2505             {
2506               if (TARGET_CPU_ZARCH && larl_operand (op0, VOIDmode))
2507                 {
2508                   if (INTVAL (op1) & 1)
2509                     {
2510                       /* LARL can't handle odd offsets, so emit a
2511                          pair of LARL and LA.  */
2512                       rtx temp = reg? reg : gen_reg_rtx (Pmode);
2513
2514                       if (!DISP_IN_RANGE (INTVAL (op1)))
2515                         {
2516                           int even = INTVAL (op1) - 1;
2517                           op0 = gen_rtx_PLUS (Pmode, op0, GEN_INT (even));
2518                           op0 = gen_rtx_CONST (Pmode, op0);
2519                           op1 = GEN_INT (1);
2520                         }
2521
2522                       emit_move_insn (temp, op0);
2523                       new = gen_rtx_PLUS (Pmode, temp, op1);
2524
2525                       if (reg != 0)
2526                         {
2527                           emit_move_insn (reg, new);
2528                           new = reg;
2529                         }
2530                     }
2531                   else
2532                     {
2533                       /* If the offset is even, we can just use LARL.
2534                          This will happen automatically.  */
2535                     }
2536                 }
2537               else
2538                 {
2539                   /* Access local symbols relative to the GOT.  */
2540
2541                   rtx temp = reg? reg : gen_reg_rtx (Pmode);
2542
2543                   if (reload_in_progress || reload_completed)
2544                     regs_ever_live[PIC_OFFSET_TABLE_REGNUM] = 1;
2545
2546                   addr = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, op0),
2547                                          UNSPEC_GOTOFF);
2548                   addr = gen_rtx_PLUS (Pmode, addr, op1);
2549                   addr = gen_rtx_CONST (Pmode, addr);
2550                   addr = force_const_mem (Pmode, addr);
2551           emit_move_insn (temp, addr);
2552
2553                   new = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp);
2554                   if (reg != 0)
2555                     {
2556                       emit_move_insn (reg, new);
2557                       new = reg;
2558                     }
2559                 }
2560             }
2561
2562           /* Now, check whether it is a GOT relative symbol plus offset
2563              that was pulled out of the literal pool.  Force it back in.  */
2564
2565           else if (GET_CODE (op0) == UNSPEC
2566                    && GET_CODE (op1) == CONST_INT)
2567             {
2568               if (XVECLEN (op0, 0) != 1)
2569                 abort ();
2570               if (XINT (op0, 1) != UNSPEC_GOTOFF)
2571                 abort ();
2572
2573               new = force_const_mem (Pmode, orig);
2574             }
2575
2576           /* Otherwise, compute the sum.  */
2577           else
2578             {
2579               base = legitimize_pic_address (XEXP (addr, 0), reg);
2580               new  = legitimize_pic_address (XEXP (addr, 1),
2581                                              base == reg ? NULL_RTX : reg);
2582               if (GET_CODE (new) == CONST_INT)
2583                 new = plus_constant (base, INTVAL (new));
2584               else
2585                 {
2586                   if (GET_CODE (new) == PLUS && CONSTANT_P (XEXP (new, 1)))
2587                     {
2588                       base = gen_rtx_PLUS (Pmode, base, XEXP (new, 0));
2589                       new = XEXP (new, 1);
2590                     }
2591                   new = gen_rtx_PLUS (Pmode, base, new);
2592                 }
2593
2594               if (GET_CODE (new) == CONST)
2595                 new = XEXP (new, 0);
2596               new = force_operand (new, 0);
2597             }
2598         }
2599     }
2600   return new;
2601 }
2602
2603 /* Load the thread pointer into a register.  */
2604
2605 static rtx
2606 get_thread_pointer (void)
2607 {
2608   rtx tp;
2609
2610   tp = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx), UNSPEC_TP);
2611   tp = force_reg (Pmode, tp);
2612   mark_reg_pointer (tp, BITS_PER_WORD);
2613
2614   return tp;
2615 }
2616
2617 /* Construct the SYMBOL_REF for the tls_get_offset function.  */
2618
2619 static GTY(()) rtx s390_tls_symbol;
2620 rtx
2621 s390_tls_get_offset (void)
2622 {
2623   if (!s390_tls_symbol)
2624     s390_tls_symbol = gen_rtx_SYMBOL_REF (Pmode, "__tls_get_offset");
2625
2626   return s390_tls_symbol;
2627 }
2628
2629 /* ADDR contains a thread-local SYMBOL_REF.  Generate code to compute
2630    this (thread-local) address.  REG may be used as temporary.  */
2631
2632 static rtx
2633 legitimize_tls_address (rtx addr, rtx reg)
2634 {
2635   rtx new, tls_call, temp, base, r2, insn;
2636
2637   if (GET_CODE (addr) == SYMBOL_REF)
2638     switch (tls_symbolic_operand (addr))
2639       {
2640       case TLS_MODEL_GLOBAL_DYNAMIC:
2641         start_sequence ();
2642         r2 = gen_rtx_REG (Pmode, 2);
2643         tls_call = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_TLSGD);
2644         new = gen_rtx_CONST (Pmode, tls_call);
2645         new = force_const_mem (Pmode, new);
2646         emit_move_insn (r2, new);
2647         emit_call_insn (gen_call_value_tls (r2, tls_call));
2648         insn = get_insns ();
2649         end_sequence ();
2650
2651         new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_NTPOFF);
2652         temp = gen_reg_rtx (Pmode);
2653         emit_libcall_block (insn, temp, r2, new);
2654
2655         new = gen_rtx_PLUS (Pmode, get_thread_pointer (), temp);
2656         if (reg != 0)
2657           {
2658             s390_load_address (reg, new);
2659             new = reg;
2660           }
2661         break;
2662
2663       case TLS_MODEL_LOCAL_DYNAMIC:
2664         start_sequence ();
2665         r2 = gen_rtx_REG (Pmode, 2);
2666         tls_call = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx), UNSPEC_TLSLDM);
2667         new = gen_rtx_CONST (Pmode, tls_call);
2668         new = force_const_mem (Pmode, new);
2669         emit_move_insn (r2, new);
2670         emit_call_insn (gen_call_value_tls (r2, tls_call));
2671         insn = get_insns ();
2672         end_sequence ();
2673
2674         new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx), UNSPEC_TLSLDM_NTPOFF);
2675         temp = gen_reg_rtx (Pmode);
2676         emit_libcall_block (insn, temp, r2, new);
2677
2678         new = gen_rtx_PLUS (Pmode, get_thread_pointer (), temp);
2679         base = gen_reg_rtx (Pmode);
2680         s390_load_address (base, new);
2681
2682         new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_DTPOFF);
2683         new = gen_rtx_CONST (Pmode, new);
2684         new = force_const_mem (Pmode, new);
2685         temp = gen_reg_rtx (Pmode);
2686         emit_move_insn (temp, new);
2687
2688         new = gen_rtx_PLUS (Pmode, base, temp);
2689         if (reg != 0)
2690           {
2691             s390_load_address (reg, new);
2692             new = reg;
2693           }
2694         break;
2695
2696       case TLS_MODEL_INITIAL_EXEC:
2697         if (flag_pic == 1)
2698           {
2699             /* Assume GOT offset < 4k.  This is handled the same way
2700                in both 31- and 64-bit code.  */
2701
2702             if (reload_in_progress || reload_completed)
2703               regs_ever_live[PIC_OFFSET_TABLE_REGNUM] = 1;
2704
2705             new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTNTPOFF);
2706             new = gen_rtx_CONST (Pmode, new);
2707             new = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, new);
2708             new = gen_rtx_MEM (Pmode, new);
2709             RTX_UNCHANGING_P (new) = 1;
2710             temp = gen_reg_rtx (Pmode);
2711             emit_move_insn (temp, new);
2712           }
2713         else if (TARGET_CPU_ZARCH)
2714           {
2715             /* If the GOT offset might be >= 4k, we determine the position
2716                of the GOT entry via a PC-relative LARL.  */
2717
2718             new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_INDNTPOFF);
2719             new = gen_rtx_CONST (Pmode, new);
2720             temp = gen_reg_rtx (Pmode);
2721             emit_move_insn (temp, new);
2722
2723             new = gen_rtx_MEM (Pmode, temp);
2724             RTX_UNCHANGING_P (new) = 1;
2725             temp = gen_reg_rtx (Pmode);
2726             emit_move_insn (temp, new);
2727           }
2728         else if (flag_pic)
2729           {
2730             /* If the GOT offset might be >= 4k, we have to load it
2731                from the literal pool.  */
2732
2733             if (reload_in_progress || reload_completed)
2734               regs_ever_live[PIC_OFFSET_TABLE_REGNUM] = 1;
2735
2736             new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTNTPOFF);
2737             new = gen_rtx_CONST (Pmode, new);
2738             new = force_const_mem (Pmode, new);
2739             temp = gen_reg_rtx (Pmode);
2740             emit_move_insn (temp, new);
2741
2742             new = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp);
2743             new = gen_rtx_MEM (Pmode, new);
2744             RTX_UNCHANGING_P (new) = 1;
2745
2746             new = gen_rtx_UNSPEC (Pmode, gen_rtvec (2, new, addr), UNSPEC_TLS_LOAD);
2747             temp = gen_reg_rtx (Pmode);
2748             emit_insn (gen_rtx_SET (Pmode, temp, new));
2749           }
2750         else
2751           {
2752             /* In position-dependent code, load the absolute address of
2753                the GOT entry from the literal pool.  */
2754
2755             new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_INDNTPOFF);
2756             new = gen_rtx_CONST (Pmode, new);
2757             new = force_const_mem (Pmode, new);
2758             temp = gen_reg_rtx (Pmode);
2759             emit_move_insn (temp, new);
2760
2761             new = temp;
2762             new = gen_rtx_MEM (Pmode, new);
2763             RTX_UNCHANGING_P (new) = 1;
2764
2765             new = gen_rtx_UNSPEC (Pmode, gen_rtvec (2, new, addr), UNSPEC_TLS_LOAD);
2766             temp = gen_reg_rtx (Pmode);
2767             emit_insn (gen_rtx_SET (Pmode, temp, new));
2768           }
2769
2770         new = gen_rtx_PLUS (Pmode, get_thread_pointer (), temp);
2771         if (reg != 0)
2772           {
2773             s390_load_address (reg, new);
2774             new = reg;
2775           }
2776         break;
2777
2778       case TLS_MODEL_LOCAL_EXEC:
2779         new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_NTPOFF);
2780         new = gen_rtx_CONST (Pmode, new);
2781         new = force_const_mem (Pmode, new);
2782         temp = gen_reg_rtx (Pmode);
2783         emit_move_insn (temp, new);
2784
2785         new = gen_rtx_PLUS (Pmode, get_thread_pointer (), temp);
2786         if (reg != 0)
2787           {
2788             s390_load_address (reg, new);
2789             new = reg;
2790           }
2791         break;
2792
2793       default:
2794         abort ();
2795       }
2796
2797   else if (GET_CODE (addr) == CONST && GET_CODE (XEXP (addr, 0)) == UNSPEC)
2798     {
2799       switch (XINT (XEXP (addr, 0), 1))
2800         {
2801         case UNSPEC_INDNTPOFF:
2802           if (TARGET_CPU_ZARCH)
2803             new = addr;
2804           else
2805             abort ();
2806           break;
2807
2808         default:
2809           abort ();
2810         }
2811     }
2812
2813   else
2814     abort ();  /* for now ... */
2815
2816   return new;
2817 }
2818
2819 /* Emit insns to move operands[1] into operands[0].  */
2820
2821 void
2822 emit_symbolic_move (rtx *operands)
2823 {
2824   rtx temp = no_new_pseudos ? operands[0] : gen_reg_rtx (Pmode);
2825
2826   if (GET_CODE (operands[0]) == MEM)
2827     operands[1] = force_reg (Pmode, operands[1]);
2828   else if (TLS_SYMBOLIC_CONST (operands[1]))
2829     operands[1] = legitimize_tls_address (operands[1], temp);
2830   else if (flag_pic)
2831     operands[1] = legitimize_pic_address (operands[1], temp);
2832 }
2833
2834 /* Try machine-dependent ways of modifying an illegitimate address X
2835    to be legitimate.  If we find one, return the new, valid address.
2836
2837    OLDX is the address as it was before break_out_memory_refs was called.
2838    In some cases it is useful to look at this to decide what needs to be done.
2839
2840    MODE is the mode of the operand pointed to by X.
2841
2842    When -fpic is used, special handling is needed for symbolic references.
2843    See comments by legitimize_pic_address for details.  */
2844
2845 rtx
2846 legitimize_address (register rtx x, register rtx oldx ATTRIBUTE_UNUSED,
2847                     enum machine_mode mode ATTRIBUTE_UNUSED)
2848 {
2849   rtx constant_term = const0_rtx;
2850
2851   if (TLS_SYMBOLIC_CONST (x))
2852     {
2853       x = legitimize_tls_address (x, 0);
2854
2855       if (legitimate_address_p (mode, x, FALSE))
2856         return x;
2857     }
2858   else if (flag_pic)
2859     {
2860       if (SYMBOLIC_CONST (x)
2861           || (GET_CODE (x) == PLUS
2862               && (SYMBOLIC_CONST (XEXP (x, 0))
2863                   || SYMBOLIC_CONST (XEXP (x, 1)))))
2864           x = legitimize_pic_address (x, 0);
2865
2866       if (legitimate_address_p (mode, x, FALSE))
2867         return x;
2868     }
2869
2870   x = eliminate_constant_term (x, &constant_term);
2871
2872   /* Optimize loading of large displacements by splitting them
2873      into the multiple of 4K and the rest; this allows the
2874      former to be CSE'd if possible.
2875
2876      Don't do this if the displacement is added to a register
2877      pointing into the stack frame, as the offsets will
2878      change later anyway.  */
2879
2880   if (GET_CODE (constant_term) == CONST_INT
2881       && !TARGET_LONG_DISPLACEMENT
2882       && !DISP_IN_RANGE (INTVAL (constant_term))
2883       && !(REG_P (x) && REGNO_PTR_FRAME_P (REGNO (x))))
2884     {
2885       HOST_WIDE_INT lower = INTVAL (constant_term) & 0xfff;
2886       HOST_WIDE_INT upper = INTVAL (constant_term) ^ lower;
2887
2888       rtx temp = gen_reg_rtx (Pmode);
2889       rtx val  = force_operand (GEN_INT (upper), temp);
2890       if (val != temp)
2891         emit_move_insn (temp, val);
2892
2893       x = gen_rtx_PLUS (Pmode, x, temp);
2894       constant_term = GEN_INT (lower);
2895     }
2896
2897   if (GET_CODE (x) == PLUS)
2898     {
2899       if (GET_CODE (XEXP (x, 0)) == REG)
2900         {
2901           register rtx temp = gen_reg_rtx (Pmode);
2902           register rtx val  = force_operand (XEXP (x, 1), temp);
2903           if (val != temp)
2904             emit_move_insn (temp, val);
2905
2906           x = gen_rtx_PLUS (Pmode, XEXP (x, 0), temp);
2907         }
2908
2909       else if (GET_CODE (XEXP (x, 1)) == REG)
2910         {
2911           register rtx temp = gen_reg_rtx (Pmode);
2912           register rtx val  = force_operand (XEXP (x, 0), temp);
2913           if (val != temp)
2914             emit_move_insn (temp, val);
2915
2916           x = gen_rtx_PLUS (Pmode, temp, XEXP (x, 1));
2917         }
2918     }
2919
2920   if (constant_term != const0_rtx)
2921     x = gen_rtx_PLUS (Pmode, x, constant_term);
2922
2923   return x;
2924 }
2925
2926 /* Emit code to move LEN bytes from DST to SRC.  */
2927
2928 void
2929 s390_expand_movstr (rtx dst, rtx src, rtx len)
2930 {
2931   if (GET_CODE (len) == CONST_INT && INTVAL (len) >= 0 && INTVAL (len) <= 256)
2932     {
2933       if (INTVAL (len) > 0)
2934         emit_insn (gen_movstr_short (dst, src, GEN_INT (INTVAL (len) - 1)));
2935     }
2936
2937   else if (TARGET_MVCLE)
2938     {
2939       emit_insn (gen_movstr_long (dst, src, convert_to_mode (Pmode, len, 1)));
2940     }
2941
2942   else
2943     {
2944       rtx dst_addr, src_addr, count, blocks, temp;
2945       rtx end_label = gen_label_rtx ();
2946       enum machine_mode mode;
2947       tree type;
2948
2949       mode = GET_MODE (len);
2950       if (mode == VOIDmode)
2951         mode = Pmode;
2952
2953       type = lang_hooks.types.type_for_mode (mode, 1);
2954       if (!type)
2955         abort ();
2956
2957       dst_addr = gen_reg_rtx (Pmode);
2958       src_addr = gen_reg_rtx (Pmode);
2959       count = gen_reg_rtx (mode);
2960       blocks = gen_reg_rtx (mode);
2961
2962       convert_move (count, len, 1);
2963       emit_cmp_and_jump_insns (count, const0_rtx,
2964                                EQ, NULL_RTX, mode, 1, end_label);
2965
2966       emit_move_insn (dst_addr, force_operand (XEXP (dst, 0), NULL_RTX));
2967       emit_move_insn (src_addr, force_operand (XEXP (src, 0), NULL_RTX));
2968       dst = change_address (dst, VOIDmode, dst_addr);
2969       src = change_address (src, VOIDmode, src_addr);
2970
2971       temp = expand_binop (mode, add_optab, count, constm1_rtx, count, 1, 0);
2972       if (temp != count)
2973         emit_move_insn (count, temp);
2974
2975       temp = expand_binop (mode, ashr_optab, count, GEN_INT (8), blocks, 1, 0);
2976       if (temp != blocks)
2977         emit_move_insn (blocks, temp);
2978
2979       expand_start_loop (1);
2980       expand_exit_loop_top_cond (0, build (NE_EXPR, type,
2981                                            make_tree (type, blocks),
2982                                            make_tree (type, const0_rtx)));
2983
2984       emit_insn (gen_movstr_short (dst, src, GEN_INT (255)));
2985       s390_load_address (dst_addr,
2986                          gen_rtx_PLUS (Pmode, dst_addr, GEN_INT (256)));
2987       s390_load_address (src_addr,
2988                          gen_rtx_PLUS (Pmode, src_addr, GEN_INT (256)));
2989
2990       temp = expand_binop (mode, add_optab, blocks, constm1_rtx, blocks, 1, 0);
2991       if (temp != blocks)
2992         emit_move_insn (blocks, temp);
2993
2994       expand_end_loop ();
2995
2996       emit_insn (gen_movstr_short (dst, src,
2997                                    convert_to_mode (Pmode, count, 1)));
2998       emit_label (end_label);
2999     }
3000 }
3001
3002 /* Emit code to clear LEN bytes at DST.  */
3003
3004 void
3005 s390_expand_clrstr (rtx dst, rtx len)
3006 {
3007   if (GET_CODE (len) == CONST_INT && INTVAL (len) >= 0 && INTVAL (len) <= 256)
3008     {
3009       if (INTVAL (len) > 0)
3010         emit_insn (gen_clrstr_short (dst, GEN_INT (INTVAL (len) - 1)));
3011     }
3012
3013   else if (TARGET_MVCLE)
3014     {
3015       emit_insn (gen_clrstr_long (dst, convert_to_mode (Pmode, len, 1)));
3016     }
3017
3018   else
3019     {
3020       rtx dst_addr, src_addr, count, blocks, temp;
3021       rtx end_label = gen_label_rtx ();
3022       enum machine_mode mode;
3023       tree type;
3024
3025       mode = GET_MODE (len);
3026       if (mode == VOIDmode)
3027         mode = Pmode;
3028
3029       type = lang_hooks.types.type_for_mode (mode, 1);
3030       if (!type)
3031         abort ();
3032
3033       dst_addr = gen_reg_rtx (Pmode);
3034       src_addr = gen_reg_rtx (Pmode);
3035       count = gen_reg_rtx (mode);
3036       blocks = gen_reg_rtx (mode);
3037
3038       convert_move (count, len, 1);
3039       emit_cmp_and_jump_insns (count, const0_rtx,
3040                                EQ, NULL_RTX, mode, 1, end_label);
3041
3042       emit_move_insn (dst_addr, force_operand (XEXP (dst, 0), NULL_RTX));
3043       dst = change_address (dst, VOIDmode, dst_addr);
3044
3045       temp = expand_binop (mode, add_optab, count, constm1_rtx, count, 1, 0);
3046       if (temp != count)
3047         emit_move_insn (count, temp);
3048
3049       temp = expand_binop (mode, ashr_optab, count, GEN_INT (8), blocks, 1, 0);
3050       if (temp != blocks)
3051         emit_move_insn (blocks, temp);
3052
3053       expand_start_loop (1);
3054       expand_exit_loop_top_cond (0, build (NE_EXPR, type,
3055                                            make_tree (type, blocks),
3056                                            make_tree (type, const0_rtx)));
3057
3058       emit_insn (gen_clrstr_short (dst, GEN_INT (255)));
3059       s390_load_address (dst_addr,
3060                          gen_rtx_PLUS (Pmode, dst_addr, GEN_INT (256)));
3061
3062       temp = expand_binop (mode, add_optab, blocks, constm1_rtx, blocks, 1, 0);
3063       if (temp != blocks)
3064         emit_move_insn (blocks, temp);
3065
3066       expand_end_loop ();
3067
3068       emit_insn (gen_clrstr_short (dst, convert_to_mode (Pmode, count, 1)));
3069       emit_label (end_label);
3070     }
3071 }
3072
3073 /* Emit code to compare LEN bytes at OP0 with those at OP1,
3074    and return the result in TARGET.  */
3075
3076 void
3077 s390_expand_cmpmem (rtx target, rtx op0, rtx op1, rtx len)
3078 {
3079   rtx (*gen_result) (rtx) =
3080     GET_MODE (target) == DImode ? gen_cmpint_di : gen_cmpint_si;
3081
3082   op0 = protect_from_queue (op0, 0);
3083   op1 = protect_from_queue (op1, 0);
3084   len = protect_from_queue (len, 0);
3085
3086   if (GET_CODE (len) == CONST_INT && INTVAL (len) >= 0 && INTVAL (len) <= 256)
3087     {
3088       if (INTVAL (len) > 0)
3089         {
3090           emit_insn (gen_cmpmem_short (op0, op1, GEN_INT (INTVAL (len) - 1)));
3091           emit_insn (gen_result (target));
3092         }
3093       else
3094         emit_move_insn (target, const0_rtx);
3095     }
3096
3097   else /* if (TARGET_MVCLE) */
3098     {
3099       emit_insn (gen_cmpmem_long (op0, op1, convert_to_mode (Pmode, len, 1)));
3100       emit_insn (gen_result (target));
3101     }
3102
3103 #if 0
3104   /* Deactivate for now as profile code cannot cope with
3105      CC being live across basic block boundaries.  */
3106   else
3107     {
3108       rtx addr0, addr1, count, blocks, temp;
3109       rtx end_label = gen_label_rtx ();
3110       enum machine_mode mode;
3111       tree type;
3112
3113       mode = GET_MODE (len);
3114       if (mode == VOIDmode)
3115         mode = Pmode;
3116
3117       type = lang_hooks.types.type_for_mode (mode, 1);
3118       if (!type)
3119         abort ();
3120
3121       addr0 = gen_reg_rtx (Pmode);
3122       addr1 = gen_reg_rtx (Pmode);
3123       count = gen_reg_rtx (mode);
3124       blocks = gen_reg_rtx (mode);
3125
3126       convert_move (count, len, 1);
3127       emit_cmp_and_jump_insns (count, const0_rtx,
3128                                EQ, NULL_RTX, mode, 1, end_label);
3129
3130       emit_move_insn (addr0, force_operand (XEXP (op0, 0), NULL_RTX));
3131       emit_move_insn (addr1, force_operand (XEXP (op1, 0), NULL_RTX));
3132       op0 = change_address (op0, VOIDmode, addr0);
3133       op1 = change_address (op1, VOIDmode, addr1);
3134
3135       temp = expand_binop (mode, add_optab, count, constm1_rtx, count, 1, 0);
3136       if (temp != count)
3137         emit_move_insn (count, temp);
3138
3139       temp = expand_binop (mode, ashr_optab, count, GEN_INT (8), blocks, 1, 0);
3140       if (temp != blocks)
3141         emit_move_insn (blocks, temp);
3142
3143       expand_start_loop (1);
3144       expand_exit_loop_top_cond (0, build (NE_EXPR, type,
3145                                            make_tree (type, blocks),
3146                                            make_tree (type, const0_rtx)));
3147
3148       emit_insn (gen_cmpmem_short (op0, op1, GEN_INT (255)));
3149       temp = gen_rtx_NE (VOIDmode, gen_rtx_REG (CCSmode, 33), const0_rtx);
3150       temp = gen_rtx_IF_THEN_ELSE (VOIDmode, temp,
3151                         gen_rtx_LABEL_REF (VOIDmode, end_label), pc_rtx);
3152       temp = gen_rtx_SET (VOIDmode, pc_rtx, temp);
3153       emit_jump_insn (temp);
3154
3155       s390_load_address (addr0,
3156                          gen_rtx_PLUS (Pmode, addr0, GEN_INT (256)));
3157       s390_load_address (addr1,
3158                          gen_rtx_PLUS (Pmode, addr1, GEN_INT (256)));
3159
3160       temp = expand_binop (mode, add_optab, blocks, constm1_rtx, blocks, 1, 0);
3161       if (temp != blocks)
3162         emit_move_insn (blocks, temp);
3163
3164       expand_end_loop ();
3165
3166       emit_insn (gen_cmpmem_short (op0, op1,
3167                                    convert_to_mode (Pmode, count, 1)));
3168       emit_label (end_label);
3169
3170       emit_insn (gen_result (target));
3171     }
3172 #endif
3173 }
3174
3175 /* This is called from dwarf2out.c via ASM_OUTPUT_DWARF_DTPREL.
3176    We need to emit DTP-relative relocations.  */
3177
3178 void
3179 s390_output_dwarf_dtprel (FILE *file, int size, rtx x)
3180 {
3181   switch (size)
3182     {
3183     case 4:
3184       fputs ("\t.long\t", file);
3185       break;
3186     case 8:
3187       fputs ("\t.quad\t", file);
3188       break;
3189     default:
3190       abort ();
3191     }
3192   output_addr_const (file, x);
3193   fputs ("@DTPOFF", file);
3194 }
3195
3196 /* In the name of slightly smaller debug output, and to cater to
3197    general assembler losage, recognize various UNSPEC sequences
3198    and turn them back into a direct symbol reference.  */
3199
3200 static rtx
3201 s390_delegitimize_address (rtx orig_x)
3202 {
3203   rtx x = orig_x, y;
3204
3205   if (GET_CODE (x) != MEM)
3206     return orig_x;
3207
3208   x = XEXP (x, 0);
3209   if (GET_CODE (x) == PLUS
3210       && GET_CODE (XEXP (x, 1)) == CONST
3211       && GET_CODE (XEXP (x, 0)) == REG
3212       && REGNO (XEXP (x, 0)) == PIC_OFFSET_TABLE_REGNUM)
3213     {
3214       y = XEXP (XEXP (x, 1), 0);
3215       if (GET_CODE (y) == UNSPEC
3216           && XINT (y, 1) == UNSPEC_GOT)
3217         return XVECEXP (y, 0, 0);
3218       return orig_x;
3219     }
3220
3221   if (GET_CODE (x) == CONST)
3222     {
3223       y = XEXP (x, 0);
3224       if (GET_CODE (y) == UNSPEC
3225           && XINT (y, 1) == UNSPEC_GOTENT)
3226         return XVECEXP (y, 0, 0);
3227       return orig_x;
3228     }
3229
3230   return orig_x;
3231 }
3232
3233 /* Output shift count operand OP to stdio stream FILE.  */
3234
3235 static void
3236 print_shift_count_operand (FILE *file, rtx op)
3237 {
3238   HOST_WIDE_INT offset = 0;
3239
3240   /* We can have an integer constant, an address register,
3241      or a sum of the two.  */
3242   if (GET_CODE (op) == CONST_INT)
3243     {
3244       offset = INTVAL (op);
3245       op = NULL_RTX;
3246     }
3247   if (op && GET_CODE (op) == PLUS && GET_CODE (XEXP (op, 1)) == CONST_INT)
3248     {
3249       offset = INTVAL (XEXP (op, 1));
3250       op = XEXP (op, 0);
3251     }
3252   while (op && GET_CODE (op) == SUBREG)
3253     op = SUBREG_REG (op);
3254
3255   /* Sanity check.  */
3256   if (op && (GET_CODE (op) != REG
3257              || REGNO (op) >= FIRST_PSEUDO_REGISTER
3258              || REGNO_REG_CLASS (REGNO (op)) != ADDR_REGS))
3259     abort ();
3260
3261   /* Shift counts are truncated to the low six bits anyway.  */
3262   fprintf (file, HOST_WIDE_INT_PRINT_DEC, offset & 63);
3263   if (op)
3264     fprintf (file, "(%s)", reg_names[REGNO (op)]);
3265 }
3266
3267 /* Locate some local-dynamic symbol still in use by this function
3268    so that we can print its name in local-dynamic base patterns.  */
3269
3270 static const char *
3271 get_some_local_dynamic_name (void)
3272 {
3273   rtx insn;
3274
3275   if (cfun->machine->some_ld_name)
3276     return cfun->machine->some_ld_name;
3277
3278   for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
3279     if (INSN_P (insn)
3280         && for_each_rtx (&PATTERN (insn), get_some_local_dynamic_name_1, 0))
3281       return cfun->machine->some_ld_name;
3282
3283   abort ();
3284 }
3285
3286 static int
3287 get_some_local_dynamic_name_1 (rtx *px, void *data ATTRIBUTE_UNUSED)
3288 {
3289   rtx x = *px;
3290
3291   if (GET_CODE (x) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (x))
3292     {
3293       x = get_pool_constant (x);
3294       return for_each_rtx (&x, get_some_local_dynamic_name_1, 0);
3295     }
3296
3297   if (GET_CODE (x) == SYMBOL_REF
3298       && tls_symbolic_operand (x) == TLS_MODEL_LOCAL_DYNAMIC)
3299     {
3300       cfun->machine->some_ld_name = XSTR (x, 0);
3301       return 1;
3302     }
3303
3304   return 0;
3305 }
3306
3307 /* Output symbolic constant X in assembler syntax to
3308    stdio stream FILE.  */
3309
3310 void
3311 s390_output_symbolic_const (FILE *file, rtx x)
3312 {
3313   switch (GET_CODE (x))
3314     {
3315     case CONST:
3316     case ZERO_EXTEND:
3317     case SIGN_EXTEND:
3318       s390_output_symbolic_const (file, XEXP (x, 0));
3319       break;
3320
3321     case PLUS:
3322       s390_output_symbolic_const (file, XEXP (x, 0));
3323       fprintf (file, "+");
3324       s390_output_symbolic_const (file, XEXP (x, 1));
3325       break;
3326
3327     case MINUS:
3328       s390_output_symbolic_const (file, XEXP (x, 0));
3329       fprintf (file, "-");
3330       s390_output_symbolic_const (file, XEXP (x, 1));
3331       break;
3332
3333     case CONST_INT:
3334     case LABEL_REF:
3335     case CODE_LABEL:
3336     case SYMBOL_REF:
3337       output_addr_const (file, x);
3338       break;
3339
3340     case UNSPEC:
3341       if (XVECLEN (x, 0) != 1)
3342         output_operand_lossage ("invalid UNSPEC as operand (1)");
3343       switch (XINT (x, 1))
3344         {
3345         case UNSPEC_GOTENT:
3346           s390_output_symbolic_const (file, XVECEXP (x, 0, 0));
3347           fprintf (file, "@GOTENT");
3348           break;
3349         case UNSPEC_GOT:
3350           s390_output_symbolic_const (file, XVECEXP (x, 0, 0));
3351           fprintf (file, "@GOT");
3352           break;
3353         case UNSPEC_GOTOFF:
3354           s390_output_symbolic_const (file, XVECEXP (x, 0, 0));
3355           fprintf (file, "@GOTOFF");
3356           break;
3357         case UNSPEC_PLT:
3358           s390_output_symbolic_const (file, XVECEXP (x, 0, 0));
3359           fprintf (file, "@PLT");
3360           break;
3361         case UNSPEC_PLTOFF:
3362           s390_output_symbolic_const (file, XVECEXP (x, 0, 0));
3363           fprintf (file, "@PLTOFF");
3364           break;
3365         case UNSPEC_TLSGD:
3366           s390_output_symbolic_const (file, XVECEXP (x, 0, 0));
3367           fprintf (file, "@TLSGD");
3368           break;
3369         case UNSPEC_TLSLDM:
3370           assemble_name (file, get_some_local_dynamic_name ());
3371           fprintf (file, "@TLSLDM");
3372           break;
3373         case UNSPEC_DTPOFF:
3374           s390_output_symbolic_const (file, XVECEXP (x, 0, 0));
3375           fprintf (file, "@DTPOFF");
3376           break;
3377         case UNSPEC_NTPOFF:
3378           s390_output_symbolic_const (file, XVECEXP (x, 0, 0));
3379           fprintf (file, "@NTPOFF");
3380           break;
3381         case UNSPEC_GOTNTPOFF:
3382           s390_output_symbolic_const (file, XVECEXP (x, 0, 0));
3383           fprintf (file, "@GOTNTPOFF");
3384           break;
3385         case UNSPEC_INDNTPOFF:
3386           s390_output_symbolic_const (file, XVECEXP (x, 0, 0));
3387           fprintf (file, "@INDNTPOFF");
3388           break;
3389         default:
3390           output_operand_lossage ("invalid UNSPEC as operand (2)");
3391           break;
3392         }
3393       break;
3394
3395     default:
3396       fatal_insn ("UNKNOWN in s390_output_symbolic_const !?", x);
3397       break;
3398     }
3399 }
3400
3401 /* Output address operand ADDR in assembler syntax to
3402    stdio stream FILE.  */
3403
3404 void
3405 print_operand_address (FILE *file, rtx addr)
3406 {
3407   struct s390_address ad;
3408
3409   if (!s390_decompose_address (addr, &ad)
3410       || (ad.base && !REG_OK_FOR_BASE_STRICT_P (ad.base))
3411       || (ad.indx && !REG_OK_FOR_INDEX_STRICT_P (ad.indx)))
3412     output_operand_lossage ("Cannot decompose address.");
3413
3414   if (ad.disp)
3415     s390_output_symbolic_const (file, ad.disp);
3416   else
3417     fprintf (file, "0");
3418
3419   if (ad.base && ad.indx)
3420     fprintf (file, "(%s,%s)", reg_names[REGNO (ad.indx)],
3421                               reg_names[REGNO (ad.base)]);
3422   else if (ad.base)
3423     fprintf (file, "(%s)", reg_names[REGNO (ad.base)]);
3424 }
3425
3426 /* Output operand X in assembler syntax to stdio stream FILE.
3427    CODE specified the format flag.  The following format flags
3428    are recognized:
3429
3430     'C': print opcode suffix for branch condition.
3431     'D': print opcode suffix for inverse branch condition.
3432     'J': print tls_load/tls_gdcall/tls_ldcall suffix
3433     'O': print only the displacement of a memory reference.
3434     'R': print only the base register of a memory reference.
3435     'N': print the second word of a DImode operand.
3436     'M': print the second word of a TImode operand.
3437     'Y': print shift count operand.
3438
3439     'b': print integer X as if it's an unsigned byte.
3440     'x': print integer X as if it's an unsigned word.
3441     'h': print integer X as if it's a signed word.
3442     'i': print the first nonzero HImode part of X.
3443     'j': print the first HImode part unequal to 0xffff of X.  */
3444
3445 void
3446 print_operand (FILE *file, rtx x, int code)
3447 {
3448   switch (code)
3449     {
3450     case 'C':
3451       fprintf (file, s390_branch_condition_mnemonic (x, FALSE));
3452       return;
3453
3454     case 'D':
3455       fprintf (file, s390_branch_condition_mnemonic (x, TRUE));
3456       return;
3457
3458     case 'J':
3459       if (GET_CODE (x) == SYMBOL_REF)
3460         {
3461           fprintf (file, "%s", ":tls_load:");
3462           output_addr_const (file, x);
3463         }
3464       else if (GET_CODE (x) == UNSPEC && XINT (x, 1) == UNSPEC_TLSGD)
3465         {
3466           fprintf (file, "%s", ":tls_gdcall:");
3467           output_addr_const (file, XVECEXP (x, 0, 0));
3468         }
3469       else if (GET_CODE (x) == UNSPEC && XINT (x, 1) == UNSPEC_TLSLDM)
3470         {
3471           fprintf (file, "%s", ":tls_ldcall:");
3472           assemble_name (file, get_some_local_dynamic_name ());
3473         }
3474       else
3475         abort ();
3476       return;
3477
3478     case 'O':
3479       {
3480         struct s390_address ad;
3481
3482         if (GET_CODE (x) != MEM
3483             || !s390_decompose_address (XEXP (x, 0), &ad)
3484             || (ad.base && !REG_OK_FOR_BASE_STRICT_P (ad.base))
3485             || ad.indx)
3486           abort ();
3487
3488         if (ad.disp)
3489           s390_output_symbolic_const (file, ad.disp);
3490         else
3491           fprintf (file, "0");
3492       }
3493       return;
3494
3495     case 'R':
3496       {
3497         struct s390_address ad;
3498
3499         if (GET_CODE (x) != MEM
3500             || !s390_decompose_address (XEXP (x, 0), &ad)
3501             || (ad.base && !REG_OK_FOR_BASE_STRICT_P (ad.base))
3502             || ad.indx)
3503           abort ();
3504
3505         if (ad.base)
3506           fprintf (file, "%s", reg_names[REGNO (ad.base)]);
3507         else
3508           fprintf (file, "0");
3509       }
3510       return;
3511
3512     case 'N':
3513       if (GET_CODE (x) == REG)
3514         x = gen_rtx_REG (GET_MODE (x), REGNO (x) + 1);
3515       else if (GET_CODE (x) == MEM)
3516         x = change_address (x, VOIDmode, plus_constant (XEXP (x, 0), 4));
3517       else
3518         abort ();
3519       break;
3520
3521     case 'M':
3522       if (GET_CODE (x) == REG)
3523         x = gen_rtx_REG (GET_MODE (x), REGNO (x) + 1);
3524       else if (GET_CODE (x) == MEM)
3525         x = change_address (x, VOIDmode, plus_constant (XEXP (x, 0), 8));
3526       else
3527         abort ();
3528       break;
3529
3530     case 'Y':
3531       print_shift_count_operand (file, x);
3532       return;
3533     }
3534
3535   switch (GET_CODE (x))
3536     {
3537     case REG:
3538       fprintf (file, "%s", reg_names[REGNO (x)]);
3539       break;
3540
3541     case MEM:
3542       output_address (XEXP (x, 0));
3543       break;
3544
3545     case CONST:
3546     case CODE_LABEL:
3547     case LABEL_REF:
3548     case SYMBOL_REF:
3549       s390_output_symbolic_const (file, x);
3550       break;
3551
3552     case CONST_INT:
3553       if (code == 'b')
3554         fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x) & 0xff);
3555       else if (code == 'x')
3556         fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x) & 0xffff);
3557       else if (code == 'h')
3558         fprintf (file, HOST_WIDE_INT_PRINT_DEC, ((INTVAL (x) & 0xffff) ^ 0x8000) - 0x8000);
3559       else if (code == 'i')
3560         fprintf (file, HOST_WIDE_INT_PRINT_DEC,
3561                  s390_extract_part (x, HImode, 0));
3562       else if (code == 'j')
3563         fprintf (file, HOST_WIDE_INT_PRINT_DEC,
3564                  s390_extract_part (x, HImode, -1));
3565       else
3566         fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
3567       break;
3568
3569     case CONST_DOUBLE:
3570       if (GET_MODE (x) != VOIDmode)
3571         abort ();
3572       if (code == 'b')
3573         fprintf (file, HOST_WIDE_INT_PRINT_DEC, CONST_DOUBLE_LOW (x) & 0xff);
3574       else if (code == 'x')
3575         fprintf (file, HOST_WIDE_INT_PRINT_DEC, CONST_DOUBLE_LOW (x) & 0xffff);
3576       else if (code == 'h')
3577         fprintf (file, HOST_WIDE_INT_PRINT_DEC, ((CONST_DOUBLE_LOW (x) & 0xffff) ^ 0x8000) - 0x8000);
3578       else
3579         abort ();
3580       break;
3581
3582     default:
3583       fatal_insn ("UNKNOWN in print_operand !?", x);
3584       break;
3585     }
3586 }
3587
3588 /* Target hook for assembling integer objects.  We need to define it
3589    here to work a round a bug in some versions of GAS, which couldn't
3590    handle values smaller than INT_MIN when printed in decimal.  */
3591
3592 static bool
3593 s390_assemble_integer (rtx x, unsigned int size, int aligned_p)
3594 {
3595   if (size == 8 && aligned_p
3596       && GET_CODE (x) == CONST_INT && INTVAL (x) < INT_MIN)
3597     {
3598       fprintf (asm_out_file, "\t.quad\t" HOST_WIDE_INT_PRINT_HEX "\n",
3599                INTVAL (x));
3600       return true;
3601     }
3602   return default_assemble_integer (x, size, aligned_p);
3603 }
3604
3605 /* Returns true if register REGNO is used  for forming
3606    a memory address in expression X.  */
3607
3608 static int
3609 reg_used_in_mem_p (int regno, rtx x)
3610 {
3611   enum rtx_code code = GET_CODE (x);
3612   int i, j;
3613   const char *fmt;
3614
3615   if (code == MEM)
3616     {
3617       if (refers_to_regno_p (regno, regno+1,
3618                              XEXP (x, 0), 0))
3619         return 1;
3620     }
3621   else if (code == SET
3622            && GET_CODE (SET_DEST (x)) == PC)
3623     {
3624       if (refers_to_regno_p (regno, regno+1,
3625                              SET_SRC (x), 0))
3626         return 1;
3627     }
3628
3629   fmt = GET_RTX_FORMAT (code);
3630   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
3631     {
3632       if (fmt[i] == 'e'
3633           && reg_used_in_mem_p (regno, XEXP (x, i)))
3634         return 1;
3635
3636       else if (fmt[i] == 'E')
3637         for (j = 0; j < XVECLEN (x, i); j++)
3638           if (reg_used_in_mem_p (regno, XVECEXP (x, i, j)))
3639             return 1;
3640     }
3641   return 0;
3642 }
3643
3644 /* Returns true if expression DEP_RTX sets an address register
3645    used by instruction INSN to address memory.  */
3646
3647 static int
3648 addr_generation_dependency_p (rtx dep_rtx, rtx insn)
3649 {
3650   rtx target, pat;
3651
3652   if (GET_CODE (dep_rtx) == INSN)
3653       dep_rtx = PATTERN (dep_rtx);
3654
3655   if (GET_CODE (dep_rtx) == SET)
3656     {
3657       target = SET_DEST (dep_rtx);
3658       if (GET_CODE (target) == STRICT_LOW_PART)
3659         target = XEXP (target, 0);
3660       while (GET_CODE (target) == SUBREG)
3661         target = SUBREG_REG (target);
3662
3663       if (GET_CODE (target) == REG)
3664         {
3665           int regno = REGNO (target);
3666
3667           if (s390_safe_attr_type (insn) == TYPE_LA)
3668             {
3669               pat = PATTERN (insn);
3670               if (GET_CODE (pat) == PARALLEL)
3671                 {
3672                   if (XVECLEN (pat, 0) != 2)
3673                     abort();
3674                   pat = XVECEXP (pat, 0, 0);
3675                 }
3676               if (GET_CODE (pat) == SET)
3677                 return refers_to_regno_p (regno, regno+1, SET_SRC (pat), 0);
3678               else
3679                 abort();
3680             }
3681           else if (get_attr_atype (insn) == ATYPE_AGEN)
3682             return reg_used_in_mem_p (regno, PATTERN (insn));
3683         }
3684     }
3685   return 0;
3686 }
3687
3688 /* Return 1, if dep_insn sets register used in insn in the agen unit.  */
3689
3690 int
3691 s390_agen_dep_p (rtx dep_insn, rtx insn)
3692 {
3693   rtx dep_rtx = PATTERN (dep_insn);
3694   int i;
3695
3696   if (GET_CODE (dep_rtx) == SET
3697       && addr_generation_dependency_p (dep_rtx, insn))
3698     return 1;
3699   else if (GET_CODE (dep_rtx) == PARALLEL)
3700     {
3701       for (i = 0; i < XVECLEN (dep_rtx, 0); i++)
3702         {
3703           if (addr_generation_dependency_p (XVECEXP (dep_rtx, 0, i), insn))
3704             return 1;
3705         }
3706     }
3707   return 0;
3708 }
3709
3710 /* Return the modified cost of the dependency of instruction INSN
3711    on instruction DEP_INSN through the link LINK.  COST is the
3712    default cost of that dependency.
3713
3714    Data dependencies are all handled without delay.  However, if a
3715    register is modified and subsequently used as base or index
3716    register of a memory reference, at least 4 cycles need to pass
3717    between setting and using the register to avoid pipeline stalls.
3718    An exception is the LA instruction. An address generated by LA can
3719    be used by introducing only a one cycle stall on the pipeline.  */
3720
3721 static int
3722 s390_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
3723 {
3724   rtx dep_rtx;
3725   int i;
3726
3727   /* If the dependence is an anti-dependence, there is no cost.  For an
3728      output dependence, there is sometimes a cost, but it doesn't seem
3729      worth handling those few cases.  */
3730
3731   if (REG_NOTE_KIND (link) != 0)
3732     return 0;
3733
3734   /* If we can't recognize the insns, we can't really do anything.  */
3735   if (recog_memoized (insn) < 0 || recog_memoized (dep_insn) < 0)
3736     return cost;
3737
3738   /* DFA based scheduling checks address dependency in md file.  */
3739   if (s390_use_dfa_pipeline_interface ())
3740   {
3741     /* Operand forward in case of lr, load and la.  */
3742     if (s390_tune == PROCESSOR_2084_Z990
3743         && cost == 1
3744         && (s390_safe_attr_type (dep_insn) == TYPE_LA
3745             || s390_safe_attr_type (dep_insn) == TYPE_LR
3746             || s390_safe_attr_type (dep_insn) == TYPE_LOAD))
3747       return 0;
3748     return cost;
3749   }
3750
3751   dep_rtx = PATTERN (dep_insn);
3752
3753   if (GET_CODE (dep_rtx) == SET
3754       && addr_generation_dependency_p (dep_rtx, insn))
3755     cost += (s390_safe_attr_type (dep_insn) == TYPE_LA) ? 1 : 4;
3756   else if (GET_CODE (dep_rtx) == PARALLEL)
3757     {
3758       for (i = 0; i < XVECLEN (dep_rtx, 0); i++)
3759         {
3760           if (addr_generation_dependency_p (XVECEXP (dep_rtx, 0, i), insn))
3761             cost += (s390_safe_attr_type (dep_insn) == TYPE_LA) ? 1 : 4;
3762         }
3763     }
3764
3765   return cost;
3766 }
3767 /* A C statement (sans semicolon) to update the integer scheduling priority
3768    INSN_PRIORITY (INSN).  Increase the priority to execute the INSN earlier,
3769    reduce the priority to execute INSN later.  Do not define this macro if
3770    you do not need to adjust the scheduling priorities of insns.
3771
3772    A STD instruction should be scheduled earlier,
3773    in order to use the bypass.  */
3774
3775 static int
3776 s390_adjust_priority (rtx insn ATTRIBUTE_UNUSED, int priority)
3777 {
3778   if (! INSN_P (insn))
3779     return priority;
3780
3781   if (s390_tune != PROCESSOR_2084_Z990)
3782     return priority;
3783
3784   switch (s390_safe_attr_type (insn))
3785     {
3786       case TYPE_FSTORED:
3787       case TYPE_FSTORES:
3788         priority = priority << 3;
3789         break;
3790       case TYPE_STORE:
3791         priority = priority << 1;
3792         break;
3793       default:
3794         break;
3795     }
3796   return priority;
3797 }
3798
3799 /* The number of instructions that can be issued per cycle.  */
3800
3801 static int
3802 s390_issue_rate (void)
3803 {
3804   if (s390_tune == PROCESSOR_2084_Z990)
3805     return 3;
3806   return 1;
3807 }
3808
3809 /* If the following function returns TRUE, we will use the the DFA
3810    insn scheduler.  */
3811
3812 static int
3813 s390_use_dfa_pipeline_interface (void)
3814 {
3815   if (s390_tune == PROCESSOR_2064_Z900
3816       || s390_tune == PROCESSOR_2084_Z990)
3817     return 1;
3818
3819   return 0;
3820 }
3821
3822 static int
3823 s390_first_cycle_multipass_dfa_lookahead (void)
3824 {
3825   return s390_use_dfa_pipeline_interface () ? 4 : 0;
3826 }
3827
3828 /* Called after issuing each insn.
3829    Triggers default sort algorithm to better slot instructions.  */
3830
3831 static int
3832 s390_sched_reorder2 (FILE *dump ATTRIBUTE_UNUSED,
3833                      int sched_verbose ATTRIBUTE_UNUSED,
3834                      rtx *ready ATTRIBUTE_UNUSED,
3835                      int *pn_ready ATTRIBUTE_UNUSED,
3836                      int clock_var ATTRIBUTE_UNUSED)
3837 {
3838     return s390_issue_rate();
3839 }
3840
3841
3842 /* Split all branches that exceed the maximum distance.
3843    Returns true if this created a new literal pool entry.  */
3844
3845 static int
3846 s390_split_branches (void)
3847 {
3848   rtx temp_reg = gen_rtx_REG (Pmode, RETURN_REGNUM);
3849   int new_literal = 0;
3850   rtx insn, pat, tmp, target;
3851   rtx *label;
3852
3853   /* We need correct insn addresses.  */
3854
3855   shorten_branches (get_insns ());
3856
3857   /* Find all branches that exceed 64KB, and split them.  */
3858
3859   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3860     {
3861       if (GET_CODE (insn) != JUMP_INSN)
3862         continue;
3863
3864       pat = PATTERN (insn);
3865       if (GET_CODE (pat) == PARALLEL && XVECLEN (pat, 0) > 2)
3866         pat = XVECEXP (pat, 0, 0);
3867       if (GET_CODE (pat) != SET || SET_DEST (pat) != pc_rtx)
3868         continue;
3869
3870       if (GET_CODE (SET_SRC (pat)) == LABEL_REF)
3871         {
3872           label = &SET_SRC (pat);
3873         }
3874       else if (GET_CODE (SET_SRC (pat)) == IF_THEN_ELSE)
3875         {
3876           if (GET_CODE (XEXP (SET_SRC (pat), 1)) == LABEL_REF)
3877             label = &XEXP (SET_SRC (pat), 1);
3878           else if (GET_CODE (XEXP (SET_SRC (pat), 2)) == LABEL_REF)
3879             label = &XEXP (SET_SRC (pat), 2);
3880           else
3881             continue;
3882         }
3883       else
3884         continue;
3885
3886       if (get_attr_length (insn) <= 4)
3887         continue;
3888
3889       /* We are going to use the return register as scratch register,
3890          make sure it will be saved/restored by the prologue/epilogue.  */
3891       cfun->machine->save_return_addr_p = 1;
3892
3893       if (!flag_pic)
3894         {
3895           new_literal = 1;
3896           tmp = force_const_mem (Pmode, *label);
3897           tmp = emit_insn_before (gen_rtx_SET (Pmode, temp_reg, tmp), insn);
3898           INSN_ADDRESSES_NEW (tmp, -1);
3899
3900           target = temp_reg;
3901         }
3902       else
3903         {
3904           new_literal = 1;
3905           target = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, *label),
3906                                    UNSPEC_LTREL_OFFSET);
3907           target = gen_rtx_CONST (Pmode, target);
3908           target = force_const_mem (Pmode, target);
3909           tmp = emit_insn_before (gen_rtx_SET (Pmode, temp_reg, target), insn);
3910           INSN_ADDRESSES_NEW (tmp, -1);
3911
3912           target = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, XEXP (target, 0)),
3913                                    UNSPEC_LTREL_BASE);
3914           target = gen_rtx_PLUS (Pmode, temp_reg, target);
3915         }
3916
3917       if (!validate_change (insn, label, target, 0))
3918         abort ();
3919     }
3920
3921   return new_literal;
3922 }
3923
3924
3925 /* Find a literal pool symbol referenced in RTX X, and store
3926    it at REF.  Will abort if X contains references to more than
3927    one such pool symbol; multiple references to the same symbol
3928    are allowed, however.
3929
3930    The rtx pointed to by REF must be initialized to NULL_RTX
3931    by the caller before calling this routine.  */
3932
3933 static void
3934 find_constant_pool_ref (rtx x, rtx *ref)
3935 {
3936   int i, j;
3937   const char *fmt;
3938
3939   /* Ignore LTREL_BASE references.  */
3940   if (GET_CODE (x) == UNSPEC
3941       && XINT (x, 1) == UNSPEC_LTREL_BASE)
3942     return;
3943   /* Likewise POOL_ENTRY insns.  */
3944   if (GET_CODE (x) == UNSPEC_VOLATILE
3945       && XINT (x, 1) == UNSPECV_POOL_ENTRY)
3946     return;
3947
3948   if (GET_CODE (x) == SYMBOL_REF
3949       && CONSTANT_POOL_ADDRESS_P (x))
3950     {
3951       if (*ref == NULL_RTX)
3952         *ref = x;
3953       else if (*ref != x)
3954         abort();
3955     }
3956
3957   fmt = GET_RTX_FORMAT (GET_CODE (x));
3958   for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
3959     {
3960       if (fmt[i] == 'e')
3961         {
3962           find_constant_pool_ref (XEXP (x, i), ref);
3963         }
3964       else if (fmt[i] == 'E')
3965         {
3966           for (j = 0; j < XVECLEN (x, i); j++)
3967             find_constant_pool_ref (XVECEXP (x, i, j), ref);
3968         }
3969     }
3970 }
3971
3972 /* Replace every reference to the literal pool symbol REF
3973    in X by the address ADDR.  Fix up MEMs as required.  */
3974
3975 static void
3976 replace_constant_pool_ref (rtx *x, rtx ref, rtx addr)
3977 {
3978   int i, j;
3979   const char *fmt;
3980
3981   if (*x == ref)
3982     abort ();
3983
3984   /* Literal pool references can only occur inside a MEM ...  */
3985   if (GET_CODE (*x) == MEM)
3986     {
3987       rtx memref = XEXP (*x, 0);
3988
3989       if (memref == ref)
3990         {
3991           *x = replace_equiv_address (*x, addr);
3992           return;
3993         }
3994
3995       if (GET_CODE (memref) == CONST
3996           && GET_CODE (XEXP (memref, 0)) == PLUS
3997           && GET_CODE (XEXP (XEXP (memref, 0), 1)) == CONST_INT
3998           && XEXP (XEXP (memref, 0), 0) == ref)
3999         {
4000           HOST_WIDE_INT off = INTVAL (XEXP (XEXP (memref, 0), 1));
4001           *x = replace_equiv_address (*x, plus_constant (addr, off));
4002           return;
4003         }
4004     }
4005
4006   /* ... or a load-address type pattern.  */
4007   if (GET_CODE (*x) == SET)
4008     {
4009       rtx addrref = SET_SRC (*x);
4010
4011       if (addrref == ref)
4012         {
4013           SET_SRC (*x) = addr;
4014           return;
4015         }
4016
4017       if (GET_CODE (addrref) == CONST
4018           && GET_CODE (XEXP (addrref, 0)) == PLUS
4019           && GET_CODE (XEXP (XEXP (addrref, 0), 1)) == CONST_INT
4020           && XEXP (XEXP (addrref, 0), 0) == ref)
4021         {
4022           HOST_WIDE_INT off = INTVAL (XEXP (XEXP (addrref, 0), 1));
4023           SET_SRC (*x) = plus_constant (addr, off);
4024           return;
4025         }
4026     }
4027
4028   fmt = GET_RTX_FORMAT (GET_CODE (*x));
4029   for (i = GET_RTX_LENGTH (GET_CODE (*x)) - 1; i >= 0; i--)
4030     {
4031       if (fmt[i] == 'e')
4032         {
4033           replace_constant_pool_ref (&XEXP (*x, i), ref, addr);
4034         }
4035       else if (fmt[i] == 'E')
4036         {
4037           for (j = 0; j < XVECLEN (*x, i); j++)
4038             replace_constant_pool_ref (&XVECEXP (*x, i, j), ref, addr);
4039         }
4040     }
4041 }
4042
4043 /* Check whether X contains an UNSPEC_LTREL_BASE.
4044    Return its constant pool symbol if found, NULL_RTX otherwise.  */
4045
4046 static rtx
4047 find_ltrel_base (rtx x)
4048 {
4049   int i, j;
4050   const char *fmt;
4051
4052   if (GET_CODE (x) == UNSPEC
4053       && XINT (x, 1) == UNSPEC_LTREL_BASE)
4054     return XVECEXP (x, 0, 0);
4055
4056   fmt = GET_RTX_FORMAT (GET_CODE (x));
4057   for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
4058     {
4059       if (fmt[i] == 'e')
4060         {
4061           rtx fnd = find_ltrel_base (XEXP (x, i));
4062           if (fnd)
4063             return fnd;
4064         }
4065       else if (fmt[i] == 'E')
4066         {
4067           for (j = 0; j < XVECLEN (x, i); j++)
4068             {
4069               rtx fnd = find_ltrel_base (XVECEXP (x, i, j));
4070               if (fnd)
4071                 return fnd;
4072             }
4073         }
4074     }
4075
4076   return NULL_RTX;
4077 }
4078
4079 /* Replace any occurrence of UNSPEC_LTREL_BASE in X with BASE.  */
4080
4081 static void
4082 replace_ltrel_base (rtx *x, rtx base)
4083 {
4084   int i, j;
4085   const char *fmt;
4086
4087   if (GET_CODE (*x) == UNSPEC
4088       && XINT (*x, 1) == UNSPEC_LTREL_BASE)
4089     {
4090       *x = base;
4091       return;
4092     }
4093
4094   fmt = GET_RTX_FORMAT (GET_CODE (*x));
4095   for (i = GET_RTX_LENGTH (GET_CODE (*x)) - 1; i >= 0; i--)
4096     {
4097       if (fmt[i] == 'e')
4098         {
4099           replace_ltrel_base (&XEXP (*x, i), base);
4100         }
4101       else if (fmt[i] == 'E')
4102         {
4103           for (j = 0; j < XVECLEN (*x, i); j++)
4104             replace_ltrel_base (&XVECEXP (*x, i, j), base);
4105         }
4106     }
4107 }
4108
4109
4110 /* We keep a list of constants which we have to add to internal
4111    constant tables in the middle of large functions.  */
4112
4113 #define NR_C_MODES 7
4114 enum machine_mode constant_modes[NR_C_MODES] =
4115 {
4116   TImode,
4117   DFmode, DImode,
4118   SFmode, SImode,
4119   HImode,
4120   QImode
4121 };
4122
4123 struct constant
4124 {
4125   struct constant *next;
4126   rtx value;
4127   rtx label;
4128 };
4129
4130 struct constant_pool
4131 {
4132   struct constant_pool *next;
4133   rtx first_insn;
4134   rtx pool_insn;
4135   bitmap insns;
4136
4137   struct constant *constants[NR_C_MODES];
4138   rtx label;
4139   int size;
4140 };
4141
4142 static struct constant_pool * s390_mainpool_start (void);
4143 static void s390_mainpool_finish (struct constant_pool *, rtx base_reg);
4144 static void s390_mainpool_cancel (struct constant_pool *);
4145
4146 static struct constant_pool * s390_chunkify_start (rtx base_reg);
4147 static void s390_chunkify_finish (struct constant_pool *, rtx base_reg);
4148 static void s390_chunkify_cancel (struct constant_pool *);
4149
4150 static struct constant_pool *s390_start_pool (struct constant_pool **, rtx);
4151 static void s390_end_pool (struct constant_pool *, rtx);
4152 static void s390_add_pool_insn (struct constant_pool *, rtx);
4153 static struct constant_pool *s390_find_pool (struct constant_pool *, rtx);
4154 static void s390_add_constant (struct constant_pool *, rtx, enum machine_mode);
4155 static rtx s390_find_constant (struct constant_pool *, rtx, enum machine_mode);
4156 static rtx s390_dump_pool (struct constant_pool *, bool);
4157 static struct constant_pool *s390_alloc_pool (void);
4158 static void s390_free_pool (struct constant_pool *);
4159
4160 /* Create new constant pool covering instructions starting at INSN
4161    and chain it to the end of POOL_LIST.  */
4162
4163 static struct constant_pool *
4164 s390_start_pool (struct constant_pool **pool_list, rtx insn)
4165 {
4166   struct constant_pool *pool, **prev;
4167
4168   pool = s390_alloc_pool ();
4169   pool->first_insn = insn;
4170
4171   for (prev = pool_list; *prev; prev = &(*prev)->next)
4172     ;
4173   *prev = pool;
4174
4175   return pool;
4176 }
4177
4178 /* End range of instructions covered by POOL at INSN and emit
4179    placeholder insn representing the pool.  */
4180
4181 static void
4182 s390_end_pool (struct constant_pool *pool, rtx insn)
4183 {
4184   rtx pool_size = GEN_INT (pool->size + 8 /* alignment slop */);
4185
4186   if (!insn)
4187     insn = get_last_insn ();
4188
4189   pool->pool_insn = emit_insn_after (gen_pool (pool_size), insn);
4190   INSN_ADDRESSES_NEW (pool->pool_insn, -1);
4191 }
4192
4193 /* Add INSN to the list of insns covered by POOL.  */
4194
4195 static void
4196 s390_add_pool_insn (struct constant_pool *pool, rtx insn)
4197 {
4198   bitmap_set_bit (pool->insns, INSN_UID (insn));
4199 }
4200
4201 /* Return pool out of POOL_LIST that covers INSN.  */
4202
4203 static struct constant_pool *
4204 s390_find_pool (struct constant_pool *pool_list, rtx insn)
4205 {
4206   struct constant_pool *pool;
4207
4208   for (pool = pool_list; pool; pool = pool->next)
4209     if (bitmap_bit_p (pool->insns, INSN_UID (insn)))
4210       break;
4211
4212   return pool;
4213 }
4214
4215 /* Add constant VAL of mode MODE to the constant pool POOL.  */
4216
4217 static void
4218 s390_add_constant (struct constant_pool *pool, rtx val, enum machine_mode mode)
4219 {
4220   struct constant *c;
4221   int i;
4222
4223   for (i = 0; i < NR_C_MODES; i++)
4224     if (constant_modes[i] == mode)
4225       break;
4226   if (i == NR_C_MODES)
4227     abort ();
4228
4229   for (c = pool->constants[i]; c != NULL; c = c->next)
4230     if (rtx_equal_p (val, c->value))
4231       break;
4232
4233   if (c == NULL)
4234     {
4235       c = (struct constant *) xmalloc (sizeof *c);
4236       c->value = val;
4237       c->label = gen_label_rtx ();
4238       c->next = pool->constants[i];
4239       pool->constants[i] = c;
4240       pool->size += GET_MODE_SIZE (mode);
4241     }
4242 }
4243
4244 /* Find constant VAL of mode MODE in the constant pool POOL.
4245    Return an RTX describing the distance from the start of
4246    the pool to the location of the new constant.  */
4247
4248 static rtx
4249 s390_find_constant (struct constant_pool *pool, rtx val,
4250                     enum machine_mode mode)
4251 {
4252   struct constant *c;
4253   rtx offset;
4254   int i;
4255
4256   for (i = 0; i < NR_C_MODES; i++)
4257     if (constant_modes[i] == mode)
4258       break;
4259   if (i == NR_C_MODES)
4260     abort ();
4261
4262   for (c = pool->constants[i]; c != NULL; c = c->next)
4263     if (rtx_equal_p (val, c->value))
4264       break;
4265
4266   if (c == NULL)
4267     abort ();
4268
4269   offset = gen_rtx_MINUS (Pmode, gen_rtx_LABEL_REF (Pmode, c->label),
4270                                  gen_rtx_LABEL_REF (Pmode, pool->label));
4271   offset = gen_rtx_CONST (Pmode, offset);
4272   return offset;
4273 }
4274
4275 /* Dump out the constants in POOL.  If REMOTE_LABEL is true,
4276    do not emit the pool base label.  */
4277
4278 static rtx
4279 s390_dump_pool (struct constant_pool *pool, bool remote_label)
4280 {
4281   struct constant *c;
4282   rtx insn;
4283   int i;
4284
4285   /* Pool start insn switches to proper section
4286      and guarantees necessary alignment.  */
4287   if (TARGET_CPU_ZARCH)
4288     insn = emit_insn_after (gen_pool_start_64 (), pool->pool_insn);
4289   else
4290     insn = emit_insn_after (gen_pool_start_31 (), pool->pool_insn);
4291   INSN_ADDRESSES_NEW (insn, -1);
4292
4293   if (!remote_label)
4294     {
4295       insn = emit_label_after (pool->label, insn);
4296       INSN_ADDRESSES_NEW (insn, -1);
4297     }
4298
4299   /* Dump constants in descending alignment requirement order,
4300      ensuring proper alignment for every constant.  */
4301   for (i = 0; i < NR_C_MODES; i++)
4302     for (c = pool->constants[i]; c; c = c->next)
4303       {
4304         /* Convert UNSPEC_LTREL_OFFSET unspecs to pool-relative references.  */
4305         rtx value = c->value;
4306         if (GET_CODE (value) == CONST
4307             && GET_CODE (XEXP (value, 0)) == UNSPEC
4308             && XINT (XEXP (value, 0), 1) == UNSPEC_LTREL_OFFSET
4309             && XVECLEN (XEXP (value, 0), 0) == 1)
4310           {
4311             value = gen_rtx_MINUS (Pmode, XVECEXP (XEXP (value, 0), 0, 0),
4312                                    gen_rtx_LABEL_REF (VOIDmode, pool->label));
4313             value = gen_rtx_CONST (VOIDmode, value);
4314           }
4315
4316         insn = emit_label_after (c->label, insn);
4317         INSN_ADDRESSES_NEW (insn, -1);
4318
4319         value = gen_rtx_UNSPEC_VOLATILE (constant_modes[i],
4320                                          gen_rtvec (1, value),
4321                                          UNSPECV_POOL_ENTRY);
4322         insn = emit_insn_after (value, insn);
4323         INSN_ADDRESSES_NEW (insn, -1);
4324       }
4325
4326   /* Pool end insn switches back to previous section
4327      and guarantees necessary alignment.  */
4328   if (TARGET_CPU_ZARCH)
4329     insn = emit_insn_after (gen_pool_end_64 (), insn);
4330   else
4331     insn = emit_insn_after (gen_pool_end_31 (), insn);
4332   INSN_ADDRESSES_NEW (insn, -1);
4333
4334   insn = emit_barrier_after (insn);
4335   INSN_ADDRESSES_NEW (insn, -1);
4336
4337   /* Remove placeholder insn.  */
4338   remove_insn (pool->pool_insn);
4339
4340   return insn;
4341 }
4342
4343 /* Allocate new constant_pool structure.  */
4344
4345 static struct constant_pool *
4346 s390_alloc_pool (void)
4347 {
4348   struct constant_pool *pool;
4349   int i;
4350
4351   pool = (struct constant_pool *) xmalloc (sizeof *pool);
4352   pool->next = NULL;
4353   for (i = 0; i < NR_C_MODES; i++)
4354     pool->constants[i] = NULL;
4355
4356   pool->label = gen_label_rtx ();
4357   pool->first_insn = NULL_RTX;
4358   pool->pool_insn = NULL_RTX;
4359   pool->insns = BITMAP_XMALLOC ();
4360   pool->size = 0;
4361
4362   return pool;
4363 }
4364
4365 /* Free all memory used by POOL.  */
4366
4367 static void
4368 s390_free_pool (struct constant_pool *pool)
4369 {
4370   int i;
4371
4372   for (i = 0; i < NR_C_MODES; i++)
4373     {
4374       struct constant *c = pool->constants[i];
4375       while (c != NULL)
4376         {
4377           struct constant *next = c->next;
4378           free (c);
4379           c = next;
4380         }
4381     }
4382
4383   BITMAP_XFREE (pool->insns);
4384   free (pool);
4385 }
4386
4387
4388 /* Collect main literal pool.  Return NULL on overflow.  */
4389
4390 static struct constant_pool *
4391 s390_mainpool_start (void)
4392 {
4393   struct constant_pool *pool;
4394   rtx insn;
4395
4396   pool = s390_alloc_pool ();
4397
4398   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4399     {
4400       if (GET_CODE (insn) == INSN
4401           && GET_CODE (PATTERN (insn)) == UNSPEC_VOLATILE
4402           && XINT (PATTERN (insn), 1) == UNSPECV_MAIN_POOL)
4403         {
4404           if (pool->pool_insn)
4405             abort ();
4406           pool->pool_insn = insn;
4407         }
4408
4409       if (GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN)
4410         {
4411           rtx pool_ref = NULL_RTX;
4412           find_constant_pool_ref (PATTERN (insn), &pool_ref);
4413           if (pool_ref)
4414             {
4415               rtx constant = get_pool_constant (pool_ref);
4416               enum machine_mode mode = get_pool_mode (pool_ref);
4417               s390_add_constant (pool, constant, mode);
4418             }
4419         }
4420     }
4421
4422   if (!pool->pool_insn)
4423     abort ();
4424
4425   if (pool->size >= 4096)
4426     {
4427       s390_free_pool (pool);
4428       pool = NULL;
4429     }
4430
4431   return pool;
4432 }
4433
4434 /* POOL holds the main literal pool as collected by s390_mainpool_start.
4435    Modify the current function to output the pool constants as well as
4436    the pool register setup instruction.  BASE_REG is the register to
4437    be used as pool base register.  */
4438
4439 static void
4440 s390_mainpool_finish (struct constant_pool *pool, rtx base_reg)
4441 {
4442   rtx insn;
4443
4444   /* If the pool is empty, we're done.  */
4445   if (pool->size == 0)
4446     {
4447       remove_insn (pool->pool_insn);
4448       s390_free_pool (pool);
4449       return;
4450     }
4451
4452   /* We need correct insn addresses.  */
4453   shorten_branches (get_insns ());
4454
4455   /* On zSeries, we use a LARL to load the pool register.  The pool is
4456      located in the .rodata section, so we emit it after the function.  */
4457   if (TARGET_CPU_ZARCH)
4458     {
4459       insn = gen_main_base_64 (base_reg, pool->label);
4460       insn = emit_insn_after (insn, pool->pool_insn);
4461       INSN_ADDRESSES_NEW (insn, -1);
4462       remove_insn (pool->pool_insn);
4463
4464       insn = get_last_insn ();
4465       pool->pool_insn = emit_insn_after (gen_pool (const0_rtx), insn);
4466       INSN_ADDRESSES_NEW (pool->pool_insn, -1);
4467
4468       s390_dump_pool (pool, 0);
4469     }
4470
4471   /* On S/390, if the total size of the function's code plus literal pool
4472      does not exceed 4096 bytes, we use BASR to set up a function base
4473      pointer, and emit the literal pool at the end of the function.  */
4474   else if (INSN_ADDRESSES (INSN_UID (get_last_insn ()))
4475            + pool->size + 8 /* alignment slop */ < 4096)
4476     {
4477       insn = gen_main_base_31_small (base_reg, pool->label);
4478       insn = emit_insn_after (insn, pool->pool_insn);
4479       INSN_ADDRESSES_NEW (insn, -1);
4480       remove_insn (pool->pool_insn);
4481
4482       insn = emit_label_after (pool->label, insn);
4483       INSN_ADDRESSES_NEW (insn, -1);
4484
4485       insn = get_last_insn ();
4486       pool->pool_insn = emit_insn_after (gen_pool (const0_rtx), insn);
4487       INSN_ADDRESSES_NEW (pool->pool_insn, -1);
4488
4489       s390_dump_pool (pool, 1);
4490     }
4491
4492   /* Otherwise, we emit an inline literal pool and use BASR to branch
4493      over it, setting up the pool register at the same time.  */
4494   else
4495     {
4496       rtx pool_end = gen_label_rtx ();
4497
4498       insn = gen_main_base_31_large (base_reg, pool->label, pool_end);
4499       insn = emit_insn_after (insn, pool->pool_insn);
4500       INSN_ADDRESSES_NEW (insn, -1);
4501       remove_insn (pool->pool_insn);
4502
4503       insn = emit_label_after (pool->label, insn);
4504       INSN_ADDRESSES_NEW (insn, -1);
4505
4506       pool->pool_insn = emit_insn_after (gen_pool (const0_rtx), insn);
4507       INSN_ADDRESSES_NEW (pool->pool_insn, -1);
4508
4509       insn = emit_label_after (pool_end, pool->pool_insn);
4510       INSN_ADDRESSES_NEW (insn, -1);
4511
4512       s390_dump_pool (pool, 1);
4513     }
4514
4515
4516   /* Replace all literal pool references.  */
4517
4518   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4519     {
4520       if (INSN_P (insn))
4521         replace_ltrel_base (&PATTERN (insn), base_reg);
4522
4523       if (GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN)
4524         {
4525           rtx addr, pool_ref = NULL_RTX;
4526           find_constant_pool_ref (PATTERN (insn), &pool_ref);
4527           if (pool_ref)
4528             {
4529               addr = s390_find_constant (pool, get_pool_constant (pool_ref),
4530                                                get_pool_mode (pool_ref));
4531               addr = gen_rtx_PLUS (Pmode, base_reg, addr);
4532               replace_constant_pool_ref (&PATTERN (insn), pool_ref, addr);
4533               INSN_CODE (insn) = -1;
4534             }
4535         }
4536     }
4537
4538
4539   /* Free the pool.  */
4540   s390_free_pool (pool);
4541 }
4542
4543 /* POOL holds the main literal pool as collected by s390_mainpool_start.
4544    We have decided we cannot use this pool, so revert all changes
4545    to the current function that were done by s390_mainpool_start.  */
4546 static void
4547 s390_mainpool_cancel (struct constant_pool *pool)
4548 {
4549   /* We didn't actually change the instruction stream, so simply
4550      free the pool memory.  */
4551   s390_free_pool (pool);
4552 }
4553
4554
4555 /* Chunkify the literal pool.  BASE_REG is to be used as pool
4556    register.  */
4557
4558 #define S390_POOL_CHUNK_MIN     0xc00
4559 #define S390_POOL_CHUNK_MAX     0xe00
4560
4561 static struct constant_pool *
4562 s390_chunkify_start (rtx base_reg)
4563 {
4564   struct constant_pool *curr_pool = NULL, *pool_list = NULL;
4565   int extra_size = 0;
4566   bitmap far_labels;
4567   rtx pending_ltrel = NULL_RTX;
4568   rtx insn;
4569
4570   rtx (*gen_reload_base) (rtx, rtx) =
4571     TARGET_CPU_ZARCH? gen_reload_base_64 : gen_reload_base_31;
4572
4573
4574   /* We need correct insn addresses.  */
4575
4576   shorten_branches (get_insns ());
4577
4578   /* Scan all insns and move literals to pool chunks.  */
4579
4580   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4581     {
4582       /* Check for pending LTREL_BASE.  */
4583       if (INSN_P (insn))
4584         {
4585           rtx ltrel_base = find_ltrel_base (PATTERN (insn));
4586           if (ltrel_base)
4587             {
4588               if (ltrel_base == pending_ltrel)
4589                 pending_ltrel = NULL_RTX;
4590               else
4591                 abort ();
4592             }
4593         }
4594
4595       if (GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN)
4596         {
4597           rtx pool_ref = NULL_RTX;
4598           find_constant_pool_ref (PATTERN (insn), &pool_ref);
4599           if (pool_ref)
4600             {
4601               rtx constant = get_pool_constant (pool_ref);
4602               enum machine_mode mode = get_pool_mode (pool_ref);
4603
4604               if (!curr_pool)
4605                 curr_pool = s390_start_pool (&pool_list, insn);
4606
4607               s390_add_constant (curr_pool, constant, mode);
4608               s390_add_pool_insn (curr_pool, insn);
4609
4610               /* Don't split the pool chunk between a LTREL_OFFSET load
4611                  and the corresponding LTREL_BASE.  */
4612               if (GET_CODE (constant) == CONST
4613                   && GET_CODE (XEXP (constant, 0)) == UNSPEC
4614                   && XINT (XEXP (constant, 0), 1) == UNSPEC_LTREL_OFFSET)
4615                 {
4616                   if (pending_ltrel)
4617                     abort ();
4618                   pending_ltrel = pool_ref;
4619                 }
4620             }
4621         }
4622
4623       if (GET_CODE (insn) == JUMP_INSN || GET_CODE (insn) == CODE_LABEL)
4624         {
4625           if (curr_pool)
4626             s390_add_pool_insn (curr_pool, insn);
4627           /* An LTREL_BASE must follow within the same basic block.  */
4628           if (pending_ltrel)
4629             abort ();
4630         }
4631
4632       if (!curr_pool
4633           || INSN_ADDRESSES_SIZE () <= (size_t) INSN_UID (insn)
4634           || INSN_ADDRESSES (INSN_UID (insn)) == -1)
4635         continue;
4636
4637       if (TARGET_CPU_ZARCH)
4638         {
4639           if (curr_pool->size < S390_POOL_CHUNK_MAX)
4640             continue;
4641
4642           s390_end_pool (curr_pool, NULL_RTX);
4643           curr_pool = NULL;
4644         }
4645       else
4646         {
4647           int chunk_size = INSN_ADDRESSES (INSN_UID (insn))
4648                            - INSN_ADDRESSES (INSN_UID (curr_pool->first_insn))
4649                          + extra_size;
4650
4651           /* We will later have to insert base register reload insns.
4652              Those will have an effect on code size, which we need to
4653              consider here.  This calculation makes rather pessimistic
4654              worst-case assumptions.  */
4655           if (GET_CODE (insn) == CODE_LABEL)
4656             extra_size += 6;
4657
4658           if (chunk_size < S390_POOL_CHUNK_MIN
4659               && curr_pool->size < S390_POOL_CHUNK_MIN)
4660             continue;
4661
4662           /* Pool chunks can only be inserted after BARRIERs ...  */
4663           if (GET_CODE (insn) == BARRIER)
4664             {
4665               s390_end_pool (curr_pool, insn);
4666               curr_pool = NULL;
4667               extra_size = 0;
4668             }
4669
4670           /* ... so if we don't find one in time, create one.  */
4671           else if ((chunk_size > S390_POOL_CHUNK_MAX
4672                    || curr_pool->size > S390_POOL_CHUNK_MAX))
4673             {
4674               rtx label, jump, barrier;
4675
4676               /* We can insert the barrier only after a 'real' insn.  */
4677               if (GET_CODE (insn) != INSN && GET_CODE (insn) != CALL_INSN)
4678                 continue;
4679               if (get_attr_length (insn) == 0)
4680                 continue;
4681
4682               /* Don't separate LTREL_BASE from the corresponding
4683                  LTREL_OFFSET load.  */
4684               if (pending_ltrel)
4685                 continue;
4686
4687               label = gen_label_rtx ();
4688               jump = emit_jump_insn_after (gen_jump (label), insn);
4689               barrier = emit_barrier_after (jump);
4690               insn = emit_label_after (label, barrier);
4691               JUMP_LABEL (jump) = label;
4692               LABEL_NUSES (label) = 1;
4693
4694               INSN_ADDRESSES_NEW (jump, -1);
4695               INSN_ADDRESSES_NEW (barrier, -1);
4696               INSN_ADDRESSES_NEW (insn, -1);
4697
4698               s390_end_pool (curr_pool, barrier);
4699               curr_pool = NULL;
4700               extra_size = 0;
4701             }
4702         }
4703     }
4704
4705   if (curr_pool)
4706     s390_end_pool (curr_pool, NULL_RTX);
4707   if (pending_ltrel)
4708     abort ();
4709
4710
4711   /* Find all labels that are branched into
4712      from an insn belonging to a different chunk.  */
4713
4714   far_labels = BITMAP_XMALLOC ();
4715
4716   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4717     {
4718       /* Labels marked with LABEL_PRESERVE_P can be target
4719          of non-local jumps, so we have to mark them.
4720          The same holds for named labels.
4721
4722          Don't do that, however, if it is the label before
4723          a jump table.  */
4724
4725       if (GET_CODE (insn) == CODE_LABEL
4726           && (LABEL_PRESERVE_P (insn) || LABEL_NAME (insn)))
4727         {
4728           rtx vec_insn = next_real_insn (insn);
4729           rtx vec_pat = vec_insn && GET_CODE (vec_insn) == JUMP_INSN ?
4730                         PATTERN (vec_insn) : NULL_RTX;
4731           if (!vec_pat
4732               || !(GET_CODE (vec_pat) == ADDR_VEC
4733                    || GET_CODE (vec_pat) == ADDR_DIFF_VEC))
4734             bitmap_set_bit (far_labels, CODE_LABEL_NUMBER (insn));
4735         }
4736
4737       /* If we have a direct jump (conditional or unconditional)
4738          or a casesi jump, check all potential targets.  */
4739       else if (GET_CODE (insn) == JUMP_INSN)
4740         {
4741           rtx pat = PATTERN (insn);
4742           if (GET_CODE (pat) == PARALLEL && XVECLEN (pat, 0) > 2)
4743             pat = XVECEXP (pat, 0, 0);
4744
4745           if (GET_CODE (pat) == SET)
4746             {
4747               rtx label = JUMP_LABEL (insn);
4748               if (label)
4749                 {
4750                   if (s390_find_pool (pool_list, label)
4751                       != s390_find_pool (pool_list, insn))
4752                     bitmap_set_bit (far_labels, CODE_LABEL_NUMBER (label));
4753                 }
4754             }
4755           else if (GET_CODE (pat) == PARALLEL
4756                    && XVECLEN (pat, 0) == 2
4757                    && GET_CODE (XVECEXP (pat, 0, 0)) == SET
4758                    && GET_CODE (XVECEXP (pat, 0, 1)) == USE
4759                    && GET_CODE (XEXP (XVECEXP (pat, 0, 1), 0)) == LABEL_REF)
4760             {
4761               /* Find the jump table used by this casesi jump.  */
4762               rtx vec_label = XEXP (XEXP (XVECEXP (pat, 0, 1), 0), 0);
4763               rtx vec_insn = next_real_insn (vec_label);
4764               rtx vec_pat = vec_insn && GET_CODE (vec_insn) == JUMP_INSN ?
4765                             PATTERN (vec_insn) : NULL_RTX;
4766               if (vec_pat
4767                   && (GET_CODE (vec_pat) == ADDR_VEC
4768                       || GET_CODE (vec_pat) == ADDR_DIFF_VEC))
4769                 {
4770                   int i, diff_p = GET_CODE (vec_pat) == ADDR_DIFF_VEC;
4771
4772                   for (i = 0; i < XVECLEN (vec_pat, diff_p); i++)
4773                     {
4774                       rtx label = XEXP (XVECEXP (vec_pat, diff_p, i), 0);
4775
4776                       if (s390_find_pool (pool_list, label)
4777                           != s390_find_pool (pool_list, insn))
4778                         bitmap_set_bit (far_labels, CODE_LABEL_NUMBER (label));
4779                     }
4780                 }
4781             }
4782         }
4783     }
4784
4785   /* Insert base register reload insns before every pool.  */
4786
4787   for (curr_pool = pool_list; curr_pool; curr_pool = curr_pool->next)
4788     {
4789       rtx new_insn = gen_reload_base (base_reg, curr_pool->label);
4790       rtx insn = curr_pool->first_insn;
4791       INSN_ADDRESSES_NEW (emit_insn_before (new_insn, insn), -1);
4792     }
4793
4794   /* Insert base register reload insns at every far label.  */
4795
4796   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4797     if (GET_CODE (insn) == CODE_LABEL
4798         && bitmap_bit_p (far_labels, CODE_LABEL_NUMBER (insn)))
4799       {
4800         struct constant_pool *pool = s390_find_pool (pool_list, insn);
4801         if (pool)
4802           {
4803             rtx new_insn = gen_reload_base (base_reg, pool->label);
4804             INSN_ADDRESSES_NEW (emit_insn_after (new_insn, insn), -1);
4805           }
4806       }
4807
4808
4809   BITMAP_XFREE (far_labels);
4810
4811
4812   /* Recompute insn addresses.  */
4813
4814   init_insn_lengths ();
4815   shorten_branches (get_insns ());
4816
4817   return pool_list;
4818 }
4819
4820 /* POOL_LIST is a chunk list as prepared by s390_chunkify_start.
4821    After we have decided to use this list, finish implementing
4822    all changes to the current function as required.  BASE_REG is
4823    to be used as pool base register.  */
4824
4825 static void
4826 s390_chunkify_finish (struct constant_pool *pool_list, rtx base_reg)
4827 {
4828   struct constant_pool *curr_pool = NULL;
4829   rtx insn;
4830
4831
4832   /* Replace all literal pool references.  */
4833
4834   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4835     {
4836       if (INSN_P (insn))
4837         replace_ltrel_base (&PATTERN (insn), base_reg);
4838
4839       curr_pool = s390_find_pool (pool_list, insn);
4840       if (!curr_pool)
4841         continue;
4842
4843       if (GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN)
4844         {
4845           rtx addr, pool_ref = NULL_RTX;
4846           find_constant_pool_ref (PATTERN (insn), &pool_ref);
4847           if (pool_ref)
4848             {
4849               addr = s390_find_constant (curr_pool, get_pool_constant (pool_ref),
4850                                                     get_pool_mode (pool_ref));
4851               addr = gen_rtx_PLUS (Pmode, base_reg, addr);
4852               replace_constant_pool_ref (&PATTERN (insn), pool_ref, addr);
4853               INSN_CODE (insn) = -1;
4854             }
4855         }
4856     }
4857
4858   /* Dump out all literal pools.  */
4859
4860   for (curr_pool = pool_list; curr_pool; curr_pool = curr_pool->next)
4861     s390_dump_pool (curr_pool, 0);
4862
4863   /* Free pool list.  */
4864
4865   while (pool_list)
4866     {
4867       struct constant_pool *next = pool_list->next;
4868       s390_free_pool (pool_list);
4869       pool_list = next;
4870     }
4871 }
4872
4873 /* POOL_LIST is a chunk list as prepared by s390_chunkify_start.
4874    We have decided we cannot use this list, so revert all changes
4875    to the current function that were done by s390_chunkify_start.  */
4876
4877 static void
4878 s390_chunkify_cancel (struct constant_pool *pool_list)
4879 {
4880   struct constant_pool *curr_pool = NULL;
4881   rtx insn;
4882
4883   /* Remove all pool placeholder insns.  */
4884
4885   for (curr_pool = pool_list; curr_pool; curr_pool = curr_pool->next)
4886     {
4887       /* Did we insert an extra barrier?  Remove it.  */
4888       rtx barrier = PREV_INSN (curr_pool->pool_insn);
4889       rtx jump = barrier? PREV_INSN (barrier) : NULL_RTX;
4890       rtx label = NEXT_INSN (curr_pool->pool_insn);
4891
4892       if (jump && GET_CODE (jump) == JUMP_INSN
4893           && barrier && GET_CODE (barrier) == BARRIER
4894           && label && GET_CODE (label) == CODE_LABEL
4895           && GET_CODE (PATTERN (jump)) == SET
4896           && SET_DEST (PATTERN (jump)) == pc_rtx
4897           && GET_CODE (SET_SRC (PATTERN (jump))) == LABEL_REF
4898           && XEXP (SET_SRC (PATTERN (jump)), 0) == label)
4899         {
4900           remove_insn (jump);
4901           remove_insn (barrier);
4902           remove_insn (label);
4903         }
4904
4905       remove_insn (curr_pool->pool_insn);
4906     }
4907
4908   /* Remove all base register reload insns.  */
4909
4910   for (insn = get_insns (); insn; )
4911     {
4912       rtx next_insn = NEXT_INSN (insn);
4913
4914       if (GET_CODE (insn) == INSN
4915           && GET_CODE (PATTERN (insn)) == SET
4916           && GET_CODE (SET_SRC (PATTERN (insn))) == UNSPEC
4917           && XINT (SET_SRC (PATTERN (insn)), 1) == UNSPEC_RELOAD_BASE)
4918         remove_insn (insn);
4919
4920       insn = next_insn;
4921     }
4922
4923   /* Free pool list.  */
4924
4925   while (pool_list)
4926     {
4927       struct constant_pool *next = pool_list->next;
4928       s390_free_pool (pool_list);
4929       pool_list = next;
4930     }
4931 }
4932
4933
4934 /* Output to FILE the constant pool entry EXP in mode MODE
4935    with alignment ALIGN.  */
4936
4937 void
4938 s390_output_pool_entry (FILE *file, rtx exp, enum machine_mode mode,
4939                         unsigned int align)
4940 {
4941   REAL_VALUE_TYPE r;
4942
4943   switch (GET_MODE_CLASS (mode))
4944     {
4945     case MODE_FLOAT:
4946       if (GET_CODE (exp) != CONST_DOUBLE)
4947         abort ();
4948
4949       REAL_VALUE_FROM_CONST_DOUBLE (r, exp);
4950       assemble_real (r, mode, align);
4951       break;
4952
4953     case MODE_INT:
4954       if (GET_CODE (exp) == CONST
4955           || GET_CODE (exp) == SYMBOL_REF
4956           || GET_CODE (exp) == LABEL_REF)
4957         {
4958           fputs (integer_asm_op (GET_MODE_SIZE (mode), TRUE), file);
4959           s390_output_symbolic_const (file, exp);
4960           fputc ('\n', file);
4961         }
4962       else
4963         {
4964           assemble_integer (exp, GET_MODE_SIZE (mode), align, 1);
4965         }
4966       break;
4967
4968     default:
4969       abort ();
4970     }
4971 }
4972
4973
4974 /* Rework the prolog/epilog to avoid saving/restoring
4975    registers unnecessarily.  BASE_USED specifies whether
4976    the literal pool base register needs to be saved.  */
4977
4978 static void
4979 s390_optimize_prolog (bool base_used)
4980 {
4981   int save_first, save_last, restore_first, restore_last;
4982   int i, j;
4983   rtx insn, new_insn, next_insn;
4984
4985   /* Recompute regs_ever_live data for special registers.  */
4986   regs_ever_live[BASE_REGISTER] = base_used;
4987   regs_ever_live[RETURN_REGNUM] = cfun->machine->save_return_addr_p;
4988   regs_ever_live[STACK_POINTER_REGNUM] = cfun->machine->frame_size > 0;
4989
4990
4991   /* Find first and last gpr to be saved.  */
4992
4993   for (i = 6; i < 16; i++)
4994     if (regs_ever_live[i])
4995       if (!global_regs[i]
4996           || i == STACK_POINTER_REGNUM
4997           || i == RETURN_REGNUM
4998           || i == BASE_REGISTER
4999           || (flag_pic && i == (int)PIC_OFFSET_TABLE_REGNUM))
5000         break;
5001
5002   for (j = 15; j > i; j--)
5003     if (regs_ever_live[j])
5004       if (!global_regs[j]
5005           || j == STACK_POINTER_REGNUM
5006           || j == RETURN_REGNUM
5007           || j == BASE_REGISTER
5008           || (flag_pic && j == (int)PIC_OFFSET_TABLE_REGNUM))
5009         break;
5010
5011   if (i == 16)
5012     {
5013       /* Nothing to save/restore.  */
5014       save_first = restore_first = -1;
5015       save_last = restore_last = -1;
5016     }
5017   else
5018     {
5019       /* Save/restore from i to j.  */
5020       save_first = restore_first = i;
5021       save_last = restore_last = j;
5022     }
5023
5024   /* Varargs functions need to save gprs 2 to 6.  */
5025   if (current_function_stdarg)
5026     {
5027       save_first = 2;
5028       if (save_last < 6)
5029         save_last = 6;
5030     }
5031
5032
5033   /* If all special registers are in fact used, there's nothing we
5034      can do, so no point in walking the insn list.  */
5035   if (i <= BASE_REGISTER && j >= BASE_REGISTER
5036       && (TARGET_CPU_ZARCH || (i <= RETURN_REGNUM && j >= RETURN_REGNUM)))
5037     return;
5038
5039
5040   /* Search for prolog/epilog insns and replace them.  */
5041
5042   for (insn = get_insns (); insn; insn = next_insn)
5043     {
5044       int first, last, off;
5045       rtx set, base, offset;
5046
5047       next_insn = NEXT_INSN (insn);
5048
5049       if (GET_CODE (insn) != INSN)
5050         continue;
5051
5052       if (GET_CODE (PATTERN (insn)) == PARALLEL
5053           && store_multiple_operation (PATTERN (insn), VOIDmode))
5054         {
5055           set = XVECEXP (PATTERN (insn), 0, 0);
5056           first = REGNO (SET_SRC (set));
5057           last = first + XVECLEN (PATTERN (insn), 0) - 1;
5058           offset = const0_rtx;
5059           base = eliminate_constant_term (XEXP (SET_DEST (set), 0), &offset);
5060           off = INTVAL (offset) - first * UNITS_PER_WORD;
5061
5062           if (GET_CODE (base) != REG || off < 0)
5063             continue;
5064           if (first > BASE_REGISTER || last < BASE_REGISTER)
5065             continue;
5066
5067           if (save_first != -1)
5068             {
5069               new_insn = save_gprs (base, off, save_first, save_last);
5070               new_insn = emit_insn_before (new_insn, insn);
5071               INSN_ADDRESSES_NEW (new_insn, -1);
5072             }
5073
5074           remove_insn (insn);
5075           continue;
5076         }
5077
5078       if (GET_CODE (PATTERN (insn)) == SET
5079           && GET_CODE (SET_SRC (PATTERN (insn))) == REG
5080           && REGNO (SET_SRC (PATTERN (insn))) == BASE_REGISTER
5081           && GET_CODE (SET_DEST (PATTERN (insn))) == MEM)
5082         {
5083           set = PATTERN (insn);
5084           offset = const0_rtx;
5085           base = eliminate_constant_term (XEXP (SET_DEST (set), 0), &offset);
5086           off = INTVAL (offset) - BASE_REGISTER * UNITS_PER_WORD;
5087
5088           if (GET_CODE (base) != REG || off < 0)
5089             continue;
5090
5091           if (save_first != -1)
5092             {
5093               new_insn = save_gprs (base, off, save_first, save_last);
5094               new_insn = emit_insn_before (new_insn, insn);
5095               INSN_ADDRESSES_NEW (new_insn, -1);
5096             }
5097
5098           remove_insn (insn);
5099           continue;
5100         }
5101
5102       if (GET_CODE (PATTERN (insn)) == PARALLEL
5103           && load_multiple_operation (PATTERN (insn), VOIDmode))
5104         {
5105           set = XVECEXP (PATTERN (insn), 0, 0);
5106           first = REGNO (SET_DEST (set));
5107           last = first + XVECLEN (PATTERN (insn), 0) - 1;
5108           offset = const0_rtx;
5109           base = eliminate_constant_term (XEXP (SET_SRC (set), 0), &offset);
5110           off = INTVAL (offset) - first * UNITS_PER_WORD;
5111
5112           if (GET_CODE (base) != REG || off < 0)
5113             continue;
5114           if (first > BASE_REGISTER || last < BASE_REGISTER)
5115             continue;
5116
5117           if (restore_first != -1)
5118             {
5119               new_insn = restore_gprs (base, off, restore_first, restore_last);
5120               new_insn = emit_insn_before (new_insn, insn);
5121               INSN_ADDRESSES_NEW (new_insn, -1);
5122             }
5123
5124           remove_insn (insn);
5125           continue;
5126         }
5127
5128       if (GET_CODE (PATTERN (insn)) == SET
5129           && GET_CODE (SET_DEST (PATTERN (insn))) == REG
5130           && REGNO (SET_DEST (PATTERN (insn))) == BASE_REGISTER
5131           && GET_CODE (SET_SRC (PATTERN (insn))) == MEM)
5132         {
5133           set = PATTERN (insn);
5134           offset = const0_rtx;
5135           base = eliminate_constant_term (XEXP (SET_SRC (set), 0), &offset);
5136           off = INTVAL (offset) - BASE_REGISTER * UNITS_PER_WORD;
5137
5138           if (GET_CODE (base) != REG || off < 0)
5139             continue;
5140
5141           if (restore_first != -1)
5142             {
5143               new_insn = restore_gprs (base, off, restore_first, restore_last);
5144               new_insn = emit_insn_before (new_insn, insn);
5145               INSN_ADDRESSES_NEW (new_insn, -1);
5146             }
5147
5148           remove_insn (insn);
5149           continue;
5150         }
5151     }
5152 }
5153
5154 /* Perform machine-dependent processing.  */
5155
5156 static void
5157 s390_reorg (void)
5158 {
5159   rtx base_reg = gen_rtx_REG (Pmode, BASE_REGISTER);
5160   bool base_used = false;
5161   bool pool_overflow = false;
5162
5163   /* Make sure all splits have been performed; splits after
5164      machine_dependent_reorg might confuse insn length counts.  */
5165   split_all_insns_noflow ();
5166
5167
5168   /* In small leaf functions, try to use an unused call-clobbered
5169      register as base register to avoid save/restore overhead.  */
5170   if (current_function_is_leaf && !regs_ever_live[5])
5171     base_reg = gen_rtx_REG (Pmode, 5);
5172
5173
5174   /* Install the main literal pool and the associated base
5175      register load insns.
5176
5177      In addition, there are two problematic situations we need
5178      to correct:
5179
5180      - the literal pool might be > 4096 bytes in size, so that
5181        some of its elements cannot be directly accessed
5182
5183      - a branch target might be > 64K away from the branch, so that
5184        it is not possible to use a PC-relative instruction.
5185
5186      To fix those, we split the single literal pool into multiple
5187      pool chunks, reloading the pool base register at various
5188      points throughout the function to ensure it always points to
5189      the pool chunk the following code expects, and / or replace
5190      PC-relative branches by absolute branches.
5191
5192      However, the two problems are interdependent: splitting the
5193      literal pool can move a branch further away from its target,
5194      causing the 64K limit to overflow, and on the other hand,
5195      replacing a PC-relative branch by an absolute branch means
5196      we need to put the branch target address into the literal
5197      pool, possibly causing it to overflow.
5198
5199      So, we loop trying to fix up both problems until we manage
5200      to satisfy both conditions at the same time.  Note that the
5201      loop is guaranteed to terminate as every pass of the loop
5202      strictly decreases the total number of PC-relative branches
5203      in the function.  (This is not completely true as there
5204      might be branch-over-pool insns introduced by chunkify_start.
5205      Those never need to be split however.)  */
5206
5207   for (;;)
5208     {
5209       struct constant_pool *pool = NULL;
5210
5211       /* Collect the literal pool.  */
5212       if (!pool_overflow)
5213         {
5214           pool = s390_mainpool_start ();
5215           if (!pool)
5216             pool_overflow = true;
5217         }
5218
5219       /* If literal pool overflowed, start to chunkify it.  */
5220       if (pool_overflow)
5221         pool = s390_chunkify_start (base_reg);
5222
5223       /* Split out-of-range branches.  If this has created new
5224          literal pool entries, cancel current chunk list and
5225          recompute it.  zSeries machines have large branch
5226          instructions, so we never need to split a branch.  */
5227       if (!TARGET_CPU_ZARCH && s390_split_branches ())
5228         {
5229           if (pool_overflow)
5230             s390_chunkify_cancel (pool);
5231           else
5232             s390_mainpool_cancel (pool);
5233
5234           continue;
5235         }
5236
5237       /* If we made it up to here, both conditions are satisfied.
5238          Finish up literal pool related changes.  */
5239       if ((pool_overflow || pool->size > 0)
5240            && REGNO (base_reg) == BASE_REGISTER)
5241         base_used = true;
5242
5243       if (pool_overflow)
5244         s390_chunkify_finish (pool, base_reg);
5245       else
5246         s390_mainpool_finish (pool, base_reg);
5247
5248       break;
5249     }
5250
5251   s390_optimize_prolog (base_used);
5252 }
5253
5254
5255 /* Return an RTL expression representing the value of the return address
5256    for the frame COUNT steps up from the current frame.  FRAME is the
5257    frame pointer of that frame.  */
5258
5259 rtx
5260 s390_return_addr_rtx (int count, rtx frame)
5261 {
5262   rtx addr;
5263
5264   /* For the current frame, we need to make sure the initial
5265      value of RETURN_REGNUM is actually saved.  */
5266
5267   if (count == 0)
5268     cfun->machine->save_return_addr_p = true;
5269
5270   /* To retrieve the return address we read the stack slot where the
5271      corresponding RETURN_REGNUM value was saved.  */
5272
5273   addr = plus_constant (frame, RETURN_REGNUM * UNITS_PER_WORD);
5274   addr = memory_address (Pmode, addr);
5275   return gen_rtx_MEM (Pmode, addr);
5276 }
5277
5278 /* Find first call clobbered register unsused in a function.
5279    This could be used as base register in a leaf function
5280    or for holding the return address before epilogue.  */
5281
5282 static int
5283 find_unused_clobbered_reg (void)
5284 {
5285   int i;
5286   for (i = 0; i < 6; i++)
5287     if (!regs_ever_live[i])
5288       return i;
5289   return 0;
5290 }
5291
5292 /* Fill FRAME with info about frame of current function.  */
5293
5294 static void
5295 s390_frame_info (void)
5296 {
5297   int i, j;
5298   HOST_WIDE_INT fsize = get_frame_size ();
5299
5300   if (fsize > 0x7fff0000)
5301     fatal_error ("Total size of local variables exceeds architecture limit.");
5302
5303   /* fprs 8 - 15 are caller saved for 64 Bit ABI.  */
5304   cfun->machine->save_fprs_p = 0;
5305   if (TARGET_64BIT)
5306     for (i = 24; i < 32; i++)
5307       if (regs_ever_live[i] && !global_regs[i])
5308         {
5309           cfun->machine->save_fprs_p = 1;
5310           break;
5311         }
5312
5313   cfun->machine->frame_size = fsize + cfun->machine->save_fprs_p * 64;
5314
5315   /* Does function need to setup frame and save area.  */
5316
5317   if (! current_function_is_leaf
5318       || cfun->machine->frame_size > 0
5319       || current_function_calls_alloca
5320       || current_function_stdarg)
5321     cfun->machine->frame_size += STARTING_FRAME_OFFSET;
5322
5323   /* If we use the return register, we'll need to make sure
5324      it is going to be saved/restored.  */
5325
5326   if (!current_function_is_leaf
5327       || regs_ever_live[RETURN_REGNUM])
5328     cfun->machine->save_return_addr_p = 1;
5329
5330   /* Find first and last gpr to be saved.  Note that at this point,
5331      we assume the base register and -on S/390- the return register
5332      always need to be saved.  This is done because the usage of these
5333      register might change even after the prolog was emitted.
5334      If it turns out later that we really don't need them, the
5335      prolog/epilog code is modified again.  */
5336
5337   regs_ever_live[BASE_REGISTER] = 1;
5338   if (!TARGET_CPU_ZARCH || cfun->machine->save_return_addr_p)
5339     regs_ever_live[RETURN_REGNUM] = 1;
5340   regs_ever_live[STACK_POINTER_REGNUM] = cfun->machine->frame_size > 0;
5341
5342   for (i = 6; i < 16; i++)
5343     if (regs_ever_live[i])
5344       if (!global_regs[i]
5345           || i == STACK_POINTER_REGNUM
5346           || i == RETURN_REGNUM
5347           || i == BASE_REGISTER
5348           || (flag_pic && i == (int)PIC_OFFSET_TABLE_REGNUM))
5349         break;
5350
5351   for (j = 15; j > i; j--)
5352     if (regs_ever_live[j])
5353       if (!global_regs[j]
5354           || j == STACK_POINTER_REGNUM
5355           || j == RETURN_REGNUM
5356           || j == BASE_REGISTER
5357           || (flag_pic && j == (int)PIC_OFFSET_TABLE_REGNUM))
5358         break;
5359
5360   /* Save / Restore from gpr i to j.  */
5361   cfun->machine->first_save_gpr = i;
5362   cfun->machine->first_restore_gpr = i;
5363   cfun->machine->last_save_gpr  = j;
5364
5365   /* Varargs functions need to save gprs 2 to 6.  */
5366   if (current_function_stdarg)
5367     cfun->machine->first_save_gpr = 2;
5368 }
5369
5370 /* Return offset between argument pointer and frame pointer
5371    initially after prologue.  */
5372
5373 int
5374 s390_arg_frame_offset (void)
5375 {
5376   HOST_WIDE_INT fsize = get_frame_size ();
5377   int save_fprs_p, i;
5378
5379   /* fprs 8 - 15 are caller saved for 64 Bit ABI.  */
5380   save_fprs_p = 0;
5381   if (TARGET_64BIT)
5382     for (i = 24; i < 32; i++)
5383       if (regs_ever_live[i] && !global_regs[i])
5384         {
5385           save_fprs_p = 1;
5386           break;
5387         }
5388
5389   fsize = fsize + save_fprs_p * 64;
5390
5391   /* Does function need to setup frame and save area.  */
5392
5393   if (! current_function_is_leaf
5394       || fsize > 0
5395       || current_function_calls_alloca
5396       || current_function_stdarg)
5397     fsize += STARTING_FRAME_OFFSET;
5398   return fsize + STACK_POINTER_OFFSET;
5399 }
5400
5401 /* Emit insn to save fpr REGNUM at offset OFFSET relative
5402    to register BASE.  Return generated insn.  */
5403
5404 static rtx
5405 save_fpr (rtx base, int offset, int regnum)
5406 {
5407   rtx addr;
5408   addr = gen_rtx_MEM (DFmode, plus_constant (base, offset));
5409   set_mem_alias_set (addr, s390_sr_alias_set);
5410
5411   return emit_move_insn (addr, gen_rtx_REG (DFmode, regnum));
5412 }
5413
5414 /* Emit insn to restore fpr REGNUM from offset OFFSET relative
5415    to register BASE.  Return generated insn.  */
5416
5417 static rtx
5418 restore_fpr (rtx base, int offset, int regnum)
5419 {
5420   rtx addr;
5421   addr = gen_rtx_MEM (DFmode, plus_constant (base, offset));
5422   set_mem_alias_set (addr, s390_sr_alias_set);
5423
5424   return emit_move_insn (gen_rtx_REG (DFmode, regnum), addr);
5425 }
5426
5427 /* Generate insn to save registers FIRST to LAST into
5428    the register save area located at offset OFFSET
5429    relative to register BASE.  */
5430
5431 static rtx
5432 save_gprs (rtx base, int offset, int first, int last)
5433 {
5434   rtx addr, insn, note;
5435   int i;
5436
5437   addr = plus_constant (base, offset + first * UNITS_PER_WORD);
5438   addr = gen_rtx_MEM (Pmode, addr);
5439   set_mem_alias_set (addr, s390_sr_alias_set);
5440
5441   /* Special-case single register.  */
5442   if (first == last)
5443     {
5444       if (TARGET_64BIT)
5445         insn = gen_movdi (addr, gen_rtx_REG (Pmode, first));
5446       else
5447         insn = gen_movsi (addr, gen_rtx_REG (Pmode, first));
5448
5449       RTX_FRAME_RELATED_P (insn) = 1;
5450       return insn;
5451     }
5452
5453
5454   insn = gen_store_multiple (addr,
5455                              gen_rtx_REG (Pmode, first),
5456                              GEN_INT (last - first + 1));
5457
5458
5459   /* We need to set the FRAME_RELATED flag on all SETs
5460      inside the store-multiple pattern.
5461
5462      However, we must not emit DWARF records for registers 2..5
5463      if they are stored for use by variable arguments ...
5464
5465      ??? Unfortunately, it is not enough to simply not the the
5466      FRAME_RELATED flags for those SETs, because the first SET
5467      of the PARALLEL is always treated as if it had the flag
5468      set, even if it does not.  Therefore we emit a new pattern
5469      without those registers as REG_FRAME_RELATED_EXPR note.  */
5470
5471   if (first >= 6)
5472     {
5473       rtx pat = PATTERN (insn);
5474
5475       for (i = 0; i < XVECLEN (pat, 0); i++)
5476         if (GET_CODE (XVECEXP (pat, 0, i)) == SET)
5477           RTX_FRAME_RELATED_P (XVECEXP (pat, 0, i)) = 1;
5478
5479       RTX_FRAME_RELATED_P (insn) = 1;
5480     }
5481   else if (last >= 6)
5482     {
5483       addr = plus_constant (base, offset + 6 * UNITS_PER_WORD);
5484       note = gen_store_multiple (gen_rtx_MEM (Pmode, addr),
5485                                  gen_rtx_REG (Pmode, 6),
5486                                  GEN_INT (last - 6 + 1));
5487       note = PATTERN (note);
5488
5489       REG_NOTES (insn) =
5490         gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
5491                            note, REG_NOTES (insn));
5492
5493       for (i = 0; i < XVECLEN (note, 0); i++)
5494         if (GET_CODE (XVECEXP (note, 0, i)) == SET)
5495           RTX_FRAME_RELATED_P (XVECEXP (note, 0, i)) = 1;
5496
5497       RTX_FRAME_RELATED_P (insn) = 1;
5498     }
5499
5500   return insn;
5501 }
5502
5503 /* Generate insn to restore registers FIRST to LAST from
5504    the register save area located at offset OFFSET
5505    relative to register BASE.  */
5506
5507 static rtx
5508 restore_gprs (rtx base, int offset, int first, int last)
5509 {
5510   rtx addr, insn;
5511
5512   addr = plus_constant (base, offset + first * UNITS_PER_WORD);
5513   addr = gen_rtx_MEM (Pmode, addr);
5514   set_mem_alias_set (addr, s390_sr_alias_set);
5515
5516   /* Special-case single register.  */
5517   if (first == last)
5518     {
5519       if (TARGET_64BIT)
5520         insn = gen_movdi (gen_rtx_REG (Pmode, first), addr);
5521       else
5522         insn = gen_movsi (gen_rtx_REG (Pmode, first), addr);
5523
5524       return insn;
5525     }
5526
5527   insn = gen_load_multiple (gen_rtx_REG (Pmode, first),
5528                             addr,
5529                             GEN_INT (last - first + 1));
5530   return insn;
5531 }
5532
5533 /* Emit code to load the GOT register.  If MAYBE_DEAD is true,
5534    annotate generated insns with REG_MAYBE_DEAD notes.  */
5535
5536 static GTY(()) rtx got_symbol;
5537 void
5538 s390_load_got (int maybe_dead)
5539 {
5540   if (!got_symbol)
5541     {
5542       got_symbol = gen_rtx_SYMBOL_REF (Pmode, "_GLOBAL_OFFSET_TABLE_");
5543       SYMBOL_REF_FLAGS (got_symbol) = SYMBOL_FLAG_LOCAL;
5544     }
5545
5546   if (TARGET_CPU_ZARCH)
5547     {
5548       rtx insn = emit_move_insn (pic_offset_table_rtx, got_symbol);
5549       if (maybe_dead)
5550         REG_NOTES(insn) = gen_rtx_EXPR_LIST (REG_MAYBE_DEAD, NULL_RTX,
5551                                              REG_NOTES (insn));
5552     }
5553   else
5554     {
5555       rtx offset, insn;
5556
5557       offset = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, got_symbol),
5558                                UNSPEC_LTREL_OFFSET);
5559       offset = gen_rtx_CONST (Pmode, offset);
5560       offset = force_const_mem (Pmode, offset);
5561
5562       insn = emit_move_insn (pic_offset_table_rtx, offset);
5563       if (maybe_dead)
5564         REG_NOTES(insn) = gen_rtx_EXPR_LIST (REG_MAYBE_DEAD, NULL_RTX,
5565                                              REG_NOTES (insn));
5566
5567       offset = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, XEXP (offset, 0)),
5568                                UNSPEC_LTREL_BASE);
5569       offset = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, offset);
5570
5571       insn = emit_move_insn (pic_offset_table_rtx, offset);
5572       if (maybe_dead)
5573         REG_NOTES(insn) = gen_rtx_EXPR_LIST (REG_MAYBE_DEAD, NULL_RTX,
5574                                              REG_NOTES (insn));
5575     }
5576 }
5577
5578 /* Expand the prologue into a bunch of separate insns.  */
5579
5580 void
5581 s390_emit_prologue (void)
5582 {
5583   rtx insn, addr;
5584   rtx temp_reg;
5585   int i;
5586
5587   /* Compute frame_info.  */
5588
5589   s390_frame_info ();
5590
5591   /* Choose best register to use for temp use within prologue.
5592      See below for why TPF must use the register 1.  */
5593
5594   if (!current_function_is_leaf
5595       && !TARGET_TPF)
5596     temp_reg = gen_rtx_REG (Pmode, RETURN_REGNUM);
5597   else
5598     temp_reg = gen_rtx_REG (Pmode, 1);
5599
5600   /* Save call saved gprs.  */
5601
5602   insn = save_gprs (stack_pointer_rtx, 0,
5603                     cfun->machine->first_save_gpr, cfun->machine->last_save_gpr);
5604   emit_insn (insn);
5605
5606   /* Dummy insn to mark literal pool slot.  */
5607
5608   emit_insn (gen_main_pool ());
5609
5610   /* Save fprs for variable args.  */
5611
5612   if (current_function_stdarg)
5613     for (i = 16; i < (TARGET_64BIT ? 20 : 18); i++)
5614       save_fpr (stack_pointer_rtx, 16*UNITS_PER_WORD + 8*(i-16), i);
5615
5616   /* Save fprs 4 and 6 if used (31 bit ABI).  */
5617
5618   if (!TARGET_64BIT)
5619     for (i = 18; i < 20; i++)
5620       if (regs_ever_live[i] && !global_regs[i])
5621         {
5622           insn = save_fpr (stack_pointer_rtx, 16*UNITS_PER_WORD + 8*(i-16), i);
5623           RTX_FRAME_RELATED_P (insn) = 1;
5624         }
5625
5626   /* Decrement stack pointer.  */
5627
5628   if (cfun->machine->frame_size > 0)
5629     {
5630       rtx frame_off = GEN_INT (-cfun->machine->frame_size);
5631
5632       /* Save incoming stack pointer into temp reg.  */
5633
5634       if (TARGET_BACKCHAIN || cfun->machine->save_fprs_p)
5635         {
5636           insn = emit_insn (gen_move_insn (temp_reg, stack_pointer_rtx));
5637         }
5638
5639       /* Subtract frame size from stack pointer.  */
5640
5641       if (DISP_IN_RANGE (INTVAL (frame_off)))
5642         {
5643           insn = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
5644                               gen_rtx_PLUS (Pmode, stack_pointer_rtx,
5645                                             frame_off));
5646           insn = emit_insn (insn);
5647         }
5648       else
5649         {
5650           if (!CONST_OK_FOR_CONSTRAINT_P (INTVAL (frame_off), 'K', "K"))
5651             frame_off = force_const_mem (Pmode, frame_off);
5652
5653           insn = emit_insn (gen_add2_insn (stack_pointer_rtx, frame_off));
5654         }
5655
5656       RTX_FRAME_RELATED_P (insn) = 1;
5657       REG_NOTES (insn) =
5658         gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
5659                            gen_rtx_SET (VOIDmode, stack_pointer_rtx,
5660                                    gen_rtx_PLUS (Pmode, stack_pointer_rtx,
5661                                    GEN_INT (-cfun->machine->frame_size))),
5662                            REG_NOTES (insn));
5663
5664       /* Set backchain.  */
5665
5666       if (TARGET_BACKCHAIN)
5667         {
5668           addr = gen_rtx_MEM (Pmode, stack_pointer_rtx);
5669           set_mem_alias_set (addr, s390_sr_alias_set);
5670           insn = emit_insn (gen_move_insn (addr, temp_reg));
5671         }
5672
5673       /* If we support asynchronous exceptions (e.g. for Java),
5674          we need to make sure the backchain pointer is set up
5675          before any possibly trapping memory access.  */
5676
5677       if (TARGET_BACKCHAIN && flag_non_call_exceptions)
5678         {
5679           addr = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode));
5680           emit_insn (gen_rtx_CLOBBER (VOIDmode, addr));
5681         }
5682     }
5683
5684   /* Save fprs 8 - 15 (64 bit ABI).  */
5685
5686   if (cfun->machine->save_fprs_p)
5687     {
5688       insn = emit_insn (gen_add2_insn (temp_reg, GEN_INT(-64)));
5689
5690       for (i = 24; i < 32; i++)
5691         if (regs_ever_live[i] && !global_regs[i])
5692           {
5693             rtx addr = plus_constant (stack_pointer_rtx,
5694                                       cfun->machine->frame_size - 64 + (i-24)*8);
5695
5696             insn = save_fpr (temp_reg, (i-24)*8, i);
5697             RTX_FRAME_RELATED_P (insn) = 1;
5698             REG_NOTES (insn) =
5699               gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
5700                 gen_rtx_SET (VOIDmode,
5701                              gen_rtx_MEM (DFmode, addr),
5702                              gen_rtx_REG (DFmode, i)),
5703                 REG_NOTES (insn));
5704           }
5705     }
5706
5707   /* Set frame pointer, if needed.  */
5708
5709   if (frame_pointer_needed)
5710     {
5711       insn = emit_move_insn (hard_frame_pointer_rtx, stack_pointer_rtx);
5712       RTX_FRAME_RELATED_P (insn) = 1;
5713     }
5714
5715   /* Set up got pointer, if needed.  */
5716
5717   if (flag_pic && regs_ever_live[PIC_OFFSET_TABLE_REGNUM])
5718     s390_load_got(true);
5719
5720   if (TARGET_TPF)
5721     {
5722       /* Generate a BAS instruction to serve as a function
5723          entry intercept to facilitate the use of tracing
5724          algorithms located at the branch target.
5725
5726          This must use register 1.  */
5727       rtx addr;
5728       rtx unkn;
5729       rtx link;
5730
5731       addr = GEN_INT (0xfe0);
5732       unkn = CONST0_RTX (SImode);
5733       link = gen_rtx_REG (Pmode, 1);
5734
5735       emit_call_insn (gen_call_exp (gen_rtx_MEM (QImode, addr), unkn, link));
5736
5737       /* Emit a blockage here so that all code
5738          lies between the profiling mechanisms.  */
5739       emit_insn (gen_blockage ());
5740     }
5741 }
5742
5743 /* Expand the epilogue into a bunch of separate insns.  */
5744
5745 void
5746 s390_emit_epilogue (void)
5747 {
5748   rtx frame_pointer, return_reg;
5749   int area_bottom, area_top, offset = 0;
5750   rtvec p;
5751   int i;
5752
5753   if (TARGET_TPF)
5754     {
5755
5756       /* Generate a BAS instruction to serve as a function
5757          entry intercept to facilitate the use of tracing
5758          algorithms located at the branch target.
5759
5760          This must use register 1.  */
5761
5762       rtx addr;
5763       rtx unkn;
5764       rtx link;
5765
5766       addr = GEN_INT (0xfe6);
5767       unkn = CONST0_RTX (SImode);
5768       link = gen_rtx_REG (Pmode, 1);
5769
5770       /* Emit a blockage here so that all code
5771          lies between the profiling mechanisms.  */
5772       emit_insn (gen_blockage ());
5773
5774       emit_call_insn (gen_call_exp (gen_rtx_MEM (QImode, addr), unkn, link));
5775     }
5776
5777   /* Check whether to use frame or stack pointer for restore.  */
5778
5779   frame_pointer = frame_pointer_needed ?
5780     hard_frame_pointer_rtx : stack_pointer_rtx;
5781
5782   /* Compute which parts of the save area we need to access.  */
5783
5784   if (cfun->machine->first_restore_gpr != -1)
5785     {
5786       area_bottom = cfun->machine->first_restore_gpr * UNITS_PER_WORD;
5787       area_top = (cfun->machine->last_save_gpr + 1) * UNITS_PER_WORD;
5788     }
5789   else
5790     {
5791       area_bottom = INT_MAX;
5792       area_top = INT_MIN;
5793     }
5794
5795   if (TARGET_64BIT)
5796     {
5797       if (cfun->machine->save_fprs_p)
5798         {
5799           if (area_bottom > -64)
5800             area_bottom = -64;
5801           if (area_top < 0)
5802             area_top = 0;
5803         }
5804     }
5805   else
5806     {
5807       for (i = 18; i < 20; i++)
5808         if (regs_ever_live[i] && !global_regs[i])
5809           {
5810             if (area_bottom > 16*UNITS_PER_WORD + 8*(i-16))
5811               area_bottom = 16*UNITS_PER_WORD + 8*(i-16);
5812             if (area_top < 16*UNITS_PER_WORD + 8*(i-16) + 8)
5813               area_top = 16*UNITS_PER_WORD + 8*(i-16) + 8;
5814           }
5815     }
5816
5817   /* Check whether we can access the register save area.
5818      If not, increment the frame pointer as required.  */
5819
5820   if (area_top <= area_bottom)
5821     {
5822       /* Nothing to restore.  */
5823     }
5824   else if (DISP_IN_RANGE (cfun->machine->frame_size + area_bottom)
5825            && DISP_IN_RANGE (cfun->machine->frame_size + area_top-1))
5826     {
5827       /* Area is in range.  */
5828       offset = cfun->machine->frame_size;
5829     }
5830   else
5831     {
5832       rtx insn, frame_off;
5833
5834       offset = area_bottom < 0 ? -area_bottom : 0;
5835       frame_off = GEN_INT (cfun->machine->frame_size - offset);
5836
5837       if (DISP_IN_RANGE (INTVAL (frame_off)))
5838         {
5839           insn = gen_rtx_SET (VOIDmode, frame_pointer,
5840                               gen_rtx_PLUS (Pmode, frame_pointer, frame_off));
5841           insn = emit_insn (insn);
5842         }
5843       else
5844         {
5845           if (!CONST_OK_FOR_CONSTRAINT_P (INTVAL (frame_off), 'K', "K"))
5846             frame_off = force_const_mem (Pmode, frame_off);
5847
5848           insn = emit_insn (gen_add2_insn (frame_pointer, frame_off));
5849         }
5850     }
5851
5852   /* Restore call saved fprs.  */
5853
5854   if (TARGET_64BIT)
5855     {
5856       if (cfun->machine->save_fprs_p)
5857         for (i = 24; i < 32; i++)
5858           if (regs_ever_live[i] && !global_regs[i])
5859             restore_fpr (frame_pointer,
5860                          offset - 64 + (i-24) * 8, i);
5861     }
5862   else
5863     {
5864       for (i = 18; i < 20; i++)
5865         if (regs_ever_live[i] && !global_regs[i])
5866           restore_fpr (frame_pointer,
5867                        offset + 16*UNITS_PER_WORD + 8*(i-16), i);
5868     }
5869
5870   /* Return register.  */
5871
5872   return_reg = gen_rtx_REG (Pmode, RETURN_REGNUM);
5873
5874   /* Restore call saved gprs.  */
5875
5876   if (cfun->machine->first_restore_gpr != -1)
5877     {
5878       rtx insn, addr;
5879       int i;
5880
5881       /* Check for global register and save them
5882          to stack location from where they get restored.  */
5883
5884       for (i = cfun->machine->first_restore_gpr;
5885            i <= cfun->machine->last_save_gpr;
5886            i++)
5887         {
5888           /* These registers are special and need to be
5889              restored in any case.  */
5890           if (i == STACK_POINTER_REGNUM
5891               || i == RETURN_REGNUM
5892               || i == BASE_REGISTER
5893               || (flag_pic && i == (int)PIC_OFFSET_TABLE_REGNUM))
5894             continue;
5895
5896           if (global_regs[i])
5897             {
5898               addr = plus_constant (frame_pointer,
5899                      offset + i * UNITS_PER_WORD);
5900               addr = gen_rtx_MEM (Pmode, addr);
5901               set_mem_alias_set (addr, s390_sr_alias_set);
5902               emit_move_insn (addr, gen_rtx_REG (Pmode, i));
5903             }
5904         }
5905
5906       /* Fetch return address from stack before load multiple,
5907          this will do good for scheduling.  */
5908
5909       if (cfun->machine->save_return_addr_p
5910           || (cfun->machine->first_restore_gpr < BASE_REGISTER
5911               && cfun->machine->last_save_gpr > RETURN_REGNUM))
5912         {
5913           int return_regnum = find_unused_clobbered_reg();
5914           if (!return_regnum)
5915             return_regnum = 4;
5916           return_reg = gen_rtx_REG (Pmode, return_regnum);
5917
5918           addr = plus_constant (frame_pointer,
5919                                 offset + RETURN_REGNUM * UNITS_PER_WORD);
5920           addr = gen_rtx_MEM (Pmode, addr);
5921           set_mem_alias_set (addr, s390_sr_alias_set);
5922           emit_move_insn (return_reg, addr);
5923         }
5924
5925       /* ??? As references to the base register are not made
5926          explicit in insn RTX code, we have to add a barrier here
5927          to prevent incorrect scheduling.  */
5928
5929       emit_insn (gen_blockage());
5930
5931       insn = restore_gprs (frame_pointer, offset,
5932                            cfun->machine->first_restore_gpr,
5933                            cfun->machine->last_save_gpr);
5934       emit_insn (insn);
5935     }
5936
5937   /* Return to caller.  */
5938
5939   p = rtvec_alloc (2);
5940
5941   RTVEC_ELT (p, 0) = gen_rtx_RETURN (VOIDmode);
5942   RTVEC_ELT (p, 1) = gen_rtx_USE (VOIDmode, return_reg);
5943   emit_jump_insn (gen_rtx_PARALLEL (VOIDmode, p));
5944 }
5945
5946
5947 /* Return the size in bytes of a function argument of
5948    type TYPE and/or mode MODE.  At least one of TYPE or
5949    MODE must be specified.  */
5950
5951 static int
5952 s390_function_arg_size (enum machine_mode mode, tree type)
5953 {
5954   if (type)
5955     return int_size_in_bytes (type);
5956
5957   /* No type info available for some library calls ...  */
5958   if (mode != BLKmode)
5959     return GET_MODE_SIZE (mode);
5960
5961   /* If we have neither type nor mode, abort */
5962   abort ();
5963 }
5964
5965 /* Return true if a function argument of type TYPE and mode MODE
5966    is to be passed in a floating-point register, if available.  */
5967
5968 static bool
5969 s390_function_arg_float (enum machine_mode mode, tree type)
5970 {
5971   int size = s390_function_arg_size (mode, type);
5972   if (size > 8)
5973     return false;
5974
5975   /* Soft-float changes the ABI: no floating-point registers are used.  */
5976   if (TARGET_SOFT_FLOAT)
5977     return false;
5978
5979   /* No type info available for some library calls ...  */
5980   if (!type)
5981     return mode == SFmode || mode == DFmode;
5982
5983   /* The ABI says that record types with a single member are treated
5984      just like that member would be.  */
5985   while (TREE_CODE (type) == RECORD_TYPE)
5986     {
5987       tree field, single = NULL_TREE;
5988
5989       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
5990         {
5991           if (TREE_CODE (field) != FIELD_DECL)
5992             continue;
5993
5994           if (single == NULL_TREE)
5995             single = TREE_TYPE (field);
5996           else
5997             return false;
5998         }
5999
6000       if (single == NULL_TREE)
6001         return false;
6002       else
6003         type = single;
6004     }
6005
6006   return TREE_CODE (type) == REAL_TYPE;
6007 }
6008
6009 /* Return true if a function argument of type TYPE and mode MODE
6010    is to be passed in an integer register, or a pair of integer
6011    registers, if available.  */
6012
6013 static bool
6014 s390_function_arg_integer (enum machine_mode mode, tree type)
6015 {
6016   int size = s390_function_arg_size (mode, type);
6017   if (size > 8)
6018     return false;
6019
6020   /* No type info available for some library calls ...  */
6021   if (!type)
6022     return GET_MODE_CLASS (mode) == MODE_INT
6023            || (TARGET_SOFT_FLOAT &&  GET_MODE_CLASS (mode) == MODE_FLOAT);
6024
6025   /* We accept small integral (and similar) types.  */
6026   if (INTEGRAL_TYPE_P (type)
6027       || POINTER_TYPE_P (type)
6028       || TREE_CODE (type) == OFFSET_TYPE
6029       || (TARGET_SOFT_FLOAT && TREE_CODE (type) == REAL_TYPE))
6030     return true;
6031
6032   /* We also accept structs of size 1, 2, 4, 8 that are not
6033      passed in floating-point registers.  */
6034   if (AGGREGATE_TYPE_P (type)
6035       && exact_log2 (size) >= 0
6036       && !s390_function_arg_float (mode, type))
6037     return true;
6038
6039   return false;
6040 }
6041
6042 /* Return 1 if a function argument of type TYPE and mode MODE
6043    is to be passed by reference.  The ABI specifies that only
6044    structures of size 1, 2, 4, or 8 bytes are passed by value,
6045    all other structures (and complex numbers) are passed by
6046    reference.  */
6047
6048 int
6049 s390_function_arg_pass_by_reference (enum machine_mode mode, tree type)
6050 {
6051   int size = s390_function_arg_size (mode, type);
6052   if (size > 8)
6053     return true;
6054
6055   if (type)
6056     {
6057       if (AGGREGATE_TYPE_P (type) && exact_log2 (size) < 0)
6058         return 1;
6059
6060       if (TREE_CODE (type) == COMPLEX_TYPE
6061           || TREE_CODE (type) == VECTOR_TYPE)
6062         return 1;
6063     }
6064
6065   return 0;
6066 }
6067
6068 /* Update the data in CUM to advance over an argument of mode MODE and
6069    data type TYPE.  (TYPE is null for libcalls where that information
6070    may not be available.).  The boolean NAMED specifies whether the
6071    argument is a named argument (as opposed to an unnamed argument
6072    matching an ellipsis).  */
6073
6074 void
6075 s390_function_arg_advance (CUMULATIVE_ARGS *cum, enum machine_mode mode,
6076                            tree type, int named ATTRIBUTE_UNUSED)
6077 {
6078   if (s390_function_arg_pass_by_reference (mode, type))
6079     {
6080       cum->gprs += 1;
6081     }
6082   else if (s390_function_arg_float (mode, type))
6083     {
6084       cum->fprs += 1;
6085     }
6086   else if (s390_function_arg_integer (mode, type))
6087     {
6088       int size = s390_function_arg_size (mode, type);
6089       cum->gprs += ((size + UNITS_PER_WORD-1) / UNITS_PER_WORD);
6090     }
6091   else
6092     abort ();
6093 }
6094
6095 /* Define where to put the arguments to a function.
6096    Value is zero to push the argument on the stack,
6097    or a hard register in which to store the argument.
6098
6099    MODE is the argument's machine mode.
6100    TYPE is the data type of the argument (as a tree).
6101     This is null for libcalls where that information may
6102     not be available.
6103    CUM is a variable of type CUMULATIVE_ARGS which gives info about
6104     the preceding args and about the function being called.
6105    NAMED is nonzero if this argument is a named parameter
6106     (otherwise it is an extra parameter matching an ellipsis).
6107
6108    On S/390, we use general purpose registers 2 through 6 to
6109    pass integer, pointer, and certain structure arguments, and
6110    floating point registers 0 and 2 (0, 2, 4, and 6 on 64-bit)
6111    to pass floating point arguments.  All remaining arguments
6112    are pushed to the stack.  */
6113
6114 rtx
6115 s390_function_arg (CUMULATIVE_ARGS *cum, enum machine_mode mode, tree type,
6116                    int named ATTRIBUTE_UNUSED)
6117 {
6118   if (s390_function_arg_pass_by_reference (mode, type))
6119       return 0;
6120
6121   if (s390_function_arg_float (mode, type))
6122     {
6123       if (cum->fprs + 1 > (TARGET_64BIT? 4 : 2))
6124         return 0;
6125       else
6126         return gen_rtx (REG, mode, cum->fprs + 16);
6127     }
6128   else if (s390_function_arg_integer (mode, type))
6129     {
6130       int size = s390_function_arg_size (mode, type);
6131       int n_gprs = (size + UNITS_PER_WORD-1) / UNITS_PER_WORD;
6132
6133       if (cum->gprs + n_gprs > 5)
6134         return 0;
6135       else
6136         return gen_rtx (REG, mode, cum->gprs + 2);
6137     }
6138
6139   /* After the real arguments, expand_call calls us once again
6140      with a void_type_node type.  Whatever we return here is
6141      passed as operand 2 to the call expanders.
6142
6143      We don't need this feature ...  */
6144   else if (type == void_type_node)
6145     return const0_rtx;
6146
6147   abort ();
6148 }
6149
6150 /* Return true if return values of type TYPE should be returned
6151    in a memory buffer whose address is passed by the caller as
6152    hidden first argument.  */
6153
6154 static bool
6155 s390_return_in_memory (tree type, tree fundecl ATTRIBUTE_UNUSED)
6156 {
6157   /* We accept small integral (and similar) types.  */
6158   if (INTEGRAL_TYPE_P (type)
6159       || POINTER_TYPE_P (type)
6160       || TREE_CODE (type) == OFFSET_TYPE
6161       || TREE_CODE (type) == REAL_TYPE)
6162     return int_size_in_bytes (type) > 8;
6163
6164   /* Aggregates and similar constructs are always returned
6165      in memory.  */
6166   if (AGGREGATE_TYPE_P (type)
6167       || TREE_CODE (type) == COMPLEX_TYPE
6168       || TREE_CODE (type) == VECTOR_TYPE)
6169     return true;
6170
6171   /* ??? We get called on all sorts of random stuff from
6172      aggregate_value_p.  We can't abort, but it's not clear
6173      what's safe to return.  Pretend it's a struct I guess.  */
6174   return true;
6175 }
6176
6177 /* Define where to return a (scalar) value of type TYPE.
6178    If TYPE is null, define where to return a (scalar)
6179    value of mode MODE from a libcall.  */
6180
6181 rtx
6182 s390_function_value (tree type, enum machine_mode mode)
6183 {
6184   if (type)
6185     {
6186       int unsignedp = TREE_UNSIGNED (type);
6187       mode = promote_mode (type, TYPE_MODE (type), &unsignedp, 1);
6188     }
6189
6190   if (GET_MODE_CLASS (mode) != MODE_INT
6191       && GET_MODE_CLASS (mode) != MODE_FLOAT)
6192     abort ();
6193   if (GET_MODE_SIZE (mode) > 8)
6194     abort ();
6195
6196   if (TARGET_HARD_FLOAT && GET_MODE_CLASS (mode) == MODE_FLOAT)
6197     return gen_rtx_REG (mode, 16);
6198   else
6199     return gen_rtx_REG (mode, 2);
6200 }
6201
6202
6203 /* Create and return the va_list datatype.
6204
6205    On S/390, va_list is an array type equivalent to
6206
6207       typedef struct __va_list_tag
6208         {
6209             long __gpr;
6210             long __fpr;
6211             void *__overflow_arg_area;
6212             void *__reg_save_area;
6213         } va_list[1];
6214
6215    where __gpr and __fpr hold the number of general purpose
6216    or floating point arguments used up to now, respectively,
6217    __overflow_arg_area points to the stack location of the
6218    next argument passed on the stack, and __reg_save_area
6219    always points to the start of the register area in the
6220    call frame of the current function.  The function prologue
6221    saves all registers used for argument passing into this
6222    area if the function uses variable arguments.  */
6223
6224 static tree
6225 s390_build_builtin_va_list (void)
6226 {
6227   tree f_gpr, f_fpr, f_ovf, f_sav, record, type_decl;
6228
6229   record = lang_hooks.types.make_type (RECORD_TYPE);
6230
6231   type_decl =
6232     build_decl (TYPE_DECL, get_identifier ("__va_list_tag"), record);
6233
6234   f_gpr = build_decl (FIELD_DECL, get_identifier ("__gpr"),
6235                       long_integer_type_node);
6236   f_fpr = build_decl (FIELD_DECL, get_identifier ("__fpr"),
6237                       long_integer_type_node);
6238   f_ovf = build_decl (FIELD_DECL, get_identifier ("__overflow_arg_area"),
6239                       ptr_type_node);
6240   f_sav = build_decl (FIELD_DECL, get_identifier ("__reg_save_area"),
6241                       ptr_type_node);
6242
6243   DECL_FIELD_CONTEXT (f_gpr) = record;
6244   DECL_FIELD_CONTEXT (f_fpr) = record;
6245   DECL_FIELD_CONTEXT (f_ovf) = record;
6246   DECL_FIELD_CONTEXT (f_sav) = record;
6247
6248   TREE_CHAIN (record) = type_decl;
6249   TYPE_NAME (record) = type_decl;
6250   TYPE_FIELDS (record) = f_gpr;
6251   TREE_CHAIN (f_gpr) = f_fpr;
6252   TREE_CHAIN (f_fpr) = f_ovf;
6253   TREE_CHAIN (f_ovf) = f_sav;
6254
6255   layout_type (record);
6256
6257   /* The correct type is an array type of one element.  */
6258   return build_array_type (record, build_index_type (size_zero_node));
6259 }
6260
6261 /* Implement va_start by filling the va_list structure VALIST.
6262    STDARG_P is always true, and ignored.
6263    NEXTARG points to the first anonymous stack argument.
6264
6265    The following global variables are used to initialize
6266    the va_list structure:
6267
6268      current_function_args_info:
6269        holds number of gprs and fprs used for named arguments.
6270      current_function_arg_offset_rtx:
6271        holds the offset of the first anonymous stack argument
6272        (relative to the virtual arg pointer).  */
6273
6274 void
6275 s390_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED)
6276 {
6277   HOST_WIDE_INT n_gpr, n_fpr;
6278   int off;
6279   tree f_gpr, f_fpr, f_ovf, f_sav;
6280   tree gpr, fpr, ovf, sav, t;
6281
6282   f_gpr = TYPE_FIELDS (TREE_TYPE (va_list_type_node));
6283   f_fpr = TREE_CHAIN (f_gpr);
6284   f_ovf = TREE_CHAIN (f_fpr);
6285   f_sav = TREE_CHAIN (f_ovf);
6286
6287   valist = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (valist)), valist);
6288   gpr = build (COMPONENT_REF, TREE_TYPE (f_gpr), valist, f_gpr);
6289   fpr = build (COMPONENT_REF, TREE_TYPE (f_fpr), valist, f_fpr);
6290   ovf = build (COMPONENT_REF, TREE_TYPE (f_ovf), valist, f_ovf);
6291   sav = build (COMPONENT_REF, TREE_TYPE (f_sav), valist, f_sav);
6292
6293   /* Count number of gp and fp argument registers used.  */
6294
6295   n_gpr = current_function_args_info.gprs;
6296   n_fpr = current_function_args_info.fprs;
6297
6298   t = build (MODIFY_EXPR, TREE_TYPE (gpr), gpr, build_int_2 (n_gpr, 0));
6299   TREE_SIDE_EFFECTS (t) = 1;
6300   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
6301
6302   t = build (MODIFY_EXPR, TREE_TYPE (fpr), fpr, build_int_2 (n_fpr, 0));
6303   TREE_SIDE_EFFECTS (t) = 1;
6304   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
6305
6306   /* Find the overflow area.  */
6307   t = make_tree (TREE_TYPE (ovf), virtual_incoming_args_rtx);
6308
6309   off = INTVAL (current_function_arg_offset_rtx);
6310   off = off < 0 ? 0 : off;
6311   if (TARGET_DEBUG_ARG)
6312     fprintf (stderr, "va_start: n_gpr = %d, n_fpr = %d off %d\n",
6313              (int)n_gpr, (int)n_fpr, off);
6314
6315   t = build (PLUS_EXPR, TREE_TYPE (ovf), t, build_int_2 (off, 0));
6316
6317   t = build (MODIFY_EXPR, TREE_TYPE (ovf), ovf, t);
6318   TREE_SIDE_EFFECTS (t) = 1;
6319   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
6320
6321   /* Find the register save area.  */
6322   t = make_tree (TREE_TYPE (sav), virtual_incoming_args_rtx);
6323   t = build (PLUS_EXPR, TREE_TYPE (sav), t,
6324              build_int_2 (-STACK_POINTER_OFFSET, -1));
6325   t = build (MODIFY_EXPR, TREE_TYPE (sav), sav, t);
6326   TREE_SIDE_EFFECTS (t) = 1;
6327   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
6328 }
6329
6330 /* Implement va_arg by updating the va_list structure
6331    VALIST as required to retrieve an argument of type
6332    TYPE, and returning that argument.
6333
6334    Generates code equivalent to:
6335
6336    if (integral value) {
6337      if (size  <= 4 && args.gpr < 5 ||
6338          size  > 4 && args.gpr < 4 )
6339        ret = args.reg_save_area[args.gpr+8]
6340      else
6341        ret = *args.overflow_arg_area++;
6342    } else if (float value) {
6343      if (args.fgpr < 2)
6344        ret = args.reg_save_area[args.fpr+64]
6345      else
6346        ret = *args.overflow_arg_area++;
6347    } else if (aggregate value) {
6348      if (args.gpr < 5)
6349        ret = *args.reg_save_area[args.gpr]
6350      else
6351        ret = **args.overflow_arg_area++;
6352    } */
6353
6354 rtx
6355 s390_va_arg (tree valist, tree type)
6356 {
6357   tree f_gpr, f_fpr, f_ovf, f_sav;
6358   tree gpr, fpr, ovf, sav, reg, t, u;
6359   int indirect_p, size, n_reg, sav_ofs, sav_scale, max_reg;
6360   rtx lab_false, lab_over, addr_rtx, r;
6361
6362   f_gpr = TYPE_FIELDS (TREE_TYPE (va_list_type_node));
6363   f_fpr = TREE_CHAIN (f_gpr);
6364   f_ovf = TREE_CHAIN (f_fpr);
6365   f_sav = TREE_CHAIN (f_ovf);
6366
6367   valist = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (valist)), valist);
6368   gpr = build (COMPONENT_REF, TREE_TYPE (f_gpr), valist, f_gpr);
6369   fpr = build (COMPONENT_REF, TREE_TYPE (f_fpr), valist, f_fpr);
6370   ovf = build (COMPONENT_REF, TREE_TYPE (f_ovf), valist, f_ovf);
6371   sav = build (COMPONENT_REF, TREE_TYPE (f_sav), valist, f_sav);
6372
6373   size = int_size_in_bytes (type);
6374
6375   if (s390_function_arg_pass_by_reference (TYPE_MODE (type), type))
6376     {
6377       if (TARGET_DEBUG_ARG)
6378         {
6379           fprintf (stderr, "va_arg: aggregate type");
6380           debug_tree (type);
6381         }
6382
6383       /* Aggregates are passed by reference.  */
6384       indirect_p = 1;
6385       reg = gpr;
6386       n_reg = 1;
6387       sav_ofs = 2 * UNITS_PER_WORD;
6388       sav_scale = UNITS_PER_WORD;
6389       size = UNITS_PER_WORD;
6390       max_reg = 4;
6391     }
6392   else if (s390_function_arg_float (TYPE_MODE (type), type))
6393     {
6394       if (TARGET_DEBUG_ARG)
6395         {
6396           fprintf (stderr, "va_arg: float type");
6397           debug_tree (type);
6398         }
6399
6400       /* FP args go in FP registers, if present.  */
6401       indirect_p = 0;
6402       reg = fpr;
6403       n_reg = 1;
6404       sav_ofs = 16 * UNITS_PER_WORD;
6405       sav_scale = 8;
6406       /* TARGET_64BIT has up to 4 parameter in fprs */
6407       max_reg = TARGET_64BIT ? 3 : 1;
6408     }
6409   else
6410     {
6411       if (TARGET_DEBUG_ARG)
6412         {
6413           fprintf (stderr, "va_arg: other type");
6414           debug_tree (type);
6415         }
6416
6417       /* Otherwise into GP registers.  */
6418       indirect_p = 0;
6419       reg = gpr;
6420       n_reg = (size + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
6421       sav_ofs = 2 * UNITS_PER_WORD;
6422
6423       if (size < UNITS_PER_WORD)
6424         sav_ofs += UNITS_PER_WORD - size;
6425
6426       sav_scale = UNITS_PER_WORD;
6427       if (n_reg > 1)
6428         max_reg = 3;
6429       else
6430         max_reg = 4;
6431     }
6432
6433   /* Pull the value out of the saved registers ...  */
6434
6435   lab_false = gen_label_rtx ();
6436   lab_over = gen_label_rtx ();
6437   addr_rtx = gen_reg_rtx (Pmode);
6438
6439   emit_cmp_and_jump_insns (expand_expr (reg, NULL_RTX, Pmode, EXPAND_NORMAL),
6440                            GEN_INT (max_reg),
6441                            GT, const1_rtx, Pmode, 0, lab_false);
6442
6443   if (sav_ofs)
6444     t = build (PLUS_EXPR, ptr_type_node, sav, build_int_2 (sav_ofs, 0));
6445   else
6446     t = sav;
6447
6448   u = build (MULT_EXPR, long_integer_type_node,
6449              reg, build_int_2 (sav_scale, 0));
6450   TREE_SIDE_EFFECTS (u) = 1;
6451
6452   t = build (PLUS_EXPR, ptr_type_node, t, u);
6453   TREE_SIDE_EFFECTS (t) = 1;
6454
6455   r = expand_expr (t, addr_rtx, Pmode, EXPAND_NORMAL);
6456   if (r != addr_rtx)
6457     emit_move_insn (addr_rtx, r);
6458
6459
6460   emit_jump_insn (gen_jump (lab_over));
6461   emit_barrier ();
6462   emit_label (lab_false);
6463
6464   /* ... Otherwise out of the overflow area.  */
6465
6466   t = save_expr (ovf);
6467
6468
6469   /* In 64 BIT for each argument on stack, a full 64 bit slot is allocated.  */
6470   if (size < UNITS_PER_WORD)
6471     {
6472       t = build (PLUS_EXPR, TREE_TYPE (t), t, build_int_2 (UNITS_PER_WORD-size, 0));
6473       t = build (MODIFY_EXPR, TREE_TYPE (ovf), ovf, t);
6474       TREE_SIDE_EFFECTS (t) = 1;
6475       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
6476
6477       t = save_expr (ovf);
6478     }
6479
6480   r = expand_expr (t, addr_rtx, Pmode, EXPAND_NORMAL);
6481   if (r != addr_rtx)
6482     emit_move_insn (addr_rtx, r);
6483
6484   t = build (PLUS_EXPR, TREE_TYPE (t), t, build_int_2 (size, 0));
6485   t = build (MODIFY_EXPR, TREE_TYPE (ovf), ovf, t);
6486   TREE_SIDE_EFFECTS (t) = 1;
6487   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
6488
6489   emit_label (lab_over);
6490
6491   /* If less than max_regs a registers are retrieved out
6492      of register save area, increment.  */
6493
6494   u = build (PREINCREMENT_EXPR, TREE_TYPE (reg), reg,
6495              build_int_2 (n_reg, 0));
6496   TREE_SIDE_EFFECTS (u) = 1;
6497   expand_expr (u, const0_rtx, VOIDmode, EXPAND_NORMAL);
6498
6499   if (indirect_p)
6500     {
6501       r = gen_rtx_MEM (Pmode, addr_rtx);
6502       set_mem_alias_set (r, get_varargs_alias_set ());
6503       emit_move_insn (addr_rtx, r);
6504     }
6505
6506
6507   return addr_rtx;
6508 }
6509
6510
6511 /* Builtins.  */
6512
6513 enum s390_builtin
6514 {
6515   S390_BUILTIN_THREAD_POINTER,
6516   S390_BUILTIN_SET_THREAD_POINTER,
6517
6518   S390_BUILTIN_max
6519 };
6520
6521 static unsigned int const code_for_builtin_64[S390_BUILTIN_max] = {
6522   CODE_FOR_get_tp_64,
6523   CODE_FOR_set_tp_64
6524 };
6525
6526 static unsigned int const code_for_builtin_31[S390_BUILTIN_max] = {
6527   CODE_FOR_get_tp_31,
6528   CODE_FOR_set_tp_31
6529 };
6530
6531 static void
6532 s390_init_builtins (void)
6533 {
6534   tree ftype;
6535
6536   ftype = build_function_type (ptr_type_node, void_list_node);
6537   builtin_function ("__builtin_thread_pointer", ftype,
6538                     S390_BUILTIN_THREAD_POINTER, BUILT_IN_MD,
6539                     NULL, NULL_TREE);
6540
6541   ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
6542   builtin_function ("__builtin_set_thread_pointer", ftype,
6543                     S390_BUILTIN_SET_THREAD_POINTER, BUILT_IN_MD,
6544                     NULL, NULL_TREE);
6545 }
6546
6547 /* Expand an expression EXP that calls a built-in function,
6548    with result going to TARGET if that's convenient
6549    (and in mode MODE if that's convenient).
6550    SUBTARGET may be used as the target for computing one of EXP's operands.
6551    IGNORE is nonzero if the value is to be ignored.  */
6552
6553 static rtx
6554 s390_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED,
6555                      enum machine_mode mode ATTRIBUTE_UNUSED,
6556                      int ignore ATTRIBUTE_UNUSED)
6557 {
6558 #define MAX_ARGS 2
6559
6560   unsigned int const *code_for_builtin =
6561     TARGET_64BIT ? code_for_builtin_64 : code_for_builtin_31;
6562
6563   tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
6564   unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
6565   tree arglist = TREE_OPERAND (exp, 1);
6566   enum insn_code icode;
6567   rtx op[MAX_ARGS], pat;
6568   int arity;
6569   bool nonvoid;
6570
6571   if (fcode >= S390_BUILTIN_max)
6572     internal_error ("bad builtin fcode");
6573   icode = code_for_builtin[fcode];
6574   if (icode == 0)
6575     internal_error ("bad builtin fcode");
6576
6577   nonvoid = TREE_TYPE (TREE_TYPE (fndecl)) != void_type_node;
6578
6579   for (arglist = TREE_OPERAND (exp, 1), arity = 0;
6580        arglist;
6581        arglist = TREE_CHAIN (arglist), arity++)
6582     {
6583       const struct insn_operand_data *insn_op;
6584
6585       tree arg = TREE_VALUE (arglist);
6586       if (arg == error_mark_node)
6587         return NULL_RTX;
6588       if (arity > MAX_ARGS)
6589         return NULL_RTX;
6590
6591       insn_op = &insn_data[icode].operand[arity + nonvoid];
6592
6593       op[arity] = expand_expr (arg, NULL_RTX, insn_op->mode, 0);
6594
6595       if (!(*insn_op->predicate) (op[arity], insn_op->mode))
6596         op[arity] = copy_to_mode_reg (insn_op->mode, op[arity]);
6597     }
6598
6599   if (nonvoid)
6600     {
6601       enum machine_mode tmode = insn_data[icode].operand[0].mode;
6602       if (!target
6603           || GET_MODE (target) != tmode
6604           || !(*insn_data[icode].operand[0].predicate) (target, tmode))
6605         target = gen_reg_rtx (tmode);
6606     }
6607
6608   switch (arity)
6609     {
6610     case 0:
6611       pat = GEN_FCN (icode) (target);
6612       break;
6613     case 1:
6614       if (nonvoid)
6615         pat = GEN_FCN (icode) (target, op[0]);
6616       else
6617         pat = GEN_FCN (icode) (op[0]);
6618       break;
6619     case 2:
6620       pat = GEN_FCN (icode) (target, op[0], op[1]);
6621       break;
6622     default:
6623       abort ();
6624     }
6625   if (!pat)
6626     return NULL_RTX;
6627   emit_insn (pat);
6628
6629   if (nonvoid)
6630     return target;
6631   else
6632     return const0_rtx;
6633 }
6634
6635
6636 /* Output assembly code for the trampoline template to
6637    stdio stream FILE.
6638
6639    On S/390, we use gpr 1 internally in the trampoline code;
6640    gpr 0 is used to hold the static chain.  */
6641
6642 void
6643 s390_trampoline_template (FILE *file)
6644 {
6645   if (TARGET_64BIT)
6646     {
6647       fprintf (file, "larl\t%s,0f\n", reg_names[1]);
6648       fprintf (file, "lg\t%s,0(%s)\n", reg_names[0], reg_names[1]);
6649       fprintf (file, "lg\t%s,8(%s)\n", reg_names[1], reg_names[1]);
6650       fprintf (file, "br\t%s\n", reg_names[1]);
6651       fprintf (file, "0:\t.quad\t0\n");
6652       fprintf (file, ".quad\t0\n");
6653     }
6654   else
6655     {
6656       fprintf (file, "basr\t%s,0\n", reg_names[1]);
6657       fprintf (file, "l\t%s,10(%s)\n", reg_names[0], reg_names[1]);
6658       fprintf (file, "l\t%s,14(%s)\n", reg_names[1], reg_names[1]);
6659       fprintf (file, "br\t%s\n", reg_names[1]);
6660       fprintf (file, ".long\t0\n");
6661       fprintf (file, ".long\t0\n");
6662     }
6663 }
6664
6665 /* Emit RTL insns to initialize the variable parts of a trampoline.
6666    FNADDR is an RTX for the address of the function's pure code.
6667    CXT is an RTX for the static chain value for the function.  */
6668
6669 void
6670 s390_initialize_trampoline (rtx addr, rtx fnaddr, rtx cxt)
6671 {
6672   emit_move_insn (gen_rtx
6673                   (MEM, Pmode,
6674                    memory_address (Pmode,
6675                    plus_constant (addr, (TARGET_64BIT ? 20 : 12) ))), cxt);
6676   emit_move_insn (gen_rtx
6677                   (MEM, Pmode,
6678                    memory_address (Pmode,
6679                    plus_constant (addr, (TARGET_64BIT ? 28 : 16) ))), fnaddr);
6680 }
6681
6682 /* Return rtx for 64-bit constant formed from the 32-bit subwords
6683    LOW and HIGH, independent of the host word size.  */
6684
6685 rtx
6686 s390_gen_rtx_const_DI (int high, int low)
6687 {
6688 #if HOST_BITS_PER_WIDE_INT >= 64
6689   HOST_WIDE_INT val;
6690   val = (HOST_WIDE_INT)high;
6691   val <<= 32;
6692   val |= (HOST_WIDE_INT)low;
6693
6694   return GEN_INT (val);
6695 #else
6696 #if HOST_BITS_PER_WIDE_INT >= 32
6697   return immed_double_const ((HOST_WIDE_INT)low, (HOST_WIDE_INT)high, DImode);
6698 #else
6699   abort ();
6700 #endif
6701 #endif
6702 }
6703
6704 /* Output assembler code to FILE to increment profiler label # LABELNO
6705    for profiling a function entry.  */
6706
6707 void
6708 s390_function_profiler (FILE *file, int labelno)
6709 {
6710   rtx op[7];
6711
6712   char label[128];
6713   ASM_GENERATE_INTERNAL_LABEL (label, "LP", labelno);
6714
6715   fprintf (file, "# function profiler \n");
6716
6717   op[0] = gen_rtx_REG (Pmode, RETURN_REGNUM);
6718   op[1] = gen_rtx_REG (Pmode, STACK_POINTER_REGNUM);
6719   op[1] = gen_rtx_MEM (Pmode, plus_constant (op[1], UNITS_PER_WORD));
6720
6721   op[2] = gen_rtx_REG (Pmode, 1);
6722   op[3] = gen_rtx_SYMBOL_REF (Pmode, label);
6723   SYMBOL_REF_FLAGS (op[3]) = SYMBOL_FLAG_LOCAL;
6724
6725   op[4] = gen_rtx_SYMBOL_REF (Pmode, "_mcount");
6726   if (flag_pic)
6727     {
6728       op[4] = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, op[4]), UNSPEC_PLT);
6729       op[4] = gen_rtx_CONST (Pmode, op[4]);
6730     }
6731
6732   if (TARGET_64BIT)
6733     {
6734       output_asm_insn ("stg\t%0,%1", op);
6735       output_asm_insn ("larl\t%2,%3", op);
6736       output_asm_insn ("brasl\t%0,%4", op);
6737       output_asm_insn ("lg\t%0,%1", op);
6738     }
6739   else if (!flag_pic)
6740     {
6741       op[6] = gen_label_rtx ();
6742
6743       output_asm_insn ("st\t%0,%1", op);
6744       output_asm_insn ("bras\t%2,%l6", op);
6745       output_asm_insn (".long\t%4", op);
6746       output_asm_insn (".long\t%3", op);
6747       targetm.asm_out.internal_label (file, "L", CODE_LABEL_NUMBER (op[6]));
6748       output_asm_insn ("l\t%0,0(%2)", op);
6749       output_asm_insn ("l\t%2,4(%2)", op);
6750       output_asm_insn ("basr\t%0,%0", op);
6751       output_asm_insn ("l\t%0,%1", op);
6752     }
6753   else
6754     {
6755       op[5] = gen_label_rtx ();
6756       op[6] = gen_label_rtx ();
6757
6758       output_asm_insn ("st\t%0,%1", op);
6759       output_asm_insn ("bras\t%2,%l6", op);
6760       targetm.asm_out.internal_label (file, "L", CODE_LABEL_NUMBER (op[5]));
6761       output_asm_insn (".long\t%4-%l5", op);
6762       output_asm_insn (".long\t%3-%l5", op);
6763       targetm.asm_out.internal_label (file, "L", CODE_LABEL_NUMBER (op[6]));
6764       output_asm_insn ("lr\t%0,%2", op);
6765       output_asm_insn ("a\t%0,0(%2)", op);
6766       output_asm_insn ("a\t%2,4(%2)", op);
6767       output_asm_insn ("basr\t%0,%0", op);
6768       output_asm_insn ("l\t%0,%1", op);
6769     }
6770 }
6771
6772 /* Select section for constant in constant pool.  In 32-bit mode,
6773    constants go in the function section; in 64-bit mode in .rodata.  */
6774
6775 static void
6776 s390_select_rtx_section (enum machine_mode mode ATTRIBUTE_UNUSED,
6777                          rtx x ATTRIBUTE_UNUSED,
6778                          unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
6779 {
6780   if (TARGET_CPU_ZARCH)
6781     readonly_data_section ();
6782   else
6783     function_section (current_function_decl);
6784 }
6785
6786 /* Encode symbol attributes (local vs. global, tls model) of a SYMBOL_REF
6787    into its SYMBOL_REF_FLAGS.  */
6788
6789 static void
6790 s390_encode_section_info (tree decl, rtx rtl, int first)
6791 {
6792   default_encode_section_info (decl, rtl, first);
6793
6794   /* If a variable has a forced alignment to < 2 bytes, mark it with
6795      SYMBOL_FLAG_ALIGN1 to prevent it from being used as LARL operand.  */
6796   if (TREE_CODE (decl) == VAR_DECL
6797       && DECL_USER_ALIGN (decl) && DECL_ALIGN (decl) < 16)
6798     SYMBOL_REF_FLAGS (XEXP (rtl, 0)) |= SYMBOL_FLAG_ALIGN1;
6799 }
6800
6801 /* Output thunk to FILE that implements a C++ virtual function call (with
6802    multiple inheritance) to FUNCTION.  The thunk adjusts the this pointer
6803    by DELTA, and unless VCALL_OFFSET is zero, applies an additional adjustment
6804    stored at VCALL_OFFSET in the vtable whose address is located at offset 0
6805    relative to the resulting this pointer.  */
6806
6807 static void
6808 s390_output_mi_thunk (FILE *file, tree thunk ATTRIBUTE_UNUSED,
6809                       HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset,
6810                       tree function)
6811 {
6812   rtx op[10];
6813   int nonlocal = 0;
6814
6815   /* Operand 0 is the target function.  */
6816   op[0] = XEXP (DECL_RTL (function), 0);
6817   if (flag_pic && !SYMBOL_REF_LOCAL_P (op[0]))
6818     {
6819       nonlocal = 1;
6820       op[0] = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, op[0]),
6821                               TARGET_64BIT ? UNSPEC_PLT : UNSPEC_GOT);
6822       op[0] = gen_rtx_CONST (Pmode, op[0]);
6823     }
6824
6825   /* Operand 1 is the 'this' pointer.  */
6826   if (aggregate_value_p (TREE_TYPE (TREE_TYPE (function)), function))
6827     op[1] = gen_rtx_REG (Pmode, 3);
6828   else
6829     op[1] = gen_rtx_REG (Pmode, 2);
6830
6831   /* Operand 2 is the delta.  */
6832   op[2] = GEN_INT (delta);
6833
6834   /* Operand 3 is the vcall_offset.  */
6835   op[3] = GEN_INT (vcall_offset);
6836
6837   /* Operand 4 is the temporary register.  */
6838   op[4] = gen_rtx_REG (Pmode, 1);
6839
6840   /* Operands 5 to 8 can be used as labels.  */
6841   op[5] = NULL_RTX;
6842   op[6] = NULL_RTX;
6843   op[7] = NULL_RTX;
6844   op[8] = NULL_RTX;
6845
6846   /* Operand 9 can be used for temporary register.  */
6847   op[9] = NULL_RTX;
6848
6849   /* Generate code.  */
6850   if (TARGET_64BIT)
6851     {
6852       /* Setup literal pool pointer if required.  */
6853       if ((!DISP_IN_RANGE (delta)
6854            && !CONST_OK_FOR_CONSTRAINT_P (delta, 'K', "K"))
6855           || (!DISP_IN_RANGE (vcall_offset)
6856               && !CONST_OK_FOR_CONSTRAINT_P (vcall_offset, 'K', "K")))
6857         {
6858           op[5] = gen_label_rtx ();
6859           output_asm_insn ("larl\t%4,%5", op);
6860         }
6861
6862       /* Add DELTA to this pointer.  */
6863       if (delta)
6864         {
6865           if (CONST_OK_FOR_CONSTRAINT_P (delta, 'J', "J"))
6866             output_asm_insn ("la\t%1,%2(%1)", op);
6867           else if (DISP_IN_RANGE (delta))
6868             output_asm_insn ("lay\t%1,%2(%1)", op);
6869           else if (CONST_OK_FOR_CONSTRAINT_P (delta, 'K', "K"))
6870             output_asm_insn ("aghi\t%1,%2", op);
6871           else
6872             {
6873               op[6] = gen_label_rtx ();
6874               output_asm_insn ("agf\t%1,%6-%5(%4)", op);
6875             }
6876         }
6877
6878       /* Perform vcall adjustment.  */
6879       if (vcall_offset)
6880         {
6881           if (DISP_IN_RANGE (vcall_offset))
6882             {
6883               output_asm_insn ("lg\t%4,0(%1)", op);
6884               output_asm_insn ("ag\t%1,%3(%4)", op);
6885             }
6886           else if (CONST_OK_FOR_CONSTRAINT_P (vcall_offset, 'K', "K"))
6887             {
6888               output_asm_insn ("lghi\t%4,%3", op);
6889               output_asm_insn ("ag\t%4,0(%1)", op);
6890               output_asm_insn ("ag\t%1,0(%4)", op);
6891             }
6892           else
6893             {
6894               op[7] = gen_label_rtx ();
6895               output_asm_insn ("llgf\t%4,%7-%5(%4)", op);
6896               output_asm_insn ("ag\t%4,0(%1)", op);
6897               output_asm_insn ("ag\t%1,0(%4)", op);
6898             }
6899         }
6900
6901       /* Jump to target.  */
6902       output_asm_insn ("jg\t%0", op);
6903
6904       /* Output literal pool if required.  */
6905       if (op[5])
6906         {
6907           output_asm_insn (".align\t4", op);
6908           targetm.asm_out.internal_label (file, "L",
6909                                           CODE_LABEL_NUMBER (op[5]));
6910         }
6911       if (op[6])
6912         {
6913           targetm.asm_out.internal_label (file, "L",
6914                                           CODE_LABEL_NUMBER (op[6]));
6915           output_asm_insn (".long\t%2", op);
6916         }
6917       if (op[7])
6918         {
6919           targetm.asm_out.internal_label (file, "L",
6920                                           CODE_LABEL_NUMBER (op[7]));
6921           output_asm_insn (".long\t%3", op);
6922         }
6923     }
6924   else
6925     {
6926       /* Setup base pointer if required.  */
6927       if (!vcall_offset
6928           || (!DISP_IN_RANGE (delta)
6929               && !CONST_OK_FOR_CONSTRAINT_P (delta, 'K', "K"))
6930           || (!DISP_IN_RANGE (delta)
6931               && !CONST_OK_FOR_CONSTRAINT_P (vcall_offset, 'K', "K")))
6932         {
6933           op[5] = gen_label_rtx ();
6934           output_asm_insn ("basr\t%4,0", op);
6935           targetm.asm_out.internal_label (file, "L",
6936                                           CODE_LABEL_NUMBER (op[5]));
6937         }
6938
6939       /* Add DELTA to this pointer.  */
6940       if (delta)
6941         {
6942           if (CONST_OK_FOR_CONSTRAINT_P (delta, 'J', "J"))
6943             output_asm_insn ("la\t%1,%2(%1)", op);
6944           else if (DISP_IN_RANGE (delta))
6945             output_asm_insn ("lay\t%1,%2(%1)", op);
6946           else if (CONST_OK_FOR_CONSTRAINT_P (delta, 'K', "K"))
6947             output_asm_insn ("ahi\t%1,%2", op);
6948           else
6949             {
6950               op[6] = gen_label_rtx ();
6951               output_asm_insn ("a\t%1,%6-%5(%4)", op);
6952             }
6953         }
6954
6955       /* Perform vcall adjustment.  */
6956       if (vcall_offset)
6957         {
6958           if (CONST_OK_FOR_CONSTRAINT_P (vcall_offset, 'J', "J"))
6959             {
6960               output_asm_insn ("lg\t%4,0(%1)", op);
6961               output_asm_insn ("a\t%1,%3(%4)", op);
6962             }
6963           else if (DISP_IN_RANGE (vcall_offset))
6964             {
6965               output_asm_insn ("lg\t%4,0(%1)", op);
6966               output_asm_insn ("ay\t%1,%3(%4)", op);
6967             }
6968           else if (CONST_OK_FOR_CONSTRAINT_P (vcall_offset, 'K', "K"))
6969             {
6970               output_asm_insn ("lhi\t%4,%3", op);
6971               output_asm_insn ("a\t%4,0(%1)", op);
6972               output_asm_insn ("a\t%1,0(%4)", op);
6973             }
6974           else
6975             {
6976               op[7] = gen_label_rtx ();
6977               output_asm_insn ("l\t%4,%7-%5(%4)", op);
6978               output_asm_insn ("a\t%4,0(%1)", op);
6979               output_asm_insn ("a\t%1,0(%4)", op);
6980             }
6981
6982           /* We had to clobber the base pointer register.
6983              Re-setup the base pointer (with a different base).  */
6984           op[5] = gen_label_rtx ();
6985           output_asm_insn ("basr\t%4,0", op);
6986           targetm.asm_out.internal_label (file, "L",
6987                                           CODE_LABEL_NUMBER (op[5]));
6988         }
6989
6990       /* Jump to target.  */
6991       op[8] = gen_label_rtx ();
6992
6993       if (!flag_pic)
6994         output_asm_insn ("l\t%4,%8-%5(%4)", op);
6995       else if (!nonlocal)
6996         output_asm_insn ("a\t%4,%8-%5(%4)", op);
6997       /* We cannot call through .plt, since .plt requires %r12 loaded.  */
6998       else if (flag_pic == 1)
6999         {
7000           output_asm_insn ("a\t%4,%8-%5(%4)", op);
7001           output_asm_insn ("l\t%4,%0(%4)", op);
7002         }
7003       else if (flag_pic == 2)
7004         {
7005           op[9] = gen_rtx_REG (Pmode, 0);
7006           output_asm_insn ("l\t%9,%8-4-%5(%4)", op);
7007           output_asm_insn ("a\t%4,%8-%5(%4)", op);
7008           output_asm_insn ("ar\t%4,%9", op);
7009           output_asm_insn ("l\t%4,0(%4)", op);
7010         }
7011
7012       output_asm_insn ("br\t%4", op);
7013
7014       /* Output literal pool.  */
7015       output_asm_insn (".align\t4", op);
7016
7017       if (nonlocal && flag_pic == 2)
7018         output_asm_insn (".long\t%0", op);
7019       if (nonlocal)
7020         {
7021           op[0] = gen_rtx_SYMBOL_REF (Pmode, "_GLOBAL_OFFSET_TABLE_");
7022           SYMBOL_REF_FLAGS (op[0]) = SYMBOL_FLAG_LOCAL;
7023         }
7024
7025       targetm.asm_out.internal_label (file, "L", CODE_LABEL_NUMBER (op[8]));
7026       if (!flag_pic)
7027         output_asm_insn (".long\t%0", op);
7028       else
7029         output_asm_insn (".long\t%0-%5", op);
7030
7031       if (op[6])
7032         {
7033           targetm.asm_out.internal_label (file, "L",
7034                                           CODE_LABEL_NUMBER (op[6]));
7035           output_asm_insn (".long\t%2", op);
7036         }
7037       if (op[7])
7038         {
7039           targetm.asm_out.internal_label (file, "L",
7040                                           CODE_LABEL_NUMBER (op[7]));
7041           output_asm_insn (".long\t%3", op);
7042         }
7043     }
7044 }
7045
7046 bool
7047 s390_valid_pointer_mode (enum machine_mode mode)
7048 {
7049   return (mode == SImode || (TARGET_64BIT && mode == DImode));
7050 }
7051
7052 /* How to allocate a 'struct machine_function'.  */
7053
7054 static struct machine_function *
7055 s390_init_machine_status (void)
7056 {
7057   return ggc_alloc_cleared (sizeof (struct machine_function));
7058 }
7059
7060 #include "gt-s390.h"