gcc/config/frv/frv.c

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