1 /* Declarations for the C-SKY back end. 2 Copyright (C) 2018-2019 Free Software Foundation, Inc. 3 Contributed by C-SKY Microsystems and Mentor Graphics. 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 22 #ifndef GCC_CSKY_H 23 #define GCC_CSKY_H 24 25 /* In some places e.g. csky_secondary_reload, we use -1 to indicate an 26 invalid register. In other places where N is unsigned the comparison 27 to zero would give an error, so explicitly cast to int here. */ 28 #define CSKY_GENERAL_REGNO_P(N) \ 29 ((N) < CSKY_NGPR_REGS && (int)(N) >= 0) 30 31 #define CSKY_VREG_P(N) \ 32 ((N) >= CSKY_FIRST_VFP_REGNUM && (N) <= CSKY_LAST_VFP_REGNUM) 33 34 #define CSKY_HILO_REG_P(N) \ 35 ((N) == CSKY_HI_REGNUM || (N) == CSKY_LO_REGNUM) 36 37 /* Helper macros for constant constraints and predicates. */ 38 #define CSKY_VALUE_BETWEEN(VALUE, LOW, HIGH) \ 39 ((VALUE) >= (LOW) && (VALUE) <= (HIGH)) 40 41 #define CSKY_CONST_OK_FOR_I(VALUE) \ 42 CSKY_VALUE_BETWEEN (VALUE, 0, 65535) 43 44 #define CSKY_CONST_OK_FOR_J(VALUE) \ 45 CSKY_VALUE_BETWEEN (VALUE, 1, 32) 46 47 #define CSKY_CONST_OK_FOR_K(VALUE) \ 48 CSKY_VALUE_BETWEEN (VALUE, 0, 31) 49 50 #define CSKY_CONST_OK_FOR_L(VALUE) \ 51 CSKY_VALUE_BETWEEN (VALUE, 1, 8) 52 53 #define CSKY_CONST_OK_FOR_M(VALUE) \ 54 CSKY_VALUE_BETWEEN (VALUE, 1, 4096) 55 56 #define CSKY_CONST_OK_FOR_N(VALUE) \ 57 CSKY_VALUE_BETWEEN (VALUE, 1, 256) 58 59 #define CSKY_CONST_OK_FOR_O(VALUE) \ 60 CSKY_VALUE_BETWEEN (VALUE, 0, 4095) 61 62 #define CSKY_CONST_OK_FOR_P(VALUE) \ 63 (((VALUE) & 0x3) == 0 && CSKY_VALUE_BETWEEN (VALUE, 4, 508)) 64 65 #define CSKY_CONST_OK_FOR_T(VALUE) \ 66 CSKY_VALUE_BETWEEN (VALUE, -256, -1) 67 68 #define CSKY_CONST_OK_FOR_Ub(VALUE) \ 69 (exact_log2 (VALUE & 0xFFFFFFFF) >= 0) 70 71 #define CSKY_CONST_OK_FOR_Uc(VALUE) \ 72 ((VALUE) == (HOST_WIDE_INT) -1 \ 73 || (exact_log2 ((VALUE) + 1) >= 0 \ 74 && exact_log2 ((VALUE) + 1) <= 31)) 75 76 #define CSKY_CONST_OK_FOR_Ud(VALUE) \ 77 ((CSKY_CONST_OK_FOR_I ((VALUE) & 0xffffffff) \ 78 || CSKY_CONST_OK_FOR_Ub ((VALUE)) \ 79 || CSKY_CONST_OK_FOR_Uc (((VALUE) << 32) >> 32)) \ 80 && (CSKY_CONST_OK_FOR_I ((VALUE) >> 32) \ 81 || CSKY_CONST_OK_FOR_Ub ((VALUE) >> 32) \ 82 || CSKY_CONST_OK_FOR_Uc ((VALUE) >> 32))) \ 83 84 #define CSKY_CONST_OK_FOR_Ug(VALUE) \ 85 (((VALUE) & 0x3) == 0 && CSKY_VALUE_BETWEEN (VALUE, -508, -4)) 86 87 #define CSKY_CONST_OK_FOR_Uh(VALUE) \ 88 CSKY_VALUE_BETWEEN (VALUE, -31, 0) 89 90 #define CSKY_CONST_OK_FOR_Uj(VALUE) \ 91 (((VALUE) & 0x3) == 0 && CSKY_VALUE_BETWEEN (VALUE, 1, 1024)) 92 93 #define CSKY_CONST_OK_FOR_Uk(VALUE) \ 94 CSKY_VALUE_BETWEEN (VALUE, 1, 65536) 95 96 #define CSKY_CONST_OK_FOR_Ul(VALUE) \ 97 (((VALUE) & 0x3) == 0 && CSKY_VALUE_BETWEEN (VALUE, -1024, -4)) 98 99 #define CSKY_CONST_OK_FOR_Um(VALUE) \ 100 CSKY_VALUE_BETWEEN (VALUE, -4096, -1) 101 102 #define CSKY_CONST_OK_FOR_US(VALUE) \ 103 CSKY_VALUE_BETWEEN (VALUE, -8, -1) 104 105 #define CSKY_CONST_OK_FOR_MOVIH(VALUE) \ 106 (((VALUE) & 0xFFFF) == 0) 107 108 #ifndef TARGET_CPU_DEFAULT 109 #define TARGET_CPU_DEFAULT CSKY_TARGET_CORE_GET(ck810f) 110 #endif 111 112 /* Options that are enabled by default are specified as such in the 113 .opt file. */ 114 #define TARGET_DEFAULT 0 115 116 /* The highest CSKY architecture version supported by the target. */ 117 #define CSKY_TARGET_ARCH(arch) \ 118 (csky_base_arch == CSKY_TARGET_ARCH_GET (arch)) 119 120 /* Define some macros for target code generation options. */ 121 #define TARGET_SOFT_FPU \ 122 (csky_fpu_index == TARGET_FPU_fpv2_sf) 123 #define TARGET_CASESI \ 124 (optimize_size && TARGET_CONSTANT_POOL \ 125 && (CSKY_TARGET_ARCH (CK801) || CSKY_TARGET_ARCH (CK802))) 126 #define TARGET_TLS \ 127 (CSKY_TARGET_ARCH (CK807) || CSKY_TARGET_ARCH (CK810)) 128 129 /* Number of loads/stores handled by ldm/stm. */ 130 #define CSKY_MIN_MULTIPLE_STLD 3 131 #define CSKY_MAX_MULTIPLE_STLD 12 132 133 /* Pull in enums and defines for processor/arch variants. This makes 134 it possible to use CSKY_TARGET_ARCH in macros defined in this file. */ 135 #include "csky_opts.h" 136 extern enum csky_base_architecture csky_base_arch; 137 138 /* Pull in enums and defines for ISA features. Likewise required to 139 support use of CSKY_ISA_FEATURE in this file. 140 Note that the CSKY_ISA_FEATURE macro tests properties of the 141 particular processor we're compiling for, not code generation 142 options that may have dependencies on those features. The latter 143 are handled by TARGET_xxxx macros/variables instead. See csky.opt. */ 144 #include "csky_isa.h" 145 extern int csky_arch_isa_features[]; 146 #define CSKY_ISA_FEATURE(IDENT) \ 147 csky_arch_isa_features[CSKY_ISA_FEATURE_GET (IDENT)] 148 149 /****************************************************************** 150 * Storage Layout * 151 ******************************************************************/ 152 153 154 /* Define this if most significant bit is lowest numbered 155 in instructions that operate on numbered bit-fields. */ 156 #define BITS_BIG_ENDIAN 0 157 158 /* If the most significant byte of a word is the lowest numbered. */ 159 #define BYTES_BIG_ENDIAN (TARGET_BIG_ENDIAN != 0) 160 161 /* If the most significant word of a multiword number is the lowest. */ 162 #define WORDS_BIG_ENDIAN (BYTES_BIG_ENDIAN) 163 164 /* Width of a word, in units (bytes). */ 165 #define UNITS_PER_WORD 4 166 167 /* Define this macro if it is advisable to hold scalars in registers 168 in a wider mode than that declared by the program. In such cases, 169 the value is constrained to be within the bounds of the declared 170 type, but kept valid in the wider mode. The signedness of the 171 extension may differ from that of the type. */ 172 #define PROMOTE_MODE(MODE, UNSIGNEDP, TYPE) \ 173 if (GET_MODE_CLASS (MODE) == MODE_INT \ 174 && GET_MODE_SIZE (MODE) < UNITS_PER_WORD) \ 175 (MODE) = SImode; 176 177 178 /* Allocation boundary (in *bits*) for storing arguments in argument list. */ 179 #define PARM_BOUNDARY 32 180 181 /* Boundary (in *bits*) on which stack pointer should be aligned. 182 Per C-SKY, the published V2 ABI document is incorrect and the proper 183 alignment is on a 4-byte boundary rather than 8 bytes. */ 184 #define STACK_BOUNDARY 32 185 186 /* Align definitions of arrays, unions and structures so that 187 initializations and copies can be made more efficient. This is not 188 ABI-changing, so it only affects places where we can see the 189 definition. Increasing the alignment tends to introduce padding, 190 so don't do this when optimizing for size/conserving stack space. */ 191 #define CSKY_EXPAND_ALIGNMENT(COND, EXP, ALIGN) \ 192 (((COND) && ((ALIGN) < BITS_PER_WORD) \ 193 && (TREE_CODE (EXP) == ARRAY_TYPE \ 194 || TREE_CODE (EXP) == UNION_TYPE \ 195 || TREE_CODE (EXP) == RECORD_TYPE)) \ 196 ? BITS_PER_WORD : (ALIGN)) 197 198 /* Align global data. */ 199 #define DATA_ALIGNMENT(EXP, ALIGN) \ 200 CSKY_EXPAND_ALIGNMENT (!optimize_size, EXP, ALIGN) 201 202 /* Similarly, make sure that objects on the stack are sensibly aligned. */ 203 #define LOCAL_ALIGNMENT(EXP, ALIGN) \ 204 CSKY_EXPAND_ALIGNMENT (!flag_conserve_stack, EXP, ALIGN) 205 206 /* No data type wants to be aligned rounder than this. */ 207 #define BIGGEST_ALIGNMENT 32 208 209 /* Every structures size must be a multiple of 8 bits. */ 210 #define STRUCTURE_SIZE_BOUNDARY 8 211 212 /* Look at the fundamental type that is used for a bit-field and use 213 that to impose alignment on the enclosing structure. 214 struct s {int a:8}; should have same alignment as "int", not "char". */ 215 #define PCC_BITFIELD_TYPE_MATTERS 1 216 217 /* Largest integer machine mode for structures. If undefined, the default 218 is GET_MODE_SIZE(DImode). */ 219 #define MAX_FIXED_MODE_SIZE 64 220 221 /* Allocation boundary (in *bits*) for the code of a function. 222 Optimize ck801 and ck802 a little harder for size. */ 223 #define FUNCTION_BOUNDARY \ 224 (((CSKY_TARGET_ARCH (CK801) || CSKY_TARGET_ARCH (CK802)) \ 225 && optimize_size) \ 226 ? 16 : 32) 227 228 /* C-SKY does not support unaligned access. */ 229 #define STRICT_ALIGNMENT 1 230 231 #undef SIZE_TYPE 232 #define SIZE_TYPE "unsigned int" 233 234 #undef PTRDIFF_TYPE 235 #define PTRDIFF_TYPE "int" 236 237 #undef WCHAR_TYPE 238 #define WCHAR_TYPE "long int" 239 240 #undef UINT_LEAST32_TYPE 241 #define UINT_LEAST32_TYPE "unsigned int" 242 243 #undef INT_LEAST32_TYPE 244 #define INT_LEAST32_TYPE "int" 245 246 #undef WCHAR_TYPE_SIZE 247 #define WCHAR_TYPE_SIZE BITS_PER_WORD 248 249 /****************************************************************** 250 * Layout of Source Language Data Types * 251 ******************************************************************/ 252 253 254 /* 'char' is unsigned by default for backward compatibility. */ 255 #define DEFAULT_SIGNED_CHAR 0 256 257 258 /****************************************************************** 259 * Stack Layout and Calling Conventions * 260 ******************************************************************/ 261 262 263 /* Basic Stack Layout */ 264 265 266 /* Define this if pushing a word on the stack 267 makes the stack pointer a smaller address. */ 268 #define STACK_GROWS_DOWNWARD 1 269 270 /* Define this to nonzero if the nominal address of the stack frame 271 is at the high-address end of the local variables; 272 that is, each additional local variable allocated 273 goes at a more negative offset in the frame. */ 274 #define FRAME_GROWS_DOWNWARD 1 275 276 /* Offset of first parameter from the argument pointer register value. */ 277 #define FIRST_PARM_OFFSET(FNDECL) 0 278 279 /* A C expression whose value is RTL representing the value of the return 280 address for the frame COUNT steps up from the current frame. */ 281 #define RETURN_ADDR_RTX(COUNT, FRAME) \ 282 csky_return_addr (COUNT, FRAME) 283 284 /* Pick up the return address upon entry to a procedure. Used for 285 dwarf2 unwind information. This also enables the table driven 286 mechanism. */ 287 #define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (Pmode, CSKY_LR_REGNUM) 288 289 290 /* Exception Handling Support */ 291 292 /* The register that holds the return address in exception handlers. */ 293 #define EH_RETURN_STACKADJ_RTX gen_rtx_REG (SImode, CSKY_EH_STACKADJ_REGNUM) 294 295 /* Select a format to encode pointers in exception handling data. */ 296 #define ASM_PREFERRED_EH_DATA_FORMAT(CODE, GLOBAL) \ 297 (((GLOBAL) ? DW_EH_PE_indirect : 0) | DW_EH_PE_pcrel | DW_EH_PE_sdata4) 298 299 /* Registers That Address the Stack Frame */ 300 301 302 /* Register to use for pushing function arguments. */ 303 #define STACK_POINTER_REGNUM CSKY_SP_REGNUM 304 305 /* Base register for access to local variables of the function. */ 306 #define FRAME_POINTER_REGNUM 8 307 308 /* Base register for access to arguments of the function. This is a fake 309 register that is always eliminated. */ 310 #define ARG_POINTER_REGNUM 32 311 312 /* Static chain register. 313 Register use is more restricted on CK801. */ 314 #define STATIC_CHAIN_REGNUM (CSKY_TARGET_ARCH (CK801) ? 13 : 12) 315 316 317 /* Eliminating Frame Pointer and Arg Pointer */ 318 319 320 /* Definitions for register eliminations. 321 322 This is an array of structures. Each structure initializes one pair 323 of eliminable registers. The "from" register number is given first, 324 followed by "to". Eliminations of the same "from" register are listed 325 in order of preference. 326 327 We have two registers that can be eliminated on the CSKY. First, the 328 arg pointer register can often be eliminated in favor of the stack 329 pointer register. Secondly, the pseudo frame pointer register can always 330 be eliminated; it is replaced with the stack pointer. */ 331 #define ELIMINABLE_REGS \ 332 {{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM },\ 333 { ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM },\ 334 { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM }} 335 336 /* Define the offset between two registers, one to be eliminated, and the 337 other its replacement, at the start of a routine. */ 338 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \ 339 (OFFSET) = csky_initial_elimination_offset (FROM, TO) 340 341 342 /* Passing Function Arguments on the Stack */ 343 344 345 /* Define this if the maximum size of all the outgoing args is to be 346 accumulated and pushed during the prologue. The amount can be 347 found in the variable crtl->outgoing_args_size. */ 348 #define ACCUMULATE_OUTGOING_ARGS 1 349 350 351 /* Passing Arguments in Registers */ 352 353 354 /* A C type for declaring a variable that is used as the first argument of 355 TARGET_ FUNCTION_ARG and other related values. */ 356 #define CUMULATIVE_ARGS int 357 358 /* Initialize a variable CUM of type CUMULATIVE_ARGS 359 for a call to a function whose data type is FNTYPE. 360 For a library call, FNTYPE is 0. 361 362 On CSKY, the offset always starts at 0: the first parm reg is always 363 the same reg. */ 364 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT, N_NAMED_ARGS) \ 365 ((CUM) = 0) 366 367 /* True if N is a possible register number for function argument passing. 368 On the CSKY, r0-r3 are used to pass args. 369 The int cast is to prevent a complaint about unsigned comparison to 370 zero, since CSKY_FIRST_PARM_REGNUM is zero. */ 371 #define FUNCTION_ARG_REGNO_P(REGNO) \ 372 (((int)(REGNO) >= CSKY_FIRST_PARM_REGNUM) && \ 373 ((REGNO) < (CSKY_NPARM_REGS + CSKY_FIRST_PARM_REGNUM))) 374 375 /* How Large Values Are Returned */ 376 377 378 /* Define DEFAULT_PCC_STRUCT_RETURN to 1 if all structure and union return 379 values must be in memory. On the CSKY, small 380 structures (eight bytes or fewer) are returned in 381 the register pair r0/r1. */ 382 #define DEFAULT_PCC_STRUCT_RETURN 0 383 384 /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function, 385 the stack pointer does not matter. The value is tested only in 386 functions that have frame pointers. 387 No definition is equivalent to always zero. 388 389 On the CSKY, the function epilogue recovers the stack pointer from the 390 frame. */ 391 #define EXIT_IGNORE_STACK 1 392 393 394 /****************************************************************** 395 * Register Usage & Register Classes * 396 ******************************************************************/ 397 398 399 #define FIRST_PSEUDO_REGISTER 71 400 401 /* 1 for registers that have pervasive standard uses 402 and are not available for the register allocator. 403 On C-SKY, r14 is SP, r26 is used by linker, 404 r27 is used by assembler, r28 is data base address, 405 r29 is GOT base address, r30 is handler base address, 406 r31 is TLS register. */ 407 #define FIXED_REGISTERS \ 408 /* r0 r1 r2 r3 r4 r5 r6 r7 */ \ 409 { 0, 0, 0, 0, 0, 0, 0, 0, \ 410 /* r8 r9 r10 r11 r12 r13 r14 r15 */ \ 411 0, 0, 0, 0, 0, 0, 1, 0, \ 412 /* r16 r17 r18 r19 r20 r21 r22 r23 */ \ 413 0, 0, 0, 0, 0, 0, 0, 0, \ 414 /* r24 r25 r26 r27 r28 r29 r30 tls */ \ 415 0, 0, 1, 1, 1, 1, 1, 1, \ 416 /* reserved c hi lo */ \ 417 1, 1, 0, 0, \ 418 /* reserved */ \ 419 1, 1, 1, 1, 1, 1, 1, 1, \ 420 1, 1, 1, 1, 1, 1, 1, 1, \ 421 /* vr0 vr1 vr2 vr3 vr4 vr5 vr6 vr7 */ \ 422 0, 0, 0, 0, 0, 0, 0, 0, \ 423 /* vr8 vr9 vr10 vr11 vr12 vr13 vr14 vr15 */ \ 424 0, 0, 0, 0, 0, 0, 0, 0 , \ 425 /* reserved */ \ 426 1, 1, \ 427 /* epc */ \ 428 1 \ 429 } 430 431 /* 1 for registers that is clobbered (in general) by function calls. 432 If a register has 0, the compiler automatically saves it on 433 function entry and restores it on function exit, if the register 434 is used within the function. */ 435 #define CALL_USED_REGISTERS \ 436 /* r0 r1 r2 r3 r4 r5 r6 r7 */ \ 437 { 1, 1, 1, 1, 0, 0, 0, 0, \ 438 /* r8 r9 r10 r11 r12 r13 r14 r15 */ \ 439 0, 0, 0, 0, 1, 1, 1, 0, \ 440 /* r16 r17 r18 r19 r20 r21 r22 r23 */ \ 441 0, 0, 1, 1, 1, 1, 1, 1, \ 442 /* r24 r25 r26 r27 r28 r29 r30 r31 */ \ 443 1, 1, 1, 1, 1, 1, 1, 1, \ 444 /* reserved c hi lo */ \ 445 1, 1, 1, 1, \ 446 /* reserved */ \ 447 1, 1, 1, 1, 1, 1, 1, 1, \ 448 1, 1, 1, 1, 1, 1, 1, 1, \ 449 /* vr0 vr1 vr2 vr3 vr4 vr5 vr6 vr7 */ \ 450 1, 1, 1, 1, 1, 1, 1, 1, \ 451 /* vr8 vr9 vr10 vr11 vr12 vr13 vr14 vr15 */ \ 452 1, 1, 1, 1, 1, 1, 1, 1, \ 453 /* reserved */ \ 454 1, 1, \ 455 /* epc */ \ 456 1 \ 457 } 458 459 /* Like `CALL_USED_REGISTERS' but used to overcome a historical 460 problem which makes CALL_USED_REGISTERS *always* include 461 all the FIXED_REGISTERS. Until this problem has been 462 resolved this macro can be used to overcome this situation. 463 In particular, block_propagate() requires this list 464 be accurate, or we can remove registers which should be live. 465 This macro is used in get_csky_live_regs(). */ 466 #define CALL_REALLY_USED_REGISTERS \ 467 /* r0 r1 r2 r3 r4 r5 r6 r7 */ \ 468 { 1, 1, 1, 1, 0, 0, 0, 0, \ 469 /* r8 r9 r10 r11 r12 r13 r14 r15 */ \ 470 0, 0, 0, 0, 1, 1, 1, 0, \ 471 /* r16 r17 r18 r19 r20 r21 r22 r23 */ \ 472 0, 0, 1, 1, 1, 1, 1, 1, \ 473 /* r24 r25 r26 r27 r28 r29 r30 r31 */ \ 474 1, 1, 1, 1, 1, 1, 1, 1, \ 475 /* reserved c hi lo */ \ 476 1, 1, 1, 1, \ 477 /* reserved */ \ 478 1, 1, 1, 1, 1, 1, 1, 1, \ 479 1, 1, 1, 1, 1, 1, 1, 1, \ 480 /* vr0 vr1 vr2 vr3 vr4 vr5 vr6 vr7 */ \ 481 1, 1, 1, 1, 1, 1, 1, 1, \ 482 /* vr8 vr9 vr10 vr11 vr12 vr13 vr14 vr15 */ \ 483 1, 1, 1, 1, 1, 1, 1, 1, \ 484 /* reserved */ \ 485 1, 1, \ 486 /* epc */ \ 487 1 \ 488 } 489 490 #define REGISTER_NAMES \ 491 { \ 492 "a0", "a1", "a2", "a3", "l0", "l1", "l2", "l3", \ 493 "l4", "l5", "l6", "l7", "t0", "t1", "sp", "lr", \ 494 "l8", "l9", "t2", "t3", "t4", "t5", "t6", "t7", \ 495 "t8", "t9", "r26", "r27", "gb", "r29", "svbr", "r31", \ 496 /* reserved */ \ 497 "reserved", \ 498 /* CC register: 33 */ \ 499 "c", \ 500 /* DSP instruction register: 34, 35 */ \ 501 "hi", "lo", \ 502 "reserved", "reserved", "reserved", "reserved", "reserved", \ 503 "reserved", "reserved", "reserved", "reserved", "reserved", \ 504 "reserved", "reserved", "reserved", "reserved", "reserved", \ 505 "reserved", \ 506 /* V registers: 52~67 */ \ 507 "vr0", "vr1", "vr2", "vr3", "vr4", "vr5", "vr6", "vr7", \ 508 "vr8", "vr9", "vr10", "vr11", "vr12", "vr13", "vr14", "vr15", \ 509 "reserved", "reserved", \ 510 "epc" \ 511 } 512 513 /* Table of additional register names to use in user input. */ 514 #define ADDITIONAL_REGISTER_NAMES \ 515 { \ 516 {"r0", 0}, \ 517 {"r1", 1}, \ 518 {"r2", 2}, \ 519 {"r3", 3}, \ 520 {"r4", 4}, \ 521 {"r5", 5}, \ 522 {"r6", 6}, \ 523 {"r7", 7}, \ 524 {"r8", 8}, \ 525 {"r9", 9}, \ 526 {"r10", 10}, \ 527 {"r11", 11}, \ 528 {"r12", 12}, \ 529 {"r13", 13}, \ 530 {"r14", 14}, \ 531 {"r15", 15}, \ 532 {"r16", 16}, \ 533 {"r17", 17}, \ 534 {"r18", 18}, \ 535 {"r19", 19}, \ 536 {"r20", 20}, \ 537 {"r21", 21}, \ 538 {"r22", 22}, \ 539 {"r23", 23}, \ 540 {"r24", 24}, \ 541 {"r25", 25}, \ 542 {"r26", 26}, \ 543 {"r27", 27}, \ 544 {"r28", 28}, \ 545 {"r29", 29}, \ 546 {"r30", 30}, \ 547 {"r31", 31}, \ 548 } 549 550 /* The order in which registers should be allocated. 551 It is better to use the registers the caller need not save. 552 Allocate r0 through r3 in reverse order since r3 is least likely 553 to contain a function parameter; in addition results are returned 554 in r0. It is quite good to use lr since other calls may clobber 555 it anyway. */ 556 #define REG_ALLOC_ORDER \ 557 /* r3 r2 r1 r0 r12 r13 r18 r19 */ \ 558 { 3, 2, 1, 0, 12, 13, 18, 19, \ 559 /* r20 r21 r22 r23 r24 r25 */ \ 560 20, 21, 22, 23, 24, 25, \ 561 /* r15 r4 r5 r6 r7 r8 r9 r10 r11 */ \ 562 15, 4, 5, 6, 7, 8, 9, 10, 11, \ 563 /* r16 r17 r26 r27 r28 r29 r30 hi lo */ \ 564 16, 17, 26, 27, 28, 29, 30, 34, 35, \ 565 /* vr0 vr1 vr2 vr3 vr4 vr5 vr6 vr7 */ \ 566 52, 53, 54, 55, 56, 57, 58, 59, \ 567 /* vr8 vr9 vr10 vr11 vr12 vr13 vr14 vr15 */ \ 568 60, 61, 62, 63, 64, 65, 66, 67, \ 569 /* reserved */ \ 570 36, 37, 38, 39, 40, 41, 42, 43, \ 571 44, 45, 46, 47, 48, 49, 50, 51, \ 572 /* sp tls reserved c reserved epc */ \ 573 14, 31, 32, 33, 68, 69, 70 } 574 575 /* Register classes. */ 576 enum reg_class 577 { 578 NO_REGS, 579 MINI_REGS, 580 SP_REGS, 581 LOW_REGS, 582 GENERAL_REGS, 583 C_REGS, 584 HI_REGS, 585 LO_REGS, 586 HILO_REGS, 587 V_REGS, 588 OTHER_REGS, 589 RESERVE_REGS, 590 ALL_REGS, 591 LIM_REG_CLASSES 592 }; 593 594 #define N_REG_CLASSES (int) LIM_REG_CLASSES 595 596 /* Give names of register classes as strings for dump file. */ 597 #define REG_CLASS_NAMES \ 598 { \ 599 "NO_REGS", \ 600 "MINI_REGS", \ 601 "SP_REGS", \ 602 "LOW_REGS", \ 603 "GENERAL_REGS", \ 604 "C_REGS", \ 605 "HI_REGS", \ 606 "LO_REGS", \ 607 "HILO_REGS", \ 608 "V_REGS", \ 609 "OTHER_REGS", \ 610 "RESERVE_REGS", \ 611 "ALL_REGS", \ 612 } 613 614 /* Define which registers fit in which classes. This is an initializer 615 for a vector of HARD_REG_SET of length N_REG_CLASSES. */ 616 #define REG_CLASS_CONTENTS \ 617 { \ 618 {0x00000000, 0x00000000, 0x00000000 }, /* NO_REGS */ \ 619 {0x000000FF, 0x00000000, 0x00000000 }, /* MINI_REGS */ \ 620 {0x00004000, 0x00000000, 0x00000000 }, /* SP_REGS */ \ 621 {0x0000FFFF, 0x00000000, 0x00000000 }, /* LOW_REGS */ \ 622 {0xFFFFFFFF, 0x00000000, 0x00000000 }, /* GENERAL_REGS */ \ 623 {0x00000000, 0x00000002, 0x00000000 }, /* C_REGS */ \ 624 {0x00000000, 0x00000004, 0x00000000 }, /* HI_REG */ \ 625 {0x00000000, 0x00000008, 0x00000000 }, /* LO_REG */ \ 626 {0x00000000, 0x0000000c, 0x00000000 }, /* HILO_REGS */ \ 627 {0x00000000, 0xFFF00000, 0x0000000F }, /* V_REGS */ \ 628 {0x00000000, 0x00000000, 0x00000040 }, /* OTHER_REGS */ \ 629 {0x00000000, 0x0FF00001, 0x00000030 }, /* RESERVE_REGS */ \ 630 {0xFFFFFFFF, 0xFFFFFFFF, 0x0000007F }, /* ALL_REGS */ \ 631 } 632 633 /* Return register class from regno. */ 634 extern enum reg_class regno_reg_class[FIRST_PSEUDO_REGISTER]; 635 #define REGNO_REG_CLASS(REGNO) regno_reg_class[REGNO] 636 637 /* The class value for index registers, and the one for base regs. */ 638 #define INDEX_REG_CLASS (CSKY_ISA_FEATURE (2E3) ? GENERAL_REGS : NO_REGS) 639 #define BASE_REG_CLASS GENERAL_REGS 640 641 /* TODO is it necessary to set it to MINI_REGS to emit more 16-bit 642 instructions? */ 643 #define MODE_BASE_REG_CLASS(MODE) GENERAL_REGS 644 645 /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx 646 and check its validity for a certain class. 647 We have two alternate definitions for each of them. 648 The usual definition accepts all pseudo regs; the other rejects 649 them unless they have been allocated suitable hard regs. 650 The symbol REG_OK_STRICT causes the latter definition to be used. 651 652 Most source files want to accept pseudo regs in the hope that 653 they will get allocated to the class that the insn wants them to be in. 654 Source files for reload pass need to be strict. 655 After reload, it makes no difference, since pseudo regs have 656 been eliminated by then. 657 658 The reg_renumber is used to map pseudo regs into hardware 659 regs, it is set up as a result of register allocation. */ 660 #ifdef REG_OK_STRICT 661 #define REGNO_OK_FOR_BASE_P(REGNO) \ 662 (CSKY_GENERAL_REGNO_P (REGNO) \ 663 || CSKY_GENERAL_REGNO_P (reg_renumber[(REGNO)]) ) 664 #else 665 #define REGNO_OK_FOR_BASE_P(REGNO) \ 666 (CSKY_GENERAL_REGNO_P (REGNO) \ 667 || (REGNO) >= FIRST_PSEUDO_REGISTER) 668 #endif 669 670 671 #ifdef REG_OK_STRICT 672 #define REGNO_OK_FOR_INDEX_P(REGNO) \ 673 (CSKY_GENERAL_REGNO_P (REGNO) \ 674 || CSKY_GENERAL_REGNO_P (reg_renumber[(REGNO)]) ) 675 #else 676 #define REGNO_OK_FOR_INDEX_P(REGNO) \ 677 (CSKY_GENERAL_REGNO_P (REGNO) \ 678 || (REGNO) >= FIRST_PSEUDO_REGISTER) 679 #endif 680 681 682 /****************************************************************** 683 * Addressing Modes * 684 ******************************************************************/ 685 686 687 /* Recognize any constant value that is a valid address. */ 688 #define CONSTANT_ADDRESS_P(X) \ 689 (GET_CODE (X) == LABEL_REF || GET_CODE (X) == SYMBOL_REF) 690 691 /* Maximum number of registers that can appear in a valid memory address. 692 Shifts in addresses can't be by a register. */ 693 #define MAX_REGS_PER_ADDRESS 2 694 695 696 /****************************************************************** 697 * Run-time Target * 698 ******************************************************************/ 699 700 701 #define TARGET_CPU_CPP_BUILTINS() \ 702 csky_cpu_cpp_builtins (pfile) 703 704 /****************************************************************** 705 * Per-function Data * 706 ******************************************************************/ 707 708 709 /* Initialize data used by insn expanders. This is called from insn_emit, 710 once for every function before code is generated. */ 711 #define INIT_EXPANDERS csky_init_expanders () 712 713 714 /****************************************************************** 715 * Dividing the Output into Sections (Texts, Data, . . . ) * 716 ******************************************************************/ 717 718 719 /* Switch to the text or data segment. */ 720 #define TEXT_SECTION_ASM_OP "\t.text" 721 #define DATA_SECTION_ASM_OP "\t.data" 722 723 /* The subroutine calls in the .init and .fini sections create literal 724 pools which must be jumped around... */ 725 #define FORCE_CODE_SECTION_ALIGN \ 726 asm ("br 1f ; .literals ; .align 2 ; 1:"); 727 728 /* Define this macro to be an expression with a nonzero value if 729 jump tables (for tablejump insns) should be output in the text section, 730 along with the assembler instructions. */ 731 #define JUMP_TABLES_IN_TEXT_SECTION TARGET_CASESI 732 733 734 /****************************************************************** 735 * Assembler Format * 736 ******************************************************************/ 737 738 739 /* A C string constant for text to be output before(after) each asm 740 statement or group of consecutive ones. */ 741 #undef ASM_APP_ON 742 #define ASM_APP_ON "// inline asm begin\n" 743 #undef ASM_APP_OFF 744 #define ASM_APP_OFF "// inline asm end\n" 745 746 /* A C string constant describing how to begin a comment in the target 747 assembler language. */ 748 #define ASM_COMMENT_START "\t//" 749 750 /* This says how to output an assembler line 751 to define a global common symbol, with alignment information. */ 752 #undef ASM_OUTPUT_ALIGNED_COMMON 753 #define ASM_OUTPUT_ALIGNED_COMMON(STREAM, NAME, SIZE, ALIGN) \ 754 do \ 755 { \ 756 fputs ("\t.comm\t", STREAM); \ 757 assemble_name (STREAM, NAME); \ 758 fprintf (STREAM, ",%lu, %u\n", (unsigned long)(SIZE), \ 759 (ALIGN) / BITS_PER_UNIT); \ 760 } \ 761 while (0) 762 763 /* Define a local common symbol whose alignment we wish to specify. 764 ALIGN comes in as bits, we have to turn it into bytes. */ 765 #undef ASM_OUTPUT_ALIGNED_LOCAL 766 #define ASM_OUTPUT_ALIGNED_LOCAL(STREAM, NAME, SIZE, ALIGN) \ 767 do \ 768 { \ 769 fputs ("\t.bss\t", (STREAM)); \ 770 assemble_name ((STREAM), (NAME)); \ 771 fprintf ((STREAM), ",%d, %d\n", (int)(SIZE), \ 772 (ALIGN) / BITS_PER_UNIT); \ 773 } \ 774 while (0) 775 776 /* Globalizing directive for a label. */ 777 #define GLOBAL_ASM_OP "\t.global\t" 778 779 /* Output a reference to a label. */ 780 #undef ASM_OUTPUT_LABELREF 781 #define ASM_OUTPUT_LABELREF(STREAM, NAME) \ 782 fprintf (STREAM, "%s%s", user_label_prefix, \ 783 (* targetm.strip_name_encoding) (NAME)) 784 785 /* Make an internal label into a string. */ 786 #undef ASM_GENERATE_INTERNAL_LABEL 787 #define ASM_GENERATE_INTERNAL_LABEL(STRING, PREFIX, NUM) \ 788 sprintf (STRING, "*.%s%ld", PREFIX, (long) NUM) 789 790 /* This is how to output an insn to push a register on the stack. 791 It need not be very fast code. */ 792 #define ASM_OUTPUT_REG_PUSH(STREAM,REGNO) \ 793 fprintf (STREAM, "\tsubi\t %s,%d\n\tst.w\t %s,(%s)\n", \ 794 reg_names[STACK_POINTER_REGNUM], \ 795 (STACK_BOUNDARY / BITS_PER_UNIT), \ 796 reg_names[REGNO], \ 797 reg_names[STACK_POINTER_REGNUM]) 798 799 /* This is how to output an insn to pop a register from the stack. */ 800 #define ASM_OUTPUT_REG_POP(STREAM,REGNO) \ 801 fprintf (STREAM, "\tld.w\t %s,(%s)\n\taddi\t %s,%d\n", \ 802 reg_names[REGNO], \ 803 reg_names[STACK_POINTER_REGNUM], \ 804 reg_names[STACK_POINTER_REGNUM], \ 805 (STACK_BOUNDARY / BITS_PER_UNIT)) 806 807 /* Output an element of a dispatch table. */ 808 #define ASM_OUTPUT_ADDR_VEC_ELT(STREAM,VALUE) \ 809 fprintf (STREAM, "\t.long\t.L%d\n", VALUE) 810 811 /* This is how to output an assembler line 812 that says to advance the location counter by SIZE bytes. */ 813 #undef ASM_OUTPUT_SKIP 814 #define ASM_OUTPUT_SKIP(STREAM,SIZE) \ 815 fprintf (STREAM, "\t.fill %d, 1\n", (int)(SIZE)) 816 817 /* Align output to a power of two. Note ".align 0" is redundant, 818 and also GAS will treat it as ".align 2" which we do not want. */ 819 #define ASM_OUTPUT_ALIGN(STREAM, POWER) \ 820 do \ 821 { \ 822 if ((POWER) > 0) \ 823 fprintf (STREAM, "\t.align\t%d\n", POWER); \ 824 } \ 825 while (0) 826 827 828 /****************************************************************** 829 * Controlling the Compilation Driver * 830 ******************************************************************/ 831 832 833 /* Define this macro as a C expression for the initializer of an 834 array of string to tell the driver program which options are 835 defaults for this target and thus do not need to be handled 836 specially when using MULTILIB_OPTIONS. */ 837 #undef MULTILIB_DEFAULTS 838 #define MULTILIB_DEFAULTS \ 839 {"mlittle-endian", "mcpu=ck810f", "msoft-float"} 840 841 /* Support for a compile-time default CPU, et cetera. The rules are: 842 --with-arch is ignored if -march or -mcpu are specified. 843 --with-cpu is ignored if -march or -mcpu are specified, and is overridden 844 by --with-arch. */ 845 #define OPTION_DEFAULT_SPECS \ 846 {"arch", "%{!march=*:%{!mcpu=*:-march=%(VALUE)}}" }, \ 847 {"cpu", "%{!march=*:%{!mcpu=*:-mcpu=%(VALUE)}}" }, \ 848 {"endian", "%{!mbig-endian:%{!mlittle-endian:-m%(VALUE)-endian}}" }, \ 849 {"float", "%{!msoft-float:%{!mhard-float:-m%(VALUE)-float}}" }, 850 851 852 /****************************************************************** 853 * Position Independent Code * 854 ******************************************************************/ 855 856 /* Define the global table register. */ 857 #define PIC_OFFSET_TABLE_REGNUM (flag_pic ? CSKY_GB_REGNUM : INVALID_REGNUM) 858 859 /* Nonzero if x is a legitimate immediate operand on the target machine 860 when generating position-independent code. */ 861 #define LEGITIMATE_PIC_OPERAND_P(X) \ 862 csky_legitimate_pic_operand_p (X) 863 864 865 /****************************************************************** 866 * Controlling Debugging Information Format * 867 ******************************************************************/ 868 869 870 /* Define this macro if GCC should produce dwarf version 2 format debugging 871 output in response to the `-g' option. */ 872 #define DWARF2_DEBUGGING_INFO 1 873 874 /* Define this macro to 0 if your target supports DWARF 2 frame unwind 875 information, but it does not yet work with exception handling. */ 876 #define DWARF2_UNWIND_INFO 1 877 878 /* Define this if you have arranged for GCC to support 879 more than one format of debugging output. 880 The value of this macro only affects the default debugging output. */ 881 #define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG 882 883 /* Define this macro if the target’s representation 884 for dwarf registers used in .eh_frame or .debug_frame 885 is different from that used in other debug info sections. 886 Given a GCC hard register number, 887 this macro should return the .eh_frame register number.*/ 888 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG) 889 890 /* If INCOMING_RETURN_ADDR_RTX is defined & the RTL is REG, 891 define DWARF_FRAME_RETURN_COLUMN to DWARF_FRAME_REGNUM. */ 892 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (CSKY_LR_REGNUM) 893 894 /* Use r0 and r1 to pass exception handling information. */ 895 #define EH_RETURN_DATA_REGNO(N) ((N) < 2 ? N : INVALID_REGNUM) 896 897 /* How to renumber registers for dbx and gdb. */ 898 extern const int csky_dbx_regno[]; 899 #define DBX_REGISTER_NUMBER(REGNO) ((unsigned int) csky_dbx_regno[REGNO]) 900 901 902 /****************************************************************** 903 * Miscellaneous Parameters * 904 ******************************************************************/ 905 906 907 /* Specify the machine mode that this machine uses 908 for the index in the tablejump instruction. */ 909 #define CASE_VECTOR_MODE SImode 910 911 /* Define if operations between registers always perform the operation 912 on the full register even if a narrower mode is specified. */ 913 #define WORD_REGISTER_OPERATIONS 1 914 915 /* Define if loading in MODE, an integral mode narrower than BITS_PER_WORD 916 will either zero-extend or sign-extend. The value of this macro should 917 be the code that says which one of the two operations is implicitly 918 done, UNKNOWN if none. */ 919 #define LOAD_EXTEND_OP(MODE) ZERO_EXTEND 920 921 /* Max number of bytes we can move from memory to memory 922 in one reasonably fast instruction. */ 923 #define MOVE_MAX 4 924 925 /* Shift counts are truncated to 6-bits (0 to 63) instead of the expected 926 5-bits, so we cannot define SHIFT_COUNT_TRUNCATED to true for this 927 target. */ 928 #define SHIFT_COUNT_TRUNCATED 0 929 930 #define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = 32, 1) 931 932 /* The machine modes of pointers and functions. */ 933 #define Pmode SImode 934 #define FUNCTION_MODE Pmode 935 936 /* Define this macro to be a C expression to indicate when jump-tables 937 should contain relative addresses. */ 938 #define CASE_VECTOR_PC_RELATIVE \ 939 (optimize_size && TARGET_CONSTANT_POOL \ 940 && (CSKY_TARGET_ARCH (CK802) || CSKY_TARGET_ARCH (CK801))) 941 942 /* Return the preferred mode for an addr_diff_vec when the minimum 943 and maximum offset are known. */ 944 #define CASE_VECTOR_SHORTEN_MODE(min, max, body) \ 945 (min >= 0 && max < 512 \ 946 ? (ADDR_DIFF_VEC_FLAGS (body).offset_unsigned = 1, QImode) \ 947 : min >= -256 && max < 256 \ 948 ? (ADDR_DIFF_VEC_FLAGS (body).offset_unsigned = 0, QImode) \ 949 : min >= 0 && max < 8192 \ 950 ? (ADDR_DIFF_VEC_FLAGS (body).offset_unsigned = 1, HImode) \ 951 : min >= -4096 && max < 4096 \ 952 ? (ADDR_DIFF_VEC_FLAGS (body).offset_unsigned = 0, HImode) \ 953 : SImode) 954 955 /* This is how to output an element of a case-vector that is relative. */ 956 #define ASM_OUTPUT_ADDR_DIFF_ELT(STREAM, BODY, VALUE, REL) \ 957 do \ 958 { \ 959 if (optimize_size && TARGET_CONSTANT_POOL \ 960 && (CSKY_TARGET_ARCH (CK802) || CSKY_TARGET_ARCH (CK801))) \ 961 { \ 962 switch (GET_MODE (BODY)) \ 963 { \ 964 case E_QImode: \ 965 asm_fprintf (STREAM, "\t.byte\t(.L%d-.L%d)/2\n", \ 966 VALUE, REL); \ 967 break; \ 968 case E_HImode: /* TBH */ \ 969 asm_fprintf (STREAM, "\t.short\t(.L%d-.L%d)/2\n", \ 970 VALUE, REL); \ 971 break; \ 972 case E_SImode: \ 973 asm_fprintf (STREAM, "\t.long\t.L%d-.L%d\n", \ 974 VALUE, REL); \ 975 break; \ 976 default: \ 977 gcc_unreachable (); \ 978 } \ 979 } \ 980 else \ 981 asm_fprintf (STREAM, "\t.long\t.L%d@GOTOFF\n", VALUE); \ 982 } while (0) 983 984 /* This macro is not documented yet. 985 But we do need it to make jump table vector aligned. */ 986 #define ADDR_VEC_ALIGN(JUMPTABLE) 0 987 988 /* We have to undef this first to override the version from elfos.h. */ 989 #undef ASM_OUTPUT_CASE_LABEL 990 #define ASM_OUTPUT_CASE_LABEL(stream, prefix, num, table) \ 991 do \ 992 { \ 993 if (GET_MODE (PATTERN (table)) == SImode) \ 994 ASM_OUTPUT_ALIGN (stream, 2); \ 995 (*targetm.asm_out.internal_label) (stream, prefix, num); \ 996 } while (0) 997 998 /* Make sure subsequent insns are aligned after a byte-sized jump offset 999 table. */ 1000 #define ASM_OUTPUT_CASE_END(stream, num, table) \ 1001 do \ 1002 { \ 1003 if (GET_MODE (PATTERN (table)) == QImode) \ 1004 ASM_OUTPUT_ALIGN (stream, 1); \ 1005 } while (0) 1006 1007 1008 1009 1010 /****************************************************************** 1011 * Trampolines for Nested Functions * 1012 ******************************************************************/ 1013 1014 1015 /* Length in units of the trampoline for entering a nested function. */ 1016 #define TRAMPOLINE_SIZE (CSKY_ISA_FEATURE (2E3) ? 16 : 20) 1017 1018 /* Alignment required for a trampoline in bits. */ 1019 #define TRAMPOLINE_ALIGNMENT 32 1020 1021 1022 /****************************************************************** 1023 * Describing Relative Costs of Operations * 1024 ******************************************************************/ 1025 1026 1027 /* Nonzero if access to memory by bytes is slow and undesirable. 1028 For RISC chips, it means that access to memory by bytes is no 1029 better than access by words when possible, so grab a whole word 1030 and maybe make use of that. */ 1031 #define SLOW_BYTE_ACCESS 0 1032 1033 /* On C-SKY, function CSE would allow use of 16-bit jsr instructions 1034 instead of normal 32-bit calls. But it also needs a separate constant 1035 pool entry for the function address and an instruction to load it, and 1036 may cause additional spills due to increased register pressure, etc. 1037 It doesn't seem like a good idea overall. */ 1038 #define NO_FUNCTION_CSE 1 1039 1040 /* Try to generate sequences that don't involve branches, we can then use 1041 conditional instructions. */ 1042 #define BRANCH_COST(speed_p, predictable_p) \ 1043 csky_default_branch_cost (speed_p, predictable_p) 1044 1045 /* False if short circuit operation is preferred. */ 1046 #define LOGICAL_OP_NON_SHORT_CIRCUIT \ 1047 (csky_default_logical_op_non_short_circuit ()) 1048 1049 1050 /****************************************************************** 1051 * Generating Code for Profiling * 1052 ******************************************************************/ 1053 1054 1055 #define FUNCTION_PROFILER(FILE, LABELNO) 1056 1057 #endif /* GCC_CSKY_H */ 1058