gcc/config/mep/mep.h

   1 /* Definitions for Toshiba Media Processor
   2    Copyright (C) 2001, 2003, 2004, 2005, 2007, 2008, 2009, 2010
   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 it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21 \f
  22
  23 #undef  CPP_SPEC
  24 #define CPP_SPEC "\
  25 -D__MEP__ -D__MeP__ \
  26 -D__section(_x)=__attribute__((section(_x))) \
  27 -D__align(_x)=__attribute__((aligned(_x))) \
  28 -D__io(_x)=__attribute__((io(_x))) \
  29 -D__cb(_x)=__attribute__((cb(_x))) \
  30 -D__based=__attribute__((based)) \
  31 -D__tiny=__attribute__((tiny)) \
  32 -D__near=__attribute__((near)) \
  33 -D__far=__attribute__((far)) \
  34 -D__vliw=__attribute__((vliw)) \
  35 -D__interrupt=__attribute__((interrupt)) \
  36 -D__disinterrupt=__attribute__((disinterrupt)) \
  37 %{!meb:%{!mel:-D__BIG_ENDIAN__}} \
  38 %{meb:-U__LITTLE_ENDIAN__ -D__BIG_ENDIAN__} \
  39 %{mel:-U__BIG_ENDIAN__ -D__LITTLE_ENDIAN__} \
  40 %{mconfig=*:-D__MEP_CONFIG_%*} \
  41 %{mivc2:-D__MEP_CONFIG_CP_DATA_BUS_WIDTH=64} \
  42 "
  43
  44 #undef  CC1_SPEC
  45 #define CC1_SPEC "%{!mlibrary:%(config_cc_spec)} \
  46 %{!.cc:%{O2:%{!funroll*:--param max-completely-peeled-insns=6 \
  47                         --param max-unrolled-insns=6 -funroll-loops}}}"
  48
  49 #undef  CC1PLUS_SPEC
  50 #define CC1PLUS_SPEC "%{!mlibrary:%(config_cc_spec)}"
  51
  52 #undef  ASM_SPEC
  53 #define ASM_SPEC "%{mconfig=*} %{meb:-EB} %{mel:-EL} \
  54 %{mno-satur} %{msatur} %{mno-clip} %{mclip} %{mno-minmax} %{mminmax} \
  55 %{mno-absdiff} %{mabsdiff} %{mno-leadz} %{mleadz} %{mno-bitops} %{mbitops} \
  56 %{mno-div} %{mdiv} %{mno-mult} %{mmult} %{mno-average} %{maverage} \
  57 %{mcop32} %{mno-debug} %{mdebug} %{mlibrary}"
  58
  59 /* The MeP config tool will edit this spec.  */
  60 #undef  STARTFILE_SPEC
  61 #define STARTFILE_SPEC "%{msdram:%{msim:simsdram-crt0.o%s}} \
  62 %{mno-sdram:%{msim:sim-crt0.o%s}} \
  63 %{msdram:%{!msim*:sdram-crt0.o%s}} \
  64 %{mno-sdram:%{!msim*:crt0.o%s}} \
  65 %(config_start_spec) \
  66 %{msimnovec:simnovec-crt0.o%s} \
  67 crtbegin.o%s"
  68
  69 #undef  LIB_SPEC
  70 #define LIB_SPEC "-( -lc %{msim*:-lsim}%{!msim*:-lnosys} -) %(config_link_spec)"
  71
  72 #undef  LINK_SPEC
  73 #define LINK_SPEC "%{meb:-EB} %{mel:-EL}"
  74
  75 #undef  ENDFILE_SPEC
  76 #define ENDFILE_SPEC "crtend.o%s %{msim*:sim-crtn.o%s}%{!msim*:crtn.o%s}"
  77
  78 /* The MeP config tool will edit this spec.  */
  79 #define CONFIG_CC_SPEC "\
  80 %{mconfig=default: -mbitops -mleadz -mabsdiff -maverage -mminmax -mclip -msatur -mvl64 -mvliw -mcop64 -D__MEP_CONFIG_CP_DATA_BUS_WIDTH=64 -mivc2}\
  81 "
  82 /* end-config-cc-spec */
  83
  84 /* The MeP config tool will edit this spec.  */
  85 #define CONFIG_LINK_SPEC "\
  86 %{mconfig=default: %{!T*:-Tdefault.ld}}\
  87 "
  88 /* end-config-link-spec */
  89
  90 /* The MeP config tool will edit this spec.  */
  91 #define CONFIG_START_SPEC "\
  92 %{!msdram:%{!mno-sdram:%{!msim*:crt0.o%s}}} \
  93 %{!msdram:%{!mno-sdram:%{msim:sim-crt0.o%s}}} \
  94 "
  95 /* end-config-start-spec */
  96
  97 #define EXTRA_SPECS \
  98   { "config_cc_spec",  CONFIG_CC_SPEC }, \
  99   { "config_link_spec",  CONFIG_LINK_SPEC }, \
 100   { "config_start_spec",  CONFIG_START_SPEC },
 101 \f
 102
 103 #define TARGET_CPU_CPP_BUILTINS()               \
 104   do                                            \
 105     {                                           \
 106       builtin_define_std ("mep");               \
 107       builtin_assert ("machine=mep");           \
 108     }                                           \
 109   while (0)
 110
 111 /* Controlled by MeP-Integrator.  */
 112 #define TARGET_H1               0
 113
 114 #define MEP_ALL_OPTS    (MASK_OPT_AVERAGE       \
 115                          | MASK_OPT_MULT        \
 116                          | MASK_OPT_DIV         \
 117                          | MASK_OPT_BITOPS      \
 118                          | MASK_OPT_LEADZ       \
 119                          | MASK_OPT_ABSDIFF     \
 120                          | MASK_OPT_MINMAX      \
 121                          | MASK_OPT_CLIP        \
 122                          | MASK_OPT_SATUR )
 123
 124 #define TARGET_DEFAULT          (MASK_IO_VOLATILE | MASK_OPT_REPEAT | MEP_ALL_OPTS | MASK_LITTLE_ENDIAN)
 125
 126 #define TARGET_IO_NO_VOLATILE   (! (target_flags & MASK_IO_VOLATILE))
 127 #define TARGET_OPT_NOREPEAT     (! (target_flags & MASK_OPT_REPEAT))
 128 #define TARGET_32BIT_CR_REGS    (! (target_flags & MASK_64BIT_CR_REGS))
 129 #define TARGET_BIG_ENDIAN       (! (target_flags & MASK_LITTLE_ENDIAN))
 130
 131 #define TARGET_COPRO_MULT       0
 132
 133 #define TARGET_VERSION fprintf (stderr, " (Toshiba Media Processor (MeP))");
 134
 135 /* The MeP config tool will replace this as appropriate.  */
 136 #define DEFAULT_ENDIAN_SPEC "%{!meb: -mel}"
 137
 138 /* The MeP config tool will replace this with an -mconfig= switch.  */
 139 #define LIBRARY_CONFIG_SPEC "-mconfig=default"
 140
 141 /* Don't add an endian option when building the libraries.  */
 142 #define DRIVER_SELF_SPECS \
 143   "%{!mlibrary:" DEFAULT_ENDIAN_SPEC "}", \
 144   "%{mlibrary: " LIBRARY_CONFIG_SPEC " %{!mel:-meb}}", \
 145   "%{mall-opts:-maverage -mmult -mdiv -mbitops -mleadz \
 146      -mabsdiff -mminmax -mclip -msatur -mdebug} %<mall-opts", \
 147   "%{mno-opts:-mno-average -mno-mult -mno-div -mno-bitops -mno-leadz \
 148      -mno-absdiff -mno-minmax -mno-clip -mno-satur -mno-debug} %<mno-opts", \
 149   "%{mfar:-ml -mtf -mc=far} %<mfar", \
 150   "%{mconfig=default:-mmult -mdiv -D__MEP_CONFIG_ISA=1}"
 151
 152 /* The MeP config tool will add COPROC_SELECTION_TABLE here.  */
 153 /* start-coproc-selection-table */
 154 #define COPROC_SELECTION_TABLE \
 155 {"default", ISA_EXT1}
 156 /* end-coproc-selection-table */
 157 \f
 158
 159 #define BITS_BIG_ENDIAN 0
 160 #define BYTES_BIG_ENDIAN (TARGET_LITTLE_ENDIAN ? 0 : 1)
 161 #define WORDS_BIG_ENDIAN (TARGET_LITTLE_ENDIAN ? 0 : 1)
 162
 163 #define UNITS_PER_WORD 4
 164
 165 #define PROMOTE_MODE(MODE, UNSIGNEDP, TYPE)     \
 166   do                                            \
 167     {                                           \
 168       if (GET_MODE_CLASS (MODE) == MODE_INT     \
 169           && GET_MODE_SIZE (MODE) < 4)          \
 170         (MODE) = SImode;                \
 171     }                                           \
 172   while (0)
 173
 174 #define PARM_BOUNDARY 32
 175 #define STACK_BOUNDARY 32
 176 #define PREFERRED_STACK_BOUNDARY 64
 177 #define FUNCTION_BOUNDARY 16
 178 #define BIGGEST_ALIGNMENT 64
 179
 180 #define DATA_ALIGNMENT(TYPE, ALIGN)             \
 181   (TREE_CODE (TYPE) == ARRAY_TYPE               \
 182    && TYPE_MODE (TREE_TYPE (TYPE)) == QImode    \
 183    && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
 184
 185 #define CONSTANT_ALIGNMENT(EXP, ALIGN)  \
 186   (TREE_CODE (EXP) == STRING_CST        \
 187    && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
 188
 189 #define STRICT_ALIGNMENT 1
 190
 191 #define PCC_BITFIELD_TYPE_MATTERS 1
 192
 193 #define DEFAULT_VTABLE_THUNKS 1
 194
 195 \f
 196 #define INT_TYPE_SIZE         32
 197 #define SHORT_TYPE_SIZE       16
 198 #define LONG_TYPE_SIZE        32
 199 #define LONG_LONG_TYPE_SIZE   64
 200 #define CHAR_TYPE_SIZE         8
 201 #define FLOAT_TYPE_SIZE       32
 202 #define DOUBLE_TYPE_SIZE      64
 203 #define LONG_DOUBLE_TYPE_SIZE 64
 204 #define DEFAULT_SIGNED_CHAR    1
 205
 206 #undef  SIZE_TYPE
 207 #define SIZE_TYPE "unsigned int"
 208
 209 #undef  PTRDIFF_TYPE
 210 #define PTRDIFF_TYPE "int"
 211
 212 #undef  WCHAR_TYPE
 213 #define WCHAR_TYPE "long int"
 214
 215 #undef  WCHAR_TYPE_SIZE
 216 #define WCHAR_TYPE_SIZE BITS_PER_WORD
 217 \f
 218 /* Register numbers:
 219         0..15   core registers
 220         16..47  control registers
 221         48..79  coprocessor registers
 222         80..111 coprocessor control registers
 223         112     virtual arg pointer register  */
 224
 225 #define FIRST_PSEUDO_REGISTER (LAST_SHADOW_REGISTER + 1)
 226
 227   /* R12 is optionally FP.  R13 is TP, R14 is GP, R15 is SP. */
 228   /* hi and lo can be used as general registers.  Others have
 229      immutable bits.  */
 230 /* A "1" here means the register is generally not available to gcc,
 231    and is assumed to remain unchanged or unused throughout.  */
 232 #define FIXED_REGISTERS {                               \
 233   /* core registers */                                  \
 234   0, 0, 0, 0,  0, 0, 0, 0,  0, 0, 0, 0,  0, 0, 0, 1,    \
 235   /* control registers */                               \
 236   1, 1, 1, 1,  1, 1, 1, 0,  0, 1, 1, 1,  1, 1, 1, 1,    \
 237   1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,    \
 238   /* coprocessor registers */                           \
 239   1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,    \
 240   1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,    \
 241   /* coprocessor control registers */                   \
 242   1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,    \
 243   1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,    \
 244   /* virtual arg pointer */                             \
 245   1, FIXED_SHADOW_REGISTERS                             \
 246   }
 247
 248 /* This is a call-clobbered reg not used for args or return value,
 249    that we use as a temp for saving control registers in the prolog
 250    and restoring them in the epilog. */
 251 #define REGSAVE_CONTROL_TEMP    11
 252
 253 /* A "1" here means a register may be changed by a function without
 254    needing to preserve its previous value.  */
 255 #define CALL_USED_REGISTERS {                           \
 256   /* core registers */                                  \
 257   1, 1, 1, 1,  1, 0, 0, 0,  0, 1, 1, 1,  1, 0, 0, 1,    \
 258   /* control registers */                               \
 259   1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,    \
 260   1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,    \
 261   /* coprocessor registers */                           \
 262   1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,    \
 263   1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,    \
 264   /* coprocessor control registers */                   \
 265   1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,    \
 266   1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,  1, 1, 1, 1,    \
 267   /* virtual arg pointer */                             \
 268   1, CALL_USED_SHADOW_REGISTERS                         \
 269   }
 270
 271 #define REG_ALLOC_ORDER {                                               \
 272   /* core registers */                                                  \
 273   3, 2, 1, 0, 9, 10, 11, 12, 4, 5, 6, 7, 8, 13, 14, 15,                 \
 274   /* control registers */                                               \
 275   16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,       \
 276   32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,       \
 277   /* coprocessor registers */                                           \
 278   /* Prefer to use the non-loadable registers when looking for a        \
 279      member of CR_REGS (as opposed to LOADABLE_CR_REGS).  */            \
 280   64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 48, 49, 50, 51, 52, 58,       \
 281   59, 60, 61, 62, 63, 53, 54, 55, 56, 57, 74, 75, 76, 77, 78, 79,       \
 282   /* coprocessor control registers */                                   \
 283   80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,       \
 284   96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, \
 285   /* virtual arg pointer */                                             \
 286   112, SHADOW_REG_ALLOC_ORDER                                           \
 287   }
 288
 289 /* We must somehow disable register remapping for interrupt functions.  */
 290 extern char mep_leaf_registers[];
 291 #define LEAF_REGISTERS mep_leaf_registers
 292 #define LEAF_REG_REMAP(REG) (REG)
 293
 294 \f
 295 #define FIRST_GR_REGNO 0
 296 #define FIRST_CONTROL_REGNO (FIRST_GR_REGNO + 16)
 297 #define FIRST_CR_REGNO (FIRST_CONTROL_REGNO + 32)
 298 #define FIRST_CCR_REGNO (FIRST_CR_REGNO + 32)
 299
 300 #define GR_REGNO_P(REGNO) \
 301   ((unsigned) ((REGNO) - FIRST_GR_REGNO) < 16)
 302
 303 #define CONTROL_REGNO_P(REGNO) \
 304   ((unsigned) ((REGNO) - FIRST_CONTROL_REGNO) < 32)
 305
 306 #define LOADABLE_CR_REGNO_P(REGNO) \
 307   ((unsigned) ((REGNO) - FIRST_CR_REGNO) < 16)
 308
 309 #define CR_REGNO_P(REGNO) \
 310   ((unsigned) ((REGNO) - FIRST_CR_REGNO) < 32)
 311
 312 #define CCR_REGNO_P(REGNO) \
 313   ((unsigned) ((REGNO) - FIRST_CCR_REGNO) < 32)
 314
 315 #define ANY_CONTROL_REGNO_P(REGNO) \
 316   (CONTROL_REGNO_P (REGNO) || CCR_REGNO_P (REGNO))
 317
 318 #define HARD_REGNO_NREGS(REGNO, MODE)           \
 319   ((CR_REGNO_P (REGNO) && TARGET_64BIT_CR_REGS) \
 320    ? (GET_MODE_SIZE (MODE) + 8 - 1) / 8         \
 321    : (GET_MODE_SIZE (MODE) + 4 - 1) / 4)
 322
 323 #define HARD_REGNO_MODE_OK(REGNO, MODE) 1
 324
 325 #define MODES_TIEABLE_P(MODE1, MODE2) 1
 326
 327 #define CANNOT_CHANGE_MODE_CLASS(FROM, TO, CLASS) \
 328   mep_cannot_change_mode_class (FROM, TO, CLASS)
 329 \f
 330 enum reg_class
 331 {
 332   NO_REGS,
 333   SP_REGS,
 334   TP_REGS,
 335   GP_REGS,
 336   R0_REGS,
 337   RPC_REGS,
 338   HI_REGS,
 339   LO_REGS,
 340   HILO_REGS,
 341   TPREL_REGS,
 342   GENERAL_NOT_R0_REGS,
 343   GENERAL_REGS,
 344   CONTROL_REGS,
 345   CONTROL_OR_GENERAL_REGS,
 346   USER0_REGS,
 347   USER1_REGS,
 348   USER2_REGS,
 349   USER3_REGS,
 350   LOADABLE_CR_REGS,
 351   CR_REGS,
 352   CCR_REGS,
 353   ALL_REGS,
 354   LIM_REG_CLASSES
 355 };
 356
 357 #define N_REG_CLASSES ((int) LIM_REG_CLASSES)
 358
 359 #define REG_CLASS_NAMES { \
 360   "NO_REGS", \
 361   "SP_REGS", \
 362   "TP_REGS", \
 363   "GP_REGS", \
 364   "R0_REGS", \
 365   "RPC_REGS", \
 366   "HI_REGS", \
 367   "LO_REGS", \
 368   "HILO_REGS", \
 369   "TPREL_REGS", \
 370   "GENERAL_NOT_R0_REGS", \
 371   "GENERAL_REGS", \
 372   "CONTROL_REGS", \
 373   "CONTROL_OR_GENERAL_REGS", \
 374   "USER0_REGS", \
 375   "USER1_REGS", \
 376   "USER2_REGS", \
 377   "USER3_REGS", \
 378   "LOADABLE_CR_REGS", \
 379   "CR_REGS", \
 380   "CCR_REGS", \
 381   "ALL_REGS" }
 382
 383 #define REG_CLASS_CONTENTS { \
 384   { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* NO_REGS */ \
 385   { 0x00008000, 0x00000000, 0x00000000, 0x00000000 }, /* SP_REGS */ \
 386   { 0x00002000, 0x00000000, 0x00000000, 0x00000000 }, /* TP_REGS */ \
 387   { 0x00004000, 0x00000000, 0x00000000, 0x00000000 }, /* GP_REGS */ \
 388   { 0x00000001, 0x00000000, 0x00000000, 0x00000000 }, /* R0_REGS */ \
 389   { 0x00400000, 0x00000000, 0x00000000, 0x00000000 }, /* RPC_REGS */ \
 390   { 0x00800000, 0x00000000, 0x00000000, 0x00000000 }, /* HI_REGS */ \
 391   { 0x01000000, 0x00000000, 0x00000000, 0x00000000 }, /* LO_REGS */ \
 392   { 0x01800000, 0x00000000, 0x00000000, 0x00000000 }, /* HILO_REGS */ \
 393   { 0x000000ff, 0x00000000, 0x00000000, 0x00000000 }, /* TPREL_REGS */ \
 394   { 0x0000fffe, 0x00000000, 0x00000000, 0x00000000 }, /* GENERAL_NOT_R0_REGS */ \
 395   { 0x0000ffff, 0x00000000, 0x00000000, 0x00010000 }, /* GENERAL_REGS */ \
 396   { 0xffff0000, 0x0000ffff, 0x00000000, 0x00000000 }, /* CONTROL_REGS */ \
 397   { 0xffffffff, 0x0000ffff, 0x00000000, 0x00000000 }, /* CONTROL_OR_GENERAL_REGS */ \
 398   { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* USER0_REGS */ \
 399   { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* USER1_REGS */ \
 400   { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* USER2_REGS */ \
 401   { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* USER3_REGS */ \
 402   { 0x00000000, 0xffff0000, 0x00000000, 0x00000000 }, /* LOADABLE_CR_REGS */ \
 403   { 0x00000000, 0xffff0000, 0x0000ffff, 0x00000000 }, /* CR_REGS */ \
 404   { 0x00000000, 0x00000000, 0xffff0000, 0x0000ffff }, /* CCR_REGS */ \
 405   { 0xffffffff, 0xffffffff, 0xffffffff, 0x0001ffff }, /* ALL_REGS */ \
 406   }
 407
 408 #define REGNO_REG_CLASS(REGNO) (enum reg_class) mep_regno_reg_class (REGNO)
 409
 410 #define IRA_COVER_CLASSES { GENERAL_REGS, CONTROL_REGS, CR_REGS, CCR_REGS, LIM_REG_CLASSES }
 411
 412 #define BASE_REG_CLASS GENERAL_REGS
 413 #define INDEX_REG_CLASS GENERAL_REGS
 414
 415 #if 0
 416 #define REG_CLASS_FROM_CONSTRAINT(CHAR, STRING) \
 417         mep_reg_class_from_constraint (CHAR, STRING)
 418 #endif
 419
 420 #define REGNO_OK_FOR_BASE_P(NUM) (GR_REGNO_P (NUM) \
 421         || (NUM) == ARG_POINTER_REGNUM \
 422         || (NUM) >= FIRST_PSEUDO_REGISTER)
 423
 424 #define REGNO_OK_FOR_INDEX_P(NUM) REGNO_OK_FOR_BASE_P (NUM)
 425
 426 #define PREFERRED_RELOAD_CLASS(X, CLASS) mep_preferred_reload_class (X, CLASS)
 427
 428 #define SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, X) \
 429         mep_secondary_input_reload_class (CLASS, MODE, X)
 430 #define SECONDARY_OUTPUT_RELOAD_CLASS(CLASS, MODE, X) \
 431         mep_secondary_output_reload_class (CLASS, MODE, X)
 432 #define SECONDARY_MEMORY_NEEDED(CLASS1, CLASS2, MODE) \
 433         mep_secondary_memory_needed (CLASS1, CLASS2, MODE)
 434
 435 #define CLASS_MAX_NREGS(CLASS, MODE) \
 436   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
 437
 438 #if 0
 439 #define CONST_OK_FOR_LETTER_P(VALUE, C) mep_const_ok_for_letter_p (VALUE, C)
 440
 441 #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) 0
 442
 443 #define CONSTRAINT_LEN(C, STR) \
 444         ((C) == 'e' ? 2 : DEFAULT_CONSTRAINT_LEN (C, STR))
 445 #define EXTRA_CONSTRAINT(VALUE, C) mep_extra_constraint (VALUE, C)
 446 #endif
 447
 448 #define WANT_GCC_DECLARATIONS
 449 #include "mep-intrin.h"
 450 #undef WANT_GCC_DECLARATIONS
 451
 452 extern int mep_intrinsic_insn[];
 453 extern unsigned int mep_selected_isa;
 454
 455 /* True if intrinsic X is available.  X is a mep_* value declared
 456    in mep-intrin.h.  */
 457 #define MEP_INTRINSIC_AVAILABLE_P(X) (mep_intrinsic_insn[X] >= 0)
 458
 459 /* Used to define CGEN_ENABLE_INTRINSIC_P in mep-intrin.h.  */
 460 #define CGEN_CURRENT_ISAS mep_selected_isa
 461 #define CGEN_CURRENT_GROUP \
 462   (mep_vliw_function_p (cfun->decl) ? GROUP_VLIW : GROUP_NORMAL)
 463
 464 \f
 465
 466 #define STACK_GROWS_DOWNWARD       1
 467 #define FRAME_GROWS_DOWNWARD       1
 468 #define STARTING_FRAME_OFFSET      0
 469 #define FIRST_PARM_OFFSET(FUNDECL) 0
 470 #define INCOMING_FRAME_SP_OFFSET   0
 471
 472 #define RETURN_ADDR_RTX(COUNT, FRAMEADDR) mep_return_addr_rtx (COUNT)
 473 #define INCOMING_RETURN_ADDR_RTX          gen_rtx_REG (SImode, LP_REGNO)
 474 #define DWARF_FRAME_RETURN_COLUMN         LP_REGNO
 475
 476 #define STACK_POINTER_REGNUM          15
 477 #define FRAME_POINTER_REGNUM           8
 478 #define ARG_POINTER_REGNUM            112
 479 #define RETURN_ADDRESS_POINTER_REGNUM 17
 480 #define STATIC_CHAIN_REGNUM            0
 481
 482 \f
 483
 484 #define ELIMINABLE_REGS                                         \
 485 {                                                               \
 486   {ARG_POINTER_REGNUM,   STACK_POINTER_REGNUM},                 \
 487   {ARG_POINTER_REGNUM,   FRAME_POINTER_REGNUM},                 \
 488   {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}                  \
 489 }
 490
 491 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
 492         (OFFSET) = mep_elimination_offset (FROM, TO)
 493
 494 #define ACCUMULATE_OUTGOING_ARGS 1
 495
 496 \f
 497
 498 #define FUNCTION_ARG_CALLEE_COPIES(CUM, MODE, TYPE, NAMED) 1
 499
 500 typedef struct
 501 {
 502   int nregs;
 503   int vliw;
 504 } CUMULATIVE_ARGS;
 505
 506 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, FNDECL, N_NAMED_ARGS) \
 507         mep_init_cumulative_args (& (CUM), FNTYPE, LIBNAME, FNDECL)
 508
 509 #define FUNCTION_ARG_REGNO_P(REGNO) \
 510         (((REGNO) >= 1 && (REGNO) <= 4) \
 511          || ((REGNO) >= FIRST_CR_REGNO + 1 \
 512              && (REGNO) <= FIRST_CR_REGNO + 4 \
 513              && TARGET_COP))
 514
 515 #define RETURN_VALUE_REGNUM      0
 516
 517 #define FUNCTION_VALUE(VALTYPE, FUNC) mep_function_value (VALTYPE, FUNC)
 518 #define LIBCALL_VALUE(MODE) mep_libcall_value (MODE)
 519
 520 #define FUNCTION_VALUE_REGNO_P(REGNO)                           \
 521   ((REGNO) == RETURN_VALUE_REGNUM)
 522
 523 #define DEFAULT_PCC_STRUCT_RETURN 0
 524
 525 #define STRUCT_VALUE 0
 526
 527 #define FUNCTION_OK_FOR_SIBCALL(DECL) mep_function_ok_for_sibcall(DECL)
 528 \f
 529 /* Prologue and epilogues are all handled via RTL.  */
 530
 531 #define EXIT_IGNORE_STACK 1
 532
 533 #define EPILOGUE_USES(REGNO)  mep_epilogue_uses (REGNO)
 534
 535 /* Profiling is supported.  */
 536
 537 #define FUNCTION_PROFILER(FILE, LABELNO) mep_function_profiler (FILE);
 538 #undef TARGET_HAS_F_SETLKW
 539 #define NO_PROFILE_COUNTERS 1
 540 \f
 541 /* Trampolines are built at run-time.  The cache is invalidated at
 542    run-time also.  */
 543
 544 #define TRAMPOLINE_SIZE 20
 545 \f
 546
 547 #define MAX_REGS_PER_ADDRESS 1
 548
 549 #ifdef REG_OK_STRICT
 550 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL)                \
 551         if (mep_legitimate_address ((MODE), (X), 1)) goto LABEL
 552 #else
 553 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL)                \
 554         if (mep_legitimate_address ((MODE), (X), 0)) goto LABEL
 555 #endif
 556
 557 #ifdef REG_OK_STRICT
 558 #define REG_OK_FOR_BASE_P(X) GR_REGNO_P (REGNO (X))
 559 #else
 560 #define REG_OK_FOR_BASE_P(X) (GR_REGNO_P (REGNO (X)) \
 561                                 || REGNO (X) == ARG_POINTER_REGNUM \
 562                                 || REGNO (X) >= FIRST_PSEUDO_REGISTER)
 563 #endif
 564
 565 #define REG_OK_FOR_INDEX_P(X) REG_OK_FOR_BASE_P (X)
 566
 567 #define LEGITIMIZE_RELOAD_ADDRESS(X, MODE, OPNUM, TYPE, IND_LEVELS, WIN) \
 568   if (mep_legitimize_reload_address (&(X), (MODE), (OPNUM), (TYPE), (IND_LEVELS))) \
 569     goto WIN
 570
 571 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR, LABEL)
 572
 573 #define LEGITIMATE_CONSTANT_P(X) \
 574   mep_legitimate_constant_p(X)
 575
 576 #define SELECT_CC_MODE(OP, X, Y)  CCmode
 577 \f
 578
 579 /* Moves between control regs need a scratch.  */
 580 #define REGISTER_MOVE_COST(MODE, FROM, TO) mep_register_move_cost (MODE, FROM, TO)
 581
 582 #define SLOW_BYTE_ACCESS 1
 583
 584 /* Define this macro if it is as good or better to call a constant function
 585    address than to call an address kept in a register.  */
 586 #define NO_FUNCTION_CSE
 587
 588 \f
 589 #define TEXT_SECTION_ASM_OP "\t.text\n\t.core"
 590 #define DATA_SECTION_ASM_OP "\t.data"
 591 #define BSS_SECTION_ASM_OP  ".bss"
 592
 593 #define USE_SELECT_SECTION_FOR_FUNCTIONS 1
 594
 595 #define JUMP_TABLES_IN_TEXT_SECTION 1
 596
 597 #define TARGET_ASM_FILE_END mep_file_cleanups
 598
 599 #define ASM_APP_ON "#APP\n"
 600 #define ASM_APP_OFF "#NO_APP\n"
 601
 602 #define ASM_OUTPUT_DOUBLE(FILE, VALUE)                          \
 603   do                                                            \
 604     {                                                           \
 605       long l[2];                                                \
 606                                                                 \
 607       REAL_VALUE_TO_TARGET_DOUBLE (VALUE, l);                   \
 608       fprintf (FILE, "\t.long\t0x%lx,0x%lx\n", l[0], l[1]);     \
 609     }                                                           \
 610   while (0)
 611
 612 #define ASM_OUTPUT_FLOAT(FILE, VALUE)           \
 613   do                                            \
 614     {                                           \
 615       long l;                                   \
 616                                                 \
 617       REAL_VALUE_TO_TARGET_SINGLE (VALUE, l);   \
 618       fprintf ((FILE), "\t.long\t0x%lx\n", l);  \
 619     }                                           \
 620   while (0)
 621
 622 #define ASM_OUTPUT_CHAR(FILE, VALUE)            \
 623   do                                            \
 624     {                                           \
 625       fprintf (FILE, "\t.byte\t");              \
 626       output_addr_const (FILE, (VALUE));        \
 627       fprintf (FILE, "\n");                     \
 628     }                                           \
 629   while (0)
 630
 631 #define ASM_OUTPUT_SHORT(FILE, VALUE)           \
 632   do                                            \
 633     {                                           \
 634       fprintf (FILE, "\t.hword\t");             \
 635       output_addr_const (FILE, (VALUE));        \
 636       fprintf (FILE, "\n");                     \
 637     }                                           \
 638   while (0)
 639
 640 #define ASM_OUTPUT_INT(FILE, VALUE)             \
 641   do                                            \
 642     {                                           \
 643       fprintf (FILE, "\t.word\t");              \
 644       output_addr_const (FILE, (VALUE));        \
 645       fprintf (FILE, "\n");                     \
 646     }                                           \
 647   while (0)
 648
 649 #define ASM_OUTPUT_BYTE(STREAM, VALUE) \
 650   fprintf (STREAM, "\t%s\t0x%x\n", ASM_BYTE_OP, (VALUE))
 651
 652 /* Most of these are here to support based/tiny/far/io attributes.  */
 653
 654 #define ASM_OUTPUT_ALIGNED_DECL_COMMON(STREAM, DECL, NAME, SIZE, ALIGNMENT) \
 655         mep_output_aligned_common (STREAM, DECL, NAME, SIZE, ALIGNMENT, 1)
 656
 657 #define ASM_OUTPUT_ALIGNED_DECL_LOCAL(STREAM, DECL, NAME, SIZE, ALIGNMENT) \
 658         mep_output_aligned_common (STREAM, DECL, NAME, SIZE, ALIGNMENT, 0)
 659
 660 #define ASM_OUTPUT_LABEL(STREAM, NAME)          \
 661   do                                            \
 662     {                                           \
 663       assemble_name (STREAM, NAME);             \
 664       fputs (":\n", STREAM);                    \
 665     }                                           \
 666   while (0)
 667
 668 /* Globalizing directive for a label.  */
 669 #define GLOBAL_ASM_OP "\t.globl "
 670
 671 #define ASM_OUTPUT_LABELREF(STREAM, NAME) \
 672   asm_fprintf ((STREAM), "%U%s", mep_strip_name_encoding (NAME))
 673
 674 #define ASM_FORMAT_PRIVATE_NAME(OUTVAR, NAME, NUMBER)           \
 675   do                                                            \
 676     {                                                           \
 677       (OUTVAR) = (char *) alloca (strlen ((NAME)) + 12);        \
 678       sprintf ((OUTVAR), "%s.%ld", (NAME), (long)(NUMBER));     \
 679     }                                                           \
 680   while (0)
 681 \f
 682
 683 #define REGISTER_NAMES                                                  \
 684 {                                                                       \
 685   /* Core registers.  */                                                \
 686   "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",                       \
 687   "$8", "$9", "$10", "$11", "$12", "$tp", "$gp", "$sp",                 \
 688   /* Control registers.  */                                             \
 689   "$pc", "$lp", "$sar", "3", "$rpb", "$rpe", "$rpc", "$hi",             \
 690   "$lo", "9", "10", "11", "$mb0", "$me0", "$mb1", "$me1",               \
 691   "$psw", "$id", "$tmp", "$epc", "$exc", "$cfg", "22", "$npc",          \
 692   "$dbg", "$depc", "$opt", "$rcfg", "$ccfg", "29", "30", "31",          \
 693   /* Coprocessor registers.  */                                         \
 694   "$c0", "$c1", "$c2", "$c3", "$c4", "$c5", "$c6", "$c7",               \
 695   "$c8", "$c9", "$c10", "$c11", "$c12", "$c13", "$c14", "$c15",         \
 696   "$c16", "$c17", "$c18", "$c19", "$c20", "$c21", "$c22", "$c23",       \
 697   "$c24", "$c25", "$c26", "$c27", "$c28", "$c29", "$c30", "$c31",       \
 698   /* Coprocessor control registers.  */                                 \
 699   "$ccr0", "$ccr1", "$ccr2", "$ccr3", "$ccr4", "$ccr5", "$ccr6",        \
 700   "$ccr7", "$ccr8", "$ccr9", "$ccr10", "$ccr11", "$ccr12", "$ccr13",    \
 701   "$ccr14", "$ccr15", "$ccr16", "$ccr17", "$ccr18", "$ccr19", "$ccr20", \
 702   "$ccr21", "$ccr22", "$ccr23", "$ccr24", "$ccr25", "$ccr26", "$ccr27", \
 703   "$ccr28", "$ccr29", "$ccr30", "$ccr31",                               \
 704   /* Virtual arg pointer.  */                                           \
 705   "$argp", SHADOW_REGISTER_NAMES                                        \
 706 }
 707
 708 /* We duplicate some of the above because we twiddle the above
 709    according to *how* the registers are used.  Likewise, we include
 710    the standard names for coprocessor control registers so that
 711    coprocessor options can rename them in the default table.  Note
 712    that these are compared to stripped names (see REGISTER_PREFIX
 713    below).  */
 714 #define ADDITIONAL_REGISTER_NAMES               \
 715 {                                               \
 716   {  "8",  8 }, { "fp",  8 },                   \
 717   { "13", 13 }, { "tp", 13 },                   \
 718   { "14", 14 }, { "gp", 14 },                   \
 719   { "15", 15 }, { "sp", 15 },                   \
 720   { "ccr0", FIRST_CCR_REGNO + 0 },              \
 721   { "ccr1", FIRST_CCR_REGNO + 1 },              \
 722   { "ccr2", FIRST_CCR_REGNO + 2 },              \
 723   { "ccr3", FIRST_CCR_REGNO + 3 },              \
 724   { "ccr4", FIRST_CCR_REGNO + 4 },              \
 725   { "ccr5", FIRST_CCR_REGNO + 5 },              \
 726   { "ccr6", FIRST_CCR_REGNO + 6 },              \
 727   { "ccr7", FIRST_CCR_REGNO + 7 },              \
 728   { "ccr8", FIRST_CCR_REGNO + 8 },              \
 729   { "ccr9", FIRST_CCR_REGNO + 9 },              \
 730   { "ccr10", FIRST_CCR_REGNO + 10 },            \
 731   { "ccr11", FIRST_CCR_REGNO + 11 },            \
 732   { "ccr12", FIRST_CCR_REGNO + 12 },            \
 733   { "ccr13", FIRST_CCR_REGNO + 13 },            \
 734   { "ccr14", FIRST_CCR_REGNO + 14 },            \
 735   { "ccr15", FIRST_CCR_REGNO + 15 },            \
 736   { "ccr16", FIRST_CCR_REGNO + 16 },            \
 737   { "ccr17", FIRST_CCR_REGNO + 17 },            \
 738   { "ccr18", FIRST_CCR_REGNO + 18 },            \
 739   { "ccr19", FIRST_CCR_REGNO + 19 },            \
 740   { "ccr20", FIRST_CCR_REGNO + 20 },            \
 741   { "ccr21", FIRST_CCR_REGNO + 21 },            \
 742   { "ccr22", FIRST_CCR_REGNO + 22 },            \
 743   { "ccr23", FIRST_CCR_REGNO + 23 },            \
 744   { "ccr24", FIRST_CCR_REGNO + 24 },            \
 745   { "ccr25", FIRST_CCR_REGNO + 25 },            \
 746   { "ccr26", FIRST_CCR_REGNO + 26 },            \
 747   { "ccr27", FIRST_CCR_REGNO + 27 },            \
 748   { "ccr28", FIRST_CCR_REGNO + 28 },            \
 749   { "ccr29", FIRST_CCR_REGNO + 29 },            \
 750   { "ccr30", FIRST_CCR_REGNO + 30 },            \
 751   { "ccr31", FIRST_CCR_REGNO + 31 }             \
 752 }
 753
 754 /* We watch for pipeline hazards with these */
 755 #define ASM_OUTPUT_OPCODE(STREAM, PTR) mep_asm_output_opcode (STREAM, PTR)
 756 #define FINAL_PRESCAN_INSN(INSN, OPVEC, NOPERANDS) mep_final_prescan_insn (INSN, OPVEC, NOPERANDS)
 757
 758 #define PRINT_OPERAND(STREAM, X, CODE) mep_print_operand (STREAM, X, CODE)
 759
 760 #define PRINT_OPERAND_PUNCT_VALID_P(CODE) ((CODE) == '!' || (CODE) == '<')
 761
 762 #define PRINT_OPERAND_ADDRESS(STREAM, X) mep_print_operand_address (STREAM, X)
 763
 764 #define REGISTER_PREFIX    "$"
 765 #define LOCAL_LABEL_PREFIX "."
 766 #define USER_LABEL_PREFIX  ""
 767 #define IMMEDIATE_PREFIX   ""
 768
 769 \f
 770
 771 #define ASM_OUTPUT_ADDR_VEC_ELT(STREAM, VALUE) \
 772   fprintf (STREAM, "\t.word .L%d\n", VALUE)
 773
 774 \f
 775
 776 #undef  PREFERRED_DEBUGGING_TYPE
 777 #define PREFERRED_DEBUGGING_TYPE  DWARF2_DEBUG
 778 #define DWARF2_DEBUGGING_INFO     1
 779 #define DWARF2_UNWIND_INFO        1
 780
 781 #define EH_RETURN_DATA_REGNO(N) ((N) < 2 ? (N) + 10 : INVALID_REGNUM)
 782
 783 #define EH_RETURN_STACKADJ_RTX mep_return_stackadj_rtx ()
 784 #define EH_RETURN_HANDLER_RTX  mep_return_handler_rtx ()
 785
 786 #define DBX_REGISTER_NUMBER(REGNO) (REGNO)
 787
 788 \f
 789
 790 #define ASM_OUTPUT_ALIGN(STREAM, POWER) \
 791   fprintf ((STREAM), "\t.p2align %d\n", (POWER))
 792
 793 \f
 794
 795 #define CASE_VECTOR_MODE SImode
 796
 797 #define WORD_REGISTER_OPERATIONS
 798 #define LOAD_EXTEND_OP(MODE) SIGN_EXTEND
 799
 800 #define SHORT_IMMEDIATES_SIGN_EXTEND
 801
 802 #define MOVE_MAX 4
 803
 804 #define SHIFT_COUNT_TRUNCATED 1
 805
 806 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
 807
 808 #define STORE_FLAG_VALUE 1
 809
 810 #define Pmode SImode
 811
 812 #define FUNCTION_MODE SImode
 813
 814 #define REGISTER_TARGET_PRAGMAS()        mep_register_pragmas ()
 815
 816 /* If defined, a C expression to determine the base term of address X.
 817    This macro is used in only one place: `find_base_term' in alias.c.
 818
 819    It is always safe for this macro to not be defined.  It exists so
 820    that alias analysis can understand machine-dependent addresses.
 821
 822    The typical use of this macro is to handle addresses containing
 823    a label_ref or symbol_ref within an UNSPEC.  */
 824 #define FIND_BASE_TERM(X) mep_find_base_term (X)