gcc/config/stormy16/stormy16.h

   1 /* Xstormy16 cpu description.
   2    Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007
   3    Free Software Foundation, Inc.
   4    Contributed by Red Hat, Inc.
   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 \f
  23 /* Driver configuration */
  24
  25 /* Defined in svr4.h.  */
  26 #undef ASM_SPEC
  27 #define ASM_SPEC ""
  28
  29 /* For xstormy16:
  30    - If -msim is specified, everything is built and linked as for the sim.
  31    - If -T is specified, that linker script is used, and it should provide
  32      appropriate libraries.
  33    - If neither is specified, everything is built as for the sim, but no
  34      I/O support is assumed.
  35
  36 */
  37 #undef LIB_SPEC
  38 #define LIB_SPEC "-( -lc %{msim:-lsim}%{!msim:%{!T*:-lnosys}} -)"
  39
  40 /* Defined in svr4.h.  */
  41 #undef STARTFILE_SPEC
  42 #define STARTFILE_SPEC "crt0.o%s crti.o%s crtbegin.o%s"
  43
  44 /* Defined in svr4.h.  */
  45 #undef ENDFILE_SPEC
  46 #define ENDFILE_SPEC "crtend.o%s crtn.o%s"
  47
  48 /* Defined in svr4.h for host compilers.  */
  49 /* #define MD_EXEC_PREFIX "" */
  50
  51 /* Defined in svr4.h for host compilers.  */
  52 /* #define MD_STARTFILE_PREFIX "" */
  53
  54 \f
  55 /* Run-time target specifications */
  56
  57 #define TARGET_CPU_CPP_BUILTINS() do {  \
  58   builtin_define_std ("xstormy16");     \
  59   builtin_assert ("machine=xstormy16"); \
  60   builtin_assert ("cpu=xstormy16");     \
  61 } while (0)
  62
  63 #define TARGET_VERSION fprintf (stderr, " (xstormy16 cpu core)");
  64
  65 #define CAN_DEBUG_WITHOUT_FP
  66
  67 \f
  68 /* Storage Layout */
  69
  70 #define BITS_BIG_ENDIAN 1
  71
  72 #define BYTES_BIG_ENDIAN 0
  73
  74 #define WORDS_BIG_ENDIAN 0
  75
  76 #define UNITS_PER_WORD 2
  77
  78 #define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE)                               \
  79 do {                                                                    \
  80   if (GET_MODE_CLASS (MODE) == MODE_INT                                 \
  81       && GET_MODE_SIZE (MODE) < 2)                                      \
  82     (MODE) = HImode;                                                    \
  83 } while (0)
  84
  85 #define PARM_BOUNDARY 16
  86
  87 #define STACK_BOUNDARY 16
  88
  89 #define FUNCTION_BOUNDARY 16
  90
  91 #define BIGGEST_ALIGNMENT 16
  92
  93 /* Defined in svr4.h.  */
  94 /* #define MAX_OFILE_ALIGNMENT */
  95
  96 #define DATA_ALIGNMENT(TYPE, ALIGN)             \
  97   (TREE_CODE (TYPE) == ARRAY_TYPE               \
  98    && TYPE_MODE (TREE_TYPE (TYPE)) == QImode    \
  99    && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
 100
 101 #define CONSTANT_ALIGNMENT(EXP, ALIGN)  \
 102   (TREE_CODE (EXP) == STRING_CST        \
 103    && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
 104
 105 #define STRICT_ALIGNMENT 1
 106
 107 /* Defined in svr4.h.  */
 108 #define PCC_BITFIELD_TYPE_MATTERS 1
 109 \f
 110 /* Layout of Source Language Data Types */
 111
 112 #define INT_TYPE_SIZE 16
 113
 114 #define SHORT_TYPE_SIZE 16
 115
 116 #define LONG_TYPE_SIZE 32
 117
 118 #define LONG_LONG_TYPE_SIZE 64
 119
 120 #define FLOAT_TYPE_SIZE 32
 121
 122 #define DOUBLE_TYPE_SIZE 64
 123
 124 #define LONG_DOUBLE_TYPE_SIZE 64
 125
 126 #define DEFAULT_SIGNED_CHAR 0
 127
 128 /* Defined in svr4.h.  */
 129 #define SIZE_TYPE "unsigned int"
 130
 131 /* Defined in svr4.h.  */
 132 #define PTRDIFF_TYPE "int"
 133
 134 /* Defined in svr4.h, to "long int".  */
 135 /* #define WCHAR_TYPE "long int" */
 136
 137 /* Defined in svr4.h.  */
 138 #undef WCHAR_TYPE_SIZE
 139 #define WCHAR_TYPE_SIZE 32
 140
 141 /* Define this macro if the type of Objective-C selectors should be `int'.
 142
 143    If this macro is not defined, then selectors should have the type `struct
 144    objc_selector *'.  */
 145 /* #define OBJC_INT_SELECTORS */
 146
 147 \f
 148 /* Register Basics */
 149
 150 #define FIRST_PSEUDO_REGISTER 19
 151
 152 #define FIXED_REGISTERS \
 153   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1 }
 154
 155 #define CALL_USED_REGISTERS \
 156   { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1 }
 157
 158 \f
 159 /* Order of allocation of registers */
 160
 161 #define REG_ALLOC_ORDER { 7, 6, 5, 4, 3, 2, 1, 0, 9, 8, 10, 11, 12, 13, 14, 15, 16 }
 162
 163 \f
 164 /* How Values Fit in Registers */
 165
 166 #define HARD_REGNO_NREGS(REGNO, MODE)                           \
 167   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
 168
 169 #define HARD_REGNO_MODE_OK(REGNO, MODE) ((REGNO) != 16 || (MODE) == BImode)
 170
 171 /* A C expression that is nonzero if it is desirable to choose register
 172    allocation so as to avoid move instructions between a value of mode MODE1
 173    and a value of mode MODE2.
 174
 175    If `HARD_REGNO_MODE_OK (R, MODE1)' and `HARD_REGNO_MODE_OK (R, MODE2)' are
 176    ever different for any R, then `MODES_TIEABLE_P (MODE1, MODE2)' must be
 177    zero.  */
 178 #define MODES_TIEABLE_P(MODE1, MODE2) ((MODE1) != BImode && (MODE2) != BImode)
 179
 180 \f
 181 /* Register Classes */
 182
 183 enum reg_class
 184 {
 185   NO_REGS,
 186   R0_REGS,
 187   R1_REGS,
 188   TWO_REGS,
 189   R2_REGS,
 190   EIGHT_REGS,
 191   R8_REGS,
 192   ICALL_REGS,
 193   GENERAL_REGS,
 194   CARRY_REGS,
 195   ALL_REGS,
 196   LIM_REG_CLASSES
 197 };
 198
 199 #define N_REG_CLASSES ((int) LIM_REG_CLASSES)
 200
 201 #define REG_CLASS_NAMES                         \
 202 {                                               \
 203   "NO_REGS",                                    \
 204   "R0_REGS",                                    \
 205   "R1_REGS",                                    \
 206   "TWO_REGS",                                   \
 207   "R2_REGS",                                    \
 208   "EIGHT_REGS",                                 \
 209   "R8_REGS",                                    \
 210   "ICALL_REGS",                                 \
 211   "GENERAL_REGS",                               \
 212   "CARRY_REGS",                                 \
 213   "ALL_REGS"                                    \
 214 }
 215
 216 #define REG_CLASS_CONTENTS                      \
 217 {                                               \
 218   { 0x00000 },                                  \
 219   { 0x00001 },                                  \
 220   { 0x00002 },                                  \
 221   { 0x00003 },                                  \
 222   { 0x00004 },                                  \
 223   { 0x000FF },                                  \
 224   { 0x00100 },                                  \
 225   { 0x00300 },                                  \
 226   { 0x6FFFF },                                  \
 227   { 0x10000 },                                  \
 228   { (1 << FIRST_PSEUDO_REGISTER) - 1 }          \
 229 }
 230
 231 #define REGNO_REG_CLASS(REGNO)                  \
 232   ((REGNO) == 0   ? R0_REGS                     \
 233    : (REGNO) == 1 ? R1_REGS                     \
 234    : (REGNO) == 2 ? R2_REGS                     \
 235    : (REGNO) < 8  ? EIGHT_REGS                  \
 236    : (REGNO) == 8 ? R8_REGS                     \
 237    : (REGNO) == 16 ? CARRY_REGS                 \
 238    : (REGNO) <= 18 ? GENERAL_REGS               \
 239    : ALL_REGS)
 240
 241 #define BASE_REG_CLASS GENERAL_REGS
 242
 243 #define INDEX_REG_CLASS GENERAL_REGS
 244
 245 /*   The following letters are unavailable, due to being used as
 246    constraints:
 247         '0'..'9'
 248         '<', '>'
 249         'E', 'F', 'G', 'H'
 250         'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P'
 251         'Q', 'R', 'S', 'T', 'U'
 252         'V', 'X'
 253         'g', 'i', 'm', 'n', 'o', 'p', 'r', 's' */
 254
 255 #define REG_CLASS_FROM_LETTER(CHAR)             \
 256  (  (CHAR) == 'a' ? R0_REGS                     \
 257   : (CHAR) == 'b' ? R1_REGS                     \
 258   : (CHAR) == 'c' ? R2_REGS                     \
 259   : (CHAR) == 'd' ? R8_REGS                     \
 260   : (CHAR) == 'e' ? EIGHT_REGS                  \
 261   : (CHAR) == 't' ? TWO_REGS                    \
 262   : (CHAR) == 'y' ? CARRY_REGS                  \
 263   : (CHAR) == 'z' ? ICALL_REGS                  \
 264   : NO_REGS)
 265
 266 #define REGNO_OK_FOR_BASE_P(NUM) 1
 267
 268 #define REGNO_OK_FOR_INDEX_P(NUM) REGNO_OK_FOR_BASE_P (NUM)
 269
 270 /* This declaration must be present.  */
 271 #define PREFERRED_RELOAD_CLASS(X, CLASS) \
 272   xstormy16_preferred_reload_class (X, CLASS)
 273
 274 #define PREFERRED_OUTPUT_RELOAD_CLASS(X, CLASS) \
 275   xstormy16_preferred_reload_class (X, CLASS)
 276
 277 /* This chip has the interesting property that only the first eight
 278    registers can be moved to/from memory.  */
 279 #define SECONDARY_RELOAD_CLASS(CLASS, MODE, X)                  \
 280   xstormy16_secondary_reload_class (CLASS, MODE, X)
 281
 282 /* Normally the compiler avoids choosing registers that have been explicitly
 283    mentioned in the rtl as spill registers (these registers are normally those
 284    used to pass parameters and return values).  However, some machines have so
 285    few registers of certain classes that there would not be enough registers to
 286    use as spill registers if this were done.
 287
 288    Define `SMALL_REGISTER_CLASSES' to be an expression with a nonzero value on
 289    these machines.  When this macro has a nonzero value, the compiler allows
 290    registers explicitly used in the rtl to be used as spill registers but
 291    avoids extending the lifetime of these registers.
 292
 293    It is always safe to define this macro with a nonzero value, but if you
 294    unnecessarily define it, you will reduce the amount of optimizations that
 295    can be performed in some cases.  If you do not define this macro with a
 296    nonzero value when it is required, the compiler will run out of spill
 297    registers and print a fatal error message.  For most machines, you should
 298    not define this macro at all.  */
 299 /* #define SMALL_REGISTER_CLASSES */
 300
 301 /* This declaration is required.  */
 302 #define CLASS_MAX_NREGS(CLASS, MODE) \
 303   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
 304
 305 /* If defined, a C expression for a class that contains registers which the
 306    compiler must always access in a mode that is the same size as the mode in
 307    which it loaded the register.
 308
 309    For the example, loading 32-bit integer or floating-point objects into
 310    floating-point registers on the Alpha extends them to 64-bits.  Therefore
 311    loading a 64-bit object and then storing it as a 32-bit object does not
 312    store the low-order 32-bits, as would be the case for a normal register.
 313    Therefore, `alpha.h' defines this macro as `FLOAT_REGS'.  */
 314 /* #define CLASS_CANNOT_CHANGE_SIZE */
 315
 316 #define CONST_OK_FOR_LETTER_P(VALUE, C)                 \
 317   (  (C) == 'I' ? (VALUE) >= 0 && (VALUE) <= 3          \
 318    : (C) == 'J' ? exact_log2 (VALUE) != -1              \
 319    : (C) == 'K' ? exact_log2 (~(VALUE)) != -1           \
 320    : (C) == 'L' ? (VALUE) >= 0 && (VALUE) <= 255        \
 321    : (C) == 'M' ? (VALUE) >= -255 && (VALUE) <= 0       \
 322    : (C) == 'N' ? (VALUE) >= -3 && (VALUE) <= 0         \
 323    : (C) == 'O' ? (VALUE) >= 1 && (VALUE) <= 4          \
 324    : (C) == 'P' ? (VALUE) >= -4 && (VALUE) <= -1        \
 325    : 0 )
 326
 327 #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) 0
 328
 329 #define EXTRA_CONSTRAINT(VALUE, C) \
 330   xstormy16_extra_constraint_p (VALUE, C)
 331
 332 \f
 333 /* Basic Stack Layout */
 334
 335 /* We want to use post-increment instructions to push things on the stack,
 336    because we don't have any pre-increment ones.  */
 337 #define STACK_PUSH_CODE POST_INC
 338
 339 #define FRAME_GROWS_DOWNWARD 0
 340
 341 #define ARGS_GROW_DOWNWARD 1
 342
 343 #define STARTING_FRAME_OFFSET 0
 344
 345 #define FIRST_PARM_OFFSET(FUNDECL) 0
 346
 347 #define RETURN_ADDR_RTX(COUNT, FRAMEADDR)       \
 348   ((COUNT) == 0                                 \
 349    ? gen_rtx_MEM (Pmode, arg_pointer_rtx)       \
 350    : NULL_RTX)
 351
 352 #define INCOMING_RETURN_ADDR_RTX  \
 353    gen_rtx_MEM (SImode, gen_rtx_PLUS (Pmode, stack_pointer_rtx, GEN_INT (-4)))
 354
 355 #define INCOMING_FRAME_SP_OFFSET (xstormy16_interrupt_function_p () ? 6 : 4)
 356
 357 \f
 358 /* Register That Address the Stack Frame.  */
 359
 360 #define STACK_POINTER_REGNUM 15
 361
 362 #define FRAME_POINTER_REGNUM 17
 363
 364 #define HARD_FRAME_POINTER_REGNUM 13
 365
 366 #define ARG_POINTER_REGNUM 18
 367
 368 #define STATIC_CHAIN_REGNUM 1
 369
 370 \f
 371 /* Eliminating the Frame Pointer and the Arg Pointer */
 372
 373 #define FRAME_POINTER_REQUIRED 0
 374
 375 #define ELIMINABLE_REGS                                 \
 376 {                                                       \
 377   {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM},         \
 378   {FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM},    \
 379   {ARG_POINTER_REGNUM,   STACK_POINTER_REGNUM},         \
 380   {ARG_POINTER_REGNUM,   HARD_FRAME_POINTER_REGNUM},    \
 381 }
 382
 383 #define CAN_ELIMINATE(FROM, TO)                                         \
 384  ((FROM) == ARG_POINTER_REGNUM && (TO) == STACK_POINTER_REGNUM          \
 385   ? ! frame_pointer_needed                                              \
 386   : 1)
 387
 388 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
 389   (OFFSET) = xstormy16_initial_elimination_offset (FROM, TO)
 390
 391 \f
 392 /* Passing Function Arguments on the Stack */
 393
 394 #define PUSH_ROUNDING(BYTES) (((BYTES) + 1) & ~1)
 395
 396 #define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACK_SIZE) 0
 397
 398 \f
 399 /* Function Arguments in Registers */
 400
 401 #define NUM_ARGUMENT_REGISTERS 6
 402 #define FIRST_ARGUMENT_REGISTER 2
 403
 404 #define XSTORMY16_WORD_SIZE(TYPE, MODE)                         \
 405   ((((TYPE) ? int_size_in_bytes (TYPE) : GET_MODE_SIZE (MODE))  \
 406     + 1)                                                        \
 407    / 2)
 408
 409 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
 410         xstormy16_function_arg (CUM, MODE, TYPE, NAMED)
 411
 412 /* For this platform, the value of CUMULATIVE_ARGS is the number of words
 413    of arguments that have been passed in registers so far.  */
 414 #define CUMULATIVE_ARGS int
 415
 416 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT, N_NAMED_ARGS) \
 417   (CUM) = 0
 418
 419 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)                    \
 420   ((CUM) = xstormy16_function_arg_advance (CUM, MODE, TYPE, NAMED))
 421
 422 #define FUNCTION_ARG_REGNO_P(REGNO)                                     \
 423   ((REGNO) >= FIRST_ARGUMENT_REGISTER                                   \
 424    && (REGNO) < FIRST_ARGUMENT_REGISTER + NUM_ARGUMENT_REGISTERS)
 425
 426 \f
 427 /* How Scalar Function Values are Returned */
 428
 429 /* The number of the hard register that is used to return a scalar value from a
 430    function call.  */
 431 #define RETURN_VALUE_REGNUM     FIRST_ARGUMENT_REGISTER
 432
 433 #define FUNCTION_VALUE(VALTYPE, FUNC) \
 434   xstormy16_function_value (VALTYPE, FUNC)
 435
 436 #define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, RETURN_VALUE_REGNUM)
 437
 438 #define FUNCTION_VALUE_REGNO_P(REGNO) ((REGNO) == RETURN_VALUE_REGNUM)
 439
 440 \f
 441 /* Function Entry and Exit */
 442
 443 #define EPILOGUE_USES(REGNO) \
 444   xstormy16_epilogue_uses (REGNO)
 445
 446 \f
 447 /* Generating Code for Profiling.  */
 448
 449 /* This declaration must be present, but it can be an abort if profiling is
 450    not implemented.  */
 451
 452 #define FUNCTION_PROFILER(FILE, LABELNO) xstormy16_function_profiler ()
 453
 454 \f
 455 /* If the target has particular reasons why a function cannot be inlined,
 456    it may define the TARGET_CANNOT_INLINE_P.  This macro takes one argument,
 457    the DECL describing the function.  The function should NULL if the function
 458    *can* be inlined.  Otherwise it should return a pointer to a string containing
 459    a message describing why the function could not be inlined.  The message will
 460    displayed if the '-Winline' command line switch has been given.  If the message
 461    contains a '%s' sequence, this will be replaced by the name of the function.  */
 462 /* #define TARGET_CANNOT_INLINE_P(FN_DECL) xstormy16_cannot_inline_p (FN_DECL) */
 463 \f
 464 /* Implementing the Varargs Macros.  */
 465
 466 /* Implement the stdarg/varargs va_start macro.  STDARG_P is nonzero if this
 467    is stdarg.h instead of varargs.h.  VALIST is the tree of the va_list
 468    variable to initialize.  NEXTARG is the machine independent notion of the
 469    'next' argument after the variable arguments.  If not defined, a standard
 470    implementation will be defined that works for arguments passed on the stack.  */
 471 #define EXPAND_BUILTIN_VA_START(VALIST, NEXTARG) \
 472   xstormy16_expand_builtin_va_start (VALIST, NEXTARG)
 473 \f
 474 /* Trampolines for Nested Functions.  */
 475
 476 #define TRAMPOLINE_SIZE 8
 477
 478 #define TRAMPOLINE_ALIGNMENT 16
 479
 480 #define INITIALIZE_TRAMPOLINE(ADDR, FNADDR, STATIC_CHAIN) \
 481   xstormy16_initialize_trampoline (ADDR, FNADDR, STATIC_CHAIN)
 482
 483 \f
 484 /* Define this macro to override the type used by the library routines to pick
 485    up arguments of type `float'.  (By default, they use a union of `float' and
 486    `int'.)
 487
 488    The obvious choice would be `float'--but that won't work with traditional C
 489    compilers that expect all arguments declared as `float' to arrive as
 490    `double'.  To avoid this conversion, the library routines ask for the value
 491    as some other type and then treat it as a `float'.  */
 492 /* #define FLOAT_ARG_TYPE */
 493
 494 /* Define this macro to override the way library routines redesignate a `float'
 495    argument as a `float' instead of the type it was passed as.  The default is
 496    an expression which takes the `float' field of the union.  */
 497 /* #define FLOATIFY(PASSED_VALUE) */
 498
 499 /* Define this macro to override the type used by the library routines to
 500    return values that ought to have type `float'.  (By default, they use
 501    `int'.)
 502
 503    The obvious choice would be `float'--but that won't work with traditional C
 504    compilers gratuitously convert values declared as `float' into `double'.  */
 505 /* #define FLOAT_VALUE_TYPE */
 506
 507 /* Define this macro to override the way the value of a `float'-returning
 508    library routine should be packaged in order to return it.  These functions
 509    are actually declared to return type `FLOAT_VALUE_TYPE' (normally `int').
 510
 511    These values can't be returned as type `float' because traditional C
 512    compilers would gratuitously convert the value to a `double'.
 513
 514    A local variable named `intify' is always available when the macro `INTIFY'
 515    is used.  It is a union of a `float' field named `f' and a field named `i'
 516    whose type is `FLOAT_VALUE_TYPE' or `int'.
 517
 518    If you don't define this macro, the default definition works by copying the
 519    value through that union.  */
 520 /* #define INTIFY(FLOAT_VALUE) */
 521
 522 /* Define this macro as the name of the data type corresponding to `SImode' in
 523    the system's own C compiler.
 524
 525    You need not define this macro if that type is `long int', as it usually is.  */
 526 /* #define nongcc_SI_type */
 527
 528 /* Define this macro as the name of the data type corresponding to the
 529    word_mode in the system's own C compiler.
 530
 531    You need not define this macro if that type is `long int', as it usually is.  */
 532 /* #define nongcc_word_type */
 533
 534 /* Define these macros to supply explicit C statements to carry out various
 535    arithmetic operations on types `float' and `double' in the library routines
 536    in `libgcc1.c'.  See that file for a full list of these macros and their
 537    arguments.
 538
 539    On most machines, you don't need to define any of these macros, because the
 540    C compiler that comes with the system takes care of doing them.  */
 541 /* #define perform_...  */
 542
 543 \f
 544 /* Addressing Modes */
 545
 546 #define HAVE_POST_INCREMENT 1
 547
 548 #define HAVE_PRE_DECREMENT 1
 549
 550 #define CONSTANT_ADDRESS_P(X) CONSTANT_P (X)
 551
 552 #define MAX_REGS_PER_ADDRESS 1
 553
 554 #ifdef REG_OK_STRICT
 555 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL)        \
 556 do {                                                    \
 557   if (xstormy16_legitimate_address_p (MODE, X, 1))      \
 558     goto LABEL;                                         \
 559 } while (0)
 560 #else
 561 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL)        \
 562 do {                                                    \
 563   if (xstormy16_legitimate_address_p (MODE, X, 0))      \
 564     goto LABEL;                                         \
 565 } while (0)
 566 #endif
 567
 568 #ifdef REG_OK_STRICT
 569 #define REG_OK_FOR_BASE_P(X)                                               \
 570   (REGNO_OK_FOR_BASE_P (REGNO (X)) && (REGNO (X) < FIRST_PSEUDO_REGISTER))
 571 #else
 572 #define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X))
 573 #endif
 574
 575 #define REG_OK_FOR_INDEX_P(X) REG_OK_FOR_BASE_P (X)
 576
 577 /* On this chip, this is true if the address is valid with an offset
 578    of 0 but not of 6, because in that case it cannot be used as an
 579    address for DImode or DFmode, or if the address is a post-increment
 580    or pre-decrement address.
 581 */
 582 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL)                        \
 583   if (xstormy16_mode_dependent_address_p (ADDR))                                \
 584     goto LABEL
 585
 586 #define LEGITIMATE_CONSTANT_P(X) 1
 587
 588 \f
 589 /* Describing Relative Costs of Operations */
 590
 591 #define REGISTER_MOVE_COST(MODE, FROM, TO) 2
 592
 593 #define MEMORY_MOVE_COST(M,C,I) (5 + memory_move_secondary_cost (M, C, I))
 594
 595 #define BRANCH_COST 5
 596
 597 #define SLOW_BYTE_ACCESS 0
 598
 599 #define NO_FUNCTION_CSE
 600
 601 \f
 602 /* Dividing the output into sections.  */
 603
 604 #define TEXT_SECTION_ASM_OP ".text"
 605
 606 #define DATA_SECTION_ASM_OP ".data"
 607
 608 #define BSS_SECTION_ASM_OP "\t.section\t.bss"
 609
 610 /* Define the pseudo-ops used to switch to the .ctors and .dtors sections.
 611    There are no shared libraries on this target so these sections need
 612    not be writable.
 613
 614    Defined in elfos.h.  */
 615
 616 #undef CTORS_SECTION_ASM_OP
 617 #undef DTORS_SECTION_ASM_OP
 618 #define CTORS_SECTION_ASM_OP    "\t.section\t.ctors,\"a\""
 619 #define DTORS_SECTION_ASM_OP    "\t.section\t.dtors,\"a\""
 620
 621 #define TARGET_ASM_INIT_SECTIONS xstormy16_asm_init_sections
 622
 623 #define JUMP_TABLES_IN_TEXT_SECTION 1
 624 \f
 625 /* The Overall Framework of an Assembler File.  */
 626
 627 #define ASM_COMMENT_START ";"
 628
 629 #define ASM_APP_ON "#APP\n"
 630
 631 #define ASM_APP_OFF "#NO_APP\n"
 632 \f
 633 /* Output of Data.  */
 634
 635 #define IS_ASM_LOGICAL_LINE_SEPARATOR(C) ((C) == '|')
 636
 637 #define ASM_OUTPUT_ALIGNED_DECL_COMMON(STREAM, DECL, NAME, SIZE, ALIGNMENT) \
 638   xstormy16_asm_output_aligned_common (STREAM, DECL, NAME, SIZE, ALIGNMENT, 1)
 639 #define ASM_OUTPUT_ALIGNED_DECL_LOCAL(STREAM, DECL, NAME, SIZE, ALIGNMENT) \
 640   xstormy16_asm_output_aligned_common (STREAM, DECL, NAME, SIZE, ALIGNMENT, 0)
 641
 642 \f
 643 /* Output and Generation of Labels.  */
 644 #define SYMBOL_FLAG_XSTORMY16_BELOW100  (SYMBOL_FLAG_MACH_DEP << 0)
 645
 646 #define ASM_OUTPUT_SYMBOL_REF(STREAM, SYMBOL)                           \
 647   do {                                                                  \
 648     const char *rn = XSTR (SYMBOL, 0);                                  \
 649     if (SYMBOL_REF_FUNCTION_P (SYMBOL))                                 \
 650       ASM_OUTPUT_LABEL_REF ((STREAM), rn);                              \
 651     else                                                                \
 652       assemble_name (STREAM, rn);                                       \
 653   } while (0)
 654
 655 #define ASM_OUTPUT_LABEL_REF(STREAM, NAME)      \
 656 do  {                                           \
 657   fputs ("@fptr(", STREAM);                     \
 658   assemble_name (STREAM, NAME);                 \
 659   fputc (')', STREAM);                          \
 660 } while (0)
 661
 662 /* Globalizing directive for a label.  */
 663 #define GLOBAL_ASM_OP "\t.globl "
 664
 665 \f
 666 /* Macros Controlling Initialization Routines.  */
 667
 668 /* When you are using special sections for
 669    initialization and termination functions, this macro also controls how
 670    `crtstuff.c' and `libgcc2.c' arrange to run the initialization functions.
 671
 672    Defined in svr4.h.  */
 673 /* #define INIT_SECTION_ASM_OP */
 674
 675 /* Define this macro as a C statement to output on the stream STREAM the
 676    assembler code to arrange to call the function named NAME at initialization
 677    time.
 678
 679    Assume that NAME is the name of a C function generated automatically by the
 680    compiler.  This function takes no arguments.  Use the function
 681    `assemble_name' to output the name NAME; this performs any system-specific
 682    syntactic transformations such as adding an underscore.
 683
 684    If you don't define this macro, nothing special is output to arrange to call
 685    the function.  This is correct when the function will be called in some
 686    other manner--for example, by means of the `collect2' program, which looks
 687    through the symbol table to find these functions by their names.
 688
 689    Defined in svr4.h.  */
 690 /* #define ASM_OUTPUT_CONSTRUCTOR(STREAM, NAME) */
 691
 692 /* This is like `ASM_OUTPUT_CONSTRUCTOR' but used for termination functions
 693    rather than initialization functions.
 694
 695    Defined in svr4.h.  */
 696 /* #define ASM_OUTPUT_DESTRUCTOR(STREAM, NAME) */
 697
 698 /* Define this macro if the system uses ELF format object files.
 699
 700    Defined in svr4.h.  */
 701 /* #define OBJECT_FORMAT_ELF */
 702
 703 \f
 704 /* Output of Assembler Instructions.  */
 705
 706 #define REGISTER_NAMES                                                  \
 707 { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10",    \
 708   "r11", "r12", "r13", "psw", "sp", "carry", "fp", "ap" }
 709
 710 #define ADDITIONAL_REGISTER_NAMES               \
 711   { { "r14", 14 },                              \
 712     { "r15", 15 } }
 713
 714 #define PRINT_OPERAND(STREAM, X, CODE) xstormy16_print_operand (STREAM, X, CODE)
 715
 716 #define PRINT_OPERAND_ADDRESS(STREAM, X) xstormy16_print_operand_address (STREAM, X)
 717
 718 /* USER_LABEL_PREFIX is defined in svr4.h.  */
 719 #define REGISTER_PREFIX ""
 720 #define LOCAL_LABEL_PREFIX "."
 721 #define USER_LABEL_PREFIX ""
 722 #define IMMEDIATE_PREFIX "#"
 723
 724 #define ASM_OUTPUT_REG_PUSH(STREAM, REGNO) \
 725   fprintf (STREAM, "\tpush %d\n", REGNO)
 726
 727 #define ASM_OUTPUT_REG_POP(STREAM, REGNO) \
 728   fprintf (STREAM, "\tpop %d\n", REGNO)
 729
 730 \f
 731 /* Output of dispatch tables.  */
 732
 733 /* This port does not use the ASM_OUTPUT_ADDR_VEC_ELT macro, because
 734    this could cause label alignment to appear between the 'br' and the table,
 735    which would be bad.  Instead, it controls the output of the table
 736    itself.  */
 737 #define ASM_OUTPUT_ADDR_VEC(LABEL, BODY) \
 738   xstormy16_output_addr_vec (file, LABEL, BODY)
 739
 740 /* Alignment for ADDR_VECs is the same as for code.  */
 741 #define ADDR_VEC_ALIGN(ADDR_VEC) 1
 742
 743 \f
 744 /* Assembler Commands for Exception Regions.  */
 745
 746 #define DWARF2_UNWIND_INFO 0
 747
 748 /* Don't use __builtin_setjmp for unwinding, since it's tricky to get
 749    at the high 16 bits of an address.  */
 750 #define DONT_USE_BUILTIN_SETJMP
 751 #define JMP_BUF_SIZE  8
 752 \f
 753 /* Assembler Commands for Alignment.  */
 754
 755 #define ASM_OUTPUT_ALIGN(STREAM, POWER) \
 756   fprintf ((STREAM), "\t.p2align %d\n", (POWER))
 757
 758 \f
 759 /* Macros Affecting all Debug Formats.  */
 760
 761 /* Defined in svr4.h.  */
 762 #undef PREFERRED_DEBUGGING_TYPE
 763 #define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG
 764
 765 \f
 766 /* Macros for SDB and Dwarf Output.  */
 767
 768 /* Define this macro if addresses in Dwarf 2 debugging info should not
 769    be the same size as pointers on the target architecture.  The
 770    macro's value should be the size, in bytes, to use for addresses in
 771    the debugging info.
 772
 773    Some architectures use word addresses to refer to code locations,
 774    but Dwarf 2 info always uses byte addresses.  On such machines,
 775    Dwarf 2 addresses need to be larger than the architecture's
 776    pointers.  */
 777 #define DWARF2_ADDR_SIZE 4
 778
 779 \f
 780 /* Miscellaneous Parameters.  */
 781
 782 #define CASE_VECTOR_MODE SImode
 783
 784 #define WORD_REGISTER_OPERATIONS
 785
 786 #define LOAD_EXTEND_OP(MODE) ZERO_EXTEND
 787
 788 #define MOVE_MAX 2
 789
 790 #define SHIFT_COUNT_TRUNCATED 1
 791
 792 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
 793
 794 #define Pmode HImode
 795
 796 #define FUNCTION_MODE HImode
 797
 798 #define NO_IMPLICIT_EXTERN_C
 799
 800 /* Defined in svr4.h.  */
 801 #define HANDLE_SYSV_PRAGMA 1
 802
 803 /* Define this if the target system supports the function `atexit' from the
 804    ANSI C standard.  If this is not defined, and `INIT_SECTION_ASM_OP' is not
 805    defined, a default `exit' function will be provided to support C++.
 806
 807    Defined by svr4.h */
 808 /* #define HAVE_ATEXIT */
 809
 810 /* A C statement which is executed by the Haifa scheduler after it has scheduled
 811    an insn from the ready list.  FILE is either a null pointer, or a stdio stream
 812    to write any debug output to.  VERBOSE is the verbose level provided by
 813    -fsched-verbose-<n>.  INSN is the instruction that was scheduled.  MORE is the
 814    number of instructions that can be issued in the current cycle.  This macro
 815    is responsible for updating the value of MORE (typically by (MORE)--).  */
 816 /* #define MD_SCHED_VARIABLE_ISSUE (FILE, VERBOSE, INSN, MORE) */
 817
 818 \f
 819 /* Define the information needed to generate branch and scc insns.  This is
 820    stored from the compare operation.  Note that we can't use "rtx" here
 821    since it hasn't been defined!  */
 822
 823 extern struct rtx_def *xstormy16_compare_op0, *xstormy16_compare_op1;
 824
 825 /* End of xstormy16.h */