1 /* Definitions for GCC. Part of the machine description for CRIS.
2 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004
3 Free Software Foundation, Inc.
4 Contributed by Axis Communications. Written by Hans-Peter Nilsson.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
25 #include "coretypes.h"
29 #include "hard-reg-set.h"
31 #include "insn-config.h"
32 #include "conditions.h"
33 #include "insn-attr.h"
45 #include "target-def.h"
49 /* Usable when we have an amount to add or subtract, and want the
50 optimal size of the insn. */
51 #define ADDITIVE_SIZE_MODIFIER(size) \
52 ((size) <= 63 ? "q" : (size) <= 255 ? "u.b" : (size) <= 65535 ? "u.w" : ".d")
54 #define ASSERT_PLT_UNSPEC(x) \
57 if (XEXP (x, 1) != NULL_RTX \
58 || (GET_CODE (XVECEXP (x, 0, 0)) != SYMBOL_REF \
59 && GET_CODE (XVECEXP (x, 0, 0)) != LABEL_REF)) \
63 #define LOSE_AND_RETURN(msgid, x) \
66 cris_operand_lossage (msgid, x); \
70 /* Per-function machine data. */
71 struct machine_function
GTY(())
73 int needs_return_address_on_stack
;
76 /* This little fix suppresses the 'u' or 's' when '%e' in assembly
78 static char cris_output_insn_is_bound
= 0;
80 /* This one suppresses printing out the "rPIC+" in
81 "rPIC+sym:GOTOFF+offset" when doing PIC. For a PLT symbol, it
82 suppresses outputting it as [rPIC+sym:GOTPLT] and outputs similarly
83 just the "sym:GOTOFF" part. */
84 static int cris_pic_sympart_only
= 0;
86 /* Fix for reg_overlap_mentioned_p. */
87 static int cris_reg_overlap_mentioned_p (rtx
, rtx
);
89 static void cris_print_base (rtx
, FILE *);
91 static void cris_print_index (rtx
, FILE *);
93 static struct machine_function
* cris_init_machine_status (void);
95 static rtx
cris_struct_value_rtx (tree
, int);
97 static void cris_setup_incoming_varargs (CUMULATIVE_ARGS
*, enum machine_mode
,
98 tree type
, int *, int);
100 static int cris_initial_frame_pointer_offset (void);
102 static int saved_regs_mentioned (rtx
);
104 static void cris_target_asm_function_prologue (FILE *, HOST_WIDE_INT
);
106 static void cris_target_asm_function_epilogue (FILE *, HOST_WIDE_INT
);
108 static void cris_operand_lossage (const char *, rtx
);
110 static void cris_asm_output_mi_thunk
111 (FILE *, tree
, HOST_WIDE_INT
, HOST_WIDE_INT
, tree
);
113 static void cris_file_start (void);
114 static void cris_init_libfuncs (void);
116 static bool cris_rtx_costs (rtx
, int, int, int *);
117 static int cris_address_cost (rtx
);
119 /* The function cris_target_asm_function_epilogue puts the last insn to
120 output here. It always fits; there won't be a symbol operand. Used in
121 delay_slots_for_epilogue and function_epilogue. */
122 static char save_last
[80];
124 /* This is the argument from the "-max-stack-stackframe=" option. */
125 const char *cris_max_stackframe_str
;
127 /* This is the argument from the "-march=" option. */
128 const char *cris_cpu_str
;
130 /* This is the argument from the "-mtune=" option. */
131 const char *cris_tune_str
;
133 /* This is the argument from the "-melinux-stacksize=" option. */
134 const char *cris_elinux_stacksize_str
;
136 /* This is the parsed result of the "-max-stack-stackframe=" option. If
137 it (still) is zero, then there was no such option given. */
138 int cris_max_stackframe
= 0;
140 /* This is the parsed result of the "-march=" option, if given. */
141 int cris_cpu_version
= CRIS_DEFAULT_CPU_VERSION
;
143 #undef TARGET_ASM_ALIGNED_HI_OP
144 #define TARGET_ASM_ALIGNED_HI_OP "\t.word\t"
145 #undef TARGET_ASM_ALIGNED_SI_OP
146 #define TARGET_ASM_ALIGNED_SI_OP "\t.dword\t"
147 #undef TARGET_ASM_ALIGNED_DI_OP
148 #define TARGET_ASM_ALIGNED_DI_OP "\t.quad\t"
150 /* We need to define these, since the 2byte, 4byte, 8byte op:s are only
151 available in ELF. These "normal" pseudos do not have any alignment
152 constraints or side-effects. */
153 #undef TARGET_ASM_UNALIGNED_HI_OP
154 #define TARGET_ASM_UNALIGNED_HI_OP TARGET_ASM_ALIGNED_HI_OP
156 #undef TARGET_ASM_UNALIGNED_SI_OP
157 #define TARGET_ASM_UNALIGNED_SI_OP TARGET_ASM_ALIGNED_SI_OP
159 #undef TARGET_ASM_UNALIGNED_DI_OP
160 #define TARGET_ASM_UNALIGNED_DI_OP TARGET_ASM_ALIGNED_DI_OP
162 #undef TARGET_ASM_FUNCTION_PROLOGUE
163 #define TARGET_ASM_FUNCTION_PROLOGUE cris_target_asm_function_prologue
165 #undef TARGET_ASM_FUNCTION_EPILOGUE
166 #define TARGET_ASM_FUNCTION_EPILOGUE cris_target_asm_function_epilogue
168 #undef TARGET_ASM_OUTPUT_MI_THUNK
169 #define TARGET_ASM_OUTPUT_MI_THUNK cris_asm_output_mi_thunk
170 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
171 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK default_can_output_mi_thunk_no_vcall
173 #undef TARGET_ASM_FILE_START
174 #define TARGET_ASM_FILE_START cris_file_start
176 #undef TARGET_INIT_LIBFUNCS
177 #define TARGET_INIT_LIBFUNCS cris_init_libfuncs
179 #undef TARGET_RTX_COSTS
180 #define TARGET_RTX_COSTS cris_rtx_costs
181 #undef TARGET_ADDRESS_COST
182 #define TARGET_ADDRESS_COST cris_address_cost
184 #undef TARGET_PROMOTE_FUNCTION_ARGS
185 #define TARGET_PROMOTE_FUNCTION_ARGS hook_bool_tree_true
187 #undef TARGET_STRUCT_VALUE_RTX
188 #define TARGET_STRUCT_VALUE_RTX cris_struct_value_rtx
190 #undef TARGET_SETUP_INCOMING_VARARGS
191 #define TARGET_SETUP_INCOMING_VARARGS cris_setup_incoming_varargs
193 struct gcc_target targetm
= TARGET_INITIALIZER
;
195 /* Predicate functions. */
197 /* This checks a part of an address, the one that is not a plain register
198 for an addressing mode using BDAP.
199 Allowed operands is either:
201 b) a CONST operand (but not a symbol when generating PIC)
202 c) a [r] or [r+] in SImode, or sign-extend from HI or QI. */
205 cris_bdap_operand (rtx op
, enum machine_mode mode
)
207 register enum rtx_code code
= GET_CODE (op
);
209 if (mode
!= SImode
&& (mode
!= VOIDmode
|| GET_MODE (op
) != VOIDmode
))
212 /* Just return whether this is a simple register or constant. */
213 if (register_operand (op
, mode
)
214 || (CONSTANT_P (op
) && !(flag_pic
&& cris_symbol (op
))))
217 /* Is it a [r] or possibly a [r+]? */
220 rtx tem
= XEXP (op
, 0);
223 && (register_operand (tem
, SImode
)
224 || (GET_CODE (tem
) == POST_INC
225 && register_operand (XEXP (tem
, 0), SImode
))))
231 /* Perhaps a sign-extended mem: [r].(b|w) or [r+].(b|w)? */
232 if (code
== SIGN_EXTEND
)
234 rtx tem
= XEXP (op
, 0);
236 if (GET_CODE (tem
) != MEM
)
241 && (register_operand (tem
, SImode
)
242 || (GET_CODE (tem
) == POST_INC
243 && register_operand (XEXP (tem
, 0), SImode
))))
252 /* This is similar to cris_bdap_operand:
253 It checks a part of an address, the one that is not a plain register
254 for an addressing mode using BDAP *or* BIAP.
255 Allowed operands is either:
257 b) a CONST operand (but not a symbol when generating PIC)
258 c) a mult of (1, 2 or 4) and a register
259 d) a [r] or [r+] in SImode, or sign-extend from HI or QI. */
262 cris_bdap_biap_operand (rtx op
, enum machine_mode mode
)
264 register enum rtx_code code
= GET_CODE (op
);
268 /* Check for bdap operand. */
269 if (cris_bdap_operand (op
, mode
))
272 if (mode
!= SImode
&& (mode
!= VOIDmode
|| GET_MODE (op
) != VOIDmode
))
275 /* Check that we're looking at a BIAP operand. */
279 /* Canonicalize register and multiplicand. */
280 if (GET_CODE (XEXP (op
, 0)) == CONST_INT
)
291 /* Check that the operands are correct after canonicalization. */
292 if (! register_operand (reg
, SImode
) || GET_CODE (val
) != CONST_INT
)
295 /* Check that the multiplicand has a valid value. */
297 && (INTVAL (val
) == 1 || INTVAL (val
) == 2 || INTVAL (val
) == 4)))
303 /* Check if MODE is same as mode for X, and X is PLUS, MINUS, IOR or
307 cris_orthogonal_operator (rtx x
, enum machine_mode mode
)
309 enum rtx_code code
= GET_CODE (x
);
311 if (mode
== VOIDmode
)
314 return (GET_MODE (x
) == mode
315 && (code
== PLUS
|| code
== MINUS
316 || code
== IOR
|| code
== AND
|| code
== UMIN
));
319 /* Check if MODE is same as mode for X, and X is PLUS, IOR or AND or
323 cris_commutative_orth_op (rtx x
, enum machine_mode mode
)
325 enum rtx_code code
= GET_CODE (x
);
327 if (mode
== VOIDmode
)
330 return (GET_MODE (x
) == mode
&&
332 || code
== IOR
|| code
== AND
|| code
== UMIN
));
335 /* Check if MODE is same as mode for X, and X is PLUS or MINUS or UMIN.
336 By the name, you might think we should include MULT. We don't because
337 it doesn't accept the same addressing modes as the others (ony
338 registers) and there's also the problem of handling TARGET_MUL_BUG. */
341 cris_operand_extend_operator (rtx x
, enum machine_mode mode
)
343 enum rtx_code code
= GET_CODE (x
);
345 if (mode
== VOIDmode
)
348 return (GET_MODE (x
) == mode
349 && (code
== PLUS
|| code
== MINUS
|| code
== UMIN
));
352 /* Check if MODE is same as mode for X, and X is PLUS or MINUS. */
355 cris_additive_operand_extend_operator (rtx x
, enum machine_mode mode
)
357 enum rtx_code code
= GET_CODE (x
);
359 if (mode
== VOIDmode
)
362 return (GET_MODE (x
) == mode
363 && (code
== PLUS
|| code
== MINUS
));
366 /* Check to see if MODE is same as mode for X, and X is SIGN_EXTEND or
370 cris_extend_operator (rtx x
, enum machine_mode mode
)
372 enum rtx_code code
= GET_CODE (x
);
374 if (mode
== VOIDmode
)
378 (GET_MODE (x
) == mode
&& (code
== SIGN_EXTEND
|| code
== ZERO_EXTEND
));
381 /* Check to see if MODE is same as mode for X, and X is PLUS or BOUND. */
384 cris_plus_or_bound_operator (rtx x
, enum machine_mode mode
)
386 enum rtx_code code
= GET_CODE (x
);
388 if (mode
== VOIDmode
)
392 (GET_MODE (x
) == mode
&& (code
== UMIN
|| code
== PLUS
));
395 /* Used as an operator to get a handle on a already-known-valid MEM rtx:es
396 (no need to validate the address), where some address expression parts
397 have their own match_operand. */
400 cris_mem_op (rtx x
, enum machine_mode mode
)
402 if (mode
== VOIDmode
)
405 return GET_MODE (x
) == mode
&& GET_CODE (x
) == MEM
;
408 /* Since with -fPIC, not all symbols are valid PIC symbols or indeed
409 general_operands, we have to have a predicate that matches it for the
413 cris_general_operand_or_symbol (rtx op
, enum machine_mode mode
)
415 return general_operand (op
, mode
)
416 || (CONSTANT_P (op
) && cris_symbol (op
));
419 /* Since a PIC symbol without a GOT entry is not a general_operand, we
420 have to have a predicate that matches it. We use this in the expanded
421 "movsi" anonymous pattern for PIC symbols. */
424 cris_general_operand_or_gotless_symbol (rtx op
, enum machine_mode mode
)
426 return general_operand (op
, mode
)
427 || (CONSTANT_P (op
) && cris_gotless_symbol (op
));
430 /* Since a PLT symbol is not a general_operand, we have to have a
431 predicate that matches it when we need it. We use this in the expanded
432 "call" and "call_value" anonymous patterns. */
435 cris_general_operand_or_plt_symbol (rtx op
, enum machine_mode mode
)
437 return general_operand (op
, mode
)
438 || (GET_CODE (op
) == CONST
439 && GET_CODE (XEXP (op
, 0)) == UNSPEC
440 && !TARGET_AVOID_GOTPLT
);
443 /* This matches a (MEM (general_operand)) or
444 (MEM (cris_general_operand_or_symbol)). The second one isn't a valid
445 memory_operand, so we need this predicate to recognize call
446 destinations before we change them to a PLT operand (by wrapping in
450 cris_mem_call_operand (rtx op
, enum machine_mode mode
)
454 if (GET_CODE (op
) != MEM
)
457 if (memory_operand (op
, mode
))
462 return cris_general_operand_or_symbol (xmem
, GET_MODE (op
));
465 /* The CONDITIONAL_REGISTER_USAGE worker. */
468 cris_conditional_register_usage (void)
470 /* FIXME: This isn't nice. We should be able to use that register for
471 something else if the PIC table isn't needed. */
473 fixed_regs
[PIC_OFFSET_TABLE_REGNUM
]
474 = call_used_regs
[PIC_OFFSET_TABLE_REGNUM
] = 1;
477 /* Return current_function_uses_pic_offset_table. For use in cris.md,
478 since some generated files do not include function.h. */
481 cris_cfun_uses_pic_table (void)
483 return current_function_uses_pic_offset_table
;
486 /* Given an rtx, return the text string corresponding to the CODE of X.
487 Intended for use in the assembly language output section of a
493 cris_output_insn_is_bound
= 0;
494 switch (GET_CODE (x
))
505 /* This function is for retrieving a part of an instruction name for
506 an operator, for immediate output. If that ever happens for
507 MULT, we need to apply TARGET_MUL_BUG in the caller. Make sure
545 /* Used to control the sign/zero-extend character for the 'e' modifier.
547 cris_output_insn_is_bound
= 1;
552 return "Unknown operator";
557 /* Emit an error message when we're in an asm, and a fatal error for
558 "normal" insns. Formatted output isn't easily implemented, since we
559 use output_operand_lossage to output the actual message and handle the
560 categorization of the error. */
563 cris_operand_lossage (const char *msgid
, rtx op
)
566 output_operand_lossage ("%s", msgid
);
569 /* Print an index part of an address to file. */
572 cris_print_index (rtx index
, FILE *file
)
574 rtx inner
= XEXP (index
, 0);
576 /* Make the index "additive" unless we'll output a negative number, in
577 which case the sign character is free (as in free beer). */
578 if (GET_CODE (index
) != CONST_INT
|| INTVAL (index
) >= 0)
582 fprintf (file
, "$%s.b", reg_names
[REGNO (index
)]);
583 else if (CONSTANT_P (index
))
584 cris_output_addr_const (file
, index
);
585 else if (GET_CODE (index
) == MULT
)
587 fprintf (file
, "$%s.",
588 reg_names
[REGNO (XEXP (index
, 0))]);
590 putc (INTVAL (XEXP (index
, 1)) == 2 ? 'w' : 'd', file
);
592 else if (GET_CODE (index
) == SIGN_EXTEND
&&
593 GET_CODE (inner
) == MEM
)
595 rtx inner_inner
= XEXP (inner
, 0);
597 if (GET_CODE (inner_inner
) == POST_INC
)
599 fprintf (file
, "[$%s+].",
600 reg_names
[REGNO (XEXP (inner_inner
, 0))]);
601 putc (GET_MODE (inner
) == HImode
? 'w' : 'b', file
);
605 fprintf (file
, "[$%s].", reg_names
[REGNO (inner_inner
)]);
607 putc (GET_MODE (inner
) == HImode
? 'w' : 'b', file
);
610 else if (GET_CODE (index
) == MEM
)
612 if (GET_CODE (inner
) == POST_INC
)
613 fprintf (file
, "[$%s+].d", reg_names
[REGNO (XEXP (inner
, 0))]);
615 fprintf (file
, "[$%s].d", reg_names
[REGNO (inner
)]);
618 cris_operand_lossage ("unexpected index-type in cris_print_index",
622 /* Print a base rtx of an address to file. */
625 cris_print_base (rtx base
, FILE *file
)
628 fprintf (file
, "$%s", reg_names
[REGNO (base
)]);
629 else if (GET_CODE (base
) == POST_INC
)
630 fprintf (file
, "$%s+", reg_names
[REGNO (XEXP (base
, 0))]);
632 cris_operand_lossage ("unexpected base-type in cris_print_base",
636 /* Usable as a guard in expressions. */
639 cris_fatal (char *arg
)
641 internal_error (arg
);
643 /* We'll never get here; this is just to appease compilers. */
647 /* Textual function prologue. */
650 cris_target_asm_function_prologue (FILE *file
, HOST_WIDE_INT size
)
654 /* Shorten the used name for readability. */
655 int cfoa_size
= current_function_outgoing_args_size
;
656 int last_movem_reg
= -1;
657 int doing_dwarf
= dwarf2out_do_frame ();
659 int faked_args_size
= 0;
660 int cfa_write_offset
= 0;
661 char *cfa_label
= NULL
;
662 int return_address_on_stack
663 = regs_ever_live
[CRIS_SRP_REGNUM
]
664 || cfun
->machine
->needs_return_address_on_stack
!= 0;
666 /* Don't do anything if no prologues or epilogues are wanted. */
667 if (!TARGET_PROLOGUE_EPILOGUE
)
673 /* Align the size to what's best for the CPU model. */
674 if (TARGET_STACK_ALIGN
)
675 size
= TARGET_ALIGN_BY_32
? (size
+ 3) & ~3 : (size
+ 1) & ~1;
677 if (current_function_pretend_args_size
)
679 int pretend
= current_function_pretend_args_size
;
680 for (regno
= CRIS_FIRST_ARG_REG
+ CRIS_MAX_ARGS_IN_REGS
- 1;
682 regno
--, pretend
-= 4)
684 fprintf (file
, "\tpush $%s\n", reg_names
[regno
]);
685 faked_args_size
+= 4;
689 framesize
= faked_args_size
;
693 /* FIXME: Slightly redundant calculation, as we do the same in
694 pieces below. This offset must be the total adjustment of the
695 stack-pointer. We can then def_cfa call at the end of this
696 function with the current implementation of execute_cfa_insn, but
697 that wouldn't really be clean. */
701 + (return_address_on_stack
? 4 : 0)
702 + (frame_pointer_needed
? 4 : 0);
706 if (frame_pointer_needed
)
707 cfa_reg
= FRAME_POINTER_REGNUM
;
710 cfa_reg
= STACK_POINTER_REGNUM
;
711 cfa_offset
+= cris_initial_frame_pointer_offset ();
714 cfa_label
= dwarf2out_cfi_label ();
715 dwarf2out_def_cfa (cfa_label
, cfa_reg
, cfa_offset
);
717 cfa_write_offset
= - faked_args_size
- 4;
720 /* Save SRP if not a leaf function. */
721 if (return_address_on_stack
)
723 fprintf (file
, "\tPush $srp\n");
728 dwarf2out_return_save (cfa_label
, cfa_write_offset
);
729 cfa_write_offset
-= 4;
733 /* Set up frame pointer if needed. */
734 if (frame_pointer_needed
)
736 fprintf (file
, "\tpush $%s\n\tmove.d $sp,$%s\n",
737 reg_names
[FRAME_POINTER_REGNUM
],
738 reg_names
[FRAME_POINTER_REGNUM
]);
743 dwarf2out_reg_save (cfa_label
, FRAME_POINTER_REGNUM
,
745 cfa_write_offset
-= 4;
749 /* Local vars are located above saved regs. */
750 cfa_write_offset
-= size
;
752 /* Get a contiguous sequence of registers, starting with r0, that need
754 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
756 if ((((regs_ever_live
[regno
]
757 && !call_used_regs
[regno
])
758 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
759 && (current_function_uses_pic_offset_table
760 /* It is saved anyway, if there would be a gap. */
762 && regs_ever_live
[regno
+ 1]
763 && !call_used_regs
[regno
+ 1]))))
764 && (regno
!= FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
765 && regno
!= CRIS_SRP_REGNUM
)
766 || (current_function_calls_eh_return
767 && (regno
== EH_RETURN_DATA_REGNO (0)
768 || regno
== EH_RETURN_DATA_REGNO (1)
769 || regno
== EH_RETURN_DATA_REGNO (2)
770 || regno
== EH_RETURN_DATA_REGNO (3))))
772 /* Check if movem may be used for registers so far. */
773 if (regno
== last_movem_reg
+ 1)
774 /* Yes, update next expected register. */
778 /* We cannot use movem for all registers. We have to flush
779 any movem:ed registers we got so far. */
780 if (last_movem_reg
!= -1)
782 /* It is a win to use a side-effect assignment for
783 64 <= size <= 128. But side-effect on movem was
784 not usable for CRIS v0..3. Also only do it if
785 side-effects insns are allowed. */
786 if ((last_movem_reg
+ 1) * 4 + size
>= 64
787 && (last_movem_reg
+ 1) * 4 + size
<= 128
788 && cris_cpu_version
>= CRIS_CPU_SVINTO
789 && TARGET_SIDE_EFFECT_PREFIXES
)
790 fprintf (file
, "\tmovem $%s,[$sp=$sp-"HOST_WIDE_INT_PRINT_DEC
"]\n",
791 reg_names
[last_movem_reg
],
792 (last_movem_reg
+ 1) * 4 + size
);
795 /* Avoid printing multiple subsequent sub:s for sp. */
796 fprintf (file
, "\tsub%s "HOST_WIDE_INT_PRINT_DEC
",$sp\n",
797 ADDITIVE_SIZE_MODIFIER ((last_movem_reg
+ 1)
799 (last_movem_reg
+ 1) * 4 + size
);
801 fprintf (file
, "\tmovem $%s,[$sp]\n",
802 reg_names
[last_movem_reg
]);
805 framesize
+= (last_movem_reg
+ 1) * 4 + size
;
808 fprintf (file
, "; frame "HOST_WIDE_INT_PRINT_DEC
809 ", #regs %d, bytes %d args %d\n",
812 (last_movem_reg
+ 1) * 4,
813 current_function_args_size
);
820 /* Local vars on stack, but there are no movem:s.
821 Just allocate space. */
822 fprintf (file
, "\tSub%s "HOST_WIDE_INT_PRINT_DEC
",$sp\n",
823 ADDITIVE_SIZE_MODIFIER (size
),
829 fprintf (file
, "\tPush $%s\n", reg_names
[regno
]);
835 /* Registers are stored lowest numbered at highest address,
836 which matches the loop order; we just need to update the
838 dwarf2out_reg_save (cfa_label
, regno
, cfa_write_offset
);
839 cfa_write_offset
-= 4;
844 /* Check after, if we can movem all registers. This is the normal
846 if (last_movem_reg
!= -1)
848 /* Side-effect assignment on movem was not supported for CRIS v0..3,
849 and don't do it if we're asked not to.
851 The movem is already accounted for, for unwind. */
853 if ((last_movem_reg
+ 1) * 4 + size
>= 64
854 && (last_movem_reg
+ 1) * 4 + size
<= 128
855 && cris_cpu_version
>= CRIS_CPU_SVINTO
856 && TARGET_SIDE_EFFECT_PREFIXES
)
857 fprintf (file
, "\tmovem $%s,[$sp=$sp-"HOST_WIDE_INT_PRINT_DEC
"]\n",
858 reg_names
[last_movem_reg
],
859 (last_movem_reg
+1) * 4 + size
);
862 /* Avoid printing multiple subsequent sub:s for sp. FIXME:
863 Clean up the conditional expression. */
864 fprintf (file
, "\tsub%s "HOST_WIDE_INT_PRINT_DEC
",$sp\n",
865 ADDITIVE_SIZE_MODIFIER ((last_movem_reg
+ 1) * 4 + size
),
866 (last_movem_reg
+ 1) * 4 + size
);
867 /* To be compatible with v0..v3 means we do not use an assignment
868 addressing mode with movem. We normally don't need that
869 anyway. It would only be slightly more efficient for 64..128
871 fprintf (file
, "\tmovem $%s,[$sp]\n", reg_names
[last_movem_reg
]);
874 framesize
+= (last_movem_reg
+ 1) * 4 + size
;
877 fprintf (file
, "; frame "HOST_WIDE_INT_PRINT_DEC
878 ", #regs %d, bytes %d args %d\n",
881 (last_movem_reg
+ 1) * 4,
882 current_function_args_size
);
884 /* We have to put outgoing argument space after regs. */
887 /* This does not need to be accounted for, for unwind. */
889 fprintf (file
, "\tSub%s %d,$sp\n",
890 ADDITIVE_SIZE_MODIFIER (cfoa_size
),
892 framesize
+= cfoa_size
;
895 else if ((size
+ cfoa_size
) > 0)
897 /* This does not need to be accounted for, for unwind. */
899 /* Local vars on stack, and we could not use movem. Add a sub here. */
900 fprintf (file
, "\tSub%s "HOST_WIDE_INT_PRINT_DEC
",$sp\n",
901 ADDITIVE_SIZE_MODIFIER (size
+ cfoa_size
),
903 framesize
+= size
+ cfoa_size
;
906 /* Set up the PIC register. */
907 if (current_function_uses_pic_offset_table
)
908 fprintf (file
, "\tmove.d $pc,$%s\n\tsub.d .:GOTOFF,$%s\n",
909 reg_names
[PIC_OFFSET_TABLE_REGNUM
],
910 reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
914 "; parm #%d @ %d; frame " HOST_WIDE_INT_PRINT_DEC
915 ", FP-SP is %d; leaf: %s%s; fp %s, outg: %d arg %d\n",
916 CRIS_MAX_ARGS_IN_REGS
+ 1, FIRST_PARM_OFFSET (0),
918 cris_initial_frame_pointer_offset (),
919 leaf_function_p () ? "yes" : "no",
920 return_address_on_stack
? "no" :"yes",
921 frame_pointer_needed
? "yes" : "no",
922 cfoa_size
, current_function_args_size
);
924 if (cris_max_stackframe
&& framesize
> cris_max_stackframe
)
925 warning ("stackframe too big: %d bytes", framesize
);
928 /* Return nonzero if there are regs mentioned in the insn that are not all
929 in the call_used regs. This is part of the decision whether an insn
930 can be put in the epilogue. */
933 saved_regs_mentioned (rtx x
)
939 /* Mainly stolen from refers_to_regno_p in rtlanal.c. */
947 return !call_used_regs
[i
];
950 /* If this is a SUBREG of a hard reg, we can see exactly which
951 registers are being modified. Otherwise, handle normally. */
952 i
= REGNO (SUBREG_REG (x
));
953 return !call_used_regs
[i
];
959 fmt
= GET_RTX_FORMAT (code
);
960 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
964 if (saved_regs_mentioned (XEXP (x
, i
)))
967 else if (fmt
[i
] == 'E')
970 for (j
= XVECLEN (x
, i
) - 1; j
>=0; j
--)
971 if (saved_regs_mentioned (XEXP (x
, i
)))
979 /* Figure out if the insn may be put in the epilogue. */
982 cris_eligible_for_epilogue_delay (rtx insn
)
984 /* First of all, it must be as slottable as for a delayed branch insn. */
985 if (get_attr_slottable (insn
) != SLOTTABLE_YES
)
988 /* It must not refer to the stack pointer (may be valid for some cases
989 that I can't think of). */
990 if (reg_mentioned_p (stack_pointer_rtx
, PATTERN (insn
)))
993 /* The frame pointer will be restored in the epilogue, before the
994 "ret", so it can't be referred to. */
995 if (frame_pointer_needed
996 && reg_mentioned_p (frame_pointer_rtx
, PATTERN (insn
)))
999 /* All saved regs are restored before the delayed insn.
1000 This means that we cannot have any instructions that mention the
1001 registers that are restored by the epilogue. */
1002 if (saved_regs_mentioned (PATTERN (insn
)))
1005 /* It seems to be ok. */
1009 /* Return the number of delay-slots in the epilogue: return 1 if it
1010 contains "ret", else 0. */
1013 cris_delay_slots_for_epilogue (void)
1015 /* Check if we use a return insn, which we only do for leaf functions.
1016 Else there is no slot to fill. */
1017 if (regs_ever_live
[CRIS_SRP_REGNUM
]
1018 || cfun
->machine
->needs_return_address_on_stack
!= 0)
1021 /* By calling function_epilogue with the same parameters as from gcc
1022 we can get info about if the epilogue can fill the delay-slot by itself.
1023 If it is filled from the epilogue, then the corresponding string
1025 This depends on that the "size" argument to function_epilogue
1026 always is get_frame_size.
1027 FIXME: Kludgy. At least make it a separate function that is not
1028 misnamed or abuses the stream parameter. */
1029 cris_target_asm_function_epilogue (NULL
, get_frame_size ());
1036 /* Textual function epilogue. When file is NULL, it serves doubly as
1037 a test for whether the epilogue can fill any "ret" delay-slots by
1038 itself by storing the delay insn in save_last. */
1041 cris_target_asm_function_epilogue (FILE *file
, HOST_WIDE_INT size
)
1044 int last_movem_reg
= -1;
1045 rtx insn
= get_last_insn ();
1046 int argspace_offset
= current_function_outgoing_args_size
;
1047 int pretend
= current_function_pretend_args_size
;
1048 int return_address_on_stack
1049 = regs_ever_live
[CRIS_SRP_REGNUM
]
1050 || cfun
->machine
->needs_return_address_on_stack
!= 0;
1054 if (file
&& !TARGET_PROLOGUE_EPILOGUE
)
1057 if (TARGET_PDEBUG
&& file
)
1058 fprintf (file
, ";;\n");
1060 /* Align byte count of stack frame. */
1061 if (TARGET_STACK_ALIGN
)
1062 size
= TARGET_ALIGN_BY_32
? (size
+ 3) & ~3 : (size
+ 1) & ~1;
1064 /* If the last insn was a BARRIER, we don't have to write any code,
1065 then all returns were covered by "return" insns. */
1066 if (GET_CODE (insn
) == NOTE
)
1067 insn
= prev_nonnote_insn (insn
);
1069 && (GET_CODE (insn
) == BARRIER
1070 /* We must make sure that the insn really is a "return" and
1071 not a conditional branch. Try to match the return exactly,
1072 and if it doesn't match, assume it is a conditional branch
1073 (and output an epilogue). */
1074 || (GET_CODE (insn
) == JUMP_INSN
1075 && GET_CODE (PATTERN (insn
)) == RETURN
)))
1077 if (TARGET_PDEBUG
&& file
)
1078 fprintf (file
, ";;;;;\n");
1082 /* Check how many saved regs we can movem. They start at r0 and must
1085 regno
< FIRST_PSEUDO_REGISTER
;
1087 if ((((regs_ever_live
[regno
]
1088 && !call_used_regs
[regno
])
1089 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
1090 && (current_function_uses_pic_offset_table
1091 /* It is saved anyway, if there would be a gap. */
1093 && regs_ever_live
[regno
+ 1]
1094 && !call_used_regs
[regno
+ 1]))))
1095 && (regno
!= FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
1096 && regno
!= CRIS_SRP_REGNUM
)
1097 || (current_function_calls_eh_return
1098 && (regno
== EH_RETURN_DATA_REGNO (0)
1099 || regno
== EH_RETURN_DATA_REGNO (1)
1100 || regno
== EH_RETURN_DATA_REGNO (2)
1101 || regno
== EH_RETURN_DATA_REGNO (3))))
1104 if (regno
== last_movem_reg
+ 1)
1110 for (regno
= FIRST_PSEUDO_REGISTER
- 1;
1111 regno
> last_movem_reg
;
1113 if ((((regs_ever_live
[regno
]
1114 && !call_used_regs
[regno
])
1115 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
1116 && (current_function_uses_pic_offset_table
1117 /* It is saved anyway, if there would be a gap. */
1119 && regs_ever_live
[regno
+ 1]
1120 && !call_used_regs
[regno
+ 1]))))
1121 && (regno
!= FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
1122 && regno
!= CRIS_SRP_REGNUM
)
1123 || (current_function_calls_eh_return
1124 && (regno
== EH_RETURN_DATA_REGNO (0)
1125 || regno
== EH_RETURN_DATA_REGNO (1)
1126 || regno
== EH_RETURN_DATA_REGNO (2)
1127 || regno
== EH_RETURN_DATA_REGNO (3))))
1129 if (argspace_offset
)
1131 /* There is an area for outgoing parameters located before
1132 the saved registers. We have to adjust for that. */
1134 fprintf (file
, "\tAdd%s %d,$sp\n",
1135 ADDITIVE_SIZE_MODIFIER (argspace_offset
),
1138 /* Make sure we only do this once. */
1139 argspace_offset
= 0;
1142 /* Flush previous non-movem:ed registers. */
1143 if (*save_last
&& file
)
1144 fprintf (file
, save_last
);
1145 sprintf (save_last
, "\tPop $%s\n", reg_names
[regno
]);
1148 if (last_movem_reg
!= -1)
1150 if (argspace_offset
)
1152 /* Adjust for the outgoing parameters area, if that's not
1154 if (*save_last
&& file
)
1156 fprintf (file
, save_last
);
1161 fprintf (file
, "\tAdd%s %d,$sp\n",
1162 ADDITIVE_SIZE_MODIFIER (argspace_offset
),
1164 argspace_offset
= 0;
1166 /* Flush previous non-movem:ed registers. */
1167 else if (*save_last
&& file
)
1168 fprintf (file
, save_last
);
1169 sprintf (save_last
, "\tmovem [$sp+],$%s\n", reg_names
[last_movem_reg
]);
1172 /* Restore frame pointer if necessary. */
1173 if (frame_pointer_needed
)
1175 if (*save_last
&& file
)
1176 fprintf (file
, save_last
);
1179 fprintf (file
, "\tmove.d $%s,$sp\n",
1180 reg_names
[FRAME_POINTER_REGNUM
]);
1181 sprintf (save_last
, "\tPop $%s\n",
1182 reg_names
[FRAME_POINTER_REGNUM
]);
1186 /* If there was no frame-pointer to restore sp from, we must
1187 explicitly deallocate local variables. */
1189 /* Handle space for outgoing parameters that hasn't been handled
1191 size
+= argspace_offset
;
1195 if (*save_last
&& file
)
1196 fprintf (file
, save_last
);
1198 sprintf (save_last
, "\tadd%s "HOST_WIDE_INT_PRINT_DEC
",$sp\n",
1199 ADDITIVE_SIZE_MODIFIER (size
), size
);
1202 /* If the size was not in the range for a "quick", we must flush
1207 fprintf (file
, save_last
);
1212 /* If this function has no pushed register parameters
1213 (stdargs/varargs), and if it is not a leaf function, then we can
1214 just jump-return here. */
1215 if (return_address_on_stack
&& pretend
== 0)
1217 if (*save_last
&& file
)
1218 fprintf (file
, save_last
);
1223 if (current_function_calls_eh_return
)
1225 /* The installed EH-return address is in *this* frame, so we
1226 need to pop it before we return. */
1227 fprintf (file
, "\tpop $srp\n");
1228 fprintf (file
, "\tret\n");
1229 fprintf (file
, "\tadd.d $%s,$sp\n", reg_names
[CRIS_STACKADJ_REG
]);
1232 fprintf (file
, "\tJump [$sp+]\n");
1234 /* Do a sanity check to avoid generating invalid code. */
1235 if (current_function_epilogue_delay_list
)
1236 internal_error ("allocated but unused delay list in epilogue");
1241 /* Rather than add current_function_calls_eh_return conditions
1242 everywhere in the following code (and not be able to test it
1243 thoroughly), assert the assumption that all usage of
1244 __builtin_eh_return are handled above. */
1245 if (current_function_calls_eh_return
)
1246 internal_error ("unexpected function type needing stack adjustment for\
1247 __builtin_eh_return");
1249 /* If we pushed some register parameters, then adjust the stack for
1253 /* Since srp is stored on the way, we need to restore it first. */
1254 if (return_address_on_stack
)
1256 if (*save_last
&& file
)
1257 fprintf (file
, save_last
);
1261 fprintf (file
, "\tpop $srp\n");
1264 if (*save_last
&& file
)
1265 fprintf (file
, save_last
);
1267 sprintf (save_last
, "\tadd%s %d,$sp\n",
1268 ADDITIVE_SIZE_MODIFIER (pretend
), pretend
);
1271 /* Here's where we have a delay-slot we need to fill. */
1272 if (file
&& current_function_epilogue_delay_list
)
1274 /* If gcc has allocated an insn for the epilogue delay slot, but
1275 things were arranged so we now thought we could do it
1276 ourselves, don't forget to flush that insn. */
1278 fprintf (file
, save_last
);
1280 fprintf (file
, "\tRet\n");
1282 /* Output the delay-slot-insn the mandated way. */
1283 final_scan_insn (XEXP (current_function_epilogue_delay_list
, 0),
1284 file
, 1, -2, 1, NULL
);
1288 fprintf (file
, "\tRet\n");
1290 /* If the GCC did not do it, we have to use whatever insn we have,
1293 fprintf (file
, save_last
);
1295 fprintf (file
, "\tnOp\n");
1299 /* The PRINT_OPERAND worker. */
1302 cris_print_operand (FILE *file
, rtx x
, int code
)
1306 /* Size-strings corresponding to MULT expressions. */
1307 static const char *const mults
[] = { "BAD:0", ".b", ".w", "BAD:3", ".d" };
1309 /* New code entries should just be added to the switch below. If
1310 handling is finished, just return. If handling was just a
1311 modification of the operand, the modified operand should be put in
1312 "operand", and then do a break to let default handling
1313 (zero-modifier) output the operand. */
1318 /* Print the unsigned supplied integer as if it were signed
1319 and < 0, i.e print 255 or 65535 as -1, 254, 65534 as -2, etc. */
1320 if (GET_CODE (x
) != CONST_INT
1321 || ! CONST_OK_FOR_LETTER_P (INTVAL (x
), 'O'))
1322 LOSE_AND_RETURN ("invalid operand for 'b' modifier", x
);
1323 fprintf (file
, HOST_WIDE_INT_PRINT_DEC
,
1324 INTVAL (x
)| (INTVAL (x
) <= 255 ? ~255 : ~65535));
1328 /* Print assembler code for operator. */
1329 fprintf (file
, "%s", cris_op_str (operand
));
1333 /* Print the operand without the PIC register. */
1334 if (! flag_pic
|| ! CONSTANT_P (x
) || ! cris_gotless_symbol (x
))
1335 LOSE_AND_RETURN ("invalid operand for 'v' modifier", x
);
1336 cris_pic_sympart_only
++;
1337 cris_output_addr_const (file
, x
);
1338 cris_pic_sympart_only
--;
1342 /* Print the PIC register. Applied to a GOT-less PIC symbol for
1344 if (! flag_pic
|| ! CONSTANT_P (x
) || ! cris_gotless_symbol (x
))
1345 LOSE_AND_RETURN ("invalid operand for 'P' modifier", x
);
1346 fprintf (file
, "$%s", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
1350 /* Adjust a power of two to its log2. */
1351 if (GET_CODE (x
) != CONST_INT
|| exact_log2 (INTVAL (x
)) < 0 )
1352 LOSE_AND_RETURN ("invalid operand for 'p' modifier", x
);
1353 fprintf (file
, "%d", exact_log2 (INTVAL (x
)));
1357 /* For an integer, print 'b' or 'w' if <= 255 or <= 65535
1358 respectively. This modifier also terminates the inhibiting
1359 effects of the 'x' modifier. */
1360 cris_output_insn_is_bound
= 0;
1361 if (GET_MODE (x
) == VOIDmode
&& GET_CODE (x
) == CONST_INT
)
1363 if (INTVAL (x
) >= 0)
1365 if (INTVAL (x
) <= 255)
1367 else if (INTVAL (x
) <= 65535)
1377 /* For a non-integer, print the size of the operand. */
1378 putc ((GET_MODE (x
) == SImode
|| GET_MODE (x
) == SFmode
)
1379 ? 'd' : GET_MODE (x
) == HImode
? 'w'
1380 : GET_MODE (x
) == QImode
? 'b'
1381 /* If none of the above, emit an erroneous size letter. */
1387 /* Const_int: print b for -127 <= x <= 255,
1388 w for -32768 <= x <= 65535, else abort. */
1389 if (GET_CODE (x
) != CONST_INT
1390 || INTVAL (x
) < -32768 || INTVAL (x
) > 65535)
1391 LOSE_AND_RETURN ("invalid operand for 'z' modifier", x
);
1392 putc (INTVAL (x
) >= -128 && INTVAL (x
) <= 255 ? 'b' : 'w', file
);
1396 /* Output a 'nop' if there's nothing for the delay slot.
1397 This method stolen from the sparc files. */
1398 if (dbr_sequence_length () == 0)
1399 fputs ("\n\tnop", file
);
1403 /* Output directive for alignment padded with "nop" insns.
1404 Optimizing for size, it's plain 4-byte alignment, otherwise we
1405 align the section to a cache-line (32 bytes) and skip at max 2
1406 bytes, i.e. we skip if it's the last insn on a cache-line. The
1407 latter is faster by a small amount (for two test-programs 99.6%
1408 and 99.9%) and larger by a small amount (ditto 100.1% and
1409 100.2%). This is supposed to be the simplest yet performance-
1410 wise least intrusive way to make sure the immediately following
1411 (supposed) muls/mulu insn isn't located at the end of a
1414 fputs (optimize_size
1415 ? ".p2alignw 2,0x050f\n\t"
1416 : ".p2alignw 5,0x050f,2\n\t", file
);
1420 /* Print high (most significant) part of something. */
1421 switch (GET_CODE (operand
))
1424 if (HOST_BITS_PER_WIDE_INT
== 32)
1425 /* Sign-extension from a normal int to a long long. */
1426 fprintf (file
, INTVAL (operand
) < 0 ? "-1" : "0");
1428 fprintf (file
, "0x%x", (unsigned int)(INTVAL (x
) >> 31 >> 1));
1432 /* High part of a long long constant. */
1433 if (GET_MODE (operand
) == VOIDmode
)
1435 fprintf (file
, HOST_WIDE_INT_PRINT_HEX
, CONST_DOUBLE_HIGH (x
));
1439 LOSE_AND_RETURN ("invalid operand for 'H' modifier", x
);
1442 /* Print reg + 1. Check that there's not an attempt to print
1443 high-parts of registers like stack-pointer or higher. */
1444 if (REGNO (operand
) > STACK_POINTER_REGNUM
- 2)
1445 LOSE_AND_RETURN ("bad register", operand
);
1446 fprintf (file
, "$%s", reg_names
[REGNO (operand
) + 1]);
1450 /* Adjust memory address to high part. */
1452 rtx adj_mem
= operand
;
1454 = GET_MODE_BITSIZE (GET_MODE (operand
)) / BITS_PER_UNIT
;
1456 /* Adjust so we can use two SImode in DImode.
1457 Calling adj_offsettable_operand will make sure it is an
1458 offsettable address. Don't do this for a postincrement
1459 though; it should remain as it was. */
1460 if (GET_CODE (XEXP (adj_mem
, 0)) != POST_INC
)
1462 = adjust_address (adj_mem
, GET_MODE (adj_mem
), size
/ 2);
1464 output_address (XEXP (adj_mem
, 0));
1469 LOSE_AND_RETURN ("invalid operand for 'H' modifier", x
);
1473 /* Strip the MEM expression. */
1474 operand
= XEXP (operand
, 0);
1478 /* Print 's' if operand is SIGN_EXTEND or 'u' if ZERO_EXTEND unless
1479 cris_output_insn_is_bound is nonzero. */
1480 if (GET_CODE (operand
) != SIGN_EXTEND
1481 && GET_CODE (operand
) != ZERO_EXTEND
1482 && GET_CODE (operand
) != CONST_INT
)
1483 LOSE_AND_RETURN ("invalid operand for 'e' modifier", x
);
1485 if (cris_output_insn_is_bound
)
1487 cris_output_insn_is_bound
= 0;
1491 putc (GET_CODE (operand
) == SIGN_EXTEND
1492 || (GET_CODE (operand
) == CONST_INT
&& INTVAL (operand
) < 0)
1497 /* Print the size letter of the inner element. We can do it by
1498 calling ourselves with the 's' modifier. */
1499 if (GET_CODE (operand
) != SIGN_EXTEND
&& GET_CODE (operand
) != ZERO_EXTEND
)
1500 LOSE_AND_RETURN ("invalid operand for 'm' modifier", x
);
1501 cris_print_operand (file
, XEXP (operand
, 0), 's');
1505 /* Print the least significant part of operand. */
1506 if (GET_CODE (operand
) == CONST_DOUBLE
)
1508 fprintf (file
, HOST_WIDE_INT_PRINT_HEX
, CONST_DOUBLE_LOW (x
));
1511 else if (HOST_BITS_PER_WIDE_INT
> 32 && GET_CODE (operand
) == CONST_INT
)
1513 fprintf (file
, HOST_WIDE_INT_PRINT_HEX
,
1514 INTVAL (x
) & ((unsigned int) 0x7fffffff * 2 + 1));
1517 /* Otherwise the least significant part equals the normal part,
1518 so handle it normally. */
1522 /* When emitting an add for the high part of a DImode constant, we
1523 want to use addq for 0 and adds.w for -1. */
1524 if (GET_CODE (operand
) != CONST_INT
)
1525 LOSE_AND_RETURN ("invalid operand for 'A' modifier", x
);
1526 fprintf (file
, INTVAL (operand
) < 0 ? "adds.w" : "addq");
1530 /* When emitting an sub for the high part of a DImode constant, we
1531 want to use subq for 0 and subs.w for -1. */
1532 if (GET_CODE (operand
) != CONST_INT
)
1533 LOSE_AND_RETURN ("invalid operand for 'D' modifier", x
);
1534 fprintf (file
, INTVAL (operand
) < 0 ? "subs.w" : "subq");
1538 /* Print the operand as the index-part of an address.
1539 Easiest way out is to use cris_print_index. */
1540 cris_print_index (operand
, file
);
1544 /* Print the size letter for an operand to a MULT, which must be a
1545 const_int with a suitable value. */
1546 if (GET_CODE (operand
) != CONST_INT
|| INTVAL (operand
) > 4)
1547 LOSE_AND_RETURN ("invalid operand for 'T' modifier", x
);
1548 fprintf (file
, "%s", mults
[INTVAL (operand
)]);
1552 /* No code, print as usual. */
1556 LOSE_AND_RETURN ("invalid operand modifier letter", x
);
1559 /* Print an operand as without a modifier letter. */
1560 switch (GET_CODE (operand
))
1563 if (REGNO (operand
) > 15)
1564 internal_error ("internal error: bad register: %d", REGNO (operand
));
1565 fprintf (file
, "$%s", reg_names
[REGNO (operand
)]);
1569 output_address (XEXP (operand
, 0));
1573 if (GET_MODE (operand
) == VOIDmode
)
1574 /* A long long constant. */
1575 output_addr_const (file
, operand
);
1578 /* Only single precision is allowed as plain operands the
1579 moment. FIXME: REAL_VALUE_FROM_CONST_DOUBLE isn't
1584 /* FIXME: Perhaps check overflow of the "single". */
1585 REAL_VALUE_FROM_CONST_DOUBLE (r
, operand
);
1586 REAL_VALUE_TO_TARGET_SINGLE (r
, l
);
1588 fprintf (file
, "0x%lx", l
);
1593 ASSERT_PLT_UNSPEC (operand
);
1597 cris_output_addr_const (file
, operand
);
1603 /* For a (MULT (reg X) const_int) we output "rX.S". */
1604 int i
= GET_CODE (XEXP (operand
, 1)) == CONST_INT
1605 ? INTVAL (XEXP (operand
, 1)) : INTVAL (XEXP (operand
, 0));
1606 rtx reg
= GET_CODE (XEXP (operand
, 1)) == CONST_INT
1607 ? XEXP (operand
, 0) : XEXP (operand
, 1);
1609 if (GET_CODE (reg
) != REG
1610 || (GET_CODE (XEXP (operand
, 0)) != CONST_INT
1611 && GET_CODE (XEXP (operand
, 1)) != CONST_INT
))
1612 LOSE_AND_RETURN ("unexpected multiplicative operand", x
);
1614 cris_print_base (reg
, file
);
1615 fprintf (file
, ".%c",
1616 i
== 0 || (i
== 1 && GET_CODE (operand
) == MULT
) ? 'b'
1618 : (i
== 2 && GET_CODE (operand
) == MULT
) || i
== 1 ? 'w'
1624 /* No need to handle all strange variants, let output_addr_const
1626 if (CONSTANT_P (operand
))
1628 cris_output_addr_const (file
, operand
);
1632 LOSE_AND_RETURN ("unexpected operand", x
);
1636 /* The PRINT_OPERAND_ADDRESS worker. */
1639 cris_print_operand_address (FILE *file
, rtx x
)
1641 /* All these were inside MEM:s so output indirection characters. */
1644 if (CONSTANT_ADDRESS_P (x
))
1645 cris_output_addr_const (file
, x
);
1646 else if (BASE_OR_AUTOINCR_P (x
))
1647 cris_print_base (x
, file
);
1648 else if (GET_CODE (x
) == PLUS
)
1656 cris_print_base (x1
, file
);
1657 cris_print_index (x2
, file
);
1659 else if (BASE_P (x2
))
1661 cris_print_base (x2
, file
);
1662 cris_print_index (x1
, file
);
1665 LOSE_AND_RETURN ("unrecognized address", x
);
1667 else if (GET_CODE (x
) == MEM
)
1669 /* A DIP. Output more indirection characters. */
1671 cris_print_base (XEXP (x
, 0), file
);
1675 LOSE_AND_RETURN ("unrecognized address", x
);
1680 /* The RETURN_ADDR_RTX worker.
1681 We mark that the return address is used, either by EH or
1682 __builtin_return_address, for use by the function prologue and
1683 epilogue. FIXME: This isn't optimal; we just use the mark in the
1684 prologue and epilogue to say that the return address is to be stored
1685 in the stack frame. We could return SRP for leaf-functions and use the
1686 initial-value machinery. */
1689 cris_return_addr_rtx (int count
, rtx frameaddr ATTRIBUTE_UNUSED
)
1691 cfun
->machine
->needs_return_address_on_stack
= 1;
1693 /* The return-address is stored just above the saved frame-pointer (if
1694 present). Apparently we can't eliminate from the frame-pointer in
1695 that direction, so use the incoming args (maybe pretended) pointer. */
1697 ? gen_rtx_MEM (Pmode
, plus_constant (virtual_incoming_args_rtx
, -4))
1701 /* This used to be the INITIAL_FRAME_POINTER_OFFSET worker; now only
1702 handles FP -> SP elimination offset. */
1705 cris_initial_frame_pointer_offset (void)
1709 /* Initial offset is 0 if we don't have a frame pointer. */
1712 /* And 4 for each register pushed. */
1713 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1714 if ((((regs_ever_live
[regno
]
1715 && !call_used_regs
[regno
])
1716 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
1717 && (current_function_uses_pic_offset_table
1718 /* It is saved anyway, if there would be a gap. */
1720 && regs_ever_live
[regno
+ 1]
1721 && !call_used_regs
[regno
+ 1]))))
1722 && (regno
!= FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
1723 && regno
!= CRIS_SRP_REGNUM
)
1724 || (current_function_calls_eh_return
1725 && (regno
== EH_RETURN_DATA_REGNO (0)
1726 || regno
== EH_RETURN_DATA_REGNO (1)
1727 || regno
== EH_RETURN_DATA_REGNO (2)
1728 || regno
== EH_RETURN_DATA_REGNO (3))))
1731 /* And then, last, we add the locals allocated. */
1732 offs
+= get_frame_size ();
1734 /* And more; the accumulated args size. */
1735 offs
+= current_function_outgoing_args_size
;
1737 /* Then round it off, in case we use aligned stack. */
1738 if (TARGET_STACK_ALIGN
)
1739 offs
= TARGET_ALIGN_BY_32
? (offs
+ 3) & ~3 : (offs
+ 1) & ~1;
1744 /* The INITIAL_ELIMINATION_OFFSET worker.
1745 Calculate the difference between imaginary registers such as frame
1746 pointer and the stack pointer. Used to eliminate the frame pointer
1747 and imaginary arg pointer. */
1750 cris_initial_elimination_offset (int fromreg
, int toreg
)
1753 = cris_initial_frame_pointer_offset ();
1755 /* We should be able to use regs_ever_live and related prologue
1756 information here, or alpha should not as well. */
1757 int return_address_on_stack
1758 = regs_ever_live
[CRIS_SRP_REGNUM
]
1759 || cfun
->machine
->needs_return_address_on_stack
!= 0;
1761 /* Here we act as if the frame-pointer were needed. */
1762 int ap_fp_offset
= 4 + (return_address_on_stack
? 4 : 0);
1764 if (fromreg
== ARG_POINTER_REGNUM
1765 && toreg
== FRAME_POINTER_REGNUM
)
1766 return ap_fp_offset
;
1768 /* Between the frame pointer and the stack are only "normal" stack
1769 variables and saved registers. */
1770 if (fromreg
== FRAME_POINTER_REGNUM
1771 && toreg
== STACK_POINTER_REGNUM
)
1772 return fp_sp_offset
;
1774 /* We need to balance out the frame pointer here. */
1775 if (fromreg
== ARG_POINTER_REGNUM
1776 && toreg
== STACK_POINTER_REGNUM
)
1777 return ap_fp_offset
+ fp_sp_offset
- 4;
1782 /* This function looks into the pattern to see how this insn affects
1785 Used when to eliminate test insns before a condition-code user,
1786 such as a "scc" insn or a conditional branch. This includes
1787 checking if the entities that cc was updated by, are changed by the
1790 Currently a jumble of the old peek-inside-the-insn and the newer
1791 check-cc-attribute methods. */
1794 cris_notice_update_cc (rtx exp
, rtx insn
)
1796 /* Check if user specified "-mcc-init" as a bug-workaround. FIXME:
1797 TARGET_CCINIT does not work; we must set CC_REVERSED as below.
1798 Several testcases will otherwise fail, for example
1799 gcc.c-torture/execute/20000217-1.c -O0 and -O1. */
1806 /* Slowly, we're converting to using attributes to control the setting
1807 of condition-code status. */
1808 switch (get_attr_cc (insn
))
1811 /* Even if it is "none", a setting may clobber a previous
1812 cc-value, so check. */
1813 if (GET_CODE (exp
) == SET
)
1815 if (cc_status
.value1
1816 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1818 cc_status
.value1
= 0;
1820 if (cc_status
.value2
1821 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1823 cc_status
.value2
= 0;
1832 /* Which means, for:
1837 CC is (reg) and (...) - unless (...) is 0, then CC does not change.
1838 CC_NO_OVERFLOW unless (...) is reg or mem.
1847 (set (reg1) (mem (bdap/biap)))
1848 (set (reg2) (bdap/biap))):
1849 CC is (reg1) and (mem (reg2))
1852 (set (mem (bdap/biap)) (reg1)) [or 0]
1853 (set (reg2) (bdap/biap))):
1856 (where reg and mem includes strict_low_parts variants thereof)
1858 For all others, assume CC is clobbered.
1859 Note that we do not have to care about setting CC_NO_OVERFLOW,
1860 since the overflow flag is set to 0 (i.e. right) for
1861 instructions where it does not have any sane sense, but where
1862 other flags have meanings. (This includes shifts; the carry is
1865 Note that there are other parallel constructs we could match,
1866 but we don't do that yet. */
1868 if (GET_CODE (exp
) == SET
)
1870 /* FIXME: Check when this happens. It looks like we should
1871 actually do a CC_STATUS_INIT here to be safe. */
1872 if (SET_DEST (exp
) == pc_rtx
)
1875 /* Record CC0 changes, so we do not have to output multiple
1877 if (SET_DEST (exp
) == cc0_rtx
)
1879 cc_status
.value1
= SET_SRC (exp
);
1880 cc_status
.value2
= 0;
1882 /* Handle flags for the special btstq on one bit. */
1883 if (GET_CODE (SET_SRC (exp
)) == ZERO_EXTRACT
1884 && XEXP (SET_SRC (exp
), 1) == const1_rtx
)
1886 if (GET_CODE (XEXP (SET_SRC (exp
), 0)) == CONST_INT
)
1888 cc_status
.flags
= CC_INVERTED
;
1890 /* A one-bit btstq. */
1891 cc_status
.flags
= CC_Z_IN_NOT_N
;
1894 cc_status
.flags
= 0;
1896 if (GET_CODE (SET_SRC (exp
)) == COMPARE
)
1898 if (!REG_P (XEXP (SET_SRC (exp
), 0))
1899 && XEXP (SET_SRC (exp
), 1) != const0_rtx
)
1900 /* For some reason gcc will not canonicalize compare
1901 operations, reversing the sign by itself if
1902 operands are in wrong order. */
1903 /* (But NOT inverted; eq is still eq.) */
1904 cc_status
.flags
= CC_REVERSED
;
1906 /* This seems to be overlooked by gcc. FIXME: Check again.
1907 FIXME: Is it really safe? */
1909 = gen_rtx_MINUS (GET_MODE (SET_SRC (exp
)),
1910 XEXP (SET_SRC (exp
), 0),
1911 XEXP (SET_SRC (exp
), 1));
1915 else if (REG_P (SET_DEST (exp
))
1916 || (GET_CODE (SET_DEST (exp
)) == STRICT_LOW_PART
1917 && REG_P (XEXP (SET_DEST (exp
), 0))))
1919 /* A register is set; normally CC is set to show that no
1920 test insn is needed. Catch the exceptions. */
1922 /* If not to cc0, then no "set"s in non-natural mode give
1924 if (GET_MODE_SIZE (GET_MODE (SET_DEST (exp
))) > UNITS_PER_WORD
1925 || GET_MODE_CLASS (GET_MODE (SET_DEST (exp
))) == MODE_FLOAT
)
1927 /* ... except add:s and sub:s in DImode. */
1928 if (GET_MODE (SET_DEST (exp
)) == DImode
1929 && (GET_CODE (SET_SRC (exp
)) == PLUS
1930 || GET_CODE (SET_SRC (exp
)) == MINUS
))
1932 cc_status
.flags
= 0;
1933 cc_status
.value1
= SET_DEST (exp
);
1934 cc_status
.value2
= SET_SRC (exp
);
1936 if (cris_reg_overlap_mentioned_p (cc_status
.value1
,
1938 cc_status
.value2
= 0;
1940 /* Add and sub may set V, which gets us
1941 unoptimizable results in "gt" and "le" condition
1943 cc_status
.flags
|= CC_NO_OVERFLOW
;
1948 else if (SET_SRC (exp
) == const0_rtx
)
1950 /* There's no CC0 change when clearing a register or
1951 memory. Just check for overlap. */
1952 if ((cc_status
.value1
1953 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1955 cc_status
.value1
= 0;
1957 if ((cc_status
.value2
1958 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1960 cc_status
.value2
= 0;
1966 cc_status
.flags
= 0;
1967 cc_status
.value1
= SET_DEST (exp
);
1968 cc_status
.value2
= SET_SRC (exp
);
1970 if (cris_reg_overlap_mentioned_p (cc_status
.value1
,
1972 cc_status
.value2
= 0;
1974 /* Some operations may set V, which gets us
1975 unoptimizable results in "gt" and "le" condition
1977 if (GET_CODE (SET_SRC (exp
)) == PLUS
1978 || GET_CODE (SET_SRC (exp
)) == MINUS
1979 || GET_CODE (SET_SRC (exp
)) == NEG
)
1980 cc_status
.flags
|= CC_NO_OVERFLOW
;
1985 else if (GET_CODE (SET_DEST (exp
)) == MEM
1986 || (GET_CODE (SET_DEST (exp
)) == STRICT_LOW_PART
1987 && GET_CODE (XEXP (SET_DEST (exp
), 0)) == MEM
))
1989 /* When SET to MEM, then CC is not changed (except for
1991 if ((cc_status
.value1
1992 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1994 cc_status
.value1
= 0;
1996 if ((cc_status
.value2
1997 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1999 cc_status
.value2
= 0;
2004 else if (GET_CODE (exp
) == PARALLEL
)
2006 if (GET_CODE (XVECEXP (exp
, 0, 0)) == SET
2007 && GET_CODE (XVECEXP (exp
, 0, 1)) == SET
2008 && REG_P (XEXP (XVECEXP (exp
, 0, 1), 0)))
2010 if (REG_P (XEXP (XVECEXP (exp
, 0, 0), 0))
2011 && GET_CODE (XEXP (XVECEXP (exp
, 0, 0), 1)) == MEM
)
2013 /* For "move.S [rx=ry+o],rz", say CC reflects
2014 value1=rz and value2=[rx] */
2015 cc_status
.value1
= XEXP (XVECEXP (exp
, 0, 0), 0);
2017 = replace_equiv_address (XEXP (XVECEXP (exp
, 0, 0), 1),
2018 XEXP (XVECEXP (exp
, 0, 1), 0));
2019 cc_status
.flags
= 0;
2021 /* Huh? A side-effect cannot change the destination
2023 if (cris_reg_overlap_mentioned_p (cc_status
.value1
,
2025 internal_error ("internal error: sideeffect-insn affecting main effect");
2028 else if ((REG_P (XEXP (XVECEXP (exp
, 0, 0), 1))
2029 || XEXP (XVECEXP (exp
, 0, 0), 1) == const0_rtx
)
2030 && GET_CODE (XEXP (XVECEXP (exp
, 0, 0), 0)) == MEM
)
2032 /* For "move.S rz,[rx=ry+o]" and "clear.S [rx=ry+o]",
2033 say flags are not changed, except for overlap. */
2034 if (cc_status
.value1
2035 && cris_reg_overlap_mentioned_p (XEXP
2039 cc_status
.value1
= 0;
2041 if (cc_status
.value1
2042 && cris_reg_overlap_mentioned_p (XEXP
2046 cc_status
.value1
= 0;
2048 if (cc_status
.value2
2049 && cris_reg_overlap_mentioned_p (XEXP
2053 cc_status
.value2
= 0;
2055 if (cc_status
.value2
2056 && cris_reg_overlap_mentioned_p (XEXP
2060 cc_status
.value2
= 0;
2069 /* Unknown cc_attr value. */
2076 /* Return != 0 if the return sequence for the current function is short,
2077 like "ret" or "jump [sp+]". Prior to reloading, we can't tell how
2078 many registers must be saved, so return 0 then. */
2081 cris_simple_epilogue (void)
2084 int reglimit
= STACK_POINTER_REGNUM
;
2087 if (! reload_completed
2088 || frame_pointer_needed
2089 || get_frame_size () != 0
2090 || current_function_pretend_args_size
2091 || current_function_args_size
2092 || current_function_outgoing_args_size
2093 || current_function_calls_eh_return
2095 /* If we're not supposed to emit prologue and epilogue, we must
2096 not emit return-type instructions. */
2097 || !TARGET_PROLOGUE_EPILOGUE
)
2100 /* We allow a "movem [sp+],rN" to sit in front if the "jump [sp+]" or
2101 in the delay-slot of the "ret". */
2102 for (regno
= 0; regno
< reglimit
; regno
++)
2103 if ((regs_ever_live
[regno
] && ! call_used_regs
[regno
])
2104 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
2105 && (current_function_uses_pic_offset_table
2106 /* It is saved anyway, if there would be a gap. */
2108 && regs_ever_live
[regno
+ 1]
2109 && !call_used_regs
[regno
+ 1]))))
2111 if (lastreg
!= regno
- 1)
2119 /* Compute a (partial) cost for rtx X. Return true if the complete
2120 cost has been computed, and false if subexpressions should be
2121 scanned. In either case, *TOTAL contains the cost result. */
2124 cris_rtx_costs (rtx x
, int code
, int outer_code
, int *total
)
2130 HOST_WIDE_INT val
= INTVAL (x
);
2133 else if (val
< 32 && val
>= -32)
2135 /* Eight or 16 bits are a word and cycle more expensive. */
2136 else if (val
<= 32767 && val
>= -32768)
2138 /* A 32 bit constant (or very seldom, unsigned 16 bits) costs
2139 another word. FIXME: This isn't linear to 16 bits. */
2151 /* For PIC, we need a prefix (if it isn't already there),
2152 and the PIC register. For a global PIC symbol, we also
2153 need a read of the GOT. */
2156 if (cris_got_symbol (x
))
2166 if (x
!= CONST0_RTX (GET_MODE (x
) == VOIDmode
? DImode
: GET_MODE (x
)))
2169 /* Make 0.0 cheap, else test-insns will not be used. */
2174 /* Identify values that are no powers of two. Powers of 2 are
2175 taken care of already and those values should not be changed. */
2176 if (GET_CODE (XEXP (x
, 1)) != CONST_INT
2177 || exact_log2 (INTVAL (XEXP (x
, 1)) < 0))
2179 /* If we have a multiply insn, then the cost is between
2180 1 and 2 "fast" instructions. */
2181 if (TARGET_HAS_MUL_INSNS
)
2183 *total
= COSTS_N_INSNS (1) + COSTS_N_INSNS (1) / 2;
2187 /* Estimate as 4 + 4 * #ofbits. */
2188 *total
= COSTS_N_INSNS (132);
2197 if (GET_CODE (XEXP (x
, 1)) != CONST_INT
2198 || exact_log2 (INTVAL (XEXP (x
, 1)) < 0))
2200 /* Estimate this as 4 + 8 * #of bits. */
2201 *total
= COSTS_N_INSNS (260);
2207 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
2208 /* Two constants may actually happen before optimization. */
2209 && GET_CODE (XEXP (x
, 0)) != CONST_INT
2210 && !CONST_OK_FOR_LETTER_P (INTVAL (XEXP (x
, 1)), 'I'))
2212 *total
= (rtx_cost (XEXP (x
, 0), outer_code
) + 2
2213 + 2 * GET_MODE_NUNITS (GET_MODE (XEXP (x
, 0))));
2218 case ZERO_EXTEND
: case SIGN_EXTEND
:
2219 *total
= rtx_cost (XEXP (x
, 0), outer_code
);
2227 /* The ADDRESS_COST worker. */
2230 cris_address_cost (rtx x
)
2232 /* The metric to use for the cost-macros is unclear.
2233 The metric used here is (the number of cycles needed) / 2,
2234 where we consider equal a cycle for a word of code and a cycle to
2237 /* The cheapest addressing modes get 0, since nothing extra is needed. */
2238 if (BASE_OR_AUTOINCR_P (x
))
2241 /* An indirect mem must be a DIP. This means two bytes extra for code,
2242 and 4 bytes extra for memory read, i.e. (2 + 4) / 2. */
2243 if (GET_CODE (x
) == MEM
)
2246 /* Assume (2 + 4) / 2 for a single constant; a dword, since it needs
2247 an extra DIP prefix and 4 bytes of constant in most cases.
2248 For PIC and a symbol with a GOT entry, we double the cost since we
2249 add a [rPIC+...] offset. A GOT-less symbol uses a BDAP prefix
2250 equivalent to the DIP prefix for non-PIC, hence the same cost. */
2252 return flag_pic
&& cris_got_symbol (x
) ? 2 * (2 + 4) / 2 : (2 + 4) / 2;
2254 /* Handle BIAP and BDAP prefixes. */
2255 if (GET_CODE (x
) == PLUS
)
2257 rtx tem1
= XEXP (x
, 0);
2258 rtx tem2
= XEXP (x
, 1);
2260 /* A BIAP is 2 extra bytes for the prefix insn, nothing more. We
2261 recognize the typical MULT which is always in tem1 because of
2262 insn canonicalization. */
2263 if ((GET_CODE (tem1
) == MULT
&& BIAP_INDEX_P (tem1
))
2267 /* A BDAP (quick) is 2 extra bytes. Any constant operand to the
2268 PLUS is always found in tem2. */
2269 if (GET_CODE (tem2
) == CONST_INT
2270 && INTVAL (tem2
) < 128 && INTVAL (tem2
) >= -128)
2273 /* A BDAP -32768 .. 32767 is like BDAP quick, but with 2 extra
2275 if (GET_CODE (tem2
) == CONST_INT
2276 && CONST_OK_FOR_LETTER_P (INTVAL (tem2
), 'L'))
2279 /* A BDAP with some other constant is 2 bytes extra. */
2280 if (CONSTANT_P (tem2
))
2281 return (2 + 2 + 2) / 2;
2283 /* BDAP with something indirect should have a higher cost than
2284 BIAP with register. FIXME: Should it cost like a MEM or more? */
2285 /* Don't need to check it, it's the only one left.
2286 FIXME: There was a REG test missing, perhaps there are others.
2288 return (2 + 2 + 2) / 2;
2291 /* What else? Return a high cost. It matters only for valid
2292 addressing modes. */
2296 /* Check various objections to the side-effect. Used in the test-part
2297 of an anonymous insn describing an insn with a possible side-effect.
2298 Returns nonzero if the implied side-effect is ok.
2301 ops : An array of rtx:es. lreg, rreg, rval,
2302 The variables multop and other_op are indexes into this,
2303 or -1 if they are not applicable.
2304 lreg : The register that gets assigned in the side-effect.
2305 rreg : One register in the side-effect expression
2306 rval : The other register, or an int.
2307 multop : An integer to multiply rval with.
2308 other_op : One of the entities of the main effect,
2309 whose mode we must consider. */
2312 cris_side_effect_mode_ok (enum rtx_code code
, rtx
*ops
,
2313 int lreg
, int rreg
, int rval
,
2314 int multop
, int other_op
)
2316 /* Find what value to multiply with, for rx =ry + rz * n. */
2317 int mult
= multop
< 0 ? 1 : INTVAL (ops
[multop
]);
2319 rtx reg_rtx
= ops
[rreg
];
2320 rtx val_rtx
= ops
[rval
];
2322 /* The operands may be swapped. Canonicalize them in reg_rtx and
2323 val_rtx, where reg_rtx always is a reg (for this constraint to
2325 if (! BASE_P (reg_rtx
))
2326 reg_rtx
= val_rtx
, val_rtx
= ops
[rreg
];
2328 /* Don't forget to check that reg_rtx really is a reg. If it isn't,
2329 we have no business. */
2330 if (! BASE_P (reg_rtx
))
2333 /* Don't do this when -mno-split. */
2334 if (!TARGET_SIDE_EFFECT_PREFIXES
)
2337 /* The mult expression may be hidden in lreg. FIXME: Add more
2338 commentary about that. */
2339 if (GET_CODE (val_rtx
) == MULT
)
2341 mult
= INTVAL (XEXP (val_rtx
, 1));
2342 val_rtx
= XEXP (val_rtx
, 0);
2346 /* First check the "other operand". */
2349 if (GET_MODE_SIZE (GET_MODE (ops
[other_op
])) > UNITS_PER_WORD
)
2352 /* Check if the lvalue register is the same as the "other
2353 operand". If so, the result is undefined and we shouldn't do
2354 this. FIXME: Check again. */
2355 if ((BASE_P (ops
[lreg
])
2356 && BASE_P (ops
[other_op
])
2357 && REGNO (ops
[lreg
]) == REGNO (ops
[other_op
]))
2358 || rtx_equal_p (ops
[other_op
], ops
[lreg
]))
2362 /* Do not accept frame_pointer_rtx as any operand. */
2363 if (ops
[lreg
] == frame_pointer_rtx
|| ops
[rreg
] == frame_pointer_rtx
2364 || ops
[rval
] == frame_pointer_rtx
2365 || (other_op
>= 0 && ops
[other_op
] == frame_pointer_rtx
))
2369 && ! BASE_P (val_rtx
))
2372 /* Do not allow rx = rx + n if a normal add or sub with same size
2374 if (rtx_equal_p (ops
[lreg
], reg_rtx
)
2375 && GET_CODE (val_rtx
) == CONST_INT
2376 && (INTVAL (val_rtx
) <= 63 && INTVAL (val_rtx
) >= -63))
2379 /* Check allowed cases, like [r(+)?].[bwd] and const.
2380 A symbol is not allowed with PIC. */
2381 if (CONSTANT_P (val_rtx
))
2382 return flag_pic
== 0 || cris_symbol (val_rtx
) == 0;
2384 if (GET_CODE (val_rtx
) == MEM
2385 && BASE_OR_AUTOINCR_P (XEXP (val_rtx
, 0)))
2388 if (GET_CODE (val_rtx
) == SIGN_EXTEND
2389 && GET_CODE (XEXP (val_rtx
, 0)) == MEM
2390 && BASE_OR_AUTOINCR_P (XEXP (XEXP (val_rtx
, 0), 0)))
2393 /* If we got here, it's not a valid addressing mode. */
2396 else if (code
== MULT
2397 || (code
== PLUS
&& BASE_P (val_rtx
)))
2399 /* Do not allow rx = rx + ry.S, since it doesn't give better code. */
2400 if (rtx_equal_p (ops
[lreg
], reg_rtx
)
2401 || (mult
== 1 && rtx_equal_p (ops
[lreg
], val_rtx
)))
2404 /* Do not allow bad multiply-values. */
2405 if (mult
!= 1 && mult
!= 2 && mult
!= 4)
2408 /* Only allow r + ... */
2409 if (! BASE_P (reg_rtx
))
2412 /* If we got here, all seems ok.
2413 (All checks need to be done above). */
2417 /* If we get here, the caller got its initial tests wrong. */
2418 internal_error ("internal error: cris_side_effect_mode_ok with bad operands");
2421 /* The function reg_overlap_mentioned_p in CVS (still as of 2001-05-16)
2422 does not handle the case where the IN operand is strict_low_part; it
2423 does handle it for X. Test-case in Axis-20010516. This function takes
2424 care of that for THIS port. FIXME: strict_low_part is going away
2428 cris_reg_overlap_mentioned_p (rtx x
, rtx in
)
2430 /* The function reg_overlap_mentioned now handles when X is
2431 strict_low_part, but not when IN is a STRICT_LOW_PART. */
2432 if (GET_CODE (in
) == STRICT_LOW_PART
)
2435 return reg_overlap_mentioned_p (x
, in
);
2438 /* The TARGET_ASM_NAMED_SECTION worker.
2439 We just dispatch to the functions for ELF and a.out. */
2442 cris_target_asm_named_section (const char *name
, unsigned int flags
)
2445 default_no_named_section (name
, flags
);
2447 default_elf_asm_named_section (name
, flags
);
2450 /* The LEGITIMATE_PIC_OPERAND_P worker. */
2453 cris_legitimate_pic_operand (rtx x
)
2455 /* The PIC representation of a symbol with a GOT entry will be (for
2456 example; relocations differ):
2457 sym => [rPIC+sym:GOT]
2458 and for a GOT-less symbol it will be (for example, relocation differ):
2459 sym => rPIC+sym:GOTOFF
2460 so only a symbol with a GOT is by itself a valid operand, and it
2461 can't be a sum of a symbol and an offset. */
2462 return ! cris_symbol (x
) || cris_got_symbol (x
);
2465 /* Return nonzero if there's a SYMBOL_REF or LABEL_REF hiding inside this
2471 switch (GET_CODE (x
))
2478 /* A PLT reference. */
2479 ASSERT_PLT_UNSPEC (x
);
2483 return cris_symbol (XEXP (x
, 0));
2487 return cris_symbol (XEXP (x
, 0)) || cris_symbol (XEXP (x
, 1));
2494 fatal_insn ("unrecognized supposed constant", x
);
2500 /* Return nonzero if there's a SYMBOL_REF or LABEL_REF hiding inside this
2501 CONSTANT_P, and the symbol does not need a GOT entry. Also set
2502 current_function_uses_pic_offset_table if we're generating PIC and ever
2503 see something that would need one. */
2506 cris_gotless_symbol (rtx x
)
2508 #ifdef ENABLE_CHECKING
2513 switch (GET_CODE (x
))
2516 ASSERT_PLT_UNSPEC (x
);
2521 current_function_uses_pic_offset_table
= 1;
2522 return SYMBOL_REF_LOCAL_P (x
);
2525 /* We don't set current_function_uses_pic_offset_table for
2526 LABEL_REF:s in here, since they are almost always originating
2527 from some branch. The only time it does not come from a label is
2528 when GCC does something like __builtin_setjmp. Then we get the
2529 LABEL_REF from the movsi expander, so we mark it there as a
2534 return cris_gotless_symbol (XEXP (x
, 0));
2539 int x0
= cris_gotless_symbol (XEXP (x
, 0)) != 0;
2540 int x1
= cris_gotless_symbol (XEXP (x
, 1)) != 0;
2542 /* One and only one of them must be a local symbol. Neither must
2543 be some other, more general kind of symbol. */
2546 && ! (x0
== 0 && cris_symbol (XEXP (x
, 0)))
2547 && ! (x1
== 0 && cris_symbol (XEXP (x
, 1)));
2555 fatal_insn ("unrecognized supposed constant", x
);
2561 /* Return nonzero if there's a SYMBOL_REF or LABEL_REF hiding inside this
2562 CONSTANT_P, and the symbol needs a GOT entry. */
2565 cris_got_symbol (rtx x
)
2567 #ifdef ENABLE_CHECKING
2572 switch (GET_CODE (x
))
2575 ASSERT_PLT_UNSPEC (x
);
2580 current_function_uses_pic_offset_table
= 1;
2581 return ! SYMBOL_REF_LOCAL_P (x
);
2584 return cris_got_symbol (XEXP (x
, 0));
2587 /* A LABEL_REF is never visible as a symbol outside the local
2591 /* Nope, can't access the GOT for "symbol + offset". */
2599 fatal_insn ("unrecognized supposed constant in cris_global_pic_symbol",
2606 /* The OVERRIDE_OPTIONS worker.
2607 As is the norm, this also parses -mfoo=bar type parameters. */
2610 cris_override_options (void)
2612 if (cris_max_stackframe_str
)
2614 cris_max_stackframe
= atoi (cris_max_stackframe_str
);
2616 /* Do some sanity checking. */
2617 if (cris_max_stackframe
< 0 || cris_max_stackframe
> 0x20000000)
2618 internal_error ("-max-stackframe=%d is not usable, not between 0 and %d",
2619 cris_max_stackframe
, 0x20000000);
2622 /* Let "-metrax4" and "-metrax100" change the cpu version. */
2623 if (TARGET_SVINTO
&& cris_cpu_version
< CRIS_CPU_SVINTO
)
2624 cris_cpu_version
= CRIS_CPU_SVINTO
;
2625 else if (TARGET_ETRAX4_ADD
&& cris_cpu_version
< CRIS_CPU_ETRAX4
)
2626 cris_cpu_version
= CRIS_CPU_ETRAX4
;
2628 /* Parse -march=... and its synonym, the deprecated -mcpu=... */
2632 = (*cris_cpu_str
== 'v' ? atoi (cris_cpu_str
+ 1) : -1);
2634 if (strcmp ("etrax4", cris_cpu_str
) == 0)
2635 cris_cpu_version
= 3;
2637 if (strcmp ("svinto", cris_cpu_str
) == 0
2638 || strcmp ("etrax100", cris_cpu_str
) == 0)
2639 cris_cpu_version
= 8;
2641 if (strcmp ("ng", cris_cpu_str
) == 0
2642 || strcmp ("etrax100lx", cris_cpu_str
) == 0)
2643 cris_cpu_version
= 10;
2645 if (cris_cpu_version
< 0 || cris_cpu_version
> 10)
2646 error ("unknown CRIS version specification in -march= or -mcpu= : %s",
2649 /* Set the target flags. */
2650 if (cris_cpu_version
>= CRIS_CPU_ETRAX4
)
2651 target_flags
|= TARGET_MASK_ETRAX4_ADD
;
2653 /* If this is Svinto or higher, align for 32 bit accesses. */
2654 if (cris_cpu_version
>= CRIS_CPU_SVINTO
)
2656 |= (TARGET_MASK_SVINTO
| TARGET_MASK_ALIGN_BY_32
2657 | TARGET_MASK_STACK_ALIGN
| TARGET_MASK_CONST_ALIGN
2658 | TARGET_MASK_DATA_ALIGN
);
2660 /* Note that we do not add new flags when it can be completely
2661 described with a macro that uses -mcpu=X. So
2662 TARGET_HAS_MUL_INSNS is (cris_cpu_version >= CRIS_CPU_NG). */
2668 = (*cris_tune_str
== 'v' ? atoi (cris_tune_str
+ 1) : -1);
2670 if (strcmp ("etrax4", cris_tune_str
) == 0)
2673 if (strcmp ("svinto", cris_tune_str
) == 0
2674 || strcmp ("etrax100", cris_tune_str
) == 0)
2677 if (strcmp ("ng", cris_tune_str
) == 0
2678 || strcmp ("etrax100lx", cris_tune_str
) == 0)
2681 if (cris_tune
< 0 || cris_tune
> 10)
2682 error ("unknown CRIS cpu version specification in -mtune= : %s",
2685 if (cris_tune
>= CRIS_CPU_SVINTO
)
2686 /* We have currently nothing more to tune than alignment for
2689 |= (TARGET_MASK_STACK_ALIGN
| TARGET_MASK_CONST_ALIGN
2690 | TARGET_MASK_DATA_ALIGN
| TARGET_MASK_ALIGN_BY_32
);
2695 /* Use error rather than warning, so invalid use is easily
2696 detectable. Still change to the values we expect, to avoid
2700 error ("-fPIC and -fpic are not supported in this configuration");
2704 /* Turn off function CSE. We need to have the addresses reach the
2705 call expanders to get PLT-marked, as they could otherwise be
2706 compared against zero directly or indirectly. After visiting the
2707 call expanders they will then be cse:ed, as the call expanders
2708 force_reg the addresses, effectively forcing flag_no_function_cse
2710 flag_no_function_cse
= 1;
2713 if ((write_symbols
== DWARF_DEBUG
2714 || write_symbols
== DWARF2_DEBUG
) && ! TARGET_ELF
)
2716 warning ("that particular -g option is invalid with -maout and -melinux");
2717 write_symbols
= DBX_DEBUG
;
2720 /* Set the per-function-data initializer. */
2721 init_machine_status
= cris_init_machine_status
;
2724 /* The TARGET_ASM_OUTPUT_MI_THUNK worker. */
2727 cris_asm_output_mi_thunk (FILE *stream
,
2728 tree thunkdecl ATTRIBUTE_UNUSED
,
2729 HOST_WIDE_INT delta
,
2730 HOST_WIDE_INT vcall_offset ATTRIBUTE_UNUSED
,
2734 fprintf (stream
, "\tadd%s " HOST_WIDE_INT_PRINT_DEC
",$%s\n",
2735 ADDITIVE_SIZE_MODIFIER (delta
), delta
,
2736 reg_names
[CRIS_FIRST_ARG_REG
]);
2738 fprintf (stream
, "\tsub%s " HOST_WIDE_INT_PRINT_DEC
",$%s\n",
2739 ADDITIVE_SIZE_MODIFIER (-delta
), -delta
,
2740 reg_names
[CRIS_FIRST_ARG_REG
]);
2744 const char *name
= XSTR (XEXP (DECL_RTL (funcdecl
), 0), 0);
2746 name
= (* targetm
.strip_name_encoding
) (name
);
2747 fprintf (stream
, "add.d ");
2748 assemble_name (stream
, name
);
2749 fprintf (stream
, "%s,$pc\n", CRIS_PLT_PCOFFSET_SUFFIX
);
2753 fprintf (stream
, "jump ");
2754 assemble_name (stream
, XSTR (XEXP (DECL_RTL (funcdecl
), 0), 0));
2755 fprintf (stream
, "\n");
2759 /* Boilerplate emitted at start of file.
2761 NO_APP *only at file start* means faster assembly. It also means
2762 comments are not allowed. In some cases comments will be output
2763 for debugging purposes. Make sure they are allowed then.
2765 We want a .file directive only if TARGET_ELF. */
2767 cris_file_start (void)
2769 /* These expressions can vary at run time, so we cannot put
2770 them into TARGET_INITIALIZER. */
2771 targetm
.file_start_app_off
= !(TARGET_PDEBUG
|| flag_print_asm_name
);
2772 targetm
.file_start_file_directive
= TARGET_ELF
;
2774 default_file_start ();
2777 /* Rename the function calls for integer multiply and divide. */
2779 cris_init_libfuncs (void)
2781 set_optab_libfunc (smul_optab
, SImode
, "__Mul");
2782 set_optab_libfunc (sdiv_optab
, SImode
, "__Div");
2783 set_optab_libfunc (udiv_optab
, SImode
, "__Udiv");
2784 set_optab_libfunc (smod_optab
, SImode
, "__Mod");
2785 set_optab_libfunc (umod_optab
, SImode
, "__Umod");
2788 /* The EXPAND_BUILTIN_VA_ARG worker. This is modified from the
2789 "standard" implementation of va_arg: read the value from the current
2790 address and increment by the size of one or two registers. The
2791 important difference for CRIS is that if the type is
2792 pass-by-reference, then perform an indirection. */
2795 cris_expand_builtin_va_arg (tree valist
, tree type
)
2799 tree passed_size
= size_zero_node
;
2800 tree type_size
= NULL
;
2801 tree size3
= size_int (3);
2802 tree size4
= size_int (4);
2803 tree size8
= size_int (8);
2809 if (type
== error_mark_node
2810 || (type_size
= TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type
))) == NULL
2811 || TREE_OVERFLOW (type_size
))
2812 /* Presumably an error; the size isn't computable. A message has
2813 supposedly been emitted elsewhere. */
2814 rounded_size
= size_zero_node
;
2817 = fold (build (MULT_EXPR
, sizetype
,
2818 fold (build (TRUNC_DIV_EXPR
, sizetype
,
2819 fold (build (PLUS_EXPR
, sizetype
,
2824 if (!integer_zerop (rounded_size
))
2826 /* Check if the type is passed by value or by reference. Values up
2827 to 8 bytes are passed by-value, padded to register-size (4
2828 bytes). Larger values and varying-size types are passed
2831 = (!really_constant_p (type_size
)
2833 : fold (build (COND_EXPR
, sizetype
,
2834 fold (build (GT_EXPR
, sizetype
,
2841 = (!really_constant_p (type_size
)
2842 ? build1 (INDIRECT_REF
, build_pointer_type (type
), addr_tree
)
2843 : fold (build (COND_EXPR
, TREE_TYPE (addr_tree
),
2844 fold (build (GT_EXPR
, sizetype
,
2847 build1 (INDIRECT_REF
, build_pointer_type (type
),
2852 addr
= expand_expr (addr_tree
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
2853 addr
= copy_to_reg (addr
);
2855 if (!integer_zerop (rounded_size
))
2857 /* Compute new value for AP. */
2858 t
= build (MODIFY_EXPR
, TREE_TYPE (valist
), valist
,
2859 build (PLUS_EXPR
, TREE_TYPE (valist
), valist
,
2861 TREE_SIDE_EFFECTS (t
) = 1;
2862 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2868 /* The INIT_EXPANDERS worker sets the per-function-data initializer and
2872 cris_init_expanders (void)
2874 /* Nothing here at the moment. */
2877 /* Zero initialization is OK for all current fields. */
2879 static struct machine_function
*
2880 cris_init_machine_status (void)
2882 return ggc_alloc_cleared (sizeof (struct machine_function
));
2885 /* Split a 2 word move (DI or presumably DF) into component parts.
2886 Originally a copy of gen_split_move_double in m32r.c. */
2889 cris_split_movdx (rtx
*operands
)
2891 enum machine_mode mode
= GET_MODE (operands
[0]);
2892 rtx dest
= operands
[0];
2893 rtx src
= operands
[1];
2896 /* We used to have to handle (SUBREG (MEM)) here, but that should no
2897 longer happen; after reload there are no SUBREGs any more, and we're
2898 only called after reload. */
2899 if (GET_CODE (dest
) == SUBREG
|| GET_CODE (src
) == SUBREG
)
2903 if (GET_CODE (dest
) == REG
)
2905 int dregno
= REGNO (dest
);
2907 /* Reg-to-reg copy. */
2908 if (GET_CODE (src
) == REG
)
2910 int sregno
= REGNO (src
);
2912 int reverse
= (dregno
== sregno
+ 1);
2914 /* We normally copy the low-numbered register first. However, if
2915 the first register operand 0 is the same as the second register of
2916 operand 1, we must copy in the opposite order. */
2917 emit_insn (gen_rtx_SET (VOIDmode
,
2918 operand_subword (dest
, reverse
, TRUE
, mode
),
2919 operand_subword (src
, reverse
, TRUE
, mode
)));
2921 emit_insn (gen_rtx_SET (VOIDmode
,
2922 operand_subword (dest
, !reverse
, TRUE
, mode
),
2923 operand_subword (src
, !reverse
, TRUE
, mode
)));
2925 /* Constant-to-reg copy. */
2926 else if (GET_CODE (src
) == CONST_INT
|| GET_CODE (src
) == CONST_DOUBLE
)
2929 split_double (src
, &words
[0], &words
[1]);
2930 emit_insn (gen_rtx_SET (VOIDmode
,
2931 operand_subword (dest
, 0, TRUE
, mode
),
2934 emit_insn (gen_rtx_SET (VOIDmode
,
2935 operand_subword (dest
, 1, TRUE
, mode
),
2938 /* Mem-to-reg copy. */
2939 else if (GET_CODE (src
) == MEM
)
2941 /* If the high-address word is used in the address, we must load it
2942 last. Otherwise, load it first. */
2943 rtx addr
= XEXP (src
, 0);
2945 = (refers_to_regno_p (dregno
, dregno
+ 1, addr
, NULL
) != 0);
2947 /* The original code implies that we can't do
2948 move.x [rN+],rM move.x [rN],rM+1
2949 when rN is dead, because of REG_NOTES damage. That is
2950 consistent with what I've seen, so don't try it.
2952 We have two different cases here; if the addr is POST_INC,
2953 just pass it through, otherwise add constants. */
2955 if (GET_CODE (addr
) == POST_INC
)
2957 emit_insn (gen_rtx_SET (VOIDmode
,
2958 operand_subword (dest
, 0, TRUE
, mode
),
2959 change_address (src
, SImode
, addr
)));
2960 emit_insn (gen_rtx_SET (VOIDmode
,
2961 operand_subword (dest
, 1, TRUE
, mode
),
2962 change_address (src
, SImode
, addr
)));
2966 /* Make sure we don't get any other addresses with
2967 embedded postincrements. They should be stopped in
2968 GO_IF_LEGITIMATE_ADDRESS, but we're here for your
2970 if (side_effects_p (addr
))
2971 fatal_insn ("unexpected side-effects in address", addr
);
2973 emit_insn (gen_rtx_SET
2975 operand_subword (dest
, reverse
, TRUE
, mode
),
2978 plus_constant (addr
,
2979 reverse
* UNITS_PER_WORD
))));
2980 emit_insn (gen_rtx_SET
2982 operand_subword (dest
, ! reverse
, TRUE
, mode
),
2985 plus_constant (addr
,
2993 /* Reg-to-mem copy or clear mem. */
2994 else if (GET_CODE (dest
) == MEM
2995 && (GET_CODE (src
) == REG
2996 || src
== const0_rtx
2997 || src
== CONST0_RTX (DFmode
)))
2999 rtx addr
= XEXP (dest
, 0);
3001 if (GET_CODE (addr
) == POST_INC
)
3003 emit_insn (gen_rtx_SET (VOIDmode
,
3004 change_address (dest
, SImode
, addr
),
3005 operand_subword (src
, 0, TRUE
, mode
)));
3006 emit_insn (gen_rtx_SET (VOIDmode
,
3007 change_address (dest
, SImode
, addr
),
3008 operand_subword (src
, 1, TRUE
, mode
)));
3012 /* Make sure we don't get any other addresses with embedded
3013 postincrements. They should be stopped in
3014 GO_IF_LEGITIMATE_ADDRESS, but we're here for your safety. */
3015 if (side_effects_p (addr
))
3016 fatal_insn ("unexpected side-effects in address", addr
);
3018 emit_insn (gen_rtx_SET
3020 change_address (dest
, SImode
, addr
),
3021 operand_subword (src
, 0, TRUE
, mode
)));
3023 emit_insn (gen_rtx_SET
3025 change_address (dest
, SImode
,
3026 plus_constant (addr
,
3028 operand_subword (src
, 1, TRUE
, mode
)));
3040 /* This is in essence a copy of output_addr_const altered to output
3041 symbolic operands as PIC.
3043 FIXME: Add hooks similar to ASM_OUTPUT_SYMBOL_REF to get this effect in
3044 the "real" output_addr_const. All we need is one for LABEL_REF (and
3045 one for CODE_LABEL?). */
3048 cris_output_addr_const (FILE *file
, rtx x
)
3053 switch (GET_CODE (x
))
3056 ASSERT_PLT_UNSPEC (x
);
3057 x
= XVECEXP (x
, 0, 0);
3064 const char *origstr
= XSTR (x
, 0);
3067 str
= (* targetm
.strip_name_encoding
) (origstr
);
3071 if (cris_pic_sympart_only
)
3073 assemble_name (file
, str
);
3074 fprintf (file
, ":PLTG");
3078 if (TARGET_AVOID_GOTPLT
)
3079 /* We shouldn't get here. */
3082 fprintf (file
, "[$%s+", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
3083 assemble_name (file
, XSTR (x
, 0));
3086 fprintf (file
, ":GOTPLT16]");
3088 fprintf (file
, ":GOTPLT]");
3091 else if (cris_gotless_symbol (x
))
3093 if (! cris_pic_sympart_only
)
3094 fprintf (file
, "$%s+", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
3095 assemble_name (file
, str
);
3096 fprintf (file
, ":GOTOFF");
3098 else if (cris_got_symbol (x
))
3100 if (cris_pic_sympart_only
)
3102 fprintf (file
, "[$%s+", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
3103 assemble_name (file
, XSTR (x
, 0));
3106 fprintf (file
, ":GOT16]");
3108 fprintf (file
, ":GOT]");
3111 LOSE_AND_RETURN ("unexpected PIC symbol", x
);
3114 if (! current_function_uses_pic_offset_table
)
3115 output_operand_lossage ("PIC register isn't set up");
3118 assemble_name (file
, XSTR (x
, 0));
3122 /* If we get one of those here, it should be dressed as PIC. Branch
3123 labels are normally output with the 'l' specifier, which means it
3124 will go directly to output_asm_label and not end up here. */
3125 if (GET_CODE (XEXP (x
, 0)) != CODE_LABEL
3126 && (GET_CODE (XEXP (x
, 0)) != NOTE
3127 || NOTE_LINE_NUMBER (XEXP (x
, 0)) != NOTE_INSN_DELETED_LABEL
))
3128 fatal_insn ("unexpected address expression", x
);
3132 if (cris_gotless_symbol (x
))
3134 if (! cris_pic_sympart_only
)
3135 fprintf (file
, "$%s+", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
3136 cris_output_addr_const (file
, XEXP (x
, 0));
3138 fprintf (file
, ":GOTOFF");
3141 /* Labels are never marked as global symbols. */
3142 fatal_insn ("unexpected PIC symbol", x
);
3145 if (! current_function_uses_pic_offset_table
)
3146 internal_error ("emitting PIC operand, but PIC register isn't set up");
3150 output_addr_const (file
, x
);
3154 if (NOTE_LINE_NUMBER (x
) != NOTE_INSN_DELETED_LABEL
)
3155 fatal_insn ("unexpected NOTE as addr_const:", x
);
3161 output_addr_const (file
, x
);
3165 /* This used to output parentheses around the expression,
3166 but that does not work on the 386 (either ATT or BSD assembler). */
3167 cris_output_addr_const (file
, XEXP (x
, 0));
3171 /* Some assemblers need integer constants to appear last (eg masm). */
3172 if (GET_CODE (XEXP (x
, 0)) == CONST_INT
)
3174 cris_output_addr_const (file
, XEXP (x
, 1));
3175 if (INTVAL (XEXP (x
, 0)) >= 0)
3176 fprintf (file
, "+");
3177 output_addr_const (file
, XEXP (x
, 0));
3181 cris_output_addr_const (file
, XEXP (x
, 0));
3182 if (GET_CODE (XEXP (x
, 1)) != CONST_INT
3183 || INTVAL (XEXP (x
, 1)) >= 0)
3184 fprintf (file
, "+");
3185 cris_output_addr_const (file
, XEXP (x
, 1));
3190 /* Avoid outputting things like x-x or x+5-x,
3191 since some assemblers can't handle that. */
3192 x
= simplify_subtraction (x
);
3193 if (GET_CODE (x
) != MINUS
)
3196 cris_output_addr_const (file
, XEXP (x
, 0));
3197 fprintf (file
, "-");
3198 if ((GET_CODE (XEXP (x
, 1)) == CONST_INT
3199 && INTVAL (XEXP (x
, 1)) < 0)
3200 || GET_CODE (XEXP (x
, 1)) != CONST_INT
)
3202 fprintf (file
, "%s", targetm
.asm_out
.open_paren
);
3203 cris_output_addr_const (file
, XEXP (x
, 1));
3204 fprintf (file
, "%s", targetm
.asm_out
.close_paren
);
3207 output_addr_const (file
, XEXP (x
, 1));
3211 LOSE_AND_RETURN ("unexpected address expression", x
);
3215 /* Worker function for TARGET_STRUCT_VALUE_RTX. */
3218 cris_struct_value_rtx (tree fntype ATTRIBUTE_UNUSED
,
3219 int incoming ATTRIBUTE_UNUSED
)
3221 return gen_rtx_REG (Pmode
, CRIS_STRUCT_VALUE_REGNUM
);
3224 /* Worker function for TARGET_SETUP_INCOMING_VARARGS. */
3227 cris_setup_incoming_varargs (CUMULATIVE_ARGS
*ca
,
3228 enum machine_mode mode ATTRIBUTE_UNUSED
,
3229 tree type ATTRIBUTE_UNUSED
,
3230 int *pretend_arg_size
,
3233 if (ca
->regs
< CRIS_MAX_ARGS_IN_REGS
)
3234 *pretend_arg_size
= (CRIS_MAX_ARGS_IN_REGS
- ca
->regs
) * 4;
3237 fprintf (asm_out_file
,
3238 "\n; VA:: ANSI: %d args before, anon @ #%d, %dtime\n",
3239 ca
->regs
, *pretend_arg_size
, second_time
);
3244 /* Various small functions to replace macros. Only called from a
3245 debugger. They might collide with gcc functions or system functions,
3246 so only emit them when '#if 1' above. */
3248 enum rtx_code
Get_code (rtx
);
3253 return GET_CODE (x
);
3256 const char *Get_mode (rtx
);
3261 return GET_MODE_NAME (GET_MODE (x
));
3264 rtx
Xexp (rtx
, int);
3272 rtx
Xvecexp (rtx
, int, int);
3275 Xvecexp (rtx x
, int n
, int m
)
3277 return XVECEXP (x
, n
, m
);
3280 int Get_rtx_len (rtx
);
3285 return GET_RTX_LENGTH (GET_CODE (x
));
3288 /* Use upper-case to distinguish from local variables that are sometimes
3289 called next_insn and prev_insn. */
3291 rtx
Next_insn (rtx
);
3294 Next_insn (rtx insn
)
3296 return NEXT_INSN (insn
);
3299 rtx
Prev_insn (rtx
);
3302 Prev_insn (rtx insn
)
3304 return PREV_INSN (insn
);
3308 #include "gt-cris.h"
3312 * eval: (c-set-style "gnu")
3313 * indent-tabs-mode: t