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