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