gcc/config/stormy16/stormy16.h

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