1 /* Definitions for GCC. Part of the machine description for CRIS.
2 Copyright (C) 1998, 1999, 2000, 2001, 2002 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. */
26 #include "hard-reg-set.h"
28 #include "insn-config.h"
29 #include "conditions.h"
30 #include "insn-attr.h"
42 #include "target-def.h"
44 /* Usable when we have an amount to add or subtract, and want the
45 optimal size of the insn. */
46 #define ADDITIVE_SIZE_MODIFIER(size) \
47 ((size) <= 63 ? "q" : (size) <= 255 ? "u.b" : (size) <= 65535 ? "u.w" : ".d")
49 #define ASSERT_PLT_UNSPEC(x) \
52 if (XEXP (x, 1) != NULL_RTX \
53 || (GET_CODE (XVECEXP (x, 0, 0)) != SYMBOL_REF \
54 && GET_CODE (XVECEXP (x, 0, 0)) != LABEL_REF)) \
58 #define LOSE_AND_RETURN(msgid, x) \
61 cris_operand_lossage (msgid, x); \
65 /* Per-function machine data. */
66 struct machine_function
GTY(())
68 int needs_return_address_on_stack
;
71 /* This little fix suppresses the 'u' or 's' when '%e' in assembly
73 static char cris_output_insn_is_bound
= 0;
75 /* This one suppresses printing out the "rPIC+" in
76 "rPIC+sym:GOTOFF+offset" when doing PIC. For a PLT symbol, it
77 suppresses outputting it as [rPIC+sym:GOTPLT] and outputs similarly
78 just the "sym:GOTOFF" part. */
79 static int cris_pic_sympart_only
= 0;
81 /* Fix for reg_overlap_mentioned_p. */
82 static int cris_reg_overlap_mentioned_p
PARAMS ((rtx
, rtx
));
84 static void cris_print_base
PARAMS ((rtx
, FILE *));
86 static void cris_print_index
PARAMS ((rtx
, FILE *));
88 static struct machine_function
* cris_init_machine_status
PARAMS ((void));
90 static int cris_initial_frame_pointer_offset
PARAMS ((void));
92 static int saved_regs_mentioned
PARAMS ((rtx
));
94 static void cris_target_asm_function_prologue
95 PARAMS ((FILE *, HOST_WIDE_INT
));
97 static void cris_target_asm_function_epilogue
98 PARAMS ((FILE *, HOST_WIDE_INT
));
100 static void cris_encode_section_info
PARAMS ((tree
, int));
101 static void cris_operand_lossage
PARAMS ((const char *, rtx
));
103 /* The function cris_target_asm_function_epilogue puts the last insn to
104 output here. It always fits; there won't be a symbol operand. Used in
105 delay_slots_for_epilogue and function_epilogue. */
106 static char save_last
[80];
108 /* This is the argument from the "-max-stack-stackframe=" option. */
109 const char *cris_max_stackframe_str
;
111 /* This is the argument from the "-march=" option. */
112 const char *cris_cpu_str
;
114 /* This is the argument from the "-mtune=" option. */
115 const char *cris_tune_str
;
117 /* This is the argument from the "-melinux-stacksize=" option. */
118 const char *cris_elinux_stacksize_str
;
120 /* This is the parsed result of the "-max-stack-stackframe=" option. If
121 it (still) is zero, then there was no such option given. */
122 int cris_max_stackframe
= 0;
124 /* This is the parsed result of the "-march=" option, if given. */
125 int cris_cpu_version
= CRIS_DEFAULT_CPU_VERSION
;
127 #undef TARGET_ASM_ALIGNED_HI_OP
128 #define TARGET_ASM_ALIGNED_HI_OP "\t.word\t"
129 #undef TARGET_ASM_ALIGNED_SI_OP
130 #define TARGET_ASM_ALIGNED_SI_OP "\t.dword\t"
131 #undef TARGET_ASM_ALIGNED_DI_OP
132 #define TARGET_ASM_ALIGNED_DI_OP "\t.quad\t"
134 /* We need to define these, since the 2byte, 4byte, 8byte op:s are only
135 available in ELF. These "normal" pseudos do not have any alignment
136 constraints or side-effects. */
137 #undef TARGET_ASM_UNALIGNED_HI_OP
138 #define TARGET_ASM_UNALIGNED_HI_OP TARGET_ASM_ALIGNED_HI_OP
140 #undef TARGET_ASM_UNALIGNED_SI_OP
141 #define TARGET_ASM_UNALIGNED_SI_OP TARGET_ASM_ALIGNED_SI_OP
143 #undef TARGET_ASM_UNALIGNED_DI_OP
144 #define TARGET_ASM_UNALIGNED_DI_OP TARGET_ASM_ALIGNED_DI_OP
146 #undef TARGET_ASM_FUNCTION_PROLOGUE
147 #define TARGET_ASM_FUNCTION_PROLOGUE cris_target_asm_function_prologue
149 #undef TARGET_ASM_FUNCTION_EPILOGUE
150 #define TARGET_ASM_FUNCTION_EPILOGUE cris_target_asm_function_epilogue
152 #undef TARGET_ENCODE_SECTION_INFO
153 #define TARGET_ENCODE_SECTION_INFO cris_encode_section_info
155 struct gcc_target targetm
= TARGET_INITIALIZER
;
157 /* Predicate functions. */
159 /* This checks a part of an address, the one that is not a plain register
160 for an addressing mode using BDAP.
161 Allowed operands is either:
163 b) a CONST operand (but not a symbol when generating PIC)
164 c) a [r] or [r+] in SImode, or sign-extend from HI or QI. */
167 cris_bdap_operand (op
, mode
)
169 enum machine_mode mode
;
171 register enum rtx_code code
= GET_CODE (op
);
173 if (mode
!= SImode
&& (mode
!= VOIDmode
|| GET_MODE (op
) != VOIDmode
))
176 /* Just return whether this is a simple register or constant. */
177 if (register_operand (op
, mode
)
178 || (CONSTANT_P (op
) && !(flag_pic
&& cris_symbol (op
))))
181 /* Is it a [r] or possibly a [r+]? */
184 rtx tem
= XEXP (op
, 0);
187 && (register_operand (tem
, SImode
)
188 || (GET_CODE (tem
) == POST_INC
189 && register_operand (XEXP (tem
, 0), SImode
))))
195 /* Perhaps a sign-extended mem: [r].(b|w) or [r+].(b|w)? */
196 if (code
== SIGN_EXTEND
)
198 rtx tem
= XEXP (op
, 0);
200 if (GET_CODE (tem
) != MEM
)
205 && (register_operand (tem
, SImode
)
206 || (GET_CODE (tem
) == POST_INC
207 && register_operand (XEXP (tem
, 0), SImode
))))
216 /* This is similar to cris_bdap_operand:
217 It checks a part of an address, the one that is not a plain register
218 for an addressing mode using BDAP *or* BIAP.
219 Allowed operands is either:
221 b) a CONST operand (but not a symbol when generating PIC)
222 c) a mult of (1, 2 or 4) and a register
223 d) a [r] or [r+] in SImode, or sign-extend from HI or QI. */
226 cris_bdap_biap_operand (op
, mode
)
228 enum machine_mode mode
;
230 register enum rtx_code code
= GET_CODE (op
);
234 /* Check for bdap operand. */
235 if (cris_bdap_operand (op
, mode
))
238 if (mode
!= SImode
&& (mode
!= VOIDmode
|| GET_MODE (op
) != VOIDmode
))
241 /* Check that we're looking at a BIAP operand. */
245 /* Canonicalize register and multiplicand. */
246 if (GET_CODE (XEXP (op
, 0)) == CONST_INT
)
257 /* Check that the operands are correct after canonicalization. */
258 if (! register_operand (reg
, SImode
) || GET_CODE (val
) != CONST_INT
)
261 /* Check that the multiplicand has a valid value. */
263 && (INTVAL (val
) == 1 || INTVAL (val
) == 2 || INTVAL (val
) == 4)))
269 /* Check if MODE is same as mode for X, and X is PLUS, MINUS, IOR or
273 cris_orthogonal_operator (x
, mode
)
275 enum machine_mode mode
;
277 enum rtx_code code
= GET_CODE (x
);
279 if (mode
== VOIDmode
)
282 return (GET_MODE (x
) == mode
283 && (code
== PLUS
|| code
== MINUS
284 || code
== IOR
|| code
== AND
|| code
== UMIN
));
287 /* Check if MODE is same as mode for X, and X is PLUS, IOR or AND or
291 cris_commutative_orth_op (x
, mode
)
293 enum machine_mode mode
;
295 enum rtx_code code
= GET_CODE (x
);
297 if (mode
== VOIDmode
)
300 return (GET_MODE (x
) == mode
&&
302 || code
== IOR
|| code
== AND
|| code
== UMIN
));
305 /* Check if MODE is same as mode for X, and X is PLUS or MINUS or UMIN. */
308 cris_operand_extend_operator (x
, mode
)
310 enum machine_mode mode
;
312 enum rtx_code code
= GET_CODE (x
);
314 if (mode
== VOIDmode
)
317 return (GET_MODE (x
) == mode
318 && (code
== PLUS
|| code
== MINUS
|| code
== UMIN
));
321 /* Check to see if MODE is same as mode for X, and X is SIGN_EXTEND or
325 cris_extend_operator (x
, mode
)
327 enum machine_mode mode
;
329 enum rtx_code code
= GET_CODE (x
);
331 if (mode
== VOIDmode
)
335 (GET_MODE (x
) == mode
&& (code
== SIGN_EXTEND
|| code
== ZERO_EXTEND
));
338 /* Check to see if MODE is same as mode for X, and X is PLUS or BOUND. */
341 cris_plus_or_bound_operator (x
, mode
)
343 enum machine_mode mode
;
345 enum rtx_code code
= GET_CODE (x
);
347 if (mode
== VOIDmode
)
351 (GET_MODE (x
) == mode
&& (code
== UMIN
|| code
== PLUS
));
354 /* Since with -fPIC, not all symbols are valid PIC symbols or indeed
355 general_operands, we have to have a predicate that matches it for the
359 cris_general_operand_or_symbol (op
, mode
)
361 enum machine_mode mode
;
363 return general_operand (op
, mode
)
364 || (CONSTANT_P (op
) && cris_symbol (op
));
367 /* Since a PIC symbol without a GOT entry is not a general_operand, we
368 have to have a predicate that matches it. We use this in the expanded
369 "movsi" anonymous pattern for PIC symbols. */
372 cris_general_operand_or_gotless_symbol (op
, mode
)
374 enum machine_mode mode
;
376 return general_operand (op
, mode
)
377 || (CONSTANT_P (op
) && cris_gotless_symbol (op
));
380 /* Since a PLT symbol is not a general_operand, we have to have a
381 predicate that matches it when we need it. We use this in the expanded
382 "call" and "call_value" anonymous patterns. */
385 cris_general_operand_or_plt_symbol (op
, mode
)
387 enum machine_mode mode
;
389 return general_operand (op
, mode
)
390 || (GET_CODE (op
) == CONST
391 && GET_CODE (XEXP (op
, 0)) == UNSPEC
392 && !TARGET_AVOID_GOTPLT
);
395 /* This matches a (MEM (general_operand)) or
396 (MEM (cris_general_operand_or_symbol)). The second one isn't a valid
397 memory_operand, so we need this predicate to recognize call
398 destinations before we change them to a PLT operand (by wrapping in
402 cris_mem_call_operand (op
, mode
)
404 enum machine_mode mode
;
408 if (GET_CODE (op
) != MEM
)
411 if (memory_operand (op
, mode
))
416 return cris_general_operand_or_symbol (xmem
, GET_MODE (op
));
419 /* The CONDITIONAL_REGISTER_USAGE worker. */
422 cris_conditional_register_usage ()
424 /* FIXME: This isn't nice. We should be able to use that register for
425 something else if the PIC table isn't needed. */
427 fixed_regs
[PIC_OFFSET_TABLE_REGNUM
]
428 = call_used_regs
[PIC_OFFSET_TABLE_REGNUM
] = 1;
431 /* Return current_function_uses_pic_offset_table. For use in cris.md,
432 since some generated files do not include function.h. */
435 cris_cfun_uses_pic_table ()
437 return current_function_uses_pic_offset_table
;
440 /* Given an rtx, return the text string corresponding to the CODE of X.
441 Intended for use in the assembly language output section of a
448 cris_output_insn_is_bound
= 0;
449 switch (GET_CODE (x
))
496 /* Used to control the sign/zero-extend character for the 'e' modifier.
498 cris_output_insn_is_bound
= 1;
503 return "Unknown operator";
508 /* Emit an error message when we're in an asm, and a fatal error for
509 "normal" insns. Formatted output isn't easily implemented, since we
510 use output_operand_lossage to output the actual message and handle the
511 categorization of the error. */
514 cris_operand_lossage (msgid
, op
)
519 output_operand_lossage ("%s", msgid
);
522 /* Print an index part of an address to file. */
525 cris_print_index (index
, file
)
529 rtx inner
= XEXP (index
, 0);
531 /* Make the index "additive" unless we'll output a negative number, in
532 which case the sign character is free (as in free beer). */
533 if (GET_CODE (index
) != CONST_INT
|| INTVAL (index
) >= 0)
537 fprintf (file
, "$%s.b", reg_names
[REGNO (index
)]);
538 else if (CONSTANT_P (index
))
539 cris_output_addr_const (file
, index
);
540 else if (GET_CODE (index
) == MULT
)
542 fprintf (file
, "$%s.",
543 reg_names
[REGNO (XEXP (index
, 0))]);
545 putc (INTVAL (XEXP (index
, 1)) == 2 ? 'w' : 'd', file
);
547 else if (GET_CODE (index
) == SIGN_EXTEND
&&
548 GET_CODE (inner
) == MEM
)
550 rtx inner_inner
= XEXP (inner
, 0);
552 if (GET_CODE (inner_inner
) == POST_INC
)
554 fprintf (file
, "[$%s+].",
555 reg_names
[REGNO (XEXP (inner_inner
, 0))]);
556 putc (GET_MODE (inner
) == HImode
? 'w' : 'b', file
);
560 fprintf (file
, "[$%s].", reg_names
[REGNO (inner_inner
)]);
562 putc (GET_MODE (inner
) == HImode
? 'w' : 'b', file
);
565 else if (GET_CODE (index
) == MEM
)
567 if (GET_CODE (inner
) == POST_INC
)
568 fprintf (file
, "[$%s+].d", reg_names
[REGNO (XEXP (inner
, 0))]);
570 fprintf (file
, "[$%s].d", reg_names
[REGNO (inner
)]);
573 cris_operand_lossage ("unexpected index-type in cris_print_index",
577 /* Print a base rtx of an address to file. */
580 cris_print_base (base
, file
)
585 fprintf (file
, "$%s", reg_names
[REGNO (base
)]);
586 else if (GET_CODE (base
) == POST_INC
)
587 fprintf (file
, "$%s+", reg_names
[REGNO (XEXP (base
, 0))]);
589 cris_operand_lossage ("unexpected base-type in cris_print_base",
593 /* Usable as a guard in expressions. */
599 internal_error (arg
);
601 /* We'll never get here; this is just to appease compilers. */
605 /* Textual function prologue. */
608 cris_target_asm_function_prologue (file
, size
)
614 /* Shorten the used name for readability. */
615 int cfoa_size
= current_function_outgoing_args_size
;
616 int last_movem_reg
= -1;
617 int doing_dwarf
= dwarf2out_do_frame ();
619 int faked_args_size
= 0;
620 int cfa_write_offset
= 0;
621 char *cfa_label
= NULL
;
622 int return_address_on_stack
623 = regs_ever_live
[CRIS_SRP_REGNUM
]
624 || cfun
->machine
->needs_return_address_on_stack
!= 0;
626 /* Don't do anything if no prologues or epilogues are wanted. */
627 if (!TARGET_PROLOGUE_EPILOGUE
)
633 /* Align the size to what's best for the CPU model. */
634 if (TARGET_STACK_ALIGN
)
635 size
= TARGET_ALIGN_BY_32
? (size
+ 3) & ~3 : (size
+ 1) & ~1;
637 if (current_function_pretend_args_size
)
639 int pretend
= current_function_pretend_args_size
;
640 for (regno
= CRIS_FIRST_ARG_REG
+ CRIS_MAX_ARGS_IN_REGS
- 1;
642 regno
--, pretend
-= 4)
644 fprintf (file
, "\tpush $%s\n", reg_names
[regno
]);
645 faked_args_size
+= 4;
649 framesize
= faked_args_size
;
653 /* FIXME: Slightly redundant calculation, as we do the same in
654 pieces below. This offset must be the total adjustment of the
655 stack-pointer. We can then def_cfa call at the end of this
656 function with the current implementation of execute_cfa_insn, but
657 that wouldn't really be clean. */
661 + (return_address_on_stack
? 4 : 0)
662 + (frame_pointer_needed
? 4 : 0);
666 if (frame_pointer_needed
)
667 cfa_reg
= FRAME_POINTER_REGNUM
;
670 cfa_reg
= STACK_POINTER_REGNUM
;
671 cfa_offset
+= cris_initial_frame_pointer_offset ();
674 cfa_label
= dwarf2out_cfi_label ();
675 dwarf2out_def_cfa (cfa_label
, cfa_reg
, cfa_offset
);
677 cfa_write_offset
= - faked_args_size
- 4;
680 /* Save SRP if not a leaf function. */
681 if (return_address_on_stack
)
683 fprintf (file
, "\tPush $srp\n");
688 dwarf2out_return_save (cfa_label
, cfa_write_offset
);
689 cfa_write_offset
-= 4;
693 /* Set up frame pointer if needed. */
694 if (frame_pointer_needed
)
696 fprintf (file
, "\tpush $%s\n\tmove.d $sp,$%s\n",
697 reg_names
[FRAME_POINTER_REGNUM
],
698 reg_names
[FRAME_POINTER_REGNUM
]);
703 dwarf2out_reg_save (cfa_label
, FRAME_POINTER_REGNUM
,
705 cfa_write_offset
-= 4;
709 /* Local vars are located above saved regs. */
710 cfa_write_offset
-= size
;
712 /* Get a contiguous sequence of registers, starting with r0, that need
714 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
716 if ((((regs_ever_live
[regno
]
717 && !call_used_regs
[regno
])
718 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
719 && (current_function_uses_pic_offset_table
720 /* It is saved anyway, if there would be a gap. */
722 && regs_ever_live
[regno
+ 1]
723 && !call_used_regs
[regno
+ 1]))))
724 && (regno
!= FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
725 && regno
!= CRIS_SRP_REGNUM
)
726 || (current_function_calls_eh_return
727 && (regno
== EH_RETURN_DATA_REGNO (0)
728 || regno
== EH_RETURN_DATA_REGNO (1)
729 || regno
== EH_RETURN_DATA_REGNO (2)
730 || regno
== EH_RETURN_DATA_REGNO (3))))
732 /* Check if movem may be used for registers so far. */
733 if (regno
== last_movem_reg
+ 1)
734 /* Yes, update next expected register. */
738 /* We cannot use movem for all registers. We have to flush
739 any movem:ed registers we got so far. */
740 if (last_movem_reg
!= -1)
742 /* It is a win to use a side-effect assignment for
743 64 <= size <= 128. But side-effect on movem was
744 not usable for CRIS v0..3. Also only do it if
745 side-effects insns are allowed. */
746 if ((last_movem_reg
+ 1) * 4 + size
>= 64
747 && (last_movem_reg
+ 1) * 4 + size
<= 128
748 && cris_cpu_version
>= CRIS_CPU_SVINTO
749 && TARGET_SIDE_EFFECT_PREFIXES
)
750 fprintf (file
, "\tmovem $%s,[$sp=$sp-%d]\n",
751 reg_names
[last_movem_reg
],
752 (last_movem_reg
+ 1) * 4 + size
);
755 /* Avoid printing multiple subsequent sub:s for sp. */
756 fprintf (file
, "\tsub%s %d,$sp\n",
757 ADDITIVE_SIZE_MODIFIER ((last_movem_reg
+ 1)
759 (last_movem_reg
+ 1) * 4 + size
);
761 fprintf (file
, "\tmovem $%s,[$sp]\n",
762 reg_names
[last_movem_reg
]);
765 framesize
+= (last_movem_reg
+ 1) * 4 + size
;
768 fprintf (file
, "; frame %d, #regs %d, bytes %d args %d\n",
771 (last_movem_reg
+ 1) * 4,
772 current_function_args_size
);
779 /* Local vars on stack, but there are no movem:s.
780 Just allocate space. */
781 fprintf (file
, "\tSub%s %d,$sp\n",
782 ADDITIVE_SIZE_MODIFIER (size
),
788 fprintf (file
, "\tPush $%s\n", reg_names
[regno
]);
794 /* Registers are stored lowest numbered at highest address,
795 which matches the loop order; we just need to update the
797 dwarf2out_reg_save (cfa_label
, regno
, cfa_write_offset
);
798 cfa_write_offset
-= 4;
803 /* Check after, if we can movem all registers. This is the normal
805 if (last_movem_reg
!= -1)
807 /* Side-effect assignment on movem was not supported for CRIS v0..3,
808 and don't do it if we're asked not to.
810 The movem is already accounted for, for unwind. */
812 if ((last_movem_reg
+ 1) * 4 + size
>= 64
813 && (last_movem_reg
+ 1) * 4 + size
<= 128
814 && cris_cpu_version
>= CRIS_CPU_SVINTO
815 && TARGET_SIDE_EFFECT_PREFIXES
)
816 fprintf (file
, "\tmovem $%s,[$sp=$sp-%d]\n",
817 reg_names
[last_movem_reg
],
818 (last_movem_reg
+1) * 4 + size
);
821 /* Avoid printing multiple subsequent sub:s for sp. FIXME:
822 Clean up the conditional expression. */
823 fprintf (file
, "\tsub%s %d,$sp\n",
824 ADDITIVE_SIZE_MODIFIER ((last_movem_reg
+ 1) * 4 + size
),
825 (last_movem_reg
+ 1) * 4 + size
);
826 /* To be compatible with v0..v3 means we do not use an assignment
827 addressing mode with movem. We normally don't need that
828 anyway. It would only be slightly more efficient for 64..128
830 fprintf (file
, "\tmovem $%s,[$sp]\n", reg_names
[last_movem_reg
]);
833 framesize
+= (last_movem_reg
+ 1) * 4 + size
;
836 fprintf (file
, "; frame %d, #regs %d, bytes %d args %d\n",
839 (last_movem_reg
+ 1) * 4,
840 current_function_args_size
);
842 /* We have to put outgoing argument space after regs. */
845 /* This does not need to be accounted for, for unwind. */
847 fprintf (file
, "\tSub%s %d,$sp\n",
848 ADDITIVE_SIZE_MODIFIER (cfoa_size
),
850 framesize
+= cfoa_size
;
853 else if ((size
+ cfoa_size
) > 0)
855 /* This does not need to be accounted for, for unwind. */
857 /* Local vars on stack, and we could not use movem. Add a sub here. */
858 fprintf (file
, "\tSub%s %d,$sp\n",
859 ADDITIVE_SIZE_MODIFIER (size
+ cfoa_size
),
861 framesize
+= size
+ cfoa_size
;
864 /* Set up the PIC register. */
865 if (current_function_uses_pic_offset_table
)
866 asm_fprintf (file
, "\tmove.d $pc,$%s\n\tsub.d .:GOTOFF,$%s\n",
867 reg_names
[PIC_OFFSET_TABLE_REGNUM
],
868 reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
872 "; parm #%d @ %d; frame %d, FP-SP is %d; leaf: %s%s; fp %s, outg: %d arg %d\n",
873 CRIS_MAX_ARGS_IN_REGS
+ 1, FIRST_PARM_OFFSET (0),
875 cris_initial_frame_pointer_offset (),
876 leaf_function_p () ? "yes" : "no",
877 return_address_on_stack
? "no" :"yes",
878 frame_pointer_needed
? "yes" : "no",
879 cfoa_size
, current_function_args_size
);
881 if (cris_max_stackframe
&& framesize
> cris_max_stackframe
)
882 warning ("stackframe too big: %d bytes", framesize
);
885 /* Return nonzero if there are regs mentioned in the insn that are not all
886 in the call_used regs. This is part of the decision whether an insn
887 can be put in the epilogue. */
890 saved_regs_mentioned (x
)
897 /* Mainly stolen from refers_to_regno_p in rtlanal.c. */
905 return !call_used_regs
[i
];
908 /* If this is a SUBREG of a hard reg, we can see exactly which
909 registers are being modified. Otherwise, handle normally. */
910 i
= REGNO (SUBREG_REG (x
));
911 return !call_used_regs
[i
];
917 fmt
= GET_RTX_FORMAT (code
);
918 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
922 if (saved_regs_mentioned (XEXP (x
, i
)))
925 else if (fmt
[i
] == 'E')
928 for (j
= XVECLEN (x
, i
) - 1; j
>=0; j
--)
929 if (saved_regs_mentioned (XEXP (x
, i
)))
937 /* Figure out if the insn may be put in the epilogue. */
940 cris_eligible_for_epilogue_delay (insn
)
943 /* First of all, it must be as slottable as for a delayed branch insn. */
944 if (get_attr_slottable (insn
) != SLOTTABLE_YES
)
947 /* It must not refer to the stack pointer (may be valid for some cases
948 that I can't think of). */
949 if (reg_mentioned_p (stack_pointer_rtx
, PATTERN (insn
)))
952 /* The frame pointer will be restored in the epilogue, before the
953 "ret", so it can't be referred to. */
954 if (frame_pointer_needed
955 && reg_mentioned_p (frame_pointer_rtx
, PATTERN (insn
)))
958 /* All saved regs are restored before the delayed insn.
959 This means that we cannot have any instructions that mention the
960 registers that are restored by the epilogue. */
961 if (saved_regs_mentioned (PATTERN (insn
)))
964 /* It seems to be ok. */
968 /* Return the number of delay-slots in the epilogue: return 1 if it
969 contains "ret", else 0. */
972 cris_delay_slots_for_epilogue ()
974 /* Check if we use a return insn, which we only do for leaf functions.
975 Else there is no slot to fill. */
976 if (regs_ever_live
[CRIS_SRP_REGNUM
]
977 || cfun
->machine
->needs_return_address_on_stack
!= 0)
980 /* By calling function_epilogue with the same parameters as from gcc
981 we can get info about if the epilogue can fill the delay-slot by itself.
982 If it is filled from the epilogue, then the corresponding string
984 This depends on that the "size" argument to function_epilogue
985 always is get_frame_size.
986 FIXME: Kludgy. At least make it a separate function that is not
987 misnamed or abuses the stream parameter. */
988 cris_target_asm_function_epilogue (NULL
, get_frame_size ());
995 /* Textual function epilogue. When file is NULL, it serves doubly as
996 a test for whether the epilogue can fill any "ret" delay-slots by
997 itself by storing the delay insn in save_last. */
1000 cris_target_asm_function_epilogue (file
, size
)
1005 int last_movem_reg
= -1;
1006 rtx insn
= get_last_insn ();
1007 int argspace_offset
= current_function_outgoing_args_size
;
1008 int pretend
= current_function_pretend_args_size
;
1009 int return_address_on_stack
1010 = regs_ever_live
[CRIS_SRP_REGNUM
]
1011 || cfun
->machine
->needs_return_address_on_stack
!= 0;
1015 if (file
&& !TARGET_PROLOGUE_EPILOGUE
)
1018 if (TARGET_PDEBUG
&& file
)
1019 fprintf (file
, ";;\n");
1021 /* Align byte count of stack frame. */
1022 if (TARGET_STACK_ALIGN
)
1023 size
= TARGET_ALIGN_BY_32
? (size
+ 3) & ~3 : (size
+ 1) & ~1;
1025 /* If the last insn was a BARRIER, we don't have to write any code,
1026 then all returns were covered by "return" insns. */
1027 if (GET_CODE (insn
) == NOTE
)
1028 insn
= prev_nonnote_insn (insn
);
1030 && (GET_CODE (insn
) == BARRIER
1031 /* We must make sure that the insn really is a "return" and
1032 not a conditional branch. Try to match the return exactly,
1033 and if it doesn't match, assume it is a conditional branch
1034 (and output an epilogue). */
1035 || (GET_CODE (insn
) == JUMP_INSN
1036 && GET_CODE (PATTERN (insn
)) == RETURN
)))
1038 if (TARGET_PDEBUG
&& file
)
1039 fprintf (file
, ";;;;;\n");
1043 /* Check how many saved regs we can movem. They start at r0 and must
1046 regno
< FIRST_PSEUDO_REGISTER
;
1048 if ((((regs_ever_live
[regno
]
1049 && !call_used_regs
[regno
])
1050 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
1051 && (current_function_uses_pic_offset_table
1052 /* It is saved anyway, if there would be a gap. */
1054 && regs_ever_live
[regno
+ 1]
1055 && !call_used_regs
[regno
+ 1]))))
1056 && (regno
!= FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
1057 && regno
!= CRIS_SRP_REGNUM
)
1058 || (current_function_calls_eh_return
1059 && (regno
== EH_RETURN_DATA_REGNO (0)
1060 || regno
== EH_RETURN_DATA_REGNO (1)
1061 || regno
== EH_RETURN_DATA_REGNO (2)
1062 || regno
== EH_RETURN_DATA_REGNO (3))))
1065 if (regno
== last_movem_reg
+ 1)
1071 for (regno
= FIRST_PSEUDO_REGISTER
- 1;
1072 regno
> last_movem_reg
;
1074 if ((((regs_ever_live
[regno
]
1075 && !call_used_regs
[regno
])
1076 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
1077 && (current_function_uses_pic_offset_table
1078 /* It is saved anyway, if there would be a gap. */
1080 && regs_ever_live
[regno
+ 1]
1081 && !call_used_regs
[regno
+ 1]))))
1082 && (regno
!= FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
1083 && regno
!= CRIS_SRP_REGNUM
)
1084 || (current_function_calls_eh_return
1085 && (regno
== EH_RETURN_DATA_REGNO (0)
1086 || regno
== EH_RETURN_DATA_REGNO (1)
1087 || regno
== EH_RETURN_DATA_REGNO (2)
1088 || regno
== EH_RETURN_DATA_REGNO (3))))
1090 if (argspace_offset
)
1092 /* There is an area for outgoing parameters located before
1093 the saved registers. We have to adjust for that. */
1095 fprintf (file
, "\tAdd%s %d,$sp\n",
1096 ADDITIVE_SIZE_MODIFIER (argspace_offset
),
1099 /* Make sure we only do this once. */
1100 argspace_offset
= 0;
1103 /* Flush previous non-movem:ed registers. */
1104 if (*save_last
&& file
)
1105 fprintf (file
, save_last
);
1106 sprintf (save_last
, "\tPop $%s\n", reg_names
[regno
]);
1109 if (last_movem_reg
!= -1)
1111 if (argspace_offset
)
1113 /* Adjust for the outgoing parameters area, if that's not
1115 if (*save_last
&& file
)
1117 fprintf (file
, save_last
);
1122 fprintf (file
, "\tAdd%s %d,$sp\n",
1123 ADDITIVE_SIZE_MODIFIER (argspace_offset
),
1125 argspace_offset
= 0;
1127 /* Flush previous non-movem:ed registers. */
1128 else if (*save_last
&& file
)
1129 fprintf (file
, save_last
);
1130 sprintf (save_last
, "\tmovem [$sp+],$%s\n", reg_names
[last_movem_reg
]);
1133 /* Restore frame pointer if necessary. */
1134 if (frame_pointer_needed
)
1136 if (*save_last
&& file
)
1137 fprintf (file
, save_last
);
1140 fprintf (file
, "\tmove.d $%s,$sp\n",
1141 reg_names
[FRAME_POINTER_REGNUM
]);
1142 sprintf (save_last
, "\tPop $%s\n",
1143 reg_names
[FRAME_POINTER_REGNUM
]);
1147 /* If there was no frame-pointer to restore sp from, we must
1148 explicitly deallocate local variables. */
1150 /* Handle space for outgoing parameters that hasn't been handled
1152 size
+= argspace_offset
;
1156 if (*save_last
&& file
)
1157 fprintf (file
, save_last
);
1159 sprintf (save_last
, "\tadd%s %d,$sp\n",
1160 ADDITIVE_SIZE_MODIFIER (size
), size
);
1163 /* If the size was not in the range for a "quick", we must flush
1168 fprintf (file
, save_last
);
1173 /* If this function has no pushed register parameters
1174 (stdargs/varargs), and if it is not a leaf function, then we can
1175 just jump-return here. */
1176 if (return_address_on_stack
&& pretend
== 0)
1178 if (*save_last
&& file
)
1179 fprintf (file
, save_last
);
1184 if (current_function_calls_eh_return
)
1186 /* The installed EH-return address is in *this* frame, so we
1187 need to pop it before we return. */
1188 fprintf (file
, "\tpop $srp\n");
1189 fprintf (file
, "\tret\n");
1190 fprintf (file
, "\tadd.d $%s,$sp\n", reg_names
[CRIS_STACKADJ_REG
]);
1193 fprintf (file
, "\tJump [$sp+]\n");
1195 /* Do a sanity check to avoid generating invalid code. */
1196 if (current_function_epilogue_delay_list
)
1197 internal_error ("allocated but unused delay list in epilogue");
1202 /* Rather than add current_function_calls_eh_return conditions
1203 everywhere in the following code (and not be able to test it
1204 thoroughly), assert the assumption that all usage of
1205 __builtin_eh_return are handled above. */
1206 if (current_function_calls_eh_return
)
1207 internal_error ("unexpected function type needing stack adjustment for\
1208 __builtin_eh_return");
1210 /* If we pushed some register parameters, then adjust the stack for
1214 /* Since srp is stored on the way, we need to restore it first. */
1215 if (return_address_on_stack
)
1217 if (*save_last
&& file
)
1218 fprintf (file
, save_last
);
1222 fprintf (file
, "\tpop $srp\n");
1225 if (*save_last
&& file
)
1226 fprintf (file
, save_last
);
1228 sprintf (save_last
, "\tadd%s %d,$sp\n",
1229 ADDITIVE_SIZE_MODIFIER (pretend
), pretend
);
1232 /* Here's where we have a delay-slot we need to fill. */
1233 if (file
&& current_function_epilogue_delay_list
)
1235 /* If gcc has allocated an insn for the epilogue delay slot, but
1236 things were arranged so we now thought we could do it
1237 ourselves, don't forget to flush that insn. */
1239 fprintf (file
, save_last
);
1241 fprintf (file
, "\tRet\n");
1243 /* Output the delay-slot-insn the mandated way. */
1244 final_scan_insn (XEXP (current_function_epilogue_delay_list
, 0),
1249 fprintf (file
, "\tRet\n");
1251 /* If the GCC did not do it, we have to use whatever insn we have,
1254 fprintf (file
, save_last
);
1256 fprintf (file
, "\tnOp\n");
1260 /* The PRINT_OPERAND worker. */
1263 cris_print_operand (file
, x
, code
)
1270 /* Size-strings corresponding to MULT expressions. */
1271 static const char *const mults
[] = { "BAD:0", ".b", ".w", "BAD:3", ".d" };
1273 /* New code entries should just be added to the switch below. If
1274 handling is finished, just return. If handling was just a
1275 modification of the operand, the modified operand should be put in
1276 "operand", and then do a break to let default handling
1277 (zero-modifier) output the operand. */
1282 /* Print the unsigned supplied integer as if it was signed
1283 and < 0, i.e print 255 or 65535 as -1, 254, 65534 as -2, etc. */
1284 if (GET_CODE (x
) != CONST_INT
1285 || ! CONST_OK_FOR_LETTER_P (INTVAL (x
), 'O'))
1286 LOSE_AND_RETURN ("invalid operand for 'b' modifier", x
);
1287 fprintf (file
, "%d", INTVAL (x
)| (INTVAL (x
) <= 255 ? ~255 : ~65535));
1291 /* Print assembler code for operator. */
1292 fprintf (file
, "%s", cris_op_str (operand
));
1296 /* Print the operand without the PIC register. */
1297 if (! flag_pic
|| ! CONSTANT_P (x
) || ! cris_gotless_symbol (x
))
1298 LOSE_AND_RETURN ("invalid operand for 'v' modifier", x
);
1299 cris_pic_sympart_only
++;
1300 cris_output_addr_const (file
, x
);
1301 cris_pic_sympart_only
--;
1305 /* Print the PIC register. Applied to a GOT-less PIC symbol for
1307 if (! flag_pic
|| ! CONSTANT_P (x
) || ! cris_gotless_symbol (x
))
1308 LOSE_AND_RETURN ("invalid operand for 'P' modifier", x
);
1309 fprintf (file
, "$%s", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
1313 /* Adjust a power of two to its log2. */
1314 if (GET_CODE (x
) != CONST_INT
|| exact_log2 (INTVAL (x
)) < 0 )
1315 LOSE_AND_RETURN ("invalid operand for 'p' modifier", x
);
1316 fprintf (file
, "%d", exact_log2 (INTVAL (x
)));
1320 /* For an integer, print 'b' or 'w' if <= 255 or <= 65535
1321 respectively. This modifier also terminates the inhibiting
1322 effects of the 'x' modifier. */
1323 cris_output_insn_is_bound
= 0;
1324 if (GET_MODE (x
) == VOIDmode
&& GET_CODE (x
) == CONST_INT
)
1326 if (INTVAL (x
) >= 0)
1328 if (INTVAL (x
) <= 255)
1330 else if (INTVAL (x
) <= 65535)
1340 /* For a non-integer, print the size of the operand. */
1341 putc ((GET_MODE (x
) == SImode
|| GET_MODE (x
) == SFmode
)
1342 ? 'd' : GET_MODE (x
) == HImode
? 'w'
1343 : GET_MODE (x
) == QImode
? 'b'
1344 /* If none of the above, emit an erroneous size letter. */
1350 /* Const_int: print b for -127 <= x <= 255,
1351 w for -32768 <= x <= 65535, else abort. */
1352 if (GET_CODE (x
) != CONST_INT
1353 || INTVAL (x
) < -32768 || INTVAL (x
) > 65535)
1354 LOSE_AND_RETURN ("invalid operand for 'z' modifier", x
);
1355 putc (INTVAL (x
) >= -128 && INTVAL (x
) <= 255 ? 'b' : 'w', file
);
1359 /* Output a 'nop' if there's nothing for the delay slot.
1360 This method stolen from the sparc files. */
1361 if (dbr_sequence_length () == 0)
1362 fputs ("\n\tnop", file
);
1366 /* Print high (most significant) part of something. */
1367 switch (GET_CODE (operand
))
1370 if (HOST_BITS_PER_WIDE_INT
== 32)
1371 /* Sign-extension from a normal int to a long long. */
1372 fprintf (file
, INTVAL (operand
) < 0 ? "-1" : "0");
1374 fprintf (file
, "0x%x", (unsigned int)(INTVAL (x
) >> 31 >> 1));
1378 /* High part of a long long constant. */
1379 if (GET_MODE (operand
) == VOIDmode
)
1381 fprintf (file
, "0x%x", CONST_DOUBLE_HIGH (x
));
1385 LOSE_AND_RETURN ("invalid operand for 'H' modifier", x
);
1388 /* Print reg + 1. Check that there's not an attempt to print
1389 high-parts of registers like stack-pointer or higher. */
1390 if (REGNO (operand
) > STACK_POINTER_REGNUM
- 2)
1391 LOSE_AND_RETURN ("bad register", operand
);
1392 fprintf (file
, "$%s", reg_names
[REGNO (operand
) + 1]);
1396 /* Adjust memory address to high part. */
1398 rtx adj_mem
= operand
;
1400 = GET_MODE_BITSIZE (GET_MODE (operand
)) / BITS_PER_UNIT
;
1402 /* Adjust so we can use two SImode in DImode.
1403 Calling adj_offsettable_operand will make sure it is an
1404 offsettable address. Don't do this for a postincrement
1405 though; it should remain as it was. */
1406 if (GET_CODE (XEXP (adj_mem
, 0)) != POST_INC
)
1408 = adjust_address (adj_mem
, GET_MODE (adj_mem
), size
/ 2);
1410 output_address (XEXP (adj_mem
, 0));
1415 LOSE_AND_RETURN ("invalid operand for 'H' modifier", x
);
1419 /* Strip the MEM expression. */
1420 operand
= XEXP (operand
, 0);
1424 /* Print 's' if operand is SIGN_EXTEND or 'u' if ZERO_EXTEND unless
1425 cris_output_insn_is_bound is nonzero. */
1426 if (GET_CODE (operand
) != SIGN_EXTEND
1427 && GET_CODE (operand
) != ZERO_EXTEND
1428 && GET_CODE (operand
) != CONST_INT
)
1429 LOSE_AND_RETURN ("invalid operand for 'e' modifier", x
);
1431 if (cris_output_insn_is_bound
)
1433 cris_output_insn_is_bound
= 0;
1437 putc (GET_CODE (operand
) == SIGN_EXTEND
1438 || (GET_CODE (operand
) == CONST_INT
&& INTVAL (operand
) < 0)
1443 /* Print the size letter of the inner element. We can do it by
1444 calling ourselves with the 's' modifier. */
1445 if (GET_CODE (operand
) != SIGN_EXTEND
&& GET_CODE (operand
) != ZERO_EXTEND
)
1446 LOSE_AND_RETURN ("invalid operand for 'm' modifier", x
);
1447 cris_print_operand (file
, XEXP (operand
, 0), 's');
1451 /* Print the least significant part of operand. */
1452 if (GET_CODE (operand
) == CONST_DOUBLE
)
1454 fprintf (file
, "0x%x", CONST_DOUBLE_LOW (x
));
1457 else if (HOST_BITS_PER_WIDE_INT
> 32 && GET_CODE (operand
) == CONST_INT
)
1459 fprintf (file
, "0x%x",
1460 INTVAL (x
) & ((unsigned int) 0x7fffffff * 2 + 1));
1463 /* Otherwise the least significant part equals the normal part,
1464 so handle it normally. */
1468 /* When emitting an add for the high part of a DImode constant, we
1469 want to use addq for 0 and adds.w for -1. */
1470 if (GET_CODE (operand
) != CONST_INT
)
1471 LOSE_AND_RETURN ("invalid operand for 'A' modifier", x
);
1472 fprintf (file
, INTVAL (operand
) < 0 ? "adds.w" : "addq");
1476 /* When emitting an sub for the high part of a DImode constant, we
1477 want to use subq for 0 and subs.w for -1. */
1478 if (GET_CODE (operand
) != CONST_INT
)
1479 LOSE_AND_RETURN ("invalid operand for 'D' modifier", x
);
1480 fprintf (file
, INTVAL (operand
) < 0 ? "subs.w" : "subq");
1484 /* Print the operand as the index-part of an address.
1485 Easiest way out is to use cris_print_index. */
1486 cris_print_index (operand
, file
);
1490 /* Print the size letter for an operand to a MULT, which must be a
1491 const_int with a suitable value. */
1492 if (GET_CODE (operand
) != CONST_INT
|| INTVAL (operand
) > 4)
1493 LOSE_AND_RETURN ("invalid operand for 'T' modifier", x
);
1494 fprintf (file
, "%s", mults
[INTVAL (operand
)]);
1498 /* No code, print as usual. */
1502 LOSE_AND_RETURN ("invalid operand modifier letter", x
);
1505 /* Print an operand as without a modifier letter. */
1506 switch (GET_CODE (operand
))
1509 if (REGNO (operand
) > 15)
1510 internal_error ("internal error: bad register: %d", REGNO (operand
));
1511 fprintf (file
, "$%s", reg_names
[REGNO (operand
)]);
1515 output_address (XEXP (operand
, 0));
1519 if (GET_MODE (operand
) == VOIDmode
)
1520 /* A long long constant. */
1521 output_addr_const (file
, operand
);
1524 /* Only single precision is allowed as plain operands the
1525 moment. FIXME: REAL_VALUE_FROM_CONST_DOUBLE isn't
1530 /* FIXME: Perhaps check overflow of the "single". */
1531 REAL_VALUE_FROM_CONST_DOUBLE (r
, operand
);
1532 REAL_VALUE_TO_TARGET_SINGLE (r
, l
);
1534 fprintf (file
, "0x%lx", l
);
1539 ASSERT_PLT_UNSPEC (operand
);
1543 cris_output_addr_const (file
, operand
);
1549 /* For a (MULT (reg X) const_int) we output "rX.S". */
1550 int i
= GET_CODE (XEXP (operand
, 1)) == CONST_INT
1551 ? INTVAL (XEXP (operand
, 1)) : INTVAL (XEXP (operand
, 0));
1552 rtx reg
= GET_CODE (XEXP (operand
, 1)) == CONST_INT
1553 ? XEXP (operand
, 0) : XEXP (operand
, 1);
1555 if (GET_CODE (reg
) != REG
1556 || (GET_CODE (XEXP (operand
, 0)) != CONST_INT
1557 && GET_CODE (XEXP (operand
, 1)) != CONST_INT
))
1558 LOSE_AND_RETURN ("unexpected multiplicative operand", x
);
1560 cris_print_base (reg
, file
);
1561 fprintf (file
, ".%c",
1562 i
== 0 || (i
== 1 && GET_CODE (operand
) == MULT
) ? 'b'
1564 : (i
== 2 && GET_CODE (operand
) == MULT
) || i
== 1 ? 'w'
1570 /* No need to handle all strange variants, let output_addr_const
1572 if (CONSTANT_P (operand
))
1574 cris_output_addr_const (file
, operand
);
1578 LOSE_AND_RETURN ("unexpected operand", x
);
1582 /* The PRINT_OPERAND_ADDRESS worker. */
1585 cris_print_operand_address (file
, x
)
1589 /* All these were inside MEM:s so output indirection characters. */
1592 if (CONSTANT_ADDRESS_P (x
))
1593 cris_output_addr_const (file
, x
);
1594 else if (BASE_OR_AUTOINCR_P (x
))
1595 cris_print_base (x
, file
);
1596 else if (GET_CODE (x
) == PLUS
)
1604 cris_print_base (x1
, file
);
1605 cris_print_index (x2
, file
);
1607 else if (BASE_P (x2
))
1609 cris_print_base (x2
, file
);
1610 cris_print_index (x1
, file
);
1613 LOSE_AND_RETURN ("unrecognized address", x
);
1615 else if (GET_CODE (x
) == MEM
)
1617 /* A DIP. Output more indirection characters. */
1619 cris_print_base (XEXP (x
, 0), file
);
1623 LOSE_AND_RETURN ("unrecognized address", x
);
1628 /* The RETURN_ADDR_RTX worker.
1629 We mark that the return address is used, either by EH or
1630 __builtin_return_address, for use by the function prologue and
1631 epilogue. FIXME: This isn't optimal; we just use the mark in the
1632 prologue and epilogue to say that the return address is to be stored
1633 in the stack frame. We could return SRP for leaf-functions and use the
1634 initial-value machinery. */
1637 cris_return_addr_rtx (count
, frameaddr
)
1639 rtx frameaddr ATTRIBUTE_UNUSED
;
1641 cfun
->machine
->needs_return_address_on_stack
= 1;
1643 /* The return-address is stored just above the saved frame-pointer (if
1644 present). Apparently we can't eliminate from the frame-pointer in
1645 that direction, so use the incoming args (maybe pretended) pointer. */
1647 ? gen_rtx_MEM (Pmode
, plus_constant (virtual_incoming_args_rtx
, -4))
1651 /* This used to be the INITIAL_FRAME_POINTER_OFFSET worker; now only
1652 handles FP -> SP elimination offset. */
1655 cris_initial_frame_pointer_offset ()
1659 /* Initial offset is 0 if we don't have a frame pointer. */
1662 /* And 4 for each register pushed. */
1663 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1664 if ((((regs_ever_live
[regno
]
1665 && !call_used_regs
[regno
])
1666 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
1667 && (current_function_uses_pic_offset_table
1668 /* It is saved anyway, if there would be a gap. */
1670 && regs_ever_live
[regno
+ 1]
1671 && !call_used_regs
[regno
+ 1]))))
1672 && (regno
!= FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
1673 && regno
!= CRIS_SRP_REGNUM
)
1674 || (current_function_calls_eh_return
1675 && (regno
== EH_RETURN_DATA_REGNO (0)
1676 || regno
== EH_RETURN_DATA_REGNO (1)
1677 || regno
== EH_RETURN_DATA_REGNO (2)
1678 || regno
== EH_RETURN_DATA_REGNO (3))))
1681 /* And then, last, we add the locals allocated. */
1682 offs
+= get_frame_size ();
1684 /* And more; the accumulated args size. */
1685 offs
+= current_function_outgoing_args_size
;
1687 /* Then round it off, in case we use aligned stack. */
1688 if (TARGET_STACK_ALIGN
)
1689 offs
= TARGET_ALIGN_BY_32
? (offs
+ 3) & ~3 : (offs
+ 1) & ~1;
1694 /* The INITIAL_ELIMINATION_OFFSET worker.
1695 Calculate the difference between imaginary registers such as frame
1696 pointer and the stack pointer. Used to eliminate the frame pointer
1697 and imaginary arg pointer. */
1700 cris_initial_elimination_offset (fromreg
, toreg
)
1705 = cris_initial_frame_pointer_offset ();
1707 /* We should be able to use regs_ever_live and related prologue
1708 information here, or alpha should not as well. */
1709 int return_address_on_stack
1710 = regs_ever_live
[CRIS_SRP_REGNUM
]
1711 || cfun
->machine
->needs_return_address_on_stack
!= 0;
1713 /* Here we act as if the frame-pointer is needed. */
1714 int ap_fp_offset
= 4 + (return_address_on_stack
? 4 : 0);
1716 if (fromreg
== ARG_POINTER_REGNUM
1717 && toreg
== FRAME_POINTER_REGNUM
)
1718 return ap_fp_offset
;
1720 /* Between the frame pointer and the stack are only "normal" stack
1721 variables and saved registers. */
1722 if (fromreg
== FRAME_POINTER_REGNUM
1723 && toreg
== STACK_POINTER_REGNUM
)
1724 return fp_sp_offset
;
1726 /* We need to balance out the frame pointer here. */
1727 if (fromreg
== ARG_POINTER_REGNUM
1728 && toreg
== STACK_POINTER_REGNUM
)
1729 return ap_fp_offset
+ fp_sp_offset
- 4;
1734 /* This function looks into the pattern to see how this insn affects
1737 Used when to eliminate test insns before a condition-code user,
1738 such as a "scc" insn or a conditional branch. This includes
1739 checking if the entities that cc was updated by, are changed by the
1742 Currently a jumble of the old peek-inside-the-insn and the newer
1743 check-cc-attribute methods. */
1746 cris_notice_update_cc (exp
, insn
)
1750 /* Check if user specified "-mcc-init" as a bug-workaround. FIXME:
1751 TARGET_CCINIT does not work; we must set CC_REVERSED as below.
1752 Several test-cases will otherwise fail, for example
1753 gcc.c-torture/execute/20000217-1.c -O0 and -O1. */
1760 /* Slowly, we're converting to using attributes to control the setting
1761 of condition-code status. */
1762 switch (get_attr_cc (insn
))
1765 /* Even if it is "none", a setting may clobber a previous
1766 cc-value, so check. */
1767 if (GET_CODE (exp
) == SET
)
1769 if (cc_status
.value1
1770 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1772 cc_status
.value1
= 0;
1774 if (cc_status
.value2
1775 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1777 cc_status
.value2
= 0;
1786 /* Which means, for:
1791 CC is (reg) and (...) - unless (...) is 0, then CC does not change.
1792 CC_NO_OVERFLOW unless (...) is reg or mem.
1801 (set (reg1) (mem (bdap/biap)))
1802 (set (reg2) (bdap/biap))):
1803 CC is (reg1) and (mem (reg2))
1806 (set (mem (bdap/biap)) (reg1)) [or 0]
1807 (set (reg2) (bdap/biap))):
1810 (where reg and mem includes strict_low_parts variants thereof)
1812 For all others, assume CC is clobbered.
1813 Note that we do not have to care about setting CC_NO_OVERFLOW,
1814 since the overflow flag is set to 0 (i.e. right) for
1815 instructions where it does not have any sane sense, but where
1816 other flags have meanings. (This includes shifts; the carry is
1819 Note that there are other parallel constructs we could match,
1820 but we don't do that yet. */
1822 if (GET_CODE (exp
) == SET
)
1824 /* FIXME: Check when this happens. It looks like we should
1825 actually do a CC_STATUS_INIT here to be safe. */
1826 if (SET_DEST (exp
) == pc_rtx
)
1829 /* Record CC0 changes, so we do not have to output multiple
1831 if (SET_DEST (exp
) == cc0_rtx
)
1833 cc_status
.value1
= SET_SRC (exp
);
1834 cc_status
.value2
= 0;
1836 /* Handle flags for the special btstq on one bit. */
1837 if (GET_CODE (SET_SRC (exp
)) == ZERO_EXTRACT
1838 && XEXP (SET_SRC (exp
), 1) == const1_rtx
)
1840 if (GET_CODE (XEXP (SET_SRC (exp
), 0)) == CONST_INT
)
1842 cc_status
.flags
= CC_INVERTED
;
1844 /* A one-bit btstq. */
1845 cc_status
.flags
= CC_Z_IN_NOT_N
;
1848 cc_status
.flags
= 0;
1850 if (GET_CODE (SET_SRC (exp
)) == COMPARE
)
1852 if (!REG_P (XEXP (SET_SRC (exp
), 0))
1853 && XEXP (SET_SRC (exp
), 1) != const0_rtx
)
1854 /* For some reason gcc will not canonicalize compare
1855 operations, reversing the sign by itself if
1856 operands are in wrong order. */
1857 /* (But NOT inverted; eq is still eq.) */
1858 cc_status
.flags
= CC_REVERSED
;
1860 /* This seems to be overlooked by gcc. FIXME: Check again.
1861 FIXME: Is it really safe? */
1863 = gen_rtx_MINUS (GET_MODE (SET_SRC (exp
)),
1864 XEXP (SET_SRC (exp
), 0),
1865 XEXP (SET_SRC (exp
), 1));
1869 else if (REG_P (SET_DEST (exp
))
1870 || (GET_CODE (SET_DEST (exp
)) == STRICT_LOW_PART
1871 && REG_P (XEXP (SET_DEST (exp
), 0))))
1873 /* A register is set; normally CC is set to show that no
1874 test insn is needed. Catch the exceptions. */
1876 /* If not to cc0, then no "set"s in non-natural mode give
1878 if (GET_MODE_SIZE (GET_MODE (SET_DEST (exp
))) > UNITS_PER_WORD
1879 || GET_MODE_CLASS (GET_MODE (SET_DEST (exp
))) == MODE_FLOAT
)
1881 /* ... except add:s and sub:s in DImode. */
1882 if (GET_MODE (SET_DEST (exp
)) == DImode
1883 && (GET_CODE (SET_SRC (exp
)) == PLUS
1884 || GET_CODE (SET_SRC (exp
)) == MINUS
))
1886 cc_status
.flags
= 0;
1887 cc_status
.value1
= SET_DEST (exp
);
1888 cc_status
.value2
= SET_SRC (exp
);
1890 if (cris_reg_overlap_mentioned_p (cc_status
.value1
,
1892 cc_status
.value2
= 0;
1894 /* Add and sub may set V, which gets us
1895 unoptimizable results in "gt" and "le" condition
1897 cc_status
.flags
|= CC_NO_OVERFLOW
;
1902 else if (SET_SRC (exp
) == const0_rtx
)
1904 /* There's no CC0 change when clearing a register or
1905 memory. Just check for overlap. */
1906 if ((cc_status
.value1
1907 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1909 cc_status
.value1
= 0;
1911 if ((cc_status
.value2
1912 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1914 cc_status
.value2
= 0;
1920 cc_status
.flags
= 0;
1921 cc_status
.value1
= SET_DEST (exp
);
1922 cc_status
.value2
= SET_SRC (exp
);
1924 if (cris_reg_overlap_mentioned_p (cc_status
.value1
,
1926 cc_status
.value2
= 0;
1928 /* Some operations may set V, which gets us
1929 unoptimizable results in "gt" and "le" condition
1931 if (GET_CODE (SET_SRC (exp
)) == PLUS
1932 || GET_CODE (SET_SRC (exp
)) == MINUS
1933 || GET_CODE (SET_SRC (exp
)) == NEG
)
1934 cc_status
.flags
|= CC_NO_OVERFLOW
;
1939 else if (GET_CODE (SET_DEST (exp
)) == MEM
1940 || (GET_CODE (SET_DEST (exp
)) == STRICT_LOW_PART
1941 && GET_CODE (XEXP (SET_DEST (exp
), 0)) == MEM
))
1943 /* When SET to MEM, then CC is not changed (except for
1945 if ((cc_status
.value1
1946 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1948 cc_status
.value1
= 0;
1950 if ((cc_status
.value2
1951 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1953 cc_status
.value2
= 0;
1958 else if (GET_CODE (exp
) == PARALLEL
)
1960 if (GET_CODE (XVECEXP (exp
, 0, 0)) == SET
1961 && GET_CODE (XVECEXP (exp
, 0, 1)) == SET
1962 && REG_P (XEXP (XVECEXP (exp
, 0, 1), 0)))
1964 if (REG_P (XEXP (XVECEXP (exp
, 0, 0), 0))
1965 && GET_CODE (XEXP (XVECEXP (exp
, 0, 0), 1)) == MEM
)
1967 /* For "move.S [rx=ry+o],rz", say CC reflects
1968 value1=rz and value2=[rx] */
1969 cc_status
.value1
= XEXP (XVECEXP (exp
, 0, 0), 0);
1971 = gen_rtx_MEM (GET_MODE (XEXP (XVECEXP (exp
, 0, 0), 0)),
1972 XEXP (XVECEXP (exp
, 0, 1), 0));
1973 cc_status
.flags
= 0;
1975 /* Huh? A side-effect cannot change the destination
1977 if (cris_reg_overlap_mentioned_p (cc_status
.value1
,
1979 internal_error ("internal error: sideeffect-insn affecting main effect");
1982 else if ((REG_P (XEXP (XVECEXP (exp
, 0, 0), 1))
1983 || XEXP (XVECEXP (exp
, 0, 0), 1) == const0_rtx
)
1984 && GET_CODE (XEXP (XVECEXP (exp
, 0, 0), 0)) == MEM
)
1986 /* For "move.S rz,[rx=ry+o]" and "clear.S [rx=ry+o]",
1987 say flags are not changed, except for overlap. */
1988 if (cc_status
.value1
1989 && cris_reg_overlap_mentioned_p (XEXP
1993 cc_status
.value1
= 0;
1995 if (cc_status
.value1
1996 && cris_reg_overlap_mentioned_p (XEXP
2000 cc_status
.value1
= 0;
2002 if (cc_status
.value2
2003 && cris_reg_overlap_mentioned_p (XEXP
2007 cc_status
.value2
= 0;
2009 if (cc_status
.value2
2010 && cris_reg_overlap_mentioned_p (XEXP
2014 cc_status
.value2
= 0;
2023 /* Unknown cc_attr value. */
2030 /* Return != 0 if the return sequence for the current function is short,
2031 like "ret" or "jump [sp+]". Prior to reloading, we can't tell how
2032 many registers must be saved, so return 0 then. */
2035 cris_simple_epilogue ()
2038 int reglimit
= STACK_POINTER_REGNUM
;
2041 if (! reload_completed
2042 || frame_pointer_needed
2043 || get_frame_size () != 0
2044 || current_function_pretend_args_size
2045 || current_function_args_size
2046 || current_function_outgoing_args_size
2047 || current_function_calls_eh_return
2049 /* If we're not supposed to emit prologue and epilogue, we must
2050 not emit return-type instructions. */
2051 || !TARGET_PROLOGUE_EPILOGUE
)
2054 /* We allow a "movem [sp+],rN" to sit in front if the "jump [sp+]" or
2055 in the delay-slot of the "ret". */
2056 for (regno
= 0; regno
< reglimit
; regno
++)
2057 if ((regs_ever_live
[regno
] && ! call_used_regs
[regno
])
2058 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
2059 && (current_function_uses_pic_offset_table
2060 /* It is saved anyway, if there would be a gap. */
2062 && regs_ever_live
[regno
+ 1]
2063 && !call_used_regs
[regno
+ 1]))))
2065 if (lastreg
!= regno
- 1)
2073 /* The ADDRESS_COST worker. */
2076 cris_address_cost (x
)
2079 /* The metric to use for the cost-macros is unclear.
2080 The metric used here is (the number of cycles needed) / 2,
2081 where we consider equal a cycle for a word of code and a cycle to
2084 /* The cheapest addressing modes get 0, since nothing extra is needed. */
2085 if (BASE_OR_AUTOINCR_P (x
))
2088 /* An indirect mem must be a DIP. This means two bytes extra for code,
2089 and 4 bytes extra for memory read, i.e. (2 + 4) / 2. */
2090 if (GET_CODE (x
) == MEM
)
2093 /* Assume (2 + 4) / 2 for a single constant; a dword, since it needs
2094 an extra DIP prefix and 4 bytes of constant in most cases.
2095 For PIC and a symbol with a GOT entry, we double the cost since we
2096 add a [rPIC+...] offset. A GOT-less symbol uses a BDAP prefix
2097 equivalent to the DIP prefix for non-PIC, hence the same cost. */
2099 return flag_pic
&& cris_got_symbol (x
) ? 2 * (2 + 4) / 2 : (2 + 4) / 2;
2101 /* Handle BIAP and BDAP prefixes. */
2102 if (GET_CODE (x
) == PLUS
)
2104 rtx tem1
= XEXP (x
, 0);
2105 rtx tem2
= XEXP (x
, 1);
2107 /* A BIAP is 2 extra bytes for the prefix insn, nothing more. We
2108 recognize the typical MULT which is always in tem1 because of
2109 insn canonicalization. */
2110 if ((GET_CODE (tem1
) == MULT
&& BIAP_INDEX_P (tem1
))
2114 /* A BDAP (quick) is 2 extra bytes. Any constant operand to the
2115 PLUS is always found in tem2. */
2116 if (GET_CODE (tem2
) == CONST_INT
2117 && INTVAL (tem2
) < 128 && INTVAL (tem2
) >= -128)
2120 /* A BDAP -32768 .. 32767 is like BDAP quick, but with 2 extra
2122 if (GET_CODE (tem2
) == CONST_INT
2123 && CONST_OK_FOR_LETTER_P (INTVAL (tem2
), 'L'))
2126 /* A BDAP with some other constant is 2 bytes extra. */
2127 if (CONSTANT_P (tem2
))
2128 return (2 + 2 + 2) / 2;
2130 /* BDAP with something indirect should have a higher cost than
2131 BIAP with register. FIXME: Should it cost like a MEM or more? */
2132 /* Don't need to check it, it's the only one left.
2133 FIXME: There was a REG test missing, perhaps there are others.
2135 return (2 + 2 + 2) / 2;
2138 /* What else? Return a high cost. It matters only for valid
2139 addressing modes. */
2143 /* Check various objections to the side-effect. Used in the test-part
2144 of an anonymous insn describing an insn with a possible side-effect.
2145 Returns nonzero if the implied side-effect is ok.
2148 ops : An array of rtx:es. lreg, rreg, rval,
2149 The variables multop and other_op are indexes into this,
2150 or -1 if they are not applicable.
2151 lreg : The register that gets assigned in the side-effect.
2152 rreg : One register in the side-effect expression
2153 rval : The other register, or an int.
2154 multop : An integer to multiply rval with.
2155 other_op : One of the entities of the main effect,
2156 whose mode we must consider. */
2159 cris_side_effect_mode_ok (code
, ops
, lreg
, rreg
, rval
, multop
, other_op
)
2162 int lreg
, rreg
, rval
, multop
, other_op
;
2164 /* Find what value to multiply with, for rx =ry + rz * n. */
2165 int mult
= multop
< 0 ? 1 : INTVAL (ops
[multop
]);
2167 rtx reg_rtx
= ops
[rreg
];
2168 rtx val_rtx
= ops
[rval
];
2170 /* The operands may be swapped. Canonicalize them in reg_rtx and
2171 val_rtx, where reg_rtx always is a reg (for this constraint to
2173 if (! BASE_P (reg_rtx
))
2174 reg_rtx
= val_rtx
, val_rtx
= ops
[rreg
];
2176 /* Don't forget to check that reg_rtx really is a reg. If it isn't,
2177 we have no business. */
2178 if (! BASE_P (reg_rtx
))
2181 /* Don't do this when -mno-split. */
2182 if (!TARGET_SIDE_EFFECT_PREFIXES
)
2185 /* The mult expression may be hidden in lreg. FIXME: Add more
2186 commentary about that. */
2187 if (GET_CODE (val_rtx
) == MULT
)
2189 mult
= INTVAL (XEXP (val_rtx
, 1));
2190 val_rtx
= XEXP (val_rtx
, 0);
2194 /* First check the "other operand". */
2197 if (GET_MODE_SIZE (GET_MODE (ops
[other_op
])) > UNITS_PER_WORD
)
2200 /* Check if the lvalue register is the same as the "other
2201 operand". If so, the result is undefined and we shouldn't do
2202 this. FIXME: Check again. */
2203 if ((BASE_P (ops
[lreg
])
2204 && BASE_P (ops
[other_op
])
2205 && REGNO (ops
[lreg
]) == REGNO (ops
[other_op
]))
2206 || rtx_equal_p (ops
[other_op
], ops
[lreg
]))
2210 /* Do not accept frame_pointer_rtx as any operand. */
2211 if (ops
[lreg
] == frame_pointer_rtx
|| ops
[rreg
] == frame_pointer_rtx
2212 || ops
[rval
] == frame_pointer_rtx
2213 || (other_op
>= 0 && ops
[other_op
] == frame_pointer_rtx
))
2217 && ! BASE_P (val_rtx
))
2220 /* Do not allow rx = rx + n if a normal add or sub with same size
2222 if (rtx_equal_p (ops
[lreg
], reg_rtx
)
2223 && GET_CODE (val_rtx
) == CONST_INT
2224 && (INTVAL (val_rtx
) <= 63 && INTVAL (val_rtx
) >= -63))
2227 /* Check allowed cases, like [r(+)?].[bwd] and const.
2228 A symbol is not allowed with PIC. */
2229 if (CONSTANT_P (val_rtx
))
2230 return flag_pic
== 0 || cris_symbol (val_rtx
) == 0;
2232 if (GET_CODE (val_rtx
) == MEM
2233 && BASE_OR_AUTOINCR_P (XEXP (val_rtx
, 0)))
2236 if (GET_CODE (val_rtx
) == SIGN_EXTEND
2237 && GET_CODE (XEXP (val_rtx
, 0)) == MEM
2238 && BASE_OR_AUTOINCR_P (XEXP (XEXP (val_rtx
, 0), 0)))
2241 /* If we got here, it's not a valid addressing mode. */
2244 else if (code
== MULT
2245 || (code
== PLUS
&& BASE_P (val_rtx
)))
2247 /* Do not allow rx = rx + ry.S, since it doesn't give better code. */
2248 if (rtx_equal_p (ops
[lreg
], reg_rtx
)
2249 || (mult
== 1 && rtx_equal_p (ops
[lreg
], val_rtx
)))
2252 /* Do not allow bad multiply-values. */
2253 if (mult
!= 1 && mult
!= 2 && mult
!= 4)
2256 /* Only allow r + ... */
2257 if (! BASE_P (reg_rtx
))
2260 /* If we got here, all seems ok.
2261 (All checks need to be done above). */
2265 /* If we get here, the caller got its initial tests wrong. */
2266 internal_error ("internal error: cris_side_effect_mode_ok with bad operands");
2269 /* The function reg_overlap_mentioned_p in CVS (still as of 2001-05-16)
2270 does not handle the case where the IN operand is strict_low_part; it
2271 does handle it for X. Test-case in Axis-20010516. This function takes
2272 care of that for THIS port. FIXME: strict_low_part is going away
2276 cris_reg_overlap_mentioned_p (x
, in
)
2279 /* The function reg_overlap_mentioned now handles when X is
2280 strict_low_part, but not when IN is a STRICT_LOW_PART. */
2281 if (GET_CODE (in
) == STRICT_LOW_PART
)
2284 return reg_overlap_mentioned_p (x
, in
);
2287 /* The TARGET_ASM_NAMED_SECTION worker.
2288 We just dispatch to the functions for ELF and a.out. */
2291 cris_target_asm_named_section (name
, flags
)
2296 default_no_named_section (name
, flags
);
2298 default_elf_asm_named_section (name
, flags
);
2301 /* The LEGITIMATE_PIC_OPERAND_P worker. */
2304 cris_legitimate_pic_operand (x
)
2307 /* The PIC representation of a symbol with a GOT entry will be (for
2308 example; relocations differ):
2309 sym => [rPIC+sym:GOT]
2310 and for a GOT-less symbol it will be (for example, relocation differ):
2311 sym => rPIC+sym:GOTOFF
2312 so only a symbol with a GOT is by itself a valid operand, and it
2313 can't be a sum of a symbol and an offset. */
2314 return ! cris_symbol (x
) || cris_got_symbol (x
);
2317 /* Return non-zero if there's a SYMBOL_REF or LABEL_REF hiding inside this
2324 switch (GET_CODE (x
))
2331 /* A PLT reference. */
2332 ASSERT_PLT_UNSPEC (x
);
2336 return cris_symbol (XEXP (x
, 0));
2340 return cris_symbol (XEXP (x
, 0)) || cris_symbol (XEXP (x
, 1));
2344 case CONSTANT_P_RTX
:
2348 fatal_insn ("unrecognized supposed constant", x
);
2354 /* Return non-zero if there's a SYMBOL_REF or LABEL_REF hiding inside this
2355 CONSTANT_P, and the symbol does not need a GOT entry. Also set
2356 current_function_uses_pic_offset_table if we're generating PIC and ever
2357 see something that would need one. */
2360 cris_gotless_symbol (x
)
2363 switch (GET_CODE (x
))
2366 ASSERT_PLT_UNSPEC (x
);
2370 if (flag_pic
&& cfun
!= NULL
)
2371 current_function_uses_pic_offset_table
= 1;
2372 return SYMBOL_REF_FLAG (x
);
2375 /* We don't set current_function_uses_pic_offset_table for
2376 LABEL_REF:s in here, since they are almost always originating
2377 from some branch. The only time it does not come from a label is
2378 when GCC does something like __builtin_setjmp. Then we get the
2379 LABEL_REF from the movsi expander, so we mark it there as a
2384 return cris_gotless_symbol (XEXP (x
, 0));
2389 int x0
= cris_gotless_symbol (XEXP (x
, 0)) != 0;
2390 int x1
= cris_gotless_symbol (XEXP (x
, 1)) != 0;
2392 /* One and only one of them must be a local symbol. Neither must
2393 be some other, more general kind of symbol. */
2396 && ! (x0
== 0 && cris_symbol (XEXP (x
, 0)))
2397 && ! (x1
== 0 && cris_symbol (XEXP (x
, 1)));
2402 case CONSTANT_P_RTX
:
2406 fatal_insn ("unrecognized supposed constant", x
);
2412 /* Return non-zero if there's a SYMBOL_REF or LABEL_REF hiding inside this
2413 CONSTANT_P, and the symbol needs a GOT entry. */
2419 switch (GET_CODE (x
))
2422 ASSERT_PLT_UNSPEC (x
);
2426 if (flag_pic
&& cfun
!= NULL
)
2427 current_function_uses_pic_offset_table
= 1;
2428 return ! SYMBOL_REF_FLAG (x
);
2431 return cris_got_symbol (XEXP (x
, 0));
2434 /* A LABEL_REF is never visible as a symbol outside the local
2438 /* Nope, can't access the GOT for "symbol + offset". */
2443 case CONSTANT_P_RTX
:
2447 fatal_insn ("unrecognized supposed constant in cris_global_pic_symbol",
2454 /* The OVERRIDE_OPTIONS worker.
2455 As is the norm, this also parses -mfoo=bar type parameters. */
2458 cris_override_options ()
2460 if (cris_max_stackframe_str
)
2462 cris_max_stackframe
= atoi (cris_max_stackframe_str
);
2464 /* Do some sanity checking. */
2465 if (cris_max_stackframe
< 0 || cris_max_stackframe
> 0x20000000)
2466 internal_error ("-max-stackframe=%d is not usable, not between 0 and %d",
2467 cris_max_stackframe
, 0x20000000);
2470 /* Let "-metrax4" and "-metrax100" change the cpu version. */
2471 if (TARGET_SVINTO
&& cris_cpu_version
< CRIS_CPU_SVINTO
)
2472 cris_cpu_version
= CRIS_CPU_SVINTO
;
2473 else if (TARGET_ETRAX4_ADD
&& cris_cpu_version
< CRIS_CPU_ETRAX4
)
2474 cris_cpu_version
= CRIS_CPU_ETRAX4
;
2476 /* Parse -march=... and its synonym, the deprecated -mcpu=... */
2480 = (*cris_cpu_str
== 'v' ? atoi (cris_cpu_str
+ 1) : -1);
2482 if (strcmp ("etrax4", cris_cpu_str
) == 0)
2483 cris_cpu_version
= 3;
2485 if (strcmp ("svinto", cris_cpu_str
) == 0
2486 || strcmp ("etrax100", cris_cpu_str
) == 0)
2487 cris_cpu_version
= 8;
2489 if (strcmp ("ng", cris_cpu_str
) == 0
2490 || strcmp ("etrax100lx", cris_cpu_str
) == 0)
2491 cris_cpu_version
= 10;
2493 if (cris_cpu_version
< 0 || cris_cpu_version
> 10)
2494 error ("unknown CRIS version specification in -march= or -mcpu= : %s",
2497 /* Set the target flags. */
2498 if (cris_cpu_version
>= CRIS_CPU_ETRAX4
)
2499 target_flags
|= TARGET_MASK_ETRAX4_ADD
;
2501 /* If this is Svinto or higher, align for 32 bit accesses. */
2502 if (cris_cpu_version
>= CRIS_CPU_SVINTO
)
2504 |= (TARGET_MASK_SVINTO
| TARGET_MASK_ALIGN_BY_32
2505 | TARGET_MASK_STACK_ALIGN
| TARGET_MASK_CONST_ALIGN
2506 | TARGET_MASK_DATA_ALIGN
);
2508 /* Note that we do not add new flags when it can be completely
2509 described with a macro that uses -mcpu=X. So
2510 TARGET_HAS_MUL_INSNS is (cris_cpu_version >= CRIS_CPU_NG). */
2516 = (*cris_tune_str
== 'v' ? atoi (cris_tune_str
+ 1) : -1);
2518 if (strcmp ("etrax4", cris_tune_str
) == 0)
2521 if (strcmp ("svinto", cris_tune_str
) == 0
2522 || strcmp ("etrax100", cris_tune_str
) == 0)
2525 if (strcmp ("ng", cris_tune_str
) == 0
2526 || strcmp ("etrax100lx", cris_tune_str
) == 0)
2529 if (cris_tune
< 0 || cris_tune
> 10)
2530 error ("unknown CRIS cpu version specification in -mtune= : %s",
2533 if (cris_tune
>= CRIS_CPU_SVINTO
)
2534 /* We have currently nothing more to tune than alignment for
2537 |= (TARGET_MASK_STACK_ALIGN
| TARGET_MASK_CONST_ALIGN
2538 | TARGET_MASK_DATA_ALIGN
| TARGET_MASK_ALIGN_BY_32
);
2543 /* Use error rather than warning, so invalid use is easily
2544 detectable. Still change to the values we expect, to avoid
2548 error ("-fPIC and -fpic are not supported in this configuration");
2552 /* Turn off function CSE. We need to have the addresses reach the
2553 call expanders to get PLT-marked, as they could otherwise be
2554 compared against zero directly or indirectly. After visiting the
2555 call expanders they will then be cse:ed, as the call expanders
2556 force_reg the addresses, effectively forcing flag_no_function_cse
2558 flag_no_function_cse
= 1;
2561 if ((write_symbols
== DWARF_DEBUG
2562 || write_symbols
== DWARF2_DEBUG
) && ! TARGET_ELF
)
2564 warning ("that particular -g option is invalid with -maout and -melinux");
2565 write_symbols
= DBX_DEBUG
;
2568 /* Set the per-function-data initializer. */
2569 init_machine_status
= cris_init_machine_status
;
2572 /* The ASM_OUTPUT_MI_THUNK worker. */
2575 cris_asm_output_mi_thunk (stream
, thunkdecl
, delta
, funcdecl
)
2577 tree thunkdecl ATTRIBUTE_UNUSED
;
2582 asm_fprintf (stream
, "\tadd%s %d,$%s\n",
2583 ADDITIVE_SIZE_MODIFIER (delta
), delta
,
2584 reg_names
[CRIS_FIRST_ARG_REG
]);
2586 asm_fprintf (stream
, "\tsub%s %d,$%s\n",
2587 ADDITIVE_SIZE_MODIFIER (-delta
), -delta
,
2588 reg_names
[CRIS_FIRST_ARG_REG
]);
2592 const char *name
= XSTR (XEXP (DECL_RTL (funcdecl
), 0), 0);
2594 name
= (* targetm
.strip_name_encoding
) (name
);
2595 fprintf (stream
, "add.d ");
2596 assemble_name (stream
, name
);
2597 fprintf (stream
, "%s,$pc\n", CRIS_PLT_PCOFFSET_SUFFIX
);
2601 fprintf (stream
, "jump ");
2602 assemble_name (stream
, XSTR (XEXP (DECL_RTL (funcdecl
), 0), 0));
2603 fprintf (stream
, "\n");
2607 /* The EXPAND_BUILTIN_VA_ARG worker. This is modified from the
2608 "standard" implementation of va_arg: read the value from the current
2609 address and increment by the size of one or two registers. The
2610 important difference for CRIS is that if the type is
2611 pass-by-reference, then perform an indirection. */
2614 cris_expand_builtin_va_arg (valist
, type
)
2620 tree passed_size
= size_zero_node
;
2621 tree type_size
= NULL
;
2622 tree size3
= size_int (3);
2623 tree size4
= size_int (4);
2624 tree size8
= size_int (8);
2630 if (type
== error_mark_node
2631 || (type_size
= TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type
))) == NULL
2632 || TREE_OVERFLOW (type_size
))
2633 /* Presumably an error; the size isn't computable. A message has
2634 supposedly been emitted elsewhere. */
2635 rounded_size
= size_zero_node
;
2638 = fold (build (MULT_EXPR
, sizetype
,
2639 fold (build (TRUNC_DIV_EXPR
, sizetype
,
2640 fold (build (PLUS_EXPR
, sizetype
,
2645 if (!integer_zerop (rounded_size
))
2647 /* Check if the type is passed by value or by reference. Values up
2648 to 8 bytes are passed by-value, padded to register-size (4
2649 bytes). Larger values and varying-size types are passed
2652 = (!really_constant_p (type_size
)
2654 : fold (build (COND_EXPR
, sizetype
,
2655 fold (build (GT_EXPR
, sizetype
,
2662 = (!really_constant_p (type_size
)
2663 ? build1 (INDIRECT_REF
, build_pointer_type (type
), addr_tree
)
2664 : fold (build (COND_EXPR
, TREE_TYPE (addr_tree
),
2665 fold (build (GT_EXPR
, sizetype
,
2668 build1 (INDIRECT_REF
, build_pointer_type (type
),
2673 addr
= expand_expr (addr_tree
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
2674 addr
= copy_to_reg (addr
);
2676 if (!integer_zerop (rounded_size
))
2678 /* Compute new value for AP. */
2679 t
= build (MODIFY_EXPR
, TREE_TYPE (valist
), valist
,
2680 build (PLUS_EXPR
, TREE_TYPE (valist
), valist
,
2682 TREE_SIDE_EFFECTS (t
) = 1;
2683 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2689 /* The INIT_EXPANDERS worker sets the per-function-data initializer and
2693 cris_init_expanders ()
2695 /* Nothing here at the moment. */
2698 /* Zero initialization is OK for all current fields. */
2700 static struct machine_function
*
2701 cris_init_machine_status ()
2703 return ggc_alloc_cleared (sizeof (struct machine_function
));
2706 /* Split a 2 word move (DI or presumably DF) into component parts.
2707 Originally a copy of gen_split_move_double in m32r.c. */
2710 cris_split_movdx (operands
)
2713 enum machine_mode mode
= GET_MODE (operands
[0]);
2714 rtx dest
= operands
[0];
2715 rtx src
= operands
[1];
2718 /* We used to have to handle (SUBREG (MEM)) here, but that should no
2719 longer happen; after reload there are no SUBREGs any more, and we're
2720 only called after reload. */
2721 if (GET_CODE (dest
) == SUBREG
|| GET_CODE (src
) == SUBREG
)
2725 if (GET_CODE (dest
) == REG
)
2727 int dregno
= REGNO (dest
);
2729 /* Reg-to-reg copy. */
2730 if (GET_CODE (src
) == REG
)
2732 int sregno
= REGNO (src
);
2734 int reverse
= (dregno
== sregno
+ 1);
2736 /* We normally copy the low-numbered register first. However, if
2737 the first register operand 0 is the same as the second register of
2738 operand 1, we must copy in the opposite order. */
2739 emit_insn (gen_rtx_SET (VOIDmode
,
2740 operand_subword (dest
, reverse
, TRUE
, mode
),
2741 operand_subword (src
, reverse
, TRUE
, mode
)));
2743 emit_insn (gen_rtx_SET (VOIDmode
,
2744 operand_subword (dest
, !reverse
, TRUE
, mode
),
2745 operand_subword (src
, !reverse
, TRUE
, mode
)));
2747 /* Constant-to-reg copy. */
2748 else if (GET_CODE (src
) == CONST_INT
|| GET_CODE (src
) == CONST_DOUBLE
)
2751 split_double (src
, &words
[0], &words
[1]);
2752 emit_insn (gen_rtx_SET (VOIDmode
,
2753 operand_subword (dest
, 0, TRUE
, mode
),
2756 emit_insn (gen_rtx_SET (VOIDmode
,
2757 operand_subword (dest
, 1, TRUE
, mode
),
2760 /* Mem-to-reg copy. */
2761 else if (GET_CODE (src
) == MEM
)
2763 /* If the high-address word is used in the address, we must load it
2764 last. Otherwise, load it first. */
2765 rtx addr
= XEXP (src
, 0);
2767 = (refers_to_regno_p (dregno
, dregno
+ 1, addr
, NULL
) != 0);
2769 /* The original code imples that we can't do
2770 move.x [rN+],rM move.x [rN],rM+1
2771 when rN is dead, because of REG_NOTES damage. That is
2772 consistent with what I've seen, so don't try it.
2774 We have two different cases here; if the addr is POST_INC,
2775 just pass it through, otherwise add constants. */
2777 if (GET_CODE (addr
) == POST_INC
)
2779 emit_insn (gen_rtx_SET (VOIDmode
,
2780 operand_subword (dest
, 0, TRUE
, mode
),
2781 change_address (src
, SImode
, addr
)));
2782 emit_insn (gen_rtx_SET (VOIDmode
,
2783 operand_subword (dest
, 1, TRUE
, mode
),
2784 change_address (src
, SImode
, addr
)));
2788 /* Make sure we don't get any other addresses with
2789 embedded postincrements. They should be stopped in
2790 GO_IF_LEGITIMATE_ADDRESS, but we're here for your
2792 if (side_effects_p (addr
))
2793 fatal_insn ("unexpected side-effects in address", addr
);
2795 emit_insn (gen_rtx_SET
2797 operand_subword (dest
, reverse
, TRUE
, mode
),
2800 plus_constant (addr
,
2801 reverse
* UNITS_PER_WORD
))));
2802 emit_insn (gen_rtx_SET
2804 operand_subword (dest
, ! reverse
, TRUE
, mode
),
2807 plus_constant (addr
,
2815 /* Reg-to-mem copy or clear mem. */
2816 else if (GET_CODE (dest
) == MEM
2817 && (GET_CODE (src
) == REG
2818 || src
== const0_rtx
2819 || src
== CONST0_RTX (DFmode
)))
2821 rtx addr
= XEXP (dest
, 0);
2823 if (GET_CODE (addr
) == POST_INC
)
2825 emit_insn (gen_rtx_SET (VOIDmode
,
2826 change_address (dest
, SImode
, addr
),
2827 operand_subword (src
, 0, TRUE
, mode
)));
2828 emit_insn (gen_rtx_SET (VOIDmode
,
2829 change_address (dest
, SImode
, addr
),
2830 operand_subword (src
, 1, TRUE
, mode
)));
2834 /* Make sure we don't get any other addresses with embedded
2835 postincrements. They should be stopped in
2836 GO_IF_LEGITIMATE_ADDRESS, but we're here for your safety. */
2837 if (side_effects_p (addr
))
2838 fatal_insn ("unexpected side-effects in address", addr
);
2840 emit_insn (gen_rtx_SET
2842 change_address (dest
, SImode
, addr
),
2843 operand_subword (src
, 0, TRUE
, mode
)));
2845 emit_insn (gen_rtx_SET
2847 change_address (dest
, SImode
,
2848 plus_constant (addr
,
2850 operand_subword (src
, 1, TRUE
, mode
)));
2857 val
= gen_sequence ();
2862 /* This is in essence a copy of output_addr_const altered to output
2863 symbolic operands as PIC.
2865 FIXME: Add hooks similar to ASM_OUTPUT_SYMBOL_REF to get this effect in
2866 the "real" output_addr_const. All we need is one for LABEL_REF (and
2867 one for CODE_LABEL?). */
2870 cris_output_addr_const (file
, x
)
2877 switch (GET_CODE (x
))
2880 ASSERT_PLT_UNSPEC (x
);
2881 x
= XVECEXP (x
, 0, 0);
2888 const char *origstr
= XSTR (x
, 0);
2891 str
= (* targetm
.strip_name_encoding
) (origstr
);
2895 if (cris_pic_sympart_only
)
2897 assemble_name (file
, str
);
2898 fprintf (file
, ":PLTG");
2902 if (TARGET_AVOID_GOTPLT
)
2903 /* We shouldn't get here. */
2906 fprintf (file
, "[$%s+", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
2907 assemble_name (file
, XSTR (x
, 0));
2910 fprintf (file
, ":GOTPLT16]");
2912 fprintf (file
, ":GOTPLT]");
2915 else if (cris_gotless_symbol (x
))
2917 if (! cris_pic_sympart_only
)
2918 fprintf (file
, "$%s+", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
2919 assemble_name (file
, str
);
2920 fprintf (file
, ":GOTOFF");
2922 else if (cris_got_symbol (x
))
2924 if (cris_pic_sympart_only
)
2926 fprintf (file
, "[$%s+", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
2927 assemble_name (file
, XSTR (x
, 0));
2930 fprintf (file
, ":GOT16]");
2932 fprintf (file
, ":GOT]");
2935 LOSE_AND_RETURN ("unexpected PIC symbol", x
);
2938 if (! current_function_uses_pic_offset_table
)
2939 output_operand_lossage ("PIC register isn't set up");
2942 assemble_name (file
, XSTR (x
, 0));
2946 /* If we get one of those here, it should be dressed as PIC. Branch
2947 labels are normally output with the 'l' specifier, which means it
2948 will go directly to output_asm_label and not end up here. */
2949 if (GET_CODE (XEXP (x
, 0)) != CODE_LABEL
2950 && (GET_CODE (XEXP (x
, 0)) != NOTE
2951 || NOTE_LINE_NUMBER (XEXP (x
, 0)) != NOTE_INSN_DELETED_LABEL
))
2952 fatal_insn ("unexpected address expression", x
);
2956 if (cris_gotless_symbol (x
))
2958 if (! cris_pic_sympart_only
)
2959 fprintf (file
, "$%s+", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
2960 cris_output_addr_const (file
, XEXP (x
, 0));
2962 fprintf (file
, ":GOTOFF");
2965 /* Labels are never marked as global symbols. */
2966 fatal_insn ("unexpected PIC symbol", x
);
2969 if (! current_function_uses_pic_offset_table
)
2970 internal_error ("emitting PIC operand, but PIC register isn't set up");
2974 output_addr_const (file
, x
);
2978 if (NOTE_LINE_NUMBER (x
) != NOTE_INSN_DELETED_LABEL
)
2979 fatal_insn ("unexpected NOTE as addr_const:", x
);
2985 output_addr_const (file
, x
);
2989 /* This used to output parentheses around the expression,
2990 but that does not work on the 386 (either ATT or BSD assembler). */
2991 cris_output_addr_const (file
, XEXP (x
, 0));
2995 /* Some assemblers need integer constants to appear last (eg masm). */
2996 if (GET_CODE (XEXP (x
, 0)) == CONST_INT
)
2998 cris_output_addr_const (file
, XEXP (x
, 1));
2999 if (INTVAL (XEXP (x
, 0)) >= 0)
3000 fprintf (file
, "+");
3001 output_addr_const (file
, XEXP (x
, 0));
3005 cris_output_addr_const (file
, XEXP (x
, 0));
3006 if (GET_CODE (XEXP (x
, 1)) != CONST_INT
3007 || INTVAL (XEXP (x
, 1)) >= 0)
3008 fprintf (file
, "+");
3009 cris_output_addr_const (file
, XEXP (x
, 1));
3014 /* Avoid outputting things like x-x or x+5-x,
3015 since some assemblers can't handle that. */
3016 x
= simplify_subtraction (x
);
3017 if (GET_CODE (x
) != MINUS
)
3020 cris_output_addr_const (file
, XEXP (x
, 0));
3021 fprintf (file
, "-");
3022 if ((GET_CODE (XEXP (x
, 1)) == CONST_INT
3023 && INTVAL (XEXP (x
, 1)) < 0)
3024 || GET_CODE (XEXP (x
, 1)) != CONST_INT
)
3026 fprintf (file
, "%s", targetm
.asm_out
.open_paren
);
3027 cris_output_addr_const (file
, XEXP (x
, 1));
3028 fprintf (file
, "%s", targetm
.asm_out
.close_paren
);
3031 output_addr_const (file
, XEXP (x
, 1));
3035 LOSE_AND_RETURN ("unexpected address expression", x
);
3039 /* Code-in whether we can get away without a GOT entry (needed for
3040 externally visible objects but not for functions) into
3041 SYMBOL_REF_FLAG and add the PLT suffix for global functions. */
3044 cris_encode_section_info (exp
, first
)
3046 int first ATTRIBUTE_UNUSED
;
3050 rtx rtl
= DECL_P (exp
) ? DECL_RTL (exp
) : TREE_CST_RTL (exp
);
3052 if (GET_CODE (rtl
) == MEM
&& GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
)
3053 SYMBOL_REF_FLAG (XEXP (rtl
, 0)) = (*targetm
.binds_local_p
) (exp
);
3058 /* Various small functions to replace macros. Only called from a
3059 debugger. They might collide with gcc functions or system functions,
3060 so only emit them when '#if 1' above. */
3062 enum rtx_code Get_code
PARAMS ((rtx
));
3068 return GET_CODE (x
);
3071 const char *Get_mode
PARAMS ((rtx
));
3077 return GET_MODE_NAME (GET_MODE (x
));
3080 rtx Xexp
PARAMS ((rtx
, int));
3090 rtx Xvecexp
PARAMS ((rtx
, int, int));
3097 return XVECEXP (x
, n
, m
);
3100 int Get_rtx_len
PARAMS ((rtx
));
3106 return GET_RTX_LENGTH (GET_CODE (x
));
3109 /* Use upper-case to distinguish from local variables that are sometimes
3110 called next_insn and prev_insn. */
3112 rtx Next_insn
PARAMS ((rtx
));
3118 return NEXT_INSN (insn
);
3121 rtx Prev_insn
PARAMS ((rtx
));
3127 return PREV_INSN (insn
);
3131 #include "gt-cris.h"
3135 * eval: (c-set-style "gnu")
3136 * indent-tabs-mode: t