]> git.ipfire.org Git - thirdparty/gcc.git/blob - gcc/config/v850/v850.c
projects / thirdparty / gcc.git / blob
? search:


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