?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2008-07-01 Jerry DeLisle <jvdelisle@gcc.gnu.org>
[official-gcc.git] / gcc / config / s390 / s390.c
blobb9f231729a60c2e18e86c9c145e79e10d05ecf12
1 /* Subroutines used for code generation on IBM S/390 and zSeries
2 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
3 2007, 2008 Free Software Foundation, Inc.
4 Contributed by Hartmut Penner (hpenner@de.ibm.com) and
5 Ulrich Weigand (uweigand@de.ibm.com) and
6 Andreas Krebbel (Andreas.Krebbel@de.ibm.com).
7
8 This file is part of GCC.
9
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
13 version.
14
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
23
24 #include "config.h"
25 #include "system.h"
26 #include "coretypes.h"
27 #include "tm.h"
28 #include "rtl.h"
29 #include "tree.h"
30 #include "tm_p.h"
31 #include "regs.h"
32 #include "hard-reg-set.h"
33 #include "real.h"
34 #include "insn-config.h"
35 #include "conditions.h"
36 #include "output.h"
37 #include "insn-attr.h"
38 #include "flags.h"
39 #include "except.h"
40 #include "function.h"
41 #include "recog.h"
42 #include "expr.h"
43 #include "reload.h"
44 #include "toplev.h"
45 #include "basic-block.h"
46 #include "integrate.h"
47 #include "ggc.h"
48 #include "target.h"
49 #include "target-def.h"
50 #include "debug.h"
51 #include "langhooks.h"
52 #include "optabs.h"
53 #include "tree-gimple.h"
54 #include "df.h"
55
56
57 /* Define the specific costs for a given cpu. */
58
59 struct processor_costs
60 {
61 /* multiplication */
62 const int m; /* cost of an M instruction. */
63 const int mghi; /* cost of an MGHI instruction. */
64 const int mh; /* cost of an MH instruction. */
65 const int mhi; /* cost of an MHI instruction. */
66 const int ml; /* cost of an ML instruction. */
67 const int mr; /* cost of an MR instruction. */
68 const int ms; /* cost of an MS instruction. */
69 const int msg; /* cost of an MSG instruction. */
70 const int msgf; /* cost of an MSGF instruction. */
71 const int msgfr; /* cost of an MSGFR instruction. */
72 const int msgr; /* cost of an MSGR instruction. */
73 const int msr; /* cost of an MSR instruction. */
74 const int mult_df; /* cost of multiplication in DFmode. */
75 const int mxbr;
76 /* square root */
77 const int sqxbr; /* cost of square root in TFmode. */
78 const int sqdbr; /* cost of square root in DFmode. */
79 const int sqebr; /* cost of square root in SFmode. */
80 /* multiply and add */
81 const int madbr; /* cost of multiply and add in DFmode. */
82 const int maebr; /* cost of multiply and add in SFmode. */
83 /* division */
84 const int dxbr;
85 const int ddbr;
86 const int debr;
87 const int dlgr;
88 const int dlr;
89 const int dr;
90 const int dsgfr;
91 const int dsgr;
92 };
93
94 const struct processor_costs *s390_cost;
95
96 static const
97 struct processor_costs z900_cost =
98 {
99 COSTS_N_INSNS (5), /* M */
100 COSTS_N_INSNS (10), /* MGHI */
101 COSTS_N_INSNS (5), /* MH */
102 COSTS_N_INSNS (4), /* MHI */
103 COSTS_N_INSNS (5), /* ML */
104 COSTS_N_INSNS (5), /* MR */
105 COSTS_N_INSNS (4), /* MS */
106 COSTS_N_INSNS (15), /* MSG */
107 COSTS_N_INSNS (7), /* MSGF */
108 COSTS_N_INSNS (7), /* MSGFR */
109 COSTS_N_INSNS (10), /* MSGR */
110 COSTS_N_INSNS (4), /* MSR */
111 COSTS_N_INSNS (7), /* multiplication in DFmode */
112 COSTS_N_INSNS (13), /* MXBR */
113 COSTS_N_INSNS (136), /* SQXBR */
114 COSTS_N_INSNS (44), /* SQDBR */
115 COSTS_N_INSNS (35), /* SQEBR */
116 COSTS_N_INSNS (18), /* MADBR */
117 COSTS_N_INSNS (13), /* MAEBR */
118 COSTS_N_INSNS (134), /* DXBR */
119 COSTS_N_INSNS (30), /* DDBR */
120 COSTS_N_INSNS (27), /* DEBR */
121 COSTS_N_INSNS (220), /* DLGR */
122 COSTS_N_INSNS (34), /* DLR */
123 COSTS_N_INSNS (34), /* DR */
124 COSTS_N_INSNS (32), /* DSGFR */
125 COSTS_N_INSNS (32), /* DSGR */
126 };
127
128 static const
129 struct processor_costs z990_cost =
130 {
131 COSTS_N_INSNS (4), /* M */
132 COSTS_N_INSNS (2), /* MGHI */
133 COSTS_N_INSNS (2), /* MH */
134 COSTS_N_INSNS (2), /* MHI */
135 COSTS_N_INSNS (4), /* ML */
136 COSTS_N_INSNS (4), /* MR */
137 COSTS_N_INSNS (5), /* MS */
138 COSTS_N_INSNS (6), /* MSG */
139 COSTS_N_INSNS (4), /* MSGF */
140 COSTS_N_INSNS (4), /* MSGFR */
141 COSTS_N_INSNS (4), /* MSGR */
142 COSTS_N_INSNS (4), /* MSR */
143 COSTS_N_INSNS (1), /* multiplication in DFmode */
144 COSTS_N_INSNS (28), /* MXBR */
145 COSTS_N_INSNS (130), /* SQXBR */
146 COSTS_N_INSNS (66), /* SQDBR */
147 COSTS_N_INSNS (38), /* SQEBR */
148 COSTS_N_INSNS (1), /* MADBR */
149 COSTS_N_INSNS (1), /* MAEBR */
150 COSTS_N_INSNS (60), /* DXBR */
151 COSTS_N_INSNS (40), /* DDBR */
152 COSTS_N_INSNS (26), /* DEBR */
153 COSTS_N_INSNS (176), /* DLGR */
154 COSTS_N_INSNS (31), /* DLR */
155 COSTS_N_INSNS (31), /* DR */
156 COSTS_N_INSNS (31), /* DSGFR */
157 COSTS_N_INSNS (31), /* DSGR */
158 };
159
160 static const
161 struct processor_costs z9_109_cost =
162 {
163 COSTS_N_INSNS (4), /* M */
164 COSTS_N_INSNS (2), /* MGHI */
165 COSTS_N_INSNS (2), /* MH */
166 COSTS_N_INSNS (2), /* MHI */
167 COSTS_N_INSNS (4), /* ML */
168 COSTS_N_INSNS (4), /* MR */
169 COSTS_N_INSNS (5), /* MS */
170 COSTS_N_INSNS (6), /* MSG */
171 COSTS_N_INSNS (4), /* MSGF */
172 COSTS_N_INSNS (4), /* MSGFR */
173 COSTS_N_INSNS (4), /* MSGR */
174 COSTS_N_INSNS (4), /* MSR */
175 COSTS_N_INSNS (1), /* multiplication in DFmode */
176 COSTS_N_INSNS (28), /* MXBR */
177 COSTS_N_INSNS (130), /* SQXBR */
178 COSTS_N_INSNS (66), /* SQDBR */
179 COSTS_N_INSNS (38), /* SQEBR */
180 COSTS_N_INSNS (1), /* MADBR */
181 COSTS_N_INSNS (1), /* MAEBR */
182 COSTS_N_INSNS (60), /* DXBR */
183 COSTS_N_INSNS (40), /* DDBR */
184 COSTS_N_INSNS (26), /* DEBR */
185 COSTS_N_INSNS (30), /* DLGR */
186 COSTS_N_INSNS (23), /* DLR */
187 COSTS_N_INSNS (23), /* DR */
188 COSTS_N_INSNS (24), /* DSGFR */
189 COSTS_N_INSNS (24), /* DSGR */
190 };
191
192 static const
193 struct processor_costs z10_cost =
194 {
195 COSTS_N_INSNS (4), /* M */
196 COSTS_N_INSNS (2), /* MGHI */
197 COSTS_N_INSNS (2), /* MH */
198 COSTS_N_INSNS (2), /* MHI */
199 COSTS_N_INSNS (4), /* ML */
200 COSTS_N_INSNS (4), /* MR */
201 COSTS_N_INSNS (5), /* MS */
202 COSTS_N_INSNS (6), /* MSG */
203 COSTS_N_INSNS (4), /* MSGF */
204 COSTS_N_INSNS (4), /* MSGFR */
205 COSTS_N_INSNS (4), /* MSGR */
206 COSTS_N_INSNS (4), /* MSR */
207 COSTS_N_INSNS (1), /* multiplication in DFmode */
208 COSTS_N_INSNS (28), /* MXBR */
209 COSTS_N_INSNS (130), /* SQXBR */
210 COSTS_N_INSNS (66), /* SQDBR */
211 COSTS_N_INSNS (38), /* SQEBR */
212 COSTS_N_INSNS (1), /* MADBR */
213 COSTS_N_INSNS (1), /* MAEBR */
214 COSTS_N_INSNS (60), /* DXBR */
215 COSTS_N_INSNS (40), /* DDBR */
216 COSTS_N_INSNS (26), /* DEBR */
217 COSTS_N_INSNS (30), /* DLGR */
218 COSTS_N_INSNS (23), /* DLR */
219 COSTS_N_INSNS (23), /* DR */
220 COSTS_N_INSNS (24), /* DSGFR */
221 COSTS_N_INSNS (24), /* DSGR */
222 };
223
224 extern int reload_completed;
225
226 /* Save information from a "cmpxx" operation until the branch or scc is
227 emitted. */
228 rtx s390_compare_op0, s390_compare_op1;
229
230 /* Save the result of a compare_and_swap until the branch or scc is
231 emitted. */
232 rtx s390_compare_emitted = NULL_RTX;
233
234 /* Structure used to hold the components of a S/390 memory
235 address. A legitimate address on S/390 is of the general
236 form
237 base + index + displacement
238 where any of the components is optional.
239
240 base and index are registers of the class ADDR_REGS,
241 displacement is an unsigned 12-bit immediate constant. */
242
243 struct s390_address
244 {
245 rtx base;
246 rtx indx;
247 rtx disp;
248 bool pointer;
249 bool literal_pool;
250 };
251
252 /* Which cpu are we tuning for. */
253 enum processor_type s390_tune = PROCESSOR_max;
254 enum processor_flags s390_tune_flags;
255 /* Which instruction set architecture to use. */
256 enum processor_type s390_arch;
257 enum processor_flags s390_arch_flags;
258
259 HOST_WIDE_INT s390_warn_framesize = 0;
260 HOST_WIDE_INT s390_stack_size = 0;
261 HOST_WIDE_INT s390_stack_guard = 0;
262
263 /* The following structure is embedded in the machine
264 specific part of struct function. */
265
266 struct s390_frame_layout GTY (())
267 {
268 /* Offset within stack frame. */
269 HOST_WIDE_INT gprs_offset;
270 HOST_WIDE_INT f0_offset;
271 HOST_WIDE_INT f4_offset;
272 HOST_WIDE_INT f8_offset;
273 HOST_WIDE_INT backchain_offset;
274
275 /* Number of first and last gpr where slots in the register
276 save area are reserved for. */
277 int first_save_gpr_slot;
278 int last_save_gpr_slot;
279
280 /* Number of first and last gpr to be saved, restored. */
281 int first_save_gpr;
282 int first_restore_gpr;
283 int last_save_gpr;
284 int last_restore_gpr;
285
286 /* Bits standing for floating point registers. Set, if the
287 respective register has to be saved. Starting with reg 16 (f0)
288 at the rightmost bit.
289 Bit 15 - 8 7 6 5 4 3 2 1 0
290 fpr 15 - 8 7 5 3 1 6 4 2 0
291 reg 31 - 24 23 22 21 20 19 18 17 16 */
292 unsigned int fpr_bitmap;
293
294 /* Number of floating point registers f8-f15 which must be saved. */
295 int high_fprs;
296
297 /* Set if return address needs to be saved.
298 This flag is set by s390_return_addr_rtx if it could not use
299 the initial value of r14 and therefore depends on r14 saved
300 to the stack. */
301 bool save_return_addr_p;
302
303 /* Size of stack frame. */
304 HOST_WIDE_INT frame_size;
305 };
306
307 /* Define the structure for the machine field in struct function. */
308
309 struct machine_function GTY(())
310 {
311 struct s390_frame_layout frame_layout;
312
313 /* Literal pool base register. */
314 rtx base_reg;
315
316 /* True if we may need to perform branch splitting. */
317 bool split_branches_pending_p;
318
319 /* True during final stage of literal pool processing. */
320 bool decomposed_literal_pool_addresses_ok_p;
321
322 /* Some local-dynamic TLS symbol name. */
323 const char *some_ld_name;
324
325 bool has_landing_pad_p;
326 };
327
328 /* Few accessor macros for struct cfun->machine->s390_frame_layout. */
329
330 #define cfun_frame_layout (cfun->machine->frame_layout)
331 #define cfun_save_high_fprs_p (!!cfun_frame_layout.high_fprs)
332 #define cfun_gprs_save_area_size ((cfun_frame_layout.last_save_gpr_slot - \
333 cfun_frame_layout.first_save_gpr_slot + 1) * UNITS_PER_WORD)
334 #define cfun_set_fpr_bit(BITNUM) (cfun->machine->frame_layout.fpr_bitmap |= \
335 (1 << (BITNUM)))
336 #define cfun_fpr_bit_p(BITNUM) (!!(cfun->machine->frame_layout.fpr_bitmap & \
337 (1 << (BITNUM))))
338
339 /* Number of GPRs and FPRs used for argument passing. */
340 #define GP_ARG_NUM_REG 5
341 #define FP_ARG_NUM_REG (TARGET_64BIT? 4 : 2)
342
343 /* A couple of shortcuts. */
344 #define CONST_OK_FOR_J(x) \
345 CONST_OK_FOR_CONSTRAINT_P((x), 'J', "J")
346 #define CONST_OK_FOR_K(x) \
347 CONST_OK_FOR_CONSTRAINT_P((x), 'K', "K")
348 #define CONST_OK_FOR_Os(x) \
349 CONST_OK_FOR_CONSTRAINT_P((x), 'O', "Os")
350 #define CONST_OK_FOR_Op(x) \
351 CONST_OK_FOR_CONSTRAINT_P((x), 'O', "Op")
352 #define CONST_OK_FOR_On(x) \
353 CONST_OK_FOR_CONSTRAINT_P((x), 'O', "On")
354
355 #define REGNO_PAIR_OK(REGNO, MODE) \
356 (HARD_REGNO_NREGS ((REGNO), (MODE)) == 1 || !((REGNO) & 1))
357
358 static enum machine_mode
359 s390_libgcc_cmp_return_mode (void)
360 {
361 return TARGET_64BIT ? DImode : SImode;
362 }
363
364 static enum machine_mode
365 s390_libgcc_shift_count_mode (void)
366 {
367 return TARGET_64BIT ? DImode : SImode;
368 }
369
370 /* Return true if the back end supports mode MODE. */
371 static bool
372 s390_scalar_mode_supported_p (enum machine_mode mode)
373 {
374 if (DECIMAL_FLOAT_MODE_P (mode))
375 return true;
376 else
377 return default_scalar_mode_supported_p (mode);
378 }
379
380 /* Set the has_landing_pad_p flag in struct machine_function to VALUE. */
381
382 void
383 s390_set_has_landing_pad_p (bool value)
384 {
385 cfun->machine->has_landing_pad_p = value;
386 }
387
388 /* If two condition code modes are compatible, return a condition code
389 mode which is compatible with both. Otherwise, return
390 VOIDmode. */
391
392 static enum machine_mode
393 s390_cc_modes_compatible (enum machine_mode m1, enum machine_mode m2)
394 {
395 if (m1 == m2)
396 return m1;
397
398 switch (m1)
399 {
400 case CCZmode:
401 if (m2 == CCUmode || m2 == CCTmode || m2 == CCZ1mode
402 || m2 == CCSmode || m2 == CCSRmode || m2 == CCURmode)
403 return m2;
404 return VOIDmode;
405
406 case CCSmode:
407 case CCUmode:
408 case CCTmode:
409 case CCSRmode:
410 case CCURmode:
411 case CCZ1mode:
412 if (m2 == CCZmode)
413 return m1;
414
415 return VOIDmode;
416
417 default:
418 return VOIDmode;
419 }
420 return VOIDmode;
421 }
422
423 /* Return true if SET either doesn't set the CC register, or else
424 the source and destination have matching CC modes and that
425 CC mode is at least as constrained as REQ_MODE. */
426
427 static bool
428 s390_match_ccmode_set (rtx set, enum machine_mode req_mode)
429 {
430 enum machine_mode set_mode;
431
432 gcc_assert (GET_CODE (set) == SET);
433
434 if (GET_CODE (SET_DEST (set)) != REG || !CC_REGNO_P (REGNO (SET_DEST (set))))
435 return 1;
436
437 set_mode = GET_MODE (SET_DEST (set));
438 switch (set_mode)
439 {
440 case CCSmode:
441 case CCSRmode:
442 case CCUmode:
443 case CCURmode:
444 case CCLmode:
445 case CCL1mode:
446 case CCL2mode:
447 case CCL3mode:
448 case CCT1mode:
449 case CCT2mode:
450 case CCT3mode:
451 if (req_mode != set_mode)
452 return 0;
453 break;
454
455 case CCZmode:
456 if (req_mode != CCSmode && req_mode != CCUmode && req_mode != CCTmode
457 && req_mode != CCSRmode && req_mode != CCURmode)
458 return 0;
459 break;
460
461 case CCAPmode:
462 case CCANmode:
463 if (req_mode != CCAmode)
464 return 0;
465 break;
466
467 default:
468 gcc_unreachable ();
469 }
470
471 return (GET_MODE (SET_SRC (set)) == set_mode);
472 }
473
474 /* Return true if every SET in INSN that sets the CC register
475 has source and destination with matching CC modes and that
476 CC mode is at least as constrained as REQ_MODE.
477 If REQ_MODE is VOIDmode, always return false. */
478
479 bool
480 s390_match_ccmode (rtx insn, enum machine_mode req_mode)
481 {
482 int i;
483
484 /* s390_tm_ccmode returns VOIDmode to indicate failure. */
485 if (req_mode == VOIDmode)
486 return false;
487
488 if (GET_CODE (PATTERN (insn)) == SET)
489 return s390_match_ccmode_set (PATTERN (insn), req_mode);
490
491 if (GET_CODE (PATTERN (insn)) == PARALLEL)
492 for (i = 0; i < XVECLEN (PATTERN (insn), 0); i++)
493 {
494 rtx set = XVECEXP (PATTERN (insn), 0, i);
495 if (GET_CODE (set) == SET)
496 if (!s390_match_ccmode_set (set, req_mode))
497 return false;
498 }
499
500 return true;
501 }
502
503 /* If a test-under-mask instruction can be used to implement
504 (compare (and ... OP1) OP2), return the CC mode required
505 to do that. Otherwise, return VOIDmode.
506 MIXED is true if the instruction can distinguish between
507 CC1 and CC2 for mixed selected bits (TMxx), it is false
508 if the instruction cannot (TM). */
509
510 enum machine_mode
511 s390_tm_ccmode (rtx op1, rtx op2, bool mixed)
512 {
513 int bit0, bit1;
514
515 /* ??? Fixme: should work on CONST_DOUBLE as well. */
516 if (GET_CODE (op1) != CONST_INT || GET_CODE (op2) != CONST_INT)
517 return VOIDmode;
518
519 /* Selected bits all zero: CC0.
520 e.g.: int a; if ((a & (16 + 128)) == 0) */
521 if (INTVAL (op2) == 0)
522 return CCTmode;
523
524 /* Selected bits all one: CC3.
525 e.g.: int a; if ((a & (16 + 128)) == 16 + 128) */
526 if (INTVAL (op2) == INTVAL (op1))
527 return CCT3mode;
528
529 /* Exactly two bits selected, mixed zeroes and ones: CC1 or CC2. e.g.:
530 int a;
531 if ((a & (16 + 128)) == 16) -> CCT1
532 if ((a & (16 + 128)) == 128) -> CCT2 */
533 if (mixed)
534 {
535 bit1 = exact_log2 (INTVAL (op2));
536 bit0 = exact_log2 (INTVAL (op1) ^ INTVAL (op2));
537 if (bit0 != -1 && bit1 != -1)
538 return bit0 > bit1 ? CCT1mode : CCT2mode;
539 }
540
541 return VOIDmode;
542 }
543
544 /* Given a comparison code OP (EQ, NE, etc.) and the operands
545 OP0 and OP1 of a COMPARE, return the mode to be used for the
546 comparison. */
547
548 enum machine_mode
549 s390_select_ccmode (enum rtx_code code, rtx op0, rtx op1)
550 {
551 switch (code)
552 {
553 case EQ:
554 case NE:
555 if ((GET_CODE (op0) == NEG || GET_CODE (op0) == ABS)
556 && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT)
557 return CCAPmode;
558 if (GET_CODE (op0) == PLUS && GET_CODE (XEXP (op0, 1)) == CONST_INT
559 && CONST_OK_FOR_K (INTVAL (XEXP (op0, 1))))
560 return CCAPmode;
561 if ((GET_CODE (op0) == PLUS || GET_CODE (op0) == MINUS
562 || GET_CODE (op1) == NEG)
563 && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT)
564 return CCLmode;
565
566 if (GET_CODE (op0) == AND)
567 {
568 /* Check whether we can potentially do it via TM. */
569 enum machine_mode ccmode;
570 ccmode = s390_tm_ccmode (XEXP (op0, 1), op1, 1);
571 if (ccmode != VOIDmode)
572 {
573 /* Relax CCTmode to CCZmode to allow fall-back to AND
574 if that turns out to be beneficial. */
575 return ccmode == CCTmode ? CCZmode : ccmode;
576 }
577 }
578
579 if (register_operand (op0, HImode)
580 && GET_CODE (op1) == CONST_INT
581 && (INTVAL (op1) == -1 || INTVAL (op1) == 65535))
582 return CCT3mode;
583 if (register_operand (op0, QImode)
584 && GET_CODE (op1) == CONST_INT
585 && (INTVAL (op1) == -1 || INTVAL (op1) == 255))
586 return CCT3mode;
587
588 return CCZmode;
589
590 case LE:
591 case LT:
592 case GE:
593 case GT:
594 /* The only overflow condition of NEG and ABS happens when
595 -INT_MAX is used as parameter, which stays negative. So
596 we have an overflow from a positive value to a negative.
597 Using CCAP mode the resulting cc can be used for comparisons. */
598 if ((GET_CODE (op0) == NEG || GET_CODE (op0) == ABS)
599 && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT)
600 return CCAPmode;
601
602 /* If constants are involved in an add instruction it is possible to use
603 the resulting cc for comparisons with zero. Knowing the sign of the
604 constant the overflow behavior gets predictable. e.g.:
605 int a, b; if ((b = a + c) > 0)
606 with c as a constant value: c < 0 -> CCAN and c >= 0 -> CCAP */
607 if (GET_CODE (op0) == PLUS && GET_CODE (XEXP (op0, 1)) == CONST_INT
608 && CONST_OK_FOR_K (INTVAL (XEXP (op0, 1))))
609 {
610 if (INTVAL (XEXP((op0), 1)) < 0)
611 return CCANmode;
612 else
613 return CCAPmode;
614 }
615 /* Fall through. */
616 case UNORDERED:
617 case ORDERED:
618 case UNEQ:
619 case UNLE:
620 case UNLT:
621 case UNGE:
622 case UNGT:
623 case LTGT:
624 if ((GET_CODE (op0) == SIGN_EXTEND || GET_CODE (op0) == ZERO_EXTEND)
625 && GET_CODE (op1) != CONST_INT)
626 return CCSRmode;
627 return CCSmode;
628
629 case LTU:
630 case GEU:
631 if (GET_CODE (op0) == PLUS
632 && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT)
633 return CCL1mode;
634
635 if ((GET_CODE (op0) == SIGN_EXTEND || GET_CODE (op0) == ZERO_EXTEND)
636 && GET_CODE (op1) != CONST_INT)
637 return CCURmode;
638 return CCUmode;
639
640 case LEU:
641 case GTU:
642 if (GET_CODE (op0) == MINUS
643 && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT)
644 return CCL2mode;
645
646 if ((GET_CODE (op0) == SIGN_EXTEND || GET_CODE (op0) == ZERO_EXTEND)
647 && GET_CODE (op1) != CONST_INT)
648 return CCURmode;
649 return CCUmode;
650
651 default:
652 gcc_unreachable ();
653 }
654 }
655
656 /* Replace the comparison OP0 CODE OP1 by a semantically equivalent one
657 that we can implement more efficiently. */
658
659 void
660 s390_canonicalize_comparison (enum rtx_code *code, rtx *op0, rtx *op1)
661 {
662 /* Convert ZERO_EXTRACT back to AND to enable TM patterns. */
663 if ((*code == EQ || *code == NE)
664 && *op1 == const0_rtx
665 && GET_CODE (*op0) == ZERO_EXTRACT
666 && GET_CODE (XEXP (*op0, 1)) == CONST_INT
667 && GET_CODE (XEXP (*op0, 2)) == CONST_INT
668 && SCALAR_INT_MODE_P (GET_MODE (XEXP (*op0, 0))))
669 {
670 rtx inner = XEXP (*op0, 0);
671 HOST_WIDE_INT modesize = GET_MODE_BITSIZE (GET_MODE (inner));
672 HOST_WIDE_INT len = INTVAL (XEXP (*op0, 1));
673 HOST_WIDE_INT pos = INTVAL (XEXP (*op0, 2));
674
675 if (len > 0 && len < modesize
676 && pos >= 0 && pos + len <= modesize
677 && modesize <= HOST_BITS_PER_WIDE_INT)
678 {
679 unsigned HOST_WIDE_INT block;
680 block = ((unsigned HOST_WIDE_INT) 1 << len) - 1;
681 block <<= modesize - pos - len;
682
683 *op0 = gen_rtx_AND (GET_MODE (inner), inner,
684 gen_int_mode (block, GET_MODE (inner)));
685 }
686 }
687
688 /* Narrow AND of memory against immediate to enable TM. */
689 if ((*code == EQ || *code == NE)
690 && *op1 == const0_rtx
691 && GET_CODE (*op0) == AND
692 && GET_CODE (XEXP (*op0, 1)) == CONST_INT
693 && SCALAR_INT_MODE_P (GET_MODE (XEXP (*op0, 0))))
694 {
695 rtx inner = XEXP (*op0, 0);
696 rtx mask = XEXP (*op0, 1);
697
698 /* Ignore paradoxical SUBREGs if all extra bits are masked out. */
699 if (GET_CODE (inner) == SUBREG
700 && SCALAR_INT_MODE_P (GET_MODE (SUBREG_REG (inner)))
701 && (GET_MODE_SIZE (GET_MODE (inner))
702 >= GET_MODE_SIZE (GET_MODE (SUBREG_REG (inner))))
703 && ((INTVAL (mask)
704 & GET_MODE_MASK (GET_MODE (inner))
705 & ~GET_MODE_MASK (GET_MODE (SUBREG_REG (inner))))
706 == 0))
707 inner = SUBREG_REG (inner);
708
709 /* Do not change volatile MEMs. */
710 if (MEM_P (inner) && !MEM_VOLATILE_P (inner))
711 {
712 int part = s390_single_part (XEXP (*op0, 1),
713 GET_MODE (inner), QImode, 0);
714 if (part >= 0)
715 {
716 mask = gen_int_mode (s390_extract_part (mask, QImode, 0), QImode);
717 inner = adjust_address_nv (inner, QImode, part);
718 *op0 = gen_rtx_AND (QImode, inner, mask);
719 }
720 }
721 }
722
723 /* Narrow comparisons against 0xffff to HImode if possible. */
724 if ((*code == EQ || *code == NE)
725 && GET_CODE (*op1) == CONST_INT
726 && INTVAL (*op1) == 0xffff
727 && SCALAR_INT_MODE_P (GET_MODE (*op0))
728 && (nonzero_bits (*op0, GET_MODE (*op0))
729 & ~(unsigned HOST_WIDE_INT) 0xffff) == 0)
730 {
731 *op0 = gen_lowpart (HImode, *op0);
732 *op1 = constm1_rtx;
733 }
734
735 /* Remove redundant UNSPEC_CCU_TO_INT conversions if possible. */
736 if (GET_CODE (*op0) == UNSPEC
737 && XINT (*op0, 1) == UNSPEC_CCU_TO_INT
738 && XVECLEN (*op0, 0) == 1
739 && GET_MODE (XVECEXP (*op0, 0, 0)) == CCUmode
740 && GET_CODE (XVECEXP (*op0, 0, 0)) == REG
741 && REGNO (XVECEXP (*op0, 0, 0)) == CC_REGNUM
742 && *op1 == const0_rtx)
743 {
744 enum rtx_code new_code = UNKNOWN;
745 switch (*code)
746 {
747 case EQ: new_code = EQ; break;
748 case NE: new_code = NE; break;
749 case LT: new_code = GTU; break;
750 case GT: new_code = LTU; break;
751 case LE: new_code = GEU; break;
752 case GE: new_code = LEU; break;
753 default: break;
754 }
755
756 if (new_code != UNKNOWN)
757 {
758 *op0 = XVECEXP (*op0, 0, 0);
759 *code = new_code;
760 }
761 }
762
763 /* Remove redundant UNSPEC_CCZ_TO_INT conversions if possible. */
764 if (GET_CODE (*op0) == UNSPEC
765 && XINT (*op0, 1) == UNSPEC_CCZ_TO_INT
766 && XVECLEN (*op0, 0) == 1
767 && GET_MODE (XVECEXP (*op0, 0, 0)) == CCZmode
768 && GET_CODE (XVECEXP (*op0, 0, 0)) == REG
769 && REGNO (XVECEXP (*op0, 0, 0)) == CC_REGNUM
770 && *op1 == const0_rtx)
771 {
772 enum rtx_code new_code = UNKNOWN;
773 switch (*code)
774 {
775 case EQ: new_code = EQ; break;
776 case NE: new_code = NE; break;
777 default: break;
778 }
779
780 if (new_code != UNKNOWN)
781 {
782 *op0 = XVECEXP (*op0, 0, 0);
783 *code = new_code;
784 }
785 }
786
787 /* Simplify cascaded EQ, NE with const0_rtx. */
788 if ((*code == NE || *code == EQ)
789 && (GET_CODE (*op0) == EQ || GET_CODE (*op0) == NE)
790 && GET_MODE (*op0) == SImode
791 && GET_MODE (XEXP (*op0, 0)) == CCZ1mode
792 && REG_P (XEXP (*op0, 0))
793 && XEXP (*op0, 1) == const0_rtx
794 && *op1 == const0_rtx)
795 {
796 if ((*code == EQ && GET_CODE (*op0) == NE)
797 || (*code == NE && GET_CODE (*op0) == EQ))
798 *code = EQ;
799 else
800 *code = NE;
801 *op0 = XEXP (*op0, 0);
802 }
803
804 /* Prefer register over memory as first operand. */
805 if (MEM_P (*op0) && REG_P (*op1))
806 {
807 rtx tem = *op0; *op0 = *op1; *op1 = tem;
808 *code = swap_condition (*code);
809 }
810 }
811
812 /* Emit a compare instruction suitable to implement the comparison
813 OP0 CODE OP1. Return the correct condition RTL to be placed in
814 the IF_THEN_ELSE of the conditional branch testing the result. */
815
816 rtx
817 s390_emit_compare (enum rtx_code code, rtx op0, rtx op1)
818 {
819 enum machine_mode mode = s390_select_ccmode (code, op0, op1);
820 rtx ret = NULL_RTX;
821
822 /* Do not output a redundant compare instruction if a compare_and_swap
823 pattern already computed the result and the machine modes are compatible. */
824 if (s390_compare_emitted
825 && (s390_cc_modes_compatible (GET_MODE (s390_compare_emitted), mode)
826 == GET_MODE (s390_compare_emitted)))
827 ret = gen_rtx_fmt_ee (code, VOIDmode, s390_compare_emitted, const0_rtx);
828 else
829 {
830 rtx cc = gen_rtx_REG (mode, CC_REGNUM);
831
832 emit_insn (gen_rtx_SET (VOIDmode, cc, gen_rtx_COMPARE (mode, op0, op1)));
833 ret = gen_rtx_fmt_ee (code, VOIDmode, cc, const0_rtx);
834 }
835 s390_compare_emitted = NULL_RTX;
836 return ret;
837 }
838
839 /* Emit a SImode compare and swap instruction setting MEM to NEW if OLD
840 matches CMP.
841 Return the correct condition RTL to be placed in the IF_THEN_ELSE of the
842 conditional branch testing the result. */
843
844 static rtx
845 s390_emit_compare_and_swap (enum rtx_code code, rtx old, rtx mem, rtx cmp, rtx new)
846 {
847 rtx ret;
848
849 emit_insn (gen_sync_compare_and_swap_ccsi (old, mem, cmp, new));
850 ret = gen_rtx_fmt_ee (code, VOIDmode, s390_compare_emitted, const0_rtx);
851
852 s390_compare_emitted = NULL_RTX;
853
854 return ret;
855 }
856
857 /* Emit a jump instruction to TARGET. If COND is NULL_RTX, emit an
858 unconditional jump, else a conditional jump under condition COND. */
859
860 void
861 s390_emit_jump (rtx target, rtx cond)
862 {
863 rtx insn;
864
865 target = gen_rtx_LABEL_REF (VOIDmode, target);
866 if (cond)
867 target = gen_rtx_IF_THEN_ELSE (VOIDmode, cond, target, pc_rtx);
868
869 insn = gen_rtx_SET (VOIDmode, pc_rtx, target);
870 emit_jump_insn (insn);
871 }
872
873 /* Return branch condition mask to implement a branch
874 specified by CODE. Return -1 for invalid comparisons. */
875
876 int
877 s390_branch_condition_mask (rtx code)
878 {
879 const int CC0 = 1 << 3;
880 const int CC1 = 1 << 2;
881 const int CC2 = 1 << 1;
882 const int CC3 = 1 << 0;
883
884 gcc_assert (GET_CODE (XEXP (code, 0)) == REG);
885 gcc_assert (REGNO (XEXP (code, 0)) == CC_REGNUM);
886 gcc_assert (XEXP (code, 1) == const0_rtx);
887
888 switch (GET_MODE (XEXP (code, 0)))
889 {
890 case CCZmode:
891 case CCZ1mode:
892 switch (GET_CODE (code))
893 {
894 case EQ: return CC0;
895 case NE: return CC1 | CC2 | CC3;
896 default: return -1;
897 }
898 break;
899
900 case CCT1mode:
901 switch (GET_CODE (code))
902 {
903 case EQ: return CC1;
904 case NE: return CC0 | CC2 | CC3;
905 default: return -1;
906 }
907 break;
908
909 case CCT2mode:
910 switch (GET_CODE (code))
911 {
912 case EQ: return CC2;
913 case NE: return CC0 | CC1 | CC3;
914 default: return -1;
915 }
916 break;
917
918 case CCT3mode:
919 switch (GET_CODE (code))
920 {
921 case EQ: return CC3;
922 case NE: return CC0 | CC1 | CC2;
923 default: return -1;
924 }
925 break;
926
927 case CCLmode:
928 switch (GET_CODE (code))
929 {
930 case EQ: return CC0 | CC2;
931 case NE: return CC1 | CC3;
932 default: return -1;
933 }
934 break;
935
936 case CCL1mode:
937 switch (GET_CODE (code))
938 {
939 case LTU: return CC2 | CC3; /* carry */
940 case GEU: return CC0 | CC1; /* no carry */
941 default: return -1;
942 }
943 break;
944
945 case CCL2mode:
946 switch (GET_CODE (code))
947 {
948 case GTU: return CC0 | CC1; /* borrow */
949 case LEU: return CC2 | CC3; /* no borrow */
950 default: return -1;
951 }
952 break;
953
954 case CCL3mode:
955 switch (GET_CODE (code))
956 {
957 case EQ: return CC0 | CC2;
958 case NE: return CC1 | CC3;
959 case LTU: return CC1;
960 case GTU: return CC3;
961 case LEU: return CC1 | CC2;
962 case GEU: return CC2 | CC3;
963 default: return -1;
964 }
965
966 case CCUmode:
967 switch (GET_CODE (code))
968 {
969 case EQ: return CC0;
970 case NE: return CC1 | CC2 | CC3;
971 case LTU: return CC1;
972 case GTU: return CC2;
973 case LEU: return CC0 | CC1;
974 case GEU: return CC0 | CC2;
975 default: return -1;
976 }
977 break;
978
979 case CCURmode:
980 switch (GET_CODE (code))
981 {
982 case EQ: return CC0;
983 case NE: return CC2 | CC1 | CC3;
984 case LTU: return CC2;
985 case GTU: return CC1;
986 case LEU: return CC0 | CC2;
987 case GEU: return CC0 | CC1;
988 default: return -1;
989 }
990 break;
991
992 case CCAPmode:
993 switch (GET_CODE (code))
994 {
995 case EQ: return CC0;
996 case NE: return CC1 | CC2 | CC3;
997 case LT: return CC1 | CC3;
998 case GT: return CC2;
999 case LE: return CC0 | CC1 | CC3;
1000 case GE: return CC0 | CC2;
1001 default: return -1;
1002 }
1003 break;
1004
1005 case CCANmode:
1006 switch (GET_CODE (code))
1007 {
1008 case EQ: return CC0;
1009 case NE: return CC1 | CC2 | CC3;
1010 case LT: return CC1;
1011 case GT: return CC2 | CC3;
1012 case LE: return CC0 | CC1;
1013 case GE: return CC0 | CC2 | CC3;
1014 default: return -1;
1015 }
1016 break;
1017
1018 case CCSmode:
1019 switch (GET_CODE (code))
1020 {
1021 case EQ: return CC0;
1022 case NE: return CC1 | CC2 | CC3;
1023 case LT: return CC1;
1024 case GT: return CC2;
1025 case LE: return CC0 | CC1;
1026 case GE: return CC0 | CC2;
1027 case UNORDERED: return CC3;
1028 case ORDERED: return CC0 | CC1 | CC2;
1029 case UNEQ: return CC0 | CC3;
1030 case UNLT: return CC1 | CC3;
1031 case UNGT: return CC2 | CC3;
1032 case UNLE: return CC0 | CC1 | CC3;
1033 case UNGE: return CC0 | CC2 | CC3;
1034 case LTGT: return CC1 | CC2;
1035 default: return -1;
1036 }
1037 break;
1038
1039 case CCSRmode:
1040 switch (GET_CODE (code))
1041 {
1042 case EQ: return CC0;
1043 case NE: return CC2 | CC1 | CC3;
1044 case LT: return CC2;
1045 case GT: return CC1;
1046 case LE: return CC0 | CC2;
1047 case GE: return CC0 | CC1;
1048 case UNORDERED: return CC3;
1049 case ORDERED: return CC0 | CC2 | CC1;
1050 case UNEQ: return CC0 | CC3;
1051 case UNLT: return CC2 | CC3;
1052 case UNGT: return CC1 | CC3;
1053 case UNLE: return CC0 | CC2 | CC3;
1054 case UNGE: return CC0 | CC1 | CC3;
1055 case LTGT: return CC2 | CC1;
1056 default: return -1;
1057 }
1058 break;
1059
1060 default:
1061 return -1;
1062 }
1063 }
1064
1065
1066 /* Return branch condition mask to implement a compare and branch
1067 specified by CODE. Return -1 for invalid comparisons. */
1068
1069 int
1070 s390_compare_and_branch_condition_mask (rtx code)
1071 {
1072 const int CC0 = 1 << 3;
1073 const int CC1 = 1 << 2;
1074 const int CC2 = 1 << 1;
1075
1076 switch (GET_CODE (code))
1077 {
1078 case EQ:
1079 return CC0;
1080 case NE:
1081 return CC1 | CC2;
1082 case LT:
1083 case LTU:
1084 return CC1;
1085 case GT:
1086 case GTU:
1087 return CC2;
1088 case LE:
1089 case LEU:
1090 return CC0 | CC1;
1091 case GE:
1092 case GEU:
1093 return CC0 | CC2;
1094 default:
1095 gcc_unreachable ();
1096 }
1097 return -1;
1098 }
1099
1100 /* If INV is false, return assembler mnemonic string to implement
1101 a branch specified by CODE. If INV is true, return mnemonic
1102 for the corresponding inverted branch. */
1103
1104 static const char *
1105 s390_branch_condition_mnemonic (rtx code, int inv)
1106 {
1107 int mask;
1108
1109 static const char *const mnemonic[16] =
1110 {
1111 NULL, "o", "h", "nle",
1112 "l", "nhe", "lh", "ne",
1113 "e", "nlh", "he", "nl",
1114 "le", "nh", "no", NULL
1115 };
1116
1117 if (GET_CODE (XEXP (code, 0)) == REG
1118 && REGNO (XEXP (code, 0)) == CC_REGNUM
1119 && XEXP (code, 1) == const0_rtx)
1120 mask = s390_branch_condition_mask (code);
1121 else
1122 mask = s390_compare_and_branch_condition_mask (code);
1123
1124 gcc_assert (mask >= 0);
1125
1126 if (inv)
1127 mask ^= 15;
1128
1129 gcc_assert (mask >= 1 && mask <= 14);
1130
1131 return mnemonic[mask];
1132 }
1133
1134 /* Return the part of op which has a value different from def.
1135 The size of the part is determined by mode.
1136 Use this function only if you already know that op really
1137 contains such a part. */
1138
1139 unsigned HOST_WIDE_INT
1140 s390_extract_part (rtx op, enum machine_mode mode, int def)
1141 {
1142 unsigned HOST_WIDE_INT value = 0;
1143 int max_parts = HOST_BITS_PER_WIDE_INT / GET_MODE_BITSIZE (mode);
1144 int part_bits = GET_MODE_BITSIZE (mode);
1145 unsigned HOST_WIDE_INT part_mask
1146 = ((unsigned HOST_WIDE_INT)1 << part_bits) - 1;
1147 int i;
1148
1149 for (i = 0; i < max_parts; i++)
1150 {
1151 if (i == 0)
1152 value = (unsigned HOST_WIDE_INT) INTVAL (op);
1153 else
1154 value >>= part_bits;
1155
1156 if ((value & part_mask) != (def & part_mask))
1157 return value & part_mask;
1158 }
1159
1160 gcc_unreachable ();
1161 }
1162
1163 /* If OP is an integer constant of mode MODE with exactly one
1164 part of mode PART_MODE unequal to DEF, return the number of that
1165 part. Otherwise, return -1. */
1166
1167 int
1168 s390_single_part (rtx op,
1169 enum machine_mode mode,
1170 enum machine_mode part_mode,
1171 int def)
1172 {
1173 unsigned HOST_WIDE_INT value = 0;
1174 int n_parts = GET_MODE_SIZE (mode) / GET_MODE_SIZE (part_mode);
1175 unsigned HOST_WIDE_INT part_mask
1176 = ((unsigned HOST_WIDE_INT)1 << GET_MODE_BITSIZE (part_mode)) - 1;
1177 int i, part = -1;
1178
1179 if (GET_CODE (op) != CONST_INT)
1180 return -1;
1181
1182 for (i = 0; i < n_parts; i++)
1183 {
1184 if (i == 0)
1185 value = (unsigned HOST_WIDE_INT) INTVAL (op);
1186 else
1187 value >>= GET_MODE_BITSIZE (part_mode);
1188
1189 if ((value & part_mask) != (def & part_mask))
1190 {
1191 if (part != -1)
1192 return -1;
1193 else
1194 part = i;
1195 }
1196 }
1197 return part == -1 ? -1 : n_parts - 1 - part;
1198 }
1199
1200 /* Return true if IN contains a contiguous bitfield in the lower SIZE
1201 bits and no other bits are set in IN. POS and LENGTH can be used
1202 to obtain the start position and the length of the bitfield.
1203
1204 POS gives the position of the first bit of the bitfield counting
1205 from the lowest order bit starting with zero. In order to use this
1206 value for S/390 instructions this has to be converted to "bits big
1207 endian" style. */
1208
1209 bool
1210 s390_contiguous_bitmask_p (unsigned HOST_WIDE_INT in, int size,
1211 int *pos, int *length)
1212 {
1213 int tmp_pos = 0;
1214 int tmp_length = 0;
1215 int i;
1216 unsigned HOST_WIDE_INT mask = 1ULL;
1217 bool contiguous = false;
1218
1219 for (i = 0; i < size; mask <<= 1, i++)
1220 {
1221 if (contiguous)
1222 {
1223 if (mask & in)
1224 tmp_length++;
1225 else
1226 break;
1227 }
1228 else
1229 {
1230 if (mask & in)
1231 {
1232 contiguous = true;
1233 tmp_length++;
1234 }
1235 else
1236 tmp_pos++;
1237 }
1238 }
1239
1240 if (!tmp_length)
1241 return false;
1242
1243 /* Calculate a mask for all bits beyond the contiguous bits. */
1244 mask = (-1LL & ~(((1ULL << (tmp_length + tmp_pos - 1)) << 1) - 1));
1245
1246 if (mask & in)
1247 return false;
1248
1249 if (tmp_length + tmp_pos - 1 > size)
1250 return false;
1251
1252 if (length)
1253 *length = tmp_length;
1254
1255 if (pos)
1256 *pos = tmp_pos;
1257
1258 return true;
1259 }
1260
1261 /* Check whether we can (and want to) split a double-word
1262 move in mode MODE from SRC to DST into two single-word
1263 moves, moving the subword FIRST_SUBWORD first. */
1264
1265 bool
1266 s390_split_ok_p (rtx dst, rtx src, enum machine_mode mode, int first_subword)
1267 {
1268 /* Floating point registers cannot be split. */
1269 if (FP_REG_P (src) || FP_REG_P (dst))
1270 return false;
1271
1272 /* We don't need to split if operands are directly accessible. */
1273 if (s_operand (src, mode) || s_operand (dst, mode))
1274 return false;
1275
1276 /* Non-offsettable memory references cannot be split. */
1277 if ((GET_CODE (src) == MEM && !offsettable_memref_p (src))
1278 || (GET_CODE (dst) == MEM && !offsettable_memref_p (dst)))
1279 return false;
1280
1281 /* Moving the first subword must not clobber a register
1282 needed to move the second subword. */
1283 if (register_operand (dst, mode))
1284 {
1285 rtx subreg = operand_subword (dst, first_subword, 0, mode);
1286 if (reg_overlap_mentioned_p (subreg, src))
1287 return false;
1288 }
1289
1290 return true;
1291 }
1292
1293 /* Return true if it can be proven that [MEM1, MEM1 + SIZE]
1294 and [MEM2, MEM2 + SIZE] do overlap and false
1295 otherwise. */
1296
1297 bool
1298 s390_overlap_p (rtx mem1, rtx mem2, HOST_WIDE_INT size)
1299 {
1300 rtx addr1, addr2, addr_delta;
1301 HOST_WIDE_INT delta;
1302
1303 if (GET_CODE (mem1) != MEM || GET_CODE (mem2) != MEM)
1304 return true;
1305
1306 if (size == 0)
1307 return false;
1308
1309 addr1 = XEXP (mem1, 0);
1310 addr2 = XEXP (mem2, 0);
1311
1312 addr_delta = simplify_binary_operation (MINUS, Pmode, addr2, addr1);
1313
1314 /* This overlapping check is used by peepholes merging memory block operations.
1315 Overlapping operations would otherwise be recognized by the S/390 hardware
1316 and would fall back to a slower implementation. Allowing overlapping
1317 operations would lead to slow code but not to wrong code. Therefore we are
1318 somewhat optimistic if we cannot prove that the memory blocks are
1319 overlapping.
1320 That's why we return false here although this may accept operations on
1321 overlapping memory areas. */
1322 if (!addr_delta || GET_CODE (addr_delta) != CONST_INT)
1323 return false;
1324
1325 delta = INTVAL (addr_delta);
1326
1327 if (delta == 0
1328 || (delta > 0 && delta < size)
1329 || (delta < 0 && -delta < size))
1330 return true;
1331
1332 return false;
1333 }
1334
1335 /* Check whether the address of memory reference MEM2 equals exactly
1336 the address of memory reference MEM1 plus DELTA. Return true if
1337 we can prove this to be the case, false otherwise. */
1338
1339 bool
1340 s390_offset_p (rtx mem1, rtx mem2, rtx delta)
1341 {
1342 rtx addr1, addr2, addr_delta;
1343
1344 if (GET_CODE (mem1) != MEM || GET_CODE (mem2) != MEM)
1345 return false;
1346
1347 addr1 = XEXP (mem1, 0);
1348 addr2 = XEXP (mem2, 0);
1349
1350 addr_delta = simplify_binary_operation (MINUS, Pmode, addr2, addr1);
1351 if (!addr_delta || !rtx_equal_p (addr_delta, delta))
1352 return false;
1353
1354 return true;
1355 }
1356
1357 /* Expand logical operator CODE in mode MODE with operands OPERANDS. */
1358
1359 void
1360 s390_expand_logical_operator (enum rtx_code code, enum machine_mode mode,
1361 rtx *operands)
1362 {
1363 enum machine_mode wmode = mode;
1364 rtx dst = operands[0];
1365 rtx src1 = operands[1];
1366 rtx src2 = operands[2];
1367 rtx op, clob, tem;
1368
1369 /* If we cannot handle the operation directly, use a temp register. */
1370 if (!s390_logical_operator_ok_p (operands))
1371 dst = gen_reg_rtx (mode);
1372
1373 /* QImode and HImode patterns make sense only if we have a destination
1374 in memory. Otherwise perform the operation in SImode. */
1375 if ((mode == QImode || mode == HImode) && GET_CODE (dst) != MEM)
1376 wmode = SImode;
1377
1378 /* Widen operands if required. */
1379 if (mode != wmode)
1380 {
1381 if (GET_CODE (dst) == SUBREG
1382 && (tem = simplify_subreg (wmode, dst, mode, 0)) != 0)
1383 dst = tem;
1384 else if (REG_P (dst))
1385 dst = gen_rtx_SUBREG (wmode, dst, 0);
1386 else
1387 dst = gen_reg_rtx (wmode);
1388
1389 if (GET_CODE (src1) == SUBREG
1390 && (tem = simplify_subreg (wmode, src1, mode, 0)) != 0)
1391 src1 = tem;
1392 else if (GET_MODE (src1) != VOIDmode)
1393 src1 = gen_rtx_SUBREG (wmode, force_reg (mode, src1), 0);
1394
1395 if (GET_CODE (src2) == SUBREG
1396 && (tem = simplify_subreg (wmode, src2, mode, 0)) != 0)
1397 src2 = tem;
1398 else if (GET_MODE (src2) != VOIDmode)
1399 src2 = gen_rtx_SUBREG (wmode, force_reg (mode, src2), 0);
1400 }
1401
1402 /* Emit the instruction. */
1403 op = gen_rtx_SET (VOIDmode, dst, gen_rtx_fmt_ee (code, wmode, src1, src2));
1404 clob = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, CC_REGNUM));
1405 emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, op, clob)));
1406
1407 /* Fix up the destination if needed. */
1408 if (dst != operands[0])
1409 emit_move_insn (operands[0], gen_lowpart (mode, dst));
1410 }
1411
1412 /* Check whether OPERANDS are OK for a logical operation (AND, IOR, XOR). */
1413
1414 bool
1415 s390_logical_operator_ok_p (rtx *operands)
1416 {
1417 /* If the destination operand is in memory, it needs to coincide
1418 with one of the source operands. After reload, it has to be
1419 the first source operand. */
1420 if (GET_CODE (operands[0]) == MEM)
1421 return rtx_equal_p (operands[0], operands[1])
1422 || (!reload_completed && rtx_equal_p (operands[0], operands[2]));
1423
1424 return true;
1425 }
1426
1427 /* Narrow logical operation CODE of memory operand MEMOP with immediate
1428 operand IMMOP to switch from SS to SI type instructions. */
1429
1430 void
1431 s390_narrow_logical_operator (enum rtx_code code, rtx *memop, rtx *immop)
1432 {
1433 int def = code == AND ? -1 : 0;
1434 HOST_WIDE_INT mask;
1435 int part;
1436
1437 gcc_assert (GET_CODE (*memop) == MEM);
1438 gcc_assert (!MEM_VOLATILE_P (*memop));
1439
1440 mask = s390_extract_part (*immop, QImode, def);
1441 part = s390_single_part (*immop, GET_MODE (*memop), QImode, def);
1442 gcc_assert (part >= 0);
1443
1444 *memop = adjust_address (*memop, QImode, part);
1445 *immop = gen_int_mode (mask, QImode);
1446 }
1447
1448
1449 /* How to allocate a 'struct machine_function'. */
1450
1451 static struct machine_function *
1452 s390_init_machine_status (void)
1453 {
1454 return GGC_CNEW (struct machine_function);
1455 }
1456
1457 /* Change optimizations to be performed, depending on the
1458 optimization level.
1459
1460 LEVEL is the optimization level specified; 2 if `-O2' is
1461 specified, 1 if `-O' is specified, and 0 if neither is specified.
1462
1463 SIZE is nonzero if `-Os' is specified and zero otherwise. */
1464
1465 void
1466 optimization_options (int level ATTRIBUTE_UNUSED, int size ATTRIBUTE_UNUSED)
1467 {
1468 /* ??? There are apparently still problems with -fcaller-saves. */
1469 flag_caller_saves = 0;
1470
1471 /* By default, always emit DWARF-2 unwind info. This allows debugging
1472 without maintaining a stack frame back-chain. */
1473 flag_asynchronous_unwind_tables = 1;
1474
1475 /* Use MVCLE instructions to decrease code size if requested. */
1476 if (size != 0)
1477 target_flags |= MASK_MVCLE;
1478 }
1479
1480 /* Return true if ARG is the name of a processor. Set *TYPE and *FLAGS
1481 to the associated processor_type and processor_flags if so. */
1482
1483 static bool
1484 s390_handle_arch_option (const char *arg,
1485 enum processor_type *type,
1486 enum processor_flags *flags)
1487 {
1488 static struct pta
1489 {
1490 const char *const name; /* processor name or nickname. */
1491 const enum processor_type processor;
1492 const enum processor_flags flags;
1493 }
1494 const processor_alias_table[] =
1495 {
1496 {"g5", PROCESSOR_9672_G5, PF_IEEE_FLOAT},
1497 {"g6", PROCESSOR_9672_G6, PF_IEEE_FLOAT},
1498 {"z900", PROCESSOR_2064_Z900, PF_IEEE_FLOAT | PF_ZARCH},
1499 {"z990", PROCESSOR_2084_Z990, PF_IEEE_FLOAT | PF_ZARCH
1500 | PF_LONG_DISPLACEMENT},
1501 {"z9-109", PROCESSOR_2094_Z9_109, PF_IEEE_FLOAT | PF_ZARCH
1502 | PF_LONG_DISPLACEMENT | PF_EXTIMM},
1503 {"z9-ec", PROCESSOR_2094_Z9_109, PF_IEEE_FLOAT | PF_ZARCH
1504 | PF_LONG_DISPLACEMENT | PF_EXTIMM | PF_DFP },
1505 {"z10", PROCESSOR_2097_Z10, PF_IEEE_FLOAT | PF_ZARCH
1506 | PF_LONG_DISPLACEMENT | PF_EXTIMM | PF_DFP | PF_Z10},
1507 };
1508 size_t i;
1509
1510 for (i = 0; i < ARRAY_SIZE (processor_alias_table); i++)
1511 if (strcmp (arg, processor_alias_table[i].name) == 0)
1512 {
1513 *type = processor_alias_table[i].processor;
1514 *flags = processor_alias_table[i].flags;
1515 return true;
1516 }
1517 return false;
1518 }
1519
1520 /* Implement TARGET_HANDLE_OPTION. */
1521
1522 static bool
1523 s390_handle_option (size_t code, const char *arg, int value ATTRIBUTE_UNUSED)
1524 {
1525 switch (code)
1526 {
1527 case OPT_march_:
1528 return s390_handle_arch_option (arg, &s390_arch, &s390_arch_flags);
1529
1530 case OPT_mstack_guard_:
1531 if (sscanf (arg, HOST_WIDE_INT_PRINT_DEC, &s390_stack_guard) != 1)
1532 return false;
1533 if (exact_log2 (s390_stack_guard) == -1)
1534 error ("stack guard value must be an exact power of 2");
1535 return true;
1536
1537 case OPT_mstack_size_:
1538 if (sscanf (arg, HOST_WIDE_INT_PRINT_DEC, &s390_stack_size) != 1)
1539 return false;
1540 if (exact_log2 (s390_stack_size) == -1)
1541 error ("stack size must be an exact power of 2");
1542 return true;
1543
1544 case OPT_mtune_:
1545 return s390_handle_arch_option (arg, &s390_tune, &s390_tune_flags);
1546
1547 case OPT_mwarn_framesize_:
1548 return sscanf (arg, HOST_WIDE_INT_PRINT_DEC, &s390_warn_framesize) == 1;
1549
1550 default:
1551 return true;
1552 }
1553 }
1554
1555 void
1556 override_options (void)
1557 {
1558 /* Set up function hooks. */
1559 init_machine_status = s390_init_machine_status;
1560
1561 /* Architecture mode defaults according to ABI. */
1562 if (!(target_flags_explicit & MASK_ZARCH))
1563 {
1564 if (TARGET_64BIT)
1565 target_flags |= MASK_ZARCH;
1566 else
1567 target_flags &= ~MASK_ZARCH;
1568 }
1569
1570 /* Determine processor architectural level. */
1571 if (!s390_arch_string)
1572 {
1573 s390_arch_string = TARGET_ZARCH? "z900" : "g5";
1574 s390_handle_arch_option (s390_arch_string, &s390_arch, &s390_arch_flags);
1575 }
1576
1577 /* Determine processor to tune for. */
1578 if (s390_tune == PROCESSOR_max)
1579 {
1580 s390_tune = s390_arch;
1581 s390_tune_flags = s390_arch_flags;
1582 }
1583
1584 /* Sanity checks. */
1585 if (TARGET_ZARCH && !TARGET_CPU_ZARCH)
1586 error ("z/Architecture mode not supported on %s", s390_arch_string);
1587 if (TARGET_64BIT && !TARGET_ZARCH)
1588 error ("64-bit ABI not supported in ESA/390 mode");
1589
1590 if (TARGET_HARD_DFP && !TARGET_DFP)
1591 {
1592 if (target_flags_explicit & MASK_HARD_DFP)
1593 {
1594 if (!TARGET_CPU_DFP)
1595 error ("Hardware decimal floating point instructions"
1596 " not available on %s", s390_arch_string);
1597 if (!TARGET_ZARCH)
1598 error ("Hardware decimal floating point instructions"
1599 " not available in ESA/390 mode");
1600 }
1601 else
1602 target_flags &= ~MASK_HARD_DFP;
1603 }
1604
1605 if ((target_flags_explicit & MASK_SOFT_FLOAT) && TARGET_SOFT_FLOAT)
1606 {
1607 if ((target_flags_explicit & MASK_HARD_DFP) && TARGET_HARD_DFP)
1608 error ("-mhard-dfp can't be used in conjunction with -msoft-float");
1609
1610 target_flags &= ~MASK_HARD_DFP;
1611 }
1612
1613 /* Set processor cost function. */
1614 switch (s390_tune)
1615 {
1616 case PROCESSOR_2084_Z990:
1617 s390_cost = &z990_cost;
1618 break;
1619 case PROCESSOR_2094_Z9_109:
1620 s390_cost = &z9_109_cost;
1621 break;
1622 case PROCESSOR_2097_Z10:
1623 s390_cost = &z10_cost;
1624 break;
1625 default:
1626 s390_cost = &z900_cost;
1627 }
1628
1629 if (TARGET_BACKCHAIN && TARGET_PACKED_STACK && TARGET_HARD_FLOAT)
1630 error ("-mbackchain -mpacked-stack -mhard-float are not supported "
1631 "in combination");
1632
1633 if (s390_stack_size)
1634 {
1635 if (s390_stack_guard >= s390_stack_size)
1636 error ("stack size must be greater than the stack guard value");
1637 else if (s390_stack_size > 1 << 16)
1638 error ("stack size must not be greater than 64k");
1639 }
1640 else if (s390_stack_guard)
1641 error ("-mstack-guard implies use of -mstack-size");
1642
1643 #ifdef TARGET_DEFAULT_LONG_DOUBLE_128
1644 if (!(target_flags_explicit & MASK_LONG_DOUBLE_128))
1645 target_flags |= MASK_LONG_DOUBLE_128;
1646 #endif
1647 }
1648
1649 /* Map for smallest class containing reg regno. */
1650
1651 const enum reg_class regclass_map[FIRST_PSEUDO_REGISTER] =
1652 { GENERAL_REGS, ADDR_REGS, ADDR_REGS, ADDR_REGS,
1653 ADDR_REGS, ADDR_REGS, ADDR_REGS, ADDR_REGS,
1654 ADDR_REGS, ADDR_REGS, ADDR_REGS, ADDR_REGS,
1655 ADDR_REGS, ADDR_REGS, ADDR_REGS, ADDR_REGS,
1656 FP_REGS, FP_REGS, FP_REGS, FP_REGS,
1657 FP_REGS, FP_REGS, FP_REGS, FP_REGS,
1658 FP_REGS, FP_REGS, FP_REGS, FP_REGS,
1659 FP_REGS, FP_REGS, FP_REGS, FP_REGS,
1660 ADDR_REGS, CC_REGS, ADDR_REGS, ADDR_REGS,
1661 ACCESS_REGS, ACCESS_REGS
1662 };
1663
1664 /* Return attribute type of insn. */
1665
1666 static enum attr_type
1667 s390_safe_attr_type (rtx insn)
1668 {
1669 if (recog_memoized (insn) >= 0)
1670 return get_attr_type (insn);
1671 else
1672 return TYPE_NONE;
1673 }
1674
1675 /* Return true if DISP is a valid short displacement. */
1676
1677 static bool
1678 s390_short_displacement (rtx disp)
1679 {
1680 /* No displacement is OK. */
1681 if (!disp)
1682 return true;
1683
1684 /* Integer displacement in range. */
1685 if (GET_CODE (disp) == CONST_INT)
1686 return INTVAL (disp) >= 0 && INTVAL (disp) < 4096;
1687
1688 /* GOT offset is not OK, the GOT can be large. */
1689 if (GET_CODE (disp) == CONST
1690 && GET_CODE (XEXP (disp, 0)) == UNSPEC
1691 && (XINT (XEXP (disp, 0), 1) == UNSPEC_GOT
1692 || XINT (XEXP (disp, 0), 1) == UNSPEC_GOTNTPOFF))
1693 return false;
1694
1695 /* All other symbolic constants are literal pool references,
1696 which are OK as the literal pool must be small. */
1697 if (GET_CODE (disp) == CONST)
1698 return true;
1699
1700 return false;
1701 }
1702
1703 /* Decompose a RTL expression ADDR for a memory address into
1704 its components, returned in OUT.
1705
1706 Returns false if ADDR is not a valid memory address, true
1707 otherwise. If OUT is NULL, don't return the components,
1708 but check for validity only.
1709
1710 Note: Only addresses in canonical form are recognized.
1711 LEGITIMIZE_ADDRESS should convert non-canonical forms to the
1712 canonical form so that they will be recognized. */
1713
1714 static int
1715 s390_decompose_address (rtx addr, struct s390_address *out)
1716 {
1717 HOST_WIDE_INT offset = 0;
1718 rtx base = NULL_RTX;
1719 rtx indx = NULL_RTX;
1720 rtx disp = NULL_RTX;
1721 rtx orig_disp;
1722 bool pointer = false;
1723 bool base_ptr = false;
1724 bool indx_ptr = false;
1725 bool literal_pool = false;
1726
1727 /* We may need to substitute the literal pool base register into the address
1728 below. However, at this point we do not know which register is going to
1729 be used as base, so we substitute the arg pointer register. This is going
1730 to be treated as holding a pointer below -- it shouldn't be used for any
1731 other purpose. */
1732 rtx fake_pool_base = gen_rtx_REG (Pmode, ARG_POINTER_REGNUM);
1733
1734 /* Decompose address into base + index + displacement. */
1735
1736 if (GET_CODE (addr) == REG || GET_CODE (addr) == UNSPEC)
1737 base = addr;
1738
1739 else if (GET_CODE (addr) == PLUS)
1740 {
1741 rtx op0 = XEXP (addr, 0);
1742 rtx op1 = XEXP (addr, 1);
1743 enum rtx_code code0 = GET_CODE (op0);
1744 enum rtx_code code1 = GET_CODE (op1);
1745
1746 if (code0 == REG || code0 == UNSPEC)
1747 {
1748 if (code1 == REG || code1 == UNSPEC)
1749 {
1750 indx = op0; /* index + base */
1751 base = op1;
1752 }
1753
1754 else
1755 {
1756 base = op0; /* base + displacement */
1757 disp = op1;
1758 }
1759 }
1760
1761 else if (code0 == PLUS)
1762 {
1763 indx = XEXP (op0, 0); /* index + base + disp */
1764 base = XEXP (op0, 1);
1765 disp = op1;
1766 }
1767
1768 else
1769 {
1770 return false;
1771 }
1772 }
1773
1774 else
1775 disp = addr; /* displacement */
1776
1777 /* Extract integer part of displacement. */
1778 orig_disp = disp;
1779 if (disp)
1780 {
1781 if (GET_CODE (disp) == CONST_INT)
1782 {
1783 offset = INTVAL (disp);
1784 disp = NULL_RTX;
1785 }
1786 else if (GET_CODE (disp) == CONST
1787 && GET_CODE (XEXP (disp, 0)) == PLUS
1788 && GET_CODE (XEXP (XEXP (disp, 0), 1)) == CONST_INT)
1789 {
1790 offset = INTVAL (XEXP (XEXP (disp, 0), 1));
1791 disp = XEXP (XEXP (disp, 0), 0);
1792 }
1793 }
1794
1795 /* Strip off CONST here to avoid special case tests later. */
1796 if (disp && GET_CODE (disp) == CONST)
1797 disp = XEXP (disp, 0);
1798
1799 /* We can convert literal pool addresses to
1800 displacements by basing them off the base register. */
1801 if (disp && GET_CODE (disp) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (disp))
1802 {
1803 /* Either base or index must be free to hold the base register. */
1804 if (!base)
1805 base = fake_pool_base, literal_pool = true;
1806 else if (!indx)
1807 indx = fake_pool_base, literal_pool = true;
1808 else
1809 return false;
1810
1811 /* Mark up the displacement. */
1812 disp = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, disp),
1813 UNSPEC_LTREL_OFFSET);
1814 }
1815
1816 /* Validate base register. */
1817 if (base)
1818 {
1819 if (GET_CODE (base) == UNSPEC)
1820 switch (XINT (base, 1))
1821 {
1822 case UNSPEC_LTREF:
1823 if (!disp)
1824 disp = gen_rtx_UNSPEC (Pmode,
1825 gen_rtvec (1, XVECEXP (base, 0, 0)),
1826 UNSPEC_LTREL_OFFSET);
1827 else
1828 return false;
1829
1830 base = XVECEXP (base, 0, 1);
1831 break;
1832
1833 case UNSPEC_LTREL_BASE:
1834 if (XVECLEN (base, 0) == 1)
1835 base = fake_pool_base, literal_pool = true;
1836 else
1837 base = XVECEXP (base, 0, 1);
1838 break;
1839
1840 default:
1841 return false;
1842 }
1843
1844 if (!REG_P (base)
1845 || (GET_MODE (base) != SImode
1846 && GET_MODE (base) != Pmode))
1847 return false;
1848
1849 if (REGNO (base) == STACK_POINTER_REGNUM
1850 || REGNO (base) == FRAME_POINTER_REGNUM
1851 || ((reload_completed || reload_in_progress)
1852 && frame_pointer_needed
1853 && REGNO (base) == HARD_FRAME_POINTER_REGNUM)
1854 || REGNO (base) == ARG_POINTER_REGNUM
1855 || (flag_pic
1856 && REGNO (base) == PIC_OFFSET_TABLE_REGNUM))
1857 pointer = base_ptr = true;
1858
1859 if ((reload_completed || reload_in_progress)
1860 && base == cfun->machine->base_reg)
1861 pointer = base_ptr = literal_pool = true;
1862 }
1863
1864 /* Validate index register. */
1865 if (indx)
1866 {
1867 if (GET_CODE (indx) == UNSPEC)
1868 switch (XINT (indx, 1))
1869 {
1870 case UNSPEC_LTREF:
1871 if (!disp)
1872 disp = gen_rtx_UNSPEC (Pmode,
1873 gen_rtvec (1, XVECEXP (indx, 0, 0)),
1874 UNSPEC_LTREL_OFFSET);
1875 else
1876 return false;
1877
1878 indx = XVECEXP (indx, 0, 1);
1879 break;
1880
1881 case UNSPEC_LTREL_BASE:
1882 if (XVECLEN (indx, 0) == 1)
1883 indx = fake_pool_base, literal_pool = true;
1884 else
1885 indx = XVECEXP (indx, 0, 1);
1886 break;
1887
1888 default:
1889 return false;
1890 }
1891
1892 if (!REG_P (indx)
1893 || (GET_MODE (indx) != SImode
1894 && GET_MODE (indx) != Pmode))
1895 return false;
1896
1897 if (REGNO (indx) == STACK_POINTER_REGNUM
1898 || REGNO (indx) == FRAME_POINTER_REGNUM
1899 || ((reload_completed || reload_in_progress)
1900 && frame_pointer_needed
1901 && REGNO (indx) == HARD_FRAME_POINTER_REGNUM)
1902 || REGNO (indx) == ARG_POINTER_REGNUM
1903 || (flag_pic
1904 && REGNO (indx) == PIC_OFFSET_TABLE_REGNUM))
1905 pointer = indx_ptr = true;
1906
1907 if ((reload_completed || reload_in_progress)
1908 && indx == cfun->machine->base_reg)
1909 pointer = indx_ptr = literal_pool = true;
1910 }
1911
1912 /* Prefer to use pointer as base, not index. */
1913 if (base && indx && !base_ptr
1914 && (indx_ptr || (!REG_POINTER (base) && REG_POINTER (indx))))
1915 {
1916 rtx tmp = base;
1917 base = indx;
1918 indx = tmp;
1919 }
1920
1921 /* Validate displacement. */
1922 if (!disp)
1923 {
1924 /* If virtual registers are involved, the displacement will change later
1925 anyway as the virtual registers get eliminated. This could make a
1926 valid displacement invalid, but it is more likely to make an invalid
1927 displacement valid, because we sometimes access the register save area
1928 via negative offsets to one of those registers.
1929 Thus we don't check the displacement for validity here. If after
1930 elimination the displacement turns out to be invalid after all,
1931 this is fixed up by reload in any case. */
1932 if (base != arg_pointer_rtx
1933 && indx != arg_pointer_rtx
1934 && base != return_address_pointer_rtx
1935 && indx != return_address_pointer_rtx
1936 && base != frame_pointer_rtx
1937 && indx != frame_pointer_rtx
1938 && base != virtual_stack_vars_rtx
1939 && indx != virtual_stack_vars_rtx)
1940 if (!DISP_IN_RANGE (offset))
1941 return false;
1942 }
1943 else
1944 {
1945 /* All the special cases are pointers. */
1946 pointer = true;
1947
1948 /* In the small-PIC case, the linker converts @GOT
1949 and @GOTNTPOFF offsets to possible displacements. */
1950 if (GET_CODE (disp) == UNSPEC
1951 && (XINT (disp, 1) == UNSPEC_GOT
1952 || XINT (disp, 1) == UNSPEC_GOTNTPOFF)
1953 && flag_pic == 1)
1954 {
1955 ;
1956 }
1957
1958 /* Accept chunkified literal pool symbol references. */
1959 else if (cfun && cfun->machine
1960 && cfun->machine->decomposed_literal_pool_addresses_ok_p
1961 && GET_CODE (disp) == MINUS
1962 && GET_CODE (XEXP (disp, 0)) == LABEL_REF
1963 && GET_CODE (XEXP (disp, 1)) == LABEL_REF)
1964 {
1965 ;
1966 }
1967
1968 /* Accept literal pool references. */
1969 else if (GET_CODE (disp) == UNSPEC
1970 && XINT (disp, 1) == UNSPEC_LTREL_OFFSET)
1971 {
1972 orig_disp = gen_rtx_CONST (Pmode, disp);
1973 if (offset)
1974 {
1975 /* If we have an offset, make sure it does not
1976 exceed the size of the constant pool entry. */
1977 rtx sym = XVECEXP (disp, 0, 0);
1978 if (offset >= GET_MODE_SIZE (get_pool_mode (sym)))
1979 return false;
1980
1981 orig_disp = plus_constant (orig_disp, offset);
1982 }
1983 }
1984
1985 else
1986 return false;
1987 }
1988
1989 if (!base && !indx)
1990 pointer = true;
1991
1992 if (out)
1993 {
1994 out->base = base;
1995 out->indx = indx;
1996 out->disp = orig_disp;
1997 out->pointer = pointer;
1998 out->literal_pool = literal_pool;
1999 }
2000
2001 return true;
2002 }
2003
2004 /* Decompose a RTL expression OP for a shift count into its components,
2005 and return the base register in BASE and the offset in OFFSET.
2006
2007 Return true if OP is a valid shift count, false if not. */
2008
2009 bool
2010 s390_decompose_shift_count (rtx op, rtx *base, HOST_WIDE_INT *offset)
2011 {
2012 HOST_WIDE_INT off = 0;
2013
2014 /* We can have an integer constant, an address register,
2015 or a sum of the two. */
2016 if (GET_CODE (op) == CONST_INT)
2017 {
2018 off = INTVAL (op);
2019 op = NULL_RTX;
2020 }
2021 if (op && GET_CODE (op) == PLUS && GET_CODE (XEXP (op, 1)) == CONST_INT)
2022 {
2023 off = INTVAL (XEXP (op, 1));
2024 op = XEXP (op, 0);
2025 }
2026 while (op && GET_CODE (op) == SUBREG)
2027 op = SUBREG_REG (op);
2028
2029 if (op && GET_CODE (op) != REG)
2030 return false;
2031
2032 if (offset)
2033 *offset = off;
2034 if (base)
2035 *base = op;
2036
2037 return true;
2038 }
2039
2040
2041 /* Return true if CODE is a valid address without index. */
2042
2043 bool
2044 s390_legitimate_address_without_index_p (rtx op)
2045 {
2046 struct s390_address addr;
2047
2048 if (!s390_decompose_address (XEXP (op, 0), &addr))
2049 return false;
2050 if (addr.indx)
2051 return false;
2052
2053 return true;
2054 }
2055
2056
2057 /* Evaluates constraint strings described by the regular expression
2058 ([A|B](Q|R|S|T))|U|W and returns 1 if OP is a valid operand for the
2059 constraint given in STR, or 0 else. */
2060
2061 int
2062 s390_mem_constraint (const char *str, rtx op)
2063 {
2064 struct s390_address addr;
2065 char c = str[0];
2066
2067 /* Check for offsettable variants of memory constraints. */
2068 if (c == 'A')
2069 {
2070 /* Only accept non-volatile MEMs. */
2071 if (!MEM_P (op) || MEM_VOLATILE_P (op))
2072 return 0;
2073
2074 if ((reload_completed || reload_in_progress)
2075 ? !offsettable_memref_p (op) : !offsettable_nonstrict_memref_p (op))
2076 return 0;
2077
2078 c = str[1];
2079 }
2080
2081 /* Check for non-literal-pool variants of memory constraints. */
2082 else if (c == 'B')
2083 {
2084 if (GET_CODE (op) != MEM)
2085 return 0;
2086 if (!s390_decompose_address (XEXP (op, 0), &addr))
2087 return 0;
2088 if (addr.literal_pool)
2089 return 0;
2090
2091 c = str[1];
2092 }
2093
2094 switch (c)
2095 {
2096 case 'Q':
2097 if (GET_CODE (op) != MEM)
2098 return 0;
2099 if (!s390_decompose_address (XEXP (op, 0), &addr))
2100 return 0;
2101 if (addr.indx)
2102 return 0;
2103
2104 if (TARGET_LONG_DISPLACEMENT)
2105 {
2106 if (!s390_short_displacement (addr.disp))
2107 return 0;
2108 }
2109 break;
2110
2111 case 'R':
2112 if (GET_CODE (op) != MEM)
2113 return 0;
2114
2115 if (TARGET_LONG_DISPLACEMENT)
2116 {
2117 if (!s390_decompose_address (XEXP (op, 0), &addr))
2118 return 0;
2119 if (!s390_short_displacement (addr.disp))
2120 return 0;
2121 }
2122 break;
2123
2124 case 'S':
2125 if (!TARGET_LONG_DISPLACEMENT)
2126 return 0;
2127 if (GET_CODE (op) != MEM)
2128 return 0;
2129 if (!s390_decompose_address (XEXP (op, 0), &addr))
2130 return 0;
2131 if (addr.indx)
2132 return 0;
2133 if (s390_short_displacement (addr.disp))
2134 return 0;
2135 break;
2136
2137 case 'T':
2138 if (!TARGET_LONG_DISPLACEMENT)
2139 return 0;
2140 if (GET_CODE (op) != MEM)
2141 return 0;
2142 if (!s390_decompose_address (XEXP (op, 0), &addr))
2143 return 0;
2144 if (s390_short_displacement (addr.disp))
2145 return 0;
2146 break;
2147
2148 case 'U':
2149 if (TARGET_LONG_DISPLACEMENT)
2150 {
2151 if (!s390_decompose_address (op, &addr))
2152 return 0;
2153 if (!s390_short_displacement (addr.disp))
2154 return 0;
2155 }
2156 break;
2157
2158 case 'W':
2159 if (!TARGET_LONG_DISPLACEMENT)
2160 return 0;
2161 if (!s390_decompose_address (op, &addr))
2162 return 0;
2163 if (s390_short_displacement (addr.disp))
2164 return 0;
2165 break;
2166
2167 case 'Y':
2168 /* Simply check for the basic form of a shift count. Reload will
2169 take care of making sure we have a proper base register. */
2170 if (!s390_decompose_shift_count (op, NULL, NULL))
2171 return 0;
2172 break;
2173
2174 default:
2175 return 0;
2176 }
2177
2178 return 1;
2179 }
2180
2181
2182
2183 /* Evaluates constraint strings starting with letter O. Input
2184 parameter C is the second letter following the "O" in the constraint
2185 string. Returns 1 if VALUE meets the respective constraint and 0
2186 otherwise. */
2187
2188 int
2189 s390_O_constraint_str (const char c, HOST_WIDE_INT value)
2190 {
2191 if (!TARGET_EXTIMM)
2192 return 0;
2193
2194 switch (c)
2195 {
2196 case 's':
2197 return trunc_int_for_mode (value, SImode) == value;
2198
2199 case 'p':
2200 return value == 0
2201 || s390_single_part (GEN_INT (value), DImode, SImode, 0) == 1;
2202
2203 case 'n':
2204 return s390_single_part (GEN_INT (value - 1), DImode, SImode, -1) == 1;
2205
2206 default:
2207 gcc_unreachable ();
2208 }
2209 }
2210
2211
2212 /* Evaluates constraint strings starting with letter N. Parameter STR
2213 contains the letters following letter "N" in the constraint string.
2214 Returns true if VALUE matches the constraint. */
2215
2216 int
2217 s390_N_constraint_str (const char *str, HOST_WIDE_INT value)
2218 {
2219 enum machine_mode mode, part_mode;
2220 int def;
2221 int part, part_goal;
2222
2223
2224 if (str[0] == 'x')
2225 part_goal = -1;
2226 else
2227 part_goal = str[0] - '0';
2228
2229 switch (str[1])
2230 {
2231 case 'Q':
2232 part_mode = QImode;
2233 break;
2234 case 'H':
2235 part_mode = HImode;
2236 break;
2237 case 'S':
2238 part_mode = SImode;
2239 break;
2240 default:
2241 return 0;
2242 }
2243
2244 switch (str[2])
2245 {
2246 case 'H':
2247 mode = HImode;
2248 break;
2249 case 'S':
2250 mode = SImode;
2251 break;
2252 case 'D':
2253 mode = DImode;
2254 break;
2255 default:
2256 return 0;
2257 }
2258
2259 switch (str[3])
2260 {
2261 case '0':
2262 def = 0;
2263 break;
2264 case 'F':
2265 def = -1;
2266 break;
2267 default:
2268 return 0;
2269 }
2270
2271 if (GET_MODE_SIZE (mode) <= GET_MODE_SIZE (part_mode))
2272 return 0;
2273
2274 part = s390_single_part (GEN_INT (value), mode, part_mode, def);
2275 if (part < 0)
2276 return 0;
2277 if (part_goal != -1 && part_goal != part)
2278 return 0;
2279
2280 return 1;
2281 }
2282
2283
2284 /* Returns true if the input parameter VALUE is a float zero. */
2285
2286 int
2287 s390_float_const_zero_p (rtx value)
2288 {
2289 return (GET_MODE_CLASS (GET_MODE (value)) == MODE_FLOAT
2290 && value == CONST0_RTX (GET_MODE (value)));
2291 }
2292
2293
2294 /* Compute a (partial) cost for rtx X. Return true if the complete
2295 cost has been computed, and false if subexpressions should be
2296 scanned. In either case, *TOTAL contains the cost result.
2297 CODE contains GET_CODE (x), OUTER_CODE contains the code
2298 of the superexpression of x. */
2299
2300 static bool
2301 s390_rtx_costs (rtx x, int code, int outer_code, int *total)
2302 {
2303 switch (code)
2304 {
2305 case CONST:
2306 case CONST_INT:
2307 case LABEL_REF:
2308 case SYMBOL_REF:
2309 case CONST_DOUBLE:
2310 case MEM:
2311 *total = 0;
2312 return true;
2313
2314 case ASHIFT:
2315 case ASHIFTRT:
2316 case LSHIFTRT:
2317 case ROTATE:
2318 case ROTATERT:
2319 case AND:
2320 case IOR:
2321 case XOR:
2322 case NEG:
2323 case NOT:
2324 *total = COSTS_N_INSNS (1);
2325 return false;
2326
2327 case PLUS:
2328 case MINUS:
2329 /* Check for multiply and add. */
2330 if ((GET_MODE (x) == DFmode || GET_MODE (x) == SFmode)
2331 && GET_CODE (XEXP (x, 0)) == MULT
2332 && TARGET_HARD_FLOAT && TARGET_FUSED_MADD)
2333 {
2334 /* This is the multiply and add case. */
2335 if (GET_MODE (x) == DFmode)
2336 *total = s390_cost->madbr;
2337 else
2338 *total = s390_cost->maebr;
2339 *total += rtx_cost (XEXP (XEXP (x, 0), 0), MULT)
2340 + rtx_cost (XEXP (XEXP (x, 0), 1), MULT)
2341 + rtx_cost (XEXP (x, 1), code);
2342 return true; /* Do not do an additional recursive descent. */
2343 }
2344 *total = COSTS_N_INSNS (1);
2345 return false;
2346
2347 case MULT:
2348 switch (GET_MODE (x))
2349 {
2350 case SImode:
2351 {
2352 rtx left = XEXP (x, 0);
2353 rtx right = XEXP (x, 1);
2354 if (GET_CODE (right) == CONST_INT
2355 && CONST_OK_FOR_K (INTVAL (right)))
2356 *total = s390_cost->mhi;
2357 else if (GET_CODE (left) == SIGN_EXTEND)
2358 *total = s390_cost->mh;
2359 else
2360 *total = s390_cost->ms; /* msr, ms, msy */
2361 break;
2362 }
2363 case DImode:
2364 {
2365 rtx left = XEXP (x, 0);
2366 rtx right = XEXP (x, 1);
2367 if (TARGET_64BIT)
2368 {
2369 if (GET_CODE (right) == CONST_INT
2370 && CONST_OK_FOR_K (INTVAL (right)))
2371 *total = s390_cost->mghi;
2372 else if (GET_CODE (left) == SIGN_EXTEND)
2373 *total = s390_cost->msgf;
2374 else
2375 *total = s390_cost->msg; /* msgr, msg */
2376 }
2377 else /* TARGET_31BIT */
2378 {
2379 if (GET_CODE (left) == SIGN_EXTEND
2380 && GET_CODE (right) == SIGN_EXTEND)
2381 /* mulsidi case: mr, m */
2382 *total = s390_cost->m;
2383 else if (GET_CODE (left) == ZERO_EXTEND
2384 && GET_CODE (right) == ZERO_EXTEND
2385 && TARGET_CPU_ZARCH)
2386 /* umulsidi case: ml, mlr */
2387 *total = s390_cost->ml;
2388 else
2389 /* Complex calculation is required. */
2390 *total = COSTS_N_INSNS (40);
2391 }
2392 break;
2393 }
2394 case SFmode:
2395 case DFmode:
2396 *total = s390_cost->mult_df;
2397 break;
2398 case TFmode:
2399 *total = s390_cost->mxbr;
2400 break;
2401 default:
2402 return false;
2403 }
2404 return false;
2405
2406 case UDIV:
2407 case UMOD:
2408 if (GET_MODE (x) == TImode) /* 128 bit division */
2409 *total = s390_cost->dlgr;
2410 else if (GET_MODE (x) == DImode)
2411 {
2412 rtx right = XEXP (x, 1);
2413 if (GET_CODE (right) == ZERO_EXTEND) /* 64 by 32 bit division */
2414 *total = s390_cost->dlr;
2415 else /* 64 by 64 bit division */
2416 *total = s390_cost->dlgr;
2417 }
2418 else if (GET_MODE (x) == SImode) /* 32 bit division */
2419 *total = s390_cost->dlr;
2420 return false;
2421
2422 case DIV:
2423 case MOD:
2424 if (GET_MODE (x) == DImode)
2425 {
2426 rtx right = XEXP (x, 1);
2427 if (GET_CODE (right) == ZERO_EXTEND) /* 64 by 32 bit division */
2428 if (TARGET_64BIT)
2429 *total = s390_cost->dsgfr;
2430 else
2431 *total = s390_cost->dr;
2432 else /* 64 by 64 bit division */
2433 *total = s390_cost->dsgr;
2434 }
2435 else if (GET_MODE (x) == SImode) /* 32 bit division */
2436 *total = s390_cost->dlr;
2437 else if (GET_MODE (x) == SFmode)
2438 {
2439 *total = s390_cost->debr;
2440 }
2441 else if (GET_MODE (x) == DFmode)
2442 {
2443 *total = s390_cost->ddbr;
2444 }
2445 else if (GET_MODE (x) == TFmode)
2446 {
2447 *total = s390_cost->dxbr;
2448 }
2449 return false;
2450
2451 case SQRT:
2452 if (GET_MODE (x) == SFmode)
2453 *total = s390_cost->sqebr;
2454 else if (GET_MODE (x) == DFmode)
2455 *total = s390_cost->sqdbr;
2456 else /* TFmode */
2457 *total = s390_cost->sqxbr;
2458 return false;
2459
2460 case SIGN_EXTEND:
2461 case ZERO_EXTEND:
2462 if (outer_code == MULT || outer_code == DIV || outer_code == MOD
2463 || outer_code == PLUS || outer_code == MINUS
2464 || outer_code == COMPARE)
2465 *total = 0;
2466 return false;
2467
2468 case COMPARE:
2469 *total = COSTS_N_INSNS (1);
2470 if (GET_CODE (XEXP (x, 0)) == AND
2471 && GET_CODE (XEXP (x, 1)) == CONST_INT
2472 && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
2473 {
2474 rtx op0 = XEXP (XEXP (x, 0), 0);
2475 rtx op1 = XEXP (XEXP (x, 0), 1);
2476 rtx op2 = XEXP (x, 1);
2477
2478 if (memory_operand (op0, GET_MODE (op0))
2479 && s390_tm_ccmode (op1, op2, 0) != VOIDmode)
2480 return true;
2481 if (register_operand (op0, GET_MODE (op0))
2482 && s390_tm_ccmode (op1, op2, 1) != VOIDmode)
2483 return true;
2484 }
2485 return false;
2486
2487 default:
2488 return false;
2489 }
2490 }
2491
2492 /* Return the cost of an address rtx ADDR. */
2493
2494 static int
2495 s390_address_cost (rtx addr)
2496 {
2497 struct s390_address ad;
2498 if (!s390_decompose_address (addr, &ad))
2499 return 1000;
2500
2501 return ad.indx? COSTS_N_INSNS (1) + 1 : COSTS_N_INSNS (1);
2502 }
2503
2504 /* If OP is a SYMBOL_REF of a thread-local symbol, return its TLS mode,
2505 otherwise return 0. */
2506
2507 int
2508 tls_symbolic_operand (rtx op)
2509 {
2510 if (GET_CODE (op) != SYMBOL_REF)
2511 return 0;
2512 return SYMBOL_REF_TLS_MODEL (op);
2513 }
2514 \f
2515 /* Split DImode access register reference REG (on 64-bit) into its constituent
2516 low and high parts, and store them into LO and HI. Note that gen_lowpart/
2517 gen_highpart cannot be used as they assume all registers are word-sized,
2518 while our access registers have only half that size. */
2519
2520 void
2521 s390_split_access_reg (rtx reg, rtx *lo, rtx *hi)
2522 {
2523 gcc_assert (TARGET_64BIT);
2524 gcc_assert (ACCESS_REG_P (reg));
2525 gcc_assert (GET_MODE (reg) == DImode);
2526 gcc_assert (!(REGNO (reg) & 1));
2527
2528 *lo = gen_rtx_REG (SImode, REGNO (reg) + 1);
2529 *hi = gen_rtx_REG (SImode, REGNO (reg));
2530 }
2531
2532 /* Return true if OP contains a symbol reference */
2533
2534 bool
2535 symbolic_reference_mentioned_p (rtx op)
2536 {
2537 const char *fmt;
2538 int i;
2539
2540 if (GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == LABEL_REF)
2541 return 1;
2542
2543 fmt = GET_RTX_FORMAT (GET_CODE (op));
2544 for (i = GET_RTX_LENGTH (GET_CODE (op)) - 1; i >= 0; i--)
2545 {
2546 if (fmt[i] == 'E')
2547 {
2548 int j;
2549
2550 for (j = XVECLEN (op, i) - 1; j >= 0; j--)
2551 if (symbolic_reference_mentioned_p (XVECEXP (op, i, j)))
2552 return 1;
2553 }
2554
2555 else if (fmt[i] == 'e' && symbolic_reference_mentioned_p (XEXP (op, i)))
2556 return 1;
2557 }
2558
2559 return 0;
2560 }
2561
2562 /* Return true if OP contains a reference to a thread-local symbol. */
2563
2564 bool
2565 tls_symbolic_reference_mentioned_p (rtx op)
2566 {
2567 const char *fmt;
2568 int i;
2569
2570 if (GET_CODE (op) == SYMBOL_REF)
2571 return tls_symbolic_operand (op);
2572
2573 fmt = GET_RTX_FORMAT (GET_CODE (op));
2574 for (i = GET_RTX_LENGTH (GET_CODE (op)) - 1; i >= 0; i--)
2575 {
2576 if (fmt[i] == 'E')
2577 {
2578 int j;
2579
2580 for (j = XVECLEN (op, i) - 1; j >= 0; j--)
2581 if (tls_symbolic_reference_mentioned_p (XVECEXP (op, i, j)))
2582 return true;
2583 }
2584
2585 else if (fmt[i] == 'e' && tls_symbolic_reference_mentioned_p (XEXP (op, i)))
2586 return true;
2587 }
2588
2589 return false;
2590 }
2591
2592
2593 /* Return true if OP is a legitimate general operand when
2594 generating PIC code. It is given that flag_pic is on
2595 and that OP satisfies CONSTANT_P or is a CONST_DOUBLE. */
2596
2597 int
2598 legitimate_pic_operand_p (rtx op)
2599 {
2600 /* Accept all non-symbolic constants. */
2601 if (!SYMBOLIC_CONST (op))
2602 return 1;
2603
2604 /* Reject everything else; must be handled
2605 via emit_symbolic_move. */
2606 return 0;
2607 }
2608
2609 /* Returns true if the constant value OP is a legitimate general operand.
2610 It is given that OP satisfies CONSTANT_P or is a CONST_DOUBLE. */
2611
2612 int
2613 legitimate_constant_p (rtx op)
2614 {
2615 /* Accept all non-symbolic constants. */
2616 if (!SYMBOLIC_CONST (op))
2617 return 1;
2618
2619 /* Accept immediate LARL operands. */
2620 if (TARGET_CPU_ZARCH && larl_operand (op, VOIDmode))
2621 return 1;
2622
2623 /* Thread-local symbols are never legal constants. This is
2624 so that emit_call knows that computing such addresses
2625 might require a function call. */
2626 if (TLS_SYMBOLIC_CONST (op))
2627 return 0;
2628
2629 /* In the PIC case, symbolic constants must *not* be
2630 forced into the literal pool. We accept them here,
2631 so that they will be handled by emit_symbolic_move. */
2632 if (flag_pic)
2633 return 1;
2634
2635 /* All remaining non-PIC symbolic constants are
2636 forced into the literal pool. */
2637 return 0;
2638 }
2639
2640 /* Determine if it's legal to put X into the constant pool. This
2641 is not possible if X contains the address of a symbol that is
2642 not constant (TLS) or not known at final link time (PIC). */
2643
2644 static bool
2645 s390_cannot_force_const_mem (rtx x)
2646 {
2647 switch (GET_CODE (x))
2648 {
2649 case CONST_INT:
2650 case CONST_DOUBLE:
2651 /* Accept all non-symbolic constants. */
2652 return false;
2653
2654 case LABEL_REF:
2655 /* Labels are OK iff we are non-PIC. */
2656 return flag_pic != 0;
2657
2658 case SYMBOL_REF:
2659 /* 'Naked' TLS symbol references are never OK,
2660 non-TLS symbols are OK iff we are non-PIC. */
2661 if (tls_symbolic_operand (x))
2662 return true;
2663 else
2664 return flag_pic != 0;
2665
2666 case CONST:
2667 return s390_cannot_force_const_mem (XEXP (x, 0));
2668 case PLUS:
2669 case MINUS:
2670 return s390_cannot_force_const_mem (XEXP (x, 0))
2671 || s390_cannot_force_const_mem (XEXP (x, 1));
2672
2673 case UNSPEC:
2674 switch (XINT (x, 1))
2675 {
2676 /* Only lt-relative or GOT-relative UNSPECs are OK. */
2677 case UNSPEC_LTREL_OFFSET:
2678 case UNSPEC_GOT:
2679 case UNSPEC_GOTOFF:
2680 case UNSPEC_PLTOFF:
2681 case UNSPEC_TLSGD:
2682 case UNSPEC_TLSLDM:
2683 case UNSPEC_NTPOFF:
2684 case UNSPEC_DTPOFF:
2685 case UNSPEC_GOTNTPOFF:
2686 case UNSPEC_INDNTPOFF:
2687 return false;
2688
2689 /* If the literal pool shares the code section, be put
2690 execute template placeholders into the pool as well. */
2691 case UNSPEC_INSN:
2692 return TARGET_CPU_ZARCH;
2693
2694 default:
2695 return true;
2696 }
2697 break;
2698
2699 default:
2700 gcc_unreachable ();
2701 }
2702 }
2703
2704 /* Returns true if the constant value OP is a legitimate general
2705 operand during and after reload. The difference to
2706 legitimate_constant_p is that this function will not accept
2707 a constant that would need to be forced to the literal pool
2708 before it can be used as operand. */
2709
2710 bool
2711 legitimate_reload_constant_p (rtx op)
2712 {
2713 /* Accept la(y) operands. */
2714 if (GET_CODE (op) == CONST_INT
2715 && DISP_IN_RANGE (INTVAL (op)))
2716 return true;
2717
2718 /* Accept l(g)hi/l(g)fi operands. */
2719 if (GET_CODE (op) == CONST_INT
2720 && (CONST_OK_FOR_K (INTVAL (op)) || CONST_OK_FOR_Os (INTVAL (op))))
2721 return true;
2722
2723 /* Accept lliXX operands. */
2724 if (TARGET_ZARCH
2725 && GET_CODE (op) == CONST_INT
2726 && trunc_int_for_mode (INTVAL (op), word_mode) == INTVAL (op)
2727 && s390_single_part (op, word_mode, HImode, 0) >= 0)
2728 return true;
2729
2730 if (TARGET_EXTIMM
2731 && GET_CODE (op) == CONST_INT
2732 && trunc_int_for_mode (INTVAL (op), word_mode) == INTVAL (op)
2733 && s390_single_part (op, word_mode, SImode, 0) >= 0)
2734 return true;
2735
2736 /* Accept larl operands. */
2737 if (TARGET_CPU_ZARCH
2738 && larl_operand (op, VOIDmode))
2739 return true;
2740
2741 /* Accept lzXX operands. */
2742 if (GET_CODE (op) == CONST_DOUBLE
2743 && CONST_DOUBLE_OK_FOR_CONSTRAINT_P (op, 'G', "G"))
2744 return true;
2745
2746 /* Accept double-word operands that can be split. */
2747 if (GET_CODE (op) == CONST_INT
2748 && trunc_int_for_mode (INTVAL (op), word_mode) != INTVAL (op))
2749 {
2750 enum machine_mode dword_mode = word_mode == SImode ? DImode : TImode;
2751 rtx hi = operand_subword (op, 0, 0, dword_mode);
2752 rtx lo = operand_subword (op, 1, 0, dword_mode);
2753 return legitimate_reload_constant_p (hi)
2754 && legitimate_reload_constant_p (lo);
2755 }
2756
2757 /* Everything else cannot be handled without reload. */
2758 return false;
2759 }
2760
2761 /* Given an rtx OP being reloaded into a reg required to be in class CLASS,
2762 return the class of reg to actually use. */
2763
2764 enum reg_class
2765 s390_preferred_reload_class (rtx op, enum reg_class class)
2766 {
2767 switch (GET_CODE (op))
2768 {
2769 /* Constants we cannot reload must be forced into the
2770 literal pool. */
2771
2772 case CONST_DOUBLE:
2773 case CONST_INT:
2774 if (legitimate_reload_constant_p (op))
2775 return class;
2776 else
2777 return NO_REGS;
2778
2779 /* If a symbolic constant or a PLUS is reloaded,
2780 it is most likely being used as an address, so
2781 prefer ADDR_REGS. If 'class' is not a superset
2782 of ADDR_REGS, e.g. FP_REGS, reject this reload. */
2783 case PLUS:
2784 case LABEL_REF:
2785 case SYMBOL_REF:
2786 case CONST:
2787 if (reg_class_subset_p (ADDR_REGS, class))
2788 return ADDR_REGS;
2789 else
2790 return NO_REGS;
2791
2792 default:
2793 break;
2794 }
2795
2796 return class;
2797 }
2798
2799 /* Return true if ADDR is of kind symbol_ref or symbol_ref + const_int
2800 and return these parts in SYMREF and ADDEND. You can pass NULL in
2801 SYMREF and/or ADDEND if you are not interested in these values. */
2802
2803 static bool
2804 s390_symref_operand_p (rtx addr, rtx *symref, HOST_WIDE_INT *addend)
2805 {
2806 HOST_WIDE_INT tmpaddend = 0;
2807
2808 if (GET_CODE (addr) == CONST)
2809 addr = XEXP (addr, 0);
2810
2811 if (GET_CODE (addr) == PLUS)
2812 {
2813 if (GET_CODE (XEXP (addr, 0)) == SYMBOL_REF
2814 && CONST_INT_P (XEXP (addr, 1)))
2815 {
2816 tmpaddend = INTVAL (XEXP (addr, 1));
2817 addr = XEXP (addr, 0);
2818 }
2819 else
2820 return false;
2821 }
2822 else
2823 if (GET_CODE (addr) != SYMBOL_REF)
2824 return false;
2825
2826 if (symref)
2827 *symref = addr;
2828 if (addend)
2829 *addend = tmpaddend;
2830
2831 return true;
2832 }
2833
2834 /* Return true if ADDR is SYMBOL_REF + addend with addend being a
2835 multiple of ALIGNMENT and the SYMBOL_REF being naturally
2836 aligned. */
2837
2838 bool
2839 s390_check_symref_alignment (rtx addr, HOST_WIDE_INT alignment)
2840 {
2841 HOST_WIDE_INT addend;
2842 rtx symref;
2843
2844 if (!s390_symref_operand_p (addr, &symref, &addend))
2845 return false;
2846
2847 return (!SYMBOL_REF_NOT_NATURALLY_ALIGNED_P (symref)
2848 && !(addend & (alignment - 1)));
2849 }
2850
2851 /* ADDR is moved into REG using larl. If ADDR isn't a valid larl
2852 operand SCRATCH is used to reload the even part of the address and
2853 adding one. */
2854
2855 void
2856 s390_reload_larl_operand (rtx reg, rtx addr, rtx scratch)
2857 {
2858 HOST_WIDE_INT addend;
2859 rtx symref;
2860
2861 if (!s390_symref_operand_p (addr, &symref, &addend))
2862 gcc_unreachable ();
2863
2864 if (!(addend & 1))
2865 /* Easy case. The addend is even so larl will do fine. */
2866 emit_move_insn (reg, addr);
2867 else
2868 {
2869 /* We can leave the scratch register untouched if the target
2870 register is a valid base register. */
2871 if (REGNO (reg) < FIRST_PSEUDO_REGISTER
2872 && REGNO_REG_CLASS (REGNO (reg)) == ADDR_REGS)
2873 scratch = reg;
2874
2875 gcc_assert (REGNO (scratch) < FIRST_PSEUDO_REGISTER);
2876 gcc_assert (REGNO_REG_CLASS (REGNO (scratch)) == ADDR_REGS);
2877
2878 if (addend != 1)
2879 emit_move_insn (scratch,
2880 gen_rtx_CONST (Pmode,
2881 gen_rtx_PLUS (Pmode, symref,
2882 GEN_INT (addend - 1))));
2883 else
2884 emit_move_insn (scratch, symref);
2885
2886 /* Increment the address using la in order to avoid clobbering cc. */
2887 emit_move_insn (reg, gen_rtx_PLUS (Pmode, scratch, const1_rtx));
2888 }
2889 }
2890
2891 /* Generate what is necessary to move between REG and MEM using
2892 SCRATCH. The direction is given by TOMEM. */
2893
2894 void
2895 s390_reload_symref_address (rtx reg, rtx mem, rtx scratch, bool tomem)
2896 {
2897 /* Reload might have pulled a constant out of the literal pool.
2898 Force it back in. */
2899 if (CONST_INT_P (mem) || GET_CODE (mem) == CONST_DOUBLE
2900 || GET_CODE (mem) == CONST)
2901 mem = force_const_mem (GET_MODE (reg), mem);
2902
2903 gcc_assert (MEM_P (mem));
2904
2905 /* For a load from memory we can leave the scratch register
2906 untouched if the target register is a valid base register. */
2907 if (!tomem
2908 && REGNO (reg) < FIRST_PSEUDO_REGISTER
2909 && REGNO_REG_CLASS (REGNO (reg)) == ADDR_REGS
2910 && GET_MODE (reg) == GET_MODE (scratch))
2911 scratch = reg;
2912
2913 /* Load address into scratch register. Since we can't have a
2914 secondary reload for a secondary reload we have to cover the case
2915 where larl would need a secondary reload here as well. */
2916 s390_reload_larl_operand (scratch, XEXP (mem, 0), scratch);
2917
2918 /* Now we can use a standard load/store to do the move. */
2919 if (tomem)
2920 emit_move_insn (replace_equiv_address (mem, scratch), reg);
2921 else
2922 emit_move_insn (reg, replace_equiv_address (mem, scratch));
2923 }
2924
2925 /* Inform reload about cases where moving X with a mode MODE to a register in
2926 CLASS requires an extra scratch or immediate register. Return the class
2927 needed for the immediate register. */
2928
2929 static enum reg_class
2930 s390_secondary_reload (bool in_p, rtx x, enum reg_class class,
2931 enum machine_mode mode, secondary_reload_info *sri)
2932 {
2933 /* Intermediate register needed. */
2934 if (reg_classes_intersect_p (CC_REGS, class))
2935 return GENERAL_REGS;
2936
2937 if (TARGET_Z10)
2938 {
2939 /* On z10 several optimizer steps may generate larl operands with
2940 an odd addend. */
2941 if (in_p
2942 && s390_symref_operand_p (x, NULL, NULL)
2943 && mode == Pmode
2944 && !s390_check_symref_alignment (x, 2))
2945 sri->icode = ((mode == DImode) ? CODE_FOR_reloaddi_larl_odd_addend_z10
2946 : CODE_FOR_reloadsi_larl_odd_addend_z10);
2947
2948 /* On z10 we need a scratch register when moving QI, TI or floating
2949 point mode values from or to a memory location with a SYMBOL_REF
2950 or if the symref addend of a SI or DI move is not aligned to the
2951 width of the access. */
2952 if (MEM_P (x)
2953 && s390_symref_operand_p (XEXP (x, 0), NULL, NULL)
2954 && (mode == QImode || mode == TImode || FLOAT_MODE_P (mode)
2955 || (!TARGET_64BIT && mode == DImode)
2956 || ((mode == HImode || mode == SImode || mode == DImode)
2957 && (!s390_check_symref_alignment (XEXP (x, 0),
2958 GET_MODE_SIZE (mode))))))
2959 {
2960 #define __SECONDARY_RELOAD_CASE(M,m) \
2961 case M##mode: \
2962 if (TARGET_64BIT) \
2963 sri->icode = in_p ? CODE_FOR_reload##m##di_toreg_z10 : \
2964 CODE_FOR_reload##m##di_tomem_z10; \
2965 else \
2966 sri->icode = in_p ? CODE_FOR_reload##m##si_toreg_z10 : \
2967 CODE_FOR_reload##m##si_tomem_z10; \
2968 break;
2969
2970 switch (GET_MODE (x))
2971 {
2972 __SECONDARY_RELOAD_CASE (QI, qi);
2973 __SECONDARY_RELOAD_CASE (HI, hi);
2974 __SECONDARY_RELOAD_CASE (SI, si);
2975 __SECONDARY_RELOAD_CASE (DI, di);
2976 __SECONDARY_RELOAD_CASE (TI, ti);
2977 __SECONDARY_RELOAD_CASE (SF, sf);
2978 __SECONDARY_RELOAD_CASE (DF, df);
2979 __SECONDARY_RELOAD_CASE (TF, tf);
2980 __SECONDARY_RELOAD_CASE (SD, sd);
2981 __SECONDARY_RELOAD_CASE (DD, dd);
2982 __SECONDARY_RELOAD_CASE (TD, td);
2983
2984 default:
2985 gcc_unreachable ();
2986 }
2987 #undef __SECONDARY_RELOAD_CASE
2988 }
2989 }
2990
2991 /* We need a scratch register when loading a PLUS expression which
2992 is not a legitimate operand of the LOAD ADDRESS instruction. */
2993 if (in_p && s390_plus_operand (x, mode))
2994 sri->icode = (TARGET_64BIT ?
2995 CODE_FOR_reloaddi_plus : CODE_FOR_reloadsi_plus);
2996
2997 /* Performing a multiword move from or to memory we have to make sure the
2998 second chunk in memory is addressable without causing a displacement
2999 overflow. If that would be the case we calculate the address in
3000 a scratch register. */
3001 if (MEM_P (x)
3002 && GET_CODE (XEXP (x, 0)) == PLUS
3003 && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
3004 && !DISP_IN_RANGE (INTVAL (XEXP (XEXP (x, 0), 1))
3005 + GET_MODE_SIZE (mode) - 1))
3006 {
3007 /* For GENERAL_REGS a displacement overflow is no problem if occurring
3008 in a s_operand address since we may fallback to lm/stm. So we only
3009 have to care about overflows in the b+i+d case. */
3010 if ((reg_classes_intersect_p (GENERAL_REGS, class)
3011 && s390_class_max_nregs (GENERAL_REGS, mode) > 1
3012 && GET_CODE (XEXP (XEXP (x, 0), 0)) == PLUS)
3013 /* For FP_REGS no lm/stm is available so this check is triggered
3014 for displacement overflows in b+i+d and b+d like addresses. */
3015 || (reg_classes_intersect_p (FP_REGS, class)
3016 && s390_class_max_nregs (FP_REGS, mode) > 1))
3017 {
3018 if (in_p)
3019 sri->icode = (TARGET_64BIT ?
3020 CODE_FOR_reloaddi_nonoffmem_in :
3021 CODE_FOR_reloadsi_nonoffmem_in);
3022 else
3023 sri->icode = (TARGET_64BIT ?
3024 CODE_FOR_reloaddi_nonoffmem_out :
3025 CODE_FOR_reloadsi_nonoffmem_out);
3026 }
3027 }
3028
3029 /* Either scratch or no register needed. */
3030 return NO_REGS;
3031 }
3032
3033 /* Generate code to load SRC, which is PLUS that is not a
3034 legitimate operand for the LA instruction, into TARGET.
3035 SCRATCH may be used as scratch register. */
3036
3037 void
3038 s390_expand_plus_operand (rtx target, rtx src,
3039 rtx scratch)
3040 {
3041 rtx sum1, sum2;
3042 struct s390_address ad;
3043
3044 /* src must be a PLUS; get its two operands. */
3045 gcc_assert (GET_CODE (src) == PLUS);
3046 gcc_assert (GET_MODE (src) == Pmode);
3047
3048 /* Check if any of the two operands is already scheduled
3049 for replacement by reload. This can happen e.g. when
3050 float registers occur in an address. */
3051 sum1 = find_replacement (&XEXP (src, 0));
3052 sum2 = find_replacement (&XEXP (src, 1));
3053 src = gen_rtx_PLUS (Pmode, sum1, sum2);
3054
3055 /* If the address is already strictly valid, there's nothing to do. */
3056 if (!s390_decompose_address (src, &ad)
3057 || (ad.base && !REGNO_OK_FOR_BASE_P (REGNO (ad.base)))
3058 || (ad.indx && !REGNO_OK_FOR_INDEX_P (REGNO (ad.indx))))
3059 {
3060 /* Otherwise, one of the operands cannot be an address register;
3061 we reload its value into the scratch register. */
3062 if (true_regnum (sum1) < 1 || true_regnum (sum1) > 15)
3063 {
3064 emit_move_insn (scratch, sum1);
3065 sum1 = scratch;
3066 }
3067 if (true_regnum (sum2) < 1 || true_regnum (sum2) > 15)
3068 {
3069 emit_move_insn (scratch, sum2);
3070 sum2 = scratch;
3071 }
3072
3073 /* According to the way these invalid addresses are generated
3074 in reload.c, it should never happen (at least on s390) that
3075 *neither* of the PLUS components, after find_replacements
3076 was applied, is an address register. */
3077 if (sum1 == scratch && sum2 == scratch)
3078 {
3079 debug_rtx (src);
3080 gcc_unreachable ();
3081 }
3082
3083 src = gen_rtx_PLUS (Pmode, sum1, sum2);
3084 }
3085
3086 /* Emit the LOAD ADDRESS pattern. Note that reload of PLUS
3087 is only ever performed on addresses, so we can mark the
3088 sum as legitimate for LA in any case. */
3089 s390_load_address (target, src);
3090 }
3091
3092
3093 /* Return true if ADDR is a valid memory address.
3094 STRICT specifies whether strict register checking applies. */
3095
3096 bool
3097 legitimate_address_p (enum machine_mode mode, rtx addr, int strict)
3098 {
3099 struct s390_address ad;
3100
3101 if (TARGET_Z10
3102 && larl_operand (addr, VOIDmode)
3103 && (mode == VOIDmode
3104 || s390_check_symref_alignment (addr, GET_MODE_SIZE (mode))))
3105 return true;
3106
3107 if (!s390_decompose_address (addr, &ad))
3108 return false;
3109
3110 if (strict)
3111 {
3112 if (ad.base && !REGNO_OK_FOR_BASE_P (REGNO (ad.base)))
3113 return false;
3114
3115 if (ad.indx && !REGNO_OK_FOR_INDEX_P (REGNO (ad.indx)))
3116 return false;
3117 }
3118 else
3119 {
3120 if (ad.base
3121 && !(REGNO (ad.base) >= FIRST_PSEUDO_REGISTER
3122 || REGNO_REG_CLASS (REGNO (ad.base)) == ADDR_REGS))
3123 return false;
3124
3125 if (ad.indx
3126 && !(REGNO (ad.indx) >= FIRST_PSEUDO_REGISTER
3127 || REGNO_REG_CLASS (REGNO (ad.indx)) == ADDR_REGS))
3128 return false;
3129 }
3130 return true;
3131 }
3132
3133 /* Return true if OP is a valid operand for the LA instruction.
3134 In 31-bit, we need to prove that the result is used as an
3135 address, as LA performs only a 31-bit addition. */
3136
3137 bool
3138 legitimate_la_operand_p (rtx op)
3139 {
3140 struct s390_address addr;
3141 if (!s390_decompose_address (op, &addr))
3142 return false;
3143
3144 return (TARGET_64BIT || addr.pointer);
3145 }
3146
3147 /* Return true if it is valid *and* preferable to use LA to
3148 compute the sum of OP1 and OP2. */
3149
3150 bool
3151 preferred_la_operand_p (rtx op1, rtx op2)
3152 {
3153 struct s390_address addr;
3154
3155 if (op2 != const0_rtx)
3156 op1 = gen_rtx_PLUS (Pmode, op1, op2);
3157
3158 if (!s390_decompose_address (op1, &addr))
3159 return false;
3160 if (addr.base && !REGNO_OK_FOR_BASE_P (REGNO (addr.base)))
3161 return false;
3162 if (addr.indx && !REGNO_OK_FOR_INDEX_P (REGNO (addr.indx)))
3163 return false;
3164
3165 if (!TARGET_64BIT && !addr.pointer)
3166 return false;
3167
3168 if (addr.pointer)
3169 return true;
3170
3171 if ((addr.base && REG_P (addr.base) && REG_POINTER (addr.base))
3172 || (addr.indx && REG_P (addr.indx) && REG_POINTER (addr.indx)))
3173 return true;
3174
3175 return false;
3176 }
3177
3178 /* Emit a forced load-address operation to load SRC into DST.
3179 This will use the LOAD ADDRESS instruction even in situations
3180 where legitimate_la_operand_p (SRC) returns false. */
3181
3182 void
3183 s390_load_address (rtx dst, rtx src)
3184 {
3185 if (TARGET_64BIT)
3186 emit_move_insn (dst, src);
3187 else
3188 emit_insn (gen_force_la_31 (dst, src));
3189 }
3190
3191 /* Return a legitimate reference for ORIG (an address) using the
3192 register REG. If REG is 0, a new pseudo is generated.
3193
3194 There are two types of references that must be handled:
3195
3196 1. Global data references must load the address from the GOT, via
3197 the PIC reg. An insn is emitted to do this load, and the reg is
3198 returned.
3199
3200 2. Static data references, constant pool addresses, and code labels
3201 compute the address as an offset from the GOT, whose base is in
3202 the PIC reg. Static data objects have SYMBOL_FLAG_LOCAL set to
3203 differentiate them from global data objects. The returned
3204 address is the PIC reg + an unspec constant.
3205
3206 GO_IF_LEGITIMATE_ADDRESS rejects symbolic references unless the PIC
3207 reg also appears in the address. */
3208
3209 rtx
3210 legitimize_pic_address (rtx orig, rtx reg)
3211 {
3212 rtx addr = orig;
3213 rtx new = orig;
3214 rtx base;
3215
3216 gcc_assert (!TLS_SYMBOLIC_CONST (addr));
3217
3218 if (GET_CODE (addr) == LABEL_REF
3219 || (GET_CODE (addr) == SYMBOL_REF && SYMBOL_REF_LOCAL_P (addr)))
3220 {
3221 /* This is a local symbol. */
3222 if (TARGET_CPU_ZARCH && larl_operand (addr, VOIDmode))
3223 {
3224 /* Access local symbols PC-relative via LARL.
3225 This is the same as in the non-PIC case, so it is
3226 handled automatically ... */
3227 }
3228 else
3229 {
3230 /* Access local symbols relative to the GOT. */
3231
3232 rtx temp = reg? reg : gen_reg_rtx (Pmode);
3233
3234 if (reload_in_progress || reload_completed)
3235 df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
3236
3237 addr = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTOFF);
3238 addr = gen_rtx_CONST (Pmode, addr);
3239 addr = force_const_mem (Pmode, addr);
3240 emit_move_insn (temp, addr);
3241
3242 new = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp);
3243 if (reg != 0)
3244 {
3245 s390_load_address (reg, new);
3246 new = reg;
3247 }
3248 }
3249 }
3250 else if (GET_CODE (addr) == SYMBOL_REF)
3251 {
3252 if (reg == 0)
3253 reg = gen_reg_rtx (Pmode);
3254
3255 if (flag_pic == 1)
3256 {
3257 /* Assume GOT offset < 4k. This is handled the same way
3258 in both 31- and 64-bit code (@GOT). */
3259
3260 if (reload_in_progress || reload_completed)
3261 df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
3262
3263 new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOT);
3264 new = gen_rtx_CONST (Pmode, new);
3265 new = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, new);
3266 new = gen_const_mem (Pmode, new);
3267 emit_move_insn (reg, new);
3268 new = reg;
3269 }
3270 else if (TARGET_CPU_ZARCH)
3271 {
3272 /* If the GOT offset might be >= 4k, we determine the position
3273 of the GOT entry via a PC-relative LARL (@GOTENT). */
3274
3275 rtx temp = gen_reg_rtx (Pmode);
3276
3277 new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTENT);
3278 new = gen_rtx_CONST (Pmode, new);
3279 emit_move_insn (temp, new);
3280
3281 new = gen_const_mem (Pmode, temp);
3282 emit_move_insn (reg, new);
3283 new = reg;
3284 }
3285 else
3286 {
3287 /* If the GOT offset might be >= 4k, we have to load it
3288 from the literal pool (@GOT). */
3289
3290 rtx temp = gen_reg_rtx (Pmode);
3291
3292 if (reload_in_progress || reload_completed)
3293 df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
3294
3295 addr = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOT);
3296 addr = gen_rtx_CONST (Pmode, addr);
3297 addr = force_const_mem (Pmode, addr);
3298 emit_move_insn (temp, addr);
3299
3300 new = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp);
3301 new = gen_const_mem (Pmode, new);
3302 emit_move_insn (reg, new);
3303 new = reg;
3304 }
3305 }
3306 else
3307 {
3308 if (GET_CODE (addr) == CONST)
3309 {
3310 addr = XEXP (addr, 0);
3311 if (GET_CODE (addr) == UNSPEC)
3312 {
3313 gcc_assert (XVECLEN (addr, 0) == 1);
3314 switch (XINT (addr, 1))
3315 {
3316 /* If someone moved a GOT-relative UNSPEC
3317 out of the literal pool, force them back in. */
3318 case UNSPEC_GOTOFF:
3319 case UNSPEC_PLTOFF:
3320 new = force_const_mem (Pmode, orig);
3321 break;
3322
3323 /* @GOT is OK as is if small. */
3324 case UNSPEC_GOT:
3325 if (flag_pic == 2)
3326 new = force_const_mem (Pmode, orig);
3327 break;
3328
3329 /* @GOTENT is OK as is. */
3330 case UNSPEC_GOTENT:
3331 break;
3332
3333 /* @PLT is OK as is on 64-bit, must be converted to
3334 GOT-relative @PLTOFF on 31-bit. */
3335 case UNSPEC_PLT:
3336 if (!TARGET_CPU_ZARCH)
3337 {
3338 rtx temp = reg? reg : gen_reg_rtx (Pmode);
3339
3340 if (reload_in_progress || reload_completed)
3341 df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
3342
3343 addr = XVECEXP (addr, 0, 0);
3344 addr = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr),
3345 UNSPEC_PLTOFF);
3346 addr = gen_rtx_CONST (Pmode, addr);
3347 addr = force_const_mem (Pmode, addr);
3348 emit_move_insn (temp, addr);
3349
3350 new = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp);
3351 if (reg != 0)
3352 {
3353 s390_load_address (reg, new);
3354 new = reg;
3355 }
3356 }
3357 break;
3358
3359 /* Everything else cannot happen. */
3360 default:
3361 gcc_unreachable ();
3362 }
3363 }
3364 else
3365 gcc_assert (GET_CODE (addr) == PLUS);
3366 }
3367 if (GET_CODE (addr) == PLUS)
3368 {
3369 rtx op0 = XEXP (addr, 0), op1 = XEXP (addr, 1);
3370
3371 gcc_assert (!TLS_SYMBOLIC_CONST (op0));
3372 gcc_assert (!TLS_SYMBOLIC_CONST (op1));
3373
3374 /* Check first to see if this is a constant offset
3375 from a local symbol reference. */
3376 if ((GET_CODE (op0) == LABEL_REF
3377 || (GET_CODE (op0) == SYMBOL_REF && SYMBOL_REF_LOCAL_P (op0)))
3378 && GET_CODE (op1) == CONST_INT)
3379 {
3380 if (TARGET_CPU_ZARCH
3381 && larl_operand (op0, VOIDmode)
3382 && INTVAL (op1) < (HOST_WIDE_INT)1 << 31
3383 && INTVAL (op1) >= -((HOST_WIDE_INT)1 << 31))
3384 {
3385 if (INTVAL (op1) & 1)
3386 {
3387 /* LARL can't handle odd offsets, so emit a
3388 pair of LARL and LA. */
3389 rtx temp = reg? reg : gen_reg_rtx (Pmode);
3390
3391 if (!DISP_IN_RANGE (INTVAL (op1)))
3392 {
3393 HOST_WIDE_INT even = INTVAL (op1) - 1;
3394 op0 = gen_rtx_PLUS (Pmode, op0, GEN_INT (even));
3395 op0 = gen_rtx_CONST (Pmode, op0);
3396 op1 = const1_rtx;
3397 }
3398
3399 emit_move_insn (temp, op0);
3400 new = gen_rtx_PLUS (Pmode, temp, op1);
3401
3402 if (reg != 0)
3403 {
3404 s390_load_address (reg, new);
3405 new = reg;
3406 }
3407 }
3408 else
3409 {
3410 /* If the offset is even, we can just use LARL.
3411 This will happen automatically. */
3412 }
3413 }
3414 else
3415 {
3416 /* Access local symbols relative to the GOT. */
3417
3418 rtx temp = reg? reg : gen_reg_rtx (Pmode);
3419
3420 if (reload_in_progress || reload_completed)
3421 df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
3422
3423 addr = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, op0),
3424 UNSPEC_GOTOFF);
3425 addr = gen_rtx_PLUS (Pmode, addr, op1);
3426 addr = gen_rtx_CONST (Pmode, addr);
3427 addr = force_const_mem (Pmode, addr);
3428 emit_move_insn (temp, addr);
3429
3430 new = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp);
3431 if (reg != 0)
3432 {
3433 s390_load_address (reg, new);
3434 new = reg;
3435 }
3436 }
3437 }
3438
3439 /* Now, check whether it is a GOT relative symbol plus offset
3440 that was pulled out of the literal pool. Force it back in. */
3441
3442 else if (GET_CODE (op0) == UNSPEC
3443 && GET_CODE (op1) == CONST_INT
3444 && XINT (op0, 1) == UNSPEC_GOTOFF)
3445 {
3446 gcc_assert (XVECLEN (op0, 0) == 1);
3447
3448 new = force_const_mem (Pmode, orig);
3449 }
3450
3451 /* Otherwise, compute the sum. */
3452 else
3453 {
3454 base = legitimize_pic_address (XEXP (addr, 0), reg);
3455 new = legitimize_pic_address (XEXP (addr, 1),
3456 base == reg ? NULL_RTX : reg);
3457 if (GET_CODE (new) == CONST_INT)
3458 new = plus_constant (base, INTVAL (new));
3459 else
3460 {
3461 if (GET_CODE (new) == PLUS && CONSTANT_P (XEXP (new, 1)))
3462 {
3463 base = gen_rtx_PLUS (Pmode, base, XEXP (new, 0));
3464 new = XEXP (new, 1);
3465 }
3466 new = gen_rtx_PLUS (Pmode, base, new);
3467 }
3468
3469 if (GET_CODE (new) == CONST)
3470 new = XEXP (new, 0);
3471 new = force_operand (new, 0);
3472 }
3473 }
3474 }
3475 return new;
3476 }
3477
3478 /* Load the thread pointer into a register. */
3479
3480 rtx
3481 s390_get_thread_pointer (void)
3482 {
3483 rtx tp = gen_reg_rtx (Pmode);
3484
3485 emit_move_insn (tp, gen_rtx_REG (Pmode, TP_REGNUM));
3486 mark_reg_pointer (tp, BITS_PER_WORD);
3487
3488 return tp;
3489 }
3490
3491 /* Emit a tls call insn. The call target is the SYMBOL_REF stored
3492 in s390_tls_symbol which always refers to __tls_get_offset.
3493 The returned offset is written to RESULT_REG and an USE rtx is
3494 generated for TLS_CALL. */
3495
3496 static GTY(()) rtx s390_tls_symbol;
3497
3498 static void
3499 s390_emit_tls_call_insn (rtx result_reg, rtx tls_call)
3500 {
3501 rtx insn;
3502
3503 gcc_assert (flag_pic);
3504
3505 if (!s390_tls_symbol)
3506 s390_tls_symbol = gen_rtx_SYMBOL_REF (Pmode, "__tls_get_offset");
3507
3508 insn = s390_emit_call (s390_tls_symbol, tls_call, result_reg,
3509 gen_rtx_REG (Pmode, RETURN_REGNUM));
3510
3511 use_reg (&CALL_INSN_FUNCTION_USAGE (insn), result_reg);
3512 RTL_CONST_CALL_P (insn) = 1;
3513 }
3514
3515 /* ADDR contains a thread-local SYMBOL_REF. Generate code to compute
3516 this (thread-local) address. REG may be used as temporary. */
3517
3518 static rtx
3519 legitimize_tls_address (rtx addr, rtx reg)
3520 {
3521 rtx new, tls_call, temp, base, r2, insn;
3522
3523 if (GET_CODE (addr) == SYMBOL_REF)
3524 switch (tls_symbolic_operand (addr))
3525 {
3526 case TLS_MODEL_GLOBAL_DYNAMIC:
3527 start_sequence ();
3528 r2 = gen_rtx_REG (Pmode, 2);
3529 tls_call = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_TLSGD);
3530 new = gen_rtx_CONST (Pmode, tls_call);
3531 new = force_const_mem (Pmode, new);
3532 emit_move_insn (r2, new);
3533 s390_emit_tls_call_insn (r2, tls_call);
3534 insn = get_insns ();
3535 end_sequence ();
3536
3537 new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_NTPOFF);
3538 temp = gen_reg_rtx (Pmode);
3539 emit_libcall_block (insn, temp, r2, new);
3540
3541 new = gen_rtx_PLUS (Pmode, s390_get_thread_pointer (), temp);
3542 if (reg != 0)
3543 {
3544 s390_load_address (reg, new);
3545 new = reg;
3546 }
3547 break;
3548
3549 case TLS_MODEL_LOCAL_DYNAMIC:
3550 start_sequence ();
3551 r2 = gen_rtx_REG (Pmode, 2);
3552 tls_call = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx), UNSPEC_TLSLDM);
3553 new = gen_rtx_CONST (Pmode, tls_call);
3554 new = force_const_mem (Pmode, new);
3555 emit_move_insn (r2, new);
3556 s390_emit_tls_call_insn (r2, tls_call);
3557 insn = get_insns ();
3558 end_sequence ();
3559
3560 new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx), UNSPEC_TLSLDM_NTPOFF);
3561 temp = gen_reg_rtx (Pmode);
3562 emit_libcall_block (insn, temp, r2, new);
3563
3564 new = gen_rtx_PLUS (Pmode, s390_get_thread_pointer (), temp);
3565 base = gen_reg_rtx (Pmode);
3566 s390_load_address (base, new);
3567
3568 new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_DTPOFF);
3569 new = gen_rtx_CONST (Pmode, new);
3570 new = force_const_mem (Pmode, new);
3571 temp = gen_reg_rtx (Pmode);
3572 emit_move_insn (temp, new);
3573
3574 new = gen_rtx_PLUS (Pmode, base, temp);
3575 if (reg != 0)
3576 {
3577 s390_load_address (reg, new);
3578 new = reg;
3579 }
3580 break;
3581
3582 case TLS_MODEL_INITIAL_EXEC:
3583 if (flag_pic == 1)
3584 {
3585 /* Assume GOT offset < 4k. This is handled the same way
3586 in both 31- and 64-bit code. */
3587
3588 if (reload_in_progress || reload_completed)
3589 df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
3590
3591 new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTNTPOFF);
3592 new = gen_rtx_CONST (Pmode, new);
3593 new = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, new);
3594 new = gen_const_mem (Pmode, new);
3595 temp = gen_reg_rtx (Pmode);
3596 emit_move_insn (temp, new);
3597 }
3598 else if (TARGET_CPU_ZARCH)
3599 {
3600 /* If the GOT offset might be >= 4k, we determine the position
3601 of the GOT entry via a PC-relative LARL. */
3602
3603 new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_INDNTPOFF);
3604 new = gen_rtx_CONST (Pmode, new);
3605 temp = gen_reg_rtx (Pmode);
3606 emit_move_insn (temp, new);
3607
3608 new = gen_const_mem (Pmode, temp);
3609 temp = gen_reg_rtx (Pmode);
3610 emit_move_insn (temp, new);
3611 }
3612 else if (flag_pic)
3613 {
3614 /* If the GOT offset might be >= 4k, we have to load it
3615 from the literal pool. */
3616
3617 if (reload_in_progress || reload_completed)
3618 df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
3619
3620 new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_GOTNTPOFF);
3621 new = gen_rtx_CONST (Pmode, new);
3622 new = force_const_mem (Pmode, new);
3623 temp = gen_reg_rtx (Pmode);
3624 emit_move_insn (temp, new);
3625
3626 new = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, temp);
3627 new = gen_const_mem (Pmode, new);
3628
3629 new = gen_rtx_UNSPEC (Pmode, gen_rtvec (2, new, addr), UNSPEC_TLS_LOAD);
3630 temp = gen_reg_rtx (Pmode);
3631 emit_insn (gen_rtx_SET (Pmode, temp, new));
3632 }
3633 else
3634 {
3635 /* In position-dependent code, load the absolute address of
3636 the GOT entry from the literal pool. */
3637
3638 new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_INDNTPOFF);
3639 new = gen_rtx_CONST (Pmode, new);
3640 new = force_const_mem (Pmode, new);
3641 temp = gen_reg_rtx (Pmode);
3642 emit_move_insn (temp, new);
3643
3644 new = temp;
3645 new = gen_const_mem (Pmode, new);
3646 new = gen_rtx_UNSPEC (Pmode, gen_rtvec (2, new, addr), UNSPEC_TLS_LOAD);
3647 temp = gen_reg_rtx (Pmode);
3648 emit_insn (gen_rtx_SET (Pmode, temp, new));
3649 }
3650
3651 new = gen_rtx_PLUS (Pmode, s390_get_thread_pointer (), temp);
3652 if (reg != 0)
3653 {
3654 s390_load_address (reg, new);
3655 new = reg;
3656 }
3657 break;
3658
3659 case TLS_MODEL_LOCAL_EXEC:
3660 new = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), UNSPEC_NTPOFF);
3661 new = gen_rtx_CONST (Pmode, new);
3662 new = force_const_mem (Pmode, new);
3663 temp = gen_reg_rtx (Pmode);
3664 emit_move_insn (temp, new);
3665
3666 new = gen_rtx_PLUS (Pmode, s390_get_thread_pointer (), temp);
3667 if (reg != 0)
3668 {
3669 s390_load_address (reg, new);
3670 new = reg;
3671 }
3672 break;
3673
3674 default:
3675 gcc_unreachable ();
3676 }
3677
3678 else if (GET_CODE (addr) == CONST && GET_CODE (XEXP (addr, 0)) == UNSPEC)
3679 {
3680 switch (XINT (XEXP (addr, 0), 1))
3681 {
3682 case UNSPEC_INDNTPOFF:
3683 gcc_assert (TARGET_CPU_ZARCH);
3684 new = addr;
3685 break;
3686
3687 default:
3688 gcc_unreachable ();
3689 }
3690 }
3691
3692 else if (GET_CODE (addr) == CONST && GET_CODE (XEXP (addr, 0)) == PLUS
3693 && GET_CODE (XEXP (XEXP (addr, 0), 1)) == CONST_INT)
3694 {
3695 new = XEXP (XEXP (addr, 0), 0);
3696 if (GET_CODE (new) != SYMBOL_REF)
3697 new = gen_rtx_CONST (Pmode, new);
3698
3699 new = legitimize_tls_address (new, reg);
3700 new = plus_constant (new, INTVAL (XEXP (XEXP (addr, 0), 1)));
3701 new = force_operand (new, 0);
3702 }
3703
3704 else
3705 gcc_unreachable (); /* for now ... */
3706
3707 return new;
3708 }
3709
3710 /* Emit insns to move operands[1] into operands[0]. */
3711
3712 void
3713 emit_symbolic_move (rtx *operands)
3714 {
3715 rtx temp = !can_create_pseudo_p () ? operands[0] : gen_reg_rtx (Pmode);
3716
3717 if (GET_CODE (operands[0]) == MEM)
3718 operands[1] = force_reg (Pmode, operands[1]);
3719 else if (TLS_SYMBOLIC_CONST (operands[1]))
3720 operands[1] = legitimize_tls_address (operands[1], temp);
3721 else if (flag_pic)
3722 operands[1] = legitimize_pic_address (operands[1], temp);
3723 }
3724
3725 /* Try machine-dependent ways of modifying an illegitimate address X
3726 to be legitimate. If we find one, return the new, valid address.
3727
3728 OLDX is the address as it was before break_out_memory_refs was called.
3729 In some cases it is useful to look at this to decide what needs to be done.
3730
3731 MODE is the mode of the operand pointed to by X.
3732
3733 When -fpic is used, special handling is needed for symbolic references.
3734 See comments by legitimize_pic_address for details. */
3735
3736 rtx
3737 legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
3738 enum machine_mode mode ATTRIBUTE_UNUSED)
3739 {
3740 rtx constant_term = const0_rtx;
3741
3742 if (TLS_SYMBOLIC_CONST (x))
3743 {
3744 x = legitimize_tls_address (x, 0);
3745
3746 if (legitimate_address_p (mode, x, FALSE))
3747 return x;
3748 }
3749 else if (GET_CODE (x) == PLUS
3750 && (TLS_SYMBOLIC_CONST (XEXP (x, 0))
3751 || TLS_SYMBOLIC_CONST (XEXP (x, 1))))
3752 {
3753 return x;
3754 }
3755 else if (flag_pic)
3756 {
3757 if (SYMBOLIC_CONST (x)
3758 || (GET_CODE (x) == PLUS
3759 && (SYMBOLIC_CONST (XEXP (x, 0))
3760 || SYMBOLIC_CONST (XEXP (x, 1)))))
3761 x = legitimize_pic_address (x, 0);
3762
3763 if (legitimate_address_p (mode, x, FALSE))
3764 return x;
3765 }
3766
3767 x = eliminate_constant_term (x, &constant_term);
3768
3769 /* Optimize loading of large displacements by splitting them
3770 into the multiple of 4K and the rest; this allows the
3771 former to be CSE'd if possible.
3772
3773 Don't do this if the displacement is added to a register
3774 pointing into the stack frame, as the offsets will
3775 change later anyway. */
3776
3777 if (GET_CODE (constant_term) == CONST_INT
3778 && !TARGET_LONG_DISPLACEMENT
3779 && !DISP_IN_RANGE (INTVAL (constant_term))
3780 && !(REG_P (x) && REGNO_PTR_FRAME_P (REGNO (x))))
3781 {
3782 HOST_WIDE_INT lower = INTVAL (constant_term) & 0xfff;
3783 HOST_WIDE_INT upper = INTVAL (constant_term) ^ lower;
3784
3785 rtx temp = gen_reg_rtx (Pmode);
3786 rtx val = force_operand (GEN_INT (upper), temp);
3787 if (val != temp)
3788 emit_move_insn (temp, val);
3789
3790 x = gen_rtx_PLUS (Pmode, x, temp);
3791 constant_term = GEN_INT (lower);
3792 }
3793
3794 if (GET_CODE (x) == PLUS)
3795 {
3796 if (GET_CODE (XEXP (x, 0)) == REG)
3797 {
3798 rtx temp = gen_reg_rtx (Pmode);
3799 rtx val = force_operand (XEXP (x, 1), temp);
3800 if (val != temp)
3801 emit_move_insn (temp, val);
3802
3803 x = gen_rtx_PLUS (Pmode, XEXP (x, 0), temp);
3804 }
3805
3806 else if (GET_CODE (XEXP (x, 1)) == REG)
3807 {
3808 rtx temp = gen_reg_rtx (Pmode);
3809 rtx val = force_operand (XEXP (x, 0), temp);
3810 if (val != temp)
3811 emit_move_insn (temp, val);
3812
3813 x = gen_rtx_PLUS (Pmode, temp, XEXP (x, 1));
3814 }
3815 }
3816
3817 if (constant_term != const0_rtx)
3818 x = gen_rtx_PLUS (Pmode, x, constant_term);
3819
3820 return x;
3821 }
3822
3823 /* Try a machine-dependent way of reloading an illegitimate address AD
3824 operand. If we find one, push the reload and and return the new address.
3825
3826 MODE is the mode of the enclosing MEM. OPNUM is the operand number
3827 and TYPE is the reload type of the current reload. */
3828
3829 rtx
3830 legitimize_reload_address (rtx ad, enum machine_mode mode ATTRIBUTE_UNUSED,
3831 int opnum, int type)
3832 {
3833 if (!optimize || TARGET_LONG_DISPLACEMENT)
3834 return NULL_RTX;
3835
3836 if (GET_CODE (ad) == PLUS)
3837 {
3838 rtx tem = simplify_binary_operation (PLUS, Pmode,
3839 XEXP (ad, 0), XEXP (ad, 1));
3840 if (tem)
3841 ad = tem;
3842 }
3843
3844 if (GET_CODE (ad) == PLUS
3845 && GET_CODE (XEXP (ad, 0)) == REG
3846 && GET_CODE (XEXP (ad, 1)) == CONST_INT
3847 && !DISP_IN_RANGE (INTVAL (XEXP (ad, 1))))
3848 {
3849 HOST_WIDE_INT lower = INTVAL (XEXP (ad, 1)) & 0xfff;
3850 HOST_WIDE_INT upper = INTVAL (XEXP (ad, 1)) ^ lower;
3851 rtx cst, tem, new;
3852
3853 cst = GEN_INT (upper);
3854 if (!legitimate_reload_constant_p (cst))
3855 cst = force_const_mem (Pmode, cst);
3856
3857 tem = gen_rtx_PLUS (Pmode, XEXP (ad, 0), cst);
3858 new = gen_rtx_PLUS (Pmode, tem, GEN_INT (lower));
3859
3860 push_reload (XEXP (tem, 1), 0, &XEXP (tem, 1), 0,
3861 BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,
3862 opnum, (enum reload_type) type);
3863 return new;
3864 }
3865
3866 return NULL_RTX;
3867 }
3868
3869 /* Emit code to move LEN bytes from DST to SRC. */
3870
3871 void
3872 s390_expand_movmem (rtx dst, rtx src, rtx len)
3873 {
3874 if (GET_CODE (len) == CONST_INT && INTVAL (len) >= 0 && INTVAL (len) <= 256)
3875 {
3876 if (INTVAL (len) > 0)
3877 emit_insn (gen_movmem_short (dst, src, GEN_INT (INTVAL (len) - 1)));
3878 }
3879
3880 else if (TARGET_MVCLE)
3881 {
3882 emit_insn (gen_movmem_long (dst, src, convert_to_mode (Pmode, len, 1)));
3883 }
3884
3885 else
3886 {
3887 rtx dst_addr, src_addr, count, blocks, temp;
3888 rtx loop_start_label = gen_label_rtx ();
3889 rtx loop_end_label = gen_label_rtx ();
3890 rtx end_label = gen_label_rtx ();
3891 enum machine_mode mode;
3892
3893 mode = GET_MODE (len);
3894 if (mode == VOIDmode)
3895 mode = Pmode;
3896
3897 dst_addr = gen_reg_rtx (Pmode);
3898 src_addr = gen_reg_rtx (Pmode);
3899 count = gen_reg_rtx (mode);
3900 blocks = gen_reg_rtx (mode);
3901
3902 convert_move (count, len, 1);
3903 emit_cmp_and_jump_insns (count, const0_rtx,
3904 EQ, NULL_RTX, mode, 1, end_label);
3905
3906 emit_move_insn (dst_addr, force_operand (XEXP (dst, 0), NULL_RTX));
3907 emit_move_insn (src_addr, force_operand (XEXP (src, 0), NULL_RTX));
3908 dst = change_address (dst, VOIDmode, dst_addr);
3909 src = change_address (src, VOIDmode, src_addr);
3910
3911 temp = expand_binop (mode, add_optab, count, constm1_rtx, count, 1, 0);
3912 if (temp != count)
3913 emit_move_insn (count, temp);
3914
3915 temp = expand_binop (mode, lshr_optab, count, GEN_INT (8), blocks, 1, 0);
3916 if (temp != blocks)
3917 emit_move_insn (blocks, temp);
3918
3919 emit_cmp_and_jump_insns (blocks, const0_rtx,
3920 EQ, NULL_RTX, mode, 1, loop_end_label);
3921
3922 emit_label (loop_start_label);
3923
3924 emit_insn (gen_movmem_short (dst, src, GEN_INT (255)));
3925 s390_load_address (dst_addr,
3926 gen_rtx_PLUS (Pmode, dst_addr, GEN_INT (256)));
3927 s390_load_address (src_addr,
3928 gen_rtx_PLUS (Pmode, src_addr, GEN_INT (256)));
3929
3930 temp = expand_binop (mode, add_optab, blocks, constm1_rtx, blocks, 1, 0);
3931 if (temp != blocks)
3932 emit_move_insn (blocks, temp);
3933
3934 emit_cmp_and_jump_insns (blocks, const0_rtx,
3935 EQ, NULL_RTX, mode, 1, loop_end_label);
3936
3937 emit_jump (loop_start_label);
3938 emit_label (loop_end_label);
3939
3940 emit_insn (gen_movmem_short (dst, src,
3941 convert_to_mode (Pmode, count, 1)));
3942 emit_label (end_label);
3943 }
3944 }
3945
3946 /* Emit code to set LEN bytes at DST to VAL.
3947 Make use of clrmem if VAL is zero. */
3948
3949 void
3950 s390_expand_setmem (rtx dst, rtx len, rtx val)
3951 {
3952 if (GET_CODE (len) == CONST_INT && INTVAL (len) == 0)
3953 return;
3954
3955 gcc_assert (GET_CODE (val) == CONST_INT || GET_MODE (val) == QImode);
3956
3957 if (GET_CODE (len) == CONST_INT && INTVAL (len) > 0 && INTVAL (len) <= 257)
3958 {
3959 if (val == const0_rtx && INTVAL (len) <= 256)
3960 emit_insn (gen_clrmem_short (dst, GEN_INT (INTVAL (len) - 1)));
3961 else
3962 {
3963 /* Initialize memory by storing the first byte. */
3964 emit_move_insn (adjust_address (dst, QImode, 0), val);
3965
3966 if (INTVAL (len) > 1)
3967 {
3968 /* Initiate 1 byte overlap move.
3969 The first byte of DST is propagated through DSTP1.
3970 Prepare a movmem for: DST+1 = DST (length = LEN - 1).
3971 DST is set to size 1 so the rest of the memory location
3972 does not count as source operand. */
3973 rtx dstp1 = adjust_address (dst, VOIDmode, 1);
3974 set_mem_size (dst, const1_rtx);
3975
3976 emit_insn (gen_movmem_short (dstp1, dst,
3977 GEN_INT (INTVAL (len) - 2)));
3978 }
3979 }
3980 }
3981
3982 else if (TARGET_MVCLE)
3983 {
3984 val = force_not_mem (convert_modes (Pmode, QImode, val, 1));
3985 emit_insn (gen_setmem_long (dst, convert_to_mode (Pmode, len, 1), val));
3986 }
3987
3988 else
3989 {
3990 rtx dst_addr, src_addr, count, blocks, temp, dstp1 = NULL_RTX;
3991 rtx loop_start_label = gen_label_rtx ();
3992 rtx loop_end_label = gen_label_rtx ();
3993 rtx end_label = gen_label_rtx ();
3994 enum machine_mode mode;
3995
3996 mode = GET_MODE (len);
3997 if (mode == VOIDmode)
3998 mode = Pmode;
3999
4000 dst_addr = gen_reg_rtx (Pmode);
4001 src_addr = gen_reg_rtx (Pmode);
4002 count = gen_reg_rtx (mode);
4003 blocks = gen_reg_rtx (mode);
4004
4005 convert_move (count, len, 1);
4006 emit_cmp_and_jump_insns (count, const0_rtx,
4007 EQ, NULL_RTX, mode, 1, end_label);
4008
4009 emit_move_insn (dst_addr, force_operand (XEXP (dst, 0), NULL_RTX));
4010 dst = change_address (dst, VOIDmode, dst_addr);
4011
4012 if (val == const0_rtx)
4013 temp = expand_binop (mode, add_optab, count, constm1_rtx, count, 1, 0);
4014 else
4015 {
4016 dstp1 = adjust_address (dst, VOIDmode, 1);
4017 set_mem_size (dst, const1_rtx);
4018
4019 /* Initialize memory by storing the first byte. */
4020 emit_move_insn (adjust_address (dst, QImode, 0), val);
4021
4022 /* If count is 1 we are done. */
4023 emit_cmp_and_jump_insns (count, const1_rtx,
4024 EQ, NULL_RTX, mode, 1, end_label);
4025
4026 temp = expand_binop (mode, add_optab, count, GEN_INT (-2), count, 1, 0);
4027 }
4028 if (temp != count)
4029 emit_move_insn (count, temp);
4030
4031 temp = expand_binop (mode, lshr_optab, count, GEN_INT (8), blocks, 1, 0);
4032 if (temp != blocks)
4033 emit_move_insn (blocks, temp);
4034
4035 emit_cmp_and_jump_insns (blocks, const0_rtx,
4036 EQ, NULL_RTX, mode, 1, loop_end_label);
4037
4038 emit_label (loop_start_label);
4039
4040 if (val == const0_rtx)
4041 emit_insn (gen_clrmem_short (dst, GEN_INT (255)));
4042 else
4043 emit_insn (gen_movmem_short (dstp1, dst, GEN_INT (255)));
4044 s390_load_address (dst_addr,
4045 gen_rtx_PLUS (Pmode, dst_addr, GEN_INT (256)));
4046
4047 temp = expand_binop (mode, add_optab, blocks, constm1_rtx, blocks, 1, 0);
4048 if (temp != blocks)
4049 emit_move_insn (blocks, temp);
4050
4051 emit_cmp_and_jump_insns (blocks, const0_rtx,
4052 EQ, NULL_RTX, mode, 1, loop_end_label);
4053
4054 emit_jump (loop_start_label);
4055 emit_label (loop_end_label);
4056
4057 if (val == const0_rtx)
4058 emit_insn (gen_clrmem_short (dst, convert_to_mode (Pmode, count, 1)));
4059 else
4060 emit_insn (gen_movmem_short (dstp1, dst, convert_to_mode (Pmode, count, 1)));
4061 emit_label (end_label);
4062 }
4063 }
4064
4065 /* Emit code to compare LEN bytes at OP0 with those at OP1,
4066 and return the result in TARGET. */
4067
4068 void
4069 s390_expand_cmpmem (rtx target, rtx op0, rtx op1, rtx len)
4070 {
4071 rtx ccreg = gen_rtx_REG (CCUmode, CC_REGNUM);
4072 rtx tmp;
4073
4074 /* As the result of CMPINT is inverted compared to what we need,
4075 we have to swap the operands. */
4076 tmp = op0; op0 = op1; op1 = tmp;
4077
4078 if (GET_CODE (len) == CONST_INT && INTVAL (len) >= 0 && INTVAL (len) <= 256)
4079 {
4080 if (INTVAL (len) > 0)
4081 {
4082 emit_insn (gen_cmpmem_short (op0, op1, GEN_INT (INTVAL (len) - 1)));
4083 emit_insn (gen_cmpint (target, ccreg));
4084 }
4085 else
4086 emit_move_insn (target, const0_rtx);
4087 }
4088 else if (TARGET_MVCLE)
4089 {
4090 emit_insn (gen_cmpmem_long (op0, op1, convert_to_mode (Pmode, len, 1)));
4091 emit_insn (gen_cmpint (target, ccreg));
4092 }
4093 else
4094 {
4095 rtx addr0, addr1, count, blocks, temp;
4096 rtx loop_start_label = gen_label_rtx ();
4097 rtx loop_end_label = gen_label_rtx ();
4098 rtx end_label = gen_label_rtx ();
4099 enum machine_mode mode;
4100
4101 mode = GET_MODE (len);
4102 if (mode == VOIDmode)
4103 mode = Pmode;
4104
4105 addr0 = gen_reg_rtx (Pmode);
4106 addr1 = gen_reg_rtx (Pmode);
4107 count = gen_reg_rtx (mode);
4108 blocks = gen_reg_rtx (mode);
4109
4110 convert_move (count, len, 1);
4111 emit_cmp_and_jump_insns (count, const0_rtx,
4112 EQ, NULL_RTX, mode, 1, end_label);
4113
4114 emit_move_insn (addr0, force_operand (XEXP (op0, 0), NULL_RTX));
4115 emit_move_insn (addr1, force_operand (XEXP (op1, 0), NULL_RTX));
4116 op0 = change_address (op0, VOIDmode, addr0);
4117 op1 = change_address (op1, VOIDmode, addr1);
4118
4119 temp = expand_binop (mode, add_optab, count, constm1_rtx, count, 1, 0);
4120 if (temp != count)
4121 emit_move_insn (count, temp);
4122
4123 temp = expand_binop (mode, lshr_optab, count, GEN_INT (8), blocks, 1, 0);
4124 if (temp != blocks)
4125 emit_move_insn (blocks, temp);
4126
4127 emit_cmp_and_jump_insns (blocks, const0_rtx,
4128 EQ, NULL_RTX, mode, 1, loop_end_label);
4129
4130 emit_label (loop_start_label);
4131
4132 emit_insn (gen_cmpmem_short (op0, op1, GEN_INT (255)));
4133 temp = gen_rtx_NE (VOIDmode, ccreg, const0_rtx);
4134 temp = gen_rtx_IF_THEN_ELSE (VOIDmode, temp,
4135 gen_rtx_LABEL_REF (VOIDmode, end_label), pc_rtx);
4136 temp = gen_rtx_SET (VOIDmode, pc_rtx, temp);
4137 emit_jump_insn (temp);
4138
4139 s390_load_address (addr0,
4140 gen_rtx_PLUS (Pmode, addr0, GEN_INT (256)));
4141 s390_load_address (addr1,
4142 gen_rtx_PLUS (Pmode, addr1, GEN_INT (256)));
4143
4144 temp = expand_binop (mode, add_optab, blocks, constm1_rtx, blocks, 1, 0);
4145 if (temp != blocks)
4146 emit_move_insn (blocks, temp);
4147
4148 emit_cmp_and_jump_insns (blocks, const0_rtx,
4149 EQ, NULL_RTX, mode, 1, loop_end_label);
4150
4151 emit_jump (loop_start_label);
4152 emit_label (loop_end_label);
4153
4154 emit_insn (gen_cmpmem_short (op0, op1,
4155 convert_to_mode (Pmode, count, 1)));
4156 emit_label (end_label);
4157
4158 emit_insn (gen_cmpint (target, ccreg));
4159 }
4160 }
4161
4162
4163 /* Expand conditional increment or decrement using alc/slb instructions.
4164 Should generate code setting DST to either SRC or SRC + INCREMENT,
4165 depending on the result of the comparison CMP_OP0 CMP_CODE CMP_OP1.
4166 Returns true if successful, false otherwise.
4167
4168 That makes it possible to implement some if-constructs without jumps e.g.:
4169 (borrow = CC0 | CC1 and carry = CC2 | CC3)
4170 unsigned int a, b, c;
4171 if (a < b) c++; -> CCU b > a -> CC2; c += carry;
4172 if (a < b) c--; -> CCL3 a - b -> borrow; c -= borrow;
4173 if (a <= b) c++; -> CCL3 b - a -> borrow; c += carry;
4174 if (a <= b) c--; -> CCU a <= b -> borrow; c -= borrow;
4175
4176 Checks for EQ and NE with a nonzero value need an additional xor e.g.:
4177 if (a == b) c++; -> CCL3 a ^= b; 0 - a -> borrow; c += carry;
4178 if (a == b) c--; -> CCU a ^= b; a <= 0 -> CC0 | CC1; c -= borrow;
4179 if (a != b) c++; -> CCU a ^= b; a > 0 -> CC2; c += carry;
4180 if (a != b) c--; -> CCL3 a ^= b; 0 - a -> borrow; c -= borrow; */
4181
4182 bool
4183 s390_expand_addcc (enum rtx_code cmp_code, rtx cmp_op0, rtx cmp_op1,
4184 rtx dst, rtx src, rtx increment)
4185 {
4186 enum machine_mode cmp_mode;
4187 enum machine_mode cc_mode;
4188 rtx op_res;
4189 rtx insn;
4190 rtvec p;
4191 int ret;
4192
4193 if ((GET_MODE (cmp_op0) == SImode || GET_MODE (cmp_op0) == VOIDmode)
4194 && (GET_MODE (cmp_op1) == SImode || GET_MODE (cmp_op1) == VOIDmode))
4195 cmp_mode = SImode;
4196 else if ((GET_MODE (cmp_op0) == DImode || GET_MODE (cmp_op0) == VOIDmode)
4197 && (GET_MODE (cmp_op1) == DImode || GET_MODE (cmp_op1) == VOIDmode))
4198 cmp_mode = DImode;
4199 else
4200 return false;
4201
4202 /* Try ADD LOGICAL WITH CARRY. */
4203 if (increment == const1_rtx)
4204 {
4205 /* Determine CC mode to use. */
4206 if (cmp_code == EQ || cmp_code == NE)
4207 {
4208 if (cmp_op1 != const0_rtx)
4209 {
4210 cmp_op0 = expand_simple_binop (cmp_mode, XOR, cmp_op0, cmp_op1,
4211 NULL_RTX, 0, OPTAB_WIDEN);
4212 cmp_op1 = const0_rtx;
4213 }
4214
4215 cmp_code = cmp_code == EQ ? LEU : GTU;
4216 }
4217
4218 if (cmp_code == LTU || cmp_code == LEU)
4219 {
4220 rtx tem = cmp_op0;
4221 cmp_op0 = cmp_op1;
4222 cmp_op1 = tem;
4223 cmp_code = swap_condition (cmp_code);
4224 }
4225
4226 switch (cmp_code)
4227 {
4228 case GTU:
4229 cc_mode = CCUmode;
4230 break;
4231
4232 case GEU:
4233 cc_mode = CCL3mode;
4234 break;
4235
4236 default:
4237 return false;
4238 }
4239
4240 /* Emit comparison instruction pattern. */
4241 if (!register_operand (cmp_op0, cmp_mode))
4242 cmp_op0 = force_reg (cmp_mode, cmp_op0);
4243
4244 insn = gen_rtx_SET (VOIDmode, gen_rtx_REG (cc_mode, CC_REGNUM),
4245 gen_rtx_COMPARE (cc_mode, cmp_op0, cmp_op1));
4246 /* We use insn_invalid_p here to add clobbers if required. */
4247 ret = insn_invalid_p (emit_insn (insn));
4248 gcc_assert (!ret);
4249
4250 /* Emit ALC instruction pattern. */
4251 op_res = gen_rtx_fmt_ee (cmp_code, GET_MODE (dst),
4252 gen_rtx_REG (cc_mode, CC_REGNUM),
4253 const0_rtx);
4254
4255 if (src != const0_rtx)
4256 {
4257 if (!register_operand (src, GET_MODE (dst)))
4258 src = force_reg (GET_MODE (dst), src);
4259
4260 op_res = gen_rtx_PLUS (GET_MODE (dst), op_res, src);
4261 op_res = gen_rtx_PLUS (GET_MODE (dst), op_res, const0_rtx);
4262 }
4263
4264 p = rtvec_alloc (2);
4265 RTVEC_ELT (p, 0) =
4266 gen_rtx_SET (VOIDmode, dst, op_res);
4267 RTVEC_ELT (p, 1) =
4268 gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, CC_REGNUM));
4269 emit_insn (gen_rtx_PARALLEL (VOIDmode, p));
4270
4271 return true;
4272 }
4273
4274 /* Try SUBTRACT LOGICAL WITH BORROW. */
4275 if (increment == constm1_rtx)
4276 {
4277 /* Determine CC mode to use. */
4278 if (cmp_code == EQ || cmp_code == NE)
4279 {
4280 if (cmp_op1 != const0_rtx)
4281 {
4282 cmp_op0 = expand_simple_binop (cmp_mode, XOR, cmp_op0, cmp_op1,
4283 NULL_RTX, 0, OPTAB_WIDEN);
4284 cmp_op1 = const0_rtx;
4285 }
4286
4287 cmp_code = cmp_code == EQ ? LEU : GTU;
4288 }
4289
4290 if (cmp_code == GTU || cmp_code == GEU)
4291 {
4292 rtx tem = cmp_op0;
4293 cmp_op0 = cmp_op1;
4294 cmp_op1 = tem;
4295 cmp_code = swap_condition (cmp_code);
4296 }
4297
4298 switch (cmp_code)
4299 {
4300 case LEU:
4301 cc_mode = CCUmode;
4302 break;
4303
4304 case LTU:
4305 cc_mode = CCL3mode;
4306 break;
4307
4308 default:
4309 return false;
4310 }
4311
4312 /* Emit comparison instruction pattern. */
4313 if (!register_operand (cmp_op0, cmp_mode))
4314 cmp_op0 = force_reg (cmp_mode, cmp_op0);
4315
4316 insn = gen_rtx_SET (VOIDmode, gen_rtx_REG (cc_mode, CC_REGNUM),
4317 gen_rtx_COMPARE (cc_mode, cmp_op0, cmp_op1));
4318 /* We use insn_invalid_p here to add clobbers if required. */
4319 ret = insn_invalid_p (emit_insn (insn));
4320 gcc_assert (!ret);
4321
4322 /* Emit SLB instruction pattern. */
4323 if (!register_operand (src, GET_MODE (dst)))
4324 src = force_reg (GET_MODE (dst), src);
4325
4326 op_res = gen_rtx_MINUS (GET_MODE (dst),
4327 gen_rtx_MINUS (GET_MODE (dst), src, const0_rtx),
4328 gen_rtx_fmt_ee (cmp_code, GET_MODE (dst),
4329 gen_rtx_REG (cc_mode, CC_REGNUM),
4330 const0_rtx));
4331 p = rtvec_alloc (2);
4332 RTVEC_ELT (p, 0) =
4333 gen_rtx_SET (VOIDmode, dst, op_res);
4334 RTVEC_ELT (p, 1) =
4335 gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, CC_REGNUM));
4336 emit_insn (gen_rtx_PARALLEL (VOIDmode, p));
4337
4338 return true;
4339 }
4340
4341 return false;
4342 }
4343
4344 /* Expand code for the insv template. Return true if successful. */
4345
4346 bool
4347 s390_expand_insv (rtx dest, rtx op1, rtx op2, rtx src)
4348 {
4349 int bitsize = INTVAL (op1);
4350 int bitpos = INTVAL (op2);
4351
4352 /* On z10 we can use the risbg instruction to implement insv. */
4353 if (TARGET_Z10
4354 && ((GET_MODE (dest) == DImode && GET_MODE (src) == DImode)
4355 || (GET_MODE (dest) == SImode && GET_MODE (src) == SImode)))
4356 {
4357 rtx op;
4358 rtx clobber;
4359
4360 op = gen_rtx_SET (GET_MODE(src),
4361 gen_rtx_ZERO_EXTRACT (GET_MODE (dest), dest, op1, op2),
4362 src);
4363 clobber = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (CCmode, CC_REGNUM));
4364 emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, op, clobber)));
4365
4366 return true;
4367 }
4368
4369 /* We need byte alignment. */
4370 if (bitsize % BITS_PER_UNIT)
4371 return false;
4372
4373 if (bitpos == 0
4374 && memory_operand (dest, VOIDmode)
4375 && (register_operand (src, word_mode)
4376 || const_int_operand (src, VOIDmode)))
4377 {
4378 /* Emit standard pattern if possible. */
4379 enum machine_mode mode = smallest_mode_for_size (bitsize, MODE_INT);
4380 if (GET_MODE_BITSIZE (mode) == bitsize)
4381 emit_move_insn (adjust_address (dest, mode, 0), gen_lowpart (mode, src));
4382
4383 /* (set (ze (mem)) (const_int)). */
4384 else if (const_int_operand (src, VOIDmode))
4385 {
4386 int size = bitsize / BITS_PER_UNIT;
4387 rtx src_mem = adjust_address (force_const_mem (word_mode, src), BLKmode,
4388 GET_MODE_SIZE (word_mode) - size);
4389
4390 dest = adjust_address (dest, BLKmode, 0);
4391 set_mem_size (dest, GEN_INT (size));
4392 s390_expand_movmem (dest, src_mem, GEN_INT (size));
4393 }
4394
4395 /* (set (ze (mem)) (reg)). */
4396 else if (register_operand (src, word_mode))
4397 {
4398 if (bitsize <= GET_MODE_BITSIZE (SImode))
4399 emit_move_insn (gen_rtx_ZERO_EXTRACT (word_mode, dest, op1,
4400 const0_rtx), src);
4401 else
4402 {
4403 /* Emit st,stcmh sequence. */
4404 int stcmh_width = bitsize - GET_MODE_BITSIZE (SImode);
4405 int size = stcmh_width / BITS_PER_UNIT;
4406
4407 emit_move_insn (adjust_address (dest, SImode, size),
4408 gen_lowpart (SImode, src));
4409 set_mem_size (dest, GEN_INT (size));
4410 emit_move_insn (gen_rtx_ZERO_EXTRACT (word_mode, dest, GEN_INT
4411 (stcmh_width), const0_rtx),
4412 gen_rtx_LSHIFTRT (word_mode, src, GEN_INT
4413 (GET_MODE_BITSIZE (SImode))));
4414 }
4415 }
4416 else
4417 return false;
4418
4419 return true;
4420 }
4421
4422 /* (set (ze (reg)) (const_int)). */
4423 if (TARGET_ZARCH
4424 && register_operand (dest, word_mode)
4425 && (bitpos % 16) == 0
4426 && (bitsize % 16) == 0
4427 && const_int_operand (src, VOIDmode))
4428 {
4429 HOST_WIDE_INT val = INTVAL (src);
4430 int regpos = bitpos + bitsize;
4431
4432 while (regpos > bitpos)
4433 {
4434 enum machine_mode putmode;
4435 int putsize;
4436
4437 if (TARGET_EXTIMM && (regpos % 32 == 0) && (regpos >= bitpos + 32))
4438 putmode = SImode;
4439 else
4440 putmode = HImode;
4441
4442 putsize = GET_MODE_BITSIZE (putmode);
4443 regpos -= putsize;
4444 emit_move_insn (gen_rtx_ZERO_EXTRACT (word_mode, dest,
4445 GEN_INT (putsize),
4446 GEN_INT (regpos)),
4447 gen_int_mode (val, putmode));
4448 val >>= putsize;
4449 }
4450 gcc_assert (regpos == bitpos);
4451 return true;
4452 }
4453
4454 return false;
4455 }
4456
4457 /* A subroutine of s390_expand_cs_hqi and s390_expand_atomic which returns a
4458 register that holds VAL of mode MODE shifted by COUNT bits. */
4459
4460 static inline rtx
4461 s390_expand_mask_and_shift (rtx val, enum machine_mode mode, rtx count)
4462 {
4463 val = expand_simple_binop (SImode, AND, val, GEN_INT (GET_MODE_MASK (mode)),
4464 NULL_RTX, 1, OPTAB_DIRECT);
4465 return expand_simple_binop (SImode, ASHIFT, val, count,
4466 NULL_RTX, 1, OPTAB_DIRECT);
4467 }
4468
4469 /* Structure to hold the initial parameters for a compare_and_swap operation
4470 in HImode and QImode. */
4471
4472 struct alignment_context
4473 {
4474 rtx memsi; /* SI aligned memory location. */
4475 rtx shift; /* Bit offset with regard to lsb. */
4476 rtx modemask; /* Mask of the HQImode shifted by SHIFT bits. */
4477 rtx modemaski; /* ~modemask */
4478 bool aligned; /* True if memory is aligned, false else. */
4479 };
4480
4481 /* A subroutine of s390_expand_cs_hqi and s390_expand_atomic to initialize
4482 structure AC for transparent simplifying, if the memory alignment is known
4483 to be at least 32bit. MEM is the memory location for the actual operation
4484 and MODE its mode. */
4485
4486 static void
4487 init_alignment_context (struct alignment_context *ac, rtx mem,
4488 enum machine_mode mode)
4489 {
4490 ac->shift = GEN_INT (GET_MODE_SIZE (SImode) - GET_MODE_SIZE (mode));
4491 ac->aligned = (MEM_ALIGN (mem) >= GET_MODE_BITSIZE (SImode));
4492
4493 if (ac->aligned)
4494 ac->memsi = adjust_address (mem, SImode, 0); /* Memory is aligned. */
4495 else
4496 {
4497 /* Alignment is unknown. */
4498 rtx byteoffset, addr, align;
4499
4500 /* Force the address into a register. */
4501 addr = force_reg (Pmode, XEXP (mem, 0));
4502
4503 /* Align it to SImode. */
4504 align = expand_simple_binop (Pmode, AND, addr,
4505 GEN_INT (-GET_MODE_SIZE (SImode)),
4506 NULL_RTX, 1, OPTAB_DIRECT);
4507 /* Generate MEM. */
4508 ac->memsi = gen_rtx_MEM (SImode, align);
4509 MEM_VOLATILE_P (ac->memsi) = MEM_VOLATILE_P (mem);
4510 set_mem_alias_set (ac->memsi, ALIAS_SET_MEMORY_BARRIER);
4511 set_mem_align (ac->memsi, GET_MODE_BITSIZE (SImode));
4512
4513 /* Calculate shiftcount. */
4514 byteoffset = expand_simple_binop (Pmode, AND, addr,
4515 GEN_INT (GET_MODE_SIZE (SImode) - 1),
4516 NULL_RTX, 1, OPTAB_DIRECT);
4517 /* As we already have some offset, evaluate the remaining distance. */
4518 ac->shift = expand_simple_binop (SImode, MINUS, ac->shift, byteoffset,
4519 NULL_RTX, 1, OPTAB_DIRECT);
4520
4521 }
4522 /* Shift is the byte count, but we need the bitcount. */
4523 ac->shift = expand_simple_binop (SImode, MULT, ac->shift, GEN_INT (BITS_PER_UNIT),
4524 NULL_RTX, 1, OPTAB_DIRECT);
4525 /* Calculate masks. */
4526 ac->modemask = expand_simple_binop (SImode, ASHIFT,
4527 GEN_INT (GET_MODE_MASK (mode)), ac->shift,
4528 NULL_RTX, 1, OPTAB_DIRECT);
4529 ac->modemaski = expand_simple_unop (SImode, NOT, ac->modemask, NULL_RTX, 1);
4530 }
4531
4532 /* Expand an atomic compare and swap operation for HImode and QImode. MEM is
4533 the memory location, CMP the old value to compare MEM with and NEW the value
4534 to set if CMP == MEM.
4535 CMP is never in memory for compare_and_swap_cc because
4536 expand_bool_compare_and_swap puts it into a register for later compare. */
4537
4538 void
4539 s390_expand_cs_hqi (enum machine_mode mode, rtx target, rtx mem, rtx cmp, rtx new)
4540 {
4541 struct alignment_context ac;
4542 rtx cmpv, newv, val, resv, cc;
4543 rtx res = gen_reg_rtx (SImode);
4544 rtx csloop = gen_label_rtx ();
4545 rtx csend = gen_label_rtx ();
4546
4547 gcc_assert (register_operand (target, VOIDmode));
4548 gcc_assert (MEM_P (mem));
4549
4550 init_alignment_context (&ac, mem, mode);
4551
4552 /* Shift the values to the correct bit positions. */
4553 if (!(ac.aligned && MEM_P (cmp)))
4554 cmp = s390_expand_mask_and_shift (cmp, mode, ac.shift);
4555 if (!(ac.aligned && MEM_P (new)))
4556 new = s390_expand_mask_and_shift (new, mode, ac.shift);
4557
4558 /* Load full word. Subsequent loads are performed by CS. */
4559 val = expand_simple_binop (SImode, AND, ac.memsi, ac.modemaski,
4560 NULL_RTX, 1, OPTAB_DIRECT);
4561
4562 /* Start CS loop. */
4563 emit_label (csloop);
4564 /* val = "<mem>00..0<mem>"
4565 * cmp = "00..0<cmp>00..0"
4566 * new = "00..0<new>00..0"
4567 */
4568
4569 /* Patch cmp and new with val at correct position. */
4570 if (ac.aligned && MEM_P (cmp))
4571 {
4572 cmpv = force_reg (SImode, val);
4573 store_bit_field (cmpv, GET_MODE_BITSIZE (mode), 0, SImode, cmp);
4574 }
4575 else
4576 cmpv = force_reg (SImode, expand_simple_binop (SImode, IOR, cmp, val,
4577 NULL_RTX, 1, OPTAB_DIRECT));
4578 if (ac.aligned && MEM_P (new))
4579 {
4580 newv = force_reg (SImode, val);
4581 store_bit_field (newv, GET_MODE_BITSIZE (mode), 0, SImode, new);
4582 }
4583 else
4584 newv = force_reg (SImode, expand_simple_binop (SImode, IOR, new, val,
4585 NULL_RTX, 1, OPTAB_DIRECT));
4586
4587 /* Jump to end if we're done (likely?). */
4588 s390_emit_jump (csend, s390_emit_compare_and_swap (EQ, res, ac.memsi,
4589 cmpv, newv));
4590
4591 /* Check for changes outside mode. */
4592 resv = expand_simple_binop (SImode, AND, res, ac.modemaski,
4593 NULL_RTX, 1, OPTAB_DIRECT);
4594 cc = s390_emit_compare (NE, resv, val);
4595 emit_move_insn (val, resv);
4596 /* Loop internal if so. */
4597 s390_emit_jump (csloop, cc);
4598
4599 emit_label (csend);
4600
4601 /* Return the correct part of the bitfield. */
4602 convert_move (target, expand_simple_binop (SImode, LSHIFTRT, res, ac.shift,
4603 NULL_RTX, 1, OPTAB_DIRECT), 1);
4604 }
4605
4606 /* Expand an atomic operation CODE of mode MODE. MEM is the memory location
4607 and VAL the value to play with. If AFTER is true then store the value
4608 MEM holds after the operation, if AFTER is false then store the value MEM
4609 holds before the operation. If TARGET is zero then discard that value, else
4610 store it to TARGET. */
4611
4612 void
4613 s390_expand_atomic (enum machine_mode mode, enum rtx_code code,
4614 rtx target, rtx mem, rtx val, bool after)
4615 {
4616 struct alignment_context ac;
4617 rtx cmp;
4618 rtx new = gen_reg_rtx (SImode);
4619 rtx orig = gen_reg_rtx (SImode);
4620 rtx csloop = gen_label_rtx ();
4621
4622 gcc_assert (!target || register_operand (target, VOIDmode));
4623 gcc_assert (MEM_P (mem));
4624
4625 init_alignment_context (&ac, mem, mode);
4626
4627 /* Shift val to the correct bit positions.
4628 Preserve "icm", but prevent "ex icm". */
4629 if (!(ac.aligned && code == SET && MEM_P (val)))
4630 val = s390_expand_mask_and_shift (val, mode, ac.shift);
4631
4632 /* Further preparation insns. */
4633 if (code == PLUS || code == MINUS)
4634 emit_move_insn (orig, val);
4635 else if (code == MULT || code == AND) /* val = "11..1<val>11..1" */
4636 val = expand_simple_binop (SImode, XOR, val, ac.modemaski,
4637 NULL_RTX, 1, OPTAB_DIRECT);
4638
4639 /* Load full word. Subsequent loads are performed by CS. */
4640 cmp = force_reg (SImode, ac.memsi);
4641
4642 /* Start CS loop. */
4643 emit_label (csloop);
4644 emit_move_insn (new, cmp);
4645
4646 /* Patch new with val at correct position. */
4647 switch (code)
4648 {
4649 case PLUS:
4650 case MINUS:
4651 val = expand_simple_binop (SImode, code, new, orig,
4652 NULL_RTX, 1, OPTAB_DIRECT);
4653 val = expand_simple_binop (SImode, AND, val, ac.modemask,
4654 NULL_RTX, 1, OPTAB_DIRECT);
4655 /* FALLTHRU */
4656 case SET:
4657 if (ac.aligned && MEM_P (val))
4658 store_bit_field (new, GET_MODE_BITSIZE (mode), 0, SImode, val);
4659 else
4660 {
4661 new = expand_simple_binop (SImode, AND, new, ac.modemaski,
4662 NULL_RTX, 1, OPTAB_DIRECT);
4663 new = expand_simple_binop (SImode, IOR, new, val,
4664 NULL_RTX, 1, OPTAB_DIRECT);
4665 }
4666 break;
4667 case AND:
4668 case IOR:
4669 case XOR:
4670 new = expand_simple_binop (SImode, code, new, val,
4671 NULL_RTX, 1, OPTAB_DIRECT);
4672 break;
4673 case MULT: /* NAND */
4674 new = expand_simple_binop (SImode, XOR, new, ac.modemask,
4675 NULL_RTX, 1, OPTAB_DIRECT);
4676 new = expand_simple_binop (SImode, AND, new, val,
4677 NULL_RTX, 1, OPTAB_DIRECT);
4678 break;
4679 default:
4680 gcc_unreachable ();
4681 }
4682
4683 s390_emit_jump (csloop, s390_emit_compare_and_swap (NE, cmp,
4684 ac.memsi, cmp, new));
4685
4686 /* Return the correct part of the bitfield. */
4687 if (target)
4688 convert_move (target, expand_simple_binop (SImode, LSHIFTRT,
4689 after ? new : cmp, ac.shift,
4690 NULL_RTX, 1, OPTAB_DIRECT), 1);
4691 }
4692
4693 /* This is called from dwarf2out.c via TARGET_ASM_OUTPUT_DWARF_DTPREL.
4694 We need to emit DTP-relative relocations. */
4695
4696 static void s390_output_dwarf_dtprel (FILE *, int, rtx) ATTRIBUTE_UNUSED;
4697
4698 static void
4699 s390_output_dwarf_dtprel (FILE *file, int size, rtx x)
4700 {
4701 switch (size)
4702 {
4703 case 4:
4704 fputs ("\t.long\t", file);
4705 break;
4706 case 8:
4707 fputs ("\t.quad\t", file);
4708 break;
4709 default:
4710 gcc_unreachable ();
4711 }
4712 output_addr_const (file, x);
4713 fputs ("@DTPOFF", file);
4714 }
4715
4716 #ifdef TARGET_ALTERNATE_LONG_DOUBLE_MANGLING
4717 /* Implement TARGET_MANGLE_TYPE. */
4718
4719 static const char *
4720 s390_mangle_type (const_tree type)
4721 {
4722 if (TYPE_MAIN_VARIANT (type) == long_double_type_node
4723 && TARGET_LONG_DOUBLE_128)
4724 return "g";
4725
4726 /* For all other types, use normal C++ mangling. */
4727 return NULL;
4728 }
4729 #endif
4730
4731 /* In the name of slightly smaller debug output, and to cater to
4732 general assembler lossage, recognize various UNSPEC sequences
4733 and turn them back into a direct symbol reference. */
4734
4735 static rtx
4736 s390_delegitimize_address (rtx orig_x)
4737 {
4738 rtx x = orig_x, y;
4739
4740 if (GET_CODE (x) != MEM)
4741 return orig_x;
4742
4743 x = XEXP (x, 0);
4744 if (GET_CODE (x) == PLUS
4745 && GET_CODE (XEXP (x, 1)) == CONST
4746 && GET_CODE (XEXP (x, 0)) == REG
4747 && REGNO (XEXP (x, 0)) == PIC_OFFSET_TABLE_REGNUM)
4748 {
4749 y = XEXP (XEXP (x, 1), 0);
4750 if (GET_CODE (y) == UNSPEC
4751 && XINT (y, 1) == UNSPEC_GOT)
4752 return XVECEXP (y, 0, 0);
4753 return orig_x;
4754 }
4755
4756 if (GET_CODE (x) == CONST)
4757 {
4758 y = XEXP (x, 0);
4759 if (GET_CODE (y) == UNSPEC
4760 && XINT (y, 1) == UNSPEC_GOTENT)
4761 return XVECEXP (y, 0, 0);
4762 return orig_x;
4763 }
4764
4765 return orig_x;
4766 }
4767
4768 /* Output operand OP to stdio stream FILE.
4769 OP is an address (register + offset) which is not used to address data;
4770 instead the rightmost bits are interpreted as the value. */
4771
4772 static void
4773 print_shift_count_operand (FILE *file, rtx op)
4774 {
4775 HOST_WIDE_INT offset;
4776 rtx base;
4777
4778 /* Extract base register and offset. */
4779 if (!s390_decompose_shift_count (op, &base, &offset))
4780 gcc_unreachable ();
4781
4782 /* Sanity check. */
4783 if (base)
4784 {
4785 gcc_assert (GET_CODE (base) == REG);
4786 gcc_assert (REGNO (base) < FIRST_PSEUDO_REGISTER);
4787 gcc_assert (REGNO_REG_CLASS (REGNO (base)) == ADDR_REGS);
4788 }
4789
4790 /* Offsets are constricted to twelve bits. */
4791 fprintf (file, HOST_WIDE_INT_PRINT_DEC, offset & ((1 << 12) - 1));
4792 if (base)
4793 fprintf (file, "(%s)", reg_names[REGNO (base)]);
4794 }
4795
4796 /* See 'get_some_local_dynamic_name'. */
4797
4798 static int
4799 get_some_local_dynamic_name_1 (rtx *px, void *data ATTRIBUTE_UNUSED)
4800 {
4801 rtx x = *px;
4802
4803 if (GET_CODE (x) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (x))
4804 {
4805 x = get_pool_constant (x);
4806 return for_each_rtx (&x, get_some_local_dynamic_name_1, 0);
4807 }
4808
4809 if (GET_CODE (x) == SYMBOL_REF
4810 && tls_symbolic_operand (x) == TLS_MODEL_LOCAL_DYNAMIC)
4811 {
4812 cfun->machine->some_ld_name = XSTR (x, 0);
4813 return 1;
4814 }
4815
4816 return 0;
4817 }
4818
4819 /* Locate some local-dynamic symbol still in use by this function
4820 so that we can print its name in local-dynamic base patterns. */
4821
4822 static const char *
4823 get_some_local_dynamic_name (void)
4824 {
4825 rtx insn;
4826
4827 if (cfun->machine->some_ld_name)
4828 return cfun->machine->some_ld_name;
4829
4830 for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
4831 if (INSN_P (insn)
4832 && for_each_rtx (&PATTERN (insn), get_some_local_dynamic_name_1, 0))
4833 return cfun->machine->some_ld_name;
4834
4835 gcc_unreachable ();
4836 }
4837
4838 /* Output machine-dependent UNSPECs occurring in address constant X
4839 in assembler syntax to stdio stream FILE. Returns true if the
4840 constant X could be recognized, false otherwise. */
4841
4842 bool
4843 s390_output_addr_const_extra (FILE *file, rtx x)
4844 {
4845 if (GET_CODE (x) == UNSPEC && XVECLEN (x, 0) == 1)
4846 switch (XINT (x, 1))
4847 {
4848 case UNSPEC_GOTENT:
4849 output_addr_const (file, XVECEXP (x, 0, 0));
4850 fprintf (file, "@GOTENT");
4851 return true;
4852 case UNSPEC_GOT:
4853 output_addr_const (file, XVECEXP (x, 0, 0));
4854 fprintf (file, "@GOT");
4855 return true;
4856 case UNSPEC_GOTOFF:
4857 output_addr_const (file, XVECEXP (x, 0, 0));
4858 fprintf (file, "@GOTOFF");
4859 return true;
4860 case UNSPEC_PLT:
4861 output_addr_const (file, XVECEXP (x, 0, 0));
4862 fprintf (file, "@PLT");
4863 return true;
4864 case UNSPEC_PLTOFF:
4865 output_addr_const (file, XVECEXP (x, 0, 0));
4866 fprintf (file, "@PLTOFF");
4867 return true;
4868 case UNSPEC_TLSGD:
4869 output_addr_const (file, XVECEXP (x, 0, 0));
4870 fprintf (file, "@TLSGD");
4871 return true;
4872 case UNSPEC_TLSLDM:
4873 assemble_name (file, get_some_local_dynamic_name ());
4874 fprintf (file, "@TLSLDM");
4875 return true;
4876 case UNSPEC_DTPOFF:
4877 output_addr_const (file, XVECEXP (x, 0, 0));
4878 fprintf (file, "@DTPOFF");
4879 return true;
4880 case UNSPEC_NTPOFF:
4881 output_addr_const (file, XVECEXP (x, 0, 0));
4882 fprintf (file, "@NTPOFF");
4883 return true;
4884 case UNSPEC_GOTNTPOFF:
4885 output_addr_const (file, XVECEXP (x, 0, 0));
4886 fprintf (file, "@GOTNTPOFF");
4887 return true;
4888 case UNSPEC_INDNTPOFF:
4889 output_addr_const (file, XVECEXP (x, 0, 0));
4890 fprintf (file, "@INDNTPOFF");
4891 return true;
4892 }
4893
4894 return false;
4895 }
4896
4897 /* Output address operand ADDR in assembler syntax to
4898 stdio stream FILE. */
4899
4900 void
4901 print_operand_address (FILE *file, rtx addr)
4902 {
4903 struct s390_address ad;
4904
4905 if (s390_symref_operand_p (addr, NULL, NULL))
4906 {
4907 gcc_assert (TARGET_Z10);
4908 output_addr_const (file, addr);
4909 return;
4910 }
4911
4912 if (!s390_decompose_address (addr, &ad)
4913 || (ad.base && !REGNO_OK_FOR_BASE_P (REGNO (ad.base)))
4914 || (ad.indx && !REGNO_OK_FOR_INDEX_P (REGNO (ad.indx))))
4915 output_operand_lossage ("cannot decompose address");
4916
4917 if (ad.disp)
4918 output_addr_const (file, ad.disp);
4919 else
4920 fprintf (file, "0");
4921
4922 if (ad.base && ad.indx)
4923 fprintf (file, "(%s,%s)", reg_names[REGNO (ad.indx)],
4924 reg_names[REGNO (ad.base)]);
4925 else if (ad.base)
4926 fprintf (file, "(%s)", reg_names[REGNO (ad.base)]);
4927 }
4928
4929 /* Output operand X in assembler syntax to stdio stream FILE.
4930 CODE specified the format flag. The following format flags
4931 are recognized:
4932
4933 'C': print opcode suffix for branch condition.
4934 'D': print opcode suffix for inverse branch condition.
4935 'J': print tls_load/tls_gdcall/tls_ldcall suffix
4936 'G': print the size of the operand in bytes.
4937 'O': print only the displacement of a memory reference.
4938 'R': print only the base register of a memory reference.
4939 'S': print S-type memory reference (base+displacement).
4940 'N': print the second word of a DImode operand.
4941 'M': print the second word of a TImode operand.
4942 'Y': print shift count operand.
4943
4944 'b': print integer X as if it's an unsigned byte.
4945 'c': print integer X as if it's an signed byte.
4946 'x': print integer X as if it's an unsigned halfword.
4947 'h': print integer X as if it's a signed halfword.
4948 'i': print the first nonzero HImode part of X.
4949 'j': print the first HImode part unequal to -1 of X.
4950 'k': print the first nonzero SImode part of X.
4951 'm': print the first SImode part unequal to -1 of X.
4952 'o': print integer X as if it's an unsigned 32bit word. */
4953
4954 void
4955 print_operand (FILE *file, rtx x, int code)
4956 {
4957 switch (code)
4958 {
4959 case 'C':
4960 fprintf (file, s390_branch_condition_mnemonic (x, FALSE));
4961 return;
4962
4963 case 'D':
4964 fprintf (file, s390_branch_condition_mnemonic (x, TRUE));
4965 return;
4966
4967 case 'J':
4968 if (GET_CODE (x) == SYMBOL_REF)
4969 {
4970 fprintf (file, "%s", ":tls_load:");
4971 output_addr_const (file, x);
4972 }
4973 else if (GET_CODE (x) == UNSPEC && XINT (x, 1) == UNSPEC_TLSGD)
4974 {
4975 fprintf (file, "%s", ":tls_gdcall:");
4976 output_addr_const (file, XVECEXP (x, 0, 0));
4977 }
4978 else if (GET_CODE (x) == UNSPEC && XINT (x, 1) == UNSPEC_TLSLDM)
4979 {
4980 fprintf (file, "%s", ":tls_ldcall:");
4981 assemble_name (file, get_some_local_dynamic_name ());
4982 }
4983 else
4984 gcc_unreachable ();
4985 return;
4986
4987 case 'G':
4988 fprintf (file, "%u", GET_MODE_SIZE (GET_MODE (x)));
4989 return;
4990
4991 case 'O':
4992 {
4993 struct s390_address ad;
4994 int ret;
4995
4996 gcc_assert (GET_CODE (x) == MEM);
4997 ret = s390_decompose_address (XEXP (x, 0), &ad);
4998 gcc_assert (ret);
4999 gcc_assert (!ad.base || REGNO_OK_FOR_BASE_P (REGNO (ad.base)));
5000 gcc_assert (!ad.indx);
5001
5002 if (ad.disp)
5003 output_addr_const (file, ad.disp);
5004 else
5005 fprintf (file, "0");
5006 }
5007 return;
5008
5009 case 'R':
5010 {
5011 struct s390_address ad;
5012 int ret;
5013
5014 gcc_assert (GET_CODE (x) == MEM);
5015 ret = s390_decompose_address (XEXP (x, 0), &ad);
5016 gcc_assert (ret);
5017 gcc_assert (!ad.base || REGNO_OK_FOR_BASE_P (REGNO (ad.base)));
5018 gcc_assert (!ad.indx);
5019
5020 if (ad.base)
5021 fprintf (file, "%s", reg_names[REGNO (ad.base)]);
5022 else
5023 fprintf (file, "0");
5024 }
5025 return;
5026
5027 case 'S':
5028 {
5029 struct s390_address ad;
5030 int ret;
5031
5032 gcc_assert (GET_CODE (x) == MEM);
5033 ret = s390_decompose_address (XEXP (x, 0), &ad);
5034 gcc_assert (ret);
5035 gcc_assert (!ad.base || REGNO_OK_FOR_BASE_P (REGNO (ad.base)));
5036 gcc_assert (!ad.indx);
5037
5038 if (ad.disp)
5039 output_addr_const (file, ad.disp);
5040 else
5041 fprintf (file, "0");
5042
5043 if (ad.base)
5044 fprintf (file, "(%s)", reg_names[REGNO (ad.base)]);
5045 }
5046 return;
5047
5048 case 'N':
5049 if (GET_CODE (x) == REG)
5050 x = gen_rtx_REG (GET_MODE (x), REGNO (x) + 1);
5051 else if (GET_CODE (x) == MEM)
5052 x = change_address (x, VOIDmode, plus_constant (XEXP (x, 0), 4));
5053 else
5054 gcc_unreachable ();
5055 break;
5056
5057 case 'M':
5058 if (GET_CODE (x) == REG)
5059 x = gen_rtx_REG (GET_MODE (x), REGNO (x) + 1);
5060 else if (GET_CODE (x) == MEM)
5061 x = change_address (x, VOIDmode, plus_constant (XEXP (x, 0), 8));
5062 else
5063 gcc_unreachable ();
5064 break;
5065
5066 case 'Y':
5067 print_shift_count_operand (file, x);
5068 return;
5069 }
5070
5071 switch (GET_CODE (x))
5072 {
5073 case REG:
5074 fprintf (file, "%s", reg_names[REGNO (x)]);
5075 break;
5076
5077 case MEM:
5078 output_address (XEXP (x, 0));
5079 break;
5080
5081 case CONST:
5082 case CODE_LABEL:
5083 case LABEL_REF:
5084 case SYMBOL_REF:
5085 output_addr_const (file, x);
5086 break;
5087
5088 case CONST_INT:
5089 if (code == 'b')
5090 fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x) & 0xff);
5091 else if (code == 'c')
5092 fprintf (file, HOST_WIDE_INT_PRINT_DEC, ((INTVAL (x) & 0xff) ^ 0x80) - 0x80);
5093 else if (code == 'x')
5094 fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x) & 0xffff);
5095 else if (code == 'h')
5096 fprintf (file, HOST_WIDE_INT_PRINT_DEC, ((INTVAL (x) & 0xffff) ^ 0x8000) - 0x8000);
5097 else if (code == 'i')
5098 fprintf (file, HOST_WIDE_INT_PRINT_DEC,
5099 s390_extract_part (x, HImode, 0));
5100 else if (code == 'j')
5101 fprintf (file, HOST_WIDE_INT_PRINT_DEC,
5102 s390_extract_part (x, HImode, -1));
5103 else if (code == 'k')
5104 fprintf (file, HOST_WIDE_INT_PRINT_DEC,
5105 s390_extract_part (x, SImode, 0));
5106 else if (code == 'm')
5107 fprintf (file, HOST_WIDE_INT_PRINT_DEC,
5108 s390_extract_part (x, SImode, -1));
5109 else if (code == 'o')
5110 fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x) & 0xffffffff);
5111 else
5112 fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
5113 break;
5114
5115 case CONST_DOUBLE:
5116 gcc_assert (GET_MODE (x) == VOIDmode);
5117 if (code == 'b')
5118 fprintf (file, HOST_WIDE_INT_PRINT_DEC, CONST_DOUBLE_LOW (x) & 0xff);
5119 else if (code == 'x')
5120 fprintf (file, HOST_WIDE_INT_PRINT_DEC, CONST_DOUBLE_LOW (x) & 0xffff);
5121 else if (code == 'h')
5122 fprintf (file, HOST_WIDE_INT_PRINT_DEC, ((CONST_DOUBLE_LOW (x) & 0xffff) ^ 0x8000) - 0x8000);
5123 else
5124 gcc_unreachable ();
5125 break;
5126
5127 default:
5128 fatal_insn ("UNKNOWN in print_operand !?", x);
5129 break;
5130 }
5131 }
5132
5133 /* Target hook for assembling integer objects. We need to define it
5134 here to work a round a bug in some versions of GAS, which couldn't
5135 handle values smaller than INT_MIN when printed in decimal. */
5136
5137 static bool
5138 s390_assemble_integer (rtx x, unsigned int size, int aligned_p)
5139 {
5140 if (size == 8 && aligned_p
5141 && GET_CODE (x) == CONST_INT && INTVAL (x) < INT_MIN)
5142 {
5143 fprintf (asm_out_file, "\t.quad\t" HOST_WIDE_INT_PRINT_HEX "\n",
5144 INTVAL (x));
5145 return true;
5146 }
5147 return default_assemble_integer (x, size, aligned_p);
5148 }
5149
5150 /* Returns true if register REGNO is used for forming
5151 a memory address in expression X. */
5152
5153 static bool
5154 reg_used_in_mem_p (int regno, rtx x)
5155 {
5156 enum rtx_code code = GET_CODE (x);
5157 int i, j;
5158 const char *fmt;
5159
5160 if (code == MEM)
5161 {
5162 if (refers_to_regno_p (regno, regno+1,
5163 XEXP (x, 0), 0))
5164 return true;
5165 }
5166 else if (code == SET
5167 && GET_CODE (SET_DEST (x)) == PC)
5168 {
5169 if (refers_to_regno_p (regno, regno+1,
5170 SET_SRC (x), 0))
5171 return true;
5172 }
5173
5174 fmt = GET_RTX_FORMAT (code);
5175 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
5176 {
5177 if (fmt[i] == 'e'
5178 && reg_used_in_mem_p (regno, XEXP (x, i)))
5179 return true;
5180
5181 else if (fmt[i] == 'E')
5182 for (j = 0; j < XVECLEN (x, i); j++)
5183 if (reg_used_in_mem_p (regno, XVECEXP (x, i, j)))
5184 return true;
5185 }
5186 return false;
5187 }
5188
5189 /* Returns true if expression DEP_RTX sets an address register
5190 used by instruction INSN to address memory. */
5191
5192 static bool
5193 addr_generation_dependency_p (rtx dep_rtx, rtx insn)
5194 {
5195 rtx target, pat;
5196
5197 if (GET_CODE (dep_rtx) == INSN)
5198 dep_rtx = PATTERN (dep_rtx);
5199
5200 if (GET_CODE (dep_rtx) == SET)
5201 {
5202 target = SET_DEST (dep_rtx);
5203 if (GET_CODE (target) == STRICT_LOW_PART)
5204 target = XEXP (target, 0);
5205 while (GET_CODE (target) == SUBREG)
5206 target = SUBREG_REG (target);
5207
5208 if (GET_CODE (target) == REG)
5209 {
5210 int regno = REGNO (target);
5211
5212 if (s390_safe_attr_type (insn) == TYPE_LA)
5213 {
5214 pat = PATTERN (insn);
5215 if (GET_CODE (pat) == PARALLEL)
5216 {
5217 gcc_assert (XVECLEN (pat, 0) == 2);
5218 pat = XVECEXP (pat, 0, 0);
5219 }
5220 gcc_assert (GET_CODE (pat) == SET);
5221 return refers_to_regno_p (regno, regno+1, SET_SRC (pat), 0);
5222 }
5223 else if (get_attr_atype (insn) == ATYPE_AGEN)
5224 return reg_used_in_mem_p (regno, PATTERN (insn));
5225 }
5226 }
5227 return false;
5228 }
5229
5230 /* Return 1, if dep_insn sets register used in insn in the agen unit. */
5231
5232 int
5233 s390_agen_dep_p (rtx dep_insn, rtx insn)
5234 {
5235 rtx dep_rtx = PATTERN (dep_insn);
5236 int i;
5237
5238 if (GET_CODE (dep_rtx) == SET
5239 && addr_generation_dependency_p (dep_rtx, insn))
5240 return 1;
5241 else if (GET_CODE (dep_rtx) == PARALLEL)
5242 {
5243 for (i = 0; i < XVECLEN (dep_rtx, 0); i++)
5244 {
5245 if (addr_generation_dependency_p (XVECEXP (dep_rtx, 0, i), insn))
5246 return 1;
5247 }
5248 }
5249 return 0;
5250 }
5251
5252 /* A C statement (sans semicolon) to update the integer scheduling priority
5253 INSN_PRIORITY (INSN). Increase the priority to execute the INSN earlier,
5254 reduce the priority to execute INSN later. Do not define this macro if
5255 you do not need to adjust the scheduling priorities of insns.
5256
5257 A STD instruction should be scheduled earlier,
5258 in order to use the bypass. */
5259
5260 static int
5261 s390_adjust_priority (rtx insn ATTRIBUTE_UNUSED, int priority)
5262 {
5263 if (! INSN_P (insn))
5264 return priority;
5265
5266 if (s390_tune != PROCESSOR_2084_Z990
5267 && s390_tune != PROCESSOR_2094_Z9_109)
5268 return priority;
5269
5270 switch (s390_safe_attr_type (insn))
5271 {
5272 case TYPE_FSTOREDF:
5273 case TYPE_FSTORESF:
5274 priority = priority << 3;
5275 break;
5276 case TYPE_STORE:
5277 case TYPE_STM:
5278 priority = priority << 1;
5279 break;
5280 default:
5281 break;
5282 }
5283 return priority;
5284 }
5285
5286 /* The number of instructions that can be issued per cycle. */
5287
5288 static int
5289 s390_issue_rate (void)
5290 {
5291 switch (s390_tune)
5292 {
5293 case PROCESSOR_2084_Z990:
5294 case PROCESSOR_2094_Z9_109:
5295 return 3;
5296 case PROCESSOR_2097_Z10:
5297 return 2;
5298 default:
5299 return 1;
5300 }
5301 }
5302
5303 static int
5304 s390_first_cycle_multipass_dfa_lookahead (void)
5305 {
5306 return 4;
5307 }
5308
5309
5310 /* Annotate every literal pool reference in X by an UNSPEC_LTREF expression.
5311 Fix up MEMs as required. */
5312
5313 static void
5314 annotate_constant_pool_refs (rtx *x)
5315 {
5316 int i, j;
5317 const char *fmt;
5318
5319 gcc_assert (GET_CODE (*x) != SYMBOL_REF
5320 || !CONSTANT_POOL_ADDRESS_P (*x));
5321
5322 /* Literal pool references can only occur inside a MEM ... */
5323 if (GET_CODE (*x) == MEM)
5324 {
5325 rtx memref = XEXP (*x, 0);
5326
5327 if (GET_CODE (memref) == SYMBOL_REF
5328 && CONSTANT_POOL_ADDRESS_P (memref))
5329 {
5330 rtx base = cfun->machine->base_reg;
5331 rtx addr = gen_rtx_UNSPEC (Pmode, gen_rtvec (2, memref, base),
5332 UNSPEC_LTREF);
5333
5334 *x = replace_equiv_address (*x, addr);
5335 return;
5336 }
5337
5338 if (GET_CODE (memref) == CONST
5339 && GET_CODE (XEXP (memref, 0)) == PLUS
5340 && GET_CODE (XEXP (XEXP (memref, 0), 1)) == CONST_INT
5341 && GET_CODE (XEXP (XEXP (memref, 0), 0)) == SYMBOL_REF
5342 && CONSTANT_POOL_ADDRESS_P (XEXP (XEXP (memref, 0), 0)))
5343 {
5344 HOST_WIDE_INT off = INTVAL (XEXP (XEXP (memref, 0), 1));
5345 rtx sym = XEXP (XEXP (memref, 0), 0);
5346 rtx base = cfun->machine->base_reg;
5347 rtx addr = gen_rtx_UNSPEC (Pmode, gen_rtvec (2, sym, base),
5348 UNSPEC_LTREF);
5349
5350 *x = replace_equiv_address (*x, plus_constant (addr, off));
5351 return;
5352 }
5353 }
5354
5355 /* ... or a load-address type pattern. */
5356 if (GET_CODE (*x) == SET)
5357 {
5358 rtx addrref = SET_SRC (*x);
5359
5360 if (GET_CODE (addrref) == SYMBOL_REF
5361 && CONSTANT_POOL_ADDRESS_P (addrref))
5362 {
5363 rtx base = cfun->machine->base_reg;
5364 rtx addr = gen_rtx_UNSPEC (Pmode, gen_rtvec (2, addrref, base),
5365 UNSPEC_LTREF);
5366
5367 SET_SRC (*x) = addr;
5368 return;
5369 }
5370
5371 if (GET_CODE (addrref) == CONST
5372 && GET_CODE (XEXP (addrref, 0)) == PLUS
5373 && GET_CODE (XEXP (XEXP (addrref, 0), 1)) == CONST_INT
5374 && GET_CODE (XEXP (XEXP (addrref, 0), 0)) == SYMBOL_REF
5375 && CONSTANT_POOL_ADDRESS_P (XEXP (XEXP (addrref, 0), 0)))
5376 {
5377 HOST_WIDE_INT off = INTVAL (XEXP (XEXP (addrref, 0), 1));
5378 rtx sym = XEXP (XEXP (addrref, 0), 0);
5379 rtx base = cfun->machine->base_reg;
5380 rtx addr = gen_rtx_UNSPEC (Pmode, gen_rtvec (2, sym, base),
5381 UNSPEC_LTREF);
5382
5383 SET_SRC (*x) = plus_constant (addr, off);
5384 return;
5385 }
5386 }
5387
5388 /* Annotate LTREL_BASE as well. */
5389 if (GET_CODE (*x) == UNSPEC
5390 && XINT (*x, 1) == UNSPEC_LTREL_BASE)
5391 {
5392 rtx base = cfun->machine->base_reg;
5393 *x = gen_rtx_UNSPEC (Pmode, gen_rtvec (2, XVECEXP (*x, 0, 0), base),
5394 UNSPEC_LTREL_BASE);
5395 return;
5396 }
5397
5398 fmt = GET_RTX_FORMAT (GET_CODE (*x));
5399 for (i = GET_RTX_LENGTH (GET_CODE (*x)) - 1; i >= 0; i--)
5400 {
5401 if (fmt[i] == 'e')
5402 {
5403 annotate_constant_pool_refs (&XEXP (*x, i));
5404 }
5405 else if (fmt[i] == 'E')
5406 {
5407 for (j = 0; j < XVECLEN (*x, i); j++)
5408 annotate_constant_pool_refs (&XVECEXP (*x, i, j));
5409 }
5410 }
5411 }
5412
5413 /* Split all branches that exceed the maximum distance.
5414 Returns true if this created a new literal pool entry. */
5415
5416 static int
5417 s390_split_branches (void)
5418 {
5419 rtx temp_reg = gen_rtx_REG (Pmode, RETURN_REGNUM);
5420 int new_literal = 0, ret;
5421 rtx insn, pat, tmp, target;
5422 rtx *label;
5423
5424 /* We need correct insn addresses. */
5425
5426 shorten_branches (get_insns ());
5427
5428 /* Find all branches that exceed 64KB, and split them. */
5429
5430 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
5431 {
5432 if (GET_CODE (insn) != JUMP_INSN)
5433 continue;
5434
5435 pat = PATTERN (insn);
5436 if (GET_CODE (pat) == PARALLEL && XVECLEN (pat, 0) > 2)
5437 pat = XVECEXP (pat, 0, 0);
5438 if (GET_CODE (pat) != SET || SET_DEST (pat) != pc_rtx)
5439 continue;
5440
5441 if (GET_CODE (SET_SRC (pat)) == LABEL_REF)
5442 {
5443 label = &SET_SRC (pat);
5444 }
5445 else if (GET_CODE (SET_SRC (pat)) == IF_THEN_ELSE)
5446 {
5447 if (GET_CODE (XEXP (SET_SRC (pat), 1)) == LABEL_REF)
5448 label = &XEXP (SET_SRC (pat), 1);
5449 else if (GET_CODE (XEXP (SET_SRC (pat), 2)) == LABEL_REF)
5450 label = &XEXP (SET_SRC (pat), 2);
5451 else
5452 continue;
5453 }
5454 else
5455 continue;
5456
5457 if (get_attr_length (insn) <= 4)
5458 continue;
5459
5460 /* We are going to use the return register as scratch register,
5461 make sure it will be saved/restored by the prologue/epilogue. */
5462 cfun_frame_layout.save_return_addr_p = 1;
5463
5464 if (!flag_pic)
5465 {
5466 new_literal = 1;
5467 tmp = force_const_mem (Pmode, *label);
5468 tmp = emit_insn_before (gen_rtx_SET (Pmode, temp_reg, tmp), insn);
5469 INSN_ADDRESSES_NEW (tmp, -1);
5470 annotate_constant_pool_refs (&PATTERN (tmp));
5471
5472 target = temp_reg;
5473 }
5474 else
5475 {
5476 new_literal = 1;
5477 target = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, *label),
5478 UNSPEC_LTREL_OFFSET);
5479 target = gen_rtx_CONST (Pmode, target);
5480 target = force_const_mem (Pmode, target);
5481 tmp = emit_insn_before (gen_rtx_SET (Pmode, temp_reg, target), insn);
5482 INSN_ADDRESSES_NEW (tmp, -1);
5483 annotate_constant_pool_refs (&PATTERN (tmp));
5484
5485 target = gen_rtx_UNSPEC (Pmode, gen_rtvec (2, XEXP (target, 0),
5486 cfun->machine->base_reg),
5487 UNSPEC_LTREL_BASE);
5488 target = gen_rtx_PLUS (Pmode, temp_reg, target);
5489 }
5490
5491 ret = validate_change (insn, label, target, 0);
5492 gcc_assert (ret);
5493 }
5494
5495 return new_literal;
5496 }
5497
5498
5499 /* Find an annotated literal pool symbol referenced in RTX X,
5500 and store it at REF. Will abort if X contains references to
5501 more than one such pool symbol; multiple references to the same
5502 symbol are allowed, however.
5503
5504 The rtx pointed to by REF must be initialized to NULL_RTX
5505 by the caller before calling this routine. */
5506
5507 static void
5508 find_constant_pool_ref (rtx x, rtx *ref)
5509 {
5510 int i, j;
5511 const char *fmt;
5512
5513 /* Ignore LTREL_BASE references. */
5514 if (GET_CODE (x) == UNSPEC
5515 && XINT (x, 1) == UNSPEC_LTREL_BASE)
5516 return;
5517 /* Likewise POOL_ENTRY insns. */
5518 if (GET_CODE (x) == UNSPEC_VOLATILE
5519 && XINT (x, 1) == UNSPECV_POOL_ENTRY)
5520 return;
5521
5522 gcc_assert (GET_CODE (x) != SYMBOL_REF
5523 || !CONSTANT_POOL_ADDRESS_P (x));
5524
5525 if (GET_CODE (x) == UNSPEC && XINT (x, 1) == UNSPEC_LTREF)
5526 {
5527 rtx sym = XVECEXP (x, 0, 0);
5528 gcc_assert (GET_CODE (sym) == SYMBOL_REF
5529 && CONSTANT_POOL_ADDRESS_P (sym));
5530
5531 if (*ref == NULL_RTX)
5532 *ref = sym;
5533 else
5534 gcc_assert (*ref == sym);
5535
5536 return;
5537 }
5538
5539 fmt = GET_RTX_FORMAT (GET_CODE (x));
5540 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
5541 {
5542 if (fmt[i] == 'e')
5543 {
5544 find_constant_pool_ref (XEXP (x, i), ref);
5545 }
5546 else if (fmt[i] == 'E')
5547 {
5548 for (j = 0; j < XVECLEN (x, i); j++)
5549 find_constant_pool_ref (XVECEXP (x, i, j), ref);
5550 }
5551 }
5552 }
5553
5554 /* Replace every reference to the annotated literal pool
5555 symbol REF in X by its base plus OFFSET. */
5556
5557 static void
5558 replace_constant_pool_ref (rtx *x, rtx ref, rtx offset)
5559 {
5560 int i, j;
5561 const char *fmt;
5562
5563 gcc_assert (*x != ref);
5564
5565 if (GET_CODE (*x) == UNSPEC
5566 && XINT (*x, 1) == UNSPEC_LTREF
5567 && XVECEXP (*x, 0, 0) == ref)
5568 {
5569 *x = gen_rtx_PLUS (Pmode, XVECEXP (*x, 0, 1), offset);
5570 return;
5571 }
5572
5573 if (GET_CODE (*x) == PLUS
5574 && GET_CODE (XEXP (*x, 1)) == CONST_INT
5575 && GET_CODE (XEXP (*x, 0)) == UNSPEC
5576 && XINT (XEXP (*x, 0), 1) == UNSPEC_LTREF
5577 && XVECEXP (XEXP (*x, 0), 0, 0) == ref)
5578 {
5579 rtx addr = gen_rtx_PLUS (Pmode, XVECEXP (XEXP (*x, 0), 0, 1), offset);
5580 *x = plus_constant (addr, INTVAL (XEXP (*x, 1)));
5581 return;
5582 }
5583
5584 fmt = GET_RTX_FORMAT (GET_CODE (*x));
5585 for (i = GET_RTX_LENGTH (GET_CODE (*x)) - 1; i >= 0; i--)
5586 {
5587 if (fmt[i] == 'e')
5588 {
5589 replace_constant_pool_ref (&XEXP (*x, i), ref, offset);
5590 }
5591 else if (fmt[i] == 'E')
5592 {
5593 for (j = 0; j < XVECLEN (*x, i); j++)
5594 replace_constant_pool_ref (&XVECEXP (*x, i, j), ref, offset);
5595 }
5596 }
5597 }
5598
5599 /* Check whether X contains an UNSPEC_LTREL_BASE.
5600 Return its constant pool symbol if found, NULL_RTX otherwise. */
5601
5602 static rtx
5603 find_ltrel_base (rtx x)
5604 {
5605 int i, j;
5606 const char *fmt;
5607
5608 if (GET_CODE (x) == UNSPEC
5609 && XINT (x, 1) == UNSPEC_LTREL_BASE)
5610 return XVECEXP (x, 0, 0);
5611
5612 fmt = GET_RTX_FORMAT (GET_CODE (x));
5613 for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
5614 {
5615 if (fmt[i] == 'e')
5616 {
5617 rtx fnd = find_ltrel_base (XEXP (x, i));
5618 if (fnd)
5619 return fnd;
5620 }
5621 else if (fmt[i] == 'E')
5622 {
5623 for (j = 0; j < XVECLEN (x, i); j++)
5624 {
5625 rtx fnd = find_ltrel_base (XVECEXP (x, i, j));
5626 if (fnd)
5627 return fnd;
5628 }
5629 }
5630 }
5631
5632 return NULL_RTX;
5633 }
5634
5635 /* Replace any occurrence of UNSPEC_LTREL_BASE in X with its base. */
5636
5637 static void
5638 replace_ltrel_base (rtx *x)
5639 {
5640 int i, j;
5641 const char *fmt;
5642
5643 if (GET_CODE (*x) == UNSPEC
5644 && XINT (*x, 1) == UNSPEC_LTREL_BASE)
5645 {
5646 *x = XVECEXP (*x, 0, 1);
5647 return;
5648 }
5649
5650 fmt = GET_RTX_FORMAT (GET_CODE (*x));
5651 for (i = GET_RTX_LENGTH (GET_CODE (*x)) - 1; i >= 0; i--)
5652 {
5653 if (fmt[i] == 'e')
5654 {
5655 replace_ltrel_base (&XEXP (*x, i));
5656 }
5657 else if (fmt[i] == 'E')
5658 {
5659 for (j = 0; j < XVECLEN (*x, i); j++)
5660 replace_ltrel_base (&XVECEXP (*x, i, j));
5661 }
5662 }
5663 }
5664
5665
5666 /* We keep a list of constants which we have to add to internal
5667 constant tables in the middle of large functions. */
5668
5669 #define NR_C_MODES 11
5670 enum machine_mode constant_modes[NR_C_MODES] =
5671 {
5672 TFmode, TImode, TDmode,
5673 DFmode, DImode, DDmode,
5674 SFmode, SImode, SDmode,
5675 HImode,
5676 QImode
5677 };
5678
5679 struct constant
5680 {
5681 struct constant *next;
5682 rtx value;
5683 rtx label;
5684 };
5685
5686 struct constant_pool
5687 {
5688 struct constant_pool *next;
5689 rtx first_insn;
5690 rtx pool_insn;
5691 bitmap insns;
5692 rtx emit_pool_after;
5693
5694 struct constant *constants[NR_C_MODES];
5695 struct constant *execute;
5696 rtx label;
5697 int size;
5698 };
5699
5700 /* Allocate new constant_pool structure. */
5701
5702 static struct constant_pool *
5703 s390_alloc_pool (void)
5704 {
5705 struct constant_pool *pool;
5706 int i;
5707
5708 pool = (struct constant_pool *) xmalloc (sizeof *pool);
5709 pool->next = NULL;
5710 for (i = 0; i < NR_C_MODES; i++)
5711 pool->constants[i] = NULL;
5712
5713 pool->execute = NULL;
5714 pool->label = gen_label_rtx ();
5715 pool->first_insn = NULL_RTX;
5716 pool->pool_insn = NULL_RTX;
5717 pool->insns = BITMAP_ALLOC (NULL);
5718 pool->size = 0;
5719 pool->emit_pool_after = NULL_RTX;
5720
5721 return pool;
5722 }
5723
5724 /* Create new constant pool covering instructions starting at INSN
5725 and chain it to the end of POOL_LIST. */
5726
5727 static struct constant_pool *
5728 s390_start_pool (struct constant_pool **pool_list, rtx insn)
5729 {
5730 struct constant_pool *pool, **prev;
5731
5732 pool = s390_alloc_pool ();
5733 pool->first_insn = insn;
5734
5735 for (prev = pool_list; *prev; prev = &(*prev)->next)
5736 ;
5737 *prev = pool;
5738
5739 return pool;
5740 }
5741
5742 /* End range of instructions covered by POOL at INSN and emit
5743 placeholder insn representing the pool. */
5744
5745 static void
5746 s390_end_pool (struct constant_pool *pool, rtx insn)
5747 {
5748 rtx pool_size = GEN_INT (pool->size + 8 /* alignment slop */);
5749
5750 if (!insn)
5751 insn = get_last_insn ();
5752
5753 pool->pool_insn = emit_insn_after (gen_pool (pool_size), insn);
5754 INSN_ADDRESSES_NEW (pool->pool_insn, -1);
5755 }
5756
5757 /* Add INSN to the list of insns covered by POOL. */
5758
5759 static void
5760 s390_add_pool_insn (struct constant_pool *pool, rtx insn)
5761 {
5762 bitmap_set_bit (pool->insns, INSN_UID (insn));
5763 }
5764
5765 /* Return pool out of POOL_LIST that covers INSN. */
5766
5767 static struct constant_pool *
5768 s390_find_pool (struct constant_pool *pool_list, rtx insn)
5769 {
5770 struct constant_pool *pool;
5771
5772 for (pool = pool_list; pool; pool = pool->next)
5773 if (bitmap_bit_p (pool->insns, INSN_UID (insn)))
5774 break;
5775
5776 return pool;
5777 }
5778
5779 /* Add constant VAL of mode MODE to the constant pool POOL. */
5780
5781 static void
5782 s390_add_constant (struct constant_pool *pool, rtx val, enum machine_mode mode)
5783 {
5784 struct constant *c;
5785 int i;
5786
5787 for (i = 0; i < NR_C_MODES; i++)
5788 if (constant_modes[i] == mode)
5789 break;
5790 gcc_assert (i != NR_C_MODES);
5791
5792 for (c = pool->constants[i]; c != NULL; c = c->next)
5793 if (rtx_equal_p (val, c->value))
5794 break;
5795
5796 if (c == NULL)
5797 {
5798 c = (struct constant *) xmalloc (sizeof *c);
5799 c->value = val;
5800 c->label = gen_label_rtx ();
5801 c->next = pool->constants[i];
5802 pool->constants[i] = c;
5803 pool->size += GET_MODE_SIZE (mode);
5804 }
5805 }
5806
5807 /* Find constant VAL of mode MODE in the constant pool POOL.
5808 Return an RTX describing the distance from the start of
5809 the pool to the location of the new constant. */
5810
5811 static rtx
5812 s390_find_constant (struct constant_pool *pool, rtx val,
5813 enum machine_mode mode)
5814 {
5815 struct constant *c;
5816 rtx offset;
5817 int i;
5818
5819 for (i = 0; i < NR_C_MODES; i++)
5820 if (constant_modes[i] == mode)
5821 break;
5822 gcc_assert (i != NR_C_MODES);
5823
5824 for (c = pool->constants[i]; c != NULL; c = c->next)
5825 if (rtx_equal_p (val, c->value))
5826 break;
5827
5828 gcc_assert (c);
5829
5830 offset = gen_rtx_MINUS (Pmode, gen_rtx_LABEL_REF (Pmode, c->label),
5831 gen_rtx_LABEL_REF (Pmode, pool->label));
5832 offset = gen_rtx_CONST (Pmode, offset);
5833 return offset;
5834 }
5835
5836 /* Check whether INSN is an execute. Return the label_ref to its
5837 execute target template if so, NULL_RTX otherwise. */
5838
5839 static rtx
5840 s390_execute_label (rtx insn)
5841 {
5842 if (GET_CODE (insn) == INSN
5843 && GET_CODE (PATTERN (insn)) == PARALLEL
5844 && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == UNSPEC
5845 && XINT (XVECEXP (PATTERN (insn), 0, 0), 1) == UNSPEC_EXECUTE)
5846 return XVECEXP (XVECEXP (PATTERN (insn), 0, 0), 0, 2);
5847
5848 return NULL_RTX;
5849 }
5850
5851 /* Add execute target for INSN to the constant pool POOL. */
5852
5853 static void
5854 s390_add_execute (struct constant_pool *pool, rtx insn)
5855 {
5856 struct constant *c;
5857
5858 for (c = pool->execute; c != NULL; c = c->next)
5859 if (INSN_UID (insn) == INSN_UID (c->value))
5860 break;
5861
5862 if (c == NULL)
5863 {
5864 c = (struct constant *) xmalloc (sizeof *c);
5865 c->value = insn;
5866 c->label = gen_label_rtx ();
5867 c->next = pool->execute;
5868 pool->execute = c;
5869 pool->size += 6;
5870 }
5871 }
5872
5873 /* Find execute target for INSN in the constant pool POOL.
5874 Return an RTX describing the distance from the start of
5875 the pool to the location of the execute target. */
5876
5877 static rtx
5878 s390_find_execute (struct constant_pool *pool, rtx insn)
5879 {
5880 struct constant *c;
5881 rtx offset;
5882
5883 for (c = pool->execute; c != NULL; c = c->next)
5884 if (INSN_UID (insn) == INSN_UID (c->value))
5885 break;
5886
5887 gcc_assert (c);
5888
5889 offset = gen_rtx_MINUS (Pmode, gen_rtx_LABEL_REF (Pmode, c->label),
5890 gen_rtx_LABEL_REF (Pmode, pool->label));
5891 offset = gen_rtx_CONST (Pmode, offset);
5892 return offset;
5893 }
5894
5895 /* For an execute INSN, extract the execute target template. */
5896
5897 static rtx
5898 s390_execute_target (rtx insn)
5899 {
5900 rtx pattern = PATTERN (insn);
5901 gcc_assert (s390_execute_label (insn));
5902
5903 if (XVECLEN (pattern, 0) == 2)
5904 {
5905 pattern = copy_rtx (XVECEXP (pattern, 0, 1));
5906 }
5907 else
5908 {
5909 rtvec vec = rtvec_alloc (XVECLEN (pattern, 0) - 1);
5910 int i;
5911
5912 for (i = 0; i < XVECLEN (pattern, 0) - 1; i++)
5913 RTVEC_ELT (vec, i) = copy_rtx (XVECEXP (pattern, 0, i + 1));
5914
5915 pattern = gen_rtx_PARALLEL (VOIDmode, vec);
5916 }
5917
5918 return pattern;
5919 }
5920
5921 /* Indicate that INSN cannot be duplicated. This is the case for
5922 execute insns that carry a unique label. */
5923
5924 static bool
5925 s390_cannot_copy_insn_p (rtx insn)
5926 {
5927 rtx label = s390_execute_label (insn);
5928 return label && label != const0_rtx;
5929 }
5930
5931 /* Dump out the constants in POOL. If REMOTE_LABEL is true,
5932 do not emit the pool base label. */
5933
5934 static void
5935 s390_dump_pool (struct constant_pool *pool, bool remote_label)
5936 {
5937 struct constant *c;
5938 rtx insn = pool->pool_insn;
5939 int i;
5940
5941 /* Switch to rodata section. */
5942 if (TARGET_CPU_ZARCH)
5943 {
5944 insn = emit_insn_after (gen_pool_section_start (), insn);
5945 INSN_ADDRESSES_NEW (insn, -1);
5946 }
5947
5948 /* Ensure minimum pool alignment. */
5949 if (TARGET_CPU_ZARCH)
5950 insn = emit_insn_after (gen_pool_align (GEN_INT (8)), insn);
5951 else
5952 insn = emit_insn_after (gen_pool_align (GEN_INT (4)), insn);
5953 INSN_ADDRESSES_NEW (insn, -1);
5954
5955 /* Emit pool base label. */
5956 if (!remote_label)
5957 {
5958 insn = emit_label_after (pool->label, insn);
5959 INSN_ADDRESSES_NEW (insn, -1);
5960 }
5961
5962 /* Dump constants in descending alignment requirement order,
5963 ensuring proper alignment for every constant. */
5964 for (i = 0; i < NR_C_MODES; i++)
5965 for (c = pool->constants[i]; c; c = c->next)
5966 {
5967 /* Convert UNSPEC_LTREL_OFFSET unspecs to pool-relative references. */
5968 rtx value = copy_rtx (c->value);
5969 if (GET_CODE (value) == CONST
5970 && GET_CODE (XEXP (value, 0)) == UNSPEC
5971 && XINT (XEXP (value, 0), 1) == UNSPEC_LTREL_OFFSET
5972 && XVECLEN (XEXP (value, 0), 0) == 1)
5973 {
5974 value = gen_rtx_MINUS (Pmode, XVECEXP (XEXP (value, 0), 0, 0),
5975 gen_rtx_LABEL_REF (VOIDmode, pool->label));
5976 value = gen_rtx_CONST (VOIDmode, value);
5977 }
5978
5979 insn = emit_label_after (c->label, insn);
5980 INSN_ADDRESSES_NEW (insn, -1);
5981
5982 value = gen_rtx_UNSPEC_VOLATILE (constant_modes[i],
5983 gen_rtvec (1, value),
5984 UNSPECV_POOL_ENTRY);
5985 insn = emit_insn_after (value, insn);
5986 INSN_ADDRESSES_NEW (insn, -1);
5987 }
5988
5989 /* Ensure minimum alignment for instructions. */
5990 insn = emit_insn_after (gen_pool_align (GEN_INT (2)), insn);
5991 INSN_ADDRESSES_NEW (insn, -1);
5992
5993 /* Output in-pool execute template insns. */
5994 for (c = pool->execute; c; c = c->next)
5995 {
5996 insn = emit_label_after (c->label, insn);
5997 INSN_ADDRESSES_NEW (insn, -1);
5998
5999 insn = emit_insn_after (s390_execute_target (c->value), insn);
6000 INSN_ADDRESSES_NEW (insn, -1);
6001 }
6002
6003 /* Switch back to previous section. */
6004 if (TARGET_CPU_ZARCH)
6005 {
6006 insn = emit_insn_after (gen_pool_section_end (), insn);
6007 INSN_ADDRESSES_NEW (insn, -1);
6008 }
6009
6010 insn = emit_barrier_after (insn);
6011 INSN_ADDRESSES_NEW (insn, -1);
6012
6013 /* Remove placeholder insn. */
6014 remove_insn (pool->pool_insn);
6015 }
6016
6017 /* Free all memory used by POOL. */
6018
6019 static void
6020 s390_free_pool (struct constant_pool *pool)
6021 {
6022 struct constant *c, *next;
6023 int i;
6024
6025 for (i = 0; i < NR_C_MODES; i++)
6026 for (c = pool->constants[i]; c; c = next)
6027 {
6028 next = c->next;
6029 free (c);
6030 }
6031
6032 for (c = pool->execute; c; c = next)
6033 {
6034 next = c->next;
6035 free (c);
6036 }
6037
6038 BITMAP_FREE (pool->insns);
6039 free (pool);
6040 }
6041
6042
6043 /* Collect main literal pool. Return NULL on overflow. */
6044
6045 static struct constant_pool *
6046 s390_mainpool_start (void)
6047 {
6048 struct constant_pool *pool;
6049 rtx insn;
6050
6051 pool = s390_alloc_pool ();
6052
6053 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
6054 {
6055 if (GET_CODE (insn) == INSN
6056 && GET_CODE (PATTERN (insn)) == SET
6057 && GET_CODE (SET_SRC (PATTERN (insn))) == UNSPEC_VOLATILE
6058 && XINT (SET_SRC (PATTERN (insn)), 1) == UNSPECV_MAIN_POOL)
6059 {
6060 gcc_assert (!pool->pool_insn);
6061 pool->pool_insn = insn;
6062 }
6063
6064 if (!TARGET_CPU_ZARCH && s390_execute_label (insn))
6065 {
6066 s390_add_execute (pool, insn);
6067 }
6068 else if (GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN)
6069 {
6070 rtx pool_ref = NULL_RTX;
6071 find_constant_pool_ref (PATTERN (insn), &pool_ref);
6072 if (pool_ref)
6073 {
6074 rtx constant = get_pool_constant (pool_ref);
6075 enum machine_mode mode = get_pool_mode (pool_ref);
6076 s390_add_constant (pool, constant, mode);
6077 }
6078 }
6079
6080 /* If hot/cold partitioning is enabled we have to make sure that
6081 the literal pool is emitted in the same section where the
6082 initialization of the literal pool base pointer takes place.
6083 emit_pool_after is only used in the non-overflow case on non
6084 Z cpus where we can emit the literal pool at the end of the
6085 function body within the text section. */
6086 if (NOTE_P (insn)
6087 && NOTE_KIND (insn) == NOTE_INSN_SWITCH_TEXT_SECTIONS
6088 && !pool->emit_pool_after)
6089 pool->emit_pool_after = PREV_INSN (insn);
6090 }
6091
6092 gcc_assert (pool->pool_insn || pool->size == 0);
6093
6094 if (pool->size >= 4096)
6095 {
6096 /* We're going to chunkify the pool, so remove the main
6097 pool placeholder insn. */
6098 remove_insn (pool->pool_insn);
6099
6100 s390_free_pool (pool);
6101 pool = NULL;
6102 }
6103
6104 /* If the functions ends with the section where the literal pool
6105 should be emitted set the marker to its end. */
6106 if (pool && !pool->emit_pool_after)
6107 pool->emit_pool_after = get_last_insn ();
6108
6109 return pool;
6110 }
6111
6112 /* POOL holds the main literal pool as collected by s390_mainpool_start.
6113 Modify the current function to output the pool constants as well as
6114 the pool register setup instruction. */
6115
6116 static void
6117 s390_mainpool_finish (struct constant_pool *pool)
6118 {
6119 rtx base_reg = cfun->machine->base_reg;
6120 rtx insn;
6121
6122 /* If the pool is empty, we're done. */
6123 if (pool->size == 0)
6124 {
6125 /* We don't actually need a base register after all. */
6126 cfun->machine->base_reg = NULL_RTX;
6127
6128 if (pool->pool_insn)
6129 remove_insn (pool->pool_insn);
6130 s390_free_pool (pool);
6131 return;
6132 }
6133
6134 /* We need correct insn addresses. */
6135 shorten_branches (get_insns ());
6136
6137 /* On zSeries, we use a LARL to load the pool register. The pool is
6138 located in the .rodata section, so we emit it after the function. */
6139 if (TARGET_CPU_ZARCH)
6140 {
6141 insn = gen_main_base_64 (base_reg, pool->label);
6142 insn = emit_insn_after (insn, pool->pool_insn);
6143 INSN_ADDRESSES_NEW (insn, -1);
6144 remove_insn (pool->pool_insn);
6145
6146 insn = get_last_insn ();
6147 pool->pool_insn = emit_insn_after (gen_pool (const0_rtx), insn);
6148 INSN_ADDRESSES_NEW (pool->pool_insn, -1);
6149
6150 s390_dump_pool (pool, 0);
6151 }
6152
6153 /* On S/390, if the total size of the function's code plus literal pool
6154 does not exceed 4096 bytes, we use BASR to set up a function base
6155 pointer, and emit the literal pool at the end of the function. */
6156 else if (INSN_ADDRESSES (INSN_UID (pool->emit_pool_after))
6157 + pool->size + 8 /* alignment slop */ < 4096)
6158 {
6159 insn = gen_main_base_31_small (base_reg, pool->label);
6160 insn = emit_insn_after (insn, pool->pool_insn);
6161 INSN_ADDRESSES_NEW (insn, -1);
6162 remove_insn (pool->pool_insn);
6163
6164 insn = emit_label_after (pool->label, insn);
6165 INSN_ADDRESSES_NEW (insn, -1);
6166
6167 /* emit_pool_after will be set by s390_mainpool_start to the
6168 last insn of the section where the literal pool should be
6169 emitted. */
6170 insn = pool->emit_pool_after;
6171
6172 pool->pool_insn = emit_insn_after (gen_pool (const0_rtx), insn);
6173 INSN_ADDRESSES_NEW (pool->pool_insn, -1);
6174
6175 s390_dump_pool (pool, 1);
6176 }
6177
6178 /* Otherwise, we emit an inline literal pool and use BASR to branch
6179 over it, setting up the pool register at the same time. */
6180 else
6181 {
6182 rtx pool_end = gen_label_rtx ();
6183
6184 insn = gen_main_base_31_large (base_reg, pool->label, pool_end);
6185 insn = emit_insn_after (insn, pool->pool_insn);
6186 INSN_ADDRESSES_NEW (insn, -1);
6187 remove_insn (pool->pool_insn);
6188
6189 insn = emit_label_after (pool->label, insn);
6190 INSN_ADDRESSES_NEW (insn, -1);
6191
6192 pool->pool_insn = emit_insn_after (gen_pool (const0_rtx), insn);
6193 INSN_ADDRESSES_NEW (pool->pool_insn, -1);
6194
6195 insn = emit_label_after (pool_end, pool->pool_insn);
6196 INSN_ADDRESSES_NEW (insn, -1);
6197
6198 s390_dump_pool (pool, 1);
6199 }
6200
6201
6202 /* Replace all literal pool references. */
6203
6204 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
6205 {
6206 if (INSN_P (insn))
6207 replace_ltrel_base (&PATTERN (insn));
6208
6209 if (GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN)
6210 {
6211 rtx addr, pool_ref = NULL_RTX;
6212 find_constant_pool_ref (PATTERN (insn), &pool_ref);
6213 if (pool_ref)
6214 {
6215 if (s390_execute_label (insn))
6216 addr = s390_find_execute (pool, insn);
6217 else
6218 addr = s390_find_constant (pool, get_pool_constant (pool_ref),
6219 get_pool_mode (pool_ref));
6220
6221 replace_constant_pool_ref (&PATTERN (insn), pool_ref, addr);
6222 INSN_CODE (insn) = -1;
6223 }
6224 }
6225 }
6226
6227
6228 /* Free the pool. */
6229 s390_free_pool (pool);
6230 }
6231
6232 /* POOL holds the main literal pool as collected by s390_mainpool_start.
6233 We have decided we cannot use this pool, so revert all changes
6234 to the current function that were done by s390_mainpool_start. */
6235 static void
6236 s390_mainpool_cancel (struct constant_pool *pool)
6237 {
6238 /* We didn't actually change the instruction stream, so simply
6239 free the pool memory. */
6240 s390_free_pool (pool);
6241 }
6242
6243
6244 /* Chunkify the literal pool. */
6245
6246 #define S390_POOL_CHUNK_MIN 0xc00
6247 #define S390_POOL_CHUNK_MAX 0xe00
6248
6249 static struct constant_pool *
6250 s390_chunkify_start (void)
6251 {
6252 struct constant_pool *curr_pool = NULL, *pool_list = NULL;
6253 int extra_size = 0;
6254 bitmap far_labels;
6255 rtx pending_ltrel = NULL_RTX;
6256 rtx insn;
6257
6258 rtx (*gen_reload_base) (rtx, rtx) =
6259 TARGET_CPU_ZARCH? gen_reload_base_64 : gen_reload_base_31;
6260
6261
6262 /* We need correct insn addresses. */
6263
6264 shorten_branches (get_insns ());
6265
6266 /* Scan all insns and move literals to pool chunks. */
6267
6268 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
6269 {
6270 bool section_switch_p = false;
6271
6272 /* Check for pending LTREL_BASE. */
6273 if (INSN_P (insn))
6274 {
6275 rtx ltrel_base = find_ltrel_base (PATTERN (insn));
6276 if (ltrel_base)
6277 {
6278 gcc_assert (ltrel_base == pending_ltrel);
6279 pending_ltrel = NULL_RTX;
6280 }
6281 }
6282
6283 if (!TARGET_CPU_ZARCH && s390_execute_label (insn))
6284 {
6285 if (!curr_pool)
6286 curr_pool = s390_start_pool (&pool_list, insn);
6287
6288 s390_add_execute (curr_pool, insn);
6289 s390_add_pool_insn (curr_pool, insn);
6290 }
6291 else if (GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN)
6292 {
6293 rtx pool_ref = NULL_RTX;
6294 find_constant_pool_ref (PATTERN (insn), &pool_ref);
6295 if (pool_ref)
6296 {
6297 rtx constant = get_pool_constant (pool_ref);
6298 enum machine_mode mode = get_pool_mode (pool_ref);
6299
6300 if (!curr_pool)
6301 curr_pool = s390_start_pool (&pool_list, insn);
6302
6303 s390_add_constant (curr_pool, constant, mode);
6304 s390_add_pool_insn (curr_pool, insn);
6305
6306 /* Don't split the pool chunk between a LTREL_OFFSET load
6307 and the corresponding LTREL_BASE. */
6308 if (GET_CODE (constant) == CONST
6309 && GET_CODE (XEXP (constant, 0)) == UNSPEC
6310 && XINT (XEXP (constant, 0), 1) == UNSPEC_LTREL_OFFSET)
6311 {
6312 gcc_assert (!pending_ltrel);
6313 pending_ltrel = pool_ref;
6314 }
6315 }
6316 }
6317
6318 if (GET_CODE (insn) == JUMP_INSN || GET_CODE (insn) == CODE_LABEL)
6319 {
6320 if (curr_pool)
6321 s390_add_pool_insn (curr_pool, insn);
6322 /* An LTREL_BASE must follow within the same basic block. */
6323 gcc_assert (!pending_ltrel);
6324 }
6325
6326 if (NOTE_P (insn) && NOTE_KIND (insn) == NOTE_INSN_SWITCH_TEXT_SECTIONS)
6327 section_switch_p = true;
6328
6329 if (!curr_pool
6330 || INSN_ADDRESSES_SIZE () <= (size_t) INSN_UID (insn)
6331 || INSN_ADDRESSES (INSN_UID (insn)) == -1)
6332 continue;
6333
6334 if (TARGET_CPU_ZARCH)
6335 {
6336 if (curr_pool->size < S390_POOL_CHUNK_MAX)
6337 continue;
6338
6339 s390_end_pool (curr_pool, NULL_RTX);
6340 curr_pool = NULL;
6341 }
6342 else
6343 {
6344 int chunk_size = INSN_ADDRESSES (INSN_UID (insn))
6345 - INSN_ADDRESSES (INSN_UID (curr_pool->first_insn))
6346 + extra_size;
6347
6348 /* We will later have to insert base register reload insns.
6349 Those will have an effect on code size, which we need to
6350 consider here. This calculation makes rather pessimistic
6351 worst-case assumptions. */
6352 if (GET_CODE (insn) == CODE_LABEL)
6353 extra_size += 6;
6354
6355 if (chunk_size < S390_POOL_CHUNK_MIN
6356 && curr_pool->size < S390_POOL_CHUNK_MIN
6357 && !section_switch_p)
6358 continue;
6359
6360 /* Pool chunks can only be inserted after BARRIERs ... */
6361 if (GET_CODE (insn) == BARRIER)
6362 {
6363 s390_end_pool (curr_pool, insn);
6364 curr_pool = NULL;
6365 extra_size = 0;
6366 }
6367
6368 /* ... so if we don't find one in time, create one. */
6369 else if (chunk_size > S390_POOL_CHUNK_MAX
6370 || curr_pool->size > S390_POOL_CHUNK_MAX
6371 || section_switch_p)
6372 {
6373 rtx label, jump, barrier;
6374
6375 if (!section_switch_p)
6376 {
6377 /* We can insert the barrier only after a 'real' insn. */
6378 if (GET_CODE (insn) != INSN && GET_CODE (insn) != CALL_INSN)
6379 continue;
6380 if (get_attr_length (insn) == 0)
6381 continue;
6382 /* Don't separate LTREL_BASE from the corresponding
6383 LTREL_OFFSET load. */
6384 if (pending_ltrel)
6385 continue;
6386 }
6387 else
6388 {
6389 gcc_assert (!pending_ltrel);
6390
6391 /* The old pool has to end before the section switch
6392 note in order to make it part of the current
6393 section. */
6394 insn = PREV_INSN (insn);
6395 }
6396
6397 label = gen_label_rtx ();
6398 jump = emit_jump_insn_after (gen_jump (label), insn);
6399 barrier = emit_barrier_after (jump);
6400 insn = emit_label_after (label, barrier);
6401 JUMP_LABEL (jump) = label;
6402 LABEL_NUSES (label) = 1;
6403
6404 INSN_ADDRESSES_NEW (jump, -1);
6405 INSN_ADDRESSES_NEW (barrier, -1);
6406 INSN_ADDRESSES_NEW (insn, -1);
6407
6408 s390_end_pool (curr_pool, barrier);
6409 curr_pool = NULL;
6410 extra_size = 0;
6411 }
6412 }
6413 }
6414
6415 if (curr_pool)
6416 s390_end_pool (curr_pool, NULL_RTX);
6417 gcc_assert (!pending_ltrel);
6418
6419 /* Find all labels that are branched into
6420 from an insn belonging to a different chunk. */
6421
6422 far_labels = BITMAP_ALLOC (NULL);
6423
6424 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
6425 {
6426 /* Labels marked with LABEL_PRESERVE_P can be target
6427 of non-local jumps, so we have to mark them.
6428 The same holds for named labels.
6429
6430 Don't do that, however, if it is the label before
6431 a jump table. */
6432
6433 if (GET_CODE (insn) == CODE_LABEL
6434 && (LABEL_PRESERVE_P (insn) || LABEL_NAME (insn)))
6435 {
6436 rtx vec_insn = next_real_insn (insn);
6437 rtx vec_pat = vec_insn && GET_CODE (vec_insn) == JUMP_INSN ?
6438 PATTERN (vec_insn) : NULL_RTX;
6439 if (!vec_pat
6440 || !(GET_CODE (vec_pat) == ADDR_VEC
6441 || GET_CODE (vec_pat) == ADDR_DIFF_VEC))
6442 bitmap_set_bit (far_labels, CODE_LABEL_NUMBER (insn));
6443 }
6444
6445 /* If we have a direct jump (conditional or unconditional)
6446 or a casesi jump, check all potential targets. */
6447 else if (GET_CODE (insn) == JUMP_INSN)
6448 {
6449 rtx pat = PATTERN (insn);
6450 if (GET_CODE (pat) == PARALLEL && XVECLEN (pat, 0) > 2)
6451 pat = XVECEXP (pat, 0, 0);
6452
6453 if (GET_CODE (pat) == SET)
6454 {
6455 rtx label = JUMP_LABEL (insn);
6456 if (label)
6457 {
6458 if (s390_find_pool (pool_list, label)
6459 != s390_find_pool (pool_list, insn))
6460 bitmap_set_bit (far_labels, CODE_LABEL_NUMBER (label));
6461 }
6462 }
6463 else if (GET_CODE (pat) == PARALLEL
6464 && XVECLEN (pat, 0) == 2
6465 && GET_CODE (XVECEXP (pat, 0, 0)) == SET
6466 && GET_CODE (XVECEXP (pat, 0, 1)) == USE
6467 && GET_CODE (XEXP (XVECEXP (pat, 0, 1), 0)) == LABEL_REF)
6468 {
6469 /* Find the jump table used by this casesi jump. */
6470 rtx vec_label = XEXP (XEXP (XVECEXP (pat, 0, 1), 0), 0);
6471 rtx vec_insn = next_real_insn (vec_label);
6472 rtx vec_pat = vec_insn && GET_CODE (vec_insn) == JUMP_INSN ?
6473 PATTERN (vec_insn) : NULL_RTX;
6474 if (vec_pat
6475 && (GET_CODE (vec_pat) == ADDR_VEC
6476 || GET_CODE (vec_pat) == ADDR_DIFF_VEC))
6477 {
6478 int i, diff_p = GET_CODE (vec_pat) == ADDR_DIFF_VEC;
6479
6480 for (i = 0; i < XVECLEN (vec_pat, diff_p); i++)
6481 {
6482 rtx label = XEXP (XVECEXP (vec_pat, diff_p, i), 0);
6483
6484 if (s390_find_pool (pool_list, label)
6485 != s390_find_pool (pool_list, insn))
6486 bitmap_set_bit (far_labels, CODE_LABEL_NUMBER (label));
6487 }
6488 }
6489 }
6490 }
6491 }
6492
6493 /* Insert base register reload insns before every pool. */
6494
6495 for (curr_pool = pool_list; curr_pool; curr_pool = curr_pool->next)
6496 {
6497 rtx new_insn = gen_reload_base (cfun->machine->base_reg,
6498 curr_pool->label);
6499 rtx insn = curr_pool->first_insn;
6500 INSN_ADDRESSES_NEW (emit_insn_before (new_insn, insn), -1);
6501 }
6502
6503 /* Insert base register reload insns at every far label. */
6504
6505 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
6506 if (GET_CODE (insn) == CODE_LABEL
6507 && bitmap_bit_p (far_labels, CODE_LABEL_NUMBER (insn)))
6508 {
6509 struct constant_pool *pool = s390_find_pool (pool_list, insn);
6510 if (pool)
6511 {
6512 rtx new_insn = gen_reload_base (cfun->machine->base_reg,
6513 pool->label);
6514 INSN_ADDRESSES_NEW (emit_insn_after (new_insn, insn), -1);
6515 }
6516 }
6517
6518
6519 BITMAP_FREE (far_labels);
6520
6521
6522 /* Recompute insn addresses. */
6523
6524 init_insn_lengths ();
6525 shorten_branches (get_insns ());
6526
6527 return pool_list;
6528 }
6529
6530 /* POOL_LIST is a chunk list as prepared by s390_chunkify_start.
6531 After we have decided to use this list, finish implementing
6532 all changes to the current function as required. */
6533
6534 static void
6535 s390_chunkify_finish (struct constant_pool *pool_list)
6536 {
6537 struct constant_pool *curr_pool = NULL;
6538 rtx insn;
6539
6540
6541 /* Replace all literal pool references. */
6542
6543 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
6544 {
6545 if (INSN_P (insn))
6546 replace_ltrel_base (&PATTERN (insn));
6547
6548 curr_pool = s390_find_pool (pool_list, insn);
6549 if (!curr_pool)
6550 continue;
6551
6552 if (GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN)
6553 {
6554 rtx addr, pool_ref = NULL_RTX;
6555 find_constant_pool_ref (PATTERN (insn), &pool_ref);
6556 if (pool_ref)
6557 {
6558 if (s390_execute_label (insn))
6559 addr = s390_find_execute (curr_pool, insn);
6560 else
6561 addr = s390_find_constant (curr_pool,
6562 get_pool_constant (pool_ref),
6563 get_pool_mode (pool_ref));
6564
6565 replace_constant_pool_ref (&PATTERN (insn), pool_ref, addr);
6566 INSN_CODE (insn) = -1;
6567 }
6568 }
6569 }
6570
6571 /* Dump out all literal pools. */
6572
6573 for (curr_pool = pool_list; curr_pool; curr_pool = curr_pool->next)
6574 s390_dump_pool (curr_pool, 0);
6575
6576 /* Free pool list. */
6577
6578 while (pool_list)
6579 {
6580 struct constant_pool *next = pool_list->next;
6581 s390_free_pool (pool_list);
6582 pool_list = next;
6583 }
6584 }
6585
6586 /* POOL_LIST is a chunk list as prepared by s390_chunkify_start.
6587 We have decided we cannot use this list, so revert all changes
6588 to the current function that were done by s390_chunkify_start. */
6589
6590 static void
6591 s390_chunkify_cancel (struct constant_pool *pool_list)
6592 {
6593 struct constant_pool *curr_pool = NULL;
6594 rtx insn;
6595
6596 /* Remove all pool placeholder insns. */
6597
6598 for (curr_pool = pool_list; curr_pool; curr_pool = curr_pool->next)
6599 {
6600 /* Did we insert an extra barrier? Remove it. */
6601 rtx barrier = PREV_INSN (curr_pool->pool_insn);
6602 rtx jump = barrier? PREV_INSN (barrier) : NULL_RTX;
6603 rtx label = NEXT_INSN (curr_pool->pool_insn);
6604
6605 if (jump && GET_CODE (jump) == JUMP_INSN
6606 && barrier && GET_CODE (barrier) == BARRIER
6607 && label && GET_CODE (label) == CODE_LABEL
6608 && GET_CODE (PATTERN (jump)) == SET
6609 && SET_DEST (PATTERN (jump)) == pc_rtx
6610 && GET_CODE (SET_SRC (PATTERN (jump))) == LABEL_REF
6611 && XEXP (SET_SRC (PATTERN (jump)), 0) == label)
6612 {
6613 remove_insn (jump);
6614 remove_insn (barrier);
6615 remove_insn (label);
6616 }
6617
6618 remove_insn (curr_pool->pool_insn);
6619 }
6620
6621 /* Remove all base register reload insns. */
6622
6623 for (insn = get_insns (); insn; )
6624 {
6625 rtx next_insn = NEXT_INSN (insn);
6626
6627 if (GET_CODE (insn) == INSN
6628 && GET_CODE (PATTERN (insn)) == SET
6629 && GET_CODE (SET_SRC (PATTERN (insn))) == UNSPEC
6630 && XINT (SET_SRC (PATTERN (insn)), 1) == UNSPEC_RELOAD_BASE)
6631 remove_insn (insn);
6632
6633 insn = next_insn;
6634 }
6635
6636 /* Free pool list. */
6637
6638 while (pool_list)
6639 {
6640 struct constant_pool *next = pool_list->next;
6641 s390_free_pool (pool_list);
6642 pool_list = next;
6643 }
6644 }
6645
6646
6647 /* Output the constant pool entry EXP in mode MODE with alignment ALIGN. */
6648
6649 void
6650 s390_output_pool_entry (rtx exp, enum machine_mode mode, unsigned int align)
6651 {
6652 REAL_VALUE_TYPE r;
6653
6654 switch (GET_MODE_CLASS (mode))
6655 {
6656 case MODE_FLOAT:
6657 case MODE_DECIMAL_FLOAT:
6658 gcc_assert (GET_CODE (exp) == CONST_DOUBLE);
6659
6660 REAL_VALUE_FROM_CONST_DOUBLE (r, exp);
6661 assemble_real (r, mode, align);
6662 break;
6663
6664 case MODE_INT:
6665 assemble_integer (exp, GET_MODE_SIZE (mode), align, 1);
6666 break;
6667
6668 default:
6669 gcc_unreachable ();
6670 }
6671 }
6672
6673
6674 /* Return an RTL expression representing the value of the return address
6675 for the frame COUNT steps up from the current frame. FRAME is the
6676 frame pointer of that frame. */
6677
6678 rtx
6679 s390_return_addr_rtx (int count, rtx frame ATTRIBUTE_UNUSED)
6680 {
6681 int offset;
6682 rtx addr;
6683
6684 /* Without backchain, we fail for all but the current frame. */
6685
6686 if (!TARGET_BACKCHAIN && count > 0)
6687 return NULL_RTX;
6688
6689 /* For the current frame, we need to make sure the initial
6690 value of RETURN_REGNUM is actually saved. */
6691
6692 if (count == 0)
6693 {
6694 /* On non-z architectures branch splitting could overwrite r14. */
6695 if (TARGET_CPU_ZARCH)
6696 return get_hard_reg_initial_val (Pmode, RETURN_REGNUM);
6697 else
6698 {
6699 cfun_frame_layout.save_return_addr_p = true;
6700 return gen_rtx_MEM (Pmode, return_address_pointer_rtx);
6701 }
6702 }
6703
6704 if (TARGET_PACKED_STACK)
6705 offset = -2 * UNITS_PER_WORD;
6706 else
6707 offset = RETURN_REGNUM * UNITS_PER_WORD;
6708
6709 addr = plus_constant (frame, offset);
6710 addr = memory_address (Pmode, addr);
6711 return gen_rtx_MEM (Pmode, addr);
6712 }
6713
6714 /* Return an RTL expression representing the back chain stored in
6715 the current stack frame. */
6716
6717 rtx
6718 s390_back_chain_rtx (void)
6719 {
6720 rtx chain;
6721
6722 gcc_assert (TARGET_BACKCHAIN);
6723
6724 if (TARGET_PACKED_STACK)
6725 chain = plus_constant (stack_pointer_rtx,
6726 STACK_POINTER_OFFSET - UNITS_PER_WORD);
6727 else
6728 chain = stack_pointer_rtx;
6729
6730 chain = gen_rtx_MEM (Pmode, chain);
6731 return chain;
6732 }
6733
6734 /* Find first call clobbered register unused in a function.
6735 This could be used as base register in a leaf function
6736 or for holding the return address before epilogue. */
6737
6738 static int
6739 find_unused_clobbered_reg (void)
6740 {
6741 int i;
6742 for (i = 0; i < 6; i++)
6743 if (!df_regs_ever_live_p (i))
6744 return i;
6745 return 0;
6746 }
6747
6748
6749 /* Helper function for s390_regs_ever_clobbered. Sets the fields in DATA for all
6750 clobbered hard regs in SETREG. */
6751
6752 static void
6753 s390_reg_clobbered_rtx (rtx setreg, const_rtx set_insn ATTRIBUTE_UNUSED, void *data)
6754 {
6755 int *regs_ever_clobbered = (int *)data;
6756 unsigned int i, regno;
6757 enum machine_mode mode = GET_MODE (setreg);
6758
6759 if (GET_CODE (setreg) == SUBREG)
6760 {
6761 rtx inner = SUBREG_REG (setreg);
6762 if (!GENERAL_REG_P (inner))
6763 return;
6764 regno = subreg_regno (setreg);
6765 }
6766 else if (GENERAL_REG_P (setreg))
6767 regno = REGNO (setreg);
6768 else
6769 return;
6770
6771 for (i = regno;
6772 i < regno + HARD_REGNO_NREGS (regno, mode);
6773 i++)
6774 regs_ever_clobbered[i] = 1;
6775 }
6776
6777 /* Walks through all basic blocks of the current function looking
6778 for clobbered hard regs using s390_reg_clobbered_rtx. The fields
6779 of the passed integer array REGS_EVER_CLOBBERED are set to one for
6780 each of those regs. */
6781
6782 static void
6783 s390_regs_ever_clobbered (int *regs_ever_clobbered)
6784 {
6785 basic_block cur_bb;
6786 rtx cur_insn;
6787 unsigned int i;
6788
6789 memset (regs_ever_clobbered, 0, 16 * sizeof (int));
6790
6791 /* For non-leaf functions we have to consider all call clobbered regs to be
6792 clobbered. */
6793 if (!current_function_is_leaf)
6794 {
6795 for (i = 0; i < 16; i++)
6796 regs_ever_clobbered[i] = call_really_used_regs[i];
6797 }
6798
6799 /* Make the "magic" eh_return registers live if necessary. For regs_ever_live
6800 this work is done by liveness analysis (mark_regs_live_at_end).
6801 Special care is needed for functions containing landing pads. Landing pads
6802 may use the eh registers, but the code which sets these registers is not
6803 contained in that function. Hence s390_regs_ever_clobbered is not able to
6804 deal with this automatically. */
6805 if (crtl->calls_eh_return || cfun->machine->has_landing_pad_p)
6806 for (i = 0; EH_RETURN_DATA_REGNO (i) != INVALID_REGNUM ; i++)
6807 if (crtl->calls_eh_return
6808 || (cfun->machine->has_landing_pad_p
6809 && df_regs_ever_live_p (EH_RETURN_DATA_REGNO (i))))
6810 regs_ever_clobbered[EH_RETURN_DATA_REGNO (i)] = 1;
6811
6812 /* For nonlocal gotos all call-saved registers have to be saved.
6813 This flag is also set for the unwinding code in libgcc.
6814 See expand_builtin_unwind_init. For regs_ever_live this is done by
6815 reload. */
6816 if (cfun->has_nonlocal_label)
6817 for (i = 0; i < 16; i++)
6818 if (!call_really_used_regs[i])
6819 regs_ever_clobbered[i] = 1;
6820
6821 FOR_EACH_BB (cur_bb)
6822 {
6823 FOR_BB_INSNS (cur_bb, cur_insn)
6824 {
6825 if (INSN_P (cur_insn))
6826 note_stores (PATTERN (cur_insn),
6827 s390_reg_clobbered_rtx,
6828 regs_ever_clobbered);
6829 }
6830 }
6831 }
6832
6833 /* Determine the frame area which actually has to be accessed
6834 in the function epilogue. The values are stored at the
6835 given pointers AREA_BOTTOM (address of the lowest used stack
6836 address) and AREA_TOP (address of the first item which does
6837 not belong to the stack frame). */
6838
6839 static void
6840 s390_frame_area (int *area_bottom, int *area_top)
6841 {
6842 int b, t;
6843 int i;
6844
6845 b = INT_MAX;
6846 t = INT_MIN;
6847
6848 if (cfun_frame_layout.first_restore_gpr != -1)
6849 {
6850 b = (cfun_frame_layout.gprs_offset
6851 + cfun_frame_layout.first_restore_gpr * UNITS_PER_WORD);
6852 t = b + (cfun_frame_layout.last_restore_gpr
6853 - cfun_frame_layout.first_restore_gpr + 1) * UNITS_PER_WORD;
6854 }
6855
6856 if (TARGET_64BIT && cfun_save_high_fprs_p)
6857 {
6858 b = MIN (b, cfun_frame_layout.f8_offset);
6859 t = MAX (t, (cfun_frame_layout.f8_offset
6860 + cfun_frame_layout.high_fprs * 8));
6861 }
6862
6863 if (!TARGET_64BIT)
6864 for (i = 2; i < 4; i++)
6865 if (cfun_fpr_bit_p (i))
6866 {
6867 b = MIN (b, cfun_frame_layout.f4_offset + (i - 2) * 8);
6868 t = MAX (t, cfun_frame_layout.f4_offset + (i - 1) * 8);
6869 }
6870
6871 *area_bottom = b;
6872 *area_top = t;
6873 }
6874
6875 /* Fill cfun->machine with info about register usage of current function.
6876 Return in CLOBBERED_REGS which GPRs are currently considered set. */
6877
6878 static void
6879 s390_register_info (int clobbered_regs[])
6880 {
6881 int i, j;
6882
6883 /* fprs 8 - 15 are call saved for 64 Bit ABI. */
6884 cfun_frame_layout.fpr_bitmap = 0;
6885 cfun_frame_layout.high_fprs = 0;
6886 if (TARGET_64BIT)
6887 for (i = 24; i < 32; i++)
6888 if (df_regs_ever_live_p (i) && !global_regs[i])
6889 {
6890 cfun_set_fpr_bit (i - 16);
6891 cfun_frame_layout.high_fprs++;
6892 }
6893
6894 /* Find first and last gpr to be saved. We trust regs_ever_live
6895 data, except that we don't save and restore global registers.
6896
6897 Also, all registers with special meaning to the compiler need
6898 to be handled extra. */
6899
6900 s390_regs_ever_clobbered (clobbered_regs);
6901
6902 for (i = 0; i < 16; i++)
6903 clobbered_regs[i] = clobbered_regs[i] && !global_regs[i] && !fixed_regs[i];
6904
6905 if (frame_pointer_needed)
6906 clobbered_regs[HARD_FRAME_POINTER_REGNUM] = 1;
6907
6908 if (flag_pic)
6909 clobbered_regs[PIC_OFFSET_TABLE_REGNUM]
6910 |= df_regs_ever_live_p (PIC_OFFSET_TABLE_REGNUM);
6911
6912 clobbered_regs[BASE_REGNUM]
6913 |= (cfun->machine->base_reg
6914 && REGNO (cfun->machine->base_reg) == BASE_REGNUM);
6915
6916 clobbered_regs[RETURN_REGNUM]
6917 |= (!current_function_is_leaf
6918 || TARGET_TPF_PROFILING
6919 || cfun->machine->split_branches_pending_p
6920 || cfun_frame_layout.save_return_addr_p
6921 || crtl->calls_eh_return
6922 || cfun->stdarg);
6923
6924 clobbered_regs[STACK_POINTER_REGNUM]
6925 |= (!current_function_is_leaf
6926 || TARGET_TPF_PROFILING
6927 || cfun_save_high_fprs_p
6928 || get_frame_size () > 0
6929 || cfun->calls_alloca
6930 || cfun->stdarg);
6931
6932 for (i = 6; i < 16; i++)
6933 if (df_regs_ever_live_p (i) || clobbered_regs[i])
6934 break;
6935 for (j = 15; j > i; j--)
6936 if (df_regs_ever_live_p (j) || clobbered_regs[j])
6937 break;
6938
6939 if (i == 16)
6940 {
6941 /* Nothing to save/restore. */
6942 cfun_frame_layout.first_save_gpr_slot = -1;
6943 cfun_frame_layout.last_save_gpr_slot = -1;
6944 cfun_frame_layout.first_save_gpr = -1;
6945 cfun_frame_layout.first_restore_gpr = -1;
6946 cfun_frame_layout.last_save_gpr = -1;
6947 cfun_frame_layout.last_restore_gpr = -1;
6948 }
6949 else
6950 {
6951 /* Save slots for gprs from i to j. */
6952 cfun_frame_layout.first_save_gpr_slot = i;
6953 cfun_frame_layout.last_save_gpr_slot = j;
6954
6955 for (i = cfun_frame_layout.first_save_gpr_slot;
6956 i < cfun_frame_layout.last_save_gpr_slot + 1;
6957 i++)
6958 if (clobbered_regs[i])
6959 break;
6960
6961 for (j = cfun_frame_layout.last_save_gpr_slot; j > i; j--)
6962 if (clobbered_regs[j])
6963 break;
6964
6965 if (i == cfun_frame_layout.last_save_gpr_slot + 1)
6966 {
6967 /* Nothing to save/restore. */
6968 cfun_frame_layout.first_save_gpr = -1;
6969 cfun_frame_layout.first_restore_gpr = -1;
6970 cfun_frame_layout.last_save_gpr = -1;
6971 cfun_frame_layout.last_restore_gpr = -1;
6972 }
6973 else
6974 {
6975 /* Save / Restore from gpr i to j. */
6976 cfun_frame_layout.first_save_gpr = i;
6977 cfun_frame_layout.first_restore_gpr = i;
6978 cfun_frame_layout.last_save_gpr = j;
6979 cfun_frame_layout.last_restore_gpr = j;
6980 }
6981 }
6982
6983 if (cfun->stdarg)
6984 {
6985 /* Varargs functions need to save gprs 2 to 6. */
6986 if (cfun->va_list_gpr_size
6987 && crtl->args.info.gprs < GP_ARG_NUM_REG)
6988 {
6989 int min_gpr = crtl->args.info.gprs;
6990 int max_gpr = min_gpr + cfun->va_list_gpr_size;
6991 if (max_gpr > GP_ARG_NUM_REG)
6992 max_gpr = GP_ARG_NUM_REG;
6993
6994 if (cfun_frame_layout.first_save_gpr == -1
6995 || cfun_frame_layout.first_save_gpr > 2 + min_gpr)
6996 {
6997 cfun_frame_layout.first_save_gpr = 2 + min_gpr;
6998 cfun_frame_layout.first_save_gpr_slot = 2 + min_gpr;
6999 }
7000
7001 if (cfun_frame_layout.last_save_gpr == -1
7002 || cfun_frame_layout.last_save_gpr < 2 + max_gpr - 1)
7003 {
7004 cfun_frame_layout.last_save_gpr = 2 + max_gpr - 1;
7005 cfun_frame_layout.last_save_gpr_slot = 2 + max_gpr - 1;
7006 }
7007 }
7008
7009 /* Mark f0, f2 for 31 bit and f0-f4 for 64 bit to be saved. */
7010 if (TARGET_HARD_FLOAT && cfun->va_list_fpr_size
7011 && crtl->args.info.fprs < FP_ARG_NUM_REG)
7012 {
7013 int min_fpr = crtl->args.info.fprs;
7014 int max_fpr = min_fpr + cfun->va_list_fpr_size;
7015 if (max_fpr > FP_ARG_NUM_REG)
7016 max_fpr = FP_ARG_NUM_REG;
7017
7018 /* ??? This is currently required to ensure proper location
7019 of the fpr save slots within the va_list save area. */
7020 if (TARGET_PACKED_STACK)
7021 min_fpr = 0;
7022
7023 for (i = min_fpr; i < max_fpr; i++)
7024 cfun_set_fpr_bit (i);
7025 }
7026 }
7027
7028 if (!TARGET_64BIT)
7029 for (i = 2; i < 4; i++)
7030 if (df_regs_ever_live_p (i + 16) && !global_regs[i + 16])
7031 cfun_set_fpr_bit (i);
7032 }
7033
7034 /* Fill cfun->machine with info about frame of current function. */
7035
7036 static void
7037 s390_frame_info (void)
7038 {
7039 int i;
7040
7041 cfun_frame_layout.frame_size = get_frame_size ();
7042 if (!TARGET_64BIT && cfun_frame_layout.frame_size > 0x7fff0000)
7043 fatal_error ("total size of local variables exceeds architecture limit");
7044
7045 if (!TARGET_PACKED_STACK)
7046 {
7047 cfun_frame_layout.backchain_offset = 0;
7048 cfun_frame_layout.f0_offset = 16 * UNITS_PER_WORD;
7049 cfun_frame_layout.f4_offset = cfun_frame_layout.f0_offset + 2 * 8;
7050 cfun_frame_layout.f8_offset = -cfun_frame_layout.high_fprs * 8;
7051 cfun_frame_layout.gprs_offset = (cfun_frame_layout.first_save_gpr_slot
7052 * UNITS_PER_WORD);
7053 }
7054 else if (TARGET_BACKCHAIN) /* kernel stack layout */
7055 {
7056 cfun_frame_layout.backchain_offset = (STACK_POINTER_OFFSET
7057 - UNITS_PER_WORD);
7058 cfun_frame_layout.gprs_offset
7059 = (cfun_frame_layout.backchain_offset
7060 - (STACK_POINTER_REGNUM - cfun_frame_layout.first_save_gpr_slot + 1)
7061 * UNITS_PER_WORD);
7062
7063 if (TARGET_64BIT)
7064 {
7065 cfun_frame_layout.f4_offset
7066 = (cfun_frame_layout.gprs_offset
7067 - 8 * (cfun_fpr_bit_p (2) + cfun_fpr_bit_p (3)));
7068
7069 cfun_frame_layout.f0_offset
7070 = (cfun_frame_layout.f4_offset
7071 - 8 * (cfun_fpr_bit_p (0) + cfun_fpr_bit_p (1)));
7072 }
7073 else
7074 {
7075 /* On 31 bit we have to care about alignment of the
7076 floating point regs to provide fastest access. */
7077 cfun_frame_layout.f0_offset
7078 = ((cfun_frame_layout.gprs_offset
7079 & ~(STACK_BOUNDARY / BITS_PER_UNIT - 1))
7080 - 8 * (cfun_fpr_bit_p (0) + cfun_fpr_bit_p (1)));
7081
7082 cfun_frame_layout.f4_offset
7083 = (cfun_frame_layout.f0_offset
7084 - 8 * (cfun_fpr_bit_p (2) + cfun_fpr_bit_p (3)));
7085 }
7086 }
7087 else /* no backchain */
7088 {
7089 cfun_frame_layout.f4_offset
7090 = (STACK_POINTER_OFFSET
7091 - 8 * (cfun_fpr_bit_p (2) + cfun_fpr_bit_p (3)));
7092
7093 cfun_frame_layout.f0_offset
7094 = (cfun_frame_layout.f4_offset
7095 - 8 * (cfun_fpr_bit_p (0) + cfun_fpr_bit_p (1)));
7096
7097 cfun_frame_layout.gprs_offset
7098 = cfun_frame_layout.f0_offset - cfun_gprs_save_area_size;
7099 }
7100
7101 if (current_function_is_leaf
7102 && !TARGET_TPF_PROFILING
7103 && cfun_frame_layout.frame_size == 0
7104 && !cfun_save_high_fprs_p
7105 && !cfun->calls_alloca
7106 && !cfun->stdarg)
7107 return;
7108
7109 if (!TARGET_PACKED_STACK)
7110 cfun_frame_layout.frame_size += (STACK_POINTER_OFFSET
7111 + crtl->outgoing_args_size
7112 + cfun_frame_layout.high_fprs * 8);
7113 else
7114 {
7115 if (TARGET_BACKCHAIN)
7116 cfun_frame_layout.frame_size += UNITS_PER_WORD;
7117
7118 /* No alignment trouble here because f8-f15 are only saved under
7119 64 bit. */
7120 cfun_frame_layout.f8_offset = (MIN (MIN (cfun_frame_layout.f0_offset,
7121 cfun_frame_layout.f4_offset),
7122 cfun_frame_layout.gprs_offset)
7123 - cfun_frame_layout.high_fprs * 8);
7124
7125 cfun_frame_layout.frame_size += cfun_frame_layout.high_fprs * 8;
7126
7127 for (i = 0; i < 8; i++)
7128 if (cfun_fpr_bit_p (i))
7129 cfun_frame_layout.frame_size += 8;
7130
7131 cfun_frame_layout.frame_size += cfun_gprs_save_area_size;
7132
7133 /* If under 31 bit an odd number of gprs has to be saved we have to adjust
7134 the frame size to sustain 8 byte alignment of stack frames. */
7135 cfun_frame_layout.frame_size = ((cfun_frame_layout.frame_size +
7136 STACK_BOUNDARY / BITS_PER_UNIT - 1)
7137 & ~(STACK_BOUNDARY / BITS_PER_UNIT - 1));
7138
7139 cfun_frame_layout.frame_size += crtl->outgoing_args_size;
7140 }
7141 }
7142
7143 /* Generate frame layout. Fills in register and frame data for the current
7144 function in cfun->machine. This routine can be called multiple times;
7145 it will re-do the complete frame layout every time. */
7146
7147 static void
7148 s390_init_frame_layout (void)
7149 {
7150 HOST_WIDE_INT frame_size;
7151 int base_used;
7152 int clobbered_regs[16];
7153
7154 /* On S/390 machines, we may need to perform branch splitting, which
7155 will require both base and return address register. We have no
7156 choice but to assume we're going to need them until right at the
7157 end of the machine dependent reorg phase. */
7158 if (!TARGET_CPU_ZARCH)
7159 cfun->machine->split_branches_pending_p = true;
7160
7161 do
7162 {
7163 frame_size = cfun_frame_layout.frame_size;
7164
7165 /* Try to predict whether we'll need the base register. */
7166 base_used = cfun->machine->split_branches_pending_p
7167 || crtl->uses_const_pool
7168 || (!DISP_IN_RANGE (frame_size)
7169 && !CONST_OK_FOR_K (frame_size));
7170
7171 /* Decide which register to use as literal pool base. In small
7172 leaf functions, try to use an unused call-clobbered register
7173 as base register to avoid save/restore overhead. */
7174 if (!base_used)
7175 cfun->machine->base_reg = NULL_RTX;
7176 else if (current_function_is_leaf && !df_regs_ever_live_p (5))
7177 cfun->machine->base_reg = gen_rtx_REG (Pmode, 5);
7178 else
7179 cfun->machine->base_reg = gen_rtx_REG (Pmode, BASE_REGNUM);
7180
7181 s390_register_info (clobbered_regs);
7182 s390_frame_info ();
7183 }
7184 while (frame_size != cfun_frame_layout.frame_size);
7185 }
7186
7187 /* Update frame layout. Recompute actual register save data based on
7188 current info and update regs_ever_live for the special registers.
7189 May be called multiple times, but may never cause *more* registers
7190 to be saved than s390_init_frame_layout allocated room for. */
7191
7192 static void
7193 s390_update_frame_layout (void)
7194 {
7195 int clobbered_regs[16];
7196
7197 s390_register_info (clobbered_regs);
7198
7199 df_set_regs_ever_live (BASE_REGNUM,
7200 clobbered_regs[BASE_REGNUM] ? true : false);
7201 df_set_regs_ever_live (RETURN_REGNUM,
7202 clobbered_regs[RETURN_REGNUM] ? true : false);
7203 df_set_regs_ever_live (STACK_POINTER_REGNUM,
7204 clobbered_regs[STACK_POINTER_REGNUM] ? true : false);
7205
7206 if (cfun->machine->base_reg)
7207 df_set_regs_ever_live (REGNO (cfun->machine->base_reg), true);
7208 }
7209
7210 /* Return true if it is legal to put a value with MODE into REGNO. */
7211
7212 bool
7213 s390_hard_regno_mode_ok (unsigned int regno, enum machine_mode mode)
7214 {
7215 switch (REGNO_REG_CLASS (regno))
7216 {
7217 case FP_REGS:
7218 if (REGNO_PAIR_OK (regno, mode))
7219 {
7220 if (mode == SImode || mode == DImode)
7221 return true;
7222
7223 if (FLOAT_MODE_P (mode) && GET_MODE_CLASS (mode) != MODE_VECTOR_FLOAT)
7224 return true;
7225 }
7226 break;
7227 case ADDR_REGS:
7228 if (FRAME_REGNO_P (regno) && mode == Pmode)
7229 return true;
7230
7231 /* fallthrough */
7232 case GENERAL_REGS:
7233 if (REGNO_PAIR_OK (regno, mode))
7234 {
7235 if (TARGET_64BIT
7236 || (mode != TFmode && mode != TCmode && mode != TDmode))
7237 return true;
7238 }
7239 break;
7240 case CC_REGS:
7241 if (GET_MODE_CLASS (mode) == MODE_CC)
7242 return true;
7243 break;
7244 case ACCESS_REGS:
7245 if (REGNO_PAIR_OK (regno, mode))
7246 {
7247 if (mode == SImode || mode == Pmode)
7248 return true;
7249 }
7250 break;
7251 default:
7252 return false;
7253 }
7254
7255 return false;
7256 }
7257
7258 /* Return nonzero if register OLD_REG can be renamed to register NEW_REG. */
7259
7260 bool
7261 s390_hard_regno_rename_ok (unsigned int old_reg, unsigned int new_reg)
7262 {
7263 /* Once we've decided upon a register to use as base register, it must
7264 no longer be used for any other purpose. */
7265 if (cfun->machine->base_reg)
7266 if (REGNO (cfun->machine->base_reg) == old_reg
7267 || REGNO (cfun->machine->base_reg) == new_reg)
7268 return false;
7269
7270 return true;
7271 }
7272
7273 /* Maximum number of registers to represent a value of mode MODE
7274 in a register of class CLASS. */
7275
7276 bool
7277 s390_class_max_nregs (enum reg_class class, enum machine_mode mode)
7278 {
7279 switch (class)
7280 {
7281 case FP_REGS:
7282 if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
7283 return 2 * ((GET_MODE_SIZE (mode) / 2 + 8 - 1) / 8);
7284 else
7285 return (GET_MODE_SIZE (mode) + 8 - 1) / 8;
7286 case ACCESS_REGS:
7287 return (GET_MODE_SIZE (mode) + 4 - 1) / 4;
7288 default:
7289 break;
7290 }
7291 return (GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
7292 }
7293
7294 /* Return true if register FROM can be eliminated via register TO. */
7295
7296 bool
7297 s390_can_eliminate (int from, int to)
7298 {
7299 /* On zSeries machines, we have not marked the base register as fixed.
7300 Instead, we have an elimination rule BASE_REGNUM -> BASE_REGNUM.
7301 If a function requires the base register, we say here that this
7302 elimination cannot be performed. This will cause reload to free
7303 up the base register (as if it were fixed). On the other hand,
7304 if the current function does *not* require the base register, we
7305 say here the elimination succeeds, which in turn allows reload
7306 to allocate the base register for any other purpose. */
7307 if (from == BASE_REGNUM && to == BASE_REGNUM)
7308 {
7309 if (TARGET_CPU_ZARCH)
7310 {
7311 s390_init_frame_layout ();
7312 return cfun->machine->base_reg == NULL_RTX;
7313 }
7314
7315 return false;
7316 }
7317
7318 /* Everything else must point into the stack frame. */
7319 gcc_assert (to == STACK_POINTER_REGNUM
7320 || to == HARD_FRAME_POINTER_REGNUM);
7321
7322 gcc_assert (from == FRAME_POINTER_REGNUM
7323 || from == ARG_POINTER_REGNUM
7324 || from == RETURN_ADDRESS_POINTER_REGNUM);
7325
7326 /* Make sure we actually saved the return address. */
7327 if (from == RETURN_ADDRESS_POINTER_REGNUM)
7328 if (!crtl->calls_eh_return
7329 && !cfun->stdarg
7330 && !cfun_frame_layout.save_return_addr_p)
7331 return false;
7332
7333 return true;
7334 }
7335
7336 /* Return offset between register FROM and TO initially after prolog. */
7337
7338 HOST_WIDE_INT
7339 s390_initial_elimination_offset (int from, int to)
7340 {
7341 HOST_WIDE_INT offset;
7342 int index;
7343
7344 /* ??? Why are we called for non-eliminable pairs? */
7345 if (!s390_can_eliminate (from, to))
7346 return 0;
7347
7348 switch (from)
7349 {
7350 case FRAME_POINTER_REGNUM:
7351 offset = (get_frame_size()
7352 + STACK_POINTER_OFFSET
7353 + crtl->outgoing_args_size);
7354 break;
7355
7356 case ARG_POINTER_REGNUM:
7357 s390_init_frame_layout ();
7358 offset = cfun_frame_layout.frame_size + STACK_POINTER_OFFSET;
7359 break;
7360
7361 case RETURN_ADDRESS_POINTER_REGNUM:
7362 s390_init_frame_layout ();
7363 index = RETURN_REGNUM - cfun_frame_layout.first_save_gpr_slot;
7364 gcc_assert (index >= 0);
7365 offset = cfun_frame_layout.frame_size + cfun_frame_layout.gprs_offset;
7366 offset += index * UNITS_PER_WORD;
7367 break;
7368
7369 case BASE_REGNUM:
7370 offset = 0;
7371 break;
7372
7373 default:
7374 gcc_unreachable ();
7375 }
7376
7377 return offset;
7378 }
7379
7380 /* Emit insn to save fpr REGNUM at offset OFFSET relative
7381 to register BASE. Return generated insn. */
7382
7383 static rtx
7384 save_fpr (rtx base, int offset, int regnum)
7385 {
7386 rtx addr;
7387 addr = gen_rtx_MEM (DFmode, plus_constant (base, offset));
7388
7389 if (regnum >= 16 && regnum <= (16 + FP_ARG_NUM_REG))
7390 set_mem_alias_set (addr, get_varargs_alias_set ());
7391 else
7392 set_mem_alias_set (addr, get_frame_alias_set ());
7393
7394 return emit_move_insn (addr, gen_rtx_REG (DFmode, regnum));
7395 }
7396
7397 /* Emit insn to restore fpr REGNUM from offset OFFSET relative
7398 to register BASE. Return generated insn. */
7399
7400 static rtx
7401 restore_fpr (rtx base, int offset, int regnum)
7402 {
7403 rtx addr;
7404 addr = gen_rtx_MEM (DFmode, plus_constant (base, offset));
7405 set_mem_alias_set (addr, get_frame_alias_set ());
7406
7407 return emit_move_insn (gen_rtx_REG (DFmode, regnum), addr);
7408 }
7409
7410 /* Generate insn to save registers FIRST to LAST into
7411 the register save area located at offset OFFSET
7412 relative to register BASE. */
7413
7414 static rtx
7415 save_gprs (rtx base, int offset, int first, int last)
7416 {
7417 rtx addr, insn, note;
7418 int i;
7419
7420 addr = plus_constant (base, offset);
7421 addr = gen_rtx_MEM (Pmode, addr);
7422
7423 set_mem_alias_set (addr, get_frame_alias_set ());
7424
7425 /* Special-case single register. */
7426 if (first == last)
7427 {
7428 if (TARGET_64BIT)
7429 insn = gen_movdi (addr, gen_rtx_REG (Pmode, first));
7430 else
7431 insn = gen_movsi (addr, gen_rtx_REG (Pmode, first));
7432
7433 RTX_FRAME_RELATED_P (insn) = 1;
7434 return insn;
7435 }
7436
7437
7438 insn = gen_store_multiple (addr,
7439 gen_rtx_REG (Pmode, first),
7440 GEN_INT (last - first + 1));
7441
7442 if (first <= 6 && cfun->stdarg)
7443 for (i = 0; i < XVECLEN (PATTERN (insn), 0); i++)
7444 {
7445 rtx mem = XEXP (XVECEXP (PATTERN (insn), 0, i), 0);
7446
7447 if (first + i <= 6)
7448 set_mem_alias_set (mem, get_varargs_alias_set ());
7449 }
7450
7451 /* We need to set the FRAME_RELATED flag on all SETs
7452 inside the store-multiple pattern.
7453
7454 However, we must not emit DWARF records for registers 2..5
7455 if they are stored for use by variable arguments ...
7456
7457 ??? Unfortunately, it is not enough to simply not the
7458 FRAME_RELATED flags for those SETs, because the first SET
7459 of the PARALLEL is always treated as if it had the flag
7460 set, even if it does not. Therefore we emit a new pattern
7461 without those registers as REG_FRAME_RELATED_EXPR note. */
7462
7463 if (first >= 6)
7464 {
7465 rtx pat = PATTERN (insn);
7466
7467 for (i = 0; i < XVECLEN (pat, 0); i++)
7468 if (GET_CODE (XVECEXP (pat, 0, i)) == SET)
7469 RTX_FRAME_RELATED_P (XVECEXP (pat, 0, i)) = 1;
7470
7471 RTX_FRAME_RELATED_P (insn) = 1;
7472 }
7473 else if (last >= 6)
7474 {
7475 addr = plus_constant (base, offset + (6 - first) * UNITS_PER_WORD);
7476 note = gen_store_multiple (gen_rtx_MEM (Pmode, addr),
7477 gen_rtx_REG (Pmode, 6),
7478 GEN_INT (last - 6 + 1));
7479 note = PATTERN (note);
7480
7481 REG_NOTES (insn) =
7482 gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
7483 note, REG_NOTES (insn));
7484
7485 for (i = 0; i < XVECLEN (note, 0); i++)
7486 if (GET_CODE (XVECEXP (note, 0, i)) == SET)
7487 RTX_FRAME_RELATED_P (XVECEXP (note, 0, i)) = 1;
7488
7489 RTX_FRAME_RELATED_P (insn) = 1;
7490 }
7491
7492 return insn;
7493 }
7494
7495 /* Generate insn to restore registers FIRST to LAST from
7496 the register save area located at offset OFFSET
7497 relative to register BASE. */
7498
7499 static rtx
7500 restore_gprs (rtx base, int offset, int first, int last)
7501 {
7502 rtx addr, insn;
7503
7504 addr = plus_constant (base, offset);
7505 addr = gen_rtx_MEM (Pmode, addr);
7506 set_mem_alias_set (addr, get_frame_alias_set ());
7507
7508 /* Special-case single register. */
7509 if (first == last)
7510 {
7511 if (TARGET_64BIT)
7512 insn = gen_movdi (gen_rtx_REG (Pmode, first), addr);
7513 else
7514 insn = gen_movsi (gen_rtx_REG (Pmode, first), addr);
7515
7516 return insn;
7517 }
7518
7519 insn = gen_load_multiple (gen_rtx_REG (Pmode, first),
7520 addr,
7521 GEN_INT (last - first + 1));
7522 return insn;
7523 }
7524
7525 /* Return insn sequence to load the GOT register. */
7526
7527 static GTY(()) rtx got_symbol;
7528 rtx
7529 s390_load_got (void)
7530 {
7531 rtx insns;
7532
7533 if (!got_symbol)
7534 {
7535 got_symbol = gen_rtx_SYMBOL_REF (Pmode, "_GLOBAL_OFFSET_TABLE_");
7536 SYMBOL_REF_FLAGS (got_symbol) = SYMBOL_FLAG_LOCAL;
7537 }
7538
7539 start_sequence ();
7540
7541 if (TARGET_CPU_ZARCH)
7542 {
7543 emit_move_insn (pic_offset_table_rtx, got_symbol);
7544 }
7545 else
7546 {
7547 rtx offset;
7548
7549 offset = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, got_symbol),
7550 UNSPEC_LTREL_OFFSET);
7551 offset = gen_rtx_CONST (Pmode, offset);
7552 offset = force_const_mem (Pmode, offset);
7553
7554 emit_move_insn (pic_offset_table_rtx, offset);
7555
7556 offset = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, XEXP (offset, 0)),
7557 UNSPEC_LTREL_BASE);
7558 offset = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, offset);
7559
7560 emit_move_insn (pic_offset_table_rtx, offset);
7561 }
7562
7563 insns = get_insns ();
7564 end_sequence ();
7565 return insns;
7566 }
7567
7568 /* This ties together stack memory (MEM with an alias set of frame_alias_set)
7569 and the change to the stack pointer. */
7570
7571 static void
7572 s390_emit_stack_tie (void)
7573 {
7574 rtx mem = gen_frame_mem (BLKmode,
7575 gen_rtx_REG (Pmode, STACK_POINTER_REGNUM));
7576
7577 emit_insn (gen_stack_tie (mem));
7578 }
7579
7580 /* Expand the prologue into a bunch of separate insns. */
7581
7582 void
7583 s390_emit_prologue (void)
7584 {
7585 rtx insn, addr;
7586 rtx temp_reg;
7587 int i;
7588 int offset;
7589 int next_fpr = 0;
7590
7591 /* Complete frame layout. */
7592
7593 s390_update_frame_layout ();
7594
7595 /* Annotate all constant pool references to let the scheduler know
7596 they implicitly use the base register. */
7597
7598 push_topmost_sequence ();
7599
7600 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
7601 if (INSN_P (insn))
7602 {
7603 annotate_constant_pool_refs (&PATTERN (insn));
7604 df_insn_rescan (insn);
7605 }
7606
7607 pop_topmost_sequence ();
7608
7609 /* Choose best register to use for temp use within prologue.
7610 See below for why TPF must use the register 1. */
7611
7612 if (!has_hard_reg_initial_val (Pmode, RETURN_REGNUM)
7613 && !current_function_is_leaf
7614 && !TARGET_TPF_PROFILING)
7615 temp_reg = gen_rtx_REG (Pmode, RETURN_REGNUM);
7616 else
7617 temp_reg = gen_rtx_REG (Pmode, 1);
7618
7619 /* Save call saved gprs. */
7620 if (cfun_frame_layout.first_save_gpr != -1)
7621 {
7622 insn = save_gprs (stack_pointer_rtx,
7623 cfun_frame_layout.gprs_offset +
7624 UNITS_PER_WORD * (cfun_frame_layout.first_save_gpr
7625 - cfun_frame_layout.first_save_gpr_slot),
7626 cfun_frame_layout.first_save_gpr,
7627 cfun_frame_layout.last_save_gpr);
7628 emit_insn (insn);
7629 }
7630
7631 /* Dummy insn to mark literal pool slot. */
7632
7633 if (cfun->machine->base_reg)
7634 emit_insn (gen_main_pool (cfun->machine->base_reg));
7635
7636 offset = cfun_frame_layout.f0_offset;
7637
7638 /* Save f0 and f2. */
7639 for (i = 0; i < 2; i++)
7640 {
7641 if (cfun_fpr_bit_p (i))
7642 {
7643 save_fpr (stack_pointer_rtx, offset, i + 16);
7644 offset += 8;
7645 }
7646 else if (!TARGET_PACKED_STACK)
7647 offset += 8;
7648 }
7649
7650 /* Save f4 and f6. */
7651 offset = cfun_frame_layout.f4_offset;
7652 for (i = 2; i < 4; i++)
7653 {
7654 if (cfun_fpr_bit_p (i))
7655 {
7656 insn = save_fpr (stack_pointer_rtx, offset, i + 16);
7657 offset += 8;
7658
7659 /* If f4 and f6 are call clobbered they are saved due to stdargs and
7660 therefore are not frame related. */
7661 if (!call_really_used_regs[i + 16])
7662 RTX_FRAME_RELATED_P (insn) = 1;
7663 }
7664 else if (!TARGET_PACKED_STACK)
7665 offset += 8;
7666 }
7667
7668 if (TARGET_PACKED_STACK
7669 && cfun_save_high_fprs_p
7670 && cfun_frame_layout.f8_offset + cfun_frame_layout.high_fprs * 8 > 0)
7671 {
7672 offset = (cfun_frame_layout.f8_offset
7673 + (cfun_frame_layout.high_fprs - 1) * 8);
7674
7675 for (i = 15; i > 7 && offset >= 0; i--)
7676 if (cfun_fpr_bit_p (i))
7677 {
7678 insn = save_fpr (stack_pointer_rtx, offset, i + 16);
7679
7680 RTX_FRAME_RELATED_P (insn) = 1;
7681 offset -= 8;
7682 }
7683 if (offset >= cfun_frame_layout.f8_offset)
7684 next_fpr = i + 16;
7685 }
7686
7687 if (!TARGET_PACKED_STACK)
7688 next_fpr = cfun_save_high_fprs_p ? 31 : 0;
7689
7690 /* Decrement stack pointer. */
7691
7692 if (cfun_frame_layout.frame_size > 0)
7693 {
7694 rtx frame_off = GEN_INT (-cfun_frame_layout.frame_size);
7695
7696 if (s390_stack_size)
7697 {
7698 HOST_WIDE_INT stack_guard;
7699
7700 if (s390_stack_guard)
7701 stack_guard = s390_stack_guard;
7702 else
7703 {
7704 /* If no value for stack guard is provided the smallest power of 2
7705 larger than the current frame size is chosen. */
7706 stack_guard = 1;
7707 while (stack_guard < cfun_frame_layout.frame_size)
7708 stack_guard <<= 1;
7709 }
7710
7711 if (cfun_frame_layout.frame_size >= s390_stack_size)
7712 {
7713 warning (0, "frame size of function %qs is "
7714 HOST_WIDE_INT_PRINT_DEC
7715 " bytes exceeding user provided stack limit of "
7716 HOST_WIDE_INT_PRINT_DEC " bytes. "
7717 "An unconditional trap is added.",
7718 current_function_name(), cfun_frame_layout.frame_size,
7719 s390_stack_size);
7720 emit_insn (gen_trap ());
7721 }
7722 else
7723 {
7724 HOST_WIDE_INT stack_check_mask = ((s390_stack_size - 1)
7725 & ~(stack_guard - 1));
7726 rtx t = gen_rtx_AND (Pmode, stack_pointer_rtx,
7727 GEN_INT (stack_check_mask));
7728 if (TARGET_64BIT)
7729 gen_cmpdi (t, const0_rtx);
7730 else
7731 gen_cmpsi (t, const0_rtx);
7732
7733 emit_insn (gen_conditional_trap (gen_rtx_EQ (CCmode,
7734 gen_rtx_REG (CCmode,
7735 CC_REGNUM),
7736 const0_rtx),
7737 const0_rtx));
7738 }
7739 }
7740
7741 if (s390_warn_framesize > 0
7742 && cfun_frame_layout.frame_size >= s390_warn_framesize)
7743 warning (0, "frame size of %qs is " HOST_WIDE_INT_PRINT_DEC " bytes",
7744 current_function_name (), cfun_frame_layout.frame_size);
7745
7746 if (s390_warn_dynamicstack_p && cfun->calls_alloca)
7747 warning (0, "%qs uses dynamic stack allocation", current_function_name ());
7748
7749 /* Save incoming stack pointer into temp reg. */
7750 if (TARGET_BACKCHAIN || next_fpr)
7751 insn = emit_insn (gen_move_insn (temp_reg, stack_pointer_rtx));
7752
7753 /* Subtract frame size from stack pointer. */
7754
7755 if (DISP_IN_RANGE (INTVAL (frame_off)))
7756 {
7757 insn = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
7758 gen_rtx_PLUS (Pmode, stack_pointer_rtx,
7759 frame_off));
7760 insn = emit_insn (insn);
7761 }
7762 else
7763 {
7764 if (!CONST_OK_FOR_K (INTVAL (frame_off)))
7765 frame_off = force_const_mem (Pmode, frame_off);
7766
7767 insn = emit_insn (gen_add2_insn (stack_pointer_rtx, frame_off));
7768 annotate_constant_pool_refs (&PATTERN (insn));
7769 }
7770
7771 RTX_FRAME_RELATED_P (insn) = 1;
7772 REG_NOTES (insn) =
7773 gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
7774 gen_rtx_SET (VOIDmode, stack_pointer_rtx,
7775 gen_rtx_PLUS (Pmode, stack_pointer_rtx,
7776 GEN_INT (-cfun_frame_layout.frame_size))),
7777 REG_NOTES (insn));
7778
7779 /* Set backchain. */
7780
7781 if (TARGET_BACKCHAIN)
7782 {
7783 if (cfun_frame_layout.backchain_offset)
7784 addr = gen_rtx_MEM (Pmode,
7785 plus_constant (stack_pointer_rtx,
7786 cfun_frame_layout.backchain_offset));
7787 else
7788 addr = gen_rtx_MEM (Pmode, stack_pointer_rtx);
7789 set_mem_alias_set (addr, get_frame_alias_set ());
7790 insn = emit_insn (gen_move_insn (addr, temp_reg));
7791 }
7792
7793 /* If we support asynchronous exceptions (e.g. for Java),
7794 we need to make sure the backchain pointer is set up
7795 before any possibly trapping memory access. */
7796
7797 if (TARGET_BACKCHAIN && flag_non_call_exceptions)
7798 {
7799 addr = gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode));
7800 emit_clobber (addr);
7801 }
7802 }
7803
7804 /* Save fprs 8 - 15 (64 bit ABI). */
7805
7806 if (cfun_save_high_fprs_p && next_fpr)
7807 {
7808 /* If the stack might be accessed through a different register
7809 we have to make sure that the stack pointer decrement is not
7810 moved below the use of the stack slots. */
7811 s390_emit_stack_tie ();
7812
7813 insn = emit_insn (gen_add2_insn (temp_reg,
7814 GEN_INT (cfun_frame_layout.f8_offset)));
7815
7816 offset = 0;
7817
7818 for (i = 24; i <= next_fpr; i++)
7819 if (cfun_fpr_bit_p (i - 16))
7820 {
7821 rtx addr = plus_constant (stack_pointer_rtx,
7822 cfun_frame_layout.frame_size
7823 + cfun_frame_layout.f8_offset
7824 + offset);
7825
7826 insn = save_fpr (temp_reg, offset, i);
7827 offset += 8;
7828 RTX_FRAME_RELATED_P (insn) = 1;
7829 REG_NOTES (insn) =
7830 gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
7831 gen_rtx_SET (VOIDmode,
7832 gen_rtx_MEM (DFmode, addr),
7833 gen_rtx_REG (DFmode, i)),
7834 REG_NOTES (insn));
7835 }
7836 }
7837
7838 /* Set frame pointer, if needed. */
7839
7840 if (frame_pointer_needed)
7841 {
7842 insn = emit_move_insn (hard_frame_pointer_rtx, stack_pointer_rtx);
7843 RTX_FRAME_RELATED_P (insn) = 1;
7844 }
7845
7846 /* Set up got pointer, if needed. */
7847
7848 if (flag_pic && df_regs_ever_live_p (PIC_OFFSET_TABLE_REGNUM))
7849 {
7850 rtx insns = s390_load_got ();
7851
7852 for (insn = insns; insn; insn = NEXT_INSN (insn))
7853 annotate_constant_pool_refs (&PATTERN (insn));
7854
7855 emit_insn (insns);
7856 }
7857
7858 if (TARGET_TPF_PROFILING)
7859 {
7860 /* Generate a BAS instruction to serve as a function
7861 entry intercept to facilitate the use of tracing
7862 algorithms located at the branch target. */
7863 emit_insn (gen_prologue_tpf ());
7864
7865 /* Emit a blockage here so that all code
7866 lies between the profiling mechanisms. */
7867 emit_insn (gen_blockage ());
7868 }
7869 }
7870
7871 /* Expand the epilogue into a bunch of separate insns. */
7872
7873 void
7874 s390_emit_epilogue (bool sibcall)
7875 {
7876 rtx frame_pointer, return_reg;
7877 int area_bottom, area_top, offset = 0;
7878 int next_offset;
7879 rtvec p;
7880 int i;
7881
7882 if (TARGET_TPF_PROFILING)
7883 {
7884
7885 /* Generate a BAS instruction to serve as a function
7886 entry intercept to facilitate the use of tracing
7887 algorithms located at the branch target. */
7888
7889 /* Emit a blockage here so that all code
7890 lies between the profiling mechanisms. */
7891 emit_insn (gen_blockage ());
7892
7893 emit_insn (gen_epilogue_tpf ());
7894 }
7895
7896 /* Check whether to use frame or stack pointer for restore. */
7897
7898 frame_pointer = (frame_pointer_needed
7899 ? hard_frame_pointer_rtx : stack_pointer_rtx);
7900
7901 s390_frame_area (&area_bottom, &area_top);
7902
7903 /* Check whether we can access the register save area.
7904 If not, increment the frame pointer as required. */
7905
7906 if (area_top <= area_bottom)
7907 {
7908 /* Nothing to restore. */
7909 }
7910 else if (DISP_IN_RANGE (cfun_frame_layout.frame_size + area_bottom)
7911 && DISP_IN_RANGE (cfun_frame_layout.frame_size + area_top - 1))
7912 {
7913 /* Area is in range. */
7914 offset = cfun_frame_layout.frame_size;
7915 }
7916 else
7917 {
7918 rtx insn, frame_off;
7919
7920 offset = area_bottom < 0 ? -area_bottom : 0;
7921 frame_off = GEN_INT (cfun_frame_layout.frame_size - offset);
7922
7923 if (DISP_IN_RANGE (INTVAL (frame_off)))
7924 {
7925 insn = gen_rtx_SET (VOIDmode, frame_pointer,
7926 gen_rtx_PLUS (Pmode, frame_pointer, frame_off));
7927 insn = emit_insn (insn);
7928 }
7929 else
7930 {
7931 if (!CONST_OK_FOR_K (INTVAL (frame_off)))
7932 frame_off = force_const_mem (Pmode, frame_off);
7933
7934 insn = emit_insn (gen_add2_insn (frame_pointer, frame_off));
7935 annotate_constant_pool_refs (&PATTERN (insn));
7936 }
7937 }
7938
7939 /* Restore call saved fprs. */
7940
7941 if (TARGET_64BIT)
7942 {
7943 if (cfun_save_high_fprs_p)
7944 {
7945 next_offset = cfun_frame_layout.f8_offset;
7946 for (i = 24; i < 32; i++)
7947 {
7948 if (cfun_fpr_bit_p (i - 16))
7949 {
7950 restore_fpr (frame_pointer,
7951 offset + next_offset, i);
7952 next_offset += 8;
7953 }
7954 }
7955 }
7956
7957 }
7958 else
7959 {
7960 next_offset = cfun_frame_layout.f4_offset;
7961 for (i = 18; i < 20; i++)
7962 {
7963 if (cfun_fpr_bit_p (i - 16))
7964 {
7965 restore_fpr (frame_pointer,
7966 offset + next_offset, i);
7967 next_offset += 8;
7968 }
7969 else if (!TARGET_PACKED_STACK)
7970 next_offset += 8;
7971 }
7972
7973 }
7974
7975 /* Return register. */
7976
7977 return_reg = gen_rtx_REG (Pmode, RETURN_REGNUM);
7978
7979 /* Restore call saved gprs. */
7980
7981 if (cfun_frame_layout.first_restore_gpr != -1)
7982 {
7983 rtx insn, addr;
7984 int i;
7985
7986 /* Check for global register and save them
7987 to stack location from where they get restored. */
7988
7989 for (i = cfun_frame_layout.first_restore_gpr;
7990 i <= cfun_frame_layout.last_restore_gpr;
7991 i++)
7992 {
7993 /* These registers are special and need to be
7994 restored in any case. */
7995 if (i == STACK_POINTER_REGNUM
7996 || i == RETURN_REGNUM
7997 || i == BASE_REGNUM
7998 || (flag_pic && i == (int)PIC_OFFSET_TABLE_REGNUM))
7999 continue;
8000
8001 if (global_regs[i])
8002 {
8003 addr = plus_constant (frame_pointer,
8004 offset + cfun_frame_layout.gprs_offset
8005 + (i - cfun_frame_layout.first_save_gpr_slot)
8006 * UNITS_PER_WORD);
8007 addr = gen_rtx_MEM (Pmode, addr);
8008 set_mem_alias_set (addr, get_frame_alias_set ());
8009 emit_move_insn (addr, gen_rtx_REG (Pmode, i));
8010 }
8011 }
8012
8013 if (! sibcall)
8014 {
8015 /* Fetch return address from stack before load multiple,
8016 this will do good for scheduling. */
8017
8018 if (cfun_frame_layout.save_return_addr_p
8019 || (cfun_frame_layout.first_restore_gpr < BASE_REGNUM
8020 && cfun_frame_layout.last_restore_gpr > RETURN_REGNUM))
8021 {
8022 int return_regnum = find_unused_clobbered_reg();
8023 if (!return_regnum)
8024 return_regnum = 4;
8025 return_reg = gen_rtx_REG (Pmode, return_regnum);
8026
8027 addr = plus_constant (frame_pointer,
8028 offset + cfun_frame_layout.gprs_offset
8029 + (RETURN_REGNUM
8030 - cfun_frame_layout.first_save_gpr_slot)
8031 * UNITS_PER_WORD);
8032 addr = gen_rtx_MEM (Pmode, addr);
8033 set_mem_alias_set (addr, get_frame_alias_set ());
8034 emit_move_insn (return_reg, addr);
8035 }
8036 }
8037
8038 insn = restore_gprs (frame_pointer,
8039 offset + cfun_frame_layout.gprs_offset
8040 + (cfun_frame_layout.first_restore_gpr
8041 - cfun_frame_layout.first_save_gpr_slot)
8042 * UNITS_PER_WORD,
8043 cfun_frame_layout.first_restore_gpr,
8044 cfun_frame_layout.last_restore_gpr);
8045 emit_insn (insn);
8046 }
8047
8048 if (! sibcall)
8049 {
8050
8051 /* Return to caller. */
8052
8053 p = rtvec_alloc (2);
8054
8055 RTVEC_ELT (p, 0) = gen_rtx_RETURN (VOIDmode);
8056 RTVEC_ELT (p, 1) = gen_rtx_USE (VOIDmode, return_reg);
8057 emit_jump_insn (gen_rtx_PARALLEL (VOIDmode, p));
8058 }
8059 }
8060
8061
8062 /* Return the size in bytes of a function argument of
8063 type TYPE and/or mode MODE. At least one of TYPE or
8064 MODE must be specified. */
8065
8066 static int
8067 s390_function_arg_size (enum machine_mode mode, const_tree type)
8068 {
8069 if (type)
8070 return int_size_in_bytes (type);
8071
8072 /* No type info available for some library calls ... */
8073 if (mode != BLKmode)
8074 return GET_MODE_SIZE (mode);
8075
8076 /* If we have neither type nor mode, abort */
8077 gcc_unreachable ();
8078 }
8079
8080 /* Return true if a function argument of type TYPE and mode MODE
8081 is to be passed in a floating-point register, if available. */
8082
8083 static bool
8084 s390_function_arg_float (enum machine_mode mode, tree type)
8085 {
8086 int size = s390_function_arg_size (mode, type);
8087 if (size > 8)
8088 return false;
8089
8090 /* Soft-float changes the ABI: no floating-point registers are used. */
8091 if (TARGET_SOFT_FLOAT)
8092 return false;
8093
8094 /* No type info available for some library calls ... */
8095 if (!type)
8096 return mode == SFmode || mode == DFmode || mode == SDmode || mode == DDmode;
8097
8098 /* The ABI says that record types with a single member are treated
8099 just like that member would be. */
8100 while (TREE_CODE (type) == RECORD_TYPE)
8101 {
8102 tree field, single = NULL_TREE;
8103
8104 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
8105 {
8106 if (TREE_CODE (field) != FIELD_DECL)
8107 continue;
8108
8109 if (single == NULL_TREE)
8110 single = TREE_TYPE (field);
8111 else
8112 return false;
8113 }
8114
8115 if (single == NULL_TREE)
8116 return false;
8117 else
8118 type = single;
8119 }
8120
8121 return TREE_CODE (type) == REAL_TYPE;
8122 }
8123
8124 /* Return true if a function argument of type TYPE and mode MODE
8125 is to be passed in an integer register, or a pair of integer
8126 registers, if available. */
8127
8128 static bool
8129 s390_function_arg_integer (enum machine_mode mode, tree type)
8130 {
8131 int size = s390_function_arg_size (mode, type);
8132 if (size > 8)
8133 return false;
8134
8135 /* No type info available for some library calls ... */
8136 if (!type)
8137 return GET_MODE_CLASS (mode) == MODE_INT
8138 || (TARGET_SOFT_FLOAT && SCALAR_FLOAT_MODE_P (mode));
8139
8140 /* We accept small integral (and similar) types. */
8141 if (INTEGRAL_TYPE_P (type)
8142 || POINTER_TYPE_P (type)
8143 || TREE_CODE (type) == OFFSET_TYPE
8144 || (TARGET_SOFT_FLOAT && TREE_CODE (type) == REAL_TYPE))
8145 return true;
8146
8147 /* We also accept structs of size 1, 2, 4, 8 that are not
8148 passed in floating-point registers. */
8149 if (AGGREGATE_TYPE_P (type)
8150 && exact_log2 (size) >= 0
8151 && !s390_function_arg_float (mode, type))
8152 return true;
8153
8154 return false;
8155 }
8156
8157 /* Return 1 if a function argument of type TYPE and mode MODE
8158 is to be passed by reference. The ABI specifies that only
8159 structures of size 1, 2, 4, or 8 bytes are passed by value,
8160 all other structures (and complex numbers) are passed by
8161 reference. */
8162
8163 static bool
8164 s390_pass_by_reference (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
8165 enum machine_mode mode, const_tree type,
8166 bool named ATTRIBUTE_UNUSED)
8167 {
8168 int size = s390_function_arg_size (mode, type);
8169 if (size > 8)
8170 return true;
8171
8172 if (type)
8173 {
8174 if (AGGREGATE_TYPE_P (type) && exact_log2 (size) < 0)
8175 return 1;
8176
8177 if (TREE_CODE (type) == COMPLEX_TYPE
8178 || TREE_CODE (type) == VECTOR_TYPE)
8179 return 1;
8180 }
8181
8182 return 0;
8183 }
8184
8185 /* Update the data in CUM to advance over an argument of mode MODE and
8186 data type TYPE. (TYPE is null for libcalls where that information
8187 may not be available.). The boolean NAMED specifies whether the
8188 argument is a named argument (as opposed to an unnamed argument
8189 matching an ellipsis). */
8190
8191 void
8192 s390_function_arg_advance (CUMULATIVE_ARGS *cum, enum machine_mode mode,
8193 tree type, int named ATTRIBUTE_UNUSED)
8194 {
8195 if (s390_function_arg_float (mode, type))
8196 {
8197 cum->fprs += 1;
8198 }
8199 else if (s390_function_arg_integer (mode, type))
8200 {
8201 int size = s390_function_arg_size (mode, type);
8202 cum->gprs += ((size + UNITS_PER_WORD-1) / UNITS_PER_WORD);
8203 }
8204 else
8205 gcc_unreachable ();
8206 }
8207
8208 /* Define where to put the arguments to a function.
8209 Value is zero to push the argument on the stack,
8210 or a hard register in which to store the argument.
8211
8212 MODE is the argument's machine mode.
8213 TYPE is the data type of the argument (as a tree).
8214 This is null for libcalls where that information may
8215 not be available.
8216 CUM is a variable of type CUMULATIVE_ARGS which gives info about
8217 the preceding args and about the function being called.
8218 NAMED is nonzero if this argument is a named parameter
8219 (otherwise it is an extra parameter matching an ellipsis).
8220
8221 On S/390, we use general purpose registers 2 through 6 to
8222 pass integer, pointer, and certain structure arguments, and
8223 floating point registers 0 and 2 (0, 2, 4, and 6 on 64-bit)
8224 to pass floating point arguments. All remaining arguments
8225 are pushed to the stack. */
8226
8227 rtx
8228 s390_function_arg (CUMULATIVE_ARGS *cum, enum machine_mode mode, tree type,
8229 int named ATTRIBUTE_UNUSED)
8230 {
8231 if (s390_function_arg_float (mode, type))
8232 {
8233 if (cum->fprs + 1 > FP_ARG_NUM_REG)
8234 return 0;
8235 else
8236 return gen_rtx_REG (mode, cum->fprs + 16);
8237 }
8238 else if (s390_function_arg_integer (mode, type))
8239 {
8240 int size = s390_function_arg_size (mode, type);
8241 int n_gprs = (size + UNITS_PER_WORD-1) / UNITS_PER_WORD;
8242
8243 if (cum->gprs + n_gprs > GP_ARG_NUM_REG)
8244 return 0;
8245 else
8246 return gen_rtx_REG (mode, cum->gprs + 2);
8247 }
8248
8249 /* After the real arguments, expand_call calls us once again
8250 with a void_type_node type. Whatever we return here is
8251 passed as operand 2 to the call expanders.
8252
8253 We don't need this feature ... */
8254 else if (type == void_type_node)
8255 return const0_rtx;
8256
8257 gcc_unreachable ();
8258 }
8259
8260 /* Return true if return values of type TYPE should be returned
8261 in a memory buffer whose address is passed by the caller as
8262 hidden first argument. */
8263
8264 static bool
8265 s390_return_in_memory (const_tree type, const_tree fundecl ATTRIBUTE_UNUSED)
8266 {
8267 /* We accept small integral (and similar) types. */
8268 if (INTEGRAL_TYPE_P (type)
8269 || POINTER_TYPE_P (type)
8270 || TREE_CODE (type) == OFFSET_TYPE
8271 || TREE_CODE (type) == REAL_TYPE)
8272 return int_size_in_bytes (type) > 8;
8273
8274 /* Aggregates and similar constructs are always returned
8275 in memory. */
8276 if (AGGREGATE_TYPE_P (type)
8277 || TREE_CODE (type) == COMPLEX_TYPE
8278 || TREE_CODE (type) == VECTOR_TYPE)
8279 return true;
8280
8281 /* ??? We get called on all sorts of random stuff from
8282 aggregate_value_p. We can't abort, but it's not clear
8283 what's safe to return. Pretend it's a struct I guess. */
8284 return true;
8285 }
8286
8287 /* Define where to return a (scalar) value of type TYPE.
8288 If TYPE is null, define where to return a (scalar)
8289 value of mode MODE from a libcall. */
8290
8291 rtx
8292 s390_function_value (const_tree type, enum machine_mode mode)
8293 {
8294 if (type)
8295 {
8296 int unsignedp = TYPE_UNSIGNED (type);
8297 mode = promote_mode (type, TYPE_MODE (type), &unsignedp, 1);
8298 }
8299
8300 gcc_assert (GET_MODE_CLASS (mode) == MODE_INT || SCALAR_FLOAT_MODE_P (mode));
8301 gcc_assert (GET_MODE_SIZE (mode) <= 8);
8302
8303 if (TARGET_HARD_FLOAT && SCALAR_FLOAT_MODE_P (mode))
8304 return gen_rtx_REG (mode, 16);
8305 else
8306 return gen_rtx_REG (mode, 2);
8307 }
8308
8309
8310 /* Create and return the va_list datatype.
8311
8312 On S/390, va_list is an array type equivalent to
8313
8314 typedef struct __va_list_tag
8315 {
8316 long __gpr;
8317 long __fpr;
8318 void *__overflow_arg_area;
8319 void *__reg_save_area;
8320 } va_list[1];
8321
8322 where __gpr and __fpr hold the number of general purpose
8323 or floating point arguments used up to now, respectively,
8324 __overflow_arg_area points to the stack location of the
8325 next argument passed on the stack, and __reg_save_area
8326 always points to the start of the register area in the
8327 call frame of the current function. The function prologue
8328 saves all registers used for argument passing into this
8329 area if the function uses variable arguments. */
8330
8331 static tree
8332 s390_build_builtin_va_list (void)
8333 {
8334 tree f_gpr, f_fpr, f_ovf, f_sav, record, type_decl;
8335
8336 record = lang_hooks.types.make_type (RECORD_TYPE);
8337
8338 type_decl =
8339 build_decl (TYPE_DECL, get_identifier ("__va_list_tag"), record);
8340
8341 f_gpr = build_decl (FIELD_DECL, get_identifier ("__gpr"),
8342 long_integer_type_node);
8343 f_fpr = build_decl (FIELD_DECL, get_identifier ("__fpr"),
8344 long_integer_type_node);
8345 f_ovf = build_decl (FIELD_DECL, get_identifier ("__overflow_arg_area"),
8346 ptr_type_node);
8347 f_sav = build_decl (FIELD_DECL, get_identifier ("__reg_save_area"),
8348 ptr_type_node);
8349
8350 va_list_gpr_counter_field = f_gpr;
8351 va_list_fpr_counter_field = f_fpr;
8352
8353 DECL_FIELD_CONTEXT (f_gpr) = record;
8354 DECL_FIELD_CONTEXT (f_fpr) = record;
8355 DECL_FIELD_CONTEXT (f_ovf) = record;
8356 DECL_FIELD_CONTEXT (f_sav) = record;
8357
8358 TREE_CHAIN (record) = type_decl;
8359 TYPE_NAME (record) = type_decl;
8360 TYPE_FIELDS (record) = f_gpr;
8361 TREE_CHAIN (f_gpr) = f_fpr;
8362 TREE_CHAIN (f_fpr) = f_ovf;
8363 TREE_CHAIN (f_ovf) = f_sav;
8364
8365 layout_type (record);
8366
8367 /* The correct type is an array type of one element. */
8368 return build_array_type (record, build_index_type (size_zero_node));
8369 }
8370
8371 /* Implement va_start by filling the va_list structure VALIST.
8372 STDARG_P is always true, and ignored.
8373 NEXTARG points to the first anonymous stack argument.
8374
8375 The following global variables are used to initialize
8376 the va_list structure:
8377
8378 crtl->args.info:
8379 holds number of gprs and fprs used for named arguments.
8380 crtl->args.arg_offset_rtx:
8381 holds the offset of the first anonymous stack argument
8382 (relative to the virtual arg pointer). */
8383
8384 static void
8385 s390_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED)
8386 {
8387 HOST_WIDE_INT n_gpr, n_fpr;
8388 int off;
8389 tree f_gpr, f_fpr, f_ovf, f_sav;
8390 tree gpr, fpr, ovf, sav, t;
8391
8392 f_gpr = TYPE_FIELDS (TREE_TYPE (va_list_type_node));
8393 f_fpr = TREE_CHAIN (f_gpr);
8394 f_ovf = TREE_CHAIN (f_fpr);
8395 f_sav = TREE_CHAIN (f_ovf);
8396
8397 valist = build_va_arg_indirect_ref (valist);
8398 gpr = build3 (COMPONENT_REF, TREE_TYPE (f_gpr), valist, f_gpr, NULL_TREE);
8399 fpr = build3 (COMPONENT_REF, TREE_TYPE (f_fpr), valist, f_fpr, NULL_TREE);
8400 ovf = build3 (COMPONENT_REF, TREE_TYPE (f_ovf), valist, f_ovf, NULL_TREE);
8401 sav = build3 (COMPONENT_REF, TREE_TYPE (f_sav), valist, f_sav, NULL_TREE);
8402
8403 /* Count number of gp and fp argument registers used. */
8404
8405 n_gpr = crtl->args.info.gprs;
8406 n_fpr = crtl->args.info.fprs;
8407
8408 if (cfun->va_list_gpr_size)
8409 {
8410 t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (gpr), gpr,
8411 build_int_cst (NULL_TREE, n_gpr));
8412 TREE_SIDE_EFFECTS (t) = 1;
8413 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
8414 }
8415
8416 if (cfun->va_list_fpr_size)
8417 {
8418 t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (fpr), fpr,
8419 build_int_cst (NULL_TREE, n_fpr));
8420 TREE_SIDE_EFFECTS (t) = 1;
8421 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
8422 }
8423
8424 /* Find the overflow area. */
8425 if (n_gpr + cfun->va_list_gpr_size > GP_ARG_NUM_REG
8426 || n_fpr + cfun->va_list_fpr_size > FP_ARG_NUM_REG)
8427 {
8428 t = make_tree (TREE_TYPE (ovf), virtual_incoming_args_rtx);
8429
8430 off = INTVAL (crtl->args.arg_offset_rtx);
8431 off = off < 0 ? 0 : off;
8432 if (TARGET_DEBUG_ARG)
8433 fprintf (stderr, "va_start: n_gpr = %d, n_fpr = %d off %d\n",
8434 (int)n_gpr, (int)n_fpr, off);
8435
8436 t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (ovf), t, size_int (off));
8437
8438 t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (ovf), ovf, t);
8439 TREE_SIDE_EFFECTS (t) = 1;
8440 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
8441 }
8442
8443 /* Find the register save area. */
8444 if ((cfun->va_list_gpr_size && n_gpr < GP_ARG_NUM_REG)
8445 || (cfun->va_list_fpr_size && n_fpr < FP_ARG_NUM_REG))
8446 {
8447 t = make_tree (TREE_TYPE (sav), return_address_pointer_rtx);
8448 t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (sav), t,
8449 size_int (-RETURN_REGNUM * UNITS_PER_WORD));
8450
8451 t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (sav), sav, t);
8452 TREE_SIDE_EFFECTS (t) = 1;
8453 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
8454 }
8455 }
8456
8457 /* Implement va_arg by updating the va_list structure
8458 VALIST as required to retrieve an argument of type
8459 TYPE, and returning that argument.
8460
8461 Generates code equivalent to:
8462
8463 if (integral value) {
8464 if (size <= 4 && args.gpr < 5 ||
8465 size > 4 && args.gpr < 4 )
8466 ret = args.reg_save_area[args.gpr+8]
8467 else
8468 ret = *args.overflow_arg_area++;
8469 } else if (float value) {
8470 if (args.fgpr < 2)
8471 ret = args.reg_save_area[args.fpr+64]
8472 else
8473 ret = *args.overflow_arg_area++;
8474 } else if (aggregate value) {
8475 if (args.gpr < 5)
8476 ret = *args.reg_save_area[args.gpr]
8477 else
8478 ret = **args.overflow_arg_area++;
8479 } */
8480
8481 static tree
8482 s390_gimplify_va_arg (tree valist, tree type, tree *pre_p,
8483 tree *post_p ATTRIBUTE_UNUSED)
8484 {
8485 tree f_gpr, f_fpr, f_ovf, f_sav;
8486 tree gpr, fpr, ovf, sav, reg, t, u;
8487 int indirect_p, size, n_reg, sav_ofs, sav_scale, max_reg;
8488 tree lab_false, lab_over, addr;
8489
8490 f_gpr = TYPE_FIELDS (TREE_TYPE (va_list_type_node));
8491 f_fpr = TREE_CHAIN (f_gpr);
8492 f_ovf = TREE_CHAIN (f_fpr);
8493 f_sav = TREE_CHAIN (f_ovf);
8494
8495 valist = build_va_arg_indirect_ref (valist);
8496 gpr = build3 (COMPONENT_REF, TREE_TYPE (f_gpr), valist, f_gpr, NULL_TREE);
8497 fpr = build3 (COMPONENT_REF, TREE_TYPE (f_fpr), valist, f_fpr, NULL_TREE);
8498 ovf = build3 (COMPONENT_REF, TREE_TYPE (f_ovf), valist, f_ovf, NULL_TREE);
8499 sav = build3 (COMPONENT_REF, TREE_TYPE (f_sav), valist, f_sav, NULL_TREE);
8500
8501 size = int_size_in_bytes (type);
8502
8503 if (pass_by_reference (NULL, TYPE_MODE (type), type, false))
8504 {
8505 if (TARGET_DEBUG_ARG)
8506 {
8507 fprintf (stderr, "va_arg: aggregate type");
8508 debug_tree (type);
8509 }
8510
8511 /* Aggregates are passed by reference. */
8512 indirect_p = 1;
8513 reg = gpr;
8514 n_reg = 1;
8515
8516 /* kernel stack layout on 31 bit: It is assumed here that no padding
8517 will be added by s390_frame_info because for va_args always an even
8518 number of gprs has to be saved r15-r2 = 14 regs. */
8519 sav_ofs = 2 * UNITS_PER_WORD;
8520 sav_scale = UNITS_PER_WORD;
8521 size = UNITS_PER_WORD;
8522 max_reg = GP_ARG_NUM_REG - n_reg;
8523 }
8524 else if (s390_function_arg_float (TYPE_MODE (type), type))
8525 {
8526 if (TARGET_DEBUG_ARG)
8527 {
8528 fprintf (stderr, "va_arg: float type");
8529 debug_tree (type);
8530 }
8531
8532 /* FP args go in FP registers, if present. */
8533 indirect_p = 0;
8534 reg = fpr;
8535 n_reg = 1;
8536 sav_ofs = 16 * UNITS_PER_WORD;
8537 sav_scale = 8;
8538 max_reg = FP_ARG_NUM_REG - n_reg;
8539 }
8540 else
8541 {
8542 if (TARGET_DEBUG_ARG)
8543 {
8544 fprintf (stderr, "va_arg: other type");
8545 debug_tree (type);
8546 }
8547
8548 /* Otherwise into GP registers. */
8549 indirect_p = 0;
8550 reg = gpr;
8551 n_reg = (size + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
8552
8553 /* kernel stack layout on 31 bit: It is assumed here that no padding
8554 will be added by s390_frame_info because for va_args always an even
8555 number of gprs has to be saved r15-r2 = 14 regs. */
8556 sav_ofs = 2 * UNITS_PER_WORD;
8557
8558 if (size < UNITS_PER_WORD)
8559 sav_ofs += UNITS_PER_WORD - size;
8560
8561 sav_scale = UNITS_PER_WORD;
8562 max_reg = GP_ARG_NUM_REG - n_reg;
8563 }
8564
8565 /* Pull the value out of the saved registers ... */
8566
8567 lab_false = create_artificial_label ();
8568 lab_over = create_artificial_label ();
8569 addr = create_tmp_var (ptr_type_node, "addr");
8570 DECL_POINTER_ALIAS_SET (addr) = get_varargs_alias_set ();
8571
8572 t = fold_convert (TREE_TYPE (reg), size_int (max_reg));
8573 t = build2 (GT_EXPR, boolean_type_node, reg, t);
8574 u = build1 (GOTO_EXPR, void_type_node, lab_false);
8575 t = build3 (COND_EXPR, void_type_node, t, u, NULL_TREE);
8576 gimplify_and_add (t, pre_p);
8577
8578 t = build2 (POINTER_PLUS_EXPR, ptr_type_node, sav,
8579 size_int (sav_ofs));
8580 u = build2 (MULT_EXPR, TREE_TYPE (reg), reg,
8581 fold_convert (TREE_TYPE (reg), size_int (sav_scale)));
8582 t = build2 (POINTER_PLUS_EXPR, ptr_type_node, t, fold_convert (sizetype, u));
8583
8584 t = build2 (GIMPLE_MODIFY_STMT, void_type_node, addr, t);
8585 gimplify_and_add (t, pre_p);
8586
8587 t = build1 (GOTO_EXPR, void_type_node, lab_over);
8588 gimplify_and_add (t, pre_p);
8589
8590 t = build1 (LABEL_EXPR, void_type_node, lab_false);
8591 append_to_statement_list (t, pre_p);
8592
8593
8594 /* ... Otherwise out of the overflow area. */
8595
8596 t = ovf;
8597 if (size < UNITS_PER_WORD)
8598 t = build2 (POINTER_PLUS_EXPR, ptr_type_node, t,
8599 size_int (UNITS_PER_WORD - size));
8600
8601 gimplify_expr (&t, pre_p, NULL, is_gimple_val, fb_rvalue);
8602
8603 u = build2 (GIMPLE_MODIFY_STMT, void_type_node, addr, t);
8604 gimplify_and_add (u, pre_p);
8605
8606 t = build2 (POINTER_PLUS_EXPR, ptr_type_node, t,
8607 size_int (size));
8608 t = build2 (GIMPLE_MODIFY_STMT, ptr_type_node, ovf, t);
8609 gimplify_and_add (t, pre_p);
8610
8611 t = build1 (LABEL_EXPR, void_type_node, lab_over);
8612 append_to_statement_list (t, pre_p);
8613
8614
8615 /* Increment register save count. */
8616
8617 u = build2 (PREINCREMENT_EXPR, TREE_TYPE (reg), reg,
8618 fold_convert (TREE_TYPE (reg), size_int (n_reg)));
8619 gimplify_and_add (u, pre_p);
8620
8621 if (indirect_p)
8622 {
8623 t = build_pointer_type (build_pointer_type (type));
8624 addr = fold_convert (t, addr);
8625 addr = build_va_arg_indirect_ref (addr);
8626 }
8627 else
8628 {
8629 t = build_pointer_type (type);
8630 addr = fold_convert (t, addr);
8631 }
8632
8633 return build_va_arg_indirect_ref (addr);
8634 }
8635
8636
8637 /* Builtins. */
8638
8639 enum s390_builtin
8640 {
8641 S390_BUILTIN_THREAD_POINTER,
8642 S390_BUILTIN_SET_THREAD_POINTER,
8643
8644 S390_BUILTIN_max
8645 };
8646
8647 static unsigned int const code_for_builtin_64[S390_BUILTIN_max] = {
8648 CODE_FOR_get_tp_64,
8649 CODE_FOR_set_tp_64
8650 };
8651
8652 static unsigned int const code_for_builtin_31[S390_BUILTIN_max] = {
8653 CODE_FOR_get_tp_31,
8654 CODE_FOR_set_tp_31
8655 };
8656
8657 static void
8658 s390_init_builtins (void)
8659 {
8660 tree ftype;
8661
8662 ftype = build_function_type (ptr_type_node, void_list_node);
8663 add_builtin_function ("__builtin_thread_pointer", ftype,
8664 S390_BUILTIN_THREAD_POINTER, BUILT_IN_MD,
8665 NULL, NULL_TREE);
8666
8667 ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
8668 add_builtin_function ("__builtin_set_thread_pointer", ftype,
8669 S390_BUILTIN_SET_THREAD_POINTER, BUILT_IN_MD,
8670 NULL, NULL_TREE);
8671 }
8672
8673 /* Expand an expression EXP that calls a built-in function,
8674 with result going to TARGET if that's convenient
8675 (and in mode MODE if that's convenient).
8676 SUBTARGET may be used as the target for computing one of EXP's operands.
8677 IGNORE is nonzero if the value is to be ignored. */
8678
8679 static rtx
8680 s390_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED,
8681 enum machine_mode mode ATTRIBUTE_UNUSED,
8682 int ignore ATTRIBUTE_UNUSED)
8683 {
8684 #define MAX_ARGS 2
8685
8686 unsigned int const *code_for_builtin =
8687 TARGET_64BIT ? code_for_builtin_64 : code_for_builtin_31;
8688
8689 tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
8690 unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
8691 enum insn_code icode;
8692 rtx op[MAX_ARGS], pat;
8693 int arity;
8694 bool nonvoid;
8695 tree arg;
8696 call_expr_arg_iterator iter;
8697
8698 if (fcode >= S390_BUILTIN_max)
8699 internal_error ("bad builtin fcode");
8700 icode = code_for_builtin[fcode];
8701 if (icode == 0)
8702 internal_error ("bad builtin fcode");
8703
8704 nonvoid = TREE_TYPE (TREE_TYPE (fndecl)) != void_type_node;
8705
8706 arity = 0;
8707 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
8708 {
8709 const struct insn_operand_data *insn_op;
8710
8711 if (arg == error_mark_node)
8712 return NULL_RTX;
8713 if (arity > MAX_ARGS)
8714 return NULL_RTX;
8715
8716 insn_op = &insn_data[icode].operand[arity + nonvoid];
8717
8718 op[arity] = expand_expr (arg, NULL_RTX, insn_op->mode, 0);
8719
8720 if (!(*insn_op->predicate) (op[arity], insn_op->mode))
8721 op[arity] = copy_to_mode_reg (insn_op->mode, op[arity]);
8722 arity++;
8723 }
8724
8725 if (nonvoid)
8726 {
8727 enum machine_mode tmode = insn_data[icode].operand[0].mode;
8728 if (!target
8729 || GET_MODE (target) != tmode
8730 || !(*insn_data[icode].operand[0].predicate) (target, tmode))
8731 target = gen_reg_rtx (tmode);
8732 }
8733
8734 switch (arity)
8735 {
8736 case 0:
8737 pat = GEN_FCN (icode) (target);
8738 break;
8739 case 1:
8740 if (nonvoid)
8741 pat = GEN_FCN (icode) (target, op[0]);
8742 else
8743 pat = GEN_FCN (icode) (op[0]);
8744 break;
8745 case 2:
8746 pat = GEN_FCN (icode) (target, op[0], op[1]);
8747 break;
8748 default:
8749 gcc_unreachable ();
8750 }
8751 if (!pat)
8752 return NULL_RTX;
8753 emit_insn (pat);
8754
8755 if (nonvoid)
8756 return target;
8757 else
8758 return const0_rtx;
8759 }
8760
8761
8762 /* Output assembly code for the trampoline template to
8763 stdio stream FILE.
8764
8765 On S/390, we use gpr 1 internally in the trampoline code;
8766 gpr 0 is used to hold the static chain. */
8767
8768 void
8769 s390_trampoline_template (FILE *file)
8770 {
8771 rtx op[2];
8772 op[0] = gen_rtx_REG (Pmode, 0);
8773 op[1] = gen_rtx_REG (Pmode, 1);
8774
8775 if (TARGET_64BIT)
8776 {
8777 output_asm_insn ("basr\t%1,0", op);
8778 output_asm_insn ("lmg\t%0,%1,14(%1)", op);
8779 output_asm_insn ("br\t%1", op);
8780 ASM_OUTPUT_SKIP (file, (HOST_WIDE_INT)(TRAMPOLINE_SIZE - 10));
8781 }
8782 else
8783 {
8784 output_asm_insn ("basr\t%1,0", op);
8785 output_asm_insn ("lm\t%0,%1,6(%1)", op);
8786 output_asm_insn ("br\t%1", op);
8787 ASM_OUTPUT_SKIP (file, (HOST_WIDE_INT)(TRAMPOLINE_SIZE - 8));
8788 }
8789 }
8790
8791 /* Emit RTL insns to initialize the variable parts of a trampoline.
8792 FNADDR is an RTX for the address of the function's pure code.
8793 CXT is an RTX for the static chain value for the function. */
8794
8795 void
8796 s390_initialize_trampoline (rtx addr, rtx fnaddr, rtx cxt)
8797 {
8798 emit_move_insn (gen_rtx_MEM (Pmode,
8799 memory_address (Pmode,
8800 plus_constant (addr, (TARGET_64BIT ? 16 : 8)))), cxt);
8801 emit_move_insn (gen_rtx_MEM (Pmode,
8802 memory_address (Pmode,
8803 plus_constant (addr, (TARGET_64BIT ? 24 : 12)))), fnaddr);
8804 }
8805
8806 /* Output assembler code to FILE to increment profiler label # LABELNO
8807 for profiling a function entry. */
8808
8809 void
8810 s390_function_profiler (FILE *file, int labelno)
8811 {
8812 rtx op[7];
8813
8814 char label[128];
8815 ASM_GENERATE_INTERNAL_LABEL (label, "LP", labelno);
8816
8817 fprintf (file, "# function profiler \n");
8818
8819 op[0] = gen_rtx_REG (Pmode, RETURN_REGNUM);
8820 op[1] = gen_rtx_REG (Pmode, STACK_POINTER_REGNUM);
8821 op[1] = gen_rtx_MEM (Pmode, plus_constant (op[1], UNITS_PER_WORD));
8822
8823 op[2] = gen_rtx_REG (Pmode, 1);
8824 op[3] = gen_rtx_SYMBOL_REF (Pmode, label);
8825 SYMBOL_REF_FLAGS (op[3]) = SYMBOL_FLAG_LOCAL;
8826
8827 op[4] = gen_rtx_SYMBOL_REF (Pmode, "_mcount");
8828 if (flag_pic)
8829 {
8830 op[4] = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, op[4]), UNSPEC_PLT);
8831 op[4] = gen_rtx_CONST (Pmode, op[4]);
8832 }
8833
8834 if (TARGET_64BIT)
8835 {
8836 output_asm_insn ("stg\t%0,%1", op);
8837 output_asm_insn ("larl\t%2,%3", op);
8838 output_asm_insn ("brasl\t%0,%4", op);
8839 output_asm_insn ("lg\t%0,%1", op);
8840 }
8841 else if (!flag_pic)
8842 {
8843 op[6] = gen_label_rtx ();
8844
8845 output_asm_insn ("st\t%0,%1", op);
8846 output_asm_insn ("bras\t%2,%l6", op);
8847 output_asm_insn (".long\t%4", op);
8848 output_asm_insn (".long\t%3", op);
8849 targetm.asm_out.internal_label (file, "L", CODE_LABEL_NUMBER (op[6]));
8850 output_asm_insn ("l\t%0,0(%2)", op);
8851 output_asm_insn ("l\t%2,4(%2)", op);
8852 output_asm_insn ("basr\t%0,%0", op);
8853 output_asm_insn ("l\t%0,%1", op);
8854 }
8855 else
8856 {
8857 op[5] = gen_label_rtx ();
8858 op[6] = gen_label_rtx ();
8859
8860 output_asm_insn ("st\t%0,%1", op);
8861 output_asm_insn ("bras\t%2,%l6", op);
8862 targetm.asm_out.internal_label (file, "L", CODE_LABEL_NUMBER (op[5]));
8863 output_asm_insn (".long\t%4-%l5", op);
8864 output_asm_insn (".long\t%3-%l5", op);
8865 targetm.asm_out.internal_label (file, "L", CODE_LABEL_NUMBER (op[6]));
8866 output_asm_insn ("lr\t%0,%2", op);
8867 output_asm_insn ("a\t%0,0(%2)", op);
8868 output_asm_insn ("a\t%2,4(%2)", op);
8869 output_asm_insn ("basr\t%0,%0", op);
8870 output_asm_insn ("l\t%0,%1", op);
8871 }
8872 }
8873
8874 /* Encode symbol attributes (local vs. global, tls model) of a SYMBOL_REF
8875 into its SYMBOL_REF_FLAGS. */
8876
8877 static void
8878 s390_encode_section_info (tree decl, rtx rtl, int first)
8879 {
8880 default_encode_section_info (decl, rtl, first);
8881
8882 if (TREE_CODE (decl) == VAR_DECL)
8883 {
8884 /* If a variable has a forced alignment to < 2 bytes, mark it
8885 with SYMBOL_FLAG_ALIGN1 to prevent it from being used as LARL
8886 operand. */
8887 if (DECL_USER_ALIGN (decl) && DECL_ALIGN (decl) < 16)
8888 SYMBOL_REF_FLAGS (XEXP (rtl, 0)) |= SYMBOL_FLAG_ALIGN1;
8889 if (!DECL_SIZE (decl)
8890 || !DECL_ALIGN (decl)
8891 || !host_integerp (DECL_SIZE (decl), 0)
8892 || (DECL_ALIGN (decl) <= 64
8893 && DECL_ALIGN (decl) != tree_low_cst (DECL_SIZE (decl), 0)))
8894 SYMBOL_REF_FLAGS (XEXP (rtl, 0)) |= SYMBOL_FLAG_NOT_NATURALLY_ALIGNED;
8895 }
8896
8897 /* Literal pool references don't have a decl so they are handled
8898 differently here. We rely on the information in the MEM_ALIGN
8899 entry to decide upon natural alignment. */
8900 if (MEM_P (rtl)
8901 && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
8902 && TREE_CONSTANT_POOL_ADDRESS_P (XEXP (rtl, 0))
8903 && (MEM_ALIGN (rtl) == 0
8904 || MEM_ALIGN (rtl) < GET_MODE_BITSIZE (GET_MODE (rtl))))
8905 SYMBOL_REF_FLAGS (XEXP (rtl, 0)) |= SYMBOL_FLAG_NOT_NATURALLY_ALIGNED;
8906 }
8907
8908 /* Output thunk to FILE that implements a C++ virtual function call (with
8909 multiple inheritance) to FUNCTION. The thunk adjusts the this pointer
8910 by DELTA, and unless VCALL_OFFSET is zero, applies an additional adjustment
8911 stored at VCALL_OFFSET in the vtable whose address is located at offset 0
8912 relative to the resulting this pointer. */
8913
8914 static void
8915 s390_output_mi_thunk (FILE *file, tree thunk ATTRIBUTE_UNUSED,
8916 HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset,
8917 tree function)
8918 {
8919 rtx op[10];
8920 int nonlocal = 0;
8921
8922 /* Operand 0 is the target function. */
8923 op[0] = XEXP (DECL_RTL (function), 0);
8924 if (flag_pic && !SYMBOL_REF_LOCAL_P (op[0]))
8925 {
8926 nonlocal = 1;
8927 op[0] = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, op[0]),
8928 TARGET_64BIT ? UNSPEC_PLT : UNSPEC_GOT);
8929 op[0] = gen_rtx_CONST (Pmode, op[0]);
8930 }
8931
8932 /* Operand 1 is the 'this' pointer. */
8933 if (aggregate_value_p (TREE_TYPE (TREE_TYPE (function)), function))
8934 op[1] = gen_rtx_REG (Pmode, 3);
8935 else
8936 op[1] = gen_rtx_REG (Pmode, 2);
8937
8938 /* Operand 2 is the delta. */
8939 op[2] = GEN_INT (delta);
8940
8941 /* Operand 3 is the vcall_offset. */
8942 op[3] = GEN_INT (vcall_offset);
8943
8944 /* Operand 4 is the temporary register. */
8945 op[4] = gen_rtx_REG (Pmode, 1);
8946
8947 /* Operands 5 to 8 can be used as labels. */
8948 op[5] = NULL_RTX;
8949 op[6] = NULL_RTX;
8950 op[7] = NULL_RTX;
8951 op[8] = NULL_RTX;
8952
8953 /* Operand 9 can be used for temporary register. */
8954 op[9] = NULL_RTX;
8955
8956 /* Generate code. */
8957 if (TARGET_64BIT)
8958 {
8959 /* Setup literal pool pointer if required. */
8960 if ((!DISP_IN_RANGE (delta)
8961 && !CONST_OK_FOR_K (delta)
8962 && !CONST_OK_FOR_Os (delta))
8963 || (!DISP_IN_RANGE (vcall_offset)
8964 && !CONST_OK_FOR_K (vcall_offset)
8965 && !CONST_OK_FOR_Os (vcall_offset)))
8966 {
8967 op[5] = gen_label_rtx ();
8968 output_asm_insn ("larl\t%4,%5", op);
8969 }
8970
8971 /* Add DELTA to this pointer. */
8972 if (delta)
8973 {
8974 if (CONST_OK_FOR_J (delta))
8975 output_asm_insn ("la\t%1,%2(%1)", op);
8976 else if (DISP_IN_RANGE (delta))
8977 output_asm_insn ("lay\t%1,%2(%1)", op);
8978 else if (CONST_OK_FOR_K (delta))
8979 output_asm_insn ("aghi\t%1,%2", op);
8980 else if (CONST_OK_FOR_Os (delta))
8981 output_asm_insn ("agfi\t%1,%2", op);
8982 else
8983 {
8984 op[6] = gen_label_rtx ();
8985 output_asm_insn ("agf\t%1,%6-%5(%4)", op);
8986 }
8987 }
8988
8989 /* Perform vcall adjustment. */
8990 if (vcall_offset)
8991 {
8992 if (DISP_IN_RANGE (vcall_offset))
8993 {
8994 output_asm_insn ("lg\t%4,0(%1)", op);
8995 output_asm_insn ("ag\t%1,%3(%4)", op);
8996 }
8997 else if (CONST_OK_FOR_K (vcall_offset))
8998 {
8999 output_asm_insn ("lghi\t%4,%3", op);
9000 output_asm_insn ("ag\t%4,0(%1)", op);
9001 output_asm_insn ("ag\t%1,0(%4)", op);
9002 }
9003 else if (CONST_OK_FOR_Os (vcall_offset))
9004 {
9005 output_asm_insn ("lgfi\t%4,%3", op);
9006 output_asm_insn ("ag\t%4,0(%1)", op);
9007 output_asm_insn ("ag\t%1,0(%4)", op);
9008 }
9009 else
9010 {
9011 op[7] = gen_label_rtx ();
9012 output_asm_insn ("llgf\t%4,%7-%5(%4)", op);
9013 output_asm_insn ("ag\t%4,0(%1)", op);
9014 output_asm_insn ("ag\t%1,0(%4)", op);
9015 }
9016 }
9017
9018 /* Jump to target. */
9019 output_asm_insn ("jg\t%0", op);
9020
9021 /* Output literal pool if required. */
9022 if (op[5])
9023 {
9024 output_asm_insn (".align\t4", op);
9025 targetm.asm_out.internal_label (file, "L",
9026 CODE_LABEL_NUMBER (op[5]));
9027 }
9028 if (op[6])
9029 {
9030 targetm.asm_out.internal_label (file, "L",
9031 CODE_LABEL_NUMBER (op[6]));
9032 output_asm_insn (".long\t%2", op);
9033 }
9034 if (op[7])
9035 {
9036 targetm.asm_out.internal_label (file, "L",
9037 CODE_LABEL_NUMBER (op[7]));
9038 output_asm_insn (".long\t%3", op);
9039 }
9040 }
9041 else
9042 {
9043 /* Setup base pointer if required. */
9044 if (!vcall_offset
9045 || (!DISP_IN_RANGE (delta)
9046 && !CONST_OK_FOR_K (delta)
9047 && !CONST_OK_FOR_Os (delta))
9048 || (!DISP_IN_RANGE (delta)
9049 && !CONST_OK_FOR_K (vcall_offset)
9050 && !CONST_OK_FOR_Os (vcall_offset)))
9051 {
9052 op[5] = gen_label_rtx ();
9053 output_asm_insn ("basr\t%4,0", op);
9054 targetm.asm_out.internal_label (file, "L",
9055 CODE_LABEL_NUMBER (op[5]));
9056 }
9057
9058 /* Add DELTA to this pointer. */
9059 if (delta)
9060 {
9061 if (CONST_OK_FOR_J (delta))
9062 output_asm_insn ("la\t%1,%2(%1)", op);
9063 else if (DISP_IN_RANGE (delta))
9064 output_asm_insn ("lay\t%1,%2(%1)", op);
9065 else if (CONST_OK_FOR_K (delta))
9066 output_asm_insn ("ahi\t%1,%2", op);
9067 else if (CONST_OK_FOR_Os (delta))
9068 output_asm_insn ("afi\t%1,%2", op);
9069 else
9070 {
9071 op[6] = gen_label_rtx ();
9072 output_asm_insn ("a\t%1,%6-%5(%4)", op);
9073 }
9074 }
9075
9076 /* Perform vcall adjustment. */
9077 if (vcall_offset)
9078 {
9079 if (CONST_OK_FOR_J (vcall_offset))
9080 {
9081 output_asm_insn ("l\t%4,0(%1)", op);
9082 output_asm_insn ("a\t%1,%3(%4)", op);
9083 }
9084 else if (DISP_IN_RANGE (vcall_offset))
9085 {
9086 output_asm_insn ("l\t%4,0(%1)", op);
9087 output_asm_insn ("ay\t%1,%3(%4)", op);
9088 }
9089 else if (CONST_OK_FOR_K (vcall_offset))
9090 {
9091 output_asm_insn ("lhi\t%4,%3", op);
9092 output_asm_insn ("a\t%4,0(%1)", op);
9093 output_asm_insn ("a\t%1,0(%4)", op);
9094 }
9095 else if (CONST_OK_FOR_Os (vcall_offset))
9096 {
9097 output_asm_insn ("iilf\t%4,%3", op);
9098 output_asm_insn ("a\t%4,0(%1)", op);
9099 output_asm_insn ("a\t%1,0(%4)", op);
9100 }
9101 else
9102 {
9103 op[7] = gen_label_rtx ();
9104 output_asm_insn ("l\t%4,%7-%5(%4)", op);
9105 output_asm_insn ("a\t%4,0(%1)", op);
9106 output_asm_insn ("a\t%1,0(%4)", op);
9107 }
9108
9109 /* We had to clobber the base pointer register.
9110 Re-setup the base pointer (with a different base). */
9111 op[5] = gen_label_rtx ();
9112 output_asm_insn ("basr\t%4,0", op);
9113 targetm.asm_out.internal_label (file, "L",
9114 CODE_LABEL_NUMBER (op[5]));
9115 }
9116
9117 /* Jump to target. */
9118 op[8] = gen_label_rtx ();
9119
9120 if (!flag_pic)
9121 output_asm_insn ("l\t%4,%8-%5(%4)", op);
9122 else if (!nonlocal)
9123 output_asm_insn ("a\t%4,%8-%5(%4)", op);
9124 /* We cannot call through .plt, since .plt requires %r12 loaded. */
9125 else if (flag_pic == 1)
9126 {
9127 output_asm_insn ("a\t%4,%8-%5(%4)", op);
9128 output_asm_insn ("l\t%4,%0(%4)", op);
9129 }
9130 else if (flag_pic == 2)
9131 {
9132 op[9] = gen_rtx_REG (Pmode, 0);
9133 output_asm_insn ("l\t%9,%8-4-%5(%4)", op);
9134 output_asm_insn ("a\t%4,%8-%5(%4)", op);
9135 output_asm_insn ("ar\t%4,%9", op);
9136 output_asm_insn ("l\t%4,0(%4)", op);
9137 }
9138
9139 output_asm_insn ("br\t%4", op);
9140
9141 /* Output literal pool. */
9142 output_asm_insn (".align\t4", op);
9143
9144 if (nonlocal && flag_pic == 2)
9145 output_asm_insn (".long\t%0", op);
9146 if (nonlocal)
9147 {
9148 op[0] = gen_rtx_SYMBOL_REF (Pmode, "_GLOBAL_OFFSET_TABLE_");
9149 SYMBOL_REF_FLAGS (op[0]) = SYMBOL_FLAG_LOCAL;
9150 }
9151
9152 targetm.asm_out.internal_label (file, "L", CODE_LABEL_NUMBER (op[8]));
9153 if (!flag_pic)
9154 output_asm_insn (".long\t%0", op);
9155 else
9156 output_asm_insn (".long\t%0-%5", op);
9157
9158 if (op[6])
9159 {
9160 targetm.asm_out.internal_label (file, "L",
9161 CODE_LABEL_NUMBER (op[6]));
9162 output_asm_insn (".long\t%2", op);
9163 }
9164 if (op[7])
9165 {
9166 targetm.asm_out.internal_label (file, "L",
9167 CODE_LABEL_NUMBER (op[7]));
9168 output_asm_insn (".long\t%3", op);
9169 }
9170 }
9171 }
9172
9173 static bool
9174 s390_valid_pointer_mode (enum machine_mode mode)
9175 {
9176 return (mode == SImode || (TARGET_64BIT && mode == DImode));
9177 }
9178
9179 /* Checks whether the given CALL_EXPR would use a caller
9180 saved register. This is used to decide whether sibling call
9181 optimization could be performed on the respective function
9182 call. */
9183
9184 static bool
9185 s390_call_saved_register_used (tree call_expr)
9186 {
9187 CUMULATIVE_ARGS cum;
9188 tree parameter;
9189 enum machine_mode mode;
9190 tree type;
9191 rtx parm_rtx;
9192 int reg, i;
9193
9194 INIT_CUMULATIVE_ARGS (cum, NULL, NULL, 0, 0);
9195
9196 for (i = 0; i < call_expr_nargs (call_expr); i++)
9197 {
9198 parameter = CALL_EXPR_ARG (call_expr, i);
9199 gcc_assert (parameter);
9200
9201 /* For an undeclared variable passed as parameter we will get
9202 an ERROR_MARK node here. */
9203 if (TREE_CODE (parameter) == ERROR_MARK)
9204 return true;
9205
9206 type = TREE_TYPE (parameter);
9207 gcc_assert (type);
9208
9209 mode = TYPE_MODE (type);
9210 gcc_assert (mode);
9211
9212 if (pass_by_reference (&cum, mode, type, true))
9213 {
9214 mode = Pmode;
9215 type = build_pointer_type (type);
9216 }
9217
9218 parm_rtx = s390_function_arg (&cum, mode, type, 0);
9219
9220 s390_function_arg_advance (&cum, mode, type, 0);
9221
9222 if (parm_rtx && REG_P (parm_rtx))
9223 {
9224 for (reg = 0;
9225 reg < HARD_REGNO_NREGS (REGNO (parm_rtx), GET_MODE (parm_rtx));
9226 reg++)
9227 if (! call_used_regs[reg + REGNO (parm_rtx)])
9228 return true;
9229 }
9230 }
9231 return false;
9232 }
9233
9234 /* Return true if the given call expression can be
9235 turned into a sibling call.
9236 DECL holds the declaration of the function to be called whereas
9237 EXP is the call expression itself. */
9238
9239 static bool
9240 s390_function_ok_for_sibcall (tree decl, tree exp)
9241 {
9242 /* The TPF epilogue uses register 1. */
9243 if (TARGET_TPF_PROFILING)
9244 return false;
9245
9246 /* The 31 bit PLT code uses register 12 (GOT pointer - caller saved)
9247 which would have to be restored before the sibcall. */
9248 if (!TARGET_64BIT && flag_pic && decl && !targetm.binds_local_p (decl))
9249 return false;
9250
9251 /* Register 6 on s390 is available as an argument register but unfortunately
9252 "caller saved". This makes functions needing this register for arguments
9253 not suitable for sibcalls. */
9254 return !s390_call_saved_register_used (exp);
9255 }
9256
9257 /* Return the fixed registers used for condition codes. */
9258
9259 static bool
9260 s390_fixed_condition_code_regs (unsigned int *p1, unsigned int *p2)
9261 {
9262 *p1 = CC_REGNUM;
9263 *p2 = INVALID_REGNUM;
9264
9265 return true;
9266 }
9267
9268 /* This function is used by the call expanders of the machine description.
9269 It emits the call insn itself together with the necessary operations
9270 to adjust the target address and returns the emitted insn.
9271 ADDR_LOCATION is the target address rtx
9272 TLS_CALL the location of the thread-local symbol
9273 RESULT_REG the register where the result of the call should be stored
9274 RETADDR_REG the register where the return address should be stored
9275 If this parameter is NULL_RTX the call is considered
9276 to be a sibling call. */
9277
9278 rtx
9279 s390_emit_call (rtx addr_location, rtx tls_call, rtx result_reg,
9280 rtx retaddr_reg)
9281 {
9282 bool plt_call = false;
9283 rtx insn;
9284 rtx call;
9285 rtx clobber;
9286 rtvec vec;
9287
9288 /* Direct function calls need special treatment. */
9289 if (GET_CODE (addr_location) == SYMBOL_REF)
9290 {
9291 /* When calling a global routine in PIC mode, we must
9292 replace the symbol itself with the PLT stub. */
9293 if (flag_pic && !SYMBOL_REF_LOCAL_P (addr_location))
9294 {
9295 addr_location = gen_rtx_UNSPEC (Pmode,
9296 gen_rtvec (1, addr_location),
9297 UNSPEC_PLT);
9298 addr_location = gen_rtx_CONST (Pmode, addr_location);
9299 plt_call = true;
9300 }
9301
9302 /* Unless we can use the bras(l) insn, force the
9303 routine address into a register. */
9304 if (!TARGET_SMALL_EXEC && !TARGET_CPU_ZARCH)
9305 {
9306 if (flag_pic)
9307 addr_location = legitimize_pic_address (addr_location, 0);
9308 else
9309 addr_location = force_reg (Pmode, addr_location);
9310 }
9311 }
9312
9313 /* If it is already an indirect call or the code above moved the
9314 SYMBOL_REF to somewhere else make sure the address can be found in
9315 register 1. */
9316 if (retaddr_reg == NULL_RTX
9317 && GET_CODE (addr_location) != SYMBOL_REF
9318 && !plt_call)
9319 {
9320 emit_move_insn (gen_rtx_REG (Pmode, SIBCALL_REGNUM), addr_location);
9321 addr_location = gen_rtx_REG (Pmode, SIBCALL_REGNUM);
9322 }
9323
9324 addr_location = gen_rtx_MEM (QImode, addr_location);
9325 call = gen_rtx_CALL (VOIDmode, addr_location, const0_rtx);
9326
9327 if (result_reg != NULL_RTX)
9328 call = gen_rtx_SET (VOIDmode, result_reg, call);
9329
9330 if (retaddr_reg != NULL_RTX)
9331 {
9332 clobber = gen_rtx_CLOBBER (VOIDmode, retaddr_reg);
9333
9334 if (tls_call != NULL_RTX)
9335 vec = gen_rtvec (3, call, clobber,
9336 gen_rtx_USE (VOIDmode, tls_call));
9337 else
9338 vec = gen_rtvec (2, call, clobber);
9339
9340 call = gen_rtx_PARALLEL (VOIDmode, vec);
9341 }
9342
9343 insn = emit_call_insn (call);
9344
9345 /* 31-bit PLT stubs and tls calls use the GOT register implicitly. */
9346 if ((!TARGET_64BIT && plt_call) || tls_call != NULL_RTX)
9347 {
9348 /* s390_function_ok_for_sibcall should
9349 have denied sibcalls in this case. */
9350 gcc_assert (retaddr_reg != NULL_RTX);
9351
9352 use_reg (&CALL_INSN_FUNCTION_USAGE (insn), pic_offset_table_rtx);
9353 }
9354 return insn;
9355 }
9356
9357 /* Implement CONDITIONAL_REGISTER_USAGE. */
9358
9359 void
9360 s390_conditional_register_usage (void)
9361 {
9362 int i;
9363
9364 if (flag_pic)
9365 {
9366 fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1;
9367 call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1;
9368 }
9369 if (TARGET_CPU_ZARCH)
9370 {
9371 fixed_regs[BASE_REGNUM] = 0;
9372 call_used_regs[BASE_REGNUM] = 0;
9373 fixed_regs[RETURN_REGNUM] = 0;
9374 call_used_regs[RETURN_REGNUM] = 0;
9375 }
9376 if (TARGET_64BIT)
9377 {
9378 for (i = 24; i < 32; i++)
9379 call_used_regs[i] = call_really_used_regs[i] = 0;
9380 }
9381 else
9382 {
9383 for (i = 18; i < 20; i++)
9384 call_used_regs[i] = call_really_used_regs[i] = 0;
9385 }
9386
9387 if (TARGET_SOFT_FLOAT)
9388 {
9389 for (i = 16; i < 32; i++)
9390 call_used_regs[i] = fixed_regs[i] = 1;
9391 }
9392 }
9393
9394 /* Corresponding function to eh_return expander. */
9395
9396 static GTY(()) rtx s390_tpf_eh_return_symbol;
9397 void
9398 s390_emit_tpf_eh_return (rtx target)
9399 {
9400 rtx insn, reg;
9401
9402 if (!s390_tpf_eh_return_symbol)
9403 s390_tpf_eh_return_symbol = gen_rtx_SYMBOL_REF (Pmode, "__tpf_eh_return");
9404
9405 reg = gen_rtx_REG (Pmode, 2);
9406
9407 emit_move_insn (reg, target);
9408 insn = s390_emit_call (s390_tpf_eh_return_symbol, NULL_RTX, reg,
9409 gen_rtx_REG (Pmode, RETURN_REGNUM));
9410 use_reg (&CALL_INSN_FUNCTION_USAGE (insn), reg);
9411
9412 emit_move_insn (EH_RETURN_HANDLER_RTX, reg);
9413 }
9414
9415 /* Rework the prologue/epilogue to avoid saving/restoring
9416 registers unnecessarily. */
9417
9418 static void
9419 s390_optimize_prologue (void)
9420 {
9421 rtx insn, new_insn, next_insn;
9422
9423 /* Do a final recompute of the frame-related data. */
9424
9425 s390_update_frame_layout ();
9426
9427 /* If all special registers are in fact used, there's nothing we
9428 can do, so no point in walking the insn list. */
9429
9430 if (cfun_frame_layout.first_save_gpr <= BASE_REGNUM
9431 && cfun_frame_layout.last_save_gpr >= BASE_REGNUM
9432 && (TARGET_CPU_ZARCH
9433 || (cfun_frame_layout.first_save_gpr <= RETURN_REGNUM
9434 && cfun_frame_layout.last_save_gpr >= RETURN_REGNUM)))
9435 return;
9436
9437 /* Search for prologue/epilogue insns and replace them. */
9438
9439 for (insn = get_insns (); insn; insn = next_insn)
9440 {
9441 int first, last, off;
9442 rtx set, base, offset;
9443
9444 next_insn = NEXT_INSN (insn);
9445
9446 if (GET_CODE (insn) != INSN)
9447 continue;
9448
9449 if (GET_CODE (PATTERN (insn)) == PARALLEL
9450 && store_multiple_operation (PATTERN (insn), VOIDmode))
9451 {
9452 set = XVECEXP (PATTERN (insn), 0, 0);
9453 first = REGNO (SET_SRC (set));
9454 last = first + XVECLEN (PATTERN (insn), 0) - 1;
9455 offset = const0_rtx;
9456 base = eliminate_constant_term (XEXP (SET_DEST (set), 0), &offset);
9457 off = INTVAL (offset);
9458
9459 if (GET_CODE (base) != REG || off < 0)
9460 continue;
9461 if (cfun_frame_layout.first_save_gpr != -1
9462 && (cfun_frame_layout.first_save_gpr < first
9463 || cfun_frame_layout.last_save_gpr > last))
9464 continue;
9465 if (REGNO (base) != STACK_POINTER_REGNUM
9466 && REGNO (base) != HARD_FRAME_POINTER_REGNUM)
9467 continue;
9468 if (first > BASE_REGNUM || last < BASE_REGNUM)
9469 continue;
9470
9471 if (cfun_frame_layout.first_save_gpr != -1)
9472 {
9473 new_insn = save_gprs (base,
9474 off + (cfun_frame_layout.first_save_gpr
9475 - first) * UNITS_PER_WORD,
9476 cfun_frame_layout.first_save_gpr,
9477 cfun_frame_layout.last_save_gpr);
9478 new_insn = emit_insn_before (new_insn, insn);
9479 INSN_ADDRESSES_NEW (new_insn, -1);
9480 }
9481
9482 remove_insn (insn);
9483 continue;
9484 }
9485
9486 if (cfun_frame_layout.first_save_gpr == -1
9487 && GET_CODE (PATTERN (insn)) == SET
9488 && GET_CODE (SET_SRC (PATTERN (insn))) == REG
9489 && (REGNO (SET_SRC (PATTERN (insn))) == BASE_REGNUM
9490 || (!TARGET_CPU_ZARCH
9491 && REGNO (SET_SRC (PATTERN (insn))) == RETURN_REGNUM))
9492 && GET_CODE (SET_DEST (PATTERN (insn))) == MEM)
9493 {
9494 set = PATTERN (insn);
9495 first = REGNO (SET_SRC (set));
9496 offset = const0_rtx;
9497 base = eliminate_constant_term (XEXP (SET_DEST (set), 0), &offset);
9498 off = INTVAL (offset);
9499
9500 if (GET_CODE (base) != REG || off < 0)
9501 continue;
9502 if (REGNO (base) != STACK_POINTER_REGNUM
9503 && REGNO (base) != HARD_FRAME_POINTER_REGNUM)
9504 continue;
9505
9506 remove_insn (insn);
9507 continue;
9508 }
9509
9510 if (GET_CODE (PATTERN (insn)) == PARALLEL
9511 && load_multiple_operation (PATTERN (insn), VOIDmode))
9512 {
9513 set = XVECEXP (PATTERN (insn), 0, 0);
9514 first = REGNO (SET_DEST (set));
9515 last = first + XVECLEN (PATTERN (insn), 0) - 1;
9516 offset = const0_rtx;
9517 base = eliminate_constant_term (XEXP (SET_SRC (set), 0), &offset);
9518 off = INTVAL (offset);
9519
9520 if (GET_CODE (base) != REG || off < 0)
9521 continue;
9522 if (cfun_frame_layout.first_restore_gpr != -1
9523 && (cfun_frame_layout.first_restore_gpr < first
9524 || cfun_frame_layout.last_restore_gpr > last))
9525 continue;
9526 if (REGNO (base) != STACK_POINTER_REGNUM
9527 && REGNO (base) != HARD_FRAME_POINTER_REGNUM)
9528 continue;
9529 if (first > BASE_REGNUM || last < BASE_REGNUM)
9530 continue;
9531
9532 if (cfun_frame_layout.first_restore_gpr != -1)
9533 {
9534 new_insn = restore_gprs (base,
9535 off + (cfun_frame_layout.first_restore_gpr
9536 - first) * UNITS_PER_WORD,
9537 cfun_frame_layout.first_restore_gpr,
9538 cfun_frame_layout.last_restore_gpr);
9539 new_insn = emit_insn_before (new_insn, insn);
9540 INSN_ADDRESSES_NEW (new_insn, -1);
9541 }
9542
9543 remove_insn (insn);
9544 continue;
9545 }
9546
9547 if (cfun_frame_layout.first_restore_gpr == -1
9548 && GET_CODE (PATTERN (insn)) == SET
9549 && GET_CODE (SET_DEST (PATTERN (insn))) == REG
9550 && (REGNO (SET_DEST (PATTERN (insn))) == BASE_REGNUM
9551 || (!TARGET_CPU_ZARCH
9552 && REGNO (SET_DEST (PATTERN (insn))) == RETURN_REGNUM))
9553 && GET_CODE (SET_SRC (PATTERN (insn))) == MEM)
9554 {
9555 set = PATTERN (insn);
9556 first = REGNO (SET_DEST (set));
9557 offset = const0_rtx;
9558 base = eliminate_constant_term (XEXP (SET_SRC (set), 0), &offset);
9559 off = INTVAL (offset);
9560
9561 if (GET_CODE (base) != REG || off < 0)
9562 continue;
9563 if (REGNO (base) != STACK_POINTER_REGNUM
9564 && REGNO (base) != HARD_FRAME_POINTER_REGNUM)
9565 continue;
9566
9567 remove_insn (insn);
9568 continue;
9569 }
9570 }
9571 }
9572
9573 /* Perform machine-dependent processing. */
9574
9575 static void
9576 s390_reorg (void)
9577 {
9578 bool pool_overflow = false;
9579
9580 /* Make sure all splits have been performed; splits after
9581 machine_dependent_reorg might confuse insn length counts. */
9582 split_all_insns_noflow ();
9583
9584 /* From here on decomposed literal pool addresses must be accepted. */
9585 cfun->machine->decomposed_literal_pool_addresses_ok_p = true;
9586
9587 /* Install the main literal pool and the associated base
9588 register load insns.
9589
9590 In addition, there are two problematic situations we need
9591 to correct:
9592
9593 - the literal pool might be > 4096 bytes in size, so that
9594 some of its elements cannot be directly accessed
9595
9596 - a branch target might be > 64K away from the branch, so that
9597 it is not possible to use a PC-relative instruction.
9598
9599 To fix those, we split the single literal pool into multiple
9600 pool chunks, reloading the pool base register at various
9601 points throughout the function to ensure it always points to
9602 the pool chunk the following code expects, and / or replace
9603 PC-relative branches by absolute branches.
9604
9605 However, the two problems are interdependent: splitting the
9606 literal pool can move a branch further away from its target,
9607 causing the 64K limit to overflow, and on the other hand,
9608 replacing a PC-relative branch by an absolute branch means
9609 we need to put the branch target address into the literal
9610 pool, possibly causing it to overflow.
9611
9612 So, we loop trying to fix up both problems until we manage
9613 to satisfy both conditions at the same time. Note that the
9614 loop is guaranteed to terminate as every pass of the loop
9615 strictly decreases the total number of PC-relative branches
9616 in the function. (This is not completely true as there
9617 might be branch-over-pool insns introduced by chunkify_start.
9618 Those never need to be split however.) */
9619
9620 for (;;)
9621 {
9622 struct constant_pool *pool = NULL;
9623
9624 /* Collect the literal pool. */
9625 if (!pool_overflow)
9626 {
9627 pool = s390_mainpool_start ();
9628 if (!pool)
9629 pool_overflow = true;
9630 }
9631
9632 /* If literal pool overflowed, start to chunkify it. */
9633 if (pool_overflow)
9634 pool = s390_chunkify_start ();
9635
9636 /* Split out-of-range branches. If this has created new
9637 literal pool entries, cancel current chunk list and
9638 recompute it. zSeries machines have large branch
9639 instructions, so we never need to split a branch. */
9640 if (!TARGET_CPU_ZARCH && s390_split_branches ())
9641 {
9642 if (pool_overflow)
9643 s390_chunkify_cancel (pool);
9644 else
9645 s390_mainpool_cancel (pool);
9646
9647 continue;
9648 }
9649
9650 /* If we made it up to here, both conditions are satisfied.
9651 Finish up literal pool related changes. */
9652 if (pool_overflow)
9653 s390_chunkify_finish (pool);
9654 else
9655 s390_mainpool_finish (pool);
9656
9657 /* We're done splitting branches. */
9658 cfun->machine->split_branches_pending_p = false;
9659 break;
9660 }
9661
9662 /* Generate out-of-pool execute target insns. */
9663 if (TARGET_CPU_ZARCH)
9664 {
9665 rtx insn, label, target;
9666
9667 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
9668 {
9669 label = s390_execute_label (insn);
9670 if (!label)
9671 continue;
9672
9673 gcc_assert (label != const0_rtx);
9674
9675 target = emit_label (XEXP (label, 0));
9676 INSN_ADDRESSES_NEW (target, -1);
9677
9678 target = emit_insn (s390_execute_target (insn));
9679 INSN_ADDRESSES_NEW (target, -1);
9680 }
9681 }
9682
9683 /* Try to optimize prologue and epilogue further. */
9684 s390_optimize_prologue ();
9685 }
9686
9687
9688 /* Initialize GCC target structure. */
9689
9690 #undef TARGET_ASM_ALIGNED_HI_OP
9691 #define TARGET_ASM_ALIGNED_HI_OP "\t.word\t"
9692 #undef TARGET_ASM_ALIGNED_DI_OP
9693 #define TARGET_ASM_ALIGNED_DI_OP "\t.quad\t"
9694 #undef TARGET_ASM_INTEGER
9695 #define TARGET_ASM_INTEGER s390_assemble_integer
9696
9697 #undef TARGET_ASM_OPEN_PAREN
9698 #define TARGET_ASM_OPEN_PAREN ""
9699
9700 #undef TARGET_ASM_CLOSE_PAREN
9701 #define TARGET_ASM_CLOSE_PAREN ""
9702
9703 #undef TARGET_DEFAULT_TARGET_FLAGS
9704 #define TARGET_DEFAULT_TARGET_FLAGS (TARGET_DEFAULT | MASK_FUSED_MADD)
9705 #undef TARGET_HANDLE_OPTION
9706 #define TARGET_HANDLE_OPTION s390_handle_option
9707
9708 #undef TARGET_ENCODE_SECTION_INFO
9709 #define TARGET_ENCODE_SECTION_INFO s390_encode_section_info
9710
9711 #ifdef HAVE_AS_TLS
9712 #undef TARGET_HAVE_TLS
9713 #define TARGET_HAVE_TLS true
9714 #endif
9715 #undef TARGET_CANNOT_FORCE_CONST_MEM
9716 #define TARGET_CANNOT_FORCE_CONST_MEM s390_cannot_force_const_mem
9717
9718 #undef TARGET_DELEGITIMIZE_ADDRESS
9719 #define TARGET_DELEGITIMIZE_ADDRESS s390_delegitimize_address
9720
9721 #undef TARGET_RETURN_IN_MEMORY
9722 #define TARGET_RETURN_IN_MEMORY s390_return_in_memory
9723
9724 #undef TARGET_INIT_BUILTINS
9725 #define TARGET_INIT_BUILTINS s390_init_builtins
9726 #undef TARGET_EXPAND_BUILTIN
9727 #define TARGET_EXPAND_BUILTIN s390_expand_builtin
9728
9729 #undef TARGET_ASM_OUTPUT_MI_THUNK
9730 #define TARGET_ASM_OUTPUT_MI_THUNK s390_output_mi_thunk
9731 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
9732 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK hook_bool_const_tree_hwi_hwi_const_tree_true
9733
9734 #undef TARGET_SCHED_ADJUST_PRIORITY
9735 #define TARGET_SCHED_ADJUST_PRIORITY s390_adjust_priority
9736 #undef TARGET_SCHED_ISSUE_RATE
9737 #define TARGET_SCHED_ISSUE_RATE s390_issue_rate
9738 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
9739 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD s390_first_cycle_multipass_dfa_lookahead
9740
9741 #undef TARGET_CANNOT_COPY_INSN_P
9742 #define TARGET_CANNOT_COPY_INSN_P s390_cannot_copy_insn_p
9743 #undef TARGET_RTX_COSTS
9744 #define TARGET_RTX_COSTS s390_rtx_costs
9745 #undef TARGET_ADDRESS_COST
9746 #define TARGET_ADDRESS_COST s390_address_cost
9747
9748 #undef TARGET_MACHINE_DEPENDENT_REORG
9749 #define TARGET_MACHINE_DEPENDENT_REORG s390_reorg
9750
9751 #undef TARGET_VALID_POINTER_MODE
9752 #define TARGET_VALID_POINTER_MODE s390_valid_pointer_mode
9753
9754 #undef TARGET_BUILD_BUILTIN_VA_LIST
9755 #define TARGET_BUILD_BUILTIN_VA_LIST s390_build_builtin_va_list
9756 #undef TARGET_EXPAND_BUILTIN_VA_START
9757 #define TARGET_EXPAND_BUILTIN_VA_START s390_va_start
9758 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
9759 #define TARGET_GIMPLIFY_VA_ARG_EXPR s390_gimplify_va_arg
9760
9761 #undef TARGET_PROMOTE_FUNCTION_ARGS
9762 #define TARGET_PROMOTE_FUNCTION_ARGS hook_bool_const_tree_true
9763 #undef TARGET_PROMOTE_FUNCTION_RETURN
9764 #define TARGET_PROMOTE_FUNCTION_RETURN hook_bool_const_tree_true
9765 #undef TARGET_PASS_BY_REFERENCE
9766 #define TARGET_PASS_BY_REFERENCE s390_pass_by_reference
9767
9768 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
9769 #define TARGET_FUNCTION_OK_FOR_SIBCALL s390_function_ok_for_sibcall
9770
9771 #undef TARGET_FIXED_CONDITION_CODE_REGS
9772 #define TARGET_FIXED_CONDITION_CODE_REGS s390_fixed_condition_code_regs
9773
9774 #undef TARGET_CC_MODES_COMPATIBLE
9775 #define TARGET_CC_MODES_COMPATIBLE s390_cc_modes_compatible
9776
9777 #undef TARGET_INVALID_WITHIN_DOLOOP
9778 #define TARGET_INVALID_WITHIN_DOLOOP hook_constcharptr_const_rtx_null
9779
9780 #ifdef HAVE_AS_TLS
9781 #undef TARGET_ASM_OUTPUT_DWARF_DTPREL
9782 #define TARGET_ASM_OUTPUT_DWARF_DTPREL s390_output_dwarf_dtprel
9783 #endif
9784
9785 #ifdef TARGET_ALTERNATE_LONG_DOUBLE_MANGLING
9786 #undef TARGET_MANGLE_TYPE
9787 #define TARGET_MANGLE_TYPE s390_mangle_type
9788 #endif
9789
9790 #undef TARGET_SCALAR_MODE_SUPPORTED_P
9791 #define TARGET_SCALAR_MODE_SUPPORTED_P s390_scalar_mode_supported_p
9792
9793 #undef TARGET_SECONDARY_RELOAD
9794 #define TARGET_SECONDARY_RELOAD s390_secondary_reload
9795
9796 #undef TARGET_LIBGCC_CMP_RETURN_MODE
9797 #define TARGET_LIBGCC_CMP_RETURN_MODE s390_libgcc_cmp_return_mode
9798
9799 #undef TARGET_LIBGCC_SHIFT_COUNT_MODE
9800 #define TARGET_LIBGCC_SHIFT_COUNT_MODE s390_libgcc_shift_count_mode
9801
9802 struct gcc_target targetm = TARGET_INITIALIZER;
9803
9804 #include "gt-s390.h"
Mirror of the offical gcc git repository hosted at gcc.gnu.org