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