OSDN Git Service

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