0
|
1 /* Definitions for GCC. Part of the machine description for CRIS.
|
|
2 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
|
|
3 Free Software Foundation, Inc.
|
|
4 Contributed by Axis Communications. Written by Hans-Peter Nilsson.
|
|
5
|
|
6 This file is part of GCC.
|
|
7
|
|
8 GCC is free software; you can redistribute it and/or modify
|
|
9 it under the terms of the GNU General Public License as published by
|
|
10 the Free Software Foundation; either version 3, or (at your option)
|
|
11 any later version.
|
|
12
|
|
13 GCC is distributed in the hope that it will be useful,
|
|
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
16 GNU General Public License for more details.
|
|
17
|
|
18 You should have received a copy of the GNU General Public License
|
|
19 along with GCC; see the file COPYING3. If not see
|
|
20 <http://www.gnu.org/licenses/>. */
|
|
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
|
|
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
|
|
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
|
|
57 /* See also *_REGNUM constants in cris.md. */
|
|
58
|
|
59 /* Most of the time, we need the index into the register-names array.
|
|
60 When passing debug-info, we need the real hardware register number. */
|
|
61 #define CRIS_CANONICAL_SRP_REGNUM (16 + 11)
|
|
62 #define CRIS_CANONICAL_MOF_REGNUM (16 + 7)
|
|
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)
|
|
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
|
|
81 /* Which CPU version this is. The parsed and adjusted cris_cpu_str. */
|
|
82 extern int cris_cpu_version;
|
|
83
|
|
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
|
|
110 #define CPP_SPEC \
|
|
111 "%{mtune=*:-D__tune_%* %{mtune=v*:-D__CRIS_arch_tune=%*}\
|
|
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}\
|
|
116 %{mtune=ng:-D__tune_v10 -D__CRIS_arch_tune=10}}\
|
|
117 %{mcpu=*:-D__arch_%* %{mcpu=v*:-D__CRIS_arch_version=%*}\
|
|
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}\
|
|
122 %{mcpu=ng:-D__arch_v10 -D__CRIS_arch_version=10}}\
|
|
123 %{march=*:-D__arch_%* %{march=v*:-D__CRIS_arch_version=%*}\
|
|
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}\
|
|
128 %{march=ng:-D__arch_v10 -D__CRIS_arch_version=10}}\
|
|
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. */
|
|
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
|
|
163 #define CRIS_CPP_SUBTARGET_SPEC \
|
|
164 "%{mbest-lib-options:\
|
|
165 %{!moverride-best-lib-options:\
|
|
166 %{!march=*:%{!metrax*:%{!mcpu=*:\
|
|
167 -D__tune_v" CRIS_DEFAULT_TUNE \
|
|
168 " -D__CRIS_arch_tune=" CRIS_DEFAULT_TUNE "}}}}}"\
|
|
169 CRIS_ARCH_CPP_DEFAULT
|
|
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:\
|
|
185 %{!march=*:%{!mcpu=*:-mtune=v" CRIS_DEFAULT_TUNE\
|
|
186 " -D__CRIS_arch_tune=" CRIS_DEFAULT_TUNE "}}\
|
|
187 %{!finhibit-size-directive:\
|
|
188 %{!fno-function-sections: -ffunction-sections}\
|
|
189 %{!fno-data-sections: -fdata-sections}}}}"
|
|
190
|
|
191 /* This adds to CC1_SPEC. */
|
|
192 #define CC1PLUS_SPEC ""
|
|
193
|
|
194 #ifdef HAVE_AS_NO_MUL_BUG_ABORT_OPTION
|
|
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
|
|
201 /* Override previous definitions (linux.h). */
|
|
202 #undef ASM_SPEC
|
|
203 #define ASM_SPEC \
|
|
204 MAYBE_AS_NO_MUL_BUG_ABORT \
|
|
205 "%{v:-v}\
|
|
206 %(asm_subtarget)\
|
|
207 %{march=*:%{cpu=*:%eDo not specify both -march=... and -mcpu=...}}\
|
|
208 %{march=v32:--march=v32} %{mcpu=v32:--march=v32}"
|
|
209
|
|
210 /* For the cris-*-elf subtarget. */
|
|
211 #define CRIS_ASM_SUBTARGET_SPEC \
|
|
212 "--em=criself %{!march=*:%{!cpu=*:" CRIS_DEFAULT_ASM_ARCH_OPTION "}}"
|
|
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
|
|
224 %s-variant that checked for existence of some specific file. */
|
|
225 /* Override previous definitions (svr4.h). */
|
|
226 #undef LINK_SPEC
|
|
227 #define LINK_SPEC \
|
|
228 "%{v:--verbose}\
|
|
229 %(link_subtarget)"
|
|
230
|
|
231 /* For the cris-*-elf subtarget. */
|
|
232 #define CRIS_LINK_SUBTARGET_SPEC \
|
|
233 "-mcriself\
|
|
234 %{sim2:%{!T*:-Tdata 0x4000000 -Tbss 0x8000000}}\
|
|
235 %{!r:%{O2|O3: --gc-sections}}"
|
|
236
|
|
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. */
|
|
241 /* Override previous definitions (linux.h). */
|
|
242 #undef LIB_SPEC
|
|
243 #define LIB_SPEC \
|
|
244 "%{sim*:--start-group -lc -lsyslinux --end-group}\
|
|
245 %{!sim*:%{g*:-lg}\
|
|
246 %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p} -lbsp}\
|
|
247 -lnosys"
|
|
248
|
|
249 /* Linker startfile options; crt0 flavors.
|
|
250 We need to remove any previous definition (elfos.h). */
|
|
251 #undef STARTFILE_SPEC
|
|
252 #define STARTFILE_SPEC \
|
|
253 "%{sim*:crt1.o%s}%{!sim*:crt0.o%s}\
|
|
254 crti.o%s crtbegin.o%s"
|
|
255
|
|
256 #undef ENDFILE_SPEC
|
|
257 #define ENDFILE_SPEC "crtend.o%s crtn.o%s"
|
|
258
|
|
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
|
|
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"); \
|
|
278 builtin_assert ("cpu=cris"); \
|
|
279 builtin_assert ("machine=cris"); \
|
|
280 } \
|
|
281 while (0)
|
|
282
|
|
283 /* This needs to be at least 32 bits. */
|
|
284 extern int target_flags;
|
|
285
|
|
286 /* Previously controlled by target_flags. */
|
|
287 #define TARGET_ELF 1
|
|
288
|
|
289 /* Previously controlled by target_flags. Note that this is *not* set
|
|
290 for -melinux. */
|
|
291 #define TARGET_LINUX 0
|
|
292
|
|
293 /* For the cris-*-elf subtarget. */
|
|
294 #define CRIS_SUBTARGET_DEFAULT 0
|
|
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]. */
|
|
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
|
|
320
|
|
321 /* Local, providing a default for cris_cpu_version. */
|
|
322 #define CRIS_DEFAULT_CPU_VERSION TARGET_CPU_DEFAULT
|
|
323
|
|
324 #define TARGET_HAS_MUL_INSNS (cris_cpu_version >= CRIS_CPU_NG)
|
|
325 #define TARGET_HAS_LZ (cris_cpu_version >= CRIS_CPU_ETRAX4)
|
|
326 #define TARGET_HAS_SWAP (cris_cpu_version >= CRIS_CPU_SVINTO)
|
|
327 #define TARGET_V32 (cris_cpu_version >= CRIS_CPU_V32)
|
|
328
|
|
329 #define CRIS_SUBTARGET_HANDLE_OPTION(x, y, z)
|
|
330
|
|
331 #define OVERRIDE_OPTIONS cris_override_options ()
|
|
332
|
|
333 #define OPTIMIZATION_OPTIONS(OPTIMIZE, SIZE) \
|
|
334 do \
|
|
335 { \
|
|
336 if ((OPTIMIZE) >= 2 || (SIZE)) \
|
|
337 flag_omit_frame_pointer = 1; \
|
|
338 } \
|
|
339 while (0)
|
|
340
|
|
341
|
|
342 /* Node: Storage Layout */
|
|
343
|
|
344 #define BITS_BIG_ENDIAN 0
|
|
345
|
|
346 #define BYTES_BIG_ENDIAN 0
|
|
347
|
|
348 /* WORDS_BIG_ENDIAN is not defined in the hardware, but for consistency,
|
|
349 we use little-endianness, and we may also be able to use
|
|
350 post-increment on DImode indirect. */
|
|
351 #define WORDS_BIG_ENDIAN 0
|
|
352
|
|
353 #define UNITS_PER_WORD 4
|
|
354
|
|
355 /* A combination of defining PROMOTE_FUNCTION_MODE,
|
|
356 TARGET_PROMOTE_FUNCTION_ARGS that always returns true
|
|
357 and *not* defining TARGET_PROMOTE_PROTOTYPES or PROMOTE_MODE gives the
|
|
358 best code size and speed for gcc, ipps and products in gcc-2.7.2. */
|
|
359 #define CRIS_PROMOTED_MODE(MODE, UNSIGNEDP, TYPE) \
|
|
360 (GET_MODE_CLASS (MODE) == MODE_INT && GET_MODE_SIZE (MODE) < 4) \
|
|
361 ? SImode : MODE
|
|
362
|
|
363 #define PROMOTE_FUNCTION_MODE(MODE, UNSIGNEDP, TYPE) \
|
|
364 (MODE) = CRIS_PROMOTED_MODE (MODE, UNSIGNEDP, TYPE)
|
|
365
|
|
366 /* Defining PROMOTE_FUNCTION_RETURN in gcc-2.7.2 uncovers bug 981110 (even
|
|
367 if defining FUNCTION_VALUE with MODE as PROMOTED_MODE ;-)
|
|
368
|
|
369 FIXME: Report this when cris.h is part of GCC, so others can easily
|
|
370 see the problem. Maybe check other systems that define
|
|
371 TARGET_PROMOTE_FUNCTION_RETURN that always returns true. */
|
|
372
|
|
373 /* We will be using prototype promotion, so they will be 32 bit. */
|
|
374 #define PARM_BOUNDARY 32
|
|
375
|
|
376 /* Stack boundary is guided by -mstack-align, -mno-stack-align,
|
|
377 -malign.
|
|
378 Old comment: (2.1: still valid in 2.7.2?)
|
|
379 Note that to make this macro affect the alignment of stack
|
|
380 locals, a fix was required, and special precautions when handling
|
|
381 the stack pointer in various other macros (TARGET_ASM_FUNCTION_PROLOGUE
|
|
382 et al) were required. See file "function.c". If you would just define
|
|
383 this macro, it would only affect the builtin alloca and variable
|
|
384 local data (non-ANSI, non-K&R, Gnu C extension). */
|
|
385 #define STACK_BOUNDARY \
|
|
386 (TARGET_STACK_ALIGN ? (TARGET_ALIGN_BY_32 ? 32 : 16) : 8)
|
|
387
|
|
388 #define FUNCTION_BOUNDARY 16
|
|
389
|
|
390 /* Do not change BIGGEST_ALIGNMENT (when optimizing), as it will affect
|
|
391 strange places, at least in 2.1. */
|
|
392 #define BIGGEST_ALIGNMENT 8
|
|
393
|
|
394 /* If -m16bit, -m16-bit, -malign or -mdata-align,
|
|
395 align everything to 16 bit. */
|
|
396 #define DATA_ALIGNMENT(TYPE, BASIC_ALIGN) \
|
|
397 (TARGET_DATA_ALIGN \
|
|
398 ? (TARGET_ALIGN_BY_32 \
|
|
399 ? (BASIC_ALIGN < 32 ? 32 : BASIC_ALIGN) \
|
|
400 : (BASIC_ALIGN < 16 ? 16 : BASIC_ALIGN)) : BASIC_ALIGN)
|
|
401
|
|
402 /* Note that CONSTANT_ALIGNMENT has the effect of making gcc believe that
|
|
403 ALL references to constant stuff (in code segment, like strings) has
|
|
404 this alignment. That is a rather rushed assumption. Luckily we do not
|
|
405 care about the "alignment" operand to builtin memcpy (only place where
|
|
406 it counts), so it doesn't affect any bad spots. */
|
|
407 #define CONSTANT_ALIGNMENT(CONSTANT, BASIC_ALIGN) \
|
|
408 (TARGET_CONST_ALIGN \
|
|
409 ? (TARGET_ALIGN_BY_32 \
|
|
410 ? (BASIC_ALIGN < 32 ? 32 : BASIC_ALIGN) \
|
|
411 : (BASIC_ALIGN < 16 ? 16 : BASIC_ALIGN)) : BASIC_ALIGN)
|
|
412
|
|
413 /* FIXME: Define LOCAL_ALIGNMENT for word and dword or arrays and
|
|
414 structures (if -mstack-align=), and check that it is good. */
|
|
415
|
|
416 #define EMPTY_FIELD_BOUNDARY 8
|
|
417
|
|
418 #define STRUCTURE_SIZE_BOUNDARY 8
|
|
419
|
|
420 #define STRICT_ALIGNMENT 0
|
|
421
|
|
422 /* Remove any previous definition (elfos.h).
|
|
423 ??? If it wasn't for all the other stuff that affects layout of
|
|
424 structures and bit-fields, this could presumably cause incompatibility
|
|
425 with other GNU/Linux ports (i.e. elfos.h users). */
|
|
426 #undef PCC_BITFIELD_TYPE_MATTERS
|
|
427
|
|
428 /* This is only used for non-scalars. Strange stuff happens to structs
|
|
429 (FIXME: What?) if we use anything larger than largest actually used
|
|
430 datum size, so lets make it 32. The type "long long" will still work
|
|
431 as usual. We can still have DImode insns, but they will only be used
|
|
432 for scalar data (i.e. long long). */
|
|
433 #define MAX_FIXED_MODE_SIZE 32
|
|
434
|
|
435
|
|
436 /* Node: Type Layout */
|
|
437
|
|
438 /* Note that DOUBLE_TYPE_SIZE is not defined anymore, since the default
|
|
439 value gives a 64-bit double, which is what we now use. */
|
|
440
|
|
441 /* For compatibility and historical reasons, a char should be signed. */
|
|
442 #define DEFAULT_SIGNED_CHAR 1
|
|
443
|
|
444 /* Note that WCHAR_TYPE_SIZE is used in cexp.y,
|
|
445 where TARGET_SHORT is not available. */
|
|
446 #undef WCHAR_TYPE
|
|
447 #define WCHAR_TYPE "long int"
|
|
448
|
|
449 #undef WCHAR_TYPE_SIZE
|
|
450 #define WCHAR_TYPE_SIZE 32
|
|
451
|
|
452
|
|
453 /* Node: Register Basics */
|
|
454
|
|
455 /* We count all 16 non-special registers, SRP, a faked argument
|
|
456 pointer register, MOF and CCR/DCCR. */
|
|
457 #define FIRST_PSEUDO_REGISTER (16 + 1 + 1 + 1 + 1)
|
|
458
|
|
459 /* For CRIS, these are r15 (pc) and r14 (sp). Register r8 is used as a
|
|
460 frame-pointer, but is not fixed. SRP is not included in general
|
|
461 registers and will not be used automatically. All other special
|
|
462 registers are fixed at the moment. The faked argument pointer register
|
|
463 is fixed too. */
|
|
464 #define FIXED_REGISTERS \
|
|
465 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0}
|
|
466
|
|
467 /* Register r9 is used for structure-address, r10-r13 for parameters,
|
|
468 r10- for return values. */
|
|
469 #define CALL_USED_REGISTERS \
|
|
470 {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1}
|
|
471
|
|
472 #define CONDITIONAL_REGISTER_USAGE cris_conditional_register_usage ()
|
|
473
|
|
474
|
|
475 /* Node: Allocation Order */
|
|
476
|
|
477 /* We need this on CRIS, because call-used regs should be used first,
|
|
478 (so we don't need to push). Else start using registers from r0 and up.
|
|
479 This preference is mainly because if we put call-used-regs from r0
|
|
480 and up, then we can't use movem to push the rest, (which have to be
|
|
481 saved if we use them, and movem has to start with r0).
|
|
482 Change here if you change which registers to use as call registers.
|
|
483
|
|
484 The actual need to explicitly prefer call-used registers improved the
|
|
485 situation a lot for 2.1, but might not actually be needed anymore.
|
|
486 Still, this order reflects what GCC should find out by itself, so it
|
|
487 probably does not hurt.
|
|
488
|
|
489 Order of preference: Call-used-regs first, then r0 and up, last fp &
|
|
490 sp & pc as fillers.
|
|
491 Call-used regs in opposite order, so they will cause less conflict if
|
|
492 a function has few args (<= 3) and it wants a scratch reg.
|
|
493 Use struct-return address first, since very few functions use
|
|
494 structure return values so it is likely to be available. */
|
|
495 #define REG_ALLOC_ORDER \
|
|
496 {9, 13, 12, 11, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 14, 15, 17, 16, 18, 19}
|
|
497
|
|
498 /* Use MOF and ACR. Prefer ACR before any other register. Prefer MOF
|
|
499 then SRP after saved registers. The *after* is because they're only
|
|
500 useful for storage, not for things being computed, which is
|
|
501 apparently more common. */
|
|
502 #define REG_ALLOC_ORDER_V32 \
|
|
503 {15, 9, 13, 12, 11, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 17, 16, 14, 18, 19}
|
|
504
|
|
505
|
|
506 /* Node: Values in Registers */
|
|
507
|
|
508 /* The VOIDmode test is so we can omit mode on anonymous insns. FIXME:
|
|
509 Still needed in 2.9x, at least for Axis-20000319. */
|
|
510 #define HARD_REGNO_NREGS(REGNO, MODE) \
|
|
511 (MODE == VOIDmode \
|
|
512 ? 1 : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD))
|
|
513
|
|
514 /* CRIS permits all registers to hold all modes. Well, except for the
|
|
515 condition-code register. And we can't hold larger-than-register size
|
|
516 modes in the last special register that can hold a full 32 bits. */
|
|
517 #define HARD_REGNO_MODE_OK(REGNO, MODE) \
|
|
518 (((MODE) == CCmode \
|
|
519 || (REGNO) != CRIS_CC0_REGNUM) \
|
|
520 && (GET_MODE_SIZE (MODE) <= UNITS_PER_WORD \
|
|
521 || ((REGNO) != CRIS_MOF_REGNUM && (REGNO) != CRIS_ACR_REGNUM)))
|
|
522
|
|
523 /* Because CCmode isn't covered by the "narrower mode" statement in
|
|
524 tm.texi, we can still say all modes are tieable despite not having an
|
|
525 always 1 HARD_REGNO_MODE_OK. */
|
|
526 #define MODES_TIEABLE_P(MODE1, MODE2) 1
|
|
527
|
|
528
|
|
529 /* Node: Leaf Functions */
|
|
530 /* (no definitions) */
|
|
531
|
|
532 /* Node: Stack Registers */
|
|
533 /* (no definitions) */
|
|
534
|
|
535
|
|
536 /* Node: Register Classes */
|
|
537
|
|
538 /* FIXME: A separate class for the return register would make sense.
|
|
539
|
|
540 We need a separate register class to handle register allocation for
|
|
541 ACR, since it can't be used for post-increment.
|
|
542
|
|
543 It's not obvious, but having subunions of all movable-between
|
|
544 register classes does really help register allocation. */
|
|
545 enum reg_class
|
|
546 {
|
|
547 NO_REGS,
|
|
548 ACR_REGS, MOF_REGS, CC0_REGS, SPECIAL_REGS,
|
|
549 SPEC_ACR_REGS, GENNONACR_REGS,
|
|
550 SPEC_GENNONACR_REGS, GENERAL_REGS,
|
|
551 ALL_REGS,
|
|
552 LIM_REG_CLASSES
|
|
553 };
|
|
554
|
|
555 #define N_REG_CLASSES (int) LIM_REG_CLASSES
|
|
556
|
|
557 #define REG_CLASS_NAMES \
|
|
558 {"NO_REGS", \
|
|
559 "ACR_REGS", "MOF_REGS", "CC0_REGS", "SPECIAL_REGS", \
|
|
560 "SPEC_ACR_REGS", "GENNONACR_REGS", "SPEC_GENNONACR_REGS", \
|
|
561 "GENERAL_REGS", "ALL_REGS"}
|
|
562
|
|
563 #define CRIS_SPECIAL_REGS_CONTENTS \
|
|
564 ((1 << CRIS_SRP_REGNUM) | (1 << CRIS_MOF_REGNUM) | (1 << CRIS_CC0_REGNUM))
|
|
565
|
|
566 /* Count in the faked argument register in GENERAL_REGS. Keep out SRP. */
|
|
567 #define REG_CLASS_CONTENTS \
|
|
568 { \
|
|
569 {0}, \
|
|
570 {1 << CRIS_ACR_REGNUM}, \
|
|
571 {1 << CRIS_MOF_REGNUM}, \
|
|
572 {1 << CRIS_CC0_REGNUM}, \
|
|
573 {CRIS_SPECIAL_REGS_CONTENTS}, \
|
|
574 {CRIS_SPECIAL_REGS_CONTENTS \
|
|
575 | (1 << CRIS_ACR_REGNUM)}, \
|
|
576 {(0xffff | (1 << CRIS_AP_REGNUM)) \
|
|
577 & ~(1 << CRIS_ACR_REGNUM)}, \
|
|
578 {(0xffff | (1 << CRIS_AP_REGNUM) \
|
|
579 | CRIS_SPECIAL_REGS_CONTENTS) \
|
|
580 & ~(1 << CRIS_ACR_REGNUM)}, \
|
|
581 {0xffff | (1 << CRIS_AP_REGNUM)}, \
|
|
582 {0xffff | (1 << CRIS_AP_REGNUM) \
|
|
583 | CRIS_SPECIAL_REGS_CONTENTS} \
|
|
584 }
|
|
585
|
|
586 #define REGNO_REG_CLASS(REGNO) \
|
|
587 ((REGNO) == CRIS_ACR_REGNUM ? ACR_REGS : \
|
|
588 (REGNO) == CRIS_MOF_REGNUM ? MOF_REGS : \
|
|
589 (REGNO) == CRIS_CC0_REGNUM ? CC0_REGS : \
|
|
590 (REGNO) == CRIS_SRP_REGNUM ? SPECIAL_REGS : \
|
|
591 GENERAL_REGS)
|
|
592
|
|
593 #define BASE_REG_CLASS GENERAL_REGS
|
|
594
|
|
595 #define MODE_CODE_BASE_REG_CLASS(MODE, OCODE, ICODE) \
|
|
596 ((OCODE) != POST_INC ? BASE_REG_CLASS : GENNONACR_REGS)
|
|
597
|
|
598 #define INDEX_REG_CLASS GENERAL_REGS
|
|
599
|
|
600 #define IRA_COVER_CLASSES { GENERAL_REGS, SPECIAL_REGS, LIM_REG_CLASSES }
|
|
601
|
|
602 #define REG_CLASS_FROM_LETTER(C) \
|
|
603 ( \
|
|
604 (C) == 'a' ? ACR_REGS : \
|
|
605 (C) == 'b' ? GENNONACR_REGS : \
|
|
606 (C) == 'h' ? MOF_REGS : \
|
|
607 (C) == 'x' ? SPECIAL_REGS : \
|
|
608 (C) == 'c' ? CC0_REGS : \
|
|
609 NO_REGS \
|
|
610 )
|
|
611
|
|
612 /* Since it uses reg_renumber, it is safe only once reg_renumber
|
|
613 has been allocated, which happens in local-alloc.c. */
|
|
614 #define REGNO_OK_FOR_BASE_P(REGNO) \
|
|
615 ((REGNO) <= CRIS_LAST_GENERAL_REGISTER \
|
|
616 || (REGNO) == ARG_POINTER_REGNUM \
|
|
617 || (unsigned) reg_renumber[REGNO] <= CRIS_LAST_GENERAL_REGISTER \
|
|
618 || (unsigned) reg_renumber[REGNO] == ARG_POINTER_REGNUM)
|
|
619
|
|
620 /* REGNO_OK_FOR_BASE_P seems to be obsolete wrt. this one, but not yet
|
|
621 documented as such. */
|
|
622 #define REGNO_MODE_CODE_OK_FOR_BASE_P(REGNO, MODE, OCODE, ICODE) \
|
|
623 (REGNO_OK_FOR_BASE_P (REGNO) \
|
|
624 && ((OCODE) != POST_INC \
|
|
625 || !((REGNO) == CRIS_ACR_REGNUM \
|
|
626 || (unsigned) reg_renumber[REGNO] == CRIS_ACR_REGNUM)))
|
|
627
|
|
628 /* See REGNO_OK_FOR_BASE_P. */
|
|
629 #define REGNO_OK_FOR_INDEX_P(REGNO) REGNO_OK_FOR_BASE_P(REGNO)
|
|
630
|
|
631 /* It seems like gcc (2.7.2 and 2.9x of 2000-03-22) may send "NO_REGS" as
|
|
632 the class for a constant (testcase: __Mul in arit.c). To avoid forcing
|
|
633 out a constant into the constant pool, we will trap this case and
|
|
634 return something a bit more sane. FIXME: Check if this is a bug.
|
|
635 Beware that we must not "override" classes that can be specified as
|
|
636 constraint letters, or else asm operands using them will fail when
|
|
637 they need to be reloaded. FIXME: Investigate whether that constitutes
|
|
638 a bug. */
|
|
639 #define PREFERRED_RELOAD_CLASS(X, CLASS) \
|
|
640 ((CLASS) != ACR_REGS \
|
|
641 && (CLASS) != MOF_REGS \
|
|
642 && (CLASS) != CC0_REGS \
|
|
643 && (CLASS) != SPECIAL_REGS \
|
|
644 ? GENERAL_REGS : (CLASS))
|
|
645
|
|
646 /* We can't move special registers to and from memory in smaller than
|
36
|
647 word_mode. We also can't move between special registers. Luckily,
|
|
648 -1, as returned by true_regnum for non-sub/registers, is valid as a
|
|
649 parameter to our REGNO_REG_CLASS, returning GENERAL_REGS, so we get
|
|
650 the effect that any X that isn't a special-register is treated as
|
|
651 a non-empty intersection with GENERAL_REGS. */
|
|
652 #define SECONDARY_RELOAD_CLASS(CLASS, MODE, X) \
|
|
653 ((((CLASS) == SPECIAL_REGS || (CLASS) == MOF_REGS) \
|
|
654 && ((GET_MODE_SIZE (MODE) < 4 && MEM_P (X)) \
|
|
655 || !reg_classes_intersect_p (REGNO_REG_CLASS (true_regnum (X)), \
|
|
656 GENERAL_REGS))) \
|
|
657 ? GENERAL_REGS : NO_REGS)
|
0
|
658
|
|
659 /* FIXME: Fix regrename.c; it should check validity of replacements,
|
|
660 not just with a silly pass-specific macro. We may miss some
|
|
661 opportunities, but we must stop regrename from creating acr++. */
|
|
662 #define HARD_REGNO_RENAME_OK(FROM, TO) ((TO) != CRIS_ACR_REGNUM)
|
|
663
|
|
664 /* For CRIS, this is always the size of MODE in words,
|
|
665 since all registers are the same size. To use omitted modes in
|
|
666 patterns with reload constraints, you must say the widest size
|
|
667 which is allowed for VOIDmode.
|
|
668 FIXME: Does that still apply for gcc-2.9x? Keep poisoned until such
|
|
669 patterns are added back. News: 2001-03-16: Happens as early as the
|
|
670 underscore-test. */
|
|
671 #define CLASS_MAX_NREGS(CLASS, MODE) \
|
|
672 ((MODE) == VOIDmode \
|
|
673 ? 1 /* + cris_fatal ("CLASS_MAX_NREGS with VOIDmode") */ \
|
|
674 : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD))
|
|
675
|
|
676 /* We are now out of letters; we could use ten more. This forces us to
|
|
677 use C-code in the 'md' file. FIXME: Use some EXTRA_CONSTRAINTS. */
|
|
678 #define CRIS_CONST_OK_FOR_LETTER_P(VALUE, C) \
|
|
679 ( \
|
|
680 /* MOVEQ, CMPQ, ANDQ, ORQ. */ \
|
|
681 (C) == 'I' ? (VALUE) >= -32 && (VALUE) <= 31 : \
|
|
682 /* ADDQ, SUBQ. */ \
|
|
683 (C) == 'J' ? (VALUE) >= 0 && (VALUE) <= 63 : \
|
|
684 /* ASRQ, BTSTQ, LSRQ, LSLQ. */ \
|
|
685 (C) == 'K' ? (VALUE) >= 0 && (VALUE) <= 31 : \
|
|
686 /* A 16-bit signed number. */ \
|
|
687 (C) == 'L' ? (VALUE) >= -32768 && (VALUE) <= 32767 : \
|
|
688 /* The constant 0 for CLEAR. */ \
|
|
689 (C) == 'M' ? (VALUE) == 0 : \
|
|
690 /* A negative ADDQ or SUBQ. */ \
|
|
691 (C) == 'N' ? (VALUE) >= -63 && (VALUE) < 0 : \
|
|
692 /* Quickened ints, QI and HI. */ \
|
|
693 (C) == 'O' ? (VALUE) >= 0 && (VALUE) <= 65535 \
|
|
694 && ((VALUE) >= (65535-31) \
|
|
695 || ((VALUE) >= (255-31) \
|
|
696 && (VALUE) <= 255 )) : \
|
|
697 /* A 16-bit number signed *or* unsigned. */ \
|
|
698 (C) == 'P' ? (VALUE) >= -32768 && (VALUE) <= 65535 : \
|
|
699 0)
|
|
700
|
|
701 #define CONST_OK_FOR_CONSTRAINT_P(VALUE, C, S) \
|
|
702 ( \
|
|
703 ((C) != 'K' || (S)[1] == 'c') \
|
|
704 ? CRIS_CONST_OK_FOR_LETTER_P (VALUE, C) : \
|
|
705 ((C) == 'K' && (S)[1] == 'p') \
|
|
706 ? exact_log2 (VALUE) >= 0 : \
|
|
707 0)
|
|
708
|
|
709 #define CONSTRAINT_LEN(C, S) ((C) == 'K' ? 2 : DEFAULT_CONSTRAINT_LEN (C, S))
|
|
710
|
|
711 /* It is really simple to make up a 0.0; it is the same as int-0 in
|
|
712 IEEE754. */
|
|
713 #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) \
|
|
714 ((C) == 'G' && ((VALUE) == CONST0_RTX (DFmode) \
|
|
715 || (VALUE) == CONST0_RTX (SFmode)))
|
|
716
|
|
717 /* We need this on cris to distinguish delay-slottable addressing modes. */
|
|
718 #define EXTRA_CONSTRAINT(X, C) \
|
|
719 ( \
|
|
720 /* Slottable address mode? */ \
|
|
721 (C) == 'Q' ? EXTRA_CONSTRAINT_Q (X) : \
|
|
722 /* Operand to BDAP or BIAP? */ \
|
|
723 (C) == 'R' ? EXTRA_CONSTRAINT_R (X) : \
|
|
724 /* A local PIC symbol? */ \
|
|
725 (C) == 'S' ? EXTRA_CONSTRAINT_S (X) : \
|
|
726 /* A three-address addressing-mode? */ \
|
|
727 (C) == 'T' ? EXTRA_CONSTRAINT_T (X) : \
|
|
728 /* A PLT symbol? */ \
|
|
729 (C) == 'U' ? EXTRA_CONSTRAINT_U (X) : \
|
|
730 0)
|
|
731
|
|
732 #define EXTRA_MEMORY_CONSTRAINT(X, STR) ((X) == 'Q')
|
|
733
|
|
734 #define EXTRA_CONSTRAINT_Q(X) \
|
|
735 ( \
|
|
736 /* Just an indirect register (happens to also be \
|
|
737 "all" slottable memory addressing modes not \
|
|
738 covered by other constraints, i.e. '>'). */ \
|
|
739 MEM_P (X) && BASE_P (XEXP (X, 0)) \
|
|
740 )
|
|
741
|
|
742 #define EXTRA_CONSTRAINT_R(X) \
|
|
743 ( \
|
|
744 /* An operand to BDAP or BIAP: \
|
|
745 A BIAP; r.S? */ \
|
|
746 BIAP_INDEX_P (X) \
|
|
747 /* A [reg] or (int) [reg], maybe with post-increment. */ \
|
|
748 || BDAP_INDEX_P (X) \
|
|
749 || CONSTANT_INDEX_P (X) \
|
|
750 )
|
|
751
|
|
752 #define EXTRA_CONSTRAINT_T(X) \
|
|
753 ( \
|
|
754 /* Memory three-address operand. All are indirect-memory: */ \
|
|
755 MEM_P (X) \
|
|
756 && ((MEM_P (XEXP (X, 0)) \
|
|
757 /* Double indirect: [[reg]] or [[reg+]]? */ \
|
|
758 && (BASE_OR_AUTOINCR_P (XEXP (XEXP (X, 0), 0)))) \
|
|
759 /* Just an explicit indirect reference: [const]? */ \
|
|
760 || CONSTANT_P (XEXP (X, 0)) \
|
|
761 /* Something that is indexed; [...+...]? */ \
|
|
762 || (GET_CODE (XEXP (X, 0)) == PLUS \
|
|
763 /* A BDAP constant: [reg+(8|16|32)bit offset]? */ \
|
|
764 && ((BASE_P (XEXP (XEXP (X, 0), 0)) \
|
|
765 && CONSTANT_INDEX_P (XEXP (XEXP (X, 0), 1))) \
|
|
766 /* A BDAP register: [reg+[reg(+)].S]? */ \
|
|
767 || (BASE_P (XEXP (XEXP (X, 0), 0)) \
|
|
768 && BDAP_INDEX_P(XEXP(XEXP(X, 0), 1))) \
|
|
769 /* Same, but with swapped arguments (no canonical \
|
|
770 ordering between e.g. REG and MEM as of LAST_UPDATED \
|
|
771 "Thu May 12 03:59:11 UTC 2005"). */ \
|
|
772 || (BASE_P (XEXP (XEXP (X, 0), 1)) \
|
|
773 && BDAP_INDEX_P (XEXP (XEXP (X, 0), 0))) \
|
|
774 /* A BIAP: [reg+reg.S] (MULT comes first). */ \
|
|
775 || (BASE_P (XEXP (XEXP (X, 0), 1)) \
|
|
776 && BIAP_INDEX_P (XEXP (XEXP (X, 0), 0)))))) \
|
|
777 )
|
|
778
|
|
779 /* PIC-constructs for symbols. */
|
|
780 #define EXTRA_CONSTRAINT_S(X) \
|
|
781 (flag_pic && GET_CODE (X) == CONST && cris_valid_pic_const (X, false))
|
|
782
|
|
783 #define EXTRA_CONSTRAINT_U(X) \
|
|
784 (flag_pic \
|
|
785 && CONSTANT_P (X) \
|
|
786 && cris_nonmemory_operand_or_callable_symbol (X, VOIDmode))
|
|
787
|
|
788
|
|
789 /* Node: Frame Layout */
|
|
790
|
|
791 #define STACK_GROWS_DOWNWARD
|
|
792 #define FRAME_GROWS_DOWNWARD 1
|
|
793
|
|
794 /* It seems to be indicated in the code (at least 2.1) that this is
|
|
795 better a constant, and best 0. */
|
|
796 #define STARTING_FRAME_OFFSET 0
|
|
797
|
|
798 #define FIRST_PARM_OFFSET(FNDECL) 0
|
|
799
|
|
800 #define RETURN_ADDR_RTX(COUNT, FRAMEADDR) \
|
|
801 cris_return_addr_rtx (COUNT, FRAMEADDR)
|
|
802
|
|
803 #define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (Pmode, CRIS_SRP_REGNUM)
|
|
804
|
|
805 /* FIXME: Any __builtin_eh_return callers must not return anything and
|
|
806 there must not be collisions with incoming parameters. Luckily the
|
|
807 number of __builtin_eh_return callers is limited. For now return
|
|
808 parameter registers in reverse order and hope for the best. */
|
|
809 #define EH_RETURN_DATA_REGNO(N) \
|
|
810 (IN_RANGE ((N), 0, 3) ? (CRIS_FIRST_ARG_REG + 3 - (N)) : INVALID_REGNUM)
|
|
811
|
|
812 /* Store the stack adjustment in the structure-return-address register. */
|
|
813 #define CRIS_STACKADJ_REG CRIS_STRUCT_VALUE_REGNUM
|
|
814 #define EH_RETURN_STACKADJ_RTX gen_rtx_REG (SImode, CRIS_STACKADJ_REG)
|
|
815
|
|
816 #define EH_RETURN_HANDLER_RTX \
|
|
817 cris_return_addr_rtx (0, NULL)
|
|
818
|
|
819 #define INIT_EXPANDERS cris_init_expanders ()
|
|
820
|
|
821 /* FIXME: Move this to right node (it's not documented properly yet). */
|
|
822 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (CRIS_SRP_REGNUM)
|
|
823
|
|
824 /* FIXME: Move this to right node (it's not documented properly yet).
|
|
825 FIXME: Check what alignment we can assume regarding
|
|
826 TARGET_STACK_ALIGN and TARGET_ALIGN_BY_32. */
|
|
827 #define DWARF_CIE_DATA_ALIGNMENT -1
|
|
828
|
|
829 /* If we would ever need an exact mapping between canonical register
|
|
830 number and dwarf frame register, we would either need to include all
|
|
831 registers in the gcc description (with some marked fixed of course), or
|
|
832 an inverse mapping from dwarf register to gcc register. There is one
|
|
833 need in dwarf2out.c:expand_builtin_init_dwarf_reg_sizes. Right now, I
|
|
834 don't see that we need exact correspondence between DWARF *frame*
|
|
835 registers and DBX_REGISTER_NUMBER, so map them onto GCC registers. */
|
|
836 #define DWARF_FRAME_REGNUM(REG) (REG)
|
|
837
|
|
838 /* Node: Stack Checking */
|
|
839 /* (no definitions) FIXME: Check. */
|
|
840
|
|
841 /* Node: Frame Registers */
|
|
842
|
|
843 #define STACK_POINTER_REGNUM CRIS_SP_REGNUM
|
|
844
|
|
845 /* Register used for frame pointer. This is also the last of the saved
|
|
846 registers, when a frame pointer is not used. */
|
|
847 #define FRAME_POINTER_REGNUM CRIS_FP_REGNUM
|
|
848
|
|
849 /* Faked register, is always eliminated. We need it to eliminate
|
|
850 allocating stack slots for the return address and the frame pointer. */
|
|
851 #define ARG_POINTER_REGNUM CRIS_AP_REGNUM
|
|
852
|
|
853 #define STATIC_CHAIN_REGNUM CRIS_STATIC_CHAIN_REGNUM
|
|
854
|
|
855
|
|
856 /* Node: Elimination */
|
|
857
|
|
858 /* Really only needed if the stack frame has variable length (alloca
|
|
859 or variable sized local arguments (GNU C extension). See PR39499 and
|
|
860 PR38609 for the reason this isn't just 0. */
|
|
861 #define FRAME_POINTER_REQUIRED (!current_function_sp_is_unchanging)
|
|
862
|
|
863 #define ELIMINABLE_REGS \
|
|
864 {{ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \
|
|
865 {ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM}, \
|
|
866 {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}}
|
|
867
|
|
868 /* We need not worry about when the frame-pointer is required for other
|
|
869 reasons. */
|
|
870 #define CAN_ELIMINATE(FROM, TO) 1
|
|
871
|
|
872 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
|
|
873 (OFFSET) = cris_initial_elimination_offset (FROM, TO)
|
|
874
|
|
875
|
|
876 /* Node: Stack Arguments */
|
|
877
|
|
878 /* Since many parameters take up one register each in any case,
|
|
879 defining TARGET_PROMOTE_PROTOTYPES that always returns true would
|
|
880 seem like a good idea, but measurements indicate that a combination
|
|
881 using PROMOTE_MODE is better. */
|
|
882
|
|
883 #define ACCUMULATE_OUTGOING_ARGS 1
|
|
884
|
|
885 #define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACKSIZE) 0
|
|
886
|
|
887
|
|
888 /* Node: Register Arguments */
|
|
889
|
|
890 /* The void_type_node is sent as a "closing" call. */
|
|
891 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
|
|
892 ((CUM).regs < CRIS_MAX_ARGS_IN_REGS \
|
|
893 ? gen_rtx_REG (MODE, (CRIS_FIRST_ARG_REG) + (CUM).regs) \
|
|
894 : NULL_RTX)
|
|
895
|
|
896 /* The differences between this and the previous, is that this one checks
|
|
897 that an argument is named, since incoming stdarg/varargs arguments are
|
|
898 pushed onto the stack, and we don't have to check against the "closing"
|
|
899 void_type_node TYPE parameter. */
|
|
900 #define FUNCTION_INCOMING_ARG(CUM, MODE, TYPE, NAMED) \
|
|
901 ((NAMED) && (CUM).regs < CRIS_MAX_ARGS_IN_REGS \
|
|
902 ? gen_rtx_REG (MODE, CRIS_FIRST_ARG_REG + (CUM).regs) \
|
|
903 : NULL_RTX)
|
|
904
|
|
905 /* Contrary to what you'd believe, defining FUNCTION_ARG_CALLEE_COPIES
|
|
906 seems like a (small total) loss, at least for gcc-2.7.2 compiling and
|
|
907 running gcc-2.1 (small win in size, small loss running -- 100.1%),
|
|
908 and similarly for size for products (.1 .. .3% bloat, sometimes win).
|
|
909 Due to the empirical likeliness of making slower code, it is not
|
|
910 defined. */
|
|
911
|
|
912 /* This no longer *needs* to be a structure; but keeping it as such should
|
|
913 not hurt (and hacking the ABI is simpler). */
|
|
914 #define CUMULATIVE_ARGS struct cum_args
|
|
915 struct cum_args {int regs;};
|
|
916
|
|
917 /* The regs member is an integer, the number of arguments got into
|
|
918 registers so far. */
|
|
919 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, FNDECL, N_NAMED_ARGS) \
|
|
920 ((CUM).regs = 0)
|
|
921
|
|
922 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \
|
|
923 ((CUM).regs += (3 + CRIS_FUNCTION_ARG_SIZE (MODE, TYPE)) / 4)
|
|
924
|
|
925 #define FUNCTION_ARG_REGNO_P(REGNO) \
|
|
926 ((REGNO) >= CRIS_FIRST_ARG_REG \
|
|
927 && (REGNO) < CRIS_FIRST_ARG_REG + (CRIS_MAX_ARGS_IN_REGS))
|
|
928
|
|
929
|
|
930 /* Node: Scalar Return */
|
|
931
|
|
932 /* Let's assume all functions return in r[CRIS_FIRST_ARG_REG] for the
|
|
933 time being. */
|
|
934 #define FUNCTION_VALUE(VALTYPE, FUNC) \
|
|
935 gen_rtx_REG (TYPE_MODE (VALTYPE), CRIS_FIRST_ARG_REG)
|
|
936
|
|
937 #define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, CRIS_FIRST_ARG_REG)
|
|
938
|
|
939 #define FUNCTION_VALUE_REGNO_P(N) ((N) == CRIS_FIRST_ARG_REG)
|
|
940
|
|
941
|
|
942 /* Node: Aggregate Return */
|
|
943
|
|
944 #define CRIS_STRUCT_VALUE_REGNUM ((CRIS_FIRST_ARG_REG) - 1)
|
|
945
|
|
946
|
|
947 /* Node: Caller Saves */
|
|
948 /* (no definitions) */
|
|
949
|
|
950 /* Node: Function entry */
|
|
951
|
|
952 /* See cris.c for TARGET_ASM_FUNCTION_PROLOGUE and
|
|
953 TARGET_ASM_FUNCTION_EPILOGUE. */
|
|
954
|
|
955 /* Node: Profiling */
|
|
956
|
|
957 #define FUNCTION_PROFILER(FILE, LABELNO) \
|
|
958 error ("no FUNCTION_PROFILER for CRIS")
|
|
959
|
|
960 /* FIXME: Some of the undefined macros might be mandatory. If so, fix
|
|
961 documentation. */
|
|
962
|
|
963
|
|
964 /* Node: Trampolines */
|
|
965
|
|
966 /* This looks too complicated, and it is. I assigned r7 to be the
|
|
967 static chain register, but it is call-saved, so we have to save it,
|
|
968 and come back to restore it after the call, so we have to save srp...
|
|
969 Anyway, trampolines are rare enough that we can cope with this
|
|
970 somewhat lack of elegance.
|
|
971 (Do not be tempted to "straighten up" whitespace in the asms; the
|
|
972 assembler #NO_APP state mandates strict spacing). */
|
|
973 #define TRAMPOLINE_TEMPLATE(FILE) \
|
|
974 do \
|
|
975 { \
|
|
976 if (TARGET_V32) \
|
|
977 { \
|
|
978 /* This normally-unused nop insn acts as an instruction to \
|
|
979 the simulator to flush its instruction cache. None of \
|
|
980 the other instructions in the trampoline template suits \
|
|
981 as a trigger for V32. The pc-relative addressing mode \
|
|
982 works nicely as a trigger for V10. \
|
|
983 FIXME: Have specific V32 template (possibly avoiding the \
|
|
984 use of a special instruction). */ \
|
|
985 fprintf (FILE, "\tclearf x\n"); \
|
|
986 /* We have to use a register as an intermediate, choosing \
|
|
987 semi-randomly R1 (which has to not be the \
|
|
988 STATIC_CHAIN_REGNUM), so we can use it for address \
|
|
989 indirection and jsr target. */ \
|
|
990 fprintf (FILE, "\tmove $r1,$mof\n"); \
|
|
991 /* +4 */ \
|
|
992 fprintf (FILE, "\tmove.d 0,$r1\n"); \
|
|
993 fprintf (FILE, "\tmove.d $%s,[$r1]\n", \
|
|
994 reg_names[STATIC_CHAIN_REGNUM]); \
|
|
995 fprintf (FILE, "\taddq 6,$r1\n"); \
|
|
996 fprintf (FILE, "\tmove $mof,[$r1]\n"); \
|
|
997 fprintf (FILE, "\taddq 6,$r1\n"); \
|
|
998 fprintf (FILE, "\tmove $srp,[$r1]\n"); \
|
|
999 /* +20 */ \
|
|
1000 fprintf (FILE, "\tmove.d 0,$%s\n", \
|
|
1001 reg_names[STATIC_CHAIN_REGNUM]); \
|
|
1002 /* +26 */ \
|
|
1003 fprintf (FILE, "\tmove.d 0,$r1\n"); \
|
|
1004 fprintf (FILE, "\tjsr $r1\n"); \
|
|
1005 fprintf (FILE, "\tsetf\n"); \
|
|
1006 /* +36 */ \
|
|
1007 fprintf (FILE, "\tmove.d 0,$%s\n", \
|
|
1008 reg_names[STATIC_CHAIN_REGNUM]); \
|
|
1009 /* +42 */ \
|
|
1010 fprintf (FILE, "\tmove.d 0,$r1\n"); \
|
|
1011 /* +48 */ \
|
|
1012 fprintf (FILE, "\tmove.d 0,$r9\n"); \
|
|
1013 fprintf (FILE, "\tjump $r9\n"); \
|
|
1014 fprintf (FILE, "\tsetf\n"); \
|
|
1015 } \
|
|
1016 else \
|
|
1017 { \
|
|
1018 fprintf (FILE, "\tmove.d $%s,[$pc+20]\n", \
|
|
1019 reg_names[STATIC_CHAIN_REGNUM]); \
|
|
1020 fprintf (FILE, "\tmove $srp,[$pc+22]\n"); \
|
|
1021 fprintf (FILE, "\tmove.d 0,$%s\n", \
|
|
1022 reg_names[STATIC_CHAIN_REGNUM]); \
|
|
1023 fprintf (FILE, "\tjsr 0\n"); \
|
|
1024 fprintf (FILE, "\tmove.d 0,$%s\n", \
|
|
1025 reg_names[STATIC_CHAIN_REGNUM]); \
|
|
1026 fprintf (FILE, "\tjump 0\n"); \
|
|
1027 } \
|
|
1028 } \
|
|
1029 while (0)
|
|
1030
|
|
1031 #define TRAMPOLINE_SIZE (TARGET_V32 ? 58 : 32)
|
|
1032
|
|
1033 /* CRIS wants instructions on word-boundary.
|
|
1034 Note that due to a bug (reported) in 2.7.2 and earlier, this is
|
|
1035 actually treated as alignment in _bytes_, not _bits_. (Obviously
|
|
1036 this is not fatal, only a slight waste of stack space). */
|
|
1037 #define TRAMPOLINE_ALIGNMENT 16
|
|
1038
|
|
1039 #define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
|
|
1040 do \
|
|
1041 if (TARGET_V32) \
|
|
1042 { \
|
|
1043 emit_move_insn (gen_rtx_MEM (SImode, \
|
|
1044 plus_constant (TRAMP, 6)), \
|
|
1045 plus_constant (TRAMP, 38)); \
|
|
1046 emit_move_insn (gen_rtx_MEM (SImode, \
|
|
1047 plus_constant (TRAMP, 22)), \
|
|
1048 CXT); \
|
|
1049 emit_move_insn (gen_rtx_MEM (SImode, \
|
|
1050 plus_constant (TRAMP, 28)), \
|
|
1051 FNADDR); \
|
|
1052 } \
|
|
1053 else \
|
|
1054 { \
|
|
1055 emit_move_insn (gen_rtx_MEM (SImode, \
|
|
1056 plus_constant (TRAMP, 10)), \
|
|
1057 CXT); \
|
|
1058 emit_move_insn (gen_rtx_MEM (SImode, \
|
|
1059 plus_constant (TRAMP, 16)), \
|
|
1060 FNADDR); \
|
|
1061 } \
|
|
1062 while (0)
|
|
1063
|
|
1064 /* Note that there is no need to do anything with the cache for sake of
|
|
1065 a trampoline. */
|
|
1066
|
|
1067
|
|
1068 /* Node: Library Calls */
|
|
1069
|
|
1070 /* If you change this, you have to check whatever libraries and systems
|
|
1071 that use it. */
|
|
1072 #define TARGET_EDOM 33
|
|
1073
|
|
1074
|
|
1075 /* Node: Addressing Modes */
|
|
1076
|
|
1077 #define HAVE_POST_INCREMENT 1
|
|
1078
|
|
1079 #define CONSTANT_ADDRESS_P(X) CONSTANT_P (X)
|
|
1080
|
|
1081 /* Must be a compile-time constant, so we go with the highest value
|
|
1082 among all CRIS variants. */
|
|
1083 #define MAX_REGS_PER_ADDRESS 2
|
|
1084
|
|
1085 /* There are helper macros defined here which are used only in
|
|
1086 GO_IF_LEGITIMATE_ADDRESS.
|
|
1087
|
|
1088 Note that you *have to* reject invalid addressing modes for mode
|
|
1089 MODE, even if it is legal for normal addressing modes. You cannot
|
|
1090 rely on the constraints to do this work. They can only be used to
|
|
1091 doublecheck your intentions. One example is that you HAVE TO reject
|
|
1092 (mem:DI (plus:SI (reg:SI x) (reg:SI y))) because for some reason
|
|
1093 this cannot be reloaded. (Which of course you can argue that gcc
|
|
1094 should have done.) FIXME: Strange. Check. */
|
|
1095
|
|
1096 /* No symbol can be used as an index (or more correct, as a base) together
|
|
1097 with a register with PIC; the PIC register must be there. */
|
|
1098 #define CONSTANT_INDEX_P(X) \
|
|
1099 (CONSTANT_P (X) && (!flag_pic || cris_valid_pic_const (X, true)))
|
|
1100
|
|
1101 /* True if X is a valid base register. */
|
|
1102 #define BASE_P(X) \
|
|
1103 (REG_P (X) && REG_OK_FOR_BASE_P (X))
|
|
1104
|
|
1105 /* True if X is a valid base register with or without autoincrement. */
|
|
1106 #define BASE_OR_AUTOINCR_P(X) \
|
|
1107 (BASE_P (X) \
|
|
1108 || (GET_CODE (X) == POST_INC \
|
|
1109 && BASE_P (XEXP (X, 0)) \
|
|
1110 && REGNO (XEXP (X, 0)) != CRIS_ACR_REGNUM))
|
|
1111
|
|
1112 /* True if X is a valid (register) index for BDAP, i.e. [Rs].S or [Rs+].S. */
|
|
1113 #define BDAP_INDEX_P(X) \
|
|
1114 ((MEM_P (X) && GET_MODE (X) == SImode \
|
|
1115 && BASE_OR_AUTOINCR_P (XEXP (X, 0))) \
|
|
1116 || (GET_CODE (X) == SIGN_EXTEND \
|
|
1117 && MEM_P (XEXP (X, 0)) \
|
|
1118 && (GET_MODE (XEXP (X, 0)) == HImode \
|
|
1119 || GET_MODE (XEXP (X, 0)) == QImode) \
|
|
1120 && BASE_OR_AUTOINCR_P (XEXP (XEXP (X, 0), 0))))
|
|
1121
|
|
1122 /* True if X is a valid (register) index for BIAP, i.e. Rd.m. */
|
|
1123 #define BIAP_INDEX_P(X) \
|
|
1124 ((BASE_P (X) && REG_OK_FOR_INDEX_P (X)) \
|
|
1125 || (GET_CODE (X) == MULT \
|
|
1126 && BASE_P (XEXP (X, 0)) \
|
|
1127 && REG_OK_FOR_INDEX_P (XEXP (X, 0)) \
|
|
1128 && CONST_INT_P (XEXP (X, 1)) \
|
|
1129 && (INTVAL (XEXP (X, 1)) == 2 \
|
|
1130 || INTVAL (XEXP (X, 1)) == 4)))
|
|
1131
|
|
1132 /* A PIC operand looks like a normal symbol here. At output we dress it
|
|
1133 in "[rPIC+symbol:GOT]" (global symbol) or "rPIC+symbol:GOTOFF" (local
|
|
1134 symbol) so we exclude all addressing modes where we can't replace a
|
|
1135 plain "symbol" with that. A global PIC symbol does not fit anywhere
|
|
1136 here (but is thankfully a general_operand in itself). A local PIC
|
|
1137 symbol is valid for the plain "symbol + offset" case. */
|
|
1138 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \
|
|
1139 { \
|
|
1140 rtx x1, x2; \
|
|
1141 if (BASE_OR_AUTOINCR_P (X)) \
|
|
1142 goto ADDR; \
|
|
1143 else if (TARGET_V32) \
|
|
1144 /* Nothing else is valid then. */ \
|
|
1145 ; \
|
|
1146 else if (CONSTANT_INDEX_P (X)) \
|
|
1147 goto ADDR; \
|
|
1148 /* Indexed? */ \
|
|
1149 else if (GET_CODE (X) == PLUS) \
|
|
1150 { \
|
|
1151 x1 = XEXP (X, 0); \
|
|
1152 x2 = XEXP (X, 1); \
|
|
1153 /* BDAP o, Rd. */ \
|
|
1154 if ((BASE_P (x1) && CONSTANT_INDEX_P (x2)) \
|
|
1155 || (BASE_P (x2) && CONSTANT_INDEX_P (x1)) \
|
|
1156 /* BDAP Rs[+], Rd. */ \
|
|
1157 || (GET_MODE_SIZE (MODE) <= UNITS_PER_WORD \
|
|
1158 && ((BASE_P (x1) && BDAP_INDEX_P (x2)) \
|
|
1159 || (BASE_P (x2) && BDAP_INDEX_P (x1)) \
|
|
1160 /* BIAP.m Rs, Rd */ \
|
|
1161 || (BASE_P (x1) && BIAP_INDEX_P (x2)) \
|
|
1162 || (BASE_P (x2) && BIAP_INDEX_P (x1))))) \
|
|
1163 goto ADDR; \
|
|
1164 } \
|
|
1165 else if (MEM_P (X)) \
|
|
1166 { \
|
|
1167 /* DIP (Rs). Reject [[reg+]] and [[reg]] for \
|
|
1168 DImode (long long). */ \
|
|
1169 if (GET_MODE_SIZE (MODE) <= UNITS_PER_WORD \
|
|
1170 && (BASE_P (XEXP (X, 0)) \
|
|
1171 || BASE_OR_AUTOINCR_P (XEXP (X, 0)))) \
|
|
1172 goto ADDR; \
|
|
1173 } \
|
|
1174 }
|
|
1175
|
|
1176 #ifndef REG_OK_STRICT
|
|
1177 /* Nonzero if X is a hard reg that can be used as a base reg
|
|
1178 or if it is a pseudo reg. */
|
|
1179 # define REG_OK_FOR_BASE_P(X) \
|
|
1180 (REGNO (X) <= CRIS_LAST_GENERAL_REGISTER \
|
|
1181 || REGNO (X) == ARG_POINTER_REGNUM \
|
|
1182 || REGNO (X) >= FIRST_PSEUDO_REGISTER)
|
|
1183 #else
|
|
1184 /* Nonzero if X is a hard reg that can be used as a base reg. */
|
|
1185 # define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X))
|
|
1186 #endif
|
|
1187
|
|
1188 #ifndef REG_OK_STRICT
|
|
1189 /* Nonzero if X is a hard reg that can be used as an index
|
|
1190 or if it is a pseudo reg. */
|
|
1191 # define REG_OK_FOR_INDEX_P(X) REG_OK_FOR_BASE_P (X)
|
|
1192 #else
|
|
1193 /* Nonzero if X is a hard reg that can be used as an index. */
|
|
1194 # define REG_OK_FOR_INDEX_P(X) REGNO_OK_FOR_INDEX_P (REGNO (X))
|
|
1195 #endif
|
|
1196
|
|
1197 /* For now, don't do anything. GCC does a good job most often.
|
|
1198
|
|
1199 Maybe we could do something about gcc:s misbehavior when it
|
|
1200 recalculates frame offsets for local variables, from fp+offs to
|
|
1201 sp+offs. The resulting address expression gets screwed up
|
|
1202 sometimes, but I'm not sure that it may be fixed here, since it is
|
|
1203 already split up in several instructions (Is this still true?).
|
|
1204 FIXME: Check and adjust for gcc-2.9x. */
|
|
1205 #define LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN) {}
|
|
1206
|
|
1207 /* Fix reloads known to cause suboptimal spilling. */
|
|
1208 #define LEGITIMIZE_RELOAD_ADDRESS(X, MODE, OPNUM, TYPE, INDL, WIN) \
|
|
1209 do \
|
|
1210 { \
|
|
1211 if (cris_reload_address_legitimized (X, MODE, OPNUM, TYPE, INDL)) \
|
|
1212 goto WIN; \
|
|
1213 } \
|
|
1214 while (0)
|
|
1215
|
|
1216 /* In CRIS, only the postincrement address mode depends thus,
|
|
1217 since the increment depends on the size of the operand. This is now
|
|
1218 treated generically within recog.c. */
|
|
1219 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR, LABEL)
|
|
1220
|
|
1221 #define LEGITIMATE_CONSTANT_P(X) 1
|
|
1222
|
|
1223
|
|
1224 /* Node: Condition Code */
|
|
1225
|
|
1226 #define NOTICE_UPDATE_CC(EXP, INSN) cris_notice_update_cc (EXP, INSN)
|
|
1227
|
|
1228 /* FIXME: Maybe define CANONICALIZE_COMPARISON later, when playing with
|
|
1229 optimizations. It is needed; currently we do this with instruction
|
|
1230 patterns and NOTICE_UPDATE_CC. */
|
|
1231
|
|
1232
|
|
1233 /* Node: Costs */
|
|
1234
|
|
1235 #define REGISTER_MOVE_COST(MODE, FROM, TO) \
|
|
1236 cris_register_move_cost (MODE, FROM, TO)
|
|
1237
|
|
1238 /* This isn't strictly correct for v0..3 in buswidth-8bit mode, but
|
|
1239 should suffice. */
|
|
1240 #define MEMORY_MOVE_COST(M, CLASS, IN) \
|
|
1241 (((M) == QImode) ? 4 : ((M) == HImode) ? 4 : 6)
|
|
1242
|
|
1243 /* Regardless of the presence of delay slots, the default value of 1 for
|
|
1244 BRANCH_COST is the best in the range (1, 2, 3), tested with gcc-2.7.2
|
|
1245 with testcases ipps and gcc, giving smallest and fastest code. */
|
|
1246
|
|
1247 #define SLOW_BYTE_ACCESS 0
|
|
1248
|
|
1249 /* This is the threshold *below* which inline move sequences of
|
|
1250 word-length sizes will be emitted. The "9" will translate to
|
|
1251 (9 - 1) * 4 = 32 bytes maximum moved, but using 16 instructions
|
|
1252 (8 instruction sequences) or less. */
|
|
1253 #define MOVE_RATIO(speed) 9
|
|
1254
|
|
1255
|
|
1256 /* Node: Sections */
|
|
1257
|
|
1258 #define TEXT_SECTION_ASM_OP "\t.text"
|
|
1259
|
|
1260 #define DATA_SECTION_ASM_OP "\t.data"
|
|
1261
|
|
1262 #define FORCE_EH_FRAME_INFO_IN_DATA_SECTION (! TARGET_ELF)
|
|
1263
|
|
1264 /* The jump table is immediately connected to the preceding insn. */
|
|
1265 #define JUMP_TABLES_IN_TEXT_SECTION 1
|
|
1266
|
|
1267
|
|
1268 /* Node: PIC */
|
|
1269
|
|
1270 /* Helper type. */
|
|
1271
|
|
1272 enum cris_pic_symbol_type
|
|
1273 {
|
|
1274 cris_no_symbol = 0,
|
|
1275 cris_got_symbol = 1,
|
|
1276 cris_rel_symbol = 2,
|
|
1277 cris_got_symbol_needing_fixup = 3,
|
|
1278 cris_invalid_pic_symbol = 4
|
|
1279 };
|
|
1280
|
|
1281 #define PIC_OFFSET_TABLE_REGNUM (flag_pic ? CRIS_GOT_REGNUM : INVALID_REGNUM)
|
|
1282
|
|
1283 #define LEGITIMATE_PIC_OPERAND_P(X) cris_legitimate_pic_operand (X)
|
|
1284
|
|
1285
|
|
1286 /* Node: File Framework */
|
|
1287
|
|
1288 /* We don't want an .ident for gcc. To avoid that but still support
|
|
1289 #ident, we override ASM_OUTPUT_IDENT and, since the gcc .ident is its
|
|
1290 only use besides ASM_OUTPUT_IDENT, undef IDENT_ASM_OP from elfos.h. */
|
|
1291 #undef IDENT_ASM_OP
|
|
1292 #undef ASM_OUTPUT_IDENT
|
|
1293 #define ASM_OUTPUT_IDENT(FILE, NAME) \
|
|
1294 fprintf (FILE, "%s\"%s\"\n", "\t.ident\t", NAME);
|
|
1295
|
|
1296 #define ASM_APP_ON "#APP\n"
|
|
1297
|
|
1298 #define ASM_APP_OFF "#NO_APP\n"
|
|
1299
|
|
1300
|
|
1301 /* Node: Data Output */
|
|
1302
|
|
1303 #define OUTPUT_ADDR_CONST_EXTRA(STREAM, X, FAIL) \
|
|
1304 do { if (!cris_output_addr_const_extra (STREAM, X)) goto FAIL; } while (0)
|
|
1305
|
|
1306 #define IS_ASM_LOGICAL_LINE_SEPARATOR(C, STR) (C) == '@'
|
|
1307
|
|
1308 /* Node: Uninitialized Data */
|
|
1309
|
|
1310 /* Remember to round off odd values if we want data alignment,
|
|
1311 since we cannot do that with an .align directive.
|
|
1312
|
|
1313 Using .comm causes the space not to be reserved in .bss, but by
|
|
1314 tricks with the symbol type. Not good if other tools than binutils
|
|
1315 are used on the object files. Since ".global ... .lcomm ..." works, we
|
|
1316 use that. Use .._ALIGNED_COMMON, since gcc whines when we only have
|
|
1317 ..._COMMON, and we prefer to whine ourselves; BIGGEST_ALIGNMENT is not
|
|
1318 the one to check. This done for a.out only. */
|
|
1319 /* FIXME: I suspect a bug in gcc with alignment. Do not warn until
|
|
1320 investigated; it mucks up the testsuite results. */
|
|
1321 #define CRIS_ASM_OUTPUT_ALIGNED_DECL_COMMON(FILE, DECL, NAME, SIZE, ALIGN, LOCAL) \
|
|
1322 do \
|
|
1323 { \
|
|
1324 int align_ = (ALIGN) / BITS_PER_UNIT; \
|
|
1325 if (TARGET_DATA_ALIGN && TARGET_ALIGN_BY_32 && align_ < 4) \
|
|
1326 align_ = 4; \
|
|
1327 else if (TARGET_DATA_ALIGN && align_ < 2) \
|
|
1328 align_ = 2; \
|
|
1329 /* FIXME: Do we need this? */ \
|
|
1330 else if (align_ < 1) \
|
|
1331 align_ = 1; \
|
|
1332 \
|
|
1333 if (TARGET_ELF) \
|
|
1334 { \
|
|
1335 if (LOCAL) \
|
|
1336 { \
|
|
1337 fprintf ((FILE), "%s", LOCAL_ASM_OP); \
|
|
1338 assemble_name ((FILE), (NAME)); \
|
|
1339 fprintf ((FILE), "\n"); \
|
|
1340 } \
|
|
1341 fprintf ((FILE), "%s", COMMON_ASM_OP); \
|
|
1342 assemble_name ((FILE), (NAME)); \
|
|
1343 fprintf ((FILE), ",%u,%u\n", (int)(SIZE), align_); \
|
|
1344 } \
|
|
1345 else \
|
|
1346 { \
|
|
1347 /* We can't tell a one-only or weak COMM from a "global \
|
|
1348 COMM" so just make all non-locals weak. */ \
|
|
1349 if (! (LOCAL)) \
|
|
1350 ASM_WEAKEN_LABEL (FILE, NAME); \
|
|
1351 fputs ("\t.lcomm ", (FILE)); \
|
|
1352 assemble_name ((FILE), (NAME)); \
|
|
1353 fprintf ((FILE), ",%u\n", \
|
|
1354 ((int)(SIZE) + (align_ - 1)) & ~(align_ - 1)); \
|
|
1355 } \
|
|
1356 } \
|
|
1357 while (0)
|
|
1358
|
|
1359 #define ASM_OUTPUT_ALIGNED_DECL_COMMON(FILE, DECL, NAME, SIZE, ALIGN) \
|
|
1360 CRIS_ASM_OUTPUT_ALIGNED_DECL_COMMON(FILE, DECL, NAME, SIZE, ALIGN, 0)
|
|
1361
|
|
1362 #undef ASM_OUTPUT_ALIGNED_DECL_LOCAL
|
|
1363 #define ASM_OUTPUT_ALIGNED_DECL_LOCAL(FILE, DECL, NAME, SIZE, ALIGN) \
|
|
1364 CRIS_ASM_OUTPUT_ALIGNED_DECL_COMMON(FILE, DECL, NAME, SIZE, ALIGN, 1)
|
|
1365
|
|
1366 /* Node: Label Output */
|
|
1367
|
|
1368 /* Globalizing directive for a label. */
|
|
1369 #define GLOBAL_ASM_OP "\t.global "
|
|
1370
|
|
1371 #define SUPPORTS_WEAK 1
|
|
1372
|
|
1373 #define ASM_OUTPUT_SYMBOL_REF(STREAM, SYM) \
|
|
1374 cris_asm_output_symbol_ref (STREAM, SYM)
|
|
1375
|
|
1376 #define ASM_OUTPUT_LABEL_REF(STREAM, BUF) \
|
|
1377 cris_asm_output_label_ref (STREAM, BUF)
|
|
1378
|
|
1379 /* Remove any previous definition (elfos.h). */
|
|
1380 #undef ASM_GENERATE_INTERNAL_LABEL
|
|
1381 #define ASM_GENERATE_INTERNAL_LABEL(LABEL, PREFIX, NUM) \
|
|
1382 sprintf (LABEL, "*%s%s%ld", LOCAL_LABEL_PREFIX, PREFIX, (long) NUM)
|
|
1383
|
|
1384 /* Node: Initialization */
|
|
1385 /* (no definitions) */
|
|
1386
|
|
1387 /* Node: Macros for Initialization */
|
|
1388 /* (no definitions) */
|
|
1389
|
|
1390 /* Node: Instruction Output */
|
|
1391
|
|
1392 #define REGISTER_NAMES \
|
|
1393 {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", \
|
|
1394 "r9", "r10", "r11", "r12", "r13", "sp", "acr", "srp", "mof", "faked_ap", "dccr"}
|
|
1395
|
|
1396 #define ADDITIONAL_REGISTER_NAMES \
|
|
1397 {{"r14", 14}, {"r15", 15}, {"pc", 15}}
|
|
1398
|
|
1399 #define PRINT_OPERAND(FILE, X, CODE) \
|
|
1400 cris_print_operand (FILE, X, CODE)
|
|
1401
|
|
1402 /* For delay-slot handling. */
|
|
1403 #define PRINT_OPERAND_PUNCT_VALID_P(CODE) \
|
|
1404 ((CODE) == '#' || (CODE) == '!' || (CODE) == ':')
|
|
1405
|
|
1406 #define PRINT_OPERAND_ADDRESS(FILE, ADDR) \
|
|
1407 cris_print_operand_address (FILE, ADDR)
|
|
1408
|
|
1409 /* Output an empty line to illustrate the presence of the delay slot. */
|
|
1410 #define DBR_OUTPUT_SEQEND(FILE) \
|
|
1411 fprintf (FILE, "\n")
|
|
1412
|
|
1413 #define LOCAL_LABEL_PREFIX (TARGET_ELF ? "." : "")
|
|
1414
|
|
1415 /* cppinit.c initializes a const array from this, so it must be constant,
|
|
1416 can't have it different based on options. Luckily, the prefix is
|
|
1417 always allowed, so let's have it on all GCC-generated code. Note that
|
|
1418 we have this verbatim everywhere in the back-end, not using %R or %s or
|
|
1419 such. */
|
|
1420 #define REGISTER_PREFIX "$"
|
|
1421
|
|
1422 /* Remove any previous definition (elfos.h). */
|
|
1423 /* We use -fno-leading-underscore to remove it, when necessary. */
|
|
1424 #undef USER_LABEL_PREFIX
|
|
1425 #define USER_LABEL_PREFIX "_"
|
|
1426
|
|
1427 #define ASM_OUTPUT_REG_PUSH(FILE, REGNO) \
|
|
1428 fprintf (FILE, \
|
|
1429 TARGET_V32 \
|
|
1430 ? "\tsubq 4,$sp\n\tmove $%s,[$sp]\n" : "\tpush $%s\n", \
|
|
1431 reg_names[REGNO])
|
|
1432
|
|
1433 #define ASM_OUTPUT_REG_POP(FILE, REGNO) \
|
|
1434 fprintf (FILE, "\tmove [$sp+],$%s\n", reg_names[REGNO])
|
|
1435
|
|
1436
|
|
1437 /* Node: Dispatch Tables */
|
|
1438
|
|
1439 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) \
|
|
1440 do \
|
|
1441 { \
|
|
1442 if (TARGET_V32) \
|
|
1443 asm_fprintf (FILE, "\t.word %LL%d-.\n", VALUE); \
|
|
1444 else \
|
|
1445 asm_fprintf (FILE, "\t.word %LL%d-%LL%d\n", VALUE, REL); \
|
|
1446 } \
|
|
1447 while (0)
|
|
1448
|
|
1449 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \
|
|
1450 asm_fprintf (FILE, "\t.dword %LL%d\n", VALUE)
|
|
1451
|
|
1452 /* Defined to also emit an .align in elfos.h. We don't want that. */
|
|
1453 #undef ASM_OUTPUT_CASE_LABEL
|
|
1454
|
|
1455 /* Since the "bound" insn loads the comparison value if the compared<
|
|
1456 value (register) is out of bounds (0..comparison value-1), we need
|
|
1457 to output another case to catch it.
|
|
1458 The way to find it is to look for the label_ref at the else-arm inside
|
|
1459 the expanded casesi core-insn.
|
|
1460 FIXME: Check this construct when changing to new version of gcc. */
|
|
1461 #define ASM_OUTPUT_CASE_END(STREAM, NUM, TABLE) \
|
|
1462 cris_asm_output_case_end (STREAM, NUM, TABLE)
|
|
1463
|
|
1464
|
|
1465 /* Node: Exception Region Output */
|
|
1466 /* (no definitions) */
|
|
1467 /* FIXME: Fill in with our own optimized layout. */
|
|
1468
|
|
1469 /* Node: Alignment Output */
|
|
1470
|
|
1471 #define ASM_OUTPUT_ALIGN(FILE, LOG) \
|
|
1472 fprintf (FILE, "\t.align %d\n", (LOG))
|
|
1473
|
|
1474
|
|
1475 /* Node: All Debuggers */
|
|
1476
|
|
1477 #define DBX_REGISTER_NUMBER(REGNO) \
|
|
1478 ((REGNO) == CRIS_SRP_REGNUM ? CRIS_CANONICAL_SRP_REGNUM : \
|
|
1479 (REGNO) == CRIS_MOF_REGNUM ? CRIS_CANONICAL_MOF_REGNUM : \
|
|
1480 (REGNO) == CRIS_CC0_REGNUM ? CRIS_CANONICAL_CC0_REGNUM : \
|
|
1481 (REGNO))
|
|
1482
|
|
1483 /* FIXME: Investigate DEBUGGER_AUTO_OFFSET, DEBUGGER_ARG_OFFSET. */
|
|
1484
|
|
1485
|
|
1486 /* Node: DBX Options */
|
|
1487
|
|
1488 /* Is this correct? Check later. */
|
|
1489 #define DBX_NO_XREFS
|
|
1490
|
|
1491 #define DBX_CONTIN_LENGTH 0
|
|
1492
|
|
1493 /* FIXME: Is this needed when we have 0 DBX_CONTIN_LENGTH? */
|
|
1494 #define DBX_CONTIN_CHAR '?'
|
|
1495
|
|
1496
|
|
1497 /* Node: DBX Hooks */
|
|
1498 /* (no definitions) */
|
|
1499
|
|
1500 /* Node: File names and DBX */
|
|
1501 /* (no definitions) */
|
|
1502
|
|
1503
|
|
1504 /* Node: SDB and DWARF */
|
|
1505 /* (no definitions) */
|
|
1506
|
|
1507 /* Node: Misc */
|
|
1508
|
|
1509 /* A combination of the bound (umin) insn together with a
|
|
1510 sign-extended add via the table to PC seems optimal.
|
|
1511 If the table overflows, the assembler will take care of it.
|
|
1512 Theoretically, in extreme cases (uncertain if they occur), an error
|
|
1513 will be emitted, so FIXME: Check how large case-tables are emitted,
|
|
1514 possible add an option to emit SImode case-tables. */
|
|
1515 #define CASE_VECTOR_MODE HImode
|
|
1516
|
|
1517 #define CASE_VECTOR_PC_RELATIVE 1
|
|
1518
|
|
1519 /* FIXME: Investigate CASE_VECTOR_SHORTEN_MODE to make sure HImode is not
|
|
1520 used when broken-.word could possibly fail (plus testcase). */
|
|
1521
|
|
1522 #define FIXUNS_TRUNC_LIKE_FIX_TRUNC
|
|
1523
|
|
1524 /* This is the number of bytes that can be moved in one
|
|
1525 reasonably fast instruction sequence. For CRIS, this is two
|
|
1526 instructions: mem => reg, reg => mem. */
|
|
1527 #define MOVE_MAX 4
|
|
1528
|
|
1529 /* Maybe SHIFT_COUNT_TRUNCATED is safe to define? FIXME: Check later. */
|
|
1530
|
|
1531 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
|
|
1532
|
|
1533 #define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = 32, 1)
|
|
1534 #define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = 32, 1)
|
|
1535
|
|
1536 #define Pmode SImode
|
|
1537
|
|
1538 #define FUNCTION_MODE QImode
|
|
1539
|
|
1540 #define NO_IMPLICIT_EXTERN_C
|
|
1541
|
|
1542 /* No specific purpose other than warningless compatibility. */
|
|
1543 #define HANDLE_PRAGMA_PACK_PUSH_POP 1
|
|
1544
|
|
1545 /*
|
|
1546 * Local variables:
|
|
1547 * eval: (c-set-style "gnu")
|
|
1548 * indent-tabs-mode: t
|
|
1549 * End:
|
|
1550 */
|