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