1 /* Subroutines for insn-output.c for Renesas H8/300.
2 Copyright (C) 1992-2015 Free Software Foundation, Inc.
3 Contributed by Steve Chamberlain (sac@cygnus.com),
4 Jim Wilson (wilson@cygnus.com), and Doug Evans (dje@cygnus.com).
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
30 #include "double-int.h"
37 #include "stor-layout.h"
40 #include "stringpool.h"
42 #include "hard-reg-set.h"
43 #include "insn-config.h"
44 #include "conditions.h"
46 #include "insn-attr.h"
51 #include "statistics.h"
53 #include "fixed-value.h"
60 #include "insn-codes.h"
62 #include "diagnostic-core.h"
63 #include "c-family/c-pragma.h" /* ??? */
65 #include "tm-constrs.h"
68 #include "target-def.h"
69 #include "dominance.h"
75 #include "cfgcleanup.h"
77 #include "basic-block.h"
81 /* Classifies a h8300_src_operand or h8300_dst_operand.
84 A constant operand of some sort.
90 A memory reference with a constant address.
93 A memory reference with a register as its address.
96 Some other kind of memory reference. */
97 enum h8300_operand_class
107 /* For a general two-operand instruction, element [X][Y] gives
108 the length of the opcode fields when the first operand has class
109 (X + 1) and the second has class Y. */
110 typedef unsigned char h8300_length_table
[NUM_H8OPS
- 1][NUM_H8OPS
];
112 /* Forward declarations. */
113 static const char *byte_reg (rtx
, int);
114 static int h8300_interrupt_function_p (tree
);
115 static int h8300_saveall_function_p (tree
);
116 static int h8300_monitor_function_p (tree
);
117 static int h8300_os_task_function_p (tree
);
118 static void h8300_emit_stack_adjustment (int, HOST_WIDE_INT
, bool);
119 static HOST_WIDE_INT
round_frame_size (HOST_WIDE_INT
);
120 static unsigned int compute_saved_regs (void);
121 static const char *cond_string (enum rtx_code
);
122 static unsigned int h8300_asm_insn_count (const char *);
123 static tree
h8300_handle_fndecl_attribute (tree
*, tree
, tree
, int, bool *);
124 static tree
h8300_handle_eightbit_data_attribute (tree
*, tree
, tree
, int, bool *);
125 static tree
h8300_handle_tiny_data_attribute (tree
*, tree
, tree
, int, bool *);
126 static void h8300_print_operand_address (FILE *, rtx
);
127 static void h8300_print_operand (FILE *, rtx
, int);
128 static bool h8300_print_operand_punct_valid_p (unsigned char code
);
129 #ifndef OBJECT_FORMAT_ELF
130 static void h8300_asm_named_section (const char *, unsigned int, tree
);
132 static int h8300_register_move_cost (machine_mode
, reg_class_t
, reg_class_t
);
133 static int h8300_and_costs (rtx
);
134 static int h8300_shift_costs (rtx
);
135 static void h8300_push_pop (int, int, bool, bool);
136 static int h8300_stack_offset_p (rtx
, int);
137 static int h8300_ldm_stm_regno (rtx
, int, int, int);
138 static void h8300_reorg (void);
139 static unsigned int h8300_constant_length (rtx
);
140 static unsigned int h8300_displacement_length (rtx
, int);
141 static unsigned int h8300_classify_operand (rtx
, int, enum h8300_operand_class
*);
142 static unsigned int h8300_length_from_table (rtx
, rtx
, const h8300_length_table
*);
143 static unsigned int h8300_unary_length (rtx
);
144 static unsigned int h8300_short_immediate_length (rtx
);
145 static unsigned int h8300_bitfield_length (rtx
, rtx
);
146 static unsigned int h8300_binary_length (rtx_insn
*, const h8300_length_table
*);
147 static bool h8300_short_move_mem_p (rtx
, enum rtx_code
);
148 static unsigned int h8300_move_length (rtx
*, const h8300_length_table
*);
149 static bool h8300_hard_regno_scratch_ok (unsigned int);
150 static rtx
h8300_get_index (rtx
, machine_mode mode
, int *);
152 /* CPU_TYPE, says what cpu we're compiling for. */
155 /* True if a #pragma interrupt has been seen for the current function. */
156 static int pragma_interrupt
;
158 /* True if a #pragma saveall has been seen for the current function. */
159 static int pragma_saveall
;
161 static const char *const names_big
[] =
162 { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7" };
164 static const char *const names_extended
[] =
165 { "er0", "er1", "er2", "er3", "er4", "er5", "er6", "er7" };
167 static const char *const names_upper_extended
[] =
168 { "e0", "e1", "e2", "e3", "e4", "e5", "e6", "e7" };
170 /* Points to one of the above. */
171 /* ??? The above could be put in an array indexed by CPU_TYPE. */
172 const char * const *h8_reg_names
;
174 /* Various operations needed by the following, indexed by CPU_TYPE. */
176 const char *h8_push_op
, *h8_pop_op
, *h8_mov_op
;
178 /* Value of MOVE_RATIO. */
179 int h8300_move_ratio
;
181 /* See below where shifts are handled for explanation of this enum. */
191 /* Symbols of the various shifts which can be used as indices. */
195 SHIFT_ASHIFT
, SHIFT_LSHIFTRT
, SHIFT_ASHIFTRT
198 /* Macros to keep the shift algorithm tables small. */
199 #define INL SHIFT_INLINE
200 #define ROT SHIFT_ROT_AND
201 #define LOP SHIFT_LOOP
202 #define SPC SHIFT_SPECIAL
204 /* The shift algorithms for each machine, mode, shift type, and shift
205 count are defined below. The three tables below correspond to
206 QImode, HImode, and SImode, respectively. Each table is organized
207 by, in the order of indices, machine, shift type, and shift count. */
209 static enum shift_alg shift_alg_qi
[3][3][8] = {
212 /* 0 1 2 3 4 5 6 7 */
213 { INL
, INL
, INL
, INL
, INL
, ROT
, ROT
, ROT
}, /* SHIFT_ASHIFT */
214 { INL
, INL
, INL
, INL
, INL
, ROT
, ROT
, ROT
}, /* SHIFT_LSHIFTRT */
215 { INL
, INL
, INL
, INL
, INL
, LOP
, LOP
, SPC
} /* SHIFT_ASHIFTRT */
219 /* 0 1 2 3 4 5 6 7 */
220 { INL
, INL
, INL
, INL
, INL
, ROT
, ROT
, ROT
}, /* SHIFT_ASHIFT */
221 { INL
, INL
, INL
, INL
, INL
, ROT
, ROT
, ROT
}, /* SHIFT_LSHIFTRT */
222 { INL
, INL
, INL
, INL
, INL
, LOP
, LOP
, SPC
} /* SHIFT_ASHIFTRT */
226 /* 0 1 2 3 4 5 6 7 */
227 { INL
, INL
, INL
, INL
, INL
, INL
, ROT
, ROT
}, /* SHIFT_ASHIFT */
228 { INL
, INL
, INL
, INL
, INL
, INL
, ROT
, ROT
}, /* SHIFT_LSHIFTRT */
229 { INL
, INL
, INL
, INL
, INL
, INL
, INL
, SPC
} /* SHIFT_ASHIFTRT */
233 static enum shift_alg shift_alg_hi
[3][3][16] = {
236 /* 0 1 2 3 4 5 6 7 */
237 /* 8 9 10 11 12 13 14 15 */
238 { INL
, INL
, INL
, INL
, INL
, INL
, INL
, SPC
,
239 SPC
, SPC
, SPC
, SPC
, SPC
, SPC
, SPC
, SPC
}, /* SHIFT_ASHIFT */
240 { INL
, INL
, INL
, INL
, INL
, LOP
, LOP
, SPC
,
241 SPC
, SPC
, SPC
, SPC
, SPC
, SPC
, SPC
, SPC
}, /* SHIFT_LSHIFTRT */
242 { INL
, INL
, INL
, INL
, INL
, LOP
, LOP
, SPC
,
243 SPC
, SPC
, SPC
, SPC
, SPC
, SPC
, SPC
, SPC
}, /* SHIFT_ASHIFTRT */
247 /* 0 1 2 3 4 5 6 7 */
248 /* 8 9 10 11 12 13 14 15 */
249 { INL
, INL
, INL
, INL
, INL
, INL
, INL
, SPC
,
250 SPC
, SPC
, SPC
, SPC
, SPC
, ROT
, ROT
, ROT
}, /* SHIFT_ASHIFT */
251 { INL
, INL
, INL
, INL
, INL
, INL
, INL
, SPC
,
252 SPC
, SPC
, SPC
, SPC
, SPC
, ROT
, ROT
, ROT
}, /* SHIFT_LSHIFTRT */
253 { INL
, INL
, INL
, INL
, INL
, INL
, INL
, SPC
,
254 SPC
, SPC
, SPC
, SPC
, SPC
, SPC
, SPC
, SPC
}, /* SHIFT_ASHIFTRT */
258 /* 0 1 2 3 4 5 6 7 */
259 /* 8 9 10 11 12 13 14 15 */
260 { INL
, INL
, INL
, INL
, INL
, INL
, INL
, INL
,
261 SPC
, SPC
, SPC
, SPC
, SPC
, ROT
, ROT
, ROT
}, /* SHIFT_ASHIFT */
262 { INL
, INL
, INL
, INL
, INL
, INL
, INL
, INL
,
263 SPC
, SPC
, SPC
, SPC
, SPC
, ROT
, ROT
, ROT
}, /* SHIFT_LSHIFTRT */
264 { INL
, INL
, INL
, INL
, INL
, INL
, INL
, INL
,
265 SPC
, SPC
, SPC
, SPC
, SPC
, SPC
, SPC
, SPC
}, /* SHIFT_ASHIFTRT */
269 static enum shift_alg shift_alg_si
[3][3][32] = {
272 /* 0 1 2 3 4 5 6 7 */
273 /* 8 9 10 11 12 13 14 15 */
274 /* 16 17 18 19 20 21 22 23 */
275 /* 24 25 26 27 28 29 30 31 */
276 { INL
, INL
, INL
, LOP
, LOP
, LOP
, LOP
, LOP
,
277 SPC
, LOP
, LOP
, LOP
, LOP
, LOP
, LOP
, LOP
,
278 SPC
, SPC
, SPC
, SPC
, SPC
, LOP
, LOP
, LOP
,
279 SPC
, SPC
, SPC
, SPC
, LOP
, LOP
, LOP
, SPC
}, /* SHIFT_ASHIFT */
280 { INL
, INL
, INL
, LOP
, LOP
, LOP
, LOP
, LOP
,
281 SPC
, SPC
, LOP
, LOP
, LOP
, LOP
, LOP
, SPC
,
282 SPC
, SPC
, SPC
, LOP
, LOP
, LOP
, LOP
, LOP
,
283 SPC
, SPC
, SPC
, SPC
, SPC
, LOP
, LOP
, SPC
}, /* SHIFT_LSHIFTRT */
284 { INL
, INL
, INL
, LOP
, LOP
, LOP
, LOP
, LOP
,
285 SPC
, LOP
, LOP
, LOP
, LOP
, LOP
, LOP
, SPC
,
286 SPC
, SPC
, LOP
, LOP
, LOP
, LOP
, LOP
, LOP
,
287 SPC
, SPC
, SPC
, LOP
, LOP
, LOP
, LOP
, SPC
}, /* SHIFT_ASHIFTRT */
291 /* 0 1 2 3 4 5 6 7 */
292 /* 8 9 10 11 12 13 14 15 */
293 /* 16 17 18 19 20 21 22 23 */
294 /* 24 25 26 27 28 29 30 31 */
295 { INL
, INL
, INL
, INL
, INL
, LOP
, LOP
, LOP
,
296 SPC
, LOP
, LOP
, LOP
, LOP
, LOP
, LOP
, SPC
,
297 SPC
, SPC
, SPC
, SPC
, LOP
, LOP
, LOP
, LOP
,
298 SPC
, LOP
, LOP
, LOP
, SPC
, SPC
, SPC
, SPC
}, /* SHIFT_ASHIFT */
299 { INL
, INL
, INL
, INL
, INL
, LOP
, LOP
, LOP
,
300 SPC
, LOP
, LOP
, LOP
, LOP
, LOP
, LOP
, SPC
,
301 SPC
, SPC
, SPC
, SPC
, LOP
, LOP
, LOP
, LOP
,
302 SPC
, LOP
, LOP
, LOP
, SPC
, SPC
, SPC
, SPC
}, /* SHIFT_LSHIFTRT */
303 { INL
, INL
, INL
, INL
, INL
, LOP
, LOP
, LOP
,
304 SPC
, LOP
, LOP
, LOP
, LOP
, LOP
, LOP
, LOP
,
305 SPC
, SPC
, SPC
, SPC
, LOP
, LOP
, LOP
, LOP
,
306 SPC
, LOP
, LOP
, LOP
, LOP
, LOP
, LOP
, SPC
}, /* SHIFT_ASHIFTRT */
310 /* 0 1 2 3 4 5 6 7 */
311 /* 8 9 10 11 12 13 14 15 */
312 /* 16 17 18 19 20 21 22 23 */
313 /* 24 25 26 27 28 29 30 31 */
314 { INL
, INL
, INL
, INL
, INL
, INL
, INL
, INL
,
315 INL
, INL
, INL
, LOP
, LOP
, LOP
, LOP
, SPC
,
316 SPC
, SPC
, SPC
, SPC
, SPC
, SPC
, LOP
, LOP
,
317 SPC
, SPC
, LOP
, LOP
, SPC
, SPC
, SPC
, SPC
}, /* SHIFT_ASHIFT */
318 { INL
, INL
, INL
, INL
, INL
, INL
, INL
, INL
,
319 INL
, INL
, INL
, LOP
, LOP
, LOP
, LOP
, SPC
,
320 SPC
, SPC
, SPC
, SPC
, SPC
, SPC
, LOP
, LOP
,
321 SPC
, SPC
, LOP
, LOP
, SPC
, SPC
, SPC
, SPC
}, /* SHIFT_LSHIFTRT */
322 { INL
, INL
, INL
, INL
, INL
, INL
, INL
, INL
,
323 INL
, INL
, INL
, LOP
, LOP
, LOP
, LOP
, LOP
,
324 SPC
, SPC
, SPC
, SPC
, SPC
, SPC
, LOP
, LOP
,
325 SPC
, SPC
, LOP
, LOP
, LOP
, LOP
, LOP
, SPC
}, /* SHIFT_ASHIFTRT */
341 /* Initialize various cpu specific globals at start up. */
344 h8300_option_override (void)
346 static const char *const h8_push_ops
[2] = { "push" , "push.l" };
347 static const char *const h8_pop_ops
[2] = { "pop" , "pop.l" };
348 static const char *const h8_mov_ops
[2] = { "mov.w", "mov.l" };
350 #ifndef OBJECT_FORMAT_ELF
353 error ("-msx is not supported in coff");
354 target_flags
|= MASK_H8300S
;
360 cpu_type
= (int) CPU_H8300
;
361 h8_reg_names
= names_big
;
365 /* For this we treat the H8/300H and H8S the same. */
366 cpu_type
= (int) CPU_H8300H
;
367 h8_reg_names
= names_extended
;
369 h8_push_op
= h8_push_ops
[cpu_type
];
370 h8_pop_op
= h8_pop_ops
[cpu_type
];
371 h8_mov_op
= h8_mov_ops
[cpu_type
];
373 if (!TARGET_H8300S
&& TARGET_MAC
)
375 error ("-ms2600 is used without -ms");
376 target_flags
|= MASK_H8300S_1
;
379 if (TARGET_H8300
&& TARGET_NORMAL_MODE
)
381 error ("-mn is used without -mh or -ms or -msx");
382 target_flags
^= MASK_NORMAL_MODE
;
385 if (! TARGET_H8300S
&& TARGET_EXR
)
387 error ("-mexr is used without -ms");
388 target_flags
|= MASK_H8300S_1
;
391 if (TARGET_H8300
&& TARGET_INT32
)
393 error ("-mint32 is not supported for H8300 and H8300L targets");
394 target_flags
^= MASK_INT32
;
397 if ((!TARGET_H8300S
&& TARGET_EXR
) && (!TARGET_H8300SX
&& TARGET_EXR
))
399 error ("-mexr is used without -ms or -msx");
400 target_flags
|= MASK_H8300S_1
;
403 if ((!TARGET_H8300S
&& TARGET_NEXR
) && (!TARGET_H8300SX
&& TARGET_NEXR
))
405 warning (OPT_mno_exr
, "-mno-exr valid only with -ms or -msx \
409 /* Some of the shifts are optimized for speed by default.
410 See http://gcc.gnu.org/ml/gcc-patches/2002-07/msg01858.html
411 If optimizing for size, change shift_alg for those shift to
416 shift_alg_hi
[H8_300
][SHIFT_ASHIFT
][5] = SHIFT_LOOP
;
417 shift_alg_hi
[H8_300
][SHIFT_ASHIFT
][6] = SHIFT_LOOP
;
418 shift_alg_hi
[H8_300
][SHIFT_ASHIFT
][13] = SHIFT_LOOP
;
419 shift_alg_hi
[H8_300
][SHIFT_ASHIFT
][14] = SHIFT_LOOP
;
421 shift_alg_hi
[H8_300
][SHIFT_LSHIFTRT
][13] = SHIFT_LOOP
;
422 shift_alg_hi
[H8_300
][SHIFT_LSHIFTRT
][14] = SHIFT_LOOP
;
424 shift_alg_hi
[H8_300
][SHIFT_ASHIFTRT
][13] = SHIFT_LOOP
;
425 shift_alg_hi
[H8_300
][SHIFT_ASHIFTRT
][14] = SHIFT_LOOP
;
428 shift_alg_hi
[H8_300H
][SHIFT_ASHIFT
][5] = SHIFT_LOOP
;
429 shift_alg_hi
[H8_300H
][SHIFT_ASHIFT
][6] = SHIFT_LOOP
;
431 shift_alg_hi
[H8_300H
][SHIFT_LSHIFTRT
][5] = SHIFT_LOOP
;
432 shift_alg_hi
[H8_300H
][SHIFT_LSHIFTRT
][6] = SHIFT_LOOP
;
434 shift_alg_hi
[H8_300H
][SHIFT_ASHIFTRT
][5] = SHIFT_LOOP
;
435 shift_alg_hi
[H8_300H
][SHIFT_ASHIFTRT
][6] = SHIFT_LOOP
;
436 shift_alg_hi
[H8_300H
][SHIFT_ASHIFTRT
][13] = SHIFT_LOOP
;
437 shift_alg_hi
[H8_300H
][SHIFT_ASHIFTRT
][14] = SHIFT_LOOP
;
440 shift_alg_hi
[H8_S
][SHIFT_ASHIFTRT
][14] = SHIFT_LOOP
;
443 /* Work out a value for MOVE_RATIO. */
446 /* Memory-memory moves are quite expensive without the
447 h8sx instructions. */
448 h8300_move_ratio
= 3;
450 else if (flag_omit_frame_pointer
)
452 /* movmd sequences are fairly cheap when er6 isn't fixed. They can
453 sometimes be as short as two individual memory-to-memory moves,
454 but since they use all the call-saved registers, it seems better
455 to allow up to three moves here. */
456 h8300_move_ratio
= 4;
458 else if (optimize_size
)
460 /* In this case we don't use movmd sequences since they tend
461 to be longer than calls to memcpy(). Memory-to-memory
462 moves are cheaper than for !TARGET_H8300SX, so it makes
463 sense to have a slightly higher threshold. */
464 h8300_move_ratio
= 4;
468 /* We use movmd sequences for some moves since it can be quicker
469 than calling memcpy(). The sequences will need to save and
470 restore er6 though, so bump up the cost. */
471 h8300_move_ratio
= 6;
474 /* This target defaults to strict volatile bitfields. */
475 if (flag_strict_volatile_bitfields
< 0 && abi_version_at_least(2))
476 flag_strict_volatile_bitfields
= 1;
479 /* Return the byte register name for a register rtx X. B should be 0
480 if you want a lower byte register. B should be 1 if you want an
481 upper byte register. */
484 byte_reg (rtx x
, int b
)
486 static const char *const names_small
[] = {
487 "r0l", "r0h", "r1l", "r1h", "r2l", "r2h", "r3l", "r3h",
488 "r4l", "r4h", "r5l", "r5h", "r6l", "r6h", "r7l", "r7h"
491 gcc_assert (REG_P (x
));
493 return names_small
[REGNO (x
) * 2 + b
];
496 /* REGNO must be saved/restored across calls if this macro is true. */
498 #define WORD_REG_USED(regno) \
500 /* No need to save registers if this function will not return. */ \
501 && ! TREE_THIS_VOLATILE (current_function_decl) \
502 && (h8300_saveall_function_p (current_function_decl) \
503 /* Save any call saved register that was used. */ \
504 || (df_regs_ever_live_p (regno) && !call_used_regs[regno]) \
505 /* Save the frame pointer if it was used. */ \
506 || (regno == HARD_FRAME_POINTER_REGNUM && df_regs_ever_live_p (regno)) \
507 /* Save any register used in an interrupt handler. */ \
508 || (h8300_current_function_interrupt_function_p () \
509 && df_regs_ever_live_p (regno)) \
510 /* Save call clobbered registers in non-leaf interrupt \
512 || (h8300_current_function_interrupt_function_p () \
513 && call_used_regs[regno] \
516 /* We use this to wrap all emitted insns in the prologue. */
518 F (rtx_insn
*x
, bool set_it
)
521 RTX_FRAME_RELATED_P (x
) = 1;
525 /* Mark all the subexpressions of the PARALLEL rtx PAR as
526 frame-related. Return PAR.
528 dwarf2out.c:dwarf2out_frame_debug_expr ignores sub-expressions of a
529 PARALLEL rtx other than the first if they do not have the
530 FRAME_RELATED flag set on them. */
534 int len
= XVECLEN (par
, 0);
537 for (i
= 0; i
< len
; i
++)
538 RTX_FRAME_RELATED_P (XVECEXP (par
, 0, i
)) = 1;
543 /* Output assembly language to FILE for the operation OP with operand size
544 SIZE to adjust the stack pointer. */
547 h8300_emit_stack_adjustment (int sign
, HOST_WIDE_INT size
, bool in_prologue
)
549 /* If the frame size is 0, we don't have anything to do. */
553 /* H8/300 cannot add/subtract a large constant with a single
554 instruction. If a temporary register is available, load the
555 constant to it and then do the addition. */
558 && !h8300_current_function_interrupt_function_p ()
559 && !(cfun
->static_chain_decl
!= NULL
&& sign
< 0))
561 rtx r3
= gen_rtx_REG (Pmode
, 3);
562 F (emit_insn (gen_movhi (r3
, GEN_INT (sign
* size
))), in_prologue
);
563 F (emit_insn (gen_addhi3 (stack_pointer_rtx
,
564 stack_pointer_rtx
, r3
)), in_prologue
);
568 /* The stack adjustment made here is further optimized by the
569 splitter. In case of H8/300, the splitter always splits the
570 addition emitted here to make the adjustment interrupt-safe.
571 FIXME: We don't always tag those, because we don't know what
572 the splitter will do. */
575 rtx_insn
*x
= emit_insn (gen_addhi3 (stack_pointer_rtx
,
577 GEN_INT (sign
* size
)));
582 F (emit_insn (gen_addsi3 (stack_pointer_rtx
,
583 stack_pointer_rtx
, GEN_INT (sign
* size
))), in_prologue
);
587 /* Round up frame size SIZE. */
590 round_frame_size (HOST_WIDE_INT size
)
592 return ((size
+ STACK_BOUNDARY
/ BITS_PER_UNIT
- 1)
593 & -STACK_BOUNDARY
/ BITS_PER_UNIT
);
596 /* Compute which registers to push/pop.
597 Return a bit vector of registers. */
600 compute_saved_regs (void)
602 unsigned int saved_regs
= 0;
605 /* Construct a bit vector of registers to be pushed/popped. */
606 for (regno
= 0; regno
<= HARD_FRAME_POINTER_REGNUM
; regno
++)
608 if (WORD_REG_USED (regno
))
609 saved_regs
|= 1 << regno
;
612 /* Don't push/pop the frame pointer as it is treated separately. */
613 if (frame_pointer_needed
)
614 saved_regs
&= ~(1 << HARD_FRAME_POINTER_REGNUM
);
619 /* Emit an insn to push register RN. */
624 rtx reg
= gen_rtx_REG (word_mode
, rn
);
628 x
= gen_push_h8300 (reg
);
629 else if (!TARGET_NORMAL_MODE
)
630 x
= gen_push_h8300hs_advanced (reg
);
632 x
= gen_push_h8300hs_normal (reg
);
633 x
= F (emit_insn (x
), true);
634 add_reg_note (x
, REG_INC
, stack_pointer_rtx
);
638 /* Emit an insn to pop register RN. */
643 rtx reg
= gen_rtx_REG (word_mode
, rn
);
647 x
= gen_pop_h8300 (reg
);
648 else if (!TARGET_NORMAL_MODE
)
649 x
= gen_pop_h8300hs_advanced (reg
);
651 x
= gen_pop_h8300hs_normal (reg
);
653 add_reg_note (x
, REG_INC
, stack_pointer_rtx
);
657 /* Emit an instruction to push or pop NREGS consecutive registers
658 starting at register REGNO. POP_P selects a pop rather than a
659 push and RETURN_P is true if the instruction should return.
661 It must be possible to do the requested operation in a single
662 instruction. If NREGS == 1 && !RETURN_P, use a normal push
663 or pop insn. Otherwise emit a parallel of the form:
666 [(return) ;; if RETURN_P
667 (save or restore REGNO)
668 (save or restore REGNO + 1)
670 (save or restore REGNO + NREGS - 1)
671 (set sp (plus sp (const_int adjust)))] */
674 h8300_push_pop (int regno
, int nregs
, bool pop_p
, bool return_p
)
680 /* See whether we can use a simple push or pop. */
681 if (!return_p
&& nregs
== 1)
690 /* We need one element for the return insn, if present, one for each
691 register, and one for stack adjustment. */
692 vec
= rtvec_alloc ((return_p
? 1 : 0) + nregs
+ 1);
693 sp
= stack_pointer_rtx
;
696 /* Add the return instruction. */
699 RTVEC_ELT (vec
, i
) = ret_rtx
;
703 /* Add the register moves. */
704 for (j
= 0; j
< nregs
; j
++)
710 /* Register REGNO + NREGS - 1 is popped first. Before the
711 stack adjustment, its slot is at address @sp. */
712 lhs
= gen_rtx_REG (SImode
, regno
+ j
);
713 rhs
= gen_rtx_MEM (SImode
, plus_constant (Pmode
, sp
,
714 (nregs
- j
- 1) * 4));
718 /* Register REGNO is pushed first and will be stored at @(-4,sp). */
719 lhs
= gen_rtx_MEM (SImode
, plus_constant (Pmode
, sp
, (j
+ 1) * -4));
720 rhs
= gen_rtx_REG (SImode
, regno
+ j
);
722 RTVEC_ELT (vec
, i
+ j
) = gen_rtx_SET (VOIDmode
, lhs
, rhs
);
725 /* Add the stack adjustment. */
726 offset
= GEN_INT ((pop_p
? nregs
: -nregs
) * 4);
727 RTVEC_ELT (vec
, i
+ j
) = gen_rtx_SET (VOIDmode
, sp
,
728 gen_rtx_PLUS (Pmode
, sp
, offset
));
730 x
= gen_rtx_PARALLEL (VOIDmode
, vec
);
740 /* Return true if X has the value sp + OFFSET. */
743 h8300_stack_offset_p (rtx x
, int offset
)
746 return x
== stack_pointer_rtx
;
748 return (GET_CODE (x
) == PLUS
749 && XEXP (x
, 0) == stack_pointer_rtx
750 && GET_CODE (XEXP (x
, 1)) == CONST_INT
751 && INTVAL (XEXP (x
, 1)) == offset
);
754 /* A subroutine of h8300_ldm_stm_parallel. X is one pattern in
755 something that may be an ldm or stm instruction. If it fits
756 the required template, return the register it loads or stores,
759 LOAD_P is true if X should be a load, false if it should be a store.
760 NREGS is the number of registers that the whole instruction is expected
761 to load or store. INDEX is the index of the register that X should
762 load or store, relative to the lowest-numbered register. */
765 h8300_ldm_stm_regno (rtx x
, int load_p
, int index
, int nregs
)
767 int regindex
, memindex
, offset
;
770 regindex
= 0, memindex
= 1, offset
= (nregs
- index
- 1) * 4;
772 memindex
= 0, regindex
= 1, offset
= (index
+ 1) * -4;
774 if (GET_CODE (x
) == SET
775 && GET_CODE (XEXP (x
, regindex
)) == REG
776 && GET_CODE (XEXP (x
, memindex
)) == MEM
777 && h8300_stack_offset_p (XEXP (XEXP (x
, memindex
), 0), offset
))
778 return REGNO (XEXP (x
, regindex
));
783 /* Return true if the elements of VEC starting at FIRST describe an
784 ldm or stm instruction (LOAD_P says which). */
787 h8300_ldm_stm_parallel (rtvec vec
, int load_p
, int first
)
790 int nregs
, i
, regno
, adjust
;
792 /* There must be a stack adjustment, a register move, and at least one
793 other operation (a return or another register move). */
794 if (GET_NUM_ELEM (vec
) < 3)
797 /* Get the range of registers to be pushed or popped. */
798 nregs
= GET_NUM_ELEM (vec
) - first
- 1;
799 regno
= h8300_ldm_stm_regno (RTVEC_ELT (vec
, first
), load_p
, 0, nregs
);
801 /* Check that the call to h8300_ldm_stm_regno succeeded and
802 that we're only dealing with GPRs. */
803 if (regno
< 0 || regno
+ nregs
> 8)
806 /* 2-register h8s instructions must start with an even-numbered register.
807 3- and 4-register instructions must start with er0 or er4. */
810 if ((regno
& 1) != 0)
812 if (nregs
> 2 && (regno
& 3) != 0)
816 /* Check the other loads or stores. */
817 for (i
= 1; i
< nregs
; i
++)
818 if (h8300_ldm_stm_regno (RTVEC_ELT (vec
, first
+ i
), load_p
, i
, nregs
)
822 /* Check the stack adjustment. */
823 last
= RTVEC_ELT (vec
, first
+ nregs
);
824 adjust
= (load_p
? nregs
: -nregs
) * 4;
825 return (GET_CODE (last
) == SET
826 && SET_DEST (last
) == stack_pointer_rtx
827 && h8300_stack_offset_p (SET_SRC (last
), adjust
));
830 /* This is what the stack looks like after the prolog of
831 a function with a frame has been set up:
837 <saved registers> <- sp
839 This is what the stack looks like after the prolog of
840 a function which doesn't have a frame:
845 <saved registers> <- sp
848 /* Generate RTL code for the function prologue. */
851 h8300_expand_prologue (void)
857 /* If the current function has the OS_Task attribute set, then
858 we have a naked prologue. */
859 if (h8300_os_task_function_p (current_function_decl
))
862 if (h8300_monitor_function_p (current_function_decl
))
863 /* The monitor function act as normal functions, which means it
864 can accept parameters and return values. In addition to this,
865 interrupts are masked in prologue and return with "rte" in epilogue. */
866 emit_insn (gen_monitor_prologue ());
868 if (frame_pointer_needed
)
871 push (HARD_FRAME_POINTER_REGNUM
);
872 F (emit_move_insn (hard_frame_pointer_rtx
, stack_pointer_rtx
), true);
875 /* Push the rest of the registers in ascending order. */
876 saved_regs
= compute_saved_regs ();
877 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
+= n_regs
)
880 if (saved_regs
& (1 << regno
))
884 /* See how many registers we can push at the same time. */
885 if ((!TARGET_H8300SX
|| (regno
& 3) == 0)
886 && ((saved_regs
>> regno
) & 0x0f) == 0x0f)
889 else if ((!TARGET_H8300SX
|| (regno
& 3) == 0)
890 && ((saved_regs
>> regno
) & 0x07) == 0x07)
893 else if ((!TARGET_H8300SX
|| (regno
& 1) == 0)
894 && ((saved_regs
>> regno
) & 0x03) == 0x03)
898 h8300_push_pop (regno
, n_regs
, false, false);
902 /* Leave room for locals. */
903 h8300_emit_stack_adjustment (-1, round_frame_size (get_frame_size ()), true);
906 /* Return nonzero if we can use "rts" for the function currently being
910 h8300_can_use_return_insn_p (void)
912 return (reload_completed
913 && !frame_pointer_needed
914 && get_frame_size () == 0
915 && compute_saved_regs () == 0);
918 /* Generate RTL code for the function epilogue. */
921 h8300_expand_epilogue (void)
926 HOST_WIDE_INT frame_size
;
929 if (h8300_os_task_function_p (current_function_decl
))
930 /* OS_Task epilogues are nearly naked -- they just have an
934 frame_size
= round_frame_size (get_frame_size ());
937 /* Deallocate locals. */
938 h8300_emit_stack_adjustment (1, frame_size
, false);
940 /* Pop the saved registers in descending order. */
941 saved_regs
= compute_saved_regs ();
942 for (regno
= FIRST_PSEUDO_REGISTER
- 1; regno
>= 0; regno
-= n_regs
)
945 if (saved_regs
& (1 << regno
))
949 /* See how many registers we can pop at the same time. */
950 if ((TARGET_H8300SX
|| (regno
& 3) == 3)
951 && ((saved_regs
<< 3 >> regno
) & 0x0f) == 0x0f)
954 else if ((TARGET_H8300SX
|| (regno
& 3) == 2)
955 && ((saved_regs
<< 2 >> regno
) & 0x07) == 0x07)
958 else if ((TARGET_H8300SX
|| (regno
& 1) == 1)
959 && ((saved_regs
<< 1 >> regno
) & 0x03) == 0x03)
963 /* See if this pop would be the last insn before the return.
964 If so, use rte/l or rts/l instead of pop or ldm.l. */
966 && !frame_pointer_needed
968 && (saved_regs
& ((1 << (regno
- n_regs
+ 1)) - 1)) == 0)
971 h8300_push_pop (regno
- n_regs
+ 1, n_regs
, true, returned_p
);
975 /* Pop frame pointer if we had one. */
976 if (frame_pointer_needed
)
980 h8300_push_pop (HARD_FRAME_POINTER_REGNUM
, 1, true, returned_p
);
984 emit_jump_insn (ret_rtx
);
987 /* Return nonzero if the current function is an interrupt
991 h8300_current_function_interrupt_function_p (void)
993 return (h8300_interrupt_function_p (current_function_decl
));
997 h8300_current_function_monitor_function_p ()
999 return (h8300_monitor_function_p (current_function_decl
));
1002 /* Output assembly code for the start of the file. */
1005 h8300_file_start (void)
1007 default_file_start ();
1010 fputs (TARGET_NORMAL_MODE
? "\t.h8300hn\n" : "\t.h8300h\n", asm_out_file
);
1011 else if (TARGET_H8300SX
)
1012 fputs (TARGET_NORMAL_MODE
? "\t.h8300sxn\n" : "\t.h8300sx\n", asm_out_file
);
1013 else if (TARGET_H8300S
)
1014 fputs (TARGET_NORMAL_MODE
? "\t.h8300sn\n" : "\t.h8300s\n", asm_out_file
);
1017 /* Output assembly language code for the end of file. */
1020 h8300_file_end (void)
1022 fputs ("\t.end\n", asm_out_file
);
1025 /* Split an add of a small constant into two adds/subs insns.
1027 If USE_INCDEC_P is nonzero, we generate the last insn using inc/dec
1028 instead of adds/subs. */
1031 split_adds_subs (machine_mode mode
, rtx
*operands
)
1033 HOST_WIDE_INT val
= INTVAL (operands
[1]);
1034 rtx reg
= operands
[0];
1035 HOST_WIDE_INT sign
= 1;
1036 HOST_WIDE_INT amount
;
1037 rtx (*gen_add
) (rtx
, rtx
, rtx
);
1039 /* Force VAL to be positive so that we do not have to consider the
1050 gen_add
= gen_addhi3
;
1054 gen_add
= gen_addsi3
;
1061 /* Try different amounts in descending order. */
1062 for (amount
= (TARGET_H8300H
|| TARGET_H8300S
) ? 4 : 2;
1066 for (; val
>= amount
; val
-= amount
)
1067 emit_insn (gen_add (reg
, reg
, GEN_INT (sign
* amount
)));
1073 /* Handle machine specific pragmas for compatibility with existing
1074 compilers for the H8/300.
1076 pragma saveall generates prologue/epilogue code which saves and
1077 restores all the registers on function entry.
1079 pragma interrupt saves and restores all registers, and exits with
1080 an rte instruction rather than an rts. A pointer to a function
1081 with this attribute may be safely used in an interrupt vector. */
1084 h8300_pr_interrupt (struct cpp_reader
*pfile ATTRIBUTE_UNUSED
)
1086 pragma_interrupt
= 1;
1090 h8300_pr_saveall (struct cpp_reader
*pfile ATTRIBUTE_UNUSED
)
1095 /* If the next function argument with MODE and TYPE is to be passed in
1096 a register, return a reg RTX for the hard register in which to pass
1097 the argument. CUM represents the state after the last argument.
1098 If the argument is to be pushed, NULL_RTX is returned.
1100 On the H8/300 all normal args are pushed, unless -mquickcall in which
1101 case the first 3 arguments are passed in registers. */
1104 h8300_function_arg (cumulative_args_t cum_v
, machine_mode mode
,
1105 const_tree type
, bool named
)
1107 CUMULATIVE_ARGS
*cum
= get_cumulative_args (cum_v
);
1109 static const char *const hand_list
[] = {
1128 rtx result
= NULL_RTX
;
1132 /* Never pass unnamed arguments in registers. */
1136 /* Pass 3 regs worth of data in regs when user asked on the command line. */
1137 if (TARGET_QUICKCALL
)
1140 /* If calling hand written assembler, use 4 regs of args. */
1143 const char * const *p
;
1145 fname
= XSTR (cum
->libcall
, 0);
1147 /* See if this libcall is one of the hand coded ones. */
1148 for (p
= hand_list
; *p
&& strcmp (*p
, fname
) != 0; p
++)
1159 if (mode
== BLKmode
)
1160 size
= int_size_in_bytes (type
);
1162 size
= GET_MODE_SIZE (mode
);
1164 if (size
+ cum
->nbytes
<= regpass
* UNITS_PER_WORD
1165 && cum
->nbytes
/ UNITS_PER_WORD
<= 3)
1166 result
= gen_rtx_REG (mode
, cum
->nbytes
/ UNITS_PER_WORD
);
1172 /* Update the data in CUM to advance over an argument
1173 of mode MODE and data type TYPE.
1174 (TYPE is null for libcalls where that information may not be available.) */
1177 h8300_function_arg_advance (cumulative_args_t cum_v
, machine_mode mode
,
1178 const_tree type
, bool named ATTRIBUTE_UNUSED
)
1180 CUMULATIVE_ARGS
*cum
= get_cumulative_args (cum_v
);
1182 cum
->nbytes
+= (mode
!= BLKmode
1183 ? (GET_MODE_SIZE (mode
) + UNITS_PER_WORD
- 1) & -UNITS_PER_WORD
1184 : (int_size_in_bytes (type
) + UNITS_PER_WORD
- 1) & -UNITS_PER_WORD
);
1188 /* Implements TARGET_REGISTER_MOVE_COST.
1190 Any SI register-to-register move may need to be reloaded,
1191 so inmplement h8300_register_move_cost to return > 2 so that reload never
1195 h8300_register_move_cost (machine_mode mode ATTRIBUTE_UNUSED
,
1196 reg_class_t from
, reg_class_t to
)
1198 if (from
== MAC_REGS
|| to
== MAC_REG
)
1204 /* Compute the cost of an and insn. */
1207 h8300_and_costs (rtx x
)
1211 if (GET_MODE (x
) == QImode
)
1214 if (GET_MODE (x
) != HImode
1215 && GET_MODE (x
) != SImode
)
1219 operands
[1] = XEXP (x
, 0);
1220 operands
[2] = XEXP (x
, 1);
1222 return compute_logical_op_length (GET_MODE (x
), operands
) / 2;
1225 /* Compute the cost of a shift insn. */
1228 h8300_shift_costs (rtx x
)
1232 if (GET_MODE (x
) != QImode
1233 && GET_MODE (x
) != HImode
1234 && GET_MODE (x
) != SImode
)
1239 operands
[2] = XEXP (x
, 1);
1241 return compute_a_shift_length (NULL
, operands
) / 2;
1244 /* Worker function for TARGET_RTX_COSTS. */
1247 h8300_rtx_costs (rtx x
, int code
, int outer_code
, int opno ATTRIBUTE_UNUSED
,
1248 int *total
, bool speed
)
1250 if (TARGET_H8300SX
&& outer_code
== MEM
)
1252 /* Estimate the number of execution states needed to calculate
1254 if (register_operand (x
, VOIDmode
)
1255 || GET_CODE (x
) == POST_INC
1256 || GET_CODE (x
) == POST_DEC
1260 *total
= COSTS_N_INSNS (1);
1268 HOST_WIDE_INT n
= INTVAL (x
);
1272 /* Constant operands need the same number of processor
1273 states as register operands. Although we could try to
1274 use a size-based cost for !speed, the lack of
1275 of a mode makes the results very unpredictable. */
1279 if (-4 <= n
&& n
<= 4)
1290 *total
= 0 + (outer_code
== SET
);
1294 if (TARGET_H8300H
|| TARGET_H8300S
)
1295 *total
= 0 + (outer_code
== SET
);
1310 /* See comment for CONST_INT. */
1322 if (XEXP (x
, 1) == const0_rtx
)
1327 if (!h8300_dst_operand (XEXP (x
, 0), VOIDmode
)
1328 || !h8300_src_operand (XEXP (x
, 1), VOIDmode
))
1330 *total
= COSTS_N_INSNS (h8300_and_costs (x
));
1333 /* We say that MOD and DIV are so expensive because otherwise we'll
1334 generate some really horrible code for division of a power of two. */
1340 switch (GET_MODE (x
))
1344 *total
= COSTS_N_INSNS (!speed
? 4 : 10);
1348 *total
= COSTS_N_INSNS (!speed
? 4 : 18);
1354 *total
= COSTS_N_INSNS (12);
1359 switch (GET_MODE (x
))
1363 *total
= COSTS_N_INSNS (2);
1367 *total
= COSTS_N_INSNS (5);
1373 *total
= COSTS_N_INSNS (4);
1379 if (h8sx_binary_shift_operator (x
, VOIDmode
))
1381 *total
= COSTS_N_INSNS (2);
1384 else if (h8sx_unary_shift_operator (x
, VOIDmode
))
1386 *total
= COSTS_N_INSNS (1);
1389 *total
= COSTS_N_INSNS (h8300_shift_costs (x
));
1394 if (GET_MODE (x
) == HImode
)
1401 *total
= COSTS_N_INSNS (1);
1406 /* Documentation for the machine specific operand escapes:
1408 'E' like s but negative.
1409 'F' like t but negative.
1410 'G' constant just the negative
1411 'R' print operand as a byte:8 address if appropriate, else fall back to
1413 'S' print operand as a long word
1414 'T' print operand as a word
1415 'V' find the set bit, and print its number.
1416 'W' find the clear bit, and print its number.
1417 'X' print operand as a byte
1418 'Y' print either l or h depending on whether last 'Z' operand < 8 or >= 8.
1419 If this operand isn't a register, fall back to 'R' handling.
1421 'c' print the opcode corresponding to rtl
1422 'e' first word of 32-bit value - if reg, then least reg. if mem
1423 then least. if const then most sig word
1424 'f' second word of 32-bit value - if reg, then biggest reg. if mem
1425 then +2. if const then least sig word
1426 'j' print operand as condition code.
1427 'k' print operand as reverse condition code.
1428 'm' convert an integer operand to a size suffix (.b, .w or .l)
1429 'o' print an integer without a leading '#'
1430 's' print as low byte of 16-bit value
1431 't' print as high byte of 16-bit value
1432 'w' print as low byte of 32-bit value
1433 'x' print as 2nd byte of 32-bit value
1434 'y' print as 3rd byte of 32-bit value
1435 'z' print as msb of 32-bit value
1438 /* Return assembly language string which identifies a comparison type. */
1441 cond_string (enum rtx_code code
)
1470 /* Print operand X using operand code CODE to assembly language output file
1474 h8300_print_operand (FILE *file
, rtx x
, int code
)
1476 /* This is used for communication between codes V,W,Z and Y. */
1482 if (h8300_constant_length (x
) == 2)
1483 fprintf (file
, ":16");
1485 fprintf (file
, ":32");
1488 switch (GET_CODE (x
))
1491 fprintf (file
, "%sl", names_big
[REGNO (x
)]);
1494 fprintf (file
, "#%ld", (-INTVAL (x
)) & 0xff);
1501 switch (GET_CODE (x
))
1504 fprintf (file
, "%sh", names_big
[REGNO (x
)]);
1507 fprintf (file
, "#%ld", ((-INTVAL (x
)) & 0xff00) >> 8);
1514 gcc_assert (GET_CODE (x
) == CONST_INT
);
1515 fprintf (file
, "#%ld", 0xff & (-INTVAL (x
)));
1518 if (GET_CODE (x
) == REG
)
1519 fprintf (file
, "%s", names_extended
[REGNO (x
)]);
1524 if (GET_CODE (x
) == REG
)
1525 fprintf (file
, "%s", names_big
[REGNO (x
)]);
1530 bitint
= (INTVAL (x
) & 0xffff);
1531 if ((exact_log2 ((bitint
>> 8) & 0xff)) == -1)
1532 bitint
= exact_log2 (bitint
& 0xff);
1534 bitint
= exact_log2 ((bitint
>> 8) & 0xff);
1535 gcc_assert (bitint
>= 0);
1536 fprintf (file
, "#%d", bitint
);
1539 bitint
= ((~INTVAL (x
)) & 0xffff);
1540 if ((exact_log2 ((bitint
>> 8) & 0xff)) == -1 )
1541 bitint
= exact_log2 (bitint
& 0xff);
1543 bitint
= (exact_log2 ((bitint
>> 8) & 0xff));
1544 gcc_assert (bitint
>= 0);
1545 fprintf (file
, "#%d", bitint
);
1549 if (GET_CODE (x
) == REG
)
1550 fprintf (file
, "%s", byte_reg (x
, 0));
1555 gcc_assert (bitint
>= 0);
1556 if (GET_CODE (x
) == REG
)
1557 fprintf (file
, "%s%c", names_big
[REGNO (x
)], bitint
> 7 ? 'h' : 'l');
1559 h8300_print_operand (file
, x
, 'R');
1563 bitint
= INTVAL (x
);
1564 fprintf (file
, "#%d", bitint
& 7);
1567 switch (GET_CODE (x
))
1570 fprintf (file
, "or");
1573 fprintf (file
, "xor");
1576 fprintf (file
, "and");
1583 switch (GET_CODE (x
))
1587 fprintf (file
, "%s", names_big
[REGNO (x
)]);
1589 fprintf (file
, "%s", names_upper_extended
[REGNO (x
)]);
1592 h8300_print_operand (file
, x
, 0);
1595 fprintf (file
, "#%ld", ((INTVAL (x
) >> 16) & 0xffff));
1601 REAL_VALUE_FROM_CONST_DOUBLE (rv
, x
);
1602 REAL_VALUE_TO_TARGET_SINGLE (rv
, val
);
1603 fprintf (file
, "#%ld", ((val
>> 16) & 0xffff));
1612 switch (GET_CODE (x
))
1616 fprintf (file
, "%s", names_big
[REGNO (x
) + 1]);
1618 fprintf (file
, "%s", names_big
[REGNO (x
)]);
1621 x
= adjust_address (x
, HImode
, 2);
1622 h8300_print_operand (file
, x
, 0);
1625 fprintf (file
, "#%ld", INTVAL (x
) & 0xffff);
1631 REAL_VALUE_FROM_CONST_DOUBLE (rv
, x
);
1632 REAL_VALUE_TO_TARGET_SINGLE (rv
, val
);
1633 fprintf (file
, "#%ld", (val
& 0xffff));
1641 fputs (cond_string (GET_CODE (x
)), file
);
1644 fputs (cond_string (reverse_condition (GET_CODE (x
))), file
);
1647 gcc_assert (GET_CODE (x
) == CONST_INT
);
1667 h8300_print_operand_address (file
, x
);
1670 if (GET_CODE (x
) == CONST_INT
)
1671 fprintf (file
, "#%ld", (INTVAL (x
)) & 0xff);
1673 fprintf (file
, "%s", byte_reg (x
, 0));
1676 if (GET_CODE (x
) == CONST_INT
)
1677 fprintf (file
, "#%ld", (INTVAL (x
) >> 8) & 0xff);
1679 fprintf (file
, "%s", byte_reg (x
, 1));
1682 if (GET_CODE (x
) == CONST_INT
)
1683 fprintf (file
, "#%ld", INTVAL (x
) & 0xff);
1685 fprintf (file
, "%s",
1686 byte_reg (x
, TARGET_H8300
? 2 : 0));
1689 if (GET_CODE (x
) == CONST_INT
)
1690 fprintf (file
, "#%ld", (INTVAL (x
) >> 8) & 0xff);
1692 fprintf (file
, "%s",
1693 byte_reg (x
, TARGET_H8300
? 3 : 1));
1696 if (GET_CODE (x
) == CONST_INT
)
1697 fprintf (file
, "#%ld", (INTVAL (x
) >> 16) & 0xff);
1699 fprintf (file
, "%s", byte_reg (x
, 0));
1702 if (GET_CODE (x
) == CONST_INT
)
1703 fprintf (file
, "#%ld", (INTVAL (x
) >> 24) & 0xff);
1705 fprintf (file
, "%s", byte_reg (x
, 1));
1710 switch (GET_CODE (x
))
1713 switch (GET_MODE (x
))
1716 #if 0 /* Is it asm ("mov.b %0,r2l", ...) */
1717 fprintf (file
, "%s", byte_reg (x
, 0));
1718 #else /* ... or is it asm ("mov.b %0l,r2l", ...) */
1719 fprintf (file
, "%s", names_big
[REGNO (x
)]);
1723 fprintf (file
, "%s", names_big
[REGNO (x
)]);
1727 fprintf (file
, "%s", names_extended
[REGNO (x
)]);
1736 rtx addr
= XEXP (x
, 0);
1738 fprintf (file
, "@");
1739 output_address (addr
);
1741 /* Add a length suffix to constant addresses. Although this
1742 is often unnecessary, it helps to avoid ambiguity in the
1743 syntax of mova. If we wrote an insn like:
1745 mova/w.l @(1,@foo.b),er0
1747 then .b would be considered part of the symbol name.
1748 Adding a length after foo will avoid this. */
1749 if (CONSTANT_P (addr
))
1753 /* Used for mov.b and bit operations. */
1754 if (h8300_eightbit_constant_address_p (addr
))
1756 fprintf (file
, ":8");
1760 /* Fall through. We should not get here if we are
1761 processing bit operations on H8/300 or H8/300H
1762 because 'U' constraint does not allow bit
1763 operations on the tiny area on these machines. */
1768 if (h8300_constant_length (addr
) == 2)
1769 fprintf (file
, ":16");
1771 fprintf (file
, ":32");
1783 fprintf (file
, "#");
1784 h8300_print_operand_address (file
, x
);
1790 REAL_VALUE_FROM_CONST_DOUBLE (rv
, x
);
1791 REAL_VALUE_TO_TARGET_SINGLE (rv
, val
);
1792 fprintf (file
, "#%ld", val
);
1801 /* Implements TARGET_PRINT_OPERAND_PUNCT_VALID_P. */
1804 h8300_print_operand_punct_valid_p (unsigned char code
)
1806 return (code
== '#');
1809 /* Output assembly language output for the address ADDR to FILE. */
1812 h8300_print_operand_address (FILE *file
, rtx addr
)
1817 switch (GET_CODE (addr
))
1820 fprintf (file
, "%s", h8_reg_names
[REGNO (addr
)]);
1824 fprintf (file
, "-%s", h8_reg_names
[REGNO (XEXP (addr
, 0))]);
1828 fprintf (file
, "%s+", h8_reg_names
[REGNO (XEXP (addr
, 0))]);
1832 fprintf (file
, "+%s", h8_reg_names
[REGNO (XEXP (addr
, 0))]);
1836 fprintf (file
, "%s-", h8_reg_names
[REGNO (XEXP (addr
, 0))]);
1840 fprintf (file
, "(");
1842 index
= h8300_get_index (XEXP (addr
, 0), VOIDmode
, &size
);
1843 if (GET_CODE (index
) == REG
)
1846 h8300_print_operand_address (file
, XEXP (addr
, 1));
1847 fprintf (file
, ",");
1851 h8300_print_operand_address (file
, index
);
1855 h8300_print_operand (file
, index
, 'X');
1860 h8300_print_operand (file
, index
, 'T');
1865 h8300_print_operand (file
, index
, 'S');
1869 /* h8300_print_operand_address (file, XEXP (addr, 0)); */
1874 h8300_print_operand_address (file
, XEXP (addr
, 0));
1875 fprintf (file
, "+");
1876 h8300_print_operand_address (file
, XEXP (addr
, 1));
1878 fprintf (file
, ")");
1883 /* Since the H8/300 only has 16-bit pointers, negative values are also
1884 those >= 32768. This happens for example with pointer minus a
1885 constant. We don't want to turn (char *p - 2) into
1886 (char *p + 65534) because loop unrolling can build upon this
1887 (IE: char *p + 131068). */
1888 int n
= INTVAL (addr
);
1890 n
= (int) (short) n
;
1891 fprintf (file
, "%d", n
);
1896 output_addr_const (file
, addr
);
1901 /* Output all insn addresses and their sizes into the assembly language
1902 output file. This is helpful for debugging whether the length attributes
1903 in the md file are correct. This is not meant to be a user selectable
1907 final_prescan_insn (rtx_insn
*insn
, rtx
*operand ATTRIBUTE_UNUSED
,
1908 int num_operands ATTRIBUTE_UNUSED
)
1910 /* This holds the last insn address. */
1911 static int last_insn_address
= 0;
1913 const int uid
= INSN_UID (insn
);
1915 if (TARGET_ADDRESSES
)
1917 fprintf (asm_out_file
, "; 0x%x %d\n", INSN_ADDRESSES (uid
),
1918 INSN_ADDRESSES (uid
) - last_insn_address
);
1919 last_insn_address
= INSN_ADDRESSES (uid
);
1923 /* Prepare for an SI sized move. */
1926 h8300_expand_movsi (rtx operands
[])
1928 rtx src
= operands
[1];
1929 rtx dst
= operands
[0];
1930 if (!reload_in_progress
&& !reload_completed
)
1932 if (!register_operand (dst
, GET_MODE (dst
)))
1934 rtx tmp
= gen_reg_rtx (GET_MODE (dst
));
1935 emit_move_insn (tmp
, src
);
1942 /* Given FROM and TO register numbers, say whether this elimination is allowed.
1943 Frame pointer elimination is automatically handled.
1945 For the h8300, if frame pointer elimination is being done, we would like to
1946 convert ap and rp into sp, not fp.
1948 All other eliminations are valid. */
1951 h8300_can_eliminate (const int from ATTRIBUTE_UNUSED
, const int to
)
1953 return (to
== STACK_POINTER_REGNUM
? ! frame_pointer_needed
: true);
1956 /* Conditionally modify register usage based on target flags. */
1959 h8300_conditional_register_usage (void)
1962 fixed_regs
[MAC_REG
] = call_used_regs
[MAC_REG
] = 1;
1965 /* Function for INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET).
1966 Define the offset between two registers, one to be eliminated, and
1967 the other its replacement, at the start of a routine. */
1970 h8300_initial_elimination_offset (int from
, int to
)
1972 /* The number of bytes that the return address takes on the stack. */
1973 int pc_size
= POINTER_SIZE
/ BITS_PER_UNIT
;
1975 /* The number of bytes that the saved frame pointer takes on the stack. */
1976 int fp_size
= frame_pointer_needed
* UNITS_PER_WORD
;
1978 /* The number of bytes that the saved registers, excluding the frame
1979 pointer, take on the stack. */
1980 int saved_regs_size
= 0;
1982 /* The number of bytes that the locals takes on the stack. */
1983 int frame_size
= round_frame_size (get_frame_size ());
1987 for (regno
= 0; regno
<= HARD_FRAME_POINTER_REGNUM
; regno
++)
1988 if (WORD_REG_USED (regno
))
1989 saved_regs_size
+= UNITS_PER_WORD
;
1991 /* Adjust saved_regs_size because the above loop took the frame
1992 pointer int account. */
1993 saved_regs_size
-= fp_size
;
1997 case HARD_FRAME_POINTER_REGNUM
:
2000 case ARG_POINTER_REGNUM
:
2001 return pc_size
+ fp_size
;
2002 case RETURN_ADDRESS_POINTER_REGNUM
:
2004 case FRAME_POINTER_REGNUM
:
2005 return -saved_regs_size
;
2010 case STACK_POINTER_REGNUM
:
2013 case ARG_POINTER_REGNUM
:
2014 return pc_size
+ saved_regs_size
+ frame_size
;
2015 case RETURN_ADDRESS_POINTER_REGNUM
:
2016 return saved_regs_size
+ frame_size
;
2017 case FRAME_POINTER_REGNUM
:
2029 /* Worker function for RETURN_ADDR_RTX. */
2032 h8300_return_addr_rtx (int count
, rtx frame
)
2037 ret
= gen_rtx_MEM (Pmode
,
2038 gen_rtx_REG (Pmode
, RETURN_ADDRESS_POINTER_REGNUM
));
2039 else if (flag_omit_frame_pointer
)
2042 ret
= gen_rtx_MEM (Pmode
,
2043 memory_address (Pmode
,
2044 plus_constant (Pmode
, frame
,
2046 set_mem_alias_set (ret
, get_frame_alias_set ());
2050 /* Update the condition code from the insn. */
2053 notice_update_cc (rtx body
, rtx_insn
*insn
)
2057 switch (get_attr_cc (insn
))
2060 /* Insn does not affect CC at all. */
2064 /* Insn does not change CC, but the 0'th operand has been changed. */
2065 if (cc_status
.value1
!= 0
2066 && reg_overlap_mentioned_p (recog_data
.operand
[0], cc_status
.value1
))
2067 cc_status
.value1
= 0;
2068 if (cc_status
.value2
!= 0
2069 && reg_overlap_mentioned_p (recog_data
.operand
[0], cc_status
.value2
))
2070 cc_status
.value2
= 0;
2074 /* Insn sets the Z,N flags of CC to recog_data.operand[0].
2075 The V flag is unusable. The C flag may or may not be known but
2076 that's ok because alter_cond will change tests to use EQ/NE. */
2078 cc_status
.flags
|= CC_OVERFLOW_UNUSABLE
| CC_NO_CARRY
;
2079 set
= single_set (insn
);
2080 cc_status
.value1
= SET_SRC (set
);
2081 if (SET_DEST (set
) != cc0_rtx
)
2082 cc_status
.value2
= SET_DEST (set
);
2086 /* Insn sets the Z,N,V flags of CC to recog_data.operand[0].
2087 The C flag may or may not be known but that's ok because
2088 alter_cond will change tests to use EQ/NE. */
2090 cc_status
.flags
|= CC_NO_CARRY
;
2091 set
= single_set (insn
);
2092 cc_status
.value1
= SET_SRC (set
);
2093 if (SET_DEST (set
) != cc0_rtx
)
2095 /* If the destination is STRICT_LOW_PART, strip off
2097 if (GET_CODE (SET_DEST (set
)) == STRICT_LOW_PART
)
2098 cc_status
.value2
= XEXP (SET_DEST (set
), 0);
2100 cc_status
.value2
= SET_DEST (set
);
2105 /* The insn is a compare instruction. */
2107 cc_status
.value1
= SET_SRC (body
);
2111 /* Insn doesn't leave CC in a usable state. */
2117 /* Given that X occurs in an address of the form (plus X constant),
2118 return the part of X that is expected to be a register. There are
2119 four kinds of addressing mode to recognize:
2126 If SIZE is nonnull, and the address is one of the last three forms,
2127 set *SIZE to the index multiplication factor. Set it to 0 for
2128 plain @(dd,Rn) addresses.
2130 MODE is the mode of the value being accessed. It can be VOIDmode
2131 if the address is known to be valid, but its mode is unknown. */
2134 h8300_get_index (rtx x
, machine_mode mode
, int *size
)
2141 factor
= (mode
== VOIDmode
? 0 : GET_MODE_SIZE (mode
));
2144 && (mode
== VOIDmode
2145 || GET_MODE_CLASS (mode
) == MODE_INT
2146 || GET_MODE_CLASS (mode
) == MODE_FLOAT
))
2148 if (factor
<= 1 && GET_CODE (x
) == ZERO_EXTEND
)
2150 /* When accessing byte-sized values, the index can be
2151 a zero-extended QImode or HImode register. */
2152 *size
= GET_MODE_SIZE (GET_MODE (XEXP (x
, 0)));
2157 /* We're looking for addresses of the form:
2160 or (mult (zero_extend X) I)
2162 where I is the size of the operand being accessed.
2163 The canonical form of the second expression is:
2165 (and (mult (subreg X) I) J)
2167 where J == GET_MODE_MASK (GET_MODE (X)) * I. */
2170 if (GET_CODE (x
) == AND
2171 && GET_CODE (XEXP (x
, 1)) == CONST_INT
2173 || INTVAL (XEXP (x
, 1)) == 0xff * factor
2174 || INTVAL (XEXP (x
, 1)) == 0xffff * factor
))
2176 index
= XEXP (x
, 0);
2177 *size
= (INTVAL (XEXP (x
, 1)) >= 0xffff ? 2 : 1);
2185 if (GET_CODE (index
) == MULT
2186 && GET_CODE (XEXP (index
, 1)) == CONST_INT
2187 && (factor
== 0 || factor
== INTVAL (XEXP (index
, 1))))
2188 return XEXP (index
, 0);
2195 /* Worker function for TARGET_MODE_DEPENDENT_ADDRESS_P.
2197 On the H8/300, the predecrement and postincrement address depend thus
2198 (the amount of decrement or increment being the length of the operand). */
2201 h8300_mode_dependent_address_p (const_rtx addr
,
2202 addr_space_t as ATTRIBUTE_UNUSED
)
2204 if (GET_CODE (addr
) == PLUS
2205 && h8300_get_index (XEXP (addr
, 0), VOIDmode
, 0) != XEXP (addr
, 0))
2211 static const h8300_length_table addb_length_table
=
2213 /* #xx Rs @aa @Rs @xx */
2214 { 2, 2, 4, 4, 4 }, /* add.b xx,Rd */
2215 { 4, 4, 4, 4, 6 }, /* add.b xx,@aa */
2216 { 4, 4, 4, 4, 6 }, /* add.b xx,@Rd */
2217 { 6, 4, 4, 4, 6 } /* add.b xx,@xx */
2220 static const h8300_length_table addw_length_table
=
2222 /* #xx Rs @aa @Rs @xx */
2223 { 2, 2, 4, 4, 4 }, /* add.w xx,Rd */
2224 { 4, 4, 4, 4, 6 }, /* add.w xx,@aa */
2225 { 4, 4, 4, 4, 6 }, /* add.w xx,@Rd */
2226 { 4, 4, 4, 4, 6 } /* add.w xx,@xx */
2229 static const h8300_length_table addl_length_table
=
2231 /* #xx Rs @aa @Rs @xx */
2232 { 2, 2, 4, 4, 4 }, /* add.l xx,Rd */
2233 { 4, 4, 6, 6, 6 }, /* add.l xx,@aa */
2234 { 4, 4, 6, 6, 6 }, /* add.l xx,@Rd */
2235 { 4, 4, 6, 6, 6 } /* add.l xx,@xx */
2238 #define logicb_length_table addb_length_table
2239 #define logicw_length_table addw_length_table
2241 static const h8300_length_table logicl_length_table
=
2243 /* #xx Rs @aa @Rs @xx */
2244 { 2, 4, 4, 4, 4 }, /* and.l xx,Rd */
2245 { 4, 4, 6, 6, 6 }, /* and.l xx,@aa */
2246 { 4, 4, 6, 6, 6 }, /* and.l xx,@Rd */
2247 { 4, 4, 6, 6, 6 } /* and.l xx,@xx */
2250 static const h8300_length_table movb_length_table
=
2252 /* #xx Rs @aa @Rs @xx */
2253 { 2, 2, 2, 2, 4 }, /* mov.b xx,Rd */
2254 { 4, 2, 4, 4, 4 }, /* mov.b xx,@aa */
2255 { 4, 2, 4, 4, 4 }, /* mov.b xx,@Rd */
2256 { 4, 4, 4, 4, 4 } /* mov.b xx,@xx */
2259 #define movw_length_table movb_length_table
2261 static const h8300_length_table movl_length_table
=
2263 /* #xx Rs @aa @Rs @xx */
2264 { 2, 2, 4, 4, 4 }, /* mov.l xx,Rd */
2265 { 4, 4, 4, 4, 4 }, /* mov.l xx,@aa */
2266 { 4, 4, 4, 4, 4 }, /* mov.l xx,@Rd */
2267 { 4, 4, 4, 4, 4 } /* mov.l xx,@xx */
2270 /* Return the size of the given address or displacement constant. */
2273 h8300_constant_length (rtx constant
)
2275 /* Check for (@d:16,Reg). */
2276 if (GET_CODE (constant
) == CONST_INT
2277 && IN_RANGE (INTVAL (constant
), -0x8000, 0x7fff))
2280 /* Check for (@d:16,Reg) in cases where the displacement is
2281 an absolute address. */
2282 if (Pmode
== HImode
|| h8300_tiny_constant_address_p (constant
))
2288 /* Return the size of a displacement field in address ADDR, which should
2289 have the form (plus X constant). SIZE is the number of bytes being
2293 h8300_displacement_length (rtx addr
, int size
)
2297 offset
= XEXP (addr
, 1);
2299 /* Check for @(d:2,Reg). */
2300 if (register_operand (XEXP (addr
, 0), VOIDmode
)
2301 && GET_CODE (offset
) == CONST_INT
2302 && (INTVAL (offset
) == size
2303 || INTVAL (offset
) == size
* 2
2304 || INTVAL (offset
) == size
* 3))
2307 return h8300_constant_length (offset
);
2310 /* Store the class of operand OP in *OPCLASS and return the length of any
2311 extra operand fields. SIZE is the number of bytes in OP. OPCLASS
2312 can be null if only the length is needed. */
2315 h8300_classify_operand (rtx op
, int size
, enum h8300_operand_class
*opclass
)
2317 enum h8300_operand_class dummy
;
2322 if (CONSTANT_P (op
))
2324 *opclass
= H8OP_IMMEDIATE
;
2326 /* Byte-sized immediates are stored in the opcode fields. */
2330 /* If this is a 32-bit instruction, see whether the constant
2331 will fit into a 16-bit immediate field. */
2334 && GET_CODE (op
) == CONST_INT
2335 && IN_RANGE (INTVAL (op
), 0, 0xffff))
2340 else if (GET_CODE (op
) == MEM
)
2343 if (CONSTANT_P (op
))
2345 *opclass
= H8OP_MEM_ABSOLUTE
;
2346 return h8300_constant_length (op
);
2348 else if (GET_CODE (op
) == PLUS
&& CONSTANT_P (XEXP (op
, 1)))
2350 *opclass
= H8OP_MEM_COMPLEX
;
2351 return h8300_displacement_length (op
, size
);
2353 else if (GET_RTX_CLASS (GET_CODE (op
)) == RTX_AUTOINC
)
2355 *opclass
= H8OP_MEM_COMPLEX
;
2358 else if (register_operand (op
, VOIDmode
))
2360 *opclass
= H8OP_MEM_BASE
;
2364 gcc_assert (register_operand (op
, VOIDmode
));
2365 *opclass
= H8OP_REGISTER
;
2369 /* Return the length of the instruction described by TABLE given that
2370 its operands are OP1 and OP2. OP1 must be an h8300_dst_operand
2371 and OP2 must be an h8300_src_operand. */
2374 h8300_length_from_table (rtx op1
, rtx op2
, const h8300_length_table
*table
)
2376 enum h8300_operand_class op1_class
, op2_class
;
2377 unsigned int size
, immediate_length
;
2379 size
= GET_MODE_SIZE (GET_MODE (op1
));
2380 immediate_length
= (h8300_classify_operand (op1
, size
, &op1_class
)
2381 + h8300_classify_operand (op2
, size
, &op2_class
));
2382 return immediate_length
+ (*table
)[op1_class
- 1][op2_class
];
2385 /* Return the length of a unary instruction such as neg or not given that
2386 its operand is OP. */
2389 h8300_unary_length (rtx op
)
2391 enum h8300_operand_class opclass
;
2392 unsigned int size
, operand_length
;
2394 size
= GET_MODE_SIZE (GET_MODE (op
));
2395 operand_length
= h8300_classify_operand (op
, size
, &opclass
);
2402 return (size
== 4 ? 6 : 4);
2404 case H8OP_MEM_ABSOLUTE
:
2405 return operand_length
+ (size
== 4 ? 6 : 4);
2407 case H8OP_MEM_COMPLEX
:
2408 return operand_length
+ 6;
2415 /* Likewise short immediate instructions such as add.w #xx:3,OP. */
2418 h8300_short_immediate_length (rtx op
)
2420 enum h8300_operand_class opclass
;
2421 unsigned int size
, operand_length
;
2423 size
= GET_MODE_SIZE (GET_MODE (op
));
2424 operand_length
= h8300_classify_operand (op
, size
, &opclass
);
2432 case H8OP_MEM_ABSOLUTE
:
2433 case H8OP_MEM_COMPLEX
:
2434 return 4 + operand_length
;
2441 /* Likewise bitfield load and store instructions. */
2444 h8300_bitfield_length (rtx op
, rtx op2
)
2446 enum h8300_operand_class opclass
;
2447 unsigned int size
, operand_length
;
2449 if (GET_CODE (op
) == REG
)
2451 gcc_assert (GET_CODE (op
) != REG
);
2453 size
= GET_MODE_SIZE (GET_MODE (op
));
2454 operand_length
= h8300_classify_operand (op
, size
, &opclass
);
2459 case H8OP_MEM_ABSOLUTE
:
2460 case H8OP_MEM_COMPLEX
:
2461 return 4 + operand_length
;
2468 /* Calculate the length of general binary instruction INSN using TABLE. */
2471 h8300_binary_length (rtx_insn
*insn
, const h8300_length_table
*table
)
2475 set
= single_set (insn
);
2478 if (BINARY_P (SET_SRC (set
)))
2479 return h8300_length_from_table (XEXP (SET_SRC (set
), 0),
2480 XEXP (SET_SRC (set
), 1), table
);
2483 gcc_assert (GET_RTX_CLASS (GET_CODE (SET_SRC (set
))) == RTX_TERNARY
);
2484 return h8300_length_from_table (XEXP (XEXP (SET_SRC (set
), 1), 0),
2485 XEXP (XEXP (SET_SRC (set
), 1), 1),
2490 /* Subroutine of h8300_move_length. Return true if OP is 1- or 2-byte
2491 memory reference and either (1) it has the form @(d:16,Rn) or
2492 (2) its address has the code given by INC_CODE. */
2495 h8300_short_move_mem_p (rtx op
, enum rtx_code inc_code
)
2500 if (GET_CODE (op
) != MEM
)
2503 addr
= XEXP (op
, 0);
2504 size
= GET_MODE_SIZE (GET_MODE (op
));
2505 if (size
!= 1 && size
!= 2)
2508 return (GET_CODE (addr
) == inc_code
2509 || (GET_CODE (addr
) == PLUS
2510 && GET_CODE (XEXP (addr
, 0)) == REG
2511 && h8300_displacement_length (addr
, size
) == 2));
2514 /* Calculate the length of move instruction INSN using the given length
2515 table. Although the tables are correct for most cases, there is some
2516 irregularity in the length of mov.b and mov.w. The following forms:
2523 are two bytes shorter than most other "mov Rs, @complex" or
2524 "mov @complex,Rd" combinations. */
2527 h8300_move_length (rtx
*operands
, const h8300_length_table
*table
)
2531 size
= h8300_length_from_table (operands
[0], operands
[1], table
);
2532 if (REG_P (operands
[0]) && h8300_short_move_mem_p (operands
[1], POST_INC
))
2534 if (REG_P (operands
[1]) && h8300_short_move_mem_p (operands
[0], PRE_DEC
))
2539 /* Return the length of a mova instruction with the given operands.
2540 DEST is the register destination, SRC is the source address and
2541 OFFSET is the 16-bit or 32-bit displacement. */
2544 h8300_mova_length (rtx dest
, rtx src
, rtx offset
)
2549 + h8300_constant_length (offset
)
2550 + h8300_classify_operand (src
, GET_MODE_SIZE (GET_MODE (src
)), 0));
2551 if (!REG_P (dest
) || !REG_P (src
) || REGNO (src
) != REGNO (dest
))
2556 /* Compute the length of INSN based on its length_table attribute.
2557 OPERANDS is the array of its operands. */
2560 h8300_insn_length_from_table (rtx_insn
*insn
, rtx
* operands
)
2562 switch (get_attr_length_table (insn
))
2564 case LENGTH_TABLE_NONE
:
2567 case LENGTH_TABLE_ADDB
:
2568 return h8300_binary_length (insn
, &addb_length_table
);
2570 case LENGTH_TABLE_ADDW
:
2571 return h8300_binary_length (insn
, &addw_length_table
);
2573 case LENGTH_TABLE_ADDL
:
2574 return h8300_binary_length (insn
, &addl_length_table
);
2576 case LENGTH_TABLE_LOGICB
:
2577 return h8300_binary_length (insn
, &logicb_length_table
);
2579 case LENGTH_TABLE_MOVB
:
2580 return h8300_move_length (operands
, &movb_length_table
);
2582 case LENGTH_TABLE_MOVW
:
2583 return h8300_move_length (operands
, &movw_length_table
);
2585 case LENGTH_TABLE_MOVL
:
2586 return h8300_move_length (operands
, &movl_length_table
);
2588 case LENGTH_TABLE_MOVA
:
2589 return h8300_mova_length (operands
[0], operands
[1], operands
[2]);
2591 case LENGTH_TABLE_MOVA_ZERO
:
2592 return h8300_mova_length (operands
[0], operands
[1], const0_rtx
);
2594 case LENGTH_TABLE_UNARY
:
2595 return h8300_unary_length (operands
[0]);
2597 case LENGTH_TABLE_MOV_IMM4
:
2598 return 2 + h8300_classify_operand (operands
[0], 0, 0);
2600 case LENGTH_TABLE_SHORT_IMMEDIATE
:
2601 return h8300_short_immediate_length (operands
[0]);
2603 case LENGTH_TABLE_BITFIELD
:
2604 return h8300_bitfield_length (operands
[0], operands
[1]);
2606 case LENGTH_TABLE_BITBRANCH
:
2607 return h8300_bitfield_length (operands
[1], operands
[2]) - 2;
2614 /* Return true if LHS and RHS are memory references that can be mapped
2615 to the same h8sx assembly operand. LHS appears as the destination of
2616 an instruction and RHS appears as a source.
2618 Three cases are allowed:
2620 - RHS is @+Rn or @-Rn, LHS is @Rn
2621 - RHS is @Rn, LHS is @Rn+ or @Rn-
2622 - RHS and LHS have the same address and neither has side effects. */
2625 h8sx_mergeable_memrefs_p (rtx lhs
, rtx rhs
)
2627 if (GET_CODE (rhs
) == MEM
&& GET_CODE (lhs
) == MEM
)
2629 rhs
= XEXP (rhs
, 0);
2630 lhs
= XEXP (lhs
, 0);
2632 if (GET_CODE (rhs
) == PRE_INC
|| GET_CODE (rhs
) == PRE_DEC
)
2633 return rtx_equal_p (XEXP (rhs
, 0), lhs
);
2635 if (GET_CODE (lhs
) == POST_INC
|| GET_CODE (lhs
) == POST_DEC
)
2636 return rtx_equal_p (rhs
, XEXP (lhs
, 0));
2638 if (rtx_equal_p (rhs
, lhs
))
2644 /* Return true if OPERANDS[1] can be mapped to the same assembly
2645 operand as OPERANDS[0]. */
2648 h8300_operands_match_p (rtx
*operands
)
2650 if (register_operand (operands
[0], VOIDmode
)
2651 && register_operand (operands
[1], VOIDmode
))
2654 if (h8sx_mergeable_memrefs_p (operands
[0], operands
[1]))
2660 /* Try using movmd to move LENGTH bytes from memory region SRC to memory
2661 region DEST. The two regions do not overlap and have the common
2662 alignment given by ALIGNMENT. Return true on success.
2664 Using movmd for variable-length moves seems to involve some
2665 complex trade-offs. For instance:
2667 - Preparing for a movmd instruction is similar to preparing
2668 for a memcpy. The main difference is that the arguments
2669 are moved into er4, er5 and er6 rather than er0, er1 and er2.
2671 - Since movmd clobbers the frame pointer, we need to save
2672 and restore it somehow when frame_pointer_needed. This can
2673 sometimes make movmd sequences longer than calls to memcpy().
2675 - The counter register is 16 bits, so the instruction is only
2676 suitable for variable-length moves when sizeof (size_t) == 2.
2677 That's only true in normal mode.
2679 - We will often lack static alignment information. Falling back
2680 on movmd.b would likely be slower than calling memcpy(), at least
2683 This function therefore only uses movmd when the length is a
2684 known constant, and only then if -fomit-frame-pointer is in
2685 effect or if we're not optimizing for size.
2687 At the moment the function uses movmd for all in-range constants,
2688 but it might be better to fall back on memcpy() for large moves
2689 if ALIGNMENT == 1. */
2692 h8sx_emit_movmd (rtx dest
, rtx src
, rtx length
,
2693 HOST_WIDE_INT alignment
)
2695 if (!flag_omit_frame_pointer
&& optimize_size
)
2698 if (GET_CODE (length
) == CONST_INT
)
2700 rtx dest_reg
, src_reg
, first_dest
, first_src
;
2704 /* Use movmd.l if the alignment allows it, otherwise fall back
2706 factor
= (alignment
>= 2 ? 4 : 1);
2708 /* Make sure the length is within range. We can handle counter
2709 values up to 65536, although HImode truncation will make
2710 the count appear negative in rtl dumps. */
2711 n
= INTVAL (length
);
2712 if (n
<= 0 || n
/ factor
> 65536)
2715 /* Create temporary registers for the source and destination
2716 pointers. Initialize them to the start of each region. */
2717 dest_reg
= copy_addr_to_reg (XEXP (dest
, 0));
2718 src_reg
= copy_addr_to_reg (XEXP (src
, 0));
2720 /* Create references to the movmd source and destination blocks. */
2721 first_dest
= replace_equiv_address (dest
, dest_reg
);
2722 first_src
= replace_equiv_address (src
, src_reg
);
2724 set_mem_size (first_dest
, n
& -factor
);
2725 set_mem_size (first_src
, n
& -factor
);
2727 length
= copy_to_mode_reg (HImode
, gen_int_mode (n
/ factor
, HImode
));
2728 emit_insn (gen_movmd (first_dest
, first_src
, length
, GEN_INT (factor
)));
2730 if ((n
& -factor
) != n
)
2732 /* Move SRC and DEST past the region we just copied.
2733 This is done to update the memory attributes. */
2734 dest
= adjust_address (dest
, BLKmode
, n
& -factor
);
2735 src
= adjust_address (src
, BLKmode
, n
& -factor
);
2737 /* Replace the addresses with the source and destination
2738 registers, which movmd has left with the right values. */
2739 dest
= replace_equiv_address (dest
, dest_reg
);
2740 src
= replace_equiv_address (src
, src_reg
);
2742 /* Mop up the left-over bytes. */
2744 emit_move_insn (adjust_address (dest
, HImode
, 0),
2745 adjust_address (src
, HImode
, 0));
2747 emit_move_insn (adjust_address (dest
, QImode
, n
& 2),
2748 adjust_address (src
, QImode
, n
& 2));
2755 /* Move ADDR into er6 after pushing its old value onto the stack. */
2758 h8300_swap_into_er6 (rtx addr
)
2760 rtx insn
= push (HARD_FRAME_POINTER_REGNUM
);
2761 if (frame_pointer_needed
)
2762 add_reg_note (insn
, REG_CFA_DEF_CFA
,
2763 plus_constant (Pmode
, gen_rtx_MEM (Pmode
, stack_pointer_rtx
),
2764 2 * UNITS_PER_WORD
));
2766 add_reg_note (insn
, REG_CFA_ADJUST_CFA
,
2767 gen_rtx_SET (VOIDmode
, stack_pointer_rtx
,
2768 plus_constant (Pmode
, stack_pointer_rtx
, 4)));
2770 emit_move_insn (hard_frame_pointer_rtx
, addr
);
2771 if (REGNO (addr
) == SP_REG
)
2772 emit_move_insn (hard_frame_pointer_rtx
,
2773 plus_constant (Pmode
, hard_frame_pointer_rtx
,
2774 GET_MODE_SIZE (word_mode
)));
2777 /* Move the current value of er6 into ADDR and pop its old value
2781 h8300_swap_out_of_er6 (rtx addr
)
2785 if (REGNO (addr
) != SP_REG
)
2786 emit_move_insn (addr
, hard_frame_pointer_rtx
);
2788 insn
= pop (HARD_FRAME_POINTER_REGNUM
);
2789 RTX_FRAME_RELATED_P (insn
) = 1;
2790 if (frame_pointer_needed
)
2791 add_reg_note (insn
, REG_CFA_DEF_CFA
,
2792 plus_constant (Pmode
, hard_frame_pointer_rtx
,
2793 2 * UNITS_PER_WORD
));
2795 add_reg_note (insn
, REG_CFA_ADJUST_CFA
,
2796 gen_rtx_SET (VOIDmode
, stack_pointer_rtx
,
2797 plus_constant (Pmode
, stack_pointer_rtx
, -4)));
2800 /* Return the length of mov instruction. */
2803 compute_mov_length (rtx
*operands
)
2805 /* If the mov instruction involves a memory operand, we compute the
2806 length, assuming the largest addressing mode is used, and then
2807 adjust later in the function. Otherwise, we compute and return
2808 the exact length in one step. */
2809 machine_mode mode
= GET_MODE (operands
[0]);
2810 rtx dest
= operands
[0];
2811 rtx src
= operands
[1];
2814 if (GET_CODE (src
) == MEM
)
2815 addr
= XEXP (src
, 0);
2816 else if (GET_CODE (dest
) == MEM
)
2817 addr
= XEXP (dest
, 0);
2823 unsigned int base_length
;
2828 if (addr
== NULL_RTX
)
2831 /* The eightbit addressing is available only in QImode, so
2832 go ahead and take care of it. */
2833 if (h8300_eightbit_constant_address_p (addr
))
2840 if (addr
== NULL_RTX
)
2845 if (src
== const0_rtx
)
2855 if (addr
== NULL_RTX
)
2860 if (GET_CODE (src
) == CONST_INT
)
2862 if (src
== const0_rtx
)
2865 if ((INTVAL (src
) & 0xffff) == 0)
2868 if ((INTVAL (src
) & 0xffff) == 0)
2871 if ((INTVAL (src
) & 0xffff)
2872 == ((INTVAL (src
) >> 16) & 0xffff))
2882 if (addr
== NULL_RTX
)
2887 if (satisfies_constraint_G (src
))
2900 /* Adjust the length based on the addressing mode used.
2901 Specifically, we subtract the difference between the actual
2902 length and the longest one, which is @(d:16,Rs). For SImode
2903 and SFmode, we double the adjustment because two mov.w are
2904 used to do the job. */
2906 /* @Rs+ and @-Rd are 2 bytes shorter than the longest. */
2907 if (GET_CODE (addr
) == PRE_DEC
2908 || GET_CODE (addr
) == POST_INC
)
2910 if (mode
== QImode
|| mode
== HImode
)
2911 return base_length
- 2;
2913 /* In SImode and SFmode, we use two mov.w instructions, so
2914 double the adjustment. */
2915 return base_length
- 4;
2918 /* @Rs and @Rd are 2 bytes shorter than the longest. Note that
2919 in SImode and SFmode, the second mov.w involves an address
2920 with displacement, namely @(2,Rs) or @(2,Rd), so we subtract
2922 if (GET_CODE (addr
) == REG
)
2923 return base_length
- 2;
2929 unsigned int base_length
;
2934 if (addr
== NULL_RTX
)
2937 /* The eightbit addressing is available only in QImode, so
2938 go ahead and take care of it. */
2939 if (h8300_eightbit_constant_address_p (addr
))
2946 if (addr
== NULL_RTX
)
2951 if (src
== const0_rtx
)
2961 if (addr
== NULL_RTX
)
2965 if (REGNO (src
) == MAC_REG
|| REGNO (dest
) == MAC_REG
)
2971 if (GET_CODE (src
) == CONST_INT
)
2973 int val
= INTVAL (src
);
2978 if (val
== (val
& 0x00ff) || val
== (val
& 0xff00))
2981 switch (val
& 0xffffffff)
3002 if (addr
== NULL_RTX
)
3007 if (satisfies_constraint_G (src
))
3020 /* Adjust the length based on the addressing mode used.
3021 Specifically, we subtract the difference between the actual
3022 length and the longest one, which is @(d:24,ERs). */
3024 /* @ERs+ and @-ERd are 6 bytes shorter than the longest. */
3025 if (GET_CODE (addr
) == PRE_DEC
3026 || GET_CODE (addr
) == POST_INC
)
3027 return base_length
- 6;
3029 /* @ERs and @ERd are 6 bytes shorter than the longest. */
3030 if (GET_CODE (addr
) == REG
)
3031 return base_length
- 6;
3033 /* @(d:16,ERs) and @(d:16,ERd) are 4 bytes shorter than the
3035 if (GET_CODE (addr
) == PLUS
3036 && GET_CODE (XEXP (addr
, 0)) == REG
3037 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
3038 && INTVAL (XEXP (addr
, 1)) > -32768
3039 && INTVAL (XEXP (addr
, 1)) < 32767)
3040 return base_length
- 4;
3042 /* @aa:16 is 4 bytes shorter than the longest. */
3043 if (h8300_tiny_constant_address_p (addr
))
3044 return base_length
- 4;
3046 /* @aa:24 is 2 bytes shorter than the longest. */
3047 if (CONSTANT_P (addr
))
3048 return base_length
- 2;
3054 /* Output an addition insn. */
3057 output_plussi (rtx
*operands
)
3059 machine_mode mode
= GET_MODE (operands
[0]);
3061 gcc_assert (mode
== SImode
);
3065 if (GET_CODE (operands
[2]) == REG
)
3066 return "add.w\t%f2,%f0\n\taddx\t%y2,%y0\n\taddx\t%z2,%z0";
3068 if (GET_CODE (operands
[2]) == CONST_INT
)
3070 HOST_WIDE_INT n
= INTVAL (operands
[2]);
3072 if ((n
& 0xffffff) == 0)
3073 return "add\t%z2,%z0";
3074 if ((n
& 0xffff) == 0)
3075 return "add\t%y2,%y0\n\taddx\t%z2,%z0";
3076 if ((n
& 0xff) == 0)
3077 return "add\t%x2,%x0\n\taddx\t%y2,%y0\n\taddx\t%z2,%z0";
3080 return "add\t%w2,%w0\n\taddx\t%x2,%x0\n\taddx\t%y2,%y0\n\taddx\t%z2,%z0";
3084 if (GET_CODE (operands
[2]) == CONST_INT
3085 && register_operand (operands
[1], VOIDmode
))
3087 HOST_WIDE_INT intval
= INTVAL (operands
[2]);
3089 if (TARGET_H8300SX
&& (intval
>= 1 && intval
<= 7))
3090 return "add.l\t%S2,%S0";
3091 if (TARGET_H8300SX
&& (intval
>= -7 && intval
<= -1))
3092 return "sub.l\t%G2,%S0";
3094 /* See if we can finish with 2 bytes. */
3096 switch ((unsigned int) intval
& 0xffffffff)
3101 return "adds\t%2,%S0";
3106 return "subs\t%G2,%S0";
3110 operands
[2] = GEN_INT (intval
>> 16);
3111 return "inc.w\t%2,%e0";
3115 operands
[2] = GEN_INT (intval
>> 16);
3116 return "dec.w\t%G2,%e0";
3119 /* See if we can finish with 4 bytes. */
3120 if ((intval
& 0xffff) == 0)
3122 operands
[2] = GEN_INT (intval
>> 16);
3123 return "add.w\t%2,%e0";
3127 if (GET_CODE (operands
[2]) == CONST_INT
&& INTVAL (operands
[2]) < 0)
3129 operands
[2] = GEN_INT (-INTVAL (operands
[2]));
3130 return "sub.l\t%S2,%S0";
3132 return "add.l\t%S2,%S0";
3136 /* ??? It would be much easier to add the h8sx stuff if a single function
3137 classified the addition as either inc/dec, adds/subs, add.w or add.l. */
3138 /* Compute the length of an addition insn. */
3141 compute_plussi_length (rtx
*operands
)
3143 machine_mode mode
= GET_MODE (operands
[0]);
3145 gcc_assert (mode
== SImode
);
3149 if (GET_CODE (operands
[2]) == REG
)
3152 if (GET_CODE (operands
[2]) == CONST_INT
)
3154 HOST_WIDE_INT n
= INTVAL (operands
[2]);
3156 if ((n
& 0xffffff) == 0)
3158 if ((n
& 0xffff) == 0)
3160 if ((n
& 0xff) == 0)
3168 if (GET_CODE (operands
[2]) == CONST_INT
3169 && register_operand (operands
[1], VOIDmode
))
3171 HOST_WIDE_INT intval
= INTVAL (operands
[2]);
3173 if (TARGET_H8300SX
&& (intval
>= 1 && intval
<= 7))
3175 if (TARGET_H8300SX
&& (intval
>= -7 && intval
<= -1))
3178 /* See if we can finish with 2 bytes. */
3180 switch ((unsigned int) intval
& 0xffffffff)
3201 /* See if we can finish with 4 bytes. */
3202 if ((intval
& 0xffff) == 0)
3206 if (GET_CODE (operands
[2]) == CONST_INT
&& INTVAL (operands
[2]) < 0)
3207 return h8300_length_from_table (operands
[0],
3208 GEN_INT (-INTVAL (operands
[2])),
3209 &addl_length_table
);
3211 return h8300_length_from_table (operands
[0], operands
[2],
3212 &addl_length_table
);
3217 /* Compute which flag bits are valid after an addition insn. */
3220 compute_plussi_cc (rtx
*operands
)
3222 machine_mode mode
= GET_MODE (operands
[0]);
3224 gcc_assert (mode
== SImode
);
3232 if (GET_CODE (operands
[2]) == CONST_INT
3233 && register_operand (operands
[1], VOIDmode
))
3235 HOST_WIDE_INT intval
= INTVAL (operands
[2]);
3237 if (TARGET_H8300SX
&& (intval
>= 1 && intval
<= 7))
3239 if (TARGET_H8300SX
&& (intval
>= -7 && intval
<= -1))
3242 /* See if we can finish with 2 bytes. */
3244 switch ((unsigned int) intval
& 0xffffffff)
3249 return CC_NONE_0HIT
;
3254 return CC_NONE_0HIT
;
3265 /* See if we can finish with 4 bytes. */
3266 if ((intval
& 0xffff) == 0)
3274 /* Output a logical insn. */
3277 output_logical_op (machine_mode mode
, rtx
*operands
)
3279 /* Figure out the logical op that we need to perform. */
3280 enum rtx_code code
= GET_CODE (operands
[3]);
3281 /* Pretend that every byte is affected if both operands are registers. */
3282 const unsigned HOST_WIDE_INT intval
=
3283 (unsigned HOST_WIDE_INT
) ((GET_CODE (operands
[2]) == CONST_INT
)
3284 /* Always use the full instruction if the
3285 first operand is in memory. It is better
3286 to use define_splits to generate the shorter
3287 sequence where valid. */
3288 && register_operand (operands
[1], VOIDmode
)
3289 ? INTVAL (operands
[2]) : 0x55555555);
3290 /* The determinant of the algorithm. If we perform an AND, 0
3291 affects a bit. Otherwise, 1 affects a bit. */
3292 const unsigned HOST_WIDE_INT det
= (code
!= AND
) ? intval
: ~intval
;
3293 /* Break up DET into pieces. */
3294 const unsigned HOST_WIDE_INT b0
= (det
>> 0) & 0xff;
3295 const unsigned HOST_WIDE_INT b1
= (det
>> 8) & 0xff;
3296 const unsigned HOST_WIDE_INT b2
= (det
>> 16) & 0xff;
3297 const unsigned HOST_WIDE_INT b3
= (det
>> 24) & 0xff;
3298 const unsigned HOST_WIDE_INT w0
= (det
>> 0) & 0xffff;
3299 const unsigned HOST_WIDE_INT w1
= (det
>> 16) & 0xffff;
3300 int lower_half_easy_p
= 0;
3301 int upper_half_easy_p
= 0;
3302 /* The name of an insn. */
3324 /* First, see if we can finish with one insn. */
3325 if ((TARGET_H8300H
|| TARGET_H8300S
)
3329 sprintf (insn_buf
, "%s.w\t%%T2,%%T0", opname
);
3330 output_asm_insn (insn_buf
, operands
);
3334 /* Take care of the lower byte. */
3337 sprintf (insn_buf
, "%s\t%%s2,%%s0", opname
);
3338 output_asm_insn (insn_buf
, operands
);
3340 /* Take care of the upper byte. */
3343 sprintf (insn_buf
, "%s\t%%t2,%%t0", opname
);
3344 output_asm_insn (insn_buf
, operands
);
3349 if (TARGET_H8300H
|| TARGET_H8300S
)
3351 /* Determine if the lower half can be taken care of in no more
3353 lower_half_easy_p
= (b0
== 0
3355 || (code
!= IOR
&& w0
== 0xffff));
3357 /* Determine if the upper half can be taken care of in no more
3359 upper_half_easy_p
= ((code
!= IOR
&& w1
== 0xffff)
3360 || (code
== AND
&& w1
== 0xff00));
3363 /* Check if doing everything with one insn is no worse than
3364 using multiple insns. */
3365 if ((TARGET_H8300H
|| TARGET_H8300S
)
3366 && w0
!= 0 && w1
!= 0
3367 && !(lower_half_easy_p
&& upper_half_easy_p
)
3368 && !(code
== IOR
&& w1
== 0xffff
3369 && (w0
& 0x8000) != 0 && lower_half_easy_p
))
3371 sprintf (insn_buf
, "%s.l\t%%S2,%%S0", opname
);
3372 output_asm_insn (insn_buf
, operands
);
3376 /* Take care of the lower and upper words individually. For
3377 each word, we try different methods in the order of
3379 1) the special insn (in case of AND or XOR),
3380 2) the word-wise insn, and
3381 3) The byte-wise insn. */
3383 && (TARGET_H8300
? (code
== AND
) : (code
!= IOR
)))
3384 output_asm_insn ((code
== AND
)
3385 ? "sub.w\t%f0,%f0" : "not.w\t%f0",
3387 else if ((TARGET_H8300H
|| TARGET_H8300S
)
3391 sprintf (insn_buf
, "%s.w\t%%f2,%%f0", opname
);
3392 output_asm_insn (insn_buf
, operands
);
3398 sprintf (insn_buf
, "%s\t%%w2,%%w0", opname
);
3399 output_asm_insn (insn_buf
, operands
);
3403 sprintf (insn_buf
, "%s\t%%x2,%%x0", opname
);
3404 output_asm_insn (insn_buf
, operands
);
3409 && (TARGET_H8300
? (code
== AND
) : (code
!= IOR
)))
3410 output_asm_insn ((code
== AND
)
3411 ? "sub.w\t%e0,%e0" : "not.w\t%e0",
3413 else if ((TARGET_H8300H
|| TARGET_H8300S
)
3416 && (w0
& 0x8000) != 0)
3418 output_asm_insn ("exts.l\t%S0", operands
);
3420 else if ((TARGET_H8300H
|| TARGET_H8300S
)
3424 output_asm_insn ("extu.w\t%e0", operands
);
3426 else if (TARGET_H8300H
|| TARGET_H8300S
)
3430 sprintf (insn_buf
, "%s.w\t%%e2,%%e0", opname
);
3431 output_asm_insn (insn_buf
, operands
);
3438 sprintf (insn_buf
, "%s\t%%y2,%%y0", opname
);
3439 output_asm_insn (insn_buf
, operands
);
3443 sprintf (insn_buf
, "%s\t%%z2,%%z0", opname
);
3444 output_asm_insn (insn_buf
, operands
);
3455 /* Compute the length of a logical insn. */
3458 compute_logical_op_length (machine_mode mode
, rtx
*operands
)
3460 /* Figure out the logical op that we need to perform. */
3461 enum rtx_code code
= GET_CODE (operands
[3]);
3462 /* Pretend that every byte is affected if both operands are registers. */
3463 const unsigned HOST_WIDE_INT intval
=
3464 (unsigned HOST_WIDE_INT
) ((GET_CODE (operands
[2]) == CONST_INT
)
3465 /* Always use the full instruction if the
3466 first operand is in memory. It is better
3467 to use define_splits to generate the shorter
3468 sequence where valid. */
3469 && register_operand (operands
[1], VOIDmode
)
3470 ? INTVAL (operands
[2]) : 0x55555555);
3471 /* The determinant of the algorithm. If we perform an AND, 0
3472 affects a bit. Otherwise, 1 affects a bit. */
3473 const unsigned HOST_WIDE_INT det
= (code
!= AND
) ? intval
: ~intval
;
3474 /* Break up DET into pieces. */
3475 const unsigned HOST_WIDE_INT b0
= (det
>> 0) & 0xff;
3476 const unsigned HOST_WIDE_INT b1
= (det
>> 8) & 0xff;
3477 const unsigned HOST_WIDE_INT b2
= (det
>> 16) & 0xff;
3478 const unsigned HOST_WIDE_INT b3
= (det
>> 24) & 0xff;
3479 const unsigned HOST_WIDE_INT w0
= (det
>> 0) & 0xffff;
3480 const unsigned HOST_WIDE_INT w1
= (det
>> 16) & 0xffff;
3481 int lower_half_easy_p
= 0;
3482 int upper_half_easy_p
= 0;
3484 unsigned int length
= 0;
3489 /* First, see if we can finish with one insn. */
3490 if ((TARGET_H8300H
|| TARGET_H8300S
)
3494 length
= h8300_length_from_table (operands
[1], operands
[2],
3495 &logicw_length_table
);
3499 /* Take care of the lower byte. */
3503 /* Take care of the upper byte. */
3509 if (TARGET_H8300H
|| TARGET_H8300S
)
3511 /* Determine if the lower half can be taken care of in no more
3513 lower_half_easy_p
= (b0
== 0
3515 || (code
!= IOR
&& w0
== 0xffff));
3517 /* Determine if the upper half can be taken care of in no more
3519 upper_half_easy_p
= ((code
!= IOR
&& w1
== 0xffff)
3520 || (code
== AND
&& w1
== 0xff00));
3523 /* Check if doing everything with one insn is no worse than
3524 using multiple insns. */
3525 if ((TARGET_H8300H
|| TARGET_H8300S
)
3526 && w0
!= 0 && w1
!= 0
3527 && !(lower_half_easy_p
&& upper_half_easy_p
)
3528 && !(code
== IOR
&& w1
== 0xffff
3529 && (w0
& 0x8000) != 0 && lower_half_easy_p
))
3531 length
= h8300_length_from_table (operands
[1], operands
[2],
3532 &logicl_length_table
);
3536 /* Take care of the lower and upper words individually. For
3537 each word, we try different methods in the order of
3539 1) the special insn (in case of AND or XOR),
3540 2) the word-wise insn, and
3541 3) The byte-wise insn. */
3543 && (TARGET_H8300
? (code
== AND
) : (code
!= IOR
)))
3547 else if ((TARGET_H8300H
|| TARGET_H8300S
)
3563 && (TARGET_H8300
? (code
== AND
) : (code
!= IOR
)))
3567 else if ((TARGET_H8300H
|| TARGET_H8300S
)
3570 && (w0
& 0x8000) != 0)
3574 else if ((TARGET_H8300H
|| TARGET_H8300S
)
3580 else if (TARGET_H8300H
|| TARGET_H8300S
)
3601 /* Compute which flag bits are valid after a logical insn. */
3604 compute_logical_op_cc (machine_mode mode
, rtx
*operands
)
3606 /* Figure out the logical op that we need to perform. */
3607 enum rtx_code code
= GET_CODE (operands
[3]);
3608 /* Pretend that every byte is affected if both operands are registers. */
3609 const unsigned HOST_WIDE_INT intval
=
3610 (unsigned HOST_WIDE_INT
) ((GET_CODE (operands
[2]) == CONST_INT
)
3611 /* Always use the full instruction if the
3612 first operand is in memory. It is better
3613 to use define_splits to generate the shorter
3614 sequence where valid. */
3615 && register_operand (operands
[1], VOIDmode
)
3616 ? INTVAL (operands
[2]) : 0x55555555);
3617 /* The determinant of the algorithm. If we perform an AND, 0
3618 affects a bit. Otherwise, 1 affects a bit. */
3619 const unsigned HOST_WIDE_INT det
= (code
!= AND
) ? intval
: ~intval
;
3620 /* Break up DET into pieces. */
3621 const unsigned HOST_WIDE_INT b0
= (det
>> 0) & 0xff;
3622 const unsigned HOST_WIDE_INT b1
= (det
>> 8) & 0xff;
3623 const unsigned HOST_WIDE_INT w0
= (det
>> 0) & 0xffff;
3624 const unsigned HOST_WIDE_INT w1
= (det
>> 16) & 0xffff;
3625 int lower_half_easy_p
= 0;
3626 int upper_half_easy_p
= 0;
3627 /* Condition code. */
3628 enum attr_cc cc
= CC_CLOBBER
;
3633 /* First, see if we can finish with one insn. */
3634 if ((TARGET_H8300H
|| TARGET_H8300S
)
3642 if (TARGET_H8300H
|| TARGET_H8300S
)
3644 /* Determine if the lower half can be taken care of in no more
3646 lower_half_easy_p
= (b0
== 0
3648 || (code
!= IOR
&& w0
== 0xffff));
3650 /* Determine if the upper half can be taken care of in no more
3652 upper_half_easy_p
= ((code
!= IOR
&& w1
== 0xffff)
3653 || (code
== AND
&& w1
== 0xff00));
3656 /* Check if doing everything with one insn is no worse than
3657 using multiple insns. */
3658 if ((TARGET_H8300H
|| TARGET_H8300S
)
3659 && w0
!= 0 && w1
!= 0
3660 && !(lower_half_easy_p
&& upper_half_easy_p
)
3661 && !(code
== IOR
&& w1
== 0xffff
3662 && (w0
& 0x8000) != 0 && lower_half_easy_p
))
3668 if ((TARGET_H8300H
|| TARGET_H8300S
)
3671 && (w0
& 0x8000) != 0)
3683 /* Expand a conditional branch. */
3686 h8300_expand_branch (rtx operands
[])
3688 enum rtx_code code
= GET_CODE (operands
[0]);
3689 rtx op0
= operands
[1];
3690 rtx op1
= operands
[2];
3691 rtx label
= operands
[3];
3694 tmp
= gen_rtx_COMPARE (VOIDmode
, op0
, op1
);
3695 emit_insn (gen_rtx_SET (VOIDmode
, cc0_rtx
, tmp
));
3697 tmp
= gen_rtx_fmt_ee (code
, VOIDmode
, cc0_rtx
, const0_rtx
);
3698 tmp
= gen_rtx_IF_THEN_ELSE (VOIDmode
, tmp
,
3699 gen_rtx_LABEL_REF (VOIDmode
, label
),
3701 emit_jump_insn (gen_rtx_SET (VOIDmode
, pc_rtx
, tmp
));
3705 /* Expand a conditional store. */
3708 h8300_expand_store (rtx operands
[])
3710 rtx dest
= operands
[0];
3711 enum rtx_code code
= GET_CODE (operands
[1]);
3712 rtx op0
= operands
[2];
3713 rtx op1
= operands
[3];
3716 tmp
= gen_rtx_COMPARE (VOIDmode
, op0
, op1
);
3717 emit_insn (gen_rtx_SET (VOIDmode
, cc0_rtx
, tmp
));
3719 tmp
= gen_rtx_fmt_ee (code
, GET_MODE (dest
), cc0_rtx
, const0_rtx
);
3720 emit_insn (gen_rtx_SET (VOIDmode
, dest
, tmp
));
3725 We devote a fair bit of code to getting efficient shifts since we
3726 can only shift one bit at a time on the H8/300 and H8/300H and only
3727 one or two bits at a time on the H8S.
3729 All shift code falls into one of the following ways of
3732 o SHIFT_INLINE: Emit straight line code for the shift; this is used
3733 when a straight line shift is about the same size or smaller than
3736 o SHIFT_ROT_AND: Rotate the value the opposite direction, then mask
3737 off the bits we don't need. This is used when only a few of the
3738 bits in the original value will survive in the shifted value.
3740 o SHIFT_SPECIAL: Often it's possible to move a byte or a word to
3741 simulate a shift by 8, 16, or 24 bits. Once moved, a few inline
3742 shifts can be added if the shift count is slightly more than 8 or
3743 16. This case also includes other oddballs that are not worth
3746 o SHIFT_LOOP: Emit a loop using one (or two on H8S) bit shifts.
3748 For each shift count, we try to use code that has no trade-off
3749 between code size and speed whenever possible.
3751 If the trade-off is unavoidable, we try to be reasonable.
3752 Specifically, the fastest version is one instruction longer than
3753 the shortest version, we take the fastest version. We also provide
3754 the use a way to switch back to the shortest version with -Os.
3756 For the details of the shift algorithms for various shift counts,
3757 refer to shift_alg_[qhs]i. */
3759 /* Classify a shift with the given mode and code. OP is the shift amount. */
3761 enum h8sx_shift_type
3762 h8sx_classify_shift (machine_mode mode
, enum rtx_code code
, rtx op
)
3764 if (!TARGET_H8300SX
)
3765 return H8SX_SHIFT_NONE
;
3771 /* Check for variable shifts (shll Rs,Rd and shlr Rs,Rd). */
3772 if (GET_CODE (op
) != CONST_INT
)
3773 return H8SX_SHIFT_BINARY
;
3775 /* Reject out-of-range shift amounts. */
3776 if (INTVAL (op
) <= 0 || INTVAL (op
) >= GET_MODE_BITSIZE (mode
))
3777 return H8SX_SHIFT_NONE
;
3779 /* Power-of-2 shifts are effectively unary operations. */
3780 if (exact_log2 (INTVAL (op
)) >= 0)
3781 return H8SX_SHIFT_UNARY
;
3783 return H8SX_SHIFT_BINARY
;
3786 if (op
== const1_rtx
|| op
== const2_rtx
)
3787 return H8SX_SHIFT_UNARY
;
3788 return H8SX_SHIFT_NONE
;
3791 if (GET_CODE (op
) == CONST_INT
3792 && (INTVAL (op
) == 1
3794 || INTVAL (op
) == GET_MODE_BITSIZE (mode
) - 2
3795 || INTVAL (op
) == GET_MODE_BITSIZE (mode
) - 1))
3796 return H8SX_SHIFT_UNARY
;
3797 return H8SX_SHIFT_NONE
;
3800 return H8SX_SHIFT_NONE
;
3804 /* Return the asm template for a single h8sx shift instruction.
3805 OPERANDS[0] and OPERANDS[1] are the destination, OPERANDS[2]
3806 is the source and OPERANDS[3] is the shift. SUFFIX is the
3807 size suffix ('b', 'w' or 'l') and OPTYPE is the h8300_print_operand
3808 prefix for the destination operand. */
3811 output_h8sx_shift (rtx
*operands
, int suffix
, int optype
)
3813 static char buffer
[16];
3816 switch (GET_CODE (operands
[3]))
3832 if (INTVAL (operands
[2]) > 2)
3834 /* This is really a right rotate. */
3835 operands
[2] = GEN_INT (GET_MODE_BITSIZE (GET_MODE (operands
[0]))
3836 - INTVAL (operands
[2]));
3844 if (operands
[2] == const1_rtx
)
3845 sprintf (buffer
, "%s.%c\t%%%c0", stem
, suffix
, optype
);
3847 sprintf (buffer
, "%s.%c\t%%X2,%%%c0", stem
, suffix
, optype
);
3851 /* Emit code to do shifts. */
3854 expand_a_shift (machine_mode mode
, enum rtx_code code
, rtx operands
[])
3856 switch (h8sx_classify_shift (mode
, code
, operands
[2]))
3858 case H8SX_SHIFT_BINARY
:
3859 operands
[1] = force_reg (mode
, operands
[1]);
3862 case H8SX_SHIFT_UNARY
:
3865 case H8SX_SHIFT_NONE
:
3869 emit_move_insn (copy_rtx (operands
[0]), operands
[1]);
3871 /* Need a loop to get all the bits we want - we generate the
3872 code at emit time, but need to allocate a scratch reg now. */
3874 emit_insn (gen_rtx_PARALLEL
3877 gen_rtx_SET (VOIDmode
, copy_rtx (operands
[0]),
3878 gen_rtx_fmt_ee (code
, mode
,
3879 copy_rtx (operands
[0]), operands
[2])),
3880 gen_rtx_CLOBBER (VOIDmode
,
3881 gen_rtx_SCRATCH (QImode
)))));
3885 /* Symbols of the various modes which can be used as indices. */
3889 QIshift
, HIshift
, SIshift
3892 /* For single bit shift insns, record assembler and what bits of the
3893 condition code are valid afterwards (represented as various CC_FOO
3894 bits, 0 means CC isn't left in a usable state). */
3898 const char *const assembler
;
3899 const enum attr_cc cc_valid
;
3902 /* Assembler instruction shift table.
3904 These tables are used to look up the basic shifts.
3905 They are indexed by cpu, shift_type, and mode. */
3907 static const struct shift_insn shift_one
[2][3][3] =
3913 { "shll\t%X0", CC_SET_ZNV
},
3914 { "add.w\t%T0,%T0", CC_SET_ZN
},
3915 { "add.w\t%f0,%f0\n\taddx\t%y0,%y0\n\taddx\t%z0,%z0", CC_CLOBBER
}
3917 /* SHIFT_LSHIFTRT */
3919 { "shlr\t%X0", CC_SET_ZNV
},
3920 { "shlr\t%t0\n\trotxr\t%s0", CC_CLOBBER
},
3921 { "shlr\t%z0\n\trotxr\t%y0\n\trotxr\t%x0\n\trotxr\t%w0", CC_CLOBBER
}
3923 /* SHIFT_ASHIFTRT */
3925 { "shar\t%X0", CC_SET_ZNV
},
3926 { "shar\t%t0\n\trotxr\t%s0", CC_CLOBBER
},
3927 { "shar\t%z0\n\trotxr\t%y0\n\trotxr\t%x0\n\trotxr\t%w0", CC_CLOBBER
}
3934 { "shll.b\t%X0", CC_SET_ZNV
},
3935 { "shll.w\t%T0", CC_SET_ZNV
},
3936 { "shll.l\t%S0", CC_SET_ZNV
}
3938 /* SHIFT_LSHIFTRT */
3940 { "shlr.b\t%X0", CC_SET_ZNV
},
3941 { "shlr.w\t%T0", CC_SET_ZNV
},
3942 { "shlr.l\t%S0", CC_SET_ZNV
}
3944 /* SHIFT_ASHIFTRT */
3946 { "shar.b\t%X0", CC_SET_ZNV
},
3947 { "shar.w\t%T0", CC_SET_ZNV
},
3948 { "shar.l\t%S0", CC_SET_ZNV
}
3953 static const struct shift_insn shift_two
[3][3] =
3957 { "shll.b\t#2,%X0", CC_SET_ZNV
},
3958 { "shll.w\t#2,%T0", CC_SET_ZNV
},
3959 { "shll.l\t#2,%S0", CC_SET_ZNV
}
3961 /* SHIFT_LSHIFTRT */
3963 { "shlr.b\t#2,%X0", CC_SET_ZNV
},
3964 { "shlr.w\t#2,%T0", CC_SET_ZNV
},
3965 { "shlr.l\t#2,%S0", CC_SET_ZNV
}
3967 /* SHIFT_ASHIFTRT */
3969 { "shar.b\t#2,%X0", CC_SET_ZNV
},
3970 { "shar.w\t#2,%T0", CC_SET_ZNV
},
3971 { "shar.l\t#2,%S0", CC_SET_ZNV
}
3975 /* Rotates are organized by which shift they'll be used in implementing.
3976 There's no need to record whether the cc is valid afterwards because
3977 it is the AND insn that will decide this. */
3979 static const char *const rotate_one
[2][3][3] =
3986 "shlr\t%t0\n\trotxr\t%s0\n\tbst\t#7,%t0",
3989 /* SHIFT_LSHIFTRT */
3992 "shll\t%s0\n\trotxl\t%t0\n\tbst\t#0,%s0",
3995 /* SHIFT_ASHIFTRT */
3998 "shll\t%s0\n\trotxl\t%t0\n\tbst\t#0,%s0",
4010 /* SHIFT_LSHIFTRT */
4016 /* SHIFT_ASHIFTRT */
4025 static const char *const rotate_two
[3][3] =
4033 /* SHIFT_LSHIFTRT */
4039 /* SHIFT_ASHIFTRT */
4048 /* Shift algorithm. */
4051 /* The number of bits to be shifted by shift1 and shift2. Valid
4052 when ALG is SHIFT_SPECIAL. */
4053 unsigned int remainder
;
4055 /* Special insn for a shift. Valid when ALG is SHIFT_SPECIAL. */
4056 const char *special
;
4058 /* Insn for a one-bit shift. Valid when ALG is either SHIFT_INLINE
4059 or SHIFT_SPECIAL, and REMAINDER is nonzero. */
4062 /* Insn for a two-bit shift. Valid when ALG is either SHIFT_INLINE
4063 or SHIFT_SPECIAL, and REMAINDER is nonzero. */
4066 /* CC status for SHIFT_INLINE. */
4067 enum attr_cc cc_inline
;
4069 /* CC status for SHIFT_SPECIAL. */
4070 enum attr_cc cc_special
;
4073 static void get_shift_alg (enum shift_type
,
4074 enum shift_mode
, unsigned int,
4075 struct shift_info
*);
4077 /* Given SHIFT_TYPE, SHIFT_MODE, and shift count COUNT, determine the
4078 best algorithm for doing the shift. The assembler code is stored
4079 in the pointers in INFO. We achieve the maximum efficiency in most
4080 cases when !TARGET_H8300. In case of TARGET_H8300, shifts in
4081 SImode in particular have a lot of room to optimize.
4083 We first determine the strategy of the shift algorithm by a table
4084 lookup. If that tells us to use a hand crafted assembly code, we
4085 go into the big switch statement to find what that is. Otherwise,
4086 we resort to a generic way, such as inlining. In either case, the
4087 result is returned through INFO. */
4090 get_shift_alg (enum shift_type shift_type
, enum shift_mode shift_mode
,
4091 unsigned int count
, struct shift_info
*info
)
4095 /* Find the target CPU. */
4098 else if (TARGET_H8300H
)
4103 /* Find the shift algorithm. */
4104 info
->alg
= SHIFT_LOOP
;
4108 if (count
< GET_MODE_BITSIZE (QImode
))
4109 info
->alg
= shift_alg_qi
[cpu
][shift_type
][count
];
4113 if (count
< GET_MODE_BITSIZE (HImode
))
4114 info
->alg
= shift_alg_hi
[cpu
][shift_type
][count
];
4118 if (count
< GET_MODE_BITSIZE (SImode
))
4119 info
->alg
= shift_alg_si
[cpu
][shift_type
][count
];
4126 /* Fill in INFO. Return unless we have SHIFT_SPECIAL. */
4130 info
->remainder
= count
;
4134 /* It is up to the caller to know that looping clobbers cc. */
4135 info
->shift1
= shift_one
[cpu_type
][shift_type
][shift_mode
].assembler
;
4136 info
->shift2
= shift_two
[shift_type
][shift_mode
].assembler
;
4137 info
->cc_inline
= shift_one
[cpu_type
][shift_type
][shift_mode
].cc_valid
;
4141 info
->shift1
= rotate_one
[cpu_type
][shift_type
][shift_mode
];
4142 info
->shift2
= rotate_two
[shift_type
][shift_mode
];
4143 info
->cc_inline
= CC_CLOBBER
;
4147 /* REMAINDER is 0 for most cases, so initialize it to 0. */
4148 info
->remainder
= 0;
4149 info
->shift1
= shift_one
[cpu_type
][shift_type
][shift_mode
].assembler
;
4150 info
->shift2
= shift_two
[shift_type
][shift_mode
].assembler
;
4151 info
->cc_inline
= shift_one
[cpu_type
][shift_type
][shift_mode
].cc_valid
;
4152 info
->cc_special
= CC_CLOBBER
;
4156 /* Here we only deal with SHIFT_SPECIAL. */
4160 /* For ASHIFTRT by 7 bits, the sign bit is simply replicated
4161 through the entire value. */
4162 gcc_assert (shift_type
== SHIFT_ASHIFTRT
&& count
== 7);
4163 info
->special
= "shll\t%X0\n\tsubx\t%X0,%X0";
4173 info
->special
= "shar.b\t%t0\n\tmov.b\t%s0,%t0\n\trotxr.b\t%t0\n\trotr.b\t%s0\n\tand.b\t#0x80,%s0";
4175 info
->special
= "shar.b\t%t0\n\tmov.b\t%s0,%t0\n\trotxr.w\t%T0\n\tand.b\t#0x80,%s0";
4177 case SHIFT_LSHIFTRT
:
4179 info
->special
= "shal.b\t%s0\n\tmov.b\t%t0,%s0\n\trotxl.b\t%s0\n\trotl.b\t%t0\n\tand.b\t#0x01,%t0";
4181 info
->special
= "shal.b\t%s0\n\tmov.b\t%t0,%s0\n\trotxl.w\t%T0\n\tand.b\t#0x01,%t0";
4183 case SHIFT_ASHIFTRT
:
4184 info
->special
= "shal.b\t%s0\n\tmov.b\t%t0,%s0\n\trotxl.b\t%s0\n\tsubx\t%t0,%t0";
4188 else if ((8 <= count
&& count
<= 13)
4189 || (TARGET_H8300S
&& count
== 14))
4191 info
->remainder
= count
- 8;
4196 info
->special
= "mov.b\t%s0,%t0\n\tsub.b\t%s0,%s0";
4198 case SHIFT_LSHIFTRT
:
4201 info
->special
= "mov.b\t%t0,%s0\n\tsub.b\t%t0,%t0";
4202 info
->shift1
= "shlr.b\t%s0";
4203 info
->cc_inline
= CC_SET_ZNV
;
4207 info
->special
= "mov.b\t%t0,%s0\n\textu.w\t%T0";
4208 info
->cc_special
= CC_SET_ZNV
;
4211 case SHIFT_ASHIFTRT
:
4214 info
->special
= "mov.b\t%t0,%s0\n\tbld\t#7,%s0\n\tsubx\t%t0,%t0";
4215 info
->shift1
= "shar.b\t%s0";
4219 info
->special
= "mov.b\t%t0,%s0\n\texts.w\t%T0";
4220 info
->cc_special
= CC_SET_ZNV
;
4225 else if (count
== 14)
4231 info
->special
= "mov.b\t%s0,%t0\n\trotr.b\t%t0\n\trotr.b\t%t0\n\tand.b\t#0xC0,%t0\n\tsub.b\t%s0,%s0";
4233 case SHIFT_LSHIFTRT
:
4235 info
->special
= "mov.b\t%t0,%s0\n\trotl.b\t%s0\n\trotl.b\t%s0\n\tand.b\t#3,%s0\n\tsub.b\t%t0,%t0";
4237 case SHIFT_ASHIFTRT
:
4239 info
->special
= "mov.b\t%t0,%s0\n\tshll.b\t%s0\n\tsubx.b\t%t0,%t0\n\tshll.b\t%s0\n\tmov.b\t%t0,%s0\n\tbst.b\t#0,%s0";
4240 else if (TARGET_H8300H
)
4242 info
->special
= "shll.b\t%t0\n\tsubx.b\t%s0,%s0\n\tshll.b\t%t0\n\trotxl.b\t%s0\n\texts.w\t%T0";
4243 info
->cc_special
= CC_SET_ZNV
;
4245 else /* TARGET_H8300S */
4250 else if (count
== 15)
4255 info
->special
= "bld\t#0,%s0\n\txor\t%s0,%s0\n\txor\t%t0,%t0\n\tbst\t#7,%t0";
4257 case SHIFT_LSHIFTRT
:
4258 info
->special
= "bld\t#7,%t0\n\txor\t%s0,%s0\n\txor\t%t0,%t0\n\tbst\t#0,%s0";
4260 case SHIFT_ASHIFTRT
:
4261 info
->special
= "shll\t%t0\n\tsubx\t%t0,%t0\n\tmov.b\t%t0,%s0";
4268 if (TARGET_H8300
&& 8 <= count
&& count
<= 9)
4270 info
->remainder
= count
- 8;
4275 info
->special
= "mov.b\t%y0,%z0\n\tmov.b\t%x0,%y0\n\tmov.b\t%w0,%x0\n\tsub.b\t%w0,%w0";
4277 case SHIFT_LSHIFTRT
:
4278 info
->special
= "mov.b\t%x0,%w0\n\tmov.b\t%y0,%x0\n\tmov.b\t%z0,%y0\n\tsub.b\t%z0,%z0";
4279 info
->shift1
= "shlr\t%y0\n\trotxr\t%x0\n\trotxr\t%w0";
4281 case SHIFT_ASHIFTRT
:
4282 info
->special
= "mov.b\t%x0,%w0\n\tmov.b\t%y0,%x0\n\tmov.b\t%z0,%y0\n\tshll\t%z0\n\tsubx\t%z0,%z0";
4286 else if (count
== 8 && !TARGET_H8300
)
4291 info
->special
= "mov.w\t%e0,%f4\n\tmov.b\t%s4,%t4\n\tmov.b\t%t0,%s4\n\tmov.b\t%s0,%t0\n\tsub.b\t%s0,%s0\n\tmov.w\t%f4,%e0";
4293 case SHIFT_LSHIFTRT
:
4294 info
->special
= "mov.w\t%e0,%f4\n\tmov.b\t%t0,%s0\n\tmov.b\t%s4,%t0\n\tmov.b\t%t4,%s4\n\textu.w\t%f4\n\tmov.w\t%f4,%e0";
4296 case SHIFT_ASHIFTRT
:
4297 info
->special
= "mov.w\t%e0,%f4\n\tmov.b\t%t0,%s0\n\tmov.b\t%s4,%t0\n\tmov.b\t%t4,%s4\n\texts.w\t%f4\n\tmov.w\t%f4,%e0";
4301 else if (count
== 15 && TARGET_H8300
)
4307 case SHIFT_LSHIFTRT
:
4308 info
->special
= "bld\t#7,%z0\n\tmov.w\t%e0,%f0\n\txor\t%y0,%y0\n\txor\t%z0,%z0\n\trotxl\t%w0\n\trotxl\t%x0\n\trotxl\t%y0";
4310 case SHIFT_ASHIFTRT
:
4311 info
->special
= "bld\t#7,%z0\n\tmov.w\t%e0,%f0\n\trotxl\t%w0\n\trotxl\t%x0\n\tsubx\t%y0,%y0\n\tsubx\t%z0,%z0";
4315 else if (count
== 15 && !TARGET_H8300
)
4320 info
->special
= "shlr.w\t%e0\n\tmov.w\t%f0,%e0\n\txor.w\t%f0,%f0\n\trotxr.l\t%S0";
4321 info
->cc_special
= CC_SET_ZNV
;
4323 case SHIFT_LSHIFTRT
:
4324 info
->special
= "shll.w\t%f0\n\tmov.w\t%e0,%f0\n\txor.w\t%e0,%e0\n\trotxl.l\t%S0";
4325 info
->cc_special
= CC_SET_ZNV
;
4327 case SHIFT_ASHIFTRT
:
4331 else if ((TARGET_H8300
&& 16 <= count
&& count
<= 20)
4332 || (TARGET_H8300H
&& 16 <= count
&& count
<= 19)
4333 || (TARGET_H8300S
&& 16 <= count
&& count
<= 21))
4335 info
->remainder
= count
- 16;
4340 info
->special
= "mov.w\t%f0,%e0\n\tsub.w\t%f0,%f0";
4342 info
->shift1
= "add.w\t%e0,%e0";
4344 case SHIFT_LSHIFTRT
:
4347 info
->special
= "mov.w\t%e0,%f0\n\tsub.w\t%e0,%e0";
4348 info
->shift1
= "shlr\t%x0\n\trotxr\t%w0";
4352 info
->special
= "mov.w\t%e0,%f0\n\textu.l\t%S0";
4353 info
->cc_special
= CC_SET_ZNV
;
4356 case SHIFT_ASHIFTRT
:
4359 info
->special
= "mov.w\t%e0,%f0\n\tshll\t%z0\n\tsubx\t%z0,%z0\n\tmov.b\t%z0,%y0";
4360 info
->shift1
= "shar\t%x0\n\trotxr\t%w0";
4364 info
->special
= "mov.w\t%e0,%f0\n\texts.l\t%S0";
4365 info
->cc_special
= CC_SET_ZNV
;
4370 else if (TARGET_H8300
&& 24 <= count
&& count
<= 28)
4372 info
->remainder
= count
- 24;
4377 info
->special
= "mov.b\t%w0,%z0\n\tsub.b\t%y0,%y0\n\tsub.w\t%f0,%f0";
4378 info
->shift1
= "shll.b\t%z0";
4379 info
->cc_inline
= CC_SET_ZNV
;
4381 case SHIFT_LSHIFTRT
:
4382 info
->special
= "mov.b\t%z0,%w0\n\tsub.b\t%x0,%x0\n\tsub.w\t%e0,%e0";
4383 info
->shift1
= "shlr.b\t%w0";
4384 info
->cc_inline
= CC_SET_ZNV
;
4386 case SHIFT_ASHIFTRT
:
4387 info
->special
= "mov.b\t%z0,%w0\n\tbld\t#7,%w0\n\tsubx\t%x0,%x0\n\tsubx\t%x0,%x0\n\tsubx\t%x0,%x0";
4388 info
->shift1
= "shar.b\t%w0";
4389 info
->cc_inline
= CC_SET_ZNV
;
4393 else if ((TARGET_H8300H
&& count
== 24)
4394 || (TARGET_H8300S
&& 24 <= count
&& count
<= 25))
4396 info
->remainder
= count
- 24;
4401 info
->special
= "mov.b\t%s0,%t0\n\tsub.b\t%s0,%s0\n\tmov.w\t%f0,%e0\n\tsub.w\t%f0,%f0";
4403 case SHIFT_LSHIFTRT
:
4404 info
->special
= "mov.w\t%e0,%f0\n\tmov.b\t%t0,%s0\n\textu.w\t%f0\n\textu.l\t%S0";
4405 info
->cc_special
= CC_SET_ZNV
;
4407 case SHIFT_ASHIFTRT
:
4408 info
->special
= "mov.w\t%e0,%f0\n\tmov.b\t%t0,%s0\n\texts.w\t%f0\n\texts.l\t%S0";
4409 info
->cc_special
= CC_SET_ZNV
;
4413 else if (!TARGET_H8300
&& count
== 28)
4419 info
->special
= "sub.w\t%e0,%e0\n\trotr.l\t%S0\n\trotr.l\t%S0\n\trotr.l\t%S0\n\trotr.l\t%S0\n\tsub.w\t%f0,%f0";
4421 info
->special
= "sub.w\t%e0,%e0\n\trotr.l\t#2,%S0\n\trotr.l\t#2,%S0\n\tsub.w\t%f0,%f0";
4423 case SHIFT_LSHIFTRT
:
4426 info
->special
= "sub.w\t%f0,%f0\n\trotl.l\t%S0\n\trotl.l\t%S0\n\trotl.l\t%S0\n\trotl.l\t%S0\n\textu.l\t%S0";
4427 info
->cc_special
= CC_SET_ZNV
;
4430 info
->special
= "sub.w\t%f0,%f0\n\trotl.l\t#2,%S0\n\trotl.l\t#2,%S0\n\textu.l\t%S0";
4432 case SHIFT_ASHIFTRT
:
4436 else if (!TARGET_H8300
&& count
== 29)
4442 info
->special
= "sub.w\t%e0,%e0\n\trotr.l\t%S0\n\trotr.l\t%S0\n\trotr.l\t%S0\n\tsub.w\t%f0,%f0";
4444 info
->special
= "sub.w\t%e0,%e0\n\trotr.l\t#2,%S0\n\trotr.l\t%S0\n\tsub.w\t%f0,%f0";
4446 case SHIFT_LSHIFTRT
:
4449 info
->special
= "sub.w\t%f0,%f0\n\trotl.l\t%S0\n\trotl.l\t%S0\n\trotl.l\t%S0\n\textu.l\t%S0";
4450 info
->cc_special
= CC_SET_ZNV
;
4454 info
->special
= "sub.w\t%f0,%f0\n\trotl.l\t#2,%S0\n\trotl.l\t%S0\n\textu.l\t%S0";
4455 info
->cc_special
= CC_SET_ZNV
;
4458 case SHIFT_ASHIFTRT
:
4462 else if (!TARGET_H8300
&& count
== 30)
4468 info
->special
= "sub.w\t%e0,%e0\n\trotr.l\t%S0\n\trotr.l\t%S0\n\tsub.w\t%f0,%f0";
4470 info
->special
= "sub.w\t%e0,%e0\n\trotr.l\t#2,%S0\n\tsub.w\t%f0,%f0";
4472 case SHIFT_LSHIFTRT
:
4474 info
->special
= "sub.w\t%f0,%f0\n\trotl.l\t%S0\n\trotl.l\t%S0\n\textu.l\t%S0";
4476 info
->special
= "sub.w\t%f0,%f0\n\trotl.l\t#2,%S0\n\textu.l\t%S0";
4478 case SHIFT_ASHIFTRT
:
4482 else if (count
== 31)
4489 info
->special
= "sub.w\t%e0,%e0\n\tshlr\t%w0\n\tmov.w\t%e0,%f0\n\trotxr\t%z0";
4491 case SHIFT_LSHIFTRT
:
4492 info
->special
= "sub.w\t%f0,%f0\n\tshll\t%z0\n\tmov.w\t%f0,%e0\n\trotxl\t%w0";
4494 case SHIFT_ASHIFTRT
:
4495 info
->special
= "shll\t%z0\n\tsubx\t%w0,%w0\n\tmov.b\t%w0,%x0\n\tmov.w\t%f0,%e0";
4504 info
->special
= "shlr.l\t%S0\n\txor.l\t%S0,%S0\n\trotxr.l\t%S0";
4505 info
->cc_special
= CC_SET_ZNV
;
4507 case SHIFT_LSHIFTRT
:
4508 info
->special
= "shll.l\t%S0\n\txor.l\t%S0,%S0\n\trotxl.l\t%S0";
4509 info
->cc_special
= CC_SET_ZNV
;
4511 case SHIFT_ASHIFTRT
:
4512 info
->special
= "shll\t%e0\n\tsubx\t%w0,%w0\n\texts.w\t%T0\n\texts.l\t%S0";
4513 info
->cc_special
= CC_SET_ZNV
;
4526 info
->shift2
= NULL
;
4529 /* Given COUNT and MODE of a shift, return 1 if a scratch reg may be
4530 needed for some shift with COUNT and MODE. Return 0 otherwise. */
4533 h8300_shift_needs_scratch_p (int count
, machine_mode mode
)
4538 if (GET_MODE_BITSIZE (mode
) <= count
)
4541 /* Find out the target CPU. */
4544 else if (TARGET_H8300H
)
4549 /* Find the shift algorithm. */
4553 a
= shift_alg_qi
[cpu
][SHIFT_ASHIFT
][count
];
4554 lr
= shift_alg_qi
[cpu
][SHIFT_LSHIFTRT
][count
];
4555 ar
= shift_alg_qi
[cpu
][SHIFT_ASHIFTRT
][count
];
4559 a
= shift_alg_hi
[cpu
][SHIFT_ASHIFT
][count
];
4560 lr
= shift_alg_hi
[cpu
][SHIFT_LSHIFTRT
][count
];
4561 ar
= shift_alg_hi
[cpu
][SHIFT_ASHIFTRT
][count
];
4565 a
= shift_alg_si
[cpu
][SHIFT_ASHIFT
][count
];
4566 lr
= shift_alg_si
[cpu
][SHIFT_LSHIFTRT
][count
];
4567 ar
= shift_alg_si
[cpu
][SHIFT_ASHIFTRT
][count
];
4574 /* On H8/300H, count == 8 uses a scratch register. */
4575 return (a
== SHIFT_LOOP
|| lr
== SHIFT_LOOP
|| ar
== SHIFT_LOOP
4576 || (TARGET_H8300H
&& mode
== SImode
&& count
== 8));
4579 /* Output the assembler code for doing shifts. */
4582 output_a_shift (rtx
*operands
)
4584 static int loopend_lab
;
4585 rtx shift
= operands
[3];
4586 machine_mode mode
= GET_MODE (shift
);
4587 enum rtx_code code
= GET_CODE (shift
);
4588 enum shift_type shift_type
;
4589 enum shift_mode shift_mode
;
4590 struct shift_info info
;
4598 shift_mode
= QIshift
;
4601 shift_mode
= HIshift
;
4604 shift_mode
= SIshift
;
4613 shift_type
= SHIFT_ASHIFTRT
;
4616 shift_type
= SHIFT_LSHIFTRT
;
4619 shift_type
= SHIFT_ASHIFT
;
4625 /* This case must be taken care of by one of the two splitters
4626 that convert a variable shift into a loop. */
4627 gcc_assert (GET_CODE (operands
[2]) == CONST_INT
);
4629 n
= INTVAL (operands
[2]);
4631 /* If the count is negative, make it 0. */
4634 /* If the count is too big, truncate it.
4635 ANSI says shifts of GET_MODE_BITSIZE are undefined - we choose to
4636 do the intuitive thing. */
4637 else if ((unsigned int) n
> GET_MODE_BITSIZE (mode
))
4638 n
= GET_MODE_BITSIZE (mode
);
4640 get_shift_alg (shift_type
, shift_mode
, n
, &info
);
4645 output_asm_insn (info
.special
, operands
);
4651 /* Emit two bit shifts first. */
4652 if (info
.shift2
!= NULL
)
4654 for (; n
> 1; n
-= 2)
4655 output_asm_insn (info
.shift2
, operands
);
4658 /* Now emit one bit shifts for any residual. */
4660 output_asm_insn (info
.shift1
, operands
);
4665 int m
= GET_MODE_BITSIZE (mode
) - n
;
4666 const int mask
= (shift_type
== SHIFT_ASHIFT
4667 ? ((1 << m
) - 1) << n
4671 /* Not all possibilities of rotate are supported. They shouldn't
4672 be generated, but let's watch for 'em. */
4673 gcc_assert (info
.shift1
);
4675 /* Emit two bit rotates first. */
4676 if (info
.shift2
!= NULL
)
4678 for (; m
> 1; m
-= 2)
4679 output_asm_insn (info
.shift2
, operands
);
4682 /* Now single bit rotates for any residual. */
4684 output_asm_insn (info
.shift1
, operands
);
4686 /* Now mask off the high bits. */
4690 sprintf (insn_buf
, "and\t#%d,%%X0", mask
);
4694 gcc_assert (TARGET_H8300H
|| TARGET_H8300S
);
4695 sprintf (insn_buf
, "and.w\t#%d,%%T0", mask
);
4702 output_asm_insn (insn_buf
, operands
);
4707 /* A loop to shift by a "large" constant value.
4708 If we have shift-by-2 insns, use them. */
4709 if (info
.shift2
!= NULL
)
4711 fprintf (asm_out_file
, "\tmov.b #%d,%sl\n", n
/ 2,
4712 names_big
[REGNO (operands
[4])]);
4713 fprintf (asm_out_file
, ".Llt%d:\n", loopend_lab
);
4714 output_asm_insn (info
.shift2
, operands
);
4715 output_asm_insn ("add #0xff,%X4", operands
);
4716 fprintf (asm_out_file
, "\tbne .Llt%d\n", loopend_lab
);
4718 output_asm_insn (info
.shift1
, operands
);
4722 fprintf (asm_out_file
, "\tmov.b #%d,%sl\n", n
,
4723 names_big
[REGNO (operands
[4])]);
4724 fprintf (asm_out_file
, ".Llt%d:\n", loopend_lab
);
4725 output_asm_insn (info
.shift1
, operands
);
4726 output_asm_insn ("add #0xff,%X4", operands
);
4727 fprintf (asm_out_file
, "\tbne .Llt%d\n", loopend_lab
);
4736 /* Count the number of assembly instructions in a string TEMPL. */
4739 h8300_asm_insn_count (const char *templ
)
4741 unsigned int count
= 1;
4743 for (; *templ
; templ
++)
4750 /* Compute the length of a shift insn. */
4753 compute_a_shift_length (rtx insn ATTRIBUTE_UNUSED
, rtx
*operands
)
4755 rtx shift
= operands
[3];
4756 machine_mode mode
= GET_MODE (shift
);
4757 enum rtx_code code
= GET_CODE (shift
);
4758 enum shift_type shift_type
;
4759 enum shift_mode shift_mode
;
4760 struct shift_info info
;
4761 unsigned int wlength
= 0;
4766 shift_mode
= QIshift
;
4769 shift_mode
= HIshift
;
4772 shift_mode
= SIshift
;
4781 shift_type
= SHIFT_ASHIFTRT
;
4784 shift_type
= SHIFT_LSHIFTRT
;
4787 shift_type
= SHIFT_ASHIFT
;
4793 if (GET_CODE (operands
[2]) != CONST_INT
)
4795 /* Get the assembler code to do one shift. */
4796 get_shift_alg (shift_type
, shift_mode
, 1, &info
);
4798 return (4 + h8300_asm_insn_count (info
.shift1
)) * 2;
4802 int n
= INTVAL (operands
[2]);
4804 /* If the count is negative, make it 0. */
4807 /* If the count is too big, truncate it.
4808 ANSI says shifts of GET_MODE_BITSIZE are undefined - we choose to
4809 do the intuitive thing. */
4810 else if ((unsigned int) n
> GET_MODE_BITSIZE (mode
))
4811 n
= GET_MODE_BITSIZE (mode
);
4813 get_shift_alg (shift_type
, shift_mode
, n
, &info
);
4818 wlength
+= h8300_asm_insn_count (info
.special
);
4820 /* Every assembly instruction used in SHIFT_SPECIAL case
4821 takes 2 bytes except xor.l, which takes 4 bytes, so if we
4822 see xor.l, we just pretend that xor.l counts as two insns
4823 so that the insn length will be computed correctly. */
4824 if (strstr (info
.special
, "xor.l") != NULL
)
4832 if (info
.shift2
!= NULL
)
4834 wlength
+= h8300_asm_insn_count (info
.shift2
) * (n
/ 2);
4838 wlength
+= h8300_asm_insn_count (info
.shift1
) * n
;
4844 int m
= GET_MODE_BITSIZE (mode
) - n
;
4846 /* Not all possibilities of rotate are supported. They shouldn't
4847 be generated, but let's watch for 'em. */
4848 gcc_assert (info
.shift1
);
4850 if (info
.shift2
!= NULL
)
4852 wlength
+= h8300_asm_insn_count (info
.shift2
) * (m
/ 2);
4856 wlength
+= h8300_asm_insn_count (info
.shift1
) * m
;
4858 /* Now mask off the high bits. */
4868 gcc_assert (!TARGET_H8300
);
4878 /* A loop to shift by a "large" constant value.
4879 If we have shift-by-2 insns, use them. */
4880 if (info
.shift2
!= NULL
)
4882 wlength
+= 3 + h8300_asm_insn_count (info
.shift2
);
4884 wlength
+= h8300_asm_insn_count (info
.shift1
);
4888 wlength
+= 3 + h8300_asm_insn_count (info
.shift1
);
4898 /* Compute which flag bits are valid after a shift insn. */
4901 compute_a_shift_cc (rtx insn ATTRIBUTE_UNUSED
, rtx
*operands
)
4903 rtx shift
= operands
[3];
4904 machine_mode mode
= GET_MODE (shift
);
4905 enum rtx_code code
= GET_CODE (shift
);
4906 enum shift_type shift_type
;
4907 enum shift_mode shift_mode
;
4908 struct shift_info info
;
4914 shift_mode
= QIshift
;
4917 shift_mode
= HIshift
;
4920 shift_mode
= SIshift
;
4929 shift_type
= SHIFT_ASHIFTRT
;
4932 shift_type
= SHIFT_LSHIFTRT
;
4935 shift_type
= SHIFT_ASHIFT
;
4941 /* This case must be taken care of by one of the two splitters
4942 that convert a variable shift into a loop. */
4943 gcc_assert (GET_CODE (operands
[2]) == CONST_INT
);
4945 n
= INTVAL (operands
[2]);
4947 /* If the count is negative, make it 0. */
4950 /* If the count is too big, truncate it.
4951 ANSI says shifts of GET_MODE_BITSIZE are undefined - we choose to
4952 do the intuitive thing. */
4953 else if ((unsigned int) n
> GET_MODE_BITSIZE (mode
))
4954 n
= GET_MODE_BITSIZE (mode
);
4956 get_shift_alg (shift_type
, shift_mode
, n
, &info
);
4961 if (info
.remainder
== 0)
4962 return info
.cc_special
;
4967 return info
.cc_inline
;
4970 /* This case always ends with an and instruction. */
4974 /* A loop to shift by a "large" constant value.
4975 If we have shift-by-2 insns, use them. */
4976 if (info
.shift2
!= NULL
)
4979 return info
.cc_inline
;
4988 /* A rotation by a non-constant will cause a loop to be generated, in
4989 which a rotation by one bit is used. A rotation by a constant,
4990 including the one in the loop, will be taken care of by
4991 output_a_rotate () at the insn emit time. */
4994 expand_a_rotate (rtx operands
[])
4996 rtx dst
= operands
[0];
4997 rtx src
= operands
[1];
4998 rtx rotate_amount
= operands
[2];
4999 machine_mode mode
= GET_MODE (dst
);
5001 if (h8sx_classify_shift (mode
, ROTATE
, rotate_amount
) == H8SX_SHIFT_UNARY
)
5004 /* We rotate in place. */
5005 emit_move_insn (dst
, src
);
5007 if (GET_CODE (rotate_amount
) != CONST_INT
)
5009 rtx counter
= gen_reg_rtx (QImode
);
5010 rtx_code_label
*start_label
= gen_label_rtx ();
5011 rtx_code_label
*end_label
= gen_label_rtx ();
5013 /* If the rotate amount is less than or equal to 0,
5014 we go out of the loop. */
5015 emit_cmp_and_jump_insns (rotate_amount
, const0_rtx
, LE
, NULL_RTX
,
5016 QImode
, 0, end_label
);
5018 /* Initialize the loop counter. */
5019 emit_move_insn (counter
, rotate_amount
);
5021 emit_label (start_label
);
5023 /* Rotate by one bit. */
5027 emit_insn (gen_rotlqi3_1 (dst
, dst
, const1_rtx
));
5030 emit_insn (gen_rotlhi3_1 (dst
, dst
, const1_rtx
));
5033 emit_insn (gen_rotlsi3_1 (dst
, dst
, const1_rtx
));
5039 /* Decrement the counter by 1. */
5040 emit_insn (gen_addqi3 (counter
, counter
, constm1_rtx
));
5042 /* If the loop counter is nonzero, we go back to the beginning
5044 emit_cmp_and_jump_insns (counter
, const0_rtx
, NE
, NULL_RTX
, QImode
, 1,
5047 emit_label (end_label
);
5051 /* Rotate by AMOUNT bits. */
5055 emit_insn (gen_rotlqi3_1 (dst
, dst
, rotate_amount
));
5058 emit_insn (gen_rotlhi3_1 (dst
, dst
, rotate_amount
));
5061 emit_insn (gen_rotlsi3_1 (dst
, dst
, rotate_amount
));
5071 /* Output a rotate insn. */
5074 output_a_rotate (enum rtx_code code
, rtx
*operands
)
5076 rtx dst
= operands
[0];
5077 rtx rotate_amount
= operands
[2];
5078 enum shift_mode rotate_mode
;
5079 enum shift_type rotate_type
;
5080 const char *insn_buf
;
5083 machine_mode mode
= GET_MODE (dst
);
5085 gcc_assert (GET_CODE (rotate_amount
) == CONST_INT
);
5090 rotate_mode
= QIshift
;
5093 rotate_mode
= HIshift
;
5096 rotate_mode
= SIshift
;
5105 rotate_type
= SHIFT_ASHIFT
;
5108 rotate_type
= SHIFT_LSHIFTRT
;
5114 amount
= INTVAL (rotate_amount
);
5116 /* Clean up AMOUNT. */
5119 if ((unsigned int) amount
> GET_MODE_BITSIZE (mode
))
5120 amount
= GET_MODE_BITSIZE (mode
);
5122 /* Determine the faster direction. After this phase, amount will be
5123 at most a half of GET_MODE_BITSIZE (mode). */
5124 if ((unsigned int) amount
> GET_MODE_BITSIZE (mode
) / (unsigned) 2)
5126 /* Flip the direction. */
5127 amount
= GET_MODE_BITSIZE (mode
) - amount
;
5129 (rotate_type
== SHIFT_ASHIFT
) ? SHIFT_LSHIFTRT
: SHIFT_ASHIFT
;
5132 /* See if a byte swap (in HImode) or a word swap (in SImode) can
5133 boost up the rotation. */
5134 if ((mode
== HImode
&& TARGET_H8300
&& amount
>= 5)
5135 || (mode
== HImode
&& TARGET_H8300H
&& amount
>= 6)
5136 || (mode
== HImode
&& TARGET_H8300S
&& amount
== 8)
5137 || (mode
== SImode
&& TARGET_H8300H
&& amount
>= 10)
5138 || (mode
== SImode
&& TARGET_H8300S
&& amount
>= 13))
5143 /* This code works on any family. */
5144 insn_buf
= "xor.b\t%s0,%t0\n\txor.b\t%t0,%s0\n\txor.b\t%s0,%t0";
5145 output_asm_insn (insn_buf
, operands
);
5149 /* This code works on the H8/300H and H8S. */
5150 insn_buf
= "xor.w\t%e0,%f0\n\txor.w\t%f0,%e0\n\txor.w\t%e0,%f0";
5151 output_asm_insn (insn_buf
, operands
);
5158 /* Adjust AMOUNT and flip the direction. */
5159 amount
= GET_MODE_BITSIZE (mode
) / 2 - amount
;
5161 (rotate_type
== SHIFT_ASHIFT
) ? SHIFT_LSHIFTRT
: SHIFT_ASHIFT
;
5164 /* Output rotate insns. */
5165 for (bits
= TARGET_H8300S
? 2 : 1; bits
> 0; bits
/= 2)
5168 insn_buf
= rotate_two
[rotate_type
][rotate_mode
];
5170 insn_buf
= rotate_one
[cpu_type
][rotate_type
][rotate_mode
];
5172 for (; amount
>= bits
; amount
-= bits
)
5173 output_asm_insn (insn_buf
, operands
);
5179 /* Compute the length of a rotate insn. */
5182 compute_a_rotate_length (rtx
*operands
)
5184 rtx src
= operands
[1];
5185 rtx amount_rtx
= operands
[2];
5186 machine_mode mode
= GET_MODE (src
);
5188 unsigned int length
= 0;
5190 gcc_assert (GET_CODE (amount_rtx
) == CONST_INT
);
5192 amount
= INTVAL (amount_rtx
);
5194 /* Clean up AMOUNT. */
5197 if ((unsigned int) amount
> GET_MODE_BITSIZE (mode
))
5198 amount
= GET_MODE_BITSIZE (mode
);
5200 /* Determine the faster direction. After this phase, amount
5201 will be at most a half of GET_MODE_BITSIZE (mode). */
5202 if ((unsigned int) amount
> GET_MODE_BITSIZE (mode
) / (unsigned) 2)
5203 /* Flip the direction. */
5204 amount
= GET_MODE_BITSIZE (mode
) - amount
;
5206 /* See if a byte swap (in HImode) or a word swap (in SImode) can
5207 boost up the rotation. */
5208 if ((mode
== HImode
&& TARGET_H8300
&& amount
>= 5)
5209 || (mode
== HImode
&& TARGET_H8300H
&& amount
>= 6)
5210 || (mode
== HImode
&& TARGET_H8300S
&& amount
== 8)
5211 || (mode
== SImode
&& TARGET_H8300H
&& amount
>= 10)
5212 || (mode
== SImode
&& TARGET_H8300S
&& amount
>= 13))
5214 /* Adjust AMOUNT and flip the direction. */
5215 amount
= GET_MODE_BITSIZE (mode
) / 2 - amount
;
5219 /* We use 2-bit rotations on the H8S. */
5221 amount
= amount
/ 2 + amount
% 2;
5223 /* The H8/300 uses three insns to rotate one bit, taking 6
5225 length
+= amount
* ((TARGET_H8300
&& mode
== HImode
) ? 6 : 2);
5230 /* Fix the operands of a gen_xxx so that it could become a bit
5234 fix_bit_operand (rtx
*operands
, enum rtx_code code
)
5236 /* The bit_operand predicate accepts any memory during RTL generation, but
5237 only 'U' memory afterwards, so if this is a MEM operand, we must force
5238 it to be valid for 'U' by reloading the address. */
5241 ? single_zero_operand (operands
[2], QImode
)
5242 : single_one_operand (operands
[2], QImode
))
5244 /* OK to have a memory dest. */
5245 if (GET_CODE (operands
[0]) == MEM
5246 && !satisfies_constraint_U (operands
[0]))
5248 rtx mem
= gen_rtx_MEM (GET_MODE (operands
[0]),
5249 copy_to_mode_reg (Pmode
,
5250 XEXP (operands
[0], 0)));
5251 MEM_COPY_ATTRIBUTES (mem
, operands
[0]);
5255 if (GET_CODE (operands
[1]) == MEM
5256 && !satisfies_constraint_U (operands
[1]))
5258 rtx mem
= gen_rtx_MEM (GET_MODE (operands
[1]),
5259 copy_to_mode_reg (Pmode
,
5260 XEXP (operands
[1], 0)));
5261 MEM_COPY_ATTRIBUTES (mem
, operands
[0]);
5267 /* Dest and src op must be register. */
5269 operands
[1] = force_reg (QImode
, operands
[1]);
5271 rtx res
= gen_reg_rtx (QImode
);
5275 emit_insn (gen_andqi3_1 (res
, operands
[1], operands
[2]));
5278 emit_insn (gen_iorqi3_1 (res
, operands
[1], operands
[2]));
5281 emit_insn (gen_xorqi3_1 (res
, operands
[1], operands
[2]));
5286 emit_insn (gen_movqi (operands
[0], res
));
5291 /* Return nonzero if FUNC is an interrupt function as specified
5292 by the "interrupt" attribute. */
5295 h8300_interrupt_function_p (tree func
)
5299 if (TREE_CODE (func
) != FUNCTION_DECL
)
5302 a
= lookup_attribute ("interrupt_handler", DECL_ATTRIBUTES (func
));
5303 return a
!= NULL_TREE
;
5306 /* Return nonzero if FUNC is a saveall function as specified by the
5307 "saveall" attribute. */
5310 h8300_saveall_function_p (tree func
)
5314 if (TREE_CODE (func
) != FUNCTION_DECL
)
5317 a
= lookup_attribute ("saveall", DECL_ATTRIBUTES (func
));
5318 return a
!= NULL_TREE
;
5321 /* Return nonzero if FUNC is an OS_Task function as specified
5322 by the "OS_Task" attribute. */
5325 h8300_os_task_function_p (tree func
)
5329 if (TREE_CODE (func
) != FUNCTION_DECL
)
5332 a
= lookup_attribute ("OS_Task", DECL_ATTRIBUTES (func
));
5333 return a
!= NULL_TREE
;
5336 /* Return nonzero if FUNC is a monitor function as specified
5337 by the "monitor" attribute. */
5340 h8300_monitor_function_p (tree func
)
5344 if (TREE_CODE (func
) != FUNCTION_DECL
)
5347 a
= lookup_attribute ("monitor", DECL_ATTRIBUTES (func
));
5348 return a
!= NULL_TREE
;
5351 /* Return nonzero if FUNC is a function that should be called
5352 through the function vector. */
5355 h8300_funcvec_function_p (tree func
)
5359 if (TREE_CODE (func
) != FUNCTION_DECL
)
5362 a
= lookup_attribute ("function_vector", DECL_ATTRIBUTES (func
));
5363 return a
!= NULL_TREE
;
5366 /* Return nonzero if DECL is a variable that's in the eight bit
5370 h8300_eightbit_data_p (tree decl
)
5374 if (TREE_CODE (decl
) != VAR_DECL
)
5377 a
= lookup_attribute ("eightbit_data", DECL_ATTRIBUTES (decl
));
5378 return a
!= NULL_TREE
;
5381 /* Return nonzero if DECL is a variable that's in the tiny
5385 h8300_tiny_data_p (tree decl
)
5389 if (TREE_CODE (decl
) != VAR_DECL
)
5392 a
= lookup_attribute ("tiny_data", DECL_ATTRIBUTES (decl
));
5393 return a
!= NULL_TREE
;
5396 /* Generate an 'interrupt_handler' attribute for decls. We convert
5397 all the pragmas to corresponding attributes. */
5400 h8300_insert_attributes (tree node
, tree
*attributes
)
5402 if (TREE_CODE (node
) == FUNCTION_DECL
)
5404 if (pragma_interrupt
)
5406 pragma_interrupt
= 0;
5408 /* Add an 'interrupt_handler' attribute. */
5409 *attributes
= tree_cons (get_identifier ("interrupt_handler"),
5417 /* Add an 'saveall' attribute. */
5418 *attributes
= tree_cons (get_identifier ("saveall"),
5424 /* Supported attributes:
5426 interrupt_handler: output a prologue and epilogue suitable for an
5429 saveall: output a prologue and epilogue that saves and restores
5430 all registers except the stack pointer.
5432 function_vector: This function should be called through the
5435 eightbit_data: This variable lives in the 8-bit data area and can
5436 be referenced with 8-bit absolute memory addresses.
5438 tiny_data: This variable lives in the tiny data area and can be
5439 referenced with 16-bit absolute memory references. */
5441 static const struct attribute_spec h8300_attribute_table
[] =
5443 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
5444 affects_type_identity } */
5445 { "interrupt_handler", 0, 0, true, false, false,
5446 h8300_handle_fndecl_attribute
, false },
5447 { "saveall", 0, 0, true, false, false,
5448 h8300_handle_fndecl_attribute
, false },
5449 { "OS_Task", 0, 0, true, false, false,
5450 h8300_handle_fndecl_attribute
, false },
5451 { "monitor", 0, 0, true, false, false,
5452 h8300_handle_fndecl_attribute
, false },
5453 { "function_vector", 0, 0, true, false, false,
5454 h8300_handle_fndecl_attribute
, false },
5455 { "eightbit_data", 0, 0, true, false, false,
5456 h8300_handle_eightbit_data_attribute
, false },
5457 { "tiny_data", 0, 0, true, false, false,
5458 h8300_handle_tiny_data_attribute
, false },
5459 { NULL
, 0, 0, false, false, false, NULL
, false }
5463 /* Handle an attribute requiring a FUNCTION_DECL; arguments as in
5464 struct attribute_spec.handler. */
5466 h8300_handle_fndecl_attribute (tree
*node
, tree name
,
5467 tree args ATTRIBUTE_UNUSED
,
5468 int flags ATTRIBUTE_UNUSED
,
5471 if (TREE_CODE (*node
) != FUNCTION_DECL
)
5473 warning (OPT_Wattributes
, "%qE attribute only applies to functions",
5475 *no_add_attrs
= true;
5481 /* Handle an "eightbit_data" attribute; arguments as in
5482 struct attribute_spec.handler. */
5484 h8300_handle_eightbit_data_attribute (tree
*node
, tree name
,
5485 tree args ATTRIBUTE_UNUSED
,
5486 int flags ATTRIBUTE_UNUSED
,
5491 if (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
))
5493 set_decl_section_name (decl
, ".eight");
5497 warning (OPT_Wattributes
, "%qE attribute ignored",
5499 *no_add_attrs
= true;
5505 /* Handle an "tiny_data" attribute; arguments as in
5506 struct attribute_spec.handler. */
5508 h8300_handle_tiny_data_attribute (tree
*node
, tree name
,
5509 tree args ATTRIBUTE_UNUSED
,
5510 int flags ATTRIBUTE_UNUSED
,
5515 if (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
))
5517 set_decl_section_name (decl
, ".tiny");
5521 warning (OPT_Wattributes
, "%qE attribute ignored",
5523 *no_add_attrs
= true;
5529 /* Mark function vectors, and various small data objects. */
5532 h8300_encode_section_info (tree decl
, rtx rtl
, int first
)
5534 int extra_flags
= 0;
5536 default_encode_section_info (decl
, rtl
, first
);
5538 if (TREE_CODE (decl
) == FUNCTION_DECL
5539 && h8300_funcvec_function_p (decl
))
5540 extra_flags
= SYMBOL_FLAG_FUNCVEC_FUNCTION
;
5541 else if (TREE_CODE (decl
) == VAR_DECL
5542 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
5544 if (h8300_eightbit_data_p (decl
))
5545 extra_flags
= SYMBOL_FLAG_EIGHTBIT_DATA
;
5546 else if (first
&& h8300_tiny_data_p (decl
))
5547 extra_flags
= SYMBOL_FLAG_TINY_DATA
;
5551 SYMBOL_REF_FLAGS (XEXP (rtl
, 0)) |= extra_flags
;
5554 /* Output a single-bit extraction. */
5557 output_simode_bld (int bild
, rtx operands
[])
5561 /* Clear the destination register. */
5562 output_asm_insn ("sub.w\t%e0,%e0\n\tsub.w\t%f0,%f0", operands
);
5564 /* Now output the bit load or bit inverse load, and store it in
5567 output_asm_insn ("bild\t%Z2,%Y1", operands
);
5569 output_asm_insn ("bld\t%Z2,%Y1", operands
);
5571 output_asm_insn ("bst\t#0,%w0", operands
);
5575 /* Determine if we can clear the destination first. */
5576 int clear_first
= (REG_P (operands
[0]) && REG_P (operands
[1])
5577 && REGNO (operands
[0]) != REGNO (operands
[1]));
5580 output_asm_insn ("sub.l\t%S0,%S0", operands
);
5582 /* Output the bit load or bit inverse load. */
5584 output_asm_insn ("bild\t%Z2,%Y1", operands
);
5586 output_asm_insn ("bld\t%Z2,%Y1", operands
);
5589 output_asm_insn ("xor.l\t%S0,%S0", operands
);
5591 /* Perform the bit store. */
5592 output_asm_insn ("rotxl.l\t%S0", operands
);
5599 /* Delayed-branch scheduling is more effective if we have some idea
5600 how long each instruction will be. Use a shorten_branches pass
5601 to get an initial estimate. */
5606 if (flag_delayed_branch
)
5607 shorten_branches (get_insns ());
5610 #ifndef OBJECT_FORMAT_ELF
5612 h8300_asm_named_section (const char *name
, unsigned int flags ATTRIBUTE_UNUSED
,
5615 /* ??? Perhaps we should be using default_coff_asm_named_section. */
5616 fprintf (asm_out_file
, "\t.section %s\n", name
);
5618 #endif /* ! OBJECT_FORMAT_ELF */
5620 /* Nonzero if X is a constant address suitable as an 8-bit absolute,
5621 which is a special case of the 'R' operand. */
5624 h8300_eightbit_constant_address_p (rtx x
)
5626 /* The ranges of the 8-bit area. */
5627 const unsigned HOST_WIDE_INT n1
= trunc_int_for_mode (0xff00, HImode
);
5628 const unsigned HOST_WIDE_INT n2
= trunc_int_for_mode (0xffff, HImode
);
5629 const unsigned HOST_WIDE_INT h1
= trunc_int_for_mode (0x00ffff00, SImode
);
5630 const unsigned HOST_WIDE_INT h2
= trunc_int_for_mode (0x00ffffff, SImode
);
5631 const unsigned HOST_WIDE_INT s1
= trunc_int_for_mode (0xffffff00, SImode
);
5632 const unsigned HOST_WIDE_INT s2
= trunc_int_for_mode (0xffffffff, SImode
);
5634 unsigned HOST_WIDE_INT addr
;
5636 /* We accept symbols declared with eightbit_data. */
5637 if (GET_CODE (x
) == SYMBOL_REF
)
5638 return (SYMBOL_REF_FLAGS (x
) & SYMBOL_FLAG_EIGHTBIT_DATA
) != 0;
5640 if (GET_CODE (x
) != CONST_INT
)
5646 || ((TARGET_H8300
|| TARGET_NORMAL_MODE
) && IN_RANGE (addr
, n1
, n2
))
5647 || (TARGET_H8300H
&& IN_RANGE (addr
, h1
, h2
))
5648 || (TARGET_H8300S
&& IN_RANGE (addr
, s1
, s2
)));
5651 /* Nonzero if X is a constant address suitable as an 16-bit absolute
5652 on H8/300H and H8S. */
5655 h8300_tiny_constant_address_p (rtx x
)
5657 /* The ranges of the 16-bit area. */
5658 const unsigned HOST_WIDE_INT h1
= trunc_int_for_mode (0x00000000, SImode
);
5659 const unsigned HOST_WIDE_INT h2
= trunc_int_for_mode (0x00007fff, SImode
);
5660 const unsigned HOST_WIDE_INT h3
= trunc_int_for_mode (0x00ff8000, SImode
);
5661 const unsigned HOST_WIDE_INT h4
= trunc_int_for_mode (0x00ffffff, SImode
);
5662 const unsigned HOST_WIDE_INT s1
= trunc_int_for_mode (0x00000000, SImode
);
5663 const unsigned HOST_WIDE_INT s2
= trunc_int_for_mode (0x00007fff, SImode
);
5664 const unsigned HOST_WIDE_INT s3
= trunc_int_for_mode (0xffff8000, SImode
);
5665 const unsigned HOST_WIDE_INT s4
= trunc_int_for_mode (0xffffffff, SImode
);
5667 unsigned HOST_WIDE_INT addr
;
5669 switch (GET_CODE (x
))
5672 /* In the normal mode, any symbol fits in the 16-bit absolute
5673 address range. We also accept symbols declared with
5675 return (TARGET_NORMAL_MODE
5676 || (SYMBOL_REF_FLAGS (x
) & SYMBOL_FLAG_TINY_DATA
) != 0);
5680 return (TARGET_NORMAL_MODE
5682 && (IN_RANGE (addr
, h1
, h2
) || IN_RANGE (addr
, h3
, h4
)))
5684 && (IN_RANGE (addr
, s1
, s2
) || IN_RANGE (addr
, s3
, s4
))));
5687 return TARGET_NORMAL_MODE
;
5695 /* Return nonzero if ADDR1 and ADDR2 point to consecutive memory
5696 locations that can be accessed as a 16-bit word. */
5699 byte_accesses_mergeable_p (rtx addr1
, rtx addr2
)
5701 HOST_WIDE_INT offset1
, offset2
;
5709 else if (GET_CODE (addr1
) == PLUS
5710 && REG_P (XEXP (addr1
, 0))
5711 && GET_CODE (XEXP (addr1
, 1)) == CONST_INT
)
5713 reg1
= XEXP (addr1
, 0);
5714 offset1
= INTVAL (XEXP (addr1
, 1));
5724 else if (GET_CODE (addr2
) == PLUS
5725 && REG_P (XEXP (addr2
, 0))
5726 && GET_CODE (XEXP (addr2
, 1)) == CONST_INT
)
5728 reg2
= XEXP (addr2
, 0);
5729 offset2
= INTVAL (XEXP (addr2
, 1));
5734 if (((reg1
== stack_pointer_rtx
&& reg2
== stack_pointer_rtx
)
5735 || (reg1
== frame_pointer_rtx
&& reg2
== frame_pointer_rtx
))
5737 && offset1
+ 1 == offset2
)
5743 /* Return nonzero if we have the same comparison insn as I3 two insns
5744 before I3. I3 is assumed to be a comparison insn. */
5747 same_cmp_preceding_p (rtx i3
)
5751 /* Make sure we have a sequence of three insns. */
5752 i2
= prev_nonnote_insn (i3
);
5755 i1
= prev_nonnote_insn (i2
);
5759 return (INSN_P (i1
) && rtx_equal_p (PATTERN (i1
), PATTERN (i3
))
5760 && any_condjump_p (i2
) && onlyjump_p (i2
));
5763 /* Return nonzero if we have the same comparison insn as I1 two insns
5764 after I1. I1 is assumed to be a comparison insn. */
5767 same_cmp_following_p (rtx i1
)
5771 /* Make sure we have a sequence of three insns. */
5772 i2
= next_nonnote_insn (i1
);
5775 i3
= next_nonnote_insn (i2
);
5779 return (INSN_P (i3
) && rtx_equal_p (PATTERN (i1
), PATTERN (i3
))
5780 && any_condjump_p (i2
) && onlyjump_p (i2
));
5783 /* Return nonzero if OPERANDS are valid for stm (or ldm) that pushes
5784 (or pops) N registers. OPERANDS are assumed to be an array of
5788 h8300_regs_ok_for_stm (int n
, rtx operands
[])
5793 return ((REGNO (operands
[0]) == 0 && REGNO (operands
[1]) == 1)
5794 || (REGNO (operands
[0]) == 2 && REGNO (operands
[1]) == 3)
5795 || (REGNO (operands
[0]) == 4 && REGNO (operands
[1]) == 5));
5797 return ((REGNO (operands
[0]) == 0
5798 && REGNO (operands
[1]) == 1
5799 && REGNO (operands
[2]) == 2)
5800 || (REGNO (operands
[0]) == 4
5801 && REGNO (operands
[1]) == 5
5802 && REGNO (operands
[2]) == 6));
5805 return (REGNO (operands
[0]) == 0
5806 && REGNO (operands
[1]) == 1
5807 && REGNO (operands
[2]) == 2
5808 && REGNO (operands
[3]) == 3);
5814 /* Return nonzero if register OLD_REG can be renamed to register NEW_REG. */
5817 h8300_hard_regno_rename_ok (unsigned int old_reg ATTRIBUTE_UNUSED
,
5818 unsigned int new_reg
)
5820 /* Interrupt functions can only use registers that have already been
5821 saved by the prologue, even if they would normally be
5824 if (h8300_current_function_interrupt_function_p ()
5825 && !df_regs_ever_live_p (new_reg
))
5831 /* Returns true if register REGNO is safe to be allocated as a scratch
5832 register in the current function. */
5835 h8300_hard_regno_scratch_ok (unsigned int regno
)
5837 if (h8300_current_function_interrupt_function_p ()
5838 && ! WORD_REG_USED (regno
))
5845 /* Return nonzero if X is a REG or SUBREG suitable as a base register. */
5848 h8300_rtx_ok_for_base_p (rtx x
, int strict
)
5850 /* Strip off SUBREG if any. */
5851 if (GET_CODE (x
) == SUBREG
)
5856 ? REG_OK_FOR_BASE_STRICT_P (x
)
5857 : REG_OK_FOR_BASE_NONSTRICT_P (x
)));
5860 /* Return nozero if X is a legitimate address. On the H8/300, a
5861 legitimate address has the form REG, REG+CONSTANT_ADDRESS or
5862 CONSTANT_ADDRESS. */
5865 h8300_legitimate_address_p (machine_mode mode
, rtx x
, bool strict
)
5867 /* The register indirect addresses like @er0 is always valid. */
5868 if (h8300_rtx_ok_for_base_p (x
, strict
))
5871 if (CONSTANT_ADDRESS_P (x
))
5875 && ( GET_CODE (x
) == PRE_INC
5876 || GET_CODE (x
) == PRE_DEC
5877 || GET_CODE (x
) == POST_INC
5878 || GET_CODE (x
) == POST_DEC
)
5879 && h8300_rtx_ok_for_base_p (XEXP (x
, 0), strict
))
5882 if (GET_CODE (x
) == PLUS
5883 && CONSTANT_ADDRESS_P (XEXP (x
, 1))
5884 && h8300_rtx_ok_for_base_p (h8300_get_index (XEXP (x
, 0),
5891 /* Worker function for HARD_REGNO_NREGS.
5893 We pretend the MAC register is 32bits -- we don't have any data
5894 types on the H8 series to handle more than 32bits. */
5897 h8300_hard_regno_nregs (int regno ATTRIBUTE_UNUSED
, machine_mode mode
)
5899 return (GET_MODE_SIZE (mode
) + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
5902 /* Worker function for HARD_REGNO_MODE_OK. */
5905 h8300_hard_regno_mode_ok (int regno
, machine_mode mode
)
5908 /* If an even reg, then anything goes. Otherwise the mode must be
5910 return ((regno
& 1) == 0) || (mode
== HImode
) || (mode
== QImode
);
5912 /* MAC register can only be of SImode. Otherwise, anything
5914 return regno
== MAC_REG
? mode
== SImode
: 1;
5917 /* Helper function for the move patterns. Make sure a move is legitimate. */
5920 h8300_move_ok (rtx dest
, rtx src
)
5924 /* Validate that at least one operand is a register. */
5927 if (MEM_P (src
) || CONSTANT_P (src
))
5929 addr
= XEXP (dest
, 0);
5932 else if (MEM_P (src
))
5934 addr
= XEXP (src
, 0);
5940 /* Validate that auto-inc doesn't affect OTHER. */
5941 if (GET_RTX_CLASS (GET_CODE (addr
)) != RTX_AUTOINC
)
5943 addr
= XEXP (addr
, 0);
5945 if (addr
== stack_pointer_rtx
)
5946 return register_no_sp_elim_operand (other
, VOIDmode
);
5948 return !reg_overlap_mentioned_p(other
, addr
);
5951 /* Perform target dependent optabs initialization. */
5953 h8300_init_libfuncs (void)
5955 set_optab_libfunc (smul_optab
, HImode
, "__mulhi3");
5956 set_optab_libfunc (sdiv_optab
, HImode
, "__divhi3");
5957 set_optab_libfunc (udiv_optab
, HImode
, "__udivhi3");
5958 set_optab_libfunc (smod_optab
, HImode
, "__modhi3");
5959 set_optab_libfunc (umod_optab
, HImode
, "__umodhi3");
5962 /* Worker function for TARGET_FUNCTION_VALUE.
5964 On the H8 the return value is in R0/R1. */
5967 h8300_function_value (const_tree ret_type
,
5968 const_tree fn_decl_or_type ATTRIBUTE_UNUSED
,
5969 bool outgoing ATTRIBUTE_UNUSED
)
5971 return gen_rtx_REG (TYPE_MODE (ret_type
), R0_REG
);
5974 /* Worker function for TARGET_LIBCALL_VALUE.
5976 On the H8 the return value is in R0/R1. */
5979 h8300_libcall_value (machine_mode mode
, const_rtx fun ATTRIBUTE_UNUSED
)
5981 return gen_rtx_REG (mode
, R0_REG
);
5984 /* Worker function for TARGET_FUNCTION_VALUE_REGNO_P.
5986 On the H8, R0 is the only register thus used. */
5989 h8300_function_value_regno_p (const unsigned int regno
)
5991 return (regno
== R0_REG
);
5994 /* Worker function for TARGET_RETURN_IN_MEMORY. */
5997 h8300_return_in_memory (const_tree type
, const_tree fntype ATTRIBUTE_UNUSED
)
5999 return (TYPE_MODE (type
) == BLKmode
6000 || GET_MODE_SIZE (TYPE_MODE (type
)) > (TARGET_H8300
? 4 : 8));
6003 /* We emit the entire trampoline here. Depending on the pointer size,
6004 we use a different trampoline.
6008 1 0000 7903xxxx mov.w #0x1234,r3
6009 2 0004 5A00xxxx jmp @0x1234
6014 2 0000 7A03xxxxxxxx mov.l #0x12345678,er3
6015 3 0006 5Axxxxxx jmp @0x123456
6020 h8300_trampoline_init (rtx m_tramp
, tree fndecl
, rtx cxt
)
6022 rtx fnaddr
= XEXP (DECL_RTL (fndecl
), 0);
6025 if (Pmode
== HImode
)
6027 mem
= adjust_address (m_tramp
, HImode
, 0);
6028 emit_move_insn (mem
, GEN_INT (0x7903));
6029 mem
= adjust_address (m_tramp
, Pmode
, 2);
6030 emit_move_insn (mem
, cxt
);
6031 mem
= adjust_address (m_tramp
, HImode
, 4);
6032 emit_move_insn (mem
, GEN_INT (0x5a00));
6033 mem
= adjust_address (m_tramp
, Pmode
, 6);
6034 emit_move_insn (mem
, fnaddr
);
6040 mem
= adjust_address (m_tramp
, HImode
, 0);
6041 emit_move_insn (mem
, GEN_INT (0x7a03));
6042 mem
= adjust_address (m_tramp
, Pmode
, 2);
6043 emit_move_insn (mem
, cxt
);
6045 tem
= copy_to_reg (fnaddr
);
6046 emit_insn (gen_andsi3 (tem
, tem
, GEN_INT (0x00ffffff)));
6047 emit_insn (gen_iorsi3 (tem
, tem
, GEN_INT (0x5a000000)));
6048 mem
= adjust_address (m_tramp
, SImode
, 6);
6049 emit_move_insn (mem
, tem
);
6053 /* Initialize the GCC target structure. */
6054 #undef TARGET_ATTRIBUTE_TABLE
6055 #define TARGET_ATTRIBUTE_TABLE h8300_attribute_table
6057 #undef TARGET_ASM_ALIGNED_HI_OP
6058 #define TARGET_ASM_ALIGNED_HI_OP "\t.word\t"
6060 #undef TARGET_ASM_FILE_START
6061 #define TARGET_ASM_FILE_START h8300_file_start
6062 #undef TARGET_ASM_FILE_START_FILE_DIRECTIVE
6063 #define TARGET_ASM_FILE_START_FILE_DIRECTIVE true
6065 #undef TARGET_ASM_FILE_END
6066 #define TARGET_ASM_FILE_END h8300_file_end
6068 #undef TARGET_PRINT_OPERAND
6069 #define TARGET_PRINT_OPERAND h8300_print_operand
6070 #undef TARGET_PRINT_OPERAND_ADDRESS
6071 #define TARGET_PRINT_OPERAND_ADDRESS h8300_print_operand_address
6072 #undef TARGET_PRINT_OPERAND_PUNCT_VALID_P
6073 #define TARGET_PRINT_OPERAND_PUNCT_VALID_P h8300_print_operand_punct_valid_p
6075 #undef TARGET_ENCODE_SECTION_INFO
6076 #define TARGET_ENCODE_SECTION_INFO h8300_encode_section_info
6078 #undef TARGET_INSERT_ATTRIBUTES
6079 #define TARGET_INSERT_ATTRIBUTES h8300_insert_attributes
6081 #undef TARGET_REGISTER_MOVE_COST
6082 #define TARGET_REGISTER_MOVE_COST h8300_register_move_cost
6084 #undef TARGET_RTX_COSTS
6085 #define TARGET_RTX_COSTS h8300_rtx_costs
6087 #undef TARGET_INIT_LIBFUNCS
6088 #define TARGET_INIT_LIBFUNCS h8300_init_libfuncs
6090 #undef TARGET_FUNCTION_VALUE
6091 #define TARGET_FUNCTION_VALUE h8300_function_value
6093 #undef TARGET_LIBCALL_VALUE
6094 #define TARGET_LIBCALL_VALUE h8300_libcall_value
6096 #undef TARGET_FUNCTION_VALUE_REGNO_P
6097 #define TARGET_FUNCTION_VALUE_REGNO_P h8300_function_value_regno_p
6099 #undef TARGET_RETURN_IN_MEMORY
6100 #define TARGET_RETURN_IN_MEMORY h8300_return_in_memory
6102 #undef TARGET_FUNCTION_ARG
6103 #define TARGET_FUNCTION_ARG h8300_function_arg
6105 #undef TARGET_FUNCTION_ARG_ADVANCE
6106 #define TARGET_FUNCTION_ARG_ADVANCE h8300_function_arg_advance
6108 #undef TARGET_MACHINE_DEPENDENT_REORG
6109 #define TARGET_MACHINE_DEPENDENT_REORG h8300_reorg
6111 #undef TARGET_HARD_REGNO_SCRATCH_OK
6112 #define TARGET_HARD_REGNO_SCRATCH_OK h8300_hard_regno_scratch_ok
6114 #undef TARGET_LEGITIMATE_ADDRESS_P
6115 #define TARGET_LEGITIMATE_ADDRESS_P h8300_legitimate_address_p
6117 #undef TARGET_CAN_ELIMINATE
6118 #define TARGET_CAN_ELIMINATE h8300_can_eliminate
6120 #undef TARGET_CONDITIONAL_REGISTER_USAGE
6121 #define TARGET_CONDITIONAL_REGISTER_USAGE h8300_conditional_register_usage
6123 #undef TARGET_TRAMPOLINE_INIT
6124 #define TARGET_TRAMPOLINE_INIT h8300_trampoline_init
6126 #undef TARGET_OPTION_OVERRIDE
6127 #define TARGET_OPTION_OVERRIDE h8300_option_override
6129 #undef TARGET_MODE_DEPENDENT_ADDRESS_P
6130 #define TARGET_MODE_DEPENDENT_ADDRESS_P h8300_mode_dependent_address_p
6132 struct gcc_target targetm
= TARGET_INITIALIZER
;