gcc/config/frv/frv.c

   1 /* Copyright (C) 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007,
   2    2008, 2009  Free Software Foundation, Inc.
   3    Contributed by Red Hat, Inc.
   4
   5 This file is part of GCC.
   6
   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)
  10 any later version.
  11
  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.
  16
  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/>.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "tm.h"
  25 #include "rtl.h"
  26 #include "tree.h"
  27 #include "regs.h"
  28 #include "hard-reg-set.h"
  29 #include "insn-config.h"
  30 #include "conditions.h"
  31 #include "insn-flags.h"
  32 #include "output.h"
  33 #include "insn-attr.h"
  34 #include "flags.h"
  35 #include "recog.h"
  36 #include "reload.h"
  37 #include "expr.h"
  38 #include "obstack.h"
  39 #include "except.h"
  40 #include "function.h"
  41 #include "optabs.h"
  42 #include "toplev.h"
  43 #include "basic-block.h"
  44 #include "tm_p.h"
  45 #include "ggc.h"
  46 #include <ctype.h>
  47 #include "target.h"
  48 #include "target-def.h"
  49 #include "targhooks.h"
  50 #include "integrate.h"
  51 #include "langhooks.h"
  52 #include "df.h"
  53
  54 #ifndef FRV_INLINE
  55 #define FRV_INLINE inline
  56 #endif
  57
  58 /* The maximum number of distinct NOP patterns.  There are three:
  59    nop, fnop and mnop.  */
  60 #define NUM_NOP_PATTERNS 3
  61
  62 /* Classification of instructions and units: integer, floating-point/media,
  63    branch and control.  */
  64 enum frv_insn_group { GROUP_I, GROUP_FM, GROUP_B, GROUP_C, NUM_GROUPS };
  65
  66 /* The DFA names of the units, in packet order.  */
  67 static const char *const frv_unit_names[] =
  68 {
  69   "c",
  70   "i0", "f0",
  71   "i1", "f1",
  72   "i2", "f2",
  73   "i3", "f3",
  74   "b0", "b1"
  75 };
  76
  77 /* The classification of each unit in frv_unit_names[].  */
  78 static const enum frv_insn_group frv_unit_groups[ARRAY_SIZE (frv_unit_names)] =
  79 {
  80   GROUP_C,
  81   GROUP_I, GROUP_FM,
  82   GROUP_I, GROUP_FM,
  83   GROUP_I, GROUP_FM,
  84   GROUP_I, GROUP_FM,
  85   GROUP_B, GROUP_B
  86 };
  87
  88 /* Return the DFA unit code associated with the Nth unit of integer
  89    or floating-point group GROUP,  */
  90 #define NTH_UNIT(GROUP, N) frv_unit_codes[(GROUP) + (N) * 2 + 1]
  91
  92 /* Return the number of integer or floating-point unit UNIT
  93    (1 for I1, 2 for F2, etc.).  */
  94 #define UNIT_NUMBER(UNIT) (((UNIT) - 1) / 2)
  95
  96 /* The DFA unit number for each unit in frv_unit_names[].  */
  97 static int frv_unit_codes[ARRAY_SIZE (frv_unit_names)];
  98
  99 /* FRV_TYPE_TO_UNIT[T] is the last unit in frv_unit_names[] that can issue
 100    an instruction of type T.  The value is ARRAY_SIZE (frv_unit_names) if
 101    no instruction of type T has been seen.  */
 102 static unsigned int frv_type_to_unit[TYPE_UNKNOWN + 1];
 103
 104 /* An array of dummy nop INSNs, one for each type of nop that the
 105    target supports.  */
 106 static GTY(()) rtx frv_nops[NUM_NOP_PATTERNS];
 107
 108 /* The number of nop instructions in frv_nops[].  */
 109 static unsigned int frv_num_nops;
 110
 111 /* Information about one __builtin_read or __builtin_write access, or
 112    the combination of several such accesses.  The most general value
 113    is all-zeros (an unknown access to an unknown address).  */
 114 struct frv_io {
 115   /* The type of access.  FRV_IO_UNKNOWN means the access can be either
 116      a read or a write.  */
 117   enum { FRV_IO_UNKNOWN, FRV_IO_READ, FRV_IO_WRITE } type;
 118
 119   /* The constant address being accessed, or zero if not known.  */
 120   HOST_WIDE_INT const_address;
 121
 122   /* The run-time address, as used in operand 0 of the membar pattern.  */
 123   rtx var_address;
 124 };
 125
 126 /* Return true if instruction INSN should be packed with the following
 127    instruction.  */
 128 #define PACKING_FLAG_P(INSN) (GET_MODE (INSN) == TImode)
 129
 130 /* Set the value of PACKING_FLAG_P(INSN).  */
 131 #define SET_PACKING_FLAG(INSN) PUT_MODE (INSN, TImode)
 132 #define CLEAR_PACKING_FLAG(INSN) PUT_MODE (INSN, VOIDmode)
 133
 134 /* Loop with REG set to each hard register in rtx X.  */
 135 #define FOR_EACH_REGNO(REG, X)                                          \
 136   for (REG = REGNO (X);                                                 \
 137        REG < REGNO (X) + HARD_REGNO_NREGS (REGNO (X), GET_MODE (X));    \
 138        REG++)
 139
 140 /* This structure contains machine specific function data.  */
 141 struct GTY(()) machine_function
 142 {
 143   /* True if we have created an rtx that relies on the stack frame.  */
 144   int frame_needed;
 145
 146   /* True if this function contains at least one __builtin_{read,write}*.  */
 147   bool has_membar_p;
 148 };
 149
 150 /* Temporary register allocation support structure.  */
 151 typedef struct frv_tmp_reg_struct
 152   {
 153     HARD_REG_SET regs;          /* possible registers to allocate */
 154     int next_reg[N_REG_CLASSES];        /* next register to allocate per class */
 155   }
 156 frv_tmp_reg_t;
 157
 158 /* Register state information for VLIW re-packing phase.  */
 159 #define REGSTATE_CC_MASK        0x07    /* Mask to isolate CCn for cond exec */
 160 #define REGSTATE_MODIFIED       0x08    /* reg modified in current VLIW insn */
 161 #define REGSTATE_IF_TRUE        0x10    /* reg modified in cond exec true */
 162 #define REGSTATE_IF_FALSE       0x20    /* reg modified in cond exec false */
 163
 164 #define REGSTATE_IF_EITHER      (REGSTATE_IF_TRUE | REGSTATE_IF_FALSE)
 165
 166 typedef unsigned char regstate_t;
 167
 168 /* Used in frv_frame_accessor_t to indicate the direction of a register-to-
 169    memory move.  */
 170 enum frv_stack_op
 171 {
 172   FRV_LOAD,
 173   FRV_STORE
 174 };
 175
 176 /* Information required by frv_frame_access.  */
 177 typedef struct
 178 {
 179   /* This field is FRV_LOAD if registers are to be loaded from the stack and
 180      FRV_STORE if they should be stored onto the stack.  FRV_STORE implies
 181      the move is being done by the prologue code while FRV_LOAD implies it
 182      is being done by the epilogue.  */
 183   enum frv_stack_op op;
 184
 185   /* The base register to use when accessing the stack.  This may be the
 186      frame pointer, stack pointer, or a temporary.  The choice of register
 187      depends on which part of the frame is being accessed and how big the
 188      frame is.  */
 189   rtx base;
 190
 191   /* The offset of BASE from the bottom of the current frame, in bytes.  */
 192   int base_offset;
 193 } frv_frame_accessor_t;
 194
 195 /* Conditional execution support gathered together in one structure.  */
 196 typedef struct
 197   {
 198     /* Linked list of insns to add if the conditional execution conversion was
 199        successful.  Each link points to an EXPR_LIST which points to the pattern
 200        of the insn to add, and the insn to be inserted before.  */
 201     rtx added_insns_list;
 202
 203     /* Identify which registers are safe to allocate for if conversions to
 204        conditional execution.  We keep the last allocated register in the
 205        register classes between COND_EXEC statements.  This will mean we allocate
 206        different registers for each different COND_EXEC group if we can.  This
 207        might allow the scheduler to intermix two different COND_EXEC sections.  */
 208     frv_tmp_reg_t tmp_reg;
 209
 210     /* For nested IFs, identify which CC registers are used outside of setting
 211        via a compare isnsn, and using via a check insn.  This will allow us to
 212        know if we can rewrite the register to use a different register that will
 213        be paired with the CR register controlling the nested IF-THEN blocks.  */
 214     HARD_REG_SET nested_cc_ok_rewrite;
 215
 216     /* Temporary registers allocated to hold constants during conditional
 217        execution.  */
 218     rtx scratch_regs[FIRST_PSEUDO_REGISTER];
 219
 220     /* Current number of temp registers available.  */
 221     int cur_scratch_regs;
 222
 223     /* Number of nested conditional execution blocks.  */
 224     int num_nested_cond_exec;
 225
 226     /* Map of insns that set up constants in scratch registers.  */
 227     bitmap scratch_insns_bitmap;
 228
 229     /* Conditional execution test register (CC0..CC7).  */
 230     rtx cr_reg;
 231
 232     /* Conditional execution compare register that is paired with cr_reg, so that
 233        nested compares can be done.  The csubcc and caddcc instructions don't
 234        have enough bits to specify both a CC register to be set and a CR register
 235        to do the test on, so the same bit number is used for both.  Needless to
 236        say, this is rather inconvenient for GCC.  */
 237     rtx nested_cc_reg;
 238
 239     /* Extra CR registers used for &&, ||.  */
 240     rtx extra_int_cr;
 241     rtx extra_fp_cr;
 242
 243     /* Previous CR used in nested if, to make sure we are dealing with the same
 244        nested if as the previous statement.  */
 245     rtx last_nested_if_cr;
 246   }
 247 frv_ifcvt_t;
 248
 249 static /* GTY(()) */ frv_ifcvt_t frv_ifcvt;
 250
 251 /* Map register number to smallest register class.  */
 252 enum reg_class regno_reg_class[FIRST_PSEUDO_REGISTER];
 253
 254 /* Map class letter into register class.  */
 255 enum reg_class reg_class_from_letter[256];
 256
 257 /* Cached value of frv_stack_info.  */
 258 static frv_stack_t *frv_stack_cache = (frv_stack_t *)0;
 259
 260 /* -mcpu= support */
 261 frv_cpu_t frv_cpu_type = CPU_TYPE;      /* value of -mcpu= */
 262
 263 /* Forward references */
 264
 265 static bool frv_handle_option                   (size_t, const char *, int);
 266 static bool frv_legitimate_address_p            (enum machine_mode, rtx, bool);
 267 static int frv_default_flags_for_cpu            (void);
 268 static int frv_string_begins_with               (const_tree, const char *);
 269 static FRV_INLINE bool frv_small_data_reloc_p   (rtx, int);
 270 static void frv_print_operand                   (FILE *, rtx, int);
 271 static void frv_print_operand_address           (FILE *, rtx);
 272 static bool frv_print_operand_punct_valid_p     (unsigned char code);
 273 static void frv_print_operand_memory_reference_reg
 274                                                 (FILE *, rtx);
 275 static void frv_print_operand_memory_reference  (FILE *, rtx, int);
 276 static int frv_print_operand_jump_hint          (rtx);
 277 static const char *comparison_string            (enum rtx_code, rtx);
 278 static rtx frv_function_value                   (const_tree, const_tree,
 279                                                  bool);
 280 static rtx frv_libcall_value                    (enum machine_mode,
 281                                                  const_rtx);
 282 static FRV_INLINE int frv_regno_ok_for_base_p   (int, int);
 283 static rtx single_set_pattern                   (rtx);
 284 static int frv_function_contains_far_jump       (void);
 285 static rtx frv_alloc_temp_reg                   (frv_tmp_reg_t *,
 286                                                  enum reg_class,
 287                                                  enum machine_mode,
 288                                                  int, int);
 289 static rtx frv_frame_offset_rtx                 (int);
 290 static rtx frv_frame_mem                        (enum machine_mode, rtx, int);
 291 static rtx frv_dwarf_store                      (rtx, int);
 292 static void frv_frame_insn                      (rtx, rtx);
 293 static void frv_frame_access                    (frv_frame_accessor_t*,
 294                                                  rtx, int);
 295 static void frv_frame_access_multi              (frv_frame_accessor_t*,
 296                                                  frv_stack_t *, int);
 297 static void frv_frame_access_standard_regs      (enum frv_stack_op,
 298                                                  frv_stack_t *);
 299 static struct machine_function *frv_init_machine_status         (void);
 300 static rtx frv_int_to_acc                       (enum insn_code, int, rtx);
 301 static enum machine_mode frv_matching_accg_mode (enum machine_mode);
 302 static rtx frv_read_argument                    (tree, unsigned int);
 303 static rtx frv_read_iacc_argument               (enum machine_mode, tree, unsigned int);
 304 static int frv_check_constant_argument          (enum insn_code, int, rtx);
 305 static rtx frv_legitimize_target                (enum insn_code, rtx);
 306 static rtx frv_legitimize_argument              (enum insn_code, int, rtx);
 307 static rtx frv_legitimize_tls_address           (rtx, enum tls_model);
 308 static rtx frv_legitimize_address               (rtx, rtx, enum machine_mode);
 309 static rtx frv_expand_set_builtin               (enum insn_code, tree, rtx);
 310 static rtx frv_expand_unop_builtin              (enum insn_code, tree, rtx);
 311 static rtx frv_expand_binop_builtin             (enum insn_code, tree, rtx);
 312 static rtx frv_expand_cut_builtin               (enum insn_code, tree, rtx);
 313 static rtx frv_expand_binopimm_builtin          (enum insn_code, tree, rtx);
 314 static rtx frv_expand_voidbinop_builtin         (enum insn_code, tree);
 315 static rtx frv_expand_int_void2arg              (enum insn_code, tree);
 316 static rtx frv_expand_prefetches                (enum insn_code, tree);
 317 static rtx frv_expand_voidtriop_builtin         (enum insn_code, tree);
 318 static rtx frv_expand_voidaccop_builtin         (enum insn_code, tree);
 319 static rtx frv_expand_mclracc_builtin           (tree);
 320 static rtx frv_expand_mrdacc_builtin            (enum insn_code, tree);
 321 static rtx frv_expand_mwtacc_builtin            (enum insn_code, tree);
 322 static rtx frv_expand_noargs_builtin            (enum insn_code);
 323 static void frv_split_iacc_move                 (rtx, rtx);
 324 static rtx frv_emit_comparison                  (enum rtx_code, rtx, rtx);
 325 static int frv_clear_registers_used             (rtx *, void *);
 326 static void frv_ifcvt_add_insn                  (rtx, rtx, int);
 327 static rtx frv_ifcvt_rewrite_mem                (rtx, enum machine_mode, rtx);
 328 static rtx frv_ifcvt_load_value                 (rtx, rtx);
 329 static int frv_acc_group_1                      (rtx *, void *);
 330 static unsigned int frv_insn_unit               (rtx);
 331 static bool frv_issues_to_branch_unit_p         (rtx);
 332 static int frv_cond_flags                       (rtx);
 333 static bool frv_regstate_conflict_p             (regstate_t, regstate_t);
 334 static int frv_registers_conflict_p_1           (rtx *, void *);
 335 static bool frv_registers_conflict_p            (rtx);
 336 static void frv_registers_update_1              (rtx, const_rtx, void *);
 337 static void frv_registers_update                (rtx);
 338 static void frv_start_packet                    (void);
 339 static void frv_start_packet_block              (void);
 340 static void frv_finish_packet                   (void (*) (void));
 341 static bool frv_pack_insn_p                     (rtx);
 342 static void frv_add_insn_to_packet              (rtx);
 343 static void frv_insert_nop_in_packet            (rtx);
 344 static bool frv_for_each_packet                 (void (*) (void));
 345 static bool frv_sort_insn_group_1               (enum frv_insn_group,
 346                                                  unsigned int, unsigned int,
 347                                                  unsigned int, unsigned int,
 348                                                  state_t);
 349 static int frv_compare_insns                    (const void *, const void *);
 350 static void frv_sort_insn_group                 (enum frv_insn_group);
 351 static void frv_reorder_packet                  (void);
 352 static void frv_fill_unused_units               (enum frv_insn_group);
 353 static void frv_align_label                     (void);
 354 static void frv_reorg_packet                    (void);
 355 static void frv_register_nop                    (rtx);
 356 static void frv_reorg                           (void);
 357 static void frv_pack_insns                      (void);
 358 static void frv_function_prologue               (FILE *, HOST_WIDE_INT);
 359 static void frv_function_epilogue               (FILE *, HOST_WIDE_INT);
 360 static bool frv_assemble_integer                (rtx, unsigned, int);
 361 static void frv_init_builtins                   (void);
 362 static rtx frv_expand_builtin                   (tree, rtx, rtx, enum machine_mode, int);
 363 static void frv_init_libfuncs                   (void);
 364 static bool frv_in_small_data_p                 (const_tree);
 365 static void frv_asm_output_mi_thunk
 366   (FILE *, tree, HOST_WIDE_INT, HOST_WIDE_INT, tree);
 367 static void frv_setup_incoming_varargs          (CUMULATIVE_ARGS *,
 368                                                  enum machine_mode,
 369                                                  tree, int *, int);
 370 static rtx frv_expand_builtin_saveregs          (void);
 371 static void frv_expand_builtin_va_start         (tree, rtx);
 372 static bool frv_rtx_costs                       (rtx, int, int, int*, bool);
 373 static void frv_asm_out_constructor             (rtx, int);
 374 static void frv_asm_out_destructor              (rtx, int);
 375 static bool frv_function_symbol_referenced_p    (rtx);
 376 static bool frv_cannot_force_const_mem          (rtx);
 377 static const char *unspec_got_name              (int);
 378 static void frv_output_const_unspec             (FILE *,
 379                                                  const struct frv_unspec *);
 380 static bool frv_function_ok_for_sibcall         (tree, tree);
 381 static rtx frv_struct_value_rtx                 (tree, int);
 382 static bool frv_must_pass_in_stack (enum machine_mode mode, const_tree type);
 383 static int frv_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode,
 384                                   tree, bool);
 385 static void frv_output_dwarf_dtprel             (FILE *, int, rtx)
 386   ATTRIBUTE_UNUSED;
 387 static bool frv_secondary_reload                (bool, rtx, enum reg_class,
 388                                                  enum machine_mode,
 389                                                  secondary_reload_info *);
 390 static bool frv_frame_pointer_required          (void);
 391 static bool frv_can_eliminate                   (const int, const int);
 392 static void frv_trampoline_init                 (rtx, tree, rtx);
 393 \f
 394 /* Allow us to easily change the default for -malloc-cc.  */
 395 #ifndef DEFAULT_NO_ALLOC_CC
 396 #define MASK_DEFAULT_ALLOC_CC   MASK_ALLOC_CC
 397 #else
 398 #define MASK_DEFAULT_ALLOC_CC   0
 399 #endif
 400 \f
 401 /* Initialize the GCC target structure.  */
 402 #undef TARGET_PRINT_OPERAND
 403 #define TARGET_PRINT_OPERAND frv_print_operand
 404 #undef TARGET_PRINT_OPERAND_ADDRESS
 405 #define TARGET_PRINT_OPERAND_ADDRESS frv_print_operand_address
 406 #undef TARGET_PRINT_OPERAND_PUNCT_VALID_P
 407 #define TARGET_PRINT_OPERAND_PUNCT_VALID_P frv_print_operand_punct_valid_p
 408 #undef  TARGET_ASM_FUNCTION_PROLOGUE
 409 #define TARGET_ASM_FUNCTION_PROLOGUE frv_function_prologue
 410 #undef  TARGET_ASM_FUNCTION_EPILOGUE
 411 #define TARGET_ASM_FUNCTION_EPILOGUE frv_function_epilogue
 412 #undef  TARGET_ASM_INTEGER
 413 #define TARGET_ASM_INTEGER frv_assemble_integer
 414 #undef TARGET_DEFAULT_TARGET_FLAGS
 415 #define TARGET_DEFAULT_TARGET_FLAGS             \
 416   (MASK_DEFAULT_ALLOC_CC                        \
 417    | MASK_COND_MOVE                             \
 418    | MASK_SCC                                   \
 419    | MASK_COND_EXEC                             \
 420    | MASK_VLIW_BRANCH                           \
 421    | MASK_MULTI_CE                              \
 422    | MASK_NESTED_CE)
 423 #undef TARGET_HANDLE_OPTION
 424 #define TARGET_HANDLE_OPTION frv_handle_option
 425 #undef TARGET_INIT_BUILTINS
 426 #define TARGET_INIT_BUILTINS frv_init_builtins
 427 #undef TARGET_EXPAND_BUILTIN
 428 #define TARGET_EXPAND_BUILTIN frv_expand_builtin
 429 #undef TARGET_INIT_LIBFUNCS
 430 #define TARGET_INIT_LIBFUNCS frv_init_libfuncs
 431 #undef TARGET_IN_SMALL_DATA_P
 432 #define TARGET_IN_SMALL_DATA_P frv_in_small_data_p
 433 #undef TARGET_RTX_COSTS
 434 #define TARGET_RTX_COSTS frv_rtx_costs
 435 #undef TARGET_ASM_CONSTRUCTOR
 436 #define TARGET_ASM_CONSTRUCTOR frv_asm_out_constructor
 437 #undef TARGET_ASM_DESTRUCTOR
 438 #define TARGET_ASM_DESTRUCTOR frv_asm_out_destructor
 439
 440 #undef TARGET_ASM_OUTPUT_MI_THUNK
 441 #define TARGET_ASM_OUTPUT_MI_THUNK frv_asm_output_mi_thunk
 442 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
 443 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK default_can_output_mi_thunk_no_vcall
 444
 445 #undef  TARGET_SCHED_ISSUE_RATE
 446 #define TARGET_SCHED_ISSUE_RATE frv_issue_rate
 447
 448 #undef TARGET_LEGITIMIZE_ADDRESS
 449 #define TARGET_LEGITIMIZE_ADDRESS frv_legitimize_address
 450
 451 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
 452 #define TARGET_FUNCTION_OK_FOR_SIBCALL frv_function_ok_for_sibcall
 453 #undef TARGET_CANNOT_FORCE_CONST_MEM
 454 #define TARGET_CANNOT_FORCE_CONST_MEM frv_cannot_force_const_mem
 455
 456 #undef TARGET_HAVE_TLS
 457 #define TARGET_HAVE_TLS HAVE_AS_TLS
 458
 459 #undef TARGET_STRUCT_VALUE_RTX
 460 #define TARGET_STRUCT_VALUE_RTX frv_struct_value_rtx
 461 #undef TARGET_MUST_PASS_IN_STACK
 462 #define TARGET_MUST_PASS_IN_STACK frv_must_pass_in_stack
 463 #undef TARGET_PASS_BY_REFERENCE
 464 #define TARGET_PASS_BY_REFERENCE hook_pass_by_reference_must_pass_in_stack
 465 #undef TARGET_ARG_PARTIAL_BYTES
 466 #define TARGET_ARG_PARTIAL_BYTES frv_arg_partial_bytes
 467
 468 #undef TARGET_EXPAND_BUILTIN_SAVEREGS
 469 #define TARGET_EXPAND_BUILTIN_SAVEREGS frv_expand_builtin_saveregs
 470 #undef TARGET_SETUP_INCOMING_VARARGS
 471 #define TARGET_SETUP_INCOMING_VARARGS frv_setup_incoming_varargs
 472 #undef TARGET_MACHINE_DEPENDENT_REORG
 473 #define TARGET_MACHINE_DEPENDENT_REORG frv_reorg
 474
 475 #undef TARGET_EXPAND_BUILTIN_VA_START
 476 #define TARGET_EXPAND_BUILTIN_VA_START frv_expand_builtin_va_start
 477
 478 #if HAVE_AS_TLS
 479 #undef TARGET_ASM_OUTPUT_DWARF_DTPREL
 480 #define TARGET_ASM_OUTPUT_DWARF_DTPREL frv_output_dwarf_dtprel
 481 #endif
 482
 483 #undef  TARGET_SECONDARY_RELOAD
 484 #define TARGET_SECONDARY_RELOAD frv_secondary_reload
 485
 486 #undef TARGET_LEGITIMATE_ADDRESS_P
 487 #define TARGET_LEGITIMATE_ADDRESS_P frv_legitimate_address_p
 488
 489 #undef TARGET_FRAME_POINTER_REQUIRED
 490 #define TARGET_FRAME_POINTER_REQUIRED frv_frame_pointer_required
 491
 492 #undef TARGET_CAN_ELIMINATE
 493 #define TARGET_CAN_ELIMINATE frv_can_eliminate
 494
 495 #undef TARGET_TRAMPOLINE_INIT
 496 #define TARGET_TRAMPOLINE_INIT frv_trampoline_init
 497
 498 #undef TARGET_FUNCTION_VALUE
 499 #define TARGET_FUNCTION_VALUE frv_function_value
 500 #undef TARGET_LIBCALL_VALUE
 501 #define TARGET_LIBCALL_VALUE frv_libcall_value
 502
 503 struct gcc_target targetm = TARGET_INITIALIZER;
 504
 505 #define FRV_SYMBOL_REF_TLS_P(RTX) \
 506   (GET_CODE (RTX) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (RTX) != 0)
 507
 508 \f
 509 /* Any function call that satisfies the machine-independent
 510    requirements is eligible on FR-V.  */
 511
 512 static bool
 513 frv_function_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED,
 514                              tree exp ATTRIBUTE_UNUSED)
 515 {
 516   return true;
 517 }
 518
 519 /* Return true if SYMBOL is a small data symbol and relocation RELOC
 520    can be used to access it directly in a load or store.  */
 521
 522 static FRV_INLINE bool
 523 frv_small_data_reloc_p (rtx symbol, int reloc)
 524 {
 525   return (GET_CODE (symbol) == SYMBOL_REF
 526           && SYMBOL_REF_SMALL_P (symbol)
 527           && (!TARGET_FDPIC || flag_pic == 1)
 528           && (reloc == R_FRV_GOTOFF12 || reloc == R_FRV_GPREL12));
 529 }
 530
 531 /* Return true if X is a valid relocation unspec.  If it is, fill in UNSPEC
 532    appropriately.  */
 533
 534 bool
 535 frv_const_unspec_p (rtx x, struct frv_unspec *unspec)
 536 {
 537   if (GET_CODE (x) == CONST)
 538     {
 539       unspec->offset = 0;
 540       x = XEXP (x, 0);
 541       if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == CONST_INT)
 542         {
 543           unspec->offset += INTVAL (XEXP (x, 1));
 544           x = XEXP (x, 0);
 545         }
 546       if (GET_CODE (x) == UNSPEC && XINT (x, 1) == UNSPEC_GOT)
 547         {
 548           unspec->symbol = XVECEXP (x, 0, 0);
 549           unspec->reloc = INTVAL (XVECEXP (x, 0, 1));
 550
 551           if (unspec->offset == 0)
 552             return true;
 553
 554           if (frv_small_data_reloc_p (unspec->symbol, unspec->reloc)
 555               && unspec->offset > 0
 556               && (unsigned HOST_WIDE_INT) unspec->offset < g_switch_value)
 557             return true;
 558         }
 559     }
 560   return false;
 561 }
 562
 563 /* Decide whether we can force certain constants to memory.  If we
 564    decide we can't, the caller should be able to cope with it in
 565    another way.
 566
 567    We never allow constants to be forced into memory for TARGET_FDPIC.
 568    This is necessary for several reasons:
 569
 570    1. Since LEGITIMATE_CONSTANT_P rejects constant pool addresses, the
 571       target-independent code will try to force them into the constant
 572       pool, thus leading to infinite recursion.
 573
 574    2. We can never introduce new constant pool references during reload.
 575       Any such reference would require use of the pseudo FDPIC register.
 576
 577    3. We can't represent a constant added to a function pointer (which is
 578       not the same as a pointer to a function+constant).
 579
 580    4. In many cases, it's more efficient to calculate the constant in-line.  */
 581
 582 static bool
 583 frv_cannot_force_const_mem (rtx x ATTRIBUTE_UNUSED)
 584 {
 585   return TARGET_FDPIC;
 586 }
 587 \f
 588 /* Implement TARGET_HANDLE_OPTION.  */
 589
 590 static bool
 591 frv_handle_option (size_t code, const char *arg, int value ATTRIBUTE_UNUSED)
 592 {
 593   switch (code)
 594     {
 595     case OPT_mcpu_:
 596       if (strcmp (arg, "simple") == 0)
 597         frv_cpu_type = FRV_CPU_SIMPLE;
 598       else if (strcmp (arg, "tomcat") == 0)
 599         frv_cpu_type = FRV_CPU_TOMCAT;
 600       else if (strcmp (arg, "fr550") == 0)
 601         frv_cpu_type = FRV_CPU_FR550;
 602       else if (strcmp (arg, "fr500") == 0)
 603         frv_cpu_type = FRV_CPU_FR500;
 604       else if (strcmp (arg, "fr450") == 0)
 605         frv_cpu_type = FRV_CPU_FR450;
 606       else if (strcmp (arg, "fr405") == 0)
 607         frv_cpu_type = FRV_CPU_FR405;
 608       else if (strcmp (arg, "fr400") == 0)
 609         frv_cpu_type = FRV_CPU_FR400;
 610       else if (strcmp (arg, "fr300") == 0)
 611         frv_cpu_type = FRV_CPU_FR300;
 612       else if (strcmp (arg, "frv") == 0)
 613         frv_cpu_type = FRV_CPU_GENERIC;
 614       else
 615         return false;
 616       return true;
 617
 618     default:
 619       return true;
 620     }
 621 }
 622
 623 static int
 624 frv_default_flags_for_cpu (void)
 625 {
 626   switch (frv_cpu_type)
 627     {
 628     case FRV_CPU_GENERIC:
 629       return MASK_DEFAULT_FRV;
 630
 631     case FRV_CPU_FR550:
 632       return MASK_DEFAULT_FR550;
 633
 634     case FRV_CPU_FR500:
 635     case FRV_CPU_TOMCAT:
 636       return MASK_DEFAULT_FR500;
 637
 638     case FRV_CPU_FR450:
 639       return MASK_DEFAULT_FR450;
 640
 641     case FRV_CPU_FR405:
 642     case FRV_CPU_FR400:
 643       return MASK_DEFAULT_FR400;
 644
 645     case FRV_CPU_FR300:
 646     case FRV_CPU_SIMPLE:
 647       return MASK_DEFAULT_SIMPLE;
 648
 649     default:
 650       gcc_unreachable ();
 651     }
 652 }
 653
 654 /* Sometimes certain combinations of command options do not make
 655    sense on a particular target machine.  You can define a macro
 656    `OVERRIDE_OPTIONS' to take account of this.  This macro, if
 657    defined, is executed once just after all the command options have
 658    been parsed.
 659
 660    Don't use this macro to turn on various extra optimizations for
 661    `-O'.  That is what `OPTIMIZATION_OPTIONS' is for.  */
 662
 663 void
 664 frv_override_options (void)
 665 {
 666   int regno;
 667   unsigned int i;
 668
 669   target_flags |= (frv_default_flags_for_cpu () & ~target_flags_explicit);
 670
 671   /* -mlibrary-pic sets -fPIC and -G0 and also suppresses warnings from the
 672      linker about linking pic and non-pic code.  */
 673   if (TARGET_LIBPIC)
 674     {
 675       if (!flag_pic)            /* -fPIC */
 676         flag_pic = 2;
 677
 678       if (! g_switch_set)       /* -G0 */
 679         {
 680           g_switch_set = 1;
 681           g_switch_value = 0;
 682         }
 683     }
 684
 685   /* A C expression whose value is a register class containing hard
 686      register REGNO.  In general there is more than one such class;
 687      choose a class which is "minimal", meaning that no smaller class
 688      also contains the register.  */
 689
 690   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 691     {
 692       enum reg_class rclass;
 693
 694       if (GPR_P (regno))
 695         {
 696           int gpr_reg = regno - GPR_FIRST;
 697
 698           if (gpr_reg == GR8_REG)
 699             rclass = GR8_REGS;
 700
 701           else if (gpr_reg == GR9_REG)
 702             rclass = GR9_REGS;
 703
 704           else if (gpr_reg == GR14_REG)
 705             rclass = FDPIC_FPTR_REGS;
 706
 707           else if (gpr_reg == FDPIC_REGNO)
 708             rclass = FDPIC_REGS;
 709
 710           else if ((gpr_reg & 3) == 0)
 711             rclass = QUAD_REGS;
 712
 713           else if ((gpr_reg & 1) == 0)
 714             rclass = EVEN_REGS;
 715
 716           else
 717             rclass = GPR_REGS;
 718         }
 719
 720       else if (FPR_P (regno))
 721         {
 722           int fpr_reg = regno - GPR_FIRST;
 723           if ((fpr_reg & 3) == 0)
 724             rclass = QUAD_FPR_REGS;
 725
 726           else if ((fpr_reg & 1) == 0)
 727             rclass = FEVEN_REGS;
 728
 729           else
 730             rclass = FPR_REGS;
 731         }
 732
 733       else if (regno == LR_REGNO)
 734         rclass = LR_REG;
 735
 736       else if (regno == LCR_REGNO)
 737         rclass = LCR_REG;
 738
 739       else if (ICC_P (regno))
 740         rclass = ICC_REGS;
 741
 742       else if (FCC_P (regno))
 743         rclass = FCC_REGS;
 744
 745       else if (ICR_P (regno))
 746         rclass = ICR_REGS;
 747
 748       else if (FCR_P (regno))
 749         rclass = FCR_REGS;
 750
 751       else if (ACC_P (regno))
 752         {
 753           int r = regno - ACC_FIRST;
 754           if ((r & 3) == 0)
 755             rclass = QUAD_ACC_REGS;
 756           else if ((r & 1) == 0)
 757             rclass = EVEN_ACC_REGS;
 758           else
 759             rclass = ACC_REGS;
 760         }
 761
 762       else if (ACCG_P (regno))
 763         rclass = ACCG_REGS;
 764
 765       else
 766         rclass = NO_REGS;
 767
 768       regno_reg_class[regno] = rclass;
 769     }
 770
 771   /* Check for small data option */
 772   if (!g_switch_set)
 773     g_switch_value = SDATA_DEFAULT_SIZE;
 774
 775   /* A C expression which defines the machine-dependent operand
 776      constraint letters for register classes.  If CHAR is such a
 777      letter, the value should be the register class corresponding to
 778      it.  Otherwise, the value should be `NO_REGS'.  The register
 779      letter `r', corresponding to class `GENERAL_REGS', will not be
 780      passed to this macro; you do not need to handle it.
 781
 782      The following letters are unavailable, due to being used as
 783      constraints:
 784         '0'..'9'
 785         '<', '>'
 786         'E', 'F', 'G', 'H'
 787         'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P'
 788         'Q', 'R', 'S', 'T', 'U'
 789         'V', 'X'
 790         'g', 'i', 'm', 'n', 'o', 'p', 'r', 's' */
 791
 792   for (i = 0; i < 256; i++)
 793     reg_class_from_letter[i] = NO_REGS;
 794
 795   reg_class_from_letter['a'] = ACC_REGS;
 796   reg_class_from_letter['b'] = EVEN_ACC_REGS;
 797   reg_class_from_letter['c'] = CC_REGS;
 798   reg_class_from_letter['d'] = GPR_REGS;
 799   reg_class_from_letter['e'] = EVEN_REGS;
 800   reg_class_from_letter['f'] = FPR_REGS;
 801   reg_class_from_letter['h'] = FEVEN_REGS;
 802   reg_class_from_letter['l'] = LR_REG;
 803   reg_class_from_letter['q'] = QUAD_REGS;
 804   reg_class_from_letter['t'] = ICC_REGS;
 805   reg_class_from_letter['u'] = FCC_REGS;
 806   reg_class_from_letter['v'] = ICR_REGS;
 807   reg_class_from_letter['w'] = FCR_REGS;
 808   reg_class_from_letter['x'] = QUAD_FPR_REGS;
 809   reg_class_from_letter['y'] = LCR_REG;
 810   reg_class_from_letter['z'] = SPR_REGS;
 811   reg_class_from_letter['A'] = QUAD_ACC_REGS;
 812   reg_class_from_letter['B'] = ACCG_REGS;
 813   reg_class_from_letter['C'] = CR_REGS;
 814   reg_class_from_letter['W'] = FDPIC_CALL_REGS; /* gp14+15 */
 815   reg_class_from_letter['Z'] = FDPIC_REGS; /* gp15 */
 816
 817   /* There is no single unaligned SI op for PIC code.  Sometimes we
 818      need to use ".4byte" and sometimes we need to use ".picptr".
 819      See frv_assemble_integer for details.  */
 820   if (flag_pic || TARGET_FDPIC)
 821     targetm.asm_out.unaligned_op.si = 0;
 822
 823   if ((target_flags_explicit & MASK_LINKED_FP) == 0)
 824     target_flags |= MASK_LINKED_FP;
 825
 826   if ((target_flags_explicit & MASK_OPTIMIZE_MEMBAR) == 0)
 827     target_flags |= MASK_OPTIMIZE_MEMBAR;
 828
 829   for (i = 0; i < ARRAY_SIZE (frv_unit_names); i++)
 830     frv_unit_codes[i] = get_cpu_unit_code (frv_unit_names[i]);
 831
 832   for (i = 0; i < ARRAY_SIZE (frv_type_to_unit); i++)
 833     frv_type_to_unit[i] = ARRAY_SIZE (frv_unit_codes);
 834
 835   init_machine_status = frv_init_machine_status;
 836 }
 837
 838 \f
 839 /* Some machines may desire to change what optimizations are performed for
 840    various optimization levels.  This macro, if defined, is executed once just
 841    after the optimization level is determined and before the remainder of the
 842    command options have been parsed.  Values set in this macro are used as the
 843    default values for the other command line options.
 844
 845    LEVEL is the optimization level specified; 2 if `-O2' is specified, 1 if
 846    `-O' is specified, and 0 if neither is specified.
 847
 848    SIZE is nonzero if `-Os' is specified, 0 otherwise.
 849
 850    You should not use this macro to change options that are not
 851    machine-specific.  These should uniformly selected by the same optimization
 852    level on all supported machines.  Use this macro to enable machine-specific
 853    optimizations.
 854
 855    *Do not examine `write_symbols' in this macro!* The debugging options are
 856    *not supposed to alter the generated code.  */
 857
 858 /* On the FRV, possibly disable VLIW packing which is done by the 2nd
 859    scheduling pass at the current time.  */
 860 void
 861 frv_optimization_options (int level, int size ATTRIBUTE_UNUSED)
 862 {
 863   if (level >= 2)
 864     {
 865 #ifdef DISABLE_SCHED2
 866       flag_schedule_insns_after_reload = 0;
 867 #endif
 868 #ifdef ENABLE_RCSP
 869       flag_rcsp = 1;
 870 #endif
 871     }
 872 }
 873
 874 \f
 875 /* Return true if NAME (a STRING_CST node) begins with PREFIX.  */
 876
 877 static int
 878 frv_string_begins_with (const_tree name, const char *prefix)
 879 {
 880   const int prefix_len = strlen (prefix);
 881
 882   /* Remember: NAME's length includes the null terminator.  */
 883   return (TREE_STRING_LENGTH (name) > prefix_len
 884           && strncmp (TREE_STRING_POINTER (name), prefix, prefix_len) == 0);
 885 }
 886 \f
 887 /* Zero or more C statements that may conditionally modify two variables
 888    `fixed_regs' and `call_used_regs' (both of type `char []') after they have
 889    been initialized from the two preceding macros.
 890
 891    This is necessary in case the fixed or call-clobbered registers depend on
 892    target flags.
 893
 894    You need not define this macro if it has no work to do.
 895
 896    If the usage of an entire class of registers depends on the target flags,
 897    you may indicate this to GCC by using this macro to modify `fixed_regs' and
 898    `call_used_regs' to 1 for each of the registers in the classes which should
 899    not be used by GCC.  Also define the macro `REG_CLASS_FROM_LETTER' to return
 900    `NO_REGS' if it is called with a letter for a class that shouldn't be used.
 901
 902    (However, if this class is not included in `GENERAL_REGS' and all of the
 903    insn patterns whose constraints permit this class are controlled by target
 904    switches, then GCC will automatically avoid using these registers when the
 905    target switches are opposed to them.)  */
 906
 907 void
 908 frv_conditional_register_usage (void)
 909 {
 910   int i;
 911
 912   for (i = GPR_FIRST + NUM_GPRS; i <= GPR_LAST; i++)
 913     fixed_regs[i] = call_used_regs[i] = 1;
 914
 915   for (i = FPR_FIRST + NUM_FPRS; i <= FPR_LAST; i++)
 916     fixed_regs[i] = call_used_regs[i] = 1;
 917
 918   /* Reserve the registers used for conditional execution.  At present, we need
 919      1 ICC and 1 ICR register.  */
 920   fixed_regs[ICC_TEMP] = call_used_regs[ICC_TEMP] = 1;
 921   fixed_regs[ICR_TEMP] = call_used_regs[ICR_TEMP] = 1;
 922
 923   if (TARGET_FIXED_CC)
 924     {
 925       fixed_regs[ICC_FIRST] = call_used_regs[ICC_FIRST] = 1;
 926       fixed_regs[FCC_FIRST] = call_used_regs[FCC_FIRST] = 1;
 927       fixed_regs[ICR_FIRST] = call_used_regs[ICR_FIRST] = 1;
 928       fixed_regs[FCR_FIRST] = call_used_regs[FCR_FIRST] = 1;
 929     }
 930
 931   if (TARGET_FDPIC)
 932     fixed_regs[GPR_FIRST + 16] = fixed_regs[GPR_FIRST + 17] =
 933       call_used_regs[GPR_FIRST + 16] = call_used_regs[GPR_FIRST + 17] = 0;
 934
 935 #if 0
 936   /* If -fpic, SDA_BASE_REG is the PIC register.  */
 937   if (g_switch_value == 0 && !flag_pic)
 938     fixed_regs[SDA_BASE_REG] = call_used_regs[SDA_BASE_REG] = 0;
 939
 940   if (!flag_pic)
 941     fixed_regs[PIC_REGNO] = call_used_regs[PIC_REGNO] = 0;
 942 #endif
 943 }
 944
 945 \f
 946 /*
 947  * Compute the stack frame layout
 948  *
 949  * Register setup:
 950  * +---------------+-----------------------+-----------------------+
 951  * |Register       |type                   |caller-save/callee-save|
 952  * +---------------+-----------------------+-----------------------+
 953  * |GR0            |Zero register          |        -              |
 954  * |GR1            |Stack pointer(SP)      |        -              |
 955  * |GR2            |Frame pointer(FP)      |        -              |
 956  * |GR3            |Hidden parameter       |        caller save    |
 957  * |GR4-GR7        |        -              |        caller save    |
 958  * |GR8-GR13       |Argument register      |        caller save    |
 959  * |GR14-GR15      |        -              |        caller save    |
 960  * |GR16-GR31      |        -              |        callee save    |
 961  * |GR32-GR47      |        -              |        caller save    |
 962  * |GR48-GR63      |        -              |        callee save    |
 963  * |FR0-FR15       |        -              |        caller save    |
 964  * |FR16-FR31      |        -              |        callee save    |
 965  * |FR32-FR47      |        -              |        caller save    |
 966  * |FR48-FR63      |        -              |        callee save    |
 967  * +---------------+-----------------------+-----------------------+
 968  *
 969  * Stack frame setup:
 970  * Low
 971  *     SP-> |-----------------------------------|
 972  *          |         Argument area             |
 973  *          |-----------------------------------|
 974  *          |    Register save area             |
 975  *          |-----------------------------------|
 976  *          |   Local variable save area        |
 977  *     FP-> |-----------------------------------|
 978  *          |       Old FP                      |
 979  *          |-----------------------------------|
 980  *          |    Hidden parameter save area     |
 981  *          |-----------------------------------|
 982  *          | Return address(LR) storage area   |
 983  *          |-----------------------------------|
 984  *          |     Padding for alignment         |
 985  *          |-----------------------------------|
 986  *          |     Register argument area        |
 987  * OLD SP-> |-----------------------------------|
 988  *          |       Parameter area              |
 989  *          |-----------------------------------|
 990  * High
 991  *
 992  * Argument area/Parameter area:
 993  *
 994  * When a function is called, this area is used for argument transfer.  When
 995  * the argument is set up by the caller function, this area is referred to as
 996  * the argument area.  When the argument is referenced by the callee function,
 997  * this area is referred to as the parameter area.  The area is allocated when
 998  * all arguments cannot be placed on the argument register at the time of
 999  * argument transfer.
1000  *
1001  * Register save area:
1002  *
1003  * This is a register save area that must be guaranteed for the caller
1004  * function.  This area is not secured when the register save operation is not
1005  * needed.
1006  *
1007  * Local variable save area:
1008  *
1009  * This is the area for local variables and temporary variables.
1010  *
1011  * Old FP:
1012  *
1013  * This area stores the FP value of the caller function.
1014  *
1015  * Hidden parameter save area:
1016  *
1017  * This area stores the start address of the return value storage
1018  * area for a struct/union return function.
1019  * When a struct/union is used as the return value, the caller
1020  * function stores the return value storage area start address in
1021  * register GR3 and passes it to the caller function.
1022  * The callee function interprets the address stored in the GR3
1023  * as the return value storage area start address.
1024  * When register GR3 needs to be saved into memory, the callee
1025  * function saves it in the hidden parameter save area.  This
1026  * area is not secured when the save operation is not needed.
1027  *
1028  * Return address(LR) storage area:
1029  *
1030  * This area saves the LR.  The LR stores the address of a return to the caller
1031  * function for the purpose of function calling.
1032  *
1033  * Argument register area:
1034  *
1035  * This area saves the argument register.  This area is not secured when the
1036  * save operation is not needed.
1037  *
1038  * Argument:
1039  *
1040  * Arguments, the count of which equals the count of argument registers (6
1041  * words), are positioned in registers GR8 to GR13 and delivered to the callee
1042  * function.  When a struct/union return function is called, the return value
1043  * area address is stored in register GR3.  Arguments not placed in the
1044  * argument registers will be stored in the stack argument area for transfer
1045  * purposes.  When an 8-byte type argument is to be delivered using registers,
1046  * it is divided into two and placed in two registers for transfer.  When
1047  * argument registers must be saved to memory, the callee function secures an
1048  * argument register save area in the stack.  In this case, a continuous
1049  * argument register save area must be established in the parameter area.  The
1050  * argument register save area must be allocated as needed to cover the size of
1051  * the argument register to be saved.  If the function has a variable count of
1052  * arguments, it saves all argument registers in the argument register save
1053  * area.
1054  *
1055  * Argument Extension Format:
1056  *
1057  * When an argument is to be stored in the stack, its type is converted to an
1058  * extended type in accordance with the individual argument type.  The argument
1059  * is freed by the caller function after the return from the callee function is
1060  * made.
1061  *
1062  * +-----------------------+---------------+------------------------+
1063  * |    Argument Type      |Extended Type  |Stack Storage Size(byte)|
1064  * +-----------------------+---------------+------------------------+
1065  * |char                   |int            |        4               |
1066  * |signed char            |int            |        4               |
1067  * |unsigned char          |int            |        4               |
1068  * |[signed] short int     |int            |        4               |
1069  * |unsigned short int     |int            |        4               |
1070  * |[signed] int           |No extension   |        4               |
1071  * |unsigned int           |No extension   |        4               |
1072  * |[signed] long int      |No extension   |        4               |
1073  * |unsigned long int      |No extension   |        4               |
1074  * |[signed] long long int |No extension   |        8               |
1075  * |unsigned long long int |No extension   |        8               |
1076  * |float                  |double         |        8               |
1077  * |double                 |No extension   |        8               |
1078  * |long double            |No extension   |        8               |
1079  * |pointer                |No extension   |        4               |
1080  * |struct/union           |-              |        4 (*1)          |
1081  * +-----------------------+---------------+------------------------+
1082  *
1083  * When a struct/union is to be delivered as an argument, the caller copies it
1084  * to the local variable area and delivers the address of that area.
1085  *
1086  * Return Value:
1087  *
1088  * +-------------------------------+----------------------+
1089  * |Return Value Type              |Return Value Interface|
1090  * +-------------------------------+----------------------+
1091  * |void                           |None                  |
1092  * |[signed|unsigned] char         |GR8                   |
1093  * |[signed|unsigned] short int    |GR8                   |
1094  * |[signed|unsigned] int          |GR8                   |
1095  * |[signed|unsigned] long int     |GR8                   |
1096  * |pointer                        |GR8                   |
1097  * |[signed|unsigned] long long int|GR8 & GR9             |
1098  * |float                          |GR8                   |
1099  * |double                         |GR8 & GR9             |
1100  * |long double                    |GR8 & GR9             |
1101  * |struct/union                   |(*1)                  |
1102  * +-------------------------------+----------------------+
1103  *
1104  * When a struct/union is used as the return value, the caller function stores
1105  * the start address of the return value storage area into GR3 and then passes
1106  * it to the callee function.  The callee function interprets GR3 as the start
1107  * address of the return value storage area.  When this address needs to be
1108  * saved in memory, the callee function secures the hidden parameter save area
1109  * and saves the address in that area.
1110  */
1111
1112 frv_stack_t *
1113 frv_stack_info (void)
1114 {
1115   static frv_stack_t info, zero_info;
1116   frv_stack_t *info_ptr = &info;
1117   tree fndecl           = current_function_decl;
1118   int varargs_p         = 0;
1119   tree cur_arg;
1120   tree next_arg;
1121   int range;
1122   int alignment;
1123   int offset;
1124
1125   /* If we've already calculated the values and reload is complete,
1126      just return now.  */
1127   if (frv_stack_cache)
1128     return frv_stack_cache;
1129
1130   /* Zero all fields.  */
1131   info = zero_info;
1132
1133   /* Set up the register range information.  */
1134   info_ptr->regs[STACK_REGS_GPR].name         = "gpr";
1135   info_ptr->regs[STACK_REGS_GPR].first        = LAST_ARG_REGNUM + 1;
1136   info_ptr->regs[STACK_REGS_GPR].last         = GPR_LAST;
1137   info_ptr->regs[STACK_REGS_GPR].dword_p      = TRUE;
1138
1139   info_ptr->regs[STACK_REGS_FPR].name         = "fpr";
1140   info_ptr->regs[STACK_REGS_FPR].first        = FPR_FIRST;
1141   info_ptr->regs[STACK_REGS_FPR].last         = FPR_LAST;
1142   info_ptr->regs[STACK_REGS_FPR].dword_p      = TRUE;
1143
1144   info_ptr->regs[STACK_REGS_LR].name          = "lr";
1145   info_ptr->regs[STACK_REGS_LR].first         = LR_REGNO;
1146   info_ptr->regs[STACK_REGS_LR].last          = LR_REGNO;
1147   info_ptr->regs[STACK_REGS_LR].special_p     = 1;
1148
1149   info_ptr->regs[STACK_REGS_CC].name          = "cc";
1150   info_ptr->regs[STACK_REGS_CC].first         = CC_FIRST;
1151   info_ptr->regs[STACK_REGS_CC].last          = CC_LAST;
1152   info_ptr->regs[STACK_REGS_CC].field_p       = TRUE;
1153
1154   info_ptr->regs[STACK_REGS_LCR].name         = "lcr";
1155   info_ptr->regs[STACK_REGS_LCR].first        = LCR_REGNO;
1156   info_ptr->regs[STACK_REGS_LCR].last         = LCR_REGNO;
1157
1158   info_ptr->regs[STACK_REGS_STDARG].name      = "stdarg";
1159   info_ptr->regs[STACK_REGS_STDARG].first     = FIRST_ARG_REGNUM;
1160   info_ptr->regs[STACK_REGS_STDARG].last      = LAST_ARG_REGNUM;
1161   info_ptr->regs[STACK_REGS_STDARG].dword_p   = 1;
1162   info_ptr->regs[STACK_REGS_STDARG].special_p = 1;
1163
1164   info_ptr->regs[STACK_REGS_STRUCT].name      = "struct";
1165   info_ptr->regs[STACK_REGS_STRUCT].first     = FRV_STRUCT_VALUE_REGNUM;
1166   info_ptr->regs[STACK_REGS_STRUCT].last      = FRV_STRUCT_VALUE_REGNUM;
1167   info_ptr->regs[STACK_REGS_STRUCT].special_p = 1;
1168
1169   info_ptr->regs[STACK_REGS_FP].name          = "fp";
1170   info_ptr->regs[STACK_REGS_FP].first         = FRAME_POINTER_REGNUM;
1171   info_ptr->regs[STACK_REGS_FP].last          = FRAME_POINTER_REGNUM;
1172   info_ptr->regs[STACK_REGS_FP].special_p     = 1;
1173
1174   /* Determine if this is a stdarg function.  If so, allocate space to store
1175      the 6 arguments.  */
1176   if (cfun->stdarg)
1177     varargs_p = 1;
1178
1179   else
1180     {
1181       /* Find the last argument, and see if it is __builtin_va_alist.  */
1182       for (cur_arg = DECL_ARGUMENTS (fndecl); cur_arg != (tree)0; cur_arg = next_arg)
1183         {
1184           next_arg = TREE_CHAIN (cur_arg);
1185           if (next_arg == (tree)0)
1186             {
1187               if (DECL_NAME (cur_arg)
1188                   && !strcmp (IDENTIFIER_POINTER (DECL_NAME (cur_arg)), "__builtin_va_alist"))
1189                 varargs_p = 1;
1190
1191               break;
1192             }
1193         }
1194     }
1195
1196   /* Iterate over all of the register ranges.  */
1197   for (range = 0; range < STACK_REGS_MAX; range++)
1198     {
1199       frv_stack_regs_t *reg_ptr = &(info_ptr->regs[range]);
1200       int first = reg_ptr->first;
1201       int last = reg_ptr->last;
1202       int size_1word = 0;
1203       int size_2words = 0;
1204       int regno;
1205
1206       /* Calculate which registers need to be saved & save area size.  */
1207       switch (range)
1208         {
1209         default:
1210           for (regno = first; regno <= last; regno++)
1211             {
1212               if ((df_regs_ever_live_p (regno) && !call_used_regs[regno])
1213                   || (crtl->calls_eh_return
1214                       && (regno >= FIRST_EH_REGNUM && regno <= LAST_EH_REGNUM))
1215                   || (!TARGET_FDPIC && flag_pic
1216                       && crtl->uses_pic_offset_table && regno == PIC_REGNO))
1217                 {
1218                   info_ptr->save_p[regno] = REG_SAVE_1WORD;
1219                   size_1word += UNITS_PER_WORD;
1220                 }
1221             }
1222           break;
1223
1224           /* Calculate whether we need to create a frame after everything else
1225              has been processed.  */
1226         case STACK_REGS_FP:
1227           break;
1228
1229         case STACK_REGS_LR:
1230           if (df_regs_ever_live_p (LR_REGNO)
1231               || profile_flag
1232               /* This is set for __builtin_return_address, etc.  */
1233               || cfun->machine->frame_needed
1234               || (TARGET_LINKED_FP && frame_pointer_needed)
1235               || (!TARGET_FDPIC && flag_pic
1236                   && crtl->uses_pic_offset_table))
1237             {
1238               info_ptr->save_p[LR_REGNO] = REG_SAVE_1WORD;
1239               size_1word += UNITS_PER_WORD;
1240             }
1241           break;
1242
1243         case STACK_REGS_STDARG:
1244           if (varargs_p)
1245             {
1246               /* If this is a stdarg function with a non varardic
1247                  argument split between registers and the stack,
1248                  adjust the saved registers downward.  */
1249               last -= (ADDR_ALIGN (crtl->args.pretend_args_size, UNITS_PER_WORD)
1250                        / UNITS_PER_WORD);
1251
1252               for (regno = first; regno <= last; regno++)
1253                 {
1254                   info_ptr->save_p[regno] = REG_SAVE_1WORD;
1255                   size_1word += UNITS_PER_WORD;
1256                 }
1257
1258               info_ptr->stdarg_size = size_1word;
1259             }
1260           break;
1261
1262         case STACK_REGS_STRUCT:
1263           if (cfun->returns_struct)
1264             {
1265               info_ptr->save_p[FRV_STRUCT_VALUE_REGNUM] = REG_SAVE_1WORD;
1266               size_1word += UNITS_PER_WORD;
1267             }
1268           break;
1269         }
1270
1271
1272       if (size_1word)
1273         {
1274           /* If this is a field, it only takes one word.  */
1275           if (reg_ptr->field_p)
1276             size_1word = UNITS_PER_WORD;
1277
1278           /* Determine which register pairs can be saved together.  */
1279           else if (reg_ptr->dword_p && TARGET_DWORD)
1280             {
1281               for (regno = first; regno < last; regno += 2)
1282                 {
1283                   if (info_ptr->save_p[regno] && info_ptr->save_p[regno+1])
1284                     {
1285                       size_2words += 2 * UNITS_PER_WORD;
1286                       size_1word -= 2 * UNITS_PER_WORD;
1287                       info_ptr->save_p[regno] = REG_SAVE_2WORDS;
1288                       info_ptr->save_p[regno+1] = REG_SAVE_NO_SAVE;
1289                     }
1290                 }
1291             }
1292
1293           reg_ptr->size_1word = size_1word;
1294           reg_ptr->size_2words = size_2words;
1295
1296           if (! reg_ptr->special_p)
1297             {
1298               info_ptr->regs_size_1word += size_1word;
1299               info_ptr->regs_size_2words += size_2words;
1300             }
1301         }
1302     }
1303
1304   /* Set up the sizes of each each field in the frame body, making the sizes
1305      of each be divisible by the size of a dword if dword operations might
1306      be used, or the size of a word otherwise.  */
1307   alignment = (TARGET_DWORD? 2 * UNITS_PER_WORD : UNITS_PER_WORD);
1308
1309   info_ptr->parameter_size = ADDR_ALIGN (crtl->outgoing_args_size, alignment);
1310   info_ptr->regs_size = ADDR_ALIGN (info_ptr->regs_size_2words
1311                                     + info_ptr->regs_size_1word,
1312                                     alignment);
1313   info_ptr->vars_size = ADDR_ALIGN (get_frame_size (), alignment);
1314
1315   info_ptr->pretend_size = crtl->args.pretend_args_size;
1316
1317   /* Work out the size of the frame, excluding the header.  Both the frame
1318      body and register parameter area will be dword-aligned.  */
1319   info_ptr->total_size
1320     = (ADDR_ALIGN (info_ptr->parameter_size
1321                    + info_ptr->regs_size
1322                    + info_ptr->vars_size,
1323                    2 * UNITS_PER_WORD)
1324        + ADDR_ALIGN (info_ptr->pretend_size
1325                      + info_ptr->stdarg_size,
1326                      2 * UNITS_PER_WORD));
1327
1328   /* See if we need to create a frame at all, if so add header area.  */
1329   if (info_ptr->total_size  > 0
1330       || frame_pointer_needed
1331       || info_ptr->regs[STACK_REGS_LR].size_1word > 0
1332       || info_ptr->regs[STACK_REGS_STRUCT].size_1word > 0)
1333     {
1334       offset = info_ptr->parameter_size;
1335       info_ptr->header_size = 4 * UNITS_PER_WORD;
1336       info_ptr->total_size += 4 * UNITS_PER_WORD;
1337
1338       /* Calculate the offsets to save normal register pairs.  */
1339       for (range = 0; range < STACK_REGS_MAX; range++)
1340         {
1341           frv_stack_regs_t *reg_ptr = &(info_ptr->regs[range]);
1342           if (! reg_ptr->special_p)
1343             {
1344               int first = reg_ptr->first;
1345               int last = reg_ptr->last;
1346               int regno;
1347
1348               for (regno = first; regno <= last; regno++)
1349                 if (info_ptr->save_p[regno] == REG_SAVE_2WORDS
1350                     && regno != FRAME_POINTER_REGNUM
1351                     && (regno < FIRST_ARG_REGNUM
1352                         || regno > LAST_ARG_REGNUM))
1353                   {
1354                     info_ptr->reg_offset[regno] = offset;
1355                     offset += 2 * UNITS_PER_WORD;
1356                   }
1357             }
1358         }
1359
1360       /* Calculate the offsets to save normal single registers.  */
1361       for (range = 0; range < STACK_REGS_MAX; range++)
1362         {
1363           frv_stack_regs_t *reg_ptr = &(info_ptr->regs[range]);
1364           if (! reg_ptr->special_p)
1365             {
1366               int first = reg_ptr->first;
1367               int last = reg_ptr->last;
1368               int regno;
1369
1370               for (regno = first; regno <= last; regno++)
1371                 if (info_ptr->save_p[regno] == REG_SAVE_1WORD
1372                     && regno != FRAME_POINTER_REGNUM
1373                     && (regno < FIRST_ARG_REGNUM
1374                         || regno > LAST_ARG_REGNUM))
1375                   {
1376                     info_ptr->reg_offset[regno] = offset;
1377                     offset += UNITS_PER_WORD;
1378                   }
1379             }
1380         }
1381
1382       /* Calculate the offset to save the local variables at.  */
1383       offset = ADDR_ALIGN (offset, alignment);
1384       if (info_ptr->vars_size)
1385         {
1386           info_ptr->vars_offset = offset;
1387           offset += info_ptr->vars_size;
1388         }
1389
1390       /* Align header to a dword-boundary.  */
1391       offset = ADDR_ALIGN (offset, 2 * UNITS_PER_WORD);
1392
1393       /* Calculate the offsets in the fixed frame.  */
1394       info_ptr->save_p[FRAME_POINTER_REGNUM] = REG_SAVE_1WORD;
1395       info_ptr->reg_offset[FRAME_POINTER_REGNUM] = offset;
1396       info_ptr->regs[STACK_REGS_FP].size_1word = UNITS_PER_WORD;
1397
1398       info_ptr->save_p[LR_REGNO] = REG_SAVE_1WORD;
1399       info_ptr->reg_offset[LR_REGNO] = offset + 2*UNITS_PER_WORD;
1400       info_ptr->regs[STACK_REGS_LR].size_1word = UNITS_PER_WORD;
1401
1402       if (cfun->returns_struct)
1403         {
1404           info_ptr->save_p[FRV_STRUCT_VALUE_REGNUM] = REG_SAVE_1WORD;
1405           info_ptr->reg_offset[FRV_STRUCT_VALUE_REGNUM] = offset + UNITS_PER_WORD;
1406           info_ptr->regs[STACK_REGS_STRUCT].size_1word = UNITS_PER_WORD;
1407         }
1408
1409       /* Calculate the offsets to store the arguments passed in registers
1410          for stdarg functions.  The register pairs are first and the single
1411          register if any is last.  The register save area starts on a
1412          dword-boundary.  */
1413       if (info_ptr->stdarg_size)
1414         {
1415           int first = info_ptr->regs[STACK_REGS_STDARG].first;
1416           int last  = info_ptr->regs[STACK_REGS_STDARG].last;
1417           int regno;
1418
1419           /* Skip the header.  */
1420           offset += 4 * UNITS_PER_WORD;
1421           for (regno = first; regno <= last; regno++)
1422             {
1423               if (info_ptr->save_p[regno] == REG_SAVE_2WORDS)
1424                 {
1425                   info_ptr->reg_offset[regno] = offset;
1426                   offset += 2 * UNITS_PER_WORD;
1427                 }
1428               else if (info_ptr->save_p[regno] == REG_SAVE_1WORD)
1429                 {
1430                   info_ptr->reg_offset[regno] = offset;
1431                   offset += UNITS_PER_WORD;
1432                 }
1433             }
1434         }
1435     }
1436
1437   if (reload_completed)
1438     frv_stack_cache = info_ptr;
1439
1440   return info_ptr;
1441 }
1442
1443 \f
1444 /* Print the information about the frv stack offsets, etc. when debugging.  */
1445
1446 void
1447 frv_debug_stack (frv_stack_t *info)
1448 {
1449   int range;
1450
1451   if (!info)
1452     info = frv_stack_info ();
1453
1454   fprintf (stderr, "\nStack information for function %s:\n",
1455            ((current_function_decl && DECL_NAME (current_function_decl))
1456             ? IDENTIFIER_POINTER (DECL_NAME (current_function_decl))
1457             : "<unknown>"));
1458
1459   fprintf (stderr, "\ttotal_size\t= %6d\n", info->total_size);
1460   fprintf (stderr, "\tvars_size\t= %6d\n", info->vars_size);
1461   fprintf (stderr, "\tparam_size\t= %6d\n", info->parameter_size);
1462   fprintf (stderr, "\tregs_size\t= %6d, 1w = %3d, 2w = %3d\n",
1463            info->regs_size, info->regs_size_1word, info->regs_size_2words);
1464
1465   fprintf (stderr, "\theader_size\t= %6d\n", info->header_size);
1466   fprintf (stderr, "\tpretend_size\t= %6d\n", info->pretend_size);
1467   fprintf (stderr, "\tvars_offset\t= %6d\n", info->vars_offset);
1468   fprintf (stderr, "\tregs_offset\t= %6d\n", info->regs_offset);
1469
1470   for (range = 0; range < STACK_REGS_MAX; range++)
1471     {
1472       frv_stack_regs_t *regs = &(info->regs[range]);
1473       if ((regs->size_1word + regs->size_2words) > 0)
1474         {
1475           int first = regs->first;
1476           int last  = regs->last;
1477           int regno;
1478
1479           fprintf (stderr, "\t%s\tsize\t= %6d, 1w = %3d, 2w = %3d, save =",
1480                    regs->name, regs->size_1word + regs->size_2words,
1481                    regs->size_1word, regs->size_2words);
1482
1483           for (regno = first; regno <= last; regno++)
1484             {
1485               if (info->save_p[regno] == REG_SAVE_1WORD)
1486                 fprintf (stderr, " %s (%d)", reg_names[regno],
1487                          info->reg_offset[regno]);
1488
1489               else if (info->save_p[regno] == REG_SAVE_2WORDS)
1490                 fprintf (stderr, " %s-%s (%d)", reg_names[regno],
1491                          reg_names[regno+1], info->reg_offset[regno]);
1492             }
1493
1494           fputc ('\n', stderr);
1495         }
1496     }
1497
1498   fflush (stderr);
1499 }
1500
1501
1502 \f
1503
1504 /* Used during final to control the packing of insns.  The value is
1505    1 if the current instruction should be packed with the next one,
1506    0 if it shouldn't or -1 if packing is disabled altogether.  */
1507
1508 static int frv_insn_packing_flag;
1509
1510 /* True if the current function contains a far jump.  */
1511
1512 static int
1513 frv_function_contains_far_jump (void)
1514 {
1515   rtx insn = get_insns ();
1516   while (insn != NULL
1517          && !(GET_CODE (insn) == JUMP_INSN
1518               /* Ignore tablejump patterns.  */
1519               && GET_CODE (PATTERN (insn)) != ADDR_VEC
1520               && GET_CODE (PATTERN (insn)) != ADDR_DIFF_VEC
1521               && get_attr_far_jump (insn) == FAR_JUMP_YES))
1522     insn = NEXT_INSN (insn);
1523   return (insn != NULL);
1524 }
1525
1526 /* For the FRV, this function makes sure that a function with far jumps
1527    will return correctly.  It also does the VLIW packing.  */
1528
1529 static void
1530 frv_function_prologue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED)
1531 {
1532   /* If no frame was created, check whether the function uses a call
1533      instruction to implement a far jump.  If so, save the link in gr3 and
1534      replace all returns to LR with returns to GR3.  GR3 is used because it
1535      is call-clobbered, because is not available to the register allocator,
1536      and because all functions that take a hidden argument pointer will have
1537      a stack frame.  */
1538   if (frv_stack_info ()->total_size == 0 && frv_function_contains_far_jump ())
1539     {
1540       rtx insn;
1541
1542       /* Just to check that the above comment is true.  */
1543       gcc_assert (!df_regs_ever_live_p (GPR_FIRST + 3));
1544
1545       /* Generate the instruction that saves the link register.  */
1546       fprintf (file, "\tmovsg lr,gr3\n");
1547
1548       /* Replace the LR with GR3 in *return_internal patterns.  The insn
1549          will now return using jmpl @(gr3,0) rather than bralr.  We cannot
1550          simply emit a different assembly directive because bralr and jmpl
1551          execute in different units.  */
1552       for (insn = get_insns(); insn != NULL; insn = NEXT_INSN (insn))
1553         if (GET_CODE (insn) == JUMP_INSN)
1554           {
1555             rtx pattern = PATTERN (insn);
1556             if (GET_CODE (pattern) == PARALLEL
1557                 && XVECLEN (pattern, 0) >= 2
1558                 && GET_CODE (XVECEXP (pattern, 0, 0)) == RETURN
1559                 && GET_CODE (XVECEXP (pattern, 0, 1)) == USE)
1560               {
1561                 rtx address = XEXP (XVECEXP (pattern, 0, 1), 0);
1562                 if (GET_CODE (address) == REG && REGNO (address) == LR_REGNO)
1563                   SET_REGNO (address, GPR_FIRST + 3);
1564               }
1565           }
1566     }
1567
1568   frv_pack_insns ();
1569
1570   /* Allow the garbage collector to free the nops created by frv_reorg.  */
1571   memset (frv_nops, 0, sizeof (frv_nops));
1572 }
1573
1574 \f
1575 /* Return the next available temporary register in a given class.  */
1576
1577 static rtx
1578 frv_alloc_temp_reg (
1579      frv_tmp_reg_t *info,       /* which registers are available */
1580      enum reg_class rclass,     /* register class desired */
1581      enum machine_mode mode,    /* mode to allocate register with */
1582      int mark_as_used,          /* register not available after allocation */
1583      int no_abort)              /* return NULL instead of aborting */
1584 {
1585   int regno = info->next_reg[ (int)rclass ];
1586   int orig_regno = regno;
1587   HARD_REG_SET *reg_in_class = &reg_class_contents[ (int)rclass ];
1588   int i, nr;
1589
1590   for (;;)
1591     {
1592       if (TEST_HARD_REG_BIT (*reg_in_class, regno)
1593           && TEST_HARD_REG_BIT (info->regs, regno))
1594           break;
1595
1596       if (++regno >= FIRST_PSEUDO_REGISTER)
1597         regno = 0;
1598       if (regno == orig_regno)
1599         {
1600           gcc_assert (no_abort);
1601           return NULL_RTX;
1602         }
1603     }
1604
1605   nr = HARD_REGNO_NREGS (regno, mode);
1606   info->next_reg[ (int)rclass ] = regno + nr;
1607
1608   if (mark_as_used)
1609     for (i = 0; i < nr; i++)
1610       CLEAR_HARD_REG_BIT (info->regs, regno+i);
1611
1612   return gen_rtx_REG (mode, regno);
1613 }
1614
1615 \f
1616 /* Return an rtx with the value OFFSET, which will either be a register or a
1617    signed 12-bit integer.  It can be used as the second operand in an "add"
1618    instruction, or as the index in a load or store.
1619
1620    The function returns a constant rtx if OFFSET is small enough, otherwise
1621    it loads the constant into register OFFSET_REGNO and returns that.  */
1622 static rtx
1623 frv_frame_offset_rtx (int offset)
1624 {
1625   rtx offset_rtx = GEN_INT (offset);
1626   if (IN_RANGE_P (offset, -2048, 2047))
1627     return offset_rtx;
1628   else
1629     {
1630       rtx reg_rtx = gen_rtx_REG (SImode, OFFSET_REGNO);
1631       if (IN_RANGE_P (offset, -32768, 32767))
1632         emit_insn (gen_movsi (reg_rtx, offset_rtx));
1633       else
1634         {
1635           emit_insn (gen_movsi_high (reg_rtx, offset_rtx));
1636           emit_insn (gen_movsi_lo_sum (reg_rtx, offset_rtx));
1637         }
1638       return reg_rtx;
1639     }
1640 }
1641
1642 /* Generate (mem:MODE (plus:Pmode BASE (frv_frame_offset OFFSET)))).  The
1643    prologue and epilogue uses such expressions to access the stack.  */
1644 static rtx
1645 frv_frame_mem (enum machine_mode mode, rtx base, int offset)
1646 {
1647   return gen_rtx_MEM (mode, gen_rtx_PLUS (Pmode,
1648                                           base,
1649                                           frv_frame_offset_rtx (offset)));
1650 }
1651
1652 /* Generate a frame-related expression:
1653
1654         (set REG (mem (plus (sp) (const_int OFFSET)))).
1655
1656    Such expressions are used in FRAME_RELATED_EXPR notes for more complex
1657    instructions.  Marking the expressions as frame-related is superfluous if
1658    the note contains just a single set.  But if the note contains a PARALLEL
1659    or SEQUENCE that has several sets, each set must be individually marked
1660    as frame-related.  */
1661 static rtx
1662 frv_dwarf_store (rtx reg, int offset)
1663 {
1664   rtx set = gen_rtx_SET (VOIDmode,
1665                          gen_rtx_MEM (GET_MODE (reg),
1666                                       plus_constant (stack_pointer_rtx,
1667                                                      offset)),
1668                          reg);
1669   RTX_FRAME_RELATED_P (set) = 1;
1670   return set;
1671 }
1672
1673 /* Emit a frame-related instruction whose pattern is PATTERN.  The
1674    instruction is the last in a sequence that cumulatively performs the
1675    operation described by DWARF_PATTERN.  The instruction is marked as
1676    frame-related and has a REG_FRAME_RELATED_EXPR note containing
1677    DWARF_PATTERN.  */
1678 static void
1679 frv_frame_insn (rtx pattern, rtx dwarf_pattern)
1680 {
1681   rtx insn = emit_insn (pattern);
1682   RTX_FRAME_RELATED_P (insn) = 1;
1683   REG_NOTES (insn) = alloc_EXPR_LIST (REG_FRAME_RELATED_EXPR,
1684                                       dwarf_pattern,
1685                                       REG_NOTES (insn));
1686 }
1687
1688 /* Emit instructions that transfer REG to or from the memory location (sp +
1689    STACK_OFFSET).  The register is stored in memory if ACCESSOR->OP is
1690    FRV_STORE and loaded if it is FRV_LOAD.  Only the prologue uses this
1691    function to store registers and only the epilogue uses it to load them.
1692
1693    The caller sets up ACCESSOR so that BASE is equal to (sp + BASE_OFFSET).
1694    The generated instruction will use BASE as its base register.  BASE may
1695    simply be the stack pointer, but if several accesses are being made to a
1696    region far away from the stack pointer, it may be more efficient to set
1697    up a temporary instead.
1698
1699    Store instructions will be frame-related and will be annotated with the
1700    overall effect of the store.  Load instructions will be followed by a
1701    (use) to prevent later optimizations from zapping them.
1702
1703    The function takes care of the moves to and from SPRs, using TEMP_REGNO
1704    as a temporary in such cases.  */
1705 static void
1706 frv_frame_access (frv_frame_accessor_t *accessor, rtx reg, int stack_offset)
1707 {
1708   enum machine_mode mode = GET_MODE (reg);
1709   rtx mem = frv_frame_mem (mode,
1710                            accessor->base,
1711                            stack_offset - accessor->base_offset);
1712
1713   if (accessor->op == FRV_LOAD)
1714     {
1715       if (SPR_P (REGNO (reg)))
1716         {
1717           rtx temp = gen_rtx_REG (mode, TEMP_REGNO);
1718           emit_insn (gen_rtx_SET (VOIDmode, temp, mem));
1719           emit_insn (gen_rtx_SET (VOIDmode, reg, temp));
1720         }
1721       else
1722         {
1723           /* We cannot use reg+reg addressing for DImode access.  */
1724           if (mode == DImode
1725               && GET_CODE (XEXP (mem, 0)) == PLUS
1726               && GET_CODE (XEXP (XEXP (mem, 0), 0)) == REG
1727               && GET_CODE (XEXP (XEXP (mem, 0), 1)) == REG)
1728             {
1729               rtx temp = gen_rtx_REG (SImode, TEMP_REGNO);
1730               rtx insn = emit_move_insn (temp,
1731                                          gen_rtx_PLUS (SImode, XEXP (XEXP (mem, 0), 0),
1732                                                        XEXP (XEXP (mem, 0), 1)));
1733               mem = gen_rtx_MEM (DImode, temp);
1734             }
1735           emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
1736         }
1737       emit_use (reg);
1738     }
1739   else
1740     {
1741       if (SPR_P (REGNO (reg)))
1742         {
1743           rtx temp = gen_rtx_REG (mode, TEMP_REGNO);
1744           emit_insn (gen_rtx_SET (VOIDmode, temp, reg));
1745           frv_frame_insn (gen_rtx_SET (Pmode, mem, temp),
1746                           frv_dwarf_store (reg, stack_offset));
1747         }
1748       else if (mode == DImode)
1749         {
1750           /* For DImode saves, the dwarf2 version needs to be a SEQUENCE
1751              with a separate save for each register.  */
1752           rtx reg1 = gen_rtx_REG (SImode, REGNO (reg));
1753           rtx reg2 = gen_rtx_REG (SImode, REGNO (reg) + 1);
1754           rtx set1 = frv_dwarf_store (reg1, stack_offset);
1755           rtx set2 = frv_dwarf_store (reg2, stack_offset + 4);
1756
1757           /* Also we cannot use reg+reg addressing.  */
1758           if (GET_CODE (XEXP (mem, 0)) == PLUS
1759               && GET_CODE (XEXP (XEXP (mem, 0), 0)) == REG
1760               && GET_CODE (XEXP (XEXP (mem, 0), 1)) == REG)
1761             {
1762               rtx temp = gen_rtx_REG (SImode, TEMP_REGNO);
1763               rtx insn = emit_move_insn (temp,
1764                                          gen_rtx_PLUS (SImode, XEXP (XEXP (mem, 0), 0),
1765                                                        XEXP (XEXP (mem, 0), 1)));
1766               mem = gen_rtx_MEM (DImode, temp);
1767             }
1768
1769           frv_frame_insn (gen_rtx_SET (Pmode, mem, reg),
1770                           gen_rtx_PARALLEL (VOIDmode,
1771                                             gen_rtvec (2, set1, set2)));
1772         }
1773       else
1774         frv_frame_insn (gen_rtx_SET (Pmode, mem, reg),
1775                         frv_dwarf_store (reg, stack_offset));
1776     }
1777 }
1778
1779 /* A function that uses frv_frame_access to transfer a group of registers to
1780    or from the stack.  ACCESSOR is passed directly to frv_frame_access, INFO
1781    is the stack information generated by frv_stack_info, and REG_SET is the
1782    number of the register set to transfer.  */
1783 static void
1784 frv_frame_access_multi (frv_frame_accessor_t *accessor,
1785                         frv_stack_t *info,
1786                         int reg_set)
1787 {
1788   frv_stack_regs_t *regs_info;
1789   int regno;
1790
1791   regs_info = &info->regs[reg_set];
1792   for (regno = regs_info->first; regno <= regs_info->last; regno++)
1793     if (info->save_p[regno])
1794       frv_frame_access (accessor,
1795                         info->save_p[regno] == REG_SAVE_2WORDS
1796                         ? gen_rtx_REG (DImode, regno)
1797                         : gen_rtx_REG (SImode, regno),
1798                         info->reg_offset[regno]);
1799 }
1800
1801 /* Save or restore callee-saved registers that are kept outside the frame
1802    header.  The function saves the registers if OP is FRV_STORE and restores
1803    them if OP is FRV_LOAD.  INFO is the stack information generated by
1804    frv_stack_info.  */
1805 static void
1806 frv_frame_access_standard_regs (enum frv_stack_op op, frv_stack_t *info)
1807 {
1808   frv_frame_accessor_t accessor;
1809
1810   accessor.op = op;
1811   accessor.base = stack_pointer_rtx;
1812   accessor.base_offset = 0;
1813   frv_frame_access_multi (&accessor, info, STACK_REGS_GPR);
1814   frv_frame_access_multi (&accessor, info, STACK_REGS_FPR);
1815   frv_frame_access_multi (&accessor, info, STACK_REGS_LCR);
1816 }
1817
1818
1819 /* Called after register allocation to add any instructions needed for the
1820    prologue.  Using a prologue insn is favored compared to putting all of the
1821    instructions in the TARGET_ASM_FUNCTION_PROLOGUE target hook, since
1822    it allows the scheduler to intermix instructions with the saves of
1823    the caller saved registers.  In some cases, it might be necessary
1824    to emit a barrier instruction as the last insn to prevent such
1825    scheduling.
1826
1827    Also any insns generated here should have RTX_FRAME_RELATED_P(insn) = 1
1828    so that the debug info generation code can handle them properly.  */
1829 void
1830 frv_expand_prologue (void)
1831 {
1832   frv_stack_t *info = frv_stack_info ();
1833   rtx sp = stack_pointer_rtx;
1834   rtx fp = frame_pointer_rtx;
1835   frv_frame_accessor_t accessor;
1836
1837   if (TARGET_DEBUG_STACK)
1838     frv_debug_stack (info);
1839
1840   if (info->total_size == 0)
1841     return;
1842
1843   /* We're interested in three areas of the frame here:
1844
1845          A: the register save area
1846          B: the old FP
1847          C: the header after B
1848
1849      If the frame pointer isn't used, we'll have to set up A, B and C
1850      using the stack pointer.  If the frame pointer is used, we'll access
1851      them as follows:
1852
1853          A: set up using sp
1854          B: set up using sp or a temporary (see below)
1855          C: set up using fp
1856
1857      We set up B using the stack pointer if the frame is small enough.
1858      Otherwise, it's more efficient to copy the old stack pointer into a
1859      temporary and use that.
1860
1861      Note that it's important to make sure the prologue and epilogue use the
1862      same registers to access A and C, since doing otherwise will confuse
1863      the aliasing code.  */
1864
1865   /* Set up ACCESSOR for accessing region B above.  If the frame pointer
1866      isn't used, the same method will serve for C.  */
1867   accessor.op = FRV_STORE;
1868   if (frame_pointer_needed && info->total_size > 2048)
1869     {
1870       rtx insn;
1871
1872       accessor.base = gen_rtx_REG (Pmode, OLD_SP_REGNO);
1873       accessor.base_offset = info->total_size;
1874       insn = emit_insn (gen_movsi (accessor.base, sp));
1875     }
1876   else
1877     {
1878       accessor.base = stack_pointer_rtx;
1879       accessor.base_offset = 0;
1880     }
1881
1882   /* Allocate the stack space.  */
1883   {
1884     rtx asm_offset = frv_frame_offset_rtx (-info->total_size);
1885     rtx dwarf_offset = GEN_INT (-info->total_size);
1886
1887     frv_frame_insn (gen_stack_adjust (sp, sp, asm_offset),
1888                     gen_rtx_SET (Pmode,
1889                                  sp,
1890                                  gen_rtx_PLUS (Pmode, sp, dwarf_offset)));
1891   }
1892
1893   /* If the frame pointer is needed, store the old one at (sp + FP_OFFSET)
1894      and point the new one to that location.  */
1895   if (frame_pointer_needed)
1896     {
1897       int fp_offset = info->reg_offset[FRAME_POINTER_REGNUM];
1898
1899       /* ASM_SRC and DWARF_SRC both point to the frame header.  ASM_SRC is
1900          based on ACCESSOR.BASE but DWARF_SRC is always based on the stack
1901          pointer.  */
1902       rtx asm_src = plus_constant (accessor.base,
1903                                    fp_offset - accessor.base_offset);
1904       rtx dwarf_src = plus_constant (sp, fp_offset);
1905
1906       /* Store the old frame pointer at (sp + FP_OFFSET).  */
1907       frv_frame_access (&accessor, fp, fp_offset);
1908
1909       /* Set up the new frame pointer.  */
1910       frv_frame_insn (gen_rtx_SET (VOIDmode, fp, asm_src),
1911                       gen_rtx_SET (VOIDmode, fp, dwarf_src));
1912
1913       /* Access region C from the frame pointer.  */
1914       accessor.base = fp;
1915       accessor.base_offset = fp_offset;
1916     }
1917
1918   /* Set up region C.  */
1919   frv_frame_access_multi (&accessor, info, STACK_REGS_STRUCT);
1920   frv_frame_access_multi (&accessor, info, STACK_REGS_LR);
1921   frv_frame_access_multi (&accessor, info, STACK_REGS_STDARG);
1922
1923   /* Set up region A.  */
1924   frv_frame_access_standard_regs (FRV_STORE, info);
1925
1926   /* If this is a varargs/stdarg function, issue a blockage to prevent the
1927      scheduler from moving loads before the stores saving the registers.  */
1928   if (info->stdarg_size > 0)
1929     emit_insn (gen_blockage ());
1930
1931   /* Set up pic register/small data register for this function.  */
1932   if (!TARGET_FDPIC && flag_pic && crtl->uses_pic_offset_table)
1933     emit_insn (gen_pic_prologue (gen_rtx_REG (Pmode, PIC_REGNO),
1934                                  gen_rtx_REG (Pmode, LR_REGNO),
1935                                  gen_rtx_REG (SImode, OFFSET_REGNO)));
1936 }
1937
1938 \f
1939 /* Under frv, all of the work is done via frv_expand_epilogue, but
1940    this function provides a convenient place to do cleanup.  */
1941
1942 static void
1943 frv_function_epilogue (FILE *file ATTRIBUTE_UNUSED,
1944                        HOST_WIDE_INT size ATTRIBUTE_UNUSED)
1945 {
1946   frv_stack_cache = (frv_stack_t *)0;
1947
1948   /* Zap last used registers for conditional execution.  */
1949   memset (&frv_ifcvt.tmp_reg, 0, sizeof (frv_ifcvt.tmp_reg));
1950
1951   /* Release the bitmap of created insns.  */
1952   BITMAP_FREE (frv_ifcvt.scratch_insns_bitmap);
1953 }
1954
1955 \f
1956 /* Called after register allocation to add any instructions needed for the
1957    epilogue.  Using an epilogue insn is favored compared to putting all of the
1958    instructions in the TARGET_ASM_FUNCTION_PROLOGUE target hook, since
1959    it allows the scheduler to intermix instructions with the saves of
1960    the caller saved registers.  In some cases, it might be necessary
1961    to emit a barrier instruction as the last insn to prevent such
1962    scheduling.  */
1963
1964 void
1965 frv_expand_epilogue (bool emit_return)
1966 {
1967   frv_stack_t *info = frv_stack_info ();
1968   rtx fp = frame_pointer_rtx;
1969   rtx sp = stack_pointer_rtx;
1970   rtx return_addr;
1971   int fp_offset;
1972
1973   fp_offset = info->reg_offset[FRAME_POINTER_REGNUM];
1974
1975   /* Restore the stack pointer to its original value if alloca or the like
1976      is used.  */
1977   if (! current_function_sp_is_unchanging)
1978     emit_insn (gen_addsi3 (sp, fp, frv_frame_offset_rtx (-fp_offset)));
1979
1980   /* Restore the callee-saved registers that were used in this function.  */
1981   frv_frame_access_standard_regs (FRV_LOAD, info);
1982
1983   /* Set RETURN_ADDR to the address we should return to.  Set it to NULL if
1984      no return instruction should be emitted.  */
1985   if (info->save_p[LR_REGNO])
1986     {
1987       int lr_offset;
1988       rtx mem;
1989
1990       /* Use the same method to access the link register's slot as we did in
1991          the prologue.  In other words, use the frame pointer if available,
1992          otherwise use the stack pointer.
1993
1994          LR_OFFSET is the offset of the link register's slot from the start
1995          of the frame and MEM is a memory rtx for it.  */
1996       lr_offset = info->reg_offset[LR_REGNO];
1997       if (frame_pointer_needed)
1998         mem = frv_frame_mem (Pmode, fp, lr_offset - fp_offset);
1999       else
2000         mem = frv_frame_mem (Pmode, sp, lr_offset);
2001
2002       /* Load the old link register into a GPR.  */
2003       return_addr = gen_rtx_REG (Pmode, TEMP_REGNO);
2004       emit_insn (gen_rtx_SET (VOIDmode, return_addr, mem));
2005     }
2006   else
2007     return_addr = gen_rtx_REG (Pmode, LR_REGNO);
2008
2009   /* Restore the old frame pointer.  Emit a USE afterwards to make sure
2010      the load is preserved.  */
2011   if (frame_pointer_needed)
2012     {
2013       emit_insn (gen_rtx_SET (VOIDmode, fp, gen_rtx_MEM (Pmode, fp)));
2014       emit_use (fp);
2015     }
2016
2017   /* Deallocate the stack frame.  */
2018   if (info->total_size != 0)
2019     {
2020       rtx offset = frv_frame_offset_rtx (info->total_size);
2021       emit_insn (gen_stack_adjust (sp, sp, offset));
2022     }
2023
2024   /* If this function uses eh_return, add the final stack adjustment now.  */
2025   if (crtl->calls_eh_return)
2026     emit_insn (gen_stack_adjust (sp, sp, EH_RETURN_STACKADJ_RTX));
2027
2028   if (emit_return)
2029     emit_jump_insn (gen_epilogue_return (return_addr));
2030   else
2031     {
2032       rtx lr = return_addr;
2033
2034       if (REGNO (return_addr) != LR_REGNO)
2035         {
2036           lr = gen_rtx_REG (Pmode, LR_REGNO);
2037           emit_move_insn (lr, return_addr);
2038         }
2039
2040       emit_use (lr);
2041     }
2042 }
2043
2044 \f
2045 /* Worker function for TARGET_ASM_OUTPUT_MI_THUNK.  */
2046
2047 static void
2048 frv_asm_output_mi_thunk (FILE *file,
2049                          tree thunk_fndecl ATTRIBUTE_UNUSED,
2050                          HOST_WIDE_INT delta,
2051                          HOST_WIDE_INT vcall_offset ATTRIBUTE_UNUSED,
2052                          tree function)
2053 {
2054   const char *name_func = XSTR (XEXP (DECL_RTL (function), 0), 0);
2055   const char *name_arg0 = reg_names[FIRST_ARG_REGNUM];
2056   const char *name_jmp = reg_names[JUMP_REGNO];
2057   const char *parallel = (frv_issue_rate () > 1 ? ".p" : "");
2058
2059   /* Do the add using an addi if possible.  */
2060   if (IN_RANGE_P (delta, -2048, 2047))
2061     fprintf (file, "\taddi %s,#%d,%s\n", name_arg0, (int) delta, name_arg0);
2062   else
2063     {
2064       const char *const name_add = reg_names[TEMP_REGNO];
2065       fprintf (file, "\tsethi%s #hi(" HOST_WIDE_INT_PRINT_DEC "),%s\n",
2066                parallel, delta, name_add);
2067       fprintf (file, "\tsetlo #lo(" HOST_WIDE_INT_PRINT_DEC "),%s\n",
2068                delta, name_add);
2069       fprintf (file, "\tadd %s,%s,%s\n", name_add, name_arg0, name_arg0);
2070     }
2071
2072   if (TARGET_FDPIC)
2073     {
2074       const char *name_pic = reg_names[FDPIC_REGNO];
2075       name_jmp = reg_names[FDPIC_FPTR_REGNO];
2076
2077       if (flag_pic != 1)
2078         {
2079           fprintf (file, "\tsethi%s #gotofffuncdeschi(", parallel);
2080           assemble_name (file, name_func);
2081           fprintf (file, "),%s\n", name_jmp);
2082
2083           fprintf (file, "\tsetlo #gotofffuncdesclo(");
2084           assemble_name (file, name_func);
2085           fprintf (file, "),%s\n", name_jmp);
2086
2087           fprintf (file, "\tldd @(%s,%s), %s\n", name_jmp, name_pic, name_jmp);
2088         }
2089       else
2090         {
2091           fprintf (file, "\tlddo @(%s,#gotofffuncdesc12(", name_pic);
2092           assemble_name (file, name_func);
2093           fprintf (file, "\t)), %s\n", name_jmp);
2094         }
2095     }
2096   else if (!flag_pic)
2097     {
2098       fprintf (file, "\tsethi%s #hi(", parallel);
2099       assemble_name (file, name_func);
2100       fprintf (file, "),%s\n", name_jmp);
2101
2102       fprintf (file, "\tsetlo #lo(");
2103       assemble_name (file, name_func);
2104       fprintf (file, "),%s\n", name_jmp);
2105     }
2106   else
2107     {
2108       /* Use JUMP_REGNO as a temporary PIC register.  */
2109       const char *name_lr = reg_names[LR_REGNO];
2110       const char *name_gppic = name_jmp;
2111       const char *name_tmp = reg_names[TEMP_REGNO];
2112
2113       fprintf (file, "\tmovsg %s,%s\n", name_lr, name_tmp);
2114       fprintf (file, "\tcall 1f\n");
2115       fprintf (file, "1:\tmovsg %s,%s\n", name_lr, name_gppic);
2116       fprintf (file, "\tmovgs %s,%s\n", name_tmp, name_lr);
2117       fprintf (file, "\tsethi%s #gprelhi(1b),%s\n", parallel, name_tmp);
2118       fprintf (file, "\tsetlo #gprello(1b),%s\n", name_tmp);
2119       fprintf (file, "\tsub %s,%s,%s\n", name_gppic, name_tmp, name_gppic);
2120
2121       fprintf (file, "\tsethi%s #gprelhi(", parallel);
2122       assemble_name (file, name_func);
2123       fprintf (file, "),%s\n", name_tmp);
2124
2125       fprintf (file, "\tsetlo #gprello(");
2126       assemble_name (file, name_func);
2127       fprintf (file, "),%s\n", name_tmp);
2128
2129       fprintf (file, "\tadd %s,%s,%s\n", name_gppic, name_tmp, name_jmp);
2130     }
2131
2132   /* Jump to the function address.  */
2133   fprintf (file, "\tjmpl @(%s,%s)\n", name_jmp, reg_names[GPR_FIRST+0]);
2134 }
2135
2136 \f
2137
2138 /* On frv, create a frame whenever we need to create stack.  */
2139
2140 static bool
2141 frv_frame_pointer_required (void)
2142 {
2143   /* If we forgoing the usual linkage requirements, we only need
2144      a frame pointer if the stack pointer might change.  */
2145   if (!TARGET_LINKED_FP)
2146     return !current_function_sp_is_unchanging;
2147
2148   if (! current_function_is_leaf)
2149     return true;
2150
2151   if (get_frame_size () != 0)
2152     return true;
2153
2154   if (cfun->stdarg)
2155     return true;
2156
2157   if (!current_function_sp_is_unchanging)
2158     return true;
2159
2160   if (!TARGET_FDPIC && flag_pic && crtl->uses_pic_offset_table)
2161     return true;
2162
2163   if (profile_flag)
2164     return true;
2165
2166   if (cfun->machine->frame_needed)
2167     return true;
2168
2169   return false;
2170 }
2171
2172 \f
2173 /* Worker function for TARGET_CAN_ELIMINATE.  */
2174
2175 bool
2176 frv_can_eliminate (const int from, const int to)
2177 {
2178   return (from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM
2179           ? ! frame_pointer_needed
2180           : true);
2181 }
2182
2183 /* This macro is similar to `INITIAL_FRAME_POINTER_OFFSET'.  It specifies the
2184    initial difference between the specified pair of registers.  This macro must
2185    be defined if `ELIMINABLE_REGS' is defined.  */
2186
2187 /* See frv_stack_info for more details on the frv stack frame.  */
2188
2189 int
2190 frv_initial_elimination_offset (int from, int to)
2191 {
2192   frv_stack_t *info = frv_stack_info ();
2193   int ret = 0;
2194
2195   if (to == STACK_POINTER_REGNUM && from == ARG_POINTER_REGNUM)
2196     ret = info->total_size - info->pretend_size;
2197
2198   else if (to == STACK_POINTER_REGNUM && from == FRAME_POINTER_REGNUM)
2199     ret = info->reg_offset[FRAME_POINTER_REGNUM];
2200
2201   else if (to == FRAME_POINTER_REGNUM && from == ARG_POINTER_REGNUM)
2202     ret = (info->total_size
2203            - info->reg_offset[FRAME_POINTER_REGNUM]
2204            - info->pretend_size);
2205
2206   else
2207     gcc_unreachable ();
2208
2209   if (TARGET_DEBUG_STACK)
2210     fprintf (stderr, "Eliminate %s to %s by adding %d\n",
2211              reg_names [from], reg_names[to], ret);
2212
2213   return ret;
2214 }
2215
2216 \f
2217 /* Worker function for TARGET_SETUP_INCOMING_VARARGS.  */
2218
2219 static void
2220 frv_setup_incoming_varargs (CUMULATIVE_ARGS *cum,
2221                             enum machine_mode mode,
2222                             tree type ATTRIBUTE_UNUSED,
2223                             int *pretend_size,
2224                             int second_time)
2225 {
2226   if (TARGET_DEBUG_ARG)
2227     fprintf (stderr,
2228              "setup_vararg: words = %2d, mode = %4s, pretend_size = %d, second_time = %d\n",
2229              *cum, GET_MODE_NAME (mode), *pretend_size, second_time);
2230 }
2231
2232 \f
2233 /* Worker function for TARGET_EXPAND_BUILTIN_SAVEREGS.  */
2234
2235 static rtx
2236 frv_expand_builtin_saveregs (void)
2237 {
2238   int offset = UNITS_PER_WORD * FRV_NUM_ARG_REGS;
2239
2240   if (TARGET_DEBUG_ARG)
2241     fprintf (stderr, "expand_builtin_saveregs: offset from ap = %d\n",
2242              offset);
2243
2244   return gen_rtx_PLUS (Pmode, virtual_incoming_args_rtx, GEN_INT (- offset));
2245 }
2246
2247 \f
2248 /* Expand __builtin_va_start to do the va_start macro.  */
2249
2250 static void
2251 frv_expand_builtin_va_start (tree valist, rtx nextarg)
2252 {
2253   tree t;
2254   int num = crtl->args.info - FIRST_ARG_REGNUM - FRV_NUM_ARG_REGS;
2255
2256   nextarg = gen_rtx_PLUS (Pmode, virtual_incoming_args_rtx,
2257                           GEN_INT (UNITS_PER_WORD * num));
2258
2259   if (TARGET_DEBUG_ARG)
2260     {
2261       fprintf (stderr, "va_start: args_info = %d, num = %d\n",
2262                crtl->args.info, num);
2263
2264       debug_rtx (nextarg);
2265     }
2266
2267   t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist,
2268               fold_convert (TREE_TYPE (valist),
2269                             make_tree (sizetype, nextarg)));
2270   TREE_SIDE_EFFECTS (t) = 1;
2271
2272   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
2273 }
2274
2275 \f
2276 /* Expand a block move operation, and return 1 if successful.  Return 0
2277    if we should let the compiler generate normal code.
2278
2279    operands[0] is the destination
2280    operands[1] is the source
2281    operands[2] is the length
2282    operands[3] is the alignment */
2283
2284 /* Maximum number of loads to do before doing the stores */
2285 #ifndef MAX_MOVE_REG
2286 #define MAX_MOVE_REG 4
2287 #endif
2288
2289 /* Maximum number of total loads to do.  */
2290 #ifndef TOTAL_MOVE_REG
2291 #define TOTAL_MOVE_REG 8
2292 #endif
2293
2294 int
2295 frv_expand_block_move (rtx operands[])
2296 {
2297   rtx orig_dest = operands[0];
2298   rtx orig_src  = operands[1];
2299   rtx bytes_rtx = operands[2];
2300   rtx align_rtx = operands[3];
2301   int constp    = (GET_CODE (bytes_rtx) == CONST_INT);
2302   int align;
2303   int bytes;
2304   int offset;
2305   int num_reg;
2306   int i;
2307   rtx src_reg;
2308   rtx dest_reg;
2309   rtx src_addr;
2310   rtx dest_addr;
2311   rtx src_mem;
2312   rtx dest_mem;
2313   rtx tmp_reg;
2314   rtx stores[MAX_MOVE_REG];
2315   int move_bytes;
2316   enum machine_mode mode;
2317
2318   /* If this is not a fixed size move, just call memcpy.  */
2319   if (! constp)
2320     return FALSE;
2321
2322   /* This should be a fixed size alignment.  */
2323   gcc_assert (GET_CODE (align_rtx) == CONST_INT);
2324
2325   align = INTVAL (align_rtx);
2326
2327   /* Anything to move? */
2328   bytes = INTVAL (bytes_rtx);
2329   if (bytes <= 0)
2330     return TRUE;
2331
2332   /* Don't support real large moves.  */
2333   if (bytes > TOTAL_MOVE_REG*align)
2334     return FALSE;
2335
2336   /* Move the address into scratch registers.  */
2337   dest_reg = copy_addr_to_reg (XEXP (orig_dest, 0));
2338   src_reg  = copy_addr_to_reg (XEXP (orig_src,  0));
2339
2340   num_reg = offset = 0;
2341   for ( ; bytes > 0; (bytes -= move_bytes), (offset += move_bytes))
2342     {
2343       /* Calculate the correct offset for src/dest.  */
2344       if (offset == 0)
2345         {
2346           src_addr  = src_reg;
2347           dest_addr = dest_reg;
2348         }
2349       else
2350         {
2351           src_addr = plus_constant (src_reg, offset);
2352           dest_addr = plus_constant (dest_reg, offset);
2353         }
2354
2355       /* Generate the appropriate load and store, saving the stores
2356          for later.  */
2357       if (bytes >= 4 && align >= 4)
2358         mode = SImode;
2359       else if (bytes >= 2 && align >= 2)
2360         mode = HImode;
2361       else
2362         mode = QImode;
2363
2364       move_bytes = GET_MODE_SIZE (mode);
2365       tmp_reg = gen_reg_rtx (mode);
2366       src_mem = change_address (orig_src, mode, src_addr);
2367       dest_mem = change_address (orig_dest, mode, dest_addr);
2368       emit_insn (gen_rtx_SET (VOIDmode, tmp_reg, src_mem));
2369       stores[num_reg++] = gen_rtx_SET (VOIDmode, dest_mem, tmp_reg);
2370
2371       if (num_reg >= MAX_MOVE_REG)
2372         {
2373           for (i = 0; i < num_reg; i++)
2374             emit_insn (stores[i]);
2375           num_reg = 0;
2376         }
2377     }
2378
2379   for (i = 0; i < num_reg; i++)
2380     emit_insn (stores[i]);
2381
2382   return TRUE;
2383 }
2384
2385 \f
2386 /* Expand a block clear operation, and return 1 if successful.  Return 0
2387    if we should let the compiler generate normal code.
2388
2389    operands[0] is the destination
2390    operands[1] is the length
2391    operands[3] is the alignment */
2392
2393 int
2394 frv_expand_block_clear (rtx operands[])
2395 {
2396   rtx orig_dest = operands[0];
2397   rtx bytes_rtx = operands[1];
2398   rtx align_rtx = operands[3];
2399   int constp    = (GET_CODE (bytes_rtx) == CONST_INT);
2400   int align;
2401   int bytes;
2402   int offset;
2403   int num_reg;
2404   rtx dest_reg;
2405   rtx dest_addr;
2406   rtx dest_mem;
2407   int clear_bytes;
2408   enum machine_mode mode;
2409
2410   /* If this is not a fixed size move, just call memcpy.  */
2411   if (! constp)
2412     return FALSE;
2413
2414   /* This should be a fixed size alignment.  */
2415   gcc_assert (GET_CODE (align_rtx) == CONST_INT);
2416
2417   align = INTVAL (align_rtx);
2418
2419   /* Anything to move? */
2420   bytes = INTVAL (bytes_rtx);
2421   if (bytes <= 0)
2422     return TRUE;
2423
2424   /* Don't support real large clears.  */
2425   if (bytes > TOTAL_MOVE_REG*align)
2426     return FALSE;
2427
2428   /* Move the address into a scratch register.  */
2429   dest_reg = copy_addr_to_reg (XEXP (orig_dest, 0));
2430
2431   num_reg = offset = 0;
2432   for ( ; bytes > 0; (bytes -= clear_bytes), (offset += clear_bytes))
2433     {
2434       /* Calculate the correct offset for src/dest.  */
2435       dest_addr = ((offset == 0)
2436                    ? dest_reg
2437                    : plus_constant (dest_reg, offset));
2438
2439       /* Generate the appropriate store of gr0.  */
2440       if (bytes >= 4 && align >= 4)
2441         mode = SImode;
2442       else if (bytes >= 2 && align >= 2)
2443         mode = HImode;
2444       else
2445         mode = QImode;
2446
2447       clear_bytes = GET_MODE_SIZE (mode);
2448       dest_mem = change_address (orig_dest, mode, dest_addr);
2449       emit_insn (gen_rtx_SET (VOIDmode, dest_mem, const0_rtx));
2450     }
2451
2452   return TRUE;
2453 }
2454
2455 \f
2456 /* The following variable is used to output modifiers of assembler
2457    code of the current output insn.  */
2458
2459 static rtx *frv_insn_operands;
2460
2461 /* The following function is used to add assembler insn code suffix .p
2462    if it is necessary.  */
2463
2464 const char *
2465 frv_asm_output_opcode (FILE *f, const char *ptr)
2466 {
2467   int c;
2468
2469   if (frv_insn_packing_flag <= 0)
2470     return ptr;
2471
2472   for (; *ptr && *ptr != ' ' && *ptr != '\t';)
2473     {
2474       c = *ptr++;
2475       if (c == '%' && ((*ptr >= 'a' && *ptr <= 'z')
2476                        || (*ptr >= 'A' && *ptr <= 'Z')))
2477         {
2478           int letter = *ptr++;
2479
2480           c = atoi (ptr);
2481           frv_print_operand (f, frv_insn_operands [c], letter);
2482           while ((c = *ptr) >= '0' && c <= '9')
2483             ptr++;
2484         }
2485       else
2486         fputc (c, f);
2487     }
2488
2489   fprintf (f, ".p");
2490
2491   return ptr;
2492 }
2493
2494 /* Set up the packing bit for the current output insn.  Note that this
2495    function is not called for asm insns.  */
2496
2497 void
2498 frv_final_prescan_insn (rtx insn, rtx *opvec,
2499                         int noperands ATTRIBUTE_UNUSED)
2500 {
2501   if (INSN_P (insn))
2502     {
2503       if (frv_insn_packing_flag >= 0)
2504         {
2505           frv_insn_operands = opvec;
2506           frv_insn_packing_flag = PACKING_FLAG_P (insn);
2507         }
2508       else if (recog_memoized (insn) >= 0
2509                && get_attr_acc_group (insn) == ACC_GROUP_ODD)
2510         /* Packing optimizations have been disabled, but INSN can only
2511            be issued in M1.  Insert an mnop in M0.  */
2512         fprintf (asm_out_file, "\tmnop.p\n");
2513     }
2514 }
2515
2516
2517 \f
2518 /* A C expression whose value is RTL representing the address in a stack frame
2519    where the pointer to the caller's frame is stored.  Assume that FRAMEADDR is
2520    an RTL expression for the address of the stack frame itself.
2521
2522    If you don't define this macro, the default is to return the value of
2523    FRAMEADDR--that is, the stack frame address is also the address of the stack
2524    word that points to the previous frame.  */
2525
2526 /* The default is correct, but we need to make sure the frame gets created.  */
2527 rtx
2528 frv_dynamic_chain_address (rtx frame)
2529 {
2530   cfun->machine->frame_needed = 1;
2531   return frame;
2532 }
2533
2534
2535 /* A C expression whose value is RTL representing the value of the return
2536    address for the frame COUNT steps up from the current frame, after the
2537    prologue.  FRAMEADDR is the frame pointer of the COUNT frame, or the frame
2538    pointer of the COUNT - 1 frame if `RETURN_ADDR_IN_PREVIOUS_FRAME' is
2539    defined.
2540
2541    The value of the expression must always be the correct address when COUNT is
2542    zero, but may be `NULL_RTX' if there is not way to determine the return
2543    address of other frames.  */
2544
2545 rtx
2546 frv_return_addr_rtx (int count, rtx frame)
2547 {
2548   if (count != 0)
2549     return const0_rtx;
2550   cfun->machine->frame_needed = 1;
2551   return gen_rtx_MEM (Pmode, plus_constant (frame, 8));
2552 }
2553
2554 /* Given a memory reference MEMREF, interpret the referenced memory as
2555    an array of MODE values, and return a reference to the element
2556    specified by INDEX.  Assume that any pre-modification implicit in
2557    MEMREF has already happened.
2558
2559    MEMREF must be a legitimate operand for modes larger than SImode.
2560    frv_legitimate_address_p forbids register+register addresses, which
2561    this function cannot handle.  */
2562 rtx
2563 frv_index_memory (rtx memref, enum machine_mode mode, int index)
2564 {
2565   rtx base = XEXP (memref, 0);
2566   if (GET_CODE (base) == PRE_MODIFY)
2567     base = XEXP (base, 0);
2568   return change_address (memref, mode,
2569                          plus_constant (base, index * GET_MODE_SIZE (mode)));
2570 }
2571
2572 \f
2573 /* Print a memory address as an operand to reference that memory location.  */
2574 static void
2575 frv_print_operand_address (FILE * stream, rtx x)
2576 {
2577   if (GET_CODE (x) == MEM)
2578     x = XEXP (x, 0);
2579
2580   switch (GET_CODE (x))
2581     {
2582     case REG:
2583       fputs (reg_names [ REGNO (x)], stream);
2584       return;
2585
2586     case CONST_INT:
2587       fprintf (stream, "%ld", (long) INTVAL (x));
2588       return;
2589
2590     case SYMBOL_REF:
2591       assemble_name (stream, XSTR (x, 0));
2592       return;
2593
2594     case LABEL_REF:
2595     case CONST:
2596       output_addr_const (stream, x);
2597       return;
2598
2599     case PLUS:
2600       /* Poorly constructed asm statements can trigger this alternative.
2601          See gcc/testsuite/gcc.dg/asm-4.c for an example.  */
2602       frv_print_operand_memory_reference (stream, x, 0);
2603       return;
2604
2605     default:
2606       break;
2607     }
2608
2609   fatal_insn ("bad insn to frv_print_operand_address:", x);
2610 }
2611
2612 \f
2613 static void
2614 frv_print_operand_memory_reference_reg (FILE * stream, rtx x)
2615 {
2616   int regno = true_regnum (x);
2617   if (GPR_P (regno))
2618     fputs (reg_names[regno], stream);
2619   else
2620     fatal_insn ("bad register to frv_print_operand_memory_reference_reg:", x);
2621 }
2622
2623 /* Print a memory reference suitable for the ld/st instructions.  */
2624
2625 static void
2626 frv_print_operand_memory_reference (FILE * stream, rtx x, int addr_offset)
2627 {
2628   struct frv_unspec unspec;
2629   rtx x0 = NULL_RTX;
2630   rtx x1 = NULL_RTX;
2631
2632   switch (GET_CODE (x))
2633     {
2634     case SUBREG:
2635     case REG:
2636       x0 = x;
2637       break;
2638
2639     case PRE_MODIFY:            /* (pre_modify (reg) (plus (reg) (reg))) */
2640       x0 = XEXP (x, 0);
2641       x1 = XEXP (XEXP (x, 1), 1);
2642       break;
2643
2644     case CONST_INT:
2645       x1 = x;
2646       break;
2647
2648     case PLUS:
2649       x0 = XEXP (x, 0);
2650       x1 = XEXP (x, 1);
2651       if (GET_CODE (x0) == CONST_INT)
2652         {
2653           x0 = XEXP (x, 1);
2654           x1 = XEXP (x, 0);
2655         }
2656       break;
2657
2658     default:
2659       fatal_insn ("bad insn to frv_print_operand_memory_reference:", x);
2660       break;
2661
2662     }
2663
2664   if (addr_offset)
2665     {
2666       if (!x1)
2667         x1 = const0_rtx;
2668       else if (GET_CODE (x1) != CONST_INT)
2669         fatal_insn ("bad insn to frv_print_operand_memory_reference:", x);
2670     }
2671
2672   fputs ("@(", stream);
2673   if (!x0)
2674     fputs (reg_names[GPR_R0], stream);
2675   else if (GET_CODE (x0) == REG || GET_CODE (x0) == SUBREG)
2676     frv_print_operand_memory_reference_reg (stream, x0);
2677   else
2678     fatal_insn ("bad insn to frv_print_operand_memory_reference:", x);
2679
2680   fputs (",", stream);
2681   if (!x1)
2682     fputs (reg_names [GPR_R0], stream);
2683
2684   else
2685     {
2686       switch (GET_CODE (x1))
2687         {
2688         case SUBREG:
2689         case REG:
2690           frv_print_operand_memory_reference_reg (stream, x1);
2691           break;
2692
2693         case CONST_INT:
2694           fprintf (stream, "%ld", (long) (INTVAL (x1) + addr_offset));
2695           break;
2696
2697         case CONST:
2698           if (!frv_const_unspec_p (x1, &unspec))
2699             fatal_insn ("bad insn to frv_print_operand_memory_reference:", x1);
2700           frv_output_const_unspec (stream, &unspec);
2701           break;
2702
2703         default:
2704           fatal_insn ("bad insn to frv_print_operand_memory_reference:", x);
2705         }
2706     }
2707
2708   fputs (")", stream);
2709 }
2710
2711 \f
2712 /* Return 2 for likely branches and 0 for non-likely branches  */
2713
2714 #define FRV_JUMP_LIKELY 2
2715 #define FRV_JUMP_NOT_LIKELY 0
2716
2717 static int
2718 frv_print_operand_jump_hint (rtx insn)
2719 {
2720   rtx note;
2721   rtx labelref;
2722   int ret;
2723   HOST_WIDE_INT prob = -1;
2724   enum { UNKNOWN, BACKWARD, FORWARD } jump_type = UNKNOWN;
2725
2726   gcc_assert (GET_CODE (insn) == JUMP_INSN);
2727
2728   /* Assume any non-conditional jump is likely.  */
2729   if (! any_condjump_p (insn))
2730     ret = FRV_JUMP_LIKELY;
2731
2732   else
2733     {
2734       labelref = condjump_label (insn);
2735       if (labelref)
2736         {
2737           rtx label = XEXP (labelref, 0);
2738           jump_type = (insn_current_address > INSN_ADDRESSES (INSN_UID (label))
2739                        ? BACKWARD
2740                        : FORWARD);
2741         }
2742
2743       note = find_reg_note (insn, REG_BR_PROB, 0);
2744       if (!note)
2745         ret = ((jump_type == BACKWARD) ? FRV_JUMP_LIKELY : FRV_JUMP_NOT_LIKELY);
2746
2747       else
2748         {
2749           prob = INTVAL (XEXP (note, 0));
2750           ret = ((prob >= (REG_BR_PROB_BASE / 2))
2751                  ? FRV_JUMP_LIKELY
2752                  : FRV_JUMP_NOT_LIKELY);
2753         }
2754     }
2755
2756 #if 0
2757   if (TARGET_DEBUG)
2758     {
2759       char *direction;
2760
2761       switch (jump_type)
2762         {
2763         default:
2764         case UNKNOWN:   direction = "unknown jump direction";   break;
2765         case BACKWARD:  direction = "jump backward";            break;
2766         case FORWARD:   direction = "jump forward";             break;
2767         }
2768
2769       fprintf (stderr,
2770                "%s: uid %ld, %s, probability = %ld, max prob. = %ld, hint = %d\n",
2771                IDENTIFIER_POINTER (DECL_NAME (current_function_decl)),
2772                (long)INSN_UID (insn), direction, (long)prob,
2773                (long)REG_BR_PROB_BASE, ret);
2774     }
2775 #endif
2776
2777   return ret;
2778 }
2779
2780 \f
2781 /* Return the comparison operator to use for CODE given that the ICC
2782    register is OP0.  */
2783
2784 static const char *
2785 comparison_string (enum rtx_code code, rtx op0)
2786 {
2787   bool is_nz_p = GET_MODE (op0) == CC_NZmode;
2788   switch (code)
2789     {
2790     default:  output_operand_lossage ("bad condition code");
2791     case EQ:  return "eq";
2792     case NE:  return "ne";
2793     case LT:  return is_nz_p ? "n" : "lt";
2794     case LE:  return "le";
2795     case GT:  return "gt";
2796     case GE:  return is_nz_p ? "p" : "ge";
2797     case LTU: return is_nz_p ? "no" : "c";
2798     case LEU: return is_nz_p ? "eq" : "ls";
2799     case GTU: return is_nz_p ? "ne" : "hi";
2800     case GEU: return is_nz_p ? "ra" : "nc";
2801     }
2802 }
2803
2804 /* Print an operand to an assembler instruction.
2805
2806    `%' followed by a letter and a digit says to output an operand in an
2807    alternate fashion.  Four letters have standard, built-in meanings
2808    described below.  The hook `TARGET_PRINT_OPERAND' can define
2809    additional letters with nonstandard meanings.
2810
2811    `%cDIGIT' can be used to substitute an operand that is a constant value
2812    without the syntax that normally indicates an immediate operand.
2813
2814    `%nDIGIT' is like `%cDIGIT' except that the value of the constant is negated
2815    before printing.
2816
2817    `%aDIGIT' can be used to substitute an operand as if it were a memory
2818    reference, with the actual operand treated as the address.  This may be
2819    useful when outputting a "load address" instruction, because often the
2820    assembler syntax for such an instruction requires you to write the operand
2821    as if it were a memory reference.
2822
2823    `%lDIGIT' is used to substitute a `label_ref' into a jump instruction.
2824
2825    `%=' outputs a number which is unique to each instruction in the entire
2826    compilation.  This is useful for making local labels to be referred to more
2827    than once in a single template that generates multiple assembler
2828    instructions.
2829
2830    `%' followed by a punctuation character specifies a substitution that
2831    does not use an operand.  Only one case is standard: `%%' outputs a
2832    `%' into the assembler code.  Other nonstandard cases can be defined
2833    in the `TARGET_PRINT_OPERAND' hook.  You must also define which
2834    punctuation characters are valid with the
2835    `TARGET_PRINT_OPERAND_PUNCT_VALID_P' hook.  */
2836
2837 static void
2838 frv_print_operand (FILE * file, rtx x, int code)
2839 {
2840   struct frv_unspec unspec;
2841   HOST_WIDE_INT value;
2842   int offset;
2843
2844   if (code != 0 && !ISALPHA (code))
2845     value = 0;
2846
2847   else if (GET_CODE (x) == CONST_INT)
2848     value = INTVAL (x);
2849
2850   else if (GET_CODE (x) == CONST_DOUBLE)
2851     {
2852       if (GET_MODE (x) == SFmode)
2853         {
2854           REAL_VALUE_TYPE rv;
2855           long l;
2856
2857           REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
2858           REAL_VALUE_TO_TARGET_SINGLE (rv, l);
2859           value = l;
2860         }
2861
2862       else if (GET_MODE (x) == VOIDmode)
2863         value = CONST_DOUBLE_LOW (x);
2864
2865       else
2866         fatal_insn ("bad insn in frv_print_operand, bad const_double", x);
2867     }
2868
2869   else
2870     value = 0;
2871
2872   switch (code)
2873     {
2874
2875     case '.':
2876       /* Output r0.  */
2877       fputs (reg_names[GPR_R0], file);
2878       break;
2879
2880     case '#':
2881       fprintf (file, "%d", frv_print_operand_jump_hint (current_output_insn));
2882       break;
2883
2884     case '@':
2885       /* Output small data area base register (gr16).  */
2886       fputs (reg_names[SDA_BASE_REG], file);
2887       break;
2888
2889     case '~':
2890       /* Output pic register (gr17).  */
2891       fputs (reg_names[PIC_REGNO], file);
2892       break;
2893
2894     case '*':
2895       /* Output the temporary integer CCR register.  */
2896       fputs (reg_names[ICR_TEMP], file);
2897       break;
2898
2899     case '&':
2900       /* Output the temporary integer CC register.  */
2901       fputs (reg_names[ICC_TEMP], file);
2902       break;
2903
2904     /* case 'a': print an address.  */
2905
2906     case 'C':
2907       /* Print appropriate test for integer branch false operation.  */
2908       fputs (comparison_string (reverse_condition (GET_CODE (x)),
2909                                 XEXP (x, 0)), file);
2910       break;
2911
2912     case 'c':
2913       /* Print appropriate test for integer branch true operation.  */
2914       fputs (comparison_string (GET_CODE (x), XEXP (x, 0)), file);
2915       break;
2916
2917     case 'e':
2918       /* Print 1 for a NE and 0 for an EQ to give the final argument
2919          for a conditional instruction.  */
2920       if (GET_CODE (x) == NE)
2921         fputs ("1", file);
2922
2923       else if (GET_CODE (x) == EQ)
2924         fputs ("0", file);
2925
2926       else
2927         fatal_insn ("bad insn to frv_print_operand, 'e' modifier:", x);
2928       break;
2929
2930     case 'F':
2931       /* Print appropriate test for floating point branch false operation.  */
2932       switch (GET_CODE (x))
2933         {
2934         default:
2935           fatal_insn ("bad insn to frv_print_operand, 'F' modifier:", x);
2936
2937         case EQ:  fputs ("ne",  file); break;
2938         case NE:  fputs ("eq",  file); break;
2939         case LT:  fputs ("uge", file); break;
2940         case LE:  fputs ("ug",  file); break;
2941         case GT:  fputs ("ule", file); break;
2942         case GE:  fputs ("ul",  file); break;
2943         }
2944       break;
2945
2946     case 'f':
2947       /* Print appropriate test for floating point branch true operation.  */
2948       switch (GET_CODE (x))
2949         {
2950         default:
2951           fatal_insn ("bad insn to frv_print_operand, 'f' modifier:", x);
2952
2953         case EQ:  fputs ("eq",  file); break;
2954         case NE:  fputs ("ne",  file); break;
2955         case LT:  fputs ("lt",  file); break;
2956         case LE:  fputs ("le",  file); break;
2957         case GT:  fputs ("gt",  file); break;
2958         case GE:  fputs ("ge",  file); break;
2959         }
2960       break;
2961
2962     case 'g':
2963       /* Print appropriate GOT function.  */
2964       if (GET_CODE (x) != CONST_INT)
2965         fatal_insn ("bad insn to frv_print_operand, 'g' modifier:", x);
2966       fputs (unspec_got_name (INTVAL (x)), file);
2967       break;
2968
2969     case 'I':
2970       /* Print 'i' if the operand is a constant, or is a memory reference that
2971          adds a constant.  */
2972       if (GET_CODE (x) == MEM)
2973         x = ((GET_CODE (XEXP (x, 0)) == PLUS)
2974              ? XEXP (XEXP (x, 0), 1)
2975              : XEXP (x, 0));
2976       else if (GET_CODE (x) == PLUS)
2977         x = XEXP (x, 1);
2978
2979       switch (GET_CODE (x))
2980         {
2981         default:
2982           break;
2983
2984         case CONST_INT:
2985         case SYMBOL_REF:
2986         case CONST:
2987           fputs ("i", file);
2988           break;
2989         }
2990       break;
2991
2992     case 'i':
2993       /* For jump instructions, print 'i' if the operand is a constant or
2994          is an expression that adds a constant.  */
2995       if (GET_CODE (x) == CONST_INT)
2996         fputs ("i", file);
2997
2998       else
2999         {
3000           if (GET_CODE (x) == CONST_INT
3001               || (GET_CODE (x) == PLUS
3002                   && (GET_CODE (XEXP (x, 1)) == CONST_INT
3003                       || GET_CODE (XEXP (x, 0)) == CONST_INT)))
3004             fputs ("i", file);
3005         }
3006       break;
3007
3008     case 'L':
3009       /* Print the lower register of a double word register pair */
3010       if (GET_CODE (x) == REG)
3011         fputs (reg_names[ REGNO (x)+1 ], file);
3012       else
3013         fatal_insn ("bad insn to frv_print_operand, 'L' modifier:", x);
3014       break;
3015
3016     /* case 'l': print a LABEL_REF.  */
3017
3018     case 'M':
3019     case 'N':
3020       /* Print a memory reference for ld/st/jmp, %N prints a memory reference
3021          for the second word of double memory operations.  */
3022       offset = (code == 'M') ? 0 : UNITS_PER_WORD;
3023       switch (GET_CODE (x))
3024         {
3025         default:
3026           fatal_insn ("bad insn to frv_print_operand, 'M/N' modifier:", x);
3027
3028         case MEM:
3029           frv_print_operand_memory_reference (file, XEXP (x, 0), offset);
3030           break;
3031
3032         case REG:
3033         case SUBREG:
3034         case CONST_INT:
3035         case PLUS:
3036         case SYMBOL_REF:
3037           frv_print_operand_memory_reference (file, x, offset);
3038           break;
3039         }
3040       break;
3041
3042     case 'O':
3043       /* Print the opcode of a command.  */
3044       switch (GET_CODE (x))
3045         {
3046         default:
3047           fatal_insn ("bad insn to frv_print_operand, 'O' modifier:", x);
3048
3049         case PLUS:     fputs ("add", file); break;
3050         case MINUS:    fputs ("sub", file); break;
3051         case AND:      fputs ("and", file); break;
3052         case IOR:      fputs ("or",  file); break;
3053         case XOR:      fputs ("xor", file); break;
3054         case ASHIFT:   fputs ("sll", file); break;
3055         case ASHIFTRT: fputs ("sra", file); break;
3056         case LSHIFTRT: fputs ("srl", file); break;
3057         }
3058       break;
3059
3060     /* case 'n': negate and print a constant int.  */
3061
3062     case 'P':
3063       /* Print PIC label using operand as the number.  */
3064       if (GET_CODE (x) != CONST_INT)
3065         fatal_insn ("bad insn to frv_print_operand, P modifier:", x);
3066
3067       fprintf (file, ".LCF%ld", (long)INTVAL (x));
3068       break;
3069
3070     case 'U':
3071       /* Print 'u' if the operand is a update load/store.  */
3072       if (GET_CODE (x) == MEM && GET_CODE (XEXP (x, 0)) == PRE_MODIFY)
3073         fputs ("u", file);
3074       break;
3075
3076     case 'z':
3077       /* If value is 0, print gr0, otherwise it must be a register.  */
3078       if (GET_CODE (x) == CONST_INT && INTVAL (x) == 0)
3079         fputs (reg_names[GPR_R0], file);
3080
3081       else if (GET_CODE (x) == REG)
3082         fputs (reg_names [REGNO (x)], file);
3083
3084       else
3085         fatal_insn ("bad insn in frv_print_operand, z case", x);
3086       break;
3087
3088     case 'x':
3089       /* Print constant in hex.  */
3090       if (GET_CODE (x) == CONST_INT || GET_CODE (x) == CONST_DOUBLE)
3091         {
3092           fprintf (file, "%s0x%.4lx", IMMEDIATE_PREFIX, (long) value);
3093           break;
3094         }
3095
3096       /* Fall through.  */
3097
3098     case '\0':
3099       if (GET_CODE (x) == REG)
3100         fputs (reg_names [REGNO (x)], file);
3101
3102       else if (GET_CODE (x) == CONST_INT
3103               || GET_CODE (x) == CONST_DOUBLE)
3104         fprintf (file, "%s%ld", IMMEDIATE_PREFIX, (long) value);
3105
3106       else if (frv_const_unspec_p (x, &unspec))
3107         frv_output_const_unspec (file, &unspec);
3108
3109       else if (GET_CODE (x) == MEM)
3110         frv_print_operand_address (file, XEXP (x, 0));
3111
3112       else if (CONSTANT_ADDRESS_P (x))
3113         frv_print_operand_address (file, x);
3114
3115       else
3116         fatal_insn ("bad insn in frv_print_operand, 0 case", x);
3117
3118       break;
3119
3120     default:
3121       fatal_insn ("frv_print_operand: unknown code", x);
3122       break;
3123     }
3124
3125   return;
3126 }
3127
3128 static bool
3129 frv_print_operand_punct_valid_p (unsigned char code)
3130 {
3131   return (code == '.' || code == '#' || code == '@' || code == '~'
3132           || code == '*' || code == '&');
3133 }
3134
3135 \f
3136 /* A C statement (sans semicolon) for initializing the variable CUM for the
3137    state at the beginning of the argument list.  The variable has type
3138    `CUMULATIVE_ARGS'.  The value of FNTYPE is the tree node for the data type
3139    of the function which will receive the args, or 0 if the args are to a
3140    compiler support library function.  The value of INDIRECT is nonzero when
3141    processing an indirect call, for example a call through a function pointer.
3142    The value of INDIRECT is zero for a call to an explicitly named function, a
3143    library function call, or when `INIT_CUMULATIVE_ARGS' is used to find
3144    arguments for the function being compiled.
3145
3146    When processing a call to a compiler support library function, LIBNAME
3147    identifies which one.  It is a `symbol_ref' rtx which contains the name of
3148    the function, as a string.  LIBNAME is 0 when an ordinary C function call is
3149    being processed.  Thus, each time this macro is called, either LIBNAME or
3150    FNTYPE is nonzero, but never both of them at once.  */
3151
3152 void
3153 frv_init_cumulative_args (CUMULATIVE_ARGS *cum,
3154                           tree fntype,
3155                           rtx libname,
3156                           tree fndecl,
3157                           int incoming)
3158 {
3159   *cum = FIRST_ARG_REGNUM;
3160
3161   if (TARGET_DEBUG_ARG)
3162     {
3163       fprintf (stderr, "\ninit_cumulative_args:");
3164       if (!fndecl && fntype)
3165         fputs (" indirect", stderr);
3166
3167       if (incoming)
3168         fputs (" incoming", stderr);
3169
3170       if (fntype)
3171         {
3172           tree ret_type = TREE_TYPE (fntype);
3173           fprintf (stderr, " return=%s,",
3174                    tree_code_name[ (int)TREE_CODE (ret_type) ]);
3175         }
3176
3177       if (libname && GET_CODE (libname) == SYMBOL_REF)
3178         fprintf (stderr, " libname=%s", XSTR (libname, 0));
3179
3180       if (cfun->returns_struct)
3181         fprintf (stderr, " return-struct");
3182
3183       putc ('\n', stderr);
3184     }
3185 }
3186
3187 \f
3188 /* Return true if we should pass an argument on the stack rather than
3189    in registers.  */
3190
3191 static bool
3192 frv_must_pass_in_stack (enum machine_mode mode, const_tree type)
3193 {
3194   if (mode == BLKmode)
3195     return true;
3196   if (type == NULL)
3197     return false;
3198   return AGGREGATE_TYPE_P (type);
3199 }
3200
3201 /* If defined, a C expression that gives the alignment boundary, in bits, of an
3202    argument with the specified mode and type.  If it is not defined,
3203    `PARM_BOUNDARY' is used for all arguments.  */
3204
3205 int
3206 frv_function_arg_boundary (enum machine_mode mode ATTRIBUTE_UNUSED,
3207                            tree type ATTRIBUTE_UNUSED)
3208 {
3209   return BITS_PER_WORD;
3210 }
3211
3212 rtx
3213 frv_function_arg (CUMULATIVE_ARGS *cum,
3214                   enum machine_mode mode,
3215                   tree type ATTRIBUTE_UNUSED,
3216                   int named,
3217                   int incoming ATTRIBUTE_UNUSED)
3218 {
3219   enum machine_mode xmode = (mode == BLKmode) ? SImode : mode;
3220   int arg_num = *cum;
3221   rtx ret;
3222   const char *debstr;
3223
3224   /* Return a marker for use in the call instruction.  */
3225   if (xmode == VOIDmode)
3226     {
3227       ret = const0_rtx;
3228       debstr = "<0>";
3229     }
3230
3231   else if (arg_num <= LAST_ARG_REGNUM)
3232     {
3233       ret = gen_rtx_REG (xmode, arg_num);
3234       debstr = reg_names[arg_num];
3235     }
3236
3237   else
3238     {
3239       ret = NULL_RTX;
3240       debstr = "memory";
3241     }
3242
3243   if (TARGET_DEBUG_ARG)
3244     fprintf (stderr,
3245              "function_arg: words = %2d, mode = %4s, named = %d, size = %3d, arg = %s\n",
3246              arg_num, GET_MODE_NAME (mode), named, GET_MODE_SIZE (mode), debstr);
3247
3248   return ret;
3249 }
3250
3251 \f
3252 /* A C statement (sans semicolon) to update the summarizer variable CUM to
3253    advance past an argument in the argument list.  The values MODE, TYPE and
3254    NAMED describe that argument.  Once this is done, the variable CUM is
3255    suitable for analyzing the *following* argument with `FUNCTION_ARG', etc.
3256
3257    This macro need not do anything if the argument in question was passed on
3258    the stack.  The compiler knows how to track the amount of stack space used
3259    for arguments without any special help.  */
3260
3261 void
3262 frv_function_arg_advance (CUMULATIVE_ARGS *cum,
3263                           enum machine_mode mode,
3264                           tree type ATTRIBUTE_UNUSED,
3265                           int named)
3266 {
3267   enum machine_mode xmode = (mode == BLKmode) ? SImode : mode;
3268   int bytes = GET_MODE_SIZE (xmode);
3269   int words = (bytes + UNITS_PER_WORD  - 1) / UNITS_PER_WORD;
3270   int arg_num = *cum;
3271
3272   *cum = arg_num + words;
3273
3274   if (TARGET_DEBUG_ARG)
3275     fprintf (stderr,
3276              "function_adv: words = %2d, mode = %4s, named = %d, size = %3d\n",
3277              arg_num, GET_MODE_NAME (mode), named, words * UNITS_PER_WORD);
3278 }
3279
3280 \f
3281 /* A C expression for the number of words, at the beginning of an argument,
3282    must be put in registers.  The value must be zero for arguments that are
3283    passed entirely in registers or that are entirely pushed on the stack.
3284
3285    On some machines, certain arguments must be passed partially in registers
3286    and partially in memory.  On these machines, typically the first N words of
3287    arguments are passed in registers, and the rest on the stack.  If a
3288    multi-word argument (a `double' or a structure) crosses that boundary, its
3289    first few words must be passed in registers and the rest must be pushed.
3290    This macro tells the compiler when this occurs, and how many of the words
3291    should go in registers.
3292
3293    `FUNCTION_ARG' for these arguments should return the first register to be
3294    used by the caller for this argument; likewise `FUNCTION_INCOMING_ARG', for
3295    the called function.  */
3296
3297 static int
3298 frv_arg_partial_bytes (CUMULATIVE_ARGS *cum, enum machine_mode mode,
3299                        tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
3300 {
3301   enum machine_mode xmode = (mode == BLKmode) ? SImode : mode;
3302   int bytes = GET_MODE_SIZE (xmode);
3303   int words = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
3304   int arg_num = *cum;
3305   int ret;
3306
3307   ret = ((arg_num <= LAST_ARG_REGNUM && arg_num + words > LAST_ARG_REGNUM+1)
3308          ? LAST_ARG_REGNUM - arg_num + 1
3309          : 0);
3310   ret *= UNITS_PER_WORD;
3311
3312   if (TARGET_DEBUG_ARG && ret)
3313     fprintf (stderr, "frv_arg_partial_bytes: %d\n", ret);
3314
3315   return ret;
3316 }
3317
3318 \f
3319 /* Implements TARGET_FUNCTION_VALUE.  */
3320
3321 static rtx
3322 frv_function_value (const_tree valtype,
3323                     const_tree fn_decl_or_type ATTRIBUTE_UNUSED,
3324                     bool outgoing ATTRIBUTE_UNUSED)
3325 {
3326   return gen_rtx_REG (TYPE_MODE (valtype), RETURN_VALUE_REGNUM);
3327 }
3328
3329 \f
3330 /* Implements TARGET_LIBCALL_VALUE.  */
3331
3332 static rtx
3333 frv_libcall_value (enum machine_mode mode,
3334                    const_rtx fun ATTRIBUTE_UNUSED)
3335 {
3336   return gen_rtx_REG (mode, RETURN_VALUE_REGNUM);
3337 }
3338
3339 \f
3340 /* Implements FUNCTION_VALUE_REGNO_P.  */
3341
3342 bool
3343 frv_function_value_regno_p (const unsigned int regno)
3344 {
3345   return (regno == RETURN_VALUE_REGNUM);
3346 }
3347 \f
3348 /* Return true if a register is ok to use as a base or index register.  */
3349
3350 static FRV_INLINE int
3351 frv_regno_ok_for_base_p (int regno, int strict_p)
3352 {
3353   if (GPR_P (regno))
3354     return TRUE;
3355
3356   if (strict_p)
3357     return (reg_renumber[regno] >= 0 && GPR_P (reg_renumber[regno]));
3358
3359   if (regno == ARG_POINTER_REGNUM)
3360     return TRUE;
3361
3362   return (regno >= FIRST_PSEUDO_REGISTER);
3363 }
3364
3365 \f
3366 /* A C compound statement with a conditional `goto LABEL;' executed if X (an
3367    RTX) is a legitimate memory address on the target machine for a memory
3368    operand of mode MODE.
3369
3370    It usually pays to define several simpler macros to serve as subroutines for
3371    this one.  Otherwise it may be too complicated to understand.
3372
3373    This macro must exist in two variants: a strict variant and a non-strict
3374    one.  The strict variant is used in the reload pass.  It must be defined so
3375    that any pseudo-register that has not been allocated a hard register is
3376    considered a memory reference.  In contexts where some kind of register is
3377    required, a pseudo-register with no hard register must be rejected.
3378
3379    The non-strict variant is used in other passes.  It must be defined to
3380    accept all pseudo-registers in every context where some kind of register is
3381    required.
3382
3383    Compiler source files that want to use the strict variant of this macro
3384    define the macro `REG_OK_STRICT'.  You should use an `#ifdef REG_OK_STRICT'
3385    conditional to define the strict variant in that case and the non-strict
3386    variant otherwise.
3387
3388    Normally, constant addresses which are the sum of a `symbol_ref' and an
3389    integer are stored inside a `const' RTX to mark them as constant.
3390    Therefore, there is no need to recognize such sums specifically as
3391    legitimate addresses.  Normally you would simply recognize any `const' as
3392    legitimate.
3393
3394    Usually `TARGET_PRINT_OPERAND_ADDRESS' is not prepared to handle
3395    constant sums that are not marked with `const'.  It assumes that a
3396    naked `plus' indicates indexing.  If so, then you *must* reject such
3397    naked constant sums as illegitimate addresses, so that none of them
3398    will be given to `TARGET_PRINT_OPERAND_ADDRESS'.  */
3399
3400 int
3401 frv_legitimate_address_p_1 (enum machine_mode mode,
3402                             rtx x,
3403                             int strict_p,
3404                             int condexec_p,
3405                             int allow_double_reg_p)
3406 {
3407   rtx x0, x1;
3408   int ret = 0;
3409   HOST_WIDE_INT value;
3410   unsigned regno0;
3411
3412   if (FRV_SYMBOL_REF_TLS_P (x))
3413     return 0;
3414
3415   switch (GET_CODE (x))
3416     {
3417     default:
3418       break;
3419
3420     case SUBREG:
3421       x = SUBREG_REG (x);
3422       if (GET_CODE (x) != REG)
3423         break;
3424
3425       /* Fall through.  */
3426
3427     case REG:
3428       ret = frv_regno_ok_for_base_p (REGNO (x), strict_p);
3429       break;
3430
3431     case PRE_MODIFY:
3432       x0 = XEXP (x, 0);
3433       x1 = XEXP (x, 1);
3434       if (GET_CODE (x0) != REG
3435           || ! frv_regno_ok_for_base_p (REGNO (x0), strict_p)
3436           || GET_CODE (x1) != PLUS
3437           || ! rtx_equal_p (x0, XEXP (x1, 0))
3438           || GET_CODE (XEXP (x1, 1)) != REG
3439           || ! frv_regno_ok_for_base_p (REGNO (XEXP (x1, 1)), strict_p))
3440         break;
3441
3442       ret = 1;
3443       break;
3444
3445     case CONST_INT:
3446       /* 12-bit immediate */
3447       if (condexec_p)
3448         ret = FALSE;
3449       else
3450         {
3451           ret = IN_RANGE_P (INTVAL (x), -2048, 2047);
3452
3453           /* If we can't use load/store double operations, make sure we can
3454              address the second word.  */
3455           if (ret && GET_MODE_SIZE (mode) > UNITS_PER_WORD)
3456             ret = IN_RANGE_P (INTVAL (x) + GET_MODE_SIZE (mode) - 1,
3457                               -2048, 2047);
3458         }
3459       break;
3460
3461     case PLUS:
3462       x0 = XEXP (x, 0);
3463       x1 = XEXP (x, 1);
3464
3465       if (GET_CODE (x0) == SUBREG)
3466         x0 = SUBREG_REG (x0);
3467
3468       if (GET_CODE (x0) != REG)
3469         break;
3470
3471       regno0 = REGNO (x0);
3472       if (!frv_regno_ok_for_base_p (regno0, strict_p))
3473         break;
3474
3475       switch (GET_CODE (x1))
3476         {
3477         default:
3478           break;
3479
3480         case SUBREG:
3481           x1 = SUBREG_REG (x1);
3482           if (GET_CODE (x1) != REG)
3483             break;
3484
3485           /* Fall through.  */
3486
3487         case REG:
3488           /* Do not allow reg+reg addressing for modes > 1 word if we
3489              can't depend on having move double instructions.  */
3490           if (!allow_double_reg_p && GET_MODE_SIZE (mode) > UNITS_PER_WORD)
3491             ret = FALSE;
3492           else
3493             ret = frv_regno_ok_for_base_p (REGNO (x1), strict_p);
3494           break;
3495
3496         case CONST_INT:
3497           /* 12-bit immediate */
3498           if (condexec_p)
3499             ret = FALSE;
3500           else
3501             {
3502               value = INTVAL (x1);
3503               ret = IN_RANGE_P (value, -2048, 2047);
3504
3505               /* If we can't use load/store double operations, make sure we can
3506                  address the second word.  */
3507               if (ret && GET_MODE_SIZE (mode) > UNITS_PER_WORD)
3508                 ret = IN_RANGE_P (value + GET_MODE_SIZE (mode) - 1, -2048, 2047);
3509             }
3510           break;
3511
3512         case CONST:
3513           if (!condexec_p && got12_operand (x1, VOIDmode))
3514             ret = TRUE;
3515           break;
3516
3517         }
3518       break;
3519     }
3520
3521   if (TARGET_DEBUG_ADDR)
3522     {
3523       fprintf (stderr, "\n========== legitimate_address_p, mode = %s, result = %d, addresses are %sstrict%s\n",
3524                GET_MODE_NAME (mode), ret, (strict_p) ? "" : "not ",
3525                (condexec_p) ? ", inside conditional code" : "");
3526       debug_rtx (x);
3527     }
3528
3529   return ret;
3530 }
3531
3532 bool
3533 frv_legitimate_address_p (enum machine_mode mode, rtx x, bool strict_p)
3534 {
3535   return frv_legitimate_address_p_1 (mode, x, strict_p, FALSE, FALSE);
3536 }
3537
3538 /* Given an ADDR, generate code to inline the PLT.  */
3539 static rtx
3540 gen_inlined_tls_plt (rtx addr)
3541 {
3542   rtx retval, dest;
3543   rtx picreg = get_hard_reg_initial_val (Pmode, FDPIC_REG);
3544
3545
3546   dest = gen_reg_rtx (DImode);
3547
3548   if (flag_pic == 1)
3549     {
3550       /*
3551         -fpic version:
3552
3553         lddi.p  @(gr15, #gottlsdesc12(ADDR)), gr8
3554         calll    #gettlsoff(ADDR)@(gr8, gr0)
3555       */
3556       emit_insn (gen_tls_lddi (dest, addr, picreg));
3557     }
3558   else
3559     {
3560       /*
3561         -fPIC version:
3562
3563         sethi.p #gottlsdeschi(ADDR), gr8
3564         setlo   #gottlsdesclo(ADDR), gr8
3565         ldd     #tlsdesc(ADDR)@(gr15, gr8), gr8
3566         calll   #gettlsoff(ADDR)@(gr8, gr0)
3567       */
3568       rtx reguse = gen_reg_rtx (Pmode);
3569       emit_insn (gen_tlsoff_hilo (reguse, addr, GEN_INT (R_FRV_GOTTLSDESCHI)));
3570       emit_insn (gen_tls_tlsdesc_ldd (dest, picreg, reguse, addr));
3571     }
3572
3573   retval = gen_reg_rtx (Pmode);
3574   emit_insn (gen_tls_indirect_call (retval, addr, dest, picreg));
3575   return retval;
3576 }
3577
3578 /* Emit a TLSMOFF or TLSMOFF12 offset, depending on -mTLS.  Returns
3579    the destination address.  */
3580 static rtx
3581 gen_tlsmoff (rtx addr, rtx reg)
3582 {
3583   rtx dest = gen_reg_rtx (Pmode);
3584
3585   if (TARGET_BIG_TLS)
3586     {
3587       /* sethi.p #tlsmoffhi(x), grA
3588          setlo   #tlsmofflo(x), grA
3589       */
3590       dest = gen_reg_rtx (Pmode);
3591       emit_insn (gen_tlsoff_hilo (dest, addr,
3592                                   GEN_INT (R_FRV_TLSMOFFHI)));
3593       dest = gen_rtx_PLUS (Pmode, dest, reg);
3594     }
3595   else
3596     {
3597       /* addi grB, #tlsmoff12(x), grC
3598            -or-
3599          ld/st @(grB, #tlsmoff12(x)), grC
3600       */
3601       dest = gen_reg_rtx (Pmode);
3602       emit_insn (gen_symGOTOFF2reg_i (dest, addr, reg,
3603                                       GEN_INT (R_FRV_TLSMOFF12)));
3604     }
3605   return dest;
3606 }
3607
3608 /* Generate code for a TLS address.  */
3609 static rtx
3610 frv_legitimize_tls_address (rtx addr, enum tls_model model)
3611 {
3612   rtx dest, tp = gen_rtx_REG (Pmode, 29);
3613   rtx picreg = get_hard_reg_initial_val (Pmode, 15);
3614
3615   switch (model)
3616     {
3617     case TLS_MODEL_INITIAL_EXEC:
3618       if (flag_pic == 1)
3619         {
3620           /* -fpic version.
3621              ldi @(gr15, #gottlsoff12(x)), gr5
3622            */
3623           dest = gen_reg_rtx (Pmode);
3624           emit_insn (gen_tls_load_gottlsoff12 (dest, addr, picreg));
3625           dest = gen_rtx_PLUS (Pmode, tp, dest);
3626         }
3627       else
3628         {
3629           /* -fPIC or anything else.
3630
3631             sethi.p #gottlsoffhi(x), gr14
3632             setlo   #gottlsofflo(x), gr14
3633             ld      #tlsoff(x)@(gr15, gr14), gr9
3634           */
3635           rtx tmp = gen_reg_rtx (Pmode);
3636           dest = gen_reg_rtx (Pmode);
3637           emit_insn (gen_tlsoff_hilo (tmp, addr,
3638                                       GEN_INT (R_FRV_GOTTLSOFF_HI)));
3639
3640           emit_insn (gen_tls_tlsoff_ld (dest, picreg, tmp, addr));
3641           dest = gen_rtx_PLUS (Pmode, tp, dest);
3642         }
3643       break;
3644     case TLS_MODEL_LOCAL_DYNAMIC:
3645       {
3646         rtx reg, retval;
3647
3648         if (TARGET_INLINE_PLT)
3649           retval = gen_inlined_tls_plt (GEN_INT (0));
3650         else
3651           {
3652             /* call #gettlsoff(0) */
3653             retval = gen_reg_rtx (Pmode);
3654             emit_insn (gen_call_gettlsoff (retval, GEN_INT (0), picreg));
3655           }
3656
3657         reg = gen_reg_rtx (Pmode);
3658         emit_insn (gen_rtx_SET (VOIDmode, reg,
3659                                 gen_rtx_PLUS (Pmode,
3660                                               retval, tp)));
3661
3662         dest = gen_tlsmoff (addr, reg);
3663
3664         /*
3665         dest = gen_reg_rtx (Pmode);
3666         emit_insn (gen_tlsoff_hilo (dest, addr,
3667                                     GEN_INT (R_FRV_TLSMOFFHI)));
3668         dest = gen_rtx_PLUS (Pmode, dest, reg);
3669         */
3670         break;
3671       }
3672     case TLS_MODEL_LOCAL_EXEC:
3673       dest = gen_tlsmoff (addr, gen_rtx_REG (Pmode, 29));
3674       break;
3675     case TLS_MODEL_GLOBAL_DYNAMIC:
3676       {
3677         rtx retval;
3678
3679         if (TARGET_INLINE_PLT)
3680           retval = gen_inlined_tls_plt (addr);
3681         else
3682           {
3683             /* call #gettlsoff(x) */
3684             retval = gen_reg_rtx (Pmode);
3685             emit_insn (gen_call_gettlsoff (retval, addr, picreg));
3686           }
3687         dest = gen_rtx_PLUS (Pmode, retval, tp);
3688         break;
3689       }
3690     default:
3691       gcc_unreachable ();
3692     }
3693
3694   return dest;
3695 }
3696
3697 rtx
3698 frv_legitimize_address (rtx x,
3699                         rtx oldx ATTRIBUTE_UNUSED,
3700                         enum machine_mode mode ATTRIBUTE_UNUSED)
3701 {
3702   if (GET_CODE (x) == SYMBOL_REF)
3703     {
3704       enum tls_model model = SYMBOL_REF_TLS_MODEL (x);
3705       if (model != 0)
3706         return frv_legitimize_tls_address (x, model);
3707     }
3708
3709   return x;
3710 }
3711 \f
3712 /* Test whether a local function descriptor is canonical, i.e.,
3713    whether we can use FUNCDESC_GOTOFF to compute the address of the
3714    function.  */
3715
3716 static bool
3717 frv_local_funcdesc_p (rtx fnx)
3718 {
3719   tree fn;
3720   enum symbol_visibility vis;
3721   bool ret;
3722
3723   if (! SYMBOL_REF_LOCAL_P (fnx))
3724     return FALSE;
3725
3726   fn = SYMBOL_REF_DECL (fnx);
3727
3728   if (! fn)
3729     return FALSE;
3730
3731   vis = DECL_VISIBILITY (fn);
3732
3733   if (vis == VISIBILITY_PROTECTED)
3734     /* Private function descriptors for protected functions are not
3735        canonical.  Temporarily change the visibility to global.  */
3736     vis = VISIBILITY_DEFAULT;
3737   else if (flag_shlib)
3738     /* If we're already compiling for a shared library (that, unlike
3739        executables, can't assume that the existence of a definition
3740        implies local binding), we can skip the re-testing.  */
3741     return TRUE;
3742
3743   ret = default_binds_local_p_1 (fn, flag_pic);
3744
3745   DECL_VISIBILITY (fn) = vis;
3746
3747   return ret;
3748 }
3749
3750 /* Load the _gp symbol into DEST.  SRC is supposed to be the FDPIC
3751    register.  */
3752
3753 rtx
3754 frv_gen_GPsym2reg (rtx dest, rtx src)
3755 {
3756   tree gp = get_identifier ("_gp");
3757   rtx gp_sym = gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (gp));
3758
3759   return gen_symGOT2reg (dest, gp_sym, src, GEN_INT (R_FRV_GOT12));
3760 }
3761
3762 static const char *
3763 unspec_got_name (int i)
3764 {
3765   switch (i)
3766     {
3767     case R_FRV_GOT12: return "got12";
3768     case R_FRV_GOTHI: return "gothi";
3769     case R_FRV_GOTLO: return "gotlo";
3770     case R_FRV_FUNCDESC: return "funcdesc";
3771     case R_FRV_FUNCDESC_GOT12: return "gotfuncdesc12";
3772     case R_FRV_FUNCDESC_GOTHI: return "gotfuncdeschi";
3773     case R_FRV_FUNCDESC_GOTLO: return "gotfuncdesclo";
3774     case R_FRV_FUNCDESC_VALUE: return "funcdescvalue";
3775     case R_FRV_FUNCDESC_GOTOFF12: return "gotofffuncdesc12";
3776     case R_FRV_FUNCDESC_GOTOFFHI: return "gotofffuncdeschi";
3777     case R_FRV_FUNCDESC_GOTOFFLO: return "gotofffuncdesclo";
3778     case R_FRV_GOTOFF12: return "gotoff12";
3779     case R_FRV_GOTOFFHI: return "gotoffhi";
3780     case R_FRV_GOTOFFLO: return "gotofflo";
3781     case R_FRV_GPREL12: return "gprel12";
3782     case R_FRV_GPRELHI: return "gprelhi";
3783     case R_FRV_GPRELLO: return "gprello";
3784     case R_FRV_GOTTLSOFF_HI: return "gottlsoffhi";
3785     case R_FRV_GOTTLSOFF_LO: return "gottlsofflo";
3786     case R_FRV_TLSMOFFHI: return "tlsmoffhi";
3787     case R_FRV_TLSMOFFLO: return "tlsmofflo";
3788     case R_FRV_TLSMOFF12: return "tlsmoff12";
3789     case R_FRV_TLSDESCHI: return "tlsdeschi";
3790     case R_FRV_TLSDESCLO: return "tlsdesclo";
3791     case R_FRV_GOTTLSDESCHI: return "gottlsdeschi";
3792     case R_FRV_GOTTLSDESCLO: return "gottlsdesclo";
3793     default: gcc_unreachable ();
3794     }
3795 }
3796
3797 /* Write the assembler syntax for UNSPEC to STREAM.  Note that any offset
3798    is added inside the relocation operator.  */
3799
3800 static void
3801 frv_output_const_unspec (FILE *stream, const struct frv_unspec *unspec)
3802 {
3803   fprintf (stream, "#%s(", unspec_got_name (unspec->reloc));
3804   output_addr_const (stream, plus_constant (unspec->symbol, unspec->offset));
3805   fputs (")", stream);
3806 }
3807
3808 /* Implement FIND_BASE_TERM.  See whether ORIG_X represents #gprel12(foo)
3809    or #gotoff12(foo) for some small data symbol foo.  If so, return foo,
3810    otherwise return ORIG_X.  */
3811
3812 rtx
3813 frv_find_base_term (rtx x)
3814 {
3815   struct frv_unspec unspec;
3816
3817   if (frv_const_unspec_p (x, &unspec)
3818       && frv_small_data_reloc_p (unspec.symbol, unspec.reloc))
3819     return plus_constant (unspec.symbol, unspec.offset);
3820
3821   return x;
3822 }
3823
3824 /* Return 1 if operand is a valid FRV address.  CONDEXEC_P is true if
3825    the operand is used by a predicated instruction.  */
3826
3827 int
3828 frv_legitimate_memory_operand (rtx op, enum machine_mode mode, int condexec_p)
3829 {
3830   return ((GET_MODE (op) == mode || mode == VOIDmode)
3831           && GET_CODE (op) == MEM
3832           && frv_legitimate_address_p_1 (mode, XEXP (op, 0),
3833                                          reload_completed, condexec_p, FALSE));
3834 }
3835
3836 void
3837 frv_expand_fdpic_call (rtx *operands, bool ret_value, bool sibcall)
3838 {
3839   rtx lr = gen_rtx_REG (Pmode, LR_REGNO);
3840   rtx picreg = get_hard_reg_initial_val (SImode, FDPIC_REG);
3841   rtx c, rvrtx=0;
3842   rtx addr;
3843
3844   if (ret_value)
3845     {
3846       rvrtx = operands[0];
3847       operands ++;
3848     }
3849
3850   addr = XEXP (operands[0], 0);
3851
3852   /* Inline PLTs if we're optimizing for speed.  We'd like to inline
3853      any calls that would involve a PLT, but can't tell, since we
3854      don't know whether an extern function is going to be provided by
3855      a separate translation unit or imported from a separate module.
3856      When compiling for shared libraries, if the function has default
3857      visibility, we assume it's overridable, so we inline the PLT, but
3858      for executables, we don't really have a way to make a good
3859      decision: a function is as likely to be imported from a shared
3860      library as it is to be defined in the executable itself.  We
3861      assume executables will get global functions defined locally,
3862      whereas shared libraries will have them potentially overridden,
3863      so we only inline PLTs when compiling for shared libraries.
3864
3865      In order to mark a function as local to a shared library, any
3866      non-default visibility attribute suffices.  Unfortunately,
3867      there's no simple way to tag a function declaration as ``in a
3868      different module'', which we could then use to trigger PLT
3869      inlining on executables.  There's -minline-plt, but it affects
3870      all external functions, so one would have to also mark function
3871      declarations available in the same module with non-default
3872      visibility, which is advantageous in itself.  */
3873   if (GET_CODE (addr) == SYMBOL_REF
3874       && ((!SYMBOL_REF_LOCAL_P (addr) && TARGET_INLINE_PLT)
3875           || sibcall))
3876     {
3877       rtx x, dest;
3878       dest = gen_reg_rtx (SImode);
3879       if (flag_pic != 1)
3880         x = gen_symGOTOFF2reg_hilo (dest, addr, OUR_FDPIC_REG,
3881                                     GEN_INT (R_FRV_FUNCDESC_GOTOFF12));
3882       else
3883         x = gen_symGOTOFF2reg (dest, addr, OUR_FDPIC_REG,
3884                                GEN_INT (R_FRV_FUNCDESC_GOTOFF12));
3885       emit_insn (x);
3886       crtl->uses_pic_offset_table = TRUE;
3887       addr = dest;
3888     }
3889   else if (GET_CODE (addr) == SYMBOL_REF)
3890     {
3891       /* These are always either local, or handled through a local
3892          PLT.  */
3893       if (ret_value)
3894         c = gen_call_value_fdpicsi (rvrtx, addr, operands[1],
3895                                     operands[2], picreg, lr);
3896       else
3897         c = gen_call_fdpicsi (addr, operands[1], operands[2], picreg, lr);
3898       emit_call_insn (c);
3899       return;
3900     }
3901   else if (! ldd_address_operand (addr, Pmode))
3902     addr = force_reg (Pmode, addr);
3903
3904   picreg = gen_reg_rtx (DImode);
3905   emit_insn (gen_movdi_ldd (picreg, addr));
3906
3907   if (sibcall && ret_value)
3908     c = gen_sibcall_value_fdpicdi (rvrtx, picreg, const0_rtx);
3909   else if (sibcall)
3910     c = gen_sibcall_fdpicdi (picreg, const0_rtx);
3911   else if (ret_value)
3912     c = gen_call_value_fdpicdi (rvrtx, picreg, const0_rtx, lr);
3913   else
3914     c = gen_call_fdpicdi (picreg, const0_rtx, lr);
3915   emit_call_insn (c);
3916 }
3917 \f
3918 /* Look for a SYMBOL_REF of a function in an rtx.  We always want to
3919    process these separately from any offsets, such that we add any
3920    offsets to the function descriptor (the actual pointer), not to the
3921    function address.  */
3922
3923 static bool
3924 frv_function_symbol_referenced_p (rtx x)
3925 {
3926   const char *format;
3927   int length;
3928   int j;
3929
3930   if (GET_CODE (x) == SYMBOL_REF)
3931     return SYMBOL_REF_FUNCTION_P (x);
3932
3933   length = GET_RTX_LENGTH (GET_CODE (x));
3934   format = GET_RTX_FORMAT (GET_CODE (x));
3935
3936   for (j = 0; j < length; ++j)
3937     {
3938       switch (format[j])
3939         {
3940         case 'e':
3941           if (frv_function_symbol_referenced_p (XEXP (x, j)))
3942             return TRUE;
3943           break;
3944
3945         case 'V':
3946         case 'E':
3947           if (XVEC (x, j) != 0)
3948             {
3949               int k;
3950               for (k = 0; k < XVECLEN (x, j); ++k)
3951                 if (frv_function_symbol_referenced_p (XVECEXP (x, j, k)))
3952                   return TRUE;
3953             }
3954           break;
3955
3956         default:
3957           /* Nothing to do.  */
3958           break;
3959         }
3960     }
3961
3962   return FALSE;
3963 }
3964
3965 /* Return true if the memory operand is one that can be conditionally
3966    executed.  */
3967
3968 int
3969 condexec_memory_operand (rtx op, enum machine_mode mode)
3970 {
3971   enum machine_mode op_mode = GET_MODE (op);
3972   rtx addr;
3973
3974   if (mode != VOIDmode && op_mode != mode)
3975     return FALSE;
3976
3977   switch (op_mode)
3978     {
3979     default:
3980       return FALSE;
3981
3982     case QImode:
3983     case HImode:
3984     case SImode:
3985     case SFmode:
3986       break;
3987     }
3988
3989   if (GET_CODE (op) != MEM)
3990     return FALSE;
3991
3992   addr = XEXP (op, 0);
3993   return frv_legitimate_address_p_1 (mode, addr, reload_completed, TRUE, FALSE);
3994 }
3995 \f
3996 /* Return true if the bare return instruction can be used outside of the
3997    epilog code.  For frv, we only do it if there was no stack allocation.  */
3998
3999 int
4000 direct_return_p (void)
4001 {
4002   frv_stack_t *info;
4003
4004   if (!reload_completed)
4005     return FALSE;
4006
4007   info = frv_stack_info ();
4008   return (info->total_size == 0);
4009 }
4010
4011 \f
4012 void
4013 frv_emit_move (enum machine_mode mode, rtx dest, rtx src)
4014 {
4015   if (GET_CODE (src) == SYMBOL_REF)
4016     {
4017       enum tls_model model = SYMBOL_REF_TLS_MODEL (src);
4018       if (model != 0)
4019         src = frv_legitimize_tls_address (src, model);
4020     }
4021
4022   switch (mode)
4023     {
4024     case SImode:
4025       if (frv_emit_movsi (dest, src))
4026         return;
4027       break;
4028
4029     case QImode:
4030     case HImode:
4031     case DImode:
4032     case SFmode:
4033     case DFmode:
4034       if (!reload_in_progress
4035           && !reload_completed
4036           && !register_operand (dest, mode)
4037           && !reg_or_0_operand (src, mode))
4038         src = copy_to_mode_reg (mode, src);
4039       break;
4040
4041     default:
4042       gcc_unreachable ();
4043     }
4044
4045   emit_insn (gen_rtx_SET (VOIDmode, dest, src));
4046 }
4047
4048 /* Emit code to handle a MOVSI, adding in the small data register or pic
4049    register if needed to load up addresses.  Return TRUE if the appropriate
4050    instructions are emitted.  */
4051
4052 int
4053 frv_emit_movsi (rtx dest, rtx src)
4054 {
4055   int base_regno = -1;
4056   int unspec = 0;
4057   rtx sym = src;
4058   struct frv_unspec old_unspec;
4059
4060   if (!reload_in_progress
4061       && !reload_completed
4062       && !register_operand (dest, SImode)
4063       && (!reg_or_0_operand (src, SImode)
4064              /* Virtual registers will almost always be replaced by an
4065                 add instruction, so expose this to CSE by copying to
4066                 an intermediate register.  */
4067           || (GET_CODE (src) == REG
4068               && IN_RANGE_P (REGNO (src),
4069                              FIRST_VIRTUAL_REGISTER,
4070                              LAST_VIRTUAL_REGISTER))))
4071     {
4072       emit_insn (gen_rtx_SET (VOIDmode, dest, copy_to_mode_reg (SImode, src)));
4073       return TRUE;
4074     }
4075
4076   /* Explicitly add in the PIC or small data register if needed.  */
4077   switch (GET_CODE (src))
4078     {
4079     default:
4080       break;
4081
4082     case LABEL_REF:
4083     handle_label:
4084       if (TARGET_FDPIC)
4085         {
4086           /* Using GPREL12, we use a single GOT entry for all symbols
4087              in read-only sections, but trade sequences such as:
4088
4089              sethi #gothi(label), gr#
4090              setlo #gotlo(label), gr#
4091              ld    @(gr15,gr#), gr#
4092
4093              for
4094
4095              ld    @(gr15,#got12(_gp)), gr#
4096              sethi #gprelhi(label), gr##
4097              setlo #gprello(label), gr##
4098              add   gr#, gr##, gr##
4099
4100              We may often be able to share gr# for multiple
4101              computations of GPREL addresses, and we may often fold
4102              the final add into the pair of registers of a load or
4103              store instruction, so it's often profitable.  Even when
4104              optimizing for size, we're trading a GOT entry for an
4105              additional instruction, which trades GOT space
4106              (read-write) for code size (read-only, shareable), as
4107              long as the symbol is not used in more than two different
4108              locations.
4109
4110              With -fpie/-fpic, we'd be trading a single load for a
4111              sequence of 4 instructions, because the offset of the
4112              label can't be assumed to be addressable with 12 bits, so
4113              we don't do this.  */
4114           if (TARGET_GPREL_RO)
4115             unspec = R_FRV_GPREL12;
4116           else
4117             unspec = R_FRV_GOT12;
4118         }
4119       else if (flag_pic)
4120         base_regno = PIC_REGNO;
4121
4122       break;
4123
4124     case CONST:
4125       if (frv_const_unspec_p (src, &old_unspec))
4126         break;
4127
4128       if (TARGET_FDPIC && frv_function_symbol_referenced_p (XEXP (src, 0)))
4129         {
4130         handle_whatever:
4131           src = force_reg (GET_MODE (XEXP (src, 0)), XEXP (src, 0));
4132           emit_move_insn (dest, src);
4133           return TRUE;
4134         }
4135       else
4136         {
4137           sym = XEXP (sym, 0);
4138           if (GET_CODE (sym) == PLUS
4139               && GET_CODE (XEXP (sym, 0)) == SYMBOL_REF
4140               && GET_CODE (XEXP (sym, 1)) == CONST_INT)
4141             sym = XEXP (sym, 0);
4142           if (GET_CODE (sym) == SYMBOL_REF)
4143             goto handle_sym;
4144           else if (GET_CODE (sym) == LABEL_REF)
4145             goto handle_label;
4146           else
4147             goto handle_whatever;
4148         }
4149       break;
4150
4151     case SYMBOL_REF:
4152     handle_sym:
4153       if (TARGET_FDPIC)
4154         {
4155           enum tls_model model = SYMBOL_REF_TLS_MODEL (sym);
4156
4157           if (model != 0)
4158             {
4159               src = frv_legitimize_tls_address (src, model);
4160               emit_move_insn (dest, src);
4161               return TRUE;
4162             }
4163
4164           if (SYMBOL_REF_FUNCTION_P (sym))
4165             {
4166               if (frv_local_funcdesc_p (sym))
4167                 unspec = R_FRV_FUNCDESC_GOTOFF12;
4168               else
4169                 unspec = R_FRV_FUNCDESC_GOT12;
4170             }
4171           else
4172             {
4173               if (CONSTANT_POOL_ADDRESS_P (sym))
4174                 switch (GET_CODE (get_pool_constant (sym)))
4175                   {
4176                   case CONST:
4177                   case SYMBOL_REF:
4178                   case LABEL_REF:
4179                     if (flag_pic)
4180                       {
4181                         unspec = R_FRV_GOTOFF12;
4182                         break;
4183                       }
4184                     /* Fall through.  */
4185                   default:
4186                     if (TARGET_GPREL_RO)
4187                       unspec = R_FRV_GPREL12;
4188                     else
4189                       unspec = R_FRV_GOT12;
4190                     break;
4191                   }
4192               else if (SYMBOL_REF_LOCAL_P (sym)
4193                        && !SYMBOL_REF_EXTERNAL_P (sym)
4194                        && SYMBOL_REF_DECL (sym)
4195                        && (!DECL_P (SYMBOL_REF_DECL (sym))
4196                            || !DECL_COMMON (SYMBOL_REF_DECL (sym))))
4197                 {
4198                   tree decl = SYMBOL_REF_DECL (sym);
4199                   tree init = TREE_CODE (decl) == VAR_DECL
4200                     ? DECL_INITIAL (decl)
4201                     : TREE_CODE (decl) == CONSTRUCTOR
4202                     ? decl : 0;
4203                   int reloc = 0;
4204                   bool named_section, readonly;
4205
4206                   if (init && init != error_mark_node)
4207                     reloc = compute_reloc_for_constant (init);
4208
4209                   named_section = TREE_CODE (decl) == VAR_DECL
4210                     && lookup_attribute ("section", DECL_ATTRIBUTES (decl));
4211                   readonly = decl_readonly_section (decl, reloc);
4212
4213                   if (named_section)
4214                     unspec = R_FRV_GOT12;
4215                   else if (!readonly)
4216                     unspec = R_FRV_GOTOFF12;
4217                   else if (readonly && TARGET_GPREL_RO)
4218                     unspec = R_FRV_GPREL12;
4219                   else
4220                     unspec = R_FRV_GOT12;
4221                 }
4222               else
4223                 unspec = R_FRV_GOT12;
4224             }
4225         }
4226
4227       else if (SYMBOL_REF_SMALL_P (sym))
4228         base_regno = SDA_BASE_REG;
4229
4230       else if (flag_pic)
4231         base_regno = PIC_REGNO;
4232
4233       break;
4234     }
4235
4236   if (base_regno >= 0)
4237     {
4238       if (GET_CODE (sym) == SYMBOL_REF && SYMBOL_REF_SMALL_P (sym))
4239         emit_insn (gen_symGOTOFF2reg (dest, src,
4240                                       gen_rtx_REG (Pmode, base_regno),
4241                                       GEN_INT (R_FRV_GPREL12)));
4242       else
4243         emit_insn (gen_symGOTOFF2reg_hilo (dest, src,
4244                                            gen_rtx_REG (Pmode, base_regno),
4245                                            GEN_INT (R_FRV_GPREL12)));
4246       if (base_regno == PIC_REGNO)
4247         crtl->uses_pic_offset_table = TRUE;
4248       return TRUE;
4249     }
4250
4251   if (unspec)
4252     {
4253       rtx x;
4254
4255       /* Since OUR_FDPIC_REG is a pseudo register, we can't safely introduce
4256          new uses of it once reload has begun.  */
4257       gcc_assert (!reload_in_progress && !reload_completed);
4258
4259       switch (unspec)
4260         {
4261         case R_FRV_GOTOFF12:
4262           if (!frv_small_data_reloc_p (sym, unspec))
4263             x = gen_symGOTOFF2reg_hilo (dest, src, OUR_FDPIC_REG,
4264                                         GEN_INT (unspec));
4265           else
4266             x = gen_symGOTOFF2reg (dest, src, OUR_FDPIC_REG, GEN_INT (unspec));
4267           break;
4268         case R_FRV_GPREL12:
4269           if (!frv_small_data_reloc_p (sym, unspec))
4270             x = gen_symGPREL2reg_hilo (dest, src, OUR_FDPIC_REG,
4271                                        GEN_INT (unspec));
4272           else
4273             x = gen_symGPREL2reg (dest, src, OUR_FDPIC_REG, GEN_INT (unspec));
4274           break;
4275         case R_FRV_FUNCDESC_GOTOFF12:
4276           if (flag_pic != 1)
4277             x = gen_symGOTOFF2reg_hilo (dest, src, OUR_FDPIC_REG,
4278                                         GEN_INT (unspec));
4279           else
4280             x = gen_symGOTOFF2reg (dest, src, OUR_FDPIC_REG, GEN_INT (unspec));
4281           break;
4282         default:
4283           if (flag_pic != 1)
4284             x = gen_symGOT2reg_hilo (dest, src, OUR_FDPIC_REG,
4285                                      GEN_INT (unspec));
4286           else
4287             x = gen_symGOT2reg (dest, src, OUR_FDPIC_REG, GEN_INT (unspec));
4288           break;
4289         }
4290       emit_insn (x);
4291       crtl->uses_pic_offset_table = TRUE;
4292       return TRUE;
4293     }
4294
4295
4296   return FALSE;
4297 }
4298
4299 \f
4300 /* Return a string to output a single word move.  */
4301
4302 const char *
4303 output_move_single (rtx operands[], rtx insn)
4304 {
4305   rtx dest = operands[0];
4306   rtx src  = operands[1];
4307
4308   if (GET_CODE (dest) == REG)
4309     {
4310       int dest_regno = REGNO (dest);
4311       enum machine_mode mode = GET_MODE (dest);
4312
4313       if (GPR_P (dest_regno))
4314         {
4315           if (GET_CODE (src) == REG)
4316             {
4317               /* gpr <- some sort of register */
4318               int src_regno = REGNO (src);
4319
4320               if (GPR_P (src_regno))
4321                 return "mov %1, %0";
4322
4323               else if (FPR_P (src_regno))
4324                 return "movfg %1, %0";
4325
4326               else if (SPR_P (src_regno))
4327                 return "movsg %1, %0";
4328             }
4329
4330           else if (GET_CODE (src) == MEM)
4331             {
4332               /* gpr <- memory */
4333               switch (mode)
4334                 {
4335                 default:
4336                   break;
4337
4338                 case QImode:
4339                   return "ldsb%I1%U1 %M1,%0";
4340
4341                 case HImode:
4342                   return "ldsh%I1%U1 %M1,%0";
4343
4344                 case SImode:
4345                 case SFmode:
4346                   return "ld%I1%U1 %M1, %0";
4347                 }
4348             }
4349
4350           else if (GET_CODE (src) == CONST_INT
4351                    || GET_CODE (src) == CONST_DOUBLE)
4352             {
4353               /* gpr <- integer/floating constant */
4354               HOST_WIDE_INT value;
4355
4356               if (GET_CODE (src) == CONST_INT)
4357                 value = INTVAL (src);
4358
4359               else if (mode == SFmode)
4360                 {
4361                   REAL_VALUE_TYPE rv;
4362                   long l;
4363
4364                   REAL_VALUE_FROM_CONST_DOUBLE (rv, src);
4365                   REAL_VALUE_TO_TARGET_SINGLE (rv, l);
4366                   value = l;
4367                 }
4368
4369               else
4370                 value = CONST_DOUBLE_LOW (src);
4371
4372               if (IN_RANGE_P (value, -32768, 32767))
4373                 return "setlos %1, %0";
4374
4375               return "#";
4376             }
4377
4378           else if (GET_CODE (src) == SYMBOL_REF
4379                    || GET_CODE (src) == LABEL_REF
4380                    || GET_CODE (src) == CONST)
4381             {
4382               return "#";
4383             }
4384         }
4385
4386       else if (FPR_P (dest_regno))
4387         {
4388           if (GET_CODE (src) == REG)
4389             {
4390               /* fpr <- some sort of register */
4391               int src_regno = REGNO (src);
4392
4393               if (GPR_P (src_regno))
4394                 return "movgf %1, %0";
4395
4396               else if (FPR_P (src_regno))
4397                 {
4398                   if (TARGET_HARD_FLOAT)
4399                     return "fmovs %1, %0";
4400                   else
4401                     return "mor %1, %1, %0";
4402                 }
4403             }
4404
4405           else if (GET_CODE (src) == MEM)
4406             {
4407               /* fpr <- memory */
4408               switch (mode)
4409                 {
4410                 default:
4411                   break;
4412
4413                 case QImode:
4414                   return "ldbf%I1%U1 %M1,%0";
4415
4416                 case HImode:
4417                   return "ldhf%I1%U1 %M1,%0";
4418
4419                 case SImode:
4420                 case SFmode:
4421                   return "ldf%I1%U1 %M1, %0";
4422                 }
4423             }
4424
4425           else if (ZERO_P (src))
4426             return "movgf %., %0";
4427         }
4428
4429       else if (SPR_P (dest_regno))
4430         {
4431           if (GET_CODE (src) == REG)
4432             {
4433               /* spr <- some sort of register */
4434               int src_regno = REGNO (src);
4435
4436               if (GPR_P (src_regno))
4437                 return "movgs %1, %0";
4438             }
4439           else if (ZERO_P (src))
4440             return "movgs %., %0";
4441         }
4442     }
4443
4444   else if (GET_CODE (dest) == MEM)
4445     {
4446       if (GET_CODE (src) == REG)
4447         {
4448           int src_regno = REGNO (src);
4449           enum machine_mode mode = GET_MODE (dest);
4450
4451           if (GPR_P (src_regno))
4452             {
4453               switch (mode)
4454                 {
4455                 default:
4456                   break;
4457
4458                 case QImode:
4459                   return "stb%I0%U0 %1, %M0";
4460
4461                 case HImode:
4462                   return "sth%I0%U0 %1, %M0";
4463
4464                 case SImode:
4465                 case SFmode:
4466                   return "st%I0%U0 %1, %M0";
4467                 }
4468             }
4469
4470           else if (FPR_P (src_regno))
4471             {
4472               switch (mode)
4473                 {
4474                 default:
4475                   break;
4476
4477                 case QImode:
4478                   return "stbf%I0%U0 %1, %M0";
4479
4480                 case HImode:
4481                   return "sthf%I0%U0 %1, %M0";
4482
4483                 case SImode:
4484                 case SFmode:
4485                   return "stf%I0%U0 %1, %M0";
4486                 }
4487             }
4488         }
4489
4490       else if (ZERO_P (src))
4491         {
4492           switch (GET_MODE (dest))
4493             {
4494             default:
4495               break;
4496
4497             case QImode:
4498               return "stb%I0%U0 %., %M0";
4499
4500             case HImode:
4501               return "sth%I0%U0 %., %M0";
4502
4503             case SImode:
4504             case SFmode:
4505               return "st%I0%U0 %., %M0";
4506             }
4507         }
4508     }
4509
4510   fatal_insn ("bad output_move_single operand", insn);
4511   return "";
4512 }
4513
4514 \f
4515 /* Return a string to output a double word move.  */
4516
4517 const char *
4518 output_move_double (rtx operands[], rtx insn)
4519 {
4520   rtx dest = operands[0];
4521   rtx src  = operands[1];
4522   enum machine_mode mode = GET_MODE (dest);
4523
4524   if (GET_CODE (dest) == REG)
4525     {
4526       int dest_regno = REGNO (dest);
4527
4528       if (GPR_P (dest_regno))
4529         {
4530           if (GET_CODE (src) == REG)
4531             {
4532               /* gpr <- some sort of register */
4533               int src_regno = REGNO (src);
4534
4535               if (GPR_P (src_regno))
4536                 return "#";
4537
4538               else if (FPR_P (src_regno))
4539                 {
4540                   if (((dest_regno - GPR_FIRST) & 1) == 0
4541                       && ((src_regno - FPR_FIRST) & 1) == 0)
4542                     return "movfgd %1, %0";
4543
4544                   return "#";
4545                 }
4546             }
4547
4548           else if (GET_CODE (src) == MEM)
4549             {
4550               /* gpr <- memory */
4551               if (dbl_memory_one_insn_operand (src, mode))
4552                 return "ldd%I1%U1 %M1, %0";
4553
4554               return "#";
4555             }
4556
4557           else if (GET_CODE (src) == CONST_INT
4558                    || GET_CODE (src) == CONST_DOUBLE)
4559             return "#";
4560         }
4561
4562       else if (FPR_P (dest_regno))
4563         {
4564           if (GET_CODE (src) == REG)
4565             {
4566               /* fpr <- some sort of register */
4567               int src_regno = REGNO (src);
4568
4569               if (GPR_P (src_regno))
4570                 {
4571                   if (((dest_regno - FPR_FIRST) & 1) == 0
4572                       && ((src_regno - GPR_FIRST) & 1) == 0)
4573                     return "movgfd %1, %0";
4574
4575                   return "#";
4576                 }
4577
4578               else if (FPR_P (src_regno))
4579                 {
4580                   if (TARGET_DOUBLE
4581                       && ((dest_regno - FPR_FIRST) & 1) == 0
4582                       && ((src_regno - FPR_FIRST) & 1) == 0)
4583                     return "fmovd %1, %0";
4584
4585                   return "#";
4586                 }
4587             }
4588
4589           else if (GET_CODE (src) == MEM)
4590             {
4591               /* fpr <- memory */
4592               if (dbl_memory_one_insn_operand (src, mode))
4593                 return "lddf%I1%U1 %M1, %0";
4594
4595               return "#";
4596             }
4597
4598           else if (ZERO_P (src))
4599             return "#";
4600         }
4601     }
4602
4603   else if (GET_CODE (dest) == MEM)
4604     {
4605       if (GET_CODE (src) == REG)
4606         {
4607           int src_regno = REGNO (src);
4608
4609           if (GPR_P (src_regno))
4610             {
4611               if (((src_regno - GPR_FIRST) & 1) == 0
4612                   && dbl_memory_one_insn_operand (dest, mode))
4613                 return "std%I0%U0 %1, %M0";
4614
4615               return "#";
4616             }
4617
4618           if (FPR_P (src_regno))
4619             {
4620               if (((src_regno - FPR_FIRST) & 1) == 0
4621                   && dbl_memory_one_insn_operand (dest, mode))
4622                 return "stdf%I0%U0 %1, %M0";
4623
4624               return "#";
4625             }
4626         }
4627
4628       else if (ZERO_P (src))
4629         {
4630           if (dbl_memory_one_insn_operand (dest, mode))
4631             return "std%I0%U0 %., %M0";
4632
4633           return "#";
4634         }
4635     }
4636
4637   fatal_insn ("bad output_move_double operand", insn);
4638   return "";
4639 }
4640
4641 \f
4642 /* Return a string to output a single word conditional move.
4643    Operand0 -- EQ/NE of ccr register and 0
4644    Operand1 -- CCR register
4645    Operand2 -- destination
4646    Operand3 -- source  */
4647
4648 const char *
4649 output_condmove_single (rtx operands[], rtx insn)
4650 {
4651   rtx dest = operands[2];
4652   rtx src  = operands[3];
4653
4654   if (GET_CODE (dest) == REG)
4655     {
4656       int dest_regno = REGNO (dest);
4657       enum machine_mode mode = GET_MODE (dest);
4658
4659       if (GPR_P (dest_regno))
4660         {
4661           if (GET_CODE (src) == REG)
4662             {
4663               /* gpr <- some sort of register */
4664               int src_regno = REGNO (src);
4665
4666               if (GPR_P (src_regno))
4667                 return "cmov %z3, %2, %1, %e0";
4668
4669               else if (FPR_P (src_regno))
4670                 return "cmovfg %3, %2, %1, %e0";
4671             }
4672
4673           else if (GET_CODE (src) == MEM)
4674             {
4675               /* gpr <- memory */
4676               switch (mode)
4677                 {
4678                 default:
4679                   break;
4680
4681                 case QImode:
4682                   return "cldsb%I3%U3 %M3, %2, %1, %e0";
4683
4684                 case HImode:
4685                   return "cldsh%I3%U3 %M3, %2, %1, %e0";
4686
4687                 case SImode:
4688                 case SFmode:
4689                   return "cld%I3%U3 %M3, %2, %1, %e0";
4690                 }
4691             }
4692
4693           else if (ZERO_P (src))
4694             return "cmov %., %2, %1, %e0";
4695         }
4696
4697       else if (FPR_P (dest_regno))
4698         {
4699           if (GET_CODE (src) == REG)
4700             {
4701               /* fpr <- some sort of register */
4702               int src_regno = REGNO (src);
4703
4704               if (GPR_P (src_regno))
4705                 return "cmovgf %3, %2, %1, %e0";
4706
4707               else if (FPR_P (src_regno))
4708                 {
4709                   if (TARGET_HARD_FLOAT)
4710                     return "cfmovs %3,%2,%1,%e0";
4711                   else
4712                     return "cmor %3, %3, %2, %1, %e0";
4713                 }
4714             }
4715
4716           else if (GET_CODE (src) == MEM)
4717             {
4718               /* fpr <- memory */
4719               if (mode == SImode || mode == SFmode)
4720                 return "cldf%I3%U3 %M3, %2, %1, %e0";
4721             }
4722
4723           else if (ZERO_P (src))
4724             return "cmovgf %., %2, %1, %e0";
4725         }
4726     }
4727
4728   else if (GET_CODE (dest) == MEM)
4729     {
4730       if (GET_CODE (src) == REG)
4731         {
4732           int src_regno = REGNO (src);
4733           enum machine_mode mode = GET_MODE (dest);
4734
4735           if (GPR_P (src_regno))
4736             {
4737               switch (mode)
4738                 {
4739                 default:
4740                   break;
4741
4742                 case QImode:
4743                   return "cstb%I2%U2 %3, %M2, %1, %e0";
4744
4745                 case HImode:
4746                   return "csth%I2%U2 %3, %M2, %1, %e0";
4747
4748                 case SImode:
4749                 case SFmode:
4750                   return "cst%I2%U2 %3, %M2, %1, %e0";
4751                 }
4752             }
4753
4754           else if (FPR_P (src_regno) && (mode == SImode || mode == SFmode))
4755             return "cstf%I2%U2 %3, %M2, %1, %e0";
4756         }
4757
4758       else if (ZERO_P (src))
4759         {
4760           enum machine_mode mode = GET_MODE (dest);
4761           switch (mode)
4762             {
4763             default:
4764               break;
4765
4766             case QImode:
4767               return "cstb%I2%U2 %., %M2, %1, %e0";
4768
4769             case HImode:
4770               return "csth%I2%U2 %., %M2, %1, %e0";
4771
4772             case SImode:
4773             case SFmode:
4774               return "cst%I2%U2 %., %M2, %1, %e0";
4775             }
4776         }
4777     }
4778
4779   fatal_insn ("bad output_condmove_single operand", insn);
4780   return "";
4781 }
4782
4783 \f
4784 /* Emit the appropriate code to do a comparison, returning the register the
4785    comparison was done it.  */
4786
4787 static rtx
4788 frv_emit_comparison (enum rtx_code test, rtx op0, rtx op1)
4789 {
4790   enum machine_mode cc_mode;
4791   rtx cc_reg;
4792
4793   /* Floating point doesn't have comparison against a constant.  */
4794   if (GET_MODE (op0) == CC_FPmode && GET_CODE (op1) != REG)
4795     op1 = force_reg (GET_MODE (op0), op1);
4796
4797   /* Possibly disable using anything but a fixed register in order to work
4798      around cse moving comparisons past function calls.  */
4799   cc_mode = SELECT_CC_MODE (test, op0, op1);
4800   cc_reg = ((TARGET_ALLOC_CC)
4801             ? gen_reg_rtx (cc_mode)
4802             : gen_rtx_REG (cc_mode,
4803                            (cc_mode == CC_FPmode) ? FCC_FIRST : ICC_FIRST));
4804
4805   emit_insn (gen_rtx_SET (VOIDmode, cc_reg,
4806                           gen_rtx_COMPARE (cc_mode, op0, op1)));
4807
4808   return cc_reg;
4809 }
4810
4811 \f
4812 /* Emit code for a conditional branch.
4813    XXX: I originally wanted to add a clobber of a CCR register to use in
4814    conditional execution, but that confuses the rest of the compiler.  */
4815
4816 int
4817 frv_emit_cond_branch (rtx operands[])
4818 {
4819   rtx test_rtx;
4820   rtx label_ref;
4821   rtx if_else;
4822   enum rtx_code test = GET_CODE (operands[0]);
4823   rtx cc_reg = frv_emit_comparison (test, operands[1], operands[2]);
4824   enum machine_mode cc_mode = GET_MODE (cc_reg);
4825
4826   /* Branches generate:
4827         (set (pc)
4828              (if_then_else (<test>, <cc_reg>, (const_int 0))
4829                             (label_ref <branch_label>)
4830                             (pc))) */
4831   label_ref = gen_rtx_LABEL_REF (VOIDmode, operands[3]);
4832   test_rtx = gen_rtx_fmt_ee (test, cc_mode, cc_reg, const0_rtx);
4833   if_else = gen_rtx_IF_THEN_ELSE (cc_mode, test_rtx, label_ref, pc_rtx);
4834   emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, if_else));
4835   return TRUE;
4836 }
4837
4838 \f
4839 /* Emit code to set a gpr to 1/0 based on a comparison.  */
4840
4841 int
4842 frv_emit_scc (rtx operands[])
4843 {
4844   rtx set;
4845   rtx test_rtx;
4846   rtx clobber;
4847   rtx cr_reg;
4848   enum rtx_code test = GET_CODE (operands[1]);
4849   rtx cc_reg = frv_emit_comparison (test, operands[2], operands[3]);
4850
4851   /* SCC instructions generate:
4852         (parallel [(set <target> (<test>, <cc_reg>, (const_int 0))
4853                    (clobber (<ccr_reg>))])  */
4854   test_rtx = gen_rtx_fmt_ee (test, SImode, cc_reg, const0_rtx);
4855   set = gen_rtx_SET (VOIDmode, operands[0], test_rtx);
4856
4857   cr_reg = ((TARGET_ALLOC_CC)
4858             ? gen_reg_rtx (CC_CCRmode)
4859             : gen_rtx_REG (CC_CCRmode,
4860                            ((GET_MODE (cc_reg) == CC_FPmode)
4861                             ? FCR_FIRST
4862                             : ICR_FIRST)));
4863
4864   clobber = gen_rtx_CLOBBER (VOIDmode, cr_reg);
4865   emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, set, clobber)));
4866   return TRUE;
4867 }
4868
4869 \f
4870 /* Split a SCC instruction into component parts, returning a SEQUENCE to hold
4871    the separate insns.  */
4872
4873 rtx
4874 frv_split_scc (rtx dest, rtx test, rtx cc_reg, rtx cr_reg, HOST_WIDE_INT value)
4875 {
4876   rtx ret;
4877
4878   start_sequence ();
4879
4880   /* Set the appropriate CCR bit.  */
4881   emit_insn (gen_rtx_SET (VOIDmode,
4882                           cr_reg,
4883                           gen_rtx_fmt_ee (GET_CODE (test),
4884                                           GET_MODE (cr_reg),
4885                                           cc_reg,
4886                                           const0_rtx)));
4887
4888   /* Move the value into the destination.  */
4889   emit_move_insn (dest, GEN_INT (value));
4890
4891   /* Move 0 into the destination if the test failed */
4892   emit_insn (gen_rtx_COND_EXEC (VOIDmode,
4893                                 gen_rtx_EQ (GET_MODE (cr_reg),
4894                                             cr_reg,
4895                                             const0_rtx),
4896                                 gen_rtx_SET (VOIDmode, dest, const0_rtx)));
4897
4898   /* Finish up, return sequence.  */
4899   ret = get_insns ();
4900   end_sequence ();
4901   return ret;
4902 }
4903
4904 \f
4905 /* Emit the code for a conditional move, return TRUE if we could do the
4906    move.  */
4907
4908 int
4909 frv_emit_cond_move (rtx dest, rtx test_rtx, rtx src1, rtx src2)
4910 {
4911   rtx set;
4912   rtx clobber_cc;
4913   rtx test2;
4914   rtx cr_reg;
4915   rtx if_rtx;
4916   enum rtx_code test = GET_CODE (test_rtx);
4917   rtx cc_reg = frv_emit_comparison (test,
4918                                     XEXP (test_rtx, 0), XEXP (test_rtx, 1));
4919   enum machine_mode cc_mode = GET_MODE (cc_reg);
4920
4921   /* Conditional move instructions generate:
4922         (parallel [(set <target>
4923                         (if_then_else (<test> <cc_reg> (const_int 0))
4924                                       <src1>
4925                                       <src2>))
4926                    (clobber (<ccr_reg>))])  */
4927
4928   /* Handle various cases of conditional move involving two constants.  */
4929   if (GET_CODE (src1) == CONST_INT && GET_CODE (src2) == CONST_INT)
4930     {
4931       HOST_WIDE_INT value1 = INTVAL (src1);
4932       HOST_WIDE_INT value2 = INTVAL (src2);
4933
4934       /* Having 0 as one of the constants can be done by loading the other
4935          constant, and optionally moving in gr0.  */
4936       if (value1 == 0 || value2 == 0)
4937         ;
4938
4939       /* If the first value is within an addi range and also the difference
4940          between the two fits in an addi's range, load up the difference, then
4941          conditionally move in 0, and then unconditionally add the first
4942          value.  */
4943       else if (IN_RANGE_P (value1, -2048, 2047)
4944                && IN_RANGE_P (value2 - value1, -2048, 2047))
4945         ;
4946
4947       /* If neither condition holds, just force the constant into a
4948          register.  */
4949       else
4950         {
4951           src1 = force_reg (GET_MODE (dest), src1);
4952           src2 = force_reg (GET_MODE (dest), src2);
4953         }
4954     }
4955
4956   /* If one value is a register, insure the other value is either 0 or a
4957      register.  */
4958   else
4959     {
4960       if (GET_CODE (src1) == CONST_INT && INTVAL (src1) != 0)
4961         src1 = force_reg (GET_MODE (dest), src1);
4962
4963       if (GET_CODE (src2) == CONST_INT && INTVAL (src2) != 0)
4964         src2 = force_reg (GET_MODE (dest), src2);
4965     }
4966
4967   test2 = gen_rtx_fmt_ee (test, cc_mode, cc_reg, const0_rtx);
4968   if_rtx = gen_rtx_IF_THEN_ELSE (GET_MODE (dest), test2, src1, src2);
4969
4970   set = gen_rtx_SET (VOIDmode, dest, if_rtx);
4971
4972   cr_reg = ((TARGET_ALLOC_CC)
4973             ? gen_reg_rtx (CC_CCRmode)
4974             : gen_rtx_REG (CC_CCRmode,
4975                            (cc_mode == CC_FPmode) ? FCR_FIRST : ICR_FIRST));
4976
4977   clobber_cc = gen_rtx_CLOBBER (VOIDmode, cr_reg);
4978   emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, set, clobber_cc)));
4979   return TRUE;
4980 }
4981
4982 \f
4983 /* Split a conditional move into constituent parts, returning a SEQUENCE
4984    containing all of the insns.  */
4985
4986 rtx
4987 frv_split_cond_move (rtx operands[])
4988 {
4989   rtx dest      = operands[0];
4990   rtx test      = operands[1];
4991   rtx cc_reg    = operands[2];
4992   rtx src1      = operands[3];
4993   rtx src2      = operands[4];
4994   rtx cr_reg    = operands[5];
4995   rtx ret;
4996   enum machine_mode cr_mode = GET_MODE (cr_reg);
4997
4998   start_sequence ();
4999
5000   /* Set the appropriate CCR bit.  */
5001   emit_insn (gen_rtx_SET (VOIDmode,
5002                           cr_reg,
5003                           gen_rtx_fmt_ee (GET_CODE (test),
5004                                           GET_MODE (cr_reg),
5005                                           cc_reg,
5006                                           const0_rtx)));
5007
5008   /* Handle various cases of conditional move involving two constants.  */
5009   if (GET_CODE (src1) == CONST_INT && GET_CODE (src2) == CONST_INT)
5010     {
5011       HOST_WIDE_INT value1 = INTVAL (src1);
5012       HOST_WIDE_INT value2 = INTVAL (src2);
5013
5014       /* Having 0 as one of the constants can be done by loading the other
5015          constant, and optionally moving in gr0.  */
5016       if (value1 == 0)
5017         {
5018           emit_move_insn (dest, src2);
5019           emit_insn (gen_rtx_COND_EXEC (VOIDmode,
5020                                         gen_rtx_NE (cr_mode, cr_reg,
5021                                                     const0_rtx),
5022                                         gen_rtx_SET (VOIDmode, dest, src1)));
5023         }
5024
5025       else if (value2 == 0)
5026         {
5027           emit_move_insn (dest, src1);
5028           emit_insn (gen_rtx_COND_EXEC (VOIDmode,
5029                                         gen_rtx_EQ (cr_mode, cr_reg,
5030                                                     const0_rtx),
5031                                         gen_rtx_SET (VOIDmode, dest, src2)));
5032         }
5033
5034       /* If the first value is within an addi range and also the difference
5035          between the two fits in an addi's range, load up the difference, then
5036          conditionally move in 0, and then unconditionally add the first
5037          value.  */
5038       else if (IN_RANGE_P (value1, -2048, 2047)
5039                && IN_RANGE_P (value2 - value1, -2048, 2047))
5040         {
5041           rtx dest_si = ((GET_MODE (dest) == SImode)
5042                          ? dest
5043                          : gen_rtx_SUBREG (SImode, dest, 0));
5044
5045           emit_move_insn (dest_si, GEN_INT (value2 - value1));
5046           emit_insn (gen_rtx_COND_EXEC (VOIDmode,
5047                                         gen_rtx_NE (cr_mode, cr_reg,
5048                                                     const0_rtx),
5049                                         gen_rtx_SET (VOIDmode, dest_si,
5050                                                      const0_rtx)));
5051           emit_insn (gen_addsi3 (dest_si, dest_si, src1));
5052         }
5053
5054       else
5055         gcc_unreachable ();
5056     }
5057   else
5058     {
5059       /* Emit the conditional move for the test being true if needed.  */
5060       if (! rtx_equal_p (dest, src1))
5061         emit_insn (gen_rtx_COND_EXEC (VOIDmode,
5062                                       gen_rtx_NE (cr_mode, cr_reg, const0_rtx),
5063                                       gen_rtx_SET (VOIDmode, dest, src1)));
5064
5065       /* Emit the conditional move for the test being false if needed.  */
5066       if (! rtx_equal_p (dest, src2))
5067         emit_insn (gen_rtx_COND_EXEC (VOIDmode,
5068                                       gen_rtx_EQ (cr_mode, cr_reg, const0_rtx),
5069                                       gen_rtx_SET (VOIDmode, dest, src2)));
5070     }
5071
5072   /* Finish up, return sequence.  */
5073   ret = get_insns ();
5074   end_sequence ();
5075   return ret;
5076 }
5077
5078 \f
5079 /* Split (set DEST SOURCE), where DEST is a double register and SOURCE is a
5080    memory location that is not known to be dword-aligned.  */
5081 void
5082 frv_split_double_load (rtx dest, rtx source)
5083 {
5084   int regno = REGNO (dest);
5085   rtx dest1 = gen_highpart (SImode, dest);
5086   rtx dest2 = gen_lowpart (SImode, dest);
5087   rtx address = XEXP (source, 0);
5088
5089   /* If the address is pre-modified, load the lower-numbered register
5090      first, then load the other register using an integer offset from
5091      the modified base register.  This order should always be safe,
5092      since the pre-modification cannot affect the same registers as the
5093      load does.
5094
5095      The situation for other loads is more complicated.  Loading one
5096      of the registers could affect the value of ADDRESS, so we must
5097      be careful which order we do them in.  */
5098   if (GET_CODE (address) == PRE_MODIFY
5099       || ! refers_to_regno_p (regno, regno + 1, address, NULL))
5100     {
5101       /* It is safe to load the lower-numbered register first.  */
5102       emit_move_insn (dest1, change_address (source, SImode, NULL));
5103       emit_move_insn (dest2, frv_index_memory (source, SImode, 1));
5104     }
5105   else
5106     {
5107       /* ADDRESS is not pre-modified and the address depends on the
5108          lower-numbered register.  Load the higher-numbered register
5109          first.  */
5110       emit_move_insn (dest2, frv_index_memory (source, SImode, 1));
5111       emit_move_insn (dest1, change_address (source, SImode, NULL));
5112     }
5113 }
5114
5115 /* Split (set DEST SOURCE), where DEST refers to a dword memory location
5116    and SOURCE is either a double register or the constant zero.  */
5117 void
5118 frv_split_double_store (rtx dest, rtx source)
5119 {
5120   rtx dest1 = change_address (dest, SImode, NULL);
5121   rtx dest2 = frv_index_memory (dest, SImode, 1);
5122   if (ZERO_P (source))
5123     {
5124       emit_move_insn (dest1, CONST0_RTX (SImode));
5125       emit_move_insn (dest2, CONST0_RTX (SImode));
5126     }
5127   else
5128     {
5129       emit_move_insn (dest1, gen_highpart (SImode, source));
5130       emit_move_insn (dest2, gen_lowpart (SImode, source));
5131     }
5132 }
5133
5134 \f
5135 /* Split a min/max operation returning a SEQUENCE containing all of the
5136    insns.  */
5137
5138 rtx
5139 frv_split_minmax (rtx operands[])
5140 {
5141   rtx dest      = operands[0];
5142   rtx minmax    = operands[1];
5143   rtx src1      = operands[2];
5144   rtx src2      = operands[3];
5145   rtx cc_reg    = operands[4];
5146   rtx cr_reg    = operands[5];
5147   rtx ret;
5148   enum rtx_code test_code;
5149   enum machine_mode cr_mode = GET_MODE (cr_reg);
5150
5151   start_sequence ();
5152
5153   /* Figure out which test to use.  */
5154   switch (GET_CODE (minmax))
5155     {
5156     default:
5157       gcc_unreachable ();
5158
5159     case SMIN: test_code = LT;  break;
5160     case SMAX: test_code = GT;  break;
5161     case UMIN: test_code = LTU; break;
5162     case UMAX: test_code = GTU; break;
5163     }
5164
5165   /* Issue the compare instruction.  */
5166   emit_insn (gen_rtx_SET (VOIDmode,
5167                           cc_reg,
5168                           gen_rtx_COMPARE (GET_MODE (cc_reg),
5169                                            src1, src2)));
5170
5171   /* Set the appropriate CCR bit.  */
5172   emit_insn (gen_rtx_SET (VOIDmode,
5173                           cr_reg,
5174                           gen_rtx_fmt_ee (test_code,
5175                                           GET_MODE (cr_reg),
5176                                           cc_reg,
5177                                           const0_rtx)));
5178
5179   /* If are taking the min/max of a nonzero constant, load that first, and
5180      then do a conditional move of the other value.  */
5181   if (GET_CODE (src2) == CONST_INT && INTVAL (src2) != 0)
5182     {
5183       gcc_assert (!rtx_equal_p (dest, src1));
5184
5185       emit_move_insn (dest, src2);
5186       emit_insn (gen_rtx_COND_EXEC (VOIDmode,
5187                                     gen_rtx_NE (cr_mode, cr_reg, const0_rtx),
5188                                     gen_rtx_SET (VOIDmode, dest, src1)));
5189     }
5190
5191   /* Otherwise, do each half of the move.  */
5192   else
5193     {
5194       /* Emit the conditional move for the test being true if needed.  */
5195       if (! rtx_equal_p (dest, src1))
5196         emit_insn (gen_rtx_COND_EXEC (VOIDmode,
5197                                       gen_rtx_NE (cr_mode, cr_reg, const0_rtx),
5198                                       gen_rtx_SET (VOIDmode, dest, src1)));
5199
5200       /* Emit the conditional move for the test being false if needed.  */
5201       if (! rtx_equal_p (dest, src2))
5202         emit_insn (gen_rtx_COND_EXEC (VOIDmode,
5203                                       gen_rtx_EQ (cr_mode, cr_reg, const0_rtx),
5204                                       gen_rtx_SET (VOIDmode, dest, src2)));
5205     }
5206
5207   /* Finish up, return sequence.  */
5208   ret = get_insns ();
5209   end_sequence ();
5210   return ret;
5211 }
5212
5213 \f
5214 /* Split an integer abs operation returning a SEQUENCE containing all of the
5215    insns.  */
5216
5217 rtx
5218 frv_split_abs (rtx operands[])
5219 {
5220   rtx dest      = operands[0];
5221   rtx src       = operands[1];
5222   rtx cc_reg    = operands[2];
5223   rtx cr_reg    = operands[3];
5224   rtx ret;
5225
5226   start_sequence ();
5227
5228   /* Issue the compare < 0 instruction.  */
5229   emit_insn (gen_rtx_SET (VOIDmode,
5230                           cc_reg,
5231                           gen_rtx_COMPARE (CCmode, src, const0_rtx)));
5232
5233   /* Set the appropriate CCR bit.  */
5234   emit_insn (gen_rtx_SET (VOIDmode,
5235                           cr_reg,
5236                           gen_rtx_fmt_ee (LT, CC_CCRmode, cc_reg, const0_rtx)));
5237
5238   /* Emit the conditional negate if the value is negative.  */
5239   emit_insn (gen_rtx_COND_EXEC (VOIDmode,
5240                                 gen_rtx_NE (CC_CCRmode, cr_reg, const0_rtx),
5241                                 gen_negsi2 (dest, src)));
5242
5243   /* Emit the conditional move for the test being false if needed.  */
5244   if (! rtx_equal_p (dest, src))
5245     emit_insn (gen_rtx_COND_EXEC (VOIDmode,
5246                                   gen_rtx_EQ (CC_CCRmode, cr_reg, const0_rtx),
5247                                   gen_rtx_SET (VOIDmode, dest, src)));
5248
5249   /* Finish up, return sequence.  */
5250   ret = get_insns ();
5251   end_sequence ();
5252   return ret;
5253 }
5254
5255 \f
5256 /* An internal function called by for_each_rtx to clear in a hard_reg set each
5257    register used in an insn.  */
5258
5259 static int
5260 frv_clear_registers_used (rtx *ptr, void *data)
5261 {
5262   if (GET_CODE (*ptr) == REG)
5263     {
5264       int regno = REGNO (*ptr);
5265       HARD_REG_SET *p_regs = (HARD_REG_SET *)data;
5266
5267       if (regno < FIRST_PSEUDO_REGISTER)
5268         {
5269           int reg_max = regno + HARD_REGNO_NREGS (regno, GET_MODE (*ptr));
5270
5271           while (regno < reg_max)
5272             {
5273               CLEAR_HARD_REG_BIT (*p_regs, regno);
5274               regno++;
5275             }
5276         }
5277     }
5278
5279   return 0;
5280 }
5281
5282 \f
5283 /* Initialize the extra fields provided by IFCVT_EXTRA_FIELDS.  */
5284
5285 /* On the FR-V, we don't have any extra fields per se, but it is useful hook to
5286    initialize the static storage.  */
5287 void
5288 frv_ifcvt_init_extra_fields (ce_if_block_t *ce_info ATTRIBUTE_UNUSED)
5289 {
5290   frv_ifcvt.added_insns_list = NULL_RTX;
5291   frv_ifcvt.cur_scratch_regs = 0;
5292   frv_ifcvt.num_nested_cond_exec = 0;
5293   frv_ifcvt.cr_reg = NULL_RTX;
5294   frv_ifcvt.nested_cc_reg = NULL_RTX;
5295   frv_ifcvt.extra_int_cr = NULL_RTX;
5296   frv_ifcvt.extra_fp_cr = NULL_RTX;
5297   frv_ifcvt.last_nested_if_cr = NULL_RTX;
5298 }
5299
5300 \f
5301 /* Internal function to add a potential insn to the list of insns to be inserted
5302    if the conditional execution conversion is successful.  */
5303
5304 static void
5305 frv_ifcvt_add_insn (rtx pattern, rtx insn, int before_p)
5306 {
5307   rtx link = alloc_EXPR_LIST (VOIDmode, pattern, insn);
5308
5309   link->jump = before_p;        /* Mark to add this before or after insn.  */
5310   frv_ifcvt.added_insns_list = alloc_EXPR_LIST (VOIDmode, link,
5311                                                 frv_ifcvt.added_insns_list);
5312
5313   if (TARGET_DEBUG_COND_EXEC)
5314     {
5315       fprintf (stderr,
5316                "\n:::::::::: frv_ifcvt_add_insn: add the following %s insn %d:\n",
5317                (before_p) ? "before" : "after",
5318                (int)INSN_UID (insn));
5319
5320       debug_rtx (pattern);
5321     }
5322 }
5323
5324 \f
5325 /* A C expression to modify the code described by the conditional if
5326    information CE_INFO, possibly updating the tests in TRUE_EXPR, and
5327    FALSE_EXPR for converting if-then and if-then-else code to conditional
5328    instructions.  Set either TRUE_EXPR or FALSE_EXPR to a null pointer if the
5329    tests cannot be converted.  */
5330
5331 void
5332 frv_ifcvt_modify_tests (ce_if_block_t *ce_info, rtx *p_true, rtx *p_false)
5333 {
5334   basic_block test_bb = ce_info->test_bb;       /* test basic block */
5335   basic_block then_bb = ce_info->then_bb;       /* THEN */
5336   basic_block else_bb = ce_info->else_bb;       /* ELSE or NULL */
5337   basic_block join_bb = ce_info->join_bb;       /* join block or NULL */
5338   rtx true_expr = *p_true;
5339   rtx cr;
5340   rtx cc;
5341   rtx nested_cc;
5342   enum machine_mode mode = GET_MODE (true_expr);
5343   int j;
5344   basic_block *bb;
5345   int num_bb;
5346   frv_tmp_reg_t *tmp_reg = &frv_ifcvt.tmp_reg;
5347   rtx check_insn;
5348   rtx sub_cond_exec_reg;
5349   enum rtx_code code;
5350   enum rtx_code code_true;
5351   enum rtx_code code_false;
5352   enum reg_class cc_class;
5353   enum reg_class cr_class;
5354   int cc_first;
5355   int cc_last;
5356   reg_set_iterator rsi;
5357
5358   /* Make sure we are only dealing with hard registers.  Also honor the
5359      -mno-cond-exec switch, and -mno-nested-cond-exec switches if
5360      applicable.  */
5361   if (!reload_completed || !TARGET_COND_EXEC
5362       || (!TARGET_NESTED_CE && ce_info->pass > 1))
5363     goto fail;
5364
5365   /* Figure out which registers we can allocate for our own purposes.  Only
5366      consider registers that are not preserved across function calls and are
5367      not fixed.  However, allow the ICC/ICR temporary registers to be allocated
5368      if we did not need to use them in reloading other registers.  */
5369   memset (&tmp_reg->regs, 0, sizeof (tmp_reg->regs));
5370   COPY_HARD_REG_SET (tmp_reg->regs, call_used_reg_set);
5371   AND_COMPL_HARD_REG_SET (tmp_reg->regs, fixed_reg_set);
5372   SET_HARD_REG_BIT (tmp_reg->regs, ICC_TEMP);
5373   SET_HARD_REG_BIT (tmp_reg->regs, ICR_TEMP);
5374
5375   /* If this is a nested IF, we need to discover whether the CC registers that
5376      are set/used inside of the block are used anywhere else.  If not, we can
5377      change them to be the CC register that is paired with the CR register that
5378      controls the outermost IF block.  */
5379   if (ce_info->pass > 1)
5380     {
5381       CLEAR_HARD_REG_SET (frv_ifcvt.nested_cc_ok_rewrite);
5382       for (j = CC_FIRST; j <= CC_LAST; j++)
5383         if (TEST_HARD_REG_BIT (tmp_reg->regs, j))
5384           {
5385             if (REGNO_REG_SET_P (df_get_live_in (then_bb), j))
5386               continue;
5387
5388             if (else_bb
5389                 && REGNO_REG_SET_P (df_get_live_in (else_bb), j))
5390               continue;
5391
5392             if (join_bb
5393                 && REGNO_REG_SET_P (df_get_live_in (join_bb), j))
5394               continue;
5395
5396             SET_HARD_REG_BIT (frv_ifcvt.nested_cc_ok_rewrite, j);
5397           }
5398     }
5399
5400   for (j = 0; j < frv_ifcvt.cur_scratch_regs; j++)
5401     frv_ifcvt.scratch_regs[j] = NULL_RTX;
5402
5403   frv_ifcvt.added_insns_list = NULL_RTX;
5404   frv_ifcvt.cur_scratch_regs = 0;
5405
5406   bb = (basic_block *) alloca ((2 + ce_info->num_multiple_test_blocks)
5407                                * sizeof (basic_block));
5408
5409   if (join_bb)
5410     {
5411       unsigned int regno;
5412
5413       /* Remove anything live at the beginning of the join block from being
5414          available for allocation.  */
5415       EXECUTE_IF_SET_IN_REG_SET (df_get_live_in (join_bb), 0, regno, rsi)
5416         {
5417           if (regno < FIRST_PSEUDO_REGISTER)
5418             CLEAR_HARD_REG_BIT (tmp_reg->regs, regno);
5419         }
5420     }
5421
5422   /* Add in all of the blocks in multiple &&/|| blocks to be scanned.  */
5423   num_bb = 0;
5424   if (ce_info->num_multiple_test_blocks)
5425     {
5426       basic_block multiple_test_bb = ce_info->last_test_bb;
5427
5428       while (multiple_test_bb != test_bb)
5429         {
5430           bb[num_bb++] = multiple_test_bb;
5431           multiple_test_bb = EDGE_PRED (multiple_test_bb, 0)->src;
5432         }
5433     }
5434
5435   /* Add in the THEN and ELSE blocks to be scanned.  */
5436   bb[num_bb++] = then_bb;
5437   if (else_bb)
5438     bb[num_bb++] = else_bb;
5439
5440   sub_cond_exec_reg = NULL_RTX;
5441   frv_ifcvt.num_nested_cond_exec = 0;
5442
5443   /* Scan all of the blocks for registers that must not be allocated.  */
5444   for (j = 0; j < num_bb; j++)
5445     {
5446       rtx last_insn = BB_END (bb[j]);
5447       rtx insn = BB_HEAD (bb[j]);
5448       unsigned int regno;
5449
5450       if (dump_file)
5451         fprintf (dump_file, "Scanning %s block %d, start %d, end %d\n",
5452                  (bb[j] == else_bb) ? "else" : ((bb[j] == then_bb) ? "then" : "test"),
5453                  (int) bb[j]->index,
5454                  (int) INSN_UID (BB_HEAD (bb[j])),
5455                  (int) INSN_UID (BB_END (bb[j])));
5456
5457       /* Anything live at the beginning of the block is obviously unavailable
5458          for allocation.  */
5459       EXECUTE_IF_SET_IN_REG_SET (df_get_live_in (bb[j]), 0, regno, rsi)
5460         {
5461           if (regno < FIRST_PSEUDO_REGISTER)
5462             CLEAR_HARD_REG_BIT (tmp_reg->regs, regno);
5463         }
5464
5465       /* Loop through the insns in the block.  */
5466       for (;;)
5467         {
5468           /* Mark any new registers that are created as being unavailable for
5469              allocation.  Also see if the CC register used in nested IFs can be
5470              reallocated.  */
5471           if (INSN_P (insn))
5472             {
5473               rtx pattern;
5474               rtx set;
5475               int skip_nested_if = FALSE;
5476
5477               for_each_rtx (&PATTERN (insn), frv_clear_registers_used,
5478                             (void *)&tmp_reg->regs);
5479
5480               pattern = PATTERN (insn);
5481               if (GET_CODE (pattern) == COND_EXEC)
5482                 {
5483                   rtx reg = XEXP (COND_EXEC_TEST (pattern), 0);
5484
5485                   if (reg != sub_cond_exec_reg)
5486                     {
5487                       sub_cond_exec_reg = reg;
5488                       frv_ifcvt.num_nested_cond_exec++;
5489                     }
5490                 }
5491
5492               set = single_set_pattern (pattern);
5493               if (set)
5494                 {
5495                   rtx dest = SET_DEST (set);
5496                   rtx src = SET_SRC (set);
5497
5498                   if (GET_CODE (dest) == REG)
5499                     {
5500                       int regno = REGNO (dest);
5501                       enum rtx_code src_code = GET_CODE (src);
5502
5503                       if (CC_P (regno) && src_code == COMPARE)
5504                         skip_nested_if = TRUE;
5505
5506                       else if (CR_P (regno)
5507                                && (src_code == IF_THEN_ELSE
5508                                    || COMPARISON_P (src)))
5509                         skip_nested_if = TRUE;
5510                     }
5511                 }
5512
5513               if (! skip_nested_if)
5514                 for_each_rtx (&PATTERN (insn), frv_clear_registers_used,
5515                               (void *)&frv_ifcvt.nested_cc_ok_rewrite);
5516             }
5517
5518           if (insn == last_insn)
5519             break;
5520
5521           insn = NEXT_INSN (insn);
5522         }
5523     }
5524
5525   /* If this is a nested if, rewrite the CC registers that are available to
5526      include the ones that can be rewritten, to increase the chance of being
5527      able to allocate a paired CC/CR register combination.  */
5528   if (ce_info->pass > 1)
5529     {
5530       for (j = CC_FIRST; j <= CC_LAST; j++)
5531         if (TEST_HARD_REG_BIT (frv_ifcvt.nested_cc_ok_rewrite, j))
5532           SET_HARD_REG_BIT (tmp_reg->regs, j);
5533         else
5534           CLEAR_HARD_REG_BIT (tmp_reg->regs, j);
5535     }
5536
5537   if (dump_file)
5538     {
5539       int num_gprs = 0;
5540       fprintf (dump_file, "Available GPRs: ");
5541
5542       for (j = GPR_FIRST; j <= GPR_LAST; j++)
5543         if (TEST_HARD_REG_BIT (tmp_reg->regs, j))
5544           {
5545             fprintf (dump_file, " %d [%s]", j, reg_names[j]);
5546             if (++num_gprs > GPR_TEMP_NUM+2)
5547               break;
5548           }
5549
5550       fprintf (dump_file, "%s\nAvailable CRs:  ",
5551                (num_gprs > GPR_TEMP_NUM+2) ? " ..." : "");
5552
5553       for (j = CR_FIRST; j <= CR_LAST; j++)
5554         if (TEST_HARD_REG_BIT (tmp_reg->regs, j))
5555           fprintf (dump_file, " %d [%s]", j, reg_names[j]);
5556
5557       fputs ("\n", dump_file);
5558
5559       if (ce_info->pass > 1)
5560         {
5561           fprintf (dump_file, "Modifiable CCs: ");
5562           for (j = CC_FIRST; j <= CC_LAST; j++)
5563             if (TEST_HARD_REG_BIT (tmp_reg->regs, j))
5564               fprintf (dump_file, " %d [%s]", j, reg_names[j]);
5565
5566           fprintf (dump_file, "\n%d nested COND_EXEC statements\n",
5567                    frv_ifcvt.num_nested_cond_exec);
5568         }
5569     }
5570
5571   /* Allocate the appropriate temporary condition code register.  Try to
5572      allocate the ICR/FCR register that corresponds to the ICC/FCC register so
5573      that conditional cmp's can be done.  */
5574   if (mode == CCmode || mode == CC_UNSmode || mode == CC_NZmode)
5575     {
5576       cr_class = ICR_REGS;
5577       cc_class = ICC_REGS;
5578       cc_first = ICC_FIRST;
5579       cc_last = ICC_LAST;
5580     }
5581   else if (mode == CC_FPmode)
5582     {
5583       cr_class = FCR_REGS;
5584       cc_class = FCC_REGS;
5585       cc_first = FCC_FIRST;
5586       cc_last = FCC_LAST;
5587     }
5588   else
5589     {
5590       cc_first = cc_last = 0;
5591       cr_class = cc_class = NO_REGS;
5592     }
5593
5594   cc = XEXP (true_expr, 0);
5595   nested_cc = cr = NULL_RTX;
5596   if (cc_class != NO_REGS)
5597     {
5598       /* For nested IFs and &&/||, see if we can find a CC and CR register pair
5599          so we can execute a csubcc/caddcc/cfcmps instruction.  */
5600       int cc_regno;
5601
5602       for (cc_regno = cc_first; cc_regno <= cc_last; cc_regno++)
5603         {
5604           int cr_regno = cc_regno - CC_FIRST + CR_FIRST;
5605
5606           if (TEST_HARD_REG_BIT (frv_ifcvt.tmp_reg.regs, cc_regno)
5607               && TEST_HARD_REG_BIT (frv_ifcvt.tmp_reg.regs, cr_regno))
5608             {
5609               frv_ifcvt.tmp_reg.next_reg[ (int)cr_class ] = cr_regno;
5610               cr = frv_alloc_temp_reg (tmp_reg, cr_class, CC_CCRmode, TRUE,
5611                                        TRUE);
5612
5613               frv_ifcvt.tmp_reg.next_reg[ (int)cc_class ] = cc_regno;
5614               nested_cc = frv_alloc_temp_reg (tmp_reg, cc_class, CCmode,
5615                                                   TRUE, TRUE);
5616               break;
5617             }
5618         }
5619     }
5620
5621   if (! cr)
5622     {
5623       if (dump_file)
5624         fprintf (dump_file, "Could not allocate a CR temporary register\n");
5625
5626       goto fail;
5627     }
5628
5629   if (dump_file)
5630     fprintf (dump_file,
5631              "Will use %s for conditional execution, %s for nested comparisons\n",
5632              reg_names[ REGNO (cr)],
5633              (nested_cc) ? reg_names[ REGNO (nested_cc) ] : "<none>");
5634
5635   /* Set the CCR bit.  Note for integer tests, we reverse the condition so that
5636      in an IF-THEN-ELSE sequence, we are testing the TRUE case against the CCR
5637      bit being true.  We don't do this for floating point, because of NaNs.  */
5638   code = GET_CODE (true_expr);
5639   if (GET_MODE (cc) != CC_FPmode)
5640     {
5641       code = reverse_condition (code);
5642       code_true = EQ;
5643       code_false = NE;
5644     }
5645   else
5646     {
5647       code_true = NE;
5648       code_false = EQ;
5649     }
5650
5651   check_insn = gen_rtx_SET (VOIDmode, cr,
5652                             gen_rtx_fmt_ee (code, CC_CCRmode, cc, const0_rtx));
5653
5654   /* Record the check insn to be inserted later.  */
5655   frv_ifcvt_add_insn (check_insn, BB_END (test_bb), TRUE);
5656
5657   /* Update the tests.  */
5658   frv_ifcvt.cr_reg = cr;
5659   frv_ifcvt.nested_cc_reg = nested_cc;
5660   *p_true = gen_rtx_fmt_ee (code_true, CC_CCRmode, cr, const0_rtx);
5661   *p_false = gen_rtx_fmt_ee (code_false, CC_CCRmode, cr, const0_rtx);
5662   return;
5663
5664   /* Fail, don't do this conditional execution.  */
5665  fail:
5666   *p_true = NULL_RTX;
5667   *p_false = NULL_RTX;
5668   if (dump_file)
5669     fprintf (dump_file, "Disabling this conditional execution.\n");
5670
5671   return;
5672 }
5673
5674 \f
5675 /* A C expression to modify the code described by the conditional if
5676    information CE_INFO, for the basic block BB, possibly updating the tests in
5677    TRUE_EXPR, and FALSE_EXPR for converting the && and || parts of if-then or
5678    if-then-else code to conditional instructions.  Set either TRUE_EXPR or
5679    FALSE_EXPR to a null pointer if the tests cannot be converted.  */
5680
5681 /* p_true and p_false are given expressions of the form:
5682
5683         (and (eq:CC_CCR (reg:CC_CCR)
5684                         (const_int 0))
5685              (eq:CC (reg:CC)
5686                     (const_int 0))) */
5687
5688 void
5689 frv_ifcvt_modify_multiple_tests (ce_if_block_t *ce_info,
5690                                  basic_block bb,
5691                                  rtx *p_true,
5692                                  rtx *p_false)
5693 {
5694   rtx old_true = XEXP (*p_true, 0);
5695   rtx old_false = XEXP (*p_false, 0);
5696   rtx true_expr = XEXP (*p_true, 1);
5697   rtx false_expr = XEXP (*p_false, 1);
5698   rtx test_expr;
5699   rtx old_test;
5700   rtx cr = XEXP (old_true, 0);
5701   rtx check_insn;
5702   rtx new_cr = NULL_RTX;
5703   rtx *p_new_cr = (rtx *)0;
5704   rtx if_else;
5705   rtx compare;
5706   rtx cc;
5707   enum reg_class cr_class;
5708   enum machine_mode mode = GET_MODE (true_expr);
5709   rtx (*logical_func)(rtx, rtx, rtx);
5710
5711   if (TARGET_DEBUG_COND_EXEC)
5712     {
5713       fprintf (stderr,
5714                "\n:::::::::: frv_ifcvt_modify_multiple_tests, before modification for %s\ntrue insn:\n",
5715                ce_info->and_and_p ? "&&" : "||");
5716
5717       debug_rtx (*p_true);
5718
5719       fputs ("\nfalse insn:\n", stderr);
5720       debug_rtx (*p_false);
5721     }
5722
5723   if (!TARGET_MULTI_CE)
5724     goto fail;
5725
5726   if (GET_CODE (cr) != REG)
5727     goto fail;
5728
5729   if (mode == CCmode || mode == CC_UNSmode || mode == CC_NZmode)
5730     {
5731       cr_class = ICR_REGS;
5732       p_new_cr = &frv_ifcvt.extra_int_cr;
5733     }
5734   else if (mode == CC_FPmode)
5735     {
5736       cr_class = FCR_REGS;
5737       p_new_cr = &frv_ifcvt.extra_fp_cr;
5738     }
5739   else
5740     goto fail;
5741
5742   /* Allocate a temp CR, reusing a previously allocated temp CR if we have 3 or
5743      more &&/|| tests.  */
5744   new_cr = *p_new_cr;
5745   if (! new_cr)
5746     {
5747       new_cr = *p_new_cr = frv_alloc_temp_reg (&frv_ifcvt.tmp_reg, cr_class,
5748                                                CC_CCRmode, TRUE, TRUE);
5749       if (! new_cr)
5750         goto fail;
5751     }
5752
5753   if (ce_info->and_and_p)
5754     {
5755       old_test = old_false;
5756       test_expr = true_expr;
5757       logical_func = (GET_CODE (old_true) == EQ) ? gen_andcr : gen_andncr;
5758       *p_true = gen_rtx_NE (CC_CCRmode, cr, const0_rtx);
5759       *p_false = gen_rtx_EQ (CC_CCRmode, cr, const0_rtx);
5760     }
5761   else
5762     {
5763       old_test = old_false;
5764       test_expr = false_expr;
5765       logical_func = (GET_CODE (old_false) == EQ) ? gen_orcr : gen_orncr;
5766       *p_true = gen_rtx_EQ (CC_CCRmode, cr, const0_rtx);
5767       *p_false = gen_rtx_NE (CC_CCRmode, cr, const0_rtx);
5768     }
5769
5770   /* First add the andcr/andncr/orcr/orncr, which will be added after the
5771      conditional check instruction, due to frv_ifcvt_add_insn being a LIFO
5772      stack.  */
5773   frv_ifcvt_add_insn ((*logical_func) (cr, cr, new_cr), BB_END (bb), TRUE);
5774
5775   /* Now add the conditional check insn.  */
5776   cc = XEXP (test_expr, 0);
5777   compare = gen_rtx_fmt_ee (GET_CODE (test_expr), CC_CCRmode, cc, const0_rtx);
5778   if_else = gen_rtx_IF_THEN_ELSE (CC_CCRmode, old_test, compare, const0_rtx);
5779
5780   check_insn = gen_rtx_SET (VOIDmode, new_cr, if_else);
5781
5782   /* Add the new check insn to the list of check insns that need to be
5783      inserted.  */
5784   frv_ifcvt_add_insn (check_insn, BB_END (bb), TRUE);
5785
5786   if (TARGET_DEBUG_COND_EXEC)
5787     {
5788       fputs ("\n:::::::::: frv_ifcvt_modify_multiple_tests, after modification\ntrue insn:\n",
5789              stderr);
5790
5791       debug_rtx (*p_true);
5792
5793       fputs ("\nfalse insn:\n", stderr);
5794       debug_rtx (*p_false);
5795     }
5796
5797   return;
5798
5799  fail:
5800   *p_true = *p_false = NULL_RTX;
5801
5802   /* If we allocated a CR register, release it.  */
5803   if (new_cr)
5804     {
5805       CLEAR_HARD_REG_BIT (frv_ifcvt.tmp_reg.regs, REGNO (new_cr));
5806       *p_new_cr = NULL_RTX;
5807     }
5808
5809   if (TARGET_DEBUG_COND_EXEC)
5810     fputs ("\n:::::::::: frv_ifcvt_modify_multiple_tests, failed.\n", stderr);
5811
5812   return;
5813 }
5814
5815 \f
5816 /* Return a register which will be loaded with a value if an IF block is
5817    converted to conditional execution.  This is used to rewrite instructions
5818    that use constants to ones that just use registers.  */
5819
5820 static rtx
5821 frv_ifcvt_load_value (rtx value, rtx insn ATTRIBUTE_UNUSED)
5822 {
5823   int num_alloc = frv_ifcvt.cur_scratch_regs;
5824   int i;
5825   rtx reg;
5826
5827   /* We know gr0 == 0, so replace any errant uses.  */
5828   if (value == const0_rtx)
5829     return gen_rtx_REG (SImode, GPR_FIRST);
5830
5831   /* First search all registers currently loaded to see if we have an
5832      applicable constant.  */
5833   if (CONSTANT_P (value)
5834       || (GET_CODE (value) == REG && REGNO (value) == LR_REGNO))
5835     {
5836       for (i = 0; i < num_alloc; i++)
5837         {
5838           if (rtx_equal_p (SET_SRC (frv_ifcvt.scratch_regs[i]), value))
5839             return SET_DEST (frv_ifcvt.scratch_regs[i]);
5840         }
5841     }
5842
5843   /* Have we exhausted the number of registers available?  */
5844   if (num_alloc >= GPR_TEMP_NUM)
5845     {
5846       if (dump_file)
5847         fprintf (dump_file, "Too many temporary registers allocated\n");
5848
5849       return NULL_RTX;
5850     }
5851
5852   /* Allocate the new register.  */
5853   reg = frv_alloc_temp_reg (&frv_ifcvt.tmp_reg, GPR_REGS, SImode, TRUE, TRUE);
5854   if (! reg)
5855     {
5856       if (dump_file)
5857         fputs ("Could not find a scratch register\n", dump_file);
5858
5859       return NULL_RTX;
5860     }
5861
5862   frv_ifcvt.cur_scratch_regs++;
5863   frv_ifcvt.scratch_regs[num_alloc] = gen_rtx_SET (VOIDmode, reg, value);
5864
5865   if (dump_file)
5866     {
5867       if (GET_CODE (value) == CONST_INT)
5868         fprintf (dump_file, "Register %s will hold %ld\n",
5869                  reg_names[ REGNO (reg)], (long)INTVAL (value));
5870
5871       else if (GET_CODE (value) == REG && REGNO (value) == LR_REGNO)
5872         fprintf (dump_file, "Register %s will hold LR\n",
5873                  reg_names[ REGNO (reg)]);
5874
5875       else
5876         fprintf (dump_file, "Register %s will hold a saved value\n",
5877                  reg_names[ REGNO (reg)]);
5878     }
5879
5880   return reg;
5881 }
5882
5883 \f
5884 /* Update a MEM used in conditional code that might contain an offset to put
5885    the offset into a scratch register, so that the conditional load/store
5886    operations can be used.  This function returns the original pointer if the
5887    MEM is valid to use in conditional code, NULL if we can't load up the offset
5888    into a temporary register, or the new MEM if we were successful.  */
5889
5890 static rtx
5891 frv_ifcvt_rewrite_mem (rtx mem, enum machine_mode mode, rtx insn)
5892 {
5893   rtx addr = XEXP (mem, 0);
5894
5895   if (!frv_legitimate_address_p_1 (mode, addr, reload_completed, TRUE, FALSE))
5896     {
5897       if (GET_CODE (addr) == PLUS)
5898         {
5899           rtx addr_op0 = XEXP (addr, 0);
5900           rtx addr_op1 = XEXP (addr, 1);
5901
5902           if (GET_CODE (addr_op0) == REG && CONSTANT_P (addr_op1))
5903             {
5904               rtx reg = frv_ifcvt_load_value (addr_op1, insn);
5905               if (!reg)
5906                 return NULL_RTX;
5907
5908               addr = gen_rtx_PLUS (Pmode, addr_op0, reg);
5909             }
5910
5911           else
5912             return NULL_RTX;
5913         }
5914
5915       else if (CONSTANT_P (addr))
5916         addr = frv_ifcvt_load_value (addr, insn);
5917
5918       else
5919         return NULL_RTX;
5920
5921       if (addr == NULL_RTX)
5922         return NULL_RTX;
5923
5924       else if (XEXP (mem, 0) != addr)
5925         return change_address (mem, mode, addr);
5926     }
5927
5928   return mem;
5929 }
5930
5931 \f
5932 /* Given a PATTERN, return a SET expression if this PATTERN has only a single
5933    SET, possibly conditionally executed.  It may also have CLOBBERs, USEs.  */
5934
5935 static rtx
5936 single_set_pattern (rtx pattern)
5937 {
5938   rtx set;
5939   int i;
5940
5941   if (GET_CODE (pattern) == COND_EXEC)
5942     pattern = COND_EXEC_CODE (pattern);
5943
5944   if (GET_CODE (pattern) == SET)
5945     return pattern;
5946
5947   else if (GET_CODE (pattern) == PARALLEL)
5948     {
5949       for (i = 0, set = 0; i < XVECLEN (pattern, 0); i++)
5950         {
5951           rtx sub = XVECEXP (pattern, 0, i);
5952
5953           switch (GET_CODE (sub))
5954             {
5955             case USE:
5956             case CLOBBER:
5957               break;
5958
5959             case SET:
5960               if (set)
5961                 return 0;
5962               else
5963                 set = sub;
5964               break;
5965
5966             default:
5967               return 0;
5968             }
5969         }
5970       return set;
5971     }
5972
5973   return 0;
5974 }
5975
5976 \f
5977 /* A C expression to modify the code described by the conditional if
5978    information CE_INFO with the new PATTERN in INSN.  If PATTERN is a null
5979    pointer after the IFCVT_MODIFY_INSN macro executes, it is assumed that that
5980    insn cannot be converted to be executed conditionally.  */
5981
5982 rtx
5983 frv_ifcvt_modify_insn (ce_if_block_t *ce_info,
5984                        rtx pattern,
5985                        rtx insn)
5986 {
5987   rtx orig_ce_pattern = pattern;
5988   rtx set;
5989   rtx op0;
5990   rtx op1;
5991   rtx test;
5992
5993   gcc_assert (GET_CODE (pattern) == COND_EXEC);
5994
5995   test = COND_EXEC_TEST (pattern);
5996   if (GET_CODE (test) == AND)
5997     {
5998       rtx cr = frv_ifcvt.cr_reg;
5999       rtx test_reg;
6000
6001       op0 = XEXP (test, 0);
6002       if (! rtx_equal_p (cr, XEXP (op0, 0)))
6003         goto fail;
6004
6005       op1 = XEXP (test, 1);
6006       test_reg = XEXP (op1, 0);
6007       if (GET_CODE (test_reg) != REG)
6008         goto fail;
6009
6010       /* Is this the first nested if block in this sequence?  If so, generate
6011          an andcr or andncr.  */
6012       if (! frv_ifcvt.last_nested_if_cr)
6013         {
6014           rtx and_op;
6015
6016           frv_ifcvt.last_nested_if_cr = test_reg;
6017           if (GET_CODE (op0) == NE)
6018             and_op = gen_andcr (test_reg, cr, test_reg);
6019           else
6020             and_op = gen_andncr (test_reg, cr, test_reg);
6021
6022           frv_ifcvt_add_insn (and_op, insn, TRUE);
6023         }
6024
6025       /* If this isn't the first statement in the nested if sequence, see if we
6026          are dealing with the same register.  */
6027       else if (! rtx_equal_p (test_reg, frv_ifcvt.last_nested_if_cr))
6028         goto fail;
6029
6030       COND_EXEC_TEST (pattern) = test = op1;
6031     }
6032
6033   /* If this isn't a nested if, reset state variables.  */
6034   else
6035     {
6036       frv_ifcvt.last_nested_if_cr = NULL_RTX;
6037     }
6038
6039   set = single_set_pattern (pattern);
6040   if (set)
6041     {
6042       rtx dest = SET_DEST (set);
6043       rtx src = SET_SRC (set);
6044       enum machine_mode mode = GET_MODE (dest);
6045
6046       /* Check for normal binary operators.  */
6047       if (mode == SImode && ARITHMETIC_P (src))
6048         {
6049           op0 = XEXP (src, 0);
6050           op1 = XEXP (src, 1);
6051
6052           if (integer_register_operand (op0, SImode) && CONSTANT_P (op1))
6053             {
6054               op1 = frv_ifcvt_load_value (op1, insn);
6055               if (op1)
6056                 COND_EXEC_CODE (pattern)
6057                   = gen_rtx_SET (VOIDmode, dest, gen_rtx_fmt_ee (GET_CODE (src),
6058                                                                  GET_MODE (src),
6059                                                                  op0, op1));
6060               else
6061                 goto fail;
6062             }
6063         }
6064
6065       /* For multiply by a constant, we need to handle the sign extending
6066          correctly.  Add a USE of the value after the multiply to prevent flow
6067          from cratering because only one register out of the two were used.  */
6068       else if (mode == DImode && GET_CODE (src) == MULT)
6069         {
6070           op0 = XEXP (src, 0);
6071           op1 = XEXP (src, 1);
6072           if (GET_CODE (op0) == SIGN_EXTEND && GET_CODE (op1) == CONST_INT)
6073             {
6074               op1 = frv_ifcvt_load_value (op1, insn);
6075               if (op1)
6076                 {
6077                   op1 = gen_rtx_SIGN_EXTEND (DImode, op1);
6078                   COND_EXEC_CODE (pattern)
6079                     = gen_rtx_SET (VOIDmode, dest,
6080                                    gen_rtx_MULT (DImode, op0, op1));
6081                 }
6082               else
6083                 goto fail;
6084             }
6085
6086           frv_ifcvt_add_insn (gen_use (dest), insn, FALSE);
6087         }
6088
6089       /* If we are just loading a constant created for a nested conditional
6090          execution statement, just load the constant without any conditional
6091          execution, since we know that the constant will not interfere with any
6092          other registers.  */
6093       else if (frv_ifcvt.scratch_insns_bitmap
6094                && bitmap_bit_p (frv_ifcvt.scratch_insns_bitmap,
6095                                 INSN_UID (insn))
6096                && REG_P (SET_DEST (set))
6097                /* We must not unconditionally set a scratch reg chosen
6098                   for a nested if-converted block if its incoming
6099                   value from the TEST block (or the result of the THEN
6100                   branch) could/should propagate to the JOIN block.
6101                   It suffices to test whether the register is live at
6102                   the JOIN point: if it's live there, we can infer
6103                   that we set it in the former JOIN block of the
6104                   nested if-converted block (otherwise it wouldn't
6105                   have been available as a scratch register), and it
6106                   is either propagated through or set in the other
6107                   conditional block.  It's probably not worth trying
6108                   to catch the latter case, and it could actually
6109                   limit scheduling of the combined block quite
6110                   severely.  */
6111                && ce_info->join_bb
6112                && ! (REGNO_REG_SET_P (df_get_live_in (ce_info->join_bb),
6113                                       REGNO (SET_DEST (set))))
6114                /* Similarly, we must not unconditionally set a reg
6115                   used as scratch in the THEN branch if the same reg
6116                   is live in the ELSE branch.  */
6117                && (! ce_info->else_bb
6118                    || BLOCK_FOR_INSN (insn) == ce_info->else_bb
6119                    || ! (REGNO_REG_SET_P (df_get_live_in (ce_info->else_bb),
6120                                           REGNO (SET_DEST (set))))))
6121         pattern = set;
6122
6123       else if (mode == QImode || mode == HImode || mode == SImode
6124                || mode == SFmode)
6125         {
6126           int changed_p = FALSE;
6127
6128           /* Check for just loading up a constant */
6129           if (CONSTANT_P (src) && integer_register_operand (dest, mode))
6130             {
6131               src = frv_ifcvt_load_value (src, insn);
6132               if (!src)
6133                 goto fail;
6134
6135               changed_p = TRUE;
6136             }
6137
6138           /* See if we need to fix up stores */
6139           if (GET_CODE (dest) == MEM)
6140             {
6141               rtx new_mem = frv_ifcvt_rewrite_mem (dest, mode, insn);
6142
6143               if (!new_mem)
6144                 goto fail;
6145
6146               else if (new_mem != dest)
6147                 {
6148                   changed_p = TRUE;
6149                   dest = new_mem;
6150                 }
6151             }
6152
6153           /* See if we need to fix up loads */
6154           if (GET_CODE (src) == MEM)
6155             {
6156               rtx new_mem = frv_ifcvt_rewrite_mem (src, mode, insn);
6157
6158               if (!new_mem)
6159                 goto fail;
6160
6161               else if (new_mem != src)
6162                 {
6163                   changed_p = TRUE;
6164                   src = new_mem;
6165                 }
6166             }
6167
6168           /* If either src or destination changed, redo SET.  */
6169           if (changed_p)
6170             COND_EXEC_CODE (pattern) = gen_rtx_SET (VOIDmode, dest, src);
6171         }
6172
6173       /* Rewrite a nested set cccr in terms of IF_THEN_ELSE.  Also deal with
6174          rewriting the CC register to be the same as the paired CC/CR register
6175          for nested ifs.  */
6176       else if (mode == CC_CCRmode && COMPARISON_P (src))
6177         {
6178           int regno = REGNO (XEXP (src, 0));
6179           rtx if_else;
6180
6181           if (ce_info->pass > 1
6182               && regno != (int)REGNO (frv_ifcvt.nested_cc_reg)
6183               && TEST_HARD_REG_BIT (frv_ifcvt.nested_cc_ok_rewrite, regno))
6184             {
6185               src = gen_rtx_fmt_ee (GET_CODE (src),
6186                                     CC_CCRmode,
6187                                     frv_ifcvt.nested_cc_reg,
6188                                     XEXP (src, 1));
6189             }
6190
6191           if_else = gen_rtx_IF_THEN_ELSE (CC_CCRmode, test, src, const0_rtx);
6192           pattern = gen_rtx_SET (VOIDmode, dest, if_else);
6193         }
6194
6195       /* Remap a nested compare instruction to use the paired CC/CR reg.  */
6196       else if (ce_info->pass > 1
6197                && GET_CODE (dest) == REG
6198                && CC_P (REGNO (dest))
6199                && REGNO (dest) != REGNO (frv_ifcvt.nested_cc_reg)
6200                && TEST_HARD_REG_BIT (frv_ifcvt.nested_cc_ok_rewrite,
6201                                      REGNO (dest))
6202                && GET_CODE (src) == COMPARE)
6203         {
6204           PUT_MODE (frv_ifcvt.nested_cc_reg, GET_MODE (dest));
6205           COND_EXEC_CODE (pattern)
6206             = gen_rtx_SET (VOIDmode, frv_ifcvt.nested_cc_reg, copy_rtx (src));
6207         }
6208     }
6209
6210   if (TARGET_DEBUG_COND_EXEC)
6211     {
6212       rtx orig_pattern = PATTERN (insn);
6213
6214       PATTERN (insn) = pattern;
6215       fprintf (stderr,
6216                "\n:::::::::: frv_ifcvt_modify_insn: pass = %d, insn after modification:\n",
6217                ce_info->pass);
6218
6219       debug_rtx (insn);
6220       PATTERN (insn) = orig_pattern;
6221     }
6222
6223   return pattern;
6224
6225  fail:
6226   if (TARGET_DEBUG_COND_EXEC)
6227     {
6228       rtx orig_pattern = PATTERN (insn);
6229
6230       PATTERN (insn) = orig_ce_pattern;
6231       fprintf (stderr,
6232                "\n:::::::::: frv_ifcvt_modify_insn: pass = %d, insn could not be modified:\n",
6233                ce_info->pass);
6234
6235       debug_rtx (insn);
6236       PATTERN (insn) = orig_pattern;
6237     }
6238
6239   return NULL_RTX;
6240 }
6241
6242 \f
6243 /* A C expression to perform any final machine dependent modifications in
6244    converting code to conditional execution in the code described by the
6245    conditional if information CE_INFO.  */
6246
6247 void
6248 frv_ifcvt_modify_final (ce_if_block_t *ce_info ATTRIBUTE_UNUSED)
6249 {
6250   rtx existing_insn;
6251   rtx check_insn;
6252   rtx p = frv_ifcvt.added_insns_list;
6253   int i;
6254
6255   /* Loop inserting the check insns.  The last check insn is the first test,
6256      and is the appropriate place to insert constants.  */
6257   gcc_assert (p);
6258
6259   do
6260     {
6261       rtx check_and_insert_insns = XEXP (p, 0);
6262       rtx old_p = p;
6263
6264       check_insn = XEXP (check_and_insert_insns, 0);
6265       existing_insn = XEXP (check_and_insert_insns, 1);
6266       p = XEXP (p, 1);
6267
6268       /* The jump bit is used to say that the new insn is to be inserted BEFORE
6269          the existing insn, otherwise it is to be inserted AFTER.  */
6270       if (check_and_insert_insns->jump)
6271         {
6272           emit_insn_before (check_insn, existing_insn);
6273           check_and_insert_insns->jump = 0;
6274         }
6275       else
6276         emit_insn_after (check_insn, existing_insn);
6277
6278       free_EXPR_LIST_node (check_and_insert_insns);
6279       free_EXPR_LIST_node (old_p);
6280     }
6281   while (p != NULL_RTX);
6282
6283   /* Load up any constants needed into temp gprs */
6284   for (i = 0; i < frv_ifcvt.cur_scratch_regs; i++)
6285     {
6286       rtx insn = emit_insn_before (frv_ifcvt.scratch_regs[i], existing_insn);
6287       if (! frv_ifcvt.scratch_insns_bitmap)
6288         frv_ifcvt.scratch_insns_bitmap = BITMAP_ALLOC (NULL);
6289       bitmap_set_bit (frv_ifcvt.scratch_insns_bitmap, INSN_UID (insn));
6290       frv_ifcvt.scratch_regs[i] = NULL_RTX;
6291     }
6292
6293   frv_ifcvt.added_insns_list = NULL_RTX;
6294   frv_ifcvt.cur_scratch_regs = 0;
6295 }
6296
6297 \f
6298 /* A C expression to cancel any machine dependent modifications in converting
6299    code to conditional execution in the code described by the conditional if
6300    information CE_INFO.  */
6301
6302 void
6303 frv_ifcvt_modify_cancel (ce_if_block_t *ce_info ATTRIBUTE_UNUSED)
6304 {
6305   int i;
6306   rtx p = frv_ifcvt.added_insns_list;
6307
6308   /* Loop freeing up the EXPR_LIST's allocated.  */
6309   while (p != NULL_RTX)
6310     {
6311       rtx check_and_jump = XEXP (p, 0);
6312       rtx old_p = p;
6313
6314       p = XEXP (p, 1);
6315       free_EXPR_LIST_node (check_and_jump);
6316       free_EXPR_LIST_node (old_p);
6317     }
6318
6319   /* Release any temporary gprs allocated.  */
6320   for (i = 0; i < frv_ifcvt.cur_scratch_regs; i++)
6321     frv_ifcvt.scratch_regs[i] = NULL_RTX;
6322
6323   frv_ifcvt.added_insns_list = NULL_RTX;
6324   frv_ifcvt.cur_scratch_regs = 0;
6325   return;
6326 }
6327 \f
6328 /* A C expression for the size in bytes of the trampoline, as an integer.
6329    The template is:
6330
6331         setlo #0, <jmp_reg>
6332         setlo #0, <static_chain>
6333         sethi #0, <jmp_reg>
6334         sethi #0, <static_chain>
6335         jmpl @(gr0,<jmp_reg>) */
6336
6337 int
6338 frv_trampoline_size (void)
6339 {
6340   if (TARGET_FDPIC)
6341     /* Allocate room for the function descriptor and the lddi
6342        instruction.  */
6343     return 8 + 6 * 4;
6344   return 5 /* instructions */ * 4 /* instruction size.  */;
6345 }
6346
6347 \f
6348 /* A C statement to initialize the variable parts of a trampoline.  ADDR is an
6349    RTX for the address of the trampoline; FNADDR is an RTX for the address of
6350    the nested function; STATIC_CHAIN is an RTX for the static chain value that
6351    should be passed to the function when it is called.
6352
6353    The template is:
6354
6355         setlo #0, <jmp_reg>
6356         setlo #0, <static_chain>
6357         sethi #0, <jmp_reg>
6358         sethi #0, <static_chain>
6359         jmpl @(gr0,<jmp_reg>) */
6360
6361 static void
6362 frv_trampoline_init (rtx m_tramp, tree fndecl, rtx static_chain)
6363 {
6364   rtx addr = XEXP (m_tramp, 0);
6365   rtx fnaddr = XEXP (DECL_RTL (fndecl), 0);
6366   rtx sc_reg = force_reg (Pmode, static_chain);
6367
6368   emit_library_call (gen_rtx_SYMBOL_REF (SImode, "__trampoline_setup"),
6369                      FALSE, VOIDmode, 4,
6370                      addr, Pmode,
6371                      GEN_INT (frv_trampoline_size ()), SImode,
6372                      fnaddr, Pmode,
6373                      sc_reg, Pmode);
6374 }
6375
6376 \f
6377 /* Many machines have some registers that cannot be copied directly to or from
6378    memory or even from other types of registers.  An example is the `MQ'
6379    register, which on most machines, can only be copied to or from general
6380    registers, but not memory.  Some machines allow copying all registers to and
6381    from memory, but require a scratch register for stores to some memory
6382    locations (e.g., those with symbolic address on the RT, and those with
6383    certain symbolic address on the SPARC when compiling PIC).  In some cases,
6384    both an intermediate and a scratch register are required.
6385
6386    You should define these macros to indicate to the reload phase that it may
6387    need to allocate at least one register for a reload in addition to the
6388    register to contain the data.  Specifically, if copying X to a register
6389    RCLASS in MODE requires an intermediate register, you should define
6390    `SECONDARY_INPUT_RELOAD_CLASS' to return the largest register class all of
6391    whose registers can be used as intermediate registers or scratch registers.
6392
6393    If copying a register RCLASS in MODE to X requires an intermediate or scratch
6394    register, `SECONDARY_OUTPUT_RELOAD_CLASS' should be defined to return the
6395    largest register class required.  If the requirements for input and output
6396    reloads are the same, the macro `SECONDARY_RELOAD_CLASS' should be used
6397    instead of defining both macros identically.
6398
6399    The values returned by these macros are often `GENERAL_REGS'.  Return
6400    `NO_REGS' if no spare register is needed; i.e., if X can be directly copied
6401    to or from a register of RCLASS in MODE without requiring a scratch register.
6402    Do not define this macro if it would always return `NO_REGS'.
6403
6404    If a scratch register is required (either with or without an intermediate
6405    register), you should define patterns for `reload_inM' or `reload_outM', as
6406    required..  These patterns, which will normally be implemented with a
6407    `define_expand', should be similar to the `movM' patterns, except that
6408    operand 2 is the scratch register.
6409
6410    Define constraints for the reload register and scratch register that contain
6411    a single register class.  If the original reload register (whose class is
6412    RCLASS) can meet the constraint given in the pattern, the value returned by
6413    these macros is used for the class of the scratch register.  Otherwise, two
6414    additional reload registers are required.  Their classes are obtained from
6415    the constraints in the insn pattern.
6416
6417    X might be a pseudo-register or a `subreg' of a pseudo-register, which could
6418    either be in a hard register or in memory.  Use `true_regnum' to find out;
6419    it will return -1 if the pseudo is in memory and the hard register number if
6420    it is in a register.
6421
6422    These macros should not be used in the case where a particular class of
6423    registers can only be copied to memory and not to another class of
6424    registers.  In that case, secondary reload registers are not needed and
6425    would not be helpful.  Instead, a stack location must be used to perform the
6426    copy and the `movM' pattern should use memory as an intermediate storage.
6427    This case often occurs between floating-point and general registers.  */
6428
6429 enum reg_class
6430 frv_secondary_reload_class (enum reg_class rclass,
6431                             enum machine_mode mode ATTRIBUTE_UNUSED,
6432                             rtx x)
6433 {
6434   enum reg_class ret;
6435
6436   switch (rclass)
6437     {
6438     default:
6439       ret = NO_REGS;
6440       break;
6441
6442       /* Accumulators/Accumulator guard registers need to go through floating
6443          point registers.  */
6444     case QUAD_REGS:
6445     case EVEN_REGS:
6446     case GPR_REGS:
6447       ret = NO_REGS;
6448       if (x && GET_CODE (x) == REG)
6449         {
6450           int regno = REGNO (x);
6451
6452           if (ACC_P (regno) || ACCG_P (regno))
6453             ret = FPR_REGS;
6454         }
6455       break;
6456
6457       /* Nonzero constants should be loaded into an FPR through a GPR.  */
6458     case QUAD_FPR_REGS:
6459     case FEVEN_REGS:
6460     case FPR_REGS:
6461       if (x && CONSTANT_P (x) && !ZERO_P (x))
6462         ret = GPR_REGS;
6463       else
6464         ret = NO_REGS;
6465       break;
6466
6467       /* All of these types need gpr registers.  */
6468     case ICC_REGS:
6469     case FCC_REGS:
6470     case CC_REGS:
6471     case ICR_REGS:
6472     case FCR_REGS:
6473     case CR_REGS:
6474     case LCR_REG:
6475     case LR_REG:
6476       ret = GPR_REGS;
6477       break;
6478
6479       /* The accumulators need fpr registers.  */
6480     case ACC_REGS:
6481     case EVEN_ACC_REGS:
6482     case QUAD_ACC_REGS:
6483     case ACCG_REGS:
6484       ret = FPR_REGS;
6485       break;
6486     }
6487
6488   return ret;
6489 }
6490
6491 /* This hook exists to catch the case where secondary_reload_class() is
6492    called from init_reg_autoinc() in regclass.c - before the reload optabs
6493    have been initialised.  */
6494
6495 static bool
6496 frv_secondary_reload (bool in_p, rtx x, enum reg_class reload_class,
6497                       enum machine_mode reload_mode,
6498                       secondary_reload_info * sri)
6499 {
6500   enum reg_class rclass = NO_REGS;
6501
6502   if (sri->prev_sri && sri->prev_sri->t_icode != CODE_FOR_nothing)
6503     {
6504       sri->icode = sri->prev_sri->t_icode;
6505       return NO_REGS;
6506     }
6507
6508   rclass = frv_secondary_reload_class (reload_class, reload_mode, x);
6509
6510   if (rclass != NO_REGS)
6511     {
6512       enum insn_code icode = (in_p ? reload_in_optab[(int) reload_mode]
6513                               : reload_out_optab[(int) reload_mode]);
6514       if (icode == 0)
6515         {
6516           /* This happens when then the reload_[in|out]_optabs have
6517              not been initialised.  */
6518           sri->t_icode = CODE_FOR_nothing;
6519           return rclass;
6520         }
6521     }
6522
6523   /* Fall back to the default secondary reload handler.  */
6524   return default_secondary_reload (in_p, x, reload_class, reload_mode, sri);
6525
6526 }
6527 \f
6528 /* A C expression whose value is nonzero if pseudos that have been assigned to
6529    registers of class RCLASS would likely be spilled because registers of RCLASS
6530    are needed for spill registers.
6531
6532    The default value of this macro returns 1 if RCLASS has exactly one register
6533    and zero otherwise.  On most machines, this default should be used.  Only
6534    define this macro to some other expression if pseudo allocated by
6535    `local-alloc.c' end up in memory because their hard registers were needed
6536    for spill registers.  If this macro returns nonzero for those classes, those
6537    pseudos will only be allocated by `global.c', which knows how to reallocate
6538    the pseudo to another register.  If there would not be another register
6539    available for reallocation, you should not change the definition of this
6540    macro since the only effect of such a definition would be to slow down
6541    register allocation.  */
6542
6543 int
6544 frv_class_likely_spilled_p (enum reg_class rclass)
6545 {
6546   switch (rclass)
6547     {
6548     default:
6549       break;
6550
6551     case GR8_REGS:
6552     case GR9_REGS:
6553     case GR89_REGS:
6554     case FDPIC_FPTR_REGS:
6555     case FDPIC_REGS:
6556     case ICC_REGS:
6557     case FCC_REGS:
6558     case CC_REGS:
6559     case ICR_REGS:
6560     case FCR_REGS:
6561     case CR_REGS:
6562     case LCR_REG:
6563     case LR_REG:
6564     case SPR_REGS:
6565     case QUAD_ACC_REGS:
6566     case EVEN_ACC_REGS:
6567     case ACC_REGS:
6568     case ACCG_REGS:
6569       return TRUE;
6570     }
6571
6572   return FALSE;
6573 }
6574
6575 \f
6576 /* An expression for the alignment of a structure field FIELD if the
6577    alignment computed in the usual way is COMPUTED.  GCC uses this
6578    value instead of the value in `BIGGEST_ALIGNMENT' or
6579    `BIGGEST_FIELD_ALIGNMENT', if defined, for structure fields only.  */
6580
6581 /* The definition type of the bit field data is either char, short, long or
6582    long long. The maximum bit size is the number of bits of its own type.
6583
6584    The bit field data is assigned to a storage unit that has an adequate size
6585    for bit field data retention and is located at the smallest address.
6586
6587    Consecutive bit field data are packed at consecutive bits having the same
6588    storage unit, with regard to the type, beginning with the MSB and continuing
6589    toward the LSB.
6590
6591    If a field to be assigned lies over a bit field type boundary, its
6592    assignment is completed by aligning it with a boundary suitable for the
6593    type.
6594
6595    When a bit field having a bit length of 0 is declared, it is forcibly
6596    assigned to the next storage unit.
6597
6598    e.g)
6599         struct {
6600                 int     a:2;
6601                 int     b:6;
6602                 char    c:4;
6603                 int     d:10;
6604                 int      :0;
6605                 int     f:2;
6606         } x;
6607
6608                 +0        +1        +2        +3
6609         &x      00000000  00000000  00000000  00000000
6610                 MLM----L
6611                 a    b
6612         &x+4    00000000  00000000  00000000  00000000
6613                 M--L
6614                 c
6615         &x+8    00000000  00000000  00000000  00000000
6616                 M----------L
6617                 d
6618         &x+12   00000000  00000000  00000000  00000000
6619                 ML
6620                 f
6621 */
6622
6623 int
6624 frv_adjust_field_align (tree field, int computed)
6625 {
6626   /* Make sure that the bitfield is not wider than the type.  */
6627   if (DECL_BIT_FIELD (field)
6628       && !DECL_ARTIFICIAL (field))
6629     {
6630       tree parent = DECL_CONTEXT (field);
6631       tree prev = NULL_TREE;
6632       tree cur;
6633
6634       for (cur = TYPE_FIELDS (parent); cur && cur != field; cur = TREE_CHAIN (cur))
6635         {
6636           if (TREE_CODE (cur) != FIELD_DECL)
6637             continue;
6638
6639           prev = cur;
6640         }
6641
6642       gcc_assert (cur);
6643
6644       /* If this isn't a :0 field and if the previous element is a bitfield
6645          also, see if the type is different, if so, we will need to align the
6646          bit-field to the next boundary.  */
6647       if (prev
6648           && ! DECL_PACKED (field)
6649           && ! integer_zerop (DECL_SIZE (field))
6650           && DECL_BIT_FIELD_TYPE (field) != DECL_BIT_FIELD_TYPE (prev))
6651         {
6652           int prev_align = TYPE_ALIGN (TREE_TYPE (prev));
6653           int cur_align  = TYPE_ALIGN (TREE_TYPE (field));
6654           computed = (prev_align > cur_align) ? prev_align : cur_align;
6655         }
6656     }
6657
6658   return computed;
6659 }
6660
6661 \f
6662 /* A C expression that is nonzero if it is permissible to store a value of mode
6663    MODE in hard register number REGNO (or in several registers starting with
6664    that one).  For a machine where all registers are equivalent, a suitable
6665    definition is
6666
6667         #define HARD_REGNO_MODE_OK(REGNO, MODE) 1
6668
6669    It is not necessary for this macro to check for the numbers of fixed
6670    registers, because the allocation mechanism considers them to be always
6671    occupied.
6672
6673    On some machines, double-precision values must be kept in even/odd register
6674    pairs.  The way to implement that is to define this macro to reject odd
6675    register numbers for such modes.
6676
6677    The minimum requirement for a mode to be OK in a register is that the
6678    `movMODE' instruction pattern support moves between the register and any
6679    other hard register for which the mode is OK; and that moving a value into
6680    the register and back out not alter it.
6681
6682    Since the same instruction used to move `SImode' will work for all narrower
6683    integer modes, it is not necessary on any machine for `HARD_REGNO_MODE_OK'
6684    to distinguish between these modes, provided you define patterns `movhi',
6685    etc., to take advantage of this.  This is useful because of the interaction
6686    between `HARD_REGNO_MODE_OK' and `MODES_TIEABLE_P'; it is very desirable for
6687    all integer modes to be tieable.
6688
6689    Many machines have special registers for floating point arithmetic.  Often
6690    people assume that floating point machine modes are allowed only in floating
6691    point registers.  This is not true.  Any registers that can hold integers
6692    can safely *hold* a floating point machine mode, whether or not floating
6693    arithmetic can be done on it in those registers.  Integer move instructions
6694    can be used to move the values.
6695
6696    On some machines, though, the converse is true: fixed-point machine modes
6697    may not go in floating registers.  This is true if the floating registers
6698    normalize any value stored in them, because storing a non-floating value
6699    there would garble it.  In this case, `HARD_REGNO_MODE_OK' should reject
6700    fixed-point machine modes in floating registers.  But if the floating
6701    registers do not automatically normalize, if you can store any bit pattern
6702    in one and retrieve it unchanged without a trap, then any machine mode may
6703    go in a floating register, so you can define this macro to say so.
6704
6705    The primary significance of special floating registers is rather that they
6706    are the registers acceptable in floating point arithmetic instructions.
6707    However, this is of no concern to `HARD_REGNO_MODE_OK'.  You handle it by
6708    writing the proper constraints for those instructions.
6709
6710    On some machines, the floating registers are especially slow to access, so
6711    that it is better to store a value in a stack frame than in such a register
6712    if floating point arithmetic is not being done.  As long as the floating
6713    registers are not in class `GENERAL_REGS', they will not be used unless some
6714    pattern's constraint asks for one.  */
6715
6716 int
6717 frv_hard_regno_mode_ok (int regno, enum machine_mode mode)
6718 {
6719   int base;
6720   int mask;
6721
6722   switch (mode)
6723     {
6724     case CCmode:
6725     case CC_UNSmode:
6726     case CC_NZmode:
6727       return ICC_P (regno) || GPR_P (regno);
6728
6729     case CC_CCRmode:
6730       return CR_P (regno) || GPR_P (regno);
6731
6732     case CC_FPmode:
6733       return FCC_P (regno) || GPR_P (regno);
6734
6735     default:
6736       break;
6737     }
6738
6739   /* Set BASE to the first register in REGNO's class.  Set MASK to the
6740      bits that must be clear in (REGNO - BASE) for the register to be
6741      well-aligned.  */
6742   if (INTEGRAL_MODE_P (mode) || FLOAT_MODE_P (mode) || VECTOR_MODE_P (mode))
6743     {
6744       if (ACCG_P (regno))
6745         {
6746           /* ACCGs store one byte.  Two-byte quantities must start in
6747              even-numbered registers, four-byte ones in registers whose
6748              numbers are divisible by four, and so on.  */
6749           base = ACCG_FIRST;
6750           mask = GET_MODE_SIZE (mode) - 1;
6751         }
6752       else
6753         {
6754            /* The other registers store one word.  */
6755           if (GPR_P (regno) || regno == AP_FIRST)
6756             base = GPR_FIRST;
6757
6758           else if (FPR_P (regno))
6759             base = FPR_FIRST;
6760
6761           else if (ACC_P (regno))
6762             base = ACC_FIRST;
6763
6764           else if (SPR_P (regno))
6765             return mode == SImode;
6766
6767           /* Fill in the table.  */
6768           else
6769             return 0;
6770
6771           /* Anything smaller than an SI is OK in any word-sized register.  */
6772           if (GET_MODE_SIZE (mode) < 4)
6773             return 1;
6774
6775           mask = (GET_MODE_SIZE (mode) / 4) - 1;
6776         }
6777       return (((regno - base) & mask) == 0);
6778     }
6779
6780   return 0;
6781 }
6782
6783 \f
6784 /* A C expression for the number of consecutive hard registers, starting at
6785    register number REGNO, required to hold a value of mode MODE.
6786
6787    On a machine where all registers are exactly one word, a suitable definition
6788    of this macro is
6789
6790         #define HARD_REGNO_NREGS(REGNO, MODE)            \
6791            ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1)  \
6792             / UNITS_PER_WORD))  */
6793
6794 /* On the FRV, make the CC_FP mode take 3 words in the integer registers, so
6795    that we can build the appropriate instructions to properly reload the
6796    values.  Also, make the byte-sized accumulator guards use one guard
6797    for each byte.  */
6798
6799 int
6800 frv_hard_regno_nregs (int regno, enum machine_mode mode)
6801 {
6802   if (ACCG_P (regno))
6803     return GET_MODE_SIZE (mode);
6804   else
6805     return (GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
6806 }
6807
6808 \f
6809 /* A C expression for the maximum number of consecutive registers of
6810    class RCLASS needed to hold a value of mode MODE.
6811
6812    This is closely related to the macro `HARD_REGNO_NREGS'.  In fact, the value
6813    of the macro `CLASS_MAX_NREGS (RCLASS, MODE)' should be the maximum value of
6814    `HARD_REGNO_NREGS (REGNO, MODE)' for all REGNO values in the class RCLASS.
6815
6816    This macro helps control the handling of multiple-word values in
6817    the reload pass.
6818
6819    This declaration is required.  */
6820
6821 int
6822 frv_class_max_nregs (enum reg_class rclass, enum machine_mode mode)
6823 {
6824   if (rclass == ACCG_REGS)
6825     /* An N-byte value requires N accumulator guards.  */
6826     return GET_MODE_SIZE (mode);
6827   else
6828     return (GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
6829 }
6830
6831 \f
6832 /* A C expression that is nonzero if X is a legitimate constant for an
6833    immediate operand on the target machine.  You can assume that X satisfies
6834    `CONSTANT_P', so you need not check this.  In fact, `1' is a suitable
6835    definition for this macro on machines where anything `CONSTANT_P' is valid.  */
6836
6837 int
6838 frv_legitimate_constant_p (rtx x)
6839 {
6840   enum machine_mode mode = GET_MODE (x);
6841
6842   /* frv_cannot_force_const_mem always returns true for FDPIC.  This
6843      means that the move expanders will be expected to deal with most
6844      kinds of constant, regardless of what we return here.
6845
6846      However, among its other duties, LEGITIMATE_CONSTANT_P decides whether
6847      a constant can be entered into reg_equiv_constant[].  If we return true,
6848      reload can create new instances of the constant whenever it likes.
6849
6850      The idea is therefore to accept as many constants as possible (to give
6851      reload more freedom) while rejecting constants that can only be created
6852      at certain times.  In particular, anything with a symbolic component will
6853      require use of the pseudo FDPIC register, which is only available before
6854      reload.  */
6855   if (TARGET_FDPIC)
6856     return LEGITIMATE_PIC_OPERAND_P (x);
6857
6858   /* All of the integer constants are ok.  */
6859   if (GET_CODE (x) != CONST_DOUBLE)
6860     return TRUE;
6861
6862   /* double integer constants are ok.  */
6863   if (mode == VOIDmode || mode == DImode)
6864     return TRUE;
6865
6866   /* 0 is always ok.  */
6867   if (x == CONST0_RTX (mode))
6868     return TRUE;
6869
6870   /* If floating point is just emulated, allow any constant, since it will be
6871      constructed in the GPRs.  */
6872   if (!TARGET_HAS_FPRS)
6873     return TRUE;
6874
6875   if (mode == DFmode && !TARGET_DOUBLE)
6876     return TRUE;
6877
6878   /* Otherwise store the constant away and do a load.  */
6879   return FALSE;
6880 }
6881
6882 /* Implement SELECT_CC_MODE.  Choose CC_FP for floating-point comparisons,
6883    CC_NZ for comparisons against zero in which a single Z or N flag test
6884    is enough, CC_UNS for other unsigned comparisons, and CC for other
6885    signed comparisons.  */
6886
6887 enum machine_mode
6888 frv_select_cc_mode (enum rtx_code code, rtx x, rtx y)
6889 {
6890   if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
6891     return CC_FPmode;
6892
6893   switch (code)
6894     {
6895     case EQ:
6896     case NE:
6897     case LT:
6898     case GE:
6899       return y == const0_rtx ? CC_NZmode : CCmode;
6900
6901     case GTU:
6902     case GEU:
6903     case LTU:
6904     case LEU:
6905       return y == const0_rtx ? CC_NZmode : CC_UNSmode;
6906
6907     default:
6908       return CCmode;
6909     }
6910 }
6911 \f
6912 /* A C expression for the cost of moving data from a register in class FROM to
6913    one in class TO.  The classes are expressed using the enumeration values
6914    such as `GENERAL_REGS'.  A value of 4 is the default; other values are
6915    interpreted relative to that.
6916
6917    It is not required that the cost always equal 2 when FROM is the same as TO;
6918    on some machines it is expensive to move between registers if they are not
6919    general registers.
6920
6921    If reload sees an insn consisting of a single `set' between two hard
6922    registers, and if `REGISTER_MOVE_COST' applied to their classes returns a
6923    value of 2, reload does not check to ensure that the constraints of the insn
6924    are met.  Setting a cost of other than 2 will allow reload to verify that
6925    the constraints are met.  You should do this if the `movM' pattern's
6926    constraints do not allow such copying.  */
6927
6928 #define HIGH_COST 40
6929 #define MEDIUM_COST 3
6930 #define LOW_COST 1
6931
6932 int
6933 frv_register_move_cost (enum reg_class from, enum reg_class to)
6934 {
6935   switch (from)
6936     {
6937     default:
6938       break;
6939
6940     case QUAD_REGS:
6941     case EVEN_REGS:
6942     case GPR_REGS:
6943       switch (to)
6944         {
6945         default:
6946           break;
6947
6948         case QUAD_REGS:
6949         case EVEN_REGS:
6950         case GPR_REGS:
6951           return LOW_COST;
6952
6953         case FEVEN_REGS:
6954         case FPR_REGS:
6955           return LOW_COST;
6956
6957         case LCR_REG:
6958         case LR_REG:
6959         case SPR_REGS:
6960           return LOW_COST;
6961         }
6962
6963     case FEVEN_REGS:
6964     case FPR_REGS:
6965       switch (to)
6966         {
6967         default:
6968           break;
6969
6970         case QUAD_REGS:
6971         case EVEN_REGS:
6972         case GPR_REGS:
6973         case ACC_REGS:
6974         case EVEN_ACC_REGS:
6975         case QUAD_ACC_REGS:
6976         case ACCG_REGS:
6977           return MEDIUM_COST;
6978
6979         case FEVEN_REGS:
6980         case FPR_REGS:
6981           return LOW_COST;
6982         }
6983
6984     case LCR_REG:
6985     case LR_REG:
6986     case SPR_REGS:
6987       switch (to)
6988         {
6989         default:
6990           break;
6991
6992         case QUAD_REGS:
6993         case EVEN_REGS:
6994         case GPR_REGS:
6995           return MEDIUM_COST;
6996         }
6997
6998     case ACC_REGS:
6999     case EVEN_ACC_REGS:
7000     case QUAD_ACC_REGS:
7001     case ACCG_REGS:
7002       switch (to)
7003         {
7004         default:
7005           break;
7006
7007         case FEVEN_REGS:
7008         case FPR_REGS:
7009           return MEDIUM_COST;
7010
7011         }
7012     }
7013
7014   return HIGH_COST;
7015 }
7016 \f
7017 /* Implementation of TARGET_ASM_INTEGER.  In the FRV case we need to
7018    use ".picptr" to generate safe relocations for PIC code.  We also
7019    need a fixup entry for aligned (non-debugging) code.  */
7020
7021 static bool
7022 frv_assemble_integer (rtx value, unsigned int size, int aligned_p)
7023 {
7024   if ((flag_pic || TARGET_FDPIC) && size == UNITS_PER_WORD)
7025     {
7026       if (GET_CODE (value) == CONST
7027           || GET_CODE (value) == SYMBOL_REF
7028           || GET_CODE (value) == LABEL_REF)
7029         {
7030           if (TARGET_FDPIC && GET_CODE (value) == SYMBOL_REF
7031               && SYMBOL_REF_FUNCTION_P (value))
7032             {
7033               fputs ("\t.picptr\tfuncdesc(", asm_out_file);
7034               output_addr_const (asm_out_file, value);
7035               fputs (")\n", asm_out_file);
7036               return true;
7037             }
7038           else if (TARGET_FDPIC && GET_CODE (value) == CONST
7039                    && frv_function_symbol_referenced_p (value))
7040             return false;
7041           if (aligned_p && !TARGET_FDPIC)
7042             {
7043               static int label_num = 0;
7044               char buf[256];
7045               const char *p;
7046
7047               ASM_GENERATE_INTERNAL_LABEL (buf, "LCP", label_num++);
7048               p = (* targetm.strip_name_encoding) (buf);
7049
7050               fprintf (asm_out_file, "%s:\n", p);
7051               fprintf (asm_out_file, "%s\n", FIXUP_SECTION_ASM_OP);
7052               fprintf (asm_out_file, "\t.picptr\t%s\n", p);
7053               fprintf (asm_out_file, "\t.previous\n");
7054             }
7055           assemble_integer_with_op ("\t.picptr\t", value);
7056           return true;
7057         }
7058       if (!aligned_p)
7059         {
7060           /* We've set the unaligned SI op to NULL, so we always have to
7061              handle the unaligned case here.  */
7062           assemble_integer_with_op ("\t.4byte\t", value);
7063           return true;
7064         }
7065     }
7066   return default_assemble_integer (value, size, aligned_p);
7067 }
7068
7069 /* Function to set up the backend function structure.  */
7070
7071 static struct machine_function *
7072 frv_init_machine_status (void)
7073 {
7074   return ggc_alloc_cleared_machine_function ();
7075 }
7076 \f
7077 /* Implement TARGET_SCHED_ISSUE_RATE.  */
7078
7079 int
7080 frv_issue_rate (void)
7081 {
7082   if (!TARGET_PACK)
7083     return 1;
7084
7085   switch (frv_cpu_type)
7086     {
7087     default:
7088     case FRV_CPU_FR300:
7089     case FRV_CPU_SIMPLE:
7090       return 1;
7091
7092     case FRV_CPU_FR400:
7093     case FRV_CPU_FR405:
7094     case FRV_CPU_FR450:
7095       return 2;
7096
7097     case FRV_CPU_GENERIC:
7098     case FRV_CPU_FR500:
7099     case FRV_CPU_TOMCAT:
7100       return 4;
7101
7102     case FRV_CPU_FR550:
7103       return 8;
7104     }
7105 }
7106 \f
7107 /* A for_each_rtx callback.  If X refers to an accumulator, return
7108    ACC_GROUP_ODD if the bit 2 of the register number is set and
7109    ACC_GROUP_EVEN if it is clear.  Return 0 (ACC_GROUP_NONE)
7110    otherwise.  */
7111
7112 static int
7113 frv_acc_group_1 (rtx *x, void *data ATTRIBUTE_UNUSED)
7114 {
7115   if (REG_P (*x))
7116     {
7117       if (ACC_P (REGNO (*x)))
7118         return (REGNO (*x) - ACC_FIRST) & 4 ? ACC_GROUP_ODD : ACC_GROUP_EVEN;
7119       if (ACCG_P (REGNO (*x)))
7120         return (REGNO (*x) - ACCG_FIRST) & 4 ? ACC_GROUP_ODD : ACC_GROUP_EVEN;
7121     }
7122   return 0;
7123 }
7124
7125 /* Return the value of INSN's acc_group attribute.  */
7126
7127 int
7128 frv_acc_group (rtx insn)
7129 {
7130   /* This distinction only applies to the FR550 packing constraints.  */
7131   if (frv_cpu_type != FRV_CPU_FR550)
7132     return ACC_GROUP_NONE;
7133   return for_each_rtx (&PATTERN (insn), frv_acc_group_1, 0);
7134 }
7135
7136 /* Return the index of the DFA unit in FRV_UNIT_NAMES[] that instruction
7137    INSN will try to claim first.  Since this value depends only on the
7138    type attribute, we can cache the results in FRV_TYPE_TO_UNIT[].  */
7139
7140 static unsigned int
7141 frv_insn_unit (rtx insn)
7142 {
7143   enum attr_type type;
7144
7145   type = get_attr_type (insn);
7146   if (frv_type_to_unit[type] == ARRAY_SIZE (frv_unit_codes))
7147     {
7148       /* We haven't seen this type of instruction before.  */
7149       state_t state;
7150       unsigned int unit;
7151
7152       /* Issue the instruction on its own to see which unit it prefers.  */
7153       state = alloca (state_size ());
7154       state_reset (state);
7155       state_transition (state, insn);
7156
7157       /* Find out which unit was taken.  */
7158       for (unit = 0; unit < ARRAY_SIZE (frv_unit_codes); unit++)
7159         if (cpu_unit_reservation_p (state, frv_unit_codes[unit]))
7160           break;
7161
7162       gcc_assert (unit != ARRAY_SIZE (frv_unit_codes));
7163
7164       frv_type_to_unit[type] = unit;
7165     }
7166   return frv_type_to_unit[type];
7167 }
7168
7169 /* Return true if INSN issues to a branch unit.  */
7170
7171 static bool
7172 frv_issues_to_branch_unit_p (rtx insn)
7173 {
7174   return frv_unit_groups[frv_insn_unit (insn)] == GROUP_B;
7175 }
7176 \f
7177 /* The current state of the packing pass, implemented by frv_pack_insns.  */
7178 static struct {
7179   /* The state of the pipeline DFA.  */
7180   state_t dfa_state;
7181
7182   /* Which hardware registers are set within the current packet,
7183      and the conditions under which they are set.  */
7184   regstate_t regstate[FIRST_PSEUDO_REGISTER];
7185
7186   /* The memory locations that have been modified so far in this
7187      packet.  MEM is the memref and COND is the regstate_t condition
7188      under which it is set.  */
7189   struct {
7190     rtx mem;
7191     regstate_t cond;
7192   } mems[2];
7193
7194   /* The number of valid entries in MEMS.  The value is larger than
7195      ARRAY_SIZE (mems) if there were too many mems to record.  */
7196   unsigned int num_mems;
7197
7198   /* The maximum number of instructions that can be packed together.  */
7199   unsigned int issue_rate;
7200
7201   /* The instructions in the packet, partitioned into groups.  */
7202   struct frv_packet_group {
7203     /* How many instructions in the packet belong to this group.  */
7204     unsigned int num_insns;
7205
7206     /* A list of the instructions that belong to this group, in the order
7207        they appear in the rtl stream.  */
7208     rtx insns[ARRAY_SIZE (frv_unit_codes)];
7209
7210     /* The contents of INSNS after they have been sorted into the correct
7211        assembly-language order.  Element X issues to unit X.  The list may
7212        contain extra nops.  */
7213     rtx sorted[ARRAY_SIZE (frv_unit_codes)];
7214
7215     /* The member of frv_nops[] to use in sorted[].  */
7216     rtx nop;
7217   } groups[NUM_GROUPS];
7218
7219   /* The instructions that make up the current packet.  */
7220   rtx insns[ARRAY_SIZE (frv_unit_codes)];
7221   unsigned int num_insns;
7222 } frv_packet;
7223
7224 /* Return the regstate_t flags for the given COND_EXEC condition.
7225    Abort if the condition isn't in the right form.  */
7226
7227 static int
7228 frv_cond_flags (rtx cond)
7229 {
7230   gcc_assert ((GET_CODE (cond) == EQ || GET_CODE (cond) == NE)
7231               && GET_CODE (XEXP (cond, 0)) == REG
7232               && CR_P (REGNO (XEXP (cond, 0)))
7233               && XEXP (cond, 1) == const0_rtx);
7234   return ((REGNO (XEXP (cond, 0)) - CR_FIRST)
7235           | (GET_CODE (cond) == NE
7236              ? REGSTATE_IF_TRUE
7237              : REGSTATE_IF_FALSE));
7238 }
7239
7240
7241 /* Return true if something accessed under condition COND2 can
7242    conflict with something written under condition COND1.  */
7243
7244 static bool
7245 frv_regstate_conflict_p (regstate_t cond1, regstate_t cond2)
7246 {
7247   /* If either reference was unconditional, we have a conflict.  */
7248   if ((cond1 & REGSTATE_IF_EITHER) == 0
7249       || (cond2 & REGSTATE_IF_EITHER) == 0)
7250     return true;
7251
7252   /* The references might conflict if they were controlled by
7253      different CRs.  */
7254   if ((cond1 & REGSTATE_CC_MASK) != (cond2 & REGSTATE_CC_MASK))
7255     return true;
7256
7257   /* They definitely conflict if they are controlled by the
7258      same condition.  */
7259   if ((cond1 & cond2 & REGSTATE_IF_EITHER) != 0)
7260     return true;
7261
7262   return false;
7263 }
7264
7265
7266 /* A for_each_rtx callback.  Return 1 if *X depends on an instruction in
7267    the current packet.  DATA points to a regstate_t that describes the
7268    condition under which *X might be set or used.  */
7269
7270 static int
7271 frv_registers_conflict_p_1 (rtx *x, void *data)
7272 {
7273   unsigned int regno, i;
7274   regstate_t cond;
7275
7276   cond = *(regstate_t *) data;
7277
7278   if (GET_CODE (*x) == REG)
7279     FOR_EACH_REGNO (regno, *x)
7280       if ((frv_packet.regstate[regno] & REGSTATE_MODIFIED) != 0)
7281         if (frv_regstate_conflict_p (frv_packet.regstate[regno], cond))
7282           return 1;
7283
7284   if (GET_CODE (*x) == MEM)
7285     {
7286       /* If we ran out of memory slots, assume a conflict.  */
7287       if (frv_packet.num_mems > ARRAY_SIZE (frv_packet.mems))
7288         return 1;
7289
7290       /* Check for output or true dependencies with earlier MEMs.  */
7291       for (i = 0; i < frv_packet.num_mems; i++)
7292         if (frv_regstate_conflict_p (frv_packet.mems[i].cond, cond))
7293           {
7294             if (true_dependence (frv_packet.mems[i].mem, VOIDmode,
7295                                  *x, rtx_varies_p))
7296               return 1;
7297
7298             if (output_dependence (frv_packet.mems[i].mem, *x))
7299               return 1;
7300           }
7301     }
7302
7303   /* The return values of calls aren't significant: they describe
7304      the effect of the call as a whole, not of the insn itself.  */
7305   if (GET_CODE (*x) == SET && GET_CODE (SET_SRC (*x)) == CALL)
7306     {
7307       if (for_each_rtx (&SET_SRC (*x), frv_registers_conflict_p_1, data))
7308         return 1;
7309       return -1;
7310     }
7311
7312   /* Check subexpressions.  */
7313   return 0;
7314 }
7315
7316
7317 /* Return true if something in X might depend on an instruction
7318    in the current packet.  */
7319
7320 static bool
7321 frv_registers_conflict_p (rtx x)
7322 {
7323   regstate_t flags;
7324
7325   flags = 0;
7326   if (GET_CODE (x) == COND_EXEC)
7327     {
7328       if (for_each_rtx (&XEXP (x, 0), frv_registers_conflict_p_1, &flags))
7329         return true;
7330
7331       flags |= frv_cond_flags (XEXP (x, 0));
7332       x = XEXP (x, 1);
7333     }
7334   return for_each_rtx (&x, frv_registers_conflict_p_1, &flags);
7335 }
7336
7337
7338 /* A note_stores callback.  DATA points to the regstate_t condition
7339    under which X is modified.  Update FRV_PACKET accordingly.  */
7340
7341 static void
7342 frv_registers_update_1 (rtx x, const_rtx pat ATTRIBUTE_UNUSED, void *data)
7343 {
7344   unsigned int regno;
7345
7346   if (GET_CODE (x) == REG)
7347     FOR_EACH_REGNO (regno, x)
7348       frv_packet.regstate[regno] |= *(regstate_t *) data;
7349
7350   if (GET_CODE (x) == MEM)
7351     {
7352       if (frv_packet.num_mems < ARRAY_SIZE (frv_packet.mems))
7353         {
7354           frv_packet.mems[frv_packet.num_mems].mem = x;
7355           frv_packet.mems[frv_packet.num_mems].cond = *(regstate_t *) data;
7356         }
7357       frv_packet.num_mems++;
7358     }
7359 }
7360
7361
7362 /* Update the register state information for an instruction whose
7363    body is X.  */
7364
7365 static void
7366 frv_registers_update (rtx x)
7367 {
7368   regstate_t flags;
7369
7370   flags = REGSTATE_MODIFIED;
7371   if (GET_CODE (x) == COND_EXEC)
7372     {
7373       flags |= frv_cond_flags (XEXP (x, 0));
7374       x = XEXP (x, 1);
7375     }
7376   note_stores (x, frv_registers_update_1, &flags);
7377 }
7378
7379
7380 /* Initialize frv_packet for the start of a new packet.  */
7381
7382 static void
7383 frv_start_packet (void)
7384 {
7385   enum frv_insn_group group;
7386
7387   memset (frv_packet.regstate, 0, sizeof (frv_packet.regstate));
7388   frv_packet.num_mems = 0;
7389   frv_packet.num_insns = 0;
7390   for (group = 0; group < NUM_GROUPS; group++)
7391     frv_packet.groups[group].num_insns = 0;
7392 }
7393
7394
7395 /* Likewise for the start of a new basic block.  */
7396
7397 static void
7398 frv_start_packet_block (void)
7399 {
7400   state_reset (frv_packet.dfa_state);
7401   frv_start_packet ();
7402 }
7403
7404
7405 /* Finish the current packet, if any, and start a new one.  Call
7406    HANDLE_PACKET with FRV_PACKET describing the completed packet.  */
7407
7408 static void
7409 frv_finish_packet (void (*handle_packet) (void))
7410 {
7411   if (frv_packet.num_insns > 0)
7412     {
7413       handle_packet ();
7414       state_transition (frv_packet.dfa_state, 0);
7415       frv_start_packet ();
7416     }
7417 }
7418
7419
7420 /* Return true if INSN can be added to the current packet.  Update
7421    the DFA state on success.  */
7422
7423 static bool
7424 frv_pack_insn_p (rtx insn)
7425 {
7426   /* See if the packet is already as long as it can be.  */
7427   if (frv_packet.num_insns == frv_packet.issue_rate)
7428     return false;
7429
7430   /* If the scheduler thought that an instruction should start a packet,
7431      it's usually a good idea to believe it.  It knows much more about
7432      the latencies than we do.
7433
7434      There are some exceptions though:
7435
7436        - Conditional instructions are scheduled on the assumption that
7437          they will be executed.  This is usually a good thing, since it
7438          tends to avoid unnecessary stalls in the conditional code.
7439          But we want to pack conditional instructions as tightly as
7440          possible, in order to optimize the case where they aren't
7441          executed.
7442
7443        - The scheduler will always put branches on their own, even
7444          if there's no real dependency.
7445
7446        - There's no point putting a call in its own packet unless
7447          we have to.  */
7448   if (frv_packet.num_insns > 0
7449       && GET_CODE (insn) == INSN
7450       && GET_MODE (insn) == TImode
7451       && GET_CODE (PATTERN (insn)) != COND_EXEC)
7452     return false;
7453
7454   /* Check for register conflicts.  Don't do this for setlo since any
7455      conflict will be with the partnering sethi, with which it can
7456      be packed.  */
7457   if (get_attr_type (insn) != TYPE_SETLO)
7458     if (frv_registers_conflict_p (PATTERN (insn)))
7459       return false;
7460
7461   return state_transition (frv_packet.dfa_state, insn) < 0;
7462 }
7463
7464
7465 /* Add instruction INSN to the current packet.  */
7466
7467 static void
7468 frv_add_insn_to_packet (rtx insn)
7469 {
7470   struct frv_packet_group *packet_group;
7471
7472   packet_group = &frv_packet.groups[frv_unit_groups[frv_insn_unit (insn)]];
7473   packet_group->insns[packet_group->num_insns++] = insn;
7474   frv_packet.insns[frv_packet.num_insns++] = insn;
7475
7476   frv_registers_update (PATTERN (insn));
7477 }
7478
7479
7480 /* Insert INSN (a member of frv_nops[]) into the current packet.  If the
7481    packet ends in a branch or call, insert the nop before it, otherwise
7482    add to the end.  */
7483
7484 static void
7485 frv_insert_nop_in_packet (rtx insn)
7486 {
7487   struct frv_packet_group *packet_group;
7488   rtx last;
7489
7490   packet_group = &frv_packet.groups[frv_unit_groups[frv_insn_unit (insn)]];
7491   last = frv_packet.insns[frv_packet.num_insns - 1];
7492   if (GET_CODE (last) != INSN)
7493     {
7494       insn = emit_insn_before (PATTERN (insn), last);
7495       frv_packet.insns[frv_packet.num_insns - 1] = insn;
7496       frv_packet.insns[frv_packet.num_insns++] = last;
7497     }
7498   else
7499     {
7500       insn = emit_insn_after (PATTERN (insn), last);
7501       frv_packet.insns[frv_packet.num_insns++] = insn;
7502     }
7503   packet_group->insns[packet_group->num_insns++] = insn;
7504 }
7505
7506
7507 /* If packing is enabled, divide the instructions into packets and
7508    return true.  Call HANDLE_PACKET for each complete packet.  */
7509
7510 static bool
7511 frv_for_each_packet (void (*handle_packet) (void))
7512 {
7513   rtx insn, next_insn;
7514
7515   frv_packet.issue_rate = frv_issue_rate ();
7516
7517   /* Early exit if we don't want to pack insns.  */
7518   if (!optimize
7519       || !flag_schedule_insns_after_reload
7520       || !TARGET_VLIW_BRANCH
7521       || frv_packet.issue_rate == 1)
7522     return false;
7523
7524   /* Set up the initial packing state.  */
7525   dfa_start ();
7526   frv_packet.dfa_state = alloca (state_size ());
7527
7528   frv_start_packet_block ();
7529   for (insn = get_insns (); insn != 0; insn = next_insn)
7530     {
7531       enum rtx_code code;
7532       bool eh_insn_p;
7533
7534       code = GET_CODE (insn);
7535       next_insn = NEXT_INSN (insn);
7536
7537       if (code == CODE_LABEL)
7538         {
7539           frv_finish_packet (handle_packet);
7540           frv_start_packet_block ();
7541         }
7542
7543       if (INSN_P (insn))
7544         switch (GET_CODE (PATTERN (insn)))
7545           {
7546           case USE:
7547           case CLOBBER:
7548           case ADDR_VEC:
7549           case ADDR_DIFF_VEC:
7550             break;
7551
7552           default:
7553             /* Calls mustn't be packed on a TOMCAT.  */
7554             if (GET_CODE (insn) == CALL_INSN && frv_cpu_type == FRV_CPU_TOMCAT)
7555               frv_finish_packet (handle_packet);
7556
7557             /* Since the last instruction in a packet determines the EH
7558                region, any exception-throwing instruction must come at
7559                the end of reordered packet.  Insns that issue to a
7560                branch unit are bound to come last; for others it's
7561                too hard to predict.  */
7562             eh_insn_p = (find_reg_note (insn, REG_EH_REGION, NULL) != NULL);
7563             if (eh_insn_p && !frv_issues_to_branch_unit_p (insn))
7564               frv_finish_packet (handle_packet);
7565
7566             /* Finish the current packet if we can't add INSN to it.
7567                Simulate cycles until INSN is ready to issue.  */
7568             if (!frv_pack_insn_p (insn))
7569               {
7570                 frv_finish_packet (handle_packet);
7571                 while (!frv_pack_insn_p (insn))
7572                   state_transition (frv_packet.dfa_state, 0);
7573               }
7574
7575             /* Add the instruction to the packet.  */
7576             frv_add_insn_to_packet (insn);
7577
7578             /* Calls and jumps end a packet, as do insns that throw
7579                an exception.  */
7580             if (code == CALL_INSN || code == JUMP_INSN || eh_insn_p)
7581               frv_finish_packet (handle_packet);
7582             break;
7583           }
7584     }
7585   frv_finish_packet (handle_packet);
7586   dfa_finish ();
7587   return true;
7588 }
7589 \f
7590 /* Subroutine of frv_sort_insn_group.  We are trying to sort
7591    frv_packet.groups[GROUP].sorted[0...NUM_INSNS-1] into assembly
7592    language order.  We have already picked a new position for
7593    frv_packet.groups[GROUP].sorted[X] if bit X of ISSUED is set.
7594    These instructions will occupy elements [0, LOWER_SLOT) and
7595    [UPPER_SLOT, NUM_INSNS) of the final (sorted) array.  STATE is
7596    the DFA state after issuing these instructions.
7597
7598    Try filling elements [LOWER_SLOT, UPPER_SLOT) with every permutation
7599    of the unused instructions.  Return true if one such permutation gives
7600    a valid ordering, leaving the successful permutation in sorted[].
7601    Do not modify sorted[] until a valid permutation is found.  */
7602
7603 static bool
7604 frv_sort_insn_group_1 (enum frv_insn_group group,
7605                        unsigned int lower_slot, unsigned int upper_slot,
7606                        unsigned int issued, unsigned int num_insns,
7607                        state_t state)
7608 {
7609   struct frv_packet_group *packet_group;
7610   unsigned int i;
7611   state_t test_state;
7612   size_t dfa_size;
7613   rtx insn;
7614
7615   /* Early success if we've filled all the slots.  */
7616   if (lower_slot == upper_slot)
7617     return true;
7618
7619   packet_group = &frv_packet.groups[group];
7620   dfa_size = state_size ();
7621   test_state = alloca (dfa_size);
7622
7623   /* Try issuing each unused instruction.  */
7624   for (i = num_insns - 1; i + 1 != 0; i--)
7625     if (~issued & (1 << i))
7626       {
7627         insn = packet_group->sorted[i];
7628         memcpy (test_state, state, dfa_size);
7629         if (state_transition (test_state, insn) < 0
7630             && cpu_unit_reservation_p (test_state,
7631                                        NTH_UNIT (group, upper_slot - 1))
7632             && frv_sort_insn_group_1 (group, lower_slot, upper_slot - 1,
7633                                       issued | (1 << i), num_insns,
7634                                       test_state))
7635           {
7636             packet_group->sorted[upper_slot - 1] = insn;
7637             return true;
7638           }
7639       }
7640
7641   return false;
7642 }
7643
7644 /* Compare two instructions by their frv_insn_unit.  */
7645
7646 static int
7647 frv_compare_insns (const void *first, const void *second)
7648 {
7649   const rtx *const insn1 = (rtx const *) first,
7650     *const insn2 = (rtx const *) second;
7651   return frv_insn_unit (*insn1) - frv_insn_unit (*insn2);
7652 }
7653
7654 /* Copy frv_packet.groups[GROUP].insns[] to frv_packet.groups[GROUP].sorted[]
7655    and sort it into assembly language order.  See frv.md for a description of
7656    the algorithm.  */
7657
7658 static void
7659 frv_sort_insn_group (enum frv_insn_group group)
7660 {
7661   struct frv_packet_group *packet_group;
7662   unsigned int first, i, nop, max_unit, num_slots;
7663   state_t state, test_state;
7664   size_t dfa_size;
7665
7666   packet_group = &frv_packet.groups[group];
7667
7668   /* Assume no nop is needed.  */
7669   packet_group->nop = 0;
7670
7671   if (packet_group->num_insns == 0)
7672     return;
7673
7674   /* Copy insns[] to sorted[].  */
7675   memcpy (packet_group->sorted, packet_group->insns,
7676           sizeof (rtx) * packet_group->num_insns);
7677
7678   /* Sort sorted[] by the unit that each insn tries to take first.  */
7679   if (packet_group->num_insns > 1)
7680     qsort (packet_group->sorted, packet_group->num_insns,
7681            sizeof (rtx), frv_compare_insns);
7682
7683   /* That's always enough for branch and control insns.  */
7684   if (group == GROUP_B || group == GROUP_C)
7685     return;
7686
7687   dfa_size = state_size ();
7688   state = alloca (dfa_size);
7689   test_state = alloca (dfa_size);
7690
7691   /* Find the highest FIRST such that sorted[0...FIRST-1] can issue
7692      consecutively and such that the DFA takes unit X when sorted[X]
7693      is added.  Set STATE to the new DFA state.  */
7694   state_reset (test_state);
7695   for (first = 0; first < packet_group->num_insns; first++)
7696     {
7697       memcpy (state, test_state, dfa_size);
7698       if (state_transition (test_state, packet_group->sorted[first]) >= 0
7699           || !cpu_unit_reservation_p (test_state, NTH_UNIT (group, first)))
7700         break;
7701     }
7702
7703   /* If all the instructions issued in ascending order, we're done.  */
7704   if (first == packet_group->num_insns)
7705     return;
7706
7707   /* Add nops to the end of sorted[] and try each permutation until
7708      we find one that works.  */
7709   for (nop = 0; nop < frv_num_nops; nop++)
7710     {
7711       max_unit = frv_insn_unit (frv_nops[nop]);
7712       if (frv_unit_groups[max_unit] == group)
7713         {
7714           packet_group->nop = frv_nops[nop];
7715           num_slots = UNIT_NUMBER (max_unit) + 1;
7716           for (i = packet_group->num_insns; i < num_slots; i++)
7717             packet_group->sorted[i] = frv_nops[nop];
7718           if (frv_sort_insn_group_1 (group, first, num_slots,
7719                                      (1 << first) - 1, num_slots, state))
7720             return;
7721         }
7722     }
7723   gcc_unreachable ();
7724 }
7725 \f
7726 /* Sort the current packet into assembly-language order.  Set packing
7727    flags as appropriate.  */
7728
7729 static void
7730 frv_reorder_packet (void)
7731 {
7732   unsigned int cursor[NUM_GROUPS];
7733   rtx insns[ARRAY_SIZE (frv_unit_groups)];
7734   unsigned int unit, to, from;
7735   enum frv_insn_group group;
7736   struct frv_packet_group *packet_group;
7737
7738   /* First sort each group individually.  */
7739   for (group = 0; group < NUM_GROUPS; group++)
7740     {
7741       cursor[group] = 0;
7742       frv_sort_insn_group (group);
7743     }
7744
7745   /* Go through the unit template and try add an instruction from
7746      that unit's group.  */
7747   to = 0;
7748   for (unit = 0; unit < ARRAY_SIZE (frv_unit_groups); unit++)
7749     {
7750       group = frv_unit_groups[unit];
7751       packet_group = &frv_packet.groups[group];
7752       if (cursor[group] < packet_group->num_insns)
7753         {
7754           /* frv_reorg should have added nops for us.  */
7755           gcc_assert (packet_group->sorted[cursor[group]]
7756                       != packet_group->nop);
7757           insns[to++] = packet_group->sorted[cursor[group]++];
7758         }
7759     }
7760
7761   gcc_assert (to == frv_packet.num_insns);
7762
7763   /* Clear the last instruction's packing flag, thus marking the end of
7764      a packet.  Reorder the other instructions relative to it.  */
7765   CLEAR_PACKING_FLAG (insns[to - 1]);
7766   for (from = 0; from < to - 1; from++)
7767     {
7768       remove_insn (insns[from]);
7769       add_insn_before (insns[from], insns[to - 1], NULL);
7770       SET_PACKING_FLAG (insns[from]);
7771     }
7772 }
7773
7774
7775 /* Divide instructions into packets.  Reorder the contents of each
7776    packet so that they are in the correct assembly-language order.
7777
7778    Since this pass can change the raw meaning of the rtl stream, it must
7779    only be called at the last minute, just before the instructions are
7780    written out.  */
7781
7782 static void
7783 frv_pack_insns (void)
7784 {
7785   if (frv_for_each_packet (frv_reorder_packet))
7786     frv_insn_packing_flag = 0;
7787   else
7788     frv_insn_packing_flag = -1;
7789 }
7790 \f
7791 /* See whether we need to add nops to group GROUP in order to
7792    make a valid packet.  */
7793
7794 static void
7795 frv_fill_unused_units (enum frv_insn_group group)
7796 {
7797   unsigned int non_nops, nops, i;
7798   struct frv_packet_group *packet_group;
7799
7800   packet_group = &frv_packet.groups[group];
7801
7802   /* Sort the instructions into assembly-language order.
7803      Use nops to fill slots that are otherwise unused.  */
7804   frv_sort_insn_group (group);
7805
7806   /* See how many nops are needed before the final useful instruction.  */
7807   i = nops = 0;
7808   for (non_nops = 0; non_nops < packet_group->num_insns; non_nops++)
7809     while (packet_group->sorted[i++] == packet_group->nop)
7810       nops++;
7811
7812   /* Insert that many nops into the instruction stream.  */
7813   while (nops-- > 0)
7814     frv_insert_nop_in_packet (packet_group->nop);
7815 }
7816
7817 /* Return true if accesses IO1 and IO2 refer to the same doubleword.  */
7818
7819 static bool
7820 frv_same_doubleword_p (const struct frv_io *io1, const struct frv_io *io2)
7821 {
7822   if (io1->const_address != 0 && io2->const_address != 0)
7823     return io1->const_address == io2->const_address;
7824
7825   if (io1->var_address != 0 && io2->var_address != 0)
7826     return rtx_equal_p (io1->var_address, io2->var_address);
7827
7828   return false;
7829 }
7830
7831 /* Return true if operations IO1 and IO2 are guaranteed to complete
7832    in order.  */
7833
7834 static bool
7835 frv_io_fixed_order_p (const struct frv_io *io1, const struct frv_io *io2)
7836 {
7837   /* The order of writes is always preserved.  */
7838   if (io1->type == FRV_IO_WRITE && io2->type == FRV_IO_WRITE)
7839     return true;
7840
7841   /* The order of reads isn't preserved.  */
7842   if (io1->type != FRV_IO_WRITE && io2->type != FRV_IO_WRITE)
7843     return false;
7844
7845   /* One operation is a write and the other is (or could be) a read.
7846      The order is only guaranteed if the accesses are to the same
7847      doubleword.  */
7848   return frv_same_doubleword_p (io1, io2);
7849 }
7850
7851 /* Generalize I/O operation X so that it covers both X and Y. */
7852
7853 static void
7854 frv_io_union (struct frv_io *x, const struct frv_io *y)
7855 {
7856   if (x->type != y->type)
7857     x->type = FRV_IO_UNKNOWN;
7858   if (!frv_same_doubleword_p (x, y))
7859     {
7860       x->const_address = 0;
7861       x->var_address = 0;
7862     }
7863 }
7864
7865 /* Fill IO with information about the load or store associated with
7866    membar instruction INSN.  */
7867
7868 static void
7869 frv_extract_membar (struct frv_io *io, rtx insn)
7870 {
7871   extract_insn (insn);
7872   io->type = INTVAL (recog_data.operand[2]);
7873   io->const_address = INTVAL (recog_data.operand[1]);
7874   io->var_address = XEXP (recog_data.operand[0], 0);
7875 }
7876
7877 /* A note_stores callback for which DATA points to an rtx.  Nullify *DATA
7878    if X is a register and *DATA depends on X.  */
7879
7880 static void
7881 frv_io_check_address (rtx x, const_rtx pat ATTRIBUTE_UNUSED, void *data)
7882 {
7883   rtx *other = (rtx *) data;
7884
7885   if (REG_P (x) && *other != 0 && reg_overlap_mentioned_p (x, *other))
7886     *other = 0;
7887 }
7888
7889 /* A note_stores callback for which DATA points to a HARD_REG_SET.
7890    Remove every modified register from the set.  */
7891
7892 static void
7893 frv_io_handle_set (rtx x, const_rtx pat ATTRIBUTE_UNUSED, void *data)
7894 {
7895   HARD_REG_SET *set = (HARD_REG_SET *) data;
7896   unsigned int regno;
7897
7898   if (REG_P (x))
7899     FOR_EACH_REGNO (regno, x)
7900       CLEAR_HARD_REG_BIT (*set, regno);
7901 }
7902
7903 /* A for_each_rtx callback for which DATA points to a HARD_REG_SET.
7904    Add every register in *X to the set.  */
7905
7906 static int
7907 frv_io_handle_use_1 (rtx *x, void *data)
7908 {
7909   HARD_REG_SET *set = (HARD_REG_SET *) data;
7910   unsigned int regno;
7911
7912   if (REG_P (*x))
7913     FOR_EACH_REGNO (regno, *x)
7914       SET_HARD_REG_BIT (*set, regno);
7915
7916   return 0;
7917 }
7918
7919 /* A note_stores callback that applies frv_io_handle_use_1 to an
7920    entire rhs value.  */
7921
7922 static void
7923 frv_io_handle_use (rtx *x, void *data)
7924 {
7925   for_each_rtx (x, frv_io_handle_use_1, data);
7926 }
7927
7928 /* Go through block BB looking for membars to remove.  There are two
7929    cases where intra-block analysis is enough:
7930
7931    - a membar is redundant if it occurs between two consecutive I/O
7932    operations and if those operations are guaranteed to complete
7933    in order.
7934
7935    - a membar for a __builtin_read is redundant if the result is
7936    used before the next I/O operation is issued.
7937
7938    If the last membar in the block could not be removed, and there
7939    are guaranteed to be no I/O operations between that membar and
7940    the end of the block, store the membar in *LAST_MEMBAR, otherwise
7941    store null.
7942
7943    Describe the block's first I/O operation in *NEXT_IO.  Describe
7944    an unknown operation if the block doesn't do any I/O.  */
7945
7946 static void
7947 frv_optimize_membar_local (basic_block bb, struct frv_io *next_io,
7948                            rtx *last_membar)
7949 {
7950   HARD_REG_SET used_regs;
7951   rtx next_membar, set, insn;
7952   bool next_is_end_p;
7953
7954   /* NEXT_IO is the next I/O operation to be performed after the current
7955      instruction.  It starts off as being an unknown operation.  */
7956   memset (next_io, 0, sizeof (*next_io));
7957
7958   /* NEXT_IS_END_P is true if NEXT_IO describes the end of the block.  */
7959   next_is_end_p = true;
7960
7961   /* If the current instruction is a __builtin_read or __builtin_write,
7962      NEXT_MEMBAR is the membar instruction associated with it.  NEXT_MEMBAR
7963      is null if the membar has already been deleted.
7964
7965      Note that the initialization here should only be needed to
7966      suppress warnings.  */
7967   next_membar = 0;
7968
7969   /* USED_REGS is the set of registers that are used before the
7970      next I/O instruction.  */
7971   CLEAR_HARD_REG_SET (used_regs);
7972
7973   for (insn = BB_END (bb); insn != BB_HEAD (bb); insn = PREV_INSN (insn))
7974     if (GET_CODE (insn) == CALL_INSN)
7975       {
7976         /* We can't predict what a call will do to volatile memory.  */
7977         memset (next_io, 0, sizeof (struct frv_io));
7978         next_is_end_p = false;
7979         CLEAR_HARD_REG_SET (used_regs);
7980       }
7981     else if (INSN_P (insn))
7982       switch (recog_memoized (insn))
7983         {
7984         case CODE_FOR_optional_membar_qi:
7985         case CODE_FOR_optional_membar_hi:
7986         case CODE_FOR_optional_membar_si:
7987         case CODE_FOR_optional_membar_di:
7988           next_membar = insn;
7989           if (next_is_end_p)
7990             {
7991               /* Local information isn't enough to decide whether this
7992                  membar is needed.  Stash it away for later.  */
7993               *last_membar = insn;
7994               frv_extract_membar (next_io, insn);
7995               next_is_end_p = false;
7996             }
7997           else
7998             {
7999               /* Check whether the I/O operation before INSN could be
8000                  reordered with one described by NEXT_IO.  If it can't,
8001                  INSN will not be needed.  */
8002               struct frv_io prev_io;
8003
8004               frv_extract_membar (&prev_io, insn);
8005               if (frv_io_fixed_order_p (&prev_io, next_io))
8006                 {
8007                   if (dump_file)
8008                     fprintf (dump_file,
8009                              ";; [Local] Removing membar %d since order"
8010                              " of accesses is guaranteed\n",
8011                              INSN_UID (next_membar));
8012
8013                   insn = NEXT_INSN (insn);
8014                   delete_insn (next_membar);
8015                   next_membar = 0;
8016                 }
8017               *next_io = prev_io;
8018             }
8019           break;
8020
8021         default:
8022           /* Invalidate NEXT_IO's address if it depends on something that
8023              is clobbered by INSN.  */
8024           if (next_io->var_address)
8025             note_stores (PATTERN (insn), frv_io_check_address,
8026                          &next_io->var_address);
8027
8028           /* If the next membar is associated with a __builtin_read,
8029              see if INSN reads from that address.  If it does, and if
8030              the destination register is used before the next I/O access,
8031              there is no need for the membar.  */
8032           set = PATTERN (insn);
8033           if (next_io->type == FRV_IO_READ
8034               && next_io->var_address != 0
8035               && next_membar != 0
8036               && GET_CODE (set) == SET
8037               && GET_CODE (SET_DEST (set)) == REG
8038               && TEST_HARD_REG_BIT (used_regs, REGNO (SET_DEST (set))))
8039             {
8040               rtx src;
8041
8042               src = SET_SRC (set);
8043               if (GET_CODE (src) == ZERO_EXTEND)
8044                 src = XEXP (src, 0);
8045
8046               if (GET_CODE (src) == MEM
8047                   && rtx_equal_p (XEXP (src, 0), next_io->var_address))
8048                 {
8049                   if (dump_file)
8050                     fprintf (dump_file,
8051                              ";; [Local] Removing membar %d since the target"
8052                              " of %d is used before the I/O operation\n",
8053                              INSN_UID (next_membar), INSN_UID (insn));
8054
8055                   if (next_membar == *last_membar)
8056                     *last_membar = 0;
8057
8058                   delete_insn (next_membar);
8059                   next_membar = 0;
8060                 }
8061             }
8062
8063           /* If INSN has volatile references, forget about any registers
8064              that are used after it.  Otherwise forget about uses that
8065              are (or might be) defined by INSN.  */
8066           if (volatile_refs_p (PATTERN (insn)))
8067             CLEAR_HARD_REG_SET (used_regs);
8068           else
8069             note_stores (PATTERN (insn), frv_io_handle_set, &used_regs);
8070
8071           note_uses (&PATTERN (insn), frv_io_handle_use, &used_regs);
8072           break;
8073         }
8074 }
8075
8076 /* See if MEMBAR, the last membar instruction in BB, can be removed.
8077    FIRST_IO[X] describes the first operation performed by basic block X.  */
8078
8079 static void
8080 frv_optimize_membar_global (basic_block bb, struct frv_io *first_io,
8081                             rtx membar)
8082 {
8083   struct frv_io this_io, next_io;
8084   edge succ;
8085   edge_iterator ei;
8086
8087   /* We need to keep the membar if there is an edge to the exit block.  */
8088   FOR_EACH_EDGE (succ, ei, bb->succs)
8089   /* for (succ = bb->succ; succ != 0; succ = succ->succ_next) */
8090     if (succ->dest == EXIT_BLOCK_PTR)
8091       return;
8092
8093   /* Work out the union of all successor blocks.  */
8094   ei = ei_start (bb->succs);
8095   ei_cond (ei, &succ);
8096   /* next_io = first_io[bb->succ->dest->index]; */
8097   next_io = first_io[succ->dest->index];
8098   ei = ei_start (bb->succs);
8099   if (ei_cond (ei, &succ))
8100     {
8101       for (ei_next (&ei); ei_cond (ei, &succ); ei_next (&ei))
8102         /*for (succ = bb->succ->succ_next; succ != 0; succ = succ->succ_next)*/
8103         frv_io_union (&next_io, &first_io[succ->dest->index]);
8104     }
8105   else
8106     gcc_unreachable ();
8107
8108   frv_extract_membar (&this_io, membar);
8109   if (frv_io_fixed_order_p (&this_io, &next_io))
8110     {
8111       if (dump_file)
8112         fprintf (dump_file,
8113                  ";; [Global] Removing membar %d since order of accesses"
8114                  " is guaranteed\n", INSN_UID (membar));
8115
8116       delete_insn (membar);
8117     }
8118 }
8119
8120 /* Remove redundant membars from the current function.  */
8121
8122 static void
8123 frv_optimize_membar (void)
8124 {
8125   basic_block bb;
8126   struct frv_io *first_io;
8127   rtx *last_membar;
8128
8129   compute_bb_for_insn ();
8130   first_io = XCNEWVEC (struct frv_io, last_basic_block);
8131   last_membar = XCNEWVEC (rtx, last_basic_block);
8132
8133   FOR_EACH_BB (bb)
8134     frv_optimize_membar_local (bb, &first_io[bb->index],
8135                                &last_membar[bb->index]);
8136
8137   FOR_EACH_BB (bb)
8138     if (last_membar[bb->index] != 0)
8139       frv_optimize_membar_global (bb, first_io, last_membar[bb->index]);
8140
8141   free (first_io);
8142   free (last_membar);
8143 }
8144 \f
8145 /* Used by frv_reorg to keep track of the current packet's address.  */
8146 static unsigned int frv_packet_address;
8147
8148 /* If the current packet falls through to a label, try to pad the packet
8149    with nops in order to fit the label's alignment requirements.  */
8150
8151 static void
8152 frv_align_label (void)
8153 {
8154   unsigned int alignment, target, nop;
8155   rtx x, last, barrier, label;
8156
8157   /* Walk forward to the start of the next packet.  Set ALIGNMENT to the
8158      maximum alignment of that packet, LABEL to the last label between
8159      the packets, and BARRIER to the last barrier.  */
8160   last = frv_packet.insns[frv_packet.num_insns - 1];
8161   label = barrier = 0;
8162   alignment = 4;
8163   for (x = NEXT_INSN (last); x != 0 && !INSN_P (x); x = NEXT_INSN (x))
8164     {
8165       if (LABEL_P (x))
8166         {
8167           unsigned int subalign = 1 << label_to_alignment (x);
8168           alignment = MAX (alignment, subalign);
8169           label = x;
8170         }
8171       if (BARRIER_P (x))
8172         barrier = x;
8173     }
8174
8175   /* If -malign-labels, and the packet falls through to an unaligned
8176      label, try introducing a nop to align that label to 8 bytes.  */
8177   if (TARGET_ALIGN_LABELS
8178       && label != 0
8179       && barrier == 0
8180       && frv_packet.num_insns < frv_packet.issue_rate)
8181     alignment = MAX (alignment, 8);
8182
8183   /* Advance the address to the end of the current packet.  */
8184   frv_packet_address += frv_packet.num_insns * 4;
8185
8186   /* Work out the target address, after alignment.  */
8187   target = (frv_packet_address + alignment - 1) & -alignment;
8188
8189   /* If the packet falls through to the label, try to find an efficient
8190      padding sequence.  */
8191   if (barrier == 0)
8192     {
8193       /* First try adding nops to the current packet.  */
8194       for (nop = 0; nop < frv_num_nops; nop++)
8195         while (frv_packet_address < target && frv_pack_insn_p (frv_nops[nop]))
8196           {
8197             frv_insert_nop_in_packet (frv_nops[nop]);
8198             frv_packet_address += 4;
8199           }
8200
8201       /* If we still haven't reached the target, add some new packets that
8202          contain only nops.  If there are two types of nop, insert an
8203          alternating sequence of frv_nops[0] and frv_nops[1], which will
8204          lead to packets like:
8205
8206                 nop.p
8207                 mnop.p/fnop.p
8208                 nop.p
8209                 mnop/fnop
8210
8211          etc.  Just emit frv_nops[0] if that's the only nop we have.  */
8212       last = frv_packet.insns[frv_packet.num_insns - 1];
8213       nop = 0;
8214       while (frv_packet_address < target)
8215         {
8216           last = emit_insn_after (PATTERN (frv_nops[nop]), last);
8217           frv_packet_address += 4;
8218           if (frv_num_nops > 1)
8219             nop ^= 1;
8220         }
8221     }
8222
8223   frv_packet_address = target;
8224 }
8225
8226 /* Subroutine of frv_reorg, called after each packet has been constructed
8227    in frv_packet.  */
8228
8229 static void
8230 frv_reorg_packet (void)
8231 {
8232   frv_fill_unused_units (GROUP_I);
8233   frv_fill_unused_units (GROUP_FM);
8234   frv_align_label ();
8235 }
8236
8237 /* Add an instruction with pattern NOP to frv_nops[].  */
8238
8239 static void
8240 frv_register_nop (rtx nop)
8241 {
8242   nop = make_insn_raw (nop);
8243   NEXT_INSN (nop) = 0;
8244   PREV_INSN (nop) = 0;
8245   frv_nops[frv_num_nops++] = nop;
8246 }
8247
8248 /* Implement TARGET_MACHINE_DEPENDENT_REORG.  Divide the instructions
8249    into packets and check whether we need to insert nops in order to
8250    fulfill the processor's issue requirements.  Also, if the user has
8251    requested a certain alignment for a label, try to meet that alignment
8252    by inserting nops in the previous packet.  */
8253
8254 static void
8255 frv_reorg (void)
8256 {
8257   if (optimize > 0 && TARGET_OPTIMIZE_MEMBAR && cfun->machine->has_membar_p)
8258     frv_optimize_membar ();
8259
8260   frv_num_nops = 0;
8261   frv_register_nop (gen_nop ());
8262   if (TARGET_MEDIA)
8263     frv_register_nop (gen_mnop ());
8264   if (TARGET_HARD_FLOAT)
8265     frv_register_nop (gen_fnop ());
8266
8267   /* Estimate the length of each branch.  Although this may change after
8268      we've inserted nops, it will only do so in big functions.  */
8269   shorten_branches (get_insns ());
8270
8271   frv_packet_address = 0;
8272   frv_for_each_packet (frv_reorg_packet);
8273 }
8274 \f
8275 #define def_builtin(name, type, code) \
8276   add_builtin_function ((name), (type), (code), BUILT_IN_MD, NULL, NULL)
8277
8278 struct builtin_description
8279 {
8280   enum insn_code icode;
8281   const char *name;
8282   enum frv_builtins code;
8283   enum rtx_code comparison;
8284   unsigned int flag;
8285 };
8286
8287 /* Media intrinsics that take a single, constant argument.  */
8288
8289 static struct builtin_description bdesc_set[] =
8290 {
8291   { CODE_FOR_mhdsets, "__MHDSETS", FRV_BUILTIN_MHDSETS, 0, 0 }
8292 };
8293
8294 /* Media intrinsics that take just one argument.  */
8295
8296 static struct builtin_description bdesc_1arg[] =
8297 {
8298   { CODE_FOR_mnot, "__MNOT", FRV_BUILTIN_MNOT, 0, 0 },
8299   { CODE_FOR_munpackh, "__MUNPACKH", FRV_BUILTIN_MUNPACKH, 0, 0 },
8300   { CODE_FOR_mbtoh, "__MBTOH", FRV_BUILTIN_MBTOH, 0, 0 },
8301   { CODE_FOR_mhtob, "__MHTOB", FRV_BUILTIN_MHTOB, 0, 0 },
8302   { CODE_FOR_mabshs, "__MABSHS", FRV_BUILTIN_MABSHS, 0, 0 },
8303   { CODE_FOR_scutss, "__SCUTSS", FRV_BUILTIN_SCUTSS, 0, 0 }
8304 };
8305
8306 /* Media intrinsics that take two arguments.  */
8307
8308 static struct builtin_description bdesc_2arg[] =
8309 {
8310   { CODE_FOR_mand, "__MAND", FRV_BUILTIN_MAND, 0, 0 },
8311   { CODE_FOR_mor, "__MOR", FRV_BUILTIN_MOR, 0, 0 },
8312   { CODE_FOR_mxor, "__MXOR", FRV_BUILTIN_MXOR, 0, 0 },
8313   { CODE_FOR_maveh, "__MAVEH", FRV_BUILTIN_MAVEH, 0, 0 },
8314   { CODE_FOR_msaths, "__MSATHS", FRV_BUILTIN_MSATHS, 0, 0 },
8315   { CODE_FOR_msathu, "__MSATHU", FRV_BUILTIN_MSATHU, 0, 0 },
8316   { CODE_FOR_maddhss, "__MADDHSS", FRV_BUILTIN_MADDHSS, 0, 0 },
8317   { CODE_FOR_maddhus, "__MADDHUS", FRV_BUILTIN_MADDHUS, 0, 0 },
8318   { CODE_FOR_msubhss, "__MSUBHSS", FRV_BUILTIN_MSUBHSS, 0, 0 },
8319   { CODE_FOR_msubhus, "__MSUBHUS", FRV_BUILTIN_MSUBHUS, 0, 0 },
8320   { CODE_FOR_mqaddhss, "__MQADDHSS", FRV_BUILTIN_MQADDHSS, 0, 0 },
8321   { CODE_FOR_mqaddhus, "__MQADDHUS", FRV_BUILTIN_MQADDHUS, 0, 0 },
8322   { CODE_FOR_mqsubhss, "__MQSUBHSS", FRV_BUILTIN_MQSUBHSS, 0, 0 },
8323   { CODE_FOR_mqsubhus, "__MQSUBHUS", FRV_BUILTIN_MQSUBHUS, 0, 0 },
8324   { CODE_FOR_mpackh, "__MPACKH", FRV_BUILTIN_MPACKH, 0, 0 },
8325   { CODE_FOR_mcop1, "__Mcop1", FRV_BUILTIN_MCOP1, 0, 0 },
8326   { CODE_FOR_mcop2, "__Mcop2", FRV_BUILTIN_MCOP2, 0, 0 },
8327   { CODE_FOR_mwcut, "__MWCUT", FRV_BUILTIN_MWCUT, 0, 0 },
8328   { CODE_FOR_mqsaths, "__MQSATHS", FRV_BUILTIN_MQSATHS, 0, 0 },
8329   { CODE_FOR_mqlclrhs, "__MQLCLRHS", FRV_BUILTIN_MQLCLRHS, 0, 0 },
8330   { CODE_FOR_mqlmths, "__MQLMTHS", FRV_BUILTIN_MQLMTHS, 0, 0 },
8331   { CODE_FOR_smul, "__SMUL", FRV_BUILTIN_SMUL, 0, 0 },
8332   { CODE_FOR_umul, "__UMUL", FRV_BUILTIN_UMUL, 0, 0 },
8333   { CODE_FOR_addss, "__ADDSS", FRV_BUILTIN_ADDSS, 0, 0 },
8334   { CODE_FOR_subss, "__SUBSS", FRV_BUILTIN_SUBSS, 0, 0 },
8335   { CODE_FOR_slass, "__SLASS", FRV_BUILTIN_SLASS, 0, 0 },
8336   { CODE_FOR_scan, "__SCAN", FRV_BUILTIN_SCAN, 0, 0 }
8337 };
8338
8339 /* Integer intrinsics that take two arguments and have no return value.  */
8340
8341 static struct builtin_description bdesc_int_void2arg[] =
8342 {
8343   { CODE_FOR_smass, "__SMASS", FRV_BUILTIN_SMASS, 0, 0 },
8344   { CODE_FOR_smsss, "__SMSSS", FRV_BUILTIN_SMSSS, 0, 0 },
8345   { CODE_FOR_smu, "__SMU", FRV_BUILTIN_SMU, 0, 0 }
8346 };
8347
8348 static struct builtin_description bdesc_prefetches[] =
8349 {
8350   { CODE_FOR_frv_prefetch0, "__data_prefetch0", FRV_BUILTIN_PREFETCH0, 0, 0 },
8351   { CODE_FOR_frv_prefetch, "__data_prefetch", FRV_BUILTIN_PREFETCH, 0, 0 }
8352 };
8353
8354 /* Media intrinsics that take two arguments, the first being an ACC number.  */
8355
8356 static struct builtin_description bdesc_cut[] =
8357 {
8358   { CODE_FOR_mcut, "__MCUT", FRV_BUILTIN_MCUT, 0, 0 },
8359   { CODE_FOR_mcutss, "__MCUTSS", FRV_BUILTIN_MCUTSS, 0, 0 },
8360   { CODE_FOR_mdcutssi, "__MDCUTSSI", FRV_BUILTIN_MDCUTSSI, 0, 0 }
8361 };
8362
8363 /* Two-argument media intrinsics with an immediate second argument.  */
8364
8365 static struct builtin_description bdesc_2argimm[] =
8366 {
8367   { CODE_FOR_mrotli, "__MROTLI", FRV_BUILTIN_MROTLI, 0, 0 },
8368   { CODE_FOR_mrotri, "__MROTRI", FRV_BUILTIN_MROTRI, 0, 0 },
8369   { CODE_FOR_msllhi, "__MSLLHI", FRV_BUILTIN_MSLLHI, 0, 0 },
8370   { CODE_FOR_msrlhi, "__MSRLHI", FRV_BUILTIN_MSRLHI, 0, 0 },
8371   { CODE_FOR_msrahi, "__MSRAHI", FRV_BUILTIN_MSRAHI, 0, 0 },
8372   { CODE_FOR_mexpdhw, "__MEXPDHW", FRV_BUILTIN_MEXPDHW, 0, 0 },
8373   { CODE_FOR_mexpdhd, "__MEXPDHD", FRV_BUILTIN_MEXPDHD, 0, 0 },
8374   { CODE_FOR_mdrotli, "__MDROTLI", FRV_BUILTIN_MDROTLI, 0, 0 },
8375   { CODE_FOR_mcplhi, "__MCPLHI", FRV_BUILTIN_MCPLHI, 0, 0 },
8376   { CODE_FOR_mcpli, "__MCPLI", FRV_BUILTIN_MCPLI, 0, 0 },
8377   { CODE_FOR_mhsetlos, "__MHSETLOS", FRV_BUILTIN_MHSETLOS, 0, 0 },
8378   { CODE_FOR_mhsetloh, "__MHSETLOH", FRV_BUILTIN_MHSETLOH, 0, 0 },
8379   { CODE_FOR_mhsethis, "__MHSETHIS", FRV_BUILTIN_MHSETHIS, 0, 0 },
8380   { CODE_FOR_mhsethih, "__MHSETHIH", FRV_BUILTIN_MHSETHIH, 0, 0 },
8381   { CODE_FOR_mhdseth, "__MHDSETH", FRV_BUILTIN_MHDSETH, 0, 0 },
8382   { CODE_FOR_mqsllhi, "__MQSLLHI", FRV_BUILTIN_MQSLLHI, 0, 0 },
8383   { CODE_FOR_mqsrahi, "__MQSRAHI", FRV_BUILTIN_MQSRAHI, 0, 0 }
8384 };
8385
8386 /* Media intrinsics that take two arguments and return void, the first argument
8387    being a pointer to 4 words in memory.  */
8388
8389 static struct builtin_description bdesc_void2arg[] =
8390 {
8391   { CODE_FOR_mdunpackh, "__MDUNPACKH", FRV_BUILTIN_MDUNPACKH, 0, 0 },
8392   { CODE_FOR_mbtohe, "__MBTOHE", FRV_BUILTIN_MBTOHE, 0, 0 },
8393 };
8394
8395 /* Media intrinsics that take three arguments, the first being a const_int that
8396    denotes an accumulator, and that return void.  */
8397
8398 static struct builtin_description bdesc_void3arg[] =
8399 {
8400   { CODE_FOR_mcpxrs, "__MCPXRS", FRV_BUILTIN_MCPXRS, 0, 0 },
8401   { CODE_FOR_mcpxru, "__MCPXRU", FRV_BUILTIN_MCPXRU, 0, 0 },
8402   { CODE_FOR_mcpxis, "__MCPXIS", FRV_BUILTIN_MCPXIS, 0, 0 },
8403   { CODE_FOR_mcpxiu, "__MCPXIU", FRV_BUILTIN_MCPXIU, 0, 0 },
8404   { CODE_FOR_mmulhs, "__MMULHS", FRV_BUILTIN_MMULHS, 0, 0 },
8405   { CODE_FOR_mmulhu, "__MMULHU", FRV_BUILTIN_MMULHU, 0, 0 },
8406   { CODE_FOR_mmulxhs, "__MMULXHS", FRV_BUILTIN_MMULXHS, 0, 0 },
8407   { CODE_FOR_mmulxhu, "__MMULXHU", FRV_BUILTIN_MMULXHU, 0, 0 },
8408   { CODE_FOR_mmachs, "__MMACHS", FRV_BUILTIN_MMACHS, 0, 0 },
8409   { CODE_FOR_mmachu, "__MMACHU", FRV_BUILTIN_MMACHU, 0, 0 },
8410   { CODE_FOR_mmrdhs, "__MMRDHS", FRV_BUILTIN_MMRDHS, 0, 0 },
8411   { CODE_FOR_mmrdhu, "__MMRDHU", FRV_BUILTIN_MMRDHU, 0, 0 },
8412   { CODE_FOR_mqcpxrs, "__MQCPXRS", FRV_BUILTIN_MQCPXRS, 0, 0 },
8413   { CODE_FOR_mqcpxru, "__MQCPXRU", FRV_BUILTIN_MQCPXRU, 0, 0 },
8414   { CODE_FOR_mqcpxis, "__MQCPXIS", FRV_BUILTIN_MQCPXIS, 0, 0 },
8415   { CODE_FOR_mqcpxiu, "__MQCPXIU", FRV_BUILTIN_MQCPXIU, 0, 0 },
8416   { CODE_FOR_mqmulhs, "__MQMULHS", FRV_BUILTIN_MQMULHS, 0, 0 },
8417   { CODE_FOR_mqmulhu, "__MQMULHU", FRV_BUILTIN_MQMULHU, 0, 0 },
8418   { CODE_FOR_mqmulxhs, "__MQMULXHS", FRV_BUILTIN_MQMULXHS, 0, 0 },
8419   { CODE_FOR_mqmulxhu, "__MQMULXHU", FRV_BUILTIN_MQMULXHU, 0, 0 },
8420   { CODE_FOR_mqmachs, "__MQMACHS", FRV_BUILTIN_MQMACHS, 0, 0 },
8421   { CODE_FOR_mqmachu, "__MQMACHU", FRV_BUILTIN_MQMACHU, 0, 0 },
8422   { CODE_FOR_mqxmachs, "__MQXMACHS", FRV_BUILTIN_MQXMACHS, 0, 0 },
8423   { CODE_FOR_mqxmacxhs, "__MQXMACXHS", FRV_BUILTIN_MQXMACXHS, 0, 0 },
8424   { CODE_FOR_mqmacxhs, "__MQMACXHS", FRV_BUILTIN_MQMACXHS, 0, 0 }
8425 };
8426
8427 /* Media intrinsics that take two accumulator numbers as argument and
8428    return void.  */
8429
8430 static struct builtin_description bdesc_voidacc[] =
8431 {
8432   { CODE_FOR_maddaccs, "__MADDACCS", FRV_BUILTIN_MADDACCS, 0, 0 },
8433   { CODE_FOR_msubaccs, "__MSUBACCS", FRV_BUILTIN_MSUBACCS, 0, 0 },
8434   { CODE_FOR_masaccs, "__MASACCS", FRV_BUILTIN_MASACCS, 0, 0 },
8435   { CODE_FOR_mdaddaccs, "__MDADDACCS", FRV_BUILTIN_MDADDACCS, 0, 0 },
8436   { CODE_FOR_mdsubaccs, "__MDSUBACCS", FRV_BUILTIN_MDSUBACCS, 0, 0 },
8437   { CODE_FOR_mdasaccs, "__MDASACCS", FRV_BUILTIN_MDASACCS, 0, 0 }
8438 };
8439
8440 /* Intrinsics that load a value and then issue a MEMBAR.  The load is
8441    a normal move and the ICODE is for the membar.  */
8442
8443 static struct builtin_description bdesc_loads[] =
8444 {
8445   { CODE_FOR_optional_membar_qi, "__builtin_read8",
8446     FRV_BUILTIN_READ8, 0, 0 },
8447   { CODE_FOR_optional_membar_hi, "__builtin_read16",
8448     FRV_BUILTIN_READ16, 0, 0 },
8449   { CODE_FOR_optional_membar_si, "__builtin_read32",
8450     FRV_BUILTIN_READ32, 0, 0 },
8451   { CODE_FOR_optional_membar_di, "__builtin_read64",
8452     FRV_BUILTIN_READ64, 0, 0 }
8453 };
8454
8455 /* Likewise stores.  */
8456
8457 static struct builtin_description bdesc_stores[] =
8458 {
8459   { CODE_FOR_optional_membar_qi, "__builtin_write8",
8460     FRV_BUILTIN_WRITE8, 0, 0 },
8461   { CODE_FOR_optional_membar_hi, "__builtin_write16",
8462     FRV_BUILTIN_WRITE16, 0, 0 },
8463   { CODE_FOR_optional_membar_si, "__builtin_write32",
8464     FRV_BUILTIN_WRITE32, 0, 0 },
8465   { CODE_FOR_optional_membar_di, "__builtin_write64",
8466     FRV_BUILTIN_WRITE64, 0, 0 },
8467 };
8468
8469 /* Initialize media builtins.  */
8470
8471 static void
8472 frv_init_builtins (void)
8473 {
8474   tree endlink = void_list_node;
8475   tree accumulator = integer_type_node;
8476   tree integer = integer_type_node;
8477   tree voidt = void_type_node;
8478   tree uhalf = short_unsigned_type_node;
8479   tree sword1 = long_integer_type_node;
8480   tree uword1 = long_unsigned_type_node;
8481   tree sword2 = long_long_integer_type_node;
8482   tree uword2 = long_long_unsigned_type_node;
8483   tree uword4 = build_pointer_type (uword1);
8484   tree vptr   = build_pointer_type (build_type_variant (void_type_node, 0, 1));
8485   tree ubyte  = unsigned_char_type_node;
8486   tree iacc   = integer_type_node;
8487
8488 #define UNARY(RET, T1) \
8489   build_function_type (RET, tree_cons (NULL_TREE, T1, endlink))
8490
8491 #define BINARY(RET, T1, T2) \
8492   build_function_type (RET, tree_cons (NULL_TREE, T1, \
8493                             tree_cons (NULL_TREE, T2, endlink)))
8494
8495 #define TRINARY(RET, T1, T2, T3) \
8496   build_function_type (RET, tree_cons (NULL_TREE, T1, \
8497                             tree_cons (NULL_TREE, T2, \
8498                             tree_cons (NULL_TREE, T3, endlink))))
8499
8500 #define QUAD(RET, T1, T2, T3, T4) \
8501   build_function_type (RET, tree_cons (NULL_TREE, T1, \
8502                             tree_cons (NULL_TREE, T2, \
8503                             tree_cons (NULL_TREE, T3, \
8504                             tree_cons (NULL_TREE, T4, endlink)))))
8505
8506   tree void_ftype_void = build_function_type (voidt, endlink);
8507
8508   tree void_ftype_acc = UNARY (voidt, accumulator);
8509   tree void_ftype_uw4_uw1 = BINARY (voidt, uword4, uword1);
8510   tree void_ftype_uw4_uw2 = BINARY (voidt, uword4, uword2);
8511   tree void_ftype_acc_uw1 = BINARY (voidt, accumulator, uword1);
8512   tree void_ftype_acc_acc = BINARY (voidt, accumulator, accumulator);
8513   tree void_ftype_acc_uw1_uw1 = TRINARY (voidt, accumulator, uword1, uword1);
8514   tree void_ftype_acc_sw1_sw1 = TRINARY (voidt, accumulator, sword1, sword1);
8515   tree void_ftype_acc_uw2_uw2 = TRINARY (voidt, accumulator, uword2, uword2);
8516   tree void_ftype_acc_sw2_sw2 = TRINARY (voidt, accumulator, sword2, sword2);
8517
8518   tree uw1_ftype_uw1 = UNARY (uword1, uword1);
8519   tree uw1_ftype_sw1 = UNARY (uword1, sword1);
8520   tree uw1_ftype_uw2 = UNARY (uword1, uword2);
8521   tree uw1_ftype_acc = UNARY (uword1, accumulator);
8522   tree uw1_ftype_uh_uh = BINARY (uword1, uhalf, uhalf);
8523   tree uw1_ftype_uw1_uw1 = BINARY (uword1, uword1, uword1);
8524   tree uw1_ftype_uw1_int = BINARY (uword1, uword1, integer);
8525   tree uw1_ftype_acc_uw1 = BINARY (uword1, accumulator, uword1);
8526   tree uw1_ftype_acc_sw1 = BINARY (uword1, accumulator, sword1);
8527   tree uw1_ftype_uw2_uw1 = BINARY (uword1, uword2, uword1);
8528   tree uw1_ftype_uw2_int = BINARY (uword1, uword2, integer);
8529
8530   tree sw1_ftype_int = UNARY (sword1, integer);
8531   tree sw1_ftype_sw1_sw1 = BINARY (sword1, sword1, sword1);
8532   tree sw1_ftype_sw1_int = BINARY (sword1, sword1, integer);
8533
8534   tree uw2_ftype_uw1 = UNARY (uword2, uword1);
8535   tree uw2_ftype_uw1_int = BINARY (uword2, uword1, integer);
8536   tree uw2_ftype_uw2_uw2 = BINARY (uword2, uword2, uword2);
8537   tree uw2_ftype_uw2_int = BINARY (uword2, uword2, integer);
8538   tree uw2_ftype_acc_int = BINARY (uword2, accumulator, integer);
8539   tree uw2_ftype_uh_uh_uh_uh = QUAD (uword2, uhalf, uhalf, uhalf, uhalf);
8540
8541   tree sw2_ftype_sw2_sw2 = BINARY (sword2, sword2, sword2);
8542   tree sw2_ftype_sw2_int   = BINARY (sword2, sword2, integer);
8543   tree uw2_ftype_uw1_uw1   = BINARY (uword2, uword1, uword1);
8544   tree sw2_ftype_sw1_sw1   = BINARY (sword2, sword1, sword1);
8545   tree void_ftype_sw1_sw1  = BINARY (voidt, sword1, sword1);
8546   tree void_ftype_iacc_sw2 = BINARY (voidt, iacc, sword2);
8547   tree void_ftype_iacc_sw1 = BINARY (voidt, iacc, sword1);
8548   tree sw1_ftype_sw1       = UNARY (sword1, sword1);
8549   tree sw2_ftype_iacc      = UNARY (sword2, iacc);
8550   tree sw1_ftype_iacc      = UNARY (sword1, iacc);
8551   tree void_ftype_ptr      = UNARY (voidt, const_ptr_type_node);
8552   tree uw1_ftype_vptr      = UNARY (uword1, vptr);
8553   tree uw2_ftype_vptr      = UNARY (uword2, vptr);
8554   tree void_ftype_vptr_ub  = BINARY (voidt, vptr, ubyte);
8555   tree void_ftype_vptr_uh  = BINARY (voidt, vptr, uhalf);
8556   tree void_ftype_vptr_uw1 = BINARY (voidt, vptr, uword1);
8557   tree void_ftype_vptr_uw2 = BINARY (voidt, vptr, uword2);
8558
8559   def_builtin ("__MAND", uw1_ftype_uw1_uw1, FRV_BUILTIN_MAND);
8560   def_builtin ("__MOR", uw1_ftype_uw1_uw1, FRV_BUILTIN_MOR);
8561   def_builtin ("__MXOR", uw1_ftype_uw1_uw1, FRV_BUILTIN_MXOR);
8562   def_builtin ("__MNOT", uw1_ftype_uw1, FRV_BUILTIN_MNOT);
8563   def_builtin ("__MROTLI", uw1_ftype_uw1_int, FRV_BUILTIN_MROTLI);
8564   def_builtin ("__MROTRI", uw1_ftype_uw1_int, FRV_BUILTIN_MROTRI);
8565   def_builtin ("__MWCUT", uw1_ftype_uw2_uw1, FRV_BUILTIN_MWCUT);
8566   def_builtin ("__MAVEH", uw1_ftype_uw1_uw1, FRV_BUILTIN_MAVEH);
8567   def_builtin ("__MSLLHI", uw1_ftype_uw1_int, FRV_BUILTIN_MSLLHI);
8568   def_builtin ("__MSRLHI", uw1_ftype_uw1_int, FRV_BUILTIN_MSRLHI);
8569   def_builtin ("__MSRAHI", sw1_ftype_sw1_int, FRV_BUILTIN_MSRAHI);
8570   def_builtin ("__MSATHS", sw1_ftype_sw1_sw1, FRV_BUILTIN_MSATHS);
8571   def_builtin ("__MSATHU", uw1_ftype_uw1_uw1, FRV_BUILTIN_MSATHU);
8572   def_builtin ("__MADDHSS", sw1_ftype_sw1_sw1, FRV_BUILTIN_MADDHSS);
8573   def_builtin ("__MADDHUS", uw1_ftype_uw1_uw1, FRV_BUILTIN_MADDHUS);
8574   def_builtin ("__MSUBHSS", sw1_ftype_sw1_sw1, FRV_BUILTIN_MSUBHSS);
8575   def_builtin ("__MSUBHUS", uw1_ftype_uw1_uw1, FRV_BUILTIN_MSUBHUS);
8576   def_builtin ("__MMULHS", void_ftype_acc_sw1_sw1, FRV_BUILTIN_MMULHS);
8577   def_builtin ("__MMULHU", void_ftype_acc_uw1_uw1, FRV_BUILTIN_MMULHU);
8578   def_builtin ("__MMULXHS", void_ftype_acc_sw1_sw1, FRV_BUILTIN_MMULXHS);
8579   def_builtin ("__MMULXHU", void_ftype_acc_uw1_uw1, FRV_BUILTIN_MMULXHU);
8580   def_builtin ("__MMACHS", void_ftype_acc_sw1_sw1, FRV_BUILTIN_MMACHS);
8581   def_builtin ("__MMACHU", void_ftype_acc_uw1_uw1, FRV_BUILTIN_MMACHU);
8582   def_builtin ("__MMRDHS", void_ftype_acc_sw1_sw1, FRV_BUILTIN_MMRDHS);
8583   def_builtin ("__MMRDHU", void_ftype_acc_uw1_uw1, FRV_BUILTIN_MMRDHU);
8584   def_builtin ("__MQADDHSS", sw2_ftype_sw2_sw2, FRV_BUILTIN_MQADDHSS);
8585   def_builtin ("__MQADDHUS", uw2_ftype_uw2_uw2, FRV_BUILTIN_MQADDHUS);
8586   def_builtin ("__MQSUBHSS", sw2_ftype_sw2_sw2, FRV_BUILTIN_MQSUBHSS);
8587   def_builtin ("__MQSUBHUS", uw2_ftype_uw2_uw2, FRV_BUILTIN_MQSUBHUS);
8588   def_builtin ("__MQMULHS", void_ftype_acc_sw2_sw2, FRV_BUILTIN_MQMULHS);
8589   def_builtin ("__MQMULHU", void_ftype_acc_uw2_uw2, FRV_BUILTIN_MQMULHU);
8590   def_builtin ("__MQMULXHS", void_ftype_acc_sw2_sw2, FRV_BUILTIN_MQMULXHS);
8591   def_builtin ("__MQMULXHU", void_ftype_acc_uw2_uw2, FRV_BUILTIN_MQMULXHU);
8592   def_builtin ("__MQMACHS", void_ftype_acc_sw2_sw2, FRV_BUILTIN_MQMACHS);
8593   def_builtin ("__MQMACHU", void_ftype_acc_uw2_uw2, FRV_BUILTIN_MQMACHU);
8594   def_builtin ("__MCPXRS", void_ftype_acc_sw1_sw1, FRV_BUILTIN_MCPXRS);
8595   def_builtin ("__MCPXRU", void_ftype_acc_uw1_uw1, FRV_BUILTIN_MCPXRU);
8596   def_builtin ("__MCPXIS", void_ftype_acc_sw1_sw1, FRV_BUILTIN_MCPXIS);
8597   def_builtin ("__MCPXIU", void_ftype_acc_uw1_uw1, FRV_BUILTIN_MCPXIU);
8598   def_builtin ("__MQCPXRS", void_ftype_acc_sw2_sw2, FRV_BUILTIN_MQCPXRS);
8599   def_builtin ("__MQCPXRU", void_ftype_acc_uw2_uw2, FRV_BUILTIN_MQCPXRU);
8600   def_builtin ("__MQCPXIS", void_ftype_acc_sw2_sw2, FRV_BUILTIN_MQCPXIS);
8601   def_builtin ("__MQCPXIU", void_ftype_acc_uw2_uw2, FRV_BUILTIN_MQCPXIU);
8602   def_builtin ("__MCUT", uw1_ftype_acc_uw1, FRV_BUILTIN_MCUT);
8603   def_builtin ("__MCUTSS", uw1_ftype_acc_sw1, FRV_BUILTIN_MCUTSS);
8604   def_builtin ("__MEXPDHW", uw1_ftype_uw1_int, FRV_BUILTIN_MEXPDHW);
8605   def_builtin ("__MEXPDHD", uw2_ftype_uw1_int, FRV_BUILTIN_MEXPDHD);
8606   def_builtin ("__MPACKH", uw1_ftype_uh_uh, FRV_BUILTIN_MPACKH);
8607   def_builtin ("__MUNPACKH", uw2_ftype_uw1, FRV_BUILTIN_MUNPACKH);
8608   def_builtin ("__MDPACKH", uw2_ftype_uh_uh_uh_uh, FRV_BUILTIN_MDPACKH);
8609   def_builtin ("__MDUNPACKH", void_ftype_uw4_uw2, FRV_BUILTIN_MDUNPACKH);
8610   def_builtin ("__MBTOH", uw2_ftype_uw1, FRV_BUILTIN_MBTOH);
8611   def_builtin ("__MHTOB", uw1_ftype_uw2, FRV_BUILTIN_MHTOB);
8612   def_builtin ("__MBTOHE", void_ftype_uw4_uw1, FRV_BUILTIN_MBTOHE);
8613   def_builtin ("__MCLRACC", void_ftype_acc, FRV_BUILTIN_MCLRACC);
8614   def_builtin ("__MCLRACCA", void_ftype_void, FRV_BUILTIN_MCLRACCA);
8615   def_builtin ("__MRDACC", uw1_ftype_acc, FRV_BUILTIN_MRDACC);
8616   def_builtin ("__MRDACCG", uw1_ftype_acc, FRV_BUILTIN_MRDACCG);
8617   def_builtin ("__MWTACC", void_ftype_acc_uw1, FRV_BUILTIN_MWTACC);
8618   def_builtin ("__MWTACCG", void_ftype_acc_uw1, FRV_BUILTIN_MWTACCG);
8619   def_builtin ("__Mcop1", uw1_ftype_uw1_uw1, FRV_BUILTIN_MCOP1);
8620   def_builtin ("__Mcop2", uw1_ftype_uw1_uw1, FRV_BUILTIN_MCOP2);
8621   def_builtin ("__MTRAP", void_ftype_void, FRV_BUILTIN_MTRAP);
8622   def_builtin ("__MQXMACHS", void_ftype_acc_sw2_sw2, FRV_BUILTIN_MQXMACHS);
8623   def_builtin ("__MQXMACXHS", void_ftype_acc_sw2_sw2, FRV_BUILTIN_MQXMACXHS);
8624   def_builtin ("__MQMACXHS", void_ftype_acc_sw2_sw2, FRV_BUILTIN_MQMACXHS);
8625   def_builtin ("__MADDACCS", void_ftype_acc_acc, FRV_BUILTIN_MADDACCS);
8626   def_builtin ("__MSUBACCS", void_ftype_acc_acc, FRV_BUILTIN_MSUBACCS);
8627   def_builtin ("__MASACCS", void_ftype_acc_acc, FRV_BUILTIN_MASACCS);
8628   def_builtin ("__MDADDACCS", void_ftype_acc_acc, FRV_BUILTIN_MDADDACCS);
8629   def_builtin ("__MDSUBACCS", void_ftype_acc_acc, FRV_BUILTIN_MDSUBACCS);
8630   def_builtin ("__MDASACCS", void_ftype_acc_acc, FRV_BUILTIN_MDASACCS);
8631   def_builtin ("__MABSHS", uw1_ftype_sw1, FRV_BUILTIN_MABSHS);
8632   def_builtin ("__MDROTLI", uw2_ftype_uw2_int, FRV_BUILTIN_MDROTLI);
8633   def_builtin ("__MCPLHI", uw1_ftype_uw2_int, FRV_BUILTIN_MCPLHI);
8634   def_builtin ("__MCPLI", uw1_ftype_uw2_int, FRV_BUILTIN_MCPLI);
8635   def_builtin ("__MDCUTSSI", uw2_ftype_acc_int, FRV_BUILTIN_MDCUTSSI);
8636   def_builtin ("__MQSATHS", sw2_ftype_sw2_sw2, FRV_BUILTIN_MQSATHS);
8637   def_builtin ("__MHSETLOS", sw1_ftype_sw1_int, FRV_BUILTIN_MHSETLOS);
8638   def_builtin ("__MHSETHIS", sw1_ftype_sw1_int, FRV_BUILTIN_MHSETHIS);
8639   def_builtin ("__MHDSETS", sw1_ftype_int, FRV_BUILTIN_MHDSETS);
8640   def_builtin ("__MHSETLOH", uw1_ftype_uw1_int, FRV_BUILTIN_MHSETLOH);
8641   def_builtin ("__MHSETHIH", uw1_ftype_uw1_int, FRV_BUILTIN_MHSETHIH);
8642   def_builtin ("__MHDSETH", uw1_ftype_uw1_int, FRV_BUILTIN_MHDSETH);
8643   def_builtin ("__MQLCLRHS", sw2_ftype_sw2_sw2, FRV_BUILTIN_MQLCLRHS);
8644   def_builtin ("__MQLMTHS", sw2_ftype_sw2_sw2, FRV_BUILTIN_MQLMTHS);
8645   def_builtin ("__MQSLLHI", uw2_ftype_uw2_int, FRV_BUILTIN_MQSLLHI);
8646   def_builtin ("__MQSRAHI", sw2_ftype_sw2_int, FRV_BUILTIN_MQSRAHI);
8647   def_builtin ("__SMUL", sw2_ftype_sw1_sw1, FRV_BUILTIN_SMUL);
8648   def_builtin ("__UMUL", uw2_ftype_uw1_uw1, FRV_BUILTIN_UMUL);
8649   def_builtin ("__SMASS", void_ftype_sw1_sw1, FRV_BUILTIN_SMASS);
8650   def_builtin ("__SMSSS", void_ftype_sw1_sw1, FRV_BUILTIN_SMSSS);
8651   def_builtin ("__SMU", void_ftype_sw1_sw1, FRV_BUILTIN_SMU);
8652   def_builtin ("__ADDSS", sw1_ftype_sw1_sw1, FRV_BUILTIN_ADDSS);
8653   def_builtin ("__SUBSS", sw1_ftype_sw1_sw1, FRV_BUILTIN_SUBSS);
8654   def_builtin ("__SLASS", sw1_ftype_sw1_sw1, FRV_BUILTIN_SLASS);
8655   def_builtin ("__SCAN", sw1_ftype_sw1_sw1, FRV_BUILTIN_SCAN);
8656   def_builtin ("__SCUTSS", sw1_ftype_sw1, FRV_BUILTIN_SCUTSS);
8657   def_builtin ("__IACCreadll", sw2_ftype_iacc, FRV_BUILTIN_IACCreadll);
8658   def_builtin ("__IACCreadl", sw1_ftype_iacc, FRV_BUILTIN_IACCreadl);
8659   def_builtin ("__IACCsetll", void_ftype_iacc_sw2, FRV_BUILTIN_IACCsetll);
8660   def_builtin ("__IACCsetl", void_ftype_iacc_sw1, FRV_BUILTIN_IACCsetl);
8661   def_builtin ("__data_prefetch0", void_ftype_ptr, FRV_BUILTIN_PREFETCH0);
8662   def_builtin ("__data_prefetch", void_ftype_ptr, FRV_BUILTIN_PREFETCH);
8663   def_builtin ("__builtin_read8", uw1_ftype_vptr, FRV_BUILTIN_READ8);
8664   def_builtin ("__builtin_read16", uw1_ftype_vptr, FRV_BUILTIN_READ16);
8665   def_builtin ("__builtin_read32", uw1_ftype_vptr, FRV_BUILTIN_READ32);
8666   def_builtin ("__builtin_read64", uw2_ftype_vptr, FRV_BUILTIN_READ64);
8667
8668   def_builtin ("__builtin_write8", void_ftype_vptr_ub, FRV_BUILTIN_WRITE8);
8669   def_builtin ("__builtin_write16", void_ftype_vptr_uh, FRV_BUILTIN_WRITE16);
8670   def_builtin ("__builtin_write32", void_ftype_vptr_uw1, FRV_BUILTIN_WRITE32);
8671   def_builtin ("__builtin_write64", void_ftype_vptr_uw2, FRV_BUILTIN_WRITE64);
8672
8673 #undef UNARY
8674 #undef BINARY
8675 #undef TRINARY
8676 #undef QUAD
8677 }
8678
8679 /* Set the names for various arithmetic operations according to the
8680    FRV ABI.  */
8681 static void
8682 frv_init_libfuncs (void)
8683 {
8684   set_optab_libfunc (smod_optab,     SImode, "__modi");
8685   set_optab_libfunc (umod_optab,     SImode, "__umodi");
8686
8687   set_optab_libfunc (add_optab,      DImode, "__addll");
8688   set_optab_libfunc (sub_optab,      DImode, "__subll");
8689   set_optab_libfunc (smul_optab,     DImode, "__mulll");
8690   set_optab_libfunc (sdiv_optab,     DImode, "__divll");
8691   set_optab_libfunc (smod_optab,     DImode, "__modll");
8692   set_optab_libfunc (umod_optab,     DImode, "__umodll");
8693   set_optab_libfunc (and_optab,      DImode, "__andll");
8694   set_optab_libfunc (ior_optab,      DImode, "__orll");
8695   set_optab_libfunc (xor_optab,      DImode, "__xorll");
8696   set_optab_libfunc (one_cmpl_optab, DImode, "__notll");
8697
8698   set_optab_libfunc (add_optab,      SFmode, "__addf");
8699   set_optab_libfunc (sub_optab,      SFmode, "__subf");
8700   set_optab_libfunc (smul_optab,     SFmode, "__mulf");
8701   set_optab_libfunc (sdiv_optab,     SFmode, "__divf");
8702
8703   set_optab_libfunc (add_optab,      DFmode, "__addd");
8704   set_optab_libfunc (sub_optab,      DFmode, "__subd");
8705   set_optab_libfunc (smul_optab,     DFmode, "__muld");
8706   set_optab_libfunc (sdiv_optab,     DFmode, "__divd");
8707
8708   set_conv_libfunc (sext_optab,   DFmode, SFmode, "__ftod");
8709   set_conv_libfunc (trunc_optab,  SFmode, DFmode, "__dtof");
8710
8711   set_conv_libfunc (sfix_optab,   SImode, SFmode, "__ftoi");
8712   set_conv_libfunc (sfix_optab,   DImode, SFmode, "__ftoll");
8713   set_conv_libfunc (sfix_optab,   SImode, DFmode, "__dtoi");
8714   set_conv_libfunc (sfix_optab,   DImode, DFmode, "__dtoll");
8715
8716   set_conv_libfunc (ufix_optab,   SImode, SFmode, "__ftoui");
8717   set_conv_libfunc (ufix_optab,   DImode, SFmode, "__ftoull");
8718   set_conv_libfunc (ufix_optab,   SImode, DFmode, "__dtoui");
8719   set_conv_libfunc (ufix_optab,   DImode, DFmode, "__dtoull");
8720
8721   set_conv_libfunc (sfloat_optab, SFmode, SImode, "__itof");
8722   set_conv_libfunc (sfloat_optab, SFmode, DImode, "__lltof");
8723   set_conv_libfunc (sfloat_optab, DFmode, SImode, "__itod");
8724   set_conv_libfunc (sfloat_optab, DFmode, DImode, "__lltod");
8725 }
8726
8727 /* Convert an integer constant to an accumulator register.  ICODE is the
8728    code of the target instruction, OPNUM is the number of the
8729    accumulator operand and OPVAL is the constant integer.  Try both
8730    ACC and ACCG registers; only report an error if neither fit the
8731    instruction.  */
8732
8733 static rtx
8734 frv_int_to_acc (enum insn_code icode, int opnum, rtx opval)
8735 {
8736   rtx reg;
8737   int i;
8738
8739   /* ACCs and ACCGs are implicit global registers if media intrinsics
8740      are being used.  We set up this lazily to avoid creating lots of
8741      unnecessary call_insn rtl in non-media code.  */
8742   for (i = 0; i <= ACC_MASK; i++)
8743     if ((i & ACC_MASK) == i)
8744       global_regs[i + ACC_FIRST] = global_regs[i + ACCG_FIRST] = 1;
8745
8746   if (GET_CODE (opval) != CONST_INT)
8747     {
8748       error ("accumulator is not a constant integer");
8749       return NULL_RTX;
8750     }
8751   if ((INTVAL (opval) & ~ACC_MASK) != 0)
8752     {
8753       error ("accumulator number is out of bounds");
8754       return NULL_RTX;
8755     }
8756
8757   reg = gen_rtx_REG (insn_data[icode].operand[opnum].mode,
8758                      ACC_FIRST + INTVAL (opval));
8759   if (! (*insn_data[icode].operand[opnum].predicate) (reg, VOIDmode))
8760     SET_REGNO (reg, ACCG_FIRST + INTVAL (opval));
8761
8762   if (! (*insn_data[icode].operand[opnum].predicate) (reg, VOIDmode))
8763     {
8764       error ("inappropriate accumulator for %qs", insn_data[icode].name);
8765       return NULL_RTX;
8766     }
8767   return reg;
8768 }
8769
8770 /* If an ACC rtx has mode MODE, return the mode that the matching ACCG
8771    should have.  */
8772
8773 static enum machine_mode
8774 frv_matching_accg_mode (enum machine_mode mode)
8775 {
8776   switch (mode)
8777     {
8778     case V4SImode:
8779       return V4QImode;
8780
8781     case DImode:
8782       return HImode;
8783
8784     case SImode:
8785       return QImode;
8786
8787     default:
8788       gcc_unreachable ();
8789     }
8790 }
8791
8792 /* Given that a __builtin_read or __builtin_write function is accessing
8793    address ADDRESS, return the value that should be used as operand 1
8794    of the membar.  */
8795
8796 static rtx
8797 frv_io_address_cookie (rtx address)
8798 {
8799   return (GET_CODE (address) == CONST_INT
8800           ? GEN_INT (INTVAL (address) / 8 * 8)
8801           : const0_rtx);
8802 }
8803
8804 /* Return the accumulator guard that should be paired with accumulator
8805    register ACC.  The mode of the returned register is in the same
8806    class as ACC, but is four times smaller.  */
8807
8808 rtx
8809 frv_matching_accg_for_acc (rtx acc)
8810 {
8811   return gen_rtx_REG (frv_matching_accg_mode (GET_MODE (acc)),
8812                       REGNO (acc) - ACC_FIRST + ACCG_FIRST);
8813 }
8814
8815 /* Read the requested argument from the call EXP given by INDEX.
8816    Return the value as an rtx.  */
8817
8818 static rtx
8819 frv_read_argument (tree exp, unsigned int index)
8820 {
8821   return expand_expr (CALL_EXPR_ARG (exp, index),
8822                       NULL_RTX, VOIDmode, 0);
8823 }
8824
8825 /* Like frv_read_argument, but interpret the argument as the number
8826    of an IACC register and return a (reg:MODE ...) rtx for it.  */
8827
8828 static rtx
8829 frv_read_iacc_argument (enum machine_mode mode, tree call,
8830                         unsigned int index)
8831 {
8832   int i, regno;
8833   rtx op;
8834
8835   op = frv_read_argument (call, index);
8836   if (GET_CODE (op) != CONST_INT
8837       || INTVAL (op) < 0
8838       || INTVAL (op) > IACC_LAST - IACC_FIRST
8839       || ((INTVAL (op) * 4) & (GET_MODE_SIZE (mode) - 1)) != 0)
8840     {
8841       error ("invalid IACC argument");
8842       op = const0_rtx;
8843     }
8844
8845   /* IACCs are implicit global registers.  We set up this lazily to
8846      avoid creating lots of unnecessary call_insn rtl when IACCs aren't
8847      being used.  */
8848   regno = INTVAL (op) + IACC_FIRST;
8849   for (i = 0; i < HARD_REGNO_NREGS (regno, mode); i++)
8850     global_regs[regno + i] = 1;
8851
8852   return gen_rtx_REG (mode, regno);
8853 }
8854
8855 /* Return true if OPVAL can be used for operand OPNUM of instruction ICODE.
8856    The instruction should require a constant operand of some sort.  The
8857    function prints an error if OPVAL is not valid.  */
8858
8859 static int
8860 frv_check_constant_argument (enum insn_code icode, int opnum, rtx opval)
8861 {
8862   if (GET_CODE (opval) != CONST_INT)
8863     {
8864       error ("%qs expects a constant argument", insn_data[icode].name);
8865       return FALSE;
8866     }
8867   if (! (*insn_data[icode].operand[opnum].predicate) (opval, VOIDmode))
8868     {
8869       error ("constant argument out of range for %qs", insn_data[icode].name);
8870       return FALSE;
8871     }
8872   return TRUE;
8873 }
8874
8875 /* Return a legitimate rtx for instruction ICODE's return value.  Use TARGET
8876    if it's not null, has the right mode, and satisfies operand 0's
8877    predicate.  */
8878
8879 static rtx
8880 frv_legitimize_target (enum insn_code icode, rtx target)
8881 {
8882   enum machine_mode mode = insn_data[icode].operand[0].mode;
8883
8884   if (! target
8885       || GET_MODE (target) != mode
8886       || ! (*insn_data[icode].operand[0].predicate) (target, mode))
8887     return gen_reg_rtx (mode);
8888   else
8889     return target;
8890 }
8891
8892 /* Given that ARG is being passed as operand OPNUM to instruction ICODE,
8893    check whether ARG satisfies the operand's constraints.  If it doesn't,
8894    copy ARG to a temporary register and return that.  Otherwise return ARG
8895    itself.  */
8896
8897 static rtx
8898 frv_legitimize_argument (enum insn_code icode, int opnum, rtx arg)
8899 {
8900   enum machine_mode mode = insn_data[icode].operand[opnum].mode;
8901
8902   if ((*insn_data[icode].operand[opnum].predicate) (arg, mode))
8903     return arg;
8904   else
8905     return copy_to_mode_reg (mode, arg);
8906 }
8907
8908 /* Return a volatile memory reference of mode MODE whose address is ARG.  */
8909
8910 static rtx
8911 frv_volatile_memref (enum machine_mode mode, rtx arg)
8912 {
8913   rtx mem;
8914
8915   mem = gen_rtx_MEM (mode, memory_address (mode, arg));
8916   MEM_VOLATILE_P (mem) = 1;
8917   return mem;
8918 }
8919
8920 /* Expand builtins that take a single, constant argument.  At the moment,
8921    only MHDSETS falls into this category.  */
8922
8923 static rtx
8924 frv_expand_set_builtin (enum insn_code icode, tree call, rtx target)
8925 {
8926   rtx pat;
8927   rtx op0 = frv_read_argument (call, 0);
8928
8929   if (! frv_check_constant_argument (icode, 1, op0))
8930     return NULL_RTX;
8931
8932   target = frv_legitimize_target (icode, target);
8933   pat = GEN_FCN (icode) (target, op0);
8934   if (! pat)
8935     return NULL_RTX;
8936
8937   emit_insn (pat);
8938   return target;
8939 }
8940
8941 /* Expand builtins that take one operand.  */
8942
8943 static rtx
8944 frv_expand_unop_builtin (enum insn_code icode, tree call, rtx target)
8945 {
8946   rtx pat;
8947   rtx op0 = frv_read_argument (call, 0);
8948
8949   target = frv_legitimize_target (icode, target);
8950   op0 = frv_legitimize_argument (icode, 1, op0);
8951   pat = GEN_FCN (icode) (target, op0);
8952   if (! pat)
8953     return NULL_RTX;
8954
8955   emit_insn (pat);
8956   return target;
8957 }
8958
8959 /* Expand builtins that take two operands.  */
8960
8961 static rtx
8962 frv_expand_binop_builtin (enum insn_code icode, tree call, rtx target)
8963 {
8964   rtx pat;
8965   rtx op0 = frv_read_argument (call, 0);
8966   rtx op1 = frv_read_argument (call, 1);
8967
8968   target = frv_legitimize_target (icode, target);
8969   op0 = frv_legitimize_argument (icode, 1, op0);
8970   op1 = frv_legitimize_argument (icode, 2, op1);
8971   pat = GEN_FCN (icode) (target, op0, op1);
8972   if (! pat)
8973     return NULL_RTX;
8974
8975   emit_insn (pat);
8976   return target;
8977 }
8978
8979 /* Expand cut-style builtins, which take two operands and an implicit ACCG
8980    one.  */
8981
8982 static rtx
8983 frv_expand_cut_builtin (enum insn_code icode, tree call, rtx target)
8984 {
8985   rtx pat;
8986   rtx op0 = frv_read_argument (call, 0);
8987   rtx op1 = frv_read_argument (call, 1);
8988   rtx op2;
8989
8990   target = frv_legitimize_target (icode, target);
8991   op0 = frv_int_to_acc (icode, 1, op0);
8992   if (! op0)
8993     return NULL_RTX;
8994
8995   if (icode == CODE_FOR_mdcutssi || GET_CODE (op1) == CONST_INT)
8996     {
8997       if (! frv_check_constant_argument (icode, 2, op1))
8998         return NULL_RTX;
8999     }
9000   else
9001     op1 = frv_legitimize_argument (icode, 2, op1);
9002
9003   op2 = frv_matching_accg_for_acc (op0);
9004   pat = GEN_FCN (icode) (target, op0, op1, op2);
9005   if (! pat)
9006     return NULL_RTX;
9007
9008   emit_insn (pat);
9009   return target;
9010 }
9011
9012 /* Expand builtins that take two operands and the second is immediate.  */
9013
9014 static rtx
9015 frv_expand_binopimm_builtin (enum insn_code icode, tree call, rtx target)
9016 {
9017   rtx pat;
9018   rtx op0 = frv_read_argument (call, 0);
9019   rtx op1 = frv_read_argument (call, 1);
9020
9021   if (! frv_check_constant_argument (icode, 2, op1))
9022     return NULL_RTX;
9023
9024   target = frv_legitimize_target (icode, target);
9025   op0 = frv_legitimize_argument (icode, 1, op0);
9026   pat = GEN_FCN (icode) (target, op0, op1);
9027   if (! pat)
9028     return NULL_RTX;
9029
9030   emit_insn (pat);
9031   return target;
9032 }
9033
9034 /* Expand builtins that take two operands, the first operand being a pointer to
9035    ints and return void.  */
9036
9037 static rtx
9038 frv_expand_voidbinop_builtin (enum insn_code icode, tree call)
9039 {
9040   rtx pat;
9041   rtx op0 = frv_read_argument (call, 0);
9042   rtx op1 = frv_read_argument (call, 1);
9043   enum machine_mode mode0 = insn_data[icode].operand[0].mode;
9044   rtx addr;
9045
9046   if (GET_CODE (op0) != MEM)
9047     {
9048       rtx reg = op0;
9049
9050       if (! offsettable_address_p (0, mode0, op0))
9051         {
9052           reg = gen_reg_rtx (Pmode);
9053           emit_insn (gen_rtx_SET (VOIDmode, reg, op0));
9054         }
9055
9056       op0 = gen_rtx_MEM (SImode, reg);
9057     }
9058
9059   addr = XEXP (op0, 0);
9060   if (! offsettable_address_p (0, mode0, addr))
9061     addr = copy_to_mode_reg (Pmode, op0);
9062
9063   op0 = change_address (op0, V4SImode, addr);
9064   op1 = frv_legitimize_argument (icode, 1, op1);
9065   pat = GEN_FCN (icode) (op0, op1);
9066   if (! pat)
9067     return 0;
9068
9069   emit_insn (pat);
9070   return 0;
9071 }
9072
9073 /* Expand builtins that take two long operands and return void.  */
9074
9075 static rtx
9076 frv_expand_int_void2arg (enum insn_code icode, tree call)
9077 {
9078   rtx pat;
9079   rtx op0 = frv_read_argument (call, 0);
9080   rtx op1 = frv_read_argument (call, 1);
9081
9082   op0 = frv_legitimize_argument (icode, 1, op0);
9083   op1 = frv_legitimize_argument (icode, 1, op1);
9084   pat = GEN_FCN (icode) (op0, op1);
9085   if (! pat)
9086     return NULL_RTX;
9087
9088   emit_insn (pat);
9089   return NULL_RTX;
9090 }
9091
9092 /* Expand prefetch builtins.  These take a single address as argument.  */
9093
9094 static rtx
9095 frv_expand_prefetches (enum insn_code icode, tree call)
9096 {
9097   rtx pat;
9098   rtx op0 = frv_read_argument (call, 0);
9099
9100   pat = GEN_FCN (icode) (force_reg (Pmode, op0));
9101   if (! pat)
9102     return 0;
9103
9104   emit_insn (pat);
9105   return 0;
9106 }
9107
9108 /* Expand builtins that take three operands and return void.  The first
9109    argument must be a constant that describes a pair or quad accumulators.  A
9110    fourth argument is created that is the accumulator guard register that
9111    corresponds to the accumulator.  */
9112
9113 static rtx
9114 frv_expand_voidtriop_builtin (enum insn_code icode, tree call)
9115 {
9116   rtx pat;
9117   rtx op0 = frv_read_argument (call, 0);
9118   rtx op1 = frv_read_argument (call, 1);
9119   rtx op2 = frv_read_argument (call, 2);
9120   rtx op3;
9121
9122   op0 = frv_int_to_acc (icode, 0, op0);
9123   if (! op0)
9124     return NULL_RTX;
9125
9126   op1 = frv_legitimize_argument (icode, 1, op1);
9127   op2 = frv_legitimize_argument (icode, 2, op2);
9128   op3 = frv_matching_accg_for_acc (op0);
9129   pat = GEN_FCN (icode) (op0, op1, op2, op3);
9130   if (! pat)
9131     return NULL_RTX;
9132
9133   emit_insn (pat);
9134   return NULL_RTX;
9135 }
9136
9137 /* Expand builtins that perform accumulator-to-accumulator operations.
9138    These builtins take two accumulator numbers as argument and return
9139    void.  */
9140
9141 static rtx
9142 frv_expand_voidaccop_builtin (enum insn_code icode, tree call)
9143 {
9144   rtx pat;
9145   rtx op0 = frv_read_argument (call, 0);
9146   rtx op1 = frv_read_argument (call, 1);
9147   rtx op2;
9148   rtx op3;
9149
9150   op0 = frv_int_to_acc (icode, 0, op0);
9151   if (! op0)
9152     return NULL_RTX;
9153
9154   op1 = frv_int_to_acc (icode, 1, op1);
9155   if (! op1)
9156     return NULL_RTX;
9157
9158   op2 = frv_matching_accg_for_acc (op0);
9159   op3 = frv_matching_accg_for_acc (op1);
9160   pat = GEN_FCN (icode) (op0, op1, op2, op3);
9161   if (! pat)
9162     return NULL_RTX;
9163
9164   emit_insn (pat);
9165   return NULL_RTX;
9166 }
9167
9168 /* Expand a __builtin_read* function.  ICODE is the instruction code for the
9169    membar and TARGET_MODE is the mode that the loaded value should have.  */
9170
9171 static rtx
9172 frv_expand_load_builtin (enum insn_code icode, enum machine_mode target_mode,
9173                          tree call, rtx target)
9174 {
9175   rtx op0 = frv_read_argument (call, 0);
9176   rtx cookie = frv_io_address_cookie (op0);
9177
9178   if (target == 0 || !REG_P (target))
9179     target = gen_reg_rtx (target_mode);
9180   op0 = frv_volatile_memref (insn_data[icode].operand[0].mode, op0);
9181   convert_move (target, op0, 1);
9182   emit_insn (GEN_FCN (icode) (copy_rtx (op0), cookie, GEN_INT (FRV_IO_READ)));
9183   cfun->machine->has_membar_p = 1;
9184   return target;
9185 }
9186
9187 /* Likewise __builtin_write* functions.  */
9188
9189 static rtx
9190 frv_expand_store_builtin (enum insn_code icode, tree call)
9191 {
9192   rtx op0 = frv_read_argument (call, 0);
9193   rtx op1 = frv_read_argument (call, 1);
9194   rtx cookie = frv_io_address_cookie (op0);
9195
9196   op0 = frv_volatile_memref (insn_data[icode].operand[0].mode, op0);
9197   convert_move (op0, force_reg (insn_data[icode].operand[0].mode, op1), 1);
9198   emit_insn (GEN_FCN (icode) (copy_rtx (op0), cookie, GEN_INT (FRV_IO_WRITE)));
9199   cfun->machine->has_membar_p = 1;
9200   return NULL_RTX;
9201 }
9202
9203 /* Expand the MDPACKH builtin.  It takes four unsigned short arguments and
9204    each argument forms one word of the two double-word input registers.
9205    CALL is the tree for the call and TARGET, if nonnull, suggests a good place
9206    to put the return value.  */
9207
9208 static rtx
9209 frv_expand_mdpackh_builtin (tree call, rtx target)
9210 {
9211   enum insn_code icode = CODE_FOR_mdpackh;
9212   rtx pat, op0, op1;
9213   rtx arg1 = frv_read_argument (call, 0);
9214   rtx arg2 = frv_read_argument (call, 1);
9215   rtx arg3 = frv_read_argument (call, 2);
9216   rtx arg4 = frv_read_argument (call, 3);
9217
9218   target = frv_legitimize_target (icode, target);
9219   op0 = gen_reg_rtx (DImode);
9220   op1 = gen_reg_rtx (DImode);
9221
9222   /* The high half of each word is not explicitly initialized, so indicate
9223      that the input operands are not live before this point.  */
9224   emit_clobber (op0);
9225   emit_clobber (op1);
9226
9227   /* Move each argument into the low half of its associated input word.  */
9228   emit_move_insn (simplify_gen_subreg (HImode, op0, DImode, 2), arg1);
9229   emit_move_insn (simplify_gen_subreg (HImode, op0, DImode, 6), arg2);
9230   emit_move_insn (simplify_gen_subreg (HImode, op1, DImode, 2), arg3);
9231   emit_move_insn (simplify_gen_subreg (HImode, op1, DImode, 6), arg4);
9232
9233   pat = GEN_FCN (icode) (target, op0, op1);
9234   if (! pat)
9235     return NULL_RTX;
9236
9237   emit_insn (pat);
9238   return target;
9239 }
9240
9241 /* Expand the MCLRACC builtin.  This builtin takes a single accumulator
9242    number as argument.  */
9243
9244 static rtx
9245 frv_expand_mclracc_builtin (tree call)
9246 {
9247   enum insn_code icode = CODE_FOR_mclracc;
9248   rtx pat;
9249   rtx op0 = frv_read_argument (call, 0);
9250
9251   op0 = frv_int_to_acc (icode, 0, op0);
9252   if (! op0)
9253     return NULL_RTX;
9254
9255   pat = GEN_FCN (icode) (op0);
9256   if (pat)
9257     emit_insn (pat);
9258
9259   return NULL_RTX;
9260 }
9261
9262 /* Expand builtins that take no arguments.  */
9263
9264 static rtx
9265 frv_expand_noargs_builtin (enum insn_code icode)
9266 {
9267   rtx pat = GEN_FCN (icode) (const0_rtx);
9268   if (pat)
9269     emit_insn (pat);
9270
9271   return NULL_RTX;
9272 }
9273
9274 /* Expand MRDACC and MRDACCG.  These builtins take a single accumulator
9275    number or accumulator guard number as argument and return an SI integer.  */
9276
9277 static rtx
9278 frv_expand_mrdacc_builtin (enum insn_code icode, tree call)
9279 {
9280   rtx pat;
9281   rtx target = gen_reg_rtx (SImode);
9282   rtx op0 = frv_read_argument (call, 0);
9283
9284   op0 = frv_int_to_acc (icode, 1, op0);
9285   if (! op0)
9286     return NULL_RTX;
9287
9288   pat = GEN_FCN (icode) (target, op0);
9289   if (! pat)
9290     return NULL_RTX;
9291
9292   emit_insn (pat);
9293   return target;
9294 }
9295
9296 /* Expand MWTACC and MWTACCG.  These builtins take an accumulator or
9297    accumulator guard as their first argument and an SImode value as their
9298    second.  */
9299
9300 static rtx
9301 frv_expand_mwtacc_builtin (enum insn_code icode, tree call)
9302 {
9303   rtx pat;
9304   rtx op0 = frv_read_argument (call, 0);
9305   rtx op1 = frv_read_argument (call, 1);
9306
9307   op0 = frv_int_to_acc (icode, 0, op0);
9308   if (! op0)
9309     return NULL_RTX;
9310
9311   op1 = frv_legitimize_argument (icode, 1, op1);
9312   pat = GEN_FCN (icode) (op0, op1);
9313   if (pat)
9314     emit_insn (pat);
9315
9316   return NULL_RTX;
9317 }
9318
9319 /* Emit a move from SRC to DEST in SImode chunks.  This can be used
9320    to move DImode values into and out of IACC0.  */
9321
9322 static void
9323 frv_split_iacc_move (rtx dest, rtx src)
9324 {
9325   enum machine_mode inner;
9326   int i;
9327
9328   inner = GET_MODE (dest);
9329   for (i = 0; i < GET_MODE_SIZE (inner); i += GET_MODE_SIZE (SImode))
9330     emit_move_insn (simplify_gen_subreg (SImode, dest, inner, i),
9331                     simplify_gen_subreg (SImode, src, inner, i));
9332 }
9333
9334 /* Expand builtins.  */
9335
9336 static rtx
9337 frv_expand_builtin (tree exp,
9338                     rtx target,
9339                     rtx subtarget ATTRIBUTE_UNUSED,
9340                     enum machine_mode mode ATTRIBUTE_UNUSED,
9341                     int ignore ATTRIBUTE_UNUSED)
9342 {
9343   tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
9344   unsigned fcode = (unsigned)DECL_FUNCTION_CODE (fndecl);
9345   unsigned i;
9346   struct builtin_description *d;
9347
9348   if (fcode < FRV_BUILTIN_FIRST_NONMEDIA && !TARGET_MEDIA)
9349     {
9350       error ("media functions are not available unless -mmedia is used");
9351       return NULL_RTX;
9352     }
9353
9354   switch (fcode)
9355     {
9356     case FRV_BUILTIN_MCOP1:
9357     case FRV_BUILTIN_MCOP2:
9358     case FRV_BUILTIN_MDUNPACKH:
9359     case FRV_BUILTIN_MBTOHE:
9360       if (! TARGET_MEDIA_REV1)
9361         {
9362           error ("this media function is only available on the fr500");
9363           return NULL_RTX;
9364         }
9365       break;
9366
9367     case FRV_BUILTIN_MQXMACHS:
9368     case FRV_BUILTIN_MQXMACXHS:
9369     case FRV_BUILTIN_MQMACXHS:
9370     case FRV_BUILTIN_MADDACCS:
9371     case FRV_BUILTIN_MSUBACCS:
9372     case FRV_BUILTIN_MASACCS:
9373     case FRV_BUILTIN_MDADDACCS:
9374     case FRV_BUILTIN_MDSUBACCS:
9375     case FRV_BUILTIN_MDASACCS:
9376     case FRV_BUILTIN_MABSHS:
9377     case FRV_BUILTIN_MDROTLI:
9378     case FRV_BUILTIN_MCPLHI:
9379     case FRV_BUILTIN_MCPLI:
9380     case FRV_BUILTIN_MDCUTSSI:
9381     case FRV_BUILTIN_MQSATHS:
9382     case FRV_BUILTIN_MHSETLOS:
9383     case FRV_BUILTIN_MHSETLOH:
9384     case FRV_BUILTIN_MHSETHIS:
9385     case FRV_BUILTIN_MHSETHIH:
9386     case FRV_BUILTIN_MHDSETS:
9387     case FRV_BUILTIN_MHDSETH:
9388       if (! TARGET_MEDIA_REV2)
9389         {
9390           error ("this media function is only available on the fr400"
9391                  " and fr550");
9392           return NULL_RTX;
9393         }
9394       break;
9395
9396     case FRV_BUILTIN_SMASS:
9397     case FRV_BUILTIN_SMSSS:
9398     case FRV_BUILTIN_SMU:
9399     case FRV_BUILTIN_ADDSS:
9400     case FRV_BUILTIN_SUBSS:
9401     case FRV_BUILTIN_SLASS:
9402     case FRV_BUILTIN_SCUTSS:
9403     case FRV_BUILTIN_IACCreadll:
9404     case FRV_BUILTIN_IACCreadl:
9405     case FRV_BUILTIN_IACCsetll:
9406     case FRV_BUILTIN_IACCsetl:
9407       if (!TARGET_FR405_BUILTINS)
9408         {
9409           error ("this builtin function is only available"
9410                  " on the fr405 and fr450");
9411           return NULL_RTX;
9412         }
9413       break;
9414
9415     case FRV_BUILTIN_PREFETCH:
9416       if (!TARGET_FR500_FR550_BUILTINS)
9417         {
9418           error ("this builtin function is only available on the fr500"
9419                  " and fr550");
9420           return NULL_RTX;
9421         }
9422       break;
9423
9424     case FRV_BUILTIN_MQLCLRHS:
9425     case FRV_BUILTIN_MQLMTHS:
9426     case FRV_BUILTIN_MQSLLHI:
9427     case FRV_BUILTIN_MQSRAHI:
9428       if (!TARGET_MEDIA_FR450)
9429         {
9430           error ("this builtin function is only available on the fr450");
9431           return NULL_RTX;
9432         }
9433       break;
9434
9435     default:
9436       break;
9437     }
9438
9439   /* Expand unique builtins.  */
9440
9441   switch (fcode)
9442     {
9443     case FRV_BUILTIN_MTRAP:
9444       return frv_expand_noargs_builtin (CODE_FOR_mtrap);
9445
9446     case FRV_BUILTIN_MCLRACC:
9447       return frv_expand_mclracc_builtin (exp);
9448
9449     case FRV_BUILTIN_MCLRACCA:
9450       if (TARGET_ACC_8)
9451         return frv_expand_noargs_builtin (CODE_FOR_mclracca8);
9452       else
9453         return frv_expand_noargs_builtin (CODE_FOR_mclracca4);
9454
9455     case FRV_BUILTIN_MRDACC:
9456       return frv_expand_mrdacc_builtin (CODE_FOR_mrdacc, exp);
9457
9458     case FRV_BUILTIN_MRDACCG:
9459       return frv_expand_mrdacc_builtin (CODE_FOR_mrdaccg, exp);
9460
9461     case FRV_BUILTIN_MWTACC:
9462       return frv_expand_mwtacc_builtin (CODE_FOR_mwtacc, exp);
9463
9464     case FRV_BUILTIN_MWTACCG:
9465       return frv_expand_mwtacc_builtin (CODE_FOR_mwtaccg, exp);
9466
9467     case FRV_BUILTIN_MDPACKH:
9468       return frv_expand_mdpackh_builtin (exp, target);
9469
9470     case FRV_BUILTIN_IACCreadll:
9471       {
9472         rtx src = frv_read_iacc_argument (DImode, exp, 0);
9473         if (target == 0 || !REG_P (target))
9474           target = gen_reg_rtx (DImode);
9475         frv_split_iacc_move (target, src);
9476         return target;
9477       }
9478
9479     case FRV_BUILTIN_IACCreadl:
9480       return frv_read_iacc_argument (SImode, exp, 0);
9481
9482     case FRV_BUILTIN_IACCsetll:
9483       {
9484         rtx dest = frv_read_iacc_argument (DImode, exp, 0);
9485         rtx src = frv_read_argument (exp, 1);
9486         frv_split_iacc_move (dest, force_reg (DImode, src));
9487         return 0;
9488       }
9489
9490     case FRV_BUILTIN_IACCsetl:
9491       {
9492         rtx dest = frv_read_iacc_argument (SImode, exp, 0);
9493         rtx src = frv_read_argument (exp, 1);
9494         emit_move_insn (dest, force_reg (SImode, src));
9495         return 0;
9496       }
9497
9498     default:
9499       break;
9500     }
9501
9502   /* Expand groups of builtins.  */
9503
9504   for (i = 0, d = bdesc_set; i < ARRAY_SIZE (bdesc_set); i++, d++)
9505     if (d->code == fcode)
9506       return frv_expand_set_builtin (d->icode, exp, target);
9507
9508   for (i = 0, d = bdesc_1arg; i < ARRAY_SIZE (bdesc_1arg); i++, d++)
9509     if (d->code == fcode)
9510       return frv_expand_unop_builtin (d->icode, exp, target);
9511
9512   for (i = 0, d = bdesc_2arg; i < ARRAY_SIZE (bdesc_2arg); i++, d++)
9513     if (d->code == fcode)
9514       return frv_expand_binop_builtin (d->icode, exp, target);
9515
9516   for (i = 0, d = bdesc_cut; i < ARRAY_SIZE (bdesc_cut); i++, d++)
9517     if (d->code == fcode)
9518       return frv_expand_cut_builtin (d->icode, exp, target);
9519
9520   for (i = 0, d = bdesc_2argimm; i < ARRAY_SIZE (bdesc_2argimm); i++, d++)
9521     if (d->code == fcode)
9522       return frv_expand_binopimm_builtin (d->icode, exp, target);
9523
9524   for (i = 0, d = bdesc_void2arg; i < ARRAY_SIZE (bdesc_void2arg); i++, d++)
9525     if (d->code == fcode)
9526       return frv_expand_voidbinop_builtin (d->icode, exp);
9527
9528   for (i = 0, d = bdesc_void3arg; i < ARRAY_SIZE (bdesc_void3arg); i++, d++)
9529     if (d->code == fcode)
9530       return frv_expand_voidtriop_builtin (d->icode, exp);
9531
9532   for (i = 0, d = bdesc_voidacc; i < ARRAY_SIZE (bdesc_voidacc); i++, d++)
9533     if (d->code == fcode)
9534       return frv_expand_voidaccop_builtin (d->icode, exp);
9535
9536   for (i = 0, d = bdesc_int_void2arg;
9537        i < ARRAY_SIZE (bdesc_int_void2arg); i++, d++)
9538     if (d->code == fcode)
9539       return frv_expand_int_void2arg (d->icode, exp);
9540
9541   for (i = 0, d = bdesc_prefetches;
9542        i < ARRAY_SIZE (bdesc_prefetches); i++, d++)
9543     if (d->code == fcode)
9544       return frv_expand_prefetches (d->icode, exp);
9545
9546   for (i = 0, d = bdesc_loads; i < ARRAY_SIZE (bdesc_loads); i++, d++)
9547     if (d->code == fcode)
9548       return frv_expand_load_builtin (d->icode, TYPE_MODE (TREE_TYPE (exp)),
9549                                       exp, target);
9550
9551   for (i = 0, d = bdesc_stores; i < ARRAY_SIZE (bdesc_stores); i++, d++)
9552     if (d->code == fcode)
9553       return frv_expand_store_builtin (d->icode, exp);
9554
9555   return 0;
9556 }
9557
9558 static bool
9559 frv_in_small_data_p (const_tree decl)
9560 {
9561   HOST_WIDE_INT size;
9562   const_tree section_name;
9563
9564   /* Don't apply the -G flag to internal compiler structures.  We
9565      should leave such structures in the main data section, partly
9566      for efficiency and partly because the size of some of them
9567      (such as C++ typeinfos) is not known until later.  */
9568   if (TREE_CODE (decl) != VAR_DECL || DECL_ARTIFICIAL (decl))
9569     return false;
9570
9571   /* If we already know which section the decl should be in, see if
9572      it's a small data section.  */
9573   section_name = DECL_SECTION_NAME (decl);
9574   if (section_name)
9575     {
9576       gcc_assert (TREE_CODE (section_name) == STRING_CST);
9577       if (frv_string_begins_with (section_name, ".sdata"))
9578         return true;
9579       if (frv_string_begins_with (section_name, ".sbss"))
9580         return true;
9581       return false;
9582     }
9583
9584   size = int_size_in_bytes (TREE_TYPE (decl));
9585   if (size > 0 && (unsigned HOST_WIDE_INT) size <= g_switch_value)
9586     return true;
9587
9588   return false;
9589 }
9590 \f
9591 static bool
9592 frv_rtx_costs (rtx x,
9593                int code ATTRIBUTE_UNUSED,
9594                int outer_code ATTRIBUTE_UNUSED,
9595                int *total,
9596                bool speed ATTRIBUTE_UNUSED)
9597 {
9598   if (outer_code == MEM)
9599     {
9600       /* Don't differentiate between memory addresses.  All the ones
9601          we accept have equal cost.  */
9602       *total = COSTS_N_INSNS (0);
9603       return true;
9604     }
9605
9606   switch (code)
9607     {
9608     case CONST_INT:
9609       /* Make 12-bit integers really cheap.  */
9610       if (IN_RANGE_P (INTVAL (x), -2048, 2047))
9611         {
9612           *total = 0;
9613           return true;
9614         }
9615       /* Fall through.  */
9616
9617     case CONST:
9618     case LABEL_REF:
9619     case SYMBOL_REF:
9620     case CONST_DOUBLE:
9621       *total = COSTS_N_INSNS (2);
9622       return true;
9623
9624     case PLUS:
9625     case MINUS:
9626     case AND:
9627     case IOR:
9628     case XOR:
9629     case ASHIFT:
9630     case ASHIFTRT:
9631     case LSHIFTRT:
9632     case NOT:
9633     case NEG:
9634     case COMPARE:
9635       if (GET_MODE (x) == SImode)
9636         *total = COSTS_N_INSNS (1);
9637       else if (GET_MODE (x) == DImode)
9638         *total = COSTS_N_INSNS (2);
9639       else
9640         *total = COSTS_N_INSNS (3);
9641       return true;
9642
9643     case MULT:
9644       if (GET_MODE (x) == SImode)
9645         *total = COSTS_N_INSNS (2);
9646       else
9647         *total = COSTS_N_INSNS (6);     /* guess */
9648       return true;
9649
9650     case DIV:
9651     case UDIV:
9652     case MOD:
9653     case UMOD:
9654       *total = COSTS_N_INSNS (18);
9655       return true;
9656
9657     case MEM:
9658       *total = COSTS_N_INSNS (3);
9659       return true;
9660
9661     default:
9662       return false;
9663     }
9664 }
9665 \f
9666 static void
9667 frv_asm_out_constructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
9668 {
9669   switch_to_section (ctors_section);
9670   assemble_align (POINTER_SIZE);
9671   if (TARGET_FDPIC)
9672     {
9673       int ok = frv_assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, 1);
9674
9675       gcc_assert (ok);
9676       return;
9677     }
9678   assemble_integer_with_op ("\t.picptr\t", symbol);
9679 }
9680
9681 static void
9682 frv_asm_out_destructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
9683 {
9684   switch_to_section (dtors_section);
9685   assemble_align (POINTER_SIZE);
9686   if (TARGET_FDPIC)
9687     {
9688       int ok = frv_assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, 1);
9689
9690       gcc_assert (ok);
9691       return;
9692     }
9693   assemble_integer_with_op ("\t.picptr\t", symbol);
9694 }
9695
9696 /* Worker function for TARGET_STRUCT_VALUE_RTX.  */
9697
9698 static rtx
9699 frv_struct_value_rtx (tree fntype ATTRIBUTE_UNUSED,
9700                       int incoming ATTRIBUTE_UNUSED)
9701 {
9702   return gen_rtx_REG (Pmode, FRV_STRUCT_VALUE_REGNUM);
9703 }
9704
9705 #define TLS_BIAS (2048 - 16)
9706
9707 /* This is called from dwarf2out.c via TARGET_ASM_OUTPUT_DWARF_DTPREL.
9708    We need to emit DTP-relative relocations.  */
9709
9710 static void
9711 frv_output_dwarf_dtprel (FILE *file, int size, rtx x)
9712 {
9713   gcc_assert (size == 4);
9714   fputs ("\t.picptr\ttlsmoff(", file);
9715   /* We want the unbiased TLS offset, so add the bias to the
9716      expression, such that the implicit biasing cancels out.  */
9717   output_addr_const (file, plus_constant (x, TLS_BIAS));
9718   fputs (")", file);
9719 }
9720
9721 #include "gt-frv.h"