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 /* Build up the stdarg/varargs va_list type tree, assigning it to NODE.  If not
 500    defined, it is assumed that va_list is a void * pointer.  */
 501 #define BUILD_VA_LIST_TYPE(NODE) \
 502   ((NODE) = xstormy16_build_va_list ())
 503
 504 /* Implement the stdarg/varargs va_start macro.  STDARG_P is nonzero if this
 505    is stdarg.h instead of varargs.h.  VALIST is the tree of the va_list
 506    variable to initialize.  NEXTARG is the machine independent notion of the
 507    'next' argument after the variable arguments.  If not defined, a standard
 508    implementation will be defined that works for arguments passed on the stack.  */
 509 #define EXPAND_BUILTIN_VA_START(VALIST, NEXTARG) \
 510   xstormy16_expand_builtin_va_start (VALIST, NEXTARG)
 511
 512 /* Implement the stdarg/varargs va_arg macro.  VALIST is the variable of type
 513    va_list as a tree, TYPE is the type passed to va_arg.  */
 514 #define EXPAND_BUILTIN_VA_ARG(VALIST, TYPE) \
 515   xstormy16_expand_builtin_va_arg (VALIST, TYPE)
 516
 517 /* Implement the stdarg/varargs va_end macro.  VALIST is the variable of type
 518    va_list as a tree.  */
 519 /* #define EXPAND_BUILTIN_VA_END(VALIST) */
 520
 521 \f
 522 /* Trampolines for Nested Functions.  */
 523
 524 #define TRAMPOLINE_SIZE 8
 525
 526 #define TRAMPOLINE_ALIGNMENT 16
 527
 528 #define INITIALIZE_TRAMPOLINE(ADDR, FNADDR, STATIC_CHAIN) \
 529   xstormy16_initialize_trampoline (ADDR, FNADDR, STATIC_CHAIN)
 530
 531 \f
 532 /* Implicit Calls to Library Routines */
 533
 534 #define TARGET_MEM_FUNCTIONS
 535
 536 /* Define this macro to override the type used by the library routines to pick
 537    up arguments of type `float'.  (By default, they use a union of `float' and
 538    `int'.)
 539
 540    The obvious choice would be `float'--but that won't work with traditional C
 541    compilers that expect all arguments declared as `float' to arrive as
 542    `double'.  To avoid this conversion, the library routines ask for the value
 543    as some other type and then treat it as a `float'.
 544
 545    On some systems, no other type will work for this.  For these systems, you
 546    must use `LIBGCC_NEEDS_DOUBLE' instead, to force conversion of the values
 547    `double' before they are passed.  */
 548 /* #define FLOAT_ARG_TYPE */
 549
 550 /* Define this macro to override the way library routines redesignate a `float'
 551    argument as a `float' instead of the type it was passed as.  The default is
 552    an expression which takes the `float' field of the union.  */
 553 /* #define FLOATIFY(PASSED_VALUE) */
 554
 555 /* Define this macro to override the type used by the library routines to
 556    return values that ought to have type `float'.  (By default, they use
 557    `int'.)
 558
 559    The obvious choice would be `float'--but that won't work with traditional C
 560    compilers gratuitously convert values declared as `float' into `double'.  */
 561 /* #define FLOAT_VALUE_TYPE */
 562
 563 /* Define this macro to override the way the value of a `float'-returning
 564    library routine should be packaged in order to return it.  These functions
 565    are actually declared to return type `FLOAT_VALUE_TYPE' (normally `int').
 566
 567    These values can't be returned as type `float' because traditional C
 568    compilers would gratuitously convert the value to a `double'.
 569
 570    A local variable named `intify' is always available when the macro `INTIFY'
 571    is used.  It is a union of a `float' field named `f' and a field named `i'
 572    whose type is `FLOAT_VALUE_TYPE' or `int'.
 573
 574    If you don't define this macro, the default definition works by copying the
 575    value through that union.  */
 576 /* #define INTIFY(FLOAT_VALUE) */
 577
 578 /* Define this macro as the name of the data type corresponding to `SImode' in
 579    the system's own C compiler.
 580
 581    You need not define this macro if that type is `long int', as it usually is.  */
 582 /* #define nongcc_SI_type */
 583
 584 /* Define this macro as the name of the data type corresponding to the
 585    word_mode in the system's own C compiler.
 586
 587    You need not define this macro if that type is `long int', as it usually is.  */
 588 /* #define nongcc_word_type */
 589
 590 /* Define these macros to supply explicit C statements to carry out various
 591    arithmetic operations on types `float' and `double' in the library routines
 592    in `libgcc1.c'.  See that file for a full list of these macros and their
 593    arguments.
 594
 595    On most machines, you don't need to define any of these macros, because the
 596    C compiler that comes with the system takes care of doing them.  */
 597 /* #define perform_...  */
 598
 599 \f
 600 /* Addressing Modes */
 601
 602 #define HAVE_POST_INCREMENT 1
 603
 604 #define HAVE_PRE_DECREMENT 1
 605
 606 #define CONSTANT_ADDRESS_P(X) CONSTANT_P (X)
 607
 608 #define MAX_REGS_PER_ADDRESS 1
 609
 610 #ifdef REG_OK_STRICT
 611 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL)        \
 612 do {                                                    \
 613   if (xstormy16_legitimate_address_p (MODE, X, 1))      \
 614     goto LABEL;                                         \
 615 } while (0)
 616 #else
 617 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL)        \
 618 do {                                                    \
 619   if (xstormy16_legitimate_address_p (MODE, X, 0))      \
 620     goto LABEL;                                         \
 621 } while (0)
 622 #endif
 623
 624 #ifdef REG_OK_STRICT
 625 #define REG_OK_FOR_BASE_P(X)                                               \
 626   (REGNO_OK_FOR_BASE_P (REGNO (X)) && (REGNO (X) < FIRST_PSEUDO_REGISTER))
 627 #else
 628 #define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X))
 629 #endif
 630
 631 #define REG_OK_FOR_INDEX_P(X) REG_OK_FOR_BASE_P (X)
 632
 633 #define LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN)
 634
 635 /* On this chip, this is true if the address is valid with an offset
 636    of 0 but not of 6, because in that case it cannot be used as an
 637    address for DImode or DFmode, or if the address is a post-increment
 638    or pre-decrement address.
 639 */
 640 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL)                        \
 641   if (xstormy16_mode_dependent_address_p (ADDR))                                \
 642     goto LABEL
 643
 644 #define LEGITIMATE_CONSTANT_P(X) 1
 645
 646 \f
 647 /* Describing Relative Costs of Operations */
 648
 649 #define REGISTER_MOVE_COST(MODE, FROM, TO) 2
 650
 651 #define MEMORY_MOVE_COST(M,C,I) (5 + memory_move_secondary_cost (M, C, I))
 652
 653 #define BRANCH_COST 5
 654
 655 #define SLOW_BYTE_ACCESS 0
 656
 657 #define NO_FUNCTION_CSE
 658
 659 #define NO_RECURSIVE_FUNCTION_CSE
 660
 661 \f
 662 /* Dividing the output into sections.  */
 663
 664 #define TEXT_SECTION_ASM_OP ".text"
 665
 666 #define DATA_SECTION_ASM_OP ".data"
 667
 668 #define BSS_SECTION_ASM_OP "\t.section\t.bss"
 669
 670 /* Define the pseudo-ops used to switch to the .ctors and .dtors sections.
 671    There are no shared libraries on this target so these sections need
 672    not be writable.
 673
 674    Defined in elfos.h.  */
 675
 676 #undef CTORS_SECTION_ASM_OP
 677 #undef DTORS_SECTION_ASM_OP
 678 #define CTORS_SECTION_ASM_OP    "\t.section\t.ctors,\"a\""
 679 #define DTORS_SECTION_ASM_OP    "\t.section\t.dtors,\"a\""
 680
 681 #define JUMP_TABLES_IN_TEXT_SECTION 1
 682
 683 \f
 684 /* The Overall Framework of an Assembler File.  */
 685
 686 #define ASM_COMMENT_START ";"
 687
 688 #define ASM_APP_ON "#APP\n"
 689
 690 #define ASM_APP_OFF "#NO_APP\n"
 691
 692 /* A C statement to output something to the assembler file to switch to section
 693    NAME for object DECL which is either a `FUNCTION_DECL', a `VAR_DECL' or
 694    `NULL_TREE'.  Some target formats do not support arbitrary sections.  Do not
 695    define this macro in such cases.
 696
 697    At present this macro is only used to support section attributes.  When this
 698    macro is undefined, section attributes are disabled.
 699
 700    Defined in svr4.h.  */
 701 /* #define ASM_OUTPUT_SECTION_NAME(STREAM, DECL, NAME) */
 702
 703 \f
 704 /* Output of Data.  */
 705
 706 #define IS_ASM_LOGICAL_LINE_SEPARATOR(C) ((C) == '|')
 707
 708 \f
 709 /* Output and Generation of Labels.  */
 710
 711 #define ASM_OUTPUT_SYMBOL_REF(STREAM, SYMBOL)                           \
 712   do {                                                                  \
 713     if (SYMBOL_REF_FUNCTION_P (SYMBOL))                                 \
 714       ASM_OUTPUT_LABEL_REF ((STREAM), XSTR (SYMBOL, 0));                \
 715     else                                                                \
 716       assemble_name (STREAM, XSTR (SYMBOL, 0));                         \
 717   } while (0)
 718
 719 #define ASM_OUTPUT_LABEL_REF(STREAM, NAME)      \
 720 do  {                                           \
 721   fputs ("@fptr(", STREAM);                     \
 722   assemble_name (STREAM, NAME);                 \
 723   fputc (')', STREAM);                          \
 724 } while (0)
 725
 726 /* Globalizing directive for a label.  */
 727 #define GLOBAL_ASM_OP "\t.globl "
 728
 729 \f
 730 /* Macros Controlling Initialization Routines.  */
 731
 732 /* When you are using special sections for
 733    initialization and termination functions, this macro also controls how
 734    `crtstuff.c' and `libgcc2.c' arrange to run the initialization functions.
 735
 736    Defined in svr4.h.  */
 737 /* #define INIT_SECTION_ASM_OP */
 738
 739 /* Define this macro as a C statement to output on the stream STREAM the
 740    assembler code to arrange to call the function named NAME at initialization
 741    time.
 742
 743    Assume that NAME is the name of a C function generated automatically by the
 744    compiler.  This function takes no arguments.  Use the function
 745    `assemble_name' to output the name NAME; this performs any system-specific
 746    syntactic transformations such as adding an underscore.
 747
 748    If you don't define this macro, nothing special is output to arrange to call
 749    the function.  This is correct when the function will be called in some
 750    other manner--for example, by means of the `collect2' program, which looks
 751    through the symbol table to find these functions by their names.
 752
 753    Defined in svr4.h.  */
 754 /* #define ASM_OUTPUT_CONSTRUCTOR(STREAM, NAME) */
 755
 756 /* This is like `ASM_OUTPUT_CONSTRUCTOR' but used for termination functions
 757    rather than initialization functions.
 758
 759    Defined in svr4.h.  */
 760 /* #define ASM_OUTPUT_DESTRUCTOR(STREAM, NAME) */
 761
 762 /* Define this macro if the system uses ELF format object files.
 763
 764    Defined in svr4.h.  */
 765 /* #define OBJECT_FORMAT_ELF */
 766
 767 \f
 768 /* Output of Assembler Instructions.  */
 769
 770 #define REGISTER_NAMES                                                  \
 771 { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10",    \
 772   "r11", "r12", "r13", "psw", "sp", "carry", "fp", "ap" }
 773
 774 #define ADDITIONAL_REGISTER_NAMES               \
 775   { { "r14", 14 },                              \
 776     { "r15", 15 } }
 777
 778 #define PRINT_OPERAND(STREAM, X, CODE) xstormy16_print_operand (STREAM, X, CODE)
 779
 780 #define PRINT_OPERAND_ADDRESS(STREAM, X) xstormy16_print_operand_address (STREAM, X)
 781
 782 /* USER_LABEL_PREFIX is defined in svr4.h.  */
 783 #define REGISTER_PREFIX ""
 784 #define LOCAL_LABEL_PREFIX "."
 785 #define USER_LABEL_PREFIX ""
 786 #define IMMEDIATE_PREFIX "#"
 787
 788 #define ASM_OUTPUT_REG_PUSH(STREAM, REGNO) \
 789   fprintf (STREAM, "\tpush %d\n", REGNO)
 790
 791 #define ASM_OUTPUT_REG_POP(STREAM, REGNO) \
 792   fprintf (STREAM, "\tpop %d\n", REGNO)
 793
 794 \f
 795 /* Output of dispatch tables.  */
 796
 797 /* This port does not use the ASM_OUTPUT_ADDR_VEC_ELT macro, because
 798    this could cause label alignment to appear between the 'br' and the table,
 799    which would be bad.  Instead, it controls the output of the table
 800    itself.  */
 801 #define ASM_OUTPUT_ADDR_VEC(LABEL, BODY) \
 802   xstormy16_output_addr_vec (file, LABEL, BODY)
 803
 804 /* Alignment for ADDR_VECs is the same as for code.  */
 805 #define ADDR_VEC_ALIGN(ADDR_VEC) 1
 806
 807 \f
 808 /* Assembler Commands for Exception Regions.  */
 809
 810 #define DWARF2_UNWIND_INFO 0
 811
 812 /* Don't use __builtin_setjmp for unwinding, since it's tricky to get
 813    at the high 16 bits of an address.  */
 814 #define DONT_USE_BUILTIN_SETJMP
 815 #define JMP_BUF_SIZE  8
 816 \f
 817 /* Assembler Commands for Alignment.  */
 818
 819 #define ASM_OUTPUT_ALIGN(STREAM, POWER) \
 820   fprintf ((STREAM), "\t.p2align %d\n", (POWER))
 821
 822 \f
 823 /* Macros Affecting all Debug Formats.  */
 824
 825 /* Defined in svr4.h.  */
 826 #undef PREFERRED_DEBUGGING_TYPE
 827 #define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG
 828
 829 \f
 830 /* Macros for SDB and Dwarf Output.  */
 831
 832 /* Define this macro if addresses in Dwarf 2 debugging info should not
 833    be the same size as pointers on the target architecture.  The
 834    macro's value should be the size, in bytes, to use for addresses in
 835    the debugging info.
 836
 837    Some architectures use word addresses to refer to code locations,
 838    but Dwarf 2 info always uses byte addresses.  On such machines,
 839    Dwarf 2 addresses need to be larger than the architecture's
 840    pointers.  */
 841 #define DWARF2_ADDR_SIZE 4
 842
 843 \f
 844 /* Miscellaneous Parameters.  */
 845
 846 #define PREDICATE_CODES                                 \
 847   {"shift_operator", {ASHIFT, ASHIFTRT, LSHIFTRT }},    \
 848   {"equality_operator", {EQ, NE }},                     \
 849   {"inequality_operator", {GE, GT, LE, LT, GEU, GTU, LEU, LTU }}, \
 850   {"xstormy16_ineqsi_operator", {LT, GE, LTU, GEU }}, \
 851   {"nonimmediate_nonstack_operand", {REG, MEM}},
 852
 853 #define CASE_VECTOR_MODE SImode
 854
 855 #define WORD_REGISTER_OPERATIONS
 856
 857 #define LOAD_EXTEND_OP(MODE) ZERO_EXTEND
 858
 859 #define MOVE_MAX 2
 860
 861 #define SHIFT_COUNT_TRUNCATED 1
 862
 863 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
 864
 865 #define Pmode HImode
 866
 867 #define FUNCTION_MODE HImode
 868
 869 #define NO_IMPLICIT_EXTERN_C
 870
 871 /* Defined in svr4.h.  */
 872 #define HANDLE_SYSV_PRAGMA 1
 873
 874 /* Define this if the target system supports the function `atexit' from the
 875    ANSI C standard.  If this is not defined, and `INIT_SECTION_ASM_OP' is not
 876    defined, a default `exit' function will be provided to support C++.
 877
 878    Defined by svr4.h */
 879 /* #define HAVE_ATEXIT */
 880
 881 /* A C statement which is executed by the Haifa scheduler after it has scheduled
 882    an insn from the ready list.  FILE is either a null pointer, or a stdio stream
 883    to write any debug output to.  VERBOSE is the verbose level provided by
 884    -fsched-verbose-<n>.  INSN is the instruction that was scheduled.  MORE is the
 885    number of instructions that can be issued in the current cycle.  This macro
 886    is responsible for updating the value of MORE (typically by (MORE)--).  */
 887 /* #define MD_SCHED_VARIABLE_ISSUE (FILE, VERBOSE, INSN, MORE) */
 888
 889 \f
 890 /* Define the information needed to generate branch and scc insns.  This is
 891    stored from the compare operation.  Note that we can't use "rtx" here
 892    since it hasn't been defined!  */
 893
 894 extern struct rtx_def *xstormy16_compare_op0, *xstormy16_compare_op1;
 895
 896 /* End of xstormy16.h */