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