gcc/config/mt/mt.h

   1 /* Target Definitions for MorphoRISC1
   2    Copyright (C) 2005 Free Software Foundation, Inc.
   3    Contributed by Red Hat, Inc.
   4
   5    This file is part of GCC.
   6
   7    GCC is free software; you can redistribute it and/or modify it
   8    under the terms of the GNU General Public License as published
   9    by the Free Software Foundation; either version 2, or (at your
  10    option) any later version.
  11
  12    GCC is distributed in the hope that it will be useful, but WITHOUT
  13    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  15    License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GCC; see the file COPYING.  If not, write to the Free
  19    Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  20    02110-1301, USA.  */
  21
  22 extern struct rtx_def * mt_ucmpsi3_libcall;
  23
  24 enum processor_type
  25 {
  26   PROCESSOR_MS1_64_001,
  27   PROCESSOR_MS1_16_002,
  28   PROCESSOR_MS1_16_003,
  29   PROCESSOR_MS2
  30 };
  31
  32 enum epilogue_type
  33 {
  34   EH_EPILOGUE,
  35   NORMAL_EPILOGUE
  36 };
  37
  38 extern enum processor_type mt_cpu;
  39
  40 \f
  41 /* Support for a compile-time default CPU, et cetera.  The rules are:
  42    --with-arch is ignored if -march is specified.  */
  43 #define OPTION_DEFAULT_SPECS \
  44   {"arch", "%{!march=*:-march=%(VALUE)}" }
  45
  46 /* A C string constant that tells the GCC driver program options to pass to
  47    the assembler.  */
  48 #undef  ASM_SPEC
  49 #define ASM_SPEC "%{march=*} %{!march=*: -march=ms1-16-002}"
  50
  51 /* A string to pass to at the end of the command given to the linker.  */
  52 #undef  LIB_SPEC
  53 #define LIB_SPEC "--start-group -lc -lsim --end-group \
  54 %{msim: ; \
  55 march=ms1-64-001:-T 64-001.ld%s; \
  56 march=ms1-16-002:-T 16-002.ld%s; \
  57 march=ms1-16-003:-T 16-003.ld%s; \
  58 march=ms2:-T ms2.ld%s; \
  59          :-T 16-002.ld}"
  60
  61 /* A string to pass at the very beginning of the command given to the
  62    linker.  */
  63 #undef  STARTFILE_SPEC
  64 #define STARTFILE_SPEC "%{msim:crt0.o%s;\
  65 march=ms1-64-001:%{!mno-crt0:crt0-64-001.o%s} startup-64-001.o%s; \
  66 march=ms1-16-002:%{!mno-crt0:crt0-16-002.o%s} startup-16-002.o%s; \
  67 march=ms1-16-003:%{!mno-crt0:crt0-16-003.o%s} startup-16-003.o%s; \
  68 march=ms2:%{!mno-crt0:crt0-ms2.o%s} startup-ms2.o%s; \
  69          :%{!mno-crt0:crt0-16-002.o%s} startup-16-002.o%s} \
  70 crti.o%s crtbegin.o%s"
  71
  72 /* A string to pass at the end of the command given to the linker.  */
  73 #undef  ENDFILE_SPEC
  74 #define ENDFILE_SPEC "%{msim:exit.o%s; \
  75 march=ms1-64-001:exit-64-001.o%s; \
  76 march=ms1-16-002:exit-16-002.o%s; \
  77 march=ms1-16-003:exit-16-003.o%s; \
  78 march=ms2:exit-ms2.o%s; \
  79          :exit-16-002.o%s} \
  80  crtend.o%s crtn.o%s"
  81 \f
  82 /* Run-time target specifications.  */
  83
  84 #define TARGET_CPU_CPP_BUILTINS()               \
  85   do                                            \
  86     {                                           \
  87       builtin_define_with_int_value ("__mt__", mt_cpu); \
  88       builtin_assert ("machine=mt");            \
  89     }                                           \
  90   while (0)
  91
  92 #define TARGET_MS1_64_001 (mt_cpu == PROCESSOR_MS1_64_001)
  93 #define TARGET_MS1_16_002 (mt_cpu == PROCESSOR_MS1_16_002)
  94 #define TARGET_MS1_16_003 (mt_cpu == PROCESSOR_MS1_16_003)
  95 #define TARGET_MS2 (mt_cpu == PROCESSOR_MS2)
  96
  97 #define TARGET_VERSION  fprintf (stderr, " (mt)");
  98
  99 #define OVERRIDE_OPTIONS mt_override_options ()
 100
 101 #define CAN_DEBUG_WITHOUT_FP 1
 102
 103 \f
 104 /* Storage Layout.  */
 105
 106 #define BITS_BIG_ENDIAN 0
 107
 108 #define BYTES_BIG_ENDIAN 1
 109
 110 #define WORDS_BIG_ENDIAN 1
 111
 112 #define UNITS_PER_WORD 4
 113
 114 /* A macro to update MODE and UNSIGNEDP when an object whose type is TYPE and
 115    which has the specified mode and signedness is to be stored in a register.
 116    This macro is only called when TYPE is a scalar type.
 117
 118    On most RISC machines, which only have operations that operate on a full
 119    register, define this macro to set M to `word_mode' if M is an integer mode
 120    narrower than `BITS_PER_WORD'.  In most cases, only integer modes should be
 121    widened because wider-precision floating-point operations are usually more
 122    expensive than their narrower counterparts.
 123
 124    For most machines, the macro definition does not change UNSIGNEDP.  However,
 125    some machines, have instructions that preferentially handle either signed or
 126    unsigned quantities of certain modes.  For example, on the DEC Alpha, 32-bit
 127    loads from memory and 32-bit add instructions sign-extend the result to 64
 128    bits.  On such machines, set UNSIGNEDP according to which kind of extension
 129    is more efficient.
 130
 131    Do not define this macro if it would never modify MODE.  */
 132 #define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE)                       \
 133   do                                                            \
 134     {                                                           \
 135       if (GET_MODE_CLASS (MODE) == MODE_INT                     \
 136           && GET_MODE_SIZE (MODE) < 4)                          \
 137         (MODE) = SImode;                                        \
 138     }                                                           \
 139   while (0)
 140
 141 /* Normal alignment required for function parameters on the stack, in bits.
 142    All stack parameters receive at least this much alignment regardless of data
 143    type.  On most machines, this is the same as the size of an integer.  */
 144 #define PARM_BOUNDARY 32
 145
 146 /* Define this macro to the minimum alignment enforced by hardware for
 147    the stack pointer on this machine.  The definition is a C
 148    expression for the desired alignment (measured in bits).  This
 149    value is used as a default if PREFERRED_STACK_BOUNDARY is not
 150    defined.  On most machines, this should be the same as
 151    PARM_BOUNDARY.  */
 152 #define STACK_BOUNDARY 32
 153
 154 /* Alignment required for a function entry point, in bits.  */
 155 #define FUNCTION_BOUNDARY 32
 156
 157 /* Biggest alignment that any data type can require on this machine,
 158    in bits.  */
 159 #define BIGGEST_ALIGNMENT 32
 160
 161 /* If defined, a C expression to compute the alignment for a variable
 162    in the static store.  TYPE is the data type, and ALIGN is the
 163    alignment that the object would ordinarily have.  The value of this
 164    macro is used instead of that alignment to align the object.
 165
 166    If this macro is not defined, then ALIGN is used.  */
 167 #define DATA_ALIGNMENT(TYPE, ALIGN)             \
 168   (TREE_CODE (TYPE) == ARRAY_TYPE               \
 169    && TYPE_MODE (TREE_TYPE (TYPE)) == QImode    \
 170    && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
 171
 172 /* If defined, a C expression to compute the alignment given to a constant that
 173    is being placed in memory.  CONSTANT is the constant and ALIGN is the
 174    alignment that the object would ordinarily have.  The value of this macro is
 175    used instead of that alignment to align the object.
 176
 177    If this macro is not defined, then ALIGN is used.
 178
 179    The typical use of this macro is to increase alignment for string constants
 180    to be word aligned so that `strcpy' calls that copy constants can be done
 181    inline.  */
 182 #define CONSTANT_ALIGNMENT(EXP, ALIGN)  \
 183   (TREE_CODE (EXP) == STRING_CST        \
 184    && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
 185
 186 /* Number of bits which any structure or union's size must be a multiple of.
 187    Each structure or union's size is rounded up to a multiple of this.
 188
 189    If you do not define this macro, the default is the same as `BITS_PER_UNIT'.  */
 190 #define STRUCTURE_SIZE_BOUNDARY 32
 191
 192 /* Define this macro to be the value 1 if instructions will fail to work if
 193    given data not on the nominal alignment.  If instructions will merely go
 194    slower in that case, define this macro as 0.  */
 195 #define STRICT_ALIGNMENT 1
 196
 197 /* Define this if you wish to imitate the way many other C compilers handle
 198    alignment of bitfields and the structures that contain them.  */
 199 #define PCC_BITFIELD_TYPE_MATTERS 1
 200 \f
 201 /* Layout of Source Language Data Types.  */
 202
 203 #define INT_TYPE_SIZE 32
 204
 205 #define SHORT_TYPE_SIZE 16
 206
 207 #define LONG_TYPE_SIZE 32
 208
 209 #define LONG_LONG_TYPE_SIZE 64
 210
 211 #define CHAR_TYPE_SIZE 8
 212
 213 #define FLOAT_TYPE_SIZE 32
 214
 215 #define DOUBLE_TYPE_SIZE 64
 216
 217 #define LONG_DOUBLE_TYPE_SIZE 64
 218
 219 #define DEFAULT_SIGNED_CHAR 1
 220 \f
 221 /* Register Basics.  */
 222
 223 /* General purpose registers.  */
 224 #define GPR_FIRST       0               /* First gpr */
 225 #define GPR_LAST        15              /* Last possible gpr */
 226
 227 #define GPR_R0          0               /* Always 0 */
 228 #define GPR_R7          7               /* Used as a scratch register */
 229 #define GPR_R8          8               /* Used as a scratch register */
 230 #define GPR_R9          9               /* Used as a scratch register */
 231 #define GPR_R10         10              /* Used as a scratch register */
 232 #define GPR_R11         11              /* Used as a scratch register */
 233 #define GPR_FP          12              /* Frame pointer */
 234 #define GPR_SP          13              /* Stack pointer */
 235 #define GPR_LINK        14              /* Saved return address as
 236                                            seen  by the caller */
 237 #define GPR_INTERRUPT_LINK 15           /* hold return addres for interrupts */
 238
 239 #define LOOP_FIRST         (GPR_LAST + 1)
 240 #define LOOP_LAST          (LOOP_FIRST + 3)
 241
 242 /* Argument register that is eliminated in favor of the frame and/or stack
 243    pointer.  Also add register to point to where the return address is
 244    stored.  */
 245 #define SPECIAL_REG_FIRST               (LOOP_LAST + 1)
 246 #define SPECIAL_REG_LAST                (SPECIAL_REG_FIRST)
 247 #define ARG_POINTER_REGNUM              (SPECIAL_REG_FIRST + 0)
 248 #define SPECIAL_REG_P(R)                ((R) == SPECIAL_REG_FIRST)
 249
 250 /* The first/last register that can contain the arguments to a function.  */
 251 #define FIRST_ARG_REGNUM        1
 252 #define LAST_ARG_REGNUM         4
 253
 254 /* The register used to hold functions return value */
 255 #define RETVAL_REGNUM           11
 256
 257 #define FIRST_PSEUDO_REGISTER (SPECIAL_REG_LAST + 1)
 258
 259 #define IS_PSEUDO_P(R)  (REGNO (R) >= FIRST_PSEUDO_REGISTER)
 260
 261 /* R0           always has the value 0
 262    R10          static link
 263    R12  FP      pointer to active frame
 264    R13  SP      pointer to top of stack
 265    R14  RA      return address
 266    R15  IRA     interrupt return address.  */
 267 #define FIXED_REGISTERS { 1, 0, 0, 0, 0, 0, 0, 0, \
 268                           0, 0, 0, 0, 1, 1, 1, 1, \
 269                           1, 1, 1, 1, 1           \
 270                          }
 271
 272 /* Like `FIXED_REGISTERS' but has 1 for each register that is clobbered (in
 273    general) by function calls as well as for fixed registers.  This macro
 274    therefore identifies the registers that are not available for general
 275    allocation of values that must live across function calls.  */
 276 #define CALL_USED_REGISTERS     { 1, 1, 1, 1, 1, 0, 0, 1, \
 277                                   1, 1, 1, 1, 1, 1, 1, 1, \
 278                                   1, 1, 1, 1, 1           \
 279                                 }
 280
 281 \f
 282 /* How Values Fit in Registers.  */
 283
 284 #define HARD_REGNO_NREGS(REGNO, MODE)                           \
 285   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
 286
 287 #define HARD_REGNO_MODE_OK(REGNO, MODE) 1
 288
 289 /* A C expression that is nonzero if a value of mode MODE1 is
 290    accessible in mode MODE2 without copying.  */
 291 #define MODES_TIEABLE_P(MODE1, MODE2) 1
 292 \f
 293 /* Register Classes.  */
 294
 295 enum reg_class
 296 {
 297   NO_REGS,
 298   ALL_REGS,
 299   LIM_REG_CLASSES
 300 };
 301
 302 #define   GENERAL_REGS  ALL_REGS
 303
 304 #define N_REG_CLASSES ((int) LIM_REG_CLASSES)
 305
 306 #define REG_CLASS_NAMES {"NO_REGS", "ALL_REGS" }
 307
 308 #define REG_CLASS_CONTENTS \
 309    {                                                            \
 310      { 0x0 },                                                   \
 311      { 0x000fffff },                                            \
 312    }
 313
 314 /* A C expression whose value is a register class containing hard register
 315    REGNO.  In general there is more than one such class; choose a class which
 316    is "minimal", meaning that no smaller class also contains the register.  */
 317 #define REGNO_REG_CLASS(REGNO) GENERAL_REGS
 318
 319 #define BASE_REG_CLASS GENERAL_REGS
 320
 321 #define INDEX_REG_CLASS NO_REGS
 322
 323 #define REG_CLASS_FROM_LETTER(CHAR) NO_REGS
 324
 325 #define REGNO_OK_FOR_BASE_P(NUM) 1
 326
 327 #define REGNO_OK_FOR_INDEX_P(NUM) 1
 328
 329 /* A C expression that places additional restrictions on the register class to
 330    use when it is necessary to copy value X into a register in class CLASS.
 331    The value is a register class; perhaps CLASS, or perhaps another, smaller
 332    class.  On many machines, the following definition is safe:
 333
 334         #define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS
 335 */
 336 #define PREFERRED_RELOAD_CLASS(X, CLASS) (CLASS)
 337
 338 #define SECONDARY_RELOAD_CLASS(CLASS,MODE,X) \
 339   mt_secondary_reload_class((CLASS), (MODE), (X))
 340
 341 /* A C expression for the maximum number of consecutive registers of
 342    class CLASS needed to hold a value of mode MODE.  */
 343 #define CLASS_MAX_NREGS(CLASS, MODE) \
 344   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
 345
 346 /* For MorphoRISC1:
 347
 348    `I'  is used for the range of constants an arithmetic insn can
 349         actually contain (16 bits signed integers).
 350
 351    `J'  is used for the range which is just zero (ie, $r0).
 352
 353    `K'  is used for the range of constants a logical insn can actually
 354         contain (16 bit zero-extended integers).
 355
 356    `L'  is used for the range of constants that be loaded with lui
 357         (ie, the bottom 16 bits are zero).
 358
 359    `M'  is used for the range of constants that take two words to load
 360         (ie, not matched by `I', `K', and `L').
 361
 362    `N'  is used for negative 16 bit constants other than -65536.
 363
 364    `O'  is a 15 bit signed integer.
 365
 366    `P'  is used for positive 16 bit constants.  */
 367
 368 #define SMALL_INT(X) ((unsigned HOST_WIDE_INT) (INTVAL (X) + 0x8000) < 0x10000)
 369 #define SMALL_INT_UNSIGNED(X) ((unsigned HOST_WIDE_INT) (INTVAL (X)) < 0x10000)
 370
 371 /* A C expression that defines the machine-dependent operand
 372    constraint letters that specify particular ranges of integer
 373    values.  If C is one of those letters, the expression should check
 374    that VALUE, an integer, is in the appropriate range and return 1 if
 375    so, 0 otherwise.  If C is not one of those letters, the value
 376    should be 0 regardless of VALUE.  */
 377 #define CONST_OK_FOR_LETTER_P(VALUE, C)                                 \
 378   ((C) == 'I' ? ((unsigned HOST_WIDE_INT) ((VALUE) + 0x8000) < 0x10000) \
 379    : (C) == 'J' ? ((VALUE) == 0)                                        \
 380    : (C) == 'K' ? ((unsigned HOST_WIDE_INT) (VALUE) < 0x10000)          \
 381    : (C) == 'L' ? (((VALUE) & 0x0000ffff) == 0                          \
 382                    && (((VALUE) & ~2147483647) == 0                     \
 383                        || ((VALUE) & ~2147483647) == ~2147483647))      \
 384    : (C) == 'M' ? ((((VALUE) & ~0x0000ffff) != 0)                       \
 385                    && (((VALUE) & ~0x0000ffff) != ~0x0000ffff)          \
 386                    && (((VALUE) & 0x0000ffff) != 0                      \
 387                        || (((VALUE) & ~2147483647) != 0                 \
 388                            && ((VALUE) & ~2147483647) != ~2147483647))) \
 389    : (C) == 'N' ? ((unsigned HOST_WIDE_INT) ((VALUE) + 0xffff) < 0xffff) \
 390    : (C) == 'O' ? ((unsigned HOST_WIDE_INT) ((VALUE) + 0x4000) < 0x8000) \
 391    : (C) == 'P' ? ((VALUE) != 0 && (((VALUE) & ~0x0000ffff) == 0))      \
 392    : 0)
 393
 394 /* A C expression that defines the machine-dependent operand constraint letters
 395    (`G', `H') that specify particular ranges of `const_double' values.  */
 396 #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) 0
 397
 398 /* Most negative value represent on mt */
 399 #define MT_MIN_INT 0x80000000
 400 \f
 401 /* Basic Stack Layout.  */
 402
 403 enum save_direction
 404 {
 405   FROM_PROCESSOR_TO_MEM,
 406   FROM_MEM_TO_PROCESSOR
 407 };
 408
 409 /* Tell prologue and epilogue if register REGNO should be saved / restored.
 410    The return address and frame pointer are treated separately.
 411    Don't consider them here.  */
 412 #define MUST_SAVE_REGISTER(regno)                               \
 413   (   (regno) != GPR_LINK                                       \
 414    && (regno) != GPR_FP                                         \
 415    && (regno) != GPR_SP                                         \
 416    && (regno) != GPR_R0                                         \
 417    &&   (( regs_ever_live [regno] && ! call_used_regs [regno] ) \
 418        /* Save ira register in an interrupt handler.  */        \
 419         || (interrupt_handler && (regno) == GPR_INTERRUPT_LINK) \
 420        /* Save any register used in an interrupt handler.  */   \
 421         || (interrupt_handler && regs_ever_live [regno])        \
 422        /* Save call clobbered registers in non-leaf interrupt   \
 423           handlers.  */                                         \
 424         || (interrupt_handler && call_used_regs[regno]          \
 425            && !current_function_is_leaf)                        \
 426         ||(current_function_calls_eh_return                     \
 427            && (regno == GPR_R7 || regno == GPR_R8))             \
 428         )                                                       \
 429   )
 430
 431 #define STACK_GROWS_DOWNWARD 1
 432
 433 /* Offset from the frame pointer to the first local variable slot to be
 434    allocated.
 435
 436    If `FRAME_GROWS_DOWNWARD', find the next slot's offset by
 437    subtracting the first slot's length from `STARTING_FRAME_OFFSET'.
 438    Otherwise, it is found by adding the length of the first slot to
 439    the value `STARTING_FRAME_OFFSET'.  */
 440 #define STARTING_FRAME_OFFSET current_function_outgoing_args_size
 441
 442 /* Offset from the argument pointer register to the first argument's address.
 443    On some machines it may depend on the data type of the function.
 444
 445    If `ARGS_GROW_DOWNWARD', this is the offset to the location above the first
 446    argument's address.  */
 447 #define FIRST_PARM_OFFSET(FUNDECL) 0
 448
 449 #define RETURN_ADDR_RTX(COUNT, FRAMEADDR)                               \
 450     mt_return_addr_rtx (COUNT)
 451
 452 /* A C expression whose value is RTL representing the location of the incoming
 453    return address at the beginning of any function, before the prologue.  This
 454    RTL is either a `REG', indicating that the return value is saved in `REG',
 455    or a `MEM' representing a location in the stack.
 456
 457    You only need to define this macro if you want to support call frame
 458    debugging information like that provided by DWARF 2.  */
 459 #define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (SImode, GPR_LINK)
 460
 461 /* A C expression whose value is an integer giving the offset, in bytes, from
 462    the value of the stack pointer register to the top of the stack frame at the
 463    beginning of any function, before the prologue.  The top of the frame is
 464    defined to be the value of the stack pointer in the previous frame, just
 465    before the call instruction.
 466
 467    You only need to define this macro if you want to support call frame
 468    debugging information like that provided by DWARF 2.  */
 469 #define INCOMING_FRAME_SP_OFFSET 0
 470
 471 #define STACK_POINTER_REGNUM GPR_SP
 472
 473 #define FRAME_POINTER_REGNUM GPR_FP
 474
 475 /* The register number of the arg pointer register, which is used to
 476    access the function's argument list.  */
 477 #define ARG_POINTER_REGNUM              (SPECIAL_REG_FIRST + 0)
 478
 479 /* Register numbers used for passing a function's static chain pointer.  */
 480 #define STATIC_CHAIN_REGNUM 10
 481
 482 /* A C expression which is nonzero if a function must have and use a frame
 483    pointer.  */
 484 #define FRAME_POINTER_REQUIRED 0
 485
 486 /* Structure to be filled in by compute_frame_size with register
 487    save masks, and offsets for the current function.  */
 488
 489 struct mt_frame_info
 490 {
 491   unsigned int total_size;      /* # Bytes that the entire frame takes up.  */
 492   unsigned int pretend_size;    /* # Bytes we push and pretend caller did.  */
 493   unsigned int args_size;       /* # Bytes that outgoing arguments take up.  */
 494   unsigned int extra_size;
 495   unsigned int reg_size;        /* # Bytes needed to store regs.  */
 496   unsigned int var_size;        /* # Bytes that variables take up.  */
 497   unsigned int frame_size;      /* # Bytes in current frame.  */
 498   unsigned int reg_mask;        /* Mask of saved registers.  */
 499   unsigned int save_fp;         /* Nonzero if frame pointer must be saved.  */
 500   unsigned int save_lr;         /* Nonzero if return pointer must be saved.  */
 501   int          initialized;     /* Nonzero if frame size already calculated.  */
 502 };
 503
 504 extern struct mt_frame_info current_frame_info;
 505
 506 /* If defined, this macro specifies a table of register pairs used to eliminate
 507    unneeded registers that point into the stack frame.  */
 508 #define ELIMINABLE_REGS                                                 \
 509 {                                                                       \
 510   {ARG_POINTER_REGNUM,   STACK_POINTER_REGNUM},                         \
 511   {ARG_POINTER_REGNUM,   FRAME_POINTER_REGNUM},                         \
 512   {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}                          \
 513 }
 514
 515 /* A C expression that returns non-zero if the compiler is allowed to try to
 516    replace register number FROM with register number TO.  */
 517 #define CAN_ELIMINATE(FROM, TO)                                         \
 518  ((FROM) == ARG_POINTER_REGNUM && (TO) == STACK_POINTER_REGNUM          \
 519   ? ! frame_pointer_needed                                              \
 520   : 1)
 521
 522 /* This macro is similar to `INITIAL_FRAME_POINTER_OFFSET'.  It
 523    specifies the initial difference between the specified pair of
 524    registers.  This macro must be defined if `ELIMINABLE_REGS' is
 525    defined.  */
 526 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET)                    \
 527   (OFFSET) = mt_initial_elimination_offset (FROM, TO)
 528
 529 /* If defined, the maximum amount of space required for outgoing
 530    arguments will be computed and placed into the variable
 531    `current_function_outgoing_args_size'.  */
 532 #define ACCUMULATE_OUTGOING_ARGS 1
 533
 534 /* Define this if it is the responsibility of the caller to
 535    allocate the area reserved for arguments passed in registers.  */
 536 #define OUTGOING_REG_PARM_STACK_SPACE
 537
 538 /* The number of register assigned to holding function arguments.  */
 539 #define MT_NUM_ARG_REGS        4
 540
 541 /* Define this if it is the responsibility of the caller to allocate
 542    the area reserved for arguments passed in registers.  */
 543 #define REG_PARM_STACK_SPACE(FNDECL) (MT_NUM_ARG_REGS * UNITS_PER_WORD)
 544
 545 /* Define this macro if `REG_PARM_STACK_SPACE' is defined, but the stack
 546    parameters don't skip the area specified by it.  */
 547 #define STACK_PARMS_IN_REG_PARM_AREA
 548
 549 /* A C expression that should indicate the number of bytes of its own
 550    arguments that a function pops on returning, or 0 if the function
 551    pops no arguments and the caller must therefore pop them all after
 552    the function returns.  */
 553 #define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACK_SIZE) 0
 554
 555 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
 556    mt_function_arg (& (CUM), (MODE), (TYPE), (NAMED), FALSE)
 557
 558 #define CUMULATIVE_ARGS int
 559
 560 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, FNDECL, N_NAMED_ARGS) \
 561     mt_init_cumulative_args (& (CUM), FNTYPE, LIBNAME, FNDECL, FALSE)
 562
 563 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)                    \
 564     mt_function_arg_advance (&CUM, MODE, TYPE, NAMED)
 565
 566 #define FUNCTION_ARG_BOUNDARY(MODE, TYPE)                               \
 567     mt_function_arg_boundary (MODE, TYPE)
 568
 569 #define FUNCTION_ARG_REGNO_P(REGNO)                                     \
 570   ((REGNO) >= FIRST_ARG_REGNUM && ((REGNO) <= LAST_ARG_REGNUM))
 571
 572 #define RETURN_VALUE_REGNUM     RETVAL_REGNUM
 573
 574 #define FUNCTION_VALUE(VALTYPE, FUNC) \
 575    mt_function_value (VALTYPE, TYPE_MODE(VALTYPE), FUNC)
 576
 577 #define LIBCALL_VALUE(MODE) \
 578    mt_function_value (NULL_TREE, MODE, NULL_TREE)
 579
 580 #define FUNCTION_VALUE_REGNO_P(REGNO) ((REGNO) == RETURN_VALUE_REGNUM)
 581
 582 /* A C expression which can inhibit the returning of certain function
 583    values in registers, based on the type of value.  */
 584 #define RETURN_IN_MEMORY(TYPE) (int_size_in_bytes (TYPE) > UNITS_PER_WORD)
 585
 586 /* Define this macro to be 1 if all structure and union return values must be
 587    in memory.  */
 588 #define DEFAULT_PCC_STRUCT_RETURN 0
 589
 590 /* Define this macro as a C expression that is nonzero if the return
 591    instruction or the function epilogue ignores the value of the stack
 592    pointer; in other words, if it is safe to delete an instruction to
 593    adjust the stack pointer before a return from the function.  */
 594 #define EXIT_IGNORE_STACK 1
 595
 596 #define EPILOGUE_USES(REGNO) mt_epilogue_uses(REGNO)
 597
 598 /* Define this macro if the function epilogue contains delay slots to which
 599    instructions from the rest of the function can be "moved".  */
 600 #define DELAY_SLOTS_FOR_EPILOGUE 1
 601
 602 /* A C expression that returns 1 if INSN can be placed in delay slot number N
 603    of the epilogue.  */
 604 #define ELIGIBLE_FOR_EPILOGUE_DELAY(INSN, N) 0
 605
 606 #define FUNCTION_PROFILER(FILE, LABELNO) gcc_unreachable ()
 607
 608 /* Trampolines are not implemented.  */
 609 #define TRAMPOLINE_SIZE 0
 610
 611 #define INITIALIZE_TRAMPOLINE(ADDR, FNADDR, STATIC_CHAIN)
 612
 613 /* ?? What is this -- aldyh ?? */
 614 #define UCMPSI3_LIBCALL         "__ucmpsi3"
 615
 616 /* Addressing Modes.  */
 617
 618 /* A C expression that is 1 if the RTX X is a constant which is a valid
 619    address.  */
 620 #define CONSTANT_ADDRESS_P(X) CONSTANT_P (X)
 621
 622 /* A number, the maximum number of registers that can appear in a valid memory
 623    address.  Note that it is up to you to specify a value equal to the maximum
 624    number that `GO_IF_LEGITIMATE_ADDRESS' would ever accept.  */
 625 #define MAX_REGS_PER_ADDRESS 1
 626
 627 #ifdef REG_OK_STRICT
 628 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \
 629 {                                               \
 630   if (mt_legitimate_address_p (MODE, X, 1))     \
 631     goto ADDR;                                  \
 632 }
 633 #else
 634 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \
 635 {                                               \
 636   if (mt_legitimate_address_p (MODE, X, 0))     \
 637     goto ADDR;                                  \
 638 }
 639 #endif
 640
 641 #ifdef REG_OK_STRICT
 642 #define REG_OK_FOR_BASE_P(X) mt_reg_ok_for_base_p (X, 1)
 643 #else
 644 #define REG_OK_FOR_BASE_P(X) mt_reg_ok_for_base_p (X, 0)
 645 #endif
 646
 647 #define REG_OK_FOR_INDEX_P(X) REG_OK_FOR_BASE_P (X)
 648
 649 #define LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN) {}
 650
 651 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR, LABEL)
 652
 653 #define LEGITIMATE_CONSTANT_P(X) 1
 654
 655 /* A C expression for the cost of moving data of mode M between a register and
 656    memory.  A value of 2 is the default; this cost is relative to those in
 657    `REGISTER_MOVE_COST'.
 658
 659    If moving between registers and memory is more expensive than between two
 660    registers, you should define this macro to express the relative cost.  */
 661 #define MEMORY_MOVE_COST(M,C,I) 10
 662
 663 /* Define this macro as a C expression which is nonzero if accessing less than
 664    a word of memory (i.e. a `char' or a `short') is no faster than accessing a
 665    word of memory.  */
 666 #define SLOW_BYTE_ACCESS 1
 667
 668 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) 1
 669
 670 #define TEXT_SECTION_ASM_OP ".text"
 671
 672 #define DATA_SECTION_ASM_OP ".data"
 673
 674 #define BSS_SECTION_ASM_OP "\t.section\t.bss"
 675
 676 /* A C string constant for text to be output before each `asm' statement or
 677    group of consecutive ones.  Normally this is `"#APP"', which is a comment
 678    that has no effect on most assemblers but tells the GNU assembler that it
 679    must check the lines that follow for all valid assembler constructs.  */
 680 #define ASM_APP_ON "#APP\n"
 681
 682 /* A C string constant for text to be output after each `asm' statement or
 683    group of consecutive ones.  Normally this is `"#NO_APP"', which tells the
 684    GNU assembler to resume making the time-saving assumptions that are valid
 685    for ordinary compiler output.  */
 686 #define ASM_APP_OFF "#NO_APP\n"
 687
 688 /* This is how to output an assembler line defining a `char' constant.  */
 689 #define ASM_OUTPUT_CHAR(FILE, VALUE)                    \
 690   do                                                    \
 691     {                                                   \
 692       fprintf (FILE, "\t.byte\t");                      \
 693       output_addr_const (FILE, (VALUE));                \
 694       fprintf (FILE, "\n");                             \
 695     }                                                   \
 696   while (0)
 697
 698 /* This is how to output an assembler line defining a `short' constant.  */
 699 #define ASM_OUTPUT_SHORT(FILE, VALUE)                   \
 700   do                                                    \
 701     {                                                   \
 702       fprintf (FILE, "\t.hword\t");                     \
 703       output_addr_const (FILE, (VALUE));                \
 704       fprintf (FILE, "\n");                             \
 705     }                                                   \
 706   while (0)
 707
 708 /* This is how to output an assembler line defining an `int' constant.
 709    We also handle symbol output here.  */
 710 #define ASM_OUTPUT_INT(FILE, VALUE)                     \
 711   do                                                    \
 712     {                                                   \
 713       fprintf (FILE, "\t.word\t");                      \
 714       output_addr_const (FILE, (VALUE));                \
 715       fprintf (FILE, "\n");                             \
 716     }                                                   \
 717   while (0)
 718
 719 /* A C statement to output to the stdio stream STREAM an assembler instruction
 720    to assemble a single byte containing the number VALUE.
 721
 722    This declaration must be present.  */
 723 #define ASM_OUTPUT_BYTE(STREAM, VALUE) \
 724   fprintf (STREAM, "\t%s\t0x%x\n", ASM_BYTE_OP, (VALUE))
 725
 726 /* Globalizing directive for a label.  */
 727 #define GLOBAL_ASM_OP "\t.globl "
 728
 729 #define REGISTER_NAMES                                                  \
 730 { "R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7",                       \
 731   "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15",                 \
 732   "LOOP1", "LOOP2", "LOOP3", "LOOP4", "ap" }
 733
 734 /* If defined, a C initializer for an array of structures containing a name and
 735    a register number.  This macro defines additional names for hard registers,
 736    thus allowing the `asm' option in declarations to refer to registers using
 737    alternate names.  */
 738 #define ADDITIONAL_REGISTER_NAMES \
 739 { { "FP", 12}, {"SP", 13}, {"RA", 14}, {"IRA", 15} }
 740
 741 /* Define this macro if you are using an unusual assembler that requires
 742    different names for the machine instructions.
 743
 744    The definition is a C statement or statements which output an assembler
 745    instruction opcode to the stdio stream STREAM.  The macro-operand PTR is a
 746    variable of type `char *' which points to the opcode name in its "internal"
 747    form--the form that is written in the machine description.  The definition
 748    should output the opcode name to STREAM, performing any translation you
 749    desire, and increment the variable PTR to point at the end of the opcode so
 750    that it will not be output twice.  */
 751 #define ASM_OUTPUT_OPCODE(STREAM, PTR) \
 752    (PTR) = mt_asm_output_opcode (STREAM, PTR)
 753
 754 #define FINAL_PRESCAN_INSN(INSN, OPVEC, NOPERANDS) \
 755   mt_final_prescan_insn (INSN, OPVEC, NOPERANDS)
 756
 757 #define PRINT_OPERAND(STREAM, X, CODE) mt_print_operand (STREAM, X, CODE)
 758
 759 /* A C expression which evaluates to true if CODE is a valid punctuation
 760    character for use in the `PRINT_OPERAND' macro.  */
 761 /* #:  Print nop for delay slot.  */
 762 #define PRINT_OPERAND_PUNCT_VALID_P(CODE) ((CODE) == '#')
 763
 764 #define PRINT_OPERAND_ADDRESS(STREAM, X) mt_print_operand_address (STREAM, X)
 765
 766 /* If defined, C string expressions to be used for the `%R', `%L', `%U', and
 767    `%I' options of `asm_fprintf' (see `final.c').  These are useful when a
 768    single `md' file must support multiple assembler formats.  In that case, the
 769    various `tm.h' files can define these macros differently.
 770
 771    USER_LABEL_PREFIX is defined in svr4.h.  */
 772 #define REGISTER_PREFIX     "%"
 773 #define LOCAL_LABEL_PREFIX  "."
 774 #define USER_LABEL_PREFIX   ""
 775 #define IMMEDIATE_PREFIX    ""
 776
 777 /* This macro should be provided on machines where the addresses in a dispatch
 778    table are relative to the table's own address.
 779
 780    The definition should be a C statement to output to the stdio stream STREAM
 781    an assembler pseudo-instruction to generate a difference between two labels.
 782    VALUE and REL are the numbers of two internal labels.  The definitions of
 783    these labels are output using `targetm.asm_out.internal_label', and they
 784    must be printed in the same way here.  */
 785 #define ASM_OUTPUT_ADDR_DIFF_ELT(STREAM, BODY, VALUE, REL) \
 786 fprintf (STREAM, "\t.word .L%d-.L%d\n", VALUE, REL)
 787
 788 /* This macro should be provided on machines where the addresses in a dispatch
 789    table are absolute.
 790
 791    The definition should be a C statement to output to the stdio stream STREAM
 792    an assembler pseudo-instruction to generate a reference to a label.  VALUE
 793    is the number of an internal label whose definition is output using
 794    `targetm.asm_out.internal_label'.  */
 795 #define ASM_OUTPUT_ADDR_VEC_ELT(STREAM, VALUE) \
 796 fprintf (STREAM, "\t.word .L%d\n", VALUE)
 797
 798 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (GPR_LINK)
 799
 800 #define EH_RETURN_DATA_REGNO(N) \
 801   ((N) == 0 ? GPR_R7 : (N) == 1 ? GPR_R8 : INVALID_REGNUM)
 802
 803 #define EH_RETURN_STACKADJ_REGNO        GPR_R11
 804 #define EH_RETURN_STACKADJ_RTX          \
 805         gen_rtx_REG (SImode, EH_RETURN_STACKADJ_REGNO)
 806 #define EH_RETURN_HANDLER_REGNO         GPR_R10
 807 #define EH_RETURN_HANDLER_RTX           \
 808         gen_rtx_REG (SImode, EH_RETURN_HANDLER_REGNO)
 809 \f
 810 #define ASM_OUTPUT_ALIGN(STREAM, POWER) \
 811   fprintf ((STREAM), "\t.p2align %d\n", (POWER))
 812
 813 #define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG
 814
 815 #ifndef DWARF2_DEBUGGING_INFO
 816 #define DWARF2_DEBUGGING_INFO
 817 #endif
 818
 819 /* Define this macro if GCC should produce dwarf version 2-style
 820    line numbers.  This usually requires extending the assembler to
 821    support them, and #defining DWARF2_LINE_MIN_INSN_LENGTH in the
 822    assembler configuration header files.  */
 823 #define DWARF2_ASM_LINE_DEBUG_INFO 1
 824
 825 /* An alias for a machine mode name.  This is the machine mode that
 826    elements of a jump-table should have.  */
 827 #define CASE_VECTOR_MODE SImode
 828
 829 /* Define this macro if operations between registers with integral
 830    mode smaller than a word are always performed on the entire
 831    register.  Most RISC machines have this property and most CISC
 832    machines do not.  */
 833 #define WORD_REGISTER_OPERATIONS
 834
 835 /* The maximum number of bytes that a single instruction can move quickly from
 836    memory to memory.  */
 837 #define MOVE_MAX 4
 838
 839 /* A C expression which is nonzero if on this machine it is safe to "convert"
 840    an integer of INPREC bits to one of OUTPREC bits (where OUTPREC is smaller
 841    than INPREC) by merely operating on it as if it had only OUTPREC bits.
 842
 843    On many machines, this expression can be 1.
 844
 845    When `TRULY_NOOP_TRUNCATION' returns 1 for a pair of sizes for modes for
 846    which `MODES_TIEABLE_P' is 0, suboptimal code can result.  If this is the
 847    case, making `TRULY_NOOP_TRUNCATION' return 0 in such cases may improve
 848    things.  */
 849 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
 850
 851 #define Pmode SImode
 852
 853 /* An alias for the machine mode used for memory references to functions being
 854    called, in `call' RTL expressions.  On most machines this should be
 855    `QImode'.  */
 856 #define FUNCTION_MODE QImode
 857
 858 #define HANDLE_SYSV_PRAGMA 1
 859
 860 /* Indicate how many instructions can be issued at the same time.  */
 861 #define ISSUE_RATE 1
 862
 863 /* Define the information needed to generate branch and scc insns.  This is
 864    stored from the compare operation.  Note that we can't use "rtx" here
 865    since it hasn't been defined!  */
 866
 867 extern struct rtx_def * mt_compare_op0;
 868 extern struct rtx_def * mt_compare_op1;
 869