gcc/config/crx/crx.h

   1 /* Definitions of target machine for GNU compiler, for CRX.
   2    Copyright (C) 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
   4
   5    This file is part of GCC.
   6
   7    GCC is free software; you can redistribute it and/or modify it
   8    under the terms of the GNU General Public License as published
   9    by the Free Software Foundation; either version 3, or (at your
  10    option) any later version.
  11
  12    GCC is distributed in the hope that it will be useful, but WITHOUT
  13    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  15    License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GCC; see the file COPYING3.  If not see
  19    <http://www.gnu.org/licenses/>.  */
  20
  21 #ifndef GCC_CRX_H
  22 #define GCC_CRX_H
  23
  24 /*****************************************************************************/
  25 /* CONTROLLING THE DRIVER                                                    */
  26 /*****************************************************************************/
  27
  28 #define CC1PLUS_SPEC "%{!frtti:-fno-rtti} \
  29     %{!fenforce-eh-specs:-fno-enforce-eh-specs} \
  30     %{!fexceptions:-fno-exceptions} \
  31     %{!fthreadsafe-statics:-fno-threadsafe-statics}"
  32
  33 #undef  STARTFILE_SPEC
  34 #define STARTFILE_SPEC "crti.o%s crtbegin.o%s"
  35
  36 #undef  ENDFILE_SPEC
  37 #define ENDFILE_SPEC "crtend.o%s crtn.o%s"
  38
  39 #undef MATH_LIBRARY
  40 #define MATH_LIBRARY ""
  41
  42 /*****************************************************************************/
  43 /* RUN-TIME TARGET SPECIFICATION                                             */
  44 /*****************************************************************************/
  45
  46 #ifndef TARGET_CPU_CPP_BUILTINS
  47 #define TARGET_CPU_CPP_BUILTINS()                               \
  48 do {                                                            \
  49      builtin_define("__CRX__");                                 \
  50      builtin_define("__CR__");                                  \
  51 } while (0)
  52 #endif
  53
  54 #define TARGET_VERSION fputs (" (CRX/ELF)", stderr);
  55
  56 /* Put each function in its own section so that PAGE-instruction
  57  * relaxation can do its best.  */
  58 #define OPTIMIZATION_OPTIONS(LEVEL, SIZEFLAG)   \
  59     do {                                        \
  60         if ((LEVEL) || (SIZEFLAG))              \
  61             flag_function_sections = 1; \
  62     } while (0)
  63
  64 /* Show we can debug even without a frame pointer.  */
  65 #define CAN_DEBUG_WITHOUT_FP
  66
  67 /*****************************************************************************/
  68 /* STORAGE LAYOUT                                                            */
  69 /*****************************************************************************/
  70
  71 #define BITS_BIG_ENDIAN  0
  72
  73 #define BYTES_BIG_ENDIAN 0
  74
  75 #define WORDS_BIG_ENDIAN 0
  76
  77 #define UNITS_PER_WORD 4
  78
  79 #define POINTER_SIZE 32
  80
  81 #define PARM_BOUNDARY 32
  82
  83 #define STACK_BOUNDARY 32
  84
  85 #define FUNCTION_BOUNDARY 32
  86
  87 #define STRUCTURE_SIZE_BOUNDARY 32
  88
  89 #define BIGGEST_ALIGNMENT 32
  90
  91 /* In CRX arrays of chars are word-aligned, so strcpy() will be faster.  */
  92 #define DATA_ALIGNMENT(TYPE, ALIGN) \
  93   (TREE_CODE (TYPE) == ARRAY_TYPE && TYPE_MODE (TREE_TYPE (TYPE)) == QImode \
  94    && (ALIGN) < BITS_PER_WORD \
  95    ? (BITS_PER_WORD) : (ALIGN))
  96
  97 /* In CRX strings are word-aligned so strcpy from constants will be faster. */
  98 #define CONSTANT_ALIGNMENT(CONSTANT, ALIGN) \
  99   (TREE_CODE (CONSTANT) == STRING_CST && (ALIGN) < BITS_PER_WORD \
 100    ? (BITS_PER_WORD) : (ALIGN))
 101
 102 #define STRICT_ALIGNMENT 0
 103
 104 #define PCC_BITFIELD_TYPE_MATTERS 1
 105
 106 /*****************************************************************************/
 107 /* LAYOUT OF SOURCE LANGUAGE DATA TYPES                                      */
 108 /*****************************************************************************/
 109
 110 #define INT_TYPE_SIZE           32
 111
 112 #define SHORT_TYPE_SIZE         16
 113
 114 #define LONG_TYPE_SIZE          32
 115
 116 #define LONG_LONG_TYPE_SIZE     64
 117
 118 #define FLOAT_TYPE_SIZE         32
 119
 120 #define DOUBLE_TYPE_SIZE        64
 121
 122 #define LONG_DOUBLE_TYPE_SIZE   64
 123
 124 #define DEFAULT_SIGNED_CHAR     1
 125
 126 #define SIZE_TYPE               "unsigned int"
 127
 128 #define PTRDIFF_TYPE            "int"
 129
 130 /*****************************************************************************/
 131 /* REGISTER USAGE.                                                           */
 132 /*****************************************************************************/
 133
 134 #define FIRST_PSEUDO_REGISTER   19
 135
 136 /* On the CRX, only the stack pointer (r15) is such. */
 137 #define FIXED_REGISTERS \
 138   { \
 139  /* r0  r1  r2  r3  r4  r5  r6  r7  r8  r9  r10 */  \
 140     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,      \
 141  /* r11 r12 r13 ra  sp  r16 r17 cc */               \
 142     0,  0,  0,  0,  1,  0,  0,  1                   \
 143   }
 144
 145 /* On the CRX, calls clobbers r0-r6 (scratch registers), ra (the return address)
 146  * and sp - (the stack pointer which is fixed). */
 147 #define CALL_USED_REGISTERS \
 148   { \
 149  /* r0  r1  r2  r3  r4  r5  r6  r7  r8  r9  r10 */  \
 150     1,  1,  1,  1,  1,  1,  1,  0,  0,  0,  0,      \
 151  /* r11 r12 r13 ra  sp  r16 r17 cc */               \
 152     0,  0,  0,  1,  1,  1,  1,  1                   \
 153   }
 154
 155 #define HARD_REGNO_NREGS(REGNO, MODE) \
 156     ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
 157
 158 /* On the CRX architecture, HILO regs can only hold SI mode. */
 159 #define HARD_REGNO_MODE_OK(REGNO, MODE) crx_hard_regno_mode_ok(REGNO, MODE)
 160
 161 /* So far no patterns for moving CCMODE data are available */
 162 #define AVOID_CCMODE_COPIES
 163
 164 /* Interrupt functions can only use registers that have already been saved by
 165  * the prologue, even if they would normally be call-clobbered. */
 166 #define HARD_REGNO_RENAME_OK(SRC, DEST) \
 167   (!crx_interrupt_function_p () || df_regs_ever_live_p (DEST))
 168
 169 #define MODES_TIEABLE_P(MODE1, MODE2)  1
 170
 171 enum reg_class
 172 {
 173   NO_REGS,
 174   LO_REGS,
 175   HI_REGS,
 176   HILO_REGS,
 177   NOSP_REGS,
 178   GENERAL_REGS,
 179   ALL_REGS,
 180   LIM_REG_CLASSES
 181 };
 182
 183 #define N_REG_CLASSES (int) LIM_REG_CLASSES
 184
 185 /* The following macro defines cover classes for Integrated Register
 186    Allocator.  Cover classes is a set of non-intersected register
 187    classes covering all hard registers used for register allocation
 188    purpose.  Any move between two registers of a cover class should be
 189    cheaper than load or store of the registers.  The macro value is
 190    array of register classes with LIM_REG_CLASSES used as the end
 191    marker.  */
 192
 193 #define IRA_COVER_CLASSES         \
 194 {                                 \
 195    GENERAL_REGS, LIM_REG_CLASSES  \
 196 }
 197
 198 #define REG_CLASS_NAMES \
 199   {                     \
 200     "NO_REGS",          \
 201     "LO_REGS",          \
 202     "HI_REGS",          \
 203     "HILO_REGS",        \
 204     "NOSP_REGS",        \
 205     "GENERAL_REGS",     \
 206     "ALL_REGS"          \
 207   }
 208
 209 #define REG_CLASS_CONTENTS                              \
 210   {                                                     \
 211     {0x00000000}, /* NO_REGS                    */      \
 212     {0x00010000}, /* LO_REGS :          16      */      \
 213     {0x00020000}, /* HI_REGS :          17      */      \
 214     {0x00030000}, /* HILO_REGS :        16, 17  */      \
 215     {0x00007fff}, /* NOSP_REGS :        0 - 14  */      \
 216     {0x0000ffff}, /* GENERAL_REGS :     0 - 15  */      \
 217     {0x0007ffff}  /* ALL_REGS :         0 - 18  */      \
 218   }
 219
 220 #define REGNO_REG_CLASS(REGNO)  crx_regno_reg_class(REGNO)
 221
 222 #define BASE_REG_CLASS          GENERAL_REGS
 223
 224 #define INDEX_REG_CLASS         GENERAL_REGS
 225
 226 #define REG_CLASS_FROM_LETTER(C)        \
 227   ((C) == 'b' ? NOSP_REGS :             \
 228    (C) == 'l' ? LO_REGS :               \
 229    (C) == 'h' ? HI_REGS :               \
 230    (C) == 'k' ? HILO_REGS :             \
 231   NO_REGS)
 232
 233 #define REGNO_OK_FOR_BASE_P(REGNO) \
 234   ((REGNO) < 16 \
 235    || (reg_renumber && (unsigned)reg_renumber[REGNO] < 16))
 236
 237 #define REGNO_OK_FOR_INDEX_P(REGNO)        REGNO_OK_FOR_BASE_P(REGNO)
 238
 239 #define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS
 240
 241 #define SECONDARY_RELOAD_CLASS(CLASS, MODE, X) \
 242   crx_secondary_reload_class (CLASS, MODE, X)
 243
 244 #define CLASS_MAX_NREGS(CLASS, MODE) \
 245     (GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD
 246
 247 #define SIGNED_INT_FITS_N_BITS(imm, N) \
 248   ((((imm) < ((long long)1<<((N)-1))) && ((imm) >= -((long long)1<<((N)-1)))) ? 1 : 0)
 249
 250 #define UNSIGNED_INT_FITS_N_BITS(imm, N) \
 251   (((imm) < ((long long)1<<(N)) && (imm) >= (long long)0) ? 1 : 0)
 252
 253 #define HILO_REGNO_P(regno) \
 254   (reg_classes_intersect_p(REGNO_REG_CLASS(regno), HILO_REGS))
 255
 256 #define INT_CST4(VALUE) \
 257   (((VALUE) >= -1 && (VALUE) <= 4) || (VALUE) == -4 \
 258   || (VALUE) == 7 || (VALUE) == 8 || (VALUE) == 16 || (VALUE) == 32 \
 259   || (VALUE) == 20 || (VALUE) == 12 || (VALUE) == 48)
 260
 261 #define CONST_OK_FOR_LETTER_P(VALUE, C)                         \
 262   /* Legal const for store immediate instructions */            \
 263   ((C) == 'I' ? UNSIGNED_INT_FITS_N_BITS(VALUE, 3) :            \
 264    (C) == 'J' ? UNSIGNED_INT_FITS_N_BITS(VALUE, 4) :            \
 265    (C) == 'K' ? UNSIGNED_INT_FITS_N_BITS(VALUE, 5) :            \
 266    (C) == 'L' ? INT_CST4(VALUE) :                               \
 267   0)
 268
 269 #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C)  \
 270   ((C) == 'G' ? crx_const_double_ok (VALUE) :   \
 271   0)
 272
 273 /*****************************************************************************/
 274 /* STACK LAYOUT AND CALLING CONVENTIONS.                                     */
 275 /*****************************************************************************/
 276
 277 #define STACK_GROWS_DOWNWARD
 278
 279 #define STARTING_FRAME_OFFSET  0
 280
 281 #define STACK_POINTER_REGNUM    15
 282
 283 #define FRAME_POINTER_REGNUM    13
 284
 285 #define ARG_POINTER_REGNUM      12
 286
 287 #define STATIC_CHAIN_REGNUM     1
 288
 289 #define RETURN_ADDRESS_REGNUM   14
 290
 291 #define FIRST_PARM_OFFSET(FNDECL)  0
 292
 293 #define FRAME_POINTER_REQUIRED (cfun->calls_alloca)
 294
 295 #define ELIMINABLE_REGS \
 296   { \
 297     { ARG_POINTER_REGNUM,   STACK_POINTER_REGNUM}, \
 298     { ARG_POINTER_REGNUM,   FRAME_POINTER_REGNUM}, \
 299     { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}  \
 300   }
 301
 302 #define CAN_ELIMINATE(FROM, TO) \
 303  ((TO) == STACK_POINTER_REGNUM ? ! frame_pointer_needed : 1)
 304
 305 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET)                    \
 306   do {                                                                  \
 307     (OFFSET) = crx_initial_elimination_offset ((FROM), (TO));           \
 308   } while (0)
 309
 310 /*****************************************************************************/
 311 /* PASSING FUNCTION ARGUMENTS                                                */
 312 /*****************************************************************************/
 313
 314 #define ACCUMULATE_OUTGOING_ARGS (TARGET_NO_PUSH_ARGS)
 315
 316 #define PUSH_ARGS (!TARGET_NO_PUSH_ARGS)
 317
 318 #define PUSH_ROUNDING(BYTES) (((BYTES) + 3) & ~3)
 319
 320 #define RETURN_POPS_ARGS(FNDECL, FUNTYPE, SIZE)   0
 321
 322 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
 323   ((rtx) crx_function_arg(&(CUM), (MODE), (TYPE), (NAMED)))
 324
 325 #ifndef CUMULATIVE_ARGS
 326 struct cumulative_args
 327 {
 328   int ints;
 329 };
 330
 331 #define CUMULATIVE_ARGS struct cumulative_args
 332 #endif
 333
 334 /* On the CRX architecture, Varargs routines should receive their parameters on
 335  * the stack.  */
 336
 337 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, FNDECL, N_NAMED_ARGS) \
 338   crx_init_cumulative_args(&(CUM), (FNTYPE), (LIBNAME))
 339
 340 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \
 341   crx_function_arg_advance(&(CUM), (MODE), (TYPE), (NAMED))
 342
 343 #define FUNCTION_ARG_REGNO_P(REGNO)  crx_function_arg_regno_p(REGNO)
 344
 345 /*****************************************************************************/
 346 /* RETURNING FUNCTION VALUE                                                  */
 347 /*****************************************************************************/
 348
 349 /* On the CRX, the return value is in R0 */
 350
 351 #define FUNCTION_VALUE(VALTYPE, FUNC) \
 352         gen_rtx_REG(TYPE_MODE (VALTYPE), 0)
 353
 354 #define LIBCALL_VALUE(MODE)     gen_rtx_REG (MODE, 0)
 355
 356 #define FUNCTION_VALUE_REGNO_P(N)       ((N) == 0)
 357
 358 #define CRX_STRUCT_VALUE_REGNUM  0
 359
 360 /*****************************************************************************/
 361 /* GENERATING CODE FOR PROFILING - NOT IMPLEMENTED                           */
 362 /*****************************************************************************/
 363
 364 #undef  FUNCTION_PROFILER
 365 #define FUNCTION_PROFILER(STREAM, LABELNO)      \
 366 {                                               \
 367     sorry ("Profiler support for CRX");         \
 368 }
 369
 370 /*****************************************************************************/
 371 /* TRAMPOLINES FOR NESTED FUNCTIONS - NOT SUPPORTED                          */
 372 /*****************************************************************************/
 373
 374 #define TRAMPOLINE_SIZE 32
 375
 376 #define INITIALIZE_TRAMPOLINE(addr, fnaddr, static_chain)       \
 377 {                                                               \
 378     sorry ("Trampoline support for CRX");                       \
 379 }
 380
 381 /*****************************************************************************/
 382 /* ADDRESSING MODES                                                          */
 383 /*****************************************************************************/
 384
 385 #define CONSTANT_ADDRESS_P(X)                                           \
 386   (GET_CODE (X) == LABEL_REF                                            \
 387    || GET_CODE (X) == SYMBOL_REF                                        \
 388    || GET_CODE (X) == CONST                                             \
 389    || GET_CODE (X) == CONST_INT)
 390
 391 #define MAX_REGS_PER_ADDRESS 2
 392
 393 #define HAVE_POST_INCREMENT  1
 394 #define HAVE_POST_DECREMENT  1
 395 #define HAVE_POST_MODIFY_DISP 1
 396 #define HAVE_POST_MODIFY_REG 0
 397
 398 #ifdef REG_OK_STRICT
 399 #define REG_OK_FOR_BASE_P(X)    REGNO_OK_FOR_BASE_P (REGNO (X))
 400 #define REG_OK_FOR_INDEX_P(X)   REGNO_OK_FOR_INDEX_P (REGNO (X))
 401 #else
 402 #define REG_OK_FOR_BASE_P(X)    1
 403 #define REG_OK_FOR_INDEX_P(X)   1
 404 #endif /* REG_OK_STRICT */
 405
 406 #ifdef REG_OK_STRICT
 407 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL)                        \
 408 {                                                                       \
 409   if (crx_legitimate_address_p (MODE, X, 1))                            \
 410       goto LABEL;                                                       \
 411 }
 412 #else
 413 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL)                        \
 414 {                                                                       \
 415   if (crx_legitimate_address_p (MODE, X, 0))                            \
 416       goto LABEL;                                                       \
 417 }
 418 #endif /* REG_OK_STRICT */
 419
 420 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR, LABEL)
 421
 422 #define LEGITIMATE_CONSTANT_P(X)  1
 423
 424 /*****************************************************************************/
 425 /* CONDITION CODE STATUS                                                     */
 426 /*****************************************************************************/
 427
 428 /*****************************************************************************/
 429 /* RELATIVE COSTS OF OPERATIONS                                              */
 430 /*****************************************************************************/
 431
 432 #define MEMORY_MOVE_COST(MODE, CLASS, IN) crx_memory_move_cost(MODE, CLASS, IN)
 433 /* Moving to processor register flushes pipeline - thus asymmetric */
 434 #define REGISTER_MOVE_COST(MODE, FROM, TO) ((TO != GENERAL_REGS) ? 8 : 2)
 435 /* Assume best case (branch predicted) */
 436 #define BRANCH_COST(speed_p, predictable_p) 2
 437
 438 #define SLOW_BYTE_ACCESS  1
 439
 440 /*****************************************************************************/
 441 /* DIVIDING THE OUTPUT INTO SECTIONS                                         */
 442 /*****************************************************************************/
 443
 444 #define TEXT_SECTION_ASM_OP     "\t.section\t.text"
 445
 446 #define DATA_SECTION_ASM_OP     "\t.section\t.data"
 447
 448 #define BSS_SECTION_ASM_OP      "\t.section\t.bss"
 449
 450 /*****************************************************************************/
 451 /* POSITION INDEPENDENT CODE                                                 */
 452 /*****************************************************************************/
 453
 454 #define PIC_OFFSET_TABLE_REGNUM  12
 455
 456 #define LEGITIMATE_PIC_OPERAND_P(X)  1
 457
 458 /*****************************************************************************/
 459 /* ASSEMBLER FORMAT                                                          */
 460 /*****************************************************************************/
 461
 462 #define GLOBAL_ASM_OP "\t.globl\t"
 463
 464 #undef  USER_LABEL_PREFIX
 465 #define USER_LABEL_PREFIX "_"
 466
 467 #undef  ASM_OUTPUT_LABELREF
 468 #define ASM_OUTPUT_LABELREF(STREAM, NAME) \
 469   asm_fprintf (STREAM, "%U%s", (*targetm.strip_name_encoding) (NAME));
 470
 471 #undef  ASM_APP_ON
 472 #define ASM_APP_ON   "#APP\n"
 473
 474 #undef  ASM_APP_OFF
 475 #define ASM_APP_OFF  "#NO_APP\n"
 476
 477 /*****************************************************************************/
 478 /* INSTRUCTION OUTPUT                                                        */
 479 /*****************************************************************************/
 480
 481 #define REGISTER_NAMES \
 482   { \
 483     "r0",  "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7", \
 484     "r8",  "r9",  "r10", "r11", "r12", "r13", "ra",  "sp", \
 485     "lo",  "hi",  "cc" \
 486   }
 487
 488 #define PRINT_OPERAND(STREAM, X, CODE) \
 489   crx_print_operand(STREAM, X, CODE)
 490
 491 #define PRINT_OPERAND_ADDRESS(STREAM, ADDR) \
 492   crx_print_operand_address(STREAM, ADDR)
 493
 494 /*****************************************************************************/
 495 /* OUTPUT OF DISPATCH TABLES                                                 */
 496 /*****************************************************************************/
 497
 498 #define ASM_OUTPUT_ADDR_VEC_ELT(STREAM, VALUE) \
 499   asm_fprintf ((STREAM), "\t.long\t.L%d\n", (VALUE))
 500
 501 /*****************************************************************************/
 502 /* ALIGNMENT IN ASSEMBLER FILE                                               */
 503 /*****************************************************************************/
 504
 505 #define ASM_OUTPUT_ALIGN(STREAM, POWER) \
 506   asm_fprintf ((STREAM), "\t.align\t%d\n", 1 << (POWER))
 507
 508 /*****************************************************************************/
 509 /* MISCELLANEOUS PARAMETERS                                                  */
 510 /*****************************************************************************/
 511
 512 #define CASE_VECTOR_MODE  Pmode
 513
 514 #define MOVE_MAX 4
 515
 516 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC)  1
 517
 518 #define STORE_FLAG_VALUE  1
 519
 520 #define Pmode           SImode
 521
 522 #define FUNCTION_MODE   QImode
 523
 524 /*****************************************************************************/
 525 /* EXTERNAL DECLARATIONS FOR VARIABLES DEFINED IN CRX.C                      */
 526 /*****************************************************************************/
 527
 528 extern rtx crx_compare_op0;    /* operand 0 for comparisons */
 529 extern rtx crx_compare_op1;    /* operand 1 for comparisons */
 530
 531 #endif /* ! GCC_CRX_H */