gcc/config/stormy16/stormy16.h

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