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