1/* score.h for Sunplus S+CORE processor 2 Copyright (C) 2005 Free Software Foundation, Inc. 3 Contributed by Sunnorth. 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#include "score-conv.h" 23#include "score-version.h" 24 25/* Define the information needed to generate branch insns. This is 26 stored from the compare operation. */ 27extern GTY(()) rtx cmp_op0; 28extern GTY(()) rtx cmp_op1; 29 30/* Controlling the Compilation Driver. */ 31#undef SWITCH_TAKES_ARG 32#define SWITCH_TAKES_ARG(CHAR) \ 33 (DEFAULT_SWITCH_TAKES_ARG (CHAR) || (CHAR) == 'G') 34 35/* CC1_SPEC is the set of arguments to pass to the compiler proper. */ 36#undef CC1_SPEC 37#define CC1_SPEC "%{G*} %{!mel:-meb}" 38 39#undef ASM_SPEC 40#define ASM_SPEC \ 41 "%{!mel:-EB} %{mel:-EL} %{mscore5:-SCORE5} %{mscore5u:-SCORE5U} \ 42 %{mscore7:%{!mmac:-SCORE7}} %{mscore7:%{mmac:-SCORE7D}} \ 43 %{mscore7d:-SCORE7D} %{G*}" 44 45#undef LINK_SPEC 46#define LINK_SPEC "%{!mel:-EB} %{mel:-EL} %{G*}" 47 48/* Run-time Target Specification. */ 49#define TARGET_CPU_CPP_BUILTINS() \ 50 do { \ 51 builtin_define ("SUNPLUS"); \ 52 builtin_define ("__SCORE__"); \ 53 builtin_define ("__score__"); \ 54 if (TARGET_LITTLE_ENDIAN) \ 55 builtin_define ("__scorele__"); \ 56 else \ 57 builtin_define ("__scorebe__"); \ 58 if (TARGET_SCORE5U) \ 59 builtin_define ("__score5u__"); \ 60 else \ 61 builtin_define ("__score7__"); \ 62 } while (0) 63 64#define TARGET_DEFAULT MASK_SCORE7 65 66#define TARGET_VERSION \ 67 fprintf (stderr, "Sunplus S+CORE %s", SCORE_GCC_VERSION); 68 69#define OVERRIDE_OPTIONS score_override_options () 70 71/* Show we can debug even without a frame pointer. */ 72#define CAN_DEBUG_WITHOUT_FP 73 74/* Target machine storage layout. */ 75#define BITS_BIG_ENDIAN 0 76#define BYTES_BIG_ENDIAN (TARGET_LITTLE_ENDIAN == 0) 77#define WORDS_BIG_ENDIAN (TARGET_LITTLE_ENDIAN == 0) 78 79/* Define this to set the endianness to use in libgcc2.c, which can 80 not depend on target_flags. */ 81#if defined(__scorele__) 82#define LIBGCC2_WORDS_BIG_ENDIAN 0 83#else 84#define LIBGCC2_WORDS_BIG_ENDIAN 1 85#endif 86 87/* Width of a word, in units (bytes). */ 88#define UNITS_PER_WORD 4 89 90/* Define this macro if it is advisable to hold scalars in registers 91 in a wider mode than that declared by the program. In such cases, 92 the value is constrained to be within the bounds of the declared 93 type, but kept valid in the wider mode. The signedness of the 94 extension may differ from that of the type. */ 95#define PROMOTE_MODE(MODE, UNSIGNEDP, TYPE) \ 96 if (GET_MODE_CLASS (MODE) == MODE_INT \ 97 && GET_MODE_SIZE (MODE) < UNITS_PER_WORD) \ 98 (MODE) = SImode; 99 100/* Allocation boundary (in *bits*) for storing arguments in argument list. */ 101#define PARM_BOUNDARY BITS_PER_WORD 102#define STACK_BOUNDARY BITS_PER_WORD 103 104/* Allocation boundary (in *bits*) for the code of a function. */ 105#define FUNCTION_BOUNDARY BITS_PER_WORD 106 107/* There is no point aligning anything to a rounder boundary than this. */ 108#define BIGGEST_ALIGNMENT LONG_DOUBLE_TYPE_SIZE 109 110/* If defined, a C expression to compute the alignment for a static 111 variable. TYPE is the data type, and ALIGN is the alignment that 112 the object would ordinarily have. The value of this macro is used 113 instead of that alignment to align the object. 114 115 If this macro is not defined, then ALIGN is used. 116 117 One use of this macro is to increase alignment of medium-size 118 data to make it all fit in fewer cache lines. Another is to 119 cause character arrays to be word-aligned so that `strcpy' calls 120 that copy constants to character arrays can be done inline. */ 121#define DATA_ALIGNMENT(TYPE, ALIGN) \ 122 ((((ALIGN) < BITS_PER_WORD) \ 123 && (TREE_CODE (TYPE) == ARRAY_TYPE \ 124 || TREE_CODE (TYPE) == UNION_TYPE \ 125 || TREE_CODE (TYPE) == RECORD_TYPE)) ? BITS_PER_WORD : (ALIGN)) 126 127/* If defined, a C expression to compute the alignment given to a 128 constant that is being placed in memory. EXP is the constant 129 and ALIGN is the alignment that the object would ordinarily have. 130 The value of this macro is used instead of that alignment to align 131 the object. 132 133 If this macro is not defined, then ALIGN is used. 134 135 The typical use of this macro is to increase alignment for string 136 constants to be word aligned so that `strcpy' calls that copy 137 constants can be done inline. */ 138#define CONSTANT_ALIGNMENT(EXP, ALIGN) \ 139 ((TREE_CODE (EXP) == STRING_CST || TREE_CODE (EXP) == CONSTRUCTOR) \ 140 && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN)) 141 142/* If defined, a C expression to compute the alignment for a local 143 variable. TYPE is the data type, and ALIGN is the alignment that 144 the object would ordinarily have. The value of this macro is used 145 instead of that alignment to align the object. 146 147 If this macro is not defined, then ALIGN is used. 148 149 One use of this macro is to increase alignment of medium-size 150 data to make it all fit in fewer cache lines. */ 151#define LOCAL_ALIGNMENT(TYPE, ALIGN) \ 152 ((TREE_CODE (TYPE) == ARRAY_TYPE \ 153 && TYPE_MODE (TREE_TYPE (TYPE)) == QImode \ 154 && (ALIGN) < BITS_PER_WORD) ? BITS_PER_WORD : (ALIGN)) 155 156/* Alignment of field after `int : 0' in a structure. */ 157#define EMPTY_FIELD_BOUNDARY 32 158 159/* All accesses must be aligned. */ 160#define STRICT_ALIGNMENT 1 161 162/* Score requires that structure alignment is affected by bitfields. */ 163#define PCC_BITFIELD_TYPE_MATTERS 1 164 165/* long double is not a fixed mode, but the idea is that, if we 166 support long double, we also want a 128-bit integer type. */ 167#define MAX_FIXED_MODE_SIZE LONG_DOUBLE_TYPE_SIZE 168 169#define TARGET_FLOAT_FORMAT IEEE_FLOAT_FORMAT 170 171/* Layout of Data Type. */ 172/* Set the sizes of the core types. */ 173#define INT_TYPE_SIZE 32 174#define SHORT_TYPE_SIZE 16 175#define LONG_TYPE_SIZE 32 176#define LONG_LONG_TYPE_SIZE 64 177#define CHAR_TYPE_SIZE 8 178#define FLOAT_TYPE_SIZE 32 179#define DOUBLE_TYPE_SIZE 64 180#define LONG_DOUBLE_TYPE_SIZE 64 181 182/* Define this as 1 if `char' should by default be signed; else as 0. */ 183#undef DEFAULT_SIGNED_CHAR 184#define DEFAULT_SIGNED_CHAR 1 185 186/* Default definitions for size_t and ptrdiff_t. */ 187#define SIZE_TYPE "unsigned int" 188 189/* Register Usage 190 191 S+core have: 192 - 32 integer registers 193 - 16 control registers (cond) 194 - 16 special registers (ceh/cel/cnt/lcr/scr/arg/fp) 195 - 32 coprocessors 1 registers 196 - 32 coprocessors 2 registers 197 - 32 coprocessors 3 registers. */ 198#define FIRST_PSEUDO_REGISTER 160 199 200/* By default, fix the kernel registers (r30 and r31), the global 201 pointer (r28) and the stack pointer (r0). This can change 202 depending on the command-line options. 203 204 Regarding coprocessor registers: without evidence to the contrary, 205 it's best to assume that each coprocessor register has a unique 206 use. This can be overridden, in, e.g., override_options() or 207 CONDITIONAL_REGISTER_USAGE should the assumption be inappropriate 208 for a particular target. */ 209 210/* Control Registers, use mfcr/mtcr insn 211 32 cr0 PSR 212 33 cr1 Condition 213 34 cr2 ECR 214 35 cr3 EXCPVec 215 36 cr4 CCR 216 37 cr5 EPC 217 38 cr6 EMA 218 39 cr7 TLBLock 219 40 cr8 TLBPT 220 41 cr8 PEADDR 221 42 cr10 TLBRPT 222 43 cr11 PEVN 223 44 cr12 PECTX 224 45 cr13 225 46 cr14 226 47 cr15 227 228 Custom Engine Register, use mfce/mtce 229 48 CEH CEH 230 49 CEL CEL 231 232 Special-Purpose Register, use mfsr/mtsr 233 50 sr0 CNT 234 51 sr1 LCR 235 52 sr2 SCR 236 237 53 ARG_POINTER_REGNUM 238 54 FRAME_POINTER_REGNUM 239 but Control register have 32 registers, cr16-cr31. */ 240#define FIXED_REGISTERS \ 241{ \ 242 /* General Purpose Registers */ \ 243 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ 244 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, \ 245 /* Control Registers */ \ 246 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 247 /* CEH/ CEL/ CNT/ LCR/ SCR / ARG_POINTER_REGNUM/ FRAME_POINTER_REGNUM */\ 248 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 249 /* CP 1 Registers */ \ 250 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 251 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 252 /* CP 2 Registers */ \ 253 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 254 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 255 /* CP 3 Registers */ \ 256 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 257 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 258} 259 260#define CALL_USED_REGISTERS \ 261{ \ 262 /* General purpose register */ \ 263 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, \ 264 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 265 /* 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 /* CP 1 Registers */ \ 269 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 270 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 271 /* CP 2 Registers */ \ 272 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 273 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 274 /* CP 3 Registers */ \ 275 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 276 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 277} 278 279#define REG_ALLOC_ORDER \ 280{ 0, 1, 6, 7, 8, 9, 10, 11, 4, 5, 22, 23, 24, 25, 26, 27, \ 281 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 28, 29, 30, 31, 2, 3, \ 282 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, \ 283 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, \ 284 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, \ 285 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, \ 286 96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111, \ 287 112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127, \ 288 128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, \ 289 144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159 } 290 291/* Macro to conditionally modify fixed_regs/call_used_regs. */ 292#define PIC_OFFSET_TABLE_REGNUM 29 293 294#define CONDITIONAL_REGISTER_USAGE \ 295{ \ 296 if (!flag_pic) \ 297 fixed_regs[PIC_OFFSET_TABLE_REGNUM] = \ 298 call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 0; \ 299} 300 301#define HARD_REGNO_NREGS(REGNO, MODE) \ 302 ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD) 303 304/* Return true if REGNO is suitable for holding a quantity of type MODE. */ 305#define HARD_REGNO_MODE_OK(REGNO, MODE) score_hard_regno_mode_ok (REGNO, MODE) 306 307/* Value is 1 if it is a good idea to tie two pseudo registers 308 when one has mode MODE1 and one has mode MODE2. 309 If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2, 310 for any hard reg, then this must be 0 for correct output. */ 311#define MODES_TIEABLE_P(MODE1, MODE2) \ 312 ((GET_MODE_CLASS (MODE1) == MODE_FLOAT \ 313 || GET_MODE_CLASS (MODE1) == MODE_COMPLEX_FLOAT) \ 314 == (GET_MODE_CLASS (MODE2) == MODE_FLOAT \ 315 || GET_MODE_CLASS (MODE2) == MODE_COMPLEX_FLOAT)) 316 317/* Register Classes. */ 318/* Define the classes of registers for register constraints in the 319 machine description. Also define ranges of constants. */ 320enum reg_class 321{ 322 NO_REGS, 323 G16_REGS, /* r0 ~ r15 */ 324 G32_REGS, /* r0 ~ r31 */ 325 T32_REGS, /* r8 ~ r11 | r22 ~ r27 */ 326 327 HI_REG, /* hi */ 328 LO_REG, /* lo */ 329 CE_REGS, /* hi + lo */ 330 331 CN_REG, /* cnt */ 332 LC_REG, /* lcb */ 333 SC_REG, /* scb */ 334 SP_REGS, /* cnt + lcb + scb */ 335 336 CR_REGS, /* cr0 - cr15 */ 337 338 CP1_REGS, /* cp1 */ 339 CP2_REGS, /* cp2 */ 340 CP3_REGS, /* cp3 */ 341 CPA_REGS, /* cp1 + cp2 + cp3 */ 342 343 ALL_REGS, 344 LIM_REG_CLASSES 345}; 346 347#define N_REG_CLASSES ((int) LIM_REG_CLASSES) 348 349#define GENERAL_REGS G32_REGS 350 351/* Give names of register classes as strings for dump file. */ 352#define REG_CLASS_NAMES \ 353{ \ 354 "NO_REGS", \ 355 "G16_REGS", \ 356 "G32_REGS", \ 357 "T32_REGS", \ 358 \ 359 "HI_REG", \ 360 "LO_REG", \ 361 "CE_REGS", \ 362 \ 363 "CN_REG", \ 364 "LC_REG", \ 365 "SC_REG", \ 366 "SP_REGS", \ 367 \ 368 "CR_REGS", \ 369 \ 370 "CP1_REGS", \ 371 "CP2_REGS", \ 372 "CP3_REGS", \ 373 "CPA_REGS", \ 374 \ 375 "ALL_REGS", \ 376} 377 378/* Define which registers fit in which classes. */ 379#define REG_CLASS_CONTENTS \ 380{ \ 381 /* NO_REGS/G16/G32/T32 */ \ 382 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000}, \ 383 { 0x0000ffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000}, \ 384 { 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000}, \ 385 { 0x0fc00f00, 0x00000000, 0x00000000, 0x00000000, 0x00000000}, \ 386 /* HI/LO/CE */ \ 387 { 0x00000000, 0x00010000, 0x00000000, 0x00000000, 0x00000000}, \ 388 { 0x00000000, 0x00020000, 0x00000000, 0x00000000, 0x00000000}, \ 389 { 0x00000000, 0x00030000, 0x00000000, 0x00000000, 0x00000000}, \ 390 /* CN/LC/SC/SP/CR */ \ 391 { 0x00000000, 0x00040000, 0x00000000, 0x00000000, 0x00000000}, \ 392 { 0x00000000, 0x00080000, 0x00000000, 0x00000000, 0x00000000}, \ 393 { 0x00000000, 0x00100000, 0x00000000, 0x00000000, 0x00000000}, \ 394 { 0x00000000, 0x001c0000, 0x00000000, 0x00000000, 0x00000000}, \ 395 { 0x00000000, 0x0000ffff, 0x00000000, 0x00000000, 0x00000000}, \ 396 /* CP1/CP2/CP3/CPA */ \ 397 { 0x00000000, 0x00000000, 0xffffffff, 0x00000000, 0x00000000}, \ 398 { 0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0x00000000}, \ 399 { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff}, \ 400 { 0x00000000, 0x00000000, 0xffffffff, 0xffffffff, 0xffffffff}, \ 401 /* ALL_REGS */ \ 402 { 0xffffffff, 0x001fffff, 0xffffffff, 0xffffffff, 0xffffffff}, \ 403} 404 405/* A C expression whose value is a register class containing hard 406 register REGNO. In general there is more that one such class; 407 choose a class which is "minimal", meaning that no smaller class 408 also contains the register. */ 409#define REGNO_REG_CLASS(REGNO) score_reg_class (REGNO) 410 411/* A macro whose definition is the name of the class to which a 412 valid base register must belong. A base register is one used in 413 an address which is the register value plus a displacement. */ 414#define BASE_REG_CLASS G16_REGS 415 416/* The class value for index registers. */ 417#define INDEX_REG_CLASS NO_REGS 418 419#define REG_CLASS_FROM_LETTER(C) score_char_to_class[(unsigned char) (C)] 420 421/* Addressing modes, and classification of registers for them. */ 422#define REGNO_MODE_OK_FOR_BASE_P(REGNO, MODE) \ 423 score_regno_mode_ok_for_base_p (REGNO, 1) 424 425#define REGNO_OK_FOR_INDEX_P(NUM) 0 426 427#define PREFERRED_RELOAD_CLASS(X, CLASS) \ 428 score_preferred_reload_class (X, CLASS) 429 430/* If we need to load shorts byte-at-a-time, then we need a scratch. */ 431#define SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, X) \ 432 score_secondary_reload_class (CLASS, MODE, X) 433 434/* Return the register class of a scratch register needed to copy IN into 435 or out of a register in CLASS in MODE. If it can be done directly, 436 NO_REGS is returned. */ 437#define SECONDARY_OUTPUT_RELOAD_CLASS(CLASS, MODE, X) \ 438 score_secondary_reload_class (CLASS, MODE, X) 439 440/* Return the maximum number of consecutive registers 441 needed to represent mode MODE in a register of class CLASS. */ 442#define CLASS_MAX_NREGS(CLASS, MODE) \ 443 ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD) 444 445#define CANNOT_CHANGE_MODE_CLASS(FROM, TO, CLASS) \ 446 (GET_MODE_SIZE (FROM) != GET_MODE_SIZE (TO) \ 447 ? reg_classes_intersect_p (HI_REG, (CLASS)) : 0) 448 449/* The letters I, J, K, L, M, N, O, and P in a register constraint 450 string can be used to stand for particular ranges of immediate 451 operands. This macro defines what the ranges are. C is the 452 letter, and VALUE is a constant value. Return 1 if VALUE is 453 in the range specified by C. */ 454#define CONST_OK_FOR_LETTER_P(VALUE, C) score_const_ok_for_letter_p (VALUE, C) 455 456/* Similar, but for floating constants, and defining letters G and H. 457 Here VALUE is the CONST_DOUBLE rtx itself. */ 458 459#define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) \ 460 ((C) == 'G' && (VALUE) == CONST0_RTX (GET_MODE (VALUE))) 461 462/* Letters in the range `Q' through `U' may be defined in a 463 machine-dependent fashion to stand for arbitrary operand types. 464 The machine description macro `EXTRA_CONSTRAINT' is passed the 465 operand as its first argument and the constraint letter as its 466 second operand. */ 467#define EXTRA_CONSTRAINT(VALUE, C) score_extra_constraint (VALUE, C) 468 469/* Basic Stack Layout. */ 470/* Stack layout; function entry, exit and calling. */ 471#define STACK_GROWS_DOWNWARD 472 473#define STACK_PUSH_CODE PRE_DEC 474#define STACK_POP_CODE POST_INC 475 476/* The offset of the first local variable from the beginning of the frame. 477 See compute_frame_size for details about the frame layout. */ 478#define STARTING_FRAME_OFFSET current_function_outgoing_args_size 479 480/* The argument pointer always points to the first argument. */ 481#define FIRST_PARM_OFFSET(FUNDECL) 0 482 483/* A C expression whose value is RTL representing the value of the return 484 address for the frame COUNT steps up from the current frame. */ 485#define RETURN_ADDR_RTX(count, frame) score_return_addr (count, frame) 486 487/* Pick up the return address upon entry to a procedure. */ 488#define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (VOIDmode, RA_REGNUM) 489 490/* Exception handling Support. */ 491/* Use r0 to r3 to pass exception handling information. */ 492#define EH_RETURN_DATA_REGNO(N) \ 493 ((N) < 4 ? (N) + ARG_REG_FIRST : INVALID_REGNUM) 494 495/* The register that holds the return address in exception handlers. */ 496#define EH_RETURN_STACKADJ_RTX gen_rtx_REG (Pmode, EH_REGNUM) 497 498/* Registers That Address the Stack Frame. */ 499/* Register to use for pushing function arguments. */ 500#define STACK_POINTER_REGNUM SP_REGNUM 501 502/* These two registers don't really exist: they get eliminated to either 503 the stack or hard frame pointer. */ 504#define FRAME_POINTER_REGNUM 53 505 506/* we use r2 as the frame pointer. */ 507#define HARD_FRAME_POINTER_REGNUM FP_REGNUM 508 509#define ARG_POINTER_REGNUM 54 510 511/* Register in which static-chain is passed to a function. */ 512#define STATIC_CHAIN_REGNUM 23 513 514/* Elimination Frame Pointer and Arg Pointer */ 515/* Value should be nonzero if functions must have frame pointers. 516 Zero means the frame pointer need not be set up (and parms 517 may be accessed via the stack pointer) in functions that seem suitable. 518 This is computed in `reload', in reload1.c. */ 519#define FRAME_POINTER_REQUIRED current_function_calls_alloca 520 521#define ELIMINABLE_REGS \ 522 {{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \ 523 { ARG_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}, \ 524 { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}, \ 525 { FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}} 526 527/* We can always eliminate to the hard frame pointer. We can eliminate 528 to the stack pointer unless a frame pointer is needed. */ 529#define CAN_ELIMINATE(FROM, TO) \ 530 (((TO) == HARD_FRAME_POINTER_REGNUM) \ 531 || ((TO) == STACK_POINTER_REGNUM \ 532 && !frame_pointer_needed)) 533 534#define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \ 535 (OFFSET) = score_initial_elimination_offset ((FROM), (TO)) 536 537/* Passing Function Arguments on the Stack. */ 538/* Allocate stack space for arguments at the beginning of each function. */ 539#define ACCUMULATE_OUTGOING_ARGS 1 540 541/* reserve stack space for all argument registers. */ 542#define REG_PARM_STACK_SPACE(FNDECL) UNITS_PER_WORD 543 544/* Define this if it is the responsibility of the caller to 545 allocate the area reserved for arguments passed in registers. 546 If `ACCUMULATE_OUTGOING_ARGS' is also defined, the only effect 547 of this macro is to determine whether the space is included in 548 `current_function_outgoing_args_size'. */ 549#define OUTGOING_REG_PARM_STACK_SPACE 1 550 551#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACK_SIZE) 0 552 553/* Passing Arguments in Registers */ 554/* Determine where to put an argument to a function. 555 Value is zero to push the argument on the stack, 556 or a hard register in which to store the argument. 557 558 MODE is the argument's machine mode. 559 TYPE is the data type of the argument (as a tree). 560 This is null for libcalls where that information may 561 not be available. 562 CUM is a variable of type CUMULATIVE_ARGS which gives info about 563 the preceding args and about the function being called. 564 NAMED is nonzero if this argument is a named parameter 565 (otherwise it is an extra parameter matching an ellipsis). */ 566#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \ 567 score_function_arg (&CUM, MODE, TYPE, NAMED) 568 569/* A C type for declaring a variable that is used as the first argument of 570 `FUNCTION_ARG' and other related values. For some target machines, the 571 type `int' suffices and can hold the number of bytes of argument so far. */ 572typedef struct score_args 573{ 574 unsigned int arg_number; /* how many arguments have been seen */ 575 unsigned int num_gprs; /* number of gprs in use */ 576 unsigned int stack_words; /* number of words in stack */ 577} score_args_t; 578 579#define CUMULATIVE_ARGS score_args_t 580 581/* Initialize a variable CUM of type CUMULATIVE_ARGS 582 for a call to a function whose data type is FNTYPE. 583 For a library call, FNTYPE is 0. */ 584#define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT, n_named_args) \ 585 score_init_cumulative_args (&CUM, FNTYPE, LIBNAME) 586 587/* Update the data in CUM to advance over an argument 588 of mode MODE and data type TYPE. 589 (TYPE is null for libcalls where that information may not be available.) */ 590#define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \ 591 score_function_arg_advance (&CUM, MODE, TYPE, NAMED) 592 593/* 1 if N is a possible register number for function argument passing. 594 We have no FP argument registers when soft-float. When FP registers 595 are 32 bits, we can't directly reference the odd numbered ones. */ 596#define FUNCTION_ARG_REGNO_P(REGNO) \ 597 REG_CONTAIN (REGNO, ARG_REG_FIRST, ARG_REG_NUM) 598 599/* How Scalar Function Values Are Returned. */ 600#define FUNCTION_VALUE(VALTYPE, FUNC) \ 601 score_function_value ((VALTYPE), (FUNC), VOIDmode) 602 603#define LIBCALL_VALUE(MODE) score_function_value (NULL_TREE, NULL, (MODE)) 604 605/* 1 if N is a possible register number for a function value. */ 606#define FUNCTION_VALUE_REGNO_P(REGNO) ((REGNO) == (ARG_REG_FIRST)) 607 608#define PIC_FUNCTION_ADDR_REGNUM (GP_REG_FIRST + 25) 609 610/* How Large Values Are Returned. */ 611#define STRUCT_VALUE 0 612 613/* Function Entry and Exit */ 614/* EXIT_IGNORE_STACK should be nonzero if, when returning from a function, 615 the stack pointer does not matter. The value is tested only in 616 functions that have frame pointers. 617 No definition is equivalent to always zero. */ 618#define EXIT_IGNORE_STACK 1 619 620/* Generating Code for Profiling */ 621/* Output assembler code to FILE to increment profiler label # LABELNO 622 for profiling a function entry. */ 623#define FUNCTION_PROFILER(FILE, LABELNO) \ 624{ \ 625 fprintf (FILE, " .set r1 \n"); \ 626 fprintf (FILE, " mv r%d,r%d \n", AT_REGNUM, RA_REGNUM); \ 627 fprintf (FILE, " subi r%d, %d \n", STACK_POINTER_REGNUM, 8); \ 628 fprintf (FILE, " jl _mcount \n"); \ 629 fprintf (FILE, " .set nor1 \n"); \ 630} 631 632/* Trampolines for Nested Functions. */ 633#define TRAMPOLINE_INSNS 8 634 635/* A C expression for the size in bytes of the trampoline, as an integer. */ 636#define TRAMPOLINE_SIZE \ 637 (TRAMPOLINE_INSNS * GET_MODE_SIZE (SImode) + GET_MODE_SIZE (ptr_mode) * 2) 638 639/* A C statement to initialize the variable parts of a trampoline. 640 ADDR is an RTX for the address of the trampoline; FNADDR is an 641 RTX for the address of the nested function; STATIC_CHAIN is an 642 RTX for the static chain value that should be passed to the 643 function when it is called. */ 644 645#define INITIALIZE_TRAMPOLINE(ADDR, FUNC, CHAIN) \ 646 score_initialize_trampoline (ADDR, FUNC, CHAIN) 647 648#define HAVE_PRE_INCREMENT 1 649#define HAVE_PRE_DECREMENT 1 650#define HAVE_POST_INCREMENT 1 651#define HAVE_POST_DECREMENT 1 652#define HAVE_PRE_MODIFY_DISP 1 653#define HAVE_POST_MODIFY_DISP 1 654#define HAVE_PRE_MODIFY_REG 0 655#define HAVE_POST_MODIFY_REG 0 656 657/* Recognize any constant value that is a valid address. */ 658#define CONSTANT_ADDRESS_P(X) CONSTANT_P (X) 659 660/* Maximum number of registers that can appear in a valid memory address. */ 661#define MAX_REGS_PER_ADDRESS 1 662 663#ifdef REG_OK_STRICT 664#define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL) \ 665 if (score_address_p (MODE, X, 1)) \ 666 goto LABEL; 667#else 668#define GO_IF_LEGITIMATE_ADDRESS(MODE, X, LABEL) \ 669 if (score_address_p (MODE, X, 0)) \ 670 goto LABEL; 671#endif 672 673/* The macros REG_OK_FOR..._P assume that the arg is a REG rtx 674 and check its validity for a certain class. 675 We have two alternate definitions for each of them. 676 The usual definition accepts all pseudo regs; the other rejects them all. 677 The symbol REG_OK_STRICT causes the latter definition to be used. 678 679 Most source files want to accept pseudo regs in the hope that 680 they will get allocated to the class that the insn wants them to be in. 681 Some source files that are used after register allocation 682 need to be strict. */ 683#ifndef REG_OK_STRICT 684#define REG_MODE_OK_FOR_BASE_P(X, MODE) \ 685 score_regno_mode_ok_for_base_p (REGNO (X), 0) 686#else 687#define REG_MODE_OK_FOR_BASE_P(X, MODE) \ 688 score_regno_mode_ok_for_base_p (REGNO (X), 1) 689#endif 690 691#define REG_OK_FOR_INDEX_P(X) 0 692 693#define LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN) \ 694 do { \ 695 if (score_legitimize_address (&(X))) \ 696 goto WIN; \ 697 } while (0) 698 699/* Go to LABEL if ADDR (a legitimate address expression) 700 has an effect that depends on the machine mode it is used for. */ 701#define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR, LABEL) {} 702 703#define LEGITIMATE_CONSTANT_P(X) 1 704 705/* Condition Code Status. */ 706#define SELECT_CC_MODE(OP, X, Y) score_select_cc_mode (OP, X, Y) 707 708/* Return nonzero if SELECT_CC_MODE will never return MODE for a 709 floating point inequality comparison. */ 710#define REVERSIBLE_CC_MODE(MODE) 1 711 712/* Describing Relative Costs of Operations */ 713/* Compute extra cost of moving data between one register class and another. */ 714#define REGISTER_MOVE_COST(MODE, FROM, TO) \ 715 score_register_move_cost (MODE, FROM, TO) 716 717/* Moves to and from memory are quite expensive */ 718#define MEMORY_MOVE_COST(MODE, CLASS, TO_P) \ 719 (4 + memory_move_secondary_cost ((MODE), (CLASS), (TO_P))) 720 721/* Try to generate sequences that don't involve branches. */ 722#define BRANCH_COST 2 723 724/* Nonzero if access to memory by bytes is slow and undesirable. */ 725#define SLOW_BYTE_ACCESS 1 726 727/* Define this macro if it is as good or better to call a constant 728 function address than to call an address kept in a register. */ 729#define NO_FUNCTION_CSE 1 730 731/* Dividing the Output into Sections (Texts, Data, ...). */ 732/* Define the strings to put out for each section in the object file. */ 733#define TEXT_SECTION_ASM_OP "\t.text" 734#define DATA_SECTION_ASM_OP "\t.data" 735#define SDATA_SECTION_ASM_OP "\t.sdata" 736 737#undef READONLY_DATA_SECTION_ASM_OP 738#define READONLY_DATA_SECTION_ASM_OP "\t.rdata" 739 740/* The Overall Framework of an Assembler File */ 741/* How to start an assembler comment. 742 The leading space is important. */ 743#define ASM_COMMENT_START "#" 744 745/* Output to assembler file text saying following lines 746 may contain character constants, extra white space, comments, etc. */ 747#define ASM_APP_ON "#APP\n\t.set volatile\n" 748 749/* Output to assembler file text saying following lines 750 no longer contain unusual constructs. */ 751#define ASM_APP_OFF "#NO_APP\n\t.set optimize\n" 752 753/* Output of Uninitialized Variables. */ 754/* This says how to define a global common symbol. */ 755#define ASM_OUTPUT_ALIGNED_DECL_COMMON(STREAM, DECL, NAME, SIZE, ALIGN) \ 756 score_declare_object (STREAM, NAME, "\n\t.comm\t", \ 757 ","HOST_WIDE_INT_PRINT_UNSIGNED",%u\n", \ 758 SIZE, ALIGN / BITS_PER_UNIT); 759 760/* This says how to define a local common symbol (i.e., not visible to 761 linker). */ 762#undef ASM_OUTPUT_ALIGNED_LOCAL 763#define ASM_OUTPUT_ALIGNED_LOCAL(STREAM, NAME, SIZE, ALIGN) \ 764 score_declare_object (STREAM, NAME, "\n\t.lcomm\t", \ 765 ","HOST_WIDE_INT_PRINT_UNSIGNED",%u\n", \ 766 SIZE, ALIGN / BITS_PER_UNIT); 767 768/* Globalizing directive for a label. */ 769#define GLOBAL_ASM_OP "\t.globl\t" 770 771/* Output and Generation of Labels */ 772/* This is how to declare a function name. The actual work of 773 emitting the label is moved to function_prologue, so that we can 774 get the line number correctly emitted before the .ent directive, 775 and after any .file directives. Define as empty so that the function 776 is not declared before the .ent directive elsewhere. */ 777#undef ASM_DECLARE_FUNCTION_NAME 778#define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL) 779 780#undef ASM_DECLARE_OBJECT_NAME 781#define ASM_DECLARE_OBJECT_NAME(STREAM, NAME, DECL) \ 782 score_declare_object (STREAM, NAME, "", ":\n", 0) 783 784/* This says how to output an external. It would be possible not to 785 output anything and let undefined symbol become external. However 786 the assembler uses length information on externals to allocate in 787 data/sdata bss/sbss, thereby saving exec time. */ 788#undef ASM_OUTPUT_EXTERNAL 789#define ASM_OUTPUT_EXTERNAL(STREAM, DECL, NAME) \ 790 score_output_external (STREAM, DECL, NAME) 791 792/* This handles the magic '..CURRENT_FUNCTION' symbol, which means 793 'the start of the function that this code is output in'. */ 794#define ASM_OUTPUT_LABELREF(STREAM, NAME) \ 795 fprintf ((STREAM), "%s", (NAME)) 796 797/* Local compiler-generated symbols must have a prefix that the assembler 798 understands. */ 799#define LOCAL_LABEL_PREFIX "." 800 801#undef ASM_GENERATE_INTERNAL_LABEL 802#define ASM_GENERATE_INTERNAL_LABEL(LABEL, PREFIX, NUM) \ 803 sprintf ((LABEL), "*%s%s%ld", (LOCAL_LABEL_PREFIX), (PREFIX), (long) (NUM)) 804 805/* Output of Assembler Instructions. */ 806#define REGISTER_NAMES \ 807{ "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \ 808 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", \ 809 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", \ 810 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31", \ 811 \ 812 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7", \ 813 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15", \ 814 \ 815 "ceh", "cel", "sr0", "sr1", "sr2", "_arg", "_frame", "", \ 816 "cr24", "cr25", "cr26", "cr27", "cr28", "cr29", "cr30", "cr31", \ 817 \ 818 "c1r0", "c1r1", "c1r2", "c1r3", "c1r4", "c1r5", "c1r6", "c1r7", \ 819 "c1r8", "c1r9", "c1r10", "c1r11", "c1r12", "c1r13", "c1r14", "c1r15", \ 820 "c1r16", "c1r17", "c1r18", "c1r19", "c1r20", "c1r21", "c1r22", "c1r23", \ 821 "c1r24", "c1r25", "c1r26", "c1r27", "c1r28", "c1r29", "c1r30", "c1r31", \ 822 \ 823 "c2r0", "c2r1", "c2r2", "c2r3", "c2r4", "c2r5", "c2r6", "c2r7", \ 824 "c2r8", "c2r9", "c2r10", "c2r11", "c2r12", "c2r13", "c2r14", "c2r15", \ 825 "c2r16", "c2r17", "c2r18", "c2r19", "c2r20", "c2r21", "c2r22", "c2r23", \ 826 "c2r24", "c2r25", "c2r26", "c2r27", "c2r28", "c2r29", "c2r30", "c2r31", \ 827 \ 828 "c3r0", "c3r1", "c3r2", "c3r3", "c3r4", "c3r5", "c3r6", "c3r7", \ 829 "c3r8", "c3r9", "c3r10", "c3r11", "c3r12", "c3r13", "c3r14", "c3r15", \ 830 "c3r16", "c3r17", "c3r18", "c3r19", "c3r20", "c3r21", "c3r22", "c3r23", \ 831 "c3r24", "c3r25", "c3r26", "c3r27", "c3r28", "c3r29", "c3r30", "c3r31", \ 832} 833 834/* Print operand X (an rtx) in assembler syntax to file FILE. */ 835#define PRINT_OPERAND(STREAM, X, CODE) score_print_operand (STREAM, X, CODE) 836 837/* A C expression which evaluates to true if CODE is a valid 838 punctuation character for use in the `PRINT_OPERAND' macro. */ 839#define PRINT_OPERAND_PUNCT_VALID_P(C) ((C) == '[' || (C) == ']') 840 841/* Print a memory address as an operand to reference that memory location. */ 842#define PRINT_OPERAND_ADDRESS(STREAM, X) \ 843 score_print_operand_address (STREAM, X) 844 845/* By default on the S+core, external symbols do not have an underscore 846 prepended. */ 847#define USER_LABEL_PREFIX "" 848 849/* This is how to output an insn to push a register on the stack. */ 850#define ASM_OUTPUT_REG_PUSH(STREAM, REGNO) \ 851 do { \ 852 fprintf (STREAM, "\tpush! %s,[%s]\n", \ 853 reg_names[REGNO], \ 854 reg_names[STACK_POINTER_REGNUM]); \ 855 } while (0) 856 857/* This is how to output an insn to pop a register from the stack. */ 858#define ASM_OUTPUT_REG_POP(STREAM, REGNO) \ 859 do { \ 860 fprintf (STREAM, "\tpop! %s,[%s]\n", \ 861 reg_names[REGNO], \ 862 reg_names[STACK_POINTER_REGNUM]); \ 863 } while (0) 864 865/* Output of Dispatch Tables. */ 866/* This is how to output an element of a case-vector. We can make the 867 entries PC-relative in GP-relative when .gp(d)word is supported. */ 868#define ASM_OUTPUT_ADDR_DIFF_ELT(STREAM, BODY, VALUE, REL) \ 869 do { \ 870 if (flag_pic) \ 871 fprintf (STREAM, "\t.gpword %sL%d\n", LOCAL_LABEL_PREFIX, VALUE); \ 872 else \ 873 fprintf (STREAM, "\t.word %sL%d\n", LOCAL_LABEL_PREFIX, VALUE); \ 874 } while (0) 875 876/* This is how to output an element of a case-vector that is absolute. */ 877#define ASM_OUTPUT_ADDR_VEC_ELT(STREAM, VALUE) \ 878 fprintf (STREAM, "\t.word %sL%d\n", LOCAL_LABEL_PREFIX, VALUE) 879 880/* Assembler Commands for Exception Regions */ 881/* Since the S+core is encoded in the least-significant bit 882 of the address, mask it off return addresses for purposes of 883 finding exception handling regions. */ 884#define MASK_RETURN_ADDR constm1_rtx 885 886/* Assembler Commands for Alignment */ 887/* This is how to output an assembler line to advance the location 888 counter by SIZE bytes. */ 889#undef ASM_OUTPUT_SKIP 890#define ASM_OUTPUT_SKIP(STREAM, SIZE) \ 891 fprintf (STREAM, "\t.space\t"HOST_WIDE_INT_PRINT_UNSIGNED"\n", (SIZE)) 892 893/* This is how to output an assembler line 894 that says to advance the location counter 895 to a multiple of 2**LOG bytes. */ 896#define ASM_OUTPUT_ALIGN(STREAM, LOG) \ 897 fprintf (STREAM, "\t.align\t%d\n", (LOG)) 898 899/* Macros Affecting All Debugging Formats. */ 900#ifndef PREFERRED_DEBUGGING_TYPE 901#define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG 902#endif 903 904/* Specific Options for DBX Output. */ 905#define DBX_DEBUGGING_INFO 1 906 907/* By default, turn on GDB extensions. */ 908#define DEFAULT_GDB_EXTENSIONS 1 909 910#define DBX_CONTIN_LENGTH 0 911 912/* File Names in DBX Format. */ 913#define DWARF2_DEBUGGING_INFO 1 914 915/* The DWARF 2 CFA column which tracks the return address. */ 916#define DWARF_FRAME_RETURN_COLUMN 3 917 918/* Specify the machine mode that this machine uses 919 for the index in the tablejump instruction. */ 920#define CASE_VECTOR_MODE SImode 921 922/* Define if operations between registers always perform the operation 923 on the full register even if a narrower mode is specified. */ 924#define WORD_REGISTER_OPERATIONS 925 926/* All references are zero extended. */ 927#define LOAD_EXTEND_OP(MODE) ZERO_EXTEND 928 929/* Define if loading short immediate values into registers sign extends. */ 930#define SHORT_IMMEDIATES_SIGN_EXTEND 931 932/* Max number of bytes we can move from memory to memory 933 in one reasonably fast instruction. */ 934#define MOVE_MAX 4 935 936/* Define this to be nonzero if shift instructions ignore all but the low-order 937 few bits. */ 938#define SHIFT_COUNT_TRUNCATED 1 939 940/* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits 941 is done just by pretending it is already truncated. */ 942#define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1 943 944/* Specify the machine mode that pointers have. 945 After generation of rtl, the compiler makes no further distinction 946 between pointers and any other objects of this machine mode. */ 947#define Pmode SImode 948 949/* Give call MEMs SImode since it is the "most permissive" mode 950 for 32-bit targets. */ 951#define FUNCTION_MODE Pmode 952 953struct extern_list GTY ((chain_next ("%h.next"))) 954{ 955 struct extern_list *next; /* next external */ 956 const char *name; /* name of the external */ 957 int size; /* size in bytes */ 958}; 959 960extern GTY (()) struct extern_list *extern_head; 961