Mercurial > hg > CbC > CbC_gcc
annotate gcc/config/cris/cris.h @ 55:77e2b8dfacca gcc-4.4.5
update it from 4.4.3 to 4.5.0
| author | ryoma <e075725@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Fri, 12 Feb 2010 23:39:51 +0900 |
| parents | 855418dad1a3 |
| children | f6334be47118 |
| rev | line source |
|---|---|
| 0 | 1 /* Definitions for GCC. Part of the machine description for CRIS. |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
3 2009 Free Software Foundation, Inc. |
| 0 | 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 #define CRIS_PROMOTED_MODE(MODE, UNSIGNEDP, TYPE) \ | |
| 356 (GET_MODE_CLASS (MODE) == MODE_INT && GET_MODE_SIZE (MODE) < 4) \ | |
| 357 ? SImode : MODE | |
| 358 | |
| 359 /* We will be using prototype promotion, so they will be 32 bit. */ | |
| 360 #define PARM_BOUNDARY 32 | |
| 361 | |
| 362 /* Stack boundary is guided by -mstack-align, -mno-stack-align, | |
| 363 -malign. | |
| 364 Old comment: (2.1: still valid in 2.7.2?) | |
| 365 Note that to make this macro affect the alignment of stack | |
| 366 locals, a fix was required, and special precautions when handling | |
| 367 the stack pointer in various other macros (TARGET_ASM_FUNCTION_PROLOGUE | |
| 368 et al) were required. See file "function.c". If you would just define | |
| 369 this macro, it would only affect the builtin alloca and variable | |
| 370 local data (non-ANSI, non-K&R, Gnu C extension). */ | |
| 371 #define STACK_BOUNDARY \ | |
| 372 (TARGET_STACK_ALIGN ? (TARGET_ALIGN_BY_32 ? 32 : 16) : 8) | |
| 373 | |
| 374 #define FUNCTION_BOUNDARY 16 | |
| 375 | |
| 376 /* Do not change BIGGEST_ALIGNMENT (when optimizing), as it will affect | |
| 377 strange places, at least in 2.1. */ | |
| 378 #define BIGGEST_ALIGNMENT 8 | |
| 379 | |
| 380 /* If -m16bit, -m16-bit, -malign or -mdata-align, | |
| 381 align everything to 16 bit. */ | |
| 382 #define DATA_ALIGNMENT(TYPE, BASIC_ALIGN) \ | |
| 383 (TARGET_DATA_ALIGN \ | |
| 384 ? (TARGET_ALIGN_BY_32 \ | |
| 385 ? (BASIC_ALIGN < 32 ? 32 : BASIC_ALIGN) \ | |
| 386 : (BASIC_ALIGN < 16 ? 16 : BASIC_ALIGN)) : BASIC_ALIGN) | |
| 387 | |
| 388 /* Note that CONSTANT_ALIGNMENT has the effect of making gcc believe that | |
| 389 ALL references to constant stuff (in code segment, like strings) has | |
| 390 this alignment. That is a rather rushed assumption. Luckily we do not | |
| 391 care about the "alignment" operand to builtin memcpy (only place where | |
| 392 it counts), so it doesn't affect any bad spots. */ | |
| 393 #define CONSTANT_ALIGNMENT(CONSTANT, BASIC_ALIGN) \ | |
| 394 (TARGET_CONST_ALIGN \ | |
| 395 ? (TARGET_ALIGN_BY_32 \ | |
| 396 ? (BASIC_ALIGN < 32 ? 32 : BASIC_ALIGN) \ | |
| 397 : (BASIC_ALIGN < 16 ? 16 : BASIC_ALIGN)) : BASIC_ALIGN) | |
| 398 | |
| 399 /* FIXME: Define LOCAL_ALIGNMENT for word and dword or arrays and | |
| 400 structures (if -mstack-align=), and check that it is good. */ | |
| 401 | |
| 402 #define EMPTY_FIELD_BOUNDARY 8 | |
| 403 | |
| 404 #define STRUCTURE_SIZE_BOUNDARY 8 | |
| 405 | |
| 406 #define STRICT_ALIGNMENT 0 | |
| 407 | |
| 408 /* Remove any previous definition (elfos.h). | |
| 409 ??? If it wasn't for all the other stuff that affects layout of | |
| 410 structures and bit-fields, this could presumably cause incompatibility | |
| 411 with other GNU/Linux ports (i.e. elfos.h users). */ | |
| 412 #undef PCC_BITFIELD_TYPE_MATTERS | |
| 413 | |
| 414 /* This is only used for non-scalars. Strange stuff happens to structs | |
| 415 (FIXME: What?) if we use anything larger than largest actually used | |
| 416 datum size, so lets make it 32. The type "long long" will still work | |
| 417 as usual. We can still have DImode insns, but they will only be used | |
| 418 for scalar data (i.e. long long). */ | |
| 419 #define MAX_FIXED_MODE_SIZE 32 | |
| 420 | |
| 421 | |
| 422 /* Node: Type Layout */ | |
| 423 | |
| 424 /* Note that DOUBLE_TYPE_SIZE is not defined anymore, since the default | |
| 425 value gives a 64-bit double, which is what we now use. */ | |
| 426 | |
| 427 /* For compatibility and historical reasons, a char should be signed. */ | |
| 428 #define DEFAULT_SIGNED_CHAR 1 | |
| 429 | |
| 430 /* Note that WCHAR_TYPE_SIZE is used in cexp.y, | |
| 431 where TARGET_SHORT is not available. */ | |
| 432 #undef WCHAR_TYPE | |
| 433 #define WCHAR_TYPE "long int" | |
| 434 | |
| 435 #undef WCHAR_TYPE_SIZE | |
| 436 #define WCHAR_TYPE_SIZE 32 | |
| 437 | |
| 438 | |
| 439 /* Node: Register Basics */ | |
| 440 | |
| 441 /* We count all 16 non-special registers, SRP, a faked argument | |
| 442 pointer register, MOF and CCR/DCCR. */ | |
| 443 #define FIRST_PSEUDO_REGISTER (16 + 1 + 1 + 1 + 1) | |
| 444 | |
| 445 /* For CRIS, these are r15 (pc) and r14 (sp). Register r8 is used as a | |
| 446 frame-pointer, but is not fixed. SRP is not included in general | |
| 447 registers and will not be used automatically. All other special | |
| 448 registers are fixed at the moment. The faked argument pointer register | |
| 449 is fixed too. */ | |
| 450 #define FIXED_REGISTERS \ | |
| 451 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0} | |
| 452 | |
| 453 /* Register r9 is used for structure-address, r10-r13 for parameters, | |
| 454 r10- for return values. */ | |
| 455 #define CALL_USED_REGISTERS \ | |
| 456 {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1} | |
| 457 | |
| 458 #define CONDITIONAL_REGISTER_USAGE cris_conditional_register_usage () | |
| 459 | |
| 460 | |
| 461 /* Node: Allocation Order */ | |
| 462 | |
| 463 /* We need this on CRIS, because call-used regs should be used first, | |
| 464 (so we don't need to push). Else start using registers from r0 and up. | |
| 465 This preference is mainly because if we put call-used-regs from r0 | |
| 466 and up, then we can't use movem to push the rest, (which have to be | |
| 467 saved if we use them, and movem has to start with r0). | |
| 468 Change here if you change which registers to use as call registers. | |
| 469 | |
| 470 The actual need to explicitly prefer call-used registers improved the | |
| 471 situation a lot for 2.1, but might not actually be needed anymore. | |
| 472 Still, this order reflects what GCC should find out by itself, so it | |
| 473 probably does not hurt. | |
| 474 | |
| 475 Order of preference: Call-used-regs first, then r0 and up, last fp & | |
| 476 sp & pc as fillers. | |
| 477 Call-used regs in opposite order, so they will cause less conflict if | |
| 478 a function has few args (<= 3) and it wants a scratch reg. | |
| 479 Use struct-return address first, since very few functions use | |
| 480 structure return values so it is likely to be available. */ | |
| 481 #define REG_ALLOC_ORDER \ | |
| 482 {9, 13, 12, 11, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 14, 15, 17, 16, 18, 19} | |
| 483 | |
| 484 /* Use MOF and ACR. Prefer ACR before any other register. Prefer MOF | |
| 485 then SRP after saved registers. The *after* is because they're only | |
| 486 useful for storage, not for things being computed, which is | |
| 487 apparently more common. */ | |
| 488 #define REG_ALLOC_ORDER_V32 \ | |
| 489 {15, 9, 13, 12, 11, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 17, 16, 14, 18, 19} | |
| 490 | |
| 491 | |
| 492 /* Node: Values in Registers */ | |
| 493 | |
| 494 /* The VOIDmode test is so we can omit mode on anonymous insns. FIXME: | |
| 495 Still needed in 2.9x, at least for Axis-20000319. */ | |
| 496 #define HARD_REGNO_NREGS(REGNO, MODE) \ | |
| 497 (MODE == VOIDmode \ | |
| 498 ? 1 : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)) | |
| 499 | |
| 500 /* CRIS permits all registers to hold all modes. Well, except for the | |
| 501 condition-code register. And we can't hold larger-than-register size | |
| 502 modes in the last special register that can hold a full 32 bits. */ | |
| 503 #define HARD_REGNO_MODE_OK(REGNO, MODE) \ | |
| 504 (((MODE) == CCmode \ | |
| 505 || (REGNO) != CRIS_CC0_REGNUM) \ | |
| 506 && (GET_MODE_SIZE (MODE) <= UNITS_PER_WORD \ | |
| 507 || ((REGNO) != CRIS_MOF_REGNUM && (REGNO) != CRIS_ACR_REGNUM))) | |
| 508 | |
| 509 /* Because CCmode isn't covered by the "narrower mode" statement in | |
| 510 tm.texi, we can still say all modes are tieable despite not having an | |
| 511 always 1 HARD_REGNO_MODE_OK. */ | |
| 512 #define MODES_TIEABLE_P(MODE1, MODE2) 1 | |
| 513 | |
| 514 | |
| 515 /* Node: Leaf Functions */ | |
| 516 /* (no definitions) */ | |
| 517 | |
| 518 /* Node: Stack Registers */ | |
| 519 /* (no definitions) */ | |
| 520 | |
| 521 | |
| 522 /* Node: Register Classes */ | |
| 523 | |
| 524 /* FIXME: A separate class for the return register would make sense. | |
| 525 | |
| 526 We need a separate register class to handle register allocation for | |
| 527 ACR, since it can't be used for post-increment. | |
| 528 | |
| 529 It's not obvious, but having subunions of all movable-between | |
| 530 register classes does really help register allocation. */ | |
| 531 enum reg_class | |
| 532 { | |
| 533 NO_REGS, | |
| 534 ACR_REGS, MOF_REGS, CC0_REGS, SPECIAL_REGS, | |
| 535 SPEC_ACR_REGS, GENNONACR_REGS, | |
| 536 SPEC_GENNONACR_REGS, GENERAL_REGS, | |
| 537 ALL_REGS, | |
| 538 LIM_REG_CLASSES | |
| 539 }; | |
| 540 | |
| 541 #define N_REG_CLASSES (int) LIM_REG_CLASSES | |
| 542 | |
| 543 #define REG_CLASS_NAMES \ | |
| 544 {"NO_REGS", \ | |
| 545 "ACR_REGS", "MOF_REGS", "CC0_REGS", "SPECIAL_REGS", \ | |
| 546 "SPEC_ACR_REGS", "GENNONACR_REGS", "SPEC_GENNONACR_REGS", \ | |
| 547 "GENERAL_REGS", "ALL_REGS"} | |
| 548 | |
| 549 #define CRIS_SPECIAL_REGS_CONTENTS \ | |
| 550 ((1 << CRIS_SRP_REGNUM) | (1 << CRIS_MOF_REGNUM) | (1 << CRIS_CC0_REGNUM)) | |
| 551 | |
| 552 /* Count in the faked argument register in GENERAL_REGS. Keep out SRP. */ | |
| 553 #define REG_CLASS_CONTENTS \ | |
| 554 { \ | |
| 555 {0}, \ | |
| 556 {1 << CRIS_ACR_REGNUM}, \ | |
| 557 {1 << CRIS_MOF_REGNUM}, \ | |
| 558 {1 << CRIS_CC0_REGNUM}, \ | |
| 559 {CRIS_SPECIAL_REGS_CONTENTS}, \ | |
| 560 {CRIS_SPECIAL_REGS_CONTENTS \ | |
| 561 | (1 << CRIS_ACR_REGNUM)}, \ | |
| 562 {(0xffff | (1 << CRIS_AP_REGNUM)) \ | |
| 563 & ~(1 << CRIS_ACR_REGNUM)}, \ | |
| 564 {(0xffff | (1 << CRIS_AP_REGNUM) \ | |
| 565 | CRIS_SPECIAL_REGS_CONTENTS) \ | |
| 566 & ~(1 << CRIS_ACR_REGNUM)}, \ | |
| 567 {0xffff | (1 << CRIS_AP_REGNUM)}, \ | |
| 568 {0xffff | (1 << CRIS_AP_REGNUM) \ | |
| 569 | CRIS_SPECIAL_REGS_CONTENTS} \ | |
| 570 } | |
| 571 | |
| 572 #define REGNO_REG_CLASS(REGNO) \ | |
| 573 ((REGNO) == CRIS_ACR_REGNUM ? ACR_REGS : \ | |
| 574 (REGNO) == CRIS_MOF_REGNUM ? MOF_REGS : \ | |
| 575 (REGNO) == CRIS_CC0_REGNUM ? CC0_REGS : \ | |
| 576 (REGNO) == CRIS_SRP_REGNUM ? SPECIAL_REGS : \ | |
| 577 GENERAL_REGS) | |
| 578 | |
| 579 #define BASE_REG_CLASS GENERAL_REGS | |
| 580 | |
| 581 #define MODE_CODE_BASE_REG_CLASS(MODE, OCODE, ICODE) \ | |
| 582 ((OCODE) != POST_INC ? BASE_REG_CLASS : GENNONACR_REGS) | |
| 583 | |
| 584 #define INDEX_REG_CLASS GENERAL_REGS | |
| 585 | |
| 586 #define IRA_COVER_CLASSES { GENERAL_REGS, SPECIAL_REGS, LIM_REG_CLASSES } | |
| 587 | |
| 588 #define REG_CLASS_FROM_LETTER(C) \ | |
| 589 ( \ | |
| 590 (C) == 'a' ? ACR_REGS : \ | |
| 591 (C) == 'b' ? GENNONACR_REGS : \ | |
| 592 (C) == 'h' ? MOF_REGS : \ | |
| 593 (C) == 'x' ? SPECIAL_REGS : \ | |
| 594 (C) == 'c' ? CC0_REGS : \ | |
| 595 NO_REGS \ | |
| 596 ) | |
| 597 | |
| 598 /* Since it uses reg_renumber, it is safe only once reg_renumber | |
| 599 has been allocated, which happens in local-alloc.c. */ | |
| 600 #define REGNO_OK_FOR_BASE_P(REGNO) \ | |
| 601 ((REGNO) <= CRIS_LAST_GENERAL_REGISTER \ | |
| 602 || (REGNO) == ARG_POINTER_REGNUM \ | |
| 603 || (unsigned) reg_renumber[REGNO] <= CRIS_LAST_GENERAL_REGISTER \ | |
| 604 || (unsigned) reg_renumber[REGNO] == ARG_POINTER_REGNUM) | |
| 605 | |
| 606 /* REGNO_OK_FOR_BASE_P seems to be obsolete wrt. this one, but not yet | |
| 607 documented as such. */ | |
| 608 #define REGNO_MODE_CODE_OK_FOR_BASE_P(REGNO, MODE, OCODE, ICODE) \ | |
| 609 (REGNO_OK_FOR_BASE_P (REGNO) \ | |
| 610 && ((OCODE) != POST_INC \ | |
| 611 || !((REGNO) == CRIS_ACR_REGNUM \ | |
| 612 || (unsigned) reg_renumber[REGNO] == CRIS_ACR_REGNUM))) | |
| 613 | |
| 614 /* See REGNO_OK_FOR_BASE_P. */ | |
| 615 #define REGNO_OK_FOR_INDEX_P(REGNO) REGNO_OK_FOR_BASE_P(REGNO) | |
| 616 | |
| 617 /* It seems like gcc (2.7.2 and 2.9x of 2000-03-22) may send "NO_REGS" as | |
| 618 the class for a constant (testcase: __Mul in arit.c). To avoid forcing | |
| 619 out a constant into the constant pool, we will trap this case and | |
| 620 return something a bit more sane. FIXME: Check if this is a bug. | |
| 621 Beware that we must not "override" classes that can be specified as | |
| 622 constraint letters, or else asm operands using them will fail when | |
| 623 they need to be reloaded. FIXME: Investigate whether that constitutes | |
| 624 a bug. */ | |
| 625 #define PREFERRED_RELOAD_CLASS(X, CLASS) \ | |
| 626 ((CLASS) != ACR_REGS \ | |
| 627 && (CLASS) != MOF_REGS \ | |
| 628 && (CLASS) != CC0_REGS \ | |
| 629 && (CLASS) != SPECIAL_REGS \ | |
| 630 ? GENERAL_REGS : (CLASS)) | |
| 631 | |
| 632 /* We can't move special registers to and from memory in smaller than | |
| 36 | 633 word_mode. We also can't move between special registers. Luckily, |
| 634 -1, as returned by true_regnum for non-sub/registers, is valid as a | |
| 635 parameter to our REGNO_REG_CLASS, returning GENERAL_REGS, so we get | |
| 636 the effect that any X that isn't a special-register is treated as | |
| 637 a non-empty intersection with GENERAL_REGS. */ | |
| 638 #define SECONDARY_RELOAD_CLASS(CLASS, MODE, X) \ | |
| 639 ((((CLASS) == SPECIAL_REGS || (CLASS) == MOF_REGS) \ | |
| 640 && ((GET_MODE_SIZE (MODE) < 4 && MEM_P (X)) \ | |
| 641 || !reg_classes_intersect_p (REGNO_REG_CLASS (true_regnum (X)), \ | |
| 642 GENERAL_REGS))) \ | |
| 643 ? GENERAL_REGS : NO_REGS) | |
| 0 | 644 |
| 645 /* FIXME: Fix regrename.c; it should check validity of replacements, | |
| 646 not just with a silly pass-specific macro. We may miss some | |
| 647 opportunities, but we must stop regrename from creating acr++. */ | |
| 648 #define HARD_REGNO_RENAME_OK(FROM, TO) ((TO) != CRIS_ACR_REGNUM) | |
| 649 | |
| 650 /* For CRIS, this is always the size of MODE in words, | |
| 651 since all registers are the same size. To use omitted modes in | |
| 652 patterns with reload constraints, you must say the widest size | |
| 653 which is allowed for VOIDmode. | |
| 654 FIXME: Does that still apply for gcc-2.9x? Keep poisoned until such | |
| 655 patterns are added back. News: 2001-03-16: Happens as early as the | |
| 656 underscore-test. */ | |
| 657 #define CLASS_MAX_NREGS(CLASS, MODE) \ | |
| 658 ((MODE) == VOIDmode \ | |
| 659 ? 1 /* + cris_fatal ("CLASS_MAX_NREGS with VOIDmode") */ \ | |
| 660 : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)) | |
| 661 | |
| 662 /* We are now out of letters; we could use ten more. This forces us to | |
| 663 use C-code in the 'md' file. FIXME: Use some EXTRA_CONSTRAINTS. */ | |
| 664 #define CRIS_CONST_OK_FOR_LETTER_P(VALUE, C) \ | |
| 665 ( \ | |
| 666 /* MOVEQ, CMPQ, ANDQ, ORQ. */ \ | |
| 667 (C) == 'I' ? (VALUE) >= -32 && (VALUE) <= 31 : \ | |
| 668 /* ADDQ, SUBQ. */ \ | |
| 669 (C) == 'J' ? (VALUE) >= 0 && (VALUE) <= 63 : \ | |
| 670 /* ASRQ, BTSTQ, LSRQ, LSLQ. */ \ | |
| 671 (C) == 'K' ? (VALUE) >= 0 && (VALUE) <= 31 : \ | |
| 672 /* A 16-bit signed number. */ \ | |
| 673 (C) == 'L' ? (VALUE) >= -32768 && (VALUE) <= 32767 : \ | |
| 674 /* The constant 0 for CLEAR. */ \ | |
| 675 (C) == 'M' ? (VALUE) == 0 : \ | |
| 676 /* A negative ADDQ or SUBQ. */ \ | |
| 677 (C) == 'N' ? (VALUE) >= -63 && (VALUE) < 0 : \ | |
| 678 /* Quickened ints, QI and HI. */ \ | |
| 679 (C) == 'O' ? (VALUE) >= 0 && (VALUE) <= 65535 \ | |
| 680 && ((VALUE) >= (65535-31) \ | |
| 681 || ((VALUE) >= (255-31) \ | |
| 682 && (VALUE) <= 255 )) : \ | |
| 683 /* A 16-bit number signed *or* unsigned. */ \ | |
| 684 (C) == 'P' ? (VALUE) >= -32768 && (VALUE) <= 65535 : \ | |
| 685 0) | |
| 686 | |
| 687 #define CONST_OK_FOR_CONSTRAINT_P(VALUE, C, S) \ | |
| 688 ( \ | |
| 689 ((C) != 'K' || (S)[1] == 'c') \ | |
| 690 ? CRIS_CONST_OK_FOR_LETTER_P (VALUE, C) : \ | |
| 691 ((C) == 'K' && (S)[1] == 'p') \ | |
| 692 ? exact_log2 (VALUE) >= 0 : \ | |
| 693 0) | |
| 694 | |
| 695 #define CONSTRAINT_LEN(C, S) ((C) == 'K' ? 2 : DEFAULT_CONSTRAINT_LEN (C, S)) | |
| 696 | |
| 697 /* It is really simple to make up a 0.0; it is the same as int-0 in | |
| 698 IEEE754. */ | |
| 699 #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) \ | |
| 700 ((C) == 'G' && ((VALUE) == CONST0_RTX (DFmode) \ | |
| 701 || (VALUE) == CONST0_RTX (SFmode))) | |
| 702 | |
| 703 /* We need this on cris to distinguish delay-slottable addressing modes. */ | |
| 704 #define EXTRA_CONSTRAINT(X, C) \ | |
| 705 ( \ | |
| 706 /* Slottable address mode? */ \ | |
| 707 (C) == 'Q' ? EXTRA_CONSTRAINT_Q (X) : \ | |
| 708 /* Operand to BDAP or BIAP? */ \ | |
| 709 (C) == 'R' ? EXTRA_CONSTRAINT_R (X) : \ | |
| 710 /* A local PIC symbol? */ \ | |
| 711 (C) == 'S' ? EXTRA_CONSTRAINT_S (X) : \ | |
| 712 /* A three-address addressing-mode? */ \ | |
| 713 (C) == 'T' ? EXTRA_CONSTRAINT_T (X) : \ | |
| 714 /* A PLT symbol? */ \ | |
| 715 (C) == 'U' ? EXTRA_CONSTRAINT_U (X) : \ | |
| 716 0) | |
| 717 | |
| 718 #define EXTRA_MEMORY_CONSTRAINT(X, STR) ((X) == 'Q') | |
| 719 | |
| 720 #define EXTRA_CONSTRAINT_Q(X) \ | |
| 721 ( \ | |
| 722 /* Just an indirect register (happens to also be \ | |
| 723 "all" slottable memory addressing modes not \ | |
| 724 covered by other constraints, i.e. '>'). */ \ | |
| 725 MEM_P (X) && BASE_P (XEXP (X, 0)) \ | |
| 726 ) | |
| 727 | |
| 728 #define EXTRA_CONSTRAINT_R(X) \ | |
| 729 ( \ | |
| 730 /* An operand to BDAP or BIAP: \ | |
| 731 A BIAP; r.S? */ \ | |
| 732 BIAP_INDEX_P (X) \ | |
| 733 /* A [reg] or (int) [reg], maybe with post-increment. */ \ | |
| 734 || BDAP_INDEX_P (X) \ | |
| 735 || CONSTANT_INDEX_P (X) \ | |
| 736 ) | |
| 737 | |
| 738 #define EXTRA_CONSTRAINT_T(X) \ | |
| 739 ( \ | |
| 740 /* Memory three-address operand. All are indirect-memory: */ \ | |
| 741 MEM_P (X) \ | |
| 742 && ((MEM_P (XEXP (X, 0)) \ | |
| 743 /* Double indirect: [[reg]] or [[reg+]]? */ \ | |
| 744 && (BASE_OR_AUTOINCR_P (XEXP (XEXP (X, 0), 0)))) \ | |
| 745 /* Just an explicit indirect reference: [const]? */ \ | |
| 746 || CONSTANT_P (XEXP (X, 0)) \ | |
| 747 /* Something that is indexed; [...+...]? */ \ | |
| 748 || (GET_CODE (XEXP (X, 0)) == PLUS \ | |
| 749 /* A BDAP constant: [reg+(8|16|32)bit offset]? */ \ | |
| 750 && ((BASE_P (XEXP (XEXP (X, 0), 0)) \ | |
| 751 && CONSTANT_INDEX_P (XEXP (XEXP (X, 0), 1))) \ | |
| 752 /* A BDAP register: [reg+[reg(+)].S]? */ \ | |
| 753 || (BASE_P (XEXP (XEXP (X, 0), 0)) \ | |
| 754 && BDAP_INDEX_P(XEXP(XEXP(X, 0), 1))) \ | |
| 755 /* Same, but with swapped arguments (no canonical \ | |
| 756 ordering between e.g. REG and MEM as of LAST_UPDATED \ | |
| 757 "Thu May 12 03:59:11 UTC 2005"). */ \ | |
| 758 || (BASE_P (XEXP (XEXP (X, 0), 1)) \ | |
| 759 && BDAP_INDEX_P (XEXP (XEXP (X, 0), 0))) \ | |
| 760 /* A BIAP: [reg+reg.S] (MULT comes first). */ \ | |
| 761 || (BASE_P (XEXP (XEXP (X, 0), 1)) \ | |
| 762 && BIAP_INDEX_P (XEXP (XEXP (X, 0), 0)))))) \ | |
| 763 ) | |
| 764 | |
| 765 /* PIC-constructs for symbols. */ | |
| 766 #define EXTRA_CONSTRAINT_S(X) \ | |
| 767 (flag_pic && GET_CODE (X) == CONST && cris_valid_pic_const (X, false)) | |
| 768 | |
| 769 #define EXTRA_CONSTRAINT_U(X) \ | |
| 770 (flag_pic \ | |
| 771 && CONSTANT_P (X) \ | |
| 772 && cris_nonmemory_operand_or_callable_symbol (X, VOIDmode)) | |
| 773 | |
| 774 | |
| 775 /* Node: Frame Layout */ | |
| 776 | |
| 777 #define STACK_GROWS_DOWNWARD | |
| 778 #define FRAME_GROWS_DOWNWARD 1 | |
| 779 | |
| 780 /* It seems to be indicated in the code (at least 2.1) that this is | |
| 781 better a constant, and best 0. */ | |
| 782 #define STARTING_FRAME_OFFSET 0 | |
| 783 | |
| 784 #define FIRST_PARM_OFFSET(FNDECL) 0 | |
| 785 | |
| 786 #define RETURN_ADDR_RTX(COUNT, FRAMEADDR) \ | |
| 787 cris_return_addr_rtx (COUNT, FRAMEADDR) | |
| 788 | |
| 789 #define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (Pmode, CRIS_SRP_REGNUM) | |
| 790 | |
| 791 /* FIXME: Any __builtin_eh_return callers must not return anything and | |
| 792 there must not be collisions with incoming parameters. Luckily the | |
| 793 number of __builtin_eh_return callers is limited. For now return | |
| 794 parameter registers in reverse order and hope for the best. */ | |
| 795 #define EH_RETURN_DATA_REGNO(N) \ | |
| 796 (IN_RANGE ((N), 0, 3) ? (CRIS_FIRST_ARG_REG + 3 - (N)) : INVALID_REGNUM) | |
| 797 | |
| 798 /* Store the stack adjustment in the structure-return-address register. */ | |
| 799 #define CRIS_STACKADJ_REG CRIS_STRUCT_VALUE_REGNUM | |
| 800 #define EH_RETURN_STACKADJ_RTX gen_rtx_REG (SImode, CRIS_STACKADJ_REG) | |
| 801 | |
| 802 #define EH_RETURN_HANDLER_RTX \ | |
| 803 cris_return_addr_rtx (0, NULL) | |
| 804 | |
| 805 #define INIT_EXPANDERS cris_init_expanders () | |
| 806 | |
| 807 /* FIXME: Move this to right node (it's not documented properly yet). */ | |
| 808 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (CRIS_SRP_REGNUM) | |
| 809 | |
| 810 /* FIXME: Move this to right node (it's not documented properly yet). | |
| 811 FIXME: Check what alignment we can assume regarding | |
| 812 TARGET_STACK_ALIGN and TARGET_ALIGN_BY_32. */ | |
| 813 #define DWARF_CIE_DATA_ALIGNMENT -1 | |
| 814 | |
| 815 /* If we would ever need an exact mapping between canonical register | |
| 816 number and dwarf frame register, we would either need to include all | |
| 817 registers in the gcc description (with some marked fixed of course), or | |
| 818 an inverse mapping from dwarf register to gcc register. There is one | |
| 819 need in dwarf2out.c:expand_builtin_init_dwarf_reg_sizes. Right now, I | |
| 820 don't see that we need exact correspondence between DWARF *frame* | |
| 821 registers and DBX_REGISTER_NUMBER, so map them onto GCC registers. */ | |
| 822 #define DWARF_FRAME_REGNUM(REG) (REG) | |
| 823 | |
| 824 /* Node: Stack Checking */ | |
| 825 /* (no definitions) FIXME: Check. */ | |
| 826 | |
| 827 /* Node: Frame Registers */ | |
| 828 | |
| 829 #define STACK_POINTER_REGNUM CRIS_SP_REGNUM | |
| 830 | |
| 831 /* Register used for frame pointer. This is also the last of the saved | |
| 832 registers, when a frame pointer is not used. */ | |
| 833 #define FRAME_POINTER_REGNUM CRIS_FP_REGNUM | |
| 834 | |
| 835 /* Faked register, is always eliminated. We need it to eliminate | |
| 836 allocating stack slots for the return address and the frame pointer. */ | |
| 837 #define ARG_POINTER_REGNUM CRIS_AP_REGNUM | |
| 838 | |
| 839 #define STATIC_CHAIN_REGNUM CRIS_STATIC_CHAIN_REGNUM | |
| 840 | |
| 841 | |
| 842 /* Node: Elimination */ | |
| 843 | |
| 844 #define ELIMINABLE_REGS \ | |
| 845 {{ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \ | |
| 846 {ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM}, \ | |
| 847 {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}} | |
| 848 | |
| 849 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \ | |
| 850 (OFFSET) = cris_initial_elimination_offset (FROM, TO) | |
| 851 | |
| 852 | |
| 853 /* Node: Stack Arguments */ | |
| 854 | |
| 855 /* Since many parameters take up one register each in any case, | |
| 856 defining TARGET_PROMOTE_PROTOTYPES that always returns true would | |
| 857 seem like a good idea, but measurements indicate that a combination | |
| 858 using PROMOTE_MODE is better. */ | |
| 859 | |
| 860 #define ACCUMULATE_OUTGOING_ARGS 1 | |
| 861 | |
| 862 #define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACKSIZE) 0 | |
| 863 | |
| 864 | |
| 865 /* Node: Register Arguments */ | |
| 866 | |
| 867 /* The void_type_node is sent as a "closing" call. */ | |
| 868 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \ | |
| 869 ((CUM).regs < CRIS_MAX_ARGS_IN_REGS \ | |
| 870 ? gen_rtx_REG (MODE, (CRIS_FIRST_ARG_REG) + (CUM).regs) \ | |
| 871 : NULL_RTX) | |
| 872 | |
| 873 /* The differences between this and the previous, is that this one checks | |
| 874 that an argument is named, since incoming stdarg/varargs arguments are | |
| 875 pushed onto the stack, and we don't have to check against the "closing" | |
| 876 void_type_node TYPE parameter. */ | |
| 877 #define FUNCTION_INCOMING_ARG(CUM, MODE, TYPE, NAMED) \ | |
| 878 ((NAMED) && (CUM).regs < CRIS_MAX_ARGS_IN_REGS \ | |
| 879 ? gen_rtx_REG (MODE, CRIS_FIRST_ARG_REG + (CUM).regs) \ | |
| 880 : NULL_RTX) | |
| 881 | |
| 882 /* Contrary to what you'd believe, defining FUNCTION_ARG_CALLEE_COPIES | |
| 883 seems like a (small total) loss, at least for gcc-2.7.2 compiling and | |
| 884 running gcc-2.1 (small win in size, small loss running -- 100.1%), | |
| 885 and similarly for size for products (.1 .. .3% bloat, sometimes win). | |
| 886 Due to the empirical likeliness of making slower code, it is not | |
| 887 defined. */ | |
| 888 | |
| 889 /* This no longer *needs* to be a structure; but keeping it as such should | |
| 890 not hurt (and hacking the ABI is simpler). */ | |
| 891 #define CUMULATIVE_ARGS struct cum_args | |
| 892 struct cum_args {int regs;}; | |
| 893 | |
| 894 /* The regs member is an integer, the number of arguments got into | |
| 895 registers so far. */ | |
| 896 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, FNDECL, N_NAMED_ARGS) \ | |
| 897 ((CUM).regs = 0) | |
| 898 | |
| 899 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \ | |
| 900 ((CUM).regs += (3 + CRIS_FUNCTION_ARG_SIZE (MODE, TYPE)) / 4) | |
| 901 | |
| 902 #define FUNCTION_ARG_REGNO_P(REGNO) \ | |
| 903 ((REGNO) >= CRIS_FIRST_ARG_REG \ | |
| 904 && (REGNO) < CRIS_FIRST_ARG_REG + (CRIS_MAX_ARGS_IN_REGS)) | |
| 905 | |
| 906 | |
| 907 /* Node: Scalar Return */ | |
| 908 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
909 #define FUNCTION_VALUE_REGNO_P(N) cris_function_value_regno_p (N) |
| 0 | 910 |
| 911 | |
| 912 | |
| 913 /* Node: Aggregate Return */ | |
| 914 | |
| 915 #define CRIS_STRUCT_VALUE_REGNUM ((CRIS_FIRST_ARG_REG) - 1) | |
| 916 | |
| 917 | |
| 918 /* Node: Caller Saves */ | |
| 919 /* (no definitions) */ | |
| 920 | |
| 921 /* Node: Function entry */ | |
| 922 | |
| 923 /* See cris.c for TARGET_ASM_FUNCTION_PROLOGUE and | |
| 924 TARGET_ASM_FUNCTION_EPILOGUE. */ | |
| 925 | |
| 926 /* Node: Profiling */ | |
| 927 | |
| 928 #define FUNCTION_PROFILER(FILE, LABELNO) \ | |
| 929 error ("no FUNCTION_PROFILER for CRIS") | |
| 930 | |
| 931 /* FIXME: Some of the undefined macros might be mandatory. If so, fix | |
| 932 documentation. */ | |
| 933 | |
| 934 | |
| 935 /* Node: Trampolines */ | |
| 936 | |
| 937 #define TRAMPOLINE_SIZE (TARGET_V32 ? 58 : 32) | |
| 938 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
939 /* CRIS wants instructions on word-boundary. */ |
| 0 | 940 #define TRAMPOLINE_ALIGNMENT 16 |
| 941 | |
| 942 /* Node: Library Calls */ | |
| 943 | |
| 944 /* If you change this, you have to check whatever libraries and systems | |
| 945 that use it. */ | |
| 946 #define TARGET_EDOM 33 | |
| 947 | |
| 948 | |
| 949 /* Node: Addressing Modes */ | |
| 950 | |
| 951 #define HAVE_POST_INCREMENT 1 | |
| 952 | |
| 953 /* Must be a compile-time constant, so we go with the highest value | |
| 954 among all CRIS variants. */ | |
| 955 #define MAX_REGS_PER_ADDRESS 2 | |
| 956 | |
| 957 /* There are helper macros defined here which are used only in | |
| 958 GO_IF_LEGITIMATE_ADDRESS. | |
| 959 | |
| 960 Note that you *have to* reject invalid addressing modes for mode | |
| 961 MODE, even if it is legal for normal addressing modes. You cannot | |
| 962 rely on the constraints to do this work. They can only be used to | |
| 963 doublecheck your intentions. One example is that you HAVE TO reject | |
| 964 (mem:DI (plus:SI (reg:SI x) (reg:SI y))) because for some reason | |
| 965 this cannot be reloaded. (Which of course you can argue that gcc | |
| 966 should have done.) FIXME: Strange. Check. */ | |
| 967 | |
| 968 /* No symbol can be used as an index (or more correct, as a base) together | |
| 969 with a register with PIC; the PIC register must be there. */ | |
| 970 #define CONSTANT_INDEX_P(X) \ | |
| 971 (CONSTANT_P (X) && (!flag_pic || cris_valid_pic_const (X, true))) | |
| 972 | |
| 973 /* True if X is a valid base register. */ | |
| 974 #define BASE_P(X) \ | |
| 975 (REG_P (X) && REG_OK_FOR_BASE_P (X)) | |
| 976 | |
| 977 /* True if X is a valid base register with or without autoincrement. */ | |
| 978 #define BASE_OR_AUTOINCR_P(X) \ | |
| 979 (BASE_P (X) \ | |
| 980 || (GET_CODE (X) == POST_INC \ | |
| 981 && BASE_P (XEXP (X, 0)) \ | |
| 982 && REGNO (XEXP (X, 0)) != CRIS_ACR_REGNUM)) | |
| 983 | |
| 984 /* True if X is a valid (register) index for BDAP, i.e. [Rs].S or [Rs+].S. */ | |
| 985 #define BDAP_INDEX_P(X) \ | |
| 986 ((MEM_P (X) && GET_MODE (X) == SImode \ | |
| 987 && BASE_OR_AUTOINCR_P (XEXP (X, 0))) \ | |
| 988 || (GET_CODE (X) == SIGN_EXTEND \ | |
| 989 && MEM_P (XEXP (X, 0)) \ | |
| 990 && (GET_MODE (XEXP (X, 0)) == HImode \ | |
| 991 || GET_MODE (XEXP (X, 0)) == QImode) \ | |
| 992 && BASE_OR_AUTOINCR_P (XEXP (XEXP (X, 0), 0)))) | |
| 993 | |
| 994 /* True if X is a valid (register) index for BIAP, i.e. Rd.m. */ | |
| 995 #define BIAP_INDEX_P(X) \ | |
| 996 ((BASE_P (X) && REG_OK_FOR_INDEX_P (X)) \ | |
| 997 || (GET_CODE (X) == MULT \ | |
| 998 && BASE_P (XEXP (X, 0)) \ | |
| 999 && REG_OK_FOR_INDEX_P (XEXP (X, 0)) \ | |
| 1000 && CONST_INT_P (XEXP (X, 1)) \ | |
| 1001 && (INTVAL (XEXP (X, 1)) == 2 \ | |
| 1002 || INTVAL (XEXP (X, 1)) == 4))) | |
| 1003 | |
| 1004 /* A PIC operand looks like a normal symbol here. At output we dress it | |
| 1005 in "[rPIC+symbol:GOT]" (global symbol) or "rPIC+symbol:GOTOFF" (local | |
| 1006 symbol) so we exclude all addressing modes where we can't replace a | |
| 1007 plain "symbol" with that. A global PIC symbol does not fit anywhere | |
| 1008 here (but is thankfully a general_operand in itself). A local PIC | |
| 1009 symbol is valid for the plain "symbol + offset" case. */ | |
| 1010 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \ | |
| 1011 { \ | |
| 1012 rtx x1, x2; \ | |
| 1013 if (BASE_OR_AUTOINCR_P (X)) \ | |
| 1014 goto ADDR; \ | |
| 1015 else if (TARGET_V32) \ | |
| 1016 /* Nothing else is valid then. */ \ | |
| 1017 ; \ | |
| 1018 else if (CONSTANT_INDEX_P (X)) \ | |
| 1019 goto ADDR; \ | |
| 1020 /* Indexed? */ \ | |
| 1021 else if (GET_CODE (X) == PLUS) \ | |
| 1022 { \ | |
| 1023 x1 = XEXP (X, 0); \ | |
| 1024 x2 = XEXP (X, 1); \ | |
| 1025 /* BDAP o, Rd. */ \ | |
| 1026 if ((BASE_P (x1) && CONSTANT_INDEX_P (x2)) \ | |
| 1027 || (BASE_P (x2) && CONSTANT_INDEX_P (x1)) \ | |
| 1028 /* BDAP Rs[+], Rd. */ \ | |
| 1029 || (GET_MODE_SIZE (MODE) <= UNITS_PER_WORD \ | |
| 1030 && ((BASE_P (x1) && BDAP_INDEX_P (x2)) \ | |
| 1031 || (BASE_P (x2) && BDAP_INDEX_P (x1)) \ | |
| 1032 /* BIAP.m Rs, Rd */ \ | |
| 1033 || (BASE_P (x1) && BIAP_INDEX_P (x2)) \ | |
| 1034 || (BASE_P (x2) && BIAP_INDEX_P (x1))))) \ | |
| 1035 goto ADDR; \ | |
| 1036 } \ | |
| 1037 else if (MEM_P (X)) \ | |
| 1038 { \ | |
| 1039 /* DIP (Rs). Reject [[reg+]] and [[reg]] for \ | |
| 1040 DImode (long long). */ \ | |
| 1041 if (GET_MODE_SIZE (MODE) <= UNITS_PER_WORD \ | |
| 1042 && (BASE_P (XEXP (X, 0)) \ | |
| 1043 || BASE_OR_AUTOINCR_P (XEXP (X, 0)))) \ | |
| 1044 goto ADDR; \ | |
| 1045 } \ | |
| 1046 } | |
| 1047 | |
| 1048 #ifndef REG_OK_STRICT | |
| 1049 /* Nonzero if X is a hard reg that can be used as a base reg | |
| 1050 or if it is a pseudo reg. */ | |
| 1051 # define REG_OK_FOR_BASE_P(X) \ | |
| 1052 (REGNO (X) <= CRIS_LAST_GENERAL_REGISTER \ | |
| 1053 || REGNO (X) == ARG_POINTER_REGNUM \ | |
| 1054 || REGNO (X) >= FIRST_PSEUDO_REGISTER) | |
| 1055 #else | |
| 1056 /* Nonzero if X is a hard reg that can be used as a base reg. */ | |
| 1057 # define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X)) | |
| 1058 #endif | |
| 1059 | |
| 1060 #ifndef REG_OK_STRICT | |
| 1061 /* Nonzero if X is a hard reg that can be used as an index | |
| 1062 or if it is a pseudo reg. */ | |
| 1063 # define REG_OK_FOR_INDEX_P(X) REG_OK_FOR_BASE_P (X) | |
| 1064 #else | |
| 1065 /* Nonzero if X is a hard reg that can be used as an index. */ | |
| 1066 # define REG_OK_FOR_INDEX_P(X) REGNO_OK_FOR_INDEX_P (REGNO (X)) | |
| 1067 #endif | |
| 1068 | |
| 1069 /* Fix reloads known to cause suboptimal spilling. */ | |
| 1070 #define LEGITIMIZE_RELOAD_ADDRESS(X, MODE, OPNUM, TYPE, INDL, WIN) \ | |
| 1071 do \ | |
| 1072 { \ | |
| 1073 if (cris_reload_address_legitimized (X, MODE, OPNUM, TYPE, INDL)) \ | |
| 1074 goto WIN; \ | |
| 1075 } \ | |
| 1076 while (0) | |
| 1077 | |
| 1078 #define LEGITIMATE_CONSTANT_P(X) 1 | |
| 1079 | |
| 1080 | |
| 1081 /* Node: Condition Code */ | |
| 1082 | |
| 1083 #define NOTICE_UPDATE_CC(EXP, INSN) cris_notice_update_cc (EXP, INSN) | |
| 1084 | |
| 1085 /* FIXME: Maybe define CANONICALIZE_COMPARISON later, when playing with | |
| 1086 optimizations. It is needed; currently we do this with instruction | |
| 1087 patterns and NOTICE_UPDATE_CC. */ | |
| 1088 | |
| 1089 | |
| 1090 /* Node: Costs */ | |
| 1091 | |
| 1092 #define REGISTER_MOVE_COST(MODE, FROM, TO) \ | |
| 1093 cris_register_move_cost (MODE, FROM, TO) | |
| 1094 | |
| 1095 /* This isn't strictly correct for v0..3 in buswidth-8bit mode, but | |
| 1096 should suffice. */ | |
| 1097 #define MEMORY_MOVE_COST(M, CLASS, IN) \ | |
| 1098 (((M) == QImode) ? 4 : ((M) == HImode) ? 4 : 6) | |
| 1099 | |
| 1100 /* Regardless of the presence of delay slots, the default value of 1 for | |
| 1101 BRANCH_COST is the best in the range (1, 2, 3), tested with gcc-2.7.2 | |
| 1102 with testcases ipps and gcc, giving smallest and fastest code. */ | |
| 1103 | |
| 1104 #define SLOW_BYTE_ACCESS 0 | |
| 1105 | |
| 1106 /* This is the threshold *below* which inline move sequences of | |
| 1107 word-length sizes will be emitted. The "9" will translate to | |
| 1108 (9 - 1) * 4 = 32 bytes maximum moved, but using 16 instructions | |
| 1109 (8 instruction sequences) or less. */ | |
| 1110 #define MOVE_RATIO(speed) 9 | |
| 1111 | |
| 1112 | |
| 1113 /* Node: Sections */ | |
| 1114 | |
| 1115 #define TEXT_SECTION_ASM_OP "\t.text" | |
| 1116 | |
| 1117 #define DATA_SECTION_ASM_OP "\t.data" | |
| 1118 | |
| 1119 #define FORCE_EH_FRAME_INFO_IN_DATA_SECTION (! TARGET_ELF) | |
| 1120 | |
| 1121 /* The jump table is immediately connected to the preceding insn. */ | |
| 1122 #define JUMP_TABLES_IN_TEXT_SECTION 1 | |
| 1123 | |
| 1124 | |
| 1125 /* Node: PIC */ | |
| 1126 | |
| 1127 /* Helper type. */ | |
| 1128 | |
| 1129 enum cris_pic_symbol_type | |
| 1130 { | |
| 1131 cris_no_symbol = 0, | |
| 1132 cris_got_symbol = 1, | |
| 1133 cris_rel_symbol = 2, | |
| 1134 cris_got_symbol_needing_fixup = 3, | |
| 1135 cris_invalid_pic_symbol = 4 | |
| 1136 }; | |
| 1137 | |
| 1138 #define PIC_OFFSET_TABLE_REGNUM (flag_pic ? CRIS_GOT_REGNUM : INVALID_REGNUM) | |
| 1139 | |
| 1140 #define LEGITIMATE_PIC_OPERAND_P(X) cris_legitimate_pic_operand (X) | |
| 1141 | |
| 1142 | |
| 1143 /* Node: File Framework */ | |
| 1144 | |
| 1145 /* We don't want an .ident for gcc. To avoid that but still support | |
| 1146 #ident, we override ASM_OUTPUT_IDENT and, since the gcc .ident is its | |
| 1147 only use besides ASM_OUTPUT_IDENT, undef IDENT_ASM_OP from elfos.h. */ | |
| 1148 #undef IDENT_ASM_OP | |
| 1149 #undef ASM_OUTPUT_IDENT | |
| 1150 #define ASM_OUTPUT_IDENT(FILE, NAME) \ | |
| 1151 fprintf (FILE, "%s\"%s\"\n", "\t.ident\t", NAME); | |
| 1152 | |
| 1153 #define ASM_APP_ON "#APP\n" | |
| 1154 | |
| 1155 #define ASM_APP_OFF "#NO_APP\n" | |
| 1156 | |
| 1157 | |
| 1158 /* Node: Data Output */ | |
| 1159 | |
| 1160 #define OUTPUT_ADDR_CONST_EXTRA(STREAM, X, FAIL) \ | |
| 1161 do { if (!cris_output_addr_const_extra (STREAM, X)) goto FAIL; } while (0) | |
| 1162 | |
| 1163 #define IS_ASM_LOGICAL_LINE_SEPARATOR(C, STR) (C) == '@' | |
| 1164 | |
| 1165 /* Node: Uninitialized Data */ | |
| 1166 | |
| 1167 /* Remember to round off odd values if we want data alignment, | |
| 1168 since we cannot do that with an .align directive. | |
| 1169 | |
| 1170 Using .comm causes the space not to be reserved in .bss, but by | |
| 1171 tricks with the symbol type. Not good if other tools than binutils | |
| 1172 are used on the object files. Since ".global ... .lcomm ..." works, we | |
| 1173 use that. Use .._ALIGNED_COMMON, since gcc whines when we only have | |
| 1174 ..._COMMON, and we prefer to whine ourselves; BIGGEST_ALIGNMENT is not | |
| 1175 the one to check. This done for a.out only. */ | |
| 1176 /* FIXME: I suspect a bug in gcc with alignment. Do not warn until | |
| 1177 investigated; it mucks up the testsuite results. */ | |
| 1178 #define CRIS_ASM_OUTPUT_ALIGNED_DECL_COMMON(FILE, DECL, NAME, SIZE, ALIGN, LOCAL) \ | |
| 1179 do \ | |
| 1180 { \ | |
| 1181 int align_ = (ALIGN) / BITS_PER_UNIT; \ | |
| 1182 if (TARGET_DATA_ALIGN && TARGET_ALIGN_BY_32 && align_ < 4) \ | |
| 1183 align_ = 4; \ | |
| 1184 else if (TARGET_DATA_ALIGN && align_ < 2) \ | |
| 1185 align_ = 2; \ | |
| 1186 /* FIXME: Do we need this? */ \ | |
| 1187 else if (align_ < 1) \ | |
| 1188 align_ = 1; \ | |
| 1189 \ | |
| 1190 if (TARGET_ELF) \ | |
| 1191 { \ | |
| 1192 if (LOCAL) \ | |
| 1193 { \ | |
| 1194 fprintf ((FILE), "%s", LOCAL_ASM_OP); \ | |
| 1195 assemble_name ((FILE), (NAME)); \ | |
| 1196 fprintf ((FILE), "\n"); \ | |
| 1197 } \ | |
| 1198 fprintf ((FILE), "%s", COMMON_ASM_OP); \ | |
| 1199 assemble_name ((FILE), (NAME)); \ | |
| 1200 fprintf ((FILE), ",%u,%u\n", (int)(SIZE), align_); \ | |
| 1201 } \ | |
| 1202 else \ | |
| 1203 { \ | |
| 1204 /* We can't tell a one-only or weak COMM from a "global \ | |
| 1205 COMM" so just make all non-locals weak. */ \ | |
| 1206 if (! (LOCAL)) \ | |
| 1207 ASM_WEAKEN_LABEL (FILE, NAME); \ | |
| 1208 fputs ("\t.lcomm ", (FILE)); \ | |
| 1209 assemble_name ((FILE), (NAME)); \ | |
| 1210 fprintf ((FILE), ",%u\n", \ | |
| 1211 ((int)(SIZE) + (align_ - 1)) & ~(align_ - 1)); \ | |
| 1212 } \ | |
| 1213 } \ | |
| 1214 while (0) | |
| 1215 | |
| 1216 #define ASM_OUTPUT_ALIGNED_DECL_COMMON(FILE, DECL, NAME, SIZE, ALIGN) \ | |
| 1217 CRIS_ASM_OUTPUT_ALIGNED_DECL_COMMON(FILE, DECL, NAME, SIZE, ALIGN, 0) | |
| 1218 | |
| 1219 #undef ASM_OUTPUT_ALIGNED_DECL_LOCAL | |
| 1220 #define ASM_OUTPUT_ALIGNED_DECL_LOCAL(FILE, DECL, NAME, SIZE, ALIGN) \ | |
| 1221 CRIS_ASM_OUTPUT_ALIGNED_DECL_COMMON(FILE, DECL, NAME, SIZE, ALIGN, 1) | |
| 1222 | |
| 1223 /* Node: Label Output */ | |
| 1224 | |
| 1225 /* Globalizing directive for a label. */ | |
| 1226 #define GLOBAL_ASM_OP "\t.global " | |
| 1227 | |
| 1228 #define SUPPORTS_WEAK 1 | |
| 1229 | |
| 1230 #define ASM_OUTPUT_SYMBOL_REF(STREAM, SYM) \ | |
| 1231 cris_asm_output_symbol_ref (STREAM, SYM) | |
| 1232 | |
| 1233 #define ASM_OUTPUT_LABEL_REF(STREAM, BUF) \ | |
| 1234 cris_asm_output_label_ref (STREAM, BUF) | |
| 1235 | |
| 1236 /* Remove any previous definition (elfos.h). */ | |
| 1237 #undef ASM_GENERATE_INTERNAL_LABEL | |
| 1238 #define ASM_GENERATE_INTERNAL_LABEL(LABEL, PREFIX, NUM) \ | |
| 1239 sprintf (LABEL, "*%s%s%ld", LOCAL_LABEL_PREFIX, PREFIX, (long) NUM) | |
| 1240 | |
| 1241 /* Node: Initialization */ | |
| 1242 /* (no definitions) */ | |
| 1243 | |
| 1244 /* Node: Macros for Initialization */ | |
| 1245 /* (no definitions) */ | |
| 1246 | |
| 1247 /* Node: Instruction Output */ | |
| 1248 | |
| 1249 #define REGISTER_NAMES \ | |
| 1250 {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", \ | |
| 1251 "r9", "r10", "r11", "r12", "r13", "sp", "acr", "srp", "mof", "faked_ap", "dccr"} | |
| 1252 | |
| 1253 #define ADDITIONAL_REGISTER_NAMES \ | |
| 1254 {{"r14", 14}, {"r15", 15}, {"pc", 15}} | |
| 1255 | |
| 1256 #define PRINT_OPERAND(FILE, X, CODE) \ | |
| 1257 cris_print_operand (FILE, X, CODE) | |
| 1258 | |
| 1259 /* For delay-slot handling. */ | |
| 1260 #define PRINT_OPERAND_PUNCT_VALID_P(CODE) \ | |
| 1261 ((CODE) == '#' || (CODE) == '!' || (CODE) == ':') | |
| 1262 | |
| 1263 #define PRINT_OPERAND_ADDRESS(FILE, ADDR) \ | |
| 1264 cris_print_operand_address (FILE, ADDR) | |
| 1265 | |
| 1266 /* Output an empty line to illustrate the presence of the delay slot. */ | |
| 1267 #define DBR_OUTPUT_SEQEND(FILE) \ | |
| 1268 fprintf (FILE, "\n") | |
| 1269 | |
| 1270 #define LOCAL_LABEL_PREFIX (TARGET_ELF ? "." : "") | |
| 1271 | |
| 1272 /* cppinit.c initializes a const array from this, so it must be constant, | |
| 1273 can't have it different based on options. Luckily, the prefix is | |
| 1274 always allowed, so let's have it on all GCC-generated code. Note that | |
| 1275 we have this verbatim everywhere in the back-end, not using %R or %s or | |
| 1276 such. */ | |
| 1277 #define REGISTER_PREFIX "$" | |
| 1278 | |
| 1279 /* Remove any previous definition (elfos.h). */ | |
| 1280 /* We use -fno-leading-underscore to remove it, when necessary. */ | |
| 1281 #undef USER_LABEL_PREFIX | |
| 1282 #define USER_LABEL_PREFIX "_" | |
| 1283 | |
| 1284 #define ASM_OUTPUT_REG_PUSH(FILE, REGNO) \ | |
| 1285 fprintf (FILE, \ | |
| 1286 TARGET_V32 \ | |
| 1287 ? "\tsubq 4,$sp\n\tmove $%s,[$sp]\n" : "\tpush $%s\n", \ | |
| 1288 reg_names[REGNO]) | |
| 1289 | |
| 1290 #define ASM_OUTPUT_REG_POP(FILE, REGNO) \ | |
| 1291 fprintf (FILE, "\tmove [$sp+],$%s\n", reg_names[REGNO]) | |
| 1292 | |
| 1293 | |
| 1294 /* Node: Dispatch Tables */ | |
| 1295 | |
| 1296 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) \ | |
| 1297 do \ | |
| 1298 { \ | |
| 1299 if (TARGET_V32) \ | |
| 1300 asm_fprintf (FILE, "\t.word %LL%d-.\n", VALUE); \ | |
| 1301 else \ | |
| 1302 asm_fprintf (FILE, "\t.word %LL%d-%LL%d\n", VALUE, REL); \ | |
| 1303 } \ | |
| 1304 while (0) | |
| 1305 | |
| 1306 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \ | |
| 1307 asm_fprintf (FILE, "\t.dword %LL%d\n", VALUE) | |
| 1308 | |
| 1309 /* Defined to also emit an .align in elfos.h. We don't want that. */ | |
| 1310 #undef ASM_OUTPUT_CASE_LABEL | |
| 1311 | |
| 1312 /* Since the "bound" insn loads the comparison value if the compared< | |
| 1313 value (register) is out of bounds (0..comparison value-1), we need | |
| 1314 to output another case to catch it. | |
| 1315 The way to find it is to look for the label_ref at the else-arm inside | |
| 1316 the expanded casesi core-insn. | |
| 1317 FIXME: Check this construct when changing to new version of gcc. */ | |
| 1318 #define ASM_OUTPUT_CASE_END(STREAM, NUM, TABLE) \ | |
| 1319 cris_asm_output_case_end (STREAM, NUM, TABLE) | |
| 1320 | |
| 1321 | |
| 1322 /* Node: Exception Region Output */ | |
| 1323 /* (no definitions) */ | |
| 1324 /* FIXME: Fill in with our own optimized layout. */ | |
| 1325 | |
| 1326 /* Node: Alignment Output */ | |
| 1327 | |
| 1328 #define ASM_OUTPUT_ALIGN(FILE, LOG) \ | |
| 1329 fprintf (FILE, "\t.align %d\n", (LOG)) | |
| 1330 | |
| 1331 | |
| 1332 /* Node: All Debuggers */ | |
| 1333 | |
| 1334 #define DBX_REGISTER_NUMBER(REGNO) \ | |
| 1335 ((REGNO) == CRIS_SRP_REGNUM ? CRIS_CANONICAL_SRP_REGNUM : \ | |
| 1336 (REGNO) == CRIS_MOF_REGNUM ? CRIS_CANONICAL_MOF_REGNUM : \ | |
| 1337 (REGNO) == CRIS_CC0_REGNUM ? CRIS_CANONICAL_CC0_REGNUM : \ | |
| 1338 (REGNO)) | |
| 1339 | |
| 1340 /* FIXME: Investigate DEBUGGER_AUTO_OFFSET, DEBUGGER_ARG_OFFSET. */ | |
| 1341 | |
| 1342 | |
| 1343 /* Node: DBX Options */ | |
| 1344 | |
| 1345 /* Is this correct? Check later. */ | |
| 1346 #define DBX_NO_XREFS | |
| 1347 | |
| 1348 #define DBX_CONTIN_LENGTH 0 | |
| 1349 | |
| 1350 /* FIXME: Is this needed when we have 0 DBX_CONTIN_LENGTH? */ | |
| 1351 #define DBX_CONTIN_CHAR '?' | |
| 1352 | |
| 1353 | |
| 1354 /* Node: DBX Hooks */ | |
| 1355 /* (no definitions) */ | |
| 1356 | |
| 1357 /* Node: File names and DBX */ | |
| 1358 /* (no definitions) */ | |
| 1359 | |
| 1360 | |
| 1361 /* Node: SDB and DWARF */ | |
| 1362 /* (no definitions) */ | |
| 1363 | |
| 1364 /* Node: Misc */ | |
| 1365 | |
| 1366 /* A combination of the bound (umin) insn together with a | |
| 1367 sign-extended add via the table to PC seems optimal. | |
| 1368 If the table overflows, the assembler will take care of it. | |
| 1369 Theoretically, in extreme cases (uncertain if they occur), an error | |
| 1370 will be emitted, so FIXME: Check how large case-tables are emitted, | |
| 1371 possible add an option to emit SImode case-tables. */ | |
| 1372 #define CASE_VECTOR_MODE HImode | |
| 1373 | |
| 1374 #define CASE_VECTOR_PC_RELATIVE 1 | |
| 1375 | |
| 1376 /* FIXME: Investigate CASE_VECTOR_SHORTEN_MODE to make sure HImode is not | |
| 1377 used when broken-.word could possibly fail (plus testcase). */ | |
| 1378 | |
| 1379 #define FIXUNS_TRUNC_LIKE_FIX_TRUNC | |
| 1380 | |
| 1381 /* This is the number of bytes that can be moved in one | |
| 1382 reasonably fast instruction sequence. For CRIS, this is two | |
| 1383 instructions: mem => reg, reg => mem. */ | |
| 1384 #define MOVE_MAX 4 | |
| 1385 | |
| 1386 /* Maybe SHIFT_COUNT_TRUNCATED is safe to define? FIXME: Check later. */ | |
| 1387 | |
| 1388 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1 | |
| 1389 | |
| 1390 #define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = 32, 1) | |
| 1391 #define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = 32, 1) | |
| 1392 | |
| 1393 #define Pmode SImode | |
| 1394 | |
| 1395 #define FUNCTION_MODE QImode | |
| 1396 | |
| 1397 #define NO_IMPLICIT_EXTERN_C | |
| 1398 | |
| 1399 /* No specific purpose other than warningless compatibility. */ | |
| 1400 #define HANDLE_PRAGMA_PACK_PUSH_POP 1 | |
| 1401 | |
| 1402 /* | |
| 1403 * Local variables: | |
| 1404 * eval: (c-set-style "gnu") | |
| 1405 * indent-tabs-mode: t | |
| 1406 * End: | |
| 1407 */ |