1 /* Copyright (C) 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007
2 Free Software Foundation, Inc.
3 Contributed by Red Hat, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
28 #include "hard-reg-set.h"
30 #include "insn-config.h"
31 #include "conditions.h"
32 #include "insn-flags.h"
34 #include "insn-attr.h"
44 #include "basic-block.h"
49 #include "target-def.h"
50 #include "targhooks.h"
51 #include "integrate.h"
52 #include "langhooks.h"
56 #define FRV_INLINE inline
59 /* The maximum number of distinct NOP patterns. There are three:
60 nop, fnop and mnop. */
61 #define NUM_NOP_PATTERNS 3
63 /* Classification of instructions and units: integer, floating-point/media,
64 branch and control. */
65 enum frv_insn_group
{ GROUP_I
, GROUP_FM
, GROUP_B
, GROUP_C
, NUM_GROUPS
};
67 /* The DFA names of the units, in packet order. */
68 static const char *const frv_unit_names
[] =
78 /* The classification of each unit in frv_unit_names[]. */
79 static const enum frv_insn_group frv_unit_groups
[ARRAY_SIZE (frv_unit_names
)] =
89 /* Return the DFA unit code associated with the Nth unit of integer
90 or floating-point group GROUP, */
91 #define NTH_UNIT(GROUP, N) frv_unit_codes[(GROUP) + (N) * 2 + 1]
93 /* Return the number of integer or floating-point unit UNIT
94 (1 for I1, 2 for F2, etc.). */
95 #define UNIT_NUMBER(UNIT) (((UNIT) - 1) / 2)
97 /* The DFA unit number for each unit in frv_unit_names[]. */
98 static int frv_unit_codes
[ARRAY_SIZE (frv_unit_names
)];
100 /* FRV_TYPE_TO_UNIT[T] is the last unit in frv_unit_names[] that can issue
101 an instruction of type T. The value is ARRAY_SIZE (frv_unit_names) if
102 no instruction of type T has been seen. */
103 static unsigned int frv_type_to_unit
[TYPE_UNKNOWN
+ 1];
105 /* An array of dummy nop INSNs, one for each type of nop that the
107 static GTY(()) rtx frv_nops
[NUM_NOP_PATTERNS
];
109 /* The number of nop instructions in frv_nops[]. */
110 static unsigned int frv_num_nops
;
112 /* Information about one __builtin_read or __builtin_write access, or
113 the combination of several such accesses. The most general value
114 is all-zeros (an unknown access to an unknown address). */
116 /* The type of access. FRV_IO_UNKNOWN means the access can be either
117 a read or a write. */
118 enum { FRV_IO_UNKNOWN
, FRV_IO_READ
, FRV_IO_WRITE
} type
;
120 /* The constant address being accessed, or zero if not known. */
121 HOST_WIDE_INT const_address
;
123 /* The run-time address, as used in operand 0 of the membar pattern. */
127 /* Return true if instruction INSN should be packed with the following
129 #define PACKING_FLAG_P(INSN) (GET_MODE (INSN) == TImode)
131 /* Set the value of PACKING_FLAG_P(INSN). */
132 #define SET_PACKING_FLAG(INSN) PUT_MODE (INSN, TImode)
133 #define CLEAR_PACKING_FLAG(INSN) PUT_MODE (INSN, VOIDmode)
135 /* Loop with REG set to each hard register in rtx X. */
136 #define FOR_EACH_REGNO(REG, X) \
137 for (REG = REGNO (X); \
138 REG < REGNO (X) + HARD_REGNO_NREGS (REGNO (X), GET_MODE (X)); \
141 /* This structure contains machine specific function data. */
142 struct machine_function
GTY(())
144 /* True if we have created an rtx that relies on the stack frame. */
147 /* True if this function contains at least one __builtin_{read,write}*. */
151 /* Temporary register allocation support structure. */
152 typedef struct frv_tmp_reg_struct
154 HARD_REG_SET regs
; /* possible registers to allocate */
155 int next_reg
[N_REG_CLASSES
]; /* next register to allocate per class */
159 /* Register state information for VLIW re-packing phase. */
160 #define REGSTATE_CC_MASK 0x07 /* Mask to isolate CCn for cond exec */
161 #define REGSTATE_MODIFIED 0x08 /* reg modified in current VLIW insn */
162 #define REGSTATE_IF_TRUE 0x10 /* reg modified in cond exec true */
163 #define REGSTATE_IF_FALSE 0x20 /* reg modified in cond exec false */
165 #define REGSTATE_IF_EITHER (REGSTATE_IF_TRUE | REGSTATE_IF_FALSE)
167 typedef unsigned char regstate_t
;
169 /* Used in frv_frame_accessor_t to indicate the direction of a register-to-
177 /* Information required by frv_frame_access. */
180 /* This field is FRV_LOAD if registers are to be loaded from the stack and
181 FRV_STORE if they should be stored onto the stack. FRV_STORE implies
182 the move is being done by the prologue code while FRV_LOAD implies it
183 is being done by the epilogue. */
184 enum frv_stack_op op
;
186 /* The base register to use when accessing the stack. This may be the
187 frame pointer, stack pointer, or a temporary. The choice of register
188 depends on which part of the frame is being accessed and how big the
192 /* The offset of BASE from the bottom of the current frame, in bytes. */
194 } frv_frame_accessor_t
;
196 /* Define the information needed to generate branch and scc insns. This is
197 stored from the compare operation. */
201 /* Conditional execution support gathered together in one structure. */
204 /* Linked list of insns to add if the conditional execution conversion was
205 successful. Each link points to an EXPR_LIST which points to the pattern
206 of the insn to add, and the insn to be inserted before. */
207 rtx added_insns_list
;
209 /* Identify which registers are safe to allocate for if conversions to
210 conditional execution. We keep the last allocated register in the
211 register classes between COND_EXEC statements. This will mean we allocate
212 different registers for each different COND_EXEC group if we can. This
213 might allow the scheduler to intermix two different COND_EXEC sections. */
214 frv_tmp_reg_t tmp_reg
;
216 /* For nested IFs, identify which CC registers are used outside of setting
217 via a compare isnsn, and using via a check insn. This will allow us to
218 know if we can rewrite the register to use a different register that will
219 be paired with the CR register controlling the nested IF-THEN blocks. */
220 HARD_REG_SET nested_cc_ok_rewrite
;
222 /* Temporary registers allocated to hold constants during conditional
224 rtx scratch_regs
[FIRST_PSEUDO_REGISTER
];
226 /* Current number of temp registers available. */
227 int cur_scratch_regs
;
229 /* Number of nested conditional execution blocks. */
230 int num_nested_cond_exec
;
232 /* Map of insns that set up constants in scratch registers. */
233 bitmap scratch_insns_bitmap
;
235 /* Conditional execution test register (CC0..CC7). */
238 /* Conditional execution compare register that is paired with cr_reg, so that
239 nested compares can be done. The csubcc and caddcc instructions don't
240 have enough bits to specify both a CC register to be set and a CR register
241 to do the test on, so the same bit number is used for both. Needless to
242 say, this is rather inconvenient for GCC. */
245 /* Extra CR registers used for &&, ||. */
249 /* Previous CR used in nested if, to make sure we are dealing with the same
250 nested if as the previous statement. */
251 rtx last_nested_if_cr
;
255 static /* GTY(()) */ frv_ifcvt_t frv_ifcvt
;
257 /* Map register number to smallest register class. */
258 enum reg_class regno_reg_class
[FIRST_PSEUDO_REGISTER
];
260 /* Map class letter into register class. */
261 enum reg_class reg_class_from_letter
[256];
263 /* Cached value of frv_stack_info. */
264 static frv_stack_t
*frv_stack_cache
= (frv_stack_t
*)0;
267 frv_cpu_t frv_cpu_type
= CPU_TYPE
; /* value of -mcpu= */
269 /* Forward references */
271 static bool frv_handle_option (size_t, const char *, int);
272 static int frv_default_flags_for_cpu (void);
273 static int frv_string_begins_with (tree
, const char *);
274 static FRV_INLINE
bool frv_small_data_reloc_p (rtx
, int);
275 static void frv_print_operand_memory_reference_reg
277 static void frv_print_operand_memory_reference (FILE *, rtx
, int);
278 static int frv_print_operand_jump_hint (rtx
);
279 static const char *comparison_string (enum rtx_code
, rtx
);
280 static FRV_INLINE
int frv_regno_ok_for_base_p (int, int);
281 static rtx
single_set_pattern (rtx
);
282 static int frv_function_contains_far_jump (void);
283 static rtx
frv_alloc_temp_reg (frv_tmp_reg_t
*,
287 static rtx
frv_frame_offset_rtx (int);
288 static rtx
frv_frame_mem (enum machine_mode
, rtx
, int);
289 static rtx
frv_dwarf_store (rtx
, int);
290 static void frv_frame_insn (rtx
, rtx
);
291 static void frv_frame_access (frv_frame_accessor_t
*,
293 static void frv_frame_access_multi (frv_frame_accessor_t
*,
295 static void frv_frame_access_standard_regs (enum frv_stack_op
,
297 static struct machine_function
*frv_init_machine_status (void);
298 static rtx
frv_int_to_acc (enum insn_code
, int, rtx
);
299 static enum machine_mode
frv_matching_accg_mode (enum machine_mode
);
300 static rtx
frv_read_argument (tree
, unsigned int);
301 static rtx
frv_read_iacc_argument (enum machine_mode
, tree
, unsigned int);
302 static int frv_check_constant_argument (enum insn_code
, int, rtx
);
303 static rtx
frv_legitimize_target (enum insn_code
, rtx
);
304 static rtx
frv_legitimize_argument (enum insn_code
, int, rtx
);
305 static rtx
frv_legitimize_tls_address (rtx
, enum tls_model
);
306 static rtx
frv_expand_set_builtin (enum insn_code
, tree
, rtx
);
307 static rtx
frv_expand_unop_builtin (enum insn_code
, tree
, rtx
);
308 static rtx
frv_expand_binop_builtin (enum insn_code
, tree
, rtx
);
309 static rtx
frv_expand_cut_builtin (enum insn_code
, tree
, rtx
);
310 static rtx
frv_expand_binopimm_builtin (enum insn_code
, tree
, rtx
);
311 static rtx
frv_expand_voidbinop_builtin (enum insn_code
, tree
);
312 static rtx
frv_expand_int_void2arg (enum insn_code
, tree
);
313 static rtx
frv_expand_prefetches (enum insn_code
, tree
);
314 static rtx
frv_expand_voidtriop_builtin (enum insn_code
, tree
);
315 static rtx
frv_expand_voidaccop_builtin (enum insn_code
, tree
);
316 static rtx
frv_expand_mclracc_builtin (tree
);
317 static rtx
frv_expand_mrdacc_builtin (enum insn_code
, tree
);
318 static rtx
frv_expand_mwtacc_builtin (enum insn_code
, tree
);
319 static rtx
frv_expand_noargs_builtin (enum insn_code
);
320 static void frv_split_iacc_move (rtx
, rtx
);
321 static rtx
frv_emit_comparison (enum rtx_code
, rtx
, rtx
);
322 static int frv_clear_registers_used (rtx
*, void *);
323 static void frv_ifcvt_add_insn (rtx
, rtx
, int);
324 static rtx
frv_ifcvt_rewrite_mem (rtx
, enum machine_mode
, rtx
);
325 static rtx
frv_ifcvt_load_value (rtx
, rtx
);
326 static int frv_acc_group_1 (rtx
*, void *);
327 static unsigned int frv_insn_unit (rtx
);
328 static bool frv_issues_to_branch_unit_p (rtx
);
329 static int frv_cond_flags (rtx
);
330 static bool frv_regstate_conflict_p (regstate_t
, regstate_t
);
331 static int frv_registers_conflict_p_1 (rtx
*, void *);
332 static bool frv_registers_conflict_p (rtx
);
333 static void frv_registers_update_1 (rtx
, const_rtx
, void *);
334 static void frv_registers_update (rtx
);
335 static void frv_start_packet (void);
336 static void frv_start_packet_block (void);
337 static void frv_finish_packet (void (*) (void));
338 static bool frv_pack_insn_p (rtx
);
339 static void frv_add_insn_to_packet (rtx
);
340 static void frv_insert_nop_in_packet (rtx
);
341 static bool frv_for_each_packet (void (*) (void));
342 static bool frv_sort_insn_group_1 (enum frv_insn_group
,
343 unsigned int, unsigned int,
344 unsigned int, unsigned int,
346 static int frv_compare_insns (const void *, const void *);
347 static void frv_sort_insn_group (enum frv_insn_group
);
348 static void frv_reorder_packet (void);
349 static void frv_fill_unused_units (enum frv_insn_group
);
350 static void frv_align_label (void);
351 static void frv_reorg_packet (void);
352 static void frv_register_nop (rtx
);
353 static void frv_reorg (void);
354 static void frv_pack_insns (void);
355 static void frv_function_prologue (FILE *, HOST_WIDE_INT
);
356 static void frv_function_epilogue (FILE *, HOST_WIDE_INT
);
357 static bool frv_assemble_integer (rtx
, unsigned, int);
358 static void frv_init_builtins (void);
359 static rtx
frv_expand_builtin (tree
, rtx
, rtx
, enum machine_mode
, int);
360 static void frv_init_libfuncs (void);
361 static bool frv_in_small_data_p (tree
);
362 static void frv_asm_output_mi_thunk
363 (FILE *, tree
, HOST_WIDE_INT
, HOST_WIDE_INT
, tree
);
364 static void frv_setup_incoming_varargs (CUMULATIVE_ARGS
*,
367 static rtx
frv_expand_builtin_saveregs (void);
368 static bool frv_rtx_costs (rtx
, int, int, int*);
369 static void frv_asm_out_constructor (rtx
, int);
370 static void frv_asm_out_destructor (rtx
, int);
371 static bool frv_function_symbol_referenced_p (rtx
);
372 static bool frv_cannot_force_const_mem (rtx
);
373 static const char *unspec_got_name (int);
374 static void frv_output_const_unspec (FILE *,
375 const struct frv_unspec
*);
376 static bool frv_function_ok_for_sibcall (tree
, tree
);
377 static rtx
frv_struct_value_rtx (tree
, int);
378 static bool frv_must_pass_in_stack (enum machine_mode mode
, const_tree type
);
379 static int frv_arg_partial_bytes (CUMULATIVE_ARGS
*, enum machine_mode
,
381 static void frv_output_dwarf_dtprel (FILE *, int, rtx
)
384 /* Allow us to easily change the default for -malloc-cc. */
385 #ifndef DEFAULT_NO_ALLOC_CC
386 #define MASK_DEFAULT_ALLOC_CC MASK_ALLOC_CC
388 #define MASK_DEFAULT_ALLOC_CC 0
391 /* Initialize the GCC target structure. */
392 #undef TARGET_ASM_FUNCTION_PROLOGUE
393 #define TARGET_ASM_FUNCTION_PROLOGUE frv_function_prologue
394 #undef TARGET_ASM_FUNCTION_EPILOGUE
395 #define TARGET_ASM_FUNCTION_EPILOGUE frv_function_epilogue
396 #undef TARGET_ASM_INTEGER
397 #define TARGET_ASM_INTEGER frv_assemble_integer
398 #undef TARGET_DEFAULT_TARGET_FLAGS
399 #define TARGET_DEFAULT_TARGET_FLAGS \
400 (MASK_DEFAULT_ALLOC_CC \
407 #undef TARGET_HANDLE_OPTION
408 #define TARGET_HANDLE_OPTION frv_handle_option
409 #undef TARGET_INIT_BUILTINS
410 #define TARGET_INIT_BUILTINS frv_init_builtins
411 #undef TARGET_EXPAND_BUILTIN
412 #define TARGET_EXPAND_BUILTIN frv_expand_builtin
413 #undef TARGET_INIT_LIBFUNCS
414 #define TARGET_INIT_LIBFUNCS frv_init_libfuncs
415 #undef TARGET_IN_SMALL_DATA_P
416 #define TARGET_IN_SMALL_DATA_P frv_in_small_data_p
417 #undef TARGET_RTX_COSTS
418 #define TARGET_RTX_COSTS frv_rtx_costs
419 #undef TARGET_ASM_CONSTRUCTOR
420 #define TARGET_ASM_CONSTRUCTOR frv_asm_out_constructor
421 #undef TARGET_ASM_DESTRUCTOR
422 #define TARGET_ASM_DESTRUCTOR frv_asm_out_destructor
424 #undef TARGET_ASM_OUTPUT_MI_THUNK
425 #define TARGET_ASM_OUTPUT_MI_THUNK frv_asm_output_mi_thunk
426 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
427 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK default_can_output_mi_thunk_no_vcall
429 #undef TARGET_SCHED_ISSUE_RATE
430 #define TARGET_SCHED_ISSUE_RATE frv_issue_rate
432 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
433 #define TARGET_FUNCTION_OK_FOR_SIBCALL frv_function_ok_for_sibcall
434 #undef TARGET_CANNOT_FORCE_CONST_MEM
435 #define TARGET_CANNOT_FORCE_CONST_MEM frv_cannot_force_const_mem
437 #undef TARGET_HAVE_TLS
438 #define TARGET_HAVE_TLS HAVE_AS_TLS
440 #undef TARGET_STRUCT_VALUE_RTX
441 #define TARGET_STRUCT_VALUE_RTX frv_struct_value_rtx
442 #undef TARGET_MUST_PASS_IN_STACK
443 #define TARGET_MUST_PASS_IN_STACK frv_must_pass_in_stack
444 #undef TARGET_PASS_BY_REFERENCE
445 #define TARGET_PASS_BY_REFERENCE hook_pass_by_reference_must_pass_in_stack
446 #undef TARGET_ARG_PARTIAL_BYTES
447 #define TARGET_ARG_PARTIAL_BYTES frv_arg_partial_bytes
449 #undef TARGET_EXPAND_BUILTIN_SAVEREGS
450 #define TARGET_EXPAND_BUILTIN_SAVEREGS frv_expand_builtin_saveregs
451 #undef TARGET_SETUP_INCOMING_VARARGS
452 #define TARGET_SETUP_INCOMING_VARARGS frv_setup_incoming_varargs
453 #undef TARGET_MACHINE_DEPENDENT_REORG
454 #define TARGET_MACHINE_DEPENDENT_REORG frv_reorg
457 #undef TARGET_ASM_OUTPUT_DWARF_DTPREL
458 #define TARGET_ASM_OUTPUT_DWARF_DTPREL frv_output_dwarf_dtprel
461 struct gcc_target targetm
= TARGET_INITIALIZER
;
463 #define FRV_SYMBOL_REF_TLS_P(RTX) \
464 (GET_CODE (RTX) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (RTX) != 0)
467 /* Any function call that satisfies the machine-independent
468 requirements is eligible on FR-V. */
471 frv_function_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED
,
472 tree exp ATTRIBUTE_UNUSED
)
477 /* Return true if SYMBOL is a small data symbol and relocation RELOC
478 can be used to access it directly in a load or store. */
480 static FRV_INLINE
bool
481 frv_small_data_reloc_p (rtx symbol
, int reloc
)
483 return (GET_CODE (symbol
) == SYMBOL_REF
484 && SYMBOL_REF_SMALL_P (symbol
)
485 && (!TARGET_FDPIC
|| flag_pic
== 1)
486 && (reloc
== R_FRV_GOTOFF12
|| reloc
== R_FRV_GPREL12
));
489 /* Return true if X is a valid relocation unspec. If it is, fill in UNSPEC
493 frv_const_unspec_p (rtx x
, struct frv_unspec
*unspec
)
495 if (GET_CODE (x
) == CONST
)
499 if (GET_CODE (x
) == PLUS
&& GET_CODE (XEXP (x
, 1)) == CONST_INT
)
501 unspec
->offset
+= INTVAL (XEXP (x
, 1));
504 if (GET_CODE (x
) == UNSPEC
&& XINT (x
, 1) == UNSPEC_GOT
)
506 unspec
->symbol
= XVECEXP (x
, 0, 0);
507 unspec
->reloc
= INTVAL (XVECEXP (x
, 0, 1));
509 if (unspec
->offset
== 0)
512 if (frv_small_data_reloc_p (unspec
->symbol
, unspec
->reloc
)
513 && unspec
->offset
> 0
514 && (unsigned HOST_WIDE_INT
) unspec
->offset
< g_switch_value
)
521 /* Decide whether we can force certain constants to memory. If we
522 decide we can't, the caller should be able to cope with it in
525 We never allow constants to be forced into memory for TARGET_FDPIC.
526 This is necessary for several reasons:
528 1. Since LEGITIMATE_CONSTANT_P rejects constant pool addresses, the
529 target-independent code will try to force them into the constant
530 pool, thus leading to infinite recursion.
532 2. We can never introduce new constant pool references during reload.
533 Any such reference would require use of the pseudo FDPIC register.
535 3. We can't represent a constant added to a function pointer (which is
536 not the same as a pointer to a function+constant).
538 4. In many cases, it's more efficient to calculate the constant in-line. */
541 frv_cannot_force_const_mem (rtx x ATTRIBUTE_UNUSED
)
546 /* Implement TARGET_HANDLE_OPTION. */
549 frv_handle_option (size_t code
, const char *arg
, int value ATTRIBUTE_UNUSED
)
554 if (strcmp (arg
, "simple") == 0)
555 frv_cpu_type
= FRV_CPU_SIMPLE
;
556 else if (strcmp (arg
, "tomcat") == 0)
557 frv_cpu_type
= FRV_CPU_TOMCAT
;
558 else if (strcmp (arg
, "fr550") == 0)
559 frv_cpu_type
= FRV_CPU_FR550
;
560 else if (strcmp (arg
, "fr500") == 0)
561 frv_cpu_type
= FRV_CPU_FR500
;
562 else if (strcmp (arg
, "fr450") == 0)
563 frv_cpu_type
= FRV_CPU_FR450
;
564 else if (strcmp (arg
, "fr405") == 0)
565 frv_cpu_type
= FRV_CPU_FR405
;
566 else if (strcmp (arg
, "fr400") == 0)
567 frv_cpu_type
= FRV_CPU_FR400
;
568 else if (strcmp (arg
, "fr300") == 0)
569 frv_cpu_type
= FRV_CPU_FR300
;
570 else if (strcmp (arg
, "frv") == 0)
571 frv_cpu_type
= FRV_CPU_GENERIC
;
582 frv_default_flags_for_cpu (void)
584 switch (frv_cpu_type
)
586 case FRV_CPU_GENERIC
:
587 return MASK_DEFAULT_FRV
;
590 return MASK_DEFAULT_FR550
;
594 return MASK_DEFAULT_FR500
;
597 return MASK_DEFAULT_FR450
;
601 return MASK_DEFAULT_FR400
;
605 return MASK_DEFAULT_SIMPLE
;
612 /* Sometimes certain combinations of command options do not make
613 sense on a particular target machine. You can define a macro
614 `OVERRIDE_OPTIONS' to take account of this. This macro, if
615 defined, is executed once just after all the command options have
618 Don't use this macro to turn on various extra optimizations for
619 `-O'. That is what `OPTIMIZATION_OPTIONS' is for. */
622 frv_override_options (void)
627 target_flags
|= (frv_default_flags_for_cpu () & ~target_flags_explicit
);
629 /* -mlibrary-pic sets -fPIC and -G0 and also suppresses warnings from the
630 linker about linking pic and non-pic code. */
633 if (!flag_pic
) /* -fPIC */
636 if (! g_switch_set
) /* -G0 */
643 /* A C expression whose value is a register class containing hard
644 register REGNO. In general there is more than one such class;
645 choose a class which is "minimal", meaning that no smaller class
646 also contains the register. */
648 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
650 enum reg_class
class;
654 int gpr_reg
= regno
- GPR_FIRST
;
656 if (gpr_reg
== GR8_REG
)
659 else if (gpr_reg
== GR9_REG
)
662 else if (gpr_reg
== GR14_REG
)
663 class = FDPIC_FPTR_REGS
;
665 else if (gpr_reg
== FDPIC_REGNO
)
668 else if ((gpr_reg
& 3) == 0)
671 else if ((gpr_reg
& 1) == 0)
678 else if (FPR_P (regno
))
680 int fpr_reg
= regno
- GPR_FIRST
;
681 if ((fpr_reg
& 3) == 0)
682 class = QUAD_FPR_REGS
;
684 else if ((fpr_reg
& 1) == 0)
691 else if (regno
== LR_REGNO
)
694 else if (regno
== LCR_REGNO
)
697 else if (ICC_P (regno
))
700 else if (FCC_P (regno
))
703 else if (ICR_P (regno
))
706 else if (FCR_P (regno
))
709 else if (ACC_P (regno
))
711 int r
= regno
- ACC_FIRST
;
713 class = QUAD_ACC_REGS
;
714 else if ((r
& 1) == 0)
715 class = EVEN_ACC_REGS
;
720 else if (ACCG_P (regno
))
726 regno_reg_class
[regno
] = class;
729 /* Check for small data option */
731 g_switch_value
= SDATA_DEFAULT_SIZE
;
733 /* A C expression which defines the machine-dependent operand
734 constraint letters for register classes. If CHAR is such a
735 letter, the value should be the register class corresponding to
736 it. Otherwise, the value should be `NO_REGS'. The register
737 letter `r', corresponding to class `GENERAL_REGS', will not be
738 passed to this macro; you do not need to handle it.
740 The following letters are unavailable, due to being used as
745 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P'
746 'Q', 'R', 'S', 'T', 'U'
748 'g', 'i', 'm', 'n', 'o', 'p', 'r', 's' */
750 for (i
= 0; i
< 256; i
++)
751 reg_class_from_letter
[i
] = NO_REGS
;
753 reg_class_from_letter
['a'] = ACC_REGS
;
754 reg_class_from_letter
['b'] = EVEN_ACC_REGS
;
755 reg_class_from_letter
['c'] = CC_REGS
;
756 reg_class_from_letter
['d'] = GPR_REGS
;
757 reg_class_from_letter
['e'] = EVEN_REGS
;
758 reg_class_from_letter
['f'] = FPR_REGS
;
759 reg_class_from_letter
['h'] = FEVEN_REGS
;
760 reg_class_from_letter
['l'] = LR_REG
;
761 reg_class_from_letter
['q'] = QUAD_REGS
;
762 reg_class_from_letter
['t'] = ICC_REGS
;
763 reg_class_from_letter
['u'] = FCC_REGS
;
764 reg_class_from_letter
['v'] = ICR_REGS
;
765 reg_class_from_letter
['w'] = FCR_REGS
;
766 reg_class_from_letter
['x'] = QUAD_FPR_REGS
;
767 reg_class_from_letter
['y'] = LCR_REG
;
768 reg_class_from_letter
['z'] = SPR_REGS
;
769 reg_class_from_letter
['A'] = QUAD_ACC_REGS
;
770 reg_class_from_letter
['B'] = ACCG_REGS
;
771 reg_class_from_letter
['C'] = CR_REGS
;
772 reg_class_from_letter
['W'] = FDPIC_CALL_REGS
; /* gp14+15 */
773 reg_class_from_letter
['Z'] = FDPIC_REGS
; /* gp15 */
775 /* There is no single unaligned SI op for PIC code. Sometimes we
776 need to use ".4byte" and sometimes we need to use ".picptr".
777 See frv_assemble_integer for details. */
778 if (flag_pic
|| TARGET_FDPIC
)
779 targetm
.asm_out
.unaligned_op
.si
= 0;
781 if ((target_flags_explicit
& MASK_LINKED_FP
) == 0)
782 target_flags
|= MASK_LINKED_FP
;
784 if ((target_flags_explicit
& MASK_OPTIMIZE_MEMBAR
) == 0)
785 target_flags
|= MASK_OPTIMIZE_MEMBAR
;
787 for (i
= 0; i
< ARRAY_SIZE (frv_unit_names
); i
++)
788 frv_unit_codes
[i
] = get_cpu_unit_code (frv_unit_names
[i
]);
790 for (i
= 0; i
< ARRAY_SIZE (frv_type_to_unit
); i
++)
791 frv_type_to_unit
[i
] = ARRAY_SIZE (frv_unit_codes
);
793 init_machine_status
= frv_init_machine_status
;
797 /* Some machines may desire to change what optimizations are performed for
798 various optimization levels. This macro, if defined, is executed once just
799 after the optimization level is determined and before the remainder of the
800 command options have been parsed. Values set in this macro are used as the
801 default values for the other command line options.
803 LEVEL is the optimization level specified; 2 if `-O2' is specified, 1 if
804 `-O' is specified, and 0 if neither is specified.
806 SIZE is nonzero if `-Os' is specified, 0 otherwise.
808 You should not use this macro to change options that are not
809 machine-specific. These should uniformly selected by the same optimization
810 level on all supported machines. Use this macro to enable machine-specific
813 *Do not examine `write_symbols' in this macro!* The debugging options are
814 *not supposed to alter the generated code. */
816 /* On the FRV, possibly disable VLIW packing which is done by the 2nd
817 scheduling pass at the current time. */
819 frv_optimization_options (int level
, int size ATTRIBUTE_UNUSED
)
823 #ifdef DISABLE_SCHED2
824 flag_schedule_insns_after_reload
= 0;
833 /* Return true if NAME (a STRING_CST node) begins with PREFIX. */
836 frv_string_begins_with (tree name
, const char *prefix
)
838 int prefix_len
= strlen (prefix
);
840 /* Remember: NAME's length includes the null terminator. */
841 return (TREE_STRING_LENGTH (name
) > prefix_len
842 && strncmp (TREE_STRING_POINTER (name
), prefix
, prefix_len
) == 0);
845 /* Zero or more C statements that may conditionally modify two variables
846 `fixed_regs' and `call_used_regs' (both of type `char []') after they have
847 been initialized from the two preceding macros.
849 This is necessary in case the fixed or call-clobbered registers depend on
852 You need not define this macro if it has no work to do.
854 If the usage of an entire class of registers depends on the target flags,
855 you may indicate this to GCC by using this macro to modify `fixed_regs' and
856 `call_used_regs' to 1 for each of the registers in the classes which should
857 not be used by GCC. Also define the macro `REG_CLASS_FROM_LETTER' to return
858 `NO_REGS' if it is called with a letter for a class that shouldn't be used.
860 (However, if this class is not included in `GENERAL_REGS' and all of the
861 insn patterns whose constraints permit this class are controlled by target
862 switches, then GCC will automatically avoid using these registers when the
863 target switches are opposed to them.) */
866 frv_conditional_register_usage (void)
870 for (i
= GPR_FIRST
+ NUM_GPRS
; i
<= GPR_LAST
; i
++)
871 fixed_regs
[i
] = call_used_regs
[i
] = 1;
873 for (i
= FPR_FIRST
+ NUM_FPRS
; i
<= FPR_LAST
; i
++)
874 fixed_regs
[i
] = call_used_regs
[i
] = 1;
876 /* Reserve the registers used for conditional execution. At present, we need
877 1 ICC and 1 ICR register. */
878 fixed_regs
[ICC_TEMP
] = call_used_regs
[ICC_TEMP
] = 1;
879 fixed_regs
[ICR_TEMP
] = call_used_regs
[ICR_TEMP
] = 1;
883 fixed_regs
[ICC_FIRST
] = call_used_regs
[ICC_FIRST
] = 1;
884 fixed_regs
[FCC_FIRST
] = call_used_regs
[FCC_FIRST
] = 1;
885 fixed_regs
[ICR_FIRST
] = call_used_regs
[ICR_FIRST
] = 1;
886 fixed_regs
[FCR_FIRST
] = call_used_regs
[FCR_FIRST
] = 1;
890 fixed_regs
[GPR_FIRST
+ 16] = fixed_regs
[GPR_FIRST
+ 17] =
891 call_used_regs
[GPR_FIRST
+ 16] = call_used_regs
[GPR_FIRST
+ 17] = 0;
894 /* If -fpic, SDA_BASE_REG is the PIC register. */
895 if (g_switch_value
== 0 && !flag_pic
)
896 fixed_regs
[SDA_BASE_REG
] = call_used_regs
[SDA_BASE_REG
] = 0;
899 fixed_regs
[PIC_REGNO
] = call_used_regs
[PIC_REGNO
] = 0;
905 * Compute the stack frame layout
908 * +---------------+-----------------------+-----------------------+
909 * |Register |type |caller-save/callee-save|
910 * +---------------+-----------------------+-----------------------+
911 * |GR0 |Zero register | - |
912 * |GR1 |Stack pointer(SP) | - |
913 * |GR2 |Frame pointer(FP) | - |
914 * |GR3 |Hidden parameter | caller save |
915 * |GR4-GR7 | - | caller save |
916 * |GR8-GR13 |Argument register | caller save |
917 * |GR14-GR15 | - | caller save |
918 * |GR16-GR31 | - | callee save |
919 * |GR32-GR47 | - | caller save |
920 * |GR48-GR63 | - | callee save |
921 * |FR0-FR15 | - | caller save |
922 * |FR16-FR31 | - | callee save |
923 * |FR32-FR47 | - | caller save |
924 * |FR48-FR63 | - | callee save |
925 * +---------------+-----------------------+-----------------------+
929 * SP-> |-----------------------------------|
931 * |-----------------------------------|
932 * | Register save area |
933 * |-----------------------------------|
934 * | Local variable save area |
935 * FP-> |-----------------------------------|
937 * |-----------------------------------|
938 * | Hidden parameter save area |
939 * |-----------------------------------|
940 * | Return address(LR) storage area |
941 * |-----------------------------------|
942 * | Padding for alignment |
943 * |-----------------------------------|
944 * | Register argument area |
945 * OLD SP-> |-----------------------------------|
947 * |-----------------------------------|
950 * Argument area/Parameter area:
952 * When a function is called, this area is used for argument transfer. When
953 * the argument is set up by the caller function, this area is referred to as
954 * the argument area. When the argument is referenced by the callee function,
955 * this area is referred to as the parameter area. The area is allocated when
956 * all arguments cannot be placed on the argument register at the time of
959 * Register save area:
961 * This is a register save area that must be guaranteed for the caller
962 * function. This area is not secured when the register save operation is not
965 * Local variable save area:
967 * This is the area for local variables and temporary variables.
971 * This area stores the FP value of the caller function.
973 * Hidden parameter save area:
975 * This area stores the start address of the return value storage
976 * area for a struct/union return function.
977 * When a struct/union is used as the return value, the caller
978 * function stores the return value storage area start address in
979 * register GR3 and passes it to the caller function.
980 * The callee function interprets the address stored in the GR3
981 * as the return value storage area start address.
982 * When register GR3 needs to be saved into memory, the callee
983 * function saves it in the hidden parameter save area. This
984 * area is not secured when the save operation is not needed.
986 * Return address(LR) storage area:
988 * This area saves the LR. The LR stores the address of a return to the caller
989 * function for the purpose of function calling.
991 * Argument register area:
993 * This area saves the argument register. This area is not secured when the
994 * save operation is not needed.
998 * Arguments, the count of which equals the count of argument registers (6
999 * words), are positioned in registers GR8 to GR13 and delivered to the callee
1000 * function. When a struct/union return function is called, the return value
1001 * area address is stored in register GR3. Arguments not placed in the
1002 * argument registers will be stored in the stack argument area for transfer
1003 * purposes. When an 8-byte type argument is to be delivered using registers,
1004 * it is divided into two and placed in two registers for transfer. When
1005 * argument registers must be saved to memory, the callee function secures an
1006 * argument register save area in the stack. In this case, a continuous
1007 * argument register save area must be established in the parameter area. The
1008 * argument register save area must be allocated as needed to cover the size of
1009 * the argument register to be saved. If the function has a variable count of
1010 * arguments, it saves all argument registers in the argument register save
1013 * Argument Extension Format:
1015 * When an argument is to be stored in the stack, its type is converted to an
1016 * extended type in accordance with the individual argument type. The argument
1017 * is freed by the caller function after the return from the callee function is
1020 * +-----------------------+---------------+------------------------+
1021 * | Argument Type |Extended Type |Stack Storage Size(byte)|
1022 * +-----------------------+---------------+------------------------+
1024 * |signed char |int | 4 |
1025 * |unsigned char |int | 4 |
1026 * |[signed] short int |int | 4 |
1027 * |unsigned short int |int | 4 |
1028 * |[signed] int |No extension | 4 |
1029 * |unsigned int |No extension | 4 |
1030 * |[signed] long int |No extension | 4 |
1031 * |unsigned long int |No extension | 4 |
1032 * |[signed] long long int |No extension | 8 |
1033 * |unsigned long long int |No extension | 8 |
1034 * |float |double | 8 |
1035 * |double |No extension | 8 |
1036 * |long double |No extension | 8 |
1037 * |pointer |No extension | 4 |
1038 * |struct/union |- | 4 (*1) |
1039 * +-----------------------+---------------+------------------------+
1041 * When a struct/union is to be delivered as an argument, the caller copies it
1042 * to the local variable area and delivers the address of that area.
1046 * +-------------------------------+----------------------+
1047 * |Return Value Type |Return Value Interface|
1048 * +-------------------------------+----------------------+
1050 * |[signed|unsigned] char |GR8 |
1051 * |[signed|unsigned] short int |GR8 |
1052 * |[signed|unsigned] int |GR8 |
1053 * |[signed|unsigned] long int |GR8 |
1055 * |[signed|unsigned] long long int|GR8 & GR9 |
1057 * |double |GR8 & GR9 |
1058 * |long double |GR8 & GR9 |
1059 * |struct/union |(*1) |
1060 * +-------------------------------+----------------------+
1062 * When a struct/union is used as the return value, the caller function stores
1063 * the start address of the return value storage area into GR3 and then passes
1064 * it to the callee function. The callee function interprets GR3 as the start
1065 * address of the return value storage area. When this address needs to be
1066 * saved in memory, the callee function secures the hidden parameter save area
1067 * and saves the address in that area.
1071 frv_stack_info (void)
1073 static frv_stack_t info
, zero_info
;
1074 frv_stack_t
*info_ptr
= &info
;
1075 tree fndecl
= current_function_decl
;
1083 /* If we've already calculated the values and reload is complete,
1085 if (frv_stack_cache
)
1086 return frv_stack_cache
;
1088 /* Zero all fields. */
1091 /* Set up the register range information. */
1092 info_ptr
->regs
[STACK_REGS_GPR
].name
= "gpr";
1093 info_ptr
->regs
[STACK_REGS_GPR
].first
= LAST_ARG_REGNUM
+ 1;
1094 info_ptr
->regs
[STACK_REGS_GPR
].last
= GPR_LAST
;
1095 info_ptr
->regs
[STACK_REGS_GPR
].dword_p
= TRUE
;
1097 info_ptr
->regs
[STACK_REGS_FPR
].name
= "fpr";
1098 info_ptr
->regs
[STACK_REGS_FPR
].first
= FPR_FIRST
;
1099 info_ptr
->regs
[STACK_REGS_FPR
].last
= FPR_LAST
;
1100 info_ptr
->regs
[STACK_REGS_FPR
].dword_p
= TRUE
;
1102 info_ptr
->regs
[STACK_REGS_LR
].name
= "lr";
1103 info_ptr
->regs
[STACK_REGS_LR
].first
= LR_REGNO
;
1104 info_ptr
->regs
[STACK_REGS_LR
].last
= LR_REGNO
;
1105 info_ptr
->regs
[STACK_REGS_LR
].special_p
= 1;
1107 info_ptr
->regs
[STACK_REGS_CC
].name
= "cc";
1108 info_ptr
->regs
[STACK_REGS_CC
].first
= CC_FIRST
;
1109 info_ptr
->regs
[STACK_REGS_CC
].last
= CC_LAST
;
1110 info_ptr
->regs
[STACK_REGS_CC
].field_p
= TRUE
;
1112 info_ptr
->regs
[STACK_REGS_LCR
].name
= "lcr";
1113 info_ptr
->regs
[STACK_REGS_LCR
].first
= LCR_REGNO
;
1114 info_ptr
->regs
[STACK_REGS_LCR
].last
= LCR_REGNO
;
1116 info_ptr
->regs
[STACK_REGS_STDARG
].name
= "stdarg";
1117 info_ptr
->regs
[STACK_REGS_STDARG
].first
= FIRST_ARG_REGNUM
;
1118 info_ptr
->regs
[STACK_REGS_STDARG
].last
= LAST_ARG_REGNUM
;
1119 info_ptr
->regs
[STACK_REGS_STDARG
].dword_p
= 1;
1120 info_ptr
->regs
[STACK_REGS_STDARG
].special_p
= 1;
1122 info_ptr
->regs
[STACK_REGS_STRUCT
].name
= "struct";
1123 info_ptr
->regs
[STACK_REGS_STRUCT
].first
= FRV_STRUCT_VALUE_REGNUM
;
1124 info_ptr
->regs
[STACK_REGS_STRUCT
].last
= FRV_STRUCT_VALUE_REGNUM
;
1125 info_ptr
->regs
[STACK_REGS_STRUCT
].special_p
= 1;
1127 info_ptr
->regs
[STACK_REGS_FP
].name
= "fp";
1128 info_ptr
->regs
[STACK_REGS_FP
].first
= FRAME_POINTER_REGNUM
;
1129 info_ptr
->regs
[STACK_REGS_FP
].last
= FRAME_POINTER_REGNUM
;
1130 info_ptr
->regs
[STACK_REGS_FP
].special_p
= 1;
1132 /* Determine if this is a stdarg function. If so, allocate space to store
1139 /* Find the last argument, and see if it is __builtin_va_alist. */
1140 for (cur_arg
= DECL_ARGUMENTS (fndecl
); cur_arg
!= (tree
)0; cur_arg
= next_arg
)
1142 next_arg
= TREE_CHAIN (cur_arg
);
1143 if (next_arg
== (tree
)0)
1145 if (DECL_NAME (cur_arg
)
1146 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (cur_arg
)), "__builtin_va_alist"))
1154 /* Iterate over all of the register ranges. */
1155 for (range
= 0; range
< STACK_REGS_MAX
; range
++)
1157 frv_stack_regs_t
*reg_ptr
= &(info_ptr
->regs
[range
]);
1158 int first
= reg_ptr
->first
;
1159 int last
= reg_ptr
->last
;
1161 int size_2words
= 0;
1164 /* Calculate which registers need to be saved & save area size. */
1168 for (regno
= first
; regno
<= last
; regno
++)
1170 if ((df_regs_ever_live_p (regno
) && !call_used_regs
[regno
])
1171 || (current_function_calls_eh_return
1172 && (regno
>= FIRST_EH_REGNUM
&& regno
<= LAST_EH_REGNUM
))
1173 || (!TARGET_FDPIC
&& flag_pic
1174 && cfun
->uses_pic_offset_table
&& regno
== PIC_REGNO
))
1176 info_ptr
->save_p
[regno
] = REG_SAVE_1WORD
;
1177 size_1word
+= UNITS_PER_WORD
;
1182 /* Calculate whether we need to create a frame after everything else
1183 has been processed. */
1188 if (df_regs_ever_live_p (LR_REGNO
)
1190 /* This is set for __builtin_return_address, etc. */
1191 || cfun
->machine
->frame_needed
1192 || (TARGET_LINKED_FP
&& frame_pointer_needed
)
1193 || (!TARGET_FDPIC
&& flag_pic
1194 && cfun
->uses_pic_offset_table
))
1196 info_ptr
->save_p
[LR_REGNO
] = REG_SAVE_1WORD
;
1197 size_1word
+= UNITS_PER_WORD
;
1201 case STACK_REGS_STDARG
:
1204 /* If this is a stdarg function with a non varardic
1205 argument split between registers and the stack,
1206 adjust the saved registers downward. */
1207 last
-= (ADDR_ALIGN (cfun
->pretend_args_size
, UNITS_PER_WORD
)
1210 for (regno
= first
; regno
<= last
; regno
++)
1212 info_ptr
->save_p
[regno
] = REG_SAVE_1WORD
;
1213 size_1word
+= UNITS_PER_WORD
;
1216 info_ptr
->stdarg_size
= size_1word
;
1220 case STACK_REGS_STRUCT
:
1221 if (cfun
->returns_struct
)
1223 info_ptr
->save_p
[FRV_STRUCT_VALUE_REGNUM
] = REG_SAVE_1WORD
;
1224 size_1word
+= UNITS_PER_WORD
;
1232 /* If this is a field, it only takes one word. */
1233 if (reg_ptr
->field_p
)
1234 size_1word
= UNITS_PER_WORD
;
1236 /* Determine which register pairs can be saved together. */
1237 else if (reg_ptr
->dword_p
&& TARGET_DWORD
)
1239 for (regno
= first
; regno
< last
; regno
+= 2)
1241 if (info_ptr
->save_p
[regno
] && info_ptr
->save_p
[regno
+1])
1243 size_2words
+= 2 * UNITS_PER_WORD
;
1244 size_1word
-= 2 * UNITS_PER_WORD
;
1245 info_ptr
->save_p
[regno
] = REG_SAVE_2WORDS
;
1246 info_ptr
->save_p
[regno
+1] = REG_SAVE_NO_SAVE
;
1251 reg_ptr
->size_1word
= size_1word
;
1252 reg_ptr
->size_2words
= size_2words
;
1254 if (! reg_ptr
->special_p
)
1256 info_ptr
->regs_size_1word
+= size_1word
;
1257 info_ptr
->regs_size_2words
+= size_2words
;
1262 /* Set up the sizes of each each field in the frame body, making the sizes
1263 of each be divisible by the size of a dword if dword operations might
1264 be used, or the size of a word otherwise. */
1265 alignment
= (TARGET_DWORD
? 2 * UNITS_PER_WORD
: UNITS_PER_WORD
);
1267 info_ptr
->parameter_size
= ADDR_ALIGN (cfun
->outgoing_args_size
, alignment
);
1268 info_ptr
->regs_size
= ADDR_ALIGN (info_ptr
->regs_size_2words
1269 + info_ptr
->regs_size_1word
,
1271 info_ptr
->vars_size
= ADDR_ALIGN (get_frame_size (), alignment
);
1273 info_ptr
->pretend_size
= cfun
->pretend_args_size
;
1275 /* Work out the size of the frame, excluding the header. Both the frame
1276 body and register parameter area will be dword-aligned. */
1277 info_ptr
->total_size
1278 = (ADDR_ALIGN (info_ptr
->parameter_size
1279 + info_ptr
->regs_size
1280 + info_ptr
->vars_size
,
1282 + ADDR_ALIGN (info_ptr
->pretend_size
1283 + info_ptr
->stdarg_size
,
1284 2 * UNITS_PER_WORD
));
1286 /* See if we need to create a frame at all, if so add header area. */
1287 if (info_ptr
->total_size
> 0
1288 || frame_pointer_needed
1289 || info_ptr
->regs
[STACK_REGS_LR
].size_1word
> 0
1290 || info_ptr
->regs
[STACK_REGS_STRUCT
].size_1word
> 0)
1292 offset
= info_ptr
->parameter_size
;
1293 info_ptr
->header_size
= 4 * UNITS_PER_WORD
;
1294 info_ptr
->total_size
+= 4 * UNITS_PER_WORD
;
1296 /* Calculate the offsets to save normal register pairs. */
1297 for (range
= 0; range
< STACK_REGS_MAX
; range
++)
1299 frv_stack_regs_t
*reg_ptr
= &(info_ptr
->regs
[range
]);
1300 if (! reg_ptr
->special_p
)
1302 int first
= reg_ptr
->first
;
1303 int last
= reg_ptr
->last
;
1306 for (regno
= first
; regno
<= last
; regno
++)
1307 if (info_ptr
->save_p
[regno
] == REG_SAVE_2WORDS
1308 && regno
!= FRAME_POINTER_REGNUM
1309 && (regno
< FIRST_ARG_REGNUM
1310 || regno
> LAST_ARG_REGNUM
))
1312 info_ptr
->reg_offset
[regno
] = offset
;
1313 offset
+= 2 * UNITS_PER_WORD
;
1318 /* Calculate the offsets to save normal single registers. */
1319 for (range
= 0; range
< STACK_REGS_MAX
; range
++)
1321 frv_stack_regs_t
*reg_ptr
= &(info_ptr
->regs
[range
]);
1322 if (! reg_ptr
->special_p
)
1324 int first
= reg_ptr
->first
;
1325 int last
= reg_ptr
->last
;
1328 for (regno
= first
; regno
<= last
; regno
++)
1329 if (info_ptr
->save_p
[regno
] == REG_SAVE_1WORD
1330 && regno
!= FRAME_POINTER_REGNUM
1331 && (regno
< FIRST_ARG_REGNUM
1332 || regno
> LAST_ARG_REGNUM
))
1334 info_ptr
->reg_offset
[regno
] = offset
;
1335 offset
+= UNITS_PER_WORD
;
1340 /* Calculate the offset to save the local variables at. */
1341 offset
= ADDR_ALIGN (offset
, alignment
);
1342 if (info_ptr
->vars_size
)
1344 info_ptr
->vars_offset
= offset
;
1345 offset
+= info_ptr
->vars_size
;
1348 /* Align header to a dword-boundary. */
1349 offset
= ADDR_ALIGN (offset
, 2 * UNITS_PER_WORD
);
1351 /* Calculate the offsets in the fixed frame. */
1352 info_ptr
->save_p
[FRAME_POINTER_REGNUM
] = REG_SAVE_1WORD
;
1353 info_ptr
->reg_offset
[FRAME_POINTER_REGNUM
] = offset
;
1354 info_ptr
->regs
[STACK_REGS_FP
].size_1word
= UNITS_PER_WORD
;
1356 info_ptr
->save_p
[LR_REGNO
] = REG_SAVE_1WORD
;
1357 info_ptr
->reg_offset
[LR_REGNO
] = offset
+ 2*UNITS_PER_WORD
;
1358 info_ptr
->regs
[STACK_REGS_LR
].size_1word
= UNITS_PER_WORD
;
1360 if (cfun
->returns_struct
)
1362 info_ptr
->save_p
[FRV_STRUCT_VALUE_REGNUM
] = REG_SAVE_1WORD
;
1363 info_ptr
->reg_offset
[FRV_STRUCT_VALUE_REGNUM
] = offset
+ UNITS_PER_WORD
;
1364 info_ptr
->regs
[STACK_REGS_STRUCT
].size_1word
= UNITS_PER_WORD
;
1367 /* Calculate the offsets to store the arguments passed in registers
1368 for stdarg functions. The register pairs are first and the single
1369 register if any is last. The register save area starts on a
1371 if (info_ptr
->stdarg_size
)
1373 int first
= info_ptr
->regs
[STACK_REGS_STDARG
].first
;
1374 int last
= info_ptr
->regs
[STACK_REGS_STDARG
].last
;
1377 /* Skip the header. */
1378 offset
+= 4 * UNITS_PER_WORD
;
1379 for (regno
= first
; regno
<= last
; regno
++)
1381 if (info_ptr
->save_p
[regno
] == REG_SAVE_2WORDS
)
1383 info_ptr
->reg_offset
[regno
] = offset
;
1384 offset
+= 2 * UNITS_PER_WORD
;
1386 else if (info_ptr
->save_p
[regno
] == REG_SAVE_1WORD
)
1388 info_ptr
->reg_offset
[regno
] = offset
;
1389 offset
+= UNITS_PER_WORD
;
1395 if (reload_completed
)
1396 frv_stack_cache
= info_ptr
;
1402 /* Print the information about the frv stack offsets, etc. when debugging. */
1405 frv_debug_stack (frv_stack_t
*info
)
1410 info
= frv_stack_info ();
1412 fprintf (stderr
, "\nStack information for function %s:\n",
1413 ((current_function_decl
&& DECL_NAME (current_function_decl
))
1414 ? IDENTIFIER_POINTER (DECL_NAME (current_function_decl
))
1417 fprintf (stderr
, "\ttotal_size\t= %6d\n", info
->total_size
);
1418 fprintf (stderr
, "\tvars_size\t= %6d\n", info
->vars_size
);
1419 fprintf (stderr
, "\tparam_size\t= %6d\n", info
->parameter_size
);
1420 fprintf (stderr
, "\tregs_size\t= %6d, 1w = %3d, 2w = %3d\n",
1421 info
->regs_size
, info
->regs_size_1word
, info
->regs_size_2words
);
1423 fprintf (stderr
, "\theader_size\t= %6d\n", info
->header_size
);
1424 fprintf (stderr
, "\tpretend_size\t= %6d\n", info
->pretend_size
);
1425 fprintf (stderr
, "\tvars_offset\t= %6d\n", info
->vars_offset
);
1426 fprintf (stderr
, "\tregs_offset\t= %6d\n", info
->regs_offset
);
1428 for (range
= 0; range
< STACK_REGS_MAX
; range
++)
1430 frv_stack_regs_t
*regs
= &(info
->regs
[range
]);
1431 if ((regs
->size_1word
+ regs
->size_2words
) > 0)
1433 int first
= regs
->first
;
1434 int last
= regs
->last
;
1437 fprintf (stderr
, "\t%s\tsize\t= %6d, 1w = %3d, 2w = %3d, save =",
1438 regs
->name
, regs
->size_1word
+ regs
->size_2words
,
1439 regs
->size_1word
, regs
->size_2words
);
1441 for (regno
= first
; regno
<= last
; regno
++)
1443 if (info
->save_p
[regno
] == REG_SAVE_1WORD
)
1444 fprintf (stderr
, " %s (%d)", reg_names
[regno
],
1445 info
->reg_offset
[regno
]);
1447 else if (info
->save_p
[regno
] == REG_SAVE_2WORDS
)
1448 fprintf (stderr
, " %s-%s (%d)", reg_names
[regno
],
1449 reg_names
[regno
+1], info
->reg_offset
[regno
]);
1452 fputc ('\n', stderr
);
1462 /* Used during final to control the packing of insns. The value is
1463 1 if the current instruction should be packed with the next one,
1464 0 if it shouldn't or -1 if packing is disabled altogether. */
1466 static int frv_insn_packing_flag
;
1468 /* True if the current function contains a far jump. */
1471 frv_function_contains_far_jump (void)
1473 rtx insn
= get_insns ();
1475 && !(GET_CODE (insn
) == JUMP_INSN
1476 /* Ignore tablejump patterns. */
1477 && GET_CODE (PATTERN (insn
)) != ADDR_VEC
1478 && GET_CODE (PATTERN (insn
)) != ADDR_DIFF_VEC
1479 && get_attr_far_jump (insn
) == FAR_JUMP_YES
))
1480 insn
= NEXT_INSN (insn
);
1481 return (insn
!= NULL
);
1484 /* For the FRV, this function makes sure that a function with far jumps
1485 will return correctly. It also does the VLIW packing. */
1488 frv_function_prologue (FILE *file
, HOST_WIDE_INT size ATTRIBUTE_UNUSED
)
1490 /* If no frame was created, check whether the function uses a call
1491 instruction to implement a far jump. If so, save the link in gr3 and
1492 replace all returns to LR with returns to GR3. GR3 is used because it
1493 is call-clobbered, because is not available to the register allocator,
1494 and because all functions that take a hidden argument pointer will have
1496 if (frv_stack_info ()->total_size
== 0 && frv_function_contains_far_jump ())
1500 /* Just to check that the above comment is true. */
1501 gcc_assert (!df_regs_ever_live_p (GPR_FIRST
+ 3));
1503 /* Generate the instruction that saves the link register. */
1504 fprintf (file
, "\tmovsg lr,gr3\n");
1506 /* Replace the LR with GR3 in *return_internal patterns. The insn
1507 will now return using jmpl @(gr3,0) rather than bralr. We cannot
1508 simply emit a different assembly directive because bralr and jmpl
1509 execute in different units. */
1510 for (insn
= get_insns(); insn
!= NULL
; insn
= NEXT_INSN (insn
))
1511 if (GET_CODE (insn
) == JUMP_INSN
)
1513 rtx pattern
= PATTERN (insn
);
1514 if (GET_CODE (pattern
) == PARALLEL
1515 && XVECLEN (pattern
, 0) >= 2
1516 && GET_CODE (XVECEXP (pattern
, 0, 0)) == RETURN
1517 && GET_CODE (XVECEXP (pattern
, 0, 1)) == USE
)
1519 rtx address
= XEXP (XVECEXP (pattern
, 0, 1), 0);
1520 if (GET_CODE (address
) == REG
&& REGNO (address
) == LR_REGNO
)
1521 SET_REGNO (address
, GPR_FIRST
+ 3);
1528 /* Allow the garbage collector to free the nops created by frv_reorg. */
1529 memset (frv_nops
, 0, sizeof (frv_nops
));
1533 /* Return the next available temporary register in a given class. */
1536 frv_alloc_temp_reg (
1537 frv_tmp_reg_t
*info
, /* which registers are available */
1538 enum reg_class
class, /* register class desired */
1539 enum machine_mode mode
, /* mode to allocate register with */
1540 int mark_as_used
, /* register not available after allocation */
1541 int no_abort
) /* return NULL instead of aborting */
1543 int regno
= info
->next_reg
[ (int)class ];
1544 int orig_regno
= regno
;
1545 HARD_REG_SET
*reg_in_class
= ®_class_contents
[ (int)class ];
1550 if (TEST_HARD_REG_BIT (*reg_in_class
, regno
)
1551 && TEST_HARD_REG_BIT (info
->regs
, regno
))
1554 if (++regno
>= FIRST_PSEUDO_REGISTER
)
1556 if (regno
== orig_regno
)
1558 gcc_assert (no_abort
);
1563 nr
= HARD_REGNO_NREGS (regno
, mode
);
1564 info
->next_reg
[ (int)class ] = regno
+ nr
;
1567 for (i
= 0; i
< nr
; i
++)
1568 CLEAR_HARD_REG_BIT (info
->regs
, regno
+i
);
1570 return gen_rtx_REG (mode
, regno
);
1574 /* Return an rtx with the value OFFSET, which will either be a register or a
1575 signed 12-bit integer. It can be used as the second operand in an "add"
1576 instruction, or as the index in a load or store.
1578 The function returns a constant rtx if OFFSET is small enough, otherwise
1579 it loads the constant into register OFFSET_REGNO and returns that. */
1581 frv_frame_offset_rtx (int offset
)
1583 rtx offset_rtx
= GEN_INT (offset
);
1584 if (IN_RANGE_P (offset
, -2048, 2047))
1588 rtx reg_rtx
= gen_rtx_REG (SImode
, OFFSET_REGNO
);
1589 if (IN_RANGE_P (offset
, -32768, 32767))
1590 emit_insn (gen_movsi (reg_rtx
, offset_rtx
));
1593 emit_insn (gen_movsi_high (reg_rtx
, offset_rtx
));
1594 emit_insn (gen_movsi_lo_sum (reg_rtx
, offset_rtx
));
1600 /* Generate (mem:MODE (plus:Pmode BASE (frv_frame_offset OFFSET)))). The
1601 prologue and epilogue uses such expressions to access the stack. */
1603 frv_frame_mem (enum machine_mode mode
, rtx base
, int offset
)
1605 return gen_rtx_MEM (mode
, gen_rtx_PLUS (Pmode
,
1607 frv_frame_offset_rtx (offset
)));
1610 /* Generate a frame-related expression:
1612 (set REG (mem (plus (sp) (const_int OFFSET)))).
1614 Such expressions are used in FRAME_RELATED_EXPR notes for more complex
1615 instructions. Marking the expressions as frame-related is superfluous if
1616 the note contains just a single set. But if the note contains a PARALLEL
1617 or SEQUENCE that has several sets, each set must be individually marked
1618 as frame-related. */
1620 frv_dwarf_store (rtx reg
, int offset
)
1622 rtx set
= gen_rtx_SET (VOIDmode
,
1623 gen_rtx_MEM (GET_MODE (reg
),
1624 plus_constant (stack_pointer_rtx
,
1627 RTX_FRAME_RELATED_P (set
) = 1;
1631 /* Emit a frame-related instruction whose pattern is PATTERN. The
1632 instruction is the last in a sequence that cumulatively performs the
1633 operation described by DWARF_PATTERN. The instruction is marked as
1634 frame-related and has a REG_FRAME_RELATED_EXPR note containing
1637 frv_frame_insn (rtx pattern
, rtx dwarf_pattern
)
1639 rtx insn
= emit_insn (pattern
);
1640 RTX_FRAME_RELATED_P (insn
) = 1;
1641 REG_NOTES (insn
) = alloc_EXPR_LIST (REG_FRAME_RELATED_EXPR
,
1646 /* Emit instructions that transfer REG to or from the memory location (sp +
1647 STACK_OFFSET). The register is stored in memory if ACCESSOR->OP is
1648 FRV_STORE and loaded if it is FRV_LOAD. Only the prologue uses this
1649 function to store registers and only the epilogue uses it to load them.
1651 The caller sets up ACCESSOR so that BASE is equal to (sp + BASE_OFFSET).
1652 The generated instruction will use BASE as its base register. BASE may
1653 simply be the stack pointer, but if several accesses are being made to a
1654 region far away from the stack pointer, it may be more efficient to set
1655 up a temporary instead.
1657 Store instructions will be frame-related and will be annotated with the
1658 overall effect of the store. Load instructions will be followed by a
1659 (use) to prevent later optimizations from zapping them.
1661 The function takes care of the moves to and from SPRs, using TEMP_REGNO
1662 as a temporary in such cases. */
1664 frv_frame_access (frv_frame_accessor_t
*accessor
, rtx reg
, int stack_offset
)
1666 enum machine_mode mode
= GET_MODE (reg
);
1667 rtx mem
= frv_frame_mem (mode
,
1669 stack_offset
- accessor
->base_offset
);
1671 if (accessor
->op
== FRV_LOAD
)
1673 if (SPR_P (REGNO (reg
)))
1675 rtx temp
= gen_rtx_REG (mode
, TEMP_REGNO
);
1676 emit_insn (gen_rtx_SET (VOIDmode
, temp
, mem
));
1677 emit_insn (gen_rtx_SET (VOIDmode
, reg
, temp
));
1680 emit_insn (gen_rtx_SET (VOIDmode
, reg
, mem
));
1681 emit_insn (gen_rtx_USE (VOIDmode
, reg
));
1685 if (SPR_P (REGNO (reg
)))
1687 rtx temp
= gen_rtx_REG (mode
, TEMP_REGNO
);
1688 emit_insn (gen_rtx_SET (VOIDmode
, temp
, reg
));
1689 frv_frame_insn (gen_rtx_SET (Pmode
, mem
, temp
),
1690 frv_dwarf_store (reg
, stack_offset
));
1692 else if (GET_MODE (reg
) == DImode
)
1694 /* For DImode saves, the dwarf2 version needs to be a SEQUENCE
1695 with a separate save for each register. */
1696 rtx reg1
= gen_rtx_REG (SImode
, REGNO (reg
));
1697 rtx reg2
= gen_rtx_REG (SImode
, REGNO (reg
) + 1);
1698 rtx set1
= frv_dwarf_store (reg1
, stack_offset
);
1699 rtx set2
= frv_dwarf_store (reg2
, stack_offset
+ 4);
1700 frv_frame_insn (gen_rtx_SET (Pmode
, mem
, reg
),
1701 gen_rtx_PARALLEL (VOIDmode
,
1702 gen_rtvec (2, set1
, set2
)));
1705 frv_frame_insn (gen_rtx_SET (Pmode
, mem
, reg
),
1706 frv_dwarf_store (reg
, stack_offset
));
1710 /* A function that uses frv_frame_access to transfer a group of registers to
1711 or from the stack. ACCESSOR is passed directly to frv_frame_access, INFO
1712 is the stack information generated by frv_stack_info, and REG_SET is the
1713 number of the register set to transfer. */
1715 frv_frame_access_multi (frv_frame_accessor_t
*accessor
,
1719 frv_stack_regs_t
*regs_info
;
1722 regs_info
= &info
->regs
[reg_set
];
1723 for (regno
= regs_info
->first
; regno
<= regs_info
->last
; regno
++)
1724 if (info
->save_p
[regno
])
1725 frv_frame_access (accessor
,
1726 info
->save_p
[regno
] == REG_SAVE_2WORDS
1727 ? gen_rtx_REG (DImode
, regno
)
1728 : gen_rtx_REG (SImode
, regno
),
1729 info
->reg_offset
[regno
]);
1732 /* Save or restore callee-saved registers that are kept outside the frame
1733 header. The function saves the registers if OP is FRV_STORE and restores
1734 them if OP is FRV_LOAD. INFO is the stack information generated by
1737 frv_frame_access_standard_regs (enum frv_stack_op op
, frv_stack_t
*info
)
1739 frv_frame_accessor_t accessor
;
1742 accessor
.base
= stack_pointer_rtx
;
1743 accessor
.base_offset
= 0;
1744 frv_frame_access_multi (&accessor
, info
, STACK_REGS_GPR
);
1745 frv_frame_access_multi (&accessor
, info
, STACK_REGS_FPR
);
1746 frv_frame_access_multi (&accessor
, info
, STACK_REGS_LCR
);
1750 /* Called after register allocation to add any instructions needed for the
1751 prologue. Using a prologue insn is favored compared to putting all of the
1752 instructions in the TARGET_ASM_FUNCTION_PROLOGUE target hook, since
1753 it allows the scheduler to intermix instructions with the saves of
1754 the caller saved registers. In some cases, it might be necessary
1755 to emit a barrier instruction as the last insn to prevent such
1758 Also any insns generated here should have RTX_FRAME_RELATED_P(insn) = 1
1759 so that the debug info generation code can handle them properly. */
1761 frv_expand_prologue (void)
1763 frv_stack_t
*info
= frv_stack_info ();
1764 rtx sp
= stack_pointer_rtx
;
1765 rtx fp
= frame_pointer_rtx
;
1766 frv_frame_accessor_t accessor
;
1768 if (TARGET_DEBUG_STACK
)
1769 frv_debug_stack (info
);
1771 if (info
->total_size
== 0)
1774 /* We're interested in three areas of the frame here:
1776 A: the register save area
1778 C: the header after B
1780 If the frame pointer isn't used, we'll have to set up A, B and C
1781 using the stack pointer. If the frame pointer is used, we'll access
1785 B: set up using sp or a temporary (see below)
1788 We set up B using the stack pointer if the frame is small enough.
1789 Otherwise, it's more efficient to copy the old stack pointer into a
1790 temporary and use that.
1792 Note that it's important to make sure the prologue and epilogue use the
1793 same registers to access A and C, since doing otherwise will confuse
1794 the aliasing code. */
1796 /* Set up ACCESSOR for accessing region B above. If the frame pointer
1797 isn't used, the same method will serve for C. */
1798 accessor
.op
= FRV_STORE
;
1799 if (frame_pointer_needed
&& info
->total_size
> 2048)
1803 accessor
.base
= gen_rtx_REG (Pmode
, OLD_SP_REGNO
);
1804 accessor
.base_offset
= info
->total_size
;
1805 insn
= emit_insn (gen_movsi (accessor
.base
, sp
));
1809 accessor
.base
= stack_pointer_rtx
;
1810 accessor
.base_offset
= 0;
1813 /* Allocate the stack space. */
1815 rtx asm_offset
= frv_frame_offset_rtx (-info
->total_size
);
1816 rtx dwarf_offset
= GEN_INT (-info
->total_size
);
1818 frv_frame_insn (gen_stack_adjust (sp
, sp
, asm_offset
),
1821 gen_rtx_PLUS (Pmode
, sp
, dwarf_offset
)));
1824 /* If the frame pointer is needed, store the old one at (sp + FP_OFFSET)
1825 and point the new one to that location. */
1826 if (frame_pointer_needed
)
1828 int fp_offset
= info
->reg_offset
[FRAME_POINTER_REGNUM
];
1830 /* ASM_SRC and DWARF_SRC both point to the frame header. ASM_SRC is
1831 based on ACCESSOR.BASE but DWARF_SRC is always based on the stack
1833 rtx asm_src
= plus_constant (accessor
.base
,
1834 fp_offset
- accessor
.base_offset
);
1835 rtx dwarf_src
= plus_constant (sp
, fp_offset
);
1837 /* Store the old frame pointer at (sp + FP_OFFSET). */
1838 frv_frame_access (&accessor
, fp
, fp_offset
);
1840 /* Set up the new frame pointer. */
1841 frv_frame_insn (gen_rtx_SET (VOIDmode
, fp
, asm_src
),
1842 gen_rtx_SET (VOIDmode
, fp
, dwarf_src
));
1844 /* Access region C from the frame pointer. */
1846 accessor
.base_offset
= fp_offset
;
1849 /* Set up region C. */
1850 frv_frame_access_multi (&accessor
, info
, STACK_REGS_STRUCT
);
1851 frv_frame_access_multi (&accessor
, info
, STACK_REGS_LR
);
1852 frv_frame_access_multi (&accessor
, info
, STACK_REGS_STDARG
);
1854 /* Set up region A. */
1855 frv_frame_access_standard_regs (FRV_STORE
, info
);
1857 /* If this is a varargs/stdarg function, issue a blockage to prevent the
1858 scheduler from moving loads before the stores saving the registers. */
1859 if (info
->stdarg_size
> 0)
1860 emit_insn (gen_blockage ());
1862 /* Set up pic register/small data register for this function. */
1863 if (!TARGET_FDPIC
&& flag_pic
&& cfun
->uses_pic_offset_table
)
1864 emit_insn (gen_pic_prologue (gen_rtx_REG (Pmode
, PIC_REGNO
),
1865 gen_rtx_REG (Pmode
, LR_REGNO
),
1866 gen_rtx_REG (SImode
, OFFSET_REGNO
)));
1870 /* Under frv, all of the work is done via frv_expand_epilogue, but
1871 this function provides a convenient place to do cleanup. */
1874 frv_function_epilogue (FILE *file ATTRIBUTE_UNUSED
,
1875 HOST_WIDE_INT size ATTRIBUTE_UNUSED
)
1877 frv_stack_cache
= (frv_stack_t
*)0;
1879 /* Zap last used registers for conditional execution. */
1880 memset (&frv_ifcvt
.tmp_reg
, 0, sizeof (frv_ifcvt
.tmp_reg
));
1882 /* Release the bitmap of created insns. */
1883 BITMAP_FREE (frv_ifcvt
.scratch_insns_bitmap
);
1887 /* Called after register allocation to add any instructions needed for the
1888 epilogue. Using an epilogue insn is favored compared to putting all of the
1889 instructions in the TARGET_ASM_FUNCTION_PROLOGUE target hook, since
1890 it allows the scheduler to intermix instructions with the saves of
1891 the caller saved registers. In some cases, it might be necessary
1892 to emit a barrier instruction as the last insn to prevent such
1896 frv_expand_epilogue (bool emit_return
)
1898 frv_stack_t
*info
= frv_stack_info ();
1899 rtx fp
= frame_pointer_rtx
;
1900 rtx sp
= stack_pointer_rtx
;
1904 fp_offset
= info
->reg_offset
[FRAME_POINTER_REGNUM
];
1906 /* Restore the stack pointer to its original value if alloca or the like
1908 if (! current_function_sp_is_unchanging
)
1909 emit_insn (gen_addsi3 (sp
, fp
, frv_frame_offset_rtx (-fp_offset
)));
1911 /* Restore the callee-saved registers that were used in this function. */
1912 frv_frame_access_standard_regs (FRV_LOAD
, info
);
1914 /* Set RETURN_ADDR to the address we should return to. Set it to NULL if
1915 no return instruction should be emitted. */
1916 if (info
->save_p
[LR_REGNO
])
1921 /* Use the same method to access the link register's slot as we did in
1922 the prologue. In other words, use the frame pointer if available,
1923 otherwise use the stack pointer.
1925 LR_OFFSET is the offset of the link register's slot from the start
1926 of the frame and MEM is a memory rtx for it. */
1927 lr_offset
= info
->reg_offset
[LR_REGNO
];
1928 if (frame_pointer_needed
)
1929 mem
= frv_frame_mem (Pmode
, fp
, lr_offset
- fp_offset
);
1931 mem
= frv_frame_mem (Pmode
, sp
, lr_offset
);
1933 /* Load the old link register into a GPR. */
1934 return_addr
= gen_rtx_REG (Pmode
, TEMP_REGNO
);
1935 emit_insn (gen_rtx_SET (VOIDmode
, return_addr
, mem
));
1938 return_addr
= gen_rtx_REG (Pmode
, LR_REGNO
);
1940 /* Restore the old frame pointer. Emit a USE afterwards to make sure
1941 the load is preserved. */
1942 if (frame_pointer_needed
)
1944 emit_insn (gen_rtx_SET (VOIDmode
, fp
, gen_rtx_MEM (Pmode
, fp
)));
1945 emit_insn (gen_rtx_USE (VOIDmode
, fp
));
1948 /* Deallocate the stack frame. */
1949 if (info
->total_size
!= 0)
1951 rtx offset
= frv_frame_offset_rtx (info
->total_size
);
1952 emit_insn (gen_stack_adjust (sp
, sp
, offset
));
1955 /* If this function uses eh_return, add the final stack adjustment now. */
1956 if (current_function_calls_eh_return
)
1957 emit_insn (gen_stack_adjust (sp
, sp
, EH_RETURN_STACKADJ_RTX
));
1960 emit_jump_insn (gen_epilogue_return (return_addr
));
1963 rtx lr
= return_addr
;
1965 if (REGNO (return_addr
) != LR_REGNO
)
1967 lr
= gen_rtx_REG (Pmode
, LR_REGNO
);
1968 emit_move_insn (lr
, return_addr
);
1971 emit_insn (gen_rtx_USE (VOIDmode
, lr
));
1976 /* Worker function for TARGET_ASM_OUTPUT_MI_THUNK. */
1979 frv_asm_output_mi_thunk (FILE *file
,
1980 tree thunk_fndecl ATTRIBUTE_UNUSED
,
1981 HOST_WIDE_INT delta
,
1982 HOST_WIDE_INT vcall_offset ATTRIBUTE_UNUSED
,
1985 const char *name_func
= XSTR (XEXP (DECL_RTL (function
), 0), 0);
1986 const char *name_arg0
= reg_names
[FIRST_ARG_REGNUM
];
1987 const char *name_jmp
= reg_names
[JUMP_REGNO
];
1988 const char *parallel
= (frv_issue_rate () > 1 ? ".p" : "");
1990 /* Do the add using an addi if possible. */
1991 if (IN_RANGE_P (delta
, -2048, 2047))
1992 fprintf (file
, "\taddi %s,#%d,%s\n", name_arg0
, (int) delta
, name_arg0
);
1995 const char *const name_add
= reg_names
[TEMP_REGNO
];
1996 fprintf (file
, "\tsethi%s #hi(" HOST_WIDE_INT_PRINT_DEC
"),%s\n",
1997 parallel
, delta
, name_add
);
1998 fprintf (file
, "\tsetlo #lo(" HOST_WIDE_INT_PRINT_DEC
"),%s\n",
2000 fprintf (file
, "\tadd %s,%s,%s\n", name_add
, name_arg0
, name_arg0
);
2005 const char *name_pic
= reg_names
[FDPIC_REGNO
];
2006 name_jmp
= reg_names
[FDPIC_FPTR_REGNO
];
2010 fprintf (file
, "\tsethi%s #gotofffuncdeschi(", parallel
);
2011 assemble_name (file
, name_func
);
2012 fprintf (file
, "),%s\n", name_jmp
);
2014 fprintf (file
, "\tsetlo #gotofffuncdesclo(");
2015 assemble_name (file
, name_func
);
2016 fprintf (file
, "),%s\n", name_jmp
);
2018 fprintf (file
, "\tldd @(%s,%s), %s\n", name_jmp
, name_pic
, name_jmp
);
2022 fprintf (file
, "\tlddo @(%s,#gotofffuncdesc12(", name_pic
);
2023 assemble_name (file
, name_func
);
2024 fprintf (file
, "\t)), %s\n", name_jmp
);
2029 fprintf (file
, "\tsethi%s #hi(", parallel
);
2030 assemble_name (file
, name_func
);
2031 fprintf (file
, "),%s\n", name_jmp
);
2033 fprintf (file
, "\tsetlo #lo(");
2034 assemble_name (file
, name_func
);
2035 fprintf (file
, "),%s\n", name_jmp
);
2039 /* Use JUMP_REGNO as a temporary PIC register. */
2040 const char *name_lr
= reg_names
[LR_REGNO
];
2041 const char *name_gppic
= name_jmp
;
2042 const char *name_tmp
= reg_names
[TEMP_REGNO
];
2044 fprintf (file
, "\tmovsg %s,%s\n", name_lr
, name_tmp
);
2045 fprintf (file
, "\tcall 1f\n");
2046 fprintf (file
, "1:\tmovsg %s,%s\n", name_lr
, name_gppic
);
2047 fprintf (file
, "\tmovgs %s,%s\n", name_tmp
, name_lr
);
2048 fprintf (file
, "\tsethi%s #gprelhi(1b),%s\n", parallel
, name_tmp
);
2049 fprintf (file
, "\tsetlo #gprello(1b),%s\n", name_tmp
);
2050 fprintf (file
, "\tsub %s,%s,%s\n", name_gppic
, name_tmp
, name_gppic
);
2052 fprintf (file
, "\tsethi%s #gprelhi(", parallel
);
2053 assemble_name (file
, name_func
);
2054 fprintf (file
, "),%s\n", name_tmp
);
2056 fprintf (file
, "\tsetlo #gprello(");
2057 assemble_name (file
, name_func
);
2058 fprintf (file
, "),%s\n", name_tmp
);
2060 fprintf (file
, "\tadd %s,%s,%s\n", name_gppic
, name_tmp
, name_jmp
);
2063 /* Jump to the function address. */
2064 fprintf (file
, "\tjmpl @(%s,%s)\n", name_jmp
, reg_names
[GPR_FIRST
+0]);
2068 /* A C expression which is nonzero if a function must have and use a frame
2069 pointer. This expression is evaluated in the reload pass. If its value is
2070 nonzero the function will have a frame pointer.
2072 The expression can in principle examine the current function and decide
2073 according to the facts, but on most machines the constant 0 or the constant
2074 1 suffices. Use 0 when the machine allows code to be generated with no
2075 frame pointer, and doing so saves some time or space. Use 1 when there is
2076 no possible advantage to avoiding a frame pointer.
2078 In certain cases, the compiler does not know how to produce valid code
2079 without a frame pointer. The compiler recognizes those cases and
2080 automatically gives the function a frame pointer regardless of what
2081 `FRAME_POINTER_REQUIRED' says. You don't need to worry about them.
2083 In a function that does not require a frame pointer, the frame pointer
2084 register can be allocated for ordinary usage, unless you mark it as a fixed
2085 register. See `FIXED_REGISTERS' for more information. */
2087 /* On frv, create a frame whenever we need to create stack. */
2090 frv_frame_pointer_required (void)
2092 /* If we forgoing the usual linkage requirements, we only need
2093 a frame pointer if the stack pointer might change. */
2094 if (!TARGET_LINKED_FP
)
2095 return !current_function_sp_is_unchanging
;
2097 if (! current_function_is_leaf
)
2100 if (get_frame_size () != 0)
2106 if (!current_function_sp_is_unchanging
)
2109 if (!TARGET_FDPIC
&& flag_pic
&& cfun
->uses_pic_offset_table
)
2115 if (cfun
->machine
->frame_needed
)
2122 /* This macro is similar to `INITIAL_FRAME_POINTER_OFFSET'. It specifies the
2123 initial difference between the specified pair of registers. This macro must
2124 be defined if `ELIMINABLE_REGS' is defined. */
2126 /* See frv_stack_info for more details on the frv stack frame. */
2129 frv_initial_elimination_offset (int from
, int to
)
2131 frv_stack_t
*info
= frv_stack_info ();
2134 if (to
== STACK_POINTER_REGNUM
&& from
== ARG_POINTER_REGNUM
)
2135 ret
= info
->total_size
- info
->pretend_size
;
2137 else if (to
== STACK_POINTER_REGNUM
&& from
== FRAME_POINTER_REGNUM
)
2138 ret
= info
->reg_offset
[FRAME_POINTER_REGNUM
];
2140 else if (to
== FRAME_POINTER_REGNUM
&& from
== ARG_POINTER_REGNUM
)
2141 ret
= (info
->total_size
2142 - info
->reg_offset
[FRAME_POINTER_REGNUM
]
2143 - info
->pretend_size
);
2148 if (TARGET_DEBUG_STACK
)
2149 fprintf (stderr
, "Eliminate %s to %s by adding %d\n",
2150 reg_names
[from
], reg_names
[to
], ret
);
2156 /* Worker function for TARGET_SETUP_INCOMING_VARARGS. */
2159 frv_setup_incoming_varargs (CUMULATIVE_ARGS
*cum
,
2160 enum machine_mode mode
,
2161 tree type ATTRIBUTE_UNUSED
,
2165 if (TARGET_DEBUG_ARG
)
2167 "setup_vararg: words = %2d, mode = %4s, pretend_size = %d, second_time = %d\n",
2168 *cum
, GET_MODE_NAME (mode
), *pretend_size
, second_time
);
2172 /* Worker function for TARGET_EXPAND_BUILTIN_SAVEREGS. */
2175 frv_expand_builtin_saveregs (void)
2177 int offset
= UNITS_PER_WORD
* FRV_NUM_ARG_REGS
;
2179 if (TARGET_DEBUG_ARG
)
2180 fprintf (stderr
, "expand_builtin_saveregs: offset from ap = %d\n",
2183 return gen_rtx_PLUS (Pmode
, virtual_incoming_args_rtx
, GEN_INT (- offset
));
2187 /* Expand __builtin_va_start to do the va_start macro. */
2190 frv_expand_builtin_va_start (tree valist
, rtx nextarg
)
2193 int num
= cfun
->args_info
- FIRST_ARG_REGNUM
- FRV_NUM_ARG_REGS
;
2195 nextarg
= gen_rtx_PLUS (Pmode
, virtual_incoming_args_rtx
,
2196 GEN_INT (UNITS_PER_WORD
* num
));
2198 if (TARGET_DEBUG_ARG
)
2200 fprintf (stderr
, "va_start: args_info = %d, num = %d\n",
2201 cfun
->args_info
, num
);
2203 debug_rtx (nextarg
);
2206 t
= build2 (GIMPLE_MODIFY_STMT
, TREE_TYPE (valist
), valist
,
2207 fold_convert (TREE_TYPE (valist
),
2208 make_tree (sizetype
, nextarg
)));
2209 TREE_SIDE_EFFECTS (t
) = 1;
2211 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2215 /* Expand a block move operation, and return 1 if successful. Return 0
2216 if we should let the compiler generate normal code.
2218 operands[0] is the destination
2219 operands[1] is the source
2220 operands[2] is the length
2221 operands[3] is the alignment */
2223 /* Maximum number of loads to do before doing the stores */
2224 #ifndef MAX_MOVE_REG
2225 #define MAX_MOVE_REG 4
2228 /* Maximum number of total loads to do. */
2229 #ifndef TOTAL_MOVE_REG
2230 #define TOTAL_MOVE_REG 8
2234 frv_expand_block_move (rtx operands
[])
2236 rtx orig_dest
= operands
[0];
2237 rtx orig_src
= operands
[1];
2238 rtx bytes_rtx
= operands
[2];
2239 rtx align_rtx
= operands
[3];
2240 int constp
= (GET_CODE (bytes_rtx
) == CONST_INT
);
2253 rtx stores
[MAX_MOVE_REG
];
2255 enum machine_mode mode
;
2257 /* If this is not a fixed size move, just call memcpy. */
2261 /* This should be a fixed size alignment. */
2262 gcc_assert (GET_CODE (align_rtx
) == CONST_INT
);
2264 align
= INTVAL (align_rtx
);
2266 /* Anything to move? */
2267 bytes
= INTVAL (bytes_rtx
);
2271 /* Don't support real large moves. */
2272 if (bytes
> TOTAL_MOVE_REG
*align
)
2275 /* Move the address into scratch registers. */
2276 dest_reg
= copy_addr_to_reg (XEXP (orig_dest
, 0));
2277 src_reg
= copy_addr_to_reg (XEXP (orig_src
, 0));
2279 num_reg
= offset
= 0;
2280 for ( ; bytes
> 0; (bytes
-= move_bytes
), (offset
+= move_bytes
))
2282 /* Calculate the correct offset for src/dest. */
2286 dest_addr
= dest_reg
;
2290 src_addr
= plus_constant (src_reg
, offset
);
2291 dest_addr
= plus_constant (dest_reg
, offset
);
2294 /* Generate the appropriate load and store, saving the stores
2296 if (bytes
>= 4 && align
>= 4)
2298 else if (bytes
>= 2 && align
>= 2)
2303 move_bytes
= GET_MODE_SIZE (mode
);
2304 tmp_reg
= gen_reg_rtx (mode
);
2305 src_mem
= change_address (orig_src
, mode
, src_addr
);
2306 dest_mem
= change_address (orig_dest
, mode
, dest_addr
);
2307 emit_insn (gen_rtx_SET (VOIDmode
, tmp_reg
, src_mem
));
2308 stores
[num_reg
++] = gen_rtx_SET (VOIDmode
, dest_mem
, tmp_reg
);
2310 if (num_reg
>= MAX_MOVE_REG
)
2312 for (i
= 0; i
< num_reg
; i
++)
2313 emit_insn (stores
[i
]);
2318 for (i
= 0; i
< num_reg
; i
++)
2319 emit_insn (stores
[i
]);
2325 /* Expand a block clear operation, and return 1 if successful. Return 0
2326 if we should let the compiler generate normal code.
2328 operands[0] is the destination
2329 operands[1] is the length
2330 operands[3] is the alignment */
2333 frv_expand_block_clear (rtx operands
[])
2335 rtx orig_dest
= operands
[0];
2336 rtx bytes_rtx
= operands
[1];
2337 rtx align_rtx
= operands
[3];
2338 int constp
= (GET_CODE (bytes_rtx
) == CONST_INT
);
2347 enum machine_mode mode
;
2349 /* If this is not a fixed size move, just call memcpy. */
2353 /* This should be a fixed size alignment. */
2354 gcc_assert (GET_CODE (align_rtx
) == CONST_INT
);
2356 align
= INTVAL (align_rtx
);
2358 /* Anything to move? */
2359 bytes
= INTVAL (bytes_rtx
);
2363 /* Don't support real large clears. */
2364 if (bytes
> TOTAL_MOVE_REG
*align
)
2367 /* Move the address into a scratch register. */
2368 dest_reg
= copy_addr_to_reg (XEXP (orig_dest
, 0));
2370 num_reg
= offset
= 0;
2371 for ( ; bytes
> 0; (bytes
-= clear_bytes
), (offset
+= clear_bytes
))
2373 /* Calculate the correct offset for src/dest. */
2374 dest_addr
= ((offset
== 0)
2376 : plus_constant (dest_reg
, offset
));
2378 /* Generate the appropriate store of gr0. */
2379 if (bytes
>= 4 && align
>= 4)
2381 else if (bytes
>= 2 && align
>= 2)
2386 clear_bytes
= GET_MODE_SIZE (mode
);
2387 dest_mem
= change_address (orig_dest
, mode
, dest_addr
);
2388 emit_insn (gen_rtx_SET (VOIDmode
, dest_mem
, const0_rtx
));
2395 /* The following variable is used to output modifiers of assembler
2396 code of the current output insn. */
2398 static rtx
*frv_insn_operands
;
2400 /* The following function is used to add assembler insn code suffix .p
2401 if it is necessary. */
2404 frv_asm_output_opcode (FILE *f
, const char *ptr
)
2408 if (frv_insn_packing_flag
<= 0)
2411 for (; *ptr
&& *ptr
!= ' ' && *ptr
!= '\t';)
2414 if (c
== '%' && ((*ptr
>= 'a' && *ptr
<= 'z')
2415 || (*ptr
>= 'A' && *ptr
<= 'Z')))
2417 int letter
= *ptr
++;
2420 frv_print_operand (f
, frv_insn_operands
[c
], letter
);
2421 while ((c
= *ptr
) >= '0' && c
<= '9')
2433 /* Set up the packing bit for the current output insn. Note that this
2434 function is not called for asm insns. */
2437 frv_final_prescan_insn (rtx insn
, rtx
*opvec
,
2438 int noperands ATTRIBUTE_UNUSED
)
2442 if (frv_insn_packing_flag
>= 0)
2444 frv_insn_operands
= opvec
;
2445 frv_insn_packing_flag
= PACKING_FLAG_P (insn
);
2447 else if (recog_memoized (insn
) >= 0
2448 && get_attr_acc_group (insn
) == ACC_GROUP_ODD
)
2449 /* Packing optimizations have been disabled, but INSN can only
2450 be issued in M1. Insert an mnop in M0. */
2451 fprintf (asm_out_file
, "\tmnop.p\n");
2457 /* A C expression whose value is RTL representing the address in a stack frame
2458 where the pointer to the caller's frame is stored. Assume that FRAMEADDR is
2459 an RTL expression for the address of the stack frame itself.
2461 If you don't define this macro, the default is to return the value of
2462 FRAMEADDR--that is, the stack frame address is also the address of the stack
2463 word that points to the previous frame. */
2465 /* The default is correct, but we need to make sure the frame gets created. */
2467 frv_dynamic_chain_address (rtx frame
)
2469 cfun
->machine
->frame_needed
= 1;
2474 /* A C expression whose value is RTL representing the value of the return
2475 address for the frame COUNT steps up from the current frame, after the
2476 prologue. FRAMEADDR is the frame pointer of the COUNT frame, or the frame
2477 pointer of the COUNT - 1 frame if `RETURN_ADDR_IN_PREVIOUS_FRAME' is
2480 The value of the expression must always be the correct address when COUNT is
2481 zero, but may be `NULL_RTX' if there is not way to determine the return
2482 address of other frames. */
2485 frv_return_addr_rtx (int count
, rtx frame
)
2489 cfun
->machine
->frame_needed
= 1;
2490 return gen_rtx_MEM (Pmode
, plus_constant (frame
, 8));
2493 /* Given a memory reference MEMREF, interpret the referenced memory as
2494 an array of MODE values, and return a reference to the element
2495 specified by INDEX. Assume that any pre-modification implicit in
2496 MEMREF has already happened.
2498 MEMREF must be a legitimate operand for modes larger than SImode.
2499 GO_IF_LEGITIMATE_ADDRESS forbids register+register addresses, which
2500 this function cannot handle. */
2502 frv_index_memory (rtx memref
, enum machine_mode mode
, int index
)
2504 rtx base
= XEXP (memref
, 0);
2505 if (GET_CODE (base
) == PRE_MODIFY
)
2506 base
= XEXP (base
, 0);
2507 return change_address (memref
, mode
,
2508 plus_constant (base
, index
* GET_MODE_SIZE (mode
)));
2512 /* Print a memory address as an operand to reference that memory location. */
2514 frv_print_operand_address (FILE * stream
, rtx x
)
2516 if (GET_CODE (x
) == MEM
)
2519 switch (GET_CODE (x
))
2522 fputs (reg_names
[ REGNO (x
)], stream
);
2526 fprintf (stream
, "%ld", (long) INTVAL (x
));
2530 assemble_name (stream
, XSTR (x
, 0));
2535 output_addr_const (stream
, x
);
2542 fatal_insn ("bad insn to frv_print_operand_address:", x
);
2547 frv_print_operand_memory_reference_reg (FILE * stream
, rtx x
)
2549 int regno
= true_regnum (x
);
2551 fputs (reg_names
[regno
], stream
);
2553 fatal_insn ("bad register to frv_print_operand_memory_reference_reg:", x
);
2556 /* Print a memory reference suitable for the ld/st instructions. */
2559 frv_print_operand_memory_reference (FILE * stream
, rtx x
, int addr_offset
)
2561 struct frv_unspec unspec
;
2565 switch (GET_CODE (x
))
2572 case PRE_MODIFY
: /* (pre_modify (reg) (plus (reg) (reg))) */
2574 x1
= XEXP (XEXP (x
, 1), 1);
2584 if (GET_CODE (x0
) == CONST_INT
)
2592 fatal_insn ("bad insn to frv_print_operand_memory_reference:", x
);
2601 else if (GET_CODE (x1
) != CONST_INT
)
2602 fatal_insn ("bad insn to frv_print_operand_memory_reference:", x
);
2605 fputs ("@(", stream
);
2607 fputs (reg_names
[GPR_R0
], stream
);
2608 else if (GET_CODE (x0
) == REG
|| GET_CODE (x0
) == SUBREG
)
2609 frv_print_operand_memory_reference_reg (stream
, x0
);
2611 fatal_insn ("bad insn to frv_print_operand_memory_reference:", x
);
2613 fputs (",", stream
);
2615 fputs (reg_names
[GPR_R0
], stream
);
2619 switch (GET_CODE (x1
))
2623 frv_print_operand_memory_reference_reg (stream
, x1
);
2627 fprintf (stream
, "%ld", (long) (INTVAL (x1
) + addr_offset
));
2631 if (!frv_const_unspec_p (x1
, &unspec
))
2632 fatal_insn ("bad insn to frv_print_operand_memory_reference:", x1
);
2633 frv_output_const_unspec (stream
, &unspec
);
2637 fatal_insn ("bad insn to frv_print_operand_memory_reference:", x
);
2641 fputs (")", stream
);
2645 /* Return 2 for likely branches and 0 for non-likely branches */
2647 #define FRV_JUMP_LIKELY 2
2648 #define FRV_JUMP_NOT_LIKELY 0
2651 frv_print_operand_jump_hint (rtx insn
)
2656 HOST_WIDE_INT prob
= -1;
2657 enum { UNKNOWN
, BACKWARD
, FORWARD
} jump_type
= UNKNOWN
;
2659 gcc_assert (GET_CODE (insn
) == JUMP_INSN
);
2661 /* Assume any non-conditional jump is likely. */
2662 if (! any_condjump_p (insn
))
2663 ret
= FRV_JUMP_LIKELY
;
2667 labelref
= condjump_label (insn
);
2670 rtx label
= XEXP (labelref
, 0);
2671 jump_type
= (insn_current_address
> INSN_ADDRESSES (INSN_UID (label
))
2676 note
= find_reg_note (insn
, REG_BR_PROB
, 0);
2678 ret
= ((jump_type
== BACKWARD
) ? FRV_JUMP_LIKELY
: FRV_JUMP_NOT_LIKELY
);
2682 prob
= INTVAL (XEXP (note
, 0));
2683 ret
= ((prob
>= (REG_BR_PROB_BASE
/ 2))
2685 : FRV_JUMP_NOT_LIKELY
);
2697 case UNKNOWN
: direction
= "unknown jump direction"; break;
2698 case BACKWARD
: direction
= "jump backward"; break;
2699 case FORWARD
: direction
= "jump forward"; break;
2703 "%s: uid %ld, %s, probability = %ld, max prob. = %ld, hint = %d\n",
2704 IDENTIFIER_POINTER (DECL_NAME (current_function_decl
)),
2705 (long)INSN_UID (insn
), direction
, (long)prob
,
2706 (long)REG_BR_PROB_BASE
, ret
);
2714 /* Return the comparison operator to use for CODE given that the ICC
2718 comparison_string (enum rtx_code code
, rtx op0
)
2720 bool is_nz_p
= GET_MODE (op0
) == CC_NZmode
;
2723 default: output_operand_lossage ("bad condition code");
2724 case EQ
: return "eq";
2725 case NE
: return "ne";
2726 case LT
: return is_nz_p
? "n" : "lt";
2727 case LE
: return "le";
2728 case GT
: return "gt";
2729 case GE
: return is_nz_p
? "p" : "ge";
2730 case LTU
: return is_nz_p
? "no" : "c";
2731 case LEU
: return is_nz_p
? "eq" : "ls";
2732 case GTU
: return is_nz_p
? "ne" : "hi";
2733 case GEU
: return is_nz_p
? "ra" : "nc";
2737 /* Print an operand to an assembler instruction.
2739 `%' followed by a letter and a digit says to output an operand in an
2740 alternate fashion. Four letters have standard, built-in meanings described
2741 below. The machine description macro `PRINT_OPERAND' can define additional
2742 letters with nonstandard meanings.
2744 `%cDIGIT' can be used to substitute an operand that is a constant value
2745 without the syntax that normally indicates an immediate operand.
2747 `%nDIGIT' is like `%cDIGIT' except that the value of the constant is negated
2750 `%aDIGIT' can be used to substitute an operand as if it were a memory
2751 reference, with the actual operand treated as the address. This may be
2752 useful when outputting a "load address" instruction, because often the
2753 assembler syntax for such an instruction requires you to write the operand
2754 as if it were a memory reference.
2756 `%lDIGIT' is used to substitute a `label_ref' into a jump instruction.
2758 `%=' outputs a number which is unique to each instruction in the entire
2759 compilation. This is useful for making local labels to be referred to more
2760 than once in a single template that generates multiple assembler
2763 `%' followed by a punctuation character specifies a substitution that does
2764 not use an operand. Only one case is standard: `%%' outputs a `%' into the
2765 assembler code. Other nonstandard cases can be defined in the
2766 `PRINT_OPERAND' macro. You must also define which punctuation characters
2767 are valid with the `PRINT_OPERAND_PUNCT_VALID_P' macro. */
2770 frv_print_operand (FILE * file
, rtx x
, int code
)
2772 struct frv_unspec unspec
;
2773 HOST_WIDE_INT value
;
2776 if (code
!= 0 && !isalpha (code
))
2779 else if (GET_CODE (x
) == CONST_INT
)
2782 else if (GET_CODE (x
) == CONST_DOUBLE
)
2784 if (GET_MODE (x
) == SFmode
)
2789 REAL_VALUE_FROM_CONST_DOUBLE (rv
, x
);
2790 REAL_VALUE_TO_TARGET_SINGLE (rv
, l
);
2794 else if (GET_MODE (x
) == VOIDmode
)
2795 value
= CONST_DOUBLE_LOW (x
);
2798 fatal_insn ("bad insn in frv_print_operand, bad const_double", x
);
2809 fputs (reg_names
[GPR_R0
], file
);
2813 fprintf (file
, "%d", frv_print_operand_jump_hint (current_output_insn
));
2817 /* Output small data area base register (gr16). */
2818 fputs (reg_names
[SDA_BASE_REG
], file
);
2822 /* Output pic register (gr17). */
2823 fputs (reg_names
[PIC_REGNO
], file
);
2827 /* Output the temporary integer CCR register. */
2828 fputs (reg_names
[ICR_TEMP
], file
);
2832 /* Output the temporary integer CC register. */
2833 fputs (reg_names
[ICC_TEMP
], file
);
2836 /* case 'a': print an address. */
2839 /* Print appropriate test for integer branch false operation. */
2840 fputs (comparison_string (reverse_condition (GET_CODE (x
)),
2841 XEXP (x
, 0)), file
);
2845 /* Print appropriate test for integer branch true operation. */
2846 fputs (comparison_string (GET_CODE (x
), XEXP (x
, 0)), file
);
2850 /* Print 1 for a NE and 0 for an EQ to give the final argument
2851 for a conditional instruction. */
2852 if (GET_CODE (x
) == NE
)
2855 else if (GET_CODE (x
) == EQ
)
2859 fatal_insn ("bad insn to frv_print_operand, 'e' modifier:", x
);
2863 /* Print appropriate test for floating point branch false operation. */
2864 switch (GET_CODE (x
))
2867 fatal_insn ("bad insn to frv_print_operand, 'F' modifier:", x
);
2869 case EQ
: fputs ("ne", file
); break;
2870 case NE
: fputs ("eq", file
); break;
2871 case LT
: fputs ("uge", file
); break;
2872 case LE
: fputs ("ug", file
); break;
2873 case GT
: fputs ("ule", file
); break;
2874 case GE
: fputs ("ul", file
); break;
2879 /* Print appropriate test for floating point branch true operation. */
2880 switch (GET_CODE (x
))
2883 fatal_insn ("bad insn to frv_print_operand, 'f' modifier:", x
);
2885 case EQ
: fputs ("eq", file
); break;
2886 case NE
: fputs ("ne", file
); break;
2887 case LT
: fputs ("lt", file
); break;
2888 case LE
: fputs ("le", file
); break;
2889 case GT
: fputs ("gt", file
); break;
2890 case GE
: fputs ("ge", file
); break;
2895 /* Print appropriate GOT function. */
2896 if (GET_CODE (x
) != CONST_INT
)
2897 fatal_insn ("bad insn to frv_print_operand, 'g' modifier:", x
);
2898 fputs (unspec_got_name (INTVAL (x
)), file
);
2902 /* Print 'i' if the operand is a constant, or is a memory reference that
2904 if (GET_CODE (x
) == MEM
)
2905 x
= ((GET_CODE (XEXP (x
, 0)) == PLUS
)
2906 ? XEXP (XEXP (x
, 0), 1)
2908 else if (GET_CODE (x
) == PLUS
)
2911 switch (GET_CODE (x
))
2925 /* For jump instructions, print 'i' if the operand is a constant or
2926 is an expression that adds a constant. */
2927 if (GET_CODE (x
) == CONST_INT
)
2932 if (GET_CODE (x
) == CONST_INT
2933 || (GET_CODE (x
) == PLUS
2934 && (GET_CODE (XEXP (x
, 1)) == CONST_INT
2935 || GET_CODE (XEXP (x
, 0)) == CONST_INT
)))
2941 /* Print the lower register of a double word register pair */
2942 if (GET_CODE (x
) == REG
)
2943 fputs (reg_names
[ REGNO (x
)+1 ], file
);
2945 fatal_insn ("bad insn to frv_print_operand, 'L' modifier:", x
);
2948 /* case 'l': print a LABEL_REF. */
2952 /* Print a memory reference for ld/st/jmp, %N prints a memory reference
2953 for the second word of double memory operations. */
2954 offset
= (code
== 'M') ? 0 : UNITS_PER_WORD
;
2955 switch (GET_CODE (x
))
2958 fatal_insn ("bad insn to frv_print_operand, 'M/N' modifier:", x
);
2961 frv_print_operand_memory_reference (file
, XEXP (x
, 0), offset
);
2969 frv_print_operand_memory_reference (file
, x
, offset
);
2975 /* Print the opcode of a command. */
2976 switch (GET_CODE (x
))
2979 fatal_insn ("bad insn to frv_print_operand, 'O' modifier:", x
);
2981 case PLUS
: fputs ("add", file
); break;
2982 case MINUS
: fputs ("sub", file
); break;
2983 case AND
: fputs ("and", file
); break;
2984 case IOR
: fputs ("or", file
); break;
2985 case XOR
: fputs ("xor", file
); break;
2986 case ASHIFT
: fputs ("sll", file
); break;
2987 case ASHIFTRT
: fputs ("sra", file
); break;
2988 case LSHIFTRT
: fputs ("srl", file
); break;
2992 /* case 'n': negate and print a constant int. */
2995 /* Print PIC label using operand as the number. */
2996 if (GET_CODE (x
) != CONST_INT
)
2997 fatal_insn ("bad insn to frv_print_operand, P modifier:", x
);
2999 fprintf (file
, ".LCF%ld", (long)INTVAL (x
));
3003 /* Print 'u' if the operand is a update load/store. */
3004 if (GET_CODE (x
) == MEM
&& GET_CODE (XEXP (x
, 0)) == PRE_MODIFY
)
3009 /* If value is 0, print gr0, otherwise it must be a register. */
3010 if (GET_CODE (x
) == CONST_INT
&& INTVAL (x
) == 0)
3011 fputs (reg_names
[GPR_R0
], file
);
3013 else if (GET_CODE (x
) == REG
)
3014 fputs (reg_names
[REGNO (x
)], file
);
3017 fatal_insn ("bad insn in frv_print_operand, z case", x
);
3021 /* Print constant in hex. */
3022 if (GET_CODE (x
) == CONST_INT
|| GET_CODE (x
) == CONST_DOUBLE
)
3024 fprintf (file
, "%s0x%.4lx", IMMEDIATE_PREFIX
, (long) value
);
3031 if (GET_CODE (x
) == REG
)
3032 fputs (reg_names
[REGNO (x
)], file
);
3034 else if (GET_CODE (x
) == CONST_INT
3035 || GET_CODE (x
) == CONST_DOUBLE
)
3036 fprintf (file
, "%s%ld", IMMEDIATE_PREFIX
, (long) value
);
3038 else if (frv_const_unspec_p (x
, &unspec
))
3039 frv_output_const_unspec (file
, &unspec
);
3041 else if (GET_CODE (x
) == MEM
)
3042 frv_print_operand_address (file
, XEXP (x
, 0));
3044 else if (CONSTANT_ADDRESS_P (x
))
3045 frv_print_operand_address (file
, x
);
3048 fatal_insn ("bad insn in frv_print_operand, 0 case", x
);
3053 fatal_insn ("frv_print_operand: unknown code", x
);
3061 /* A C statement (sans semicolon) for initializing the variable CUM for the
3062 state at the beginning of the argument list. The variable has type
3063 `CUMULATIVE_ARGS'. The value of FNTYPE is the tree node for the data type
3064 of the function which will receive the args, or 0 if the args are to a
3065 compiler support library function. The value of INDIRECT is nonzero when
3066 processing an indirect call, for example a call through a function pointer.
3067 The value of INDIRECT is zero for a call to an explicitly named function, a
3068 library function call, or when `INIT_CUMULATIVE_ARGS' is used to find
3069 arguments for the function being compiled.
3071 When processing a call to a compiler support library function, LIBNAME
3072 identifies which one. It is a `symbol_ref' rtx which contains the name of
3073 the function, as a string. LIBNAME is 0 when an ordinary C function call is
3074 being processed. Thus, each time this macro is called, either LIBNAME or
3075 FNTYPE is nonzero, but never both of them at once. */
3078 frv_init_cumulative_args (CUMULATIVE_ARGS
*cum
,
3084 *cum
= FIRST_ARG_REGNUM
;
3086 if (TARGET_DEBUG_ARG
)
3088 fprintf (stderr
, "\ninit_cumulative_args:");
3089 if (!fndecl
&& fntype
)
3090 fputs (" indirect", stderr
);
3093 fputs (" incoming", stderr
);
3097 tree ret_type
= TREE_TYPE (fntype
);
3098 fprintf (stderr
, " return=%s,",
3099 tree_code_name
[ (int)TREE_CODE (ret_type
) ]);
3102 if (libname
&& GET_CODE (libname
) == SYMBOL_REF
)
3103 fprintf (stderr
, " libname=%s", XSTR (libname
, 0));
3105 if (cfun
->returns_struct
)
3106 fprintf (stderr
, " return-struct");
3108 putc ('\n', stderr
);
3113 /* Return true if we should pass an argument on the stack rather than
3117 frv_must_pass_in_stack (enum machine_mode mode
, const_tree type
)
3119 if (mode
== BLKmode
)
3123 return AGGREGATE_TYPE_P (type
);
3126 /* If defined, a C expression that gives the alignment boundary, in bits, of an
3127 argument with the specified mode and type. If it is not defined,
3128 `PARM_BOUNDARY' is used for all arguments. */
3131 frv_function_arg_boundary (enum machine_mode mode ATTRIBUTE_UNUSED
,
3132 tree type ATTRIBUTE_UNUSED
)
3134 return BITS_PER_WORD
;
3138 frv_function_arg (CUMULATIVE_ARGS
*cum
,
3139 enum machine_mode mode
,
3140 tree type ATTRIBUTE_UNUSED
,
3142 int incoming ATTRIBUTE_UNUSED
)
3144 enum machine_mode xmode
= (mode
== BLKmode
) ? SImode
: mode
;
3149 /* Return a marker for use in the call instruction. */
3150 if (xmode
== VOIDmode
)
3156 else if (arg_num
<= LAST_ARG_REGNUM
)
3158 ret
= gen_rtx_REG (xmode
, arg_num
);
3159 debstr
= reg_names
[arg_num
];
3168 if (TARGET_DEBUG_ARG
)
3170 "function_arg: words = %2d, mode = %4s, named = %d, size = %3d, arg = %s\n",
3171 arg_num
, GET_MODE_NAME (mode
), named
, GET_MODE_SIZE (mode
), debstr
);
3177 /* A C statement (sans semicolon) to update the summarizer variable CUM to
3178 advance past an argument in the argument list. The values MODE, TYPE and
3179 NAMED describe that argument. Once this is done, the variable CUM is
3180 suitable for analyzing the *following* argument with `FUNCTION_ARG', etc.
3182 This macro need not do anything if the argument in question was passed on
3183 the stack. The compiler knows how to track the amount of stack space used
3184 for arguments without any special help. */
3187 frv_function_arg_advance (CUMULATIVE_ARGS
*cum
,
3188 enum machine_mode mode
,
3189 tree type ATTRIBUTE_UNUSED
,
3192 enum machine_mode xmode
= (mode
== BLKmode
) ? SImode
: mode
;
3193 int bytes
= GET_MODE_SIZE (xmode
);
3194 int words
= (bytes
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
3197 *cum
= arg_num
+ words
;
3199 if (TARGET_DEBUG_ARG
)
3201 "function_adv: words = %2d, mode = %4s, named = %d, size = %3d\n",
3202 arg_num
, GET_MODE_NAME (mode
), named
, words
* UNITS_PER_WORD
);
3206 /* A C expression for the number of words, at the beginning of an argument,
3207 must be put in registers. The value must be zero for arguments that are
3208 passed entirely in registers or that are entirely pushed on the stack.
3210 On some machines, certain arguments must be passed partially in registers
3211 and partially in memory. On these machines, typically the first N words of
3212 arguments are passed in registers, and the rest on the stack. If a
3213 multi-word argument (a `double' or a structure) crosses that boundary, its
3214 first few words must be passed in registers and the rest must be pushed.
3215 This macro tells the compiler when this occurs, and how many of the words
3216 should go in registers.
3218 `FUNCTION_ARG' for these arguments should return the first register to be
3219 used by the caller for this argument; likewise `FUNCTION_INCOMING_ARG', for
3220 the called function. */
3223 frv_arg_partial_bytes (CUMULATIVE_ARGS
*cum
, enum machine_mode mode
,
3224 tree type ATTRIBUTE_UNUSED
, bool named ATTRIBUTE_UNUSED
)
3226 enum machine_mode xmode
= (mode
== BLKmode
) ? SImode
: mode
;
3227 int bytes
= GET_MODE_SIZE (xmode
);
3228 int words
= (bytes
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
3232 ret
= ((arg_num
<= LAST_ARG_REGNUM
&& arg_num
+ words
> LAST_ARG_REGNUM
+1)
3233 ? LAST_ARG_REGNUM
- arg_num
+ 1
3235 ret
*= UNITS_PER_WORD
;
3237 if (TARGET_DEBUG_ARG
&& ret
)
3238 fprintf (stderr
, "frv_arg_partial_bytes: %d\n", ret
);
3244 /* Return true if a register is ok to use as a base or index register. */
3246 static FRV_INLINE
int
3247 frv_regno_ok_for_base_p (int regno
, int strict_p
)
3253 return (reg_renumber
[regno
] >= 0 && GPR_P (reg_renumber
[regno
]));
3255 if (regno
== ARG_POINTER_REGNUM
)
3258 return (regno
>= FIRST_PSEUDO_REGISTER
);
3262 /* A C compound statement with a conditional `goto LABEL;' executed if X (an
3263 RTX) is a legitimate memory address on the target machine for a memory
3264 operand of mode MODE.
3266 It usually pays to define several simpler macros to serve as subroutines for
3267 this one. Otherwise it may be too complicated to understand.
3269 This macro must exist in two variants: a strict variant and a non-strict
3270 one. The strict variant is used in the reload pass. It must be defined so
3271 that any pseudo-register that has not been allocated a hard register is
3272 considered a memory reference. In contexts where some kind of register is
3273 required, a pseudo-register with no hard register must be rejected.
3275 The non-strict variant is used in other passes. It must be defined to
3276 accept all pseudo-registers in every context where some kind of register is
3279 Compiler source files that want to use the strict variant of this macro
3280 define the macro `REG_OK_STRICT'. You should use an `#ifdef REG_OK_STRICT'
3281 conditional to define the strict variant in that case and the non-strict
3284 Subroutines to check for acceptable registers for various purposes (one for
3285 base registers, one for index registers, and so on) are typically among the
3286 subroutines used to define `GO_IF_LEGITIMATE_ADDRESS'. Then only these
3287 subroutine macros need have two variants; the higher levels of macros may be
3288 the same whether strict or not.
3290 Normally, constant addresses which are the sum of a `symbol_ref' and an
3291 integer are stored inside a `const' RTX to mark them as constant.
3292 Therefore, there is no need to recognize such sums specifically as
3293 legitimate addresses. Normally you would simply recognize any `const' as
3296 Usually `PRINT_OPERAND_ADDRESS' is not prepared to handle constant sums that
3297 are not marked with `const'. It assumes that a naked `plus' indicates
3298 indexing. If so, then you *must* reject such naked constant sums as
3299 illegitimate addresses, so that none of them will be given to
3300 `PRINT_OPERAND_ADDRESS'.
3302 On some machines, whether a symbolic address is legitimate depends on the
3303 section that the address refers to. On these machines, define the macro
3304 `ENCODE_SECTION_INFO' to store the information into the `symbol_ref', and
3305 then check for it here. When you see a `const', you will have to look
3306 inside it to find the `symbol_ref' in order to determine the section.
3308 The best way to modify the name string is by adding text to the beginning,
3309 with suitable punctuation to prevent any ambiguity. Allocate the new name
3310 in `saveable_obstack'. You will have to modify `ASM_OUTPUT_LABELREF' to
3311 remove and decode the added text and output the name accordingly, and define
3312 `(* targetm.strip_name_encoding)' to access the original name string.
3314 You can check the information stored here into the `symbol_ref' in the
3315 definitions of the macros `GO_IF_LEGITIMATE_ADDRESS' and
3316 `PRINT_OPERAND_ADDRESS'. */
3319 frv_legitimate_address_p (enum machine_mode mode
,
3323 int allow_double_reg_p
)
3327 HOST_WIDE_INT value
;
3330 if (FRV_SYMBOL_REF_TLS_P (x
))
3333 switch (GET_CODE (x
))
3340 if (GET_CODE (x
) != REG
)
3346 ret
= frv_regno_ok_for_base_p (REGNO (x
), strict_p
);
3352 if (GET_CODE (x0
) != REG
3353 || ! frv_regno_ok_for_base_p (REGNO (x0
), strict_p
)
3354 || GET_CODE (x1
) != PLUS
3355 || ! rtx_equal_p (x0
, XEXP (x1
, 0))
3356 || GET_CODE (XEXP (x1
, 1)) != REG
3357 || ! frv_regno_ok_for_base_p (REGNO (XEXP (x1
, 1)), strict_p
))
3364 /* 12-bit immediate */
3369 ret
= IN_RANGE_P (INTVAL (x
), -2048, 2047);
3371 /* If we can't use load/store double operations, make sure we can
3372 address the second word. */
3373 if (ret
&& GET_MODE_SIZE (mode
) > UNITS_PER_WORD
)
3374 ret
= IN_RANGE_P (INTVAL (x
) + GET_MODE_SIZE (mode
) - 1,
3383 if (GET_CODE (x0
) == SUBREG
)
3384 x0
= SUBREG_REG (x0
);
3386 if (GET_CODE (x0
) != REG
)
3389 regno0
= REGNO (x0
);
3390 if (!frv_regno_ok_for_base_p (regno0
, strict_p
))
3393 switch (GET_CODE (x1
))
3399 x1
= SUBREG_REG (x1
);
3400 if (GET_CODE (x1
) != REG
)
3406 /* Do not allow reg+reg addressing for modes > 1 word if we
3407 can't depend on having move double instructions. */
3408 if (!allow_double_reg_p
&& GET_MODE_SIZE (mode
) > UNITS_PER_WORD
)
3411 ret
= frv_regno_ok_for_base_p (REGNO (x1
), strict_p
);
3415 /* 12-bit immediate */
3420 value
= INTVAL (x1
);
3421 ret
= IN_RANGE_P (value
, -2048, 2047);
3423 /* If we can't use load/store double operations, make sure we can
3424 address the second word. */
3425 if (ret
&& GET_MODE_SIZE (mode
) > UNITS_PER_WORD
)
3426 ret
= IN_RANGE_P (value
+ GET_MODE_SIZE (mode
) - 1, -2048, 2047);
3431 if (!condexec_p
&& got12_operand (x1
, VOIDmode
))
3439 if (TARGET_DEBUG_ADDR
)
3441 fprintf (stderr
, "\n========== GO_IF_LEGITIMATE_ADDRESS, mode = %s, result = %d, addresses are %sstrict%s\n",
3442 GET_MODE_NAME (mode
), ret
, (strict_p
) ? "" : "not ",
3443 (condexec_p
) ? ", inside conditional code" : "");
3450 /* Given an ADDR, generate code to inline the PLT. */
3452 gen_inlined_tls_plt (rtx addr
)
3455 rtx picreg
= get_hard_reg_initial_val (Pmode
, FDPIC_REG
);
3458 dest
= gen_reg_rtx (DImode
);
3465 lddi.p @(gr15, #gottlsdesc12(ADDR)), gr8
3466 calll #gettlsoff(ADDR)@(gr8, gr0)
3468 emit_insn (gen_tls_lddi (dest
, addr
, picreg
));
3475 sethi.p #gottlsdeschi(ADDR), gr8
3476 setlo #gottlsdesclo(ADDR), gr8
3477 ldd #tlsdesc(ADDR)@(gr15, gr8), gr8
3478 calll #gettlsoff(ADDR)@(gr8, gr0)
3480 rtx reguse
= gen_reg_rtx (Pmode
);
3481 emit_insn (gen_tlsoff_hilo (reguse
, addr
, GEN_INT (R_FRV_GOTTLSDESCHI
)));
3482 emit_insn (gen_tls_tlsdesc_ldd (dest
, picreg
, reguse
, addr
));
3485 retval
= gen_reg_rtx (Pmode
);
3486 emit_insn (gen_tls_indirect_call (retval
, addr
, dest
, picreg
));
3490 /* Emit a TLSMOFF or TLSMOFF12 offset, depending on -mTLS. Returns
3491 the destination address. */
3493 gen_tlsmoff (rtx addr
, rtx reg
)
3495 rtx dest
= gen_reg_rtx (Pmode
);
3499 /* sethi.p #tlsmoffhi(x), grA
3500 setlo #tlsmofflo(x), grA
3502 dest
= gen_reg_rtx (Pmode
);
3503 emit_insn (gen_tlsoff_hilo (dest
, addr
,
3504 GEN_INT (R_FRV_TLSMOFFHI
)));
3505 dest
= gen_rtx_PLUS (Pmode
, dest
, reg
);
3509 /* addi grB, #tlsmoff12(x), grC
3511 ld/st @(grB, #tlsmoff12(x)), grC
3513 dest
= gen_reg_rtx (Pmode
);
3514 emit_insn (gen_symGOTOFF2reg_i (dest
, addr
, reg
,
3515 GEN_INT (R_FRV_TLSMOFF12
)));
3520 /* Generate code for a TLS address. */
3522 frv_legitimize_tls_address (rtx addr
, enum tls_model model
)
3524 rtx dest
, tp
= gen_rtx_REG (Pmode
, 29);
3525 rtx picreg
= get_hard_reg_initial_val (Pmode
, 15);
3529 case TLS_MODEL_INITIAL_EXEC
:
3533 ldi @(gr15, #gottlsoff12(x)), gr5
3535 dest
= gen_reg_rtx (Pmode
);
3536 emit_insn (gen_tls_load_gottlsoff12 (dest
, addr
, picreg
));
3537 dest
= gen_rtx_PLUS (Pmode
, tp
, dest
);
3541 /* -fPIC or anything else.
3543 sethi.p #gottlsoffhi(x), gr14
3544 setlo #gottlsofflo(x), gr14
3545 ld #tlsoff(x)@(gr15, gr14), gr9
3547 rtx tmp
= gen_reg_rtx (Pmode
);
3548 dest
= gen_reg_rtx (Pmode
);
3549 emit_insn (gen_tlsoff_hilo (tmp
, addr
,
3550 GEN_INT (R_FRV_GOTTLSOFF_HI
)));
3552 emit_insn (gen_tls_tlsoff_ld (dest
, picreg
, tmp
, addr
));
3553 dest
= gen_rtx_PLUS (Pmode
, tp
, dest
);
3556 case TLS_MODEL_LOCAL_DYNAMIC
:
3560 if (TARGET_INLINE_PLT
)
3561 retval
= gen_inlined_tls_plt (GEN_INT (0));
3564 /* call #gettlsoff(0) */
3565 retval
= gen_reg_rtx (Pmode
);
3566 emit_insn (gen_call_gettlsoff (retval
, GEN_INT (0), picreg
));
3569 reg
= gen_reg_rtx (Pmode
);
3570 emit_insn (gen_rtx_SET (VOIDmode
, reg
,
3571 gen_rtx_PLUS (Pmode
,
3574 dest
= gen_tlsmoff (addr
, reg
);
3577 dest = gen_reg_rtx (Pmode);
3578 emit_insn (gen_tlsoff_hilo (dest, addr,
3579 GEN_INT (R_FRV_TLSMOFFHI)));
3580 dest = gen_rtx_PLUS (Pmode, dest, reg);
3584 case TLS_MODEL_LOCAL_EXEC
:
3585 dest
= gen_tlsmoff (addr
, gen_rtx_REG (Pmode
, 29));
3587 case TLS_MODEL_GLOBAL_DYNAMIC
:
3591 if (TARGET_INLINE_PLT
)
3592 retval
= gen_inlined_tls_plt (addr
);
3595 /* call #gettlsoff(x) */
3596 retval
= gen_reg_rtx (Pmode
);
3597 emit_insn (gen_call_gettlsoff (retval
, addr
, picreg
));
3599 dest
= gen_rtx_PLUS (Pmode
, retval
, tp
);
3610 frv_legitimize_address (rtx x
,
3611 rtx oldx ATTRIBUTE_UNUSED
,
3612 enum machine_mode mode ATTRIBUTE_UNUSED
)
3614 if (GET_CODE (x
) == SYMBOL_REF
)
3616 enum tls_model model
= SYMBOL_REF_TLS_MODEL (x
);
3618 return frv_legitimize_tls_address (x
, model
);
3624 /* Test whether a local function descriptor is canonical, i.e.,
3625 whether we can use FUNCDESC_GOTOFF to compute the address of the
3629 frv_local_funcdesc_p (rtx fnx
)
3632 enum symbol_visibility vis
;
3635 if (! SYMBOL_REF_LOCAL_P (fnx
))
3638 fn
= SYMBOL_REF_DECL (fnx
);
3643 vis
= DECL_VISIBILITY (fn
);
3645 if (vis
== VISIBILITY_PROTECTED
)
3646 /* Private function descriptors for protected functions are not
3647 canonical. Temporarily change the visibility to global. */
3648 vis
= VISIBILITY_DEFAULT
;
3649 else if (flag_shlib
)
3650 /* If we're already compiling for a shared library (that, unlike
3651 executables, can't assume that the existence of a definition
3652 implies local binding), we can skip the re-testing. */
3655 ret
= default_binds_local_p_1 (fn
, flag_pic
);
3657 DECL_VISIBILITY (fn
) = vis
;
3662 /* Load the _gp symbol into DEST. SRC is supposed to be the FDPIC
3666 frv_gen_GPsym2reg (rtx dest
, rtx src
)
3668 tree gp
= get_identifier ("_gp");
3669 rtx gp_sym
= gen_rtx_SYMBOL_REF (Pmode
, IDENTIFIER_POINTER (gp
));
3671 return gen_symGOT2reg (dest
, gp_sym
, src
, GEN_INT (R_FRV_GOT12
));
3675 unspec_got_name (int i
)
3679 case R_FRV_GOT12
: return "got12";
3680 case R_FRV_GOTHI
: return "gothi";
3681 case R_FRV_GOTLO
: return "gotlo";
3682 case R_FRV_FUNCDESC
: return "funcdesc";
3683 case R_FRV_FUNCDESC_GOT12
: return "gotfuncdesc12";
3684 case R_FRV_FUNCDESC_GOTHI
: return "gotfuncdeschi";
3685 case R_FRV_FUNCDESC_GOTLO
: return "gotfuncdesclo";
3686 case R_FRV_FUNCDESC_VALUE
: return "funcdescvalue";
3687 case R_FRV_FUNCDESC_GOTOFF12
: return "gotofffuncdesc12";
3688 case R_FRV_FUNCDESC_GOTOFFHI
: return "gotofffuncdeschi";
3689 case R_FRV_FUNCDESC_GOTOFFLO
: return "gotofffuncdesclo";
3690 case R_FRV_GOTOFF12
: return "gotoff12";
3691 case R_FRV_GOTOFFHI
: return "gotoffhi";
3692 case R_FRV_GOTOFFLO
: return "gotofflo";
3693 case R_FRV_GPREL12
: return "gprel12";
3694 case R_FRV_GPRELHI
: return "gprelhi";
3695 case R_FRV_GPRELLO
: return "gprello";
3696 case R_FRV_GOTTLSOFF_HI
: return "gottlsoffhi";
3697 case R_FRV_GOTTLSOFF_LO
: return "gottlsofflo";
3698 case R_FRV_TLSMOFFHI
: return "tlsmoffhi";
3699 case R_FRV_TLSMOFFLO
: return "tlsmofflo";
3700 case R_FRV_TLSMOFF12
: return "tlsmoff12";
3701 case R_FRV_TLSDESCHI
: return "tlsdeschi";
3702 case R_FRV_TLSDESCLO
: return "tlsdesclo";
3703 case R_FRV_GOTTLSDESCHI
: return "gottlsdeschi";
3704 case R_FRV_GOTTLSDESCLO
: return "gottlsdesclo";
3705 default: gcc_unreachable ();
3709 /* Write the assembler syntax for UNSPEC to STREAM. Note that any offset
3710 is added inside the relocation operator. */
3713 frv_output_const_unspec (FILE *stream
, const struct frv_unspec
*unspec
)
3715 fprintf (stream
, "#%s(", unspec_got_name (unspec
->reloc
));
3716 output_addr_const (stream
, plus_constant (unspec
->symbol
, unspec
->offset
));
3717 fputs (")", stream
);
3720 /* Implement FIND_BASE_TERM. See whether ORIG_X represents #gprel12(foo)
3721 or #gotoff12(foo) for some small data symbol foo. If so, return foo,
3722 otherwise return ORIG_X. */
3725 frv_find_base_term (rtx x
)
3727 struct frv_unspec unspec
;
3729 if (frv_const_unspec_p (x
, &unspec
)
3730 && frv_small_data_reloc_p (unspec
.symbol
, unspec
.reloc
))
3731 return plus_constant (unspec
.symbol
, unspec
.offset
);
3736 /* Return 1 if operand is a valid FRV address. CONDEXEC_P is true if
3737 the operand is used by a predicated instruction. */
3740 frv_legitimate_memory_operand (rtx op
, enum machine_mode mode
, int condexec_p
)
3742 return ((GET_MODE (op
) == mode
|| mode
== VOIDmode
)
3743 && GET_CODE (op
) == MEM
3744 && frv_legitimate_address_p (mode
, XEXP (op
, 0),
3745 reload_completed
, condexec_p
, FALSE
));
3749 frv_expand_fdpic_call (rtx
*operands
, bool ret_value
, bool sibcall
)
3751 rtx lr
= gen_rtx_REG (Pmode
, LR_REGNO
);
3752 rtx picreg
= get_hard_reg_initial_val (SImode
, FDPIC_REG
);
3758 rvrtx
= operands
[0];
3762 addr
= XEXP (operands
[0], 0);
3764 /* Inline PLTs if we're optimizing for speed. We'd like to inline
3765 any calls that would involve a PLT, but can't tell, since we
3766 don't know whether an extern function is going to be provided by
3767 a separate translation unit or imported from a separate module.
3768 When compiling for shared libraries, if the function has default
3769 visibility, we assume it's overridable, so we inline the PLT, but
3770 for executables, we don't really have a way to make a good
3771 decision: a function is as likely to be imported from a shared
3772 library as it is to be defined in the executable itself. We
3773 assume executables will get global functions defined locally,
3774 whereas shared libraries will have them potentially overridden,
3775 so we only inline PLTs when compiling for shared libraries.
3777 In order to mark a function as local to a shared library, any
3778 non-default visibility attribute suffices. Unfortunately,
3779 there's no simple way to tag a function declaration as ``in a
3780 different module'', which we could then use to trigger PLT
3781 inlining on executables. There's -minline-plt, but it affects
3782 all external functions, so one would have to also mark function
3783 declarations available in the same module with non-default
3784 visibility, which is advantageous in itself. */
3785 if (GET_CODE (addr
) == SYMBOL_REF
3786 && ((!SYMBOL_REF_LOCAL_P (addr
) && TARGET_INLINE_PLT
)
3790 dest
= gen_reg_rtx (SImode
);
3792 x
= gen_symGOTOFF2reg_hilo (dest
, addr
, OUR_FDPIC_REG
,
3793 GEN_INT (R_FRV_FUNCDESC_GOTOFF12
));
3795 x
= gen_symGOTOFF2reg (dest
, addr
, OUR_FDPIC_REG
,
3796 GEN_INT (R_FRV_FUNCDESC_GOTOFF12
));
3798 cfun
->uses_pic_offset_table
= TRUE
;
3801 else if (GET_CODE (addr
) == SYMBOL_REF
)
3803 /* These are always either local, or handled through a local
3806 c
= gen_call_value_fdpicsi (rvrtx
, addr
, operands
[1],
3807 operands
[2], picreg
, lr
);
3809 c
= gen_call_fdpicsi (addr
, operands
[1], operands
[2], picreg
, lr
);
3813 else if (! ldd_address_operand (addr
, Pmode
))
3814 addr
= force_reg (Pmode
, addr
);
3816 picreg
= gen_reg_rtx (DImode
);
3817 emit_insn (gen_movdi_ldd (picreg
, addr
));
3819 if (sibcall
&& ret_value
)
3820 c
= gen_sibcall_value_fdpicdi (rvrtx
, picreg
, const0_rtx
);
3822 c
= gen_sibcall_fdpicdi (picreg
, const0_rtx
);
3824 c
= gen_call_value_fdpicdi (rvrtx
, picreg
, const0_rtx
, lr
);
3826 c
= gen_call_fdpicdi (picreg
, const0_rtx
, lr
);
3830 /* Look for a SYMBOL_REF of a function in an rtx. We always want to
3831 process these separately from any offsets, such that we add any
3832 offsets to the function descriptor (the actual pointer), not to the
3833 function address. */
3836 frv_function_symbol_referenced_p (rtx x
)
3842 if (GET_CODE (x
) == SYMBOL_REF
)
3843 return SYMBOL_REF_FUNCTION_P (x
);
3845 length
= GET_RTX_LENGTH (GET_CODE (x
));
3846 format
= GET_RTX_FORMAT (GET_CODE (x
));
3848 for (j
= 0; j
< length
; ++j
)
3853 if (frv_function_symbol_referenced_p (XEXP (x
, j
)))
3859 if (XVEC (x
, j
) != 0)
3862 for (k
= 0; k
< XVECLEN (x
, j
); ++k
)
3863 if (frv_function_symbol_referenced_p (XVECEXP (x
, j
, k
)))
3869 /* Nothing to do. */
3877 /* Return true if the memory operand is one that can be conditionally
3881 condexec_memory_operand (rtx op
, enum machine_mode mode
)
3883 enum machine_mode op_mode
= GET_MODE (op
);
3886 if (mode
!= VOIDmode
&& op_mode
!= mode
)
3901 if (GET_CODE (op
) != MEM
)
3904 addr
= XEXP (op
, 0);
3905 return frv_legitimate_address_p (mode
, addr
, reload_completed
, TRUE
, FALSE
);
3908 /* Return true if the bare return instruction can be used outside of the
3909 epilog code. For frv, we only do it if there was no stack allocation. */
3912 direct_return_p (void)
3916 if (!reload_completed
)
3919 info
= frv_stack_info ();
3920 return (info
->total_size
== 0);
3925 frv_emit_move (enum machine_mode mode
, rtx dest
, rtx src
)
3927 if (GET_CODE (src
) == SYMBOL_REF
)
3929 enum tls_model model
= SYMBOL_REF_TLS_MODEL (src
);
3931 src
= frv_legitimize_tls_address (src
, model
);
3937 if (frv_emit_movsi (dest
, src
))
3946 if (!reload_in_progress
3947 && !reload_completed
3948 && !register_operand (dest
, mode
)
3949 && !reg_or_0_operand (src
, mode
))
3950 src
= copy_to_mode_reg (mode
, src
);
3957 emit_insn (gen_rtx_SET (VOIDmode
, dest
, src
));
3960 /* Emit code to handle a MOVSI, adding in the small data register or pic
3961 register if needed to load up addresses. Return TRUE if the appropriate
3962 instructions are emitted. */
3965 frv_emit_movsi (rtx dest
, rtx src
)
3967 int base_regno
= -1;
3970 struct frv_unspec old_unspec
;
3972 if (!reload_in_progress
3973 && !reload_completed
3974 && !register_operand (dest
, SImode
)
3975 && (!reg_or_0_operand (src
, SImode
)
3976 /* Virtual registers will almost always be replaced by an
3977 add instruction, so expose this to CSE by copying to
3978 an intermediate register. */
3979 || (GET_CODE (src
) == REG
3980 && IN_RANGE_P (REGNO (src
),
3981 FIRST_VIRTUAL_REGISTER
,
3982 LAST_VIRTUAL_REGISTER
))))
3984 emit_insn (gen_rtx_SET (VOIDmode
, dest
, copy_to_mode_reg (SImode
, src
)));
3988 /* Explicitly add in the PIC or small data register if needed. */
3989 switch (GET_CODE (src
))
3998 /* Using GPREL12, we use a single GOT entry for all symbols
3999 in read-only sections, but trade sequences such as:
4001 sethi #gothi(label), gr#
4002 setlo #gotlo(label), gr#
4007 ld @(gr15,#got12(_gp)), gr#
4008 sethi #gprelhi(label), gr##
4009 setlo #gprello(label), gr##
4012 We may often be able to share gr# for multiple
4013 computations of GPREL addresses, and we may often fold
4014 the final add into the pair of registers of a load or
4015 store instruction, so it's often profitable. Even when
4016 optimizing for size, we're trading a GOT entry for an
4017 additional instruction, which trades GOT space
4018 (read-write) for code size (read-only, shareable), as
4019 long as the symbol is not used in more than two different
4022 With -fpie/-fpic, we'd be trading a single load for a
4023 sequence of 4 instructions, because the offset of the
4024 label can't be assumed to be addressable with 12 bits, so
4025 we don't do this. */
4026 if (TARGET_GPREL_RO
)
4027 unspec
= R_FRV_GPREL12
;
4029 unspec
= R_FRV_GOT12
;
4032 base_regno
= PIC_REGNO
;
4037 if (frv_const_unspec_p (src
, &old_unspec
))
4040 if (TARGET_FDPIC
&& frv_function_symbol_referenced_p (XEXP (src
, 0)))
4043 src
= force_reg (GET_MODE (XEXP (src
, 0)), XEXP (src
, 0));
4044 emit_move_insn (dest
, src
);
4049 sym
= XEXP (sym
, 0);
4050 if (GET_CODE (sym
) == PLUS
4051 && GET_CODE (XEXP (sym
, 0)) == SYMBOL_REF
4052 && GET_CODE (XEXP (sym
, 1)) == CONST_INT
)
4053 sym
= XEXP (sym
, 0);
4054 if (GET_CODE (sym
) == SYMBOL_REF
)
4056 else if (GET_CODE (sym
) == LABEL_REF
)
4059 goto handle_whatever
;
4067 enum tls_model model
= SYMBOL_REF_TLS_MODEL (sym
);
4071 src
= frv_legitimize_tls_address (src
, model
);
4072 emit_move_insn (dest
, src
);
4076 if (SYMBOL_REF_FUNCTION_P (sym
))
4078 if (frv_local_funcdesc_p (sym
))
4079 unspec
= R_FRV_FUNCDESC_GOTOFF12
;
4081 unspec
= R_FRV_FUNCDESC_GOT12
;
4085 if (CONSTANT_POOL_ADDRESS_P (sym
))
4086 switch (GET_CODE (get_pool_constant (sym
)))
4093 unspec
= R_FRV_GOTOFF12
;
4098 if (TARGET_GPREL_RO
)
4099 unspec
= R_FRV_GPREL12
;
4101 unspec
= R_FRV_GOT12
;
4104 else if (SYMBOL_REF_LOCAL_P (sym
)
4105 && !SYMBOL_REF_EXTERNAL_P (sym
)
4106 && SYMBOL_REF_DECL (sym
)
4107 && (!DECL_P (SYMBOL_REF_DECL (sym
))
4108 || !DECL_COMMON (SYMBOL_REF_DECL (sym
))))
4110 tree decl
= SYMBOL_REF_DECL (sym
);
4111 tree init
= TREE_CODE (decl
) == VAR_DECL
4112 ? DECL_INITIAL (decl
)
4113 : TREE_CODE (decl
) == CONSTRUCTOR
4116 bool named_section
, readonly
;
4118 if (init
&& init
!= error_mark_node
)
4119 reloc
= compute_reloc_for_constant (init
);
4121 named_section
= TREE_CODE (decl
) == VAR_DECL
4122 && lookup_attribute ("section", DECL_ATTRIBUTES (decl
));
4123 readonly
= decl_readonly_section (decl
, reloc
);
4126 unspec
= R_FRV_GOT12
;
4128 unspec
= R_FRV_GOTOFF12
;
4129 else if (readonly
&& TARGET_GPREL_RO
)
4130 unspec
= R_FRV_GPREL12
;
4132 unspec
= R_FRV_GOT12
;
4135 unspec
= R_FRV_GOT12
;
4139 else if (SYMBOL_REF_SMALL_P (sym
))
4140 base_regno
= SDA_BASE_REG
;
4143 base_regno
= PIC_REGNO
;
4148 if (base_regno
>= 0)
4150 if (GET_CODE (sym
) == SYMBOL_REF
&& SYMBOL_REF_SMALL_P (sym
))
4151 emit_insn (gen_symGOTOFF2reg (dest
, src
,
4152 gen_rtx_REG (Pmode
, base_regno
),
4153 GEN_INT (R_FRV_GPREL12
)));
4155 emit_insn (gen_symGOTOFF2reg_hilo (dest
, src
,
4156 gen_rtx_REG (Pmode
, base_regno
),
4157 GEN_INT (R_FRV_GPREL12
)));
4158 if (base_regno
== PIC_REGNO
)
4159 cfun
->uses_pic_offset_table
= TRUE
;
4167 /* Since OUR_FDPIC_REG is a pseudo register, we can't safely introduce
4168 new uses of it once reload has begun. */
4169 gcc_assert (!reload_in_progress
&& !reload_completed
);
4173 case R_FRV_GOTOFF12
:
4174 if (!frv_small_data_reloc_p (sym
, unspec
))
4175 x
= gen_symGOTOFF2reg_hilo (dest
, src
, OUR_FDPIC_REG
,
4178 x
= gen_symGOTOFF2reg (dest
, src
, OUR_FDPIC_REG
, GEN_INT (unspec
));
4181 if (!frv_small_data_reloc_p (sym
, unspec
))
4182 x
= gen_symGPREL2reg_hilo (dest
, src
, OUR_FDPIC_REG
,
4185 x
= gen_symGPREL2reg (dest
, src
, OUR_FDPIC_REG
, GEN_INT (unspec
));
4187 case R_FRV_FUNCDESC_GOTOFF12
:
4189 x
= gen_symGOTOFF2reg_hilo (dest
, src
, OUR_FDPIC_REG
,
4192 x
= gen_symGOTOFF2reg (dest
, src
, OUR_FDPIC_REG
, GEN_INT (unspec
));
4196 x
= gen_symGOT2reg_hilo (dest
, src
, OUR_FDPIC_REG
,
4199 x
= gen_symGOT2reg (dest
, src
, OUR_FDPIC_REG
, GEN_INT (unspec
));
4203 cfun
->uses_pic_offset_table
= TRUE
;
4212 /* Return a string to output a single word move. */
4215 output_move_single (rtx operands
[], rtx insn
)
4217 rtx dest
= operands
[0];
4218 rtx src
= operands
[1];
4220 if (GET_CODE (dest
) == REG
)
4222 int dest_regno
= REGNO (dest
);
4223 enum machine_mode mode
= GET_MODE (dest
);
4225 if (GPR_P (dest_regno
))
4227 if (GET_CODE (src
) == REG
)
4229 /* gpr <- some sort of register */
4230 int src_regno
= REGNO (src
);
4232 if (GPR_P (src_regno
))
4233 return "mov %1, %0";
4235 else if (FPR_P (src_regno
))
4236 return "movfg %1, %0";
4238 else if (SPR_P (src_regno
))
4239 return "movsg %1, %0";
4242 else if (GET_CODE (src
) == MEM
)
4251 return "ldsb%I1%U1 %M1,%0";
4254 return "ldsh%I1%U1 %M1,%0";
4258 return "ld%I1%U1 %M1, %0";
4262 else if (GET_CODE (src
) == CONST_INT
4263 || GET_CODE (src
) == CONST_DOUBLE
)
4265 /* gpr <- integer/floating constant */
4266 HOST_WIDE_INT value
;
4268 if (GET_CODE (src
) == CONST_INT
)
4269 value
= INTVAL (src
);
4271 else if (mode
== SFmode
)
4276 REAL_VALUE_FROM_CONST_DOUBLE (rv
, src
);
4277 REAL_VALUE_TO_TARGET_SINGLE (rv
, l
);
4282 value
= CONST_DOUBLE_LOW (src
);
4284 if (IN_RANGE_P (value
, -32768, 32767))
4285 return "setlos %1, %0";
4290 else if (GET_CODE (src
) == SYMBOL_REF
4291 || GET_CODE (src
) == LABEL_REF
4292 || GET_CODE (src
) == CONST
)
4298 else if (FPR_P (dest_regno
))
4300 if (GET_CODE (src
) == REG
)
4302 /* fpr <- some sort of register */
4303 int src_regno
= REGNO (src
);
4305 if (GPR_P (src_regno
))
4306 return "movgf %1, %0";
4308 else if (FPR_P (src_regno
))
4310 if (TARGET_HARD_FLOAT
)
4311 return "fmovs %1, %0";
4313 return "mor %1, %1, %0";
4317 else if (GET_CODE (src
) == MEM
)
4326 return "ldbf%I1%U1 %M1,%0";
4329 return "ldhf%I1%U1 %M1,%0";
4333 return "ldf%I1%U1 %M1, %0";
4337 else if (ZERO_P (src
))
4338 return "movgf %., %0";
4341 else if (SPR_P (dest_regno
))
4343 if (GET_CODE (src
) == REG
)
4345 /* spr <- some sort of register */
4346 int src_regno
= REGNO (src
);
4348 if (GPR_P (src_regno
))
4349 return "movgs %1, %0";
4351 else if (ZERO_P (src
))
4352 return "movgs %., %0";
4356 else if (GET_CODE (dest
) == MEM
)
4358 if (GET_CODE (src
) == REG
)
4360 int src_regno
= REGNO (src
);
4361 enum machine_mode mode
= GET_MODE (dest
);
4363 if (GPR_P (src_regno
))
4371 return "stb%I0%U0 %1, %M0";
4374 return "sth%I0%U0 %1, %M0";
4378 return "st%I0%U0 %1, %M0";
4382 else if (FPR_P (src_regno
))
4390 return "stbf%I0%U0 %1, %M0";
4393 return "sthf%I0%U0 %1, %M0";
4397 return "stf%I0%U0 %1, %M0";
4402 else if (ZERO_P (src
))
4404 switch (GET_MODE (dest
))
4410 return "stb%I0%U0 %., %M0";
4413 return "sth%I0%U0 %., %M0";
4417 return "st%I0%U0 %., %M0";
4422 fatal_insn ("bad output_move_single operand", insn
);
4427 /* Return a string to output a double word move. */
4430 output_move_double (rtx operands
[], rtx insn
)
4432 rtx dest
= operands
[0];
4433 rtx src
= operands
[1];
4434 enum machine_mode mode
= GET_MODE (dest
);
4436 if (GET_CODE (dest
) == REG
)
4438 int dest_regno
= REGNO (dest
);
4440 if (GPR_P (dest_regno
))
4442 if (GET_CODE (src
) == REG
)
4444 /* gpr <- some sort of register */
4445 int src_regno
= REGNO (src
);
4447 if (GPR_P (src_regno
))
4450 else if (FPR_P (src_regno
))
4452 if (((dest_regno
- GPR_FIRST
) & 1) == 0
4453 && ((src_regno
- FPR_FIRST
) & 1) == 0)
4454 return "movfgd %1, %0";
4460 else if (GET_CODE (src
) == MEM
)
4463 if (dbl_memory_one_insn_operand (src
, mode
))
4464 return "ldd%I1%U1 %M1, %0";
4469 else if (GET_CODE (src
) == CONST_INT
4470 || GET_CODE (src
) == CONST_DOUBLE
)
4474 else if (FPR_P (dest_regno
))
4476 if (GET_CODE (src
) == REG
)
4478 /* fpr <- some sort of register */
4479 int src_regno
= REGNO (src
);
4481 if (GPR_P (src_regno
))
4483 if (((dest_regno
- FPR_FIRST
) & 1) == 0
4484 && ((src_regno
- GPR_FIRST
) & 1) == 0)
4485 return "movgfd %1, %0";
4490 else if (FPR_P (src_regno
))
4493 && ((dest_regno
- FPR_FIRST
) & 1) == 0
4494 && ((src_regno
- FPR_FIRST
) & 1) == 0)
4495 return "fmovd %1, %0";
4501 else if (GET_CODE (src
) == MEM
)
4504 if (dbl_memory_one_insn_operand (src
, mode
))
4505 return "lddf%I1%U1 %M1, %0";
4510 else if (ZERO_P (src
))
4515 else if (GET_CODE (dest
) == MEM
)
4517 if (GET_CODE (src
) == REG
)
4519 int src_regno
= REGNO (src
);
4521 if (GPR_P (src_regno
))
4523 if (((src_regno
- GPR_FIRST
) & 1) == 0
4524 && dbl_memory_one_insn_operand (dest
, mode
))
4525 return "std%I0%U0 %1, %M0";
4530 if (FPR_P (src_regno
))
4532 if (((src_regno
- FPR_FIRST
) & 1) == 0
4533 && dbl_memory_one_insn_operand (dest
, mode
))
4534 return "stdf%I0%U0 %1, %M0";
4540 else if (ZERO_P (src
))
4542 if (dbl_memory_one_insn_operand (dest
, mode
))
4543 return "std%I0%U0 %., %M0";
4549 fatal_insn ("bad output_move_double operand", insn
);
4554 /* Return a string to output a single word conditional move.
4555 Operand0 -- EQ/NE of ccr register and 0
4556 Operand1 -- CCR register
4557 Operand2 -- destination
4558 Operand3 -- source */
4561 output_condmove_single (rtx operands
[], rtx insn
)
4563 rtx dest
= operands
[2];
4564 rtx src
= operands
[3];
4566 if (GET_CODE (dest
) == REG
)
4568 int dest_regno
= REGNO (dest
);
4569 enum machine_mode mode
= GET_MODE (dest
);
4571 if (GPR_P (dest_regno
))
4573 if (GET_CODE (src
) == REG
)
4575 /* gpr <- some sort of register */
4576 int src_regno
= REGNO (src
);
4578 if (GPR_P (src_regno
))
4579 return "cmov %z3, %2, %1, %e0";
4581 else if (FPR_P (src_regno
))
4582 return "cmovfg %3, %2, %1, %e0";
4585 else if (GET_CODE (src
) == MEM
)
4594 return "cldsb%I3%U3 %M3, %2, %1, %e0";
4597 return "cldsh%I3%U3 %M3, %2, %1, %e0";
4601 return "cld%I3%U3 %M3, %2, %1, %e0";
4605 else if (ZERO_P (src
))
4606 return "cmov %., %2, %1, %e0";
4609 else if (FPR_P (dest_regno
))
4611 if (GET_CODE (src
) == REG
)
4613 /* fpr <- some sort of register */
4614 int src_regno
= REGNO (src
);
4616 if (GPR_P (src_regno
))
4617 return "cmovgf %3, %2, %1, %e0";
4619 else if (FPR_P (src_regno
))
4621 if (TARGET_HARD_FLOAT
)
4622 return "cfmovs %3,%2,%1,%e0";
4624 return "cmor %3, %3, %2, %1, %e0";
4628 else if (GET_CODE (src
) == MEM
)
4631 if (mode
== SImode
|| mode
== SFmode
)
4632 return "cldf%I3%U3 %M3, %2, %1, %e0";
4635 else if (ZERO_P (src
))
4636 return "cmovgf %., %2, %1, %e0";
4640 else if (GET_CODE (dest
) == MEM
)
4642 if (GET_CODE (src
) == REG
)
4644 int src_regno
= REGNO (src
);
4645 enum machine_mode mode
= GET_MODE (dest
);
4647 if (GPR_P (src_regno
))
4655 return "cstb%I2%U2 %3, %M2, %1, %e0";
4658 return "csth%I2%U2 %3, %M2, %1, %e0";
4662 return "cst%I2%U2 %3, %M2, %1, %e0";
4666 else if (FPR_P (src_regno
) && (mode
== SImode
|| mode
== SFmode
))
4667 return "cstf%I2%U2 %3, %M2, %1, %e0";
4670 else if (ZERO_P (src
))
4672 enum machine_mode mode
= GET_MODE (dest
);
4679 return "cstb%I2%U2 %., %M2, %1, %e0";
4682 return "csth%I2%U2 %., %M2, %1, %e0";
4686 return "cst%I2%U2 %., %M2, %1, %e0";
4691 fatal_insn ("bad output_condmove_single operand", insn
);
4696 /* Emit the appropriate code to do a comparison, returning the register the
4697 comparison was done it. */
4700 frv_emit_comparison (enum rtx_code test
, rtx op0
, rtx op1
)
4702 enum machine_mode cc_mode
;
4705 /* Floating point doesn't have comparison against a constant. */
4706 if (GET_MODE (op0
) == CC_FPmode
&& GET_CODE (op1
) != REG
)
4707 op1
= force_reg (GET_MODE (op0
), op1
);
4709 /* Possibly disable using anything but a fixed register in order to work
4710 around cse moving comparisons past function calls. */
4711 cc_mode
= SELECT_CC_MODE (test
, op0
, op1
);
4712 cc_reg
= ((TARGET_ALLOC_CC
)
4713 ? gen_reg_rtx (cc_mode
)
4714 : gen_rtx_REG (cc_mode
,
4715 (cc_mode
== CC_FPmode
) ? FCC_FIRST
: ICC_FIRST
));
4717 emit_insn (gen_rtx_SET (VOIDmode
, cc_reg
,
4718 gen_rtx_COMPARE (cc_mode
, op0
, op1
)));
4724 /* Emit code for a conditional branch. The comparison operands were previously
4725 stored in frv_compare_op0 and frv_compare_op1.
4727 XXX: I originally wanted to add a clobber of a CCR register to use in
4728 conditional execution, but that confuses the rest of the compiler. */
4731 frv_emit_cond_branch (enum rtx_code test
, rtx label
)
4736 rtx cc_reg
= frv_emit_comparison (test
, frv_compare_op0
, frv_compare_op1
);
4737 enum machine_mode cc_mode
= GET_MODE (cc_reg
);
4739 /* Branches generate:
4741 (if_then_else (<test>, <cc_reg>, (const_int 0))
4742 (label_ref <branch_label>)
4744 label_ref
= gen_rtx_LABEL_REF (VOIDmode
, label
);
4745 test_rtx
= gen_rtx_fmt_ee (test
, cc_mode
, cc_reg
, const0_rtx
);
4746 if_else
= gen_rtx_IF_THEN_ELSE (cc_mode
, test_rtx
, label_ref
, pc_rtx
);
4747 emit_jump_insn (gen_rtx_SET (VOIDmode
, pc_rtx
, if_else
));
4752 /* Emit code to set a gpr to 1/0 based on a comparison. The comparison
4753 operands were previously stored in frv_compare_op0 and frv_compare_op1. */
4756 frv_emit_scc (enum rtx_code test
, rtx target
)
4762 rtx cc_reg
= frv_emit_comparison (test
, frv_compare_op0
, frv_compare_op1
);
4764 /* SCC instructions generate:
4765 (parallel [(set <target> (<test>, <cc_reg>, (const_int 0))
4766 (clobber (<ccr_reg>))]) */
4767 test_rtx
= gen_rtx_fmt_ee (test
, SImode
, cc_reg
, const0_rtx
);
4768 set
= gen_rtx_SET (VOIDmode
, target
, test_rtx
);
4770 cr_reg
= ((TARGET_ALLOC_CC
)
4771 ? gen_reg_rtx (CC_CCRmode
)
4772 : gen_rtx_REG (CC_CCRmode
,
4773 ((GET_MODE (cc_reg
) == CC_FPmode
)
4777 clobber
= gen_rtx_CLOBBER (VOIDmode
, cr_reg
);
4778 emit_insn (gen_rtx_PARALLEL (VOIDmode
, gen_rtvec (2, set
, clobber
)));
4783 /* Split a SCC instruction into component parts, returning a SEQUENCE to hold
4784 the separate insns. */
4787 frv_split_scc (rtx dest
, rtx test
, rtx cc_reg
, rtx cr_reg
, HOST_WIDE_INT value
)
4793 /* Set the appropriate CCR bit. */
4794 emit_insn (gen_rtx_SET (VOIDmode
,
4796 gen_rtx_fmt_ee (GET_CODE (test
),
4801 /* Move the value into the destination. */
4802 emit_move_insn (dest
, GEN_INT (value
));
4804 /* Move 0 into the destination if the test failed */
4805 emit_insn (gen_rtx_COND_EXEC (VOIDmode
,
4806 gen_rtx_EQ (GET_MODE (cr_reg
),
4809 gen_rtx_SET (VOIDmode
, dest
, const0_rtx
)));
4811 /* Finish up, return sequence. */
4818 /* Emit the code for a conditional move, return TRUE if we could do the
4822 frv_emit_cond_move (rtx dest
, rtx test_rtx
, rtx src1
, rtx src2
)
4829 enum rtx_code test
= GET_CODE (test_rtx
);
4830 rtx cc_reg
= frv_emit_comparison (test
, frv_compare_op0
, frv_compare_op1
);
4831 enum machine_mode cc_mode
= GET_MODE (cc_reg
);
4833 /* Conditional move instructions generate:
4834 (parallel [(set <target>
4835 (if_then_else (<test> <cc_reg> (const_int 0))
4838 (clobber (<ccr_reg>))]) */
4840 /* Handle various cases of conditional move involving two constants. */
4841 if (GET_CODE (src1
) == CONST_INT
&& GET_CODE (src2
) == CONST_INT
)
4843 HOST_WIDE_INT value1
= INTVAL (src1
);
4844 HOST_WIDE_INT value2
= INTVAL (src2
);
4846 /* Having 0 as one of the constants can be done by loading the other
4847 constant, and optionally moving in gr0. */
4848 if (value1
== 0 || value2
== 0)
4851 /* If the first value is within an addi range and also the difference
4852 between the two fits in an addi's range, load up the difference, then
4853 conditionally move in 0, and then unconditionally add the first
4855 else if (IN_RANGE_P (value1
, -2048, 2047)
4856 && IN_RANGE_P (value2
- value1
, -2048, 2047))
4859 /* If neither condition holds, just force the constant into a
4863 src1
= force_reg (GET_MODE (dest
), src1
);
4864 src2
= force_reg (GET_MODE (dest
), src2
);
4868 /* If one value is a register, insure the other value is either 0 or a
4872 if (GET_CODE (src1
) == CONST_INT
&& INTVAL (src1
) != 0)
4873 src1
= force_reg (GET_MODE (dest
), src1
);
4875 if (GET_CODE (src2
) == CONST_INT
&& INTVAL (src2
) != 0)
4876 src2
= force_reg (GET_MODE (dest
), src2
);
4879 test2
= gen_rtx_fmt_ee (test
, cc_mode
, cc_reg
, const0_rtx
);
4880 if_rtx
= gen_rtx_IF_THEN_ELSE (GET_MODE (dest
), test2
, src1
, src2
);
4882 set
= gen_rtx_SET (VOIDmode
, dest
, if_rtx
);
4884 cr_reg
= ((TARGET_ALLOC_CC
)
4885 ? gen_reg_rtx (CC_CCRmode
)
4886 : gen_rtx_REG (CC_CCRmode
,
4887 (cc_mode
== CC_FPmode
) ? FCR_FIRST
: ICR_FIRST
));
4889 clobber_cc
= gen_rtx_CLOBBER (VOIDmode
, cr_reg
);
4890 emit_insn (gen_rtx_PARALLEL (VOIDmode
, gen_rtvec (2, set
, clobber_cc
)));
4895 /* Split a conditional move into constituent parts, returning a SEQUENCE
4896 containing all of the insns. */
4899 frv_split_cond_move (rtx operands
[])
4901 rtx dest
= operands
[0];
4902 rtx test
= operands
[1];
4903 rtx cc_reg
= operands
[2];
4904 rtx src1
= operands
[3];
4905 rtx src2
= operands
[4];
4906 rtx cr_reg
= operands
[5];
4908 enum machine_mode cr_mode
= GET_MODE (cr_reg
);
4912 /* Set the appropriate CCR bit. */
4913 emit_insn (gen_rtx_SET (VOIDmode
,
4915 gen_rtx_fmt_ee (GET_CODE (test
),
4920 /* Handle various cases of conditional move involving two constants. */
4921 if (GET_CODE (src1
) == CONST_INT
&& GET_CODE (src2
) == CONST_INT
)
4923 HOST_WIDE_INT value1
= INTVAL (src1
);
4924 HOST_WIDE_INT value2
= INTVAL (src2
);
4926 /* Having 0 as one of the constants can be done by loading the other
4927 constant, and optionally moving in gr0. */
4930 emit_move_insn (dest
, src2
);
4931 emit_insn (gen_rtx_COND_EXEC (VOIDmode
,
4932 gen_rtx_NE (cr_mode
, cr_reg
,
4934 gen_rtx_SET (VOIDmode
, dest
, src1
)));
4937 else if (value2
== 0)
4939 emit_move_insn (dest
, src1
);
4940 emit_insn (gen_rtx_COND_EXEC (VOIDmode
,
4941 gen_rtx_EQ (cr_mode
, cr_reg
,
4943 gen_rtx_SET (VOIDmode
, dest
, src2
)));
4946 /* If the first value is within an addi range and also the difference
4947 between the two fits in an addi's range, load up the difference, then
4948 conditionally move in 0, and then unconditionally add the first
4950 else if (IN_RANGE_P (value1
, -2048, 2047)
4951 && IN_RANGE_P (value2
- value1
, -2048, 2047))
4953 rtx dest_si
= ((GET_MODE (dest
) == SImode
)
4955 : gen_rtx_SUBREG (SImode
, dest
, 0));
4957 emit_move_insn (dest_si
, GEN_INT (value2
- value1
));
4958 emit_insn (gen_rtx_COND_EXEC (VOIDmode
,
4959 gen_rtx_NE (cr_mode
, cr_reg
,
4961 gen_rtx_SET (VOIDmode
, dest_si
,
4963 emit_insn (gen_addsi3 (dest_si
, dest_si
, src1
));
4971 /* Emit the conditional move for the test being true if needed. */
4972 if (! rtx_equal_p (dest
, src1
))
4973 emit_insn (gen_rtx_COND_EXEC (VOIDmode
,
4974 gen_rtx_NE (cr_mode
, cr_reg
, const0_rtx
),
4975 gen_rtx_SET (VOIDmode
, dest
, src1
)));
4977 /* Emit the conditional move for the test being false if needed. */
4978 if (! rtx_equal_p (dest
, src2
))
4979 emit_insn (gen_rtx_COND_EXEC (VOIDmode
,
4980 gen_rtx_EQ (cr_mode
, cr_reg
, const0_rtx
),
4981 gen_rtx_SET (VOIDmode
, dest
, src2
)));
4984 /* Finish up, return sequence. */
4991 /* Split (set DEST SOURCE), where DEST is a double register and SOURCE is a
4992 memory location that is not known to be dword-aligned. */
4994 frv_split_double_load (rtx dest
, rtx source
)
4996 int regno
= REGNO (dest
);
4997 rtx dest1
= gen_highpart (SImode
, dest
);
4998 rtx dest2
= gen_lowpart (SImode
, dest
);
4999 rtx address
= XEXP (source
, 0);
5001 /* If the address is pre-modified, load the lower-numbered register
5002 first, then load the other register using an integer offset from
5003 the modified base register. This order should always be safe,
5004 since the pre-modification cannot affect the same registers as the
5007 The situation for other loads is more complicated. Loading one
5008 of the registers could affect the value of ADDRESS, so we must
5009 be careful which order we do them in. */
5010 if (GET_CODE (address
) == PRE_MODIFY
5011 || ! refers_to_regno_p (regno
, regno
+ 1, address
, NULL
))
5013 /* It is safe to load the lower-numbered register first. */
5014 emit_move_insn (dest1
, change_address (source
, SImode
, NULL
));
5015 emit_move_insn (dest2
, frv_index_memory (source
, SImode
, 1));
5019 /* ADDRESS is not pre-modified and the address depends on the
5020 lower-numbered register. Load the higher-numbered register
5022 emit_move_insn (dest2
, frv_index_memory (source
, SImode
, 1));
5023 emit_move_insn (dest1
, change_address (source
, SImode
, NULL
));
5027 /* Split (set DEST SOURCE), where DEST refers to a dword memory location
5028 and SOURCE is either a double register or the constant zero. */
5030 frv_split_double_store (rtx dest
, rtx source
)
5032 rtx dest1
= change_address (dest
, SImode
, NULL
);
5033 rtx dest2
= frv_index_memory (dest
, SImode
, 1);
5034 if (ZERO_P (source
))
5036 emit_move_insn (dest1
, CONST0_RTX (SImode
));
5037 emit_move_insn (dest2
, CONST0_RTX (SImode
));
5041 emit_move_insn (dest1
, gen_highpart (SImode
, source
));
5042 emit_move_insn (dest2
, gen_lowpart (SImode
, source
));
5047 /* Split a min/max operation returning a SEQUENCE containing all of the
5051 frv_split_minmax (rtx operands
[])
5053 rtx dest
= operands
[0];
5054 rtx minmax
= operands
[1];
5055 rtx src1
= operands
[2];
5056 rtx src2
= operands
[3];
5057 rtx cc_reg
= operands
[4];
5058 rtx cr_reg
= operands
[5];
5060 enum rtx_code test_code
;
5061 enum machine_mode cr_mode
= GET_MODE (cr_reg
);
5065 /* Figure out which test to use. */
5066 switch (GET_CODE (minmax
))
5071 case SMIN
: test_code
= LT
; break;
5072 case SMAX
: test_code
= GT
; break;
5073 case UMIN
: test_code
= LTU
; break;
5074 case UMAX
: test_code
= GTU
; break;
5077 /* Issue the compare instruction. */
5078 emit_insn (gen_rtx_SET (VOIDmode
,
5080 gen_rtx_COMPARE (GET_MODE (cc_reg
),
5083 /* Set the appropriate CCR bit. */
5084 emit_insn (gen_rtx_SET (VOIDmode
,
5086 gen_rtx_fmt_ee (test_code
,
5091 /* If are taking the min/max of a nonzero constant, load that first, and
5092 then do a conditional move of the other value. */
5093 if (GET_CODE (src2
) == CONST_INT
&& INTVAL (src2
) != 0)
5095 gcc_assert (!rtx_equal_p (dest
, src1
));
5097 emit_move_insn (dest
, src2
);
5098 emit_insn (gen_rtx_COND_EXEC (VOIDmode
,
5099 gen_rtx_NE (cr_mode
, cr_reg
, const0_rtx
),
5100 gen_rtx_SET (VOIDmode
, dest
, src1
)));
5103 /* Otherwise, do each half of the move. */
5106 /* Emit the conditional move for the test being true if needed. */
5107 if (! rtx_equal_p (dest
, src1
))
5108 emit_insn (gen_rtx_COND_EXEC (VOIDmode
,
5109 gen_rtx_NE (cr_mode
, cr_reg
, const0_rtx
),
5110 gen_rtx_SET (VOIDmode
, dest
, src1
)));
5112 /* Emit the conditional move for the test being false if needed. */
5113 if (! rtx_equal_p (dest
, src2
))
5114 emit_insn (gen_rtx_COND_EXEC (VOIDmode
,
5115 gen_rtx_EQ (cr_mode
, cr_reg
, const0_rtx
),
5116 gen_rtx_SET (VOIDmode
, dest
, src2
)));
5119 /* Finish up, return sequence. */
5126 /* Split an integer abs operation returning a SEQUENCE containing all of the
5130 frv_split_abs (rtx operands
[])
5132 rtx dest
= operands
[0];
5133 rtx src
= operands
[1];
5134 rtx cc_reg
= operands
[2];
5135 rtx cr_reg
= operands
[3];
5140 /* Issue the compare < 0 instruction. */
5141 emit_insn (gen_rtx_SET (VOIDmode
,
5143 gen_rtx_COMPARE (CCmode
, src
, const0_rtx
)));
5145 /* Set the appropriate CCR bit. */
5146 emit_insn (gen_rtx_SET (VOIDmode
,
5148 gen_rtx_fmt_ee (LT
, CC_CCRmode
, cc_reg
, const0_rtx
)));
5150 /* Emit the conditional negate if the value is negative. */
5151 emit_insn (gen_rtx_COND_EXEC (VOIDmode
,
5152 gen_rtx_NE (CC_CCRmode
, cr_reg
, const0_rtx
),
5153 gen_negsi2 (dest
, src
)));
5155 /* Emit the conditional move for the test being false if needed. */
5156 if (! rtx_equal_p (dest
, src
))
5157 emit_insn (gen_rtx_COND_EXEC (VOIDmode
,
5158 gen_rtx_EQ (CC_CCRmode
, cr_reg
, const0_rtx
),
5159 gen_rtx_SET (VOIDmode
, dest
, src
)));
5161 /* Finish up, return sequence. */
5168 /* An internal function called by for_each_rtx to clear in a hard_reg set each
5169 register used in an insn. */
5172 frv_clear_registers_used (rtx
*ptr
, void *data
)
5174 if (GET_CODE (*ptr
) == REG
)
5176 int regno
= REGNO (*ptr
);
5177 HARD_REG_SET
*p_regs
= (HARD_REG_SET
*)data
;
5179 if (regno
< FIRST_PSEUDO_REGISTER
)
5181 int reg_max
= regno
+ HARD_REGNO_NREGS (regno
, GET_MODE (*ptr
));
5183 while (regno
< reg_max
)
5185 CLEAR_HARD_REG_BIT (*p_regs
, regno
);
5195 /* Initialize the extra fields provided by IFCVT_EXTRA_FIELDS. */
5197 /* On the FR-V, we don't have any extra fields per se, but it is useful hook to
5198 initialize the static storage. */
5200 frv_ifcvt_init_extra_fields (ce_if_block_t
*ce_info ATTRIBUTE_UNUSED
)
5202 frv_ifcvt
.added_insns_list
= NULL_RTX
;
5203 frv_ifcvt
.cur_scratch_regs
= 0;
5204 frv_ifcvt
.num_nested_cond_exec
= 0;
5205 frv_ifcvt
.cr_reg
= NULL_RTX
;
5206 frv_ifcvt
.nested_cc_reg
= NULL_RTX
;
5207 frv_ifcvt
.extra_int_cr
= NULL_RTX
;
5208 frv_ifcvt
.extra_fp_cr
= NULL_RTX
;
5209 frv_ifcvt
.last_nested_if_cr
= NULL_RTX
;
5213 /* Internal function to add a potential insn to the list of insns to be inserted
5214 if the conditional execution conversion is successful. */
5217 frv_ifcvt_add_insn (rtx pattern
, rtx insn
, int before_p
)
5219 rtx link
= alloc_EXPR_LIST (VOIDmode
, pattern
, insn
);
5221 link
->jump
= before_p
; /* Mark to add this before or after insn. */
5222 frv_ifcvt
.added_insns_list
= alloc_EXPR_LIST (VOIDmode
, link
,
5223 frv_ifcvt
.added_insns_list
);
5225 if (TARGET_DEBUG_COND_EXEC
)
5228 "\n:::::::::: frv_ifcvt_add_insn: add the following %s insn %d:\n",
5229 (before_p
) ? "before" : "after",
5230 (int)INSN_UID (insn
));
5232 debug_rtx (pattern
);
5237 /* A C expression to modify the code described by the conditional if
5238 information CE_INFO, possibly updating the tests in TRUE_EXPR, and
5239 FALSE_EXPR for converting if-then and if-then-else code to conditional
5240 instructions. Set either TRUE_EXPR or FALSE_EXPR to a null pointer if the
5241 tests cannot be converted. */
5244 frv_ifcvt_modify_tests (ce_if_block_t
*ce_info
, rtx
*p_true
, rtx
*p_false
)
5246 basic_block test_bb
= ce_info
->test_bb
; /* test basic block */
5247 basic_block then_bb
= ce_info
->then_bb
; /* THEN */
5248 basic_block else_bb
= ce_info
->else_bb
; /* ELSE or NULL */
5249 basic_block join_bb
= ce_info
->join_bb
; /* join block or NULL */
5250 rtx true_expr
= *p_true
;
5254 enum machine_mode mode
= GET_MODE (true_expr
);
5258 frv_tmp_reg_t
*tmp_reg
= &frv_ifcvt
.tmp_reg
;
5260 rtx sub_cond_exec_reg
;
5262 enum rtx_code code_true
;
5263 enum rtx_code code_false
;
5264 enum reg_class cc_class
;
5265 enum reg_class cr_class
;
5268 reg_set_iterator rsi
;
5270 /* Make sure we are only dealing with hard registers. Also honor the
5271 -mno-cond-exec switch, and -mno-nested-cond-exec switches if
5273 if (!reload_completed
|| !TARGET_COND_EXEC
5274 || (!TARGET_NESTED_CE
&& ce_info
->pass
> 1))
5277 /* Figure out which registers we can allocate for our own purposes. Only
5278 consider registers that are not preserved across function calls and are
5279 not fixed. However, allow the ICC/ICR temporary registers to be allocated
5280 if we did not need to use them in reloading other registers. */
5281 memset (&tmp_reg
->regs
, 0, sizeof (tmp_reg
->regs
));
5282 COPY_HARD_REG_SET (tmp_reg
->regs
, call_used_reg_set
);
5283 AND_COMPL_HARD_REG_SET (tmp_reg
->regs
, fixed_reg_set
);
5284 SET_HARD_REG_BIT (tmp_reg
->regs
, ICC_TEMP
);
5285 SET_HARD_REG_BIT (tmp_reg
->regs
, ICR_TEMP
);
5287 /* If this is a nested IF, we need to discover whether the CC registers that
5288 are set/used inside of the block are used anywhere else. If not, we can
5289 change them to be the CC register that is paired with the CR register that
5290 controls the outermost IF block. */
5291 if (ce_info
->pass
> 1)
5293 CLEAR_HARD_REG_SET (frv_ifcvt
.nested_cc_ok_rewrite
);
5294 for (j
= CC_FIRST
; j
<= CC_LAST
; j
++)
5295 if (TEST_HARD_REG_BIT (tmp_reg
->regs
, j
))
5297 if (REGNO_REG_SET_P (df_get_live_in (then_bb
), j
))
5301 && REGNO_REG_SET_P (df_get_live_in (else_bb
), j
))
5305 && REGNO_REG_SET_P (df_get_live_in (join_bb
), j
))
5308 SET_HARD_REG_BIT (frv_ifcvt
.nested_cc_ok_rewrite
, j
);
5312 for (j
= 0; j
< frv_ifcvt
.cur_scratch_regs
; j
++)
5313 frv_ifcvt
.scratch_regs
[j
] = NULL_RTX
;
5315 frv_ifcvt
.added_insns_list
= NULL_RTX
;
5316 frv_ifcvt
.cur_scratch_regs
= 0;
5318 bb
= (basic_block
*) alloca ((2 + ce_info
->num_multiple_test_blocks
)
5319 * sizeof (basic_block
));
5325 /* Remove anything live at the beginning of the join block from being
5326 available for allocation. */
5327 EXECUTE_IF_SET_IN_REG_SET (df_get_live_in (join_bb
), 0, regno
, rsi
)
5329 if (regno
< FIRST_PSEUDO_REGISTER
)
5330 CLEAR_HARD_REG_BIT (tmp_reg
->regs
, regno
);
5334 /* Add in all of the blocks in multiple &&/|| blocks to be scanned. */
5336 if (ce_info
->num_multiple_test_blocks
)
5338 basic_block multiple_test_bb
= ce_info
->last_test_bb
;
5340 while (multiple_test_bb
!= test_bb
)
5342 bb
[num_bb
++] = multiple_test_bb
;
5343 multiple_test_bb
= EDGE_PRED (multiple_test_bb
, 0)->src
;
5347 /* Add in the THEN and ELSE blocks to be scanned. */
5348 bb
[num_bb
++] = then_bb
;
5350 bb
[num_bb
++] = else_bb
;
5352 sub_cond_exec_reg
= NULL_RTX
;
5353 frv_ifcvt
.num_nested_cond_exec
= 0;
5355 /* Scan all of the blocks for registers that must not be allocated. */
5356 for (j
= 0; j
< num_bb
; j
++)
5358 rtx last_insn
= BB_END (bb
[j
]);
5359 rtx insn
= BB_HEAD (bb
[j
]);
5363 fprintf (dump_file
, "Scanning %s block %d, start %d, end %d\n",
5364 (bb
[j
] == else_bb
) ? "else" : ((bb
[j
] == then_bb
) ? "then" : "test"),
5366 (int) INSN_UID (BB_HEAD (bb
[j
])),
5367 (int) INSN_UID (BB_END (bb
[j
])));
5369 /* Anything live at the beginning of the block is obviously unavailable
5371 EXECUTE_IF_SET_IN_REG_SET (df_get_live_in (bb
[j
]), 0, regno
, rsi
)
5373 if (regno
< FIRST_PSEUDO_REGISTER
)
5374 CLEAR_HARD_REG_BIT (tmp_reg
->regs
, regno
);
5377 /* Loop through the insns in the block. */
5380 /* Mark any new registers that are created as being unavailable for
5381 allocation. Also see if the CC register used in nested IFs can be
5387 int skip_nested_if
= FALSE
;
5389 for_each_rtx (&PATTERN (insn
), frv_clear_registers_used
,
5390 (void *)&tmp_reg
->regs
);
5392 pattern
= PATTERN (insn
);
5393 if (GET_CODE (pattern
) == COND_EXEC
)
5395 rtx reg
= XEXP (COND_EXEC_TEST (pattern
), 0);
5397 if (reg
!= sub_cond_exec_reg
)
5399 sub_cond_exec_reg
= reg
;
5400 frv_ifcvt
.num_nested_cond_exec
++;
5404 set
= single_set_pattern (pattern
);
5407 rtx dest
= SET_DEST (set
);
5408 rtx src
= SET_SRC (set
);
5410 if (GET_CODE (dest
) == REG
)
5412 int regno
= REGNO (dest
);
5413 enum rtx_code src_code
= GET_CODE (src
);
5415 if (CC_P (regno
) && src_code
== COMPARE
)
5416 skip_nested_if
= TRUE
;
5418 else if (CR_P (regno
)
5419 && (src_code
== IF_THEN_ELSE
5420 || COMPARISON_P (src
)))
5421 skip_nested_if
= TRUE
;
5425 if (! skip_nested_if
)
5426 for_each_rtx (&PATTERN (insn
), frv_clear_registers_used
,
5427 (void *)&frv_ifcvt
.nested_cc_ok_rewrite
);
5430 if (insn
== last_insn
)
5433 insn
= NEXT_INSN (insn
);
5437 /* If this is a nested if, rewrite the CC registers that are available to
5438 include the ones that can be rewritten, to increase the chance of being
5439 able to allocate a paired CC/CR register combination. */
5440 if (ce_info
->pass
> 1)
5442 for (j
= CC_FIRST
; j
<= CC_LAST
; j
++)
5443 if (TEST_HARD_REG_BIT (frv_ifcvt
.nested_cc_ok_rewrite
, j
))
5444 SET_HARD_REG_BIT (tmp_reg
->regs
, j
);
5446 CLEAR_HARD_REG_BIT (tmp_reg
->regs
, j
);
5452 fprintf (dump_file
, "Available GPRs: ");
5454 for (j
= GPR_FIRST
; j
<= GPR_LAST
; j
++)
5455 if (TEST_HARD_REG_BIT (tmp_reg
->regs
, j
))
5457 fprintf (dump_file
, " %d [%s]", j
, reg_names
[j
]);
5458 if (++num_gprs
> GPR_TEMP_NUM
+2)
5462 fprintf (dump_file
, "%s\nAvailable CRs: ",
5463 (num_gprs
> GPR_TEMP_NUM
+2) ? " ..." : "");
5465 for (j
= CR_FIRST
; j
<= CR_LAST
; j
++)
5466 if (TEST_HARD_REG_BIT (tmp_reg
->regs
, j
))
5467 fprintf (dump_file
, " %d [%s]", j
, reg_names
[j
]);
5469 fputs ("\n", dump_file
);
5471 if (ce_info
->pass
> 1)
5473 fprintf (dump_file
, "Modifiable CCs: ");
5474 for (j
= CC_FIRST
; j
<= CC_LAST
; j
++)
5475 if (TEST_HARD_REG_BIT (tmp_reg
->regs
, j
))
5476 fprintf (dump_file
, " %d [%s]", j
, reg_names
[j
]);
5478 fprintf (dump_file
, "\n%d nested COND_EXEC statements\n",
5479 frv_ifcvt
.num_nested_cond_exec
);
5483 /* Allocate the appropriate temporary condition code register. Try to
5484 allocate the ICR/FCR register that corresponds to the ICC/FCC register so
5485 that conditional cmp's can be done. */
5486 if (mode
== CCmode
|| mode
== CC_UNSmode
|| mode
== CC_NZmode
)
5488 cr_class
= ICR_REGS
;
5489 cc_class
= ICC_REGS
;
5490 cc_first
= ICC_FIRST
;
5493 else if (mode
== CC_FPmode
)
5495 cr_class
= FCR_REGS
;
5496 cc_class
= FCC_REGS
;
5497 cc_first
= FCC_FIRST
;
5502 cc_first
= cc_last
= 0;
5503 cr_class
= cc_class
= NO_REGS
;
5506 cc
= XEXP (true_expr
, 0);
5507 nested_cc
= cr
= NULL_RTX
;
5508 if (cc_class
!= NO_REGS
)
5510 /* For nested IFs and &&/||, see if we can find a CC and CR register pair
5511 so we can execute a csubcc/caddcc/cfcmps instruction. */
5514 for (cc_regno
= cc_first
; cc_regno
<= cc_last
; cc_regno
++)
5516 int cr_regno
= cc_regno
- CC_FIRST
+ CR_FIRST
;
5518 if (TEST_HARD_REG_BIT (frv_ifcvt
.tmp_reg
.regs
, cc_regno
)
5519 && TEST_HARD_REG_BIT (frv_ifcvt
.tmp_reg
.regs
, cr_regno
))
5521 frv_ifcvt
.tmp_reg
.next_reg
[ (int)cr_class
] = cr_regno
;
5522 cr
= frv_alloc_temp_reg (tmp_reg
, cr_class
, CC_CCRmode
, TRUE
,
5525 frv_ifcvt
.tmp_reg
.next_reg
[ (int)cc_class
] = cc_regno
;
5526 nested_cc
= frv_alloc_temp_reg (tmp_reg
, cc_class
, CCmode
,
5536 fprintf (dump_file
, "Could not allocate a CR temporary register\n");
5543 "Will use %s for conditional execution, %s for nested comparisons\n",
5544 reg_names
[ REGNO (cr
)],
5545 (nested_cc
) ? reg_names
[ REGNO (nested_cc
) ] : "<none>");
5547 /* Set the CCR bit. Note for integer tests, we reverse the condition so that
5548 in an IF-THEN-ELSE sequence, we are testing the TRUE case against the CCR
5549 bit being true. We don't do this for floating point, because of NaNs. */
5550 code
= GET_CODE (true_expr
);
5551 if (GET_MODE (cc
) != CC_FPmode
)
5553 code
= reverse_condition (code
);
5563 check_insn
= gen_rtx_SET (VOIDmode
, cr
,
5564 gen_rtx_fmt_ee (code
, CC_CCRmode
, cc
, const0_rtx
));
5566 /* Record the check insn to be inserted later. */
5567 frv_ifcvt_add_insn (check_insn
, BB_END (test_bb
), TRUE
);
5569 /* Update the tests. */
5570 frv_ifcvt
.cr_reg
= cr
;
5571 frv_ifcvt
.nested_cc_reg
= nested_cc
;
5572 *p_true
= gen_rtx_fmt_ee (code_true
, CC_CCRmode
, cr
, const0_rtx
);
5573 *p_false
= gen_rtx_fmt_ee (code_false
, CC_CCRmode
, cr
, const0_rtx
);
5576 /* Fail, don't do this conditional execution. */
5579 *p_false
= NULL_RTX
;
5581 fprintf (dump_file
, "Disabling this conditional execution.\n");
5587 /* A C expression to modify the code described by the conditional if
5588 information CE_INFO, for the basic block BB, possibly updating the tests in
5589 TRUE_EXPR, and FALSE_EXPR for converting the && and || parts of if-then or
5590 if-then-else code to conditional instructions. Set either TRUE_EXPR or
5591 FALSE_EXPR to a null pointer if the tests cannot be converted. */
5593 /* p_true and p_false are given expressions of the form:
5595 (and (eq:CC_CCR (reg:CC_CCR)
5601 frv_ifcvt_modify_multiple_tests (ce_if_block_t
*ce_info
,
5606 rtx old_true
= XEXP (*p_true
, 0);
5607 rtx old_false
= XEXP (*p_false
, 0);
5608 rtx true_expr
= XEXP (*p_true
, 1);
5609 rtx false_expr
= XEXP (*p_false
, 1);
5612 rtx cr
= XEXP (old_true
, 0);
5614 rtx new_cr
= NULL_RTX
;
5615 rtx
*p_new_cr
= (rtx
*)0;
5619 enum reg_class cr_class
;
5620 enum machine_mode mode
= GET_MODE (true_expr
);
5621 rtx (*logical_func
)(rtx
, rtx
, rtx
);
5623 if (TARGET_DEBUG_COND_EXEC
)
5626 "\n:::::::::: frv_ifcvt_modify_multiple_tests, before modification for %s\ntrue insn:\n",
5627 ce_info
->and_and_p
? "&&" : "||");
5629 debug_rtx (*p_true
);
5631 fputs ("\nfalse insn:\n", stderr
);
5632 debug_rtx (*p_false
);
5635 if (!TARGET_MULTI_CE
)
5638 if (GET_CODE (cr
) != REG
)
5641 if (mode
== CCmode
|| mode
== CC_UNSmode
|| mode
== CC_NZmode
)
5643 cr_class
= ICR_REGS
;
5644 p_new_cr
= &frv_ifcvt
.extra_int_cr
;
5646 else if (mode
== CC_FPmode
)
5648 cr_class
= FCR_REGS
;
5649 p_new_cr
= &frv_ifcvt
.extra_fp_cr
;
5654 /* Allocate a temp CR, reusing a previously allocated temp CR if we have 3 or
5655 more &&/|| tests. */
5659 new_cr
= *p_new_cr
= frv_alloc_temp_reg (&frv_ifcvt
.tmp_reg
, cr_class
,
5660 CC_CCRmode
, TRUE
, TRUE
);
5665 if (ce_info
->and_and_p
)
5667 old_test
= old_false
;
5668 test_expr
= true_expr
;
5669 logical_func
= (GET_CODE (old_true
) == EQ
) ? gen_andcr
: gen_andncr
;
5670 *p_true
= gen_rtx_NE (CC_CCRmode
, cr
, const0_rtx
);
5671 *p_false
= gen_rtx_EQ (CC_CCRmode
, cr
, const0_rtx
);
5675 old_test
= old_false
;
5676 test_expr
= false_expr
;
5677 logical_func
= (GET_CODE (old_false
) == EQ
) ? gen_orcr
: gen_orncr
;
5678 *p_true
= gen_rtx_EQ (CC_CCRmode
, cr
, const0_rtx
);
5679 *p_false
= gen_rtx_NE (CC_CCRmode
, cr
, const0_rtx
);
5682 /* First add the andcr/andncr/orcr/orncr, which will be added after the
5683 conditional check instruction, due to frv_ifcvt_add_insn being a LIFO
5685 frv_ifcvt_add_insn ((*logical_func
) (cr
, cr
, new_cr
), BB_END (bb
), TRUE
);
5687 /* Now add the conditional check insn. */
5688 cc
= XEXP (test_expr
, 0);
5689 compare
= gen_rtx_fmt_ee (GET_CODE (test_expr
), CC_CCRmode
, cc
, const0_rtx
);
5690 if_else
= gen_rtx_IF_THEN_ELSE (CC_CCRmode
, old_test
, compare
, const0_rtx
);
5692 check_insn
= gen_rtx_SET (VOIDmode
, new_cr
, if_else
);
5694 /* Add the new check insn to the list of check insns that need to be
5696 frv_ifcvt_add_insn (check_insn
, BB_END (bb
), TRUE
);
5698 if (TARGET_DEBUG_COND_EXEC
)
5700 fputs ("\n:::::::::: frv_ifcvt_modify_multiple_tests, after modification\ntrue insn:\n",
5703 debug_rtx (*p_true
);
5705 fputs ("\nfalse insn:\n", stderr
);
5706 debug_rtx (*p_false
);
5712 *p_true
= *p_false
= NULL_RTX
;
5714 /* If we allocated a CR register, release it. */
5717 CLEAR_HARD_REG_BIT (frv_ifcvt
.tmp_reg
.regs
, REGNO (new_cr
));
5718 *p_new_cr
= NULL_RTX
;
5721 if (TARGET_DEBUG_COND_EXEC
)
5722 fputs ("\n:::::::::: frv_ifcvt_modify_multiple_tests, failed.\n", stderr
);
5728 /* Return a register which will be loaded with a value if an IF block is
5729 converted to conditional execution. This is used to rewrite instructions
5730 that use constants to ones that just use registers. */
5733 frv_ifcvt_load_value (rtx value
, rtx insn ATTRIBUTE_UNUSED
)
5735 int num_alloc
= frv_ifcvt
.cur_scratch_regs
;
5739 /* We know gr0 == 0, so replace any errant uses. */
5740 if (value
== const0_rtx
)
5741 return gen_rtx_REG (SImode
, GPR_FIRST
);
5743 /* First search all registers currently loaded to see if we have an
5744 applicable constant. */
5745 if (CONSTANT_P (value
)
5746 || (GET_CODE (value
) == REG
&& REGNO (value
) == LR_REGNO
))
5748 for (i
= 0; i
< num_alloc
; i
++)
5750 if (rtx_equal_p (SET_SRC (frv_ifcvt
.scratch_regs
[i
]), value
))
5751 return SET_DEST (frv_ifcvt
.scratch_regs
[i
]);
5755 /* Have we exhausted the number of registers available? */
5756 if (num_alloc
>= GPR_TEMP_NUM
)
5759 fprintf (dump_file
, "Too many temporary registers allocated\n");
5764 /* Allocate the new register. */
5765 reg
= frv_alloc_temp_reg (&frv_ifcvt
.tmp_reg
, GPR_REGS
, SImode
, TRUE
, TRUE
);
5769 fputs ("Could not find a scratch register\n", dump_file
);
5774 frv_ifcvt
.cur_scratch_regs
++;
5775 frv_ifcvt
.scratch_regs
[num_alloc
] = gen_rtx_SET (VOIDmode
, reg
, value
);
5779 if (GET_CODE (value
) == CONST_INT
)
5780 fprintf (dump_file
, "Register %s will hold %ld\n",
5781 reg_names
[ REGNO (reg
)], (long)INTVAL (value
));
5783 else if (GET_CODE (value
) == REG
&& REGNO (value
) == LR_REGNO
)
5784 fprintf (dump_file
, "Register %s will hold LR\n",
5785 reg_names
[ REGNO (reg
)]);
5788 fprintf (dump_file
, "Register %s will hold a saved value\n",
5789 reg_names
[ REGNO (reg
)]);
5796 /* Update a MEM used in conditional code that might contain an offset to put
5797 the offset into a scratch register, so that the conditional load/store
5798 operations can be used. This function returns the original pointer if the
5799 MEM is valid to use in conditional code, NULL if we can't load up the offset
5800 into a temporary register, or the new MEM if we were successful. */
5803 frv_ifcvt_rewrite_mem (rtx mem
, enum machine_mode mode
, rtx insn
)
5805 rtx addr
= XEXP (mem
, 0);
5807 if (!frv_legitimate_address_p (mode
, addr
, reload_completed
, TRUE
, FALSE
))
5809 if (GET_CODE (addr
) == PLUS
)
5811 rtx addr_op0
= XEXP (addr
, 0);
5812 rtx addr_op1
= XEXP (addr
, 1);
5814 if (GET_CODE (addr_op0
) == REG
&& CONSTANT_P (addr_op1
))
5816 rtx reg
= frv_ifcvt_load_value (addr_op1
, insn
);
5820 addr
= gen_rtx_PLUS (Pmode
, addr_op0
, reg
);
5827 else if (CONSTANT_P (addr
))
5828 addr
= frv_ifcvt_load_value (addr
, insn
);
5833 if (addr
== NULL_RTX
)
5836 else if (XEXP (mem
, 0) != addr
)
5837 return change_address (mem
, mode
, addr
);
5844 /* Given a PATTERN, return a SET expression if this PATTERN has only a single
5845 SET, possibly conditionally executed. It may also have CLOBBERs, USEs. */
5848 single_set_pattern (rtx pattern
)
5853 if (GET_CODE (pattern
) == COND_EXEC
)
5854 pattern
= COND_EXEC_CODE (pattern
);
5856 if (GET_CODE (pattern
) == SET
)
5859 else if (GET_CODE (pattern
) == PARALLEL
)
5861 for (i
= 0, set
= 0; i
< XVECLEN (pattern
, 0); i
++)
5863 rtx sub
= XVECEXP (pattern
, 0, i
);
5865 switch (GET_CODE (sub
))
5889 /* A C expression to modify the code described by the conditional if
5890 information CE_INFO with the new PATTERN in INSN. If PATTERN is a null
5891 pointer after the IFCVT_MODIFY_INSN macro executes, it is assumed that that
5892 insn cannot be converted to be executed conditionally. */
5895 frv_ifcvt_modify_insn (ce_if_block_t
*ce_info
,
5899 rtx orig_ce_pattern
= pattern
;
5905 gcc_assert (GET_CODE (pattern
) == COND_EXEC
);
5907 test
= COND_EXEC_TEST (pattern
);
5908 if (GET_CODE (test
) == AND
)
5910 rtx cr
= frv_ifcvt
.cr_reg
;
5913 op0
= XEXP (test
, 0);
5914 if (! rtx_equal_p (cr
, XEXP (op0
, 0)))
5917 op1
= XEXP (test
, 1);
5918 test_reg
= XEXP (op1
, 0);
5919 if (GET_CODE (test_reg
) != REG
)
5922 /* Is this the first nested if block in this sequence? If so, generate
5923 an andcr or andncr. */
5924 if (! frv_ifcvt
.last_nested_if_cr
)
5928 frv_ifcvt
.last_nested_if_cr
= test_reg
;
5929 if (GET_CODE (op0
) == NE
)
5930 and_op
= gen_andcr (test_reg
, cr
, test_reg
);
5932 and_op
= gen_andncr (test_reg
, cr
, test_reg
);
5934 frv_ifcvt_add_insn (and_op
, insn
, TRUE
);
5937 /* If this isn't the first statement in the nested if sequence, see if we
5938 are dealing with the same register. */
5939 else if (! rtx_equal_p (test_reg
, frv_ifcvt
.last_nested_if_cr
))
5942 COND_EXEC_TEST (pattern
) = test
= op1
;
5945 /* If this isn't a nested if, reset state variables. */
5948 frv_ifcvt
.last_nested_if_cr
= NULL_RTX
;
5951 set
= single_set_pattern (pattern
);
5954 rtx dest
= SET_DEST (set
);
5955 rtx src
= SET_SRC (set
);
5956 enum machine_mode mode
= GET_MODE (dest
);
5958 /* Check for normal binary operators. */
5959 if (mode
== SImode
&& ARITHMETIC_P (src
))
5961 op0
= XEXP (src
, 0);
5962 op1
= XEXP (src
, 1);
5964 if (integer_register_operand (op0
, SImode
) && CONSTANT_P (op1
))
5966 op1
= frv_ifcvt_load_value (op1
, insn
);
5968 COND_EXEC_CODE (pattern
)
5969 = gen_rtx_SET (VOIDmode
, dest
, gen_rtx_fmt_ee (GET_CODE (src
),
5977 /* For multiply by a constant, we need to handle the sign extending
5978 correctly. Add a USE of the value after the multiply to prevent flow
5979 from cratering because only one register out of the two were used. */
5980 else if (mode
== DImode
&& GET_CODE (src
) == MULT
)
5982 op0
= XEXP (src
, 0);
5983 op1
= XEXP (src
, 1);
5984 if (GET_CODE (op0
) == SIGN_EXTEND
&& GET_CODE (op1
) == CONST_INT
)
5986 op1
= frv_ifcvt_load_value (op1
, insn
);
5989 op1
= gen_rtx_SIGN_EXTEND (DImode
, op1
);
5990 COND_EXEC_CODE (pattern
)
5991 = gen_rtx_SET (VOIDmode
, dest
,
5992 gen_rtx_MULT (DImode
, op0
, op1
));
5998 frv_ifcvt_add_insn (gen_rtx_USE (VOIDmode
, dest
), insn
, FALSE
);
6001 /* If we are just loading a constant created for a nested conditional
6002 execution statement, just load the constant without any conditional
6003 execution, since we know that the constant will not interfere with any
6005 else if (frv_ifcvt
.scratch_insns_bitmap
6006 && bitmap_bit_p (frv_ifcvt
.scratch_insns_bitmap
,
6008 && REG_P (SET_DEST (set
))
6009 /* We must not unconditionally set a scratch reg chosen
6010 for a nested if-converted block if its incoming
6011 value from the TEST block (or the result of the THEN
6012 branch) could/should propagate to the JOIN block.
6013 It suffices to test whether the register is live at
6014 the JOIN point: if it's live there, we can infer
6015 that we set it in the former JOIN block of the
6016 nested if-converted block (otherwise it wouldn't
6017 have been available as a scratch register), and it
6018 is either propagated through or set in the other
6019 conditional block. It's probably not worth trying
6020 to catch the latter case, and it could actually
6021 limit scheduling of the combined block quite
6024 && ! (REGNO_REG_SET_P (df_get_live_in (ce_info
->join_bb
),
6025 REGNO (SET_DEST (set
))))
6026 /* Similarly, we must not unconditionally set a reg
6027 used as scratch in the THEN branch if the same reg
6028 is live in the ELSE branch. */
6029 && (! ce_info
->else_bb
6030 || BLOCK_FOR_INSN (insn
) == ce_info
->else_bb
6031 || ! (REGNO_REG_SET_P (df_get_live_in (ce_info
->else_bb
),
6032 REGNO (SET_DEST (set
))))))
6035 else if (mode
== QImode
|| mode
== HImode
|| mode
== SImode
6038 int changed_p
= FALSE
;
6040 /* Check for just loading up a constant */
6041 if (CONSTANT_P (src
) && integer_register_operand (dest
, mode
))
6043 src
= frv_ifcvt_load_value (src
, insn
);
6050 /* See if we need to fix up stores */
6051 if (GET_CODE (dest
) == MEM
)
6053 rtx new_mem
= frv_ifcvt_rewrite_mem (dest
, mode
, insn
);
6058 else if (new_mem
!= dest
)
6065 /* See if we need to fix up loads */
6066 if (GET_CODE (src
) == MEM
)
6068 rtx new_mem
= frv_ifcvt_rewrite_mem (src
, mode
, insn
);
6073 else if (new_mem
!= src
)
6080 /* If either src or destination changed, redo SET. */
6082 COND_EXEC_CODE (pattern
) = gen_rtx_SET (VOIDmode
, dest
, src
);
6085 /* Rewrite a nested set cccr in terms of IF_THEN_ELSE. Also deal with
6086 rewriting the CC register to be the same as the paired CC/CR register
6088 else if (mode
== CC_CCRmode
&& COMPARISON_P (src
))
6090 int regno
= REGNO (XEXP (src
, 0));
6093 if (ce_info
->pass
> 1
6094 && regno
!= (int)REGNO (frv_ifcvt
.nested_cc_reg
)
6095 && TEST_HARD_REG_BIT (frv_ifcvt
.nested_cc_ok_rewrite
, regno
))
6097 src
= gen_rtx_fmt_ee (GET_CODE (src
),
6099 frv_ifcvt
.nested_cc_reg
,
6103 if_else
= gen_rtx_IF_THEN_ELSE (CC_CCRmode
, test
, src
, const0_rtx
);
6104 pattern
= gen_rtx_SET (VOIDmode
, dest
, if_else
);
6107 /* Remap a nested compare instruction to use the paired CC/CR reg. */
6108 else if (ce_info
->pass
> 1
6109 && GET_CODE (dest
) == REG
6110 && CC_P (REGNO (dest
))
6111 && REGNO (dest
) != REGNO (frv_ifcvt
.nested_cc_reg
)
6112 && TEST_HARD_REG_BIT (frv_ifcvt
.nested_cc_ok_rewrite
,
6114 && GET_CODE (src
) == COMPARE
)
6116 PUT_MODE (frv_ifcvt
.nested_cc_reg
, GET_MODE (dest
));
6117 COND_EXEC_CODE (pattern
)
6118 = gen_rtx_SET (VOIDmode
, frv_ifcvt
.nested_cc_reg
, copy_rtx (src
));
6122 if (TARGET_DEBUG_COND_EXEC
)
6124 rtx orig_pattern
= PATTERN (insn
);
6126 PATTERN (insn
) = pattern
;
6128 "\n:::::::::: frv_ifcvt_modify_insn: pass = %d, insn after modification:\n",
6132 PATTERN (insn
) = orig_pattern
;
6138 if (TARGET_DEBUG_COND_EXEC
)
6140 rtx orig_pattern
= PATTERN (insn
);
6142 PATTERN (insn
) = orig_ce_pattern
;
6144 "\n:::::::::: frv_ifcvt_modify_insn: pass = %d, insn could not be modified:\n",
6148 PATTERN (insn
) = orig_pattern
;
6155 /* A C expression to perform any final machine dependent modifications in
6156 converting code to conditional execution in the code described by the
6157 conditional if information CE_INFO. */
6160 frv_ifcvt_modify_final (ce_if_block_t
*ce_info ATTRIBUTE_UNUSED
)
6164 rtx p
= frv_ifcvt
.added_insns_list
;
6167 /* Loop inserting the check insns. The last check insn is the first test,
6168 and is the appropriate place to insert constants. */
6173 rtx check_and_insert_insns
= XEXP (p
, 0);
6176 check_insn
= XEXP (check_and_insert_insns
, 0);
6177 existing_insn
= XEXP (check_and_insert_insns
, 1);
6180 /* The jump bit is used to say that the new insn is to be inserted BEFORE
6181 the existing insn, otherwise it is to be inserted AFTER. */
6182 if (check_and_insert_insns
->jump
)
6184 emit_insn_before (check_insn
, existing_insn
);
6185 check_and_insert_insns
->jump
= 0;
6188 emit_insn_after (check_insn
, existing_insn
);
6190 free_EXPR_LIST_node (check_and_insert_insns
);
6191 free_EXPR_LIST_node (old_p
);
6193 while (p
!= NULL_RTX
);
6195 /* Load up any constants needed into temp gprs */
6196 for (i
= 0; i
< frv_ifcvt
.cur_scratch_regs
; i
++)
6198 rtx insn
= emit_insn_before (frv_ifcvt
.scratch_regs
[i
], existing_insn
);
6199 if (! frv_ifcvt
.scratch_insns_bitmap
)
6200 frv_ifcvt
.scratch_insns_bitmap
= BITMAP_ALLOC (NULL
);
6201 bitmap_set_bit (frv_ifcvt
.scratch_insns_bitmap
, INSN_UID (insn
));
6202 frv_ifcvt
.scratch_regs
[i
] = NULL_RTX
;
6205 frv_ifcvt
.added_insns_list
= NULL_RTX
;
6206 frv_ifcvt
.cur_scratch_regs
= 0;
6210 /* A C expression to cancel any machine dependent modifications in converting
6211 code to conditional execution in the code described by the conditional if
6212 information CE_INFO. */
6215 frv_ifcvt_modify_cancel (ce_if_block_t
*ce_info ATTRIBUTE_UNUSED
)
6218 rtx p
= frv_ifcvt
.added_insns_list
;
6220 /* Loop freeing up the EXPR_LIST's allocated. */
6221 while (p
!= NULL_RTX
)
6223 rtx check_and_jump
= XEXP (p
, 0);
6227 free_EXPR_LIST_node (check_and_jump
);
6228 free_EXPR_LIST_node (old_p
);
6231 /* Release any temporary gprs allocated. */
6232 for (i
= 0; i
< frv_ifcvt
.cur_scratch_regs
; i
++)
6233 frv_ifcvt
.scratch_regs
[i
] = NULL_RTX
;
6235 frv_ifcvt
.added_insns_list
= NULL_RTX
;
6236 frv_ifcvt
.cur_scratch_regs
= 0;
6240 /* A C expression for the size in bytes of the trampoline, as an integer.
6244 setlo #0, <static_chain>
6246 sethi #0, <static_chain>
6247 jmpl @(gr0,<jmp_reg>) */
6250 frv_trampoline_size (void)
6253 /* Allocate room for the function descriptor and the lddi
6256 return 5 /* instructions */ * 4 /* instruction size. */;
6260 /* A C statement to initialize the variable parts of a trampoline. ADDR is an
6261 RTX for the address of the trampoline; FNADDR is an RTX for the address of
6262 the nested function; STATIC_CHAIN is an RTX for the static chain value that
6263 should be passed to the function when it is called.
6268 setlo #0, <static_chain>
6270 sethi #0, <static_chain>
6271 jmpl @(gr0,<jmp_reg>) */
6274 frv_initialize_trampoline (rtx addr
, rtx fnaddr
, rtx static_chain
)
6276 rtx sc_reg
= force_reg (Pmode
, static_chain
);
6278 emit_library_call (gen_rtx_SYMBOL_REF (SImode
, "__trampoline_setup"),
6281 GEN_INT (frv_trampoline_size ()), SImode
,
6287 /* Many machines have some registers that cannot be copied directly to or from
6288 memory or even from other types of registers. An example is the `MQ'
6289 register, which on most machines, can only be copied to or from general
6290 registers, but not memory. Some machines allow copying all registers to and
6291 from memory, but require a scratch register for stores to some memory
6292 locations (e.g., those with symbolic address on the RT, and those with
6293 certain symbolic address on the SPARC when compiling PIC). In some cases,
6294 both an intermediate and a scratch register are required.
6296 You should define these macros to indicate to the reload phase that it may
6297 need to allocate at least one register for a reload in addition to the
6298 register to contain the data. Specifically, if copying X to a register
6299 CLASS in MODE requires an intermediate register, you should define
6300 `SECONDARY_INPUT_RELOAD_CLASS' to return the largest register class all of
6301 whose registers can be used as intermediate registers or scratch registers.
6303 If copying a register CLASS in MODE to X requires an intermediate or scratch
6304 register, `SECONDARY_OUTPUT_RELOAD_CLASS' should be defined to return the
6305 largest register class required. If the requirements for input and output
6306 reloads are the same, the macro `SECONDARY_RELOAD_CLASS' should be used
6307 instead of defining both macros identically.
6309 The values returned by these macros are often `GENERAL_REGS'. Return
6310 `NO_REGS' if no spare register is needed; i.e., if X can be directly copied
6311 to or from a register of CLASS in MODE without requiring a scratch register.
6312 Do not define this macro if it would always return `NO_REGS'.
6314 If a scratch register is required (either with or without an intermediate
6315 register), you should define patterns for `reload_inM' or `reload_outM', as
6316 required.. These patterns, which will normally be implemented with a
6317 `define_expand', should be similar to the `movM' patterns, except that
6318 operand 2 is the scratch register.
6320 Define constraints for the reload register and scratch register that contain
6321 a single register class. If the original reload register (whose class is
6322 CLASS) can meet the constraint given in the pattern, the value returned by
6323 these macros is used for the class of the scratch register. Otherwise, two
6324 additional reload registers are required. Their classes are obtained from
6325 the constraints in the insn pattern.
6327 X might be a pseudo-register or a `subreg' of a pseudo-register, which could
6328 either be in a hard register or in memory. Use `true_regnum' to find out;
6329 it will return -1 if the pseudo is in memory and the hard register number if
6330 it is in a register.
6332 These macros should not be used in the case where a particular class of
6333 registers can only be copied to memory and not to another class of
6334 registers. In that case, secondary reload registers are not needed and
6335 would not be helpful. Instead, a stack location must be used to perform the
6336 copy and the `movM' pattern should use memory as an intermediate storage.
6337 This case often occurs between floating-point and general registers. */
6340 frv_secondary_reload_class (enum reg_class
class,
6341 enum machine_mode mode ATTRIBUTE_UNUSED
,
6343 int in_p ATTRIBUTE_UNUSED
)
6353 /* Accumulators/Accumulator guard registers need to go through floating
6359 if (x
&& GET_CODE (x
) == REG
)
6361 int regno
= REGNO (x
);
6363 if (ACC_P (regno
) || ACCG_P (regno
))
6368 /* Nonzero constants should be loaded into an FPR through a GPR. */
6372 if (x
&& CONSTANT_P (x
) && !ZERO_P (x
))
6378 /* All of these types need gpr registers. */
6390 /* The accumulators need fpr registers */
6403 /* A C expression whose value is nonzero if pseudos that have been assigned to
6404 registers of class CLASS would likely be spilled because registers of CLASS
6405 are needed for spill registers.
6407 The default value of this macro returns 1 if CLASS has exactly one register
6408 and zero otherwise. On most machines, this default should be used. Only
6409 define this macro to some other expression if pseudo allocated by
6410 `local-alloc.c' end up in memory because their hard registers were needed
6411 for spill registers. If this macro returns nonzero for those classes, those
6412 pseudos will only be allocated by `global.c', which knows how to reallocate
6413 the pseudo to another register. If there would not be another register
6414 available for reallocation, you should not change the definition of this
6415 macro since the only effect of such a definition would be to slow down
6416 register allocation. */
6419 frv_class_likely_spilled_p (enum reg_class
class)
6429 case FDPIC_FPTR_REGS
:
6451 /* An expression for the alignment of a structure field FIELD if the
6452 alignment computed in the usual way is COMPUTED. GCC uses this
6453 value instead of the value in `BIGGEST_ALIGNMENT' or
6454 `BIGGEST_FIELD_ALIGNMENT', if defined, for structure fields only. */
6456 /* The definition type of the bit field data is either char, short, long or
6457 long long. The maximum bit size is the number of bits of its own type.
6459 The bit field data is assigned to a storage unit that has an adequate size
6460 for bit field data retention and is located at the smallest address.
6462 Consecutive bit field data are packed at consecutive bits having the same
6463 storage unit, with regard to the type, beginning with the MSB and continuing
6466 If a field to be assigned lies over a bit field type boundary, its
6467 assignment is completed by aligning it with a boundary suitable for the
6470 When a bit field having a bit length of 0 is declared, it is forcibly
6471 assigned to the next storage unit.
6484 &x 00000000 00000000 00000000 00000000
6487 &x+4 00000000 00000000 00000000 00000000
6490 &x+8 00000000 00000000 00000000 00000000
6493 &x+12 00000000 00000000 00000000 00000000
6499 frv_adjust_field_align (tree field
, int computed
)
6501 /* Make sure that the bitfield is not wider than the type. */
6502 if (DECL_BIT_FIELD (field
)
6503 && !DECL_ARTIFICIAL (field
))
6505 tree parent
= DECL_CONTEXT (field
);
6506 tree prev
= NULL_TREE
;
6509 for (cur
= TYPE_FIELDS (parent
); cur
&& cur
!= field
; cur
= TREE_CHAIN (cur
))
6511 if (TREE_CODE (cur
) != FIELD_DECL
)
6519 /* If this isn't a :0 field and if the previous element is a bitfield
6520 also, see if the type is different, if so, we will need to align the
6521 bit-field to the next boundary. */
6523 && ! DECL_PACKED (field
)
6524 && ! integer_zerop (DECL_SIZE (field
))
6525 && DECL_BIT_FIELD_TYPE (field
) != DECL_BIT_FIELD_TYPE (prev
))
6527 int prev_align
= TYPE_ALIGN (TREE_TYPE (prev
));
6528 int cur_align
= TYPE_ALIGN (TREE_TYPE (field
));
6529 computed
= (prev_align
> cur_align
) ? prev_align
: cur_align
;
6537 /* A C expression that is nonzero if it is permissible to store a value of mode
6538 MODE in hard register number REGNO (or in several registers starting with
6539 that one). For a machine where all registers are equivalent, a suitable
6542 #define HARD_REGNO_MODE_OK(REGNO, MODE) 1
6544 It is not necessary for this macro to check for the numbers of fixed
6545 registers, because the allocation mechanism considers them to be always
6548 On some machines, double-precision values must be kept in even/odd register
6549 pairs. The way to implement that is to define this macro to reject odd
6550 register numbers for such modes.
6552 The minimum requirement for a mode to be OK in a register is that the
6553 `movMODE' instruction pattern support moves between the register and any
6554 other hard register for which the mode is OK; and that moving a value into
6555 the register and back out not alter it.
6557 Since the same instruction used to move `SImode' will work for all narrower
6558 integer modes, it is not necessary on any machine for `HARD_REGNO_MODE_OK'
6559 to distinguish between these modes, provided you define patterns `movhi',
6560 etc., to take advantage of this. This is useful because of the interaction
6561 between `HARD_REGNO_MODE_OK' and `MODES_TIEABLE_P'; it is very desirable for
6562 all integer modes to be tieable.
6564 Many machines have special registers for floating point arithmetic. Often
6565 people assume that floating point machine modes are allowed only in floating
6566 point registers. This is not true. Any registers that can hold integers
6567 can safely *hold* a floating point machine mode, whether or not floating
6568 arithmetic can be done on it in those registers. Integer move instructions
6569 can be used to move the values.
6571 On some machines, though, the converse is true: fixed-point machine modes
6572 may not go in floating registers. This is true if the floating registers
6573 normalize any value stored in them, because storing a non-floating value
6574 there would garble it. In this case, `HARD_REGNO_MODE_OK' should reject
6575 fixed-point machine modes in floating registers. But if the floating
6576 registers do not automatically normalize, if you can store any bit pattern
6577 in one and retrieve it unchanged without a trap, then any machine mode may
6578 go in a floating register, so you can define this macro to say so.
6580 The primary significance of special floating registers is rather that they
6581 are the registers acceptable in floating point arithmetic instructions.
6582 However, this is of no concern to `HARD_REGNO_MODE_OK'. You handle it by
6583 writing the proper constraints for those instructions.
6585 On some machines, the floating registers are especially slow to access, so
6586 that it is better to store a value in a stack frame than in such a register
6587 if floating point arithmetic is not being done. As long as the floating
6588 registers are not in class `GENERAL_REGS', they will not be used unless some
6589 pattern's constraint asks for one. */
6592 frv_hard_regno_mode_ok (int regno
, enum machine_mode mode
)
6602 return ICC_P (regno
) || GPR_P (regno
);
6605 return CR_P (regno
) || GPR_P (regno
);
6608 return FCC_P (regno
) || GPR_P (regno
);
6614 /* Set BASE to the first register in REGNO's class. Set MASK to the
6615 bits that must be clear in (REGNO - BASE) for the register to be
6617 if (INTEGRAL_MODE_P (mode
) || FLOAT_MODE_P (mode
) || VECTOR_MODE_P (mode
))
6621 /* ACCGs store one byte. Two-byte quantities must start in
6622 even-numbered registers, four-byte ones in registers whose
6623 numbers are divisible by four, and so on. */
6625 mask
= GET_MODE_SIZE (mode
) - 1;
6629 /* The other registers store one word. */
6630 if (GPR_P (regno
) || regno
== AP_FIRST
)
6633 else if (FPR_P (regno
))
6636 else if (ACC_P (regno
))
6639 else if (SPR_P (regno
))
6640 return mode
== SImode
;
6642 /* Fill in the table. */
6646 /* Anything smaller than an SI is OK in any word-sized register. */
6647 if (GET_MODE_SIZE (mode
) < 4)
6650 mask
= (GET_MODE_SIZE (mode
) / 4) - 1;
6652 return (((regno
- base
) & mask
) == 0);
6659 /* A C expression for the number of consecutive hard registers, starting at
6660 register number REGNO, required to hold a value of mode MODE.
6662 On a machine where all registers are exactly one word, a suitable definition
6665 #define HARD_REGNO_NREGS(REGNO, MODE) \
6666 ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) \
6667 / UNITS_PER_WORD)) */
6669 /* On the FRV, make the CC_FP mode take 3 words in the integer registers, so
6670 that we can build the appropriate instructions to properly reload the
6671 values. Also, make the byte-sized accumulator guards use one guard
6675 frv_hard_regno_nregs (int regno
, enum machine_mode mode
)
6678 return GET_MODE_SIZE (mode
);
6680 return (GET_MODE_SIZE (mode
) + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
6684 /* A C expression for the maximum number of consecutive registers of
6685 class CLASS needed to hold a value of mode MODE.
6687 This is closely related to the macro `HARD_REGNO_NREGS'. In fact, the value
6688 of the macro `CLASS_MAX_NREGS (CLASS, MODE)' should be the maximum value of
6689 `HARD_REGNO_NREGS (REGNO, MODE)' for all REGNO values in the class CLASS.
6691 This macro helps control the handling of multiple-word values in
6694 This declaration is required. */
6697 frv_class_max_nregs (enum reg_class
class, enum machine_mode mode
)
6699 if (class == ACCG_REGS
)
6700 /* An N-byte value requires N accumulator guards. */
6701 return GET_MODE_SIZE (mode
);
6703 return (GET_MODE_SIZE (mode
) + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
6707 /* A C expression that is nonzero if X is a legitimate constant for an
6708 immediate operand on the target machine. You can assume that X satisfies
6709 `CONSTANT_P', so you need not check this. In fact, `1' is a suitable
6710 definition for this macro on machines where anything `CONSTANT_P' is valid. */
6713 frv_legitimate_constant_p (rtx x
)
6715 enum machine_mode mode
= GET_MODE (x
);
6717 /* frv_cannot_force_const_mem always returns true for FDPIC. This
6718 means that the move expanders will be expected to deal with most
6719 kinds of constant, regardless of what we return here.
6721 However, among its other duties, LEGITIMATE_CONSTANT_P decides whether
6722 a constant can be entered into reg_equiv_constant[]. If we return true,
6723 reload can create new instances of the constant whenever it likes.
6725 The idea is therefore to accept as many constants as possible (to give
6726 reload more freedom) while rejecting constants that can only be created
6727 at certain times. In particular, anything with a symbolic component will
6728 require use of the pseudo FDPIC register, which is only available before
6731 return LEGITIMATE_PIC_OPERAND_P (x
);
6733 /* All of the integer constants are ok. */
6734 if (GET_CODE (x
) != CONST_DOUBLE
)
6737 /* double integer constants are ok. */
6738 if (mode
== VOIDmode
|| mode
== DImode
)
6741 /* 0 is always ok. */
6742 if (x
== CONST0_RTX (mode
))
6745 /* If floating point is just emulated, allow any constant, since it will be
6746 constructed in the GPRs. */
6747 if (!TARGET_HAS_FPRS
)
6750 if (mode
== DFmode
&& !TARGET_DOUBLE
)
6753 /* Otherwise store the constant away and do a load. */
6757 /* Implement SELECT_CC_MODE. Choose CC_FP for floating-point comparisons,
6758 CC_NZ for comparisons against zero in which a single Z or N flag test
6759 is enough, CC_UNS for other unsigned comparisons, and CC for other
6760 signed comparisons. */
6763 frv_select_cc_mode (enum rtx_code code
, rtx x
, rtx y
)
6765 if (GET_MODE_CLASS (GET_MODE (x
)) == MODE_FLOAT
)
6774 return y
== const0_rtx
? CC_NZmode
: CCmode
;
6780 return y
== const0_rtx
? CC_NZmode
: CC_UNSmode
;
6787 /* A C expression for the cost of moving data from a register in class FROM to
6788 one in class TO. The classes are expressed using the enumeration values
6789 such as `GENERAL_REGS'. A value of 4 is the default; other values are
6790 interpreted relative to that.
6792 It is not required that the cost always equal 2 when FROM is the same as TO;
6793 on some machines it is expensive to move between registers if they are not
6796 If reload sees an insn consisting of a single `set' between two hard
6797 registers, and if `REGISTER_MOVE_COST' applied to their classes returns a
6798 value of 2, reload does not check to ensure that the constraints of the insn
6799 are met. Setting a cost of other than 2 will allow reload to verify that
6800 the constraints are met. You should do this if the `movM' pattern's
6801 constraints do not allow such copying. */
6803 #define HIGH_COST 40
6804 #define MEDIUM_COST 3
6808 frv_register_move_cost (enum reg_class from
, enum reg_class to
)
6892 /* Implementation of TARGET_ASM_INTEGER. In the FRV case we need to
6893 use ".picptr" to generate safe relocations for PIC code. We also
6894 need a fixup entry for aligned (non-debugging) code. */
6897 frv_assemble_integer (rtx value
, unsigned int size
, int aligned_p
)
6899 if ((flag_pic
|| TARGET_FDPIC
) && size
== UNITS_PER_WORD
)
6901 if (GET_CODE (value
) == CONST
6902 || GET_CODE (value
) == SYMBOL_REF
6903 || GET_CODE (value
) == LABEL_REF
)
6905 if (TARGET_FDPIC
&& GET_CODE (value
) == SYMBOL_REF
6906 && SYMBOL_REF_FUNCTION_P (value
))
6908 fputs ("\t.picptr\tfuncdesc(", asm_out_file
);
6909 output_addr_const (asm_out_file
, value
);
6910 fputs (")\n", asm_out_file
);
6913 else if (TARGET_FDPIC
&& GET_CODE (value
) == CONST
6914 && frv_function_symbol_referenced_p (value
))
6916 if (aligned_p
&& !TARGET_FDPIC
)
6918 static int label_num
= 0;
6922 ASM_GENERATE_INTERNAL_LABEL (buf
, "LCP", label_num
++);
6923 p
= (* targetm
.strip_name_encoding
) (buf
);
6925 fprintf (asm_out_file
, "%s:\n", p
);
6926 fprintf (asm_out_file
, "%s\n", FIXUP_SECTION_ASM_OP
);
6927 fprintf (asm_out_file
, "\t.picptr\t%s\n", p
);
6928 fprintf (asm_out_file
, "\t.previous\n");
6930 assemble_integer_with_op ("\t.picptr\t", value
);
6935 /* We've set the unaligned SI op to NULL, so we always have to
6936 handle the unaligned case here. */
6937 assemble_integer_with_op ("\t.4byte\t", value
);
6941 return default_assemble_integer (value
, size
, aligned_p
);
6944 /* Function to set up the backend function structure. */
6946 static struct machine_function
*
6947 frv_init_machine_status (void)
6949 return ggc_alloc_cleared (sizeof (struct machine_function
));
6952 /* Implement TARGET_SCHED_ISSUE_RATE. */
6955 frv_issue_rate (void)
6960 switch (frv_cpu_type
)
6964 case FRV_CPU_SIMPLE
:
6972 case FRV_CPU_GENERIC
:
6974 case FRV_CPU_TOMCAT
:
6982 /* A for_each_rtx callback. If X refers to an accumulator, return
6983 ACC_GROUP_ODD if the bit 2 of the register number is set and
6984 ACC_GROUP_EVEN if it is clear. Return 0 (ACC_GROUP_NONE)
6988 frv_acc_group_1 (rtx
*x
, void *data ATTRIBUTE_UNUSED
)
6992 if (ACC_P (REGNO (*x
)))
6993 return (REGNO (*x
) - ACC_FIRST
) & 4 ? ACC_GROUP_ODD
: ACC_GROUP_EVEN
;
6994 if (ACCG_P (REGNO (*x
)))
6995 return (REGNO (*x
) - ACCG_FIRST
) & 4 ? ACC_GROUP_ODD
: ACC_GROUP_EVEN
;
7000 /* Return the value of INSN's acc_group attribute. */
7003 frv_acc_group (rtx insn
)
7005 /* This distinction only applies to the FR550 packing constraints. */
7006 if (frv_cpu_type
!= FRV_CPU_FR550
)
7007 return ACC_GROUP_NONE
;
7008 return for_each_rtx (&PATTERN (insn
), frv_acc_group_1
, 0);
7011 /* Return the index of the DFA unit in FRV_UNIT_NAMES[] that instruction
7012 INSN will try to claim first. Since this value depends only on the
7013 type attribute, we can cache the results in FRV_TYPE_TO_UNIT[]. */
7016 frv_insn_unit (rtx insn
)
7018 enum attr_type type
;
7020 type
= get_attr_type (insn
);
7021 if (frv_type_to_unit
[type
] == ARRAY_SIZE (frv_unit_codes
))
7023 /* We haven't seen this type of instruction before. */
7027 /* Issue the instruction on its own to see which unit it prefers. */
7028 state
= alloca (state_size ());
7029 state_reset (state
);
7030 state_transition (state
, insn
);
7032 /* Find out which unit was taken. */
7033 for (unit
= 0; unit
< ARRAY_SIZE (frv_unit_codes
); unit
++)
7034 if (cpu_unit_reservation_p (state
, frv_unit_codes
[unit
]))
7037 gcc_assert (unit
!= ARRAY_SIZE (frv_unit_codes
));
7039 frv_type_to_unit
[type
] = unit
;
7041 return frv_type_to_unit
[type
];
7044 /* Return true if INSN issues to a branch unit. */
7047 frv_issues_to_branch_unit_p (rtx insn
)
7049 return frv_unit_groups
[frv_insn_unit (insn
)] == GROUP_B
;
7052 /* The current state of the packing pass, implemented by frv_pack_insns. */
7054 /* The state of the pipeline DFA. */
7057 /* Which hardware registers are set within the current packet,
7058 and the conditions under which they are set. */
7059 regstate_t regstate
[FIRST_PSEUDO_REGISTER
];
7061 /* The memory locations that have been modified so far in this
7062 packet. MEM is the memref and COND is the regstate_t condition
7063 under which it is set. */
7069 /* The number of valid entries in MEMS. The value is larger than
7070 ARRAY_SIZE (mems) if there were too many mems to record. */
7071 unsigned int num_mems
;
7073 /* The maximum number of instructions that can be packed together. */
7074 unsigned int issue_rate
;
7076 /* The instructions in the packet, partitioned into groups. */
7077 struct frv_packet_group
{
7078 /* How many instructions in the packet belong to this group. */
7079 unsigned int num_insns
;
7081 /* A list of the instructions that belong to this group, in the order
7082 they appear in the rtl stream. */
7083 rtx insns
[ARRAY_SIZE (frv_unit_codes
)];
7085 /* The contents of INSNS after they have been sorted into the correct
7086 assembly-language order. Element X issues to unit X. The list may
7087 contain extra nops. */
7088 rtx sorted
[ARRAY_SIZE (frv_unit_codes
)];
7090 /* The member of frv_nops[] to use in sorted[]. */
7092 } groups
[NUM_GROUPS
];
7094 /* The instructions that make up the current packet. */
7095 rtx insns
[ARRAY_SIZE (frv_unit_codes
)];
7096 unsigned int num_insns
;
7099 /* Return the regstate_t flags for the given COND_EXEC condition.
7100 Abort if the condition isn't in the right form. */
7103 frv_cond_flags (rtx cond
)
7105 gcc_assert ((GET_CODE (cond
) == EQ
|| GET_CODE (cond
) == NE
)
7106 && GET_CODE (XEXP (cond
, 0)) == REG
7107 && CR_P (REGNO (XEXP (cond
, 0)))
7108 && XEXP (cond
, 1) == const0_rtx
);
7109 return ((REGNO (XEXP (cond
, 0)) - CR_FIRST
)
7110 | (GET_CODE (cond
) == NE
7112 : REGSTATE_IF_FALSE
));
7116 /* Return true if something accessed under condition COND2 can
7117 conflict with something written under condition COND1. */
7120 frv_regstate_conflict_p (regstate_t cond1
, regstate_t cond2
)
7122 /* If either reference was unconditional, we have a conflict. */
7123 if ((cond1
& REGSTATE_IF_EITHER
) == 0
7124 || (cond2
& REGSTATE_IF_EITHER
) == 0)
7127 /* The references might conflict if they were controlled by
7129 if ((cond1
& REGSTATE_CC_MASK
) != (cond2
& REGSTATE_CC_MASK
))
7132 /* They definitely conflict if they are controlled by the
7134 if ((cond1
& cond2
& REGSTATE_IF_EITHER
) != 0)
7141 /* A for_each_rtx callback. Return 1 if *X depends on an instruction in
7142 the current packet. DATA points to a regstate_t that describes the
7143 condition under which *X might be set or used. */
7146 frv_registers_conflict_p_1 (rtx
*x
, void *data
)
7148 unsigned int regno
, i
;
7151 cond
= *(regstate_t
*) data
;
7153 if (GET_CODE (*x
) == REG
)
7154 FOR_EACH_REGNO (regno
, *x
)
7155 if ((frv_packet
.regstate
[regno
] & REGSTATE_MODIFIED
) != 0)
7156 if (frv_regstate_conflict_p (frv_packet
.regstate
[regno
], cond
))
7159 if (GET_CODE (*x
) == MEM
)
7161 /* If we ran out of memory slots, assume a conflict. */
7162 if (frv_packet
.num_mems
> ARRAY_SIZE (frv_packet
.mems
))
7165 /* Check for output or true dependencies with earlier MEMs. */
7166 for (i
= 0; i
< frv_packet
.num_mems
; i
++)
7167 if (frv_regstate_conflict_p (frv_packet
.mems
[i
].cond
, cond
))
7169 if (true_dependence (frv_packet
.mems
[i
].mem
, VOIDmode
,
7173 if (output_dependence (frv_packet
.mems
[i
].mem
, *x
))
7178 /* The return values of calls aren't significant: they describe
7179 the effect of the call as a whole, not of the insn itself. */
7180 if (GET_CODE (*x
) == SET
&& GET_CODE (SET_SRC (*x
)) == CALL
)
7182 if (for_each_rtx (&SET_SRC (*x
), frv_registers_conflict_p_1
, data
))
7187 /* Check subexpressions. */
7192 /* Return true if something in X might depend on an instruction
7193 in the current packet. */
7196 frv_registers_conflict_p (rtx x
)
7201 if (GET_CODE (x
) == COND_EXEC
)
7203 if (for_each_rtx (&XEXP (x
, 0), frv_registers_conflict_p_1
, &flags
))
7206 flags
|= frv_cond_flags (XEXP (x
, 0));
7209 return for_each_rtx (&x
, frv_registers_conflict_p_1
, &flags
);
7213 /* A note_stores callback. DATA points to the regstate_t condition
7214 under which X is modified. Update FRV_PACKET accordingly. */
7217 frv_registers_update_1 (rtx x
, const_rtx pat ATTRIBUTE_UNUSED
, void *data
)
7221 if (GET_CODE (x
) == REG
)
7222 FOR_EACH_REGNO (regno
, x
)
7223 frv_packet
.regstate
[regno
] |= *(regstate_t
*) data
;
7225 if (GET_CODE (x
) == MEM
)
7227 if (frv_packet
.num_mems
< ARRAY_SIZE (frv_packet
.mems
))
7229 frv_packet
.mems
[frv_packet
.num_mems
].mem
= x
;
7230 frv_packet
.mems
[frv_packet
.num_mems
].cond
= *(regstate_t
*) data
;
7232 frv_packet
.num_mems
++;
7237 /* Update the register state information for an instruction whose
7241 frv_registers_update (rtx x
)
7245 flags
= REGSTATE_MODIFIED
;
7246 if (GET_CODE (x
) == COND_EXEC
)
7248 flags
|= frv_cond_flags (XEXP (x
, 0));
7251 note_stores (x
, frv_registers_update_1
, &flags
);
7255 /* Initialize frv_packet for the start of a new packet. */
7258 frv_start_packet (void)
7260 enum frv_insn_group group
;
7262 memset (frv_packet
.regstate
, 0, sizeof (frv_packet
.regstate
));
7263 frv_packet
.num_mems
= 0;
7264 frv_packet
.num_insns
= 0;
7265 for (group
= 0; group
< NUM_GROUPS
; group
++)
7266 frv_packet
.groups
[group
].num_insns
= 0;
7270 /* Likewise for the start of a new basic block. */
7273 frv_start_packet_block (void)
7275 state_reset (frv_packet
.dfa_state
);
7276 frv_start_packet ();
7280 /* Finish the current packet, if any, and start a new one. Call
7281 HANDLE_PACKET with FRV_PACKET describing the completed packet. */
7284 frv_finish_packet (void (*handle_packet
) (void))
7286 if (frv_packet
.num_insns
> 0)
7289 state_transition (frv_packet
.dfa_state
, 0);
7290 frv_start_packet ();
7295 /* Return true if INSN can be added to the current packet. Update
7296 the DFA state on success. */
7299 frv_pack_insn_p (rtx insn
)
7301 /* See if the packet is already as long as it can be. */
7302 if (frv_packet
.num_insns
== frv_packet
.issue_rate
)
7305 /* If the scheduler thought that an instruction should start a packet,
7306 it's usually a good idea to believe it. It knows much more about
7307 the latencies than we do.
7309 There are some exceptions though:
7311 - Conditional instructions are scheduled on the assumption that
7312 they will be executed. This is usually a good thing, since it
7313 tends to avoid unnecessary stalls in the conditional code.
7314 But we want to pack conditional instructions as tightly as
7315 possible, in order to optimize the case where they aren't
7318 - The scheduler will always put branches on their own, even
7319 if there's no real dependency.
7321 - There's no point putting a call in its own packet unless
7323 if (frv_packet
.num_insns
> 0
7324 && GET_CODE (insn
) == INSN
7325 && GET_MODE (insn
) == TImode
7326 && GET_CODE (PATTERN (insn
)) != COND_EXEC
)
7329 /* Check for register conflicts. Don't do this for setlo since any
7330 conflict will be with the partnering sethi, with which it can
7332 if (get_attr_type (insn
) != TYPE_SETLO
)
7333 if (frv_registers_conflict_p (PATTERN (insn
)))
7336 return state_transition (frv_packet
.dfa_state
, insn
) < 0;
7340 /* Add instruction INSN to the current packet. */
7343 frv_add_insn_to_packet (rtx insn
)
7345 struct frv_packet_group
*packet_group
;
7347 packet_group
= &frv_packet
.groups
[frv_unit_groups
[frv_insn_unit (insn
)]];
7348 packet_group
->insns
[packet_group
->num_insns
++] = insn
;
7349 frv_packet
.insns
[frv_packet
.num_insns
++] = insn
;
7351 frv_registers_update (PATTERN (insn
));
7355 /* Insert INSN (a member of frv_nops[]) into the current packet. If the
7356 packet ends in a branch or call, insert the nop before it, otherwise
7360 frv_insert_nop_in_packet (rtx insn
)
7362 struct frv_packet_group
*packet_group
;
7365 packet_group
= &frv_packet
.groups
[frv_unit_groups
[frv_insn_unit (insn
)]];
7366 last
= frv_packet
.insns
[frv_packet
.num_insns
- 1];
7367 if (GET_CODE (last
) != INSN
)
7369 insn
= emit_insn_before (PATTERN (insn
), last
);
7370 frv_packet
.insns
[frv_packet
.num_insns
- 1] = insn
;
7371 frv_packet
.insns
[frv_packet
.num_insns
++] = last
;
7375 insn
= emit_insn_after (PATTERN (insn
), last
);
7376 frv_packet
.insns
[frv_packet
.num_insns
++] = insn
;
7378 packet_group
->insns
[packet_group
->num_insns
++] = insn
;
7382 /* If packing is enabled, divide the instructions into packets and
7383 return true. Call HANDLE_PACKET for each complete packet. */
7386 frv_for_each_packet (void (*handle_packet
) (void))
7388 rtx insn
, next_insn
;
7390 frv_packet
.issue_rate
= frv_issue_rate ();
7392 /* Early exit if we don't want to pack insns. */
7394 || !flag_schedule_insns_after_reload
7395 || !TARGET_VLIW_BRANCH
7396 || frv_packet
.issue_rate
== 1)
7399 /* Set up the initial packing state. */
7401 frv_packet
.dfa_state
= alloca (state_size ());
7403 frv_start_packet_block ();
7404 for (insn
= get_insns (); insn
!= 0; insn
= next_insn
)
7409 code
= GET_CODE (insn
);
7410 next_insn
= NEXT_INSN (insn
);
7412 if (code
== CODE_LABEL
)
7414 frv_finish_packet (handle_packet
);
7415 frv_start_packet_block ();
7419 switch (GET_CODE (PATTERN (insn
)))
7428 /* Calls mustn't be packed on a TOMCAT. */
7429 if (GET_CODE (insn
) == CALL_INSN
&& frv_cpu_type
== FRV_CPU_TOMCAT
)
7430 frv_finish_packet (handle_packet
);
7432 /* Since the last instruction in a packet determines the EH
7433 region, any exception-throwing instruction must come at
7434 the end of reordered packet. Insns that issue to a
7435 branch unit are bound to come last; for others it's
7436 too hard to predict. */
7437 eh_insn_p
= (find_reg_note (insn
, REG_EH_REGION
, NULL
) != NULL
);
7438 if (eh_insn_p
&& !frv_issues_to_branch_unit_p (insn
))
7439 frv_finish_packet (handle_packet
);
7441 /* Finish the current packet if we can't add INSN to it.
7442 Simulate cycles until INSN is ready to issue. */
7443 if (!frv_pack_insn_p (insn
))
7445 frv_finish_packet (handle_packet
);
7446 while (!frv_pack_insn_p (insn
))
7447 state_transition (frv_packet
.dfa_state
, 0);
7450 /* Add the instruction to the packet. */
7451 frv_add_insn_to_packet (insn
);
7453 /* Calls and jumps end a packet, as do insns that throw
7455 if (code
== CALL_INSN
|| code
== JUMP_INSN
|| eh_insn_p
)
7456 frv_finish_packet (handle_packet
);
7460 frv_finish_packet (handle_packet
);
7465 /* Subroutine of frv_sort_insn_group. We are trying to sort
7466 frv_packet.groups[GROUP].sorted[0...NUM_INSNS-1] into assembly
7467 language order. We have already picked a new position for
7468 frv_packet.groups[GROUP].sorted[X] if bit X of ISSUED is set.
7469 These instructions will occupy elements [0, LOWER_SLOT) and
7470 [UPPER_SLOT, NUM_INSNS) of the final (sorted) array. STATE is
7471 the DFA state after issuing these instructions.
7473 Try filling elements [LOWER_SLOT, UPPER_SLOT) with every permutation
7474 of the unused instructions. Return true if one such permutation gives
7475 a valid ordering, leaving the successful permutation in sorted[].
7476 Do not modify sorted[] until a valid permutation is found. */
7479 frv_sort_insn_group_1 (enum frv_insn_group group
,
7480 unsigned int lower_slot
, unsigned int upper_slot
,
7481 unsigned int issued
, unsigned int num_insns
,
7484 struct frv_packet_group
*packet_group
;
7490 /* Early success if we've filled all the slots. */
7491 if (lower_slot
== upper_slot
)
7494 packet_group
= &frv_packet
.groups
[group
];
7495 dfa_size
= state_size ();
7496 test_state
= alloca (dfa_size
);
7498 /* Try issuing each unused instruction. */
7499 for (i
= num_insns
- 1; i
+ 1 != 0; i
--)
7500 if (~issued
& (1 << i
))
7502 insn
= packet_group
->sorted
[i
];
7503 memcpy (test_state
, state
, dfa_size
);
7504 if (state_transition (test_state
, insn
) < 0
7505 && cpu_unit_reservation_p (test_state
,
7506 NTH_UNIT (group
, upper_slot
- 1))
7507 && frv_sort_insn_group_1 (group
, lower_slot
, upper_slot
- 1,
7508 issued
| (1 << i
), num_insns
,
7511 packet_group
->sorted
[upper_slot
- 1] = insn
;
7519 /* Compare two instructions by their frv_insn_unit. */
7522 frv_compare_insns (const void *first
, const void *second
)
7524 const rtx
*insn1
= first
, *insn2
= second
;
7525 return frv_insn_unit (*insn1
) - frv_insn_unit (*insn2
);
7528 /* Copy frv_packet.groups[GROUP].insns[] to frv_packet.groups[GROUP].sorted[]
7529 and sort it into assembly language order. See frv.md for a description of
7533 frv_sort_insn_group (enum frv_insn_group group
)
7535 struct frv_packet_group
*packet_group
;
7536 unsigned int first
, i
, nop
, max_unit
, num_slots
;
7537 state_t state
, test_state
;
7540 packet_group
= &frv_packet
.groups
[group
];
7542 /* Assume no nop is needed. */
7543 packet_group
->nop
= 0;
7545 if (packet_group
->num_insns
== 0)
7548 /* Copy insns[] to sorted[]. */
7549 memcpy (packet_group
->sorted
, packet_group
->insns
,
7550 sizeof (rtx
) * packet_group
->num_insns
);
7552 /* Sort sorted[] by the unit that each insn tries to take first. */
7553 if (packet_group
->num_insns
> 1)
7554 qsort (packet_group
->sorted
, packet_group
->num_insns
,
7555 sizeof (rtx
), frv_compare_insns
);
7557 /* That's always enough for branch and control insns. */
7558 if (group
== GROUP_B
|| group
== GROUP_C
)
7561 dfa_size
= state_size ();
7562 state
= alloca (dfa_size
);
7563 test_state
= alloca (dfa_size
);
7565 /* Find the highest FIRST such that sorted[0...FIRST-1] can issue
7566 consecutively and such that the DFA takes unit X when sorted[X]
7567 is added. Set STATE to the new DFA state. */
7568 state_reset (test_state
);
7569 for (first
= 0; first
< packet_group
->num_insns
; first
++)
7571 memcpy (state
, test_state
, dfa_size
);
7572 if (state_transition (test_state
, packet_group
->sorted
[first
]) >= 0
7573 || !cpu_unit_reservation_p (test_state
, NTH_UNIT (group
, first
)))
7577 /* If all the instructions issued in ascending order, we're done. */
7578 if (first
== packet_group
->num_insns
)
7581 /* Add nops to the end of sorted[] and try each permutation until
7582 we find one that works. */
7583 for (nop
= 0; nop
< frv_num_nops
; nop
++)
7585 max_unit
= frv_insn_unit (frv_nops
[nop
]);
7586 if (frv_unit_groups
[max_unit
] == group
)
7588 packet_group
->nop
= frv_nops
[nop
];
7589 num_slots
= UNIT_NUMBER (max_unit
) + 1;
7590 for (i
= packet_group
->num_insns
; i
< num_slots
; i
++)
7591 packet_group
->sorted
[i
] = frv_nops
[nop
];
7592 if (frv_sort_insn_group_1 (group
, first
, num_slots
,
7593 (1 << first
) - 1, num_slots
, state
))
7600 /* Sort the current packet into assembly-language order. Set packing
7601 flags as appropriate. */
7604 frv_reorder_packet (void)
7606 unsigned int cursor
[NUM_GROUPS
];
7607 rtx insns
[ARRAY_SIZE (frv_unit_groups
)];
7608 unsigned int unit
, to
, from
;
7609 enum frv_insn_group group
;
7610 struct frv_packet_group
*packet_group
;
7612 /* First sort each group individually. */
7613 for (group
= 0; group
< NUM_GROUPS
; group
++)
7616 frv_sort_insn_group (group
);
7619 /* Go through the unit template and try add an instruction from
7620 that unit's group. */
7622 for (unit
= 0; unit
< ARRAY_SIZE (frv_unit_groups
); unit
++)
7624 group
= frv_unit_groups
[unit
];
7625 packet_group
= &frv_packet
.groups
[group
];
7626 if (cursor
[group
] < packet_group
->num_insns
)
7628 /* frv_reorg should have added nops for us. */
7629 gcc_assert (packet_group
->sorted
[cursor
[group
]]
7630 != packet_group
->nop
);
7631 insns
[to
++] = packet_group
->sorted
[cursor
[group
]++];
7635 gcc_assert (to
== frv_packet
.num_insns
);
7637 /* Clear the last instruction's packing flag, thus marking the end of
7638 a packet. Reorder the other instructions relative to it. */
7639 CLEAR_PACKING_FLAG (insns
[to
- 1]);
7640 for (from
= 0; from
< to
- 1; from
++)
7642 remove_insn (insns
[from
]);
7643 add_insn_before (insns
[from
], insns
[to
- 1], NULL
);
7644 SET_PACKING_FLAG (insns
[from
]);
7649 /* Divide instructions into packets. Reorder the contents of each
7650 packet so that they are in the correct assembly-language order.
7652 Since this pass can change the raw meaning of the rtl stream, it must
7653 only be called at the last minute, just before the instructions are
7657 frv_pack_insns (void)
7659 if (frv_for_each_packet (frv_reorder_packet
))
7660 frv_insn_packing_flag
= 0;
7662 frv_insn_packing_flag
= -1;
7665 /* See whether we need to add nops to group GROUP in order to
7666 make a valid packet. */
7669 frv_fill_unused_units (enum frv_insn_group group
)
7671 unsigned int non_nops
, nops
, i
;
7672 struct frv_packet_group
*packet_group
;
7674 packet_group
= &frv_packet
.groups
[group
];
7676 /* Sort the instructions into assembly-language order.
7677 Use nops to fill slots that are otherwise unused. */
7678 frv_sort_insn_group (group
);
7680 /* See how many nops are needed before the final useful instruction. */
7682 for (non_nops
= 0; non_nops
< packet_group
->num_insns
; non_nops
++)
7683 while (packet_group
->sorted
[i
++] == packet_group
->nop
)
7686 /* Insert that many nops into the instruction stream. */
7688 frv_insert_nop_in_packet (packet_group
->nop
);
7691 /* Return true if accesses IO1 and IO2 refer to the same doubleword. */
7694 frv_same_doubleword_p (const struct frv_io
*io1
, const struct frv_io
*io2
)
7696 if (io1
->const_address
!= 0 && io2
->const_address
!= 0)
7697 return io1
->const_address
== io2
->const_address
;
7699 if (io1
->var_address
!= 0 && io2
->var_address
!= 0)
7700 return rtx_equal_p (io1
->var_address
, io2
->var_address
);
7705 /* Return true if operations IO1 and IO2 are guaranteed to complete
7709 frv_io_fixed_order_p (const struct frv_io
*io1
, const struct frv_io
*io2
)
7711 /* The order of writes is always preserved. */
7712 if (io1
->type
== FRV_IO_WRITE
&& io2
->type
== FRV_IO_WRITE
)
7715 /* The order of reads isn't preserved. */
7716 if (io1
->type
!= FRV_IO_WRITE
&& io2
->type
!= FRV_IO_WRITE
)
7719 /* One operation is a write and the other is (or could be) a read.
7720 The order is only guaranteed if the accesses are to the same
7722 return frv_same_doubleword_p (io1
, io2
);
7725 /* Generalize I/O operation X so that it covers both X and Y. */
7728 frv_io_union (struct frv_io
*x
, const struct frv_io
*y
)
7730 if (x
->type
!= y
->type
)
7731 x
->type
= FRV_IO_UNKNOWN
;
7732 if (!frv_same_doubleword_p (x
, y
))
7734 x
->const_address
= 0;
7739 /* Fill IO with information about the load or store associated with
7740 membar instruction INSN. */
7743 frv_extract_membar (struct frv_io
*io
, rtx insn
)
7745 extract_insn (insn
);
7746 io
->type
= INTVAL (recog_data
.operand
[2]);
7747 io
->const_address
= INTVAL (recog_data
.operand
[1]);
7748 io
->var_address
= XEXP (recog_data
.operand
[0], 0);
7751 /* A note_stores callback for which DATA points to an rtx. Nullify *DATA
7752 if X is a register and *DATA depends on X. */
7755 frv_io_check_address (rtx x
, const_rtx pat ATTRIBUTE_UNUSED
, void *data
)
7759 if (REG_P (x
) && *other
!= 0 && reg_overlap_mentioned_p (x
, *other
))
7763 /* A note_stores callback for which DATA points to a HARD_REG_SET.
7764 Remove every modified register from the set. */
7767 frv_io_handle_set (rtx x
, const_rtx pat ATTRIBUTE_UNUSED
, void *data
)
7769 HARD_REG_SET
*set
= data
;
7773 FOR_EACH_REGNO (regno
, x
)
7774 CLEAR_HARD_REG_BIT (*set
, regno
);
7777 /* A for_each_rtx callback for which DATA points to a HARD_REG_SET.
7778 Add every register in *X to the set. */
7781 frv_io_handle_use_1 (rtx
*x
, void *data
)
7783 HARD_REG_SET
*set
= data
;
7787 FOR_EACH_REGNO (regno
, *x
)
7788 SET_HARD_REG_BIT (*set
, regno
);
7793 /* A note_stores callback that applies frv_io_handle_use_1 to an
7794 entire rhs value. */
7797 frv_io_handle_use (rtx
*x
, void *data
)
7799 for_each_rtx (x
, frv_io_handle_use_1
, data
);
7802 /* Go through block BB looking for membars to remove. There are two
7803 cases where intra-block analysis is enough:
7805 - a membar is redundant if it occurs between two consecutive I/O
7806 operations and if those operations are guaranteed to complete
7809 - a membar for a __builtin_read is redundant if the result is
7810 used before the next I/O operation is issued.
7812 If the last membar in the block could not be removed, and there
7813 are guaranteed to be no I/O operations between that membar and
7814 the end of the block, store the membar in *LAST_MEMBAR, otherwise
7817 Describe the block's first I/O operation in *NEXT_IO. Describe
7818 an unknown operation if the block doesn't do any I/O. */
7821 frv_optimize_membar_local (basic_block bb
, struct frv_io
*next_io
,
7824 HARD_REG_SET used_regs
;
7825 rtx next_membar
, set
, insn
;
7828 /* NEXT_IO is the next I/O operation to be performed after the current
7829 instruction. It starts off as being an unknown operation. */
7830 memset (next_io
, 0, sizeof (*next_io
));
7832 /* NEXT_IS_END_P is true if NEXT_IO describes the end of the block. */
7833 next_is_end_p
= true;
7835 /* If the current instruction is a __builtin_read or __builtin_write,
7836 NEXT_MEMBAR is the membar instruction associated with it. NEXT_MEMBAR
7837 is null if the membar has already been deleted.
7839 Note that the initialization here should only be needed to
7840 suppress warnings. */
7843 /* USED_REGS is the set of registers that are used before the
7844 next I/O instruction. */
7845 CLEAR_HARD_REG_SET (used_regs
);
7847 for (insn
= BB_END (bb
); insn
!= BB_HEAD (bb
); insn
= PREV_INSN (insn
))
7848 if (GET_CODE (insn
) == CALL_INSN
)
7850 /* We can't predict what a call will do to volatile memory. */
7851 memset (next_io
, 0, sizeof (struct frv_io
));
7852 next_is_end_p
= false;
7853 CLEAR_HARD_REG_SET (used_regs
);
7855 else if (INSN_P (insn
))
7856 switch (recog_memoized (insn
))
7858 case CODE_FOR_optional_membar_qi
:
7859 case CODE_FOR_optional_membar_hi
:
7860 case CODE_FOR_optional_membar_si
:
7861 case CODE_FOR_optional_membar_di
:
7865 /* Local information isn't enough to decide whether this
7866 membar is needed. Stash it away for later. */
7867 *last_membar
= insn
;
7868 frv_extract_membar (next_io
, insn
);
7869 next_is_end_p
= false;
7873 /* Check whether the I/O operation before INSN could be
7874 reordered with one described by NEXT_IO. If it can't,
7875 INSN will not be needed. */
7876 struct frv_io prev_io
;
7878 frv_extract_membar (&prev_io
, insn
);
7879 if (frv_io_fixed_order_p (&prev_io
, next_io
))
7883 ";; [Local] Removing membar %d since order"
7884 " of accesses is guaranteed\n",
7885 INSN_UID (next_membar
));
7887 insn
= NEXT_INSN (insn
);
7888 delete_insn (next_membar
);
7896 /* Invalidate NEXT_IO's address if it depends on something that
7897 is clobbered by INSN. */
7898 if (next_io
->var_address
)
7899 note_stores (PATTERN (insn
), frv_io_check_address
,
7900 &next_io
->var_address
);
7902 /* If the next membar is associated with a __builtin_read,
7903 see if INSN reads from that address. If it does, and if
7904 the destination register is used before the next I/O access,
7905 there is no need for the membar. */
7906 set
= PATTERN (insn
);
7907 if (next_io
->type
== FRV_IO_READ
7908 && next_io
->var_address
!= 0
7910 && GET_CODE (set
) == SET
7911 && GET_CODE (SET_DEST (set
)) == REG
7912 && TEST_HARD_REG_BIT (used_regs
, REGNO (SET_DEST (set
))))
7916 src
= SET_SRC (set
);
7917 if (GET_CODE (src
) == ZERO_EXTEND
)
7918 src
= XEXP (src
, 0);
7920 if (GET_CODE (src
) == MEM
7921 && rtx_equal_p (XEXP (src
, 0), next_io
->var_address
))
7925 ";; [Local] Removing membar %d since the target"
7926 " of %d is used before the I/O operation\n",
7927 INSN_UID (next_membar
), INSN_UID (insn
));
7929 if (next_membar
== *last_membar
)
7932 delete_insn (next_membar
);
7937 /* If INSN has volatile references, forget about any registers
7938 that are used after it. Otherwise forget about uses that
7939 are (or might be) defined by INSN. */
7940 if (volatile_refs_p (PATTERN (insn
)))
7941 CLEAR_HARD_REG_SET (used_regs
);
7943 note_stores (PATTERN (insn
), frv_io_handle_set
, &used_regs
);
7945 note_uses (&PATTERN (insn
), frv_io_handle_use
, &used_regs
);
7950 /* See if MEMBAR, the last membar instruction in BB, can be removed.
7951 FIRST_IO[X] describes the first operation performed by basic block X. */
7954 frv_optimize_membar_global (basic_block bb
, struct frv_io
*first_io
,
7957 struct frv_io this_io
, next_io
;
7961 /* We need to keep the membar if there is an edge to the exit block. */
7962 FOR_EACH_EDGE (succ
, ei
, bb
->succs
)
7963 /* for (succ = bb->succ; succ != 0; succ = succ->succ_next) */
7964 if (succ
->dest
== EXIT_BLOCK_PTR
)
7967 /* Work out the union of all successor blocks. */
7968 ei
= ei_start (bb
->succs
);
7969 ei_cond (ei
, &succ
);
7970 /* next_io = first_io[bb->succ->dest->index]; */
7971 next_io
= first_io
[succ
->dest
->index
];
7972 ei
= ei_start (bb
->succs
);
7973 if (ei_cond (ei
, &succ
))
7975 for (ei_next (&ei
); ei_cond (ei
, &succ
); ei_next (&ei
))
7976 /*for (succ = bb->succ->succ_next; succ != 0; succ = succ->succ_next)*/
7977 frv_io_union (&next_io
, &first_io
[succ
->dest
->index
]);
7982 frv_extract_membar (&this_io
, membar
);
7983 if (frv_io_fixed_order_p (&this_io
, &next_io
))
7987 ";; [Global] Removing membar %d since order of accesses"
7988 " is guaranteed\n", INSN_UID (membar
));
7990 delete_insn (membar
);
7994 /* Remove redundant membars from the current function. */
7997 frv_optimize_membar (void)
8000 struct frv_io
*first_io
;
8003 compute_bb_for_insn ();
8004 first_io
= xcalloc (last_basic_block
, sizeof (struct frv_io
));
8005 last_membar
= xcalloc (last_basic_block
, sizeof (rtx
));
8008 frv_optimize_membar_local (bb
, &first_io
[bb
->index
],
8009 &last_membar
[bb
->index
]);
8012 if (last_membar
[bb
->index
] != 0)
8013 frv_optimize_membar_global (bb
, first_io
, last_membar
[bb
->index
]);
8019 /* Used by frv_reorg to keep track of the current packet's address. */
8020 static unsigned int frv_packet_address
;
8022 /* If the current packet falls through to a label, try to pad the packet
8023 with nops in order to fit the label's alignment requirements. */
8026 frv_align_label (void)
8028 unsigned int alignment
, target
, nop
;
8029 rtx x
, last
, barrier
, label
;
8031 /* Walk forward to the start of the next packet. Set ALIGNMENT to the
8032 maximum alignment of that packet, LABEL to the last label between
8033 the packets, and BARRIER to the last barrier. */
8034 last
= frv_packet
.insns
[frv_packet
.num_insns
- 1];
8035 label
= barrier
= 0;
8037 for (x
= NEXT_INSN (last
); x
!= 0 && !INSN_P (x
); x
= NEXT_INSN (x
))
8041 unsigned int subalign
= 1 << label_to_alignment (x
);
8042 alignment
= MAX (alignment
, subalign
);
8049 /* If -malign-labels, and the packet falls through to an unaligned
8050 label, try introducing a nop to align that label to 8 bytes. */
8051 if (TARGET_ALIGN_LABELS
8054 && frv_packet
.num_insns
< frv_packet
.issue_rate
)
8055 alignment
= MAX (alignment
, 8);
8057 /* Advance the address to the end of the current packet. */
8058 frv_packet_address
+= frv_packet
.num_insns
* 4;
8060 /* Work out the target address, after alignment. */
8061 target
= (frv_packet_address
+ alignment
- 1) & -alignment
;
8063 /* If the packet falls through to the label, try to find an efficient
8064 padding sequence. */
8067 /* First try adding nops to the current packet. */
8068 for (nop
= 0; nop
< frv_num_nops
; nop
++)
8069 while (frv_packet_address
< target
&& frv_pack_insn_p (frv_nops
[nop
]))
8071 frv_insert_nop_in_packet (frv_nops
[nop
]);
8072 frv_packet_address
+= 4;
8075 /* If we still haven't reached the target, add some new packets that
8076 contain only nops. If there are two types of nop, insert an
8077 alternating sequence of frv_nops[0] and frv_nops[1], which will
8078 lead to packets like:
8085 etc. Just emit frv_nops[0] if that's the only nop we have. */
8086 last
= frv_packet
.insns
[frv_packet
.num_insns
- 1];
8088 while (frv_packet_address
< target
)
8090 last
= emit_insn_after (PATTERN (frv_nops
[nop
]), last
);
8091 frv_packet_address
+= 4;
8092 if (frv_num_nops
> 1)
8097 frv_packet_address
= target
;
8100 /* Subroutine of frv_reorg, called after each packet has been constructed
8104 frv_reorg_packet (void)
8106 frv_fill_unused_units (GROUP_I
);
8107 frv_fill_unused_units (GROUP_FM
);
8111 /* Add an instruction with pattern NOP to frv_nops[]. */
8114 frv_register_nop (rtx nop
)
8116 nop
= make_insn_raw (nop
);
8117 NEXT_INSN (nop
) = 0;
8118 PREV_INSN (nop
) = 0;
8119 frv_nops
[frv_num_nops
++] = nop
;
8122 /* Implement TARGET_MACHINE_DEPENDENT_REORG. Divide the instructions
8123 into packets and check whether we need to insert nops in order to
8124 fulfill the processor's issue requirements. Also, if the user has
8125 requested a certain alignment for a label, try to meet that alignment
8126 by inserting nops in the previous packet. */
8131 if (optimize
> 0 && TARGET_OPTIMIZE_MEMBAR
&& cfun
->machine
->has_membar_p
)
8132 frv_optimize_membar ();
8135 frv_register_nop (gen_nop ());
8137 frv_register_nop (gen_mnop ());
8138 if (TARGET_HARD_FLOAT
)
8139 frv_register_nop (gen_fnop ());
8141 /* Estimate the length of each branch. Although this may change after
8142 we've inserted nops, it will only do so in big functions. */
8143 shorten_branches (get_insns ());
8145 frv_packet_address
= 0;
8146 frv_for_each_packet (frv_reorg_packet
);
8149 #define def_builtin(name, type, code) \
8150 add_builtin_function ((name), (type), (code), BUILT_IN_MD, NULL, NULL)
8152 struct builtin_description
8154 enum insn_code icode
;
8156 enum frv_builtins code
;
8157 enum rtx_code comparison
;
8161 /* Media intrinsics that take a single, constant argument. */
8163 static struct builtin_description bdesc_set
[] =
8165 { CODE_FOR_mhdsets
, "__MHDSETS", FRV_BUILTIN_MHDSETS
, 0, 0 }
8168 /* Media intrinsics that take just one argument. */
8170 static struct builtin_description bdesc_1arg
[] =
8172 { CODE_FOR_mnot
, "__MNOT", FRV_BUILTIN_MNOT
, 0, 0 },
8173 { CODE_FOR_munpackh
, "__MUNPACKH", FRV_BUILTIN_MUNPACKH
, 0, 0 },
8174 { CODE_FOR_mbtoh
, "__MBTOH", FRV_BUILTIN_MBTOH
, 0, 0 },
8175 { CODE_FOR_mhtob
, "__MHTOB", FRV_BUILTIN_MHTOB
, 0, 0 },
8176 { CODE_FOR_mabshs
, "__MABSHS", FRV_BUILTIN_MABSHS
, 0, 0 },
8177 { CODE_FOR_scutss
, "__SCUTSS", FRV_BUILTIN_SCUTSS
, 0, 0 }
8180 /* Media intrinsics that take two arguments. */
8182 static struct builtin_description bdesc_2arg
[] =
8184 { CODE_FOR_mand
, "__MAND", FRV_BUILTIN_MAND
, 0, 0 },
8185 { CODE_FOR_mor
, "__MOR", FRV_BUILTIN_MOR
, 0, 0 },
8186 { CODE_FOR_mxor
, "__MXOR", FRV_BUILTIN_MXOR
, 0, 0 },
8187 { CODE_FOR_maveh
, "__MAVEH", FRV_BUILTIN_MAVEH
, 0, 0 },
8188 { CODE_FOR_msaths
, "__MSATHS", FRV_BUILTIN_MSATHS
, 0, 0 },
8189 { CODE_FOR_msathu
, "__MSATHU", FRV_BUILTIN_MSATHU
, 0, 0 },
8190 { CODE_FOR_maddhss
, "__MADDHSS", FRV_BUILTIN_MADDHSS
, 0, 0 },
8191 { CODE_FOR_maddhus
, "__MADDHUS", FRV_BUILTIN_MADDHUS
, 0, 0 },
8192 { CODE_FOR_msubhss
, "__MSUBHSS", FRV_BUILTIN_MSUBHSS
, 0, 0 },
8193 { CODE_FOR_msubhus
, "__MSUBHUS", FRV_BUILTIN_MSUBHUS
, 0, 0 },
8194 { CODE_FOR_mqaddhss
, "__MQADDHSS", FRV_BUILTIN_MQADDHSS
, 0, 0 },
8195 { CODE_FOR_mqaddhus
, "__MQADDHUS", FRV_BUILTIN_MQADDHUS
, 0, 0 },
8196 { CODE_FOR_mqsubhss
, "__MQSUBHSS", FRV_BUILTIN_MQSUBHSS
, 0, 0 },
8197 { CODE_FOR_mqsubhus
, "__MQSUBHUS", FRV_BUILTIN_MQSUBHUS
, 0, 0 },
8198 { CODE_FOR_mpackh
, "__MPACKH", FRV_BUILTIN_MPACKH
, 0, 0 },
8199 { CODE_FOR_mcop1
, "__Mcop1", FRV_BUILTIN_MCOP1
, 0, 0 },
8200 { CODE_FOR_mcop2
, "__Mcop2", FRV_BUILTIN_MCOP2
, 0, 0 },
8201 { CODE_FOR_mwcut
, "__MWCUT", FRV_BUILTIN_MWCUT
, 0, 0 },
8202 { CODE_FOR_mqsaths
, "__MQSATHS", FRV_BUILTIN_MQSATHS
, 0, 0 },
8203 { CODE_FOR_mqlclrhs
, "__MQLCLRHS", FRV_BUILTIN_MQLCLRHS
, 0, 0 },
8204 { CODE_FOR_mqlmths
, "__MQLMTHS", FRV_BUILTIN_MQLMTHS
, 0, 0 },
8205 { CODE_FOR_smul
, "__SMUL", FRV_BUILTIN_SMUL
, 0, 0 },
8206 { CODE_FOR_umul
, "__UMUL", FRV_BUILTIN_UMUL
, 0, 0 },
8207 { CODE_FOR_addss
, "__ADDSS", FRV_BUILTIN_ADDSS
, 0, 0 },
8208 { CODE_FOR_subss
, "__SUBSS", FRV_BUILTIN_SUBSS
, 0, 0 },
8209 { CODE_FOR_slass
, "__SLASS", FRV_BUILTIN_SLASS
, 0, 0 },
8210 { CODE_FOR_scan
, "__SCAN", FRV_BUILTIN_SCAN
, 0, 0 }
8213 /* Integer intrinsics that take two arguments and have no return value. */
8215 static struct builtin_description bdesc_int_void2arg
[] =
8217 { CODE_FOR_smass
, "__SMASS", FRV_BUILTIN_SMASS
, 0, 0 },
8218 { CODE_FOR_smsss
, "__SMSSS", FRV_BUILTIN_SMSSS
, 0, 0 },
8219 { CODE_FOR_smu
, "__SMU", FRV_BUILTIN_SMU
, 0, 0 }
8222 static struct builtin_description bdesc_prefetches
[] =
8224 { CODE_FOR_frv_prefetch0
, "__data_prefetch0", FRV_BUILTIN_PREFETCH0
, 0, 0 },
8225 { CODE_FOR_frv_prefetch
, "__data_prefetch", FRV_BUILTIN_PREFETCH
, 0, 0 }
8228 /* Media intrinsics that take two arguments, the first being an ACC number. */
8230 static struct builtin_description bdesc_cut
[] =
8232 { CODE_FOR_mcut
, "__MCUT", FRV_BUILTIN_MCUT
, 0, 0 },
8233 { CODE_FOR_mcutss
, "__MCUTSS", FRV_BUILTIN_MCUTSS
, 0, 0 },
8234 { CODE_FOR_mdcutssi
, "__MDCUTSSI", FRV_BUILTIN_MDCUTSSI
, 0, 0 }
8237 /* Two-argument media intrinsics with an immediate second argument. */
8239 static struct builtin_description bdesc_2argimm
[] =
8241 { CODE_FOR_mrotli
, "__MROTLI", FRV_BUILTIN_MROTLI
, 0, 0 },
8242 { CODE_FOR_mrotri
, "__MROTRI", FRV_BUILTIN_MROTRI
, 0, 0 },
8243 { CODE_FOR_msllhi
, "__MSLLHI", FRV_BUILTIN_MSLLHI
, 0, 0 },
8244 { CODE_FOR_msrlhi
, "__MSRLHI", FRV_BUILTIN_MSRLHI
, 0, 0 },
8245 { CODE_FOR_msrahi
, "__MSRAHI", FRV_BUILTIN_MSRAHI
, 0, 0 },
8246 { CODE_FOR_mexpdhw
, "__MEXPDHW", FRV_BUILTIN_MEXPDHW
, 0, 0 },
8247 { CODE_FOR_mexpdhd
, "__MEXPDHD", FRV_BUILTIN_MEXPDHD
, 0, 0 },
8248 { CODE_FOR_mdrotli
, "__MDROTLI", FRV_BUILTIN_MDROTLI
, 0, 0 },
8249 { CODE_FOR_mcplhi
, "__MCPLHI", FRV_BUILTIN_MCPLHI
, 0, 0 },
8250 { CODE_FOR_mcpli
, "__MCPLI", FRV_BUILTIN_MCPLI
, 0, 0 },
8251 { CODE_FOR_mhsetlos
, "__MHSETLOS", FRV_BUILTIN_MHSETLOS
, 0, 0 },
8252 { CODE_FOR_mhsetloh
, "__MHSETLOH", FRV_BUILTIN_MHSETLOH
, 0, 0 },
8253 { CODE_FOR_mhsethis
, "__MHSETHIS", FRV_BUILTIN_MHSETHIS
, 0, 0 },
8254 { CODE_FOR_mhsethih
, "__MHSETHIH", FRV_BUILTIN_MHSETHIH
, 0, 0 },
8255 { CODE_FOR_mhdseth
, "__MHDSETH", FRV_BUILTIN_MHDSETH
, 0, 0 },
8256 { CODE_FOR_mqsllhi
, "__MQSLLHI", FRV_BUILTIN_MQSLLHI
, 0, 0 },
8257 { CODE_FOR_mqsrahi
, "__MQSRAHI", FRV_BUILTIN_MQSRAHI
, 0, 0 }
8260 /* Media intrinsics that take two arguments and return void, the first argument
8261 being a pointer to 4 words in memory. */
8263 static struct builtin_description bdesc_void2arg
[] =
8265 { CODE_FOR_mdunpackh
, "__MDUNPACKH", FRV_BUILTIN_MDUNPACKH
, 0, 0 },
8266 { CODE_FOR_mbtohe
, "__MBTOHE", FRV_BUILTIN_MBTOHE
, 0, 0 },
8269 /* Media intrinsics that take three arguments, the first being a const_int that
8270 denotes an accumulator, and that return void. */
8272 static struct builtin_description bdesc_void3arg
[] =
8274 { CODE_FOR_mcpxrs
, "__MCPXRS", FRV_BUILTIN_MCPXRS
, 0, 0 },
8275 { CODE_FOR_mcpxru
, "__MCPXRU", FRV_BUILTIN_MCPXRU
, 0, 0 },
8276 { CODE_FOR_mcpxis
, "__MCPXIS", FRV_BUILTIN_MCPXIS
, 0, 0 },
8277 { CODE_FOR_mcpxiu
, "__MCPXIU", FRV_BUILTIN_MCPXIU
, 0, 0 },
8278 { CODE_FOR_mmulhs
, "__MMULHS", FRV_BUILTIN_MMULHS
, 0, 0 },
8279 { CODE_FOR_mmulhu
, "__MMULHU", FRV_BUILTIN_MMULHU
, 0, 0 },
8280 { CODE_FOR_mmulxhs
, "__MMULXHS", FRV_BUILTIN_MMULXHS
, 0, 0 },
8281 { CODE_FOR_mmulxhu
, "__MMULXHU", FRV_BUILTIN_MMULXHU
, 0, 0 },
8282 { CODE_FOR_mmachs
, "__MMACHS", FRV_BUILTIN_MMACHS
, 0, 0 },
8283 { CODE_FOR_mmachu
, "__MMACHU", FRV_BUILTIN_MMACHU
, 0, 0 },
8284 { CODE_FOR_mmrdhs
, "__MMRDHS", FRV_BUILTIN_MMRDHS
, 0, 0 },
8285 { CODE_FOR_mmrdhu
, "__MMRDHU", FRV_BUILTIN_MMRDHU
, 0, 0 },
8286 { CODE_FOR_mqcpxrs
, "__MQCPXRS", FRV_BUILTIN_MQCPXRS
, 0, 0 },
8287 { CODE_FOR_mqcpxru
, "__MQCPXRU", FRV_BUILTIN_MQCPXRU
, 0, 0 },
8288 { CODE_FOR_mqcpxis
, "__MQCPXIS", FRV_BUILTIN_MQCPXIS
, 0, 0 },
8289 { CODE_FOR_mqcpxiu
, "__MQCPXIU", FRV_BUILTIN_MQCPXIU
, 0, 0 },
8290 { CODE_FOR_mqmulhs
, "__MQMULHS", FRV_BUILTIN_MQMULHS
, 0, 0 },
8291 { CODE_FOR_mqmulhu
, "__MQMULHU", FRV_BUILTIN_MQMULHU
, 0, 0 },
8292 { CODE_FOR_mqmulxhs
, "__MQMULXHS", FRV_BUILTIN_MQMULXHS
, 0, 0 },
8293 { CODE_FOR_mqmulxhu
, "__MQMULXHU", FRV_BUILTIN_MQMULXHU
, 0, 0 },
8294 { CODE_FOR_mqmachs
, "__MQMACHS", FRV_BUILTIN_MQMACHS
, 0, 0 },
8295 { CODE_FOR_mqmachu
, "__MQMACHU", FRV_BUILTIN_MQMACHU
, 0, 0 },
8296 { CODE_FOR_mqxmachs
, "__MQXMACHS", FRV_BUILTIN_MQXMACHS
, 0, 0 },
8297 { CODE_FOR_mqxmacxhs
, "__MQXMACXHS", FRV_BUILTIN_MQXMACXHS
, 0, 0 },
8298 { CODE_FOR_mqmacxhs
, "__MQMACXHS", FRV_BUILTIN_MQMACXHS
, 0, 0 }
8301 /* Media intrinsics that take two accumulator numbers as argument and
8304 static struct builtin_description bdesc_voidacc
[] =
8306 { CODE_FOR_maddaccs
, "__MADDACCS", FRV_BUILTIN_MADDACCS
, 0, 0 },
8307 { CODE_FOR_msubaccs
, "__MSUBACCS", FRV_BUILTIN_MSUBACCS
, 0, 0 },
8308 { CODE_FOR_masaccs
, "__MASACCS", FRV_BUILTIN_MASACCS
, 0, 0 },
8309 { CODE_FOR_mdaddaccs
, "__MDADDACCS", FRV_BUILTIN_MDADDACCS
, 0, 0 },
8310 { CODE_FOR_mdsubaccs
, "__MDSUBACCS", FRV_BUILTIN_MDSUBACCS
, 0, 0 },
8311 { CODE_FOR_mdasaccs
, "__MDASACCS", FRV_BUILTIN_MDASACCS
, 0, 0 }
8314 /* Intrinsics that load a value and then issue a MEMBAR. The load is
8315 a normal move and the ICODE is for the membar. */
8317 static struct builtin_description bdesc_loads
[] =
8319 { CODE_FOR_optional_membar_qi
, "__builtin_read8",
8320 FRV_BUILTIN_READ8
, 0, 0 },
8321 { CODE_FOR_optional_membar_hi
, "__builtin_read16",
8322 FRV_BUILTIN_READ16
, 0, 0 },
8323 { CODE_FOR_optional_membar_si
, "__builtin_read32",
8324 FRV_BUILTIN_READ32
, 0, 0 },
8325 { CODE_FOR_optional_membar_di
, "__builtin_read64",
8326 FRV_BUILTIN_READ64
, 0, 0 }
8329 /* Likewise stores. */
8331 static struct builtin_description bdesc_stores
[] =
8333 { CODE_FOR_optional_membar_qi
, "__builtin_write8",
8334 FRV_BUILTIN_WRITE8
, 0, 0 },
8335 { CODE_FOR_optional_membar_hi
, "__builtin_write16",
8336 FRV_BUILTIN_WRITE16
, 0, 0 },
8337 { CODE_FOR_optional_membar_si
, "__builtin_write32",
8338 FRV_BUILTIN_WRITE32
, 0, 0 },
8339 { CODE_FOR_optional_membar_di
, "__builtin_write64",
8340 FRV_BUILTIN_WRITE64
, 0, 0 },
8343 /* Initialize media builtins. */
8346 frv_init_builtins (void)
8348 tree endlink
= void_list_node
;
8349 tree accumulator
= integer_type_node
;
8350 tree integer
= integer_type_node
;
8351 tree voidt
= void_type_node
;
8352 tree uhalf
= short_unsigned_type_node
;
8353 tree sword1
= long_integer_type_node
;
8354 tree uword1
= long_unsigned_type_node
;
8355 tree sword2
= long_long_integer_type_node
;
8356 tree uword2
= long_long_unsigned_type_node
;
8357 tree uword4
= build_pointer_type (uword1
);
8358 tree vptr
= build_pointer_type (build_type_variant (void_type_node
, 0, 1));
8359 tree ubyte
= unsigned_char_type_node
;
8360 tree iacc
= integer_type_node
;
8362 #define UNARY(RET, T1) \
8363 build_function_type (RET, tree_cons (NULL_TREE, T1, endlink))
8365 #define BINARY(RET, T1, T2) \
8366 build_function_type (RET, tree_cons (NULL_TREE, T1, \
8367 tree_cons (NULL_TREE, T2, endlink)))
8369 #define TRINARY(RET, T1, T2, T3) \
8370 build_function_type (RET, tree_cons (NULL_TREE, T1, \
8371 tree_cons (NULL_TREE, T2, \
8372 tree_cons (NULL_TREE, T3, endlink))))
8374 #define QUAD(RET, T1, T2, T3, T4) \
8375 build_function_type (RET, tree_cons (NULL_TREE, T1, \
8376 tree_cons (NULL_TREE, T2, \
8377 tree_cons (NULL_TREE, T3, \
8378 tree_cons (NULL_TREE, T4, endlink)))))
8380 tree void_ftype_void
= build_function_type (voidt
, endlink
);
8382 tree void_ftype_acc
= UNARY (voidt
, accumulator
);
8383 tree void_ftype_uw4_uw1
= BINARY (voidt
, uword4
, uword1
);
8384 tree void_ftype_uw4_uw2
= BINARY (voidt
, uword4
, uword2
);
8385 tree void_ftype_acc_uw1
= BINARY (voidt
, accumulator
, uword1
);
8386 tree void_ftype_acc_acc
= BINARY (voidt
, accumulator
, accumulator
);
8387 tree void_ftype_acc_uw1_uw1
= TRINARY (voidt
, accumulator
, uword1
, uword1
);
8388 tree void_ftype_acc_sw1_sw1
= TRINARY (voidt
, accumulator
, sword1
, sword1
);
8389 tree void_ftype_acc_uw2_uw2
= TRINARY (voidt
, accumulator
, uword2
, uword2
);
8390 tree void_ftype_acc_sw2_sw2
= TRINARY (voidt
, accumulator
, sword2
, sword2
);
8392 tree uw1_ftype_uw1
= UNARY (uword1
, uword1
);
8393 tree uw1_ftype_sw1
= UNARY (uword1
, sword1
);
8394 tree uw1_ftype_uw2
= UNARY (uword1
, uword2
);
8395 tree uw1_ftype_acc
= UNARY (uword1
, accumulator
);
8396 tree uw1_ftype_uh_uh
= BINARY (uword1
, uhalf
, uhalf
);
8397 tree uw1_ftype_uw1_uw1
= BINARY (uword1
, uword1
, uword1
);
8398 tree uw1_ftype_uw1_int
= BINARY (uword1
, uword1
, integer
);
8399 tree uw1_ftype_acc_uw1
= BINARY (uword1
, accumulator
, uword1
);
8400 tree uw1_ftype_acc_sw1
= BINARY (uword1
, accumulator
, sword1
);
8401 tree uw1_ftype_uw2_uw1
= BINARY (uword1
, uword2
, uword1
);
8402 tree uw1_ftype_uw2_int
= BINARY (uword1
, uword2
, integer
);
8404 tree sw1_ftype_int
= UNARY (sword1
, integer
);
8405 tree sw1_ftype_sw1_sw1
= BINARY (sword1
, sword1
, sword1
);
8406 tree sw1_ftype_sw1_int
= BINARY (sword1
, sword1
, integer
);
8408 tree uw2_ftype_uw1
= UNARY (uword2
, uword1
);
8409 tree uw2_ftype_uw1_int
= BINARY (uword2
, uword1
, integer
);
8410 tree uw2_ftype_uw2_uw2
= BINARY (uword2
, uword2
, uword2
);
8411 tree uw2_ftype_uw2_int
= BINARY (uword2
, uword2
, integer
);
8412 tree uw2_ftype_acc_int
= BINARY (uword2
, accumulator
, integer
);
8413 tree uw2_ftype_uh_uh_uh_uh
= QUAD (uword2
, uhalf
, uhalf
, uhalf
, uhalf
);
8415 tree sw2_ftype_sw2_sw2
= BINARY (sword2
, sword2
, sword2
);
8416 tree sw2_ftype_sw2_int
= BINARY (sword2
, sword2
, integer
);
8417 tree uw2_ftype_uw1_uw1
= BINARY (uword2
, uword1
, uword1
);
8418 tree sw2_ftype_sw1_sw1
= BINARY (sword2
, sword1
, sword1
);
8419 tree void_ftype_sw1_sw1
= BINARY (voidt
, sword1
, sword1
);
8420 tree void_ftype_iacc_sw2
= BINARY (voidt
, iacc
, sword2
);
8421 tree void_ftype_iacc_sw1
= BINARY (voidt
, iacc
, sword1
);
8422 tree sw1_ftype_sw1
= UNARY (sword1
, sword1
);
8423 tree sw2_ftype_iacc
= UNARY (sword2
, iacc
);
8424 tree sw1_ftype_iacc
= UNARY (sword1
, iacc
);
8425 tree void_ftype_ptr
= UNARY (voidt
, const_ptr_type_node
);
8426 tree uw1_ftype_vptr
= UNARY (uword1
, vptr
);
8427 tree uw2_ftype_vptr
= UNARY (uword2
, vptr
);
8428 tree void_ftype_vptr_ub
= BINARY (voidt
, vptr
, ubyte
);
8429 tree void_ftype_vptr_uh
= BINARY (voidt
, vptr
, uhalf
);
8430 tree void_ftype_vptr_uw1
= BINARY (voidt
, vptr
, uword1
);
8431 tree void_ftype_vptr_uw2
= BINARY (voidt
, vptr
, uword2
);
8433 def_builtin ("__MAND", uw1_ftype_uw1_uw1
, FRV_BUILTIN_MAND
);
8434 def_builtin ("__MOR", uw1_ftype_uw1_uw1
, FRV_BUILTIN_MOR
);
8435 def_builtin ("__MXOR", uw1_ftype_uw1_uw1
, FRV_BUILTIN_MXOR
);
8436 def_builtin ("__MNOT", uw1_ftype_uw1
, FRV_BUILTIN_MNOT
);
8437 def_builtin ("__MROTLI", uw1_ftype_uw1_int
, FRV_BUILTIN_MROTLI
);
8438 def_builtin ("__MROTRI", uw1_ftype_uw1_int
, FRV_BUILTIN_MROTRI
);
8439 def_builtin ("__MWCUT", uw1_ftype_uw2_uw1
, FRV_BUILTIN_MWCUT
);
8440 def_builtin ("__MAVEH", uw1_ftype_uw1_uw1
, FRV_BUILTIN_MAVEH
);
8441 def_builtin ("__MSLLHI", uw1_ftype_uw1_int
, FRV_BUILTIN_MSLLHI
);
8442 def_builtin ("__MSRLHI", uw1_ftype_uw1_int
, FRV_BUILTIN_MSRLHI
);
8443 def_builtin ("__MSRAHI", sw1_ftype_sw1_int
, FRV_BUILTIN_MSRAHI
);
8444 def_builtin ("__MSATHS", sw1_ftype_sw1_sw1
, FRV_BUILTIN_MSATHS
);
8445 def_builtin ("__MSATHU", uw1_ftype_uw1_uw1
, FRV_BUILTIN_MSATHU
);
8446 def_builtin ("__MADDHSS", sw1_ftype_sw1_sw1
, FRV_BUILTIN_MADDHSS
);
8447 def_builtin ("__MADDHUS", uw1_ftype_uw1_uw1
, FRV_BUILTIN_MADDHUS
);
8448 def_builtin ("__MSUBHSS", sw1_ftype_sw1_sw1
, FRV_BUILTIN_MSUBHSS
);
8449 def_builtin ("__MSUBHUS", uw1_ftype_uw1_uw1
, FRV_BUILTIN_MSUBHUS
);
8450 def_builtin ("__MMULHS", void_ftype_acc_sw1_sw1
, FRV_BUILTIN_MMULHS
);
8451 def_builtin ("__MMULHU", void_ftype_acc_uw1_uw1
, FRV_BUILTIN_MMULHU
);
8452 def_builtin ("__MMULXHS", void_ftype_acc_sw1_sw1
, FRV_BUILTIN_MMULXHS
);
8453 def_builtin ("__MMULXHU", void_ftype_acc_uw1_uw1
, FRV_BUILTIN_MMULXHU
);
8454 def_builtin ("__MMACHS", void_ftype_acc_sw1_sw1
, FRV_BUILTIN_MMACHS
);
8455 def_builtin ("__MMACHU", void_ftype_acc_uw1_uw1
, FRV_BUILTIN_MMACHU
);
8456 def_builtin ("__MMRDHS", void_ftype_acc_sw1_sw1
, FRV_BUILTIN_MMRDHS
);
8457 def_builtin ("__MMRDHU", void_ftype_acc_uw1_uw1
, FRV_BUILTIN_MMRDHU
);
8458 def_builtin ("__MQADDHSS", sw2_ftype_sw2_sw2
, FRV_BUILTIN_MQADDHSS
);
8459 def_builtin ("__MQADDHUS", uw2_ftype_uw2_uw2
, FRV_BUILTIN_MQADDHUS
);
8460 def_builtin ("__MQSUBHSS", sw2_ftype_sw2_sw2
, FRV_BUILTIN_MQSUBHSS
);
8461 def_builtin ("__MQSUBHUS", uw2_ftype_uw2_uw2
, FRV_BUILTIN_MQSUBHUS
);
8462 def_builtin ("__MQMULHS", void_ftype_acc_sw2_sw2
, FRV_BUILTIN_MQMULHS
);
8463 def_builtin ("__MQMULHU", void_ftype_acc_uw2_uw2
, FRV_BUILTIN_MQMULHU
);
8464 def_builtin ("__MQMULXHS", void_ftype_acc_sw2_sw2
, FRV_BUILTIN_MQMULXHS
);
8465 def_builtin ("__MQMULXHU", void_ftype_acc_uw2_uw2
, FRV_BUILTIN_MQMULXHU
);
8466 def_builtin ("__MQMACHS", void_ftype_acc_sw2_sw2
, FRV_BUILTIN_MQMACHS
);
8467 def_builtin ("__MQMACHU", void_ftype_acc_uw2_uw2
, FRV_BUILTIN_MQMACHU
);
8468 def_builtin ("__MCPXRS", void_ftype_acc_sw1_sw1
, FRV_BUILTIN_MCPXRS
);
8469 def_builtin ("__MCPXRU", void_ftype_acc_uw1_uw1
, FRV_BUILTIN_MCPXRU
);
8470 def_builtin ("__MCPXIS", void_ftype_acc_sw1_sw1
, FRV_BUILTIN_MCPXIS
);
8471 def_builtin ("__MCPXIU", void_ftype_acc_uw1_uw1
, FRV_BUILTIN_MCPXIU
);
8472 def_builtin ("__MQCPXRS", void_ftype_acc_sw2_sw2
, FRV_BUILTIN_MQCPXRS
);
8473 def_builtin ("__MQCPXRU", void_ftype_acc_uw2_uw2
, FRV_BUILTIN_MQCPXRU
);
8474 def_builtin ("__MQCPXIS", void_ftype_acc_sw2_sw2
, FRV_BUILTIN_MQCPXIS
);
8475 def_builtin ("__MQCPXIU", void_ftype_acc_uw2_uw2
, FRV_BUILTIN_MQCPXIU
);
8476 def_builtin ("__MCUT", uw1_ftype_acc_uw1
, FRV_BUILTIN_MCUT
);
8477 def_builtin ("__MCUTSS", uw1_ftype_acc_sw1
, FRV_BUILTIN_MCUTSS
);
8478 def_builtin ("__MEXPDHW", uw1_ftype_uw1_int
, FRV_BUILTIN_MEXPDHW
);
8479 def_builtin ("__MEXPDHD", uw2_ftype_uw1_int
, FRV_BUILTIN_MEXPDHD
);
8480 def_builtin ("__MPACKH", uw1_ftype_uh_uh
, FRV_BUILTIN_MPACKH
);
8481 def_builtin ("__MUNPACKH", uw2_ftype_uw1
, FRV_BUILTIN_MUNPACKH
);
8482 def_builtin ("__MDPACKH", uw2_ftype_uh_uh_uh_uh
, FRV_BUILTIN_MDPACKH
);
8483 def_builtin ("__MDUNPACKH", void_ftype_uw4_uw2
, FRV_BUILTIN_MDUNPACKH
);
8484 def_builtin ("__MBTOH", uw2_ftype_uw1
, FRV_BUILTIN_MBTOH
);
8485 def_builtin ("__MHTOB", uw1_ftype_uw2
, FRV_BUILTIN_MHTOB
);
8486 def_builtin ("__MBTOHE", void_ftype_uw4_uw1
, FRV_BUILTIN_MBTOHE
);
8487 def_builtin ("__MCLRACC", void_ftype_acc
, FRV_BUILTIN_MCLRACC
);
8488 def_builtin ("__MCLRACCA", void_ftype_void
, FRV_BUILTIN_MCLRACCA
);
8489 def_builtin ("__MRDACC", uw1_ftype_acc
, FRV_BUILTIN_MRDACC
);
8490 def_builtin ("__MRDACCG", uw1_ftype_acc
, FRV_BUILTIN_MRDACCG
);
8491 def_builtin ("__MWTACC", void_ftype_acc_uw1
, FRV_BUILTIN_MWTACC
);
8492 def_builtin ("__MWTACCG", void_ftype_acc_uw1
, FRV_BUILTIN_MWTACCG
);
8493 def_builtin ("__Mcop1", uw1_ftype_uw1_uw1
, FRV_BUILTIN_MCOP1
);
8494 def_builtin ("__Mcop2", uw1_ftype_uw1_uw1
, FRV_BUILTIN_MCOP2
);
8495 def_builtin ("__MTRAP", void_ftype_void
, FRV_BUILTIN_MTRAP
);
8496 def_builtin ("__MQXMACHS", void_ftype_acc_sw2_sw2
, FRV_BUILTIN_MQXMACHS
);
8497 def_builtin ("__MQXMACXHS", void_ftype_acc_sw2_sw2
, FRV_BUILTIN_MQXMACXHS
);
8498 def_builtin ("__MQMACXHS", void_ftype_acc_sw2_sw2
, FRV_BUILTIN_MQMACXHS
);
8499 def_builtin ("__MADDACCS", void_ftype_acc_acc
, FRV_BUILTIN_MADDACCS
);
8500 def_builtin ("__MSUBACCS", void_ftype_acc_acc
, FRV_BUILTIN_MSUBACCS
);
8501 def_builtin ("__MASACCS", void_ftype_acc_acc
, FRV_BUILTIN_MASACCS
);
8502 def_builtin ("__MDADDACCS", void_ftype_acc_acc
, FRV_BUILTIN_MDADDACCS
);
8503 def_builtin ("__MDSUBACCS", void_ftype_acc_acc
, FRV_BUILTIN_MDSUBACCS
);
8504 def_builtin ("__MDASACCS", void_ftype_acc_acc
, FRV_BUILTIN_MDASACCS
);
8505 def_builtin ("__MABSHS", uw1_ftype_sw1
, FRV_BUILTIN_MABSHS
);
8506 def_builtin ("__MDROTLI", uw2_ftype_uw2_int
, FRV_BUILTIN_MDROTLI
);
8507 def_builtin ("__MCPLHI", uw1_ftype_uw2_int
, FRV_BUILTIN_MCPLHI
);
8508 def_builtin ("__MCPLI", uw1_ftype_uw2_int
, FRV_BUILTIN_MCPLI
);
8509 def_builtin ("__MDCUTSSI", uw2_ftype_acc_int
, FRV_BUILTIN_MDCUTSSI
);
8510 def_builtin ("__MQSATHS", sw2_ftype_sw2_sw2
, FRV_BUILTIN_MQSATHS
);
8511 def_builtin ("__MHSETLOS", sw1_ftype_sw1_int
, FRV_BUILTIN_MHSETLOS
);
8512 def_builtin ("__MHSETHIS", sw1_ftype_sw1_int
, FRV_BUILTIN_MHSETHIS
);
8513 def_builtin ("__MHDSETS", sw1_ftype_int
, FRV_BUILTIN_MHDSETS
);
8514 def_builtin ("__MHSETLOH", uw1_ftype_uw1_int
, FRV_BUILTIN_MHSETLOH
);
8515 def_builtin ("__MHSETHIH", uw1_ftype_uw1_int
, FRV_BUILTIN_MHSETHIH
);
8516 def_builtin ("__MHDSETH", uw1_ftype_uw1_int
, FRV_BUILTIN_MHDSETH
);
8517 def_builtin ("__MQLCLRHS", sw2_ftype_sw2_sw2
, FRV_BUILTIN_MQLCLRHS
);
8518 def_builtin ("__MQLMTHS", sw2_ftype_sw2_sw2
, FRV_BUILTIN_MQLMTHS
);
8519 def_builtin ("__MQSLLHI", uw2_ftype_uw2_int
, FRV_BUILTIN_MQSLLHI
);
8520 def_builtin ("__MQSRAHI", sw2_ftype_sw2_int
, FRV_BUILTIN_MQSRAHI
);
8521 def_builtin ("__SMUL", sw2_ftype_sw1_sw1
, FRV_BUILTIN_SMUL
);
8522 def_builtin ("__UMUL", uw2_ftype_uw1_uw1
, FRV_BUILTIN_UMUL
);
8523 def_builtin ("__SMASS", void_ftype_sw1_sw1
, FRV_BUILTIN_SMASS
);
8524 def_builtin ("__SMSSS", void_ftype_sw1_sw1
, FRV_BUILTIN_SMSSS
);
8525 def_builtin ("__SMU", void_ftype_sw1_sw1
, FRV_BUILTIN_SMU
);
8526 def_builtin ("__ADDSS", sw1_ftype_sw1_sw1
, FRV_BUILTIN_ADDSS
);
8527 def_builtin ("__SUBSS", sw1_ftype_sw1_sw1
, FRV_BUILTIN_SUBSS
);
8528 def_builtin ("__SLASS", sw1_ftype_sw1_sw1
, FRV_BUILTIN_SLASS
);
8529 def_builtin ("__SCAN", sw1_ftype_sw1_sw1
, FRV_BUILTIN_SCAN
);
8530 def_builtin ("__SCUTSS", sw1_ftype_sw1
, FRV_BUILTIN_SCUTSS
);
8531 def_builtin ("__IACCreadll", sw2_ftype_iacc
, FRV_BUILTIN_IACCreadll
);
8532 def_builtin ("__IACCreadl", sw1_ftype_iacc
, FRV_BUILTIN_IACCreadl
);
8533 def_builtin ("__IACCsetll", void_ftype_iacc_sw2
, FRV_BUILTIN_IACCsetll
);
8534 def_builtin ("__IACCsetl", void_ftype_iacc_sw1
, FRV_BUILTIN_IACCsetl
);
8535 def_builtin ("__data_prefetch0", void_ftype_ptr
, FRV_BUILTIN_PREFETCH0
);
8536 def_builtin ("__data_prefetch", void_ftype_ptr
, FRV_BUILTIN_PREFETCH
);
8537 def_builtin ("__builtin_read8", uw1_ftype_vptr
, FRV_BUILTIN_READ8
);
8538 def_builtin ("__builtin_read16", uw1_ftype_vptr
, FRV_BUILTIN_READ16
);
8539 def_builtin ("__builtin_read32", uw1_ftype_vptr
, FRV_BUILTIN_READ32
);
8540 def_builtin ("__builtin_read64", uw2_ftype_vptr
, FRV_BUILTIN_READ64
);
8542 def_builtin ("__builtin_write8", void_ftype_vptr_ub
, FRV_BUILTIN_WRITE8
);
8543 def_builtin ("__builtin_write16", void_ftype_vptr_uh
, FRV_BUILTIN_WRITE16
);
8544 def_builtin ("__builtin_write32", void_ftype_vptr_uw1
, FRV_BUILTIN_WRITE32
);
8545 def_builtin ("__builtin_write64", void_ftype_vptr_uw2
, FRV_BUILTIN_WRITE64
);
8553 /* Set the names for various arithmetic operations according to the
8556 frv_init_libfuncs (void)
8558 set_optab_libfunc (smod_optab
, SImode
, "__modi");
8559 set_optab_libfunc (umod_optab
, SImode
, "__umodi");
8561 set_optab_libfunc (add_optab
, DImode
, "__addll");
8562 set_optab_libfunc (sub_optab
, DImode
, "__subll");
8563 set_optab_libfunc (smul_optab
, DImode
, "__mulll");
8564 set_optab_libfunc (sdiv_optab
, DImode
, "__divll");
8565 set_optab_libfunc (smod_optab
, DImode
, "__modll");
8566 set_optab_libfunc (umod_optab
, DImode
, "__umodll");
8567 set_optab_libfunc (and_optab
, DImode
, "__andll");
8568 set_optab_libfunc (ior_optab
, DImode
, "__orll");
8569 set_optab_libfunc (xor_optab
, DImode
, "__xorll");
8570 set_optab_libfunc (one_cmpl_optab
, DImode
, "__notll");
8572 set_optab_libfunc (add_optab
, SFmode
, "__addf");
8573 set_optab_libfunc (sub_optab
, SFmode
, "__subf");
8574 set_optab_libfunc (smul_optab
, SFmode
, "__mulf");
8575 set_optab_libfunc (sdiv_optab
, SFmode
, "__divf");
8577 set_optab_libfunc (add_optab
, DFmode
, "__addd");
8578 set_optab_libfunc (sub_optab
, DFmode
, "__subd");
8579 set_optab_libfunc (smul_optab
, DFmode
, "__muld");
8580 set_optab_libfunc (sdiv_optab
, DFmode
, "__divd");
8582 set_conv_libfunc (sext_optab
, DFmode
, SFmode
, "__ftod");
8583 set_conv_libfunc (trunc_optab
, SFmode
, DFmode
, "__dtof");
8585 set_conv_libfunc (sfix_optab
, SImode
, SFmode
, "__ftoi");
8586 set_conv_libfunc (sfix_optab
, DImode
, SFmode
, "__ftoll");
8587 set_conv_libfunc (sfix_optab
, SImode
, DFmode
, "__dtoi");
8588 set_conv_libfunc (sfix_optab
, DImode
, DFmode
, "__dtoll");
8590 set_conv_libfunc (ufix_optab
, SImode
, SFmode
, "__ftoui");
8591 set_conv_libfunc (ufix_optab
, DImode
, SFmode
, "__ftoull");
8592 set_conv_libfunc (ufix_optab
, SImode
, DFmode
, "__dtoui");
8593 set_conv_libfunc (ufix_optab
, DImode
, DFmode
, "__dtoull");
8595 set_conv_libfunc (sfloat_optab
, SFmode
, SImode
, "__itof");
8596 set_conv_libfunc (sfloat_optab
, SFmode
, DImode
, "__lltof");
8597 set_conv_libfunc (sfloat_optab
, DFmode
, SImode
, "__itod");
8598 set_conv_libfunc (sfloat_optab
, DFmode
, DImode
, "__lltod");
8601 /* Convert an integer constant to an accumulator register. ICODE is the
8602 code of the target instruction, OPNUM is the number of the
8603 accumulator operand and OPVAL is the constant integer. Try both
8604 ACC and ACCG registers; only report an error if neither fit the
8608 frv_int_to_acc (enum insn_code icode
, int opnum
, rtx opval
)
8613 /* ACCs and ACCGs are implicit global registers if media intrinsics
8614 are being used. We set up this lazily to avoid creating lots of
8615 unnecessary call_insn rtl in non-media code. */
8616 for (i
= 0; i
<= ACC_MASK
; i
++)
8617 if ((i
& ACC_MASK
) == i
)
8618 global_regs
[i
+ ACC_FIRST
] = global_regs
[i
+ ACCG_FIRST
] = 1;
8620 if (GET_CODE (opval
) != CONST_INT
)
8622 error ("accumulator is not a constant integer");
8625 if ((INTVAL (opval
) & ~ACC_MASK
) != 0)
8627 error ("accumulator number is out of bounds");
8631 reg
= gen_rtx_REG (insn_data
[icode
].operand
[opnum
].mode
,
8632 ACC_FIRST
+ INTVAL (opval
));
8633 if (! (*insn_data
[icode
].operand
[opnum
].predicate
) (reg
, VOIDmode
))
8634 SET_REGNO (reg
, ACCG_FIRST
+ INTVAL (opval
));
8636 if (! (*insn_data
[icode
].operand
[opnum
].predicate
) (reg
, VOIDmode
))
8638 error ("inappropriate accumulator for %qs", insn_data
[icode
].name
);
8644 /* If an ACC rtx has mode MODE, return the mode that the matching ACCG
8647 static enum machine_mode
8648 frv_matching_accg_mode (enum machine_mode mode
)
8666 /* Given that a __builtin_read or __builtin_write function is accessing
8667 address ADDRESS, return the value that should be used as operand 1
8671 frv_io_address_cookie (rtx address
)
8673 return (GET_CODE (address
) == CONST_INT
8674 ? GEN_INT (INTVAL (address
) / 8 * 8)
8678 /* Return the accumulator guard that should be paired with accumulator
8679 register ACC. The mode of the returned register is in the same
8680 class as ACC, but is four times smaller. */
8683 frv_matching_accg_for_acc (rtx acc
)
8685 return gen_rtx_REG (frv_matching_accg_mode (GET_MODE (acc
)),
8686 REGNO (acc
) - ACC_FIRST
+ ACCG_FIRST
);
8689 /* Read the requested argument from the call EXP given by INDEX.
8690 Return the value as an rtx. */
8693 frv_read_argument (tree exp
, unsigned int index
)
8695 return expand_expr (CALL_EXPR_ARG (exp
, index
),
8696 NULL_RTX
, VOIDmode
, 0);
8699 /* Like frv_read_argument, but interpret the argument as the number
8700 of an IACC register and return a (reg:MODE ...) rtx for it. */
8703 frv_read_iacc_argument (enum machine_mode mode
, tree call
,
8709 op
= frv_read_argument (call
, index
);
8710 if (GET_CODE (op
) != CONST_INT
8712 || INTVAL (op
) > IACC_LAST
- IACC_FIRST
8713 || ((INTVAL (op
) * 4) & (GET_MODE_SIZE (mode
) - 1)) != 0)
8715 error ("invalid IACC argument");
8719 /* IACCs are implicit global registers. We set up this lazily to
8720 avoid creating lots of unnecessary call_insn rtl when IACCs aren't
8722 regno
= INTVAL (op
) + IACC_FIRST
;
8723 for (i
= 0; i
< HARD_REGNO_NREGS (regno
, mode
); i
++)
8724 global_regs
[regno
+ i
] = 1;
8726 return gen_rtx_REG (mode
, regno
);
8729 /* Return true if OPVAL can be used for operand OPNUM of instruction ICODE.
8730 The instruction should require a constant operand of some sort. The
8731 function prints an error if OPVAL is not valid. */
8734 frv_check_constant_argument (enum insn_code icode
, int opnum
, rtx opval
)
8736 if (GET_CODE (opval
) != CONST_INT
)
8738 error ("%qs expects a constant argument", insn_data
[icode
].name
);
8741 if (! (*insn_data
[icode
].operand
[opnum
].predicate
) (opval
, VOIDmode
))
8743 error ("constant argument out of range for %qs", insn_data
[icode
].name
);
8749 /* Return a legitimate rtx for instruction ICODE's return value. Use TARGET
8750 if it's not null, has the right mode, and satisfies operand 0's
8754 frv_legitimize_target (enum insn_code icode
, rtx target
)
8756 enum machine_mode mode
= insn_data
[icode
].operand
[0].mode
;
8759 || GET_MODE (target
) != mode
8760 || ! (*insn_data
[icode
].operand
[0].predicate
) (target
, mode
))
8761 return gen_reg_rtx (mode
);
8766 /* Given that ARG is being passed as operand OPNUM to instruction ICODE,
8767 check whether ARG satisfies the operand's constraints. If it doesn't,
8768 copy ARG to a temporary register and return that. Otherwise return ARG
8772 frv_legitimize_argument (enum insn_code icode
, int opnum
, rtx arg
)
8774 enum machine_mode mode
= insn_data
[icode
].operand
[opnum
].mode
;
8776 if ((*insn_data
[icode
].operand
[opnum
].predicate
) (arg
, mode
))
8779 return copy_to_mode_reg (mode
, arg
);
8782 /* Return a volatile memory reference of mode MODE whose address is ARG. */
8785 frv_volatile_memref (enum machine_mode mode
, rtx arg
)
8789 mem
= gen_rtx_MEM (mode
, memory_address (mode
, arg
));
8790 MEM_VOLATILE_P (mem
) = 1;
8794 /* Expand builtins that take a single, constant argument. At the moment,
8795 only MHDSETS falls into this category. */
8798 frv_expand_set_builtin (enum insn_code icode
, tree call
, rtx target
)
8801 rtx op0
= frv_read_argument (call
, 0);
8803 if (! frv_check_constant_argument (icode
, 1, op0
))
8806 target
= frv_legitimize_target (icode
, target
);
8807 pat
= GEN_FCN (icode
) (target
, op0
);
8815 /* Expand builtins that take one operand. */
8818 frv_expand_unop_builtin (enum insn_code icode
, tree call
, rtx target
)
8821 rtx op0
= frv_read_argument (call
, 0);
8823 target
= frv_legitimize_target (icode
, target
);
8824 op0
= frv_legitimize_argument (icode
, 1, op0
);
8825 pat
= GEN_FCN (icode
) (target
, op0
);
8833 /* Expand builtins that take two operands. */
8836 frv_expand_binop_builtin (enum insn_code icode
, tree call
, rtx target
)
8839 rtx op0
= frv_read_argument (call
, 0);
8840 rtx op1
= frv_read_argument (call
, 1);
8842 target
= frv_legitimize_target (icode
, target
);
8843 op0
= frv_legitimize_argument (icode
, 1, op0
);
8844 op1
= frv_legitimize_argument (icode
, 2, op1
);
8845 pat
= GEN_FCN (icode
) (target
, op0
, op1
);
8853 /* Expand cut-style builtins, which take two operands and an implicit ACCG
8857 frv_expand_cut_builtin (enum insn_code icode
, tree call
, rtx target
)
8860 rtx op0
= frv_read_argument (call
, 0);
8861 rtx op1
= frv_read_argument (call
, 1);
8864 target
= frv_legitimize_target (icode
, target
);
8865 op0
= frv_int_to_acc (icode
, 1, op0
);
8869 if (icode
== CODE_FOR_mdcutssi
|| GET_CODE (op1
) == CONST_INT
)
8871 if (! frv_check_constant_argument (icode
, 2, op1
))
8875 op1
= frv_legitimize_argument (icode
, 2, op1
);
8877 op2
= frv_matching_accg_for_acc (op0
);
8878 pat
= GEN_FCN (icode
) (target
, op0
, op1
, op2
);
8886 /* Expand builtins that take two operands and the second is immediate. */
8889 frv_expand_binopimm_builtin (enum insn_code icode
, tree call
, rtx target
)
8892 rtx op0
= frv_read_argument (call
, 0);
8893 rtx op1
= frv_read_argument (call
, 1);
8895 if (! frv_check_constant_argument (icode
, 2, op1
))
8898 target
= frv_legitimize_target (icode
, target
);
8899 op0
= frv_legitimize_argument (icode
, 1, op0
);
8900 pat
= GEN_FCN (icode
) (target
, op0
, op1
);
8908 /* Expand builtins that take two operands, the first operand being a pointer to
8909 ints and return void. */
8912 frv_expand_voidbinop_builtin (enum insn_code icode
, tree call
)
8915 rtx op0
= frv_read_argument (call
, 0);
8916 rtx op1
= frv_read_argument (call
, 1);
8917 enum machine_mode mode0
= insn_data
[icode
].operand
[0].mode
;
8920 if (GET_CODE (op0
) != MEM
)
8924 if (! offsettable_address_p (0, mode0
, op0
))
8926 reg
= gen_reg_rtx (Pmode
);
8927 emit_insn (gen_rtx_SET (VOIDmode
, reg
, op0
));
8930 op0
= gen_rtx_MEM (SImode
, reg
);
8933 addr
= XEXP (op0
, 0);
8934 if (! offsettable_address_p (0, mode0
, addr
))
8935 addr
= copy_to_mode_reg (Pmode
, op0
);
8937 op0
= change_address (op0
, V4SImode
, addr
);
8938 op1
= frv_legitimize_argument (icode
, 1, op1
);
8939 pat
= GEN_FCN (icode
) (op0
, op1
);
8947 /* Expand builtins that take two long operands and return void. */
8950 frv_expand_int_void2arg (enum insn_code icode
, tree call
)
8953 rtx op0
= frv_read_argument (call
, 0);
8954 rtx op1
= frv_read_argument (call
, 1);
8956 op0
= frv_legitimize_argument (icode
, 1, op0
);
8957 op1
= frv_legitimize_argument (icode
, 1, op1
);
8958 pat
= GEN_FCN (icode
) (op0
, op1
);
8966 /* Expand prefetch builtins. These take a single address as argument. */
8969 frv_expand_prefetches (enum insn_code icode
, tree call
)
8972 rtx op0
= frv_read_argument (call
, 0);
8974 pat
= GEN_FCN (icode
) (force_reg (Pmode
, op0
));
8982 /* Expand builtins that take three operands and return void. The first
8983 argument must be a constant that describes a pair or quad accumulators. A
8984 fourth argument is created that is the accumulator guard register that
8985 corresponds to the accumulator. */
8988 frv_expand_voidtriop_builtin (enum insn_code icode
, tree call
)
8991 rtx op0
= frv_read_argument (call
, 0);
8992 rtx op1
= frv_read_argument (call
, 1);
8993 rtx op2
= frv_read_argument (call
, 2);
8996 op0
= frv_int_to_acc (icode
, 0, op0
);
9000 op1
= frv_legitimize_argument (icode
, 1, op1
);
9001 op2
= frv_legitimize_argument (icode
, 2, op2
);
9002 op3
= frv_matching_accg_for_acc (op0
);
9003 pat
= GEN_FCN (icode
) (op0
, op1
, op2
, op3
);
9011 /* Expand builtins that perform accumulator-to-accumulator operations.
9012 These builtins take two accumulator numbers as argument and return
9016 frv_expand_voidaccop_builtin (enum insn_code icode
, tree call
)
9019 rtx op0
= frv_read_argument (call
, 0);
9020 rtx op1
= frv_read_argument (call
, 1);
9024 op0
= frv_int_to_acc (icode
, 0, op0
);
9028 op1
= frv_int_to_acc (icode
, 1, op1
);
9032 op2
= frv_matching_accg_for_acc (op0
);
9033 op3
= frv_matching_accg_for_acc (op1
);
9034 pat
= GEN_FCN (icode
) (op0
, op1
, op2
, op3
);
9042 /* Expand a __builtin_read* function. ICODE is the instruction code for the
9043 membar and TARGET_MODE is the mode that the loaded value should have. */
9046 frv_expand_load_builtin (enum insn_code icode
, enum machine_mode target_mode
,
9047 tree call
, rtx target
)
9049 rtx op0
= frv_read_argument (call
, 0);
9050 rtx cookie
= frv_io_address_cookie (op0
);
9052 if (target
== 0 || !REG_P (target
))
9053 target
= gen_reg_rtx (target_mode
);
9054 op0
= frv_volatile_memref (insn_data
[icode
].operand
[0].mode
, op0
);
9055 convert_move (target
, op0
, 1);
9056 emit_insn (GEN_FCN (icode
) (copy_rtx (op0
), cookie
, GEN_INT (FRV_IO_READ
)));
9057 cfun
->machine
->has_membar_p
= 1;
9061 /* Likewise __builtin_write* functions. */
9064 frv_expand_store_builtin (enum insn_code icode
, tree call
)
9066 rtx op0
= frv_read_argument (call
, 0);
9067 rtx op1
= frv_read_argument (call
, 1);
9068 rtx cookie
= frv_io_address_cookie (op0
);
9070 op0
= frv_volatile_memref (insn_data
[icode
].operand
[0].mode
, op0
);
9071 convert_move (op0
, force_reg (insn_data
[icode
].operand
[0].mode
, op1
), 1);
9072 emit_insn (GEN_FCN (icode
) (copy_rtx (op0
), cookie
, GEN_INT (FRV_IO_WRITE
)));
9073 cfun
->machine
->has_membar_p
= 1;
9077 /* Expand the MDPACKH builtin. It takes four unsigned short arguments and
9078 each argument forms one word of the two double-word input registers.
9079 CALL is the tree for the call and TARGET, if nonnull, suggests a good place
9080 to put the return value. */
9083 frv_expand_mdpackh_builtin (tree call
, rtx target
)
9085 enum insn_code icode
= CODE_FOR_mdpackh
;
9087 rtx arg1
= frv_read_argument (call
, 0);
9088 rtx arg2
= frv_read_argument (call
, 1);
9089 rtx arg3
= frv_read_argument (call
, 2);
9090 rtx arg4
= frv_read_argument (call
, 3);
9092 target
= frv_legitimize_target (icode
, target
);
9093 op0
= gen_reg_rtx (DImode
);
9094 op1
= gen_reg_rtx (DImode
);
9096 /* The high half of each word is not explicitly initialized, so indicate
9097 that the input operands are not live before this point. */
9098 emit_insn (gen_rtx_CLOBBER (DImode
, op0
));
9099 emit_insn (gen_rtx_CLOBBER (DImode
, op1
));
9101 /* Move each argument into the low half of its associated input word. */
9102 emit_move_insn (simplify_gen_subreg (HImode
, op0
, DImode
, 2), arg1
);
9103 emit_move_insn (simplify_gen_subreg (HImode
, op0
, DImode
, 6), arg2
);
9104 emit_move_insn (simplify_gen_subreg (HImode
, op1
, DImode
, 2), arg3
);
9105 emit_move_insn (simplify_gen_subreg (HImode
, op1
, DImode
, 6), arg4
);
9107 pat
= GEN_FCN (icode
) (target
, op0
, op1
);
9115 /* Expand the MCLRACC builtin. This builtin takes a single accumulator
9116 number as argument. */
9119 frv_expand_mclracc_builtin (tree call
)
9121 enum insn_code icode
= CODE_FOR_mclracc
;
9123 rtx op0
= frv_read_argument (call
, 0);
9125 op0
= frv_int_to_acc (icode
, 0, op0
);
9129 pat
= GEN_FCN (icode
) (op0
);
9136 /* Expand builtins that take no arguments. */
9139 frv_expand_noargs_builtin (enum insn_code icode
)
9141 rtx pat
= GEN_FCN (icode
) (const0_rtx
);
9148 /* Expand MRDACC and MRDACCG. These builtins take a single accumulator
9149 number or accumulator guard number as argument and return an SI integer. */
9152 frv_expand_mrdacc_builtin (enum insn_code icode
, tree call
)
9155 rtx target
= gen_reg_rtx (SImode
);
9156 rtx op0
= frv_read_argument (call
, 0);
9158 op0
= frv_int_to_acc (icode
, 1, op0
);
9162 pat
= GEN_FCN (icode
) (target
, op0
);
9170 /* Expand MWTACC and MWTACCG. These builtins take an accumulator or
9171 accumulator guard as their first argument and an SImode value as their
9175 frv_expand_mwtacc_builtin (enum insn_code icode
, tree call
)
9178 rtx op0
= frv_read_argument (call
, 0);
9179 rtx op1
= frv_read_argument (call
, 1);
9181 op0
= frv_int_to_acc (icode
, 0, op0
);
9185 op1
= frv_legitimize_argument (icode
, 1, op1
);
9186 pat
= GEN_FCN (icode
) (op0
, op1
);
9193 /* Emit a move from SRC to DEST in SImode chunks. This can be used
9194 to move DImode values into and out of IACC0. */
9197 frv_split_iacc_move (rtx dest
, rtx src
)
9199 enum machine_mode inner
;
9202 inner
= GET_MODE (dest
);
9203 for (i
= 0; i
< GET_MODE_SIZE (inner
); i
+= GET_MODE_SIZE (SImode
))
9204 emit_move_insn (simplify_gen_subreg (SImode
, dest
, inner
, i
),
9205 simplify_gen_subreg (SImode
, src
, inner
, i
));
9208 /* Expand builtins. */
9211 frv_expand_builtin (tree exp
,
9213 rtx subtarget ATTRIBUTE_UNUSED
,
9214 enum machine_mode mode ATTRIBUTE_UNUSED
,
9215 int ignore ATTRIBUTE_UNUSED
)
9217 tree fndecl
= TREE_OPERAND (CALL_EXPR_FN (exp
), 0);
9218 unsigned fcode
= (unsigned)DECL_FUNCTION_CODE (fndecl
);
9220 struct builtin_description
*d
;
9222 if (fcode
< FRV_BUILTIN_FIRST_NONMEDIA
&& !TARGET_MEDIA
)
9224 error ("media functions are not available unless -mmedia is used");
9230 case FRV_BUILTIN_MCOP1
:
9231 case FRV_BUILTIN_MCOP2
:
9232 case FRV_BUILTIN_MDUNPACKH
:
9233 case FRV_BUILTIN_MBTOHE
:
9234 if (! TARGET_MEDIA_REV1
)
9236 error ("this media function is only available on the fr500");
9241 case FRV_BUILTIN_MQXMACHS
:
9242 case FRV_BUILTIN_MQXMACXHS
:
9243 case FRV_BUILTIN_MQMACXHS
:
9244 case FRV_BUILTIN_MADDACCS
:
9245 case FRV_BUILTIN_MSUBACCS
:
9246 case FRV_BUILTIN_MASACCS
:
9247 case FRV_BUILTIN_MDADDACCS
:
9248 case FRV_BUILTIN_MDSUBACCS
:
9249 case FRV_BUILTIN_MDASACCS
:
9250 case FRV_BUILTIN_MABSHS
:
9251 case FRV_BUILTIN_MDROTLI
:
9252 case FRV_BUILTIN_MCPLHI
:
9253 case FRV_BUILTIN_MCPLI
:
9254 case FRV_BUILTIN_MDCUTSSI
:
9255 case FRV_BUILTIN_MQSATHS
:
9256 case FRV_BUILTIN_MHSETLOS
:
9257 case FRV_BUILTIN_MHSETLOH
:
9258 case FRV_BUILTIN_MHSETHIS
:
9259 case FRV_BUILTIN_MHSETHIH
:
9260 case FRV_BUILTIN_MHDSETS
:
9261 case FRV_BUILTIN_MHDSETH
:
9262 if (! TARGET_MEDIA_REV2
)
9264 error ("this media function is only available on the fr400"
9270 case FRV_BUILTIN_SMASS
:
9271 case FRV_BUILTIN_SMSSS
:
9272 case FRV_BUILTIN_SMU
:
9273 case FRV_BUILTIN_ADDSS
:
9274 case FRV_BUILTIN_SUBSS
:
9275 case FRV_BUILTIN_SLASS
:
9276 case FRV_BUILTIN_SCUTSS
:
9277 case FRV_BUILTIN_IACCreadll
:
9278 case FRV_BUILTIN_IACCreadl
:
9279 case FRV_BUILTIN_IACCsetll
:
9280 case FRV_BUILTIN_IACCsetl
:
9281 if (!TARGET_FR405_BUILTINS
)
9283 error ("this builtin function is only available"
9284 " on the fr405 and fr450");
9289 case FRV_BUILTIN_PREFETCH
:
9290 if (!TARGET_FR500_FR550_BUILTINS
)
9292 error ("this builtin function is only available on the fr500"
9298 case FRV_BUILTIN_MQLCLRHS
:
9299 case FRV_BUILTIN_MQLMTHS
:
9300 case FRV_BUILTIN_MQSLLHI
:
9301 case FRV_BUILTIN_MQSRAHI
:
9302 if (!TARGET_MEDIA_FR450
)
9304 error ("this builtin function is only available on the fr450");
9313 /* Expand unique builtins. */
9317 case FRV_BUILTIN_MTRAP
:
9318 return frv_expand_noargs_builtin (CODE_FOR_mtrap
);
9320 case FRV_BUILTIN_MCLRACC
:
9321 return frv_expand_mclracc_builtin (exp
);
9323 case FRV_BUILTIN_MCLRACCA
:
9325 return frv_expand_noargs_builtin (CODE_FOR_mclracca8
);
9327 return frv_expand_noargs_builtin (CODE_FOR_mclracca4
);
9329 case FRV_BUILTIN_MRDACC
:
9330 return frv_expand_mrdacc_builtin (CODE_FOR_mrdacc
, exp
);
9332 case FRV_BUILTIN_MRDACCG
:
9333 return frv_expand_mrdacc_builtin (CODE_FOR_mrdaccg
, exp
);
9335 case FRV_BUILTIN_MWTACC
:
9336 return frv_expand_mwtacc_builtin (CODE_FOR_mwtacc
, exp
);
9338 case FRV_BUILTIN_MWTACCG
:
9339 return frv_expand_mwtacc_builtin (CODE_FOR_mwtaccg
, exp
);
9341 case FRV_BUILTIN_MDPACKH
:
9342 return frv_expand_mdpackh_builtin (exp
, target
);
9344 case FRV_BUILTIN_IACCreadll
:
9346 rtx src
= frv_read_iacc_argument (DImode
, exp
, 0);
9347 if (target
== 0 || !REG_P (target
))
9348 target
= gen_reg_rtx (DImode
);
9349 frv_split_iacc_move (target
, src
);
9353 case FRV_BUILTIN_IACCreadl
:
9354 return frv_read_iacc_argument (SImode
, exp
, 0);
9356 case FRV_BUILTIN_IACCsetll
:
9358 rtx dest
= frv_read_iacc_argument (DImode
, exp
, 0);
9359 rtx src
= frv_read_argument (exp
, 1);
9360 frv_split_iacc_move (dest
, force_reg (DImode
, src
));
9364 case FRV_BUILTIN_IACCsetl
:
9366 rtx dest
= frv_read_iacc_argument (SImode
, exp
, 0);
9367 rtx src
= frv_read_argument (exp
, 1);
9368 emit_move_insn (dest
, force_reg (SImode
, src
));
9376 /* Expand groups of builtins. */
9378 for (i
= 0, d
= bdesc_set
; i
< ARRAY_SIZE (bdesc_set
); i
++, d
++)
9379 if (d
->code
== fcode
)
9380 return frv_expand_set_builtin (d
->icode
, exp
, target
);
9382 for (i
= 0, d
= bdesc_1arg
; i
< ARRAY_SIZE (bdesc_1arg
); i
++, d
++)
9383 if (d
->code
== fcode
)
9384 return frv_expand_unop_builtin (d
->icode
, exp
, target
);
9386 for (i
= 0, d
= bdesc_2arg
; i
< ARRAY_SIZE (bdesc_2arg
); i
++, d
++)
9387 if (d
->code
== fcode
)
9388 return frv_expand_binop_builtin (d
->icode
, exp
, target
);
9390 for (i
= 0, d
= bdesc_cut
; i
< ARRAY_SIZE (bdesc_cut
); i
++, d
++)
9391 if (d
->code
== fcode
)
9392 return frv_expand_cut_builtin (d
->icode
, exp
, target
);
9394 for (i
= 0, d
= bdesc_2argimm
; i
< ARRAY_SIZE (bdesc_2argimm
); i
++, d
++)
9395 if (d
->code
== fcode
)
9396 return frv_expand_binopimm_builtin (d
->icode
, exp
, target
);
9398 for (i
= 0, d
= bdesc_void2arg
; i
< ARRAY_SIZE (bdesc_void2arg
); i
++, d
++)
9399 if (d
->code
== fcode
)
9400 return frv_expand_voidbinop_builtin (d
->icode
, exp
);
9402 for (i
= 0, d
= bdesc_void3arg
; i
< ARRAY_SIZE (bdesc_void3arg
); i
++, d
++)
9403 if (d
->code
== fcode
)
9404 return frv_expand_voidtriop_builtin (d
->icode
, exp
);
9406 for (i
= 0, d
= bdesc_voidacc
; i
< ARRAY_SIZE (bdesc_voidacc
); i
++, d
++)
9407 if (d
->code
== fcode
)
9408 return frv_expand_voidaccop_builtin (d
->icode
, exp
);
9410 for (i
= 0, d
= bdesc_int_void2arg
;
9411 i
< ARRAY_SIZE (bdesc_int_void2arg
); i
++, d
++)
9412 if (d
->code
== fcode
)
9413 return frv_expand_int_void2arg (d
->icode
, exp
);
9415 for (i
= 0, d
= bdesc_prefetches
;
9416 i
< ARRAY_SIZE (bdesc_prefetches
); i
++, d
++)
9417 if (d
->code
== fcode
)
9418 return frv_expand_prefetches (d
->icode
, exp
);
9420 for (i
= 0, d
= bdesc_loads
; i
< ARRAY_SIZE (bdesc_loads
); i
++, d
++)
9421 if (d
->code
== fcode
)
9422 return frv_expand_load_builtin (d
->icode
, TYPE_MODE (TREE_TYPE (exp
)),
9425 for (i
= 0, d
= bdesc_stores
; i
< ARRAY_SIZE (bdesc_stores
); i
++, d
++)
9426 if (d
->code
== fcode
)
9427 return frv_expand_store_builtin (d
->icode
, exp
);
9433 frv_in_small_data_p (tree decl
)
9438 /* Don't apply the -G flag to internal compiler structures. We
9439 should leave such structures in the main data section, partly
9440 for efficiency and partly because the size of some of them
9441 (such as C++ typeinfos) is not known until later. */
9442 if (TREE_CODE (decl
) != VAR_DECL
|| DECL_ARTIFICIAL (decl
))
9445 /* If we already know which section the decl should be in, see if
9446 it's a small data section. */
9447 section_name
= DECL_SECTION_NAME (decl
);
9450 gcc_assert (TREE_CODE (section_name
) == STRING_CST
);
9451 if (frv_string_begins_with (section_name
, ".sdata"))
9453 if (frv_string_begins_with (section_name
, ".sbss"))
9458 size
= int_size_in_bytes (TREE_TYPE (decl
));
9459 if (size
> 0 && (unsigned HOST_WIDE_INT
) size
<= g_switch_value
)
9466 frv_rtx_costs (rtx x
,
9467 int code ATTRIBUTE_UNUSED
,
9468 int outer_code ATTRIBUTE_UNUSED
,
9471 if (outer_code
== MEM
)
9473 /* Don't differentiate between memory addresses. All the ones
9474 we accept have equal cost. */
9475 *total
= COSTS_N_INSNS (0);
9482 /* Make 12-bit integers really cheap. */
9483 if (IN_RANGE_P (INTVAL (x
), -2048, 2047))
9494 *total
= COSTS_N_INSNS (2);
9508 if (GET_MODE (x
) == SImode
)
9509 *total
= COSTS_N_INSNS (1);
9510 else if (GET_MODE (x
) == DImode
)
9511 *total
= COSTS_N_INSNS (2);
9513 *total
= COSTS_N_INSNS (3);
9517 if (GET_MODE (x
) == SImode
)
9518 *total
= COSTS_N_INSNS (2);
9520 *total
= COSTS_N_INSNS (6); /* guess */
9527 *total
= COSTS_N_INSNS (18);
9531 *total
= COSTS_N_INSNS (3);
9540 frv_asm_out_constructor (rtx symbol
, int priority ATTRIBUTE_UNUSED
)
9542 switch_to_section (ctors_section
);
9543 assemble_align (POINTER_SIZE
);
9546 int ok
= frv_assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, 1);
9551 assemble_integer_with_op ("\t.picptr\t", symbol
);
9555 frv_asm_out_destructor (rtx symbol
, int priority ATTRIBUTE_UNUSED
)
9557 switch_to_section (dtors_section
);
9558 assemble_align (POINTER_SIZE
);
9561 int ok
= frv_assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, 1);
9566 assemble_integer_with_op ("\t.picptr\t", symbol
);
9569 /* Worker function for TARGET_STRUCT_VALUE_RTX. */
9572 frv_struct_value_rtx (tree fntype ATTRIBUTE_UNUSED
,
9573 int incoming ATTRIBUTE_UNUSED
)
9575 return gen_rtx_REG (Pmode
, FRV_STRUCT_VALUE_REGNUM
);
9578 #define TLS_BIAS (2048 - 16)
9580 /* This is called from dwarf2out.c via TARGET_ASM_OUTPUT_DWARF_DTPREL.
9581 We need to emit DTP-relative relocations. */
9584 frv_output_dwarf_dtprel (FILE *file
, int size
, rtx x
)
9586 gcc_assert (size
== 4);
9587 fputs ("\t.picptr\ttlsmoff(", file
);
9588 /* We want the unbiased TLS offset, so add the bias to the
9589 expression, such that the implicit biasing cancels out. */
9590 output_addr_const (file
, plus_constant (x
, TLS_BIAS
));