gcc/config/mn10300/mn10300.h

   1 /* Definitions of target machine for GNU compiler.
   2    Matsushita MN10300 series
   3    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
   4    Free Software Foundation, Inc.
   5    Contributed by Jeff Law (law@cygnus.com).
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING.  If not, write to
  21 the Free Software Foundation, 59 Temple Place - Suite 330,
  22 Boston, MA 02111-1307, USA.  */
  23
  24
  25 #undef ASM_SPEC
  26 #undef LIB_SPEC
  27 #undef ENDFILE_SPEC
  28 #undef LINK_SPEC
  29 #define LINK_SPEC "%{mrelax:--relax}"
  30 #undef STARTFILE_SPEC
  31 #define STARTFILE_SPEC "%{!mno-crt0:%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}}"
  32
  33 /* Names to predefine in the preprocessor for this target machine.  */
  34
  35 #define TARGET_CPU_CPP_BUILTINS()               \
  36   do                                            \
  37     {                                           \
  38       builtin_define ("__mn10300__");           \
  39       builtin_define ("__MN10300__");           \
  40     }                                           \
  41   while (0)
  42
  43 #define CPP_SPEC "%{mam33:-D__AM33__} %{mam33-2:-D__AM33__=2 -D__AM33_2__}"
  44
  45 extern GTY(()) int mn10300_unspec_int_label_counter;
  46
  47 enum processor_type {
  48   PROCESSOR_MN10300,
  49   PROCESSOR_AM33,
  50   PROCESSOR_AM33_2
  51 };
  52
  53 extern enum processor_type mn10300_processor;
  54
  55 #define TARGET_AM33     (mn10300_processor >= PROCESSOR_AM33)
  56 #define TARGET_AM33_2   (mn10300_processor == PROCESSOR_AM33_2)
  57
  58 #ifndef PROCESSOR_DEFAULT
  59 #define PROCESSOR_DEFAULT PROCESSOR_MN10300
  60 #endif
  61
  62 #define OVERRIDE_OPTIONS mn10300_override_options ()
  63
  64 /* Print subsidiary information on the compiler version in use.  */
  65
  66 #define TARGET_VERSION fprintf (stderr, " (MN10300)");
  67
  68 \f
  69 /* Target machine storage layout */
  70
  71 /* Define this if most significant bit is lowest numbered
  72    in instructions that operate on numbered bit-fields.
  73    This is not true on the Matsushita MN1003.  */
  74 #define BITS_BIG_ENDIAN 0
  75
  76 /* Define this if most significant byte of a word is the lowest numbered.  */
  77 /* This is not true on the Matsushita MN10300.  */
  78 #define BYTES_BIG_ENDIAN 0
  79
  80 /* Define this if most significant word of a multiword number is lowest
  81    numbered.
  82    This is not true on the Matsushita MN10300.  */
  83 #define WORDS_BIG_ENDIAN 0
  84
  85 /* Width of a word, in units (bytes).  */
  86 #define UNITS_PER_WORD          4
  87
  88 /* Allocation boundary (in *bits*) for storing arguments in argument list.  */
  89 #define PARM_BOUNDARY           32
  90
  91 /* The stack goes in 32 bit lumps.  */
  92 #define STACK_BOUNDARY          32
  93
  94 /* Allocation boundary (in *bits*) for the code of a function.
  95    8 is the minimum boundary; it's unclear if bigger alignments
  96    would improve performance.  */
  97 #define FUNCTION_BOUNDARY 8
  98
  99 /* No data type wants to be aligned rounder than this.  */
 100 #define BIGGEST_ALIGNMENT       32
 101
 102 /* Alignment of field after `int : 0' in a structure.  */
 103 #define EMPTY_FIELD_BOUNDARY 32
 104
 105 /* Define this if move instructions will actually fail to work
 106    when given unaligned data.  */
 107 #define STRICT_ALIGNMENT 1
 108
 109 /* Define this as 1 if `char' should by default be signed; else as 0.  */
 110 #define DEFAULT_SIGNED_CHAR 0
 111 \f
 112 /* Standard register usage.  */
 113
 114 /* Number of actual hardware registers.
 115    The hardware registers are assigned numbers for the compiler
 116    from 0 to just below FIRST_PSEUDO_REGISTER.
 117
 118    All registers that the compiler knows about must be given numbers,
 119    even those that are not normally considered general registers.  */
 120
 121 #define FIRST_PSEUDO_REGISTER 50
 122
 123 /* Specify machine-specific register numbers.  */
 124 #define FIRST_DATA_REGNUM 0
 125 #define LAST_DATA_REGNUM 3
 126 #define FIRST_ADDRESS_REGNUM 4
 127 #define LAST_ADDRESS_REGNUM 8
 128 #define FIRST_EXTENDED_REGNUM 10
 129 #define LAST_EXTENDED_REGNUM 17
 130 #define FIRST_FP_REGNUM 18
 131 #define LAST_FP_REGNUM 49
 132
 133 /* Specify the registers used for certain standard purposes.
 134    The values of these macros are register numbers.  */
 135
 136 /* Register to use for pushing function arguments.  */
 137 #define STACK_POINTER_REGNUM (LAST_ADDRESS_REGNUM+1)
 138
 139 /* Base register for access to local variables of the function.  */
 140 #define FRAME_POINTER_REGNUM (LAST_ADDRESS_REGNUM-1)
 141
 142 /* Base register for access to arguments of the function.  This
 143    is a fake register and will be eliminated into either the frame
 144    pointer or stack pointer.  */
 145 #define ARG_POINTER_REGNUM LAST_ADDRESS_REGNUM
 146
 147 /* Register in which static-chain is passed to a function.  */
 148 #define STATIC_CHAIN_REGNUM (FIRST_ADDRESS_REGNUM+1)
 149
 150 /* 1 for registers that have pervasive standard uses
 151    and are not available for the register allocator.  */
 152
 153 #define FIXED_REGISTERS \
 154   { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 \
 155   , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 \
 156   , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 \
 157   }
 158
 159 /* 1 for registers not available across function calls.
 160    These must include the FIXED_REGISTERS and also any
 161    registers that can be used without being saved.
 162    The latter must include the registers where values are returned
 163    and the register where structure-value addresses are passed.
 164    Aside from that, you can include as many other registers as you
 165    like.  */
 166
 167 #define CALL_USED_REGISTERS \
 168   { 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0 \
 169   , 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 \
 170   , 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 \
 171   }
 172
 173 #define REG_ALLOC_ORDER \
 174   { 0, 1, 4, 5, 2, 3, 6, 7, 10, 11, 12, 13, 14, 15, 16, 17, 8, 9 \
 175   , 42, 43, 44, 45, 46, 47, 48, 49, 34, 35, 36, 37, 38, 39, 40, 41 \
 176   , 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33 \
 177   }
 178
 179 #define CONDITIONAL_REGISTER_USAGE \
 180 {                                               \
 181   unsigned int i;                               \
 182                                                 \
 183   if (!TARGET_AM33)                             \
 184     {                                           \
 185       for (i = FIRST_EXTENDED_REGNUM;           \
 186            i <= LAST_EXTENDED_REGNUM; i++)      \
 187         fixed_regs[i] = call_used_regs[i] = 1;  \
 188     }                                           \
 189   if (!TARGET_AM33_2)                           \
 190     {                                           \
 191       for (i = FIRST_FP_REGNUM;                 \
 192            i <= LAST_FP_REGNUM;                 \
 193            i++)                                 \
 194         fixed_regs[i] = call_used_regs[i] = 1;  \
 195     }                                           \
 196   if (flag_pic)                                 \
 197     fixed_regs[PIC_OFFSET_TABLE_REGNUM] =       \
 198     call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1;\
 199 }
 200
 201 /* Return number of consecutive hard regs needed starting at reg REGNO
 202    to hold something of mode MODE.
 203
 204    This is ordinarily the length in words of a value of mode MODE
 205    but can be less for certain modes in special long registers.  */
 206
 207 #define HARD_REGNO_NREGS(REGNO, MODE)   \
 208   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
 209
 210 /* Value is 1 if hard register REGNO can hold a value of machine-mode
 211    MODE.  */
 212
 213 #define HARD_REGNO_MODE_OK(REGNO, MODE) \
 214  ((REGNO_REG_CLASS (REGNO) == DATA_REGS \
 215    || (TARGET_AM33 && REGNO_REG_CLASS (REGNO) == ADDRESS_REGS) \
 216    || REGNO_REG_CLASS (REGNO) == EXTENDED_REGS) \
 217   ? ((REGNO) & 1) == 0 || GET_MODE_SIZE (MODE) <= 4     \
 218   : ((REGNO) & 1) == 0 || GET_MODE_SIZE (MODE) == 4)
 219
 220 /* Value is 1 if it is a good idea to tie two pseudo registers
 221    when one has mode MODE1 and one has mode MODE2.
 222    If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2,
 223    for any hard reg, then this must be 0 for correct output.  */
 224 #define MODES_TIEABLE_P(MODE1, MODE2) \
 225   (TARGET_AM33  \
 226    || MODE1 == MODE2 \
 227    || (GET_MODE_SIZE (MODE1) <= 4 && GET_MODE_SIZE (MODE2) <= 4))
 228
 229 /* 4 data, and effectively 3 address registers is small as far as I'm
 230    concerned.  */
 231 #define SMALL_REGISTER_CLASSES 1
 232 \f
 233 /* Define the classes of registers for register constraints in the
 234    machine description.  Also define ranges of constants.
 235
 236    One of the classes must always be named ALL_REGS and include all hard regs.
 237    If there is more than one class, another class must be named NO_REGS
 238    and contain no registers.
 239
 240    The name GENERAL_REGS must be the name of a class (or an alias for
 241    another name such as ALL_REGS).  This is the class of registers
 242    that is allowed by "g" or "r" in a register constraint.
 243    Also, registers outside this class are allocated only when
 244    instructions express preferences for them.
 245
 246    The classes must be numbered in nondecreasing order; that is,
 247    a larger-numbered class must never be contained completely
 248    in a smaller-numbered class.
 249
 250    For any two classes, it is very desirable that there be another
 251    class that represents their union.  */
 252
 253 enum reg_class {
 254   NO_REGS, DATA_REGS, ADDRESS_REGS, SP_REGS,
 255   DATA_OR_ADDRESS_REGS, SP_OR_ADDRESS_REGS,
 256   EXTENDED_REGS, DATA_OR_EXTENDED_REGS, ADDRESS_OR_EXTENDED_REGS,
 257   SP_OR_EXTENDED_REGS, SP_OR_ADDRESS_OR_EXTENDED_REGS,
 258   FP_REGS, FP_ACC_REGS,
 259   GENERAL_REGS, ALL_REGS, LIM_REG_CLASSES
 260 };
 261
 262 #define N_REG_CLASSES (int) LIM_REG_CLASSES
 263
 264 /* Give names of register classes as strings for dump file.  */
 265
 266 #define REG_CLASS_NAMES \
 267 { "NO_REGS", "DATA_REGS", "ADDRESS_REGS", \
 268   "SP_REGS", "DATA_OR_ADDRESS_REGS", "SP_OR_ADDRESS_REGS", \
 269   "EXTENDED_REGS", \
 270   "DATA_OR_EXTENDED_REGS", "ADDRESS_OR_EXTENDED_REGS", \
 271   "SP_OR_EXTENDED_REGS", "SP_OR_ADDRESS_OR_EXTENDED_REGS", \
 272   "FP_REGS", "FP_ACC_REGS", \
 273   "GENERAL_REGS", "ALL_REGS", "LIM_REGS" }
 274
 275 /* Define which registers fit in which classes.
 276    This is an initializer for a vector of HARD_REG_SET
 277    of length N_REG_CLASSES.  */
 278
 279 #define REG_CLASS_CONTENTS                      \
 280 {  { 0, 0 },            /* No regs      */      \
 281  { 0x0000f, 0 },        /* DATA_REGS */         \
 282  { 0x001f0, 0 },        /* ADDRESS_REGS */      \
 283  { 0x00200, 0 },        /* SP_REGS */           \
 284  { 0x001ff, 0 },        /* DATA_OR_ADDRESS_REGS */\
 285  { 0x003f0, 0 },        /* SP_OR_ADDRESS_REGS */\
 286  { 0x3fc00, 0 },        /* EXTENDED_REGS */     \
 287  { 0x3fc0f, 0 },        /* DATA_OR_EXTENDED_REGS */     \
 288  { 0x3fdf0, 0 },        /* ADDRESS_OR_EXTENDED_REGS */  \
 289  { 0x3fe00, 0 },        /* SP_OR_EXTENDED_REGS */       \
 290  { 0x3fff0, 0 },        /* SP_OR_ADDRESS_OR_EXTENDED_REGS */    \
 291  { 0xfffc0000, 0x3ffff }, /* FP_REGS */         \
 292  { 0x03fc0000, 0 },     /* FP_ACC_REGS */       \
 293  { 0x3fdff, 0 },        /* GENERAL_REGS */      \
 294  { 0xffffffff, 0x3ffff } /* ALL_REGS    */      \
 295 }
 296
 297 /* The same information, inverted:
 298    Return the class number of the smallest class containing
 299    reg number REGNO.  This could be a conditional expression
 300    or could index an array.  */
 301
 302 #define REGNO_REG_CLASS(REGNO) \
 303   ((REGNO) <= LAST_DATA_REGNUM ? DATA_REGS : \
 304    (REGNO) <= LAST_ADDRESS_REGNUM ? ADDRESS_REGS : \
 305    (REGNO) == STACK_POINTER_REGNUM ? SP_REGS : \
 306    (REGNO) <= LAST_EXTENDED_REGNUM ? EXTENDED_REGS : \
 307    (REGNO) <= LAST_FP_REGNUM ? FP_REGS : \
 308    NO_REGS)
 309
 310 /* The class value for index registers, and the one for base regs.  */
 311 #define INDEX_REG_CLASS DATA_OR_EXTENDED_REGS
 312 #define BASE_REG_CLASS  SP_OR_ADDRESS_REGS
 313
 314 /* Get reg_class from a letter such as appears in the machine description.  */
 315
 316 #define REG_CLASS_FROM_LETTER(C) \
 317   ((C) == 'd' ? DATA_REGS : \
 318    (C) == 'a' ? ADDRESS_REGS : \
 319    (C) == 'y' ? SP_REGS : \
 320    ! TARGET_AM33 ? NO_REGS : \
 321    (C) == 'x' ? EXTENDED_REGS : \
 322    ! TARGET_AM33_2 ? NO_REGS : \
 323    (C) == 'f' ? FP_REGS : \
 324    (C) == 'A' ? FP_ACC_REGS : \
 325    NO_REGS)
 326
 327 /* Macros to check register numbers against specific register classes.  */
 328
 329 /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
 330    and check its validity for a certain class.
 331    We have two alternate definitions for each of them.
 332    The usual definition accepts all pseudo regs; the other rejects
 333    them unless they have been allocated suitable hard regs.
 334    The symbol REG_OK_STRICT causes the latter definition to be used.
 335
 336    Most source files want to accept pseudo regs in the hope that
 337    they will get allocated to the class that the insn wants them to be in.
 338    Source files for reload pass need to be strict.
 339    After reload, it makes no difference, since pseudo regs have
 340    been eliminated by then.  */
 341
 342 /* These assume that REGNO is a hard or pseudo reg number.
 343    They give nonzero only if REGNO is a hard reg of the suitable class
 344    or a pseudo reg currently allocated to a suitable hard reg.
 345    Since they use reg_renumber, they are safe only once reg_renumber
 346    has been allocated, which happens in local-alloc.c.  */
 347
 348 #ifndef REG_OK_STRICT
 349 # define REG_STRICT 0
 350 #else
 351 # define REG_STRICT 1
 352 #endif
 353
 354 # define REGNO_IN_RANGE_P(regno,min,max,strict) \
 355   (IN_RANGE ((regno), (min), (max))             \
 356    || ((strict)                                 \
 357        ? (reg_renumber                          \
 358           && reg_renumber[(regno)] >= (min)     \
 359           && reg_renumber[(regno)] <= (max))    \
 360        : (regno) >= FIRST_PSEUDO_REGISTER))
 361
 362 #define REGNO_DATA_P(regno, strict) \
 363   (REGNO_IN_RANGE_P ((regno), FIRST_DATA_REGNUM, LAST_DATA_REGNUM, \
 364                      (strict)))
 365 #define REGNO_ADDRESS_P(regno, strict) \
 366   (REGNO_IN_RANGE_P ((regno), FIRST_ADDRESS_REGNUM, LAST_ADDRESS_REGNUM, \
 367                      (strict)))
 368 #define REGNO_SP_P(regno, strict) \
 369   (REGNO_IN_RANGE_P ((regno), STACK_POINTER_REGNUM, STACK_POINTER_REGNUM, \
 370                      (strict)))
 371 #define REGNO_EXTENDED_P(regno, strict) \
 372   (REGNO_IN_RANGE_P ((regno), FIRST_EXTENDED_REGNUM, LAST_EXTENDED_REGNUM, \
 373                      (strict)))
 374 #define REGNO_AM33_P(regno, strict) \
 375   (REGNO_DATA_P ((regno), (strict)) || REGNO_ADDRESS_P ((regno), (strict)) \
 376    || REGNO_EXTENDED_P ((regno), (strict)))
 377 #define REGNO_FP_P(regno, strict) \
 378   (REGNO_IN_RANGE_P ((regno), FIRST_FP_REGNUM, LAST_FP_REGNUM, (strict)))
 379
 380 #define REGNO_STRICT_OK_FOR_BASE_P(regno, strict) \
 381   (REGNO_SP_P ((regno), (strict)) \
 382    || REGNO_ADDRESS_P ((regno), (strict)) \
 383    || REGNO_EXTENDED_P ((regno), (strict)))
 384 #define REGNO_OK_FOR_BASE_P(regno) \
 385   (REGNO_STRICT_OK_FOR_BASE_P ((regno), REG_STRICT))
 386 #define REG_OK_FOR_BASE_P(X) \
 387   (REGNO_OK_FOR_BASE_P (REGNO (X)))
 388
 389 #define REGNO_STRICT_OK_FOR_BIT_BASE_P(regno, strict) \
 390   (REGNO_SP_P ((regno), (strict)) || REGNO_ADDRESS_P ((regno), (strict)))
 391 #define REGNO_OK_FOR_BIT_BASE_P(regno) \
 392   (REGNO_STRICT_OK_FOR_BIT_BASE_P ((regno), REG_STRICT))
 393 #define REG_OK_FOR_BIT_BASE_P(X) \
 394   (REGNO_OK_FOR_BIT_BASE_P (REGNO (X)))
 395
 396 #define REGNO_STRICT_OK_FOR_INDEX_P(regno, strict) \
 397   (REGNO_DATA_P ((regno), (strict)) || REGNO_EXTENDED_P ((regno), (strict)))
 398 #define REGNO_OK_FOR_INDEX_P(regno) \
 399   (REGNO_STRICT_OK_FOR_INDEX_P ((regno), REG_STRICT))
 400 #define REG_OK_FOR_INDEX_P(X) \
 401   (REGNO_OK_FOR_INDEX_P (REGNO (X)))
 402
 403 /* Given an rtx X being reloaded into a reg required to be
 404    in class CLASS, return the class of reg to actually use.
 405    In general this is just CLASS; but on some machines
 406    in some cases it is preferable to use a more restrictive class.  */
 407
 408 #define PREFERRED_RELOAD_CLASS(X,CLASS)                         \
 409   ((X) == stack_pointer_rtx && (CLASS) != SP_REGS               \
 410    ? ADDRESS_OR_EXTENDED_REGS                                   \
 411    : (GET_CODE (X) == MEM                                       \
 412       || (GET_CODE (X) == REG                                   \
 413           && REGNO (X) >= FIRST_PSEUDO_REGISTER)                \
 414       || (GET_CODE (X) == SUBREG                                \
 415           && GET_CODE (SUBREG_REG (X)) == REG                   \
 416           && REGNO (SUBREG_REG (X)) >= FIRST_PSEUDO_REGISTER)   \
 417       ? LIMIT_RELOAD_CLASS (GET_MODE (X), CLASS)                \
 418       : (CLASS)))
 419
 420 #define PREFERRED_OUTPUT_RELOAD_CLASS(X,CLASS) \
 421   (X == stack_pointer_rtx && CLASS != SP_REGS \
 422    ? ADDRESS_OR_EXTENDED_REGS : CLASS)
 423
 424 #define LIMIT_RELOAD_CLASS(MODE, CLASS) \
 425   (!TARGET_AM33 && (MODE == QImode || MODE == HImode) ? DATA_REGS : CLASS)
 426
 427 #define SECONDARY_RELOAD_CLASS(CLASS,MODE,IN) \
 428   secondary_reload_class(CLASS,MODE,IN)
 429
 430 /* Return the maximum number of consecutive registers
 431    needed to represent mode MODE in a register of class CLASS.  */
 432
 433 #define CLASS_MAX_NREGS(CLASS, MODE)    \
 434   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
 435
 436 /* A class that contains registers which the compiler must always
 437    access in a mode that is the same size as the mode in which it
 438    loaded the register.  */
 439 #define CLASS_CANNOT_CHANGE_SIZE FP_REGS
 440
 441 /* The letters I, J, K, L, M, N, O, P in a register constraint string
 442    can be used to stand for particular ranges of immediate operands.
 443    This macro defines what the ranges are.
 444    C is the letter, and VALUE is a constant value.
 445    Return 1 if VALUE is in the range specified by C.  */
 446
 447 #define INT_8_BITS(VALUE) ((unsigned) (VALUE) + 0x80 < 0x100)
 448 #define INT_16_BITS(VALUE) ((unsigned) (VALUE) + 0x8000 < 0x10000)
 449
 450 #define CONST_OK_FOR_I(VALUE) ((VALUE) == 0)
 451 #define CONST_OK_FOR_J(VALUE) ((VALUE) == 1)
 452 #define CONST_OK_FOR_K(VALUE) ((VALUE) == 2)
 453 #define CONST_OK_FOR_L(VALUE) ((VALUE) == 4)
 454 #define CONST_OK_FOR_M(VALUE) ((VALUE) == 3)
 455 #define CONST_OK_FOR_N(VALUE) ((VALUE) == 255 || (VALUE) == 65535)
 456
 457 #define CONST_OK_FOR_LETTER_P(VALUE, C) \
 458   ((C) == 'I' ? CONST_OK_FOR_I (VALUE) : \
 459    (C) == 'J' ? CONST_OK_FOR_J (VALUE) : \
 460    (C) == 'K' ? CONST_OK_FOR_K (VALUE) : \
 461    (C) == 'L' ? CONST_OK_FOR_L (VALUE) : \
 462    (C) == 'M' ? CONST_OK_FOR_M (VALUE) : \
 463    (C) == 'N' ? CONST_OK_FOR_N (VALUE) : 0)
 464
 465
 466 /* Similar, but for floating constants, and defining letters G and H.
 467    Here VALUE is the CONST_DOUBLE rtx itself.
 468
 469   `G' is a floating-point zero.  */
 470
 471 #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) \
 472   ((C) == 'G' ? (GET_MODE_CLASS (GET_MODE (VALUE)) == MODE_FLOAT        \
 473                  && (VALUE) == CONST0_RTX (GET_MODE (VALUE))) : 0)
 474
 475 \f
 476 /* Stack layout; function entry, exit and calling.  */
 477
 478 /* Define this if pushing a word on the stack
 479    makes the stack pointer a smaller address.  */
 480
 481 #define STACK_GROWS_DOWNWARD
 482
 483 /* Define this if the nominal address of the stack frame
 484    is at the high-address end of the local variables;
 485    that is, each additional local variable allocated
 486    goes at a more negative offset in the frame.  */
 487
 488 #define FRAME_GROWS_DOWNWARD
 489
 490 /* Offset within stack frame to start allocating local variables at.
 491    If FRAME_GROWS_DOWNWARD, this is the offset to the END of the
 492    first local allocated.  Otherwise, it is the offset to the BEGINNING
 493    of the first local allocated.  */
 494
 495 #define STARTING_FRAME_OFFSET 0
 496
 497 /* Offset of first parameter from the argument pointer register value.  */
 498 /* Is equal to the size of the saved fp + pc, even if an fp isn't
 499    saved since the value is used before we know.  */
 500
 501 #define FIRST_PARM_OFFSET(FNDECL) 4
 502
 503 #define ELIMINABLE_REGS                         \
 504 {{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM},   \
 505  { ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM},   \
 506  { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}}
 507
 508 #define CAN_ELIMINATE(FROM, TO) 1
 509
 510 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
 511   OFFSET = initial_offset (FROM, TO)
 512
 513 /* We can debug without frame pointers on the mn10300, so eliminate
 514    them whenever possible.  */
 515 #define FRAME_POINTER_REQUIRED 0
 516 #define CAN_DEBUG_WITHOUT_FP
 517
 518 /* Value is the number of bytes of arguments automatically
 519    popped when returning from a subroutine call.
 520    FUNDECL is the declaration node of the function (as a tree),
 521    FUNTYPE is the data type of the function (as a tree),
 522    or for a library call it is an identifier node for the subroutine name.
 523    SIZE is the number of bytes of arguments passed on the stack.  */
 524
 525 #define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
 526
 527 /* We use d0/d1 for passing parameters, so allocate 8 bytes of space
 528    for a register flushback area.  */
 529 #define REG_PARM_STACK_SPACE(DECL) 8
 530 #define OUTGOING_REG_PARM_STACK_SPACE
 531 #define ACCUMULATE_OUTGOING_ARGS 1
 532
 533 /* So we can allocate space for return pointers once for the function
 534    instead of around every call.  */
 535 #define STACK_POINTER_OFFSET 4
 536
 537 /* 1 if N is a possible register number for function argument passing.
 538    On the MN10300, no registers are used in this way.  */
 539
 540 #define FUNCTION_ARG_REGNO_P(N) ((N) <= 1)
 541
 542 \f
 543 /* Define a data type for recording info about an argument list
 544    during the scan of that argument list.  This data type should
 545    hold all necessary information about the function itself
 546    and about the args processed so far, enough to enable macros
 547    such as FUNCTION_ARG to determine where the next arg should go.
 548
 549    On the MN10300, this is a single integer, which is a number of bytes
 550    of arguments scanned so far.  */
 551
 552 #define CUMULATIVE_ARGS struct cum_arg
 553 struct cum_arg {int nbytes; };
 554
 555 /* Initialize a variable CUM of type CUMULATIVE_ARGS
 556    for a call to a function whose data type is FNTYPE.
 557    For a library call, FNTYPE is 0.
 558
 559    On the MN10300, the offset starts at 0.  */
 560
 561 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT, N_NAMED_ARGS) \
 562  ((CUM).nbytes = 0)
 563
 564 /* Update the data in CUM to advance over an argument
 565    of mode MODE and data type TYPE.
 566    (TYPE is null for libcalls where that information may not be available.)  */
 567
 568 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)    \
 569  ((CUM).nbytes += ((MODE) != BLKmode                    \
 570                    ? (GET_MODE_SIZE (MODE) + 3) & ~3    \
 571                    : (int_size_in_bytes (TYPE) + 3) & ~3))
 572
 573 /* Define where to put the arguments to a function.
 574    Value is zero to push the argument on the stack,
 575    or a hard register in which to store the argument.
 576
 577    MODE is the argument's machine mode.
 578    TYPE is the data type of the argument (as a tree).
 579     This is null for libcalls where that information may
 580     not be available.
 581    CUM is a variable of type CUMULATIVE_ARGS which gives info about
 582     the preceding args and about the function being called.
 583    NAMED is nonzero if this argument is a named parameter
 584     (otherwise it is an extra parameter matching an ellipsis).  */
 585
 586 /* On the MN10300 all args are pushed.  */
 587
 588 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
 589   function_arg (&CUM, MODE, TYPE, NAMED)
 590
 591 /* Define how to find the value returned by a function.
 592    VALTYPE is the data type of the value (as a tree).
 593    If the precise function being called is known, FUNC is its FUNCTION_DECL;
 594    otherwise, FUNC is 0.  */
 595
 596 #define FUNCTION_VALUE(VALTYPE, FUNC) \
 597   gen_rtx_REG (TYPE_MODE (VALTYPE), POINTER_TYPE_P (VALTYPE) \
 598                ? FIRST_ADDRESS_REGNUM : FIRST_DATA_REGNUM)
 599
 600 /* Define how to find the value returned by a library function
 601    assuming the value has mode MODE.  */
 602
 603 #define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, FIRST_DATA_REGNUM)
 604
 605 /* 1 if N is a possible register number for a function value.  */
 606
 607 #define FUNCTION_VALUE_REGNO_P(N) \
 608   ((N) == FIRST_DATA_REGNUM || (N) == FIRST_ADDRESS_REGNUM)
 609
 610 #define DEFAULT_PCC_STRUCT_RETURN 0
 611
 612 /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
 613    the stack pointer does not matter.  The value is tested only in
 614    functions that have frame pointers.
 615    No definition is equivalent to always zero.  */
 616
 617 #define EXIT_IGNORE_STACK 1
 618
 619 /* Output assembler code to FILE to increment profiler label # LABELNO
 620    for profiling a function entry.  */
 621
 622 #define FUNCTION_PROFILER(FILE, LABELNO) ;
 623
 624 #define TRAMPOLINE_TEMPLATE(FILE)                       \
 625   do {                                                  \
 626     fprintf (FILE, "\tadd -4,sp\n");                    \
 627     fprintf (FILE, "\t.long 0x0004fffa\n");             \
 628     fprintf (FILE, "\tmov (0,sp),a0\n");                \
 629     fprintf (FILE, "\tadd 4,sp\n");                     \
 630     fprintf (FILE, "\tmov (13,a0),a1\n");               \
 631     fprintf (FILE, "\tmov (17,a0),a0\n");               \
 632     fprintf (FILE, "\tjmp (a0)\n");                     \
 633     fprintf (FILE, "\t.long 0\n");                      \
 634     fprintf (FILE, "\t.long 0\n");                      \
 635   } while (0)
 636
 637 /* Length in units of the trampoline for entering a nested function.  */
 638
 639 #define TRAMPOLINE_SIZE 0x1b
 640
 641 #define TRAMPOLINE_ALIGNMENT 32
 642
 643 /* Emit RTL insns to initialize the variable parts of a trampoline.
 644    FNADDR is an RTX for the address of the function's pure code.
 645    CXT is an RTX for the static chain value for the function.  */
 646
 647 #define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT)                       \
 648 {                                                                       \
 649   emit_move_insn (gen_rtx_MEM (SImode, plus_constant ((TRAMP), 0x14)),  \
 650                  (CXT));                                                \
 651   emit_move_insn (gen_rtx_MEM (SImode, plus_constant ((TRAMP), 0x18)),  \
 652                  (FNADDR));                                             \
 653 }
 654 /* A C expression whose value is RTL representing the value of the return
 655    address for the frame COUNT steps up from the current frame.
 656
 657    On the mn10300, the return address is not at a constant location
 658    due to the frame layout.  Luckily, it is at a constant offset from
 659    the argument pointer, so we define RETURN_ADDR_RTX to return a
 660    MEM using arg_pointer_rtx.  Reload will replace arg_pointer_rtx
 661    with a reference to the stack/frame pointer + an appropriate offset.  */
 662
 663 #define RETURN_ADDR_RTX(COUNT, FRAME)   \
 664   ((COUNT == 0)                         \
 665    ? gen_rtx_MEM (Pmode, arg_pointer_rtx) \
 666    : (rtx) 0)
 667
 668 /* Implement `va_start' for varargs and stdarg.  */
 669 #define EXPAND_BUILTIN_VA_START(valist, nextarg) \
 670   mn10300_va_start (valist, nextarg)
 671 \f
 672 /* 1 if X is an rtx for a constant that is a valid address.  */
 673
 674 #define CONSTANT_ADDRESS_P(X)   CONSTANT_P (X)
 675
 676 /* Extra constraints.  */
 677
 678 #define OK_FOR_Q(OP) \
 679    (GET_CODE (OP) == MEM && ! CONSTANT_ADDRESS_P (XEXP (OP, 0)))
 680
 681 #define OK_FOR_R(OP) \
 682    (GET_CODE (OP) == MEM                                        \
 683     && GET_MODE (OP) == QImode                                  \
 684     && (CONSTANT_ADDRESS_P (XEXP (OP, 0))                       \
 685         || (GET_CODE (XEXP (OP, 0)) == REG                      \
 686             && REG_OK_FOR_BIT_BASE_P (XEXP (OP, 0))             \
 687             && XEXP (OP, 0) != stack_pointer_rtx)               \
 688         || (GET_CODE (XEXP (OP, 0)) == PLUS                     \
 689             && GET_CODE (XEXP (XEXP (OP, 0), 0)) == REG         \
 690             && REG_OK_FOR_BIT_BASE_P (XEXP (XEXP (OP, 0), 0))   \
 691             && XEXP (XEXP (OP, 0), 0) != stack_pointer_rtx      \
 692             && GET_CODE (XEXP (XEXP (OP, 0), 1)) == CONST_INT   \
 693             && INT_8_BITS (INTVAL (XEXP (XEXP (OP, 0), 1))))))
 694
 695 #define OK_FOR_T(OP) \
 696    (GET_CODE (OP) == MEM                                        \
 697     && GET_MODE (OP) == QImode                                  \
 698     && (GET_CODE (XEXP (OP, 0)) == REG                          \
 699         && REG_OK_FOR_BIT_BASE_P (XEXP (OP, 0))                 \
 700         && XEXP (OP, 0) != stack_pointer_rtx))
 701
 702 #define EXTRA_CONSTRAINT(OP, C) \
 703  ((C) == 'R' ? OK_FOR_R (OP) \
 704   : (C) == 'Q' ? OK_FOR_Q (OP) \
 705   : (C) == 'S' && flag_pic \
 706   ? GET_CODE (OP) == UNSPEC && (XINT (OP, 1) == UNSPEC_PLT \
 707                                 || XINT (OP, 1) == UNSPEC_PIC) \
 708   : (C) == 'S' ? GET_CODE (OP) == SYMBOL_REF \
 709   : (C) == 'T' ? OK_FOR_T (OP) \
 710   : 0)
 711
 712 /* Maximum number of registers that can appear in a valid memory address.  */
 713
 714 #define MAX_REGS_PER_ADDRESS 2
 715
 716 \f
 717 #define HAVE_POST_INCREMENT (TARGET_AM33)
 718
 719 /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression
 720    that is a valid memory address for an instruction.
 721    The MODE argument is the machine mode for the MEM expression
 722    that wants to use this address.
 723
 724    The other macros defined here are used only in GO_IF_LEGITIMATE_ADDRESS,
 725    except for CONSTANT_ADDRESS_P which is actually
 726    machine-independent.
 727
 728    On the mn10300, the value in the address register must be
 729    in the same memory space/segment as the effective address.
 730
 731    This is problematical for reload since it does not understand
 732    that base+index != index+base in a memory reference.
 733
 734    Note it is still possible to use reg+reg addressing modes,
 735    it's just much more difficult.  For a discussion of a possible
 736    workaround and solution, see the comments in pa.c before the
 737    function record_unscaled_index_insn_codes.  */
 738
 739 /* Accept either REG or SUBREG where a register is valid.  */
 740
 741 #define RTX_OK_FOR_BASE_P(X, strict)                            \
 742   ((REG_P (X) && REGNO_STRICT_OK_FOR_BASE_P (REGNO (X),         \
 743                                              (strict)))         \
 744    || (GET_CODE (X) == SUBREG && REG_P (SUBREG_REG (X))         \
 745        && REGNO_STRICT_OK_FOR_BASE_P (REGNO (SUBREG_REG (X)),   \
 746                                       (strict))))
 747
 748 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR)         \
 749 do                                                      \
 750   {                                                     \
 751     if (legitimate_address_p ((MODE), (X), REG_STRICT)) \
 752       goto ADDR;                                        \
 753   }                                                     \
 754 while (0)
 755
 756 \f
 757 /* Try machine-dependent ways of modifying an illegitimate address
 758    to be legitimate.  If we find one, return the new, valid address.
 759    This macro is used in only one place: `memory_address' in explow.c.
 760
 761    OLDX is the address as it was before break_out_memory_refs was called.
 762    In some cases it is useful to look at this to decide what needs to be done.
 763
 764    MODE and WIN are passed so that this macro can use
 765    GO_IF_LEGITIMATE_ADDRESS.
 766
 767    It is always safe for this macro to do nothing.  It exists to recognize
 768    opportunities to optimize the output.  */
 769
 770 #define LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN)  \
 771 { rtx orig_x = (X);                             \
 772   (X) = legitimize_address (X, OLDX, MODE);     \
 773   if ((X) != orig_x && memory_address_p (MODE, X)) \
 774     goto WIN; }
 775
 776 /* Go to LABEL if ADDR (a legitimate address expression)
 777    has an effect that depends on the machine mode it is used for.  */
 778
 779 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL)        \
 780   if (GET_CODE (ADDR) == POST_INC) \
 781     goto LABEL
 782
 783 /* Nonzero if the constant value X is a legitimate general operand.
 784    It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE.  */
 785
 786 #define LEGITIMATE_CONSTANT_P(X) 1
 787
 788 /* Zero if this needs fixing up to become PIC.  */
 789
 790 #define LEGITIMATE_PIC_OPERAND_P(X) (legitimate_pic_operand_p (X))
 791
 792 /* Register to hold the addressing base for
 793    position independent code access to data items.  */
 794 #define PIC_OFFSET_TABLE_REGNUM PIC_REG
 795
 796 /* The name of the pseudo-symbol representing the Global Offset Table.  */
 797 #define GOT_SYMBOL_NAME "*_GLOBAL_OFFSET_TABLE_"
 798
 799 #define SYMBOLIC_CONST_P(X)     \
 800 ((GET_CODE (X) == SYMBOL_REF || GET_CODE (X) == LABEL_REF)      \
 801   && ! LEGITIMATE_PIC_OPERAND_P (X))
 802
 803 /* Non-global SYMBOL_REFs have SYMBOL_REF_FLAG enabled.  */
 804 #define MN10300_GLOBAL_P(X) (! SYMBOL_REF_FLAG (X))
 805
 806 /* Recognize machine-specific patterns that may appear within
 807    constants.  Used for PIC-specific UNSPECs.  */
 808 #define OUTPUT_ADDR_CONST_EXTRA(STREAM, X, FAIL) \
 809   do                                                                    \
 810     if (GET_CODE (X) == UNSPEC && XVECLEN ((X), 0) == 1)        \
 811       {                                                                 \
 812         switch (XINT ((X), 1))                                          \
 813           {                                                             \
 814           case UNSPEC_INT_LABEL:                                        \
 815             asm_fprintf ((STREAM), ".%LLIL%d",                          \
 816                          INTVAL (XVECEXP ((X), 0, 0)));                 \
 817             break;                                                      \
 818           case UNSPEC_PIC:                                              \
 819             /* GLOBAL_OFFSET_TABLE or local symbols, no suffix.  */     \
 820             output_addr_const ((STREAM), XVECEXP ((X), 0, 0));          \
 821             break;                                                      \
 822           case UNSPEC_GOT:                                              \
 823             output_addr_const ((STREAM), XVECEXP ((X), 0, 0));          \
 824             fputs ("@GOT", (STREAM));                                   \
 825             break;                                                      \
 826           case UNSPEC_GOTOFF:                                           \
 827             output_addr_const ((STREAM), XVECEXP ((X), 0, 0));          \
 828             fputs ("@GOTOFF", (STREAM));                                \
 829             break;                                                      \
 830           case UNSPEC_PLT:                                              \
 831             output_addr_const ((STREAM), XVECEXP ((X), 0, 0));          \
 832             fputs ("@PLT", (STREAM));                                   \
 833             break;                                                      \
 834           default:                                                      \
 835             goto FAIL;                                                  \
 836           }                                                             \
 837         break;                                                          \
 838       }                                                                 \
 839     else                                                                \
 840       goto FAIL;                                                        \
 841   while (0)
 842 \f
 843 /* Tell final.c how to eliminate redundant test instructions.  */
 844
 845 /* Here we define machine-dependent flags and fields in cc_status
 846    (see `conditions.h').  No extra ones are needed for the VAX.  */
 847
 848 /* Store in cc_status the expressions
 849    that the condition codes will describe
 850    after execution of an instruction whose pattern is EXP.
 851    Do not alter them if the instruction would not alter the cc's.  */
 852
 853 #define CC_OVERFLOW_UNUSABLE 0x200
 854 #define CC_NO_CARRY CC_NO_OVERFLOW
 855 #define NOTICE_UPDATE_CC(EXP, INSN) notice_update_cc(EXP, INSN)
 856
 857 #define REGISTER_MOVE_COST(MODE, CLASS1, CLASS2) \
 858   ((CLASS1 == CLASS2 && (CLASS1 == ADDRESS_REGS || CLASS1 == DATA_REGS)) ? 2 :\
 859    ((CLASS1 == ADDRESS_REGS || CLASS1 == DATA_REGS) && \
 860     (CLASS2 == ADDRESS_REGS || CLASS2 == DATA_REGS)) ? 4 : \
 861    (CLASS1 == SP_REGS && CLASS2 == ADDRESS_REGS) ? 2 : \
 862    (CLASS1 == ADDRESS_REGS && CLASS2 == SP_REGS) ? 4 : \
 863    ! TARGET_AM33 ? 6 : \
 864    (CLASS1 == SP_REGS || CLASS2 == SP_REGS) ? 6 : \
 865    (CLASS1 == CLASS2 && CLASS1 == EXTENDED_REGS) ? 6 : \
 866    (CLASS1 == FP_REGS || CLASS2 == FP_REGS) ? 6 : \
 867    (CLASS1 == EXTENDED_REGS || CLASS2 == EXTENDED_REGS) ? 4 : \
 868    4)
 869
 870 /* Nonzero if access to memory by bytes or half words is no faster
 871    than accessing full words.  */
 872 #define SLOW_BYTE_ACCESS 1
 873
 874 /* Dispatch tables on the mn10300 are extremely expensive in terms of code
 875    and readonly data size.  So we crank up the case threshold value to
 876    encourage a series of if/else comparisons to implement many small switch
 877    statements.  In theory, this value could be increased much more if we
 878    were solely optimizing for space, but we keep it "reasonable" to avoid
 879    serious code efficiency lossage.  */
 880 #define CASE_VALUES_THRESHOLD 6
 881
 882 #define NO_FUNCTION_CSE
 883
 884 /* According expr.c, a value of around 6 should minimize code size, and
 885    for the MN10300 series, that's our primary concern.  */
 886 #define MOVE_RATIO 6
 887
 888 #define TEXT_SECTION_ASM_OP "\t.section .text"
 889 #define DATA_SECTION_ASM_OP "\t.section .data"
 890 #define BSS_SECTION_ASM_OP "\t.section .bss"
 891
 892 #define ASM_COMMENT_START "#"
 893
 894 /* Output to assembler file text saying following lines
 895    may contain character constants, extra white space, comments, etc.  */
 896
 897 #define ASM_APP_ON "#APP\n"
 898
 899 /* Output to assembler file text saying following lines
 900    no longer contain unusual constructs.  */
 901
 902 #define ASM_APP_OFF "#NO_APP\n"
 903
 904 /* This says how to output the assembler to define a global
 905    uninitialized but not common symbol.
 906    Try to use asm_output_bss to implement this macro.  */
 907
 908 #define ASM_OUTPUT_ALIGNED_BSS(FILE, DECL, NAME, SIZE, ALIGN) \
 909   asm_output_aligned_bss ((FILE), (DECL), (NAME), (SIZE), (ALIGN))
 910
 911 /* Globalizing directive for a label.  */
 912 #define GLOBAL_ASM_OP "\t.global "
 913
 914 /* This is how to output a reference to a user-level label named NAME.
 915    `assemble_name' uses this.  */
 916
 917 #undef ASM_OUTPUT_LABELREF
 918 #define ASM_OUTPUT_LABELREF(FILE, NAME) \
 919   fprintf (FILE, "_%s", (*targetm.strip_name_encoding) (NAME))
 920
 921 #define ASM_PN_FORMAT "%s___%lu"
 922
 923 /* This is how we tell the assembler that two symbols have the same value.  */
 924
 925 #define ASM_OUTPUT_DEF(FILE,NAME1,NAME2) \
 926   do { assemble_name(FILE, NAME1);       \
 927        fputs(" = ", FILE);               \
 928        assemble_name(FILE, NAME2);       \
 929        fputc('\n', FILE); } while (0)
 930
 931
 932 /* How to refer to registers in assembler output.
 933    This sequence is indexed by compiler's hard-register-number (see above).  */
 934
 935 #define REGISTER_NAMES \
 936 { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3", "ap", "sp", \
 937   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7" \
 938 , "fs0", "fs1", "fs2", "fs3", "fs4", "fs5", "fs6", "fs7" \
 939 , "fs8", "fs9", "fs10", "fs11", "fs12", "fs13", "fs14", "fs15" \
 940 , "fs16", "fs17", "fs18", "fs19", "fs20", "fs21", "fs22", "fs23" \
 941 , "fs24", "fs25", "fs26", "fs27", "fs28", "fs29", "fs30", "fs31" \
 942 }
 943
 944 #define ADDITIONAL_REGISTER_NAMES \
 945 { {"r8",  4}, {"r9",  5}, {"r10", 6}, {"r11", 7}, \
 946   {"r12", 0}, {"r13", 1}, {"r14", 2}, {"r15", 3}, \
 947   {"e0", 10}, {"e1", 11}, {"e2", 12}, {"e3", 13}, \
 948   {"e4", 14}, {"e5", 15}, {"e6", 16}, {"e7", 17} \
 949 , {"fd0", 18}, {"fd2", 20}, {"fd4", 22}, {"fd6", 24} \
 950 , {"fd8", 26}, {"fd10", 28}, {"fd12", 30}, {"fd14", 32} \
 951 , {"fd16", 34}, {"fd18", 36}, {"fd20", 38}, {"fd22", 40} \
 952 , {"fd24", 42}, {"fd26", 44}, {"fd28", 46}, {"fd30", 48} \
 953 }
 954
 955 /* Print an instruction operand X on file FILE.
 956    look in mn10300.c for details */
 957
 958 #define PRINT_OPERAND(FILE, X, CODE)  print_operand(FILE,X,CODE)
 959
 960 /* Print a memory operand whose address is X, on file FILE.
 961    This uses a function in output-vax.c.  */
 962
 963 #define PRINT_OPERAND_ADDRESS(FILE, ADDR) print_operand_address (FILE, ADDR)
 964
 965 #define ASM_OUTPUT_REG_PUSH(FILE,REGNO)
 966 #define ASM_OUTPUT_REG_POP(FILE,REGNO)
 967
 968 /* This is how to output an element of a case-vector that is absolute.  */
 969
 970 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \
 971   fprintf (FILE, "\t%s .L%d\n", ".long", VALUE)
 972
 973 /* This is how to output an element of a case-vector that is relative.  */
 974
 975 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) \
 976   fprintf (FILE, "\t%s .L%d-.L%d\n", ".long", VALUE, REL)
 977
 978 #define ASM_OUTPUT_ALIGN(FILE,LOG)      \
 979   if ((LOG) != 0)                       \
 980     fprintf (FILE, "\t.align %d\n", (LOG))
 981
 982 /* We don't have to worry about dbx compatibility for the mn10300.  */
 983 #define DEFAULT_GDB_EXTENSIONS 1
 984
 985 /* Use dwarf2 debugging info by default.  */
 986 #undef PREFERRED_DEBUGGING_TYPE
 987 #define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG
 988
 989 #define DWARF2_ASM_LINE_DEBUG_INFO 1
 990
 991 /* GDB always assumes the current function's frame begins at the value
 992    of the stack pointer upon entry to the current function.  Accessing
 993    local variables and parameters passed on the stack is done using the
 994    base of the frame + an offset provided by GCC.
 995
 996    For functions which have frame pointers this method works fine;
 997    the (frame pointer) == (stack pointer at function entry) and GCC provides
 998    an offset relative to the frame pointer.
 999
1000    This loses for functions without a frame pointer; GCC provides an offset
1001    which is relative to the stack pointer after adjusting for the function's
1002    frame size.  GDB would prefer the offset to be relative to the value of
1003    the stack pointer at the function's entry.  Yuk!  */
1004 #define DEBUGGER_AUTO_OFFSET(X) \
1005   ((GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0) \
1006     + (frame_pointer_needed \
1007        ? 0 : -initial_offset (FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM)))
1008
1009 #define DEBUGGER_ARG_OFFSET(OFFSET, X) \
1010   ((GET_CODE (X) == PLUS ? OFFSET : 0) \
1011     + (frame_pointer_needed \
1012        ? 0 : -initial_offset (ARG_POINTER_REGNUM, STACK_POINTER_REGNUM)))
1013
1014 /* Specify the machine mode that this machine uses
1015    for the index in the tablejump instruction.  */
1016 #define CASE_VECTOR_MODE Pmode
1017
1018 /* Define if operations between registers always perform the operation
1019    on the full register even if a narrower mode is specified.  */
1020 #define WORD_REGISTER_OPERATIONS
1021
1022 #define LOAD_EXTEND_OP(MODE) ZERO_EXTEND
1023
1024 /* This flag, if defined, says the same insns that convert to a signed fixnum
1025    also convert validly to an unsigned one.  */
1026 #define FIXUNS_TRUNC_LIKE_FIX_TRUNC
1027
1028 /* Max number of bytes we can move from memory to memory
1029    in one reasonably fast instruction.  */
1030 #define MOVE_MAX        4
1031
1032 /* Define if shifts truncate the shift count
1033    which implies one can omit a sign-extension or zero-extension
1034    of a shift count.  */
1035 #define SHIFT_COUNT_TRUNCATED 1
1036
1037 /* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits
1038    is done just by pretending it is already truncated.  */
1039 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
1040
1041 /* Specify the machine mode that pointers have.
1042    After generation of rtl, the compiler makes no further distinction
1043    between pointers and any other objects of this machine mode.  */
1044 #define Pmode SImode
1045
1046 /* A function address in a call instruction
1047    is a byte address (for indexing purposes)
1048    so give the MEM rtx a byte's mode.  */
1049 #define FUNCTION_MODE QImode
1050
1051 /* The assembler op to get a word.  */
1052
1053 #define FILE_ASM_OP "\t.file\n"
1054
1055 typedef struct mn10300_cc_status_mdep
1056   {
1057     int fpCC;
1058   }
1059 cc_status_mdep;
1060
1061 #define CC_STATUS_MDEP cc_status_mdep
1062
1063 #define CC_STATUS_MDEP_INIT (cc_status.mdep.fpCC = 0)