OSDN Git Service

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