gcc/config/frv/frv.c

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