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).
6 This file is part of GCC.
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)
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
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
25 #include "coretypes.h"
30 #include "hard-reg-set.h"
32 #include "insn-config.h"
33 #include "conditions.h"
35 #include "insn-attr.h"
42 #include "integrate.h"
45 #include "target-def.h"
48 #define streq(a,b) (strcmp (a, b) == 0)
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,
71 static bool v850_pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode,
73 static int v850_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode,
76 /* Information about the various small memory areas. */
77 struct small_memory_info small_memory[ (int)SMALL_MEMORY_max ] =
79 /* name max physical max */
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];
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;
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;
97 /* Whether current function is an interrupt handler. */
98 static int v850_interrupt_p = FALSE;
100 /* Initialize the GCC target structure. */
101 #undef TARGET_ASM_ALIGNED_HI_OP
102 #define TARGET_ASM_ALIGNED_HI_OP "\t.hword\t"
104 #undef TARGET_ATTRIBUTE_TABLE
105 #define TARGET_ATTRIBUTE_TABLE v850_attribute_table
107 #undef TARGET_INSERT_ATTRIBUTES
108 #define TARGET_INSERT_ATTRIBUTES v850_insert_attributes
110 #undef TARGET_ASM_SELECT_SECTION
111 #define TARGET_ASM_SELECT_SECTION v850_select_section
113 #undef TARGET_ENCODE_SECTION_INFO
114 #define TARGET_ENCODE_SECTION_INFO v850_encode_section_info
116 #undef TARGET_ASM_FILE_START_FILE_DIRECTIVE
117 #define TARGET_ASM_FILE_START_FILE_DIRECTIVE true
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
124 #undef TARGET_RTX_COSTS
125 #define TARGET_RTX_COSTS v850_rtx_costs
127 #undef TARGET_ADDRESS_COST
128 #define TARGET_ADDRESS_COST hook_int_rtx_0
130 #undef TARGET_MACHINE_DEPENDENT_REORG
131 #define TARGET_MACHINE_DEPENDENT_REORG v850_reorg
133 #undef TARGET_PROMOTE_PROTOTYPES
134 #define TARGET_PROMOTE_PROTOTYPES hook_bool_tree_true
136 #undef TARGET_RETURN_IN_MEMORY
137 #define TARGET_RETURN_IN_MEMORY v850_return_in_memory
139 #undef TARGET_PASS_BY_REFERENCE
140 #define TARGET_PASS_BY_REFERENCE v850_pass_by_reference
142 #undef TARGET_CALLEE_COPIES
143 #define TARGET_CALLEE_COPIES hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true
145 #undef TARGET_SETUP_INCOMING_VARARGS
146 #define TARGET_SETUP_INCOMING_VARARGS v850_setup_incoming_varargs
148 #undef TARGET_ARG_PARTIAL_BYTES
149 #define TARGET_ARG_PARTIAL_BYTES v850_arg_partial_bytes
151 struct gcc_target targetm = TARGET_INITIALIZER;
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 "=". */
158 v850_handle_memory_option (enum small_memory_type type, const char *value)
162 if (*value != '-' && *value != '=')
166 for (i = 0; value[i]; i++)
167 if (!ISDIGIT (value[i]))
171 if (size > small_memory[type].physical_max)
172 error ("value passed to %<-m%s%> is too large", small_memory[type].name);
174 small_memory[type].max = size;
178 /* Implement TARGET_HANDLE_OPTION. */
181 v850_handle_option (size_t code, const char *arg, int value ATTRIBUTE_UNUSED)
186 target_flags |= MASK_EP | MASK_PROLOG_FUNCTION;
190 target_flags &= ~(MASK_CPU ^ MASK_V850);
195 target_flags &= ~(MASK_CPU ^ MASK_V850E);
199 return v850_handle_memory_option (SMALL_MEMORY_TDA, arg);
202 return v850_handle_memory_option (SMALL_MEMORY_SDA, arg);
205 return v850_handle_memory_option (SMALL_MEMORY_ZDA, arg);
213 v850_pass_by_reference (CUMULATIVE_ARGS *cum ATTRIBUTE_UNUSED,
214 enum machine_mode mode, tree type,
215 bool named ATTRIBUTE_UNUSED)
217 unsigned HOST_WIDE_INT size;
220 size = int_size_in_bytes (type);
222 size = GET_MODE_SIZE (mode);
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. */
231 function_arg (CUMULATIVE_ARGS * cum,
232 enum machine_mode mode,
239 if (TARGET_GHS && !named)
243 size = int_size_in_bytes (type);
245 size = GET_MODE_SIZE (mode);
251 align = TYPE_ALIGN (type) / BITS_PER_UNIT;
255 cum->nbytes = (cum->nbytes + align - 1) &~(align - 1);
257 if (cum->nbytes > 4 * UNITS_PER_WORD)
260 if (type == NULL_TREE
261 && cum->nbytes + size > 4 * UNITS_PER_WORD)
264 switch (cum->nbytes / UNITS_PER_WORD)
267 result = gen_rtx_REG (mode, 6);
270 result = gen_rtx_REG (mode, 7);
273 result = gen_rtx_REG (mode, 8);
276 result = gen_rtx_REG (mode, 9);
286 /* Return the number of bytes which must be put into registers
287 for values which are part in registers and part in memory. */
290 v850_arg_partial_bytes (CUMULATIVE_ARGS * cum, enum machine_mode mode,
291 tree type, bool named)
295 if (TARGET_GHS && !named)
299 size = int_size_in_bytes (type);
301 size = GET_MODE_SIZE (mode);
304 align = TYPE_ALIGN (type) / BITS_PER_UNIT;
308 cum->nbytes = (cum->nbytes + align - 1) &~(align - 1);
310 if (cum->nbytes > 4 * UNITS_PER_WORD)
313 if (cum->nbytes + size <= 4 * UNITS_PER_WORD)
316 if (type == NULL_TREE
317 && cum->nbytes + size > 4 * UNITS_PER_WORD)
320 return 4 * UNITS_PER_WORD - cum->nbytes;
324 /* Return the high and low words of a CONST_DOUBLE */
327 const_double_split (rtx x, HOST_WIDE_INT * p_high, HOST_WIDE_INT * p_low)
329 if (GET_CODE (x) == CONST_DOUBLE)
334 switch (GET_MODE (x))
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 */
344 REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
345 REAL_VALUE_TO_TARGET_SINGLE (rv, *p_high);
351 *p_high = CONST_DOUBLE_HIGH (x);
352 *p_low = CONST_DOUBLE_LOW (x);
360 fatal_insn ("const_double_split got a bad insn:", x);
364 /* Return the cost of the rtx R with code CODE. */
367 const_costs_int (HOST_WIDE_INT value, int zero_cost)
369 if (CONST_OK_FOR_I (value))
371 else if (CONST_OK_FOR_J (value))
373 else if (CONST_OK_FOR_K (value))
380 const_costs (rtx r, enum rtx_code c)
382 HOST_WIDE_INT high, low;
387 return const_costs_int (INTVAL (r), 0);
390 const_double_split (r, &high, &low);
391 if (GET_MODE (r) == SFmode)
392 return const_costs_int (high, 1);
394 return const_costs_int (high, 1) + const_costs_int (low, 1);
410 v850_rtx_costs (rtx x,
412 int outer_code ATTRIBUTE_UNUSED,
422 *total = COSTS_N_INSNS (const_costs (x, code));
429 if (TARGET_V850E && optimize_size)
437 && ( GET_MODE (x) == SImode
438 || GET_MODE (x) == HImode
439 || GET_MODE (x) == QImode))
441 if (GET_CODE (XEXP (x, 1)) == REG)
443 else if (GET_CODE (XEXP (x, 1)) == CONST_INT)
445 if (CONST_OK_FOR_O (INTVAL (XEXP (x, 1))))
447 else if (CONST_OK_FOR_K (INTVAL (XEXP (x, 1))))
460 /* Print operand X using operand code CODE to assembly language output file
464 print_operand (FILE * file, rtx x, int code)
466 HOST_WIDE_INT high, low;
471 /* We use 'c' operands with symbols for .vtinherit */
472 if (GET_CODE (x) == SYMBOL_REF)
474 output_addr_const(file, x);
481 switch ((code == 'B' || code == 'C')
482 ? reverse_condition (GET_CODE (x)) : GET_CODE (x))
485 if (code == 'c' || code == 'C')
486 fprintf (file, "nz");
488 fprintf (file, "ne");
491 if (code == 'c' || code == 'C')
497 fprintf (file, "ge");
500 fprintf (file, "gt");
503 fprintf (file, "le");
506 fprintf (file, "lt");
509 fprintf (file, "nl");
515 fprintf (file, "nh");
524 case 'F': /* high word of CONST_DOUBLE */
525 if (GET_CODE (x) == CONST_INT)
526 fprintf (file, "%d", (INTVAL (x) >= 0) ? 0 : -1);
527 else if (GET_CODE (x) == CONST_DOUBLE)
529 const_double_split (x, &high, &low);
530 fprintf (file, "%ld", (long) high);
535 case 'G': /* low word of CONST_DOUBLE */
536 if (GET_CODE (x) == CONST_INT)
537 fprintf (file, "%ld", (long) INTVAL (x));
538 else if (GET_CODE (x) == CONST_DOUBLE)
540 const_double_split (x, &high, &low);
541 fprintf (file, "%ld", (long) low);
547 fprintf (file, "%d\n", (int)(INTVAL (x) & 0xffff));
550 fprintf (file, "%d", exact_log2 (INTVAL (x)));
553 if (special_symbolref_operand (x, VOIDmode))
555 if (GET_CODE (x) == SYMBOL_REF)
557 else if (GET_CODE (x) == CONST)
558 x = XEXP (XEXP (x, 0), 0);
562 if (SYMBOL_REF_ZDA_P (x))
563 fprintf (file, "zdaoff");
564 else if (SYMBOL_REF_SDA_P (x))
565 fprintf (file, "sdaoff");
566 else if (SYMBOL_REF_TDA_P (x))
567 fprintf (file, "tdaoff");
575 if (special_symbolref_operand (x, VOIDmode))
576 output_addr_const (file, x);
581 if (special_symbolref_operand (x, VOIDmode))
583 if (GET_CODE (x) == SYMBOL_REF)
585 else if (GET_CODE (x) == CONST)
586 x = XEXP (XEXP (x, 0), 0);
590 if (SYMBOL_REF_ZDA_P (x))
591 fprintf (file, "r0");
592 else if (SYMBOL_REF_SDA_P (x))
593 fprintf (file, "gp");
594 else if (SYMBOL_REF_TDA_P (x))
595 fprintf (file, "ep");
602 case 'R': /* 2nd word of a double. */
603 switch (GET_CODE (x))
606 fprintf (file, reg_names[REGNO (x) + 1]);
609 x = XEXP (adjust_address (x, SImode, 4), 0);
610 print_operand_address (file, x);
611 if (GET_CODE (x) == CONST_INT)
612 fprintf (file, "[r0]");
621 /* if it's a reference to a TDA variable, use sst/sld vs. st/ld */
622 if (GET_CODE (x) == MEM && ep_memory_operand (x, GET_MODE (x), FALSE))
629 /* Like an 'S' operand above, but for unsigned loads only. */
630 if (GET_CODE (x) == MEM && ep_memory_operand (x, GET_MODE (x), TRUE))
635 case 'W': /* print the instruction suffix */
636 switch (GET_MODE (x))
641 case QImode: fputs (".b", file); break;
642 case HImode: fputs (".h", file); break;
643 case SImode: fputs (".w", file); break;
644 case SFmode: fputs (".w", file); break;
647 case '.': /* register r0 */
648 fputs (reg_names[0], file);
650 case 'z': /* reg or zero */
652 fputs (reg_names[0], file);
653 else if (GET_CODE (x) == REG)
654 fputs (reg_names[REGNO (x)], file);
659 switch (GET_CODE (x))
662 if (GET_CODE (XEXP (x, 0)) == CONST_INT)
663 output_address (gen_rtx_PLUS (SImode, gen_rtx_REG (SImode, 0),
666 output_address (XEXP (x, 0));
670 fputs (reg_names[REGNO (x)], file);
673 fputs (reg_names[subreg_regno (x)], file);
680 print_operand_address (file, x);
691 /* Output assembly language output for the address ADDR to FILE. */
694 print_operand_address (FILE * file, rtx addr)
696 switch (GET_CODE (addr))
699 fprintf (file, "0[");
700 print_operand (file, addr, 0);
704 if (GET_CODE (XEXP (addr, 0)) == REG)
707 fprintf (file, "lo(");
708 print_operand (file, XEXP (addr, 1), 0);
709 fprintf (file, ")[");
710 print_operand (file, XEXP (addr, 0), 0);
715 if (GET_CODE (XEXP (addr, 0)) == REG
716 || GET_CODE (XEXP (addr, 0)) == SUBREG)
719 print_operand (file, XEXP (addr, 1), 0);
721 print_operand (file, XEXP (addr, 0), 0);
726 print_operand (file, XEXP (addr, 0), 0);
728 print_operand (file, XEXP (addr, 1), 0);
733 const char *off_name = NULL;
734 const char *reg_name = NULL;
736 if (SYMBOL_REF_ZDA_P (addr))
741 else if (SYMBOL_REF_SDA_P (addr))
746 else if (SYMBOL_REF_TDA_P (addr))
753 fprintf (file, "%s(", off_name);
754 output_addr_const (file, addr);
756 fprintf (file, ")[%s]", reg_name);
760 if (special_symbolref_operand (addr, VOIDmode))
762 rtx x = XEXP (XEXP (addr, 0), 0);
763 const char *off_name;
764 const char *reg_name;
766 if (SYMBOL_REF_ZDA_P (x))
771 else if (SYMBOL_REF_SDA_P (x))
776 else if (SYMBOL_REF_TDA_P (x))
784 fprintf (file, "%s(", off_name);
785 output_addr_const (file, addr);
786 fprintf (file, ")[%s]", reg_name);
789 output_addr_const (file, addr);
792 output_addr_const (file, addr);
797 /* When assemble_integer is used to emit the offsets for a switch
798 table it can encounter (TRUNCATE:HI (MINUS:SI (LABEL_REF:SI) (LABEL_REF:SI))).
799 output_addr_const will normally barf at this, but it is OK to omit
800 the truncate and just emit the difference of the two labels. The
801 .hword directive will automatically handle the truncation for us.
803 Returns 1 if rtx was handled, 0 otherwise. */
806 v850_output_addr_const_extra (FILE * file, rtx x)
808 if (GET_CODE (x) != TRUNCATE)
813 /* We must also handle the case where the switch table was passed a
814 constant value and so has been collapsed. In this case the first
815 label will have been deleted. In such a case it is OK to emit
816 nothing, since the table will not be used.
817 (cf gcc.c-torture/compile/990801-1.c). */
818 if (GET_CODE (x) == MINUS
819 && GET_CODE (XEXP (x, 0)) == LABEL_REF
820 && GET_CODE (XEXP (XEXP (x, 0), 0)) == CODE_LABEL
821 && INSN_DELETED_P (XEXP (XEXP (x, 0), 0)))
824 output_addr_const (file, x);
828 /* Return appropriate code to load up a 1, 2, or 4 integer/floating
832 output_move_single (rtx * operands)
834 rtx dst = operands[0];
835 rtx src = operands[1];
842 else if (GET_CODE (src) == CONST_INT)
844 HOST_WIDE_INT value = INTVAL (src);
846 if (CONST_OK_FOR_J (value)) /* Signed 5 bit immediate. */
849 else if (CONST_OK_FOR_K (value)) /* Signed 16 bit immediate. */
850 return "movea lo(%1),%.,%0";
852 else if (CONST_OK_FOR_L (value)) /* Upper 16 bits were set. */
853 return "movhi hi(%1),%.,%0";
855 /* A random constant. */
856 else if (TARGET_V850E)
859 return "movhi hi(%1),%.,%0\n\tmovea lo(%1),%0,%0";
862 else if (GET_CODE (src) == CONST_DOUBLE && GET_MODE (src) == SFmode)
864 HOST_WIDE_INT high, low;
866 const_double_split (src, &high, &low);
868 if (CONST_OK_FOR_J (high)) /* Signed 5 bit immediate. */
871 else if (CONST_OK_FOR_K (high)) /* Signed 16 bit immediate. */
872 return "movea lo(%F1),%.,%0";
874 else if (CONST_OK_FOR_L (high)) /* Upper 16 bits were set. */
875 return "movhi hi(%F1),%.,%0";
877 /* A random constant. */
878 else if (TARGET_V850E)
882 return "movhi hi(%F1),%.,%0\n\tmovea lo(%F1),%0,%0";
885 else if (GET_CODE (src) == MEM)
886 return "%S1ld%W1 %1,%0";
888 else if (special_symbolref_operand (src, VOIDmode))
889 return "movea %O1(%P1),%Q1,%0";
891 else if (GET_CODE (src) == LABEL_REF
892 || GET_CODE (src) == SYMBOL_REF
893 || GET_CODE (src) == CONST)
896 return "mov hilo(%1),%0";
898 return "movhi hi(%1),%.,%0\n\tmovea lo(%1),%0,%0";
901 else if (GET_CODE (src) == HIGH)
902 return "movhi hi(%1),%.,%0";
904 else if (GET_CODE (src) == LO_SUM)
906 operands[2] = XEXP (src, 0);
907 operands[3] = XEXP (src, 1);
908 return "movea lo(%3),%2,%0";
912 else if (GET_CODE (dst) == MEM)
915 return "%S0st%W0 %1,%0";
917 else if (GET_CODE (src) == CONST_INT && INTVAL (src) == 0)
918 return "%S0st%W0 %.,%0";
920 else if (GET_CODE (src) == CONST_DOUBLE
921 && CONST0_RTX (GET_MODE (dst)) == src)
922 return "%S0st%W0 %.,%0";
925 fatal_insn ("output_move_single:", gen_rtx_SET (VOIDmode, dst, src));
930 /* Return appropriate code to load up an 8 byte integer or
931 floating point value */
934 output_move_double (rtx * operands)
936 enum machine_mode mode = GET_MODE (operands[0]);
937 rtx dst = operands[0];
938 rtx src = operands[1];
940 if (register_operand (dst, mode)
941 && register_operand (src, mode))
943 if (REGNO (src) + 1 == REGNO (dst))
944 return "mov %R1,%R0\n\tmov %1,%0";
946 return "mov %1,%0\n\tmov %R1,%R0";
950 if (GET_CODE (dst) == MEM
951 && ((GET_CODE (src) == CONST_INT && INTVAL (src) == 0)
952 || (GET_CODE (src) == CONST_DOUBLE && CONST_DOUBLE_OK_FOR_G (src))))
953 return "st.w %.,%0\n\tst.w %.,%R0";
955 if (GET_CODE (src) == CONST_INT || GET_CODE (src) == CONST_DOUBLE)
957 HOST_WIDE_INT high_low[2];
961 if (GET_CODE (src) == CONST_DOUBLE)
962 const_double_split (src, &high_low[1], &high_low[0]);
965 high_low[0] = INTVAL (src);
966 high_low[1] = (INTVAL (src) >= 0) ? 0 : -1;
969 for (i = 0; i < 2; i++)
971 xop[0] = gen_rtx_REG (SImode, REGNO (dst)+i);
972 xop[1] = GEN_INT (high_low[i]);
973 output_asm_insn (output_move_single (xop), xop);
979 if (GET_CODE (src) == MEM)
982 int dreg = REGNO (dst);
983 rtx inside = XEXP (src, 0);
985 if (GET_CODE (inside) == REG)
986 ptrreg = REGNO (inside);
987 else if (GET_CODE (inside) == SUBREG)
988 ptrreg = subreg_regno (inside);
989 else if (GET_CODE (inside) == PLUS)
990 ptrreg = REGNO (XEXP (inside, 0));
991 else if (GET_CODE (inside) == LO_SUM)
992 ptrreg = REGNO (XEXP (inside, 0));
995 return "ld.w %R1,%R0\n\tld.w %1,%0";
998 if (GET_CODE (src) == MEM)
999 return "ld.w %1,%0\n\tld.w %R1,%R0";
1001 if (GET_CODE (dst) == MEM)
1002 return "st.w %1,%0\n\tst.w %R1,%R0";
1004 return "mov %1,%0\n\tmov %R1,%R0";
1008 /* Return maximum offset supported for a short EP memory reference of mode
1009 MODE and signedness UNSIGNEDP. */
1012 ep_memory_offset (enum machine_mode mode, int unsignedp ATTRIBUTE_UNUSED)
1019 if (TARGET_SMALL_SLD)
1020 max_offset = (1 << 4);
1021 else if (TARGET_V850E
1022 && ( ( unsignedp && ! TARGET_US_BIT_SET)
1023 || (! unsignedp && TARGET_US_BIT_SET)))
1024 max_offset = (1 << 4);
1026 max_offset = (1 << 7);
1030 if (TARGET_SMALL_SLD)
1031 max_offset = (1 << 5);
1032 else if (TARGET_V850E
1033 && ( ( unsignedp && ! TARGET_US_BIT_SET)
1034 || (! unsignedp && TARGET_US_BIT_SET)))
1035 max_offset = (1 << 5);
1037 max_offset = (1 << 8);
1042 max_offset = (1 << 8);
1052 /* Return true if OP is a valid short EP memory reference */
1055 ep_memory_operand (rtx op, enum machine_mode mode, int unsigned_load)
1061 if (GET_CODE (op) != MEM)
1064 max_offset = ep_memory_offset (mode, unsigned_load);
1066 mask = GET_MODE_SIZE (mode) - 1;
1068 addr = XEXP (op, 0);
1069 if (GET_CODE (addr) == CONST)
1070 addr = XEXP (addr, 0);
1072 switch (GET_CODE (addr))
1078 return SYMBOL_REF_TDA_P (addr);
1081 return REGNO (addr) == EP_REGNUM;
1084 op0 = XEXP (addr, 0);
1085 op1 = XEXP (addr, 1);
1086 if (GET_CODE (op1) == CONST_INT
1087 && INTVAL (op1) < max_offset
1088 && INTVAL (op1) >= 0
1089 && (INTVAL (op1) & mask) == 0)
1091 if (GET_CODE (op0) == REG && REGNO (op0) == EP_REGNUM)
1094 if (GET_CODE (op0) == SYMBOL_REF && SYMBOL_REF_TDA_P (op0))
1103 /* Substitute memory references involving a pointer, to use the ep pointer,
1104 taking care to save and preserve the ep. */
1107 substitute_ep_register (rtx first_insn,
1114 rtx reg = gen_rtx_REG (Pmode, regno);
1119 regs_ever_live[1] = 1;
1120 *p_r1 = gen_rtx_REG (Pmode, 1);
1121 *p_ep = gen_rtx_REG (Pmode, 30);
1126 Saved %d bytes (%d uses of register %s) in function %s, starting as insn %d, ending at %d\n",
1127 2 * (uses - 3), uses, reg_names[regno],
1128 IDENTIFIER_POINTER (DECL_NAME (current_function_decl)),
1129 INSN_UID (first_insn), INSN_UID (last_insn));
1131 if (GET_CODE (first_insn) == NOTE)
1132 first_insn = next_nonnote_insn (first_insn);
1134 last_insn = next_nonnote_insn (last_insn);
1135 for (insn = first_insn; insn && insn != last_insn; insn = NEXT_INSN (insn))
1137 if (GET_CODE (insn) == INSN)
1139 rtx pattern = single_set (insn);
1141 /* Replace the memory references. */
1145 /* Memory operands are signed by default. */
1146 int unsignedp = FALSE;
1148 if (GET_CODE (SET_DEST (pattern)) == MEM
1149 && GET_CODE (SET_SRC (pattern)) == MEM)
1152 else if (GET_CODE (SET_DEST (pattern)) == MEM)
1153 p_mem = &SET_DEST (pattern);
1155 else if (GET_CODE (SET_SRC (pattern)) == MEM)
1156 p_mem = &SET_SRC (pattern);
1158 else if (GET_CODE (SET_SRC (pattern)) == SIGN_EXTEND
1159 && GET_CODE (XEXP (SET_SRC (pattern), 0)) == MEM)
1160 p_mem = &XEXP (SET_SRC (pattern), 0);
1162 else if (GET_CODE (SET_SRC (pattern)) == ZERO_EXTEND
1163 && GET_CODE (XEXP (SET_SRC (pattern), 0)) == MEM)
1165 p_mem = &XEXP (SET_SRC (pattern), 0);
1173 rtx addr = XEXP (*p_mem, 0);
1175 if (GET_CODE (addr) == REG && REGNO (addr) == (unsigned) regno)
1176 *p_mem = change_address (*p_mem, VOIDmode, *p_ep);
1178 else if (GET_CODE (addr) == PLUS
1179 && GET_CODE (XEXP (addr, 0)) == REG
1180 && REGNO (XEXP (addr, 0)) == (unsigned) regno
1181 && GET_CODE (XEXP (addr, 1)) == CONST_INT
1182 && ((INTVAL (XEXP (addr, 1)))
1183 < ep_memory_offset (GET_MODE (*p_mem),
1185 && ((INTVAL (XEXP (addr, 1))) >= 0))
1186 *p_mem = change_address (*p_mem, VOIDmode,
1187 gen_rtx_PLUS (Pmode,
1195 /* Optimize back to back cases of ep <- r1 & r1 <- ep. */
1196 insn = prev_nonnote_insn (first_insn);
1197 if (insn && GET_CODE (insn) == INSN
1198 && GET_CODE (PATTERN (insn)) == SET
1199 && SET_DEST (PATTERN (insn)) == *p_ep
1200 && SET_SRC (PATTERN (insn)) == *p_r1)
1203 emit_insn_before (gen_rtx_SET (Pmode, *p_r1, *p_ep), first_insn);
1205 emit_insn_before (gen_rtx_SET (Pmode, *p_ep, reg), first_insn);
1206 emit_insn_before (gen_rtx_SET (Pmode, *p_ep, *p_r1), last_insn);
1210 /* TARGET_MACHINE_DEPENDENT_REORG. On the 850, we use it to implement
1211 the -mep mode to copy heavily used pointers to ep to use the implicit
1223 regs[FIRST_PSEUDO_REGISTER];
1232 /* If not ep mode, just return now. */
1236 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1239 regs[i].first_insn = NULL_RTX;
1240 regs[i].last_insn = NULL_RTX;
1243 for (insn = get_insns (); insn != NULL_RTX; insn = NEXT_INSN (insn))
1245 switch (GET_CODE (insn))
1247 /* End of basic block */
1254 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1256 if (max_uses < regs[i].uses)
1258 max_uses = regs[i].uses;
1264 substitute_ep_register (regs[max_regno].first_insn,
1265 regs[max_regno].last_insn,
1266 max_uses, max_regno, &r1, &ep);
1270 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1273 regs[i].first_insn = NULL_RTX;
1274 regs[i].last_insn = NULL_RTX;
1282 pattern = single_set (insn);
1284 /* See if there are any memory references we can shorten */
1287 rtx src = SET_SRC (pattern);
1288 rtx dest = SET_DEST (pattern);
1290 /* Memory operands are signed by default. */
1291 int unsignedp = FALSE;
1293 /* We might have (SUBREG (MEM)) here, so just get rid of the
1294 subregs to make this code simpler. */
1295 if (GET_CODE (dest) == SUBREG
1296 && (GET_CODE (SUBREG_REG (dest)) == MEM
1297 || GET_CODE (SUBREG_REG (dest)) == REG))
1298 alter_subreg (&dest);
1299 if (GET_CODE (src) == SUBREG
1300 && (GET_CODE (SUBREG_REG (src)) == MEM
1301 || GET_CODE (SUBREG_REG (src)) == REG))
1302 alter_subreg (&src);
1304 if (GET_CODE (dest) == MEM && GET_CODE (src) == MEM)
1307 else if (GET_CODE (dest) == MEM)
1310 else if (GET_CODE (src) == MEM)
1313 else if (GET_CODE (src) == SIGN_EXTEND
1314 && GET_CODE (XEXP (src, 0)) == MEM)
1315 mem = XEXP (src, 0);
1317 else if (GET_CODE (src) == ZERO_EXTEND
1318 && GET_CODE (XEXP (src, 0)) == MEM)
1320 mem = XEXP (src, 0);
1326 if (mem && ep_memory_operand (mem, GET_MODE (mem), unsignedp))
1329 else if (!use_ep && mem
1330 && GET_MODE_SIZE (GET_MODE (mem)) <= UNITS_PER_WORD)
1332 rtx addr = XEXP (mem, 0);
1336 if (GET_CODE (addr) == REG)
1339 regno = REGNO (addr);
1342 else if (GET_CODE (addr) == PLUS
1343 && GET_CODE (XEXP (addr, 0)) == REG
1344 && GET_CODE (XEXP (addr, 1)) == CONST_INT
1345 && ((INTVAL (XEXP (addr, 1)))
1346 < ep_memory_offset (GET_MODE (mem), unsignedp))
1347 && ((INTVAL (XEXP (addr, 1))) >= 0))
1350 regno = REGNO (XEXP (addr, 0));
1359 regs[regno].last_insn = insn;
1360 if (!regs[regno].first_insn)
1361 regs[regno].first_insn = insn;
1365 /* Loading up a register in the basic block zaps any savings
1367 if (GET_CODE (dest) == REG)
1369 enum machine_mode mode = GET_MODE (dest);
1373 regno = REGNO (dest);
1374 endregno = regno + HARD_REGNO_NREGS (regno, mode);
1378 /* See if we can use the pointer before this
1383 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1385 if (max_uses < regs[i].uses)
1387 max_uses = regs[i].uses;
1393 && max_regno >= regno
1394 && max_regno < endregno)
1396 substitute_ep_register (regs[max_regno].first_insn,
1397 regs[max_regno].last_insn,
1398 max_uses, max_regno, &r1,
1401 /* Since we made a substitution, zap all remembered
1403 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1406 regs[i].first_insn = NULL_RTX;
1407 regs[i].last_insn = NULL_RTX;
1412 for (i = regno; i < endregno; i++)
1415 regs[i].first_insn = NULL_RTX;
1416 regs[i].last_insn = NULL_RTX;
1425 /* # of registers saved by the interrupt handler. */
1426 #define INTERRUPT_FIXED_NUM 4
1428 /* # of bytes for registers saved by the interrupt handler. */
1429 #define INTERRUPT_FIXED_SAVE_SIZE (4 * INTERRUPT_FIXED_NUM)
1431 /* # of registers saved in register parameter area. */
1432 #define INTERRUPT_REGPARM_NUM 4
1433 /* # of words saved for other registers. */
1434 #define INTERRUPT_ALL_SAVE_NUM \
1435 (30 - INTERRUPT_FIXED_NUM + INTERRUPT_REGPARM_NUM)
1437 #define INTERRUPT_ALL_SAVE_SIZE (4 * INTERRUPT_ALL_SAVE_NUM)
1440 compute_register_save_size (long * p_reg_saved)
1444 int interrupt_handler = v850_interrupt_function_p (current_function_decl);
1445 int call_p = regs_ever_live [LINK_POINTER_REGNUM];
1448 /* Count the return pointer if we need to save it. */
1449 if (current_function_profile && !call_p)
1450 regs_ever_live [LINK_POINTER_REGNUM] = call_p = 1;
1452 /* Count space for the register saves. */
1453 if (interrupt_handler)
1455 for (i = 0; i <= 31; i++)
1459 if (regs_ever_live[i] || call_p)
1462 reg_saved |= 1L << i;
1466 /* We don't save/restore r0 or the stack pointer */
1468 case STACK_POINTER_REGNUM:
1471 /* For registers with fixed use, we save them, set them to the
1472 appropriate value, and then restore them.
1473 These registers are handled specially, so don't list them
1474 on the list of registers to save in the prologue. */
1475 case 1: /* temp used to hold ep */
1477 case 10: /* temp used to call interrupt save/restore */
1478 case EP_REGNUM: /* ep */
1485 /* Find the first register that needs to be saved. */
1486 for (i = 0; i <= 31; i++)
1487 if (regs_ever_live[i] && ((! call_used_regs[i])
1488 || i == LINK_POINTER_REGNUM))
1491 /* If it is possible that an out-of-line helper function might be
1492 used to generate the prologue for the current function, then we
1493 need to cover the possibility that such a helper function will
1494 be used, despite the fact that there might be gaps in the list of
1495 registers that need to be saved. To detect this we note that the
1496 helper functions always push at least register r29 (provided
1497 that the function is not an interrupt handler). */
1499 if (TARGET_PROLOG_FUNCTION
1500 && (i == 2 || ((i >= 20) && (i < 30))))
1505 reg_saved |= 1L << i;
1510 /* Helper functions save all registers between the starting
1511 register and the last register, regardless of whether they
1512 are actually used by the function or not. */
1513 for (; i <= 29; i++)
1516 reg_saved |= 1L << i;
1519 if (regs_ever_live [LINK_POINTER_REGNUM])
1522 reg_saved |= 1L << LINK_POINTER_REGNUM;
1527 for (; i <= 31; i++)
1528 if (regs_ever_live[i] && ((! call_used_regs[i])
1529 || i == LINK_POINTER_REGNUM))
1532 reg_saved |= 1L << i;
1538 *p_reg_saved = reg_saved;
1544 compute_frame_size (int size, long * p_reg_saved)
1547 + compute_register_save_size (p_reg_saved)
1548 + current_function_outgoing_args_size);
1553 expand_prologue (void)
1557 unsigned int size = get_frame_size ();
1558 unsigned int actual_fsize;
1559 unsigned int init_stack_alloc = 0;
1562 unsigned int num_save;
1563 unsigned int default_stack;
1565 int interrupt_handler = v850_interrupt_function_p (current_function_decl);
1568 actual_fsize = compute_frame_size (size, ®_saved);
1570 /* Save/setup global registers for interrupt functions right now. */
1571 if (interrupt_handler)
1573 if (TARGET_V850E && ! TARGET_DISABLE_CALLT)
1574 emit_insn (gen_callt_save_interrupt ());
1576 emit_insn (gen_save_interrupt ());
1578 actual_fsize -= INTERRUPT_FIXED_SAVE_SIZE;
1580 if (((1L << LINK_POINTER_REGNUM) & reg_saved) != 0)
1581 actual_fsize -= INTERRUPT_ALL_SAVE_SIZE;
1584 /* Save arg registers to the stack if necessary. */
1585 else if (current_function_args_info.anonymous_args)
1587 if (TARGET_PROLOG_FUNCTION && TARGET_V850E && !TARGET_DISABLE_CALLT)
1588 emit_insn (gen_save_r6_r9_v850e ());
1589 else if (TARGET_PROLOG_FUNCTION && ! TARGET_LONG_CALLS)
1590 emit_insn (gen_save_r6_r9 ());
1594 for (i = 6; i < 10; i++)
1596 emit_move_insn (gen_rtx_MEM (SImode,
1597 plus_constant (stack_pointer_rtx,
1599 gen_rtx_REG (SImode, i));
1605 /* Identify all of the saved registers. */
1608 for (i = 1; i < 31; i++)
1610 if (((1L << i) & reg_saved) != 0)
1611 save_regs[num_save++] = gen_rtx_REG (Pmode, i);
1614 /* If the return pointer is saved, the helper functions also allocate
1615 16 bytes of stack for arguments to be saved in. */
1616 if (((1L << LINK_POINTER_REGNUM) & reg_saved) != 0)
1618 save_regs[num_save++] = gen_rtx_REG (Pmode, LINK_POINTER_REGNUM);
1622 /* See if we have an insn that allocates stack space and saves the particular
1623 registers we want to. */
1624 save_all = NULL_RTX;
1625 if (TARGET_PROLOG_FUNCTION && num_save > 0 && actual_fsize >= default_stack)
1627 int alloc_stack = (4 * num_save) + default_stack;
1628 int unalloc_stack = actual_fsize - alloc_stack;
1629 int save_func_len = 4;
1630 int save_normal_len;
1633 save_func_len += CONST_OK_FOR_J (unalloc_stack) ? 2 : 4;
1635 /* see if we would have used ep to save the stack */
1636 if (TARGET_EP && num_save > 3 && (unsigned)actual_fsize < 255)
1637 save_normal_len = (3 * 2) + (2 * num_save);
1639 save_normal_len = 4 * num_save;
1641 save_normal_len += CONST_OK_FOR_J (actual_fsize) ? 2 : 4;
1643 /* Don't bother checking if we don't actually save any space.
1644 This happens for instance if one register is saved and additional
1645 stack space is allocated. */
1646 if (save_func_len < save_normal_len)
1648 save_all = gen_rtx_PARALLEL
1650 rtvec_alloc (num_save + 1
1651 + (TARGET_V850 ? (TARGET_LONG_CALLS ? 2 : 1) : 0)));
1653 XVECEXP (save_all, 0, 0)
1654 = gen_rtx_SET (VOIDmode,
1656 plus_constant (stack_pointer_rtx, -alloc_stack));
1658 offset = - default_stack;
1659 for (i = 0; i < num_save; i++)
1661 XVECEXP (save_all, 0, i+1)
1662 = gen_rtx_SET (VOIDmode,
1664 plus_constant (stack_pointer_rtx,
1672 XVECEXP (save_all, 0, num_save + 1)
1673 = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (Pmode, 10));
1675 if (TARGET_LONG_CALLS)
1676 XVECEXP (save_all, 0, num_save + 2)
1677 = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (Pmode, 11));
1680 code = recog (save_all, NULL_RTX, NULL);
1683 rtx insn = emit_insn (save_all);
1684 INSN_CODE (insn) = code;
1685 actual_fsize -= alloc_stack;
1689 Saved %d bytes via prologue function (%d vs. %d) for function %s\n",
1690 save_normal_len - save_func_len,
1691 save_normal_len, save_func_len,
1692 IDENTIFIER_POINTER (DECL_NAME (current_function_decl)));
1695 save_all = NULL_RTX;
1699 /* If no prolog save function is available, store the registers the old
1700 fashioned way (one by one). */
1703 /* Special case interrupt functions that save all registers for a call. */
1704 if (interrupt_handler && ((1L << LINK_POINTER_REGNUM) & reg_saved) != 0)
1706 if (TARGET_V850E && ! TARGET_DISABLE_CALLT)
1707 emit_insn (gen_callt_save_all_interrupt ());
1709 emit_insn (gen_save_all_interrupt ());
1713 /* If the stack is too big, allocate it in chunks so we can do the
1714 register saves. We use the register save size so we use the ep
1716 if (actual_fsize && !CONST_OK_FOR_K (-actual_fsize))
1717 init_stack_alloc = compute_register_save_size (NULL);
1719 init_stack_alloc = actual_fsize;
1721 /* Save registers at the beginning of the stack frame. */
1722 offset = init_stack_alloc - 4;
1724 if (init_stack_alloc)
1725 emit_insn (gen_addsi3 (stack_pointer_rtx,
1727 GEN_INT (-init_stack_alloc)));
1729 /* Save the return pointer first. */
1730 if (num_save > 0 && REGNO (save_regs[num_save-1]) == LINK_POINTER_REGNUM)
1732 emit_move_insn (gen_rtx_MEM (SImode,
1733 plus_constant (stack_pointer_rtx,
1735 save_regs[--num_save]);
1739 for (i = 0; i < num_save; i++)
1741 emit_move_insn (gen_rtx_MEM (SImode,
1742 plus_constant (stack_pointer_rtx,
1750 /* Allocate the rest of the stack that was not allocated above (either it is
1751 > 32K or we just called a function to save the registers and needed more
1753 if (actual_fsize > init_stack_alloc)
1755 int diff = actual_fsize - init_stack_alloc;
1756 if (CONST_OK_FOR_K (diff))
1757 emit_insn (gen_addsi3 (stack_pointer_rtx,
1762 rtx reg = gen_rtx_REG (Pmode, 12);
1763 emit_move_insn (reg, GEN_INT (-diff));
1764 emit_insn (gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx, reg));
1768 /* If we need a frame pointer, set it up now. */
1769 if (frame_pointer_needed)
1770 emit_move_insn (hard_frame_pointer_rtx, stack_pointer_rtx);
1775 expand_epilogue (void)
1779 unsigned int size = get_frame_size ();
1781 unsigned int actual_fsize = compute_frame_size (size, ®_saved);
1782 unsigned int init_stack_free = 0;
1783 rtx restore_regs[32];
1785 unsigned int num_restore;
1786 unsigned int default_stack;
1788 int interrupt_handler = v850_interrupt_function_p (current_function_decl);
1790 /* Eliminate the initial stack stored by interrupt functions. */
1791 if (interrupt_handler)
1793 actual_fsize -= INTERRUPT_FIXED_SAVE_SIZE;
1794 if (((1L << LINK_POINTER_REGNUM) & reg_saved) != 0)
1795 actual_fsize -= INTERRUPT_ALL_SAVE_SIZE;
1798 /* Cut off any dynamic stack created. */
1799 if (frame_pointer_needed)
1800 emit_move_insn (stack_pointer_rtx, hard_frame_pointer_rtx);
1802 /* Identify all of the saved registers. */
1805 for (i = 1; i < 31; i++)
1807 if (((1L << i) & reg_saved) != 0)
1808 restore_regs[num_restore++] = gen_rtx_REG (Pmode, i);
1811 /* If the return pointer is saved, the helper functions also allocate
1812 16 bytes of stack for arguments to be saved in. */
1813 if (((1L << LINK_POINTER_REGNUM) & reg_saved) != 0)
1815 restore_regs[num_restore++] = gen_rtx_REG (Pmode, LINK_POINTER_REGNUM);
1819 /* See if we have an insn that restores the particular registers we
1821 restore_all = NULL_RTX;
1823 if (TARGET_PROLOG_FUNCTION
1825 && actual_fsize >= default_stack
1826 && !interrupt_handler)
1828 int alloc_stack = (4 * num_restore) + default_stack;
1829 int unalloc_stack = actual_fsize - alloc_stack;
1830 int restore_func_len = 4;
1831 int restore_normal_len;
1834 restore_func_len += CONST_OK_FOR_J (unalloc_stack) ? 2 : 4;
1836 /* See if we would have used ep to restore the registers. */
1837 if (TARGET_EP && num_restore > 3 && (unsigned)actual_fsize < 255)
1838 restore_normal_len = (3 * 2) + (2 * num_restore);
1840 restore_normal_len = 4 * num_restore;
1842 restore_normal_len += (CONST_OK_FOR_J (actual_fsize) ? 2 : 4) + 2;
1844 /* Don't bother checking if we don't actually save any space. */
1845 if (restore_func_len < restore_normal_len)
1847 restore_all = gen_rtx_PARALLEL (VOIDmode,
1848 rtvec_alloc (num_restore + 2));
1849 XVECEXP (restore_all, 0, 0) = gen_rtx_RETURN (VOIDmode);
1850 XVECEXP (restore_all, 0, 1)
1851 = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
1852 gen_rtx_PLUS (Pmode,
1854 GEN_INT (alloc_stack)));
1856 offset = alloc_stack - 4;
1857 for (i = 0; i < num_restore; i++)
1859 XVECEXP (restore_all, 0, i+2)
1860 = gen_rtx_SET (VOIDmode,
1863 plus_constant (stack_pointer_rtx,
1868 code = recog (restore_all, NULL_RTX, NULL);
1874 actual_fsize -= alloc_stack;
1877 if (CONST_OK_FOR_K (actual_fsize))
1878 emit_insn (gen_addsi3 (stack_pointer_rtx,
1880 GEN_INT (actual_fsize)));
1883 rtx reg = gen_rtx_REG (Pmode, 12);
1884 emit_move_insn (reg, GEN_INT (actual_fsize));
1885 emit_insn (gen_addsi3 (stack_pointer_rtx,
1891 insn = emit_jump_insn (restore_all);
1892 INSN_CODE (insn) = code;
1896 Saved %d bytes via epilogue function (%d vs. %d) in function %s\n",
1897 restore_normal_len - restore_func_len,
1898 restore_normal_len, restore_func_len,
1899 IDENTIFIER_POINTER (DECL_NAME (current_function_decl)));
1902 restore_all = NULL_RTX;
1906 /* If no epilog save function is available, restore the registers the
1907 old fashioned way (one by one). */
1910 /* If the stack is large, we need to cut it down in 2 pieces. */
1911 if (actual_fsize && !CONST_OK_FOR_K (-actual_fsize))
1912 init_stack_free = 4 * num_restore;
1914 init_stack_free = actual_fsize;
1916 /* Deallocate the rest of the stack if it is > 32K. */
1917 if (actual_fsize > init_stack_free)
1921 diff = actual_fsize - ((interrupt_handler) ? 0 : init_stack_free);
1923 if (CONST_OK_FOR_K (diff))
1924 emit_insn (gen_addsi3 (stack_pointer_rtx,
1929 rtx reg = gen_rtx_REG (Pmode, 12);
1930 emit_move_insn (reg, GEN_INT (diff));
1931 emit_insn (gen_addsi3 (stack_pointer_rtx,
1937 /* Special case interrupt functions that save all registers
1939 if (interrupt_handler && ((1L << LINK_POINTER_REGNUM) & reg_saved) != 0)
1941 if (TARGET_V850E && ! TARGET_DISABLE_CALLT)
1942 emit_insn (gen_callt_restore_all_interrupt ());
1944 emit_insn (gen_restore_all_interrupt ());
1948 /* Restore registers from the beginning of the stack frame. */
1949 offset = init_stack_free - 4;
1951 /* Restore the return pointer first. */
1953 && REGNO (restore_regs [num_restore - 1]) == LINK_POINTER_REGNUM)
1955 emit_move_insn (restore_regs[--num_restore],
1956 gen_rtx_MEM (SImode,
1957 plus_constant (stack_pointer_rtx,
1962 for (i = 0; i < num_restore; i++)
1964 emit_move_insn (restore_regs[i],
1965 gen_rtx_MEM (SImode,
1966 plus_constant (stack_pointer_rtx,
1969 emit_insn (gen_rtx_USE (VOIDmode, restore_regs[i]));
1973 /* Cut back the remainder of the stack. */
1974 if (init_stack_free)
1975 emit_insn (gen_addsi3 (stack_pointer_rtx,
1977 GEN_INT (init_stack_free)));
1980 /* And return or use reti for interrupt handlers. */
1981 if (interrupt_handler)
1983 if (TARGET_V850E && ! TARGET_DISABLE_CALLT)
1984 emit_insn (gen_callt_return_interrupt ());
1986 emit_jump_insn (gen_return_interrupt ());
1988 else if (actual_fsize)
1989 emit_jump_insn (gen_return_internal ());
1991 emit_jump_insn (gen_return ());
1994 v850_interrupt_cache_p = FALSE;
1995 v850_interrupt_p = FALSE;
1999 /* Update the condition code from the insn. */
2002 notice_update_cc (rtx body, rtx insn)
2004 switch (get_attr_cc (insn))
2007 /* Insn does not affect CC at all. */
2011 /* Insn does not change CC, but the 0'th operand has been changed. */
2012 if (cc_status.value1 != 0
2013 && reg_overlap_mentioned_p (recog_data.operand[0], cc_status.value1))
2014 cc_status.value1 = 0;
2018 /* Insn sets the Z,N flags of CC to recog_data.operand[0].
2019 V,C is in an unusable state. */
2021 cc_status.flags |= CC_OVERFLOW_UNUSABLE | CC_NO_CARRY;
2022 cc_status.value1 = recog_data.operand[0];
2026 /* Insn sets the Z,N,V flags of CC to recog_data.operand[0].
2027 C is in an unusable state. */
2029 cc_status.flags |= CC_NO_CARRY;
2030 cc_status.value1 = recog_data.operand[0];
2034 /* The insn is a compare instruction. */
2036 cc_status.value1 = SET_SRC (body);
2040 /* Insn doesn't leave CC in a usable state. */
2046 /* Retrieve the data area that has been chosen for the given decl. */
2049 v850_get_data_area (tree decl)
2051 if (lookup_attribute ("sda", DECL_ATTRIBUTES (decl)) != NULL_TREE)
2052 return DATA_AREA_SDA;
2054 if (lookup_attribute ("tda", DECL_ATTRIBUTES (decl)) != NULL_TREE)
2055 return DATA_AREA_TDA;
2057 if (lookup_attribute ("zda", DECL_ATTRIBUTES (decl)) != NULL_TREE)
2058 return DATA_AREA_ZDA;
2060 return DATA_AREA_NORMAL;
2063 /* Store the indicated data area in the decl's attributes. */
2066 v850_set_data_area (tree decl, v850_data_area data_area)
2072 case DATA_AREA_SDA: name = get_identifier ("sda"); break;
2073 case DATA_AREA_TDA: name = get_identifier ("tda"); break;
2074 case DATA_AREA_ZDA: name = get_identifier ("zda"); break;
2079 DECL_ATTRIBUTES (decl) = tree_cons
2080 (name, NULL, DECL_ATTRIBUTES (decl));
2083 const struct attribute_spec v850_attribute_table[] =
2085 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2086 { "interrupt_handler", 0, 0, true, false, false, v850_handle_interrupt_attribute },
2087 { "interrupt", 0, 0, true, false, false, v850_handle_interrupt_attribute },
2088 { "sda", 0, 0, true, false, false, v850_handle_data_area_attribute },
2089 { "tda", 0, 0, true, false, false, v850_handle_data_area_attribute },
2090 { "zda", 0, 0, true, false, false, v850_handle_data_area_attribute },
2091 { NULL, 0, 0, false, false, false, NULL }
2094 /* Handle an "interrupt" attribute; arguments as in
2095 struct attribute_spec.handler. */
2097 v850_handle_interrupt_attribute (tree * node,
2099 tree args ATTRIBUTE_UNUSED,
2100 int flags ATTRIBUTE_UNUSED,
2101 bool * no_add_attrs)
2103 if (TREE_CODE (*node) != FUNCTION_DECL)
2105 warning (0, "%qs attribute only applies to functions",
2106 IDENTIFIER_POINTER (name));
2107 *no_add_attrs = true;
2113 /* Handle a "sda", "tda" or "zda" attribute; arguments as in
2114 struct attribute_spec.handler. */
2116 v850_handle_data_area_attribute (tree* node,
2118 tree args ATTRIBUTE_UNUSED,
2119 int flags ATTRIBUTE_UNUSED,
2120 bool * no_add_attrs)
2122 v850_data_area data_area;
2123 v850_data_area area;
2126 /* Implement data area attribute. */
2127 if (is_attribute_p ("sda", name))
2128 data_area = DATA_AREA_SDA;
2129 else if (is_attribute_p ("tda", name))
2130 data_area = DATA_AREA_TDA;
2131 else if (is_attribute_p ("zda", name))
2132 data_area = DATA_AREA_ZDA;
2136 switch (TREE_CODE (decl))
2139 if (current_function_decl != NULL_TREE)
2141 error ("%Jdata area attributes cannot be specified for "
2142 "local variables", decl, decl);
2143 *no_add_attrs = true;
2149 area = v850_get_data_area (decl);
2150 if (area != DATA_AREA_NORMAL && data_area != area)
2152 error ("%Jdata area of '%D' conflicts with previous declaration",
2154 *no_add_attrs = true;
2166 /* Return nonzero if FUNC is an interrupt function as specified
2167 by the "interrupt" attribute. */
2170 v850_interrupt_function_p (tree func)
2175 if (v850_interrupt_cache_p)
2176 return v850_interrupt_p;
2178 if (TREE_CODE (func) != FUNCTION_DECL)
2181 a = lookup_attribute ("interrupt_handler", DECL_ATTRIBUTES (func));
2187 a = lookup_attribute ("interrupt", DECL_ATTRIBUTES (func));
2188 ret = a != NULL_TREE;
2191 /* Its not safe to trust global variables until after function inlining has
2193 if (reload_completed | reload_in_progress)
2194 v850_interrupt_p = ret;
2201 v850_encode_data_area (tree decl, rtx symbol)
2205 /* Map explicit sections into the appropriate attribute */
2206 if (v850_get_data_area (decl) == DATA_AREA_NORMAL)
2208 if (DECL_SECTION_NAME (decl))
2210 const char *name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
2212 if (streq (name, ".zdata") || streq (name, ".zbss"))
2213 v850_set_data_area (decl, DATA_AREA_ZDA);
2215 else if (streq (name, ".sdata") || streq (name, ".sbss"))
2216 v850_set_data_area (decl, DATA_AREA_SDA);
2218 else if (streq (name, ".tdata"))
2219 v850_set_data_area (decl, DATA_AREA_TDA);
2222 /* If no attribute, support -m{zda,sda,tda}=n */
2225 int size = int_size_in_bytes (TREE_TYPE (decl));
2229 else if (size <= small_memory [(int) SMALL_MEMORY_TDA].max)
2230 v850_set_data_area (decl, DATA_AREA_TDA);
2232 else if (size <= small_memory [(int) SMALL_MEMORY_SDA].max)
2233 v850_set_data_area (decl, DATA_AREA_SDA);
2235 else if (size <= small_memory [(int) SMALL_MEMORY_ZDA].max)
2236 v850_set_data_area (decl, DATA_AREA_ZDA);
2239 if (v850_get_data_area (decl) == DATA_AREA_NORMAL)
2243 flags = SYMBOL_REF_FLAGS (symbol);
2244 switch (v850_get_data_area (decl))
2246 case DATA_AREA_ZDA: flags |= SYMBOL_FLAG_ZDA; break;
2247 case DATA_AREA_TDA: flags |= SYMBOL_FLAG_TDA; break;
2248 case DATA_AREA_SDA: flags |= SYMBOL_FLAG_SDA; break;
2251 SYMBOL_REF_FLAGS (symbol) = flags;
2255 v850_encode_section_info (tree decl, rtx rtl, int first)
2257 default_encode_section_info (decl, rtl, first);
2259 if (TREE_CODE (decl) == VAR_DECL
2260 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
2261 v850_encode_data_area (decl, XEXP (rtl, 0));
2264 /* Construct a JR instruction to a routine that will perform the equivalent of
2265 the RTL passed in as an argument. This RTL is a function epilogue that
2266 pops registers off the stack and possibly releases some extra stack space
2267 as well. The code has already verified that the RTL matches these
2270 construct_restore_jr (rtx op)
2272 int count = XVECLEN (op, 0);
2274 unsigned long int mask;
2275 unsigned long int first;
2276 unsigned long int last;
2278 static char buff [100]; /* XXX */
2282 error ("bogus JR construction: %d\n", count);
2286 /* Work out how many bytes to pop off the stack before retrieving
2288 if (GET_CODE (XVECEXP (op, 0, 1)) != SET)
2290 if (GET_CODE (SET_SRC (XVECEXP (op, 0, 1))) != PLUS)
2292 if (GET_CODE (XEXP (SET_SRC (XVECEXP (op, 0, 1)), 1)) != CONST_INT)
2295 stack_bytes = INTVAL (XEXP (SET_SRC (XVECEXP (op, 0, 1)), 1));
2297 /* Each pop will remove 4 bytes from the stack.... */
2298 stack_bytes -= (count - 2) * 4;
2300 /* Make sure that the amount we are popping either 0 or 16 bytes. */
2301 if (stack_bytes != 0 && stack_bytes != 16)
2303 error ("bad amount of stack space removal: %d", stack_bytes);
2307 /* Now compute the bit mask of registers to push. */
2309 for (i = 2; i < count; i++)
2311 rtx vector_element = XVECEXP (op, 0, i);
2313 if (GET_CODE (vector_element) != SET)
2315 if (GET_CODE (SET_DEST (vector_element)) != REG)
2317 if (! register_is_ok_for_epilogue (SET_DEST (vector_element), SImode))
2320 mask |= 1 << REGNO (SET_DEST (vector_element));
2323 /* Scan for the first register to pop. */
2324 for (first = 0; first < 32; first++)
2326 if (mask & (1 << first))
2333 /* Discover the last register to pop. */
2334 if (mask & (1 << LINK_POINTER_REGNUM))
2336 if (stack_bytes != 16)
2339 last = LINK_POINTER_REGNUM;
2343 if (stack_bytes != 0)
2346 if ((mask & (1 << 29)) == 0)
2352 /* Note, it is possible to have gaps in the register mask.
2353 We ignore this here, and generate a JR anyway. We will
2354 be popping more registers than is strictly necessary, but
2355 it does save code space. */
2357 if (TARGET_LONG_CALLS)
2362 sprintf (name, "__return_%s", reg_names [first]);
2364 sprintf (name, "__return_%s_%s", reg_names [first], reg_names [last]);
2366 sprintf (buff, "movhi hi(%s), r0, r6\n\tmovea lo(%s), r6, r6\n\tjmp r6",
2372 sprintf (buff, "jr __return_%s", reg_names [first]);
2374 sprintf (buff, "jr __return_%s_%s", reg_names [first], reg_names [last]);
2381 /* Construct a JARL instruction to a routine that will perform the equivalent
2382 of the RTL passed as a parameter. This RTL is a function prologue that
2383 saves some of the registers r20 - r31 onto the stack, and possibly acquires
2384 some stack space as well. The code has already verified that the RTL
2385 matches these requirements. */
2387 construct_save_jarl (rtx op)
2389 int count = XVECLEN (op, 0);
2391 unsigned long int mask;
2392 unsigned long int first;
2393 unsigned long int last;
2395 static char buff [100]; /* XXX */
2399 error ("bogus JARL construction: %d\n", count);
2404 if (GET_CODE (XVECEXP (op, 0, 0)) != SET)
2406 if (GET_CODE (SET_SRC (XVECEXP (op, 0, 0))) != PLUS)
2408 if (GET_CODE (XEXP (SET_SRC (XVECEXP (op, 0, 0)), 0)) != REG)
2410 if (GET_CODE (XEXP (SET_SRC (XVECEXP (op, 0, 0)), 1)) != CONST_INT)
2413 /* Work out how many bytes to push onto the stack after storing the
2415 stack_bytes = INTVAL (XEXP (SET_SRC (XVECEXP (op, 0, 0)), 1));
2417 /* Each push will put 4 bytes from the stack.... */
2418 stack_bytes += (count - (TARGET_LONG_CALLS ? 3 : 2)) * 4;
2420 /* Make sure that the amount we are popping either 0 or 16 bytes. */
2421 if (stack_bytes != 0 && stack_bytes != -16)
2423 error ("bad amount of stack space removal: %d", stack_bytes);
2427 /* Now compute the bit mask of registers to push. */
2429 for (i = 1; i < count - (TARGET_LONG_CALLS ? 2 : 1); i++)
2431 rtx vector_element = XVECEXP (op, 0, i);
2433 if (GET_CODE (vector_element) != SET)
2435 if (GET_CODE (SET_SRC (vector_element)) != REG)
2437 if (! register_is_ok_for_epilogue (SET_SRC (vector_element), SImode))
2440 mask |= 1 << REGNO (SET_SRC (vector_element));
2443 /* Scan for the first register to push. */
2444 for (first = 0; first < 32; first++)
2446 if (mask & (1 << first))
2453 /* Discover the last register to push. */
2454 if (mask & (1 << LINK_POINTER_REGNUM))
2456 if (stack_bytes != -16)
2459 last = LINK_POINTER_REGNUM;
2463 if (stack_bytes != 0)
2465 if ((mask & (1 << 29)) == 0)
2471 /* Note, it is possible to have gaps in the register mask.
2472 We ignore this here, and generate a JARL anyway. We will
2473 be pushing more registers than is strictly necessary, but
2474 it does save code space. */
2476 if (TARGET_LONG_CALLS)
2481 sprintf (name, "__save_%s", reg_names [first]);
2483 sprintf (name, "__save_%s_%s", reg_names [first], reg_names [last]);
2485 sprintf (buff, "movhi hi(%s), r0, r11\n\tmovea lo(%s), r11, r11\n\tjarl .+4, r10\n\tadd 4, r10\n\tjmp r11",
2491 sprintf (buff, "jarl __save_%s, r10", reg_names [first]);
2493 sprintf (buff, "jarl __save_%s_%s, r10", reg_names [first],
2500 extern tree last_assemble_variable_decl;
2501 extern int size_directive_output;
2503 /* A version of asm_output_aligned_bss() that copes with the special
2504 data areas of the v850. */
2506 v850_output_aligned_bss (FILE * file,
2512 switch (v850_get_data_area (decl))
2530 ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
2531 #ifdef ASM_DECLARE_OBJECT_NAME
2532 last_assemble_variable_decl = decl;
2533 ASM_DECLARE_OBJECT_NAME (file, name, decl);
2535 /* Standard thing is just output label for the object. */
2536 ASM_OUTPUT_LABEL (file, name);
2537 #endif /* ASM_DECLARE_OBJECT_NAME */
2538 ASM_OUTPUT_SKIP (file, size ? size : 1);
2541 /* Called via the macro ASM_OUTPUT_DECL_COMMON */
2543 v850_output_common (FILE * file,
2549 if (decl == NULL_TREE)
2551 fprintf (file, "%s", COMMON_ASM_OP);
2555 switch (v850_get_data_area (decl))
2558 fprintf (file, "%s", ZCOMMON_ASM_OP);
2562 fprintf (file, "%s", SCOMMON_ASM_OP);
2566 fprintf (file, "%s", TCOMMON_ASM_OP);
2570 fprintf (file, "%s", COMMON_ASM_OP);
2575 assemble_name (file, name);
2576 fprintf (file, ",%u,%u\n", size, align / BITS_PER_UNIT);
2579 /* Called via the macro ASM_OUTPUT_DECL_LOCAL */
2581 v850_output_local (FILE * file,
2587 fprintf (file, "%s", LOCAL_ASM_OP);
2588 assemble_name (file, name);
2589 fprintf (file, "\n");
2591 ASM_OUTPUT_ALIGNED_DECL_COMMON (file, decl, name, size, align);
2594 /* Add data area to the given declaration if a ghs data area pragma is
2595 currently in effect (#pragma ghs startXXX/endXXX). */
2597 v850_insert_attributes (tree decl, tree * attr_ptr ATTRIBUTE_UNUSED )
2600 && data_area_stack->data_area
2601 && current_function_decl == NULL_TREE
2602 && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == CONST_DECL)
2603 && v850_get_data_area (decl) == DATA_AREA_NORMAL)
2604 v850_set_data_area (decl, data_area_stack->data_area);
2606 /* Initialize the default names of the v850 specific sections,
2607 if this has not been done before. */
2609 if (GHS_default_section_names [(int) GHS_SECTION_KIND_SDATA] == NULL)
2611 GHS_default_section_names [(int) GHS_SECTION_KIND_SDATA]
2612 = build_string (sizeof (".sdata")-1, ".sdata");
2614 GHS_default_section_names [(int) GHS_SECTION_KIND_ROSDATA]
2615 = build_string (sizeof (".rosdata")-1, ".rosdata");
2617 GHS_default_section_names [(int) GHS_SECTION_KIND_TDATA]
2618 = build_string (sizeof (".tdata")-1, ".tdata");
2620 GHS_default_section_names [(int) GHS_SECTION_KIND_ZDATA]
2621 = build_string (sizeof (".zdata")-1, ".zdata");
2623 GHS_default_section_names [(int) GHS_SECTION_KIND_ROZDATA]
2624 = build_string (sizeof (".rozdata")-1, ".rozdata");
2627 if (current_function_decl == NULL_TREE
2628 && (TREE_CODE (decl) == VAR_DECL
2629 || TREE_CODE (decl) == CONST_DECL
2630 || TREE_CODE (decl) == FUNCTION_DECL)
2631 && (!DECL_EXTERNAL (decl) || DECL_INITIAL (decl))
2632 && !DECL_SECTION_NAME (decl))
2634 enum GHS_section_kind kind = GHS_SECTION_KIND_DEFAULT;
2635 tree chosen_section;
2637 if (TREE_CODE (decl) == FUNCTION_DECL)
2638 kind = GHS_SECTION_KIND_TEXT;
2641 /* First choose a section kind based on the data area of the decl. */
2642 switch (v850_get_data_area (decl))
2648 kind = ((TREE_READONLY (decl))
2649 ? GHS_SECTION_KIND_ROSDATA
2650 : GHS_SECTION_KIND_SDATA);
2654 kind = GHS_SECTION_KIND_TDATA;
2658 kind = ((TREE_READONLY (decl))
2659 ? GHS_SECTION_KIND_ROZDATA
2660 : GHS_SECTION_KIND_ZDATA);
2663 case DATA_AREA_NORMAL: /* default data area */
2664 if (TREE_READONLY (decl))
2665 kind = GHS_SECTION_KIND_RODATA;
2666 else if (DECL_INITIAL (decl))
2667 kind = GHS_SECTION_KIND_DATA;
2669 kind = GHS_SECTION_KIND_BSS;
2673 /* Now, if the section kind has been explicitly renamed,
2674 then attach a section attribute. */
2675 chosen_section = GHS_current_section_names [(int) kind];
2677 /* Otherwise, if this kind of section needs an explicit section
2678 attribute, then also attach one. */
2679 if (chosen_section == NULL)
2680 chosen_section = GHS_default_section_names [(int) kind];
2684 /* Only set the section name if specified by a pragma, because
2685 otherwise it will force those variables to get allocated storage
2686 in this module, rather than by the linker. */
2687 DECL_SECTION_NAME (decl) = chosen_section;
2692 /* Construct a DISPOSE instruction that is the equivalent of
2693 the given RTX. We have already verified that this should
2697 construct_dispose_instruction (rtx op)
2699 int count = XVECLEN (op, 0);
2701 unsigned long int mask;
2703 static char buff[ 100 ]; /* XXX */
2708 error ("Bogus DISPOSE construction: %d\n", count);
2712 /* Work out how many bytes to pop off the
2713 stack before retrieving registers. */
2714 if (GET_CODE (XVECEXP (op, 0, 1)) != SET)
2716 if (GET_CODE (SET_SRC (XVECEXP (op, 0, 1))) != PLUS)
2718 if (GET_CODE (XEXP (SET_SRC (XVECEXP (op, 0, 1)), 1)) != CONST_INT)
2721 stack_bytes = INTVAL (XEXP (SET_SRC (XVECEXP (op, 0, 1)), 1));
2723 /* Each pop will remove 4 bytes from the stack.... */
2724 stack_bytes -= (count - 2) * 4;
2726 /* Make sure that the amount we are popping
2727 will fit into the DISPOSE instruction. */
2728 if (stack_bytes > 128)
2730 error ("Too much stack space to dispose of: %d", stack_bytes);
2734 /* Now compute the bit mask of registers to push. */
2737 for (i = 2; i < count; i++)
2739 rtx vector_element = XVECEXP (op, 0, i);
2741 if (GET_CODE (vector_element) != SET)
2743 if (GET_CODE (SET_DEST (vector_element)) != REG)
2745 if (! register_is_ok_for_epilogue (SET_DEST (vector_element), SImode))
2748 if (REGNO (SET_DEST (vector_element)) == 2)
2751 mask |= 1 << REGNO (SET_DEST (vector_element));
2754 if (! TARGET_DISABLE_CALLT
2755 && (use_callt || stack_bytes == 0 || stack_bytes == 16))
2759 sprintf (buff, "callt ctoff(__callt_return_r2_r%d)", (mask & (1 << 31)) ? 31 : 29);
2764 for (i = 20; i < 32; i++)
2765 if (mask & (1 << i))
2769 sprintf (buff, "callt ctoff(__callt_return_r31c)");
2771 sprintf (buff, "callt ctoff(__callt_return_r%d_r%d%s)",
2772 i, (mask & (1 << 31)) ? 31 : 29, stack_bytes ? "c" : "");
2777 static char regs [100]; /* XXX */
2780 /* Generate the DISPOSE instruction. Note we could just issue the
2781 bit mask as a number as the assembler can cope with this, but for
2782 the sake of our readers we turn it into a textual description. */
2786 for (i = 20; i < 32; i++)
2788 if (mask & (1 << i))
2793 strcat (regs, ", ");
2798 strcat (regs, reg_names[ first ]);
2800 for (i++; i < 32; i++)
2801 if ((mask & (1 << i)) == 0)
2806 strcat (regs, " - ");
2807 strcat (regs, reg_names[ i - 1 ] );
2812 sprintf (buff, "dispose %d {%s}, r31", stack_bytes / 4, regs);
2818 /* Construct a PREPARE instruction that is the equivalent of
2819 the given RTL. We have already verified that this should
2823 construct_prepare_instruction (rtx op)
2825 int count = XVECLEN (op, 0);
2827 unsigned long int mask;
2829 static char buff[ 100 ]; /* XXX */
2834 error ("Bogus PREPEARE construction: %d\n", count);
2838 /* Work out how many bytes to push onto
2839 the stack after storing the registers. */
2840 if (GET_CODE (XVECEXP (op, 0, 0)) != SET)
2842 if (GET_CODE (SET_SRC (XVECEXP (op, 0, 0))) != PLUS)
2844 if (GET_CODE (XEXP (SET_SRC (XVECEXP (op, 0, 0)), 1)) != CONST_INT)
2847 stack_bytes = INTVAL (XEXP (SET_SRC (XVECEXP (op, 0, 0)), 1));
2849 /* Each push will put 4 bytes from the stack. */
2850 stack_bytes += (count - 1) * 4;
2852 /* Make sure that the amount we are popping
2853 will fit into the DISPOSE instruction. */
2854 if (stack_bytes < -128)
2856 error ("Too much stack space to prepare: %d", stack_bytes);
2860 /* Now compute the bit mask of registers to push. */
2862 for (i = 1; i < count; i++)
2864 rtx vector_element = XVECEXP (op, 0, i);
2866 if (GET_CODE (vector_element) != SET)
2868 if (GET_CODE (SET_SRC (vector_element)) != REG)
2870 if (! register_is_ok_for_epilogue (SET_SRC (vector_element), SImode))
2873 if (REGNO (SET_SRC (vector_element)) == 2)
2876 mask |= 1 << REGNO (SET_SRC (vector_element));
2879 if ((! TARGET_DISABLE_CALLT)
2880 && (use_callt || stack_bytes == 0 || stack_bytes == -16))
2884 sprintf (buff, "callt ctoff(__callt_save_r2_r%d)", (mask & (1 << 31)) ? 31 : 29 );
2888 for (i = 20; i < 32; i++)
2889 if (mask & (1 << i))
2893 sprintf (buff, "callt ctoff(__callt_save_r31c)");
2895 sprintf (buff, "callt ctoff(__callt_save_r%d_r%d%s)",
2896 i, (mask & (1 << 31)) ? 31 : 29, stack_bytes ? "c" : "");
2900 static char regs [100]; /* XXX */
2904 /* Generate the PREPARE instruction. Note we could just issue the
2905 bit mask as a number as the assembler can cope with this, but for
2906 the sake of our readers we turn it into a textual description. */
2910 for (i = 20; i < 32; i++)
2912 if (mask & (1 << i))
2917 strcat (regs, ", ");
2922 strcat (regs, reg_names[ first ]);
2924 for (i++; i < 32; i++)
2925 if ((mask & (1 << i)) == 0)
2930 strcat (regs, " - ");
2931 strcat (regs, reg_names[ i - 1 ] );
2936 sprintf (buff, "prepare {%s}, %d", regs, (- stack_bytes) / 4);
2942 /* Return an RTX indicating where the return address to the
2943 calling function can be found. */
2946 v850_return_addr (int count)
2951 return get_hard_reg_initial_val (Pmode, LINK_POINTER_REGNUM);
2955 v850_select_section (tree exp,
2956 int reloc ATTRIBUTE_UNUSED,
2957 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
2959 if (TREE_CODE (exp) == VAR_DECL)
2962 if (!TREE_READONLY (exp)
2963 || TREE_SIDE_EFFECTS (exp)
2964 || !DECL_INITIAL (exp)
2965 || (DECL_INITIAL (exp) != error_mark_node
2966 && !TREE_CONSTANT (DECL_INITIAL (exp))))
2971 switch (v850_get_data_area (exp))
2993 readonly_data_section ();
3000 readonly_data_section ();
3003 /* Worker function for TARGET_RETURN_IN_MEMORY. */
3006 v850_return_in_memory (tree type, tree fntype ATTRIBUTE_UNUSED)
3008 /* Return values > 8 bytes in length in memory. */
3009 return int_size_in_bytes (type) > 8 || TYPE_MODE (type) == BLKmode;
3012 /* Worker function for TARGET_SETUP_INCOMING_VARARGS. */
3015 v850_setup_incoming_varargs (CUMULATIVE_ARGS *ca,
3016 enum machine_mode mode ATTRIBUTE_UNUSED,
3017 tree type ATTRIBUTE_UNUSED,
3018 int *pretend_arg_size ATTRIBUTE_UNUSED,
3019 int second_time ATTRIBUTE_UNUSED)
3021 ca->anonymous_args = (!TARGET_GHS ? 1 : 0);