OSDN Git Service

gcc/
[pf3gnuchains/gcc-fork.git] / gcc / config / iq2000 / iq2000.h
1 /* Definitions of target machine for GNU compiler.  
2    Vitesse IQ2000 processors
3    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4    Free Software Foundation, Inc.
5
6    This file is part of GCC.
7
8    GCC is free software; you can redistribute it and/or modify it
9    under the terms of the GNU General Public License as published
10    by the Free Software Foundation; either version 3, or (at your
11    option) any later version.
12
13    GCC is distributed in the hope that it will be useful, but WITHOUT
14    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
16    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 /* Driver configuration.  */
23
24 /* The svr4.h LIB_SPEC with -leval and --*group tacked on */
25 #undef  LIB_SPEC
26 #define LIB_SPEC "%{!shared:%{!symbolic:--start-group -lc -leval -lgcc --end-group}}"
27
28 #undef STARTFILE_SPEC
29 #undef ENDFILE_SPEC
30
31 \f
32 /* Run-time target specifications.  */
33
34 #define TARGET_CPU_CPP_BUILTINS()               \
35   do                                            \
36     {                                           \
37       builtin_define ("__iq2000__");            \
38       builtin_assert ("cpu=iq2000");            \
39       builtin_assert ("machine=iq2000");        \
40     }                                           \
41   while (0)
42
43 /* Macros used in the machine description to test the flags.  */
44
45 #define TARGET_STATS            0
46
47 #define TARGET_DEBUG_MODE       0
48 #define TARGET_DEBUG_A_MODE     0
49 #define TARGET_DEBUG_B_MODE     0
50 #define TARGET_DEBUG_C_MODE     0
51 #define TARGET_DEBUG_D_MODE     0
52
53 #ifndef IQ2000_ISA_DEFAULT
54 #define IQ2000_ISA_DEFAULT 1
55 #endif
56
57 #define IQ2000_VERSION "[1.0]"
58
59 #ifndef MACHINE_TYPE
60 #define MACHINE_TYPE "IQ2000"
61 #endif
62
63 #ifndef TARGET_VERSION_INTERNAL
64 #define TARGET_VERSION_INTERNAL(STREAM)                                 \
65   fprintf (STREAM, " %s %s", IQ2000_VERSION, MACHINE_TYPE)
66 #endif
67
68 #ifndef TARGET_VERSION
69 #define TARGET_VERSION TARGET_VERSION_INTERNAL (stderr)
70 #endif
71 \f
72 /* Storage Layout.  */
73
74 #define BITS_BIG_ENDIAN                 0
75 #define BYTES_BIG_ENDIAN                1 
76 #define WORDS_BIG_ENDIAN                1
77 #define BITS_PER_WORD                   32
78 #define MAX_BITS_PER_WORD               64
79 #define UNITS_PER_WORD                  4
80 #define MIN_UNITS_PER_WORD              4
81 #define POINTER_SIZE                    32
82
83 /* Define this macro if it is advisable to hold scalars in registers
84    in a wider mode than that declared by the program.  In such cases,
85    the value is constrained to be within the bounds of the declared
86    type, but kept valid in the wider mode.  The signedness of the
87    extension may differ from that of the type.
88
89    We promote any value smaller than SImode up to SImode.  */
90
91 #define PROMOTE_MODE(MODE, UNSIGNEDP, TYPE)     \
92   if (GET_MODE_CLASS (MODE) == MODE_INT         \
93       && GET_MODE_SIZE (MODE) < 4)              \
94     (MODE) = SImode;
95
96 #define PARM_BOUNDARY 32
97
98 #define STACK_BOUNDARY 64
99
100 #define FUNCTION_BOUNDARY 32
101
102 #define BIGGEST_ALIGNMENT 64
103
104 #undef  DATA_ALIGNMENT
105 #define DATA_ALIGNMENT(TYPE, ALIGN)                                     \
106   ((((ALIGN) < BITS_PER_WORD)                                           \
107     && (TREE_CODE (TYPE) == ARRAY_TYPE                                  \
108         || TREE_CODE (TYPE) == UNION_TYPE                               \
109         || TREE_CODE (TYPE) == RECORD_TYPE)) ? BITS_PER_WORD : (ALIGN))
110
111 #define CONSTANT_ALIGNMENT(EXP, ALIGN)                                  \
112   ((TREE_CODE (EXP) == STRING_CST  || TREE_CODE (EXP) == CONSTRUCTOR)   \
113    && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
114
115 #define EMPTY_FIELD_BOUNDARY 32
116
117 #define STRUCTURE_SIZE_BOUNDARY 8
118
119 #define STRICT_ALIGNMENT 1
120
121 #define PCC_BITFIELD_TYPE_MATTERS 1
122
123 \f
124 /* Layout of Source Language Data Types.  */
125
126 #define INT_TYPE_SIZE           32
127 #define SHORT_TYPE_SIZE         16
128 #define LONG_TYPE_SIZE          32
129 #define LONG_LONG_TYPE_SIZE     64
130 #define CHAR_TYPE_SIZE          BITS_PER_UNIT
131 #define FLOAT_TYPE_SIZE         32
132 #define DOUBLE_TYPE_SIZE        64
133 #define LONG_DOUBLE_TYPE_SIZE   64
134 #define DEFAULT_SIGNED_CHAR     1
135
136 \f
137 /* Register Basics.  */
138
139 /* On the IQ2000, we have 32 integer registers.  */
140 #define FIRST_PSEUDO_REGISTER 33
141
142 #define FIXED_REGISTERS                                                 \
143 {                                                                       \
144   1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                       \
145   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1                     \
146 }
147
148 #define CALL_USED_REGISTERS                                             \
149 {                                                                       \
150   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,                       \
151   0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1                     \
152 }
153
154 \f
155 /* Order of allocation of registers.  */
156
157 #define REG_ALLOC_ORDER                                                 \
158 {  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,       \
159   16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31        \
160 }
161
162 \f
163 /* How Values Fit in Registers.  */
164
165 #define HARD_REGNO_NREGS(REGNO, MODE)   \
166   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
167
168 #define HARD_REGNO_MODE_OK(REGNO, MODE)                         \
169  ((REGNO_REG_CLASS (REGNO) == GR_REGS)                          \
170   ? ((REGNO) & 1) == 0 || GET_MODE_SIZE (MODE) <= 4             \
171   : ((REGNO) & 1) == 0 || GET_MODE_SIZE (MODE) == 4)
172
173 #define MODES_TIEABLE_P(MODE1, MODE2)                           \
174   ((GET_MODE_CLASS (MODE1) == MODE_FLOAT ||                     \
175     GET_MODE_CLASS (MODE1) == MODE_COMPLEX_FLOAT)               \
176    == (GET_MODE_CLASS (MODE2) == MODE_FLOAT ||                  \
177        GET_MODE_CLASS (MODE2) == MODE_COMPLEX_FLOAT))
178
179 #define AVOID_CCMODE_COPIES
180
181 \f
182 /* Register Classes.  */
183
184 enum reg_class
185 {
186   NO_REGS,                      /* No registers in set.  */
187   GR_REGS,                      /* Integer registers.  */
188   ALL_REGS,                     /* All registers.  */
189   LIM_REG_CLASSES               /* Max value + 1.  */
190 };
191
192 #define GENERAL_REGS GR_REGS
193
194 #define N_REG_CLASSES (int) LIM_REG_CLASSES
195
196 #define IRA_COVER_CLASSES       \
197 {                               \
198   GR_REGS, LIM_REG_CLASSES      \
199 }
200
201 #define REG_CLASS_NAMES                                         \
202 {                                                               \
203   "NO_REGS",                                                    \
204   "GR_REGS",                                                    \
205   "ALL_REGS"                                                    \
206 }
207
208 #define REG_CLASS_CONTENTS                                      \
209 {                                                               \
210   { 0x00000000, 0x00000000 },   /* No registers,  */            \
211   { 0xffffffff, 0x00000000 },   /* Integer registers.  */       \
212   { 0xffffffff, 0x00000001 }    /* All registers.  */           \
213 }
214
215 #define REGNO_REG_CLASS(REGNO) \
216 ((REGNO) <= GP_REG_LAST + 1 ? GR_REGS : NO_REGS)
217
218 #define BASE_REG_CLASS  (GR_REGS)
219
220 #define INDEX_REG_CLASS NO_REGS
221
222 #define REG_CLASS_FROM_LETTER(C) \
223   ((C) == 'd' ? GR_REGS :        \
224    (C) == 'b' ? ALL_REGS :       \
225    (C) == 'y' ? GR_REGS :        \
226    NO_REGS)
227
228 #define REGNO_OK_FOR_INDEX_P(regno)     0
229
230 #define PREFERRED_RELOAD_CLASS(X,CLASS)                         \
231   ((CLASS) != ALL_REGS                                          \
232    ? (CLASS)                                                    \
233    : ((GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT              \
234        || GET_MODE_CLASS (GET_MODE (X)) == MODE_COMPLEX_FLOAT)  \
235       ? (GR_REGS)                                               \
236       : ((GET_MODE_CLASS (GET_MODE (X)) == MODE_INT             \
237           || GET_MODE (X) == VOIDmode)                          \
238          ? (GR_REGS)                                            \
239          : (CLASS))))
240
241 #define CLASS_MAX_NREGS(CLASS, MODE)    \
242   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
243
244 /* For IQ2000:
245
246    `I'  is used for the range of constants an arithmetic insn can
247         actually contain (16-bits signed integers).
248
249    `J'  is used for the range which is just zero (i.e., $r0).
250
251    `K'  is used for the range of constants a logical insn can actually
252         contain (16-bit zero-extended integers).
253
254    `L'  is used for the range of constants that be loaded with lui
255         (i.e., the bottom 16 bits are zero).
256
257    `M'  is used for the range of constants that take two words to load
258         (i.e., not matched by `I', `K', and `L').
259
260    `N'  is used for constants 0xffffnnnn or 0xnnnnffff
261
262    `O'  is a 5-bit zero-extended integer.  */
263
264 #define CONST_OK_FOR_LETTER_P(VALUE, C)                                 \
265   ((C) == 'I' ? ((unsigned HOST_WIDE_INT) ((VALUE) + 0x8000) < 0x10000) \
266    : (C) == 'J' ? ((VALUE) == 0)                                        \
267    : (C) == 'K' ? ((unsigned HOST_WIDE_INT) (VALUE) < 0x10000)          \
268    : (C) == 'L' ? (((VALUE) & 0x0000ffff) == 0                          \
269                    && (((VALUE) & ~2147483647) == 0                     \
270                        || ((VALUE) & ~2147483647) == ~2147483647))      \
271    : (C) == 'M' ? ((((VALUE) & ~0x0000ffff) != 0)                       \
272                    && (((VALUE) & ~0x0000ffff) != ~0x0000ffff)          \
273                    && (((VALUE) & 0x0000ffff) != 0                      \
274                        || (((VALUE) & ~2147483647) != 0                 \
275                            && ((VALUE) & ~2147483647) != ~2147483647))) \
276    : (C) == 'N' ? ((((VALUE) & 0xffff) == 0xffff)                       \
277                    || (((VALUE) & 0xffff0000) == 0xffff0000))           \
278    : (C) == 'O' ? ((unsigned HOST_WIDE_INT) ((VALUE) + 0x20) < 0x40)    \
279    : 0)
280
281 #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C)                          \
282   ((C) == 'G'                                                           \
283    && (VALUE) == CONST0_RTX (GET_MODE (VALUE)))
284
285 /* `R' is for memory references which take 1 word for the instruction.  */
286
287 #define EXTRA_CONSTRAINT(OP,CODE)                                       \
288   (((CODE) == 'R')        ? simple_memory_operand (OP, GET_MODE (OP))   \
289    : FALSE)
290
291 \f
292 /* Basic Stack Layout.  */
293
294 #define STACK_GROWS_DOWNWARD
295
296 #define FRAME_GROWS_DOWNWARD 0
297
298 #define STARTING_FRAME_OFFSET                                           \
299   (crtl->outgoing_args_size)
300
301 /* Use the default value zero.  */
302 /* #define STACK_POINTER_OFFSET 0 */
303
304 #define FIRST_PARM_OFFSET(FNDECL) 0
305
306 /* The return address for the current frame is in r31 if this is a leaf
307    function.  Otherwise, it is on the stack.  It is at a variable offset
308    from sp/fp/ap, so we define a fake hard register rap which is a
309    pointer to the return address on the stack.  This always gets eliminated
310    during reload to be either the frame pointer or the stack pointer plus
311    an offset.  */
312
313 #define RETURN_ADDR_RTX(count, frame)                                   \
314   (((count) == 0)                                                       \
315    ? (leaf_function_p ()                                                \
316       ? gen_rtx_REG (Pmode, GP_REG_FIRST + 31)                          \
317       : gen_rtx_MEM (Pmode, gen_rtx_REG (Pmode,                         \
318                                          RETURN_ADDRESS_POINTER_REGNUM))) \
319     : (rtx) 0)
320
321 /* Before the prologue, RA lives in r31.  */
322 #define INCOMING_RETURN_ADDR_RTX  gen_rtx_REG (VOIDmode, GP_REG_FIRST + 31)
323
324 \f
325 /* Register That Address the Stack Frame.  */
326
327 #define STACK_POINTER_REGNUM            (GP_REG_FIRST + 29)
328 #define FRAME_POINTER_REGNUM            (GP_REG_FIRST + 1)
329 #define HARD_FRAME_POINTER_REGNUM       (GP_REG_FIRST + 27)
330 #define ARG_POINTER_REGNUM              GP_REG_FIRST
331 #define RETURN_ADDRESS_POINTER_REGNUM   RAP_REG_NUM
332 #define STATIC_CHAIN_REGNUM             (GP_REG_FIRST + 2)
333
334 \f
335 /* Eliminating the Frame Pointer and the Arg Pointer.  */
336
337 #define ELIMINABLE_REGS                                                 \
338 {{ ARG_POINTER_REGNUM,   STACK_POINTER_REGNUM},                         \
339  { ARG_POINTER_REGNUM,   HARD_FRAME_POINTER_REGNUM},                    \
340  { RETURN_ADDRESS_POINTER_REGNUM, STACK_POINTER_REGNUM},                \
341  { RETURN_ADDRESS_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM},           \
342  { RETURN_ADDRESS_POINTER_REGNUM, GP_REG_FIRST + 31},                   \
343  { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM},                         \
344  { FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}}
345
346 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET)                     \
347         (OFFSET) = iq2000_initial_elimination_offset ((FROM), (TO))
348 \f
349 /* Passing Function Arguments on the Stack.  */
350
351 /* #define PUSH_ROUNDING(BYTES) 0 */
352
353 #define ACCUMULATE_OUTGOING_ARGS 1
354
355 #define REG_PARM_STACK_SPACE(FNDECL) 0
356
357 #define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 1
358
359 \f
360 /* Function Arguments in Registers.  */
361
362 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
363   function_arg (& CUM, MODE, TYPE, NAMED)
364
365 #define MAX_ARGS_IN_REGISTERS 8
366
367 typedef struct iq2000_args
368 {
369   int gp_reg_found;             /* Whether a gp register was found yet.  */
370   unsigned int arg_number;      /* Argument number.  */
371   unsigned int arg_words;       /* # total words the arguments take.  */
372   unsigned int fp_arg_words;    /* # words for FP args (IQ2000_EABI only).  */
373   int last_arg_fp;              /* Nonzero if last arg was FP (EABI only).  */
374   int fp_code;                  /* Mode of FP arguments.  */
375   unsigned int num_adjusts;     /* Number of adjustments made.  */
376                                 /* Adjustments made to args pass in regs.  */
377   struct rtx_def * adjust[MAX_ARGS_IN_REGISTERS * 2];
378 } CUMULATIVE_ARGS;
379
380 /* Initialize a variable CUM of type CUMULATIVE_ARGS
381    for a call to a function whose data type is FNTYPE.
382    For a library call, FNTYPE is 0.  */
383 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT, N_NAMED_ARGS) \
384   init_cumulative_args (& CUM, FNTYPE, LIBNAME)                         \
385
386 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)                    \
387   function_arg_advance (& CUM, MODE, TYPE, NAMED)
388
389 #define FUNCTION_ARG_PADDING(MODE, TYPE)                                \
390   (! BYTES_BIG_ENDIAN                                                   \
391    ? upward                                                             \
392    : (((MODE) == BLKmode                                                \
393        ? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST         \
394           && int_size_in_bytes (TYPE) < (PARM_BOUNDARY / BITS_PER_UNIT))\
395        : (GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY                       \
396           && (GET_MODE_CLASS (MODE) == MODE_INT)))                      \
397       ? downward : upward))
398
399 #define FUNCTION_ARG_BOUNDARY(MODE, TYPE)                               \
400   (((TYPE) != 0)                                                        \
401         ? ((TYPE_ALIGN(TYPE) <= PARM_BOUNDARY)                          \
402                 ? PARM_BOUNDARY                                         \
403                 : TYPE_ALIGN(TYPE))                                     \
404         : ((GET_MODE_ALIGNMENT(MODE) <= PARM_BOUNDARY)                  \
405                 ? PARM_BOUNDARY                                         \
406                 : GET_MODE_ALIGNMENT(MODE)))
407
408 #define FUNCTION_ARG_REGNO_P(N)                                         \
409   (((N) >= GP_ARG_FIRST && (N) <= GP_ARG_LAST))                 
410
411 \f
412 /* On the IQ2000, R2 and R3 are the only register thus used.  */
413
414 #define FUNCTION_VALUE_REGNO_P(N) iq2000_function_value_regno_p (N)
415
416 \f
417 /* How Large Values are Returned.  */
418
419 #define DEFAULT_PCC_STRUCT_RETURN 0
420 \f
421 /* Function Entry and Exit.  */
422
423 #define EXIT_IGNORE_STACK 1
424
425 \f
426 /* Generating Code for Profiling.  */
427
428 #define FUNCTION_PROFILER(FILE, LABELNO)                                \
429 {                                                                       \
430   fprintf (FILE, "\t.set\tnoreorder\n");                                \
431   fprintf (FILE, "\t.set\tnoat\n");                                     \
432   fprintf (FILE, "\tmove\t%s,%s\t\t# save current return address\n",    \
433            reg_names[GP_REG_FIRST + 1], reg_names[GP_REG_FIRST + 31]);  \
434   fprintf (FILE, "\tjal\t_mcount\n");                                   \
435   fprintf (FILE,                                                        \
436            "\t%s\t%s,%s,%d\t\t# _mcount pops 2 words from  stack\n",    \
437            "subu",                                                      \
438            reg_names[STACK_POINTER_REGNUM],                             \
439            reg_names[STACK_POINTER_REGNUM],                             \
440            Pmode == DImode ? 16 : 8);                                   \
441   fprintf (FILE, "\t.set\treorder\n");                                  \
442   fprintf (FILE, "\t.set\tat\n");                                       \
443 }
444
445 \f
446 /* Trampolines for Nested Functions.  */
447
448 #define TRAMPOLINE_CODE_SIZE  (8*4)
449 #define TRAMPOLINE_SIZE       (TRAMPOLINE_CODE_SIZE + 2*GET_MODE_SIZE (Pmode))
450 #define TRAMPOLINE_ALIGNMENT  GET_MODE_ALIGNMENT (Pmode)
451
452 \f
453 /* Addressing Modes.  */
454
455 #define CONSTANT_ADDRESS_P(X)                                           \
456   (   (GET_CODE (X) == LABEL_REF || GET_CODE (X) == SYMBOL_REF          \
457     || GET_CODE (X) == CONST_INT || GET_CODE (X) == HIGH                \
458     || (GET_CODE (X) == CONST)))
459
460 #define MAX_REGS_PER_ADDRESS 1
461
462 #define REG_OK_FOR_INDEX_P(X) 0
463
464 #define LEGITIMATE_CONSTANT_P(X) (1)
465
466 \f
467 /* Describing Relative Costs of Operations.  */
468
469 #define REGISTER_MOVE_COST(MODE, FROM, TO)      2
470
471 #define MEMORY_MOVE_COST(MODE,CLASS,TO_P)       \
472   (TO_P ? 2 : 16)
473
474 #define BRANCH_COST(speed_p, predictable_p) 2
475
476 #define SLOW_BYTE_ACCESS 1
477
478 #define NO_FUNCTION_CSE 1
479
480 #define ADJUST_COST(INSN,LINK,DEP_INSN,COST)                            \
481   if (REG_NOTE_KIND (LINK) != 0)                                        \
482     (COST) = 0; /* Anti or output dependence.  */
483
484 \f
485 /* Dividing the output into sections.  */
486
487 #define TEXT_SECTION_ASM_OP     "\t.text"       /* Instructions.  */
488
489 #define DATA_SECTION_ASM_OP     "\t.data"       /* Large data.  */
490
491 \f
492 /* The Overall Framework of an Assembler File.  */
493
494 #define ASM_COMMENT_START " #"
495
496 #define ASM_APP_ON "#APP\n"
497
498 #define ASM_APP_OFF "#NO_APP\n"
499
500 \f
501 /* Output and Generation of Labels.  */
502
503 #undef ASM_GENERATE_INTERNAL_LABEL
504 #define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM)                   \
505   sprintf ((LABEL), "*%s%s%ld", (LOCAL_LABEL_PREFIX), (PREFIX), (long) (NUM))
506
507 #define GLOBAL_ASM_OP "\t.globl\t"
508
509 \f
510 /* Output of Assembler Instructions.  */
511
512 #define REGISTER_NAMES                                                  \
513 {                                                                       \
514  "%0",   "%1",   "%2",   "%3",   "%4",   "%5",   "%6",   "%7",          \
515  "%8",   "%9",   "%10",  "%11",  "%12",  "%13",  "%14",  "%15",         \
516  "%16",  "%17",  "%18",  "%19",  "%20",  "%21",  "%22",  "%23",         \
517  "%24",  "%25",  "%26",  "%27",  "%28",  "%29",  "%30",  "%31",  "%rap" \
518 };
519
520 #define ADDITIONAL_REGISTER_NAMES                                       \
521 {                                                                       \
522   { "%0",        0 + GP_REG_FIRST },                                    \
523   { "%1",        1 + GP_REG_FIRST },                                    \
524   { "%2",        2 + GP_REG_FIRST },                                    \
525   { "%3",        3 + GP_REG_FIRST },                                    \
526   { "%4",        4 + GP_REG_FIRST },                                    \
527   { "%5",        5 + GP_REG_FIRST },                                    \
528   { "%6",        6 + GP_REG_FIRST },                                    \
529   { "%7",        7 + GP_REG_FIRST },                                    \
530   { "%8",        8 + GP_REG_FIRST },                                    \
531   { "%9",        9 + GP_REG_FIRST },                                    \
532   { "%10",      10 + GP_REG_FIRST },                                    \
533   { "%11",      11 + GP_REG_FIRST },                                    \
534   { "%12",      12 + GP_REG_FIRST },                                    \
535   { "%13",      13 + GP_REG_FIRST },                                    \
536   { "%14",      14 + GP_REG_FIRST },                                    \
537   { "%15",      15 + GP_REG_FIRST },                                    \
538   { "%16",      16 + GP_REG_FIRST },                                    \
539   { "%17",      17 + GP_REG_FIRST },                                    \
540   { "%18",      18 + GP_REG_FIRST },                                    \
541   { "%19",      19 + GP_REG_FIRST },                                    \
542   { "%20",      20 + GP_REG_FIRST },                                    \
543   { "%21",      21 + GP_REG_FIRST },                                    \
544   { "%22",      22 + GP_REG_FIRST },                                    \
545   { "%23",      23 + GP_REG_FIRST },                                    \
546   { "%24",      24 + GP_REG_FIRST },                                    \
547   { "%25",      25 + GP_REG_FIRST },                                    \
548   { "%26",      26 + GP_REG_FIRST },                                    \
549   { "%27",      27 + GP_REG_FIRST },                                    \
550   { "%28",      28 + GP_REG_FIRST },                                    \
551   { "%29",      29 + GP_REG_FIRST },                                    \
552   { "%30",      27 + GP_REG_FIRST },                                    \
553   { "%31",      31 + GP_REG_FIRST },                                    \
554   { "%rap",     32 + GP_REG_FIRST },                                    \
555 }
556
557 /* Check if the current insn needs a nop in front of it
558    because of load delays, and also update the delay slot statistics.  */
559
560 #define FINAL_PRESCAN_INSN(INSN, OPVEC, NOPERANDS)                      \
561   final_prescan_insn (INSN, OPVEC, NOPERANDS)
562
563 #define DBR_OUTPUT_SEQEND(STREAM)                                       \
564 do                                                                      \
565   {                                                                     \
566     fputs ("\n", STREAM);                                               \
567   }                                                                     \
568 while (0)
569
570 #define LOCAL_LABEL_PREFIX      "$"
571
572 #define USER_LABEL_PREFIX       ""
573
574 \f
575 /* Output of dispatch tables.  */
576
577 #define ASM_OUTPUT_ADDR_DIFF_ELT(STREAM, BODY, VALUE, REL)              \
578   do                                                                    \
579     {                                                                   \
580       fprintf (STREAM, "\t%s\t%sL%d\n",                                 \
581                Pmode == DImode ? ".dword" : ".word",                    \
582                LOCAL_LABEL_PREFIX, VALUE);                              \
583     }                                                                   \
584   while (0)
585
586 #define ASM_OUTPUT_ADDR_VEC_ELT(STREAM, VALUE)                          \
587   fprintf (STREAM, "\t%s\t%sL%d\n",                                     \
588            Pmode == DImode ? ".dword" : ".word",                        \
589            LOCAL_LABEL_PREFIX,                                          \
590            VALUE)
591
592 \f
593 /* Assembler Commands for Alignment.  */
594
595 #undef ASM_OUTPUT_SKIP
596 #define ASM_OUTPUT_SKIP(STREAM,SIZE)                                    \
597   fprintf (STREAM, "\t.space\t" HOST_WIDE_INT_PRINT_UNSIGNED "\n",      \
598            (unsigned HOST_WIDE_INT)(SIZE))
599
600 #define ASM_OUTPUT_ALIGN(STREAM,LOG)                                    \
601   if ((LOG) != 0)                                                       \
602     fprintf (STREAM, "\t.balign %d\n", 1<<(LOG))
603
604 \f
605 /* Macros Affecting all Debug Formats.  */
606
607 #define DEBUGGER_AUTO_OFFSET(X)  \
608   iq2000_debugger_offset (X, (HOST_WIDE_INT) 0)
609
610 #define DEBUGGER_ARG_OFFSET(OFFSET, X)  \
611   iq2000_debugger_offset (X, (HOST_WIDE_INT) OFFSET)
612
613 #define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG
614
615 #define DWARF2_DEBUGGING_INFO 1
616
617 \f
618 /* Miscellaneous Parameters.  */
619
620 #define CASE_VECTOR_MODE SImode
621
622 #define WORD_REGISTER_OPERATIONS
623
624 #define LOAD_EXTEND_OP(MODE) ZERO_EXTEND
625
626 #define MOVE_MAX 4
627
628 #define MAX_MOVE_MAX 8
629
630 #define SHIFT_COUNT_TRUNCATED 1
631
632 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
633
634 #define STORE_FLAG_VALUE 1
635
636 #define Pmode SImode
637
638 #define FUNCTION_MODE SImode
639
640 /* Standard GCC variables that we reference.  */
641
642 extern char     call_used_regs[];
643
644 /* IQ2000 external variables defined in iq2000.c.  */
645
646 /* Comparison type.  */
647 enum cmp_type
648 {
649   CMP_SI,                               /* Compare four byte integers.  */
650   CMP_DI,                               /* Compare eight byte integers.  */
651   CMP_SF,                               /* Compare single precision floats.  */
652   CMP_DF,                               /* Compare double precision floats.  */
653   CMP_MAX                               /* Max comparison type.  */
654 };
655
656 /* Types of delay slot.  */
657 enum delay_type
658 {
659   DELAY_NONE,                           /* No delay slot.  */
660   DELAY_LOAD,                           /* Load from memory delay.  */
661   DELAY_FCMP                            /* Delay after doing c.<xx>.{d,s}.  */
662 };
663
664 /* Which processor to schedule for.  */
665
666 enum processor_type
667 {
668   PROCESSOR_DEFAULT,
669   PROCESSOR_IQ2000,
670   PROCESSOR_IQ10
671 };
672
673 /* Recast the cpu class to be the cpu attribute.  */
674 #define iq2000_cpu_attr ((enum attr_cpu) iq2000_tune)
675
676 #define BITMASK_UPPER16 ((unsigned long) 0xffff << 16)  /* 0xffff0000 */
677 #define BITMASK_LOWER16 ((unsigned long) 0xffff)        /* 0x0000ffff */
678
679 \f
680 #define GENERATE_BRANCHLIKELY  (ISA_HAS_BRANCHLIKELY)
681
682 /* Macros to decide whether certain features are available or not,
683    depending on the instruction set architecture level.  */
684
685 #define BRANCH_LIKELY_P()       GENERATE_BRANCHLIKELY
686
687 /* ISA has branch likely instructions.  */
688 #define ISA_HAS_BRANCHLIKELY    (iq2000_isa == 1)
689
690 \f
691 #undef ASM_SPEC
692
693 \f
694 /* The mapping from gcc register number to DWARF 2 CFA column number.  */
695 #define DWARF_FRAME_REGNUM(REG)        (REG)
696
697 /* The DWARF 2 CFA column which tracks the return address.  */
698 #define DWARF_FRAME_RETURN_COLUMN (GP_REG_FIRST + 31)
699
700 /* Describe how we implement __builtin_eh_return.  */
701 #define EH_RETURN_DATA_REGNO(N) ((N) < 4 ? (N) + GP_ARG_FIRST : INVALID_REGNUM)
702
703 /* The EH_RETURN_STACKADJ_RTX macro returns RTL which describes the
704    location used to store the amount to adjust the stack.  This is
705    usually a register that is available from end of the function's body
706    to the end of the epilogue. Thus, this cannot be a register used as a
707    temporary by the epilogue.
708
709    This must be an integer register.  */
710 #define EH_RETURN_STACKADJ_REGNO        3
711 #define EH_RETURN_STACKADJ_RTX  gen_rtx_REG (Pmode, EH_RETURN_STACKADJ_REGNO)
712
713 /* The EH_RETURN_HANDLER_RTX macro returns RTL which describes the
714    location used to store the address the processor should jump to
715    catch exception.  This is usually a registers that is available from
716    end of the function's body to the end of the epilogue. Thus, this
717    cannot be a register used as a temporary by the epilogue.
718
719    This must be an address register.  */
720 #define EH_RETURN_HANDLER_REGNO         26
721 #define EH_RETURN_HANDLER_RTX           \
722         gen_rtx_REG (Pmode, EH_RETURN_HANDLER_REGNO)
723
724 /* Offsets recorded in opcodes are a multiple of this alignment factor.  */
725 #define DWARF_CIE_DATA_ALIGNMENT 4
726
727 /* For IQ2000, width of a floating point register.  */
728 #define UNITS_PER_FPREG 4
729
730 /* Force right-alignment for small varargs in 32 bit little_endian mode */
731
732 #define PAD_VARARGS_DOWN !BYTES_BIG_ENDIAN
733
734 /* Internal macros to classify a register number as to whether it's a
735    general purpose register, a floating point register, a
736    multiply/divide register, or a status register.  */
737
738 #define GP_REG_FIRST 0
739 #define GP_REG_LAST  31
740 #define GP_REG_NUM   (GP_REG_LAST - GP_REG_FIRST + 1)
741
742 #define RAP_REG_NUM   32
743 #define AT_REGNUM       (GP_REG_FIRST + 1)
744
745 #define GP_REG_P(REGNO) \
746   ((unsigned int) ((int) (REGNO) - GP_REG_FIRST) < GP_REG_NUM)
747
748 /* IQ2000 registers used in prologue/epilogue code when the stack frame
749    is larger than 32K bytes.  These registers must come from the
750    scratch register set, and not used for passing and returning
751    arguments and any other information used in the calling sequence.  */
752
753 #define IQ2000_TEMP1_REGNUM (GP_REG_FIRST + 12)
754 #define IQ2000_TEMP2_REGNUM (GP_REG_FIRST + 13)
755
756 /* This macro is used later on in the file.  */
757 #define GR_REG_CLASS_P(CLASS)                                           \
758   ((CLASS) == GR_REGS)
759
760 #define SMALL_INT(X) ((unsigned HOST_WIDE_INT) (INTVAL (X) + 0x8000) < 0x10000)
761 #define SMALL_INT_UNSIGNED(X) ((unsigned HOST_WIDE_INT) (INTVAL (X)) < 0x10000)
762
763 /* Certain machines have the property that some registers cannot be
764    copied to some other registers without using memory.  Define this
765    macro on those machines to be a C expression that is nonzero if
766    objects of mode MODE in registers of CLASS1 can only be copied to
767    registers of class CLASS2 by storing a register of CLASS1 into
768    memory and loading that memory location into a register of CLASS2.
769
770    Do not define this macro if its value would always be zero.  */
771
772 /* Return the maximum number of consecutive registers
773    needed to represent mode MODE in a register of class CLASS.  */
774
775 #define CLASS_UNITS(mode, size)                                         \
776   ((GET_MODE_SIZE (mode) + (size) - 1) / (size))
777
778 /* If defined, gives a class of registers that cannot be used as the
779    operand of a SUBREG that changes the mode of the object illegally.  */
780
781 #define CLASS_CANNOT_CHANGE_MODE 0
782
783 /* Defines illegal mode changes for CLASS_CANNOT_CHANGE_MODE.  */
784
785 #define CLASS_CANNOT_CHANGE_MODE_P(FROM,TO) \
786   (GET_MODE_SIZE (FROM) != GET_MODE_SIZE (TO))
787
788 /* Make sure 4 words are always allocated on the stack.  */
789
790 #ifndef STACK_ARGS_ADJUST
791 #define STACK_ARGS_ADJUST(SIZE)                                         \
792   {                                                                     \
793     if (SIZE.constant < 4 * UNITS_PER_WORD)                             \
794       SIZE.constant = 4 * UNITS_PER_WORD;                               \
795   }
796 #endif
797
798 \f
799 /* Symbolic macros for the registers used to return integer and floating
800    point values.  */
801
802 #define GP_RETURN (GP_REG_FIRST + 2)
803
804 /* Symbolic macros for the first/last argument registers.  */
805
806 #define GP_ARG_FIRST (GP_REG_FIRST + 4)
807 #define GP_ARG_LAST  (GP_REG_FIRST + 11)
808
809 #define MAX_ARGS_IN_REGISTERS   8
810
811 \f
812 /* Tell prologue and epilogue if register REGNO should be saved / restored.  */
813
814 #define MUST_SAVE_REGISTER(regno) \
815   ((df_regs_ever_live_p (regno) && !call_used_regs[regno])              \
816   || (regno == HARD_FRAME_POINTER_REGNUM && frame_pointer_needed)       \
817    || (regno == (GP_REG_FIRST + 31) && df_regs_ever_live_p (GP_REG_FIRST + 31)))
818
819 /* ALIGN FRAMES on double word boundaries */
820 #ifndef IQ2000_STACK_ALIGN
821 #define IQ2000_STACK_ALIGN(LOC) (((LOC) + 7) & ~7)
822 #endif
823
824 \f
825 /* These assume that REGNO is a hard or pseudo reg number.
826    They give nonzero only if REGNO is a hard reg of the suitable class
827    or a pseudo reg currently allocated to a suitable hard reg.
828    These definitions are NOT overridden anywhere.  */
829
830 #define BASE_REG_P(regno, mode)                                 \
831   (GP_REG_P (regno))
832
833 #define GP_REG_OR_PSEUDO_STRICT_P(regno, mode)                              \
834   BASE_REG_P((regno < FIRST_PSEUDO_REGISTER) ? regno : reg_renumber[regno], \
835              (mode))
836
837 #define GP_REG_OR_PSEUDO_NONSTRICT_P(regno, mode) \
838   (((regno) >= FIRST_PSEUDO_REGISTER) || (BASE_REG_P ((regno), (mode))))
839
840 #define REGNO_MODE_OK_FOR_BASE_P(regno, mode) \
841   GP_REG_OR_PSEUDO_STRICT_P ((regno), (mode))
842
843 /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
844    and check its validity for a certain class.
845    We have two alternate definitions for each of them.
846    The usual definition accepts all pseudo regs; the other rejects them all.
847    The symbol REG_OK_STRICT causes the latter definition to be used.
848
849    Most source files want to accept pseudo regs in the hope that
850    they will get allocated to the class that the insn wants them to be in.
851    Some source files that are used after register allocation
852    need to be strict.  */
853
854 #ifndef REG_OK_STRICT
855 #define REG_MODE_OK_FOR_BASE_P(X, MODE) \
856   iq2000_reg_mode_ok_for_base_p (X, MODE, 0)
857 #else
858 #define REG_MODE_OK_FOR_BASE_P(X, MODE) \
859   iq2000_reg_mode_ok_for_base_p (X, MODE, 1)
860 #endif
861
862 #if 1
863 #define GO_PRINTF(x)    fprintf (stderr, (x))
864 #define GO_PRINTF2(x,y) fprintf (stderr, (x), (y))
865 #define GO_DEBUG_RTX(x) debug_rtx (x)
866
867 #else
868 #define GO_PRINTF(x)
869 #define GO_PRINTF2(x,y)
870 #define GO_DEBUG_RTX(x)
871 #endif
872
873 /* If defined, modifies the length assigned to instruction INSN as a
874    function of the context in which it is used.  LENGTH is an lvalue
875    that contains the initially computed length of the insn and should
876    be updated with the correct length of the insn.  */
877 #define ADJUST_INSN_LENGTH(INSN, LENGTH) \
878   ((LENGTH) = iq2000_adjust_insn_length ((INSN), (LENGTH)))
879
880 \f
881
882
883 /* How to tell the debugger about changes of source files.  */
884
885 #ifndef SET_FILE_NUMBER
886 #define SET_FILE_NUMBER() ++ num_source_filenames
887 #endif
888
889 /* This is how to output a note the debugger telling it the line number
890    to which the following sequence of instructions corresponds.  */
891
892 #ifndef LABEL_AFTER_LOC
893 #define LABEL_AFTER_LOC(STREAM)
894 #endif
895
896 \f
897 /* Default to -G 8 */
898 #ifndef IQ2000_DEFAULT_GVALUE
899 #define IQ2000_DEFAULT_GVALUE 8
900 #endif
901
902 #define SDATA_SECTION_ASM_OP    "\t.sdata"      /* Small data.  */
903
904 \f
905 /* The target cpu for optimization and scheduling.  */
906 extern enum processor_type iq2000_tune;
907
908 /* Which instruction set architecture to use.  */
909 extern int iq2000_isa;
910
911 enum iq2000_builtins
912 {
913   IQ2000_BUILTIN_ADO16,
914   IQ2000_BUILTIN_CFC0,
915   IQ2000_BUILTIN_CFC1,
916   IQ2000_BUILTIN_CFC2,
917   IQ2000_BUILTIN_CFC3,
918   IQ2000_BUILTIN_CHKHDR,
919   IQ2000_BUILTIN_CTC0,
920   IQ2000_BUILTIN_CTC1,
921   IQ2000_BUILTIN_CTC2,
922   IQ2000_BUILTIN_CTC3,
923   IQ2000_BUILTIN_LU,
924   IQ2000_BUILTIN_LUC32L,
925   IQ2000_BUILTIN_LUC64,
926   IQ2000_BUILTIN_LUC64L,
927   IQ2000_BUILTIN_LUK,
928   IQ2000_BUILTIN_LULCK,
929   IQ2000_BUILTIN_LUM32,
930   IQ2000_BUILTIN_LUM32L,
931   IQ2000_BUILTIN_LUM64,
932   IQ2000_BUILTIN_LUM64L,
933   IQ2000_BUILTIN_LUR,
934   IQ2000_BUILTIN_LURL,
935   IQ2000_BUILTIN_MFC0,
936   IQ2000_BUILTIN_MFC1,
937   IQ2000_BUILTIN_MFC2,
938   IQ2000_BUILTIN_MFC3,
939   IQ2000_BUILTIN_MRGB,
940   IQ2000_BUILTIN_MTC0,
941   IQ2000_BUILTIN_MTC1,
942   IQ2000_BUILTIN_MTC2,
943   IQ2000_BUILTIN_MTC3,
944   IQ2000_BUILTIN_PKRL,
945   IQ2000_BUILTIN_RAM,
946   IQ2000_BUILTIN_RB,
947   IQ2000_BUILTIN_RX,
948   IQ2000_BUILTIN_SRRD,
949   IQ2000_BUILTIN_SRRDL,
950   IQ2000_BUILTIN_SRULC,
951   IQ2000_BUILTIN_SRULCK,
952   IQ2000_BUILTIN_SRWR,
953   IQ2000_BUILTIN_SRWRU,
954   IQ2000_BUILTIN_TRAPQF,
955   IQ2000_BUILTIN_TRAPQFL,
956   IQ2000_BUILTIN_TRAPQN,
957   IQ2000_BUILTIN_TRAPQNE,
958   IQ2000_BUILTIN_TRAPRE,
959   IQ2000_BUILTIN_TRAPREL,
960   IQ2000_BUILTIN_WB,
961   IQ2000_BUILTIN_WBR,
962   IQ2000_BUILTIN_WBU,
963   IQ2000_BUILTIN_WX,
964   IQ2000_BUILTIN_SYSCALL
965 };