gcc/config/m68k/m68k.c

   1 /* Subroutines for insn-output.c for Motorola 68000 family.
   2    Copyright (C) 1987, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2003, 2004, 2005, 2006, 2007
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "tree.h"
  27 #include "rtl.h"
  28 #include "function.h"
  29 #include "regs.h"
  30 #include "hard-reg-set.h"
  31 #include "real.h"
  32 #include "insn-config.h"
  33 #include "conditions.h"
  34 #include "output.h"
  35 #include "insn-attr.h"
  36 #include "recog.h"
  37 #include "toplev.h"
  38 #include "expr.h"
  39 #include "reload.h"
  40 #include "tm_p.h"
  41 #include "target.h"
  42 #include "target-def.h"
  43 #include "debug.h"
  44 #include "flags.h"
  45 #include "df.h"
  46 /* ??? Need to add a dependency between m68k.o and sched-int.h.  */
  47 #include "sched-int.h"
  48 #include "insn-codes.h"
  49
  50 enum reg_class regno_reg_class[] =
  51 {
  52   DATA_REGS, DATA_REGS, DATA_REGS, DATA_REGS,
  53   DATA_REGS, DATA_REGS, DATA_REGS, DATA_REGS,
  54   ADDR_REGS, ADDR_REGS, ADDR_REGS, ADDR_REGS,
  55   ADDR_REGS, ADDR_REGS, ADDR_REGS, ADDR_REGS,
  56   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
  57   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
  58   ADDR_REGS
  59 };
  60
  61
  62 /* The minimum number of integer registers that we want to save with the
  63    movem instruction.  Using two movel instructions instead of a single
  64    moveml is about 15% faster for the 68020 and 68030 at no expense in
  65    code size.  */
  66 #define MIN_MOVEM_REGS 3
  67
  68 /* The minimum number of floating point registers that we want to save
  69    with the fmovem instruction.  */
  70 #define MIN_FMOVEM_REGS 1
  71
  72 /* Structure describing stack frame layout.  */
  73 struct m68k_frame
  74 {
  75   /* Stack pointer to frame pointer offset.  */
  76   HOST_WIDE_INT offset;
  77
  78   /* Offset of FPU registers.  */
  79   HOST_WIDE_INT foffset;
  80
  81   /* Frame size in bytes (rounded up).  */
  82   HOST_WIDE_INT size;
  83
  84   /* Data and address register.  */
  85   int reg_no;
  86   unsigned int reg_mask;
  87
  88   /* FPU registers.  */
  89   int fpu_no;
  90   unsigned int fpu_mask;
  91
  92   /* Offsets relative to ARG_POINTER.  */
  93   HOST_WIDE_INT frame_pointer_offset;
  94   HOST_WIDE_INT stack_pointer_offset;
  95
  96   /* Function which the above information refers to.  */
  97   int funcdef_no;
  98 };
  99
 100 /* Current frame information calculated by m68k_compute_frame_layout().  */
 101 static struct m68k_frame current_frame;
 102
 103 /* Structure describing an m68k address.
 104
 105    If CODE is UNKNOWN, the address is BASE + INDEX * SCALE + OFFSET,
 106    with null fields evaluating to 0.  Here:
 107
 108    - BASE satisfies m68k_legitimate_base_reg_p
 109    - INDEX satisfies m68k_legitimate_index_reg_p
 110    - OFFSET satisfies m68k_legitimate_constant_address_p
 111
 112    INDEX is either HImode or SImode.  The other fields are SImode.
 113
 114    If CODE is PRE_DEC, the address is -(BASE).  If CODE is POST_INC,
 115    the address is (BASE)+.  */
 116 struct m68k_address {
 117   enum rtx_code code;
 118   rtx base;
 119   rtx index;
 120   rtx offset;
 121   int scale;
 122 };
 123
 124 static int m68k_sched_adjust_cost (rtx, rtx, rtx, int);
 125 static int m68k_sched_variable_issue (FILE *, int, rtx, int);
 126 static void m68k_sched_md_init_global (FILE *, int, int);
 127 static void m68k_sched_md_finish_global (FILE *, int);
 128 static void m68k_sched_md_init (FILE *, int, int);
 129 static void m68k_sched_dfa_pre_advance_cycle (void);
 130 static void m68k_sched_dfa_post_advance_cycle (void);
 131
 132 static bool m68k_handle_option (size_t, const char *, int);
 133 static rtx find_addr_reg (rtx);
 134 static const char *singlemove_string (rtx *);
 135 #ifdef M68K_TARGET_COFF
 136 static void m68k_coff_asm_named_section (const char *, unsigned int, tree);
 137 #endif /* M68K_TARGET_COFF */
 138 static void m68k_output_mi_thunk (FILE *, tree, HOST_WIDE_INT,
 139                                           HOST_WIDE_INT, tree);
 140 static rtx m68k_struct_value_rtx (tree, int);
 141 static tree m68k_handle_fndecl_attribute (tree *node, tree name,
 142                                           tree args, int flags,
 143                                           bool *no_add_attrs);
 144 static void m68k_compute_frame_layout (void);
 145 static bool m68k_save_reg (unsigned int regno, bool interrupt_handler);
 146 static bool m68k_ok_for_sibcall_p (tree, tree);
 147 static bool m68k_rtx_costs (rtx, int, int, int *);
 148 #if M68K_HONOR_TARGET_STRICT_ALIGNMENT
 149 static bool m68k_return_in_memory (tree, tree);
 150 #endif
 151 \f
 152
 153 /* Specify the identification number of the library being built */
 154 const char *m68k_library_id_string = "_current_shared_library_a5_offset_";
 155
 156 /* Nonzero if the last compare/test insn had FP operands.  The
 157    sCC expanders peek at this to determine what to do for the
 158    68060, which has no fsCC instructions.  */
 159 int m68k_last_compare_had_fp_operands;
 160 \f
 161 /* Initialize the GCC target structure.  */
 162
 163 #if INT_OP_GROUP == INT_OP_DOT_WORD
 164 #undef TARGET_ASM_ALIGNED_HI_OP
 165 #define TARGET_ASM_ALIGNED_HI_OP "\t.word\t"
 166 #endif
 167
 168 #if INT_OP_GROUP == INT_OP_NO_DOT
 169 #undef TARGET_ASM_BYTE_OP
 170 #define TARGET_ASM_BYTE_OP "\tbyte\t"
 171 #undef TARGET_ASM_ALIGNED_HI_OP
 172 #define TARGET_ASM_ALIGNED_HI_OP "\tshort\t"
 173 #undef TARGET_ASM_ALIGNED_SI_OP
 174 #define TARGET_ASM_ALIGNED_SI_OP "\tlong\t"
 175 #endif
 176
 177 #if INT_OP_GROUP == INT_OP_DC
 178 #undef TARGET_ASM_BYTE_OP
 179 #define TARGET_ASM_BYTE_OP "\tdc.b\t"
 180 #undef TARGET_ASM_ALIGNED_HI_OP
 181 #define TARGET_ASM_ALIGNED_HI_OP "\tdc.w\t"
 182 #undef TARGET_ASM_ALIGNED_SI_OP
 183 #define TARGET_ASM_ALIGNED_SI_OP "\tdc.l\t"
 184 #endif
 185
 186 #undef TARGET_ASM_UNALIGNED_HI_OP
 187 #define TARGET_ASM_UNALIGNED_HI_OP TARGET_ASM_ALIGNED_HI_OP
 188 #undef TARGET_ASM_UNALIGNED_SI_OP
 189 #define TARGET_ASM_UNALIGNED_SI_OP TARGET_ASM_ALIGNED_SI_OP
 190
 191 #undef TARGET_ASM_OUTPUT_MI_THUNK
 192 #define TARGET_ASM_OUTPUT_MI_THUNK m68k_output_mi_thunk
 193 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
 194 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK hook_bool_const_tree_hwi_hwi_const_tree_true
 195
 196 #undef TARGET_ASM_FILE_START_APP_OFF
 197 #define TARGET_ASM_FILE_START_APP_OFF true
 198
 199 #undef TARGET_SCHED_ADJUST_COST
 200 #define TARGET_SCHED_ADJUST_COST m68k_sched_adjust_cost
 201
 202 #undef TARGET_SCHED_VARIABLE_ISSUE
 203 #define TARGET_SCHED_VARIABLE_ISSUE m68k_sched_variable_issue
 204
 205 #undef TARGET_SCHED_INIT_GLOBAL
 206 #define TARGET_SCHED_INIT_GLOBAL m68k_sched_md_init_global
 207
 208 #undef TARGET_SCHED_FINISH_GLOBAL
 209 #define TARGET_SCHED_FINISH_GLOBAL m68k_sched_md_finish_global
 210
 211 #undef TARGET_SCHED_INIT
 212 #define TARGET_SCHED_INIT m68k_sched_md_init
 213
 214 #undef TARGET_SCHED_DFA_PRE_ADVANCE_CYCLE
 215 #define TARGET_SCHED_DFA_PRE_ADVANCE_CYCLE m68k_sched_dfa_pre_advance_cycle
 216
 217 #undef TARGET_SCHED_DFA_POST_ADVANCE_CYCLE
 218 #define TARGET_SCHED_DFA_POST_ADVANCE_CYCLE m68k_sched_dfa_post_advance_cycle
 219
 220 #undef TARGET_HANDLE_OPTION
 221 #define TARGET_HANDLE_OPTION m68k_handle_option
 222
 223 #undef TARGET_RTX_COSTS
 224 #define TARGET_RTX_COSTS m68k_rtx_costs
 225
 226 #undef TARGET_ATTRIBUTE_TABLE
 227 #define TARGET_ATTRIBUTE_TABLE m68k_attribute_table
 228
 229 #undef TARGET_PROMOTE_PROTOTYPES
 230 #define TARGET_PROMOTE_PROTOTYPES hook_bool_const_tree_true
 231
 232 #undef TARGET_STRUCT_VALUE_RTX
 233 #define TARGET_STRUCT_VALUE_RTX m68k_struct_value_rtx
 234
 235 #undef TARGET_CANNOT_FORCE_CONST_MEM
 236 #define TARGET_CANNOT_FORCE_CONST_MEM m68k_illegitimate_symbolic_constant_p
 237
 238 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
 239 #define TARGET_FUNCTION_OK_FOR_SIBCALL m68k_ok_for_sibcall_p
 240
 241 #if M68K_HONOR_TARGET_STRICT_ALIGNMENT
 242 #undef TARGET_RETURN_IN_MEMORY
 243 #define TARGET_RETURN_IN_MEMORY m68k_return_in_memory
 244 #endif
 245
 246 static const struct attribute_spec m68k_attribute_table[] =
 247 {
 248   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
 249   { "interrupt", 0, 0, true,  false, false, m68k_handle_fndecl_attribute },
 250   { "interrupt_handler", 0, 0, true,  false, false, m68k_handle_fndecl_attribute },
 251   { "interrupt_thread", 0, 0, true,  false, false, m68k_handle_fndecl_attribute },
 252   { NULL,                0, 0, false, false, false, NULL }
 253 };
 254
 255 struct gcc_target targetm = TARGET_INITIALIZER;
 256 \f
 257 /* Base flags for 68k ISAs.  */
 258 #define FL_FOR_isa_00    FL_ISA_68000
 259 #define FL_FOR_isa_10    (FL_FOR_isa_00 | FL_ISA_68010)
 260 /* FL_68881 controls the default setting of -m68881.  gcc has traditionally
 261    generated 68881 code for 68020 and 68030 targets unless explicitly told
 262    not to.  */
 263 #define FL_FOR_isa_20    (FL_FOR_isa_10 | FL_ISA_68020 \
 264                           | FL_BITFIELD | FL_68881)
 265 #define FL_FOR_isa_40    (FL_FOR_isa_20 | FL_ISA_68040)
 266 #define FL_FOR_isa_cpu32 (FL_FOR_isa_10 | FL_ISA_68020)
 267
 268 /* Base flags for ColdFire ISAs.  */
 269 #define FL_FOR_isa_a     (FL_COLDFIRE | FL_ISA_A)
 270 #define FL_FOR_isa_aplus (FL_FOR_isa_a | FL_ISA_APLUS | FL_CF_USP)
 271 /* Note ISA_B doesn't necessarily include USP (user stack pointer) support.  */
 272 #define FL_FOR_isa_b     (FL_FOR_isa_a | FL_ISA_B | FL_CF_HWDIV)
 273 /* ISA_C is not upwardly compatible with ISA_B.  */
 274 #define FL_FOR_isa_c     (FL_FOR_isa_a | FL_ISA_C | FL_CF_USP)
 275
 276 enum m68k_isa
 277 {
 278   /* Traditional 68000 instruction sets.  */
 279   isa_00,
 280   isa_10,
 281   isa_20,
 282   isa_40,
 283   isa_cpu32,
 284   /* ColdFire instruction set variants.  */
 285   isa_a,
 286   isa_aplus,
 287   isa_b,
 288   isa_c,
 289   isa_max
 290 };
 291
 292 /* Information about one of the -march, -mcpu or -mtune arguments.  */
 293 struct m68k_target_selection
 294 {
 295   /* The argument being described.  */
 296   const char *name;
 297
 298   /* For -mcpu, this is the device selected by the option.
 299      For -mtune and -march, it is a representative device
 300      for the microarchitecture or ISA respectively.  */
 301   enum target_device device;
 302
 303   /* The M68K_DEVICE fields associated with DEVICE.  See the comment
 304      in m68k-devices.def for details.  FAMILY is only valid for -mcpu.  */
 305   const char *family;
 306   enum uarch_type microarch;
 307   enum m68k_isa isa;
 308   unsigned long flags;
 309 };
 310
 311 /* A list of all devices in m68k-devices.def.  Used for -mcpu selection.  */
 312 static const struct m68k_target_selection all_devices[] =
 313 {
 314 #define M68K_DEVICE(NAME,ENUM_VALUE,FAMILY,MULTILIB,MICROARCH,ISA,FLAGS) \
 315   { NAME, ENUM_VALUE, FAMILY, u##MICROARCH, ISA, FLAGS | FL_FOR_##ISA },
 316 #include "m68k-devices.def"
 317 #undef M68K_DEVICE
 318   { NULL, unk_device, NULL, unk_arch, isa_max, 0 }
 319 };
 320
 321 /* A list of all ISAs, mapping each one to a representative device.
 322    Used for -march selection.  */
 323 static const struct m68k_target_selection all_isas[] =
 324 {
 325   { "68000",    m68000,     NULL,  u68000,   isa_00,    FL_FOR_isa_00 },
 326   { "68010",    m68010,     NULL,  u68010,   isa_10,    FL_FOR_isa_10 },
 327   { "68020",    m68020,     NULL,  u68020,   isa_20,    FL_FOR_isa_20 },
 328   { "68030",    m68030,     NULL,  u68030,   isa_20,    FL_FOR_isa_20 },
 329   { "68040",    m68040,     NULL,  u68040,   isa_40,    FL_FOR_isa_40 },
 330   { "68060",    m68060,     NULL,  u68060,   isa_40,    FL_FOR_isa_40 },
 331   { "cpu32",    cpu32,      NULL,  ucpu32,   isa_20,    FL_FOR_isa_cpu32 },
 332   { "isaa",     mcf5206e,   NULL,  ucfv2,    isa_a,     (FL_FOR_isa_a
 333                                                          | FL_CF_HWDIV) },
 334   { "isaaplus", mcf5271,    NULL,  ucfv2,    isa_aplus, (FL_FOR_isa_aplus
 335                                                          | FL_CF_HWDIV) },
 336   { "isab",     mcf5407,    NULL,  ucfv4,    isa_b,     FL_FOR_isa_b },
 337   { "isac",     unk_device, NULL,  ucfv4,    isa_c,     (FL_FOR_isa_c
 338                                                          | FL_CF_HWDIV) },
 339   { NULL,       unk_device, NULL,  unk_arch, isa_max,   0 }
 340 };
 341
 342 /* A list of all microarchitectures, mapping each one to a representative
 343    device.  Used for -mtune selection.  */
 344 static const struct m68k_target_selection all_microarchs[] =
 345 {
 346   { "68000",    m68000,     NULL,  u68000,    isa_00,  FL_FOR_isa_00 },
 347   { "68010",    m68010,     NULL,  u68010,    isa_10,  FL_FOR_isa_10 },
 348   { "68020",    m68020,     NULL,  u68020,    isa_20,  FL_FOR_isa_20 },
 349   { "68020-40", m68020,     NULL,  u68020_40, isa_20,  FL_FOR_isa_20 },
 350   { "68020-60", m68020,     NULL,  u68020_60, isa_20,  FL_FOR_isa_20 },
 351   { "68030",    m68030,     NULL,  u68030,    isa_20,  FL_FOR_isa_20 },
 352   { "68040",    m68040,     NULL,  u68040,    isa_40,  FL_FOR_isa_40 },
 353   { "68060",    m68060,     NULL,  u68060,    isa_40,  FL_FOR_isa_40 },
 354   { "cpu32",    cpu32,      NULL,  ucpu32,    isa_20,  FL_FOR_isa_cpu32 },
 355   { "cfv1",     mcf51qe,    NULL,  ucfv1,     isa_c,   FL_FOR_isa_c },
 356   { "cfv2",     mcf5206,    NULL,  ucfv2,     isa_a,   FL_FOR_isa_a },
 357   { "cfv3",     mcf5307,    NULL,  ucfv3,     isa_a,   (FL_FOR_isa_a
 358                                                         | FL_CF_HWDIV) },
 359   { "cfv4",     mcf5407,    NULL,  ucfv4,     isa_b,   FL_FOR_isa_b },
 360   { "cfv4e",    mcf547x,    NULL,  ucfv4e,    isa_b,   (FL_FOR_isa_b
 361                                                         | FL_CF_USP
 362                                                         | FL_CF_EMAC
 363                                                         | FL_CF_FPU) },
 364   { NULL,       unk_device, NULL,  unk_arch,  isa_max, 0 }
 365 };
 366 \f
 367 /* The entries associated with the -mcpu, -march and -mtune settings,
 368    or null for options that have not been used.  */
 369 const struct m68k_target_selection *m68k_cpu_entry;
 370 const struct m68k_target_selection *m68k_arch_entry;
 371 const struct m68k_target_selection *m68k_tune_entry;
 372
 373 /* Which CPU we are generating code for.  */
 374 enum target_device m68k_cpu;
 375
 376 /* Which microarchitecture to tune for.  */
 377 enum uarch_type m68k_tune;
 378
 379 /* Which FPU to use.  */
 380 enum fpu_type m68k_fpu;
 381
 382 /* The set of FL_* flags that apply to the target processor.  */
 383 unsigned int m68k_cpu_flags;
 384
 385 /* Asm templates for calling or jumping to an arbitrary symbolic address,
 386    or NULL if such calls or jumps are not supported.  The address is held
 387    in operand 0.  */
 388 const char *m68k_symbolic_call;
 389 const char *m68k_symbolic_jump;
 390
 391 /* Enum variable that corresponds to m68k_symbolic_call values.  */
 392 enum M68K_SYMBOLIC_CALL m68k_symbolic_call_var;
 393
 394 \f
 395 /* See whether TABLE has an entry with name NAME.  Return true and
 396    store the entry in *ENTRY if so, otherwise return false and
 397    leave *ENTRY alone.  */
 398
 399 static bool
 400 m68k_find_selection (const struct m68k_target_selection **entry,
 401                      const struct m68k_target_selection *table,
 402                      const char *name)
 403 {
 404   size_t i;
 405
 406   for (i = 0; table[i].name; i++)
 407     if (strcmp (table[i].name, name) == 0)
 408       {
 409         *entry = table + i;
 410         return true;
 411       }
 412   return false;
 413 }
 414
 415 /* Implement TARGET_HANDLE_OPTION.  */
 416
 417 static bool
 418 m68k_handle_option (size_t code, const char *arg, int value)
 419 {
 420   switch (code)
 421     {
 422     case OPT_march_:
 423       return m68k_find_selection (&m68k_arch_entry, all_isas, arg);
 424
 425     case OPT_mcpu_:
 426       return m68k_find_selection (&m68k_cpu_entry, all_devices, arg);
 427
 428     case OPT_mtune_:
 429       return m68k_find_selection (&m68k_tune_entry, all_microarchs, arg);
 430
 431     case OPT_m5200:
 432       return m68k_find_selection (&m68k_cpu_entry, all_devices, "5206");
 433
 434     case OPT_m5206e:
 435       return m68k_find_selection (&m68k_cpu_entry, all_devices, "5206e");
 436
 437     case OPT_m528x:
 438       return m68k_find_selection (&m68k_cpu_entry, all_devices, "528x");
 439
 440     case OPT_m5307:
 441       return m68k_find_selection (&m68k_cpu_entry, all_devices, "5307");
 442
 443     case OPT_m5407:
 444       return m68k_find_selection (&m68k_cpu_entry, all_devices, "5407");
 445
 446     case OPT_mcfv4e:
 447       return m68k_find_selection (&m68k_cpu_entry, all_devices, "547x");
 448
 449     case OPT_m68000:
 450     case OPT_mc68000:
 451       return m68k_find_selection (&m68k_cpu_entry, all_devices, "68000");
 452
 453     case OPT_m68010:
 454       return m68k_find_selection (&m68k_cpu_entry, all_devices, "68010");
 455
 456     case OPT_m68020:
 457     case OPT_mc68020:
 458       return m68k_find_selection (&m68k_cpu_entry, all_devices, "68020");
 459
 460     case OPT_m68020_40:
 461       return (m68k_find_selection (&m68k_tune_entry, all_microarchs,
 462                                    "68020-40")
 463               && m68k_find_selection (&m68k_cpu_entry, all_devices, "68020"));
 464
 465     case OPT_m68020_60:
 466       return (m68k_find_selection (&m68k_tune_entry, all_microarchs,
 467                                    "68020-60")
 468               && m68k_find_selection (&m68k_cpu_entry, all_devices, "68020"));
 469
 470     case OPT_m68030:
 471       return m68k_find_selection (&m68k_cpu_entry, all_devices, "68030");
 472
 473     case OPT_m68040:
 474       return m68k_find_selection (&m68k_cpu_entry, all_devices, "68040");
 475
 476     case OPT_m68060:
 477       return m68k_find_selection (&m68k_cpu_entry, all_devices, "68060");
 478
 479     case OPT_m68302:
 480       return m68k_find_selection (&m68k_cpu_entry, all_devices, "68302");
 481
 482     case OPT_m68332:
 483     case OPT_mcpu32:
 484       return m68k_find_selection (&m68k_cpu_entry, all_devices, "68332");
 485
 486     case OPT_mshared_library_id_:
 487       if (value > MAX_LIBRARY_ID)
 488         error ("-mshared-library-id=%s is not between 0 and %d",
 489                arg, MAX_LIBRARY_ID);
 490       else
 491         asprintf ((char **) &m68k_library_id_string, "%d", (value * -4) - 4);
 492       return true;
 493
 494     default:
 495       return true;
 496     }
 497 }
 498
 499 /* Sometimes certain combinations of command options do not make
 500    sense on a particular target machine.  You can define a macro
 501    `OVERRIDE_OPTIONS' to take account of this.  This macro, if
 502    defined, is executed once just after all the command options have
 503    been parsed.
 504
 505    Don't use this macro to turn on various extra optimizations for
 506    `-O'.  That is what `OPTIMIZATION_OPTIONS' is for.  */
 507
 508 void
 509 override_options (void)
 510 {
 511   const struct m68k_target_selection *entry;
 512   unsigned long target_mask;
 513
 514   /* User can choose:
 515
 516      -mcpu=
 517      -march=
 518      -mtune=
 519
 520      -march=ARCH should generate code that runs any processor
 521      implementing architecture ARCH.  -mcpu=CPU should override -march
 522      and should generate code that runs on processor CPU, making free
 523      use of any instructions that CPU understands.  -mtune=UARCH applies
 524      on top of -mcpu or -march and optimizes the code for UARCH.  It does
 525      not change the target architecture.  */
 526   if (m68k_cpu_entry)
 527     {
 528       /* Complain if the -march setting is for a different microarchitecture,
 529          or includes flags that the -mcpu setting doesn't.  */
 530       if (m68k_arch_entry
 531           && (m68k_arch_entry->microarch != m68k_cpu_entry->microarch
 532               || (m68k_arch_entry->flags & ~m68k_cpu_entry->flags) != 0))
 533         warning (0, "-mcpu=%s conflicts with -march=%s",
 534                  m68k_cpu_entry->name, m68k_arch_entry->name);
 535
 536       entry = m68k_cpu_entry;
 537     }
 538   else
 539     entry = m68k_arch_entry;
 540
 541   if (!entry)
 542     entry = all_devices + TARGET_CPU_DEFAULT;
 543
 544   m68k_cpu_flags = entry->flags;
 545
 546   /* Use the architecture setting to derive default values for
 547      certain flags.  */
 548   target_mask = 0;
 549
 550   /* ColdFire is lenient about alignment.  */
 551   if (!TARGET_COLDFIRE)
 552     target_mask |= MASK_STRICT_ALIGNMENT;
 553
 554   if ((m68k_cpu_flags & FL_BITFIELD) != 0)
 555     target_mask |= MASK_BITFIELD;
 556   if ((m68k_cpu_flags & FL_CF_HWDIV) != 0)
 557     target_mask |= MASK_CF_HWDIV;
 558   if ((m68k_cpu_flags & (FL_68881 | FL_CF_FPU)) != 0)
 559     target_mask |= MASK_HARD_FLOAT;
 560   target_flags |= target_mask & ~target_flags_explicit;
 561
 562   /* Set the directly-usable versions of the -mcpu and -mtune settings.  */
 563   m68k_cpu = entry->device;
 564   if (m68k_tune_entry)
 565     m68k_tune = m68k_tune_entry->microarch;
 566 #ifdef M68K_DEFAULT_TUNE
 567   else if (!m68k_cpu_entry && !m68k_arch_entry)
 568     m68k_tune = M68K_DEFAULT_TUNE;
 569 #endif
 570   else
 571     m68k_tune = entry->microarch;
 572
 573   /* Set the type of FPU.  */
 574   m68k_fpu = (!TARGET_HARD_FLOAT ? FPUTYPE_NONE
 575               : (m68k_cpu_flags & FL_COLDFIRE) != 0 ? FPUTYPE_COLDFIRE
 576               : FPUTYPE_68881);
 577
 578   /* Sanity check to ensure that msep-data and mid-sahred-library are not
 579    * both specified together.  Doing so simply doesn't make sense.
 580    */
 581   if (TARGET_SEP_DATA && TARGET_ID_SHARED_LIBRARY)
 582     error ("cannot specify both -msep-data and -mid-shared-library");
 583
 584   /* If we're generating code for a separate A5 relative data segment,
 585    * we've got to enable -fPIC as well.  This might be relaxable to
 586    * -fpic but it hasn't been tested properly.
 587    */
 588   if (TARGET_SEP_DATA || TARGET_ID_SHARED_LIBRARY)
 589     flag_pic = 2;
 590
 591   /* -mpcrel -fPIC uses 32-bit pc-relative displacements.  Raise an
 592      error if the target does not support them.  */
 593   if (TARGET_PCREL && !TARGET_68020 && flag_pic == 2)
 594     error ("-mpcrel -fPIC is not currently supported on selected cpu");
 595
 596   /* ??? A historic way of turning on pic, or is this intended to
 597      be an embedded thing that doesn't have the same name binding
 598      significance that it does on hosted ELF systems?  */
 599   if (TARGET_PCREL && flag_pic == 0)
 600     flag_pic = 1;
 601
 602   if (!flag_pic)
 603     {
 604       m68k_symbolic_call_var = M68K_SYMBOLIC_CALL_JSR;
 605
 606       m68k_symbolic_jump = "jra %a0";
 607     }
 608   else if (TARGET_ID_SHARED_LIBRARY)
 609     /* All addresses must be loaded from the GOT.  */
 610     ;
 611   else if (TARGET_68020 || TARGET_ISAB || TARGET_ISAC)
 612     {
 613       if (TARGET_PCREL)
 614         m68k_symbolic_call_var = M68K_SYMBOLIC_CALL_BSR_C;
 615       else
 616         m68k_symbolic_call_var = M68K_SYMBOLIC_CALL_BSR_P;
 617
 618       if (TARGET_ISAC)
 619         /* No unconditional long branch */;
 620       else if (TARGET_PCREL)
 621         m68k_symbolic_jump = "bra%.l %c0";
 622       else
 623         m68k_symbolic_jump = "bra%.l %p0";
 624       /* Turn off function cse if we are doing PIC.  We always want
 625          function call to be done as `bsr foo@PLTPC'.  */
 626       /* ??? It's traditional to do this for -mpcrel too, but it isn't
 627          clear how intentional that is.  */
 628       flag_no_function_cse = 1;
 629     }
 630
 631   switch (m68k_symbolic_call_var)
 632     {
 633     case M68K_SYMBOLIC_CALL_JSR:
 634       m68k_symbolic_call = "jsr %a0";
 635       break;
 636
 637     case M68K_SYMBOLIC_CALL_BSR_C:
 638       m68k_symbolic_call = "bsr%.l %c0";
 639       break;
 640
 641     case M68K_SYMBOLIC_CALL_BSR_P:
 642       m68k_symbolic_call = "bsr%.l %p0";
 643       break;
 644
 645     case M68K_SYMBOLIC_CALL_NONE:
 646       gcc_assert (m68k_symbolic_call == NULL);
 647       break;
 648
 649     default:
 650       gcc_unreachable ();
 651     }
 652
 653 #ifndef ASM_OUTPUT_ALIGN_WITH_NOP
 654   if (align_labels > 2)
 655     {
 656       warning (0, "-falign-labels=%d is not supported", align_labels);
 657       align_labels = 0;
 658     }
 659   if (align_loops > 2)
 660     {
 661       warning (0, "-falign-loops=%d is not supported", align_loops);
 662       align_loops = 0;
 663     }
 664 #endif
 665
 666   SUBTARGET_OVERRIDE_OPTIONS;
 667
 668   /* Setup scheduling options.  */
 669   if (TUNE_CFV2)
 670     m68k_sched_cpu = CPU_CF_V2;
 671   else
 672     {
 673       m68k_sched_cpu = CPU_UNKNOWN;
 674       flag_schedule_insns = 0;
 675       flag_schedule_insns_after_reload = 0;
 676       flag_modulo_sched = 0;
 677     }
 678 }
 679
 680 /* Generate a macro of the form __mPREFIX_cpu_NAME, where PREFIX is the
 681    given argument and NAME is the argument passed to -mcpu.  Return NULL
 682    if -mcpu was not passed.  */
 683
 684 const char *
 685 m68k_cpp_cpu_ident (const char *prefix)
 686 {
 687   if (!m68k_cpu_entry)
 688     return NULL;
 689   return concat ("__m", prefix, "_cpu_", m68k_cpu_entry->name, NULL);
 690 }
 691
 692 /* Generate a macro of the form __mPREFIX_family_NAME, where PREFIX is the
 693    given argument and NAME is the name of the representative device for
 694    the -mcpu argument's family.  Return NULL if -mcpu was not passed.  */
 695
 696 const char *
 697 m68k_cpp_cpu_family (const char *prefix)
 698 {
 699   if (!m68k_cpu_entry)
 700     return NULL;
 701   return concat ("__m", prefix, "_family_", m68k_cpu_entry->family, NULL);
 702 }
 703 \f
 704 /* Return m68k_fk_interrupt_handler if FUNC has an "interrupt" or
 705    "interrupt_handler" attribute and interrupt_thread if FUNC has an
 706    "interrupt_thread" attribute.  Otherwise, return
 707    m68k_fk_normal_function.  */
 708
 709 enum m68k_function_kind
 710 m68k_get_function_kind (tree func)
 711 {
 712   tree a;
 713
 714   gcc_assert (TREE_CODE (func) == FUNCTION_DECL);
 715
 716   a = lookup_attribute ("interrupt", DECL_ATTRIBUTES (func));
 717   if (a != NULL_TREE)
 718     return m68k_fk_interrupt_handler;
 719
 720   a = lookup_attribute ("interrupt_handler", DECL_ATTRIBUTES (func));
 721   if (a != NULL_TREE)
 722     return m68k_fk_interrupt_handler;
 723
 724   a = lookup_attribute ("interrupt_thread", DECL_ATTRIBUTES (func));
 725   if (a != NULL_TREE)
 726     return m68k_fk_interrupt_thread;
 727
 728   return m68k_fk_normal_function;
 729 }
 730
 731 /* Handle an attribute requiring a FUNCTION_DECL; arguments as in
 732    struct attribute_spec.handler.  */
 733 static tree
 734 m68k_handle_fndecl_attribute (tree *node, tree name,
 735                               tree args ATTRIBUTE_UNUSED,
 736                               int flags ATTRIBUTE_UNUSED,
 737                               bool *no_add_attrs)
 738 {
 739   if (TREE_CODE (*node) != FUNCTION_DECL)
 740     {
 741       warning (OPT_Wattributes, "%qs attribute only applies to functions",
 742                IDENTIFIER_POINTER (name));
 743       *no_add_attrs = true;
 744     }
 745
 746   if (m68k_get_function_kind (*node) != m68k_fk_normal_function)
 747     {
 748       error ("multiple interrupt attributes not allowed");
 749       *no_add_attrs = true;
 750     }
 751
 752   if (!TARGET_FIDOA
 753       && !strcmp (IDENTIFIER_POINTER (name), "interrupt_thread"))
 754     {
 755       error ("interrupt_thread is available only on fido");
 756       *no_add_attrs = true;
 757     }
 758
 759   return NULL_TREE;
 760 }
 761
 762 static void
 763 m68k_compute_frame_layout (void)
 764 {
 765   int regno, saved;
 766   unsigned int mask;
 767   enum m68k_function_kind func_kind =
 768     m68k_get_function_kind (current_function_decl);
 769   bool interrupt_handler = func_kind == m68k_fk_interrupt_handler;
 770   bool interrupt_thread = func_kind == m68k_fk_interrupt_thread;
 771
 772   /* Only compute the frame once per function.
 773      Don't cache information until reload has been completed.  */
 774   if (current_frame.funcdef_no == current_function_funcdef_no
 775       && reload_completed)
 776     return;
 777
 778   current_frame.size = (get_frame_size () + 3) & -4;
 779
 780   mask = saved = 0;
 781
 782   /* Interrupt thread does not need to save any register.  */
 783   if (!interrupt_thread)
 784     for (regno = 0; regno < 16; regno++)
 785       if (m68k_save_reg (regno, interrupt_handler))
 786         {
 787           mask |= 1 << (regno - D0_REG);
 788           saved++;
 789         }
 790   current_frame.offset = saved * 4;
 791   current_frame.reg_no = saved;
 792   current_frame.reg_mask = mask;
 793
 794   current_frame.foffset = 0;
 795   mask = saved = 0;
 796   if (TARGET_HARD_FLOAT)
 797     {
 798       /* Interrupt thread does not need to save any register.  */
 799       if (!interrupt_thread)
 800         for (regno = 16; regno < 24; regno++)
 801           if (m68k_save_reg (regno, interrupt_handler))
 802             {
 803               mask |= 1 << (regno - FP0_REG);
 804               saved++;
 805             }
 806       current_frame.foffset = saved * TARGET_FP_REG_SIZE;
 807       current_frame.offset += current_frame.foffset;
 808     }
 809   current_frame.fpu_no = saved;
 810   current_frame.fpu_mask = mask;
 811
 812   /* Remember what function this frame refers to.  */
 813   current_frame.funcdef_no = current_function_funcdef_no;
 814 }
 815
 816 HOST_WIDE_INT
 817 m68k_initial_elimination_offset (int from, int to)
 818 {
 819   int argptr_offset;
 820   /* The arg pointer points 8 bytes before the start of the arguments,
 821      as defined by FIRST_PARM_OFFSET.  This makes it coincident with the
 822      frame pointer in most frames.  */
 823   argptr_offset = frame_pointer_needed ? 0 : UNITS_PER_WORD;
 824   if (from == ARG_POINTER_REGNUM && to == FRAME_POINTER_REGNUM)
 825     return argptr_offset;
 826
 827   m68k_compute_frame_layout ();
 828
 829   gcc_assert (to == STACK_POINTER_REGNUM);
 830   switch (from)
 831     {
 832     case ARG_POINTER_REGNUM:
 833       return current_frame.offset + current_frame.size - argptr_offset;
 834     case FRAME_POINTER_REGNUM:
 835       return current_frame.offset + current_frame.size;
 836     default:
 837       gcc_unreachable ();
 838     }
 839 }
 840
 841 /* Refer to the array `regs_ever_live' to determine which registers
 842    to save; `regs_ever_live[I]' is nonzero if register number I
 843    is ever used in the function.  This function is responsible for
 844    knowing which registers should not be saved even if used.
 845    Return true if we need to save REGNO.  */
 846
 847 static bool
 848 m68k_save_reg (unsigned int regno, bool interrupt_handler)
 849 {
 850   if (flag_pic && regno == PIC_REG)
 851     {
 852       if (current_function_saves_all_registers)
 853         return true;
 854       if (current_function_uses_pic_offset_table)
 855         return true;
 856       /* Reload may introduce constant pool references into a function
 857          that thitherto didn't need a PIC register.  Note that the test
 858          above will not catch that case because we will only set
 859          current_function_uses_pic_offset_table when emitting
 860          the address reloads.  */
 861       if (current_function_uses_const_pool)
 862         return true;
 863     }
 864
 865   if (current_function_calls_eh_return)
 866     {
 867       unsigned int i;
 868       for (i = 0; ; i++)
 869         {
 870           unsigned int test = EH_RETURN_DATA_REGNO (i);
 871           if (test == INVALID_REGNUM)
 872             break;
 873           if (test == regno)
 874             return true;
 875         }
 876     }
 877
 878   /* Fixed regs we never touch.  */
 879   if (fixed_regs[regno])
 880     return false;
 881
 882   /* The frame pointer (if it is such) is handled specially.  */
 883   if (regno == FRAME_POINTER_REGNUM && frame_pointer_needed)
 884     return false;
 885
 886   /* Interrupt handlers must also save call_used_regs
 887      if they are live or when calling nested functions.  */
 888   if (interrupt_handler)
 889     {
 890       if (df_regs_ever_live_p (regno))
 891         return true;
 892
 893       if (!current_function_is_leaf && call_used_regs[regno])
 894         return true;
 895     }
 896
 897   /* Never need to save registers that aren't touched.  */
 898   if (!df_regs_ever_live_p (regno))
 899     return false;
 900
 901   /* Otherwise save everything that isn't call-clobbered.  */
 902   return !call_used_regs[regno];
 903 }
 904
 905 /* Emit RTL for a MOVEM or FMOVEM instruction.  BASE + OFFSET represents
 906    the lowest memory address.  COUNT is the number of registers to be
 907    moved, with register REGNO + I being moved if bit I of MASK is set.
 908    STORE_P specifies the direction of the move and ADJUST_STACK_P says
 909    whether or not this is pre-decrement (if STORE_P) or post-increment
 910    (if !STORE_P) operation.  */
 911
 912 static rtx
 913 m68k_emit_movem (rtx base, HOST_WIDE_INT offset,
 914                  unsigned int count, unsigned int regno,
 915                  unsigned int mask, bool store_p, bool adjust_stack_p)
 916 {
 917   int i;
 918   rtx body, addr, src, operands[2];
 919   enum machine_mode mode;
 920
 921   body = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (adjust_stack_p + count));
 922   mode = reg_raw_mode[regno];
 923   i = 0;
 924
 925   if (adjust_stack_p)
 926     {
 927       src = plus_constant (base, (count
 928                                   * GET_MODE_SIZE (mode)
 929                                   * (HOST_WIDE_INT) (store_p ? -1 : 1)));
 930       XVECEXP (body, 0, i++) = gen_rtx_SET (VOIDmode, base, src);
 931     }
 932
 933   for (; mask != 0; mask >>= 1, regno++)
 934     if (mask & 1)
 935       {
 936         addr = plus_constant (base, offset);
 937         operands[!store_p] = gen_frame_mem (mode, addr);
 938         operands[store_p] = gen_rtx_REG (mode, regno);
 939         XVECEXP (body, 0, i++)
 940           = gen_rtx_SET (VOIDmode, operands[0], operands[1]);
 941         offset += GET_MODE_SIZE (mode);
 942       }
 943   gcc_assert (i == XVECLEN (body, 0));
 944
 945   return emit_insn (body);
 946 }
 947
 948 /* Make INSN a frame-related instruction.  */
 949
 950 static void
 951 m68k_set_frame_related (rtx insn)
 952 {
 953   rtx body;
 954   int i;
 955
 956   RTX_FRAME_RELATED_P (insn) = 1;
 957   body = PATTERN (insn);
 958   if (GET_CODE (body) == PARALLEL)
 959     for (i = 0; i < XVECLEN (body, 0); i++)
 960       RTX_FRAME_RELATED_P (XVECEXP (body, 0, i)) = 1;
 961 }
 962
 963 /* Emit RTL for the "prologue" define_expand.  */
 964
 965 void
 966 m68k_expand_prologue (void)
 967 {
 968   HOST_WIDE_INT fsize_with_regs;
 969   rtx limit, src, dest, insn;
 970
 971   m68k_compute_frame_layout ();
 972
 973   /* If the stack limit is a symbol, we can check it here,
 974      before actually allocating the space.  */
 975   if (current_function_limit_stack
 976       && GET_CODE (stack_limit_rtx) == SYMBOL_REF)
 977     {
 978       limit = plus_constant (stack_limit_rtx, current_frame.size + 4);
 979       if (!LEGITIMATE_CONSTANT_P (limit))
 980         {
 981           emit_move_insn (gen_rtx_REG (Pmode, D0_REG), limit);
 982           limit = gen_rtx_REG (Pmode, D0_REG);
 983         }
 984       emit_insn (gen_cmpsi (stack_pointer_rtx, limit));
 985       emit_insn (gen_conditional_trap (gen_rtx_LTU (VOIDmode,
 986                                                     cc0_rtx, const0_rtx),
 987                                        const1_rtx));
 988     }
 989
 990   fsize_with_regs = current_frame.size;
 991   if (TARGET_COLDFIRE)
 992     {
 993       /* ColdFire's move multiple instructions do not allow pre-decrement
 994          addressing.  Add the size of movem saves to the initial stack
 995          allocation instead.  */
 996       if (current_frame.reg_no >= MIN_MOVEM_REGS)
 997         fsize_with_regs += current_frame.reg_no * GET_MODE_SIZE (SImode);
 998       if (current_frame.fpu_no >= MIN_FMOVEM_REGS)
 999         fsize_with_regs += current_frame.fpu_no * GET_MODE_SIZE (DFmode);
1000     }
1001
1002   if (frame_pointer_needed)
1003     {
1004       if (fsize_with_regs == 0 && TUNE_68040)
1005         {
1006           /* On the 68040, two separate moves are faster than link.w 0.  */
1007           dest = gen_frame_mem (Pmode,
1008                                 gen_rtx_PRE_DEC (Pmode, stack_pointer_rtx));
1009           m68k_set_frame_related (emit_move_insn (dest, frame_pointer_rtx));
1010           m68k_set_frame_related (emit_move_insn (frame_pointer_rtx,
1011                                                   stack_pointer_rtx));
1012         }
1013       else if (fsize_with_regs < 0x8000 || TARGET_68020)
1014         m68k_set_frame_related
1015           (emit_insn (gen_link (frame_pointer_rtx,
1016                                 GEN_INT (-4 - fsize_with_regs))));
1017       else
1018         {
1019           m68k_set_frame_related
1020             (emit_insn (gen_link (frame_pointer_rtx, GEN_INT (-4))));
1021           m68k_set_frame_related
1022             (emit_insn (gen_addsi3 (stack_pointer_rtx,
1023                                     stack_pointer_rtx,
1024                                     GEN_INT (-fsize_with_regs))));
1025         }
1026     }
1027   else if (fsize_with_regs != 0)
1028     m68k_set_frame_related
1029       (emit_insn (gen_addsi3 (stack_pointer_rtx,
1030                               stack_pointer_rtx,
1031                               GEN_INT (-fsize_with_regs))));
1032
1033   if (current_frame.fpu_mask)
1034     {
1035       gcc_assert (current_frame.fpu_no >= MIN_FMOVEM_REGS);
1036       if (TARGET_68881)
1037         m68k_set_frame_related
1038           (m68k_emit_movem (stack_pointer_rtx,
1039                             current_frame.fpu_no * -GET_MODE_SIZE (XFmode),
1040                             current_frame.fpu_no, FP0_REG,
1041                             current_frame.fpu_mask, true, true));
1042       else
1043         {
1044           int offset;
1045
1046           /* If we're using moveml to save the integer registers,
1047              the stack pointer will point to the bottom of the moveml
1048              save area.  Find the stack offset of the first FP register.  */
1049           if (current_frame.reg_no < MIN_MOVEM_REGS)
1050             offset = 0;
1051           else
1052             offset = current_frame.reg_no * GET_MODE_SIZE (SImode);
1053           m68k_set_frame_related
1054             (m68k_emit_movem (stack_pointer_rtx, offset,
1055                               current_frame.fpu_no, FP0_REG,
1056                               current_frame.fpu_mask, true, false));
1057         }
1058     }
1059
1060   /* If the stack limit is not a symbol, check it here.
1061      This has the disadvantage that it may be too late...  */
1062   if (current_function_limit_stack)
1063     {
1064       if (REG_P (stack_limit_rtx))
1065         {
1066           emit_insn (gen_cmpsi (stack_pointer_rtx, stack_limit_rtx));
1067           emit_insn (gen_conditional_trap (gen_rtx_LTU (VOIDmode,
1068                                                         cc0_rtx, const0_rtx),
1069                                            const1_rtx));
1070         }
1071       else if (GET_CODE (stack_limit_rtx) != SYMBOL_REF)
1072         warning (0, "stack limit expression is not supported");
1073     }
1074
1075   if (current_frame.reg_no < MIN_MOVEM_REGS)
1076     {
1077       /* Store each register separately in the same order moveml does.  */
1078       int i;
1079
1080       for (i = 16; i-- > 0; )
1081         if (current_frame.reg_mask & (1 << i))
1082           {
1083             src = gen_rtx_REG (SImode, D0_REG + i);
1084             dest = gen_frame_mem (SImode,
1085                                   gen_rtx_PRE_DEC (Pmode, stack_pointer_rtx));
1086             m68k_set_frame_related (emit_insn (gen_movsi (dest, src)));
1087           }
1088     }
1089   else
1090     {
1091       if (TARGET_COLDFIRE)
1092         /* The required register save space has already been allocated.
1093            The first register should be stored at (%sp).  */
1094         m68k_set_frame_related
1095           (m68k_emit_movem (stack_pointer_rtx, 0,
1096                             current_frame.reg_no, D0_REG,
1097                             current_frame.reg_mask, true, false));
1098       else
1099         m68k_set_frame_related
1100           (m68k_emit_movem (stack_pointer_rtx,
1101                             current_frame.reg_no * -GET_MODE_SIZE (SImode),
1102                             current_frame.reg_no, D0_REG,
1103                             current_frame.reg_mask, true, true));
1104     }
1105
1106   if (flag_pic
1107       && !TARGET_SEP_DATA
1108       && current_function_uses_pic_offset_table)
1109     insn = emit_insn (gen_load_got (pic_offset_table_rtx));
1110 }
1111 \f
1112 /* Return true if a simple (return) instruction is sufficient for this
1113    instruction (i.e. if no epilogue is needed).  */
1114
1115 bool
1116 m68k_use_return_insn (void)
1117 {
1118   if (!reload_completed || frame_pointer_needed || get_frame_size () != 0)
1119     return false;
1120
1121   m68k_compute_frame_layout ();
1122   return current_frame.offset == 0;
1123 }
1124
1125 /* Emit RTL for the "epilogue" or "sibcall_epilogue" define_expand;
1126    SIBCALL_P says which.
1127
1128    The function epilogue should not depend on the current stack pointer!
1129    It should use the frame pointer only, if there is a frame pointer.
1130    This is mandatory because of alloca; we also take advantage of it to
1131    omit stack adjustments before returning.  */
1132
1133 void
1134 m68k_expand_epilogue (bool sibcall_p)
1135 {
1136   HOST_WIDE_INT fsize, fsize_with_regs;
1137   bool big, restore_from_sp;
1138
1139   m68k_compute_frame_layout ();
1140
1141   fsize = current_frame.size;
1142   big = false;
1143   restore_from_sp = false;
1144
1145   /* FIXME : current_function_is_leaf below is too strong.
1146      What we really need to know there is if there could be pending
1147      stack adjustment needed at that point.  */
1148   restore_from_sp = (!frame_pointer_needed
1149                      || (!current_function_calls_alloca
1150                          && current_function_is_leaf));
1151
1152   /* fsize_with_regs is the size we need to adjust the sp when
1153      popping the frame.  */
1154   fsize_with_regs = fsize;
1155   if (TARGET_COLDFIRE && restore_from_sp)
1156     {
1157       /* ColdFire's move multiple instructions do not allow post-increment
1158          addressing.  Add the size of movem loads to the final deallocation
1159          instead.  */
1160       if (current_frame.reg_no >= MIN_MOVEM_REGS)
1161         fsize_with_regs += current_frame.reg_no * GET_MODE_SIZE (SImode);
1162       if (current_frame.fpu_no >= MIN_FMOVEM_REGS)
1163         fsize_with_regs += current_frame.fpu_no * GET_MODE_SIZE (DFmode);
1164     }
1165
1166   if (current_frame.offset + fsize >= 0x8000
1167       && !restore_from_sp
1168       && (current_frame.reg_mask || current_frame.fpu_mask))
1169     {
1170       if (TARGET_COLDFIRE
1171           && (current_frame.reg_no >= MIN_MOVEM_REGS
1172               || current_frame.fpu_no >= MIN_FMOVEM_REGS))
1173         {
1174           /* ColdFire's move multiple instructions do not support the
1175              (d8,Ax,Xi) addressing mode, so we're as well using a normal
1176              stack-based restore.  */
1177           emit_move_insn (gen_rtx_REG (Pmode, A1_REG),
1178                           GEN_INT (-(current_frame.offset + fsize)));
1179           emit_insn (gen_addsi3 (stack_pointer_rtx,
1180                                  gen_rtx_REG (Pmode, A1_REG),
1181                                  frame_pointer_rtx));
1182           restore_from_sp = true;
1183         }
1184       else
1185         {
1186           emit_move_insn (gen_rtx_REG (Pmode, A1_REG), GEN_INT (-fsize));
1187           fsize = 0;
1188           big = true;
1189         }
1190     }
1191
1192   if (current_frame.reg_no < MIN_MOVEM_REGS)
1193     {
1194       /* Restore each register separately in the same order moveml does.  */
1195       int i;
1196       HOST_WIDE_INT offset;
1197
1198       offset = current_frame.offset + fsize;
1199       for (i = 0; i < 16; i++)
1200         if (current_frame.reg_mask & (1 << i))
1201           {
1202             rtx addr;
1203
1204             if (big)
1205               {
1206                 /* Generate the address -OFFSET(%fp,%a1.l).  */
1207                 addr = gen_rtx_REG (Pmode, A1_REG);
1208                 addr = gen_rtx_PLUS (Pmode, addr, frame_pointer_rtx);
1209                 addr = plus_constant (addr, -offset);
1210               }
1211             else if (restore_from_sp)
1212               addr = gen_rtx_POST_INC (Pmode, stack_pointer_rtx);
1213             else
1214               addr = plus_constant (frame_pointer_rtx, -offset);
1215             emit_move_insn (gen_rtx_REG (SImode, D0_REG + i),
1216                             gen_frame_mem (SImode, addr));
1217             offset -= GET_MODE_SIZE (SImode);
1218           }
1219     }
1220   else if (current_frame.reg_mask)
1221     {
1222       if (big)
1223         m68k_emit_movem (gen_rtx_PLUS (Pmode,
1224                                        gen_rtx_REG (Pmode, A1_REG),
1225                                        frame_pointer_rtx),
1226                          -(current_frame.offset + fsize),
1227                          current_frame.reg_no, D0_REG,
1228                          current_frame.reg_mask, false, false);
1229       else if (restore_from_sp)
1230         m68k_emit_movem (stack_pointer_rtx, 0,
1231                          current_frame.reg_no, D0_REG,
1232                          current_frame.reg_mask, false,
1233                          !TARGET_COLDFIRE);
1234       else
1235         m68k_emit_movem (frame_pointer_rtx,
1236                          -(current_frame.offset + fsize),
1237                          current_frame.reg_no, D0_REG,
1238                          current_frame.reg_mask, false, false);
1239     }
1240
1241   if (current_frame.fpu_no > 0)
1242     {
1243       if (big)
1244         m68k_emit_movem (gen_rtx_PLUS (Pmode,
1245                                        gen_rtx_REG (Pmode, A1_REG),
1246                                        frame_pointer_rtx),
1247                          -(current_frame.foffset + fsize),
1248                          current_frame.fpu_no, FP0_REG,
1249                          current_frame.fpu_mask, false, false);
1250       else if (restore_from_sp)
1251         {
1252           if (TARGET_COLDFIRE)
1253             {
1254               int offset;
1255
1256               /* If we used moveml to restore the integer registers, the
1257                  stack pointer will still point to the bottom of the moveml
1258                  save area.  Find the stack offset of the first FP
1259                  register.  */
1260               if (current_frame.reg_no < MIN_MOVEM_REGS)
1261                 offset = 0;
1262               else
1263                 offset = current_frame.reg_no * GET_MODE_SIZE (SImode);
1264               m68k_emit_movem (stack_pointer_rtx, offset,
1265                                current_frame.fpu_no, FP0_REG,
1266                                current_frame.fpu_mask, false, false);
1267             }
1268           else
1269             m68k_emit_movem (stack_pointer_rtx, 0,
1270                              current_frame.fpu_no, FP0_REG,
1271                              current_frame.fpu_mask, false, true);
1272         }
1273       else
1274         m68k_emit_movem (frame_pointer_rtx,
1275                          -(current_frame.foffset + fsize),
1276                          current_frame.fpu_no, FP0_REG,
1277                          current_frame.fpu_mask, false, false);
1278     }
1279
1280   if (frame_pointer_needed)
1281     emit_insn (gen_unlink (frame_pointer_rtx));
1282   else if (fsize_with_regs)
1283     emit_insn (gen_addsi3 (stack_pointer_rtx,
1284                            stack_pointer_rtx,
1285                            GEN_INT (fsize_with_regs)));
1286
1287   if (current_function_calls_eh_return)
1288     emit_insn (gen_addsi3 (stack_pointer_rtx,
1289                            stack_pointer_rtx,
1290                            EH_RETURN_STACKADJ_RTX));
1291
1292   if (!sibcall_p)
1293     emit_jump_insn (gen_rtx_RETURN (VOIDmode));
1294 }
1295 \f
1296 /* Return true if X is a valid comparison operator for the dbcc
1297    instruction.
1298
1299    Note it rejects floating point comparison operators.
1300    (In the future we could use Fdbcc).
1301
1302    It also rejects some comparisons when CC_NO_OVERFLOW is set.  */
1303
1304 int
1305 valid_dbcc_comparison_p_2 (rtx x, enum machine_mode mode ATTRIBUTE_UNUSED)
1306 {
1307   switch (GET_CODE (x))
1308     {
1309       case EQ: case NE: case GTU: case LTU:
1310       case GEU: case LEU:
1311         return 1;
1312
1313       /* Reject some when CC_NO_OVERFLOW is set.  This may be over
1314          conservative */
1315       case GT: case LT: case GE: case LE:
1316         return ! (cc_prev_status.flags & CC_NO_OVERFLOW);
1317       default:
1318         return 0;
1319     }
1320 }
1321
1322 /* Return nonzero if flags are currently in the 68881 flag register.  */
1323 int
1324 flags_in_68881 (void)
1325 {
1326   /* We could add support for these in the future */
1327   return cc_status.flags & CC_IN_68881;
1328 }
1329
1330 /* Implement TARGET_FUNCTION_OK_FOR_SIBCALL_P.  */
1331
1332 static bool
1333 m68k_ok_for_sibcall_p (tree decl, tree exp)
1334 {
1335   enum m68k_function_kind kind;
1336
1337   /* We cannot use sibcalls for nested functions because we use the
1338      static chain register for indirect calls.  */
1339   if (CALL_EXPR_STATIC_CHAIN (exp))
1340     return false;
1341
1342   kind = m68k_get_function_kind (current_function_decl);
1343   if (kind == m68k_fk_normal_function)
1344     /* We can always sibcall from a normal function, because it's
1345        undefined if it is calling an interrupt function.  */
1346     return true;
1347
1348   /* Otherwise we can only sibcall if the function kind is known to be
1349      the same.  */
1350   if (decl && m68k_get_function_kind (decl) == kind)
1351     return true;
1352
1353   return false;
1354 }
1355
1356 /* Convert X to a legitimate function call memory reference and return the
1357    result.  */
1358
1359 rtx
1360 m68k_legitimize_call_address (rtx x)
1361 {
1362   gcc_assert (MEM_P (x));
1363   if (call_operand (XEXP (x, 0), VOIDmode))
1364     return x;
1365   return replace_equiv_address (x, force_reg (Pmode, XEXP (x, 0)));
1366 }
1367
1368 /* Likewise for sibling calls.  */
1369
1370 rtx
1371 m68k_legitimize_sibcall_address (rtx x)
1372 {
1373   gcc_assert (MEM_P (x));
1374   if (sibcall_operand (XEXP (x, 0), VOIDmode))
1375     return x;
1376
1377   emit_move_insn (gen_rtx_REG (Pmode, STATIC_CHAIN_REGNUM), XEXP (x, 0));
1378   return replace_equiv_address (x, gen_rtx_REG (Pmode, STATIC_CHAIN_REGNUM));
1379 }
1380
1381 /* Output a dbCC; jCC sequence.  Note we do not handle the
1382    floating point version of this sequence (Fdbcc).  We also
1383    do not handle alternative conditions when CC_NO_OVERFLOW is
1384    set.  It is assumed that valid_dbcc_comparison_p and flags_in_68881 will
1385    kick those out before we get here.  */
1386
1387 void
1388 output_dbcc_and_branch (rtx *operands)
1389 {
1390   switch (GET_CODE (operands[3]))
1391     {
1392       case EQ:
1393         output_asm_insn ("dbeq %0,%l1\n\tjeq %l2", operands);
1394         break;
1395
1396       case NE:
1397         output_asm_insn ("dbne %0,%l1\n\tjne %l2", operands);
1398         break;
1399
1400       case GT:
1401         output_asm_insn ("dbgt %0,%l1\n\tjgt %l2", operands);
1402         break;
1403
1404       case GTU:
1405         output_asm_insn ("dbhi %0,%l1\n\tjhi %l2", operands);
1406         break;
1407
1408       case LT:
1409         output_asm_insn ("dblt %0,%l1\n\tjlt %l2", operands);
1410         break;
1411
1412       case LTU:
1413         output_asm_insn ("dbcs %0,%l1\n\tjcs %l2", operands);
1414         break;
1415
1416       case GE:
1417         output_asm_insn ("dbge %0,%l1\n\tjge %l2", operands);
1418         break;
1419
1420       case GEU:
1421         output_asm_insn ("dbcc %0,%l1\n\tjcc %l2", operands);
1422         break;
1423
1424       case LE:
1425         output_asm_insn ("dble %0,%l1\n\tjle %l2", operands);
1426         break;
1427
1428       case LEU:
1429         output_asm_insn ("dbls %0,%l1\n\tjls %l2", operands);
1430         break;
1431
1432       default:
1433         gcc_unreachable ();
1434     }
1435
1436   /* If the decrement is to be done in SImode, then we have
1437      to compensate for the fact that dbcc decrements in HImode.  */
1438   switch (GET_MODE (operands[0]))
1439     {
1440       case SImode:
1441         output_asm_insn ("clr%.w %0\n\tsubq%.l #1,%0\n\tjpl %l1", operands);
1442         break;
1443
1444       case HImode:
1445         break;
1446
1447       default:
1448         gcc_unreachable ();
1449     }
1450 }
1451
1452 const char *
1453 output_scc_di (rtx op, rtx operand1, rtx operand2, rtx dest)
1454 {
1455   rtx loperands[7];
1456   enum rtx_code op_code = GET_CODE (op);
1457
1458   /* This does not produce a useful cc.  */
1459   CC_STATUS_INIT;
1460
1461   /* The m68k cmp.l instruction requires operand1 to be a reg as used
1462      below.  Swap the operands and change the op if these requirements
1463      are not fulfilled.  */
1464   if (GET_CODE (operand2) == REG && GET_CODE (operand1) != REG)
1465     {
1466       rtx tmp = operand1;
1467
1468       operand1 = operand2;
1469       operand2 = tmp;
1470       op_code = swap_condition (op_code);
1471     }
1472   loperands[0] = operand1;
1473   if (GET_CODE (operand1) == REG)
1474     loperands[1] = gen_rtx_REG (SImode, REGNO (operand1) + 1);
1475   else
1476     loperands[1] = adjust_address (operand1, SImode, 4);
1477   if (operand2 != const0_rtx)
1478     {
1479       loperands[2] = operand2;
1480       if (GET_CODE (operand2) == REG)
1481         loperands[3] = gen_rtx_REG (SImode, REGNO (operand2) + 1);
1482       else
1483         loperands[3] = adjust_address (operand2, SImode, 4);
1484     }
1485   loperands[4] = gen_label_rtx ();
1486   if (operand2 != const0_rtx)
1487     output_asm_insn ("cmp%.l %2,%0\n\tjne %l4\n\tcmp%.l %3,%1", loperands);
1488   else
1489     {
1490       if (TARGET_68020 || TARGET_COLDFIRE || ! ADDRESS_REG_P (loperands[0]))
1491         output_asm_insn ("tst%.l %0", loperands);
1492       else
1493         output_asm_insn ("cmp%.w #0,%0", loperands);
1494
1495       output_asm_insn ("jne %l4", loperands);
1496
1497       if (TARGET_68020 || TARGET_COLDFIRE || ! ADDRESS_REG_P (loperands[1]))
1498         output_asm_insn ("tst%.l %1", loperands);
1499       else
1500         output_asm_insn ("cmp%.w #0,%1", loperands);
1501     }
1502
1503   loperands[5] = dest;
1504
1505   switch (op_code)
1506     {
1507       case EQ:
1508         (*targetm.asm_out.internal_label) (asm_out_file, "L",
1509                                            CODE_LABEL_NUMBER (loperands[4]));
1510         output_asm_insn ("seq %5", loperands);
1511         break;
1512
1513       case NE:
1514         (*targetm.asm_out.internal_label) (asm_out_file, "L",
1515                                            CODE_LABEL_NUMBER (loperands[4]));
1516         output_asm_insn ("sne %5", loperands);
1517         break;
1518
1519       case GT:
1520         loperands[6] = gen_label_rtx ();
1521         output_asm_insn ("shi %5\n\tjra %l6", loperands);
1522         (*targetm.asm_out.internal_label) (asm_out_file, "L",
1523                                            CODE_LABEL_NUMBER (loperands[4]));
1524         output_asm_insn ("sgt %5", loperands);
1525         (*targetm.asm_out.internal_label) (asm_out_file, "L",
1526                                            CODE_LABEL_NUMBER (loperands[6]));
1527         break;
1528
1529       case GTU:
1530         (*targetm.asm_out.internal_label) (asm_out_file, "L",
1531                                            CODE_LABEL_NUMBER (loperands[4]));
1532         output_asm_insn ("shi %5", loperands);
1533         break;
1534
1535       case LT:
1536         loperands[6] = gen_label_rtx ();
1537         output_asm_insn ("scs %5\n\tjra %l6", loperands);
1538         (*targetm.asm_out.internal_label) (asm_out_file, "L",
1539                                            CODE_LABEL_NUMBER (loperands[4]));
1540         output_asm_insn ("slt %5", loperands);
1541         (*targetm.asm_out.internal_label) (asm_out_file, "L",
1542                                            CODE_LABEL_NUMBER (loperands[6]));
1543         break;
1544
1545       case LTU:
1546         (*targetm.asm_out.internal_label) (asm_out_file, "L",
1547                                            CODE_LABEL_NUMBER (loperands[4]));
1548         output_asm_insn ("scs %5", loperands);
1549         break;
1550
1551       case GE:
1552         loperands[6] = gen_label_rtx ();
1553         output_asm_insn ("scc %5\n\tjra %l6", loperands);
1554         (*targetm.asm_out.internal_label) (asm_out_file, "L",
1555                                            CODE_LABEL_NUMBER (loperands[4]));
1556         output_asm_insn ("sge %5", loperands);
1557         (*targetm.asm_out.internal_label) (asm_out_file, "L",
1558                                            CODE_LABEL_NUMBER (loperands[6]));
1559         break;
1560
1561       case GEU:
1562         (*targetm.asm_out.internal_label) (asm_out_file, "L",
1563                                            CODE_LABEL_NUMBER (loperands[4]));
1564         output_asm_insn ("scc %5", loperands);
1565         break;
1566
1567       case LE:
1568         loperands[6] = gen_label_rtx ();
1569         output_asm_insn ("sls %5\n\tjra %l6", loperands);
1570         (*targetm.asm_out.internal_label) (asm_out_file, "L",
1571                                            CODE_LABEL_NUMBER (loperands[4]));
1572         output_asm_insn ("sle %5", loperands);
1573         (*targetm.asm_out.internal_label) (asm_out_file, "L",
1574                                            CODE_LABEL_NUMBER (loperands[6]));
1575         break;
1576
1577       case LEU:
1578         (*targetm.asm_out.internal_label) (asm_out_file, "L",
1579                                            CODE_LABEL_NUMBER (loperands[4]));
1580         output_asm_insn ("sls %5", loperands);
1581         break;
1582
1583       default:
1584         gcc_unreachable ();
1585     }
1586   return "";
1587 }
1588
1589 const char *
1590 output_btst (rtx *operands, rtx countop, rtx dataop, rtx insn, int signpos)
1591 {
1592   operands[0] = countop;
1593   operands[1] = dataop;
1594
1595   if (GET_CODE (countop) == CONST_INT)
1596     {
1597       register int count = INTVAL (countop);
1598       /* If COUNT is bigger than size of storage unit in use,
1599          advance to the containing unit of same size.  */
1600       if (count > signpos)
1601         {
1602           int offset = (count & ~signpos) / 8;
1603           count = count & signpos;
1604           operands[1] = dataop = adjust_address (dataop, QImode, offset);
1605         }
1606       if (count == signpos)
1607         cc_status.flags = CC_NOT_POSITIVE | CC_Z_IN_NOT_N;
1608       else
1609         cc_status.flags = CC_NOT_NEGATIVE | CC_Z_IN_NOT_N;
1610
1611       /* These three statements used to use next_insns_test_no...
1612          but it appears that this should do the same job.  */
1613       if (count == 31
1614           && next_insn_tests_no_inequality (insn))
1615         return "tst%.l %1";
1616       if (count == 15
1617           && next_insn_tests_no_inequality (insn))
1618         return "tst%.w %1";
1619       if (count == 7
1620           && next_insn_tests_no_inequality (insn))
1621         return "tst%.b %1";
1622       /* Try to use `movew to ccr' followed by the appropriate branch insn.
1623          On some m68k variants unfortunately that's slower than btst.
1624          On 68000 and higher, that should also work for all HImode operands. */
1625       if (TUNE_CPU32 || TARGET_COLDFIRE || optimize_size)
1626         {
1627           if (count == 3 && DATA_REG_P (operands[1])
1628               && next_insn_tests_no_inequality (insn))
1629             {
1630             cc_status.flags = CC_NOT_NEGATIVE | CC_Z_IN_NOT_N | CC_NO_OVERFLOW;
1631             return "move%.w %1,%%ccr";
1632             }
1633           if (count == 2 && DATA_REG_P (operands[1])
1634               && next_insn_tests_no_inequality (insn))
1635             {
1636             cc_status.flags = CC_NOT_NEGATIVE | CC_INVERTED | CC_NO_OVERFLOW;
1637             return "move%.w %1,%%ccr";
1638             }
1639           /* count == 1 followed by bvc/bvs and
1640              count == 0 followed by bcc/bcs are also possible, but need
1641              m68k-specific CC_Z_IN_NOT_V and CC_Z_IN_NOT_C flags. */
1642         }
1643
1644       cc_status.flags = CC_NOT_NEGATIVE;
1645     }
1646   return "btst %0,%1";
1647 }
1648 \f
1649 /* Return true if X is a legitimate base register.  STRICT_P says
1650    whether we need strict checking.  */
1651
1652 bool
1653 m68k_legitimate_base_reg_p (rtx x, bool strict_p)
1654 {
1655   /* Allow SUBREG everywhere we allow REG.  This results in better code.  */
1656   if (!strict_p && GET_CODE (x) == SUBREG)
1657     x = SUBREG_REG (x);
1658
1659   return (REG_P (x)
1660           && (strict_p
1661               ? REGNO_OK_FOR_BASE_P (REGNO (x))
1662               : REGNO_OK_FOR_BASE_NONSTRICT_P (REGNO (x))));
1663 }
1664
1665 /* Return true if X is a legitimate index register.  STRICT_P says
1666    whether we need strict checking.  */
1667
1668 bool
1669 m68k_legitimate_index_reg_p (rtx x, bool strict_p)
1670 {
1671   if (!strict_p && GET_CODE (x) == SUBREG)
1672     x = SUBREG_REG (x);
1673
1674   return (REG_P (x)
1675           && (strict_p
1676               ? REGNO_OK_FOR_INDEX_P (REGNO (x))
1677               : REGNO_OK_FOR_INDEX_NONSTRICT_P (REGNO (x))));
1678 }
1679
1680 /* Return true if X is a legitimate index expression for a (d8,An,Xn) or
1681    (bd,An,Xn) addressing mode.  Fill in the INDEX and SCALE fields of
1682    ADDRESS if so.  STRICT_P says whether we need strict checking.  */
1683
1684 static bool
1685 m68k_decompose_index (rtx x, bool strict_p, struct m68k_address *address)
1686 {
1687   int scale;
1688
1689   /* Check for a scale factor.  */
1690   scale = 1;
1691   if ((TARGET_68020 || TARGET_COLDFIRE)
1692       && GET_CODE (x) == MULT
1693       && GET_CODE (XEXP (x, 1)) == CONST_INT
1694       && (INTVAL (XEXP (x, 1)) == 2
1695           || INTVAL (XEXP (x, 1)) == 4
1696           || (INTVAL (XEXP (x, 1)) == 8
1697               && (TARGET_COLDFIRE_FPU || !TARGET_COLDFIRE))))
1698     {
1699       scale = INTVAL (XEXP (x, 1));
1700       x = XEXP (x, 0);
1701     }
1702
1703   /* Check for a word extension.  */
1704   if (!TARGET_COLDFIRE
1705       && GET_CODE (x) == SIGN_EXTEND
1706       && GET_MODE (XEXP (x, 0)) == HImode)
1707     x = XEXP (x, 0);
1708
1709   if (m68k_legitimate_index_reg_p (x, strict_p))
1710     {
1711       address->scale = scale;
1712       address->index = x;
1713       return true;
1714     }
1715
1716   return false;
1717 }
1718
1719 /* Return true if X is an illegitimate symbolic constant.  */
1720
1721 bool
1722 m68k_illegitimate_symbolic_constant_p (rtx x)
1723 {
1724   rtx base, offset;
1725
1726   if (M68K_OFFSETS_MUST_BE_WITHIN_SECTIONS_P)
1727     {
1728       split_const (x, &base, &offset);
1729       if (GET_CODE (base) == SYMBOL_REF
1730           && !offset_within_block_p (base, INTVAL (offset)))
1731         return true;
1732     }
1733   return false;
1734 }
1735
1736 /* Return true if X is a legitimate constant address that can reach
1737    bytes in the range [X, X + REACH).  STRICT_P says whether we need
1738    strict checking.  */
1739
1740 static bool
1741 m68k_legitimate_constant_address_p (rtx x, unsigned int reach, bool strict_p)
1742 {
1743   rtx base, offset;
1744
1745   if (!CONSTANT_ADDRESS_P (x))
1746     return false;
1747
1748   if (flag_pic
1749       && !(strict_p && TARGET_PCREL)
1750       && symbolic_operand (x, VOIDmode))
1751     return false;
1752
1753   if (M68K_OFFSETS_MUST_BE_WITHIN_SECTIONS_P && reach > 1)
1754     {
1755       split_const (x, &base, &offset);
1756       if (GET_CODE (base) == SYMBOL_REF
1757           && !offset_within_block_p (base, INTVAL (offset) + reach - 1))
1758         return false;
1759     }
1760
1761   return true;
1762 }
1763
1764 /* Return true if X is a LABEL_REF for a jump table.  Assume that unplaced
1765    labels will become jump tables.  */
1766
1767 static bool
1768 m68k_jump_table_ref_p (rtx x)
1769 {
1770   if (GET_CODE (x) != LABEL_REF)
1771     return false;
1772
1773   x = XEXP (x, 0);
1774   if (!NEXT_INSN (x) && !PREV_INSN (x))
1775     return true;
1776
1777   x = next_nonnote_insn (x);
1778   return x && JUMP_TABLE_DATA_P (x);
1779 }
1780
1781 /* Return true if X is a legitimate address for values of mode MODE.
1782    STRICT_P says whether strict checking is needed.  If the address
1783    is valid, describe its components in *ADDRESS.  */
1784
1785 static bool
1786 m68k_decompose_address (enum machine_mode mode, rtx x,
1787                         bool strict_p, struct m68k_address *address)
1788 {
1789   unsigned int reach;
1790
1791   memset (address, 0, sizeof (*address));
1792
1793   if (mode == BLKmode)
1794     reach = 1;
1795   else
1796     reach = GET_MODE_SIZE (mode);
1797
1798   /* Check for (An) (mode 2).  */
1799   if (m68k_legitimate_base_reg_p (x, strict_p))
1800     {
1801       address->base = x;
1802       return true;
1803     }
1804
1805   /* Check for -(An) and (An)+ (modes 3 and 4).  */
1806   if ((GET_CODE (x) == PRE_DEC || GET_CODE (x) == POST_INC)
1807       && m68k_legitimate_base_reg_p (XEXP (x, 0), strict_p))
1808     {
1809       address->code = GET_CODE (x);
1810       address->base = XEXP (x, 0);
1811       return true;
1812     }
1813
1814   /* Check for (d16,An) (mode 5).  */
1815   if (GET_CODE (x) == PLUS
1816       && GET_CODE (XEXP (x, 1)) == CONST_INT
1817       && IN_RANGE (INTVAL (XEXP (x, 1)), -0x8000, 0x8000 - reach)
1818       && m68k_legitimate_base_reg_p (XEXP (x, 0), strict_p))
1819     {
1820       address->base = XEXP (x, 0);
1821       address->offset = XEXP (x, 1);
1822       return true;
1823     }
1824
1825   /* Check for GOT loads.  These are (bd,An,Xn) addresses if
1826      TARGET_68020 && flag_pic == 2, otherwise they are (d16,An)
1827      addresses.  */
1828   if (flag_pic
1829       && GET_CODE (x) == PLUS
1830       && XEXP (x, 0) == pic_offset_table_rtx
1831       && (GET_CODE (XEXP (x, 1)) == SYMBOL_REF
1832           || GET_CODE (XEXP (x, 1)) == LABEL_REF))
1833     {
1834       address->base = XEXP (x, 0);
1835       address->offset = XEXP (x, 1);
1836       return true;
1837     }
1838
1839   /* The ColdFire FPU only accepts addressing modes 2-5.  */
1840   if (TARGET_COLDFIRE_FPU && GET_MODE_CLASS (mode) == MODE_FLOAT)
1841     return false;
1842
1843   /* Check for (xxx).w and (xxx).l.  Also, in the TARGET_PCREL case,
1844      check for (d16,PC) or (bd,PC,Xn) with a suppressed index register.
1845      All these modes are variations of mode 7.  */
1846   if (m68k_legitimate_constant_address_p (x, reach, strict_p))
1847     {
1848       address->offset = x;
1849       return true;
1850     }
1851
1852   /* Check for (d8,PC,Xn), a mode 7 form.  This case is needed for
1853      tablejumps.
1854
1855      ??? do_tablejump creates these addresses before placing the target
1856      label, so we have to assume that unplaced labels are jump table
1857      references.  It seems unlikely that we would ever generate indexed
1858      accesses to unplaced labels in other cases.  */
1859   if (GET_CODE (x) == PLUS
1860       && m68k_jump_table_ref_p (XEXP (x, 1))
1861       && m68k_decompose_index (XEXP (x, 0), strict_p, address))
1862     {
1863       address->offset = XEXP (x, 1);
1864       return true;
1865     }
1866
1867   /* Everything hereafter deals with (d8,An,Xn.SIZE*SCALE) or
1868      (bd,An,Xn.SIZE*SCALE) addresses.  */
1869
1870   if (TARGET_68020)
1871     {
1872       /* Check for a nonzero base displacement.  */
1873       if (GET_CODE (x) == PLUS
1874           && m68k_legitimate_constant_address_p (XEXP (x, 1), reach, strict_p))
1875         {
1876           address->offset = XEXP (x, 1);
1877           x = XEXP (x, 0);
1878         }
1879
1880       /* Check for a suppressed index register.  */
1881       if (m68k_legitimate_base_reg_p (x, strict_p))
1882         {
1883           address->base = x;
1884           return true;
1885         }
1886
1887       /* Check for a suppressed base register.  Do not allow this case
1888          for non-symbolic offsets as it effectively gives gcc freedom
1889          to treat data registers as base registers, which can generate
1890          worse code.  */
1891       if (address->offset
1892           && symbolic_operand (address->offset, VOIDmode)
1893           && m68k_decompose_index (x, strict_p, address))
1894         return true;
1895     }
1896   else
1897     {
1898       /* Check for a nonzero base displacement.  */
1899       if (GET_CODE (x) == PLUS
1900           && GET_CODE (XEXP (x, 1)) == CONST_INT
1901           && IN_RANGE (INTVAL (XEXP (x, 1)), -0x80, 0x80 - reach))
1902         {
1903           address->offset = XEXP (x, 1);
1904           x = XEXP (x, 0);
1905         }
1906     }
1907
1908   /* We now expect the sum of a base and an index.  */
1909   if (GET_CODE (x) == PLUS)
1910     {
1911       if (m68k_legitimate_base_reg_p (XEXP (x, 0), strict_p)
1912           && m68k_decompose_index (XEXP (x, 1), strict_p, address))
1913         {
1914           address->base = XEXP (x, 0);
1915           return true;
1916         }
1917
1918       if (m68k_legitimate_base_reg_p (XEXP (x, 1), strict_p)
1919           && m68k_decompose_index (XEXP (x, 0), strict_p, address))
1920         {
1921           address->base = XEXP (x, 1);
1922           return true;
1923         }
1924     }
1925   return false;
1926 }
1927
1928 /* Return true if X is a legitimate address for values of mode MODE.
1929    STRICT_P says whether strict checking is needed.  */
1930
1931 bool
1932 m68k_legitimate_address_p (enum machine_mode mode, rtx x, bool strict_p)
1933 {
1934   struct m68k_address address;
1935
1936   return m68k_decompose_address (mode, x, strict_p, &address);
1937 }
1938
1939 /* Return true if X is a memory, describing its address in ADDRESS if so.
1940    Apply strict checking if called during or after reload.  */
1941
1942 static bool
1943 m68k_legitimate_mem_p (rtx x, struct m68k_address *address)
1944 {
1945   return (MEM_P (x)
1946           && m68k_decompose_address (GET_MODE (x), XEXP (x, 0),
1947                                      reload_in_progress || reload_completed,
1948                                      address));
1949 }
1950
1951 /* Return true if X matches the 'Q' constraint.  It must be a memory
1952    with a base address and no constant offset or index.  */
1953
1954 bool
1955 m68k_matches_q_p (rtx x)
1956 {
1957   struct m68k_address address;
1958
1959   return (m68k_legitimate_mem_p (x, &address)
1960           && address.code == UNKNOWN
1961           && address.base
1962           && !address.offset
1963           && !address.index);
1964 }
1965
1966 /* Return true if X matches the 'U' constraint.  It must be a base address
1967    with a constant offset and no index.  */
1968
1969 bool
1970 m68k_matches_u_p (rtx x)
1971 {
1972   struct m68k_address address;
1973
1974   return (m68k_legitimate_mem_p (x, &address)
1975           && address.code == UNKNOWN
1976           && address.base
1977           && address.offset
1978           && !address.index);
1979 }
1980
1981 /* Legitimize PIC addresses.  If the address is already
1982    position-independent, we return ORIG.  Newly generated
1983    position-independent addresses go to REG.  If we need more
1984    than one register, we lose.
1985
1986    An address is legitimized by making an indirect reference
1987    through the Global Offset Table with the name of the symbol
1988    used as an offset.
1989
1990    The assembler and linker are responsible for placing the
1991    address of the symbol in the GOT.  The function prologue
1992    is responsible for initializing a5 to the starting address
1993    of the GOT.
1994
1995    The assembler is also responsible for translating a symbol name
1996    into a constant displacement from the start of the GOT.
1997
1998    A quick example may make things a little clearer:
1999
2000    When not generating PIC code to store the value 12345 into _foo
2001    we would generate the following code:
2002
2003         movel #12345, _foo
2004
2005    When generating PIC two transformations are made.  First, the compiler
2006    loads the address of foo into a register.  So the first transformation makes:
2007
2008         lea     _foo, a0
2009         movel   #12345, a0@
2010
2011    The code in movsi will intercept the lea instruction and call this
2012    routine which will transform the instructions into:
2013
2014         movel   a5@(_foo:w), a0
2015         movel   #12345, a0@
2016
2017
2018    That (in a nutshell) is how *all* symbol and label references are
2019    handled.  */
2020
2021 rtx
2022 legitimize_pic_address (rtx orig, enum machine_mode mode ATTRIBUTE_UNUSED,
2023                         rtx reg)
2024 {
2025   rtx pic_ref = orig;
2026
2027   /* First handle a simple SYMBOL_REF or LABEL_REF */
2028   if (GET_CODE (orig) == SYMBOL_REF || GET_CODE (orig) == LABEL_REF)
2029     {
2030       gcc_assert (reg);
2031
2032       pic_ref = gen_rtx_MEM (Pmode,
2033                              gen_rtx_PLUS (Pmode,
2034                                            pic_offset_table_rtx, orig));
2035       current_function_uses_pic_offset_table = 1;
2036       MEM_READONLY_P (pic_ref) = 1;
2037       emit_move_insn (reg, pic_ref);
2038       return reg;
2039     }
2040   else if (GET_CODE (orig) == CONST)
2041     {
2042       rtx base;
2043
2044       /* Make sure this has not already been legitimized.  */
2045       if (GET_CODE (XEXP (orig, 0)) == PLUS
2046           && XEXP (XEXP (orig, 0), 0) == pic_offset_table_rtx)
2047         return orig;
2048
2049       gcc_assert (reg);
2050
2051       /* legitimize both operands of the PLUS */
2052       gcc_assert (GET_CODE (XEXP (orig, 0)) == PLUS);
2053
2054       base = legitimize_pic_address (XEXP (XEXP (orig, 0), 0), Pmode, reg);
2055       orig = legitimize_pic_address (XEXP (XEXP (orig, 0), 1), Pmode,
2056                                      base == reg ? 0 : reg);
2057
2058       if (GET_CODE (orig) == CONST_INT)
2059         return plus_constant (base, INTVAL (orig));
2060       pic_ref = gen_rtx_PLUS (Pmode, base, orig);
2061       /* Likewise, should we set special REG_NOTEs here?  */
2062     }
2063   return pic_ref;
2064 }
2065
2066 \f
2067
2068 #define USE_MOVQ(i)     ((unsigned) ((i) + 128) <= 255)
2069
2070 /* Return the type of move that should be used for integer I.  */
2071
2072 M68K_CONST_METHOD
2073 m68k_const_method (HOST_WIDE_INT i)
2074 {
2075   unsigned u;
2076
2077   if (USE_MOVQ (i))
2078     return MOVQ;
2079
2080   /* The ColdFire doesn't have byte or word operations.  */
2081   /* FIXME: This may not be useful for the m68060 either.  */
2082   if (!TARGET_COLDFIRE)
2083     {
2084       /* if -256 < N < 256 but N is not in range for a moveq
2085          N^ff will be, so use moveq #N^ff, dreg; not.b dreg.  */
2086       if (USE_MOVQ (i ^ 0xff))
2087         return NOTB;
2088       /* Likewise, try with not.w */
2089       if (USE_MOVQ (i ^ 0xffff))
2090         return NOTW;
2091       /* This is the only value where neg.w is useful */
2092       if (i == -65408)
2093         return NEGW;
2094     }
2095
2096   /* Try also with swap.  */
2097   u = i;
2098   if (USE_MOVQ ((u >> 16) | (u << 16)))
2099     return SWAP;
2100
2101   if (TARGET_ISAB)
2102     {
2103       /* Try using MVZ/MVS with an immediate value to load constants.  */
2104       if (i >= 0 && i <= 65535)
2105         return MVZ;
2106       if (i >= -32768 && i <= 32767)
2107         return MVS;
2108     }
2109
2110   /* Otherwise, use move.l */
2111   return MOVL;
2112 }
2113
2114 /* Return the cost of moving constant I into a data register.  */
2115
2116 static int
2117 const_int_cost (HOST_WIDE_INT i)
2118 {
2119   switch (m68k_const_method (i))
2120     {
2121     case MOVQ:
2122       /* Constants between -128 and 127 are cheap due to moveq.  */
2123       return 0;
2124     case MVZ:
2125     case MVS:
2126     case NOTB:
2127     case NOTW:
2128     case NEGW:
2129     case SWAP:
2130       /* Constants easily generated by moveq + not.b/not.w/neg.w/swap.  */
2131       return 1;
2132     case MOVL:
2133       return 2;
2134     default:
2135       gcc_unreachable ();
2136     }
2137 }
2138
2139 static bool
2140 m68k_rtx_costs (rtx x, int code, int outer_code, int *total)
2141 {
2142   switch (code)
2143     {
2144     case CONST_INT:
2145       /* Constant zero is super cheap due to clr instruction.  */
2146       if (x == const0_rtx)
2147         *total = 0;
2148       else
2149         *total = const_int_cost (INTVAL (x));
2150       return true;
2151
2152     case CONST:
2153     case LABEL_REF:
2154     case SYMBOL_REF:
2155       *total = 3;
2156       return true;
2157
2158     case CONST_DOUBLE:
2159       /* Make 0.0 cheaper than other floating constants to
2160          encourage creating tstsf and tstdf insns.  */
2161       if (outer_code == COMPARE
2162           && (x == CONST0_RTX (SFmode) || x == CONST0_RTX (DFmode)))
2163         *total = 4;
2164       else
2165         *total = 5;
2166       return true;
2167
2168     /* These are vaguely right for a 68020.  */
2169     /* The costs for long multiply have been adjusted to work properly
2170        in synth_mult on the 68020, relative to an average of the time
2171        for add and the time for shift, taking away a little more because
2172        sometimes move insns are needed.  */
2173     /* div?.w is relatively cheaper on 68000 counted in COSTS_N_INSNS
2174        terms.  */
2175 #define MULL_COST                               \
2176   (TUNE_68060 ? 2                               \
2177    : TUNE_68040 ? 5                             \
2178    : TUNE_CFV2 ? 10                             \
2179    : TARGET_COLDFIRE ? 3 : 13)
2180
2181 #define MULW_COST                               \
2182   (TUNE_68060 ? 2                               \
2183    : TUNE_68040 ? 3                             \
2184    : TUNE_68000_10 || TUNE_CFV2 ? 5             \
2185    : TARGET_COLDFIRE ? 2 : 8)
2186
2187 #define DIVW_COST                               \
2188   (TARGET_CF_HWDIV ? 11                         \
2189    : TUNE_68000_10 || TARGET_COLDFIRE ? 12 : 27)
2190
2191     case PLUS:
2192       /* An lea costs about three times as much as a simple add.  */
2193       if (GET_MODE (x) == SImode
2194           && GET_CODE (XEXP (x, 1)) == REG
2195           && GET_CODE (XEXP (x, 0)) == MULT
2196           && GET_CODE (XEXP (XEXP (x, 0), 0)) == REG
2197           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
2198           && (INTVAL (XEXP (XEXP (x, 0), 1)) == 2
2199               || INTVAL (XEXP (XEXP (x, 0), 1)) == 4
2200               || INTVAL (XEXP (XEXP (x, 0), 1)) == 8))
2201         {
2202             /* lea an@(dx:l:i),am */
2203             *total = COSTS_N_INSNS (TARGET_COLDFIRE ? 2 : 3);
2204             return true;
2205         }
2206       return false;
2207
2208     case ASHIFT:
2209     case ASHIFTRT:
2210     case LSHIFTRT:
2211       if (TUNE_68060)
2212         {
2213           *total = COSTS_N_INSNS(1);
2214           return true;
2215         }
2216       if (TUNE_68000_10)
2217         {
2218           if (GET_CODE (XEXP (x, 1)) == CONST_INT)
2219             {
2220               if (INTVAL (XEXP (x, 1)) < 16)
2221                 *total = COSTS_N_INSNS (2) + INTVAL (XEXP (x, 1)) / 2;
2222               else
2223                 /* We're using clrw + swap for these cases.  */
2224                 *total = COSTS_N_INSNS (4) + (INTVAL (XEXP (x, 1)) - 16) / 2;
2225             }
2226           else
2227             *total = COSTS_N_INSNS (10); /* Worst case.  */
2228           return true;
2229         }
2230       /* A shift by a big integer takes an extra instruction.  */
2231       if (GET_CODE (XEXP (x, 1)) == CONST_INT
2232           && (INTVAL (XEXP (x, 1)) == 16))
2233         {
2234           *total = COSTS_N_INSNS (2);    /* clrw;swap */
2235           return true;
2236         }
2237       if (GET_CODE (XEXP (x, 1)) == CONST_INT
2238           && !(INTVAL (XEXP (x, 1)) > 0
2239                && INTVAL (XEXP (x, 1)) <= 8))
2240         {
2241           *total = COSTS_N_INSNS (TARGET_COLDFIRE ? 1 : 3);      /* lsr #i,dn */
2242           return true;
2243         }
2244       return false;
2245
2246     case MULT:
2247       if ((GET_CODE (XEXP (x, 0)) == ZERO_EXTEND
2248            || GET_CODE (XEXP (x, 0)) == SIGN_EXTEND)
2249           && GET_MODE (x) == SImode)
2250         *total = COSTS_N_INSNS (MULW_COST);
2251       else if (GET_MODE (x) == QImode || GET_MODE (x) == HImode)
2252         *total = COSTS_N_INSNS (MULW_COST);
2253       else
2254         *total = COSTS_N_INSNS (MULL_COST);
2255       return true;
2256
2257     case DIV:
2258     case UDIV:
2259     case MOD:
2260     case UMOD:
2261       if (GET_MODE (x) == QImode || GET_MODE (x) == HImode)
2262         *total = COSTS_N_INSNS (DIVW_COST);     /* div.w */
2263       else if (TARGET_CF_HWDIV)
2264         *total = COSTS_N_INSNS (18);
2265       else
2266         *total = COSTS_N_INSNS (43);            /* div.l */
2267       return true;
2268
2269     default:
2270       return false;
2271     }
2272 }
2273
2274 /* Return an instruction to move CONST_INT OPERANDS[1] into data register
2275    OPERANDS[0].  */
2276
2277 static const char *
2278 output_move_const_into_data_reg (rtx *operands)
2279 {
2280   HOST_WIDE_INT i;
2281
2282   i = INTVAL (operands[1]);
2283   switch (m68k_const_method (i))
2284     {
2285     case MVZ:
2286       return "mvzw %1,%0";
2287     case MVS:
2288       return "mvsw %1,%0";
2289     case MOVQ:
2290       return "moveq %1,%0";
2291     case NOTB:
2292       CC_STATUS_INIT;
2293       operands[1] = GEN_INT (i ^ 0xff);
2294       return "moveq %1,%0\n\tnot%.b %0";
2295     case NOTW:
2296       CC_STATUS_INIT;
2297       operands[1] = GEN_INT (i ^ 0xffff);
2298       return "moveq %1,%0\n\tnot%.w %0";
2299     case NEGW:
2300       CC_STATUS_INIT;
2301       return "moveq #-128,%0\n\tneg%.w %0";
2302     case SWAP:
2303       {
2304         unsigned u = i;
2305
2306         operands[1] = GEN_INT ((u << 16) | (u >> 16));
2307         return "moveq %1,%0\n\tswap %0";
2308       }
2309     case MOVL:
2310       return "move%.l %1,%0";
2311     default:
2312       gcc_unreachable ();
2313     }
2314 }
2315
2316 /* Return true if I can be handled by ISA B's mov3q instruction.  */
2317
2318 bool
2319 valid_mov3q_const (HOST_WIDE_INT i)
2320 {
2321   return TARGET_ISAB && (i == -1 || IN_RANGE (i, 1, 7));
2322 }
2323
2324 /* Return an instruction to move CONST_INT OPERANDS[1] into OPERANDS[0].
2325    I is the value of OPERANDS[1].  */
2326
2327 static const char *
2328 output_move_simode_const (rtx *operands)
2329 {
2330   rtx dest;
2331   HOST_WIDE_INT src;
2332
2333   dest = operands[0];
2334   src = INTVAL (operands[1]);
2335   if (src == 0
2336       && (DATA_REG_P (dest) || MEM_P (dest))
2337       /* clr insns on 68000 read before writing.  */
2338       && ((TARGET_68010 || TARGET_COLDFIRE)
2339           || !(MEM_P (dest) && MEM_VOLATILE_P (dest))))
2340     return "clr%.l %0";
2341   else if (GET_MODE (dest) == SImode && valid_mov3q_const (src))
2342     return "mov3q%.l %1,%0";
2343   else if (src == 0 && ADDRESS_REG_P (dest))
2344     return "sub%.l %0,%0";
2345   else if (DATA_REG_P (dest))
2346     return output_move_const_into_data_reg (operands);
2347   else if (ADDRESS_REG_P (dest) && IN_RANGE (src, -0x8000, 0x7fff))
2348     {
2349       if (valid_mov3q_const (src))
2350         return "mov3q%.l %1,%0";
2351       return "move%.w %1,%0";
2352     }
2353   else if (MEM_P (dest)
2354            && GET_CODE (XEXP (dest, 0)) == PRE_DEC
2355            && REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
2356            && IN_RANGE (src, -0x8000, 0x7fff))
2357     {
2358       if (valid_mov3q_const (src))
2359         return "mov3q%.l %1,%-";
2360       return "pea %a1";
2361     }
2362   return "move%.l %1,%0";
2363 }
2364
2365 const char *
2366 output_move_simode (rtx *operands)
2367 {
2368   if (GET_CODE (operands[1]) == CONST_INT)
2369     return output_move_simode_const (operands);
2370   else if ((GET_CODE (operands[1]) == SYMBOL_REF
2371             || GET_CODE (operands[1]) == CONST)
2372            && push_operand (operands[0], SImode))
2373     return "pea %a1";
2374   else if ((GET_CODE (operands[1]) == SYMBOL_REF
2375             || GET_CODE (operands[1]) == CONST)
2376            && ADDRESS_REG_P (operands[0]))
2377     return "lea %a1,%0";
2378   return "move%.l %1,%0";
2379 }
2380
2381 const char *
2382 output_move_himode (rtx *operands)
2383 {
2384  if (GET_CODE (operands[1]) == CONST_INT)
2385     {
2386       if (operands[1] == const0_rtx
2387           && (DATA_REG_P (operands[0])
2388               || GET_CODE (operands[0]) == MEM)
2389           /* clr insns on 68000 read before writing.  */
2390           && ((TARGET_68010 || TARGET_COLDFIRE)
2391               || !(GET_CODE (operands[0]) == MEM
2392                    && MEM_VOLATILE_P (operands[0]))))
2393         return "clr%.w %0";
2394       else if (operands[1] == const0_rtx
2395                && ADDRESS_REG_P (operands[0]))
2396         return "sub%.l %0,%0";
2397       else if (DATA_REG_P (operands[0])
2398                && INTVAL (operands[1]) < 128
2399                && INTVAL (operands[1]) >= -128)
2400         return "moveq %1,%0";
2401       else if (INTVAL (operands[1]) < 0x8000
2402                && INTVAL (operands[1]) >= -0x8000)
2403         return "move%.w %1,%0";
2404     }
2405   else if (CONSTANT_P (operands[1]))
2406     return "move%.l %1,%0";
2407   return "move%.w %1,%0";
2408 }
2409
2410 const char *
2411 output_move_qimode (rtx *operands)
2412 {
2413   /* 68k family always modifies the stack pointer by at least 2, even for
2414      byte pushes.  The 5200 (ColdFire) does not do this.  */
2415
2416   /* This case is generated by pushqi1 pattern now.  */
2417   gcc_assert (!(GET_CODE (operands[0]) == MEM
2418                 && GET_CODE (XEXP (operands[0], 0)) == PRE_DEC
2419                 && XEXP (XEXP (operands[0], 0), 0) == stack_pointer_rtx
2420                 && ! ADDRESS_REG_P (operands[1])
2421                 && ! TARGET_COLDFIRE));
2422
2423   /* clr and st insns on 68000 read before writing.  */
2424   if (!ADDRESS_REG_P (operands[0])
2425       && ((TARGET_68010 || TARGET_COLDFIRE)
2426           || !(GET_CODE (operands[0]) == MEM && MEM_VOLATILE_P (operands[0]))))
2427     {
2428       if (operands[1] == const0_rtx)
2429         return "clr%.b %0";
2430       if ((!TARGET_COLDFIRE || DATA_REG_P (operands[0]))
2431           && GET_CODE (operands[1]) == CONST_INT
2432           && (INTVAL (operands[1]) & 255) == 255)
2433         {
2434           CC_STATUS_INIT;
2435           return "st %0";
2436         }
2437     }
2438   if (GET_CODE (operands[1]) == CONST_INT
2439       && DATA_REG_P (operands[0])
2440       && INTVAL (operands[1]) < 128
2441       && INTVAL (operands[1]) >= -128)
2442     return "moveq %1,%0";
2443   if (operands[1] == const0_rtx && ADDRESS_REG_P (operands[0]))
2444     return "sub%.l %0,%0";
2445   if (GET_CODE (operands[1]) != CONST_INT && CONSTANT_P (operands[1]))
2446     return "move%.l %1,%0";
2447   /* 68k family (including the 5200 ColdFire) does not support byte moves to
2448      from address registers.  */
2449   if (ADDRESS_REG_P (operands[0]) || ADDRESS_REG_P (operands[1]))
2450     return "move%.w %1,%0";
2451   return "move%.b %1,%0";
2452 }
2453
2454 const char *
2455 output_move_stricthi (rtx *operands)
2456 {
2457   if (operands[1] == const0_rtx
2458       /* clr insns on 68000 read before writing.  */
2459       && ((TARGET_68010 || TARGET_COLDFIRE)
2460           || !(GET_CODE (operands[0]) == MEM && MEM_VOLATILE_P (operands[0]))))
2461     return "clr%.w %0";
2462   return "move%.w %1,%0";
2463 }
2464
2465 const char *
2466 output_move_strictqi (rtx *operands)
2467 {
2468   if (operands[1] == const0_rtx
2469       /* clr insns on 68000 read before writing.  */
2470       && ((TARGET_68010 || TARGET_COLDFIRE)
2471           || !(GET_CODE (operands[0]) == MEM && MEM_VOLATILE_P (operands[0]))))
2472     return "clr%.b %0";
2473   return "move%.b %1,%0";
2474 }
2475
2476 /* Return the best assembler insn template
2477    for moving operands[1] into operands[0] as a fullword.  */
2478
2479 static const char *
2480 singlemove_string (rtx *operands)
2481 {
2482   if (GET_CODE (operands[1]) == CONST_INT)
2483     return output_move_simode_const (operands);
2484   return "move%.l %1,%0";
2485 }
2486
2487
2488 /* Output assembler or rtl code to perform a doubleword move insn
2489    with operands OPERANDS.
2490    Pointers to 3 helper functions should be specified:
2491    HANDLE_REG_ADJUST to adjust a register by a small value,
2492    HANDLE_COMPADR to compute an address and
2493    HANDLE_MOVSI to move 4 bytes.  */
2494
2495 static void
2496 handle_move_double (rtx operands[2],
2497                     void (*handle_reg_adjust) (rtx, int),
2498                     void (*handle_compadr) (rtx [2]),
2499                     void (*handle_movsi) (rtx [2]))
2500 {
2501   enum
2502     {
2503       REGOP, OFFSOP, MEMOP, PUSHOP, POPOP, CNSTOP, RNDOP
2504     } optype0, optype1;
2505   rtx latehalf[2];
2506   rtx middlehalf[2];
2507   rtx xops[2];
2508   rtx addreg0 = 0, addreg1 = 0;
2509   int dest_overlapped_low = 0;
2510   int size = GET_MODE_SIZE (GET_MODE (operands[0]));
2511
2512   middlehalf[0] = 0;
2513   middlehalf[1] = 0;
2514
2515   /* First classify both operands.  */
2516
2517   if (REG_P (operands[0]))
2518     optype0 = REGOP;
2519   else if (offsettable_memref_p (operands[0]))
2520     optype0 = OFFSOP;
2521   else if (GET_CODE (XEXP (operands[0], 0)) == POST_INC)
2522     optype0 = POPOP;
2523   else if (GET_CODE (XEXP (operands[0], 0)) == PRE_DEC)
2524     optype0 = PUSHOP;
2525   else if (GET_CODE (operands[0]) == MEM)
2526     optype0 = MEMOP;
2527   else
2528     optype0 = RNDOP;
2529
2530   if (REG_P (operands[1]))
2531     optype1 = REGOP;
2532   else if (CONSTANT_P (operands[1]))
2533     optype1 = CNSTOP;
2534   else if (offsettable_memref_p (operands[1]))
2535     optype1 = OFFSOP;
2536   else if (GET_CODE (XEXP (operands[1], 0)) == POST_INC)
2537     optype1 = POPOP;
2538   else if (GET_CODE (XEXP (operands[1], 0)) == PRE_DEC)
2539     optype1 = PUSHOP;
2540   else if (GET_CODE (operands[1]) == MEM)
2541     optype1 = MEMOP;
2542   else
2543     optype1 = RNDOP;
2544
2545   /* Check for the cases that the operand constraints are not supposed
2546      to allow to happen.  Generating code for these cases is
2547      painful.  */
2548   gcc_assert (optype0 != RNDOP && optype1 != RNDOP);
2549
2550   /* If one operand is decrementing and one is incrementing
2551      decrement the former register explicitly
2552      and change that operand into ordinary indexing.  */
2553
2554   if (optype0 == PUSHOP && optype1 == POPOP)
2555     {
2556       operands[0] = XEXP (XEXP (operands[0], 0), 0);
2557
2558       handle_reg_adjust (operands[0], -size);
2559
2560       if (GET_MODE (operands[1]) == XFmode)
2561         operands[0] = gen_rtx_MEM (XFmode, operands[0]);
2562       else if (GET_MODE (operands[0]) == DFmode)
2563         operands[0] = gen_rtx_MEM (DFmode, operands[0]);
2564       else
2565         operands[0] = gen_rtx_MEM (DImode, operands[0]);
2566       optype0 = OFFSOP;
2567     }
2568   if (optype0 == POPOP && optype1 == PUSHOP)
2569     {
2570       operands[1] = XEXP (XEXP (operands[1], 0), 0);
2571
2572       handle_reg_adjust (operands[1], -size);
2573
2574       if (GET_MODE (operands[1]) == XFmode)
2575         operands[1] = gen_rtx_MEM (XFmode, operands[1]);
2576       else if (GET_MODE (operands[1]) == DFmode)
2577         operands[1] = gen_rtx_MEM (DFmode, operands[1]);
2578       else
2579         operands[1] = gen_rtx_MEM (DImode, operands[1]);
2580       optype1 = OFFSOP;
2581     }
2582
2583   /* If an operand is an unoffsettable memory ref, find a register
2584      we can increment temporarily to make it refer to the second word.  */
2585
2586   if (optype0 == MEMOP)
2587     addreg0 = find_addr_reg (XEXP (operands[0], 0));
2588
2589   if (optype1 == MEMOP)
2590     addreg1 = find_addr_reg (XEXP (operands[1], 0));
2591
2592   /* Ok, we can do one word at a time.
2593      Normally we do the low-numbered word first,
2594      but if either operand is autodecrementing then we
2595      do the high-numbered word first.
2596
2597      In either case, set up in LATEHALF the operands to use
2598      for the high-numbered word and in some cases alter the
2599      operands in OPERANDS to be suitable for the low-numbered word.  */
2600
2601   if (size == 12)
2602     {
2603       if (optype0 == REGOP)
2604         {
2605           latehalf[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 2);
2606           middlehalf[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
2607         }
2608       else if (optype0 == OFFSOP)
2609         {
2610           middlehalf[0] = adjust_address (operands[0], SImode, 4);
2611           latehalf[0] = adjust_address (operands[0], SImode, size - 4);
2612         }
2613       else
2614         {
2615           middlehalf[0] = adjust_address (operands[0], SImode, 0);
2616           latehalf[0] = adjust_address (operands[0], SImode, 0);
2617         }
2618
2619       if (optype1 == REGOP)
2620         {
2621           latehalf[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 2);
2622           middlehalf[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
2623         }
2624       else if (optype1 == OFFSOP)
2625         {
2626           middlehalf[1] = adjust_address (operands[1], SImode, 4);
2627           latehalf[1] = adjust_address (operands[1], SImode, size - 4);
2628         }
2629       else if (optype1 == CNSTOP)
2630         {
2631           if (GET_CODE (operands[1]) == CONST_DOUBLE)
2632             {
2633               REAL_VALUE_TYPE r;
2634               long l[3];
2635
2636               REAL_VALUE_FROM_CONST_DOUBLE (r, operands[1]);
2637               REAL_VALUE_TO_TARGET_LONG_DOUBLE (r, l);
2638               operands[1] = GEN_INT (l[0]);
2639               middlehalf[1] = GEN_INT (l[1]);
2640               latehalf[1] = GEN_INT (l[2]);
2641             }
2642           else
2643             {
2644               /* No non-CONST_DOUBLE constant should ever appear
2645                  here.  */
2646               gcc_assert (!CONSTANT_P (operands[1]));
2647             }
2648         }
2649       else
2650         {
2651           middlehalf[1] = adjust_address (operands[1], SImode, 0);
2652           latehalf[1] = adjust_address (operands[1], SImode, 0);
2653         }
2654     }
2655   else
2656     /* size is not 12: */
2657     {
2658       if (optype0 == REGOP)
2659         latehalf[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
2660       else if (optype0 == OFFSOP)
2661         latehalf[0] = adjust_address (operands[0], SImode, size - 4);
2662       else
2663         latehalf[0] = adjust_address (operands[0], SImode, 0);
2664
2665       if (optype1 == REGOP)
2666         latehalf[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
2667       else if (optype1 == OFFSOP)
2668         latehalf[1] = adjust_address (operands[1], SImode, size - 4);
2669       else if (optype1 == CNSTOP)
2670         split_double (operands[1], &operands[1], &latehalf[1]);
2671       else
2672         latehalf[1] = adjust_address (operands[1], SImode, 0);
2673     }
2674
2675   /* If insn is effectively movd N(sp),-(sp) then we will do the
2676      high word first.  We should use the adjusted operand 1 (which is N+4(sp))
2677      for the low word as well, to compensate for the first decrement of sp.  */
2678   if (optype0 == PUSHOP
2679       && REGNO (XEXP (XEXP (operands[0], 0), 0)) == STACK_POINTER_REGNUM
2680       && reg_overlap_mentioned_p (stack_pointer_rtx, operands[1]))
2681     operands[1] = middlehalf[1] = latehalf[1];
2682
2683   /* For (set (reg:DI N) (mem:DI ... (reg:SI N) ...)),
2684      if the upper part of reg N does not appear in the MEM, arrange to
2685      emit the move late-half first.  Otherwise, compute the MEM address
2686      into the upper part of N and use that as a pointer to the memory
2687      operand.  */
2688   if (optype0 == REGOP
2689       && (optype1 == OFFSOP || optype1 == MEMOP))
2690     {
2691       rtx testlow = gen_rtx_REG (SImode, REGNO (operands[0]));
2692
2693       if (reg_overlap_mentioned_p (testlow, XEXP (operands[1], 0))
2694           && reg_overlap_mentioned_p (latehalf[0], XEXP (operands[1], 0)))
2695         {
2696           /* If both halves of dest are used in the src memory address,
2697              compute the address into latehalf of dest.
2698              Note that this can't happen if the dest is two data regs.  */
2699         compadr:
2700           xops[0] = latehalf[0];
2701           xops[1] = XEXP (operands[1], 0);
2702
2703           handle_compadr (xops);
2704           if (GET_MODE (operands[1]) == XFmode)
2705             {
2706               operands[1] = gen_rtx_MEM (XFmode, latehalf[0]);
2707               middlehalf[1] = adjust_address (operands[1], DImode, size - 8);
2708               latehalf[1] = adjust_address (operands[1], DImode, size - 4);
2709             }
2710           else
2711             {
2712               operands[1] = gen_rtx_MEM (DImode, latehalf[0]);
2713               latehalf[1] = adjust_address (operands[1], DImode, size - 4);
2714             }
2715         }
2716       else if (size == 12
2717                && reg_overlap_mentioned_p (middlehalf[0],
2718                                            XEXP (operands[1], 0)))
2719         {
2720           /* Check for two regs used by both source and dest.
2721              Note that this can't happen if the dest is all data regs.
2722              It can happen if the dest is d6, d7, a0.
2723              But in that case, latehalf is an addr reg, so
2724              the code at compadr does ok.  */
2725
2726           if (reg_overlap_mentioned_p (testlow, XEXP (operands[1], 0))
2727               || reg_overlap_mentioned_p (latehalf[0], XEXP (operands[1], 0)))
2728             goto compadr;
2729
2730           /* JRV says this can't happen: */
2731           gcc_assert (!addreg0 && !addreg1);
2732
2733           /* Only the middle reg conflicts; simply put it last.  */
2734           handle_movsi (operands);
2735           handle_movsi (latehalf);
2736           handle_movsi (middlehalf);
2737
2738           return;
2739         }
2740       else if (reg_overlap_mentioned_p (testlow, XEXP (operands[1], 0)))
2741         /* If the low half of dest is mentioned in the source memory
2742            address, the arrange to emit the move late half first.  */
2743         dest_overlapped_low = 1;
2744     }
2745
2746   /* If one or both operands autodecrementing,
2747      do the two words, high-numbered first.  */
2748
2749   /* Likewise,  the first move would clobber the source of the second one,
2750      do them in the other order.  This happens only for registers;
2751      such overlap can't happen in memory unless the user explicitly
2752      sets it up, and that is an undefined circumstance.  */
2753
2754   if (optype0 == PUSHOP || optype1 == PUSHOP
2755       || (optype0 == REGOP && optype1 == REGOP
2756           && ((middlehalf[1] && REGNO (operands[0]) == REGNO (middlehalf[1]))
2757               || REGNO (operands[0]) == REGNO (latehalf[1])))
2758       || dest_overlapped_low)
2759     {
2760       /* Make any unoffsettable addresses point at high-numbered word.  */
2761       if (addreg0)
2762         handle_reg_adjust (addreg0, size - 4);
2763       if (addreg1)
2764         handle_reg_adjust (addreg1, size - 4);
2765
2766       /* Do that word.  */
2767       handle_movsi (latehalf);
2768
2769       /* Undo the adds we just did.  */
2770       if (addreg0)
2771         handle_reg_adjust (addreg0, -4);
2772       if (addreg1)
2773         handle_reg_adjust (addreg1, -4);
2774
2775       if (size == 12)
2776         {
2777           handle_movsi (middlehalf);
2778
2779           if (addreg0)
2780             handle_reg_adjust (addreg0, -4);
2781           if (addreg1)
2782             handle_reg_adjust (addreg1, -4);
2783         }
2784
2785       /* Do low-numbered word.  */
2786
2787       handle_movsi (operands);
2788       return;
2789     }
2790
2791   /* Normal case: do the two words, low-numbered first.  */
2792
2793   handle_movsi (operands);
2794
2795   /* Do the middle one of the three words for long double */
2796   if (size == 12)
2797     {
2798       if (addreg0)
2799         handle_reg_adjust (addreg0, 4);
2800       if (addreg1)
2801         handle_reg_adjust (addreg1, 4);
2802
2803       handle_movsi (middlehalf);
2804     }
2805
2806   /* Make any unoffsettable addresses point at high-numbered word.  */
2807   if (addreg0)
2808     handle_reg_adjust (addreg0, 4);
2809   if (addreg1)
2810     handle_reg_adjust (addreg1, 4);
2811
2812   /* Do that word.  */
2813   handle_movsi (latehalf);
2814
2815   /* Undo the adds we just did.  */
2816   if (addreg0)
2817     handle_reg_adjust (addreg0, -(size - 4));
2818   if (addreg1)
2819     handle_reg_adjust (addreg1, -(size - 4));
2820
2821   return;
2822 }
2823
2824 /* Output assembler code to adjust REG by N.  */
2825 static void
2826 output_reg_adjust (rtx reg, int n)
2827 {
2828   const char *s;
2829
2830   gcc_assert (GET_MODE (reg) == SImode
2831               && -12 <= n && n != 0 && n <= 12);
2832
2833   switch (n)
2834     {
2835     case 12:
2836       s = "add%.l #12,%0";
2837       break;
2838
2839     case 8:
2840       s = "addq%.l #8,%0";
2841       break;
2842
2843     case 4:
2844       s = "addq%.l #4,%0";
2845       break;
2846
2847     case -12:
2848       s = "sub%.l #12,%0";
2849       break;
2850
2851     case -8:
2852       s = "subq%.l #8,%0";
2853       break;
2854
2855     case -4:
2856       s = "subq%.l #4,%0";
2857       break;
2858
2859     default:
2860       gcc_unreachable ();
2861       s = NULL;
2862     }
2863
2864   output_asm_insn (s, &reg);
2865 }
2866
2867 /* Emit rtl code to adjust REG by N.  */
2868 static void
2869 emit_reg_adjust (rtx reg1, int n)
2870 {
2871   rtx reg2;
2872
2873   gcc_assert (GET_MODE (reg1) == SImode
2874               && -12 <= n && n != 0 && n <= 12);
2875
2876   reg1 = copy_rtx (reg1);
2877   reg2 = copy_rtx (reg1);
2878
2879   if (n < 0)
2880     emit_insn (gen_subsi3 (reg1, reg2, GEN_INT (-n)));
2881   else if (n > 0)
2882     emit_insn (gen_addsi3 (reg1, reg2, GEN_INT (n)));
2883   else
2884     gcc_unreachable ();
2885 }
2886
2887 /* Output assembler to load address OPERANDS[0] to register OPERANDS[1].  */
2888 static void
2889 output_compadr (rtx operands[2])
2890 {
2891   output_asm_insn ("lea %a1,%0", operands);
2892 }
2893
2894 /* Output the best assembler insn for moving operands[1] into operands[0]
2895    as a fullword.  */
2896 static void
2897 output_movsi (rtx operands[2])
2898 {
2899   output_asm_insn (singlemove_string (operands), operands);
2900 }
2901
2902 /* Copy OP and change its mode to MODE.  */
2903 static rtx
2904 copy_operand (rtx op, enum machine_mode mode)
2905 {
2906   /* ??? This looks really ugly.  There must be a better way
2907      to change a mode on the operand.  */
2908   if (GET_MODE (op) != VOIDmode)
2909     {
2910       if (REG_P (op))
2911         op = gen_rtx_REG (mode, REGNO (op));
2912       else
2913         {
2914           op = copy_rtx (op);
2915           PUT_MODE (op, mode);
2916         }
2917     }
2918
2919   return op;
2920 }
2921
2922 /* Emit rtl code for moving operands[1] into operands[0] as a fullword.  */
2923 static void
2924 emit_movsi (rtx operands[2])
2925 {
2926   operands[0] = copy_operand (operands[0], SImode);
2927   operands[1] = copy_operand (operands[1], SImode);
2928
2929   emit_insn (gen_movsi (operands[0], operands[1]));
2930 }
2931
2932 /* Output assembler code to perform a doubleword move insn
2933    with operands OPERANDS.  */
2934 const char *
2935 output_move_double (rtx *operands)
2936 {
2937   handle_move_double (operands,
2938                       output_reg_adjust, output_compadr, output_movsi);
2939
2940   return "";
2941 }
2942
2943 /* Output rtl code to perform a doubleword move insn
2944    with operands OPERANDS.  */
2945 void
2946 m68k_emit_move_double (rtx operands[2])
2947 {
2948   handle_move_double (operands, emit_reg_adjust, emit_movsi, emit_movsi);
2949 }
2950
2951 /* Ensure mode of ORIG, a REG rtx, is MODE.  Returns either ORIG or a
2952    new rtx with the correct mode.  */
2953
2954 static rtx
2955 force_mode (enum machine_mode mode, rtx orig)
2956 {
2957   if (mode == GET_MODE (orig))
2958     return orig;
2959
2960   if (REGNO (orig) >= FIRST_PSEUDO_REGISTER)
2961     abort ();
2962
2963   return gen_rtx_REG (mode, REGNO (orig));
2964 }
2965
2966 static int
2967 fp_reg_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2968 {
2969   return reg_renumber && FP_REG_P (op);
2970 }
2971
2972 /* Emit insns to move operands[1] into operands[0].
2973
2974    Return 1 if we have written out everything that needs to be done to
2975    do the move.  Otherwise, return 0 and the caller will emit the move
2976    normally.
2977
2978    Note SCRATCH_REG may not be in the proper mode depending on how it
2979    will be used.  This routine is responsible for creating a new copy
2980    of SCRATCH_REG in the proper mode.  */
2981
2982 int
2983 emit_move_sequence (rtx *operands, enum machine_mode mode, rtx scratch_reg)
2984 {
2985   register rtx operand0 = operands[0];
2986   register rtx operand1 = operands[1];
2987   register rtx tem;
2988
2989   if (scratch_reg
2990       && reload_in_progress && GET_CODE (operand0) == REG
2991       && REGNO (operand0) >= FIRST_PSEUDO_REGISTER)
2992     operand0 = reg_equiv_mem[REGNO (operand0)];
2993   else if (scratch_reg
2994            && reload_in_progress && GET_CODE (operand0) == SUBREG
2995            && GET_CODE (SUBREG_REG (operand0)) == REG
2996            && REGNO (SUBREG_REG (operand0)) >= FIRST_PSEUDO_REGISTER)
2997     {
2998      /* We must not alter SUBREG_BYTE (operand0) since that would confuse
2999         the code which tracks sets/uses for delete_output_reload.  */
3000       rtx temp = gen_rtx_SUBREG (GET_MODE (operand0),
3001                                  reg_equiv_mem [REGNO (SUBREG_REG (operand0))],
3002                                  SUBREG_BYTE (operand0));
3003       operand0 = alter_subreg (&temp);
3004     }
3005
3006   if (scratch_reg
3007       && reload_in_progress && GET_CODE (operand1) == REG
3008       && REGNO (operand1) >= FIRST_PSEUDO_REGISTER)
3009     operand1 = reg_equiv_mem[REGNO (operand1)];
3010   else if (scratch_reg
3011            && reload_in_progress && GET_CODE (operand1) == SUBREG
3012            && GET_CODE (SUBREG_REG (operand1)) == REG
3013            && REGNO (SUBREG_REG (operand1)) >= FIRST_PSEUDO_REGISTER)
3014     {
3015      /* We must not alter SUBREG_BYTE (operand0) since that would confuse
3016         the code which tracks sets/uses for delete_output_reload.  */
3017       rtx temp = gen_rtx_SUBREG (GET_MODE (operand1),
3018                                  reg_equiv_mem [REGNO (SUBREG_REG (operand1))],
3019                                  SUBREG_BYTE (operand1));
3020       operand1 = alter_subreg (&temp);
3021     }
3022
3023   if (scratch_reg && reload_in_progress && GET_CODE (operand0) == MEM
3024       && ((tem = find_replacement (&XEXP (operand0, 0)))
3025           != XEXP (operand0, 0)))
3026     operand0 = gen_rtx_MEM (GET_MODE (operand0), tem);
3027   if (scratch_reg && reload_in_progress && GET_CODE (operand1) == MEM
3028       && ((tem = find_replacement (&XEXP (operand1, 0)))
3029           != XEXP (operand1, 0)))
3030     operand1 = gen_rtx_MEM (GET_MODE (operand1), tem);
3031
3032   /* Handle secondary reloads for loads/stores of FP registers where
3033      the address is symbolic by using the scratch register */
3034   if (fp_reg_operand (operand0, mode)
3035       && ((GET_CODE (operand1) == MEM
3036            && ! memory_address_p (DFmode, XEXP (operand1, 0)))
3037           || ((GET_CODE (operand1) == SUBREG
3038                && GET_CODE (XEXP (operand1, 0)) == MEM
3039                && !memory_address_p (DFmode, XEXP (XEXP (operand1, 0), 0)))))
3040       && scratch_reg)
3041     {
3042       if (GET_CODE (operand1) == SUBREG)
3043         operand1 = XEXP (operand1, 0);
3044
3045       /* SCRATCH_REG will hold an address.  We want
3046          it in SImode regardless of what mode it was originally given
3047          to us.  */
3048       scratch_reg = force_mode (SImode, scratch_reg);
3049
3050       /* D might not fit in 14 bits either; for such cases load D into
3051          scratch reg.  */
3052       if (!memory_address_p (Pmode, XEXP (operand1, 0)))
3053         {
3054           emit_move_insn (scratch_reg, XEXP (XEXP (operand1, 0), 1));
3055           emit_move_insn (scratch_reg, gen_rtx_fmt_ee (GET_CODE (XEXP (operand1, 0)),
3056                                                        Pmode,
3057                                                        XEXP (XEXP (operand1, 0), 0),
3058                                                        scratch_reg));
3059         }
3060       else
3061         emit_move_insn (scratch_reg, XEXP (operand1, 0));
3062       emit_insn (gen_rtx_SET (VOIDmode, operand0,
3063                               gen_rtx_MEM (mode, scratch_reg)));
3064       return 1;
3065     }
3066   else if (fp_reg_operand (operand1, mode)
3067            && ((GET_CODE (operand0) == MEM
3068                 && ! memory_address_p (DFmode, XEXP (operand0, 0)))
3069                || ((GET_CODE (operand0) == SUBREG)
3070                    && GET_CODE (XEXP (operand0, 0)) == MEM
3071                    && !memory_address_p (DFmode, XEXP (XEXP (operand0, 0), 0))))
3072            && scratch_reg)
3073     {
3074       if (GET_CODE (operand0) == SUBREG)
3075         operand0 = XEXP (operand0, 0);
3076
3077       /* SCRATCH_REG will hold an address and maybe the actual data.  We want
3078          it in SIMODE regardless of what mode it was originally given
3079          to us.  */
3080       scratch_reg = force_mode (SImode, scratch_reg);
3081
3082       /* D might not fit in 14 bits either; for such cases load D into
3083          scratch reg.  */
3084       if (!memory_address_p (Pmode, XEXP (operand0, 0)))
3085         {
3086           emit_move_insn (scratch_reg, XEXP (XEXP (operand0, 0), 1));
3087           emit_move_insn (scratch_reg, gen_rtx_fmt_ee (GET_CODE (XEXP (operand0,
3088                                                                         0)),
3089                                                        Pmode,
3090                                                        XEXP (XEXP (operand0, 0),
3091                                                                    0),
3092                                                        scratch_reg));
3093         }
3094       else
3095         emit_move_insn (scratch_reg, XEXP (operand0, 0));
3096       emit_insn (gen_rtx_SET (VOIDmode, gen_rtx_MEM (mode, scratch_reg),
3097                               operand1));
3098       return 1;
3099     }
3100   /* Handle secondary reloads for loads of FP registers from constant
3101      expressions by forcing the constant into memory.
3102
3103      use scratch_reg to hold the address of the memory location.
3104
3105      The proper fix is to change PREFERRED_RELOAD_CLASS to return
3106      NO_REGS when presented with a const_int and an register class
3107      containing only FP registers.  Doing so unfortunately creates
3108      more problems than it solves.   Fix this for 2.5.  */
3109   else if (fp_reg_operand (operand0, mode)
3110            && CONSTANT_P (operand1)
3111            && scratch_reg)
3112     {
3113       rtx xoperands[2];
3114
3115       /* SCRATCH_REG will hold an address and maybe the actual data.  We want
3116          it in SIMODE regardless of what mode it was originally given
3117          to us.  */
3118       scratch_reg = force_mode (SImode, scratch_reg);
3119
3120       /* Force the constant into memory and put the address of the
3121          memory location into scratch_reg.  */
3122       xoperands[0] = scratch_reg;
3123       xoperands[1] = XEXP (force_const_mem (mode, operand1), 0);
3124       emit_insn (gen_rtx_SET (mode, scratch_reg, xoperands[1]));
3125
3126       /* Now load the destination register.  */
3127       emit_insn (gen_rtx_SET (mode, operand0,
3128                               gen_rtx_MEM (mode, scratch_reg)));
3129       return 1;
3130     }
3131
3132   /* Now have insn-emit do whatever it normally does.  */
3133   return 0;
3134 }
3135
3136 /* Split one or more DImode RTL references into pairs of SImode
3137    references.  The RTL can be REG, offsettable MEM, integer constant, or
3138    CONST_DOUBLE.  "operands" is a pointer to an array of DImode RTL to
3139    split and "num" is its length.  lo_half and hi_half are output arrays
3140    that parallel "operands".  */
3141
3142 void
3143 split_di (rtx operands[], int num, rtx lo_half[], rtx hi_half[])
3144 {
3145   while (num--)
3146     {
3147       rtx op = operands[num];
3148
3149       /* simplify_subreg refuses to split volatile memory addresses,
3150          but we still have to handle it.  */
3151       if (GET_CODE (op) == MEM)
3152         {
3153           lo_half[num] = adjust_address (op, SImode, 4);
3154           hi_half[num] = adjust_address (op, SImode, 0);
3155         }
3156       else
3157         {
3158           lo_half[num] = simplify_gen_subreg (SImode, op,
3159                                               GET_MODE (op) == VOIDmode
3160                                               ? DImode : GET_MODE (op), 4);
3161           hi_half[num] = simplify_gen_subreg (SImode, op,
3162                                               GET_MODE (op) == VOIDmode
3163                                               ? DImode : GET_MODE (op), 0);
3164         }
3165     }
3166 }
3167
3168 /* Split X into a base and a constant offset, storing them in *BASE
3169    and *OFFSET respectively.  */
3170
3171 static void
3172 m68k_split_offset (rtx x, rtx *base, HOST_WIDE_INT *offset)
3173 {
3174   *offset = 0;
3175   if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == CONST_INT)
3176     {
3177       *offset += INTVAL (XEXP (x, 1));
3178       x = XEXP (x, 0);
3179     }
3180   *base = x;
3181 }
3182
3183 /* Return true if PATTERN is a PARALLEL suitable for a movem or fmovem
3184    instruction.  STORE_P says whether the move is a load or store.
3185
3186    If the instruction uses post-increment or pre-decrement addressing,
3187    AUTOMOD_BASE is the base register and AUTOMOD_OFFSET is the total
3188    adjustment.  This adjustment will be made by the first element of
3189    PARALLEL, with the loads or stores starting at element 1.  If the
3190    instruction does not use post-increment or pre-decrement addressing,
3191    AUTOMOD_BASE is null, AUTOMOD_OFFSET is 0, and the loads or stores
3192    start at element 0.  */
3193
3194 bool
3195 m68k_movem_pattern_p (rtx pattern, rtx automod_base,
3196                       HOST_WIDE_INT automod_offset, bool store_p)
3197 {
3198   rtx base, mem_base, set, mem, reg, last_reg;
3199   HOST_WIDE_INT offset, mem_offset;
3200   int i, first, len;
3201   enum reg_class rclass;
3202
3203   len = XVECLEN (pattern, 0);
3204   first = (automod_base != NULL);
3205
3206   if (automod_base)
3207     {
3208       /* Stores must be pre-decrement and loads must be post-increment.  */
3209       if (store_p != (automod_offset < 0))
3210         return false;
3211
3212       /* Work out the base and offset for lowest memory location.  */
3213       base = automod_base;
3214       offset = (automod_offset < 0 ? automod_offset : 0);
3215     }
3216   else
3217     {
3218       /* Allow any valid base and offset in the first access.  */
3219       base = NULL;
3220       offset = 0;
3221     }
3222
3223   last_reg = NULL;
3224   rclass = NO_REGS;
3225   for (i = first; i < len; i++)
3226     {
3227       /* We need a plain SET.  */
3228       set = XVECEXP (pattern, 0, i);
3229       if (GET_CODE (set) != SET)
3230         return false;
3231
3232       /* Check that we have a memory location...  */
3233       mem = XEXP (set, !store_p);
3234       if (!MEM_P (mem) || !memory_operand (mem, VOIDmode))
3235         return false;
3236
3237       /* ...with the right address.  */
3238       if (base == NULL)
3239         {
3240           m68k_split_offset (XEXP (mem, 0), &base, &offset);
3241           /* The ColdFire instruction only allows (An) and (d16,An) modes.
3242              There are no mode restrictions for 680x0 besides the
3243              automodification rules enforced above.  */
3244           if (TARGET_COLDFIRE
3245               && !m68k_legitimate_base_reg_p (base, reload_completed))
3246             return false;
3247         }
3248       else
3249         {
3250           m68k_split_offset (XEXP (mem, 0), &mem_base, &mem_offset);
3251           if (!rtx_equal_p (base, mem_base) || offset != mem_offset)
3252             return false;
3253         }
3254
3255       /* Check that we have a register of the required mode and class.  */
3256       reg = XEXP (set, store_p);
3257       if (!REG_P (reg)
3258           || !HARD_REGISTER_P (reg)
3259           || GET_MODE (reg) != reg_raw_mode[REGNO (reg)])
3260         return false;
3261
3262       if (last_reg)
3263         {
3264           /* The register must belong to RCLASS and have a higher number
3265              than the register in the previous SET.  */
3266           if (!TEST_HARD_REG_BIT (reg_class_contents[rclass], REGNO (reg))
3267               || REGNO (last_reg) >= REGNO (reg))
3268             return false;
3269         }
3270       else
3271         {
3272           /* Work out which register class we need.  */
3273           if (INT_REGNO_P (REGNO (reg)))
3274             rclass = GENERAL_REGS;
3275           else if (FP_REGNO_P (REGNO (reg)))
3276             rclass = FP_REGS;
3277           else
3278             return false;
3279         }
3280
3281       last_reg = reg;
3282       offset += GET_MODE_SIZE (GET_MODE (reg));
3283     }
3284
3285   /* If we have an automodification, check whether the final offset is OK.  */
3286   if (automod_base && offset != (automod_offset < 0 ? 0 : automod_offset))
3287     return false;
3288
3289   /* Reject unprofitable cases.  */
3290   if (len < first + (rclass == FP_REGS ? MIN_FMOVEM_REGS : MIN_MOVEM_REGS))
3291     return false;
3292
3293   return true;
3294 }
3295
3296 /* Return the assembly code template for a movem or fmovem instruction
3297    whose pattern is given by PATTERN.  Store the template's operands
3298    in OPERANDS.
3299
3300    If the instruction uses post-increment or pre-decrement addressing,
3301    AUTOMOD_OFFSET is the total adjustment, otherwise it is 0.  STORE_P
3302    is true if this is a store instruction.  */
3303
3304 const char *
3305 m68k_output_movem (rtx *operands, rtx pattern,
3306                    HOST_WIDE_INT automod_offset, bool store_p)
3307 {
3308   unsigned int mask;
3309   int i, first;
3310
3311   gcc_assert (GET_CODE (pattern) == PARALLEL);
3312   mask = 0;
3313   first = (automod_offset != 0);
3314   for (i = first; i < XVECLEN (pattern, 0); i++)
3315     {
3316       /* When using movem with pre-decrement addressing, register X + D0_REG
3317          is controlled by bit 15 - X.  For all other addressing modes,
3318          register X + D0_REG is controlled by bit X.  Confusingly, the
3319          register mask for fmovem is in the opposite order to that for
3320          movem.  */
3321       unsigned int regno;
3322
3323       gcc_assert (MEM_P (XEXP (XVECEXP (pattern, 0, i), !store_p)));
3324       gcc_assert (REG_P (XEXP (XVECEXP (pattern, 0, i), store_p)));
3325       regno = REGNO (XEXP (XVECEXP (pattern, 0, i), store_p));
3326       if (automod_offset < 0)
3327         {
3328           if (FP_REGNO_P (regno))
3329             mask |= 1 << (regno - FP0_REG);
3330           else
3331             mask |= 1 << (15 - (regno - D0_REG));
3332         }
3333       else
3334         {
3335           if (FP_REGNO_P (regno))
3336             mask |= 1 << (7 - (regno - FP0_REG));
3337           else
3338             mask |= 1 << (regno - D0_REG);
3339         }
3340     }
3341   CC_STATUS_INIT;
3342
3343   if (automod_offset == 0)
3344     operands[0] = XEXP (XEXP (XVECEXP (pattern, 0, first), !store_p), 0);
3345   else if (automod_offset < 0)
3346     operands[0] = gen_rtx_PRE_DEC (Pmode, SET_DEST (XVECEXP (pattern, 0, 0)));
3347   else
3348     operands[0] = gen_rtx_POST_INC (Pmode, SET_DEST (XVECEXP (pattern, 0, 0)));
3349   operands[1] = GEN_INT (mask);
3350   if (FP_REGNO_P (REGNO (XEXP (XVECEXP (pattern, 0, first), store_p))))
3351     {
3352       if (store_p)
3353         return "fmovem %1,%a0";
3354       else
3355         return "fmovem %a0,%1";
3356     }
3357   else
3358     {
3359       if (store_p)
3360         return "movem%.l %1,%a0";
3361       else
3362         return "movem%.l %a0,%1";
3363     }
3364 }
3365
3366 /* Return a REG that occurs in ADDR with coefficient 1.
3367    ADDR can be effectively incremented by incrementing REG.  */
3368
3369 static rtx
3370 find_addr_reg (rtx addr)
3371 {
3372   while (GET_CODE (addr) == PLUS)
3373     {
3374       if (GET_CODE (XEXP (addr, 0)) == REG)
3375         addr = XEXP (addr, 0);
3376       else if (GET_CODE (XEXP (addr, 1)) == REG)
3377         addr = XEXP (addr, 1);
3378       else if (CONSTANT_P (XEXP (addr, 0)))
3379         addr = XEXP (addr, 1);
3380       else if (CONSTANT_P (XEXP (addr, 1)))
3381         addr = XEXP (addr, 0);
3382       else
3383         gcc_unreachable ();
3384     }
3385   gcc_assert (GET_CODE (addr) == REG);
3386   return addr;
3387 }
3388
3389 /* Output assembler code to perform a 32-bit 3-operand add.  */
3390
3391 const char *
3392 output_addsi3 (rtx *operands)
3393 {
3394   if (! operands_match_p (operands[0], operands[1]))
3395     {
3396       if (!ADDRESS_REG_P (operands[1]))
3397         {
3398           rtx tmp = operands[1];
3399
3400           operands[1] = operands[2];
3401           operands[2] = tmp;
3402         }
3403
3404       /* These insns can result from reloads to access
3405          stack slots over 64k from the frame pointer.  */
3406       if (GET_CODE (operands[2]) == CONST_INT
3407           && (INTVAL (operands[2]) < -32768 || INTVAL (operands[2]) > 32767))
3408         return "move%.l %2,%0\n\tadd%.l %1,%0";
3409       if (GET_CODE (operands[2]) == REG)
3410         return MOTOROLA ? "lea (%1,%2.l),%0" : "lea %1@(0,%2:l),%0";
3411       return MOTOROLA ? "lea (%c2,%1),%0" : "lea %1@(%c2),%0";
3412     }
3413   if (GET_CODE (operands[2]) == CONST_INT)
3414     {
3415       if (INTVAL (operands[2]) > 0
3416           && INTVAL (operands[2]) <= 8)
3417         return "addq%.l %2,%0";
3418       if (INTVAL (operands[2]) < 0
3419           && INTVAL (operands[2]) >= -8)
3420         {
3421           operands[2] = GEN_INT (- INTVAL (operands[2]));
3422           return "subq%.l %2,%0";
3423         }
3424       /* On the CPU32 it is faster to use two addql instructions to
3425          add a small integer (8 < N <= 16) to a register.
3426          Likewise for subql.  */
3427       if (TUNE_CPU32 && REG_P (operands[0]))
3428         {
3429           if (INTVAL (operands[2]) > 8
3430               && INTVAL (operands[2]) <= 16)
3431             {
3432               operands[2] = GEN_INT (INTVAL (operands[2]) - 8);
3433               return "addq%.l #8,%0\n\taddq%.l %2,%0";
3434             }
3435           if (INTVAL (operands[2]) < -8
3436               && INTVAL (operands[2]) >= -16)
3437             {
3438               operands[2] = GEN_INT (- INTVAL (operands[2]) - 8);
3439               return "subq%.l #8,%0\n\tsubq%.l %2,%0";
3440             }
3441         }
3442       if (ADDRESS_REG_P (operands[0])
3443           && INTVAL (operands[2]) >= -0x8000
3444           && INTVAL (operands[2]) < 0x8000)
3445         {
3446           if (TUNE_68040)
3447             return "add%.w %2,%0";
3448           else
3449             return MOTOROLA ? "lea (%c2,%0),%0" : "lea %0@(%c2),%0";
3450         }
3451     }
3452   return "add%.l %2,%0";
3453 }
3454 \f
3455 /* Store in cc_status the expressions that the condition codes will
3456    describe after execution of an instruction whose pattern is EXP.
3457    Do not alter them if the instruction would not alter the cc's.  */
3458
3459 /* On the 68000, all the insns to store in an address register fail to
3460    set the cc's.  However, in some cases these instructions can make it
3461    possibly invalid to use the saved cc's.  In those cases we clear out
3462    some or all of the saved cc's so they won't be used.  */
3463
3464 void
3465 notice_update_cc (rtx exp, rtx insn)
3466 {
3467   if (GET_CODE (exp) == SET)