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