projects / gcc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
* config/h8300/h8300.h: Fix formatting.
[gcc.git] / gcc / config / h8300 / h8300.h
1 /* Definitions of target machine for GNU compiler.
2 Hitachi H8/300 version generating coff
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1996, 1997, 1998, 1999, 2000
4 Free SoftwareFoundation, Inc.
5 Contributed by Steve Chamberlain (sac@cygnus.com),
6 Jim Wilson (wilson@cygnus.com), and Doug Evans (dje@cygnus.com).
7
8 This file is part of GNU CC.
9
10 GNU CC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2, or (at your option)
13 any later version.
14
15 GNU CC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with GNU CC; see the file COPYING. If not, write to
22 the Free Software Foundation, 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
24
25 #ifndef GCC_H8300_H
26 #define GCC_H8300_H
27
28 /* Which CPU to compile for.
29 We use int for CPU_TYPE to avoid lots of casts. */
30 #if 0 /* defined in insn-attr.h, here for documentation */
31 enum attr_cpu { CPU_H8300, CPU_H8300H };
32 #endif
33 extern int cpu_type;
34
35 /* Various globals defined in h8300.c. */
36
37 extern const char *h8_push_op, *h8_pop_op, *h8_mov_op;
38 extern const char * const *h8_reg_names;
39
40 /* Names to predefine in the preprocessor for this target machine. */
41
42 #define CPP_PREDEFINES \
43 "-D__LONG_MAX__=2147483647L -D__LONG_LONG_MAX__=2147483647L"
44
45 #define CPP_SPEC \
46 "%{!mh:%{!ms:-D__H8300__}} %{mh:-D__H8300H__} %{ms:-D__H8300S__} \
47 %{!mh:%{!ms:-D__SIZE_TYPE__=unsigned\\ int -D__PTRDIFF_TYPE__=int}} \
48 %{mh:-D__SIZE_TYPE__=unsigned\\ long -D__PTRDIFF_TYPE__=long} \
49 %{ms:-D__SIZE_TYPE__=unsigned\\ long -D__PTRDIFF_TYPE__=long} \
50 %{!mh:%{!ms:-Acpu=h8300 -Amachine=h8300}} \
51 %{mh:-Acpu=h8300h -Amachine=h8300h} \
52 %{ms:-Acpu=h8300s -Amachine=h8300s} \
53 %{!mint32:-D__INT_MAX__=32767} %{mint32:-D__INT_MAX__=2147483647}"
54
55 #define LINK_SPEC "%{mh:-m h8300h} %{ms:-m h8300s}"
56
57 #define LIB_SPEC "%{mrelax:-relax} %{g:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}"
58
59 /* Print subsidiary information on the compiler version in use. */
60
61 #define TARGET_VERSION fprintf (stderr, " (Hitachi H8/300)");
62
63 /* Run-time compilation parameters selecting different hardware subsets. */
64
65 extern int target_flags;
66
67 /* Macros used in the machine description to test the flags. */
68
69 /* Make int's 32 bits. */
70 #define TARGET_INT32 (target_flags & 8)
71
72 /* Dump recorded insn lengths into the output file. This helps debug the
73 md file. */
74 #define TARGET_ADDRESSES (target_flags & 64)
75
76 /* Pass the first few arguments in registers. */
77 #define TARGET_QUICKCALL (target_flags & 128)
78
79 /* Pretend byte accesses are slow. */
80 #define TARGET_SLOWBYTE (target_flags & 256)
81
82 /* Dump each assembler insn's rtl into the output file.
83 This is for debugging the compiler only. */
84 #define TARGET_RTL_DUMP (target_flags & 2048)
85
86 /* Select between the H8/300 and H8/300H CPUs. */
87 #define TARGET_H8300 (! TARGET_H8300H && ! TARGET_H8300S)
88 #define TARGET_H8300H (target_flags & 4096)
89 #define TARGET_H8300S (target_flags & 1)
90
91 /* mac register and relevant instructions are available. */
92 #define TARGET_MAC (target_flags & 2)
93
94 /* Align all values on the H8/300H the same way as the H8/300. Specifically,
95 32 bit and larger values are aligned on 16 bit boundaries.
96 This is all the hardware requires, but the default is 32 bits for the 300H.
97 ??? Now watch someone add hardware floating point requiring 32 bit
98 alignment. */
99 #define TARGET_ALIGN_300 (target_flags & 8192)
100
101 /* Macro to define tables used to set the flags.
102 This is a list in braces of pairs in braces,
103 each pair being { "NAME", VALUE }
104 where VALUE is the bits to set or minus the bits to clear.
105 An empty string NAME is used to identify the default VALUE. */
106
107 #define TARGET_SWITCHES \
108 { {"s", 1, N_("Generate H8/S code")}, \
109 {"no-s", -1, N_("Do not generate H8/S code")}, \
110 {"s2600", 2, N_("Generate H8/S2600 code")}, \
111 {"no-s2600", -2, N_("Do not generate H8/S2600 code")}, \
112 {"int32", 8, N_("Make integers 32 bits wide")}, \
113 {"addresses", 64, NULL}, \
114 {"quickcall", 128, \
115 N_("Use registers for argument passing")}, \
116 {"no-quickcall", -128, \
117 N_("Do not use registers for argument passing")}, \
118 {"slowbyte", 256, \
119 N_("Consider access to byte sized memory slow")}, \
120 {"relax", 1024, N_("Enable linker relaxing")}, \
121 {"rtl-dump", 2048, NULL}, \
122 {"h", 4096, N_("Generate H8/300H code")}, \
123 {"no-h", -4096, N_("Do not generate H8/300H code")}, \
124 {"align-300", 8192, N_("Use H8/300 alignment rules")}, \
125 { "", TARGET_DEFAULT, NULL}}
126
127 #ifdef IN_LIBGCC2
128 #undef TARGET_H8300H
129 #undef TARGET_H8300S
130 /* If compiling libgcc2, make these compile time constants based on what
131 flags are we actually compiling with. */
132 #ifdef __H8300H__
133 #define TARGET_H8300H 1
134 #else
135 #define TARGET_H8300H 0
136 #endif
137 #ifdef __H8300S__
138 #define TARGET_H8300S 1
139 #else
140 #define TARGET_H8300S 0
141 #endif
142 #endif /* !IN_LIBGCC2 */
143
144 /* Do things that must be done once at start up. */
145
146 #define OVERRIDE_OPTIONS \
147 do \
148 { \
149 h8300_init_once (); \
150 } \
151 while (0)
152
153 /* Default target_flags if no switches specified. */
154
155 #ifndef TARGET_DEFAULT
156 #define TARGET_DEFAULT (128) /* quickcall */
157 #endif
158
159 /* Show we can debug even without a frame pointer. */
160 /* #define CAN_DEBUG_WITHOUT_FP */
161
162 /* Define this if addresses of constant functions
163 shouldn't be put through pseudo regs where they can be cse'd.
164 Desirable on machines where ordinary constants are expensive
165 but a CALL with constant address is cheap.
166
167 Calls through a register are cheaper than calls to named
168 functions; however, the register pressure this causes makes
169 CSEing of function addresses generally a lose. */
170 #define NO_FUNCTION_CSE
171 \f
172 /* Target machine storage layout */
173
174 /* Define to use software floating point emulator for REAL_ARITHMETIC and
175 decimal <-> binary conversion. */
176 #define REAL_ARITHMETIC
177
178 /* Define this if most significant bit is lowest numbered
179 in instructions that operate on numbered bit-fields.
180 This is not true on the H8/300. */
181 #define BITS_BIG_ENDIAN 0
182
183 /* Define this if most significant byte of a word is the lowest numbered. */
184 /* That is true on the H8/300. */
185 #define BYTES_BIG_ENDIAN 1
186
187 /* Define this if most significant word of a multiword number is lowest
188 numbered.
189 This is true on an H8/300 (actually we can make it up, but we choose to
190 be consistent). */
191 #define WORDS_BIG_ENDIAN 1
192
193 /* Number of bits in an addressable storage unit */
194 #define BITS_PER_UNIT 8
195
196 /* Width in bits of a "word", which is the contents of a machine register.
197 Note that this is not necessarily the width of data type `int';
198 if using 16-bit ints on a 68000, this would still be 32.
199 But on a machine with 16-bit registers, this would be 16. */
200 #define BITS_PER_WORD (TARGET_H8300H || TARGET_H8300S ? 32 : 16)
201 #define MAX_BITS_PER_WORD 32
202
203 /* Width of a word, in units (bytes). */
204 #define UNITS_PER_WORD (TARGET_H8300H || TARGET_H8300S ? 4 : 2)
205 #define MIN_UNITS_PER_WORD 2
206
207 /* Width in bits of a pointer.
208 See also the macro `Pmode' defined below. */
209 #define POINTER_SIZE (TARGET_H8300H || TARGET_H8300S ? 32 : 16)
210
211 #define SHORT_TYPE_SIZE 16
212 #define INT_TYPE_SIZE (TARGET_INT32 ? 32 : 16)
213 #define LONG_TYPE_SIZE 32
214 #define LONG_LONG_TYPE_SIZE 32
215 #define FLOAT_TYPE_SIZE 32
216 #define DOUBLE_TYPE_SIZE 32
217 #define LONG_DOUBLE_TYPE_SIZE DOUBLE_TYPE_SIZE
218
219 #define MAX_FIXED_MODE_SIZE 32
220
221 /* Allocation boundary (in *bits*) for storing arguments in argument list. */
222 #define PARM_BOUNDARY (TARGET_H8300H || TARGET_H8300S ? 32 : 16)
223
224 /* Allocation boundary (in *bits*) for the code of a function. */
225 #define FUNCTION_BOUNDARY 16
226
227 /* Alignment of field after `int : 0' in a structure. */
228 /* One can argue this should be 32 for -mint32, but since 32 bit ints only
229 need 16 bit alignment, this is left as is so that -mint32 doesn't change
230 structure layouts. */
231 #define EMPTY_FIELD_BOUNDARY 16
232
233 /* A bitfield declared as `int' forces `int' alignment for the struct. */
234 #define PCC_BITFIELD_TYPE_MATTERS 0
235
236 /* No data type wants to be aligned rounder than this.
237 32 bit values are aligned as such on the 300h for speed. */
238 #define BIGGEST_ALIGNMENT \
239 (((TARGET_H8300H || TARGET_H8300S) && ! TARGET_ALIGN_300) ? 32 : 16)
240
241 /* The stack goes in 16/32 bit lumps. */
242 #define STACK_BOUNDARY (TARGET_H8300 ? 16 : 32)
243
244 /* Define this if move instructions will actually fail to work
245 when given unaligned data. */
246 /* On the H8/300, longs can be aligned on halfword boundaries, but not
247 byte boundaries. */
248 #define STRICT_ALIGNMENT 1
249 \f
250 /* Standard register usage. */
251
252 /* Number of actual hardware registers.
253 The hardware registers are assigned numbers for the compiler
254 from 0 to just below FIRST_PSEUDO_REGISTER.
255
256 All registers that the compiler knows about must be given numbers,
257 even those that are not normally considered general registers.
258
259 Reg 9 does not correspond to any hardware register, but instead
260 appears in the RTL as an argument pointer prior to reload, and is
261 eliminated during reloading in favor of either the stack or frame
262 pointer. */
263
264 #define FIRST_PSEUDO_REGISTER 10
265
266 /* 1 for registers that have pervasive standard uses
267 and are not available for the register allocator. */
268
269 #define FIXED_REGISTERS \
270 { 0, 0, 0, 0, 0, 0, 0, 1, 0, 1}
271
272 /* 1 for registers not available across function calls.
273 These must include the FIXED_REGISTERS and also any
274 registers that can be used without being saved.
275 The latter must include the registers where values are returned
276 and the register where structure-value addresses are passed.
277 Aside from that, you can include as many other registers as you
278 like.
279
280 H8 destroys r0,r1,r2,r3. */
281
282 #define CALL_USED_REGISTERS \
283 { 1, 1, 1, 1, 0, 0, 0, 1, 1, 1 }
284
285 #define REG_ALLOC_ORDER \
286 { 2, 3, 0, 1, 4, 5, 6, 8, 7, 9}
287
288 #define CONDITIONAL_REGISTER_USAGE \
289 { \
290 if (!TARGET_MAC) \
291 fixed_regs[8] = call_used_regs[8] = 1; \
292 }
293
294 /* Return number of consecutive hard regs needed starting at reg REGNO
295 to hold something of mode MODE.
296
297 This is ordinarily the length in words of a value of mode MODE
298 but can be less for certain modes in special long registers.
299
300 We pretend the MAC register is 32bits -- we don't have any data
301 types on the H8 series to handle more than 32bits. */
302
303 #define HARD_REGNO_NREGS(REGNO, MODE) \
304 ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
305
306 /* Value is 1 if hard register REGNO can hold a value of machine-mode
307 MODE.
308
309 H8/300: If an even reg, then anything goes. Otherwise the mode must be QI
310 or HI.
311 H8/300H: Anything goes. */
312
313 #define HARD_REGNO_MODE_OK(REGNO, MODE) \
314 (TARGET_H8300 ? (((REGNO)&1)==0) || (MODE==HImode) || (MODE==QImode) \
315 : REGNO == 8 ? MODE == SImode : 1)
316
317 /* Value is 1 if it is a good idea to tie two pseudo registers
318 when one has mode MODE1 and one has mode MODE2.
319 If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2,
320 for any hard reg, then this must be 0 for correct output. */
321 #define MODES_TIEABLE_P(MODE1, MODE2) \
322 ((MODE1) == (MODE2) \
323 || ((MODE1) == HImode && (MODE2) == QImode) \
324 || ((MODE1) == QImode && (MODE2) == HImode) \
325 || ((TARGET_H8300H || TARGET_H8300S) \
326 && (((MODE1) == SImode && (MODE2) == HImode) \
327 || ((MODE1) == HImode && (MODE2) == SImode))))
328
329 /* Specify the registers used for certain standard purposes.
330 The values of these macros are register numbers. */
331
332 /* H8/300 pc is not overloaded on a register. */
333
334 /*#define PC_REGNUM 15*/
335
336 /* Register to use for pushing function arguments. */
337 #define STACK_POINTER_REGNUM 7
338
339 /* Base register for access to local variables of the function. */
340 #define FRAME_POINTER_REGNUM 6
341
342 /* Value should be nonzero if functions must have frame pointers.
343 Zero means the frame pointer need not be set up (and parms
344 may be accessed via the stack pointer) in functions that seem suitable.
345 This is computed in `reload', in reload1.c. */
346 #define FRAME_POINTER_REQUIRED 0
347
348 /* Base register for access to arguments of the function. */
349 #define ARG_POINTER_REGNUM 9
350
351 /* Register in which static-chain is passed to a function. */
352 #define STATIC_CHAIN_REGNUM 3
353 \f
354 /* Define the classes of registers for register constraints in the
355 machine description. Also define ranges of constants.
356
357 One of the classes must always be named ALL_REGS and include all hard regs.
358 If there is more than one class, another class must be named NO_REGS
359 and contain no registers.
360
361 The name GENERAL_REGS must be the name of a class (or an alias for
362 another name such as ALL_REGS). This is the class of registers
363 that is allowed by "g" or "r" in a register constraint.
364 Also, registers outside this class are allocated only when
365 instructions express preferences for them.
366
367 The classes must be numbered in nondecreasing order; that is,
368 a larger-numbered class must never be contained completely
369 in a smaller-numbered class.
370
371 For any two classes, it is very desirable that there be another
372 class that represents their union. */
373
374 enum reg_class {
375 NO_REGS, GENERAL_REGS, MAC_REGS, ALL_REGS, LIM_REG_CLASSES
376 };
377
378 #define N_REG_CLASSES (int) LIM_REG_CLASSES
379
380 /* Give names of register classes as strings for dump file. */
381
382 #define REG_CLASS_NAMES \
383 { "NO_REGS", "GENERAL_REGS", "MAC_REGS", "ALL_REGS", "LIM_REGS" }
384
385 /* Define which registers fit in which classes.
386 This is an initializer for a vector of HARD_REG_SET
387 of length N_REG_CLASSES. */
388
389 #define REG_CLASS_CONTENTS \
390 { {0}, /* No regs */ \
391 {0x2ff}, /* GENERAL_REGS */ \
392 {0x100}, /* MAC_REGS */ \
393 {0x3ff}, /* ALL_REGS */ \
394 }
395
396 /* The same information, inverted:
397 Return the class number of the smallest class containing
398 reg number REGNO. This could be a conditional expression
399 or could index an array. */
400
401 #define REGNO_REG_CLASS(REGNO) (REGNO != 8 ? GENERAL_REGS : MAC_REGS)
402
403 /* The class value for index registers, and the one for base regs. */
404
405 #define INDEX_REG_CLASS NO_REGS
406 #define BASE_REG_CLASS GENERAL_REGS
407
408 /* Get reg_class from a letter such as appears in the machine description.
409
410 'a' is the MAC register. */
411
412 #define REG_CLASS_FROM_LETTER(C) ((C) == 'a' ? MAC_REGS : NO_REGS)
413
414 /* The letters I, J, K, L, M, N, O, P in a register constraint string
415 can be used to stand for particular ranges of immediate operands.
416 This macro defines what the ranges are.
417 C is the letter, and VALUE is a constant value.
418 Return 1 if VALUE is in the range specified by C. */
419
420 #define CONST_OK_FOR_I(VALUE) ((VALUE) == 0)
421 #define CONST_OK_FOR_J(VALUE) ((unsigned HOST_WIDE_INT) (VALUE) < 256)
422 #define CONST_OK_FOR_K(VALUE) ((VALUE) == 1 || (VALUE) == 2)
423 #define CONST_OK_FOR_L(VALUE) \
424 (TARGET_H8300H || TARGET_H8300S \
425 ? (VALUE) == 1 || (VALUE) == 2 || (VALUE) == 4 \
426 : (VALUE) == 1 || (VALUE) == 2)
427 #define CONST_OK_FOR_M(VALUE) ((VALUE) == 3 || (VALUE) == 4)
428 #define CONST_OK_FOR_N(VALUE) \
429 (TARGET_H8300H || TARGET_H8300S \
430 ? (VALUE) == -1 || (VALUE) == -2 || (VALUE) == -4 \
431 : (VALUE) == -1 || (VALUE) == -2)
432 #define CONST_OK_FOR_O(VALUE) (ok_for_bclr (VALUE))
433 #define CONST_OK_FOR_P(VALUE) (small_power_of_two (VALUE))
434
435 #define CONST_OK_FOR_LETTER_P(VALUE, C) \
436 ((C) == 'I' ? CONST_OK_FOR_I (VALUE) : \
437 (C) == 'J' ? CONST_OK_FOR_J (VALUE) : \
438 (C) == 'K' ? CONST_OK_FOR_K (VALUE) : \
439 (C) == 'L' ? CONST_OK_FOR_L (VALUE) : \
440 (C) == 'M' ? CONST_OK_FOR_M (VALUE) : \
441 (C) == 'N' ? CONST_OK_FOR_N (VALUE) : \
442 (C) == 'O' ? CONST_OK_FOR_O (VALUE) : \
443 (C) == 'P' ? CONST_OK_FOR_P (VALUE) : \
444 0)
445
446 /* Similar, but for floating constants, and defining letters G and H.
447 Here VALUE is the CONST_DOUBLE rtx itself.
448
449 `G' is a floating-point zero. */
450
451 #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) \
452 ((C) == 'G' ? (VALUE) == CONST0_RTX (DFmode) \
453 : 0)
454
455 /* Given an rtx X being reloaded into a reg required to be
456 in class CLASS, return the class of reg to actually use.
457 In general this is just CLASS; but on some machines
458 in some cases it is preferable to use a more restrictive class. */
459
460 #define PREFERRED_RELOAD_CLASS(X,CLASS) (CLASS)
461
462 /* Return the maximum number of consecutive registers
463 needed to represent mode MODE in a register of class CLASS. */
464
465 /* On the H8, this is the size of MODE in words. */
466
467 #define CLASS_MAX_NREGS(CLASS, MODE) \
468 ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
469
470 /* Any SI register to register move may need to be reloaded,
471 so define REGISTER_MOVE_COST to be > 2 so that reload never
472 shortcuts. */
473
474 #define REGISTER_MOVE_COST(CLASS1, CLASS2) \
475 (CLASS1 == MAC_REGS || CLASS2 == MAC_REGS ? 6 : 3)
476 \f
477 /* Stack layout; function entry, exit and calling. */
478
479 /* Define this if pushing a word on the stack
480 makes the stack pointer a smaller address. */
481
482 #define STACK_GROWS_DOWNWARD
483
484 /* Define this if the nominal address of the stack frame
485 is at the high-address end of the local variables;
486 that is, each additional local variable allocated
487 goes at a more negative offset in the frame. */
488
489 #define FRAME_GROWS_DOWNWARD
490
491 /* Offset within stack frame to start allocating local variables at.
492 If FRAME_GROWS_DOWNWARD, this is the offset to the END of the
493 first local allocated. Otherwise, it is the offset to the BEGINNING
494 of the first local allocated. */
495
496 #define STARTING_FRAME_OFFSET 0
497
498 /* If we generate an insn to push BYTES bytes,
499 this says how many the stack pointer really advances by.
500
501 On the H8/300, @-sp really pushes a byte if you ask it to - but that's
502 dangerous, so we claim that it always pushes a word, then we catch
503 the mov.b rx,@-sp and turn it into a mov.w rx,@-sp on output.
504
505 On the H8/300H, we simplify TARGET_QUICKCALL by setting this to 4
506 and doing a similar thing. */
507
508 #define PUSH_ROUNDING(BYTES) \
509 (((BYTES) + PARM_BOUNDARY / 8 - 1) & -PARM_BOUNDARY / 8)
510
511 /* Offset of first parameter from the argument pointer register value. */
512 /* Is equal to the size of the saved fp + pc, even if an fp isn't
513 saved since the value is used before we know. */
514
515 #define FIRST_PARM_OFFSET(FNDECL) 0
516
517 /* Value is the number of bytes of arguments automatically
518 popped when returning from a subroutine call.
519 FUNDECL is the declaration node of the function (as a tree),
520 FUNTYPE is the data type of the function (as a tree),
521 or for a library call it is an identifier node for the subroutine name.
522 SIZE is the number of bytes of arguments passed on the stack.
523
524 On the H8 the return does not pop anything. */
525
526 #define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
527
528 /* Definitions for register eliminations.
529
530 This is an array of structures. Each structure initializes one pair
531 of eliminable registers. The "from" register number is given first,
532 followed by "to". Eliminations of the same "from" register are listed
533 in order of preference.
534
535 We have two registers that can be eliminated on the h8300. First, the
536 frame pointer register can often be eliminated in favor of the stack
537 pointer register. Secondly, the argument pointer register can always be
538 eliminated; it is replaced with either the stack or frame pointer. */
539
540 #define ELIMINABLE_REGS \
541 {{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \
542 { ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM}, \
543 { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}}
544
545 /* Given FROM and TO register numbers, say whether this elimination is allowed.
546 Frame pointer elimination is automatically handled.
547
548 For the h8300, if frame pointer elimination is being done, we would like to
549 convert ap into sp, not fp.
550
551 All other eliminations are valid. */
552
553 #define CAN_ELIMINATE(FROM, TO) \
554 ((FROM) == ARG_POINTER_REGNUM && (TO) == STACK_POINTER_REGNUM \
555 ? ! frame_pointer_needed \
556 : 1)
557
558 /* Define the offset between two registers, one to be eliminated, and the other
559 its replacement, at the start of a routine. */
560
561 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
562 OFFSET = initial_offset (FROM, TO)
563
564 /* Define how to find the value returned by a function.
565 VALTYPE is the data type of the value (as a tree).
566 If the precise function being called is known, FUNC is its FUNCTION_DECL;
567 otherwise, FUNC is 0.
568
569 On the H8 the return value is in R0/R1. */
570
571 #define FUNCTION_VALUE(VALTYPE, FUNC) \
572 gen_rtx_REG (TYPE_MODE (VALTYPE), 0)
573
574 /* Define how to find the value returned by a library function
575 assuming the value has mode MODE. */
576
577 /* On the H8 the return value is in R0/R1. */
578
579 #define LIBCALL_VALUE(MODE) \
580 gen_rtx_REG (MODE, 0)
581
582 /* 1 if N is a possible register number for a function value.
583 On the H8, R0 is the only register thus used. */
584
585 #define FUNCTION_VALUE_REGNO_P(N) ((N) == 0)
586
587 /* Define this if PCC uses the nonreentrant convention for returning
588 structure and union values. */
589
590 /*#define PCC_STATIC_STRUCT_RETURN*/
591
592 /* 1 if N is a possible register number for function argument passing.
593 On the H8, no registers are used in this way. */
594
595 #define FUNCTION_ARG_REGNO_P(N) (TARGET_QUICKCALL ? N < 3 : 0)
596
597 /* Register in which address to store a structure value
598 is passed to a function. */
599
600 #define STRUCT_VALUE 0
601
602 /* Return true if X should be returned in memory. */
603 #define RETURN_IN_MEMORY(X) \
604 (TYPE_MODE (X) == BLKmode || GET_MODE_SIZE (TYPE_MODE (X)) > 4)
605
606 /* When defined, the compiler allows registers explicitly used in the
607 rtl to be used as spill registers but prevents the compiler from
608 extending the lifetime of these registers. */
609
610 #define SMALL_REGISTER_CLASSES 1
611 \f
612 /* Define a data type for recording info about an argument list
613 during the scan of that argument list. This data type should
614 hold all necessary information about the function itself
615 and about the args processed so far, enough to enable macros
616 such as FUNCTION_ARG to determine where the next arg should go.
617
618 On the H8/300, this is a two item struct, the first is the number
619 of bytes scanned so far and the second is the rtx of the called
620 library function if any. */
621
622 #define CUMULATIVE_ARGS struct cum_arg
623 struct cum_arg
624 {
625 int nbytes;
626 struct rtx_def *libcall;
627 };
628
629 /* Initialize a variable CUM of type CUMULATIVE_ARGS
630 for a call to a function whose data type is FNTYPE.
631 For a library call, FNTYPE is 0.
632
633 On the H8/300, the offset starts at 0. */
634
635 #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,INDIRECT) \
636 ((CUM).nbytes = 0, (CUM).libcall = LIBNAME)
637
638 /* Update the data in CUM to advance over an argument
639 of mode MODE and data type TYPE.
640 (TYPE is null for libcalls where that information may not be available.) */
641
642 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \
643 ((CUM).nbytes += ((MODE) != BLKmode \
644 ? (GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) & -UNITS_PER_WORD \
645 : (int_size_in_bytes (TYPE) + UNITS_PER_WORD - 1) & -UNITS_PER_WORD))
646
647 /* Define where to put the arguments to a function.
648 Value is zero to push the argument on the stack,
649 or a hard register in which to store the argument.
650
651 MODE is the argument's machine mode.
652 TYPE is the data type of the argument (as a tree).
653 This is null for libcalls where that information may
654 not be available.
655 CUM is a variable of type CUMULATIVE_ARGS which gives info about
656 the preceding args and about the function being called.
657 NAMED is nonzero if this argument is a named parameter
658 (otherwise it is an extra parameter matching an ellipsis). */
659
660 /* On the H8/300 all normal args are pushed, unless -mquickcall in which
661 case the first 3 arguments are passed in registers.
662 See function `function_arg'. */
663
664 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
665 function_arg (&CUM, MODE, TYPE, NAMED)
666
667 /* Generate assembly output for the start of a function. */
668
669 #define FUNCTION_PROLOGUE(FILE, SIZE) \
670 function_prologue (FILE, SIZE)
671
672 /* Output assembler code to FILE to increment profiler label # LABELNO
673 for profiling a function entry. */
674
675 #define FUNCTION_PROFILER(FILE, LABELNO) \
676 fprintf (FILE, "\t%s\t#LP%d,%s\n\tjsr @mcount\n", \
677 h8_mov_op, (LABELNO), h8_reg_names[0]);
678
679 /* Output assembler code to FILE to initialize this source file's
680 basic block profiling info, if that has not already been done. */
681 /* ??? @LPBX0 is moved into r0 twice. */
682
683 #define FUNCTION_BLOCK_PROFILER(FILE, LABELNO) \
684 fprintf (FILE, "\t%s\t%s\n\t%s\t@LPBX0,%s\n\tbne LPI%d\n\t%s\t@LPBX0,%s\n\t%s\t%s\n\tjsr\t@__bb_init_func\nLPI%d:\t%s\t%s\n", \
685 h8_push_op, h8_reg_names[0], \
686 h8_mov_op, h8_reg_names[0], \
687 (LABELNO), \
688 h8_mov_op, h8_reg_names[0], \
689 h8_push_op, h8_reg_names[0], \
690 (LABELNO), \
691 h8_pop_op, h8_reg_names[0]);
692
693 /* Output assembler code to FILE to increment the entry-count for
694 the BLOCKNO'th basic block in this source file. This is a real pain in the
695 sphincter on a VAX, since we do not want to change any of the bits in the
696 processor status word. The way it is done here, it is pushed onto the stack
697 before any flags have changed, and then the stack is fixed up to account for
698 the fact that the instruction to restore the flags only reads a word.
699 It may seem a bit clumsy, but at least it works. */
700 /* ??? This one needs work. */
701
702 #define BLOCK_PROFILER(FILE, BLOCKNO) \
703 fprintf (FILE, "\tmovpsl -(sp)\n\tmovw (sp),2(sp)\n\taddl2 $2,sp\n\taddl2 $1,LPBX2+%d\n\tbicpsw $255\n\tbispsw (sp)+\n", \
704 4 * BLOCKNO)
705
706 /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
707 the stack pointer does not matter. The value is tested only in
708 functions that have frame pointers.
709 No definition is equivalent to always zero. */
710
711 #define EXIT_IGNORE_STACK 0
712
713 /* This macro generates the assembly code for function exit,
714 on machines that need it. If FUNCTION_EPILOGUE is not defined
715 then individual return instructions are generated for each
716 return statement. Args are same as for FUNCTION_PROLOGUE. */
717
718 #define FUNCTION_EPILOGUE(FILE, SIZE) \
719 function_epilogue (FILE, SIZE)
720
721 /* Output assembler code for a block containing the constant parts
722 of a trampoline, leaving space for the variable parts.
723
724 H8/300
725 vvvv context
726 1 0000 7900xxxx mov.w #0x1234,r3
727 2 0004 5A00xxxx jmp @0x1234
728 ^^^^ function
729
730 H8/300H
731 vvvvvvvv context
732 2 0000 7A00xxxxxxxx mov.l #0x12345678,er3
733 3 0006 5Axxxxxx jmp @0x123456
734 ^^^^^^ function
735 */
736
737 #define TRAMPOLINE_TEMPLATE(FILE) \
738 do { \
739 if (TARGET_H8300) \
740 { \
741 fprintf (FILE, "\tmov.w #0x1234,r3\n"); \
742 fprintf (FILE, "\tjmp @0x1234\n"); \
743 } \
744 else \
745 { \
746 fprintf (FILE, "\tmov.l #0x12345678,er3\n"); \
747 fprintf (FILE, "\tjmp @0x123456\n"); \
748 } \
749 } while (0)
750
751 /* Length in units of the trampoline for entering a nested function. */
752
753 #define TRAMPOLINE_SIZE (TARGET_H8300 ? 8 : 12)
754
755 /* Emit RTL insns to initialize the variable parts of a trampoline.
756 FNADDR is an RTX for the address of the function's pure code.
757 CXT is an RTX for the static chain value for the function. */
758
759 #define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
760 { \
761 enum machine_mode mode = TARGET_H8300H || TARGET_H8300S? SImode : HImode; \
762 emit_move_insn (gen_rtx_MEM (mode, plus_constant ((TRAMP), 2)), CXT); \
763 emit_move_insn (gen_rtx_MEM (mode, plus_constant ((TRAMP), 6)), FNADDR); \
764 if (TARGET_H8300H || TARGET_H8300S) \
765 emit_move_insn (gen_rtx_MEM (QImode, plus_constant ((TRAMP), 6)), \
766 GEN_INT (0x5A)); \
767 }
768 \f
769 /* Addressing modes, and classification of registers for them. */
770
771 #define HAVE_POST_INCREMENT 1
772 /*#define HAVE_POST_DECREMENT 0 */
773
774 #define HAVE_PRE_DECREMENT 1
775 /*#define HAVE_PRE_INCREMENT 0 */
776
777 /* Macros to check register numbers against specific register classes. */
778
779 /* These assume that REGNO is a hard or pseudo reg number.
780 They give nonzero only if REGNO is a hard reg of the suitable class
781 or a pseudo reg currently allocated to a suitable hard reg.
782 Since they use reg_renumber, they are safe only once reg_renumber
783 has been allocated, which happens in local-alloc.c. */
784
785 #define REGNO_OK_FOR_INDEX_P(regno) 0
786
787 #define REGNO_OK_FOR_BASE_P(regno) \
788 (((regno) < FIRST_PSEUDO_REGISTER && regno != 8) || reg_renumber[regno] >= 0)
789 \f
790 /* Maximum number of registers that can appear in a valid memory address. */
791
792 #define MAX_REGS_PER_ADDRESS 1
793
794 /* 1 if X is an rtx for a constant that is a valid address. */
795
796 #define CONSTANT_ADDRESS_P(X) \
797 (GET_CODE (X) == LABEL_REF || GET_CODE (X) == SYMBOL_REF \
798 || (GET_CODE (X) == CONST_INT \
799 /* We handle signed and unsigned offsets here. */ \
800 && INTVAL (X) > (TARGET_H8300 ? -0x10000 : -0x1000000) \
801 && INTVAL (X) < (TARGET_H8300 ? 0x10000 : 0x1000000)) \
802 || ((GET_CODE (X) == HIGH || GET_CODE (X) == CONST) \
803 && TARGET_H8300))
804
805 /* Nonzero if the constant value X is a legitimate general operand.
806 It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE. */
807
808 #define LEGITIMATE_CONSTANT_P(X) (GET_CODE (X) != CONST_DOUBLE)
809
810 /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
811 and check its validity for a certain class.
812 We have two alternate definitions for each of them.
813 The usual definition accepts all pseudo regs; the other rejects
814 them unless they have been allocated suitable hard regs.
815 The symbol REG_OK_STRICT causes the latter definition to be used.
816
817 Most source files want to accept pseudo regs in the hope that
818 they will get allocated to the class that the insn wants them to be in.
819 Source files for reload pass need to be strict.
820 After reload, it makes no difference, since pseudo regs have
821 been eliminated by then. */
822
823 #ifndef REG_OK_STRICT
824
825 /* Nonzero if X is a hard reg that can be used as an index
826 or if it is a pseudo reg. */
827 #define REG_OK_FOR_INDEX_P(X) 0
828 /* Nonzero if X is a hard reg that can be used as a base reg
829 or if it is a pseudo reg. */
830 /* Don't use REGNO_OK_FOR_BASE_P here because it uses reg_renumber. */
831 #define REG_OK_FOR_BASE_P(X) \
832 (REGNO (X) >= FIRST_PSEUDO_REGISTER || REGNO (X) != 8)
833 #define REG_OK_FOR_INDEX_P_STRICT(X) REGNO_OK_FOR_INDEX_P (REGNO (X))
834 #define REG_OK_FOR_BASE_P_STRICT(X) REGNO_OK_FOR_BASE_P (REGNO (X))
835 #define STRICT 0
836
837 #else
838
839 /* Nonzero if X is a hard reg that can be used as an index. */
840 #define REG_OK_FOR_INDEX_P(X) REGNO_OK_FOR_INDEX_P (REGNO (X))
841 /* Nonzero if X is a hard reg that can be used as a base reg. */
842 #define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X))
843 #define STRICT 1
844
845 #endif
846
847 /* Extra constraints. */
848
849 /* 'T' if valid for dec.[wl] on H8/300H and H8/S. Note that, for
850 inc.[wl], we can use 'K', which has already been defined. */
851 #define OK_FOR_T(OP) \
852 (GET_CODE (OP) == CONST_INT \
853 && (INTVAL (OP) == -1 || INTVAL (OP) == -2))
854
855 /* Nonzero if X is a constant address suitable as an 8-bit absolute on
856 the H8/300H, which is a special case of the 'R' operand. */
857
858 #define EIGHTBIT_CONSTANT_ADDRESS_P(X) \
859 (GET_CODE (X) == CONST_INT && TARGET_H8300H \
860 && 0xffff00 <= INTVAL (X) && INTVAL (X) <= 0xffffff)
861
862 /* 'U' if valid for a bset destination;
863 i.e. a register, register indirect, or the eightbit memory region
864 (a SYMBOL_REF with an SYMBOL_REF_FLAG set).
865
866 On the H8/S 'U' can also be a 16bit or 32bit absolute. */
867 #define OK_FOR_U(OP) \
868 ((GET_CODE (OP) == REG && REG_OK_FOR_BASE_P (OP)) \
869 || (GET_CODE (OP) == MEM && GET_CODE (XEXP (OP, 0)) == REG \
870 && REG_OK_FOR_BASE_P (XEXP (OP, 0))) \
871 || (GET_CODE (OP) == MEM && GET_CODE (XEXP (OP, 0)) == SYMBOL_REF \
872 && (TARGET_H8300S || SYMBOL_REF_FLAG (XEXP (OP, 0)))) \
873 || ((GET_CODE (OP) == MEM && GET_CODE (XEXP (OP, 0)) == CONST \
874 && GET_CODE (XEXP (XEXP (OP, 0), 0)) == PLUS \
875 && GET_CODE (XEXP (XEXP (XEXP (OP, 0), 0), 0)) == SYMBOL_REF \
876 && GET_CODE (XEXP (XEXP (XEXP (OP, 0), 0), 1)) == CONST_INT) \
877 && (TARGET_H8300S || SYMBOL_REF_FLAG (XEXP (XEXP (OP, 0), 0)))) \
878 || (GET_CODE (OP) == MEM \
879 && EIGHTBIT_CONSTANT_ADDRESS_P (XEXP (OP, 0))) \
880 || (GET_CODE (OP) == MEM && TARGET_H8300S \
881 && GET_CODE (XEXP (OP, 0)) == CONST_INT))
882
883 #define EXTRA_CONSTRAINT(OP, C) \
884 ((C) == 'T' ? OK_FOR_T (OP) : \
885 (C) == 'U' ? OK_FOR_U (OP) : \
886 0)
887 \f
888 /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression
889 that is a valid memory address for an instruction.
890 The MODE argument is the machine mode for the MEM expression
891 that wants to use this address.
892
893 The other macros defined here are used only in GO_IF_LEGITIMATE_ADDRESS,
894 except for CONSTANT_ADDRESS_P which is actually
895 machine-independent.
896
897 On the H8/300, a legitimate address has the form
898 REG, REG+CONSTANT_ADDRESS or CONSTANT_ADDRESS. */
899
900 /* Accept either REG or SUBREG where a register is valid. */
901
902 #define RTX_OK_FOR_BASE_P(X) \
903 ((REG_P (X) && REG_OK_FOR_BASE_P (X)) \
904 || (GET_CODE (X) == SUBREG && REG_P (SUBREG_REG (X)) \
905 && REG_OK_FOR_BASE_P (SUBREG_REG (X))))
906
907 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \
908 if (RTX_OK_FOR_BASE_P (X)) goto ADDR; \
909 if (CONSTANT_ADDRESS_P (X)) goto ADDR; \
910 if (GET_CODE (X) == PLUS \
911 && CONSTANT_ADDRESS_P (XEXP (X, 1)) \
912 && RTX_OK_FOR_BASE_P (XEXP (X, 0))) goto ADDR;
913 \f
914 /* Try machine-dependent ways of modifying an illegitimate address
915 to be legitimate. If we find one, return the new, valid address.
916 This macro is used in only one place: `memory_address' in explow.c.
917
918 OLDX is the address as it was before break_out_memory_refs was called.
919 In some cases it is useful to look at this to decide what needs to be done.
920
921 MODE and WIN are passed so that this macro can use
922 GO_IF_LEGITIMATE_ADDRESS.
923
924 It is always safe for this macro to do nothing. It exists to recognize
925 opportunities to optimize the output.
926
927 For the H8/300, don't do anything. */
928
929 #define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN) {}
930
931 /* Go to LABEL if ADDR (a legitimate address expression)
932 has an effect that depends on the machine mode it is used for.
933
934 On the H8/300, the predecrement and postincrement address depend thus
935 (the amount of decrement or increment being the length of the operand). */
936
937 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL) \
938 if (GET_CODE (ADDR) == POST_INC || GET_CODE (ADDR) == PRE_DEC) goto LABEL;
939 \f
940 /* Specify the machine mode that this machine uses
941 for the index in the tablejump instruction. */
942 #define CASE_VECTOR_MODE Pmode
943
944 /* Define as C expression which evaluates to nonzero if the tablejump
945 instruction expects the table to contain offsets from the address of the
946 table.
947 Do not define this if the table should contain absolute addresses. */
948 /*#define CASE_VECTOR_PC_RELATIVE 1 */
949
950 /* Specify the tree operation to be used to convert reals to integers. */
951 #define IMPLICIT_FIX_EXPR FIX_ROUND_EXPR
952
953 /* This is the kind of divide that is easiest to do in the general case. */
954 #define EASY_DIV_EXPR TRUNC_DIV_EXPR
955
956 /* Define this as 1 if `char' should by default be signed; else as 0.
957
958 On the H8/300, sign extension is expensive, so we'll say that chars
959 are unsigned. */
960 #define DEFAULT_SIGNED_CHAR 0
961
962 /* This flag, if defined, says the same insns that convert to a signed fixnum
963 also convert validly to an unsigned one. */
964 #define FIXUNS_TRUNC_LIKE_FIX_TRUNC
965
966 /* Max number of bytes we can move from memory to memory
967 in one reasonably fast instruction. */
968 #define MOVE_MAX (TARGET_H8300H || TARGET_H8300S ? 4 : 2)
969 #define MAX_MOVE_MAX 4
970
971 /* Define this if zero-extension is slow (more than one real instruction). */
972 /* #define SLOW_ZERO_EXTEND */
973
974 /* Nonzero if access to memory by bytes is slow and undesirable. */
975 #define SLOW_BYTE_ACCESS TARGET_SLOWBYTE
976
977 /* Define if shifts truncate the shift count
978 which implies one can omit a sign-extension or zero-extension
979 of a shift count. */
980 /* #define SHIFT_COUNT_TRUNCATED */
981
982 /* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits
983 is done just by pretending it is already truncated. */
984 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
985
986 /* Specify the machine mode that pointers have.
987 After generation of rtl, the compiler makes no further distinction
988 between pointers and any other objects of this machine mode. */
989 #define Pmode (TARGET_H8300H || TARGET_H8300S ? SImode : HImode)
990
991 /* ANSI C types.
992 We use longs for the 300H because ints can be 16 or 32.
993 GCC requires SIZE_TYPE to be the same size as pointers. */
994 #define NO_BUILTIN_SIZE_TYPE
995 #define NO_BUILTIN_PTRDIFF_TYPE
996 #define SIZE_TYPE (TARGET_H8300 ? "unsigned int" : "long unsigned int")
997 #define PTRDIFF_TYPE (TARGET_H8300 ? "int" : "long int")
998
999 #define WCHAR_TYPE "short unsigned int"
1000 #define WCHAR_TYPE_SIZE 16
1001 #define MAX_WCHAR_TYPE_SIZE 16
1002
1003 /* A function address in a call instruction
1004 is a byte address (for indexing purposes)
1005 so give the MEM rtx a byte's mode. */
1006 #define FUNCTION_MODE QImode
1007
1008 /* A C expression whose value is nonzero if IDENTIFIER with arguments ARGS
1009 is a valid machine specific attribute for DECL.
1010 The attributes in ATTRIBUTES have previously been assigned to DECL. */
1011 #define VALID_MACHINE_DECL_ATTRIBUTE(DECL, ATTRIBUTES, IDENTIFIER, ARGS) \
1012 h8300_valid_machine_decl_attribute (DECL, ATTRIBUTES, IDENTIFIER, ARGS)
1013
1014 #define ADJUST_INSN_LENGTH(INSN, LENGTH) \
1015 LENGTH += h8300_adjust_insn_length (INSN, LENGTH);
1016
1017 /* Compute the cost of computing a constant rtl expression RTX
1018 whose rtx-code is CODE. The body of this macro is a portion
1019 of a switch statement. If the code is computed here,
1020 return it with a return statement. Otherwise, break from the switch. */
1021
1022 #define DEFAULT_RTX_COSTS(RTX,CODE,OUTER_CODE) \
1023 return (const_costs (RTX, CODE));
1024
1025 #define BRANCH_COST 0
1026
1027 /* We say that MOD and DIV are so cheap because otherwise we'll
1028 generate some really horrible code for division of a power of two. */
1029
1030 /* Provide the costs of a rtl expression. This is in the body of a
1031 switch on CODE. */
1032 /* ??? Shifts need to have a *much* higher cost than this. */
1033
1034 #define RTX_COSTS(RTX,CODE,OUTER_CODE) \
1035 case MOD: \
1036 case DIV: \
1037 return 60; \
1038 case MULT: \
1039 return 20; \
1040 case ASHIFT: \
1041 case ASHIFTRT: \
1042 case LSHIFTRT: \
1043 case ROTATE: \
1044 case ROTATERT: \
1045 if (GET_MODE (RTX) == HImode) return 2; \
1046 return 8;
1047
1048 /* Tell final.c how to eliminate redundant test instructions. */
1049
1050 /* Here we define machine-dependent flags and fields in cc_status
1051 (see `conditions.h'). No extra ones are needed for the h8300. */
1052
1053 /* Store in cc_status the expressions
1054 that the condition codes will describe
1055 after execution of an instruction whose pattern is EXP.
1056 Do not alter them if the instruction would not alter the cc's. */
1057
1058 #define NOTICE_UPDATE_CC(EXP, INSN) notice_update_cc(EXP, INSN)
1059
1060 /* The add insns don't set overflow in a usable way. */
1061 #define CC_OVERFLOW_UNUSABLE 01000
1062 /* The mov,and,or,xor insns don't set carry. That's ok though as the
1063 Z bit is all we need when doing unsigned comparisons on the result of
1064 these insns (since they're always with 0). However, conditions.h has
1065 CC_NO_OVERFLOW defined for this purpose. Rename it to something more
1066 understandable. */
1067 #define CC_NO_CARRY CC_NO_OVERFLOW
1068 \f
1069 /* Control the assembler format that we output. */
1070
1071 #define ASM_IDENTIFY_GCC(FILE) /* nothing */
1072
1073 /* Output at beginning/end of assembler file. */
1074
1075 #define ASM_FILE_START(FILE) asm_file_start(FILE)
1076
1077 #define ASM_FILE_END(FILE) asm_file_end(FILE)
1078
1079 /* Output to assembler file text saying following lines
1080 may contain character constants, extra white space, comments, etc. */
1081
1082 #define ASM_APP_ON "; #APP\n"
1083
1084 /* Output to assembler file text saying following lines
1085 no longer contain unusual constructs. */
1086
1087 #define ASM_APP_OFF "; #NO_APP\n"
1088
1089 #define FILE_ASM_OP "\t.file\n"
1090 #define IDENT_ASM_OP "\t.ident\n"
1091
1092 /* The assembler op to get a word, 2 bytes for the H8/300, 4 for H8/300H. */
1093 #define ASM_WORD_OP (TARGET_H8300 ? "\t.word\t" : "\t.long\t")
1094
1095 /* We define a readonly data section solely to remove readonly data
1096 from the instruction stream. This can improve relaxing in two significant
1097 ways. First it's more likely that references to readonly data
1098 can be done with a 16bit absolute address since they'll be in low
1099 memory. Second, it's more likely that jsr instructions can be
1100 turned into bsr instructions since read-only data is not in the
1101 instruction stream. */
1102 #define READONLY_DATA_SECTION readonly_data
1103
1104 #define TEXT_SECTION_ASM_OP "\t.section .text"
1105 #define DATA_SECTION_ASM_OP "\t.section .data"
1106 #define BSS_SECTION_ASM_OP "\t.section .bss"
1107 #define INIT_SECTION_ASM_OP "\t.section .init"
1108 #define CTORS_SECTION_ASM_OP "\t.section .ctors"
1109 #define DTORS_SECTION_ASM_OP "\t.section .dtors"
1110 #define READONLY_DATA_SECTION_ASM_OP "\t.section .rodata"
1111
1112 #define EXTRA_SECTIONS in_ctors, in_dtors, in_readonly_data
1113
1114 #define EXTRA_SECTION_FUNCTIONS \
1115 \
1116 void \
1117 ctors_section () \
1118 { \
1119 if (in_section != in_ctors) \
1120 { \
1121 fprintf (asm_out_file, "%s\n", CTORS_SECTION_ASM_OP); \
1122 in_section = in_ctors; \
1123 } \
1124 } \
1125 \
1126 void \
1127 dtors_section () \
1128 { \
1129 if (in_section != in_dtors) \
1130 { \
1131 fprintf (asm_out_file, "%s\n", DTORS_SECTION_ASM_OP); \
1132 in_section = in_dtors; \
1133 } \
1134 } \
1135 \
1136 void \
1137 readonly_data () \
1138 { \
1139 if (in_section != in_readonly_data) \
1140 { \
1141 fprintf (asm_out_file, "%s\n", READONLY_DATA_SECTION_ASM_OP); \
1142 in_section = in_readonly_data; \
1143 } \
1144 }
1145
1146 #define ASM_OUTPUT_CONSTRUCTOR(FILE,NAME) \
1147 do \
1148 { \
1149 ctors_section (); \
1150 fprintf (FILE, "%s_%s\n", ASM_WORD_OP, NAME); \
1151 } \
1152 while (0)
1153
1154 #define ASM_OUTPUT_DESTRUCTOR(FILE,NAME) \
1155 do \
1156 { \
1157 dtors_section (); \
1158 fprintf (FILE, "%s_%s\n", ASM_WORD_OP, NAME); \
1159 } \
1160 while (0)
1161
1162 #undef DO_GLOBAL_CTORS_BODY
1163 #define DO_GLOBAL_CTORS_BODY \
1164 { \
1165 typedef (*pfunc)(); \
1166 extern pfunc __ctors[]; \
1167 extern pfunc __ctors_end[]; \
1168 pfunc *p; \
1169 for (p = __ctors_end; p > __ctors; ) \
1170 { \
1171 (*--p)(); \
1172 } \
1173 }
1174
1175 #undef DO_GLOBAL_DTORS_BODY
1176 #define DO_GLOBAL_DTORS_BODY \
1177 { \
1178 typedef (*pfunc)(); \
1179 extern pfunc __dtors[]; \
1180 extern pfunc __dtors_end[]; \
1181 pfunc *p; \
1182 for (p = __dtors; p < __dtors_end; p++) \
1183 { \
1184 (*p)(); \
1185 } \
1186 }
1187
1188 #define TINY_DATA_NAME_P(NAME) (*(NAME) == '&')
1189
1190 /* If we are referencing a function that is supposed to be called
1191 through the function vector, the SYMBOL_REF_FLAG in the rtl
1192 so the call patterns can generate the correct code. */
1193 #define ENCODE_SECTION_INFO(DECL) \
1194 if (TREE_CODE (DECL) == FUNCTION_DECL \
1195 && h8300_funcvec_function_p (DECL)) \
1196 SYMBOL_REF_FLAG (XEXP (DECL_RTL (DECL), 0)) = 1; \
1197 else if ((TREE_STATIC (DECL) || DECL_EXTERNAL (DECL)) \
1198 && TREE_CODE (DECL) == VAR_DECL \
1199 && h8300_eightbit_data_p (DECL)) \
1200 SYMBOL_REF_FLAG (XEXP (DECL_RTL (DECL), 0)) = 1; \
1201 else if ((TREE_STATIC (DECL) || DECL_EXTERNAL (DECL)) \
1202 && TREE_CODE (DECL) == VAR_DECL \
1203 && h8300_tiny_data_p (DECL)) \
1204 h8300_encode_label (DECL);
1205
1206 /* Store the user-specified part of SYMBOL_NAME in VAR.
1207 This is sort of inverse to ENCODE_SECTION_INFO. */
1208 #define STRIP_NAME_ENCODING(VAR,SYMBOL_NAME) \
1209 (VAR) = (SYMBOL_NAME) + ((SYMBOL_NAME)[0] == '*' \
1210 || (SYMBOL_NAME)[0] == '@' \
1211 || (SYMBOL_NAME)[0] == '&');
1212
1213 /* How to refer to registers in assembler output.
1214 This sequence is indexed by compiler's hard-register-number (see above). */
1215
1216 #define REGISTER_NAMES \
1217 { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "sp", "mac", "ap" }
1218
1219 #define ADDITIONAL_REGISTER_NAMES \
1220 { {"er0", 0}, {"er1", 1}, {"er2", 2}, {"er3", 3}, {"er4", 4}, \
1221 {"er5", 5}, {"er6", 6}, {"er7", 7}, {"r7", 7} }
1222
1223 /* How to renumber registers for dbx and gdb.
1224 H8/300 needs no change in the numeration. */
1225
1226 #define DBX_REGISTER_NUMBER(REGNO) (REGNO)
1227
1228 #define SDB_DEBUGGING_INFO
1229 #define SDB_DELIM "\n"
1230
1231 /* Support -gstabs. */
1232
1233 #include "dbxcoff.h"
1234
1235 /* Override definition in dbxcoff.h. */
1236 /* Generate a blank trailing N_SO to mark the end of the .o file, since
1237 we can't depend upon the linker to mark .o file boundaries with
1238 embedded stabs. */
1239
1240 #undef DBX_OUTPUT_MAIN_SOURCE_FILE_END
1241 #define DBX_OUTPUT_MAIN_SOURCE_FILE_END(FILE, FILENAME) \
1242 fprintf (FILE, \
1243 "\t.text\n.stabs \"\",%d,0,0,.Letext\n.Letext:\n", N_SO)
1244
1245 /* A C statement to output something to the assembler file to switch to section
1246 NAME for object DECL which is either a FUNCTION_DECL, a VAR_DECL or
1247 NULL_TREE. Some target formats do not support arbitrary sections. Do not
1248 define this macro in such cases. */
1249
1250 #define ASM_OUTPUT_SECTION_NAME(FILE, DECL, NAME, RELOC) \
1251 fprintf (FILE, "\t.section %s\n", NAME)
1252
1253 /* This is how to output the definition of a user-level label named NAME,
1254 such as the label on a static function or variable NAME. */
1255
1256 #define ASM_OUTPUT_LABEL(FILE, NAME) \
1257 do \
1258 { \
1259 assemble_name (FILE, NAME); \
1260 fputs (":\n", FILE); \
1261 } \
1262 while (0)
1263
1264 #define ASM_OUTPUT_LABELREF(FILE,NAME) \
1265 asm_fprintf ((FILE), "%U%s", (NAME) + (TINY_DATA_NAME_P (NAME) ? 1 : 0))
1266
1267 #define ASM_OUTPUT_EXTERNAL(FILE, DECL, NAME)
1268
1269 /* This is how to output a command to make the user-level label named NAME
1270 defined for reference from other files. */
1271
1272 #define ASM_GLOBALIZE_LABEL(FILE, NAME) \
1273 do \
1274 { \
1275 fputs ("\t.global ", FILE); \
1276 assemble_name (FILE, NAME); \
1277 fputs ("\n", FILE); \
1278 } \
1279 while (0)
1280
1281 #define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL) \
1282 ASM_OUTPUT_LABEL(FILE, NAME)
1283
1284 /* The prefix to add to user-visible assembler symbols. */
1285
1286 #define USER_LABEL_PREFIX "_"
1287
1288 /* This is how to output an internal numbered label where
1289 PREFIX is the class of label and NUM is the number within the class.
1290
1291 N.B.: The h8300.md branch_true and branch_false patterns also know
1292 how to generate internal labels. */
1293
1294 #define ASM_OUTPUT_INTERNAL_LABEL(FILE, PREFIX, NUM) \
1295 fprintf (FILE, ".%s%d:\n", PREFIX, NUM)
1296
1297 /* This is how to store into the string LABEL
1298 the symbol_ref name of an internal numbered label where
1299 PREFIX is the class of label and NUM is the number within the class.
1300 This is suitable for output with `assemble_name'. */
1301
1302 #define ASM_GENERATE_INTERNAL_LABEL(LABEL, PREFIX, NUM) \
1303 sprintf (LABEL, "*.%s%d", PREFIX, NUM)
1304
1305 /* This is how to output an assembler line defining a `double' constant.
1306 It is .dfloat or .gfloat, depending. */
1307
1308 #define ASM_OUTPUT_DOUBLE(FILE, VALUE) \
1309 do \
1310 { \
1311 char dstr[30]; \
1312 REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
1313 fprintf (FILE, "\t.double %s\n", dstr); \
1314 } while (0)
1315
1316 /* This is how to output an assembler line defining a `float' constant. */
1317 #define ASM_OUTPUT_FLOAT(FILE, VALUE) \
1318 do \
1319 { \
1320 char dstr[30]; \
1321 REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr); \
1322 fprintf (FILE, "\t.float %s\n", dstr); \
1323 } while (0)
1324
1325 /* This is how to output an assembler line defining an `int' constant. */
1326
1327 #define ASM_OUTPUT_INT(FILE, VALUE) \
1328 ( fprintf (FILE, "\t.long "), \
1329 output_addr_const (FILE, (VALUE)), \
1330 fprintf (FILE, "\n"))
1331
1332 /* Likewise for `char' and `short' constants. */
1333
1334 #define ASM_OUTPUT_SHORT(FILE, VALUE) \
1335 ( fprintf (FILE, "\t.word "), \
1336 output_addr_const (FILE, (VALUE)), \
1337 fprintf (FILE, "\n"))
1338
1339 #define ASM_OUTPUT_CHAR(FILE, VALUE) \
1340 ( fprintf (FILE, "\t.byte "), \
1341 output_addr_const (FILE, (VALUE)), \
1342 fprintf (FILE, "\n"))
1343
1344 /* This is how to output an assembler line for a numeric constant byte. */
1345 #define ASM_OUTPUT_BYTE(FILE, VALUE) \
1346 fprintf (FILE, "\t.byte 0x%x\n", (VALUE))
1347
1348 /* This is how to output an insn to push a register on the stack.
1349 It need not be very fast code. */
1350
1351 #define ASM_OUTPUT_REG_PUSH(FILE, REGNO) \
1352 fprintf (FILE, "\t%s\t%s\n", h8_push_op, h8_reg_names[REGNO])
1353
1354 /* This is how to output an insn to pop a register from the stack.
1355 It need not be very fast code. */
1356
1357 #define ASM_OUTPUT_REG_POP(FILE,REGNO) \
1358 fprintf (FILE, "\t%s\t%s\n", h8_pop_op, h8_reg_names[REGNO])
1359
1360 /* This is how to output an element of a case-vector that is absolute. */
1361
1362 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \
1363 asm_fprintf (FILE, "%s.L%d\n", ASM_WORD_OP, VALUE)
1364
1365 /* This is how to output an element of a case-vector that is relative. */
1366
1367 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) \
1368 fprintf (FILE, "%s.L%d-.L%d\n", ASM_WORD_OP, VALUE, REL)
1369
1370 /* This is how to output an assembler line
1371 that says to advance the location counter
1372 to a multiple of 2**LOG bytes. */
1373
1374 #define ASM_OUTPUT_ALIGN(FILE,LOG) \
1375 if ((LOG) != 0) \
1376 fprintf (FILE, "\t.align %d\n", (LOG))
1377
1378 /* This is how to output an assembler line
1379 that says to advance the location counter by SIZE bytes. */
1380
1381 #define ASM_OUTPUT_IDENT(FILE, NAME) \
1382 fprintf (FILE, "%s\"%s\"\n", IDENT_ASM_OP, NAME)
1383
1384 #define ASM_OUTPUT_SKIP(FILE, SIZE) \
1385 fprintf (FILE, "\t.space %d\n", (SIZE))
1386
1387 /* This says how to output an assembler line
1388 to define a global common symbol. */
1389
1390 #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED) \
1391 ( fputs ("\t.comm ", (FILE)), \
1392 assemble_name ((FILE), (NAME)), \
1393 fprintf ((FILE), ",%d\n", (SIZE)))
1394
1395 /* This says how to output the assembler to define a global
1396 uninitialized but not common symbol.
1397 Try to use asm_output_bss to implement this macro. */
1398
1399 #define ASM_OUTPUT_BSS(FILE, DECL, NAME, SIZE, ROUNDED) \
1400 asm_output_bss ((FILE), (DECL), (NAME), (SIZE), (ROUNDED))
1401
1402 /* This says how to output an assembler line
1403 to define a local common symbol. */
1404
1405 #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE,ROUNDED) \
1406 ( fputs ("\t.lcomm ", (FILE)), \
1407 assemble_name ((FILE), (NAME)), \
1408 fprintf ((FILE), ",%d\n", (SIZE)))
1409
1410 /* Store in OUTPUT a string (made with alloca) containing
1411 an assembler-name for a local static variable named NAME.
1412 LABELNO is an integer which is different for each call. */
1413
1414 #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO) \
1415 ( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 10), \
1416 sprintf ((OUTPUT), "%s___%d", (NAME), (LABELNO)))
1417
1418 /* Define the parentheses used to group arithmetic operations
1419 in assembler code. */
1420
1421 #define ASM_OPEN_PAREN "("
1422 #define ASM_CLOSE_PAREN ")"
1423
1424 /* Define results of standard character escape sequences. */
1425 #define TARGET_BELL 007
1426 #define TARGET_BS 010
1427 #define TARGET_TAB 011
1428 #define TARGET_NEWLINE 012
1429 #define TARGET_VT 013
1430 #define TARGET_FF 014
1431 #define TARGET_CR 015
1432
1433 /* Print an instruction operand X on file FILE.
1434 Look in h8300.c for details. */
1435
1436 #define PRINT_OPERAND_PUNCT_VALID_P(CODE) \
1437 ((CODE) == '#')
1438
1439 #define PRINT_OPERAND(FILE, X, CODE) print_operand(FILE,X,CODE)
1440
1441 /* Print a memory operand whose address is X, on file FILE.
1442 This uses a function in h8300.c. */
1443
1444 #define PRINT_OPERAND_ADDRESS(FILE, ADDR) print_operand_address (FILE, ADDR)
1445
1446 /* H8300 specific pragmas. */
1447 #define REGISTER_TARGET_PRAGMAS(PFILE) \
1448 do \
1449 { \
1450 cpp_register_pragma (PFILE, 0, "saveall", h8300_pr_saveall); \
1451 cpp_register_pragma (PFILE, 0, "interrupt", h8300_pr_interrupt); \
1452 } \
1453 while (0)
1454
1455 #define FINAL_PRESCAN_INSN(insn, operand, nop) \
1456 final_prescan_insn (insn, operand, nop)
1457
1458 /* Define this macro if GNU CC should generate calls to the System V
1459 (and ANSI C) library functions `memcpy' and `memset' rather than
1460 the BSD functions `bcopy' and `bzero'. */
1461
1462 #define TARGET_MEM_FUNCTIONS 1
1463
1464 #define MULHI3_LIBCALL "__mulhi3"
1465 #define DIVHI3_LIBCALL "__divhi3"
1466 #define UDIVHI3_LIBCALL "__udivhi3"
1467 #define MODHI3_LIBCALL "__modhi3"
1468 #define UMODHI3_LIBCALL "__umodhi3"
1469
1470 /* Perform target dependent optabs initialization. */
1471
1472 #define INIT_TARGET_OPTABS \
1473 do \
1474 { \
1475 smul_optab->handlers[(int) HImode].libfunc \
1476 = init_one_libfunc (MULHI3_LIBCALL); \
1477 sdiv_optab->handlers[(int) HImode].libfunc \
1478 = init_one_libfunc (DIVHI3_LIBCALL); \
1479 udiv_optab->handlers[(int) HImode].libfunc \
1480 = init_one_libfunc (UDIVHI3_LIBCALL); \
1481 smod_optab->handlers[(int) HImode].libfunc \
1482 = init_one_libfunc (MODHI3_LIBCALL); \
1483 umod_optab->handlers[(int) HImode].libfunc \
1484 = init_one_libfunc (UMODHI3_LIBCALL); \
1485 } \
1486 while (0)
1487
1488 #define MOVE_RATIO 3
1489
1490 #endif /* GCC_H8300_H */