OSDN Git Service

* config/stormy16/stormy16.h (IRA_COVER_CLASSES): Define.
[pf3gnuchains/gcc-fork.git] / gcc / config / stormy16 / stormy16.h
1 /* Xstormy16 cpu description.
2    Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007,
3    2008  Free Software Foundation, Inc.
4    Contributed by Red Hat, Inc.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
12
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
21
22 \f
23 /* Driver configuration */
24
25 /* Defined in svr4.h.  */
26 #undef ASM_SPEC
27 #define ASM_SPEC ""
28
29 /* For xstormy16:
30    - If -msim is specified, everything is built and linked as for the sim.
31    - If -T is specified, that linker script is used, and it should provide
32      appropriate libraries.
33    - If neither is specified, everything is built as for the sim, but no
34      I/O support is assumed.
35
36 */
37 #undef LIB_SPEC
38 #define LIB_SPEC "-( -lc %{msim:-lsim}%{!msim:%{!T*:-lnosys}} -)"
39
40 /* Defined in svr4.h.  */
41 #undef STARTFILE_SPEC
42 #define STARTFILE_SPEC "crt0.o%s crti.o%s crtbegin.o%s"
43
44 /* Defined in svr4.h.  */
45 #undef ENDFILE_SPEC
46 #define ENDFILE_SPEC "crtend.o%s crtn.o%s"
47
48 /* Defined in svr4.h for host compilers.  */
49 /* #define MD_EXEC_PREFIX "" */
50
51 /* Defined in svr4.h for host compilers.  */
52 /* #define MD_STARTFILE_PREFIX "" */
53
54 \f
55 /* Run-time target specifications */
56
57 #define TARGET_CPU_CPP_BUILTINS() do {  \
58   builtin_define_std ("xstormy16");     \
59   builtin_assert ("machine=xstormy16"); \
60   builtin_assert ("cpu=xstormy16");     \
61 } while (0)
62
63 #define TARGET_VERSION fprintf (stderr, " (xstormy16 cpu core)");
64
65 #define CAN_DEBUG_WITHOUT_FP
66
67 \f
68 /* Storage Layout */
69
70 #define BITS_BIG_ENDIAN 1
71
72 #define BYTES_BIG_ENDIAN 0
73
74 #define WORDS_BIG_ENDIAN 0
75
76 #define UNITS_PER_WORD 2
77
78 #define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE)                               \
79 do {                                                                    \
80   if (GET_MODE_CLASS (MODE) == MODE_INT                                 \
81       && GET_MODE_SIZE (MODE) < 2)                                      \
82     (MODE) = HImode;                                                    \
83 } while (0)
84
85 #define PARM_BOUNDARY 16
86
87 #define STACK_BOUNDARY 16
88
89 #define FUNCTION_BOUNDARY 16
90
91 #define BIGGEST_ALIGNMENT 16
92
93 /* Defined in svr4.h.  */
94 /* #define MAX_OFILE_ALIGNMENT */
95
96 #define DATA_ALIGNMENT(TYPE, ALIGN)             \
97   (TREE_CODE (TYPE) == ARRAY_TYPE               \
98    && TYPE_MODE (TREE_TYPE (TYPE)) == QImode    \
99    && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
100
101 #define CONSTANT_ALIGNMENT(EXP, ALIGN)  \
102   (TREE_CODE (EXP) == STRING_CST        \
103    && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
104
105 #define STRICT_ALIGNMENT 1
106
107 /* Defined in svr4.h.  */
108 #define PCC_BITFIELD_TYPE_MATTERS 1
109 \f
110 /* Layout of Source Language Data Types */
111
112 #define INT_TYPE_SIZE 16
113
114 #define SHORT_TYPE_SIZE 16
115
116 #define LONG_TYPE_SIZE 32
117
118 #define LONG_LONG_TYPE_SIZE 64
119
120 #define FLOAT_TYPE_SIZE 32
121
122 #define DOUBLE_TYPE_SIZE 64
123
124 #define LONG_DOUBLE_TYPE_SIZE 64
125
126 #define DEFAULT_SIGNED_CHAR 0
127
128 /* Defined in svr4.h.  */
129 #define SIZE_TYPE "unsigned int"
130
131 /* Defined in svr4.h.  */
132 #define PTRDIFF_TYPE "int"
133
134 /* Defined in svr4.h, to "long int".  */
135 /* #define WCHAR_TYPE "long int" */
136
137 /* Defined in svr4.h.  */
138 #undef WCHAR_TYPE_SIZE
139 #define WCHAR_TYPE_SIZE 32
140
141 /* Define this macro if the type of Objective-C selectors should be `int'.
142
143    If this macro is not defined, then selectors should have the type `struct
144    objc_selector *'.  */
145 /* #define OBJC_INT_SELECTORS */
146
147 \f
148 /* Register Basics */
149
150 #define FIRST_PSEUDO_REGISTER 19
151
152 #define FIXED_REGISTERS \
153   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1 }
154
155 #define CALL_USED_REGISTERS \
156   { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1 }
157
158 \f
159 /* Order of allocation of registers */
160
161 #define REG_ALLOC_ORDER { 7, 6, 5, 4, 3, 2, 1, 0, 9, 8, 10, 11, 12, 13, 14, 15, 16 }
162
163 \f
164 /* How Values Fit in Registers */
165
166 #define HARD_REGNO_NREGS(REGNO, MODE)                           \
167   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
168
169 #define HARD_REGNO_MODE_OK(REGNO, MODE) ((REGNO) != 16 || (MODE) == BImode)
170
171 /* A C expression that is nonzero if it is desirable to choose register
172    allocation so as to avoid move instructions between a value of mode MODE1
173    and a value of mode MODE2.
174
175    If `HARD_REGNO_MODE_OK (R, MODE1)' and `HARD_REGNO_MODE_OK (R, MODE2)' are
176    ever different for any R, then `MODES_TIEABLE_P (MODE1, MODE2)' must be
177    zero.  */
178 #define MODES_TIEABLE_P(MODE1, MODE2) ((MODE1) != BImode && (MODE2) != BImode)
179
180 \f
181 /* Register Classes */
182
183 enum reg_class
184 {
185   NO_REGS,
186   R0_REGS,
187   R1_REGS,
188   TWO_REGS,
189   R2_REGS,
190   EIGHT_REGS,
191   R8_REGS,
192   ICALL_REGS,
193   GENERAL_REGS,
194   CARRY_REGS,
195   ALL_REGS,
196   LIM_REG_CLASSES
197 };
198
199 #define N_REG_CLASSES ((int) LIM_REG_CLASSES)
200
201 #define IRA_COVER_CLASSES                       \
202 {                                               \
203   GENERAL_REGS, CARRY_REGS, LIM_REG_CLASSES     \
204 }
205
206 #define REG_CLASS_NAMES                         \
207 {                                               \
208   "NO_REGS",                                    \
209   "R0_REGS",                                    \
210   "R1_REGS",                                    \
211   "TWO_REGS",                                   \
212   "R2_REGS",                                    \
213   "EIGHT_REGS",                                 \
214   "R8_REGS",                                    \
215   "ICALL_REGS",                                 \
216   "GENERAL_REGS",                               \
217   "CARRY_REGS",                                 \
218   "ALL_REGS"                                    \
219 }
220
221 #define REG_CLASS_CONTENTS                      \
222 {                                               \
223   { 0x00000 },                                  \
224   { 0x00001 },                                  \
225   { 0x00002 },                                  \
226   { 0x00003 },                                  \
227   { 0x00004 },                                  \
228   { 0x000FF },                                  \
229   { 0x00100 },                                  \
230   { 0x00300 },                                  \
231   { 0x6FFFF },                                  \
232   { 0x10000 },                                  \
233   { (1 << FIRST_PSEUDO_REGISTER) - 1 }          \
234 }
235
236 #define REGNO_REG_CLASS(REGNO)                  \
237   ((REGNO) == 0   ? R0_REGS                     \
238    : (REGNO) == 1 ? R1_REGS                     \
239    : (REGNO) == 2 ? R2_REGS                     \
240    : (REGNO) < 8  ? EIGHT_REGS                  \
241    : (REGNO) == 8 ? R8_REGS                     \
242    : (REGNO) == 16 ? CARRY_REGS                 \
243    : (REGNO) <= 18 ? GENERAL_REGS               \
244    : ALL_REGS)
245
246 #define BASE_REG_CLASS GENERAL_REGS
247
248 #define INDEX_REG_CLASS GENERAL_REGS
249
250 /*   The following letters are unavailable, due to being used as
251    constraints:
252         '0'..'9'
253         '<', '>'
254         'E', 'F', 'G', 'H'
255         'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P'
256         'Q', 'R', 'S', 'T', 'U'
257         'V', 'X'
258         'g', 'i', 'm', 'n', 'o', 'p', 'r', 's' */
259
260 #define REG_CLASS_FROM_LETTER(CHAR)             \
261  (  (CHAR) == 'a' ? R0_REGS                     \
262   : (CHAR) == 'b' ? R1_REGS                     \
263   : (CHAR) == 'c' ? R2_REGS                     \
264   : (CHAR) == 'd' ? R8_REGS                     \
265   : (CHAR) == 'e' ? EIGHT_REGS                  \
266   : (CHAR) == 't' ? TWO_REGS                    \
267   : (CHAR) == 'y' ? CARRY_REGS                  \
268   : (CHAR) == 'z' ? ICALL_REGS                  \
269   : NO_REGS)
270
271 #define REGNO_OK_FOR_BASE_P(NUM) 1
272
273 #define REGNO_OK_FOR_INDEX_P(NUM) REGNO_OK_FOR_BASE_P (NUM)
274
275 /* This declaration must be present.  */
276 #define PREFERRED_RELOAD_CLASS(X, CLASS) \
277   xstormy16_preferred_reload_class (X, CLASS)
278
279 #define PREFERRED_OUTPUT_RELOAD_CLASS(X, CLASS) \
280   xstormy16_preferred_reload_class (X, CLASS)
281
282 /* This chip has the interesting property that only the first eight
283    registers can be moved to/from memory.  */
284 #define SECONDARY_RELOAD_CLASS(CLASS, MODE, X)                  \
285   xstormy16_secondary_reload_class (CLASS, MODE, X)
286
287 /* Normally the compiler avoids choosing registers that have been explicitly
288    mentioned in the rtl as spill registers (these registers are normally those
289    used to pass parameters and return values).  However, some machines have so
290    few registers of certain classes that there would not be enough registers to
291    use as spill registers if this were done.
292
293    Define `SMALL_REGISTER_CLASSES' to be an expression with a nonzero value on
294    these machines.  When this macro has a nonzero value, the compiler allows
295    registers explicitly used in the rtl to be used as spill registers but
296    avoids extending the lifetime of these registers.
297
298    It is always safe to define this macro with a nonzero value, but if you
299    unnecessarily define it, you will reduce the amount of optimizations that
300    can be performed in some cases.  If you do not define this macro with a
301    nonzero value when it is required, the compiler will run out of spill
302    registers and print a fatal error message.  For most machines, you should
303    not define this macro at all.  */
304 /* #define SMALL_REGISTER_CLASSES */
305
306 /* This declaration is required.  */
307 #define CLASS_MAX_NREGS(CLASS, MODE) \
308   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
309
310 /* If defined, a C expression for a class that contains registers which the
311    compiler must always access in a mode that is the same size as the mode in
312    which it loaded the register.
313
314    For the example, loading 32-bit integer or floating-point objects into
315    floating-point registers on the Alpha extends them to 64-bits.  Therefore
316    loading a 64-bit object and then storing it as a 32-bit object does not
317    store the low-order 32-bits, as would be the case for a normal register.
318    Therefore, `alpha.h' defines this macro as `FLOAT_REGS'.  */
319 /* #define CLASS_CANNOT_CHANGE_SIZE */
320
321 #define CONST_OK_FOR_LETTER_P(VALUE, C)                 \
322   (  (C) == 'I' ? (VALUE) >= 0 && (VALUE) <= 3          \
323    : (C) == 'J' ? exact_log2 (VALUE) != -1              \
324    : (C) == 'K' ? exact_log2 (~(VALUE)) != -1           \
325    : (C) == 'L' ? (VALUE) >= 0 && (VALUE) <= 255        \
326    : (C) == 'M' ? (VALUE) >= -255 && (VALUE) <= 0       \
327    : (C) == 'N' ? (VALUE) >= -3 && (VALUE) <= 0         \
328    : (C) == 'O' ? (VALUE) >= 1 && (VALUE) <= 4          \
329    : (C) == 'P' ? (VALUE) >= -4 && (VALUE) <= -1        \
330    : 0 )
331
332 #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) 0
333
334 #define EXTRA_CONSTRAINT(VALUE, C) \
335   xstormy16_extra_constraint_p (VALUE, C)
336
337 \f
338 /* Basic Stack Layout */
339
340 /* We want to use post-increment instructions to push things on the stack,
341    because we don't have any pre-increment ones.  */
342 #define STACK_PUSH_CODE POST_INC
343
344 #define FRAME_GROWS_DOWNWARD 0
345
346 #define ARGS_GROW_DOWNWARD 1
347
348 #define STARTING_FRAME_OFFSET 0
349
350 #define FIRST_PARM_OFFSET(FUNDECL) 0
351
352 #define RETURN_ADDR_RTX(COUNT, FRAMEADDR)       \
353   ((COUNT) == 0                                 \
354    ? gen_rtx_MEM (Pmode, arg_pointer_rtx)       \
355    : NULL_RTX)
356
357 #define INCOMING_RETURN_ADDR_RTX  \
358    gen_rtx_MEM (SImode, gen_rtx_PLUS (Pmode, stack_pointer_rtx, GEN_INT (-4)))
359
360 #define INCOMING_FRAME_SP_OFFSET (xstormy16_interrupt_function_p () ? 6 : 4)
361
362 \f
363 /* Register That Address the Stack Frame.  */
364
365 #define STACK_POINTER_REGNUM 15
366
367 #define FRAME_POINTER_REGNUM 17
368
369 #define HARD_FRAME_POINTER_REGNUM 13
370
371 #define ARG_POINTER_REGNUM 18
372
373 #define STATIC_CHAIN_REGNUM 1
374
375 \f
376 /* Eliminating the Frame Pointer and the Arg Pointer */
377
378 #define FRAME_POINTER_REQUIRED 0
379
380 #define ELIMINABLE_REGS                                 \
381 {                                                       \
382   {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM},         \
383   {FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM},    \
384   {ARG_POINTER_REGNUM,   STACK_POINTER_REGNUM},         \
385   {ARG_POINTER_REGNUM,   HARD_FRAME_POINTER_REGNUM},    \
386 }
387
388 #define CAN_ELIMINATE(FROM, TO)                                         \
389  ((FROM) == ARG_POINTER_REGNUM && (TO) == STACK_POINTER_REGNUM          \
390   ? ! frame_pointer_needed                                              \
391   : 1)
392
393 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
394   (OFFSET) = xstormy16_initial_elimination_offset (FROM, TO)
395
396 \f
397 /* Passing Function Arguments on the Stack */
398
399 #define PUSH_ROUNDING(BYTES) (((BYTES) + 1) & ~1)
400
401 #define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACK_SIZE) 0
402
403 \f
404 /* Function Arguments in Registers */
405
406 #define NUM_ARGUMENT_REGISTERS 6
407 #define FIRST_ARGUMENT_REGISTER 2
408
409 #define XSTORMY16_WORD_SIZE(TYPE, MODE)                         \
410   ((((TYPE) ? int_size_in_bytes (TYPE) : GET_MODE_SIZE (MODE))  \
411     + 1)                                                        \
412    / 2)
413
414 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
415         xstormy16_function_arg (CUM, MODE, TYPE, NAMED)
416
417 /* For this platform, the value of CUMULATIVE_ARGS is the number of words
418    of arguments that have been passed in registers so far.  */
419 #define CUMULATIVE_ARGS int
420
421 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT, N_NAMED_ARGS) \
422   (CUM) = 0
423
424 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)                    \
425   ((CUM) = xstormy16_function_arg_advance (CUM, MODE, TYPE, NAMED))
426
427 #define FUNCTION_ARG_REGNO_P(REGNO)                                     \
428   ((REGNO) >= FIRST_ARGUMENT_REGISTER                                   \
429    && (REGNO) < FIRST_ARGUMENT_REGISTER + NUM_ARGUMENT_REGISTERS)
430
431 \f
432 /* How Scalar Function Values are Returned */
433
434 /* The number of the hard register that is used to return a scalar value from a
435    function call.  */
436 #define RETURN_VALUE_REGNUM     FIRST_ARGUMENT_REGISTER
437      
438 #define FUNCTION_VALUE(VALTYPE, FUNC) \
439   xstormy16_function_value (VALTYPE, FUNC)
440
441 #define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, RETURN_VALUE_REGNUM)
442
443 #define FUNCTION_VALUE_REGNO_P(REGNO) ((REGNO) == RETURN_VALUE_REGNUM)
444
445 \f
446 /* Function Entry and Exit */
447
448 #define EPILOGUE_USES(REGNO) \
449   xstormy16_epilogue_uses (REGNO)
450
451 \f
452 /* Generating Code for Profiling.  */
453
454 /* This declaration must be present, but it can be an abort if profiling is
455    not implemented.  */
456      
457 #define FUNCTION_PROFILER(FILE, LABELNO) xstormy16_function_profiler ()
458
459 \f
460 /* If the target has particular reasons why a function cannot be inlined,
461    it may define the TARGET_CANNOT_INLINE_P.  This macro takes one argument,
462    the DECL describing the function.  The function should NULL if the function
463    *can* be inlined.  Otherwise it should return a pointer to a string containing
464    a message describing why the function could not be inlined.  The message will
465    displayed if the '-Winline' command line switch has been given.  If the message
466    contains a '%s' sequence, this will be replaced by the name of the function.  */
467 /* #define TARGET_CANNOT_INLINE_P(FN_DECL) xstormy16_cannot_inline_p (FN_DECL) */
468 \f
469 /* Trampolines for Nested Functions.  */
470
471 #define TRAMPOLINE_SIZE 8
472
473 #define TRAMPOLINE_ALIGNMENT 16
474
475 #define INITIALIZE_TRAMPOLINE(ADDR, FNADDR, STATIC_CHAIN) \
476   xstormy16_initialize_trampoline (ADDR, FNADDR, STATIC_CHAIN)
477
478 \f
479 /* Define this macro to override the type used by the library routines to pick
480    up arguments of type `float'.  (By default, they use a union of `float' and
481    `int'.)
482
483    The obvious choice would be `float'--but that won't work with traditional C
484    compilers that expect all arguments declared as `float' to arrive as
485    `double'.  To avoid this conversion, the library routines ask for the value
486    as some other type and then treat it as a `float'.  */
487 /* #define FLOAT_ARG_TYPE */
488
489 /* Define this macro to override the way library routines redesignate a `float'
490    argument as a `float' instead of the type it was passed as.  The default is
491    an expression which takes the `float' field of the union.  */
492 /* #define FLOATIFY(PASSED_VALUE) */
493
494 /* Define this macro to override the type used by the library routines to
495    return values that ought to have type `float'.  (By default, they use
496    `int'.)
497
498    The obvious choice would be `float'--but that won't work with traditional C
499    compilers gratuitously convert values declared as `float' into `double'.  */
500 /* #define FLOAT_VALUE_TYPE */
501
502 /* Define this macro to override the way the value of a `float'-returning
503    library routine should be packaged in order to return it.  These functions
504    are actually declared to return type `FLOAT_VALUE_TYPE' (normally `int').
505
506    These values can't be returned as type `float' because traditional C
507    compilers would gratuitously convert the value to a `double'.
508
509    A local variable named `intify' is always available when the macro `INTIFY'
510    is used.  It is a union of a `float' field named `f' and a field named `i'
511    whose type is `FLOAT_VALUE_TYPE' or `int'.
512
513    If you don't define this macro, the default definition works by copying the
514    value through that union.  */
515 /* #define INTIFY(FLOAT_VALUE) */
516
517 /* Define this macro as the name of the data type corresponding to `SImode' in
518    the system's own C compiler.
519
520    You need not define this macro if that type is `long int', as it usually is.  */
521 /* #define nongcc_SI_type */
522
523 /* Define this macro as the name of the data type corresponding to the
524    word_mode in the system's own C compiler.
525
526    You need not define this macro if that type is `long int', as it usually is.  */
527 /* #define nongcc_word_type */
528
529 /* Define these macros to supply explicit C statements to carry out various
530    arithmetic operations on types `float' and `double' in the library routines
531    in `libgcc1.c'.  See that file for a full list of these macros and their
532    arguments.
533
534    On most machines, you don't need to define any of these macros, because the
535    C compiler that comes with the system takes care of doing them.  */
536 /* #define perform_...  */
537
538 \f
539 /* Addressing Modes */
540
541 #define HAVE_POST_INCREMENT 1
542
543 #define HAVE_PRE_DECREMENT 1
544
545 #define CONSTANT_ADDRESS_P(X) CONSTANT_P (X)
546
547 #define MAX_REGS_PER_ADDRESS 1
548
549 #ifdef REG_OK_STRICT
550 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL)        \
551 do {                                                    \
552   if (xstormy16_legitimate_address_p (MODE, X, 1))      \
553     goto LABEL;                                         \
554 } while (0)
555 #else
556 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL)        \
557 do {                                                    \
558   if (xstormy16_legitimate_address_p (MODE, X, 0))      \
559     goto LABEL;                                         \
560 } while (0)
561 #endif
562
563 #ifdef REG_OK_STRICT
564 #define REG_OK_FOR_BASE_P(X)                                               \
565   (REGNO_OK_FOR_BASE_P (REGNO (X)) && (REGNO (X) < FIRST_PSEUDO_REGISTER))
566 #else
567 #define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X))
568 #endif
569
570 #define REG_OK_FOR_INDEX_P(X) REG_OK_FOR_BASE_P (X)
571
572 /* On this chip, this is true if the address is valid with an offset
573    of 0 but not of 6, because in that case it cannot be used as an
574    address for DImode or DFmode, or if the address is a post-increment
575    or pre-decrement address.
576 */
577 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL)                        \
578   if (xstormy16_mode_dependent_address_p (ADDR))                                \
579     goto LABEL
580
581 #define LEGITIMATE_CONSTANT_P(X) 1
582
583 \f
584 /* Describing Relative Costs of Operations */
585
586 #define REGISTER_MOVE_COST(MODE, FROM, TO) 2
587
588 #define MEMORY_MOVE_COST(M,C,I) (5 + memory_move_secondary_cost (M, C, I))
589
590 #define BRANCH_COST 5
591
592 #define SLOW_BYTE_ACCESS 0
593
594 #define NO_FUNCTION_CSE
595
596 \f
597 /* Dividing the output into sections.  */
598
599 #define TEXT_SECTION_ASM_OP ".text"
600
601 #define DATA_SECTION_ASM_OP ".data"
602
603 #define BSS_SECTION_ASM_OP "\t.section\t.bss"
604
605 /* Define the pseudo-ops used to switch to the .ctors and .dtors sections.
606    There are no shared libraries on this target so these sections need
607    not be writable.
608
609    Defined in elfos.h.  */
610
611 #undef CTORS_SECTION_ASM_OP
612 #undef DTORS_SECTION_ASM_OP
613 #define CTORS_SECTION_ASM_OP    "\t.section\t.ctors,\"a\""
614 #define DTORS_SECTION_ASM_OP    "\t.section\t.dtors,\"a\""
615
616 #define TARGET_ASM_INIT_SECTIONS xstormy16_asm_init_sections
617
618 #define JUMP_TABLES_IN_TEXT_SECTION 1
619 \f
620 /* The Overall Framework of an Assembler File.  */
621
622 #define ASM_COMMENT_START ";"
623
624 #define ASM_APP_ON "#APP\n"
625
626 #define ASM_APP_OFF "#NO_APP\n"
627 \f
628 /* Output of Data.  */
629
630 #define IS_ASM_LOGICAL_LINE_SEPARATOR(C, STR) ((C) == '|')
631
632 #define ASM_OUTPUT_ALIGNED_DECL_COMMON(STREAM, DECL, NAME, SIZE, ALIGNMENT) \
633   xstormy16_asm_output_aligned_common (STREAM, DECL, NAME, SIZE, ALIGNMENT, 1)
634 #define ASM_OUTPUT_ALIGNED_DECL_LOCAL(STREAM, DECL, NAME, SIZE, ALIGNMENT) \
635   xstormy16_asm_output_aligned_common (STREAM, DECL, NAME, SIZE, ALIGNMENT, 0)
636
637 \f
638 /* Output and Generation of Labels.  */
639 #define SYMBOL_FLAG_XSTORMY16_BELOW100  (SYMBOL_FLAG_MACH_DEP << 0)
640
641 #define ASM_OUTPUT_SYMBOL_REF(STREAM, SYMBOL)                           \
642   do {                                                                  \
643     const char *rn = XSTR (SYMBOL, 0);                                  \
644     if (SYMBOL_REF_FUNCTION_P (SYMBOL))                                 \
645       ASM_OUTPUT_LABEL_REF ((STREAM), rn);                              \
646     else                                                                \
647       assemble_name (STREAM, rn);                                       \
648   } while (0)
649
650 #define ASM_OUTPUT_LABEL_REF(STREAM, NAME)      \
651 do  {                                           \
652   fputs ("@fptr(", STREAM);                     \
653   assemble_name (STREAM, NAME);                 \
654   fputc (')', STREAM);                          \
655 } while (0)
656
657 /* Globalizing directive for a label.  */
658 #define GLOBAL_ASM_OP "\t.globl "
659
660 \f
661 /* Macros Controlling Initialization Routines.  */
662
663 /* When you are using special sections for
664    initialization and termination functions, this macro also controls how
665    `crtstuff.c' and `libgcc2.c' arrange to run the initialization functions.
666
667    Defined in svr4.h.  */
668 /* #define INIT_SECTION_ASM_OP */
669
670 /* Define this macro as a C statement to output on the stream STREAM the
671    assembler code to arrange to call the function named NAME at initialization
672    time.
673
674    Assume that NAME is the name of a C function generated automatically by the
675    compiler.  This function takes no arguments.  Use the function
676    `assemble_name' to output the name NAME; this performs any system-specific
677    syntactic transformations such as adding an underscore.
678
679    If you don't define this macro, nothing special is output to arrange to call
680    the function.  This is correct when the function will be called in some
681    other manner--for example, by means of the `collect2' program, which looks
682    through the symbol table to find these functions by their names.
683
684    Defined in svr4.h.  */
685 /* #define ASM_OUTPUT_CONSTRUCTOR(STREAM, NAME) */
686
687 /* This is like `ASM_OUTPUT_CONSTRUCTOR' but used for termination functions
688    rather than initialization functions.
689
690    Defined in svr4.h.  */
691 /* #define ASM_OUTPUT_DESTRUCTOR(STREAM, NAME) */
692
693 /* Define this macro if the system uses ELF format object files.
694
695    Defined in svr4.h.  */
696 /* #define OBJECT_FORMAT_ELF */
697
698 \f
699 /* Output of Assembler Instructions.  */
700
701 #define REGISTER_NAMES                                                  \
702 { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10",    \
703   "r11", "r12", "r13", "psw", "sp", "carry", "fp", "ap" }
704
705 #define ADDITIONAL_REGISTER_NAMES               \
706   { { "r14", 14 },                              \
707     { "r15", 15 } }
708
709 #define PRINT_OPERAND(STREAM, X, CODE) xstormy16_print_operand (STREAM, X, CODE)
710
711 #define PRINT_OPERAND_ADDRESS(STREAM, X) xstormy16_print_operand_address (STREAM, X)
712
713 /* USER_LABEL_PREFIX is defined in svr4.h.  */
714 #define REGISTER_PREFIX ""
715 #define LOCAL_LABEL_PREFIX "."
716 #define USER_LABEL_PREFIX ""
717 #define IMMEDIATE_PREFIX "#"
718
719 #define ASM_OUTPUT_REG_PUSH(STREAM, REGNO) \
720   fprintf (STREAM, "\tpush %d\n", REGNO)
721
722 #define ASM_OUTPUT_REG_POP(STREAM, REGNO) \
723   fprintf (STREAM, "\tpop %d\n", REGNO)
724
725 \f
726 /* Output of dispatch tables.  */
727
728 /* This port does not use the ASM_OUTPUT_ADDR_VEC_ELT macro, because
729    this could cause label alignment to appear between the 'br' and the table,
730    which would be bad.  Instead, it controls the output of the table
731    itself.  */
732 #define ASM_OUTPUT_ADDR_VEC(LABEL, BODY) \
733   xstormy16_output_addr_vec (file, LABEL, BODY)
734
735 /* Alignment for ADDR_VECs is the same as for code.  */
736 #define ADDR_VEC_ALIGN(ADDR_VEC) 1
737
738 \f
739 /* Assembler Commands for Exception Regions.  */
740
741 #define DWARF2_UNWIND_INFO 0
742
743 /* Don't use __builtin_setjmp for unwinding, since it's tricky to get
744    at the high 16 bits of an address.  */
745 #define DONT_USE_BUILTIN_SETJMP
746 #define JMP_BUF_SIZE  8
747 \f
748 /* Assembler Commands for Alignment.  */
749
750 #define ASM_OUTPUT_ALIGN(STREAM, POWER) \
751   fprintf ((STREAM), "\t.p2align %d\n", (POWER))
752
753 \f
754 /* Macros Affecting all Debug Formats.  */
755
756 /* Defined in svr4.h.  */
757 #undef PREFERRED_DEBUGGING_TYPE
758 #define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG
759
760 \f
761 /* Macros for SDB and Dwarf Output.  */
762
763 /* Define this macro if addresses in Dwarf 2 debugging info should not
764    be the same size as pointers on the target architecture.  The
765    macro's value should be the size, in bytes, to use for addresses in
766    the debugging info.
767
768    Some architectures use word addresses to refer to code locations,
769    but Dwarf 2 info always uses byte addresses.  On such machines,
770    Dwarf 2 addresses need to be larger than the architecture's
771    pointers.  */
772 #define DWARF2_ADDR_SIZE 4
773
774 \f
775 /* Miscellaneous Parameters.  */
776
777 #define CASE_VECTOR_MODE SImode
778
779 #define WORD_REGISTER_OPERATIONS
780
781 #define LOAD_EXTEND_OP(MODE) ZERO_EXTEND
782
783 #define MOVE_MAX 2
784
785 #define SHIFT_COUNT_TRUNCATED 1
786
787 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
788
789 #define Pmode HImode
790
791 #define FUNCTION_MODE HImode
792
793 #define NO_IMPLICIT_EXTERN_C
794
795 /* Defined in svr4.h.  */
796 #define HANDLE_SYSV_PRAGMA 1
797
798 /* Define this if the target system supports the function `atexit' from the
799    ANSI C standard.  If this is not defined, and `INIT_SECTION_ASM_OP' is not
800    defined, a default `exit' function will be provided to support C++.
801
802    Defined by svr4.h */
803 /* #define HAVE_ATEXIT */
804
805 /* A C statement which is executed by the Haifa scheduler after it has scheduled
806    an insn from the ready list.  FILE is either a null pointer, or a stdio stream
807    to write any debug output to.  VERBOSE is the verbose level provided by
808    -fsched-verbose-<n>.  INSN is the instruction that was scheduled.  MORE is the
809    number of instructions that can be issued in the current cycle.  This macro
810    is responsible for updating the value of MORE (typically by (MORE)--).  */
811 /* #define MD_SCHED_VARIABLE_ISSUE (FILE, VERBOSE, INSN, MORE) */
812
813 \f
814 /* Define the information needed to generate branch and scc insns.  This is
815    stored from the compare operation.  Note that we can't use "rtx" here
816    since it hasn't been defined!  */
817
818 extern struct rtx_def *xstormy16_compare_op0, *xstormy16_compare_op1;
819
820 /* End of xstormy16.h */