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"
45 /* Usable when we have an amount to add or subtract, and want the
46 optimal size of the insn. */
47 #define ADDITIVE_SIZE_MODIFIER(size) \
48 ((size) <= 63 ? "q" : (size) <= 255 ? "u.b" : (size) <= 65535 ? "u.w" : ".d")
50 #define ASSERT_PLT_UNSPEC(x) \
53 if (XEXP (x, 1) != NULL_RTX \
54 || (GET_CODE (XVECEXP (x, 0, 0)) != SYMBOL_REF \
55 && GET_CODE (XVECEXP (x, 0, 0)) != LABEL_REF)) \
59 #define LOSE_AND_RETURN(msgid, x) \
62 cris_operand_lossage (msgid, x); \
66 /* Per-function machine data. */
67 struct machine_function
GTY(())
69 int needs_return_address_on_stack
;
72 /* This little fix suppresses the 'u' or 's' when '%e' in assembly
74 static char cris_output_insn_is_bound
= 0;
76 /* This one suppresses printing out the "rPIC+" in
77 "rPIC+sym:GOTOFF+offset" when doing PIC. For a PLT symbol, it
78 suppresses outputting it as [rPIC+sym:GOTPLT] and outputs similarly
79 just the "sym:GOTOFF" part. */
80 static int cris_pic_sympart_only
= 0;
82 /* Fix for reg_overlap_mentioned_p. */
83 static int cris_reg_overlap_mentioned_p
PARAMS ((rtx
, rtx
));
85 static void cris_print_base
PARAMS ((rtx
, FILE *));
87 static void cris_print_index
PARAMS ((rtx
, FILE *));
89 static struct machine_function
* cris_init_machine_status
PARAMS ((void));
91 static int cris_initial_frame_pointer_offset
PARAMS ((void));
93 static int saved_regs_mentioned
PARAMS ((rtx
));
95 static void cris_target_asm_function_prologue
96 PARAMS ((FILE *, HOST_WIDE_INT
));
98 static void cris_target_asm_function_epilogue
99 PARAMS ((FILE *, HOST_WIDE_INT
));
101 static void cris_encode_section_info
PARAMS ((tree
, int));
102 static void cris_operand_lossage
PARAMS ((const char *, rtx
));
104 /* The function cris_target_asm_function_epilogue puts the last insn to
105 output here. It always fits; there won't be a symbol operand. Used in
106 delay_slots_for_epilogue and function_epilogue. */
107 static char save_last
[80];
109 /* This is the argument from the "-max-stack-stackframe=" option. */
110 const char *cris_max_stackframe_str
;
112 /* This is the argument from the "-march=" option. */
113 const char *cris_cpu_str
;
115 /* This is the argument from the "-mtune=" option. */
116 const char *cris_tune_str
;
118 /* This is the argument from the "-melinux-stacksize=" option. */
119 const char *cris_elinux_stacksize_str
;
121 /* This is the parsed result of the "-max-stack-stackframe=" option. If
122 it (still) is zero, then there was no such option given. */
123 int cris_max_stackframe
= 0;
125 /* This is the parsed result of the "-march=" option, if given. */
126 int cris_cpu_version
= CRIS_DEFAULT_CPU_VERSION
;
128 #undef TARGET_ASM_ALIGNED_HI_OP
129 #define TARGET_ASM_ALIGNED_HI_OP "\t.word\t"
130 #undef TARGET_ASM_ALIGNED_SI_OP
131 #define TARGET_ASM_ALIGNED_SI_OP "\t.dword\t"
132 #undef TARGET_ASM_ALIGNED_DI_OP
133 #define TARGET_ASM_ALIGNED_DI_OP "\t.quad\t"
135 /* We need to define these, since the 2byte, 4byte, 8byte op:s are only
136 available in ELF. These "normal" pseudos do not have any alignment
137 constraints or side-effects. */
138 #undef TARGET_ASM_UNALIGNED_HI_OP
139 #define TARGET_ASM_UNALIGNED_HI_OP TARGET_ASM_ALIGNED_HI_OP
141 #undef TARGET_ASM_UNALIGNED_SI_OP
142 #define TARGET_ASM_UNALIGNED_SI_OP TARGET_ASM_ALIGNED_SI_OP
144 #undef TARGET_ASM_UNALIGNED_DI_OP
145 #define TARGET_ASM_UNALIGNED_DI_OP TARGET_ASM_ALIGNED_DI_OP
147 #undef TARGET_ASM_FUNCTION_PROLOGUE
148 #define TARGET_ASM_FUNCTION_PROLOGUE cris_target_asm_function_prologue
150 #undef TARGET_ASM_FUNCTION_EPILOGUE
151 #define TARGET_ASM_FUNCTION_EPILOGUE cris_target_asm_function_epilogue
153 #undef TARGET_ENCODE_SECTION_INFO
154 #define TARGET_ENCODE_SECTION_INFO cris_encode_section_info
156 struct gcc_target targetm
= TARGET_INITIALIZER
;
158 /* Predicate functions. */
160 /* This checks a part of an address, the one that is not a plain register
161 for an addressing mode using BDAP.
162 Allowed operands is either:
164 b) a CONST operand (but not a symbol when generating PIC)
165 c) a [r] or [r+] in SImode, or sign-extend from HI or QI. */
168 cris_bdap_operand (op
, mode
)
170 enum machine_mode mode
;
172 register enum rtx_code code
= GET_CODE (op
);
174 if (mode
!= SImode
&& (mode
!= VOIDmode
|| GET_MODE (op
) != VOIDmode
))
177 /* Just return whether this is a simple register or constant. */
178 if (register_operand (op
, mode
)
179 || (CONSTANT_P (op
) && !(flag_pic
&& cris_symbol (op
))))
182 /* Is it a [r] or possibly a [r+]? */
185 rtx tem
= XEXP (op
, 0);
188 && (register_operand (tem
, SImode
)
189 || (GET_CODE (tem
) == POST_INC
190 && register_operand (XEXP (tem
, 0), SImode
))))
196 /* Perhaps a sign-extended mem: [r].(b|w) or [r+].(b|w)? */
197 if (code
== SIGN_EXTEND
)
199 rtx tem
= XEXP (op
, 0);
201 if (GET_CODE (tem
) != MEM
)
206 && (register_operand (tem
, SImode
)
207 || (GET_CODE (tem
) == POST_INC
208 && register_operand (XEXP (tem
, 0), SImode
))))
217 /* This is similar to cris_bdap_operand:
218 It checks a part of an address, the one that is not a plain register
219 for an addressing mode using BDAP *or* BIAP.
220 Allowed operands is either:
222 b) a CONST operand (but not a symbol when generating PIC)
223 c) a mult of (1, 2 or 4) and a register
224 d) a [r] or [r+] in SImode, or sign-extend from HI or QI. */
227 cris_bdap_biap_operand (op
, mode
)
229 enum machine_mode mode
;
231 register enum rtx_code code
= GET_CODE (op
);
235 /* Check for bdap operand. */
236 if (cris_bdap_operand (op
, mode
))
239 if (mode
!= SImode
&& (mode
!= VOIDmode
|| GET_MODE (op
) != VOIDmode
))
242 /* Check that we're looking at a BIAP operand. */
246 /* Canonicalize register and multiplicand. */
247 if (GET_CODE (XEXP (op
, 0)) == CONST_INT
)
258 /* Check that the operands are correct after canonicalization. */
259 if (! register_operand (reg
, SImode
) || GET_CODE (val
) != CONST_INT
)
262 /* Check that the multiplicand has a valid value. */
264 && (INTVAL (val
) == 1 || INTVAL (val
) == 2 || INTVAL (val
) == 4)))
270 /* Check if MODE is same as mode for X, and X is PLUS, MINUS, IOR or
274 cris_orthogonal_operator (x
, mode
)
276 enum machine_mode mode
;
278 enum rtx_code code
= GET_CODE (x
);
280 if (mode
== VOIDmode
)
283 return (GET_MODE (x
) == mode
284 && (code
== PLUS
|| code
== MINUS
285 || code
== IOR
|| code
== AND
|| code
== UMIN
));
288 /* Check if MODE is same as mode for X, and X is PLUS, IOR or AND or
292 cris_commutative_orth_op (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
&&
303 || code
== IOR
|| code
== AND
|| code
== UMIN
));
306 /* Check if MODE is same as mode for X, and X is PLUS or MINUS or UMIN. */
309 cris_operand_extend_operator (x
, mode
)
311 enum machine_mode mode
;
313 enum rtx_code code
= GET_CODE (x
);
315 if (mode
== VOIDmode
)
318 return (GET_MODE (x
) == mode
319 && (code
== PLUS
|| code
== MINUS
|| code
== UMIN
));
322 /* Check to see if MODE is same as mode for X, and X is SIGN_EXTEND or
326 cris_extend_operator (x
, mode
)
328 enum machine_mode mode
;
330 enum rtx_code code
= GET_CODE (x
);
332 if (mode
== VOIDmode
)
336 (GET_MODE (x
) == mode
&& (code
== SIGN_EXTEND
|| code
== ZERO_EXTEND
));
339 /* Check to see if MODE is same as mode for X, and X is PLUS or BOUND. */
342 cris_plus_or_bound_operator (x
, mode
)
344 enum machine_mode mode
;
346 enum rtx_code code
= GET_CODE (x
);
348 if (mode
== VOIDmode
)
352 (GET_MODE (x
) == mode
&& (code
== UMIN
|| code
== PLUS
));
355 /* Since with -fPIC, not all symbols are valid PIC symbols or indeed
356 general_operands, we have to have a predicate that matches it for the
360 cris_general_operand_or_symbol (op
, mode
)
362 enum machine_mode mode
;
364 return general_operand (op
, mode
)
365 || (CONSTANT_P (op
) && cris_symbol (op
));
368 /* Since a PIC symbol without a GOT entry is not a general_operand, we
369 have to have a predicate that matches it. We use this in the expanded
370 "movsi" anonymous pattern for PIC symbols. */
373 cris_general_operand_or_gotless_symbol (op
, mode
)
375 enum machine_mode mode
;
377 return general_operand (op
, mode
)
378 || (CONSTANT_P (op
) && cris_gotless_symbol (op
));
381 /* Since a PLT symbol is not a general_operand, we have to have a
382 predicate that matches it when we need it. We use this in the expanded
383 "call" and "call_value" anonymous patterns. */
386 cris_general_operand_or_plt_symbol (op
, mode
)
388 enum machine_mode mode
;
390 return general_operand (op
, mode
)
391 || (GET_CODE (op
) == CONST
392 && GET_CODE (XEXP (op
, 0)) == UNSPEC
393 && !TARGET_AVOID_GOTPLT
);
396 /* This matches a (MEM (general_operand)) or
397 (MEM (cris_general_operand_or_symbol)). The second one isn't a valid
398 memory_operand, so we need this predicate to recognize call
399 destinations before we change them to a PLT operand (by wrapping in
403 cris_mem_call_operand (op
, mode
)
405 enum machine_mode mode
;
409 if (GET_CODE (op
) != MEM
)
412 if (memory_operand (op
, mode
))
417 return cris_general_operand_or_symbol (xmem
, GET_MODE (op
));
420 /* The CONDITIONAL_REGISTER_USAGE worker. */
423 cris_conditional_register_usage ()
425 /* FIXME: This isn't nice. We should be able to use that register for
426 something else if the PIC table isn't needed. */
428 fixed_regs
[PIC_OFFSET_TABLE_REGNUM
]
429 = call_used_regs
[PIC_OFFSET_TABLE_REGNUM
] = 1;
432 /* Return current_function_uses_pic_offset_table. For use in cris.md,
433 since some generated files do not include function.h. */
436 cris_cfun_uses_pic_table ()
438 return current_function_uses_pic_offset_table
;
441 /* Given an rtx, return the text string corresponding to the CODE of X.
442 Intended for use in the assembly language output section of a
449 cris_output_insn_is_bound
= 0;
450 switch (GET_CODE (x
))
497 /* Used to control the sign/zero-extend character for the 'e' modifier.
499 cris_output_insn_is_bound
= 1;
504 return "Unknown operator";
509 /* Emit an error message when we're in an asm, and a fatal error for
510 "normal" insns. Formatted output isn't easily implemented, since we
511 use output_operand_lossage to output the actual message and handle the
512 categorization of the error. */
515 cris_operand_lossage (msgid
, op
)
520 output_operand_lossage ("%s", msgid
);
523 /* Print an index part of an address to file. */
526 cris_print_index (index
, file
)
530 rtx inner
= XEXP (index
, 0);
532 /* Make the index "additive" unless we'll output a negative number, in
533 which case the sign character is free (as in free beer). */
534 if (GET_CODE (index
) != CONST_INT
|| INTVAL (index
) >= 0)
538 fprintf (file
, "$%s.b", reg_names
[REGNO (index
)]);
539 else if (CONSTANT_P (index
))
540 cris_output_addr_const (file
, index
);
541 else if (GET_CODE (index
) == MULT
)
543 fprintf (file
, "$%s.",
544 reg_names
[REGNO (XEXP (index
, 0))]);
546 putc (INTVAL (XEXP (index
, 1)) == 2 ? 'w' : 'd', file
);
548 else if (GET_CODE (index
) == SIGN_EXTEND
&&
549 GET_CODE (inner
) == MEM
)
551 rtx inner_inner
= XEXP (inner
, 0);
553 if (GET_CODE (inner_inner
) == POST_INC
)
555 fprintf (file
, "[$%s+].",
556 reg_names
[REGNO (XEXP (inner_inner
, 0))]);
557 putc (GET_MODE (inner
) == HImode
? 'w' : 'b', file
);
561 fprintf (file
, "[$%s].", reg_names
[REGNO (inner_inner
)]);
563 putc (GET_MODE (inner
) == HImode
? 'w' : 'b', file
);
566 else if (GET_CODE (index
) == MEM
)
568 if (GET_CODE (inner
) == POST_INC
)
569 fprintf (file
, "[$%s+].d", reg_names
[REGNO (XEXP (inner
, 0))]);
571 fprintf (file
, "[$%s].d", reg_names
[REGNO (inner
)]);
574 cris_operand_lossage ("unexpected index-type in cris_print_index",
578 /* Print a base rtx of an address to file. */
581 cris_print_base (base
, file
)
586 fprintf (file
, "$%s", reg_names
[REGNO (base
)]);
587 else if (GET_CODE (base
) == POST_INC
)
588 fprintf (file
, "$%s+", reg_names
[REGNO (XEXP (base
, 0))]);
590 cris_operand_lossage ("unexpected base-type in cris_print_base",
594 /* Usable as a guard in expressions. */
600 internal_error (arg
);
602 /* We'll never get here; this is just to appease compilers. */
606 /* Textual function prologue. */
609 cris_target_asm_function_prologue (file
, size
)
615 /* Shorten the used name for readability. */
616 int cfoa_size
= current_function_outgoing_args_size
;
617 int last_movem_reg
= -1;
618 int doing_dwarf
= dwarf2out_do_frame ();
620 int faked_args_size
= 0;
621 int cfa_write_offset
= 0;
622 char *cfa_label
= NULL
;
623 int return_address_on_stack
624 = regs_ever_live
[CRIS_SRP_REGNUM
]
625 || cfun
->machine
->needs_return_address_on_stack
!= 0;
627 /* Don't do anything if no prologues or epilogues are wanted. */
628 if (!TARGET_PROLOGUE_EPILOGUE
)
634 /* Align the size to what's best for the CPU model. */
635 if (TARGET_STACK_ALIGN
)
636 size
= TARGET_ALIGN_BY_32
? (size
+ 3) & ~3 : (size
+ 1) & ~1;
638 if (current_function_pretend_args_size
)
640 int pretend
= current_function_pretend_args_size
;
641 for (regno
= CRIS_FIRST_ARG_REG
+ CRIS_MAX_ARGS_IN_REGS
- 1;
643 regno
--, pretend
-= 4)
645 fprintf (file
, "\tpush $%s\n", reg_names
[regno
]);
646 faked_args_size
+= 4;
650 framesize
= faked_args_size
;
654 /* FIXME: Slightly redundant calculation, as we do the same in
655 pieces below. This offset must be the total adjustment of the
656 stack-pointer. We can then def_cfa call at the end of this
657 function with the current implementation of execute_cfa_insn, but
658 that wouldn't really be clean. */
662 + (return_address_on_stack
? 4 : 0)
663 + (frame_pointer_needed
? 4 : 0);
667 if (frame_pointer_needed
)
668 cfa_reg
= FRAME_POINTER_REGNUM
;
671 cfa_reg
= STACK_POINTER_REGNUM
;
672 cfa_offset
+= cris_initial_frame_pointer_offset ();
675 cfa_label
= dwarf2out_cfi_label ();
676 dwarf2out_def_cfa (cfa_label
, cfa_reg
, cfa_offset
);
678 cfa_write_offset
= - faked_args_size
- 4;
681 /* Save SRP if not a leaf function. */
682 if (return_address_on_stack
)
684 fprintf (file
, "\tPush $srp\n");
689 dwarf2out_return_save (cfa_label
, cfa_write_offset
);
690 cfa_write_offset
-= 4;
694 /* Set up frame pointer if needed. */
695 if (frame_pointer_needed
)
697 fprintf (file
, "\tpush $%s\n\tmove.d $sp,$%s\n",
698 reg_names
[FRAME_POINTER_REGNUM
],
699 reg_names
[FRAME_POINTER_REGNUM
]);
704 dwarf2out_reg_save (cfa_label
, FRAME_POINTER_REGNUM
,
706 cfa_write_offset
-= 4;
710 /* Local vars are located above saved regs. */
711 cfa_write_offset
-= size
;
713 /* Get a contiguous sequence of registers, starting with r0, that need
715 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
717 if ((((regs_ever_live
[regno
]
718 && !call_used_regs
[regno
])
719 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
720 && (current_function_uses_pic_offset_table
721 /* It is saved anyway, if there would be a gap. */
723 && regs_ever_live
[regno
+ 1]
724 && !call_used_regs
[regno
+ 1]))))
725 && (regno
!= FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
726 && regno
!= CRIS_SRP_REGNUM
)
727 || (current_function_calls_eh_return
728 && (regno
== EH_RETURN_DATA_REGNO (0)
729 || regno
== EH_RETURN_DATA_REGNO (1)
730 || regno
== EH_RETURN_DATA_REGNO (2)
731 || regno
== EH_RETURN_DATA_REGNO (3))))
733 /* Check if movem may be used for registers so far. */
734 if (regno
== last_movem_reg
+ 1)
735 /* Yes, update next expected register. */
739 /* We cannot use movem for all registers. We have to flush
740 any movem:ed registers we got so far. */
741 if (last_movem_reg
!= -1)
743 /* It is a win to use a side-effect assignment for
744 64 <= size <= 128. But side-effect on movem was
745 not usable for CRIS v0..3. Also only do it if
746 side-effects insns are allowed. */
747 if ((last_movem_reg
+ 1) * 4 + size
>= 64
748 && (last_movem_reg
+ 1) * 4 + size
<= 128
749 && cris_cpu_version
>= CRIS_CPU_SVINTO
750 && TARGET_SIDE_EFFECT_PREFIXES
)
751 fprintf (file
, "\tmovem $%s,[$sp=$sp-%d]\n",
752 reg_names
[last_movem_reg
],
753 (last_movem_reg
+ 1) * 4 + size
);
756 /* Avoid printing multiple subsequent sub:s for sp. */
757 fprintf (file
, "\tsub%s %d,$sp\n",
758 ADDITIVE_SIZE_MODIFIER ((last_movem_reg
+ 1)
760 (last_movem_reg
+ 1) * 4 + size
);
762 fprintf (file
, "\tmovem $%s,[$sp]\n",
763 reg_names
[last_movem_reg
]);
766 framesize
+= (last_movem_reg
+ 1) * 4 + size
;
769 fprintf (file
, "; frame %d, #regs %d, bytes %d args %d\n",
772 (last_movem_reg
+ 1) * 4,
773 current_function_args_size
);
780 /* Local vars on stack, but there are no movem:s.
781 Just allocate space. */
782 fprintf (file
, "\tSub%s %d,$sp\n",
783 ADDITIVE_SIZE_MODIFIER (size
),
789 fprintf (file
, "\tPush $%s\n", reg_names
[regno
]);
795 /* Registers are stored lowest numbered at highest address,
796 which matches the loop order; we just need to update the
798 dwarf2out_reg_save (cfa_label
, regno
, cfa_write_offset
);
799 cfa_write_offset
-= 4;
804 /* Check after, if we can movem all registers. This is the normal
806 if (last_movem_reg
!= -1)
808 /* Side-effect assignment on movem was not supported for CRIS v0..3,
809 and don't do it if we're asked not to.
811 The movem is already accounted for, for unwind. */
813 if ((last_movem_reg
+ 1) * 4 + size
>= 64
814 && (last_movem_reg
+ 1) * 4 + size
<= 128
815 && cris_cpu_version
>= CRIS_CPU_SVINTO
816 && TARGET_SIDE_EFFECT_PREFIXES
)
817 fprintf (file
, "\tmovem $%s,[$sp=$sp-%d]\n",
818 reg_names
[last_movem_reg
],
819 (last_movem_reg
+1) * 4 + size
);
822 /* Avoid printing multiple subsequent sub:s for sp. FIXME:
823 Clean up the conditional expression. */
824 fprintf (file
, "\tsub%s %d,$sp\n",
825 ADDITIVE_SIZE_MODIFIER ((last_movem_reg
+ 1) * 4 + size
),
826 (last_movem_reg
+ 1) * 4 + size
);
827 /* To be compatible with v0..v3 means we do not use an assignment
828 addressing mode with movem. We normally don't need that
829 anyway. It would only be slightly more efficient for 64..128
831 fprintf (file
, "\tmovem $%s,[$sp]\n", reg_names
[last_movem_reg
]);
834 framesize
+= (last_movem_reg
+ 1) * 4 + size
;
837 fprintf (file
, "; frame %d, #regs %d, bytes %d args %d\n",
840 (last_movem_reg
+ 1) * 4,
841 current_function_args_size
);
843 /* We have to put outgoing argument space after regs. */
846 /* This does not need to be accounted for, for unwind. */
848 fprintf (file
, "\tSub%s %d,$sp\n",
849 ADDITIVE_SIZE_MODIFIER (cfoa_size
),
851 framesize
+= cfoa_size
;
854 else if ((size
+ cfoa_size
) > 0)
856 /* This does not need to be accounted for, for unwind. */
858 /* Local vars on stack, and we could not use movem. Add a sub here. */
859 fprintf (file
, "\tSub%s %d,$sp\n",
860 ADDITIVE_SIZE_MODIFIER (size
+ cfoa_size
),
862 framesize
+= size
+ cfoa_size
;
865 /* Set up the PIC register. */
866 if (current_function_uses_pic_offset_table
)
867 asm_fprintf (file
, "\tmove.d $pc,$%s\n\tsub.d .:GOTOFF,$%s\n",
868 reg_names
[PIC_OFFSET_TABLE_REGNUM
],
869 reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
873 "; parm #%d @ %d; frame %d, FP-SP is %d; leaf: %s%s; fp %s, outg: %d arg %d\n",
874 CRIS_MAX_ARGS_IN_REGS
+ 1, FIRST_PARM_OFFSET (0),
876 cris_initial_frame_pointer_offset (),
877 leaf_function_p () ? "yes" : "no",
878 return_address_on_stack
? "no" :"yes",
879 frame_pointer_needed
? "yes" : "no",
880 cfoa_size
, current_function_args_size
);
882 if (cris_max_stackframe
&& framesize
> cris_max_stackframe
)
883 warning ("stackframe too big: %d bytes", framesize
);
886 /* Return nonzero if there are regs mentioned in the insn that are not all
887 in the call_used regs. This is part of the decision whether an insn
888 can be put in the epilogue. */
891 saved_regs_mentioned (x
)
898 /* Mainly stolen from refers_to_regno_p in rtlanal.c. */
906 return !call_used_regs
[i
];
909 /* If this is a SUBREG of a hard reg, we can see exactly which
910 registers are being modified. Otherwise, handle normally. */
911 i
= REGNO (SUBREG_REG (x
));
912 return !call_used_regs
[i
];
918 fmt
= GET_RTX_FORMAT (code
);
919 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
923 if (saved_regs_mentioned (XEXP (x
, i
)))
926 else if (fmt
[i
] == 'E')
929 for (j
= XVECLEN (x
, i
) - 1; j
>=0; j
--)
930 if (saved_regs_mentioned (XEXP (x
, i
)))
938 /* Figure out if the insn may be put in the epilogue. */
941 cris_eligible_for_epilogue_delay (insn
)
944 /* First of all, it must be as slottable as for a delayed branch insn. */
945 if (get_attr_slottable (insn
) != SLOTTABLE_YES
)
948 /* It must not refer to the stack pointer (may be valid for some cases
949 that I can't think of). */
950 if (reg_mentioned_p (stack_pointer_rtx
, PATTERN (insn
)))
953 /* The frame pointer will be restored in the epilogue, before the
954 "ret", so it can't be referred to. */
955 if (frame_pointer_needed
956 && reg_mentioned_p (frame_pointer_rtx
, PATTERN (insn
)))
959 /* All saved regs are restored before the delayed insn.
960 This means that we cannot have any instructions that mention the
961 registers that are restored by the epilogue. */
962 if (saved_regs_mentioned (PATTERN (insn
)))
965 /* It seems to be ok. */
969 /* Return the number of delay-slots in the epilogue: return 1 if it
970 contains "ret", else 0. */
973 cris_delay_slots_for_epilogue ()
975 /* Check if we use a return insn, which we only do for leaf functions.
976 Else there is no slot to fill. */
977 if (regs_ever_live
[CRIS_SRP_REGNUM
]
978 || cfun
->machine
->needs_return_address_on_stack
!= 0)
981 /* By calling function_epilogue with the same parameters as from gcc
982 we can get info about if the epilogue can fill the delay-slot by itself.
983 If it is filled from the epilogue, then the corresponding string
985 This depends on that the "size" argument to function_epilogue
986 always is get_frame_size.
987 FIXME: Kludgy. At least make it a separate function that is not
988 misnamed or abuses the stream parameter. */
989 cris_target_asm_function_epilogue (NULL
, get_frame_size ());
996 /* Textual function epilogue. When file is NULL, it serves doubly as
997 a test for whether the epilogue can fill any "ret" delay-slots by
998 itself by storing the delay insn in save_last. */
1001 cris_target_asm_function_epilogue (file
, size
)
1006 int last_movem_reg
= -1;
1007 rtx insn
= get_last_insn ();
1008 int argspace_offset
= current_function_outgoing_args_size
;
1009 int pretend
= current_function_pretend_args_size
;
1010 int return_address_on_stack
1011 = regs_ever_live
[CRIS_SRP_REGNUM
]
1012 || cfun
->machine
->needs_return_address_on_stack
!= 0;
1016 if (file
&& !TARGET_PROLOGUE_EPILOGUE
)
1019 if (TARGET_PDEBUG
&& file
)
1020 fprintf (file
, ";;\n");
1022 /* Align byte count of stack frame. */
1023 if (TARGET_STACK_ALIGN
)
1024 size
= TARGET_ALIGN_BY_32
? (size
+ 3) & ~3 : (size
+ 1) & ~1;
1026 /* If the last insn was a BARRIER, we don't have to write any code,
1027 then all returns were covered by "return" insns. */
1028 if (GET_CODE (insn
) == NOTE
)
1029 insn
= prev_nonnote_insn (insn
);
1031 && (GET_CODE (insn
) == BARRIER
1032 /* We must make sure that the insn really is a "return" and
1033 not a conditional branch. Try to match the return exactly,
1034 and if it doesn't match, assume it is a conditional branch
1035 (and output an epilogue). */
1036 || (GET_CODE (insn
) == JUMP_INSN
1037 && GET_CODE (PATTERN (insn
)) == RETURN
)))
1039 if (TARGET_PDEBUG
&& file
)
1040 fprintf (file
, ";;;;;\n");
1044 /* Check how many saved regs we can movem. They start at r0 and must
1047 regno
< FIRST_PSEUDO_REGISTER
;
1049 if ((((regs_ever_live
[regno
]
1050 && !call_used_regs
[regno
])
1051 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
1052 && (current_function_uses_pic_offset_table
1053 /* It is saved anyway, if there would be a gap. */
1055 && regs_ever_live
[regno
+ 1]
1056 && !call_used_regs
[regno
+ 1]))))
1057 && (regno
!= FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
1058 && regno
!= CRIS_SRP_REGNUM
)
1059 || (current_function_calls_eh_return
1060 && (regno
== EH_RETURN_DATA_REGNO (0)
1061 || regno
== EH_RETURN_DATA_REGNO (1)
1062 || regno
== EH_RETURN_DATA_REGNO (2)
1063 || regno
== EH_RETURN_DATA_REGNO (3))))
1066 if (regno
== last_movem_reg
+ 1)
1072 for (regno
= FIRST_PSEUDO_REGISTER
- 1;
1073 regno
> last_movem_reg
;
1075 if ((((regs_ever_live
[regno
]
1076 && !call_used_regs
[regno
])
1077 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
1078 && (current_function_uses_pic_offset_table
1079 /* It is saved anyway, if there would be a gap. */
1081 && regs_ever_live
[regno
+ 1]
1082 && !call_used_regs
[regno
+ 1]))))
1083 && (regno
!= FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
1084 && regno
!= CRIS_SRP_REGNUM
)
1085 || (current_function_calls_eh_return
1086 && (regno
== EH_RETURN_DATA_REGNO (0)
1087 || regno
== EH_RETURN_DATA_REGNO (1)
1088 || regno
== EH_RETURN_DATA_REGNO (2)
1089 || regno
== EH_RETURN_DATA_REGNO (3))))
1091 if (argspace_offset
)
1093 /* There is an area for outgoing parameters located before
1094 the saved registers. We have to adjust for that. */
1096 fprintf (file
, "\tAdd%s %d,$sp\n",
1097 ADDITIVE_SIZE_MODIFIER (argspace_offset
),
1100 /* Make sure we only do this once. */
1101 argspace_offset
= 0;
1104 /* Flush previous non-movem:ed registers. */
1105 if (*save_last
&& file
)
1106 fprintf (file
, save_last
);
1107 sprintf (save_last
, "\tPop $%s\n", reg_names
[regno
]);
1110 if (last_movem_reg
!= -1)
1112 if (argspace_offset
)
1114 /* Adjust for the outgoing parameters area, if that's not
1116 if (*save_last
&& file
)
1118 fprintf (file
, save_last
);
1123 fprintf (file
, "\tAdd%s %d,$sp\n",
1124 ADDITIVE_SIZE_MODIFIER (argspace_offset
),
1126 argspace_offset
= 0;
1128 /* Flush previous non-movem:ed registers. */
1129 else if (*save_last
&& file
)
1130 fprintf (file
, save_last
);
1131 sprintf (save_last
, "\tmovem [$sp+],$%s\n", reg_names
[last_movem_reg
]);
1134 /* Restore frame pointer if necessary. */
1135 if (frame_pointer_needed
)
1137 if (*save_last
&& file
)
1138 fprintf (file
, save_last
);
1141 fprintf (file
, "\tmove.d $%s,$sp\n",
1142 reg_names
[FRAME_POINTER_REGNUM
]);
1143 sprintf (save_last
, "\tPop $%s\n",
1144 reg_names
[FRAME_POINTER_REGNUM
]);
1148 /* If there was no frame-pointer to restore sp from, we must
1149 explicitly deallocate local variables. */
1151 /* Handle space for outgoing parameters that hasn't been handled
1153 size
+= argspace_offset
;
1157 if (*save_last
&& file
)
1158 fprintf (file
, save_last
);
1160 sprintf (save_last
, "\tadd%s %d,$sp\n",
1161 ADDITIVE_SIZE_MODIFIER (size
), size
);
1164 /* If the size was not in the range for a "quick", we must flush
1169 fprintf (file
, save_last
);
1174 /* If this function has no pushed register parameters
1175 (stdargs/varargs), and if it is not a leaf function, then we can
1176 just jump-return here. */
1177 if (return_address_on_stack
&& pretend
== 0)
1179 if (*save_last
&& file
)
1180 fprintf (file
, save_last
);
1185 if (current_function_calls_eh_return
)
1187 /* The installed EH-return address is in *this* frame, so we
1188 need to pop it before we return. */
1189 fprintf (file
, "\tpop $srp\n");
1190 fprintf (file
, "\tret\n");
1191 fprintf (file
, "\tadd.d $%s,$sp\n", reg_names
[CRIS_STACKADJ_REG
]);
1194 fprintf (file
, "\tJump [$sp+]\n");
1196 /* Do a sanity check to avoid generating invalid code. */
1197 if (current_function_epilogue_delay_list
)
1198 internal_error ("allocated but unused delay list in epilogue");
1203 /* Rather than add current_function_calls_eh_return conditions
1204 everywhere in the following code (and not be able to test it
1205 thoroughly), assert the assumption that all usage of
1206 __builtin_eh_return are handled above. */
1207 if (current_function_calls_eh_return
)
1208 internal_error ("unexpected function type needing stack adjustment for\
1209 __builtin_eh_return");
1211 /* If we pushed some register parameters, then adjust the stack for
1215 /* Since srp is stored on the way, we need to restore it first. */
1216 if (return_address_on_stack
)
1218 if (*save_last
&& file
)
1219 fprintf (file
, save_last
);
1223 fprintf (file
, "\tpop $srp\n");
1226 if (*save_last
&& file
)
1227 fprintf (file
, save_last
);
1229 sprintf (save_last
, "\tadd%s %d,$sp\n",
1230 ADDITIVE_SIZE_MODIFIER (pretend
), pretend
);
1233 /* Here's where we have a delay-slot we need to fill. */
1234 if (file
&& current_function_epilogue_delay_list
)
1236 /* If gcc has allocated an insn for the epilogue delay slot, but
1237 things were arranged so we now thought we could do it
1238 ourselves, don't forget to flush that insn. */
1240 fprintf (file
, save_last
);
1242 fprintf (file
, "\tRet\n");
1244 /* Output the delay-slot-insn the mandated way. */
1245 final_scan_insn (XEXP (current_function_epilogue_delay_list
, 0),
1250 fprintf (file
, "\tRet\n");
1252 /* If the GCC did not do it, we have to use whatever insn we have,
1255 fprintf (file
, save_last
);
1257 fprintf (file
, "\tnOp\n");
1261 /* The PRINT_OPERAND worker. */
1264 cris_print_operand (file
, x
, code
)
1271 /* Size-strings corresponding to MULT expressions. */
1272 static const char *const mults
[] = { "BAD:0", ".b", ".w", "BAD:3", ".d" };
1274 /* New code entries should just be added to the switch below. If
1275 handling is finished, just return. If handling was just a
1276 modification of the operand, the modified operand should be put in
1277 "operand", and then do a break to let default handling
1278 (zero-modifier) output the operand. */
1283 /* Print the unsigned supplied integer as if it was signed
1284 and < 0, i.e print 255 or 65535 as -1, 254, 65534 as -2, etc. */
1285 if (GET_CODE (x
) != CONST_INT
1286 || ! CONST_OK_FOR_LETTER_P (INTVAL (x
), 'O'))
1287 LOSE_AND_RETURN ("invalid operand for 'b' modifier", x
);
1288 fprintf (file
, "%d", INTVAL (x
)| (INTVAL (x
) <= 255 ? ~255 : ~65535));
1292 /* Print assembler code for operator. */
1293 fprintf (file
, "%s", cris_op_str (operand
));
1297 /* Print the operand without the PIC register. */
1298 if (! flag_pic
|| ! CONSTANT_P (x
) || ! cris_gotless_symbol (x
))
1299 LOSE_AND_RETURN ("invalid operand for 'v' modifier", x
);
1300 cris_pic_sympart_only
++;
1301 cris_output_addr_const (file
, x
);
1302 cris_pic_sympart_only
--;
1306 /* Print the PIC register. Applied to a GOT-less PIC symbol for
1308 if (! flag_pic
|| ! CONSTANT_P (x
) || ! cris_gotless_symbol (x
))
1309 LOSE_AND_RETURN ("invalid operand for 'P' modifier", x
);
1310 fprintf (file
, "$%s", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
1314 /* Adjust a power of two to its log2. */
1315 if (GET_CODE (x
) != CONST_INT
|| exact_log2 (INTVAL (x
)) < 0 )
1316 LOSE_AND_RETURN ("invalid operand for 'p' modifier", x
);
1317 fprintf (file
, "%d", exact_log2 (INTVAL (x
)));
1321 /* For an integer, print 'b' or 'w' if <= 255 or <= 65535
1322 respectively. This modifier also terminates the inhibiting
1323 effects of the 'x' modifier. */
1324 cris_output_insn_is_bound
= 0;
1325 if (GET_MODE (x
) == VOIDmode
&& GET_CODE (x
) == CONST_INT
)
1327 if (INTVAL (x
) >= 0)
1329 if (INTVAL (x
) <= 255)
1331 else if (INTVAL (x
) <= 65535)
1341 /* For a non-integer, print the size of the operand. */
1342 putc ((GET_MODE (x
) == SImode
|| GET_MODE (x
) == SFmode
)
1343 ? 'd' : GET_MODE (x
) == HImode
? 'w'
1344 : GET_MODE (x
) == QImode
? 'b'
1345 /* If none of the above, emit an erroneous size letter. */
1351 /* Const_int: print b for -127 <= x <= 255,
1352 w for -32768 <= x <= 65535, else abort. */
1353 if (GET_CODE (x
) != CONST_INT
1354 || INTVAL (x
) < -32768 || INTVAL (x
) > 65535)
1355 LOSE_AND_RETURN ("invalid operand for 'z' modifier", x
);
1356 putc (INTVAL (x
) >= -128 && INTVAL (x
) <= 255 ? 'b' : 'w', file
);
1360 /* Output a 'nop' if there's nothing for the delay slot.
1361 This method stolen from the sparc files. */
1362 if (dbr_sequence_length () == 0)
1363 fputs ("\n\tnop", file
);
1367 /* Print high (most significant) part of something. */
1368 switch (GET_CODE (operand
))
1371 if (HOST_BITS_PER_WIDE_INT
== 32)
1372 /* Sign-extension from a normal int to a long long. */
1373 fprintf (file
, INTVAL (operand
) < 0 ? "-1" : "0");
1375 fprintf (file
, "0x%x", (unsigned int)(INTVAL (x
) >> 31 >> 1));
1379 /* High part of a long long constant. */
1380 if (GET_MODE (operand
) == VOIDmode
)
1382 fprintf (file
, "0x%x", CONST_DOUBLE_HIGH (x
));
1386 LOSE_AND_RETURN ("invalid operand for 'H' modifier", x
);
1389 /* Print reg + 1. Check that there's not an attempt to print
1390 high-parts of registers like stack-pointer or higher. */
1391 if (REGNO (operand
) > STACK_POINTER_REGNUM
- 2)
1392 LOSE_AND_RETURN ("bad register", operand
);
1393 fprintf (file
, "$%s", reg_names
[REGNO (operand
) + 1]);
1397 /* Adjust memory address to high part. */
1399 rtx adj_mem
= operand
;
1401 = GET_MODE_BITSIZE (GET_MODE (operand
)) / BITS_PER_UNIT
;
1403 /* Adjust so we can use two SImode in DImode.
1404 Calling adj_offsettable_operand will make sure it is an
1405 offsettable address. Don't do this for a postincrement
1406 though; it should remain as it was. */
1407 if (GET_CODE (XEXP (adj_mem
, 0)) != POST_INC
)
1409 = adjust_address (adj_mem
, GET_MODE (adj_mem
), size
/ 2);
1411 output_address (XEXP (adj_mem
, 0));
1416 LOSE_AND_RETURN ("invalid operand for 'H' modifier", x
);
1420 /* Strip the MEM expression. */
1421 operand
= XEXP (operand
, 0);
1425 /* Print 's' if operand is SIGN_EXTEND or 'u' if ZERO_EXTEND unless
1426 cris_output_insn_is_bound is nonzero. */
1427 if (GET_CODE (operand
) != SIGN_EXTEND
1428 && GET_CODE (operand
) != ZERO_EXTEND
1429 && GET_CODE (operand
) != CONST_INT
)
1430 LOSE_AND_RETURN ("invalid operand for 'e' modifier", x
);
1432 if (cris_output_insn_is_bound
)
1434 cris_output_insn_is_bound
= 0;
1438 putc (GET_CODE (operand
) == SIGN_EXTEND
1439 || (GET_CODE (operand
) == CONST_INT
&& INTVAL (operand
) < 0)
1444 /* Print the size letter of the inner element. We can do it by
1445 calling ourselves with the 's' modifier. */
1446 if (GET_CODE (operand
) != SIGN_EXTEND
&& GET_CODE (operand
) != ZERO_EXTEND
)
1447 LOSE_AND_RETURN ("invalid operand for 'm' modifier", x
);
1448 cris_print_operand (file
, XEXP (operand
, 0), 's');
1452 /* Print the least significant part of operand. */
1453 if (GET_CODE (operand
) == CONST_DOUBLE
)
1455 fprintf (file
, "0x%x", CONST_DOUBLE_LOW (x
));
1458 else if (HOST_BITS_PER_WIDE_INT
> 32 && GET_CODE (operand
) == CONST_INT
)
1460 fprintf (file
, "0x%x",
1461 INTVAL (x
) & ((unsigned int) 0x7fffffff * 2 + 1));
1464 /* Otherwise the least significant part equals the normal part,
1465 so handle it normally. */
1469 /* When emitting an add for the high part of a DImode constant, we
1470 want to use addq for 0 and adds.w for -1. */
1471 if (GET_CODE (operand
) != CONST_INT
)
1472 LOSE_AND_RETURN ("invalid operand for 'A' modifier", x
);
1473 fprintf (file
, INTVAL (operand
) < 0 ? "adds.w" : "addq");
1477 /* When emitting an sub for the high part of a DImode constant, we
1478 want to use subq for 0 and subs.w for -1. */
1479 if (GET_CODE (operand
) != CONST_INT
)
1480 LOSE_AND_RETURN ("invalid operand for 'D' modifier", x
);
1481 fprintf (file
, INTVAL (operand
) < 0 ? "subs.w" : "subq");
1485 /* Print the operand as the index-part of an address.
1486 Easiest way out is to use cris_print_index. */
1487 cris_print_index (operand
, file
);
1491 /* Print the size letter for an operand to a MULT, which must be a
1492 const_int with a suitable value. */
1493 if (GET_CODE (operand
) != CONST_INT
|| INTVAL (operand
) > 4)
1494 LOSE_AND_RETURN ("invalid operand for 'T' modifier", x
);
1495 fprintf (file
, "%s", mults
[INTVAL (operand
)]);
1499 /* No code, print as usual. */
1503 LOSE_AND_RETURN ("invalid operand modifier letter", x
);
1506 /* Print an operand as without a modifier letter. */
1507 switch (GET_CODE (operand
))
1510 if (REGNO (operand
) > 15)
1511 internal_error ("internal error: bad register: %d", REGNO (operand
));
1512 fprintf (file
, "$%s", reg_names
[REGNO (operand
)]);
1516 output_address (XEXP (operand
, 0));
1520 if (GET_MODE (operand
) == VOIDmode
)
1521 /* A long long constant. */
1522 output_addr_const (file
, operand
);
1525 /* Only single precision is allowed as plain operands the
1526 moment. FIXME: REAL_VALUE_FROM_CONST_DOUBLE isn't
1531 /* FIXME: Perhaps check overflow of the "single". */
1532 REAL_VALUE_FROM_CONST_DOUBLE (r
, operand
);
1533 REAL_VALUE_TO_TARGET_SINGLE (r
, l
);
1535 fprintf (file
, "0x%lx", l
);
1540 ASSERT_PLT_UNSPEC (operand
);
1544 cris_output_addr_const (file
, operand
);
1550 /* For a (MULT (reg X) const_int) we output "rX.S". */
1551 int i
= GET_CODE (XEXP (operand
, 1)) == CONST_INT
1552 ? INTVAL (XEXP (operand
, 1)) : INTVAL (XEXP (operand
, 0));
1553 rtx reg
= GET_CODE (XEXP (operand
, 1)) == CONST_INT
1554 ? XEXP (operand
, 0) : XEXP (operand
, 1);
1556 if (GET_CODE (reg
) != REG
1557 || (GET_CODE (XEXP (operand
, 0)) != CONST_INT
1558 && GET_CODE (XEXP (operand
, 1)) != CONST_INT
))
1559 LOSE_AND_RETURN ("unexpected multiplicative operand", x
);
1561 cris_print_base (reg
, file
);
1562 fprintf (file
, ".%c",
1563 i
== 0 || (i
== 1 && GET_CODE (operand
) == MULT
) ? 'b'
1565 : (i
== 2 && GET_CODE (operand
) == MULT
) || i
== 1 ? 'w'
1571 /* No need to handle all strange variants, let output_addr_const
1573 if (CONSTANT_P (operand
))
1575 cris_output_addr_const (file
, operand
);
1579 LOSE_AND_RETURN ("unexpected operand", x
);
1583 /* The PRINT_OPERAND_ADDRESS worker. */
1586 cris_print_operand_address (file
, x
)
1590 /* All these were inside MEM:s so output indirection characters. */
1593 if (CONSTANT_ADDRESS_P (x
))
1594 cris_output_addr_const (file
, x
);
1595 else if (BASE_OR_AUTOINCR_P (x
))
1596 cris_print_base (x
, file
);
1597 else if (GET_CODE (x
) == PLUS
)
1605 cris_print_base (x1
, file
);
1606 cris_print_index (x2
, file
);
1608 else if (BASE_P (x2
))
1610 cris_print_base (x2
, file
);
1611 cris_print_index (x1
, file
);
1614 LOSE_AND_RETURN ("unrecognized address", x
);
1616 else if (GET_CODE (x
) == MEM
)
1618 /* A DIP. Output more indirection characters. */
1620 cris_print_base (XEXP (x
, 0), file
);
1624 LOSE_AND_RETURN ("unrecognized address", x
);
1629 /* The RETURN_ADDR_RTX worker.
1630 We mark that the return address is used, either by EH or
1631 __builtin_return_address, for use by the function prologue and
1632 epilogue. FIXME: This isn't optimal; we just use the mark in the
1633 prologue and epilogue to say that the return address is to be stored
1634 in the stack frame. We could return SRP for leaf-functions and use the
1635 initial-value machinery. */
1638 cris_return_addr_rtx (count
, frameaddr
)
1640 rtx frameaddr ATTRIBUTE_UNUSED
;
1642 cfun
->machine
->needs_return_address_on_stack
= 1;
1644 /* The return-address is stored just above the saved frame-pointer (if
1645 present). Apparently we can't eliminate from the frame-pointer in
1646 that direction, so use the incoming args (maybe pretended) pointer. */
1648 ? gen_rtx_MEM (Pmode
, plus_constant (virtual_incoming_args_rtx
, -4))
1652 /* This used to be the INITIAL_FRAME_POINTER_OFFSET worker; now only
1653 handles FP -> SP elimination offset. */
1656 cris_initial_frame_pointer_offset ()
1660 /* Initial offset is 0 if we don't have a frame pointer. */
1663 /* And 4 for each register pushed. */
1664 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1665 if ((((regs_ever_live
[regno
]
1666 && !call_used_regs
[regno
])
1667 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
1668 && (current_function_uses_pic_offset_table
1669 /* It is saved anyway, if there would be a gap. */
1671 && regs_ever_live
[regno
+ 1]
1672 && !call_used_regs
[regno
+ 1]))))
1673 && (regno
!= FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
1674 && regno
!= CRIS_SRP_REGNUM
)
1675 || (current_function_calls_eh_return
1676 && (regno
== EH_RETURN_DATA_REGNO (0)
1677 || regno
== EH_RETURN_DATA_REGNO (1)
1678 || regno
== EH_RETURN_DATA_REGNO (2)
1679 || regno
== EH_RETURN_DATA_REGNO (3))))
1682 /* And then, last, we add the locals allocated. */
1683 offs
+= get_frame_size ();
1685 /* And more; the accumulated args size. */
1686 offs
+= current_function_outgoing_args_size
;
1688 /* Then round it off, in case we use aligned stack. */
1689 if (TARGET_STACK_ALIGN
)
1690 offs
= TARGET_ALIGN_BY_32
? (offs
+ 3) & ~3 : (offs
+ 1) & ~1;
1695 /* The INITIAL_ELIMINATION_OFFSET worker.
1696 Calculate the difference between imaginary registers such as frame
1697 pointer and the stack pointer. Used to eliminate the frame pointer
1698 and imaginary arg pointer. */
1701 cris_initial_elimination_offset (fromreg
, toreg
)
1706 = cris_initial_frame_pointer_offset ();
1708 /* We should be able to use regs_ever_live and related prologue
1709 information here, or alpha should not as well. */
1710 int return_address_on_stack
1711 = regs_ever_live
[CRIS_SRP_REGNUM
]
1712 || cfun
->machine
->needs_return_address_on_stack
!= 0;
1714 /* Here we act as if the frame-pointer is needed. */
1715 int ap_fp_offset
= 4 + (return_address_on_stack
? 4 : 0);
1717 if (fromreg
== ARG_POINTER_REGNUM
1718 && toreg
== FRAME_POINTER_REGNUM
)
1719 return ap_fp_offset
;
1721 /* Between the frame pointer and the stack are only "normal" stack
1722 variables and saved registers. */
1723 if (fromreg
== FRAME_POINTER_REGNUM
1724 && toreg
== STACK_POINTER_REGNUM
)
1725 return fp_sp_offset
;
1727 /* We need to balance out the frame pointer here. */
1728 if (fromreg
== ARG_POINTER_REGNUM
1729 && toreg
== STACK_POINTER_REGNUM
)
1730 return ap_fp_offset
+ fp_sp_offset
- 4;
1735 /* This function looks into the pattern to see how this insn affects
1738 Used when to eliminate test insns before a condition-code user,
1739 such as a "scc" insn or a conditional branch. This includes
1740 checking if the entities that cc was updated by, are changed by the
1743 Currently a jumble of the old peek-inside-the-insn and the newer
1744 check-cc-attribute methods. */
1747 cris_notice_update_cc (exp
, insn
)
1751 /* Check if user specified "-mcc-init" as a bug-workaround. FIXME:
1752 TARGET_CCINIT does not work; we must set CC_REVERSED as below.
1753 Several test-cases will otherwise fail, for example
1754 gcc.c-torture/execute/20000217-1.c -O0 and -O1. */
1761 /* Slowly, we're converting to using attributes to control the setting
1762 of condition-code status. */
1763 switch (get_attr_cc (insn
))
1766 /* Even if it is "none", a setting may clobber a previous
1767 cc-value, so check. */
1768 if (GET_CODE (exp
) == SET
)
1770 if (cc_status
.value1
1771 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1773 cc_status
.value1
= 0;
1775 if (cc_status
.value2
1776 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1778 cc_status
.value2
= 0;
1787 /* Which means, for:
1792 CC is (reg) and (...) - unless (...) is 0, then CC does not change.
1793 CC_NO_OVERFLOW unless (...) is reg or mem.
1802 (set (reg1) (mem (bdap/biap)))
1803 (set (reg2) (bdap/biap))):
1804 CC is (reg1) and (mem (reg2))
1807 (set (mem (bdap/biap)) (reg1)) [or 0]
1808 (set (reg2) (bdap/biap))):
1811 (where reg and mem includes strict_low_parts variants thereof)
1813 For all others, assume CC is clobbered.
1814 Note that we do not have to care about setting CC_NO_OVERFLOW,
1815 since the overflow flag is set to 0 (i.e. right) for
1816 instructions where it does not have any sane sense, but where
1817 other flags have meanings. (This includes shifts; the carry is
1820 Note that there are other parallel constructs we could match,
1821 but we don't do that yet. */
1823 if (GET_CODE (exp
) == SET
)
1825 /* FIXME: Check when this happens. It looks like we should
1826 actually do a CC_STATUS_INIT here to be safe. */
1827 if (SET_DEST (exp
) == pc_rtx
)
1830 /* Record CC0 changes, so we do not have to output multiple
1832 if (SET_DEST (exp
) == cc0_rtx
)
1834 cc_status
.value1
= SET_SRC (exp
);
1835 cc_status
.value2
= 0;
1837 /* Handle flags for the special btstq on one bit. */
1838 if (GET_CODE (SET_SRC (exp
)) == ZERO_EXTRACT
1839 && XEXP (SET_SRC (exp
), 1) == const1_rtx
)
1841 if (GET_CODE (XEXP (SET_SRC (exp
), 0)) == CONST_INT
)
1843 cc_status
.flags
= CC_INVERTED
;
1845 /* A one-bit btstq. */
1846 cc_status
.flags
= CC_Z_IN_NOT_N
;
1849 cc_status
.flags
= 0;
1851 if (GET_CODE (SET_SRC (exp
)) == COMPARE
)
1853 if (!REG_P (XEXP (SET_SRC (exp
), 0))
1854 && XEXP (SET_SRC (exp
), 1) != const0_rtx
)
1855 /* For some reason gcc will not canonicalize compare
1856 operations, reversing the sign by itself if
1857 operands are in wrong order. */
1858 /* (But NOT inverted; eq is still eq.) */
1859 cc_status
.flags
= CC_REVERSED
;
1861 /* This seems to be overlooked by gcc. FIXME: Check again.
1862 FIXME: Is it really safe? */
1864 = gen_rtx_MINUS (GET_MODE (SET_SRC (exp
)),
1865 XEXP (SET_SRC (exp
), 0),
1866 XEXP (SET_SRC (exp
), 1));
1870 else if (REG_P (SET_DEST (exp
))
1871 || (GET_CODE (SET_DEST (exp
)) == STRICT_LOW_PART
1872 && REG_P (XEXP (SET_DEST (exp
), 0))))
1874 /* A register is set; normally CC is set to show that no
1875 test insn is needed. Catch the exceptions. */
1877 /* If not to cc0, then no "set"s in non-natural mode give
1879 if (GET_MODE_SIZE (GET_MODE (SET_DEST (exp
))) > UNITS_PER_WORD
1880 || GET_MODE_CLASS (GET_MODE (SET_DEST (exp
))) == MODE_FLOAT
)
1882 /* ... except add:s and sub:s in DImode. */
1883 if (GET_MODE (SET_DEST (exp
)) == DImode
1884 && (GET_CODE (SET_SRC (exp
)) == PLUS
1885 || GET_CODE (SET_SRC (exp
)) == MINUS
))
1887 cc_status
.flags
= 0;
1888 cc_status
.value1
= SET_DEST (exp
);
1889 cc_status
.value2
= SET_SRC (exp
);
1891 if (cris_reg_overlap_mentioned_p (cc_status
.value1
,
1893 cc_status
.value2
= 0;
1895 /* Add and sub may set V, which gets us
1896 unoptimizable results in "gt" and "le" condition
1898 cc_status
.flags
|= CC_NO_OVERFLOW
;
1903 else if (SET_SRC (exp
) == const0_rtx
)
1905 /* There's no CC0 change when clearing a register or
1906 memory. Just check for overlap. */
1907 if ((cc_status
.value1
1908 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1910 cc_status
.value1
= 0;
1912 if ((cc_status
.value2
1913 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1915 cc_status
.value2
= 0;
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 /* Some operations may set V, which gets us
1930 unoptimizable results in "gt" and "le" condition
1932 if (GET_CODE (SET_SRC (exp
)) == PLUS
1933 || GET_CODE (SET_SRC (exp
)) == MINUS
1934 || GET_CODE (SET_SRC (exp
)) == NEG
)
1935 cc_status
.flags
|= CC_NO_OVERFLOW
;
1940 else if (GET_CODE (SET_DEST (exp
)) == MEM
1941 || (GET_CODE (SET_DEST (exp
)) == STRICT_LOW_PART
1942 && GET_CODE (XEXP (SET_DEST (exp
), 0)) == MEM
))
1944 /* When SET to MEM, then CC is not changed (except for
1946 if ((cc_status
.value1
1947 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1949 cc_status
.value1
= 0;
1951 if ((cc_status
.value2
1952 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1954 cc_status
.value2
= 0;
1959 else if (GET_CODE (exp
) == PARALLEL
)
1961 if (GET_CODE (XVECEXP (exp
, 0, 0)) == SET
1962 && GET_CODE (XVECEXP (exp
, 0, 1)) == SET
1963 && REG_P (XEXP (XVECEXP (exp
, 0, 1), 0)))
1965 if (REG_P (XEXP (XVECEXP (exp
, 0, 0), 0))
1966 && GET_CODE (XEXP (XVECEXP (exp
, 0, 0), 1)) == MEM
)
1968 /* For "move.S [rx=ry+o],rz", say CC reflects
1969 value1=rz and value2=[rx] */
1970 cc_status
.value1
= XEXP (XVECEXP (exp
, 0, 0), 0);
1972 = gen_rtx_MEM (GET_MODE (XEXP (XVECEXP (exp
, 0, 0), 0)),
1973 XEXP (XVECEXP (exp
, 0, 1), 0));
1974 cc_status
.flags
= 0;
1976 /* Huh? A side-effect cannot change the destination
1978 if (cris_reg_overlap_mentioned_p (cc_status
.value1
,
1980 internal_error ("internal error: sideeffect-insn affecting main effect");
1983 else if ((REG_P (XEXP (XVECEXP (exp
, 0, 0), 1))
1984 || XEXP (XVECEXP (exp
, 0, 0), 1) == const0_rtx
)
1985 && GET_CODE (XEXP (XVECEXP (exp
, 0, 0), 0)) == MEM
)
1987 /* For "move.S rz,[rx=ry+o]" and "clear.S [rx=ry+o]",
1988 say flags are not changed, except for overlap. */
1989 if (cc_status
.value1
1990 && cris_reg_overlap_mentioned_p (XEXP
1994 cc_status
.value1
= 0;
1996 if (cc_status
.value1
1997 && cris_reg_overlap_mentioned_p (XEXP
2001 cc_status
.value1
= 0;
2003 if (cc_status
.value2
2004 && cris_reg_overlap_mentioned_p (XEXP
2008 cc_status
.value2
= 0;
2010 if (cc_status
.value2
2011 && cris_reg_overlap_mentioned_p (XEXP
2015 cc_status
.value2
= 0;
2024 /* Unknown cc_attr value. */
2031 /* Return != 0 if the return sequence for the current function is short,
2032 like "ret" or "jump [sp+]". Prior to reloading, we can't tell how
2033 many registers must be saved, so return 0 then. */
2036 cris_simple_epilogue ()
2039 int reglimit
= STACK_POINTER_REGNUM
;
2042 if (! reload_completed
2043 || frame_pointer_needed
2044 || get_frame_size () != 0
2045 || current_function_pretend_args_size
2046 || current_function_args_size
2047 || current_function_outgoing_args_size
2048 || current_function_calls_eh_return
2050 /* If we're not supposed to emit prologue and epilogue, we must
2051 not emit return-type instructions. */
2052 || !TARGET_PROLOGUE_EPILOGUE
)
2055 /* We allow a "movem [sp+],rN" to sit in front if the "jump [sp+]" or
2056 in the delay-slot of the "ret". */
2057 for (regno
= 0; regno
< reglimit
; regno
++)
2058 if ((regs_ever_live
[regno
] && ! call_used_regs
[regno
])
2059 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
2060 && (current_function_uses_pic_offset_table
2061 /* It is saved anyway, if there would be a gap. */
2063 && regs_ever_live
[regno
+ 1]
2064 && !call_used_regs
[regno
+ 1]))))
2066 if (lastreg
!= regno
- 1)
2074 /* The ADDRESS_COST worker. */
2077 cris_address_cost (x
)
2080 /* The metric to use for the cost-macros is unclear.
2081 The metric used here is (the number of cycles needed) / 2,
2082 where we consider equal a cycle for a word of code and a cycle to
2085 /* The cheapest addressing modes get 0, since nothing extra is needed. */
2086 if (BASE_OR_AUTOINCR_P (x
))
2089 /* An indirect mem must be a DIP. This means two bytes extra for code,
2090 and 4 bytes extra for memory read, i.e. (2 + 4) / 2. */
2091 if (GET_CODE (x
) == MEM
)
2094 /* Assume (2 + 4) / 2 for a single constant; a dword, since it needs
2095 an extra DIP prefix and 4 bytes of constant in most cases.
2096 For PIC and a symbol with a GOT entry, we double the cost since we
2097 add a [rPIC+...] offset. A GOT-less symbol uses a BDAP prefix
2098 equivalent to the DIP prefix for non-PIC, hence the same cost. */
2100 return flag_pic
&& cris_got_symbol (x
) ? 2 * (2 + 4) / 2 : (2 + 4) / 2;
2102 /* Handle BIAP and BDAP prefixes. */
2103 if (GET_CODE (x
) == PLUS
)
2105 rtx tem1
= XEXP (x
, 0);
2106 rtx tem2
= XEXP (x
, 1);
2108 /* A BIAP is 2 extra bytes for the prefix insn, nothing more. We
2109 recognize the typical MULT which is always in tem1 because of
2110 insn canonicalization. */
2111 if ((GET_CODE (tem1
) == MULT
&& BIAP_INDEX_P (tem1
))
2115 /* A BDAP (quick) is 2 extra bytes. Any constant operand to the
2116 PLUS is always found in tem2. */
2117 if (GET_CODE (tem2
) == CONST_INT
2118 && INTVAL (tem2
) < 128 && INTVAL (tem2
) >= -128)
2121 /* A BDAP -32768 .. 32767 is like BDAP quick, but with 2 extra
2123 if (GET_CODE (tem2
) == CONST_INT
2124 && CONST_OK_FOR_LETTER_P (INTVAL (tem2
), 'L'))
2127 /* A BDAP with some other constant is 2 bytes extra. */
2128 if (CONSTANT_P (tem2
))
2129 return (2 + 2 + 2) / 2;
2131 /* BDAP with something indirect should have a higher cost than
2132 BIAP with register. FIXME: Should it cost like a MEM or more? */
2133 /* Don't need to check it, it's the only one left.
2134 FIXME: There was a REG test missing, perhaps there are others.
2136 return (2 + 2 + 2) / 2;
2139 /* What else? Return a high cost. It matters only for valid
2140 addressing modes. */
2144 /* Check various objections to the side-effect. Used in the test-part
2145 of an anonymous insn describing an insn with a possible side-effect.
2146 Returns nonzero if the implied side-effect is ok.
2149 ops : An array of rtx:es. lreg, rreg, rval,
2150 The variables multop and other_op are indexes into this,
2151 or -1 if they are not applicable.
2152 lreg : The register that gets assigned in the side-effect.
2153 rreg : One register in the side-effect expression
2154 rval : The other register, or an int.
2155 multop : An integer to multiply rval with.
2156 other_op : One of the entities of the main effect,
2157 whose mode we must consider. */
2160 cris_side_effect_mode_ok (code
, ops
, lreg
, rreg
, rval
, multop
, other_op
)
2163 int lreg
, rreg
, rval
, multop
, other_op
;
2165 /* Find what value to multiply with, for rx =ry + rz * n. */
2166 int mult
= multop
< 0 ? 1 : INTVAL (ops
[multop
]);
2168 rtx reg_rtx
= ops
[rreg
];
2169 rtx val_rtx
= ops
[rval
];
2171 /* The operands may be swapped. Canonicalize them in reg_rtx and
2172 val_rtx, where reg_rtx always is a reg (for this constraint to
2174 if (! BASE_P (reg_rtx
))
2175 reg_rtx
= val_rtx
, val_rtx
= ops
[rreg
];
2177 /* Don't forget to check that reg_rtx really is a reg. If it isn't,
2178 we have no business. */
2179 if (! BASE_P (reg_rtx
))
2182 /* Don't do this when -mno-split. */
2183 if (!TARGET_SIDE_EFFECT_PREFIXES
)
2186 /* The mult expression may be hidden in lreg. FIXME: Add more
2187 commentary about that. */
2188 if (GET_CODE (val_rtx
) == MULT
)
2190 mult
= INTVAL (XEXP (val_rtx
, 1));
2191 val_rtx
= XEXP (val_rtx
, 0);
2195 /* First check the "other operand". */
2198 if (GET_MODE_SIZE (GET_MODE (ops
[other_op
])) > UNITS_PER_WORD
)
2201 /* Check if the lvalue register is the same as the "other
2202 operand". If so, the result is undefined and we shouldn't do
2203 this. FIXME: Check again. */
2204 if ((BASE_P (ops
[lreg
])
2205 && BASE_P (ops
[other_op
])
2206 && REGNO (ops
[lreg
]) == REGNO (ops
[other_op
]))
2207 || rtx_equal_p (ops
[other_op
], ops
[lreg
]))
2211 /* Do not accept frame_pointer_rtx as any operand. */
2212 if (ops
[lreg
] == frame_pointer_rtx
|| ops
[rreg
] == frame_pointer_rtx
2213 || ops
[rval
] == frame_pointer_rtx
2214 || (other_op
>= 0 && ops
[other_op
] == frame_pointer_rtx
))
2218 && ! BASE_P (val_rtx
))
2221 /* Do not allow rx = rx + n if a normal add or sub with same size
2223 if (rtx_equal_p (ops
[lreg
], reg_rtx
)
2224 && GET_CODE (val_rtx
) == CONST_INT
2225 && (INTVAL (val_rtx
) <= 63 && INTVAL (val_rtx
) >= -63))
2228 /* Check allowed cases, like [r(+)?].[bwd] and const.
2229 A symbol is not allowed with PIC. */
2230 if (CONSTANT_P (val_rtx
))
2231 return flag_pic
== 0 || cris_symbol (val_rtx
) == 0;
2233 if (GET_CODE (val_rtx
) == MEM
2234 && BASE_OR_AUTOINCR_P (XEXP (val_rtx
, 0)))
2237 if (GET_CODE (val_rtx
) == SIGN_EXTEND
2238 && GET_CODE (XEXP (val_rtx
, 0)) == MEM
2239 && BASE_OR_AUTOINCR_P (XEXP (XEXP (val_rtx
, 0), 0)))
2242 /* If we got here, it's not a valid addressing mode. */
2245 else if (code
== MULT
2246 || (code
== PLUS
&& BASE_P (val_rtx
)))
2248 /* Do not allow rx = rx + ry.S, since it doesn't give better code. */
2249 if (rtx_equal_p (ops
[lreg
], reg_rtx
)
2250 || (mult
== 1 && rtx_equal_p (ops
[lreg
], val_rtx
)))
2253 /* Do not allow bad multiply-values. */
2254 if (mult
!= 1 && mult
!= 2 && mult
!= 4)
2257 /* Only allow r + ... */
2258 if (! BASE_P (reg_rtx
))
2261 /* If we got here, all seems ok.
2262 (All checks need to be done above). */
2266 /* If we get here, the caller got its initial tests wrong. */
2267 internal_error ("internal error: cris_side_effect_mode_ok with bad operands");
2270 /* The function reg_overlap_mentioned_p in CVS (still as of 2001-05-16)
2271 does not handle the case where the IN operand is strict_low_part; it
2272 does handle it for X. Test-case in Axis-20010516. This function takes
2273 care of that for THIS port. FIXME: strict_low_part is going away
2277 cris_reg_overlap_mentioned_p (x
, in
)
2280 /* The function reg_overlap_mentioned now handles when X is
2281 strict_low_part, but not when IN is a STRICT_LOW_PART. */
2282 if (GET_CODE (in
) == STRICT_LOW_PART
)
2285 return reg_overlap_mentioned_p (x
, in
);
2288 /* The TARGET_ASM_NAMED_SECTION worker.
2289 We just dispatch to the functions for ELF and a.out. */
2292 cris_target_asm_named_section (name
, flags
)
2297 default_no_named_section (name
, flags
);
2299 default_elf_asm_named_section (name
, flags
);
2302 /* The LEGITIMATE_PIC_OPERAND_P worker. */
2305 cris_legitimate_pic_operand (x
)
2308 /* The PIC representation of a symbol with a GOT entry will be (for
2309 example; relocations differ):
2310 sym => [rPIC+sym:GOT]
2311 and for a GOT-less symbol it will be (for example, relocation differ):
2312 sym => rPIC+sym:GOTOFF
2313 so only a symbol with a GOT is by itself a valid operand, and it
2314 can't be a sum of a symbol and an offset. */
2315 return ! cris_symbol (x
) || cris_got_symbol (x
);
2318 /* Return non-zero if there's a SYMBOL_REF or LABEL_REF hiding inside this
2325 switch (GET_CODE (x
))
2332 /* A PLT reference. */
2333 ASSERT_PLT_UNSPEC (x
);
2337 return cris_symbol (XEXP (x
, 0));
2341 return cris_symbol (XEXP (x
, 0)) || cris_symbol (XEXP (x
, 1));
2345 case CONSTANT_P_RTX
:
2349 fatal_insn ("unrecognized supposed constant", x
);
2355 /* Return non-zero if there's a SYMBOL_REF or LABEL_REF hiding inside this
2356 CONSTANT_P, and the symbol does not need a GOT entry. Also set
2357 current_function_uses_pic_offset_table if we're generating PIC and ever
2358 see something that would need one. */
2361 cris_gotless_symbol (x
)
2364 switch (GET_CODE (x
))
2367 ASSERT_PLT_UNSPEC (x
);
2371 if (flag_pic
&& cfun
!= NULL
)
2372 current_function_uses_pic_offset_table
= 1;
2373 return SYMBOL_REF_FLAG (x
);
2376 /* We don't set current_function_uses_pic_offset_table for
2377 LABEL_REF:s in here, since they are almost always originating
2378 from some branch. The only time it does not come from a label is
2379 when GCC does something like __builtin_setjmp. Then we get the
2380 LABEL_REF from the movsi expander, so we mark it there as a
2385 return cris_gotless_symbol (XEXP (x
, 0));
2390 int x0
= cris_gotless_symbol (XEXP (x
, 0)) != 0;
2391 int x1
= cris_gotless_symbol (XEXP (x
, 1)) != 0;
2393 /* One and only one of them must be a local symbol. Neither must
2394 be some other, more general kind of symbol. */
2397 && ! (x0
== 0 && cris_symbol (XEXP (x
, 0)))
2398 && ! (x1
== 0 && cris_symbol (XEXP (x
, 1)));
2403 case CONSTANT_P_RTX
:
2407 fatal_insn ("unrecognized supposed constant", x
);
2413 /* Return non-zero if there's a SYMBOL_REF or LABEL_REF hiding inside this
2414 CONSTANT_P, and the symbol needs a GOT entry. */
2420 switch (GET_CODE (x
))
2423 ASSERT_PLT_UNSPEC (x
);
2427 if (flag_pic
&& cfun
!= NULL
)
2428 current_function_uses_pic_offset_table
= 1;
2429 return ! SYMBOL_REF_FLAG (x
);
2432 return cris_got_symbol (XEXP (x
, 0));
2435 /* A LABEL_REF is never visible as a symbol outside the local
2439 /* Nope, can't access the GOT for "symbol + offset". */
2444 case CONSTANT_P_RTX
:
2448 fatal_insn ("unrecognized supposed constant in cris_global_pic_symbol",
2455 /* The OVERRIDE_OPTIONS worker.
2456 As is the norm, this also parses -mfoo=bar type parameters. */
2459 cris_override_options ()
2461 if (cris_max_stackframe_str
)
2463 cris_max_stackframe
= atoi (cris_max_stackframe_str
);
2465 /* Do some sanity checking. */
2466 if (cris_max_stackframe
< 0 || cris_max_stackframe
> 0x20000000)
2467 internal_error ("-max-stackframe=%d is not usable, not between 0 and %d",
2468 cris_max_stackframe
, 0x20000000);
2471 /* Let "-metrax4" and "-metrax100" change the cpu version. */
2472 if (TARGET_SVINTO
&& cris_cpu_version
< CRIS_CPU_SVINTO
)
2473 cris_cpu_version
= CRIS_CPU_SVINTO
;
2474 else if (TARGET_ETRAX4_ADD
&& cris_cpu_version
< CRIS_CPU_ETRAX4
)
2475 cris_cpu_version
= CRIS_CPU_ETRAX4
;
2477 /* Parse -march=... and its synonym, the deprecated -mcpu=... */
2481 = (*cris_cpu_str
== 'v' ? atoi (cris_cpu_str
+ 1) : -1);
2483 if (strcmp ("etrax4", cris_cpu_str
) == 0)
2484 cris_cpu_version
= 3;
2486 if (strcmp ("svinto", cris_cpu_str
) == 0
2487 || strcmp ("etrax100", cris_cpu_str
) == 0)
2488 cris_cpu_version
= 8;
2490 if (strcmp ("ng", cris_cpu_str
) == 0
2491 || strcmp ("etrax100lx", cris_cpu_str
) == 0)
2492 cris_cpu_version
= 10;
2494 if (cris_cpu_version
< 0 || cris_cpu_version
> 10)
2495 error ("unknown CRIS version specification in -march= or -mcpu= : %s",
2498 /* Set the target flags. */
2499 if (cris_cpu_version
>= CRIS_CPU_ETRAX4
)
2500 target_flags
|= TARGET_MASK_ETRAX4_ADD
;
2502 /* If this is Svinto or higher, align for 32 bit accesses. */
2503 if (cris_cpu_version
>= CRIS_CPU_SVINTO
)
2505 |= (TARGET_MASK_SVINTO
| TARGET_MASK_ALIGN_BY_32
2506 | TARGET_MASK_STACK_ALIGN
| TARGET_MASK_CONST_ALIGN
2507 | TARGET_MASK_DATA_ALIGN
);
2509 /* Note that we do not add new flags when it can be completely
2510 described with a macro that uses -mcpu=X. So
2511 TARGET_HAS_MUL_INSNS is (cris_cpu_version >= CRIS_CPU_NG). */
2517 = (*cris_tune_str
== 'v' ? atoi (cris_tune_str
+ 1) : -1);
2519 if (strcmp ("etrax4", cris_tune_str
) == 0)
2522 if (strcmp ("svinto", cris_tune_str
) == 0
2523 || strcmp ("etrax100", cris_tune_str
) == 0)
2526 if (strcmp ("ng", cris_tune_str
) == 0
2527 || strcmp ("etrax100lx", cris_tune_str
) == 0)
2530 if (cris_tune
< 0 || cris_tune
> 10)
2531 error ("unknown CRIS cpu version specification in -mtune= : %s",
2534 if (cris_tune
>= CRIS_CPU_SVINTO
)
2535 /* We have currently nothing more to tune than alignment for
2538 |= (TARGET_MASK_STACK_ALIGN
| TARGET_MASK_CONST_ALIGN
2539 | TARGET_MASK_DATA_ALIGN
| TARGET_MASK_ALIGN_BY_32
);
2544 /* Use error rather than warning, so invalid use is easily
2545 detectable. Still change to the values we expect, to avoid
2549 error ("-fPIC and -fpic are not supported in this configuration");
2553 /* Turn off function CSE. We need to have the addresses reach the
2554 call expanders to get PLT-marked, as they could otherwise be
2555 compared against zero directly or indirectly. After visiting the
2556 call expanders they will then be cse:ed, as the call expanders
2557 force_reg the addresses, effectively forcing flag_no_function_cse
2559 flag_no_function_cse
= 1;
2562 if ((write_symbols
== DWARF_DEBUG
2563 || write_symbols
== DWARF2_DEBUG
) && ! TARGET_ELF
)
2565 warning ("that particular -g option is invalid with -maout and -melinux");
2566 write_symbols
= DBX_DEBUG
;
2569 /* Set the per-function-data initializer. */
2570 init_machine_status
= cris_init_machine_status
;
2573 /* The ASM_OUTPUT_MI_THUNK worker. */
2576 cris_asm_output_mi_thunk (stream
, thunkdecl
, delta
, funcdecl
)
2578 tree thunkdecl ATTRIBUTE_UNUSED
;
2583 asm_fprintf (stream
, "\tadd%s %d,$%s\n",
2584 ADDITIVE_SIZE_MODIFIER (delta
), delta
,
2585 reg_names
[CRIS_FIRST_ARG_REG
]);
2587 asm_fprintf (stream
, "\tsub%s %d,$%s\n",
2588 ADDITIVE_SIZE_MODIFIER (-delta
), -delta
,
2589 reg_names
[CRIS_FIRST_ARG_REG
]);
2593 const char *name
= XSTR (XEXP (DECL_RTL (funcdecl
), 0), 0);
2595 name
= (* targetm
.strip_name_encoding
) (name
);
2596 fprintf (stream
, "add.d ");
2597 assemble_name (stream
, name
);
2598 fprintf (stream
, "%s,$pc\n", CRIS_PLT_PCOFFSET_SUFFIX
);
2602 fprintf (stream
, "jump ");
2603 assemble_name (stream
, XSTR (XEXP (DECL_RTL (funcdecl
), 0), 0));
2604 fprintf (stream
, "\n");
2608 /* The EXPAND_BUILTIN_VA_ARG worker. This is modified from the
2609 "standard" implementation of va_arg: read the value from the current
2610 address and increment by the size of one or two registers. The
2611 important difference for CRIS is that if the type is
2612 pass-by-reference, then perform an indirection. */
2615 cris_expand_builtin_va_arg (valist
, type
)
2621 tree passed_size
= size_zero_node
;
2622 tree type_size
= NULL
;
2623 tree size3
= size_int (3);
2624 tree size4
= size_int (4);
2625 tree size8
= size_int (8);
2631 if (type
== error_mark_node
2632 || (type_size
= TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type
))) == NULL
2633 || TREE_OVERFLOW (type_size
))
2634 /* Presumably an error; the size isn't computable. A message has
2635 supposedly been emitted elsewhere. */
2636 rounded_size
= size_zero_node
;
2639 = fold (build (MULT_EXPR
, sizetype
,
2640 fold (build (TRUNC_DIV_EXPR
, sizetype
,
2641 fold (build (PLUS_EXPR
, sizetype
,
2646 if (!integer_zerop (rounded_size
))
2648 /* Check if the type is passed by value or by reference. Values up
2649 to 8 bytes are passed by-value, padded to register-size (4
2650 bytes). Larger values and varying-size types are passed
2653 = (!really_constant_p (type_size
)
2655 : fold (build (COND_EXPR
, sizetype
,
2656 fold (build (GT_EXPR
, sizetype
,
2663 = (!really_constant_p (type_size
)
2664 ? build1 (INDIRECT_REF
, build_pointer_type (type
), addr_tree
)
2665 : fold (build (COND_EXPR
, TREE_TYPE (addr_tree
),
2666 fold (build (GT_EXPR
, sizetype
,
2669 build1 (INDIRECT_REF
, build_pointer_type (type
),
2674 addr
= expand_expr (addr_tree
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
2675 addr
= copy_to_reg (addr
);
2677 if (!integer_zerop (rounded_size
))
2679 /* Compute new value for AP. */
2680 t
= build (MODIFY_EXPR
, TREE_TYPE (valist
), valist
,
2681 build (PLUS_EXPR
, TREE_TYPE (valist
), valist
,
2683 TREE_SIDE_EFFECTS (t
) = 1;
2684 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2690 /* The INIT_EXPANDERS worker sets the per-function-data initializer and
2694 cris_init_expanders ()
2696 /* Nothing here at the moment. */
2699 /* Zero initialization is OK for all current fields. */
2701 static struct machine_function
*
2702 cris_init_machine_status ()
2704 return ggc_alloc_cleared (sizeof (struct machine_function
));
2707 /* Split a 2 word move (DI or presumably DF) into component parts.
2708 Originally a copy of gen_split_move_double in m32r.c. */
2711 cris_split_movdx (operands
)
2714 enum machine_mode mode
= GET_MODE (operands
[0]);
2715 rtx dest
= operands
[0];
2716 rtx src
= operands
[1];
2719 /* We used to have to handle (SUBREG (MEM)) here, but that should no
2720 longer happen; after reload there are no SUBREGs any more, and we're
2721 only called after reload. */
2722 if (GET_CODE (dest
) == SUBREG
|| GET_CODE (src
) == SUBREG
)
2726 if (GET_CODE (dest
) == REG
)
2728 int dregno
= REGNO (dest
);
2730 /* Reg-to-reg copy. */
2731 if (GET_CODE (src
) == REG
)
2733 int sregno
= REGNO (src
);
2735 int reverse
= (dregno
== sregno
+ 1);
2737 /* We normally copy the low-numbered register first. However, if
2738 the first register operand 0 is the same as the second register of
2739 operand 1, we must copy in the opposite order. */
2740 emit_insn (gen_rtx_SET (VOIDmode
,
2741 operand_subword (dest
, reverse
, TRUE
, mode
),
2742 operand_subword (src
, reverse
, TRUE
, mode
)));
2744 emit_insn (gen_rtx_SET (VOIDmode
,
2745 operand_subword (dest
, !reverse
, TRUE
, mode
),
2746 operand_subword (src
, !reverse
, TRUE
, mode
)));
2748 /* Constant-to-reg copy. */
2749 else if (GET_CODE (src
) == CONST_INT
|| GET_CODE (src
) == CONST_DOUBLE
)
2752 split_double (src
, &words
[0], &words
[1]);
2753 emit_insn (gen_rtx_SET (VOIDmode
,
2754 operand_subword (dest
, 0, TRUE
, mode
),
2757 emit_insn (gen_rtx_SET (VOIDmode
,
2758 operand_subword (dest
, 1, TRUE
, mode
),
2761 /* Mem-to-reg copy. */
2762 else if (GET_CODE (src
) == MEM
)
2764 /* If the high-address word is used in the address, we must load it
2765 last. Otherwise, load it first. */
2766 rtx addr
= XEXP (src
, 0);
2768 = (refers_to_regno_p (dregno
, dregno
+ 1, addr
, NULL
) != 0);
2770 /* The original code imples that we can't do
2771 move.x [rN+],rM move.x [rN],rM+1
2772 when rN is dead, because of REG_NOTES damage. That is
2773 consistent with what I've seen, so don't try it.
2775 We have two different cases here; if the addr is POST_INC,
2776 just pass it through, otherwise add constants. */
2778 if (GET_CODE (addr
) == POST_INC
)
2780 emit_insn (gen_rtx_SET (VOIDmode
,
2781 operand_subword (dest
, 0, TRUE
, mode
),
2782 change_address (src
, SImode
, addr
)));
2783 emit_insn (gen_rtx_SET (VOIDmode
,
2784 operand_subword (dest
, 1, TRUE
, mode
),
2785 change_address (src
, SImode
, addr
)));
2789 /* Make sure we don't get any other addresses with
2790 embedded postincrements. They should be stopped in
2791 GO_IF_LEGITIMATE_ADDRESS, but we're here for your
2793 if (side_effects_p (addr
))
2794 fatal_insn ("unexpected side-effects in address", addr
);
2796 emit_insn (gen_rtx_SET
2798 operand_subword (dest
, reverse
, TRUE
, mode
),
2801 plus_constant (addr
,
2802 reverse
* UNITS_PER_WORD
))));
2803 emit_insn (gen_rtx_SET
2805 operand_subword (dest
, ! reverse
, TRUE
, mode
),
2808 plus_constant (addr
,
2816 /* Reg-to-mem copy or clear mem. */
2817 else if (GET_CODE (dest
) == MEM
2818 && (GET_CODE (src
) == REG
2819 || src
== const0_rtx
2820 || src
== CONST0_RTX (DFmode
)))
2822 rtx addr
= XEXP (dest
, 0);
2824 if (GET_CODE (addr
) == POST_INC
)
2826 emit_insn (gen_rtx_SET (VOIDmode
,
2827 change_address (dest
, SImode
, addr
),
2828 operand_subword (src
, 0, TRUE
, mode
)));
2829 emit_insn (gen_rtx_SET (VOIDmode
,
2830 change_address (dest
, SImode
, addr
),
2831 operand_subword (src
, 1, TRUE
, mode
)));
2835 /* Make sure we don't get any other addresses with embedded
2836 postincrements. They should be stopped in
2837 GO_IF_LEGITIMATE_ADDRESS, but we're here for your safety. */
2838 if (side_effects_p (addr
))
2839 fatal_insn ("unexpected side-effects in address", addr
);
2841 emit_insn (gen_rtx_SET
2843 change_address (dest
, SImode
, addr
),
2844 operand_subword (src
, 0, TRUE
, mode
)));
2846 emit_insn (gen_rtx_SET
2848 change_address (dest
, SImode
,
2849 plus_constant (addr
,
2851 operand_subword (src
, 1, TRUE
, mode
)));
2863 /* This is in essence a copy of output_addr_const altered to output
2864 symbolic operands as PIC.
2866 FIXME: Add hooks similar to ASM_OUTPUT_SYMBOL_REF to get this effect in
2867 the "real" output_addr_const. All we need is one for LABEL_REF (and
2868 one for CODE_LABEL?). */
2871 cris_output_addr_const (file
, x
)
2878 switch (GET_CODE (x
))
2881 ASSERT_PLT_UNSPEC (x
);
2882 x
= XVECEXP (x
, 0, 0);
2889 const char *origstr
= XSTR (x
, 0);
2892 str
= (* targetm
.strip_name_encoding
) (origstr
);
2896 if (cris_pic_sympart_only
)
2898 assemble_name (file
, str
);
2899 fprintf (file
, ":PLTG");
2903 if (TARGET_AVOID_GOTPLT
)
2904 /* We shouldn't get here. */
2907 fprintf (file
, "[$%s+", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
2908 assemble_name (file
, XSTR (x
, 0));
2911 fprintf (file
, ":GOTPLT16]");
2913 fprintf (file
, ":GOTPLT]");
2916 else if (cris_gotless_symbol (x
))
2918 if (! cris_pic_sympart_only
)
2919 fprintf (file
, "$%s+", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
2920 assemble_name (file
, str
);
2921 fprintf (file
, ":GOTOFF");
2923 else if (cris_got_symbol (x
))
2925 if (cris_pic_sympart_only
)
2927 fprintf (file
, "[$%s+", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
2928 assemble_name (file
, XSTR (x
, 0));
2931 fprintf (file
, ":GOT16]");
2933 fprintf (file
, ":GOT]");
2936 LOSE_AND_RETURN ("unexpected PIC symbol", x
);
2939 if (! current_function_uses_pic_offset_table
)
2940 output_operand_lossage ("PIC register isn't set up");
2943 assemble_name (file
, XSTR (x
, 0));
2947 /* If we get one of those here, it should be dressed as PIC. Branch
2948 labels are normally output with the 'l' specifier, which means it
2949 will go directly to output_asm_label and not end up here. */
2950 if (GET_CODE (XEXP (x
, 0)) != CODE_LABEL
2951 && (GET_CODE (XEXP (x
, 0)) != NOTE
2952 || NOTE_LINE_NUMBER (XEXP (x
, 0)) != NOTE_INSN_DELETED_LABEL
))
2953 fatal_insn ("unexpected address expression", x
);
2957 if (cris_gotless_symbol (x
))
2959 if (! cris_pic_sympart_only
)
2960 fprintf (file
, "$%s+", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
2961 cris_output_addr_const (file
, XEXP (x
, 0));
2963 fprintf (file
, ":GOTOFF");
2966 /* Labels are never marked as global symbols. */
2967 fatal_insn ("unexpected PIC symbol", x
);
2970 if (! current_function_uses_pic_offset_table
)
2971 internal_error ("emitting PIC operand, but PIC register isn't set up");
2975 output_addr_const (file
, x
);
2979 if (NOTE_LINE_NUMBER (x
) != NOTE_INSN_DELETED_LABEL
)
2980 fatal_insn ("unexpected NOTE as addr_const:", x
);
2986 output_addr_const (file
, x
);
2990 /* This used to output parentheses around the expression,
2991 but that does not work on the 386 (either ATT or BSD assembler). */
2992 cris_output_addr_const (file
, XEXP (x
, 0));
2996 /* Some assemblers need integer constants to appear last (eg masm). */
2997 if (GET_CODE (XEXP (x
, 0)) == CONST_INT
)
2999 cris_output_addr_const (file
, XEXP (x
, 1));
3000 if (INTVAL (XEXP (x
, 0)) >= 0)
3001 fprintf (file
, "+");
3002 output_addr_const (file
, XEXP (x
, 0));
3006 cris_output_addr_const (file
, XEXP (x
, 0));
3007 if (GET_CODE (XEXP (x
, 1)) != CONST_INT
3008 || INTVAL (XEXP (x
, 1)) >= 0)
3009 fprintf (file
, "+");
3010 cris_output_addr_const (file
, XEXP (x
, 1));
3015 /* Avoid outputting things like x-x or x+5-x,
3016 since some assemblers can't handle that. */
3017 x
= simplify_subtraction (x
);
3018 if (GET_CODE (x
) != MINUS
)
3021 cris_output_addr_const (file
, XEXP (x
, 0));
3022 fprintf (file
, "-");
3023 if ((GET_CODE (XEXP (x
, 1)) == CONST_INT
3024 && INTVAL (XEXP (x
, 1)) < 0)
3025 || GET_CODE (XEXP (x
, 1)) != CONST_INT
)
3027 fprintf (file
, "%s", targetm
.asm_out
.open_paren
);
3028 cris_output_addr_const (file
, XEXP (x
, 1));
3029 fprintf (file
, "%s", targetm
.asm_out
.close_paren
);
3032 output_addr_const (file
, XEXP (x
, 1));
3036 LOSE_AND_RETURN ("unexpected address expression", x
);
3040 /* Code-in whether we can get away without a GOT entry (needed for
3041 externally visible objects but not for functions) into
3042 SYMBOL_REF_FLAG and add the PLT suffix for global functions. */
3045 cris_encode_section_info (exp
, first
)
3047 int first ATTRIBUTE_UNUSED
;
3051 rtx rtl
= DECL_P (exp
) ? DECL_RTL (exp
) : TREE_CST_RTL (exp
);
3053 if (GET_CODE (rtl
) == MEM
&& GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
)
3054 SYMBOL_REF_FLAG (XEXP (rtl
, 0)) = (*targetm
.binds_local_p
) (exp
);
3059 /* Various small functions to replace macros. Only called from a
3060 debugger. They might collide with gcc functions or system functions,
3061 so only emit them when '#if 1' above. */
3063 enum rtx_code Get_code
PARAMS ((rtx
));
3069 return GET_CODE (x
);
3072 const char *Get_mode
PARAMS ((rtx
));
3078 return GET_MODE_NAME (GET_MODE (x
));
3081 rtx Xexp
PARAMS ((rtx
, int));
3091 rtx Xvecexp
PARAMS ((rtx
, int, int));
3098 return XVECEXP (x
, n
, m
);
3101 int Get_rtx_len
PARAMS ((rtx
));
3107 return GET_RTX_LENGTH (GET_CODE (x
));
3110 /* Use upper-case to distinguish from local variables that are sometimes
3111 called next_insn and prev_insn. */
3113 rtx Next_insn
PARAMS ((rtx
));
3119 return NEXT_INSN (insn
);
3122 rtx Prev_insn
PARAMS ((rtx
));
3128 return PREV_INSN (insn
);
3132 #include "gt-cris.h"
3136 * eval: (c-set-style "gnu")
3137 * indent-tabs-mode: t