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 int cris_initial_frame_pointer_offset (void);
97 static int saved_regs_mentioned (rtx
);
99 static void cris_target_asm_function_prologue (FILE *, HOST_WIDE_INT
);
101 static void cris_target_asm_function_epilogue (FILE *, HOST_WIDE_INT
);
103 static void cris_operand_lossage (const char *, rtx
);
105 static void cris_asm_output_mi_thunk
106 (FILE *, tree
, HOST_WIDE_INT
, HOST_WIDE_INT
, tree
);
108 static void cris_file_start (void);
109 static void cris_init_libfuncs (void);
111 static bool cris_rtx_costs (rtx
, int, int, int *);
112 static int cris_address_cost (rtx
);
114 /* The function cris_target_asm_function_epilogue puts the last insn to
115 output here. It always fits; there won't be a symbol operand. Used in
116 delay_slots_for_epilogue and function_epilogue. */
117 static char save_last
[80];
119 /* This is the argument from the "-max-stack-stackframe=" option. */
120 const char *cris_max_stackframe_str
;
122 /* This is the argument from the "-march=" option. */
123 const char *cris_cpu_str
;
125 /* This is the argument from the "-mtune=" option. */
126 const char *cris_tune_str
;
128 /* This is the argument from the "-melinux-stacksize=" option. */
129 const char *cris_elinux_stacksize_str
;
131 /* This is the parsed result of the "-max-stack-stackframe=" option. If
132 it (still) is zero, then there was no such option given. */
133 int cris_max_stackframe
= 0;
135 /* This is the parsed result of the "-march=" option, if given. */
136 int cris_cpu_version
= CRIS_DEFAULT_CPU_VERSION
;
138 #undef TARGET_ASM_ALIGNED_HI_OP
139 #define TARGET_ASM_ALIGNED_HI_OP "\t.word\t"
140 #undef TARGET_ASM_ALIGNED_SI_OP
141 #define TARGET_ASM_ALIGNED_SI_OP "\t.dword\t"
142 #undef TARGET_ASM_ALIGNED_DI_OP
143 #define TARGET_ASM_ALIGNED_DI_OP "\t.quad\t"
145 /* We need to define these, since the 2byte, 4byte, 8byte op:s are only
146 available in ELF. These "normal" pseudos do not have any alignment
147 constraints or side-effects. */
148 #undef TARGET_ASM_UNALIGNED_HI_OP
149 #define TARGET_ASM_UNALIGNED_HI_OP TARGET_ASM_ALIGNED_HI_OP
151 #undef TARGET_ASM_UNALIGNED_SI_OP
152 #define TARGET_ASM_UNALIGNED_SI_OP TARGET_ASM_ALIGNED_SI_OP
154 #undef TARGET_ASM_UNALIGNED_DI_OP
155 #define TARGET_ASM_UNALIGNED_DI_OP TARGET_ASM_ALIGNED_DI_OP
157 #undef TARGET_ASM_FUNCTION_PROLOGUE
158 #define TARGET_ASM_FUNCTION_PROLOGUE cris_target_asm_function_prologue
160 #undef TARGET_ASM_FUNCTION_EPILOGUE
161 #define TARGET_ASM_FUNCTION_EPILOGUE cris_target_asm_function_epilogue
163 #undef TARGET_ASM_OUTPUT_MI_THUNK
164 #define TARGET_ASM_OUTPUT_MI_THUNK cris_asm_output_mi_thunk
165 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
166 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK default_can_output_mi_thunk_no_vcall
168 #undef TARGET_ASM_FILE_START
169 #define TARGET_ASM_FILE_START cris_file_start
171 #undef TARGET_INIT_LIBFUNCS
172 #define TARGET_INIT_LIBFUNCS cris_init_libfuncs
174 #undef TARGET_RTX_COSTS
175 #define TARGET_RTX_COSTS cris_rtx_costs
176 #undef TARGET_ADDRESS_COST
177 #define TARGET_ADDRESS_COST cris_address_cost
179 struct gcc_target targetm
= TARGET_INITIALIZER
;
181 /* Predicate functions. */
183 /* This checks a part of an address, the one that is not a plain register
184 for an addressing mode using BDAP.
185 Allowed operands is either:
187 b) a CONST operand (but not a symbol when generating PIC)
188 c) a [r] or [r+] in SImode, or sign-extend from HI or QI. */
191 cris_bdap_operand (rtx op
, enum machine_mode mode
)
193 register enum rtx_code code
= GET_CODE (op
);
195 if (mode
!= SImode
&& (mode
!= VOIDmode
|| GET_MODE (op
) != VOIDmode
))
198 /* Just return whether this is a simple register or constant. */
199 if (register_operand (op
, mode
)
200 || (CONSTANT_P (op
) && !(flag_pic
&& cris_symbol (op
))))
203 /* Is it a [r] or possibly a [r+]? */
206 rtx tem
= XEXP (op
, 0);
209 && (register_operand (tem
, SImode
)
210 || (GET_CODE (tem
) == POST_INC
211 && register_operand (XEXP (tem
, 0), SImode
))))
217 /* Perhaps a sign-extended mem: [r].(b|w) or [r+].(b|w)? */
218 if (code
== SIGN_EXTEND
)
220 rtx tem
= XEXP (op
, 0);
222 if (GET_CODE (tem
) != MEM
)
227 && (register_operand (tem
, SImode
)
228 || (GET_CODE (tem
) == POST_INC
229 && register_operand (XEXP (tem
, 0), SImode
))))
238 /* This is similar to cris_bdap_operand:
239 It checks a part of an address, the one that is not a plain register
240 for an addressing mode using BDAP *or* BIAP.
241 Allowed operands is either:
243 b) a CONST operand (but not a symbol when generating PIC)
244 c) a mult of (1, 2 or 4) and a register
245 d) a [r] or [r+] in SImode, or sign-extend from HI or QI. */
248 cris_bdap_biap_operand (rtx op
, enum machine_mode mode
)
250 register enum rtx_code code
= GET_CODE (op
);
254 /* Check for bdap operand. */
255 if (cris_bdap_operand (op
, mode
))
258 if (mode
!= SImode
&& (mode
!= VOIDmode
|| GET_MODE (op
) != VOIDmode
))
261 /* Check that we're looking at a BIAP operand. */
265 /* Canonicalize register and multiplicand. */
266 if (GET_CODE (XEXP (op
, 0)) == CONST_INT
)
277 /* Check that the operands are correct after canonicalization. */
278 if (! register_operand (reg
, SImode
) || GET_CODE (val
) != CONST_INT
)
281 /* Check that the multiplicand has a valid value. */
283 && (INTVAL (val
) == 1 || INTVAL (val
) == 2 || INTVAL (val
) == 4)))
289 /* Check if MODE is same as mode for X, and X is PLUS, MINUS, IOR or
293 cris_orthogonal_operator (rtx x
, enum machine_mode mode
)
295 enum rtx_code code
= GET_CODE (x
);
297 if (mode
== VOIDmode
)
300 return (GET_MODE (x
) == mode
301 && (code
== PLUS
|| code
== MINUS
302 || code
== IOR
|| code
== AND
|| code
== UMIN
));
305 /* Check if MODE is same as mode for X, and X is PLUS, IOR or AND or
309 cris_commutative_orth_op (rtx x
, enum machine_mode mode
)
311 enum rtx_code code
= GET_CODE (x
);
313 if (mode
== VOIDmode
)
316 return (GET_MODE (x
) == mode
&&
318 || code
== IOR
|| code
== AND
|| code
== UMIN
));
321 /* Check if MODE is same as mode for X, and X is PLUS or MINUS or UMIN. */
324 cris_operand_extend_operator (rtx x
, enum machine_mode mode
)
326 enum rtx_code code
= GET_CODE (x
);
328 if (mode
== VOIDmode
)
331 return (GET_MODE (x
) == mode
332 && (code
== PLUS
|| code
== MINUS
|| code
== UMIN
));
335 /* Check if MODE is same as mode for X, and X is PLUS or MINUS. */
338 cris_additive_operand_extend_operator (rtx x
, enum machine_mode mode
)
340 enum rtx_code code
= GET_CODE (x
);
342 if (mode
== VOIDmode
)
345 return (GET_MODE (x
) == mode
346 && (code
== PLUS
|| code
== MINUS
));
349 /* Check to see if MODE is same as mode for X, and X is SIGN_EXTEND or
353 cris_extend_operator (rtx x
, enum machine_mode mode
)
355 enum rtx_code code
= GET_CODE (x
);
357 if (mode
== VOIDmode
)
361 (GET_MODE (x
) == mode
&& (code
== SIGN_EXTEND
|| code
== ZERO_EXTEND
));
364 /* Check to see if MODE is same as mode for X, and X is PLUS or BOUND. */
367 cris_plus_or_bound_operator (rtx x
, enum machine_mode mode
)
369 enum rtx_code code
= GET_CODE (x
);
371 if (mode
== VOIDmode
)
375 (GET_MODE (x
) == mode
&& (code
== UMIN
|| code
== PLUS
));
378 /* Used as an operator to get a handle on a already-known-valid MEM rtx:es
379 (no need to validate the address), where some address expression parts
380 have their own match_operand. */
383 cris_mem_op (rtx x
, enum machine_mode mode
)
385 if (mode
== VOIDmode
)
388 return GET_MODE (x
) == mode
&& GET_CODE (x
) == MEM
;
391 /* Since with -fPIC, not all symbols are valid PIC symbols or indeed
392 general_operands, we have to have a predicate that matches it for the
396 cris_general_operand_or_symbol (rtx op
, enum machine_mode mode
)
398 return general_operand (op
, mode
)
399 || (CONSTANT_P (op
) && cris_symbol (op
));
402 /* Since a PIC symbol without a GOT entry is not a general_operand, we
403 have to have a predicate that matches it. We use this in the expanded
404 "movsi" anonymous pattern for PIC symbols. */
407 cris_general_operand_or_gotless_symbol (rtx op
, enum machine_mode mode
)
409 return general_operand (op
, mode
)
410 || (CONSTANT_P (op
) && cris_gotless_symbol (op
));
413 /* Since a PLT symbol is not a general_operand, we have to have a
414 predicate that matches it when we need it. We use this in the expanded
415 "call" and "call_value" anonymous patterns. */
418 cris_general_operand_or_plt_symbol (rtx op
, enum machine_mode mode
)
420 return general_operand (op
, mode
)
421 || (GET_CODE (op
) == CONST
422 && GET_CODE (XEXP (op
, 0)) == UNSPEC
423 && !TARGET_AVOID_GOTPLT
);
426 /* This matches a (MEM (general_operand)) or
427 (MEM (cris_general_operand_or_symbol)). The second one isn't a valid
428 memory_operand, so we need this predicate to recognize call
429 destinations before we change them to a PLT operand (by wrapping in
433 cris_mem_call_operand (rtx op
, enum machine_mode mode
)
437 if (GET_CODE (op
) != MEM
)
440 if (memory_operand (op
, mode
))
445 return cris_general_operand_or_symbol (xmem
, GET_MODE (op
));
448 /* The CONDITIONAL_REGISTER_USAGE worker. */
451 cris_conditional_register_usage (void)
453 /* FIXME: This isn't nice. We should be able to use that register for
454 something else if the PIC table isn't needed. */
456 fixed_regs
[PIC_OFFSET_TABLE_REGNUM
]
457 = call_used_regs
[PIC_OFFSET_TABLE_REGNUM
] = 1;
460 /* Return current_function_uses_pic_offset_table. For use in cris.md,
461 since some generated files do not include function.h. */
464 cris_cfun_uses_pic_table (void)
466 return current_function_uses_pic_offset_table
;
469 /* Given an rtx, return the text string corresponding to the CODE of X.
470 Intended for use in the assembly language output section of a
476 cris_output_insn_is_bound
= 0;
477 switch (GET_CODE (x
))
524 /* Used to control the sign/zero-extend character for the 'e' modifier.
526 cris_output_insn_is_bound
= 1;
531 return "Unknown operator";
536 /* Emit an error message when we're in an asm, and a fatal error for
537 "normal" insns. Formatted output isn't easily implemented, since we
538 use output_operand_lossage to output the actual message and handle the
539 categorization of the error. */
542 cris_operand_lossage (const char *msgid
, rtx op
)
545 output_operand_lossage ("%s", msgid
);
548 /* Print an index part of an address to file. */
551 cris_print_index (rtx index
, FILE *file
)
553 rtx inner
= XEXP (index
, 0);
555 /* Make the index "additive" unless we'll output a negative number, in
556 which case the sign character is free (as in free beer). */
557 if (GET_CODE (index
) != CONST_INT
|| INTVAL (index
) >= 0)
561 fprintf (file
, "$%s.b", reg_names
[REGNO (index
)]);
562 else if (CONSTANT_P (index
))
563 cris_output_addr_const (file
, index
);
564 else if (GET_CODE (index
) == MULT
)
566 fprintf (file
, "$%s.",
567 reg_names
[REGNO (XEXP (index
, 0))]);
569 putc (INTVAL (XEXP (index
, 1)) == 2 ? 'w' : 'd', file
);
571 else if (GET_CODE (index
) == SIGN_EXTEND
&&
572 GET_CODE (inner
) == MEM
)
574 rtx inner_inner
= XEXP (inner
, 0);
576 if (GET_CODE (inner_inner
) == POST_INC
)
578 fprintf (file
, "[$%s+].",
579 reg_names
[REGNO (XEXP (inner_inner
, 0))]);
580 putc (GET_MODE (inner
) == HImode
? 'w' : 'b', file
);
584 fprintf (file
, "[$%s].", reg_names
[REGNO (inner_inner
)]);
586 putc (GET_MODE (inner
) == HImode
? 'w' : 'b', file
);
589 else if (GET_CODE (index
) == MEM
)
591 if (GET_CODE (inner
) == POST_INC
)
592 fprintf (file
, "[$%s+].d", reg_names
[REGNO (XEXP (inner
, 0))]);
594 fprintf (file
, "[$%s].d", reg_names
[REGNO (inner
)]);
597 cris_operand_lossage ("unexpected index-type in cris_print_index",
601 /* Print a base rtx of an address to file. */
604 cris_print_base (rtx base
, FILE *file
)
607 fprintf (file
, "$%s", reg_names
[REGNO (base
)]);
608 else if (GET_CODE (base
) == POST_INC
)
609 fprintf (file
, "$%s+", reg_names
[REGNO (XEXP (base
, 0))]);
611 cris_operand_lossage ("unexpected base-type in cris_print_base",
615 /* Usable as a guard in expressions. */
618 cris_fatal (char *arg
)
620 internal_error (arg
);
622 /* We'll never get here; this is just to appease compilers. */
626 /* Textual function prologue. */
629 cris_target_asm_function_prologue (FILE *file
, HOST_WIDE_INT size
)
633 /* Shorten the used name for readability. */
634 int cfoa_size
= current_function_outgoing_args_size
;
635 int last_movem_reg
= -1;
636 int doing_dwarf
= dwarf2out_do_frame ();
638 int faked_args_size
= 0;
639 int cfa_write_offset
= 0;
640 char *cfa_label
= NULL
;
641 int return_address_on_stack
642 = regs_ever_live
[CRIS_SRP_REGNUM
]
643 || cfun
->machine
->needs_return_address_on_stack
!= 0;
645 /* Don't do anything if no prologues or epilogues are wanted. */
646 if (!TARGET_PROLOGUE_EPILOGUE
)
652 /* Align the size to what's best for the CPU model. */
653 if (TARGET_STACK_ALIGN
)
654 size
= TARGET_ALIGN_BY_32
? (size
+ 3) & ~3 : (size
+ 1) & ~1;
656 if (current_function_pretend_args_size
)
658 int pretend
= current_function_pretend_args_size
;
659 for (regno
= CRIS_FIRST_ARG_REG
+ CRIS_MAX_ARGS_IN_REGS
- 1;
661 regno
--, pretend
-= 4)
663 fprintf (file
, "\tpush $%s\n", reg_names
[regno
]);
664 faked_args_size
+= 4;
668 framesize
= faked_args_size
;
672 /* FIXME: Slightly redundant calculation, as we do the same in
673 pieces below. This offset must be the total adjustment of the
674 stack-pointer. We can then def_cfa call at the end of this
675 function with the current implementation of execute_cfa_insn, but
676 that wouldn't really be clean. */
680 + (return_address_on_stack
? 4 : 0)
681 + (frame_pointer_needed
? 4 : 0);
685 if (frame_pointer_needed
)
686 cfa_reg
= FRAME_POINTER_REGNUM
;
689 cfa_reg
= STACK_POINTER_REGNUM
;
690 cfa_offset
+= cris_initial_frame_pointer_offset ();
693 cfa_label
= dwarf2out_cfi_label ();
694 dwarf2out_def_cfa (cfa_label
, cfa_reg
, cfa_offset
);
696 cfa_write_offset
= - faked_args_size
- 4;
699 /* Save SRP if not a leaf function. */
700 if (return_address_on_stack
)
702 fprintf (file
, "\tPush $srp\n");
707 dwarf2out_return_save (cfa_label
, cfa_write_offset
);
708 cfa_write_offset
-= 4;
712 /* Set up frame pointer if needed. */
713 if (frame_pointer_needed
)
715 fprintf (file
, "\tpush $%s\n\tmove.d $sp,$%s\n",
716 reg_names
[FRAME_POINTER_REGNUM
],
717 reg_names
[FRAME_POINTER_REGNUM
]);
722 dwarf2out_reg_save (cfa_label
, FRAME_POINTER_REGNUM
,
724 cfa_write_offset
-= 4;
728 /* Local vars are located above saved regs. */
729 cfa_write_offset
-= size
;
731 /* Get a contiguous sequence of registers, starting with r0, that need
733 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
735 if ((((regs_ever_live
[regno
]
736 && !call_used_regs
[regno
])
737 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
738 && (current_function_uses_pic_offset_table
739 /* It is saved anyway, if there would be a gap. */
741 && regs_ever_live
[regno
+ 1]
742 && !call_used_regs
[regno
+ 1]))))
743 && (regno
!= FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
744 && regno
!= CRIS_SRP_REGNUM
)
745 || (current_function_calls_eh_return
746 && (regno
== EH_RETURN_DATA_REGNO (0)
747 || regno
== EH_RETURN_DATA_REGNO (1)
748 || regno
== EH_RETURN_DATA_REGNO (2)
749 || regno
== EH_RETURN_DATA_REGNO (3))))
751 /* Check if movem may be used for registers so far. */
752 if (regno
== last_movem_reg
+ 1)
753 /* Yes, update next expected register. */
757 /* We cannot use movem for all registers. We have to flush
758 any movem:ed registers we got so far. */
759 if (last_movem_reg
!= -1)
761 /* It is a win to use a side-effect assignment for
762 64 <= size <= 128. But side-effect on movem was
763 not usable for CRIS v0..3. Also only do it if
764 side-effects insns are allowed. */
765 if ((last_movem_reg
+ 1) * 4 + size
>= 64
766 && (last_movem_reg
+ 1) * 4 + size
<= 128
767 && cris_cpu_version
>= CRIS_CPU_SVINTO
768 && TARGET_SIDE_EFFECT_PREFIXES
)
769 fprintf (file
, "\tmovem $%s,[$sp=$sp-"HOST_WIDE_INT_PRINT_DEC
"]\n",
770 reg_names
[last_movem_reg
],
771 (last_movem_reg
+ 1) * 4 + size
);
774 /* Avoid printing multiple subsequent sub:s for sp. */
775 fprintf (file
, "\tsub%s "HOST_WIDE_INT_PRINT_DEC
",$sp\n",
776 ADDITIVE_SIZE_MODIFIER ((last_movem_reg
+ 1)
778 (last_movem_reg
+ 1) * 4 + size
);
780 fprintf (file
, "\tmovem $%s,[$sp]\n",
781 reg_names
[last_movem_reg
]);
784 framesize
+= (last_movem_reg
+ 1) * 4 + size
;
787 fprintf (file
, "; frame "HOST_WIDE_INT_PRINT_DEC
788 ", #regs %d, bytes %d args %d\n",
791 (last_movem_reg
+ 1) * 4,
792 current_function_args_size
);
799 /* Local vars on stack, but there are no movem:s.
800 Just allocate space. */
801 fprintf (file
, "\tSub%s "HOST_WIDE_INT_PRINT_DEC
",$sp\n",
802 ADDITIVE_SIZE_MODIFIER (size
),
808 fprintf (file
, "\tPush $%s\n", reg_names
[regno
]);
814 /* Registers are stored lowest numbered at highest address,
815 which matches the loop order; we just need to update the
817 dwarf2out_reg_save (cfa_label
, regno
, cfa_write_offset
);
818 cfa_write_offset
-= 4;
823 /* Check after, if we can movem all registers. This is the normal
825 if (last_movem_reg
!= -1)
827 /* Side-effect assignment on movem was not supported for CRIS v0..3,
828 and don't do it if we're asked not to.
830 The movem is already accounted for, for unwind. */
832 if ((last_movem_reg
+ 1) * 4 + size
>= 64
833 && (last_movem_reg
+ 1) * 4 + size
<= 128
834 && cris_cpu_version
>= CRIS_CPU_SVINTO
835 && TARGET_SIDE_EFFECT_PREFIXES
)
836 fprintf (file
, "\tmovem $%s,[$sp=$sp-"HOST_WIDE_INT_PRINT_DEC
"]\n",
837 reg_names
[last_movem_reg
],
838 (last_movem_reg
+1) * 4 + size
);
841 /* Avoid printing multiple subsequent sub:s for sp. FIXME:
842 Clean up the conditional expression. */
843 fprintf (file
, "\tsub%s "HOST_WIDE_INT_PRINT_DEC
",$sp\n",
844 ADDITIVE_SIZE_MODIFIER ((last_movem_reg
+ 1) * 4 + size
),
845 (last_movem_reg
+ 1) * 4 + size
);
846 /* To be compatible with v0..v3 means we do not use an assignment
847 addressing mode with movem. We normally don't need that
848 anyway. It would only be slightly more efficient for 64..128
850 fprintf (file
, "\tmovem $%s,[$sp]\n", reg_names
[last_movem_reg
]);
853 framesize
+= (last_movem_reg
+ 1) * 4 + size
;
856 fprintf (file
, "; frame "HOST_WIDE_INT_PRINT_DEC
857 ", #regs %d, bytes %d args %d\n",
860 (last_movem_reg
+ 1) * 4,
861 current_function_args_size
);
863 /* We have to put outgoing argument space after regs. */
866 /* This does not need to be accounted for, for unwind. */
868 fprintf (file
, "\tSub%s %d,$sp\n",
869 ADDITIVE_SIZE_MODIFIER (cfoa_size
),
871 framesize
+= cfoa_size
;
874 else if ((size
+ cfoa_size
) > 0)
876 /* This does not need to be accounted for, for unwind. */
878 /* Local vars on stack, and we could not use movem. Add a sub here. */
879 fprintf (file
, "\tSub%s "HOST_WIDE_INT_PRINT_DEC
",$sp\n",
880 ADDITIVE_SIZE_MODIFIER (size
+ cfoa_size
),
882 framesize
+= size
+ cfoa_size
;
885 /* Set up the PIC register. */
886 if (current_function_uses_pic_offset_table
)
887 fprintf (file
, "\tmove.d $pc,$%s\n\tsub.d .:GOTOFF,$%s\n",
888 reg_names
[PIC_OFFSET_TABLE_REGNUM
],
889 reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
893 "; parm #%d @ %d; frame " HOST_WIDE_INT_PRINT_DEC
894 ", FP-SP is %d; leaf: %s%s; fp %s, outg: %d arg %d\n",
895 CRIS_MAX_ARGS_IN_REGS
+ 1, FIRST_PARM_OFFSET (0),
897 cris_initial_frame_pointer_offset (),
898 leaf_function_p () ? "yes" : "no",
899 return_address_on_stack
? "no" :"yes",
900 frame_pointer_needed
? "yes" : "no",
901 cfoa_size
, current_function_args_size
);
903 if (cris_max_stackframe
&& framesize
> cris_max_stackframe
)
904 warning ("stackframe too big: %d bytes", framesize
);
907 /* Return nonzero if there are regs mentioned in the insn that are not all
908 in the call_used regs. This is part of the decision whether an insn
909 can be put in the epilogue. */
912 saved_regs_mentioned (rtx x
)
918 /* Mainly stolen from refers_to_regno_p in rtlanal.c. */
926 return !call_used_regs
[i
];
929 /* If this is a SUBREG of a hard reg, we can see exactly which
930 registers are being modified. Otherwise, handle normally. */
931 i
= REGNO (SUBREG_REG (x
));
932 return !call_used_regs
[i
];
938 fmt
= GET_RTX_FORMAT (code
);
939 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
943 if (saved_regs_mentioned (XEXP (x
, i
)))
946 else if (fmt
[i
] == 'E')
949 for (j
= XVECLEN (x
, i
) - 1; j
>=0; j
--)
950 if (saved_regs_mentioned (XEXP (x
, i
)))
958 /* Figure out if the insn may be put in the epilogue. */
961 cris_eligible_for_epilogue_delay (rtx insn
)
963 /* First of all, it must be as slottable as for a delayed branch insn. */
964 if (get_attr_slottable (insn
) != SLOTTABLE_YES
)
967 /* It must not refer to the stack pointer (may be valid for some cases
968 that I can't think of). */
969 if (reg_mentioned_p (stack_pointer_rtx
, PATTERN (insn
)))
972 /* The frame pointer will be restored in the epilogue, before the
973 "ret", so it can't be referred to. */
974 if (frame_pointer_needed
975 && reg_mentioned_p (frame_pointer_rtx
, PATTERN (insn
)))
978 /* All saved regs are restored before the delayed insn.
979 This means that we cannot have any instructions that mention the
980 registers that are restored by the epilogue. */
981 if (saved_regs_mentioned (PATTERN (insn
)))
984 /* It seems to be ok. */
988 /* Return the number of delay-slots in the epilogue: return 1 if it
989 contains "ret", else 0. */
992 cris_delay_slots_for_epilogue (void)
994 /* Check if we use a return insn, which we only do for leaf functions.
995 Else there is no slot to fill. */
996 if (regs_ever_live
[CRIS_SRP_REGNUM
]
997 || cfun
->machine
->needs_return_address_on_stack
!= 0)
1000 /* By calling function_epilogue with the same parameters as from gcc
1001 we can get info about if the epilogue can fill the delay-slot by itself.
1002 If it is filled from the epilogue, then the corresponding string
1004 This depends on that the "size" argument to function_epilogue
1005 always is get_frame_size.
1006 FIXME: Kludgy. At least make it a separate function that is not
1007 misnamed or abuses the stream parameter. */
1008 cris_target_asm_function_epilogue (NULL
, get_frame_size ());
1015 /* Textual function epilogue. When file is NULL, it serves doubly as
1016 a test for whether the epilogue can fill any "ret" delay-slots by
1017 itself by storing the delay insn in save_last. */
1020 cris_target_asm_function_epilogue (FILE *file
, HOST_WIDE_INT size
)
1023 int last_movem_reg
= -1;
1024 rtx insn
= get_last_insn ();
1025 int argspace_offset
= current_function_outgoing_args_size
;
1026 int pretend
= current_function_pretend_args_size
;
1027 int return_address_on_stack
1028 = regs_ever_live
[CRIS_SRP_REGNUM
]
1029 || cfun
->machine
->needs_return_address_on_stack
!= 0;
1033 if (file
&& !TARGET_PROLOGUE_EPILOGUE
)
1036 if (TARGET_PDEBUG
&& file
)
1037 fprintf (file
, ";;\n");
1039 /* Align byte count of stack frame. */
1040 if (TARGET_STACK_ALIGN
)
1041 size
= TARGET_ALIGN_BY_32
? (size
+ 3) & ~3 : (size
+ 1) & ~1;
1043 /* If the last insn was a BARRIER, we don't have to write any code,
1044 then all returns were covered by "return" insns. */
1045 if (GET_CODE (insn
) == NOTE
)
1046 insn
= prev_nonnote_insn (insn
);
1048 && (GET_CODE (insn
) == BARRIER
1049 /* We must make sure that the insn really is a "return" and
1050 not a conditional branch. Try to match the return exactly,
1051 and if it doesn't match, assume it is a conditional branch
1052 (and output an epilogue). */
1053 || (GET_CODE (insn
) == JUMP_INSN
1054 && GET_CODE (PATTERN (insn
)) == RETURN
)))
1056 if (TARGET_PDEBUG
&& file
)
1057 fprintf (file
, ";;;;;\n");
1061 /* Check how many saved regs we can movem. They start at r0 and must
1064 regno
< FIRST_PSEUDO_REGISTER
;
1066 if ((((regs_ever_live
[regno
]
1067 && !call_used_regs
[regno
])
1068 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
1069 && (current_function_uses_pic_offset_table
1070 /* It is saved anyway, if there would be a gap. */
1072 && regs_ever_live
[regno
+ 1]
1073 && !call_used_regs
[regno
+ 1]))))
1074 && (regno
!= FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
1075 && regno
!= CRIS_SRP_REGNUM
)
1076 || (current_function_calls_eh_return
1077 && (regno
== EH_RETURN_DATA_REGNO (0)
1078 || regno
== EH_RETURN_DATA_REGNO (1)
1079 || regno
== EH_RETURN_DATA_REGNO (2)
1080 || regno
== EH_RETURN_DATA_REGNO (3))))
1083 if (regno
== last_movem_reg
+ 1)
1089 for (regno
= FIRST_PSEUDO_REGISTER
- 1;
1090 regno
> last_movem_reg
;
1092 if ((((regs_ever_live
[regno
]
1093 && !call_used_regs
[regno
])
1094 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
1095 && (current_function_uses_pic_offset_table
1096 /* It is saved anyway, if there would be a gap. */
1098 && regs_ever_live
[regno
+ 1]
1099 && !call_used_regs
[regno
+ 1]))))
1100 && (regno
!= FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
1101 && regno
!= CRIS_SRP_REGNUM
)
1102 || (current_function_calls_eh_return
1103 && (regno
== EH_RETURN_DATA_REGNO (0)
1104 || regno
== EH_RETURN_DATA_REGNO (1)
1105 || regno
== EH_RETURN_DATA_REGNO (2)
1106 || regno
== EH_RETURN_DATA_REGNO (3))))
1108 if (argspace_offset
)
1110 /* There is an area for outgoing parameters located before
1111 the saved registers. We have to adjust for that. */
1113 fprintf (file
, "\tAdd%s %d,$sp\n",
1114 ADDITIVE_SIZE_MODIFIER (argspace_offset
),
1117 /* Make sure we only do this once. */
1118 argspace_offset
= 0;
1121 /* Flush previous non-movem:ed registers. */
1122 if (*save_last
&& file
)
1123 fprintf (file
, save_last
);
1124 sprintf (save_last
, "\tPop $%s\n", reg_names
[regno
]);
1127 if (last_movem_reg
!= -1)
1129 if (argspace_offset
)
1131 /* Adjust for the outgoing parameters area, if that's not
1133 if (*save_last
&& file
)
1135 fprintf (file
, save_last
);
1140 fprintf (file
, "\tAdd%s %d,$sp\n",
1141 ADDITIVE_SIZE_MODIFIER (argspace_offset
),
1143 argspace_offset
= 0;
1145 /* Flush previous non-movem:ed registers. */
1146 else if (*save_last
&& file
)
1147 fprintf (file
, save_last
);
1148 sprintf (save_last
, "\tmovem [$sp+],$%s\n", reg_names
[last_movem_reg
]);
1151 /* Restore frame pointer if necessary. */
1152 if (frame_pointer_needed
)
1154 if (*save_last
&& file
)
1155 fprintf (file
, save_last
);
1158 fprintf (file
, "\tmove.d $%s,$sp\n",
1159 reg_names
[FRAME_POINTER_REGNUM
]);
1160 sprintf (save_last
, "\tPop $%s\n",
1161 reg_names
[FRAME_POINTER_REGNUM
]);
1165 /* If there was no frame-pointer to restore sp from, we must
1166 explicitly deallocate local variables. */
1168 /* Handle space for outgoing parameters that hasn't been handled
1170 size
+= argspace_offset
;
1174 if (*save_last
&& file
)
1175 fprintf (file
, save_last
);
1177 sprintf (save_last
, "\tadd%s "HOST_WIDE_INT_PRINT_DEC
",$sp\n",
1178 ADDITIVE_SIZE_MODIFIER (size
), size
);
1181 /* If the size was not in the range for a "quick", we must flush
1186 fprintf (file
, save_last
);
1191 /* If this function has no pushed register parameters
1192 (stdargs/varargs), and if it is not a leaf function, then we can
1193 just jump-return here. */
1194 if (return_address_on_stack
&& pretend
== 0)
1196 if (*save_last
&& file
)
1197 fprintf (file
, save_last
);
1202 if (current_function_calls_eh_return
)
1204 /* The installed EH-return address is in *this* frame, so we
1205 need to pop it before we return. */
1206 fprintf (file
, "\tpop $srp\n");
1207 fprintf (file
, "\tret\n");
1208 fprintf (file
, "\tadd.d $%s,$sp\n", reg_names
[CRIS_STACKADJ_REG
]);
1211 fprintf (file
, "\tJump [$sp+]\n");
1213 /* Do a sanity check to avoid generating invalid code. */
1214 if (current_function_epilogue_delay_list
)
1215 internal_error ("allocated but unused delay list in epilogue");
1220 /* Rather than add current_function_calls_eh_return conditions
1221 everywhere in the following code (and not be able to test it
1222 thoroughly), assert the assumption that all usage of
1223 __builtin_eh_return are handled above. */
1224 if (current_function_calls_eh_return
)
1225 internal_error ("unexpected function type needing stack adjustment for\
1226 __builtin_eh_return");
1228 /* If we pushed some register parameters, then adjust the stack for
1232 /* Since srp is stored on the way, we need to restore it first. */
1233 if (return_address_on_stack
)
1235 if (*save_last
&& file
)
1236 fprintf (file
, save_last
);
1240 fprintf (file
, "\tpop $srp\n");
1243 if (*save_last
&& file
)
1244 fprintf (file
, save_last
);
1246 sprintf (save_last
, "\tadd%s %d,$sp\n",
1247 ADDITIVE_SIZE_MODIFIER (pretend
), pretend
);
1250 /* Here's where we have a delay-slot we need to fill. */
1251 if (file
&& current_function_epilogue_delay_list
)
1253 /* If gcc has allocated an insn for the epilogue delay slot, but
1254 things were arranged so we now thought we could do it
1255 ourselves, don't forget to flush that insn. */
1257 fprintf (file
, save_last
);
1259 fprintf (file
, "\tRet\n");
1261 /* Output the delay-slot-insn the mandated way. */
1262 final_scan_insn (XEXP (current_function_epilogue_delay_list
, 0),
1263 file
, 1, -2, 1, NULL
);
1267 fprintf (file
, "\tRet\n");
1269 /* If the GCC did not do it, we have to use whatever insn we have,
1272 fprintf (file
, save_last
);
1274 fprintf (file
, "\tnOp\n");
1278 /* The PRINT_OPERAND worker. */
1281 cris_print_operand (FILE *file
, rtx x
, int code
)
1285 /* Size-strings corresponding to MULT expressions. */
1286 static const char *const mults
[] = { "BAD:0", ".b", ".w", "BAD:3", ".d" };
1288 /* New code entries should just be added to the switch below. If
1289 handling is finished, just return. If handling was just a
1290 modification of the operand, the modified operand should be put in
1291 "operand", and then do a break to let default handling
1292 (zero-modifier) output the operand. */
1297 /* Print the unsigned supplied integer as if it was signed
1298 and < 0, i.e print 255 or 65535 as -1, 254, 65534 as -2, etc. */
1299 if (GET_CODE (x
) != CONST_INT
1300 || ! CONST_OK_FOR_LETTER_P (INTVAL (x
), 'O'))
1301 LOSE_AND_RETURN ("invalid operand for 'b' modifier", x
);
1302 fprintf (file
, HOST_WIDE_INT_PRINT_DEC
,
1303 INTVAL (x
)| (INTVAL (x
) <= 255 ? ~255 : ~65535));
1307 /* Print assembler code for operator. */
1308 fprintf (file
, "%s", cris_op_str (operand
));
1312 /* Print the operand without the PIC register. */
1313 if (! flag_pic
|| ! CONSTANT_P (x
) || ! cris_gotless_symbol (x
))
1314 LOSE_AND_RETURN ("invalid operand for 'v' modifier", x
);
1315 cris_pic_sympart_only
++;
1316 cris_output_addr_const (file
, x
);
1317 cris_pic_sympart_only
--;
1321 /* Print the PIC register. Applied to a GOT-less PIC symbol for
1323 if (! flag_pic
|| ! CONSTANT_P (x
) || ! cris_gotless_symbol (x
))
1324 LOSE_AND_RETURN ("invalid operand for 'P' modifier", x
);
1325 fprintf (file
, "$%s", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
1329 /* Adjust a power of two to its log2. */
1330 if (GET_CODE (x
) != CONST_INT
|| exact_log2 (INTVAL (x
)) < 0 )
1331 LOSE_AND_RETURN ("invalid operand for 'p' modifier", x
);
1332 fprintf (file
, "%d", exact_log2 (INTVAL (x
)));
1336 /* For an integer, print 'b' or 'w' if <= 255 or <= 65535
1337 respectively. This modifier also terminates the inhibiting
1338 effects of the 'x' modifier. */
1339 cris_output_insn_is_bound
= 0;
1340 if (GET_MODE (x
) == VOIDmode
&& GET_CODE (x
) == CONST_INT
)
1342 if (INTVAL (x
) >= 0)
1344 if (INTVAL (x
) <= 255)
1346 else if (INTVAL (x
) <= 65535)
1356 /* For a non-integer, print the size of the operand. */
1357 putc ((GET_MODE (x
) == SImode
|| GET_MODE (x
) == SFmode
)
1358 ? 'd' : GET_MODE (x
) == HImode
? 'w'
1359 : GET_MODE (x
) == QImode
? 'b'
1360 /* If none of the above, emit an erroneous size letter. */
1366 /* Const_int: print b for -127 <= x <= 255,
1367 w for -32768 <= x <= 65535, else abort. */
1368 if (GET_CODE (x
) != CONST_INT
1369 || INTVAL (x
) < -32768 || INTVAL (x
) > 65535)
1370 LOSE_AND_RETURN ("invalid operand for 'z' modifier", x
);
1371 putc (INTVAL (x
) >= -128 && INTVAL (x
) <= 255 ? 'b' : 'w', file
);
1375 /* Output a 'nop' if there's nothing for the delay slot.
1376 This method stolen from the sparc files. */
1377 if (dbr_sequence_length () == 0)
1378 fputs ("\n\tnop", file
);
1382 /* Print high (most significant) part of something. */
1383 switch (GET_CODE (operand
))
1386 if (HOST_BITS_PER_WIDE_INT
== 32)
1387 /* Sign-extension from a normal int to a long long. */
1388 fprintf (file
, INTVAL (operand
) < 0 ? "-1" : "0");
1390 fprintf (file
, "0x%x", (unsigned int)(INTVAL (x
) >> 31 >> 1));
1394 /* High part of a long long constant. */
1395 if (GET_MODE (operand
) == VOIDmode
)
1397 fprintf (file
, HOST_WIDE_INT_PRINT_HEX
, CONST_DOUBLE_HIGH (x
));
1401 LOSE_AND_RETURN ("invalid operand for 'H' modifier", x
);
1404 /* Print reg + 1. Check that there's not an attempt to print
1405 high-parts of registers like stack-pointer or higher. */
1406 if (REGNO (operand
) > STACK_POINTER_REGNUM
- 2)
1407 LOSE_AND_RETURN ("bad register", operand
);
1408 fprintf (file
, "$%s", reg_names
[REGNO (operand
) + 1]);
1412 /* Adjust memory address to high part. */
1414 rtx adj_mem
= operand
;
1416 = GET_MODE_BITSIZE (GET_MODE (operand
)) / BITS_PER_UNIT
;
1418 /* Adjust so we can use two SImode in DImode.
1419 Calling adj_offsettable_operand will make sure it is an
1420 offsettable address. Don't do this for a postincrement
1421 though; it should remain as it was. */
1422 if (GET_CODE (XEXP (adj_mem
, 0)) != POST_INC
)
1424 = adjust_address (adj_mem
, GET_MODE (adj_mem
), size
/ 2);
1426 output_address (XEXP (adj_mem
, 0));
1431 LOSE_AND_RETURN ("invalid operand for 'H' modifier", x
);
1435 /* Strip the MEM expression. */
1436 operand
= XEXP (operand
, 0);
1440 /* Print 's' if operand is SIGN_EXTEND or 'u' if ZERO_EXTEND unless
1441 cris_output_insn_is_bound is nonzero. */
1442 if (GET_CODE (operand
) != SIGN_EXTEND
1443 && GET_CODE (operand
) != ZERO_EXTEND
1444 && GET_CODE (operand
) != CONST_INT
)
1445 LOSE_AND_RETURN ("invalid operand for 'e' modifier", x
);
1447 if (cris_output_insn_is_bound
)
1449 cris_output_insn_is_bound
= 0;
1453 putc (GET_CODE (operand
) == SIGN_EXTEND
1454 || (GET_CODE (operand
) == CONST_INT
&& INTVAL (operand
) < 0)
1459 /* Print the size letter of the inner element. We can do it by
1460 calling ourselves with the 's' modifier. */
1461 if (GET_CODE (operand
) != SIGN_EXTEND
&& GET_CODE (operand
) != ZERO_EXTEND
)
1462 LOSE_AND_RETURN ("invalid operand for 'm' modifier", x
);
1463 cris_print_operand (file
, XEXP (operand
, 0), 's');
1467 /* Print the least significant part of operand. */
1468 if (GET_CODE (operand
) == CONST_DOUBLE
)
1470 fprintf (file
, HOST_WIDE_INT_PRINT_HEX
, CONST_DOUBLE_LOW (x
));
1473 else if (HOST_BITS_PER_WIDE_INT
> 32 && GET_CODE (operand
) == CONST_INT
)
1475 fprintf (file
, HOST_WIDE_INT_PRINT_HEX
,
1476 INTVAL (x
) & ((unsigned int) 0x7fffffff * 2 + 1));
1479 /* Otherwise the least significant part equals the normal part,
1480 so handle it normally. */
1484 /* When emitting an add for the high part of a DImode constant, we
1485 want to use addq for 0 and adds.w for -1. */
1486 if (GET_CODE (operand
) != CONST_INT
)
1487 LOSE_AND_RETURN ("invalid operand for 'A' modifier", x
);
1488 fprintf (file
, INTVAL (operand
) < 0 ? "adds.w" : "addq");
1492 /* When emitting an sub for the high part of a DImode constant, we
1493 want to use subq for 0 and subs.w for -1. */
1494 if (GET_CODE (operand
) != CONST_INT
)
1495 LOSE_AND_RETURN ("invalid operand for 'D' modifier", x
);
1496 fprintf (file
, INTVAL (operand
) < 0 ? "subs.w" : "subq");
1500 /* Print the operand as the index-part of an address.
1501 Easiest way out is to use cris_print_index. */
1502 cris_print_index (operand
, file
);
1506 /* Print the size letter for an operand to a MULT, which must be a
1507 const_int with a suitable value. */
1508 if (GET_CODE (operand
) != CONST_INT
|| INTVAL (operand
) > 4)
1509 LOSE_AND_RETURN ("invalid operand for 'T' modifier", x
);
1510 fprintf (file
, "%s", mults
[INTVAL (operand
)]);
1514 /* No code, print as usual. */
1518 LOSE_AND_RETURN ("invalid operand modifier letter", x
);
1521 /* Print an operand as without a modifier letter. */
1522 switch (GET_CODE (operand
))
1525 if (REGNO (operand
) > 15)
1526 internal_error ("internal error: bad register: %d", REGNO (operand
));
1527 fprintf (file
, "$%s", reg_names
[REGNO (operand
)]);
1531 output_address (XEXP (operand
, 0));
1535 if (GET_MODE (operand
) == VOIDmode
)
1536 /* A long long constant. */
1537 output_addr_const (file
, operand
);
1540 /* Only single precision is allowed as plain operands the
1541 moment. FIXME: REAL_VALUE_FROM_CONST_DOUBLE isn't
1546 /* FIXME: Perhaps check overflow of the "single". */
1547 REAL_VALUE_FROM_CONST_DOUBLE (r
, operand
);
1548 REAL_VALUE_TO_TARGET_SINGLE (r
, l
);
1550 fprintf (file
, "0x%lx", l
);
1555 ASSERT_PLT_UNSPEC (operand
);
1559 cris_output_addr_const (file
, operand
);
1565 /* For a (MULT (reg X) const_int) we output "rX.S". */
1566 int i
= GET_CODE (XEXP (operand
, 1)) == CONST_INT
1567 ? INTVAL (XEXP (operand
, 1)) : INTVAL (XEXP (operand
, 0));
1568 rtx reg
= GET_CODE (XEXP (operand
, 1)) == CONST_INT
1569 ? XEXP (operand
, 0) : XEXP (operand
, 1);
1571 if (GET_CODE (reg
) != REG
1572 || (GET_CODE (XEXP (operand
, 0)) != CONST_INT
1573 && GET_CODE (XEXP (operand
, 1)) != CONST_INT
))
1574 LOSE_AND_RETURN ("unexpected multiplicative operand", x
);
1576 cris_print_base (reg
, file
);
1577 fprintf (file
, ".%c",
1578 i
== 0 || (i
== 1 && GET_CODE (operand
) == MULT
) ? 'b'
1580 : (i
== 2 && GET_CODE (operand
) == MULT
) || i
== 1 ? 'w'
1586 /* No need to handle all strange variants, let output_addr_const
1588 if (CONSTANT_P (operand
))
1590 cris_output_addr_const (file
, operand
);
1594 LOSE_AND_RETURN ("unexpected operand", x
);
1598 /* The PRINT_OPERAND_ADDRESS worker. */
1601 cris_print_operand_address (FILE *file
, rtx x
)
1603 /* All these were inside MEM:s so output indirection characters. */
1606 if (CONSTANT_ADDRESS_P (x
))
1607 cris_output_addr_const (file
, x
);
1608 else if (BASE_OR_AUTOINCR_P (x
))
1609 cris_print_base (x
, file
);
1610 else if (GET_CODE (x
) == PLUS
)
1618 cris_print_base (x1
, file
);
1619 cris_print_index (x2
, file
);
1621 else if (BASE_P (x2
))
1623 cris_print_base (x2
, file
);
1624 cris_print_index (x1
, file
);
1627 LOSE_AND_RETURN ("unrecognized address", x
);
1629 else if (GET_CODE (x
) == MEM
)
1631 /* A DIP. Output more indirection characters. */
1633 cris_print_base (XEXP (x
, 0), file
);
1637 LOSE_AND_RETURN ("unrecognized address", x
);
1642 /* The RETURN_ADDR_RTX worker.
1643 We mark that the return address is used, either by EH or
1644 __builtin_return_address, for use by the function prologue and
1645 epilogue. FIXME: This isn't optimal; we just use the mark in the
1646 prologue and epilogue to say that the return address is to be stored
1647 in the stack frame. We could return SRP for leaf-functions and use the
1648 initial-value machinery. */
1651 cris_return_addr_rtx (int count
, rtx frameaddr ATTRIBUTE_UNUSED
)
1653 cfun
->machine
->needs_return_address_on_stack
= 1;
1655 /* The return-address is stored just above the saved frame-pointer (if
1656 present). Apparently we can't eliminate from the frame-pointer in
1657 that direction, so use the incoming args (maybe pretended) pointer. */
1659 ? gen_rtx_MEM (Pmode
, plus_constant (virtual_incoming_args_rtx
, -4))
1663 /* This used to be the INITIAL_FRAME_POINTER_OFFSET worker; now only
1664 handles FP -> SP elimination offset. */
1667 cris_initial_frame_pointer_offset (void)
1671 /* Initial offset is 0 if we don't have a frame pointer. */
1674 /* And 4 for each register pushed. */
1675 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
1676 if ((((regs_ever_live
[regno
]
1677 && !call_used_regs
[regno
])
1678 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
1679 && (current_function_uses_pic_offset_table
1680 /* It is saved anyway, if there would be a gap. */
1682 && regs_ever_live
[regno
+ 1]
1683 && !call_used_regs
[regno
+ 1]))))
1684 && (regno
!= FRAME_POINTER_REGNUM
|| !frame_pointer_needed
)
1685 && regno
!= CRIS_SRP_REGNUM
)
1686 || (current_function_calls_eh_return
1687 && (regno
== EH_RETURN_DATA_REGNO (0)
1688 || regno
== EH_RETURN_DATA_REGNO (1)
1689 || regno
== EH_RETURN_DATA_REGNO (2)
1690 || regno
== EH_RETURN_DATA_REGNO (3))))
1693 /* And then, last, we add the locals allocated. */
1694 offs
+= get_frame_size ();
1696 /* And more; the accumulated args size. */
1697 offs
+= current_function_outgoing_args_size
;
1699 /* Then round it off, in case we use aligned stack. */
1700 if (TARGET_STACK_ALIGN
)
1701 offs
= TARGET_ALIGN_BY_32
? (offs
+ 3) & ~3 : (offs
+ 1) & ~1;
1706 /* The INITIAL_ELIMINATION_OFFSET worker.
1707 Calculate the difference between imaginary registers such as frame
1708 pointer and the stack pointer. Used to eliminate the frame pointer
1709 and imaginary arg pointer. */
1712 cris_initial_elimination_offset (int fromreg
, int toreg
)
1715 = cris_initial_frame_pointer_offset ();
1717 /* We should be able to use regs_ever_live and related prologue
1718 information here, or alpha should not as well. */
1719 int return_address_on_stack
1720 = regs_ever_live
[CRIS_SRP_REGNUM
]
1721 || cfun
->machine
->needs_return_address_on_stack
!= 0;
1723 /* Here we act as if the frame-pointer is needed. */
1724 int ap_fp_offset
= 4 + (return_address_on_stack
? 4 : 0);
1726 if (fromreg
== ARG_POINTER_REGNUM
1727 && toreg
== FRAME_POINTER_REGNUM
)
1728 return ap_fp_offset
;
1730 /* Between the frame pointer and the stack are only "normal" stack
1731 variables and saved registers. */
1732 if (fromreg
== FRAME_POINTER_REGNUM
1733 && toreg
== STACK_POINTER_REGNUM
)
1734 return fp_sp_offset
;
1736 /* We need to balance out the frame pointer here. */
1737 if (fromreg
== ARG_POINTER_REGNUM
1738 && toreg
== STACK_POINTER_REGNUM
)
1739 return ap_fp_offset
+ fp_sp_offset
- 4;
1744 /* This function looks into the pattern to see how this insn affects
1747 Used when to eliminate test insns before a condition-code user,
1748 such as a "scc" insn or a conditional branch. This includes
1749 checking if the entities that cc was updated by, are changed by the
1752 Currently a jumble of the old peek-inside-the-insn and the newer
1753 check-cc-attribute methods. */
1756 cris_notice_update_cc (rtx exp
, rtx insn
)
1758 /* Check if user specified "-mcc-init" as a bug-workaround. FIXME:
1759 TARGET_CCINIT does not work; we must set CC_REVERSED as below.
1760 Several testcases will otherwise fail, for example
1761 gcc.c-torture/execute/20000217-1.c -O0 and -O1. */
1768 /* Slowly, we're converting to using attributes to control the setting
1769 of condition-code status. */
1770 switch (get_attr_cc (insn
))
1773 /* Even if it is "none", a setting may clobber a previous
1774 cc-value, so check. */
1775 if (GET_CODE (exp
) == SET
)
1777 if (cc_status
.value1
1778 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1780 cc_status
.value1
= 0;
1782 if (cc_status
.value2
1783 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1785 cc_status
.value2
= 0;
1794 /* Which means, for:
1799 CC is (reg) and (...) - unless (...) is 0, then CC does not change.
1800 CC_NO_OVERFLOW unless (...) is reg or mem.
1809 (set (reg1) (mem (bdap/biap)))
1810 (set (reg2) (bdap/biap))):
1811 CC is (reg1) and (mem (reg2))
1814 (set (mem (bdap/biap)) (reg1)) [or 0]
1815 (set (reg2) (bdap/biap))):
1818 (where reg and mem includes strict_low_parts variants thereof)
1820 For all others, assume CC is clobbered.
1821 Note that we do not have to care about setting CC_NO_OVERFLOW,
1822 since the overflow flag is set to 0 (i.e. right) for
1823 instructions where it does not have any sane sense, but where
1824 other flags have meanings. (This includes shifts; the carry is
1827 Note that there are other parallel constructs we could match,
1828 but we don't do that yet. */
1830 if (GET_CODE (exp
) == SET
)
1832 /* FIXME: Check when this happens. It looks like we should
1833 actually do a CC_STATUS_INIT here to be safe. */
1834 if (SET_DEST (exp
) == pc_rtx
)
1837 /* Record CC0 changes, so we do not have to output multiple
1839 if (SET_DEST (exp
) == cc0_rtx
)
1841 cc_status
.value1
= SET_SRC (exp
);
1842 cc_status
.value2
= 0;
1844 /* Handle flags for the special btstq on one bit. */
1845 if (GET_CODE (SET_SRC (exp
)) == ZERO_EXTRACT
1846 && XEXP (SET_SRC (exp
), 1) == const1_rtx
)
1848 if (GET_CODE (XEXP (SET_SRC (exp
), 0)) == CONST_INT
)
1850 cc_status
.flags
= CC_INVERTED
;
1852 /* A one-bit btstq. */
1853 cc_status
.flags
= CC_Z_IN_NOT_N
;
1856 cc_status
.flags
= 0;
1858 if (GET_CODE (SET_SRC (exp
)) == COMPARE
)
1860 if (!REG_P (XEXP (SET_SRC (exp
), 0))
1861 && XEXP (SET_SRC (exp
), 1) != const0_rtx
)
1862 /* For some reason gcc will not canonicalize compare
1863 operations, reversing the sign by itself if
1864 operands are in wrong order. */
1865 /* (But NOT inverted; eq is still eq.) */
1866 cc_status
.flags
= CC_REVERSED
;
1868 /* This seems to be overlooked by gcc. FIXME: Check again.
1869 FIXME: Is it really safe? */
1871 = gen_rtx_MINUS (GET_MODE (SET_SRC (exp
)),
1872 XEXP (SET_SRC (exp
), 0),
1873 XEXP (SET_SRC (exp
), 1));
1877 else if (REG_P (SET_DEST (exp
))
1878 || (GET_CODE (SET_DEST (exp
)) == STRICT_LOW_PART
1879 && REG_P (XEXP (SET_DEST (exp
), 0))))
1881 /* A register is set; normally CC is set to show that no
1882 test insn is needed. Catch the exceptions. */
1884 /* If not to cc0, then no "set"s in non-natural mode give
1886 if (GET_MODE_SIZE (GET_MODE (SET_DEST (exp
))) > UNITS_PER_WORD
1887 || GET_MODE_CLASS (GET_MODE (SET_DEST (exp
))) == MODE_FLOAT
)
1889 /* ... except add:s and sub:s in DImode. */
1890 if (GET_MODE (SET_DEST (exp
)) == DImode
1891 && (GET_CODE (SET_SRC (exp
)) == PLUS
1892 || GET_CODE (SET_SRC (exp
)) == MINUS
))
1894 cc_status
.flags
= 0;
1895 cc_status
.value1
= SET_DEST (exp
);
1896 cc_status
.value2
= SET_SRC (exp
);
1898 if (cris_reg_overlap_mentioned_p (cc_status
.value1
,
1900 cc_status
.value2
= 0;
1902 /* Add and sub may set V, which gets us
1903 unoptimizable results in "gt" and "le" condition
1905 cc_status
.flags
|= CC_NO_OVERFLOW
;
1910 else if (SET_SRC (exp
) == const0_rtx
)
1912 /* There's no CC0 change when clearing a register or
1913 memory. Just check for overlap. */
1914 if ((cc_status
.value1
1915 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1917 cc_status
.value1
= 0;
1919 if ((cc_status
.value2
1920 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1922 cc_status
.value2
= 0;
1928 cc_status
.flags
= 0;
1929 cc_status
.value1
= SET_DEST (exp
);
1930 cc_status
.value2
= SET_SRC (exp
);
1932 if (cris_reg_overlap_mentioned_p (cc_status
.value1
,
1934 cc_status
.value2
= 0;
1936 /* Some operations may set V, which gets us
1937 unoptimizable results in "gt" and "le" condition
1939 if (GET_CODE (SET_SRC (exp
)) == PLUS
1940 || GET_CODE (SET_SRC (exp
)) == MINUS
1941 || GET_CODE (SET_SRC (exp
)) == NEG
)
1942 cc_status
.flags
|= CC_NO_OVERFLOW
;
1947 else if (GET_CODE (SET_DEST (exp
)) == MEM
1948 || (GET_CODE (SET_DEST (exp
)) == STRICT_LOW_PART
1949 && GET_CODE (XEXP (SET_DEST (exp
), 0)) == MEM
))
1951 /* When SET to MEM, then CC is not changed (except for
1953 if ((cc_status
.value1
1954 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1956 cc_status
.value1
= 0;
1958 if ((cc_status
.value2
1959 && cris_reg_overlap_mentioned_p (SET_DEST (exp
),
1961 cc_status
.value2
= 0;
1966 else if (GET_CODE (exp
) == PARALLEL
)
1968 if (GET_CODE (XVECEXP (exp
, 0, 0)) == SET
1969 && GET_CODE (XVECEXP (exp
, 0, 1)) == SET
1970 && REG_P (XEXP (XVECEXP (exp
, 0, 1), 0)))
1972 if (REG_P (XEXP (XVECEXP (exp
, 0, 0), 0))
1973 && GET_CODE (XEXP (XVECEXP (exp
, 0, 0), 1)) == MEM
)
1975 /* For "move.S [rx=ry+o],rz", say CC reflects
1976 value1=rz and value2=[rx] */
1977 cc_status
.value1
= XEXP (XVECEXP (exp
, 0, 0), 0);
1979 = replace_equiv_address (XEXP (XVECEXP (exp
, 0, 0), 1),
1980 XEXP (XVECEXP (exp
, 0, 1), 0));
1981 cc_status
.flags
= 0;
1983 /* Huh? A side-effect cannot change the destination
1985 if (cris_reg_overlap_mentioned_p (cc_status
.value1
,
1987 internal_error ("internal error: sideeffect-insn affecting main effect");
1990 else if ((REG_P (XEXP (XVECEXP (exp
, 0, 0), 1))
1991 || XEXP (XVECEXP (exp
, 0, 0), 1) == const0_rtx
)
1992 && GET_CODE (XEXP (XVECEXP (exp
, 0, 0), 0)) == MEM
)
1994 /* For "move.S rz,[rx=ry+o]" and "clear.S [rx=ry+o]",
1995 say flags are not changed, except for overlap. */
1996 if (cc_status
.value1
1997 && cris_reg_overlap_mentioned_p (XEXP
2001 cc_status
.value1
= 0;
2003 if (cc_status
.value1
2004 && cris_reg_overlap_mentioned_p (XEXP
2008 cc_status
.value1
= 0;
2010 if (cc_status
.value2
2011 && cris_reg_overlap_mentioned_p (XEXP
2015 cc_status
.value2
= 0;
2017 if (cc_status
.value2
2018 && cris_reg_overlap_mentioned_p (XEXP
2022 cc_status
.value2
= 0;
2031 /* Unknown cc_attr value. */
2038 /* Return != 0 if the return sequence for the current function is short,
2039 like "ret" or "jump [sp+]". Prior to reloading, we can't tell how
2040 many registers must be saved, so return 0 then. */
2043 cris_simple_epilogue (void)
2046 int reglimit
= STACK_POINTER_REGNUM
;
2049 if (! reload_completed
2050 || frame_pointer_needed
2051 || get_frame_size () != 0
2052 || current_function_pretend_args_size
2053 || current_function_args_size
2054 || current_function_outgoing_args_size
2055 || current_function_calls_eh_return
2057 /* If we're not supposed to emit prologue and epilogue, we must
2058 not emit return-type instructions. */
2059 || !TARGET_PROLOGUE_EPILOGUE
)
2062 /* We allow a "movem [sp+],rN" to sit in front if the "jump [sp+]" or
2063 in the delay-slot of the "ret". */
2064 for (regno
= 0; regno
< reglimit
; regno
++)
2065 if ((regs_ever_live
[regno
] && ! call_used_regs
[regno
])
2066 || (regno
== (int) PIC_OFFSET_TABLE_REGNUM
2067 && (current_function_uses_pic_offset_table
2068 /* It is saved anyway, if there would be a gap. */
2070 && regs_ever_live
[regno
+ 1]
2071 && !call_used_regs
[regno
+ 1]))))
2073 if (lastreg
!= regno
- 1)
2081 /* Compute a (partial) cost for rtx X. Return true if the complete
2082 cost has been computed, and false if subexpressions should be
2083 scanned. In either case, *TOTAL contains the cost result. */
2086 cris_rtx_costs (rtx x
, int code
, int outer_code
, int *total
)
2092 HOST_WIDE_INT val
= INTVAL (x
);
2095 else if (val
< 32 && val
>= -32)
2097 /* Eight or 16 bits are a word and cycle more expensive. */
2098 else if (val
<= 32767 && val
>= -32768)
2100 /* A 32 bit constant (or very seldom, unsigned 16 bits) costs
2101 another word. FIXME: This isn't linear to 16 bits. */
2113 /* For PIC, we need a prefix (if it isn't already there),
2114 and the PIC register. For a global PIC symbol, we also
2115 need a read of the GOT. */
2118 if (cris_got_symbol (x
))
2128 if (x
!= CONST0_RTX (GET_MODE (x
) == VOIDmode
? DImode
: GET_MODE (x
)))
2131 /* Make 0.0 cheap, else test-insns will not be used. */
2136 /* Identify values that are no powers of two. Powers of 2 are
2137 taken care of already and those values should not be changed. */
2138 if (GET_CODE (XEXP (x
, 1)) != CONST_INT
2139 || exact_log2 (INTVAL (XEXP (x
, 1)) < 0))
2141 /* If we have a multiply insn, then the cost is between
2142 1 and 2 "fast" instructions. */
2143 if (TARGET_HAS_MUL_INSNS
)
2145 *total
= COSTS_N_INSNS (1) + COSTS_N_INSNS (1) / 2;
2149 /* Estimate as 4 + 4 * #ofbits. */
2150 *total
= COSTS_N_INSNS (132);
2159 if (GET_CODE (XEXP (x
, 1)) != CONST_INT
2160 || exact_log2 (INTVAL (XEXP (x
, 1)) < 0))
2162 /* Estimate this as 4 + 8 * #of bits. */
2163 *total
= COSTS_N_INSNS (260);
2169 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
2170 /* Two constants may actually happen before optimization. */
2171 && GET_CODE (XEXP (x
, 0)) != CONST_INT
2172 && !CONST_OK_FOR_LETTER_P (INTVAL (XEXP (x
, 1)), 'I'))
2174 *total
= (rtx_cost (XEXP (x
, 0), outer_code
) + 2
2175 + 2 * GET_MODE_NUNITS (GET_MODE (XEXP (x
, 0))));
2180 case ZERO_EXTEND
: case SIGN_EXTEND
:
2181 *total
= rtx_cost (XEXP (x
, 0), outer_code
);
2189 /* The ADDRESS_COST worker. */
2192 cris_address_cost (rtx x
)
2194 /* The metric to use for the cost-macros is unclear.
2195 The metric used here is (the number of cycles needed) / 2,
2196 where we consider equal a cycle for a word of code and a cycle to
2199 /* The cheapest addressing modes get 0, since nothing extra is needed. */
2200 if (BASE_OR_AUTOINCR_P (x
))
2203 /* An indirect mem must be a DIP. This means two bytes extra for code,
2204 and 4 bytes extra for memory read, i.e. (2 + 4) / 2. */
2205 if (GET_CODE (x
) == MEM
)
2208 /* Assume (2 + 4) / 2 for a single constant; a dword, since it needs
2209 an extra DIP prefix and 4 bytes of constant in most cases.
2210 For PIC and a symbol with a GOT entry, we double the cost since we
2211 add a [rPIC+...] offset. A GOT-less symbol uses a BDAP prefix
2212 equivalent to the DIP prefix for non-PIC, hence the same cost. */
2214 return flag_pic
&& cris_got_symbol (x
) ? 2 * (2 + 4) / 2 : (2 + 4) / 2;
2216 /* Handle BIAP and BDAP prefixes. */
2217 if (GET_CODE (x
) == PLUS
)
2219 rtx tem1
= XEXP (x
, 0);
2220 rtx tem2
= XEXP (x
, 1);
2222 /* A BIAP is 2 extra bytes for the prefix insn, nothing more. We
2223 recognize the typical MULT which is always in tem1 because of
2224 insn canonicalization. */
2225 if ((GET_CODE (tem1
) == MULT
&& BIAP_INDEX_P (tem1
))
2229 /* A BDAP (quick) is 2 extra bytes. Any constant operand to the
2230 PLUS is always found in tem2. */
2231 if (GET_CODE (tem2
) == CONST_INT
2232 && INTVAL (tem2
) < 128 && INTVAL (tem2
) >= -128)
2235 /* A BDAP -32768 .. 32767 is like BDAP quick, but with 2 extra
2237 if (GET_CODE (tem2
) == CONST_INT
2238 && CONST_OK_FOR_LETTER_P (INTVAL (tem2
), 'L'))
2241 /* A BDAP with some other constant is 2 bytes extra. */
2242 if (CONSTANT_P (tem2
))
2243 return (2 + 2 + 2) / 2;
2245 /* BDAP with something indirect should have a higher cost than
2246 BIAP with register. FIXME: Should it cost like a MEM or more? */
2247 /* Don't need to check it, it's the only one left.
2248 FIXME: There was a REG test missing, perhaps there are others.
2250 return (2 + 2 + 2) / 2;
2253 /* What else? Return a high cost. It matters only for valid
2254 addressing modes. */
2258 /* Check various objections to the side-effect. Used in the test-part
2259 of an anonymous insn describing an insn with a possible side-effect.
2260 Returns nonzero if the implied side-effect is ok.
2263 ops : An array of rtx:es. lreg, rreg, rval,
2264 The variables multop and other_op are indexes into this,
2265 or -1 if they are not applicable.
2266 lreg : The register that gets assigned in the side-effect.
2267 rreg : One register in the side-effect expression
2268 rval : The other register, or an int.
2269 multop : An integer to multiply rval with.
2270 other_op : One of the entities of the main effect,
2271 whose mode we must consider. */
2274 cris_side_effect_mode_ok (enum rtx_code code
, rtx
*ops
,
2275 int lreg
, int rreg
, int rval
,
2276 int multop
, int other_op
)
2278 /* Find what value to multiply with, for rx =ry + rz * n. */
2279 int mult
= multop
< 0 ? 1 : INTVAL (ops
[multop
]);
2281 rtx reg_rtx
= ops
[rreg
];
2282 rtx val_rtx
= ops
[rval
];
2284 /* The operands may be swapped. Canonicalize them in reg_rtx and
2285 val_rtx, where reg_rtx always is a reg (for this constraint to
2287 if (! BASE_P (reg_rtx
))
2288 reg_rtx
= val_rtx
, val_rtx
= ops
[rreg
];
2290 /* Don't forget to check that reg_rtx really is a reg. If it isn't,
2291 we have no business. */
2292 if (! BASE_P (reg_rtx
))
2295 /* Don't do this when -mno-split. */
2296 if (!TARGET_SIDE_EFFECT_PREFIXES
)
2299 /* The mult expression may be hidden in lreg. FIXME: Add more
2300 commentary about that. */
2301 if (GET_CODE (val_rtx
) == MULT
)
2303 mult
= INTVAL (XEXP (val_rtx
, 1));
2304 val_rtx
= XEXP (val_rtx
, 0);
2308 /* First check the "other operand". */
2311 if (GET_MODE_SIZE (GET_MODE (ops
[other_op
])) > UNITS_PER_WORD
)
2314 /* Check if the lvalue register is the same as the "other
2315 operand". If so, the result is undefined and we shouldn't do
2316 this. FIXME: Check again. */
2317 if ((BASE_P (ops
[lreg
])
2318 && BASE_P (ops
[other_op
])
2319 && REGNO (ops
[lreg
]) == REGNO (ops
[other_op
]))
2320 || rtx_equal_p (ops
[other_op
], ops
[lreg
]))
2324 /* Do not accept frame_pointer_rtx as any operand. */
2325 if (ops
[lreg
] == frame_pointer_rtx
|| ops
[rreg
] == frame_pointer_rtx
2326 || ops
[rval
] == frame_pointer_rtx
2327 || (other_op
>= 0 && ops
[other_op
] == frame_pointer_rtx
))
2331 && ! BASE_P (val_rtx
))
2334 /* Do not allow rx = rx + n if a normal add or sub with same size
2336 if (rtx_equal_p (ops
[lreg
], reg_rtx
)
2337 && GET_CODE (val_rtx
) == CONST_INT
2338 && (INTVAL (val_rtx
) <= 63 && INTVAL (val_rtx
) >= -63))
2341 /* Check allowed cases, like [r(+)?].[bwd] and const.
2342 A symbol is not allowed with PIC. */
2343 if (CONSTANT_P (val_rtx
))
2344 return flag_pic
== 0 || cris_symbol (val_rtx
) == 0;
2346 if (GET_CODE (val_rtx
) == MEM
2347 && BASE_OR_AUTOINCR_P (XEXP (val_rtx
, 0)))
2350 if (GET_CODE (val_rtx
) == SIGN_EXTEND
2351 && GET_CODE (XEXP (val_rtx
, 0)) == MEM
2352 && BASE_OR_AUTOINCR_P (XEXP (XEXP (val_rtx
, 0), 0)))
2355 /* If we got here, it's not a valid addressing mode. */
2358 else if (code
== MULT
2359 || (code
== PLUS
&& BASE_P (val_rtx
)))
2361 /* Do not allow rx = rx + ry.S, since it doesn't give better code. */
2362 if (rtx_equal_p (ops
[lreg
], reg_rtx
)
2363 || (mult
== 1 && rtx_equal_p (ops
[lreg
], val_rtx
)))
2366 /* Do not allow bad multiply-values. */
2367 if (mult
!= 1 && mult
!= 2 && mult
!= 4)
2370 /* Only allow r + ... */
2371 if (! BASE_P (reg_rtx
))
2374 /* If we got here, all seems ok.
2375 (All checks need to be done above). */
2379 /* If we get here, the caller got its initial tests wrong. */
2380 internal_error ("internal error: cris_side_effect_mode_ok with bad operands");
2383 /* The function reg_overlap_mentioned_p in CVS (still as of 2001-05-16)
2384 does not handle the case where the IN operand is strict_low_part; it
2385 does handle it for X. Test-case in Axis-20010516. This function takes
2386 care of that for THIS port. FIXME: strict_low_part is going away
2390 cris_reg_overlap_mentioned_p (rtx x
, rtx in
)
2392 /* The function reg_overlap_mentioned now handles when X is
2393 strict_low_part, but not when IN is a STRICT_LOW_PART. */
2394 if (GET_CODE (in
) == STRICT_LOW_PART
)
2397 return reg_overlap_mentioned_p (x
, in
);
2400 /* The TARGET_ASM_NAMED_SECTION worker.
2401 We just dispatch to the functions for ELF and a.out. */
2404 cris_target_asm_named_section (const char *name
, unsigned int flags
)
2407 default_no_named_section (name
, flags
);
2409 default_elf_asm_named_section (name
, flags
);
2412 /* The LEGITIMATE_PIC_OPERAND_P worker. */
2415 cris_legitimate_pic_operand (rtx x
)
2417 /* The PIC representation of a symbol with a GOT entry will be (for
2418 example; relocations differ):
2419 sym => [rPIC+sym:GOT]
2420 and for a GOT-less symbol it will be (for example, relocation differ):
2421 sym => rPIC+sym:GOTOFF
2422 so only a symbol with a GOT is by itself a valid operand, and it
2423 can't be a sum of a symbol and an offset. */
2424 return ! cris_symbol (x
) || cris_got_symbol (x
);
2427 /* Return nonzero if there's a SYMBOL_REF or LABEL_REF hiding inside this
2433 switch (GET_CODE (x
))
2440 /* A PLT reference. */
2441 ASSERT_PLT_UNSPEC (x
);
2445 return cris_symbol (XEXP (x
, 0));
2449 return cris_symbol (XEXP (x
, 0)) || cris_symbol (XEXP (x
, 1));
2453 case CONSTANT_P_RTX
:
2457 fatal_insn ("unrecognized supposed constant", x
);
2463 /* Return nonzero if there's a SYMBOL_REF or LABEL_REF hiding inside this
2464 CONSTANT_P, and the symbol does not need a GOT entry. Also set
2465 current_function_uses_pic_offset_table if we're generating PIC and ever
2466 see something that would need one. */
2469 cris_gotless_symbol (rtx x
)
2471 #ifdef ENABLE_CHECKING
2476 switch (GET_CODE (x
))
2479 ASSERT_PLT_UNSPEC (x
);
2484 current_function_uses_pic_offset_table
= 1;
2485 return SYMBOL_REF_LOCAL_P (x
);
2488 /* We don't set current_function_uses_pic_offset_table for
2489 LABEL_REF:s in here, since they are almost always originating
2490 from some branch. The only time it does not come from a label is
2491 when GCC does something like __builtin_setjmp. Then we get the
2492 LABEL_REF from the movsi expander, so we mark it there as a
2497 return cris_gotless_symbol (XEXP (x
, 0));
2502 int x0
= cris_gotless_symbol (XEXP (x
, 0)) != 0;
2503 int x1
= cris_gotless_symbol (XEXP (x
, 1)) != 0;
2505 /* One and only one of them must be a local symbol. Neither must
2506 be some other, more general kind of symbol. */
2509 && ! (x0
== 0 && cris_symbol (XEXP (x
, 0)))
2510 && ! (x1
== 0 && cris_symbol (XEXP (x
, 1)));
2515 case CONSTANT_P_RTX
:
2519 fatal_insn ("unrecognized supposed constant", x
);
2525 /* Return nonzero if there's a SYMBOL_REF or LABEL_REF hiding inside this
2526 CONSTANT_P, and the symbol needs a GOT entry. */
2529 cris_got_symbol (rtx x
)
2531 #ifdef ENABLE_CHECKING
2536 switch (GET_CODE (x
))
2539 ASSERT_PLT_UNSPEC (x
);
2544 current_function_uses_pic_offset_table
= 1;
2545 return ! SYMBOL_REF_LOCAL_P (x
);
2548 return cris_got_symbol (XEXP (x
, 0));
2551 /* A LABEL_REF is never visible as a symbol outside the local
2555 /* Nope, can't access the GOT for "symbol + offset". */
2560 case CONSTANT_P_RTX
:
2564 fatal_insn ("unrecognized supposed constant in cris_global_pic_symbol",
2571 /* The OVERRIDE_OPTIONS worker.
2572 As is the norm, this also parses -mfoo=bar type parameters. */
2575 cris_override_options (void)
2577 if (cris_max_stackframe_str
)
2579 cris_max_stackframe
= atoi (cris_max_stackframe_str
);
2581 /* Do some sanity checking. */
2582 if (cris_max_stackframe
< 0 || cris_max_stackframe
> 0x20000000)
2583 internal_error ("-max-stackframe=%d is not usable, not between 0 and %d",
2584 cris_max_stackframe
, 0x20000000);
2587 /* Let "-metrax4" and "-metrax100" change the cpu version. */
2588 if (TARGET_SVINTO
&& cris_cpu_version
< CRIS_CPU_SVINTO
)
2589 cris_cpu_version
= CRIS_CPU_SVINTO
;
2590 else if (TARGET_ETRAX4_ADD
&& cris_cpu_version
< CRIS_CPU_ETRAX4
)
2591 cris_cpu_version
= CRIS_CPU_ETRAX4
;
2593 /* Parse -march=... and its synonym, the deprecated -mcpu=... */
2597 = (*cris_cpu_str
== 'v' ? atoi (cris_cpu_str
+ 1) : -1);
2599 if (strcmp ("etrax4", cris_cpu_str
) == 0)
2600 cris_cpu_version
= 3;
2602 if (strcmp ("svinto", cris_cpu_str
) == 0
2603 || strcmp ("etrax100", cris_cpu_str
) == 0)
2604 cris_cpu_version
= 8;
2606 if (strcmp ("ng", cris_cpu_str
) == 0
2607 || strcmp ("etrax100lx", cris_cpu_str
) == 0)
2608 cris_cpu_version
= 10;
2610 if (cris_cpu_version
< 0 || cris_cpu_version
> 10)
2611 error ("unknown CRIS version specification in -march= or -mcpu= : %s",
2614 /* Set the target flags. */
2615 if (cris_cpu_version
>= CRIS_CPU_ETRAX4
)
2616 target_flags
|= TARGET_MASK_ETRAX4_ADD
;
2618 /* If this is Svinto or higher, align for 32 bit accesses. */
2619 if (cris_cpu_version
>= CRIS_CPU_SVINTO
)
2621 |= (TARGET_MASK_SVINTO
| TARGET_MASK_ALIGN_BY_32
2622 | TARGET_MASK_STACK_ALIGN
| TARGET_MASK_CONST_ALIGN
2623 | TARGET_MASK_DATA_ALIGN
);
2625 /* Note that we do not add new flags when it can be completely
2626 described with a macro that uses -mcpu=X. So
2627 TARGET_HAS_MUL_INSNS is (cris_cpu_version >= CRIS_CPU_NG). */
2633 = (*cris_tune_str
== 'v' ? atoi (cris_tune_str
+ 1) : -1);
2635 if (strcmp ("etrax4", cris_tune_str
) == 0)
2638 if (strcmp ("svinto", cris_tune_str
) == 0
2639 || strcmp ("etrax100", cris_tune_str
) == 0)
2642 if (strcmp ("ng", cris_tune_str
) == 0
2643 || strcmp ("etrax100lx", cris_tune_str
) == 0)
2646 if (cris_tune
< 0 || cris_tune
> 10)
2647 error ("unknown CRIS cpu version specification in -mtune= : %s",
2650 if (cris_tune
>= CRIS_CPU_SVINTO
)
2651 /* We have currently nothing more to tune than alignment for
2654 |= (TARGET_MASK_STACK_ALIGN
| TARGET_MASK_CONST_ALIGN
2655 | TARGET_MASK_DATA_ALIGN
| TARGET_MASK_ALIGN_BY_32
);
2660 /* Use error rather than warning, so invalid use is easily
2661 detectable. Still change to the values we expect, to avoid
2665 error ("-fPIC and -fpic are not supported in this configuration");
2669 /* Turn off function CSE. We need to have the addresses reach the
2670 call expanders to get PLT-marked, as they could otherwise be
2671 compared against zero directly or indirectly. After visiting the
2672 call expanders they will then be cse:ed, as the call expanders
2673 force_reg the addresses, effectively forcing flag_no_function_cse
2675 flag_no_function_cse
= 1;
2678 if ((write_symbols
== DWARF_DEBUG
2679 || write_symbols
== DWARF2_DEBUG
) && ! TARGET_ELF
)
2681 warning ("that particular -g option is invalid with -maout and -melinux");
2682 write_symbols
= DBX_DEBUG
;
2685 /* Set the per-function-data initializer. */
2686 init_machine_status
= cris_init_machine_status
;
2689 /* The TARGET_ASM_OUTPUT_MI_THUNK worker. */
2692 cris_asm_output_mi_thunk (FILE *stream
,
2693 tree thunkdecl ATTRIBUTE_UNUSED
,
2694 HOST_WIDE_INT delta
,
2695 HOST_WIDE_INT vcall_offset ATTRIBUTE_UNUSED
,
2699 fprintf (stream
, "\tadd%s " HOST_WIDE_INT_PRINT_DEC
",$%s\n",
2700 ADDITIVE_SIZE_MODIFIER (delta
), delta
,
2701 reg_names
[CRIS_FIRST_ARG_REG
]);
2703 fprintf (stream
, "\tsub%s " HOST_WIDE_INT_PRINT_DEC
",$%s\n",
2704 ADDITIVE_SIZE_MODIFIER (-delta
), -delta
,
2705 reg_names
[CRIS_FIRST_ARG_REG
]);
2709 const char *name
= XSTR (XEXP (DECL_RTL (funcdecl
), 0), 0);
2711 name
= (* targetm
.strip_name_encoding
) (name
);
2712 fprintf (stream
, "add.d ");
2713 assemble_name (stream
, name
);
2714 fprintf (stream
, "%s,$pc\n", CRIS_PLT_PCOFFSET_SUFFIX
);
2718 fprintf (stream
, "jump ");
2719 assemble_name (stream
, XSTR (XEXP (DECL_RTL (funcdecl
), 0), 0));
2720 fprintf (stream
, "\n");
2724 /* Boilerplate emitted at start of file.
2726 NO_APP *only at file start* means faster assembly. It also means
2727 comments are not allowed. In some cases comments will be output
2728 for debugging purposes. Make sure they are allowed then.
2730 We want a .file directive only if TARGET_ELF. */
2732 cris_file_start (void)
2734 /* These expressions can vary at run time, so we cannot put
2735 them into TARGET_INITIALIZER. */
2736 targetm
.file_start_app_off
= !(TARGET_PDEBUG
|| flag_print_asm_name
);
2737 targetm
.file_start_file_directive
= TARGET_ELF
;
2739 default_file_start ();
2742 /* Rename the function calls for integer multiply and divide. */
2744 cris_init_libfuncs (void)
2746 set_optab_libfunc (smul_optab
, SImode
, "__Mul");
2747 set_optab_libfunc (sdiv_optab
, SImode
, "__Div");
2748 set_optab_libfunc (udiv_optab
, SImode
, "__Udiv");
2749 set_optab_libfunc (smod_optab
, SImode
, "__Mod");
2750 set_optab_libfunc (umod_optab
, SImode
, "__Umod");
2753 /* The EXPAND_BUILTIN_VA_ARG worker. This is modified from the
2754 "standard" implementation of va_arg: read the value from the current
2755 address and increment by the size of one or two registers. The
2756 important difference for CRIS is that if the type is
2757 pass-by-reference, then perform an indirection. */
2760 cris_expand_builtin_va_arg (tree valist
, tree type
)
2764 tree passed_size
= size_zero_node
;
2765 tree type_size
= NULL
;
2766 tree size3
= size_int (3);
2767 tree size4
= size_int (4);
2768 tree size8
= size_int (8);
2774 if (type
== error_mark_node
2775 || (type_size
= TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type
))) == NULL
2776 || TREE_OVERFLOW (type_size
))
2777 /* Presumably an error; the size isn't computable. A message has
2778 supposedly been emitted elsewhere. */
2779 rounded_size
= size_zero_node
;
2782 = fold (build (MULT_EXPR
, sizetype
,
2783 fold (build (TRUNC_DIV_EXPR
, sizetype
,
2784 fold (build (PLUS_EXPR
, sizetype
,
2789 if (!integer_zerop (rounded_size
))
2791 /* Check if the type is passed by value or by reference. Values up
2792 to 8 bytes are passed by-value, padded to register-size (4
2793 bytes). Larger values and varying-size types are passed
2796 = (!really_constant_p (type_size
)
2798 : fold (build (COND_EXPR
, sizetype
,
2799 fold (build (GT_EXPR
, sizetype
,
2806 = (!really_constant_p (type_size
)
2807 ? build1 (INDIRECT_REF
, build_pointer_type (type
), addr_tree
)
2808 : fold (build (COND_EXPR
, TREE_TYPE (addr_tree
),
2809 fold (build (GT_EXPR
, sizetype
,
2812 build1 (INDIRECT_REF
, build_pointer_type (type
),
2817 addr
= expand_expr (addr_tree
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
2818 addr
= copy_to_reg (addr
);
2820 if (!integer_zerop (rounded_size
))
2822 /* Compute new value for AP. */
2823 t
= build (MODIFY_EXPR
, TREE_TYPE (valist
), valist
,
2824 build (PLUS_EXPR
, TREE_TYPE (valist
), valist
,
2826 TREE_SIDE_EFFECTS (t
) = 1;
2827 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2833 /* The INIT_EXPANDERS worker sets the per-function-data initializer and
2837 cris_init_expanders (void)
2839 /* Nothing here at the moment. */
2842 /* Zero initialization is OK for all current fields. */
2844 static struct machine_function
*
2845 cris_init_machine_status (void)
2847 return ggc_alloc_cleared (sizeof (struct machine_function
));
2850 /* Split a 2 word move (DI or presumably DF) into component parts.
2851 Originally a copy of gen_split_move_double in m32r.c. */
2854 cris_split_movdx (rtx
*operands
)
2856 enum machine_mode mode
= GET_MODE (operands
[0]);
2857 rtx dest
= operands
[0];
2858 rtx src
= operands
[1];
2861 /* We used to have to handle (SUBREG (MEM)) here, but that should no
2862 longer happen; after reload there are no SUBREGs any more, and we're
2863 only called after reload. */
2864 if (GET_CODE (dest
) == SUBREG
|| GET_CODE (src
) == SUBREG
)
2868 if (GET_CODE (dest
) == REG
)
2870 int dregno
= REGNO (dest
);
2872 /* Reg-to-reg copy. */
2873 if (GET_CODE (src
) == REG
)
2875 int sregno
= REGNO (src
);
2877 int reverse
= (dregno
== sregno
+ 1);
2879 /* We normally copy the low-numbered register first. However, if
2880 the first register operand 0 is the same as the second register of
2881 operand 1, we must copy in the opposite order. */
2882 emit_insn (gen_rtx_SET (VOIDmode
,
2883 operand_subword (dest
, reverse
, TRUE
, mode
),
2884 operand_subword (src
, reverse
, TRUE
, mode
)));
2886 emit_insn (gen_rtx_SET (VOIDmode
,
2887 operand_subword (dest
, !reverse
, TRUE
, mode
),
2888 operand_subword (src
, !reverse
, TRUE
, mode
)));
2890 /* Constant-to-reg copy. */
2891 else if (GET_CODE (src
) == CONST_INT
|| GET_CODE (src
) == CONST_DOUBLE
)
2894 split_double (src
, &words
[0], &words
[1]);
2895 emit_insn (gen_rtx_SET (VOIDmode
,
2896 operand_subword (dest
, 0, TRUE
, mode
),
2899 emit_insn (gen_rtx_SET (VOIDmode
,
2900 operand_subword (dest
, 1, TRUE
, mode
),
2903 /* Mem-to-reg copy. */
2904 else if (GET_CODE (src
) == MEM
)
2906 /* If the high-address word is used in the address, we must load it
2907 last. Otherwise, load it first. */
2908 rtx addr
= XEXP (src
, 0);
2910 = (refers_to_regno_p (dregno
, dregno
+ 1, addr
, NULL
) != 0);
2912 /* The original code imples that we can't do
2913 move.x [rN+],rM move.x [rN],rM+1
2914 when rN is dead, because of REG_NOTES damage. That is
2915 consistent with what I've seen, so don't try it.
2917 We have two different cases here; if the addr is POST_INC,
2918 just pass it through, otherwise add constants. */
2920 if (GET_CODE (addr
) == POST_INC
)
2922 emit_insn (gen_rtx_SET (VOIDmode
,
2923 operand_subword (dest
, 0, TRUE
, mode
),
2924 change_address (src
, SImode
, addr
)));
2925 emit_insn (gen_rtx_SET (VOIDmode
,
2926 operand_subword (dest
, 1, TRUE
, mode
),
2927 change_address (src
, SImode
, addr
)));
2931 /* Make sure we don't get any other addresses with
2932 embedded postincrements. They should be stopped in
2933 GO_IF_LEGITIMATE_ADDRESS, but we're here for your
2935 if (side_effects_p (addr
))
2936 fatal_insn ("unexpected side-effects in address", addr
);
2938 emit_insn (gen_rtx_SET
2940 operand_subword (dest
, reverse
, TRUE
, mode
),
2943 plus_constant (addr
,
2944 reverse
* UNITS_PER_WORD
))));
2945 emit_insn (gen_rtx_SET
2947 operand_subword (dest
, ! reverse
, TRUE
, mode
),
2950 plus_constant (addr
,
2958 /* Reg-to-mem copy or clear mem. */
2959 else if (GET_CODE (dest
) == MEM
2960 && (GET_CODE (src
) == REG
2961 || src
== const0_rtx
2962 || src
== CONST0_RTX (DFmode
)))
2964 rtx addr
= XEXP (dest
, 0);
2966 if (GET_CODE (addr
) == POST_INC
)
2968 emit_insn (gen_rtx_SET (VOIDmode
,
2969 change_address (dest
, SImode
, addr
),
2970 operand_subword (src
, 0, TRUE
, mode
)));
2971 emit_insn (gen_rtx_SET (VOIDmode
,
2972 change_address (dest
, SImode
, addr
),
2973 operand_subword (src
, 1, TRUE
, mode
)));
2977 /* Make sure we don't get any other addresses with embedded
2978 postincrements. They should be stopped in
2979 GO_IF_LEGITIMATE_ADDRESS, but we're here for your safety. */
2980 if (side_effects_p (addr
))
2981 fatal_insn ("unexpected side-effects in address", addr
);
2983 emit_insn (gen_rtx_SET
2985 change_address (dest
, SImode
, addr
),
2986 operand_subword (src
, 0, TRUE
, mode
)));
2988 emit_insn (gen_rtx_SET
2990 change_address (dest
, SImode
,
2991 plus_constant (addr
,
2993 operand_subword (src
, 1, TRUE
, mode
)));
3005 /* This is in essence a copy of output_addr_const altered to output
3006 symbolic operands as PIC.
3008 FIXME: Add hooks similar to ASM_OUTPUT_SYMBOL_REF to get this effect in
3009 the "real" output_addr_const. All we need is one for LABEL_REF (and
3010 one for CODE_LABEL?). */
3013 cris_output_addr_const (FILE *file
, rtx x
)
3018 switch (GET_CODE (x
))
3021 ASSERT_PLT_UNSPEC (x
);
3022 x
= XVECEXP (x
, 0, 0);
3029 const char *origstr
= XSTR (x
, 0);
3032 str
= (* targetm
.strip_name_encoding
) (origstr
);
3036 if (cris_pic_sympart_only
)
3038 assemble_name (file
, str
);
3039 fprintf (file
, ":PLTG");
3043 if (TARGET_AVOID_GOTPLT
)
3044 /* We shouldn't get here. */
3047 fprintf (file
, "[$%s+", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
3048 assemble_name (file
, XSTR (x
, 0));
3051 fprintf (file
, ":GOTPLT16]");
3053 fprintf (file
, ":GOTPLT]");
3056 else if (cris_gotless_symbol (x
))
3058 if (! cris_pic_sympart_only
)
3059 fprintf (file
, "$%s+", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
3060 assemble_name (file
, str
);
3061 fprintf (file
, ":GOTOFF");
3063 else if (cris_got_symbol (x
))
3065 if (cris_pic_sympart_only
)
3067 fprintf (file
, "[$%s+", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
3068 assemble_name (file
, XSTR (x
, 0));
3071 fprintf (file
, ":GOT16]");
3073 fprintf (file
, ":GOT]");
3076 LOSE_AND_RETURN ("unexpected PIC symbol", x
);
3079 if (! current_function_uses_pic_offset_table
)
3080 output_operand_lossage ("PIC register isn't set up");
3083 assemble_name (file
, XSTR (x
, 0));
3087 /* If we get one of those here, it should be dressed as PIC. Branch
3088 labels are normally output with the 'l' specifier, which means it
3089 will go directly to output_asm_label and not end up here. */
3090 if (GET_CODE (XEXP (x
, 0)) != CODE_LABEL
3091 && (GET_CODE (XEXP (x
, 0)) != NOTE
3092 || NOTE_LINE_NUMBER (XEXP (x
, 0)) != NOTE_INSN_DELETED_LABEL
))
3093 fatal_insn ("unexpected address expression", x
);
3097 if (cris_gotless_symbol (x
))
3099 if (! cris_pic_sympart_only
)
3100 fprintf (file
, "$%s+", reg_names
[PIC_OFFSET_TABLE_REGNUM
]);
3101 cris_output_addr_const (file
, XEXP (x
, 0));
3103 fprintf (file
, ":GOTOFF");
3106 /* Labels are never marked as global symbols. */
3107 fatal_insn ("unexpected PIC symbol", x
);
3110 if (! current_function_uses_pic_offset_table
)
3111 internal_error ("emitting PIC operand, but PIC register isn't set up");
3115 output_addr_const (file
, x
);
3119 if (NOTE_LINE_NUMBER (x
) != NOTE_INSN_DELETED_LABEL
)
3120 fatal_insn ("unexpected NOTE as addr_const:", x
);
3126 output_addr_const (file
, x
);
3130 /* This used to output parentheses around the expression,
3131 but that does not work on the 386 (either ATT or BSD assembler). */
3132 cris_output_addr_const (file
, XEXP (x
, 0));
3136 /* Some assemblers need integer constants to appear last (eg masm). */
3137 if (GET_CODE (XEXP (x
, 0)) == CONST_INT
)
3139 cris_output_addr_const (file
, XEXP (x
, 1));
3140 if (INTVAL (XEXP (x
, 0)) >= 0)
3141 fprintf (file
, "+");
3142 output_addr_const (file
, XEXP (x
, 0));
3146 cris_output_addr_const (file
, XEXP (x
, 0));
3147 if (GET_CODE (XEXP (x
, 1)) != CONST_INT
3148 || INTVAL (XEXP (x
, 1)) >= 0)
3149 fprintf (file
, "+");
3150 cris_output_addr_const (file
, XEXP (x
, 1));
3155 /* Avoid outputting things like x-x or x+5-x,
3156 since some assemblers can't handle that. */
3157 x
= simplify_subtraction (x
);
3158 if (GET_CODE (x
) != MINUS
)
3161 cris_output_addr_const (file
, XEXP (x
, 0));
3162 fprintf (file
, "-");
3163 if ((GET_CODE (XEXP (x
, 1)) == CONST_INT
3164 && INTVAL (XEXP (x
, 1)) < 0)
3165 || GET_CODE (XEXP (x
, 1)) != CONST_INT
)
3167 fprintf (file
, "%s", targetm
.asm_out
.open_paren
);
3168 cris_output_addr_const (file
, XEXP (x
, 1));
3169 fprintf (file
, "%s", targetm
.asm_out
.close_paren
);
3172 output_addr_const (file
, XEXP (x
, 1));
3176 LOSE_AND_RETURN ("unexpected address expression", x
);
3181 /* Various small functions to replace macros. Only called from a
3182 debugger. They might collide with gcc functions or system functions,
3183 so only emit them when '#if 1' above. */
3185 enum rtx_code
Get_code (rtx
);
3190 return GET_CODE (x
);
3193 const char *Get_mode (rtx
);
3198 return GET_MODE_NAME (GET_MODE (x
));
3201 rtx
Xexp (rtx
, int);
3209 rtx
Xvecexp (rtx
, int, int);
3212 Xvecexp (rtx x
, int n
, int m
)
3214 return XVECEXP (x
, n
, m
);
3217 int Get_rtx_len (rtx
);
3222 return GET_RTX_LENGTH (GET_CODE (x
));
3225 /* Use upper-case to distinguish from local variables that are sometimes
3226 called next_insn and prev_insn. */
3228 rtx
Next_insn (rtx
);
3231 Next_insn (rtx insn
)
3233 return NEXT_INSN (insn
);
3236 rtx
Prev_insn (rtx
);
3239 Prev_insn (rtx insn
)
3241 return PREV_INSN (insn
);
3245 #include "gt-cris.h"
3249 * eval: (c-set-style "gnu")
3250 * indent-tabs-mode: t