Mercurial > hg > CbC > CbC_gcc
annotate gcc/config/cris/cris.h @ 143:76e1cf5455ef
add cbc_gc test
author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
---|---|
date | Sun, 23 Dec 2018 19:24:05 +0900 |
parents | 84e7813d76e9 |
children | 1830386684a0 |
rev | line source |
---|---|
0 | 1 /* Definitions for GCC. Part of the machine description for CRIS. |
131 | 2 Copyright (C) 1998-2018 Free Software Foundation, Inc. |
0 | 3 Contributed by Axis Communications. Written by Hans-Peter Nilsson. |
4 | |
5 This file is part of GCC. | |
6 | |
7 GCC is free software; you can redistribute it and/or modify | |
8 it under the terms of the GNU General Public License as published by | |
9 the Free Software Foundation; either version 3, or (at your option) | |
10 any later version. | |
11 | |
12 GCC is distributed in the hope that it will be useful, | |
13 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 GNU General Public License for more details. | |
16 | |
17 You should have received a copy of the GNU General Public License | |
18 along with GCC; see the file COPYING3. If not see | |
19 <http://www.gnu.org/licenses/>. */ | |
20 | |
21 /* After the first "Node:" comment comes all preprocessor directives and | |
22 attached declarations described in the info files, the "Using and | |
23 Porting GCC" manual (uapgcc), in the same order as found in the "Target | |
24 macros" section in the gcc-2.9x CVS edition of 2000-03-17. FIXME: Not | |
25 really, but needs an update anyway. | |
26 | |
27 There is no generic copy-of-uapgcc comment, you'll have to see uapgcc | |
28 for that. If applicable, there is a CRIS-specific comment. The order | |
29 of macro definitions follow the order in the manual. Every section in | |
30 the manual (node in the info pages) has an introductory `Node: | |
31 <subchapter>' comment. If no macros are defined for a section, only | |
32 the section-comment is present. */ | |
33 | |
34 /* Note that other header files (e.g. config/elfos.h, config/linux.h, | |
111 | 35 and config/cris/linux.h) are responsible for lots of settings not |
36 repeated below. This file contains general CRIS definitions | |
37 and definitions for the cris-*-elf subtarget. */ | |
0 | 38 |
39 /* We don't want to use gcc_assert for everything, as that can be | |
40 compiled out. */ | |
41 #define CRIS_ASSERT(x) \ | |
42 do { if (!(x)) internal_error ("CRIS-port assertion failed: " #x); } while (0) | |
43 | |
44 /* Replacement for REG_P since it does not match SUBREGs. Happens for | |
45 testcase Axis-20000320 with gcc-2.9x. */ | |
46 #define REG_S_P(x) \ | |
47 (REG_P (x) || (GET_CODE (x) == SUBREG && REG_P (XEXP (x, 0)))) | |
48 | |
49 /* Last register in main register bank r0..r15. */ | |
50 #define CRIS_LAST_GENERAL_REGISTER 15 | |
51 | |
52 /* Descriptions of registers used for arguments. */ | |
53 #define CRIS_FIRST_ARG_REG 10 | |
54 #define CRIS_MAX_ARGS_IN_REGS 4 | |
55 | |
56 /* See also *_REGNUM constants in cris.md. */ | |
57 | |
58 /* Most of the time, we need the index into the register-names array. | |
59 When passing debug-info, we need the real hardware register number. */ | |
60 #define CRIS_CANONICAL_SRP_REGNUM (16 + 11) | |
61 #define CRIS_CANONICAL_MOF_REGNUM (16 + 7) | |
62 /* We have CCR in all models including v10, but that's 16 bits, so let's | |
63 prefer the DCCR number, which is a DMA pointer in pre-v8, so we'll | |
64 never clash with it for GCC purposes. */ | |
65 #define CRIS_CANONICAL_CC0_REGNUM (16 + 13) | |
66 | |
67 /* When generating PIC, these suffixes are added to the names of non-local | |
68 functions when being output. Contrary to other ports, we have offsets | |
69 relative to the GOT, not the PC. We might implement PC-relative PLT | |
70 semantics later for the general case; they are used in some cases right | |
71 now, such as MI thunks. */ | |
72 #define CRIS_GOTPLT_SUFFIX ":GOTPLT" | |
73 #define CRIS_PLT_GOTOFFSET_SUFFIX ":PLTG" | |
74 #define CRIS_PLT_PCOFFSET_SUFFIX ":PLT" | |
75 | |
76 #define CRIS_FUNCTION_ARG_SIZE(MODE, TYPE) \ | |
77 ((MODE) != BLKmode ? GET_MODE_SIZE (MODE) \ | |
78 : (unsigned) int_size_in_bytes (TYPE)) | |
79 | |
80 /* Which CPU version this is. The parsed and adjusted cris_cpu_str. */ | |
81 extern int cris_cpu_version; | |
82 | |
83 | |
84 /* Node: Driver */ | |
85 | |
111 | 86 /* Also provide canonical vN definitions when user specifies an alias. */ |
0 | 87 |
88 #define CPP_SPEC \ | |
89 "%{mtune=*:-D__tune_%* %{mtune=v*:-D__CRIS_arch_tune=%*}\ | |
90 %{mtune=etrax4:-D__tune_v3 -D__CRIS_arch_tune=3}\ | |
91 %{mtune=etrax100:-D__tune_v8 -D__CRIS_arch_tune=8}\ | |
92 %{mtune=svinto:-D__tune_v8 -D__CRIS_arch_tune=8}\ | |
93 %{mtune=etrax100lx:-D__tune_v10 -D__CRIS_arch_tune=10}\ | |
94 %{mtune=ng:-D__tune_v10 -D__CRIS_arch_tune=10}}\ | |
95 %{mcpu=*:-D__arch_%* %{mcpu=v*:-D__CRIS_arch_version=%*}\ | |
96 %{mcpu=etrax4:-D__arch_v3 -D__CRIS_arch_version=3}\ | |
97 %{mcpu=etrax100:-D__arch_v8 -D__CRIS_arch_version=8}\ | |
98 %{mcpu=svinto:-D__arch_v8 -D__CRIS_arch_version=8}\ | |
99 %{mcpu=etrax100lx:-D__arch_v10 -D__CRIS_arch_version=10}\ | |
100 %{mcpu=ng:-D__arch_v10 -D__CRIS_arch_version=10}}\ | |
101 %{march=*:-D__arch_%* %{march=v*:-D__CRIS_arch_version=%*}\ | |
102 %{march=etrax4:-D__arch_v3 -D__CRIS_arch_version=3}\ | |
103 %{march=etrax100:-D__arch_v8 -D__CRIS_arch_version=8}\ | |
104 %{march=svinto:-D__arch_v8 -D__CRIS_arch_version=8}\ | |
105 %{march=etrax100lx:-D__arch_v10 -D__CRIS_arch_version=10}\ | |
106 %{march=ng:-D__arch_v10 -D__CRIS_arch_version=10}}\ | |
107 %{metrax100:-D__arch__v8 -D__CRIS_arch_version=8}\ | |
108 %{metrax4:-D__arch__v3 -D__CRIS_arch_version=3}\ | |
109 %(cpp_subtarget)" | |
110 | |
111 /* For the cris-*-elf subtarget. */ | |
112 | |
113 #define CRIS_DEFAULT_TUNE "10" | |
114 #define CRIS_ARCH_CPP_DEFAULT | |
115 #define CRIS_DEFAULT_ASM_ARCH_OPTION "" | |
116 | |
117 #ifdef TARGET_CPU_DEFAULT | |
118 #if TARGET_CPU_DEFAULT != 32 && TARGET_CPU_DEFAULT != 10 | |
119 #error "Due to '()'; e.g. '#define TARGET_CPU_DEFAULT (10)', stringize TARGET_CPU_DEFAULT isn't useful: update manually." | |
120 #endif | |
121 | |
122 #if TARGET_CPU_DEFAULT == 32 | |
123 #undef CRIS_DEFAULT_TUNE | |
124 #define CRIS_DEFAULT_TUNE "32" | |
125 /* To enable use of "generic" cris-axis-elf binutils, always pass the | |
126 architecture option to GAS. (We don't do this for non-v32.) */ | |
127 #undef CRIS_DEFAULT_ASM_ARCH_OPTION | |
128 #define CRIS_DEFAULT_ASM_ARCH_OPTION "--march=v32" | |
129 #endif | |
130 | |
131 #undef CRIS_ARCH_CPP_DEFAULT | |
132 #define CRIS_ARCH_CPP_DEFAULT \ | |
133 "%{!march=*:\ | |
134 %{!metrax*:\ | |
135 %{!mcpu=*:\ | |
136 %{!mtune=*:-D__tune_v" CRIS_DEFAULT_TUNE "}\ | |
111 | 137 -D__arch_v" CRIS_DEFAULT_TUNE \ |
0 | 138 " -D__CRIS_arch_version=" CRIS_DEFAULT_TUNE "}}}" |
139 #endif | |
140 | |
141 #define CRIS_CPP_SUBTARGET_SPEC \ | |
142 "%{mbest-lib-options:\ | |
143 %{!moverride-best-lib-options:\ | |
144 %{!march=*:%{!metrax*:%{!mcpu=*:\ | |
145 -D__tune_v" CRIS_DEFAULT_TUNE \ | |
146 " -D__CRIS_arch_tune=" CRIS_DEFAULT_TUNE "}}}}}"\ | |
147 CRIS_ARCH_CPP_DEFAULT | |
148 | |
111 | 149 /* Override previous definitions (../linux.h). */ |
0 | 150 #undef CC1_SPEC |
151 #define CC1_SPEC \ | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
152 "%{metrax4:-march=v3}\ |
0 | 153 %{metrax100:-march=v8}\ |
111 | 154 %{march=*:-march=%*}\ |
155 %{mcpu=*:-mcpu=%*}\ | |
0 | 156 %(cc1_subtarget)" |
157 | |
158 /* For the cris-*-elf subtarget. */ | |
159 #define CRIS_CC1_SUBTARGET_SPEC \ | |
160 "-melf\ | |
161 %{mbest-lib-options:\ | |
162 %{!moverride-best-lib-options:\ | |
163 %{!march=*:%{!mcpu=*:-mtune=v" CRIS_DEFAULT_TUNE\ | |
164 " -D__CRIS_arch_tune=" CRIS_DEFAULT_TUNE "}}\ | |
165 %{!finhibit-size-directive:\ | |
166 %{!fno-function-sections: -ffunction-sections}\ | |
167 %{!fno-data-sections: -fdata-sections}}}}" | |
168 | |
169 /* This adds to CC1_SPEC. */ | |
170 #define CC1PLUS_SPEC "" | |
171 | |
172 #ifdef HAVE_AS_NO_MUL_BUG_ABORT_OPTION | |
173 #define MAYBE_AS_NO_MUL_BUG_ABORT \ | |
174 "%{mno-mul-bug-workaround:-no-mul-bug-abort} " | |
175 #else | |
176 #define MAYBE_AS_NO_MUL_BUG_ABORT | |
177 #endif | |
178 | |
111 | 179 /* Override previous definitions (../linux.h). */ |
0 | 180 #undef ASM_SPEC |
181 #define ASM_SPEC \ | |
182 MAYBE_AS_NO_MUL_BUG_ABORT \ | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
183 "%(asm_subtarget)\ |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
184 %{march=*:%{mcpu=*:%edo not specify both -march=... and -mcpu=...}}\ |
111 | 185 %{march=v0|mcpu=v0|march=v3|mcpu=v3|march=v8|mcpu=v8:--march=v0_v10}\ |
186 %{march=v10|mcpu=v10:--march=v10}\ | |
187 %{march=v32|mcpu=v32:--march=v32}" | |
0 | 188 |
189 /* For the cris-*-elf subtarget. */ | |
190 #define CRIS_ASM_SUBTARGET_SPEC \ | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
191 "--em=criself %{!march=*:%{!mcpu=*:" CRIS_DEFAULT_ASM_ARCH_OPTION "}}" |
0 | 192 |
193 /* FIXME: We should propagate the -melf option to make the criself | |
194 "emulation" unless a linker script is provided (-T*), but I don't know | |
195 how to do that if either of -Ttext, -Tdata or -Tbss is given but no | |
196 linker script, as is usually the case. Leave it to the user for the | |
111 | 197 time being. */ |
0 | 198 #undef LINK_SPEC |
199 #define LINK_SPEC \ | |
200 "%{v:--verbose}\ | |
201 %(link_subtarget)" | |
202 | |
203 /* For the cris-*-elf subtarget. */ | |
204 #define CRIS_LINK_SUBTARGET_SPEC \ | |
205 "-mcriself\ | |
206 %{sim2:%{!T*:-Tdata 0x4000000 -Tbss 0x8000000}}\ | |
207 %{!r:%{O2|O3: --gc-sections}}" | |
208 | |
209 /* Which library to get. The simulator uses a different library for | |
210 the low-level syscalls (implementing the Linux syscall ABI instead | |
211 of direct-iron accesses). Default everything with the stub "nosys" | |
212 library. */ | |
213 /* Override previous definitions (linux.h). */ | |
214 #undef LIB_SPEC | |
215 #define LIB_SPEC \ | |
216 "%{sim*:--start-group -lc -lsyslinux --end-group}\ | |
217 %{!sim*:%{g*:-lg}\ | |
218 %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p} -lbsp}\ | |
219 -lnosys" | |
220 | |
221 /* Linker startfile options; crt0 flavors. | |
222 We need to remove any previous definition (elfos.h). */ | |
223 #undef STARTFILE_SPEC | |
224 #define STARTFILE_SPEC \ | |
225 "%{sim*:crt1.o%s}%{!sim*:crt0.o%s}\ | |
226 crti.o%s crtbegin.o%s" | |
227 | |
228 #undef ENDFILE_SPEC | |
229 #define ENDFILE_SPEC "crtend.o%s crtn.o%s" | |
230 | |
231 #define EXTRA_SPECS \ | |
232 {"cpp_subtarget", CRIS_CPP_SUBTARGET_SPEC}, \ | |
233 {"cc1_subtarget", CRIS_CC1_SUBTARGET_SPEC}, \ | |
234 {"asm_subtarget", CRIS_ASM_SUBTARGET_SPEC}, \ | |
235 {"link_subtarget", CRIS_LINK_SUBTARGET_SPEC}, \ | |
236 CRIS_SUBTARGET_EXTRA_SPECS | |
237 | |
238 #define CRIS_SUBTARGET_EXTRA_SPECS | |
239 | |
240 | |
241 /* Node: Run-time Target */ | |
242 | |
243 #define TARGET_CPU_CPP_BUILTINS() \ | |
244 do \ | |
245 { \ | |
246 builtin_define_std ("cris"); \ | |
247 builtin_define_std ("CRIS"); \ | |
248 builtin_define_std ("GNU_CRIS"); \ | |
249 builtin_define ("__CRIS_ABI_version=2"); \ | |
250 builtin_assert ("cpu=cris"); \ | |
251 builtin_assert ("machine=cris"); \ | |
252 } \ | |
253 while (0) | |
254 | |
255 /* Previously controlled by target_flags. Note that this is *not* set | |
256 for -melinux. */ | |
257 #define TARGET_LINUX 0 | |
258 | |
259 /* For the cris-*-elf subtarget. */ | |
260 #define CRIS_SUBTARGET_DEFAULT 0 | |
261 | |
262 #define CRIS_CPU_BASE 0 | |
263 #define CRIS_CPU_ETRAX4 3 /* Just lz added. */ | |
264 #define CRIS_CPU_SVINTO 8 /* Added swap, jsrc & Co., 32-bit accesses. */ | |
265 #define CRIS_CPU_NG 10 /* Added mul[su]. */ | |
266 #define CRIS_CPU_V32 32 /* Major changes. */ | |
267 | |
268 #ifndef TARGET_CPU_DEFAULT | |
269 #define TARGET_CPU_DEFAULT CRIS_CPU_BASE | |
270 #endif | |
271 | |
111 | 272 /* Default target_flags if no switches specified. |
273 The alignment-by-32 is to make builtin atomic support for v10 and v32 | |
274 work for *-elf for types without specified alignment (like plain | |
275 "int"). See top comment in sync.md. */ | |
0 | 276 #ifndef TARGET_DEFAULT |
277 # if TARGET_CPU_DEFAULT == 32 | |
278 # define TARGET_DEFAULT \ | |
279 (MASK_STACK_ALIGN \ | |
280 + MASK_CONST_ALIGN + MASK_DATA_ALIGN \ | |
111 | 281 + MASK_ALIGN_BY_32 \ |
0 | 282 + MASK_PROLOGUE_EPILOGUE) |
111 | 283 # elif TARGET_CPU_DEFAULT == 10 |
284 # define TARGET_DEFAULT \ | |
285 (MASK_SIDE_EFFECT_PREFIXES + MASK_STACK_ALIGN \ | |
286 + MASK_CONST_ALIGN + MASK_DATA_ALIGN \ | |
287 + MASK_ALIGN_BY_32 \ | |
288 + MASK_PROLOGUE_EPILOGUE + MASK_MUL_BUG) | |
289 # else /* 0 */ | |
290 # define TARGET_DEFAULT \ | |
0 | 291 (MASK_SIDE_EFFECT_PREFIXES + MASK_STACK_ALIGN \ |
292 + MASK_CONST_ALIGN + MASK_DATA_ALIGN \ | |
293 + MASK_PROLOGUE_EPILOGUE + MASK_MUL_BUG) | |
294 # endif | |
295 #endif | |
296 | |
297 /* Local, providing a default for cris_cpu_version. */ | |
298 #define CRIS_DEFAULT_CPU_VERSION TARGET_CPU_DEFAULT | |
299 | |
300 #define TARGET_HAS_MUL_INSNS (cris_cpu_version >= CRIS_CPU_NG) | |
301 #define TARGET_HAS_LZ (cris_cpu_version >= CRIS_CPU_ETRAX4) | |
111 | 302 #define TARGET_HAS_BREAK (cris_cpu_version >= CRIS_CPU_ETRAX4) |
0 | 303 #define TARGET_HAS_SWAP (cris_cpu_version >= CRIS_CPU_SVINTO) |
304 #define TARGET_V32 (cris_cpu_version >= CRIS_CPU_V32) | |
305 | |
111 | 306 /* The "break" instruction was introduced with ETRAX 4. */ |
307 #define TARGET_TRAP_USING_BREAK8 \ | |
308 (cris_trap_using_break8 == 2 ? TARGET_HAS_BREAK : cris_trap_using_break8) | |
309 | |
310 /* Call library functions by default for GNU/Linux. */ | |
311 #define TARGET_ATOMICS_MAY_CALL_LIBFUNCS \ | |
312 (cris_atomics_calling_libfunc == 2 \ | |
313 ? TARGET_LINUX : cris_atomics_calling_libfunc) | |
314 | |
315 /* The < v10 atomics turn off interrupts, so they don't need alignment. | |
316 Incidentally, by default alignment is off there causing variables to | |
317 be default unaligned all over, so we'd have to make support | |
318 libraries use a proper atomic type (instead of "int"), one we'd | |
319 specify as aligned. */ | |
320 #define TARGET_TRAP_UNALIGNED_ATOMIC \ | |
321 (cris_trap_unaligned_atomic == 2 \ | |
322 ? (TARGET_V32 || cris_cpu_version == 10) \ | |
323 : cris_trap_unaligned_atomic) | |
0 | 324 |
325 /* Node: Storage Layout */ | |
326 | |
327 #define BITS_BIG_ENDIAN 0 | |
328 | |
329 #define BYTES_BIG_ENDIAN 0 | |
330 | |
331 /* WORDS_BIG_ENDIAN is not defined in the hardware, but for consistency, | |
332 we use little-endianness, and we may also be able to use | |
333 post-increment on DImode indirect. */ | |
334 #define WORDS_BIG_ENDIAN 0 | |
335 | |
336 #define UNITS_PER_WORD 4 | |
337 | |
338 #define CRIS_PROMOTED_MODE(MODE, UNSIGNEDP, TYPE) \ | |
339 (GET_MODE_CLASS (MODE) == MODE_INT && GET_MODE_SIZE (MODE) < 4) \ | |
340 ? SImode : MODE | |
341 | |
342 /* We will be using prototype promotion, so they will be 32 bit. */ | |
343 #define PARM_BOUNDARY 32 | |
344 | |
345 /* Stack boundary is guided by -mstack-align, -mno-stack-align, | |
346 -malign. | |
347 Old comment: (2.1: still valid in 2.7.2?) | |
348 Note that to make this macro affect the alignment of stack | |
349 locals, a fix was required, and special precautions when handling | |
350 the stack pointer in various other macros (TARGET_ASM_FUNCTION_PROLOGUE | |
351 et al) were required. See file "function.c". If you would just define | |
352 this macro, it would only affect the builtin alloca and variable | |
353 local data (non-ANSI, non-K&R, Gnu C extension). */ | |
354 #define STACK_BOUNDARY \ | |
355 (TARGET_STACK_ALIGN ? (TARGET_ALIGN_BY_32 ? 32 : 16) : 8) | |
356 | |
357 #define FUNCTION_BOUNDARY 16 | |
358 | |
359 /* Do not change BIGGEST_ALIGNMENT (when optimizing), as it will affect | |
360 strange places, at least in 2.1. */ | |
361 #define BIGGEST_ALIGNMENT 8 | |
362 | |
363 /* If -m16bit, -m16-bit, -malign or -mdata-align, | |
364 align everything to 16 bit. */ | |
365 #define DATA_ALIGNMENT(TYPE, BASIC_ALIGN) \ | |
366 (TARGET_DATA_ALIGN \ | |
367 ? (TARGET_ALIGN_BY_32 \ | |
368 ? (BASIC_ALIGN < 32 ? 32 : BASIC_ALIGN) \ | |
369 : (BASIC_ALIGN < 16 ? 16 : BASIC_ALIGN)) : BASIC_ALIGN) | |
370 | |
371 /* FIXME: Define LOCAL_ALIGNMENT for word and dword or arrays and | |
372 structures (if -mstack-align=), and check that it is good. */ | |
373 | |
374 #define EMPTY_FIELD_BOUNDARY 8 | |
375 | |
376 #define STRUCTURE_SIZE_BOUNDARY 8 | |
377 | |
378 #define STRICT_ALIGNMENT 0 | |
379 | |
380 /* Remove any previous definition (elfos.h). | |
381 ??? If it wasn't for all the other stuff that affects layout of | |
382 structures and bit-fields, this could presumably cause incompatibility | |
383 with other GNU/Linux ports (i.e. elfos.h users). */ | |
384 #undef PCC_BITFIELD_TYPE_MATTERS | |
385 | |
386 /* This is only used for non-scalars. Strange stuff happens to structs | |
387 (FIXME: What?) if we use anything larger than largest actually used | |
388 datum size, so lets make it 32. The type "long long" will still work | |
389 as usual. We can still have DImode insns, but they will only be used | |
390 for scalar data (i.e. long long). */ | |
391 #define MAX_FIXED_MODE_SIZE 32 | |
392 | |
393 | |
394 /* Node: Type Layout */ | |
395 | |
396 /* Note that DOUBLE_TYPE_SIZE is not defined anymore, since the default | |
397 value gives a 64-bit double, which is what we now use. */ | |
398 | |
399 /* For compatibility and historical reasons, a char should be signed. */ | |
400 #define DEFAULT_SIGNED_CHAR 1 | |
401 | |
402 /* Note that WCHAR_TYPE_SIZE is used in cexp.y, | |
403 where TARGET_SHORT is not available. */ | |
404 #undef WCHAR_TYPE | |
405 #define WCHAR_TYPE "long int" | |
406 | |
407 #undef WCHAR_TYPE_SIZE | |
408 #define WCHAR_TYPE_SIZE 32 | |
409 | |
410 | |
411 /* Node: Register Basics */ | |
412 | |
413 /* We count all 16 non-special registers, SRP, a faked argument | |
414 pointer register, MOF and CCR/DCCR. */ | |
415 #define FIRST_PSEUDO_REGISTER (16 + 1 + 1 + 1 + 1) | |
416 | |
417 /* For CRIS, these are r15 (pc) and r14 (sp). Register r8 is used as a | |
418 frame-pointer, but is not fixed. SRP is not included in general | |
419 registers and will not be used automatically. All other special | |
420 registers are fixed at the moment. The faked argument pointer register | |
421 is fixed too. */ | |
422 #define FIXED_REGISTERS \ | |
111 | 423 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1} |
0 | 424 |
425 /* Register r9 is used for structure-address, r10-r13 for parameters, | |
426 r10- for return values. */ | |
427 #define CALL_USED_REGISTERS \ | |
428 {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1} | |
429 | |
430 /* Node: Allocation Order */ | |
431 | |
432 /* We need this on CRIS, because call-used regs should be used first, | |
433 (so we don't need to push). Else start using registers from r0 and up. | |
434 This preference is mainly because if we put call-used-regs from r0 | |
435 and up, then we can't use movem to push the rest, (which have to be | |
436 saved if we use them, and movem has to start with r0). | |
437 Change here if you change which registers to use as call registers. | |
438 | |
439 The actual need to explicitly prefer call-used registers improved the | |
440 situation a lot for 2.1, but might not actually be needed anymore. | |
441 Still, this order reflects what GCC should find out by itself, so it | |
442 probably does not hurt. | |
443 | |
444 Order of preference: Call-used-regs first, then r0 and up, last fp & | |
445 sp & pc as fillers. | |
446 Call-used regs in opposite order, so they will cause less conflict if | |
447 a function has few args (<= 3) and it wants a scratch reg. | |
448 Use struct-return address first, since very few functions use | |
449 structure return values so it is likely to be available. */ | |
450 #define REG_ALLOC_ORDER \ | |
451 {9, 13, 12, 11, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 14, 15, 17, 16, 18, 19} | |
452 | |
453 /* Use MOF and ACR. Prefer ACR before any other register. Prefer MOF | |
454 then SRP after saved registers. The *after* is because they're only | |
455 useful for storage, not for things being computed, which is | |
456 apparently more common. */ | |
457 #define REG_ALLOC_ORDER_V32 \ | |
458 {15, 9, 13, 12, 11, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 17, 16, 14, 18, 19} | |
459 | |
460 | |
461 /* Node: Leaf Functions */ | |
462 /* (no definitions) */ | |
463 | |
464 /* Node: Stack Registers */ | |
465 /* (no definitions) */ | |
466 | |
467 | |
468 /* Node: Register Classes */ | |
469 | |
111 | 470 /* We need a separate register class to handle register allocation for |
0 | 471 ACR, since it can't be used for post-increment. |
472 | |
473 It's not obvious, but having subunions of all movable-between | |
111 | 474 register classes does really help register allocation (pre-IRA |
475 comment). */ | |
0 | 476 enum reg_class |
477 { | |
478 NO_REGS, | |
111 | 479 ACR_REGS, MOF_REGS, SRP_REGS, CC0_REGS, |
480 MOF_SRP_REGS, SPECIAL_REGS, | |
0 | 481 SPEC_ACR_REGS, GENNONACR_REGS, |
482 SPEC_GENNONACR_REGS, GENERAL_REGS, | |
483 ALL_REGS, | |
484 LIM_REG_CLASSES | |
485 }; | |
486 | |
487 #define N_REG_CLASSES (int) LIM_REG_CLASSES | |
488 | |
489 #define REG_CLASS_NAMES \ | |
490 {"NO_REGS", \ | |
111 | 491 "ACR_REGS", "MOF_REGS", "SRP_REGS", "CC0_REGS", \ |
492 "MOF_SRP_REGS", "SPECIAL_REGS", \ | |
0 | 493 "SPEC_ACR_REGS", "GENNONACR_REGS", "SPEC_GENNONACR_REGS", \ |
494 "GENERAL_REGS", "ALL_REGS"} | |
495 | |
496 #define CRIS_SPECIAL_REGS_CONTENTS \ | |
497 ((1 << CRIS_SRP_REGNUM) | (1 << CRIS_MOF_REGNUM) | (1 << CRIS_CC0_REGNUM)) | |
498 | |
499 /* Count in the faked argument register in GENERAL_REGS. Keep out SRP. */ | |
500 #define REG_CLASS_CONTENTS \ | |
501 { \ | |
502 {0}, \ | |
503 {1 << CRIS_ACR_REGNUM}, \ | |
504 {1 << CRIS_MOF_REGNUM}, \ | |
111 | 505 {1 << CRIS_SRP_REGNUM}, \ |
0 | 506 {1 << CRIS_CC0_REGNUM}, \ |
111 | 507 {(1 << CRIS_MOF_REGNUM) \ |
508 | (1 << CRIS_SRP_REGNUM)}, \ | |
0 | 509 {CRIS_SPECIAL_REGS_CONTENTS}, \ |
510 {CRIS_SPECIAL_REGS_CONTENTS \ | |
511 | (1 << CRIS_ACR_REGNUM)}, \ | |
512 {(0xffff | (1 << CRIS_AP_REGNUM)) \ | |
513 & ~(1 << CRIS_ACR_REGNUM)}, \ | |
514 {(0xffff | (1 << CRIS_AP_REGNUM) \ | |
515 | CRIS_SPECIAL_REGS_CONTENTS) \ | |
516 & ~(1 << CRIS_ACR_REGNUM)}, \ | |
517 {0xffff | (1 << CRIS_AP_REGNUM)}, \ | |
518 {0xffff | (1 << CRIS_AP_REGNUM) \ | |
519 | CRIS_SPECIAL_REGS_CONTENTS} \ | |
520 } | |
521 | |
522 #define REGNO_REG_CLASS(REGNO) \ | |
523 ((REGNO) == CRIS_ACR_REGNUM ? ACR_REGS : \ | |
524 (REGNO) == CRIS_MOF_REGNUM ? MOF_REGS : \ | |
111 | 525 (REGNO) == CRIS_SRP_REGNUM ? SRP_REGS : \ |
0 | 526 (REGNO) == CRIS_CC0_REGNUM ? CC0_REGS : \ |
527 GENERAL_REGS) | |
528 | |
529 #define BASE_REG_CLASS GENERAL_REGS | |
530 | |
111 | 531 #define MODE_CODE_BASE_REG_CLASS(MODE, AS, OCODE, ICODE) \ |
0 | 532 ((OCODE) != POST_INC ? BASE_REG_CLASS : GENNONACR_REGS) |
533 | |
534 #define INDEX_REG_CLASS GENERAL_REGS | |
535 | |
536 /* Since it uses reg_renumber, it is safe only once reg_renumber | |
111 | 537 has been allocated, which happens in reginfo.c during register |
538 allocation. */ | |
0 | 539 #define REGNO_OK_FOR_BASE_P(REGNO) \ |
540 ((REGNO) <= CRIS_LAST_GENERAL_REGISTER \ | |
541 || (REGNO) == ARG_POINTER_REGNUM \ | |
542 || (unsigned) reg_renumber[REGNO] <= CRIS_LAST_GENERAL_REGISTER \ | |
543 || (unsigned) reg_renumber[REGNO] == ARG_POINTER_REGNUM) | |
544 | |
545 /* REGNO_OK_FOR_BASE_P seems to be obsolete wrt. this one, but not yet | |
546 documented as such. */ | |
111 | 547 #define REGNO_MODE_CODE_OK_FOR_BASE_P(REGNO, MODE, AS, OCODE, ICODE) \ |
0 | 548 (REGNO_OK_FOR_BASE_P (REGNO) \ |
549 && ((OCODE) != POST_INC \ | |
550 || !((REGNO) == CRIS_ACR_REGNUM \ | |
551 || (unsigned) reg_renumber[REGNO] == CRIS_ACR_REGNUM))) | |
552 | |
553 /* See REGNO_OK_FOR_BASE_P. */ | |
554 #define REGNO_OK_FOR_INDEX_P(REGNO) REGNO_OK_FOR_BASE_P(REGNO) | |
555 | |
556 /* We can't move special registers to and from memory in smaller than | |
36 | 557 word_mode. We also can't move between special registers. Luckily, |
558 -1, as returned by true_regnum for non-sub/registers, is valid as a | |
559 parameter to our REGNO_REG_CLASS, returning GENERAL_REGS, so we get | |
560 the effect that any X that isn't a special-register is treated as | |
561 a non-empty intersection with GENERAL_REGS. */ | |
562 #define SECONDARY_RELOAD_CLASS(CLASS, MODE, X) \ | |
111 | 563 ((reg_class_subset_p (CLASS, SPECIAL_REGS) \ |
36 | 564 && ((GET_MODE_SIZE (MODE) < 4 && MEM_P (X)) \ |
565 || !reg_classes_intersect_p (REGNO_REG_CLASS (true_regnum (X)), \ | |
566 GENERAL_REGS))) \ | |
567 ? GENERAL_REGS : NO_REGS) | |
0 | 568 |
569 /* FIXME: Fix regrename.c; it should check validity of replacements, | |
570 not just with a silly pass-specific macro. We may miss some | |
571 opportunities, but we must stop regrename from creating acr++. */ | |
572 #define HARD_REGNO_RENAME_OK(FROM, TO) ((TO) != CRIS_ACR_REGNUM) | |
573 | |
574 /* For CRIS, this is always the size of MODE in words, | |
575 since all registers are the same size. To use omitted modes in | |
576 patterns with reload constraints, you must say the widest size | |
577 which is allowed for VOIDmode. | |
578 FIXME: Does that still apply for gcc-2.9x? Keep poisoned until such | |
579 patterns are added back. News: 2001-03-16: Happens as early as the | |
580 underscore-test. */ | |
581 #define CLASS_MAX_NREGS(CLASS, MODE) \ | |
582 ((MODE) == VOIDmode \ | |
583 ? 1 /* + cris_fatal ("CLASS_MAX_NREGS with VOIDmode") */ \ | |
584 : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)) | |
585 | |
586 | |
587 /* Node: Frame Layout */ | |
588 | |
111 | 589 #define STACK_GROWS_DOWNWARD 1 |
0 | 590 #define FRAME_GROWS_DOWNWARD 1 |
591 | |
592 #define FIRST_PARM_OFFSET(FNDECL) 0 | |
593 | |
594 #define RETURN_ADDR_RTX(COUNT, FRAMEADDR) \ | |
595 cris_return_addr_rtx (COUNT, FRAMEADDR) | |
596 | |
597 #define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (Pmode, CRIS_SRP_REGNUM) | |
598 | |
599 /* FIXME: Any __builtin_eh_return callers must not return anything and | |
600 there must not be collisions with incoming parameters. Luckily the | |
601 number of __builtin_eh_return callers is limited. For now return | |
602 parameter registers in reverse order and hope for the best. */ | |
603 #define EH_RETURN_DATA_REGNO(N) \ | |
604 (IN_RANGE ((N), 0, 3) ? (CRIS_FIRST_ARG_REG + 3 - (N)) : INVALID_REGNUM) | |
605 | |
606 /* Store the stack adjustment in the structure-return-address register. */ | |
607 #define CRIS_STACKADJ_REG CRIS_STRUCT_VALUE_REGNUM | |
608 #define EH_RETURN_STACKADJ_RTX gen_rtx_REG (SImode, CRIS_STACKADJ_REG) | |
609 | |
610 #define EH_RETURN_HANDLER_RTX \ | |
611 cris_return_addr_rtx (0, NULL) | |
612 | |
613 #define INIT_EXPANDERS cris_init_expanders () | |
614 | |
615 /* FIXME: Move this to right node (it's not documented properly yet). */ | |
616 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (CRIS_SRP_REGNUM) | |
617 | |
618 /* FIXME: Move this to right node (it's not documented properly yet). | |
619 FIXME: Check what alignment we can assume regarding | |
620 TARGET_STACK_ALIGN and TARGET_ALIGN_BY_32. */ | |
621 #define DWARF_CIE_DATA_ALIGNMENT -1 | |
622 | |
623 /* If we would ever need an exact mapping between canonical register | |
624 number and dwarf frame register, we would either need to include all | |
625 registers in the gcc description (with some marked fixed of course), or | |
626 an inverse mapping from dwarf register to gcc register. There is one | |
627 need in dwarf2out.c:expand_builtin_init_dwarf_reg_sizes. Right now, I | |
628 don't see that we need exact correspondence between DWARF *frame* | |
629 registers and DBX_REGISTER_NUMBER, so map them onto GCC registers. */ | |
630 #define DWARF_FRAME_REGNUM(REG) (REG) | |
631 | |
632 /* Node: Stack Checking */ | |
633 /* (no definitions) FIXME: Check. */ | |
634 | |
635 /* Node: Frame Registers */ | |
636 | |
637 #define STACK_POINTER_REGNUM CRIS_SP_REGNUM | |
638 | |
639 /* Register used for frame pointer. This is also the last of the saved | |
640 registers, when a frame pointer is not used. */ | |
641 #define FRAME_POINTER_REGNUM CRIS_FP_REGNUM | |
642 | |
643 /* Faked register, is always eliminated. We need it to eliminate | |
644 allocating stack slots for the return address and the frame pointer. */ | |
645 #define ARG_POINTER_REGNUM CRIS_AP_REGNUM | |
646 | |
647 #define STATIC_CHAIN_REGNUM CRIS_STATIC_CHAIN_REGNUM | |
648 | |
649 | |
650 /* Node: Elimination */ | |
651 | |
652 #define ELIMINABLE_REGS \ | |
653 {{ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \ | |
654 {ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM}, \ | |
655 {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}} | |
656 | |
657 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \ | |
658 (OFFSET) = cris_initial_elimination_offset (FROM, TO) | |
659 | |
660 | |
661 /* Node: Stack Arguments */ | |
662 | |
663 /* Since many parameters take up one register each in any case, | |
664 defining TARGET_PROMOTE_PROTOTYPES that always returns true would | |
665 seem like a good idea, but measurements indicate that a combination | |
666 using PROMOTE_MODE is better. */ | |
667 | |
668 #define ACCUMULATE_OUTGOING_ARGS 1 | |
669 | |
670 | |
671 /* Node: Register Arguments */ | |
672 | |
673 /* Contrary to what you'd believe, defining FUNCTION_ARG_CALLEE_COPIES | |
674 seems like a (small total) loss, at least for gcc-2.7.2 compiling and | |
675 running gcc-2.1 (small win in size, small loss running -- 100.1%), | |
676 and similarly for size for products (.1 .. .3% bloat, sometimes win). | |
677 Due to the empirical likeliness of making slower code, it is not | |
678 defined. */ | |
679 | |
680 /* This no longer *needs* to be a structure; but keeping it as such should | |
681 not hurt (and hacking the ABI is simpler). */ | |
682 #define CUMULATIVE_ARGS struct cum_args | |
683 struct cum_args {int regs;}; | |
684 | |
685 /* The regs member is an integer, the number of arguments got into | |
686 registers so far. */ | |
687 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, FNDECL, N_NAMED_ARGS) \ | |
688 ((CUM).regs = 0) | |
689 | |
690 #define FUNCTION_ARG_REGNO_P(REGNO) \ | |
691 ((REGNO) >= CRIS_FIRST_ARG_REG \ | |
692 && (REGNO) < CRIS_FIRST_ARG_REG + (CRIS_MAX_ARGS_IN_REGS)) | |
693 | |
694 | |
695 /* Node: Aggregate Return */ | |
696 | |
697 #define CRIS_STRUCT_VALUE_REGNUM ((CRIS_FIRST_ARG_REG) - 1) | |
698 | |
699 | |
700 /* Node: Caller Saves */ | |
701 /* (no definitions) */ | |
702 | |
703 /* Node: Function entry */ | |
704 | |
705 /* See cris.c for TARGET_ASM_FUNCTION_PROLOGUE and | |
706 TARGET_ASM_FUNCTION_EPILOGUE. */ | |
707 | |
708 /* Node: Profiling */ | |
709 | |
710 #define FUNCTION_PROFILER(FILE, LABELNO) \ | |
711 error ("no FUNCTION_PROFILER for CRIS") | |
712 | |
713 /* FIXME: Some of the undefined macros might be mandatory. If so, fix | |
714 documentation. */ | |
715 | |
716 | |
717 /* Node: Trampolines */ | |
718 | |
719 #define TRAMPOLINE_SIZE (TARGET_V32 ? 58 : 32) | |
720 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
721 /* CRIS wants instructions on word-boundary. */ |
0 | 722 #define TRAMPOLINE_ALIGNMENT 16 |
723 | |
724 /* Node: Library Calls */ | |
725 | |
726 /* If you change this, you have to check whatever libraries and systems | |
727 that use it. */ | |
728 #define TARGET_EDOM 33 | |
729 | |
730 | |
731 /* Node: Addressing Modes */ | |
732 | |
733 #define HAVE_POST_INCREMENT 1 | |
734 | |
111 | 735 #define CONSTANT_ADDRESS_P(X) \ |
736 (CONSTANT_P (X) && cris_legitimate_address_p (QImode, X, false)) | |
737 | |
0 | 738 /* Must be a compile-time constant, so we go with the highest value |
739 among all CRIS variants. */ | |
740 #define MAX_REGS_PER_ADDRESS 2 | |
741 | |
742 /* Fix reloads known to cause suboptimal spilling. */ | |
743 #define LEGITIMIZE_RELOAD_ADDRESS(X, MODE, OPNUM, TYPE, INDL, WIN) \ | |
744 do \ | |
745 { \ | |
746 if (cris_reload_address_legitimized (X, MODE, OPNUM, TYPE, INDL)) \ | |
747 goto WIN; \ | |
748 } \ | |
749 while (0) | |
750 | |
111 | 751 /* The mode argument to cris_legitimate_constant_p isn't used, so just |
752 pass a cheap dummy. N.B. we have to cast away const from the | |
753 parameter rather than adjust the parameter, as it's type is mandated | |
754 by the TARGET_LEGITIMATE_CONSTANT_P target hook interface. */ | |
755 #define CRIS_CONSTANT_P(X) \ | |
756 (CONSTANT_P (X) && cris_legitimate_constant_p (VOIDmode, CONST_CAST_RTX (X))) | |
0 | 757 |
758 /* Node: Condition Code */ | |
759 | |
760 #define NOTICE_UPDATE_CC(EXP, INSN) cris_notice_update_cc (EXP, INSN) | |
761 | |
762 /* FIXME: Maybe define CANONICALIZE_COMPARISON later, when playing with | |
763 optimizations. It is needed; currently we do this with instruction | |
764 patterns and NOTICE_UPDATE_CC. */ | |
765 | |
766 | |
767 /* Node: Costs */ | |
768 | |
769 /* Regardless of the presence of delay slots, the default value of 1 for | |
770 BRANCH_COST is the best in the range (1, 2, 3), tested with gcc-2.7.2 | |
771 with testcases ipps and gcc, giving smallest and fastest code. */ | |
772 | |
773 #define SLOW_BYTE_ACCESS 0 | |
774 | |
775 /* This is the threshold *below* which inline move sequences of | |
776 word-length sizes will be emitted. The "9" will translate to | |
777 (9 - 1) * 4 = 32 bytes maximum moved, but using 16 instructions | |
778 (8 instruction sequences) or less. */ | |
779 #define MOVE_RATIO(speed) 9 | |
780 | |
781 | |
782 /* Node: Sections */ | |
783 | |
784 #define TEXT_SECTION_ASM_OP "\t.text" | |
785 | |
786 #define DATA_SECTION_ASM_OP "\t.data" | |
787 | |
788 /* The jump table is immediately connected to the preceding insn. */ | |
789 #define JUMP_TABLES_IN_TEXT_SECTION 1 | |
790 | |
791 | |
792 /* Node: PIC */ | |
793 | |
794 /* Helper type. */ | |
795 | |
111 | 796 enum cris_symbol_type |
0 | 797 { |
798 cris_no_symbol = 0, | |
799 cris_got_symbol = 1, | |
800 cris_rel_symbol = 2, | |
801 cris_got_symbol_needing_fixup = 3, | |
111 | 802 cris_unspec = 7, |
803 cris_offsettable_symbol = 8 | |
0 | 804 }; |
805 | |
806 #define PIC_OFFSET_TABLE_REGNUM (flag_pic ? CRIS_GOT_REGNUM : INVALID_REGNUM) | |
807 | |
808 #define LEGITIMATE_PIC_OPERAND_P(X) cris_legitimate_pic_operand (X) | |
809 | |
810 | |
811 /* Node: File Framework */ | |
812 | |
813 /* We don't want an .ident for gcc. To avoid that but still support | |
111 | 814 #ident, we override TARGET_ASM_OUTPUT_IDENT and, since the gcc .ident |
815 is its only use besides front-end .ident directives, we return if | |
816 the state if the cgraph is not PARSING. */ | |
817 #undef TARGET_ASM_OUTPUT_IDENT | |
818 #define TARGET_ASM_OUTPUT_IDENT cris_asm_output_ident | |
0 | 819 |
820 #define ASM_APP_ON "#APP\n" | |
821 | |
822 #define ASM_APP_OFF "#NO_APP\n" | |
823 | |
824 | |
825 /* Node: Data Output */ | |
826 | |
827 #define IS_ASM_LOGICAL_LINE_SEPARATOR(C, STR) (C) == '@' | |
828 | |
829 /* Node: Uninitialized Data */ | |
830 | |
831 /* Remember to round off odd values if we want data alignment, | |
832 since we cannot do that with an .align directive. | |
833 | |
834 Using .comm causes the space not to be reserved in .bss, but by | |
835 tricks with the symbol type. Not good if other tools than binutils | |
836 are used on the object files. Since ".global ... .lcomm ..." works, we | |
837 use that. Use .._ALIGNED_COMMON, since gcc whines when we only have | |
838 ..._COMMON, and we prefer to whine ourselves; BIGGEST_ALIGNMENT is not | |
111 | 839 the one to check. */ |
0 | 840 /* FIXME: I suspect a bug in gcc with alignment. Do not warn until |
841 investigated; it mucks up the testsuite results. */ | |
842 #define CRIS_ASM_OUTPUT_ALIGNED_DECL_COMMON(FILE, DECL, NAME, SIZE, ALIGN, LOCAL) \ | |
843 do \ | |
844 { \ | |
845 int align_ = (ALIGN) / BITS_PER_UNIT; \ | |
846 if (TARGET_DATA_ALIGN && TARGET_ALIGN_BY_32 && align_ < 4) \ | |
847 align_ = 4; \ | |
848 else if (TARGET_DATA_ALIGN && align_ < 2) \ | |
849 align_ = 2; \ | |
850 /* FIXME: Do we need this? */ \ | |
851 else if (align_ < 1) \ | |
852 align_ = 1; \ | |
853 \ | |
111 | 854 if (LOCAL) \ |
0 | 855 { \ |
111 | 856 fprintf ((FILE), "%s", LOCAL_ASM_OP); \ |
0 | 857 assemble_name ((FILE), (NAME)); \ |
111 | 858 fprintf ((FILE), "\n"); \ |
0 | 859 } \ |
111 | 860 fprintf ((FILE), "%s", COMMON_ASM_OP); \ |
861 assemble_name ((FILE), (NAME)); \ | |
862 fprintf ((FILE), ",%u,%u\n", (int)(SIZE), align_); \ | |
0 | 863 } \ |
864 while (0) | |
865 | |
866 #define ASM_OUTPUT_ALIGNED_DECL_COMMON(FILE, DECL, NAME, SIZE, ALIGN) \ | |
867 CRIS_ASM_OUTPUT_ALIGNED_DECL_COMMON(FILE, DECL, NAME, SIZE, ALIGN, 0) | |
868 | |
869 #undef ASM_OUTPUT_ALIGNED_DECL_LOCAL | |
870 #define ASM_OUTPUT_ALIGNED_DECL_LOCAL(FILE, DECL, NAME, SIZE, ALIGN) \ | |
871 CRIS_ASM_OUTPUT_ALIGNED_DECL_COMMON(FILE, DECL, NAME, SIZE, ALIGN, 1) | |
872 | |
873 /* Node: Label Output */ | |
874 | |
875 /* Globalizing directive for a label. */ | |
876 #define GLOBAL_ASM_OP "\t.global " | |
877 | |
878 #define SUPPORTS_WEAK 1 | |
879 | |
880 #define ASM_OUTPUT_SYMBOL_REF(STREAM, SYM) \ | |
881 cris_asm_output_symbol_ref (STREAM, SYM) | |
882 | |
883 #define ASM_OUTPUT_LABEL_REF(STREAM, BUF) \ | |
884 cris_asm_output_label_ref (STREAM, BUF) | |
885 | |
886 /* Remove any previous definition (elfos.h). */ | |
887 #undef ASM_GENERATE_INTERNAL_LABEL | |
888 #define ASM_GENERATE_INTERNAL_LABEL(LABEL, PREFIX, NUM) \ | |
889 sprintf (LABEL, "*%s%s%ld", LOCAL_LABEL_PREFIX, PREFIX, (long) NUM) | |
890 | |
891 /* Node: Initialization */ | |
892 /* (no definitions) */ | |
893 | |
894 /* Node: Macros for Initialization */ | |
895 /* (no definitions) */ | |
896 | |
897 /* Node: Instruction Output */ | |
898 | |
899 #define REGISTER_NAMES \ | |
900 {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", \ | |
901 "r9", "r10", "r11", "r12", "r13", "sp", "acr", "srp", "mof", "faked_ap", "dccr"} | |
902 | |
903 #define ADDITIONAL_REGISTER_NAMES \ | |
904 {{"r14", 14}, {"r15", 15}, {"pc", 15}} | |
905 | |
906 /* Output an empty line to illustrate the presence of the delay slot. */ | |
907 #define DBR_OUTPUT_SEQEND(FILE) \ | |
908 fprintf (FILE, "\n") | |
909 | |
111 | 910 #define LOCAL_LABEL_PREFIX "." |
0 | 911 |
912 /* cppinit.c initializes a const array from this, so it must be constant, | |
913 can't have it different based on options. Luckily, the prefix is | |
914 always allowed, so let's have it on all GCC-generated code. Note that | |
915 we have this verbatim everywhere in the back-end, not using %R or %s or | |
916 such. */ | |
917 #define REGISTER_PREFIX "$" | |
918 | |
919 /* Remove any previous definition (elfos.h). */ | |
920 /* We use -fno-leading-underscore to remove it, when necessary. */ | |
921 #undef USER_LABEL_PREFIX | |
922 #define USER_LABEL_PREFIX "_" | |
923 | |
924 #define ASM_OUTPUT_REG_PUSH(FILE, REGNO) \ | |
925 fprintf (FILE, \ | |
926 TARGET_V32 \ | |
927 ? "\tsubq 4,$sp\n\tmove $%s,[$sp]\n" : "\tpush $%s\n", \ | |
928 reg_names[REGNO]) | |
929 | |
930 #define ASM_OUTPUT_REG_POP(FILE, REGNO) \ | |
931 fprintf (FILE, "\tmove [$sp+],$%s\n", reg_names[REGNO]) | |
932 | |
933 | |
934 /* Node: Dispatch Tables */ | |
935 | |
936 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) \ | |
937 do \ | |
938 { \ | |
939 if (TARGET_V32) \ | |
940 asm_fprintf (FILE, "\t.word %LL%d-.\n", VALUE); \ | |
941 else \ | |
942 asm_fprintf (FILE, "\t.word %LL%d-%LL%d\n", VALUE, REL); \ | |
943 } \ | |
944 while (0) | |
945 | |
946 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \ | |
947 asm_fprintf (FILE, "\t.dword %LL%d\n", VALUE) | |
948 | |
949 /* Defined to also emit an .align in elfos.h. We don't want that. */ | |
950 #undef ASM_OUTPUT_CASE_LABEL | |
951 | |
952 /* Since the "bound" insn loads the comparison value if the compared< | |
953 value (register) is out of bounds (0..comparison value-1), we need | |
954 to output another case to catch it. | |
955 The way to find it is to look for the label_ref at the else-arm inside | |
956 the expanded casesi core-insn. | |
957 FIXME: Check this construct when changing to new version of gcc. */ | |
958 #define ASM_OUTPUT_CASE_END(STREAM, NUM, TABLE) \ | |
959 cris_asm_output_case_end (STREAM, NUM, TABLE) | |
960 | |
961 | |
962 /* Node: Exception Region Output */ | |
963 /* (no definitions) */ | |
964 /* FIXME: Fill in with our own optimized layout. */ | |
965 | |
966 /* Node: Alignment Output */ | |
967 | |
968 #define ASM_OUTPUT_ALIGN(FILE, LOG) \ | |
969 fprintf (FILE, "\t.align %d\n", (LOG)) | |
970 | |
971 | |
972 /* Node: All Debuggers */ | |
973 | |
974 #define DBX_REGISTER_NUMBER(REGNO) \ | |
975 ((REGNO) == CRIS_SRP_REGNUM ? CRIS_CANONICAL_SRP_REGNUM : \ | |
976 (REGNO) == CRIS_MOF_REGNUM ? CRIS_CANONICAL_MOF_REGNUM : \ | |
977 (REGNO) == CRIS_CC0_REGNUM ? CRIS_CANONICAL_CC0_REGNUM : \ | |
978 (REGNO)) | |
979 | |
980 /* FIXME: Investigate DEBUGGER_AUTO_OFFSET, DEBUGGER_ARG_OFFSET. */ | |
981 | |
982 | |
983 /* Node: DBX Options */ | |
984 | |
985 /* Is this correct? Check later. */ | |
986 #define DBX_NO_XREFS | |
987 | |
988 #define DBX_CONTIN_LENGTH 0 | |
989 | |
990 /* FIXME: Is this needed when we have 0 DBX_CONTIN_LENGTH? */ | |
991 #define DBX_CONTIN_CHAR '?' | |
992 | |
993 | |
994 /* Node: DBX Hooks */ | |
995 /* (no definitions) */ | |
996 | |
997 /* Node: File names and DBX */ | |
998 /* (no definitions) */ | |
999 | |
1000 | |
131 | 1001 /* Node: DWARF */ |
0 | 1002 /* (no definitions) */ |
1003 | |
1004 /* Node: Misc */ | |
1005 | |
1006 /* A combination of the bound (umin) insn together with a | |
1007 sign-extended add via the table to PC seems optimal. | |
1008 If the table overflows, the assembler will take care of it. | |
1009 Theoretically, in extreme cases (uncertain if they occur), an error | |
1010 will be emitted, so FIXME: Check how large case-tables are emitted, | |
1011 possible add an option to emit SImode case-tables. */ | |
1012 #define CASE_VECTOR_MODE HImode | |
1013 | |
1014 #define CASE_VECTOR_PC_RELATIVE 1 | |
1015 | |
1016 /* FIXME: Investigate CASE_VECTOR_SHORTEN_MODE to make sure HImode is not | |
1017 used when broken-.word could possibly fail (plus testcase). */ | |
1018 | |
1019 /* This is the number of bytes that can be moved in one | |
1020 reasonably fast instruction sequence. For CRIS, this is two | |
1021 instructions: mem => reg, reg => mem. */ | |
1022 #define MOVE_MAX 4 | |
1023 | |
1024 /* Maybe SHIFT_COUNT_TRUNCATED is safe to define? FIXME: Check later. */ | |
1025 | |
1026 #define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = 32, 1) | |
1027 #define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = 32, 1) | |
1028 | |
1029 #define Pmode SImode | |
1030 | |
1031 #define FUNCTION_MODE QImode | |
1032 | |
1033 /* | |
1034 * Local variables: | |
1035 * eval: (c-set-style "gnu") | |
1036 * indent-tabs-mode: t | |
1037 * End: | |
1038 */ |