1 /* Definitions for GCC. Part of the machine description for CRIS.
2 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
3 Contributed by Axis Communications. Written by Hans-Peter Nilsson.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include "coretypes.h"
28 #include "hard-reg-set.h"
30 #include "insn-config.h"
31 #include "conditions.h"
32 #include "insn-attr.h"
44 #include "target-def.h"
47 /* Usable when we have an amount to add or subtract, and want the
48 optimal size of the insn. */
49 #define ADDITIVE_SIZE_MODIFIER(size) \
50 ((size) <= 63 ? "q" : (size) <= 255 ? "u.b" : (size) <= 65535 ? "u.w" : ".d")
52 #define ASSERT_PLT_UNSPEC(x) \
55 if (XEXP (x, 1) != NULL_RTX \
56 || (GET_CODE (XVECEXP (x, 0, 0)) != SYMBOL_REF \
57 && GET_CODE (XVECEXP (x, 0, 0)) != LABEL_REF)) \
61 #define LOSE_AND_RETURN(msgid, x) \
64 cris_operand_lossage (msgid, x); \
68 /* Per-function machine data. */
69 struct machine_function
GTY(())
71 int needs_return_address_on_stack
;
74 /* This little fix suppresses the 'u' or 's' when '%e' in assembly
76 static char cris_output_insn_is_bound
= 0;
78 /* This one suppresses printing out the "rPIC+" in
79 "rPIC+sym:GOTOFF+offset" when doing PIC. For a PLT symbol, it
80 suppresses outputting it as [rPIC+sym:GOTPLT] and outputs similarly
81 just the "sym:GOTOFF" part. */
82 static int cris_pic_sympart_only
= 0;
84 /* Fix for reg_overlap_mentioned_p. */
85 static int cris_reg_overlap_mentioned_p
PARAMS ((rtx
, rtx
));
87 static void cris_print_base
PARAMS ((rtx
, FILE *));
89 static void cris_print_index
PARAMS ((rtx
, FILE *));
91 static struct machine_function
* cris_init_machine_status
PARAMS ((void));
93 static int cris_initial_frame_pointer_offset
PARAMS ((void));
95 static int saved_regs_mentioned
PARAMS ((rtx
));
97 static void cris_target_asm_function_prologue
98 PARAMS ((FILE *, HOST_WIDE_INT
));
100 static void cris_target_asm_function_epilogue
101 PARAMS ((FILE *, HOST_WIDE_INT
));
103 static void cris_encode_section_info
PARAMS ((tree
, int));
104 static void cris_operand_lossage
PARAMS ((const char *, rtx
));
106 static void cris_asm_output_mi_thunk
107 PARAMS ((FILE *, tree
, HOST_WIDE_INT
, HOST_WIDE_INT
, tree
));
109 static bool cris_rtx_costs
PARAMS ((rtx
, int, int, int *));
110 static int cris_address_cost
PARAMS ((rtx
));
112 /* The function cris_target_asm_function_epilogue puts the last insn to
113 output here. It always fits; there won't be a symbol operand. Used in
114 delay_slots_for_epilogue and function_epilogue. */
115 static char save_last
[80];
117 /* This is the argument from the "-max-stack-stackframe=" option. */
118 const char *cris_max_stackframe_str
;
120 /* This is the argument from the "-march=" option. */
121 const char *cris_cpu_str
;
123 /* This is the argument from the "-mtune=" option. */
124 const char *cris_tune_str
;
126 /* This is the argument from the "-melinux-stacksize=" option. */
127 const char *cris_elinux_stacksize_str
;
129 /* This is the parsed result of the "-max-stack-stackframe=" option. If
130 it (still) is zero, then there was no such option given. */
131 int cris_max_stackframe
= 0;
133 /* This is the parsed result of the "-march=" option, if given. */
134 int cris_cpu_version
= CRIS_DEFAULT_CPU_VERSION
;
136 #undef TARGET_ASM_ALIGNED_HI_OP
137 #define TARGET_ASM_ALIGNED_HI_OP "\t.word\t"
138 #undef TARGET_ASM_ALIGNED_SI_OP
139 #define TARGET_ASM_ALIGNED_SI_OP "\t.dword\t"
140 #undef TARGET_ASM_ALIGNED_DI_OP
141 #define TARGET_ASM_ALIGNED_DI_OP "\t.quad\t"
143 /* We need to define these, since the 2byte, 4byte, 8byte op:s are only
144 available in ELF. These "normal" pseudos do not have any alignment
145 constraints or side-effects. */
146 #undef TARGET_ASM_UNALIGNED_HI_OP
147 #define TARGET_ASM_UNALIGNED_HI_OP TARGET_ASM_ALIGNED_HI_OP
149 #undef TARGET_ASM_UNALIGNED_SI_OP
150 #define TARGET_ASM_UNALIGNED_SI_OP TARGET_ASM_ALIGNED_SI_OP
152 #undef TARGET_ASM_UNALIGNED_DI_OP
153 #define TARGET_ASM_UNALIGNED_DI_OP TARGET_ASM_ALIGNED_DI_OP
155 #undef TARGET_ASM_FUNCTION_PROLOGUE
156 #define TARGET_ASM_FUNCTION_PROLOGUE cris_target_asm_function_prologue
158 #undef TARGET_ASM_FUNCTION_EPILOGUE
159 #define TARGET_ASM_FUNCTION_EPILOGUE cris_target_asm_function_epilogue
161 #undef TARGET_ENCODE_SECTION_INFO
162 #define TARGET_ENCODE_SECTION_INFO cris_encode_section_info
164 #undef TARGET_ASM_OUTPUT_MI_THUNK
165 #define TARGET_ASM_OUTPUT_MI_THUNK cris_asm_output_mi_thunk
166 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
167 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK default_can_output_mi_thunk_no_vcall
169 #undef TARGET_RTX_COSTS
170 #define TARGET_RTX_COSTS cris_rtx_costs
171 #undef TARGET_ADDRESS_COST
172 #define TARGET_ADDRESS_COST cris_address_cost
174 struct gcc_target targetm
= TARGET_INITIALIZER
;
176 /* Predicate functions. */
178 /* This checks a part of an address, the one that is not a plain register
179 for an addressing mode using BDAP.
180 Allowed operands is either:
182 b) a CONST operand (but not a symbol when generating PIC)
183 c) a [r] or [r+] in SImode, or sign-extend from HI or QI. */
186 cris_bdap_operand (op
, mode
)
188 enum machine_mode mode
;
190 register enum rtx_code code
= GET_CODE (op
);
192 if (mode
!= SImode
&& (mode
!= VOIDmode
|| GET_MODE (op
) != VOIDmode
))
195 /* Just return whether this is a simple register or constant. */
196 if (register_operand (op
, mode
)
197 || (CONSTANT_P (op
) && !(flag_pic
&& cris_symbol (op
))))
200 /* Is it a [r] or possibly a [r+]? */
203 rtx tem
= XEXP (op
, 0);
206 && (register_operand (tem
, SImode
)
207 || (GET_CODE (tem
) == POST_INC
208 && register_operand (XEXP (tem
, 0), SImode
))))
214 /* Perhaps a sign-extended mem: [r].(b|w) or [r+].(b|w)? */
215 if (code
== SIGN_EXTEND
)
217 rtx tem
= XEXP (op
, 0);
219 if (GET_CODE (tem
) != MEM
)
224 && (register_operand (tem
, SImode
)
225 || (GET_CODE (tem
) == POST_INC
226 && register_operand (XEXP (tem
, 0), SImode
))))
235 /* This is similar to cris_bdap_operand:
236 It checks a part of an address, the one that is not a plain register
237 for an addressing mode using BDAP *or* BIAP.
238 Allowed operands is either:
240 b) a CONST operand (but not a symbol when generating PIC)
241 c) a mult of (1, 2 or 4) and a register
242 d) a [r] or [r+] in SImode, or sign-extend from HI or QI. */
245 cris_bdap_biap_operand (op
, mode
)
247 enum machine_mode mode
;
249 register enum rtx_code code
= GET_CODE (op
);
253 /* Check for bdap operand. */
254 if (cris_bdap_operand (op
, mode
))
257 if (mode
!= SImode
&& (mode
!= VOIDmode
|| GET_MODE (op
) != VOIDmode
))
260 /* Check that we're looking at a BIAP operand. */
264 /* Canonicalize register and multiplicand. */
265 if (GET_CODE (XEXP (op
, 0)) == CONST_INT
)
276 /* Check that the operands are correct after canonicalization. */
277 if (! register_operand (reg
, SImode
) || GET_CODE (val
) != CONST_INT
)
280 /* Check that the multiplicand has a valid value. */
282 && (INTVAL (val
) == 1 || INTVAL (val
) == 2 || INTVAL (val
) == 4)))
288 /* Check if MODE is same as mode for X, and X is PLUS, MINUS, IOR or
292 cris_orthogonal_operator (x
, mode
)
294 enum machine_mode mode
;
296 enum rtx_code code
= GET_CODE (x
);
298 if (mode
== VOIDmode
)
301 return (GET_MODE (x
) == mode
302 && (code
== PLUS
|| code
== MINUS
303 || code
== IOR
|| code
== AND
|| code
== UMIN
));
306 /* Check if MODE is same as mode for X, and X is PLUS, IOR or AND or
310 cris_commutative_orth_op (x
, mode
)
312 enum machine_mode mode
;
314 enum rtx_code code
= GET_CODE (x
);
316 if (mode
== VOIDmode
)
319 return (GET_MODE (x
) == mode
&&
321 || code
== IOR
|| code
== AND
|| code
== UMIN
));
324 /* Check if MODE is same as mode for X, and X is PLUS or MINUS or UMIN. */
327 cris_operand_extend_operator (x
, mode
)
329 enum machine_mode mode
;
331 enum rtx_code code
= GET_CODE (x
);
333 if (mode
== VOIDmode
)
336 return (GET_MODE (x
) == mode
337 && (code
== PLUS
|| code
== MINUS
|| code
== UMIN
));
340 /* Check if MODE is same as mode for X, and X is PLUS or MINUS. */
343 cris_additive_operand_extend_operator (x
, mode
)
345 enum machine_mode mode
;
347 enum rtx_code code
= GET_CODE (x
);
349 if (mode
== VOIDmode
)
352 return (GET_MODE (x
) == mode
353 && (code
== PLUS
|| code
== MINUS
));
356 /* Check to see if MODE is same as mode for X, and X is SIGN_EXTEND or
360 cris_extend_operator (x
, mode
)
362 enum machine_mode mode
;
364 enum rtx_code code
= GET_CODE (x
);
366 if (mode
== VOIDmode
)
370 (GET_MODE (x
) == mode
&& (code
== SIGN_EXTEND
|| code
== ZERO_EXTEND
));
373 /* Check to see if MODE is same as mode for X, and X is PLUS or BOUND. */
376 cris_plus_or_bound_operator (x
, mode
)
378 enum machine_mode mode
;
380 enum rtx_code code
= GET_CODE (x
);
382 if (mode
== VOIDmode
)
386 (GET_MODE (x
) == mode
&& (code
== UMIN
|| code
== PLUS
));
389 /* Since with -fPIC, not all symbols are valid PIC symbols or indeed
390 general_operands, we have to have a predicate that matches it for the
394 cris_general_operand_or_symbol (op
, mode
)
396 enum machine_mode mode
;
398 return general_operand (op
, mode
)
399 || (CONSTANT_P (op
) && cris_symbol (op
));
402 /* Since a PIC symbol without a GOT entry is not a general_operand, we
403 have to have a predicate that matches it. We use this in the expanded
404 "movsi" anonymous pattern for PIC symbols. */
407 cris_general_operand_or_gotless_symbol (op
, mode
)
409 enum machine_mode mode
;
411 return general_operand (op
, mode
)
412 || (CONSTANT_P (op
) && cris_gotless_symbol (op
));
415 /* Since a PLT symbol is not a general_operand, we have to have a
416 predicate that matches it when we need it. We use this in the expanded
417 "call" and "call_value" anonymous patterns. */
420 cris_general_operand_or_plt_symbol (op
, mode
)
422 enum machine_mode mode
;
424 return general_operand (op
, mode
)
425 || (GET_CODE (op
) == CONST
426 && GET_CODE (XEXP (op
, 0)) == UNSPEC
427 && !TARGET_AVOID_GOTPLT
);
430 /* This matches a (MEM (general_operand)) or
431 (MEM (cris_general_operand_or_symbol)). The second one isn't a valid
432 memory_operand, so we need this predicate to recognize call
433 destinations before we change them to a PLT operand (by wrapping in
437 cris_mem_call_operand (op
, mode
)
439 enum machine_mode mode
;
443 if (GET_CODE (op
) != MEM
)
446 if (memory_operand (op
, mode
))
451 return cris_general_operand_or_symbol (xmem
, GET_MODE (op
));
454 /* The CONDITIONAL_REGISTER_USAGE worker. */
457 cris_conditional_register_usage ()
459 /* FIXME: This isn't nice. We should be able to use that register for
460 something else if the PIC table isn't needed. */
462 fixed_regs
[PIC_OFFSET_TABLE_REGNUM
]
463 = call_used_regs
[PIC_OFFSET_TABLE_REGNUM
] = 1;
466 /* Return current_function_uses_pic_offset_table. For use in cris.md,
467 since some generated files do not include function.h. */
470 cris_cfun_uses_pic_table ()
472 return current_function_uses_pic_offset_table
;
475 /* Given an rtx, return the text string corresponding to the CODE of X.
476 Intended for use in the assembly language output section of a
483 cris_output_insn_is_bound
= 0;
484 switch (GET_CODE (x
))
531 /* Used to control the sign/zero-extend character for the 'e' modifier.
533 cris_output_insn_is_bound
= 1;
538 return "Unknown operator";
543 /* Emit an error message when we're in an asm, and a fatal error for
544 "normal" insns. Formatted output isn't easily implemented, since we
545 use output_operand_lossage to output the actual message and handle the
546 categorization of the error. */
549 cris_operand_lossage (msgid
, op
)
554 output_operand_lossage ("%s", msgid
);
557 /* Print an index part of an address to file. */
560 cris_print_index (index
, file
)
564 rtx inner
= XEXP (index
, 0);
566 /* Make the index "additive" unless we'll output a negative number, in
567 which case the sign character is free (as in free beer). */
568 if (GET_CODE (index
) != CONST_INT
|| INTVAL (index
) >= 0)
572 fprintf (file
, "$%s.b", reg_names
[REGNO (index
)]);
573 else if (CONSTANT_P (index
))
574 cris_output_addr_const (file
, index
);
575 else if (GET_CODE (index
) == MULT
)
577 fprintf (file
, "$%s.",
578 reg_names
[REGNO (XEXP (index
, 0))]);
580 putc (INTVAL (XEXP (index
, 1)) == 2 ? 'w' : 'd', file
);
582 else if (GET_CODE (index
) == SIGN_EXTEND
&&
583 GET_CODE (inner
) == MEM
)
585 rtx inner_inner
= XEXP (inner
, 0);
587 if (GET_CODE (inner_inner
) == POST_INC
)
589 fprintf (file
, "[$%s+].",
590 reg_names
[REGNO (XEXP (inner_inner
, 0))]);
591 putc (GET_MODE (inner
) == HImode
? 'w' : 'b', file
);
595 fprintf (file
, "[$%s].", reg_names
[REGNO (inner_inner
)]);
597 putc (GET_MODE (inner
) == HImode
? 'w' : 'b', file
);
600 else if (GET_CODE (index
) == MEM
)
602 if (GET_CODE (inner
) == POST_INC
)
603 fprintf (file
, "[$%s+].d", reg_names
[REGNO (XEXP (inner
, 0))]);
605 fprintf (file
, "[$%s].d", reg_names
[REGNO (inner
)]);
608 cris_operand_lossage ("unexpected index-type in cris_print_index",
612 /* Print a base rtx of an address to file. */
615 cris_print_base (base
, file
)
620 fprintf (file
, "$%s", reg_names
[REGNO (base
)]);
621 else if (GET_CODE (base
) == POST_INC
)
622 fprintf (file
, "$%s+", reg_names
[REGNO (XEXP (base
, 0))]);
624 cris_operand_lossage ("unexpected base-type in cris_print_base",
628 /* Usable as a guard in expressions. */
634 internal_error (arg
);
636 /* We'll never get here; this is just to appease compilers. */
640 /* Textual function prologue. */
643 cris_target_asm_function_prologue (file
, size
)
649 /* Shorten the used name for readability. */
650 int cfoa_size
= current_function_outgoing_args_size
;
651 int last_movem_reg
= -1;
652 int doing_dwarf
= dwarf2out_do_frame ();
654 int faked_args_size
= 0;
655 int cfa_write_offset
= 0;
656 char *cfa_label
= NULL
;
657 int return_address_on_stack
658 = regs_ever_live
[CRIS_SRP_REGNUM
]
659 || cfun
->machine
->needs_return_address_on_stack
!= 0;
661 /* Don't do anything if no prologues or epilogues are wanted. */
662 if (!TARGET_PROLOGUE_EPILOGUE
)
668 /* Align the size to what's best for the CPU model. */
669 if (TARGET_STACK_ALIGN
)
670 size
= TARGET_ALIGN_BY_32
? (size
+ 3) & ~3 : (size
+ 1) & ~1;
672 if (current_function_pretend_args_size
)
674 int pretend
= current_function_pretend_args_size
;
675 for (regno
= CRIS_FIRST_ARG_REG
+ CRIS_MAX_ARGS_IN_REGS
- 1;
677 regno
--, pretend
-= 4)
679 fprintf (file
, "\tpush $%s\n", reg_names
[regno
]);
680 faked_args_size
+= 4;
684 framesize
= faked_args_size
;
688 /* FIXME: Slightly redundant calculation, as we do the same in
689 pieces below. This offset must be the total adjustment of the
690 stack-pointer. We can then def_cfa call at the end of this
691 function with the current implementation of execute_cfa_insn, but
692 that wouldn't really be clean. */
696 + (return_address_on_stack
? 4 : 0)
697 + (frame_pointer_needed
? 4 : 0);
701 if (frame_pointer_needed
)
702 cfa_reg
= FRAME_POINTER_REGNUM
;
705 cfa_reg
= STACK_POINTER_REGNUM
;
706 cfa_offset
+= cris_initial_frame_pointer_offset ();
709 cfa_label
= dwarf2out_cfi_label ();
710 dwarf2out_def_cfa (cfa_label
, cfa_reg
, cfa_offset
);
712 cfa_write_offset
= - faked_args_size
- 4;
715 /* Save SRP if not a leaf function. */
716 if (return_address_on_stack
)
718 fprintf (file
, "\tPush $srp\n");
723 dwarf2out_return_save (cfa_label
, cfa_write_offset
);
724 cfa_write_offset
-= 4;
728 /* Set up frame pointer if needed. */
729 if (frame_pointer_needed
)
731 fprintf (file
, "\tpush $%s\n\tmove.d $sp,$%s\n",
732 reg_names
[FRAME_POINTER_REGNUM
],
733 reg_names
[FRAME_POINTER_REGNUM
]);
738 dwarf2out_reg_save (cfa_label
, FRAME_POINTER_REGNUM
,
740 cfa_write_offset
-= 4;
744 /* Local vars are located above saved regs. */
745 cfa_write_offset
-= size
;
747 /* Get a contiguous sequence of registers, starting with r0, that need
749 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
751 if ((((regs_ever_live
[regno
]
752 && !call_used_regs
[regno
])
753 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
754 && (current_function_uses_pic_offset_table
755 /* It is saved anyway, if there would be a gap. */
757 && regs_ever_live
[regno
+ 1]
758 && !call_used_regs
[regno
+ 1]))))
759 && (regno
!= FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
760 && regno
!= CRIS_SRP_REGNUM
)
761 || (current_function_calls_eh_return
762 && (regno
== EH_RETURN_DATA_REGNO (0)
763 || regno
== EH_RETURN_DATA_REGNO (1)
764 || regno
== EH_RETURN_DATA_REGNO (2)
765 || regno
== EH_RETURN_DATA_REGNO (3))))
767 /* Check if movem may be used for registers so far. */
768 if (regno
== last_movem_reg
+ 1)
769 /* Yes, update next expected register. */
773 /* We cannot use movem for all registers. We have to flush
774 any movem:ed registers we got so far. */
775 if (last_movem_reg
!= -1)
777 /* It is a win to use a side-effect assignment for
778 64 <= size <= 128. But side-effect on movem was
779 not usable for CRIS v0..3. Also only do it if
780 side-effects insns are allowed. */
781 if ((last_movem_reg
+ 1) * 4 + size
>= 64
782 && (last_movem_reg
+ 1) * 4 + size
<= 128
783 && cris_cpu_version
>= CRIS_CPU_SVINTO
784 && TARGET_SIDE_EFFECT_PREFIXES
)
785 fprintf (file
, "\tmovem $%s,[$sp=$sp-%d]\n",
786 reg_names
[last_movem_reg
],
787 (last_movem_reg
+ 1) * 4 + size
);
790 /* Avoid printing multiple subsequent sub:s for sp. */
791 fprintf (file
, "\tsub%s %d,$sp\n",
792 ADDITIVE_SIZE_MODIFIER ((last_movem_reg
+ 1)
794 (last_movem_reg
+ 1) * 4 + size
);
796 fprintf (file
, "\tmovem $%s,[$sp]\n",
797 reg_names
[last_movem_reg
]);
800 framesize
+= (last_movem_reg
+ 1) * 4 + size
;
803 fprintf (file
, "; frame %d, #regs %d, bytes %d args %d\n",
806 (last_movem_reg
+ 1) * 4,
807 current_function_args_size
);
814 /* Local vars on stack, but there are no movem:s.
815 Just allocate space. */
816 fprintf (file
, "\tSub%s %d,$sp\n",
817 ADDITIVE_SIZE_MODIFIER (size
),
823 fprintf (file
, "\tPush $%s\n", reg_names
[regno
]);
829 /* Registers are stored lowest numbered at highest address,
830 which matches the loop order; we just need to update the
832 dwarf2out_reg_save (cfa_label
, regno
, cfa_write_offset
);
833 cfa_write_offset
-= 4;
838 /* Check after, if we can movem all registers. This is the normal
840 if (last_movem_reg
!= -1)
842 /* Side-effect assignment on movem was not supported for CRIS v0..3,
843 and don't do it if we're asked not to.
845 The movem is already accounted for, for unwind. */
847 if ((last_movem_reg
+ 1) * 4 + size
>= 64
848 && (last_movem_reg
+ 1) * 4 + size
<= 128
849 && cris_cpu_version
>= CRIS_CPU_SVINTO
850 && TARGET_SIDE_EFFECT_PREFIXES
)
851 fprintf (file
, "\tmovem $%s,[$sp=$sp-%d]\n",
852 reg_names
[last_movem_reg
],
853 (last_movem_reg
+1) * 4 + size
);
856 /* Avoid printing multiple subsequent sub:s for sp. FIXME:
857 Clean up the conditional expression. */
858 fprintf (file
, "\tsub%s %d,$sp\n",
859 ADDITIVE_SIZE_MODIFIER ((last_movem_reg
+ 1) * 4 + size
),
860 (last_movem_reg
+ 1) * 4 + size
);
861 /* To be compatible with v0..v3 means we do not use an assignment
862 addressing mode with movem. We normally don't need that
863 anyway. It would only be slightly more efficient for 64..128
865 fprintf (file
, "\tmovem $%s,[$sp]\n", reg_names
[last_movem_reg
]);
868 framesize
+= (last_movem_reg
+ 1) * 4 + size
;
871 fprintf (file
, "; frame %d, #regs %d, bytes %d args %d\n",
874 (last_movem_reg
+ 1) * 4,
875 current_function_args_size
);
877 /* We have to put outgoing argument space after regs. */
880 /* This does not need to be accounted for, for unwind. */
882 fprintf (file
, "\tSub%s %d,$sp\n",
883 ADDITIVE_SIZE_MODIFIER (cfoa_size
),
885 framesize
+= cfoa_size
;
888 else if ((size
+ cfoa_size
) > 0)
890 /* This does not need to be accounted for, for unwind. */
892 /* Local vars on stack, and we could not use movem. Add a sub here. */
893 fprintf (file
, "\tSub%s %d,$sp\n",
894 ADDITIVE_SIZE_MODIFIER (size
+ cfoa_size
),
896 framesize
+= size
+ cfoa_size
;
899 /* Set up the PIC register. */
900 if (current_function_uses_pic_offset_table
)
901 fprintf (file
, "\tmove.d $pc,$%s\n\tsub.d .:GOTOFF,$%s\n",
902 reg_names
[PIC_OFFSET_TABLE_REGNUM
],
903 reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
907 "; parm #%d @ %d; frame %d, FP-SP is %d; leaf: %s%s; fp %s, outg: %d arg %d\n",
908 CRIS_MAX_ARGS_IN_REGS
+ 1, FIRST_PARM_OFFSET (0),
910 cris_initial_frame_pointer_offset (),
911 leaf_function_p () ? "yes" : "no",
912 return_address_on_stack
? "no" :"yes",
913 frame_pointer_needed
? "yes" : "no",
914 cfoa_size
, current_function_args_size
);
916 if (cris_max_stackframe
&& framesize
> cris_max_stackframe
)
917 warning ("stackframe too big: %d bytes", framesize
);
920 /* Return nonzero if there are regs mentioned in the insn that are not all
921 in the call_used regs. This is part of the decision whether an insn
922 can be put in the epilogue. */
925 saved_regs_mentioned (x
)
932 /* Mainly stolen from refers_to_regno_p in rtlanal.c. */
940 return !call_used_regs
[i
];
943 /* If this is a SUBREG of a hard reg, we can see exactly which
944 registers are being modified. Otherwise, handle normally. */
945 i
= REGNO (SUBREG_REG (x
));
946 return !call_used_regs
[i
];
952 fmt
= GET_RTX_FORMAT (code
);
953 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
957 if (saved_regs_mentioned (XEXP (x
, i
)))
960 else if (fmt
[i
] == 'E')
963 for (j
= XVECLEN (x
, i
) - 1; j
>=0; j
--)
964 if (saved_regs_mentioned (XEXP (x
, i
)))
972 /* Figure out if the insn may be put in the epilogue. */
975 cris_eligible_for_epilogue_delay (insn
)
978 /* First of all, it must be as slottable as for a delayed branch insn. */
979 if (get_attr_slottable (insn
) != SLOTTABLE_YES
)
982 /* It must not refer to the stack pointer (may be valid for some cases
983 that I can't think of). */
984 if (reg_mentioned_p (stack_pointer_rtx
, PATTERN (insn
)))
987 /* The frame pointer will be restored in the epilogue, before the
988 "ret", so it can't be referred to. */
989 if (frame_pointer_needed
990 && reg_mentioned_p (frame_pointer_rtx
, PATTERN (insn
)))
993 /* All saved regs are restored before the delayed insn.
994 This means that we cannot have any instructions that mention the
995 registers that are restored by the epilogue. */
996 if (saved_regs_mentioned (PATTERN (insn
)))
999 /* It seems to be ok. */
1003 /* Return the number of delay-slots in the epilogue: return 1 if it
1004 contains "ret", else 0. */
1007 cris_delay_slots_for_epilogue ()
1009 /* Check if we use a return insn, which we only do for leaf functions.
1010 Else there is no slot to fill. */
1011 if (regs_ever_live
[CRIS_SRP_REGNUM
]
1012 || cfun
->machine
->needs_return_address_on_stack
!= 0)
1015 /* By calling function_epilogue with the same parameters as from gcc
1016 we can get info about if the epilogue can fill the delay-slot by itself.
1017 If it is filled from the epilogue, then the corresponding string
1019 This depends on that the "size" argument to function_epilogue
1020 always is get_frame_size.
1021 FIXME: Kludgy. At least make it a separate function that is not
1022 misnamed or abuses the stream parameter. */
1023 cris_target_asm_function_epilogue (NULL
, get_frame_size ());
1030 /* Textual function epilogue. When file is NULL, it serves doubly as
1031 a test for whether the epilogue can fill any "ret" delay-slots by
1032 itself by storing the delay insn in save_last. */
1035 cris_target_asm_function_epilogue (file
, size
)
1040 int last_movem_reg
= -1;
1041 rtx insn
= get_last_insn ();
1042 int argspace_offset
= current_function_outgoing_args_size
;
1043 int pretend
= current_function_pretend_args_size
;
1044 int return_address_on_stack
1045 = regs_ever_live
[CRIS_SRP_REGNUM
]
1046 || cfun
->machine
->needs_return_address_on_stack
!= 0;
1050 if (file
&& !TARGET_PROLOGUE_EPILOGUE
)
1053 if (TARGET_PDEBUG
&& file
)
1054 fprintf (file
, ";;\n");
1056 /* Align byte count of stack frame. */
1057 if (TARGET_STACK_ALIGN
)
1058 size
= TARGET_ALIGN_BY_32
? (size
+ 3) & ~3 : (size
+ 1) & ~1;
1060 /* If the last insn was a BARRIER, we don't have to write any code,
1061 then all returns were covered by "return" insns. */
1062 if (GET_CODE (insn
) == NOTE
)
1063 insn
= prev_nonnote_insn (insn
);
1065 && (GET_CODE (insn
) == BARRIER
1066 /* We must make sure that the insn really is a "return" and
1067 not a conditional branch. Try to match the return exactly,
1068 and if it doesn't match, assume it is a conditional branch
1069 (and output an epilogue). */
1070 || (GET_CODE (insn
) == JUMP_INSN
1071 && GET_CODE (PATTERN (insn
)) == RETURN
)))
1073 if (TARGET_PDEBUG
&& file
)
1074 fprintf (file
, ";;;;;\n");
1078 /* Check how many saved regs we can movem. They start at r0 and must
1081 regno
< FIRST_PSEUDO_REGISTER
;
1083 if ((((regs_ever_live
[regno
]
1084 && !call_used_regs
[regno
])
1085 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
1086 && (current_function_uses_pic_offset_table
1087 /* It is saved anyway, if there would be a gap. */
1089 && regs_ever_live
[regno
+ 1]
1090 && !call_used_regs
[regno
+ 1]))))
1091 && (regno
!= FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
1092 && regno
!= CRIS_SRP_REGNUM
)
1093 || (current_function_calls_eh_return
1094 && (regno
== EH_RETURN_DATA_REGNO (0)
1095 || regno
== EH_RETURN_DATA_REGNO (1)
1096 || regno
== EH_RETURN_DATA_REGNO (2)
1097 || regno
== EH_RETURN_DATA_REGNO (3))))
1100 if (regno
== last_movem_reg
+ 1)
1106 for (regno
= FIRST_PSEUDO_REGISTER
- 1;
1107 regno
> last_movem_reg
;
1109 if ((((regs_ever_live
[regno
]
1110 && !call_used_regs
[regno
])
1111 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
1112 && (current_function_uses_pic_offset_table
1113 /* It is saved anyway, if there would be a gap. */
1115 && regs_ever_live
[regno
+ 1]
1116 && !call_used_regs
[regno
+ 1]))))
1117 && (regno
!= FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
1118 && regno
!= CRIS_SRP_REGNUM
)
1119 || (current_function_calls_eh_return
1120 && (regno
== EH_RETURN_DATA_REGNO (0)
1121 || regno
== EH_RETURN_DATA_REGNO (1)
1122 || regno
== EH_RETURN_DATA_REGNO (2)
1123 || regno
== EH_RETURN_DATA_REGNO (3))))
1125 if (argspace_offset
)
1127 /* There is an area for outgoing parameters located before
1128 the saved registers. We have to adjust for that. */
1130 fprintf (file
, "\tAdd%s %d,$sp\n",
1131 ADDITIVE_SIZE_MODIFIER (argspace_offset
),
1134 /* Make sure we only do this once. */
1135 argspace_offset
= 0;
1138 /* Flush previous non-movem:ed registers. */
1139 if (*save_last
&& file
)
1140 fprintf (file
, save_last
);
1141 sprintf (save_last
, "\tPop $%s\n", reg_names
[regno
]);
1144 if (last_movem_reg
!= -1)
1146 if (argspace_offset
)
1148 /* Adjust for the outgoing parameters area, if that's not
1150 if (*save_last
&& file
)
1152 fprintf (file
, save_last
);
1157 fprintf (file
, "\tAdd%s %d,$sp\n",
1158 ADDITIVE_SIZE_MODIFIER (argspace_offset
),
1160 argspace_offset
= 0;
1162 /* Flush previous non-movem:ed registers. */
1163 else if (*save_last
&& file
)
1164 fprintf (file
, save_last
);
1165 sprintf (save_last
, "\tmovem [$sp+],$%s\n", reg_names
[last_movem_reg
]);
1168 /* Restore frame pointer if necessary. */
1169 if (frame_pointer_needed
)
1171 if (*save_last
&& file
)
1172 fprintf (file
, save_last
);
1175 fprintf (file
, "\tmove.d $%s,$sp\n",
1176 reg_names
[FRAME_POINTER_REGNUM
]);
1177 sprintf (save_last
, "\tPop $%s\n",
1178 reg_names
[FRAME_POINTER_REGNUM
]);
1182 /* If there was no frame-pointer to restore sp from, we must
1183 explicitly deallocate local variables. */
1185 /* Handle space for outgoing parameters that hasn't been handled
1187 size
+= argspace_offset
;
1191 if (*save_last
&& file
)
1192 fprintf (file
, save_last
);
1194 sprintf (save_last
, "\tadd%s %d,$sp\n",
1195 ADDITIVE_SIZE_MODIFIER (size
), size
);
1198 /* If the size was not in the range for a "quick", we must flush
1203 fprintf (file
, save_last
);
1208 /* If this function has no pushed register parameters
1209 (stdargs/varargs), and if it is not a leaf function, then we can
1210 just jump-return here. */
1211 if (return_address_on_stack
&& pretend
== 0)
1213 if (*save_last
&& file
)
1214 fprintf (file
, save_last
);
1219 if (current_function_calls_eh_return
)
1221 /* The installed EH-return address is in *this* frame, so we
1222 need to pop it before we return. */
1223 fprintf (file
, "\tpop $srp\n");
1224 fprintf (file
, "\tret\n");
1225 fprintf (file
, "\tadd.d $%s,$sp\n", reg_names
[CRIS_STACKADJ_REG
]);
1228 fprintf (file
, "\tJump [$sp+]\n");
1230 /* Do a sanity check to avoid generating invalid code. */
1231 if (current_function_epilogue_delay_list
)
1232 internal_error ("allocated but unused delay list in epilogue");
1237 /* Rather than add current_function_calls_eh_return conditions
1238 everywhere in the following code (and not be able to test it
1239 thoroughly), assert the assumption that all usage of
1240 __builtin_eh_return are handled above. */
1241 if (current_function_calls_eh_return
)
1242 internal_error ("unexpected function type needing stack adjustment for\
1243 __builtin_eh_return");
1245 /* If we pushed some register parameters, then adjust the stack for
1249 /* Since srp is stored on the way, we need to restore it first. */
1250 if (return_address_on_stack
)
1252 if (*save_last
&& file
)
1253 fprintf (file
, save_last
);
1257 fprintf (file
, "\tpop $srp\n");
1260 if (*save_last
&& file
)
1261 fprintf (file
, save_last
);
1263 sprintf (save_last
, "\tadd%s %d,$sp\n",
1264 ADDITIVE_SIZE_MODIFIER (pretend
), pretend
);
1267 /* Here's where we have a delay-slot we need to fill. */
1268 if (file
&& current_function_epilogue_delay_list
)
1270 /* If gcc has allocated an insn for the epilogue delay slot, but
1271 things were arranged so we now thought we could do it
1272 ourselves, don't forget to flush that insn. */
1274 fprintf (file
, save_last
);
1276 fprintf (file
, "\tRet\n");
1278 /* Output the delay-slot-insn the mandated way. */
1279 final_scan_insn (XEXP (current_function_epilogue_delay_list
, 0),
1284 fprintf (file
, "\tRet\n");
1286 /* If the GCC did not do it, we have to use whatever insn we have,
1289 fprintf (file
, save_last
);
1291 fprintf (file
, "\tnOp\n");
1295 /* The PRINT_OPERAND worker. */
1298 cris_print_operand (file
, x
, code
)
1305 /* Size-strings corresponding to MULT expressions. */
1306 static const char *const mults
[] = { "BAD:0", ".b", ".w", "BAD:3", ".d" };
1308 /* New code entries should just be added to the switch below. If
1309 handling is finished, just return. If handling was just a
1310 modification of the operand, the modified operand should be put in
1311 "operand", and then do a break to let default handling
1312 (zero-modifier) output the operand. */
1317 /* Print the unsigned supplied integer as if it was signed
1318 and < 0, i.e print 255 or 65535 as -1, 254, 65534 as -2, etc. */
1319 if (GET_CODE (x
) != CONST_INT
1320 || ! CONST_OK_FOR_LETTER_P (INTVAL (x
), 'O'))
1321 LOSE_AND_RETURN ("invalid operand for 'b' modifier", x
);
1322 fprintf (file
, "%d", INTVAL (x
)| (INTVAL (x
) <= 255 ? ~255 : ~65535));
1326 /* Print assembler code for operator. */
1327 fprintf (file
, "%s", cris_op_str (operand
));
1331 /* Print the operand without the PIC register. */
1332 if (! flag_pic
|| ! CONSTANT_P (x
) || ! cris_gotless_symbol (x
))
1333 LOSE_AND_RETURN ("invalid operand for 'v' modifier", x
);
1334 cris_pic_sympart_only
++;
1335 cris_output_addr_const (file
, x
);
1336 cris_pic_sympart_only
--;
1340 /* Print the PIC register. Applied to a GOT-less PIC symbol for
1342 if (! flag_pic
|| ! CONSTANT_P (x
) || ! cris_gotless_symbol (x
))
1343 LOSE_AND_RETURN ("invalid operand for 'P' modifier", x
);
1344 fprintf (file
, "$%s", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
1348 /* Adjust a power of two to its log2. */
1349 if (GET_CODE (x
) != CONST_INT
|| exact_log2 (INTVAL (x
)) < 0 )
1350 LOSE_AND_RETURN ("invalid operand for 'p' modifier", x
);
1351 fprintf (file
, "%d", exact_log2 (INTVAL (x
)));
1355 /* For an integer, print 'b' or 'w' if <= 255 or <= 65535
1356 respectively. This modifier also terminates the inhibiting
1357 effects of the 'x' modifier. */
1358 cris_output_insn_is_bound
= 0;
1359 if (GET_MODE (x
) == VOIDmode
&& GET_CODE (x
) == CONST_INT
)
1361 if (INTVAL (x
) >= 0)
1363 if (INTVAL (x
) <= 255)
1365 else if (INTVAL (x
) <= 65535)
1375 /* For a non-integer, print the size of the operand. */
1376 putc ((GET_MODE (x
) == SImode
|| GET_MODE (x
) == SFmode
)
1377 ? 'd' : GET_MODE (x
) == HImode
? 'w'
1378 : GET_MODE (x
) == QImode
? 'b'
1379 /* If none of the above, emit an erroneous size letter. */
1385 /* Const_int: print b for -127 <= x <= 255,
1386 w for -32768 <= x <= 65535, else abort. */
1387 if (GET_CODE (x
) != CONST_INT
1388 || INTVAL (x
) < -32768 || INTVAL (x
) > 65535)
1389 LOSE_AND_RETURN ("invalid operand for 'z' modifier", x
);
1390 putc (INTVAL (x
) >= -128 && INTVAL (x
) <= 255 ? 'b' : 'w', file
);
1394 /* Output a 'nop' if there's nothing for the delay slot.
1395 This method stolen from the sparc files. */
1396 if (dbr_sequence_length () == 0)
1397 fputs ("\n\tnop", file
);
1401 /* Print high (most significant) part of something. */
1402 switch (GET_CODE (operand
))
1405 if (HOST_BITS_PER_WIDE_INT
== 32)
1406 /* Sign-extension from a normal int to a long long. */
1407 fprintf (file
, INTVAL (operand
) < 0 ? "-1" : "0");
1409 fprintf (file
, "0x%x", (unsigned int)(INTVAL (x
) >> 31 >> 1));
1413 /* High part of a long long constant. */
1414 if (GET_MODE (operand
) == VOIDmode
)
1416 fprintf (file
, "0x%x", CONST_DOUBLE_HIGH (x
));
1420 LOSE_AND_RETURN ("invalid operand for 'H' modifier", x
);
1423 /* Print reg + 1. Check that there's not an attempt to print
1424 high-parts of registers like stack-pointer or higher. */
1425 if (REGNO (operand
) > STACK_POINTER_REGNUM
- 2)
1426 LOSE_AND_RETURN ("bad register", operand
);
1427 fprintf (file
, "$%s", reg_names
[REGNO (operand
) + 1]);
1431 /* Adjust memory address to high part. */
1433 rtx adj_mem
= operand
;
1435 = GET_MODE_BITSIZE (GET_MODE (operand
)) / BITS_PER_UNIT
;
1437 /* Adjust so we can use two SImode in DImode.
1438 Calling adj_offsettable_operand will make sure it is an
1439 offsettable address. Don't do this for a postincrement
1440 though; it should remain as it was. */
1441 if (GET_CODE (XEXP (adj_mem
, 0)) != POST_INC
)
1443 = adjust_address (adj_mem
, GET_MODE (adj_mem
), size
/ 2);
1445 output_address (XEXP (adj_mem
, 0));
1450 LOSE_AND_RETURN ("invalid operand for 'H' modifier", x
);
1454 /* Strip the MEM expression. */
1455 operand
= XEXP (operand
, 0);
1459 /* Print 's' if operand is SIGN_EXTEND or 'u' if ZERO_EXTEND unless
1460 cris_output_insn_is_bound is nonzero. */
1461 if (GET_CODE (operand
) != SIGN_EXTEND
1462 && GET_CODE (operand
) != ZERO_EXTEND
1463 && GET_CODE (operand
) != CONST_INT
)
1464 LOSE_AND_RETURN ("invalid operand for 'e' modifier", x
);
1466 if (cris_output_insn_is_bound
)
1468 cris_output_insn_is_bound
= 0;
1472 putc (GET_CODE (operand
) == SIGN_EXTEND
1473 || (GET_CODE (operand
) == CONST_INT
&& INTVAL (operand
) < 0)
1478 /* Print the size letter of the inner element. We can do it by
1479 calling ourselves with the 's' modifier. */
1480 if (GET_CODE (operand
) != SIGN_EXTEND
&& GET_CODE (operand
) != ZERO_EXTEND
)
1481 LOSE_AND_RETURN ("invalid operand for 'm' modifier", x
);
1482 cris_print_operand (file
, XEXP (operand
, 0), 's');
1486 /* Print the least significant part of operand. */
1487 if (GET_CODE (operand
) == CONST_DOUBLE
)
1489 fprintf (file
, "0x%x", CONST_DOUBLE_LOW (x
));
1492 else if (HOST_BITS_PER_WIDE_INT
> 32 && GET_CODE (operand
) == CONST_INT
)
1494 fprintf (file
, "0x%x",
1495 INTVAL (x
) & ((unsigned int) 0x7fffffff * 2 + 1));
1498 /* Otherwise the least significant part equals the normal part,
1499 so handle it normally. */
1503 /* When emitting an add for the high part of a DImode constant, we
1504 want to use addq for 0 and adds.w for -1. */
1505 if (GET_CODE (operand
) != CONST_INT
)
1506 LOSE_AND_RETURN ("invalid operand for 'A' modifier", x
);
1507 fprintf (file
, INTVAL (operand
) < 0 ? "adds.w" : "addq");
1511 /* When emitting an sub for the high part of a DImode constant, we
1512 want to use subq for 0 and subs.w for -1. */
1513 if (GET_CODE (operand
) != CONST_INT
)
1514 LOSE_AND_RETURN ("invalid operand for 'D' modifier", x
);
1515 fprintf (file
, INTVAL (operand
) < 0 ? "subs.w" : "subq");
1519 /* Print the operand as the index-part of an address.
1520 Easiest way out is to use cris_print_index. */
1521 cris_print_index (operand
, file
);
1525 /* Print the size letter for an operand to a MULT, which must be a
1526 const_int with a suitable value. */
1527 if (GET_CODE (operand
) != CONST_INT
|| INTVAL (operand
) > 4)
1528 LOSE_AND_RETURN ("invalid operand for 'T' modifier", x
);
1529 fprintf (file
, "%s", mults
[INTVAL (operand
)]);
1533 /* No code, print as usual. */
1537 LOSE_AND_RETURN ("invalid operand modifier letter", x
);
1540 /* Print an operand as without a modifier letter. */
1541 switch (GET_CODE (operand
))
1544 if (REGNO (operand
) > 15)
1545 internal_error ("internal error: bad register: %d", REGNO (operand
));
1546 fprintf (file
, "$%s", reg_names
[REGNO (operand
)]);
1550 output_address (XEXP (operand
, 0));
1554 if (GET_MODE (operand
) == VOIDmode
)
1555 /* A long long constant. */
1556 output_addr_const (file
, operand
);
1559 /* Only single precision is allowed as plain operands the
1560 moment. FIXME: REAL_VALUE_FROM_CONST_DOUBLE isn't
1565 /* FIXME: Perhaps check overflow of the "single". */
1566 REAL_VALUE_FROM_CONST_DOUBLE (r
, operand
);
1567 REAL_VALUE_TO_TARGET_SINGLE (r
, l
);
1569 fprintf (file
, "0x%lx", l
);
1574 ASSERT_PLT_UNSPEC (operand
);
1578 cris_output_addr_const (file
, operand
);
1584 /* For a (MULT (reg X) const_int) we output "rX.S". */
1585 int i
= GET_CODE (XEXP (operand
, 1)) == CONST_INT
1586 ? INTVAL (XEXP (operand
, 1)) : INTVAL (XEXP (operand
, 0));
1587 rtx reg
= GET_CODE (XEXP (operand
, 1)) == CONST_INT
1588 ? XEXP (operand
, 0) : XEXP (operand
, 1);
1590 if (GET_CODE (reg
) != REG
1591 || (GET_CODE (XEXP (operand
, 0)) != CONST_INT
1592 && GET_CODE (XEXP (operand
, 1)) != CONST_INT
))
1593 LOSE_AND_RETURN ("unexpected multiplicative operand", x
);
1595 cris_print_base (reg
, file
);
1596 fprintf (file
, ".%c",
1597 i
== 0 || (i
== 1 && GET_CODE (operand
) == MULT
) ? 'b'
1599 : (i
== 2 && GET_CODE (operand
) == MULT
) || i
== 1 ? 'w'
1605 /* No need to handle all strange variants, let output_addr_const
1607 if (CONSTANT_P (operand
))
1609 cris_output_addr_const (file
, operand
);
1613 LOSE_AND_RETURN ("unexpected operand", x
);
1617 /* The PRINT_OPERAND_ADDRESS worker. */
1620 cris_print_operand_address (file
, x
)
1624 /* All these were inside MEM:s so output indirection characters. */
1627 if (CONSTANT_ADDRESS_P (x
))
1628 cris_output_addr_const (file
, x
);
1629 else if (BASE_OR_AUTOINCR_P (x
))
1630 cris_print_base (x
, file
);
1631 else if (GET_CODE (x
) == PLUS
)
1639 cris_print_base (x1
, file
);
1640 cris_print_index (x2
, file
);
1642 else if (BASE_P (x2
))
1644 cris_print_base (x2
, file
);
1645 cris_print_index (x1
, file
);
1648 LOSE_AND_RETURN ("unrecognized address", x
);
1650 else if (GET_CODE (x
) == MEM
)
1652 /* A DIP. Output more indirection characters. */
1654 cris_print_base (XEXP (x
, 0), file
);
1658 LOSE_AND_RETURN ("unrecognized address", x
);
1663 /* The RETURN_ADDR_RTX worker.
1664 We mark that the return address is used, either by EH or
1665 __builtin_return_address, for use by the function prologue and
1666 epilogue. FIXME: This isn't optimal; we just use the mark in the
1667 prologue and epilogue to say that the return address is to be stored
1668 in the stack frame. We could return SRP for leaf-functions and use the
1669 initial-value machinery. */
1672 cris_return_addr_rtx (count
, frameaddr
)
1674 rtx frameaddr ATTRIBUTE_UNUSED
;
1676 cfun
->machine
->needs_return_address_on_stack
= 1;
1678 /* The return-address is stored just above the saved frame-pointer (if
1679 present). Apparently we can't eliminate from the frame-pointer in
1680 that direction, so use the incoming args (maybe pretended) pointer. */
1682 ? gen_rtx_MEM (Pmode
, plus_constant (virtual_incoming_args_rtx
, -4))
1686 /* This used to be the INITIAL_FRAME_POINTER_OFFSET worker; now only
1687 handles FP -> SP elimination offset. */
1690 cris_initial_frame_pointer_offset ()
1694 /* Initial offset is 0 if we don't have a frame pointer. */
1697 /* And 4 for each register pushed. */
1698 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1699 if ((((regs_ever_live
[regno
]
1700 && !call_used_regs
[regno
])
1701 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
1702 && (current_function_uses_pic_offset_table
1703 /* It is saved anyway, if there would be a gap. */
1705 && regs_ever_live
[regno
+ 1]
1706 && !call_used_regs
[regno
+ 1]))))
1707 && (regno
!= FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
1708 && regno
!= CRIS_SRP_REGNUM
)
1709 || (current_function_calls_eh_return
1710 && (regno
== EH_RETURN_DATA_REGNO (0)
1711 || regno
== EH_RETURN_DATA_REGNO (1)
1712 || regno
== EH_RETURN_DATA_REGNO (2)
1713 || regno
== EH_RETURN_DATA_REGNO (3))))
1716 /* And then, last, we add the locals allocated. */
1717 offs
+= get_frame_size ();
1719 /* And more; the accumulated args size. */
1720 offs
+= current_function_outgoing_args_size
;
1722 /* Then round it off, in case we use aligned stack. */
1723 if (TARGET_STACK_ALIGN
)
1724 offs
= TARGET_ALIGN_BY_32
? (offs
+ 3) & ~3 : (offs
+ 1) & ~1;
1729 /* The INITIAL_ELIMINATION_OFFSET worker.
1730 Calculate the difference between imaginary registers such as frame
1731 pointer and the stack pointer. Used to eliminate the frame pointer
1732 and imaginary arg pointer. */
1735 cris_initial_elimination_offset (fromreg
, toreg
)
1740 = cris_initial_frame_pointer_offset ();
1742 /* We should be able to use regs_ever_live and related prologue
1743 information here, or alpha should not as well. */
1744 int return_address_on_stack
1745 = regs_ever_live
[CRIS_SRP_REGNUM
]
1746 || cfun
->machine
->needs_return_address_on_stack
!= 0;
1748 /* Here we act as if the frame-pointer is needed. */
1749 int ap_fp_offset
= 4 + (return_address_on_stack
? 4 : 0);
1751 if (fromreg
== ARG_POINTER_REGNUM
1752 && toreg
== FRAME_POINTER_REGNUM
)
1753 return ap_fp_offset
;
1755 /* Between the frame pointer and the stack are only "normal" stack
1756 variables and saved registers. */
1757 if (fromreg
== FRAME_POINTER_REGNUM
1758 && toreg
== STACK_POINTER_REGNUM
)
1759 return fp_sp_offset
;
1761 /* We need to balance out the frame pointer here. */
1762 if (fromreg
== ARG_POINTER_REGNUM
1763 && toreg
== STACK_POINTER_REGNUM
)
1764 return ap_fp_offset
+ fp_sp_offset
- 4;
1769 /* This function looks into the pattern to see how this insn affects
1772 Used when to eliminate test insns before a condition-code user,
1773 such as a "scc" insn or a conditional branch. This includes
1774 checking if the entities that cc was updated by, are changed by the
1777 Currently a jumble of the old peek-inside-the-insn and the newer
1778 check-cc-attribute methods. */
1781 cris_notice_update_cc (exp
, insn
)
1785 /* Check if user specified "-mcc-init" as a bug-workaround. FIXME:
1786 TARGET_CCINIT does not work; we must set CC_REVERSED as below.
1787 Several test-cases will otherwise fail, for example
1788 gcc.c-torture/execute/20000217-1.c -O0 and -O1. */
1795 /* Slowly, we're converting to using attributes to control the setting
1796 of condition-code status. */
1797 switch (get_attr_cc (insn
))
1800 /* Even if it is "none", a setting may clobber a previous
1801 cc-value, so check. */
1802 if (GET_CODE (exp
) == SET
)
1804 if (cc_status
.value1
1805 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1807 cc_status
.value1
= 0;
1809 if (cc_status
.value2
1810 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1812 cc_status
.value2
= 0;
1821 /* Which means, for:
1826 CC is (reg) and (...) - unless (...) is 0, then CC does not change.
1827 CC_NO_OVERFLOW unless (...) is reg or mem.
1836 (set (reg1) (mem (bdap/biap)))
1837 (set (reg2) (bdap/biap))):
1838 CC is (reg1) and (mem (reg2))
1841 (set (mem (bdap/biap)) (reg1)) [or 0]
1842 (set (reg2) (bdap/biap))):
1845 (where reg and mem includes strict_low_parts variants thereof)
1847 For all others, assume CC is clobbered.
1848 Note that we do not have to care about setting CC_NO_OVERFLOW,
1849 since the overflow flag is set to 0 (i.e. right) for
1850 instructions where it does not have any sane sense, but where
1851 other flags have meanings. (This includes shifts; the carry is
1854 Note that there are other parallel constructs we could match,
1855 but we don't do that yet. */
1857 if (GET_CODE (exp
) == SET
)
1859 /* FIXME: Check when this happens. It looks like we should
1860 actually do a CC_STATUS_INIT here to be safe. */
1861 if (SET_DEST (exp
) == pc_rtx
)
1864 /* Record CC0 changes, so we do not have to output multiple
1866 if (SET_DEST (exp
) == cc0_rtx
)
1868 cc_status
.value1
= SET_SRC (exp
);
1869 cc_status
.value2
= 0;
1871 /* Handle flags for the special btstq on one bit. */
1872 if (GET_CODE (SET_SRC (exp
)) == ZERO_EXTRACT
1873 && XEXP (SET_SRC (exp
), 1) == const1_rtx
)
1875 if (GET_CODE (XEXP (SET_SRC (exp
), 0)) == CONST_INT
)
1877 cc_status
.flags
= CC_INVERTED
;
1879 /* A one-bit btstq. */
1880 cc_status
.flags
= CC_Z_IN_NOT_N
;
1883 cc_status
.flags
= 0;
1885 if (GET_CODE (SET_SRC (exp
)) == COMPARE
)
1887 if (!REG_P (XEXP (SET_SRC (exp
), 0))
1888 && XEXP (SET_SRC (exp
), 1) != const0_rtx
)
1889 /* For some reason gcc will not canonicalize compare
1890 operations, reversing the sign by itself if
1891 operands are in wrong order. */
1892 /* (But NOT inverted; eq is still eq.) */
1893 cc_status
.flags
= CC_REVERSED
;
1895 /* This seems to be overlooked by gcc. FIXME: Check again.
1896 FIXME: Is it really safe? */
1898 = gen_rtx_MINUS (GET_MODE (SET_SRC (exp
)),
1899 XEXP (SET_SRC (exp
), 0),
1900 XEXP (SET_SRC (exp
), 1));
1904 else if (REG_P (SET_DEST (exp
))
1905 || (GET_CODE (SET_DEST (exp
)) == STRICT_LOW_PART
1906 && REG_P (XEXP (SET_DEST (exp
), 0))))
1908 /* A register is set; normally CC is set to show that no
1909 test insn is needed. Catch the exceptions. */
1911 /* If not to cc0, then no "set"s in non-natural mode give
1913 if (GET_MODE_SIZE (GET_MODE (SET_DEST (exp
))) > UNITS_PER_WORD
1914 || GET_MODE_CLASS (GET_MODE (SET_DEST (exp
))) == MODE_FLOAT
)
1916 /* ... except add:s and sub:s in DImode. */
1917 if (GET_MODE (SET_DEST (exp
)) == DImode
1918 && (GET_CODE (SET_SRC (exp
)) == PLUS
1919 || GET_CODE (SET_SRC (exp
)) == MINUS
))
1921 cc_status
.flags
= 0;
1922 cc_status
.value1
= SET_DEST (exp
);
1923 cc_status
.value2
= SET_SRC (exp
);
1925 if (cris_reg_overlap_mentioned_p (cc_status
.value1
,
1927 cc_status
.value2
= 0;
1929 /* Add and sub may set V, which gets us
1930 unoptimizable results in "gt" and "le" condition
1932 cc_status
.flags
|= CC_NO_OVERFLOW
;
1937 else if (SET_SRC (exp
) == const0_rtx
)
1939 /* There's no CC0 change when clearing a register or
1940 memory. Just check for overlap. */
1941 if ((cc_status
.value1
1942 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1944 cc_status
.value1
= 0;
1946 if ((cc_status
.value2
1947 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1949 cc_status
.value2
= 0;
1955 cc_status
.flags
= 0;
1956 cc_status
.value1
= SET_DEST (exp
);
1957 cc_status
.value2
= SET_SRC (exp
);
1959 if (cris_reg_overlap_mentioned_p (cc_status
.value1
,
1961 cc_status
.value2
= 0;
1963 /* Some operations may set V, which gets us
1964 unoptimizable results in "gt" and "le" condition
1966 if (GET_CODE (SET_SRC (exp
)) == PLUS
1967 || GET_CODE (SET_SRC (exp
)) == MINUS
1968 || GET_CODE (SET_SRC (exp
)) == NEG
)
1969 cc_status
.flags
|= CC_NO_OVERFLOW
;
1974 else if (GET_CODE (SET_DEST (exp
)) == MEM
1975 || (GET_CODE (SET_DEST (exp
)) == STRICT_LOW_PART
1976 && GET_CODE (XEXP (SET_DEST (exp
), 0)) == MEM
))
1978 /* When SET to MEM, then CC is not changed (except for
1980 if ((cc_status
.value1
1981 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1983 cc_status
.value1
= 0;
1985 if ((cc_status
.value2
1986 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1988 cc_status
.value2
= 0;
1993 else if (GET_CODE (exp
) == PARALLEL
)
1995 if (GET_CODE (XVECEXP (exp
, 0, 0)) == SET
1996 && GET_CODE (XVECEXP (exp
, 0, 1)) == SET
1997 && REG_P (XEXP (XVECEXP (exp
, 0, 1), 0)))
1999 if (REG_P (XEXP (XVECEXP (exp
, 0, 0), 0))
2000 && GET_CODE (XEXP (XVECEXP (exp
, 0, 0), 1)) == MEM
)
2002 /* For "move.S [rx=ry+o],rz", say CC reflects
2003 value1=rz and value2=[rx] */
2004 cc_status
.value1
= XEXP (XVECEXP (exp
, 0, 0), 0);
2006 = gen_rtx_MEM (GET_MODE (XEXP (XVECEXP (exp
, 0, 0), 0)),
2007 XEXP (XVECEXP (exp
, 0, 1), 0));
2008 cc_status
.flags
= 0;
2010 /* Huh? A side-effect cannot change the destination
2012 if (cris_reg_overlap_mentioned_p (cc_status
.value1
,
2014 internal_error ("internal error: sideeffect-insn affecting main effect");
2017 else if ((REG_P (XEXP (XVECEXP (exp
, 0, 0), 1))
2018 || XEXP (XVECEXP (exp
, 0, 0), 1) == const0_rtx
)
2019 && GET_CODE (XEXP (XVECEXP (exp
, 0, 0), 0)) == MEM
)
2021 /* For "move.S rz,[rx=ry+o]" and "clear.S [rx=ry+o]",
2022 say flags are not changed, except for overlap. */
2023 if (cc_status
.value1
2024 && cris_reg_overlap_mentioned_p (XEXP
2028 cc_status
.value1
= 0;
2030 if (cc_status
.value1
2031 && cris_reg_overlap_mentioned_p (XEXP
2035 cc_status
.value1
= 0;
2037 if (cc_status
.value2
2038 && cris_reg_overlap_mentioned_p (XEXP
2042 cc_status
.value2
= 0;
2044 if (cc_status
.value2
2045 && cris_reg_overlap_mentioned_p (XEXP
2049 cc_status
.value2
= 0;
2058 /* Unknown cc_attr value. */
2065 /* Return != 0 if the return sequence for the current function is short,
2066 like "ret" or "jump [sp+]". Prior to reloading, we can't tell how
2067 many registers must be saved, so return 0 then. */
2070 cris_simple_epilogue ()
2073 int reglimit
= STACK_POINTER_REGNUM
;
2076 if (! reload_completed
2077 || frame_pointer_needed
2078 || get_frame_size () != 0
2079 || current_function_pretend_args_size
2080 || current_function_args_size
2081 || current_function_outgoing_args_size
2082 || current_function_calls_eh_return
2084 /* If we're not supposed to emit prologue and epilogue, we must
2085 not emit return-type instructions. */
2086 || !TARGET_PROLOGUE_EPILOGUE
)
2089 /* We allow a "movem [sp+],rN" to sit in front if the "jump [sp+]" or
2090 in the delay-slot of the "ret". */
2091 for (regno
= 0; regno
< reglimit
; regno
++)
2092 if ((regs_ever_live
[regno
] && ! call_used_regs
[regno
])
2093 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
2094 && (current_function_uses_pic_offset_table
2095 /* It is saved anyway, if there would be a gap. */
2097 && regs_ever_live
[regno
+ 1]
2098 && !call_used_regs
[regno
+ 1]))))
2100 if (lastreg
!= regno
- 1)
2108 /* Compute a (partial) cost for rtx X. Return true if the complete
2109 cost has been computed, and false if subexpressions should be
2110 scanned. In either case, *TOTAL contains the cost result. */
2113 cris_rtx_costs (x
, code
, outer_code
, total
)
2115 int code
, outer_code
;
2122 HOST_WIDE_INT val
= INTVAL (x
);
2125 else if (val
< 32 && val
>= -32)
2127 /* Eight or 16 bits are a word and cycle more expensive. */
2128 else if (val
<= 32767 && val
>= -32768)
2130 /* A 32 bit constant (or very seldom, unsigned 16 bits) costs
2131 another word. FIXME: This isn't linear to 16 bits. */
2143 /* For PIC, we need a prefix (if it isn't already there),
2144 and the PIC register. For a global PIC symbol, we also
2145 need a read of the GOT. */
2148 if (cris_got_symbol (x
))
2158 if (x
!= CONST0_RTX (GET_MODE (x
) == VOIDmode
? DImode
: GET_MODE (x
)))
2161 /* Make 0.0 cheap, else test-insns will not be used. */
2166 /* Identify values that are no powers of two. Powers of 2 are
2167 taken care of already and those values should not be changed. */
2168 if (GET_CODE (XEXP (x
, 1)) != CONST_INT
2169 || exact_log2 (INTVAL (XEXP (x
, 1)) < 0))
2171 /* If we have a multiply insn, then the cost is between
2172 1 and 2 "fast" instructions. */
2173 if (TARGET_HAS_MUL_INSNS
)
2175 *total
= COSTS_N_INSNS (1) + COSTS_N_INSNS (1) / 2;
2179 /* Estimate as 4 + 4 * #ofbits. */
2180 *total
= COSTS_N_INSNS (132);
2189 if (GET_CODE (XEXP (x
, 1)) != CONST_INT
2190 || exact_log2 (INTVAL (XEXP (x
, 1)) < 0))
2192 /* Estimate this as 4 + 8 * #of bits. */
2193 *total
= COSTS_N_INSNS (260);
2199 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
2200 /* Two constants may actually happen before optimization. */
2201 && GET_CODE (XEXP (x
, 0)) != CONST_INT
2202 && !CONST_OK_FOR_LETTER_P (INTVAL (XEXP (x
, 1)), 'I'))
2204 *total
= (rtx_cost (XEXP (x
, 0), outer_code
) + 2
2205 + 2 * GET_MODE_NUNITS (GET_MODE (XEXP (x
, 0))));
2210 case ZERO_EXTEND
: case SIGN_EXTEND
:
2211 *total
= rtx_cost (XEXP (x
, 0), outer_code
);
2219 /* The ADDRESS_COST worker. */
2222 cris_address_cost (x
)
2225 /* The metric to use for the cost-macros is unclear.
2226 The metric used here is (the number of cycles needed) / 2,
2227 where we consider equal a cycle for a word of code and a cycle to
2230 /* The cheapest addressing modes get 0, since nothing extra is needed. */
2231 if (BASE_OR_AUTOINCR_P (x
))
2234 /* An indirect mem must be a DIP. This means two bytes extra for code,
2235 and 4 bytes extra for memory read, i.e. (2 + 4) / 2. */
2236 if (GET_CODE (x
) == MEM
)
2239 /* Assume (2 + 4) / 2 for a single constant; a dword, since it needs
2240 an extra DIP prefix and 4 bytes of constant in most cases.
2241 For PIC and a symbol with a GOT entry, we double the cost since we
2242 add a [rPIC+...] offset. A GOT-less symbol uses a BDAP prefix
2243 equivalent to the DIP prefix for non-PIC, hence the same cost. */
2245 return flag_pic
&& cris_got_symbol (x
) ? 2 * (2 + 4) / 2 : (2 + 4) / 2;
2247 /* Handle BIAP and BDAP prefixes. */
2248 if (GET_CODE (x
) == PLUS
)
2250 rtx tem1
= XEXP (x
, 0);
2251 rtx tem2
= XEXP (x
, 1);
2253 /* A BIAP is 2 extra bytes for the prefix insn, nothing more. We
2254 recognize the typical MULT which is always in tem1 because of
2255 insn canonicalization. */
2256 if ((GET_CODE (tem1
) == MULT
&& BIAP_INDEX_P (tem1
))
2260 /* A BDAP (quick) is 2 extra bytes. Any constant operand to the
2261 PLUS is always found in tem2. */
2262 if (GET_CODE (tem2
) == CONST_INT
2263 && INTVAL (tem2
) < 128 && INTVAL (tem2
) >= -128)
2266 /* A BDAP -32768 .. 32767 is like BDAP quick, but with 2 extra
2268 if (GET_CODE (tem2
) == CONST_INT
2269 && CONST_OK_FOR_LETTER_P (INTVAL (tem2
), 'L'))
2272 /* A BDAP with some other constant is 2 bytes extra. */
2273 if (CONSTANT_P (tem2
))
2274 return (2 + 2 + 2) / 2;
2276 /* BDAP with something indirect should have a higher cost than
2277 BIAP with register. FIXME: Should it cost like a MEM or more? */
2278 /* Don't need to check it, it's the only one left.
2279 FIXME: There was a REG test missing, perhaps there are others.
2281 return (2 + 2 + 2) / 2;
2284 /* What else? Return a high cost. It matters only for valid
2285 addressing modes. */
2289 /* Check various objections to the side-effect. Used in the test-part
2290 of an anonymous insn describing an insn with a possible side-effect.
2291 Returns nonzero if the implied side-effect is ok.
2294 ops : An array of rtx:es. lreg, rreg, rval,
2295 The variables multop and other_op are indexes into this,
2296 or -1 if they are not applicable.
2297 lreg : The register that gets assigned in the side-effect.
2298 rreg : One register in the side-effect expression
2299 rval : The other register, or an int.
2300 multop : An integer to multiply rval with.
2301 other_op : One of the entities of the main effect,
2302 whose mode we must consider. */
2305 cris_side_effect_mode_ok (code
, ops
, lreg
, rreg
, rval
, multop
, other_op
)
2308 int lreg
, rreg
, rval
, multop
, other_op
;
2310 /* Find what value to multiply with, for rx =ry + rz * n. */
2311 int mult
= multop
< 0 ? 1 : INTVAL (ops
[multop
]);
2313 rtx reg_rtx
= ops
[rreg
];
2314 rtx val_rtx
= ops
[rval
];
2316 /* The operands may be swapped. Canonicalize them in reg_rtx and
2317 val_rtx, where reg_rtx always is a reg (for this constraint to
2319 if (! BASE_P (reg_rtx
))
2320 reg_rtx
= val_rtx
, val_rtx
= ops
[rreg
];
2322 /* Don't forget to check that reg_rtx really is a reg. If it isn't,
2323 we have no business. */
2324 if (! BASE_P (reg_rtx
))
2327 /* Don't do this when -mno-split. */
2328 if (!TARGET_SIDE_EFFECT_PREFIXES
)
2331 /* The mult expression may be hidden in lreg. FIXME: Add more
2332 commentary about that. */
2333 if (GET_CODE (val_rtx
) == MULT
)
2335 mult
= INTVAL (XEXP (val_rtx
, 1));
2336 val_rtx
= XEXP (val_rtx
, 0);
2340 /* First check the "other operand". */
2343 if (GET_MODE_SIZE (GET_MODE (ops
[other_op
])) > UNITS_PER_WORD
)
2346 /* Check if the lvalue register is the same as the "other
2347 operand". If so, the result is undefined and we shouldn't do
2348 this. FIXME: Check again. */
2349 if ((BASE_P (ops
[lreg
])
2350 && BASE_P (ops
[other_op
])
2351 && REGNO (ops
[lreg
]) == REGNO (ops
[other_op
]))
2352 || rtx_equal_p (ops
[other_op
], ops
[lreg
]))
2356 /* Do not accept frame_pointer_rtx as any operand. */
2357 if (ops
[lreg
] == frame_pointer_rtx
|| ops
[rreg
] == frame_pointer_rtx
2358 || ops
[rval
] == frame_pointer_rtx
2359 || (other_op
>= 0 && ops
[other_op
] == frame_pointer_rtx
))
2363 && ! BASE_P (val_rtx
))
2366 /* Do not allow rx = rx + n if a normal add or sub with same size
2368 if (rtx_equal_p (ops
[lreg
], reg_rtx
)
2369 && GET_CODE (val_rtx
) == CONST_INT
2370 && (INTVAL (val_rtx
) <= 63 && INTVAL (val_rtx
) >= -63))
2373 /* Check allowed cases, like [r(+)?].[bwd] and const.
2374 A symbol is not allowed with PIC. */
2375 if (CONSTANT_P (val_rtx
))
2376 return flag_pic
== 0 || cris_symbol (val_rtx
) == 0;
2378 if (GET_CODE (val_rtx
) == MEM
2379 && BASE_OR_AUTOINCR_P (XEXP (val_rtx
, 0)))
2382 if (GET_CODE (val_rtx
) == SIGN_EXTEND
2383 && GET_CODE (XEXP (val_rtx
, 0)) == MEM
2384 && BASE_OR_AUTOINCR_P (XEXP (XEXP (val_rtx
, 0), 0)))
2387 /* If we got here, it's not a valid addressing mode. */
2390 else if (code
== MULT
2391 || (code
== PLUS
&& BASE_P (val_rtx
)))
2393 /* Do not allow rx = rx + ry.S, since it doesn't give better code. */
2394 if (rtx_equal_p (ops
[lreg
], reg_rtx
)
2395 || (mult
== 1 && rtx_equal_p (ops
[lreg
], val_rtx
)))
2398 /* Do not allow bad multiply-values. */
2399 if (mult
!= 1 && mult
!= 2 && mult
!= 4)
2402 /* Only allow r + ... */
2403 if (! BASE_P (reg_rtx
))
2406 /* If we got here, all seems ok.
2407 (All checks need to be done above). */
2411 /* If we get here, the caller got its initial tests wrong. */
2412 internal_error ("internal error: cris_side_effect_mode_ok with bad operands");
2415 /* The function reg_overlap_mentioned_p in CVS (still as of 2001-05-16)
2416 does not handle the case where the IN operand is strict_low_part; it
2417 does handle it for X. Test-case in Axis-20010516. This function takes
2418 care of that for THIS port. FIXME: strict_low_part is going away
2422 cris_reg_overlap_mentioned_p (x
, in
)
2425 /* The function reg_overlap_mentioned now handles when X is
2426 strict_low_part, but not when IN is a STRICT_LOW_PART. */
2427 if (GET_CODE (in
) == STRICT_LOW_PART
)
2430 return reg_overlap_mentioned_p (x
, in
);
2433 /* The TARGET_ASM_NAMED_SECTION worker.
2434 We just dispatch to the functions for ELF and a.out. */
2437 cris_target_asm_named_section (name
, flags
)
2442 default_no_named_section (name
, flags
);
2444 default_elf_asm_named_section (name
, flags
);
2447 /* The LEGITIMATE_PIC_OPERAND_P worker. */
2450 cris_legitimate_pic_operand (x
)
2453 /* The PIC representation of a symbol with a GOT entry will be (for
2454 example; relocations differ):
2455 sym => [rPIC+sym:GOT]
2456 and for a GOT-less symbol it will be (for example, relocation differ):
2457 sym => rPIC+sym:GOTOFF
2458 so only a symbol with a GOT is by itself a valid operand, and it
2459 can't be a sum of a symbol and an offset. */
2460 return ! cris_symbol (x
) || cris_got_symbol (x
);
2463 /* Return nonzero if there's a SYMBOL_REF or LABEL_REF hiding inside this
2470 switch (GET_CODE (x
))
2477 /* A PLT reference. */
2478 ASSERT_PLT_UNSPEC (x
);
2482 return cris_symbol (XEXP (x
, 0));
2486 return cris_symbol (XEXP (x
, 0)) || cris_symbol (XEXP (x
, 1));
2490 case CONSTANT_P_RTX
:
2494 fatal_insn ("unrecognized supposed constant", x
);
2500 /* Return nonzero if there's a SYMBOL_REF or LABEL_REF hiding inside this
2501 CONSTANT_P, and the symbol does not need a GOT entry. Also set
2502 current_function_uses_pic_offset_table if we're generating PIC and ever
2503 see something that would need one. */
2506 cris_gotless_symbol (x
)
2509 switch (GET_CODE (x
))
2512 ASSERT_PLT_UNSPEC (x
);
2516 if (flag_pic
&& cfun
!= NULL
)
2517 current_function_uses_pic_offset_table
= 1;
2518 return SYMBOL_REF_FLAG (x
);
2521 /* We don't set current_function_uses_pic_offset_table for
2522 LABEL_REF:s in here, since they are almost always originating
2523 from some branch. The only time it does not come from a label is
2524 when GCC does something like __builtin_setjmp. Then we get the
2525 LABEL_REF from the movsi expander, so we mark it there as a
2530 return cris_gotless_symbol (XEXP (x
, 0));
2535 int x0
= cris_gotless_symbol (XEXP (x
, 0)) != 0;
2536 int x1
= cris_gotless_symbol (XEXP (x
, 1)) != 0;
2538 /* One and only one of them must be a local symbol. Neither must
2539 be some other, more general kind of symbol. */
2542 && ! (x0
== 0 && cris_symbol (XEXP (x
, 0)))
2543 && ! (x1
== 0 && cris_symbol (XEXP (x
, 1)));
2548 case CONSTANT_P_RTX
:
2552 fatal_insn ("unrecognized supposed constant", x
);
2558 /* Return nonzero if there's a SYMBOL_REF or LABEL_REF hiding inside this
2559 CONSTANT_P, and the symbol needs a GOT entry. */
2565 switch (GET_CODE (x
))
2568 ASSERT_PLT_UNSPEC (x
);
2572 if (flag_pic
&& cfun
!= NULL
)
2573 current_function_uses_pic_offset_table
= 1;
2574 return ! SYMBOL_REF_FLAG (x
);
2577 return cris_got_symbol (XEXP (x
, 0));
2580 /* A LABEL_REF is never visible as a symbol outside the local
2584 /* Nope, can't access the GOT for "symbol + offset". */
2589 case CONSTANT_P_RTX
:
2593 fatal_insn ("unrecognized supposed constant in cris_global_pic_symbol",
2600 /* The OVERRIDE_OPTIONS worker.
2601 As is the norm, this also parses -mfoo=bar type parameters. */
2604 cris_override_options ()
2606 if (cris_max_stackframe_str
)
2608 cris_max_stackframe
= atoi (cris_max_stackframe_str
);
2610 /* Do some sanity checking. */
2611 if (cris_max_stackframe
< 0 || cris_max_stackframe
> 0x20000000)
2612 internal_error ("-max-stackframe=%d is not usable, not between 0 and %d",
2613 cris_max_stackframe
, 0x20000000);
2616 /* Let "-metrax4" and "-metrax100" change the cpu version. */
2617 if (TARGET_SVINTO
&& cris_cpu_version
< CRIS_CPU_SVINTO
)
2618 cris_cpu_version
= CRIS_CPU_SVINTO
;
2619 else if (TARGET_ETRAX4_ADD
&& cris_cpu_version
< CRIS_CPU_ETRAX4
)
2620 cris_cpu_version
= CRIS_CPU_ETRAX4
;
2622 /* Parse -march=... and its synonym, the deprecated -mcpu=... */
2626 = (*cris_cpu_str
== 'v' ? atoi (cris_cpu_str
+ 1) : -1);
2628 if (strcmp ("etrax4", cris_cpu_str
) == 0)
2629 cris_cpu_version
= 3;
2631 if (strcmp ("svinto", cris_cpu_str
) == 0
2632 || strcmp ("etrax100", cris_cpu_str
) == 0)
2633 cris_cpu_version
= 8;
2635 if (strcmp ("ng", cris_cpu_str
) == 0
2636 || strcmp ("etrax100lx", cris_cpu_str
) == 0)
2637 cris_cpu_version
= 10;
2639 if (cris_cpu_version
< 0 || cris_cpu_version
> 10)
2640 error ("unknown CRIS version specification in -march= or -mcpu= : %s",
2643 /* Set the target flags. */
2644 if (cris_cpu_version
>= CRIS_CPU_ETRAX4
)
2645 target_flags
|= TARGET_MASK_ETRAX4_ADD
;
2647 /* If this is Svinto or higher, align for 32 bit accesses. */
2648 if (cris_cpu_version
>= CRIS_CPU_SVINTO
)
2650 |= (TARGET_MASK_SVINTO
| TARGET_MASK_ALIGN_BY_32
2651 | TARGET_MASK_STACK_ALIGN
| TARGET_MASK_CONST_ALIGN
2652 | TARGET_MASK_DATA_ALIGN
);
2654 /* Note that we do not add new flags when it can be completely
2655 described with a macro that uses -mcpu=X. So
2656 TARGET_HAS_MUL_INSNS is (cris_cpu_version >= CRIS_CPU_NG). */
2662 = (*cris_tune_str
== 'v' ? atoi (cris_tune_str
+ 1) : -1);
2664 if (strcmp ("etrax4", cris_tune_str
) == 0)
2667 if (strcmp ("svinto", cris_tune_str
) == 0
2668 || strcmp ("etrax100", cris_tune_str
) == 0)
2671 if (strcmp ("ng", cris_tune_str
) == 0
2672 || strcmp ("etrax100lx", cris_tune_str
) == 0)
2675 if (cris_tune
< 0 || cris_tune
> 10)
2676 error ("unknown CRIS cpu version specification in -mtune= : %s",
2679 if (cris_tune
>= CRIS_CPU_SVINTO
)
2680 /* We have currently nothing more to tune than alignment for
2683 |= (TARGET_MASK_STACK_ALIGN
| TARGET_MASK_CONST_ALIGN
2684 | TARGET_MASK_DATA_ALIGN
| TARGET_MASK_ALIGN_BY_32
);
2689 /* Use error rather than warning, so invalid use is easily
2690 detectable. Still change to the values we expect, to avoid
2694 error ("-fPIC and -fpic are not supported in this configuration");
2698 /* Turn off function CSE. We need to have the addresses reach the
2699 call expanders to get PLT-marked, as they could otherwise be
2700 compared against zero directly or indirectly. After visiting the
2701 call expanders they will then be cse:ed, as the call expanders
2702 force_reg the addresses, effectively forcing flag_no_function_cse
2704 flag_no_function_cse
= 1;
2707 if ((write_symbols
== DWARF_DEBUG
2708 || write_symbols
== DWARF2_DEBUG
) && ! TARGET_ELF
)
2710 warning ("that particular -g option is invalid with -maout and -melinux");
2711 write_symbols
= DBX_DEBUG
;
2714 /* Set the per-function-data initializer. */
2715 init_machine_status
= cris_init_machine_status
;
2718 /* The TARGET_ASM_OUTPUT_MI_THUNK worker. */
2721 cris_asm_output_mi_thunk (stream
, thunkdecl
, delta
, vcall_offset
, funcdecl
)
2723 tree thunkdecl ATTRIBUTE_UNUSED
;
2724 HOST_WIDE_INT delta
;
2725 HOST_WIDE_INT vcall_offset ATTRIBUTE_UNUSED
;
2730 fprintf (stream
, "\tadd%s ", ADDITIVE_SIZE_MODIFIER (delta
));
2731 fprintf (stream
, HOST_WIDE_INT_PRINT_DEC
, delta
);
2732 fprintf (stream
, ",$%s\n", reg_names
[CRIS_FIRST_ARG_REG
]);
2736 fprintf (stream
, "\tsub%s ", ADDITIVE_SIZE_MODIFIER (-delta
));
2737 fprintf (stream
, HOST_WIDE_INT_PRINT_DEC
, -delta
);
2738 fprintf (stream
, ",$%s\n", reg_names
[CRIS_FIRST_ARG_REG
]);
2743 const char *name
= XSTR (XEXP (DECL_RTL (funcdecl
), 0), 0);
2745 name
= (* targetm
.strip_name_encoding
) (name
);
2746 fprintf (stream
, "add.d ");
2747 assemble_name (stream
, name
);
2748 fprintf (stream
, "%s,$pc\n", CRIS_PLT_PCOFFSET_SUFFIX
);
2752 fprintf (stream
, "jump ");
2753 assemble_name (stream
, XSTR (XEXP (DECL_RTL (funcdecl
), 0), 0));
2754 fprintf (stream
, "\n");
2758 /* The EXPAND_BUILTIN_VA_ARG worker. This is modified from the
2759 "standard" implementation of va_arg: read the value from the current
2760 address and increment by the size of one or two registers. The
2761 important difference for CRIS is that if the type is
2762 pass-by-reference, then perform an indirection. */
2765 cris_expand_builtin_va_arg (valist
, type
)
2771 tree passed_size
= size_zero_node
;
2772 tree type_size
= NULL
;
2773 tree size3
= size_int (3);
2774 tree size4
= size_int (4);
2775 tree size8
= size_int (8);
2781 if (type
== error_mark_node
2782 || (type_size
= TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type
))) == NULL
2783 || TREE_OVERFLOW (type_size
))
2784 /* Presumably an error; the size isn't computable. A message has
2785 supposedly been emitted elsewhere. */
2786 rounded_size
= size_zero_node
;
2789 = fold (build (MULT_EXPR
, sizetype
,
2790 fold (build (TRUNC_DIV_EXPR
, sizetype
,
2791 fold (build (PLUS_EXPR
, sizetype
,
2796 if (!integer_zerop (rounded_size
))
2798 /* Check if the type is passed by value or by reference. Values up
2799 to 8 bytes are passed by-value, padded to register-size (4
2800 bytes). Larger values and varying-size types are passed
2803 = (!really_constant_p (type_size
)
2805 : fold (build (COND_EXPR
, sizetype
,
2806 fold (build (GT_EXPR
, sizetype
,
2813 = (!really_constant_p (type_size
)
2814 ? build1 (INDIRECT_REF
, build_pointer_type (type
), addr_tree
)
2815 : fold (build (COND_EXPR
, TREE_TYPE (addr_tree
),
2816 fold (build (GT_EXPR
, sizetype
,
2819 build1 (INDIRECT_REF
, build_pointer_type (type
),
2824 addr
= expand_expr (addr_tree
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
2825 addr
= copy_to_reg (addr
);
2827 if (!integer_zerop (rounded_size
))
2829 /* Compute new value for AP. */
2830 t
= build (MODIFY_EXPR
, TREE_TYPE (valist
), valist
,
2831 build (PLUS_EXPR
, TREE_TYPE (valist
), valist
,
2833 TREE_SIDE_EFFECTS (t
) = 1;
2834 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2840 /* The INIT_EXPANDERS worker sets the per-function-data initializer and
2844 cris_init_expanders ()
2846 /* Nothing here at the moment. */
2849 /* Zero initialization is OK for all current fields. */
2851 static struct machine_function
*
2852 cris_init_machine_status ()
2854 return ggc_alloc_cleared (sizeof (struct machine_function
));
2857 /* Split a 2 word move (DI or presumably DF) into component parts.
2858 Originally a copy of gen_split_move_double in m32r.c. */
2861 cris_split_movdx (operands
)
2864 enum machine_mode mode
= GET_MODE (operands
[0]);
2865 rtx dest
= operands
[0];
2866 rtx src
= operands
[1];
2869 /* We used to have to handle (SUBREG (MEM)) here, but that should no
2870 longer happen; after reload there are no SUBREGs any more, and we're
2871 only called after reload. */
2872 if (GET_CODE (dest
) == SUBREG
|| GET_CODE (src
) == SUBREG
)
2876 if (GET_CODE (dest
) == REG
)
2878 int dregno
= REGNO (dest
);
2880 /* Reg-to-reg copy. */
2881 if (GET_CODE (src
) == REG
)
2883 int sregno
= REGNO (src
);
2885 int reverse
= (dregno
== sregno
+ 1);
2887 /* We normally copy the low-numbered register first. However, if
2888 the first register operand 0 is the same as the second register of
2889 operand 1, we must copy in the opposite order. */
2890 emit_insn (gen_rtx_SET (VOIDmode
,
2891 operand_subword (dest
, reverse
, TRUE
, mode
),
2892 operand_subword (src
, reverse
, TRUE
, mode
)));
2894 emit_insn (gen_rtx_SET (VOIDmode
,
2895 operand_subword (dest
, !reverse
, TRUE
, mode
),
2896 operand_subword (src
, !reverse
, TRUE
, mode
)));
2898 /* Constant-to-reg copy. */
2899 else if (GET_CODE (src
) == CONST_INT
|| GET_CODE (src
) == CONST_DOUBLE
)
2902 split_double (src
, &words
[0], &words
[1]);
2903 emit_insn (gen_rtx_SET (VOIDmode
,
2904 operand_subword (dest
, 0, TRUE
, mode
),
2907 emit_insn (gen_rtx_SET (VOIDmode
,
2908 operand_subword (dest
, 1, TRUE
, mode
),
2911 /* Mem-to-reg copy. */
2912 else if (GET_CODE (src
) == MEM
)
2914 /* If the high-address word is used in the address, we must load it
2915 last. Otherwise, load it first. */
2916 rtx addr
= XEXP (src
, 0);
2918 = (refers_to_regno_p (dregno
, dregno
+ 1, addr
, NULL
) != 0);
2920 /* The original code imples that we can't do
2921 move.x [rN+],rM move.x [rN],rM+1
2922 when rN is dead, because of REG_NOTES damage. That is
2923 consistent with what I've seen, so don't try it.
2925 We have two different cases here; if the addr is POST_INC,
2926 just pass it through, otherwise add constants. */
2928 if (GET_CODE (addr
) == POST_INC
)
2930 emit_insn (gen_rtx_SET (VOIDmode
,
2931 operand_subword (dest
, 0, TRUE
, mode
),
2932 change_address (src
, SImode
, addr
)));
2933 emit_insn (gen_rtx_SET (VOIDmode
,
2934 operand_subword (dest
, 1, TRUE
, mode
),
2935 change_address (src
, SImode
, addr
)));
2939 /* Make sure we don't get any other addresses with
2940 embedded postincrements. They should be stopped in
2941 GO_IF_LEGITIMATE_ADDRESS, but we're here for your
2943 if (side_effects_p (addr
))
2944 fatal_insn ("unexpected side-effects in address", addr
);
2946 emit_insn (gen_rtx_SET
2948 operand_subword (dest
, reverse
, TRUE
, mode
),
2951 plus_constant (addr
,
2952 reverse
* UNITS_PER_WORD
))));
2953 emit_insn (gen_rtx_SET
2955 operand_subword (dest
, ! reverse
, TRUE
, mode
),
2958 plus_constant (addr
,
2966 /* Reg-to-mem copy or clear mem. */
2967 else if (GET_CODE (dest
) == MEM
2968 && (GET_CODE (src
) == REG
2969 || src
== const0_rtx
2970 || src
== CONST0_RTX (DFmode
)))
2972 rtx addr
= XEXP (dest
, 0);
2974 if (GET_CODE (addr
) == POST_INC
)
2976 emit_insn (gen_rtx_SET (VOIDmode
,
2977 change_address (dest
, SImode
, addr
),
2978 operand_subword (src
, 0, TRUE
, mode
)));
2979 emit_insn (gen_rtx_SET (VOIDmode
,
2980 change_address (dest
, SImode
, addr
),
2981 operand_subword (src
, 1, TRUE
, mode
)));
2985 /* Make sure we don't get any other addresses with embedded
2986 postincrements. They should be stopped in
2987 GO_IF_LEGITIMATE_ADDRESS, but we're here for your safety. */
2988 if (side_effects_p (addr
))
2989 fatal_insn ("unexpected side-effects in address", addr
);
2991 emit_insn (gen_rtx_SET
2993 change_address (dest
, SImode
, addr
),
2994 operand_subword (src
, 0, TRUE
, mode
)));
2996 emit_insn (gen_rtx_SET
2998 change_address (dest
, SImode
,
2999 plus_constant (addr
,
3001 operand_subword (src
, 1, TRUE
, mode
)));
3013 /* This is in essence a copy of output_addr_const altered to output
3014 symbolic operands as PIC.
3016 FIXME: Add hooks similar to ASM_OUTPUT_SYMBOL_REF to get this effect in
3017 the "real" output_addr_const. All we need is one for LABEL_REF (and
3018 one for CODE_LABEL?). */
3021 cris_output_addr_const (file
, x
)
3028 switch (GET_CODE (x
))
3031 ASSERT_PLT_UNSPEC (x
);
3032 x
= XVECEXP (x
, 0, 0);
3039 const char *origstr
= XSTR (x
, 0);
3042 str
= (* targetm
.strip_name_encoding
) (origstr
);
3046 if (cris_pic_sympart_only
)
3048 assemble_name (file
, str
);
3049 fprintf (file
, ":PLTG");
3053 if (TARGET_AVOID_GOTPLT
)
3054 /* We shouldn't get here. */
3057 fprintf (file
, "[$%s+", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
3058 assemble_name (file
, XSTR (x
, 0));
3061 fprintf (file
, ":GOTPLT16]");
3063 fprintf (file
, ":GOTPLT]");
3066 else if (cris_gotless_symbol (x
))
3068 if (! cris_pic_sympart_only
)
3069 fprintf (file
, "$%s+", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
3070 assemble_name (file
, str
);
3071 fprintf (file
, ":GOTOFF");
3073 else if (cris_got_symbol (x
))
3075 if (cris_pic_sympart_only
)
3077 fprintf (file
, "[$%s+", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
3078 assemble_name (file
, XSTR (x
, 0));
3081 fprintf (file
, ":GOT16]");
3083 fprintf (file
, ":GOT]");
3086 LOSE_AND_RETURN ("unexpected PIC symbol", x
);
3089 if (! current_function_uses_pic_offset_table
)
3090 output_operand_lossage ("PIC register isn't set up");
3093 assemble_name (file
, XSTR (x
, 0));
3097 /* If we get one of those here, it should be dressed as PIC. Branch
3098 labels are normally output with the 'l' specifier, which means it
3099 will go directly to output_asm_label and not end up here. */
3100 if (GET_CODE (XEXP (x
, 0)) != CODE_LABEL
3101 && (GET_CODE (XEXP (x
, 0)) != NOTE
3102 || NOTE_LINE_NUMBER (XEXP (x
, 0)) != NOTE_INSN_DELETED_LABEL
))
3103 fatal_insn ("unexpected address expression", x
);
3107 if (cris_gotless_symbol (x
))
3109 if (! cris_pic_sympart_only
)
3110 fprintf (file
, "$%s+", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
3111 cris_output_addr_const (file
, XEXP (x
, 0));
3113 fprintf (file
, ":GOTOFF");
3116 /* Labels are never marked as global symbols. */
3117 fatal_insn ("unexpected PIC symbol", x
);
3120 if (! current_function_uses_pic_offset_table
)
3121 internal_error ("emitting PIC operand, but PIC register isn't set up");
3125 output_addr_const (file
, x
);
3129 if (NOTE_LINE_NUMBER (x
) != NOTE_INSN_DELETED_LABEL
)
3130 fatal_insn ("unexpected NOTE as addr_const:", x
);
3136 output_addr_const (file
, x
);
3140 /* This used to output parentheses around the expression,
3141 but that does not work on the 386 (either ATT or BSD assembler). */
3142 cris_output_addr_const (file
, XEXP (x
, 0));
3146 /* Some assemblers need integer constants to appear last (eg masm). */
3147 if (GET_CODE (XEXP (x
, 0)) == CONST_INT
)
3149 cris_output_addr_const (file
, XEXP (x
, 1));
3150 if (INTVAL (XEXP (x
, 0)) >= 0)
3151 fprintf (file
, "+");
3152 output_addr_const (file
, XEXP (x
, 0));
3156 cris_output_addr_const (file
, XEXP (x
, 0));
3157 if (GET_CODE (XEXP (x
, 1)) != CONST_INT
3158 || INTVAL (XEXP (x
, 1)) >= 0)
3159 fprintf (file
, "+");
3160 cris_output_addr_const (file
, XEXP (x
, 1));
3165 /* Avoid outputting things like x-x or x+5-x,
3166 since some assemblers can't handle that. */
3167 x
= simplify_subtraction (x
);
3168 if (GET_CODE (x
) != MINUS
)
3171 cris_output_addr_const (file
, XEXP (x
, 0));
3172 fprintf (file
, "-");
3173 if ((GET_CODE (XEXP (x
, 1)) == CONST_INT
3174 && INTVAL (XEXP (x
, 1)) < 0)
3175 || GET_CODE (XEXP (x
, 1)) != CONST_INT
)
3177 fprintf (file
, "%s", targetm
.asm_out
.open_paren
);
3178 cris_output_addr_const (file
, XEXP (x
, 1));
3179 fprintf (file
, "%s", targetm
.asm_out
.close_paren
);
3182 output_addr_const (file
, XEXP (x
, 1));
3186 LOSE_AND_RETURN ("unexpected address expression", x
);
3190 /* Code-in whether we can get away without a GOT entry (needed for
3191 externally visible objects but not for functions) into
3192 SYMBOL_REF_FLAG and add the PLT suffix for global functions. */
3195 cris_encode_section_info (exp
, first
)
3197 int first ATTRIBUTE_UNUSED
;
3201 rtx rtl
= DECL_P (exp
) ? DECL_RTL (exp
) : TREE_CST_RTL (exp
);
3203 if (GET_CODE (rtl
) == MEM
&& GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
)
3204 SYMBOL_REF_FLAG (XEXP (rtl
, 0)) = (*targetm
.binds_local_p
) (exp
);
3209 /* Various small functions to replace macros. Only called from a
3210 debugger. They might collide with gcc functions or system functions,
3211 so only emit them when '#if 1' above. */
3213 enum rtx_code Get_code
PARAMS ((rtx
));
3219 return GET_CODE (x
);
3222 const char *Get_mode
PARAMS ((rtx
));
3228 return GET_MODE_NAME (GET_MODE (x
));
3231 rtx Xexp
PARAMS ((rtx
, int));
3241 rtx Xvecexp
PARAMS ((rtx
, int, int));
3248 return XVECEXP (x
, n
, m
);
3251 int Get_rtx_len
PARAMS ((rtx
));
3257 return GET_RTX_LENGTH (GET_CODE (x
));
3260 /* Use upper-case to distinguish from local variables that are sometimes
3261 called next_insn and prev_insn. */
3263 rtx Next_insn
PARAMS ((rtx
));
3269 return NEXT_INSN (insn
);
3272 rtx Prev_insn
PARAMS ((rtx
));
3278 return PREV_INSN (insn
);
3282 #include "gt-cris.h"
3286 * eval: (c-set-style "gnu")
3287 * indent-tabs-mode: t