gcc/config/cris/cris.h

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