]>
Commit | Line | Data |
---|---|---|
0b85d816 | 1 | /* Definitions for GCC. Part of the machine description for CRIS. |
3be639f7 | 2 | Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, |
c5387660 | 3 | 2009, 2010 Free Software Foundation, Inc. |
0b85d816 HPN |
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 | |
2f83c7d6 | 10 | the Free Software Foundation; either version 3, or (at your option) |
0b85d816 HPN |
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 | |
2f83c7d6 NC |
19 | along with GCC; see the file COPYING3. If not see |
20 | <http://www.gnu.org/licenses/>. */ | |
0b85d816 HPN |
21 | |
22 | /* After the first "Node:" comment comes all preprocessor directives and | |
23 | attached declarations described in the info files, the "Using and | |
24 | Porting GCC" manual (uapgcc), in the same order as found in the "Target | |
25 | macros" section in the gcc-2.9x CVS edition of 2000-03-17. FIXME: Not | |
26 | really, but needs an update anyway. | |
27 | ||
28 | There is no generic copy-of-uapgcc comment, you'll have to see uapgcc | |
29 | for that. If applicable, there is a CRIS-specific comment. The order | |
30 | of macro definitions follow the order in the manual. Every section in | |
31 | the manual (node in the info pages) has an introductory `Node: | |
32 | <subchapter>' comment. If no macros are defined for a section, only | |
33 | the section-comment is present. */ | |
34 | ||
35 | /* Note that other header files (e.g. config/elfos.h, config/linux.h, | |
36 | config/cris/linux.h and config/cris/aout.h) are responsible for lots of | |
37 | settings not repeated below. This file contains general CRIS | |
38 | definitions and definitions for the cris-*-elf subtarget. */ | |
39 | ||
b6c34129 HPN |
40 | /* We don't want to use gcc_assert for everything, as that can be |
41 | compiled out. */ | |
42 | #define CRIS_ASSERT(x) \ | |
43 | do { if (!(x)) internal_error ("CRIS-port assertion failed: " #x); } while (0) | |
44 | ||
0b85d816 HPN |
45 | /* Replacement for REG_P since it does not match SUBREGs. Happens for |
46 | testcase Axis-20000320 with gcc-2.9x. */ | |
47 | #define REG_S_P(x) \ | |
48 | (REG_P (x) || (GET_CODE (x) == SUBREG && REG_P (XEXP (x, 0)))) | |
49 | ||
50 | /* Last register in main register bank r0..r15. */ | |
51 | #define CRIS_LAST_GENERAL_REGISTER 15 | |
52 | ||
53 | /* Descriptions of registers used for arguments. */ | |
54 | #define CRIS_FIRST_ARG_REG 10 | |
55 | #define CRIS_MAX_ARGS_IN_REGS 4 | |
56 | ||
f60c7155 | 57 | /* See also *_REGNUM constants in cris.md. */ |
0b85d816 HPN |
58 | |
59 | /* Most of the time, we need the index into the register-names array. | |
f60c7155 | 60 | When passing debug-info, we need the real hardware register number. */ |
0b85d816 HPN |
61 | #define CRIS_CANONICAL_SRP_REGNUM (16 + 11) |
62 | #define CRIS_CANONICAL_MOF_REGNUM (16 + 7) | |
f9968e3e HPN |
63 | /* We have CCR in all models including v10, but that's 16 bits, so let's |
64 | prefer the DCCR number, which is a DMA pointer in pre-v8, so we'll | |
65 | never clash with it for GCC purposes. */ | |
66 | #define CRIS_CANONICAL_CC0_REGNUM (16 + 13) | |
0b85d816 HPN |
67 | |
68 | /* When generating PIC, these suffixes are added to the names of non-local | |
69 | functions when being output. Contrary to other ports, we have offsets | |
70 | relative to the GOT, not the PC. We might implement PC-relative PLT | |
71 | semantics later for the general case; they are used in some cases right | |
72 | now, such as MI thunks. */ | |
73 | #define CRIS_GOTPLT_SUFFIX ":GOTPLT" | |
74 | #define CRIS_PLT_GOTOFFSET_SUFFIX ":PLTG" | |
75 | #define CRIS_PLT_PCOFFSET_SUFFIX ":PLT" | |
76 | ||
77 | #define CRIS_FUNCTION_ARG_SIZE(MODE, TYPE) \ | |
78 | ((MODE) != BLKmode ? GET_MODE_SIZE (MODE) \ | |
79 | : (unsigned) int_size_in_bytes (TYPE)) | |
80 | ||
0b85d816 HPN |
81 | /* Which CPU version this is. The parsed and adjusted cris_cpu_str. */ |
82 | extern int cris_cpu_version; | |
83 | ||
0b85d816 HPN |
84 | /* Changing the order used to be necessary to put the fourth __make_dp |
85 | argument (a DImode parameter) in registers, to fit with the libfunc | |
86 | parameter passing scheme used for intrinsic functions. FIXME: Check | |
87 | performance and maybe remove definition from TARGET_LIBGCC2_CFLAGS now | |
88 | that it isn't strictly necessary. We used to do this through | |
89 | TARGET_LIBGCC2_CFLAGS, but that became increasingly difficult as the | |
90 | parenthesis (that needed quoting) travels through several layers of | |
91 | make and shell invocations. */ | |
92 | #ifdef IN_LIBGCC2 | |
93 | #define __make_dp(a,b,c,d) __cris_make_dp(d,a,b,c) | |
94 | #endif | |
95 | ||
96 | ||
97 | /* Node: Driver */ | |
98 | ||
99 | /* When using make with defaults.mak for Sun this will handily remove | |
100 | any "-target sun*" switches. */ | |
101 | /* We need to override any previous definitions (linux.h) */ | |
102 | #undef WORD_SWITCH_TAKES_ARG | |
103 | #define WORD_SWITCH_TAKES_ARG(STR) \ | |
104 | (DEFAULT_WORD_SWITCH_TAKES_ARG (STR) \ | |
105 | || !strcmp (STR, "target")) | |
106 | ||
107 | /* Also provide canonical vN definitions when user specifies an alias. | |
108 | Note that -melf overrides -maout. */ | |
109 | ||
0b85d816 | 110 | #define CPP_SPEC \ |
c555b47f | 111 | "%{mtune=*:-D__tune_%* %{mtune=v*:-D__CRIS_arch_tune=%*}\ |
0b85d816 HPN |
112 | %{mtune=etrax4:-D__tune_v3 -D__CRIS_arch_tune=3}\ |
113 | %{mtune=etrax100:-D__tune_v8 -D__CRIS_arch_tune=8}\ | |
114 | %{mtune=svinto:-D__tune_v8 -D__CRIS_arch_tune=8}\ | |
115 | %{mtune=etrax100lx:-D__tune_v10 -D__CRIS_arch_tune=10}\ | |
c555b47f HPN |
116 | %{mtune=ng:-D__tune_v10 -D__CRIS_arch_tune=10}}\ |
117 | %{mcpu=*:-D__arch_%* %{mcpu=v*:-D__CRIS_arch_version=%*}\ | |
0b85d816 HPN |
118 | %{mcpu=etrax4:-D__arch_v3 -D__CRIS_arch_version=3}\ |
119 | %{mcpu=etrax100:-D__arch_v8 -D__CRIS_arch_version=8}\ | |
120 | %{mcpu=svinto:-D__arch_v8 -D__CRIS_arch_version=8}\ | |
121 | %{mcpu=etrax100lx:-D__arch_v10 -D__CRIS_arch_version=10}\ | |
c555b47f HPN |
122 | %{mcpu=ng:-D__arch_v10 -D__CRIS_arch_version=10}}\ |
123 | %{march=*:-D__arch_%* %{march=v*:-D__CRIS_arch_version=%*}\ | |
0b85d816 HPN |
124 | %{march=etrax4:-D__arch_v3 -D__CRIS_arch_version=3}\ |
125 | %{march=etrax100:-D__arch_v8 -D__CRIS_arch_version=8}\ | |
126 | %{march=svinto:-D__arch_v8 -D__CRIS_arch_version=8}\ | |
127 | %{march=etrax100lx:-D__arch_v10 -D__CRIS_arch_version=10}\ | |
c555b47f | 128 | %{march=ng:-D__arch_v10 -D__CRIS_arch_version=10}}\ |
0b85d816 HPN |
129 | %{metrax100:-D__arch__v8 -D__CRIS_arch_version=8}\ |
130 | %{metrax4:-D__arch__v3 -D__CRIS_arch_version=3}\ | |
131 | %(cpp_subtarget)" | |
132 | ||
133 | /* For the cris-*-elf subtarget. */ | |
6725c402 HPN |
134 | |
135 | #define CRIS_DEFAULT_TUNE "10" | |
136 | #define CRIS_ARCH_CPP_DEFAULT | |
137 | #define CRIS_DEFAULT_ASM_ARCH_OPTION "" | |
138 | ||
139 | #ifdef TARGET_CPU_DEFAULT | |
140 | #if TARGET_CPU_DEFAULT != 32 && TARGET_CPU_DEFAULT != 10 | |
141 | #error "Due to '()'; e.g. '#define TARGET_CPU_DEFAULT (10)', stringize TARGET_CPU_DEFAULT isn't useful: update manually." | |
142 | #endif | |
143 | ||
144 | #if TARGET_CPU_DEFAULT == 32 | |
145 | #undef CRIS_DEFAULT_TUNE | |
146 | #define CRIS_DEFAULT_TUNE "32" | |
147 | /* To enable use of "generic" cris-axis-elf binutils, always pass the | |
148 | architecture option to GAS. (We don't do this for non-v32.) */ | |
149 | #undef CRIS_DEFAULT_ASM_ARCH_OPTION | |
150 | #define CRIS_DEFAULT_ASM_ARCH_OPTION "--march=v32" | |
151 | #endif | |
152 | ||
153 | #undef CRIS_ARCH_CPP_DEFAULT | |
154 | #define CRIS_ARCH_CPP_DEFAULT \ | |
155 | "%{!march=*:\ | |
156 | %{!metrax*:\ | |
157 | %{!mcpu=*:\ | |
158 | %{!mtune=*:-D__tune_v" CRIS_DEFAULT_TUNE "}\ | |
159 | -D__arch_v"CRIS_DEFAULT_TUNE\ | |
160 | " -D__CRIS_arch_version=" CRIS_DEFAULT_TUNE "}}}" | |
161 | #endif | |
162 | ||
0b85d816 | 163 | #define CRIS_CPP_SUBTARGET_SPEC \ |
a6e464ae | 164 | "%{mbest-lib-options:\ |
0b85d816 | 165 | %{!moverride-best-lib-options:\ |
6725c402 HPN |
166 | %{!march=*:%{!metrax*:%{!mcpu=*:\ |
167 | -D__tune_v" CRIS_DEFAULT_TUNE \ | |
168 | " -D__CRIS_arch_tune=" CRIS_DEFAULT_TUNE "}}}}}"\ | |
169 | CRIS_ARCH_CPP_DEFAULT | |
0b85d816 HPN |
170 | |
171 | /* Remove those Sun-make "target" switches. */ | |
172 | /* Override previous definitions (linux.h). */ | |
173 | #undef CC1_SPEC | |
174 | #define CC1_SPEC \ | |
175 | "%{target*:}\ | |
176 | %{metrax4:-march=v3}\ | |
177 | %{metrax100:-march=v8}\ | |
178 | %(cc1_subtarget)" | |
179 | ||
180 | /* For the cris-*-elf subtarget. */ | |
181 | #define CRIS_CC1_SUBTARGET_SPEC \ | |
182 | "-melf\ | |
183 | %{mbest-lib-options:\ | |
184 | %{!moverride-best-lib-options:\ | |
6725c402 HPN |
185 | %{!march=*:%{!mcpu=*:-mtune=v" CRIS_DEFAULT_TUNE\ |
186 | " -D__CRIS_arch_tune=" CRIS_DEFAULT_TUNE "}}\ | |
0b85d816 HPN |
187 | %{!finhibit-size-directive:\ |
188 | %{!fno-function-sections: -ffunction-sections}\ | |
189 | %{!fno-data-sections: -fdata-sections}}}}" | |
190 | ||
6c660aeb | 191 | /* This adds to CC1_SPEC. */ |
0b85d816 HPN |
192 | #define CC1PLUS_SPEC "" |
193 | ||
43537bf6 | 194 | #ifdef HAVE_AS_NO_MUL_BUG_ABORT_OPTION |
86da66b5 HPN |
195 | #define MAYBE_AS_NO_MUL_BUG_ABORT \ |
196 | "%{mno-mul-bug-workaround:-no-mul-bug-abort} " | |
197 | #else | |
198 | #define MAYBE_AS_NO_MUL_BUG_ABORT | |
199 | #endif | |
200 | ||
0b85d816 HPN |
201 | /* Override previous definitions (linux.h). */ |
202 | #undef ASM_SPEC | |
203 | #define ASM_SPEC \ | |
86da66b5 | 204 | MAYBE_AS_NO_MUL_BUG_ABORT \ |
0b85d816 | 205 | "%{v:-v}\ |
6725c402 HPN |
206 | %(asm_subtarget)\ |
207 | %{march=*:%{cpu=*:%eDo not specify both -march=... and -mcpu=...}}\ | |
208 | %{march=v32:--march=v32} %{mcpu=v32:--march=v32}" | |
0b85d816 HPN |
209 | |
210 | /* For the cris-*-elf subtarget. */ | |
6725c402 HPN |
211 | #define CRIS_ASM_SUBTARGET_SPEC \ |
212 | "--em=criself %{!march=*:%{!cpu=*:" CRIS_DEFAULT_ASM_ARCH_OPTION "}}" | |
0b85d816 HPN |
213 | |
214 | /* FIXME: We should propagate the -melf option to make the criself | |
215 | "emulation" unless a linker script is provided (-T*), but I don't know | |
216 | how to do that if either of -Ttext, -Tdata or -Tbss is given but no | |
217 | linker script, as is usually the case. Leave it to the user for the | |
218 | time being. | |
219 | ||
220 | Note that -melf overrides -maout except that a.out-compiled libraries | |
221 | are linked in (multilibbing). The somewhat cryptic -rpath-link pair is | |
222 | to avoid *only* picking up the linux multilib subdir from the "-B./" | |
223 | option during build, while still giving it preference. We'd need some | |
f5143c46 | 224 | %s-variant that checked for existence of some specific file. */ |
0b85d816 HPN |
225 | /* Override previous definitions (svr4.h). */ |
226 | #undef LINK_SPEC | |
227 | #define LINK_SPEC \ | |
228 | "%{v:--verbose}\ | |
d3295e25 | 229 | %(link_subtarget)" |
0b85d816 HPN |
230 | |
231 | /* For the cris-*-elf subtarget. */ | |
232 | #define CRIS_LINK_SUBTARGET_SPEC \ | |
233 | "-mcriself\ | |
234 | %{sim2:%{!T*:-Tdata 0x4000000 -Tbss 0x8000000}}\ | |
349ccf2e | 235 | %{!r:%{O2|O3: --gc-sections}}" |
0b85d816 | 236 | |
fe04ce06 HPN |
237 | /* Which library to get. The simulator uses a different library for |
238 | the low-level syscalls (implementing the Linux syscall ABI instead | |
239 | of direct-iron accesses). Default everything with the stub "nosys" | |
240 | library. */ | |
0b85d816 HPN |
241 | /* Override previous definitions (linux.h). */ |
242 | #undef LIB_SPEC | |
243 | #define LIB_SPEC \ | |
fe04ce06 | 244 | "%{sim*:--start-group -lc -lsyslinux --end-group}\ |
0b85d816 HPN |
245 | %{!sim*:%{g*:-lg}\ |
246 | %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p} -lbsp}\ | |
247 | -lnosys" | |
248 | ||
249 | /* Linker startfile options; crt0 flavors. | |
fe04ce06 | 250 | We need to remove any previous definition (elfos.h). */ |
e16b32fc | 251 | #undef STARTFILE_SPEC |
0b85d816 | 252 | #define STARTFILE_SPEC \ |
fe04ce06 HPN |
253 | "%{sim*:crt1.o%s}%{!sim*:crt0.o%s}\ |
254 | crti.o%s crtbegin.o%s" | |
0b85d816 | 255 | |
e16b32fc | 256 | #undef ENDFILE_SPEC |
fe04ce06 | 257 | #define ENDFILE_SPEC "crtend.o%s crtn.o%s" |
aa97fdf3 | 258 | |
0b85d816 HPN |
259 | #define EXTRA_SPECS \ |
260 | {"cpp_subtarget", CRIS_CPP_SUBTARGET_SPEC}, \ | |
261 | {"cc1_subtarget", CRIS_CC1_SUBTARGET_SPEC}, \ | |
262 | {"asm_subtarget", CRIS_ASM_SUBTARGET_SPEC}, \ | |
263 | {"link_subtarget", CRIS_LINK_SUBTARGET_SPEC}, \ | |
264 | CRIS_SUBTARGET_EXTRA_SPECS | |
265 | ||
266 | #define CRIS_SUBTARGET_EXTRA_SPECS | |
267 | ||
268 | ||
269 | /* Node: Run-time Target */ | |
270 | ||
a6e464ae HPN |
271 | #define TARGET_CPU_CPP_BUILTINS() \ |
272 | do \ | |
273 | { \ | |
274 | builtin_define_std ("cris"); \ | |
275 | builtin_define_std ("CRIS"); \ | |
276 | builtin_define_std ("GNU_CRIS"); \ | |
277 | builtin_define ("__CRIS_ABI_version=2"); \ | |
26b0ad13 KG |
278 | builtin_assert ("cpu=cris"); \ |
279 | builtin_assert ("machine=cris"); \ | |
a6e464ae HPN |
280 | } \ |
281 | while (0) | |
282 | ||
0b85d816 HPN |
283 | /* This needs to be at least 32 bits. */ |
284 | extern int target_flags; | |
285 | ||
2a186d97 HPN |
286 | /* Previously controlled by target_flags. */ |
287 | #define TARGET_ELF 1 | |
0b85d816 | 288 | |
2a186d97 HPN |
289 | /* Previously controlled by target_flags. Note that this is *not* set |
290 | for -melinux. */ | |
291 | #define TARGET_LINUX 0 | |
0b85d816 | 292 | |
0b85d816 | 293 | /* For the cris-*-elf subtarget. */ |
2a186d97 | 294 | #define CRIS_SUBTARGET_DEFAULT 0 |
0b85d816 HPN |
295 | |
296 | #define CRIS_CPU_BASE 0 | |
297 | #define CRIS_CPU_ETRAX4 3 /* Just lz added. */ | |
298 | #define CRIS_CPU_SVINTO 8 /* Added swap, jsrc & Co., 32-bit accesses. */ | |
299 | #define CRIS_CPU_NG 10 /* Added mul[su]. */ | |
6725c402 HPN |
300 | #define CRIS_CPU_V32 32 /* Major changes. */ |
301 | ||
302 | #ifndef TARGET_CPU_DEFAULT | |
303 | #define TARGET_CPU_DEFAULT CRIS_CPU_BASE | |
304 | #endif | |
305 | ||
306 | /* Default target_flags if no switches specified. */ | |
307 | #ifndef TARGET_DEFAULT | |
308 | # if TARGET_CPU_DEFAULT == 32 | |
309 | # define TARGET_DEFAULT \ | |
310 | (MASK_STACK_ALIGN \ | |
311 | + MASK_CONST_ALIGN + MASK_DATA_ALIGN \ | |
312 | + MASK_PROLOGUE_EPILOGUE) | |
313 | # else /* 10 */ | |
314 | # define TARGET_DEFAULT \ | |
315 | (MASK_SIDE_EFFECT_PREFIXES + MASK_STACK_ALIGN \ | |
316 | + MASK_CONST_ALIGN + MASK_DATA_ALIGN \ | |
317 | + MASK_PROLOGUE_EPILOGUE + MASK_MUL_BUG) | |
318 | # endif | |
319 | #endif | |
0b85d816 HPN |
320 | |
321 | /* Local, providing a default for cris_cpu_version. */ | |
6725c402 | 322 | #define CRIS_DEFAULT_CPU_VERSION TARGET_CPU_DEFAULT |
0b85d816 HPN |
323 | |
324 | #define TARGET_HAS_MUL_INSNS (cris_cpu_version >= CRIS_CPU_NG) | |
e636e508 | 325 | #define TARGET_HAS_LZ (cris_cpu_version >= CRIS_CPU_ETRAX4) |
df638b27 | 326 | #define TARGET_HAS_SWAP (cris_cpu_version >= CRIS_CPU_SVINTO) |
6725c402 | 327 | #define TARGET_V32 (cris_cpu_version >= CRIS_CPU_V32) |
0b85d816 | 328 | |
2a186d97 | 329 | #define CRIS_SUBTARGET_HANDLE_OPTION(x, y, z) |
0b85d816 | 330 | |
0b85d816 HPN |
331 | #define OPTIMIZATION_OPTIONS(OPTIMIZE, SIZE) \ |
332 | do \ | |
333 | { \ | |
334 | if ((OPTIMIZE) >= 2 || (SIZE)) \ | |
3de5e93a | 335 | flag_omit_frame_pointer = 1; \ |
0b85d816 HPN |
336 | } \ |
337 | while (0) | |
338 | ||
339 | ||
340 | /* Node: Storage Layout */ | |
341 | ||
342 | #define BITS_BIG_ENDIAN 0 | |
343 | ||
344 | #define BYTES_BIG_ENDIAN 0 | |
345 | ||
346 | /* WORDS_BIG_ENDIAN is not defined in the hardware, but for consistency, | |
347 | we use little-endianness, and we may also be able to use | |
348 | post-increment on DImode indirect. */ | |
349 | #define WORDS_BIG_ENDIAN 0 | |
350 | ||
0b85d816 HPN |
351 | #define UNITS_PER_WORD 4 |
352 | ||
0b85d816 HPN |
353 | #define CRIS_PROMOTED_MODE(MODE, UNSIGNEDP, TYPE) \ |
354 | (GET_MODE_CLASS (MODE) == MODE_INT && GET_MODE_SIZE (MODE) < 4) \ | |
355 | ? SImode : MODE | |
356 | ||
0b85d816 HPN |
357 | /* We will be using prototype promotion, so they will be 32 bit. */ |
358 | #define PARM_BOUNDARY 32 | |
359 | ||
360 | /* Stack boundary is guided by -mstack-align, -mno-stack-align, | |
361 | -malign. | |
362 | Old comment: (2.1: still valid in 2.7.2?) | |
363 | Note that to make this macro affect the alignment of stack | |
364 | locals, a fix was required, and special precautions when handling | |
41441dc7 NB |
365 | the stack pointer in various other macros (TARGET_ASM_FUNCTION_PROLOGUE |
366 | et al) were required. See file "function.c". If you would just define | |
0b85d816 HPN |
367 | this macro, it would only affect the builtin alloca and variable |
368 | local data (non-ANSI, non-K&R, Gnu C extension). */ | |
369 | #define STACK_BOUNDARY \ | |
370 | (TARGET_STACK_ALIGN ? (TARGET_ALIGN_BY_32 ? 32 : 16) : 8) | |
371 | ||
372 | #define FUNCTION_BOUNDARY 16 | |
373 | ||
374 | /* Do not change BIGGEST_ALIGNMENT (when optimizing), as it will affect | |
e5837c07 | 375 | strange places, at least in 2.1. */ |
0b85d816 HPN |
376 | #define BIGGEST_ALIGNMENT 8 |
377 | ||
378 | /* If -m16bit, -m16-bit, -malign or -mdata-align, | |
e5837c07 | 379 | align everything to 16 bit. */ |
0b85d816 HPN |
380 | #define DATA_ALIGNMENT(TYPE, BASIC_ALIGN) \ |
381 | (TARGET_DATA_ALIGN \ | |
382 | ? (TARGET_ALIGN_BY_32 \ | |
383 | ? (BASIC_ALIGN < 32 ? 32 : BASIC_ALIGN) \ | |
384 | : (BASIC_ALIGN < 16 ? 16 : BASIC_ALIGN)) : BASIC_ALIGN) | |
385 | ||
386 | /* Note that CONSTANT_ALIGNMENT has the effect of making gcc believe that | |
387 | ALL references to constant stuff (in code segment, like strings) has | |
388 | this alignment. That is a rather rushed assumption. Luckily we do not | |
389 | care about the "alignment" operand to builtin memcpy (only place where | |
390 | it counts), so it doesn't affect any bad spots. */ | |
391 | #define CONSTANT_ALIGNMENT(CONSTANT, BASIC_ALIGN) \ | |
392 | (TARGET_CONST_ALIGN \ | |
393 | ? (TARGET_ALIGN_BY_32 \ | |
394 | ? (BASIC_ALIGN < 32 ? 32 : BASIC_ALIGN) \ | |
395 | : (BASIC_ALIGN < 16 ? 16 : BASIC_ALIGN)) : BASIC_ALIGN) | |
396 | ||
397 | /* FIXME: Define LOCAL_ALIGNMENT for word and dword or arrays and | |
398 | structures (if -mstack-align=), and check that it is good. */ | |
399 | ||
400 | #define EMPTY_FIELD_BOUNDARY 8 | |
401 | ||
402 | #define STRUCTURE_SIZE_BOUNDARY 8 | |
403 | ||
404 | #define STRICT_ALIGNMENT 0 | |
405 | ||
406 | /* Remove any previous definition (elfos.h). | |
407 | ??? If it wasn't for all the other stuff that affects layout of | |
408 | structures and bit-fields, this could presumably cause incompatibility | |
409 | with other GNU/Linux ports (i.e. elfos.h users). */ | |
410 | #undef PCC_BITFIELD_TYPE_MATTERS | |
411 | ||
412 | /* This is only used for non-scalars. Strange stuff happens to structs | |
413 | (FIXME: What?) if we use anything larger than largest actually used | |
414 | datum size, so lets make it 32. The type "long long" will still work | |
415 | as usual. We can still have DImode insns, but they will only be used | |
416 | for scalar data (i.e. long long). */ | |
417 | #define MAX_FIXED_MODE_SIZE 32 | |
418 | ||
419 | ||
420 | /* Node: Type Layout */ | |
421 | ||
422 | /* Note that DOUBLE_TYPE_SIZE is not defined anymore, since the default | |
423 | value gives a 64-bit double, which is what we now use. */ | |
424 | ||
425 | /* For compatibility and historical reasons, a char should be signed. */ | |
426 | #define DEFAULT_SIGNED_CHAR 1 | |
427 | ||
0b85d816 HPN |
428 | /* Note that WCHAR_TYPE_SIZE is used in cexp.y, |
429 | where TARGET_SHORT is not available. */ | |
430 | #undef WCHAR_TYPE | |
431 | #define WCHAR_TYPE "long int" | |
432 | ||
433 | #undef WCHAR_TYPE_SIZE | |
434 | #define WCHAR_TYPE_SIZE 32 | |
435 | ||
436 | ||
437 | /* Node: Register Basics */ | |
438 | ||
f60c7155 | 439 | /* We count all 16 non-special registers, SRP, a faked argument |
f9968e3e HPN |
440 | pointer register, MOF and CCR/DCCR. */ |
441 | #define FIRST_PSEUDO_REGISTER (16 + 1 + 1 + 1 + 1) | |
0b85d816 HPN |
442 | |
443 | /* For CRIS, these are r15 (pc) and r14 (sp). Register r8 is used as a | |
444 | frame-pointer, but is not fixed. SRP is not included in general | |
445 | registers and will not be used automatically. All other special | |
446 | registers are fixed at the moment. The faked argument pointer register | |
447 | is fixed too. */ | |
448 | #define FIXED_REGISTERS \ | |
f9968e3e | 449 | {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0} |
0b85d816 HPN |
450 | |
451 | /* Register r9 is used for structure-address, r10-r13 for parameters, | |
452 | r10- for return values. */ | |
453 | #define CALL_USED_REGISTERS \ | |
f9968e3e | 454 | {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1} |
0b85d816 HPN |
455 | |
456 | #define CONDITIONAL_REGISTER_USAGE cris_conditional_register_usage () | |
457 | ||
458 | ||
459 | /* Node: Allocation Order */ | |
460 | ||
461 | /* We need this on CRIS, because call-used regs should be used first, | |
f710504c | 462 | (so we don't need to push). Else start using registers from r0 and up. |
0b85d816 HPN |
463 | This preference is mainly because if we put call-used-regs from r0 |
464 | and up, then we can't use movem to push the rest, (which have to be | |
465 | saved if we use them, and movem has to start with r0). | |
466 | Change here if you change which registers to use as call registers. | |
467 | ||
468 | The actual need to explicitly prefer call-used registers improved the | |
469 | situation a lot for 2.1, but might not actually be needed anymore. | |
470 | Still, this order reflects what GCC should find out by itself, so it | |
471 | probably does not hurt. | |
472 | ||
473 | Order of preference: Call-used-regs first, then r0 and up, last fp & | |
474 | sp & pc as fillers. | |
475 | Call-used regs in opposite order, so they will cause less conflict if | |
476 | a function has few args (<= 3) and it wants a scratch reg. | |
477 | Use struct-return address first, since very few functions use | |
478 | structure return values so it is likely to be available. */ | |
479 | #define REG_ALLOC_ORDER \ | |
f9968e3e | 480 | {9, 13, 12, 11, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 14, 15, 17, 16, 18, 19} |
0b85d816 | 481 | |
6725c402 HPN |
482 | /* Use MOF and ACR. Prefer ACR before any other register. Prefer MOF |
483 | then SRP after saved registers. The *after* is because they're only | |
484 | useful for storage, not for things being computed, which is | |
485 | apparently more common. */ | |
486 | #define REG_ALLOC_ORDER_V32 \ | |
487 | {15, 9, 13, 12, 11, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 17, 16, 14, 18, 19} | |
488 | ||
0b85d816 HPN |
489 | |
490 | /* Node: Values in Registers */ | |
491 | ||
492 | /* The VOIDmode test is so we can omit mode on anonymous insns. FIXME: | |
493 | Still needed in 2.9x, at least for Axis-20000319. */ | |
494 | #define HARD_REGNO_NREGS(REGNO, MODE) \ | |
495 | (MODE == VOIDmode \ | |
496 | ? 1 : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)) | |
497 | ||
f9968e3e HPN |
498 | /* CRIS permits all registers to hold all modes. Well, except for the |
499 | condition-code register. And we can't hold larger-than-register size | |
500 | modes in the last special register that can hold a full 32 bits. */ | |
501 | #define HARD_REGNO_MODE_OK(REGNO, MODE) \ | |
502 | (((MODE) == CCmode \ | |
503 | || (REGNO) != CRIS_CC0_REGNUM) \ | |
504 | && (GET_MODE_SIZE (MODE) <= UNITS_PER_WORD \ | |
6725c402 | 505 | || ((REGNO) != CRIS_MOF_REGNUM && (REGNO) != CRIS_ACR_REGNUM))) |
0b85d816 | 506 | |
f9968e3e HPN |
507 | /* Because CCmode isn't covered by the "narrower mode" statement in |
508 | tm.texi, we can still say all modes are tieable despite not having an | |
509 | always 1 HARD_REGNO_MODE_OK. */ | |
510 | #define MODES_TIEABLE_P(MODE1, MODE2) 1 | |
0b85d816 HPN |
511 | |
512 | ||
513 | /* Node: Leaf Functions */ | |
514 | /* (no definitions) */ | |
515 | ||
516 | /* Node: Stack Registers */ | |
517 | /* (no definitions) */ | |
518 | ||
519 | ||
520 | /* Node: Register Classes */ | |
521 | ||
6725c402 HPN |
522 | /* FIXME: A separate class for the return register would make sense. |
523 | ||
524 | We need a separate register class to handle register allocation for | |
525 | ACR, since it can't be used for post-increment. | |
526 | ||
527 | It's not obvious, but having subunions of all movable-between | |
528 | register classes does really help register allocation. */ | |
529 | enum reg_class | |
f60c7155 HPN |
530 | { |
531 | NO_REGS, | |
6725c402 HPN |
532 | ACR_REGS, MOF_REGS, CC0_REGS, SPECIAL_REGS, |
533 | SPEC_ACR_REGS, GENNONACR_REGS, | |
534 | SPEC_GENNONACR_REGS, GENERAL_REGS, | |
535 | ALL_REGS, | |
f60c7155 HPN |
536 | LIM_REG_CLASSES |
537 | }; | |
0b85d816 HPN |
538 | |
539 | #define N_REG_CLASSES (int) LIM_REG_CLASSES | |
540 | ||
6725c402 HPN |
541 | #define REG_CLASS_NAMES \ |
542 | {"NO_REGS", \ | |
543 | "ACR_REGS", "MOF_REGS", "CC0_REGS", "SPECIAL_REGS", \ | |
544 | "SPEC_ACR_REGS", "GENNONACR_REGS", "SPEC_GENNONACR_REGS", \ | |
545 | "GENERAL_REGS", "ALL_REGS"} | |
0b85d816 | 546 | |
f60c7155 | 547 | #define CRIS_SPECIAL_REGS_CONTENTS \ |
f9968e3e | 548 | ((1 << CRIS_SRP_REGNUM) | (1 << CRIS_MOF_REGNUM) | (1 << CRIS_CC0_REGNUM)) |
0b85d816 HPN |
549 | |
550 | /* Count in the faked argument register in GENERAL_REGS. Keep out SRP. */ | |
f60c7155 HPN |
551 | #define REG_CLASS_CONTENTS \ |
552 | { \ | |
553 | {0}, \ | |
6725c402 | 554 | {1 << CRIS_ACR_REGNUM}, \ |
f60c7155 | 555 | {1 << CRIS_MOF_REGNUM}, \ |
f9968e3e | 556 | {1 << CRIS_CC0_REGNUM}, \ |
f60c7155 | 557 | {CRIS_SPECIAL_REGS_CONTENTS}, \ |
6725c402 HPN |
558 | {CRIS_SPECIAL_REGS_CONTENTS \ |
559 | | (1 << CRIS_ACR_REGNUM)}, \ | |
560 | {(0xffff | (1 << CRIS_AP_REGNUM)) \ | |
561 | & ~(1 << CRIS_ACR_REGNUM)}, \ | |
562 | {(0xffff | (1 << CRIS_AP_REGNUM) \ | |
563 | | CRIS_SPECIAL_REGS_CONTENTS) \ | |
564 | & ~(1 << CRIS_ACR_REGNUM)}, \ | |
f9968e3e HPN |
565 | {0xffff | (1 << CRIS_AP_REGNUM)}, \ |
566 | {0xffff | (1 << CRIS_AP_REGNUM) \ | |
567 | | CRIS_SPECIAL_REGS_CONTENTS} \ | |
f60c7155 HPN |
568 | } |
569 | ||
570 | #define REGNO_REG_CLASS(REGNO) \ | |
6725c402 HPN |
571 | ((REGNO) == CRIS_ACR_REGNUM ? ACR_REGS : \ |
572 | (REGNO) == CRIS_MOF_REGNUM ? MOF_REGS : \ | |
f9968e3e | 573 | (REGNO) == CRIS_CC0_REGNUM ? CC0_REGS : \ |
f60c7155 HPN |
574 | (REGNO) == CRIS_SRP_REGNUM ? SPECIAL_REGS : \ |
575 | GENERAL_REGS) | |
0b85d816 HPN |
576 | |
577 | #define BASE_REG_CLASS GENERAL_REGS | |
578 | ||
6725c402 HPN |
579 | #define MODE_CODE_BASE_REG_CLASS(MODE, OCODE, ICODE) \ |
580 | ((OCODE) != POST_INC ? BASE_REG_CLASS : GENNONACR_REGS) | |
581 | ||
0b85d816 HPN |
582 | #define INDEX_REG_CLASS GENERAL_REGS |
583 | ||
e53c2677 HPN |
584 | #define IRA_COVER_CLASSES { GENERAL_REGS, SPECIAL_REGS, LIM_REG_CLASSES } |
585 | ||
f60c7155 HPN |
586 | #define REG_CLASS_FROM_LETTER(C) \ |
587 | ( \ | |
6725c402 | 588 | (C) == 'a' ? ACR_REGS : \ |
fe82487e | 589 | (C) == 'b' ? GENNONACR_REGS : \ |
f60c7155 HPN |
590 | (C) == 'h' ? MOF_REGS : \ |
591 | (C) == 'x' ? SPECIAL_REGS : \ | |
f9968e3e | 592 | (C) == 'c' ? CC0_REGS : \ |
f60c7155 HPN |
593 | NO_REGS \ |
594 | ) | |
0b85d816 HPN |
595 | |
596 | /* Since it uses reg_renumber, it is safe only once reg_renumber | |
597 | has been allocated, which happens in local-alloc.c. */ | |
598 | #define REGNO_OK_FOR_BASE_P(REGNO) \ | |
599 | ((REGNO) <= CRIS_LAST_GENERAL_REGISTER \ | |
600 | || (REGNO) == ARG_POINTER_REGNUM \ | |
601 | || (unsigned) reg_renumber[REGNO] <= CRIS_LAST_GENERAL_REGISTER \ | |
602 | || (unsigned) reg_renumber[REGNO] == ARG_POINTER_REGNUM) | |
603 | ||
6725c402 HPN |
604 | /* REGNO_OK_FOR_BASE_P seems to be obsolete wrt. this one, but not yet |
605 | documented as such. */ | |
606 | #define REGNO_MODE_CODE_OK_FOR_BASE_P(REGNO, MODE, OCODE, ICODE) \ | |
607 | (REGNO_OK_FOR_BASE_P (REGNO) \ | |
608 | && ((OCODE) != POST_INC \ | |
609 | || !((REGNO) == CRIS_ACR_REGNUM \ | |
610 | || (unsigned) reg_renumber[REGNO] == CRIS_ACR_REGNUM))) | |
611 | ||
0b85d816 HPN |
612 | /* See REGNO_OK_FOR_BASE_P. */ |
613 | #define REGNO_OK_FOR_INDEX_P(REGNO) REGNO_OK_FOR_BASE_P(REGNO) | |
614 | ||
615 | /* It seems like gcc (2.7.2 and 2.9x of 2000-03-22) may send "NO_REGS" as | |
616 | the class for a constant (testcase: __Mul in arit.c). To avoid forcing | |
617 | out a constant into the constant pool, we will trap this case and | |
f60c7155 HPN |
618 | return something a bit more sane. FIXME: Check if this is a bug. |
619 | Beware that we must not "override" classes that can be specified as | |
620 | constraint letters, or else asm operands using them will fail when | |
621 | they need to be reloaded. FIXME: Investigate whether that constitutes | |
622 | a bug. */ | |
623 | #define PREFERRED_RELOAD_CLASS(X, CLASS) \ | |
6725c402 HPN |
624 | ((CLASS) != ACR_REGS \ |
625 | && (CLASS) != MOF_REGS \ | |
f9968e3e | 626 | && (CLASS) != CC0_REGS \ |
f60c7155 HPN |
627 | && (CLASS) != SPECIAL_REGS \ |
628 | ? GENERAL_REGS : (CLASS)) | |
629 | ||
630 | /* We can't move special registers to and from memory in smaller than | |
83907fdd HPN |
631 | word_mode. We also can't move between special registers. Luckily, |
632 | -1, as returned by true_regnum for non-sub/registers, is valid as a | |
633 | parameter to our REGNO_REG_CLASS, returning GENERAL_REGS, so we get | |
634 | the effect that any X that isn't a special-register is treated as | |
635 | a non-empty intersection with GENERAL_REGS. */ | |
636 | #define SECONDARY_RELOAD_CLASS(CLASS, MODE, X) \ | |
637 | ((((CLASS) == SPECIAL_REGS || (CLASS) == MOF_REGS) \ | |
638 | && ((GET_MODE_SIZE (MODE) < 4 && MEM_P (X)) \ | |
639 | || !reg_classes_intersect_p (REGNO_REG_CLASS (true_regnum (X)), \ | |
640 | GENERAL_REGS))) \ | |
641 | ? GENERAL_REGS : NO_REGS) | |
0b85d816 | 642 | |
6725c402 HPN |
643 | /* FIXME: Fix regrename.c; it should check validity of replacements, |
644 | not just with a silly pass-specific macro. We may miss some | |
645 | opportunities, but we must stop regrename from creating acr++. */ | |
646 | #define HARD_REGNO_RENAME_OK(FROM, TO) ((TO) != CRIS_ACR_REGNUM) | |
647 | ||
0b85d816 HPN |
648 | /* For CRIS, this is always the size of MODE in words, |
649 | since all registers are the same size. To use omitted modes in | |
650 | patterns with reload constraints, you must say the widest size | |
651 | which is allowed for VOIDmode. | |
652 | FIXME: Does that still apply for gcc-2.9x? Keep poisoned until such | |
653 | patterns are added back. News: 2001-03-16: Happens as early as the | |
654 | underscore-test. */ | |
655 | #define CLASS_MAX_NREGS(CLASS, MODE) \ | |
656 | ((MODE) == VOIDmode \ | |
657 | ? 1 /* + cris_fatal ("CLASS_MAX_NREGS with VOIDmode") */ \ | |
658 | : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)) | |
659 | ||
660 | /* We are now out of letters; we could use ten more. This forces us to | |
661 | use C-code in the 'md' file. FIXME: Use some EXTRA_CONSTRAINTS. */ | |
f49e46d8 | 662 | #define CRIS_CONST_OK_FOR_LETTER_P(VALUE, C) \ |
0b85d816 HPN |
663 | ( \ |
664 | /* MOVEQ, CMPQ, ANDQ, ORQ. */ \ | |
665 | (C) == 'I' ? (VALUE) >= -32 && (VALUE) <= 31 : \ | |
666 | /* ADDQ, SUBQ. */ \ | |
667 | (C) == 'J' ? (VALUE) >= 0 && (VALUE) <= 63 : \ | |
668 | /* ASRQ, BTSTQ, LSRQ, LSLQ. */ \ | |
669 | (C) == 'K' ? (VALUE) >= 0 && (VALUE) <= 31 : \ | |
670 | /* A 16-bit signed number. */ \ | |
671 | (C) == 'L' ? (VALUE) >= -32768 && (VALUE) <= 32767 : \ | |
672 | /* The constant 0 for CLEAR. */ \ | |
673 | (C) == 'M' ? (VALUE) == 0 : \ | |
674 | /* A negative ADDQ or SUBQ. */ \ | |
675 | (C) == 'N' ? (VALUE) >= -63 && (VALUE) < 0 : \ | |
676 | /* Quickened ints, QI and HI. */ \ | |
677 | (C) == 'O' ? (VALUE) >= 0 && (VALUE) <= 65535 \ | |
678 | && ((VALUE) >= (65535-31) \ | |
679 | || ((VALUE) >= (255-31) \ | |
680 | && (VALUE) <= 255 )) : \ | |
681 | /* A 16-bit number signed *or* unsigned. */ \ | |
682 | (C) == 'P' ? (VALUE) >= -32768 && (VALUE) <= 65535 : \ | |
683 | 0) | |
684 | ||
f49e46d8 HPN |
685 | #define CONST_OK_FOR_CONSTRAINT_P(VALUE, C, S) \ |
686 | ( \ | |
687 | ((C) != 'K' || (S)[1] == 'c') \ | |
688 | ? CRIS_CONST_OK_FOR_LETTER_P (VALUE, C) : \ | |
689 | ((C) == 'K' && (S)[1] == 'p') \ | |
690 | ? exact_log2 (VALUE) >= 0 : \ | |
691 | 0) | |
692 | ||
693 | #define CONSTRAINT_LEN(C, S) ((C) == 'K' ? 2 : DEFAULT_CONSTRAINT_LEN (C, S)) | |
694 | ||
0b85d816 | 695 | /* It is really simple to make up a 0.0; it is the same as int-0 in |
e5837c07 | 696 | IEEE754. */ |
0b85d816 HPN |
697 | #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) \ |
698 | ((C) == 'G' && ((VALUE) == CONST0_RTX (DFmode) \ | |
699 | || (VALUE) == CONST0_RTX (SFmode))) | |
700 | ||
701 | /* We need this on cris to distinguish delay-slottable addressing modes. */ | |
702 | #define EXTRA_CONSTRAINT(X, C) \ | |
703 | ( \ | |
704 | /* Slottable address mode? */ \ | |
705 | (C) == 'Q' ? EXTRA_CONSTRAINT_Q (X) : \ | |
706 | /* Operand to BDAP or BIAP? */ \ | |
707 | (C) == 'R' ? EXTRA_CONSTRAINT_R (X) : \ | |
708 | /* A local PIC symbol? */ \ | |
709 | (C) == 'S' ? EXTRA_CONSTRAINT_S (X) : \ | |
710 | /* A three-address addressing-mode? */ \ | |
711 | (C) == 'T' ? EXTRA_CONSTRAINT_T (X) : \ | |
6725c402 HPN |
712 | /* A PLT symbol? */ \ |
713 | (C) == 'U' ? EXTRA_CONSTRAINT_U (X) : \ | |
0b85d816 HPN |
714 | 0) |
715 | ||
23369bef HPN |
716 | #define EXTRA_MEMORY_CONSTRAINT(X, STR) ((X) == 'Q') |
717 | ||
0b85d816 HPN |
718 | #define EXTRA_CONSTRAINT_Q(X) \ |
719 | ( \ | |
23369bef HPN |
720 | /* Just an indirect register (happens to also be \ |
721 | "all" slottable memory addressing modes not \ | |
722 | covered by other constraints, i.e. '>'). */ \ | |
991c42ac | 723 | MEM_P (X) && BASE_P (XEXP (X, 0)) \ |
0b85d816 HPN |
724 | ) |
725 | ||
726 | #define EXTRA_CONSTRAINT_R(X) \ | |
727 | ( \ | |
728 | /* An operand to BDAP or BIAP: \ | |
729 | A BIAP; r.S? */ \ | |
730 | BIAP_INDEX_P (X) \ | |
731 | /* A [reg] or (int) [reg], maybe with post-increment. */ \ | |
732 | || BDAP_INDEX_P (X) \ | |
733 | || CONSTANT_INDEX_P (X) \ | |
734 | ) | |
735 | ||
0b85d816 HPN |
736 | #define EXTRA_CONSTRAINT_T(X) \ |
737 | ( \ | |
d3295e25 | 738 | /* Memory three-address operand. All are indirect-memory: */ \ |
991c42ac JBG |
739 | MEM_P (X) \ |
740 | && ((MEM_P (XEXP (X, 0)) \ | |
d3295e25 HPN |
741 | /* Double indirect: [[reg]] or [[reg+]]? */ \ |
742 | && (BASE_OR_AUTOINCR_P (XEXP (XEXP (X, 0), 0)))) \ | |
45b677bc | 743 | /* Just an explicit indirect reference: [const]? */ \ |
0b85d816 HPN |
744 | || CONSTANT_P (XEXP (X, 0)) \ |
745 | /* Something that is indexed; [...+...]? */ \ | |
746 | || (GET_CODE (XEXP (X, 0)) == PLUS \ | |
747 | /* A BDAP constant: [reg+(8|16|32)bit offset]? */ \ | |
748 | && ((BASE_P (XEXP (XEXP (X, 0), 0)) \ | |
749 | && CONSTANT_INDEX_P (XEXP (XEXP (X, 0), 1))) \ | |
0b85d816 HPN |
750 | /* A BDAP register: [reg+[reg(+)].S]? */ \ |
751 | || (BASE_P (XEXP (XEXP (X, 0), 0)) \ | |
752 | && BDAP_INDEX_P(XEXP(XEXP(X, 0), 1))) \ | |
39fbb17b HPN |
753 | /* Same, but with swapped arguments (no canonical \ |
754 | ordering between e.g. REG and MEM as of LAST_UPDATED \ | |
755 | "Thu May 12 03:59:11 UTC 2005"). */ \ | |
0b85d816 HPN |
756 | || (BASE_P (XEXP (XEXP (X, 0), 1)) \ |
757 | && BDAP_INDEX_P (XEXP (XEXP (X, 0), 0))) \ | |
39fbb17b | 758 | /* A BIAP: [reg+reg.S] (MULT comes first). */ \ |
0b85d816 HPN |
759 | || (BASE_P (XEXP (XEXP (X, 0), 1)) \ |
760 | && BIAP_INDEX_P (XEXP (XEXP (X, 0), 0)))))) \ | |
761 | ) | |
762 | ||
c00fc5cf | 763 | /* PIC-constructs for symbols. */ |
d29b4b1b | 764 | #define EXTRA_CONSTRAINT_S(X) \ |
6725c402 HPN |
765 | (flag_pic && GET_CODE (X) == CONST && cris_valid_pic_const (X, false)) |
766 | ||
767 | #define EXTRA_CONSTRAINT_U(X) \ | |
768 | (flag_pic \ | |
769 | && CONSTANT_P (X) \ | |
770 | && cris_nonmemory_operand_or_callable_symbol (X, VOIDmode)) | |
0b85d816 HPN |
771 | |
772 | ||
773 | /* Node: Frame Layout */ | |
774 | ||
775 | #define STACK_GROWS_DOWNWARD | |
f62c8a5c | 776 | #define FRAME_GROWS_DOWNWARD 1 |
0b85d816 HPN |
777 | |
778 | /* It seems to be indicated in the code (at least 2.1) that this is | |
779 | better a constant, and best 0. */ | |
780 | #define STARTING_FRAME_OFFSET 0 | |
781 | ||
782 | #define FIRST_PARM_OFFSET(FNDECL) 0 | |
783 | ||
784 | #define RETURN_ADDR_RTX(COUNT, FRAMEADDR) \ | |
785 | cris_return_addr_rtx (COUNT, FRAMEADDR) | |
786 | ||
f1c25d3b | 787 | #define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (Pmode, CRIS_SRP_REGNUM) |
0b85d816 HPN |
788 | |
789 | /* FIXME: Any __builtin_eh_return callers must not return anything and | |
790 | there must not be collisions with incoming parameters. Luckily the | |
791 | number of __builtin_eh_return callers is limited. For now return | |
792 | parameter registers in reverse order and hope for the best. */ | |
793 | #define EH_RETURN_DATA_REGNO(N) \ | |
2b371d25 | 794 | (IN_RANGE ((N), 0, 3) ? (CRIS_FIRST_ARG_REG + 3 - (N)) : INVALID_REGNUM) |
0b85d816 HPN |
795 | |
796 | /* Store the stack adjustment in the structure-return-address register. */ | |
a2fef3a4 | 797 | #define CRIS_STACKADJ_REG CRIS_STRUCT_VALUE_REGNUM |
0b85d816 HPN |
798 | #define EH_RETURN_STACKADJ_RTX gen_rtx_REG (SImode, CRIS_STACKADJ_REG) |
799 | ||
800 | #define EH_RETURN_HANDLER_RTX \ | |
801 | cris_return_addr_rtx (0, NULL) | |
802 | ||
803 | #define INIT_EXPANDERS cris_init_expanders () | |
804 | ||
805 | /* FIXME: Move this to right node (it's not documented properly yet). */ | |
806 | #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (CRIS_SRP_REGNUM) | |
807 | ||
808 | /* FIXME: Move this to right node (it's not documented properly yet). | |
809 | FIXME: Check what alignment we can assume regarding | |
810 | TARGET_STACK_ALIGN and TARGET_ALIGN_BY_32. */ | |
811 | #define DWARF_CIE_DATA_ALIGNMENT -1 | |
812 | ||
a338be44 KG |
813 | /* If we would ever need an exact mapping between canonical register |
814 | number and dwarf frame register, we would either need to include all | |
839a4992 | 815 | registers in the gcc description (with some marked fixed of course), or |
a338be44 KG |
816 | an inverse mapping from dwarf register to gcc register. There is one |
817 | need in dwarf2out.c:expand_builtin_init_dwarf_reg_sizes. Right now, I | |
818 | don't see that we need exact correspondence between DWARF *frame* | |
819 | registers and DBX_REGISTER_NUMBER, so map them onto GCC registers. */ | |
820 | #define DWARF_FRAME_REGNUM(REG) (REG) | |
821 | ||
0b85d816 HPN |
822 | /* Node: Stack Checking */ |
823 | /* (no definitions) FIXME: Check. */ | |
824 | ||
825 | /* Node: Frame Registers */ | |
826 | ||
f60c7155 | 827 | #define STACK_POINTER_REGNUM CRIS_SP_REGNUM |
0b85d816 HPN |
828 | |
829 | /* Register used for frame pointer. This is also the last of the saved | |
e5837c07 | 830 | registers, when a frame pointer is not used. */ |
f60c7155 | 831 | #define FRAME_POINTER_REGNUM CRIS_FP_REGNUM |
0b85d816 HPN |
832 | |
833 | /* Faked register, is always eliminated. We need it to eliminate | |
834 | allocating stack slots for the return address and the frame pointer. */ | |
f60c7155 | 835 | #define ARG_POINTER_REGNUM CRIS_AP_REGNUM |
0b85d816 | 836 | |
f60c7155 | 837 | #define STATIC_CHAIN_REGNUM CRIS_STATIC_CHAIN_REGNUM |
0b85d816 HPN |
838 | |
839 | ||
840 | /* Node: Elimination */ | |
841 | ||
0b85d816 HPN |
842 | #define ELIMINABLE_REGS \ |
843 | {{ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \ | |
844 | {ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM}, \ | |
845 | {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}} | |
846 | ||
0b85d816 HPN |
847 | #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \ |
848 | (OFFSET) = cris_initial_elimination_offset (FROM, TO) | |
849 | ||
850 | ||
851 | /* Node: Stack Arguments */ | |
852 | ||
853 | /* Since many parameters take up one register each in any case, | |
a2fef3a4 KH |
854 | defining TARGET_PROMOTE_PROTOTYPES that always returns true would |
855 | seem like a good idea, but measurements indicate that a combination | |
856 | using PROMOTE_MODE is better. */ | |
0b85d816 HPN |
857 | |
858 | #define ACCUMULATE_OUTGOING_ARGS 1 | |
859 | ||
0b85d816 HPN |
860 | |
861 | /* Node: Register Arguments */ | |
862 | ||
8cd5a4e0 | 863 | /* The void_type_node is sent as a "closing" call. */ |
0b85d816 HPN |
864 | #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \ |
865 | ((CUM).regs < CRIS_MAX_ARGS_IN_REGS \ | |
f1c25d3b | 866 | ? gen_rtx_REG (MODE, (CRIS_FIRST_ARG_REG) + (CUM).regs) \ |
0b85d816 HPN |
867 | : NULL_RTX) |
868 | ||
869 | /* The differences between this and the previous, is that this one checks | |
870 | that an argument is named, since incoming stdarg/varargs arguments are | |
871 | pushed onto the stack, and we don't have to check against the "closing" | |
872 | void_type_node TYPE parameter. */ | |
8cd5a4e0 RH |
873 | #define FUNCTION_INCOMING_ARG(CUM, MODE, TYPE, NAMED) \ |
874 | ((NAMED) && (CUM).regs < CRIS_MAX_ARGS_IN_REGS \ | |
f1c25d3b | 875 | ? gen_rtx_REG (MODE, CRIS_FIRST_ARG_REG + (CUM).regs) \ |
0b85d816 HPN |
876 | : NULL_RTX) |
877 | ||
0b85d816 HPN |
878 | /* Contrary to what you'd believe, defining FUNCTION_ARG_CALLEE_COPIES |
879 | seems like a (small total) loss, at least for gcc-2.7.2 compiling and | |
880 | running gcc-2.1 (small win in size, small loss running -- 100.1%), | |
881 | and similarly for size for products (.1 .. .3% bloat, sometimes win). | |
882 | Due to the empirical likeliness of making slower code, it is not | |
883 | defined. */ | |
884 | ||
885 | /* This no longer *needs* to be a structure; but keeping it as such should | |
886 | not hurt (and hacking the ABI is simpler). */ | |
887 | #define CUMULATIVE_ARGS struct cum_args | |
888 | struct cum_args {int regs;}; | |
889 | ||
890 | /* The regs member is an integer, the number of arguments got into | |
fa5848c7 | 891 | registers so far. */ |
0f6937fe | 892 | #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, FNDECL, N_NAMED_ARGS) \ |
0b85d816 HPN |
893 | ((CUM).regs = 0) |
894 | ||
895 | #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \ | |
8cd5a4e0 | 896 | ((CUM).regs += (3 + CRIS_FUNCTION_ARG_SIZE (MODE, TYPE)) / 4) |
0b85d816 HPN |
897 | |
898 | #define FUNCTION_ARG_REGNO_P(REGNO) \ | |
899 | ((REGNO) >= CRIS_FIRST_ARG_REG \ | |
900 | && (REGNO) < CRIS_FIRST_ARG_REG + (CRIS_MAX_ARGS_IN_REGS)) | |
901 | ||
902 | ||
903 | /* Node: Scalar Return */ | |
904 | ||
4d696ad0 | 905 | #define FUNCTION_VALUE_REGNO_P(N) cris_function_value_regno_p (N) |
0b85d816 | 906 | |
0b85d816 HPN |
907 | |
908 | ||
909 | /* Node: Aggregate Return */ | |
910 | ||
a2fef3a4 | 911 | #define CRIS_STRUCT_VALUE_REGNUM ((CRIS_FIRST_ARG_REG) - 1) |
0b85d816 HPN |
912 | |
913 | ||
914 | /* Node: Caller Saves */ | |
915 | /* (no definitions) */ | |
916 | ||
917 | /* Node: Function entry */ | |
918 | ||
919 | /* See cris.c for TARGET_ASM_FUNCTION_PROLOGUE and | |
920 | TARGET_ASM_FUNCTION_EPILOGUE. */ | |
921 | ||
0b85d816 HPN |
922 | /* Node: Profiling */ |
923 | ||
924 | #define FUNCTION_PROFILER(FILE, LABELNO) \ | |
c725bd79 | 925 | error ("no FUNCTION_PROFILER for CRIS") |
0b85d816 | 926 | |
0b85d816 HPN |
927 | /* FIXME: Some of the undefined macros might be mandatory. If so, fix |
928 | documentation. */ | |
929 | ||
930 | ||
0b85d816 HPN |
931 | /* Node: Trampolines */ |
932 | ||
6725c402 | 933 | #define TRAMPOLINE_SIZE (TARGET_V32 ? 58 : 32) |
0b85d816 | 934 | |
3e322b77 | 935 | /* CRIS wants instructions on word-boundary. */ |
0b85d816 HPN |
936 | #define TRAMPOLINE_ALIGNMENT 16 |
937 | ||
0b85d816 HPN |
938 | /* Node: Library Calls */ |
939 | ||
0b85d816 HPN |
940 | /* If you change this, you have to check whatever libraries and systems |
941 | that use it. */ | |
942 | #define TARGET_EDOM 33 | |
943 | ||
944 | ||
945 | /* Node: Addressing Modes */ | |
946 | ||
947 | #define HAVE_POST_INCREMENT 1 | |
948 | ||
6725c402 HPN |
949 | /* Must be a compile-time constant, so we go with the highest value |
950 | among all CRIS variants. */ | |
0b85d816 HPN |
951 | #define MAX_REGS_PER_ADDRESS 2 |
952 | ||
953 | /* There are helper macros defined here which are used only in | |
954 | GO_IF_LEGITIMATE_ADDRESS. | |
955 | ||
956 | Note that you *have to* reject invalid addressing modes for mode | |
957 | MODE, even if it is legal for normal addressing modes. You cannot | |
958 | rely on the constraints to do this work. They can only be used to | |
959 | doublecheck your intentions. One example is that you HAVE TO reject | |
960 | (mem:DI (plus:SI (reg:SI x) (reg:SI y))) because for some reason | |
961 | this cannot be reloaded. (Which of course you can argue that gcc | |
962 | should have done.) FIXME: Strange. Check. */ | |
963 | ||
964 | /* No symbol can be used as an index (or more correct, as a base) together | |
965 | with a register with PIC; the PIC register must be there. */ | |
966 | #define CONSTANT_INDEX_P(X) \ | |
6725c402 | 967 | (CONSTANT_P (X) && (!flag_pic || cris_valid_pic_const (X, true))) |
0b85d816 HPN |
968 | |
969 | /* True if X is a valid base register. */ | |
970 | #define BASE_P(X) \ | |
971 | (REG_P (X) && REG_OK_FOR_BASE_P (X)) | |
972 | ||
973 | /* True if X is a valid base register with or without autoincrement. */ | |
6725c402 HPN |
974 | #define BASE_OR_AUTOINCR_P(X) \ |
975 | (BASE_P (X) \ | |
976 | || (GET_CODE (X) == POST_INC \ | |
977 | && BASE_P (XEXP (X, 0)) \ | |
978 | && REGNO (XEXP (X, 0)) != CRIS_ACR_REGNUM)) | |
0b85d816 HPN |
979 | |
980 | /* True if X is a valid (register) index for BDAP, i.e. [Rs].S or [Rs+].S. */ | |
981 | #define BDAP_INDEX_P(X) \ | |
991c42ac | 982 | ((MEM_P (X) && GET_MODE (X) == SImode \ |
0b85d816 HPN |
983 | && BASE_OR_AUTOINCR_P (XEXP (X, 0))) \ |
984 | || (GET_CODE (X) == SIGN_EXTEND \ | |
991c42ac | 985 | && MEM_P (XEXP (X, 0)) \ |
0b85d816 HPN |
986 | && (GET_MODE (XEXP (X, 0)) == HImode \ |
987 | || GET_MODE (XEXP (X, 0)) == QImode) \ | |
988 | && BASE_OR_AUTOINCR_P (XEXP (XEXP (X, 0), 0)))) | |
989 | ||
990 | /* True if X is a valid (register) index for BIAP, i.e. Rd.m. */ | |
991 | #define BIAP_INDEX_P(X) \ | |
992 | ((BASE_P (X) && REG_OK_FOR_INDEX_P (X)) \ | |
993 | || (GET_CODE (X) == MULT \ | |
994 | && BASE_P (XEXP (X, 0)) \ | |
995 | && REG_OK_FOR_INDEX_P (XEXP (X, 0)) \ | |
991c42ac | 996 | && CONST_INT_P (XEXP (X, 1)) \ |
0b85d816 HPN |
997 | && (INTVAL (XEXP (X, 1)) == 2 \ |
998 | || INTVAL (XEXP (X, 1)) == 4))) | |
999 | ||
0b85d816 HPN |
1000 | /* A PIC operand looks like a normal symbol here. At output we dress it |
1001 | in "[rPIC+symbol:GOT]" (global symbol) or "rPIC+symbol:GOTOFF" (local | |
1002 | symbol) so we exclude all addressing modes where we can't replace a | |
1003 | plain "symbol" with that. A global PIC symbol does not fit anywhere | |
1004 | here (but is thankfully a general_operand in itself). A local PIC | |
1005 | symbol is valid for the plain "symbol + offset" case. */ | |
1006 | #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \ | |
1007 | { \ | |
1008 | rtx x1, x2; \ | |
6725c402 | 1009 | if (BASE_OR_AUTOINCR_P (X)) \ |
0b85d816 | 1010 | goto ADDR; \ |
6725c402 HPN |
1011 | else if (TARGET_V32) \ |
1012 | /* Nothing else is valid then. */ \ | |
1013 | ; \ | |
1014 | else if (CONSTANT_INDEX_P (X)) \ | |
0b85d816 HPN |
1015 | goto ADDR; \ |
1016 | /* Indexed? */ \ | |
6725c402 | 1017 | else if (GET_CODE (X) == PLUS) \ |
0b85d816 HPN |
1018 | { \ |
1019 | x1 = XEXP (X, 0); \ | |
1020 | x2 = XEXP (X, 1); \ | |
1021 | /* BDAP o, Rd. */ \ | |
1022 | if ((BASE_P (x1) && CONSTANT_INDEX_P (x2)) \ | |
1023 | || (BASE_P (x2) && CONSTANT_INDEX_P (x1)) \ | |
1024 | /* BDAP Rs[+], Rd. */ \ | |
1025 | || (GET_MODE_SIZE (MODE) <= UNITS_PER_WORD \ | |
1026 | && ((BASE_P (x1) && BDAP_INDEX_P (x2)) \ | |
1027 | || (BASE_P (x2) && BDAP_INDEX_P (x1)) \ | |
1028 | /* BIAP.m Rs, Rd */ \ | |
1029 | || (BASE_P (x1) && BIAP_INDEX_P (x2)) \ | |
1030 | || (BASE_P (x2) && BIAP_INDEX_P (x1))))) \ | |
1031 | goto ADDR; \ | |
1032 | } \ | |
991c42ac | 1033 | else if (MEM_P (X)) \ |
0b85d816 HPN |
1034 | { \ |
1035 | /* DIP (Rs). Reject [[reg+]] and [[reg]] for \ | |
1036 | DImode (long long). */ \ | |
1037 | if (GET_MODE_SIZE (MODE) <= UNITS_PER_WORD \ | |
1038 | && (BASE_P (XEXP (X, 0)) \ | |
1039 | || BASE_OR_AUTOINCR_P (XEXP (X, 0)))) \ | |
1040 | goto ADDR; \ | |
1041 | } \ | |
1042 | } | |
1043 | ||
1044 | #ifndef REG_OK_STRICT | |
1045 | /* Nonzero if X is a hard reg that can be used as a base reg | |
1046 | or if it is a pseudo reg. */ | |
1047 | # define REG_OK_FOR_BASE_P(X) \ | |
1048 | (REGNO (X) <= CRIS_LAST_GENERAL_REGISTER \ | |
1049 | || REGNO (X) == ARG_POINTER_REGNUM \ | |
1050 | || REGNO (X) >= FIRST_PSEUDO_REGISTER) | |
1051 | #else | |
1052 | /* Nonzero if X is a hard reg that can be used as a base reg. */ | |
1053 | # define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X)) | |
1054 | #endif | |
1055 | ||
1056 | #ifndef REG_OK_STRICT | |
1057 | /* Nonzero if X is a hard reg that can be used as an index | |
1058 | or if it is a pseudo reg. */ | |
1059 | # define REG_OK_FOR_INDEX_P(X) REG_OK_FOR_BASE_P (X) | |
1060 | #else | |
1061 | /* Nonzero if X is a hard reg that can be used as an index. */ | |
1062 | # define REG_OK_FOR_INDEX_P(X) REGNO_OK_FOR_INDEX_P (REGNO (X)) | |
1063 | #endif | |
1064 | ||
15883505 HPN |
1065 | /* Fix reloads known to cause suboptimal spilling. */ |
1066 | #define LEGITIMIZE_RELOAD_ADDRESS(X, MODE, OPNUM, TYPE, INDL, WIN) \ | |
1067 | do \ | |
1068 | { \ | |
1069 | if (cris_reload_address_legitimized (X, MODE, OPNUM, TYPE, INDL)) \ | |
1070 | goto WIN; \ | |
1071 | } \ | |
1072 | while (0) | |
1073 | ||
0b85d816 HPN |
1074 | #define LEGITIMATE_CONSTANT_P(X) 1 |
1075 | ||
1076 | ||
1077 | /* Node: Condition Code */ | |
1078 | ||
1079 | #define NOTICE_UPDATE_CC(EXP, INSN) cris_notice_update_cc (EXP, INSN) | |
1080 | ||
1081 | /* FIXME: Maybe define CANONICALIZE_COMPARISON later, when playing with | |
1082 | optimizations. It is needed; currently we do this with instruction | |
1083 | patterns and NOTICE_UPDATE_CC. */ | |
1084 | ||
1085 | ||
1086 | /* Node: Costs */ | |
1087 | ||
6725c402 HPN |
1088 | #define REGISTER_MOVE_COST(MODE, FROM, TO) \ |
1089 | cris_register_move_cost (MODE, FROM, TO) | |
0b85d816 HPN |
1090 | |
1091 | /* This isn't strictly correct for v0..3 in buswidth-8bit mode, but | |
1092 | should suffice. */ | |
1093 | #define MEMORY_MOVE_COST(M, CLASS, IN) \ | |
1094 | (((M) == QImode) ? 4 : ((M) == HImode) ? 4 : 6) | |
1095 | ||
1096 | /* Regardless of the presence of delay slots, the default value of 1 for | |
1097 | BRANCH_COST is the best in the range (1, 2, 3), tested with gcc-2.7.2 | |
1098 | with testcases ipps and gcc, giving smallest and fastest code. */ | |
1099 | ||
1100 | #define SLOW_BYTE_ACCESS 0 | |
1101 | ||
1102 | /* This is the threshold *below* which inline move sequences of | |
1103 | word-length sizes will be emitted. The "9" will translate to | |
1104 | (9 - 1) * 4 = 32 bytes maximum moved, but using 16 instructions | |
1105 | (8 instruction sequences) or less. */ | |
e04ad03d | 1106 | #define MOVE_RATIO(speed) 9 |
0b85d816 HPN |
1107 | |
1108 | ||
1109 | /* Node: Sections */ | |
1110 | ||
1111 | #define TEXT_SECTION_ASM_OP "\t.text" | |
1112 | ||
1113 | #define DATA_SECTION_ASM_OP "\t.data" | |
1114 | ||
1115 | #define FORCE_EH_FRAME_INFO_IN_DATA_SECTION (! TARGET_ELF) | |
1116 | ||
1117 | /* The jump table is immediately connected to the preceding insn. */ | |
1118 | #define JUMP_TABLES_IN_TEXT_SECTION 1 | |
1119 | ||
0b85d816 HPN |
1120 | |
1121 | /* Node: PIC */ | |
1122 | ||
c00fc5cf HPN |
1123 | /* Helper type. */ |
1124 | ||
1125 | enum cris_pic_symbol_type | |
1126 | { | |
1127 | cris_no_symbol = 0, | |
1128 | cris_got_symbol = 1, | |
6725c402 | 1129 | cris_rel_symbol = 2, |
c00fc5cf HPN |
1130 | cris_got_symbol_needing_fixup = 3, |
1131 | cris_invalid_pic_symbol = 4 | |
1132 | }; | |
1133 | ||
f60c7155 | 1134 | #define PIC_OFFSET_TABLE_REGNUM (flag_pic ? CRIS_GOT_REGNUM : INVALID_REGNUM) |
0b85d816 HPN |
1135 | |
1136 | #define LEGITIMATE_PIC_OPERAND_P(X) cris_legitimate_pic_operand (X) | |
1137 | ||
1138 | ||
1139 | /* Node: File Framework */ | |
1140 | ||
0b85d816 HPN |
1141 | /* We don't want an .ident for gcc. To avoid that but still support |
1142 | #ident, we override ASM_OUTPUT_IDENT and, since the gcc .ident is its | |
1143 | only use besides ASM_OUTPUT_IDENT, undef IDENT_ASM_OP from elfos.h. */ | |
1144 | #undef IDENT_ASM_OP | |
1145 | #undef ASM_OUTPUT_IDENT | |
1146 | #define ASM_OUTPUT_IDENT(FILE, NAME) \ | |
1147 | fprintf (FILE, "%s\"%s\"\n", "\t.ident\t", NAME); | |
1148 | ||
1149 | #define ASM_APP_ON "#APP\n" | |
1150 | ||
1151 | #define ASM_APP_OFF "#NO_APP\n" | |
1152 | ||
1153 | ||
1154 | /* Node: Data Output */ | |
1155 | ||
453bd0f5 HPN |
1156 | #define OUTPUT_ADDR_CONST_EXTRA(STREAM, X, FAIL) \ |
1157 | do { if (!cris_output_addr_const_extra (STREAM, X)) goto FAIL; } while (0) | |
1158 | ||
980d8882 | 1159 | #define IS_ASM_LOGICAL_LINE_SEPARATOR(C, STR) (C) == '@' |
0b85d816 | 1160 | |
0b85d816 HPN |
1161 | /* Node: Uninitialized Data */ |
1162 | ||
1163 | /* Remember to round off odd values if we want data alignment, | |
1164 | since we cannot do that with an .align directive. | |
1165 | ||
1166 | Using .comm causes the space not to be reserved in .bss, but by | |
1167 | tricks with the symbol type. Not good if other tools than binutils | |
1168 | are used on the object files. Since ".global ... .lcomm ..." works, we | |
1169 | use that. Use .._ALIGNED_COMMON, since gcc whines when we only have | |
d6a7951f | 1170 | ..._COMMON, and we prefer to whine ourselves; BIGGEST_ALIGNMENT is not |
0b85d816 HPN |
1171 | the one to check. This done for a.out only. */ |
1172 | /* FIXME: I suspect a bug in gcc with alignment. Do not warn until | |
1173 | investigated; it mucks up the testsuite results. */ | |
1174 | #define CRIS_ASM_OUTPUT_ALIGNED_DECL_COMMON(FILE, DECL, NAME, SIZE, ALIGN, LOCAL) \ | |
1175 | do \ | |
1176 | { \ | |
1177 | int align_ = (ALIGN) / BITS_PER_UNIT; \ | |
1178 | if (TARGET_DATA_ALIGN && TARGET_ALIGN_BY_32 && align_ < 4) \ | |
1179 | align_ = 4; \ | |
1180 | else if (TARGET_DATA_ALIGN && align_ < 2) \ | |
1181 | align_ = 2; \ | |
1182 | /* FIXME: Do we need this? */ \ | |
1183 | else if (align_ < 1) \ | |
1184 | align_ = 1; \ | |
1185 | \ | |
1186 | if (TARGET_ELF) \ | |
1187 | { \ | |
1188 | if (LOCAL) \ | |
1189 | { \ | |
1190 | fprintf ((FILE), "%s", LOCAL_ASM_OP); \ | |
1191 | assemble_name ((FILE), (NAME)); \ | |
1192 | fprintf ((FILE), "\n"); \ | |
1193 | } \ | |
1194 | fprintf ((FILE), "%s", COMMON_ASM_OP); \ | |
1195 | assemble_name ((FILE), (NAME)); \ | |
58e15542 | 1196 | fprintf ((FILE), ",%u,%u\n", (int)(SIZE), align_); \ |
0b85d816 HPN |
1197 | } \ |
1198 | else \ | |
1199 | { \ | |
1200 | /* We can't tell a one-only or weak COMM from a "global \ | |
1201 | COMM" so just make all non-locals weak. */ \ | |
1202 | if (! (LOCAL)) \ | |
1203 | ASM_WEAKEN_LABEL (FILE, NAME); \ | |
1204 | fputs ("\t.lcomm ", (FILE)); \ | |
1205 | assemble_name ((FILE), (NAME)); \ | |
1206 | fprintf ((FILE), ",%u\n", \ | |
58e15542 | 1207 | ((int)(SIZE) + (align_ - 1)) & ~(align_ - 1)); \ |
0b85d816 HPN |
1208 | } \ |
1209 | } \ | |
1210 | while (0) | |
1211 | ||
1212 | #define ASM_OUTPUT_ALIGNED_DECL_COMMON(FILE, DECL, NAME, SIZE, ALIGN) \ | |
1213 | CRIS_ASM_OUTPUT_ALIGNED_DECL_COMMON(FILE, DECL, NAME, SIZE, ALIGN, 0) | |
1214 | ||
1215 | #undef ASM_OUTPUT_ALIGNED_DECL_LOCAL | |
1216 | #define ASM_OUTPUT_ALIGNED_DECL_LOCAL(FILE, DECL, NAME, SIZE, ALIGN) \ | |
1217 | CRIS_ASM_OUTPUT_ALIGNED_DECL_COMMON(FILE, DECL, NAME, SIZE, ALIGN, 1) | |
1218 | ||
0b85d816 HPN |
1219 | /* Node: Label Output */ |
1220 | ||
506a61b1 KG |
1221 | /* Globalizing directive for a label. */ |
1222 | #define GLOBAL_ASM_OP "\t.global " | |
0b85d816 HPN |
1223 | |
1224 | #define SUPPORTS_WEAK 1 | |
1225 | ||
453bd0f5 HPN |
1226 | #define ASM_OUTPUT_SYMBOL_REF(STREAM, SYM) \ |
1227 | cris_asm_output_symbol_ref (STREAM, SYM) | |
1228 | ||
1229 | #define ASM_OUTPUT_LABEL_REF(STREAM, BUF) \ | |
1230 | cris_asm_output_label_ref (STREAM, BUF) | |
1231 | ||
0b85d816 HPN |
1232 | /* Remove any previous definition (elfos.h). */ |
1233 | #undef ASM_GENERATE_INTERNAL_LABEL | |
1234 | #define ASM_GENERATE_INTERNAL_LABEL(LABEL, PREFIX, NUM) \ | |
1235 | sprintf (LABEL, "*%s%s%ld", LOCAL_LABEL_PREFIX, PREFIX, (long) NUM) | |
1236 | ||
0b85d816 HPN |
1237 | /* Node: Initialization */ |
1238 | /* (no definitions) */ | |
1239 | ||
1240 | /* Node: Macros for Initialization */ | |
44a4ca5e | 1241 | /* (no definitions) */ |
0b85d816 HPN |
1242 | |
1243 | /* Node: Instruction Output */ | |
1244 | ||
1245 | #define REGISTER_NAMES \ | |
1246 | {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", \ | |
6725c402 | 1247 | "r9", "r10", "r11", "r12", "r13", "sp", "acr", "srp", "mof", "faked_ap", "dccr"} |
0b85d816 HPN |
1248 | |
1249 | #define ADDITIONAL_REGISTER_NAMES \ | |
6725c402 | 1250 | {{"r14", 14}, {"r15", 15}, {"pc", 15}} |
0b85d816 | 1251 | |
0b85d816 HPN |
1252 | /* Output an empty line to illustrate the presence of the delay slot. */ |
1253 | #define DBR_OUTPUT_SEQEND(FILE) \ | |
1254 | fprintf (FILE, "\n") | |
1255 | ||
1256 | #define LOCAL_LABEL_PREFIX (TARGET_ELF ? "." : "") | |
1257 | ||
1258 | /* cppinit.c initializes a const array from this, so it must be constant, | |
1259 | can't have it different based on options. Luckily, the prefix is | |
1260 | always allowed, so let's have it on all GCC-generated code. Note that | |
1261 | we have this verbatim everywhere in the back-end, not using %R or %s or | |
1262 | such. */ | |
1263 | #define REGISTER_PREFIX "$" | |
1264 | ||
1265 | /* Remove any previous definition (elfos.h). */ | |
1266 | /* We use -fno-leading-underscore to remove it, when necessary. */ | |
1267 | #undef USER_LABEL_PREFIX | |
1268 | #define USER_LABEL_PREFIX "_" | |
1269 | ||
6725c402 HPN |
1270 | #define ASM_OUTPUT_REG_PUSH(FILE, REGNO) \ |
1271 | fprintf (FILE, \ | |
1272 | TARGET_V32 \ | |
1273 | ? "\tsubq 4,$sp\n\tmove $%s,[$sp]\n" : "\tpush $%s\n", \ | |
1274 | reg_names[REGNO]) | |
0b85d816 HPN |
1275 | |
1276 | #define ASM_OUTPUT_REG_POP(FILE, REGNO) \ | |
6725c402 | 1277 | fprintf (FILE, "\tmove [$sp+],$%s\n", reg_names[REGNO]) |
0b85d816 HPN |
1278 | |
1279 | ||
1280 | /* Node: Dispatch Tables */ | |
1281 | ||
6725c402 HPN |
1282 | #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) \ |
1283 | do \ | |
1284 | { \ | |
1285 | if (TARGET_V32) \ | |
1286 | asm_fprintf (FILE, "\t.word %LL%d-.\n", VALUE); \ | |
1287 | else \ | |
1288 | asm_fprintf (FILE, "\t.word %LL%d-%LL%d\n", VALUE, REL); \ | |
1289 | } \ | |
1290 | while (0) | |
0b85d816 HPN |
1291 | |
1292 | #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \ | |
1293 | asm_fprintf (FILE, "\t.dword %LL%d\n", VALUE) | |
1294 | ||
1295 | /* Defined to also emit an .align in elfos.h. We don't want that. */ | |
1296 | #undef ASM_OUTPUT_CASE_LABEL | |
1297 | ||
1298 | /* Since the "bound" insn loads the comparison value if the compared< | |
1299 | value (register) is out of bounds (0..comparison value-1), we need | |
1300 | to output another case to catch it. | |
1301 | The way to find it is to look for the label_ref at the else-arm inside | |
1302 | the expanded casesi core-insn. | |
1303 | FIXME: Check this construct when changing to new version of gcc. */ | |
1304 | #define ASM_OUTPUT_CASE_END(STREAM, NUM, TABLE) \ | |
6725c402 | 1305 | cris_asm_output_case_end (STREAM, NUM, TABLE) |
0b85d816 HPN |
1306 | |
1307 | ||
1308 | /* Node: Exception Region Output */ | |
1309 | /* (no definitions) */ | |
1310 | /* FIXME: Fill in with our own optimized layout. */ | |
1311 | ||
1312 | /* Node: Alignment Output */ | |
1313 | ||
1314 | #define ASM_OUTPUT_ALIGN(FILE, LOG) \ | |
1315 | fprintf (FILE, "\t.align %d\n", (LOG)) | |
1316 | ||
1317 | ||
1318 | /* Node: All Debuggers */ | |
1319 | ||
f60c7155 HPN |
1320 | #define DBX_REGISTER_NUMBER(REGNO) \ |
1321 | ((REGNO) == CRIS_SRP_REGNUM ? CRIS_CANONICAL_SRP_REGNUM : \ | |
1322 | (REGNO) == CRIS_MOF_REGNUM ? CRIS_CANONICAL_MOF_REGNUM : \ | |
f9968e3e | 1323 | (REGNO) == CRIS_CC0_REGNUM ? CRIS_CANONICAL_CC0_REGNUM : \ |
f60c7155 | 1324 | (REGNO)) |
0b85d816 HPN |
1325 | |
1326 | /* FIXME: Investigate DEBUGGER_AUTO_OFFSET, DEBUGGER_ARG_OFFSET. */ | |
1327 | ||
1328 | ||
1329 | /* Node: DBX Options */ | |
1330 | ||
e5837c07 | 1331 | /* Is this correct? Check later. */ |
0b85d816 HPN |
1332 | #define DBX_NO_XREFS |
1333 | ||
1334 | #define DBX_CONTIN_LENGTH 0 | |
1335 | ||
1336 | /* FIXME: Is this needed when we have 0 DBX_CONTIN_LENGTH? */ | |
1337 | #define DBX_CONTIN_CHAR '?' | |
1338 | ||
1339 | ||
1340 | /* Node: DBX Hooks */ | |
1341 | /* (no definitions) */ | |
1342 | ||
1343 | /* Node: File names and DBX */ | |
1344 | /* (no definitions) */ | |
1345 | ||
1346 | ||
1347 | /* Node: SDB and DWARF */ | |
d94084f7 | 1348 | /* (no definitions) */ |
0b85d816 | 1349 | |
0b85d816 HPN |
1350 | /* Node: Misc */ |
1351 | ||
0b85d816 HPN |
1352 | /* A combination of the bound (umin) insn together with a |
1353 | sign-extended add via the table to PC seems optimal. | |
1354 | If the table overflows, the assembler will take care of it. | |
1355 | Theoretically, in extreme cases (uncertain if they occur), an error | |
1356 | will be emitted, so FIXME: Check how large case-tables are emitted, | |
1357 | possible add an option to emit SImode case-tables. */ | |
1358 | #define CASE_VECTOR_MODE HImode | |
1359 | ||
1360 | #define CASE_VECTOR_PC_RELATIVE 1 | |
1361 | ||
1362 | /* FIXME: Investigate CASE_VECTOR_SHORTEN_MODE to make sure HImode is not | |
109b748d | 1363 | used when broken-.word could possibly fail (plus testcase). */ |
0b85d816 | 1364 | |
0b85d816 HPN |
1365 | #define FIXUNS_TRUNC_LIKE_FIX_TRUNC |
1366 | ||
0b85d816 HPN |
1367 | /* This is the number of bytes that can be moved in one |
1368 | reasonably fast instruction sequence. For CRIS, this is two | |
1369 | instructions: mem => reg, reg => mem. */ | |
1370 | #define MOVE_MAX 4 | |
1371 | ||
1372 | /* Maybe SHIFT_COUNT_TRUNCATED is safe to define? FIXME: Check later. */ | |
1373 | ||
1374 | #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1 | |
1375 | ||
e636e508 | 1376 | #define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = 32, 1) |
9ef4a0cd | 1377 | #define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = 32, 1) |
e636e508 | 1378 | |
0b85d816 HPN |
1379 | #define Pmode SImode |
1380 | ||
1381 | #define FUNCTION_MODE QImode | |
1382 | ||
1383 | #define NO_IMPLICIT_EXTERN_C | |
1384 | ||
c3271cd2 HPN |
1385 | /* No specific purpose other than warningless compatibility. */ |
1386 | #define HANDLE_PRAGMA_PACK_PUSH_POP 1 | |
1387 | ||
0b85d816 HPN |
1388 | /* |
1389 | * Local variables: | |
1390 | * eval: (c-set-style "gnu") | |
1391 | * indent-tabs-mode: t | |
1392 | * End: | |
1393 | */ |