?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* doc/tm.texi (INIT_CUMULATIVE_ARGS): Update doco.
[official-gcc.git] / gcc / config / cris / cris.h
blob5110f9adbfb92484e923f0a43c5988160da6912d
1 /* Definitions for GCC. Part of the machine description for CRIS.
2 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004
3 Free Software Foundation, Inc.
4 Contributed by Axis Communications. Written by Hans-Peter Nilsson.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
22
23 /* After the first "Node:" comment comes all preprocessor directives and
24 attached declarations described in the info files, the "Using and
25 Porting GCC" manual (uapgcc), in the same order as found in the "Target
26 macros" section in the gcc-2.9x CVS edition of 2000-03-17. FIXME: Not
27 really, but needs an update anyway.
28
29 There is no generic copy-of-uapgcc comment, you'll have to see uapgcc
30 for that. If applicable, there is a CRIS-specific comment. The order
31 of macro definitions follow the order in the manual. Every section in
32 the manual (node in the info pages) has an introductory `Node:
33 <subchapter>' comment. If no macros are defined for a section, only
34 the section-comment is present. */
35
36 /* Note that other header files (e.g. config/elfos.h, config/linux.h,
37 config/cris/linux.h and config/cris/aout.h) are responsible for lots of
38 settings not repeated below. This file contains general CRIS
39 definitions and definitions for the cris-*-elf subtarget. */
40
41 /* Replacement for REG_P since it does not match SUBREGs. Happens for
42 testcase Axis-20000320 with gcc-2.9x. */
43 #define REG_S_P(x) \
44 (REG_P (x) || (GET_CODE (x) == SUBREG && REG_P (XEXP (x, 0))))
45
46 /* Last register in main register bank r0..r15. */
47 #define CRIS_LAST_GENERAL_REGISTER 15
48
49 /* Descriptions of registers used for arguments. */
50 #define CRIS_FIRST_ARG_REG 10
51 #define CRIS_MAX_ARGS_IN_REGS 4
52
53 /* Other convenience definitions. */
54 #define CRIS_PC_REGNUM 15
55 #define CRIS_SRP_REGNUM 16
56
57 /* Most of the time, we need the index into the register-names array.
58 When passing debug-info, we need the real register number. */
59 #define CRIS_CANONICAL_SRP_REGNUM (16 + 11)
60 #define CRIS_CANONICAL_MOF_REGNUM (16 + 7)
61
62 /* When generating PIC, these suffixes are added to the names of non-local
63 functions when being output. Contrary to other ports, we have offsets
64 relative to the GOT, not the PC. We might implement PC-relative PLT
65 semantics later for the general case; they are used in some cases right
66 now, such as MI thunks. */
67 #define CRIS_GOTPLT_SUFFIX ":GOTPLT"
68 #define CRIS_PLT_GOTOFFSET_SUFFIX ":PLTG"
69 #define CRIS_PLT_PCOFFSET_SUFFIX ":PLT"
70
71 /* If you tweak this, don't forget to check cris_expand_builtin_va_arg. */
72 #define CRIS_FUNCTION_ARG_SIZE(MODE, TYPE) \
73 ((MODE) != BLKmode ? GET_MODE_SIZE (MODE) \
74 : (unsigned) int_size_in_bytes (TYPE))
75
76 /* Check for max allowed stackframe. A "const char *" to be parsed. */
77 extern const char *cris_max_stackframe_str;
78
79 /* Which CPU version this is. A "const char *" to be parsed. */
80 extern const char *cris_cpu_str;
81
82 /* Which CPU version this is. The parsed and adjusted cris_cpu_str. */
83 extern int cris_cpu_version;
84
85 /* Which CPU version to tune for. A "const char *" to be parsed. */
86 extern const char *cris_tune_str;
87
88 /* The argument to "-melinux-stacksize=". We don't parse it currently;
89 it's just passed on to the linker. We might want to do something
90 here someday. */
91 extern const char *cris_elinux_stacksize_str;
92
93 /* Changing the order used to be necessary to put the fourth __make_dp
94 argument (a DImode parameter) in registers, to fit with the libfunc
95 parameter passing scheme used for intrinsic functions. FIXME: Check
96 performance and maybe remove definition from TARGET_LIBGCC2_CFLAGS now
97 that it isn't strictly necessary. We used to do this through
98 TARGET_LIBGCC2_CFLAGS, but that became increasingly difficult as the
99 parenthesis (that needed quoting) travels through several layers of
100 make and shell invocations. */
101 #ifdef IN_LIBGCC2
102 #define __make_dp(a,b,c,d) __cris_make_dp(d,a,b,c)
103 #endif
104
105
106 /* Node: Driver */
107
108 /* When using make with defaults.mak for Sun this will handily remove
109 any "-target sun*" switches. */
110 /* We need to override any previous definitions (linux.h) */
111 #undef WORD_SWITCH_TAKES_ARG
112 #define WORD_SWITCH_TAKES_ARG(STR) \
113 (DEFAULT_WORD_SWITCH_TAKES_ARG (STR) \
114 || !strcmp (STR, "target"))
115
116 /* Also provide canonical vN definitions when user specifies an alias.
117 Note that -melf overrides -maout. */
118
119 #define CPP_SPEC \
120 "%{mtune=*:-D__tune_%* %{mtune=v*:-D__CRIS_arch_tune=%*}}\
121 %{mtune=etrax4:-D__tune_v3 -D__CRIS_arch_tune=3}\
122 %{mtune=etrax100:-D__tune_v8 -D__CRIS_arch_tune=8}\
123 %{mtune=svinto:-D__tune_v8 -D__CRIS_arch_tune=8}\
124 %{mtune=etrax100lx:-D__tune_v10 -D__CRIS_arch_tune=10}\
125 %{mtune=ng:-D__tune_v10 -D__CRIS_arch_tune=10}\
126 %{mcpu=*:-D__arch_%* %{mcpu=v*:-D__CRIS_arch_version=%*}}\
127 %{mcpu=etrax4:-D__arch_v3 -D__CRIS_arch_version=3}\
128 %{mcpu=etrax100:-D__arch_v8 -D__CRIS_arch_version=8}\
129 %{mcpu=svinto:-D__arch_v8 -D__CRIS_arch_version=8}\
130 %{mcpu=etrax100lx:-D__arch_v10 -D__CRIS_arch_version=10}\
131 %{mcpu=ng:-D__arch_v10 -D__CRIS_arch_version=10}\
132 %{march=*:-D__arch_%* %{march=v*:-D__CRIS_arch_version=%*}}\
133 %{march=etrax4:-D__arch_v3 -D__CRIS_arch_version=3}\
134 %{march=etrax100:-D__arch_v8 -D__CRIS_arch_version=8}\
135 %{march=svinto:-D__arch_v8 -D__CRIS_arch_version=8}\
136 %{march=etrax100lx:-D__arch_v10 -D__CRIS_arch_version=10}\
137 %{march=ng:-D__arch_v10 -D__CRIS_arch_version=10}\
138 %{metrax100:-D__arch__v8 -D__CRIS_arch_version=8}\
139 %{metrax4:-D__arch__v3 -D__CRIS_arch_version=3}\
140 %(cpp_subtarget)"
141
142 /* For the cris-*-elf subtarget. */
143 #define CRIS_CPP_SUBTARGET_SPEC \
144 "%{mbest-lib-options:\
145 %{!moverride-best-lib-options:\
146 %{!march=*:%{!metrax*:%{!mcpu=*:-D__tune_v10 -D__CRIS_arch_tune=10}}}}}"
147
148 /* Remove those Sun-make "target" switches. */
149 /* Override previous definitions (linux.h). */
150 #undef CC1_SPEC
151 #define CC1_SPEC \
152 "%{target*:}\
153 %{metrax4:-march=v3}\
154 %{metrax100:-march=v8}\
155 %(cc1_subtarget)"
156
157 /* For the cris-*-elf subtarget. */
158 #define CRIS_CC1_SUBTARGET_SPEC \
159 "-melf\
160 %{mbest-lib-options:\
161 %{!moverride-best-lib-options:\
162 %{!march=*:%{!mcpu=*:-mtune=v10 -D__CRIS_arch_tune=10}}\
163 %{!finhibit-size-directive:\
164 %{!fno-function-sections: -ffunction-sections}\
165 %{!fno-data-sections: -fdata-sections}}}}"
166
167 /* This adds to CC1_SPEC. When bugs are removed from -fvtable-gc
168 (-fforce-addr causes invalid .vtable_entry asm in tinfo.cc and
169 nothing at all works in GCC 3.0-pre), add this line:
170 "%{mbest-lib-options:%{!moverride-best-lib-options:\
171 %{!melinux:%{!maout|melf:%{!fno-vtable-gc:-fvtable-gc}}}}}". */
172 #define CC1PLUS_SPEC ""
173
174 /* Override previous definitions (linux.h). */
175 #undef ASM_SPEC
176 #define ASM_SPEC \
177 "%{v:-v}\
178 %(asm_subtarget)"
179
180 /* For the cris-*-elf subtarget. */
181 #define CRIS_ASM_SUBTARGET_SPEC "--em=criself"
182
183 /* FIXME: We should propagate the -melf option to make the criself
184 "emulation" unless a linker script is provided (-T*), but I don't know
185 how to do that if either of -Ttext, -Tdata or -Tbss is given but no
186 linker script, as is usually the case. Leave it to the user for the
187 time being.
188
189 Note that -melf overrides -maout except that a.out-compiled libraries
190 are linked in (multilibbing). The somewhat cryptic -rpath-link pair is
191 to avoid *only* picking up the linux multilib subdir from the "-B./"
192 option during build, while still giving it preference. We'd need some
193 %s-variant that checked for existence of some specific file. */
194 /* Override previous definitions (svr4.h). */
195 #undef LINK_SPEC
196 #define LINK_SPEC \
197 "%{v:--verbose}\
198 %(link_subtarget)"
199
200 /* For the cris-*-elf subtarget. */
201 #define CRIS_LINK_SUBTARGET_SPEC \
202 "-mcriself\
203 %{sim2:%{!T*:-Tdata 0x4000000 -Tbss 0x8000000}}\
204 %{!r:%{O2|O3: --gc-sections}}"
205
206 /* Which library to get. The only difference from the default is to get
207 libsc.a if -sim is given to the driver. Repeat -lc -lsysX
208 {X=sim,linux}, because libsysX needs (at least) errno from libc, and
209 then we want to resolve new unknowns in libc against libsysX, not
210 libnosys. */
211 /* Override previous definitions (linux.h). */
212 #undef LIB_SPEC
213 #define LIB_SPEC \
214 "%{sim*:-lc -lsyssim -lc -lsyssim}\
215 %{!sim*:%{g*:-lg}\
216 %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p} -lbsp}\
217 -lnosys"
218
219 /* Linker startfile options; crt0 flavors.
220
221 At the moment there are no gcrt0.o or mcrt0.o, but keep them here and
222 link them to crt0.o to be prepared. Use scrt0.c if running the
223 simulator, linear style, or s2crt0.c if fixed style. */
224 /* We need to remove any previous definition (elfos.h). */
225 #undef STARTFILE_SPEC
226 #define STARTFILE_SPEC \
227 "%{sim2:s2crt0.o%s}\
228 %{!sim2:%{sim:scrt0.o%s}\
229 %{!sim:%{pg:gcrt0.o%s}\
230 %{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}}}\
231 crtbegin.o%s"
232
233 #undef ENDFILE_SPEC
234 #define ENDFILE_SPEC "crtend.o%s"
235
236 #define EXTRA_SPECS \
237 {"cpp_subtarget", CRIS_CPP_SUBTARGET_SPEC}, \
238 {"cc1_subtarget", CRIS_CC1_SUBTARGET_SPEC}, \
239 {"asm_subtarget", CRIS_ASM_SUBTARGET_SPEC}, \
240 {"link_subtarget", CRIS_LINK_SUBTARGET_SPEC}, \
241 CRIS_SUBTARGET_EXTRA_SPECS
242
243 #define CRIS_SUBTARGET_EXTRA_SPECS
244
245
246 /* Node: Run-time Target */
247
248 #define TARGET_CPU_CPP_BUILTINS() \
249 do \
250 { \
251 builtin_define_std ("cris"); \
252 builtin_define_std ("CRIS"); \
253 builtin_define_std ("GNU_CRIS"); \
254 builtin_define ("__CRIS_ABI_version=2"); \
255 builtin_assert ("cpu=cris"); \
256 builtin_assert ("machine=cris"); \
257 } \
258 while (0)
259
260 /* This needs to be at least 32 bits. */
261 extern int target_flags;
262
263 /* Currently this just affects alignment. FIXME: Redundant with
264 TARGET_ALIGN_BY_32, or put machine stuff here? */
265 #define TARGET_MASK_SVINTO 1
266 #define TARGET_SVINTO (target_flags & TARGET_MASK_SVINTO)
267
268 /* If to use condition-codes generated by insns other than the
269 immediately preceding compare/test insn.
270 Used to check for errors in notice_update_cc. */
271 #define TARGET_MASK_CCINIT 2
272 #define TARGET_CCINIT (target_flags & TARGET_MASK_CCINIT)
273
274 /* Debug option. */
275 #define TARGET_MASK_PDEBUG 4
276 #define TARGET_PDEBUG (target_flags & TARGET_MASK_PDEBUG)
277
278 /* If to use side-effect patterns. Used to debug the [rx=ry+i] type
279 patterns. */
280 #define TARGET_MASK_SIDE_EFFECT_PREFIXES 8
281 #define TARGET_SIDE_EFFECT_PREFIXES \
282 (target_flags & TARGET_MASK_SIDE_EFFECT_PREFIXES)
283
284 /* If to expand mul into mstep. Only used when making libc.a. */
285 #define TARGET_MASK_EXPAND_MUL 16
286 #define TARGET_EXPAND_MUL (target_flags & TARGET_MASK_EXPAND_MUL)
287
288 /* If to *keep* (not force) alignment of stack at 16 bits. */
289 #define TARGET_MASK_STACK_ALIGN 32
290 #define TARGET_STACK_ALIGN (target_flags & TARGET_MASK_STACK_ALIGN)
291
292 /* If to do alignment on individual non-modifiable objects. */
293 #define TARGET_MASK_CONST_ALIGN 64
294 #define TARGET_CONST_ALIGN (target_flags & TARGET_MASK_CONST_ALIGN)
295
296 /* If to do alignment on individual modifiable objects. */
297 #define TARGET_MASK_DATA_ALIGN 128
298 #define TARGET_DATA_ALIGN (target_flags & TARGET_MASK_DATA_ALIGN)
299
300 /* If not to omit function prologue and epilogue. */
301 #define TARGET_MASK_PROLOGUE_EPILOGUE 256
302 #define TARGET_PROLOGUE_EPILOGUE (target_flags & TARGET_MASK_PROLOGUE_EPILOGUE)
303
304 /* Instructions additions from Etrax 4 and up.
305 (Just "lz", which we don't really generate from GCC -- yet). */
306 #define TARGET_MASK_ETRAX4_ADD 512
307 #define TARGET_ETRAX4_ADD (target_flags & TARGET_MASK_ETRAX4_ADD)
308
309 /* Say that all alignment specifications say to prefer 32 rather
310 than 16 bits. */
311 #define TARGET_MASK_ALIGN_BY_32 1024
312 #define TARGET_ALIGN_BY_32 (target_flags & TARGET_MASK_ALIGN_BY_32)
313
314 /* This condition is of limited use, as gcc is riddled with #ifdef:s
315 controlling this, rather than if (...):s. */
316 #define TARGET_MASK_ELF 2048
317 #define TARGET_ELF (target_flags & TARGET_MASK_ELF)
318
319 /* Currently just used to error-check other options. Note that this is
320 *not* set for -melinux. */
321 #define TARGET_MASK_LINUX 4096
322 #define TARGET_LINUX (target_flags & TARGET_MASK_LINUX)
323
324 /* There's a small setup cost with using GOTPLT references, but should
325 in total be a win both in code-size and execution-time. */
326 #define TARGET_MASK_AVOID_GOTPLT 8192
327 #define TARGET_AVOID_GOTPLT (target_flags & TARGET_MASK_AVOID_GOTPLT)
328
329 #define TARGET_SWITCHES \
330 { \
331 /* No "no-etrax" as it does not really imply any model. \
332 On the other hand, "etrax" implies the common (and large) \
333 subset matching all models. */ \
334 {"etrax4", TARGET_MASK_ETRAX4_ADD, \
335 N_("Compile for ETRAX 4 (CRIS v3)")}, \
336 {"no-etrax4", -TARGET_MASK_ETRAX4_ADD, ""}, \
337 {"etrax100", (TARGET_MASK_SVINTO \
338 + TARGET_MASK_ETRAX4_ADD \
339 + TARGET_MASK_ALIGN_BY_32), \
340 N_("Compile for ETRAX 100 (CRIS v8)")}, \
341 {"no-etrax100", -(TARGET_MASK_SVINTO \
342 + TARGET_MASK_ETRAX4_ADD), ""}, \
343 {"pdebug", TARGET_MASK_PDEBUG, \
344 N_("Emit verbose debug information in assembly code")}, \
345 {"no-pdebug", -TARGET_MASK_PDEBUG, ""}, \
346 {"cc-init", TARGET_MASK_CCINIT, \
347 N_("Do not use condition codes from normal instructions")}, \
348 {"no-cc-init", -TARGET_MASK_CCINIT, ""}, \
349 {"side-effects", TARGET_MASK_SIDE_EFFECT_PREFIXES, ""}, \
350 {"no-side-effects", -TARGET_MASK_SIDE_EFFECT_PREFIXES, \
351 N_("Do not emit addressing modes with side-effect assignment")}, \
352 {"stack-align", TARGET_MASK_STACK_ALIGN, ""}, \
353 {"no-stack-align", -TARGET_MASK_STACK_ALIGN, \
354 N_("Do not tune stack alignment")}, \
355 {"data-align", TARGET_MASK_DATA_ALIGN, ""}, \
356 {"no-data-align", -TARGET_MASK_DATA_ALIGN, \
357 N_("Do not tune writable data alignment")}, \
358 {"const-align", TARGET_MASK_CONST_ALIGN, ""}, \
359 {"no-const-align", -TARGET_MASK_CONST_ALIGN, \
360 N_("Do not tune code and read-only data alignment")}, \
361 {"32-bit", (TARGET_MASK_STACK_ALIGN \
362 + TARGET_MASK_CONST_ALIGN \
363 + TARGET_MASK_DATA_ALIGN \
364 + TARGET_MASK_ALIGN_BY_32), ""}, \
365 {"32bit", (TARGET_MASK_STACK_ALIGN \
366 + TARGET_MASK_CONST_ALIGN \
367 + TARGET_MASK_DATA_ALIGN \
368 + TARGET_MASK_ALIGN_BY_32), \
369 N_("Align code and data to 32 bits")}, \
370 {"16-bit", (TARGET_MASK_STACK_ALIGN \
371 + TARGET_MASK_CONST_ALIGN \
372 + TARGET_MASK_DATA_ALIGN), ""}, \
373 {"16bit", (TARGET_MASK_STACK_ALIGN \
374 + TARGET_MASK_CONST_ALIGN \
375 + TARGET_MASK_DATA_ALIGN), ""}, \
376 {"8-bit", -(TARGET_MASK_STACK_ALIGN \
377 + TARGET_MASK_CONST_ALIGN \
378 + TARGET_MASK_DATA_ALIGN), ""}, \
379 {"8bit", -(TARGET_MASK_STACK_ALIGN \
380 + TARGET_MASK_CONST_ALIGN \
381 + TARGET_MASK_DATA_ALIGN), \
382 N_("Don't align items in code or data")}, \
383 {"prologue-epilogue", TARGET_MASK_PROLOGUE_EPILOGUE, ""}, \
384 {"no-prologue-epilogue", -TARGET_MASK_PROLOGUE_EPILOGUE, \
385 N_("Do not emit function prologue or epilogue")}, \
386 /* We have to handle this m-option here since we can't wash it off in \
387 both CC1_SPEC and CC1PLUS_SPEC. */ \
388 {"best-lib-options", 0, \
389 N_("Use the most feature-enabling options allowed by other options")}, \
390 \
391 /* We must call it "override-" since calling it "no-" will cause \
392 gcc.c to forget it, if there's a "later" -mbest-lib-options. \
393 Kludgy, but needed for some multilibbed files. */ \
394 {"override-best-lib-options", 0, \
395 N_("Override -mbest-lib-options")}, \
396 CRIS_SUBTARGET_SWITCHES \
397 {"", TARGET_DEFAULT | CRIS_SUBTARGET_DEFAULT, ""}} \
398
399 /* For the cris-*-elf subtarget. */
400 #define CRIS_SUBTARGET_SWITCHES \
401 {"elf", 0, ""},
402
403 /* Default target_flags if no switches specified. */
404 #ifndef TARGET_DEFAULT
405 # define TARGET_DEFAULT \
406 (TARGET_MASK_SIDE_EFFECT_PREFIXES + TARGET_MASK_STACK_ALIGN \
407 + TARGET_MASK_CONST_ALIGN + TARGET_MASK_DATA_ALIGN \
408 + TARGET_MASK_PROLOGUE_EPILOGUE)
409 #endif
410
411 /* For the cris-*-elf subtarget. */
412 #define CRIS_SUBTARGET_DEFAULT TARGET_MASK_ELF
413
414 #define CRIS_CPU_BASE 0
415 #define CRIS_CPU_ETRAX4 3 /* Just lz added. */
416 #define CRIS_CPU_SVINTO 8 /* Added swap, jsrc & Co., 32-bit accesses. */
417 #define CRIS_CPU_NG 10 /* Added mul[su]. */
418
419 /* Local, providing a default for cris_cpu_version. */
420 #define CRIS_DEFAULT_CPU_VERSION CRIS_CPU_BASE
421
422 #define TARGET_HAS_MUL_INSNS (cris_cpu_version >= CRIS_CPU_NG)
423
424 #define TARGET_OPTIONS \
425 {{"cpu=", &cris_cpu_str, "", 0}, \
426 {"arch=", &cris_cpu_str, \
427 N_("Generate code for the specified chip or CPU version"), 0}, \
428 {"tune=", &cris_tune_str, \
429 N_("Tune alignment for the specified chip or CPU version"), 0}, \
430 {"max-stackframe=", &cris_max_stackframe_str, \
431 N_("Warn when a stackframe is larger than the specified size"), 0}, \
432 CRIS_SUBTARGET_LONG_OPTIONS \
433 {"ax-stackframe=", &cris_max_stackframe_str, "", 0} }
434
435 #define CRIS_SUBTARGET_LONG_OPTIONS
436
437 /* Print subsidiary information on the compiler version in use.
438 Do not use VD.D syntax (D=digit), since this will cause confusion
439 with the base gcc version among users, when we ask which version of
440 gcc-cris they are using. Please use some flavor of "R<number>" for
441 the version (no need for major.minor versions, I believe). */
442 #define TARGET_VERSION \
443 fprintf (stderr, " [Axis CRIS%s]", CRIS_SUBTARGET_VERSION)
444
445 /* For the cris-*-elf subtarget. */
446 #define CRIS_SUBTARGET_VERSION " - generic ELF"
447
448 #define OVERRIDE_OPTIONS cris_override_options ()
449
450 /* The following gives optimal code for gcc-2.7.2, but *may* be subject
451 to change. Omitting flag_force_addr gives .1-.7% faster code for gcc
452 *only*, but 1.3% larger code. On ipps it gives 5.3-10.6% slower
453 code(!) and 0.3% larger code. For products, images gets .1-1.8%
454 larger. Do not set strict aliasing from optimization options. */
455 #define OPTIMIZATION_OPTIONS(OPTIMIZE, SIZE) \
456 do \
457 { \
458 if ((OPTIMIZE) >= 2 || (SIZE)) \
459 { \
460 flag_force_addr = 1; \
461 flag_omit_frame_pointer = 1; \
462 } \
463 } \
464 while (0)
465
466
467 /* Node: Storage Layout */
468
469 #define BITS_BIG_ENDIAN 0
470
471 #define BYTES_BIG_ENDIAN 0
472
473 /* WORDS_BIG_ENDIAN is not defined in the hardware, but for consistency,
474 we use little-endianness, and we may also be able to use
475 post-increment on DImode indirect. */
476 #define WORDS_BIG_ENDIAN 0
477
478 #define UNITS_PER_WORD 4
479
480 /* A combination of defining PROMOTE_MODE,
481 TARGET_PROMOTE_FUNCTION_ARGS that always returns true,
482 PROMOTE_FOR_CALL_ONLY and *not* defining TARGET_PROMOTE_PROTOTYPES gives the
483 best code size and speed for gcc, ipps and products in gcc-2.7.2. */
484 #define CRIS_PROMOTED_MODE(MODE, UNSIGNEDP, TYPE) \
485 (GET_MODE_CLASS (MODE) == MODE_INT && GET_MODE_SIZE (MODE) < 4) \
486 ? SImode : MODE
487
488 #define PROMOTE_MODE(MODE, UNSIGNEDP, TYPE) \
489 (MODE) = CRIS_PROMOTED_MODE (MODE, UNSIGNEDP, TYPE)
490
491 /* Defining PROMOTE_FUNCTION_RETURN in gcc-2.7.2 uncovers bug 981110 (even
492 if defining FUNCTION_VALUE with MODE as PROMOTED_MODE ;-)
493
494 FIXME: Report this when cris.h is part of GCC, so others can easily
495 see the problem. Maybe check other systems that define
496 TARGET_PROMOTE_FUNCTION_RETURN that always returns true. */
497 #define PROMOTE_FOR_CALL_ONLY
498
499 /* We will be using prototype promotion, so they will be 32 bit. */
500 #define PARM_BOUNDARY 32
501
502 /* Stack boundary is guided by -mstack-align, -mno-stack-align,
503 -malign.
504 Old comment: (2.1: still valid in 2.7.2?)
505 Note that to make this macro affect the alignment of stack
506 locals, a fix was required, and special precautions when handling
507 the stack pointer in various other macros (TARGET_ASM_FUNCTION_PROLOGUE
508 et al) were required. See file "function.c". If you would just define
509 this macro, it would only affect the builtin alloca and variable
510 local data (non-ANSI, non-K&R, Gnu C extension). */
511 #define STACK_BOUNDARY \
512 (TARGET_STACK_ALIGN ? (TARGET_ALIGN_BY_32 ? 32 : 16) : 8)
513
514 #define FUNCTION_BOUNDARY 16
515
516 /* Do not change BIGGEST_ALIGNMENT (when optimizing), as it will affect
517 strange places, at least in 2.1. */
518 #define BIGGEST_ALIGNMENT 8
519
520 /* If -m16bit, -m16-bit, -malign or -mdata-align,
521 align everything to 16 bit. */
522 #define DATA_ALIGNMENT(TYPE, BASIC_ALIGN) \
523 (TARGET_DATA_ALIGN \
524 ? (TARGET_ALIGN_BY_32 \
525 ? (BASIC_ALIGN < 32 ? 32 : BASIC_ALIGN) \
526 : (BASIC_ALIGN < 16 ? 16 : BASIC_ALIGN)) : BASIC_ALIGN)
527
528 /* Note that CONSTANT_ALIGNMENT has the effect of making gcc believe that
529 ALL references to constant stuff (in code segment, like strings) has
530 this alignment. That is a rather rushed assumption. Luckily we do not
531 care about the "alignment" operand to builtin memcpy (only place where
532 it counts), so it doesn't affect any bad spots. */
533 #define CONSTANT_ALIGNMENT(CONSTANT, BASIC_ALIGN) \
534 (TARGET_CONST_ALIGN \
535 ? (TARGET_ALIGN_BY_32 \
536 ? (BASIC_ALIGN < 32 ? 32 : BASIC_ALIGN) \
537 : (BASIC_ALIGN < 16 ? 16 : BASIC_ALIGN)) : BASIC_ALIGN)
538
539 /* FIXME: Define LOCAL_ALIGNMENT for word and dword or arrays and
540 structures (if -mstack-align=), and check that it is good. */
541
542 #define EMPTY_FIELD_BOUNDARY 8
543
544 #define STRUCTURE_SIZE_BOUNDARY 8
545
546 #define STRICT_ALIGNMENT 0
547
548 /* Remove any previous definition (elfos.h).
549 ??? If it wasn't for all the other stuff that affects layout of
550 structures and bit-fields, this could presumably cause incompatibility
551 with other GNU/Linux ports (i.e. elfos.h users). */
552 #undef PCC_BITFIELD_TYPE_MATTERS
553
554 /* This is only used for non-scalars. Strange stuff happens to structs
555 (FIXME: What?) if we use anything larger than largest actually used
556 datum size, so lets make it 32. The type "long long" will still work
557 as usual. We can still have DImode insns, but they will only be used
558 for scalar data (i.e. long long). */
559 #define MAX_FIXED_MODE_SIZE 32
560
561
562 /* Node: Type Layout */
563
564 /* Note that DOUBLE_TYPE_SIZE is not defined anymore, since the default
565 value gives a 64-bit double, which is what we now use. */
566
567 /* For compatibility and historical reasons, a char should be signed. */
568 #define DEFAULT_SIGNED_CHAR 1
569
570 /* No DEFAULT_SHORT_ENUMS, please. */
571
572 /* Note that WCHAR_TYPE_SIZE is used in cexp.y,
573 where TARGET_SHORT is not available. */
574 #undef WCHAR_TYPE
575 #define WCHAR_TYPE "long int"
576
577 #undef WCHAR_TYPE_SIZE
578 #define WCHAR_TYPE_SIZE 32
579
580
581 /* Node: Register Basics */
582
583 /* We count all 16 non-special registers, SRP and a faked argument
584 pointer register. */
585 #define FIRST_PSEUDO_REGISTER (16 + 1 + 1)
586
587 /* For CRIS, these are r15 (pc) and r14 (sp). Register r8 is used as a
588 frame-pointer, but is not fixed. SRP is not included in general
589 registers and will not be used automatically. All other special
590 registers are fixed at the moment. The faked argument pointer register
591 is fixed too. */
592 #define FIXED_REGISTERS \
593 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1}
594
595 /* Register r9 is used for structure-address, r10-r13 for parameters,
596 r10- for return values. */
597 #define CALL_USED_REGISTERS \
598 {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1}
599
600 #define CONDITIONAL_REGISTER_USAGE cris_conditional_register_usage ()
601
602
603 /* Node: Allocation Order */
604
605 /* We need this on CRIS, because call-used regs should be used first,
606 (so we don't need to push). Else start using registers from r0 and up.
607 This preference is mainly because if we put call-used-regs from r0
608 and up, then we can't use movem to push the rest, (which have to be
609 saved if we use them, and movem has to start with r0).
610 Change here if you change which registers to use as call registers.
611
612 The actual need to explicitly prefer call-used registers improved the
613 situation a lot for 2.1, but might not actually be needed anymore.
614 Still, this order reflects what GCC should find out by itself, so it
615 probably does not hurt.
616
617 Order of preference: Call-used-regs first, then r0 and up, last fp &
618 sp & pc as fillers.
619 Call-used regs in opposite order, so they will cause less conflict if
620 a function has few args (<= 3) and it wants a scratch reg.
621 Use struct-return address first, since very few functions use
622 structure return values so it is likely to be available. */
623 #define REG_ALLOC_ORDER \
624 {9, 13, 12, 11, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 14, 15, 16, 17}
625
626
627 /* Node: Values in Registers */
628
629 /* The VOIDmode test is so we can omit mode on anonymous insns. FIXME:
630 Still needed in 2.9x, at least for Axis-20000319. */
631 #define HARD_REGNO_NREGS(REGNO, MODE) \
632 (MODE == VOIDmode \
633 ? 1 : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD))
634
635 /* CRIS permits all registers to hold all modes. */
636 #define HARD_REGNO_MODE_OK(REGNO, MODE) 1
637
638 #define MODES_TIEABLE_P(MODE1, MODE2) 1
639
640
641 /* Node: Leaf Functions */
642 /* (no definitions) */
643
644 /* Node: Stack Registers */
645 /* (no definitions) */
646
647
648 /* Node: Register Classes */
649
650 /* CRIS has only one kind of registers, so NO_REGS and ALL_REGS
651 are the only classes. FIXME: It actually makes sense to have another
652 class for special registers, and yet another class for the
653 multiply-overflow register in v10; then a class for the return
654 register also makes sense. */
655 enum reg_class {NO_REGS, ALL_REGS, LIM_REG_CLASSES};
656
657 #define N_REG_CLASSES (int) LIM_REG_CLASSES
658
659 #define REG_CLASS_NAMES {"NO_REGS", "ALL_REGS"}
660
661 #define GENERAL_REGS ALL_REGS
662
663 /* Count in the faked argument register in GENERAL_REGS. Keep out SRP. */
664 #define REG_CLASS_CONTENTS {{0}, {0x2ffff}}
665
666 #define REGNO_REG_CLASS(REGNO) GENERAL_REGS
667
668 #define BASE_REG_CLASS GENERAL_REGS
669
670 #define INDEX_REG_CLASS GENERAL_REGS
671
672 /* Get reg_class from a letter such as appears in the machine
673 description. No letters are used, since 'r' is used for any
674 register. */
675 #define REG_CLASS_FROM_LETTER(C) NO_REGS
676
677 /* Since it uses reg_renumber, it is safe only once reg_renumber
678 has been allocated, which happens in local-alloc.c. */
679 #define REGNO_OK_FOR_BASE_P(REGNO) \
680 ((REGNO) <= CRIS_LAST_GENERAL_REGISTER \
681 || (REGNO) == ARG_POINTER_REGNUM \
682 || (unsigned) reg_renumber[REGNO] <= CRIS_LAST_GENERAL_REGISTER \
683 || (unsigned) reg_renumber[REGNO] == ARG_POINTER_REGNUM)
684
685 /* See REGNO_OK_FOR_BASE_P. */
686 #define REGNO_OK_FOR_INDEX_P(REGNO) REGNO_OK_FOR_BASE_P(REGNO)
687
688 /* It seems like gcc (2.7.2 and 2.9x of 2000-03-22) may send "NO_REGS" as
689 the class for a constant (testcase: __Mul in arit.c). To avoid forcing
690 out a constant into the constant pool, we will trap this case and
691 return something a bit more sane. FIXME: Check if this is a bug. */
692 #define PREFERRED_RELOAD_CLASS(X, CLASS) \
693 ((CLASS) == NO_REGS ? GENERAL_REGS : (CLASS))
694
695 /* For CRIS, this is always the size of MODE in words,
696 since all registers are the same size. To use omitted modes in
697 patterns with reload constraints, you must say the widest size
698 which is allowed for VOIDmode.
699 FIXME: Does that still apply for gcc-2.9x? Keep poisoned until such
700 patterns are added back. News: 2001-03-16: Happens as early as the
701 underscore-test. */
702 #define CLASS_MAX_NREGS(CLASS, MODE) \
703 ((MODE) == VOIDmode \
704 ? 1 /* + cris_fatal ("CLASS_MAX_NREGS with VOIDmode") */ \
705 : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD))
706
707 /* We are now out of letters; we could use ten more. This forces us to
708 use C-code in the 'md' file. FIXME: Use some EXTRA_CONSTRAINTS. */
709 #define CONST_OK_FOR_LETTER_P(VALUE, C) \
710 ( \
711 /* MOVEQ, CMPQ, ANDQ, ORQ. */ \
712 (C) == 'I' ? (VALUE) >= -32 && (VALUE) <= 31 : \
713 /* ADDQ, SUBQ. */ \
714 (C) == 'J' ? (VALUE) >= 0 && (VALUE) <= 63 : \
715 /* ASRQ, BTSTQ, LSRQ, LSLQ. */ \
716 (C) == 'K' ? (VALUE) >= 0 && (VALUE) <= 31 : \
717 /* A 16-bit signed number. */ \
718 (C) == 'L' ? (VALUE) >= -32768 && (VALUE) <= 32767 : \
719 /* The constant 0 for CLEAR. */ \
720 (C) == 'M' ? (VALUE) == 0 : \
721 /* A negative ADDQ or SUBQ. */ \
722 (C) == 'N' ? (VALUE) >= -63 && (VALUE) < 0 : \
723 /* Quickened ints, QI and HI. */ \
724 (C) == 'O' ? (VALUE) >= 0 && (VALUE) <= 65535 \
725 && ((VALUE) >= (65535-31) \
726 || ((VALUE) >= (255-31) \
727 && (VALUE) <= 255 )) : \
728 /* A 16-bit number signed *or* unsigned. */ \
729 (C) == 'P' ? (VALUE) >= -32768 && (VALUE) <= 65535 : \
730 0)
731
732 /* It is really simple to make up a 0.0; it is the same as int-0 in
733 IEEE754. */
734 #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) \
735 ((C) == 'G' && ((VALUE) == CONST0_RTX (DFmode) \
736 || (VALUE) == CONST0_RTX (SFmode)))
737
738 /* We need this on cris to distinguish delay-slottable addressing modes. */
739 #define EXTRA_CONSTRAINT(X, C) \
740 ( \
741 /* Slottable address mode? */ \
742 (C) == 'Q' ? EXTRA_CONSTRAINT_Q (X) : \
743 /* Operand to BDAP or BIAP? */ \
744 (C) == 'R' ? EXTRA_CONSTRAINT_R (X) : \
745 /* A local PIC symbol? */ \
746 (C) == 'S' ? EXTRA_CONSTRAINT_S (X) : \
747 /* A three-address addressing-mode? */ \
748 (C) == 'T' ? EXTRA_CONSTRAINT_T (X) : \
749 /* A global PIC symbol? */ \
750 (C) == 'U' ? EXTRA_CONSTRAINT_U (X) : \
751 0)
752
753 #define EXTRA_CONSTRAINT_Q(X) \
754 ( \
755 /* Slottable addressing modes: \
756 A register? FIXME: Unnecessary. */ \
757 (BASE_P (X) && REGNO (X) != CRIS_PC_REGNUM) \
758 /* Indirect register: [reg]? */ \
759 || (GET_CODE (X) == MEM && BASE_P (XEXP (X, 0)) \
760 && REGNO (XEXP (X, 0)) != CRIS_PC_REGNUM) \
761 )
762
763 #define EXTRA_CONSTRAINT_R(X) \
764 ( \
765 /* An operand to BDAP or BIAP: \
766 A BIAP; r.S? */ \
767 BIAP_INDEX_P (X) \
768 /* A [reg] or (int) [reg], maybe with post-increment. */ \
769 || BDAP_INDEX_P (X) \
770 || CONSTANT_INDEX_P (X) \
771 )
772
773 #define EXTRA_CONSTRAINT_T(X) \
774 ( \
775 /* Memory three-address operand. All are indirect-memory: */ \
776 GET_CODE (X) == MEM \
777 && ((GET_CODE (XEXP (X, 0)) == MEM \
778 /* Double indirect: [[reg]] or [[reg+]]? */ \
779 && (BASE_OR_AUTOINCR_P (XEXP (XEXP (X, 0), 0)))) \
780 /* Just an explicit indirect reference: [const]? */ \
781 || CONSTANT_P (XEXP (X, 0)) \
782 /* Something that is indexed; [...+...]? */ \
783 || (GET_CODE (XEXP (X, 0)) == PLUS \
784 /* A BDAP constant: [reg+(8|16|32)bit offset]? */ \
785 && ((BASE_P (XEXP (XEXP (X, 0), 0)) \
786 && CONSTANT_INDEX_P (XEXP (XEXP (X, 0), 1))) \
787 /* Swap arguments to the above. FIXME: gcc-2.9x? */ \
788 || (BASE_P (XEXP (XEXP (X, 0), 1)) \
789 && CONSTANT_INDEX_P (XEXP (XEXP (X, 0), 0))) \
790 /* A BDAP register: [reg+[reg(+)].S]? */ \
791 || (BASE_P (XEXP (XEXP (X, 0), 0)) \
792 && BDAP_INDEX_P(XEXP(XEXP(X, 0), 1))) \
793 /* Same, but with swapped arguments. */ \
794 || (BASE_P (XEXP (XEXP (X, 0), 1)) \
795 && BDAP_INDEX_P (XEXP (XEXP (X, 0), 0))) \
796 /* A BIAP: [reg+reg.S]. */ \
797 || (BASE_P (XEXP (XEXP (X, 0), 0)) \
798 && BIAP_INDEX_P (XEXP (XEXP (X, 0), 1))) \
799 /* Same, but with swapped arguments. */ \
800 || (BASE_P (XEXP (XEXP (X, 0), 1)) \
801 && BIAP_INDEX_P (XEXP (XEXP (X, 0), 0)))))) \
802 )
803
804 #define EXTRA_CONSTRAINT_S(X) \
805 (flag_pic && CONSTANT_P (X) && cris_gotless_symbol (X))
806
807 #define EXTRA_CONSTRAINT_U(X) \
808 (flag_pic && CONSTANT_P (X) && cris_got_symbol (X))
809
810
811 /* Node: Frame Layout */
812
813 #define STACK_GROWS_DOWNWARD
814 #define FRAME_GROWS_DOWNWARD
815
816 /* It seems to be indicated in the code (at least 2.1) that this is
817 better a constant, and best 0. */
818 #define STARTING_FRAME_OFFSET 0
819
820 #define FIRST_PARM_OFFSET(FNDECL) 0
821
822 #define RETURN_ADDR_RTX(COUNT, FRAMEADDR) \
823 cris_return_addr_rtx (COUNT, FRAMEADDR)
824
825 #define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (Pmode, CRIS_SRP_REGNUM)
826
827 /* FIXME: Any __builtin_eh_return callers must not return anything and
828 there must not be collisions with incoming parameters. Luckily the
829 number of __builtin_eh_return callers is limited. For now return
830 parameter registers in reverse order and hope for the best. */
831 #define EH_RETURN_DATA_REGNO(N) \
832 (IN_RANGE ((N), 0, 3) ? (CRIS_FIRST_ARG_REG + 3 - (N)) : INVALID_REGNUM)
833
834 /* Store the stack adjustment in the structure-return-address register. */
835 #define CRIS_STACKADJ_REG CRIS_STRUCT_VALUE_REGNUM
836 #define EH_RETURN_STACKADJ_RTX gen_rtx_REG (SImode, CRIS_STACKADJ_REG)
837
838 #define EH_RETURN_HANDLER_RTX \
839 cris_return_addr_rtx (0, NULL)
840
841 #define INIT_EXPANDERS cris_init_expanders ()
842
843 /* FIXME: Move this to right node (it's not documented properly yet). */
844 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (CRIS_SRP_REGNUM)
845
846 /* FIXME: Move this to right node (it's not documented properly yet).
847 FIXME: Check what alignment we can assume regarding
848 TARGET_STACK_ALIGN and TARGET_ALIGN_BY_32. */
849 #define DWARF_CIE_DATA_ALIGNMENT -1
850
851 /* If we would ever need an exact mapping between canonical register
852 number and dwarf frame register, we would either need to include all
853 registers in the gcc description (with some marked fixed of course), or
854 an inverse mapping from dwarf register to gcc register. There is one
855 need in dwarf2out.c:expand_builtin_init_dwarf_reg_sizes. Right now, I
856 don't see that we need exact correspondence between DWARF *frame*
857 registers and DBX_REGISTER_NUMBER, so map them onto GCC registers. */
858 #define DWARF_FRAME_REGNUM(REG) (REG)
859
860 /* Node: Stack Checking */
861 /* (no definitions) FIXME: Check. */
862
863 /* Node: Frame Registers */
864
865 #define STACK_POINTER_REGNUM 14
866
867 /* Register used for frame pointer. This is also the last of the saved
868 registers, when a frame pointer is not used. */
869 #define FRAME_POINTER_REGNUM 8
870
871 /* Faked register, is always eliminated. We need it to eliminate
872 allocating stack slots for the return address and the frame pointer. */
873 #define ARG_POINTER_REGNUM 17
874
875 #define STATIC_CHAIN_REGNUM 7
876
877
878 /* Node: Elimination */
879
880 /* Really only needed if the stack frame has variable length (alloca
881 or variable sized local arguments (GNU C extension). */
882 #define FRAME_POINTER_REQUIRED 0
883
884 #define ELIMINABLE_REGS \
885 {{ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \
886 {ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM}, \
887 {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}}
888
889 /* We need not worry about when the frame-pointer is required for other
890 reasons. */
891 #define CAN_ELIMINATE(FROM, TO) 1
892
893 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
894 (OFFSET) = cris_initial_elimination_offset (FROM, TO)
895
896
897 /* Node: Stack Arguments */
898
899 /* Since many parameters take up one register each in any case,
900 defining TARGET_PROMOTE_PROTOTYPES that always returns true would
901 seem like a good idea, but measurements indicate that a combination
902 using PROMOTE_MODE is better. */
903
904 #define ACCUMULATE_OUTGOING_ARGS 1
905
906 #define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACKSIZE) 0
907
908
909 /* Node: Register Arguments */
910
911 /* The void_type_node is sent as a "closing" call. We have to stop it
912 since it's invalid to FUNCTION_ARG_PASS_BY_REFERENCE (or was invalid at
913 some time). */
914 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
915 ((CUM).regs < CRIS_MAX_ARGS_IN_REGS \
916 && (TYPE) != void_type_node \
917 && ! FUNCTION_ARG_PASS_BY_REFERENCE (CUM, MODE, TYPE, NAMED) \
918 ? gen_rtx_REG (MODE, (CRIS_FIRST_ARG_REG) + (CUM).regs) \
919 : NULL_RTX)
920
921 /* The differences between this and the previous, is that this one checks
922 that an argument is named, since incoming stdarg/varargs arguments are
923 pushed onto the stack, and we don't have to check against the "closing"
924 void_type_node TYPE parameter. */
925 #define FUNCTION_INCOMING_ARG(CUM, MODE, TYPE, NAMED) \
926 (((NAMED) && (CUM).regs < CRIS_MAX_ARGS_IN_REGS \
927 && ! FUNCTION_ARG_PASS_BY_REFERENCE (CUM, MODE, TYPE, NAMED)) \
928 ? gen_rtx_REG (MODE, CRIS_FIRST_ARG_REG + (CUM).regs) \
929 : NULL_RTX)
930
931 #define FUNCTION_ARG_PARTIAL_NREGS(CUM, MODE, TYPE, NAMED) \
932 (((CUM).regs == (CRIS_MAX_ARGS_IN_REGS - 1) \
933 && !MUST_PASS_IN_STACK (MODE, TYPE) \
934 && CRIS_FUNCTION_ARG_SIZE (MODE, TYPE) > 4 \
935 && CRIS_FUNCTION_ARG_SIZE (MODE, TYPE) <= 8) \
936 ? 1 : 0)
937
938 /* Structs may be passed by value, but they must not be more than 8
939 bytes long. If you tweak this, don't forget to adjust
940 cris_expand_builtin_va_arg. */
941 #define FUNCTION_ARG_PASS_BY_REFERENCE(CUM, MODE, TYPE, NAMED) \
942 (MUST_PASS_IN_STACK (MODE, TYPE) \
943 || CRIS_FUNCTION_ARG_SIZE (MODE, TYPE) > 8) \
944
945 /* Contrary to what you'd believe, defining FUNCTION_ARG_CALLEE_COPIES
946 seems like a (small total) loss, at least for gcc-2.7.2 compiling and
947 running gcc-2.1 (small win in size, small loss running -- 100.1%),
948 and similarly for size for products (.1 .. .3% bloat, sometimes win).
949 Due to the empirical likeliness of making slower code, it is not
950 defined. */
951
952 /* This no longer *needs* to be a structure; but keeping it as such should
953 not hurt (and hacking the ABI is simpler). */
954 #define CUMULATIVE_ARGS struct cum_args
955 struct cum_args {int regs;};
956
957 /* The regs member is an integer, the number of arguments got into
958 registers so far. */
959 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, FNDECL, N_NAMED_ARGS) \
960 ((CUM).regs = 0)
961
962 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \
963 ((CUM).regs \
964 = (FUNCTION_ARG_PASS_BY_REFERENCE(CUM, MODE, TYPE, NAMED) \
965 ? (CRIS_MAX_ARGS_IN_REGS) + 1 \
966 : ((CUM).regs \
967 + (3 + (CRIS_FUNCTION_ARG_SIZE (MODE, TYPE))) / 4)))
968
969 #define FUNCTION_ARG_REGNO_P(REGNO) \
970 ((REGNO) >= CRIS_FIRST_ARG_REG \
971 && (REGNO) < CRIS_FIRST_ARG_REG + (CRIS_MAX_ARGS_IN_REGS))
972
973
974 /* Node: Scalar Return */
975
976 /* Let's assume all functions return in r[CRIS_FIRST_ARG_REG] for the
977 time being. */
978 #define FUNCTION_VALUE(VALTYPE, FUNC) \
979 gen_rtx_REG (TYPE_MODE (VALTYPE), CRIS_FIRST_ARG_REG)
980
981 #define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, CRIS_FIRST_ARG_REG)
982
983 #define FUNCTION_VALUE_REGNO_P(N) ((N) == CRIS_FIRST_ARG_REG)
984
985
986 /* Node: Aggregate Return */
987
988 #if 0
989 /* FIXME: Let's try this some time, so we return structures in registers.
990 We would cast the result of int_size_in_bytes to unsigned, so we will
991 get a huge number for "structures" of variable size (-1). */
992 #define RETURN_IN_MEMORY(TYPE) \
993 ((unsigned) int_size_in_bytes (TYPE) > CRIS_MAX_ARGS_IN_REGS * UNITS_PER_WORD)
994 #endif
995
996 #define CRIS_STRUCT_VALUE_REGNUM ((CRIS_FIRST_ARG_REG) - 1)
997
998
999 /* Node: Caller Saves */
1000 /* (no definitions) */
1001
1002 /* Node: Function entry */
1003
1004 /* See cris.c for TARGET_ASM_FUNCTION_PROLOGUE and
1005 TARGET_ASM_FUNCTION_EPILOGUE. */
1006
1007 /* If the epilogue uses the "ret" insn, we need to fill the
1008 delay slot. */
1009 #define DELAY_SLOTS_FOR_EPILOGUE cris_delay_slots_for_epilogue ()
1010
1011 #define ELIGIBLE_FOR_EPILOGUE_DELAY(INSN, N) \
1012 cris_eligible_for_epilogue_delay (INSN)
1013
1014 /* Node: Profiling */
1015
1016 #define FUNCTION_PROFILER(FILE, LABELNO) \
1017 error ("no FUNCTION_PROFILER for CRIS")
1018
1019 /* FIXME: Some of the undefined macros might be mandatory. If so, fix
1020 documentation. */
1021
1022
1023 /* Node: Varargs */
1024
1025 /* FIXME: This and other EXPAND_BUILTIN_VA_... target macros are not
1026 documented, although used by several targets. */
1027 #define EXPAND_BUILTIN_VA_ARG(VALIST, TYPE) \
1028 cris_expand_builtin_va_arg (VALIST, TYPE)
1029
1030
1031 /* Node: Trampolines */
1032
1033 /* This looks too complicated, and it is. I assigned r7 to be the
1034 static chain register, but it is call-saved, so we have to save it,
1035 and come back to restore it after the call, so we have to save srp...
1036 Anyway, trampolines are rare enough that we can cope with this
1037 somewhat lack of elegance.
1038 (Do not be tempted to "straighten up" whitespace in the asms; the
1039 assembler #NO_APP state mandates strict spacing). */
1040 #define TRAMPOLINE_TEMPLATE(FILE) \
1041 do \
1042 { \
1043 fprintf (FILE, "\tmove.d $%s,[$pc+20]\n", \
1044 reg_names[STATIC_CHAIN_REGNUM]); \
1045 fprintf (FILE, "\tmove $srp,[$pc+22]\n"); \
1046 fprintf (FILE, "\tmove.d 0,$%s\n", \
1047 reg_names[STATIC_CHAIN_REGNUM]); \
1048 fprintf (FILE, "\tjsr 0\n"); \
1049 fprintf (FILE, "\tmove.d 0,$%s\n", \
1050 reg_names[STATIC_CHAIN_REGNUM]); \
1051 fprintf (FILE, "\tjump 0\n"); \
1052 } \
1053 while (0)
1054
1055 #define TRAMPOLINE_SIZE 32
1056
1057 /* CRIS wants instructions on word-boundary.
1058 Note that due to a bug (reported) in 2.7.2 and earlier, this is
1059 actually treated as alignment in _bytes_, not _bits_. (Obviously
1060 this is not fatal, only a slight waste of stack space). */
1061 #define TRAMPOLINE_ALIGNMENT 16
1062
1063 #define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
1064 do \
1065 { \
1066 emit_move_insn (gen_rtx_MEM (SImode, \
1067 plus_constant (TRAMP, 10)), \
1068 CXT); \
1069 emit_move_insn (gen_rtx_MEM (SImode, \
1070 plus_constant (TRAMP, 16)), \
1071 FNADDR); \
1072 } \
1073 while (0)
1074
1075 /* Note that there is no need to do anything with the cache for sake of
1076 a trampoline. */
1077
1078
1079 /* Node: Library Calls */
1080
1081 /* If you change this, you have to check whatever libraries and systems
1082 that use it. */
1083 #define TARGET_EDOM 33
1084
1085
1086 /* Node: Addressing Modes */
1087
1088 #define HAVE_POST_INCREMENT 1
1089
1090 #define CONSTANT_ADDRESS_P(X) CONSTANT_P (X)
1091
1092 #define MAX_REGS_PER_ADDRESS 2
1093
1094 /* There are helper macros defined here which are used only in
1095 GO_IF_LEGITIMATE_ADDRESS.
1096
1097 Note that you *have to* reject invalid addressing modes for mode
1098 MODE, even if it is legal for normal addressing modes. You cannot
1099 rely on the constraints to do this work. They can only be used to
1100 doublecheck your intentions. One example is that you HAVE TO reject
1101 (mem:DI (plus:SI (reg:SI x) (reg:SI y))) because for some reason
1102 this cannot be reloaded. (Which of course you can argue that gcc
1103 should have done.) FIXME: Strange. Check. */
1104
1105 /* No symbol can be used as an index (or more correct, as a base) together
1106 with a register with PIC; the PIC register must be there. */
1107 #define CONSTANT_INDEX_P(X) \
1108 (CONSTANT_P (X) && !(flag_pic && cris_symbol (X)))
1109
1110 /* True if X is a valid base register. */
1111 #define BASE_P(X) \
1112 (REG_P (X) && REG_OK_FOR_BASE_P (X))
1113
1114 /* True if X is a valid base register with or without autoincrement. */
1115 #define BASE_OR_AUTOINCR_P(X) \
1116 (BASE_P (X) || (GET_CODE (X) == POST_INC && BASE_P (XEXP (X, 0))))
1117
1118 /* True if X is a valid (register) index for BDAP, i.e. [Rs].S or [Rs+].S. */
1119 #define BDAP_INDEX_P(X) \
1120 ((GET_CODE (X) == MEM && GET_MODE (X) == SImode \
1121 && BASE_OR_AUTOINCR_P (XEXP (X, 0))) \
1122 || (GET_CODE (X) == SIGN_EXTEND \
1123 && GET_CODE (XEXP (X, 0)) == MEM \
1124 && (GET_MODE (XEXP (X, 0)) == HImode \
1125 || GET_MODE (XEXP (X, 0)) == QImode) \
1126 && BASE_OR_AUTOINCR_P (XEXP (XEXP (X, 0), 0))))
1127
1128 /* True if X is a valid (register) index for BIAP, i.e. Rd.m. */
1129 #define BIAP_INDEX_P(X) \
1130 ((BASE_P (X) && REG_OK_FOR_INDEX_P (X)) \
1131 || (GET_CODE (X) == MULT \
1132 && BASE_P (XEXP (X, 0)) \
1133 && REG_OK_FOR_INDEX_P (XEXP (X, 0)) \
1134 && GET_CODE (XEXP (X, 1)) == CONST_INT \
1135 && (INTVAL (XEXP (X, 1)) == 2 \
1136 || INTVAL (XEXP (X, 1)) == 4)))
1137
1138 /* True if X is an address that doesn't need a prefix i.e. [Rs] or [Rs+]. */
1139 #define SIMPLE_ADDRESS_P(X) \
1140 (BASE_P (X) \
1141 || (GET_CODE (X) == POST_INC \
1142 && BASE_P (XEXP (X, 0))))
1143
1144 /* A PIC operand looks like a normal symbol here. At output we dress it
1145 in "[rPIC+symbol:GOT]" (global symbol) or "rPIC+symbol:GOTOFF" (local
1146 symbol) so we exclude all addressing modes where we can't replace a
1147 plain "symbol" with that. A global PIC symbol does not fit anywhere
1148 here (but is thankfully a general_operand in itself). A local PIC
1149 symbol is valid for the plain "symbol + offset" case. */
1150 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \
1151 { \
1152 rtx x1, x2; \
1153 if (SIMPLE_ADDRESS_P (X)) \
1154 goto ADDR; \
1155 if (CONSTANT_P (X) \
1156 && (! flag_pic \
1157 || cris_gotless_symbol (X) \
1158 || ! cris_symbol (X))) \
1159 goto ADDR; \
1160 /* Indexed? */ \
1161 if (GET_CODE (X) == PLUS) \
1162 { \
1163 x1 = XEXP (X, 0); \
1164 x2 = XEXP (X, 1); \
1165 /* BDAP o, Rd. */ \
1166 if ((BASE_P (x1) && CONSTANT_INDEX_P (x2)) \
1167 || (BASE_P (x2) && CONSTANT_INDEX_P (x1)) \
1168 /* BDAP Rs[+], Rd. */ \
1169 || (GET_MODE_SIZE (MODE) <= UNITS_PER_WORD \
1170 && ((BASE_P (x1) && BDAP_INDEX_P (x2)) \
1171 || (BASE_P (x2) && BDAP_INDEX_P (x1)) \
1172 /* BIAP.m Rs, Rd */ \
1173 || (BASE_P (x1) && BIAP_INDEX_P (x2)) \
1174 || (BASE_P (x2) && BIAP_INDEX_P (x1))))) \
1175 goto ADDR; \
1176 } \
1177 else if (GET_CODE (X) == MEM) \
1178 { \
1179 /* DIP (Rs). Reject [[reg+]] and [[reg]] for \
1180 DImode (long long). */ \
1181 if (GET_MODE_SIZE (MODE) <= UNITS_PER_WORD \
1182 && (BASE_P (XEXP (X, 0)) \
1183 || BASE_OR_AUTOINCR_P (XEXP (X, 0)))) \
1184 goto ADDR; \
1185 } \
1186 }
1187
1188 #ifndef REG_OK_STRICT
1189 /* Nonzero if X is a hard reg that can be used as a base reg
1190 or if it is a pseudo reg. */
1191 # define REG_OK_FOR_BASE_P(X) \
1192 (REGNO (X) <= CRIS_LAST_GENERAL_REGISTER \
1193 || REGNO (X) == ARG_POINTER_REGNUM \
1194 || REGNO (X) >= FIRST_PSEUDO_REGISTER)
1195 #else
1196 /* Nonzero if X is a hard reg that can be used as a base reg. */
1197 # define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X))
1198 #endif
1199
1200 #ifndef REG_OK_STRICT
1201 /* Nonzero if X is a hard reg that can be used as an index
1202 or if it is a pseudo reg. */
1203 # define REG_OK_FOR_INDEX_P(X) REG_OK_FOR_BASE_P (X)
1204 #else
1205 /* Nonzero if X is a hard reg that can be used as an index. */
1206 # define REG_OK_FOR_INDEX_P(X) REGNO_OK_FOR_INDEX_P (REGNO (X))
1207 #endif
1208
1209 /* For now, don't do anything. GCC does a good job most often.
1210
1211 Maybe we could do something about gcc:s misbehavior when it
1212 recalculates frame offsets for local variables, from fp+offs to
1213 sp+offs. The resulting address expression gets screwed up
1214 sometimes, but I'm not sure that it may be fixed here, since it is
1215 already split up in several instructions (Is this still true?).
1216 FIXME: Check and adjust for gcc-2.9x. */
1217 #define LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN) {}
1218
1219 /* Kludge to solve Axis-990219: Work around imperfection in
1220 reload_load_address1:
1221 (plus (sign_extend (mem:qi (reg))) (reg))
1222 should be reloaded as (plus (reg) (reg)), not
1223 (plus (sign_extend (reg)) (reg)).
1224 There are no checks that reload_load_address_1 "reloads"
1225 addresses correctly, so invalidness is not caught or
1226 corrected.
1227 When the right thing happens in reload, the kludge can
1228 be removed; still not as of 2003-02-27. */
1229
1230 #define LEGITIMIZE_RELOAD_ADDRESS(X, MODE, OPNUM, TYPE, IND_LEVELS, WIN) \
1231 do \
1232 { \
1233 if (GET_CODE (X) == PLUS \
1234 && REG_P (XEXP (X, 1)) \
1235 && GET_CODE (XEXP (X, 0)) == SIGN_EXTEND \
1236 && GET_CODE (XEXP (XEXP (X, 0), 0)) == MEM \
1237 && (GET_MODE (XEXP (XEXP (X, 0), 0)) == HImode \
1238 || GET_MODE (XEXP (XEXP (X, 0), 0)) == QImode) \
1239 && (REG_P (XEXP (XEXP (XEXP (X, 0), 0), 0)) \
1240 || (GET_CODE (XEXP (XEXP (XEXP (X, 0), 0), 0)) \
1241 == POST_INC \
1242 && REG_P (XEXP (XEXP (XEXP (XEXP (X, 0), 0), 0), \
1243 0))))) \
1244 { \
1245 int something_reloaded = 0; \
1246 \
1247 if (REGNO (XEXP (X, 1)) >= FIRST_PSEUDO_REGISTER) \
1248 { \
1249 /* Second reg is pseudo, reload it. */ \
1250 push_reload (XEXP (X, 1), NULL_RTX, &XEXP (X, 1), \
1251 NULL, \
1252 GENERAL_REGS, GET_MODE (X), VOIDmode, 0, 0, \
1253 OPNUM, TYPE); \
1254 something_reloaded = 1; \
1255 } \
1256 \
1257 if (REG_P (XEXP (XEXP (XEXP (X, 0), 0), 0)) \
1258 && (REGNO (XEXP (XEXP (XEXP (X, 0), 0), 0)) \
1259 >= FIRST_PSEUDO_REGISTER)) \
1260 { \
1261 /* First one is a pseudo - reload that. */ \
1262 push_reload (XEXP (XEXP (XEXP (X, 0), 0), 0), NULL_RTX, \
1263 &XEXP (XEXP (XEXP (X, 0), 0), 0), NULL, \
1264 GENERAL_REGS, \
1265 GET_MODE (X), VOIDmode, 0, 0, OPNUM, TYPE); \
1266 something_reloaded = 1; \
1267 } \
1268 \
1269 if (! something_reloaded \
1270 || (GET_CODE (XEXP (XEXP (X, 0), 0)) == POST_INC \
1271 && (REGNO (XEXP (XEXP (XEXP (X, 0), 0), 0)) \
1272 >= FIRST_PSEUDO_REGISTER))) \
1273 /* Reload the sign_extend. Happens if neither reg is a \
1274 pseudo, or the first one was inside post_increment. */ \
1275 push_reload (XEXP (X, 0), NULL_RTX, &XEXP (X, 0), NULL, \
1276 GENERAL_REGS, GET_MODE (X), VOIDmode, 0, 0, \
1277 OPNUM, TYPE); \
1278 goto WIN; \
1279 } \
1280 } \
1281 while (0)
1282
1283 /* In CRIS, only the postincrement address mode depends thus,
1284 since the increment depends on the size of the operand. */
1285 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR, LABEL) \
1286 do \
1287 { \
1288 if (GET_CODE (ADDR) == POST_INC) \
1289 goto LABEL; \
1290 } \
1291 while (0)
1292
1293 #define LEGITIMATE_CONSTANT_P(X) 1
1294
1295
1296 /* Node: Condition Code */
1297
1298 #define NOTICE_UPDATE_CC(EXP, INSN) cris_notice_update_cc (EXP, INSN)
1299
1300 /* FIXME: Maybe define CANONICALIZE_COMPARISON later, when playing with
1301 optimizations. It is needed; currently we do this with instruction
1302 patterns and NOTICE_UPDATE_CC. */
1303
1304
1305 /* Node: Costs */
1306
1307 /* FIXME: Need to define REGISTER_MOVE_COST when more register classes are
1308 introduced. */
1309
1310 /* This isn't strictly correct for v0..3 in buswidth-8bit mode, but
1311 should suffice. */
1312 #define MEMORY_MOVE_COST(M, CLASS, IN) \
1313 (((M) == QImode) ? 4 : ((M) == HImode) ? 4 : 6)
1314
1315 /* Regardless of the presence of delay slots, the default value of 1 for
1316 BRANCH_COST is the best in the range (1, 2, 3), tested with gcc-2.7.2
1317 with testcases ipps and gcc, giving smallest and fastest code. */
1318
1319 #define SLOW_BYTE_ACCESS 0
1320
1321 /* This is the threshold *below* which inline move sequences of
1322 word-length sizes will be emitted. The "9" will translate to
1323 (9 - 1) * 4 = 32 bytes maximum moved, but using 16 instructions
1324 (8 instruction sequences) or less. */
1325 #define MOVE_RATIO 9
1326
1327
1328 /* Node: Sections */
1329
1330 #define TEXT_SECTION_ASM_OP "\t.text"
1331
1332 #define DATA_SECTION_ASM_OP "\t.data"
1333
1334 #define FORCE_EH_FRAME_INFO_IN_DATA_SECTION (! TARGET_ELF)
1335
1336 /* The jump table is immediately connected to the preceding insn. */
1337 #define JUMP_TABLES_IN_TEXT_SECTION 1
1338
1339 /* We pull a little trick to register the _fini function with atexit,
1340 after (presumably) registering the eh frame info, since we don't handle
1341 _fini (a.k.a. ___fini_start) in crt0 or have a crti for "pure" ELF. If
1342 you change this, don't forget that you can't have library function
1343 references (e.g. to atexit) in crtend.o, since those won't be resolved
1344 to libraries; those are linked in *before* crtend.o. */
1345 #ifdef CRT_BEGIN
1346 # define CRT_CALL_STATIC_FUNCTION(SECTION_OP, FUNC) \
1347 static void __attribute__((__used__)) \
1348 call_ ## FUNC (void) \
1349 { \
1350 asm (SECTION_OP); \
1351 FUNC (); \
1352 if (__builtin_strcmp (#FUNC, "frame_dummy") == 0) \
1353 { \
1354 extern void __fini__start (void); \
1355 atexit (__fini__start); \
1356 } \
1357 asm (TEXT_SECTION_ASM_OP); \
1358 }
1359 #endif
1360
1361 /* Node: PIC */
1362
1363 #define PIC_OFFSET_TABLE_REGNUM (flag_pic ? 0 : INVALID_REGNUM)
1364
1365 #define LEGITIMATE_PIC_OPERAND_P(X) cris_legitimate_pic_operand (X)
1366
1367
1368 /* Node: File Framework */
1369
1370 /* We don't want an .ident for gcc. To avoid that but still support
1371 #ident, we override ASM_OUTPUT_IDENT and, since the gcc .ident is its
1372 only use besides ASM_OUTPUT_IDENT, undef IDENT_ASM_OP from elfos.h. */
1373 #undef IDENT_ASM_OP
1374 #undef ASM_OUTPUT_IDENT
1375 #define ASM_OUTPUT_IDENT(FILE, NAME) \
1376 fprintf (FILE, "%s\"%s\"\n", "\t.ident\t", NAME);
1377
1378 #define ASM_APP_ON "#APP\n"
1379
1380 #define ASM_APP_OFF "#NO_APP\n"
1381
1382
1383 /* Node: Data Output */
1384
1385 #define IS_ASM_LOGICAL_LINE_SEPARATOR(C) (C) == '@'
1386
1387 /* Node: Uninitialized Data */
1388
1389 /* Remember to round off odd values if we want data alignment,
1390 since we cannot do that with an .align directive.
1391
1392 Using .comm causes the space not to be reserved in .bss, but by
1393 tricks with the symbol type. Not good if other tools than binutils
1394 are used on the object files. Since ".global ... .lcomm ..." works, we
1395 use that. Use .._ALIGNED_COMMON, since gcc whines when we only have
1396 ..._COMMON, and we prefer to whine ourselves; BIGGEST_ALIGNMENT is not
1397 the one to check. This done for a.out only. */
1398 /* FIXME: I suspect a bug in gcc with alignment. Do not warn until
1399 investigated; it mucks up the testsuite results. */
1400 #define CRIS_ASM_OUTPUT_ALIGNED_DECL_COMMON(FILE, DECL, NAME, SIZE, ALIGN, LOCAL) \
1401 do \
1402 { \
1403 int align_ = (ALIGN) / BITS_PER_UNIT; \
1404 if (TARGET_DATA_ALIGN && TARGET_ALIGN_BY_32 && align_ < 4) \
1405 align_ = 4; \
1406 else if (TARGET_DATA_ALIGN && align_ < 2) \
1407 align_ = 2; \
1408 /* FIXME: Do we need this? */ \
1409 else if (align_ < 1) \
1410 align_ = 1; \
1411 \
1412 if (TARGET_ELF) \
1413 { \
1414 if (LOCAL) \
1415 { \
1416 fprintf ((FILE), "%s", LOCAL_ASM_OP); \
1417 assemble_name ((FILE), (NAME)); \
1418 fprintf ((FILE), "\n"); \
1419 } \
1420 fprintf ((FILE), "%s", COMMON_ASM_OP); \
1421 assemble_name ((FILE), (NAME)); \
1422 fprintf ((FILE), ",%u,%u\n", (int)(SIZE), align_); \
1423 } \
1424 else \
1425 { \
1426 /* We can't tell a one-only or weak COMM from a "global \
1427 COMM" so just make all non-locals weak. */ \
1428 if (! (LOCAL)) \
1429 ASM_WEAKEN_LABEL (FILE, NAME); \
1430 fputs ("\t.lcomm ", (FILE)); \
1431 assemble_name ((FILE), (NAME)); \
1432 fprintf ((FILE), ",%u\n", \
1433 ((int)(SIZE) + (align_ - 1)) & ~(align_ - 1)); \
1434 } \
1435 } \
1436 while (0)
1437
1438 #define ASM_OUTPUT_ALIGNED_DECL_COMMON(FILE, DECL, NAME, SIZE, ALIGN) \
1439 CRIS_ASM_OUTPUT_ALIGNED_DECL_COMMON(FILE, DECL, NAME, SIZE, ALIGN, 0)
1440
1441 #undef ASM_OUTPUT_ALIGNED_DECL_LOCAL
1442 #define ASM_OUTPUT_ALIGNED_DECL_LOCAL(FILE, DECL, NAME, SIZE, ALIGN) \
1443 CRIS_ASM_OUTPUT_ALIGNED_DECL_COMMON(FILE, DECL, NAME, SIZE, ALIGN, 1)
1444
1445 /* FIXME: define ASM_OUTPUT_SHARED_COMMON and emit an error when it is
1446 used with -melinux and a.out. */
1447
1448 /* Node: Label Output */
1449
1450 /* Globalizing directive for a label. */
1451 #define GLOBAL_ASM_OP "\t.global "
1452
1453 #define SUPPORTS_WEAK 1
1454
1455 /* Remove any previous definition (elfos.h). */
1456 #undef ASM_GENERATE_INTERNAL_LABEL
1457 #define ASM_GENERATE_INTERNAL_LABEL(LABEL, PREFIX, NUM) \
1458 sprintf (LABEL, "*%s%s%ld", LOCAL_LABEL_PREFIX, PREFIX, (long) NUM)
1459
1460 /* Node: Initialization */
1461 /* (no definitions) */
1462
1463 /* Node: Macros for Initialization */
1464 /* (no definitions) */
1465
1466 /* Node: Instruction Output */
1467
1468 #define REGISTER_NAMES \
1469 {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", \
1470 "r9", "r10", "r11", "r12", "r13", "sp", "pc", "srp", "faked_ap"}
1471
1472 #define ADDITIONAL_REGISTER_NAMES \
1473 {{"r14", 14}, {"r15", 15}}
1474
1475 #define PRINT_OPERAND(FILE, X, CODE) \
1476 cris_print_operand (FILE, X, CODE)
1477
1478 /* For delay-slot handling. */
1479 #define PRINT_OPERAND_PUNCT_VALID_P(CODE) (CODE == '#')
1480
1481 #define PRINT_OPERAND_ADDRESS(FILE, ADDR) \
1482 cris_print_operand_address (FILE, ADDR)
1483
1484 /* Output an empty line to illustrate the presence of the delay slot. */
1485 #define DBR_OUTPUT_SEQEND(FILE) \
1486 fprintf (FILE, "\n")
1487
1488 #define LOCAL_LABEL_PREFIX (TARGET_ELF ? "." : "")
1489
1490 /* cppinit.c initializes a const array from this, so it must be constant,
1491 can't have it different based on options. Luckily, the prefix is
1492 always allowed, so let's have it on all GCC-generated code. Note that
1493 we have this verbatim everywhere in the back-end, not using %R or %s or
1494 such. */
1495 #define REGISTER_PREFIX "$"
1496
1497 /* Remove any previous definition (elfos.h). */
1498 /* We use -fno-leading-underscore to remove it, when necessary. */
1499 #undef USER_LABEL_PREFIX
1500 #define USER_LABEL_PREFIX "_"
1501
1502 #define ASM_OUTPUT_REG_PUSH(FILE, REGNO) \
1503 fprintf (FILE, "\tpush $%s\n", reg_names[REGNO])
1504
1505 #define ASM_OUTPUT_REG_POP(FILE, REGNO) \
1506 fprintf (FILE, "\tpop $%s\n", reg_names[REGNO])
1507
1508
1509 /* Node: Dispatch Tables */
1510
1511 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) \
1512 asm_fprintf (FILE, "\t.word %LL%d-%LL%d\n", VALUE, REL)
1513
1514 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \
1515 asm_fprintf (FILE, "\t.dword %LL%d\n", VALUE)
1516
1517 /* Defined to also emit an .align in elfos.h. We don't want that. */
1518 #undef ASM_OUTPUT_CASE_LABEL
1519
1520 /* Since the "bound" insn loads the comparison value if the compared<
1521 value (register) is out of bounds (0..comparison value-1), we need
1522 to output another case to catch it.
1523 The way to find it is to look for the label_ref at the else-arm inside
1524 the expanded casesi core-insn.
1525 FIXME: Check this construct when changing to new version of gcc. */
1526 #define ASM_OUTPUT_CASE_END(STREAM, NUM, TABLE) \
1527 do \
1528 { \
1529 asm_fprintf (STREAM, "\t.word %LL%d-%LL%d%s\n", \
1530 CODE_LABEL_NUMBER \
1531 (XEXP (XEXP (XEXP \
1532 (XVECEXP \
1533 (PATTERN (PREV_INSN (PREV_INSN \
1534 (TABLE))), \
1535 0, 0), 1), 2), 0)), \
1536 NUM, \
1537 (TARGET_PDEBUG ? "; default" : "")); \
1538 } \
1539 while (0)
1540
1541
1542 /* Node: Exception Region Output */
1543 /* (no definitions) */
1544 /* FIXME: Fill in with our own optimized layout. */
1545
1546 /* Node: Alignment Output */
1547
1548 #define ASM_OUTPUT_ALIGN(FILE, LOG) \
1549 fprintf (FILE, "\t.align %d\n", (LOG))
1550
1551
1552 /* Node: All Debuggers */
1553
1554 #define DBX_REGISTER_NUMBER(REGNO) \
1555 ((REGNO) == CRIS_SRP_REGNUM ? CRIS_CANONICAL_SRP_REGNUM : (REGNO))
1556
1557 /* FIXME: Investigate DEBUGGER_AUTO_OFFSET, DEBUGGER_ARG_OFFSET. */
1558
1559
1560 /* Node: DBX Options */
1561
1562 /* Is this correct? Check later. */
1563 #define DBX_NO_XREFS
1564
1565 #define DBX_CONTIN_LENGTH 0
1566
1567 /* FIXME: Is this needed when we have 0 DBX_CONTIN_LENGTH? */
1568 #define DBX_CONTIN_CHAR '?'
1569
1570
1571 /* Node: DBX Hooks */
1572 /* (no definitions) */
1573
1574 /* Node: File names and DBX */
1575 /* (no definitions) */
1576
1577
1578 /* Node: SDB and DWARF */
1579 /* (no definitions) */
1580
1581 /* Node: Misc */
1582
1583 /* FIXME: Check this one more time. */
1584 #define PREDICATE_CODES \
1585 {"cris_orthogonal_operator", \
1586 {PLUS, MINUS, IOR, AND, UMIN}}, \
1587 {"cris_commutative_orth_op", \
1588 {PLUS, IOR, AND, UMIN}}, \
1589 {"cris_operand_extend_operator", \
1590 {PLUS, MINUS, UMIN}}, \
1591 {"cris_additive_operand_extend_operator", \
1592 {PLUS, MINUS}}, \
1593 {"cris_extend_operator", \
1594 {ZERO_EXTEND, SIGN_EXTEND}}, \
1595 {"cris_plus_or_bound_operator", \
1596 {PLUS, UMIN}}, \
1597 {"cris_mem_op", \
1598 {MEM}}, \
1599 {"cris_bdap_operand", \
1600 {SUBREG, REG, LABEL_REF, SYMBOL_REF, MEM, CONST_INT, \
1601 CONST_DOUBLE, CONST, SIGN_EXTEND}}, \
1602 {"cris_bdap_biap_operand", \
1603 {SUBREG, REG, LABEL_REF, SYMBOL_REF, MEM, CONST_INT, \
1604 CONST_DOUBLE, CONST, SIGN_EXTEND, MULT}}, \
1605 {"cris_general_operand_or_gotless_symbol", \
1606 {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF, \
1607 LABEL_REF, SUBREG, REG, MEM}}, \
1608 {"cris_general_operand_or_symbol", \
1609 {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF, \
1610 LABEL_REF, SUBREG, REG, MEM}}, \
1611 {"cris_general_operand_or_plt_symbol", \
1612 {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF, \
1613 LABEL_REF, SUBREG, REG, MEM}}, \
1614 {"cris_mem_call_operand", \
1615 {MEM}},
1616
1617 /* A combination of the bound (umin) insn together with a
1618 sign-extended add via the table to PC seems optimal.
1619 If the table overflows, the assembler will take care of it.
1620 Theoretically, in extreme cases (uncertain if they occur), an error
1621 will be emitted, so FIXME: Check how large case-tables are emitted,
1622 possible add an option to emit SImode case-tables. */
1623 #define CASE_VECTOR_MODE HImode
1624
1625 #define CASE_VECTOR_PC_RELATIVE 1
1626
1627 /* FIXME: Investigate CASE_VECTOR_SHORTEN_MODE to make sure HImode is not
1628 used when broken-.word could possibly fail (plus testcase). */
1629
1630 #define FIXUNS_TRUNC_LIKE_FIX_TRUNC
1631
1632 /* This is the number of bytes that can be moved in one
1633 reasonably fast instruction sequence. For CRIS, this is two
1634 instructions: mem => reg, reg => mem. */
1635 #define MOVE_MAX 4
1636
1637 /* Maybe SHIFT_COUNT_TRUNCATED is safe to define? FIXME: Check later. */
1638
1639 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
1640
1641 #define Pmode SImode
1642
1643 #define FUNCTION_MODE QImode
1644
1645 #define NO_IMPLICIT_EXTERN_C
1646
1647 /*
1648 * Local variables:
1649 * eval: (c-set-style "gnu")
1650 * indent-tabs-mode: t
1651 * End:
1652 */
Mirror of the offical gcc git repository hosted at gcc.gnu.org