OSDN Git Service

gcc/
[pf3gnuchains/gcc-fork.git] / gcc / config / mep / mep.h
1 /* Definitions for Toshiba Media Processor
2    Copyright (C) 2001, 2003, 2004, 2005, 2007, 2008, 2009, 2010
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 it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16 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 \f
22
23 #undef  CPP_SPEC
24 #define CPP_SPEC "\
25 -D__MEP__ -D__MeP__ \
26 -D__section(_x)=__attribute__((section(_x))) \
27 -D__align(_x)=__attribute__((aligned(_x))) \
28 -D__io(_x)=__attribute__((io(_x))) \
29 -D__cb(_x)=__attribute__((cb(_x))) \
30 -D__based=__attribute__((based)) \
31 -D__tiny=__attribute__((tiny)) \
32 -D__near=__attribute__((near)) \
33 -D__far=__attribute__((far)) \
34 -D__vliw=__attribute__((vliw)) \
35 -D__interrupt=__attribute__((interrupt)) \
36 -D__disinterrupt=__attribute__((disinterrupt)) \
37 %{!meb:%{!mel:-D__BIG_ENDIAN__}} \
38 %{meb:-U__LITTLE_ENDIAN__ -D__BIG_ENDIAN__} \
39 %{mel:-U__BIG_ENDIAN__ -D__LITTLE_ENDIAN__} \
40 %{mconfig=*:-D__MEP_CONFIG_%*} \
41 %{mivc2:-D__MEP_CONFIG_CP_DATA_BUS_WIDTH=64} \
42 "
43
44 #undef  CC1_SPEC
45 #define CC1_SPEC "%{!mlibrary:%(config_cc_spec)} \
46 %{!.cc:%{O2:%{!funroll*:--param max-completely-peeled-insns=6 \
47                         --param max-unrolled-insns=6 -funroll-loops}}}"
48
49 #undef  CC1PLUS_SPEC
50 #define CC1PLUS_SPEC "%{!mlibrary:%(config_cc_spec)}"
51
52 #undef  ASM_SPEC
53 #define ASM_SPEC "%{mconfig=*} %{meb:-EB} %{mel:-EL} \
54 %{mno-satur} %{msatur} %{mno-clip} %{mclip} %{mno-minmax} %{mminmax} \
55 %{mno-absdiff} %{mabsdiff} %{mno-leadz} %{mleadz} %{mno-bitops} %{mbitops} \
56 %{mno-div} %{mdiv} %{mno-mult} %{mmult} %{mno-average} %{maverage} \
57 %{mcop32} %{mno-debug} %{mdebug} %{mlibrary}"
58
59 /* The MeP config tool will edit this spec.  */
60 #undef  STARTFILE_SPEC
61 #define STARTFILE_SPEC "%{msdram:%{msim:simsdram-crt0.o%s}} \
62 %{mno-sdram:%{msim:sim-crt0.o%s}} \
63 %{msdram:%{!msim*:sdram-crt0.o%s}} \
64 %{mno-sdram:%{!msim*:crt0.o%s}} \
65 %(config_start_spec) \
66 %{msimnovec:simnovec-crt0.o%s} \
67 crtbegin.o%s"
68
69 #undef  LIB_SPEC
70 #define LIB_SPEC "-( -lc %{msim*:-lsim}%{!msim*:-lnosys} -) %(config_link_spec)"
71
72 #undef  LINK_SPEC
73 #define LINK_SPEC "%{meb:-EB} %{mel:-EL}"
74
75 #undef  ENDFILE_SPEC
76 #define ENDFILE_SPEC "crtend.o%s %{msim*:sim-crtn.o%s}%{!msim*:crtn.o%s}"
77
78 /* The MeP config tool will edit this spec.  */
79 #define CONFIG_CC_SPEC "\
80 %{mconfig=default: -mbitops -mleadz -mabsdiff -maverage -mminmax -mclip -msatur -mvl64 -mvliw -mcop64 -D__MEP_CONFIG_CP_DATA_BUS_WIDTH=64 -mivc2}\
81 "
82 /* end-config-cc-spec */
83
84 /* The MeP config tool will edit this spec.  */
85 #define CONFIG_LINK_SPEC "\
86 %{mconfig=default: %{!T*:-Tdefault.ld}}\
87 "
88 /* end-config-link-spec */
89
90 /* The MeP config tool will edit this spec.  */
91 #define CONFIG_START_SPEC "\
92 %{!msdram:%{!mno-sdram:%{!msim*:crt0.o%s}}} \
93 %{!msdram:%{!mno-sdram:%{msim:sim-crt0.o%s}}} \
94 "
95 /* end-config-start-spec */
96
97 #define EXTRA_SPECS \
98   { "config_cc_spec",  CONFIG_CC_SPEC }, \
99   { "config_link_spec",  CONFIG_LINK_SPEC }, \
100   { "config_start_spec",  CONFIG_START_SPEC },
101 \f
102
103 #define TARGET_CPU_CPP_BUILTINS()               \
104   do                                            \
105     {                                           \
106       builtin_define_std ("mep");               \
107       builtin_assert ("machine=mep");           \
108     }                                           \
109   while (0)
110
111 /* Controlled by MeP-Integrator.  */
112 #define TARGET_H1               0
113
114 #define MEP_ALL_OPTS    (MASK_OPT_AVERAGE       \
115                          | MASK_OPT_MULT        \
116                          | MASK_OPT_DIV         \
117                          | MASK_OPT_BITOPS      \
118                          | MASK_OPT_LEADZ       \
119                          | MASK_OPT_ABSDIFF     \
120                          | MASK_OPT_MINMAX      \
121                          | MASK_OPT_CLIP        \
122                          | MASK_OPT_SATUR )
123
124 #define TARGET_DEFAULT          (MASK_IO_VOLATILE | MASK_OPT_REPEAT | MEP_ALL_OPTS | MASK_LITTLE_ENDIAN)
125
126 #define TARGET_IO_NO_VOLATILE   (! (target_flags & MASK_IO_VOLATILE))
127 #define TARGET_OPT_NOREPEAT     (! (target_flags & MASK_OPT_REPEAT))
128 #define TARGET_32BIT_CR_REGS    (! (target_flags & MASK_64BIT_CR_REGS))
129 #define TARGET_BIG_ENDIAN       (! (target_flags & MASK_LITTLE_ENDIAN))
130
131 #define TARGET_COPRO_MULT       0
132
133 #define TARGET_VERSION fprintf (stderr, " (Toshiba Media Processor (MeP))");
134
135 /* The MeP config tool will add TARGET_OPTION_TRANSLATE_TABLE here.  */
136 #define TARGET_OPTION_TRANSLATE_TABLE \
137   {"-mall-opts", "-maverage -mmult -mdiv -mbitops -mleadz \
138                   -mabsdiff -mminmax -mclip -msatur -mdebug" }, \
139   {"-mno-opts", "-mno-average -mno-mult -mno-div -mno-bitops -mno-leadz \
140                   -mno-absdiff -mno-minmax -mno-clip -mno-satur -mno-debug" }, \
141   {"-mfar", "-ml -mtf -mc=far" } \
142 /* start-target-option-table */ \
143 , {"-mconfig=default", "-mconfig=default -mmult -mdiv -D__MEP_CONFIG_ISA=1" } \
144 /* end-target-option-table */
145
146 /* The MeP config tool will replace this as appropriate.  */
147 #define DEFAULT_ENDIAN_SPEC "%{!meb: -mel}"
148
149 /* The MeP config tool will replace this with an -mconfig= switch.  */
150 #define LIBRARY_CONFIG_SPEC "-mconfig=default"
151
152 /* Don't add an endian option when building the libraries.  */
153 #define DRIVER_SELF_SPECS \
154   "%{!mlibrary:" DEFAULT_ENDIAN_SPEC "}", \
155   "%{mlibrary: " LIBRARY_CONFIG_SPEC " %{!mel:-meb}}"
156
157 /* The MeP config tool will add COPROC_SELECTION_TABLE here.  */
158 /* start-coproc-selection-table */
159 #define COPROC_SELECTION_TABLE \
160 {"default", ISA_EXT1}
161 /* end-coproc-selection-table */
162 \f
163
164 #define BITS_BIG_ENDIAN 0
165 #define BYTES_BIG_ENDIAN (TARGET_LITTLE_ENDIAN ? 0 : 1)
166 #define WORDS_BIG_ENDIAN (TARGET_LITTLE_ENDIAN ? 0 : 1)
167
168 #define UNITS_PER_WORD 4
169
170 #define PROMOTE_MODE(MODE, UNSIGNEDP, TYPE)     \
171   do                                            \
172     {                                           \
173       if (GET_MODE_CLASS (MODE) == MODE_INT     \
174           && GET_MODE_SIZE (MODE) < 4)          \
175         (MODE) = SImode;                \
176     }                                           \
177   while (0)
178
179 #define PARM_BOUNDARY 32
180 #define STACK_BOUNDARY 32
181 #define PREFERRED_STACK_BOUNDARY 64
182 #define FUNCTION_BOUNDARY 16
183 #define BIGGEST_ALIGNMENT 64
184
185 #define DATA_ALIGNMENT(TYPE, ALIGN)             \
186   (TREE_CODE (TYPE) == ARRAY_TYPE               \
187    && TYPE_MODE (TREE_TYPE (TYPE)) == QImode    \
188    && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
189
190 #define CONSTANT_ALIGNMENT(EXP, ALIGN)  \
191   (TREE_CODE (EXP) == STRING_CST        \
192    && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
193
194 #define STRICT_ALIGNMENT 1
195
196 #define PCC_BITFIELD_TYPE_MATTERS 1
197
198 #define DEFAULT_VTABLE_THUNKS 1
199
200 \f
201 #define INT_TYPE_SIZE         32
202 #define SHORT_TYPE_SIZE       16
203 #define LONG_TYPE_SIZE        32
204 #define LONG_LONG_TYPE_SIZE   64
205 #define CHAR_TYPE_SIZE         8
206 #define FLOAT_TYPE_SIZE       32
207 #define DOUBLE_TYPE_SIZE      64
208 #define LONG_DOUBLE_TYPE_SIZE 64
209 #define DEFAULT_SIGNED_CHAR    1
210 \f
211 /* Register numbers:
212         0..15   core registers
213         16..47  control registers
214         48..79  coprocessor registers
215         80..111 coprocessor control registers
216         112     virtual arg pointer register  */
217
218 #define FIRST_PSEUDO_REGISTER (LAST_SHADOW_REGISTER + 1)
219
220   /* R12 is optionally FP.  R13 is TP, R14 is GP, R15 is SP. */
221   /* hi and lo can be used as general registers.  Others have
222      immutable bits.  */
223 /* A "1" here means the register is generally not available to gcc,
224    and is assumed to remain unchanged or unused throughout.  */
225 #define FIXED_REGISTERS {                               \
226   /* core registers */                                  \
227   0, 0, 0, 0,  0, 0, 0, 0,  0, 0, 0, 0,  0, 0, 0, 1,    \
228   /* control registers */                               \
229   1, 1, 1, 1,  1, 1, 1, 0,  0, 1, 1, 1,  1, 1, 1, 1,    \
230   1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,    \
231   /* coprocessor registers */                           \
232   1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,    \
233   1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,    \
234   /* coprocessor control registers */                   \
235   1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,    \
236   1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,    \
237   /* virtual arg pointer */                             \
238   1, FIXED_SHADOW_REGISTERS                             \
239   }
240
241 /* This is a call-clobbered reg not used for args or return value,
242    that we use as a temp for saving control registers in the prolog
243    and restoring them in the epilog. */
244 #define REGSAVE_CONTROL_TEMP    11
245
246 /* A "1" here means a register may be changed by a function without
247    needing to preserve its previous value.  */
248 #define CALL_USED_REGISTERS {                           \
249   /* core registers */                                  \
250   1, 1, 1, 1,  1, 0, 0, 0,  0, 1, 1, 1,  1, 0, 0, 1,    \
251   /* control registers */                               \
252   1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,    \
253   1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,    \
254   /* coprocessor registers */                           \
255   1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,    \
256   1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,    \
257   /* coprocessor control registers */                   \
258   1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,    \
259   1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,    \
260   /* virtual arg pointer */                             \
261   1, CALL_USED_SHADOW_REGISTERS                         \
262   }
263
264 #define CONDITIONAL_REGISTER_USAGE \
265         mep_conditional_register_usage ();
266
267 #define REG_ALLOC_ORDER {                                               \
268   /* core registers */                                                  \
269   3, 2, 1, 0, 9, 10, 11, 12, 4, 5, 6, 7, 8, 13, 14, 15,                 \
270   /* control registers */                                               \
271   16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,       \
272   32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,       \
273   /* coprocessor registers */                                           \
274   /* Prefer to use the non-loadable registers when looking for a        \
275      member of CR_REGS (as opposed to LOADABLE_CR_REGS).  */            \
276   64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 48, 49, 50, 51, 52, 58,       \
277   59, 60, 61, 62, 63, 53, 54, 55, 56, 57, 74, 75, 76, 77, 78, 79,       \
278   /* coprocessor control registers */                                   \
279   80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,       \
280   96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, \
281   /* virtual arg pointer */                                             \
282   112, SHADOW_REG_ALLOC_ORDER                                           \
283   }
284
285 /* We must somehow disable register remapping for interrupt functions.  */
286 extern char mep_leaf_registers[];
287 #define LEAF_REGISTERS mep_leaf_registers
288 #define LEAF_REG_REMAP(REG) (REG)
289
290 \f
291 #define FIRST_GR_REGNO 0
292 #define FIRST_CONTROL_REGNO (FIRST_GR_REGNO + 16)
293 #define FIRST_CR_REGNO (FIRST_CONTROL_REGNO + 32)
294 #define FIRST_CCR_REGNO (FIRST_CR_REGNO + 32)
295
296 #define GR_REGNO_P(REGNO) \
297   ((unsigned) ((REGNO) - FIRST_GR_REGNO) < 16)
298
299 #define CONTROL_REGNO_P(REGNO) \
300   ((unsigned) ((REGNO) - FIRST_CONTROL_REGNO) < 32)
301
302 #define LOADABLE_CR_REGNO_P(REGNO) \
303   ((unsigned) ((REGNO) - FIRST_CR_REGNO) < 16)
304
305 #define CR_REGNO_P(REGNO) \
306   ((unsigned) ((REGNO) - FIRST_CR_REGNO) < 32)
307
308 #define CCR_REGNO_P(REGNO) \
309   ((unsigned) ((REGNO) - FIRST_CCR_REGNO) < 32)
310
311 #define ANY_CONTROL_REGNO_P(REGNO) \
312   (CONTROL_REGNO_P (REGNO) || CCR_REGNO_P (REGNO))
313
314 #define HARD_REGNO_NREGS(REGNO, MODE)           \
315   ((CR_REGNO_P (REGNO) && TARGET_64BIT_CR_REGS) \
316    ? (GET_MODE_SIZE (MODE) + 8 - 1) / 8         \
317    : (GET_MODE_SIZE (MODE) + 4 - 1) / 4)
318
319 #define HARD_REGNO_MODE_OK(REGNO, MODE) 1
320
321 #define MODES_TIEABLE_P(MODE1, MODE2) 1
322
323 #define CANNOT_CHANGE_MODE_CLASS(FROM, TO, CLASS) \
324   mep_cannot_change_mode_class (FROM, TO, CLASS)
325 \f
326 enum reg_class
327 {
328   NO_REGS,
329   SP_REGS,
330   TP_REGS,
331   GP_REGS,
332   R0_REGS,
333   RPC_REGS,
334   HI_REGS,
335   LO_REGS,
336   HILO_REGS,
337   TPREL_REGS,
338   GENERAL_NOT_R0_REGS,
339   GENERAL_REGS,
340   CONTROL_REGS,
341   CONTROL_OR_GENERAL_REGS,
342   USER0_REGS,
343   USER1_REGS,
344   USER2_REGS,
345   USER3_REGS,
346   LOADABLE_CR_REGS,
347   CR_REGS,
348   CCR_REGS,
349   ALL_REGS,
350   LIM_REG_CLASSES
351 };
352
353 #define N_REG_CLASSES ((int) LIM_REG_CLASSES)
354
355 #define REG_CLASS_NAMES { \
356   "NO_REGS", \
357   "SP_REGS", \
358   "TP_REGS", \
359   "GP_REGS", \
360   "R0_REGS", \
361   "RPC_REGS", \
362   "HI_REGS", \
363   "LO_REGS", \
364   "HILO_REGS", \
365   "TPREL_REGS", \
366   "GENERAL_NOT_R0_REGS", \
367   "GENERAL_REGS", \
368   "CONTROL_REGS", \
369   "CONTROL_OR_GENERAL_REGS", \
370   "USER0_REGS", \
371   "USER1_REGS", \
372   "USER2_REGS", \
373   "USER3_REGS", \
374   "LOADABLE_CR_REGS", \
375   "CR_REGS", \
376   "CCR_REGS", \
377   "ALL_REGS" }
378
379 #define REG_CLASS_CONTENTS { \
380   { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* NO_REGS */ \
381   { 0x00008000, 0x00000000, 0x00000000, 0x00000000 }, /* SP_REGS */ \
382   { 0x00002000, 0x00000000, 0x00000000, 0x00000000 }, /* TP_REGS */ \
383   { 0x00004000, 0x00000000, 0x00000000, 0x00000000 }, /* GP_REGS */ \
384   { 0x00000001, 0x00000000, 0x00000000, 0x00000000 }, /* R0_REGS */ \
385   { 0x00400000, 0x00000000, 0x00000000, 0x00000000 }, /* RPC_REGS */ \
386   { 0x00800000, 0x00000000, 0x00000000, 0x00000000 }, /* HI_REGS */ \
387   { 0x01000000, 0x00000000, 0x00000000, 0x00000000 }, /* LO_REGS */ \
388   { 0x01800000, 0x00000000, 0x00000000, 0x00000000 }, /* HILO_REGS */ \
389   { 0x000000ff, 0x00000000, 0x00000000, 0x00000000 }, /* TPREL_REGS */ \
390   { 0x0000fffe, 0x00000000, 0x00000000, 0x00000000 }, /* GENERAL_NOT_R0_REGS */ \
391   { 0x0000ffff, 0x00000000, 0x00000000, 0x00010000 }, /* GENERAL_REGS */ \
392   { 0xffff0000, 0x0000ffff, 0x00000000, 0x00000000 }, /* CONTROL_REGS */ \
393   { 0xffffffff, 0x0000ffff, 0x00000000, 0x00000000 }, /* CONTROL_OR_GENERAL_REGS */ \
394   { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* USER0_REGS */ \
395   { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* USER1_REGS */ \
396   { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* USER2_REGS */ \
397   { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* USER3_REGS */ \
398   { 0x00000000, 0xffff0000, 0x00000000, 0x00000000 }, /* LOADABLE_CR_REGS */ \
399   { 0x00000000, 0xffff0000, 0x0000ffff, 0x00000000 }, /* CR_REGS */ \
400   { 0x00000000, 0x00000000, 0xffff0000, 0x0000ffff }, /* CCR_REGS */ \
401   { 0xffffffff, 0xffffffff, 0xffffffff, 0x0001ffff }, /* ALL_REGS */ \
402   }
403
404 #define REGNO_REG_CLASS(REGNO) mep_regno_reg_class (REGNO)
405
406 #define IRA_COVER_CLASSES { GENERAL_REGS, CONTROL_REGS, CR_REGS, CCR_REGS, LIM_REG_CLASSES }
407
408 #define BASE_REG_CLASS GENERAL_REGS
409 #define INDEX_REG_CLASS GENERAL_REGS
410
411 #if 0
412 #define REG_CLASS_FROM_CONSTRAINT(CHAR, STRING) \
413         mep_reg_class_from_constraint (CHAR, STRING)
414 #endif
415
416 #define REGNO_OK_FOR_BASE_P(NUM) (GR_REGNO_P (NUM) \
417         || (NUM) == ARG_POINTER_REGNUM \
418         || (NUM) >= FIRST_PSEUDO_REGISTER)
419
420 #define REGNO_OK_FOR_INDEX_P(NUM) REGNO_OK_FOR_BASE_P (NUM)
421
422 #define PREFERRED_RELOAD_CLASS(X, CLASS) mep_preferred_reload_class (X, CLASS)
423
424 #define SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, X) \
425         mep_secondary_input_reload_class (CLASS, MODE, X)
426 #define SECONDARY_OUTPUT_RELOAD_CLASS(CLASS, MODE, X) \
427         mep_secondary_output_reload_class (CLASS, MODE, X)
428 #define SECONDARY_MEMORY_NEEDED(CLASS1, CLASS2, MODE) \
429         mep_secondary_memory_needed (CLASS1, CLASS2, MODE)
430
431 #define CLASS_MAX_NREGS(CLASS, MODE) \
432   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
433
434 #if 0
435 #define CONST_OK_FOR_LETTER_P(VALUE, C) mep_const_ok_for_letter_p (VALUE, C)
436
437 #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) 0
438
439 #define CONSTRAINT_LEN(C, STR) \
440         ((C) == 'e' ? 2 : DEFAULT_CONSTRAINT_LEN (C, STR))
441 #define EXTRA_CONSTRAINT(VALUE, C) mep_extra_constraint (VALUE, C)
442 #endif
443
444 #define WANT_GCC_DECLARATIONS
445 #include "mep-intrin.h"
446 #undef WANT_GCC_DECLARATIONS
447
448 extern int mep_intrinsic_insn[];
449 extern unsigned int mep_selected_isa;
450
451 /* True if intrinsic X is available.  X is a mep_* value declared
452    in mep-intrin.h.  */
453 #define MEP_INTRINSIC_AVAILABLE_P(X) (mep_intrinsic_insn[X] >= 0)
454
455 /* Used to define CGEN_ENABLE_INTRINSIC_P in mep-intrin.h.  */
456 #define CGEN_CURRENT_ISAS mep_selected_isa
457 #define CGEN_CURRENT_GROUP \
458   (mep_vliw_function_p (cfun->decl) ? GROUP_VLIW : GROUP_NORMAL)
459
460 \f
461
462 #define STACK_GROWS_DOWNWARD       1
463 #define FRAME_GROWS_DOWNWARD       1
464 #define STARTING_FRAME_OFFSET      0
465 #define FIRST_PARM_OFFSET(FUNDECL) 0
466 #define INCOMING_FRAME_SP_OFFSET   0
467
468 #define RETURN_ADDR_RTX(COUNT, FRAMEADDR) mep_return_addr_rtx (COUNT)
469 #define INCOMING_RETURN_ADDR_RTX          gen_rtx_REG (SImode, LP_REGNO)
470 #define DWARF_FRAME_RETURN_COLUMN         LP_REGNO
471
472 #define STACK_POINTER_REGNUM          15
473 #define FRAME_POINTER_REGNUM           8
474 #define ARG_POINTER_REGNUM            112
475 #define RETURN_ADDRESS_POINTER_REGNUM 17
476 #define STATIC_CHAIN_REGNUM            0
477
478 \f
479
480 #define ELIMINABLE_REGS                                         \
481 {                                                               \
482   {ARG_POINTER_REGNUM,   STACK_POINTER_REGNUM},                 \
483   {ARG_POINTER_REGNUM,   FRAME_POINTER_REGNUM},                 \
484   {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}                  \
485 }
486
487 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
488         (OFFSET) = mep_elimination_offset (FROM, TO)
489
490 #define ACCUMULATE_OUTGOING_ARGS 1
491
492 \f
493
494 #define FUNCTION_ARG_CALLEE_COPIES(CUM, MODE, TYPE, NAMED) 1
495
496 typedef struct
497 {
498   int nregs;
499   int vliw;
500 } CUMULATIVE_ARGS;
501
502 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, FNDECL, N_NAMED_ARGS) \
503         mep_init_cumulative_args (& (CUM), FNTYPE, LIBNAME, FNDECL)
504
505 #define FUNCTION_ARG_REGNO_P(REGNO) \
506         (((REGNO) >= 1 && (REGNO) <= 4) \
507          || ((REGNO) >= FIRST_CR_REGNO + 1 \
508              && (REGNO) <= FIRST_CR_REGNO + 4 \
509              && TARGET_COP))
510
511 #define RETURN_VALUE_REGNUM      0
512
513 #define FUNCTION_VALUE(VALTYPE, FUNC) mep_function_value (VALTYPE, FUNC)
514 #define LIBCALL_VALUE(MODE) mep_libcall_value (MODE)
515
516 #define FUNCTION_VALUE_REGNO_P(REGNO)                           \
517   ((REGNO) == RETURN_VALUE_REGNUM)
518
519 #define DEFAULT_PCC_STRUCT_RETURN 0
520
521 #define STRUCT_VALUE 0
522
523 #define FUNCTION_OK_FOR_SIBCALL(DECL) mep_function_ok_for_sibcall(DECL)
524 \f
525 /* Prologue and epilogues are all handled via RTL.  */
526
527 #define EXIT_IGNORE_STACK 1
528
529 #define EPILOGUE_USES(REGNO)  mep_epilogue_uses (REGNO)
530
531 /* Profiling is supported.  */
532      
533 #define FUNCTION_PROFILER(FILE, LABELNO) mep_function_profiler (FILE);
534 #undef TARGET_HAS_F_SETLKW
535 #define NO_PROFILE_COUNTERS 1
536 \f
537 /* Trampolines are built at run-time.  The cache is invalidated at
538    run-time also.  */
539
540 #define TRAMPOLINE_SIZE 20
541 \f
542
543 #define MAX_REGS_PER_ADDRESS 1
544
545 #ifdef REG_OK_STRICT
546 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL)                \
547         if (mep_legitimate_address ((MODE), (X), 1)) goto LABEL
548 #else
549 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL)                \
550         if (mep_legitimate_address ((MODE), (X), 0)) goto LABEL
551 #endif
552
553 #ifdef REG_OK_STRICT
554 #define REG_OK_FOR_BASE_P(X) GR_REGNO_P (REGNO (X))
555 #else
556 #define REG_OK_FOR_BASE_P(X) (GR_REGNO_P (REGNO (X)) \
557                                 || REGNO (X) == ARG_POINTER_REGNUM \
558                                 || REGNO (X) >= FIRST_PSEUDO_REGISTER)
559 #endif
560
561 #define REG_OK_FOR_INDEX_P(X) REG_OK_FOR_BASE_P (X)
562
563 #define LEGITIMIZE_RELOAD_ADDRESS(X, MODE, OPNUM, TYPE, IND_LEVELS, WIN) \
564   if (mep_legitimize_reload_address (&(X), (MODE), (OPNUM), (TYPE), (IND_LEVELS))) \
565     goto WIN
566
567 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR, LABEL)
568
569 #define LEGITIMATE_CONSTANT_P(X) \
570   mep_legitimate_constant_p(X)
571
572 #define SELECT_CC_MODE(OP, X, Y)  CCmode
573 \f
574
575 /* Moves between control regs need a scratch.  */
576 #define REGISTER_MOVE_COST(MODE, FROM, TO) mep_register_move_cost (MODE, FROM, TO)
577
578 #define SLOW_BYTE_ACCESS 1
579
580 /* Define this macro if it is as good or better to call a constant function
581    address than to call an address kept in a register.  */
582 #define NO_FUNCTION_CSE 
583
584 \f
585 #define TEXT_SECTION_ASM_OP "\t.text\n\t.core"
586 #define DATA_SECTION_ASM_OP "\t.data"
587 #define BSS_SECTION_ASM_OP  ".bss"
588
589 #define USE_SELECT_SECTION_FOR_FUNCTIONS 1
590
591 #define JUMP_TABLES_IN_TEXT_SECTION 1
592
593 #define TARGET_ASM_FILE_END mep_file_cleanups
594
595 #define ASM_APP_ON "#APP\n"
596 #define ASM_APP_OFF "#NO_APP\n"
597
598 #define ASM_OUTPUT_DOUBLE(FILE, VALUE)                          \
599   do                                                            \
600     {                                                           \
601       long l[2];                                                \
602                                                                 \
603       REAL_VALUE_TO_TARGET_DOUBLE (VALUE, l);                   \
604       fprintf (FILE, "\t.long\t0x%lx,0x%lx\n", l[0], l[1]);     \
605     }                                                           \
606   while (0)
607
608 #define ASM_OUTPUT_FLOAT(FILE, VALUE)           \
609   do                                            \
610     {                                           \
611       long l;                                   \
612                                                 \
613       REAL_VALUE_TO_TARGET_SINGLE (VALUE, l);   \
614       fprintf ((FILE), "\t.long\t0x%lx\n", l);  \
615     }                                           \
616   while (0)
617
618 #define ASM_OUTPUT_CHAR(FILE, VALUE)            \
619   do                                            \
620     {                                           \
621       fprintf (FILE, "\t.byte\t");              \
622       output_addr_const (FILE, (VALUE));        \
623       fprintf (FILE, "\n");                     \
624     }                                           \
625   while (0)
626
627 #define ASM_OUTPUT_SHORT(FILE, VALUE)           \
628   do                                            \
629     {                                           \
630       fprintf (FILE, "\t.hword\t");             \
631       output_addr_const (FILE, (VALUE));        \
632       fprintf (FILE, "\n");                     \
633     }                                           \
634   while (0)
635
636 #define ASM_OUTPUT_INT(FILE, VALUE)             \
637   do                                            \
638     {                                           \
639       fprintf (FILE, "\t.word\t");              \
640       output_addr_const (FILE, (VALUE));        \
641       fprintf (FILE, "\n");                     \
642     }                                           \
643   while (0)
644
645 #define ASM_OUTPUT_BYTE(STREAM, VALUE) \
646   fprintf (STREAM, "\t%s\t0x%x\n", ASM_BYTE_OP, (VALUE))
647
648 /* Most of these are here to support based/tiny/far/io attributes.  */
649
650 #define ASM_OUTPUT_ALIGNED_DECL_COMMON(STREAM, DECL, NAME, SIZE, ALIGNMENT) \
651         mep_output_aligned_common (STREAM, DECL, NAME, SIZE, ALIGNMENT, 1)
652
653 #define ASM_OUTPUT_ALIGNED_DECL_LOCAL(STREAM, DECL, NAME, SIZE, ALIGNMENT) \
654         mep_output_aligned_common (STREAM, DECL, NAME, SIZE, ALIGNMENT, 0)
655
656 #define ASM_OUTPUT_LABEL(STREAM, NAME)          \
657   do                                            \
658     {                                           \
659       assemble_name (STREAM, NAME);             \
660       fputs (":\n", STREAM);                    \
661     }                                           \
662   while (0)
663
664 /* Globalizing directive for a label.  */
665 #define GLOBAL_ASM_OP "\t.globl "
666
667 #define ASM_OUTPUT_LABELREF(STREAM, NAME) \
668   asm_fprintf ((STREAM), "%U%s", mep_strip_name_encoding (NAME))
669
670 #define ASM_FORMAT_PRIVATE_NAME(OUTVAR, NAME, NUMBER)           \
671   do                                                            \
672     {                                                           \
673       (OUTVAR) = (char *) alloca (strlen ((NAME)) + 12);        \
674       sprintf ((OUTVAR), "%s.%ld", (NAME), (long)(NUMBER));     \
675     }                                                           \
676   while (0)
677 \f
678
679 #define REGISTER_NAMES                                                  \
680 {                                                                       \
681   /* Core registers.  */                                                \
682   "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",                       \
683   "$8", "$9", "$10", "$11", "$12", "$tp", "$gp", "$sp",                 \
684   /* Control registers.  */                                             \
685   "$pc", "$lp", "$sar", "3", "$rpb", "$rpe", "$rpc", "$hi",             \
686   "$lo", "9", "10", "11", "$mb0", "$me0", "$mb1", "$me1",               \
687   "$psw", "$id", "$tmp", "$epc", "$exc", "$cfg", "22", "$npc",          \
688   "$dbg", "$depc", "$opt", "$rcfg", "$ccfg", "29", "30", "31",          \
689   /* Coprocessor registers.  */                                         \
690   "$c0", "$c1", "$c2", "$c3", "$c4", "$c5", "$c6", "$c7",               \
691   "$c8", "$c9", "$c10", "$c11", "$c12", "$c13", "$c14", "$c15",         \
692   "$c16", "$c17", "$c18", "$c19", "$c20", "$c21", "$c22", "$c23",       \
693   "$c24", "$c25", "$c26", "$c27", "$c28", "$c29", "$c30", "$c31",       \
694   /* Coprocessor control registers.  */                                 \
695   "$ccr0", "$ccr1", "$ccr2", "$ccr3", "$ccr4", "$ccr5", "$ccr6",        \
696   "$ccr7", "$ccr8", "$ccr9", "$ccr10", "$ccr11", "$ccr12", "$ccr13",    \
697   "$ccr14", "$ccr15", "$ccr16", "$ccr17", "$ccr18", "$ccr19", "$ccr20", \
698   "$ccr21", "$ccr22", "$ccr23", "$ccr24", "$ccr25", "$ccr26", "$ccr27", \
699   "$ccr28", "$ccr29", "$ccr30", "$ccr31",                               \
700   /* Virtual arg pointer.  */                                           \
701   "$argp", SHADOW_REGISTER_NAMES                                        \
702 }
703
704 /* We duplicate some of the above because we twiddle the above
705    according to *how* the registers are used.  Likewise, we include
706    the standard names for coprocessor control registers so that
707    coprocessor options can rename them in the default table.  Note
708    that these are compared to stripped names (see REGISTER_PREFIX
709    below).  */
710 #define ADDITIONAL_REGISTER_NAMES               \
711 {                                               \
712   {  "8",  8 }, { "fp",  8 },                   \
713   { "13", 13 }, { "tp", 13 },                   \
714   { "14", 14 }, { "gp", 14 },                   \
715   { "15", 15 }, { "sp", 15 },                   \
716   { "ccr0", FIRST_CCR_REGNO + 0 },              \
717   { "ccr1", FIRST_CCR_REGNO + 1 },              \
718   { "ccr2", FIRST_CCR_REGNO + 2 },              \
719   { "ccr3", FIRST_CCR_REGNO + 3 },              \
720   { "ccr4", FIRST_CCR_REGNO + 4 },              \
721   { "ccr5", FIRST_CCR_REGNO + 5 },              \
722   { "ccr6", FIRST_CCR_REGNO + 6 },              \
723   { "ccr7", FIRST_CCR_REGNO + 7 },              \
724   { "ccr8", FIRST_CCR_REGNO + 8 },              \
725   { "ccr9", FIRST_CCR_REGNO + 9 },              \
726   { "ccr10", FIRST_CCR_REGNO + 10 },            \
727   { "ccr11", FIRST_CCR_REGNO + 11 },            \
728   { "ccr12", FIRST_CCR_REGNO + 12 },            \
729   { "ccr13", FIRST_CCR_REGNO + 13 },            \
730   { "ccr14", FIRST_CCR_REGNO + 14 },            \
731   { "ccr15", FIRST_CCR_REGNO + 15 },            \
732   { "ccr16", FIRST_CCR_REGNO + 16 },            \
733   { "ccr17", FIRST_CCR_REGNO + 17 },            \
734   { "ccr18", FIRST_CCR_REGNO + 18 },            \
735   { "ccr19", FIRST_CCR_REGNO + 19 },            \
736   { "ccr20", FIRST_CCR_REGNO + 20 },            \
737   { "ccr21", FIRST_CCR_REGNO + 21 },            \
738   { "ccr22", FIRST_CCR_REGNO + 22 },            \
739   { "ccr23", FIRST_CCR_REGNO + 23 },            \
740   { "ccr24", FIRST_CCR_REGNO + 24 },            \
741   { "ccr25", FIRST_CCR_REGNO + 25 },            \
742   { "ccr26", FIRST_CCR_REGNO + 26 },            \
743   { "ccr27", FIRST_CCR_REGNO + 27 },            \
744   { "ccr28", FIRST_CCR_REGNO + 28 },            \
745   { "ccr29", FIRST_CCR_REGNO + 29 },            \
746   { "ccr30", FIRST_CCR_REGNO + 30 },            \
747   { "ccr31", FIRST_CCR_REGNO + 31 }             \
748 }
749
750 /* We watch for pipeline hazards with these */
751 #define ASM_OUTPUT_OPCODE(STREAM, PTR) mep_asm_output_opcode (STREAM, PTR)
752 #define FINAL_PRESCAN_INSN(INSN, OPVEC, NOPERANDS) mep_final_prescan_insn (INSN, OPVEC, NOPERANDS)
753
754 #define PRINT_OPERAND(STREAM, X, CODE) mep_print_operand (STREAM, X, CODE)
755
756 #define PRINT_OPERAND_PUNCT_VALID_P(CODE) ((CODE) == '!' || (CODE) == '<')
757
758 #define PRINT_OPERAND_ADDRESS(STREAM, X) mep_print_operand_address (STREAM, X)
759
760 #define REGISTER_PREFIX    "$"
761 #define LOCAL_LABEL_PREFIX "."
762 #define USER_LABEL_PREFIX  ""
763 #define IMMEDIATE_PREFIX   ""
764
765 \f
766
767 #define ASM_OUTPUT_ADDR_VEC_ELT(STREAM, VALUE) \
768   fprintf (STREAM, "\t.word .L%d\n", VALUE)
769
770 \f
771
772 #undef  PREFERRED_DEBUGGING_TYPE
773 #define PREFERRED_DEBUGGING_TYPE  DWARF2_DEBUG
774 #define DWARF2_DEBUGGING_INFO     1
775 #define DWARF2_UNWIND_INFO        1
776
777 #define EH_RETURN_DATA_REGNO(N) ((N) < 2 ? (N) + 10 : INVALID_REGNUM)
778
779 #define EH_RETURN_STACKADJ_RTX mep_return_stackadj_rtx ()
780 #define EH_RETURN_HANDLER_RTX  mep_return_handler_rtx ()
781
782 #define DBX_REGISTER_NUMBER(REGNO) (REGNO)
783
784 \f
785
786 #define ASM_OUTPUT_ALIGN(STREAM, POWER) \
787   fprintf ((STREAM), "\t.p2align %d\n", (POWER))
788
789 \f
790
791 #define CASE_VECTOR_MODE SImode
792
793 #define WORD_REGISTER_OPERATIONS
794 #define LOAD_EXTEND_OP(MODE) SIGN_EXTEND
795
796 #define SHORT_IMMEDIATES_SIGN_EXTEND
797
798 #define MOVE_MAX 4
799
800 #define SHIFT_COUNT_TRUNCATED 1
801
802 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
803
804 #define STORE_FLAG_VALUE 1
805
806 #define Pmode SImode
807
808 #define FUNCTION_MODE SImode
809
810 #define REGISTER_TARGET_PRAGMAS()        mep_register_pragmas ()
811
812 #define HANDLE_PRAGMA_PACK_PUSH_POP 1
813    
814 /* If defined, a C expression to determine the base term of address X.
815    This macro is used in only one place: `find_base_term' in alias.c.
816
817    It is always safe for this macro to not be defined.  It exists so
818    that alias analysis can understand machine-dependent addresses.
819
820    The typical use of this macro is to handle addresses containing
821    a label_ref or symbol_ref within an UNSPEC.  */
822 #define FIND_BASE_TERM(X) mep_find_base_term (X)