OSDN Git Service

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