OSDN Git Service

0a24a3f85e9fc6709c0482a95f28e4de3555823d
[pf3gnuchains/gcc-fork.git] / gcc / config / score / score.h
1 /* score.h for Sunplus S+CORE processor
2    Copyright (C) 2005 Free Software Foundation, Inc.
3    Contributed by Sunnorth.
4
5    This file is part of GCC.
6
7    GCC is free software; you can redistribute it and/or modify it
8    under the terms of the GNU General Public License as published
9    by the Free Software Foundation; either version 2, or (at your
10    option) any later version.
11
12    GCC is distributed in the hope that it will be useful, but WITHOUT
13    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
15    License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with GCC; see the file COPYING.  If not, write to
19    the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20    Boston, MA 02110-1301, USA.  */
21
22 #include "score-conv.h"
23 #include "score-version.h"
24
25 /* Define the information needed to generate branch insns.  This is
26    stored from the compare operation.  */
27 extern GTY(()) rtx cmp_op0;
28 extern GTY(()) rtx cmp_op1;
29
30 /* Controlling the Compilation Driver.  */
31 #define SWITCH_TAKES_ARG(CHAR) \
32   (DEFAULT_SWITCH_TAKES_ARG (CHAR) || (CHAR) == 'G')
33
34 /* CC1_SPEC is the set of arguments to pass to the compiler proper.  */
35 #undef CC1_SPEC
36 #define CC1_SPEC                 "%{!mel:-meb}"
37
38 #undef ASM_SPEC
39 #define ASM_SPEC \
40   "%{!mel:-EB} %{mel:-EL} %{mSCORE5U:-SCORE5U} %{mSCORE7:-SCORE7} %{G*}"
41
42 #undef LINK_SPEC
43 #define LINK_SPEC                 "%{!mel:-EB} %{mel:-EL} %{G*}"
44
45 /* Run-time Target Specification.  */
46 #define TARGET_CPU_CPP_BUILTINS()               \
47   do {                                          \
48     builtin_define ("SUNPLUS");                 \
49     builtin_define ("__SCORE__");               \
50     builtin_define ("__score__");               \
51     if (TARGET_LITTLE_ENDIAN)                   \
52       builtin_define ("__scorele__");           \
53     else                                        \
54       builtin_define ("__scorebe__");           \
55     if (TARGET_SCORE5U)                         \
56       builtin_define ("__score5u__");           \
57   } while (0)
58
59
60 #define TARGET_DEFAULT         MASK_SCORE7
61
62 #define TARGET_VERSION \
63   fprintf (stderr, "Sunplus S+CORE %s", SCORE_GCC_VERSION);
64
65 #define OVERRIDE_OPTIONS       score_override_options ()
66
67 /* Show we can debug even without a frame pointer.  */
68 #define CAN_DEBUG_WITHOUT_FP
69
70 /* Target machine storage layout.  */
71 #define BITS_BIG_ENDIAN        0
72 #define BYTES_BIG_ENDIAN       (TARGET_LITTLE_ENDIAN == 0)
73 #define WORDS_BIG_ENDIAN       (TARGET_LITTLE_ENDIAN == 0)
74
75 /* Define this to set the endianness to use in libgcc2.c, which can
76    not depend on target_flags.  */
77 #if defined(__scorele__)
78 #define LIBGCC2_WORDS_BIG_ENDIAN       0
79 #else
80 #define LIBGCC2_WORDS_BIG_ENDIAN       1
81 #endif
82
83 /* Width of a word, in units (bytes).  */
84 #define UNITS_PER_WORD                 4
85
86 /* Define this macro if it is advisable to hold scalars in registers
87    in a wider mode than that declared by the program.  In such cases,
88    the value is constrained to be within the bounds of the declared
89    type, but kept valid in the wider mode.  The signedness of the
90    extension may differ from that of the type.  */
91 #define PROMOTE_MODE(MODE, UNSIGNEDP, TYPE)     \
92   if (GET_MODE_CLASS (MODE) == MODE_INT         \
93       && GET_MODE_SIZE (MODE) < UNITS_PER_WORD) \
94     (MODE) = SImode;
95
96 /* Allocation boundary (in *bits*) for storing arguments in argument list.  */
97 #define PARM_BOUNDARY                  BITS_PER_WORD
98 #define STACK_BOUNDARY                 64
99
100 /* Allocation boundary (in *bits*) for the code of a function.  */
101 #define FUNCTION_BOUNDARY              BITS_PER_WORD
102
103 /* There is no point aligning anything to a rounder boundary than this.  */
104 #define BIGGEST_ALIGNMENT              LONG_DOUBLE_TYPE_SIZE
105
106 /* If defined, a C expression to compute the alignment for a static
107    variable.  TYPE is the data type, and ALIGN is the alignment that
108    the object would ordinarily have.  The value of this macro is used
109    instead of that alignment to align the object.
110
111    If this macro is not defined, then ALIGN is used.
112
113    One use of this macro is to increase alignment of medium-size
114    data to make it all fit in fewer cache lines.  Another is to
115    cause character arrays to be word-aligned so that `strcpy' calls
116    that copy constants to character arrays can be done inline.  */
117 #define DATA_ALIGNMENT(TYPE, ALIGN)                                     \
118   ((((ALIGN) < BITS_PER_WORD)                                           \
119     && (TREE_CODE (TYPE) == ARRAY_TYPE                                  \
120         || TREE_CODE (TYPE) == UNION_TYPE                               \
121         || TREE_CODE (TYPE) == RECORD_TYPE)) ? BITS_PER_WORD : (ALIGN))
122
123 /* Alignment of field after `int : 0' in a structure.  */
124 #define EMPTY_FIELD_BOUNDARY           32
125
126 /* All accesses must be aligned.  */
127 #define STRICT_ALIGNMENT               1
128
129 /* Score requires that structure alignment is affected by bitfields.  */
130 #define PCC_BITFIELD_TYPE_MATTERS      1
131
132 /* long double is not a fixed mode, but the idea is that, if we
133    support long double, we also want a 128-bit integer type.  */
134 #define MAX_FIXED_MODE_SIZE            LONG_DOUBLE_TYPE_SIZE
135
136 #define TARGET_FLOAT_FORMAT            IEEE_FLOAT_FORMAT
137
138 /* Layout of Data Type.  */
139 /* Set the sizes of the core types.  */
140 #define INT_TYPE_SIZE                   32
141 #define SHORT_TYPE_SIZE                 16
142 #define LONG_TYPE_SIZE                  32
143 #define LONG_LONG_TYPE_SIZE             64
144 #define CHAR_TYPE_SIZE                  8
145 #define FLOAT_TYPE_SIZE                 32
146 #define DOUBLE_TYPE_SIZE                64
147 #define LONG_DOUBLE_TYPE_SIZE           64
148
149 /* Define this as 1 if `char' should by default be signed; else as 0.  */
150 #undef DEFAULT_SIGNED_CHAR
151 #define DEFAULT_SIGNED_CHAR             1
152
153 /* Default definitions for size_t and ptrdiff_t.  */
154 #define SIZE_TYPE                       "unsigned int"
155
156 /* Register Usage
157
158    S+core have:
159    - 32 integer registers
160    - 16 control registers (cond)
161    - 16 special registers (ceh/cel/cnt/lcr/scr/arg/fp)
162    - 32 coprocessors 1 registers
163    - 32 coprocessors 2 registers
164    - 32 coprocessors 3 registers.  */
165 #define FIRST_PSEUDO_REGISTER           160
166
167 /* By default, fix the kernel registers (r30 and r31), the global
168    pointer (r28) and the stack pointer (r0).  This can change
169    depending on the command-line options.
170
171    Regarding coprocessor registers: without evidence to the contrary,
172    it's best to assume that each coprocessor register has a unique
173    use.  This can be overridden, in, e.g., override_options() or
174    CONDITIONAL_REGISTER_USAGE should the assumption be inappropriate
175    for a particular target.  */
176
177 /* Control Registers, use mfcr/mtcr insn
178     32        cr0         PSR
179     33        cr1         Condition
180     34        cr2         ECR
181     35        cr3         EXCPVec
182     36        cr4         CCR
183     37        cr5         EPC
184     38        cr6         EMA
185     39        cr7         TLBLock
186     40        cr8         TLBPT
187     41        cr8         PEADDR
188     42        cr10        TLBRPT
189     43        cr11        PEVN
190     44        cr12        PECTX
191     45        cr13
192     46        cr14
193     47        cr15
194
195     Custom Engine Register, use mfce/mtce
196     48        CEH        CEH
197     49        CEL        CEL
198
199     Special-Purpose Register, use mfsr/mtsr
200     50        sr0        CNT
201     51        sr1        LCR
202     52        sr2        SCR
203
204     53        ARG_POINTER_REGNUM
205     54        FRAME_POINTER_REGNUM
206     but Control register have 32 registers, cr16-cr31.  */
207 #define FIXED_REGISTERS                                  \
208 {                                                        \
209   /* General Purpose Registers */                        \
210   1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        \
211   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1,        \
212   /* Control Registers */                                \
213   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
214   /* CEH/ CEL/ CNT/ LCR/ SCR / ARG_POINTER_REGNUM/ FRAME_POINTER_REGNUM */\
215   0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
216   /* CP 1 Registers  */                                  \
217   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
218   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
219   /* CP 2 Registers  */                                  \
220   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
221   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
222   /* CP 3 Registers*/                                    \
223   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
224   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
225 }
226
227 #define CALL_USED_REGISTERS                              \
228 {                                                        \
229   /* General purpose register */                         \
230   1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,        \
231   0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
232   /* Control Registers */                                \
233   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
234   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
235   /* CP 1 Registers  */                                  \
236   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
237   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
238   /* CP 2 Registers  */                                  \
239   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
240   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
241   /* CP 3 Registers  */                                  \
242   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
243   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
244 }
245
246 #define REG_ALLOC_ORDER                                                   \
247 {   0,  1,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,        \
248    18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,  2,  3,        \
249    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,        \
250    48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,        \
251    64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,        \
252    80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,        \
253    96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,        \
254   112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,        \
255   128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,        \
256   144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159        }
257
258 #define HARD_REGNO_NREGS(REGNO, MODE) \
259   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
260
261 /* Return true if REGNO is suitable for holding a quantity of type MODE.  */
262 #define HARD_REGNO_MODE_OK(REGNO, MODE) score_hard_regno_mode_ok (REGNO, MODE)
263
264 /* Value is 1 if it is a good idea to tie two pseudo registers
265    when one has mode MODE1 and one has mode MODE2.
266    If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2,
267    for any hard reg, then this must be 0 for correct output.  */
268 #define MODES_TIEABLE_P(MODE1, MODE2)                             \
269   ((GET_MODE_CLASS (MODE1) == MODE_FLOAT                          \
270     || GET_MODE_CLASS (MODE1) == MODE_COMPLEX_FLOAT)              \
271    == (GET_MODE_CLASS (MODE2) == MODE_FLOAT                       \
272        || GET_MODE_CLASS (MODE2) == MODE_COMPLEX_FLOAT))
273
274 /* Register Classes.  */
275 /* Define the classes of registers for register constraints in the
276    machine description.  Also define ranges of constants.  */
277 enum reg_class
278 {
279   NO_REGS,
280   G16_REGS,    /* r0 ~ r15 */
281   G32_REGS,    /* r0 ~ r31 */
282   T32_REGS,    /* r8 ~ r11 | r22 ~ r27 */
283
284   HI_REG,      /* hi                 */
285   LO_REG,      /* lo                 */
286   CE_REGS,     /* hi + lo            */
287
288   CN_REG,      /* cnt                */
289   LC_REG,      /* lcb                */
290   SC_REG,      /* scb                */
291   SP_REGS,     /* cnt + lcb + scb    */
292
293   CR_REGS,     /* cr0 - cr15         */
294
295   CP1_REGS,    /* cp1                */
296   CP2_REGS,    /* cp2                */
297   CP3_REGS,    /* cp3                */
298   CPA_REGS,    /* cp1 + cp2 + cp3    */
299
300   ALL_REGS,
301   LIM_REG_CLASSES
302 };
303
304 #define N_REG_CLASSES                  ((int) LIM_REG_CLASSES)
305
306 #define GENERAL_REGS                   G32_REGS
307
308 /* Give names of register classes as strings for dump file.  */
309 #define REG_CLASS_NAMES           \
310 {                                 \
311   "NO_REGS",                      \
312   "G16_REGS",                     \
313   "G32_REGS",                     \
314   "T32_REGS",                     \
315                                   \
316   "HI_REG",                       \
317   "LO_REG",                       \
318   "CE_REGS",                      \
319                                   \
320   "CN_REG",                       \
321   "LC_REG",                       \
322   "SC_REG",                       \
323   "SP_REGS",                      \
324                                   \
325   "CR_REGS",                      \
326                                   \
327   "CP1_REGS",                     \
328   "CP2_REGS",                     \
329   "CP3_REGS",                     \
330   "CPA_REGS",                     \
331                                   \
332   "ALL_REGS",                     \
333 }
334
335 /* Define which registers fit in which classes.  */
336 #define REG_CLASS_CONTENTS                                        \
337 {                                                                 \
338   /* NO_REGS/G16/G32/T32  */                                      \
339   { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000},  \
340   { 0x0000ffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000},  \
341   { 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000},  \
342   { 0x0fc00f00, 0x00000000, 0x00000000, 0x00000000, 0x00000000},  \
343   /* HI/LO/CE  */                                                 \
344   { 0x00000000, 0x00010000, 0x00000000, 0x00000000, 0x00000000},  \
345   { 0x00000000, 0x00020000, 0x00000000, 0x00000000, 0x00000000},  \
346   { 0x00000000, 0x00030000, 0x00000000, 0x00000000, 0x00000000},  \
347   /* CN/LC/SC/SP/CR  */                                           \
348   { 0x00000000, 0x00040000, 0x00000000, 0x00000000, 0x00000000},  \
349   { 0x00000000, 0x00080000, 0x00000000, 0x00000000, 0x00000000},  \
350   { 0x00000000, 0x00100000, 0x00000000, 0x00000000, 0x00000000},  \
351   { 0x00000000, 0x001c0000, 0x00000000, 0x00000000, 0x00000000},  \
352   { 0x00000000, 0x0000ffff, 0x00000000, 0x00000000, 0x00000000},  \
353   /* CP1/CP2/CP3/CPA  */                                          \
354   { 0x00000000, 0x00000000, 0xffffffff, 0x00000000, 0x00000000},  \
355   { 0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0x00000000},  \
356   { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff},  \
357   { 0x00000000, 0x00000000, 0xffffffff, 0xffffffff, 0xffffffff},  \
358   /* ALL_REGS        */                                           \
359   { 0xffffffff, 0x001fffff, 0xffffffff, 0xffffffff, 0xffffffff},  \
360 }
361
362 /* A C expression whose value is a register class containing hard
363    register REGNO.  In general there is more that one such class;
364    choose a class which is "minimal", meaning that no smaller class
365    also contains the register.  */
366 #define REGNO_REG_CLASS(REGNO)         score_reg_class (REGNO)
367
368 /* A macro whose definition is the name of the class to which a
369    valid base register must belong.  A base register is one used in
370    an address which is the register value plus a displacement.  */
371 #define BASE_REG_CLASS                 G16_REGS
372
373 /* The class value for index registers.  */
374 #define INDEX_REG_CLASS                NO_REGS
375
376 #define REG_CLASS_FROM_LETTER(C)       score_char_to_class[(unsigned char) (C)]
377
378 /* Addressing modes, and classification of registers for them.  */
379 #define REGNO_MODE_OK_FOR_BASE_P(REGNO, MODE) \
380   score_regno_mode_ok_for_base_p (REGNO, 1)
381
382 #define REGNO_OK_FOR_INDEX_P(NUM)       0
383
384 #define PREFERRED_RELOAD_CLASS(X, CLASS) \
385   score_preferred_reload_class (X, CLASS)
386
387 /* If we need to load shorts byte-at-a-time, then we need a scratch.  */
388 #define SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, X)        \
389   score_secondary_reload_class (CLASS, MODE, X)
390
391 /* Return the register class of a scratch register needed to copy IN into
392    or out of a register in CLASS in MODE.  If it can be done directly,
393    NO_REGS is returned.  */
394 #define SECONDARY_OUTPUT_RELOAD_CLASS(CLASS, MODE, X)       \
395   score_secondary_reload_class (CLASS, MODE, X)
396
397 /* Return the maximum number of consecutive registers
398    needed to represent mode MODE in a register of class CLASS.  */
399 #define CLASS_MAX_NREGS(CLASS, MODE)    \
400   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
401
402 #define CANNOT_CHANGE_MODE_CLASS(FROM, TO, CLASS)    \
403   (GET_MODE_SIZE (FROM) != GET_MODE_SIZE (TO)        \
404    ? reg_classes_intersect_p (HI_REG, (CLASS)) : 0)
405
406 /* The letters I, J, K, L, M, N, O, and P in a register constraint
407    string can be used to stand for particular ranges of immediate
408    operands.  This macro defines what the ranges are.  C is the
409    letter, and VALUE is a constant value.  Return 1 if VALUE is
410    in the range specified by C.  */
411 #define CONST_OK_FOR_LETTER_P(VALUE, C) score_const_ok_for_letter_p (VALUE, C)
412
413 /* Similar, but for floating constants, and defining letters G and H.
414    Here VALUE is the CONST_DOUBLE rtx itself.  */
415
416 #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C)        \
417   ((C) == 'G' && (VALUE) == CONST0_RTX (GET_MODE (VALUE)))
418
419 /* Letters in the range `Q' through `U' may be defined in a
420    machine-dependent fashion to stand for arbitrary operand types.
421    The machine description macro `EXTRA_CONSTRAINT' is passed the
422    operand as its first argument and the constraint letter as its
423    second operand.  */
424 #define EXTRA_CONSTRAINT(VALUE, C)      score_extra_constraint (VALUE, C)
425
426 /* Basic Stack Layout.  */
427 /* Stack layout; function entry, exit and calling.  */
428 #define STACK_GROWS_DOWNWARD
429
430 #define STACK_PUSH_CODE                 PRE_DEC
431 #define STACK_POP_CODE                  POST_INC
432
433 /* The offset of the first local variable from the beginning of the frame.
434    See compute_frame_size for details about the frame layout.  */
435 #define STARTING_FRAME_OFFSET           current_function_outgoing_args_size
436
437 /* The argument pointer always points to the first argument.  */
438 #define FIRST_PARM_OFFSET(FUNDECL)      0
439
440 /* A C expression whose value is RTL representing the value of the return
441    address for the frame COUNT steps up from the current frame.  */
442 #define RETURN_ADDR_RTX(count, frame)   score_return_addr (count, frame)
443
444 /* Pick up the return address upon entry to a procedure.  */
445 #define INCOMING_RETURN_ADDR_RTX        gen_rtx_REG (VOIDmode, RA_REGNUM)
446
447 /* Exception handling Support.  */
448 /* Use r0 to r3 to pass exception handling information.  */
449 #define EH_RETURN_DATA_REGNO(N) \
450   ((N) < 4 ? (N) + ARG_REG_FIRST : INVALID_REGNUM)
451
452 /* The register that holds the return address in exception handlers.  */
453 #define EH_RETURN_STACKADJ_RTX          gen_rtx_REG (Pmode, EH_REGNUM)
454
455 /* Registers That Address the Stack Frame.  */
456 /* Register to use for pushing function arguments.  */
457 #define STACK_POINTER_REGNUM            SP_REGNUM
458
459 /* These two registers don't really exist: they get eliminated to either
460    the stack or hard frame pointer.  */
461 #define FRAME_POINTER_REGNUM            53
462
463 /*  we use r2 as the frame pointer.  */
464 #define HARD_FRAME_POINTER_REGNUM       FP_REGNUM
465
466 #define ARG_POINTER_REGNUM              54
467
468 /* Register in which static-chain is passed to a function.  */
469 #define STATIC_CHAIN_REGNUM             23
470
471 /* Elimination Frame Pointer and Arg Pointer  */
472 /* Value should be nonzero if functions must have frame pointers.
473    Zero means the frame pointer need not be set up (and parms
474    may be accessed via the stack pointer) in functions that seem suitable.
475    This is computed in `reload', in reload1.c.  */
476 #define FRAME_POINTER_REQUIRED          current_function_calls_alloca
477
478 #define ELIMINABLE_REGS                                \
479   {{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM},        \
480    { ARG_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM},   \
481    { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM},      \
482    { FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}}
483
484 /* We can always eliminate to the hard frame pointer.  We can eliminate
485    to the stack pointer unless a frame pointer is needed.  */
486 #define CAN_ELIMINATE(FROM, TO)        \
487   (((TO) == HARD_FRAME_POINTER_REGNUM) \
488    || ((TO) == STACK_POINTER_REGNUM    \
489        && !frame_pointer_needed))
490
491 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
492   (OFFSET) = score_initial_elimination_offset ((FROM), (TO))
493
494 /* Passing Function Arguments on the Stack.  */
495 /* Allocate stack space for arguments at the beginning of each function.  */
496 #define ACCUMULATE_OUTGOING_ARGS        1
497
498 /* reserve stack space for all argument registers.  */
499 #define REG_PARM_STACK_SPACE(FNDECL)    UNITS_PER_WORD
500
501 /* Define this if it is the responsibility of the caller to
502    allocate the area reserved for arguments passed in registers.
503    If `ACCUMULATE_OUTGOING_ARGS' is also defined, the only effect
504    of this macro is to determine whether the space is included in
505    `current_function_outgoing_args_size'.  */
506 #define OUTGOING_REG_PARM_STACK_SPACE
507
508 #define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACK_SIZE) 0
509
510 /* Passing Arguments in Registers  */
511 /* Determine where to put an argument to a function.
512    Value is zero to push the argument on the stack,
513    or a hard register in which to store the argument.
514
515    MODE is the argument's machine mode.
516    TYPE is the data type of the argument (as a tree).
517     This is null for libcalls where that information may
518     not be available.
519    CUM is a variable of type CUMULATIVE_ARGS which gives info about
520     the preceding args and about the function being called.
521    NAMED is nonzero if this argument is a named parameter
522     (otherwise it is an extra parameter matching an ellipsis).  */
523 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
524   score_function_arg (&CUM, MODE, TYPE, NAMED)
525
526 /* A C type for declaring a variable that is used as the first argument of
527    `FUNCTION_ARG' and other related values.  For some target machines, the
528    type `int' suffices and can hold the number of bytes of argument so far.  */
529 typedef struct score_args
530 {
531   unsigned int arg_number;             /* how many arguments have been seen  */
532   unsigned int num_gprs;               /* number of gprs in use  */
533   unsigned int stack_words;            /* number of words in stack  */
534 } score_args_t;
535
536 #define CUMULATIVE_ARGS                score_args_t
537
538 /* Initialize a variable CUM of type CUMULATIVE_ARGS
539    for a call to a function whose data type is FNTYPE.
540    For a library call, FNTYPE is 0.  */
541 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT, n_named_args) \
542   score_init_cumulative_args (&CUM, FNTYPE, LIBNAME)
543
544 /* Update the data in CUM to advance over an argument
545    of mode MODE and data type TYPE.
546    (TYPE is null for libcalls where that information may not be available.)  */
547 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \
548   score_function_arg_advance (&CUM, MODE, TYPE, NAMED)
549
550 /* 1 if N is a possible register number for function argument passing.
551    We have no FP argument registers when soft-float.  When FP registers
552    are 32 bits, we can't directly reference the odd numbered ones.  */
553 #define FUNCTION_ARG_REGNO_P(REGNO) \
554   REG_CONTAIN (REGNO, ARG_REG_FIRST, ARG_REG_NUM)
555
556 /* How Scalar Function Values Are Returned.  */
557 #define FUNCTION_VALUE(VALTYPE, FUNC) \
558   score_function_value ((VALTYPE), (FUNC), VOIDmode)
559
560 #define LIBCALL_VALUE(MODE)  score_function_value (NULL_TREE, NULL, (MODE))
561
562 /* 1 if N is a possible register number for a function value.  */
563 #define FUNCTION_VALUE_REGNO_P(REGNO)   ((REGNO) == (ARG_REG_FIRST))
564
565 #define PIC_FUNCTION_ADDR_REGNUM        (GP_REG_FIRST + 25)
566
567 /* How Large Values Are Returned.  */
568 #define STRUCT_VALUE                    0
569
570 /* Function Entry and Exit  */
571 /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
572    the stack pointer does not matter.  The value is tested only in
573    functions that have frame pointers.
574    No definition is equivalent to always zero.  */
575 #define EXIT_IGNORE_STACK               1
576
577 /* Generating Code for Profiling  */
578 /* Output assembler code to FILE to increment profiler label # LABELNO
579    for profiling a function entry.  */
580 #define FUNCTION_PROFILER(FILE, LABELNO)                           \
581 {                                                                  \
582   fprintf (FILE, " .set r1  \n");                                  \
583   fprintf (FILE, " mv   r%d,r%d \n", AT_REGNUM, RA_REGNUM);        \
584   fprintf (FILE, " subi r%d, %d \n", STACK_POINTER_REGNUM, 8);     \
585   fprintf (FILE, " jl   _mcount \n");                              \
586   fprintf (FILE, " .set nor1 \n");                                 \
587 }
588
589 /* Trampolines for Nested Functions.  */
590 #define TRAMPOLINE_INSNS                8
591
592 /* A C expression for the size in bytes of the trampoline, as an integer.  */
593 #define TRAMPOLINE_SIZE \
594   (TRAMPOLINE_INSNS * GET_MODE_SIZE (SImode) + GET_MODE_SIZE (ptr_mode) * 2)
595
596 /* A C statement to initialize the variable parts of a trampoline.
597    ADDR is an RTX for the address of the trampoline; FNADDR is an
598    RTX for the address of the nested function; STATIC_CHAIN is an
599    RTX for the static chain value that should be passed to the
600    function when it is called.  */
601
602 #define INITIALIZE_TRAMPOLINE(ADDR, FUNC, CHAIN) \
603   score_initialize_trampoline (ADDR, FUNC, CHAIN)
604
605 #define HAVE_PRE_INCREMENT              1
606 #define HAVE_PRE_DECREMENT              1
607 #define HAVE_POST_INCREMENT             1
608 #define HAVE_POST_DECREMENT             1
609 #define HAVE_PRE_MODIFY_DISP            0
610 #define HAVE_POST_MODIFY_DISP           0
611 #define HAVE_PRE_MODIFY_REG             0
612 #define HAVE_POST_MODIFY_REG            0
613
614 /* Recognize any constant value that is a valid address.  */
615 #define CONSTANT_ADDRESS_P(X)           CONSTANT_P (X)
616
617 /* Maximum number of registers that can appear in a valid memory address.  */
618 #define MAX_REGS_PER_ADDRESS            1
619
620 #ifdef REG_OK_STRICT
621 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL)   \
622   if (score_address_p (MODE, X, 1))                \
623     goto LABEL;
624 #else
625 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL)   \
626   if (score_address_p (MODE, X, 0))                \
627     goto LABEL;
628 #endif
629
630 /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
631    and check its validity for a certain class.
632    We have two alternate definitions for each of them.
633    The usual definition accepts all pseudo regs; the other rejects them all.
634    The symbol REG_OK_STRICT causes the latter definition to be used.
635
636    Most source files want to accept pseudo regs in the hope that
637    they will get allocated to the class that the insn wants them to be in.
638    Some source files that are used after register allocation
639    need to be strict.  */
640 #ifndef REG_OK_STRICT
641 #define REG_MODE_OK_FOR_BASE_P(X, MODE) \
642   score_regno_mode_ok_for_base_p (REGNO (X), 0)
643 #else
644 #define REG_MODE_OK_FOR_BASE_P(X, MODE) \
645   score_regno_mode_ok_for_base_p (REGNO (X), 1)
646 #endif
647
648 #define REG_OK_FOR_INDEX_P(X) 0
649
650 #define LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN)   \
651   do {                                           \
652     if (score_legitimize_address (&(X)))         \
653       goto WIN;                                  \
654   } while (0)
655
656 /* Go to LABEL if ADDR (a legitimate address expression)
657    has an effect that depends on the machine mode it is used for.  */
658 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR, LABEL)       {}
659
660 #define LEGITIMATE_CONSTANT_P(X)        1
661
662 /* Describing Relative Costs of Operations  */
663 /* Compute extra cost of moving data between one register class and another.  */
664 #define REGISTER_MOVE_COST(MODE, FROM, TO) \
665   score_register_move_cost (MODE, FROM, TO)
666
667 /* Moves to and from memory are quite expensive */
668 #define MEMORY_MOVE_COST(MODE, CLASS, TO_P) \
669   (4 + memory_move_secondary_cost ((MODE), (CLASS), (TO_P)))
670
671 /* Try to generate sequences that don't involve branches.  */
672 #define BRANCH_COST                     2
673
674 /* Nonzero if access to memory by bytes is slow and undesirable.  */
675 #define SLOW_BYTE_ACCESS                1
676
677 /* Define this macro if it is as good or better to call a constant
678    function address than to call an address kept in a register.  */
679 #define NO_FUNCTION_CSE                 1
680
681 /* Dividing the Output into Sections (Texts, Data, ...).  */
682 /* Define the strings to put out for each section in the object file.  */
683 #define TEXT_SECTION_ASM_OP             "\t.text"
684 #define DATA_SECTION_ASM_OP             "\t.data"
685 #define SDATA_SECTION_ASM_OP            "\t.sdata"
686
687 #undef  READONLY_DATA_SECTION_ASM_OP
688 #define READONLY_DATA_SECTION_ASM_OP    "\t.rdata"
689
690 /* The Overall Framework of an Assembler File  */
691 /* How to start an assembler comment.
692    The leading space is important.  */
693 #define ASM_COMMENT_START               "#"
694
695 /* Output to assembler file text saying following lines
696    may contain character constants, extra white space, comments, etc.  */
697 #define ASM_APP_ON                     "#APP\n\t.set volatile\n"
698
699 /* Output to assembler file text saying following lines
700    no longer contain unusual constructs.  */
701 #define ASM_APP_OFF                     "#NO_APP\n\t.set optimize\n"
702
703 /* Output of Uninitialized Variables.  */
704 /* This says how to define a global common symbol.  */
705 #define ASM_OUTPUT_ALIGNED_DECL_COMMON(STREAM, DECL, NAME, SIZE, ALIGN)     \
706   score_declare_object (STREAM, NAME, "\n\t.comm\t",                        \
707                         ","HOST_WIDE_INT_PRINT_UNSIGNED",%u\n",             \
708                         SIZE, ALIGN / BITS_PER_UNIT);
709
710 /* This says how to define a local common symbol (i.e., not visible to
711    linker).  */
712 #undef ASM_OUTPUT_ALIGNED_LOCAL
713 #define ASM_OUTPUT_ALIGNED_LOCAL(STREAM, NAME, SIZE, ALIGN)            \
714   score_declare_object (STREAM, NAME, "\n\t.lcomm\t",                  \
715                         ","HOST_WIDE_INT_PRINT_UNSIGNED",%u\n",        \
716                         SIZE, ALIGN / BITS_PER_UNIT);
717
718 /* Globalizing directive for a label.  */
719 #define GLOBAL_ASM_OP                   "\t.globl\t"
720
721 /* Output and Generation of Labels  */
722 /* This is how to declare a function name.  The actual work of
723    emitting the label is moved to function_prologue, so that we can
724    get the line number correctly emitted before the .ent directive,
725    and after any .file directives.  Define as empty so that the function
726    is not declared before the .ent directive elsewhere.  */
727 #undef ASM_DECLARE_FUNCTION_NAME
728 #define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL)
729
730 #undef ASM_DECLARE_OBJECT_NAME
731 #define ASM_DECLARE_OBJECT_NAME(STREAM, NAME, DECL) \
732   score_declare_object (STREAM, NAME, "", ":\n", 0)
733
734 /* This says how to output an external.  It would be possible not to
735    output anything and let undefined symbol become external. However
736    the assembler uses length information on externals to allocate in
737    data/sdata bss/sbss, thereby saving exec time.  */
738 #define ASM_OUTPUT_EXTERNAL(STREAM, DECL, NAME) \
739   score_output_external (STREAM, DECL, NAME)
740
741 /* This handles the magic '..CURRENT_FUNCTION' symbol, which means
742    'the start of the function that this code is output in'.  */
743 #define ASM_OUTPUT_LABELREF(STREAM, NAME) \
744   fprintf ((STREAM), "%s", (NAME))
745
746 /* Local compiler-generated symbols must have a prefix that the assembler
747    understands.  */
748 #define LOCAL_LABEL_PREFIX              "."
749
750 #undef ASM_GENERATE_INTERNAL_LABEL
751 #define ASM_GENERATE_INTERNAL_LABEL(LABEL, PREFIX, NUM) \
752   sprintf ((LABEL), "*%s%s%ld", (LOCAL_LABEL_PREFIX), (PREFIX), (long) (NUM))
753
754 /* Output of Assembler Instructions.  */
755 #define REGISTER_NAMES                                                   \
756 { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",                        \
757   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",                  \
758   "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",                \
759   "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",                \
760                                                                          \
761   "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",                \
762   "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",          \
763                                                                          \
764   "ceh", "cel", "sr0", "sr1", "sr2", "_arg", "_frame", "",               \
765   "cr24", "cr25", "cr26", "cr27", "cr28", "cr29", "cr30", "cr31",        \
766                                                                          \
767   "c1r0", "c1r1", "c1r2", "c1r3", "c1r4", "c1r5", "c1r6", "c1r7",        \
768   "c1r8", "c1r9", "c1r10", "c1r11", "c1r12", "c1r13", "c1r14", "c1r15",  \
769   "c1r16", "c1r17", "c1r18", "c1r19", "c1r20", "c1r21", "c1r22", "c1r23",\
770   "c1r24", "c1r25", "c1r26", "c1r27", "c1r28", "c1r29", "c1r30", "c1r31",\
771                                                                          \
772   "c2r0", "c2r1", "c2r2", "c2r3", "c2r4", "c2r5", "c2r6", "c2r7",        \
773   "c2r8", "c2r9", "c2r10", "c2r11", "c2r12", "c2r13", "c2r14", "c2r15",  \
774   "c2r16", "c2r17", "c2r18", "c2r19", "c2r20", "c2r21", "c2r22", "c2r23",\
775   "c2r24", "c2r25", "c2r26", "c2r27", "c2r28", "c2r29", "c2r30", "c2r31",\
776                                                                          \
777   "c3r0", "c3r1", "c3r2", "c3r3", "c3r4", "c3r5", "c3r6", "c3r7",        \
778   "c3r8", "c3r9", "c3r10", "c3r11", "c3r12", "c3r13", "c3r14", "c3r15",  \
779   "c3r16", "c3r17", "c3r18", "c3r19", "c3r20", "c3r21", "c3r22", "c3r23",\
780   "c3r24", "c3r25", "c3r26", "c3r27", "c3r28", "c3r29", "c3r30", "c3r31",\
781 }
782
783 /* Print operand X (an rtx) in assembler syntax to file FILE.  */
784 #define PRINT_OPERAND(STREAM, X, CODE)  score_print_operand (STREAM, X, CODE)
785
786 /* A C expression which evaluates to true if CODE is a valid
787    punctuation character for use in the `PRINT_OPERAND' macro.  */
788 #define PRINT_OPERAND_PUNCT_VALID_P(C)  ((C) == '[' || (C) == ']')
789
790 /* Print a memory address as an operand to reference that memory location.  */
791 #define PRINT_OPERAND_ADDRESS(STREAM, X) \
792   score_print_operand_address (STREAM, X)
793
794 /* By default on the S+core, external symbols do not have an underscore
795    prepended.  */
796 #define USER_LABEL_PREFIX        ""
797
798 /* This is how to output an insn to push a register on the stack.  */
799 #define ASM_OUTPUT_REG_PUSH(STREAM, REGNO)       \
800   do {                                           \
801     fprintf (STREAM, "\tpush! %s,[%s]\n",        \
802              reg_names[REGNO],                   \
803              reg_names[STACK_POINTER_REGNUM]);   \
804   } while (0)
805
806 /* This is how to output an insn to pop a register from the stack.  */
807 #define ASM_OUTPUT_REG_POP(STREAM, REGNO)        \
808   do {                                           \
809     fprintf (STREAM, "\tpop! %s,[%s]\n",         \
810              reg_names[REGNO],                   \
811              reg_names[STACK_POINTER_REGNUM]);   \
812   } while (0)
813
814 /* Output of Dispatch Tables.  */
815 /* This is how to output an element of a case-vector.  We can make the
816    entries PC-relative in GP-relative when .gp(d)word is supported.  */
817 #define ASM_OUTPUT_ADDR_DIFF_ELT(STREAM, BODY, VALUE, REL)              \
818   do {                                                                  \
819     if (flag_pic)                                                       \
820       fprintf (STREAM, "\t.gpword %sL%d\n", LOCAL_LABEL_PREFIX, VALUE); \
821     else                                                                \
822       fprintf (STREAM, "\t.word %sL%d\n", LOCAL_LABEL_PREFIX, VALUE);   \
823   } while (0)
824
825 /* This is how to output an element of a case-vector that is absolute.  */
826 #define ASM_OUTPUT_ADDR_VEC_ELT(STREAM, VALUE) \
827   fprintf (STREAM, "\t.word %sL%d\n", LOCAL_LABEL_PREFIX, VALUE)
828
829 /* Assembler Commands for Exception Regions  */
830 /* Since the S+core is encoded in the least-significant bit
831    of the address, mask it off return addresses for purposes of
832    finding exception handling regions.  */
833 #define MASK_RETURN_ADDR               constm1_rtx
834
835 /* Assembler Commands for Alignment  */
836 /* This is how to output an assembler line to advance the location
837    counter by SIZE bytes.  */
838 #undef ASM_OUTPUT_SKIP
839 #define ASM_OUTPUT_SKIP(STREAM, SIZE) \
840   fprintf (STREAM, "\t.space\t"HOST_WIDE_INT_PRINT_UNSIGNED"\n", (SIZE))
841
842 /* This is how to output an assembler line
843    that says to advance the location counter
844    to a multiple of 2**LOG bytes.  */
845 #define ASM_OUTPUT_ALIGN(STREAM, LOG) \
846   fprintf (STREAM, "\t.align\t%d\n", (LOG))
847
848 /* Macros Affecting All Debugging Formats.  */
849 #ifndef PREFERRED_DEBUGGING_TYPE
850 #define PREFERRED_DEBUGGING_TYPE         DWARF2_DEBUG
851 #endif
852
853 /* Specific Options for DBX Output.  */
854 #define DBX_DEBUGGING_INFO              1
855
856 /* By default, turn on GDB extensions.  */
857 #define DEFAULT_GDB_EXTENSIONS          1
858
859 #define DBX_CONTIN_LENGTH               0
860
861 /* File Names in DBX Format.  */
862 #define DWARF2_DEBUGGING_INFO           1
863
864 /* The DWARF 2 CFA column which tracks the return address.  */
865 #define DWARF_FRAME_RETURN_COLUMN       3
866
867 /* Specify the machine mode that this machine uses
868    for the index in the tablejump instruction.  */
869 #define CASE_VECTOR_MODE                SImode
870
871 /* Define if operations between registers always perform the operation
872    on the full register even if a narrower mode is specified.  */
873 #define WORD_REGISTER_OPERATIONS
874
875 /*  All references are zero extended.  */
876 #define LOAD_EXTEND_OP(MODE)            ZERO_EXTEND
877
878 /* Define if loading short immediate values into registers sign extends.  */
879 #define SHORT_IMMEDIATES_SIGN_EXTEND
880
881 /* Max number of bytes we can move from memory to memory
882    in one reasonably fast instruction.  */
883 #define MOVE_MAX                        4
884
885 /* Define this to be nonzero if shift instructions ignore all but the low-order
886    few bits.  */
887 #define SHIFT_COUNT_TRUNCATED           1
888
889 /* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits
890    is done just by pretending it is already truncated.  */
891 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
892
893 /* Specify the machine mode that pointers have.
894    After generation of rtl, the compiler makes no further distinction
895    between pointers and any other objects of this machine mode.  */
896 #define Pmode                           SImode
897
898 /* Give call MEMs SImode since it is the "most permissive" mode
899    for 32-bit targets.  */
900 #define FUNCTION_MODE                   Pmode
901
902 struct extern_list GTY ((chain_next ("%h.next")))
903 {
904   struct extern_list *next;             /* next external  */
905   const char *name;                     /* name of the external  */
906   int size;                             /* size in bytes  */
907 };
908
909 extern GTY (()) struct extern_list      *extern_head ;