]> git.ipfire.org Git - thirdparty/gcc.git/blob - gcc/config/v850/v850.c
projects / thirdparty / gcc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
gcc/ada/
[thirdparty/gcc.git] / gcc / config / v850 / v850.c
1 /* Subroutines for insn-output.c for NEC V850 series
2 Copyright (C) 1996-2014 Free Software Foundation, Inc.
3 Contributed by Jeff Law (law@cygnus.com).
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
20
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "tm.h"
25 #include "tree.h"
26 #include "stringpool.h"
27 #include "stor-layout.h"
28 #include "varasm.h"
29 #include "calls.h"
30 #include "rtl.h"
31 #include "regs.h"
32 #include "hard-reg-set.h"
33 #include "insn-config.h"
34 #include "conditions.h"
35 #include "output.h"
36 #include "insn-attr.h"
37 #include "flags.h"
38 #include "recog.h"
39 #include "expr.h"
40 #include "hashtab.h"
41 #include "hash-set.h"
42 #include "vec.h"
43 #include "machmode.h"
44 #include "input.h"
45 #include "function.h"
46 #include "diagnostic-core.h"
47 #include "ggc.h"
48 #include "tm_p.h"
49 #include "target.h"
50 #include "target-def.h"
51 #include "dominance.h"
52 #include "cfg.h"
53 #include "cfgrtl.h"
54 #include "cfganal.h"
55 #include "lcm.h"
56 #include "cfgbuild.h"
57 #include "cfgcleanup.h"
58 #include "predict.h"
59 #include "basic-block.h"
60 #include "df.h"
61 #include "opts.h"
62 #include "builtins.h"
63
64 #ifndef streq
65 #define streq(a,b) (strcmp (a, b) == 0)
66 #endif
67
68 static void v850_print_operand_address (FILE *, rtx);
69
70 /* Names of the various data areas used on the v850. */
71 const char * GHS_default_section_names [(int) COUNT_OF_GHS_SECTION_KINDS];
72 const char * GHS_current_section_names [(int) COUNT_OF_GHS_SECTION_KINDS];
73
74 /* Track the current data area set by the data area pragma (which
75 can be nested). Tested by check_default_data_area. */
76 data_area_stack_element * data_area_stack = NULL;
77
78 /* True if we don't need to check any more if the current
79 function is an interrupt handler. */
80 static int v850_interrupt_cache_p = FALSE;
81
82 rtx v850_compare_op0, v850_compare_op1;
83
84 /* Whether current function is an interrupt handler. */
85 static int v850_interrupt_p = FALSE;
86
87 static GTY(()) section * rosdata_section;
88 static GTY(()) section * rozdata_section;
89 static GTY(()) section * tdata_section;
90 static GTY(()) section * zdata_section;
91 static GTY(()) section * zbss_section;
92 \f
93 /* We use this to wrap all emitted insns in the prologue. */
94 static rtx
95 F (rtx x)
96 {
97 if (GET_CODE (x) != CLOBBER)
98 RTX_FRAME_RELATED_P (x) = 1;
99 return x;
100 }
101
102 /* Mark all the subexpressions of the PARALLEL rtx PAR as
103 frame-related. Return PAR.
104
105 dwarf2out.c:dwarf2out_frame_debug_expr ignores sub-expressions of a
106 PARALLEL rtx other than the first if they do not have the
107 FRAME_RELATED flag set on them. */
108
109 static rtx
110 v850_all_frame_related (rtx par)
111 {
112 int len = XVECLEN (par, 0);
113 int i;
114
115 gcc_assert (GET_CODE (par) == PARALLEL);
116 for (i = 0; i < len; i++)
117 F (XVECEXP (par, 0, i));
118
119 return par;
120 }
121
122 /* Handle the TARGET_PASS_BY_REFERENCE target hook.
123 Specify whether to pass the argument by reference. */
124
125 static bool
126 v850_pass_by_reference (cumulative_args_t cum ATTRIBUTE_UNUSED,
127 machine_mode mode, const_tree type,
128 bool named ATTRIBUTE_UNUSED)
129 {
130 unsigned HOST_WIDE_INT size;
131
132 if (!TARGET_GCC_ABI)
133 return 0;
134
135 if (type)
136 size = int_size_in_bytes (type);
137 else
138 size = GET_MODE_SIZE (mode);
139
140 return size > 8;
141 }
142
143 /* Return an RTX to represent where an argument with mode MODE
144 and type TYPE will be passed to a function. If the result
145 is NULL_RTX, the argument will be pushed. */
146
147 static rtx
148 v850_function_arg (cumulative_args_t cum_v, machine_mode mode,
149 const_tree type, bool named)
150 {
151 CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
152 rtx result = NULL_RTX;
153 int size, align;
154
155 if (!named)
156 return NULL_RTX;
157
158 if (mode == BLKmode)
159 size = int_size_in_bytes (type);
160 else
161 size = GET_MODE_SIZE (mode);
162
163 size = (size + UNITS_PER_WORD -1) & ~(UNITS_PER_WORD -1);
164
165 if (size < 1)
166 {
167 /* Once we have stopped using argument registers, do not start up again. */
168 cum->nbytes = 4 * UNITS_PER_WORD;
169 return NULL_RTX;
170 }
171
172 if (!TARGET_GCC_ABI)
173 align = UNITS_PER_WORD;
174 else if (size <= UNITS_PER_WORD && type)
175 align = TYPE_ALIGN (type) / BITS_PER_UNIT;
176 else
177 align = size;
178
179 cum->nbytes = (cum->nbytes + align - 1) &~(align - 1);
180
181 if (cum->nbytes > 4 * UNITS_PER_WORD)
182 return NULL_RTX;
183
184 if (type == NULL_TREE
185 && cum->nbytes + size > 4 * UNITS_PER_WORD)
186 return NULL_RTX;
187
188 switch (cum->nbytes / UNITS_PER_WORD)
189 {
190 case 0:
191 result = gen_rtx_REG (mode, 6);
192 break;
193 case 1:
194 result = gen_rtx_REG (mode, 7);
195 break;
196 case 2:
197 result = gen_rtx_REG (mode, 8);
198 break;
199 case 3:
200 result = gen_rtx_REG (mode, 9);
201 break;
202 default:
203 result = NULL_RTX;
204 }
205
206 return result;
207 }
208
209 /* Return the number of bytes which must be put into registers
210 for values which are part in registers and part in memory. */
211 static int
212 v850_arg_partial_bytes (cumulative_args_t cum_v, machine_mode mode,
213 tree type, bool named)
214 {
215 CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
216 int size, align;
217
218 if (!named)
219 return 0;
220
221 if (mode == BLKmode)
222 size = int_size_in_bytes (type);
223 else
224 size = GET_MODE_SIZE (mode);
225
226 if (size < 1)
227 size = 1;
228
229 if (!TARGET_GCC_ABI)
230 align = UNITS_PER_WORD;
231 else if (type)
232 align = TYPE_ALIGN (type) / BITS_PER_UNIT;
233 else
234 align = size;
235
236 cum->nbytes = (cum->nbytes + align - 1) & ~ (align - 1);
237
238 if (cum->nbytes > 4 * UNITS_PER_WORD)
239 return 0;
240
241 if (cum->nbytes + size <= 4 * UNITS_PER_WORD)
242 return 0;
243
244 if (type == NULL_TREE
245 && cum->nbytes + size > 4 * UNITS_PER_WORD)
246 return 0;
247
248 return 4 * UNITS_PER_WORD - cum->nbytes;
249 }
250
251 /* Update the data in CUM to advance over an argument
252 of mode MODE and data type TYPE.
253 (TYPE is null for libcalls where that information may not be available.) */
254
255 static void
256 v850_function_arg_advance (cumulative_args_t cum_v, machine_mode mode,
257 const_tree type, bool named ATTRIBUTE_UNUSED)
258 {
259 CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
260
261 if (!TARGET_GCC_ABI)
262 cum->nbytes += (((mode != BLKmode
263 ? GET_MODE_SIZE (mode)
264 : int_size_in_bytes (type)) + UNITS_PER_WORD - 1)
265 & -UNITS_PER_WORD);
266 else
267 cum->nbytes += (((type && int_size_in_bytes (type) > 8
268 ? GET_MODE_SIZE (Pmode)
269 : (mode != BLKmode
270 ? GET_MODE_SIZE (mode)
271 : int_size_in_bytes (type))) + UNITS_PER_WORD - 1)
272 & -UNITS_PER_WORD);
273 }
274
275 /* Return the high and low words of a CONST_DOUBLE */
276
277 static void
278 const_double_split (rtx x, HOST_WIDE_INT * p_high, HOST_WIDE_INT * p_low)
279 {
280 if (GET_CODE (x) == CONST_DOUBLE)
281 {
282 long t[2];
283 REAL_VALUE_TYPE rv;
284
285 switch (GET_MODE (x))
286 {
287 case DFmode:
288 REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
289 REAL_VALUE_TO_TARGET_DOUBLE (rv, t);
290 *p_high = t[1]; /* since v850 is little endian */
291 *p_low = t[0]; /* high is second word */
292 return;
293
294 case SFmode:
295 REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
296 REAL_VALUE_TO_TARGET_SINGLE (rv, *p_high);
297 *p_low = 0;
298 return;
299
300 case VOIDmode:
301 case DImode:
302 *p_high = CONST_DOUBLE_HIGH (x);
303 *p_low = CONST_DOUBLE_LOW (x);
304 return;
305
306 default:
307 break;
308 }
309 }
310
311 fatal_insn ("const_double_split got a bad insn:", x);
312 }
313
314 \f
315 /* Return the cost of the rtx R with code CODE. */
316
317 static int
318 const_costs_int (HOST_WIDE_INT value, int zero_cost)
319 {
320 if (CONST_OK_FOR_I (value))
321 return zero_cost;
322 else if (CONST_OK_FOR_J (value))
323 return 1;
324 else if (CONST_OK_FOR_K (value))
325 return 2;
326 else
327 return 4;
328 }
329
330 static int
331 const_costs (rtx r, enum rtx_code c)
332 {
333 HOST_WIDE_INT high, low;
334
335 switch (c)
336 {
337 case CONST_INT:
338 return const_costs_int (INTVAL (r), 0);
339
340 case CONST_DOUBLE:
341 const_double_split (r, &high, &low);
342 if (GET_MODE (r) == SFmode)
343 return const_costs_int (high, 1);
344 else
345 return const_costs_int (high, 1) + const_costs_int (low, 1);
346
347 case SYMBOL_REF:
348 case LABEL_REF:
349 case CONST:
350 return 2;
351
352 case HIGH:
353 return 1;
354
355 default:
356 return 4;
357 }
358 }
359
360 static bool
361 v850_rtx_costs (rtx x,
362 int codearg,
363 int outer_code ATTRIBUTE_UNUSED,
364 int opno ATTRIBUTE_UNUSED,
365 int * total, bool speed)
366 {
367 enum rtx_code code = (enum rtx_code) codearg;
368
369 switch (code)
370 {
371 case CONST_INT:
372 case CONST_DOUBLE:
373 case CONST:
374 case SYMBOL_REF:
375 case LABEL_REF:
376 *total = COSTS_N_INSNS (const_costs (x, code));
377 return true;
378
379 case MOD:
380 case DIV:
381 case UMOD:
382 case UDIV:
383 if (TARGET_V850E && !speed)
384 *total = 6;
385 else
386 *total = 60;
387 return true;
388
389 case MULT:
390 if (TARGET_V850E
391 && ( GET_MODE (x) == SImode
392 || GET_MODE (x) == HImode
393 || GET_MODE (x) == QImode))
394 {
395 if (GET_CODE (XEXP (x, 1)) == REG)
396 *total = 4;
397 else if (GET_CODE (XEXP (x, 1)) == CONST_INT)
398 {
399 if (CONST_OK_FOR_O (INTVAL (XEXP (x, 1))))
400 *total = 6;
401 else if (CONST_OK_FOR_K (INTVAL (XEXP (x, 1))))
402 *total = 10;
403 }
404 }
405 else
406 *total = 20;
407 return true;
408
409 case ZERO_EXTRACT:
410 if (outer_code == COMPARE)
411 *total = 0;
412 return false;
413
414 default:
415 return false;
416 }
417 }
418 \f
419 /* Print operand X using operand code CODE to assembly language output file
420 FILE. */
421
422 static void
423 v850_print_operand (FILE * file, rtx x, int code)
424 {
425 HOST_WIDE_INT high, low;
426
427 switch (code)
428 {
429 case 'c':
430 /* We use 'c' operands with symbols for .vtinherit. */
431 if (GET_CODE (x) == SYMBOL_REF)
432 {
433 output_addr_const(file, x);
434 break;
435 }
436 /* Fall through. */
437 case 'b':
438 case 'B':
439 case 'C':
440 switch ((code == 'B' || code == 'C')
441 ? reverse_condition (GET_CODE (x)) : GET_CODE (x))
442 {
443 case NE:
444 if (code == 'c' || code == 'C')
445 fprintf (file, "nz");
446 else
447 fprintf (file, "ne");
448 break;
449 case EQ:
450 if (code == 'c' || code == 'C')
451 fprintf (file, "z");
452 else
453 fprintf (file, "e");
454 break;
455 case GE:
456 fprintf (file, "ge");
457 break;
458 case GT:
459 fprintf (file, "gt");
460 break;
461 case LE:
462 fprintf (file, "le");
463 break;
464 case LT:
465 fprintf (file, "lt");
466 break;
467 case GEU:
468 fprintf (file, "nl");
469 break;
470 case GTU:
471 fprintf (file, "h");
472 break;
473 case LEU:
474 fprintf (file, "nh");
475 break;
476 case LTU:
477 fprintf (file, "l");
478 break;
479 default:
480 gcc_unreachable ();
481 }
482 break;
483 case 'F': /* High word of CONST_DOUBLE. */
484 switch (GET_CODE (x))
485 {
486 case CONST_INT:
487 fprintf (file, "%d", (INTVAL (x) >= 0) ? 0 : -1);
488 break;
489
490 case CONST_DOUBLE:
491 const_double_split (x, &high, &low);
492 fprintf (file, "%ld", (long) high);
493 break;
494
495 default:
496 gcc_unreachable ();
497 }
498 break;
499 case 'G': /* Low word of CONST_DOUBLE. */
500 switch (GET_CODE (x))
501 {
502 case CONST_INT:
503 fprintf (file, "%ld", (long) INTVAL (x));
504 break;
505
506 case CONST_DOUBLE:
507 const_double_split (x, &high, &low);
508 fprintf (file, "%ld", (long) low);
509 break;
510
511 default:
512 gcc_unreachable ();
513 }
514 break;
515 case 'L':
516 fprintf (file, "%d\n", (int)(INTVAL (x) & 0xffff));
517 break;
518 case 'M':
519 fprintf (file, "%d", exact_log2 (INTVAL (x)));
520 break;
521 case 'O':
522 gcc_assert (special_symbolref_operand (x, VOIDmode));
523
524 if (GET_CODE (x) == CONST)
525 x = XEXP (XEXP (x, 0), 0);
526 else
527 gcc_assert (GET_CODE (x) == SYMBOL_REF);
528
529 if (SYMBOL_REF_ZDA_P (x))
530 fprintf (file, "zdaoff");
531 else if (SYMBOL_REF_SDA_P (x))
532 fprintf (file, "sdaoff");
533 else if (SYMBOL_REF_TDA_P (x))
534 fprintf (file, "tdaoff");
535 else
536 gcc_unreachable ();
537 break;
538 case 'P':
539 gcc_assert (special_symbolref_operand (x, VOIDmode));
540 output_addr_const (file, x);
541 break;
542 case 'Q':
543 gcc_assert (special_symbolref_operand (x, VOIDmode));
544
545 if (GET_CODE (x) == CONST)
546 x = XEXP (XEXP (x, 0), 0);
547 else
548 gcc_assert (GET_CODE (x) == SYMBOL_REF);
549
550 if (SYMBOL_REF_ZDA_P (x))
551 fprintf (file, "r0");
552 else if (SYMBOL_REF_SDA_P (x))
553 fprintf (file, "gp");
554 else if (SYMBOL_REF_TDA_P (x))
555 fprintf (file, "ep");
556 else
557 gcc_unreachable ();
558 break;
559 case 'R': /* 2nd word of a double. */
560 switch (GET_CODE (x))
561 {
562 case REG:
563 fprintf (file, reg_names[REGNO (x) + 1]);
564 break;
565 case MEM:
566 x = XEXP (adjust_address (x, SImode, 4), 0);
567 v850_print_operand_address (file, x);
568 if (GET_CODE (x) == CONST_INT)
569 fprintf (file, "[r0]");
570 break;
571
572 case CONST_INT:
573 {
574 unsigned HOST_WIDE_INT v = INTVAL (x);
575
576 /* Trickery to avoid problems with shifting
577 32-bits at a time on a 32-bit host. */
578 v = v >> 16;
579 v = v >> 16;
580 fprintf (file, HOST_WIDE_INT_PRINT_HEX, v);
581 break;
582 }
583
584 case CONST_DOUBLE:
585 fprintf (file, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_HIGH (x));
586 break;
587
588 default:
589 debug_rtx (x);
590 gcc_unreachable ();
591 }
592 break;
593 case 'S':
594 {
595 /* If it's a reference to a TDA variable, use sst/sld vs. st/ld. */
596 if (GET_CODE (x) == MEM && ep_memory_operand (x, GET_MODE (x), FALSE))
597 fputs ("s", file);
598
599 break;
600 }
601 case 'T':
602 {
603 /* Like an 'S' operand above, but for unsigned loads only. */
604 if (GET_CODE (x) == MEM && ep_memory_operand (x, GET_MODE (x), TRUE))
605 fputs ("s", file);
606
607 break;
608 }
609 case 'W': /* Print the instruction suffix. */
610 switch (GET_MODE (x))
611 {
612 default:
613 gcc_unreachable ();
614
615 case QImode: fputs (".b", file); break;
616 case HImode: fputs (".h", file); break;
617 case SImode: fputs (".w", file); break;
618 case SFmode: fputs (".w", file); break;
619 }
620 break;
621 case '.': /* Register r0. */
622 fputs (reg_names[0], file);
623 break;
624 case 'z': /* Reg or zero. */
625 if (REG_P (x))
626 fputs (reg_names[REGNO (x)], file);
627 else if ((GET_MODE(x) == SImode
628 || GET_MODE(x) == DFmode
629 || GET_MODE(x) == SFmode)
630 && x == CONST0_RTX(GET_MODE(x)))
631 fputs (reg_names[0], file);
632 else
633 {
634 gcc_assert (x == const0_rtx);
635 fputs (reg_names[0], file);
636 }
637 break;
638 default:
639 switch (GET_CODE (x))
640 {
641 case MEM:
642 if (GET_CODE (XEXP (x, 0)) == CONST_INT)
643 output_address (gen_rtx_PLUS (SImode, gen_rtx_REG (SImode, 0),
644 XEXP (x, 0)));
645 else
646 output_address (XEXP (x, 0));
647 break;
648
649 case REG:
650 fputs (reg_names[REGNO (x)], file);
651 break;
652 case SUBREG:
653 fputs (reg_names[subreg_regno (x)], file);
654 break;
655 case CONST_DOUBLE:
656 fprintf (file, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x));
657 break;
658
659 case CONST_INT:
660 case SYMBOL_REF:
661 case CONST:
662 case LABEL_REF:
663 case CODE_LABEL:
664 v850_print_operand_address (file, x);
665 break;
666 default:
667 gcc_unreachable ();
668 }
669 break;
670
671 }
672 }
673
674 \f
675 /* Output assembly language output for the address ADDR to FILE. */
676
677 static void
678 v850_print_operand_address (FILE * file, rtx addr)
679 {
680 switch (GET_CODE (addr))
681 {
682 case REG:
683 fprintf (file, "0[");
684 v850_print_operand (file, addr, 0);
685 fprintf (file, "]");
686 break;
687 case LO_SUM:
688 if (GET_CODE (XEXP (addr, 0)) == REG)
689 {
690 /* reg,foo */
691 fprintf (file, "lo(");
692 v850_print_operand (file, XEXP (addr, 1), 0);
693 fprintf (file, ")[");
694 v850_print_operand (file, XEXP (addr, 0), 0);
695 fprintf (file, "]");
696 }
697 break;
698 case PLUS:
699 if (GET_CODE (XEXP (addr, 0)) == REG
700 || GET_CODE (XEXP (addr, 0)) == SUBREG)
701 {
702 /* reg,foo */
703 v850_print_operand (file, XEXP (addr, 1), 0);
704 fprintf (file, "[");
705 v850_print_operand (file, XEXP (addr, 0), 0);
706 fprintf (file, "]");
707 }
708 else
709 {
710 v850_print_operand (file, XEXP (addr, 0), 0);
711 fprintf (file, "+");
712 v850_print_operand (file, XEXP (addr, 1), 0);
713 }
714 break;
715 case SYMBOL_REF:
716 {
717 const char *off_name = NULL;
718 const char *reg_name = NULL;
719
720 if (SYMBOL_REF_ZDA_P (addr))
721 {
722 off_name = "zdaoff";
723 reg_name = "r0";
724 }
725 else if (SYMBOL_REF_SDA_P (addr))
726 {
727 off_name = "sdaoff";
728 reg_name = "gp";
729 }
730 else if (SYMBOL_REF_TDA_P (addr))
731 {
732 off_name = "tdaoff";
733 reg_name = "ep";
734 }
735
736 if (off_name)
737 fprintf (file, "%s(", off_name);
738 output_addr_const (file, addr);
739 if (reg_name)
740 fprintf (file, ")[%s]", reg_name);
741 }
742 break;
743 case CONST:
744 if (special_symbolref_operand (addr, VOIDmode))
745 {
746 rtx x = XEXP (XEXP (addr, 0), 0);
747 const char *off_name;
748 const char *reg_name;
749
750 if (SYMBOL_REF_ZDA_P (x))
751 {
752 off_name = "zdaoff";
753 reg_name = "r0";
754 }
755 else if (SYMBOL_REF_SDA_P (x))
756 {
757 off_name = "sdaoff";
758 reg_name = "gp";
759 }
760 else if (SYMBOL_REF_TDA_P (x))
761 {
762 off_name = "tdaoff";
763 reg_name = "ep";
764 }
765 else
766 gcc_unreachable ();
767
768 fprintf (file, "%s(", off_name);
769 output_addr_const (file, addr);
770 fprintf (file, ")[%s]", reg_name);
771 }
772 else
773 output_addr_const (file, addr);
774 break;
775 default:
776 output_addr_const (file, addr);
777 break;
778 }
779 }
780
781 static bool
782 v850_print_operand_punct_valid_p (unsigned char code)
783 {
784 return code == '.';
785 }
786
787 /* When assemble_integer is used to emit the offsets for a switch
788 table it can encounter (TRUNCATE:HI (MINUS:SI (LABEL_REF:SI) (LABEL_REF:SI))).
789 output_addr_const will normally barf at this, but it is OK to omit
790 the truncate and just emit the difference of the two labels. The
791 .hword directive will automatically handle the truncation for us.
792
793 Returns true if rtx was handled, false otherwise. */
794
795 static bool
796 v850_output_addr_const_extra (FILE * file, rtx x)
797 {
798 if (GET_CODE (x) != TRUNCATE)
799 return false;
800
801 x = XEXP (x, 0);
802
803 /* We must also handle the case where the switch table was passed a
804 constant value and so has been collapsed. In this case the first
805 label will have been deleted. In such a case it is OK to emit
806 nothing, since the table will not be used.
807 (cf gcc.c-torture/compile/990801-1.c). */
808 if (GET_CODE (x) == MINUS
809 && GET_CODE (XEXP (x, 0)) == LABEL_REF)
810 {
811 rtx_code_label *label
812 = dyn_cast<rtx_code_label *> (XEXP (XEXP (x, 0), 0));
813 if (label && label->deleted ())
814 return true;
815 }
816
817 output_addr_const (file, x);
818 return true;
819 }
820 \f
821 /* Return appropriate code to load up a 1, 2, or 4 integer/floating
822 point value. */
823
824 const char *
825 output_move_single (rtx * operands)
826 {
827 rtx dst = operands[0];
828 rtx src = operands[1];
829
830 if (REG_P (dst))
831 {
832 if (REG_P (src))
833 return "mov %1,%0";
834
835 else if (GET_CODE (src) == CONST_INT)
836 {
837 HOST_WIDE_INT value = INTVAL (src);
838
839 if (CONST_OK_FOR_J (value)) /* Signed 5-bit immediate. */
840 return "mov %1,%0";
841
842 else if (CONST_OK_FOR_K (value)) /* Signed 16-bit immediate. */
843 return "movea %1,%.,%0";
844
845 else if (CONST_OK_FOR_L (value)) /* Upper 16 bits were set. */
846 return "movhi hi0(%1),%.,%0";
847
848 /* A random constant. */
849 else if (TARGET_V850E_UP)
850 return "mov %1,%0";
851 else
852 return "movhi hi(%1),%.,%0\n\tmovea lo(%1),%0,%0";
853 }
854
855 else if (GET_CODE (src) == CONST_DOUBLE && GET_MODE (src) == SFmode)
856 {
857 HOST_WIDE_INT high, low;
858
859 const_double_split (src, &high, &low);
860
861 if (CONST_OK_FOR_J (high)) /* Signed 5-bit immediate. */
862 return "mov %F1,%0";
863
864 else if (CONST_OK_FOR_K (high)) /* Signed 16-bit immediate. */
865 return "movea %F1,%.,%0";
866
867 else if (CONST_OK_FOR_L (high)) /* Upper 16 bits were set. */
868 return "movhi hi0(%F1),%.,%0";
869
870 /* A random constant. */
871 else if (TARGET_V850E_UP)
872 return "mov %F1,%0";
873
874 else
875 return "movhi hi(%F1),%.,%0\n\tmovea lo(%F1),%0,%0";
876 }
877
878 else if (GET_CODE (src) == MEM)
879 return "%S1ld%W1 %1,%0";
880
881 else if (special_symbolref_operand (src, VOIDmode))
882 return "movea %O1(%P1),%Q1,%0";
883
884 else if (GET_CODE (src) == LABEL_REF
885 || GET_CODE (src) == SYMBOL_REF
886 || GET_CODE (src) == CONST)
887 {
888 if (TARGET_V850E_UP)
889 return "mov hilo(%1),%0";
890 else
891 return "movhi hi(%1),%.,%0\n\tmovea lo(%1),%0,%0";
892 }
893
894 else if (GET_CODE (src) == HIGH)
895 return "movhi hi(%1),%.,%0";
896
897 else if (GET_CODE (src) == LO_SUM)
898 {
899 operands[2] = XEXP (src, 0);
900 operands[3] = XEXP (src, 1);
901 return "movea lo(%3),%2,%0";
902 }
903 }
904
905 else if (GET_CODE (dst) == MEM)
906 {
907 if (REG_P (src))
908 return "%S0st%W0 %1,%0";
909
910 else if (GET_CODE (src) == CONST_INT && INTVAL (src) == 0)
911 return "%S0st%W0 %.,%0";
912
913 else if (GET_CODE (src) == CONST_DOUBLE
914 && CONST0_RTX (GET_MODE (dst)) == src)
915 return "%S0st%W0 %.,%0";
916 }
917
918 fatal_insn ("output_move_single:", gen_rtx_SET (VOIDmode, dst, src));
919 return "";
920 }
921
922 machine_mode
923 v850_select_cc_mode (enum rtx_code cond, rtx op0, rtx op1 ATTRIBUTE_UNUSED)
924 {
925 if (GET_MODE_CLASS (GET_MODE (op0)) == MODE_FLOAT)
926 {
927 switch (cond)
928 {
929 case LE:
930 return CC_FPU_LEmode;
931 case GE:
932 return CC_FPU_GEmode;
933 case LT:
934 return CC_FPU_LTmode;
935 case GT:
936 return CC_FPU_GTmode;
937 case EQ:
938 return CC_FPU_EQmode;
939 case NE:
940 return CC_FPU_NEmode;
941 default:
942 gcc_unreachable ();
943 }
944 }
945 return CCmode;
946 }
947
948 machine_mode
949 v850_gen_float_compare (enum rtx_code cond, machine_mode mode ATTRIBUTE_UNUSED, rtx op0, rtx op1)
950 {
951 if (GET_MODE (op0) == DFmode)
952 {
953 switch (cond)
954 {
955 case LE:
956 emit_insn (gen_cmpdf_le_insn (op0, op1));
957 break;
958 case GE:
959 emit_insn (gen_cmpdf_ge_insn (op0, op1));
960 break;
961 case LT:
962 emit_insn (gen_cmpdf_lt_insn (op0, op1));
963 break;
964 case GT:
965 emit_insn (gen_cmpdf_gt_insn (op0, op1));
966 break;
967 case NE:
968 /* Note: There is no NE comparison operator. So we
969 perform an EQ comparison and invert the branch.
970 See v850_float_nz_comparison for how this is done. */
971 case EQ:
972 emit_insn (gen_cmpdf_eq_insn (op0, op1));
973 break;
974 default:
975 gcc_unreachable ();
976 }
977 }
978 else if (GET_MODE (v850_compare_op0) == SFmode)
979 {
980 switch (cond)
981 {
982 case LE:
983 emit_insn (gen_cmpsf_le_insn(op0, op1));
984 break;
985 case GE:
986 emit_insn (gen_cmpsf_ge_insn(op0, op1));
987 break;
988 case LT:
989 emit_insn (gen_cmpsf_lt_insn(op0, op1));
990 break;
991 case GT:
992 emit_insn (gen_cmpsf_gt_insn(op0, op1));
993 break;
994 case NE:
995 /* Note: There is no NE comparison operator. So we
996 perform an EQ comparison and invert the branch.
997 See v850_float_nz_comparison for how this is done. */
998 case EQ:
999 emit_insn (gen_cmpsf_eq_insn(op0, op1));
1000 break;
1001 default:
1002 gcc_unreachable ();
1003 }
1004 }
1005 else
1006 gcc_unreachable ();
1007
1008 return v850_select_cc_mode (cond, op0, op1);
1009 }
1010
1011 rtx
1012 v850_gen_compare (enum rtx_code cond, machine_mode mode, rtx op0, rtx op1)
1013 {
1014 if (GET_MODE_CLASS(GET_MODE (op0)) != MODE_FLOAT)
1015 {
1016 emit_insn (gen_cmpsi_insn (op0, op1));
1017 return gen_rtx_fmt_ee (cond, mode, gen_rtx_REG(CCmode, CC_REGNUM), const0_rtx);
1018 }
1019 else
1020 {
1021 rtx cc_reg;
1022 mode = v850_gen_float_compare (cond, mode, op0, op1);
1023 cc_reg = gen_rtx_REG (mode, CC_REGNUM);
1024 emit_insn (gen_rtx_SET(mode, cc_reg, gen_rtx_REG (mode, FCC_REGNUM)));
1025
1026 return gen_rtx_fmt_ee (cond, mode, cc_reg, const0_rtx);
1027 }
1028 }
1029
1030 /* Return maximum offset supported for a short EP memory reference of mode
1031 MODE and signedness UNSIGNEDP. */
1032
1033 static int
1034 ep_memory_offset (machine_mode mode, int unsignedp ATTRIBUTE_UNUSED)
1035 {
1036 int max_offset = 0;
1037
1038 switch (mode)
1039 {
1040 case QImode:
1041 if (TARGET_SMALL_SLD)
1042 max_offset = (1 << 4);
1043 else if ((TARGET_V850E_UP)
1044 && unsignedp)
1045 max_offset = (1 << 4);
1046 else
1047 max_offset = (1 << 7);
1048 break;
1049
1050 case HImode:
1051 if (TARGET_SMALL_SLD)
1052 max_offset = (1 << 5);
1053 else if ((TARGET_V850E_UP)
1054 && unsignedp)
1055 max_offset = (1 << 5);
1056 else
1057 max_offset = (1 << 8);
1058 break;
1059
1060 case SImode:
1061 case SFmode:
1062 max_offset = (1 << 8);
1063 break;
1064
1065 default:
1066 break;
1067 }
1068
1069 return max_offset;
1070 }
1071
1072 /* Return true if OP is a valid short EP memory reference */
1073
1074 int
1075 ep_memory_operand (rtx op, machine_mode mode, int unsigned_load)
1076 {
1077 rtx addr, op0, op1;
1078 int max_offset;
1079 int mask;
1080
1081 /* If we are not using the EP register on a per-function basis
1082 then do not allow this optimization at all. This is to
1083 prevent the use of the SLD/SST instructions which cannot be
1084 guaranteed to work properly due to a hardware bug. */
1085 if (!TARGET_EP)
1086 return FALSE;
1087
1088 if (GET_CODE (op) != MEM)
1089 return FALSE;
1090
1091 max_offset = ep_memory_offset (mode, unsigned_load);
1092
1093 mask = GET_MODE_SIZE (mode) - 1;
1094
1095 addr = XEXP (op, 0);
1096 if (GET_CODE (addr) == CONST)
1097 addr = XEXP (addr, 0);
1098
1099 switch (GET_CODE (addr))
1100 {
1101 default:
1102 break;
1103
1104 case SYMBOL_REF:
1105 return SYMBOL_REF_TDA_P (addr);
1106
1107 case REG:
1108 return REGNO (addr) == EP_REGNUM;
1109
1110 case PLUS:
1111 op0 = XEXP (addr, 0);
1112 op1 = XEXP (addr, 1);
1113 if (GET_CODE (op1) == CONST_INT
1114 && INTVAL (op1) < max_offset
1115 && INTVAL (op1) >= 0
1116 && (INTVAL (op1) & mask) == 0)
1117 {
1118 if (GET_CODE (op0) == REG && REGNO (op0) == EP_REGNUM)
1119 return TRUE;
1120
1121 if (GET_CODE (op0) == SYMBOL_REF && SYMBOL_REF_TDA_P (op0))
1122 return TRUE;
1123 }
1124 break;
1125 }
1126
1127 return FALSE;
1128 }
1129 \f
1130 /* Substitute memory references involving a pointer, to use the ep pointer,
1131 taking care to save and preserve the ep. */
1132
1133 static void
1134 substitute_ep_register (rtx_insn *first_insn,
1135 rtx_insn *last_insn,
1136 int uses,
1137 int regno,
1138 rtx * p_r1,
1139 rtx * p_ep)
1140 {
1141 rtx reg = gen_rtx_REG (Pmode, regno);
1142 rtx_insn *insn;
1143
1144 if (!*p_r1)
1145 {
1146 df_set_regs_ever_live (1, true);
1147 *p_r1 = gen_rtx_REG (Pmode, 1);
1148 *p_ep = gen_rtx_REG (Pmode, 30);
1149 }
1150
1151 if (TARGET_DEBUG)
1152 fprintf (stderr, "\
1153 Saved %d bytes (%d uses of register %s) in function %s, starting as insn %d, ending at %d\n",
1154 2 * (uses - 3), uses, reg_names[regno],
1155 IDENTIFIER_POINTER (DECL_NAME (current_function_decl)),
1156 INSN_UID (first_insn), INSN_UID (last_insn));
1157
1158 if (NOTE_P (first_insn))
1159 first_insn = next_nonnote_insn (first_insn);
1160
1161 last_insn = next_nonnote_insn (last_insn);
1162 for (insn = first_insn; insn && insn != last_insn; insn = NEXT_INSN (insn))
1163 {
1164 if (NONJUMP_INSN_P (insn))
1165 {
1166 rtx pattern = single_set (insn);
1167
1168 /* Replace the memory references. */
1169 if (pattern)
1170 {
1171 rtx *p_mem;
1172 /* Memory operands are signed by default. */
1173 int unsignedp = FALSE;
1174
1175 if (GET_CODE (SET_DEST (pattern)) == MEM
1176 && GET_CODE (SET_SRC (pattern)) == MEM)
1177 p_mem = (rtx *)0;
1178
1179 else if (GET_CODE (SET_DEST (pattern)) == MEM)
1180 p_mem = &SET_DEST (pattern);
1181
1182 else if (GET_CODE (SET_SRC (pattern)) == MEM)
1183 p_mem = &SET_SRC (pattern);
1184
1185 else if (GET_CODE (SET_SRC (pattern)) == SIGN_EXTEND
1186 && GET_CODE (XEXP (SET_SRC (pattern), 0)) == MEM)
1187 p_mem = &XEXP (SET_SRC (pattern), 0);
1188
1189 else if (GET_CODE (SET_SRC (pattern)) == ZERO_EXTEND
1190 && GET_CODE (XEXP (SET_SRC (pattern), 0)) == MEM)
1191 {
1192 p_mem = &XEXP (SET_SRC (pattern), 0);
1193 unsignedp = TRUE;
1194 }
1195 else
1196 p_mem = (rtx *)0;
1197
1198 if (p_mem)
1199 {
1200 rtx addr = XEXP (*p_mem, 0);
1201
1202 if (GET_CODE (addr) == REG && REGNO (addr) == (unsigned) regno)
1203 *p_mem = change_address (*p_mem, VOIDmode, *p_ep);
1204
1205 else if (GET_CODE (addr) == PLUS
1206 && GET_CODE (XEXP (addr, 0)) == REG
1207 && REGNO (XEXP (addr, 0)) == (unsigned) regno
1208 && GET_CODE (XEXP (addr, 1)) == CONST_INT
1209 && ((INTVAL (XEXP (addr, 1)))
1210 < ep_memory_offset (GET_MODE (*p_mem),
1211 unsignedp))
1212 && ((INTVAL (XEXP (addr, 1))) >= 0))
1213 *p_mem = change_address (*p_mem, VOIDmode,
1214 gen_rtx_PLUS (Pmode,
1215 *p_ep,
1216 XEXP (addr, 1)));
1217 }
1218 }
1219 }
1220 }
1221
1222 /* Optimize back to back cases of ep <- r1 & r1 <- ep. */
1223 insn = prev_nonnote_insn (first_insn);
1224 if (insn && NONJUMP_INSN_P (insn)
1225 && GET_CODE (PATTERN (insn)) == SET
1226 && SET_DEST (PATTERN (insn)) == *p_ep
1227 && SET_SRC (PATTERN (insn)) == *p_r1)
1228 delete_insn (insn);
1229 else
1230 emit_insn_before (gen_rtx_SET (Pmode, *p_r1, *p_ep), first_insn);
1231
1232 emit_insn_before (gen_rtx_SET (Pmode, *p_ep, reg), first_insn);
1233 emit_insn_before (gen_rtx_SET (Pmode, *p_ep, *p_r1), last_insn);
1234 }
1235
1236 \f
1237 /* TARGET_MACHINE_DEPENDENT_REORG. On the 850, we use it to implement
1238 the -mep mode to copy heavily used pointers to ep to use the implicit
1239 addressing. */
1240
1241 static void
1242 v850_reorg (void)
1243 {
1244 struct
1245 {
1246 int uses;
1247 rtx_insn *first_insn;
1248 rtx_insn *last_insn;
1249 }
1250 regs[FIRST_PSEUDO_REGISTER];
1251
1252 int i;
1253 int use_ep = FALSE;
1254 rtx r1 = NULL_RTX;
1255 rtx ep = NULL_RTX;
1256 rtx_insn *insn;
1257 rtx pattern;
1258
1259 /* If not ep mode, just return now. */
1260 if (!TARGET_EP)
1261 return;
1262
1263 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1264 {
1265 regs[i].uses = 0;
1266 regs[i].first_insn = NULL;
1267 regs[i].last_insn = NULL;
1268 }
1269
1270 for (insn = get_insns (); insn != NULL_RTX; insn = NEXT_INSN (insn))
1271 {
1272 switch (GET_CODE (insn))
1273 {
1274 /* End of basic block */
1275 default:
1276 if (!use_ep)
1277 {
1278 int max_uses = -1;
1279 int max_regno = -1;
1280
1281 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1282 {
1283 if (max_uses < regs[i].uses)
1284 {
1285 max_uses = regs[i].uses;
1286 max_regno = i;
1287 }
1288 }
1289
1290 if (max_uses > 3)
1291 substitute_ep_register (regs[max_regno].first_insn,
1292 regs[max_regno].last_insn,
1293 max_uses, max_regno, &r1, &ep);
1294 }
1295
1296 use_ep = FALSE;
1297 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1298 {
1299 regs[i].uses = 0;
1300 regs[i].first_insn = NULL;
1301 regs[i].last_insn = NULL;
1302 }
1303 break;
1304
1305 case NOTE:
1306 break;
1307
1308 case INSN:
1309 pattern = single_set (insn);
1310
1311 /* See if there are any memory references we can shorten. */
1312 if (pattern)
1313 {
1314 rtx src = SET_SRC (pattern);
1315 rtx dest = SET_DEST (pattern);
1316 rtx mem;
1317 /* Memory operands are signed by default. */
1318 int unsignedp = FALSE;
1319
1320 /* We might have (SUBREG (MEM)) here, so just get rid of the
1321 subregs to make this code simpler. */
1322 if (GET_CODE (dest) == SUBREG
1323 && (GET_CODE (SUBREG_REG (dest)) == MEM
1324 || GET_CODE (SUBREG_REG (dest)) == REG))
1325 alter_subreg (&dest, false);
1326 if (GET_CODE (src) == SUBREG
1327 && (GET_CODE (SUBREG_REG (src)) == MEM
1328 || GET_CODE (SUBREG_REG (src)) == REG))
1329 alter_subreg (&src, false);
1330
1331 if (GET_CODE (dest) == MEM && GET_CODE (src) == MEM)
1332 mem = NULL_RTX;
1333
1334 else if (GET_CODE (dest) == MEM)
1335 mem = dest;
1336
1337 else if (GET_CODE (src) == MEM)
1338 mem = src;
1339
1340 else if (GET_CODE (src) == SIGN_EXTEND
1341 && GET_CODE (XEXP (src, 0)) == MEM)
1342 mem = XEXP (src, 0);
1343
1344 else if (GET_CODE (src) == ZERO_EXTEND
1345 && GET_CODE (XEXP (src, 0)) == MEM)
1346 {
1347 mem = XEXP (src, 0);
1348 unsignedp = TRUE;
1349 }
1350 else
1351 mem = NULL_RTX;
1352
1353 if (mem && ep_memory_operand (mem, GET_MODE (mem), unsignedp))
1354 use_ep = TRUE;
1355
1356 else if (!use_ep && mem
1357 && GET_MODE_SIZE (GET_MODE (mem)) <= UNITS_PER_WORD)
1358 {
1359 rtx addr = XEXP (mem, 0);
1360 int regno = -1;
1361 int short_p;
1362
1363 if (GET_CODE (addr) == REG)
1364 {
1365 short_p = TRUE;
1366 regno = REGNO (addr);
1367 }
1368
1369 else if (GET_CODE (addr) == PLUS
1370 && GET_CODE (XEXP (addr, 0)) == REG
1371 && GET_CODE (XEXP (addr, 1)) == CONST_INT
1372 && ((INTVAL (XEXP (addr, 1)))
1373 < ep_memory_offset (GET_MODE (mem), unsignedp))
1374 && ((INTVAL (XEXP (addr, 1))) >= 0))
1375 {
1376 short_p = TRUE;
1377 regno = REGNO (XEXP (addr, 0));
1378 }
1379
1380 else
1381 short_p = FALSE;
1382
1383 if (short_p)
1384 {
1385 regs[regno].uses++;
1386 regs[regno].last_insn = insn;
1387 if (!regs[regno].first_insn)
1388 regs[regno].first_insn = insn;
1389 }
1390 }
1391
1392 /* Loading up a register in the basic block zaps any savings
1393 for the register */
1394 if (GET_CODE (dest) == REG)
1395 {
1396 machine_mode mode = GET_MODE (dest);
1397 int regno;
1398 int endregno;
1399
1400 regno = REGNO (dest);
1401 endregno = regno + HARD_REGNO_NREGS (regno, mode);
1402
1403 if (!use_ep)
1404 {
1405 /* See if we can use the pointer before this
1406 modification. */
1407 int max_uses = -1;
1408 int max_regno = -1;
1409
1410 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1411 {
1412 if (max_uses < regs[i].uses)
1413 {
1414 max_uses = regs[i].uses;
1415 max_regno = i;
1416 }
1417 }
1418
1419 if (max_uses > 3
1420 && max_regno >= regno
1421 && max_regno < endregno)
1422 {
1423 substitute_ep_register (regs[max_regno].first_insn,
1424 regs[max_regno].last_insn,
1425 max_uses, max_regno, &r1,
1426 &ep);
1427
1428 /* Since we made a substitution, zap all remembered
1429 registers. */
1430 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1431 {
1432 regs[i].uses = 0;
1433 regs[i].first_insn = NULL;
1434 regs[i].last_insn = NULL;
1435 }
1436 }
1437 }
1438
1439 for (i = regno; i < endregno; i++)
1440 {
1441 regs[i].uses = 0;
1442 regs[i].first_insn = NULL;
1443 regs[i].last_insn = NULL;
1444 }
1445 }
1446 }
1447 }
1448 }
1449 }
1450
1451 /* # of registers saved by the interrupt handler. */
1452 #define INTERRUPT_FIXED_NUM 5
1453
1454 /* # of bytes for registers saved by the interrupt handler. */
1455 #define INTERRUPT_FIXED_SAVE_SIZE (4 * INTERRUPT_FIXED_NUM)
1456
1457 /* # of words saved for other registers. */
1458 #define INTERRUPT_ALL_SAVE_NUM \
1459 (30 - INTERRUPT_FIXED_NUM)
1460
1461 #define INTERRUPT_ALL_SAVE_SIZE (4 * INTERRUPT_ALL_SAVE_NUM)
1462
1463 int
1464 compute_register_save_size (long * p_reg_saved)
1465 {
1466 int size = 0;
1467 int i;
1468 int interrupt_handler = v850_interrupt_function_p (current_function_decl);
1469 int call_p = df_regs_ever_live_p (LINK_POINTER_REGNUM);
1470 long reg_saved = 0;
1471
1472 /* Count space for the register saves. */
1473 if (interrupt_handler)
1474 {
1475 for (i = 0; i <= 31; i++)
1476 switch (i)
1477 {
1478 default:
1479 if (df_regs_ever_live_p (i) || call_p)
1480 {
1481 size += 4;
1482 reg_saved |= 1L << i;
1483 }
1484 break;
1485
1486 /* We don't save/restore r0 or the stack pointer */
1487 case 0:
1488 case STACK_POINTER_REGNUM:
1489 break;
1490
1491 /* For registers with fixed use, we save them, set them to the
1492 appropriate value, and then restore them.
1493 These registers are handled specially, so don't list them
1494 on the list of registers to save in the prologue. */
1495 case 1: /* temp used to hold ep */
1496 case 4: /* gp */
1497 case 10: /* temp used to call interrupt save/restore */
1498 case 11: /* temp used to call interrupt save/restore (long call) */
1499 case EP_REGNUM: /* ep */
1500 size += 4;
1501 break;
1502 }
1503 }
1504 else
1505 {
1506 /* Find the first register that needs to be saved. */
1507 for (i = 0; i <= 31; i++)
1508 if (df_regs_ever_live_p (i) && ((! call_used_regs[i])
1509 || i == LINK_POINTER_REGNUM))
1510 break;
1511
1512 /* If it is possible that an out-of-line helper function might be
1513 used to generate the prologue for the current function, then we
1514 need to cover the possibility that such a helper function will
1515 be used, despite the fact that there might be gaps in the list of
1516 registers that need to be saved. To detect this we note that the
1517 helper functions always push at least register r29 (provided
1518 that the function is not an interrupt handler). */
1519
1520 if (TARGET_PROLOG_FUNCTION
1521 && (i == 2 || ((i >= 20) && (i < 30))))
1522 {
1523 if (i == 2)
1524 {
1525 size += 4;
1526 reg_saved |= 1L << i;
1527
1528 i = 20;
1529 }
1530
1531 /* Helper functions save all registers between the starting
1532 register and the last register, regardless of whether they
1533 are actually used by the function or not. */
1534 for (; i <= 29; i++)
1535 {
1536 size += 4;
1537 reg_saved |= 1L << i;
1538 }
1539
1540 if (df_regs_ever_live_p (LINK_POINTER_REGNUM))
1541 {
1542 size += 4;
1543 reg_saved |= 1L << LINK_POINTER_REGNUM;
1544 }
1545 }
1546 else
1547 {
1548 for (; i <= 31; i++)
1549 if (df_regs_ever_live_p (i) && ((! call_used_regs[i])
1550 || i == LINK_POINTER_REGNUM))
1551 {
1552 size += 4;
1553 reg_saved |= 1L << i;
1554 }
1555 }
1556 }
1557
1558 if (p_reg_saved)
1559 *p_reg_saved = reg_saved;
1560
1561 return size;
1562 }
1563
1564 /* Typical stack layout should looks like this after the function's prologue:
1565
1566 | |
1567 -- ^
1568 | | \ |
1569 | | arguments saved | Increasing
1570 | | on the stack | addresses
1571 PARENT arg pointer -> | | /
1572 -------------------------- ---- -------------------
1573 | | - space for argument split between regs & stack
1574 --
1575 CHILD | | \ <-- (return address here)
1576 | | other call
1577 | | saved registers
1578 | | /
1579 --
1580 frame pointer -> | | \ ___
1581 | | local |
1582 | | variables |f
1583 | | / |r
1584 -- |a
1585 | | \ |m
1586 | | outgoing |e
1587 | | arguments | | Decreasing
1588 (hard) frame pointer | | / | | addresses
1589 and stack pointer -> | | / _|_ |
1590 -------------------------- ---- ------------------ V */
1591
1592 int
1593 compute_frame_size (int size, long * p_reg_saved)
1594 {
1595 return (size
1596 + compute_register_save_size (p_reg_saved)
1597 + crtl->outgoing_args_size);
1598 }
1599
1600 static int
1601 use_prolog_function (int num_save, int frame_size)
1602 {
1603 int alloc_stack = (4 * num_save);
1604 int unalloc_stack = frame_size - alloc_stack;
1605 int save_func_len, restore_func_len;
1606 int save_normal_len, restore_normal_len;
1607
1608 if (! TARGET_DISABLE_CALLT)
1609 save_func_len = restore_func_len = 2;
1610 else
1611 save_func_len = restore_func_len = TARGET_LONG_CALLS ? (4+4+4+2+2) : 4;
1612
1613 if (unalloc_stack)
1614 {
1615 save_func_len += CONST_OK_FOR_J (-unalloc_stack) ? 2 : 4;
1616 restore_func_len += CONST_OK_FOR_J (-unalloc_stack) ? 2 : 4;
1617 }
1618
1619 /* See if we would have used ep to save the stack. */
1620 if (TARGET_EP && num_save > 3 && (unsigned)frame_size < 255)
1621 save_normal_len = restore_normal_len = (3 * 2) + (2 * num_save);
1622 else
1623 save_normal_len = restore_normal_len = 4 * num_save;
1624
1625 save_normal_len += CONST_OK_FOR_J (-frame_size) ? 2 : 4;
1626 restore_normal_len += (CONST_OK_FOR_J (frame_size) ? 2 : 4) + 2;
1627
1628 /* Don't bother checking if we don't actually save any space.
1629 This happens for instance if one register is saved and additional
1630 stack space is allocated. */
1631 return ((save_func_len + restore_func_len) < (save_normal_len + restore_normal_len));
1632 }
1633
1634 static void
1635 increment_stack (signed int amount, bool in_prologue)
1636 {
1637 rtx inc;
1638
1639 if (amount == 0)
1640 return;
1641
1642 inc = GEN_INT (amount);
1643
1644 if (! CONST_OK_FOR_K (amount))
1645 {
1646 rtx reg = gen_rtx_REG (Pmode, 12);
1647
1648 inc = emit_move_insn (reg, inc);
1649 if (in_prologue)
1650 F (inc);
1651 inc = reg;
1652 }
1653
1654 inc = emit_insn (gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx, inc));
1655 if (in_prologue)
1656 F (inc);
1657 }
1658
1659 void
1660 expand_prologue (void)
1661 {
1662 unsigned int i;
1663 unsigned int size = get_frame_size ();
1664 unsigned int actual_fsize;
1665 unsigned int init_stack_alloc = 0;
1666 rtx save_regs[32];
1667 rtx save_all;
1668 unsigned int num_save;
1669 int code;
1670 int interrupt_handler = v850_interrupt_function_p (current_function_decl);
1671 long reg_saved = 0;
1672
1673 actual_fsize = compute_frame_size (size, &reg_saved);
1674
1675 if (flag_stack_usage_info)
1676 current_function_static_stack_size = actual_fsize;
1677
1678 /* Save/setup global registers for interrupt functions right now. */
1679 if (interrupt_handler)
1680 {
1681 if (! TARGET_DISABLE_CALLT && (TARGET_V850E_UP))
1682 emit_insn (gen_callt_save_interrupt ());
1683 else
1684 emit_insn (gen_save_interrupt ());
1685
1686 actual_fsize -= INTERRUPT_FIXED_SAVE_SIZE;
1687
1688 if (((1L << LINK_POINTER_REGNUM) & reg_saved) != 0)
1689 actual_fsize -= INTERRUPT_ALL_SAVE_SIZE;
1690
1691 /* Interrupt functions are not passed arguments, so no need to
1692 allocate space for split structure arguments. */
1693 gcc_assert (crtl->args.pretend_args_size == 0);
1694 }
1695
1696 /* Identify all of the saved registers. */
1697 num_save = 0;
1698 for (i = 1; i < 32; i++)
1699 {
1700 if (((1L << i) & reg_saved) != 0)
1701 save_regs[num_save++] = gen_rtx_REG (Pmode, i);
1702 }
1703
1704 if (crtl->args.pretend_args_size)
1705 {
1706 if (num_save == 0)
1707 {
1708 increment_stack (- (actual_fsize + crtl->args.pretend_args_size), true);
1709 actual_fsize = 0;
1710 }
1711 else
1712 increment_stack (- crtl->args.pretend_args_size, true);
1713 }
1714
1715 /* See if we have an insn that allocates stack space and saves the particular
1716 registers we want to. Note that the helpers won't
1717 allocate additional space for registers GCC saves to complete a
1718 "split" structure argument. */
1719 save_all = NULL_RTX;
1720 if (TARGET_PROLOG_FUNCTION
1721 && !crtl->args.pretend_args_size
1722 && num_save > 0)
1723 {
1724 if (use_prolog_function (num_save, actual_fsize))
1725 {
1726 int alloc_stack = 4 * num_save;
1727 int offset = 0;
1728
1729 save_all = gen_rtx_PARALLEL
1730 (VOIDmode,
1731 rtvec_alloc (num_save + 1
1732 + (TARGET_DISABLE_CALLT ? (TARGET_LONG_CALLS ? 2 : 1) : 0)));
1733
1734 XVECEXP (save_all, 0, 0)
1735 = gen_rtx_SET (VOIDmode,
1736 stack_pointer_rtx,
1737 gen_rtx_PLUS (Pmode,
1738 stack_pointer_rtx,
1739 GEN_INT(-alloc_stack)));
1740 for (i = 0; i < num_save; i++)
1741 {
1742 offset -= 4;
1743 XVECEXP (save_all, 0, i+1)
1744 = gen_rtx_SET (VOIDmode,
1745 gen_rtx_MEM (Pmode,
1746 gen_rtx_PLUS (Pmode,
1747 stack_pointer_rtx,
1748 GEN_INT(offset))),
1749 save_regs[i]);
1750 }
1751
1752 if (TARGET_DISABLE_CALLT)
1753 {
1754 XVECEXP (save_all, 0, num_save + 1)
1755 = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (Pmode, 10));
1756
1757 if (TARGET_LONG_CALLS)
1758 XVECEXP (save_all, 0, num_save + 2)
1759 = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (Pmode, 11));
1760 }
1761
1762 v850_all_frame_related (save_all);
1763
1764 code = recog (save_all, NULL_RTX, NULL);
1765 if (code >= 0)
1766 {
1767 rtx insn = emit_insn (save_all);
1768 INSN_CODE (insn) = code;
1769 actual_fsize -= alloc_stack;
1770
1771 }
1772 else
1773 save_all = NULL_RTX;
1774 }
1775 }
1776
1777 /* If no prolog save function is available, store the registers the old
1778 fashioned way (one by one). */
1779 if (!save_all)
1780 {
1781 /* Special case interrupt functions that save all registers for a call. */
1782 if (interrupt_handler && ((1L << LINK_POINTER_REGNUM) & reg_saved) != 0)
1783 {
1784 if (! TARGET_DISABLE_CALLT && (TARGET_V850E_UP))
1785 emit_insn (gen_callt_save_all_interrupt ());
1786 else
1787 emit_insn (gen_save_all_interrupt ());
1788 }
1789 else
1790 {
1791 int offset;
1792 /* If the stack is too big, allocate it in chunks so we can do the
1793 register saves. We use the register save size so we use the ep
1794 register. */
1795 if (actual_fsize && !CONST_OK_FOR_K (-actual_fsize))
1796 init_stack_alloc = compute_register_save_size (NULL);
1797 else
1798 init_stack_alloc = actual_fsize;
1799
1800 /* Save registers at the beginning of the stack frame. */
1801 offset = init_stack_alloc - 4;
1802
1803 if (init_stack_alloc)
1804 increment_stack (- (signed) init_stack_alloc, true);
1805
1806 /* Save the return pointer first. */
1807 if (num_save > 0 && REGNO (save_regs[num_save-1]) == LINK_POINTER_REGNUM)
1808 {
1809 F (emit_move_insn (gen_rtx_MEM (SImode,
1810 plus_constant (Pmode,
1811 stack_pointer_rtx,
1812 offset)),
1813 save_regs[--num_save]));
1814 offset -= 4;
1815 }
1816
1817 for (i = 0; i < num_save; i++)
1818 {
1819 F (emit_move_insn (gen_rtx_MEM (SImode,
1820 plus_constant (Pmode,
1821 stack_pointer_rtx,
1822 offset)),
1823 save_regs[i]));
1824 offset -= 4;
1825 }
1826 }
1827 }
1828
1829 /* Allocate the rest of the stack that was not allocated above (either it is
1830 > 32K or we just called a function to save the registers and needed more
1831 stack. */
1832 if (actual_fsize > init_stack_alloc)
1833 increment_stack (init_stack_alloc - actual_fsize, true);
1834
1835 /* If we need a frame pointer, set it up now. */
1836 if (frame_pointer_needed)
1837 F (emit_move_insn (hard_frame_pointer_rtx, stack_pointer_rtx));
1838 }
1839 \f
1840
1841 void
1842 expand_epilogue (void)
1843 {
1844 unsigned int i;
1845 unsigned int size = get_frame_size ();
1846 long reg_saved = 0;
1847 int actual_fsize = compute_frame_size (size, &reg_saved);
1848 rtx restore_regs[32];
1849 rtx restore_all;
1850 unsigned int num_restore;
1851 int code;
1852 int interrupt_handler = v850_interrupt_function_p (current_function_decl);
1853
1854 /* Eliminate the initial stack stored by interrupt functions. */
1855 if (interrupt_handler)
1856 {
1857 actual_fsize -= INTERRUPT_FIXED_SAVE_SIZE;
1858 if (((1L << LINK_POINTER_REGNUM) & reg_saved) != 0)
1859 actual_fsize -= INTERRUPT_ALL_SAVE_SIZE;
1860 }
1861
1862 /* Cut off any dynamic stack created. */
1863 if (frame_pointer_needed)
1864 emit_move_insn (stack_pointer_rtx, hard_frame_pointer_rtx);
1865
1866 /* Identify all of the saved registers. */
1867 num_restore = 0;
1868 for (i = 1; i < 32; i++)
1869 {
1870 if (((1L << i) & reg_saved) != 0)
1871 restore_regs[num_restore++] = gen_rtx_REG (Pmode, i);
1872 }
1873
1874 /* See if we have an insn that restores the particular registers we
1875 want to. */
1876 restore_all = NULL_RTX;
1877
1878 if (TARGET_PROLOG_FUNCTION
1879 && num_restore > 0
1880 && !crtl->args.pretend_args_size
1881 && !interrupt_handler)
1882 {
1883 int alloc_stack = (4 * num_restore);
1884
1885 /* Don't bother checking if we don't actually save any space. */
1886 if (use_prolog_function (num_restore, actual_fsize))
1887 {
1888 int offset;
1889 restore_all = gen_rtx_PARALLEL (VOIDmode,
1890 rtvec_alloc (num_restore + 2));
1891 XVECEXP (restore_all, 0, 0) = ret_rtx;
1892 XVECEXP (restore_all, 0, 1)
1893 = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
1894 gen_rtx_PLUS (Pmode,
1895 stack_pointer_rtx,
1896 GEN_INT (alloc_stack)));
1897
1898 offset = alloc_stack - 4;
1899 for (i = 0; i < num_restore; i++)
1900 {
1901 XVECEXP (restore_all, 0, i+2)
1902 = gen_rtx_SET (VOIDmode,
1903 restore_regs[i],
1904 gen_rtx_MEM (Pmode,
1905 gen_rtx_PLUS (Pmode,
1906 stack_pointer_rtx,
1907 GEN_INT(offset))));
1908 offset -= 4;
1909 }
1910
1911 code = recog (restore_all, NULL_RTX, NULL);
1912
1913 if (code >= 0)
1914 {
1915 rtx insn;
1916
1917 actual_fsize -= alloc_stack;
1918 increment_stack (actual_fsize, false);
1919
1920 insn = emit_jump_insn (restore_all);
1921 INSN_CODE (insn) = code;
1922 }
1923 else
1924 restore_all = NULL_RTX;
1925 }
1926 }
1927
1928 /* If no epilogue save function is available, restore the registers the
1929 old fashioned way (one by one). */
1930 if (!restore_all)
1931 {
1932 unsigned int init_stack_free;
1933
1934 /* If the stack is large, we need to cut it down in 2 pieces. */
1935 if (interrupt_handler)
1936 init_stack_free = 0;
1937 else if (actual_fsize && !CONST_OK_FOR_K (-actual_fsize))
1938 init_stack_free = 4 * num_restore;
1939 else
1940 init_stack_free = (signed) actual_fsize;
1941
1942 /* Deallocate the rest of the stack if it is > 32K. */
1943 if ((unsigned int) actual_fsize > init_stack_free)
1944 increment_stack (actual_fsize - init_stack_free, false);
1945
1946 /* Special case interrupt functions that save all registers
1947 for a call. */
1948 if (interrupt_handler && ((1L << LINK_POINTER_REGNUM) & reg_saved) != 0)
1949 {
1950 if (! TARGET_DISABLE_CALLT)
1951 emit_insn (gen_callt_restore_all_interrupt ());
1952 else
1953 emit_insn (gen_restore_all_interrupt ());
1954 }
1955 else
1956 {
1957 /* Restore registers from the beginning of the stack frame. */
1958 int offset = init_stack_free - 4;
1959
1960 /* Restore the return pointer first. */
1961 if (num_restore > 0
1962 && REGNO (restore_regs [num_restore - 1]) == LINK_POINTER_REGNUM)
1963 {
1964 emit_move_insn (restore_regs[--num_restore],
1965 gen_rtx_MEM (SImode,
1966 plus_constant (Pmode,
1967 stack_pointer_rtx,
1968 offset)));
1969 offset -= 4;
1970 }
1971
1972 for (i = 0; i < num_restore; i++)
1973 {
1974 emit_move_insn (restore_regs[i],
1975 gen_rtx_MEM (SImode,
1976 plus_constant (Pmode,
1977 stack_pointer_rtx,
1978 offset)));
1979
1980 emit_use (restore_regs[i]);
1981 offset -= 4;
1982 }
1983
1984 /* Cut back the remainder of the stack. */
1985 increment_stack (init_stack_free + crtl->args.pretend_args_size,
1986 false);
1987 }
1988
1989 /* And return or use reti for interrupt handlers. */
1990 if (interrupt_handler)
1991 {
1992 if (! TARGET_DISABLE_CALLT && (TARGET_V850E_UP))
1993 emit_insn (gen_callt_return_interrupt ());
1994 else
1995 emit_jump_insn (gen_return_interrupt ());
1996 }
1997 else if (actual_fsize)
1998 emit_jump_insn (gen_return_internal ());
1999 else
2000 emit_jump_insn (gen_return_simple ());
2001 }
2002
2003 v850_interrupt_cache_p = FALSE;
2004 v850_interrupt_p = FALSE;
2005 }
2006
2007 /* Update the condition code from the insn. */
2008 void
2009 notice_update_cc (rtx body, rtx_insn *insn)
2010 {
2011 switch (get_attr_cc (insn))
2012 {
2013 case CC_NONE:
2014 /* Insn does not affect CC at all. */
2015 break;
2016
2017 case CC_NONE_0HIT:
2018 /* Insn does not change CC, but the 0'th operand has been changed. */
2019 if (cc_status.value1 != 0
2020 && reg_overlap_mentioned_p (recog_data.operand[0], cc_status.value1))
2021 cc_status.value1 = 0;
2022 break;
2023
2024 case CC_SET_ZN:
2025 /* Insn sets the Z,N flags of CC to recog_data.operand[0].
2026 V,C is in an unusable state. */
2027 CC_STATUS_INIT;
2028 cc_status.flags |= CC_OVERFLOW_UNUSABLE | CC_NO_CARRY;
2029 cc_status.value1 = recog_data.operand[0];
2030 break;
2031
2032 case CC_SET_ZNV:
2033 /* Insn sets the Z,N,V flags of CC to recog_data.operand[0].
2034 C is in an unusable state. */
2035 CC_STATUS_INIT;
2036 cc_status.flags |= CC_NO_CARRY;
2037 cc_status.value1 = recog_data.operand[0];
2038 break;
2039
2040 case CC_COMPARE:
2041 /* The insn is a compare instruction. */
2042 CC_STATUS_INIT;
2043 cc_status.value1 = SET_SRC (body);
2044 break;
2045
2046 case CC_CLOBBER:
2047 /* Insn doesn't leave CC in a usable state. */
2048 CC_STATUS_INIT;
2049 break;
2050
2051 default:
2052 break;
2053 }
2054 }
2055
2056 /* Retrieve the data area that has been chosen for the given decl. */
2057
2058 v850_data_area
2059 v850_get_data_area (tree decl)
2060 {
2061 if (lookup_attribute ("sda", DECL_ATTRIBUTES (decl)) != NULL_TREE)
2062 return DATA_AREA_SDA;
2063
2064 if (lookup_attribute ("tda", DECL_ATTRIBUTES (decl)) != NULL_TREE)
2065 return DATA_AREA_TDA;
2066
2067 if (lookup_attribute ("zda", DECL_ATTRIBUTES (decl)) != NULL_TREE)
2068 return DATA_AREA_ZDA;
2069
2070 return DATA_AREA_NORMAL;
2071 }
2072
2073 /* Store the indicated data area in the decl's attributes. */
2074
2075 static void
2076 v850_set_data_area (tree decl, v850_data_area data_area)
2077 {
2078 tree name;
2079
2080 switch (data_area)
2081 {
2082 case DATA_AREA_SDA: name = get_identifier ("sda"); break;
2083 case DATA_AREA_TDA: name = get_identifier ("tda"); break;
2084 case DATA_AREA_ZDA: name = get_identifier ("zda"); break;
2085 default:
2086 return;
2087 }
2088
2089 DECL_ATTRIBUTES (decl) = tree_cons
2090 (name, NULL, DECL_ATTRIBUTES (decl));
2091 }
2092 \f
2093 /* Handle an "interrupt" attribute; arguments as in
2094 struct attribute_spec.handler. */
2095 static tree
2096 v850_handle_interrupt_attribute (tree * node,
2097 tree name,
2098 tree args ATTRIBUTE_UNUSED,
2099 int flags ATTRIBUTE_UNUSED,
2100 bool * no_add_attrs)
2101 {
2102 if (TREE_CODE (*node) != FUNCTION_DECL)
2103 {
2104 warning (OPT_Wattributes, "%qE attribute only applies to functions",
2105 name);
2106 *no_add_attrs = true;
2107 }
2108
2109 return NULL_TREE;
2110 }
2111
2112 /* Handle a "sda", "tda" or "zda" attribute; arguments as in
2113 struct attribute_spec.handler. */
2114 static tree
2115 v850_handle_data_area_attribute (tree* node,
2116 tree name,
2117 tree args ATTRIBUTE_UNUSED,
2118 int flags ATTRIBUTE_UNUSED,
2119 bool * no_add_attrs)
2120 {
2121 v850_data_area data_area;
2122 v850_data_area area;
2123 tree decl = *node;
2124
2125 /* Implement data area attribute. */
2126 if (is_attribute_p ("sda", name))
2127 data_area = DATA_AREA_SDA;
2128 else if (is_attribute_p ("tda", name))
2129 data_area = DATA_AREA_TDA;
2130 else if (is_attribute_p ("zda", name))
2131 data_area = DATA_AREA_ZDA;
2132 else
2133 gcc_unreachable ();
2134
2135 switch (TREE_CODE (decl))
2136 {
2137 case VAR_DECL:
2138 if (current_function_decl != NULL_TREE)
2139 {
2140 error_at (DECL_SOURCE_LOCATION (decl),
2141 "data area attributes cannot be specified for "
2142 "local variables");
2143 *no_add_attrs = true;
2144 }
2145
2146 /* Drop through. */
2147
2148 case FUNCTION_DECL:
2149 area = v850_get_data_area (decl);
2150 if (area != DATA_AREA_NORMAL && data_area != area)
2151 {
2152 error ("data area of %q+D conflicts with previous declaration",
2153 decl);
2154 *no_add_attrs = true;
2155 }
2156 break;
2157
2158 default:
2159 break;
2160 }
2161
2162 return NULL_TREE;
2163 }
2164
2165 \f
2166 /* Return nonzero if FUNC is an interrupt function as specified
2167 by the "interrupt" attribute. */
2168
2169 int
2170 v850_interrupt_function_p (tree func)
2171 {
2172 tree a;
2173 int ret = 0;
2174
2175 if (v850_interrupt_cache_p)
2176 return v850_interrupt_p;
2177
2178 if (TREE_CODE (func) != FUNCTION_DECL)
2179 return 0;
2180
2181 a = lookup_attribute ("interrupt_handler", DECL_ATTRIBUTES (func));
2182 if (a != NULL_TREE)
2183 ret = 1;
2184
2185 else
2186 {
2187 a = lookup_attribute ("interrupt", DECL_ATTRIBUTES (func));
2188 ret = a != NULL_TREE;
2189 }
2190
2191 /* Its not safe to trust global variables until after function inlining has
2192 been done. */
2193 if (reload_completed | reload_in_progress)
2194 v850_interrupt_p = ret;
2195
2196 return ret;
2197 }
2198
2199 \f
2200 static void
2201 v850_encode_data_area (tree decl, rtx symbol)
2202 {
2203 int flags;
2204
2205 /* Map explicit sections into the appropriate attribute */
2206 if (v850_get_data_area (decl) == DATA_AREA_NORMAL)
2207 {
2208 if (DECL_SECTION_NAME (decl))
2209 {
2210 const char *name = DECL_SECTION_NAME (decl);
2211
2212 if (streq (name, ".zdata") || streq (name, ".zbss"))
2213 v850_set_data_area (decl, DATA_AREA_ZDA);
2214
2215 else if (streq (name, ".sdata") || streq (name, ".sbss"))
2216 v850_set_data_area (decl, DATA_AREA_SDA);
2217
2218 else if (streq (name, ".tdata"))
2219 v850_set_data_area (decl, DATA_AREA_TDA);
2220 }
2221
2222 /* If no attribute, support -m{zda,sda,tda}=n */
2223 else
2224 {
2225 int size = int_size_in_bytes (TREE_TYPE (decl));
2226 if (size <= 0)
2227 ;
2228
2229 else if (size <= small_memory_max [(int) SMALL_MEMORY_TDA])
2230 v850_set_data_area (decl, DATA_AREA_TDA);
2231
2232 else if (size <= small_memory_max [(int) SMALL_MEMORY_SDA])
2233 v850_set_data_area (decl, DATA_AREA_SDA);
2234
2235 else if (size <= small_memory_max [(int) SMALL_MEMORY_ZDA])
2236 v850_set_data_area (decl, DATA_AREA_ZDA);
2237 }
2238
2239 if (v850_get_data_area (decl) == DATA_AREA_NORMAL)
2240 return;
2241 }
2242
2243 flags = SYMBOL_REF_FLAGS (symbol);
2244 switch (v850_get_data_area (decl))
2245 {
2246 case DATA_AREA_ZDA: flags |= SYMBOL_FLAG_ZDA; break;
2247 case DATA_AREA_TDA: flags |= SYMBOL_FLAG_TDA; break;
2248 case DATA_AREA_SDA: flags |= SYMBOL_FLAG_SDA; break;
2249 default: gcc_unreachable ();
2250 }
2251 SYMBOL_REF_FLAGS (symbol) = flags;
2252 }
2253
2254 static void
2255 v850_encode_section_info (tree decl, rtx rtl, int first)
2256 {
2257 default_encode_section_info (decl, rtl, first);
2258
2259 if (TREE_CODE (decl) == VAR_DECL
2260 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
2261 v850_encode_data_area (decl, XEXP (rtl, 0));
2262 }
2263
2264 /* Construct a JR instruction to a routine that will perform the equivalent of
2265 the RTL passed in as an argument. This RTL is a function epilogue that
2266 pops registers off the stack and possibly releases some extra stack space
2267 as well. The code has already verified that the RTL matches these
2268 requirements. */
2269
2270 char *
2271 construct_restore_jr (rtx op)
2272 {
2273 int count = XVECLEN (op, 0);
2274 int stack_bytes;
2275 unsigned long int mask;
2276 unsigned long int first;
2277 unsigned long int last;
2278 int i;
2279 static char buff [100]; /* XXX */
2280
2281 if (count <= 2)
2282 {
2283 error ("bogus JR construction: %d", count);
2284 return NULL;
2285 }
2286
2287 /* Work out how many bytes to pop off the stack before retrieving
2288 registers. */
2289 gcc_assert (GET_CODE (XVECEXP (op, 0, 1)) == SET);
2290 gcc_assert (GET_CODE (SET_SRC (XVECEXP (op, 0, 1))) == PLUS);
2291 gcc_assert (GET_CODE (XEXP (SET_SRC (XVECEXP (op, 0, 1)), 1)) == CONST_INT);
2292
2293 stack_bytes = INTVAL (XEXP (SET_SRC (XVECEXP (op, 0, 1)), 1));
2294
2295 /* Each pop will remove 4 bytes from the stack.... */
2296 stack_bytes -= (count - 2) * 4;
2297
2298 /* Make sure that the amount we are popping either 0 or 16 bytes. */
2299 if (stack_bytes != 0)
2300 {
2301 error ("bad amount of stack space removal: %d", stack_bytes);
2302 return NULL;
2303 }
2304
2305 /* Now compute the bit mask of registers to push. */
2306 mask = 0;
2307 for (i = 2; i < count; i++)
2308 {
2309 rtx vector_element = XVECEXP (op, 0, i);
2310
2311 gcc_assert (GET_CODE (vector_element) == SET);
2312 gcc_assert (GET_CODE (SET_DEST (vector_element)) == REG);
2313 gcc_assert (register_is_ok_for_epilogue (SET_DEST (vector_element),
2314 SImode));
2315
2316 mask |= 1 << REGNO (SET_DEST (vector_element));
2317 }
2318
2319 /* Scan for the first register to pop. */
2320 for (first = 0; first < 32; first++)
2321 {
2322 if (mask & (1 << first))
2323 break;
2324 }
2325
2326 gcc_assert (first < 32);
2327
2328 /* Discover the last register to pop. */
2329 if (mask & (1 << LINK_POINTER_REGNUM))
2330 {
2331 last = LINK_POINTER_REGNUM;
2332 }
2333 else
2334 {
2335 gcc_assert (!stack_bytes);
2336 gcc_assert (mask & (1 << 29));
2337
2338 last = 29;
2339 }
2340
2341 /* Note, it is possible to have gaps in the register mask.
2342 We ignore this here, and generate a JR anyway. We will
2343 be popping more registers than is strictly necessary, but
2344 it does save code space. */
2345
2346 if (TARGET_LONG_CALLS)
2347 {
2348 char name[40];
2349
2350 if (first == last)
2351 sprintf (name, "__return_%s", reg_names [first]);
2352 else
2353 sprintf (name, "__return_%s_%s", reg_names [first], reg_names [last]);
2354
2355 sprintf (buff, "movhi hi(%s), r0, r6\n\tmovea lo(%s), r6, r6\n\tjmp r6",
2356 name, name);
2357 }
2358 else
2359 {
2360 if (first == last)
2361 sprintf (buff, "jr __return_%s", reg_names [first]);
2362 else
2363 sprintf (buff, "jr __return_%s_%s", reg_names [first], reg_names [last]);
2364 }
2365
2366 return buff;
2367 }
2368
2369
2370 /* Construct a JARL instruction to a routine that will perform the equivalent
2371 of the RTL passed as a parameter. This RTL is a function prologue that
2372 saves some of the registers r20 - r31 onto the stack, and possibly acquires
2373 some stack space as well. The code has already verified that the RTL
2374 matches these requirements. */
2375 char *
2376 construct_save_jarl (rtx op)
2377 {
2378 int count = XVECLEN (op, 0);
2379 int stack_bytes;
2380 unsigned long int mask;
2381 unsigned long int first;
2382 unsigned long int last;
2383 int i;
2384 static char buff [100]; /* XXX */
2385
2386 if (count <= (TARGET_LONG_CALLS ? 3 : 2))
2387 {
2388 error ("bogus JARL construction: %d", count);
2389 return NULL;
2390 }
2391
2392 /* Paranoia. */
2393 gcc_assert (GET_CODE (XVECEXP (op, 0, 0)) == SET);
2394 gcc_assert (GET_CODE (SET_SRC (XVECEXP (op, 0, 0))) == PLUS);
2395 gcc_assert (GET_CODE (XEXP (SET_SRC (XVECEXP (op, 0, 0)), 0)) == REG);
2396 gcc_assert (GET_CODE (XEXP (SET_SRC (XVECEXP (op, 0, 0)), 1)) == CONST_INT);
2397
2398 /* Work out how many bytes to push onto the stack after storing the
2399 registers. */
2400 stack_bytes = INTVAL (XEXP (SET_SRC (XVECEXP (op, 0, 0)), 1));
2401
2402 /* Each push will put 4 bytes from the stack.... */
2403 stack_bytes += (count - (TARGET_LONG_CALLS ? 3 : 2)) * 4;
2404
2405 /* Make sure that the amount we are popping either 0 or 16 bytes. */
2406 if (stack_bytes != 0)
2407 {
2408 error ("bad amount of stack space removal: %d", stack_bytes);
2409 return NULL;
2410 }
2411
2412 /* Now compute the bit mask of registers to push. */
2413 mask = 0;
2414 for (i = 1; i < count - (TARGET_LONG_CALLS ? 2 : 1); i++)
2415 {
2416 rtx vector_element = XVECEXP (op, 0, i);
2417
2418 gcc_assert (GET_CODE (vector_element) == SET);
2419 gcc_assert (GET_CODE (SET_SRC (vector_element)) == REG);
2420 gcc_assert (register_is_ok_for_epilogue (SET_SRC (vector_element),
2421 SImode));
2422
2423 mask |= 1 << REGNO (SET_SRC (vector_element));
2424 }
2425
2426 /* Scan for the first register to push. */
2427 for (first = 0; first < 32; first++)
2428 {
2429 if (mask & (1 << first))
2430 break;
2431 }
2432
2433 gcc_assert (first < 32);
2434
2435 /* Discover the last register to push. */
2436 if (mask & (1 << LINK_POINTER_REGNUM))
2437 {
2438 last = LINK_POINTER_REGNUM;
2439 }
2440 else
2441 {
2442 gcc_assert (!stack_bytes);
2443 gcc_assert (mask & (1 << 29));
2444
2445 last = 29;
2446 }
2447
2448 /* Note, it is possible to have gaps in the register mask.
2449 We ignore this here, and generate a JARL anyway. We will
2450 be pushing more registers than is strictly necessary, but
2451 it does save code space. */
2452
2453 if (TARGET_LONG_CALLS)
2454 {
2455 char name[40];
2456
2457 if (first == last)
2458 sprintf (name, "__save_%s", reg_names [first]);
2459 else
2460 sprintf (name, "__save_%s_%s", reg_names [first], reg_names [last]);
2461
2462 if (TARGET_V850E3V5_UP)
2463 sprintf (buff, "mov hilo(%s), r11\n\tjarl [r11], r10", name);
2464 else
2465 sprintf (buff, "movhi hi(%s), r0, r11\n\tmovea lo(%s), r11, r11\n\tjarl .+4, r10\n\tadd 4, r10\n\tjmp r11",
2466 name, name);
2467 }
2468 else
2469 {
2470 if (first == last)
2471 sprintf (buff, "jarl __save_%s, r10", reg_names [first]);
2472 else
2473 sprintf (buff, "jarl __save_%s_%s, r10", reg_names [first],
2474 reg_names [last]);
2475 }
2476
2477 return buff;
2478 }
2479
2480 /* A version of asm_output_aligned_bss() that copes with the special
2481 data areas of the v850. */
2482 void
2483 v850_output_aligned_bss (FILE * file,
2484 tree decl,
2485 const char * name,
2486 unsigned HOST_WIDE_INT size,
2487 int align)
2488 {
2489 switch (v850_get_data_area (decl))
2490 {
2491 case DATA_AREA_ZDA:
2492 switch_to_section (zbss_section);
2493 break;
2494
2495 case DATA_AREA_SDA:
2496 switch_to_section (sbss_section);
2497 break;
2498
2499 case DATA_AREA_TDA:
2500 switch_to_section (tdata_section);
2501
2502 default:
2503 switch_to_section (bss_section);
2504 break;
2505 }
2506
2507 ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
2508 #ifdef ASM_DECLARE_OBJECT_NAME
2509 last_assemble_variable_decl = decl;
2510 ASM_DECLARE_OBJECT_NAME (file, name, decl);
2511 #else
2512 /* Standard thing is just output label for the object. */
2513 ASM_OUTPUT_LABEL (file, name);
2514 #endif /* ASM_DECLARE_OBJECT_NAME */
2515 ASM_OUTPUT_SKIP (file, size ? size : 1);
2516 }
2517
2518 /* Called via the macro ASM_OUTPUT_DECL_COMMON */
2519 void
2520 v850_output_common (FILE * file,
2521 tree decl,
2522 const char * name,
2523 int size,
2524 int align)
2525 {
2526 if (decl == NULL_TREE)
2527 {
2528 fprintf (file, "%s", COMMON_ASM_OP);
2529 }
2530 else
2531 {
2532 switch (v850_get_data_area (decl))
2533 {
2534 case DATA_AREA_ZDA:
2535 fprintf (file, "%s", ZCOMMON_ASM_OP);
2536 break;
2537
2538 case DATA_AREA_SDA:
2539 fprintf (file, "%s", SCOMMON_ASM_OP);
2540 break;
2541
2542 case DATA_AREA_TDA:
2543 fprintf (file, "%s", TCOMMON_ASM_OP);
2544 break;
2545
2546 default:
2547 fprintf (file, "%s", COMMON_ASM_OP);
2548 break;
2549 }
2550 }
2551
2552 assemble_name (file, name);
2553 fprintf (file, ",%u,%u\n", size, align / BITS_PER_UNIT);
2554 }
2555
2556 /* Called via the macro ASM_OUTPUT_DECL_LOCAL */
2557 void
2558 v850_output_local (FILE * file,
2559 tree decl,
2560 const char * name,
2561 int size,
2562 int align)
2563 {
2564 fprintf (file, "%s", LOCAL_ASM_OP);
2565 assemble_name (file, name);
2566 fprintf (file, "\n");
2567
2568 ASM_OUTPUT_ALIGNED_DECL_COMMON (file, decl, name, size, align);
2569 }
2570
2571 /* Add data area to the given declaration if a ghs data area pragma is
2572 currently in effect (#pragma ghs startXXX/endXXX). */
2573 static void
2574 v850_insert_attributes (tree decl, tree * attr_ptr ATTRIBUTE_UNUSED )
2575 {
2576 if (data_area_stack
2577 && data_area_stack->data_area
2578 && current_function_decl == NULL_TREE
2579 && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == CONST_DECL)
2580 && v850_get_data_area (decl) == DATA_AREA_NORMAL)
2581 v850_set_data_area (decl, data_area_stack->data_area);
2582
2583 /* Initialize the default names of the v850 specific sections,
2584 if this has not been done before. */
2585
2586 if (GHS_default_section_names [(int) GHS_SECTION_KIND_SDATA] == NULL)
2587 {
2588 GHS_default_section_names [(int) GHS_SECTION_KIND_SDATA]
2589 = ".sdata";
2590
2591 GHS_default_section_names [(int) GHS_SECTION_KIND_ROSDATA]
2592 = ".rosdata";
2593
2594 GHS_default_section_names [(int) GHS_SECTION_KIND_TDATA]
2595 = ".tdata";
2596
2597 GHS_default_section_names [(int) GHS_SECTION_KIND_ZDATA]
2598 = ".zdata";
2599
2600 GHS_default_section_names [(int) GHS_SECTION_KIND_ROZDATA]
2601 = ".rozdata";
2602 }
2603
2604 if (current_function_decl == NULL_TREE
2605 && (TREE_CODE (decl) == VAR_DECL
2606 || TREE_CODE (decl) == CONST_DECL
2607 || TREE_CODE (decl) == FUNCTION_DECL)
2608 && (!DECL_EXTERNAL (decl) || DECL_INITIAL (decl))
2609 && !DECL_SECTION_NAME (decl))
2610 {
2611 enum GHS_section_kind kind = GHS_SECTION_KIND_DEFAULT;
2612 const char * chosen_section;
2613
2614 if (TREE_CODE (decl) == FUNCTION_DECL)
2615 kind = GHS_SECTION_KIND_TEXT;
2616 else
2617 {
2618 /* First choose a section kind based on the data area of the decl. */
2619 switch (v850_get_data_area (decl))
2620 {
2621 default:
2622 gcc_unreachable ();
2623
2624 case DATA_AREA_SDA:
2625 kind = ((TREE_READONLY (decl))
2626 ? GHS_SECTION_KIND_ROSDATA
2627 : GHS_SECTION_KIND_SDATA);
2628 break;
2629
2630 case DATA_AREA_TDA:
2631 kind = GHS_SECTION_KIND_TDATA;
2632 break;
2633
2634 case DATA_AREA_ZDA:
2635 kind = ((TREE_READONLY (decl))
2636 ? GHS_SECTION_KIND_ROZDATA
2637 : GHS_SECTION_KIND_ZDATA);
2638 break;
2639
2640 case DATA_AREA_NORMAL: /* default data area */
2641 if (TREE_READONLY (decl))
2642 kind = GHS_SECTION_KIND_RODATA;
2643 else if (DECL_INITIAL (decl))
2644 kind = GHS_SECTION_KIND_DATA;
2645 else
2646 kind = GHS_SECTION_KIND_BSS;
2647 }
2648 }
2649
2650 /* Now, if the section kind has been explicitly renamed,
2651 then attach a section attribute. */
2652 chosen_section = GHS_current_section_names [(int) kind];
2653
2654 /* Otherwise, if this kind of section needs an explicit section
2655 attribute, then also attach one. */
2656 if (chosen_section == NULL)
2657 chosen_section = GHS_default_section_names [(int) kind];
2658
2659 if (chosen_section)
2660 {
2661 /* Only set the section name if specified by a pragma, because
2662 otherwise it will force those variables to get allocated storage
2663 in this module, rather than by the linker. */
2664 set_decl_section_name (decl, chosen_section);
2665 }
2666 }
2667 }
2668
2669 /* Construct a DISPOSE instruction that is the equivalent of
2670 the given RTX. We have already verified that this should
2671 be possible. */
2672
2673 char *
2674 construct_dispose_instruction (rtx op)
2675 {
2676 int count = XVECLEN (op, 0);
2677 int stack_bytes;
2678 unsigned long int mask;
2679 int i;
2680 static char buff[ 100 ]; /* XXX */
2681 int use_callt = 0;
2682
2683 if (count <= 2)
2684 {
2685 error ("bogus DISPOSE construction: %d", count);
2686 return NULL;
2687 }
2688
2689 /* Work out how many bytes to pop off the
2690 stack before retrieving registers. */
2691 gcc_assert (GET_CODE (XVECEXP (op, 0, 1)) == SET);
2692 gcc_assert (GET_CODE (SET_SRC (XVECEXP (op, 0, 1))) == PLUS);
2693 gcc_assert (GET_CODE (XEXP (SET_SRC (XVECEXP (op, 0, 1)), 1)) == CONST_INT);
2694
2695 stack_bytes = INTVAL (XEXP (SET_SRC (XVECEXP (op, 0, 1)), 1));
2696
2697 /* Each pop will remove 4 bytes from the stack.... */
2698 stack_bytes -= (count - 2) * 4;
2699
2700 /* Make sure that the amount we are popping
2701 will fit into the DISPOSE instruction. */
2702 if (stack_bytes > 128)
2703 {
2704 error ("too much stack space to dispose of: %d", stack_bytes);
2705 return NULL;
2706 }
2707
2708 /* Now compute the bit mask of registers to push. */
2709 mask = 0;
2710
2711 for (i = 2; i < count; i++)
2712 {
2713 rtx vector_element = XVECEXP (op, 0, i);
2714
2715 gcc_assert (GET_CODE (vector_element) == SET);
2716 gcc_assert (GET_CODE (SET_DEST (vector_element)) == REG);
2717 gcc_assert (register_is_ok_for_epilogue (SET_DEST (vector_element),
2718 SImode));
2719
2720 if (REGNO (SET_DEST (vector_element)) == 2)
2721 use_callt = 1;
2722 else
2723 mask |= 1 << REGNO (SET_DEST (vector_element));
2724 }
2725
2726 if (! TARGET_DISABLE_CALLT
2727 && (use_callt || stack_bytes == 0))
2728 {
2729 if (use_callt)
2730 {
2731 sprintf (buff, "callt ctoff(__callt_return_r2_r%d)", (mask & (1 << 31)) ? 31 : 29);
2732 return buff;
2733 }
2734 else
2735 {
2736 for (i = 20; i < 32; i++)
2737 if (mask & (1 << i))
2738 break;
2739
2740 if (i == 31)
2741 sprintf (buff, "callt ctoff(__callt_return_r31c)");
2742 else
2743 sprintf (buff, "callt ctoff(__callt_return_r%d_r%s)",
2744 i, (mask & (1 << 31)) ? "31c" : "29");
2745 }
2746 }
2747 else
2748 {
2749 static char regs [100]; /* XXX */
2750 int done_one;
2751
2752 /* Generate the DISPOSE instruction. Note we could just issue the
2753 bit mask as a number as the assembler can cope with this, but for
2754 the sake of our readers we turn it into a textual description. */
2755 regs[0] = 0;
2756 done_one = 0;
2757
2758 for (i = 20; i < 32; i++)
2759 {
2760 if (mask & (1 << i))
2761 {
2762 int first;
2763
2764 if (done_one)
2765 strcat (regs, ", ");
2766 else
2767 done_one = 1;
2768
2769 first = i;
2770 strcat (regs, reg_names[ first ]);
2771
2772 for (i++; i < 32; i++)
2773 if ((mask & (1 << i)) == 0)
2774 break;
2775
2776 if (i > first + 1)
2777 {
2778 strcat (regs, " - ");
2779 strcat (regs, reg_names[ i - 1 ] );
2780 }
2781 }
2782 }
2783
2784 sprintf (buff, "dispose %d {%s}, r31", stack_bytes / 4, regs);
2785 }
2786
2787 return buff;
2788 }
2789
2790 /* Construct a PREPARE instruction that is the equivalent of
2791 the given RTL. We have already verified that this should
2792 be possible. */
2793
2794 char *
2795 construct_prepare_instruction (rtx op)
2796 {
2797 int count;
2798 int stack_bytes;
2799 unsigned long int mask;
2800 int i;
2801 static char buff[ 100 ]; /* XXX */
2802 int use_callt = 0;
2803
2804 if (XVECLEN (op, 0) <= 1)
2805 {
2806 error ("bogus PREPEARE construction: %d", XVECLEN (op, 0));
2807 return NULL;
2808 }
2809
2810 /* Work out how many bytes to push onto
2811 the stack after storing the registers. */
2812 gcc_assert (GET_CODE (XVECEXP (op, 0, 0)) == SET);
2813 gcc_assert (GET_CODE (SET_SRC (XVECEXP (op, 0, 0))) == PLUS);
2814 gcc_assert (GET_CODE (XEXP (SET_SRC (XVECEXP (op, 0, 0)), 1)) == CONST_INT);
2815
2816 stack_bytes = INTVAL (XEXP (SET_SRC (XVECEXP (op, 0, 0)), 1));
2817
2818
2819 /* Make sure that the amount we are popping
2820 will fit into the DISPOSE instruction. */
2821 if (stack_bytes < -128)
2822 {
2823 error ("too much stack space to prepare: %d", stack_bytes);
2824 return NULL;
2825 }
2826
2827 /* Now compute the bit mask of registers to push. */
2828 count = 0;
2829 mask = 0;
2830 for (i = 1; i < XVECLEN (op, 0); i++)
2831 {
2832 rtx vector_element = XVECEXP (op, 0, i);
2833
2834 if (GET_CODE (vector_element) == CLOBBER)
2835 continue;
2836
2837 gcc_assert (GET_CODE (vector_element) == SET);
2838 gcc_assert (GET_CODE (SET_SRC (vector_element)) == REG);
2839 gcc_assert (register_is_ok_for_epilogue (SET_SRC (vector_element),
2840 SImode));
2841
2842 if (REGNO (SET_SRC (vector_element)) == 2)
2843 use_callt = 1;
2844 else
2845 mask |= 1 << REGNO (SET_SRC (vector_element));
2846 count++;
2847 }
2848
2849 stack_bytes += count * 4;
2850
2851 if ((! TARGET_DISABLE_CALLT)
2852 && (use_callt || stack_bytes == 0))
2853 {
2854 if (use_callt)
2855 {
2856 sprintf (buff, "callt ctoff(__callt_save_r2_r%d)", (mask & (1 << 31)) ? 31 : 29 );
2857 return buff;
2858 }
2859
2860 for (i = 20; i < 32; i++)
2861 if (mask & (1 << i))
2862 break;
2863
2864 if (i == 31)
2865 sprintf (buff, "callt ctoff(__callt_save_r31c)");
2866 else
2867 sprintf (buff, "callt ctoff(__callt_save_r%d_r%s)",
2868 i, (mask & (1 << 31)) ? "31c" : "29");
2869 }
2870 else
2871 {
2872 static char regs [100]; /* XXX */
2873 int done_one;
2874
2875
2876 /* Generate the PREPARE instruction. Note we could just issue the
2877 bit mask as a number as the assembler can cope with this, but for
2878 the sake of our readers we turn it into a textual description. */
2879 regs[0] = 0;
2880 done_one = 0;
2881
2882 for (i = 20; i < 32; i++)
2883 {
2884 if (mask & (1 << i))
2885 {
2886 int first;
2887
2888 if (done_one)
2889 strcat (regs, ", ");
2890 else
2891 done_one = 1;
2892
2893 first = i;
2894 strcat (regs, reg_names[ first ]);
2895
2896 for (i++; i < 32; i++)
2897 if ((mask & (1 << i)) == 0)
2898 break;
2899
2900 if (i > first + 1)
2901 {
2902 strcat (regs, " - ");
2903 strcat (regs, reg_names[ i - 1 ] );
2904 }
2905 }
2906 }
2907
2908 sprintf (buff, "prepare {%s}, %d", regs, (- stack_bytes) / 4);
2909 }
2910
2911 return buff;
2912 }
2913
2914 /* Return an RTX indicating where the return address to the
2915 calling function can be found. */
2916
2917 rtx
2918 v850_return_addr (int count)
2919 {
2920 if (count != 0)
2921 return const0_rtx;
2922
2923 return get_hard_reg_initial_val (Pmode, LINK_POINTER_REGNUM);
2924 }
2925 \f
2926 /* Implement TARGET_ASM_INIT_SECTIONS. */
2927
2928 static void
2929 v850_asm_init_sections (void)
2930 {
2931 rosdata_section
2932 = get_unnamed_section (0, output_section_asm_op,
2933 "\t.section .rosdata,\"a\"");
2934
2935 rozdata_section
2936 = get_unnamed_section (0, output_section_asm_op,
2937 "\t.section .rozdata,\"a\"");
2938
2939 tdata_section
2940 = get_unnamed_section (SECTION_WRITE, output_section_asm_op,
2941 "\t.section .tdata,\"aw\"");
2942
2943 zdata_section
2944 = get_unnamed_section (SECTION_WRITE, output_section_asm_op,
2945 "\t.section .zdata,\"aw\"");
2946
2947 zbss_section
2948 = get_unnamed_section (SECTION_WRITE | SECTION_BSS,
2949 output_section_asm_op,
2950 "\t.section .zbss,\"aw\"");
2951 }
2952
2953 static section *
2954 v850_select_section (tree exp,
2955 int reloc ATTRIBUTE_UNUSED,
2956 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
2957 {
2958 if (TREE_CODE (exp) == VAR_DECL)
2959 {
2960 int is_const;
2961 if (!TREE_READONLY (exp)
2962 || TREE_SIDE_EFFECTS (exp)
2963 || !DECL_INITIAL (exp)
2964 || (DECL_INITIAL (exp) != error_mark_node
2965 && !TREE_CONSTANT (DECL_INITIAL (exp))))
2966 is_const = FALSE;
2967 else
2968 is_const = TRUE;
2969
2970 switch (v850_get_data_area (exp))
2971 {
2972 case DATA_AREA_ZDA:
2973 return is_const ? rozdata_section : zdata_section;
2974
2975 case DATA_AREA_TDA:
2976 return tdata_section;
2977
2978 case DATA_AREA_SDA:
2979 return is_const ? rosdata_section : sdata_section;
2980
2981 default:
2982 return is_const ? readonly_data_section : data_section;
2983 }
2984 }
2985 return readonly_data_section;
2986 }
2987 \f
2988 /* Worker function for TARGET_FUNCTION_VALUE_REGNO_P. */
2989
2990 static bool
2991 v850_function_value_regno_p (const unsigned int regno)
2992 {
2993 return (regno == 10);
2994 }
2995
2996 /* Worker function for TARGET_RETURN_IN_MEMORY. */
2997
2998 static bool
2999 v850_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
3000 {
3001 /* Return values > 8 bytes in length in memory. */
3002 return int_size_in_bytes (type) > 8
3003 || TYPE_MODE (type) == BLKmode
3004 /* With the rh850 ABI return all aggregates in memory. */
3005 || ((! TARGET_GCC_ABI) && AGGREGATE_TYPE_P (type))
3006 ;
3007 }
3008
3009 /* Worker function for TARGET_FUNCTION_VALUE. */
3010
3011 static rtx
3012 v850_function_value (const_tree valtype,
3013 const_tree fn_decl_or_type ATTRIBUTE_UNUSED,
3014 bool outgoing ATTRIBUTE_UNUSED)
3015 {
3016 return gen_rtx_REG (TYPE_MODE (valtype), 10);
3017 }
3018
3019 \f
3020 /* Worker function for TARGET_CAN_ELIMINATE. */
3021
3022 static bool
3023 v850_can_eliminate (const int from ATTRIBUTE_UNUSED, const int to)
3024 {
3025 return (to == STACK_POINTER_REGNUM ? ! frame_pointer_needed : true);
3026 }
3027
3028 /* Worker function for TARGET_CONDITIONAL_REGISTER_USAGE.
3029
3030 If TARGET_APP_REGS is not defined then add r2 and r5 to
3031 the pool of fixed registers. See PR 14505. */
3032
3033 static void
3034 v850_conditional_register_usage (void)
3035 {
3036 if (TARGET_APP_REGS)
3037 {
3038 fixed_regs[2] = 0; call_used_regs[2] = 0;
3039 fixed_regs[5] = 0; call_used_regs[5] = 1;
3040 }
3041 }
3042 \f
3043 /* Worker function for TARGET_ASM_TRAMPOLINE_TEMPLATE. */
3044
3045 static void
3046 v850_asm_trampoline_template (FILE *f)
3047 {
3048 fprintf (f, "\tjarl .+4,r12\n");
3049 fprintf (f, "\tld.w 12[r12],r20\n");
3050 fprintf (f, "\tld.w 16[r12],r12\n");
3051 fprintf (f, "\tjmp [r12]\n");
3052 fprintf (f, "\tnop\n");
3053 fprintf (f, "\t.long 0\n");
3054 fprintf (f, "\t.long 0\n");
3055 }
3056
3057 /* Worker function for TARGET_TRAMPOLINE_INIT. */
3058
3059 static void
3060 v850_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value)
3061 {
3062 rtx mem, fnaddr = XEXP (DECL_RTL (fndecl), 0);
3063
3064 emit_block_move (m_tramp, assemble_trampoline_template (),
3065 GEN_INT (TRAMPOLINE_SIZE), BLOCK_OP_NORMAL);
3066
3067 mem = adjust_address (m_tramp, SImode, 16);
3068 emit_move_insn (mem, chain_value);
3069 mem = adjust_address (m_tramp, SImode, 20);
3070 emit_move_insn (mem, fnaddr);
3071 }
3072
3073 static int
3074 v850_issue_rate (void)
3075 {
3076 return (TARGET_V850E2_UP ? 2 : 1);
3077 }
3078
3079 /* Implement TARGET_LEGITIMATE_CONSTANT_P. */
3080
3081 static bool
3082 v850_legitimate_constant_p (machine_mode mode ATTRIBUTE_UNUSED, rtx x)
3083 {
3084 return (GET_CODE (x) == CONST_DOUBLE
3085 || !(GET_CODE (x) == CONST
3086 && GET_CODE (XEXP (x, 0)) == PLUS
3087 && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
3088 && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
3089 && !CONST_OK_FOR_K (INTVAL (XEXP (XEXP (x, 0), 1)))));
3090 }
3091
3092 static int
3093 v850_memory_move_cost (machine_mode mode,
3094 reg_class_t reg_class ATTRIBUTE_UNUSED,
3095 bool in)
3096 {
3097 switch (GET_MODE_SIZE (mode))
3098 {
3099 case 0:
3100 return in ? 24 : 8;
3101 case 1:
3102 case 2:
3103 case 3:
3104 case 4:
3105 return in ? 6 : 2;
3106 default:
3107 return (GET_MODE_SIZE (mode) / 2) * (in ? 3 : 1);
3108 }
3109 }
3110
3111 int
3112 v850_adjust_insn_length (rtx_insn *insn, int length)
3113 {
3114 if (TARGET_V850E3V5_UP)
3115 {
3116 if (CALL_P (insn))
3117 {
3118 if (TARGET_LONG_CALLS)
3119 {
3120 /* call_internal_long, call_value_internal_long. */
3121 if (length == 8)
3122 length = 4;
3123 if (length == 16)
3124 length = 10;
3125 }
3126 else
3127 {
3128 /* call_internal_short, call_value_internal_short. */
3129 if (length == 8)
3130 length = 4;
3131 }
3132 }
3133 }
3134 return length;
3135 }
3136 \f
3137 /* V850 specific attributes. */
3138
3139 static const struct attribute_spec v850_attribute_table[] =
3140 {
3141 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
3142 affects_type_identity } */
3143 { "interrupt_handler", 0, 0, true, false, false,
3144 v850_handle_interrupt_attribute, false },
3145 { "interrupt", 0, 0, true, false, false,
3146 v850_handle_interrupt_attribute, false },
3147 { "sda", 0, 0, true, false, false,
3148 v850_handle_data_area_attribute, false },
3149 { "tda", 0, 0, true, false, false,
3150 v850_handle_data_area_attribute, false },
3151 { "zda", 0, 0, true, false, false,
3152 v850_handle_data_area_attribute, false },
3153 { NULL, 0, 0, false, false, false, NULL, false }
3154 };
3155 \f
3156 static void
3157 v850_option_override (void)
3158 {
3159 if (flag_exceptions || flag_non_call_exceptions)
3160 flag_omit_frame_pointer = 0;
3161
3162 /* The RH850 ABI does not (currently) support the use of the CALLT instruction. */
3163 if (! TARGET_GCC_ABI)
3164 target_flags |= MASK_DISABLE_CALLT;
3165 }
3166 \f
3167 const char *
3168 v850_gen_movdi (rtx * operands)
3169 {
3170 if (REG_P (operands[0]))
3171 {
3172 if (REG_P (operands[1]))
3173 {
3174 if (REGNO (operands[0]) == (REGNO (operands[1]) - 1))
3175 return "mov %1, %0; mov %R1, %R0";
3176
3177 return "mov %R1, %R0; mov %1, %0";
3178 }
3179
3180 if (MEM_P (operands[1]))
3181 {
3182 if (REGNO (operands[0]) & 1)
3183 /* Use two load word instructions to synthesise a load double. */
3184 return "ld.w %1, %0 ; ld.w %R1, %R0" ;
3185
3186 return "ld.dw %1, %0";
3187 }
3188
3189 return "mov %1, %0; mov %R1, %R0";
3190 }
3191
3192 gcc_assert (REG_P (operands[1]));
3193
3194 if (REGNO (operands[1]) & 1)
3195 /* Use two store word instructions to synthesise a store double. */
3196 return "st.w %1, %0 ; st.w %R1, %R0 ";
3197
3198 return "st.dw %1, %0";
3199 }
3200 \f
3201 /* Initialize the GCC target structure. */
3202
3203 #undef TARGET_OPTION_OVERRIDE
3204 #define TARGET_OPTION_OVERRIDE v850_option_override
3205
3206 #undef TARGET_MEMORY_MOVE_COST
3207 #define TARGET_MEMORY_MOVE_COST v850_memory_move_cost
3208
3209 #undef TARGET_ASM_ALIGNED_HI_OP
3210 #define TARGET_ASM_ALIGNED_HI_OP "\t.hword\t"
3211
3212 #undef TARGET_PRINT_OPERAND
3213 #define TARGET_PRINT_OPERAND v850_print_operand
3214 #undef TARGET_PRINT_OPERAND_ADDRESS
3215 #define TARGET_PRINT_OPERAND_ADDRESS v850_print_operand_address
3216 #undef TARGET_PRINT_OPERAND_PUNCT_VALID_P
3217 #define TARGET_PRINT_OPERAND_PUNCT_VALID_P v850_print_operand_punct_valid_p
3218
3219 #undef TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA
3220 #define TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA v850_output_addr_const_extra
3221
3222 #undef TARGET_ATTRIBUTE_TABLE
3223 #define TARGET_ATTRIBUTE_TABLE v850_attribute_table
3224
3225 #undef TARGET_INSERT_ATTRIBUTES
3226 #define TARGET_INSERT_ATTRIBUTES v850_insert_attributes
3227
3228 #undef TARGET_ASM_SELECT_SECTION
3229 #define TARGET_ASM_SELECT_SECTION v850_select_section
3230
3231 /* The assembler supports switchable .bss sections, but
3232 v850_select_section doesn't yet make use of them. */
3233 #undef TARGET_HAVE_SWITCHABLE_BSS_SECTIONS
3234 #define TARGET_HAVE_SWITCHABLE_BSS_SECTIONS false
3235
3236 #undef TARGET_ENCODE_SECTION_INFO
3237 #define TARGET_ENCODE_SECTION_INFO v850_encode_section_info
3238
3239 #undef TARGET_ASM_FILE_START_FILE_DIRECTIVE
3240 #define TARGET_ASM_FILE_START_FILE_DIRECTIVE true
3241
3242 #undef TARGET_RTX_COSTS
3243 #define TARGET_RTX_COSTS v850_rtx_costs
3244
3245 #undef TARGET_ADDRESS_COST
3246 #define TARGET_ADDRESS_COST hook_int_rtx_mode_as_bool_0
3247
3248 #undef TARGET_MACHINE_DEPENDENT_REORG
3249 #define TARGET_MACHINE_DEPENDENT_REORG v850_reorg
3250
3251 #undef TARGET_SCHED_ISSUE_RATE
3252 #define TARGET_SCHED_ISSUE_RATE v850_issue_rate
3253
3254 #undef TARGET_FUNCTION_VALUE_REGNO_P
3255 #define TARGET_FUNCTION_VALUE_REGNO_P v850_function_value_regno_p
3256 #undef TARGET_FUNCTION_VALUE
3257 #define TARGET_FUNCTION_VALUE v850_function_value
3258
3259 #undef TARGET_PROMOTE_PROTOTYPES
3260 #define TARGET_PROMOTE_PROTOTYPES hook_bool_const_tree_true
3261
3262 #undef TARGET_RETURN_IN_MEMORY
3263 #define TARGET_RETURN_IN_MEMORY v850_return_in_memory
3264
3265 #undef TARGET_PASS_BY_REFERENCE
3266 #define TARGET_PASS_BY_REFERENCE v850_pass_by_reference
3267
3268 #undef TARGET_CALLEE_COPIES
3269 #define TARGET_CALLEE_COPIES hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true
3270
3271 #undef TARGET_ARG_PARTIAL_BYTES
3272 #define TARGET_ARG_PARTIAL_BYTES v850_arg_partial_bytes
3273
3274 #undef TARGET_FUNCTION_ARG
3275 #define TARGET_FUNCTION_ARG v850_function_arg
3276
3277 #undef TARGET_FUNCTION_ARG_ADVANCE
3278 #define TARGET_FUNCTION_ARG_ADVANCE v850_function_arg_advance
3279
3280 #undef TARGET_CAN_ELIMINATE
3281 #define TARGET_CAN_ELIMINATE v850_can_eliminate
3282
3283 #undef TARGET_CONDITIONAL_REGISTER_USAGE
3284 #define TARGET_CONDITIONAL_REGISTER_USAGE v850_conditional_register_usage
3285
3286 #undef TARGET_ASM_TRAMPOLINE_TEMPLATE
3287 #define TARGET_ASM_TRAMPOLINE_TEMPLATE v850_asm_trampoline_template
3288 #undef TARGET_TRAMPOLINE_INIT
3289 #define TARGET_TRAMPOLINE_INIT v850_trampoline_init
3290
3291 #undef TARGET_LEGITIMATE_CONSTANT_P
3292 #define TARGET_LEGITIMATE_CONSTANT_P v850_legitimate_constant_p
3293
3294 #undef TARGET_CAN_USE_DOLOOP_P
3295 #define TARGET_CAN_USE_DOLOOP_P can_use_doloop_if_innermost
3296
3297 struct gcc_target targetm = TARGET_INITIALIZER;
3298
3299 #include "gt-v850.h"
Mirror of https://gcc.gnu.org/git/gcc.git