gcc/config/score/score.h

   1 /* score.h for Sunplus S+CORE processor
   2    Copyright (C) 2005, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   3    Contributed by Sunnorth.
   4
   5    This file is part of GCC.
   6
   7    GCC is free software; you can redistribute it and/or modify it
   8    under the terms of the GNU General Public License as published
   9    by the Free Software Foundation; either version 3, or (at your
  10    option) any later version.
  11
  12    GCC is distributed in the hope that it will be useful, but WITHOUT
  13    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  15    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 #include "score-conv.h"
  22
  23 /* Controlling the Compilation Driver.  */
  24 #undef SWITCH_TAKES_ARG
  25 #define SWITCH_TAKES_ARG(CHAR) \
  26   (DEFAULT_SWITCH_TAKES_ARG (CHAR) || (CHAR) == 'G')
  27
  28 #undef CPP_SPEC
  29 #define CPP_SPEC                 "%{mscore3:-D__score3__} %{G*}"
  30
  31 #undef CC1_SPEC
  32 #define CC1_SPEC                 "%{!mel:-meb} %{mel:-mel } \
  33 %{!mscore*:-mscore7}    \
  34 %{mscore3:-mscore3}     \
  35 %{mscore3d:-mscore3d}   \
  36 %{mscore7:-mscore7}     \
  37 %{mscore7d:-mscore7d}   \
  38 %{G*}"
  39
  40 #undef ASM_SPEC
  41 #define ASM_SPEC                 "%{!mel:-EB} %{mel:-EL} \
  42 %{!mscore*:-march=score7}         \
  43 %{mscore7:-march=score7}          \
  44 %{mscore7d:-march=score7}         \
  45 %{mscore3:-march=score3}          \
  46 %{mscore3d:-march=score3}         \
  47 %{march=score5:-march=score7}     \
  48 %{march=score5u:-march=score7}    \
  49 %{march=score7:-march=score7}     \
  50 %{march=score7d:-march=score7}    \
  51 %{march=score3:-march=score3}     \
  52 %{march=score3d:-march=score3}    \
  53 %{G*}"
  54
  55 #undef LINK_SPEC
  56 #define LINK_SPEC                "%{!mel:-EB} %{mel:-EL} \
  57 %{!mscore*:-mscore7_elf}          \
  58 %{mscore7:-mscore7_elf}           \
  59 %{mscore7d:-mscore7_elf}          \
  60 %{mscore3:-mscore3_elf}           \
  61 %{mscore3d:-mscore3_elf}          \
  62 %{march=score5:-mscore7_elf}      \
  63 %{march=score5u:-mscore7_elf}     \
  64 %{march=score7:-mscore7_elf}      \
  65 %{march=score7d:-mscore7_elf}     \
  66 %{march=score3:-mscore3_elf}      \
  67 %{march=score3d:-mscore3_elf}     \
  68 %{G*}"
  69
  70 /* Run-time Target Specification.  */
  71 #define TARGET_CPU_CPP_BUILTINS()               \
  72   do {                                          \
  73     builtin_define ("SUNPLUS");                 \
  74     builtin_define ("__SCORE__");               \
  75     builtin_define ("__score__");               \
  76     if (TARGET_LITTLE_ENDIAN)                   \
  77       builtin_define ("__scorele__");           \
  78     else                                        \
  79       builtin_define ("__scorebe__");           \
  80     if (TARGET_SCORE5)                          \
  81       builtin_define ("__score5__");            \
  82     if (TARGET_SCORE5U)                         \
  83       builtin_define ("__score5u__");           \
  84     if (TARGET_SCORE7)                          \
  85       builtin_define ("__score7__");            \
  86     if (TARGET_SCORE7D)                         \
  87       builtin_define ("__score7d__");           \
  88     if (TARGET_SCORE3)                          \
  89       builtin_define ("__score3__");            \
  90     if (TARGET_SCORE3D)                         \
  91       builtin_define ("__score3d__");           \
  92   } while (0)
  93
  94 #define TARGET_DEFAULT         0
  95
  96 #define SCORE_GCC_VERSION      "1.6"
  97
  98 #define TARGET_VERSION \
  99       fprintf (stderr, "Sunplus S+core rev=%s", SCORE_GCC_VERSION);
 100
 101 /* Target machine storage layout.  */
 102 #define BITS_BIG_ENDIAN        0
 103 #define BYTES_BIG_ENDIAN       (TARGET_LITTLE_ENDIAN == 0)
 104 #define WORDS_BIG_ENDIAN       (TARGET_LITTLE_ENDIAN == 0)
 105
 106 /* Width of a word, in units (bytes).  */
 107 #define UNITS_PER_WORD                 4
 108
 109 /* Define this macro if it is advisable to hold scalars in registers
 110    in a wider mode than that declared by the program.  In such cases,
 111    the value is constrained to be within the bounds of the declared
 112    type, but kept valid in the wider mode.  The signedness of the
 113    extension may differ from that of the type.  */
 114 #define PROMOTE_MODE(MODE, UNSIGNEDP, TYPE)     \
 115   if (GET_MODE_CLASS (MODE) == MODE_INT         \
 116       && GET_MODE_SIZE (MODE) < UNITS_PER_WORD) \
 117     (MODE) = SImode;
 118
 119 /* Allocation boundary (in *bits*) for storing arguments in argument list.  */
 120 #define PARM_BOUNDARY                  BITS_PER_WORD
 121 #define STACK_BOUNDARY                 BITS_PER_WORD
 122
 123 /* Allocation boundary (in *bits*) for the code of a function.  */
 124 #define FUNCTION_BOUNDARY              BITS_PER_WORD
 125
 126 /* There is no point aligning anything to a rounder boundary than this.  */
 127 #define BIGGEST_ALIGNMENT              LONG_DOUBLE_TYPE_SIZE
 128
 129 /* If defined, a C expression to compute the alignment for a static
 130    variable.  TYPE is the data type, and ALIGN is the alignment that
 131    the object would ordinarily have.  The value of this macro is used
 132    instead of that alignment to align the object.
 133
 134    If this macro is not defined, then ALIGN is used.
 135
 136    One use of this macro is to increase alignment of medium-size
 137    data to make it all fit in fewer cache lines.  Another is to
 138    cause character arrays to be word-aligned so that `strcpy' calls
 139    that copy constants to character arrays can be done inline.  */
 140 #define DATA_ALIGNMENT(TYPE, ALIGN)                                      \
 141   ((((ALIGN) < BITS_PER_WORD)                                            \
 142     && (TREE_CODE (TYPE) == ARRAY_TYPE                                   \
 143         || TREE_CODE (TYPE) == UNION_TYPE                                \
 144         || TREE_CODE (TYPE) == RECORD_TYPE)) ? BITS_PER_WORD : (ALIGN))
 145
 146 /* If defined, a C expression to compute the alignment given to a
 147    constant that is being placed in memory.  EXP is the constant
 148    and ALIGN is the alignment that the object would ordinarily have.
 149    The value of this macro is used instead of that alignment to align
 150    the object.
 151
 152    If this macro is not defined, then ALIGN is used.
 153
 154    The typical use of this macro is to increase alignment for string
 155    constants to be word aligned so that `strcpy' calls that copy
 156    constants can be done inline.  */
 157 #define CONSTANT_ALIGNMENT(EXP, ALIGN)                                  \
 158   ((TREE_CODE (EXP) == STRING_CST  || TREE_CODE (EXP) == CONSTRUCTOR)   \
 159    && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
 160
 161 /* If defined, a C expression to compute the alignment for a local
 162    variable.  TYPE is the data type, and ALIGN is the alignment that
 163    the object would ordinarily have.  The value of this macro is used
 164    instead of that alignment to align the object.
 165
 166    If this macro is not defined, then ALIGN is used.
 167
 168    One use of this macro is to increase alignment of medium-size
 169    data to make it all fit in fewer cache lines.  */
 170 #define LOCAL_ALIGNMENT(TYPE, ALIGN)                                    \
 171   ((TREE_CODE (TYPE) == ARRAY_TYPE                                      \
 172     && TYPE_MODE (TREE_TYPE (TYPE)) == QImode                           \
 173     && (ALIGN) < BITS_PER_WORD) ? BITS_PER_WORD : (ALIGN))
 174
 175 /* Alignment of field after `int : 0' in a structure.  */
 176 #define EMPTY_FIELD_BOUNDARY           32
 177
 178 /* All accesses must be aligned.  */
 179 #define STRICT_ALIGNMENT               1
 180
 181 /* Score requires that structure alignment is affected by bitfields.  */
 182 #define PCC_BITFIELD_TYPE_MATTERS      1
 183
 184 /* long double is not a fixed mode, but the idea is that, if we
 185    support long double, we also want a 128-bit integer type.  */
 186 #define MAX_FIXED_MODE_SIZE            LONG_DOUBLE_TYPE_SIZE
 187
 188 /* Layout of Data Type.  */
 189 /* Set the sizes of the core types.  */
 190 #define INT_TYPE_SIZE                   32
 191 #define SHORT_TYPE_SIZE                 16
 192 #define LONG_TYPE_SIZE                  32
 193 #define LONG_LONG_TYPE_SIZE             64
 194 #define CHAR_TYPE_SIZE                  8
 195 #define FLOAT_TYPE_SIZE                 32
 196 #define DOUBLE_TYPE_SIZE                64
 197 #define LONG_DOUBLE_TYPE_SIZE           64
 198
 199 /* Define this as 1 if `char' should by default be signed; else as 0.  */
 200 #undef DEFAULT_SIGNED_CHAR
 201 #define DEFAULT_SIGNED_CHAR             1
 202
 203 /* Default definitions for size_t and ptrdiff_t.  */
 204 #define SIZE_TYPE                       "unsigned int"
 205
 206 #define UINTPTR_TYPE                    "long unsigned int"
 207
 208 /* Register Usage
 209
 210    S+core have:
 211    - 32 integer registers
 212    - 16 control registers (cond)
 213    - 16 special registers (ceh/cel/cnt/lcr/scr/arg/fp)
 214    - 32 coprocessors 1 registers
 215    - 32 coprocessors 2 registers
 216    - 32 coprocessors 3 registers.  */
 217 #define FIRST_PSEUDO_REGISTER           160
 218
 219 /* By default, fix the kernel registers (r30 and r31), the global
 220    pointer (r28) and the stack pointer (r0).  This can change
 221    depending on the command-line options.
 222
 223    Regarding coprocessor registers: without evidence to the contrary,
 224    it's best to assume that each coprocessor register has a unique
 225    use.  This can be overridden, in, e.g., TARGET_OPTION_OVERRIDE or
 226    CONDITIONAL_REGISTER_USAGE should the assumption be inappropriate
 227    for a particular target.  */
 228
 229 /* Control Registers, use mfcr/mtcr insn
 230     32        cr0         PSR
 231     33        cr1         Condition
 232     34        cr2         ECR
 233     35        cr3         EXCPVec
 234     36        cr4         CCR
 235     37        cr5         EPC
 236     38        cr6         EMA
 237     39        cr7         TLBLock
 238     40        cr8         TLBPT
 239     41        cr8         PEADDR
 240     42        cr10        TLBRPT
 241     43        cr11        PEVN
 242     44        cr12        PECTX
 243     45        cr13
 244     46        cr14
 245     47        cr15
 246
 247     Custom Engine Register, use mfce/mtce
 248     48        CEH        CEH
 249     49        CEL        CEL
 250
 251     Special-Purpose Register, use mfsr/mtsr
 252     50        sr0        CNT
 253     51        sr1        LCR
 254     52        sr2        SCR
 255
 256     53        ARG_POINTER_REGNUM
 257     54        FRAME_POINTER_REGNUM
 258     but Control register have 32 registers, cr16-cr31.  */
 259 #define FIXED_REGISTERS                                  \
 260 {                                                        \
 261   /* General Purpose Registers  */                       \
 262   1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,        \
 263   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,        \
 264   /* Control Registers  */                               \
 265   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
 266   /* CEH/ CEL/ CNT/ LCR/ SCR / ARG_POINTER_REGNUM/ FRAME_POINTER_REGNUM */\
 267   0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
 268   /* CP 1 Registers  */                                  \
 269   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
 270   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
 271   /* CP 2 Registers  */                                  \
 272   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
 273   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
 274   /* CP 3 Registers  */                                  \
 275   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
 276   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
 277 }
 278
 279 #define CALL_USED_REGISTERS                              \
 280 {                                                        \
 281   /* General purpose register  */                        \
 282   1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,        \
 283   0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
 284   /* Control Registers  */                               \
 285   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
 286   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
 287   /* CP 1 Registers  */                                  \
 288   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
 289   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
 290   /* CP 2 Registers  */                                  \
 291   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
 292   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
 293   /* CP 3 Registers  */                                  \
 294   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
 295   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,        \
 296 }
 297
 298 #define REG_ALLOC_ORDER                                                   \
 299 {   0,  1,  6,  7,  8,  9, 10, 11,  4,  5, 22, 23, 24, 25, 26, 27,        \
 300    12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 28, 29, 30, 31,  2,  3,        \
 301    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,        \
 302    48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,        \
 303    64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,        \
 304    80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,        \
 305    96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,        \
 306   112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,        \
 307   128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,        \
 308   144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159        }
 309
 310 /* Macro to conditionally modify fixed_regs/call_used_regs.  */
 311 #define PIC_OFFSET_TABLE_REGNUM          29
 312
 313 #define CONDITIONAL_REGISTER_USAGE                     \
 314 {                                                      \
 315    if (!flag_pic)                                      \
 316      fixed_regs[PIC_OFFSET_TABLE_REGNUM] =             \
 317      call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 0;      \
 318 }
 319
 320 #define HARD_REGNO_NREGS(REGNO, MODE) \
 321   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
 322
 323 /* Return true if REGNO is suitable for holding a quantity of type MODE.  */
 324 #define HARD_REGNO_MODE_OK(REGNO, MODE) score_hard_regno_mode_ok (REGNO, MODE)
 325
 326 /* Value is 1 if it is a good idea to tie two pseudo registers
 327    when one has mode MODE1 and one has mode MODE2.
 328    If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2,
 329    for any hard reg, then this must be 0 for correct output.  */
 330 #define MODES_TIEABLE_P(MODE1, MODE2)                             \
 331   ((GET_MODE_CLASS (MODE1) == MODE_FLOAT                          \
 332     || GET_MODE_CLASS (MODE1) == MODE_COMPLEX_FLOAT)              \
 333    == (GET_MODE_CLASS (MODE2) == MODE_FLOAT                       \
 334        || GET_MODE_CLASS (MODE2) == MODE_COMPLEX_FLOAT))
 335
 336 /* Register Classes.  */
 337 /* Define the classes of registers for register constraints in the
 338    machine description.  Also define ranges of constants.  */
 339 enum reg_class
 340 {
 341   NO_REGS,
 342   G16_REGS,    /* r0 ~ r15 */
 343   G32_REGS,    /* r0 ~ r31 */
 344   T32_REGS,    /* r8 ~ r11 | r22 ~ r27 */
 345
 346   HI_REG,      /* hi                 */
 347   LO_REG,      /* lo                 */
 348   CE_REGS,     /* hi + lo            */
 349
 350   CN_REG,      /* cnt                */
 351   LC_REG,      /* lcb                */
 352   SC_REG,      /* scb                */
 353   SP_REGS,     /* cnt + lcb + scb    */
 354
 355   CR_REGS,     /* cr0 - cr15         */
 356
 357   CP1_REGS,    /* cp1                */
 358   CP2_REGS,    /* cp2                */
 359   CP3_REGS,    /* cp3                */
 360   CPA_REGS,    /* cp1 + cp2 + cp3    */
 361
 362   ALL_REGS,
 363   LIM_REG_CLASSES
 364 };
 365
 366 #define N_REG_CLASSES                  ((int) LIM_REG_CLASSES)
 367
 368 #define GENERAL_REGS                   G32_REGS
 369
 370 /* Give names of register classes as strings for dump file.  */
 371 #define REG_CLASS_NAMES           \
 372 {                                 \
 373   "NO_REGS",                      \
 374   "G16_REGS",                     \
 375   "G32_REGS",                     \
 376   "T32_REGS",                     \
 377                                   \
 378   "HI_REG",                       \
 379   "LO_REG",                       \
 380   "CE_REGS",                      \
 381                                   \
 382   "CN_REG",                       \
 383   "LC_REG",                       \
 384   "SC_REG",                       \
 385   "SP_REGS",                      \
 386                                   \
 387   "CR_REGS",                      \
 388                                   \
 389   "CP1_REGS",                     \
 390   "CP2_REGS",                     \
 391   "CP3_REGS",                     \
 392   "CPA_REGS",                     \
 393                                   \
 394   "ALL_REGS",                     \
 395 }
 396
 397 /* Define which registers fit in which classes.  */
 398 #define REG_CLASS_CONTENTS                                        \
 399 {                                                                 \
 400   /* NO_REGS/G16/G32/T32  */                                      \
 401   { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000},  \
 402   { 0x0000ffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000},  \
 403   { 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000},  \
 404   { 0x0fc00f00, 0x00000000, 0x00000000, 0x00000000, 0x00000000},  \
 405   /* HI/LO/CE  */                                                 \
 406   { 0x00000000, 0x00010000, 0x00000000, 0x00000000, 0x00000000},  \
 407   { 0x00000000, 0x00020000, 0x00000000, 0x00000000, 0x00000000},  \
 408   { 0x00000000, 0x00030000, 0x00000000, 0x00000000, 0x00000000},  \
 409   /* CN/LC/SC/SP/CR  */                                           \
 410   { 0x00000000, 0x00040000, 0x00000000, 0x00000000, 0x00000000},  \
 411   { 0x00000000, 0x00080000, 0x00000000, 0x00000000, 0x00000000},  \
 412   { 0x00000000, 0x00100000, 0x00000000, 0x00000000, 0x00000000},  \
 413   { 0x00000000, 0x001c0000, 0x00000000, 0x00000000, 0x00000000},  \
 414   { 0x00000000, 0x0000ffff, 0x00000000, 0x00000000, 0x00000000},  \
 415   /* CP1/CP2/CP3/CPA  */                                          \
 416   { 0x00000000, 0x00000000, 0xffffffff, 0x00000000, 0x00000000},  \
 417   { 0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0x00000000},  \
 418   { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff},  \
 419   { 0x00000000, 0x00000000, 0xffffffff, 0xffffffff, 0xffffffff},  \
 420   /* ALL_REGS  */                                                 \
 421   { 0xffffffff, 0x001fffff, 0xffffffff, 0xffffffff, 0xffffffff},  \
 422 }
 423
 424 /* A C expression whose value is a register class containing hard
 425    register REGNO.  In general there is more that one such class;
 426    choose a class which is "minimal", meaning that no smaller class
 427    also contains the register.  */
 428 #define REGNO_REG_CLASS(REGNO)         score_reg_class (REGNO)
 429
 430 /* The following macro defines cover classes for Integrated Register
 431    Allocator.  Cover classes is a set of non-intersected register
 432    classes covering all hard registers used for register allocation
 433    purpose.  Any move between two registers of a cover class should be
 434    cheaper than load or store of the registers.  The macro value is
 435    array of register classes with LIM_REG_CLASSES used as the end
 436    marker.  */
 437 #define IRA_COVER_CLASSES                                       \
 438 {                                                               \
 439   G32_REGS, CE_REGS, SP_REGS, LIM_REG_CLASSES                   \
 440 }
 441
 442 /* A macro whose definition is the name of the class to which a
 443    valid base register must belong.  A base register is one used in
 444    an address which is the register value plus a displacement.  */
 445 #define BASE_REG_CLASS                 G16_REGS
 446
 447 /* The class value for index registers.  */
 448 #define INDEX_REG_CLASS                NO_REGS
 449
 450 extern enum reg_class score_char_to_class[256];
 451 #define REG_CLASS_FROM_LETTER(C)       score_char_to_class[(unsigned char) (C)]
 452
 453 /* Addressing modes, and classification of registers for them.  */
 454 #define REGNO_MODE_OK_FOR_BASE_P(REGNO, MODE) \
 455   score_regno_mode_ok_for_base_p (REGNO, 1)
 456
 457 #define REGNO_OK_FOR_INDEX_P(NUM)       0
 458
 459 #define PREFERRED_RELOAD_CLASS(X, CLASS) \
 460   score_preferred_reload_class (X, CLASS)
 461
 462 /* If we need to load shorts byte-at-a-time, then we need a scratch.  */
 463 #define SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, X) \
 464   score_secondary_reload_class (CLASS, MODE, X)
 465
 466 /* Return the register class of a scratch register needed to copy IN into
 467    or out of a register in CLASS in MODE.  If it can be done directly,
 468    NO_REGS is returned.  */
 469 #define SECONDARY_OUTPUT_RELOAD_CLASS(CLASS, MODE, X) \
 470   score_secondary_reload_class (CLASS, MODE, X)
 471
 472 /* Return the maximum number of consecutive registers
 473    needed to represent mode MODE in a register of class CLASS.  */
 474 #define CLASS_MAX_NREGS(CLASS, MODE) \
 475   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
 476
 477 #define CANNOT_CHANGE_MODE_CLASS(FROM, TO, CLASS)    \
 478   (GET_MODE_SIZE (FROM) != GET_MODE_SIZE (TO)        \
 479    ? reg_classes_intersect_p (HI_REG, (CLASS)) : 0)
 480
 481 /* The letters I, J, K, L, M, N, O, and P in a register constraint
 482    string can be used to stand for particular ranges of immediate
 483    operands.  This macro defines what the ranges are.  C is the
 484    letter, and VALUE is a constant value.  Return 1 if VALUE is
 485    in the range specified by C.  */
 486 #define CONST_OK_FOR_LETTER_P(VALUE, C) score_const_ok_for_letter_p (VALUE, C)
 487
 488 /* Similar, but for floating constants, and defining letters G and H.
 489    Here VALUE is the CONST_DOUBLE rtx itself.  */
 490
 491 #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C)        \
 492   ((C) == 'G' && (VALUE) == CONST0_RTX (GET_MODE (VALUE)))
 493
 494 /* Letters in the range `Q' through `U' may be defined in a
 495    machine-dependent fashion to stand for arbitrary operand types.
 496    The machine description macro `EXTRA_CONSTRAINT' is passed the
 497    operand as its first argument and the constraint letter as its
 498    second operand.  */
 499 #define EXTRA_CONSTRAINT(VALUE, C)      score_extra_constraint (VALUE, C)
 500
 501 /* Basic Stack Layout.  */
 502 /* Stack layout; function entry, exit and calling.  */
 503 #define STACK_GROWS_DOWNWARD
 504
 505 #define STACK_PUSH_CODE                 PRE_DEC
 506 #define STACK_POP_CODE                  POST_INC
 507
 508 /* The offset of the first local variable from the beginning of the frame.
 509    See compute_frame_size for details about the frame layout.  */
 510 #define STARTING_FRAME_OFFSET           crtl->outgoing_args_size
 511
 512 /* The argument pointer always points to the first argument.  */
 513 #define FIRST_PARM_OFFSET(FUNDECL)      0
 514
 515 /* A C expression whose value is RTL representing the value of the return
 516    address for the frame COUNT steps up from the current frame.  */
 517 #define RETURN_ADDR_RTX(count, frame)   score_return_addr (count, frame)
 518
 519 /* Pick up the return address upon entry to a procedure.  */
 520 #define INCOMING_RETURN_ADDR_RTX        gen_rtx_REG (VOIDmode, RA_REGNUM)
 521
 522 /* Exception handling Support.  */
 523 /* Use r0 to r3 to pass exception handling information.  */
 524 #define EH_RETURN_DATA_REGNO(N) \
 525   ((N) < 4 ? (N) + ARG_REG_FIRST : INVALID_REGNUM)
 526
 527 /* The register that holds the return address in exception handlers.  */
 528 #define EH_RETURN_STACKADJ_RTX          gen_rtx_REG (Pmode, EH_REGNUM)
 529
 530 /* Registers That Address the Stack Frame.  */
 531 /* Register to use for pushing function arguments.  */
 532 #define STACK_POINTER_REGNUM            SP_REGNUM
 533
 534 /* These two registers don't really exist: they get eliminated to either
 535    the stack or hard frame pointer.  */
 536 #define FRAME_POINTER_REGNUM            53
 537
 538 /*  we use r2 as the frame pointer.  */
 539 #define HARD_FRAME_POINTER_REGNUM       FP_REGNUM
 540
 541 #define ARG_POINTER_REGNUM              54
 542
 543 /* Register in which static-chain is passed to a function.  */
 544 #define STATIC_CHAIN_REGNUM             23
 545
 546 /* Elimination Frame Pointer and Arg Pointer  */
 547
 548 #define ELIMINABLE_REGS                                \
 549   {{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM},        \
 550    { ARG_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM},   \
 551    { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM},      \
 552    { FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}}
 553
 554 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
 555   (OFFSET) = score_initial_elimination_offset ((FROM), (TO))
 556
 557 /* Passing Function Arguments on the Stack.  */
 558 /* Allocate stack space for arguments at the beginning of each function.  */
 559 #define ACCUMULATE_OUTGOING_ARGS        1
 560
 561 /* reserve stack space for all argument registers.  */
 562 #define REG_PARM_STACK_SPACE(FNDECL)    UNITS_PER_WORD
 563
 564 /* Define this if it is the responsibility of the caller to
 565    allocate the area reserved for arguments passed in registers.
 566    If `ACCUMULATE_OUTGOING_ARGS' is also defined, the only effect
 567    of this macro is to determine whether the space is included in
 568    `crtl->outgoing_args_size'.  */
 569 #define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 1
 570
 571 /* Passing Arguments in Registers  */
 572 /* Determine where to put an argument to a function.
 573    Value is zero to push the argument on the stack,
 574    or a hard register in which to store the argument.
 575
 576    MODE is the argument's machine mode.
 577    TYPE is the data type of the argument (as a tree).
 578     This is null for libcalls where that information may
 579     not be available.
 580    CUM is a variable of type CUMULATIVE_ARGS which gives info about
 581     the preceding args and about the function being called.
 582    NAMED is nonzero if this argument is a named parameter
 583     (otherwise it is an extra parameter matching an ellipsis).  */
 584 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
 585   score_function_arg (&CUM, MODE, TYPE, NAMED)
 586
 587 /* A C type for declaring a variable that is used as the first argument of
 588    `FUNCTION_ARG' and other related values.  For some target machines, the
 589    type `int' suffices and can hold the number of bytes of argument so far.  */
 590 typedef struct score_args
 591 {
 592   unsigned int arg_number;             /* how many arguments have been seen  */
 593   unsigned int num_gprs;               /* number of gprs in use  */
 594   unsigned int stack_words;            /* number of words in stack  */
 595 } score_args_t;
 596
 597 #define CUMULATIVE_ARGS                score_args_t
 598
 599 /* Initialize a variable CUM of type CUMULATIVE_ARGS
 600    for a call to a function whose data type is FNTYPE.
 601    For a library call, FNTYPE is 0.  */
 602 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT, n_named_args) \
 603   score_init_cumulative_args (&CUM, FNTYPE, LIBNAME)
 604
 605 /* Update the data in CUM to advance over an argument
 606    of mode MODE and data type TYPE.
 607    (TYPE is null for libcalls where that information may not be available.)  */
 608 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \
 609   score_function_arg_advance (&CUM, MODE, TYPE, NAMED)
 610
 611 /* 1 if N is a possible register number for function argument passing.
 612    We have no FP argument registers when soft-float.  When FP registers
 613    are 32 bits, we can't directly reference the odd numbered ones.  */
 614 #define FUNCTION_ARG_REGNO_P(REGNO) \
 615   REG_CONTAIN (REGNO, ARG_REG_FIRST, ARG_REG_NUM)
 616
 617 /* How Scalar Function Values Are Returned.  */
 618 #define FUNCTION_VALUE(VALTYPE, FUNC) \
 619   score_function_value ((VALTYPE), (FUNC), VOIDmode)
 620
 621 #define LIBCALL_VALUE(MODE)  score_function_value (NULL_TREE, NULL, (MODE))
 622
 623 /* 1 if N is a possible register number for a function value.  */
 624 #define FUNCTION_VALUE_REGNO_P(REGNO)   ((REGNO) == (ARG_REG_FIRST))
 625
 626 #define PIC_FUNCTION_ADDR_REGNUM        (GP_REG_FIRST + 25)
 627
 628 /* How Large Values Are Returned.  */
 629 #define STRUCT_VALUE                    0
 630
 631 /* Function Entry and Exit  */
 632 /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
 633    the stack pointer does not matter.  The value is tested only in
 634    functions that have frame pointers.
 635    No definition is equivalent to always zero.  */
 636 #define EXIT_IGNORE_STACK               1
 637
 638 /* Generating Code for Profiling  */
 639 /* Output assembler code to FILE to increment profiler label # LABELNO
 640    for profiling a function entry.  */
 641 #define FUNCTION_PROFILER(FILE, LABELNO)                              \
 642   do {                                                                \
 643     if (TARGET_SCORE7)                                                \
 644       {                                                               \
 645         fprintf (FILE, " .set r1  \n");                               \
 646         fprintf (FILE, " mv   r%d,r%d \n", AT_REGNUM, RA_REGNUM);     \
 647         fprintf (FILE, " subi r%d, %d \n", STACK_POINTER_REGNUM, 8);  \
 648         fprintf (FILE, " jl   _mcount \n");                           \
 649         fprintf (FILE, " .set nor1 \n");                              \
 650       }                                                               \
 651     else if (TARGET_SCORE3)                                           \
 652       {                                                               \
 653         fprintf (FILE, " .set r1  \n");                               \
 654         fprintf (FILE, " mv!   r%d,r%d \n", AT_REGNUM, RA_REGNUM);    \
 655         fprintf (FILE, " addi! r%d, %d \n", STACK_POINTER_REGNUM, -8);\
 656         fprintf (FILE, " jl   _mcount \n");                           \
 657         fprintf (FILE, " .set nor1 \n");                              \
 658       }                                                               \
 659   } while (0)
 660
 661 /* Trampolines for Nested Functions.  */
 662 #define TRAMPOLINE_INSNS                6
 663
 664 /* A C expression for the size in bytes of the trampoline, as an integer.  */
 665 #define TRAMPOLINE_SIZE                (24 + GET_MODE_SIZE (ptr_mode) * 2)
 666
 667 #define HAVE_PRE_INCREMENT              1
 668 #define HAVE_PRE_DECREMENT              1
 669 #define HAVE_POST_INCREMENT             1
 670 #define HAVE_POST_DECREMENT             1
 671 #define HAVE_PRE_MODIFY_DISP            1
 672 #define HAVE_POST_MODIFY_DISP           1
 673 #define HAVE_PRE_MODIFY_REG             0
 674 #define HAVE_POST_MODIFY_REG            0
 675
 676 /* Maximum number of registers that can appear in a valid memory address.  */
 677 #define MAX_REGS_PER_ADDRESS            1
 678
 679 /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
 680    and check its validity for a certain class.
 681    We have two alternate definitions for each of them.
 682    The usual definition accepts all pseudo regs; the other rejects them all.
 683    The symbol REG_OK_STRICT causes the latter definition to be used.
 684
 685    Most source files want to accept pseudo regs in the hope that
 686    they will get allocated to the class that the insn wants them to be in.
 687    Some source files that are used after register allocation
 688    need to be strict.  */
 689 #ifndef REG_OK_STRICT
 690 #define REG_MODE_OK_FOR_BASE_P(X, MODE) \
 691   score_regno_mode_ok_for_base_p (REGNO (X), 0)
 692 #else
 693 #define REG_MODE_OK_FOR_BASE_P(X, MODE) \
 694   score_regno_mode_ok_for_base_p (REGNO (X), 1)
 695 #endif
 696
 697 #define REG_OK_FOR_INDEX_P(X) 0
 698
 699 #define LEGITIMATE_CONSTANT_P(X)        1
 700
 701 /* Condition Code Status.  */
 702 #define SELECT_CC_MODE(OP, X, Y)        score_select_cc_mode (OP, X, Y)
 703
 704 /* Return nonzero if SELECT_CC_MODE will never return MODE for a
 705    floating point inequality comparison.  */
 706 #define REVERSIBLE_CC_MODE(MODE)        1
 707
 708 /* Describing Relative Costs of Operations  */
 709 /* Compute extra cost of moving data between one register class and another.  */
 710 #define REGISTER_MOVE_COST(MODE, FROM, TO) \
 711   score_register_move_cost (MODE, FROM, TO)
 712
 713 /* Moves to and from memory are quite expensive */
 714 #define MEMORY_MOVE_COST(MODE, CLASS, TO_P) \
 715   (4 + memory_move_secondary_cost ((MODE), (CLASS), (TO_P)))
 716
 717 /* Try to generate sequences that don't involve branches.  */
 718 #define BRANCH_COST(speed_p, predictable_p) 2
 719
 720 /* Nonzero if access to memory by bytes is slow and undesirable.  */
 721 #define SLOW_BYTE_ACCESS                1
 722
 723 /* Define this macro if it is as good or better to call a constant
 724    function address than to call an address kept in a register.  */
 725 #define NO_FUNCTION_CSE                 1
 726
 727 /* Dividing the Output into Sections (Texts, Data, ...).  */
 728 /* Define the strings to put out for each section in the object file.  */
 729 #define TEXT_SECTION_ASM_OP             "\t.text"
 730 #define DATA_SECTION_ASM_OP             "\t.data"
 731 #define SDATA_SECTION_ASM_OP            "\t.sdata"
 732
 733 #undef  READONLY_DATA_SECTION_ASM_OP
 734 #define READONLY_DATA_SECTION_ASM_OP    "\t.rdata"
 735
 736 /* The Overall Framework of an Assembler File  */
 737 /* How to start an assembler comment.
 738    The leading space is important.  */
 739 #define ASM_COMMENT_START               "#"
 740
 741 /* Output to assembler file text saying following lines
 742    may contain character constants, extra white space, comments, etc.  */
 743 #define ASM_APP_ON                     "#APP\n\t.set volatile\n"
 744
 745 /* Output to assembler file text saying following lines
 746    no longer contain unusual constructs.  */
 747 #define ASM_APP_OFF                     "#NO_APP\n\t.set optimize\n"
 748
 749 /* Output of Uninitialized Variables.  */
 750 /* This says how to define a global common symbol.  */
 751 #define ASM_OUTPUT_ALIGNED_DECL_COMMON(STREAM, DECL, NAME, SIZE, ALIGN)     \
 752   do {                                                                      \
 753     fputs ("\n\t.comm\t", STREAM);                                          \
 754     assemble_name (STREAM, NAME);                                           \
 755     fprintf (STREAM, " , " HOST_WIDE_INT_PRINT_UNSIGNED ", %u\n",           \
 756              SIZE, ALIGN / BITS_PER_UNIT);                                  \
 757   } while (0)
 758
 759 /* This says how to define a local common symbol (i.e., not visible to
 760    linker).  */
 761 #undef ASM_OUTPUT_ALIGNED_LOCAL
 762 #define ASM_OUTPUT_ALIGNED_LOCAL(STREAM, NAME, SIZE, ALIGN)                 \
 763   do {                                                                      \
 764     fputs ("\n\t.lcomm\t", STREAM);                                         \
 765     assemble_name (STREAM, NAME);                                           \
 766     fprintf (STREAM, " , " HOST_WIDE_INT_PRINT_UNSIGNED ", %u\n",           \
 767              SIZE, ALIGN / BITS_PER_UNIT);                                  \
 768   } while (0)
 769
 770 /* Globalizing directive for a label.  */
 771 #define GLOBAL_ASM_OP                   "\t.globl\t"
 772
 773 /* Output and Generation of Labels  */
 774 /* This is how to declare a function name.  The actual work of
 775    emitting the label is moved to function_prologue, so that we can
 776    get the line number correctly emitted before the .ent directive,
 777    and after any .file directives.  Define as empty so that the function
 778    is not declared before the .ent directive elsewhere.  */
 779 #undef ASM_DECLARE_FUNCTION_NAME
 780 #define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL)
 781
 782 #undef ASM_DECLARE_OBJECT_NAME
 783 #define ASM_DECLARE_OBJECT_NAME(STREAM, NAME, DECL)   \
 784   do {                                                \
 785     assemble_name (STREAM, NAME);                     \
 786     fprintf (STREAM, ":\n");                          \
 787   } while (0)
 788
 789 /* This says how to output an external.  It would be possible not to
 790    output anything and let undefined symbol become external. However
 791    the assembler uses length information on externals to allocate in
 792    data/sdata bss/sbss, thereby saving exec time.  */
 793 #undef ASM_OUTPUT_EXTERNAL
 794 #define ASM_OUTPUT_EXTERNAL(STREAM, DECL, NAME) \
 795   score_output_external (STREAM, DECL, NAME)
 796
 797 /* This handles the magic '..CURRENT_FUNCTION' symbol, which means
 798    'the start of the function that this code is output in'.  */
 799 #define ASM_OUTPUT_LABELREF(STREAM, NAME) \
 800   fprintf ((STREAM), "%s", (NAME))
 801
 802 /* Local compiler-generated symbols must have a prefix that the assembler
 803    understands.  */
 804 #define LOCAL_LABEL_PREFIX              (TARGET_SCORE7 ? "." : "$")
 805
 806 #undef ASM_GENERATE_INTERNAL_LABEL
 807 #define ASM_GENERATE_INTERNAL_LABEL(LABEL, PREFIX, NUM) \
 808   sprintf ((LABEL), "*%s%s%ld", (LOCAL_LABEL_PREFIX), (PREFIX), (long) (NUM))
 809
 810 /* Output of Assembler Instructions.  */
 811 #define REGISTER_NAMES                                                    \
 812 { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",                         \
 813   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",                   \
 814   "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",                 \
 815   "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",                 \
 816                                                                           \
 817   "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",                 \
 818   "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",           \
 819                                                                           \
 820   "ceh", "cel", "sr0", "sr1", "sr2", "_arg", "_frame", "",                \
 821   "cr24", "cr25", "cr26", "cr27", "cr28", "cr29", "cr30", "cr31",         \
 822                                                                           \
 823   "c1r0", "c1r1", "c1r2", "c1r3", "c1r4", "c1r5", "c1r6", "c1r7",         \
 824   "c1r8", "c1r9", "c1r10", "c1r11", "c1r12", "c1r13", "c1r14", "c1r15",   \
 825   "c1r16", "c1r17", "c1r18", "c1r19", "c1r20", "c1r21", "c1r22", "c1r23", \
 826   "c1r24", "c1r25", "c1r26", "c1r27", "c1r28", "c1r29", "c1r30", "c1r31", \
 827                                                                           \
 828   "c2r0", "c2r1", "c2r2", "c2r3", "c2r4", "c2r5", "c2r6", "c2r7",         \
 829   "c2r8", "c2r9", "c2r10", "c2r11", "c2r12", "c2r13", "c2r14", "c2r15",   \
 830   "c2r16", "c2r17", "c2r18", "c2r19", "c2r20", "c2r21", "c2r22", "c2r23", \
 831   "c2r24", "c2r25", "c2r26", "c2r27", "c2r28", "c2r29", "c2r30", "c2r31", \
 832                                                                           \
 833   "c3r0", "c3r1", "c3r2", "c3r3", "c3r4", "c3r5", "c3r6", "c3r7",         \
 834   "c3r8", "c3r9", "c3r10", "c3r11", "c3r12", "c3r13", "c3r14", "c3r15",   \
 835   "c3r16", "c3r17", "c3r18", "c3r19", "c3r20", "c3r21", "c3r22", "c3r23", \
 836   "c3r24", "c3r25", "c3r26", "c3r27", "c3r28", "c3r29", "c3r30", "c3r31", \
 837 }
 838
 839 /* Print operand X (an rtx) in assembler syntax to file FILE.  */
 840 #define PRINT_OPERAND(STREAM, X, CODE)  score_print_operand (STREAM, X, CODE)
 841
 842 /* A C expression which evaluates to true if CODE is a valid
 843    punctuation character for use in the `PRINT_OPERAND' macro.  */
 844 #define PRINT_OPERAND_PUNCT_VALID_P(C)  ((C) == '[' || (C) == ']')
 845
 846 /* Print a memory address as an operand to reference that memory location.  */
 847 #define PRINT_OPERAND_ADDRESS(STREAM, X) \
 848   score_print_operand_address (STREAM, X)
 849
 850 /* By default on the S+core, external symbols do not have an underscore
 851    prepended.  */
 852 #define USER_LABEL_PREFIX        ""
 853
 854 /* This is how to output an insn to push a register on the stack.  */
 855 #define ASM_OUTPUT_REG_PUSH(STREAM, REGNO)           \
 856   do {                                               \
 857     if (TARGET_SCORE7)                               \
 858         fprintf (STREAM, "\tpush! %s,[%s]\n",        \
 859                  reg_names[REGNO],                   \
 860                  reg_names[STACK_POINTER_REGNUM]);   \
 861     else if (TARGET_SCORE3)                          \
 862         fprintf (STREAM, "\tpush!\t%s\n",            \
 863                  reg_names[REGNO]);                  \
 864   } while (0)
 865
 866 /* This is how to output an insn to pop a register from the stack.  */
 867 #define ASM_OUTPUT_REG_POP(STREAM, REGNO)            \
 868   do {                                               \
 869     if (TARGET_SCORE7)                               \
 870       fprintf (STREAM, "\tpop! %s,[%s]\n",           \
 871                reg_names[REGNO],                     \
 872                reg_names[STACK_POINTER_REGNUM]);     \
 873     else if (TARGET_SCORE3)                          \
 874       fprintf (STREAM, "\tpop!\t%s\n",               \
 875                reg_names[REGNO]);                    \
 876   } while (0)
 877
 878 /* Output of Dispatch Tables.  */
 879 /* This is how to output an element of a case-vector.  We can make the
 880    entries PC-relative in GP-relative when .gp(d)word is supported.  */
 881 #define ASM_OUTPUT_ADDR_DIFF_ELT(STREAM, BODY, VALUE, REL)                \
 882   do {                                                                    \
 883     if (TARGET_SCORE7)                                                    \
 884       if (flag_pic)                                                       \
 885         fprintf (STREAM, "\t.gpword %sL%d\n", LOCAL_LABEL_PREFIX, VALUE); \
 886       else                                                                \
 887         fprintf (STREAM, "\t.word %sL%d\n", LOCAL_LABEL_PREFIX, VALUE);   \
 888     else if (TARGET_SCORE3)                                               \
 889       {                                                                   \
 890         switch (GET_MODE(BODY))                                           \
 891           {                                                               \
 892           case QImode: /* TBB */                                          \
 893             asm_fprintf (STREAM, "\t.byte\t(%LL%d-%LL%d_tbb)/2\n",        \
 894                          VALUE, REL);                                     \
 895             break;                                                        \
 896           case HImode: /* TBH */                                          \
 897             asm_fprintf (STREAM, "\t.2byte\t(%LL%d-%LL%d_tbb)/2\n",       \
 898                          VALUE, REL);                                     \
 899             break;                                                        \
 900           case SImode:                                                    \
 901             if (flag_pic)                                                 \
 902               fprintf (STREAM, "\t.gpword %sL%d\n", LOCAL_LABEL_PREFIX, VALUE); \
 903             else                                                          \
 904               fprintf (STREAM, "\t.word %sL%d\n", LOCAL_LABEL_PREFIX, VALUE);   \
 905             break;                                                        \
 906           default:                                                        \
 907             gcc_unreachable();                                            \
 908           }                                                               \
 909       }                                                                   \
 910   } while (0)
 911
 912 /* Jump table alignment is explicit in ASM_OUTPUT_CASE_LABEL.  */
 913 #define ADDR_VEC_ALIGN(JUMPTABLE) (GET_MODE (PATTERN (JUMPTABLE)) == SImode ? 2 \
 914                                    : GET_MODE (PATTERN (JUMPTABLE)) == HImode ? 1 : 0)
 915
 916 /* This is how to output a label which precedes a jumptable.  Since
 917    Score3 instructions are 2 bytes, we may need explicit alignment here.  */
 918 #undef  ASM_OUTPUT_CASE_LABEL
 919 #define ASM_OUTPUT_CASE_LABEL(FILE, PREFIX, NUM, JUMPTABLE)             \
 920   do {                                                                  \
 921       if ((TARGET_SCORE7) && GET_MODE (PATTERN (JUMPTABLE)) == SImode)  \
 922         ASM_OUTPUT_ALIGN (FILE, 2);                                     \
 923       (*targetm.asm_out.internal_label) (FILE, PREFIX, NUM);            \
 924   } while (0)
 925
 926 /* Specify the machine mode that this machine uses
 927    for the index in the tablejump instruction.  */
 928 #define CASE_VECTOR_MODE                SImode
 929
 930 #define CASE_VECTOR_PC_RELATIVE         (TARGET_SCORE3)
 931
 932 #define CASE_VECTOR_SHORTEN_MODE(min, max, body)                \
 933    ((min < 0 || max >= 0x2000 || TARGET_SCORE7) ? SImode        \
 934    : (max >= 0x200) ? HImode                                    \
 935    : QImode)
 936
 937 /* This is how to output an element of a case-vector that is absolute.  */
 938 #define ASM_OUTPUT_ADDR_VEC_ELT(STREAM, VALUE) \
 939   fprintf (STREAM, "\t.word %sL%d\n", LOCAL_LABEL_PREFIX, VALUE)
 940
 941 /* Assembler Commands for Exception Regions  */
 942 /* Since the S+core is encoded in the least-significant bit
 943    of the address, mask it off return addresses for purposes of
 944    finding exception handling regions.  */
 945 #define MASK_RETURN_ADDR               constm1_rtx
 946
 947 /* Assembler Commands for Alignment  */
 948 /* This is how to output an assembler line to advance the location
 949    counter by SIZE bytes.  */
 950 #undef ASM_OUTPUT_SKIP
 951 #define ASM_OUTPUT_SKIP(STREAM, SIZE) \
 952   fprintf (STREAM, "\t.space\t"HOST_WIDE_INT_PRINT_UNSIGNED"\n", (SIZE))
 953
 954 /* This is how to output an assembler line
 955    that says to advance the location counter
 956    to a multiple of 2**LOG bytes.  */
 957 #define ASM_OUTPUT_ALIGN(STREAM, LOG) \
 958   fprintf (STREAM, "\t.align\t%d\n", (LOG))
 959
 960 /* Macros Affecting All Debugging Formats.  */
 961 #ifndef PREFERRED_DEBUGGING_TYPE
 962 #define PREFERRED_DEBUGGING_TYPE         DWARF2_DEBUG
 963 #endif
 964
 965 /* Specific Options for DBX Output.  */
 966 #define DBX_DEBUGGING_INFO              1
 967
 968 /* By default, turn on GDB extensions.  */
 969 #define DEFAULT_GDB_EXTENSIONS          1
 970
 971 #define DBX_CONTIN_LENGTH               0
 972
 973 /* File Names in DBX Format.  */
 974 #define DWARF2_DEBUGGING_INFO           1
 975
 976 /* The DWARF 2 CFA column which tracks the return address.  */
 977 #define DWARF_FRAME_RETURN_COLUMN       3
 978
 979 /* Define if operations between registers always perform the operation
 980    on the full register even if a narrower mode is specified.  */
 981 #define WORD_REGISTER_OPERATIONS
 982
 983 /*  All references are zero extended.  */
 984 #define LOAD_EXTEND_OP(MODE)            ZERO_EXTEND
 985
 986 /* Define if loading short immediate values into registers sign extends.  */
 987 #define SHORT_IMMEDIATES_SIGN_EXTEND
 988
 989 /* Max number of bytes we can move from memory to memory
 990    in one reasonably fast instruction.  */
 991 #define MOVE_MAX                        4
 992
 993 /* Define this to be nonzero if shift instructions ignore all but the low-order
 994    few bits.  */
 995 #define SHIFT_COUNT_TRUNCATED           1
 996
 997 /* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits
 998    is done just by pretending it is already truncated.  */
 999 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
1000
1001 /* Specify the machine mode that pointers have.
1002    After generation of rtl, the compiler makes no further distinction
1003    between pointers and any other objects of this machine mode.  */
1004 #define Pmode                           SImode
1005
1006 /* Give call MEMs SImode since it is the "most permissive" mode
1007    for 32-bit targets.  */
1008 #define FUNCTION_MODE                   Pmode
1009
1010 struct GTY ((chain_next ("%h.next"))) extern_list
1011 {
1012   struct extern_list *next;             /* next external  */
1013   const char *name;                     /* name of the external  */
1014   int size;                             /* size in bytes  */
1015 };
1016
1017 extern GTY (()) struct extern_list      *extern_head;