gcc/config/cris/cris.h

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