OSDN Git Service

410882766c7cf78f362cc559ba078752609d8691
[pf3gnuchains/gcc-fork.git] / gcc / config / m32r / m32r.c
1 /* Subroutines used for code generation on the Renesas M32R cpu.
2    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3    2005, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
4
5    This file is part of GCC.
6
7    GCC is free software; you can redistribute it and/or modify it
8    under the terms of the GNU General Public License as published
9    by the Free Software Foundation; either version 3, or (at your
10    option) any later version.
11
12    GCC is distributed in the hope that it will be useful, but WITHOUT
13    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
15    License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with GCC; see the file COPYING3.  If not see
19    <http://www.gnu.org/licenses/>.  */
20
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "tm.h"
25 #include "tree.h"
26 #include "rtl.h"
27 #include "regs.h"
28 #include "hard-reg-set.h"
29 #include "insn-config.h"
30 #include "conditions.h"
31 #include "output.h"
32 #include "insn-attr.h"
33 #include "flags.h"
34 #include "expr.h"
35 #include "function.h"
36 #include "recog.h"
37 #include "diagnostic-core.h"
38 #include "ggc.h"
39 #include "integrate.h"
40 #include "df.h"
41 #include "tm_p.h"
42 #include "target.h"
43 #include "target-def.h"
44 #include "tm-constrs.h"
45
46 /* Array of valid operand punctuation characters.  */
47 static char m32r_punct_chars[256];
48
49 /* Selected code model.  */
50 enum m32r_model m32r_model = M32R_MODEL_DEFAULT;
51
52 /* Selected SDA support.  */
53 enum m32r_sdata m32r_sdata = M32R_SDATA_DEFAULT;
54
55 /* Machine-specific symbol_ref flags.  */
56 #define SYMBOL_FLAG_MODEL_SHIFT         SYMBOL_FLAG_MACH_DEP_SHIFT
57 #define SYMBOL_REF_MODEL(X) \
58   ((enum m32r_model) ((SYMBOL_REF_FLAGS (X) >> SYMBOL_FLAG_MODEL_SHIFT) & 3))
59
60 /* For string literals, etc.  */
61 #define LIT_NAME_P(NAME) ((NAME)[0] == '*' && (NAME)[1] == '.')
62
63 /* Forward declaration.  */
64 static bool  m32r_handle_option (size_t, const char *, int);
65 static void  m32r_option_override (void);
66 static void  init_reg_tables (void);
67 static void  block_move_call (rtx, rtx, rtx);
68 static int   m32r_is_insn (rtx);
69 static rtx   m32r_legitimize_address (rtx, rtx, enum machine_mode);
70 static bool  m32r_mode_dependent_address_p (const_rtx);
71 static tree  m32r_handle_model_attribute (tree *, tree, tree, int, bool *);
72 static void  m32r_print_operand (FILE *, rtx, int);
73 static void  m32r_print_operand_address (FILE *, rtx);
74 static bool  m32r_print_operand_punct_valid_p (unsigned char code);
75 static void  m32r_output_function_prologue (FILE *, HOST_WIDE_INT);
76 static void  m32r_output_function_epilogue (FILE *, HOST_WIDE_INT);
77
78 static void  m32r_file_start (void);
79
80 static int    m32r_adjust_priority (rtx, int);
81 static int    m32r_issue_rate (void);
82
83 static void m32r_encode_section_info (tree, rtx, int);
84 static bool m32r_in_small_data_p (const_tree);
85 static bool m32r_return_in_memory (const_tree, const_tree);
86 static rtx m32r_function_value (const_tree, const_tree, bool);
87 static rtx m32r_libcall_value (enum machine_mode, const_rtx);
88 static bool m32r_function_value_regno_p (const unsigned int);
89 static void m32r_setup_incoming_varargs (CUMULATIVE_ARGS *, enum machine_mode,
90                                          tree, int *, int);
91 static void init_idents (void);
92 static bool m32r_rtx_costs (rtx, int, int, int *, bool speed);
93 static int m32r_memory_move_cost (enum machine_mode, reg_class_t, bool);
94 static bool m32r_pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode,
95                                     const_tree, bool);
96 static int m32r_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode,
97                                    tree, bool);
98 static rtx m32r_function_arg (CUMULATIVE_ARGS *, enum machine_mode,
99                               const_tree, bool);
100 static void m32r_function_arg_advance (CUMULATIVE_ARGS *, enum machine_mode,
101                                        const_tree, bool);
102 static bool m32r_can_eliminate (const int, const int);
103 static void m32r_conditional_register_usage (void);
104 static void m32r_trampoline_init (rtx, tree, rtx);
105 \f
106 /* M32R specific attributes.  */
107
108 static const struct attribute_spec m32r_attribute_table[] =
109 {
110   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
111   { "interrupt", 0, 0, true,  false, false, NULL },
112   { "model",     1, 1, true,  false, false, m32r_handle_model_attribute },
113   { NULL,        0, 0, false, false, false, NULL }
114 };
115
116 static const struct default_options m32r_option_optimization_table[] =
117   {
118     { OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
119     { OPT_LEVELS_1_PLUS, OPT_fregmove, NULL, 1 },
120     { OPT_LEVELS_NONE, 0, NULL, 0 }
121   };
122 \f
123 /* Initialize the GCC target structure.  */
124 #undef  TARGET_ATTRIBUTE_TABLE
125 #define TARGET_ATTRIBUTE_TABLE m32r_attribute_table
126
127 #undef TARGET_LEGITIMIZE_ADDRESS
128 #define TARGET_LEGITIMIZE_ADDRESS m32r_legitimize_address
129 #undef TARGET_MODE_DEPENDENT_ADDRESS_P
130 #define TARGET_MODE_DEPENDENT_ADDRESS_P m32r_mode_dependent_address_p
131
132 #undef  TARGET_ASM_ALIGNED_HI_OP
133 #define TARGET_ASM_ALIGNED_HI_OP "\t.hword\t"
134 #undef  TARGET_ASM_ALIGNED_SI_OP
135 #define TARGET_ASM_ALIGNED_SI_OP "\t.word\t"
136
137 #undef  TARGET_PRINT_OPERAND
138 #define TARGET_PRINT_OPERAND m32r_print_operand
139 #undef  TARGET_PRINT_OPERAND_ADDRESS
140 #define TARGET_PRINT_OPERAND_ADDRESS m32r_print_operand_address
141 #undef  TARGET_PRINT_OPERAND_PUNCT_VALID_P
142 #define TARGET_PRINT_OPERAND_PUNCT_VALID_P m32r_print_operand_punct_valid_p
143
144 #undef  TARGET_ASM_FUNCTION_PROLOGUE
145 #define TARGET_ASM_FUNCTION_PROLOGUE m32r_output_function_prologue
146 #undef  TARGET_ASM_FUNCTION_EPILOGUE
147 #define TARGET_ASM_FUNCTION_EPILOGUE m32r_output_function_epilogue
148
149 #undef  TARGET_ASM_FILE_START
150 #define TARGET_ASM_FILE_START m32r_file_start
151
152 #undef  TARGET_SCHED_ADJUST_PRIORITY
153 #define TARGET_SCHED_ADJUST_PRIORITY m32r_adjust_priority
154 #undef  TARGET_SCHED_ISSUE_RATE
155 #define TARGET_SCHED_ISSUE_RATE m32r_issue_rate
156
157 #undef  TARGET_DEFAULT_TARGET_FLAGS
158 #define TARGET_DEFAULT_TARGET_FLAGS TARGET_CPU_DEFAULT
159 #undef  TARGET_HANDLE_OPTION
160 #define TARGET_HANDLE_OPTION m32r_handle_option
161 #undef  TARGET_OPTION_OVERRIDE
162 #define TARGET_OPTION_OVERRIDE m32r_option_override
163 #undef  TARGET_OPTION_OPTIMIZATION_TABLE
164 #define TARGET_OPTION_OPTIMIZATION_TABLE m32r_option_optimization_table
165
166 #undef  TARGET_ENCODE_SECTION_INFO
167 #define TARGET_ENCODE_SECTION_INFO m32r_encode_section_info
168 #undef  TARGET_IN_SMALL_DATA_P
169 #define TARGET_IN_SMALL_DATA_P m32r_in_small_data_p
170
171
172 #undef  TARGET_MEMORY_MOVE_COST
173 #define TARGET_MEMORY_MOVE_COST m32r_memory_move_cost
174 #undef  TARGET_RTX_COSTS
175 #define TARGET_RTX_COSTS m32r_rtx_costs
176 #undef  TARGET_ADDRESS_COST
177 #define TARGET_ADDRESS_COST hook_int_rtx_bool_0
178
179 #undef  TARGET_PROMOTE_PROTOTYPES
180 #define TARGET_PROMOTE_PROTOTYPES hook_bool_const_tree_true
181 #undef  TARGET_RETURN_IN_MEMORY
182 #define TARGET_RETURN_IN_MEMORY m32r_return_in_memory
183
184 #undef TARGET_FUNCTION_VALUE
185 #define TARGET_FUNCTION_VALUE m32r_function_value
186 #undef TARGET_LIBCALL_VALUE
187 #define TARGET_LIBCALL_VALUE m32r_libcall_value
188 #undef TARGET_FUNCTION_VALUE_REGNO_P
189 #define TARGET_FUNCTION_VALUE_REGNO_P m32r_function_value_regno_p
190
191 #undef  TARGET_SETUP_INCOMING_VARARGS
192 #define TARGET_SETUP_INCOMING_VARARGS m32r_setup_incoming_varargs
193 #undef  TARGET_MUST_PASS_IN_STACK
194 #define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size
195 #undef  TARGET_PASS_BY_REFERENCE
196 #define TARGET_PASS_BY_REFERENCE m32r_pass_by_reference
197 #undef  TARGET_ARG_PARTIAL_BYTES
198 #define TARGET_ARG_PARTIAL_BYTES m32r_arg_partial_bytes
199 #undef  TARGET_FUNCTION_ARG
200 #define TARGET_FUNCTION_ARG m32r_function_arg
201 #undef  TARGET_FUNCTION_ARG_ADVANCE
202 #define TARGET_FUNCTION_ARG_ADVANCE m32r_function_arg_advance
203
204 #undef TARGET_CAN_ELIMINATE
205 #define TARGET_CAN_ELIMINATE m32r_can_eliminate
206
207 #undef TARGET_CONDITIONAL_REGISTER_USAGE
208 #define TARGET_CONDITIONAL_REGISTER_USAGE m32r_conditional_register_usage
209
210 #undef TARGET_TRAMPOLINE_INIT
211 #define TARGET_TRAMPOLINE_INIT m32r_trampoline_init
212
213 struct gcc_target targetm = TARGET_INITIALIZER;
214 \f
215 /* Implement TARGET_HANDLE_OPTION.  */
216
217 static bool
218 m32r_handle_option (size_t code, const char *arg, int value)
219 {
220   switch (code)
221     {
222     case OPT_m32r:
223       target_flags &= ~(MASK_M32R2 | MASK_M32RX);
224       return true;
225
226     case OPT_mmodel_:
227       if (strcmp (arg, "small") == 0)
228         m32r_model = M32R_MODEL_SMALL;
229       else if (strcmp (arg, "medium") == 0)
230         m32r_model = M32R_MODEL_MEDIUM;
231       else if (strcmp (arg, "large") == 0)
232         m32r_model = M32R_MODEL_LARGE;
233       else
234         return false;
235       return true;
236
237     case OPT_msdata_:
238       if (strcmp (arg, "none") == 0)
239         m32r_sdata = M32R_SDATA_NONE;
240       else if (strcmp (arg, "sdata") == 0)
241         m32r_sdata = M32R_SDATA_SDATA;
242       else if (strcmp (arg, "use") == 0)
243         m32r_sdata = M32R_SDATA_USE;
244       else
245         return false;
246       return true;
247
248     case OPT_mno_flush_func:
249       m32r_cache_flush_func = NULL;
250       return true;
251
252     case OPT_mflush_trap_:
253       return value <= 15;
254
255     case OPT_mno_flush_trap:
256       m32r_cache_flush_trap = -1;
257       return true;
258
259     default:
260       return true;
261     }
262 }
263
264 /* Called by m32r_option_override to initialize various things.  */
265
266 void
267 m32r_init (void)
268 {
269   init_reg_tables ();
270
271   /* Initialize array for TARGET_PRINT_OPERAND_PUNCT_VALID_P.  */
272   memset (m32r_punct_chars, 0, sizeof (m32r_punct_chars));
273   m32r_punct_chars['#'] = 1;
274   m32r_punct_chars['@'] = 1; /* ??? no longer used */
275
276   /* Provide default value if not specified.  */
277   if (!global_options_set.x_g_switch_value)
278     g_switch_value = SDATA_DEFAULT_SIZE;
279 }
280
281 static void
282 m32r_option_override (void)
283 {
284   /* These need to be done at start up.
285      It's convenient to do them here.  */
286   m32r_init ();
287   SUBTARGET_OVERRIDE_OPTIONS;
288 }
289
290 /* Vectors to keep interesting information about registers where it can easily
291    be got.  We use to use the actual mode value as the bit number, but there
292    is (or may be) more than 32 modes now.  Instead we use two tables: one
293    indexed by hard register number, and one indexed by mode.  */
294
295 /* The purpose of m32r_mode_class is to shrink the range of modes so that
296    they all fit (as bit numbers) in a 32-bit word (again).  Each real mode is
297    mapped into one m32r_mode_class mode.  */
298
299 enum m32r_mode_class
300 {
301   C_MODE,
302   S_MODE, D_MODE, T_MODE, O_MODE,
303   SF_MODE, DF_MODE, TF_MODE, OF_MODE, A_MODE
304 };
305
306 /* Modes for condition codes.  */
307 #define C_MODES (1 << (int) C_MODE)
308
309 /* Modes for single-word and smaller quantities.  */
310 #define S_MODES ((1 << (int) S_MODE) | (1 << (int) SF_MODE))
311
312 /* Modes for double-word and smaller quantities.  */
313 #define D_MODES (S_MODES | (1 << (int) D_MODE) | (1 << DF_MODE))
314
315 /* Modes for quad-word and smaller quantities.  */
316 #define T_MODES (D_MODES | (1 << (int) T_MODE) | (1 << (int) TF_MODE))
317
318 /* Modes for accumulators.  */
319 #define A_MODES (1 << (int) A_MODE)
320
321 /* Value is 1 if register/mode pair is acceptable on arc.  */
322
323 const unsigned int m32r_hard_regno_mode_ok[FIRST_PSEUDO_REGISTER] =
324 {
325   T_MODES, T_MODES, T_MODES, T_MODES, T_MODES, T_MODES, T_MODES, T_MODES,
326   T_MODES, T_MODES, T_MODES, T_MODES, T_MODES, S_MODES, S_MODES, S_MODES,
327   S_MODES, C_MODES, A_MODES, A_MODES
328 };
329
330 unsigned int m32r_mode_class [NUM_MACHINE_MODES];
331
332 enum reg_class m32r_regno_reg_class[FIRST_PSEUDO_REGISTER];
333
334 static void
335 init_reg_tables (void)
336 {
337   int i;
338
339   for (i = 0; i < NUM_MACHINE_MODES; i++)
340     {
341       switch (GET_MODE_CLASS (i))
342         {
343         case MODE_INT:
344         case MODE_PARTIAL_INT:
345         case MODE_COMPLEX_INT:
346           if (GET_MODE_SIZE (i) <= 4)
347             m32r_mode_class[i] = 1 << (int) S_MODE;
348           else if (GET_MODE_SIZE (i) == 8)
349             m32r_mode_class[i] = 1 << (int) D_MODE;
350           else if (GET_MODE_SIZE (i) == 16)
351             m32r_mode_class[i] = 1 << (int) T_MODE;
352           else if (GET_MODE_SIZE (i) == 32)
353             m32r_mode_class[i] = 1 << (int) O_MODE;
354           else
355             m32r_mode_class[i] = 0;
356           break;
357         case MODE_FLOAT:
358         case MODE_COMPLEX_FLOAT:
359           if (GET_MODE_SIZE (i) <= 4)
360             m32r_mode_class[i] = 1 << (int) SF_MODE;
361           else if (GET_MODE_SIZE (i) == 8)
362             m32r_mode_class[i] = 1 << (int) DF_MODE;
363           else if (GET_MODE_SIZE (i) == 16)
364             m32r_mode_class[i] = 1 << (int) TF_MODE;
365           else if (GET_MODE_SIZE (i) == 32)
366             m32r_mode_class[i] = 1 << (int) OF_MODE;
367           else
368             m32r_mode_class[i] = 0;
369           break;
370         case MODE_CC:
371           m32r_mode_class[i] = 1 << (int) C_MODE;
372           break;
373         default:
374           m32r_mode_class[i] = 0;
375           break;
376         }
377     }
378
379   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
380     {
381       if (GPR_P (i))
382         m32r_regno_reg_class[i] = GENERAL_REGS;
383       else if (i == ARG_POINTER_REGNUM)
384         m32r_regno_reg_class[i] = GENERAL_REGS;
385       else
386         m32r_regno_reg_class[i] = NO_REGS;
387     }
388 }
389 \f
390 /* M32R specific attribute support.
391
392    interrupt - for interrupt functions
393
394    model - select code model used to access object
395
396         small: addresses use 24 bits, use bl to make calls
397         medium: addresses use 32 bits, use bl to make calls
398         large: addresses use 32 bits, use seth/add3/jl to make calls
399
400         Grep for MODEL in m32r.h for more info.  */
401
402 static tree small_ident1;
403 static tree small_ident2;
404 static tree medium_ident1;
405 static tree medium_ident2;
406 static tree large_ident1;
407 static tree large_ident2;
408
409 static void
410 init_idents (void)
411 {
412   if (small_ident1 == 0)
413     {
414       small_ident1 = get_identifier ("small");
415       small_ident2 = get_identifier ("__small__");
416       medium_ident1 = get_identifier ("medium");
417       medium_ident2 = get_identifier ("__medium__");
418       large_ident1 = get_identifier ("large");
419       large_ident2 = get_identifier ("__large__");
420     }
421 }
422
423 /* Handle an "model" attribute; arguments as in
424    struct attribute_spec.handler.  */
425 static tree
426 m32r_handle_model_attribute (tree *node ATTRIBUTE_UNUSED, tree name,
427                              tree args, int flags ATTRIBUTE_UNUSED,
428                              bool *no_add_attrs)
429 {
430   tree arg;
431
432   init_idents ();
433   arg = TREE_VALUE (args);
434
435   if (arg != small_ident1
436       && arg != small_ident2
437       && arg != medium_ident1
438       && arg != medium_ident2
439       && arg != large_ident1
440       && arg != large_ident2)
441     {
442       warning (OPT_Wattributes, "invalid argument of %qs attribute",
443                IDENTIFIER_POINTER (name));
444       *no_add_attrs = true;
445     }
446
447   return NULL_TREE;
448 }
449 \f
450 /* Encode section information of DECL, which is either a VAR_DECL,
451    FUNCTION_DECL, STRING_CST, CONSTRUCTOR, or ???.
452
453    For the M32R we want to record:
454
455    - whether the object lives in .sdata/.sbss.
456    - what code model should be used to access the object
457 */
458
459 static void
460 m32r_encode_section_info (tree decl, rtx rtl, int first)
461 {
462   int extra_flags = 0;
463   tree model_attr;
464   enum m32r_model model;
465
466   default_encode_section_info (decl, rtl, first);
467
468   if (!DECL_P (decl))
469     return;
470
471   model_attr = lookup_attribute ("model", DECL_ATTRIBUTES (decl));
472   if (model_attr)
473     {
474       tree id;
475
476       init_idents ();
477
478       id = TREE_VALUE (TREE_VALUE (model_attr));
479
480       if (id == small_ident1 || id == small_ident2)
481         model = M32R_MODEL_SMALL;
482       else if (id == medium_ident1 || id == medium_ident2)
483         model = M32R_MODEL_MEDIUM;
484       else if (id == large_ident1 || id == large_ident2)
485         model = M32R_MODEL_LARGE;
486       else
487         gcc_unreachable (); /* shouldn't happen */
488     }
489   else
490     {
491       if (TARGET_MODEL_SMALL)
492         model = M32R_MODEL_SMALL;
493       else if (TARGET_MODEL_MEDIUM)
494         model = M32R_MODEL_MEDIUM;
495       else if (TARGET_MODEL_LARGE)
496         model = M32R_MODEL_LARGE;
497       else
498         gcc_unreachable (); /* shouldn't happen */
499     }
500   extra_flags |= model << SYMBOL_FLAG_MODEL_SHIFT;
501
502   if (extra_flags)
503     SYMBOL_REF_FLAGS (XEXP (rtl, 0)) |= extra_flags;
504 }
505
506 /* Only mark the object as being small data area addressable if
507    it hasn't been explicitly marked with a code model.
508
509    The user can explicitly put an object in the small data area with the
510    section attribute.  If the object is in sdata/sbss and marked with a
511    code model do both [put the object in .sdata and mark it as being
512    addressed with a specific code model - don't mark it as being addressed
513    with an SDA reloc though].  This is ok and might be useful at times.  If
514    the object doesn't fit the linker will give an error.  */
515
516 static bool
517 m32r_in_small_data_p (const_tree decl)
518 {
519   const_tree section;
520
521   if (TREE_CODE (decl) != VAR_DECL)
522     return false;
523
524   if (lookup_attribute ("model", DECL_ATTRIBUTES (decl)))
525     return false;
526
527   section = DECL_SECTION_NAME (decl);
528   if (section)
529     {
530       const char *const name = TREE_STRING_POINTER (section);
531       if (strcmp (name, ".sdata") == 0 || strcmp (name, ".sbss") == 0)
532         return true;
533     }
534   else
535     {
536       if (! TREE_READONLY (decl) && ! TARGET_SDATA_NONE)
537         {
538           int size = int_size_in_bytes (TREE_TYPE (decl));
539
540           if (size > 0 && size <= g_switch_value)
541             return true;
542         }
543     }
544
545   return false;
546 }
547
548 /* Do anything needed before RTL is emitted for each function.  */
549
550 void
551 m32r_init_expanders (void)
552 {
553   /* ??? At one point there was code here.  The function is left in
554      to make it easy to experiment.  */
555 }
556 \f
557 int
558 call_operand (rtx op, enum machine_mode mode)
559 {
560   if (!MEM_P (op))
561     return 0;
562   op = XEXP (op, 0);
563   return call_address_operand (op, mode);
564 }
565
566 /* Return 1 if OP is a reference to an object in .sdata/.sbss.  */
567
568 int
569 small_data_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
570 {
571   if (! TARGET_SDATA_USE)
572     return 0;
573
574   if (GET_CODE (op) == SYMBOL_REF)
575     return SYMBOL_REF_SMALL_P (op);
576
577   if (GET_CODE (op) == CONST
578       && GET_CODE (XEXP (op, 0)) == PLUS
579       && GET_CODE (XEXP (XEXP (op, 0), 0)) == SYMBOL_REF
580       && satisfies_constraint_J (XEXP (XEXP (op, 0), 1)))
581     return SYMBOL_REF_SMALL_P (XEXP (XEXP (op, 0), 0));
582
583   return 0;
584 }
585
586 /* Return 1 if OP is a symbol that can use 24-bit addressing.  */
587
588 int
589 addr24_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
590 {
591   rtx sym;
592
593   if (flag_pic)
594     return 0;
595
596   if (GET_CODE (op) == LABEL_REF)
597     return TARGET_ADDR24;
598
599   if (GET_CODE (op) == SYMBOL_REF)
600     sym = op;
601   else if (GET_CODE (op) == CONST
602            && GET_CODE (XEXP (op, 0)) == PLUS
603            && GET_CODE (XEXP (XEXP (op, 0), 0)) == SYMBOL_REF
604            && satisfies_constraint_M (XEXP (XEXP (op, 0), 1)))
605     sym = XEXP (XEXP (op, 0), 0);
606   else
607     return 0;
608
609   if (SYMBOL_REF_MODEL (sym) == M32R_MODEL_SMALL)
610     return 1;
611
612   if (TARGET_ADDR24
613       && (CONSTANT_POOL_ADDRESS_P (sym)
614           || LIT_NAME_P (XSTR (sym, 0))))
615     return 1;
616
617   return 0;
618 }
619
620 /* Return 1 if OP is a symbol that needs 32-bit addressing.  */
621
622 int
623 addr32_operand (rtx op, enum machine_mode mode)
624 {
625   rtx sym;
626
627   if (GET_CODE (op) == LABEL_REF)
628     return TARGET_ADDR32;
629
630   if (GET_CODE (op) == SYMBOL_REF)
631     sym = op;
632   else if (GET_CODE (op) == CONST
633            && GET_CODE (XEXP (op, 0)) == PLUS
634            && GET_CODE (XEXP (XEXP (op, 0), 0)) == SYMBOL_REF
635            && CONST_INT_P (XEXP (XEXP (op, 0), 1))
636            && ! flag_pic)
637     sym = XEXP (XEXP (op, 0), 0);
638   else
639     return 0;
640
641   return (! addr24_operand (sym, mode)
642           && ! small_data_operand (sym, mode));
643 }
644
645 /* Return 1 if OP is a function that can be called with the `bl' insn.  */
646
647 int
648 call26_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
649 {
650   if (flag_pic)
651     return 1;
652
653   if (GET_CODE (op) == SYMBOL_REF)
654     return SYMBOL_REF_MODEL (op) != M32R_MODEL_LARGE;
655
656   return TARGET_CALL26;
657 }
658
659 /* Return 1 if OP is a DImode const we want to handle inline.
660    This must match the code in the movdi pattern.
661    It is used by the 'G' CONST_DOUBLE_OK_FOR_LETTER.  */
662
663 int
664 easy_di_const (rtx op)
665 {
666   rtx high_rtx, low_rtx;
667   HOST_WIDE_INT high, low;
668
669   split_double (op, &high_rtx, &low_rtx);
670   high = INTVAL (high_rtx);
671   low = INTVAL (low_rtx);
672   /* Pick constants loadable with 2 16-bit `ldi' insns.  */
673   if (high >= -128 && high <= 127
674       && low >= -128 && low <= 127)
675     return 1;
676   return 0;
677 }
678
679 /* Return 1 if OP is a DFmode const we want to handle inline.
680    This must match the code in the movdf pattern.
681    It is used by the 'H' CONST_DOUBLE_OK_FOR_LETTER.  */
682
683 int
684 easy_df_const (rtx op)
685 {
686   REAL_VALUE_TYPE r;
687   long l[2];
688
689   REAL_VALUE_FROM_CONST_DOUBLE (r, op);
690   REAL_VALUE_TO_TARGET_DOUBLE (r, l);
691   if (l[0] == 0 && l[1] == 0)
692     return 1;
693   if ((l[0] & 0xffff) == 0 && l[1] == 0)
694     return 1;
695   return 0;
696 }
697
698 /* Return 1 if OP is (mem (reg ...)).
699    This is used in insn length calcs.  */
700
701 int
702 memreg_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
703 {
704   return MEM_P (op) && REG_P (XEXP (op, 0));
705 }
706
707 /* Return nonzero if TYPE must be passed by indirect reference.  */
708
709 static bool
710 m32r_pass_by_reference (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
711                         enum machine_mode mode, const_tree type,
712                         bool named ATTRIBUTE_UNUSED)
713 {
714   int size;
715
716   if (type)
717     size = int_size_in_bytes (type);
718   else
719     size = GET_MODE_SIZE (mode);
720
721   return (size < 0 || size > 8);
722 }
723 \f
724 /* Comparisons.  */
725
726 /* X and Y are two things to compare using CODE.  Emit the compare insn and
727    return the rtx for compare [arg0 of the if_then_else].
728    If need_compare is true then the comparison insn must be generated, rather
729    than being subsumed into the following branch instruction.  */
730
731 rtx
732 gen_compare (enum rtx_code code, rtx x, rtx y, int need_compare)
733 {
734   enum rtx_code compare_code;
735   enum rtx_code branch_code;
736   rtx cc_reg = gen_rtx_REG (CCmode, CARRY_REGNUM);
737   int must_swap = 0;
738
739   switch (code)
740     {
741     case EQ:  compare_code = EQ;  branch_code = NE; break;
742     case NE:  compare_code = EQ;  branch_code = EQ; break;
743     case LT:  compare_code = LT;  branch_code = NE; break;
744     case LE:  compare_code = LT;  branch_code = EQ; must_swap = 1; break;
745     case GT:  compare_code = LT;  branch_code = NE; must_swap = 1; break;
746     case GE:  compare_code = LT;  branch_code = EQ; break;
747     case LTU: compare_code = LTU; branch_code = NE; break;
748     case LEU: compare_code = LTU; branch_code = EQ; must_swap = 1; break;
749     case GTU: compare_code = LTU; branch_code = NE; must_swap = 1; break;
750     case GEU: compare_code = LTU; branch_code = EQ; break;
751
752     default:
753       gcc_unreachable ();
754     }
755
756   if (need_compare)
757     {
758       switch (compare_code)
759         {
760         case EQ:
761           if (satisfies_constraint_P (y)                /* Reg equal to small const.  */
762               && y != const0_rtx)
763             {
764               rtx tmp = gen_reg_rtx (SImode);
765
766               emit_insn (gen_addsi3 (tmp, x, GEN_INT (-INTVAL (y))));
767               x = tmp;
768               y = const0_rtx;
769             }
770           else if (CONSTANT_P (y))                      /* Reg equal to const.  */
771             {
772               rtx tmp = force_reg (GET_MODE (x), y);
773               y = tmp;
774             }
775
776           if (register_operand (y, SImode)              /* Reg equal to reg.  */
777               || y == const0_rtx)                       /* Reg equal to zero.  */
778             {
779               emit_insn (gen_cmp_eqsi_insn (x, y));
780
781               return gen_rtx_fmt_ee (code, CCmode, cc_reg, const0_rtx);
782             }
783           break;
784
785         case LT:
786           if (register_operand (y, SImode)
787               || satisfies_constraint_P (y))
788             {
789               rtx tmp = gen_reg_rtx (SImode);         /* Reg compared to reg.  */
790
791               switch (code)
792                 {
793                 case LT:
794                   emit_insn (gen_cmp_ltsi_insn (x, y));
795                   code = EQ;
796                   break;
797                 case LE:
798                   if (y == const0_rtx)
799                     tmp = const1_rtx;
800                   else
801                     emit_insn (gen_addsi3 (tmp, y, constm1_rtx));
802                   emit_insn (gen_cmp_ltsi_insn (x, tmp));
803                   code = EQ;
804                   break;
805                 case GT:
806                   if (CONST_INT_P (y))
807                     tmp = gen_rtx_PLUS (SImode, y, const1_rtx);
808                   else
809                     emit_insn (gen_addsi3 (tmp, y, constm1_rtx));
810                   emit_insn (gen_cmp_ltsi_insn (x, tmp));
811                   code = NE;
812                   break;
813                 case GE:
814                   emit_insn (gen_cmp_ltsi_insn (x, y));
815                   code = NE;
816                   break;
817                 default:
818                   gcc_unreachable ();
819                 }
820
821               return gen_rtx_fmt_ee (code, CCmode, cc_reg, const0_rtx);
822             }
823           break;
824
825         case LTU:
826           if (register_operand (y, SImode)
827               || satisfies_constraint_P (y))
828             {
829               rtx tmp = gen_reg_rtx (SImode);         /* Reg (unsigned) compared to reg.  */
830
831               switch (code)
832                 {
833                 case LTU:
834                   emit_insn (gen_cmp_ltusi_insn (x, y));
835                   code = EQ;
836                   break;
837                 case LEU:
838                   if (y == const0_rtx)
839                     tmp = const1_rtx;
840                   else
841                     emit_insn (gen_addsi3 (tmp, y, constm1_rtx));
842                   emit_insn (gen_cmp_ltusi_insn (x, tmp));
843                   code = EQ;
844                   break;
845                 case GTU:
846                   if (CONST_INT_P (y))
847                     tmp = gen_rtx_PLUS (SImode, y, const1_rtx);
848                   else
849                     emit_insn (gen_addsi3 (tmp, y, constm1_rtx));
850                   emit_insn (gen_cmp_ltusi_insn (x, tmp));
851                   code = NE;
852                   break;
853                 case GEU:
854                   emit_insn (gen_cmp_ltusi_insn (x, y));
855                   code = NE;
856                   break;
857                 default:
858                   gcc_unreachable ();
859                 }
860
861               return gen_rtx_fmt_ee (code, CCmode, cc_reg, const0_rtx);
862             }
863           break;
864
865         default:
866           gcc_unreachable ();
867         }
868     }
869   else
870     {
871       /* Reg/reg equal comparison.  */
872       if (compare_code == EQ
873           && register_operand (y, SImode))
874         return gen_rtx_fmt_ee (code, CCmode, x, y);
875
876       /* Reg/zero signed comparison.  */
877       if ((compare_code == EQ || compare_code == LT)
878           && y == const0_rtx)
879         return gen_rtx_fmt_ee (code, CCmode, x, y);
880
881       /* Reg/smallconst equal comparison.  */
882       if (compare_code == EQ
883           && satisfies_constraint_P (y))
884         {
885           rtx tmp = gen_reg_rtx (SImode);
886
887           emit_insn (gen_addsi3 (tmp, x, GEN_INT (-INTVAL (y))));
888           return gen_rtx_fmt_ee (code, CCmode, tmp, const0_rtx);
889         }
890
891       /* Reg/const equal comparison.  */
892       if (compare_code == EQ
893           && CONSTANT_P (y))
894         {
895           rtx tmp = force_reg (GET_MODE (x), y);
896
897           return gen_rtx_fmt_ee (code, CCmode, x, tmp);
898         }
899     }
900
901   if (CONSTANT_P (y))
902     {
903       if (must_swap)
904         y = force_reg (GET_MODE (x), y);
905       else
906         {
907           int ok_const = reg_or_int16_operand (y, GET_MODE (y));
908
909           if (! ok_const)
910             y = force_reg (GET_MODE (x), y);
911         }
912     }
913
914   switch (compare_code)
915     {
916     case EQ :
917       emit_insn (gen_cmp_eqsi_insn (must_swap ? y : x, must_swap ? x : y));
918       break;
919     case LT :
920       emit_insn (gen_cmp_ltsi_insn (must_swap ? y : x, must_swap ? x : y));
921       break;
922     case LTU :
923       emit_insn (gen_cmp_ltusi_insn (must_swap ? y : x, must_swap ? x : y));
924       break;
925
926     default:
927       gcc_unreachable ();
928     }
929
930   return gen_rtx_fmt_ee (branch_code, VOIDmode, cc_reg, CONST0_RTX (CCmode));
931 }
932
933 bool
934 gen_cond_store (enum rtx_code code, rtx op0, rtx op1, rtx op2)
935 {
936   enum machine_mode mode = GET_MODE (op0);
937
938   gcc_assert (mode == SImode);
939   switch (code)
940     {
941     case EQ:
942       if (!register_operand (op1, mode))
943         op1 = force_reg (mode, op1);
944
945       if (TARGET_M32RX || TARGET_M32R2)
946         {
947           if (!reg_or_zero_operand (op2, mode))
948             op2 = force_reg (mode, op2);
949
950           emit_insn (gen_seq_insn_m32rx (op0, op1, op2));
951           return true;
952         }
953       if (CONST_INT_P (op2) && INTVAL (op2) == 0)
954         {
955           emit_insn (gen_seq_zero_insn (op0, op1));
956           return true;
957         }
958
959       if (!reg_or_eq_int16_operand (op2, mode))
960         op2 = force_reg (mode, op2);
961
962       emit_insn (gen_seq_insn (op0, op1, op2));
963       return true;
964
965     case NE:
966       if (!CONST_INT_P (op2)
967           || (INTVAL (op2) != 0 && satisfies_constraint_K (op2)))
968         {
969           rtx reg;
970
971           if (reload_completed || reload_in_progress)
972             return false;
973
974           reg = gen_reg_rtx (SImode);
975           emit_insn (gen_xorsi3 (reg, op1, op2));
976           op1 = reg;
977
978           if (!register_operand (op1, mode))
979             op1 = force_reg (mode, op1);
980
981           emit_insn (gen_sne_zero_insn (op0, op1));
982           return true;
983         }
984       return false;
985
986     case LT:
987     case GT:
988       if (code == GT)
989         {
990           rtx tmp = op2;
991           op2 = op1;
992           op1 = tmp;
993           code = LT;
994         }
995
996       if (!register_operand (op1, mode))
997         op1 = force_reg (mode, op1);
998
999       if (!reg_or_int16_operand (op2, mode))
1000         op2 = force_reg (mode, op2);
1001
1002       emit_insn (gen_slt_insn (op0, op1, op2));
1003       return true;
1004
1005     case LTU:
1006     case GTU:
1007       if (code == GTU)
1008         {
1009           rtx tmp = op2;
1010           op2 = op1;
1011           op1 = tmp;
1012           code = LTU;
1013         }
1014
1015       if (!register_operand (op1, mode))
1016         op1 = force_reg (mode, op1);
1017
1018       if (!reg_or_int16_operand (op2, mode))
1019         op2 = force_reg (mode, op2);
1020
1021       emit_insn (gen_sltu_insn (op0, op1, op2));
1022       return true;
1023
1024     case GE:
1025     case GEU:
1026       if (!register_operand (op1, mode))
1027         op1 = force_reg (mode, op1);
1028
1029       if (!reg_or_int16_operand (op2, mode))
1030         op2 = force_reg (mode, op2);
1031
1032       if (code == GE)
1033         emit_insn (gen_sge_insn (op0, op1, op2));
1034       else
1035         emit_insn (gen_sgeu_insn (op0, op1, op2));
1036       return true;
1037
1038     case LE:
1039     case LEU:
1040       if (!register_operand (op1, mode))
1041         op1 = force_reg (mode, op1);
1042
1043       if (CONST_INT_P (op2))
1044         {
1045           HOST_WIDE_INT value = INTVAL (op2);
1046           if (value >= 2147483647)
1047             {
1048               emit_move_insn (op0, const1_rtx);
1049               return true;
1050             }
1051
1052           op2 = GEN_INT (value + 1);
1053           if (value < -32768 || value >= 32767)
1054             op2 = force_reg (mode, op2);
1055
1056           if (code == LEU)
1057             emit_insn (gen_sltu_insn (op0, op1, op2));
1058           else
1059             emit_insn (gen_slt_insn (op0, op1, op2));
1060           return true;
1061         }
1062
1063       if (!register_operand (op2, mode))
1064         op2 = force_reg (mode, op2);
1065
1066       if (code == LEU)
1067         emit_insn (gen_sleu_insn (op0, op1, op2));
1068       else
1069         emit_insn (gen_sle_insn (op0, op1, op2));
1070       return true;
1071
1072     default:
1073       gcc_unreachable ();
1074     }
1075 }
1076
1077 \f
1078 /* Split a 2 word move (DI or DF) into component parts.  */
1079
1080 rtx
1081 gen_split_move_double (rtx operands[])
1082 {
1083   enum machine_mode mode = GET_MODE (operands[0]);
1084   rtx dest = operands[0];
1085   rtx src  = operands[1];
1086   rtx val;
1087
1088   /* We might have (SUBREG (MEM)) here, so just get rid of the
1089      subregs to make this code simpler.  It is safe to call
1090      alter_subreg any time after reload.  */
1091   if (GET_CODE (dest) == SUBREG)
1092     alter_subreg (&dest);
1093   if (GET_CODE (src) == SUBREG)
1094     alter_subreg (&src);
1095
1096   start_sequence ();
1097   if (REG_P (dest))
1098     {
1099       int dregno = REGNO (dest);
1100
1101       /* Reg = reg.  */
1102       if (REG_P (src))
1103         {
1104           int sregno = REGNO (src);
1105
1106           int reverse = (dregno == sregno + 1);
1107
1108           /* We normally copy the low-numbered register first.  However, if
1109              the first register operand 0 is the same as the second register of
1110              operand 1, we must copy in the opposite order.  */
1111           emit_insn (gen_rtx_SET (VOIDmode,
1112                                   operand_subword (dest, reverse, TRUE, mode),
1113                                   operand_subword (src,  reverse, TRUE, mode)));
1114
1115           emit_insn (gen_rtx_SET (VOIDmode,
1116                                   operand_subword (dest, !reverse, TRUE, mode),
1117                                   operand_subword (src,  !reverse, TRUE, mode)));
1118         }
1119
1120       /* Reg = constant.  */
1121       else if (CONST_INT_P (src) || GET_CODE (src) == CONST_DOUBLE)
1122         {
1123           rtx words[2];
1124           split_double (src, &words[0], &words[1]);
1125           emit_insn (gen_rtx_SET (VOIDmode,
1126                                   operand_subword (dest, 0, TRUE, mode),
1127                                   words[0]));
1128
1129           emit_insn (gen_rtx_SET (VOIDmode,
1130                                   operand_subword (dest, 1, TRUE, mode),
1131                                   words[1]));
1132         }
1133
1134       /* Reg = mem.  */
1135       else if (MEM_P (src))
1136         {
1137           /* If the high-address word is used in the address, we must load it
1138              last.  Otherwise, load it first.  */
1139           int reverse
1140             = (refers_to_regno_p (dregno, dregno + 1, XEXP (src, 0), 0) != 0);
1141
1142           /* We used to optimize loads from single registers as
1143
1144                 ld r1,r3+; ld r2,r3
1145
1146              if r3 were not used subsequently.  However, the REG_NOTES aren't
1147              propagated correctly by the reload phase, and it can cause bad
1148              code to be generated.  We could still try:
1149
1150                 ld r1,r3+; ld r2,r3; addi r3,-4
1151
1152              which saves 2 bytes and doesn't force longword alignment.  */
1153           emit_insn (gen_rtx_SET (VOIDmode,
1154                                   operand_subword (dest, reverse, TRUE, mode),
1155                                   adjust_address (src, SImode,
1156                                                   reverse * UNITS_PER_WORD)));
1157
1158           emit_insn (gen_rtx_SET (VOIDmode,
1159                                   operand_subword (dest, !reverse, TRUE, mode),
1160                                   adjust_address (src, SImode,
1161                                                   !reverse * UNITS_PER_WORD)));
1162         }
1163       else
1164         gcc_unreachable ();
1165     }
1166
1167   /* Mem = reg.  */
1168   /* We used to optimize loads from single registers as
1169
1170         st r1,r3; st r2,+r3
1171
1172      if r3 were not used subsequently.  However, the REG_NOTES aren't
1173      propagated correctly by the reload phase, and it can cause bad
1174      code to be generated.  We could still try:
1175
1176         st r1,r3; st r2,+r3; addi r3,-4
1177
1178      which saves 2 bytes and doesn't force longword alignment.  */
1179   else if (MEM_P (dest) && REG_P (src))
1180     {
1181       emit_insn (gen_rtx_SET (VOIDmode,
1182                               adjust_address (dest, SImode, 0),
1183                               operand_subword (src, 0, TRUE, mode)));
1184
1185       emit_insn (gen_rtx_SET (VOIDmode,
1186                               adjust_address (dest, SImode, UNITS_PER_WORD),
1187                               operand_subword (src, 1, TRUE, mode)));
1188     }
1189
1190   else
1191     gcc_unreachable ();
1192
1193   val = get_insns ();
1194   end_sequence ();
1195   return val;
1196 }
1197
1198 \f
1199 static int
1200 m32r_arg_partial_bytes (CUMULATIVE_ARGS *cum, enum machine_mode mode,
1201                         tree type, bool named ATTRIBUTE_UNUSED)
1202 {
1203   int words;
1204   unsigned int size =
1205     (((mode == BLKmode && type)
1206       ? (unsigned int) int_size_in_bytes (type)
1207       : GET_MODE_SIZE (mode)) + UNITS_PER_WORD - 1)
1208     / UNITS_PER_WORD;
1209
1210   if (*cum >= M32R_MAX_PARM_REGS)
1211     words = 0;
1212   else if (*cum + size > M32R_MAX_PARM_REGS)
1213     words = (*cum + size) - M32R_MAX_PARM_REGS;
1214   else
1215     words = 0;
1216
1217   return words * UNITS_PER_WORD;
1218 }
1219
1220 /* The ROUND_ADVANCE* macros are local to this file.  */
1221 /* Round SIZE up to a word boundary.  */
1222 #define ROUND_ADVANCE(SIZE) \
1223   (((SIZE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
1224
1225 /* Round arg MODE/TYPE up to the next word boundary.  */
1226 #define ROUND_ADVANCE_ARG(MODE, TYPE) \
1227   ((MODE) == BLKmode                            \
1228    ? ROUND_ADVANCE ((unsigned int) int_size_in_bytes (TYPE))    \
1229    : ROUND_ADVANCE ((unsigned int) GET_MODE_SIZE (MODE)))
1230
1231 /* Round CUM up to the necessary point for argument MODE/TYPE.  */
1232 #define ROUND_ADVANCE_CUM(CUM, MODE, TYPE) (CUM)
1233
1234 /* Return boolean indicating arg of type TYPE and mode MODE will be passed in
1235    a reg.  This includes arguments that have to be passed by reference as the
1236    pointer to them is passed in a reg if one is available (and that is what
1237    we're given).
1238    This macro is only used in this file.  */
1239 #define PASS_IN_REG_P(CUM, MODE, TYPE) \
1240   (ROUND_ADVANCE_CUM ((CUM), (MODE), (TYPE)) < M32R_MAX_PARM_REGS)
1241
1242 /* Determine where to put an argument to a function.
1243    Value is zero to push the argument on the stack,
1244    or a hard register in which to store the argument.
1245
1246    MODE is the argument's machine mode.
1247    TYPE is the data type of the argument (as a tree).
1248     This is null for libcalls where that information may
1249     not be available.
1250    CUM is a variable of type CUMULATIVE_ARGS which gives info about
1251     the preceding args and about the function being called.
1252    NAMED is nonzero if this argument is a named parameter
1253     (otherwise it is an extra parameter matching an ellipsis).  */
1254 /* On the M32R the first M32R_MAX_PARM_REGS args are normally in registers
1255    and the rest are pushed.  */
1256
1257 static rtx
1258 m32r_function_arg (CUMULATIVE_ARGS *cum, enum machine_mode mode,
1259                    const_tree type ATTRIBUTE_UNUSED,
1260                    bool named ATTRIBUTE_UNUSED)
1261 {
1262   return (PASS_IN_REG_P (*cum, mode, type)
1263           ? gen_rtx_REG (mode, ROUND_ADVANCE_CUM (*cum, mode, type))
1264           : NULL_RTX);
1265 }
1266
1267 /* Update the data in CUM to advance over an argument
1268    of mode MODE and data type TYPE.
1269    (TYPE is null for libcalls where that information may not be available.)  */
1270
1271 static void
1272 m32r_function_arg_advance (CUMULATIVE_ARGS *cum, enum machine_mode mode,
1273                            const_tree type, bool named ATTRIBUTE_UNUSED)
1274 {
1275   *cum = (ROUND_ADVANCE_CUM (*cum, mode, type)
1276           + ROUND_ADVANCE_ARG (mode, type));
1277 }
1278
1279 /* Worker function for TARGET_RETURN_IN_MEMORY.  */
1280
1281 static bool
1282 m32r_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
1283 {
1284   return m32r_pass_by_reference (NULL, TYPE_MODE (type), type, false);
1285 }
1286
1287 /* Worker function for TARGET_FUNCTION_VALUE.  */
1288
1289 static rtx
1290 m32r_function_value (const_tree valtype,
1291                 const_tree fn_decl_or_type ATTRIBUTE_UNUSED,
1292                 bool outgoing ATTRIBUTE_UNUSED)
1293 {
1294   return gen_rtx_REG (TYPE_MODE (valtype), 0);
1295 }
1296
1297 /* Worker function for TARGET_LIBCALL_VALUE.  */
1298
1299 static rtx
1300 m32r_libcall_value (enum machine_mode mode,
1301                 const_rtx fun ATTRIBUTE_UNUSED)
1302 {
1303   return gen_rtx_REG (mode, 0);
1304 }
1305
1306 /* Worker function for TARGET_FUNCTION_VALUE_REGNO_P.
1307
1308   ??? What about r1 in DI/DF values.  */
1309
1310 static bool
1311 m32r_function_value_regno_p (const unsigned int regno)
1312 {
1313   return (regno == 0);
1314 }
1315
1316 /* Do any needed setup for a variadic function.  For the M32R, we must
1317    create a register parameter block, and then copy any anonymous arguments
1318    in registers to memory.
1319
1320    CUM has not been updated for the last named argument which has type TYPE
1321    and mode MODE, and we rely on this fact.  */
1322
1323 static void
1324 m32r_setup_incoming_varargs (CUMULATIVE_ARGS *cum, enum machine_mode mode,
1325                              tree type, int *pretend_size, int no_rtl)
1326 {
1327   int first_anon_arg;
1328
1329   if (no_rtl)
1330     return;
1331
1332   /* All BLKmode values are passed by reference.  */
1333   gcc_assert (mode != BLKmode);
1334
1335   first_anon_arg = (ROUND_ADVANCE_CUM (*cum, mode, type)
1336                     + ROUND_ADVANCE_ARG (mode, type));
1337
1338   if (first_anon_arg < M32R_MAX_PARM_REGS)
1339     {
1340       /* Note that first_reg_offset < M32R_MAX_PARM_REGS.  */
1341       int first_reg_offset = first_anon_arg;
1342       /* Size in words to "pretend" allocate.  */
1343       int size = M32R_MAX_PARM_REGS - first_reg_offset;
1344       rtx regblock;
1345
1346       regblock = gen_frame_mem (BLKmode,
1347                                 plus_constant (arg_pointer_rtx,
1348                                                FIRST_PARM_OFFSET (0)));
1349       set_mem_alias_set (regblock, get_varargs_alias_set ());
1350       move_block_from_reg (first_reg_offset, regblock, size);
1351
1352       *pretend_size = (size * UNITS_PER_WORD);
1353     }
1354 }
1355
1356 \f
1357 /* Return true if INSN is real instruction bearing insn.  */
1358
1359 static int
1360 m32r_is_insn (rtx insn)
1361 {
1362   return (NONDEBUG_INSN_P (insn)
1363           && GET_CODE (PATTERN (insn)) != USE
1364           && GET_CODE (PATTERN (insn)) != CLOBBER
1365           && GET_CODE (PATTERN (insn)) != ADDR_VEC);
1366 }
1367
1368 /* Increase the priority of long instructions so that the
1369    short instructions are scheduled ahead of the long ones.  */
1370
1371 static int
1372 m32r_adjust_priority (rtx insn, int priority)
1373 {
1374   if (m32r_is_insn (insn)
1375       && get_attr_insn_size (insn) != INSN_SIZE_SHORT)
1376     priority <<= 3;
1377
1378   return priority;
1379 }
1380
1381 \f
1382 /* Indicate how many instructions can be issued at the same time.
1383    This is sort of a lie.  The m32r can issue only 1 long insn at
1384    once, but it can issue 2 short insns.  The default therefore is
1385    set at 2, but this can be overridden by the command line option
1386    -missue-rate=1.  */
1387
1388 static int
1389 m32r_issue_rate (void)
1390 {
1391   return ((TARGET_LOW_ISSUE_RATE) ? 1 : 2);
1392 }
1393 \f
1394 /* Cost functions.  */
1395
1396 /* Implement TARGET_HANDLE_OPTION.
1397
1398    Memory is 3 times as expensive as registers.
1399    ??? Is that the right way to look at it?  */
1400
1401 static int
1402 m32r_memory_move_cost (enum machine_mode mode,
1403                        reg_class_t rclass ATTRIBUTE_UNUSED,
1404                        bool in ATTRIBUTE_UNUSED)
1405 {
1406   if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD)
1407     return 6;
1408   else
1409     return 12;
1410 }
1411
1412 static bool
1413 m32r_rtx_costs (rtx x, int code, int outer_code ATTRIBUTE_UNUSED, int *total,
1414                 bool speed ATTRIBUTE_UNUSED)
1415 {
1416   switch (code)
1417     {
1418       /* Small integers are as cheap as registers.  4 byte values can be
1419          fetched as immediate constants - let's give that the cost of an
1420          extra insn.  */
1421     case CONST_INT:
1422       if (INT16_P (INTVAL (x)))
1423         {
1424           *total = 0;
1425           return true;
1426         }
1427       /* FALLTHRU */
1428
1429     case CONST:
1430     case LABEL_REF:
1431     case SYMBOL_REF:
1432       *total = COSTS_N_INSNS (1);
1433       return true;
1434
1435     case CONST_DOUBLE:
1436       {
1437         rtx high, low;
1438
1439         split_double (x, &high, &low);
1440         *total = COSTS_N_INSNS (!INT16_P (INTVAL (high))
1441                                 + !INT16_P (INTVAL (low)));
1442         return true;
1443       }
1444
1445     case MULT:
1446       *total = COSTS_N_INSNS (3);
1447       return true;
1448
1449     case DIV:
1450     case UDIV:
1451     case MOD:
1452     case UMOD:
1453       *total = COSTS_N_INSNS (10);
1454       return true;
1455
1456     default:
1457       return false;
1458     }
1459 }
1460 \f
1461 /* Type of function DECL.
1462
1463    The result is cached.  To reset the cache at the end of a function,
1464    call with DECL = NULL_TREE.  */
1465
1466 enum m32r_function_type
1467 m32r_compute_function_type (tree decl)
1468 {
1469   /* Cached value.  */
1470   static enum m32r_function_type fn_type = M32R_FUNCTION_UNKNOWN;
1471   /* Last function we were called for.  */
1472   static tree last_fn = NULL_TREE;
1473
1474   /* Resetting the cached value?  */
1475   if (decl == NULL_TREE)
1476     {
1477       fn_type = M32R_FUNCTION_UNKNOWN;
1478       last_fn = NULL_TREE;
1479       return fn_type;
1480     }
1481
1482   if (decl == last_fn && fn_type != M32R_FUNCTION_UNKNOWN)
1483     return fn_type;
1484
1485   /* Compute function type.  */
1486   fn_type = (lookup_attribute ("interrupt", DECL_ATTRIBUTES (current_function_decl)) != NULL_TREE
1487              ? M32R_FUNCTION_INTERRUPT
1488              : M32R_FUNCTION_NORMAL);
1489
1490   last_fn = decl;
1491   return fn_type;
1492 }
1493 \f/* Function prologue/epilogue handlers.  */
1494
1495 /* M32R stack frames look like:
1496
1497              Before call                       After call
1498         +-----------------------+       +-----------------------+
1499         |                       |       |                       |
1500    high |  local variables,     |       |  local variables,     |
1501    mem  |  reg save area, etc.  |       |  reg save area, etc.  |
1502         |                       |       |                       |
1503         +-----------------------+       +-----------------------+
1504         |                       |       |                       |
1505         |  arguments on stack.  |       |  arguments on stack.  |
1506         |                       |       |                       |
1507   SP+0->+-----------------------+       +-----------------------+
1508                                         |  reg parm save area,  |
1509                                         |  only created for     |
1510                                         |  variable argument    |
1511                                         |  functions            |
1512                                         +-----------------------+
1513                                         |   previous frame ptr  |
1514                                         +-----------------------+
1515                                         |                       |
1516                                         |  register save area   |
1517                                         |                       |
1518                                         +-----------------------+
1519                                         |    return address     |
1520                                         +-----------------------+
1521                                         |                       |
1522                                         |  local variables      |
1523                                         |                       |
1524                                         +-----------------------+
1525                                         |                       |
1526                                         |  alloca allocations   |
1527                                         |                       |
1528                                         +-----------------------+
1529                                         |                       |
1530    low                                  |  arguments on stack   |
1531    memory                               |                       |
1532                                   SP+0->+-----------------------+
1533
1534 Notes:
1535 1) The "reg parm save area" does not exist for non variable argument fns.
1536 2) The "reg parm save area" can be eliminated completely if we saved regs
1537    containing anonymous args separately but that complicates things too
1538    much (so it's not done).
1539 3) The return address is saved after the register save area so as to have as
1540    many insns as possible between the restoration of `lr' and the `jmp lr'.  */
1541
1542 /* Structure to be filled in by m32r_compute_frame_size with register
1543    save masks, and offsets for the current function.  */
1544 struct m32r_frame_info
1545 {
1546   unsigned int total_size;      /* # bytes that the entire frame takes up.  */
1547   unsigned int extra_size;      /* # bytes of extra stuff.  */
1548   unsigned int pretend_size;    /* # bytes we push and pretend caller did.  */
1549   unsigned int args_size;       /* # bytes that outgoing arguments take up.  */
1550   unsigned int reg_size;        /* # bytes needed to store regs.  */
1551   unsigned int var_size;        /* # bytes that variables take up.  */
1552   unsigned int gmask;           /* Mask of saved gp registers.  */
1553   unsigned int save_fp;         /* Nonzero if fp must be saved.  */
1554   unsigned int save_lr;         /* Nonzero if lr (return addr) must be saved.  */
1555   int          initialized;     /* Nonzero if frame size already calculated.  */
1556 };
1557
1558 /* Current frame information calculated by m32r_compute_frame_size.  */
1559 static struct m32r_frame_info current_frame_info;
1560
1561 /* Zero structure to initialize current_frame_info.  */
1562 static struct m32r_frame_info zero_frame_info;
1563
1564 #define FRAME_POINTER_MASK (1 << (FRAME_POINTER_REGNUM))
1565 #define RETURN_ADDR_MASK   (1 << (RETURN_ADDR_REGNUM))
1566
1567 /* Tell prologue and epilogue if register REGNO should be saved / restored.
1568    The return address and frame pointer are treated separately.
1569    Don't consider them here.  */
1570 #define MUST_SAVE_REGISTER(regno, interrupt_p) \
1571   ((regno) != RETURN_ADDR_REGNUM && (regno) != FRAME_POINTER_REGNUM \
1572    && (df_regs_ever_live_p (regno) && (!call_really_used_regs[regno] || interrupt_p)))
1573
1574 #define MUST_SAVE_FRAME_POINTER (df_regs_ever_live_p (FRAME_POINTER_REGNUM))
1575 #define MUST_SAVE_RETURN_ADDR   (df_regs_ever_live_p (RETURN_ADDR_REGNUM) || crtl->profile)
1576
1577 #define SHORT_INSN_SIZE 2       /* Size of small instructions.  */
1578 #define LONG_INSN_SIZE 4        /* Size of long instructions.  */
1579
1580 /* Return the bytes needed to compute the frame pointer from the current
1581    stack pointer.
1582
1583    SIZE is the size needed for local variables.  */
1584
1585 unsigned int
1586 m32r_compute_frame_size (int size)      /* # of var. bytes allocated.  */
1587 {
1588   unsigned int regno;
1589   unsigned int total_size, var_size, args_size, pretend_size, extra_size;
1590   unsigned int reg_size;
1591   unsigned int gmask;
1592   enum m32r_function_type fn_type;
1593   int interrupt_p;
1594   int pic_reg_used = flag_pic && (crtl->uses_pic_offset_table
1595                                   | crtl->profile);
1596
1597   var_size      = M32R_STACK_ALIGN (size);
1598   args_size     = M32R_STACK_ALIGN (crtl->outgoing_args_size);
1599   pretend_size  = crtl->args.pretend_args_size;
1600   extra_size    = FIRST_PARM_OFFSET (0);
1601   total_size    = extra_size + pretend_size + args_size + var_size;
1602   reg_size      = 0;
1603   gmask         = 0;
1604
1605   /* See if this is an interrupt handler.  Call used registers must be saved
1606      for them too.  */
1607   fn_type = m32r_compute_function_type (current_function_decl);
1608   interrupt_p = M32R_INTERRUPT_P (fn_type);
1609
1610   /* Calculate space needed for registers.  */
1611   for (regno = 0; regno < M32R_MAX_INT_REGS; regno++)
1612     {
1613       if (MUST_SAVE_REGISTER (regno, interrupt_p)
1614           || (regno == PIC_OFFSET_TABLE_REGNUM && pic_reg_used))
1615         {
1616           reg_size += UNITS_PER_WORD;
1617           gmask |= 1 << regno;
1618         }
1619     }
1620
1621   current_frame_info.save_fp = MUST_SAVE_FRAME_POINTER;
1622   current_frame_info.save_lr = MUST_SAVE_RETURN_ADDR || pic_reg_used;
1623
1624   reg_size += ((current_frame_info.save_fp + current_frame_info.save_lr)
1625                * UNITS_PER_WORD);
1626   total_size += reg_size;
1627
1628   /* ??? Not sure this is necessary, and I don't think the epilogue
1629      handler will do the right thing if this changes total_size.  */
1630   total_size = M32R_STACK_ALIGN (total_size);
1631
1632   /* frame_size = total_size - (pretend_size + reg_size); */
1633
1634   /* Save computed information.  */
1635   current_frame_info.total_size   = total_size;
1636   current_frame_info.extra_size   = extra_size;
1637   current_frame_info.pretend_size = pretend_size;
1638   current_frame_info.var_size     = var_size;
1639   current_frame_info.args_size    = args_size;
1640   current_frame_info.reg_size     = reg_size;
1641   current_frame_info.gmask        = gmask;
1642   current_frame_info.initialized  = reload_completed;
1643
1644   /* Ok, we're done.  */
1645   return total_size;
1646 }
1647
1648 /* Worker function for TARGET_CAN_ELIMINATE.  */
1649
1650 bool
1651 m32r_can_eliminate (const int from, const int to)
1652 {
1653   return (from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM
1654           ? ! frame_pointer_needed
1655           : true);
1656 }
1657
1658 \f
1659 /* The table we use to reference PIC data.  */
1660 static rtx global_offset_table;
1661
1662 static void
1663 m32r_reload_lr (rtx sp, int size)
1664 {
1665   rtx lr = gen_rtx_REG (Pmode, RETURN_ADDR_REGNUM);
1666
1667   if (size == 0)
1668     emit_insn (gen_movsi (lr, gen_frame_mem (Pmode, sp)));
1669   else if (size < 32768)
1670     emit_insn (gen_movsi (lr, gen_frame_mem (Pmode,
1671                                              gen_rtx_PLUS (Pmode, sp,
1672                                                            GEN_INT (size)))));
1673   else
1674     {
1675       rtx tmp = gen_rtx_REG (Pmode, PROLOGUE_TMP_REGNUM);
1676
1677       emit_insn (gen_movsi (tmp, GEN_INT (size)));
1678       emit_insn (gen_addsi3 (tmp, tmp, sp));
1679       emit_insn (gen_movsi (lr, gen_frame_mem (Pmode, tmp)));
1680     }
1681
1682   emit_use (lr);
1683 }
1684
1685 void
1686 m32r_load_pic_register (void)
1687 {
1688   global_offset_table = gen_rtx_SYMBOL_REF (Pmode, "_GLOBAL_OFFSET_TABLE_");
1689   emit_insn (gen_get_pc (pic_offset_table_rtx, global_offset_table,
1690                          GEN_INT (TARGET_MODEL_SMALL)));
1691
1692   /* Need to emit this whether or not we obey regdecls,
1693      since setjmp/longjmp can cause life info to screw up.  */
1694   emit_use (pic_offset_table_rtx);
1695 }
1696
1697 /* Expand the m32r prologue as a series of insns.  */
1698
1699 void
1700 m32r_expand_prologue (void)
1701 {
1702   int regno;
1703   int frame_size;
1704   unsigned int gmask;
1705   int pic_reg_used = flag_pic && (crtl->uses_pic_offset_table
1706                                   | crtl->profile);
1707
1708   if (! current_frame_info.initialized)
1709     m32r_compute_frame_size (get_frame_size ());
1710
1711   gmask = current_frame_info.gmask;
1712
1713   /* These cases shouldn't happen.  Catch them now.  */
1714   gcc_assert (current_frame_info.total_size || !gmask);
1715
1716   /* Allocate space for register arguments if this is a variadic function.  */
1717   if (current_frame_info.pretend_size != 0)
1718     {
1719       /* Use a HOST_WIDE_INT temporary, since negating an unsigned int gives
1720          the wrong result on a 64-bit host.  */
1721       HOST_WIDE_INT pretend_size = current_frame_info.pretend_size;
1722       emit_insn (gen_addsi3 (stack_pointer_rtx,
1723                              stack_pointer_rtx,
1724                              GEN_INT (-pretend_size)));
1725     }
1726
1727   /* Save any registers we need to and set up fp.  */
1728   if (current_frame_info.save_fp)
1729     emit_insn (gen_movsi_push (stack_pointer_rtx, frame_pointer_rtx));
1730
1731   gmask &= ~(FRAME_POINTER_MASK | RETURN_ADDR_MASK);
1732
1733   /* Save any needed call-saved regs (and call-used if this is an
1734      interrupt handler).  */
1735   for (regno = 0; regno <= M32R_MAX_INT_REGS; ++regno)
1736     {
1737       if ((gmask & (1 << regno)) != 0)
1738         emit_insn (gen_movsi_push (stack_pointer_rtx,
1739                                    gen_rtx_REG (Pmode, regno)));
1740     }
1741
1742   if (current_frame_info.save_lr)
1743     emit_insn (gen_movsi_push (stack_pointer_rtx,
1744                                gen_rtx_REG (Pmode, RETURN_ADDR_REGNUM)));
1745
1746   /* Allocate the stack frame.  */
1747   frame_size = (current_frame_info.total_size
1748                 - (current_frame_info.pretend_size
1749                    + current_frame_info.reg_size));
1750
1751   if (frame_size == 0)
1752     ; /* Nothing to do.  */
1753   else if (frame_size <= 32768)
1754     emit_insn (gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx,
1755                            GEN_INT (-frame_size)));
1756   else
1757     {
1758       rtx tmp = gen_rtx_REG (Pmode, PROLOGUE_TMP_REGNUM);
1759
1760       emit_insn (gen_movsi (tmp, GEN_INT (frame_size)));
1761       emit_insn (gen_subsi3 (stack_pointer_rtx, stack_pointer_rtx, tmp));
1762     }
1763
1764   if (frame_pointer_needed)
1765     emit_insn (gen_movsi (frame_pointer_rtx, stack_pointer_rtx));
1766
1767   if (crtl->profile)
1768     /* Push lr for mcount (form_pc, x).  */
1769     emit_insn (gen_movsi_push (stack_pointer_rtx,
1770                                gen_rtx_REG (Pmode, RETURN_ADDR_REGNUM)));
1771
1772   if (pic_reg_used)
1773     {
1774       m32r_load_pic_register ();
1775       m32r_reload_lr (stack_pointer_rtx,
1776                       (crtl->profile ? 0 : frame_size));
1777     }
1778
1779   if (crtl->profile && !pic_reg_used)
1780     emit_insn (gen_blockage ());
1781 }
1782
1783 \f
1784 /* Set up the stack and frame pointer (if desired) for the function.
1785    Note, if this is changed, you need to mirror the changes in
1786    m32r_compute_frame_size which calculates the prolog size.  */
1787
1788 static void
1789 m32r_output_function_prologue (FILE * file, HOST_WIDE_INT size)
1790 {
1791   enum m32r_function_type fn_type = m32r_compute_function_type (current_function_decl);
1792
1793   /* If this is an interrupt handler, mark it as such.  */
1794   if (M32R_INTERRUPT_P (fn_type))
1795     fprintf (file, "\t%s interrupt handler\n", ASM_COMMENT_START);
1796
1797   if (! current_frame_info.initialized)
1798     m32r_compute_frame_size (size);
1799
1800   /* This is only for the human reader.  */
1801   fprintf (file,
1802            "\t%s PROLOGUE, vars= %d, regs= %d, args= %d, extra= %d\n",
1803            ASM_COMMENT_START,
1804            current_frame_info.var_size,
1805            current_frame_info.reg_size / 4,
1806            current_frame_info.args_size,
1807            current_frame_info.extra_size);
1808 }
1809 \f
1810 /* Output RTL to pop register REGNO from the stack.  */
1811
1812 static void
1813 pop (int regno)
1814 {
1815   rtx x;
1816
1817   x = emit_insn (gen_movsi_pop (gen_rtx_REG (Pmode, regno),
1818                                 stack_pointer_rtx));
1819   add_reg_note (x, REG_INC, stack_pointer_rtx);
1820 }
1821
1822 /* Expand the m32r epilogue as a series of insns.  */
1823
1824 void
1825 m32r_expand_epilogue (void)
1826 {
1827   int regno;
1828   int noepilogue = FALSE;
1829   int total_size;
1830
1831   gcc_assert (current_frame_info.initialized);
1832   total_size = current_frame_info.total_size;
1833
1834   if (total_size == 0)
1835     {
1836       rtx insn = get_last_insn ();
1837
1838       /* If the last insn was a BARRIER, we don't have to write any code
1839          because a jump (aka return) was put there.  */
1840       if (insn && NOTE_P (insn))
1841         insn = prev_nonnote_insn (insn);
1842       if (insn && BARRIER_P (insn))
1843         noepilogue = TRUE;
1844     }
1845
1846   if (!noepilogue)
1847     {
1848       unsigned int var_size = current_frame_info.var_size;
1849       unsigned int args_size = current_frame_info.args_size;
1850       unsigned int gmask = current_frame_info.gmask;
1851       int can_trust_sp_p = !cfun->calls_alloca;
1852
1853       if (flag_exceptions)
1854         emit_insn (gen_blockage ());
1855
1856       /* The first thing to do is point the sp at the bottom of the register
1857          save area.  */
1858       if (can_trust_sp_p)
1859         {
1860           unsigned int reg_offset = var_size + args_size;
1861
1862           if (reg_offset == 0)
1863             ; /* Nothing to do.  */
1864           else if (reg_offset < 32768)
1865             emit_insn (gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx,
1866                            GEN_INT (reg_offset)));
1867           else
1868             {
1869               rtx tmp = gen_rtx_REG (Pmode, PROLOGUE_TMP_REGNUM);
1870
1871               emit_insn (gen_movsi (tmp, GEN_INT (reg_offset)));
1872               emit_insn (gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx,
1873                                      tmp));
1874             }
1875         }
1876       else if (frame_pointer_needed)
1877         {
1878           unsigned int reg_offset = var_size + args_size;
1879
1880           if (reg_offset == 0)
1881             emit_insn (gen_movsi (stack_pointer_rtx, frame_pointer_rtx));
1882           else if (reg_offset < 32768)
1883             emit_insn (gen_addsi3 (stack_pointer_rtx, frame_pointer_rtx,
1884                            GEN_INT (reg_offset)));
1885           else
1886             {
1887               rtx tmp = gen_rtx_REG (Pmode, PROLOGUE_TMP_REGNUM);
1888
1889               emit_insn (gen_movsi (tmp, GEN_INT (reg_offset)));
1890               emit_insn (gen_movsi (stack_pointer_rtx, frame_pointer_rtx));
1891               emit_insn (gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx,
1892                                      tmp));
1893             }
1894         }
1895       else
1896         gcc_unreachable ();
1897
1898       if (current_frame_info.save_lr)
1899         pop (RETURN_ADDR_REGNUM);
1900
1901       /* Restore any saved registers, in reverse order of course.  */
1902       gmask &= ~(FRAME_POINTER_MASK | RETURN_ADDR_MASK);
1903       for (regno = M32R_MAX_INT_REGS - 1; regno >= 0; --regno)
1904         {
1905           if ((gmask & (1L << regno)) != 0)
1906             pop (regno);
1907         }
1908
1909       if (current_frame_info.save_fp)
1910         pop (FRAME_POINTER_REGNUM);
1911
1912       /* Remove varargs area if present.  */
1913       if (current_frame_info.pretend_size != 0)
1914         emit_insn (gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx,
1915                                GEN_INT (current_frame_info.pretend_size)));
1916
1917       emit_insn (gen_blockage ());
1918     }
1919 }
1920
1921 /* Do any necessary cleanup after a function to restore stack, frame,
1922    and regs.  */
1923
1924 static void
1925 m32r_output_function_epilogue (FILE * file ATTRIBUTE_UNUSED,
1926                                HOST_WIDE_INT size ATTRIBUTE_UNUSED)
1927 {
1928   /* Reset state info for each function.  */
1929   current_frame_info = zero_frame_info;
1930   m32r_compute_function_type (NULL_TREE);
1931 }
1932 \f
1933 /* Return nonzero if this function is known to have a null or 1 instruction
1934    epilogue.  */
1935
1936 int
1937 direct_return (void)
1938 {
1939   if (!reload_completed)
1940     return FALSE;
1941
1942   if (M32R_INTERRUPT_P (m32r_compute_function_type (current_function_decl)))
1943     return FALSE;
1944
1945   if (! current_frame_info.initialized)
1946     m32r_compute_frame_size (get_frame_size ());
1947
1948   return current_frame_info.total_size == 0;
1949 }
1950
1951 \f
1952 /* PIC.  */
1953
1954 int
1955 m32r_legitimate_pic_operand_p (rtx x)
1956 {
1957   if (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == LABEL_REF)
1958     return 0;
1959
1960   if (GET_CODE (x) == CONST
1961       && GET_CODE (XEXP (x, 0)) == PLUS
1962       && (GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
1963           || GET_CODE (XEXP (XEXP (x, 0), 0)) == LABEL_REF)
1964       && (CONST_INT_P (XEXP (XEXP (x, 0), 1))))
1965     return 0;
1966
1967   return 1;
1968 }
1969
1970 rtx
1971 m32r_legitimize_pic_address (rtx orig, rtx reg)
1972 {
1973 #ifdef DEBUG_PIC
1974   printf("m32r_legitimize_pic_address()\n");
1975 #endif
1976
1977   if (GET_CODE (orig) == SYMBOL_REF || GET_CODE (orig) == LABEL_REF)
1978     {
1979       rtx pic_ref, address;
1980       int subregs = 0;
1981
1982       if (reg == 0)
1983         {
1984           gcc_assert (!reload_in_progress && !reload_completed);
1985           reg = gen_reg_rtx (Pmode);
1986
1987           subregs = 1;
1988         }
1989
1990       if (subregs)
1991         address = gen_reg_rtx (Pmode);
1992       else
1993         address = reg;
1994
1995       crtl->uses_pic_offset_table = 1;
1996
1997       if (GET_CODE (orig) == LABEL_REF
1998           || (GET_CODE (orig) == SYMBOL_REF && SYMBOL_REF_LOCAL_P (orig)))
1999         {
2000           emit_insn (gen_gotoff_load_addr (reg, orig));
2001           emit_insn (gen_addsi3 (reg, reg, pic_offset_table_rtx));
2002           return reg;
2003         }
2004
2005       emit_insn (gen_pic_load_addr (address, orig));
2006
2007       emit_insn (gen_addsi3 (address, address, pic_offset_table_rtx));
2008       pic_ref = gen_const_mem (Pmode, address);
2009       emit_move_insn (reg, pic_ref);
2010       return reg;
2011     }
2012   else if (GET_CODE (orig) == CONST)
2013     {
2014       rtx base, offset;
2015
2016       if (GET_CODE (XEXP (orig, 0)) == PLUS
2017           && XEXP (XEXP (orig, 0), 1) == pic_offset_table_rtx)
2018         return orig;
2019
2020       if (reg == 0)
2021         {
2022           gcc_assert (!reload_in_progress && !reload_completed);
2023           reg = gen_reg_rtx (Pmode);
2024         }
2025
2026       if (GET_CODE (XEXP (orig, 0)) == PLUS)
2027         {
2028           base = m32r_legitimize_pic_address (XEXP (XEXP (orig, 0), 0), reg);
2029           if (base == reg)
2030             offset = m32r_legitimize_pic_address (XEXP (XEXP (orig, 0), 1), NULL_RTX);
2031           else
2032             offset = m32r_legitimize_pic_address (XEXP (XEXP (orig, 0), 1), reg);
2033         }
2034       else
2035         return orig;
2036
2037       if (CONST_INT_P (offset))
2038         {
2039           if (INT16_P (INTVAL (offset)))
2040             return plus_constant (base, INTVAL (offset));
2041           else
2042             {
2043               gcc_assert (! reload_in_progress && ! reload_completed);
2044               offset = force_reg (Pmode, offset);
2045             }
2046         }
2047
2048       return gen_rtx_PLUS (Pmode, base, offset);
2049     }
2050
2051   return orig;
2052 }
2053
2054 static rtx
2055 m32r_legitimize_address (rtx x, rtx orig_x ATTRIBUTE_UNUSED,
2056                          enum machine_mode mode ATTRIBUTE_UNUSED)
2057 {
2058   if (flag_pic)
2059     return m32r_legitimize_pic_address (x, NULL_RTX);
2060   else
2061     return x;
2062 }
2063
2064 /* Worker function for TARGET_MODE_DEPENDENT_ADDRESS_P.  */
2065
2066 static bool
2067 m32r_mode_dependent_address_p (const_rtx addr)
2068 {
2069   if (GET_CODE (addr) == LO_SUM)
2070     return true;
2071
2072   return false;
2073 }
2074 \f
2075 /* Nested function support.  */
2076
2077 /* Emit RTL insns to initialize the variable parts of a trampoline.
2078    FNADDR is an RTX for the address of the function's pure code.
2079    CXT is an RTX for the static chain value for the function.  */
2080
2081 void
2082 m32r_initialize_trampoline (rtx tramp ATTRIBUTE_UNUSED,
2083                             rtx fnaddr ATTRIBUTE_UNUSED,
2084                             rtx cxt ATTRIBUTE_UNUSED)
2085 {
2086 }
2087 \f
2088 static void
2089 m32r_file_start (void)
2090 {
2091   default_file_start ();
2092
2093   if (flag_verbose_asm)
2094     fprintf (asm_out_file,
2095              "%s M32R/D special options: -G %d\n",
2096              ASM_COMMENT_START, g_switch_value);
2097
2098   if (TARGET_LITTLE_ENDIAN)
2099     fprintf (asm_out_file, "\t.little\n");
2100 }
2101 \f
2102 /* Print operand X (an rtx) in assembler syntax to file FILE.
2103    CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified.
2104    For `%' followed by punctuation, CODE is the punctuation and X is null.  */
2105
2106 static void
2107 m32r_print_operand (FILE * file, rtx x, int code)
2108 {
2109   rtx addr;
2110
2111   switch (code)
2112     {
2113       /* The 's' and 'p' codes are used by output_block_move() to
2114          indicate post-increment 's'tores and 'p're-increment loads.  */
2115     case 's':
2116       if (REG_P (x))
2117         fprintf (file, "@+%s", reg_names [REGNO (x)]);
2118       else
2119         output_operand_lossage ("invalid operand to %%s code");
2120       return;
2121
2122     case 'p':
2123       if (REG_P (x))
2124         fprintf (file, "@%s+", reg_names [REGNO (x)]);
2125       else
2126         output_operand_lossage ("invalid operand to %%p code");
2127       return;
2128
2129     case 'R' :
2130       /* Write second word of DImode or DFmode reference,
2131          register or memory.  */
2132       if (REG_P (x))
2133         fputs (reg_names[REGNO (x)+1], file);
2134       else if (MEM_P (x))
2135         {
2136           fprintf (file, "@(");
2137           /* Handle possible auto-increment.  Since it is pre-increment and
2138              we have already done it, we can just use an offset of four.  */
2139           /* ??? This is taken from rs6000.c I think.  I don't think it is
2140              currently necessary, but keep it around.  */
2141           if (GET_CODE (XEXP (x, 0)) == PRE_INC
2142               || GET_CODE (XEXP (x, 0)) == PRE_DEC)
2143             output_address (plus_constant (XEXP (XEXP (x, 0), 0), 4));
2144           else
2145             output_address (plus_constant (XEXP (x, 0), 4));
2146           fputc (')', file);
2147         }
2148       else
2149         output_operand_lossage ("invalid operand to %%R code");
2150       return;
2151
2152     case 'H' : /* High word.  */
2153     case 'L' : /* Low word.  */
2154       if (REG_P (x))
2155         {
2156           /* L = least significant word, H = most significant word.  */
2157           if ((WORDS_BIG_ENDIAN != 0) ^ (code == 'L'))
2158             fputs (reg_names[REGNO (x)], file);
2159           else
2160             fputs (reg_names[REGNO (x)+1], file);
2161         }
2162       else if (CONST_INT_P (x)
2163                || GET_CODE (x) == CONST_DOUBLE)
2164         {
2165           rtx first, second;
2166
2167           split_double (x, &first, &second);
2168           fprintf (file, HOST_WIDE_INT_PRINT_HEX,
2169                    code == 'L' ? INTVAL (first) : INTVAL (second));
2170         }
2171       else
2172         output_operand_lossage ("invalid operand to %%H/%%L code");
2173       return;
2174
2175     case 'A' :
2176       {
2177         char str[30];
2178
2179         if (GET_CODE (x) != CONST_DOUBLE
2180             || GET_MODE_CLASS (GET_MODE (x)) != MODE_FLOAT)
2181           fatal_insn ("bad insn for 'A'", x);
2182
2183         real_to_decimal (str, CONST_DOUBLE_REAL_VALUE (x), sizeof (str), 0, 1);
2184         fprintf (file, "%s", str);
2185         return;
2186       }
2187
2188     case 'B' : /* Bottom half.  */
2189     case 'T' : /* Top half.  */
2190       /* Output the argument to a `seth' insn (sets the Top half-word).
2191          For constants output arguments to a seth/or3 pair to set Top and
2192          Bottom halves.  For symbols output arguments to a seth/add3 pair to
2193          set Top and Bottom halves.  The difference exists because for
2194          constants seth/or3 is more readable but for symbols we need to use
2195          the same scheme as `ld' and `st' insns (16-bit addend is signed).  */
2196       switch (GET_CODE (x))
2197         {
2198         case CONST_INT :
2199         case CONST_DOUBLE :
2200           {
2201             rtx first, second;
2202
2203             split_double (x, &first, &second);
2204             x = WORDS_BIG_ENDIAN ? second : first;
2205             fprintf (file, HOST_WIDE_INT_PRINT_HEX,
2206                      (code == 'B'
2207                       ? INTVAL (x) & 0xffff
2208                       : (INTVAL (x) >> 16) & 0xffff));
2209           }
2210           return;
2211         case CONST :
2212         case SYMBOL_REF :
2213           if (code == 'B'
2214               && small_data_operand (x, VOIDmode))
2215             {
2216               fputs ("sda(", file);
2217               output_addr_const (file, x);
2218               fputc (')', file);
2219               return;
2220             }
2221           /* fall through */
2222         case LABEL_REF :
2223           fputs (code == 'T' ? "shigh(" : "low(", file);
2224           output_addr_const (file, x);
2225           fputc (')', file);
2226           return;
2227         default :
2228           output_operand_lossage ("invalid operand to %%T/%%B code");
2229           return;
2230         }
2231       break;
2232
2233     case 'U' :
2234       /* ??? wip */
2235       /* Output a load/store with update indicator if appropriate.  */
2236       if (MEM_P (x))
2237         {
2238           if (GET_CODE (XEXP (x, 0)) == PRE_INC
2239               || GET_CODE (XEXP (x, 0)) == PRE_DEC)
2240             fputs (".a", file);
2241         }
2242       else
2243         output_operand_lossage ("invalid operand to %%U code");
2244       return;
2245
2246     case 'N' :
2247       /* Print a constant value negated.  */
2248       if (CONST_INT_P (x))
2249         output_addr_const (file, GEN_INT (- INTVAL (x)));
2250       else
2251         output_operand_lossage ("invalid operand to %%N code");
2252       return;
2253
2254     case 'X' :
2255       /* Print a const_int in hex.  Used in comments.  */
2256       if (CONST_INT_P (x))
2257         fprintf (file, HOST_WIDE_INT_PRINT_HEX, INTVAL (x));
2258       return;
2259
2260     case '#' :
2261       fputs (IMMEDIATE_PREFIX, file);
2262       return;
2263
2264     case 0 :
2265       /* Do nothing special.  */
2266       break;
2267
2268     default :
2269       /* Unknown flag.  */
2270       output_operand_lossage ("invalid operand output code");
2271     }
2272
2273   switch (GET_CODE (x))
2274     {
2275     case REG :
2276       fputs (reg_names[REGNO (x)], file);
2277       break;
2278
2279     case MEM :
2280       addr = XEXP (x, 0);
2281       if (GET_CODE (addr) == PRE_INC)
2282         {
2283           if (!REG_P (XEXP (addr, 0)))
2284             fatal_insn ("pre-increment address is not a register", x);
2285
2286           fprintf (file, "@+%s", reg_names[REGNO (XEXP (addr, 0))]);
2287         }
2288       else if (GET_CODE (addr) == PRE_DEC)
2289         {
2290           if (!REG_P (XEXP (addr, 0)))
2291             fatal_insn ("pre-decrement address is not a register", x);
2292
2293           fprintf (file, "@-%s", reg_names[REGNO (XEXP (addr, 0))]);
2294         }
2295       else if (GET_CODE (addr) == POST_INC)
2296         {
2297           if (!REG_P (XEXP (addr, 0)))
2298             fatal_insn ("post-increment address is not a register", x);
2299
2300           fprintf (file, "@%s+", reg_names[REGNO (XEXP (addr, 0))]);
2301         }
2302       else
2303         {
2304           fputs ("@(", file);
2305           output_address (XEXP (x, 0));
2306           fputc (')', file);
2307         }
2308       break;
2309
2310     case CONST_DOUBLE :
2311       /* We handle SFmode constants here as output_addr_const doesn't.  */
2312       if (GET_MODE (x) == SFmode)
2313         {
2314           REAL_VALUE_TYPE d;
2315           long l;
2316
2317           REAL_VALUE_FROM_CONST_DOUBLE (d, x);
2318           REAL_VALUE_TO_TARGET_SINGLE (d, l);
2319           fprintf (file, "0x%08lx", l);
2320           break;
2321         }
2322
2323       /* Fall through.  Let output_addr_const deal with it.  */
2324
2325     default :
2326       output_addr_const (file, x);
2327       break;
2328     }
2329 }
2330
2331 /* Print a memory address as an operand to reference that memory location.  */
2332
2333 static void
2334 m32r_print_operand_address (FILE * file, rtx addr)
2335 {
2336   rtx base;
2337   rtx index = 0;
2338   int offset = 0;
2339
2340   switch (GET_CODE (addr))
2341     {
2342     case REG :
2343       fputs (reg_names[REGNO (addr)], file);
2344       break;
2345
2346     case PLUS :
2347       if (CONST_INT_P (XEXP (addr, 0)))
2348         offset = INTVAL (XEXP (addr, 0)), base = XEXP (addr, 1);
2349       else if (CONST_INT_P (XEXP (addr, 1)))
2350         offset = INTVAL (XEXP (addr, 1)), base = XEXP (addr, 0);
2351       else
2352         base = XEXP (addr, 0), index = XEXP (addr, 1);
2353       if (REG_P (base))
2354         {
2355           /* Print the offset first (if present) to conform to the manual.  */
2356           if (index == 0)
2357             {
2358               if (offset != 0)
2359                 fprintf (file, "%d,", offset);
2360               fputs (reg_names[REGNO (base)], file);
2361             }
2362           /* The chip doesn't support this, but left in for generality.  */
2363           else if (REG_P (index))
2364             fprintf (file, "%s,%s",
2365                      reg_names[REGNO (base)], reg_names[REGNO (index)]);
2366           /* Not sure this can happen, but leave in for now.  */
2367           else if (GET_CODE (index) == SYMBOL_REF)
2368             {
2369               output_addr_const (file, index);
2370               fputc (',', file);
2371               fputs (reg_names[REGNO (base)], file);
2372             }
2373           else
2374             fatal_insn ("bad address", addr);
2375         }
2376       else if (GET_CODE (base) == LO_SUM)
2377         {
2378           gcc_assert (!index && REG_P (XEXP (base, 0)));
2379           if (small_data_operand (XEXP (base, 1), VOIDmode))
2380             fputs ("sda(", file);
2381           else
2382             fputs ("low(", file);
2383           output_addr_const (file, plus_constant (XEXP (base, 1), offset));
2384           fputs ("),", file);
2385           fputs (reg_names[REGNO (XEXP (base, 0))], file);
2386         }
2387       else
2388         fatal_insn ("bad address", addr);
2389       break;
2390
2391     case LO_SUM :
2392       if (!REG_P (XEXP (addr, 0)))
2393         fatal_insn ("lo_sum not of register", addr);
2394       if (small_data_operand (XEXP (addr, 1), VOIDmode))
2395         fputs ("sda(", file);
2396       else
2397         fputs ("low(", file);
2398       output_addr_const (file, XEXP (addr, 1));
2399       fputs ("),", file);
2400       fputs (reg_names[REGNO (XEXP (addr, 0))], file);
2401       break;
2402
2403     case PRE_INC :      /* Assume SImode.  */
2404       fprintf (file, "+%s", reg_names[REGNO (XEXP (addr, 0))]);
2405       break;
2406
2407     case PRE_DEC :      /* Assume SImode.  */
2408       fprintf (file, "-%s", reg_names[REGNO (XEXP (addr, 0))]);
2409       break;
2410
2411     case POST_INC :     /* Assume SImode.  */
2412       fprintf (file, "%s+", reg_names[REGNO (XEXP (addr, 0))]);
2413       break;
2414
2415     default :
2416       output_addr_const (file, addr);
2417       break;
2418     }
2419 }
2420
2421 static bool
2422 m32r_print_operand_punct_valid_p (unsigned char code)
2423 {
2424   return m32r_punct_chars[code];
2425 }
2426
2427 /* Return true if the operands are the constants 0 and 1.  */
2428
2429 int
2430 zero_and_one (rtx operand1, rtx operand2)
2431 {
2432   return
2433        CONST_INT_P (operand1)
2434     && CONST_INT_P (operand2)
2435     && (  ((INTVAL (operand1) == 0) && (INTVAL (operand2) == 1))
2436         ||((INTVAL (operand1) == 1) && (INTVAL (operand2) == 0)));
2437 }
2438
2439 /* Generate the correct assembler code to handle the conditional loading of a
2440    value into a register.  It is known that the operands satisfy the
2441    conditional_move_operand() function above.  The destination is operand[0].
2442    The condition is operand [1].  The 'true' value is operand [2] and the
2443    'false' value is operand [3].  */
2444
2445 char *
2446 emit_cond_move (rtx * operands, rtx insn ATTRIBUTE_UNUSED)
2447 {
2448   static char buffer [100];
2449   const char * dest = reg_names [REGNO (operands [0])];
2450
2451   buffer [0] = 0;
2452
2453   /* Destination must be a register.  */
2454   gcc_assert (REG_P (operands [0]));
2455   gcc_assert (conditional_move_operand (operands [2], SImode));
2456   gcc_assert (conditional_move_operand (operands [3], SImode));
2457
2458   /* Check to see if the test is reversed.  */
2459   if (GET_CODE (operands [1]) == NE)
2460     {
2461       rtx tmp = operands [2];
2462       operands [2] = operands [3];
2463       operands [3] = tmp;
2464     }
2465
2466   sprintf (buffer, "mvfc %s, cbr", dest);
2467
2468   /* If the true value was '0' then we need to invert the results of the move.  */
2469   if (INTVAL (operands [2]) == 0)
2470     sprintf (buffer + strlen (buffer), "\n\txor3 %s, %s, #1",
2471              dest, dest);
2472
2473   return buffer;
2474 }
2475
2476 /* Returns true if the registers contained in the two
2477    rtl expressions are different.  */
2478
2479 int
2480 m32r_not_same_reg (rtx a, rtx b)
2481 {
2482   int reg_a = -1;
2483   int reg_b = -2;
2484
2485   while (GET_CODE (a) == SUBREG)
2486     a = SUBREG_REG (a);
2487
2488   if (REG_P (a))
2489     reg_a = REGNO (a);
2490
2491   while (GET_CODE (b) == SUBREG)
2492     b = SUBREG_REG (b);
2493
2494   if (REG_P (b))
2495     reg_b = REGNO (b);
2496
2497   return reg_a != reg_b;
2498 }
2499
2500 \f
2501 rtx
2502 m32r_function_symbol (const char *name)
2503 {
2504   int extra_flags = 0;
2505   enum m32r_model model;
2506   rtx sym = gen_rtx_SYMBOL_REF (Pmode, name);
2507
2508   if (TARGET_MODEL_SMALL)
2509     model = M32R_MODEL_SMALL;
2510   else if (TARGET_MODEL_MEDIUM)
2511     model = M32R_MODEL_MEDIUM;
2512   else if (TARGET_MODEL_LARGE)
2513     model = M32R_MODEL_LARGE;
2514   else
2515     gcc_unreachable (); /* Shouldn't happen.  */
2516   extra_flags |= model << SYMBOL_FLAG_MODEL_SHIFT;
2517
2518   if (extra_flags)
2519     SYMBOL_REF_FLAGS (sym) |= extra_flags;
2520
2521   return sym;
2522 }
2523
2524 /* Use a library function to move some bytes.  */
2525
2526 static void
2527 block_move_call (rtx dest_reg, rtx src_reg, rtx bytes_rtx)
2528 {
2529   /* We want to pass the size as Pmode, which will normally be SImode
2530      but will be DImode if we are using 64-bit longs and pointers.  */
2531   if (GET_MODE (bytes_rtx) != VOIDmode
2532       && GET_MODE (bytes_rtx) != Pmode)
2533     bytes_rtx = convert_to_mode (Pmode, bytes_rtx, 1);
2534
2535   emit_library_call (m32r_function_symbol ("memcpy"), LCT_NORMAL,
2536                      VOIDmode, 3, dest_reg, Pmode, src_reg, Pmode,
2537                      convert_to_mode (TYPE_MODE (sizetype), bytes_rtx,
2538                                       TYPE_UNSIGNED (sizetype)),
2539                      TYPE_MODE (sizetype));
2540 }
2541
2542 /* Expand string/block move operations.
2543
2544    operands[0] is the pointer to the destination.
2545    operands[1] is the pointer to the source.
2546    operands[2] is the number of bytes to move.
2547    operands[3] is the alignment.
2548
2549    Returns 1 upon success, 0 otherwise.  */
2550
2551 int
2552 m32r_expand_block_move (rtx operands[])
2553 {
2554   rtx           orig_dst  = operands[0];
2555   rtx           orig_src  = operands[1];
2556   rtx           bytes_rtx = operands[2];
2557   rtx           align_rtx = operands[3];
2558   int           constp    = CONST_INT_P (bytes_rtx);
2559   HOST_WIDE_INT bytes     = constp ? INTVAL (bytes_rtx) : 0;
2560   int           align     = INTVAL (align_rtx);
2561   int           leftover;
2562   rtx           src_reg;
2563   rtx           dst_reg;
2564
2565   if (constp && bytes <= 0)
2566     return 1;
2567
2568   /* Move the address into scratch registers.  */
2569   dst_reg = copy_addr_to_reg (XEXP (orig_dst, 0));
2570   src_reg = copy_addr_to_reg (XEXP (orig_src, 0));
2571
2572   if (align > UNITS_PER_WORD)
2573     align = UNITS_PER_WORD;
2574
2575   /* If we prefer size over speed, always use a function call.
2576      If we do not know the size, use a function call.
2577      If the blocks are not word aligned, use a function call.  */
2578   if (optimize_size || ! constp || align != UNITS_PER_WORD)
2579     {
2580       block_move_call (dst_reg, src_reg, bytes_rtx);
2581       return 0;
2582     }
2583
2584   leftover = bytes % MAX_MOVE_BYTES;
2585   bytes   -= leftover;
2586
2587   /* If necessary, generate a loop to handle the bulk of the copy.  */
2588   if (bytes)
2589     {
2590       rtx label = NULL_RTX;
2591       rtx final_src = NULL_RTX;
2592       rtx at_a_time = GEN_INT (MAX_MOVE_BYTES);
2593       rtx rounded_total = GEN_INT (bytes);
2594       rtx new_dst_reg = gen_reg_rtx (SImode);
2595       rtx new_src_reg = gen_reg_rtx (SImode);
2596
2597       /* If we are going to have to perform this loop more than
2598          once, then generate a label and compute the address the
2599          source register will contain upon completion of the final
2600          iteration.  */
2601       if (bytes > MAX_MOVE_BYTES)
2602         {
2603           final_src = gen_reg_rtx (Pmode);
2604
2605           if (INT16_P(bytes))
2606             emit_insn (gen_addsi3 (final_src, src_reg, rounded_total));
2607           else
2608             {
2609               emit_insn (gen_movsi (final_src, rounded_total));
2610               emit_insn (gen_addsi3 (final_src, final_src, src_reg));
2611             }
2612
2613           label = gen_label_rtx ();
2614           emit_label (label);
2615         }
2616
2617       /* It is known that output_block_move() will update src_reg to point
2618          to the word after the end of the source block, and dst_reg to point
2619          to the last word of the destination block, provided that the block
2620          is MAX_MOVE_BYTES long.  */
2621       emit_insn (gen_movmemsi_internal (dst_reg, src_reg, at_a_time,
2622                                         new_dst_reg, new_src_reg));
2623       emit_move_insn (dst_reg, new_dst_reg);
2624       emit_move_insn (src_reg, new_src_reg);
2625       emit_insn (gen_addsi3 (dst_reg, dst_reg, GEN_INT (4)));
2626
2627       if (bytes > MAX_MOVE_BYTES)
2628         {
2629           rtx test = gen_rtx_NE (VOIDmode, src_reg, final_src);
2630           emit_jump_insn (gen_cbranchsi4 (test, src_reg, final_src, label));
2631         }
2632     }
2633
2634   if (leftover)
2635     emit_insn (gen_movmemsi_internal (dst_reg, src_reg, GEN_INT (leftover),
2636                                       gen_reg_rtx (SImode),
2637                                       gen_reg_rtx (SImode)));
2638   return 1;
2639 }
2640
2641 \f
2642 /* Emit load/stores for a small constant word aligned block_move.
2643
2644    operands[0] is the memory address of the destination.
2645    operands[1] is the memory address of the source.
2646    operands[2] is the number of bytes to move.
2647    operands[3] is a temp register.
2648    operands[4] is a temp register.  */
2649
2650 void
2651 m32r_output_block_move (rtx insn ATTRIBUTE_UNUSED, rtx operands[])
2652 {
2653   HOST_WIDE_INT bytes = INTVAL (operands[2]);
2654   int           first_time;
2655   int           got_extra = 0;
2656
2657   gcc_assert (bytes >= 1 && bytes <= MAX_MOVE_BYTES);
2658
2659   /* We do not have a post-increment store available, so the first set of
2660      stores are done without any increment, then the remaining ones can use
2661      the pre-increment addressing mode.
2662
2663      Note: expand_block_move() also relies upon this behavior when building
2664      loops to copy large blocks.  */
2665   first_time = 1;
2666
2667   while (bytes > 0)
2668     {
2669       if (bytes >= 8)
2670         {
2671           if (first_time)
2672             {
2673               output_asm_insn ("ld\t%5, %p1", operands);
2674               output_asm_insn ("ld\t%6, %p1", operands);
2675               output_asm_insn ("st\t%5, @%0", operands);
2676               output_asm_insn ("st\t%6, %s0", operands);
2677             }
2678           else
2679             {
2680               output_asm_insn ("ld\t%5, %p1", operands);
2681               output_asm_insn ("ld\t%6, %p1", operands);
2682               output_asm_insn ("st\t%5, %s0", operands);
2683               output_asm_insn ("st\t%6, %s0", operands);
2684             }
2685
2686           bytes -= 8;
2687         }
2688       else if (bytes >= 4)
2689         {
2690           if (bytes > 4)
2691             got_extra = 1;
2692
2693           output_asm_insn ("ld\t%5, %p1", operands);
2694
2695           if (got_extra)
2696             output_asm_insn ("ld\t%6, %p1", operands);
2697
2698           if (first_time)
2699             output_asm_insn ("st\t%5, @%0", operands);
2700           else
2701             output_asm_insn ("st\t%5, %s0", operands);
2702
2703           bytes -= 4;
2704         }
2705       else
2706         {
2707           /* Get the entire next word, even though we do not want all of it.
2708              The saves us from doing several smaller loads, and we assume that
2709              we cannot cause a page fault when at least part of the word is in
2710              valid memory [since we don't get called if things aren't properly
2711              aligned].  */
2712           int dst_offset = first_time ? 0 : 4;
2713           /* The amount of increment we have to make to the
2714              destination pointer.  */
2715           int dst_inc_amount = dst_offset + bytes - 4;
2716           /* The same for the source pointer.  */
2717           int src_inc_amount = bytes;
2718           int last_shift;
2719           rtx my_operands[3];
2720
2721           /* If got_extra is true then we have already loaded
2722              the next word as part of loading and storing the previous word.  */
2723           if (! got_extra)
2724             output_asm_insn ("ld\t%6, @%1", operands);
2725
2726           if (bytes >= 2)
2727             {
2728               bytes -= 2;
2729
2730               output_asm_insn ("sra3\t%5, %6, #16", operands);
2731               my_operands[0] = operands[5];
2732               my_operands[1] = GEN_INT (dst_offset);
2733               my_operands[2] = operands[0];
2734               output_asm_insn ("sth\t%0, @(%1,%2)", my_operands);
2735
2736               /* If there is a byte left to store then increment the
2737                  destination address and shift the contents of the source
2738                  register down by 8 bits.  We could not do the address
2739                  increment in the store half word instruction, because it does
2740                  not have an auto increment mode.  */
2741               if (bytes > 0)  /* assert (bytes == 1) */
2742                 {
2743                   dst_offset += 2;
2744                   last_shift = 8;
2745                 }
2746             }
2747           else
2748             last_shift = 24;
2749
2750           if (bytes > 0)
2751             {
2752               my_operands[0] = operands[6];
2753               my_operands[1] = GEN_INT (last_shift);
2754               output_asm_insn ("srai\t%0, #%1", my_operands);
2755               my_operands[0] = operands[6];
2756               my_operands[1] = GEN_INT (dst_offset);
2757               my_operands[2] = operands[0];
2758               output_asm_insn ("stb\t%0, @(%1,%2)", my_operands);
2759             }
2760
2761           /* Update the destination pointer if needed.  We have to do
2762              this so that the patterns matches what we output in this
2763              function.  */
2764           if (dst_inc_amount
2765               && !find_reg_note (insn, REG_UNUSED, operands[0]))
2766             {
2767               my_operands[0] = operands[0];
2768               my_operands[1] = GEN_INT (dst_inc_amount);
2769               output_asm_insn ("addi\t%0, #%1", my_operands);
2770             }
2771
2772           /* Update the source pointer if needed.  We have to do this
2773              so that the patterns matches what we output in this
2774              function.  */
2775           if (src_inc_amount
2776               && !find_reg_note (insn, REG_UNUSED, operands[1]))
2777             {
2778               my_operands[0] = operands[1];
2779               my_operands[1] = GEN_INT (src_inc_amount);
2780               output_asm_insn ("addi\t%0, #%1", my_operands);
2781             }
2782
2783           bytes = 0;
2784         }
2785
2786       first_time = 0;
2787     }
2788 }
2789
2790 /* Return true if using NEW_REG in place of OLD_REG is ok.  */
2791
2792 int
2793 m32r_hard_regno_rename_ok (unsigned int old_reg ATTRIBUTE_UNUSED,
2794                            unsigned int new_reg)
2795 {
2796   /* Interrupt routines can't clobber any register that isn't already used.  */
2797   if (lookup_attribute ("interrupt", DECL_ATTRIBUTES (current_function_decl))
2798       && !df_regs_ever_live_p (new_reg))
2799     return 0;
2800
2801   return 1;
2802 }
2803
2804 rtx
2805 m32r_return_addr (int count)
2806 {
2807   if (count != 0)
2808     return const0_rtx;
2809
2810   return get_hard_reg_initial_val (Pmode, RETURN_ADDR_REGNUM);
2811 }
2812
2813 static void
2814 m32r_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value)
2815 {
2816   emit_move_insn (adjust_address (m_tramp, SImode, 0),
2817                   gen_int_mode (TARGET_LITTLE_ENDIAN ?
2818                                 0x017e8e17 : 0x178e7e01, SImode));
2819   emit_move_insn (adjust_address (m_tramp, SImode, 4),
2820                   gen_int_mode (TARGET_LITTLE_ENDIAN ?
2821                                 0x0c00ae86 : 0x86ae000c, SImode));
2822   emit_move_insn (adjust_address (m_tramp, SImode, 8),
2823                   gen_int_mode (TARGET_LITTLE_ENDIAN ?
2824                                 0xe627871e : 0x1e8727e6, SImode));
2825   emit_move_insn (adjust_address (m_tramp, SImode, 12),
2826                   gen_int_mode (TARGET_LITTLE_ENDIAN ?
2827                                 0xc616c626 : 0x26c61fc6, SImode));
2828   emit_move_insn (adjust_address (m_tramp, SImode, 16),
2829                   chain_value);
2830   emit_move_insn (adjust_address (m_tramp, SImode, 20),
2831                   XEXP (DECL_RTL (fndecl), 0));
2832
2833   if (m32r_cache_flush_trap >= 0)
2834     emit_insn (gen_flush_icache
2835                (validize_mem (adjust_address (m_tramp, SImode, 0)),
2836                 gen_int_mode (m32r_cache_flush_trap, SImode)));
2837   else if (m32r_cache_flush_func && m32r_cache_flush_func[0])
2838     emit_library_call (m32r_function_symbol (m32r_cache_flush_func),
2839                        LCT_NORMAL, VOIDmode, 3, XEXP (m_tramp, 0), Pmode,
2840                        gen_int_mode (TRAMPOLINE_SIZE, SImode), SImode,
2841                        GEN_INT (3), SImode);
2842 }
2843
2844 static void
2845 m32r_conditional_register_usage (void)
2846 {
2847   if (flag_pic)
2848     {
2849       fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1;
2850       call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1;
2851     }
2852 }